1 /* 2 * cistpl.c -- 16-bit PCMCIA Card Information Structure parser 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 * 8 * The initial developer of the original code is David A. Hinds 9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 11 * 12 * (C) 1999 David A. Hinds 13 */ 14 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/kernel.h> 18 #include <linux/string.h> 19 #include <linux/major.h> 20 #include <linux/errno.h> 21 #include <linux/timer.h> 22 #include <linux/slab.h> 23 #include <linux/mm.h> 24 #include <linux/pci.h> 25 #include <linux/ioport.h> 26 #include <linux/io.h> 27 #include <asm/byteorder.h> 28 #include <asm/unaligned.h> 29 30 #include <pcmcia/cs_types.h> 31 #include <pcmcia/ss.h> 32 #include <pcmcia/cs.h> 33 #include <pcmcia/cisreg.h> 34 #include <pcmcia/cistpl.h> 35 #include "cs_internal.h" 36 37 static const u_char mantissa[] = { 38 10, 12, 13, 15, 20, 25, 30, 35, 39 40, 45, 50, 55, 60, 70, 80, 90 40 }; 41 42 static const u_int exponent[] = { 43 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000 44 }; 45 46 /* Convert an extended speed byte to a time in nanoseconds */ 47 #define SPEED_CVT(v) \ 48 (mantissa[(((v)>>3)&15)-1] * exponent[(v)&7] / 10) 49 /* Convert a power byte to a current in 0.1 microamps */ 50 #define POWER_CVT(v) \ 51 (mantissa[((v)>>3)&15] * exponent[(v)&7] / 10) 52 #define POWER_SCALE(v) (exponent[(v)&7]) 53 54 /* Upper limit on reasonable # of tuples */ 55 #define MAX_TUPLES 200 56 57 /*====================================================================*/ 58 59 /* Parameters that can be set with 'insmod' */ 60 61 /* 16-bit CIS? */ 62 static int cis_width; 63 module_param(cis_width, int, 0444); 64 65 void release_cis_mem(struct pcmcia_socket *s) 66 { 67 if (s->cis_mem.flags & MAP_ACTIVE) { 68 s->cis_mem.flags &= ~MAP_ACTIVE; 69 s->ops->set_mem_map(s, &s->cis_mem); 70 if (s->cis_mem.res) { 71 release_resource(s->cis_mem.res); 72 kfree(s->cis_mem.res); 73 s->cis_mem.res = NULL; 74 } 75 iounmap(s->cis_virt); 76 s->cis_virt = NULL; 77 } 78 } 79 EXPORT_SYMBOL(release_cis_mem); 80 81 /* 82 * Map the card memory at "card_offset" into virtual space. 83 * If flags & MAP_ATTRIB, map the attribute space, otherwise 84 * map the memory space. 85 */ 86 static void __iomem * 87 set_cis_map(struct pcmcia_socket *s, unsigned int card_offset, unsigned int flags) 88 { 89 pccard_mem_map *mem = &s->cis_mem; 90 int ret; 91 92 if (!(s->features & SS_CAP_STATIC_MAP) && (mem->res == NULL)) { 93 mem->res = pcmcia_find_mem_region(0, s->map_size, s->map_size, 0, s); 94 if (mem->res == NULL) { 95 dev_printk(KERN_NOTICE, &s->dev, 96 "cs: unable to map card memory!\n"); 97 return NULL; 98 } 99 s->cis_virt = NULL; 100 } 101 102 if (!(s->features & SS_CAP_STATIC_MAP) && (!s->cis_virt)) 103 s->cis_virt = ioremap(mem->res->start, s->map_size); 104 105 mem->card_start = card_offset; 106 mem->flags = flags; 107 108 ret = s->ops->set_mem_map(s, mem); 109 if (ret) { 110 iounmap(s->cis_virt); 111 s->cis_virt = NULL; 112 return NULL; 113 } 114 115 if (s->features & SS_CAP_STATIC_MAP) { 116 if (s->cis_virt) 117 iounmap(s->cis_virt); 118 s->cis_virt = ioremap(mem->static_start, s->map_size); 119 } 120 121 return s->cis_virt; 122 } 123 124 /*====================================================================== 125 126 Low-level functions to read and write CIS memory. I think the 127 write routine is only useful for writing one-byte registers. 128 129 ======================================================================*/ 130 131 /* Bits in attr field */ 132 #define IS_ATTR 1 133 #define IS_INDIRECT 8 134 135 int pcmcia_read_cis_mem(struct pcmcia_socket *s, int attr, u_int addr, 136 u_int len, void *ptr) 137 { 138 void __iomem *sys, *end; 139 unsigned char *buf = ptr; 140 141 dev_dbg(&s->dev, "pcmcia_read_cis_mem(%d, %#x, %u)\n", attr, addr, len); 142 143 if (attr & IS_INDIRECT) { 144 /* Indirect accesses use a bunch of special registers at fixed 145 locations in common memory */ 146 u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN; 147 if (attr & IS_ATTR) { 148 addr *= 2; 149 flags = ICTRL0_AUTOINC; 150 } 151 152 sys = set_cis_map(s, 0, MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0)); 153 if (!sys) { 154 memset(ptr, 0xff, len); 155 return -1; 156 } 157 158 writeb(flags, sys+CISREG_ICTRL0); 159 writeb(addr & 0xff, sys+CISREG_IADDR0); 160 writeb((addr>>8) & 0xff, sys+CISREG_IADDR1); 161 writeb((addr>>16) & 0xff, sys+CISREG_IADDR2); 162 writeb((addr>>24) & 0xff, sys+CISREG_IADDR3); 163 for ( ; len > 0; len--, buf++) 164 *buf = readb(sys+CISREG_IDATA0); 165 } else { 166 u_int inc = 1, card_offset, flags; 167 168 flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0); 169 if (attr) { 170 flags |= MAP_ATTRIB; 171 inc++; 172 addr *= 2; 173 } 174 175 card_offset = addr & ~(s->map_size-1); 176 while (len) { 177 sys = set_cis_map(s, card_offset, flags); 178 if (!sys) { 179 memset(ptr, 0xff, len); 180 return -1; 181 } 182 end = sys + s->map_size; 183 sys = sys + (addr & (s->map_size-1)); 184 for ( ; len > 0; len--, buf++, sys += inc) { 185 if (sys == end) 186 break; 187 *buf = readb(sys); 188 } 189 card_offset += s->map_size; 190 addr = 0; 191 } 192 } 193 dev_dbg(&s->dev, " %#2.2x %#2.2x %#2.2x %#2.2x ...\n", 194 *(u_char *)(ptr+0), *(u_char *)(ptr+1), 195 *(u_char *)(ptr+2), *(u_char *)(ptr+3)); 196 return 0; 197 } 198 EXPORT_SYMBOL(pcmcia_read_cis_mem); 199 200 201 void pcmcia_write_cis_mem(struct pcmcia_socket *s, int attr, u_int addr, 202 u_int len, void *ptr) 203 { 204 void __iomem *sys, *end; 205 unsigned char *buf = ptr; 206 207 dev_dbg(&s->dev, "pcmcia_write_cis_mem(%d, %#x, %u)\n", attr, addr, len); 208 209 if (attr & IS_INDIRECT) { 210 /* Indirect accesses use a bunch of special registers at fixed 211 locations in common memory */ 212 u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN; 213 if (attr & IS_ATTR) { 214 addr *= 2; 215 flags = ICTRL0_AUTOINC; 216 } 217 218 sys = set_cis_map(s, 0, MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0)); 219 if (!sys) 220 return; /* FIXME: Error */ 221 222 writeb(flags, sys+CISREG_ICTRL0); 223 writeb(addr & 0xff, sys+CISREG_IADDR0); 224 writeb((addr>>8) & 0xff, sys+CISREG_IADDR1); 225 writeb((addr>>16) & 0xff, sys+CISREG_IADDR2); 226 writeb((addr>>24) & 0xff, sys+CISREG_IADDR3); 227 for ( ; len > 0; len--, buf++) 228 writeb(*buf, sys+CISREG_IDATA0); 229 } else { 230 u_int inc = 1, card_offset, flags; 231 232 flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0); 233 if (attr & IS_ATTR) { 234 flags |= MAP_ATTRIB; 235 inc++; 236 addr *= 2; 237 } 238 239 card_offset = addr & ~(s->map_size-1); 240 while (len) { 241 sys = set_cis_map(s, card_offset, flags); 242 if (!sys) 243 return; /* FIXME: error */ 244 245 end = sys + s->map_size; 246 sys = sys + (addr & (s->map_size-1)); 247 for ( ; len > 0; len--, buf++, sys += inc) { 248 if (sys == end) 249 break; 250 writeb(*buf, sys); 251 } 252 card_offset += s->map_size; 253 addr = 0; 254 } 255 } 256 } 257 EXPORT_SYMBOL(pcmcia_write_cis_mem); 258 259 260 /*====================================================================== 261 262 This is a wrapper around read_cis_mem, with the same interface, 263 but which caches information, for cards whose CIS may not be 264 readable all the time. 265 266 ======================================================================*/ 267 268 static void read_cis_cache(struct pcmcia_socket *s, int attr, u_int addr, 269 size_t len, void *ptr) 270 { 271 struct cis_cache_entry *cis; 272 int ret; 273 274 if (s->fake_cis) { 275 if (s->fake_cis_len >= addr+len) 276 memcpy(ptr, s->fake_cis+addr, len); 277 else 278 memset(ptr, 0xff, len); 279 return; 280 } 281 282 list_for_each_entry(cis, &s->cis_cache, node) { 283 if (cis->addr == addr && cis->len == len && cis->attr == attr) { 284 memcpy(ptr, cis->cache, len); 285 return; 286 } 287 } 288 289 #ifdef CONFIG_CARDBUS 290 if (s->state & SOCKET_CARDBUS) 291 ret = read_cb_mem(s, attr, addr, len, ptr); 292 else 293 #endif 294 ret = pcmcia_read_cis_mem(s, attr, addr, len, ptr); 295 296 if (ret == 0) { 297 /* Copy data into the cache */ 298 cis = kmalloc(sizeof(struct cis_cache_entry) + len, GFP_KERNEL); 299 if (cis) { 300 cis->addr = addr; 301 cis->len = len; 302 cis->attr = attr; 303 memcpy(cis->cache, ptr, len); 304 list_add(&cis->node, &s->cis_cache); 305 } 306 } 307 } 308 309 static void 310 remove_cis_cache(struct pcmcia_socket *s, int attr, u_int addr, u_int len) 311 { 312 struct cis_cache_entry *cis; 313 314 list_for_each_entry(cis, &s->cis_cache, node) 315 if (cis->addr == addr && cis->len == len && cis->attr == attr) { 316 list_del(&cis->node); 317 kfree(cis); 318 break; 319 } 320 } 321 322 void destroy_cis_cache(struct pcmcia_socket *s) 323 { 324 struct list_head *l, *n; 325 326 list_for_each_safe(l, n, &s->cis_cache) { 327 struct cis_cache_entry *cis = list_entry(l, struct cis_cache_entry, node); 328 329 list_del(&cis->node); 330 kfree(cis); 331 } 332 333 /* 334 * If there was a fake CIS, destroy that as well. 335 */ 336 kfree(s->fake_cis); 337 s->fake_cis = NULL; 338 } 339 EXPORT_SYMBOL(destroy_cis_cache); 340 341 /*====================================================================== 342 343 This verifies if the CIS of a card matches what is in the CIS 344 cache. 345 346 ======================================================================*/ 347 348 int verify_cis_cache(struct pcmcia_socket *s) 349 { 350 struct cis_cache_entry *cis; 351 char *buf; 352 353 buf = kmalloc(256, GFP_KERNEL); 354 if (buf == NULL) { 355 dev_printk(KERN_WARNING, &s->dev, 356 "no memory for verifying CIS\n"); 357 return -ENOMEM; 358 } 359 list_for_each_entry(cis, &s->cis_cache, node) { 360 int len = cis->len; 361 362 if (len > 256) 363 len = 256; 364 #ifdef CONFIG_CARDBUS 365 if (s->state & SOCKET_CARDBUS) 366 read_cb_mem(s, cis->attr, cis->addr, len, buf); 367 else 368 #endif 369 pcmcia_read_cis_mem(s, cis->attr, cis->addr, len, buf); 370 371 if (memcmp(buf, cis->cache, len) != 0) { 372 kfree(buf); 373 return -1; 374 } 375 } 376 kfree(buf); 377 return 0; 378 } 379 380 /*====================================================================== 381 382 For really bad cards, we provide a facility for uploading a 383 replacement CIS. 384 385 ======================================================================*/ 386 387 int pcmcia_replace_cis(struct pcmcia_socket *s, 388 const u8 *data, const size_t len) 389 { 390 if (len > CISTPL_MAX_CIS_SIZE) { 391 dev_printk(KERN_WARNING, &s->dev, "replacement CIS too big\n"); 392 return -EINVAL; 393 } 394 kfree(s->fake_cis); 395 s->fake_cis = kmalloc(len, GFP_KERNEL); 396 if (s->fake_cis == NULL) { 397 dev_printk(KERN_WARNING, &s->dev, "no memory to replace CIS\n"); 398 return -ENOMEM; 399 } 400 s->fake_cis_len = len; 401 memcpy(s->fake_cis, data, len); 402 return 0; 403 } 404 EXPORT_SYMBOL(pcmcia_replace_cis); 405 406 /*====================================================================== 407 408 The high-level CIS tuple services 409 410 ======================================================================*/ 411 412 typedef struct tuple_flags { 413 u_int link_space:4; 414 u_int has_link:1; 415 u_int mfc_fn:3; 416 u_int space:4; 417 } tuple_flags; 418 419 #define LINK_SPACE(f) (((tuple_flags *)(&(f)))->link_space) 420 #define HAS_LINK(f) (((tuple_flags *)(&(f)))->has_link) 421 #define MFC_FN(f) (((tuple_flags *)(&(f)))->mfc_fn) 422 #define SPACE(f) (((tuple_flags *)(&(f)))->space) 423 424 int pccard_get_first_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple) 425 { 426 if (!s) 427 return -EINVAL; 428 if (!(s->state & SOCKET_PRESENT)) 429 return -ENODEV; 430 tuple->TupleLink = tuple->Flags = 0; 431 #ifdef CONFIG_CARDBUS 432 if (s->state & SOCKET_CARDBUS) { 433 struct pci_dev *dev = s->cb_dev; 434 u_int ptr; 435 pci_bus_read_config_dword(dev->subordinate, 0, PCI_CARDBUS_CIS, &ptr); 436 tuple->CISOffset = ptr & ~7; 437 SPACE(tuple->Flags) = (ptr & 7); 438 } else 439 #endif 440 { 441 /* Assume presence of a LONGLINK_C to address 0 */ 442 tuple->CISOffset = tuple->LinkOffset = 0; 443 SPACE(tuple->Flags) = HAS_LINK(tuple->Flags) = 1; 444 } 445 if (!(s->state & SOCKET_CARDBUS) && (s->functions > 1) && 446 !(tuple->Attributes & TUPLE_RETURN_COMMON)) { 447 cisdata_t req = tuple->DesiredTuple; 448 tuple->DesiredTuple = CISTPL_LONGLINK_MFC; 449 if (pccard_get_next_tuple(s, function, tuple) == 0) { 450 tuple->DesiredTuple = CISTPL_LINKTARGET; 451 if (pccard_get_next_tuple(s, function, tuple) != 0) 452 return -ENOSPC; 453 } else 454 tuple->CISOffset = tuple->TupleLink = 0; 455 tuple->DesiredTuple = req; 456 } 457 return pccard_get_next_tuple(s, function, tuple); 458 } 459 EXPORT_SYMBOL(pccard_get_first_tuple); 460 461 static int follow_link(struct pcmcia_socket *s, tuple_t *tuple) 462 { 463 u_char link[5]; 464 u_int ofs; 465 466 if (MFC_FN(tuple->Flags)) { 467 /* Get indirect link from the MFC tuple */ 468 read_cis_cache(s, LINK_SPACE(tuple->Flags), 469 tuple->LinkOffset, 5, link); 470 ofs = get_unaligned_le32(link + 1); 471 SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR); 472 /* Move to the next indirect link */ 473 tuple->LinkOffset += 5; 474 MFC_FN(tuple->Flags)--; 475 } else if (HAS_LINK(tuple->Flags)) { 476 ofs = tuple->LinkOffset; 477 SPACE(tuple->Flags) = LINK_SPACE(tuple->Flags); 478 HAS_LINK(tuple->Flags) = 0; 479 } else { 480 return -1; 481 } 482 if (!(s->state & SOCKET_CARDBUS) && SPACE(tuple->Flags)) { 483 /* This is ugly, but a common CIS error is to code the long 484 link offset incorrectly, so we check the right spot... */ 485 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link); 486 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) && 487 (strncmp(link+2, "CIS", 3) == 0)) 488 return ofs; 489 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5); 490 /* Then, we try the wrong spot... */ 491 ofs = ofs >> 1; 492 } 493 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link); 494 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) && 495 (strncmp(link+2, "CIS", 3) == 0)) 496 return ofs; 497 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5); 498 return -1; 499 } 500 501 int pccard_get_next_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple) 502 { 503 u_char link[2], tmp; 504 int ofs, i, attr; 505 506 if (!s) 507 return -EINVAL; 508 if (!(s->state & SOCKET_PRESENT)) 509 return -ENODEV; 510 511 link[1] = tuple->TupleLink; 512 ofs = tuple->CISOffset + tuple->TupleLink; 513 attr = SPACE(tuple->Flags); 514 515 for (i = 0; i < MAX_TUPLES; i++) { 516 if (link[1] == 0xff) { 517 link[0] = CISTPL_END; 518 } else { 519 read_cis_cache(s, attr, ofs, 2, link); 520 if (link[0] == CISTPL_NULL) { 521 ofs++; continue; 522 } 523 } 524 525 /* End of chain? Follow long link if possible */ 526 if (link[0] == CISTPL_END) { 527 ofs = follow_link(s, tuple); 528 if (ofs < 0) 529 return -ENOSPC; 530 attr = SPACE(tuple->Flags); 531 read_cis_cache(s, attr, ofs, 2, link); 532 } 533 534 /* Is this a link tuple? Make a note of it */ 535 if ((link[0] == CISTPL_LONGLINK_A) || 536 (link[0] == CISTPL_LONGLINK_C) || 537 (link[0] == CISTPL_LONGLINK_MFC) || 538 (link[0] == CISTPL_LINKTARGET) || 539 (link[0] == CISTPL_INDIRECT) || 540 (link[0] == CISTPL_NO_LINK)) { 541 switch (link[0]) { 542 case CISTPL_LONGLINK_A: 543 HAS_LINK(tuple->Flags) = 1; 544 LINK_SPACE(tuple->Flags) = attr | IS_ATTR; 545 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset); 546 break; 547 case CISTPL_LONGLINK_C: 548 HAS_LINK(tuple->Flags) = 1; 549 LINK_SPACE(tuple->Flags) = attr & ~IS_ATTR; 550 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset); 551 break; 552 case CISTPL_INDIRECT: 553 HAS_LINK(tuple->Flags) = 1; 554 LINK_SPACE(tuple->Flags) = IS_ATTR | IS_INDIRECT; 555 tuple->LinkOffset = 0; 556 break; 557 case CISTPL_LONGLINK_MFC: 558 tuple->LinkOffset = ofs + 3; 559 LINK_SPACE(tuple->Flags) = attr; 560 if (function == BIND_FN_ALL) { 561 /* Follow all the MFC links */ 562 read_cis_cache(s, attr, ofs+2, 1, &tmp); 563 MFC_FN(tuple->Flags) = tmp; 564 } else { 565 /* Follow exactly one of the links */ 566 MFC_FN(tuple->Flags) = 1; 567 tuple->LinkOffset += function * 5; 568 } 569 break; 570 case CISTPL_NO_LINK: 571 HAS_LINK(tuple->Flags) = 0; 572 break; 573 } 574 if ((tuple->Attributes & TUPLE_RETURN_LINK) && 575 (tuple->DesiredTuple == RETURN_FIRST_TUPLE)) 576 break; 577 } else 578 if (tuple->DesiredTuple == RETURN_FIRST_TUPLE) 579 break; 580 581 if (link[0] == tuple->DesiredTuple) 582 break; 583 ofs += link[1] + 2; 584 } 585 if (i == MAX_TUPLES) { 586 dev_dbg(&s->dev, "cs: overrun in pcmcia_get_next_tuple\n"); 587 return -ENOSPC; 588 } 589 590 tuple->TupleCode = link[0]; 591 tuple->TupleLink = link[1]; 592 tuple->CISOffset = ofs + 2; 593 return 0; 594 } 595 EXPORT_SYMBOL(pccard_get_next_tuple); 596 597 /*====================================================================*/ 598 599 #define _MIN(a, b) (((a) < (b)) ? (a) : (b)) 600 601 int pccard_get_tuple_data(struct pcmcia_socket *s, tuple_t *tuple) 602 { 603 u_int len; 604 605 if (!s) 606 return -EINVAL; 607 608 if (tuple->TupleLink < tuple->TupleOffset) 609 return -ENOSPC; 610 len = tuple->TupleLink - tuple->TupleOffset; 611 tuple->TupleDataLen = tuple->TupleLink; 612 if (len == 0) 613 return 0; 614 read_cis_cache(s, SPACE(tuple->Flags), 615 tuple->CISOffset + tuple->TupleOffset, 616 _MIN(len, tuple->TupleDataMax), tuple->TupleData); 617 return 0; 618 } 619 EXPORT_SYMBOL(pccard_get_tuple_data); 620 621 622 /*====================================================================== 623 624 Parsing routines for individual tuples 625 626 ======================================================================*/ 627 628 static int parse_device(tuple_t *tuple, cistpl_device_t *device) 629 { 630 int i; 631 u_char scale; 632 u_char *p, *q; 633 634 p = (u_char *)tuple->TupleData; 635 q = p + tuple->TupleDataLen; 636 637 device->ndev = 0; 638 for (i = 0; i < CISTPL_MAX_DEVICES; i++) { 639 640 if (*p == 0xff) 641 break; 642 device->dev[i].type = (*p >> 4); 643 device->dev[i].wp = (*p & 0x08) ? 1 : 0; 644 switch (*p & 0x07) { 645 case 0: 646 device->dev[i].speed = 0; 647 break; 648 case 1: 649 device->dev[i].speed = 250; 650 break; 651 case 2: 652 device->dev[i].speed = 200; 653 break; 654 case 3: 655 device->dev[i].speed = 150; 656 break; 657 case 4: 658 device->dev[i].speed = 100; 659 break; 660 case 7: 661 if (++p == q) 662 return -EINVAL; 663 device->dev[i].speed = SPEED_CVT(*p); 664 while (*p & 0x80) 665 if (++p == q) 666 return -EINVAL; 667 break; 668 default: 669 return -EINVAL; 670 } 671 672 if (++p == q) 673 return -EINVAL; 674 if (*p == 0xff) 675 break; 676 scale = *p & 7; 677 if (scale == 7) 678 return -EINVAL; 679 device->dev[i].size = ((*p >> 3) + 1) * (512 << (scale*2)); 680 device->ndev++; 681 if (++p == q) 682 break; 683 } 684 685 return 0; 686 } 687 688 /*====================================================================*/ 689 690 static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum) 691 { 692 u_char *p; 693 if (tuple->TupleDataLen < 5) 694 return -EINVAL; 695 p = (u_char *) tuple->TupleData; 696 csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2; 697 csum->len = get_unaligned_le16(p + 2); 698 csum->sum = *(p + 4); 699 return 0; 700 } 701 702 /*====================================================================*/ 703 704 static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link) 705 { 706 if (tuple->TupleDataLen < 4) 707 return -EINVAL; 708 link->addr = get_unaligned_le32(tuple->TupleData); 709 return 0; 710 } 711 712 /*====================================================================*/ 713 714 static int parse_longlink_mfc(tuple_t *tuple, 715 cistpl_longlink_mfc_t *link) 716 { 717 u_char *p; 718 int i; 719 720 p = (u_char *)tuple->TupleData; 721 722 link->nfn = *p; p++; 723 if (tuple->TupleDataLen <= link->nfn*5) 724 return -EINVAL; 725 for (i = 0; i < link->nfn; i++) { 726 link->fn[i].space = *p; p++; 727 link->fn[i].addr = get_unaligned_le32(p); 728 p += 4; 729 } 730 return 0; 731 } 732 733 /*====================================================================*/ 734 735 static int parse_strings(u_char *p, u_char *q, int max, 736 char *s, u_char *ofs, u_char *found) 737 { 738 int i, j, ns; 739 740 if (p == q) 741 return -EINVAL; 742 ns = 0; j = 0; 743 for (i = 0; i < max; i++) { 744 if (*p == 0xff) 745 break; 746 ofs[i] = j; 747 ns++; 748 for (;;) { 749 s[j++] = (*p == 0xff) ? '\0' : *p; 750 if ((*p == '\0') || (*p == 0xff)) 751 break; 752 if (++p == q) 753 return -EINVAL; 754 } 755 if ((*p == 0xff) || (++p == q)) 756 break; 757 } 758 if (found) { 759 *found = ns; 760 return 0; 761 } else { 762 return (ns == max) ? 0 : -EINVAL; 763 } 764 } 765 766 /*====================================================================*/ 767 768 static int parse_vers_1(tuple_t *tuple, cistpl_vers_1_t *vers_1) 769 { 770 u_char *p, *q; 771 772 p = (u_char *)tuple->TupleData; 773 q = p + tuple->TupleDataLen; 774 775 vers_1->major = *p; p++; 776 vers_1->minor = *p; p++; 777 if (p >= q) 778 return -EINVAL; 779 780 return parse_strings(p, q, CISTPL_VERS_1_MAX_PROD_STRINGS, 781 vers_1->str, vers_1->ofs, &vers_1->ns); 782 } 783 784 /*====================================================================*/ 785 786 static int parse_altstr(tuple_t *tuple, cistpl_altstr_t *altstr) 787 { 788 u_char *p, *q; 789 790 p = (u_char *)tuple->TupleData; 791 q = p + tuple->TupleDataLen; 792 793 return parse_strings(p, q, CISTPL_MAX_ALTSTR_STRINGS, 794 altstr->str, altstr->ofs, &altstr->ns); 795 } 796 797 /*====================================================================*/ 798 799 static int parse_jedec(tuple_t *tuple, cistpl_jedec_t *jedec) 800 { 801 u_char *p, *q; 802 int nid; 803 804 p = (u_char *)tuple->TupleData; 805 q = p + tuple->TupleDataLen; 806 807 for (nid = 0; nid < CISTPL_MAX_DEVICES; nid++) { 808 if (p > q-2) 809 break; 810 jedec->id[nid].mfr = p[0]; 811 jedec->id[nid].info = p[1]; 812 p += 2; 813 } 814 jedec->nid = nid; 815 return 0; 816 } 817 818 /*====================================================================*/ 819 820 static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m) 821 { 822 if (tuple->TupleDataLen < 4) 823 return -EINVAL; 824 m->manf = get_unaligned_le16(tuple->TupleData); 825 m->card = get_unaligned_le16(tuple->TupleData + 2); 826 return 0; 827 } 828 829 /*====================================================================*/ 830 831 static int parse_funcid(tuple_t *tuple, cistpl_funcid_t *f) 832 { 833 u_char *p; 834 if (tuple->TupleDataLen < 2) 835 return -EINVAL; 836 p = (u_char *)tuple->TupleData; 837 f->func = p[0]; 838 f->sysinit = p[1]; 839 return 0; 840 } 841 842 /*====================================================================*/ 843 844 static int parse_funce(tuple_t *tuple, cistpl_funce_t *f) 845 { 846 u_char *p; 847 int i; 848 if (tuple->TupleDataLen < 1) 849 return -EINVAL; 850 p = (u_char *)tuple->TupleData; 851 f->type = p[0]; 852 for (i = 1; i < tuple->TupleDataLen; i++) 853 f->data[i-1] = p[i]; 854 return 0; 855 } 856 857 /*====================================================================*/ 858 859 static int parse_config(tuple_t *tuple, cistpl_config_t *config) 860 { 861 int rasz, rmsz, i; 862 u_char *p; 863 864 p = (u_char *)tuple->TupleData; 865 rasz = *p & 0x03; 866 rmsz = (*p & 0x3c) >> 2; 867 if (tuple->TupleDataLen < rasz+rmsz+4) 868 return -EINVAL; 869 config->last_idx = *(++p); 870 p++; 871 config->base = 0; 872 for (i = 0; i <= rasz; i++) 873 config->base += p[i] << (8*i); 874 p += rasz+1; 875 for (i = 0; i < 4; i++) 876 config->rmask[i] = 0; 877 for (i = 0; i <= rmsz; i++) 878 config->rmask[i>>2] += p[i] << (8*(i%4)); 879 config->subtuples = tuple->TupleDataLen - (rasz+rmsz+4); 880 return 0; 881 } 882 883 /*====================================================================== 884 885 The following routines are all used to parse the nightmarish 886 config table entries. 887 888 ======================================================================*/ 889 890 static u_char *parse_power(u_char *p, u_char *q, 891 cistpl_power_t *pwr) 892 { 893 int i; 894 u_int scale; 895 896 if (p == q) 897 return NULL; 898 pwr->present = *p; 899 pwr->flags = 0; 900 p++; 901 for (i = 0; i < 7; i++) 902 if (pwr->present & (1<<i)) { 903 if (p == q) 904 return NULL; 905 pwr->param[i] = POWER_CVT(*p); 906 scale = POWER_SCALE(*p); 907 while (*p & 0x80) { 908 if (++p == q) 909 return NULL; 910 if ((*p & 0x7f) < 100) 911 pwr->param[i] += (*p & 0x7f) * scale / 100; 912 else if (*p == 0x7d) 913 pwr->flags |= CISTPL_POWER_HIGHZ_OK; 914 else if (*p == 0x7e) 915 pwr->param[i] = 0; 916 else if (*p == 0x7f) 917 pwr->flags |= CISTPL_POWER_HIGHZ_REQ; 918 else 919 return NULL; 920 } 921 p++; 922 } 923 return p; 924 } 925 926 /*====================================================================*/ 927 928 static u_char *parse_timing(u_char *p, u_char *q, 929 cistpl_timing_t *timing) 930 { 931 u_char scale; 932 933 if (p == q) 934 return NULL; 935 scale = *p; 936 if ((scale & 3) != 3) { 937 if (++p == q) 938 return NULL; 939 timing->wait = SPEED_CVT(*p); 940 timing->waitscale = exponent[scale & 3]; 941 } else 942 timing->wait = 0; 943 scale >>= 2; 944 if ((scale & 7) != 7) { 945 if (++p == q) 946 return NULL; 947 timing->ready = SPEED_CVT(*p); 948 timing->rdyscale = exponent[scale & 7]; 949 } else 950 timing->ready = 0; 951 scale >>= 3; 952 if (scale != 7) { 953 if (++p == q) 954 return NULL; 955 timing->reserved = SPEED_CVT(*p); 956 timing->rsvscale = exponent[scale]; 957 } else 958 timing->reserved = 0; 959 p++; 960 return p; 961 } 962 963 /*====================================================================*/ 964 965 static u_char *parse_io(u_char *p, u_char *q, cistpl_io_t *io) 966 { 967 int i, j, bsz, lsz; 968 969 if (p == q) 970 return NULL; 971 io->flags = *p; 972 973 if (!(*p & 0x80)) { 974 io->nwin = 1; 975 io->win[0].base = 0; 976 io->win[0].len = (1 << (io->flags & CISTPL_IO_LINES_MASK)); 977 return p+1; 978 } 979 980 if (++p == q) 981 return NULL; 982 io->nwin = (*p & 0x0f) + 1; 983 bsz = (*p & 0x30) >> 4; 984 if (bsz == 3) 985 bsz++; 986 lsz = (*p & 0xc0) >> 6; 987 if (lsz == 3) 988 lsz++; 989 p++; 990 991 for (i = 0; i < io->nwin; i++) { 992 io->win[i].base = 0; 993 io->win[i].len = 1; 994 for (j = 0; j < bsz; j++, p++) { 995 if (p == q) 996 return NULL; 997 io->win[i].base += *p << (j*8); 998 } 999 for (j = 0; j < lsz; j++, p++) { 1000 if (p == q) 1001 return NULL; 1002 io->win[i].len += *p << (j*8); 1003 } 1004 } 1005 return p; 1006 } 1007 1008 /*====================================================================*/ 1009 1010 static u_char *parse_mem(u_char *p, u_char *q, cistpl_mem_t *mem) 1011 { 1012 int i, j, asz, lsz, has_ha; 1013 u_int len, ca, ha; 1014 1015 if (p == q) 1016 return NULL; 1017 1018 mem->nwin = (*p & 0x07) + 1; 1019 lsz = (*p & 0x18) >> 3; 1020 asz = (*p & 0x60) >> 5; 1021 has_ha = (*p & 0x80); 1022 if (++p == q) 1023 return NULL; 1024 1025 for (i = 0; i < mem->nwin; i++) { 1026 len = ca = ha = 0; 1027 for (j = 0; j < lsz; j++, p++) { 1028 if (p == q) 1029 return NULL; 1030 len += *p << (j*8); 1031 } 1032 for (j = 0; j < asz; j++, p++) { 1033 if (p == q) 1034 return NULL; 1035 ca += *p << (j*8); 1036 } 1037 if (has_ha) 1038 for (j = 0; j < asz; j++, p++) { 1039 if (p == q) 1040 return NULL; 1041 ha += *p << (j*8); 1042 } 1043 mem->win[i].len = len << 8; 1044 mem->win[i].card_addr = ca << 8; 1045 mem->win[i].host_addr = ha << 8; 1046 } 1047 return p; 1048 } 1049 1050 /*====================================================================*/ 1051 1052 static u_char *parse_irq(u_char *p, u_char *q, cistpl_irq_t *irq) 1053 { 1054 if (p == q) 1055 return NULL; 1056 irq->IRQInfo1 = *p; p++; 1057 if (irq->IRQInfo1 & IRQ_INFO2_VALID) { 1058 if (p+2 > q) 1059 return NULL; 1060 irq->IRQInfo2 = (p[1]<<8) + p[0]; 1061 p += 2; 1062 } 1063 return p; 1064 } 1065 1066 /*====================================================================*/ 1067 1068 static int parse_cftable_entry(tuple_t *tuple, 1069 cistpl_cftable_entry_t *entry) 1070 { 1071 u_char *p, *q, features; 1072 1073 p = tuple->TupleData; 1074 q = p + tuple->TupleDataLen; 1075 entry->index = *p & 0x3f; 1076 entry->flags = 0; 1077 if (*p & 0x40) 1078 entry->flags |= CISTPL_CFTABLE_DEFAULT; 1079 if (*p & 0x80) { 1080 if (++p == q) 1081 return -EINVAL; 1082 if (*p & 0x10) 1083 entry->flags |= CISTPL_CFTABLE_BVDS; 1084 if (*p & 0x20) 1085 entry->flags |= CISTPL_CFTABLE_WP; 1086 if (*p & 0x40) 1087 entry->flags |= CISTPL_CFTABLE_RDYBSY; 1088 if (*p & 0x80) 1089 entry->flags |= CISTPL_CFTABLE_MWAIT; 1090 entry->interface = *p & 0x0f; 1091 } else 1092 entry->interface = 0; 1093 1094 /* Process optional features */ 1095 if (++p == q) 1096 return -EINVAL; 1097 features = *p; p++; 1098 1099 /* Power options */ 1100 if ((features & 3) > 0) { 1101 p = parse_power(p, q, &entry->vcc); 1102 if (p == NULL) 1103 return -EINVAL; 1104 } else 1105 entry->vcc.present = 0; 1106 if ((features & 3) > 1) { 1107 p = parse_power(p, q, &entry->vpp1); 1108 if (p == NULL) 1109 return -EINVAL; 1110 } else 1111 entry->vpp1.present = 0; 1112 if ((features & 3) > 2) { 1113 p = parse_power(p, q, &entry->vpp2); 1114 if (p == NULL) 1115 return -EINVAL; 1116 } else 1117 entry->vpp2.present = 0; 1118 1119 /* Timing options */ 1120 if (features & 0x04) { 1121 p = parse_timing(p, q, &entry->timing); 1122 if (p == NULL) 1123 return -EINVAL; 1124 } else { 1125 entry->timing.wait = 0; 1126 entry->timing.ready = 0; 1127 entry->timing.reserved = 0; 1128 } 1129 1130 /* I/O window options */ 1131 if (features & 0x08) { 1132 p = parse_io(p, q, &entry->io); 1133 if (p == NULL) 1134 return -EINVAL; 1135 } else 1136 entry->io.nwin = 0; 1137 1138 /* Interrupt options */ 1139 if (features & 0x10) { 1140 p = parse_irq(p, q, &entry->irq); 1141 if (p == NULL) 1142 return -EINVAL; 1143 } else 1144 entry->irq.IRQInfo1 = 0; 1145 1146 switch (features & 0x60) { 1147 case 0x00: 1148 entry->mem.nwin = 0; 1149 break; 1150 case 0x20: 1151 entry->mem.nwin = 1; 1152 entry->mem.win[0].len = get_unaligned_le16(p) << 8; 1153 entry->mem.win[0].card_addr = 0; 1154 entry->mem.win[0].host_addr = 0; 1155 p += 2; 1156 if (p > q) 1157 return -EINVAL; 1158 break; 1159 case 0x40: 1160 entry->mem.nwin = 1; 1161 entry->mem.win[0].len = get_unaligned_le16(p) << 8; 1162 entry->mem.win[0].card_addr = get_unaligned_le16(p + 2) << 8; 1163 entry->mem.win[0].host_addr = 0; 1164 p += 4; 1165 if (p > q) 1166 return -EINVAL; 1167 break; 1168 case 0x60: 1169 p = parse_mem(p, q, &entry->mem); 1170 if (p == NULL) 1171 return -EINVAL; 1172 break; 1173 } 1174 1175 /* Misc features */ 1176 if (features & 0x80) { 1177 if (p == q) 1178 return -EINVAL; 1179 entry->flags |= (*p << 8); 1180 while (*p & 0x80) 1181 if (++p == q) 1182 return -EINVAL; 1183 p++; 1184 } 1185 1186 entry->subtuples = q-p; 1187 1188 return 0; 1189 } 1190 1191 /*====================================================================*/ 1192 1193 #ifdef CONFIG_CARDBUS 1194 1195 static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar) 1196 { 1197 u_char *p; 1198 if (tuple->TupleDataLen < 6) 1199 return -EINVAL; 1200 p = (u_char *)tuple->TupleData; 1201 bar->attr = *p; 1202 p += 2; 1203 bar->size = get_unaligned_le32(p); 1204 return 0; 1205 } 1206 1207 static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config) 1208 { 1209 u_char *p; 1210 1211 p = (u_char *)tuple->TupleData; 1212 if ((*p != 3) || (tuple->TupleDataLen < 6)) 1213 return -EINVAL; 1214 config->last_idx = *(++p); 1215 p++; 1216 config->base = get_unaligned_le32(p); 1217 config->subtuples = tuple->TupleDataLen - 6; 1218 return 0; 1219 } 1220 1221 static int parse_cftable_entry_cb(tuple_t *tuple, 1222 cistpl_cftable_entry_cb_t *entry) 1223 { 1224 u_char *p, *q, features; 1225 1226 p = tuple->TupleData; 1227 q = p + tuple->TupleDataLen; 1228 entry->index = *p & 0x3f; 1229 entry->flags = 0; 1230 if (*p & 0x40) 1231 entry->flags |= CISTPL_CFTABLE_DEFAULT; 1232 1233 /* Process optional features */ 1234 if (++p == q) 1235 return -EINVAL; 1236 features = *p; p++; 1237 1238 /* Power options */ 1239 if ((features & 3) > 0) { 1240 p = parse_power(p, q, &entry->vcc); 1241 if (p == NULL) 1242 return -EINVAL; 1243 } else 1244 entry->vcc.present = 0; 1245 if ((features & 3) > 1) { 1246 p = parse_power(p, q, &entry->vpp1); 1247 if (p == NULL) 1248 return -EINVAL; 1249 } else 1250 entry->vpp1.present = 0; 1251 if ((features & 3) > 2) { 1252 p = parse_power(p, q, &entry->vpp2); 1253 if (p == NULL) 1254 return -EINVAL; 1255 } else 1256 entry->vpp2.present = 0; 1257 1258 /* I/O window options */ 1259 if (features & 0x08) { 1260 if (p == q) 1261 return -EINVAL; 1262 entry->io = *p; p++; 1263 } else 1264 entry->io = 0; 1265 1266 /* Interrupt options */ 1267 if (features & 0x10) { 1268 p = parse_irq(p, q, &entry->irq); 1269 if (p == NULL) 1270 return -EINVAL; 1271 } else 1272 entry->irq.IRQInfo1 = 0; 1273 1274 if (features & 0x20) { 1275 if (p == q) 1276 return -EINVAL; 1277 entry->mem = *p; p++; 1278 } else 1279 entry->mem = 0; 1280 1281 /* Misc features */ 1282 if (features & 0x80) { 1283 if (p == q) 1284 return -EINVAL; 1285 entry->flags |= (*p << 8); 1286 if (*p & 0x80) { 1287 if (++p == q) 1288 return -EINVAL; 1289 entry->flags |= (*p << 16); 1290 } 1291 while (*p & 0x80) 1292 if (++p == q) 1293 return -EINVAL; 1294 p++; 1295 } 1296 1297 entry->subtuples = q-p; 1298 1299 return 0; 1300 } 1301 1302 #endif 1303 1304 /*====================================================================*/ 1305 1306 static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo) 1307 { 1308 u_char *p, *q; 1309 int n; 1310 1311 p = (u_char *)tuple->TupleData; 1312 q = p + tuple->TupleDataLen; 1313 1314 for (n = 0; n < CISTPL_MAX_DEVICES; n++) { 1315 if (p > q-6) 1316 break; 1317 geo->geo[n].buswidth = p[0]; 1318 geo->geo[n].erase_block = 1 << (p[1]-1); 1319 geo->geo[n].read_block = 1 << (p[2]-1); 1320 geo->geo[n].write_block = 1 << (p[3]-1); 1321 geo->geo[n].partition = 1 << (p[4]-1); 1322 geo->geo[n].interleave = 1 << (p[5]-1); 1323 p += 6; 1324 } 1325 geo->ngeo = n; 1326 return 0; 1327 } 1328 1329 /*====================================================================*/ 1330 1331 static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2) 1332 { 1333 u_char *p, *q; 1334 1335 if (tuple->TupleDataLen < 10) 1336 return -EINVAL; 1337 1338 p = tuple->TupleData; 1339 q = p + tuple->TupleDataLen; 1340 1341 v2->vers = p[0]; 1342 v2->comply = p[1]; 1343 v2->dindex = get_unaligned_le16(p + 2); 1344 v2->vspec8 = p[6]; 1345 v2->vspec9 = p[7]; 1346 v2->nhdr = p[8]; 1347 p += 9; 1348 return parse_strings(p, q, 2, v2->str, &v2->vendor, NULL); 1349 } 1350 1351 /*====================================================================*/ 1352 1353 static int parse_org(tuple_t *tuple, cistpl_org_t *org) 1354 { 1355 u_char *p, *q; 1356 int i; 1357 1358 p = tuple->TupleData; 1359 q = p + tuple->TupleDataLen; 1360 if (p == q) 1361 return -EINVAL; 1362 org->data_org = *p; 1363 if (++p == q) 1364 return -EINVAL; 1365 for (i = 0; i < 30; i++) { 1366 org->desc[i] = *p; 1367 if (*p == '\0') 1368 break; 1369 if (++p == q) 1370 return -EINVAL; 1371 } 1372 return 0; 1373 } 1374 1375 /*====================================================================*/ 1376 1377 static int parse_format(tuple_t *tuple, cistpl_format_t *fmt) 1378 { 1379 u_char *p; 1380 1381 if (tuple->TupleDataLen < 10) 1382 return -EINVAL; 1383 1384 p = tuple->TupleData; 1385 1386 fmt->type = p[0]; 1387 fmt->edc = p[1]; 1388 fmt->offset = get_unaligned_le32(p + 2); 1389 fmt->length = get_unaligned_le32(p + 6); 1390 1391 return 0; 1392 } 1393 1394 /*====================================================================*/ 1395 1396 int pcmcia_parse_tuple(tuple_t *tuple, cisparse_t *parse) 1397 { 1398 int ret = 0; 1399 1400 if (tuple->TupleDataLen > tuple->TupleDataMax) 1401 return -EINVAL; 1402 switch (tuple->TupleCode) { 1403 case CISTPL_DEVICE: 1404 case CISTPL_DEVICE_A: 1405 ret = parse_device(tuple, &parse->device); 1406 break; 1407 #ifdef CONFIG_CARDBUS 1408 case CISTPL_BAR: 1409 ret = parse_bar(tuple, &parse->bar); 1410 break; 1411 case CISTPL_CONFIG_CB: 1412 ret = parse_config_cb(tuple, &parse->config); 1413 break; 1414 case CISTPL_CFTABLE_ENTRY_CB: 1415 ret = parse_cftable_entry_cb(tuple, &parse->cftable_entry_cb); 1416 break; 1417 #endif 1418 case CISTPL_CHECKSUM: 1419 ret = parse_checksum(tuple, &parse->checksum); 1420 break; 1421 case CISTPL_LONGLINK_A: 1422 case CISTPL_LONGLINK_C: 1423 ret = parse_longlink(tuple, &parse->longlink); 1424 break; 1425 case CISTPL_LONGLINK_MFC: 1426 ret = parse_longlink_mfc(tuple, &parse->longlink_mfc); 1427 break; 1428 case CISTPL_VERS_1: 1429 ret = parse_vers_1(tuple, &parse->version_1); 1430 break; 1431 case CISTPL_ALTSTR: 1432 ret = parse_altstr(tuple, &parse->altstr); 1433 break; 1434 case CISTPL_JEDEC_A: 1435 case CISTPL_JEDEC_C: 1436 ret = parse_jedec(tuple, &parse->jedec); 1437 break; 1438 case CISTPL_MANFID: 1439 ret = parse_manfid(tuple, &parse->manfid); 1440 break; 1441 case CISTPL_FUNCID: 1442 ret = parse_funcid(tuple, &parse->funcid); 1443 break; 1444 case CISTPL_FUNCE: 1445 ret = parse_funce(tuple, &parse->funce); 1446 break; 1447 case CISTPL_CONFIG: 1448 ret = parse_config(tuple, &parse->config); 1449 break; 1450 case CISTPL_CFTABLE_ENTRY: 1451 ret = parse_cftable_entry(tuple, &parse->cftable_entry); 1452 break; 1453 case CISTPL_DEVICE_GEO: 1454 case CISTPL_DEVICE_GEO_A: 1455 ret = parse_device_geo(tuple, &parse->device_geo); 1456 break; 1457 case CISTPL_VERS_2: 1458 ret = parse_vers_2(tuple, &parse->vers_2); 1459 break; 1460 case CISTPL_ORG: 1461 ret = parse_org(tuple, &parse->org); 1462 break; 1463 case CISTPL_FORMAT: 1464 case CISTPL_FORMAT_A: 1465 ret = parse_format(tuple, &parse->format); 1466 break; 1467 case CISTPL_NO_LINK: 1468 case CISTPL_LINKTARGET: 1469 ret = 0; 1470 break; 1471 default: 1472 ret = -EINVAL; 1473 break; 1474 } 1475 if (ret) 1476 pr_debug("parse_tuple failed %d\n", ret); 1477 return ret; 1478 } 1479 EXPORT_SYMBOL(pcmcia_parse_tuple); 1480 1481 /*====================================================================== 1482 1483 This is used internally by Card Services to look up CIS stuff. 1484 1485 ======================================================================*/ 1486 1487 int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t code, void *parse) 1488 { 1489 tuple_t tuple; 1490 cisdata_t *buf; 1491 int ret; 1492 1493 buf = kmalloc(256, GFP_KERNEL); 1494 if (buf == NULL) { 1495 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n"); 1496 return -ENOMEM; 1497 } 1498 tuple.DesiredTuple = code; 1499 tuple.Attributes = 0; 1500 if (function == BIND_FN_ALL) 1501 tuple.Attributes = TUPLE_RETURN_COMMON; 1502 ret = pccard_get_first_tuple(s, function, &tuple); 1503 if (ret != 0) 1504 goto done; 1505 tuple.TupleData = buf; 1506 tuple.TupleOffset = 0; 1507 tuple.TupleDataMax = 255; 1508 ret = pccard_get_tuple_data(s, &tuple); 1509 if (ret != 0) 1510 goto done; 1511 ret = pcmcia_parse_tuple(&tuple, parse); 1512 done: 1513 kfree(buf); 1514 return ret; 1515 } 1516 EXPORT_SYMBOL(pccard_read_tuple); 1517 1518 1519 /** 1520 * pccard_loop_tuple() - loop over tuples in the CIS 1521 * @s: the struct pcmcia_socket where the card is inserted 1522 * @function: the device function we loop for 1523 * @code: which CIS code shall we look for? 1524 * @parse: buffer where the tuple shall be parsed (or NULL, if no parse) 1525 * @priv_data: private data to be passed to the loop_tuple function. 1526 * @loop_tuple: function to call for each CIS entry of type @function. IT 1527 * gets passed the raw tuple, the paresed tuple (if @parse is 1528 * set) and @priv_data. 1529 * 1530 * pccard_loop_tuple() loops over all CIS entries of type @function, and 1531 * calls the @loop_tuple function for each entry. If the call to @loop_tuple 1532 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise. 1533 */ 1534 int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function, 1535 cisdata_t code, cisparse_t *parse, void *priv_data, 1536 int (*loop_tuple) (tuple_t *tuple, 1537 cisparse_t *parse, 1538 void *priv_data)) 1539 { 1540 tuple_t tuple; 1541 cisdata_t *buf; 1542 int ret; 1543 1544 buf = kzalloc(256, GFP_KERNEL); 1545 if (buf == NULL) { 1546 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n"); 1547 return -ENOMEM; 1548 } 1549 1550 tuple.TupleData = buf; 1551 tuple.TupleDataMax = 255; 1552 tuple.TupleOffset = 0; 1553 tuple.DesiredTuple = code; 1554 tuple.Attributes = 0; 1555 1556 ret = pccard_get_first_tuple(s, function, &tuple); 1557 while (!ret) { 1558 if (pccard_get_tuple_data(s, &tuple)) 1559 goto next_entry; 1560 1561 if (parse) 1562 if (pcmcia_parse_tuple(&tuple, parse)) 1563 goto next_entry; 1564 1565 ret = loop_tuple(&tuple, parse, priv_data); 1566 if (!ret) 1567 break; 1568 1569 next_entry: 1570 ret = pccard_get_next_tuple(s, function, &tuple); 1571 } 1572 1573 kfree(buf); 1574 return ret; 1575 } 1576 EXPORT_SYMBOL(pccard_loop_tuple); 1577 1578 1579 /*====================================================================== 1580 1581 This tries to determine if a card has a sensible CIS. It returns 1582 the number of tuples in the CIS, or 0 if the CIS looks bad. The 1583 checks include making sure several critical tuples are present and 1584 valid; seeing if the total number of tuples is reasonable; and 1585 looking for tuples that use reserved codes. 1586 1587 ======================================================================*/ 1588 1589 int pccard_validate_cis(struct pcmcia_socket *s, unsigned int *info) 1590 { 1591 tuple_t *tuple; 1592 cisparse_t *p; 1593 unsigned int count = 0; 1594 int ret, reserved, dev_ok = 0, ident_ok = 0; 1595 1596 if (!s) 1597 return -EINVAL; 1598 1599 tuple = kmalloc(sizeof(*tuple), GFP_KERNEL); 1600 if (tuple == NULL) { 1601 dev_printk(KERN_WARNING, &s->dev, "no memory to validate CIS\n"); 1602 return -ENOMEM; 1603 } 1604 p = kmalloc(sizeof(*p), GFP_KERNEL); 1605 if (p == NULL) { 1606 kfree(tuple); 1607 dev_printk(KERN_WARNING, &s->dev, "no memory to validate CIS\n"); 1608 return -ENOMEM; 1609 } 1610 1611 count = reserved = 0; 1612 tuple->DesiredTuple = RETURN_FIRST_TUPLE; 1613 tuple->Attributes = TUPLE_RETURN_COMMON; 1614 ret = pccard_get_first_tuple(s, BIND_FN_ALL, tuple); 1615 if (ret != 0) 1616 goto done; 1617 1618 /* First tuple should be DEVICE; we should really have either that 1619 or a CFTABLE_ENTRY of some sort */ 1620 if ((tuple->TupleCode == CISTPL_DEVICE) || 1621 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY, p) == 0) || 1622 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY_CB, p) == 0)) 1623 dev_ok++; 1624 1625 /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2 1626 tuple, for card identification. Certain old D-Link and Linksys 1627 cards have only a broken VERS_2 tuple; hence the bogus test. */ 1628 if ((pccard_read_tuple(s, BIND_FN_ALL, CISTPL_MANFID, p) == 0) || 1629 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_1, p) == 0) || 1630 (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_2, p) != -ENOSPC)) 1631 ident_ok++; 1632 1633 if (!dev_ok && !ident_ok) 1634 goto done; 1635 1636 for (count = 1; count < MAX_TUPLES; count++) { 1637 ret = pccard_get_next_tuple(s, BIND_FN_ALL, tuple); 1638 if (ret != 0) 1639 break; 1640 if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) || 1641 ((tuple->TupleCode > 0x47) && (tuple->TupleCode < 0x80)) || 1642 ((tuple->TupleCode > 0x90) && (tuple->TupleCode < 0xff))) 1643 reserved++; 1644 } 1645 if ((count == MAX_TUPLES) || (reserved > 5) || 1646 ((!dev_ok || !ident_ok) && (count > 10))) 1647 count = 0; 1648 1649 done: 1650 if (info) 1651 *info = count; 1652 kfree(tuple); 1653 kfree(p); 1654 return 0; 1655 } 1656 EXPORT_SYMBOL(pccard_validate_cis); 1657