FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/isa/gusc.c
1 /*-
2 * Copyright (c) 1999 Seigo Tanimura
3 * Copyright (c) 1999 Ville-Pertti Keinonen
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/kernel.h>
31 #include <sys/bus.h>
32 #include <sys/malloc.h>
33 #include <sys/module.h>
34 #include <machine/resource.h>
35 #include <machine/bus.h>
36 #include <sys/rman.h>
37 #include <sys/soundcard.h>
38 #include <dev/sound/pcm/sound.h>
39 #include <dev/sound/chip.h>
40 #include "bus_if.h"
41
42 #include <isa/isavar.h>
43 #include <isa/isa_common.h>
44
45 SND_DECLARE_FILE("$FreeBSD$");
46
47 #define LOGICALID_NOPNP 0
48 #define LOGICALID_PCM 0x0000561e
49 #define LOGICALID_OPL 0x0300561e
50 #define LOGICALID_MIDI 0x0400561e
51
52 /* PnP IDs */
53 static struct isa_pnp_id gusc_ids[] = {
54 {LOGICALID_PCM, "GRV0000 Gravis UltraSound PnP PCM"}, /* GRV0000 */
55 {LOGICALID_OPL, "GRV0003 Gravis UltraSound PnP OPL"}, /* GRV0003 */
56 {LOGICALID_MIDI, "GRV0004 Gravis UltraSound PnP MIDI"}, /* GRV0004 */
57 };
58
59 /* Interrupt handler. */
60 struct gusc_ihandler {
61 void (*intr)(void *);
62 void *arg;
63 };
64
65 /* Here is the parameter structure per a device. */
66 struct gusc_softc {
67 device_t dev; /* device */
68 int io_rid[3]; /* io port rids */
69 struct resource *io[3]; /* io port resources */
70 int io_alloced[3]; /* io port alloc flag */
71 int irq_rid; /* irq rids */
72 struct resource *irq; /* irq resources */
73 int irq_alloced; /* irq alloc flag */
74 int drq_rid[2]; /* drq rids */
75 struct resource *drq[2]; /* drq resources */
76 int drq_alloced[2]; /* drq alloc flag */
77
78 /* Interrupts are shared (XXX non-PnP only?) */
79 struct gusc_ihandler midi_intr;
80 struct gusc_ihandler pcm_intr;
81 };
82
83 typedef struct gusc_softc *sc_p;
84
85 static int gusc_probe(device_t dev);
86 static int gusc_attach(device_t dev);
87 static int gusisa_probe(device_t dev);
88 static void gusc_intr(void *);
89 static struct resource *gusc_alloc_resource(device_t bus, device_t child, int type, int *rid,
90 u_long start, u_long end, u_long count, u_int flags);
91 static int gusc_release_resource(device_t bus, device_t child, int type, int rid,
92 struct resource *r);
93
94 static device_t find_masterdev(sc_p scp);
95 static int alloc_resource(sc_p scp);
96 static int release_resource(sc_p scp);
97
98 static devclass_t gusc_devclass;
99
100 static int
101 gusc_probe(device_t dev)
102 {
103 device_t child;
104 u_int32_t logical_id;
105 char *s;
106 struct sndcard_func *func;
107 int ret;
108
109 logical_id = isa_get_logicalid(dev);
110 s = NULL;
111
112 /* Check isapnp ids */
113 if (logical_id != 0 && (ret = ISA_PNP_PROBE(device_get_parent(dev), dev, gusc_ids)) != 0)
114 return (ret);
115 else {
116 if (logical_id == 0)
117 return gusisa_probe(dev);
118 }
119
120 switch (logical_id) {
121 case LOGICALID_PCM:
122 s = "Gravis UltraSound Plug & Play PCM";
123 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
124 if (func == NULL)
125 return (ENOMEM);
126 func->func = SCF_PCM;
127 child = device_add_child(dev, "pcm", -1);
128 device_set_ivars(child, func);
129 break;
130 case LOGICALID_OPL:
131 s = "Gravis UltraSound Plug & Play OPL";
132 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
133 if (func == NULL)
134 return (ENOMEM);
135 func->func = SCF_SYNTH;
136 child = device_add_child(dev, "midi", -1);
137 device_set_ivars(child, func);
138 break;
139 case LOGICALID_MIDI:
140 s = "Gravis UltraSound Plug & Play MIDI";
141 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
142 if (func == NULL)
143 return (ENOMEM);
144 func->func = SCF_MIDI;
145 child = device_add_child(dev, "midi", -1);
146 device_set_ivars(child, func);
147 break;
148 }
149
150 if (s != NULL) {
151 device_set_desc(dev, s);
152 return (0);
153 }
154
155 return (ENXIO);
156 }
157
158 static void
159 port_wr(struct resource *r, int i, unsigned char v)
160 {
161 bus_space_write_1(rman_get_bustag(r), rman_get_bushandle(r), i, v);
162 }
163
164 static int
165 port_rd(struct resource *r, int i)
166 {
167 return bus_space_read_1(rman_get_bustag(r), rman_get_bushandle(r), i);
168 }
169
170 /*
171 * Probe for an old (non-PnP) GUS card on the ISA bus.
172 */
173
174 static int
175 gusisa_probe(device_t dev)
176 {
177 device_t child;
178 struct resource *res, *res2;
179 int base, rid, rid2, s, flags;
180 unsigned char val;
181
182 base = isa_get_port(dev);
183 flags = device_get_flags(dev);
184 rid = 1;
185 res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, base + 0x100,
186 base + 0x107, 8, RF_ACTIVE);
187
188 if (res == NULL)
189 return ENXIO;
190
191 res2 = NULL;
192
193 /*
194 * Check for the presence of some GUS card. Reset the card,
195 * then see if we can access the memory on it.
196 */
197
198 port_wr(res, 3, 0x4c);
199 port_wr(res, 5, 0);
200 DELAY(30 * 1000);
201
202 port_wr(res, 3, 0x4c);
203 port_wr(res, 5, 1);
204 DELAY(30 * 1000);
205
206 s = splhigh();
207
208 /* Write to DRAM. */
209
210 port_wr(res, 3, 0x43); /* Register select */
211 port_wr(res, 4, 0); /* Low addr */
212 port_wr(res, 5, 0); /* Med addr */
213
214 port_wr(res, 3, 0x44); /* Register select */
215 port_wr(res, 4, 0); /* High addr */
216 port_wr(res, 7, 0x55); /* DRAM */
217
218 /* Read from DRAM. */
219
220 port_wr(res, 3, 0x43); /* Register select */
221 port_wr(res, 4, 0); /* Low addr */
222 port_wr(res, 5, 0); /* Med addr */
223
224 port_wr(res, 3, 0x44); /* Register select */
225 port_wr(res, 4, 0); /* High addr */
226 val = port_rd(res, 7); /* DRAM */
227
228 splx(s);
229
230 if (val != 0x55)
231 goto fail;
232
233 rid2 = 0;
234 res2 = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid2, base, base, 1,
235 RF_ACTIVE);
236
237 if (res2 == NULL)
238 goto fail;
239
240 s = splhigh();
241 port_wr(res2, 0x0f, 0x20);
242 val = port_rd(res2, 0x0f);
243 splx(s);
244
245 if (val == 0xff || (val & 0x06) == 0)
246 val = 0;
247 else {
248 val = port_rd(res2, 0x506); /* XXX Out of range. */
249 if (val == 0xff)
250 val = 0;
251 }
252
253 bus_release_resource(dev, SYS_RES_IOPORT, rid2, res2);
254 bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
255
256 if (val >= 10) {
257 struct sndcard_func *func;
258
259 /* Looks like a GUS MAX. Set the rest of the resources. */
260
261 bus_set_resource(dev, SYS_RES_IOPORT, 2, base + 0x10c, 8);
262
263 if (flags & DV_F_DUAL_DMA)
264 bus_set_resource(dev, SYS_RES_DRQ, 1,
265 flags & DV_F_DRQ_MASK, 1);
266
267 /* We can support the CS4231 and MIDI devices. */
268
269 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
270 if (func == NULL)
271 return ENOMEM;
272 func->func = SCF_MIDI;
273 child = device_add_child(dev, "midi", -1);
274 device_set_ivars(child, func);
275
276 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
277 if (func == NULL)
278 printf("xxx: gus pcm not attached, out of memory\n");
279 else {
280 func->func = SCF_PCM;
281 child = device_add_child(dev, "pcm", -1);
282 device_set_ivars(child, func);
283 }
284 device_set_desc(dev, "Gravis UltraSound MAX");
285 return 0;
286 } else {
287
288 /*
289 * TODO: Support even older GUS cards. MIDI should work on
290 * all models.
291 */
292 return ENXIO;
293 }
294
295 fail:
296 bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
297 return ENXIO;
298 }
299
300 static int
301 gusc_attach(device_t dev)
302 {
303 sc_p scp;
304 int unit;
305 void *ih;
306
307 scp = device_get_softc(dev);
308 unit = device_get_unit(dev);
309
310 bzero(scp, sizeof(*scp));
311
312 scp->dev = dev;
313 if (alloc_resource(scp)) {
314 release_resource(scp);
315 return (ENXIO);
316 }
317
318 if (scp->irq != NULL)
319 snd_setup_intr(dev, scp->irq, 0, gusc_intr, scp, &ih);
320 bus_generic_attach(dev);
321
322 return (0);
323 }
324
325 /*
326 * Handle interrupts on GUS devices until there aren't any left.
327 */
328 static void
329 gusc_intr(void *arg)
330 {
331 sc_p scp = (sc_p)arg;
332 int did_something;
333
334 do {
335 did_something = 0;
336 if (scp->pcm_intr.intr != NULL &&
337 (port_rd(scp->io[2], 2) & 1)) {
338 (*scp->pcm_intr.intr)(scp->pcm_intr.arg);
339 did_something = 1;
340 }
341 if (scp->midi_intr.intr != NULL &&
342 (port_rd(scp->io[1], 0) & 0x80)) {
343 (*scp->midi_intr.intr)(scp->midi_intr.arg);
344 did_something = 1;
345 }
346 } while (did_something != 0);
347 }
348
349 static struct resource *
350 gusc_alloc_resource(device_t bus, device_t child, int type, int *rid,
351 u_long start, u_long end, u_long count, u_int flags)
352 {
353 sc_p scp;
354 int *alloced, rid_max, alloced_max;
355 struct resource **res;
356
357 scp = device_get_softc(bus);
358 switch (type) {
359 case SYS_RES_IOPORT:
360 alloced = scp->io_alloced;
361 res = scp->io;
362 rid_max = 2;
363 alloced_max = 2; /* pcm + midi (more to include synth) */
364 break;
365 case SYS_RES_IRQ:
366 alloced = &scp->irq_alloced;
367 res = &scp->irq;
368 rid_max = 0;
369 alloced_max = 2; /* pcm and midi share the single irq. */
370 break;
371 case SYS_RES_DRQ:
372 alloced = scp->drq_alloced;
373 res = scp->drq;
374 rid_max = 1;
375 alloced_max = 1;
376 break;
377 default:
378 return (NULL);
379 }
380
381 if (*rid > rid_max || alloced[*rid] == alloced_max)
382 return (NULL);
383
384 alloced[*rid]++;
385 return (res[*rid]);
386 }
387
388 static int
389 gusc_release_resource(device_t bus, device_t child, int type, int rid,
390 struct resource *r)
391 {
392 sc_p scp;
393 int *alloced, rid_max;
394
395 scp = device_get_softc(bus);
396 switch (type) {
397 case SYS_RES_IOPORT:
398 alloced = scp->io_alloced;
399 rid_max = 2;
400 break;
401 case SYS_RES_IRQ:
402 alloced = &scp->irq_alloced;
403 rid_max = 0;
404 break;
405 case SYS_RES_DRQ:
406 alloced = scp->drq_alloced;
407 rid_max = 1;
408 break;
409 default:
410 return (1);
411 }
412
413 if (rid > rid_max || alloced[rid] == 0)
414 return (1);
415
416 alloced[rid]--;
417 return (0);
418 }
419
420 static int
421 gusc_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
422 #if __FreeBSD_version >= 700031
423 driver_filter_t *filter,
424 #endif
425 driver_intr_t *intr, void *arg, void **cookiep)
426 {
427 sc_p scp = (sc_p)device_get_softc(dev);
428 devclass_t devclass;
429
430 #if __FreeBSD_version >= 700031
431 if (filter != NULL) {
432 printf("gusc.c: we cannot use a filter here\n");
433 return (EINVAL);
434 }
435 #endif
436 devclass = device_get_devclass(child);
437 if (strcmp(devclass_get_name(devclass), "midi") == 0) {
438 scp->midi_intr.intr = intr;
439 scp->midi_intr.arg = arg;
440 return 0;
441 } else if (strcmp(devclass_get_name(devclass), "pcm") == 0) {
442 scp->pcm_intr.intr = intr;
443 scp->pcm_intr.arg = arg;
444 return 0;
445 }
446 return bus_generic_setup_intr(dev, child, irq, flags,
447 #if __FreeBSD_version >= 700031
448 filter,
449 #endif
450 intr, arg, cookiep);
451 }
452
453 static device_t
454 find_masterdev(sc_p scp)
455 {
456 int i, units;
457 devclass_t devclass;
458 device_t dev;
459
460 devclass = device_get_devclass(scp->dev);
461 units = devclass_get_maxunit(devclass);
462 dev = NULL;
463 for (i = 0 ; i < units ; i++) {
464 dev = devclass_get_device(devclass, i);
465 if (isa_get_vendorid(dev) == isa_get_vendorid(scp->dev)
466 && isa_get_logicalid(dev) == LOGICALID_PCM
467 && isa_get_serial(dev) == isa_get_serial(scp->dev))
468 break;
469 }
470 if (i == units)
471 return (NULL);
472
473 return (dev);
474 }
475
476 static int io_range[3] = {0x10, 0x8 , 0x4 };
477 static int io_offset[3] = {0x0 , 0x100, 0x10c};
478 static int
479 alloc_resource(sc_p scp)
480 {
481 int i, base, lid, flags;
482 device_t dev;
483
484 flags = 0;
485 if (isa_get_vendorid(scp->dev))
486 lid = isa_get_logicalid(scp->dev);
487 else {
488 lid = LOGICALID_NOPNP;
489 flags = device_get_flags(scp->dev);
490 }
491 switch(lid) {
492 case LOGICALID_PCM:
493 case LOGICALID_NOPNP: /* XXX Non-PnP */
494 if (lid == LOGICALID_NOPNP)
495 base = isa_get_port(scp->dev);
496 else
497 base = 0;
498 for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
499 if (scp->io[i] == NULL) {
500 scp->io_rid[i] = i;
501 if (base == 0)
502 scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
503 0, ~0, io_range[i], RF_ACTIVE);
504 else
505 scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
506 base + io_offset[i],
507 base + io_offset[i] + io_range[i] - 1
508 , io_range[i], RF_ACTIVE);
509 if (scp->io[i] == NULL)
510 return (1);
511 scp->io_alloced[i] = 0;
512 }
513 }
514 if (scp->irq == NULL) {
515 scp->irq_rid = 0;
516 scp->irq =
517 bus_alloc_resource_any(scp->dev, SYS_RES_IRQ,
518 &scp->irq_rid,
519 RF_ACTIVE|RF_SHAREABLE);
520 if (scp->irq == NULL)
521 return (1);
522 scp->irq_alloced = 0;
523 }
524 for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
525 if (scp->drq[i] == NULL) {
526 scp->drq_rid[i] = i;
527 if (base == 0 || i == 0)
528 scp->drq[i] =
529 bus_alloc_resource_any(
530 scp->dev, SYS_RES_DRQ,
531 &scp->drq_rid[i],
532 RF_ACTIVE);
533 else if ((flags & DV_F_DUAL_DMA) != 0)
534 /* XXX The secondary drq is specified in the flag. */
535 scp->drq[i] = bus_alloc_resource(scp->dev, SYS_RES_DRQ, &scp->drq_rid[i],
536 flags & DV_F_DRQ_MASK,
537 flags & DV_F_DRQ_MASK, 1, RF_ACTIVE);
538 if (scp->drq[i] == NULL)
539 return (1);
540 scp->drq_alloced[i] = 0;
541 }
542 }
543 break;
544 case LOGICALID_OPL:
545 if (scp->io[0] == NULL) {
546 scp->io_rid[0] = 0;
547 scp->io[0] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[0],
548 0, ~0, io_range[0], RF_ACTIVE);
549 if (scp->io[0] == NULL)
550 return (1);
551 scp->io_alloced[0] = 0;
552 }
553 break;
554 case LOGICALID_MIDI:
555 if (scp->io[0] == NULL) {
556 scp->io_rid[0] = 0;
557 scp->io[0] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[0],
558 0, ~0, io_range[0], RF_ACTIVE);
559 if (scp->io[0] == NULL)
560 return (1);
561 scp->io_alloced[0] = 0;
562 }
563 if (scp->irq == NULL) {
564 /* The irq is shared with pcm audio. */
565 dev = find_masterdev(scp);
566 if (dev == NULL)
567 return (1);
568 scp->irq_rid = 0;
569 scp->irq = BUS_ALLOC_RESOURCE(dev, NULL, SYS_RES_IRQ, &scp->irq_rid,
570 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
571 if (scp->irq == NULL)
572 return (1);
573 scp->irq_alloced = 0;
574 }
575 break;
576 }
577 return (0);
578 }
579
580 static int
581 release_resource(sc_p scp)
582 {
583 int i, lid, flags;
584 device_t dev;
585
586 flags = 0;
587 if (isa_get_vendorid(scp->dev))
588 lid = isa_get_logicalid(scp->dev);
589 else {
590 lid = LOGICALID_NOPNP;
591 flags = device_get_flags(scp->dev);
592 }
593 switch(lid) {
594 case LOGICALID_PCM:
595 case LOGICALID_NOPNP: /* XXX Non-PnP */
596 for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
597 if (scp->io[i] != NULL) {
598 bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
599 scp->io[i] = NULL;
600 }
601 }
602 if (scp->irq != NULL) {
603 bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid, scp->irq);
604 scp->irq = NULL;
605 }
606 for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
607 if (scp->drq[i] != NULL) {
608 bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
609 scp->drq[i] = NULL;
610 }
611 }
612 break;
613 case LOGICALID_OPL:
614 if (scp->io[0] != NULL) {
615 bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
616 scp->io[0] = NULL;
617 }
618 break;
619 case LOGICALID_MIDI:
620 if (scp->io[0] != NULL) {
621 bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
622 scp->io[0] = NULL;
623 }
624 if (scp->irq != NULL) {
625 /* The irq is shared with pcm audio. */
626 dev = find_masterdev(scp);
627 if (dev == NULL)
628 return (1);
629 BUS_RELEASE_RESOURCE(dev, NULL, SYS_RES_IOPORT, scp->irq_rid, scp->irq);
630 scp->irq = NULL;
631 }
632 break;
633 }
634 return (0);
635 }
636
637 static device_method_t gusc_methods[] = {
638 /* Device interface */
639 DEVMETHOD(device_probe, gusc_probe),
640 DEVMETHOD(device_attach, gusc_attach),
641 DEVMETHOD(device_detach, bus_generic_detach),
642 DEVMETHOD(device_shutdown, bus_generic_shutdown),
643 DEVMETHOD(device_suspend, bus_generic_suspend),
644 DEVMETHOD(device_resume, bus_generic_resume),
645
646 /* Bus interface */
647 DEVMETHOD(bus_print_child, bus_generic_print_child),
648 DEVMETHOD(bus_alloc_resource, gusc_alloc_resource),
649 DEVMETHOD(bus_release_resource, gusc_release_resource),
650 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
651 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
652 DEVMETHOD(bus_setup_intr, gusc_setup_intr),
653 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
654
655 { 0, 0 }
656 };
657
658 static driver_t gusc_driver = {
659 "gusc",
660 gusc_methods,
661 sizeof(struct gusc_softc),
662 };
663
664 /*
665 * gusc can be attached to an isa bus.
666 */
667 DRIVER_MODULE(snd_gusc, isa, gusc_driver, gusc_devclass, 0, 0);
668 DRIVER_MODULE(snd_gusc, acpi, gusc_driver, gusc_devclass, 0, 0);
669 MODULE_DEPEND(snd_gusc, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
670 MODULE_VERSION(snd_gusc, 1);
671
672
Cache object: b09843d7302683879ca478273a8a43f8
|