1 /*- 2 * Copyright (c) 2000,2001 Jonathan Chen. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: src/sys/dev/cardbus/cardbus_cis.c,v 1.50 2005/02/20 20:36:16 imp Exp $ 27 * $DragonFly: src/sys/dev/pccard/cardbus/cardbus_cis.c,v 1.6 2007/07/05 12:08:54 sephe Exp $ 28 */ 29 30 /* 31 * CIS Handling for the Cardbus Bus 32 */ 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/malloc.h> 38 39 #include <sys/bus.h> 40 #include <sys/rman.h> 41 #include <sys/endian.h> 42 43 #include <sys/pciio.h> 44 #include <bus/pci/pcivar.h> 45 #include <bus/pci/pcireg.h> 46 47 #include <bus/pccard/pccardvar.h> 48 #include <bus/pccard/pccard_cis.h> 49 50 #include <dev/pccard/cardbus/cardbusreg.h> 51 #include <dev/pccard/cardbus/cardbusvar.h> 52 #include <dev/pccard/cardbus/cardbus_cis.h> 53 54 extern int cardbus_cis_debug; 55 56 #define DPRINTF(a) if (cardbus_cis_debug) kprintf a 57 #define DEVPRINTF(x) if (cardbus_cis_debug) device_printf x 58 59 struct tuple_callbacks; 60 61 typedef int (tuple_cb) (device_t cbdev, device_t child, int id, int len, 62 uint8_t *tupledata, uint32_t start, uint32_t *off, 63 struct tuple_callbacks *info); 64 65 struct tuple_callbacks { 66 int id; 67 char *name; 68 tuple_cb *func; 69 }; 70 71 static int decode_tuple_generic(device_t cbdev, device_t child, int id, 72 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 73 struct tuple_callbacks *info); 74 static int decode_tuple_linktarget(device_t cbdev, device_t child, int id, 75 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 76 struct tuple_callbacks *info); 77 static int decode_tuple_vers_1(device_t cbdev, device_t child, int id, 78 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 79 struct tuple_callbacks *info); 80 static int decode_tuple_funcid(device_t cbdev, device_t child, int id, 81 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 82 struct tuple_callbacks *info); 83 static int decode_tuple_manfid(device_t cbdev, device_t child, int id, 84 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 85 struct tuple_callbacks *info); 86 static int decode_tuple_funce(device_t cbdev, device_t child, int id, 87 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 88 struct tuple_callbacks *info); 89 static int decode_tuple_bar(device_t cbdev, device_t child, int id, 90 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 91 struct tuple_callbacks *info); 92 static int decode_tuple_unhandled(device_t cbdev, device_t child, int id, 93 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 94 struct tuple_callbacks *info); 95 static int decode_tuple_end(device_t cbdev, device_t child, int id, 96 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 97 struct tuple_callbacks *info); 98 99 static int cardbus_read_tuple_conf(device_t cbdev, device_t child, 100 uint32_t start, uint32_t *off, int *tupleid, int *len, 101 uint8_t *tupledata); 102 static int cardbus_read_tuple_mem(device_t cbdev, struct resource *res, 103 uint32_t start, uint32_t *off, int *tupleid, int *len, 104 uint8_t *tupledata); 105 static int cardbus_read_tuple(device_t cbdev, device_t child, 106 struct resource *res, uint32_t start, uint32_t *off, 107 int *tupleid, int *len, uint8_t *tupledata); 108 static void cardbus_read_tuple_finish(device_t cbdev, device_t child, 109 int rid, struct resource *res); 110 static struct resource *cardbus_read_tuple_init(device_t cbdev, device_t child, 111 uint32_t *start, int *rid); 112 static int decode_tuple(device_t cbdev, device_t child, int tupleid, 113 int len, uint8_t *tupledata, uint32_t start, 114 uint32_t *off, struct tuple_callbacks *callbacks); 115 static int cardbus_parse_cis(device_t cbdev, device_t child, 116 struct tuple_callbacks *callbacks); 117 118 #define MAKETUPLE(NAME,FUNC) { CISTPL_ ## NAME, #NAME, decode_tuple_ ## FUNC } 119 120 static char *funcnames[] = { 121 "Multi-Functioned", 122 "Memory", 123 "Serial Port", 124 "Parallel Port", 125 "Fixed Disk", 126 "Video Adaptor", 127 "Network Adaptor", 128 "AIMS", 129 "SCSI", 130 "Security" 131 }; 132 133 /* 134 * Handler functions for various CIS tuples 135 */ 136 137 static int 138 decode_tuple_generic(device_t cbdev, device_t child, int id, 139 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 140 struct tuple_callbacks *info) 141 { 142 int i; 143 144 if (cardbus_cis_debug) { 145 if (info) 146 kprintf("TUPLE: %s [%d]:", info->name, len); 147 else 148 kprintf("TUPLE: Unknown(0x%02x) [%d]:", id, len); 149 150 for (i = 0; i < len; i++) { 151 if (i % 0x10 == 0 && len > 0x10) 152 kprintf("\n 0x%02x:", i); 153 kprintf(" %02x", tupledata[i]); 154 } 155 kprintf("\n"); 156 } 157 return (0); 158 } 159 160 static int 161 decode_tuple_linktarget(device_t cbdev, device_t child, int id, 162 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 163 struct tuple_callbacks *info) 164 { 165 int i; 166 167 if (cardbus_cis_debug) { 168 kprintf("TUPLE: %s [%d]:", info->name, len); 169 170 for (i = 0; i < len; i++) { 171 if (i % 0x10 == 0 && len > 0x10) 172 kprintf("\n 0x%02x:", i); 173 kprintf(" %02x", tupledata[i]); 174 } 175 kprintf("\n"); 176 } 177 if (len != 3 || tupledata[0] != 'C' || tupledata[1] != 'I' || 178 tupledata[2] != 'S') { 179 kprintf("Invalid data for CIS Link Target!\n"); 180 decode_tuple_generic(cbdev, child, id, len, tupledata, 181 start, off, info); 182 return (EINVAL); 183 } 184 return (0); 185 } 186 187 static int 188 decode_tuple_vers_1(device_t cbdev, device_t child, int id, 189 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 190 struct tuple_callbacks *info) 191 { 192 int i; 193 194 if (cardbus_cis_debug) { 195 kprintf("Product version: %d.%d\n", tupledata[0], tupledata[1]); 196 kprintf("Product name: "); 197 for (i = 2; i < len; i++) { 198 if (tupledata[i] == '\0') 199 kprintf(" | "); 200 else if (tupledata[i] == 0xff) 201 break; 202 else 203 kprintf("%c", tupledata[i]); 204 } 205 kprintf("\n"); 206 } 207 return (0); 208 } 209 210 static int 211 decode_tuple_funcid(device_t cbdev, device_t child, int id, 212 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 213 struct tuple_callbacks *info) 214 { 215 struct cardbus_devinfo *dinfo = device_get_ivars(child); 216 int numnames = sizeof(funcnames) / sizeof(funcnames[0]); 217 int i; 218 219 if (cardbus_cis_debug) { 220 kprintf("Functions: "); 221 for (i = 0; i < len; i++) { 222 if (tupledata[i] < numnames) 223 kprintf("%s", funcnames[tupledata[i]]); 224 else 225 kprintf("Unknown(%d)", tupledata[i]); 226 if (i < len-1) 227 kprintf(", "); 228 } 229 kprintf("\n"); 230 } 231 if (len > 0) 232 dinfo->funcid = tupledata[0]; /* use first in list */ 233 return (0); 234 } 235 236 static int 237 decode_tuple_manfid(device_t cbdev, device_t child, int id, 238 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 239 struct tuple_callbacks *info) 240 { 241 struct cardbus_devinfo *dinfo = device_get_ivars(child); 242 int i; 243 244 if (cardbus_cis_debug) { 245 kprintf("Manufacturer ID: "); 246 for (i = 0; i < len; i++) 247 kprintf("%02x", tupledata[i]); 248 kprintf("\n"); 249 } 250 251 if (len == 5) { 252 dinfo->mfrid = tupledata[1] | (tupledata[2] << 8); 253 dinfo->prodid = tupledata[3] | (tupledata[4] << 8); 254 } 255 return (0); 256 } 257 258 static int 259 decode_tuple_funce(device_t cbdev, device_t child, int id, 260 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 261 struct tuple_callbacks *info) 262 { 263 struct cardbus_devinfo *dinfo = device_get_ivars(child); 264 int type, i; 265 266 if (cardbus_cis_debug) { 267 kprintf("Function Extension: "); 268 for (i = 0; i < len; i++) 269 kprintf("%02x", tupledata[i]); 270 kprintf("\n"); 271 } 272 if (len < 2) /* too short */ 273 return (0); 274 type = tupledata[0]; /* XXX <32 always? */ 275 switch (dinfo->funcid) { 276 case PCCARD_FUNCTION_NETWORK: 277 switch (type) { 278 case PCCARD_TPLFE_TYPE_LAN_NID: 279 if (tupledata[1] > sizeof(dinfo->funce.lan.nid)) { 280 /* ignore, warning? */ 281 return (0); 282 } 283 bcopy(tupledata + 2, dinfo->funce.lan.nid, 284 tupledata[1]); 285 break; 286 } 287 dinfo->fepresent |= 1<<type; 288 break; 289 } 290 return (0); 291 } 292 293 static int 294 decode_tuple_bar(device_t cbdev, device_t child, int id, 295 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 296 struct tuple_callbacks *info) 297 { 298 struct cardbus_devinfo *dinfo = device_get_ivars(child); 299 int type; 300 uint8_t reg; 301 uint32_t bar, pci_bar; 302 303 if (len != 6) { 304 device_printf(cbdev, "CIS BAR length not 6 (%d)\n", len); 305 return (EINVAL); 306 } 307 308 reg = *tupledata; 309 len = le32toh(*(uint32_t*)(tupledata + 2)); 310 if (reg & TPL_BAR_REG_AS) { 311 type = SYS_RES_IOPORT; 312 } else { 313 type = SYS_RES_MEMORY; 314 } 315 316 bar = reg & TPL_BAR_REG_ASI_MASK; 317 if (bar == 0) { 318 device_printf(cbdev, "Invalid BAR type 0 in CIS\n"); 319 return (EINVAL); /* XXX Return an error? */ 320 } else if (bar == 7) { 321 /* XXX Should we try to map in Option ROMs? */ 322 return (0); 323 } 324 325 /* Convert from BAR type to BAR offset */ 326 bar = CARDBUS_BASE0_REG + (bar - 1) * 4; 327 328 if (type == SYS_RES_MEMORY) { 329 if (reg & TPL_BAR_REG_PREFETCHABLE) 330 dinfo->mprefetchable |= BARBIT(bar); 331 #if 0 332 /* 333 * XXX: It appears from a careful reading of the spec 334 * that we're not supposed to honor this when the bridge 335 * is not on the main system bus. PCI spec doesn't appear 336 * to allow for memory ranges not listed in the bridge's 337 * decode range to be decoded. The PC Card spec seems to 338 * indicate that this should only be done on x86 based 339 * machines, which seems to imply that on non-x86 machines 340 * the adddresses can be anywhere. This further implies that 341 * since the hardware can do it on non-x86 machines, it should 342 * be able to do it on x86 machines. Therefore, we can and 343 * should ignore this hint. Furthermore, the PC Card spec 344 * recommends always allocating memory above 1MB, contradicting 345 * the other part of the PC Card spec. 346 * 347 * NetBSD ignores this bit, but it also ignores the 348 * prefetchable bit too, so that's not an indication of 349 * correctness. 350 */ 351 if (reg & TPL_BAR_REG_BELOW1MB) 352 dinfo->mbelow1mb |= BARBIT(bar); 353 #endif 354 } 355 356 /* 357 * Sanity check the BAR length reported in the CIS with the length 358 * encoded in the PCI BAR. The latter seems to be more reliable. 359 * XXX - This probably belongs elsewhere. 360 */ 361 pci_write_config(child, bar, 0xffffffff, 4); 362 pci_bar = pci_read_config(child, bar, 4); 363 if ((pci_bar != 0x0) && (pci_bar != 0xffffffff)) { 364 if (type == SYS_RES_MEMORY) { 365 pci_bar &= ~0xf; 366 } else { 367 pci_bar &= ~0x3; 368 } 369 len = 1 << (ffs(pci_bar) - 1); 370 } 371 372 DEVPRINTF((cbdev, "Opening BAR: type=%s, bar=%02x, len=%04x%s%s\n", 373 (type == SYS_RES_MEMORY) ? "MEM" : "IO", bar, len, 374 (type == SYS_RES_MEMORY && dinfo->mprefetchable & BARBIT(bar)) ? 375 " (Prefetchable)" : "", type == SYS_RES_MEMORY ? 376 ((dinfo->mbelow1mb & BARBIT(bar)) ? " (Below 1Mb)" : "") : "")); 377 378 resource_list_add(&dinfo->pci.resources, type, bar, 0UL, ~0UL, len); 379 380 /* 381 * Mark the appropriate bit in the PCI command register so that 382 * device drivers will know which type of BARs can be used. 383 */ 384 pci_enable_io(child, type); 385 return (0); 386 } 387 388 static int 389 decode_tuple_unhandled(device_t cbdev, device_t child, int id, 390 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 391 struct tuple_callbacks *info) 392 { 393 /* Make this message suck less XXX */ 394 kprintf("TUPLE: %s [%d] is unhandled! Bailing...", info->name, len); 395 return (-1); 396 } 397 398 static int 399 decode_tuple_end(device_t cbdev, device_t child, int id, 400 int len, uint8_t *tupledata, uint32_t start, uint32_t *off, 401 struct tuple_callbacks *info) 402 { 403 if (cardbus_cis_debug) 404 kprintf("CIS reading done\n"); 405 return (0); 406 } 407 408 /* 409 * Functions to read the a tuple from the card 410 */ 411 412 static int 413 cardbus_read_tuple_conf(device_t cbdev, device_t child, uint32_t start, 414 uint32_t *off, int *tupleid, int *len, uint8_t *tupledata) 415 { 416 int i, j; 417 uint32_t e; 418 uint32_t loc; 419 420 loc = start + *off; 421 422 e = pci_read_config(child, loc - loc % 4, 4); 423 for (j = loc % 4; j > 0; j--) 424 e >>= 8; 425 *len = 0; 426 for (i = loc, j = -2; j < *len; j++, i++) { 427 if (i % 4 == 0) 428 e = pci_read_config(child, i, 4); 429 if (j == -2) 430 *tupleid = 0xff & e; 431 else if (j == -1) 432 *len = 0xff & e; 433 else 434 tupledata[j] = 0xff & e; 435 e >>= 8; 436 } 437 *off += *len + 2; 438 return (0); 439 } 440 441 static int 442 cardbus_read_tuple_mem(device_t cbdev, struct resource *res, uint32_t start, 443 uint32_t *off, int *tupleid, int *len, uint8_t *tupledata) 444 { 445 bus_space_tag_t bt; 446 bus_space_handle_t bh; 447 int ret; 448 449 bt = rman_get_bustag(res); 450 bh = rman_get_bushandle(res); 451 452 *tupleid = bus_space_read_1(bt, bh, start + *off); 453 *len = bus_space_read_1(bt, bh, start + *off + 1); 454 bus_space_read_region_1(bt, bh, *off + start + 2, tupledata, *len); 455 ret = 0; 456 *off += *len + 2; 457 return (ret); 458 } 459 460 static int 461 cardbus_read_tuple(device_t cbdev, device_t child, struct resource *res, 462 uint32_t start, uint32_t *off, int *tupleid, int *len, 463 uint8_t *tupledata) 464 { 465 if (res == (struct resource*)~0UL) { 466 return (cardbus_read_tuple_conf(cbdev, child, start, off, 467 tupleid, len, tupledata)); 468 } else { 469 return (cardbus_read_tuple_mem(cbdev, res, start, off, 470 tupleid, len, tupledata)); 471 } 472 } 473 474 static void 475 cardbus_read_tuple_finish(device_t cbdev, device_t child, int rid, 476 struct resource *res) 477 { 478 if (res != (struct resource*)~0UL) { 479 bus_release_resource(cbdev, SYS_RES_MEMORY, rid, res); 480 pci_write_config(child, rid, 0, 4); 481 PCI_DISABLE_IO(cbdev, child, SYS_RES_MEMORY); 482 } 483 } 484 485 static struct resource * 486 cardbus_read_tuple_init(device_t cbdev, device_t child, uint32_t *start, 487 int *rid) 488 { 489 uint32_t testval; 490 uint32_t size; 491 struct resource *res; 492 493 switch (CARDBUS_CIS_SPACE(*start)) { 494 case CARDBUS_CIS_ASI_TUPLE: 495 /* CIS in PCI config space need no initialization */ 496 return ((struct resource*)~0UL); 497 case CARDBUS_CIS_ASI_BAR0: 498 case CARDBUS_CIS_ASI_BAR1: 499 case CARDBUS_CIS_ASI_BAR2: 500 case CARDBUS_CIS_ASI_BAR3: 501 case CARDBUS_CIS_ASI_BAR4: 502 case CARDBUS_CIS_ASI_BAR5: 503 *rid = CARDBUS_BASE0_REG + (CARDBUS_CIS_SPACE(*start) - 1) * 4; 504 break; 505 case CARDBUS_CIS_ASI_ROM: 506 *rid = CARDBUS_ROM_REG; 507 #if 0 508 /* 509 * This mask doesn't contain the bit that actually enables 510 * the Option ROM. 511 */ 512 pci_write_config(child, *rid, CARDBUS_ROM_ADDRMASK, 4); 513 #endif 514 break; 515 default: 516 device_printf(cbdev, "Unable to read CIS: Unknown space: %d\n", 517 CARDBUS_CIS_SPACE(*start)); 518 return (NULL); 519 } 520 521 /* figure out how much space we need */ 522 pci_write_config(child, *rid, 0xffffffff, 4); 523 testval = pci_read_config(child, *rid, 4); 524 525 /* 526 * This bit has a different meaning depending if we are dealing 527 * with a normal BAR or an Option ROM BAR. 528 */ 529 if (((testval & 0x1) == 0x1) && (*rid != CARDBUS_ROM_REG)) { 530 device_printf(cbdev, "CIS Space is IO, expecting memory.\n"); 531 return (NULL); 532 } 533 534 size = CARDBUS_MAPREG_MEM_SIZE(testval); 535 /* XXX Is this some kind of hack? */ 536 if (size < 4096) 537 size = 4096; 538 /* allocate the memory space to read CIS */ 539 res = bus_alloc_resource(cbdev, SYS_RES_MEMORY, rid, 0, ~0, size, 540 rman_make_alignment_flags(size) | RF_ACTIVE); 541 if (res == NULL) { 542 device_printf(cbdev, "Unable to allocate resource " 543 "to read CIS.\n"); 544 return (NULL); 545 } 546 pci_write_config(child, *rid, 547 rman_get_start(res) | ((*rid == CARDBUS_ROM_REG)? 548 CARDBUS_ROM_ENABLE : 0), 549 4); 550 PCI_ENABLE_IO(cbdev, child, SYS_RES_MEMORY); 551 552 /* Flip to the right ROM image if CIS is in ROM */ 553 if (CARDBUS_CIS_SPACE(*start) == CARDBUS_CIS_ASI_ROM) { 554 bus_space_tag_t bt; 555 bus_space_handle_t bh; 556 uint32_t imagesize; 557 uint32_t imagebase = 0; 558 uint32_t pcidata; 559 uint16_t romsig; 560 int romnum = 0; 561 int imagenum; 562 563 bt = rman_get_bustag(res); 564 bh = rman_get_bushandle(res); 565 566 imagenum = CARDBUS_CIS_ASI_ROM_IMAGE(*start); 567 for (romnum = 0;; romnum++) { 568 romsig = bus_space_read_2(bt, bh, 569 imagebase + CARDBUS_EXROM_SIGNATURE); 570 if (romsig != 0xaa55) { 571 device_printf(cbdev, "Bad header in rom %d: " 572 "[%x] %04x\n", romnum, imagebase + 573 CARDBUS_EXROM_SIGNATURE, romsig); 574 bus_release_resource(cbdev, SYS_RES_MEMORY, 575 *rid, res); 576 *rid = 0; 577 return (NULL); 578 } 579 580 /* 581 * If this was the Option ROM image that we were 582 * looking for, then we are done. 583 */ 584 if (romnum == imagenum) 585 break; 586 587 /* Find out where the next Option ROM image is */ 588 pcidata = imagebase + bus_space_read_2(bt, bh, 589 imagebase + CARDBUS_EXROM_DATA_PTR); 590 imagesize = bus_space_read_2(bt, bh, 591 pcidata + CARDBUS_EXROM_DATA_IMAGE_LENGTH); 592 593 if (imagesize == 0) { 594 /* 595 * XXX some ROMs seem to have this as zero, 596 * can we assume this means 1 block? 597 */ 598 device_printf(cbdev, "Warning, size of Option " 599 "ROM image %d is 0 bytes, assuming 512 " 600 "bytes.\n", romnum); 601 imagesize = 1; 602 } 603 604 /* Image size is in 512 byte units */ 605 imagesize <<= 9; 606 607 if ((bus_space_read_1(bt, bh, pcidata + 608 CARDBUS_EXROM_DATA_INDICATOR) & 0x80) != 0) { 609 device_printf(cbdev, "Cannot find CIS in " 610 "Option ROM\n"); 611 bus_release_resource(cbdev, SYS_RES_MEMORY, 612 *rid, res); 613 *rid = 0; 614 return (NULL); 615 } 616 imagebase += imagesize; 617 } 618 *start = imagebase + CARDBUS_CIS_ADDR(*start); 619 } else { 620 *start = CARDBUS_CIS_ADDR(*start); 621 } 622 623 return (res); 624 } 625 626 /* 627 * Dispatch the right handler function per tuple 628 */ 629 630 static int 631 decode_tuple(device_t cbdev, device_t child, int tupleid, int len, 632 uint8_t *tupledata, uint32_t start, uint32_t *off, 633 struct tuple_callbacks *callbacks) 634 { 635 int i; 636 for (i = 0; callbacks[i].id != CISTPL_GENERIC; i++) { 637 if (tupleid == callbacks[i].id) 638 return (callbacks[i].func(cbdev, child, tupleid, len, 639 tupledata, start, off, &callbacks[i])); 640 } 641 return (callbacks[i].func(cbdev, child, tupleid, len, 642 tupledata, start, off, NULL)); 643 } 644 645 static int 646 cardbus_parse_cis(device_t cbdev, device_t child, 647 struct tuple_callbacks *callbacks) 648 { 649 uint8_t tupledata[MAXTUPLESIZE]; 650 int tupleid; 651 int len; 652 int expect_linktarget; 653 uint32_t start, off; 654 struct resource *res; 655 int rid; 656 657 bzero(tupledata, MAXTUPLESIZE); 658 expect_linktarget = TRUE; 659 if ((start = pci_read_config(child, CARDBUS_CIS_REG, 4)) == 0) { 660 device_printf(cbdev, "CIS pointer is 0!\n"); 661 return (ENXIO); 662 } 663 off = 0; 664 res = cardbus_read_tuple_init(cbdev, child, &start, &rid); 665 if (res == NULL) { 666 device_printf(cbdev, "Unable to allocate resources for CIS\n"); 667 return (ENXIO); 668 } 669 670 do { 671 if (0 != cardbus_read_tuple(cbdev, child, res, start, &off, 672 &tupleid, &len, tupledata)) { 673 device_printf(cbdev, "Failed to read CIS.\n"); 674 cardbus_read_tuple_finish(cbdev, child, rid, res); 675 return (ENXIO); 676 } 677 678 if (expect_linktarget && tupleid != CISTPL_LINKTARGET) { 679 device_printf(cbdev, "Expecting link target, got 0x%x\n", 680 tupleid); 681 cardbus_read_tuple_finish(cbdev, child, rid, res); 682 return (EINVAL); 683 } 684 expect_linktarget = decode_tuple(cbdev, child, tupleid, len, 685 tupledata, start, &off, callbacks); 686 if (expect_linktarget != 0) { 687 device_printf(cbdev, "Parsing failed with %d\n", 688 expect_linktarget); 689 cardbus_read_tuple_finish(cbdev, child, rid, res); 690 return (expect_linktarget); 691 } 692 } while (tupleid != CISTPL_END); 693 cardbus_read_tuple_finish(cbdev, child, rid, res); 694 return (0); 695 } 696 697 int 698 cardbus_do_cis(device_t cbdev, device_t child) 699 { 700 int ret; 701 struct tuple_callbacks init_callbacks[] = { 702 MAKETUPLE(LONGLINK_CB, unhandled), 703 MAKETUPLE(INDIRECT, unhandled), 704 MAKETUPLE(LONGLINK_MFC, unhandled), 705 MAKETUPLE(BAR, bar), 706 MAKETUPLE(LONGLINK_A, unhandled), 707 MAKETUPLE(LONGLINK_C, unhandled), 708 MAKETUPLE(LINKTARGET, linktarget), 709 MAKETUPLE(VERS_1, vers_1), 710 MAKETUPLE(MANFID, manfid), 711 MAKETUPLE(FUNCID, funcid), 712 MAKETUPLE(FUNCE, funce), 713 MAKETUPLE(END, end), 714 MAKETUPLE(GENERIC, generic), 715 }; 716 717 ret = cardbus_parse_cis(cbdev, child, init_callbacks); 718 if (ret < 0) 719 return (ret); 720 return 0; 721 } 722