eso.c revision 1.3
1 /* $NetBSD: eso.c,v 1.3 1999/08/02 17:37:43 augustss Exp $ */ 2 3 /* 4 * Copyright (c) 1999 Klaus J. Klein 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 /* 32 * ESS Technology Inc. Solo-1 PCI AudioDrive (ES1938/1946) device driver. 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/malloc.h> 39 #include <sys/device.h> 40 #include <sys/proc.h> 41 42 #include <dev/pci/pcidevs.h> 43 #include <dev/pci/pcivar.h> 44 45 #include <sys/audioio.h> 46 #include <dev/audio_if.h> 47 #include <dev/midi_if.h> 48 49 #include <dev/mulaw.h> 50 #include <dev/auconv.h> 51 52 #include <dev/ic/mpuvar.h> 53 #include <dev/ic/i8237reg.h> 54 #include <dev/pci/esoreg.h> 55 #include <dev/pci/esovar.h> 56 57 #include <machine/bus.h> 58 #include <machine/intr.h> 59 60 #if BYTE_ORDER == BIG_ENDIAN 61 #include <machine/bswap.h> 62 #define htopci(x) bswap32(x) 63 #define pcitoh(x) bswap32(x) 64 #else 65 #define htopci(x) (x) 66 #define pcitoh(x) (x) 67 #endif 68 69 70 #if defined(AUDIO_DEBUG) || defined(DEBUG) 71 #define DPRINTF(x) printf x 72 #else 73 #define DPRINTF(x) 74 #endif 75 76 struct eso_dma { 77 bus_dmamap_t ed_map; 78 caddr_t ed_addr; 79 bus_dma_segment_t ed_segs[1]; 80 int ed_nsegs; 81 size_t ed_size; 82 struct eso_dma * ed_next; 83 }; 84 85 #define KVADDR(dma) ((void *)(dma)->ed_addr) 86 #define DMAADDR(dma) ((dma)->ed_map->dm_segs[0].ds_addr) 87 88 /* Autoconfiguration interface */ 89 static int eso_match __P((struct device *, struct cfdata *, void *)); 90 static void eso_attach __P((struct device *, struct device *, void *)); 91 static void eso_defer __P((struct device *)); 92 93 struct cfattach eso_ca = { 94 sizeof (struct eso_softc), eso_match, eso_attach 95 }; 96 97 /* PCI interface */ 98 static int eso_intr __P((void *)); 99 100 /* MI audio layer interface */ 101 static int eso_open __P((void *, int)); 102 static void eso_close __P((void *)); 103 static int eso_query_encoding __P((void *, struct audio_encoding *)); 104 static int eso_set_params __P((void *, int, int, struct audio_params *, 105 struct audio_params *)); 106 static int eso_round_blocksize __P((void *, int)); 107 static int eso_halt_output __P((void *)); 108 static int eso_halt_input __P((void *)); 109 static int eso_getdev __P((void *, struct audio_device *)); 110 static int eso_set_port __P((void *, mixer_ctrl_t *)); 111 static int eso_get_port __P((void *, mixer_ctrl_t *)); 112 static int eso_query_devinfo __P((void *, mixer_devinfo_t *)); 113 static void * eso_allocm __P((void *, int, size_t, int, int)); 114 static void eso_freem __P((void *, void *, int)); 115 static size_t eso_round_buffersize __P((void *, int, size_t)); 116 static int eso_mappage __P((void *, void *, int, int)); 117 static int eso_get_props __P((void *)); 118 static int eso_trigger_output __P((void *, void *, void *, int, 119 void (*)(void *), void *, struct audio_params *)); 120 static int eso_trigger_input __P((void *, void *, void *, int, 121 void (*)(void *), void *, struct audio_params *)); 122 123 static struct audio_hw_if eso_hw_if = { 124 eso_open, 125 eso_close, 126 NULL, /* drain */ 127 eso_query_encoding, 128 eso_set_params, 129 eso_round_blocksize, 130 NULL, /* commit_settings */ 131 NULL, /* init_output */ 132 NULL, /* init_input */ 133 NULL, /* start_output */ 134 NULL, /* start_input */ 135 eso_halt_output, 136 eso_halt_input, 137 NULL, /* speaker_ctl */ 138 eso_getdev, 139 NULL, /* setfd */ 140 eso_set_port, 141 eso_get_port, 142 eso_query_devinfo, 143 eso_allocm, 144 eso_freem, 145 eso_round_buffersize, 146 eso_mappage, 147 eso_get_props, 148 eso_trigger_output, 149 eso_trigger_input 150 }; 151 152 static const char * const eso_rev2model[] = { 153 "ES1938", 154 "ES1946" 155 }; 156 157 158 /* 159 * Utility routines 160 */ 161 /* Register access etc. */ 162 static uint8_t eso_read_ctlreg __P((struct eso_softc *, uint8_t)); 163 static uint8_t eso_read_mixreg __P((struct eso_softc *, uint8_t)); 164 static uint8_t eso_read_rdr __P((struct eso_softc *)); 165 static int eso_reset __P((struct eso_softc *)); 166 static void eso_set_gain __P((struct eso_softc *, unsigned int)); 167 static int eso_set_recsrc __P((struct eso_softc *, unsigned int)); 168 static void eso_write_cmd __P((struct eso_softc *, uint8_t)); 169 static void eso_write_ctlreg __P((struct eso_softc *, uint8_t, uint8_t)); 170 static void eso_write_mixreg __P((struct eso_softc *, uint8_t, uint8_t)); 171 /* DMA memory allocation */ 172 static int eso_allocmem __P((struct eso_softc *, size_t, size_t, size_t, 173 int, struct eso_dma *)); 174 static void eso_freemem __P((struct eso_softc *, struct eso_dma *)); 175 176 177 static int 178 eso_match(parent, match, aux) 179 struct device *parent; 180 struct cfdata *match; 181 void *aux; 182 { 183 struct pci_attach_args *pa = aux; 184 185 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ESSTECH && 186 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ESSTECH_SOLO1) 187 return (1); 188 189 return (0); 190 } 191 192 static void 193 eso_attach(parent, self, aux) 194 struct device *parent, *self; 195 void *aux; 196 { 197 struct eso_softc *sc = (struct eso_softc *)self; 198 struct pci_attach_args *pa = aux; 199 struct audio_attach_args aa; 200 pci_intr_handle_t ih; 201 bus_addr_t vcbase; 202 const char *intrstring; 203 int idx; 204 uint8_t a2mode; 205 206 sc->sc_revision = PCI_REVISION(pa->pa_class); 207 208 printf(": ESS Solo-1 PCI AudioDrive "); 209 if (sc->sc_revision <= 210 sizeof (eso_rev2model) / sizeof (eso_rev2model[0])) 211 printf("%s\n", eso_rev2model[sc->sc_revision]); 212 else 213 printf("(unknown rev. 0x%02x)\n", sc->sc_revision); 214 215 /* Map I/O registers. */ 216 if (pci_mapreg_map(pa, ESO_PCI_BAR_IO, PCI_MAPREG_TYPE_IO, 0, 217 &sc->sc_iot, &sc->sc_ioh, NULL, NULL)) { 218 printf("%s: can't map I/O space\n", sc->sc_dev.dv_xname); 219 return; 220 } 221 if (pci_mapreg_map(pa, ESO_PCI_BAR_SB, PCI_MAPREG_TYPE_IO, 0, 222 &sc->sc_sb_iot, &sc->sc_sb_ioh, NULL, NULL)) { 223 printf("%s: can't map SB I/O space\n", sc->sc_dev.dv_xname); 224 return; 225 } 226 if (pci_mapreg_map(pa, ESO_PCI_BAR_VC, PCI_MAPREG_TYPE_IO, 0, 227 &sc->sc_dmac_iot, &sc->sc_dmac_ioh, &vcbase, &sc->sc_vcsize)) { 228 printf("%s: can't map VC I/O space\n", sc->sc_dev.dv_xname); 229 /* Don't bail out yet: we can map it later, see below. */ 230 vcbase = 0; 231 sc->sc_vcsize = 0x10; /* From the data sheet. */ 232 } 233 234 if (pci_mapreg_map(pa, ESO_PCI_BAR_MPU, PCI_MAPREG_TYPE_IO, 0, 235 &sc->sc_mpu_iot, &sc->sc_mpu_ioh, NULL, NULL)) { 236 printf("%s: can't map MPU I/O space\n", sc->sc_dev.dv_xname); 237 return; 238 } 239 if (pci_mapreg_map(pa, ESO_PCI_BAR_GAME, PCI_MAPREG_TYPE_IO, 0, 240 &sc->sc_game_iot, &sc->sc_game_ioh, NULL, NULL)) { 241 printf("%s: can't map Game I/O space\n", sc->sc_dev.dv_xname); 242 return; 243 } 244 245 sc->sc_dmat = pa->pa_dmat; 246 sc->sc_dmas = NULL; 247 sc->sc_dmac_configured = 0; 248 249 /* Enable bus mastering. */ 250 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 251 pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG) | 252 PCI_COMMAND_MASTER_ENABLE); 253 254 /* Reset the device; bail out upon failure. */ 255 if (eso_reset(sc) != 0) { 256 printf("%s: can't reset\n", sc->sc_dev.dv_xname); 257 return; 258 } 259 260 /* Select the DMA/IRQ policy: DDMA, ISA IRQ emulation disabled. */ 261 pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C, 262 pci_conf_read(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C) & 263 ~(ESO_PCI_S1C_IRQP_MASK | ESO_PCI_S1C_DMAP_MASK)); 264 265 /* Enable the relevant DMA interrupts. */ 266 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL, 267 ESO_IO_IRQCTL_A1IRQ | ESO_IO_IRQCTL_A2IRQ); 268 269 /* Set up A1's sample rate generator for new-style parameters. */ 270 a2mode = eso_read_mixreg(sc, ESO_MIXREG_A2MODE); 271 a2mode |= ESO_MIXREG_A2MODE_NEWA1 | ESO_MIXREG_A2MODE_ASYNC; 272 eso_write_mixreg(sc, ESO_MIXREG_A2MODE, a2mode); 273 274 /* Set mixer regs to something reasonable, needs work. */ 275 for (idx = 0; idx < ESO_NGAINDEVS; idx++) { 276 int v; 277 278 switch (idx) { 279 case ESO_MIC_PLAY_VOL: 280 case ESO_LINE_PLAY_VOL: 281 case ESO_CD_PLAY_VOL: 282 case ESO_MONO_PLAY_VOL: 283 case ESO_AUXB_PLAY_VOL: 284 case ESO_DAC_REC_VOL: 285 case ESO_LINE_REC_VOL: 286 case ESO_SYNTH_REC_VOL: 287 case ESO_CD_REC_VOL: 288 case ESO_MONO_REC_VOL: 289 case ESO_AUXB_REC_VOL: 290 case ESO_SPATIALIZER: 291 v = 0; 292 break; 293 case ESO_MASTER_VOL: 294 v = ESO_GAIN_TO_6BIT(AUDIO_MAX_GAIN / 2); 295 break; 296 default: 297 v = ESO_GAIN_TO_4BIT(AUDIO_MAX_GAIN / 2); 298 break; 299 } 300 sc->sc_gain[idx][ESO_LEFT] = sc->sc_gain[idx][ESO_RIGHT] = v; 301 eso_set_gain(sc, idx); 302 } 303 eso_set_recsrc(sc, ESO_MIXREG_ERS_MIC); 304 305 /* Map and establish the interrupt. */ 306 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin, 307 pa->pa_intrline, &ih)) { 308 printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname); 309 return; 310 } 311 intrstring = pci_intr_string(pa->pa_pc, ih); 312 sc->sc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, eso_intr, sc); 313 if (sc->sc_ih == NULL) { 314 printf("%s: couldn't establish interrupt", 315 sc->sc_dev.dv_xname); 316 if (intrstring != NULL) 317 printf(" at %s", intrstring); 318 printf("\n"); 319 return; 320 } 321 printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstring); 322 323 /* 324 * Set up the DDMA Control register; a suitable I/O region has been 325 * supposedly mapped in the VC base address register. 326 * 327 * The Solo-1 has an ... interesting silicon bug that causes it to 328 * not respond to I/O space accesses to the Audio 1 DMA controller 329 * if the latter's mapping base address is aligned on a 1K boundary. 330 * As a consequence, it is quite possible for the mapping provided 331 * in the VC BAR to be useless. To work around this, we defer this 332 * part until all autoconfiguration on our parent bus is completed 333 * and then try to map it ourselves in fulfillment of the constraint. 334 * 335 * According to the register map we may write to the low 16 bits 336 * only, but experimenting has shown we're safe. 337 * -kjk 338 */ 339 if (ESO_VALID_DDMAC_BASE(vcbase)) { 340 pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC, 341 vcbase | ESO_PCI_DDMAC_DE); 342 sc->sc_dmac_configured = 1; 343 344 printf("%s: mapping Audio 1 DMA using VC I/O space at 0x%lx\n", 345 sc->sc_dev.dv_xname, (unsigned long)vcbase); 346 } else { 347 DPRINTF(("%s: VC I/O space at 0x%lx not suitable, deferring\n", 348 sc->sc_dev.dv_xname, (unsigned long)vcbase)); 349 sc->sc_pa = *pa; 350 config_defer(self, eso_defer); 351 } 352 353 audio_attach_mi(&eso_hw_if, sc, &sc->sc_dev); 354 355 aa.type = AUDIODEV_TYPE_OPL; 356 aa.hwif = NULL; 357 aa.hdl = NULL; 358 (void)config_found(&sc->sc_dev, &aa, audioprint); 359 360 #if 0 361 aa.type = AUDIODEV_TYPE_MPU; 362 aa.hwif = NULL; 363 aa.hdl = NULL; 364 sc->sc_mpudev = config_found(&sc->sc_dev, &aa, audioprint); 365 #endif 366 } 367 368 static void 369 eso_defer(self) 370 struct device *self; 371 { 372 struct eso_softc *sc = (struct eso_softc *)self; 373 struct pci_attach_args *pa = &sc->sc_pa; 374 bus_addr_t addr, start; 375 376 printf("%s: ", sc->sc_dev.dv_xname); 377 378 /* 379 * This is outright ugly, but since we must not make assumptions 380 * on the underlying allocator's behaviour it's the most straight- 381 * forward way to implement it. Note that we skip over the first 382 * 1K region, which is typically occupied by an attached ISA bus. 383 */ 384 for (start = 0x0400; start < 0xffff; start += 0x0400) { 385 if (bus_space_alloc(sc->sc_iot, 386 start + sc->sc_vcsize, start + 0x0400 - 1, 387 sc->sc_vcsize, sc->sc_vcsize, 0, 0, &addr, 388 &sc->sc_dmac_ioh) != 0) 389 continue; 390 391 pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC, 392 addr | ESO_PCI_DDMAC_DE); 393 sc->sc_dmac_iot = sc->sc_iot; 394 sc->sc_dmac_configured = 1; 395 printf("mapping Audio 1 DMA using I/O space at 0x%lx\n", 396 (unsigned long)addr); 397 398 return; 399 } 400 401 printf("can't map Audio 1 DMA into I/O space\n"); 402 } 403 404 static void 405 eso_write_cmd(sc, cmd) 406 struct eso_softc *sc; 407 uint8_t cmd; 408 { 409 int i; 410 411 /* Poll for busy indicator to become clear. */ 412 for (i = 0; i < ESO_WDR_TIMEOUT; i++) { 413 if ((bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RSR) 414 & ESO_SB_RSR_BUSY) == 0) { 415 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, 416 ESO_SB_WDR, cmd); 417 return; 418 } else { 419 delay(10); 420 } 421 } 422 423 printf("%s: WDR timeout\n", sc->sc_dev.dv_xname); 424 return; 425 } 426 427 /* Write to a controller register */ 428 static void 429 eso_write_ctlreg(sc, reg, val) 430 struct eso_softc *sc; 431 uint8_t reg, val; 432 { 433 434 /* DPRINTF(("ctlreg 0x%02x = 0x%02x\n", reg, val)); */ 435 436 eso_write_cmd(sc, reg); 437 eso_write_cmd(sc, val); 438 } 439 440 /* Read out the Read Data Register */ 441 static uint8_t 442 eso_read_rdr(sc) 443 struct eso_softc *sc; 444 { 445 int i; 446 447 for (i = 0; i < ESO_RDR_TIMEOUT; i++) { 448 if (bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, 449 ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) { 450 return (bus_space_read_1(sc->sc_sb_iot, 451 sc->sc_sb_ioh, ESO_SB_RDR)); 452 } else { 453 delay(10); 454 } 455 } 456 457 printf("%s: RDR timeout\n", sc->sc_dev.dv_xname); 458 return (-1); 459 } 460 461 462 static uint8_t 463 eso_read_ctlreg(sc, reg) 464 struct eso_softc *sc; 465 uint8_t reg; 466 { 467 468 eso_write_cmd(sc, ESO_CMD_RCR); 469 eso_write_cmd(sc, reg); 470 return (eso_read_rdr(sc)); 471 } 472 473 static void 474 eso_write_mixreg(sc, reg, val) 475 struct eso_softc *sc; 476 uint8_t reg, val; 477 { 478 int s; 479 480 /* DPRINTF(("mixreg 0x%02x = 0x%02x\n", reg, val)); */ 481 482 s = splaudio(); 483 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg); 484 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA, val); 485 splx(s); 486 } 487 488 static uint8_t 489 eso_read_mixreg(sc, reg) 490 struct eso_softc *sc; 491 uint8_t reg; 492 { 493 int s; 494 uint8_t val; 495 496 s = splaudio(); 497 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg); 498 val = bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA); 499 splx(s); 500 501 return (val); 502 } 503 504 static int 505 eso_intr(hdl) 506 void *hdl; 507 { 508 struct eso_softc *sc = hdl; 509 uint8_t irqctl; 510 511 irqctl = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL); 512 513 /* If it wasn't ours, that's all she wrote. */ 514 if ((irqctl & (ESO_IO_IRQCTL_A1IRQ | ESO_IO_IRQCTL_A2IRQ)) == 0) 515 return (0); 516 517 if (irqctl & ESO_IO_IRQCTL_A1IRQ) { 518 /* Clear interrupt. */ 519 (void)bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, 520 ESO_SB_RBSR); 521 522 if (sc->sc_rintr) 523 sc->sc_rintr(sc->sc_rarg); 524 else 525 wakeup(&sc->sc_rintr); 526 } 527 528 if (irqctl & ESO_IO_IRQCTL_A2IRQ) { 529 /* 530 * Clear the A2 IRQ latch: the cached value reflects the 531 * current DAC settings with the IRQ latch bit not set. 532 */ 533 eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2); 534 535 if (sc->sc_pintr) 536 sc->sc_pintr(sc->sc_parg); 537 else 538 wakeup(&sc->sc_pintr); 539 } 540 541 #if 0 542 if ((irqctl & ESO_IO_IRQCTL_MPUIRQ) && sc->sc_mpudev != 0) 543 mpu_intr(sc->sc_mpudev); 544 #endif 545 546 return (1); 547 } 548 549 /* Perform a software reset, including DMA FIFOs. */ 550 static int 551 eso_reset(sc) 552 struct eso_softc *sc; 553 { 554 int i; 555 556 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET, 557 ESO_SB_RESET_SW | ESO_SB_RESET_FIFO); 558 /* `Delay' suggested in the data sheet. */ 559 (void)bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_STATUS); 560 bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET, 0); 561 562 /* Wait for reset to take effect. */ 563 for (i = 0; i < ESO_RESET_TIMEOUT; i++) { 564 /* Poll for data to become available. */ 565 if ((bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, 566 ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) != 0 && 567 bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, 568 ESO_SB_RDR) == ESO_SB_RDR_RESETMAGIC) { 569 570 /* Activate Solo-1 extension commands. */ 571 eso_write_cmd(sc, ESO_CMD_EXTENB); 572 /* Reset mixer registers. */ 573 eso_write_mixreg(sc, ESO_MIXREG_RESET, 574 ESO_MIXREG_RESET_RESET); 575 576 return (0); 577 } else { 578 delay(1000); 579 } 580 } 581 582 printf("%s: reset timeout\n", sc->sc_dev.dv_xname); 583 return (-1); 584 } 585 586 587 /* ARGSUSED */ 588 static int 589 eso_open(hdl, flags) 590 void *hdl; 591 int flags; 592 { 593 struct eso_softc *sc = hdl; 594 595 DPRINTF(("%s: open\n", sc->sc_dev.dv_xname)); 596 597 sc->sc_pintr = NULL; 598 sc->sc_rintr = NULL; 599 600 return (0); 601 } 602 603 static void 604 eso_close(hdl) 605 void *hdl; 606 { 607 608 DPRINTF(("%s: close\n", ((struct eso_softc *)hdl)->sc_dev.dv_xname)); 609 } 610 611 static int 612 eso_query_encoding(hdl, fp) 613 void *hdl; 614 struct audio_encoding *fp; 615 { 616 617 switch (fp->index) { 618 case 0: 619 strcpy(fp->name, AudioEulinear); 620 fp->encoding = AUDIO_ENCODING_ULINEAR; 621 fp->precision = 8; 622 fp->flags = 0; 623 break; 624 case 1: 625 strcpy(fp->name, AudioEmulaw); 626 fp->encoding = AUDIO_ENCODING_ULAW; 627 fp->precision = 8; 628 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 629 break; 630 case 2: 631 strcpy(fp->name, AudioEalaw); 632 fp->encoding = AUDIO_ENCODING_ALAW; 633 fp->precision = 8; 634 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 635 break; 636 case 3: 637 strcpy(fp->name, AudioEslinear); 638 fp->encoding = AUDIO_ENCODING_SLINEAR; 639 fp->precision = 8; 640 fp->flags = 0; 641 break; 642 case 4: 643 strcpy(fp->name, AudioEslinear_le); 644 fp->encoding = AUDIO_ENCODING_SLINEAR_LE; 645 fp->precision = 16; 646 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 647 break; 648 case 5: 649 strcpy(fp->name, AudioEulinear_le); 650 fp->encoding = AUDIO_ENCODING_ULINEAR_LE; 651 fp->precision = 16; 652 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 653 break; 654 case 6: 655 strcpy(fp->name, AudioEslinear_be); 656 fp->encoding = AUDIO_ENCODING_SLINEAR_BE; 657 fp->precision = 16; 658 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 659 break; 660 case 7: 661 strcpy(fp->name, AudioEulinear_be); 662 fp->encoding = AUDIO_ENCODING_ULINEAR_BE; 663 fp->precision = 16; 664 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 665 break; 666 default: 667 return (EINVAL); 668 } 669 670 return (0); 671 } 672 673 static int 674 eso_set_params(hdl, setmode, usemode, play, rec) 675 void *hdl; 676 int setmode, usemode; 677 struct audio_params *play, *rec; 678 { 679 struct eso_softc *sc = hdl; 680 struct audio_params *p; 681 int mode, r[2], rd[2], clk; 682 unsigned int srg, fltdiv; 683 684 for (mode = AUMODE_RECORD; mode != -1; 685 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) { 686 if ((setmode & mode) == 0) 687 continue; 688 689 p = (mode == AUMODE_PLAY) ? play : rec; 690 691 if (p->sample_rate < ESO_MINRATE || 692 p->sample_rate > ESO_MAXRATE || 693 (p->precision != 8 && p->precision != 16) || 694 (p->channels != 1 && p->channels != 2)) 695 return (EINVAL); 696 697 p->factor = 1; 698 p->sw_code = NULL; 699 switch (p->encoding) { 700 case AUDIO_ENCODING_SLINEAR_BE: 701 case AUDIO_ENCODING_ULINEAR_BE: 702 if (mode == AUMODE_PLAY && p->precision == 16) 703 p->sw_code = swap_bytes; 704 break; 705 case AUDIO_ENCODING_SLINEAR_LE: 706 case AUDIO_ENCODING_ULINEAR_LE: 707 if (mode == AUMODE_RECORD && p->precision == 16) 708 p->sw_code = swap_bytes; 709 break; 710 case AUDIO_ENCODING_ULAW: 711 if (mode == AUMODE_PLAY) { 712 p->factor = 2; 713 p->sw_code = mulaw_to_ulinear16; 714 } else { 715 p->sw_code = ulinear8_to_mulaw; 716 } 717 break; 718 case AUDIO_ENCODING_ALAW: 719 if (mode == AUMODE_PLAY) { 720 p->factor = 2; 721 p->sw_code = alaw_to_ulinear16; 722 } else { 723 p->sw_code = ulinear8_to_alaw; 724 } 725 break; 726 default: 727 return (EINVAL); 728 } 729 730 /* 731 * We'll compute both possible sample rate dividers and pick 732 * the one with the least error. 733 */ 734 #define ABS(x) ((x) < 0 ? -(x) : (x)) 735 r[0] = ESO_CLK0 / 736 (128 - (rd[0] = 128 - ESO_CLK0 / p->sample_rate)); 737 r[1] = ESO_CLK1 / 738 (128 - (rd[1] = 128 - ESO_CLK1 / p->sample_rate)); 739 740 clk = ABS(p->sample_rate - r[0]) > ABS(p->sample_rate - r[1]); 741 srg = rd[clk] | (clk == 1 ? ESO_CLK1_SELECT : 0x00); 742 743 /* Roll-off frequency of 87%, as in the ES1888 driver. */ 744 fltdiv = 256 - 200279L / p->sample_rate; 745 746 /* Update to reflect the possibly inexact rate. */ 747 p->sample_rate = r[clk]; 748 749 if (mode == AUMODE_RECORD) { 750 /* Audio 1 */ 751 DPRINTF(("A1 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv)); 752 eso_write_ctlreg(sc, ESO_CTLREG_SRG, srg); 753 eso_write_ctlreg(sc, ESO_CTLREG_FLTDIV, fltdiv); 754 } else { 755 /* Audio 2 */ 756 DPRINTF(("A2 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv)); 757 eso_write_mixreg(sc, ESO_MIXREG_A2SRG, srg); 758 eso_write_mixreg(sc, ESO_MIXREG_A2FLTDIV, fltdiv); 759 } 760 #undef ABS 761 762 } 763 764 return (0); 765 } 766 767 static int 768 eso_round_blocksize(hdl, blk) 769 void *hdl; 770 int blk; 771 { 772 773 return (blk & -32); /* keep good alignment; at least 16 req'd */ 774 } 775 776 static int 777 eso_halt_output(hdl) 778 void *hdl; 779 { 780 struct eso_softc *sc = hdl; 781 int error, s; 782 783 DPRINTF(("%s: halt_output\n", sc->sc_dev.dv_xname)); 784 785 /* 786 * Disable auto-initialize DMA, allowing the FIFO to drain and then 787 * stop. The interrupt callback pointer is cleared at this 788 * point so that an outstanding FIFO interrupt for the remaining data 789 * will be acknowledged without further processing. 790 * 791 * This does not immediately `abort' an operation in progress (c.f. 792 * audio(9)) but is the method to leave the FIFO behind in a clean 793 * state with the least hair. (Besides, that item needs to be 794 * rephrased for trigger_*()-based DMA environments.) 795 */ 796 s = splaudio(); 797 eso_write_mixreg(sc, ESO_MIXREG_A2C1, 798 ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB); 799 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 800 ESO_IO_A2DMAM_DMAENB); 801 802 sc->sc_pintr = NULL; 803 error = tsleep(&sc->sc_pintr, PCATCH | PWAIT, "esoho", hz); 804 splx(s); 805 806 /* Shut down DMA completely. */ 807 eso_write_mixreg(sc, ESO_MIXREG_A2C1, 0); 808 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 0); 809 810 return (error == EWOULDBLOCK ? 0 : error); 811 } 812 813 static int 814 eso_halt_input(hdl) 815 void *hdl; 816 { 817 struct eso_softc *sc = hdl; 818 int error, s; 819 820 DPRINTF(("%s: halt_input\n", sc->sc_dev.dv_xname)); 821 822 /* Just like eso_halt_output(), but for Audio 1. */ 823 s = splaudio(); 824 eso_write_ctlreg(sc, ESO_CTLREG_A1C2, 825 ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC | 826 ESO_CTLREG_A1C2_DMAENB); 827 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE, 828 DMA37MD_WRITE | DMA37MD_DEMAND); 829 830 sc->sc_rintr = NULL; 831 error = tsleep(&sc->sc_rintr, PCATCH | PWAIT, "esohi", hz); 832 splx(s); 833 834 /* Shut down DMA completely. */ 835 eso_write_ctlreg(sc, ESO_CTLREG_A1C2, 836 ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC); 837 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK, 838 ESO_DMAC_MASK_MASK); 839 840 return (error == EWOULDBLOCK ? 0 : error); 841 } 842 843 /* ARGSUSED */ 844 static int 845 eso_getdev(hdl, retp) 846 void *hdl; 847 struct audio_device *retp; 848 { 849 struct eso_softc *sc = hdl; 850 851 strncpy(retp->name, "ESS Solo-1", sizeof (retp->name)); 852 snprintf(retp->version, sizeof (retp->version), "0x%02x", 853 sc->sc_revision); 854 if (sc->sc_revision <= 855 sizeof (eso_rev2model) / sizeof (eso_rev2model[0])) 856 strncpy(retp->config, eso_rev2model[sc->sc_revision], 857 sizeof (retp->config)); 858 else 859 strncpy(retp->config, "unknown", sizeof (retp->config)); 860 861 return (0); 862 } 863 864 static int 865 eso_set_port(hdl, cp) 866 void *hdl; 867 mixer_ctrl_t *cp; 868 { 869 struct eso_softc *sc = hdl; 870 unsigned int lgain, rgain; 871 uint8_t tmp; 872 873 switch (cp->dev) { 874 case ESO_DAC_PLAY_VOL: 875 case ESO_MIC_PLAY_VOL: 876 case ESO_LINE_PLAY_VOL: 877 case ESO_SYNTH_PLAY_VOL: 878 case ESO_CD_PLAY_VOL: 879 case ESO_AUXB_PLAY_VOL: 880 case ESO_RECORD_VOL: 881 case ESO_DAC_REC_VOL: 882 case ESO_MIC_REC_VOL: 883 case ESO_LINE_REC_VOL: 884 case ESO_SYNTH_REC_VOL: 885 case ESO_CD_REC_VOL: 886 case ESO_AUXB_REC_VOL: 887 if (cp->type != AUDIO_MIXER_VALUE) 888 return (EINVAL); 889 890 /* 891 * Stereo-capable mixer ports: if we get a single-channel 892 * gain value passed in, then we duplicate it to both left 893 * and right channels. 894 */ 895 switch (cp->un.value.num_channels) { 896 case 1: 897 lgain = rgain = ESO_GAIN_TO_4BIT( 898 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]); 899 break; 900 case 2: 901 lgain = ESO_GAIN_TO_4BIT( 902 cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]); 903 rgain = ESO_GAIN_TO_4BIT( 904 cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]); 905 break; 906 default: 907 return (EINVAL); 908 } 909 910 sc->sc_gain[cp->dev][ESO_LEFT] = lgain; 911 sc->sc_gain[cp->dev][ESO_RIGHT] = rgain; 912 eso_set_gain(sc, cp->dev); 913 break; 914 915 case ESO_MASTER_VOL: 916 if (cp->type != AUDIO_MIXER_VALUE) 917 return (EINVAL); 918 919 /* Like above, but a precision of 6 bits. */ 920 switch (cp->un.value.num_channels) { 921 case 1: 922 lgain = rgain = ESO_GAIN_TO_6BIT( 923 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]); 924 break; 925 case 2: 926 lgain = ESO_GAIN_TO_6BIT( 927 cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]); 928 rgain = ESO_GAIN_TO_6BIT( 929 cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]); 930 break; 931 default: 932 return (EINVAL); 933 } 934 935 sc->sc_gain[cp->dev][ESO_LEFT] = lgain; 936 sc->sc_gain[cp->dev][ESO_RIGHT] = rgain; 937 eso_set_gain(sc, cp->dev); 938 break; 939 940 case ESO_SPATIALIZER: 941 if (cp->type != AUDIO_MIXER_VALUE || 942 cp->un.value.num_channels != 1) 943 return (EINVAL); 944 945 sc->sc_gain[cp->dev][ESO_LEFT] = 946 sc->sc_gain[cp->dev][ESO_RIGHT] = 947 ESO_GAIN_TO_6BIT( 948 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]); 949 eso_set_gain(sc, cp->dev); 950 break; 951 952 case ESO_MONO_PLAY_VOL: 953 case ESO_MONO_REC_VOL: 954 if (cp->type != AUDIO_MIXER_VALUE || 955 cp->un.value.num_channels != 1) 956 return (EINVAL); 957 958 sc->sc_gain[cp->dev][ESO_LEFT] = 959 sc->sc_gain[cp->dev][ESO_RIGHT] = 960 ESO_GAIN_TO_4BIT( 961 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]); 962 eso_set_gain(sc, cp->dev); 963 break; 964 965 case ESO_PCSPEAKER_VOL: 966 if (cp->type != AUDIO_MIXER_VALUE || 967 cp->un.value.num_channels != 1) 968 return (EINVAL); 969 970 sc->sc_gain[cp->dev][ESO_LEFT] = 971 sc->sc_gain[cp->dev][ESO_RIGHT] = 972 ESO_GAIN_TO_3BIT( 973 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]); 974 eso_set_gain(sc, cp->dev); 975 break; 976 977 case ESO_SPATIALIZER_ENABLE: 978 if (cp->type != AUDIO_MIXER_ENUM) 979 return (EINVAL); 980 981 sc->sc_spatializer = (cp->un.ord != 0); 982 983 tmp = eso_read_mixreg(sc, ESO_MIXREG_SPAT); 984 if (sc->sc_spatializer) 985 tmp |= ESO_MIXREG_SPAT_ENB; 986 else 987 tmp &= ~ESO_MIXREG_SPAT_ENB; 988 eso_write_mixreg(sc, ESO_MIXREG_SPAT, 989 tmp | ESO_MIXREG_SPAT_RSTREL); 990 break; 991 992 case ESO_MONOOUT_SOURCE: 993 if (cp->type != AUDIO_MIXER_ENUM) 994 return (EINVAL); 995 996 sc->sc_monooutsrc = cp->un.ord; 997 998 tmp = eso_read_mixreg(sc, ESO_MIXREG_MPM); 999 tmp &= ~ESO_MIXREG_MPM_MOMASK; 1000 tmp |= sc->sc_monooutsrc; 1001 eso_write_mixreg(sc, ESO_MIXREG_MPM, tmp); 1002 break; 1003 1004 case ESO_RECORD_MONITOR: 1005 if (cp->type != AUDIO_MIXER_ENUM) 1006 return (EINVAL); 1007 1008 sc->sc_recmon = (cp->un.ord != 0); 1009 1010 tmp = eso_read_ctlreg(sc, ESO_CTLREG_ACTL); 1011 if (sc->sc_recmon) 1012 tmp |= ESO_CTLREG_ACTL_RECMON; 1013 else 1014 tmp &= ~ESO_CTLREG_ACTL_RECMON; 1015 eso_write_ctlreg(sc, ESO_CTLREG_ACTL, tmp); 1016 break; 1017 1018 case ESO_RECORD_SOURCE: 1019 if (cp->type != AUDIO_MIXER_ENUM) 1020 return (EINVAL); 1021 1022 return (eso_set_recsrc(sc, cp->un.ord)); 1023 1024 case ESO_MIC_PREAMP: 1025 if (cp->type != AUDIO_MIXER_ENUM) 1026 return (EINVAL); 1027 1028 sc->sc_preamp = (cp->un.ord != 0); 1029 1030 tmp = eso_read_mixreg(sc, ESO_MIXREG_MPM); 1031 tmp &= ~ESO_MIXREG_MPM_RESV0; 1032 if (sc->sc_preamp) 1033 tmp |= ESO_MIXREG_MPM_PREAMP; 1034 else 1035 tmp &= ~ESO_MIXREG_MPM_PREAMP; 1036 eso_write_mixreg(sc, ESO_MIXREG_MPM, tmp); 1037 break; 1038 1039 default: 1040 return (EINVAL); 1041 } 1042 1043 return (0); 1044 } 1045 1046 static int 1047 eso_get_port(hdl, cp) 1048 void *hdl; 1049 mixer_ctrl_t *cp; 1050 { 1051 struct eso_softc *sc = hdl; 1052 1053 switch (cp->dev) { 1054 case ESO_DAC_PLAY_VOL: 1055 case ESO_MIC_PLAY_VOL: 1056 case ESO_LINE_PLAY_VOL: 1057 case ESO_SYNTH_PLAY_VOL: 1058 case ESO_CD_PLAY_VOL: 1059 case ESO_AUXB_PLAY_VOL: 1060 case ESO_MASTER_VOL: 1061 case ESO_RECORD_VOL: 1062 case ESO_DAC_REC_VOL: 1063 case ESO_MIC_REC_VOL: 1064 case ESO_LINE_REC_VOL: 1065 case ESO_SYNTH_REC_VOL: 1066 case ESO_CD_REC_VOL: 1067 case ESO_AUXB_REC_VOL: 1068 /* 1069 * Stereo-capable ports: if a single-channel query is made, 1070 * just return the left channel's value (since single-channel 1071 * settings themselves are applied to both channels). 1072 */ 1073 switch (cp->un.value.num_channels) { 1074 case 1: 1075 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1076 sc->sc_gain[cp->dev][ESO_LEFT]; 1077 break; 1078 case 2: 1079 cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 1080 sc->sc_gain[cp->dev][ESO_LEFT]; 1081 cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 1082 sc->sc_gain[cp->dev][ESO_RIGHT]; 1083 break; 1084 default: 1085 return (EINVAL); 1086 } 1087 break; 1088 1089 case ESO_MONO_PLAY_VOL: 1090 case ESO_PCSPEAKER_VOL: 1091 case ESO_MONO_REC_VOL: 1092 case ESO_SPATIALIZER: 1093 if (cp->un.value.num_channels != 1) 1094 return (EINVAL); 1095 cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1096 sc->sc_gain[cp->dev][ESO_LEFT]; 1097 break; 1098 1099 case ESO_RECORD_MONITOR: 1100 cp->un.ord = sc->sc_recmon; 1101 break; 1102 1103 case ESO_RECORD_SOURCE: 1104 cp->un.ord = sc->sc_recsrc; 1105 break; 1106 1107 case ESO_MONOOUT_SOURCE: 1108 cp->un.ord = sc->sc_monooutsrc; 1109 break; 1110 1111 case ESO_SPATIALIZER_ENABLE: 1112 cp->un.ord = sc->sc_spatializer; 1113 break; 1114 1115 case ESO_MIC_PREAMP: 1116 cp->un.ord = sc->sc_preamp; 1117 break; 1118 1119 default: 1120 return (EINVAL); 1121 } 1122 1123 1124 return (0); 1125 1126 } 1127 1128 static int 1129 eso_query_devinfo(hdl, dip) 1130 void *hdl; 1131 mixer_devinfo_t *dip; 1132 { 1133 1134 switch (dip->index) { 1135 case ESO_DAC_PLAY_VOL: 1136 dip->mixer_class = ESO_INPUT_CLASS; 1137 dip->next = dip->prev = AUDIO_MIXER_LAST; 1138 strcpy(dip->label.name, AudioNdac); 1139 dip->type = AUDIO_MIXER_VALUE; 1140 dip->un.v.num_channels = 2; 1141 strcpy(dip->un.v.units.name, AudioNvolume); 1142 break; 1143 case ESO_MIC_PLAY_VOL: 1144 dip->mixer_class = ESO_INPUT_CLASS; 1145 dip->next = dip->prev = AUDIO_MIXER_LAST; 1146 strcpy(dip->label.name, AudioNmicrophone); 1147 dip->type = AUDIO_MIXER_VALUE; 1148 dip->un.v.num_channels = 2; 1149 strcpy(dip->un.v.units.name, AudioNvolume); 1150 break; 1151 case ESO_LINE_PLAY_VOL: 1152 dip->mixer_class = ESO_INPUT_CLASS; 1153 dip->next = dip->prev = AUDIO_MIXER_LAST; 1154 strcpy(dip->label.name, AudioNline); 1155 dip->type = AUDIO_MIXER_VALUE; 1156 dip->un.v.num_channels = 2; 1157 strcpy(dip->un.v.units.name, AudioNvolume); 1158 break; 1159 case ESO_SYNTH_PLAY_VOL: 1160 dip->mixer_class = ESO_INPUT_CLASS; 1161 dip->next = dip->prev = AUDIO_MIXER_LAST; 1162 strcpy(dip->label.name, AudioNfmsynth); 1163 dip->type = AUDIO_MIXER_VALUE; 1164 dip->un.v.num_channels = 2; 1165 strcpy(dip->un.v.units.name, AudioNvolume); 1166 break; 1167 case ESO_MONO_PLAY_VOL: 1168 dip->mixer_class = ESO_INPUT_CLASS; 1169 dip->next = dip->prev = AUDIO_MIXER_LAST; 1170 strcpy(dip->label.name, "mono_in"); 1171 dip->type = AUDIO_MIXER_VALUE; 1172 dip->un.v.num_channels = 1; 1173 strcpy(dip->un.v.units.name, AudioNvolume); 1174 break; 1175 case ESO_CD_PLAY_VOL: 1176 dip->mixer_class = ESO_INPUT_CLASS; 1177 dip->next = dip->prev = AUDIO_MIXER_LAST; 1178 strcpy(dip->label.name, AudioNcd); 1179 dip->type = AUDIO_MIXER_VALUE; 1180 dip->un.v.num_channels = 2; 1181 strcpy(dip->un.v.units.name, AudioNvolume); 1182 break; 1183 case ESO_AUXB_PLAY_VOL: 1184 dip->mixer_class = ESO_INPUT_CLASS; 1185 dip->next = dip->prev = AUDIO_MIXER_LAST; 1186 strcpy(dip->label.name, "auxb"); 1187 dip->type = AUDIO_MIXER_VALUE; 1188 dip->un.v.num_channels = 2; 1189 strcpy(dip->un.v.units.name, AudioNvolume); 1190 break; 1191 1192 case ESO_MIC_PREAMP: 1193 dip->mixer_class = ESO_MICROPHONE_CLASS; 1194 dip->next = dip->prev = AUDIO_MIXER_LAST; 1195 strcpy(dip->label.name, AudioNpreamp); 1196 dip->type = AUDIO_MIXER_ENUM; 1197 dip->un.e.num_mem = 2; 1198 strcpy(dip->un.e.member[0].label.name, AudioNoff); 1199 dip->un.e.member[0].ord = 0; 1200 strcpy(dip->un.e.member[1].label.name, AudioNon); 1201 dip->un.e.member[1].ord = 1; 1202 break; 1203 case ESO_MICROPHONE_CLASS: 1204 dip->mixer_class = ESO_MICROPHONE_CLASS; 1205 dip->next = dip->prev = AUDIO_MIXER_LAST; 1206 strcpy(dip->label.name, AudioNmicrophone); 1207 dip->type = AUDIO_MIXER_CLASS; 1208 break; 1209 1210 case ESO_INPUT_CLASS: 1211 dip->mixer_class = ESO_INPUT_CLASS; 1212 dip->next = dip->prev = AUDIO_MIXER_LAST; 1213 strcpy(dip->label.name, AudioCinputs); 1214 dip->type = AUDIO_MIXER_CLASS; 1215 break; 1216 1217 case ESO_MASTER_VOL: 1218 dip->mixer_class = ESO_OUTPUT_CLASS; 1219 dip->next = dip->prev = AUDIO_MIXER_LAST; 1220 strcpy(dip->label.name, AudioNmaster); 1221 dip->type = AUDIO_MIXER_VALUE; 1222 dip->un.v.num_channels = 2; 1223 strcpy(dip->un.v.units.name, AudioNvolume); 1224 break; 1225 case ESO_PCSPEAKER_VOL: 1226 dip->mixer_class = ESO_OUTPUT_CLASS; 1227 dip->next = dip->prev = AUDIO_MIXER_LAST; 1228 strcpy(dip->label.name, "pc_speaker"); 1229 dip->type = AUDIO_MIXER_VALUE; 1230 dip->un.v.num_channels = 1; 1231 strcpy(dip->un.v.units.name, AudioNvolume); 1232 break; 1233 case ESO_MONOOUT_SOURCE: 1234 dip->mixer_class = ESO_OUTPUT_CLASS; 1235 dip->next = dip->prev = AUDIO_MIXER_LAST; 1236 strcpy(dip->label.name, "mono_out"); 1237 dip->type = AUDIO_MIXER_ENUM; 1238 dip->un.e.num_mem = 3; 1239 strcpy(dip->un.e.member[0].label.name, AudioNmute); 1240 dip->un.e.member[0].ord = ESO_MIXREG_MPM_MOMUTE; 1241 strcpy(dip->un.e.member[1].label.name, AudioNdac); 1242 dip->un.e.member[1].ord = ESO_MIXREG_MPM_MOA2R; 1243 strcpy(dip->un.e.member[2].label.name, AudioNmixerout); 1244 dip->un.e.member[2].ord = ESO_MIXREG_MPM_MOREC; 1245 break; 1246 case ESO_SPATIALIZER: 1247 dip->mixer_class = ESO_OUTPUT_CLASS; 1248 dip->prev = AUDIO_MIXER_LAST; 1249 dip->next = ESO_SPATIALIZER_ENABLE; 1250 strcpy(dip->label.name, AudioNspatial); 1251 dip->type = AUDIO_MIXER_VALUE; 1252 dip->un.v.num_channels = 1; 1253 strcpy(dip->un.v.units.name, "level"); 1254 break; 1255 case ESO_SPATIALIZER_ENABLE: 1256 dip->mixer_class = ESO_OUTPUT_CLASS; 1257 dip->prev = ESO_SPATIALIZER; 1258 dip->next = AUDIO_MIXER_LAST; 1259 strcpy(dip->label.name, "enable"); 1260 dip->type = AUDIO_MIXER_ENUM; 1261 dip->un.e.num_mem = 2; 1262 strcpy(dip->un.e.member[0].label.name, AudioNoff); 1263 dip->un.e.member[0].ord = 0; 1264 strcpy(dip->un.e.member[1].label.name, AudioNon); 1265 dip->un.e.member[1].ord = 1; 1266 break; 1267 1268 case ESO_OUTPUT_CLASS: 1269 dip->mixer_class = ESO_OUTPUT_CLASS; 1270 dip->next = dip->prev = AUDIO_MIXER_LAST; 1271 strcpy(dip->label.name, AudioCoutputs); 1272 dip->type = AUDIO_MIXER_CLASS; 1273 break; 1274 1275 case ESO_RECORD_MONITOR: 1276 dip->mixer_class = ESO_MONITOR_CLASS; 1277 dip->next = dip->prev = AUDIO_MIXER_LAST; 1278 strcpy(dip->label.name, AudioNmute); 1279 dip->type = AUDIO_MIXER_ENUM; 1280 dip->un.e.num_mem = 2; 1281 strcpy(dip->un.e.member[0].label.name, AudioNoff); 1282 dip->un.e.member[0].ord = 0; 1283 strcpy(dip->un.e.member[1].label.name, AudioNon); 1284 dip->un.e.member[1].ord = 1; 1285 break; 1286 case ESO_MONITOR_CLASS: 1287 dip->mixer_class = ESO_MONITOR_CLASS; 1288 dip->next = dip->prev = AUDIO_MIXER_LAST; 1289 strcpy(dip->label.name, AudioCmonitor); 1290 dip->type = AUDIO_MIXER_CLASS; 1291 break; 1292 1293 case ESO_RECORD_VOL: 1294 dip->mixer_class = ESO_RECORD_CLASS; 1295 dip->next = dip->prev = AUDIO_MIXER_LAST; 1296 strcpy(dip->label.name, AudioNrecord); 1297 dip->type = AUDIO_MIXER_VALUE; 1298 strcpy(dip->un.v.units.name, AudioNvolume); 1299 break; 1300 case ESO_RECORD_SOURCE: 1301 dip->mixer_class = ESO_RECORD_CLASS; 1302 dip->next = dip->prev = AUDIO_MIXER_LAST; 1303 strcpy(dip->label.name, AudioNsource); 1304 dip->type = AUDIO_MIXER_ENUM; 1305 dip->un.e.num_mem = 4; 1306 strcpy(dip->un.e.member[0].label.name, AudioNmicrophone); 1307 dip->un.e.member[0].ord = ESO_MIXREG_ERS_MIC; 1308 strcpy(dip->un.e.member[1].label.name, AudioNline); 1309 dip->un.e.member[1].ord = ESO_MIXREG_ERS_LINE; 1310 strcpy(dip->un.e.member[2].label.name, AudioNcd); 1311 dip->un.e.member[2].ord = ESO_MIXREG_ERS_CD; 1312 strcpy(dip->un.e.member[3].label.name, AudioNmixerout); 1313 dip->un.e.member[3].ord = ESO_MIXREG_ERS_MIXER; 1314 break; 1315 case ESO_DAC_REC_VOL: 1316 dip->mixer_class = ESO_RECORD_CLASS; 1317 dip->next = dip->prev = AUDIO_MIXER_LAST; 1318 strcpy(dip->label.name, AudioNdac); 1319 dip->type = AUDIO_MIXER_VALUE; 1320 dip->un.v.num_channels = 2; 1321 strcpy(dip->un.v.units.name, AudioNvolume); 1322 break; 1323 case ESO_MIC_REC_VOL: 1324 dip->mixer_class = ESO_RECORD_CLASS; 1325 dip->next = dip->prev = AUDIO_MIXER_LAST; 1326 strcpy(dip->label.name, AudioNmicrophone); 1327 dip->type = AUDIO_MIXER_VALUE; 1328 dip->un.v.num_channels = 2; 1329 strcpy(dip->un.v.units.name, AudioNvolume); 1330 break; 1331 case ESO_LINE_REC_VOL: 1332 dip->mixer_class = ESO_RECORD_CLASS; 1333 dip->next = dip->prev = AUDIO_MIXER_LAST; 1334 strcpy(dip->label.name, AudioNline); 1335 dip->type = AUDIO_MIXER_VALUE; 1336 dip->un.v.num_channels = 2; 1337 strcpy(dip->un.v.units.name, AudioNvolume); 1338 break; 1339 case ESO_SYNTH_REC_VOL: 1340 dip->mixer_class = ESO_RECORD_CLASS; 1341 dip->next = dip->prev = AUDIO_MIXER_LAST; 1342 strcpy(dip->label.name, AudioNfmsynth); 1343 dip->type = AUDIO_MIXER_VALUE; 1344 dip->un.v.num_channels = 2; 1345 strcpy(dip->un.v.units.name, AudioNvolume); 1346 break; 1347 case ESO_MONO_REC_VOL: 1348 dip->mixer_class = ESO_RECORD_CLASS; 1349 dip->next = dip->prev = AUDIO_MIXER_LAST; 1350 strcpy(dip->label.name, "mono_in"); 1351 dip->type = AUDIO_MIXER_VALUE; 1352 dip->un.v.num_channels = 1; /* No lies */ 1353 strcpy(dip->un.v.units.name, AudioNvolume); 1354 break; 1355 case ESO_CD_REC_VOL: 1356 dip->mixer_class = ESO_RECORD_CLASS; 1357 dip->next = dip->prev = AUDIO_MIXER_LAST; 1358 strcpy(dip->label.name, AudioNcd); 1359 dip->type = AUDIO_MIXER_VALUE; 1360 dip->un.v.num_channels = 2; 1361 strcpy(dip->un.v.units.name, AudioNvolume); 1362 break; 1363 case ESO_AUXB_REC_VOL: 1364 dip->mixer_class = ESO_RECORD_CLASS; 1365 dip->next = dip->prev = AUDIO_MIXER_LAST; 1366 strcpy(dip->label.name, "auxb"); 1367 dip->type = AUDIO_MIXER_VALUE; 1368 dip->un.v.num_channels = 2; 1369 strcpy(dip->un.v.units.name, AudioNvolume); 1370 break; 1371 case ESO_RECORD_CLASS: 1372 dip->mixer_class = ESO_RECORD_CLASS; 1373 dip->next = dip->prev = AUDIO_MIXER_LAST; 1374 strcpy(dip->label.name, AudioCrecord); 1375 dip->type = AUDIO_MIXER_CLASS; 1376 break; 1377 1378 default: 1379 return (ENXIO); 1380 } 1381 1382 return (0); 1383 } 1384 1385 static int 1386 eso_allocmem(sc, size, align, boundary, flags, ed) 1387 struct eso_softc *sc; 1388 size_t size; 1389 size_t align; 1390 size_t boundary; 1391 int flags; 1392 struct eso_dma *ed; 1393 { 1394 int error, wait; 1395 1396 wait = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK; 1397 ed->ed_size = size; 1398 1399 error = bus_dmamem_alloc(sc->sc_dmat, ed->ed_size, align, boundary, 1400 ed->ed_segs, sizeof (ed->ed_segs) / sizeof (ed->ed_segs[0]), 1401 &ed->ed_nsegs, wait); 1402 if (error) 1403 goto out; 1404 1405 error = bus_dmamem_map(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs, 1406 ed->ed_size, &ed->ed_addr, wait | BUS_DMA_COHERENT); 1407 if (error) 1408 goto free; 1409 1410 error = bus_dmamap_create(sc->sc_dmat, ed->ed_size, 1, ed->ed_size, 0, 1411 wait, &ed->ed_map); 1412 if (error) 1413 goto unmap; 1414 1415 error = bus_dmamap_load(sc->sc_dmat, ed->ed_map, ed->ed_addr, 1416 ed->ed_size, NULL, wait); 1417 if (error) 1418 goto destroy; 1419 1420 return (0); 1421 1422 destroy: 1423 bus_dmamap_destroy(sc->sc_dmat, ed->ed_map); 1424 unmap: 1425 bus_dmamem_unmap(sc->sc_dmat, ed->ed_addr, ed->ed_size); 1426 free: 1427 bus_dmamem_free(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs); 1428 out: 1429 return (error); 1430 } 1431 1432 static void 1433 eso_freemem(sc, ed) 1434 struct eso_softc *sc; 1435 struct eso_dma *ed; 1436 { 1437 1438 bus_dmamap_unload(sc->sc_dmat, ed->ed_map); 1439 bus_dmamap_destroy(sc->sc_dmat, ed->ed_map); 1440 bus_dmamem_unmap(sc->sc_dmat, ed->ed_addr, ed->ed_size); 1441 bus_dmamem_free(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs); 1442 } 1443 1444 static void * 1445 eso_allocm(hdl, direction, size, type, flags) 1446 void *hdl; 1447 int direction; 1448 size_t size; 1449 int type, flags; 1450 { 1451 struct eso_softc *sc = hdl; 1452 struct eso_dma *ed; 1453 size_t boundary; 1454 int error; 1455 1456 if ((ed = malloc(size, type, flags)) == NULL) 1457 return (NULL); 1458 1459 /* 1460 * Apparently the Audio 1 DMA controller's current address 1461 * register can't roll over a 64K address boundary, so we have to 1462 * take care of that ourselves. The second channel DMA controller 1463 * doesn't have that restriction, however. 1464 */ 1465 if (direction == AUMODE_RECORD) 1466 boundary = 0x10000; 1467 else 1468 boundary = 0; 1469 1470 error = eso_allocmem(sc, size, 32, boundary, flags, ed); 1471 if (error) { 1472 free(ed, type); 1473 return (NULL); 1474 } 1475 ed->ed_next = sc->sc_dmas; 1476 sc->sc_dmas = ed; 1477 1478 return (KVADDR(ed)); 1479 } 1480 1481 static void 1482 eso_freem(hdl, addr, type) 1483 void *hdl; 1484 void *addr; 1485 int type; 1486 { 1487 struct eso_softc *sc; 1488 struct eso_dma *p, **pp; 1489 1490 for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &p->ed_next) { 1491 if (KVADDR(p) == addr) { 1492 eso_freemem(sc, p); 1493 *pp = p->ed_next; 1494 free(p, type); 1495 return; 1496 } 1497 } 1498 } 1499 1500 static size_t 1501 eso_round_buffersize(hdl, direction, bufsize) 1502 void *hdl; 1503 int direction; 1504 size_t bufsize; 1505 { 1506 1507 /* 64K restriction: ISA at eleven? */ 1508 if (bufsize > 65536) 1509 bufsize = 65536; 1510 1511 return (bufsize); 1512 } 1513 1514 static int 1515 eso_mappage(hdl, addr, offs, prot) 1516 void *hdl; 1517 void *addr; 1518 int offs; 1519 int prot; 1520 { 1521 struct eso_softc *sc = hdl; 1522 struct eso_dma *ed; 1523 1524 if (offs < 0) 1525 return (-1); 1526 for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) == addr; 1527 ed = ed->ed_next) 1528 ; 1529 if (ed == NULL) 1530 return (-1); 1531 1532 return (bus_dmamem_mmap(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs, 1533 offs, prot, BUS_DMA_WAITOK)); 1534 } 1535 1536 /* ARGSUSED */ 1537 static int 1538 eso_get_props(hdl) 1539 void *hdl; 1540 { 1541 1542 return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | 1543 AUDIO_PROP_FULLDUPLEX); 1544 } 1545 1546 static int 1547 eso_trigger_output(hdl, start, end, blksize, intr, arg, param) 1548 void *hdl; 1549 void *start, *end; 1550 int blksize; 1551 void (*intr) __P((void *)); 1552 void *arg; 1553 struct audio_params *param; 1554 { 1555 struct eso_softc *sc = hdl; 1556 struct eso_dma *ed; 1557 uint8_t a2c1; 1558 1559 DPRINTF(( 1560 "%s: trigger_output: start %p, end %p, blksize %d, intr %p(%p)\n", 1561 sc->sc_dev.dv_xname, start, end, blksize, intr, arg)); 1562 DPRINTF(("%s: param: rate %lu, encoding %u, precision %u, channels %u, sw_code %p, factor %d\n", 1563 sc->sc_dev.dv_xname, param->sample_rate, param->encoding, 1564 param->precision, param->channels, param->sw_code, param->factor)); 1565 1566 /* Find DMA buffer. */ 1567 for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) != start; 1568 ed = ed->ed_next) 1569 ; 1570 if (ed == NULL) { 1571 printf("%s: trigger_output: bad addr %p\n", 1572 sc->sc_dev.dv_xname, start); 1573 return (EINVAL); 1574 } 1575 1576 sc->sc_pintr = intr; 1577 sc->sc_parg = arg; 1578 1579 /* DMA transfer count (in `words'!) reload using 2's complement. */ 1580 blksize = -(blksize >> 1); 1581 eso_write_mixreg(sc, ESO_MIXREG_A2TCRLO, blksize & 0xff); 1582 eso_write_mixreg(sc, ESO_MIXREG_A2TCRHI, blksize >> 8); 1583 1584 /* Update DAC to reflect DMA count and audio parameters. */ 1585 /* Note: we cache A2C2 in order to avoid r/m/w at interrupt time. */ 1586 if (param->precision * param->factor == 16) 1587 sc->sc_a2c2 |= ESO_MIXREG_A2C2_16BIT; 1588 else 1589 sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_16BIT; 1590 if (param->channels == 2) 1591 sc->sc_a2c2 |= ESO_MIXREG_A2C2_STEREO; 1592 else 1593 sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_STEREO; 1594 if (param->encoding == AUDIO_ENCODING_SLINEAR_BE || 1595 param->encoding == AUDIO_ENCODING_SLINEAR_LE) 1596 sc->sc_a2c2 |= ESO_MIXREG_A2C2_SIGNED; 1597 else 1598 sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_SIGNED; 1599 /* Unmask IRQ. */ 1600 sc->sc_a2c2 |= ESO_MIXREG_A2C2_IRQM; 1601 eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2); 1602 1603 /* Set up DMA controller. */ 1604 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAA, 1605 htopci(DMAADDR(ed))); 1606 bus_space_write_2(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAC, 1607 htopci((uint8_t *)end - (uint8_t *)start)); 1608 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 1609 ESO_IO_A2DMAM_DMAENB | ESO_IO_A2DMAM_AUTO); 1610 1611 /* Start DMA. */ 1612 a2c1 = eso_read_mixreg(sc, ESO_MIXREG_A2C1); 1613 a2c1 &= ~ESO_MIXREG_A2C1_RESV0; /* Paranoia? XXX bit 5 */ 1614 a2c1 |= ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB | 1615 ESO_MIXREG_A2C1_AUTO; 1616 eso_write_mixreg(sc, ESO_MIXREG_A2C1, a2c1); 1617 1618 return (0); 1619 } 1620 1621 static int 1622 eso_trigger_input(hdl, start, end, blksize, intr, arg, param) 1623 void *hdl; 1624 void *start, *end; 1625 int blksize; 1626 void (*intr) __P((void *)); 1627 void *arg; 1628 struct audio_params *param; 1629 { 1630 struct eso_softc *sc = hdl; 1631 struct eso_dma *ed; 1632 uint8_t actl, a1c1; 1633 1634 DPRINTF(( 1635 "%s: trigger_input: start %p, end %p, blksize %d, intr %p(%p)\n", 1636 sc->sc_dev.dv_xname, start, end, blksize, intr, arg)); 1637 DPRINTF(("%s: param: rate %lu, encoding %u, precision %u, channels %u, sw_code %p, factor %d\n", 1638 sc->sc_dev.dv_xname, param->sample_rate, param->encoding, 1639 param->precision, param->channels, param->sw_code, param->factor)); 1640 1641 /* 1642 * If we failed to configure the Audio 1 DMA controller, bail here 1643 * while retaining availability of the DAC direction (in Audio 2). 1644 */ 1645 if (!sc->sc_dmac_configured) 1646 return (EIO); 1647 1648 /* Find DMA buffer. */ 1649 for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) != start; 1650 ed = ed->ed_next) 1651 ; 1652 if (ed == NULL) { 1653 printf("%s: trigger_output: bad addr %p\n", 1654 sc->sc_dev.dv_xname, start); 1655 return (EINVAL); 1656 } 1657 1658 sc->sc_rintr = intr; 1659 sc->sc_rarg = arg; 1660 1661 /* Set up ADC DMA converter parameters. */ 1662 actl = eso_read_ctlreg(sc, ESO_CTLREG_ACTL); 1663 if (param->channels == 2) { 1664 actl &= ~ESO_CTLREG_ACTL_MONO; 1665 actl |= ESO_CTLREG_ACTL_STEREO; 1666 } else { 1667 actl &= ~ESO_CTLREG_ACTL_STEREO; 1668 actl |= ESO_CTLREG_ACTL_MONO; 1669 } 1670 eso_write_ctlreg(sc, ESO_CTLREG_ACTL, actl); 1671 1672 /* Set up Transfer Type: maybe move to attach time? */ 1673 eso_write_ctlreg(sc, ESO_CTLREG_A1TT, ESO_CTLREG_A1TT_DEMAND4); 1674 1675 /* DMA transfer count reload using 2's complement. */ 1676 blksize = -blksize; 1677 eso_write_ctlreg(sc, ESO_CTLREG_A1TCRLO, blksize & 0xff); 1678 eso_write_ctlreg(sc, ESO_CTLREG_A1TCRHI, blksize >> 8); 1679 1680 /* Set up and enable Audio 1 DMA FIFO. */ 1681 a1c1 = ESO_CTLREG_A1C1_RESV1 | ESO_CTLREG_A1C1_FIFOENB; 1682 if (param->precision * param->factor == 16) 1683 a1c1 |= ESO_CTLREG_A1C1_16BIT; 1684 if (param->channels == 2) 1685 a1c1 |= ESO_CTLREG_A1C1_STEREO; 1686 else 1687 a1c1 |= ESO_CTLREG_A1C1_MONO; 1688 if (param->encoding == AUDIO_ENCODING_SLINEAR_BE || 1689 param->encoding == AUDIO_ENCODING_SLINEAR_LE) 1690 a1c1 |= ESO_CTLREG_A1C1_SIGNED; 1691 eso_write_ctlreg(sc, ESO_CTLREG_A1C1, a1c1); 1692 1693 /* Set up ADC IRQ/DRQ parameters. */ 1694 eso_write_ctlreg(sc, ESO_CTLREG_LAIC, 1695 ESO_CTLREG_LAIC_PINENB | ESO_CTLREG_LAIC_EXTENB); 1696 eso_write_ctlreg(sc, ESO_CTLREG_DRQCTL, 1697 ESO_CTLREG_DRQCTL_ENB1 | ESO_CTLREG_DRQCTL_EXTENB); 1698 1699 /* Set up and enable DMA controller. */ 1700 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_CLEAR, 0); 1701 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK, 1702 ESO_DMAC_MASK_MASK); 1703 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE, 1704 DMA37MD_WRITE | DMA37MD_LOOP | DMA37MD_DEMAND); 1705 bus_space_write_4(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAA, 1706 htopci(DMAADDR(ed))); 1707 bus_space_write_2(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAC, 1708 htopci((uint8_t *)end - (uint8_t *)start - 1)); 1709 bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK, 0); 1710 1711 /* Start DMA. */ 1712 eso_write_ctlreg(sc, ESO_CTLREG_A1C2, 1713 ESO_CTLREG_A1C2_DMAENB | ESO_CTLREG_A1C2_READ | 1714 ESO_CTLREG_A1C2_AUTO | ESO_CTLREG_A1C2_ADC); 1715 1716 return (0); 1717 } 1718 1719 static int 1720 eso_set_recsrc(sc, recsrc) 1721 struct eso_softc *sc; 1722 unsigned int recsrc; 1723 { 1724 1725 eso_write_mixreg(sc, ESO_MIXREG_ERS, recsrc); 1726 sc->sc_recsrc = recsrc; 1727 return (0); 1728 } 1729 1730 static void 1731 eso_set_gain(sc, port) 1732 struct eso_softc *sc; 1733 unsigned int port; 1734 { 1735 uint8_t mixreg, tmp; 1736 1737 switch (port) { 1738 case ESO_DAC_PLAY_VOL: 1739 mixreg = ESO_MIXREG_PVR_A2; 1740 break; 1741 case ESO_MIC_PLAY_VOL: 1742 mixreg = ESO_MIXREG_PVR_MIC; 1743 break; 1744 case ESO_LINE_PLAY_VOL: 1745 mixreg = ESO_MIXREG_PVR_LINE; 1746 break; 1747 case ESO_SYNTH_PLAY_VOL: 1748 mixreg = ESO_MIXREG_PVR_SYNTH; 1749 break; 1750 case ESO_CD_PLAY_VOL: 1751 mixreg = ESO_MIXREG_PVR_CD; 1752 break; 1753 case ESO_AUXB_PLAY_VOL: 1754 mixreg = ESO_MIXREG_PVR_AUXB; 1755 break; 1756 1757 case ESO_DAC_REC_VOL: 1758 mixreg = ESO_MIXREG_RVR_A2; 1759 break; 1760 case ESO_MIC_REC_VOL: 1761 mixreg = ESO_MIXREG_RVR_MIC; 1762 break; 1763 case ESO_LINE_REC_VOL: 1764 mixreg = ESO_MIXREG_RVR_LINE; 1765 break; 1766 case ESO_SYNTH_REC_VOL: 1767 mixreg = ESO_MIXREG_RVR_SYNTH; 1768 break; 1769 case ESO_CD_REC_VOL: 1770 mixreg = ESO_MIXREG_RVR_CD; 1771 break; 1772 case ESO_AUXB_REC_VOL: 1773 mixreg = ESO_MIXREG_RVR_AUXB; 1774 break; 1775 case ESO_MONO_PLAY_VOL: 1776 mixreg = ESO_MIXREG_PVR_MONO; 1777 break; 1778 case ESO_MONO_REC_VOL: 1779 mixreg = ESO_MIXREG_RVR_MONO; 1780 break; 1781 1782 case ESO_PCSPEAKER_VOL: 1783 /* Special case - only 3-bit, mono, and reserved bits. */ 1784 tmp = eso_read_mixreg(sc, ESO_MIXREG_PCSVR); 1785 tmp &= ESO_MIXREG_PCSVR_RESV; 1786 /* Map bits 7:5 -> 2:0. */ 1787 tmp |= (sc->sc_gain[port][ESO_LEFT] >> 5); 1788 eso_write_mixreg(sc, ESO_MIXREG_PCSVR, tmp); 1789 return; 1790 1791 case ESO_MASTER_VOL: 1792 /* Special case - separate regs, and 6-bit precision. */ 1793 /* Map bits 7:2 -> 5:0. */ 1794 eso_write_mixreg(sc, ESO_MIXREG_LMVM, 1795 sc->sc_gain[port][ESO_LEFT] >> 2); 1796 eso_write_mixreg(sc, ESO_MIXREG_RMVM, 1797 sc->sc_gain[port][ESO_RIGHT] >> 2); 1798 return; 1799 1800 case ESO_SPATIALIZER: 1801 /* Special case - only `mono', and higher precision. */ 1802 eso_write_mixreg(sc, ESO_MIXREG_SPATLVL, 1803 sc->sc_gain[port][ESO_LEFT]); 1804 return; 1805 1806 case ESO_RECORD_VOL: 1807 /* Very Special case, controller register. */ 1808 eso_write_ctlreg(sc, ESO_CTLREG_RECLVL,ESO_4BIT_GAIN_TO_STEREO( 1809 sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT])); 1810 return; 1811 1812 default: 1813 #ifdef DIAGNOSTIC 1814 panic("eso_set_gain: bad port %u", port); 1815 /* NOTREACHED */ 1816 #else 1817 return; 1818 #endif 1819 } 1820 1821 eso_write_mixreg(sc, mixreg, ESO_4BIT_GAIN_TO_STEREO( 1822 sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT])); 1823 } 1824
Indexes created Tue Sep 30 11:09:46 GMT 2025