sys/dev/cardbus/cardbus_cis.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2000,2001 Jonathan Chen All rights reserved.
   5  * Copyright (c) 2005-2008 M. Warner Losh <imp@FreeBSD.org>
   6  *
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 /*
  32  * CIS Handling for the Cardbus Bus
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/malloc.h>
  39
  40 #include <sys/bus.h>
  41 #include <machine/bus.h>
  42 #include <machine/resource.h>
  43 #include <sys/rman.h>
  44 #include <sys/endian.h>
  45
  46 #include <sys/pciio.h>
  47 #include <dev/pci/pcivar.h>
  48 #include <dev/pci/pcireg.h>
  49
  50 #include <dev/pccard/pccardvar.h>
  51 #include <dev/pccard/pccard_cis.h>
  52
  53 #include <dev/cardbus/cardbusreg.h>
  54 #include <dev/cardbus/cardbusvar.h>
  55 #include <dev/cardbus/cardbus_cis.h>
  56
  57 extern int cardbus_cis_debug;
  58
  59 #define DPRINTF(a) if (cardbus_cis_debug) printf a
  60 #define DEVPRINTF(x) if (cardbus_cis_debug) device_printf x
  61
  62 #define CIS_CONFIG_SPACE        (struct resource *)~0UL
  63
  64 static int decode_tuple_generic(device_t cbdev, device_t child, int id,
  65     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  66     struct tuple_callbacks *info, void *);
  67 static int decode_tuple_linktarget(device_t cbdev, device_t child, int id,
  68     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  69     struct tuple_callbacks *info, void *);
  70 static int decode_tuple_vers_1(device_t cbdev, device_t child, int id,
  71     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  72     struct tuple_callbacks *info, void *);
  73 static int decode_tuple_funcid(device_t cbdev, device_t child, int id,
  74     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  75     struct tuple_callbacks *info, void *);
  76 static int decode_tuple_manfid(device_t cbdev, device_t child, int id,
  77     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  78     struct tuple_callbacks *info, void *);
  79 static int decode_tuple_funce(device_t cbdev, device_t child, int id,
  80     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  81     struct tuple_callbacks *info, void *);
  82 static int decode_tuple_bar(device_t cbdev, device_t child, int id,
  83     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  84     struct tuple_callbacks *info, void *);
  85 static int decode_tuple_unhandled(device_t cbdev, device_t child, int id,
  86     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  87     struct tuple_callbacks *info, void *);
  88 static int decode_tuple_end(device_t cbdev, device_t child, int id,
  89     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
  90     struct tuple_callbacks *info, void *);
  91
  92 static int      cardbus_read_tuple_conf(device_t cbdev, device_t child,
  93                     uint32_t start, uint32_t *off, int *tupleid, int *len,
  94                     uint8_t *tupledata);
  95 static int      cardbus_read_tuple_mem(device_t cbdev, struct resource *res,
  96                     uint32_t start, uint32_t *off, int *tupleid, int *len,
  97                     uint8_t *tupledata);
  98 static int      cardbus_read_tuple(device_t cbdev, device_t child,
  99                     struct resource *res, uint32_t start, uint32_t *off,
 100                     int *tupleid, int *len, uint8_t *tupledata);
 101 static void     cardbus_read_tuple_finish(device_t cbdev, device_t child,
 102                     int rid, struct resource *res);
 103 static struct resource  *cardbus_read_tuple_init(device_t cbdev, device_t child,
 104                     uint32_t *start, int *rid);
 105 static int      decode_tuple(device_t cbdev, device_t child, int tupleid,
 106                     int len, uint8_t *tupledata, uint32_t start,
 107                     uint32_t *off, struct tuple_callbacks *callbacks,
 108                     void *);
 109 #define MAKETUPLE(NAME,FUNC) { CISTPL_ ## NAME, #NAME, decode_tuple_ ## FUNC }
 110
 111 static char *funcnames[] = {
 112         "Multi-Functioned",
 113         "Memory",
 114         "Serial Port",
 115         "Parallel Port",
 116         "Fixed Disk",
 117         "Video Adaptor",
 118         "Network Adaptor",
 119         "AIMS",
 120         "SCSI",
 121         "Security"
 122 };
 123
 124 /*
 125  * Handler functions for various CIS tuples
 126  */
 127
 128 static int
 129 decode_tuple_generic(device_t cbdev, device_t child, int id,
 130     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 131     struct tuple_callbacks *info, void *argp)
 132 {
 133         int i;
 134
 135         if (cardbus_cis_debug) {
 136                 if (info)
 137                         printf("TUPLE: %s [%d]:", info->name, len);
 138                 else
 139                         printf("TUPLE: Unknown(0x%02x) [%d]:", id, len);
 140
 141                 for (i = 0; i < len; i++) {
 142                         if (i % 0x10 == 0 && len > 0x10)
 143                                 printf("\n       0x%02x:", i);
 144                         printf(" %02x", tupledata[i]);
 145                 }
 146                 printf("\n");
 147         }
 148         return (0);
 149 }
 150
 151 static int
 152 decode_tuple_linktarget(device_t cbdev, device_t child, int id,
 153     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 154     struct tuple_callbacks *info, void *argp)
 155 {
 156         int i;
 157
 158         if (cardbus_cis_debug) {
 159                 printf("TUPLE: %s [%d]:", info->name, len);
 160
 161                 for (i = 0; i < len; i++) {
 162                         if (i % 0x10 == 0 && len > 0x10)
 163                                 printf("\n       0x%02x:", i);
 164                         printf(" %02x", tupledata[i]);
 165                 }
 166                 printf("\n");
 167         }
 168         if (len != 3 || tupledata[0] != 'C' || tupledata[1] != 'I' ||
 169             tupledata[2] != 'S') {
 170                 printf("Invalid data for CIS Link Target!\n");
 171                 decode_tuple_generic(cbdev, child, id, len, tupledata,
 172                     start, off, info, argp);
 173                 return (EINVAL);
 174         }
 175         return (0);
 176 }
 177
 178 static int
 179 decode_tuple_vers_1(device_t cbdev, device_t child, int id,
 180     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 181     struct tuple_callbacks *info, void *argp)
 182 {
 183         int i;
 184
 185         if (cardbus_cis_debug) {
 186                 printf("Product version: %d.%d\n", tupledata[0], tupledata[1]);
 187                 printf("Product name: ");
 188                 for (i = 2; i < len; i++) {
 189                         if (tupledata[i] == '\0')
 190                                 printf(" | ");
 191                         else if (tupledata[i] == 0xff)
 192                                 break;
 193                         else
 194                                 printf("%c", tupledata[i]);
 195                 }
 196                 printf("\n");
 197         }
 198         return (0);
 199 }
 200
 201 static int
 202 decode_tuple_funcid(device_t cbdev, device_t child, int id,
 203     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 204     struct tuple_callbacks *info, void *argp)
 205 {
 206         struct cardbus_devinfo *dinfo = device_get_ivars(child);
 207         int numnames = nitems(funcnames);
 208         int i;
 209
 210         if (cardbus_cis_debug) {
 211                 printf("Functions: ");
 212                 for (i = 0; i < len; i++) {
 213                         if (tupledata[i] < numnames)
 214                                 printf("%s", funcnames[tupledata[i]]);
 215                         else
 216                                 printf("Unknown(%d)", tupledata[i]);
 217                         if (i < len - 1)
 218                                 printf(", ");
 219                 }
 220                 printf("\n");
 221         }
 222         if (len > 0)
 223                 dinfo->funcid = tupledata[0];           /* use first in list */
 224         return (0);
 225 }
 226
 227 static int
 228 decode_tuple_manfid(device_t cbdev, device_t child, int id,
 229     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 230     struct tuple_callbacks *info, void *argp)
 231 {
 232         struct cardbus_devinfo *dinfo = device_get_ivars(child);
 233         int i;
 234
 235         if (cardbus_cis_debug) {
 236                 printf("Manufacturer ID: ");
 237                 for (i = 0; i < len; i++)
 238                         printf("%02x", tupledata[i]);
 239                 printf("\n");
 240         }
 241
 242         if (len == 5) {
 243                 dinfo->mfrid = tupledata[1] | (tupledata[2] << 8);
 244                 dinfo->prodid = tupledata[3] | (tupledata[4] << 8);
 245         }
 246         return (0);
 247 }
 248
 249 static int
 250 decode_tuple_funce(device_t cbdev, device_t child, int id,
 251     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 252     struct tuple_callbacks *info, void *argp)
 253 {
 254         struct cardbus_devinfo *dinfo = device_get_ivars(child);
 255         int type, i;
 256
 257         if (cardbus_cis_debug) {
 258                 printf("Function Extension: ");
 259                 for (i = 0; i < len; i++)
 260                         printf("%02x", tupledata[i]);
 261                 printf("\n");
 262         }
 263         if (len < 2)                    /* too short */
 264                 return (0);
 265         type = tupledata[0];            /* XXX <32 always? */
 266         switch (dinfo->funcid) {
 267         case PCCARD_FUNCTION_NETWORK:
 268                 switch (type) {
 269                 case PCCARD_TPLFE_TYPE_LAN_NID:
 270                         if (tupledata[1] > sizeof(dinfo->funce.lan.nid)) {
 271                                 /* ignore, warning? */
 272                                 return (0);
 273                         }
 274                         bcopy(tupledata + 2, dinfo->funce.lan.nid,
 275                             tupledata[1]);
 276                         break;
 277                 }
 278                 dinfo->fepresent |= 1<<type;
 279                 break;
 280         }
 281         return (0);
 282 }
 283
 284 static int
 285 decode_tuple_bar(device_t cbdev, device_t child, int id,
 286     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 287     struct tuple_callbacks *info, void *argp)
 288 {
 289         struct cardbus_devinfo *dinfo = device_get_ivars(child);
 290         int type;
 291         uint8_t reg;
 292         uint32_t bar;
 293
 294         if (len != 6) {
 295                 device_printf(cbdev, "CIS BAR length not 6 (%d)\n", len);
 296                 return (EINVAL);
 297         }
 298
 299         reg = *tupledata;
 300         len = le32toh(*(uint32_t*)(tupledata + 2));
 301         if (reg & TPL_BAR_REG_AS)
 302                 type = SYS_RES_IOPORT;
 303         else
 304                 type = SYS_RES_MEMORY;
 305
 306         bar = reg & TPL_BAR_REG_ASI_MASK;
 307         if (bar == 0) {
 308                 device_printf(cbdev, "Invalid BAR type 0 in CIS\n");
 309                 return (EINVAL);        /* XXX Return an error? */
 310         } else if (bar == 7) {
 311                 /* XXX Should we try to map in Option ROMs? */
 312                 return (0);
 313         }
 314
 315         /* Convert from BAR type to BAR offset */
 316         bar = PCIR_BAR(bar - 1);
 317
 318         if (type == SYS_RES_MEMORY) {
 319                 if (reg & TPL_BAR_REG_PREFETCHABLE)
 320                         dinfo->mprefetchable |= (1 << PCI_RID2BAR(bar));
 321                 /*
 322                  * The PC Card spec says we're only supposed to honor this
 323                  * hint when the cardbus bridge is a child of pci0 (the main
 324                  * bus).  The PC Card spec seems to indicate that this should
 325                  * only be done on x86 based machines, which suggests that on
 326                  * non-x86 machines the addresses can be anywhere.  Since the
 327                  * hardware can do it on non-x86 machines, it should be able
 328                  * to do it on x86 machines too.  Therefore, we can and should
 329                  * ignore this hint.  Furthermore, the PC Card spec recommends
 330                  * always allocating memory above 1MB, contradicting the other
 331                  * part of the PC Card spec, it seems.  We make note of it,
 332                  * but otherwise don't use this information.
 333                  *
 334                  * Some Realtek cards have this set in their CIS, but fail
 335                  * to actually work when mapped this way, and experience
 336                  * has shown ignoring this big to be a wise choice.
 337                  *
 338                  * XXX We should cite chapter and verse for standard refs.
 339                  */
 340                 if (reg & TPL_BAR_REG_BELOW1MB)
 341                         dinfo->mbelow1mb |= (1 << PCI_RID2BAR(bar));
 342         }
 343
 344         return (0);
 345 }
 346
 347 static int
 348 decode_tuple_unhandled(device_t cbdev, device_t child, int id,
 349     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 350     struct tuple_callbacks *info, void *argp)
 351 {
 352         /* Make this message suck less XXX */
 353         printf("TUPLE: %s [%d] is unhandled! Bailing...", info->name, len);
 354         return (EINVAL);
 355 }
 356
 357 static int
 358 decode_tuple_end(device_t cbdev, device_t child, int id,
 359     int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
 360     struct tuple_callbacks *info, void *argp)
 361 {
 362         if (cardbus_cis_debug)
 363                 printf("CIS reading done\n");
 364         return (0);
 365 }
 366
 367 /*
 368  * Functions to read the a tuple from the card
 369  */
 370
 371 /*
 372  * Read CIS bytes out of the config space.  We have to read it 4 bytes at a
 373  * time and do the usual mask and shift to return the bytes.  The standard
 374  * defines the byte order to be little endian.  pci_read_config converts it to
 375  * host byte order.  This is why we have no endian conversion functions: the
 376  * shifts wind up being endian neutral.  This is also why we avoid the obvious
 377  * memcpy optimization.
 378  */
 379 static int
 380 cardbus_read_tuple_conf(device_t cbdev, device_t child, uint32_t start,
 381     uint32_t *off, int *tupleid, int *len, uint8_t *tupledata)
 382 {
 383         int i, j;
 384         uint32_t e;
 385         uint32_t loc;
 386
 387         loc = start + *off;
 388
 389         e = pci_read_config(child, loc & ~0x3, 4);
 390         e >>= 8 * (loc & 0x3);
 391         *len = 0;
 392         for (i = loc, j = -2; j < *len; j++, i++) {
 393                 if ((i & 0x3) == 0)
 394                         e = pci_read_config(child, i, 4);
 395                 if (j == -2)
 396                         *tupleid = 0xff & e;
 397                 else if (j == -1)
 398                         *len = 0xff & e;
 399                 else
 400                         tupledata[j] = 0xff & e;
 401                 e >>= 8;
 402         }
 403         *off += *len + 2;
 404         return (0);
 405 }
 406
 407 /*
 408  * Read the CIS data out of memory.  We indirect through the bus space
 409  * routines to ensure proper byte ordering conversions when necessary.
 410  */
 411 static int
 412 cardbus_read_tuple_mem(device_t cbdev, struct resource *res, uint32_t start,
 413     uint32_t *off, int *tupleid, int *len, uint8_t *tupledata)
 414 {
 415         int ret;
 416
 417         *tupleid = bus_read_1(res, start + *off);
 418         *len = bus_read_1(res, start + *off + 1);
 419         bus_read_region_1(res, *off + start + 2, tupledata, *len);
 420         ret = 0;
 421         *off += *len + 2;
 422         return (ret);
 423 }
 424
 425 static int
 426 cardbus_read_tuple(device_t cbdev, device_t child, struct resource *res,
 427     uint32_t start, uint32_t *off, int *tupleid, int *len,
 428     uint8_t *tupledata)
 429 {
 430         if (res == CIS_CONFIG_SPACE)
 431                 return (cardbus_read_tuple_conf(cbdev, child, start, off,
 432                     tupleid, len, tupledata));
 433         return (cardbus_read_tuple_mem(cbdev, res, start, off, tupleid, len,
 434             tupledata));
 435 }
 436
 437 static void
 438 cardbus_read_tuple_finish(device_t cbdev, device_t child, int rid,
 439     struct resource *res)
 440 {
 441         if (res != CIS_CONFIG_SPACE) {
 442                 bus_release_resource(child, SYS_RES_MEMORY, rid, res);
 443                 bus_delete_resource(child, SYS_RES_MEMORY, rid);
 444         }
 445 }
 446
 447 static struct resource *
 448 cardbus_read_tuple_init(device_t cbdev, device_t child, uint32_t *start,
 449     int *rid)
 450 {
 451         struct resource *res;
 452         uint32_t space;
 453
 454         space = *start & PCIM_CIS_ASI_MASK;
 455         switch (space) {
 456         case PCIM_CIS_ASI_CONFIG:
 457                 DEVPRINTF((cbdev, "CIS in PCI config space\n"));
 458                 /* CIS in PCI config space need no initialization */
 459                 return (CIS_CONFIG_SPACE);
 460         case PCIM_CIS_ASI_BAR0:
 461         case PCIM_CIS_ASI_BAR1:
 462         case PCIM_CIS_ASI_BAR2:
 463         case PCIM_CIS_ASI_BAR3:
 464         case PCIM_CIS_ASI_BAR4:
 465         case PCIM_CIS_ASI_BAR5:
 466                 *rid = PCIR_BAR(space - PCIM_CIS_ASI_BAR0);
 467                 DEVPRINTF((cbdev, "CIS in BAR %#x\n", *rid));
 468                 break;
 469         case PCIM_CIS_ASI_ROM:
 470                 *rid = PCIR_BIOS;
 471                 DEVPRINTF((cbdev, "CIS in option rom\n"));
 472                 break;
 473         default:
 474                 device_printf(cbdev, "Unable to read CIS: Unknown space: %d\n",
 475                     space);
 476                 return (NULL);
 477         }
 478
 479         /* allocate the memory space to read CIS */
 480         res = bus_alloc_resource_any(child, SYS_RES_MEMORY, rid,
 481             rman_make_alignment_flags(4096) | RF_ACTIVE);
 482         if (res == NULL) {
 483                 device_printf(cbdev, "Unable to allocate resource "
 484                     "to read CIS.\n");
 485                 return (NULL);
 486         }
 487         DEVPRINTF((cbdev, "CIS Mapped to %#jx\n",
 488             rman_get_start(res)));
 489
 490         /* Flip to the right ROM image if CIS is in ROM */
 491         if (space == PCIM_CIS_ASI_ROM) {
 492                 uint32_t imagesize;
 493                 uint32_t imagebase = 0;
 494                 uint32_t pcidata;
 495                 uint16_t romsig;
 496                 int romnum = 0;
 497                 int imagenum;
 498
 499                 imagenum = (*start & PCIM_CIS_ROM_MASK) >> 28;
 500                 for (romnum = 0;; romnum++) {
 501                         romsig = bus_read_2(res,
 502                             imagebase + CARDBUS_EXROM_SIGNATURE);
 503                         if (romsig != 0xaa55) {
 504                                 device_printf(cbdev, "Bad header in rom %d: "
 505                                     "[%x] %04x\n", romnum, imagebase +
 506                                     CARDBUS_EXROM_SIGNATURE, romsig);
 507                                 cardbus_read_tuple_finish(cbdev, child, *rid,
 508                                     res);
 509                                 *rid = 0;
 510                                 return (NULL);
 511                         }
 512
 513                         /*
 514                          * If this was the Option ROM image that we were
 515                          * looking for, then we are done.
 516                          */
 517                         if (romnum == imagenum)
 518                                 break;
 519
 520                         /* Find out where the next Option ROM image is */
 521                         pcidata = imagebase + bus_read_2(res,
 522                             imagebase + CARDBUS_EXROM_DATA_PTR);
 523                         imagesize = bus_read_2(res,
 524                             pcidata + CARDBUS_EXROM_DATA_IMAGE_LENGTH);
 525
 526                         if (imagesize == 0) {
 527                                 /*
 528                                  * XXX some ROMs seem to have this as zero,
 529                                  * can we assume this means 1 block?
 530                                  */
 531                                 device_printf(cbdev, "Warning, size of Option "
 532                                     "ROM image %d is 0 bytes, assuming 512 "
 533                                     "bytes.\n", romnum);
 534                                 imagesize = 1;
 535                         }
 536
 537                         /* Image size is in 512 byte units */
 538                         imagesize <<= 9;
 539
 540                         if ((bus_read_1(res, pcidata +
 541                             CARDBUS_EXROM_DATA_INDICATOR) & 0x80) != 0) {
 542                                 device_printf(cbdev, "Cannot find CIS in "
 543                                     "Option ROM\n");
 544                                 cardbus_read_tuple_finish(cbdev, child, *rid,
 545                                     res);
 546                                 *rid = 0;
 547                                 return (NULL);
 548                         }
 549                         imagebase += imagesize;
 550                 }
 551                 *start = imagebase + (*start & PCIM_CIS_ADDR_MASK);
 552         } else {
 553                 *start = *start & PCIM_CIS_ADDR_MASK;
 554         }
 555         DEVPRINTF((cbdev, "CIS offset is %#x\n", *start));
 556
 557         return (res);
 558 }
 559
 560 /*
 561  * Dispatch the right handler function per tuple
 562  */
 563
 564 static int
 565 decode_tuple(device_t cbdev, device_t child, int tupleid, int len,
 566     uint8_t *tupledata, uint32_t start, uint32_t *off,
 567     struct tuple_callbacks *callbacks, void *argp)
 568 {
 569         int i;
 570         for (i = 0; callbacks[i].id != CISTPL_GENERIC; i++) {
 571                 if (tupleid == callbacks[i].id)
 572                         return (callbacks[i].func(cbdev, child, tupleid, len,
 573                             tupledata, start, off, &callbacks[i], argp));
 574         }
 575         return (callbacks[i].func(cbdev, child, tupleid, len,
 576             tupledata, start, off, NULL, argp));
 577 }
 578
 579 int
 580 cardbus_parse_cis(device_t cbdev, device_t child,
 581     struct tuple_callbacks *callbacks, void *argp)
 582 {
 583         uint8_t *tupledata;
 584         int tupleid = CISTPL_NULL;
 585         int len;
 586         int expect_linktarget;
 587         uint32_t start, off;
 588         struct resource *res;
 589         int rid;
 590
 591         tupledata = malloc(MAXTUPLESIZE, M_DEVBUF, M_WAITOK | M_ZERO);
 592         expect_linktarget = TRUE;
 593         if ((start = pci_read_config(child, PCIR_CIS, 4)) == 0) {
 594                 DEVPRINTF((cbdev, "Warning: CIS pointer is 0: (no CIS)\n"));
 595                 free(tupledata, M_DEVBUF);
 596                 return (0);
 597         }
 598         DEVPRINTF((cbdev, "CIS pointer is %#x\n", start));
 599         off = 0;
 600         res = cardbus_read_tuple_init(cbdev, child, &start, &rid);
 601         if (res == NULL) {
 602                 device_printf(cbdev, "Unable to allocate resources for CIS\n");
 603                 free(tupledata, M_DEVBUF);
 604                 return (ENXIO);
 605         }
 606
 607         do {
 608                 if (cardbus_read_tuple(cbdev, child, res, start, &off,
 609                     &tupleid, &len, tupledata) != 0) {
 610                         device_printf(cbdev, "Failed to read CIS.\n");
 611                         cardbus_read_tuple_finish(cbdev, child, rid, res);
 612                         free(tupledata, M_DEVBUF);
 613                         return (ENXIO);
 614                 }
 615
 616                 if (expect_linktarget && tupleid != CISTPL_LINKTARGET) {
 617                         device_printf(cbdev, "Expecting link target, got 0x%x\n",
 618                             tupleid);
 619                         cardbus_read_tuple_finish(cbdev, child, rid, res);
 620                         free(tupledata, M_DEVBUF);
 621                         return (EINVAL);
 622                 }
 623                 expect_linktarget = decode_tuple(cbdev, child, tupleid, len,
 624                     tupledata, start, &off, callbacks, argp);
 625                 if (expect_linktarget != 0) {
 626                         device_printf(cbdev, "Parsing failed with %d\n",
 627                             expect_linktarget);
 628                         cardbus_read_tuple_finish(cbdev, child, rid, res);
 629                         free(tupledata, M_DEVBUF);
 630                         return (expect_linktarget);
 631                 }
 632         } while (tupleid != CISTPL_END);
 633         cardbus_read_tuple_finish(cbdev, child, rid, res);
 634         free(tupledata, M_DEVBUF);
 635         return (0);
 636 }
 637
 638 int
 639 cardbus_do_cis(device_t cbdev, device_t child)
 640 {
 641         struct tuple_callbacks init_callbacks[] = {
 642                 MAKETUPLE(LONGLINK_CB,          unhandled),
 643                 MAKETUPLE(INDIRECT,             unhandled),
 644                 MAKETUPLE(LONGLINK_MFC,         unhandled),
 645                 MAKETUPLE(BAR,                  bar),
 646                 MAKETUPLE(LONGLINK_A,           unhandled),
 647                 MAKETUPLE(LONGLINK_C,           unhandled),
 648                 MAKETUPLE(LINKTARGET,           linktarget),
 649                 MAKETUPLE(VERS_1,               vers_1),
 650                 MAKETUPLE(MANFID,               manfid),
 651                 MAKETUPLE(FUNCID,               funcid),
 652                 MAKETUPLE(FUNCE,                funce),
 653                 MAKETUPLE(END,                  end),
 654                 MAKETUPLE(GENERIC,              generic),
 655         };
 656
 657         return (cardbus_parse_cis(cbdev, child, init_callbacks, NULL));
 658 }