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