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