![[BACK]](/icons/back.gif){kind=icon}
Return to pcmcia_cis.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pcmcia|
Return to pcmcia_cis.c CVS log | Up to [local] / sys / dev / pcmcia |
1.1 nbrk 1: /* $OpenBSD: pcmcia_cis.c,v 1.13 2005/08/01 21:58:01 fgsch Exp $ */
2: /* $NetBSD: pcmcia_cis.c,v 1.9 1998/08/22 23:41:48 msaitoh Exp $ */
3:
4: /*
5: * Copyright (c) 1997 Marc Horowitz. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Marc Horowitz.
18: * 4. The name of the author may not be used to endorse or promote products
19: * derived from this software without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31: */
32:
33: #include <sys/types.h>
34: #include <sys/param.h>
35: #include <sys/systm.h>
36: #include <sys/device.h>
37: #include <sys/malloc.h>
38:
39: #include <dev/pcmcia/pcmciareg.h>
40: #include <dev/pcmcia/pcmciachip.h>
41: #include <dev/pcmcia/pcmciavar.h>
42:
43: #ifdef PCMCIACISDEBUG
44: #define DPRINTF(arg) printf arg
45: #else
46: #define DPRINTF(arg)
47: #endif
48:
49: #define PCMCIA_CIS_SIZE 1024
50:
51: struct cis_state {
52: int count;
53: int gotmfc;
54: struct pcmcia_config_entry temp_cfe;
55: struct pcmcia_config_entry *default_cfe;
56: struct pcmcia_card *card;
57: struct pcmcia_function *pf;
58: };
59:
60: int pcmcia_parse_cis_tuple(struct pcmcia_tuple *, void *);
61:
62: void
63: pcmcia_read_cis(sc)
64: struct pcmcia_softc *sc;
65: {
66: struct cis_state state;
67:
68: memset(&state, 0, sizeof state);
69:
70: state.card = &sc->card;
71:
72: state.card->error = 0;
73: state.card->cis1_major = -1;
74: state.card->cis1_minor = -1;
75: state.card->cis1_info[0] = NULL;
76: state.card->cis1_info[1] = NULL;
77: state.card->cis1_info[2] = NULL;
78: state.card->cis1_info[3] = NULL;
79: state.card->manufacturer = PCMCIA_VENDOR_INVALID;
80: state.card->product = PCMCIA_PRODUCT_INVALID;
81: SIMPLEQ_INIT(&state.card->pf_head);
82:
83: state.pf = NULL;
84:
85: if (pcmcia_scan_cis((struct device *)sc, pcmcia_parse_cis_tuple,
86: &state) == -1)
87: state.card->error++;
88: }
89:
90: int
91: pcmcia_scan_cis(dev, fct, arg)
92: struct device *dev;
93: int (*fct)(struct pcmcia_tuple *, void *);
94: void *arg;
95: {
96: struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
97: pcmcia_chipset_tag_t pct;
98: pcmcia_chipset_handle_t pch;
99: int window;
100: struct pcmcia_mem_handle pcmh;
101: struct pcmcia_tuple tuple;
102: int longlink_present;
103: int longlink_common;
104: u_long longlink_addr;
105: int mfc_count;
106: int mfc_index;
107: struct {
108: int common;
109: u_long addr;
110: } mfc[256 / 5];
111: int ret;
112:
113: ret = 0;
114:
115: pct = sc->pct;
116: pch = sc->pch;
117:
118: /* allocate some memory */
119:
120: if (pcmcia_chip_mem_alloc(pct, pch, PCMCIA_CIS_SIZE, &pcmh)) {
121: #ifdef DIAGNOSTIC
122: printf("%s: can't alloc memory to read attributes\n",
123: sc->dev.dv_xname);
124: #endif
125: return -1;
126: }
127:
128: /* initialize state for the primary tuple chain */
129: if (pcmcia_chip_mem_map(pct, pch, PCMCIA_MEM_ATTR, 0,
130: PCMCIA_CIS_SIZE, &pcmh, &tuple.ptr, &window)) {
131: pcmcia_chip_mem_free(pct, pch, &pcmh);
132: #ifdef DIAGNOSTIC
133: printf("%s: can't map memory to read attributes\n",
134: sc->dev.dv_xname);
135: #endif
136: return -1;
137: }
138: tuple.memt = pcmh.memt;
139: tuple.memh = pcmh.memh;
140:
141: DPRINTF(("cis mem map %x\n", (unsigned int) tuple.memh));
142:
143: tuple.mult = 2;
144:
145: longlink_present = 1;
146: longlink_common = 1;
147: longlink_addr = 0;
148:
149: mfc_count = 0;
150: mfc_index = 0;
151:
152: DPRINTF(("%s: CIS tuple chain:\n", sc->dev.dv_xname));
153:
154: while (1) {
155: while (1) {
156: /*
157: * Perform boundary check for insane cards.
158: * If CIS is too long, simulate CIS end.
159: * (This check may not be sufficient for
160: * malicious cards.)
161: */
162: if (tuple.mult * tuple.ptr >= PCMCIA_CIS_SIZE - 1
163: - 32 /* ad hoc value */ ) {
164: DPRINTF(("CISTPL_END (too long CIS)\n"));
165: tuple.code = PCMCIA_CISTPL_END;
166: goto cis_end;
167: }
168:
169: /* get the tuple code */
170:
171: tuple.code = pcmcia_cis_read_1(&tuple, tuple.ptr);
172:
173: /* two special-case tuples */
174:
175: if (tuple.code == PCMCIA_CISTPL_NULL) {
176: DPRINTF(("CISTPL_NONE\n 00\n"));
177: tuple.ptr++;
178: continue;
179: } else if (tuple.code == PCMCIA_CISTPL_END) {
180: DPRINTF(("CISTPL_END\n ff\n"));
181: cis_end:
182: /* Call the function for the END tuple, since
183: the CIS semantics depend on it */
184: if ((*fct) (&tuple, arg)) {
185: pcmcia_chip_mem_unmap(pct, pch,
186: window);
187: ret = 1;
188: goto done;
189: }
190: tuple.ptr++;
191: break;
192: }
193: /* now all the normal tuples */
194:
195: tuple.length = pcmcia_cis_read_1(&tuple, tuple.ptr + 1);
196: switch (tuple.code) {
197: case PCMCIA_CISTPL_LONGLINK_A:
198: case PCMCIA_CISTPL_LONGLINK_C:
199: if (tuple.length < 4) {
200: DPRINTF(("CISTPL_LONGLINK_%s too "
201: "short %d\n",
202: longlink_common ? "C" : "A",
203: tuple.length));
204: break;
205: }
206: longlink_present = 1;
207: longlink_common = (tuple.code ==
208: PCMCIA_CISTPL_LONGLINK_C) ? 1 : 0;
209: longlink_addr = pcmcia_tuple_read_4(&tuple, 0);
210: DPRINTF(("CISTPL_LONGLINK_%s %lx\n",
211: longlink_common ? "C" : "A",
212: longlink_addr));
213: break;
214: case PCMCIA_CISTPL_NO_LINK:
215: longlink_present = 0;
216: DPRINTF(("CISTPL_NO_LINK\n"));
217: break;
218: case PCMCIA_CISTPL_CHECKSUM:
219: if (tuple.length < 5) {
220: DPRINTF(("CISTPL_CHECKSUM too "
221: "short %d\n", tuple.length));
222: break;
223: } {
224: int16_t offset;
225: u_long addr, length;
226: u_int cksum, sum;
227: int i;
228:
229: *((u_int16_t *) & offset) =
230: pcmcia_tuple_read_2(&tuple, 0);
231: length = pcmcia_tuple_read_2(&tuple, 2);
232: cksum = pcmcia_tuple_read_1(&tuple, 4);
233:
234: addr = tuple.ptr + offset;
235:
236: DPRINTF(("CISTPL_CHECKSUM addr=%lx "
237: "len=%lx cksum=%x",
238: addr, length, cksum));
239:
240: /*
241: * XXX do more work to deal with
242: * distant regions
243: */
244: if ((addr >= PCMCIA_CIS_SIZE) ||
245: ((addr + length) < 0) ||
246: ((addr + length) >=
247: PCMCIA_CIS_SIZE)) {
248: DPRINTF((" skipped, "
249: "too distant\n"));
250: break;
251: }
252: sum = 0;
253: for (i = 0; i < length; i++)
254: sum +=
255: bus_space_read_1(tuple.memt,
256: tuple.memh,
257: addr + tuple.mult * i);
258: if (cksum != (sum & 0xff)) {
259: DPRINTF((" failed sum=%x\n",
260: sum));
261: printf("%s: CIS checksum "
262: "failed\n",
263: sc->dev.dv_xname);
264: #if 0
265: /*
266: * XXX Some working cards have
267: * XXX bad checksums!!
268: */
269: ret = -1;
270: #endif
271: } else {
272: DPRINTF((" ok\n"));
273: }
274: }
275: break;
276: case PCMCIA_CISTPL_LONGLINK_MFC:
277: if (tuple.length < 6) {
278: DPRINTF(("CISTPL_LONGLINK_MFC too "
279: "short %d\n", tuple.length));
280: break;
281: }
282: if (((tuple.length - 1) % 5) != 0) {
283: DPRINTF(("CISTPL_LONGLINK_MFC bogus "
284: "length %d\n", tuple.length));
285: break;
286: }
287: {
288: int i, tmp_count;
289:
290: /*
291: * put count into tmp var so that
292: * if we have to bail (because it's
293: * a bogus count) it won't be
294: * remembered for later use.
295: */
296: tmp_count =
297: pcmcia_tuple_read_1(&tuple, 0);
298: DPRINTF(("CISTPL_LONGLINK_MFC %d",
299: tmp_count));
300:
301: /*
302: * make _sure_ it's the right size;
303: * if too short, it may be a weird
304: * (unknown/undefined) format
305: */
306: if (tuple.length != (tmp_count*5 + 1)) {
307: DPRINTF((" bogus length %d\n",
308: tuple.length));
309: break;
310: }
311:
312: #ifdef PCMCIACISDEBUG /* maybe enable all the time? */
313: /*
314: * sanity check for a programming
315: * error which is difficult to find
316: * when debugging.
317: */
318: if (tmp_count >
319: howmany(sizeof mfc, sizeof mfc[0]))
320: panic("CISTPL_LONGLINK_MFC mfc "
321: "count would blow stack");
322: #endif
323:
324: mfc_count = tmp_count;
325: for (i = 0; i < mfc_count; i++) {
326: mfc[i].common =
327: (pcmcia_tuple_read_1(&tuple,
328: 1 + 5 * i) ==
329: PCMCIA_MFC_MEM_COMMON) ?
330: 1 : 0;
331: mfc[i].addr =
332: pcmcia_tuple_read_4(&tuple,
333: 1 + 5 * i + 1);
334: DPRINTF((" %s:%lx",
335: mfc[i].common ? "common" :
336: "attr", mfc[i].addr));
337: }
338: DPRINTF(("\n"));
339: }
340: /*
341: * for LONGLINK_MFC, fall through to the
342: * function. This tuple has structural and
343: * semantic content.
344: */
345: default:
346: {
347: if ((*fct) (&tuple, arg)) {
348: pcmcia_chip_mem_unmap(pct,
349: pch, window);
350: ret = 1;
351: goto done;
352: }
353: }
354: break;
355: } /* switch */
356: #ifdef PCMCIACISDEBUG
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: pcmcia_tuple_read_1(&tuple, i)));
367: if ((i % 16) == 13)
368: DPRINTF(("\n"));
369: }
370: if ((i % 16) != 14)
371: DPRINTF(("\n"));
372: }
373: #endif
374: /* skip to the next tuple */
375: tuple.ptr += 2 + tuple.length;
376: }
377:
378: /*
379: * the chain is done. Clean up and move onto the next one,
380: * if any. The loop is here in the case that there is an MFC
381: * card with no longlink (which defaults to existing, == 0).
382: * In general, this means that if one pointer fails, it will
383: * try the next one, instead of just bailing.
384: */
385:
386: while (1) {
387: pcmcia_chip_mem_unmap(pct, pch, window);
388:
389: if (longlink_present) {
390: /*
391: * if the longlink is to attribute memory,
392: * then it is unindexed. That is, if the
393: * link value is 0x100, then the actual
394: * memory address is 0x200. This means that
395: * we need to multiply by 2 before calling
396: * mem_map, and then divide the resulting ptr
397: * by 2 after.
398: */
399:
400: if (!longlink_common)
401: longlink_addr *= 2;
402:
403: pcmcia_chip_mem_map(pct, pch, longlink_common ?
404: PCMCIA_MEM_COMMON : PCMCIA_MEM_ATTR,
405: longlink_addr, PCMCIA_CIS_SIZE,
406: &pcmh, &tuple.ptr, &window);
407:
408: if (!longlink_common)
409: tuple.ptr /= 2;
410:
411: DPRINTF(("cis mem map %x\n",
412: (unsigned int) tuple.memh));
413:
414: tuple.mult = longlink_common ? 1 : 2;
415: longlink_present = 0;
416: longlink_common = 1;
417: longlink_addr = 0;
418: } else if (mfc_count && (mfc_index < mfc_count)) {
419: if (!mfc[mfc_index].common)
420: mfc[mfc_index].addr *= 2;
421:
422: pcmcia_chip_mem_map(pct, pch,
423: mfc[mfc_index].common ?
424: PCMCIA_MEM_COMMON : PCMCIA_MEM_ATTR,
425: mfc[mfc_index].addr, PCMCIA_CIS_SIZE,
426: &pcmh, &tuple.ptr, &window);
427:
428: if (!mfc[mfc_index].common)
429: tuple.ptr /= 2;
430:
431: DPRINTF(("cis mem map %x\n",
432: (unsigned int) tuple.memh));
433:
434: /* set parse state, and point at the next one */
435:
436: tuple.mult = mfc[mfc_index].common ? 1 : 2;
437:
438: mfc_index++;
439: } else {
440: goto done;
441: }
442:
443: /* make sure that the link is valid */
444: tuple.code = pcmcia_cis_read_1(&tuple, tuple.ptr);
445: if (tuple.code != PCMCIA_CISTPL_LINKTARGET) {
446: DPRINTF(("CISTPL_LINKTARGET expected, "
447: "code %02x observed\n", tuple.code));
448: continue;
449: }
450: tuple.length = pcmcia_cis_read_1(&tuple, tuple.ptr + 1);
451: if (tuple.length < 3) {
452: DPRINTF(("CISTPL_LINKTARGET too short %d\n",
453: tuple.length));
454: continue;
455: }
456: if ((pcmcia_tuple_read_1(&tuple, 0) != 'C') ||
457: (pcmcia_tuple_read_1(&tuple, 1) != 'I') ||
458: (pcmcia_tuple_read_1(&tuple, 2) != 'S')) {
459: DPRINTF(("CISTPL_LINKTARGET magic "
460: "%02x%02x%02x incorrect\n",
461: pcmcia_tuple_read_1(&tuple, 0),
462: pcmcia_tuple_read_1(&tuple, 1),
463: pcmcia_tuple_read_1(&tuple, 2)));
464: continue;
465: }
466: tuple.ptr += 2 + tuple.length;
467:
468: break;
469: }
470: }
471:
472: pcmcia_chip_mem_unmap(pct, pch, window);
473:
474: done:
475: /* Last, free the allocated memory block */
476: pcmcia_chip_mem_free(pct, pch, &pcmh);
477:
478: return (ret);
479: }
480:
481: /* XXX this is incredibly verbose. Not sure what trt is */
482:
483: void
484: pcmcia_print_cis(sc)
485: struct pcmcia_softc *sc;
486: {
487: struct pcmcia_card *card = &sc->card;
488: struct pcmcia_function *pf;
489: struct pcmcia_config_entry *cfe;
490: int i;
491:
492: printf("%s: CIS version ", sc->dev.dv_xname);
493: if (card->cis1_major == 4) {
494: if (card->cis1_minor == 0)
495: printf("PCMCIA 1.0\n");
496: else if (card->cis1_minor == 1)
497: printf("PCMCIA 2.0 or 2.1\n");
498: } else if (card->cis1_major >= 5)
499: printf("PC Card Standard %d.%d\n", card->cis1_major,
500: card->cis1_minor);
501: else
502: printf("unknown (major=%d, minor=%d)\n",
503: card->cis1_major, card->cis1_minor);
504:
505: printf("%s: CIS info: ", sc->dev.dv_xname);
506: for (i = 0; i < 4; i++) {
507: if (card->cis1_info[i] == NULL)
508: break;
509: if (i)
510: printf(", ");
511: printf("%s", card->cis1_info[i]);
512: }
513: printf("\n");
514:
515: printf("%s: Manufacturer code 0x%x, product 0x%x\n",
516: sc->dev.dv_xname, card->manufacturer, card->product);
517:
518: SIMPLEQ_FOREACH(pf, &card->pf_head, pf_list) {
519: printf("%s: function %d: ", sc->dev.dv_xname, pf->number);
520:
521: switch (pf->function) {
522: case PCMCIA_FUNCTION_UNSPEC:
523: printf("unspecified");
524: break;
525: case PCMCIA_FUNCTION_MULTIFUNCTION:
526: printf("multi-function");
527: break;
528: case PCMCIA_FUNCTION_MEMORY:
529: printf("memory");
530: break;
531: case PCMCIA_FUNCTION_SERIAL:
532: printf("serial port");
533: break;
534: case PCMCIA_FUNCTION_PARALLEL:
535: printf("parallel port");
536: break;
537: case PCMCIA_FUNCTION_DISK:
538: printf("fixed disk");
539: break;
540: case PCMCIA_FUNCTION_VIDEO:
541: printf("video adapter");
542: break;
543: case PCMCIA_FUNCTION_NETWORK:
544: printf("network adapter");
545: break;
546: case PCMCIA_FUNCTION_AIMS:
547: printf("auto incrementing mass storage");
548: break;
549: case PCMCIA_FUNCTION_SCSI:
550: printf("SCSI bridge");
551: break;
552: case PCMCIA_FUNCTION_SECURITY:
553: printf("Security services");
554: break;
555: case PCMCIA_FUNCTION_INSTRUMENT:
556: printf("Instrument");
557: break;
558: case PCMCIA_FUNCTION_IOBUS:
559: printf("Serial I/O Bus Adapter");
560: break;
561: default:
562: printf("unknown (%d)", pf->function);
563: break;
564: }
565:
566: printf(", ccr addr %lx mask %lx\n", pf->ccr_base, pf->ccr_mask);
567:
568: SIMPLEQ_FOREACH(cfe, &pf->cfe_head, cfe_list) {
569: printf("%s: function %d, config table entry %d: ",
570: sc->dev.dv_xname, pf->number, cfe->number);
571:
572: switch (cfe->iftype) {
573: case PCMCIA_IFTYPE_MEMORY:
574: printf("memory card");
575: break;
576: case PCMCIA_IFTYPE_IO:
577: printf("I/O card");
578: break;
579: default:
580: printf("card type unknown");
581: break;
582: }
583:
584: printf("; irq mask %x", cfe->irqmask);
585:
586: if (cfe->num_iospace) {
587: printf("; iomask %lx, iospace", cfe->iomask);
588:
589: for (i = 0; i < cfe->num_iospace; i++)
590: printf(" %lx%s%lx",
591: cfe->iospace[i].start,
592: cfe->iospace[i].length ? "-" : "",
593: cfe->iospace[i].start +
594: cfe->iospace[i].length - 1);
595: }
596: if (cfe->num_memspace) {
597: printf("; memspace");
598:
599: for (i = 0; i < cfe->num_memspace; i++)
600: printf(" %lx%s%lx%s%lx",
601: cfe->memspace[i].cardaddr,
602: cfe->memspace[i].length ? "-" : "",
603: cfe->memspace[i].cardaddr +
604: cfe->memspace[i].length - 1,
605: cfe->memspace[i].hostaddr ?
606: "@" : "",
607: cfe->memspace[i].hostaddr);
608: }
609: if (cfe->maxtwins)
610: printf("; maxtwins %d", cfe->maxtwins);
611:
612: printf(";");
613:
614: if (cfe->flags & PCMCIA_CFE_MWAIT_REQUIRED)
615: printf(" mwait_required");
616: if (cfe->flags & PCMCIA_CFE_RDYBSY_ACTIVE)
617: printf(" rdybsy_active");
618: if (cfe->flags & PCMCIA_CFE_WP_ACTIVE)
619: printf(" wp_active");
620: if (cfe->flags & PCMCIA_CFE_BVD_ACTIVE)
621: printf(" bvd_active");
622: if (cfe->flags & PCMCIA_CFE_IO8)
623: printf(" io8");
624: if (cfe->flags & PCMCIA_CFE_IO16)
625: printf(" io16");
626: if (cfe->flags & PCMCIA_CFE_IRQSHARE)
627: printf(" irqshare");
628: if (cfe->flags & PCMCIA_CFE_IRQPULSE)
629: printf(" irqpulse");
630: if (cfe->flags & PCMCIA_CFE_IRQLEVEL)
631: printf(" irqlevel");
632: if (cfe->flags & PCMCIA_CFE_POWERDOWN)
633: printf(" powerdown");
634: if (cfe->flags & PCMCIA_CFE_READONLY)
635: printf(" readonly");
636: if (cfe->flags & PCMCIA_CFE_AUDIO)
637: printf(" audio");
638:
639: printf("\n");
640: }
641: }
642:
643: if (card->error)
644: printf("%s: %d errors found while parsing CIS\n",
645: sc->dev.dv_xname, card->error);
646: }
647:
648: int
649: pcmcia_parse_cis_tuple(tuple, arg)
650: struct pcmcia_tuple *tuple;
651: void *arg;
652: {
653: /* most of these are educated guesses */
654: static struct pcmcia_config_entry init_cfe = {
655: -1, PCMCIA_CFE_RDYBSY_ACTIVE | PCMCIA_CFE_WP_ACTIVE |
656: PCMCIA_CFE_BVD_ACTIVE, PCMCIA_IFTYPE_MEMORY,
657: };
658:
659: struct cis_state *state = arg;
660:
661: switch (tuple->code) {
662: case PCMCIA_CISTPL_END:
663: /*
664: * If we've seen a LONGLINK_MFC, and this is the first
665: * END after it, reset the function list.
666: *
667: * XXX This might also be the right place to start a
668: * new function, but that assumes that a function
669: * definition never crosses any longlink, and I'm not
670: * sure about that. This is probably safe for MFC
671: * cards, but what we have now isn't broken, so I'd
672: * rather not change it.
673: */
674: if (state->gotmfc == 1) {
675: struct pcmcia_function *pf, *pfnext;
676:
677: for (pf = SIMPLEQ_FIRST(&state->card->pf_head);
678: pf != NULL; pf = pfnext) {
679: pfnext = SIMPLEQ_NEXT(pf, pf_list);
680: free(pf, M_DEVBUF);
681: }
682:
683: SIMPLEQ_INIT(&state->card->pf_head);
684:
685: state->count = 0;
686: state->gotmfc = 2;
687: state->pf = NULL;
688: }
689: break;
690:
691: case PCMCIA_CISTPL_LONGLINK_MFC:
692: /*
693: * This tuple's structure was dealt with in scan_cis. here,
694: * record the fact that the MFC tuple was seen, so that
695: * functions declared before the MFC link can be cleaned
696: * up.
697: */
698: state->gotmfc = 1;
699: break;
700:
701: #ifdef PCMCIACISDEBUG
702: case PCMCIA_CISTPL_DEVICE:
703: case PCMCIA_CISTPL_DEVICE_A:
704: {
705: u_int reg, dtype, dspeed;
706:
707: reg = pcmcia_tuple_read_1(tuple, 0);
708: dtype = reg & PCMCIA_DTYPE_MASK;
709: dspeed = reg & PCMCIA_DSPEED_MASK;
710:
711: DPRINTF(("CISTPL_DEVICE%s type=",
712: (tuple->code == PCMCIA_CISTPL_DEVICE) ? "" : "_A"));
713: switch (dtype) {
714: case PCMCIA_DTYPE_NULL:
715: DPRINTF(("null"));
716: break;
717: case PCMCIA_DTYPE_ROM:
718: DPRINTF(("rom"));
719: break;
720: case PCMCIA_DTYPE_OTPROM:
721: DPRINTF(("otprom"));
722: break;
723: case PCMCIA_DTYPE_EPROM:
724: DPRINTF(("eprom"));
725: break;
726: case PCMCIA_DTYPE_EEPROM:
727: DPRINTF(("eeprom"));
728: break;
729: case PCMCIA_DTYPE_FLASH:
730: DPRINTF(("flash"));
731: break;
732: case PCMCIA_DTYPE_SRAM:
733: DPRINTF(("sram"));
734: break;
735: case PCMCIA_DTYPE_DRAM:
736: DPRINTF(("dram"));
737: break;
738: case PCMCIA_DTYPE_FUNCSPEC:
739: DPRINTF(("funcspec"));
740: break;
741: case PCMCIA_DTYPE_EXTEND:
742: DPRINTF(("extend"));
743: break;
744: default:
745: DPRINTF(("reserved"));
746: break;
747: }
748: DPRINTF((" speed="));
749: switch (dspeed) {
750: case PCMCIA_DSPEED_NULL:
751: DPRINTF(("null"));
752: break;
753: case PCMCIA_DSPEED_250NS:
754: DPRINTF(("250ns"));
755: break;
756: case PCMCIA_DSPEED_200NS:
757: DPRINTF(("200ns"));
758: break;
759: case PCMCIA_DSPEED_150NS:
760: DPRINTF(("150ns"));
761: break;
762: case PCMCIA_DSPEED_100NS:
763: DPRINTF(("100ns"));
764: break;
765: case PCMCIA_DSPEED_EXT:
766: DPRINTF(("ext"));
767: break;
768: default:
769: DPRINTF(("reserved"));
770: break;
771: }
772: }
773: DPRINTF(("\n"));
774: break;
775: #endif
776:
777: case PCMCIA_CISTPL_VERS_1:
778: if (tuple->length < 6) {
779: DPRINTF(("CISTPL_VERS_1 too short %d\n",
780: tuple->length));
781: break;
782: } {
783: int start, i, ch, count;
784:
785: state->card->cis1_major = pcmcia_tuple_read_1(tuple, 0);
786: state->card->cis1_minor = pcmcia_tuple_read_1(tuple, 1);
787:
788: for (count = 0, start = 0, i = 0;
789: (count < 4) && ((i + 4) < 256); i++) {
790: ch = pcmcia_tuple_read_1(tuple, 2 + i);
791: if (ch == 0xff)
792: break;
793: state->card->cis1_info_buf[i] = ch;
794: if (ch == 0) {
795: state->card->cis1_info[count] =
796: state->card->cis1_info_buf + start;
797: start = i + 1;
798: count++;
799: }
800: }
801: DPRINTF(("CISTPL_VERS_1\n"));
802: }
803: break;
804:
805: case PCMCIA_CISTPL_MANFID:
806: if (tuple->length < 4) {
807: DPRINTF(("CISTPL_MANFID too short %d\n",
808: tuple->length));
809: break;
810: }
811: state->card->manufacturer = pcmcia_tuple_read_2(tuple, 0);
812: state->card->product = pcmcia_tuple_read_2(tuple, 2);
813: DPRINTF(("CISTPL_MANFID\n"));
814: break;
815:
816: case PCMCIA_CISTPL_FUNCID:
817: if (tuple->length < 2) {
818: DPRINTF(("CISTPL_FUNCID too short %d\n",
819: tuple->length));
820: break;
821: }
822:
823: /*
824: * As far as I understand this, manufacturers do multifunction
825: * cards in various ways. Sadly enough I do not have the
826: * PC-Card standard (donate!) so I can only guess what can
827: * be done.
828: * The original code implies FUNCID nodes are above CONFIG
829: * nodes in the CIS tree, however Xircom does it the other
830: * way round, which of course makes things a bit hard.
831: * --niklas@openbsd.org
832: */
833: if (state->pf) {
834: if (state->pf->function == PCMCIA_FUNCTION_UNSPEC) {
835: /*
836: * This looks like a opportunistic function
837: * created by a CONFIG tuple. Just keep it.
838: */
839: } else {
840: /*
841: * A function is being defined, end it.
842: */
843: state->pf = NULL;
844: }
845: }
846: if (state->pf == NULL) {
847: state->pf = malloc(sizeof(*state->pf), M_DEVBUF,
848: M_NOWAIT);
849: if (state->pf == NULL)
850: panic("pcmcia_parse_cis_tuple");
851: bzero(state->pf, sizeof(*state->pf));
852: state->pf->number = state->count++;
853: state->pf->last_config_index = -1;
854: SIMPLEQ_INIT(&state->pf->cfe_head);
855:
856: SIMPLEQ_INSERT_TAIL(&state->card->pf_head, state->pf,
857: pf_list);
858: }
859: state->pf->function = pcmcia_tuple_read_1(tuple, 0);
860:
861: DPRINTF(("CISTPL_FUNCID\n"));
862: break;
863:
864: case PCMCIA_CISTPL_CONFIG:
865: if (tuple->length < 3) {
866: DPRINTF(("CISTPL_CONFIG too short %d\n",
867: tuple->length));
868: break;
869: } {
870: u_int reg, rasz, rmsz, rfsz;
871: int i;
872:
873: reg = pcmcia_tuple_read_1(tuple, 0);
874: rasz = 1 + ((reg & PCMCIA_TPCC_RASZ_MASK) >>
875: PCMCIA_TPCC_RASZ_SHIFT);
876: rmsz = 1 + ((reg & PCMCIA_TPCC_RMSZ_MASK) >>
877: PCMCIA_TPCC_RMSZ_SHIFT);
878: rfsz = ((reg & PCMCIA_TPCC_RFSZ_MASK) >>
879: PCMCIA_TPCC_RFSZ_SHIFT);
880:
881: if (tuple->length < (rasz + rmsz + rfsz)) {
882: DPRINTF(("CISTPL_CONFIG (%d,%d,%d) too "
883: "short %d\n", rasz, rmsz, rfsz,
884: tuple->length));
885: break;
886: }
887: if (state->pf == NULL) {
888: state->pf = malloc(sizeof(*state->pf),
889: M_DEVBUF, M_NOWAIT);
890: if (state->pf == NULL)
891: panic("pcmcia_parse_cis_tuple");
892: bzero(state->pf, sizeof(*state->pf));
893: state->pf->number = state->count++;
894: state->pf->last_config_index = -1;
895: SIMPLEQ_INIT(&state->pf->cfe_head);
896:
897: SIMPLEQ_INSERT_TAIL(&state->card->pf_head,
898: state->pf, pf_list);
899:
900: state->pf->function = PCMCIA_FUNCTION_UNSPEC;
901: }
902: state->pf->last_config_index =
903: pcmcia_tuple_read_1(tuple, 1);
904:
905: state->pf->ccr_base = 0;
906: for (i = 0; i < rasz; i++)
907: state->pf->ccr_base |=
908: ((pcmcia_tuple_read_1(tuple, 2 + i)) <<
909: (i * 8));
910:
911: state->pf->ccr_mask = 0;
912: for (i = 0; i < rmsz; i++)
913: state->pf->ccr_mask |=
914: ((pcmcia_tuple_read_1(tuple,
915: 2 + rasz + i)) << (i * 8));
916:
917: /* skip the reserved area and subtuples */
918:
919: /* reset the default cfe for each cfe list */
920: state->temp_cfe = init_cfe;
921: state->default_cfe = &state->temp_cfe;
922: }
923: DPRINTF(("CISTPL_CONFIG\n"));
924: break;
925:
926: case PCMCIA_CISTPL_CFTABLE_ENTRY:
927: if (tuple->length < 2) {
928: DPRINTF(("CISTPL_CFTABLE_ENTRY too short %d\n",
929: tuple->length));
930: break;
931: } {
932: int idx, i, j;
933: u_int reg, reg2;
934: u_int intface, def, num;
935: u_int power, timing, iospace, irq, memspace, misc;
936: struct pcmcia_config_entry *cfe;
937:
938: idx = 0;
939:
940: reg = pcmcia_tuple_read_1(tuple, idx);
941: idx++;
942: intface = reg & PCMCIA_TPCE_INDX_INTFACE;
943: def = reg & PCMCIA_TPCE_INDX_DEFAULT;
944: num = reg & PCMCIA_TPCE_INDX_NUM_MASK;
945:
946: /*
947: * this is a little messy. Some cards have only a
948: * cfentry with the default bit set. So, as we go
949: * through the list, we add new indexes to the queue,
950: * and keep a pointer to the last one with the
951: * default bit set. if we see a record with the same
952: * index, as the default, we stash the default and
953: * replace the queue entry. otherwise, we just add
954: * new entries to the queue, pointing the default ptr
955: * at them if the default bit is set. if we get to
956: * the end with the default pointer pointing at a
957: * record which hasn't had a matching index, that's
958: * ok; it just becomes a cfentry like any other.
959: */
960:
961: /*
962: * if the index in the cis differs from the default
963: * cis, create new entry in the queue and start it
964: * with the current default
965: */
966: if (state->default_cfe == NULL) {
967: DPRINTF(("CISTPL_CFTABLE_ENTRY with no "
968: "default\n"));
969: break;
970: }
971: if (num != state->default_cfe->number) {
972: cfe = (struct pcmcia_config_entry *)
973: malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
974: if (cfe == NULL)
975: panic("pcmcia_parse_cis_tuple");
976:
977: *cfe = *state->default_cfe;
978:
979: SIMPLEQ_INSERT_TAIL(&state->pf->cfe_head,
980: cfe, cfe_list);
981:
982: cfe->number = num;
983:
984: /*
985: * if the default bit is set in the cis, then
986: * point the new default at whatever is being
987: * filled in
988: */
989: if (def)
990: state->default_cfe = cfe;
991: } else {
992: /*
993: * the cis index matches the default index,
994: * fill in the default cfentry. It is
995: * assumed that the cfdefault index is in the
996: * queue. For it to be otherwise, the cis
997: * index would have to be -1 (initial
998: * condition) which is not possible, or there
999: * would have to be a preceding cis entry
1000: * which had the same cis index and had the
1001: * default bit unset. Neither condition
1002: * should happen. If it does, this cfentry
1003: * is lost (written into temp space), which
1004: * is an acceptable failure mode.
1005: */
1006:
1007: cfe = state->default_cfe;
1008:
1009: /*
1010: * if the cis entry does not have the default
1011: * bit set, copy the default out of the way
1012: * first.
1013: */
1014: if (!def) {
1015: state->temp_cfe = *state->default_cfe;
1016: state->default_cfe = &state->temp_cfe;
1017: }
1018: }
1019:
1020: if (intface) {
1021: reg = pcmcia_tuple_read_1(tuple, idx);
1022: idx++;
1023: cfe->flags &= ~(PCMCIA_CFE_MWAIT_REQUIRED
1024: | PCMCIA_CFE_RDYBSY_ACTIVE
1025: | PCMCIA_CFE_WP_ACTIVE
1026: | PCMCIA_CFE_BVD_ACTIVE);
1027: if (reg & PCMCIA_TPCE_IF_MWAIT)
1028: cfe->flags |= PCMCIA_CFE_MWAIT_REQUIRED;
1029: if (reg & PCMCIA_TPCE_IF_RDYBSY)
1030: cfe->flags |= PCMCIA_CFE_RDYBSY_ACTIVE;
1031: if (reg & PCMCIA_TPCE_IF_WP)
1032: cfe->flags |= PCMCIA_CFE_WP_ACTIVE;
1033: if (reg & PCMCIA_TPCE_IF_BVD)
1034: cfe->flags |= PCMCIA_CFE_BVD_ACTIVE;
1035: cfe->iftype = reg & PCMCIA_TPCE_IF_IFTYPE;
1036: }
1037: reg = pcmcia_tuple_read_1(tuple, idx);
1038: idx++;
1039:
1040: power = reg & PCMCIA_TPCE_FS_POWER_MASK;
1041: timing = reg & PCMCIA_TPCE_FS_TIMING;
1042: iospace = reg & PCMCIA_TPCE_FS_IOSPACE;
1043: irq = reg & PCMCIA_TPCE_FS_IRQ;
1044: memspace = reg & PCMCIA_TPCE_FS_MEMSPACE_MASK;
1045: misc = reg & PCMCIA_TPCE_FS_MISC;
1046:
1047: if (power) {
1048: /* skip over power, don't save */
1049: /* for each parameter selection byte */
1050: for (i = 0; i < power; i++) {
1051: reg = pcmcia_tuple_read_1(tuple, idx);
1052: idx++;
1053: /* for each bit */
1054: for (j = 0; j < 7; j++) {
1055: /* if the bit is set */
1056: if ((reg >> j) & 0x01) {
1057: /* skip over bytes */
1058: do {
1059: reg2 = pcmcia_tuple_read_1(tuple, idx);
1060: idx++;
1061: /*
1062: * until
1063: * non-
1064: * extension
1065: * byte
1066: */
1067: } while (reg2 & 0x80);
1068: }
1069: }
1070: }
1071: }
1072: if (timing) {
1073: /* skip over timing, don't save */
1074: reg = pcmcia_tuple_read_1(tuple, idx);
1075: idx++;
1076:
1077: if ((reg & PCMCIA_TPCE_TD_RESERVED_MASK) !=
1078: PCMCIA_TPCE_TD_RESERVED_MASK)
1079: idx++;
1080: if ((reg & PCMCIA_TPCE_TD_RDYBSY_MASK) !=
1081: PCMCIA_TPCE_TD_RDYBSY_MASK)
1082: idx++;
1083: if ((reg & PCMCIA_TPCE_TD_WAIT_MASK) !=
1084: PCMCIA_TPCE_TD_WAIT_MASK)
1085: idx++;
1086: }
1087: if (iospace) {
1088: if (tuple->length <= idx) {
1089: DPRINTF(("ran out of space before TPCE_IO\n"));
1090:
1091: goto abort_cfe;
1092: }
1093:
1094: reg = pcmcia_tuple_read_1(tuple, idx);
1095: idx++;
1096:
1097: cfe->flags &=
1098: ~(PCMCIA_CFE_IO8 | PCMCIA_CFE_IO16);
1099: if (reg & PCMCIA_TPCE_IO_BUSWIDTH_8BIT)
1100: cfe->flags |= PCMCIA_CFE_IO8;
1101: if (reg & PCMCIA_TPCE_IO_BUSWIDTH_16BIT)
1102: cfe->flags |= PCMCIA_CFE_IO16;
1103: cfe->iomask =
1104: reg & PCMCIA_TPCE_IO_IOADDRLINES_MASK;
1105:
1106: if (reg & PCMCIA_TPCE_IO_HASRANGE) {
1107: reg = pcmcia_tuple_read_1(tuple, idx);
1108: idx++;
1109:
1110: cfe->num_iospace = 1 + (reg &
1111: PCMCIA_TPCE_IO_RANGE_COUNT);
1112:
1113: if (cfe->num_iospace >
1114: (sizeof(cfe->iospace) /
1115: sizeof(cfe->iospace[0]))) {
1116: DPRINTF(("too many io "
1117: "spaces %d",
1118: cfe->num_iospace));
1119: state->card->error++;
1120: break;
1121: }
1122: for (i = 0; i < cfe->num_iospace; i++) {
1123: switch (reg & PCMCIA_TPCE_IO_RANGE_ADDRSIZE_MASK) {
1124: case PCMCIA_TPCE_IO_RANGE_ADDRSIZE_ONE:
1125: cfe->iospace[i].start =
1126: pcmcia_tuple_read_1(tuple, idx);
1127: idx++;
1128: break;
1129: case PCMCIA_TPCE_IO_RANGE_ADDRSIZE_TWO:
1130: cfe->iospace[i].start =
1131: pcmcia_tuple_read_2(tuple, idx);
1132: idx += 2;
1133: break;
1134: case PCMCIA_TPCE_IO_RANGE_ADDRSIZE_FOUR:
1135: cfe->iospace[i].start =
1136: pcmcia_tuple_read_4(tuple, idx);
1137: idx += 4;
1138: break;
1139: }
1140: switch (reg &
1141: PCMCIA_TPCE_IO_RANGE_LENGTHSIZE_MASK) {
1142: case PCMCIA_TPCE_IO_RANGE_LENGTHSIZE_ONE:
1143: cfe->iospace[i].length =
1144: pcmcia_tuple_read_1(tuple, idx);
1145: idx++;
1146: break;
1147: case PCMCIA_TPCE_IO_RANGE_LENGTHSIZE_TWO:
1148: cfe->iospace[i].length =
1149: pcmcia_tuple_read_2(tuple, idx);
1150: idx += 2;
1151: break;
1152: case PCMCIA_TPCE_IO_RANGE_LENGTHSIZE_FOUR:
1153: cfe->iospace[i].length =
1154: pcmcia_tuple_read_4(tuple, idx);
1155: idx += 4;
1156: break;
1157: }
1158: cfe->iospace[i].length++;
1159: }
1160: } else {
1161: cfe->num_iospace = 1;
1162: cfe->iospace[0].start = 0;
1163: cfe->iospace[0].length =
1164: (1 << cfe->iomask);
1165: }
1166: }
1167:
1168: if (irq) {
1169: if (tuple->length <= idx) {
1170: DPRINTF(("ran out of space before TPCE_IR\n"));
1171:
1172: goto abort_cfe;
1173: }
1174:
1175: reg = pcmcia_tuple_read_1(tuple, idx);
1176: idx++;
1177:
1178: cfe->flags &= ~(PCMCIA_CFE_IRQSHARE
1179: | PCMCIA_CFE_IRQPULSE
1180: | PCMCIA_CFE_IRQLEVEL);
1181: if (reg & PCMCIA_TPCE_IR_SHARE)
1182: cfe->flags |= PCMCIA_CFE_IRQSHARE;
1183: if (reg & PCMCIA_TPCE_IR_PULSE)
1184: cfe->flags |= PCMCIA_CFE_IRQPULSE;
1185: if (reg & PCMCIA_TPCE_IR_LEVEL)
1186: cfe->flags |= PCMCIA_CFE_IRQLEVEL;
1187:
1188: if (reg & PCMCIA_TPCE_IR_HASMASK) {
1189: /*
1190: * it's legal to ignore the
1191: * special-interrupt bits, so I will
1192: */
1193:
1194: cfe->irqmask =
1195: pcmcia_tuple_read_2(tuple, idx);
1196: idx += 2;
1197: } else {
1198: cfe->irqmask =
1199: (1 << (reg & PCMCIA_TPCE_IR_IRQ));
1200: }
1201: }
1202: if (memspace) {
1203: if (tuple->length <= idx) {
1204: DPRINTF(("ran out of space before TPCE_MS\n"));
1205: goto abort_cfe;
1206: }
1207:
1208: if (memspace == PCMCIA_TPCE_FS_MEMSPACE_NONE) {
1209: cfe->num_memspace = 0;
1210: } else if (memspace == PCMCIA_TPCE_FS_MEMSPACE_LENGTH) {
1211: cfe->num_memspace = 1;
1212: cfe->memspace[0].length = 256 *
1213: pcmcia_tuple_read_2(tuple, idx);
1214: idx += 2;
1215: cfe->memspace[0].cardaddr = 0;
1216: cfe->memspace[0].hostaddr = 0;
1217: } else if (memspace ==
1218: PCMCIA_TPCE_FS_MEMSPACE_LENGTHADDR) {
1219: cfe->num_memspace = 1;
1220: cfe->memspace[0].length = 256 *
1221: pcmcia_tuple_read_2(tuple, idx);
1222: idx += 2;
1223: cfe->memspace[0].cardaddr = 256 *
1224: pcmcia_tuple_read_2(tuple, idx);
1225: idx += 2;
1226: cfe->memspace[0].hostaddr = cfe->memspace[0].cardaddr;
1227: } else {
1228: int lengthsize;
1229: int cardaddrsize;
1230: int hostaddrsize;
1231:
1232: reg = pcmcia_tuple_read_1(tuple, idx);
1233: idx++;
1234:
1235: cfe->num_memspace = (reg &
1236: PCMCIA_TPCE_MS_COUNT) + 1;
1237:
1238: if (cfe->num_memspace >
1239: (sizeof(cfe->memspace) /
1240: sizeof(cfe->memspace[0]))) {
1241: DPRINTF(("too many mem "
1242: "spaces %d",
1243: cfe->num_memspace));
1244: state->card->error++;
1245: break;
1246: }
1247: lengthsize =
1248: ((reg & PCMCIA_TPCE_MS_LENGTH_SIZE_MASK) >>
1249: PCMCIA_TPCE_MS_LENGTH_SIZE_SHIFT);
1250: cardaddrsize =
1251: ((reg & PCMCIA_TPCE_MS_CARDADDR_SIZE_MASK) >>
1252: PCMCIA_TPCE_MS_CARDADDR_SIZE_SHIFT);
1253: hostaddrsize =
1254: (reg & PCMCIA_TPCE_MS_HOSTADDR) ? cardaddrsize : 0;
1255:
1256: if (lengthsize == 0) {
1257: DPRINTF(("cfe memspace "
1258: "lengthsize == 0"));
1259: state->card->error++;
1260: }
1261: for (i = 0; i < cfe->num_memspace; i++) {
1262: if (lengthsize) {
1263: cfe->memspace[i].length =
1264: 256 * pcmcia_tuple_read_n(tuple, lengthsize,
1265: idx);
1266: idx += lengthsize;
1267: } else {
1268: cfe->memspace[i].length = 0;
1269: }
1270: if (cfe->memspace[i].length == 0) {
1271: DPRINTF(("cfe->memspace[%d].length == 0",
1272: i));
1273: state->card->error++;
1274: }
1275: if (cardaddrsize) {
1276: cfe->memspace[i].cardaddr =
1277: 256 * pcmcia_tuple_read_n(tuple, cardaddrsize,
1278: idx);
1279: idx += cardaddrsize;
1280: } else {
1281: cfe->memspace[i].cardaddr = 0;
1282: }
1283: if (hostaddrsize) {
1284: cfe->memspace[i].hostaddr =
1285: 256 * pcmcia_tuple_read_n(tuple, hostaddrsize,
1286: idx);
1287: idx += hostaddrsize;
1288: } else {
1289: cfe->memspace[i].hostaddr = 0;
1290: }
1291: }
1292: }
1293: }
1294: if (misc) {
1295: if (tuple->length <= idx) {
1296: DPRINTF(("ran out of space before TPCE_MI\n"));
1297:
1298: goto abort_cfe;
1299: }
1300:
1301: reg = pcmcia_tuple_read_1(tuple, idx);
1302: idx++;
1303:
1304: cfe->flags &= ~(PCMCIA_CFE_POWERDOWN
1305: | PCMCIA_CFE_READONLY
1306: | PCMCIA_CFE_AUDIO);
1307: if (reg & PCMCIA_TPCE_MI_PWRDOWN)
1308: cfe->flags |= PCMCIA_CFE_POWERDOWN;
1309: if (reg & PCMCIA_TPCE_MI_READONLY)
1310: cfe->flags |= PCMCIA_CFE_READONLY;
1311: if (reg & PCMCIA_TPCE_MI_AUDIO)
1312: cfe->flags |= PCMCIA_CFE_AUDIO;
1313: cfe->maxtwins = reg & PCMCIA_TPCE_MI_MAXTWINS;
1314:
1315: while (reg & PCMCIA_TPCE_MI_EXT) {
1316: reg = pcmcia_tuple_read_1(tuple, idx);
1317: idx++;
1318: }
1319: }
1320: /* skip all the subtuples */
1321: }
1322:
1323: abort_cfe:
1324: DPRINTF(("CISTPL_CFTABLE_ENTRY\n"));
1325: break;
1326:
1327: default:
1328: DPRINTF(("unhandled CISTPL %x\n", tuple->code));
1329: break;
1330: }
1331:
1332: return (0);
1333: }