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