root/dev/pci/eso.c

DEFINITIONS

1. eso_match
2. eso_attach
3. eso_setup
4. eso_defer
5. eso_write_cmd
6. eso_write_ctlreg
7. eso_read_rdr
8. eso_read_ctlreg
9. eso_write_mixreg
10. eso_read_mixreg
11. eso_intr
12. eso_reset
13. eso_open
14. eso_close
15. eso_query_encoding
16. eso_set_params
17. eso_round_blocksize
18. eso_halt_output
19. eso_halt_input
20. eso_getdev
21. eso_set_port
22. eso_get_port
23. eso_query_devinfo
24. eso_allocmem
25. eso_freemem
26. eso_allocm
27. eso_freem
28. eso_round_buffersize
29. eso_mappage
30. eso_get_props
31. eso_trigger_output
32. eso_trigger_input
33. eso_set_recsrc
34. eso_set_gain
35. eso_powerhook

    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 $ */
    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  */
   32 /*
   33  * ESS Technology Inc. Solo-1 PCI AudioDrive (ES1938/1946) device driver.
   34  */
   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
   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>
   51 #include <dev/pci/pcidevs.h>
   52 #include <dev/pci/pcivar.h>
   54 #include <sys/audioio.h>
   55 #include <dev/audio_if.h>
   56 #include <dev/midi_if.h>
   58 #include <dev/mulaw.h>
   59 #include <dev/auconv.h>
   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>
   67 #include <machine/bus.h>
   68 #include <machine/intr.h>
   70 #if defined(AUDIO_DEBUG) || defined(DEBUG)
   71 #define DPRINTF(x) printf x
   72 #else
   73 #define DPRINTF(x)
   74 #endif
   76 struct eso_dma {
bus_dmamap_t            ed_map;
caddr_t                 ed_addr;
bus_dma_segment_t       ed_segs[1];
   80         int                     ed_nsegs;
size_t                  ed_size;
   82         struct eso_dma *        ed_next;
   83 };
   85 #define KVADDR(dma)     ((void *)(dma)->ed_addr)
   86 #define DMAADDR(dma)    ((dma)->ed_map->dm_segs[0].ds_addr)
   88 /* Autoconfiguration interface */
HIDE int eso_match(struct device *, MATCH_ARG_2_T, void *);
HIDE void eso_attach(struct device *, struct device *, void *);
HIDE void eso_defer(struct device *);
   93 struct cfattach eso_ca = {
   94         sizeof (struct eso_softc), eso_match, eso_attach
   95 };
   97 #ifdef __OpenBSD__
   98 struct cfdriver eso_cd = {
NULL, "eso", DV_DULL
  100 };
  101 #endif
  103 /* PCI interface */
HIDE int eso_intr(void *);
  106 /* MI audio layer interface */
HIDE int        eso_open(void *, int);
HIDE void       eso_close(void *);
HIDE int        eso_query_encoding(void *, struct audio_encoding *);
HIDE int        eso_set_params(void *, int, int, struct audio_params *,
  111                     struct audio_params *);
HIDE int        eso_round_blocksize(void *, int);
HIDE int        eso_halt_output(void *);
HIDE int        eso_halt_input(void *);
HIDE int        eso_getdev(void *, struct audio_device *);
HIDE int        eso_set_port(void *, mixer_ctrl_t *);
HIDE int        eso_get_port(void *, mixer_ctrl_t *);
HIDE int        eso_query_devinfo(void *, mixer_devinfo_t *);
HIDE void *     eso_allocm(void *, int, size_t, int, int);
HIDE void       eso_freem(void *, void *, int);
HIDE size_t     eso_round_buffersize(void *, int, size_t);
HIDE paddr_t    eso_mappage(void *, void *, off_t, int);
HIDE int        eso_get_props(void *);
HIDE int        eso_trigger_output(void *, void *, void *, int,
  125                     void (*)(void *), void *, struct audio_params *);
HIDE int        eso_trigger_input(void *, void *, void *, int,
  127                     void (*)(void *), void *, struct audio_params *);
HIDE void       eso_setup(struct eso_softc *, int);
HIDE void       eso_powerhook(int, void *);
HIDE struct audio_hw_if eso_hw_if = {
eso_open,
eso_close,
NULL,                   /* drain */
eso_query_encoding,
eso_set_params,
eso_round_blocksize,
NULL,                   /* commit_settings */
NULL,                   /* init_output */
NULL,                   /* init_input */
NULL,                   /* start_output */
NULL,                   /* start_input */
eso_halt_output,
eso_halt_input,
NULL,                   /* speaker_ctl */
eso_getdev,
NULL,                   /* setfd */
eso_set_port,
eso_get_port,
eso_query_devinfo,
eso_allocm,
eso_freem,
eso_round_buffersize,
eso_mappage,
eso_get_props,
eso_trigger_output,
eso_trigger_input,
  160 };
HIDE const char * const eso_rev2model[] = {
  163         "ES1938",
  164         "ES1946",
  165         "ES1946 rev E"
  166 };
  169 /*
  170  * Utility routines
  171  */
  172 /* Register access etc. */
HIDE uint8_t    eso_read_ctlreg(struct eso_softc *, uint8_t);
HIDE uint8_t    eso_read_mixreg(struct eso_softc *, uint8_t);
HIDE uint8_t    eso_read_rdr(struct eso_softc *);
HIDE int        eso_reset(struct eso_softc *);
HIDE void       eso_set_gain(struct eso_softc *, unsigned int);
HIDE int        eso_set_recsrc(struct eso_softc *, unsigned int);
HIDE void       eso_write_cmd(struct eso_softc *, uint8_t);
HIDE void       eso_write_ctlreg(struct eso_softc *, uint8_t, uint8_t);
HIDE void       eso_write_mixreg(struct eso_softc *, uint8_t, uint8_t);
  182 /* DMA memory allocation */
HIDE int        eso_allocmem(struct eso_softc *, size_t, size_t, size_t,
  184                     int, struct eso_dma *);
HIDE void       eso_freemem(struct eso_softc *, struct eso_dma *);
HIDE int
eso_match(parent, match, aux)
  190         struct device *parent;
MATCH_ARG_2_T match;
  192         void *aux;
  193 {
  194         struct pci_attach_args *pa = aux;
  196         if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ESSTECH &&
PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ESSTECH_SOLO1)
  198                 return (1);
  200         return (0);
  201 }
HIDE void
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;
pci_intr_handle_t ih;
bus_addr_t vcbase;
  213         const char *intrstring;
