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