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