sc->sc_revision = PCI_REVISION(pa->pa_class);
  217         if (sc->sc_revision <
  218             sizeof (eso_rev2model) / sizeof (eso_rev2model[0]))
printf(": %s", eso_rev2model[sc->sc_revision]);
  220         else
printf(": (unknown rev. 0x%02x)", sc->sc_revision);
  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)) {
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)) {
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)) {
vcbase = 0;
sc->sc_vcsize = 0x10; /* From the data sheet. */
  238         }
  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)) {
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)) {
printf(", can't map Game I/O space\n");
  248                 return;
  249         }
sc->sc_dmat = pa->pa_dmat;
sc->sc_dmas = NULL;
sc->sc_dmac_configured = 0;
sc->sc_pa = *pa;
eso_setup(sc, 1);
  259         /* map and establish the interrupt. */
  260         if (pci_intr_map(pa, &ih)) {
printf(", couldn't map interrupt\n");
  262                 return;
  263         }
intrstring = pci_intr_string(pa->pa_pc, ih);
  265 #ifdef __OpenBSD__
sc->sc_ih  = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, eso_intr, sc,
sc->sc_dev.dv_xname);
  268 #else
sc->sc_ih  = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, eso_intr, sc);
  270 #endif
  271         if (sc->sc_ih == NULL) {
printf(", couldn't establish interrupt");
  273                 if (intrstring != NULL)
printf(" at %s", intrstring);
printf("\n");
  276                 return;
  277         }
printf(", %s\n", intrstring);
  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          */
  297         if (ESO_VALID_DDMAC_BASE(vcbase)) {
pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC,
vcbase | ESO_PCI_DDMAC_DE);
sc->sc_dmac_configured = 1;
printf("%s: mapping Audio 1 DMA using VC I/O space at 0x%lx\n",
sc->sc_dev.dv_xname, (unsigned long)vcbase);
  304         } else {
DPRINTF(("%s: VC I/O space at 0x%lx not suitable, deferring\n",
sc->sc_dev.dv_xname, (unsigned long)vcbase));
config_defer((struct device *)sc, eso_defer);
  308         }
audio_attach_mi(&eso_hw_if, sc, &sc->sc_dev);
aa.type = AUDIODEV_TYPE_OPL;
aa.hwif = NULL;
aa.hdl = NULL;
  315         (void)config_found(&sc->sc_dev, &aa, audioprint);
sc->sc_powerhook = powerhook_establish(&eso_powerhook, sc);
  319 #if 0
aa.type = AUDIODEV_TYPE_MPU;
aa.hwif = NULL;
aa.hdl = NULL;
sc->sc_mpudev = config_found(&sc->sc_dev, &aa, audioprint);
  324 #endif
  325 }
HIDE void
eso_setup(sc, verbose)
  329         struct eso_softc *sc;
  330         int verbose;
  331 {
  332         struct pci_attach_args *pa = &sc->sc_pa;        
uint8_t a2mode;
  334         int idx; 
  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         }
  342         /* Select the DMA/IRQ policy: DDMA, ISA IRQ emulation disabled. */
pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C,
pci_conf_read(pa->pa_pc, pa->pa_tag, ESO_PCI_S1C) &
  345                        ~(ESO_PCI_S1C_IRQP_MASK | ESO_PCI_S1C_DMAP_MASK));
  347         /* Enable the relevant DMA interrupts. */
bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL,
ESO_IO_IRQCTL_A1IRQ | ESO_IO_IRQCTL_A2IRQ);
  351         /* Set up A1's sample rate generator for new-style parameters. */
a2mode = eso_read_mixreg(sc, ESO_MIXREG_A2MODE);
a2mode |= ESO_MIXREG_A2MODE_NEWA1 | ESO_MIXREG_A2MODE_ASYNC;
eso_write_mixreg(sc, ESO_MIXREG_A2MODE, a2mode);
  356         /* Set mixer regs to something reasonable, needs work. */
  357         for (idx = 0; idx < ESO_NGAINDEVS; idx++) {
  358                 int v;
  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:
v = 0;
  374                         break;
  375                 case ESO_MASTER_VOL:
v = ESO_GAIN_TO_6BIT(AUDIO_MAX_GAIN / 2);
  377                         break;
  378                 default:
v = ESO_GAIN_TO_4BIT(AUDIO_MAX_GAIN / 2);
  380                         break;
  381                 }
sc->sc_gain[idx][ESO_LEFT] = sc->sc_gain[idx][ESO_RIGHT] = v;
eso_set_gain(sc, idx);
  384         }
eso_set_recsrc(sc, ESO_MIXREG_ERS_MIC);
  386 }
HIDE void
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;
bus_addr_t addr, start;
printf("%s: ", sc->sc_dev.dv_xname);
  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,
start + sc->sc_vcsize, start + 0x0400 - 1,
sc->sc_vcsize, sc->sc_vcsize, 0, 0, &addr,
  408                     &sc->sc_dmac_ioh) != 0)
  409                         continue;
pci_conf_write(pa->pa_pc, pa->pa_tag, ESO_PCI_DDMAC,
addr | ESO_PCI_DDMAC_DE);
sc->sc_dmac_iot = sc->sc_iot;
sc->sc_dmac_configured = 1;
printf("mapping Audio 1 DMA using I/O space at 0x%lx\n",
  416                     (unsigned long)addr);
  418                 return;
  419         }
printf("can't map Audio 1 DMA into I/O space\n");
  422 }
HIDE void
eso_write_cmd(sc, cmd)
  426         struct eso_softc *sc;
uint8_t cmd;
  428 {
  429         int i;
  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) {
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh,
ESO_SB_WDR, cmd);
  437                         return;
  438                 } else {
delay(10);
  440                 }
  441         }
printf("%s: WDR timeout\n", sc->sc_dev.dv_xname);
  444         return;
  445 }
  447 /* Write to a controller register */
HIDE void
eso_write_ctlreg(sc, reg, val)
  450         struct eso_softc *sc;
uint8_t reg, val;
  452 {
  454         /* DPRINTF(("ctlreg 0x%02x = 0x%02x\n", reg, val)); */
eso_write_cmd(sc, reg);
eso_write_cmd(sc, val);
  458 }
  460 /* Read out the Read Data Register */
HIDE uint8_t
eso_read_rdr(sc)
  463         struct eso_softc *sc;
  464 {
  465         int i;
  467         for (i = 0; i < ESO_RDR_TIMEOUT; i++) {
  468                 if (bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) {
  470                         return (bus_space_read_1(sc->sc_sb_iot,
sc->sc_sb_ioh, ESO_SB_RDR));
  472                 } else {
delay(10);
  474                 }
  475         }
printf("%s: RDR timeout\n", sc->sc_dev.dv_xname);
  478         return (-1);
  479 }
