2 * Copyright (c) 1997 Marc Horowitz. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. All advertising materials mentioning features or use of this software
13 * must display the following acknowledgement:
14 * This product includes software developed by Marc Horowitz.
15 * 4. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 * $NetBSD: pcmcia_cis.c,v 1.10 1998/12/29 09:03:15 marc Exp $
30 * $FreeBSD: src/sys/dev/pccard/pccard_cis.c,v 1.5.2.1 2000/05/23 03:56:59 imp Exp $
31 * $DragonFly: src/sys/dev/misc/pccard/Attic/pccard_cis.c,v 1.3 2003/08/15 08:32:29 dillon Exp $
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>
43 #include <machine/bus.h>
45 #include <machine/resource.h>
47 #include <bus/pccard/pccardreg.h>
48 #include <bus/pccard/pccardvar.h>
52 #define PCCARDCISDEBUG
54 int pccardcis_debug = 1;
55 #define DPRINTF(arg) if (pccardcis_debug) printf arg
56 #define DEVPRINTF(arg) if (pccardcis_debug) device_printf arg
59 #define DEVPRINTF(arg)
62 #define PCCARD_CIS_SIZE 1024
67 struct pccard_config_entry temp_cfe;
68 struct pccard_config_entry *default_cfe;
69 struct pccard_card *card;
70 struct pccard_function *pf;
73 int pccard_parse_cis_tuple(struct pccard_tuple *, void *);
76 pccard_read_cis(struct pccard_softc *sc)
78 struct cis_state state;
83 state.card = &sc->card;
85 state.card->error = 0;
86 state.card->cis1_major = -1;
87 state.card->cis1_minor = -1;
88 state.card->cis1_info[0] = NULL;
89 state.card->cis1_info[1] = NULL;
90 state.card->cis1_info[2] = NULL;
91 state.card->cis1_info[3] = NULL;
92 state.card->manufacturer = PCCARD_VENDOR_INVALID;
93 state.card->product = PCCARD_PRODUCT_INVALID;
94 STAILQ_INIT(&state.card->pf_head);
98 printf("Calling scan_cis\n");
100 if (pccard_scan_cis(sc->dev, pccard_parse_cis_tuple,
106 pccard_scan_cis(device_t dev, int (*fct)(struct pccard_tuple *, void *),
109 struct resource *res;
111 struct pccard_tuple tuple;
112 int longlink_present;
114 u_long longlink_addr;
125 /* allocate some memory */
128 res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0, ~0,
129 PCCARD_CIS_SIZE, RF_ACTIVE);
131 device_printf(dev, "can't alloc memory to read attributes\n");
134 CARD_SET_RES_FLAGS(device_get_parent(dev), dev, SYS_RES_MEMORY,
135 rid, PCCARD_A_MEM_ATTR);
136 tuple.memt = rman_get_bustag(res);
137 tuple.memh = rman_get_bushandle(res);
140 DPRINTF(("cis mem map %x\n", (unsigned int) tuple.memh));
144 longlink_present = 1;
151 DEVPRINTF((dev, "CIS tuple chain:\n"));
155 /* get the tuple code */
157 tuple.code = pccard_cis_read_1(&tuple, tuple.ptr);
159 /* two special-case tuples */
161 if (tuple.code == PCCARD_CISTPL_NULL) {
162 DPRINTF(("CISTPL_NONE\n 00\n"));
165 } else if (tuple.code == PCCARD_CISTPL_END) {
166 DPRINTF(("CISTPL_END\n ff\n"));
167 /* Call the function for the END tuple, since
168 the CIS semantics depend on it */
169 if ((*fct) (&tuple, arg)) {
173 ret = 1; goto done; /* XXX IMP XXX */
177 /* now all the normal tuples */
179 tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
180 switch (tuple.code) {
181 case PCCARD_CISTPL_LONGLINK_A:
182 case PCCARD_CISTPL_LONGLINK_C:
183 if (tuple.length < 4) {
184 DPRINTF(("CISTPL_LONGLINK_%s too "
186 longlink_common ? "C" : "A",
190 longlink_present = 1;
191 longlink_common = (tuple.code ==
192 PCCARD_CISTPL_LONGLINK_C) ? 1 : 0;
193 longlink_addr = pccard_tuple_read_4(&tuple, 0);
194 DPRINTF(("CISTPL_LONGLINK_%s %lx\n",
195 longlink_common ? "C" : "A",
198 case PCCARD_CISTPL_NO_LINK:
199 longlink_present = 0;
200 DPRINTF(("CISTPL_NO_LINK\n"));
202 case PCCARD_CISTPL_CHECKSUM:
203 if (tuple.length < 5) {
204 DPRINTF(("CISTPL_CHECKSUM too "
205 "short %d\n", tuple.length));
213 *((u_int16_t *) & offset) =
214 pccard_tuple_read_2(&tuple, 0);
215 length = pccard_tuple_read_2(&tuple, 2);
216 cksum = pccard_tuple_read_1(&tuple, 4);
218 addr = tuple.ptr + offset;
220 DPRINTF(("CISTPL_CHECKSUM addr=%lx "
222 addr, length, cksum));
225 * XXX do more work to deal with
228 if ((addr >= PCCARD_CIS_SIZE) ||
229 ((addr + length) < 0) ||
232 DPRINTF((" skipped, "
237 for (i = 0; i < length; i++)
239 bus_space_read_1(tuple.memt,
241 addr + tuple.mult * i);
242 if (cksum != (sum & 0xff)) {
243 DPRINTF((" failed sum=%x\n",
246 "CIS checksum failed\n");
249 * XXX Some working cards have
250 * XXX bad checksums!!
259 case PCCARD_CISTPL_LONGLINK_MFC:
260 if (tuple.length < 1) {
261 DPRINTF(("CISTPL_LONGLINK_MFC too "
262 "short %d\n", tuple.length));
266 * this is kind of ad hoc, as I don't have
267 * any real documentation
273 pccard_tuple_read_1(&tuple, 0);
274 DPRINTF(("CISTPL_LONGLINK_MFC %d",
276 for (i = 0; i < mfc_count; i++) {
278 (pccard_tuple_read_1(&tuple,
280 PCCARD_MFC_MEM_COMMON) ?
283 pccard_tuple_read_4(&tuple,
286 mfc[i].common ? "common" :
287 "attr", mfc[i].addr));
292 * for LONGLINK_MFC, fall through to the
293 * function. This tuple has structural and
298 if ((*fct) (&tuple, arg)) {
305 #ifdef PCCARDCISDEBUG
306 /* print the tuple */
310 DPRINTF((" %02x %02x", tuple.code,
313 for (i = 0; i < tuple.length; i++) {
315 pccard_tuple_read_1(&tuple, i)));
323 /* skip to the next tuple */
324 tuple.ptr += 2 + tuple.length;
327 #ifdef XXX /* I'm not up to this tonight, need to implement new API */
328 /* to deal with moving windows and such. At least that's */
329 /* what it appears at this instant */
332 * the chain is done. Clean up and move onto the next one,
333 * if any. The loop is here in the case that there is an MFC
334 * card with no longlink (which defaults to existing, == 0).
335 * In general, this means that if one pointer fails, it will
336 * try the next one, instead of just bailing.
340 pccard_chip_mem_unmap(pct, pch, window);
342 if (longlink_present) {
344 * if the longlink is to attribute memory,
345 * then it is unindexed. That is, if the
346 * link value is 0x100, then the actual
347 * memory address is 0x200. This means that
348 * we need to multiply by 2 before calling
349 * mem_map, and then divide the resulting ptr
353 if (!longlink_common)
356 pccard_chip_mem_map(pct, pch, longlink_common ?
357 PCCARD_MEM_COMMON : PCCARD_MEM_ATTR,
358 longlink_addr, PCCARD_CIS_SIZE,
359 &pcmh, &tuple.ptr, &window);
361 if (!longlink_common)
363 DPRINTF(("cis mem map %x\n",
364 (unsigned int) tuple.memh));
365 tuple.mult = longlink_common ? 1 : 2;
366 longlink_present = 0;
369 } else if (mfc_count && (mfc_index < mfc_count)) {
370 if (!mfc[mfc_index].common)
371 mfc[mfc_index].addr *= 2;
373 pccard_chip_mem_map(pct, pch,
374 mfc[mfc_index].common ?
375 PCCARD_MEM_COMMON : PCCARD_MEM_ATTR,
376 mfc[mfc_index].addr, PCCARD_CIS_SIZE,
377 &pcmh, &tuple.ptr, &window);
379 if (!mfc[mfc_index].common)
381 DPRINTF(("cis mem map %x\n",
382 (unsigned int) tuple.memh));
383 /* set parse state, and point at the next one */
385 tuple.mult = mfc[mfc_index].common ? 1 : 2;
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));
399 tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
400 if (tuple.length < 3) {
401 DPRINTF(("CISTPL_LINKTARGET too short %d\n",
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)));
415 tuple.ptr += 2 + tuple.length;
423 bus_release_resource(dev, SYS_RES_MEMORY, rid, res);
428 /* XXX this is incredibly verbose. Not sure what trt is */
431 pccard_print_cis(device_t dev)
433 struct pccard_softc *sc = (struct pccard_softc *) device_get_softc(dev);
434 struct pccard_card *card = &sc->card;
435 struct pccard_function *pf;
436 struct pccard_config_entry *cfe;
439 device_printf(dev, "CIS version ");
440 if (card->cis1_major == 4) {
441 if (card->cis1_minor == 0)
442 printf("PCCARD 1.0\n");
443 else if (card->cis1_minor == 1)
444 printf("PCCARD 2.0 or 2.1\n");
445 } else if (card->cis1_major >= 5)
446 printf("PC Card Standard %d.%d\n", card->cis1_major, card->cis1_minor);
448 printf("unknown (major=%d, minor=%d)\n",
449 card->cis1_major, card->cis1_minor);
451 device_printf(dev, "CIS info: ");
452 for (i = 0; i < 4; i++) {
453 if (card->cis1_info[i] == NULL)
457 printf("%s", card->cis1_info[i]);
461 device_printf(dev, "Manufacturer code 0x%x, product 0x%x\n",
462 card->manufacturer, card->product);
464 STAILQ_FOREACH(pf, &card->pf_head, pf_list) {
465 device_printf(dev, "function %d: ", pf->number);
467 switch (pf->function) {
468 case PCCARD_FUNCTION_UNSPEC:
469 printf("unspecified");
471 case PCCARD_FUNCTION_MULTIFUNCTION:
472 printf("multi-function");
474 case PCCARD_FUNCTION_MEMORY:
477 case PCCARD_FUNCTION_SERIAL:
478 printf("serial port");
480 case PCCARD_FUNCTION_PARALLEL:
481 printf("parallel port");
483 case PCCARD_FUNCTION_DISK:
484 printf("fixed disk");
486 case PCCARD_FUNCTION_VIDEO:
487 printf("video adapter");
489 case PCCARD_FUNCTION_NETWORK:
490 printf("network adapter");
492 case PCCARD_FUNCTION_AIMS:
493 printf("auto incrementing mass storage");
495 case PCCARD_FUNCTION_SCSI:
496 printf("SCSI bridge");
498 case PCCARD_FUNCTION_SECURITY:
499 printf("Security services");
501 case PCCARD_FUNCTION_INSTRUMENT:
502 printf("Instrument");
505 printf("unknown (%d)", pf->function);
509 printf(", ccr addr %lx mask %lx\n", pf->ccr_base, pf->ccr_mask);
511 STAILQ_FOREACH(cfe, &pf->cfe_head, cfe_list) {
512 device_printf(dev, "function %d, config table entry "
513 "%d: ", pf->number, cfe->number);
515 switch (cfe->iftype) {
516 case PCCARD_IFTYPE_MEMORY:
517 printf("memory card");
519 case PCCARD_IFTYPE_IO:
523 printf("card type unknown");
527 printf("; irq mask %x", cfe->irqmask);
529 if (cfe->num_iospace) {
530 printf("; iomask %lx, iospace", cfe->iomask);
532 for (i = 0; i < cfe->num_iospace; i++) {
533 printf(" %lx", cfe->iospace[i].start);
534 if (cfe->iospace[i].length)
536 cfe->iospace[i].start +
537 cfe->iospace[i].length - 1);
540 if (cfe->num_memspace) {
541 printf("; memspace");
543 for (i = 0; i < cfe->num_memspace; i++) {
545 cfe->memspace[i].cardaddr);
546 if (cfe->memspace[i].length)
548 cfe->memspace[i].cardaddr +
549 cfe->memspace[i].length - 1);
550 if (cfe->memspace[i].hostaddr)
552 cfe->memspace[i].hostaddr);
556 printf("; maxtwins %d", cfe->maxtwins);
560 if (cfe->flags & PCCARD_CFE_MWAIT_REQUIRED)
561 printf(" mwait_required");
562 if (cfe->flags & PCCARD_CFE_RDYBSY_ACTIVE)
563 printf(" rdybsy_active");
564 if (cfe->flags & PCCARD_CFE_WP_ACTIVE)
565 printf(" wp_active");
566 if (cfe->flags & PCCARD_CFE_BVD_ACTIVE)
567 printf(" bvd_active");
568 if (cfe->flags & PCCARD_CFE_IO8)
570 if (cfe->flags & PCCARD_CFE_IO16)
572 if (cfe->flags & PCCARD_CFE_IRQSHARE)
574 if (cfe->flags & PCCARD_CFE_IRQPULSE)
576 if (cfe->flags & PCCARD_CFE_IRQLEVEL)
578 if (cfe->flags & PCCARD_CFE_POWERDOWN)
579 printf(" powerdown");
580 if (cfe->flags & PCCARD_CFE_READONLY)
582 if (cfe->flags & PCCARD_CFE_AUDIO)
590 device_printf(dev, "%d errors found while parsing CIS\n",
595 pccard_parse_cis_tuple(struct pccard_tuple *tuple, void *arg)
597 /* most of these are educated guesses */
598 static struct pccard_config_entry init_cfe = {
599 -1, PCCARD_CFE_RDYBSY_ACTIVE | PCCARD_CFE_WP_ACTIVE |
600 PCCARD_CFE_BVD_ACTIVE, PCCARD_IFTYPE_MEMORY,
603 struct cis_state *state = arg;
605 switch (tuple->code) {
606 case PCCARD_CISTPL_END:
607 /* if we've seen a LONGLINK_MFC, and this is the first
608 * END after it, reset the function list.
610 * XXX This might also be the right place to start a
611 * new function, but that assumes that a function
612 * definition never crosses any longlink, and I'm not
613 * sure about that. This is probably safe for MFC
614 * cards, but what we have now isn't broken, so I'd
615 * rather not change it.
617 if (state->gotmfc == 1) {
618 struct pccard_function *pf, *pfnext;
620 for (pf = STAILQ_FIRST(&state->card->pf_head);
621 pf != NULL; pf = pfnext) {
622 pfnext = STAILQ_NEXT(pf, pf_list);
626 STAILQ_INIT(&state->card->pf_head);
633 case PCCARD_CISTPL_LONGLINK_MFC:
635 * this tuple's structure was dealt with in scan_cis. here,
636 * record the fact that the MFC tuple was seen, so that
637 * functions declared before the MFC link can be cleaned
642 #ifdef PCCARDCISDEBUG
643 case PCCARD_CISTPL_DEVICE:
644 case PCCARD_CISTPL_DEVICE_A:
646 u_int reg, dtype, dspeed;
648 reg = pccard_tuple_read_1(tuple, 0);
649 dtype = reg & PCCARD_DTYPE_MASK;
650 dspeed = reg & PCCARD_DSPEED_MASK;
652 DPRINTF(("CISTPL_DEVICE%s type=",
653 (tuple->code == PCCARD_CISTPL_DEVICE) ? "" : "_A"));
655 case PCCARD_DTYPE_NULL:
658 case PCCARD_DTYPE_ROM:
661 case PCCARD_DTYPE_OTPROM:
664 case PCCARD_DTYPE_EPROM:
667 case PCCARD_DTYPE_EEPROM:
670 case PCCARD_DTYPE_FLASH:
673 case PCCARD_DTYPE_SRAM:
676 case PCCARD_DTYPE_DRAM:
679 case PCCARD_DTYPE_FUNCSPEC:
680 DPRINTF(("funcspec"));
682 case PCCARD_DTYPE_EXTEND:
686 DPRINTF(("reserved"));
689 DPRINTF((" speed="));
691 case PCCARD_DSPEED_NULL:
694 case PCCARD_DSPEED_250NS:
697 case PCCARD_DSPEED_200NS:
700 case PCCARD_DSPEED_150NS:
703 case PCCARD_DSPEED_100NS:
706 case PCCARD_DSPEED_EXT:
710 DPRINTF(("reserved"));
717 case PCCARD_CISTPL_VERS_1:
718 if (tuple->length < 6) {
719 DPRINTF(("CISTPL_VERS_1 too short %d\n",
723 int start, i, ch, count;
725 state->card->cis1_major = pccard_tuple_read_1(tuple, 0);
726 state->card->cis1_minor = pccard_tuple_read_1(tuple, 1);
728 for (count = 0, start = 0, i = 0;
729 (count < 4) && ((i + 4) < 256); i++) {
730 ch = pccard_tuple_read_1(tuple, 2 + i);
733 state->card->cis1_info_buf[i] = ch;
735 state->card->cis1_info[count] =
736 state->card->cis1_info_buf + start;
741 DPRINTF(("CISTPL_VERS_1\n"));
744 case PCCARD_CISTPL_MANFID:
745 if (tuple->length < 4) {
746 DPRINTF(("CISTPL_MANFID too short %d\n",
750 state->card->manufacturer = pccard_tuple_read_2(tuple, 0);
751 state->card->product = pccard_tuple_read_2(tuple, 2);
752 DPRINTF(("CISTPL_MANFID\n"));
754 case PCCARD_CISTPL_FUNCID:
755 if (tuple->length < 1) {
756 DPRINTF(("CISTPL_FUNCID too short %d\n",
760 if ((state->pf == NULL) || (state->gotmfc == 2)) {
761 state->pf = malloc(sizeof(*state->pf), M_DEVBUF,
763 bzero(state->pf, sizeof(*state->pf));
764 state->pf->number = state->count++;
765 state->pf->last_config_index = -1;
766 STAILQ_INIT(&state->pf->cfe_head);
768 STAILQ_INSERT_TAIL(&state->card->pf_head, state->pf,
771 state->pf->function = pccard_tuple_read_1(tuple, 0);
773 DPRINTF(("CISTPL_FUNCID\n"));
775 case PCCARD_CISTPL_CONFIG:
776 if (tuple->length < 3) {
777 DPRINTF(("CISTPL_CONFIG too short %d\n",
781 u_int reg, rasz, rmsz, rfsz;
784 reg = pccard_tuple_read_1(tuple, 0);
785 rasz = 1 + ((reg & PCCARD_TPCC_RASZ_MASK) >>
786 PCCARD_TPCC_RASZ_SHIFT);
787 rmsz = 1 + ((reg & PCCARD_TPCC_RMSZ_MASK) >>
788 PCCARD_TPCC_RMSZ_SHIFT);
789 rfsz = ((reg & PCCARD_TPCC_RFSZ_MASK) >>
790 PCCARD_TPCC_RFSZ_SHIFT);
792 if (tuple->length < (rasz + rmsz + rfsz)) {
793 DPRINTF(("CISTPL_CONFIG (%d,%d,%d) too "
794 "short %d\n", rasz, rmsz, rfsz,
798 if (state->pf == NULL) {
799 state->pf = malloc(sizeof(*state->pf),
801 bzero(state->pf, sizeof(*state->pf));
802 state->pf->number = state->count++;
803 state->pf->last_config_index = -1;
804 STAILQ_INIT(&state->pf->cfe_head);
806 STAILQ_INSERT_TAIL(&state->card->pf_head,
809 state->pf->function = PCCARD_FUNCTION_UNSPEC;
811 state->pf->last_config_index =
812 pccard_tuple_read_1(tuple, 1);
814 state->pf->ccr_base = 0;
815 for (i = 0; i < rasz; i++)
816 state->pf->ccr_base |=
817 ((pccard_tuple_read_1(tuple, 2 + i)) <<
820 state->pf->ccr_mask = 0;
821 for (i = 0; i < rmsz; i++)
822 state->pf->ccr_mask |=
823 ((pccard_tuple_read_1(tuple,
824 2 + rasz + i)) << (i * 8));
826 /* skip the reserved area and subtuples */
828 /* reset the default cfe for each cfe list */
829 state->temp_cfe = init_cfe;
830 state->default_cfe = &state->temp_cfe;
832 DPRINTF(("CISTPL_CONFIG\n"));
834 case PCCARD_CISTPL_CFTABLE_ENTRY:
838 u_int intface, def, num;
839 u_int power, timing, iospace, irq, memspace, misc;
840 struct pccard_config_entry *cfe;
844 reg = pccard_tuple_read_1(tuple, idx);
846 intface = reg & PCCARD_TPCE_INDX_INTFACE;
847 def = reg & PCCARD_TPCE_INDX_DEFAULT;
848 num = reg & PCCARD_TPCE_INDX_NUM_MASK;
851 * this is a little messy. Some cards have only a
852 * cfentry with the default bit set. So, as we go
853 * through the list, we add new indexes to the queue,
854 * and keep a pointer to the last one with the
855 * default bit set. if we see a record with the same
856 * index, as the default, we stash the default and
857 * replace the queue entry. otherwise, we just add
858 * new entries to the queue, pointing the default ptr
859 * at them if the default bit is set. if we get to
860 * the end with the default pointer pointing at a
861 * record which hasn't had a matching index, that's
862 * ok; it just becomes a cfentry like any other.
866 * if the index in the cis differs from the default
867 * cis, create new entry in the queue and start it
868 * with the current default
870 if (num != state->default_cfe->number) {
871 cfe = (struct pccard_config_entry *)
872 malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
874 *cfe = *state->default_cfe;
876 STAILQ_INSERT_TAIL(&state->pf->cfe_head,
882 * if the default bit is set in the cis, then
883 * point the new default at whatever is being
887 state->default_cfe = cfe;
890 * the cis index matches the default index,
891 * fill in the default cfentry. It is
892 * assumed that the cfdefault index is in the
893 * queue. For it to be otherwise, the cis
894 * index would have to be -1 (initial
895 * condition) which is not possible, or there
896 * would have to be a preceding cis entry
897 * which had the same cis index and had the
898 * default bit unset. Neither condition
899 * should happen. If it does, this cfentry
900 * is lost (written into temp space), which
901 * is an acceptable failure mode.
904 cfe = state->default_cfe;
907 * if the cis entry does not have the default
908 * bit set, copy the default out of the way
912 state->temp_cfe = *state->default_cfe;
913 state->default_cfe = &state->temp_cfe;
918 reg = pccard_tuple_read_1(tuple, idx);
920 if (reg & PCCARD_TPCE_IF_MWAIT)
921 cfe->flags |= PCCARD_CFE_MWAIT_REQUIRED;
922 if (reg & PCCARD_TPCE_IF_RDYBSY)
923 cfe->flags |= PCCARD_CFE_RDYBSY_ACTIVE;
924 if (reg & PCCARD_TPCE_IF_WP)
925 cfe->flags |= PCCARD_CFE_WP_ACTIVE;
926 if (reg & PCCARD_TPCE_IF_BVD)
927 cfe->flags |= PCCARD_CFE_BVD_ACTIVE;
928 cfe->iftype = reg & PCCARD_TPCE_IF_IFTYPE;
930 reg = pccard_tuple_read_1(tuple, idx);
933 power = reg & PCCARD_TPCE_FS_POWER_MASK;
934 timing = reg & PCCARD_TPCE_FS_TIMING;
935 iospace = reg & PCCARD_TPCE_FS_IOSPACE;
936 irq = reg & PCCARD_TPCE_FS_IRQ;
937 memspace = reg & PCCARD_TPCE_FS_MEMSPACE_MASK;
938 misc = reg & PCCARD_TPCE_FS_MISC;
941 /* skip over power, don't save */
942 /* for each parameter selection byte */
943 for (i = 0; i < power; i++) {
944 reg = pccard_tuple_read_1(tuple, idx);
947 for (j = 0; j < 7; j++) {
948 /* if the bit is set */
949 if ((reg >> j) & 0x01) {
950 /* skip over bytes */
952 reg2 = pccard_tuple_read_1(tuple, idx);
959 } while (reg2 & 0x80);
965 /* skip over timing, don't save */
966 reg = pccard_tuple_read_1(tuple, idx);
969 if ((reg & PCCARD_TPCE_TD_RESERVED_MASK) !=
970 PCCARD_TPCE_TD_RESERVED_MASK)
972 if ((reg & PCCARD_TPCE_TD_RDYBSY_MASK) !=
973 PCCARD_TPCE_TD_RDYBSY_MASK)
975 if ((reg & PCCARD_TPCE_TD_WAIT_MASK) !=
976 PCCARD_TPCE_TD_WAIT_MASK)
980 if (tuple->length <= idx) {
981 DPRINTF(("ran out of space before TCPE_IO\n"));
985 reg = pccard_tuple_read_1(tuple, idx);
988 if (reg & PCCARD_TPCE_IO_BUSWIDTH_8BIT)
989 cfe->flags |= PCCARD_CFE_IO8;
990 if (reg & PCCARD_TPCE_IO_BUSWIDTH_16BIT)
991 cfe->flags |= PCCARD_CFE_IO16;
993 reg & PCCARD_TPCE_IO_IOADDRLINES_MASK;
995 if (reg & PCCARD_TPCE_IO_HASRANGE) {
996 reg = pccard_tuple_read_1(tuple, idx);
999 cfe->num_iospace = 1 + (reg &
1000 PCCARD_TPCE_IO_RANGE_COUNT);
1002 if (cfe->num_iospace >
1003 (sizeof(cfe->iospace) /
1004 sizeof(cfe->iospace[0]))) {
1005 DPRINTF(("too many io "
1008 state->card->error++;
1011 for (i = 0; i < cfe->num_iospace; i++) {
1012 switch (reg & PCCARD_TPCE_IO_RANGE_ADDRSIZE_MASK) {
1013 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_ONE:
1014 cfe->iospace[i].start =
1015 pccard_tuple_read_1(tuple, idx);
1018 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_TWO:
1019 cfe->iospace[i].start =
1020 pccard_tuple_read_2(tuple, idx);
1023 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_FOUR:
1024 cfe->iospace[i].start =
1025 pccard_tuple_read_4(tuple, idx);
1030 PCCARD_TPCE_IO_RANGE_LENGTHSIZE_MASK) {
1031 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_ONE:
1032 cfe->iospace[i].length =
1033 pccard_tuple_read_1(tuple, idx);
1036 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_TWO:
1037 cfe->iospace[i].length =
1038 pccard_tuple_read_2(tuple, idx);
1041 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_FOUR:
1042 cfe->iospace[i].length =
1043 pccard_tuple_read_4(tuple, idx);
1047 cfe->iospace[i].length++;
1050 cfe->num_iospace = 1;
1051 cfe->iospace[0].start = 0;
1052 cfe->iospace[0].length =
1057 if (tuple->length <= idx) {
1058 DPRINTF(("ran out of space before TCPE_IR\n"));
1062 reg = pccard_tuple_read_1(tuple, idx);
1065 if (reg & PCCARD_TPCE_IR_SHARE)
1066 cfe->flags |= PCCARD_CFE_IRQSHARE;
1067 if (reg & PCCARD_TPCE_IR_PULSE)
1068 cfe->flags |= PCCARD_CFE_IRQPULSE;
1069 if (reg & PCCARD_TPCE_IR_LEVEL)
1070 cfe->flags |= PCCARD_CFE_IRQLEVEL;
1072 if (reg & PCCARD_TPCE_IR_HASMASK) {
1074 * it's legal to ignore the
1075 * special-interrupt bits, so I will
1079 pccard_tuple_read_2(tuple, idx);
1083 (1 << (reg & PCCARD_TPCE_IR_IRQ));
1087 if (tuple->length <= idx) {
1088 DPRINTF(("ran out of space before TCPE_MS\n"));
1092 if (memspace == PCCARD_TPCE_FS_MEMSPACE_NONE) {
1093 cfe->num_memspace = 0;
1094 } else if (memspace == PCCARD_TPCE_FS_MEMSPACE_LENGTH) {
1095 cfe->num_memspace = 1;
1096 cfe->memspace[0].length = 256 *
1097 pccard_tuple_read_2(tuple, idx);
1099 cfe->memspace[0].cardaddr = 0;
1100 cfe->memspace[0].hostaddr = 0;
1101 } else if (memspace ==
1102 PCCARD_TPCE_FS_MEMSPACE_LENGTHADDR) {
1103 cfe->num_memspace = 1;
1104 cfe->memspace[0].length = 256 *
1105 pccard_tuple_read_2(tuple, idx);
1107 cfe->memspace[0].cardaddr = 256 *
1108 pccard_tuple_read_2(tuple, idx);
1110 cfe->memspace[0].hostaddr = cfe->memspace[0].cardaddr;
1116 reg = pccard_tuple_read_1(tuple, idx);
1119 cfe->num_memspace = (reg &
1120 PCCARD_TPCE_MS_COUNT) + 1;
1122 if (cfe->num_memspace >
1123 (sizeof(cfe->memspace) /
1124 sizeof(cfe->memspace[0]))) {
1125 DPRINTF(("too many mem "
1127 cfe->num_memspace));
1128 state->card->error++;
1132 ((reg & PCCARD_TPCE_MS_LENGTH_SIZE_MASK) >>
1133 PCCARD_TPCE_MS_LENGTH_SIZE_SHIFT);
1135 ((reg & PCCARD_TPCE_MS_CARDADDR_SIZE_MASK) >>
1136 PCCARD_TPCE_MS_CARDADDR_SIZE_SHIFT);
1138 (reg & PCCARD_TPCE_MS_HOSTADDR) ? cardaddrsize : 0;
1140 if (lengthsize == 0) {
1141 DPRINTF(("cfe memspace "
1142 "lengthsize == 0"));
1143 state->card->error++;
1145 for (i = 0; i < cfe->num_memspace; i++) {
1147 cfe->memspace[i].length =
1148 256 * pccard_tuple_read_n(tuple, lengthsize,
1152 cfe->memspace[i].length = 0;
1154 if (cfe->memspace[i].length == 0) {
1155 DPRINTF(("cfe->memspace[%d].length == 0",
1157 state->card->error++;
1160 cfe->memspace[i].cardaddr =
1161 256 * pccard_tuple_read_n(tuple, cardaddrsize,
1163 idx += cardaddrsize;
1165 cfe->memspace[i].cardaddr = 0;
1168 cfe->memspace[i].hostaddr =
1169 256 * pccard_tuple_read_n(tuple, hostaddrsize,
1171 idx += hostaddrsize;
1173 cfe->memspace[i].hostaddr = 0;
1179 if (tuple->length <= idx) {
1180 DPRINTF(("ran out of space before TCPE_MI\n"));
1184 reg = pccard_tuple_read_1(tuple, idx);
1187 if (reg & PCCARD_TPCE_MI_PWRDOWN)
1188 cfe->flags = PCCARD_CFE_POWERDOWN;
1189 if (reg & PCCARD_TPCE_MI_READONLY)
1190 cfe->flags = PCCARD_CFE_READONLY;
1191 if (reg & PCCARD_TPCE_MI_AUDIO)
1192 cfe->flags = PCCARD_CFE_AUDIO;
1193 cfe->maxtwins = reg & PCCARD_TPCE_MI_MAXTWINS;
1195 while (reg & PCCARD_TPCE_MI_EXT) {
1196 reg = pccard_tuple_read_1(tuple, idx);
1200 /* skip all the subtuples */
1204 DPRINTF(("CISTPL_CFTABLE_ENTRY\n"));
1207 DPRINTF(("unhandled CISTPL %x\n", tuple->code));