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