HIDE uint8_t
eso_read_ctlreg(sc, reg)
  484         struct eso_softc *sc;
uint8_t reg;
  486 {
eso_write_cmd(sc, ESO_CMD_RCR);
eso_write_cmd(sc, reg);
  490         return (eso_read_rdr(sc));
  491 }
HIDE void
eso_write_mixreg(sc, reg, val)
  495         struct eso_softc *sc;
uint8_t reg, val;
  497 {
  498         int s;
  500         /* DPRINTF(("mixreg 0x%02x = 0x%02x\n", reg, val)); */
s = splaudio();
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg);
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA, val);
splx(s);
  506 }
HIDE uint8_t
eso_read_mixreg(sc, reg)
  510         struct eso_softc *sc;
uint8_t reg;
  512 {
  513         int s;
uint8_t val;
s = splaudio();
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERADDR, reg);
val = bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_MIXERDATA);
splx(s);
  521         return (val);
  522 }
HIDE int
eso_intr(hdl)
  526         void *hdl;
  527 {
  528         struct eso_softc *sc = hdl;
uint8_t irqctl;
irqctl = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ESO_IO_IRQCTL);
  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);
  537         if (irqctl & ESO_IO_IRQCTL_A1IRQ) {
  538                 /* Clear interrupt. */
  539                 (void)bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
ESO_SB_RBSR);
  542                 if (sc->sc_rintr)
sc->sc_rintr(sc->sc_rarg);
  544                 else
wakeup(&sc->sc_rintr);
  546         }
  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                  */
eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2);
  555                 if (sc->sc_pintr)
sc->sc_pintr(sc->sc_parg);
  557                 else
wakeup(&sc->sc_pintr);
  559         }
  561 #if 0
  562         if ((irqctl & ESO_IO_IRQCTL_MPUIRQ) && sc->sc_mpudev != 0)
mpu_intr(sc->sc_mpudev);
  564 #endif
  566         return (1);
  567 }
  569 /* Perform a software reset, including DMA FIFOs. */
HIDE int
eso_reset(sc)
  572         struct eso_softc *sc;
  573 {
  574         int i;
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET,
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);
bus_space_write_1(sc->sc_sb_iot, sc->sc_sb_ioh, ESO_SB_RESET, 0);
  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,
ESO_SB_RBSR) & ESO_SB_RBSR_RDAV) != 0 &&
bus_space_read_1(sc->sc_sb_iot, sc->sc_sb_ioh,
ESO_SB_RDR) == ESO_SB_RDR_RESETMAGIC) {
  590                         /* Activate Solo-1 extension commands. */
eso_write_cmd(sc, ESO_CMD_EXTENB);
  592                         /* Reset mixer registers. */
eso_write_mixreg(sc, ESO_MIXREG_RESET,
ESO_MIXREG_RESET_RESET);
  596                         return (0);
  597                 } else {
delay(1000);
  599                 }
  600         }
printf("%s: reset timeout\n", sc->sc_dev.dv_xname);
  603         return (-1);
  604 }
  607 /* ARGSUSED */
HIDE int
eso_open(hdl, flags)
  610         void *hdl;
  611         int flags;
  612 {
  613         struct eso_softc *sc = hdl;
DPRINTF(("%s: open\n", sc->sc_dev.dv_xname));
sc->sc_pintr = NULL;
sc->sc_rintr = NULL;
  620         return (0);
  621 }
HIDE void
eso_close(hdl)
  625         void *hdl;
  626 {
DPRINTF(("%s: close\n", ((struct eso_softc *)hdl)->sc_dev.dv_xname));
  629 }
HIDE int
eso_query_encoding(hdl, fp)
  633         void *hdl;
  634         struct audio_encoding *fp;
  635 {
  637         switch (fp->index) {
  638         case 0:
strlcpy(fp->name, AudioEulinear, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR;
fp->precision = 8;
fp->flags = 0;
  643                 break;
  644         case 1:
strlcpy(fp->name, AudioEslinear, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR;
fp->precision = 8;
fp->flags = 0;
  649                 break;
  650         case 2:
fp->precision = 16;
  652                 if (fp->flags & AUOPEN_READ) {
strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
  655                         if (fp->flags & AUOPEN_WRITE)
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  657                         else
fp->flags = 0;
  659                 } else {
strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
fp->flags = 0;
  663                 }
  664                 break;
  665         case 3:
fp->precision = 16;
  667                 if (fp->flags & AUOPEN_READ) {
strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
  670                         if (fp->flags & AUOPEN_WRITE)
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  672                         else
fp->flags = 0;
  674                 } else {
strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
fp->flags = 0;
  678                 }
  679                 break;
  680         case 4:
fp->precision = 16;
  682                 if (fp->flags & AUOPEN_READ) {
strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
  685                 } else {
strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
  688                 }
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  690                 break;
  691         case 5:
fp->precision = 16;
  693                 if (fp->flags & AUOPEN_READ) {
strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
  696                 } else {
strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
  699                 }
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  701                 break;
  702         case 6:
strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULAW;
fp->precision = 8;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  707                 break;
  708         case 7:
strlcpy(fp->name, AudioEalaw, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ALAW;
fp->precision = 8;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  713                 break;
  714         default:
  715                 return (EINVAL);
  716         }
  718         return (0);
  719 }
HIDE int
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;
  732         for (mode = AUMODE_RECORD; mode != -1; 
mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
  734                 if ((setmode & mode) == 0)
  735                         continue;
p = (mode == AUMODE_PLAY) ? play : rec;
  739                 if (p->sample_rate < ESO_MINRATE ||
p->sample_rate > ESO_MAXRATE ||
  741                     (p->precision != 8 && p->precision != 16) ||
  742                     (p->channels != 1 && p->channels != 2))
  743                         return (EINVAL);
p->factor = 1;
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)
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)
p->sw_code = swap_bytes;
  757                         break;
  758                 case AUDIO_ENCODING_ULAW:
  759                         if (mode == AUMODE_PLAY) {
p->factor = 2;
p->sw_code = mulaw_to_ulinear16;
  762                         } else {
p->sw_code = ulinear8_to_mulaw;
  764                         }
  765                         break;
  766                 case AUDIO_ENCODING_ALAW:
  767                         if (mode == AUMODE_PLAY) {
p->factor = 2;
p->sw_code = alaw_to_ulinear16;
  770                         } else {
p->sw_code = ulinear8_to_alaw;
  772                         }
  773                         break;
  774                 default:
  775                         return (EINVAL);
  776                 }
  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))
