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