sys/bus/pccard/pccard_cis.c

   1 /* $NetBSD: pcmcia_cis.c,v 1.17 2000/02/10 09:01:52 chopps Exp $ */
   2 /* $FreeBSD: src/sys/dev/pccard/pccard_cis.c,v 1.36 2005/07/17 20:16:22 imp Exp $ */
   3 /* $DragonFly: src/sys/bus/pccard/pccard_cis.c,v 1.8 2007/07/05 12:08:53 sephe Exp $ */
   4
   5 /*-
   6  * Copyright (c) 1997 Marc Horowitz.  All rights reserved.
   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  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Marc Horowitz.
  19  * 4. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/kernel.h>
  39 #include <sys/queue.h>
  40 #include <sys/types.h>
  41
  42 #include <sys/bus.h>
  43 #include <sys/rman.h>
  44
  45 #include <bus/pccard/pccardreg.h>
  46 #include <bus/pccard/pccardvar.h>
  47 #include <bus/pccard/pccard_cis.h>
  48
  49 #include "card_if.h"
  50
  51 extern int      pccard_cis_debug;
  52
  53 #define PCCARDCISDEBUG
  54 #ifdef PCCARDCISDEBUG
  55 #define DPRINTF(arg) do { if (pccard_cis_debug) kprintf arg; } while (0)
  56 #define DEVPRINTF(arg) do { if (pccard_cis_debug) device_printf arg; } while (0)
  57 #else
  58 #define DPRINTF(arg)
  59 #define DEVPRINTF(arg)
  60 #endif
  61
  62 #define PCCARD_CIS_SIZE         4096
  63
  64 struct cis_state {
  65         int     count;
  66         int     gotmfc;
  67         struct pccard_config_entry temp_cfe;
  68         struct pccard_config_entry *default_cfe;
  69         struct pccard_card *card;
  70         struct pccard_function *pf;
  71 };
  72
  73 static int pccard_parse_cis_tuple(const struct pccard_tuple *, void *);
  74 static int decode_funce(const struct pccard_tuple *, struct pccard_function *);
  75
  76 void
  77 pccard_read_cis(struct pccard_softc *sc)
  78 {
  79         struct cis_state state;
  80
  81         bzero(&state, sizeof state);
  82         state.card = &sc->card;
  83         state.card->error = 0;
  84         state.card->cis1_major = -1;
  85         state.card->cis1_minor = -1;
  86         state.card->cis1_info[0] = NULL;
  87         state.card->cis1_info[1] = NULL;
  88         state.card->cis1_info[2] = NULL;
  89         state.card->cis1_info[3] = NULL;
  90         state.card->manufacturer = PCMCIA_VENDOR_INVALID;
  91         state.card->product = PCMCIA_PRODUCT_INVALID;
  92         STAILQ_INIT(&state.card->pf_head);
  93         state.pf = NULL;
  94
  95         if (pccard_scan_cis(sc->dev, pccard_parse_cis_tuple, &state) == -1)
  96                 state.card->error++;
  97 }
  98
  99 int
 100 pccard_scan_cis(device_t dev, pccard_scan_t fct, void *arg)
 101 {
 102         struct resource *res;
 103         int rid;
 104         struct pccard_tuple tuple;
 105         int longlink_present;
 106         int longlink_common;
 107         u_long longlink_addr;           /* Type suspect */
 108         int mfc_count;
 109         int mfc_index;
 110 #ifdef PCCARDCISDEBUG
 111         int cis_none_cnt = 10;  /* Only report 10 CIS_NONEs */
 112 #endif
 113         struct {
 114                 int     common;
 115                 u_long  addr;
 116         } mfc[256 / 5];
 117         int ret;
 118
 119         ret = 0;
 120
 121         /* allocate some memory */
 122
 123         /*
 124          * Some reports from the field suggest that a 64k memory boundary
 125          * helps card CIS being able to be read.  Try it here and see what
 126          * the results actually are.  I'm not sure I understand why this
 127          * would make cards work better, but it is easy enough to test.
 128          */
 129         rid = 0;
 130         res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0, ~0,
 131             PCCARD_CIS_SIZE, RF_ACTIVE | rman_make_alignment_flags(64*1024));
 132         if (res == NULL) {
 133                 device_printf(dev, "can't alloc memory to read attributes\n");
 134                 return -1;
 135         }
 136         CARD_SET_RES_FLAGS(device_get_parent(dev), dev, SYS_RES_MEMORY,
 137             rid, PCCARD_A_MEM_ATTR);
 138         tuple.memt = rman_get_bustag(res);
 139         tuple.memh = rman_get_bushandle(res);
 140         tuple.ptr = 0;
 141
 142         DPRINTF(("cis mem map 0x%x (resource: 0x%lx)\n",
 143             (unsigned int) tuple.memh, rman_get_start(res)));
 144
 145         tuple.mult = 2;
 146
 147         longlink_present = 1;
 148         longlink_common = 1;
 149         longlink_addr = 0;
 150
 151         mfc_count = 0;
 152         mfc_index = 0;
 153
 154         DEVPRINTF((dev, "CIS tuple chain:\n"));
 155
 156         while (1) {
 157                 while (1) {
 158                         /*
 159                          * Perform boundary check for insane cards.
 160                          * If CIS is too long, simulate CIS end.
 161                          * (This check may not be sufficient for
 162                          * malicious cards.)
 163                          */
 164                         if (tuple.mult * tuple.ptr >= PCCARD_CIS_SIZE - 1
 165                             - 32 /* ad hoc value */ ) {
 166                                 kprintf("CIS is too long -- truncating\n");
 167                                 tuple.code = CISTPL_END;
 168                         } else {
 169                                 /* get the tuple code */
 170                                 tuple.code = pccard_cis_read_1(&tuple, tuple.ptr);
 171                         }
 172
 173                         /* two special-case tuples */
 174
 175                         if (tuple.code == CISTPL_NULL) {
 176 #ifdef PCCARDCISDEBUG
 177                                 if (cis_none_cnt > 0)
 178                                         DPRINTF(("CISTPL_NONE\n 00\n"));
 179                                 else if (cis_none_cnt == 0)
 180                                         DPRINTF(("TOO MANY CIS_NONE\n"));
 181                                 cis_none_cnt--;
 182 #endif
 183                                 tuple.ptr++;
 184                                 continue;
 185                         } else if (tuple.code == CISTPL_END) {
 186                                 DPRINTF(("CISTPL_END\n ff\n"));
 187                                 /* Call the function for the END tuple, since
 188                                    the CIS semantics depend on it */
 189                                 if ((*fct)(&tuple, arg)) {
 190                                         ret = 1;
 191                                         goto done;
 192                                 }
 193                                 tuple.ptr++;
 194                                 break;
 195                         }
 196                         /* now all the normal tuples */
 197
 198                         tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
 199                         switch (tuple.code) {
 200                         case CISTPL_LONGLINK_A:
 201                         case CISTPL_LONGLINK_C:
 202                                 if (tuple.length < 4) {
 203                                         DPRINTF(("CISTPL_LONGLINK_%s too "
 204                                             "short %d\n",
 205                                             longlink_common ? "C" : "A",
 206                                             tuple.length));
 207                                         break;
 208                                 }
 209                                 longlink_present = 1;
 210                                 longlink_common = (tuple.code ==
 211                                     CISTPL_LONGLINK_C) ? 1 : 0;
 212                                 longlink_addr = pccard_tuple_read_4(&tuple, 0);
 213                                 DPRINTF(("CISTPL_LONGLINK_%s %lx\n",
 214                                     longlink_common ? "C" : "A",
 215                                     longlink_addr));
 216                                 break;
 217                         case CISTPL_NO_LINK:
 218                                 longlink_present = 0;
 219                                 DPRINTF(("CISTPL_NO_LINK\n"));
 220                                 break;
 221                         case CISTPL_CHECKSUM:
 222                                 if (tuple.length < 5) {
 223                                         DPRINTF(("CISTPL_CHECKSUM too "
 224                                             "short %d\n", tuple.length));
 225                                         break;
 226                                 } {
 227                                         int16_t offset;
 228                                         u_long addr, length;
 229                                         u_int cksum, sum;
 230                                         int i;
 231
 232                                         offset = (uint16_t)
 233                                             pccard_tuple_read_2(&tuple, 0);
 234                                         length = pccard_tuple_read_2(&tuple, 2);
 235                                         cksum = pccard_tuple_read_1(&tuple, 4);
 236
 237                                         addr = tuple.ptr + offset;
 238
 239                                         DPRINTF(("CISTPL_CHECKSUM addr=%lx "
 240                                             "len=%lx cksum=%x",
 241                                             addr, length, cksum));
 242
 243                                         /*
 244                                          * XXX do more work to deal with
 245                                          * distant regions
 246                                          */
 247                                         if ((addr >= PCCARD_CIS_SIZE) ||
 248                                             ((addr + length) >=
 249                                             PCCARD_CIS_SIZE)) {
 250                                                 DPRINTF((" skipped, "
 251                                                     "too distant\n"));
 252                                                 break;
 253                                         }
 254                                         sum = 0;
 255                                         for (i = 0; i < length; i++)
 256                                                 sum +=
 257                                                     bus_space_read_1(tuple.memt,
 258                                                     tuple.memh,
 259                                                     addr + tuple.mult * i);
 260                                         if (cksum != (sum & 0xff)) {
 261                                                 DPRINTF((" failed sum=%x\n",
 262                                                     sum));
 263                                                 device_printf(dev,
 264                                                     "CIS checksum failed\n");
 265 #if 0
 266                                                 /*
 267                                                  * XXX Some working cards have
 268                                                  * XXX bad checksums!!
 269                                                  */
 270                                                 ret = -1;
 271 #endif
 272                                         } else {
 273                                                 DPRINTF((" ok\n"));
 274                                         }
 275                                 }
 276                                 break;
 277                         case CISTPL_LONGLINK_MFC:
 278                                 if (tuple.length < 1) {
 279                                         DPRINTF(("CISTPL_LONGLINK_MFC too "
 280                                             "short %d\n", tuple.length));
 281                                         break;
 282                                 }
 283                                 if (((tuple.length - 1) % 5) != 0) {
 284                                         DPRINTF(("CISTPL_LONGLINK_MFC bogus "
 285                                             "length %d\n", tuple.length));
 286                                         break;
 287                                 }
 288                                 /*
 289                                  * this is kind of ad hoc, as I don't have
 290                                  * any real documentation
 291                                  */
 292                                 {
 293                                         int i, tmp_count;
 294
 295                                         /*
 296                                          * put count into tmp var so that
 297                                          * if we have to bail (because it's
 298                                          * a bogus count) it won't be
 299                                          * remembered for later use.
 300                                          */
 301                                         tmp_count =
 302                                             pccard_tuple_read_1(&tuple, 0);
 303
 304                                         DPRINTF(("CISTPL_LONGLINK_MFC %d",
 305                                             tmp_count));
 306
 307                                         /*
 308                                          * make _sure_ it's the right size;
 309                                          * if too short, it may be a weird
 310                                          * (unknown/undefined) format
 311                                          */
 312                                         if (tuple.length != (tmp_count*5 + 1)) {
 313                                                 DPRINTF((" bogus length %d\n",
 314                                                     tuple.length));
 315                                                 break;
 316                                         }
 317                                         /*
 318                                          * sanity check for a programming
 319                                          * error which is difficult to find
 320                                          * when debugging.
 321                                          */
 322                                         if (tmp_count >
 323                                             howmany(sizeof mfc, sizeof mfc[0]))
 324                                                 panic("CISTPL_LONGLINK_MFC mfc "
 325                                                     "count would blow stack");
 326                                         mfc_count = tmp_count;
 327                                         for (i = 0; i < mfc_count; i++) {
 328                                                 mfc[i].common =
 329                                                     (pccard_tuple_read_1(&tuple,
 330                                                     1 + 5 * i) ==
 331                                                     PCCARD_MFC_MEM_COMMON) ?
 332                                                     1 : 0;
 333                                                 mfc[i].addr =
 334                                                     pccard_tuple_read_4(&tuple,
 335                                                     1 + 5 * i + 1);
 336                                                 DPRINTF((" %s:%lx",
 337                                                     mfc[i].common ? "common" :
 338                                                     "attr", mfc[i].addr));
 339                                         }
 340                                         DPRINTF(("\n"));
 341                                 }
 342                                 /*
 343                                  * for LONGLINK_MFC, fall through to the
 344                                  * function.  This tuple has structural and
 345                                  * semantic content.
 346                                  */
 347                         default:
 348                                 {
 349                                         if ((*fct)(&tuple, arg)) {
 350                                                 ret = 1;
 351                                                 goto done;
 352                                         }
 353                                 }
 354                                 break;
 355                         }       /* switch */
 356 #ifdef PCCARDCISDEBUG
 357                         /* print the tuple */
 358                         {
 359                                 int i;
 360
 361                                 DPRINTF((" %02x %02x", tuple.code,
 362                                     tuple.length));
 363
 364                                 for (i = 0; i < tuple.length; i++) {
 365                                         DPRINTF((" %02x",
 366                                             pccard_tuple_read_1(&tuple, i)));
 367                                         if ((i % 16) == 13)
 368                                                 DPRINTF(("\n"));
 369                                 }
 370
 371                                 if ((i % 16) != 14)
 372                                         DPRINTF(("\n"));
 373                         }
 374 #endif
 375                         /* skip to the next tuple */
 376                         tuple.ptr += 2 + tuple.length;
 377                 }
 378
 379                 /*
 380                  * the chain is done.  Clean up and move onto the next one,
 381                  * if any.  The loop is here in the case that there is an MFC
 382                  * card with no longlink (which defaults to existing, == 0).
 383                  * In general, this means that if one pointer fails, it will
 384                  * try the next one, instead of just bailing.
 385                  */
 386                 while (1) {
 387                         if (longlink_present) {
 388                                 CARD_SET_RES_FLAGS(device_get_parent(dev), dev,
 389                                     SYS_RES_MEMORY, rid, longlink_common ?
 390                                     PCCARD_A_MEM_COM : PCCARD_A_MEM_ATTR);
 391                                 DPRINTF(("cis mem map %x\n",
 392                                     (unsigned int) tuple.memh));
 393                                 tuple.mult = longlink_common ? 1 : 2;
 394                                 tuple.ptr = longlink_addr;
 395                                 longlink_present = 0;
 396                                 longlink_common = 1;
 397                                 longlink_addr = 0;
 398                         } else if (mfc_count && (mfc_index < mfc_count)) {
 399                                 CARD_SET_RES_FLAGS(device_get_parent(dev), dev,
 400                                     SYS_RES_MEMORY, rid, mfc[mfc_index].common
 401                                     ? PCCARD_A_MEM_COM : PCCARD_A_MEM_ATTR);
 402                                 DPRINTF(("cis mem map %x\n",
 403                                     (unsigned int) tuple.memh));
 404                                 /* set parse state, and point at the next one */
 405                                 tuple.mult = mfc[mfc_index].common ? 1 : 2;
 406                                 tuple.ptr = mfc[mfc_index].addr;
 407                                 mfc_index++;
 408                         } else {
 409                                 goto done;
 410                         }
 411
 412                         /* make sure that the link is valid */
 413                         tuple.code = pccard_cis_read_1(&tuple, tuple.ptr);
 414                         if (tuple.code != CISTPL_LINKTARGET) {
 415                                 DPRINTF(("CISTPL_LINKTARGET expected, "
 416                                     "code %02x observed\n", tuple.code));
 417                                 continue;
 418                         }
 419                         tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
 420                         if (tuple.length < 3) {
 421                                 DPRINTF(("CISTPL_LINKTARGET too short %d\n",
 422                                     tuple.length));
 423                                 continue;
 424                         }
 425                         if ((pccard_tuple_read_1(&tuple, 0) != 'C') ||
 426                             (pccard_tuple_read_1(&tuple, 1) != 'I') ||
 427                             (pccard_tuple_read_1(&tuple, 2) != 'S')) {
 428                                 DPRINTF(("CISTPL_LINKTARGET magic "
 429                                     "%02x%02x%02x incorrect\n",
 430                                     pccard_tuple_read_1(&tuple, 0),
 431                                     pccard_tuple_read_1(&tuple, 1),
 432                                     pccard_tuple_read_1(&tuple, 2)));
 433                                 continue;
 434                         }
 435                         tuple.ptr += 2 + tuple.length;
 436                         break;
 437                 }
 438         }
 439
 440 done:
 441         bus_release_resource(dev, SYS_RES_MEMORY, rid, res);
 442
 443         return (ret);
 444 }
 445
 446 /* XXX this is incredibly verbose.  Not sure what trt is */
 447
 448 void
 449 pccard_print_cis(device_t dev)
 450 {
 451         struct pccard_softc *sc = PCCARD_SOFTC(dev);
 452         struct pccard_card *card = &sc->card;
 453         struct pccard_function *pf;
 454         struct pccard_config_entry *cfe;
 455         int i;
 456
 457         device_printf(dev, "CIS version ");
 458         if (card->cis1_major == 4) {
 459                 if (card->cis1_minor == 0)
 460                         kprintf("PCCARD 1.0\n");
 461                 else if (card->cis1_minor == 1)
 462                         kprintf("PCCARD 2.0 or 2.1\n");
 463         } else if (card->cis1_major >= 5)
 464                 kprintf("PC Card Standard %d.%d\n", card->cis1_major, card->cis1_minor);
 465         else
 466                 kprintf("unknown (major=%d, minor=%d)\n",
 467                     card->cis1_major, card->cis1_minor);
 468
 469         device_printf(dev, "CIS info: ");
 470         for (i = 0; i < 4; i++) {
 471                 if (card->cis1_info[i] == NULL)
 472                         break;
 473                 if (i)
 474                         kprintf(", ");
 475                 kprintf("%s", card->cis1_info[i]);
 476         }
 477         kprintf("\n");
 478
 479         device_printf(dev, "Manufacturer code 0x%x, product 0x%x\n",
 480             card->manufacturer, card->product);
 481
 482         STAILQ_FOREACH(pf, &card->pf_head, pf_list) {
 483                 device_printf(dev, "function %d: ", pf->number);
 484
 485                 switch (pf->function) {
 486                 case PCCARD_FUNCTION_UNSPEC:
 487                         kprintf("unspecified");
 488                         break;
 489                 case PCCARD_FUNCTION_MULTIFUNCTION:
 490                         kprintf("multi-function");
 491                         break;
 492                 case PCCARD_FUNCTION_MEMORY:
 493                         kprintf("memory");
 494                         break;
 495                 case PCCARD_FUNCTION_SERIAL:
 496                         kprintf("serial port");
 497                         break;
 498                 case PCCARD_FUNCTION_PARALLEL:
 499                         kprintf("parallel port");
 500                         break;
 501                 case PCCARD_FUNCTION_DISK:
 502                         kprintf("fixed disk");
 503                         break;
 504                 case PCCARD_FUNCTION_VIDEO:
 505                         kprintf("video adapter");
 506                         break;
 507                 case PCCARD_FUNCTION_NETWORK:
 508                         kprintf("network adapter");
 509                         break;
 510                 case PCCARD_FUNCTION_AIMS:
 511                         kprintf("auto incrementing mass storage");
 512                         break;
 513                 case PCCARD_FUNCTION_SCSI:
 514                         kprintf("SCSI bridge");
 515                         break;
 516                 case PCCARD_FUNCTION_SECURITY:
 517                         kprintf("Security services");
 518                         break;
 519                 case PCCARD_FUNCTION_INSTRUMENT:
 520                         kprintf("Instrument");
 521                         break;
 522                 default:
 523                         kprintf("unknown (%d)", pf->function);
 524                         break;
 525                 }
 526
 527                 kprintf(", ccr addr %x mask %x\n", pf->ccr_base, pf->ccr_mask);
 528
 529                 STAILQ_FOREACH(cfe, &pf->cfe_head, cfe_list) {
 530                         device_printf(dev, "function %d, config table entry "
 531                             "%d: ", pf->number, cfe->number);
 532
 533                         switch (cfe->iftype) {
 534                         case PCCARD_IFTYPE_MEMORY:
 535                                 kprintf("memory card");
 536                                 break;
 537                         case PCCARD_IFTYPE_IO:
 538                                 kprintf("I/O card");
 539                                 break;
 540                         default:
 541                                 kprintf("card type unknown");
 542                                 break;
 543                         }
 544
 545                         kprintf("; irq mask %x", cfe->irqmask);
 546
 547                         if (cfe->num_iospace) {
 548                                 kprintf("; iomask %lx, iospace", cfe->iomask);
 549
 550                                 for (i = 0; i < cfe->num_iospace; i++) {
 551                                         kprintf(" %lx", cfe->iospace[i].start);
 552                                         if (cfe->iospace[i].length)
 553                                                 kprintf("-%lx",
 554                                                     cfe->iospace[i].start +
 555                                                     cfe->iospace[i].length - 1);
 556                                 }
 557                         }
 558                         if (cfe->num_memspace) {
 559                                 kprintf("; memspace");
 560
 561                                 for (i = 0; i < cfe->num_memspace; i++) {
 562                                         kprintf(" %lx",
 563                                             cfe->memspace[i].cardaddr);
 564                                         if (cfe->memspace[i].length)
 565                                                 kprintf("-%lx",
 566                                                     cfe->memspace[i].cardaddr +
 567                                                     cfe->memspace[i].length - 1);
 568                                         if (cfe->memspace[i].hostaddr)
 569                                                 kprintf("@%lx",
 570                                                     cfe->memspace[i].hostaddr);
 571                                 }
 572                         }
 573                         if (cfe->maxtwins)
 574                                 kprintf("; maxtwins %d", cfe->maxtwins);
 575
 576                         kprintf(";");
 577
 578                         if (cfe->flags & PCCARD_CFE_MWAIT_REQUIRED)
 579                                 kprintf(" mwait_required");
 580                         if (cfe->flags & PCCARD_CFE_RDYBSY_ACTIVE)
 581                                 kprintf(" rdybsy_active");
 582                         if (cfe->flags & PCCARD_CFE_WP_ACTIVE)
 583                                 kprintf(" wp_active");
 584                         if (cfe->flags & PCCARD_CFE_BVD_ACTIVE)
 585                                 kprintf(" bvd_active");
 586                         if (cfe->flags & PCCARD_CFE_IO8)
 587                                 kprintf(" io8");
 588                         if (cfe->flags & PCCARD_CFE_IO16)
 589                                 kprintf(" io16");
 590                         if (cfe->flags & PCCARD_CFE_IRQSHARE)
 591                                 kprintf(" irqshare");
 592                         if (cfe->flags & PCCARD_CFE_IRQPULSE)
 593                                 kprintf(" irqpulse");
 594                         if (cfe->flags & PCCARD_CFE_IRQLEVEL)
 595                                 kprintf(" irqlevel");
 596                         if (cfe->flags & PCCARD_CFE_POWERDOWN)
 597                                 kprintf(" powerdown");
 598                         if (cfe->flags & PCCARD_CFE_READONLY)
 599                                 kprintf(" readonly");
 600                         if (cfe->flags & PCCARD_CFE_AUDIO)
 601                                 kprintf(" audio");
 602
 603                         kprintf("\n");
 604                 }
 605         }
 606
 607         if (card->error)
 608                 device_printf(dev, "%d errors found while parsing CIS\n",
 609                     card->error);
 610 }
 611
 612 static int
 613 pccard_parse_cis_tuple(const struct pccard_tuple *tuple, void *arg)
 614 {
 615         /* most of these are educated guesses */
 616         static struct pccard_config_entry init_cfe = {
 617                 -1, PCCARD_CFE_RDYBSY_ACTIVE | PCCARD_CFE_WP_ACTIVE |
 618                 PCCARD_CFE_BVD_ACTIVE, PCCARD_IFTYPE_MEMORY,
 619         };
 620
 621         struct cis_state *state = arg;
 622
 623         switch (tuple->code) {
 624         case CISTPL_END:
 625                 /* if we've seen a LONGLINK_MFC, and this is the first
 626                  * END after it, reset the function list.
 627                  *
 628                  * XXX This might also be the right place to start a
 629                  * new function, but that assumes that a function
 630                  * definition never crosses any longlink, and I'm not
 631                  * sure about that.  This is probably safe for MFC
 632                  * cards, but what we have now isn't broken, so I'd
 633                  * rather not change it.
 634                  */
 635                 if (state->gotmfc == 1) {
 636                         struct pccard_function *pf, *pfnext;
 637
 638                         for (pf = STAILQ_FIRST(&state->card->pf_head);
 639                              pf != NULL; pf = pfnext) {
 640                                 pfnext = STAILQ_NEXT(pf, pf_list);
 641                                 kfree(pf, M_DEVBUF);
 642                         }
 643
 644                         STAILQ_INIT(&state->card->pf_head);
 645
 646                         state->count = 0;
 647                         state->gotmfc = 2;
 648                         state->pf = NULL;
 649                 }
 650                 break;
 651         case CISTPL_LONGLINK_MFC:
 652                 /*
 653                  * this tuple's structure was dealt with in scan_cis.  here,
 654                  * record the fact that the MFC tuple was seen, so that
 655                  * functions declared before the MFC link can be cleaned
 656                  * up.
 657                  */
 658                 state->gotmfc = 1;
 659                 break;
 660 #ifdef PCCARDCISDEBUG
 661         case CISTPL_DEVICE:
 662         case CISTPL_DEVICE_A:
 663                 {
 664                         u_int reg, dtype, dspeed;
 665
 666                         reg = pccard_tuple_read_1(tuple, 0);
 667                         dtype = reg & PCCARD_DTYPE_MASK;
 668                         dspeed = reg & PCCARD_DSPEED_MASK;
 669
 670                         DPRINTF(("CISTPL_DEVICE%s type=",
 671                         (tuple->code == CISTPL_DEVICE) ? "" : "_A"));
 672                         switch (dtype) {
 673                         case PCCARD_DTYPE_NULL:
 674                                 DPRINTF(("null"));
 675                                 break;
 676                         case PCCARD_DTYPE_ROM:
 677                                 DPRINTF(("rom"));
 678                                 break;
 679                         case PCCARD_DTYPE_OTPROM:
 680                                 DPRINTF(("otprom"));
 681                                 break;
 682                         case PCCARD_DTYPE_EPROM:
 683                                 DPRINTF(("eprom"));
 684                                 break;
 685                         case PCCARD_DTYPE_EEPROM:
 686                                 DPRINTF(("eeprom"));
 687                                 break;
 688                         case PCCARD_DTYPE_FLASH:
 689                                 DPRINTF(("flash"));
 690                                 break;
 691                         case PCCARD_DTYPE_SRAM:
 692                                 DPRINTF(("sram"));
 693                                 break;
 694                         case PCCARD_DTYPE_DRAM:
 695                                 DPRINTF(("dram"));
 696                                 break;
 697                         case PCCARD_DTYPE_FUNCSPEC:
 698                                 DPRINTF(("funcspec"));
 699                                 break;
 700                         case PCCARD_DTYPE_EXTEND:
 701                                 DPRINTF(("extend"));
 702                                 break;
 703                         default:
 704                                 DPRINTF(("reserved"));
 705                                 break;
 706                         }
 707                         DPRINTF((" speed="));
 708                         switch (dspeed) {
 709                         case PCCARD_DSPEED_NULL:
 710                                 DPRINTF(("null"));
 711                                 break;
 712                         case PCCARD_DSPEED_250NS:
 713                                 DPRINTF(("250ns"));
 714                                 break;
 715                         case PCCARD_DSPEED_200NS:
 716                                 DPRINTF(("200ns"));
 717                                 break;
 718                         case PCCARD_DSPEED_150NS:
 719                                 DPRINTF(("150ns"));
 720                                 break;
 721                         case PCCARD_DSPEED_100NS:
 722                                 DPRINTF(("100ns"));
 723                                 break;
 724                         case PCCARD_DSPEED_EXT:
 725                                 DPRINTF(("ext"));
 726                                 break;
 727                         default:
 728                                 DPRINTF(("reserved"));
 729                                 break;
 730                         }
 731                 }
 732                 DPRINTF(("\n"));
 733                 break;
 734 #endif
 735         case CISTPL_VERS_1:
 736                 if (tuple->length < 6) {
 737                         DPRINTF(("CISTPL_VERS_1 too short %d\n",
 738                             tuple->length));
 739                         break;
 740                 } {
 741                         int start, i, ch, count;
 742
 743                         state->card->cis1_major = pccard_tuple_read_1(tuple, 0);
 744                         state->card->cis1_minor = pccard_tuple_read_1(tuple, 1);
 745
 746                         for (count = 0, start = 0, i = 0;
 747                             (count < 4) && ((i + 4) < 256); i++) {
 748                                 ch = pccard_tuple_read_1(tuple, 2 + i);
 749                                 if (ch == 0xff)
 750                                         break;
 751                                 state->card->cis1_info_buf[i] = ch;
 752                                 if (ch == 0) {
 753                                         state->card->cis1_info[count] =
 754                                             state->card->cis1_info_buf + start;
 755                                         start = i + 1;
 756                                         count++;
 757                                 }
 758                         }
 759                         DPRINTF(("CISTPL_VERS_1\n"));
 760                 }
 761                 break;
 762         case CISTPL_MANFID:
 763                 if (tuple->length < 4) {
 764                         DPRINTF(("CISTPL_MANFID too short %d\n",
 765                             tuple->length));
 766                         break;
 767                 }
 768                 state->card->manufacturer = pccard_tuple_read_2(tuple, 0);
 769                 state->card->product = pccard_tuple_read_2(tuple, 2);
 770                 /*
 771                  * This is for xe driver. But not limited to that driver.
 772                  * In PC Card Standard,
 773                  * Manufacturer ID: 2byte.
 774                  * Product ID: typically 2bytes, but there's no limit on its
 775                  * size.  prodext is a two byte field, so maybe we should
 776                  * also handle the '6' case.  So far no cards have surfaced
 777                  * with a length of '6'.
 778                  */
 779                 if (tuple->length == 5 )
 780                         state->card->prodext = pccard_tuple_read_1(tuple, 4);
 781                 DPRINTF(("CISTPL_MANFID\n"));
 782                 break;
 783         case CISTPL_FUNCID:
 784                 if (tuple->length < 1) {
 785                         DPRINTF(("CISTPL_FUNCID too short %d\n",
 786                             tuple->length));
 787                         break;
 788                 }
 789                 if ((state->pf == NULL) || (state->gotmfc == 2)) {
 790                         state->pf = kmalloc(sizeof(*state->pf), M_DEVBUF,
 791                             M_NOWAIT | M_ZERO);
 792                         state->pf->number = state->count++;
 793                         state->pf->last_config_index = -1;
 794                         STAILQ_INIT(&state->pf->cfe_head);
 795
 796                         STAILQ_INSERT_TAIL(&state->card->pf_head, state->pf,
 797                             pf_list);
 798                 }
 799                 state->pf->function = pccard_tuple_read_1(tuple, 0);
 800
 801                 DPRINTF(("CISTPL_FUNCID\n"));
 802                 break;
 803         case CISTPL_FUNCE:
 804                 if (state->pf == NULL || state->pf->function <= 0) {
 805                         DPRINTF(("CISTPL_FUNCE is not followed by "
 806                                 "valid CISTPL_FUNCID\n"));
 807                         break;
 808                 }
 809                 if (tuple->length >= 2)
 810                         decode_funce(tuple, state->pf);
 811                 DPRINTF(("CISTPL_FUNCE\n"));
 812                 break;
 813         case CISTPL_CONFIG:
 814                 if (tuple->length < 3) {
 815                         DPRINTF(("CISTPL_CONFIG too short %d\n",
 816                             tuple->length));
 817                         break;
 818                 } {
 819                         u_int reg, rasz, rmsz, rfsz;
 820                         int i;
 821
 822                         reg = pccard_tuple_read_1(tuple, 0);
 823                         rasz = 1 + ((reg & PCCARD_TPCC_RASZ_MASK) >>
 824                             PCCARD_TPCC_RASZ_SHIFT);
 825                         rmsz = 1 + ((reg & PCCARD_TPCC_RMSZ_MASK) >>
 826                             PCCARD_TPCC_RMSZ_SHIFT);
 827                         rfsz = ((reg & PCCARD_TPCC_RFSZ_MASK) >>
 828                             PCCARD_TPCC_RFSZ_SHIFT);
 829
 830                         if (tuple->length < (rasz + rmsz + rfsz)) {
 831                                 DPRINTF(("CISTPL_CONFIG (%d,%d,%d) too "
 832                                     "short %d\n", rasz, rmsz, rfsz,
 833                                     tuple->length));
 834                                 break;
 835                         }
 836                         if (state->pf == NULL) {
 837                                 state->pf = kmalloc(sizeof(*state->pf),
 838                                     M_DEVBUF, M_NOWAIT | M_ZERO);
 839                                 state->pf->number = state->count++;
 840                                 state->pf->last_config_index = -1;
 841                                 STAILQ_INIT(&state->pf->cfe_head);
 842
 843                                 STAILQ_INSERT_TAIL(&state->card->pf_head,
 844                                     state->pf, pf_list);
 845
 846                                 state->pf->function = PCCARD_FUNCTION_UNSPEC;
 847                         }
 848                         state->pf->last_config_index =
 849                             pccard_tuple_read_1(tuple, 1);
 850
 851                         state->pf->ccr_base = 0;
 852                         for (i = 0; i < rasz; i++)
 853                                 state->pf->ccr_base |=
 854                                     ((pccard_tuple_read_1(tuple, 2 + i)) <<
 855                                     (i * 8));
 856
 857                         state->pf->ccr_mask = 0;
 858                         for (i = 0; i < rmsz; i++)
 859                                 state->pf->ccr_mask |=
 860                                     ((pccard_tuple_read_1(tuple,
 861                                     2 + rasz + i)) << (i * 8));
 862
 863                         /* skip the reserved area and subtuples */
 864
 865                         /* reset the default cfe for each cfe list */
 866                         state->temp_cfe = init_cfe;
 867                         state->default_cfe = &state->temp_cfe;
 868                 }
 869                 DPRINTF(("CISTPL_CONFIG\n"));
 870                 break;
 871         case CISTPL_CFTABLE_ENTRY:
 872                 {
 873                         int idx, i, j;
 874                         u_int reg, reg2;
 875                         u_int intface, def, num;
 876                         u_int power, timing, iospace, irq, memspace, misc;
 877                         struct pccard_config_entry *cfe;
 878
 879                         idx = 0;
 880
 881                         reg = pccard_tuple_read_1(tuple, idx);
 882                         idx++;
 883                         intface = reg & PCCARD_TPCE_INDX_INTFACE;
 884                         def = reg & PCCARD_TPCE_INDX_DEFAULT;
 885                         num = reg & PCCARD_TPCE_INDX_NUM_MASK;
 886
 887                         /*
 888                          * this is a little messy.  Some cards have only a
 889                          * cfentry with the default bit set.  So, as we go
 890                          * through the list, we add new indexes to the queue,
 891                          * and keep a pointer to the last one with the
 892                          * default bit set.  if we see a record with the same
 893                          * index, as the default, we stash the default and
 894                          * replace the queue entry. otherwise, we just add
 895                          * new entries to the queue, pointing the default ptr
 896                          * at them if the default bit is set.  if we get to
 897                          * the end with the default pointer pointing at a
 898                          * record which hasn't had a matching index, that's
 899                          * ok; it just becomes a cfentry like any other.
 900                          */
 901
 902                         /*
 903                          * if the index in the cis differs from the default
 904                          * cis, create new entry in the queue and start it
 905                          * with the current default
 906                          */
 907                         if (num != state->default_cfe->number) {
 908                                 cfe = (struct pccard_config_entry *)
 909                                     kmalloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
 910                                 if (cfe == NULL) {
 911                                         DPRINTF(("no memory for config entry\n"));
 912                                         goto abort_cfe;
 913                                 }
 914                                 *cfe = *state->default_cfe;
 915
 916                                 STAILQ_INSERT_TAIL(&state->pf->cfe_head,
 917                                     cfe, cfe_list);
 918
 919                                 cfe->number = num;
 920
 921                                 /*
 922                                  * if the default bit is set in the cis, then
 923                                  * point the new default at whatever is being
 924                                  * filled in
 925                                  */
 926                                 if (def)
 927                                         state->default_cfe = cfe;
 928                         } else {
 929                                 /*
 930                                  * the cis index matches the default index,
 931                                  * fill in the default cfentry.  It is
 932                                  * assumed that the cfdefault index is in the
 933                                  * queue.  For it to be otherwise, the cis
 934                                  * index would have to be -1 (initial
 935                                  * condition) which is not possible, or there
 936                                  * would have to be a preceding cis entry
 937                                  * which had the same cis index and had the
 938                                  * default bit unset. Neither condition
 939                                  * should happen.  If it does, this cfentry
 940                                  * is lost (written into temp space), which
 941                                  * is an acceptable failure mode.
 942                                  */
 943
 944                                 cfe = state->default_cfe;
 945
 946                                 /*
 947                                  * if the cis entry does not have the default
 948                                  * bit set, copy the default out of the way
 949                                  * first.
 950                                  */
 951                                 if (!def) {
 952                                         state->temp_cfe = *state->default_cfe;
 953                                         state->default_cfe = &state->temp_cfe;
 954                                 }
 955                         }
 956
 957                         if (intface) {
 958                                 reg = pccard_tuple_read_1(tuple, idx);
 959                                 idx++;
 960                                 cfe->flags &= ~(PCCARD_CFE_MWAIT_REQUIRED
 961                                     | PCCARD_CFE_RDYBSY_ACTIVE
 962                                     | PCCARD_CFE_WP_ACTIVE
 963                                     | PCCARD_CFE_BVD_ACTIVE);
 964                                 if (reg & PCCARD_TPCE_IF_MWAIT)
 965                                         cfe->flags |= PCCARD_CFE_MWAIT_REQUIRED;
 966                                 if (reg & PCCARD_TPCE_IF_RDYBSY)
 967                                         cfe->flags |= PCCARD_CFE_RDYBSY_ACTIVE;
 968                                 if (reg & PCCARD_TPCE_IF_WP)
 969                                         cfe->flags |= PCCARD_CFE_WP_ACTIVE;
 970                                 if (reg & PCCARD_TPCE_IF_BVD)
 971                                         cfe->flags |= PCCARD_CFE_BVD_ACTIVE;
 972                                 cfe->iftype = reg & PCCARD_TPCE_IF_IFTYPE;
 973                         }
 974                         reg = pccard_tuple_read_1(tuple, idx);
 975                         idx++;
 976
 977                         power = reg & PCCARD_TPCE_FS_POWER_MASK;
 978                         timing = reg & PCCARD_TPCE_FS_TIMING;
 979                         iospace = reg & PCCARD_TPCE_FS_IOSPACE;
 980                         irq = reg & PCCARD_TPCE_FS_IRQ;
 981                         memspace = reg & PCCARD_TPCE_FS_MEMSPACE_MASK;
 982                         misc = reg & PCCARD_TPCE_FS_MISC;
 983
 984                         if (power) {
 985                                 /* skip over power, don't save */
 986                                 /* for each parameter selection byte */
 987                                 for (i = 0; i < power; i++) {
 988                                         reg = pccard_tuple_read_1(tuple, idx);
 989                                         idx++;
 990                                         /* for each bit */
 991                                         for (j = 0; j < 7; j++) {
 992                                                 /* if the bit is set */
 993                                                 if ((reg >> j) & 0x01) {
 994                                                         /* skip over bytes */
 995                                                         do {
 996                                                                 reg2 = pccard_tuple_read_1(tuple, idx);
 997                                                                 idx++;
 998                                                                 /*
 999                                                                  * until
1000                                                                  * non-extensi
1001                                                                  * on byte
1002                                                                  */
1003                                                         } while (reg2 & 0x80);
1004                                                 }
1005                                         }
1006                                 }
1007                         }
1008                         if (timing) {
1009                                 /* skip over timing, don't save */
1010                                 reg = pccard_tuple_read_1(tuple, idx);
1011                                 idx++;
1012
1013                                 if ((reg & PCCARD_TPCE_TD_RESERVED_MASK) !=
1014                                     PCCARD_TPCE_TD_RESERVED_MASK)
1015                                         idx++;
1016                                 if ((reg & PCCARD_TPCE_TD_RDYBSY_MASK) !=
1017                                     PCCARD_TPCE_TD_RDYBSY_MASK)
1018                                         idx++;
1019                                 if ((reg & PCCARD_TPCE_TD_WAIT_MASK) !=
1020                                     PCCARD_TPCE_TD_WAIT_MASK)
1021                                         idx++;
1022                         }
1023                         if (iospace) {
1024                                 if (tuple->length <= idx) {
1025                                         DPRINTF(("ran out of space before TCPE_IO\n"));
1026                                         goto abort_cfe;
1027                                 }
1028
1029                                 reg = pccard_tuple_read_1(tuple, idx);
1030                                 idx++;
1031                                 cfe->flags &=
1032                                     ~(PCCARD_CFE_IO8 | PCCARD_CFE_IO16);
1033                                 if (reg & PCCARD_TPCE_IO_BUSWIDTH_8BIT)
1034                                         cfe->flags |= PCCARD_CFE_IO8;
1035                                 if (reg & PCCARD_TPCE_IO_BUSWIDTH_16BIT)
1036                                         cfe->flags |= PCCARD_CFE_IO16;
1037                                 cfe->iomask =
1038                                     reg & PCCARD_TPCE_IO_IOADDRLINES_MASK;
1039
1040                                 if (reg & PCCARD_TPCE_IO_HASRANGE) {
1041                                         reg = pccard_tuple_read_1(tuple, idx);
1042                                         idx++;
1043
1044                                         cfe->num_iospace = 1 + (reg &
1045                                             PCCARD_TPCE_IO_RANGE_COUNT);
1046
1047                                         if (cfe->num_iospace >
1048                                             (sizeof(cfe->iospace) /
1049                                              sizeof(cfe->iospace[0]))) {
1050                                                 DPRINTF(("too many io "
1051                                                     "spaces %d",
1052                                                     cfe->num_iospace));
1053                                                 state->card->error++;
1054                                                 break;
1055                                         }
1056                                         for (i = 0; i < cfe->num_iospace; i++) {
1057                                                 switch (reg & PCCARD_TPCE_IO_RANGE_ADDRSIZE_MASK) {
1058                                                 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_ONE:
1059                                                         cfe->iospace[i].start =
1060                                                                 pccard_tuple_read_1(tuple, idx);
1061                                                         idx++;
1062                                                         break;
1063                                                 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_TWO:
1064                                                         cfe->iospace[i].start =
1065                                                                 pccard_tuple_read_2(tuple, idx);
1066                                                         idx += 2;
1067                                                         break;
1068                                                 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_FOUR:
1069                                                         cfe->iospace[i].start =
1070                                                                 pccard_tuple_read_4(tuple, idx);
1071                                                         idx += 4;
1072                                                         break;
1073                                                 }
1074                                                 switch (reg &
1075                                                         PCCARD_TPCE_IO_RANGE_LENGTHSIZE_MASK) {
1076                                                 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_ONE:
1077                                                         cfe->iospace[i].length =
1078                                                                 pccard_tuple_read_1(tuple, idx);
1079                                                         idx++;
1080                                                         break;
1081                                                 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_TWO:
1082                                                         cfe->iospace[i].length =
1083                                                                 pccard_tuple_read_2(tuple, idx);
1084                                                         idx += 2;
1085                                                         break;
1086                                                 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_FOUR:
1087                                                         cfe->iospace[i].length =
1088                                                                 pccard_tuple_read_4(tuple, idx);
1089                                                         idx += 4;
1090                                                         break;
1091                                                 }
1092                                                 cfe->iospace[i].length++;
1093                                         }
1094                                 } else {
1095                                         cfe->num_iospace = 1;
1096                                         cfe->iospace[0].start = 0;
1097                                         cfe->iospace[0].length =
1098                                             (1 << cfe->iomask);
1099                                 }
1100                         }
1101                         if (irq) {
1102                                 if (tuple->length <= idx) {
1103                                         DPRINTF(("ran out of space before TCPE_IR\n"));
1104                                         goto abort_cfe;
1105                                 }
1106
1107                                 reg = pccard_tuple_read_1(tuple, idx);
1108                                 idx++;
1109                                 cfe->flags &= ~(PCCARD_CFE_IRQSHARE
1110                                     | PCCARD_CFE_IRQPULSE
1111                                     | PCCARD_CFE_IRQLEVEL);
1112                                 if (reg & PCCARD_TPCE_IR_SHARE)
1113                                         cfe->flags |= PCCARD_CFE_IRQSHARE;
1114                                 if (reg & PCCARD_TPCE_IR_PULSE)
1115                                         cfe->flags |= PCCARD_CFE_IRQPULSE;
1116                                 if (reg & PCCARD_TPCE_IR_LEVEL)
1117                                         cfe->flags |= PCCARD_CFE_IRQLEVEL;
1118
1119                                 if (reg & PCCARD_TPCE_IR_HASMASK) {
1120                                         /*
1121                                          * it's legal to ignore the
1122                                          * special-interrupt bits, so I will
1123                                          */
1124
1125                                         cfe->irqmask =
1126                                             pccard_tuple_read_2(tuple, idx);
1127                                         idx += 2;
1128                                 } else {
1129                                         cfe->irqmask =
1130                                             (1 << (reg & PCCARD_TPCE_IR_IRQ));
1131                                 }
1132                         }
1133                         if (memspace) {
1134                                 if (tuple->length <= idx) {
1135                                         DPRINTF(("ran out of space before TCPE_MS\n"));
1136                                         goto abort_cfe;
1137                                 }
1138
1139                                 if (memspace == PCCARD_TPCE_FS_MEMSPACE_LENGTH) {
1140                                         cfe->num_memspace = 1;
1141                                         cfe->memspace[0].length = 256 *
1142                                             pccard_tuple_read_2(tuple, idx);
1143                                         idx += 2;
1144                                         cfe->memspace[0].cardaddr = 0;
1145                                         cfe->memspace[0].hostaddr = 0;
1146                                 } else if (memspace ==
1147                                     PCCARD_TPCE_FS_MEMSPACE_LENGTHADDR) {
1148                                         cfe->num_memspace = 1;
1149                                         cfe->memspace[0].length = 256 *
1150                                             pccard_tuple_read_2(tuple, idx);
1151                                         idx += 2;
1152                                         cfe->memspace[0].cardaddr = 256 *
1153                                             pccard_tuple_read_2(tuple, idx);
1154                                         idx += 2;
1155                                         cfe->memspace[0].hostaddr = cfe->memspace[0].cardaddr;
1156                                 } else {
1157                                         int lengthsize;
1158                                         int cardaddrsize;
1159                                         int hostaddrsize;
1160
1161                                         reg = pccard_tuple_read_1(tuple, idx);
1162                                         idx++;
1163
1164                                         cfe->num_memspace = (reg &
1165                                             PCCARD_TPCE_MS_COUNT) + 1;
1166
1167                                         if (cfe->num_memspace >
1168                                             (sizeof(cfe->memspace) /
1169                                              sizeof(cfe->memspace[0]))) {
1170                                                 DPRINTF(("too many mem "
1171                                                     "spaces %d",
1172                                                     cfe->num_memspace));
1173                                                 state->card->error++;
1174                                                 break;
1175                                         }
1176                                         lengthsize =
1177                                                 ((reg & PCCARD_TPCE_MS_LENGTH_SIZE_MASK) >>
1178                                                  PCCARD_TPCE_MS_LENGTH_SIZE_SHIFT);
1179                                         cardaddrsize =
1180                                                 ((reg & PCCARD_TPCE_MS_CARDADDR_SIZE_MASK) >>
1181                                                  PCCARD_TPCE_MS_CARDADDR_SIZE_SHIFT);
1182                                         hostaddrsize =
1183                                                 (reg & PCCARD_TPCE_MS_HOSTADDR) ? cardaddrsize : 0;
1184
1185                                         if (lengthsize == 0) {
1186                                                 DPRINTF(("cfe memspace "
1187                                                     "lengthsize == 0"));
1188                                                 state->card->error++;
1189                                         }
1190                                         for (i = 0; i < cfe->num_memspace; i++) {
1191                                                 if (lengthsize) {
1192                                                         cfe->memspace[i].length =
1193                                                                 256 * pccard_tuple_read_n(tuple, lengthsize,
1194                                                                        idx);
1195                                                         idx += lengthsize;
1196                                                 } else {
1197                                                         cfe->memspace[i].length = 0;
1198                                                 }
1199                                                 if (cfe->memspace[i].length == 0) {
1200                                                         DPRINTF(("cfe->memspace[%d].length == 0",
1201                                                                  i));
1202                                                         state->card->error++;
1203                                                 }
1204                                                 if (cardaddrsize) {
1205                                                         cfe->memspace[i].cardaddr =
1206                                                                 256 * pccard_tuple_read_n(tuple, cardaddrsize,
1207                                                                        idx);
1208                                                         idx += cardaddrsize;
1209                                                 } else {
1210                                                         cfe->memspace[i].cardaddr = 0;
1211                                                 }
1212                                                 if (hostaddrsize) {
1213                                                         cfe->memspace[i].hostaddr =
1214                                                                 256 * pccard_tuple_read_n(tuple, hostaddrsize,
1215                                                                        idx);
1216                                                         idx += hostaddrsize;
1217                                                 } else {
1218                                                         cfe->memspace[i].hostaddr = 0;
1219                                                 }
1220                                         }
1221                                 }
1222                         } else
1223                                 cfe->num_memspace = 0;
1224                         if (misc) {
1225                                 if (tuple->length <= idx) {
1226                                         DPRINTF(("ran out of space before TCPE_MI\n"));
1227                                         goto abort_cfe;
1228                                 }
1229
1230                                 reg = pccard_tuple_read_1(tuple, idx);
1231                                 idx++;
1232                                 cfe->flags &= ~(PCCARD_CFE_POWERDOWN
1233                                     | PCCARD_CFE_READONLY
1234                                     | PCCARD_CFE_AUDIO);
1235                                 if (reg & PCCARD_TPCE_MI_PWRDOWN)
1236                                         cfe->flags |= PCCARD_CFE_POWERDOWN;
1237                                 if (reg & PCCARD_TPCE_MI_READONLY)
1238                                         cfe->flags |= PCCARD_CFE_READONLY;
1239                                 if (reg & PCCARD_TPCE_MI_AUDIO)
1240                                         cfe->flags |= PCCARD_CFE_AUDIO;
1241                                 cfe->maxtwins = reg & PCCARD_TPCE_MI_MAXTWINS;
1242
1243                                 while (reg & PCCARD_TPCE_MI_EXT) {
1244                                         reg = pccard_tuple_read_1(tuple, idx);
1245                                         idx++;
1246                                 }
1247                         }
1248                         /* skip all the subtuples */
1249                 }
1250
1251         abort_cfe:
1252                 DPRINTF(("CISTPL_CFTABLE_ENTRY\n"));
1253                 break;
1254         default:
1255                 DPRINTF(("unhandled CISTPL %x\n", tuple->code));
1256                 break;
1257         }
1258
1259         return (0);
1260 }
1261
1262 static int
1263 decode_funce(const struct pccard_tuple *tuple, struct pccard_function *pf)
1264 {
1265         int i;
1266         int len;
1267         int type = pccard_tuple_read_1(tuple, 0);
1268
1269         switch (pf->function) {
1270         case PCCARD_FUNCTION_DISK:
1271                 if (type == PCCARD_TPLFE_TYPE_DISK_DEVICE_INTERFACE) {
1272                         pf->pf_funce_disk_interface
1273                                 = pccard_tuple_read_1(tuple, 1);
1274                 }
1275                 break;
1276         case PCCARD_FUNCTION_NETWORK:
1277                 if (type == PCCARD_TPLFE_TYPE_LAN_NID) {
1278                         len = pccard_tuple_read_1(tuple, 1);
1279                         if (tuple->length < 2 + len || len > 8) {
1280                                 /* tuple length not enough or nid too long */
1281                                 break;
1282                         }
1283                         for (i = 0; i < len; i++) {
1284                                 pf->pf_funce_lan_nid[i]
1285                                         = pccard_tuple_read_1(tuple, i + 2);
1286                         }
1287                         pf->pf_funce_lan_nidlen = len;
1288                 }
1289                 break;
1290         default:
1291                 break;
1292         }
1293         return 0;
1294 }