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