r[0] = ESO_CLK0 /
  784                     (128 - (rd[0] = 128 - ESO_CLK0 / p->sample_rate));
r[1] = ESO_CLK1 /
  786                     (128 - (rd[1] = 128 - ESO_CLK1 / p->sample_rate));
clk = ABS(p->sample_rate - r[0]) > ABS(p->sample_rate - r[1]);
srg = rd[clk] | (clk == 1 ? ESO_CLK1_SELECT : 0x00);
  791                 /* Roll-off frequency of 87%, as in the ES1888 driver. */
fltdiv = 256 - 200279L / p->sample_rate;
  794                 /* Update to reflect the possibly inexact rate. */
p->sample_rate = r[clk];
  797                 if (mode == AUMODE_RECORD) {
  798                         /* Audio 1 */
DPRINTF(("A1 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv));
eso_write_ctlreg(sc, ESO_CTLREG_SRG, srg);
eso_write_ctlreg(sc, ESO_CTLREG_FLTDIV, fltdiv);
  802                 } else {
  803                         /* Audio 2 */
DPRINTF(("A2 srg 0x%02x fdiv 0x%02x\n", srg, fltdiv));
eso_write_mixreg(sc, ESO_MIXREG_A2SRG, srg);
eso_write_mixreg(sc, ESO_MIXREG_A2FLTDIV, fltdiv);
  807                 }
  808 #undef ABS
  810         }
  812         return (0);
  813 }
HIDE int
eso_round_blocksize(hdl, blk)
  817         void *hdl;
  818         int blk;
  819 {
  821         return ((blk + 31) & -32); /* keep good alignment; at least 16 req'd */
  822 }
HIDE int
eso_halt_output(hdl)
  826         void *hdl;
  827 {
  828         struct eso_softc *sc = hdl;
  829         int error, s;
DPRINTF(("%s: halt_output\n", sc->sc_dev.dv_xname));
  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          */
s = splaudio();
eso_write_mixreg(sc, ESO_MIXREG_A2C1,
ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM,
ESO_IO_A2DMAM_DMAENB);
sc->sc_pintr = NULL;
error = tsleep(&sc->sc_pintr, PCATCH | PWAIT, "esoho", hz);
splx(s);
  854         /* Shut down DMA completely. */
eso_write_mixreg(sc, ESO_MIXREG_A2C1, 0);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 0);
  858         return (error == EWOULDBLOCK ? 0 : error);
  859 }
HIDE int
eso_halt_input(hdl)
  863         void *hdl;
  864 {
  865         struct eso_softc *sc = hdl;
  866         int error, s;
DPRINTF(("%s: halt_input\n", sc->sc_dev.dv_xname));
  870         /* Just like eso_halt_output(), but for Audio 1. */
s = splaudio();
eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC |
ESO_CTLREG_A1C2_DMAENB);
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE,
DMA37MD_WRITE | DMA37MD_DEMAND);
sc->sc_rintr = NULL;
error = tsleep(&sc->sc_rintr, PCATCH | PWAIT, "esohi", hz);
splx(s);
  882         /* Shut down DMA completely. */
eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
ESO_CTLREG_A1C2_READ | ESO_CTLREG_A1C2_ADC);
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK,
ESO_DMAC_MASK_MASK);
  888         return (error == EWOULDBLOCK ? 0 : error);
  889 }
  891 /* ARGSUSED */
HIDE int
eso_getdev(hdl, retp)
  894         void *hdl;
  895         struct audio_device *retp;
  896 {
  897         struct eso_softc *sc = hdl;
strlcpy(retp->name, "ESS Solo-1", sizeof retp->name);
snprintf(retp->version, sizeof retp->version, "0x%02x",
sc->sc_revision);
  902         if (sc->sc_revision <=
  903             sizeof (eso_rev2model) / sizeof (eso_rev2model[0]))
strlcpy(retp->config, eso_rev2model[sc->sc_revision],
  905                     sizeof retp->config);
  906         else
strlcpy(retp->config, "unknown", sizeof retp->config);
  909         return (0);
  910 }
HIDE int
eso_set_port(hdl, cp)
  914         void *hdl;
mixer_ctrl_t *cp;
  916 {
  917         struct eso_softc *sc = hdl;
  918         unsigned int lgain, rgain;
uint8_t tmp;
  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);
  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:
lgain = rgain = ESO_GAIN_TO_4BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
  947                         break;
  948                 case 2:
lgain = ESO_GAIN_TO_4BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
rgain = ESO_GAIN_TO_4BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
  953                         break;
  954                 default:
  955                         return (EINVAL);
  956                 }
sc->sc_gain[cp->dev][ESO_LEFT] = lgain;
sc->sc_gain[cp->dev][ESO_RIGHT] = rgain;
eso_set_gain(sc, cp->dev);
  961                 break;
  963         case ESO_MASTER_VOL:
  964                 if (cp->type != AUDIO_MIXER_VALUE)
  965                         return (EINVAL);
  967                 /* Like above, but a precision of 6 bits. */
  968                 switch (cp->un.value.num_channels) {
  969                 case 1:
lgain = rgain = ESO_GAIN_TO_6BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
  972                         break;
  973                 case 2:
lgain = ESO_GAIN_TO_6BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
rgain = ESO_GAIN_TO_6BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
  978                         break;
  979                 default:
  980                         return (EINVAL);
  981                 }
sc->sc_gain[cp->dev][ESO_LEFT] = lgain;
sc->sc_gain[cp->dev][ESO_RIGHT] = rgain;
eso_set_gain(sc, cp->dev);
  986                 break;
  988         case ESO_SPATIALIZER:
  989                 if (cp->type != AUDIO_MIXER_VALUE ||
cp->un.value.num_channels != 1)
  991                         return (EINVAL);
sc->sc_gain[cp->dev][ESO_LEFT] =
sc->sc_gain[cp->dev][ESO_RIGHT] =
ESO_GAIN_TO_6BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
eso_set_gain(sc, cp->dev);
  998                 break;
 1000         case ESO_MONO_PLAY_VOL:
 1001         case ESO_MONO_REC_VOL:
 1002                 if (cp->type != AUDIO_MIXER_VALUE ||
cp->un.value.num_channels != 1)
 1004                         return (EINVAL);
sc->sc_gain[cp->dev][ESO_LEFT] =
sc->sc_gain[cp->dev][ESO_RIGHT] =
ESO_GAIN_TO_4BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
eso_set_gain(sc, cp->dev);
 1011                 break;
 1013         case ESO_PCSPEAKER_VOL:
 1014                 if (cp->type != AUDIO_MIXER_VALUE ||
cp->un.value.num_channels != 1)
 1016                         return (EINVAL);
