1 /* $NetBSD: toccata.c,v 1.22 2023/08/27 18:36:55 andvar Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 1999, 2001, 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Paul Kranenburg and Ignatios Souvatzis. 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 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: toccata.c,v 1.22 2023/08/27 18:36:55 andvar Exp $"); 34 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/device.h> 40 #include <sys/fcntl.h> /* FREAD */ 41 #include <sys/bus.h> 42 43 #include <sys/audioio.h> 44 #include <dev/audio/audio_if.h> 45 46 #include <dev/ic/ad1848reg.h> 47 #include <dev/ic/ad1848var.h> 48 49 #include <amiga/dev/zbusvar.h> 50 #include <amiga/amiga/isr.h> 51 52 #ifdef AUDIO_DEBUG 53 #define DPRINTF(x) if (ad1848debug) printf x 54 extern int ad1848debug; 55 #else 56 #define DPRINTF(x) 57 #endif 58 59 /* Register offsets. XXX All of this is guesswork. */ 60 61 /* 62 * The Toccata board consists of: GALs for ZBus AutoConfig(tm) glue, GALs 63 * that interface the FIFO chips and the audio codec chip to the ZBus, 64 * an AD1848 (or AD1845), and 2 Integrated Device Technology 7202LA 65 * (1024x9bit FIFO) chips. 66 */ 67 68 #define TOCC_FIFO_STAT 0x1ffe 69 #define TOCC_FIFO_DATA 0x2000 70 71 /* 72 * I don't know whether the AD1848 PIO data registers are connected... and 73 * at 2 or 3 accesses to read or write a data byte in the best case, I better 74 * don't even think about it. The AD1848 address/status and data port are 75 * here: 76 */ 77 #define TOCC_CODEC_ADDR 0x67FF 78 #define TOCC_CODEC_STAT TOCC_CODEC_ADDR 79 #define TOCC_CODEC_REG 0x6801 80 81 /* fifo status bits, read */ 82 83 #define TOCC_FIFO_INT 0x80 /* active low; together with one of those: */ 84 85 #define TOCC_FIFO_PBHE 0x08 /* playback fifo is half empty (active high) */ 86 #define TOCC_FIFO_CPHF 0x04 /* capture fifo is half full (active high) */ 87 88 /* fifo status bits, write */ 89 90 /* 91 * seems to work like this: 92 * init: write 2; delay; write 1 93 * 94 * capture: write 1; write 1+4+8+0x40 (0x4D) 95 * capt. int: read 512 bytes out of fifo. 96 * capt. int off by writing 1+4+8 (0x0D) 97 * 98 * playback: write 1; write 1 + 0x10; (0x11) 99 * 3/4 fill fifo with silence; init codec; 100 * write 1+4+0x10+0x80 (0x95) 101 * pb int: write 512 bytes to fifo 102 * pb int off by writing 1+4+0x10 (0x15) 103 */ 104 105 #define TOCC_RST 0x02 106 #define TOCC_ACT 0x01 107 #define TOCC_MAGIC 0x04 108 109 #define TOCC_PB_INTENA 0x80 110 #define TOCC_PB_FILL 0x10 111 112 #define TOCC_PB_PREP (TOCC_ACT + TOCC_PB_FILL) 113 #define TOCC_PB_TAIL (TOCC_PB_PREP + TOCC_MAGIC) 114 #define TOCC_PB_MAIN (TOCC_PB_TAIL + TOCC_PB_INTENA) 115 116 #define TOCC_CP_INTENA 0x40 117 #define TOCC_CP_RUN 0x08 118 119 #define TOCC_CP_TAIL (TOCC_ACT + TOCC_CP_RUN) 120 #define TOCC_CP_MAIN (TOCC_CP_TAIL + TOCC_CP_INTENA + TOCC_MAGIC) 121 122 /* 123 * For the port stuff. Similar to the cs4231 table, but MONO is not wired 124 * on the Toccata, which was designed for the AD1848. Also we know how 125 * to handle input. 126 */ 127 128 #define TOCCATA_INPUT_CLASS 0 129 #define TOCCATA_OUTPUT_CLASS 1 130 #define TOCCATA_MONITOR_CLASS 2 131 #define TOCCATA_RECORD_CLASS 3 132 133 #define TOCCATA_RECORD_SOURCE 4 134 #define TOCCATA_REC_LVL 5 135 136 #define TOCCATA_MIC_IN_LVL 6 137 138 #define TOCCATA_AUX1_LVL 7 139 #define TOCCATA_AUX1_MUTE 8 140 141 #define TOCCATA_AUX2_LVL 9 142 #define TOCCATA_AUX2_MUTE 10 143 144 #define TOCCATA_MONITOR_LVL 11 145 #define TOCCATA_MONITOR_MUTE 12 146 #define TOCCATA_OUTPUT_LVL 13 147 148 /* only on AD1845 in mode 2 */ 149 150 #define TOCCATA_LINE_IN_LVL 14 151 #define TOCCATA_LINE_IN_MUTE 15 152 153 /* special, need support */ 154 #define TOCCATA_MIC_LVL 16 155 #define TOCCATA_MIC_MUTE 17 156 157 158 159 /* prototypes */ 160 161 int toccata_intr(void *); 162 int toccata_readreg(struct ad1848_softc *, int); 163 void toccata_writereg(struct ad1848_softc *, int, int); 164 165 int toccata_round_blocksize(void *, int, int, const audio_params_t *); 166 size_t toccata_round_buffersize(void *, int, size_t); 167 168 int toccata_open(void *, int); 169 void toccata_close(void *); 170 int toccata_getdev(void *, struct audio_device *); 171 int toccata_get_props(void *); 172 173 int toccata_halt_input(void *); 174 int toccata_halt_output(void *); 175 int toccata_start_input(void *, void *, int, void (*)(void *), void *); 176 int toccata_start_output(void *, void *, int, void (*)(void *), void *); 177 178 /* I suspect those should be in a shared file */ 179 int toccata_set_port(void *, mixer_ctrl_t *); 180 int toccata_get_port(void *, mixer_ctrl_t *); 181 int toccata_query_devinfo(void *, mixer_devinfo_t *); 182 183 void toccata_get_locks(void *, kmutex_t **, kmutex_t **); 184 185 const struct audio_hw_if audiocs_hw_if = { 186 .open = toccata_open, 187 .close = toccata_close, 188 .query_format = ad1848_query_format, 189 .set_format = ad1848_set_format, 190 .round_blocksize = toccata_round_blocksize, 191 .commit_settings = ad1848_commit_settings, 192 .init_output = NULL, /* XXX need this to prefill? */ 193 .init_input = NULL, 194 .start_output = toccata_start_output, 195 .start_input = toccata_start_input, 196 .halt_output = toccata_halt_output, 197 .halt_input = toccata_halt_input, 198 .getdev = toccata_getdev, 199 .set_port = toccata_set_port, 200 .get_port = toccata_get_port, 201 .query_devinfo = toccata_query_devinfo, 202 .round_buffersize = toccata_round_buffersize, 203 .get_props = toccata_get_props, 204 .get_locks = toccata_get_locks, 205 }; 206 207 struct toccata_softc { 208 struct ad1848_softc sc_ad; 209 struct isr sc_isr; 210 volatile uint8_t *sc_boardp; /* only need a few addresses! */ 211 212 void (*sc_captmore)(void *); 213 void *sc_captarg; 214 void *sc_captbuf; 215 int sc_captbufsz; 216 217 void (*sc_playmore)(void *); 218 void *sc_playarg; 219 220 kmutex_t sc_lock; 221 kmutex_t sc_intr_lock; 222 }; 223 224 int toccata_match(device_t, cfdata_t, void *); 225 void toccata_attach(device_t, device_t, void *); 226 227 CFATTACH_DECL_NEW(toccata, sizeof(struct toccata_softc), 228 toccata_match, toccata_attach, NULL, NULL); 229 230 int 231 toccata_match(device_t parent, cfdata_t cfp, void *aux) 232 { 233 struct zbus_args *zap; 234 235 zap = aux; 236 237 if (zap->manid != 18260) 238 return (0); 239 240 if (zap->prodid != 12) 241 return (0); 242 243 return (1); 244 } 245 246 void 247 toccata_attach(device_t parent, device_t self, void *aux) 248 { 249 struct toccata_softc *sc; 250 struct ad1848_softc *asc; 251 struct zbus_args *zap; 252 volatile uint8_t *boardp; 253 254 sc = device_private(self); 255 asc = &sc->sc_ad; 256 asc->sc_dev = self; 257 zap = aux; 258 259 boardp = (volatile uint8_t *)zap->va; 260 sc->sc_boardp = boardp; 261 262 *boardp = TOCC_RST; 263 delay(500000); /* look up value */ 264 *boardp = TOCC_ACT; 265 266 asc->parent = sc; 267 asc->sc_readreg = toccata_readreg; 268 asc->sc_writereg = toccata_writereg; 269 270 asc->chip_name = "ad1848"; 271 asc->mode = 1; 272 ad1848_attach(asc); 273 printf("\n"); 274 275 sc->sc_captbuf = 0; 276 sc->sc_playmore = 0; 277 278 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 279 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED); 280 281 sc->sc_isr.isr_ipl = 6; 282 sc->sc_isr.isr_arg = sc; 283 sc->sc_isr.isr_intr = toccata_intr; 284 add_isr(&sc->sc_isr); 285 286 audio_attach_mi(&audiocs_hw_if, sc, self); 287 288 } 289 290 /* interrupt handler */ 291 int 292 toccata_intr(void *tag) { 293 struct toccata_softc *sc; 294 uint8_t *buf; 295 volatile uint8_t *fifo; 296 uint8_t status; 297 int i; 298 299 sc = tag; 300 301 mutex_spin_enter(&sc->sc_intr_lock); 302 303 status = *(sc->sc_boardp); 304 305 if (status & TOCC_FIFO_INT) { /* active low */ 306 mutex_spin_exit(&sc->sc_intr_lock); 307 return 0; 308 } 309 310 if (status & TOCC_FIFO_PBHE) { 311 if (sc->sc_playmore) { 312 (*sc->sc_playmore)(sc->sc_playarg); 313 mutex_spin_exit(&sc->sc_intr_lock); 314 return 1; 315 } 316 } else if (status & TOCC_FIFO_CPHF) { 317 if (sc->sc_captbuf) { 318 buf = sc->sc_captbuf; 319 fifo = sc->sc_boardp + TOCC_FIFO_DATA; 320 321 for (i = sc->sc_captbufsz/4 - 1; i>=0; --i) { 322 *buf++ = *fifo; 323 *buf++ = *fifo; 324 *buf++ = *fifo; 325 *buf++ = *fifo; 326 } 327 328 /* XXX if (sc->sc_captmore) { */ 329 (*sc->sc_captmore)(sc->sc_captarg); 330 mutex_spin_exit(&sc->sc_intr_lock); 331 return 1; 332 } 333 } 334 335 /* 336 * Something is wrong; switch interrupts off to avoid wedging the 337 * machine, and notify the alpha tester. 338 * Normally, the halt_* functions should have switched off the 339 * FIFO interrupt. 340 */ 341 #ifdef DEBUG 342 printf("%s: got unexpected interrupt %x\n", 343 device_xname(sc->sc_ad.sc_dev), status); 344 #endif 345 *sc->sc_boardp = TOCC_ACT; 346 mutex_spin_exit(&sc->sc_intr_lock); 347 return 1; 348 } 349 350 /* support for ad1848 functions */ 351 352 int 353 toccata_readreg(struct ad1848_softc *asc, int offset) 354 { 355 struct toccata_softc *sc; 356 357 sc = (struct toccata_softc *)asc; 358 return *(sc->sc_boardp + TOCC_CODEC_ADDR + 359 offset * (TOCC_CODEC_REG - TOCC_CODEC_ADDR)); 360 } 361 362 void 363 toccata_writereg(struct ad1848_softc *asc, int offset, int value) 364 { 365 struct toccata_softc *sc; 366 367 sc = (struct toccata_softc *)asc; 368 *(sc->sc_boardp + TOCC_CODEC_ADDR + 369 offset * (TOCC_CODEC_REG - TOCC_CODEC_ADDR)) = value; 370 } 371 372 /* our own copy of open/close; we don't ever enable the ad1848 interrupts */ 373 int 374 toccata_open(void *addr, int flags) 375 { 376 struct toccata_softc *sc; 377 struct ad1848_softc *asc; 378 379 sc = addr; 380 asc = &sc->sc_ad; 381 382 asc->open_mode = flags; 383 /* If recording && monitoring, the playback part is also used. */ 384 if (flags & FREAD && asc->mute[AD1848_MONITOR_CHANNEL] == 0) 385 ad1848_mute_wave_output(asc, WAVE_UNMUTE1, 1); 386 387 #ifdef AUDIO_DEBUG 388 if (ad1848debug) 389 ad1848_dump_regs(asc); 390 #endif 391 392 return 0; 393 } 394 395 void 396 toccata_close(void *addr) 397 { 398 struct toccata_softc *sc; 399 struct ad1848_softc *asc; 400 unsigned reg; 401 402 sc = addr; 403 asc = &sc->sc_ad; 404 asc->open_mode = 0; 405 406 ad1848_mute_wave_output(asc, WAVE_UNMUTE1, 0); 407 408 reg = ad_read(&sc->sc_ad, SP_INTERFACE_CONFIG); 409 ad_write(&sc->sc_ad, SP_INTERFACE_CONFIG, 410 (reg & ~(CAPTURE_ENABLE|PLAYBACK_ENABLE))); 411 412 /* Disable interrupts */ 413 *sc->sc_boardp = TOCC_ACT; 414 #ifdef AUDIO_DEBUG 415 if (ad1848debug) 416 ad1848_dump_regs(asc); 417 #endif 418 } 419 420 int 421 toccata_round_blocksize(void *addr, int blk, 422 int mode, const audio_params_t *param) 423 { 424 425 if (blk > 512) 426 blk = 512; 427 return blk; 428 } 429 430 size_t 431 toccata_round_buffersize(void *addr, int direction, size_t suggested) 432 { 433 434 return suggested & -4; 435 } 436 437 struct audio_device toccata_device = { 438 "toccata", "x", "audio" 439 }; 440 441 int 442 toccata_getdev(void *addr, struct audio_device *retp) 443 { 444 445 *retp = toccata_device; 446 return 0; 447 } 448 449 int 450 toccata_get_props(void *addr) 451 { 452 453 return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE; 454 } 455 456 void 457 toccata_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread) 458 { 459 struct toccata_softc *sc = opaque; 460 461 *intr = &sc->sc_intr_lock; 462 *thread = &sc->sc_lock; 463 } 464 465 int 466 toccata_halt_input(void *addr) 467 { 468 struct toccata_softc *sc; 469 unsigned reg; 470 471 sc = addr; 472 473 /* we're half_duplex; be brutal */ 474 *sc->sc_boardp = TOCC_CP_TAIL; 475 sc->sc_captmore = 0; 476 sc->sc_captbuf = 0; 477 478 reg = ad_read(&sc->sc_ad, SP_INTERFACE_CONFIG); 479 ad_write(&sc->sc_ad, SP_INTERFACE_CONFIG, (reg & ~CAPTURE_ENABLE)); 480 481 return 0; 482 } 483 484 int 485 toccata_start_input(void *addr, void *block, int blksize, 486 void (*intr)(void *), void *intrarg) 487 { 488 struct toccata_softc *sc; 489 unsigned int reg; 490 volatile uint8_t *cmd; 491 492 sc = addr; 493 cmd = sc->sc_boardp; 494 495 if (sc->sc_captmore == 0) { 496 497 /* we're half-duplex, be brutal */ 498 *cmd = TOCC_ACT; 499 *cmd = TOCC_CP_MAIN; 500 501 reg = ad_read(&sc->sc_ad, SP_INTERFACE_CONFIG); 502 ad_write(&sc->sc_ad, SP_INTERFACE_CONFIG, 503 (reg | CAPTURE_ENABLE)); 504 505 } 506 507 sc->sc_captarg = intrarg; 508 sc->sc_captmore = intr; 509 sc->sc_captbuf = (uint8_t *)block; 510 sc->sc_captbufsz = blksize; 511 512 return 0; 513 } 514 515 int 516 toccata_halt_output(void *addr) 517 { 518 struct toccata_softc *sc; 519 unsigned int reg; 520 521 sc = addr; 522 523 /* we're half_duplex; be brutal */ 524 *sc->sc_boardp = TOCC_PB_TAIL; 525 sc->sc_playmore = 0; 526 527 reg = ad_read(&sc->sc_ad, SP_INTERFACE_CONFIG); 528 ad_write(&sc->sc_ad, SP_INTERFACE_CONFIG, (reg & ~PLAYBACK_ENABLE)); 529 530 return 0; 531 } 532 533 int 534 toccata_start_output(void *addr, void *block, int blksize, 535 void (*intr)(void*), void *intrarg) 536 { 537 struct toccata_softc *sc; 538 unsigned reg; 539 int i; 540 volatile uint8_t *cmd, *fifo; 541 uint8_t *buf; 542 543 sc = addr; 544 buf = block; 545 546 cmd = sc->sc_boardp; 547 fifo = sc->sc_boardp + TOCC_FIFO_DATA; 548 549 if (sc->sc_playmore == 0) { 550 *cmd = TOCC_ACT; 551 *cmd = TOCC_PB_PREP; 552 } 553 554 /* 555 * We rounded the blocksize to a multiple of 4 bytes. Modest 556 * unrolling saves 2% of cputime playing 48000 16bit stereo 557 * on 68040/25MHz. 558 */ 559 560 for (i = blksize/4 - 1; i>=0; --i) { 561 *fifo = *buf++; 562 *fifo = *buf++; 563 *fifo = *buf++; 564 *fifo = *buf++; 565 } 566 567 if (sc->sc_playmore == 0) { 568 reg = ad_read(&sc->sc_ad, SP_INTERFACE_CONFIG); 569 ad_write(&sc->sc_ad, SP_INTERFACE_CONFIG, 570 (reg | PLAYBACK_ENABLE)); 571 572 /* we're half-duplex, be brutal */ 573 *sc->sc_boardp = TOCC_PB_MAIN; 574 } 575 576 sc->sc_playarg = intrarg; 577 sc->sc_playmore = intr; 578 579 return 0; 580 } 581 582 static ad1848_devmap_t csmapping[] = { 583 { TOCCATA_MIC_IN_LVL, AD1848_KIND_MICGAIN, -1 }, 584 { TOCCATA_AUX1_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL }, 585 { TOCCATA_AUX1_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL }, 586 { TOCCATA_AUX2_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL }, 587 { TOCCATA_AUX2_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL }, 588 { TOCCATA_OUTPUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL }, 589 { TOCCATA_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL }, 590 { TOCCATA_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL }, 591 { TOCCATA_REC_LVL, AD1848_KIND_RECORDGAIN, -1 }, 592 { TOCCATA_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 }, 593 /* only in mode 2: */ 594 { TOCCATA_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL }, 595 { TOCCATA_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL }, 596 }; 597 598 #define nummap (sizeof(csmapping) / sizeof(csmapping[0])) 599 600 int 601 toccata_set_port(void *addr, mixer_ctrl_t *cp) 602 { 603 struct ad1848_softc *ac; 604 605 /* printf("set_port(%d)\n", cp->dev); */ 606 ac = addr; 607 return ad1848_mixer_set_port(ac, csmapping, 608 ac->mode == 2 ? nummap : nummap - 2, cp); 609 } 610 611 int 612 toccata_get_port(void *addr, mixer_ctrl_t *cp) 613 { 614 struct ad1848_softc *ac; 615 616 /* printf("get_port(%d)\n", cp->dev); */ 617 ac = addr; 618 return ad1848_mixer_get_port(ac, csmapping, 619 ac->mode == 2 ? nummap : nummap - 2, cp); 620 } 621 622 int 623 toccata_query_devinfo(void *addr, mixer_devinfo_t *dip) 624 { 625 626 switch(dip->index) { 627 case TOCCATA_MIC_IN_LVL: /* Microphone */ 628 dip->type = AUDIO_MIXER_VALUE; 629 dip->mixer_class = TOCCATA_INPUT_CLASS; 630 dip->prev = dip->next = AUDIO_MIXER_LAST; 631 strcpy(dip->label.name, AudioNmicrophone); 632 dip->un.v.num_channels = 1; 633 strcpy(dip->un.v.units.name, AudioNvolume); 634 break; 635 #if 0 636 637 case TOCCATA_MONO_LVL: /* mono/microphone mixer */ 638 dip->type = AUDIO_MIXER_VALUE; 639 dip->mixer_class = TOCCATA_INPUT_CLASS; 640 dip->prev = AUDIO_MIXER_LAST; 641 dip->next = TOCCATA_MONO_MUTE; 642 strcpy(dip->label.name, AudioNmicrophone); 643 dip->un.v.num_channels = 1; 644 strcpy(dip->un.v.units.name, AudioNvolume); 645 break; 646 #endif 647 648 case TOCCATA_AUX1_LVL: /* dacout */ 649 dip->type = AUDIO_MIXER_VALUE; 650 dip->mixer_class = TOCCATA_INPUT_CLASS; 651 dip->prev = AUDIO_MIXER_LAST; 652 dip->next = TOCCATA_AUX1_MUTE; 653 strcpy(dip->label.name, "aux1"); 654 dip->un.v.num_channels = 2; 655 strcpy(dip->un.v.units.name, AudioNvolume); 656 break; 657 658 case TOCCATA_AUX1_MUTE: 659 dip->mixer_class = TOCCATA_INPUT_CLASS; 660 dip->type = AUDIO_MIXER_ENUM; 661 dip->prev = TOCCATA_AUX1_LVL; 662 dip->next = AUDIO_MIXER_LAST; 663 goto mute; 664 665 666 667 case TOCCATA_AUX2_LVL: 668 dip->type = AUDIO_MIXER_VALUE; 669 dip->mixer_class = TOCCATA_INPUT_CLASS; 670 dip->prev = AUDIO_MIXER_LAST; 671 dip->next = TOCCATA_AUX2_MUTE; 672 strcpy(dip->label.name, "aux2"); 673 dip->un.v.num_channels = 2; 674 strcpy(dip->un.v.units.name, AudioNvolume); 675 break; 676 677 case TOCCATA_AUX2_MUTE: 678 dip->mixer_class = TOCCATA_INPUT_CLASS; 679 dip->type = AUDIO_MIXER_ENUM; 680 dip->prev = TOCCATA_AUX2_LVL; 681 dip->next = AUDIO_MIXER_LAST; 682 goto mute; 683 684 685 case TOCCATA_MONITOR_LVL: /* monitor level */ 686 dip->type = AUDIO_MIXER_VALUE; 687 dip->mixer_class = TOCCATA_MONITOR_CLASS; 688 dip->next = TOCCATA_MONITOR_MUTE; 689 dip->prev = AUDIO_MIXER_LAST; 690 strcpy(dip->label.name, AudioNmonitor); 691 dip->un.v.num_channels = 1; 692 strcpy(dip->un.v.units.name, AudioNvolume); 693 break; 694 695 case TOCCATA_OUTPUT_LVL: /* output volume */ 696 dip->type = AUDIO_MIXER_VALUE; 697 dip->mixer_class = TOCCATA_OUTPUT_CLASS; 698 dip->prev = dip->next = AUDIO_MIXER_LAST; 699 strcpy(dip->label.name, AudioNmaster); 700 dip->un.v.num_channels = 2; 701 strcpy(dip->un.v.units.name, AudioNvolume); 702 break; 703 #if 0 704 case TOCCATA_LINE_IN_LVL: /* line */ 705 dip->type = AUDIO_MIXER_VALUE; 706 dip->mixer_class = TOCCATA_INPUT_CLASS; 707 dip->prev = AUDIO_MIXER_LAST; 708 dip->next = TOCCATA_LINE_IN_MUTE; 709 strcpy(dip->label.name, AudioNline); 710 dip->un.v.num_channels = 2; 711 strcpy(dip->un.v.units.name, AudioNvolume); 712 break; 713 714 case TOCCATA_LINE_IN_MUTE: 715 dip->mixer_class = TOCCATA_INPUT_CLASS; 716 dip->type = AUDIO_MIXER_ENUM; 717 dip->prev = TOCCATA_LINE_IN_LVL; 718 dip->next = AUDIO_MIXER_LAST; 719 goto mute; 720 #endif 721 case TOCCATA_MONITOR_MUTE: 722 dip->mixer_class = TOCCATA_MONITOR_CLASS; 723 dip->type = AUDIO_MIXER_ENUM; 724 dip->prev = TOCCATA_MONITOR_LVL; 725 dip->next = AUDIO_MIXER_LAST; 726 mute: 727 strcpy(dip->label.name, AudioNmute); 728 dip->un.e.num_mem = 2; 729 strcpy(dip->un.e.member[0].label.name, AudioNoff); 730 dip->un.e.member[0].ord = 0; 731 strcpy(dip->un.e.member[1].label.name, AudioNon); 732 dip->un.e.member[1].ord = 1; 733 break; 734 735 case TOCCATA_REC_LVL: /* record level */ 736 dip->type = AUDIO_MIXER_VALUE; 737 dip->mixer_class = TOCCATA_INPUT_CLASS; 738 dip->prev = AUDIO_MIXER_LAST; 739 dip->next = TOCCATA_RECORD_SOURCE; 740 strcpy(dip->label.name, AudioNrecord); 741 dip->un.v.num_channels = 2; 742 strcpy(dip->un.v.units.name, AudioNvolume); 743 break; 744 745 case TOCCATA_RECORD_SOURCE: 746 dip->mixer_class = TOCCATA_RECORD_CLASS; 747 dip->type = AUDIO_MIXER_ENUM; 748 dip->prev = TOCCATA_REC_LVL; 749 dip->next = AUDIO_MIXER_LAST; 750 strcpy(dip->label.name, AudioNsource); 751 dip->un.e.num_mem = 4; 752 strcpy(dip->un.e.member[0].label.name, AudioNmicrophone); 753 dip->un.e.member[1].ord = MIC_IN_PORT; 754 strcpy(dip->un.e.member[1].label.name, AudioNline); 755 dip->un.e.member[3].ord = LINE_IN_PORT; 756 strcpy(dip->un.e.member[2].label.name, "aux1"); 757 dip->un.e.member[2].ord = AUX1_IN_PORT; 758 strcpy(dip->un.e.member[3].label.name, AudioNoutput); 759 dip->un.e.member[0].ord = DAC_IN_PORT; 760 break; 761 762 case TOCCATA_INPUT_CLASS: /* input class descriptor */ 763 dip->type = AUDIO_MIXER_CLASS; 764 dip->mixer_class = TOCCATA_INPUT_CLASS; 765 dip->next = dip->prev = AUDIO_MIXER_LAST; 766 strcpy(dip->label.name, AudioCinputs); 767 break; 768 769 case TOCCATA_OUTPUT_CLASS: /* output class descriptor */ 770 dip->type = AUDIO_MIXER_CLASS; 771 dip->mixer_class = TOCCATA_OUTPUT_CLASS; 772 dip->next = dip->prev = AUDIO_MIXER_LAST; 773 strcpy(dip->label.name, AudioCoutputs); 774 break; 775 776 case TOCCATA_MONITOR_CLASS: /* monitor class descriptor */ 777 dip->type = AUDIO_MIXER_CLASS; 778 dip->mixer_class = TOCCATA_MONITOR_CLASS; 779 dip->next = dip->prev = AUDIO_MIXER_LAST; 780 strcpy(dip->label.name, AudioCmonitor); 781 break; 782 783 case TOCCATA_RECORD_CLASS: /* record source class */ 784 dip->type = AUDIO_MIXER_CLASS; 785 dip->mixer_class = TOCCATA_RECORD_CLASS; 786 dip->next = dip->prev = AUDIO_MIXER_LAST; 787 strcpy(dip->label.name, AudioCrecord); 788 break; 789 790 default: 791 return ENXIO; 792 /*NOTREACHED*/ 793 } 794 795 return 0; 796 } 797
Indexes created Mon Sep 22 13:09:51 GMT 2025