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