sc->sc_gain[cp->dev][ESO_LEFT] =
sc->sc_gain[cp->dev][ESO_RIGHT] =
ESO_GAIN_TO_3BIT(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
eso_set_gain(sc, cp->dev);
 1023                 break;
 1025         case ESO_SPATIALIZER_ENABLE:
 1026                 if (cp->type != AUDIO_MIXER_ENUM)
 1027                         return (EINVAL);
sc->sc_spatializer = (cp->un.ord != 0);
tmp = eso_read_mixreg(sc, ESO_MIXREG_SPAT);
 1032                 if (sc->sc_spatializer)
tmp |= ESO_MIXREG_SPAT_ENB;
 1034                 else
tmp &= ~ESO_MIXREG_SPAT_ENB;
eso_write_mixreg(sc, ESO_MIXREG_SPAT,
tmp | ESO_MIXREG_SPAT_RSTREL);
 1038                 break;
 1040         case ESO_MONOOUT_SOURCE:
 1041                 if (cp->type != AUDIO_MIXER_ENUM)
 1042                         return (EINVAL);
sc->sc_monooutsrc = cp->un.ord;
tmp = eso_read_mixreg(sc, ESO_MIXREG_MPM);
tmp &= ~ESO_MIXREG_MPM_MOMASK;
tmp |= sc->sc_monooutsrc;
eso_write_mixreg(sc, ESO_MIXREG_MPM, tmp);
 1050                 break;
 1052         case ESO_RECORD_MONITOR:
 1053                 if (cp->type != AUDIO_MIXER_ENUM)
 1054                         return (EINVAL);
sc->sc_recmon = (cp->un.ord != 0);
tmp = eso_read_ctlreg(sc, ESO_CTLREG_ACTL);
 1059                 if (sc->sc_recmon)
tmp |= ESO_CTLREG_ACTL_RECMON;
 1061                 else
tmp &= ~ESO_CTLREG_ACTL_RECMON;
eso_write_ctlreg(sc, ESO_CTLREG_ACTL, tmp);
 1064                 break;
 1066         case ESO_RECORD_SOURCE:
 1067                 if (cp->type != AUDIO_MIXER_ENUM)
 1068                         return (EINVAL);
 1070                 return (eso_set_recsrc(sc, cp->un.ord));
 1072         case ESO_MIC_PREAMP:
 1073                 if (cp->type != AUDIO_MIXER_ENUM)
 1074                         return (EINVAL);
sc->sc_preamp = (cp->un.ord != 0);
tmp = eso_read_mixreg(sc, ESO_MIXREG_MPM);
tmp &= ~ESO_MIXREG_MPM_RESV0;
 1080                 if (sc->sc_preamp)
tmp |= ESO_MIXREG_MPM_PREAMP;
 1082                 else
tmp &= ~ESO_MIXREG_MPM_PREAMP;
eso_write_mixreg(sc, ESO_MIXREG_MPM, tmp);
 1085                 break;
 1087         default:
 1088                 return (EINVAL);
 1089         }
 1091         return (0);
 1092 }
HIDE int
eso_get_port(hdl, cp)
 1096         void *hdl;
mixer_ctrl_t *cp;
 1098 {
 1099         struct eso_softc *sc = hdl;
 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:
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
sc->sc_gain[cp->dev][ESO_LEFT];
 1125                         break;
 1126                 case 2:
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
sc->sc_gain[cp->dev][ESO_LEFT];
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
sc->sc_gain[cp->dev][ESO_RIGHT];
 1131                         break;
 1132                 default:
 1133                         return (EINVAL);
 1134                 }
 1135                 break;
 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);
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
sc->sc_gain[cp->dev][ESO_LEFT];
 1145                 break;
 1147         case ESO_RECORD_MONITOR:
cp->un.ord = sc->sc_recmon;
 1149                 break;
 1151         case ESO_RECORD_SOURCE:
cp->un.ord = sc->sc_recsrc;
 1153                 break;
 1155         case ESO_MONOOUT_SOURCE:
cp->un.ord = sc->sc_monooutsrc;
 1157                 break;
 1159         case ESO_SPATIALIZER_ENABLE:
cp->un.ord = sc->sc_spatializer;
 1161                 break;
 1163         case ESO_MIC_PREAMP:
cp->un.ord = sc->sc_preamp;
 1165                 break;
 1167         default:
 1168                 return (EINVAL);
 1169         }
 1172         return (0);
 1174 }
HIDE int
eso_query_devinfo(hdl, dip)
 1178         void *hdl;
mixer_devinfo_t *dip;
 1180 {
 1182         switch (dip->index) {
 1183         case ESO_DAC_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1190                     sizeof dip->un.v.units.name);
 1191                 break;
 1192         case ESO_MIC_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmicrophone,
 1196                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1200                     sizeof dip->un.v.units.name);
 1201                 break;
 1202         case ESO_LINE_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1209                     sizeof dip->un.v.units.name);
 1210                 break;
 1211         case ESO_SYNTH_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNfmsynth,
 1215                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1219                     sizeof dip->un.v.units.name);
 1220                 break;
 1221         case ESO_MONO_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "mono_in", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 1;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1228                     sizeof dip->un.v.units.name);
 1229                 break;
 1230         case ESO_CD_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1237                     sizeof dip->un.v.units.name);
 1238                 break;
 1239         case ESO_AUXB_PLAY_VOL:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1246                     sizeof dip->un.v.units.name);
 1247                 break;
 1249         case ESO_MIC_PREAMP:
dip->mixer_class = ESO_MICROPHONE_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNpreamp, sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 2;
strlcpy(dip->un.e.member[0].label.name, AudioNoff,
 1256                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = 0;
strlcpy(dip->un.e.member[1].label.name, AudioNon,
 1259                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = 1;
 1261                 break;
 1262         case ESO_MICROPHONE_CLASS:
dip->mixer_class = ESO_MICROPHONE_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmicrophone,
 1266                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1268                 break;
 1270         case ESO_INPUT_CLASS:
dip->mixer_class = ESO_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1275                 break;
 1277         case ESO_MASTER_VOL:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1284                     sizeof dip->un.v.units.name);
 1285                 break;
 1286         case ESO_PCSPEAKER_VOL:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "pc_speaker", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 1;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1293                     sizeof dip->un.v.units.name);
 1294                 break;
 1295         case ESO_MONOOUT_SOURCE:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "mono_out", sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 3;
