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