![[BACK]](/icons/back.gif){kind=icon}
Return to aria.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa|
Return to aria.c CVS log | Up to [local] / sys / dev / isa |
1.1 nbrk 1: /* $OpenBSD: aria.c,v 1.13 2006/05/11 18:50:18 miod Exp $ */
2:
3: /*
4: * Copyright (c) 1995, 1996 Roland C. Dowdeswell. 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: * 3. All advertising materials mentioning features or use of this software
15: * must display the following acknowledgement:
16: * This product includes software developed by Roland C. Dowdeswell.
17: * 4. The name of the authors may not be used to endorse or promote products
18: * derived from this software without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
21: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23: * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30: */
31:
32: /*
33: * TODO:
34: * o Test the driver on cards other than a single
35: * Prometheus Aria 16.
36: * o Look into where aria_prometheus_kludge() belongs.
37: * o Add some dma code. It accomplishes its goal by
38: * direct IO at the moment.
39: * o Look into return values on aria_set_sr(), if there is
40: * no matching rate. (I think that this behaves in the
41: * same way as sbdsp.c)
42: * o Different programs should be able to open the device
43: * with O_RDONLY and O_WRONLY at the same time. But I
44: * do not see support for this in /sys/dev/audio.c, so
45: * I cannot effectively code it.
46: * o Separate the debugging code, with a #define.
47: * Write more into aria_printsc().
48: * o Rework the mixer interface.
49: * o Deal with the lvls better. We need to do better mapping
50: * between logarithmic scales and the one byte that
51: * we are passed.
52: * o Deal better with cards that have no mixer.
53: *
54: * roland@imrryr.org
55: * update from http://www.imrryr.org/NetBSD/hacks/aria/
56: */
57:
58: #include "aria.h"
59: #if NARIA > 0
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/errno.h>
64: #include <sys/ioctl.h>
65: #include <sys/syslog.h>
66: #include <sys/device.h>
67: #include <sys/proc.h>
68: #include <sys/buf.h>
69:
70: #include <machine/cpu.h>
71: #include <machine/pio.h>
72:
73: #include <sys/audioio.h>
74: #include <dev/audio_if.h>
75:
76: #include <dev/mulaw.h>
77: #include <dev/isa/isavar.h>
78: #include <dev/isa/isadmavar.h>
79:
80: #include <dev/isa/ariareg.h>
81:
82: #define FREAD 1
83: #define FWRITE 2
84:
85: #ifdef AUDIO_DEBUG
86: extern void Dprintf(const char *, ...);
87: #define DPRINTF(x) if (ariadebug) Dprintf x
88: int ariadebug = 0;
89: #else
90: #define DPRINTF(x)
91: #endif
92:
93: struct aria_mixdev_info {
94: u_char num_channels;
95: u_char level[2];
96: u_char mute;
97: };
98:
99: struct aria_mixmaster {
100: u_char num_channels;
101: u_char level[2];
102: u_char treble[2];
103: u_char bass[2];
104: };
105:
106: struct aria_softc {
107: struct device sc_dev; /* base device */
108: struct isadev sc_id; /* ISA device */
109: void *sc_ih; /* interrupt vectoring */
110:
111: u_short sc_iobase; /* I/O port base address */
112: u_short sc_irq; /* interrupt */
113: u_short sc_drq; /* dma chan */
114:
115: u_short sc_open; /* reference count of open calls */
116: u_short sc_play; /* non-paused play chans 2**chan */
117: u_short sc_record; /* non-paused record chans 2**chan */
118: u_short sc_change; /* to keep track of changes of a type */
119: u_short gain[2]; /* left/right gain (play) */
120: u_int spkr_state; /* non-null is on */
121:
122: u_long sc_rate; /* Sample rate for input and output */
123: u_int sc_encoding; /* audio encoding -- ulaw/linear */
124: int sc_chans; /* # of channels */
125: int sc_precision; /* # bits per sample */
126:
127: u_long sc_interrupts; /* number of interrupts taken */
128: void (*sc_rintr)(void *); /* record transfer completion intr handler */
129: void (*sc_pintr)(void *); /* play transfer completion intr handler */
130: void *sc_rarg; /* arg for sc_rintr() */
131: void *sc_parg; /* arg for sc_pintr() */
132:
133: int sc_blocksize; /* literal dio block size */
134: void *sc_rdiobuffer; /* record: where the next samples should be */
135: void *sc_pdiobuffer; /* play: where the next samples are */
136:
137: u_short sc_hardware; /* bit field of hardware present */
138: #define ARIA_TELEPHONE 0x0001 /* has telephone input */
139: #define ARIA_MIXER 0x0002 /* has SC18075 digital mixer */
140: #define ARIA_MODEL 0x0004 /* is SC18025 (=0) or SC18026 (=1) */
141:
142: struct aria_mixdev_info aria_mix[6];
143: struct aria_mixmaster ariamix_master;
144: u_char aria_mix_source;
145: };
146:
147: struct {
148: int sendcmd;
149: int wmidi;
150: } ariaerr;
151:
152:
153:
154: int ariaprobe();
155: void ariaattach(struct device *, struct device *, void *);
156: void ariaclose(void *);
157: int ariaopen(dev_t, int);
158: int aria_getdev(void *, struct audio_device *);
159:
160: void aria_do_kludge(u_short, u_short, u_short, u_short, u_short);
161: void aria_prometheus_kludge(struct isa_attach_args *);
162:
163: int aria_set_sr(void *, u_long);
164: u_long aria_get_sr(void *);
165: int aria_query_encoding(void *, struct audio_encoding *);
166: int aria_set_format(void *, u_int, u_int);
167: int aria_get_encoding(void *);
168: int aria_get_precision(void *);
169: int aria_set_channels(void *, int);
170: int aria_get_channels(void *);
171: int aria_round_blocksize(void *, int);
172: int aria_set_out_port(void *, int);
173: int aria_get_out_port(void *);
174: int aria_set_in_port(void *, int);
175: int aria_get_in_port(void *);
176: int aria_speaker_ctl(void *, int);
177: int aria_commit_settings(void *);
178:
179: int aria_start_output(void *, void *, int, void (*)(), void *);
180: int aria_start_input(void *, void *, int, void (*)(), void *);
181:
182: int aria_halt_input(void *);
183: int aria_halt_output(void *);
184: int aria_cont(void *);
185:
186: int aria_sendcmd(u_short, u_short, int, int, int);
187:
188: u_short aria_getdspmem(u_short, u_short);
189: u_short aria_putdspmem(u_short, u_short, u_short);
190:
191: int aria_intr(void *);
192: short ariaversion(struct aria_softc *);
193:
194: int aria_setfd(void *, int);
195:
196: void aria_mix_write(struct aria_softc *, int, int);
197: int aria_mix_read(struct aria_softc *, int);
198:
199: int aria_mixer_set_port(void *, mixer_ctrl_t *);
200: int aria_mixer_get_port(void *, mixer_ctrl_t *);
201: int aria_mixer_query_devinfo(void *, mixer_devinfo_t *);
202:
203: /*
204: * Mixer defines...
205: */
206:
207: struct cfattach aria_ca = {
208: sizeof(struct aria_softc), ariaprobe, ariaattach
209: };
210:
211: struct cfdriver aria_cd = {
212: NULL, "aria", DV_DULL
213: };
214:
215: struct audio_device aria_device = {
216: "Aria 16(se)",
217: "x",
218: "aria"
219: };
220:
221: /*
222: * Define our interface to the higher level audio driver.
223: */
224:
225: struct audio_hw_if aria_hw_if = {
226: ariaopen,
227: ariaclose,
228: NULL,
229: aria_set_sr,
230: aria_get_sr,
231: aria_set_sr,
232: aria_get_sr,
233: aria_query_encoding,
234: aria_set_format,
235: aria_get_encoding,
236: aria_get_precision,
237: aria_set_channels,
238: aria_get_channels,
239: aria_round_blocksize,
240: aria_set_out_port,
241: aria_get_out_port,
242: aria_set_in_port,
243: aria_get_in_port,
244: aria_commit_settings,
245: mulaw_expand,
246: mulaw_compress,
247: aria_start_output,
248: aria_start_input,
249: aria_halt_input,
250: aria_halt_output,
251: aria_cont,
252: aria_cont,
253: aria_speaker_ctl,
254: aria_getdev,
255: aria_setfd,
256: aria_mixer_set_port,
257: aria_mixer_get_port,
258: aria_mixer_query_devinfo,
259: 1, /* full-duplex */
260: 0,
261: NULL,
262: NULL
263: };
264:
265: /*
266: * Probe / attach routines.
267: */
268:
269: /*
270: * Probe for the aria hardware.
271: */
272: int
273: ariaprobe(parent, self, aux)
274: struct device *parent, *self;
275: void *aux;
276: {
277: register struct aria_softc *sc = (void *)self;
278: register struct isa_attach_args *ia = aux;
279: struct cfdata *cf = sc->sc_dev.dv_cfdata;
280: register u_short iobase = ia->ia_iobase;
281: static u_char irq_conf[11] = {
282: -1, -1, 0x01, -1, -1, 0x02, -1, 0x04, -1, 0x01, 0x08
283: };
284: int i,j;
285: int flags = cf->cf_flags;
286:
287: if (!ARIA_BASE_VALID(ia->ia_iobase)) {
288: printf("aria: configured iobase %d invalid\n", ia->ia_iobase);
289: return 0;
290: }
291: sc->sc_iobase = iobase;
292:
293: if (!ARIA_IRQ_VALID(ia->ia_irq)) {
294: printf("aria: configured irq %d invalid\n", ia->ia_irq);
295: return 0;
296: }
297:
298: sc->sc_irq = ia->ia_irq;
299:
300: if (flags & ARIAR_PROMETHEUS_KLUDGE)
301: aria_prometheus_kludge(ia);
302:
303: if (aria_reset(sc) != 0) {
304: DPRINTF(("aria: aria probe failed\n"));
305: return 0;
306: }
307:
308: ia->ia_iosize = ARIADSP_NPORT;
309: return 1;
310: }
311:
312:
313:
314: /*
315: * I didn't call this a kludge for
316: * nothing. This is cribbed from
317: * ariainit, the author of that
318: * disassembled some code to discover
319: * how to set up the initial values of
320: * the card. Without this, the card
321: * is dead. (It will not respond to _any_
322: * input at all.)
323: *
324: * ariainit can be found (ftp) at:
325: * ftp://ftp.wi.leidenuniv.nl/pub/audio/aria/programming/contrib/ariainit.zip
326: * currently.
327: */
328:
329: void
330: aria_prometheus_kludge(ia)
331: register struct isa_attach_args *ia;
332: {
333: int i, j;
334: u_short end;
335: u_short rba = ia->ia_iobase;
336:
337: DPRINTF(("aria_prometheus_kludge\n"));
338:
339: /* Begin Config Sequence */
340:
341: outb(0x204, 0x4c);
342: outb(0x205, 0x42);
343: outb(0x206, 0x00);
344: outw(0x200, 0x0f);
345: outb(0x201, 0x00);
346: outw(0x200, 0x02);
347: outb(0x201, rba>>2);
348:
349: /* These next three lines set up the iobase, and the irq; and disable the drq. */
350:
351: aria_do_kludge(0x111, ((ia->ia_iobase-0x280)>>2)+0xA0, 0xbf, 0xa0, rba);
352: aria_do_kludge(0x011, ia->ia_irq-6, 0xf8, 0x00, rba);
353: aria_do_kludge(0x011, 0x00, 0xef, 0x00, rba);
354:
355: /* The rest of these lines just disable everything else */
356:
357: aria_do_kludge(0x113, 0x00, 0x88, 0x00, rba);
358: aria_do_kludge(0x013, 0x00, 0xf8, 0x00, rba);
359: aria_do_kludge(0x013, 0x00, 0xef, 0x00, rba);
360: aria_do_kludge(0x117, 0x00, 0x88, 0x00, rba);
361: aria_do_kludge(0x017, 0x00, 0xff, 0x00, rba);
362:
363: /* End Sequence */
364:
365: outb(0x200, 0x0f);
366: end = inb(rba);
367: outw(0x200, 0x0f);
368: outb(0x201, end|0x80);
369: inb(0x200);
370: /*
371: * This delay is necessary for some reason,
372: * at least it would crash, and sometimes not
373: * probe properly if it did not exist.
374: */
375: delay(1000000);
376: }
377:
378: void
379: aria_do_kludge(func, bits, and, or, rba)
380: u_short func;
381: u_short bits;
382: u_short and;
383: u_short or;
384: u_short rba;
385: {
386: u_int i;
387: if (func & 0x100) {
388: func &= ~0x100;
389: if (bits) {
390: outw(0x200, func-1);
391: outb(0x201, bits);
392: }
393: } else
394: or |= bits;
395:
396: outb(0x200, func);
397: i = inb(rba);
398: outw(0x200, func);
399: outb(0x201, (i&and) | or);
400: }
401:
402: /*
403: * Attach hardware to driver, attach hardware driver to audio
404: * pseudo-device driver.
405: */
406: void
407: ariaattach(parent, self, aux)
408: struct device *parent, *self;
409: void *aux;
410: {
411: register struct aria_softc *sc = (struct aria_softc *)self;
412: struct isa_attach_args *ia = (struct isa_attach_args *)aux;
413: register u_short iobase = ia->ia_iobase;
414: register u_short i;
415: int err;
416:
417: sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
418: IPL_AUDIO, aria_intr, sc, sc->sc_dev.dv_xname);
419:
420: i = aria_getdspmem(iobase, ARIAA_HARDWARE_A);
421:
422: sc->sc_hardware = 0;
423: sc->sc_hardware |= ((i>>13)&0x01==1)?ARIA_TELEPHONE:0;
424: sc->sc_hardware |= (((i>>5)&0x07)==0x04)?ARIA_MIXER:0;
425: sc->sc_hardware |= (aria_getdspmem(iobase, ARIAA_MODEL_A)==1)?ARIA_MODEL:0;
426:
427: sc->sc_open = 0;
428: sc->sc_play = 0;
429: sc->sc_record = 0;
430: sc->sc_rate = 7875;
431: sc->sc_chans = 1;
432: sc->sc_change = 1;
433: sc->sc_blocksize = 1024;
434: sc->sc_precision = 8;
435: sc->sc_rintr = 0;
436: sc->sc_rarg = 0;
437: sc->sc_pintr = 0;
438: sc->sc_parg = 0;
439: sc->gain[0] = 127;
440: sc->gain[1] = 127;
441:
442: for (i=0; i<6; i++) {
443: if (i == ARIAMIX_TEL_LVL)
444: sc->aria_mix[i].num_channels = 1;
445: else
446: sc->aria_mix[i].num_channels = 2;
447: sc->aria_mix[i].level[0] = 127;
448: sc->aria_mix[i].level[1] = 127;
449: }
450:
451: sc->ariamix_master.num_channels = 2;
452: sc->ariamix_master.level[0] = 222;
453: sc->ariamix_master.level[1] = 222;
454: sc->ariamix_master.bass[0] = 127;
455: sc->ariamix_master.bass[1] = 127;
456: sc->ariamix_master.treble[0] = 127;
457: sc->ariamix_master.treble[1] = 127;
458: sc->aria_mix_source = 0;
459:
460: sc->sc_change = 1;
461: aria_commit_settings(sc); /* so that my cdplayer is at the 'right' vol */
462:
463: printf(": dsp %s", (ARIA_MODEL&sc->sc_hardware)?"SC18026":"SC18025");
464: if (ARIA_TELEPHONE&sc->sc_hardware)
465: printf(", tel");
466: if (ARIA_MIXER&sc->sc_hardware)
467: printf(", SC18075 mixer");
468: printf("\n");
469:
470: snprintf(aria_device.version, sizeof aria_device.version, "%s",
471: (ARIA_MODEL&sc->sc_hardware?"SC18026":"SC18025"));
472:
473: if ((err = audio_hardware_attach(&aria_hw_if, sc)) != 0)
474: printf("aria: could not attach to audio pseudo-device driver (%d)\n", err);
475: }
476:
477: /*
478: * Various routines to interface to higher level audio driver
479: */
480:
481: int
482: ariaopen(dev, flags)
483: dev_t dev;
484: int flags;
485: {
486: struct aria_softc *sc;
487: register u_short iobase = sc->sc_iobase;
488: int unit = AUDIOUNIT(dev);
489: short err;
490:
491: DPRINTF(("ariaopen() called\n"));
492:
493: if (unit >= aria_cd.cd_ndevs)
494: return ENXIO;
495:
496: sc = aria_cd.cd_devs[unit];
497:
498: if (!sc || sc->sc_open != 0)
499: return ENXIO;
500:
501: sc->sc_open = 0;
502: if (flags&FREAD)
503: sc->sc_open |= ARIAR_OPEN_RECORD;
504: if (flags&FWRITE)
505: sc->sc_open |= ARIAR_OPEN_PLAY;
506: sc->sc_play = 0;
507: sc->sc_record= 0;
508: sc->sc_rintr = 0;
509: sc->sc_rarg = 0;
510: sc->sc_pintr = 0;
511: sc->sc_parg = 0;
512: sc->sc_change= 1;
513:
514: return 0;
515: }
516:
517: int
518: aria_getdev(addr, retp)
519: void *addr;
520: struct audio_device *retp;
521: {
522: *retp = aria_device;
523: return 0;
524: }
525:
526: #ifdef AUDIO_DEBUG
527: void
528: aria_printsc(struct aria_softc *sc)
529: {
530: printf("open %x dmachan %d irq %d iobase %x nintr %d\n", sc->sc_open, sc->sc_drq,
531: sc->sc_irq, sc->sc_iobase, sc->sc_interrupts);
532: printf("irate %d encoding %x chans %d\n", sc->sc_rate, sc->encoding,
533: sc->sc_chans);
534: printf("\n");
535: }
536: #endif
537:
538:
539: /*
540: * Various routines to interface to higher level audio driver
541: */
542:
543: int
544: aria_set_sr(addr, sr)
545: void *addr;
546: u_long sr;
547: {
548: struct aria_softc *sc = addr;
549:
550: if (sr<=9000)
551: sr = 7875;
552: else if (sr<=15000)
553: sr = 11025;
554: else if (sr<=20000)
555: sr = 15750;
556: else if (sr<=25000)
557: sr = 22050;
558: else if (sr<=40000)
559: sr = 31500;
560: else
561: sr = 44100;
562:
563: sc->sc_rate = sr;
564: return 0;
565: }
566:
567: u_long
568: aria_get_sr(addr)
569: void *addr;
570: {
571: struct aria_softc *sc = addr;
572: return sc->sc_rate;
573: }
574:
575: int
576: aria_query_encoding(addr, fp)
577: void *addr;
578: struct audio_encoding *fp;
579: {
580: register struct aria_softc *sc = addr;
581:
582: switch (fp->index) {
583: case 0:
584: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
585: fp->format_id = AUDIO_ENCODING_ULAW;
586: break;
587: case 1:
588: strlcpy(fp->name, AudioEpcm16, sizeof fp->name);
589: fp->format_id = AUDIO_ENCODING_PCM16;
590: break;
591: default:
592: return(EINVAL);
593: /*NOTREACHED*/
594: }
595:
596: return (0);
597: }
598:
599: int
600: aria_set_format(addr, enc, precision)
601: void *addr;
602: u_int enc, prec;
603: {
604: register struct aria_softc *sc = addr;
605:
606: DPRINTF(("aria_set_format\n"));
607:
608: switch(enc){
609: case AUDIO_ENCODING_ULAW:
610: case AUDIO_ENCODING_PCM16:
611: case AUDIO_ENCODING_PCM8:
612: break;
613: default:
614: return (EINVAL);
615: }
616:
617: if (prec!=8 && prec!=16)
618: return (EINVAL);
619:
620: if (sc->encoding!=AUDIO_ENCODING_PCM16 && prec==16)
621: return (EINVAL);
622:
623: sc->sc_encoding = enc;
624: sc->sc_precision = prec;
625: return (0);
626: }
627:
628: int
629: aria_get_encoding(addr)
630: void *addr;
631: {
632: register struct aria_softc *sc = addr;
633:
634: DPRINTF(("aria_get_encoding\n"));
635:
636: return(sc->encoding);
637: }
638:
639: int
640: aria_get_precision(addr)
641: void *addr;
642: {
643: struct aria_softc *sc = addr;
644:
645: DPRINTF(("aria_get_precision\n"));
646:
647: return sc->sc_precision;
648: }
649:
650: int
651: aria_set_channels(addr, chans)
652: void *addr;
653: int chans;
654: {
655: struct aria_softc *sc = addr;
656:
657: DPRINTF(("aria_set_channels\n"));
658:
659: if (chans != 1 && chans != 2)
660: return EINVAL;
661:
662: sc->sc_chans = chans;
663:
664: return(0);
665: }
666:
667: int
668: aria_get_channels(addr)
669: void *addr;
670: {
671: struct aria_softc *sc = addr;
672:
673: DPRINTF(("aria_get_channels\n"));
674:
675: return sc->sc_chans;
676: }
677:
678: /*
679: * There is only one way to output on
680: * this card.
681: */
682: int
683: aria_set_out_port(addr, port)
684: void *addr;
685: int port;
686: {
687: DPRINTF(("aria_set_out_port\n"));
688: return(0);
689: }
690:
691: int
692: aria_get_out_port(addr)
693: void *addr;
694: {
695: DPRINTF(("aria_get_out_port\n"));
696: return(ARIAMIX_OUT_LVL);
697: }
698:
699:
700: int
701: aria_set_in_port(addr, port)
702: void *addr;
703: int port;
704: {
705: register struct aria_softc *sc = addr;
706:
707: DPRINTF(("aria_set_in_port\n"));
708:
709: if (port<0 || port>6)
710: return ENXIO;
711:
712: sc->aria_mix_source = port;
713: return(0);
714: }
715:
716: int
717: aria_get_in_port(addr)
718: void *addr;
719: {
720: register struct aria_softc *sc = addr;
721:
722: DPRINTF(("aria_get_in_port\n"));
723:
724: return(sc->aria_mix_source);
725: }
726:
727: /*
728: * XXX -- to be done
729: * I should probably just add a mixer thing, and
730: * access it through here.
731: */
732: int
733: aria_speaker_ctl(addr, newstate)
734: void *addr;
735: int newstate;
736: {
737: return(0);
738: }
739:
740: /*
741: * Store blocksize in words (what the chipset
742: * understands), but report and take values
743: * in bytes.
744: */
745:
746: int
747: aria_round_blocksize(addr, blk)
748: void *addr;
749: int blk;
750: {
751: int i;
752: struct aria_softc *sc = addr;
753: for (i=64; i<1024; i*=2)
754: if (blk <= i)
755: break;
756: sc->sc_blocksize = i;
757: sc->sc_change = 1;
758: return(i);
759: }
760:
761: /*
762: * This is where all of the twiddling goes on.
763: */
764:
765: int
766: aria_commit_settings(addr)
767: void *addr;
768: {
769: struct aria_softc *sc = addr;
770: register u_short iobase = sc->sc_iobase;
771: u_char tones[16] = { 7, 6, 5, 4, 3, 2, 1, 0, 8, 9, 10, 11, 12, 13, 14, 15 };
772: u_short format;
773: u_short left, right;
774: u_short samp;
775: u_char i;
776:
777: DPRINTF(("aria_commit_settings\n"));
778:
779: switch (sc->sc_rate) {
780: case 7875: format = 0x00; samp = 0x60; break;
781: case 11025: format = 0x00; samp = 0x40; break;
782: case 15750: format = 0x10; samp = 0x60; break;
783: case 22050: format = 0x10; samp = 0x40; break;
784: case 31500: format = 0x10; samp = 0x20; break;
785: case 44100: format = 0x20; samp = 0x00; break;
786: default: format = 0x00; samp = 0x40; break;
787: }
788:
789: format |= (sc->sc_chans==2)?1:0;
790: format |= (sc->sc_precision==16)?2:0;
791:
792: aria_sendcmd(iobase, ARIADSPC_FORMAT, format, -1, -1);
793: outw(iobase+ARIADSP_CONTROL, (inw(iobase+ARIADSP_STATUS)&~0x60)|samp); /* Addition parm for sample rate */
794:
795: if (sc->sc_hardware&ARIA_MIXER) {
796: for (i=0; i<6; i++) {
797: u_char source;
798: switch(i) {
799: case ARIAMIX_MIC_LVL: source = 0x0001; break;
800: case ARIAMIX_CD_LVL: source = 0x0002; break;
801: case ARIAMIX_LINE_IN_LVL: source = 0x0008; break;
802: case ARIAMIX_TEL_LVL: source = 0x0020; break;
803: case ARIAMIX_AUX_LVL: source = 0x0010; break;
804: case ARIAMIX_DAC_LVL: source = 0x0004; break;
805: default: source = 0x0000; break;
806: }
807:
808: if (source != 0x0000 && source != 0x0004) {
809: if (sc->aria_mix[i].mute == 1)
810: aria_sendcmd(iobase, ARIADSPC_INPMONMODE, source, 3, -1);
811: else
812: aria_sendcmd(iobase, ARIADSPC_INPMONMODE, source, (sc->aria_mix[i].num_channels==2)?0:1, -1);
813:
814: aria_sendcmd(iobase, ARIADSPC_INPMONMODE, 0x8000|source, (sc->aria_mix[i].num_channels==2)?0:1, -1);
815: aria_sendcmd(iobase, ARIADSPC_MIXERVOL, source, sc->aria_mix[i].level[0] << 7, sc->aria_mix[i].level[1] << 7);
816: }
817:
818: if (sc->aria_mix_source == i) {
819: aria_sendcmd(iobase, ARIADSPC_ADCSOURCE, source, -1, -1);
820:
821: if (sc->sc_open & ARIAR_OPEN_RECORD)
822: aria_sendcmd(iobase, ARIADSPC_ADCCONTROL, 1, -1, -1);
823: else
824: aria_sendcmd(iobase, ARIADSPC_ADCCONTROL, 0, -1, -1);
825: }
826: }
827:
828: if (sc->sc_chans==2) {
829: aria_sendcmd(iobase, ARIADSPC_CHAN_VOL, (sc->gain[0]+sc->gain[1])/2, -1, -1);
830: aria_sendcmd(iobase, ARIADSPC_CHAN_PAN, (sc->gain[0]-sc->gain[1])/4+0x40, -1, -1);
831: } else {
832: aria_sendcmd(iobase, ARIADSPC_CHAN_VOL, sc->gain[0], -1, -1);
833: aria_sendcmd(iobase, ARIADSPC_CHAN_PAN, 0x40, -1, -1);
834: }
835:
836: /* aria_sendcmd(iobase, ARIADSPC_MASMONMODE, (sc->ariamix_master.num_channels==2)?0:1 | (1<<8), -1, -1); */
837: aria_sendcmd(iobase, ARIADSPC_MASMONMODE, (sc->ariamix_master.num_channels==2)?0:1, -1, -1);
838:
839: aria_sendcmd(iobase, ARIADSPC_MIXERVOL, 0x0004, sc->ariamix_master.level[0] << 7, sc->ariamix_master.level[1] << 7);
840:
841: /* Convert treb/bass from byte to soundcard style */
842:
843: left = tones[(sc->ariamix_master.bass[0]>>4)&0x0f]<<8 | tones[(sc->ariamix_master.treble[0]>>4)&0x0f];
844: right = tones[(sc->ariamix_master.bass[1]>>4)&0x0f]<<8 | tones[(sc->ariamix_master.treble[1]>>4)&0x0f];
845:
846: aria_sendcmd(iobase, ARIADSPC_TONE, left, right, -1);
847: }
848:
849: if (sc->sc_change != 0)
850: aria_sendcmd(iobase, ARIADSPC_BLOCKSIZE, sc->sc_blocksize/2, -1, -1);
851:
852: /*
853: * If we think that the card is recording or playing, start it up again here.
854: * Some of the previous commands turn the channels off.
855: */
856:
857: if (sc->sc_record&(1<<ARIAR_RECORD_CHAN)) {
858: aria_sendcmd(iobase, ARIADSPC_START_REC, ARIAR_PLAY_CHAN, -1, -1);
859: sc->sc_play |= (1<<ARIAR_RECORD_CHAN);
860: }
861:
862: if (sc->sc_play&(1<<ARIAR_PLAY_CHAN)) {
863: aria_sendcmd(iobase, ARIADSPC_START_PLAY, ARIAR_PLAY_CHAN, -1, -1);
864: sc->sc_play |= (1<<ARIAR_PLAY_CHAN);
865: }
866:
867: sc->sc_change = 0;
868:
869: return(0);
870: }
871:
872: void
873: ariaclose(addr)
874: void *addr;
875: {
876: struct aria_softc *sc = addr;
877: register u_int iobase = sc->sc_iobase;
878:
879: DPRINTF(("aria_close sc=0x%x\n", sc));
880:
881: sc->spkr_state = SPKR_OFF;
882: sc->sc_rintr = 0;
883: sc->sc_pintr = 0;
884: sc->sc_rdiobuffer = 0;
885: sc->sc_pdiobuffer = 0;
886:
887: if (sc->sc_play&(1<<ARIAR_PLAY_CHAN) && sc->sc_open & ARIAR_OPEN_PLAY) {
888: aria_sendcmd(iobase, ARIADSPC_STOP_PLAY, ARIAR_PLAY_CHAN, -1, -1);
889: sc->sc_play &= ~(1<<ARIAR_PLAY_CHAN);
890: }
891:
892: if (sc->sc_record&(1<<ARIAR_RECORD_CHAN) && sc->sc_open & ARIAR_OPEN_RECORD) {
893: aria_sendcmd(iobase, ARIADSPC_STOP_REC, ARIAR_RECORD_CHAN, -1, -1);
894: sc->sc_record &= ~(1<<ARIAR_RECORD_CHAN);
895: }
896:
897: sc->sc_open = 0;
898:
899: if (aria_reset(sc) != 0) {
900: delay(500);
901: aria_reset(sc);
902: }
903: }
904:
905: /*
906: * Reset the hardware.
907: */
908:
909: int
910: aria_reset(sc)
911: register struct aria_softc *sc;
912: {
913: register u_short iobase = sc->sc_iobase;
914: int fail=0;
915:
916: outw(iobase + ARIADSP_CONTROL, ARIAR_ARIA_SYNTH|ARIAR_SR22K|ARIAR_DSPINTWR);
917: aria_putdspmem(iobase, 0x6102, 0);
918:
919: fail |= aria_sendcmd(iobase, ARIADSPC_SYSINIT, 0x0000, 0x0000, 0x0000);
920:
921: while (aria_getdspmem(iobase, ARIAA_TASK_A) != 1)
922: ;
923:
924: outw(iobase+ARIADSP_CONTROL, ARIAR_ARIA_SYNTH|ARIAR_SR22K|ARIAR_DSPINTWR|ARIAR_PCINTWR);
925: fail |= aria_sendcmd(iobase, ARIADSPC_MODE, ARIAV_MODE_NO_SYNTH,-1,-1);
926:
927: return (fail);
928: }
929:
930: /*
931: * Lower-level routines
932: */
933:
934: u_short
935: aria_putdspmem(iobase, loc, val)
936: register u_short iobase;
937: register u_short loc;
938: register u_short val;
939: {
940: outw(iobase + ARIADSP_DMAADDRESS, loc);
941: outw(iobase + ARIADSP_DMADATA, val);
942: }
943:
944: u_short
945: aria_getdspmem(iobase, loc)
946: register u_short iobase;
947: register u_short loc;
948: {
949: outw(iobase+ARIADSP_DMAADDRESS, loc);
950: return inw(iobase+ARIADSP_DMADATA);
951: }
952:
953: /*
954: * aria_sendcmd()
955: * each full DSP command is unified into this
956: * function.
957: */
958:
959: int
960: aria_sendcmd(iobase, command, arg1, arg2, arg3)
961: u_short iobase;
962: u_short command;
963: int arg1;
964: int arg2;
965: int arg3;
966: {
967: int i, fail = 0;
968:
969: for (i = ARIAR_NPOLL; (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY) != 0 && i>0; i-- )
970: ;
971:
972: fail |= (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY)==0?0:1;
973: outw(iobase + ARIADSP_WRITE, (u_short) command);
974:
975: if (arg1 != -1) {
976: for (i = ARIAR_NPOLL; (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY) != 0 && i>0; i-- )
977: ;
978:
979: fail |= (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY)==0?0:2;
980: outw(iobase + ARIADSP_WRITE, (u_short) arg1);
981: }
982:
983: if (arg2 != -1) {
984: for (i = ARIAR_NPOLL; (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY) != 0 && i>0; i-- )
985: ;
986:
987: fail |= (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY)==0?0:4;
988: outw(iobase + ARIADSP_WRITE, (u_short) arg2);
989: }
990:
991: if (arg3 != -1) {
992: for (i = ARIAR_NPOLL; (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY) != 0 && i>0; i-- )
993: ;
994:
995: fail |= (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY)==0?0:8;
996: outw(iobase + ARIADSP_WRITE, (u_short) arg3);
997: }
998:
999: for (i = ARIAR_NPOLL; (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY) != 0 && i>0; i-- )
1000: ;
1001:
1002: fail |= (inw(iobase + ARIADSP_STATUS) & ARIAR_BUSY)==0?0:16;
1003: outw(iobase + ARIADSP_WRITE, (u_short) ARIADSPC_TERM);
1004:
1005: #ifdef AUDIO_DEBUG
1006: if (fail) {
1007: ++ariaerr.sendcmd;
1008: DPRINTF(("aria_sendcmd: failure=(%d) cmd=(0x%x) fail=(0x%x)\n", ariaerr.sendcmd, command, fail));
1009: return -1;
1010: }
1011: #else
1012: if (fail != 0) {
1013: ++ariaerr.sendcmd;
1014: return -1;
1015: }
1016: #endif
1017:
1018: return 0;
1019: }
1020:
1021: int
1022: aria_halt_input(addr)
1023: void *addr;
1024: {
1025: register struct aria_softc *sc = addr;
1026:
1027: DPRINTF(("aria_halt_input\n"));
1028:
1029: if (sc->sc_record&(1<<0)) {
1030: aria_sendcmd(sc->sc_iobase, ARIADSPC_STOP_REC, 0, -1, -1);
1031: sc->sc_record &= ~(1<<0);
1032: }
1033:
1034: return(0);
1035: }
1036:
1037: int
1038: aria_halt_output(addr)
1039: void *addr;
1040: {
1041: register struct aria_softc *sc = addr;
1042:
1043: DPRINTF(("aria_halt_output\n"));
1044:
1045: if (sc->sc_play & (1<<1)) {
1046: aria_sendcmd(sc->sc_iobase, ARIADSPC_STOP_PLAY, 1, -1, -1);
1047: sc->sc_play &= ~(1<<1);
1048: }
1049:
1050: return(0);
1051: }
1052:
1053: /*
1054: * This is not called in dev/audio.c?
1055: */
1056: int
1057: aria_cont(addr)
1058: void *addr;
1059: {
1060: register struct aria_softc *sc = addr;
1061:
1062: DPRINTF(("aria_cont\n"));
1063:
1064: if (!(sc->sc_record&(1<<0)) && (sc->sc_open&ARIAR_OPEN_RECORD)) {
1065: aria_sendcmd(sc->sc_iobase, ARIADSPC_START_REC, ARIAR_RECORD_CHAN, -1, -1);
1066: sc->sc_record |= ~(1<<ARIAR_RECORD_CHAN);
1067: }
1068:
1069: if (!(sc->sc_play&(1<<ARIAR_PLAY_CHAN)) && (sc->sc_open&ARIAR_OPEN_PLAY)) {
1070: aria_sendcmd(sc->sc_iobase, ARIADSPC_START_PLAY, 1, -1, -1);
1071: sc->sc_play |= ~(1<<ARIAR_PLAY_CHAN);
1072: }
1073:
1074: return(0);
1075: }
1076:
1077: /*
1078: * Here we just set up the buffers. If we receive
1079: * an interrupt without these set, it is ignored.
1080: */
1081:
1082: int
1083: aria_start_input(addr, p, cc, intr, arg)
1084: void *addr;
1085: void *p;
1086: int cc;
1087: void (*intr)();
1088: void *arg;
1089: {
1090: register struct aria_softc *sc = addr;
1091: register int i;
1092:
1093: DPRINTF(("aria_start_input %d @ %x\n", cc, p));
1094:
1095: if (cc != sc->sc_blocksize) {
1096: DPRINTF(("aria_start_input reqsize %d not sc_blocksize %d\n",
1097: cc, sc->sc_blocksize));
1098: return EINVAL;
1099: }
1100:
1101: sc->sc_rarg = arg;
1102: sc->sc_rintr = intr;
1103: sc->sc_rdiobuffer = p;
1104:
1105: if (!(sc->sc_record&(1<<0))) {
1106: aria_sendcmd(sc->sc_iobase, ARIADSPC_START_REC, 0, -1, -1);
1107: sc->sc_record |= (1<<0);
1108: }
1109:
1110: return 0;
1111: }
1112:
1113: int
1114: aria_start_output(addr, p, cc, intr, arg)
1115: void *addr;
1116: void *p;
1117: int cc;
1118: void (*intr)();
1119: void *arg;
1120: {
1121: register struct aria_softc *sc = addr;
1122: register int i;
1123:
1124: DPRINTF(("aria_start_output %d @ %x\n", cc, p));
1125:
1126: if (cc != sc->sc_blocksize) {
1127: DPRINTF(("aria_start_output reqsize %d not sc_blocksize %d\n",
1128: cc, sc->sc_blocksize));
1129: return EINVAL;
1130: }
1131:
1132: sc->sc_parg = arg;
1133: sc->sc_pintr = intr;
1134: sc->sc_pdiobuffer = p;
1135:
1136: if (!(sc->sc_play&(1<<1))) {
1137: aria_sendcmd(sc->sc_iobase, ARIADSPC_START_PLAY, 1, -1, -1);
1138: sc->sc_play |= (1<<1);
1139: }
1140:
1141: return 0;
1142: }
1143:
1144: /*
1145: * Process an interrupt. This should be a
1146: * request (from the card) to write or read
1147: * samples.
1148: */
1149: int
1150: aria_intr(arg)
1151: void *arg;
1152: {
1153: register struct aria_softc *sc = arg;
1154: register u_short iobase = sc->sc_iobase;
1155: register u_short *pdata = sc->sc_pdiobuffer;
1156: register u_short *rdata = sc->sc_rdiobuffer;
1157: u_short address;
1158: int i;
1159:
1160: if (inw(iobase) & 1 != 0x1)
1161: return 0; /* not for us */
1162:
1163: sc->sc_interrupts++;
1164:
1165: DPRINTF(("aria_intr\n"));
1166:
1167: if ((sc->sc_open & ARIAR_OPEN_PLAY) && (pdata!=NULL)) {
1168: DPRINTF(("aria_intr play=(%x)\n", pdata));
1169: address = 0x8000 - 2*(sc->sc_blocksize);
1170: address+= aria_getdspmem(iobase, ARIAA_PLAY_FIFO_A);
1171: outw(iobase+ARIADSP_DMAADDRESS, address);
1172: outsw(iobase + ARIADSP_DMADATA, pdata, sc->sc_blocksize/2);
1173: if (sc->sc_pintr != NULL)
1174: (*sc->sc_pintr)(sc->sc_parg);
1175: }
1176:
1177: if ((sc->sc_open & ARIAR_OPEN_RECORD) && (rdata!=NULL)) {
1178: DPRINTF(("aria_intr record=(%x)\n", rdata));
1179: address = 0x8000 - (sc->sc_blocksize);
1180: address+= aria_getdspmem(iobase, ARIAA_REC_FIFO_A);
1181: outw(iobase+ARIADSP_DMAADDRESS, address);
1182: insw(iobase + ARIADSP_DMADATA, rdata, sc->sc_blocksize/2);
1183: if (sc->sc_rintr != NULL)
1184: (*sc->sc_rintr)(sc->sc_rarg);
1185: }
1186:
1187: aria_sendcmd(iobase, ARIADSPC_TRANSCOMPLETE, -1, -1, -1);
1188:
1189: return 1;
1190: }
1191:
1192: int
1193: aria_setfd(addr, flag)
1194: void *addr;
1195: int flag;
1196: {
1197: /*
1198: * okay return yes. I'll assume that it will only
1199: * ask when the file open read/write... Or before...
1200: */
1201: return(0);
1202: }
1203:
1204: int
1205: aria_mixer_set_port(addr, cp)
1206: void *addr;
1207: mixer_ctrl_t *cp;
1208: {
1209: register struct aria_softc *sc = addr;
1210: int error = EINVAL;
1211:
1212: DPRINTF(("aria_mixer_set_port\n"));
1213:
1214: if (!(ARIA_MIXER&sc->sc_hardware)) /* This could be done better, no mixer still has some controls. */
1215: return ENXIO;
1216:
1217: if (cp->type == AUDIO_MIXER_VALUE) {
1218: register mixer_level_t *mv = &cp->un.value;
1219: switch (cp->dev) {
1220: case ARIAMIX_MIC_LVL:
1221: if (mv->num_channels == 1 || mv->num_channels == 2) {
1222: sc->aria_mix[ARIAMIX_MIC_LVL].num_channels = mv->num_channels;
1223: sc->aria_mix[ARIAMIX_MIC_LVL].level[0] = mv->level[0];
1224: sc->aria_mix[ARIAMIX_MIC_LVL].level[1] = mv->level[1];
1225: error = 0;
1226: }
1227: break;
1228:
1229: case ARIAMIX_LINE_IN_LVL:
1230: if (mv->num_channels == 1 || mv->num_channels == 2) {
1231: sc->aria_mix[ARIAMIX_LINE_IN_LVL].num_channels = mv->num_channels;
1232: sc->aria_mix[ARIAMIX_LINE_IN_LVL].level[0] = mv->level[0];
1233: sc->aria_mix[ARIAMIX_LINE_IN_LVL].level[1] = mv->level[1];
1234: error = 0;
1235: }
1236: break;
1237:
1238: case ARIAMIX_CD_LVL:
1239: if (mv->num_channels == 1 || mv->num_channels == 2) {
1240: sc->aria_mix[ARIAMIX_CD_LVL].num_channels = mv->num_channels;
1241: sc->aria_mix[ARIAMIX_CD_LVL].level[0] = mv->level[0];
1242: sc->aria_mix[ARIAMIX_CD_LVL].level[1] = mv->level[1];
1243: error = 0;
1244: }
1245: break;
1246:
1247: case ARIAMIX_TEL_LVL:
1248: if (mv->num_channels == 1) {
1249: sc->aria_mix[ARIAMIX_TEL_LVL].num_channels = mv->num_channels;
1250: sc->aria_mix[ARIAMIX_TEL_LVL].level[0] = mv->level[0];
1251: error = 0;
1252: }
1253: break;
1254:
1255: case ARIAMIX_DAC_LVL:
1256: if (mv->num_channels == 1 || mv->num_channels == 2) {
1257: sc->aria_mix[ARIAMIX_DAC_LVL].num_channels = mv->num_channels;
1258: sc->aria_mix[ARIAMIX_DAC_LVL].level[0] = mv->level[0];
1259: sc->aria_mix[ARIAMIX_DAC_LVL].level[1] = mv->level[1];
1260: error = 0;
1261: }
1262: break;
1263:
1264: case ARIAMIX_AUX_LVL:
1265: if (mv->num_channels == 1 || mv->num_channels == 2) {
1266: sc->aria_mix[ARIAMIX_AUX_LVL].num_channels = mv->num_channels;
1267: sc->aria_mix[ARIAMIX_AUX_LVL].level[0] = mv->level[0];
1268: sc->aria_mix[ARIAMIX_AUX_LVL].level[1] = mv->level[1];
1269: error = 0;
1270: }
1271: break;
1272:
1273: case ARIAMIX_MASTER_LVL:
1274: if (mv->num_channels == 1 || mv->num_channels == 2) {
1275: sc->ariamix_master.num_channels = mv->num_channels;
1276: sc->ariamix_master.level[0] = mv->level[0];
1277: sc->ariamix_master.level[1] = mv->level[1];
1278: error = 0;
1279: }
1280: break;
1281:
1282: case ARIAMIX_MASTER_TREBLE:
1283: if (mv->num_channels == 2) {
1284: sc->ariamix_master.treble[0] = (mv->level[0]==0)?1:mv->level[0];
1285: sc->ariamix_master.treble[1] = (mv->level[1]==0)?1:mv->level[1];
1286: error = 0;
1287: }
1288: break;
1289: case ARIAMIX_MASTER_BASS:
1290: if (mv->num_channels == 2) {
1291: sc->ariamix_master.bass[0] = (mv->level[0]==0)?1:mv->level[0];
1292: sc->ariamix_master.bass[1] = (mv->level[1]==0)?1:mv->level[1];
1293: error = 0;
1294: }
1295: break;
1296: case ARIAMIX_OUT_LVL:
1297: if (mv->num_channels == 1 || mv->num_channels == 2) {
1298: sc->gain[0] = mv->level[0];
1299: sc->gain[1] = mv->level[1];
1300: error = 0;
1301: }
1302: break;
1303: default:
1304: }
1305: }
1306:
1307: if (cp->type == AUDIO_MIXER_ENUM)
1308: switch(cp->dev) {
1309: case ARIAMIX_RECORD_SOURCE:
1310: if (cp->un.ord>=0 && cp->un.ord<=6) {
1311: sc->aria_mix_source = cp->un.ord;
1312: error = 0;
1313: }
1314: break;
1315:
1316: case ARIAMIX_MIC_MUTE:
1317: if (cp->un.ord == 0 || cp->un.ord == 1) {
1318: sc->aria_mix[ARIAMIX_MIC_LVL].mute = cp->un.ord;
1319: error = 0;
1320: }
1321: break;
1322:
1323: case ARIAMIX_LINE_IN_MUTE:
1324: if (cp->un.ord == 0 || cp->un.ord == 1) {
1325: sc->aria_mix[ARIAMIX_LINE_IN_LVL].mute = cp->un.ord;
1326: error = 0;
1327: }
1328: break;
1329:
1330: case ARIAMIX_CD_MUTE:
1331: if (cp->un.ord == 0 || cp->un.ord == 1) {
1332: sc->aria_mix[ARIAMIX_CD_LVL].mute = cp->un.ord;
1333: error = 0;
1334: }
1335: break;
1336:
1337: case ARIAMIX_DAC_MUTE:
1338: if (cp->un.ord == 0 || cp->un.ord == 1) {
1339: sc->aria_mix[ARIAMIX_DAC_LVL].mute = cp->un.ord;
1340: error = 0;
1341: }
1342: break;
1343:
1344: case ARIAMIX_AUX_MUTE:
1345: if (cp->un.ord == 0 || cp->un.ord == 1) {
1346: sc->aria_mix[ARIAMIX_AUX_LVL].mute = cp->un.ord;
1347: error = 0;
1348: }
1349: break;
1350:
1351: case ARIAMIX_TEL_MUTE:
1352: if (cp->un.ord == 0 || cp->un.ord == 1) {
1353: sc->aria_mix[ARIAMIX_TEL_LVL].mute = cp->un.ord;
1354: error = 0;
1355: }
1356: break;
1357:
1358: default:
1359: return ENXIO;
1360: /* NOTREACHED */
1361: }
1362:
1363: return(error);
1364: }
1365:
1366: int
1367: aria_mixer_get_port(addr, cp)
1368: void *addr;
1369: mixer_ctrl_t *cp;
1370: {
1371: register struct aria_softc *sc = addr;
1372: int error = EINVAL;
1373:
1374: DPRINTF(("aria_mixer_get_port\n"));
1375:
1376: if (!(ARIA_MIXER&sc->sc_hardware)) /* This could be done better, no mixer still has some controls. */
1377: return ENXIO;
1378:
1379: switch (cp->dev) {
1380: case ARIAMIX_MIC_LVL:
1381: if (cp->type == AUDIO_MIXER_VALUE) {
1382: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_MIC_LVL].num_channels;
1383: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_MIC_LVL].level[0];
1384: cp->un.value.level[1] = sc->aria_mix[ARIAMIX_MIC_LVL].level[1];
1385: error = 0;
1386: }
1387: break;
1388:
1389: case ARIAMIX_LINE_IN_LVL:
1390: if (cp->type == AUDIO_MIXER_VALUE) {
1391: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_LINE_IN_LVL].num_channels;
1392: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_LINE_IN_LVL].level[0];
1393: cp->un.value.level[1] = sc->aria_mix[ARIAMIX_LINE_IN_LVL].level[1];
1394: error = 0;
1395: }
1396: break;
1397:
1398: case ARIAMIX_CD_LVL:
1399: if (cp->type == AUDIO_MIXER_VALUE) {
1400: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_CD_LVL].num_channels;
1401: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_CD_LVL].level[0];
1402: cp->un.value.level[1] = sc->aria_mix[ARIAMIX_CD_LVL].level[1];
1403: error = 0;
1404: }
1405: break;
1406:
1407: case ARIAMIX_TEL_LVL:
1408: if (cp->type == AUDIO_MIXER_VALUE) {
1409: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_TEL_LVL].num_channels;
1410: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_TEL_LVL].level[0];
1411: error = 0;
1412: }
1413: break;
1414: case ARIAMIX_DAC_LVL:
1415: if (cp->type == AUDIO_MIXER_VALUE) {
1416: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_DAC_LVL].num_channels;
1417: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_DAC_LVL].level[0];
1418: cp->un.value.level[1] = sc->aria_mix[ARIAMIX_DAC_LVL].level[1];
1419: error = 0;
1420: }
1421: break;
1422:
1423: case ARIAMIX_AUX_LVL:
1424: if (cp->type == AUDIO_MIXER_VALUE) {
1425: cp->un.value.num_channels = sc->aria_mix[ARIAMIX_AUX_LVL].num_channels;
1426: cp->un.value.level[0] = sc->aria_mix[ARIAMIX_AUX_LVL].level[0];
1427: cp->un.value.level[1] = sc->aria_mix[ARIAMIX_AUX_LVL].level[1];
1428: error = 0;
1429: }
1430: break;
1431:
1432: case ARIAMIX_MIC_MUTE:
1433: if (cp->type == AUDIO_MIXER_ENUM) {
1434: cp->un.ord = sc->aria_mix[ARIAMIX_MIC_LVL].mute;
1435: error = 0;
1436: }
1437: break;
1438:
1439: case ARIAMIX_LINE_IN_MUTE:
1440: if (cp->type == AUDIO_MIXER_ENUM) {
1441: cp->un.ord = sc->aria_mix[ARIAMIX_LINE_IN_LVL].mute;
1442: error = 0;
1443: }
1444: break;
1445:
1446: case ARIAMIX_CD_MUTE:
1447: if (cp->type == AUDIO_MIXER_ENUM) {
1448: cp->un.ord = sc->aria_mix[ARIAMIX_CD_LVL].mute;
1449: error = 0;
1450: }
1451: break;
1452:
1453: case ARIAMIX_DAC_MUTE:
1454: if (cp->type == AUDIO_MIXER_ENUM) {
1455: cp->un.ord = sc->aria_mix[ARIAMIX_DAC_LVL].mute;
1456: error = 0;
1457: }
1458: break;
1459:
1460: case ARIAMIX_AUX_MUTE:
1461: if (cp->type == AUDIO_MIXER_ENUM) {
1462: cp->un.ord = sc->aria_mix[ARIAMIX_AUX_LVL].mute;
1463: error = 0;
1464: }
1465: break;
1466:
1467: case ARIAMIX_TEL_MUTE:
1468: if (cp->type == AUDIO_MIXER_ENUM) {
1469: cp->un.ord = sc->aria_mix[ARIAMIX_TEL_LVL].mute;
1470: error = 0;
1471: }
1472: break;
1473:
1474: case ARIAMIX_MASTER_LVL:
1475: if (cp->type == AUDIO_MIXER_VALUE) {
1476: cp->un.value.num_channels = sc->ariamix_master.num_channels;
1477: cp->un.value.level[0] = sc->ariamix_master.level[0];
1478: cp->un.value.level[1] = sc->ariamix_master.level[1];
1479: error = 0;
1480: }
1481: break;
1482:
1483: case ARIAMIX_MASTER_TREBLE:
1484: if (cp->type == AUDIO_MIXER_VALUE) {
1485: cp->un.value.num_channels = 2;
1486: cp->un.value.level[0] = sc->ariamix_master.treble[0];
1487: cp->un.value.level[1] = sc->ariamix_master.treble[1];
1488: error = 0;
1489: }
1490: break;
1491:
1492: case ARIAMIX_MASTER_BASS:
1493: if (cp->type == AUDIO_MIXER_VALUE) {
1494: cp->un.value.num_channels = 2;
1495: cp->un.value.level[0] = sc->ariamix_master.bass[0];
1496: cp->un.value.level[1] = sc->ariamix_master.bass[1];
1497: error = 0;
1498: }
1499: break;
1500:
1501: case ARIAMIX_OUT_LVL:
1502: if (cp->type == AUDIO_MIXER_VALUE) {
1503: cp->un.value.num_channels = sc->sc_chans;
1504: cp->un.value.level[0] = sc->gain[0];
1505: cp->un.value.level[1] = sc->gain[1];
1506: error = 0;
1507: }
1508: break;
1509: case ARIAMIX_RECORD_SOURCE:
1510: if (cp->type == AUDIO_MIXER_ENUM) {
1511: cp->un.ord = sc->aria_mix_source;
1512: error = 0;
1513: }
1514: break;
1515:
1516: default:
1517: return ENXIO;
1518: /* NOT REACHED */
1519: }
1520:
1521: return(error);
1522: }
1523:
1524: int
1525: aria_mixer_query_devinfo(addr, dip)
1526: void *addr;
1527: register mixer_devinfo_t *dip;
1528: {
1529:
1530: register struct aria_softc *sc = addr;
1531:
1532: DPRINTF(("aria_mixer_query_devinfo\n"));
1533:
1534: if (!(ARIA_MIXER&sc->sc_hardware)) /* This could be done better, no mixer still has some controls. */
1535: return ENXIO;
1536:
1537: dip->prev = dip->next = AUDIO_MIXER_LAST;
1538:
1539: switch(dip->index) {
1540: case ARIAMIX_MIC_LVL:
1541: dip->type = AUDIO_MIXER_VALUE;
1542: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1543: dip->next = ARIAMIX_MIC_MUTE;
1544: strlcpy(dip->label.name, AudioNmicrophone,
1545: sizeof dip->label.name);
1546: dip->un.v.num_channels = 2;
1547: strlcpy(dip->un.v.units.name, AudioNvolume,
1548: sizeof dip->un.v.units.name);
1549: break;
1550:
1551: case ARIAMIX_LINE_IN_LVL:
1552: dip->type = AUDIO_MIXER_VALUE;
1553: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1554: dip->next = ARIAMIX_LINE_IN_MUTE;
1555: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
1556: dip->un.v.num_channels = 2;
1557: strlcpy(dip->un.v.units.name, AudioNvolume,
1558: sizeof dip->un.v.units.name);
1559: break;
1560:
1561: case ARIAMIX_CD_LVL:
1562: dip->type = AUDIO_MIXER_VALUE;
1563: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1564: dip->next = ARIAMIX_CD_MUTE;
1565: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
1566: dip->un.v.num_channels = 2;
1567: strlcpy(dip->un.v.units.name, AudioNvolume,
1568: sizeof dip->un.v.units.name);
1569: break;
1570:
1571: case ARIAMIX_TEL_LVL:
1572: dip->type = AUDIO_MIXER_VALUE;
1573: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1574: dip->next = ARIAMIX_TEL_MUTE;
1575: strlcpy(dip->label.name, "telephone", sizeof dip->label.name);
1576: dip->un.v.num_channels = 1;
1577: strlcpy(dip->un.v.units.name, AudioNvolume,
1578: sizeof dip->un.v.units.name);
1579: break;
1580:
1581: case ARIAMIX_DAC_LVL:
1582: dip->type = AUDIO_MIXER_VALUE;
1583: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1584: dip->next = ARIAMIX_DAC_MUTE;
1585: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
1586: dip->un.v.num_channels = 1;
1587: strlcpy(dip->un.v.units.name, AudioNvolume,
1588: sizeof dip->un.v.units.name);
1589: break;
1590:
1591: case ARIAMIX_AUX_LVL:
1592: dip->type = AUDIO_MIXER_VALUE;
1593: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1594: dip->next = ARIAMIX_AUX_MUTE;
1595: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
1596: dip->un.v.num_channels = 1;
1597: strlcpy(dip->un.v.units.name, AudioNvolume,
1598: sizeof dip->un.v.units.name);
1599: break;
1600:
1601: case ARIAMIX_MIC_MUTE:
1602: dip->prev = ARIAMIX_MIC_LVL;
1603: goto mode;
1604:
1605: case ARIAMIX_LINE_IN_MUTE:
1606: dip->prev = ARIAMIX_LINE_IN_LVL;
1607: goto mode;
1608:
1609: case ARIAMIX_CD_MUTE:
1610: dip->prev = ARIAMIX_CD_LVL;
1611: goto mode;
1612:
1613: case ARIAMIX_DAC_MUTE:
1614: dip->prev = ARIAMIX_DAC_LVL;
1615: goto mode;
1616:
1617: case ARIAMIX_AUX_MUTE:
1618: dip->prev = ARIAMIX_AUX_LVL;
1619: goto mode;
1620:
1621: case ARIAMIX_TEL_MUTE:
1622: dip->prev = ARIAMIX_TEL_LVL;
1623: goto mode;
1624:
1625: mode:
1626: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1627: dip->type = AUDIO_MIXER_ENUM;
1628: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
1629: dip->un.e.num_mem = 2;
1630: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
1631: sizeof dip->un.e.member[0].label.name);
1632: dip->un.e.member[0].ord = 0;
1633: strlcpy(dip->un.e.member[1].label.name, AudioNon,
1634: sizeof dip->un.e.member[0].label.name);
1635: dip->un.e.member[1].ord = 1;
1636: break;
1637:
1638: case ARIAMIX_MASTER_LVL:
1639: dip->type = AUDIO_MIXER_VALUE;
1640: dip->mixer_class = ARIAMIX_OUTPUT_CLASS;
1641: dip->next = ARIAMIX_MASTER_TREBLE;
1642: strlcpy(dip->label.name, AudioNvolume, sizeof dip->label.name);
1643: dip->un.v.num_channels = 2;
1644: strlcpy(dip->un.v.units.name, AudioNvolume,
1645: sizeof dip->un.v.units.name);
1646: break;
1647:
1648: case ARIAMIX_MASTER_TREBLE:
1649: dip->type = AUDIO_MIXER_VALUE;
1650: dip->mixer_class = ARIAMIX_OUTPUT_CLASS;
1651: dip->prev = ARIAMIX_MASTER_LVL;
1652: dip->next = ARIAMIX_MASTER_BASS;
1653: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1654: dip->un.v.num_channels = 2;
1655: strlcpy(dip->un.v.units.name, AudioNtreble,
1656: sizeof dip->un.v.units.name);
1657: break;
1658:
1659: case ARIAMIX_MASTER_BASS:
1660: dip->type = AUDIO_MIXER_VALUE;
1661: dip->mixer_class = ARIAMIX_OUTPUT_CLASS;
1662: dip->prev = ARIAMIX_MASTER_TREBLE;
1663: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
1664: dip->un.v.num_channels = 2;
1665: strlcpy(dip->un.v.units.name, AudioNbass,
1666: sizeof dip->un.v.units.name);
1667: break;
1668:
1669: case ARIAMIX_OUT_LVL:
1670: dip->type = AUDIO_MIXER_VALUE;
1671: dip->mixer_class = ARIAMIX_OUTPUT_CLASS;
1672: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
1673: dip->un.v.num_channels = 2;
1674: strlcpy(dip->un.v.units.name, AudioNvolume,
1675: sizeof dip->un.v.units.name);
1676: break;
1677:
1678: case ARIAMIX_RECORD_SOURCE:
1679: dip->mixer_class = ARIAMIX_RECORD_CLASS;
1680: dip->type = AUDIO_MIXER_ENUM;
1681: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
1682: dip->un.e.num_mem = 6;
1683: strlcpy(dip->un.e.member[0].label.name, AudioNoutput,
1684: sizeof dip->un.e.member[0].label.name);
1685: dip->un.e.member[0].ord = ARIAMIX_AUX_LVL;
1686: strlcpy(dip->un.e.member[1].label.name, AudioNmicrophone,
1687: sizeof dip->un.e.member[0].label.name);
1688: dip->un.e.member[1].ord = ARIAMIX_MIC_LVL;
1689: strlcpy(dip->un.e.member[2].label.name, AudioNdac,
1690: sizeof dip->un.e.member[0].label.name);
1691: dip->un.e.member[2].ord = ARIAMIX_DAC_LVL;
1692: strlcpy(dip->un.e.member[3].label.name, AudioNline,
1693: sizeof dip->un.e.member[0].label.name);
1694: dip->un.e.member[3].ord = ARIAMIX_LINE_IN_LVL;
1695: strlcpy(dip->un.e.member[3].label.name, AudioNcd,
1696: sizeof dip->un.e.member[0].label.name);
1697: dip->un.e.member[4].ord = ARIAMIX_CD_LVL;
1698: strlcpy(dip->un.e.member[3].label.name, "telephone",
1699: sizeof dip->un.e.member[0].label.name);
1700: dip->un.e.member[5].ord = ARIAMIX_TEL_LVL;
1701: break;
1702:
1703: case ARIAMIX_INPUT_CLASS:
1704: dip->type = AUDIO_MIXER_CLASS;
1705: dip->mixer_class = ARIAMIX_INPUT_CLASS;
1706: strlcpy(dip->label.name, AudioCInputs, sizeof dip->label.name);
1707: break;
1708:
1709: case ARIAMIX_OUTPUT_CLASS:
1710: dip->type = AUDIO_MIXER_CLASS;
1711: dip->mixer_class = ARIAMIX_OUTPUT_CLASS;
1712: strlcpy(dip->label.name, AudioCOutputs,
1713: sizeof dip->label.name);
1714: break;
1715:
1716: case ARIAMIX_RECORD_CLASS:
1717: dip->type = AUDIO_MIXER_CLASS;
1718: dip->mixer_class = ARIAMIX_RECORD_CLASS;
1719: strlcpy(dip->label.name, AudioCRecord, sizeof dip->label.name);
1720: break;
1721:
1722: case ARIAMIX_EQ_CLASS:
1723: dip->type = AUDIO_MIXER_CLASS;
1724: dip->mixer_class = ARIAMIX_EQ_CLASS;
1725: strlcpy(dip->label.name, AudioCEqualization,
1726: sizeof dip->label.name);
1727: break;
1728:
1729: default:
1730: return ENXIO;
1731: /*NOTREACHED*/
1732: }
1733: return 0;
1734: }
1735:
1736: #endif /* NARIA */