strlcpy(dip->un.e.member[0].label.name, AudioNmute,
 1302                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = ESO_MIXREG_MPM_MOMUTE;
strlcpy(dip->un.e.member[1].label.name, AudioNdac,
 1305                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = ESO_MIXREG_MPM_MOA2R;
strlcpy(dip->un.e.member[2].label.name, AudioNmixerout,
 1308                     sizeof dip->un.e.member[2].label.name);
dip->un.e.member[2].ord = ESO_MIXREG_MPM_MOREC;
 1310                 break;
 1311         case ESO_SPATIALIZER:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->prev = AUDIO_MIXER_LAST;
dip->next = ESO_SPATIALIZER_ENABLE;
strlcpy(dip->label.name, AudioNspatial,
 1316                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 1;
strlcpy(dip->un.v.units.name, "level",
 1320                     sizeof dip->un.v.units.name);
 1321                 break;
 1322         case ESO_SPATIALIZER_ENABLE:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->prev = ESO_SPATIALIZER;
dip->next = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "enable", sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 2;
strlcpy(dip->un.e.member[0].label.name, AudioNoff,
 1330                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = 0;
strlcpy(dip->un.e.member[1].label.name, AudioNon,
 1333                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = 1;
 1335                 break;
 1337         case ESO_OUTPUT_CLASS:
dip->mixer_class = ESO_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCoutputs,
 1341                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1343                 break;
 1345         case ESO_RECORD_MONITOR:
dip->mixer_class = ESO_MONITOR_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 2;
strlcpy(dip->un.e.member[0].label.name, AudioNoff,
 1352                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = 0;
strlcpy(dip->un.e.member[1].label.name, AudioNon,
 1355                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = 1;
 1357                 break;
 1358         case ESO_MONITOR_CLASS:
dip->mixer_class = ESO_MONITOR_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCmonitor,
 1362                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1364                 break;
 1366         case ESO_RECORD_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1372                     sizeof dip->un.v.units.name);
 1373                 break;
 1374         case ESO_RECORD_SOURCE:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 4;
strlcpy(dip->un.e.member[0].label.name, AudioNmicrophone,
 1381                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = ESO_MIXREG_ERS_MIC;
strlcpy(dip->un.e.member[1].label.name, AudioNline,
 1384                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = ESO_MIXREG_ERS_LINE;
strlcpy(dip->un.e.member[2].label.name, AudioNcd,
 1387                     sizeof dip->un.e.member[2].label.name);
dip->un.e.member[2].ord = ESO_MIXREG_ERS_CD;
strlcpy(dip->un.e.member[3].label.name, AudioNmixerout,
 1390                     sizeof dip->un.e.member[3].label.name);
dip->un.e.member[3].ord = ESO_MIXREG_ERS_MIXER;
 1392                 break;
 1393         case ESO_DAC_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1400                     sizeof dip->un.v.units.name);
 1401                 break;
 1402         case ESO_MIC_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmicrophone,
 1406                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1410                     sizeof dip->un.v.units.name);
 1411                 break;
 1412         case ESO_LINE_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1419                     sizeof dip->un.v.units.name);
 1420                 break;
 1421         case ESO_SYNTH_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNfmsynth,
 1425                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1429                     sizeof dip->un.v.units.name);
 1430                 break;
 1431         case ESO_MONO_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "mono_in", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 1; /* No lies */
strlcpy(dip->un.v.units.name, AudioNvolume,
 1438                     sizeof dip->un.v.units.name);
 1439                 break;
 1440         case ESO_CD_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1447                     sizeof dip->un.v.units.name);
 1448                 break;
 1449         case ESO_AUXB_REC_VOL:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1456                     sizeof dip->un.v.units.name);
 1457                 break;
 1458         case ESO_RECORD_CLASS:
dip->mixer_class = ESO_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1463                 break;
 1465         default:
 1466                 return (ENXIO);
 1467         }
 1469         return (0);
 1470 }
HIDE int
eso_allocmem(sc, size, align, boundary, flags, ed)
 1474         struct eso_softc *sc;
size_t size;
size_t align;
size_t boundary;
 1478         int flags;
 1479         struct eso_dma *ed;
 1480 {
 1481         int error, wait;
wait = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
ed->ed_size = size;
error = bus_dmamem_alloc(sc->sc_dmat, ed->ed_size, align, boundary,
ed->ed_segs, sizeof (ed->ed_segs) / sizeof (ed->ed_segs[0]),
 1488             &ed->ed_nsegs, wait);
 1489         if (error)
 1490                 goto out;
error = bus_dmamem_map(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs,
ed->ed_size, &ed->ed_addr, wait | BUS_DMA_COHERENT);
 1494         if (error)
 1495                 goto free;
error = bus_dmamap_create(sc->sc_dmat, ed->ed_size, 1, ed->ed_size, 0,
wait, &ed->ed_map);
 1499         if (error)
 1500                 goto unmap;
error = bus_dmamap_load(sc->sc_dmat, ed->ed_map, ed->ed_addr,
ed->ed_size, NULL, wait);
 1504         if (error)
 1505                 goto destroy;
 1507         return (0);
destroy:
bus_dmamap_destroy(sc->sc_dmat, ed->ed_map);
unmap:
bus_dmamem_unmap(sc->sc_dmat, ed->ed_addr, ed->ed_size);
free:
bus_dmamem_free(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs);
out:
 1516         return (error);
 1517 }
HIDE void
eso_freemem(sc, ed)
 1521         struct eso_softc *sc;
 1522         struct eso_dma *ed;
 1523 {
bus_dmamap_unload(sc->sc_dmat, ed->ed_map);
bus_dmamap_destroy(sc->sc_dmat, ed->ed_map);
bus_dmamem_unmap(sc->sc_dmat, ed->ed_addr, ed->ed_size);
bus_dmamem_free(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs);
 1529 }
HIDE void *
eso_allocm(hdl, direction, size, type, flags)
 1533         void *hdl;
 1534         int direction;
size_t size;
 1536         int type, flags;
 1537 {
 1538         struct eso_softc *sc = hdl;
 1539         struct eso_dma *ed;
size_t boundary;
 1541         int error;
 1543         if ((ed = malloc(size, type, flags)) == NULL)
 1544                 return (NULL);
 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)
boundary = 0x10000;
 1554         else
boundary = 0;
error = eso_allocmem(sc, size, 32, boundary, flags, ed);
 1559         if (error) {
free(ed, type);
 1561                 return (NULL);
 1562         }
ed->ed_next = sc->sc_dmas;
sc->sc_dmas = ed;
 1566         return (KVADDR(ed));
 1567 }
