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