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