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 <asm/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/bulkmem.h> 34 #include <pcmcia/cisreg.h> 35 #include <pcmcia/cistpl.h> 36 #include "cs_internal.h" 37 38 static const u_char mantissa[] = { 39 10, 12, 13, 15, 20, 25, 30, 35, 40 40, 45, 50, 55, 60, 70, 80, 90 41 }; 42 43 static const u_int exponent[] = { 44 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000 45 }; 46 47 /* Convert an extended speed byte to a time in nanoseconds */ 48 #define SPEED_CVT(v) \ 49 (mantissa[(((v)>>3)&15)-1] * exponent[(v)&7] / 10) 50 /* Convert a power byte to a current in 0.1 microamps */ 51 #define POWER_CVT(v) \ 52 (mantissa[((v)>>3)&15] * exponent[(v)&7] / 10) 53 #define POWER_SCALE(v) (exponent[(v)&7]) 54 55 /* Upper limit on reasonable # of tuples */ 56 #define MAX_TUPLES 200 57 58 /*====================================================================*/ 59 60 /* Parameters that can be set with 'insmod' */ 61 62 /* 16-bit CIS? */ 63 static int cis_width; 64 module_param(cis_width, int, 0444); 65 66 void release_cis_mem(struct pcmcia_socket *s) 67 { 68 if (s->cis_mem.flags & MAP_ACTIVE) { 69 s->cis_mem.flags &= ~MAP_ACTIVE; 70 s->ops->set_mem_map(s, &s->cis_mem); 71 if (s->cis_mem.res) { 72 release_resource(s->cis_mem.res); 73 kfree(s->cis_mem.res); 74 s->cis_mem.res = NULL; 75 } 76 iounmap(s->cis_virt); 77 s->cis_virt = NULL; 78 } 79 } 80 EXPORT_SYMBOL(release_cis_mem); 81 82 /* 83 * Map the card memory at "card_offset" into virtual space. 84 * If flags & MAP_ATTRIB, map the attribute space, otherwise 85 * map the memory space. 86 */ 87 static void __iomem * 88 set_cis_map(struct pcmcia_socket *s, unsigned int card_offset, unsigned int flags) 89 { 90 pccard_mem_map *mem = &s->cis_mem; 91 int ret; 92 93 if (!(s->features & SS_CAP_STATIC_MAP) && (mem->res == NULL)) { 94 mem->res = pcmcia_find_mem_region(0, s->map_size, s->map_size, 0, s); 95 if (mem->res == NULL) { 96 printk(KERN_NOTICE "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 cs_dbg(s, 3, "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 cs_dbg(s, 3, " %#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 cs_dbg(s, 3, "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 u_int 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 return -1; 356 list_for_each_entry(cis, &s->cis_cache, node) { 357 int len = cis->len; 358 359 if (len > 256) 360 len = 256; 361 #ifdef CONFIG_CARDBUS 362 if (s->state & SOCKET_CARDBUS) 363 read_cb_mem(s, cis->attr, cis->addr, len, buf); 364 else 365 #endif 366 pcmcia_read_cis_mem(s, cis->attr, cis->addr, len, buf); 367 368 if (memcmp(buf, cis->cache, len) != 0) { 369 kfree(buf); 370 return -1; 371 } 372 } 373 kfree(buf); 374 return 0; 375 } 376 377 /*====================================================================== 378 379 For really bad cards, we provide a facility for uploading a 380 replacement CIS. 381 382 ======================================================================*/ 383 384 int pcmcia_replace_cis(struct pcmcia_socket *s, cisdump_t *cis) 385 { 386 kfree(s->fake_cis); 387 s->fake_cis = NULL; 388 if (cis->Length > CISTPL_MAX_CIS_SIZE) 389 return CS_BAD_SIZE; 390 s->fake_cis = kmalloc(cis->Length, GFP_KERNEL); 391 if (s->fake_cis == NULL) 392 return CS_OUT_OF_RESOURCE; 393 s->fake_cis_len = cis->Length; 394 memcpy(s->fake_cis, cis->Data, cis->Length); 395 return CS_SUCCESS; 396 } 397 EXPORT_SYMBOL(pcmcia_replace_cis); 398 399 /*====================================================================== 400 401 The high-level CIS tuple services 402 403 ======================================================================*/ 404 405 static inline u16 cis_get_u16(void *ptr) 406 { 407 return le16_to_cpu(get_unaligned((__le16 *) ptr)); 408 } 409 static inline u32 cis_get_u32(void *ptr) 410 { 411 return le32_to_cpu(get_unaligned((__le32 *) ptr)); 412 } 413 414 typedef struct tuple_flags { 415 u_int link_space:4; 416 u_int has_link:1; 417 u_int mfc_fn:3; 418 u_int space:4; 419 } tuple_flags; 420 421 #define LINK_SPACE(f) (((tuple_flags *)(&(f)))->link_space) 422 #define HAS_LINK(f) (((tuple_flags *)(&(f)))->has_link) 423 #define MFC_FN(f) (((tuple_flags *)(&(f)))->mfc_fn) 424 #define SPACE(f) (((tuple_flags *)(&(f)))->space) 425 426 int pccard_get_next_tuple(struct pcmcia_socket *s, unsigned int func, tuple_t *tuple); 427 428 int pccard_get_first_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple) 429 { 430 if (!s) 431 return CS_BAD_HANDLE; 432 if (!(s->state & SOCKET_PRESENT)) 433 return CS_NO_CARD; 434 tuple->TupleLink = tuple->Flags = 0; 435 #ifdef CONFIG_CARDBUS 436 if (s->state & SOCKET_CARDBUS) { 437 struct pci_dev *dev = s->cb_dev; 438 u_int ptr; 439 pci_bus_read_config_dword(dev->subordinate, 0, PCI_CARDBUS_CIS, &ptr); 440 tuple->CISOffset = ptr & ~7; 441 SPACE(tuple->Flags) = (ptr & 7); 442 } else 443 #endif 444 { 445 /* Assume presence of a LONGLINK_C to address 0 */ 446 tuple->CISOffset = tuple->LinkOffset = 0; 447 SPACE(tuple->Flags) = HAS_LINK(tuple->Flags) = 1; 448 } 449 if (!(s->state & SOCKET_CARDBUS) && (s->functions > 1) && 450 !(tuple->Attributes & TUPLE_RETURN_COMMON)) { 451 cisdata_t req = tuple->DesiredTuple; 452 tuple->DesiredTuple = CISTPL_LONGLINK_MFC; 453 if (pccard_get_next_tuple(s, function, tuple) == CS_SUCCESS) { 454 tuple->DesiredTuple = CISTPL_LINKTARGET; 455 if (pccard_get_next_tuple(s, function, tuple) != CS_SUCCESS) 456 return CS_NO_MORE_ITEMS; 457 } else 458 tuple->CISOffset = tuple->TupleLink = 0; 459 tuple->DesiredTuple = req; 460 } 461 return pccard_get_next_tuple(s, function, tuple); 462 } 463 EXPORT_SYMBOL(pccard_get_first_tuple); 464 465 static int follow_link(struct pcmcia_socket *s, tuple_t *tuple) 466 { 467 u_char link[5]; 468 u_int ofs; 469 470 if (MFC_FN(tuple->Flags)) { 471 /* Get indirect link from the MFC tuple */ 472 read_cis_cache(s, LINK_SPACE(tuple->Flags), 473 tuple->LinkOffset, 5, link); 474 ofs = cis_get_u32(link + 1); 475 SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR); 476 /* Move to the next indirect link */ 477 tuple->LinkOffset += 5; 478 MFC_FN(tuple->Flags)--; 479 } else if (HAS_LINK(tuple->Flags)) { 480 ofs = tuple->LinkOffset; 481 SPACE(tuple->Flags) = LINK_SPACE(tuple->Flags); 482 HAS_LINK(tuple->Flags) = 0; 483 } else { 484 return -1; 485 } 486 if (!(s->state & SOCKET_CARDBUS) && SPACE(tuple->Flags)) { 487 /* This is ugly, but a common CIS error is to code the long 488 link offset incorrectly, so we check the right spot... */ 489 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link); 490 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) && 491 (strncmp(link+2, "CIS", 3) == 0)) 492 return ofs; 493 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5); 494 /* Then, we try the wrong spot... */ 495 ofs = ofs >> 1; 496 } 497 read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link); 498 if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) && 499 (strncmp(link+2, "CIS", 3) == 0)) 500 return ofs; 501 remove_cis_cache(s, SPACE(tuple->Flags), ofs, 5); 502 return -1; 503 } 504 505 int pccard_get_next_tuple(struct pcmcia_socket *s, unsigned int function, tuple_t *tuple) 506 { 507 u_char link[2], tmp; 508 int ofs, i, attr; 509 510 if (!s) 511 return CS_BAD_HANDLE; 512 if (!(s->state & SOCKET_PRESENT)) 513 return CS_NO_CARD; 514 515 link[1] = tuple->TupleLink; 516 ofs = tuple->CISOffset + tuple->TupleLink; 517 attr = SPACE(tuple->Flags); 518 519 for (i = 0; i < MAX_TUPLES; i++) { 520 if (link[1] == 0xff) { 521 link[0] = CISTPL_END; 522 } else { 523 read_cis_cache(s, attr, ofs, 2, link); 524 if (link[0] == CISTPL_NULL) { 525 ofs++; continue; 526 } 527 } 528 529 /* End of chain? Follow long link if possible */ 530 if (link[0] == CISTPL_END) { 531 if ((ofs = follow_link(s, tuple)) < 0) 532 return CS_NO_MORE_ITEMS; 533 attr = SPACE(tuple->Flags); 534 read_cis_cache(s, attr, ofs, 2, link); 535 } 536 537 /* Is this a link tuple? Make a note of it */ 538 if ((link[0] == CISTPL_LONGLINK_A) || 539 (link[0] == CISTPL_LONGLINK_C) || 540 (link[0] == CISTPL_LONGLINK_MFC) || 541 (link[0] == CISTPL_LINKTARGET) || 542 (link[0] == CISTPL_INDIRECT) || 543 (link[0] == CISTPL_NO_LINK)) { 544 switch (link[0]) { 545 case CISTPL_LONGLINK_A: 546 HAS_LINK(tuple->Flags) = 1; 547 LINK_SPACE(tuple->Flags) = attr | IS_ATTR; 548 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset); 549 break; 550 case CISTPL_LONGLINK_C: 551 HAS_LINK(tuple->Flags) = 1; 552 LINK_SPACE(tuple->Flags) = attr & ~IS_ATTR; 553 read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset); 554 break; 555 case CISTPL_INDIRECT: 556 HAS_LINK(tuple->Flags) = 1; 557 LINK_SPACE(tuple->Flags) = IS_ATTR | IS_INDIRECT; 558 tuple->LinkOffset = 0; 559 break; 560 case CISTPL_LONGLINK_MFC: 561 tuple->LinkOffset = ofs + 3; 562 LINK_SPACE(tuple->Flags) = attr; 563 if (function == BIND_FN_ALL) { 564 /* Follow all the MFC links */ 565 read_cis_cache(s, attr, ofs+2, 1, &tmp); 566 MFC_FN(tuple->Flags) = tmp; 567 } else { 568 /* Follow exactly one of the links */ 569 MFC_FN(tuple->Flags) = 1; 570 tuple->LinkOffset += function * 5; 571 } 572 break; 573 case CISTPL_NO_LINK: 574 HAS_LINK(tuple->Flags) = 0; 575 break; 576 } 577 if ((tuple->Attributes & TUPLE_RETURN_LINK) && 578 (tuple->DesiredTuple == RETURN_FIRST_TUPLE)) 579 break; 580 } else 581 if (tuple->DesiredTuple == RETURN_FIRST_TUPLE) 582 break; 583 584 if (link[0] == tuple->DesiredTuple) 585 break; 586 ofs += link[1] + 2; 587 } 588 if (i == MAX_TUPLES) { 589 cs_dbg(s, 1, "cs: overrun in pcmcia_get_next_tuple\n"); 590 return CS_NO_MORE_ITEMS; 591 } 592 593 tuple->TupleCode = link[0]; 594 tuple->TupleLink = link[1]; 595 tuple->CISOffset = ofs + 2; 596 return CS_SUCCESS; 597 } 598 EXPORT_SYMBOL(pccard_get_next_tuple); 599 600 /*====================================================================*/ 601 602 #define _MIN(a, b) (((a) < (b)) ? (a) : (b)) 603 604 int pccard_get_tuple_data(struct pcmcia_socket *s, tuple_t *tuple) 605 { 606 u_int len; 607 608 if (!s) 609 return CS_BAD_HANDLE; 610 611 if (tuple->TupleLink < tuple->TupleOffset) 612 return CS_NO_MORE_ITEMS; 613 len = tuple->TupleLink - tuple->TupleOffset; 614 tuple->TupleDataLen = tuple->TupleLink; 615 if (len == 0) 616 return CS_SUCCESS; 617 read_cis_cache(s, SPACE(tuple->Flags), 618 tuple->CISOffset + tuple->TupleOffset, 619 _MIN(len, tuple->TupleDataMax), tuple->TupleData); 620 return CS_SUCCESS; 621 } 622 EXPORT_SYMBOL(pccard_get_tuple_data); 623 624 625 /*====================================================================== 626 627 Parsing routines for individual tuples 628 629 ======================================================================*/ 630 631 static int parse_device(tuple_t *tuple, cistpl_device_t *device) 632 { 633 int i; 634 u_char scale; 635 u_char *p, *q; 636 637 p = (u_char *)tuple->TupleData; 638 q = p + tuple->TupleDataLen; 639 640 device->ndev = 0; 641 for (i = 0; i < CISTPL_MAX_DEVICES; i++) { 642 643 if (*p == 0xff) break; 644 device->dev[i].type = (*p >> 4); 645 device->dev[i].wp = (*p & 0x08) ? 1 : 0; 646 switch (*p & 0x07) { 647 case 0: device->dev[i].speed = 0; break; 648 case 1: device->dev[i].speed = 250; break; 649 case 2: device->dev[i].speed = 200; break; 650 case 3: device->dev[i].speed = 150; break; 651 case 4: device->dev[i].speed = 100; break; 652 case 7: 653 if (++p == q) return CS_BAD_TUPLE; 654 device->dev[i].speed = SPEED_CVT(*p); 655 while (*p & 0x80) 656 if (++p == q) return CS_BAD_TUPLE; 657 break; 658 default: 659 return CS_BAD_TUPLE; 660 } 661 662 if (++p == q) return CS_BAD_TUPLE; 663 if (*p == 0xff) break; 664 scale = *p & 7; 665 if (scale == 7) return CS_BAD_TUPLE; 666 device->dev[i].size = ((*p >> 3) + 1) * (512 << (scale*2)); 667 device->ndev++; 668 if (++p == q) break; 669 } 670 671 return CS_SUCCESS; 672 } 673 674 /*====================================================================*/ 675 676 static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum) 677 { 678 u_char *p; 679 if (tuple->TupleDataLen < 5) 680 return CS_BAD_TUPLE; 681 p = (u_char *) tuple->TupleData; 682 csum->addr = tuple->CISOffset + cis_get_u16(p) - 2; 683 csum->len = cis_get_u16(p + 2); 684 csum->sum = *(p + 4); 685 return CS_SUCCESS; 686 } 687 688 /*====================================================================*/ 689 690 static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link) 691 { 692 if (tuple->TupleDataLen < 4) 693 return CS_BAD_TUPLE; 694 link->addr = cis_get_u32(tuple->TupleData); 695 return CS_SUCCESS; 696 } 697 698 /*====================================================================*/ 699 700 static int parse_longlink_mfc(tuple_t *tuple, 701 cistpl_longlink_mfc_t *link) 702 { 703 u_char *p; 704 int i; 705 706 p = (u_char *)tuple->TupleData; 707 708 link->nfn = *p; p++; 709 if (tuple->TupleDataLen <= link->nfn*5) 710 return CS_BAD_TUPLE; 711 for (i = 0; i < link->nfn; i++) { 712 link->fn[i].space = *p; p++; 713 link->fn[i].addr = cis_get_u32(p); 714 p += 4; 715 } 716 return CS_SUCCESS; 717 } 718 719 /*====================================================================*/ 720 721 static int parse_strings(u_char *p, u_char *q, int max, 722 char *s, u_char *ofs, u_char *found) 723 { 724 int i, j, ns; 725 726 if (p == q) return CS_BAD_TUPLE; 727 ns = 0; j = 0; 728 for (i = 0; i < max; i++) { 729 if (*p == 0xff) break; 730 ofs[i] = j; 731 ns++; 732 for (;;) { 733 s[j++] = (*p == 0xff) ? '\0' : *p; 734 if ((*p == '\0') || (*p == 0xff)) break; 735 if (++p == q) return CS_BAD_TUPLE; 736 } 737 if ((*p == 0xff) || (++p == q)) break; 738 } 739 if (found) { 740 *found = ns; 741 return CS_SUCCESS; 742 } else { 743 return (ns == max) ? CS_SUCCESS : CS_BAD_TUPLE; 744 } 745 } 746 747 /*====================================================================*/ 748 749 static int parse_vers_1(tuple_t *tuple, cistpl_vers_1_t *vers_1) 750 { 751 u_char *p, *q; 752 753 p = (u_char *)tuple->TupleData; 754 q = p + tuple->TupleDataLen; 755 756 vers_1->major = *p; p++; 757 vers_1->minor = *p; p++; 758 if (p >= q) return CS_BAD_TUPLE; 759 760 return parse_strings(p, q, CISTPL_VERS_1_MAX_PROD_STRINGS, 761 vers_1->str, vers_1->ofs, &vers_1->ns); 762 } 763 764 /*====================================================================*/ 765 766 static int parse_altstr(tuple_t *tuple, cistpl_altstr_t *altstr) 767 { 768 u_char *p, *q; 769 770 p = (u_char *)tuple->TupleData; 771 q = p + tuple->TupleDataLen; 772 773 return parse_strings(p, q, CISTPL_MAX_ALTSTR_STRINGS, 774 altstr->str, altstr->ofs, &altstr->ns); 775 } 776 777 /*====================================================================*/ 778 779 static int parse_jedec(tuple_t *tuple, cistpl_jedec_t *jedec) 780 { 781 u_char *p, *q; 782 int nid; 783 784 p = (u_char *)tuple->TupleData; 785 q = p + tuple->TupleDataLen; 786 787 for (nid = 0; nid < CISTPL_MAX_DEVICES; nid++) { 788 if (p > q-2) break; 789 jedec->id[nid].mfr = p[0]; 790 jedec->id[nid].info = p[1]; 791 p += 2; 792 } 793 jedec->nid = nid; 794 return CS_SUCCESS; 795 } 796 797 /*====================================================================*/ 798 799 static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m) 800 { 801 if (tuple->TupleDataLen < 4) 802 return CS_BAD_TUPLE; 803 m->manf = cis_get_u16(tuple->TupleData); 804 m->card = cis_get_u16(tuple->TupleData + 2); 805 return CS_SUCCESS; 806 } 807 808 /*====================================================================*/ 809 810 static int parse_funcid(tuple_t *tuple, cistpl_funcid_t *f) 811 { 812 u_char *p; 813 if (tuple->TupleDataLen < 2) 814 return CS_BAD_TUPLE; 815 p = (u_char *)tuple->TupleData; 816 f->func = p[0]; 817 f->sysinit = p[1]; 818 return CS_SUCCESS; 819 } 820 821 /*====================================================================*/ 822 823 static int parse_funce(tuple_t *tuple, cistpl_funce_t *f) 824 { 825 u_char *p; 826 int i; 827 if (tuple->TupleDataLen < 1) 828 return CS_BAD_TUPLE; 829 p = (u_char *)tuple->TupleData; 830 f->type = p[0]; 831 for (i = 1; i < tuple->TupleDataLen; i++) 832 f->data[i-1] = p[i]; 833 return CS_SUCCESS; 834 } 835 836 /*====================================================================*/ 837 838 static int parse_config(tuple_t *tuple, cistpl_config_t *config) 839 { 840 int rasz, rmsz, i; 841 u_char *p; 842 843 p = (u_char *)tuple->TupleData; 844 rasz = *p & 0x03; 845 rmsz = (*p & 0x3c) >> 2; 846 if (tuple->TupleDataLen < rasz+rmsz+4) 847 return CS_BAD_TUPLE; 848 config->last_idx = *(++p); 849 p++; 850 config->base = 0; 851 for (i = 0; i <= rasz; i++) 852 config->base += p[i] << (8*i); 853 p += rasz+1; 854 for (i = 0; i < 4; i++) 855 config->rmask[i] = 0; 856 for (i = 0; i <= rmsz; i++) 857 config->rmask[i>>2] += p[i] << (8*(i%4)); 858 config->subtuples = tuple->TupleDataLen - (rasz+rmsz+4); 859 return CS_SUCCESS; 860 } 861 862 /*====================================================================== 863 864 The following routines are all used to parse the nightmarish 865 config table entries. 866 867 ======================================================================*/ 868 869 static u_char *parse_power(u_char *p, u_char *q, 870 cistpl_power_t *pwr) 871 { 872 int i; 873 u_int scale; 874 875 if (p == q) return NULL; 876 pwr->present = *p; 877 pwr->flags = 0; 878 p++; 879 for (i = 0; i < 7; i++) 880 if (pwr->present & (1<<i)) { 881 if (p == q) return NULL; 882 pwr->param[i] = POWER_CVT(*p); 883 scale = POWER_SCALE(*p); 884 while (*p & 0x80) { 885 if (++p == q) return NULL; 886 if ((*p & 0x7f) < 100) 887 pwr->param[i] += (*p & 0x7f) * scale / 100; 888 else if (*p == 0x7d) 889 pwr->flags |= CISTPL_POWER_HIGHZ_OK; 890 else if (*p == 0x7e) 891 pwr->param[i] = 0; 892 else if (*p == 0x7f) 893 pwr->flags |= CISTPL_POWER_HIGHZ_REQ; 894 else 895 return NULL; 896 } 897 p++; 898 } 899 return p; 900 } 901 902 /*====================================================================*/ 903 904 static u_char *parse_timing(u_char *p, u_char *q, 905 cistpl_timing_t *timing) 906 { 907 u_char scale; 908 909 if (p == q) return NULL; 910 scale = *p; 911 if ((scale & 3) != 3) { 912 if (++p == q) return NULL; 913 timing->wait = SPEED_CVT(*p); 914 timing->waitscale = exponent[scale & 3]; 915 } else 916 timing->wait = 0; 917 scale >>= 2; 918 if ((scale & 7) != 7) { 919 if (++p == q) return NULL; 920 timing->ready = SPEED_CVT(*p); 921 timing->rdyscale = exponent[scale & 7]; 922 } else 923 timing->ready = 0; 924 scale >>= 3; 925 if (scale != 7) { 926 if (++p == q) return NULL; 927 timing->reserved = SPEED_CVT(*p); 928 timing->rsvscale = exponent[scale]; 929 } else 930 timing->reserved = 0; 931 p++; 932 return p; 933 } 934 935 /*====================================================================*/ 936 937 static u_char *parse_io(u_char *p, u_char *q, cistpl_io_t *io) 938 { 939 int i, j, bsz, lsz; 940 941 if (p == q) return NULL; 942 io->flags = *p; 943 944 if (!(*p & 0x80)) { 945 io->nwin = 1; 946 io->win[0].base = 0; 947 io->win[0].len = (1 << (io->flags & CISTPL_IO_LINES_MASK)); 948 return p+1; 949 } 950 951 if (++p == q) return NULL; 952 io->nwin = (*p & 0x0f) + 1; 953 bsz = (*p & 0x30) >> 4; 954 if (bsz == 3) bsz++; 955 lsz = (*p & 0xc0) >> 6; 956 if (lsz == 3) lsz++; 957 p++; 958 959 for (i = 0; i < io->nwin; i++) { 960 io->win[i].base = 0; 961 io->win[i].len = 1; 962 for (j = 0; j < bsz; j++, p++) { 963 if (p == q) return NULL; 964 io->win[i].base += *p << (j*8); 965 } 966 for (j = 0; j < lsz; j++, p++) { 967 if (p == q) return NULL; 968 io->win[i].len += *p << (j*8); 969 } 970 } 971 return p; 972 } 973 974 /*====================================================================*/ 975 976 static u_char *parse_mem(u_char *p, u_char *q, cistpl_mem_t *mem) 977 { 978 int i, j, asz, lsz, has_ha; 979 u_int len, ca, ha; 980 981 if (p == q) return NULL; 982 983 mem->nwin = (*p & 0x07) + 1; 984 lsz = (*p & 0x18) >> 3; 985 asz = (*p & 0x60) >> 5; 986 has_ha = (*p & 0x80); 987 if (++p == q) return NULL; 988 989 for (i = 0; i < mem->nwin; i++) { 990 len = ca = ha = 0; 991 for (j = 0; j < lsz; j++, p++) { 992 if (p == q) return NULL; 993 len += *p << (j*8); 994 } 995 for (j = 0; j < asz; j++, p++) { 996 if (p == q) return NULL; 997 ca += *p << (j*8); 998 } 999 if (has_ha) 1000 for (j = 0; j < asz; j++, p++) { 1001 if (p == q) return NULL; 1002 ha += *p << (j*8); 1003 } 1004 mem->win[i].len = len << 8; 1005 mem->win[i].card_addr = ca << 8; 1006 mem->win[i].host_addr = ha << 8; 1007 } 1008 return p; 1009 } 1010 1011 /*====================================================================*/ 1012 1013 static u_char *parse_irq(u_char *p, u_char *q, cistpl_irq_t *irq) 1014 { 1015 if (p == q) return NULL; 1016 irq->IRQInfo1 = *p; p++; 1017 if (irq->IRQInfo1 & IRQ_INFO2_VALID) { 1018 if (p+2 > q) return NULL; 1019 irq->IRQInfo2 = (p[1]<<8) + p[0]; 1020 p += 2; 1021 } 1022 return p; 1023 } 1024 1025 /*====================================================================*/ 1026 1027 static int parse_cftable_entry(tuple_t *tuple, 1028 cistpl_cftable_entry_t *entry) 1029 { 1030 u_char *p, *q, features; 1031 1032 p = tuple->TupleData; 1033 q = p + tuple->TupleDataLen; 1034 entry->index = *p & 0x3f; 1035 entry->flags = 0; 1036 if (*p & 0x40) 1037 entry->flags |= CISTPL_CFTABLE_DEFAULT; 1038 if (*p & 0x80) { 1039 if (++p == q) return CS_BAD_TUPLE; 1040 if (*p & 0x10) 1041 entry->flags |= CISTPL_CFTABLE_BVDS; 1042 if (*p & 0x20) 1043 entry->flags |= CISTPL_CFTABLE_WP; 1044 if (*p & 0x40) 1045 entry->flags |= CISTPL_CFTABLE_RDYBSY; 1046 if (*p & 0x80) 1047 entry->flags |= CISTPL_CFTABLE_MWAIT; 1048 entry->interface = *p & 0x0f; 1049 } else 1050 entry->interface = 0; 1051 1052 /* Process optional features */ 1053 if (++p == q) return CS_BAD_TUPLE; 1054 features = *p; p++; 1055 1056 /* Power options */ 1057 if ((features & 3) > 0) { 1058 p = parse_power(p, q, &entry->vcc); 1059 if (p == NULL) return CS_BAD_TUPLE; 1060 } else 1061 entry->vcc.present = 0; 1062 if ((features & 3) > 1) { 1063 p = parse_power(p, q, &entry->vpp1); 1064 if (p == NULL) return CS_BAD_TUPLE; 1065 } else 1066 entry->vpp1.present = 0; 1067 if ((features & 3) > 2) { 1068 p = parse_power(p, q, &entry->vpp2); 1069 if (p == NULL) return CS_BAD_TUPLE; 1070 } else 1071 entry->vpp2.present = 0; 1072 1073 /* Timing options */ 1074 if (features & 0x04) { 1075 p = parse_timing(p, q, &entry->timing); 1076 if (p == NULL) return CS_BAD_TUPLE; 1077 } else { 1078 entry->timing.wait = 0; 1079 entry->timing.ready = 0; 1080 entry->timing.reserved = 0; 1081 } 1082 1083 /* I/O window options */ 1084 if (features & 0x08) { 1085 p = parse_io(p, q, &entry->io); 1086 if (p == NULL) return CS_BAD_TUPLE; 1087 } else 1088 entry->io.nwin = 0; 1089 1090 /* Interrupt options */ 1091 if (features & 0x10) { 1092 p = parse_irq(p, q, &entry->irq); 1093 if (p == NULL) return CS_BAD_TUPLE; 1094 } else 1095 entry->irq.IRQInfo1 = 0; 1096 1097 switch (features & 0x60) { 1098 case 0x00: 1099 entry->mem.nwin = 0; 1100 break; 1101 case 0x20: 1102 entry->mem.nwin = 1; 1103 entry->mem.win[0].len = cis_get_u16(p) << 8; 1104 entry->mem.win[0].card_addr = 0; 1105 entry->mem.win[0].host_addr = 0; 1106 p += 2; 1107 if (p > q) return CS_BAD_TUPLE; 1108 break; 1109 case 0x40: 1110 entry->mem.nwin = 1; 1111 entry->mem.win[0].len = cis_get_u16(p) << 8; 1112 entry->mem.win[0].card_addr = cis_get_u16(p + 2) << 8; 1113 entry->mem.win[0].host_addr = 0; 1114 p += 4; 1115 if (p > q) return CS_BAD_TUPLE; 1116 break; 1117 case 0x60: 1118 p = parse_mem(p, q, &entry->mem); 1119 if (p == NULL) return CS_BAD_TUPLE; 1120 break; 1121 } 1122 1123 /* Misc features */ 1124 if (features & 0x80) { 1125 if (p == q) return CS_BAD_TUPLE; 1126 entry->flags |= (*p << 8); 1127 while (*p & 0x80) 1128 if (++p == q) return CS_BAD_TUPLE; 1129 p++; 1130 } 1131 1132 entry->subtuples = q-p; 1133 1134 return CS_SUCCESS; 1135 } 1136 1137 /*====================================================================*/ 1138 1139 #ifdef CONFIG_CARDBUS 1140 1141 static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar) 1142 { 1143 u_char *p; 1144 if (tuple->TupleDataLen < 6) 1145 return CS_BAD_TUPLE; 1146 p = (u_char *)tuple->TupleData; 1147 bar->attr = *p; 1148 p += 2; 1149 bar->size = cis_get_u32(p); 1150 return CS_SUCCESS; 1151 } 1152 1153 static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config) 1154 { 1155 u_char *p; 1156 1157 p = (u_char *)tuple->TupleData; 1158 if ((*p != 3) || (tuple->TupleDataLen < 6)) 1159 return CS_BAD_TUPLE; 1160 config->last_idx = *(++p); 1161 p++; 1162 config->base = cis_get_u32(p); 1163 config->subtuples = tuple->TupleDataLen - 6; 1164 return CS_SUCCESS; 1165 } 1166 1167 static int parse_cftable_entry_cb(tuple_t *tuple, 1168 cistpl_cftable_entry_cb_t *entry) 1169 { 1170 u_char *p, *q, features; 1171 1172 p = tuple->TupleData; 1173 q = p + tuple->TupleDataLen; 1174 entry->index = *p & 0x3f; 1175 entry->flags = 0; 1176 if (*p & 0x40) 1177 entry->flags |= CISTPL_CFTABLE_DEFAULT; 1178 1179 /* Process optional features */ 1180 if (++p == q) return CS_BAD_TUPLE; 1181 features = *p; p++; 1182 1183 /* Power options */ 1184 if ((features & 3) > 0) { 1185 p = parse_power(p, q, &entry->vcc); 1186 if (p == NULL) return CS_BAD_TUPLE; 1187 } else 1188 entry->vcc.present = 0; 1189 if ((features & 3) > 1) { 1190 p = parse_power(p, q, &entry->vpp1); 1191 if (p == NULL) return CS_BAD_TUPLE; 1192 } else 1193 entry->vpp1.present = 0; 1194 if ((features & 3) > 2) { 1195 p = parse_power(p, q, &entry->vpp2); 1196 if (p == NULL) return CS_BAD_TUPLE; 1197 } else 1198 entry->vpp2.present = 0; 1199 1200 /* I/O window options */ 1201 if (features & 0x08) { 1202 if (p == q) return CS_BAD_TUPLE; 1203 entry->io = *p; p++; 1204 } else 1205 entry->io = 0; 1206 1207 /* Interrupt options */ 1208 if (features & 0x10) { 1209 p = parse_irq(p, q, &entry->irq); 1210 if (p == NULL) return CS_BAD_TUPLE; 1211 } else 1212 entry->irq.IRQInfo1 = 0; 1213 1214 if (features & 0x20) { 1215 if (p == q) return CS_BAD_TUPLE; 1216 entry->mem = *p; p++; 1217 } else 1218 entry->mem = 0; 1219 1220 /* Misc features */ 1221 if (features & 0x80) { 1222 if (p == q) return CS_BAD_TUPLE; 1223 entry->flags |= (*p << 8); 1224 if (*p & 0x80) { 1225 if (++p == q) return CS_BAD_TUPLE; 1226 entry->flags |= (*p << 16); 1227 } 1228 while (*p & 0x80) 1229 if (++p == q) return CS_BAD_TUPLE; 1230 p++; 1231 } 1232 1233 entry->subtuples = q-p; 1234 1235 return CS_SUCCESS; 1236 } 1237 1238 #endif 1239 1240 /*====================================================================*/ 1241 1242 static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo) 1243 { 1244 u_char *p, *q; 1245 int n; 1246 1247 p = (u_char *)tuple->TupleData; 1248 q = p + tuple->TupleDataLen; 1249 1250 for (n = 0; n < CISTPL_MAX_DEVICES; n++) { 1251 if (p > q-6) break; 1252 geo->geo[n].buswidth = p[0]; 1253 geo->geo[n].erase_block = 1 << (p[1]-1); 1254 geo->geo[n].read_block = 1 << (p[2]-1); 1255 geo->geo[n].write_block = 1 << (p[3]-1); 1256 geo->geo[n].partition = 1 << (p[4]-1); 1257 geo->geo[n].interleave = 1 << (p[5]-1); 1258 p += 6; 1259 } 1260 geo->ngeo = n; 1261 return CS_SUCCESS; 1262 } 1263 1264 /*====================================================================*/ 1265 1266 static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2) 1267 { 1268 u_char *p, *q; 1269 1270 if (tuple->TupleDataLen < 10) 1271 return CS_BAD_TUPLE; 1272 1273 p = tuple->TupleData; 1274 q = p + tuple->TupleDataLen; 1275 1276 v2->vers = p[0]; 1277 v2->comply = p[1]; 1278 v2->dindex = cis_get_u16(p +2 ); 1279 v2->vspec8 = p[6]; 1280 v2->vspec9 = p[7]; 1281 v2->nhdr = p[8]; 1282 p += 9; 1283 return parse_strings(p, q, 2, v2->str, &v2->vendor, NULL); 1284 } 1285 1286 /*====================================================================*/ 1287 1288 static int parse_org(tuple_t *tuple, cistpl_org_t *org) 1289 { 1290 u_char *p, *q; 1291 int i; 1292 1293 p = tuple->TupleData; 1294 q = p + tuple->TupleDataLen; 1295 if (p == q) return CS_BAD_TUPLE; 1296 org->data_org = *p; 1297 if (++p == q) return CS_BAD_TUPLE; 1298 for (i = 0; i < 30; i++) { 1299 org->desc[i] = *p; 1300 if (*p == '\0') break; 1301 if (++p == q) return CS_BAD_TUPLE; 1302 } 1303 return CS_SUCCESS; 1304 } 1305 1306 /*====================================================================*/ 1307 1308 static int parse_format(tuple_t *tuple, cistpl_format_t *fmt) 1309 { 1310 u_char *p; 1311 1312 if (tuple->TupleDataLen < 10) 1313 return CS_BAD_TUPLE; 1314 1315 p = tuple->TupleData; 1316 1317 fmt->type = p[0]; 1318 fmt->edc = p[1]; 1319 fmt->offset = cis_get_u32(p + 2); 1320 fmt->length = cis_get_u32(p + 6); 1321 1322 return CS_SUCCESS; 1323 } 1324 1325 /*====================================================================*/ 1326 1327 int pccard_parse_tuple(tuple_t *tuple, cisparse_t *parse) 1328 { 1329 int ret = CS_SUCCESS; 1330 1331 if (tuple->TupleDataLen > tuple->TupleDataMax) 1332 return CS_BAD_TUPLE; 1333 switch (tuple->TupleCode) { 1334 case CISTPL_DEVICE: 1335 case CISTPL_DEVICE_A: 1336 ret = parse_device(tuple, &parse->device); 1337 break; 1338 #ifdef CONFIG_CARDBUS 1339 case CISTPL_BAR: 1340 ret = parse_bar(tuple, &parse->bar); 1341 break; 1342 case CISTPL_CONFIG_CB: 1343 ret = parse_config_cb(tuple, &parse->config); 1344 break; 1345 case CISTPL_CFTABLE_ENTRY_CB: 1346 ret = parse_cftable_entry_cb(tuple, &parse->cftable_entry_cb); 1347 break; 1348 #endif 1349 case CISTPL_CHECKSUM: 1350 ret = parse_checksum(tuple, &parse->checksum); 1351 break; 1352 case CISTPL_LONGLINK_A: 1353 case CISTPL_LONGLINK_C: 1354 ret = parse_longlink(tuple, &parse->longlink); 1355 break; 1356 case CISTPL_LONGLINK_MFC: 1357 ret = parse_longlink_mfc(tuple, &parse->longlink_mfc); 1358 break; 1359 case CISTPL_VERS_1: 1360 ret = parse_vers_1(tuple, &parse->version_1); 1361 break; 1362 case CISTPL_ALTSTR: 1363 ret = parse_altstr(tuple, &parse->altstr); 1364 break; 1365 case CISTPL_JEDEC_A: 1366 case CISTPL_JEDEC_C: 1367 ret = parse_jedec(tuple, &parse->jedec); 1368 break; 1369 case CISTPL_MANFID: 1370 ret = parse_manfid(tuple, &parse->manfid); 1371 break; 1372 case CISTPL_FUNCID: 1373 ret = parse_funcid(tuple, &parse->funcid); 1374 break; 1375 case CISTPL_FUNCE: 1376 ret = parse_funce(tuple, &parse->funce); 1377 break; 1378 case CISTPL_CONFIG: 1379 ret = parse_config(tuple, &parse->config); 1380 break; 1381 case CISTPL_CFTABLE_ENTRY: 1382 ret = parse_cftable_entry(tuple, &parse->cftable_entry); 1383 break; 1384 case CISTPL_DEVICE_GEO: 1385 case CISTPL_DEVICE_GEO_A: 1386 ret = parse_device_geo(tuple, &parse->device_geo); 1387 break; 1388 case CISTPL_VERS_2: 1389 ret = parse_vers_2(tuple, &parse->vers_2); 1390 break; 1391 case CISTPL_ORG: 1392 ret = parse_org(tuple, &parse->org); 1393 break; 1394 case CISTPL_FORMAT: 1395 case CISTPL_FORMAT_A: 1396 ret = parse_format(tuple, &parse->format); 1397 break; 1398 case CISTPL_NO_LINK: 1399 case CISTPL_LINKTARGET: 1400 ret = CS_SUCCESS; 1401 break; 1402 default: 1403 ret = CS_UNSUPPORTED_FUNCTION; 1404 break; 1405 } 1406 return ret; 1407 } 1408 EXPORT_SYMBOL(pccard_parse_tuple); 1409 1410 /*====================================================================== 1411 1412 This is used internally by Card Services to look up CIS stuff. 1413 1414 ======================================================================*/ 1415 1416 int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t code, void *parse) 1417 { 1418 tuple_t tuple; 1419 cisdata_t *buf; 1420 int ret; 1421 1422 buf = kmalloc(256, GFP_KERNEL); 1423 if (buf == NULL) 1424 return CS_OUT_OF_RESOURCE; 1425 tuple.DesiredTuple = code; 1426 tuple.Attributes = TUPLE_RETURN_COMMON; 1427 ret = pccard_get_first_tuple(s, function, &tuple); 1428 if (ret != CS_SUCCESS) goto done; 1429 tuple.TupleData = buf; 1430 tuple.TupleOffset = 0; 1431 tuple.TupleDataMax = 255; 1432 ret = pccard_get_tuple_data(s, &tuple); 1433 if (ret != CS_SUCCESS) goto done; 1434 ret = pccard_parse_tuple(&tuple, parse); 1435 done: 1436 kfree(buf); 1437 return ret; 1438 } 1439 EXPORT_SYMBOL(pccard_read_tuple); 1440 1441 /*====================================================================== 1442 1443 This tries to determine if a card has a sensible CIS. It returns 1444 the number of tuples in the CIS, or 0 if the CIS looks bad. The 1445 checks include making sure several critical tuples are present and 1446 valid; seeing if the total number of tuples is reasonable; and 1447 looking for tuples that use reserved codes. 1448 1449 ======================================================================*/ 1450 1451 int pccard_validate_cis(struct pcmcia_socket *s, unsigned int function, cisinfo_t *info) 1452 { 1453 tuple_t *tuple; 1454 cisparse_t *p; 1455 int ret, reserved, dev_ok = 0, ident_ok = 0; 1456 1457 if (!s) 1458 return CS_BAD_HANDLE; 1459 1460 tuple = kmalloc(sizeof(*tuple), GFP_KERNEL); 1461 if (tuple == NULL) 1462 return CS_OUT_OF_RESOURCE; 1463 p = kmalloc(sizeof(*p), GFP_KERNEL); 1464 if (p == NULL) { 1465 kfree(tuple); 1466 return CS_OUT_OF_RESOURCE; 1467 } 1468 1469 info->Chains = reserved = 0; 1470 tuple->DesiredTuple = RETURN_FIRST_TUPLE; 1471 tuple->Attributes = TUPLE_RETURN_COMMON; 1472 ret = pccard_get_first_tuple(s, function, tuple); 1473 if (ret != CS_SUCCESS) 1474 goto done; 1475 1476 /* First tuple should be DEVICE; we should really have either that 1477 or a CFTABLE_ENTRY of some sort */ 1478 if ((tuple->TupleCode == CISTPL_DEVICE) || 1479 (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY, p) == CS_SUCCESS) || 1480 (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY_CB, p) == CS_SUCCESS)) 1481 dev_ok++; 1482 1483 /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2 1484 tuple, for card identification. Certain old D-Link and Linksys 1485 cards have only a broken VERS_2 tuple; hence the bogus test. */ 1486 if ((pccard_read_tuple(s, function, CISTPL_MANFID, p) == CS_SUCCESS) || 1487 (pccard_read_tuple(s, function, CISTPL_VERS_1, p) == CS_SUCCESS) || 1488 (pccard_read_tuple(s, function, CISTPL_VERS_2, p) != CS_NO_MORE_ITEMS)) 1489 ident_ok++; 1490 1491 if (!dev_ok && !ident_ok) 1492 goto done; 1493 1494 for (info->Chains = 1; info->Chains < MAX_TUPLES; info->Chains++) { 1495 ret = pccard_get_next_tuple(s, function, tuple); 1496 if (ret != CS_SUCCESS) break; 1497 if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) || 1498 ((tuple->TupleCode > 0x47) && (tuple->TupleCode < 0x80)) || 1499 ((tuple->TupleCode > 0x90) && (tuple->TupleCode < 0xff))) 1500 reserved++; 1501 } 1502 if ((info->Chains == MAX_TUPLES) || (reserved > 5) || 1503 ((!dev_ok || !ident_ok) && (info->Chains > 10))) 1504 info->Chains = 0; 1505 1506 done: 1507 kfree(tuple); 1508 kfree(p); 1509 return CS_SUCCESS; 1510 } 1511 EXPORT_SYMBOL(pccard_validate_cis); 1512