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