1 /* $NetBSD: isapnp.c,v 1.42 2003/12/04 13:57:30 keihan Exp $ */
2
3 /*-
4 * Copyright (c) 1996 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Christos Zoulas.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 /*
40 * ISA PnP bus autoconfiguration.
41 */
42
43 #include <sys/cdefs.h>
44 __KERNEL_RCSID(0, "$NetBSD: isapnp.c,v 1.42 2003/12/04 13:57:30 keihan Exp $");
45
46 #include "isadma.h"
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/device.h>
51 #include <sys/malloc.h>
52
53 #include <machine/bus.h>
54
55 #include <dev/isa/isavar.h>
56
57 #include <dev/isapnp/isapnpreg.h>
58 #include <dev/isapnp/isapnpvar.h>
59 #include <dev/isapnp/isapnpdevs.h>
60
61 #include "wss_isapnp.h" /* XXX part of disgusting CS chip hack */
62
63 #ifndef ISAPNP_ALLOC_INTR_MASK
64 #define ISAPNP_ALLOC_INTR_MASK (~0)
65 #endif
66
67 static void isapnp_init __P((struct isapnp_softc *));
68 static __inline u_char isapnp_shift_bit __P((struct isapnp_softc *));
69 static int isapnp_findcard __P((struct isapnp_softc *));
70 static void isapnp_free_region __P((bus_space_tag_t, struct isapnp_region *));
71 static int isapnp_alloc_region __P((bus_space_tag_t, struct isapnp_region *));
72 static int isapnp_alloc_irq __P((isa_chipset_tag_t, struct isapnp_pin *));
73 static int isapnp_alloc_drq __P((isa_chipset_tag_t, struct isapnp_pin *));
74 static int isapnp_testconfig __P((bus_space_tag_t, bus_space_tag_t,
75 struct isapnp_attach_args *, int));
76 static struct isapnp_attach_args *isapnp_bestconfig __P((struct isapnp_softc *,
77 struct isapnp_attach_args **));
78 static void isapnp_print_region __P((const char *, struct isapnp_region *,
79 size_t));
80 static void isapnp_configure __P((struct isapnp_softc *,
81 const struct isapnp_attach_args *));
82 static void isapnp_print_pin __P((const char *, struct isapnp_pin *, size_t));
83 static int isapnp_print __P((void *, const char *));
84 #ifdef _KERNEL
85 static int isapnp_submatch __P((struct device *, struct cfdata *, void *));
86 #endif
87 static int isapnp_find __P((struct isapnp_softc *, int));
88 static int isapnp_match __P((struct device *, struct cfdata *, void *));
89 static void isapnp_attach __P((struct device *, struct device *, void *));
90 static void isapnp_callback __P((struct device *));
91
92 CFATTACH_DECL(isapnp, sizeof(struct isapnp_softc),
93 isapnp_match, isapnp_attach, NULL, NULL);
94
95 /*
96 * This keeps track if which ISA's we have been probed on.
97 */
98 struct isapnp_probe_cookie {
99 LIST_ENTRY(isapnp_probe_cookie) ipc_link;
100 struct device *ipc_parent;
101 };
102 LIST_HEAD(, isapnp_probe_cookie) isapnp_probes =
103 LIST_HEAD_INITIALIZER(isapnp_probes);
104
105 /* isapnp_init():
106 * Write the PNP initiation key to wake up the cards...
107 */
108 static void
109 isapnp_init(sc)
110 struct isapnp_softc *sc;
111 {
112 int i;
113 u_char v = ISAPNP_LFSR_INIT;
114
115 /* First write 0's twice to enter the Wait for Key state */
116 ISAPNP_WRITE_ADDR(sc, 0);
117 ISAPNP_WRITE_ADDR(sc, 0);
118
119 /* Send the 32 byte sequence to awake the logic */
120 for (i = 0; i < ISAPNP_LFSR_LENGTH; i++) {
121 ISAPNP_WRITE_ADDR(sc, v);
122 v = ISAPNP_LFSR_NEXT(v);
123 }
124 }
125
126
127 /* isapnp_shift_bit():
128 * Read a bit at a time from the config card.
129 */
130 static __inline u_char
131 isapnp_shift_bit(sc)
132 struct isapnp_softc *sc;
133 {
134 u_char c1, c2;
135
136 DELAY(250);
137 c1 = ISAPNP_READ_DATA(sc);
138 DELAY(250);
139 c2 = ISAPNP_READ_DATA(sc);
140
141 if (c1 == 0x55 && c2 == 0xAA)
142 return 0x80;
143 else
144 return 0;
145 }
146
147
148 /* isapnp_findcard():
149 * Attempt to read the vendor/serial/checksum for a card
150 * If a card is found [the checksum matches], assign the
151 * next card number to it and return 1
152 */
153 static int
154 isapnp_findcard(sc)
155 struct isapnp_softc *sc;
156 {
157 u_char v = ISAPNP_LFSR_INIT, csum, w;
158 int i, b;
159
160 if (sc->sc_ncards == ISAPNP_MAX_CARDS) {
161 printf("%s: Too many pnp cards\n", sc->sc_dev.dv_xname);
162 return 0;
163 }
164
165 /* Set the read port */
166 isapnp_write_reg(sc, ISAPNP_WAKE, 0);
167 isapnp_write_reg(sc, ISAPNP_SET_RD_PORT, sc->sc_read_port >> 2);
168 sc->sc_read_port |= 3;
169 DELAY(1000);
170
171 ISAPNP_WRITE_ADDR(sc, ISAPNP_SERIAL_ISOLATION);
172 DELAY(1000);
173
174 /* Read the 8 bytes of the Vendor ID and Serial Number */
175 for(i = 0; i < 8; i++) {
176 /* Read each bit separately */
177 for (w = 0, b = 0; b < 8; b++) {
178 u_char neg = isapnp_shift_bit(sc);
179
180 w >>= 1;
181 w |= neg;
182 v = ISAPNP_LFSR_NEXT(v) ^ neg;
183 }
184 sc->sc_id[sc->sc_ncards][i] = w;
185 }
186
187 /* Read the remaining checksum byte */
188 for (csum = 0, b = 0; b < 8; b++) {
189 u_char neg = isapnp_shift_bit(sc);
190
191 csum >>= 1;
192 csum |= neg;
193 }
194 sc->sc_id[sc->sc_ncards][8] = csum;
195
196 if (csum == v) {
197 sc->sc_ncards++;
198 isapnp_write_reg(sc, ISAPNP_CARD_SELECT_NUM, sc->sc_ncards);
199 return 1;
200 }
201 return 0;
202 }
203
204
205 /* isapnp_free_region():
206 * Free a region
207 */
208 static void
209 isapnp_free_region(t, r)
210 bus_space_tag_t t;
211 struct isapnp_region *r;
212 {
213 if (r->length == 0)
214 return;
215
216 #ifdef _KERNEL
217 bus_space_unmap(t, r->h, r->length);
218 #endif
219 }
220
221
222 /* isapnp_alloc_region():
223 * Allocate a single region if possible
224 */
225 static int
226 isapnp_alloc_region(t, r)
227 bus_space_tag_t t;
228 struct isapnp_region *r;
229 {
230 int error = 0;
231
232 if (r->length == 0) {
233 r->base = 0;
234 return 0;
235 }
236
237 for (r->base = r->minbase; r->base <= r->maxbase;
238 r->base += r->align) {
239 #ifdef _KERNEL
240 error = bus_space_map(t, r->base, r->length, 0, &r->h);
241 #endif
242 if (error == 0)
243 return 0;
244 if (r->align == 0)
245 break;
246 }
247 return error;
248 }
249
250
251 /* isapnp_alloc_irq():
252 * Allocate an irq
253 */
254 static int
255 isapnp_alloc_irq(ic, i)
256 isa_chipset_tag_t ic;
257 struct isapnp_pin *i;
258 {
259 int irq;
260 #define LEVEL_IRQ (ISAPNP_IRQTYPE_LEVEL_PLUS|ISAPNP_IRQTYPE_LEVEL_MINUS)
261 i->type = (i->flags & LEVEL_IRQ) ? IST_LEVEL : IST_EDGE;
262
263 if (i->bits == 0) {
264 i->num = 0;
265 return 0;
266 }
267
268 if (isa_intr_alloc(ic, ISAPNP_ALLOC_INTR_MASK & i->bits,
269 i->type, &irq) == 0) {
270 i->num = irq;
271 return 0;
272 }
273
274 return EINVAL;
275 }
276
277 /* isapnp_alloc_drq():
278 * Allocate a drq
279 */
280 static int
281 isapnp_alloc_drq(ic, i)
282 isa_chipset_tag_t ic;
283 struct isapnp_pin *i;
284 {
285 #if NISADMA > 0
286 int b;
287
288 if (i->bits == 0) {
289 i->num = 0;
290 return 0;
291 }
292
293 for (b = 0; b < 8; b++)
294 if ((i->bits & (1 << b)) && isa_drq_isfree(ic, b)) {
295 i->num = b;
296 return 0;
297 }
298 #endif /* NISADMA > 0 */
299
300 return EINVAL;
301 }
302
303 /* isapnp_testconfig():
304 * Test/Allocate the regions used
305 */
306 static int
307 isapnp_testconfig(iot, memt, ipa, alloc)
308 bus_space_tag_t iot, memt;
309 struct isapnp_attach_args *ipa;
310 int alloc;
311 {
312 int nio = 0, nmem = 0, nmem32 = 0, nirq = 0, ndrq = 0;
313 int error = 0;
314
315 #ifdef DEBUG_ISAPNP
316 isapnp_print_attach(ipa);
317 #endif
318
319 for (; nio < ipa->ipa_nio; nio++) {
320 error = isapnp_alloc_region(iot, &ipa->ipa_io[nio]);
321 if (error)
322 goto bad;
323 }
324
325 for (; nmem < ipa->ipa_nmem; nmem++) {
326 error = isapnp_alloc_region(memt, &ipa->ipa_mem[nmem]);
327 if (error)
328 goto bad;
329 }
330
331 for (; nmem32 < ipa->ipa_nmem32; nmem32++) {
332 error = isapnp_alloc_region(memt, &ipa->ipa_mem32[nmem32]);
333 if (error)
334 goto bad;
335 }
336
337 for (; nirq < ipa->ipa_nirq; nirq++) {
338 error = isapnp_alloc_irq(ipa->ipa_ic, &ipa->ipa_irq[nirq]);
339 if (error)
340 goto bad;
341 }
342
343 for (; ndrq < ipa->ipa_ndrq; ndrq++) {
344 error = isapnp_alloc_drq(ipa->ipa_ic, &ipa->ipa_drq[ndrq]);
345 if (error)
346 goto bad;
347 }
348
349 if (alloc)
350 return error;
351
352 bad:
353 #ifdef notyet
354 for (ndrq--; ndrq >= 0; ndrq--)
355 isapnp_free_pin(&ipa->ipa_drq[ndrq]);
356
357 for (nirq--; nirq >= 0; nirq--)
358 isapnp_free_pin(&ipa->ipa_irq[nirq]);
359 #endif
360
361 for (nmem32--; nmem32 >= 0; nmem32--)
362 isapnp_free_region(memt, &ipa->ipa_mem32[nmem32]);
363
364 for (nmem--; nmem >= 0; nmem--)
365 isapnp_free_region(memt, &ipa->ipa_mem[nmem]);
366
367 for (nio--; nio >= 0; nio--)
368 isapnp_free_region(iot, &ipa->ipa_io[nio]);
369
370 return error;
371 }
372
373
374 /* isapnp_config():
375 * Test/Allocate the regions used
376 */
377 int
378 isapnp_config(iot, memt, ipa)
379 bus_space_tag_t iot, memt;
380 struct isapnp_attach_args *ipa;
381 {
382 return isapnp_testconfig(iot, memt, ipa, 1);
383 }
384
385
386 /* isapnp_unconfig():
387 * Free the regions used
388 */
389 void
390 isapnp_unconfig(iot, memt, ipa)
391 bus_space_tag_t iot, memt;
392 struct isapnp_attach_args *ipa;
393 {
394 int i;
395
396 #ifdef notyet
397 for (i = 0; i < ipa->ipa_ndrq; i++)
398 isapnp_free_pin(&ipa->ipa_drq[i]);
399
400 for (i = 0; i < ipa->ipa_nirq; i++)
401 isapnp_free_pin(&ipa->ipa_irq[i]);
402 #endif
403
404 for (i = 0; i < ipa->ipa_nmem32; i++)
405 isapnp_free_region(memt, &ipa->ipa_mem32[i]);
406
407 for (i = 0; i < ipa->ipa_nmem; i++)
408 isapnp_free_region(memt, &ipa->ipa_mem[i]);
409
410 for (i = 0; i < ipa->ipa_nio; i++)
411 isapnp_free_region(iot, &ipa->ipa_io[i]);
412 }
413
414
415 /* isapnp_bestconfig():
416 * Return the best configuration for each logical device, remove and
417 * free all other configurations.
418 */
419 static struct isapnp_attach_args *
420 isapnp_bestconfig(sc, ipa)
421 struct isapnp_softc *sc;
422 struct isapnp_attach_args **ipa;
423 {
424 struct isapnp_attach_args *c, *best, *f = *ipa;
425 int error;
426
427 for (;;) {
428 if (f == NULL)
429 return NULL;
430
431 #define SAMEDEV(a, b) (strcmp((a)->ipa_devlogic, (b)->ipa_devlogic) == 0)
432
433 /* Find the best config */
434 for (best = c = f; c != NULL; c = c->ipa_sibling) {
435 if (!SAMEDEV(c, f))
436 continue;
437 if (c->ipa_pref < best->ipa_pref)
438 best = c;
439 }
440
441 /*
442 * Make sure the ISA chipset is initialized! We need
443 * it to test the best config!
444 */
445 best->ipa_ic = sc->sc_ic;
446
447 /* Test the best config */
448 error = isapnp_testconfig(sc->sc_iot, sc->sc_memt, best, 0);
449
450 /* Remove this config from the list */
451 if (best == f)
452 f = f->ipa_sibling;
453 else {
454 for (c = f; c->ipa_sibling != best; c = c->ipa_sibling)
455 continue;
456 c->ipa_sibling = best->ipa_sibling;
457 }
458
459 if (error) {
460 best->ipa_pref = ISAPNP_DEP_CONFLICTING;
461
462 for (c = f; c != NULL; c = c->ipa_sibling)
463 if (c != best && SAMEDEV(c, best))
464 break;
465 /* Last config for this logical device is conflicting */
466 if (c == NULL) {
467 *ipa = f;
468 return best;
469 }
470
471 ISAPNP_FREE(best);
472 continue;
473 }
474 else {
475 /* Remove all other configs for this device */
476 struct isapnp_attach_args *l = NULL, *n = NULL, *d;
477
478 for (c = f; c; ) {
479 if (c == best)
480 continue;
481 d = c->ipa_sibling;
482 if (SAMEDEV(c, best))
483 ISAPNP_FREE(c);
484 else {
485 if (n)
486 n->ipa_sibling = c;
487
488 else
489 l = c;
490 n = c;
491 c->ipa_sibling = NULL;
492 }
493 c = d;
494 }
495 f = l;
496 }
497 *ipa = f;
498 return best;
499 }
500 }
501
502
503 /* isapnp_id_to_vendor():
504 * Convert a pnp ``compressed ascii'' vendor id to a string
505 */
506 char *
507 isapnp_id_to_vendor(v, id)
508 char *v;
509 const u_char *id;
510 {
511 static const char hex[] = "0123456789ABCDEF";
512 char *p = v;
513
514 *p++ = 'A' + (id[0] >> 2) - 1;
515 *p++ = 'A' + ((id[0] & 3) << 3) + (id[1] >> 5) - 1;
516 *p++ = 'A' + (id[1] & 0x1f) - 1;
517 *p++ = hex[id[2] >> 4];
518 *p++ = hex[id[2] & 0x0f];
519 *p++ = hex[id[3] >> 4];
520 *p++ = hex[id[3] & 0x0f];
521 *p = '\0';
522
523 return v;
524 }
525
526
527 /* isapnp_print_region():
528 * Print a region allocation
529 */
530 static void
531 isapnp_print_region(str, r, n)
532 const char *str;
533 struct isapnp_region *r;
534 size_t n;
535 {
536 size_t i;
537
538 if (n == 0)
539 return;
540
541 aprint_normal(" %s ", str);
542 for (i = 0; i < n; i++, r++) {
543 aprint_normal("0x%x", r->base);
544 if (r->length)
545 aprint_normal("/%d", r->length);
546 if (i != n - 1)
547 aprint_normal(",");
548 }
549 }
550
551
552 /* isapnp_print_pin():
553 * Print an irq/drq assignment
554 */
555 static void
556 isapnp_print_pin(str, p, n)
557 const char *str;
558 struct isapnp_pin *p;
559 size_t n;
560 {
561 size_t i;
562
563 if (n == 0)
564 return;
565
566 printf(" %s ", str);
567 for (i = 0; i < n; i++, p++) {
568 printf("%d", p->num);
569 if (i != n - 1)
570 printf(",");
571 }
572 }
573
574
575 /* isapnp_print():
576 * Print the configuration line for an ISA PnP card.
577 */
578 static int
579 isapnp_print(aux, str)
580 void *aux;
581 const char *str;
582 {
583 struct isapnp_attach_args *ipa = aux;
584
585 if (str != NULL)
586 aprint_normal("%s: <%s, %s, %s, %s>",
587 str, ipa->ipa_devident, ipa->ipa_devlogic,
588 ipa->ipa_devcompat, ipa->ipa_devclass);
589
590 isapnp_print_region("port", ipa->ipa_io, ipa->ipa_nio);
591 isapnp_print_region("mem", ipa->ipa_mem, ipa->ipa_nmem);
592 isapnp_print_region("mem32", ipa->ipa_mem32, ipa->ipa_nmem32);
593 isapnp_print_pin("irq", ipa->ipa_irq, ipa->ipa_nirq);
594 isapnp_print_pin("drq", ipa->ipa_drq, ipa->ipa_ndrq);
595
596 return UNCONF;
597 }
598
599
600 #ifdef _KERNEL
601 /* isapnp_submatch():
602 * Probe the logical device...
603 */
604 static int
605 isapnp_submatch(parent, match, aux)
606 struct device *parent;
607 struct cfdata *match;
608 void *aux;
609 {
610 return (config_match(parent, match, aux));
611 }
612
613
614 /* isapnp_devmatch():
615 * Match a probed device with the information from the driver
616 */
617 int
618 isapnp_devmatch(ipa, dinfo, variant)
619 const struct isapnp_attach_args *ipa;
620 const struct isapnp_devinfo *dinfo;
621 int *variant;
622 {
623 const struct isapnp_matchinfo *match;
624 int n;
625
626 for (match = dinfo->devlogic, n = dinfo->nlogic; n--; match++)
627 if (strcmp(match->name, ipa->ipa_devlogic) == 0) {
628 *variant = match->variant;
629 return (1);
630 }
631
632 for (match = dinfo->devcompat, n = dinfo->ncompat; n--; match++)
633 if (strcmp(match->name, ipa->ipa_devcompat) == 0) {
634 *variant = match->variant;
635 return (1);
636 }
637
638 return (0);
639 }
640
641
642 /* isapnp_isa_attach_hook():
643 * This routine is called from the isa attach code and
644 * is a kludge; we are resetting all the cards here in order
645 * to undo any card configuration that the bios did for us, in order
646 * to avoid having the PnP devices match an isa probe. The correct
647 * way of doing this is to read the PnP BIOS and find the card settings
648 * from there. Unfortunately it is not as easy as it sounds.
649 */
650 void
651 isapnp_isa_attach_hook(isa_sc)
652 struct isa_softc *isa_sc;
653 {
654 struct isapnp_softc sc;
655
656 sc.sc_iot = isa_sc->sc_iot;
657 sc.sc_ncards = 0;
658
659 if (isapnp_map(&sc))
660 return;
661
662 #if NWSS_ISAPNP > 0
663 /*
664 * XXX XXX
665 * This a totally disgusting hack, but I can't figure out another way.
666 * It seems that many CS audio chips have a bug (as far as I can
667 * understand). The reset below does not really reset the chip, it
668 * remains in a catatonic state and will not respond when probed.
669 * The chip can be used both as a WSS and as a SB device, and a
670 * single read at the WSS address (0x534) takes it out of this
671 * non-responsive state.
672 * The read has to happen at this point in time (or earlier) so
673 * it cannot be moved to the wss_isapnp.c driver.
674 * (BTW, We're not alone in having problems with these chips:
675 * Windoze 98 couldn't detect the sound chip on a Dell when I tried.)
676 *
677 * Lennart Augustsson <augustss@NetBSD.org>
678 *
679 * (Implementation from John Kohl <jtk@kolvir.arlington.ma.us>)
680 */
681 {
682 bus_space_handle_t ioh;
683 int rv;
684 if ((rv = bus_space_map(sc.sc_iot, 0x534, 1, 0, &ioh)) == 0) {
685 DPRINTF(("wss probe kludge\n"));
686 (void)bus_space_read_1(sc.sc_iot, ioh, 0);
687 bus_space_unmap(sc.sc_iot, ioh, 1);
688 } else {
689 DPRINTF(("wss probe kludge failed to map: %d\n", rv));
690 }
691 }
692 #endif
693
694 isapnp_init(&sc);
695
696 isapnp_write_reg(&sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
697 DELAY(2000);
698
699 isapnp_unmap(&sc);
700 }
701 #endif
702
703
704 /* isapnp_find():
705 * Probe and add cards
706 */
707 static int
708 isapnp_find(sc, all)
709 struct isapnp_softc *sc;
710 int all;
711 {
712 int p;
713
714 isapnp_init(sc);
715
716 isapnp_write_reg(sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
717 DELAY(2000);
718
719 isapnp_init(sc);
720 DELAY(2000);
721
722 for (p = ISAPNP_RDDATA_MIN; p <= ISAPNP_RDDATA_MAX; p += 4) {
723 sc->sc_read_port = p;
724 if (isapnp_map_readport(sc))
725 continue;
726 DPRINTF(("%s: Trying port %x\r", sc->sc_dev.dv_xname, p));
727 if (isapnp_findcard(sc))
728 break;
729 isapnp_unmap_readport(sc);
730 }
731
732 if (p > ISAPNP_RDDATA_MAX) {
733 sc->sc_read_port = 0;
734 return 0;
735 }
736
737 if (all)
738 while (isapnp_findcard(sc))
739 continue;
740
741 return 1;
742 }
743
744
745 /* isapnp_configure():
746 * Configure a PnP card
747 * XXX: The memory configuration code is wrong. We need to check the
748 * range/length bit an do appropriate sets.
749 */
750 static void
751 isapnp_configure(sc, ipa)
752 struct isapnp_softc *sc;
753 const struct isapnp_attach_args *ipa;
754 {
755 int i;
756 static u_char isapnp_mem_range[] = ISAPNP_MEM_DESC;
757 static u_char isapnp_io_range[] = ISAPNP_IO_DESC;
758 static u_char isapnp_irq_range[] = ISAPNP_IRQ_DESC;
759 static u_char isapnp_drq_range[] = ISAPNP_DRQ_DESC;
760 static u_char isapnp_mem32_range[] = ISAPNP_MEM32_DESC;
761 const struct isapnp_region *r;
762 const struct isapnp_pin *p;
763 struct isapnp_region rz;
764 struct isapnp_pin pz;
765
766 memset(&pz, 0, sizeof(pz));
767 memset(&rz, 0, sizeof(rz));
768
769 #define B0(a) ((a) & 0xff)
770 #define B1(a) (((a) >> 8) & 0xff)
771 #define B2(a) (((a) >> 16) & 0xff)
772 #define B3(a) (((a) >> 24) & 0xff)
773
774 for (i = 0; i < sizeof(isapnp_io_range); i++) {
775 if (i < ipa->ipa_nio)
776 r = &ipa->ipa_io[i];
777 else
778 r = &rz;
779
780 isapnp_write_reg(sc,
781 isapnp_io_range[i] + ISAPNP_IO_BASE_15_8, B1(r->base));
782 isapnp_write_reg(sc,
783 isapnp_io_range[i] + ISAPNP_IO_BASE_7_0, B0(r->base));
784 }
785
786 for (i = 0; i < sizeof(isapnp_mem_range); i++) {
787 if (i < ipa->ipa_nmem)
788 r = &ipa->ipa_mem[i];
789 else
790 r = &rz;
791
792 isapnp_write_reg(sc,
793 isapnp_mem_range[i] + ISAPNP_MEM_BASE_23_16, B2(r->base));
794 isapnp_write_reg(sc,
795 isapnp_mem_range[i] + ISAPNP_MEM_BASE_15_8, B1(r->base));
796
797 isapnp_write_reg(sc,
798 isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_23_16,
799 B2(r->length));
800 isapnp_write_reg(sc,
801 isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_15_8,
802 B1(r->length));
803 }
804
805 for (i = 0; i < sizeof(isapnp_irq_range); i++) {
806 u_char v;
807
808 if (i < ipa->ipa_nirq)
809 p = &ipa->ipa_irq[i];
810 else
811 p = &pz;
812
813 isapnp_write_reg(sc,
814 isapnp_irq_range[i] + ISAPNP_IRQ_NUMBER, p->num);
815
816 switch (p->flags) {
817 case ISAPNP_IRQTYPE_LEVEL_PLUS:
818 v = ISAPNP_IRQ_LEVEL|ISAPNP_IRQ_HIGH;
819 break;
820
821 case ISAPNP_IRQTYPE_EDGE_PLUS:
822 v = ISAPNP_IRQ_HIGH;
823 break;
824
825 case ISAPNP_IRQTYPE_LEVEL_MINUS:
826 v = ISAPNP_IRQ_LEVEL;
827 break;
828
829 default:
830 case ISAPNP_IRQTYPE_EDGE_MINUS:
831 v = 0;
832 break;
833 }
834 isapnp_write_reg(sc,
835 isapnp_irq_range[i] + ISAPNP_IRQ_CONTROL, v);
836 }
837
838 for (i = 0; i < sizeof(isapnp_drq_range); i++) {
839 u_char v;
840
841 if (i < ipa->ipa_ndrq)
842 v = ipa->ipa_drq[i].num;
843 else
844 v = 4;
845
846 isapnp_write_reg(sc, isapnp_drq_range[i], v);
847 }
848
849 for (i = 0; i < sizeof(isapnp_mem32_range); i++) {
850 if (i < ipa->ipa_nmem32)
851 r = &ipa->ipa_mem32[i];
852 else
853 r = &rz;
854
855 isapnp_write_reg(sc,
856 isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_31_24,
857 B3(r->base));
858 isapnp_write_reg(sc,
859 isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_23_16,
860 B2(r->base));
861 isapnp_write_reg(sc,
862 isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_15_8,
863 B1(r->base));
864 isapnp_write_reg(sc,
865 isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_7_0,
866 B0(r->base));
867
868 isapnp_write_reg(sc,
869 isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_31_24,
870 B3(r->length));
871 isapnp_write_reg(sc,
872 isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_23_16,
873 B2(r->length));
874 isapnp_write_reg(sc,
875 isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_15_8,
876 B1(r->length));
877 isapnp_write_reg(sc,
878 isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_7_0,
879 B0(r->length));
880 }
881 }
882
883
884 /* isapnp_match():
885 * Probe routine
886 */
887 static int
888 isapnp_match(parent, match, aux)
889 struct device *parent;
890 struct cfdata *match;
891 void *aux;
892 {
893 struct isapnp_softc sc;
894 struct isa_attach_args *ia = aux;
895 struct isapnp_probe_cookie *ipc;
896
897 /*
898 * Ensure we only probe ISA PnP once; we don't actually consume
899 * bus resources, so we have to prevent being cloned forever.
900 */
901 for (ipc = LIST_FIRST(&isapnp_probes); ipc != NULL;
902 ipc = LIST_NEXT(ipc, ipc_link))
903 if (ipc->ipc_parent == parent)
904 return (0);
905
906 ipc = malloc(sizeof(*ipc), M_DEVBUF, M_NOWAIT);
907 if (ipc == NULL)
908 panic("isapnp_match: can't allocate probe cookie");
909
910 ipc->ipc_parent = parent;
911 LIST_INSERT_HEAD(&isapnp_probes, ipc, ipc_link);
912
913 sc.sc_iot = ia->ia_iot;
914 (void) strcpy(sc.sc_dev.dv_xname, "(isapnp probe)");
915
916 if (isapnp_map(&sc))
917 return 0;
918
919 isapnp_unmap(&sc);
920
921 /*
922 * We always match. We must let all legacy ISA devices map
923 * their address spaces before we look for a read port.
924 */
925 ia->ia_io[0].ir_addr = ISAPNP_ADDR;
926 ia->ia_io[0].ir_size = 1;
927
928 ia->ia_niomem = 0;
929 ia->ia_nirq = 0;
930 ia->ia_ndrq = 0;
931
932 return (1);
933 }
934
935
936 /* isapnp_attach
937 * Attach the PnP `bus'.
938 */
939 static void
940 isapnp_attach(parent, self, aux)
941 struct device *parent, *self;
942 void *aux;
943 {
944 struct isapnp_softc *sc = (struct isapnp_softc *) self;
945 struct isa_attach_args *ia = aux;
946
947 sc->sc_iot = ia->ia_iot;
948 sc->sc_memt = ia->ia_memt;
949 sc->sc_ic = ia->ia_ic;
950 sc->sc_dmat = ia->ia_dmat;
951 sc->sc_ncards = 0;
952
953 printf(": ISA Plug 'n Play device support\n");
954
955 if (isapnp_map(sc)) {
956 printf("%s: unable to map PnP register\n",
957 sc->sc_dev.dv_xname);
958 return;
959 }
960
961 #ifdef _KERNEL
962 /*
963 * Defer configuration until the rest of the ISA devices have
964 * attached themselves.
965 */
966 config_defer(self, isapnp_callback);
967 #else
968 isapnp_callback(self);
969 #endif
970 }
971
972 /* isapnp_callback
973 * Find and attach PnP cards.
974 */
975 void
976 isapnp_callback(self)
977 struct device *self;
978 {
979 struct isapnp_softc *sc = (struct isapnp_softc *)self;
980 struct isapnp_attach_args *ipa, *lpa;
981 int c, d;
982
983 /*
984 * Look for cards. If none are found, we say so and just return.
985 */
986 if (isapnp_find(sc, 1) == 0) {
987 printf("%s: no ISA Plug 'n Play devices found\n",
988 sc->sc_dev.dv_xname);
989 return;
990 }
991
992 printf("%s: read port 0x%x\n", sc->sc_dev.dv_xname, sc->sc_read_port);
993
994 /*
995 * Now configure all of the cards.
996 */
997 for (c = 0; c < sc->sc_ncards; c++) {
998 /* Good morning card c */
999 isapnp_write_reg(sc, ISAPNP_WAKE, c + 1);
1000
1001 if ((ipa = isapnp_get_resource(sc, c)) == NULL)
1002 continue;
1003
1004 DPRINTF(("Selecting attachments\n"));
1005 for (d = 0;
1006 (lpa = isapnp_bestconfig(sc, &ipa)) != NULL; d++) {
1007 isapnp_write_reg(sc, ISAPNP_LOGICAL_DEV_NUM, d);
1008 isapnp_configure(sc, lpa);
1009 #ifdef DEBUG_ISAPNP
1010 {
1011 struct isapnp_attach_args pa;
1012
1013 isapnp_get_config(sc, &pa);
1014 isapnp_print_config(&pa);
1015 }
1016 #endif
1017
1018 DPRINTF(("%s: configuring <%s, %s, %s, %s>\n",
1019 sc->sc_dev.dv_xname,
1020 lpa->ipa_devident, lpa->ipa_devlogic,
1021 lpa->ipa_devcompat, lpa->ipa_devclass));
1022 if (lpa->ipa_pref == ISAPNP_DEP_CONFLICTING) {
1023 printf("%s: <%s, %s, %s, %s> ignored; %s\n",
1024 sc->sc_dev.dv_xname,
1025 lpa->ipa_devident, lpa->ipa_devlogic,
1026 lpa->ipa_devcompat, lpa->ipa_devclass,
1027 "resource conflict");
1028 ISAPNP_FREE(lpa);
1029 continue;
1030 }
1031
1032 lpa->ipa_ic = sc->sc_ic;
1033 lpa->ipa_iot = sc->sc_iot;
1034 lpa->ipa_memt = sc->sc_memt;
1035 lpa->ipa_dmat = sc->sc_dmat;
1036
1037 isapnp_write_reg(sc, ISAPNP_ACTIVATE, 1);
1038 #ifdef _KERNEL
1039 if (config_found_sm(self, lpa, isapnp_print,
1040 isapnp_submatch) == NULL)
1041 isapnp_write_reg(sc, ISAPNP_ACTIVATE, 0);
1042 #else
1043 isapnp_print(lpa, NULL);
1044 printf("\n");
1045 #endif
1046 ISAPNP_FREE(lpa);
1047 }
1048 isapnp_write_reg(sc, ISAPNP_WAKE, 0); /* Good night cards */
1049 }
1050 }
Cache object: 75836fc32ec223aae80f5e1337d1f1c5
|