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