HIDE void
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;
 1578         for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &p->ed_next) {
 1579                 if (KVADDR(p) == addr) {
eso_freemem(sc, p);
 1581                         *pp = p->ed_next;
free(p, type);
 1583                         return;
 1584                 }
 1585         }
 1586 }
HIDE size_t
eso_round_buffersize(hdl, direction, bufsize)
 1590         void *hdl;
 1591         int direction;
size_t bufsize;
 1593 {
 1595         /* 64K restriction: ISA at eleven? */
 1596         if (bufsize > 65536)
bufsize = 65536;
 1599         return (bufsize);
 1600 }
HIDE paddr_t
eso_mappage(hdl, addr, offs, prot)
 1604         void *hdl;
 1605         void *addr;
off_t offs;
 1607         int prot;
 1608 {
 1609         struct eso_softc *sc = hdl;
 1610         struct eso_dma *ed;
 1612         if (offs < 0)
 1613                 return (-1);
 1614         for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) == addr;
ed = ed->ed_next)
 1616                 ;
 1617         if (ed == NULL)
 1618                 return (-1);
 1620         return (bus_dmamem_mmap(sc->sc_dmat, ed->ed_segs, ed->ed_nsegs,
offs, prot, BUS_DMA_WAITOK));
 1622 }
 1624 /* ARGSUSED */
HIDE int
eso_get_props(hdl)
 1627         void *hdl;
 1628 {
 1630         return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT |
AUDIO_PROP_FULLDUPLEX);
 1632 }
HIDE int
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;
uint8_t a2c1;
DPRINTF((
 1648             "%s: trigger_output: start %p, end %p, blksize %d, intr %p(%p)\n",
sc->sc_dev.dv_xname, start, end, blksize, intr, arg));
DPRINTF(("%s: param: rate %lu, encoding %u, precision %u, channels %u, sw_code %p, factor %d\n",
sc->sc_dev.dv_xname, param->sample_rate, param->encoding,
param->precision, param->channels, param->sw_code, param->factor));
 1654         /* Find DMA buffer. */
 1655         for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) != start;
ed = ed->ed_next)
 1657                 ;
 1658         if (ed == NULL) {
printf("%s: trigger_output: bad addr %p\n",
sc->sc_dev.dv_xname, start);
 1661                 return (EINVAL);
 1662         }
sc->sc_pintr = intr;
sc->sc_parg = arg;
 1667         /* DMA transfer count (in `words'!) reload using 2's complement. */
blksize = -(blksize >> 1);
eso_write_mixreg(sc, ESO_MIXREG_A2TCRLO, blksize & 0xff);
eso_write_mixreg(sc, ESO_MIXREG_A2TCRHI, blksize >> 8);
 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)
sc->sc_a2c2 |= ESO_MIXREG_A2C2_16BIT;
 1676         else
sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_16BIT;
 1678         if (param->channels == 2)
sc->sc_a2c2 |= ESO_MIXREG_A2C2_STEREO;
 1680         else
sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_STEREO;
 1682         if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
param->encoding == AUDIO_ENCODING_SLINEAR_LE)
sc->sc_a2c2 |= ESO_MIXREG_A2C2_SIGNED;
 1685         else
sc->sc_a2c2 &= ~ESO_MIXREG_A2C2_SIGNED;
 1687         /* Unmask IRQ. */
sc->sc_a2c2 |= ESO_MIXREG_A2C2_IRQM;
eso_write_mixreg(sc, ESO_MIXREG_A2C2, sc->sc_a2c2);
 1691         /* Set up DMA controller. */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAA, DMAADDR(ed));
bus_space_write_2(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAC,
 1694             (uint8_t *)end - (uint8_t *)start);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM,
ESO_IO_A2DMAM_DMAENB | ESO_IO_A2DMAM_AUTO);
 1698         /* Start DMA. */
a2c1 = eso_read_mixreg(sc, ESO_MIXREG_A2C1);
a2c1 &= ~ESO_MIXREG_A2C1_RESV0; /* Paranoia? XXX bit 5 */
a2c1 |= ESO_MIXREG_A2C1_FIFOENB | ESO_MIXREG_A2C1_DMAENB |
ESO_MIXREG_A2C1_AUTO;
eso_write_mixreg(sc, ESO_MIXREG_A2C1, a2c1);
 1705         return (0);
 1706 }
HIDE int
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;
uint8_t actl, a1c1;
DPRINTF((
 1722             "%s: trigger_input: start %p, end %p, blksize %d, intr %p(%p)\n",
sc->sc_dev.dv_xname, start, end, blksize, intr, arg));
DPRINTF(("%s: param: rate %lu, encoding %u, precision %u, channels %u, sw_code %p, factor %d\n",
sc->sc_dev.dv_xname, param->sample_rate, param->encoding,
param->precision, param->channels, param->sw_code, param->factor));
 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);
 1735         /* Find DMA buffer. */
 1736         for (ed = sc->sc_dmas; ed != NULL && KVADDR(ed) != start;
ed = ed->ed_next)
 1738                 ;
 1739         if (ed == NULL) {
printf("%s: trigger_output: bad addr %p\n",
sc->sc_dev.dv_xname, start);
 1742                 return (EINVAL);
 1743         }
sc->sc_rintr = intr;
sc->sc_rarg = arg;
 1748         /* Set up ADC DMA converter parameters. */
actl = eso_read_ctlreg(sc, ESO_CTLREG_ACTL);
 1750         if (param->channels == 2) {
actl &= ~ESO_CTLREG_ACTL_MONO;
actl |= ESO_CTLREG_ACTL_STEREO;
 1753         } else {
actl &= ~ESO_CTLREG_ACTL_STEREO;
actl |= ESO_CTLREG_ACTL_MONO;
 1756         }
eso_write_ctlreg(sc, ESO_CTLREG_ACTL, actl);
 1759         /* Set up Transfer Type: maybe move to attach time? */
eso_write_ctlreg(sc, ESO_CTLREG_A1TT, ESO_CTLREG_A1TT_DEMAND4);
 1762         /* DMA transfer count reload using 2's complement. */
blksize = -blksize;
eso_write_ctlreg(sc, ESO_CTLREG_A1TCRLO, blksize & 0xff);
eso_write_ctlreg(sc, ESO_CTLREG_A1TCRHI, blksize >> 8);
 1767         /* Set up and enable Audio 1 DMA FIFO. */
a1c1 = ESO_CTLREG_A1C1_RESV1 | ESO_CTLREG_A1C1_FIFOENB;
 1769         if (param->precision * param->factor == 16)
a1c1 |= ESO_CTLREG_A1C1_16BIT;
 1771         if (param->channels == 2)
