This source file includes following definitions.
- ariaprobe
- aria_prometheus_kludge
- aria_do_kludge
- ariaattach
- ariaopen
- aria_getdev
- aria_printsc
- aria_set_sr
- aria_get_sr
- aria_query_encoding
- aria_set_format
- aria_get_encoding
- aria_get_precision
- aria_set_channels
- aria_get_channels
- aria_set_out_port
- aria_get_out_port
- aria_set_in_port
- aria_get_in_port
- aria_speaker_ctl
- aria_round_blocksize
- aria_commit_settings
- ariaclose
- aria_reset
- aria_putdspmem
- aria_getdspmem
- aria_sendcmd
- aria_halt_input
- aria_halt_output
- aria_cont
- aria_start_input
- aria_start_output
- aria_intr
- aria_setfd
- aria_mixer_set_port
- aria_mixer_get_port
- aria_mixer_query_devinfo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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;
108 struct isadev sc_id;
109 void *sc_ih;
110
111 u_short sc_iobase;
112 u_short sc_irq;
113 u_short sc_drq;
114
115 u_short sc_open;
116 u_short sc_play;
117 u_short sc_record;
118 u_short sc_change;
119 u_short gain[2];
120 u_int spkr_state;
121
122 u_long sc_rate;
123 u_int sc_encoding;
124 int sc_chans;
125 int sc_precision;
126
127 u_long sc_interrupts;
128 void (*sc_rintr)(void *);
129 void (*sc_pintr)(void *);
130 void *sc_rarg;
131 void *sc_parg;
132
133 int sc_blocksize;
134 void *sc_rdiobuffer;
135 void *sc_pdiobuffer;
136
137 u_short sc_hardware;
138 #define ARIA_TELEPHONE 0x0001
139 #define ARIA_MIXER 0x0002
140 #define ARIA_MODEL 0x0004
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
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
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,
260 0,
261 NULL,
262 NULL
263 };
264
265
266
267
268
269
270
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
316
317
318
319
320
321
322
323
324
325
326
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
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
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
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
364
365 outb(0x200, 0x0f);
366 end = inb(rba);
367 outw(0x200, 0x0f);
368 outb(0x201, end|0x80);
369 inb(0x200);
370
371
372
373
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
404
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);
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
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
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
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
680
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
729
730
731
732 int
733 aria_speaker_ctl(addr, newstate)
734 void *addr;
735 int newstate;
736 {
737 return(0);
738 }
739
740
741
742
743
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
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);
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
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
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
854
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
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
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
955
956
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
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
1079
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
1146
1147
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;
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
1199
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))
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
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))
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
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))
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
1732 }
1733 return 0;
1734 }
1735
1736 #endif