2 * Copyright (c) 2000,2001 Jonathan Chen.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
31 * CIS Handling for the Cardbus Bus
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
40 #include <machine/bus.h>
41 #include <machine/resource.h>
43 #include <sys/endian.h>
45 #include <sys/pciio.h>
46 #include <dev/pci/pcivar.h>
47 #include <dev/pci/pcireg.h>
49 #include <dev/pccard/pccardvar.h>
50 #include <dev/pccard/pccard_cis.h>
52 #include <dev/cardbus/cardbusreg.h>
53 #include <dev/cardbus/cardbusvar.h>
54 #include <dev/cardbus/cardbus_cis.h>
56 extern int cardbus_cis_debug;
58 #define DPRINTF(a) if (cardbus_cis_debug) printf a
59 #define DEVPRINTF(x) if (cardbus_cis_debug) device_printf x
61 struct tuple_callbacks;
63 typedef int (tuple_cb) (device_t cbdev, device_t child, int id, int len,
64 uint8_t *tupledata, uint32_t start, uint32_t *off,
65 struct tuple_callbacks *info);
67 struct tuple_callbacks {
73 static int decode_tuple_generic(device_t cbdev, device_t child, int id,
74 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
75 struct tuple_callbacks *info);
76 static int decode_tuple_linktarget(device_t cbdev, device_t child, int id,
77 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
78 struct tuple_callbacks *info);
79 static int decode_tuple_vers_1(device_t cbdev, device_t child, int id,
80 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
81 struct tuple_callbacks *info);
82 static int decode_tuple_funcid(device_t cbdev, device_t child, int id,
83 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
84 struct tuple_callbacks *info);
85 static int decode_tuple_manfid(device_t cbdev, device_t child, int id,
86 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
87 struct tuple_callbacks *info);
88 static int decode_tuple_funce(device_t cbdev, device_t child, int id,
89 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
90 struct tuple_callbacks *info);
91 static int decode_tuple_bar(device_t cbdev, device_t child, int id,
92 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
93 struct tuple_callbacks *info);
94 static int decode_tuple_unhandled(device_t cbdev, device_t child, int id,
95 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
96 struct tuple_callbacks *info);
97 static int decode_tuple_end(device_t cbdev, device_t child, int id,
98 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
99 struct tuple_callbacks *info);
101 static int cardbus_read_tuple_conf(device_t cbdev, device_t child,
102 uint32_t start, uint32_t *off, int *tupleid, int *len,
104 static int cardbus_read_tuple_mem(device_t cbdev, struct resource *res,
105 uint32_t start, uint32_t *off, int *tupleid, int *len,
107 static int cardbus_read_tuple(device_t cbdev, device_t child,
108 struct resource *res, uint32_t start, uint32_t *off,
109 int *tupleid, int *len, uint8_t *tupledata);
110 static void cardbus_read_tuple_finish(device_t cbdev, device_t child,
111 int rid, struct resource *res);
112 static struct resource *cardbus_read_tuple_init(device_t cbdev, device_t child,
113 uint32_t *start, int *rid);
114 static int decode_tuple(device_t cbdev, device_t child, int tupleid,
115 int len, uint8_t *tupledata, uint32_t start,
116 uint32_t *off, struct tuple_callbacks *callbacks);
117 static int cardbus_parse_cis(device_t cbdev, device_t child,
118 struct tuple_callbacks *callbacks);
120 #define MAKETUPLE(NAME,FUNC) { CISTPL_ ## NAME, #NAME, decode_tuple_ ## FUNC }
122 static char *funcnames[] = {
136 * Handler functions for various CIS tuples
140 decode_tuple_generic(device_t cbdev, device_t child, int id,
141 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
142 struct tuple_callbacks *info)
146 if (cardbus_cis_debug) {
148 printf("TUPLE: %s [%d]:", info->name, len);
150 printf("TUPLE: Unknown(0x%02x) [%d]:", id, len);
152 for (i = 0; i < len; i++) {
153 if (i % 0x10 == 0 && len > 0x10)
154 printf("\n 0x%02x:", i);
155 printf(" %02x", tupledata[i]);
163 decode_tuple_linktarget(device_t cbdev, device_t child, int id,
164 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
165 struct tuple_callbacks *info)
169 if (cardbus_cis_debug) {
170 printf("TUPLE: %s [%d]:", info->name, len);
172 for (i = 0; i < len; i++) {
173 if (i % 0x10 == 0 && len > 0x10)
174 printf("\n 0x%02x:", i);
175 printf(" %02x", tupledata[i]);
179 if (len != 3 || tupledata[0] != 'C' || tupledata[1] != 'I' ||
180 tupledata[2] != 'S') {
181 printf("Invalid data for CIS Link Target!\n");
182 decode_tuple_generic(cbdev, child, id, len, tupledata,
190 decode_tuple_vers_1(device_t cbdev, device_t child, int id,
191 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
192 struct tuple_callbacks *info)
196 if (cardbus_cis_debug) {
197 printf("Product version: %d.%d\n", tupledata[0], tupledata[1]);
198 printf("Product name: ");
199 for (i = 2; i < len; i++) {
200 if (tupledata[i] == '\0')
202 else if (tupledata[i] == 0xff)
205 printf("%c", tupledata[i]);
213 decode_tuple_funcid(device_t cbdev, device_t child, int id,
214 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
215 struct tuple_callbacks *info)
217 struct cardbus_devinfo *dinfo = device_get_ivars(child);
218 int numnames = sizeof(funcnames) / sizeof(funcnames[0]);
221 if (cardbus_cis_debug) {
222 printf("Functions: ");
223 for (i = 0; i < len; i++) {
224 if (tupledata[i] < numnames)
225 printf("%s", funcnames[tupledata[i]]);
227 printf("Unknown(%d)", tupledata[i]);
234 dinfo->funcid = tupledata[0]; /* use first in list */
239 decode_tuple_manfid(device_t cbdev, device_t child, int id,
240 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
241 struct tuple_callbacks *info)
243 struct cardbus_devinfo *dinfo = device_get_ivars(child);
246 if (cardbus_cis_debug) {
247 printf("Manufacturer ID: ");
248 for (i = 0; i < len; i++)
249 printf("%02x", tupledata[i]);
254 dinfo->mfrid = tupledata[1] | (tupledata[2] << 8);
255 dinfo->prodid = tupledata[3] | (tupledata[4] << 8);
261 decode_tuple_funce(device_t cbdev, device_t child, int id,
262 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
263 struct tuple_callbacks *info)
265 struct cardbus_devinfo *dinfo = device_get_ivars(child);
268 if (cardbus_cis_debug) {
269 printf("Function Extension: ");
270 for (i = 0; i < len; i++)
271 printf("%02x", tupledata[i]);
274 if (len < 2) /* too short */
276 type = tupledata[0]; /* XXX <32 always? */
277 switch (dinfo->funcid) {
278 case PCCARD_FUNCTION_NETWORK:
280 case PCCARD_TPLFE_TYPE_LAN_NID:
281 if (tupledata[1] > sizeof(dinfo->funce.lan.nid)) {
282 /* ignore, warning? */
285 bcopy(tupledata + 2, dinfo->funce.lan.nid,
289 dinfo->fepresent |= 1<<type;
296 decode_tuple_bar(device_t cbdev, device_t child, int id,
297 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
298 struct tuple_callbacks *info)
300 struct cardbus_devinfo *dinfo = device_get_ivars(child);
303 uint32_t bar, pci_bar;
306 device_printf(cbdev, "CIS BAR length not 6 (%d)\n", len);
311 len = le32toh(*(uint32_t*)(tupledata + 2));
312 if (reg & TPL_BAR_REG_AS) {
313 type = SYS_RES_IOPORT;
315 type = SYS_RES_MEMORY;
318 bar = reg & TPL_BAR_REG_ASI_MASK;
320 device_printf(cbdev, "Invalid BAR type 0 in CIS\n");
321 return (EINVAL); /* XXX Return an error? */
322 } else if (bar == 7) {
323 /* XXX Should we try to map in Option ROMs? */
327 /* Convert from BAR type to BAR offset */
328 bar = CARDBUS_BASE0_REG + (bar - 1) * 4;
330 if (type == SYS_RES_MEMORY) {
331 if (reg & TPL_BAR_REG_PREFETCHABLE)
332 dinfo->mprefetchable |= BARBIT(bar);
335 * XXX: It appears from a careful reading of the spec
336 * that we're not supposed to honor this when the bridge
337 * is not on the main system bus. PCI spec doesn't appear
338 * to allow for memory ranges not listed in the bridge's
339 * decode range to be decoded. The PC Card spec seems to
340 * indicate that this should only be done on x86 based
341 * machines, which seems to imply that on non-x86 machines
342 * the adddresses can be anywhere. This further implies that
343 * since the hardware can do it on non-x86 machines, it should
344 * be able to do it on x86 machines. Therefore, we can and
345 * should ignore this hint. Furthermore, the PC Card spec
346 * recommends always allocating memory above 1MB, contradicting
347 * the other part of the PC Card spec.
349 * NetBSD ignores this bit, but it also ignores the
350 * prefetchable bit too, so that's not an indication of
353 if (reg & TPL_BAR_REG_BELOW1MB)
354 dinfo->mbelow1mb |= BARBIT(bar);
359 * Sanity check the BAR length reported in the CIS with the length
360 * encoded in the PCI BAR. The latter seems to be more reliable.
361 * XXX - This probably belongs elsewhere.
363 pci_write_config(child, bar, 0xffffffff, 4);
364 pci_bar = pci_read_config(child, bar, 4);
365 if ((pci_bar != 0x0) && (pci_bar != 0xffffffff)) {
366 if (type == SYS_RES_MEMORY) {
371 len = 1 << (ffs(pci_bar) - 1);
374 DEVPRINTF((cbdev, "Opening BAR: type=%s, bar=%02x, len=%04x%s%s\n",
375 (type == SYS_RES_MEMORY) ? "MEM" : "IO", bar, len,
376 (type == SYS_RES_MEMORY && dinfo->mprefetchable & BARBIT(bar)) ?
377 " (Prefetchable)" : "", type == SYS_RES_MEMORY ?
378 ((dinfo->mbelow1mb & BARBIT(bar)) ? " (Below 1Mb)" : "") : ""));
380 resource_list_add(&dinfo->pci.resources, type, bar, 0UL, ~0UL, len);
383 * Mark the appropriate bit in the PCI command register so that
384 * device drivers will know which type of BARs can be used.
386 pci_enable_io(child, type);
391 decode_tuple_unhandled(device_t cbdev, device_t child, int id,
392 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
393 struct tuple_callbacks *info)
395 /* Make this message suck less XXX */
396 printf("TUPLE: %s [%d] is unhandled! Bailing...", info->name, len);
401 decode_tuple_end(device_t cbdev, device_t child, int id,
402 int len, uint8_t *tupledata, uint32_t start, uint32_t *off,
403 struct tuple_callbacks *info)
405 if (cardbus_cis_debug)
406 printf("CIS reading done\n");
411 * Functions to read the a tuple from the card
415 cardbus_read_tuple_conf(device_t cbdev, device_t child, uint32_t start,
416 uint32_t *off, int *tupleid, int *len, uint8_t *tupledata)
424 e = pci_read_config(child, loc - loc % 4, 4);
425 for (j = loc % 4; j > 0; j--)
428 for (i = loc, j = -2; j < *len; j++, i++) {
430 e = pci_read_config(child, i, 4);
436 tupledata[j] = 0xff & e;
444 cardbus_read_tuple_mem(device_t cbdev, struct resource *res, uint32_t start,
445 uint32_t *off, int *tupleid, int *len, uint8_t *tupledata)
448 bus_space_handle_t bh;
451 bt = rman_get_bustag(res);
452 bh = rman_get_bushandle(res);
454 *tupleid = bus_space_read_1(bt, bh, start + *off);
455 *len = bus_space_read_1(bt, bh, start + *off + 1);
456 bus_space_read_region_1(bt, bh, *off + start + 2, tupledata, *len);
463 cardbus_read_tuple(device_t cbdev, device_t child, struct resource *res,
464 uint32_t start, uint32_t *off, int *tupleid, int *len,
467 if (res == (struct resource*)~0UL) {
468 return (cardbus_read_tuple_conf(cbdev, child, start, off,
469 tupleid, len, tupledata));
471 return (cardbus_read_tuple_mem(cbdev, res, start, off,
472 tupleid, len, tupledata));
477 cardbus_read_tuple_finish(device_t cbdev, device_t child, int rid,
478 struct resource *res)
480 if (res != (struct resource*)~0UL) {
481 bus_release_resource(cbdev, SYS_RES_MEMORY, rid, res);
482 pci_write_config(child, rid, 0, 4);
483 PCI_DISABLE_IO(cbdev, child, SYS_RES_MEMORY);
487 static struct resource *
488 cardbus_read_tuple_init(device_t cbdev, device_t child, uint32_t *start,
493 struct resource *res;
495 switch (CARDBUS_CIS_SPACE(*start)) {
496 case CARDBUS_CIS_ASI_TUPLE:
497 /* CIS in PCI config space need no initialization */
498 return ((struct resource*)~0UL);
499 case CARDBUS_CIS_ASI_BAR0:
500 case CARDBUS_CIS_ASI_BAR1:
501 case CARDBUS_CIS_ASI_BAR2:
502 case CARDBUS_CIS_ASI_BAR3:
503 case CARDBUS_CIS_ASI_BAR4:
504 case CARDBUS_CIS_ASI_BAR5:
505 *rid = CARDBUS_BASE0_REG + (CARDBUS_CIS_SPACE(*start) - 1) * 4;
507 case CARDBUS_CIS_ASI_ROM:
508 *rid = CARDBUS_ROM_REG;
511 * This mask doesn't contain the bit that actually enables
514 pci_write_config(child, *rid, CARDBUS_ROM_ADDRMASK, 4);
518 device_printf(cbdev, "Unable to read CIS: Unknown space: %d\n",
519 CARDBUS_CIS_SPACE(*start));
523 /* figure out how much space we need */
524 pci_write_config(child, *rid, 0xffffffff, 4);
525 testval = pci_read_config(child, *rid, 4);
528 * This bit has a different meaning depending if we are dealing
529 * with a normal BAR or an Option ROM BAR.
531 if (((testval & 0x1) == 0x1) && (*rid != CARDBUS_ROM_REG)) {
532 device_printf(cbdev, "CIS Space is IO, expecting memory.\n");
536 size = CARDBUS_MAPREG_MEM_SIZE(testval);
537 /* XXX Is this some kind of hack? */
540 /* allocate the memory space to read CIS */
541 res = bus_alloc_resource(cbdev, SYS_RES_MEMORY, rid, 0, ~0, size,
542 rman_make_alignment_flags(size) | RF_ACTIVE);
544 device_printf(cbdev, "Unable to allocate resource "
548 pci_write_config(child, *rid,
549 rman_get_start(res) | ((*rid == CARDBUS_ROM_REG)?
550 CARDBUS_ROM_ENABLE : 0),
552 PCI_ENABLE_IO(cbdev, child, SYS_RES_MEMORY);
554 /* Flip to the right ROM image if CIS is in ROM */
555 if (CARDBUS_CIS_SPACE(*start) == CARDBUS_CIS_ASI_ROM) {
557 bus_space_handle_t bh;
559 uint32_t imagebase = 0;
565 bt = rman_get_bustag(res);
566 bh = rman_get_bushandle(res);
568 imagenum = CARDBUS_CIS_ASI_ROM_IMAGE(*start);
569 for (romnum = 0;; romnum++) {
570 romsig = bus_space_read_2(bt, bh,
571 imagebase + CARDBUS_EXROM_SIGNATURE);
572 if (romsig != 0xaa55) {
573 device_printf(cbdev, "Bad header in rom %d: "
574 "[%x] %04x\n", romnum, imagebase +
575 CARDBUS_EXROM_SIGNATURE, romsig);
576 bus_release_resource(cbdev, SYS_RES_MEMORY,
583 * If this was the Option ROM image that we were
584 * looking for, then we are done.
586 if (romnum == imagenum)
589 /* Find out where the next Option ROM image is */
590 pcidata = imagebase + bus_space_read_2(bt, bh,
591 imagebase + CARDBUS_EXROM_DATA_PTR);
592 imagesize = bus_space_read_2(bt, bh,
593 pcidata + CARDBUS_EXROM_DATA_IMAGE_LENGTH);
595 if (imagesize == 0) {
597 * XXX some ROMs seem to have this as zero,
598 * can we assume this means 1 block?
600 device_printf(cbdev, "Warning, size of Option "
601 "ROM image %d is 0 bytes, assuming 512 "
606 /* Image size is in 512 byte units */
609 if ((bus_space_read_1(bt, bh, pcidata +
610 CARDBUS_EXROM_DATA_INDICATOR) & 0x80) != 0) {
611 device_printf(cbdev, "Cannot find CIS in "
613 bus_release_resource(cbdev, SYS_RES_MEMORY,
618 imagebase += imagesize;
620 *start = imagebase + CARDBUS_CIS_ADDR(*start);
622 *start = CARDBUS_CIS_ADDR(*start);
629 * Dispatch the right handler function per tuple
633 decode_tuple(device_t cbdev, device_t child, int tupleid, int len,
634 uint8_t *tupledata, uint32_t start, uint32_t *off,
635 struct tuple_callbacks *callbacks)
638 for (i = 0; callbacks[i].id != CISTPL_GENERIC; i++) {
639 if (tupleid == callbacks[i].id)
640 return (callbacks[i].func(cbdev, child, tupleid, len,
641 tupledata, start, off, &callbacks[i]));
643 return (callbacks[i].func(cbdev, child, tupleid, len,
644 tupledata, start, off, NULL));
648 cardbus_parse_cis(device_t cbdev, device_t child,
649 struct tuple_callbacks *callbacks)
651 uint8_t tupledata[MAXTUPLESIZE];
654 int expect_linktarget;
656 struct resource *res;
659 bzero(tupledata, MAXTUPLESIZE);
660 expect_linktarget = TRUE;
661 if ((start = pci_read_config(child, CARDBUS_CIS_REG, 4)) == 0) {
662 device_printf(cbdev, "CIS pointer is 0!\n");
666 res = cardbus_read_tuple_init(cbdev, child, &start, &rid);
668 device_printf(cbdev, "Unable to allocate resources for CIS\n");
673 if (0 != cardbus_read_tuple(cbdev, child, res, start, &off,
674 &tupleid, &len, tupledata)) {
675 device_printf(cbdev, "Failed to read CIS.\n");
676 cardbus_read_tuple_finish(cbdev, child, rid, res);
680 if (expect_linktarget && tupleid != CISTPL_LINKTARGET) {
681 device_printf(cbdev, "Expecting link target, got 0x%x\n",
683 cardbus_read_tuple_finish(cbdev, child, rid, res);
686 expect_linktarget = decode_tuple(cbdev, child, tupleid, len,
687 tupledata, start, &off, callbacks);
688 if (expect_linktarget != 0) {
689 device_printf(cbdev, "Parsing failed with %d\n",
691 cardbus_read_tuple_finish(cbdev, child, rid, res);
692 return (expect_linktarget);
694 } while (tupleid != CISTPL_END);
695 cardbus_read_tuple_finish(cbdev, child, rid, res);
700 cardbus_do_cis(device_t cbdev, device_t child)
703 struct tuple_callbacks init_callbacks[] = {
704 MAKETUPLE(LONGLINK_CB, unhandled),
705 MAKETUPLE(INDIRECT, unhandled),
706 MAKETUPLE(LONGLINK_MFC, unhandled),
708 MAKETUPLE(LONGLINK_A, unhandled),
709 MAKETUPLE(LONGLINK_C, unhandled),
710 MAKETUPLE(LINKTARGET, linktarget),
711 MAKETUPLE(VERS_1, vers_1),
712 MAKETUPLE(MANFID, manfid),
713 MAKETUPLE(FUNCID, funcid),
714 MAKETUPLE(FUNCE, funce),
716 MAKETUPLE(GENERIC, generic),
719 ret = cardbus_parse_cis(cbdev, child, init_callbacks);