1 /* $NetBSD: pcmcia_cis.c,v 1.17 2000/02/10 09:01:52 chopps Exp $ */
5 * SPDX-License-Identifier: BSD-4-Clause
7 * Copyright (c) 1997 Marc Horowitz. All rights reserved.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by Marc Horowitz.
20 * 4. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/malloc.h>
38 #include <sys/module.h>
39 #include <sys/kernel.h>
40 #include <sys/queue.h>
41 #include <sys/types.h>
44 #include <machine/bus.h>
46 #include <machine/resource.h>
48 #include <dev/pccard/pccardreg.h>
49 #include <dev/pccard/pccardvar.h>
50 #include <dev/pccard/pccardvarp.h>
51 #include <dev/pccard/pccard_cis.h>
55 extern int pccard_cis_debug;
57 #define PCCARDCISDEBUG
59 #define DPRINTF(arg) do { if (pccard_cis_debug) printf arg; } while (0)
60 #define DEVPRINTF(arg) do { if (pccard_cis_debug) device_printf arg; } while (0)
63 #define DEVPRINTF(arg)
66 #define PCCARD_CIS_SIZE 4096
71 struct pccard_config_entry temp_cfe;
72 struct pccard_config_entry *default_cfe;
73 struct pccard_card *card;
74 struct pccard_function *pf;
77 static int pccard_parse_cis_tuple(const struct pccard_tuple *, void *);
78 static int decode_funce(const struct pccard_tuple *, struct pccard_function *);
81 pccard_read_cis(struct pccard_softc *sc)
83 struct cis_state state;
85 bzero(&state, sizeof state);
86 state.card = &sc->card;
87 state.card->error = 0;
88 state.card->cis1_major = -1;
89 state.card->cis1_minor = -1;
90 state.card->cis1_info[0] = NULL;
91 state.card->cis1_info[1] = NULL;
92 state.card->cis1_info[2] = NULL;
93 state.card->cis1_info[3] = NULL;
94 state.card->manufacturer = PCMCIA_VENDOR_INVALID;
95 state.card->product = PCMCIA_PRODUCT_INVALID;
96 STAILQ_INIT(&state.card->pf_head);
100 * XXX The following shouldn't be needed, but some slow cards
101 * XXX seem to need it still. Need to investigate if there's
102 * XXX a way to tell if the card is 'ready' or not rather than
103 * XXX sleeping like this. We're called just after the power
104 * XXX up of the socket. The standard timing diagrams don't
105 * XXX seem to indicate that a delay is required. The old
106 * XXX delay was 1s. This delay is .1s.
108 pause("pccard", hz / 10);
109 if (pccard_scan_cis(device_get_parent(sc->dev), sc->dev,
110 pccard_parse_cis_tuple, &state) == -1)
115 pccard_scan_cis(device_t bus, device_t dev, pccard_scan_t fct, void *arg)
117 struct resource *res;
119 struct pccard_tuple tuple;
120 int longlink_present;
122 u_long longlink_addr; /* Type suspect */
125 #ifdef PCCARDCISDEBUG
126 int cis_none_cnt = 10; /* Only report 10 CIS_NONEs */
136 /* allocate some memory */
139 * Some reports from the field suggest that a 64k memory boundary
140 * helps card CIS being able to be read. Try it here and see what
141 * the results actually are. I'm not sure I understand why this
142 * would make cards work better, but it is easy enough to test.
145 res = bus_alloc_resource_anywhere(dev, SYS_RES_MEMORY, &rid,
146 PCCARD_CIS_SIZE, RF_ACTIVE | rman_make_alignment_flags(64*1024));
148 device_printf(dev, "can't alloc memory to read attributes\n");
151 CARD_SET_RES_FLAGS(bus, dev, SYS_RES_MEMORY, rid, PCCARD_A_MEM_ATTR);
152 tuple.memt = rman_get_bustag(res);
153 tuple.memh = rman_get_bushandle(res);
156 DPRINTF(("cis mem map %#x (resource: %#jx)\n",
157 (unsigned int) tuple.memh, rman_get_start(res)));
161 longlink_present = 1;
168 DEVPRINTF((dev, "CIS tuple chain:\n"));
173 * Perform boundary check for insane cards.
174 * If CIS is too long, simulate CIS end.
175 * (This check may not be sufficient for
178 if (tuple.mult * tuple.ptr >= PCCARD_CIS_SIZE - 1
179 - 32 /* ad hoc value */ ) {
180 printf("CIS is too long -- truncating\n");
181 tuple.code = CISTPL_END;
183 /* get the tuple code */
184 tuple.code = pccard_cis_read_1(&tuple, tuple.ptr);
187 /* two special-case tuples */
189 if (tuple.code == CISTPL_NULL) {
190 #ifdef PCCARDCISDEBUG
191 if (cis_none_cnt > 0)
192 DPRINTF(("CISTPL_NONE\n 00\n"));
193 else if (cis_none_cnt == 0)
194 DPRINTF(("TOO MANY CIS_NONE\n"));
197 if ((*fct)(&tuple, arg)) {
203 } else if (tuple.code == CISTPL_END) {
204 DPRINTF(("CISTPL_END\n ff\n"));
205 /* Call the function for the END tuple, since
206 the CIS semantics depend on it */
207 if ((*fct)(&tuple, arg)) {
214 /* now all the normal tuples */
216 tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
217 switch (tuple.code) {
218 case CISTPL_LONGLINK_A:
219 case CISTPL_LONGLINK_C:
220 if ((*fct)(&tuple, arg)) {
224 if (tuple.length < 4) {
225 DPRINTF(("CISTPL_LONGLINK_%s too "
227 longlink_common ? "C" : "A",
231 longlink_present = 1;
232 longlink_common = (tuple.code ==
233 CISTPL_LONGLINK_C) ? 1 : 0;
234 longlink_addr = pccard_tuple_read_4(&tuple, 0);
235 DPRINTF(("CISTPL_LONGLINK_%s %#lx\n",
236 longlink_common ? "C" : "A",
240 if ((*fct)(&tuple, arg)) {
244 longlink_present = 0;
245 DPRINTF(("CISTPL_NO_LINK\n"));
247 case CISTPL_CHECKSUM:
248 if ((*fct)(&tuple, arg)) {
252 if (tuple.length < 5) {
253 DPRINTF(("CISTPL_CHECKSUM too "
254 "short %d\n", tuple.length));
263 pccard_tuple_read_2(&tuple, 0);
264 length = pccard_tuple_read_2(&tuple, 2);
265 cksum = pccard_tuple_read_1(&tuple, 4);
267 addr = tuple.ptr + offset;
269 DPRINTF(("CISTPL_CHECKSUM addr=%#lx "
270 "len=%#lx cksum=%#x",
271 addr, length, cksum));
274 * XXX do more work to deal with
277 if ((addr >= PCCARD_CIS_SIZE) ||
280 DPRINTF((" skipped, "
285 for (i = 0; i < length; i++)
287 bus_space_read_1(tuple.memt,
289 addr + tuple.mult * i);
290 if (cksum != (sum & 0xff)) {
291 DPRINTF((" failed sum=%#x\n",
294 "CIS checksum failed\n");
297 * XXX Some working cards have
298 * XXX bad checksums!!
307 case CISTPL_LONGLINK_MFC:
308 if (tuple.length < 1) {
309 DPRINTF(("CISTPL_LONGLINK_MFC too "
310 "short %d\n", tuple.length));
313 if (((tuple.length - 1) % 5) != 0) {
314 DPRINTF(("CISTPL_LONGLINK_MFC bogus "
315 "length %d\n", tuple.length));
319 * this is kind of ad hoc, as I don't have
320 * any real documentation
326 * put count into tmp var so that
327 * if we have to bail (because it's
328 * a bogus count) it won't be
329 * remembered for later use.
332 pccard_tuple_read_1(&tuple, 0);
334 DPRINTF(("CISTPL_LONGLINK_MFC %d",
338 * make _sure_ it's the right size;
339 * if too short, it may be a weird
340 * (unknown/undefined) format
342 if (tuple.length != (tmp_count*5 + 1)) {
343 DPRINTF((" bogus length %d\n",
348 * sanity check for a programming
349 * error which is difficult to find
353 howmany(sizeof mfc, sizeof mfc[0]))
354 panic("CISTPL_LONGLINK_MFC mfc "
355 "count would blow stack");
356 mfc_count = tmp_count;
357 for (i = 0; i < mfc_count; i++) {
359 (pccard_tuple_read_1(&tuple,
361 PCCARD_MFC_MEM_COMMON) ?
364 pccard_tuple_read_4(&tuple,
367 mfc[i].common ? "common" :
368 "attr", mfc[i].addr));
373 * for LONGLINK_MFC, fall through to the
374 * function. This tuple has structural and
379 if ((*fct)(&tuple, arg)) {
386 #ifdef PCCARDCISDEBUG
387 /* print the tuple */
391 DPRINTF((" %#02x %#02x", tuple.code,
394 for (i = 0; i < tuple.length; i++) {
396 pccard_tuple_read_1(&tuple, i)));
405 /* skip to the next tuple */
406 tuple.ptr += 2 + tuple.length;
410 * the chain is done. Clean up and move onto the next one,
411 * if any. The loop is here in the case that there is an MFC
412 * card with no longlink (which defaults to existing, == 0).
413 * In general, this means that if one pointer fails, it will
414 * try the next one, instead of just bailing.
417 if (longlink_present) {
418 CARD_SET_RES_FLAGS(bus, dev, SYS_RES_MEMORY,
419 rid, longlink_common ?
420 PCCARD_A_MEM_COM : PCCARD_A_MEM_ATTR);
421 DPRINTF(("cis mem map %#x\n",
422 (unsigned int) tuple.memh));
423 tuple.mult = longlink_common ? 1 : 2;
424 tuple.ptr = longlink_addr;
425 longlink_present = 0;
428 } else if (mfc_count && (mfc_index < mfc_count)) {
429 CARD_SET_RES_FLAGS(bus, dev, SYS_RES_MEMORY,
430 rid, mfc[mfc_index].common ?
431 PCCARD_A_MEM_COM : PCCARD_A_MEM_ATTR);
432 DPRINTF(("cis mem map %#x\n",
433 (unsigned int) tuple.memh));
434 /* set parse state, and point at the next one */
435 tuple.mult = mfc[mfc_index].common ? 1 : 2;
436 tuple.ptr = mfc[mfc_index].addr;
442 /* make sure that the link is valid */
443 tuple.code = pccard_cis_read_1(&tuple, tuple.ptr);
444 if (tuple.code != CISTPL_LINKTARGET) {
445 DPRINTF(("CISTPL_LINKTARGET expected, "
446 "code %#02x observed\n", tuple.code));
449 tuple.length = pccard_cis_read_1(&tuple, tuple.ptr + 1);
450 if (tuple.length < 3) {
451 DPRINTF(("CISTPL_LINKTARGET too short %d\n",
455 if ((pccard_tuple_read_1(&tuple, 0) != 'C') ||
456 (pccard_tuple_read_1(&tuple, 1) != 'I') ||
457 (pccard_tuple_read_1(&tuple, 2) != 'S')) {
458 DPRINTF(("CISTPL_LINKTARGET magic "
459 "%02x%02x%02x incorrect\n",
460 pccard_tuple_read_1(&tuple, 0),
461 pccard_tuple_read_1(&tuple, 1),
462 pccard_tuple_read_1(&tuple, 2)));
465 tuple.ptr += 2 + tuple.length;
471 bus_release_resource(dev, SYS_RES_MEMORY, rid, res);
476 /* XXX this is incredibly verbose. Not sure what trt is */
479 pccard_print_cis(device_t dev)
481 struct pccard_softc *sc = PCCARD_SOFTC(dev);
482 struct pccard_card *card = &sc->card;
483 struct pccard_function *pf;
484 struct pccard_config_entry *cfe;
487 device_printf(dev, "CIS version ");
488 if (card->cis1_major == 4) {
489 if (card->cis1_minor == 0)
490 printf("PCCARD 1.0\n");
491 else if (card->cis1_minor == 1)
492 printf("PCCARD 2.0 or 2.1\n");
493 } else if (card->cis1_major >= 5)
494 printf("PC Card Standard %d.%d\n", card->cis1_major, card->cis1_minor);
496 printf("unknown (major=%d, minor=%d)\n",
497 card->cis1_major, card->cis1_minor);
499 device_printf(dev, "CIS info: ");
500 for (i = 0; i < 4; i++) {
501 if (card->cis1_info[i] == NULL)
505 printf("%s", card->cis1_info[i]);
509 device_printf(dev, "Manufacturer code %#x, product %#x\n",
510 card->manufacturer, card->product);
512 STAILQ_FOREACH(pf, &card->pf_head, pf_list) {
513 device_printf(dev, "function %d: ", pf->number);
515 switch (pf->function) {
516 case PCCARD_FUNCTION_UNSPEC:
517 printf("unspecified");
519 case PCCARD_FUNCTION_MULTIFUNCTION:
520 printf("multi-function");
522 case PCCARD_FUNCTION_MEMORY:
525 case PCCARD_FUNCTION_SERIAL:
526 printf("serial port");
528 case PCCARD_FUNCTION_PARALLEL:
529 printf("parallel port");
531 case PCCARD_FUNCTION_DISK:
532 printf("fixed disk");
534 case PCCARD_FUNCTION_VIDEO:
535 printf("video adapter");
537 case PCCARD_FUNCTION_NETWORK:
538 printf("network adapter");
540 case PCCARD_FUNCTION_AIMS:
541 printf("auto incrementing mass storage");
543 case PCCARD_FUNCTION_SCSI:
544 printf("SCSI bridge");
546 case PCCARD_FUNCTION_SECURITY:
547 printf("Security services");
549 case PCCARD_FUNCTION_INSTRUMENT:
550 printf("Instrument");
553 printf("unknown (%d)", pf->function);
557 printf(", ccr addr %#x mask %#x\n", pf->ccr_base, pf->ccr_mask);
559 STAILQ_FOREACH(cfe, &pf->cfe_head, cfe_list) {
560 device_printf(dev, "function %d, config table entry "
561 "%d: ", pf->number, cfe->number);
563 switch (cfe->iftype) {
564 case PCCARD_IFTYPE_MEMORY:
565 printf("memory card");
567 case PCCARD_IFTYPE_IO:
571 printf("card type unknown");
575 printf("; irq mask %#x", cfe->irqmask);
577 if (cfe->num_iospace) {
578 printf("; iomask %#lx, iospace", cfe->iomask);
580 for (i = 0; i < cfe->num_iospace; i++) {
581 printf(" %#jx", cfe->iospace[i].start);
582 if (cfe->iospace[i].length)
584 cfe->iospace[i].start +
585 cfe->iospace[i].length - 1);
588 if (cfe->num_memspace) {
589 printf("; memspace");
591 for (i = 0; i < cfe->num_memspace; i++) {
593 cfe->memspace[i].cardaddr);
594 if (cfe->memspace[i].length)
596 cfe->memspace[i].cardaddr +
597 cfe->memspace[i].length - 1);
598 if (cfe->memspace[i].hostaddr)
600 cfe->memspace[i].hostaddr);
604 printf("; maxtwins %d", cfe->maxtwins);
608 if (cfe->flags & PCCARD_CFE_MWAIT_REQUIRED)
609 printf(" mwait_required");
610 if (cfe->flags & PCCARD_CFE_RDYBSY_ACTIVE)
611 printf(" rdybsy_active");
612 if (cfe->flags & PCCARD_CFE_WP_ACTIVE)
613 printf(" wp_active");
614 if (cfe->flags & PCCARD_CFE_BVD_ACTIVE)
615 printf(" bvd_active");
616 if (cfe->flags & PCCARD_CFE_IO8)
618 if (cfe->flags & PCCARD_CFE_IO16)
620 if (cfe->flags & PCCARD_CFE_IRQSHARE)
622 if (cfe->flags & PCCARD_CFE_IRQPULSE)
624 if (cfe->flags & PCCARD_CFE_IRQLEVEL)
626 if (cfe->flags & PCCARD_CFE_POWERDOWN)
627 printf(" powerdown");
628 if (cfe->flags & PCCARD_CFE_READONLY)
630 if (cfe->flags & PCCARD_CFE_AUDIO)
638 device_printf(dev, "%d errors found while parsing CIS\n",
643 pccard_parse_cis_tuple(const struct pccard_tuple *tuple, void *arg)
645 /* most of these are educated guesses */
646 static struct pccard_config_entry init_cfe = {
647 -1, PCCARD_CFE_RDYBSY_ACTIVE | PCCARD_CFE_WP_ACTIVE |
648 PCCARD_CFE_BVD_ACTIVE, PCCARD_IFTYPE_MEMORY,
651 struct cis_state *state = arg;
653 switch (tuple->code) {
655 /* if we've seen a LONGLINK_MFC, and this is the first
656 * END after it, reset the function list.
658 * XXX This might also be the right place to start a
659 * new function, but that assumes that a function
660 * definition never crosses any longlink, and I'm not
661 * sure about that. This is probably safe for MFC
662 * cards, but what we have now isn't broken, so I'd
663 * rather not change it.
665 if (state->gotmfc == 1) {
666 struct pccard_function *pf, *pfnext;
668 for (pf = STAILQ_FIRST(&state->card->pf_head);
669 pf != NULL; pf = pfnext) {
670 pfnext = STAILQ_NEXT(pf, pf_list);
674 STAILQ_INIT(&state->card->pf_head);
681 case CISTPL_LONGLINK_MFC:
683 * this tuple's structure was dealt with in scan_cis. here,
684 * record the fact that the MFC tuple was seen, so that
685 * functions declared before the MFC link can be cleaned
690 #ifdef PCCARDCISDEBUG
692 case CISTPL_DEVICE_A:
694 u_int reg, dtype, dspeed;
696 reg = pccard_tuple_read_1(tuple, 0);
697 dtype = reg & PCCARD_DTYPE_MASK;
698 dspeed = reg & PCCARD_DSPEED_MASK;
700 DPRINTF(("CISTPL_DEVICE%s type=",
701 (tuple->code == CISTPL_DEVICE) ? "" : "_A"));
703 case PCCARD_DTYPE_NULL:
706 case PCCARD_DTYPE_ROM:
709 case PCCARD_DTYPE_OTPROM:
712 case PCCARD_DTYPE_EPROM:
715 case PCCARD_DTYPE_EEPROM:
718 case PCCARD_DTYPE_FLASH:
721 case PCCARD_DTYPE_SRAM:
724 case PCCARD_DTYPE_DRAM:
727 case PCCARD_DTYPE_FUNCSPEC:
728 DPRINTF(("funcspec"));
730 case PCCARD_DTYPE_EXTEND:
734 DPRINTF(("reserved"));
737 DPRINTF((" speed="));
739 case PCCARD_DSPEED_NULL:
742 case PCCARD_DSPEED_250NS:
745 case PCCARD_DSPEED_200NS:
748 case PCCARD_DSPEED_150NS:
751 case PCCARD_DSPEED_100NS:
754 case PCCARD_DSPEED_EXT:
758 DPRINTF(("reserved"));
766 if (tuple->length < 6) {
767 DPRINTF(("CISTPL_VERS_1 too short %d\n",
771 int start, i, ch, count;
773 state->card->cis1_major = pccard_tuple_read_1(tuple, 0);
774 state->card->cis1_minor = pccard_tuple_read_1(tuple, 1);
776 for (count = 0, start = 0, i = 0;
777 (count < 4) && ((i + 4) < 256); i++) {
778 ch = pccard_tuple_read_1(tuple, 2 + i);
781 state->card->cis1_info_buf[i] = ch;
783 state->card->cis1_info[count] =
784 state->card->cis1_info_buf + start;
789 DPRINTF(("CISTPL_VERS_1\n"));
793 if (tuple->length < 4) {
794 DPRINTF(("CISTPL_MANFID too short %d\n",
798 state->card->manufacturer = pccard_tuple_read_2(tuple, 0);
799 state->card->product = pccard_tuple_read_2(tuple, 2);
801 * This is for xe driver. But not limited to that driver.
802 * In PC Card Standard,
803 * Manufacturer ID: 2byte.
804 * Product ID: typically 2bytes, but there's no limit on its
805 * size. prodext is a two byte field, so maybe we should
806 * also handle the '6' case. So far no cards have surfaced
807 * with a length of '6'.
809 if (tuple->length == 5 )
810 state->card->prodext = pccard_tuple_read_1(tuple, 4);
811 DPRINTF(("CISTPL_MANFID\n"));
814 if (tuple->length < 1) {
815 DPRINTF(("CISTPL_FUNCID too short %d\n",
819 if ((state->pf == NULL) || (state->gotmfc == 2)) {
820 state->pf = malloc(sizeof(*state->pf), M_DEVBUF,
822 state->pf->number = state->count++;
823 state->pf->last_config_index = -1;
824 STAILQ_INIT(&state->pf->cfe_head);
826 STAILQ_INSERT_TAIL(&state->card->pf_head, state->pf,
829 state->pf->function = pccard_tuple_read_1(tuple, 0);
831 DPRINTF(("CISTPL_FUNCID\n"));
834 if (state->pf == NULL || state->pf->function <= 0) {
835 DPRINTF(("CISTPL_FUNCE is not followed by "
836 "valid CISTPL_FUNCID\n"));
839 if (tuple->length >= 2)
840 decode_funce(tuple, state->pf);
841 DPRINTF(("CISTPL_FUNCE\n"));
844 if (tuple->length < 3) {
845 DPRINTF(("CISTPL_CONFIG too short %d\n",
849 u_int reg, rasz, rmsz, rfsz;
852 reg = pccard_tuple_read_1(tuple, 0);
853 rasz = 1 + ((reg & PCCARD_TPCC_RASZ_MASK) >>
854 PCCARD_TPCC_RASZ_SHIFT);
855 rmsz = 1 + ((reg & PCCARD_TPCC_RMSZ_MASK) >>
856 PCCARD_TPCC_RMSZ_SHIFT);
857 rfsz = ((reg & PCCARD_TPCC_RFSZ_MASK) >>
858 PCCARD_TPCC_RFSZ_SHIFT);
860 if (tuple->length < (rasz + rmsz + rfsz)) {
861 DPRINTF(("CISTPL_CONFIG (%d,%d,%d) too "
862 "short %d\n", rasz, rmsz, rfsz,
866 if (state->pf == NULL) {
867 state->pf = malloc(sizeof(*state->pf),
868 M_DEVBUF, M_NOWAIT | M_ZERO);
869 state->pf->number = state->count++;
870 state->pf->last_config_index = -1;
871 STAILQ_INIT(&state->pf->cfe_head);
873 STAILQ_INSERT_TAIL(&state->card->pf_head,
876 state->pf->function = PCCARD_FUNCTION_UNSPEC;
878 state->pf->last_config_index =
879 pccard_tuple_read_1(tuple, 1);
881 state->pf->ccr_base = 0;
882 for (i = 0; i < rasz; i++)
883 state->pf->ccr_base |=
884 ((pccard_tuple_read_1(tuple, 2 + i)) <<
887 state->pf->ccr_mask = 0;
888 for (i = 0; i < rmsz; i++)
889 state->pf->ccr_mask |=
890 ((pccard_tuple_read_1(tuple,
891 2 + rasz + i)) << (i * 8));
893 /* skip the reserved area and subtuples */
895 /* reset the default cfe for each cfe list */
896 state->temp_cfe = init_cfe;
897 state->default_cfe = &state->temp_cfe;
899 DPRINTF(("CISTPL_CONFIG\n"));
901 case CISTPL_CFTABLE_ENTRY:
905 u_int intface, def, num;
906 u_int power, timing, iospace, irq, memspace, misc;
907 struct pccard_config_entry *cfe;
911 reg = pccard_tuple_read_1(tuple, idx++);
912 intface = reg & PCCARD_TPCE_INDX_INTFACE;
913 def = reg & PCCARD_TPCE_INDX_DEFAULT;
914 num = reg & PCCARD_TPCE_INDX_NUM_MASK;
917 * this is a little messy. Some cards have only a
918 * cfentry with the default bit set. So, as we go
919 * through the list, we add new indexes to the queue,
920 * and keep a pointer to the last one with the
921 * default bit set. if we see a record with the same
922 * index, as the default, we stash the default and
923 * replace the queue entry. otherwise, we just add
924 * new entries to the queue, pointing the default ptr
925 * at them if the default bit is set. if we get to
926 * the end with the default pointer pointing at a
927 * record which hasn't had a matching index, that's
928 * ok; it just becomes a cfentry like any other.
932 * if the index in the cis differs from the default
933 * cis, create new entry in the queue and start it
934 * with the current default
936 if (num != state->default_cfe->number) {
937 cfe = (struct pccard_config_entry *)
938 malloc(sizeof(*cfe), M_DEVBUF, M_NOWAIT);
940 DPRINTF(("no memory for config entry\n"));
943 *cfe = *state->default_cfe;
945 STAILQ_INSERT_TAIL(&state->pf->cfe_head,
951 * if the default bit is set in the cis, then
952 * point the new default at whatever is being
956 state->default_cfe = cfe;
959 * the cis index matches the default index,
960 * fill in the default cfentry. It is
961 * assumed that the cfdefault index is in the
962 * queue. For it to be otherwise, the cis
963 * index would have to be -1 (initial
964 * condition) which is not possible, or there
965 * would have to be a preceding cis entry
966 * which had the same cis index and had the
967 * default bit unset. Neither condition
968 * should happen. If it does, this cfentry
969 * is lost (written into temp space), which
970 * is an acceptable failure mode.
973 cfe = state->default_cfe;
976 * if the cis entry does not have the default
977 * bit set, copy the default out of the way
981 state->temp_cfe = *state->default_cfe;
982 state->default_cfe = &state->temp_cfe;
987 reg = pccard_tuple_read_1(tuple, idx++);
988 cfe->flags &= ~(PCCARD_CFE_MWAIT_REQUIRED
989 | PCCARD_CFE_RDYBSY_ACTIVE
990 | PCCARD_CFE_WP_ACTIVE
991 | PCCARD_CFE_BVD_ACTIVE);
992 if (reg & PCCARD_TPCE_IF_MWAIT)
993 cfe->flags |= PCCARD_CFE_MWAIT_REQUIRED;
994 if (reg & PCCARD_TPCE_IF_RDYBSY)
995 cfe->flags |= PCCARD_CFE_RDYBSY_ACTIVE;
996 if (reg & PCCARD_TPCE_IF_WP)
997 cfe->flags |= PCCARD_CFE_WP_ACTIVE;
998 if (reg & PCCARD_TPCE_IF_BVD)
999 cfe->flags |= PCCARD_CFE_BVD_ACTIVE;
1000 cfe->iftype = reg & PCCARD_TPCE_IF_IFTYPE;
1002 reg = pccard_tuple_read_1(tuple, idx++);
1004 power = reg & PCCARD_TPCE_FS_POWER_MASK;
1005 timing = reg & PCCARD_TPCE_FS_TIMING;
1006 iospace = reg & PCCARD_TPCE_FS_IOSPACE;
1007 irq = reg & PCCARD_TPCE_FS_IRQ;
1008 memspace = reg & PCCARD_TPCE_FS_MEMSPACE_MASK;
1009 misc = reg & PCCARD_TPCE_FS_MISC;
1012 /* skip over power, don't save */
1013 /* for each parameter selection byte */
1014 for (i = 0; i < power; i++) {
1015 reg = pccard_tuple_read_1(tuple, idx++);
1016 for (; reg; reg >>= 1)
1018 /* set bit -> read */
1021 /* skip over bytes */
1023 reg2 = pccard_tuple_read_1(tuple, idx++);
1025 * until non-extension
1028 } while (reg2 & 0x80);
1033 /* skip over timing, don't save */
1034 reg = pccard_tuple_read_1(tuple, idx++);
1036 if ((reg & PCCARD_TPCE_TD_RESERVED_MASK) !=
1037 PCCARD_TPCE_TD_RESERVED_MASK)
1039 if ((reg & PCCARD_TPCE_TD_RDYBSY_MASK) !=
1040 PCCARD_TPCE_TD_RDYBSY_MASK)
1042 if ((reg & PCCARD_TPCE_TD_WAIT_MASK) !=
1043 PCCARD_TPCE_TD_WAIT_MASK)
1047 if (tuple->length <= idx) {
1048 DPRINTF(("ran out of space before TCPE_IO\n"));
1052 reg = pccard_tuple_read_1(tuple, idx++);
1054 ~(PCCARD_CFE_IO8 | PCCARD_CFE_IO16);
1055 if (reg & PCCARD_TPCE_IO_BUSWIDTH_8BIT)
1056 cfe->flags |= PCCARD_CFE_IO8;
1057 if (reg & PCCARD_TPCE_IO_BUSWIDTH_16BIT)
1058 cfe->flags |= PCCARD_CFE_IO16;
1060 reg & PCCARD_TPCE_IO_IOADDRLINES_MASK;
1062 if (reg & PCCARD_TPCE_IO_HASRANGE) {
1063 reg = pccard_tuple_read_1(tuple, idx++);
1064 cfe->num_iospace = 1 + (reg &
1065 PCCARD_TPCE_IO_RANGE_COUNT);
1067 if (cfe->num_iospace >
1068 (sizeof(cfe->iospace) /
1069 sizeof(cfe->iospace[0]))) {
1070 DPRINTF(("too many io "
1073 state->card->error++;
1076 for (i = 0; i < cfe->num_iospace; i++) {
1077 switch (reg & PCCARD_TPCE_IO_RANGE_ADDRSIZE_MASK) {
1078 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_ONE:
1079 cfe->iospace[i].start =
1080 pccard_tuple_read_1(tuple, idx++);
1082 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_TWO:
1083 cfe->iospace[i].start =
1084 pccard_tuple_read_2(tuple, idx);
1087 case PCCARD_TPCE_IO_RANGE_ADDRSIZE_FOUR:
1088 cfe->iospace[i].start =
1089 pccard_tuple_read_4(tuple, idx);
1094 PCCARD_TPCE_IO_RANGE_LENGTHSIZE_MASK) {
1095 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_ONE:
1096 cfe->iospace[i].length =
1097 pccard_tuple_read_1(tuple, idx++);
1099 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_TWO:
1100 cfe->iospace[i].length =
1101 pccard_tuple_read_2(tuple, idx);
1104 case PCCARD_TPCE_IO_RANGE_LENGTHSIZE_FOUR:
1105 cfe->iospace[i].length =
1106 pccard_tuple_read_4(tuple, idx);
1110 cfe->iospace[i].length++;
1113 cfe->num_iospace = 1;
1114 cfe->iospace[0].start = 0;
1115 cfe->iospace[0].length =
1120 if (tuple->length <= idx) {
1121 DPRINTF(("ran out of space before TCPE_IR\n"));
1125 reg = pccard_tuple_read_1(tuple, idx++);
1126 cfe->flags &= ~(PCCARD_CFE_IRQSHARE
1127 | PCCARD_CFE_IRQPULSE
1128 | PCCARD_CFE_IRQLEVEL);
1129 if (reg & PCCARD_TPCE_IR_SHARE)
1130 cfe->flags |= PCCARD_CFE_IRQSHARE;
1131 if (reg & PCCARD_TPCE_IR_PULSE)
1132 cfe->flags |= PCCARD_CFE_IRQPULSE;
1133 if (reg & PCCARD_TPCE_IR_LEVEL)
1134 cfe->flags |= PCCARD_CFE_IRQLEVEL;
1136 if (reg & PCCARD_TPCE_IR_HASMASK) {
1138 * it's legal to ignore the
1139 * special-interrupt bits, so I will
1143 pccard_tuple_read_2(tuple, idx);
1147 (1 << (reg & PCCARD_TPCE_IR_IRQ));
1150 cfe->irqmask = 0xffff;
1153 if (tuple->length <= idx) {
1154 DPRINTF(("ran out of space before TCPE_MS\n"));
1158 if (memspace == PCCARD_TPCE_FS_MEMSPACE_LENGTH) {
1159 cfe->num_memspace = 1;
1160 cfe->memspace[0].length = 256 *
1161 pccard_tuple_read_2(tuple, idx);
1163 cfe->memspace[0].cardaddr = 0;
1164 cfe->memspace[0].hostaddr = 0;
1165 } else if (memspace ==
1166 PCCARD_TPCE_FS_MEMSPACE_LENGTHADDR) {
1167 cfe->num_memspace = 1;
1168 cfe->memspace[0].length = 256 *
1169 pccard_tuple_read_2(tuple, idx);
1171 cfe->memspace[0].cardaddr = 256 *
1172 pccard_tuple_read_2(tuple, idx);
1174 cfe->memspace[0].hostaddr = cfe->memspace[0].cardaddr;
1180 reg = pccard_tuple_read_1(tuple, idx++);
1181 cfe->num_memspace = (reg &
1182 PCCARD_TPCE_MS_COUNT) + 1;
1183 if (cfe->num_memspace >
1184 (sizeof(cfe->memspace) /
1185 sizeof(cfe->memspace[0]))) {
1186 DPRINTF(("too many mem "
1188 cfe->num_memspace));
1189 state->card->error++;
1193 ((reg & PCCARD_TPCE_MS_LENGTH_SIZE_MASK) >>
1194 PCCARD_TPCE_MS_LENGTH_SIZE_SHIFT);
1196 ((reg & PCCARD_TPCE_MS_CARDADDR_SIZE_MASK) >>
1197 PCCARD_TPCE_MS_CARDADDR_SIZE_SHIFT);
1199 (reg & PCCARD_TPCE_MS_HOSTADDR) ? cardaddrsize : 0;
1201 if (lengthsize == 0) {
1202 DPRINTF(("cfe memspace "
1203 "lengthsize == 0\n"));
1205 for (i = 0; i < cfe->num_memspace; i++) {
1207 cfe->memspace[i].length =
1208 256 * pccard_tuple_read_n(tuple, lengthsize,
1212 cfe->memspace[i].length = 0;
1214 if (cfe->memspace[i].length == 0) {
1215 DPRINTF(("cfe->memspace[%d].length == 0\n",
1219 cfe->memspace[i].cardaddr =
1220 256 * pccard_tuple_read_n(tuple, cardaddrsize,
1222 idx += cardaddrsize;
1224 cfe->memspace[i].cardaddr = 0;
1227 cfe->memspace[i].hostaddr =
1228 256 * pccard_tuple_read_n(tuple, hostaddrsize,
1230 idx += hostaddrsize;
1232 cfe->memspace[i].hostaddr = 0;
1237 cfe->num_memspace = 0;
1239 if (tuple->length <= idx) {
1240 DPRINTF(("ran out of space before TCPE_MI\n"));
1244 reg = pccard_tuple_read_1(tuple, idx++);
1245 cfe->flags &= ~(PCCARD_CFE_POWERDOWN
1246 | PCCARD_CFE_READONLY
1247 | PCCARD_CFE_AUDIO);
1248 if (reg & PCCARD_TPCE_MI_PWRDOWN)
1249 cfe->flags |= PCCARD_CFE_POWERDOWN;
1250 if (reg & PCCARD_TPCE_MI_READONLY)
1251 cfe->flags |= PCCARD_CFE_READONLY;
1252 if (reg & PCCARD_TPCE_MI_AUDIO)
1253 cfe->flags |= PCCARD_CFE_AUDIO;
1254 cfe->maxtwins = reg & PCCARD_TPCE_MI_MAXTWINS;
1256 while (reg & PCCARD_TPCE_MI_EXT) {
1257 reg = pccard_tuple_read_1(tuple, idx++);
1260 /* skip all the subtuples */
1264 DPRINTF(("CISTPL_CFTABLE_ENTRY\n"));
1267 DPRINTF(("unhandled CISTPL %#x\n", tuple->code));
1275 decode_funce(const struct pccard_tuple *tuple, struct pccard_function *pf)
1279 int type = pccard_tuple_read_1(tuple, 0);
1281 switch (pf->function) {
1282 case PCCARD_FUNCTION_DISK:
1283 if (type == PCCARD_TPLFE_TYPE_DISK_DEVICE_INTERFACE) {
1284 pf->pf_funce_disk_interface
1285 = pccard_tuple_read_1(tuple, 1);
1286 pf->pf_funce_disk_power
1287 = pccard_tuple_read_1(tuple, 2);
1290 case PCCARD_FUNCTION_NETWORK:
1291 if (type == PCCARD_TPLFE_TYPE_LAN_NID) {
1292 len = pccard_tuple_read_1(tuple, 1);
1293 if (tuple->length < 2 + len || len > 8) {
1294 /* tuple length not enough or nid too long */
1297 for (i = 0; i < len; i++) {
1298 pf->pf_funce_lan_nid[i]
1299 = pccard_tuple_read_1(tuple, i + 2);
1301 pf->pf_funce_lan_nidlen = len;