a1c1 |= ESO_CTLREG_A1C1_STEREO;
 1773         else
a1c1 |= ESO_CTLREG_A1C1_MONO;
 1775         if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
param->encoding == AUDIO_ENCODING_SLINEAR_LE)
a1c1 |= ESO_CTLREG_A1C1_SIGNED;
eso_write_ctlreg(sc, ESO_CTLREG_A1C1, a1c1);
 1780         /* Set up ADC IRQ/DRQ parameters. */
eso_write_ctlreg(sc, ESO_CTLREG_LAIC,
ESO_CTLREG_LAIC_PINENB | ESO_CTLREG_LAIC_EXTENB);
eso_write_ctlreg(sc, ESO_CTLREG_DRQCTL,
ESO_CTLREG_DRQCTL_ENB1 | ESO_CTLREG_DRQCTL_EXTENB);
 1786         /* Set up and enable DMA controller. */
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_CLEAR, 0);
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK,
ESO_DMAC_MASK_MASK);
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MODE,
DMA37MD_WRITE | DMA37MD_LOOP | DMA37MD_DEMAND);
bus_space_write_4(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAA,
DMAADDR(ed));
bus_space_write_2(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_DMAC,
 1795             (uint8_t *)end - (uint8_t *)start - 1);
bus_space_write_1(sc->sc_dmac_iot, sc->sc_dmac_ioh, ESO_DMAC_MASK, 0);
 1798         /* Start DMA. */
eso_write_ctlreg(sc, ESO_CTLREG_A1C2,
ESO_CTLREG_A1C2_DMAENB | ESO_CTLREG_A1C2_READ |
ESO_CTLREG_A1C2_AUTO | ESO_CTLREG_A1C2_ADC);
 1803         return (0);
 1804 }
HIDE int
eso_set_recsrc(sc, recsrc)
 1808         struct eso_softc *sc;
 1809         unsigned int recsrc;
 1810 {
eso_write_mixreg(sc, ESO_MIXREG_ERS, recsrc);
sc->sc_recsrc = recsrc;
 1814         return (0);
 1815 }
HIDE void
eso_set_gain(sc, port)
 1819         struct eso_softc *sc;
 1820         unsigned int port;
 1821 {
uint8_t mixreg, tmp;
 1824         switch (port) {
 1825         case ESO_DAC_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_A2;
 1827                 break;
 1828         case ESO_MIC_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_MIC;
 1830                 break;
 1831         case ESO_LINE_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_LINE;
 1833                 break;
 1834         case ESO_SYNTH_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_SYNTH;
 1836                 break;
 1837         case ESO_CD_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_CD;
 1839                 break;
 1840         case ESO_AUXB_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_AUXB;
 1842                 break;
 1844         case ESO_DAC_REC_VOL:
mixreg = ESO_MIXREG_RVR_A2;
 1846                 break;
 1847         case ESO_MIC_REC_VOL:
mixreg = ESO_MIXREG_RVR_MIC;
 1849                 break;
 1850         case ESO_LINE_REC_VOL:
mixreg = ESO_MIXREG_RVR_LINE;
 1852                 break;
 1853         case ESO_SYNTH_REC_VOL:
mixreg = ESO_MIXREG_RVR_SYNTH;
 1855                 break;
 1856         case ESO_CD_REC_VOL:
mixreg = ESO_MIXREG_RVR_CD;
 1858                 break;
 1859         case ESO_AUXB_REC_VOL:
mixreg = ESO_MIXREG_RVR_AUXB;
 1861                 break;
 1862         case ESO_MONO_PLAY_VOL:
mixreg = ESO_MIXREG_PVR_MONO;
 1864                 break;
 1865         case ESO_MONO_REC_VOL:
mixreg = ESO_MIXREG_RVR_MONO;
 1867                 break;
 1869         case ESO_PCSPEAKER_VOL:
 1870                 /* Special case - only 3-bit, mono, and reserved bits. */
tmp = eso_read_mixreg(sc, ESO_MIXREG_PCSVR);
tmp &= ESO_MIXREG_PCSVR_RESV;
 1873                 /* Map bits 7:5 -> 2:0. */
tmp |= (sc->sc_gain[port][ESO_LEFT] >> 5);
eso_write_mixreg(sc, ESO_MIXREG_PCSVR, tmp);
 1876                 return;
 1878         case ESO_MASTER_VOL:
 1879                 /* Special case - separate regs, and 6-bit precision. */
 1880                 /* Map bits 7:2 -> 5:0. */
eso_write_mixreg(sc, ESO_MIXREG_LMVM,
sc->sc_gain[port][ESO_LEFT] >> 2);
eso_write_mixreg(sc, ESO_MIXREG_RMVM,
sc->sc_gain[port][ESO_RIGHT] >> 2);
 1885                 return;
 1887         case ESO_SPATIALIZER:
 1888                 /* Special case - only `mono', and higher precision. */
eso_write_mixreg(sc, ESO_MIXREG_SPATLVL,
sc->sc_gain[port][ESO_LEFT]);
 1891                 return;
 1893         case ESO_RECORD_VOL:
 1894                 /* Very Special case, controller register. */
eso_write_ctlreg(sc, ESO_CTLREG_RECLVL,ESO_4BIT_GAIN_TO_STEREO(
sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT]));
 1897                 return;
 1899         default:
 1900 #ifdef DIAGNOSTIC               
panic("eso_set_gain: bad port %u", port);
 1902                 /* NOTREACHED */
 1903 #else
 1904                 return;
 1905 #endif          
 1906                 }
eso_write_mixreg(sc, mixreg, ESO_4BIT_GAIN_TO_STEREO(
sc->sc_gain[port][ESO_LEFT], sc->sc_gain[port][ESO_RIGHT]));
 1910 }
HIDE void
eso_powerhook(why, self)
 1915         int why;
 1916         void *self;
 1917 {
 1918         struct eso_softc *sc = (struct eso_softc *)self;        
 1920         if (why != PWR_RESUME) {
eso_halt_output(sc);
eso_halt_input(sc);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, ESO_IO_A2DMAM, 0);
bus_space_write_1(sc->sc_dmac_iot,
sc->sc_dmac_ioh, ESO_DMAC_CLEAR, 0);
bus_space_write_1(sc->sc_sb_iot,
sc->sc_sb_ioh, ESO_SB_STATUSFLAGS, 3);
 1930                 /* shut down dma */
pci_conf_write(sc->sc_pa.pa_pc,
sc->sc_pa.pa_tag, ESO_PCI_DDMAC, 0);
 1933         } else
eso_setup(sc, 0);
 1935 }