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