/*      $NetBSD: ess.c,v 1.91 2024/02/09 22:08:35 andvar Exp $  */

/*
 * Copyright 1997
 * Digital Equipment Corporation. All rights reserved.
 *
 * This software is furnished under license and may be used and
 * copied only in accordance with the following terms and conditions.
 * Subject to these conditions, you may download, copy, install,
 * use, modify and distribute this software in source and/or binary
 * form. No title or ownership is transferred hereby.
 *
 * 1) Any source code used, modified or distributed must reproduce
 *    and retain this copyright notice and list of conditions as
 *    they appear in the source file.
 *
 * 2) No right is granted to use any trade name, trademark, or logo of
 *    Digital Equipment Corporation. Neither the "Digital Equipment
 *    Corporation" name nor any trademark or logo of Digital Equipment
 *    Corporation may be used to endorse or promote products derived
 *    from this software without the prior written permission of
 *    Digital Equipment Corporation.
 *
 * 3) This software is provided "AS-IS" and any express or implied
 *    warranties, including but not limited to, any implied warranties
 *    of merchantability, fitness for a particular purpose, or
 *    non-infringement are disclaimed. In no event shall DIGITAL be
 *    liable for any damages whatsoever, and in particular, DIGITAL
 *    shall not be liable for special, indirect, consequential, or
 *    incidental damages or damages for lost profits, loss of
 *    revenue or loss of use, whether such damages arise in contract,
 *    negligence, tort, under statute, in equity, at law or otherwise,
 *    even if advised of the possibility of such damage.
 */

/*
**++
**
**  ess.c
**
**  FACILITY:
**
**      DIGITAL Network Appliance Reference Design (DNARD)
**
**  MODULE DESCRIPTION:
**
**      This module contains the device driver for the ESS
**      Technologies 1888/1887/888 sound chip. The code in sbdsp.c was
**      used as a reference point when implementing this driver.
**
**  AUTHORS:
**
**      Blair Fidler    Software Engineering Australia
**                      Gold Coast, Australia.
**
**  CREATION DATE:
**
**      March 10, 1997.
**
**  MODIFICATION HISTORY:
**
**      Heavily modified by Lennart Augustsson and Charles M. Hannum for
**      bus_dma, changes to audio interface, and many bug fixes.
**      ESS1788 support by Nathan J. Williams and Charles M. Hannum.
**--
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ess.c,v 1.91 2024/02/09 22:08:35 andvar Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/cpu.h>
#include <sys/intr.h>
#include <sys/bus.h>
#include <sys/audioio.h>
#include <sys/malloc.h>

#include <dev/audio/audio_if.h>

#include <dev/isa/isavar.h>
#include <dev/isa/isadmavar.h>

#include <dev/isa/essvar.h>
#include <dev/isa/essreg.h>

#include "joy_ess.h"

#ifdef AUDIO_DEBUG
#define DPRINTF(x)      if (essdebug) printf x
#define DPRINTFN(n,x)   if (essdebug>(n)) printf x
int     essdebug = 0;
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif

#if 0
unsigned uuu;
#define EREAD1(t, h, a) (uuu=bus_space_read_1(t, h, a),printf("EREAD  %02x=%02x\n", ((int)h&0xfff)+a, uuu),uuu)
#define EWRITE1(t, h, a, d) (printf("EWRITE %02x=%02x\n", ((int)h & 0xfff)+a, d), bus_space_write_1(t, h, a, d))
#else
#define EREAD1(t, h, a) bus_space_read_1(t, h, a)
#define EWRITE1(t, h, a, d) bus_space_write_1(t, h, a, d)
#endif


int     ess_setup_sc(struct ess_softc *, int);

void    ess_close(void *);
int     ess_getdev(void *, struct audio_device *);

int     ess_query_format(void *, audio_format_query_t *);

int     ess_set_format(void *, int,
            const audio_params_t *, const audio_params_t *,
            audio_filter_reg_t *, audio_filter_reg_t *);

int     ess_round_blocksize(void *, int, int, const audio_params_t *);

int     ess_audio1_trigger_output(void *, void *, void *, int,
            void (*)(void *), void *, const audio_params_t *);
int     ess_audio2_trigger_output(void *, void *, void *, int,
            void (*)(void *), void *, const audio_params_t *);
int     ess_audio1_trigger_input(void *, void *, void *, int,
            void (*)(void *), void *, const audio_params_t *);
int     ess_audio1_halt(void *);
int     ess_audio2_halt(void *);
int     ess_audio1_intr(void *);
int     ess_audio2_intr(void *);
void    ess_audio1_poll(void *);
void    ess_audio2_poll(void *);

int     ess_speaker_ctl(void *, int);

int     ess_getdev(void *, struct audio_device *);

int     ess_set_port(void *, mixer_ctrl_t *);
int     ess_get_port(void *, mixer_ctrl_t *);

void   *ess_malloc(void *, int, size_t);
void    ess_free(void *, void *, size_t);
size_t  ess_round_buffersize(void *, int, size_t);


int     ess_query_devinfo(void *, mixer_devinfo_t *);
int     ess_1788_get_props(void *);
int     ess_1888_get_props(void *);
void    ess_get_locks(void *, kmutex_t **, kmutex_t **);

void    ess_speaker_on(struct ess_softc *);
void    ess_speaker_off(struct ess_softc *);

void    ess_config_irq(struct ess_softc *);
void    ess_config_drq(struct ess_softc *);
void    ess_setup(struct ess_softc *);
int     ess_identify(struct ess_softc *);

int     ess_reset(struct ess_softc *);
void    ess_set_gain(struct ess_softc *, int, int);
int     ess_set_in_port(struct ess_softc *, int);
int     ess_set_in_ports(struct ess_softc *, int);
u_int   ess_srtotc(struct ess_softc *, u_int);
u_int   ess_srtofc(u_int);
u_char  ess_get_dsp_status(struct ess_softc *);
u_char  ess_dsp_read_ready(struct ess_softc *);
u_char  ess_dsp_write_ready(struct ess_softc *);
int     ess_rdsp(struct ess_softc *);
int     ess_wdsp(struct ess_softc *, u_char);
u_char  ess_read_x_reg(struct ess_softc *, u_char);
int     ess_write_x_reg(struct ess_softc *, u_char, u_char);
void    ess_clear_xreg_bits(struct ess_softc *, u_char, u_char);
void    ess_set_xreg_bits(struct ess_softc *, u_char, u_char);
u_char  ess_read_mix_reg(struct ess_softc *, u_char);
void    ess_write_mix_reg(struct ess_softc *, u_char, u_char);
void    ess_clear_mreg_bits(struct ess_softc *, u_char, u_char);
void    ess_set_mreg_bits(struct ess_softc *, u_char, u_char);
void    ess_read_multi_mix_reg(struct ess_softc *, u_char, u_int8_t *,
    bus_size_t);

static const char *essmodel[] = {
        "unsupported",

        "688",
        "1688",
        "1788",
        "1868",
        "1869",
        "1878",
        "1879",

        "888",
        "1887",
        "1888",
};

struct audio_device ess_device = {
        "ESS Technology",
        "x",
        "ess"
};

/*
 * Define our interface to the higher level audio driver.
 */

const struct audio_hw_if ess_1788_hw_if = {
        .close                  = ess_close,
        .query_format           = ess_query_format,
        .set_format             = ess_set_format,
        .round_blocksize        = ess_round_blocksize,
        .halt_output            = ess_audio1_halt,
        .halt_input             = ess_audio1_halt,
        .speaker_ctl            = ess_speaker_ctl,
        .getdev                 = ess_getdev,
        .set_port               = ess_set_port,
        .get_port               = ess_get_port,
        .query_devinfo          = ess_query_devinfo,
        .allocm                 = ess_malloc,
        .freem                  = ess_free,
        .round_buffersize       = ess_round_buffersize,
        .get_props              = ess_1788_get_props,
        .trigger_output         = ess_audio1_trigger_output,
        .trigger_input          = ess_audio1_trigger_input,
        .get_locks              = ess_get_locks,
};

const struct audio_hw_if ess_1888_hw_if = {
        .close                  = ess_close,
        .query_format           = ess_query_format,
        .set_format             = ess_set_format,
        .round_blocksize        = ess_round_blocksize,
        .halt_output            = ess_audio2_halt,
        .halt_input             = ess_audio1_halt,
        .speaker_ctl            = ess_speaker_ctl,
        .getdev                 = ess_getdev,
        .set_port               = ess_set_port,
        .get_port               = ess_get_port,
        .query_devinfo          = ess_query_devinfo,
        .allocm                 = ess_malloc,
        .freem                  = ess_free,
        .round_buffersize       = ess_round_buffersize,
        .get_props              = ess_1888_get_props,
        .trigger_output         = ess_audio2_trigger_output,
        .trigger_input          = ess_audio1_trigger_input,
        .get_locks              = ess_get_locks,
};

static const struct audio_format ess_formats[] = {
        {
                .mode           = AUMODE_PLAY | AUMODE_RECORD,
                .encoding       = AUDIO_ENCODING_SLINEAR_LE,
                .validbits      = 16,
                .precision      = 16,
                .channels       = 2,
                .channel_mask   = AUFMT_STEREO,
                .frequency_type = 0,
                .frequency      = { ESS_MINRATE, ESS_MAXRATE },
        },
};
#define ESS_NFORMATS __arraycount(ess_formats)

#ifdef AUDIO_DEBUG
void ess_printsc(struct ess_softc *);
void ess_dump_mixer(struct ess_softc *);

void
ess_printsc(struct ess_softc *sc)
{
        int i;

        printf("iobase 0x%x outport %u inport %u speaker %s\n",
               sc->sc_iobase, sc->out_port,
               sc->in_port, sc->spkr_state ? "on" : "off");

        printf("audio1: DMA chan %d irq %d nintr %lu intr %p arg %p\n",
               sc->sc_audio1.drq, sc->sc_audio1.irq, sc->sc_audio1.nintr,
               sc->sc_audio1.intr, sc->sc_audio1.arg);

        if (!ESS_USE_AUDIO1(sc->sc_model)) {
                printf("audio2: DMA chan %d irq %d nintr %lu intr %p arg %p\n",
                       sc->sc_audio2.drq, sc->sc_audio2.irq, sc->sc_audio2.nintr,
                       sc->sc_audio2.intr, sc->sc_audio2.arg);
        }

        printf("gain:");
        for (i = 0; i < sc->ndevs; i++)
                printf(" %u,%u", sc->gain[i][ESS_LEFT], sc->gain[i][ESS_RIGHT]);
        printf("\n");
}

void
ess_dump_mixer(struct ess_softc *sc)
{

        printf("ESS_DAC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x7C, ess_read_mix_reg(sc, 0x7C));
        printf("ESS_MIC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x1A, ess_read_mix_reg(sc, 0x1A));
        printf("ESS_LINE_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x3E, ess_read_mix_reg(sc, 0x3E));
        printf("ESS_SYNTH_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x36, ess_read_mix_reg(sc, 0x36));
        printf("ESS_CD_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x38, ess_read_mix_reg(sc, 0x38));
        printf("ESS_AUXB_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
               0x3A, ess_read_mix_reg(sc, 0x3A));
        printf("ESS_MASTER_VOL: mix reg 0x%02x=0x%02x\n",
               0x32, ess_read_mix_reg(sc, 0x32));
        printf("ESS_PCSPEAKER_VOL: mix reg 0x%02x=0x%02x\n",
               0x3C, ess_read_mix_reg(sc, 0x3C));
        printf("ESS_DAC_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x69, ess_read_mix_reg(sc, 0x69));
        printf("ESS_MIC_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x68, ess_read_mix_reg(sc, 0x68));
        printf("ESS_LINE_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x6E, ess_read_mix_reg(sc, 0x6E));
        printf("ESS_SYNTH_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x6B, ess_read_mix_reg(sc, 0x6B));
        printf("ESS_CD_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x6A, ess_read_mix_reg(sc, 0x6A));
        printf("ESS_AUXB_REC_VOL: mix reg 0x%02x=0x%02x\n",
               0x6C, ess_read_mix_reg(sc, 0x6C));
        printf("ESS_RECORD_VOL: x reg 0x%02x=0x%02x\n",
               0xB4, ess_read_x_reg(sc, 0xB4));
        printf("Audio 1 play vol (unused): mix reg 0x%02x=0x%02x\n",
               0x14, ess_read_mix_reg(sc, 0x14));

        printf("ESS_MIC_PREAMP: x reg 0x%02x=0x%02x\n",
               ESS_XCMD_PREAMP_CTRL, ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL));
        printf("ESS_RECORD_MONITOR: x reg 0x%02x=0x%02x\n",
               ESS_XCMD_AUDIO_CTRL, ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL));
        printf("Record source: mix reg 0x%02x=0x%02x, 0x%02x=0x%02x\n",
               ESS_MREG_ADC_SOURCE, ess_read_mix_reg(sc, ESS_MREG_ADC_SOURCE),
               ESS_MREG_AUDIO2_CTRL2, ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2));
}

#endif

/*
 * Configure the ESS chip for the desired audio base address.
 */
int
ess_config_addr(struct ess_softc *sc)
{
        int iobase;
        bus_space_tag_t iot;
        /*
         * Configure using the System Control Register method.  This
         * method is used when the AMODE line is tied high, which is
         * the case for the Shark, but not for the evaluation board.
         */
        bus_space_handle_t scr_access_ioh;
        bus_space_handle_t scr_ioh;
        u_short scr_value;

        iobase = sc->sc_iobase;
        iot = sc->sc_iot;
        /*
         * Set the SCR bit to enable audio.
         */
        scr_value = ESS_SCR_AUDIO_ENABLE;

        /*
         * Set the SCR bits necessary to select the specified audio
         * base address.
         */
        switch(iobase) {
        case 0x220:
                scr_value |= ESS_SCR_AUDIO_220;
                break;
        case 0x230:
                scr_value |= ESS_SCR_AUDIO_230;
                break;
        case 0x240:
                scr_value |= ESS_SCR_AUDIO_240;
                break;
        case 0x250:
                scr_value |= ESS_SCR_AUDIO_250;
                break;
        default:
                printf("ess: configured iobase 0x%x invalid\n", iobase);
                return 1;
                break;
        }

        /*
         * Get a mapping for the System Control Register (SCR) access
         * registers and the SCR data registers.
         */
        if (bus_space_map(iot, ESS_SCR_ACCESS_BASE, ESS_SCR_ACCESS_PORTS,
                          0, &scr_access_ioh)) {
                printf("ess: can't map SCR access registers\n");
                return 1;
        }
        if (bus_space_map(iot, ESS_SCR_BASE, ESS_SCR_PORTS,
                          0, &scr_ioh)) {
                printf("ess: can't map SCR registers\n");
                bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
                return 1;
        }

        /* Unlock the SCR. */
        EWRITE1(iot, scr_access_ioh, ESS_SCR_UNLOCK, 0);

        /* Write the base address information into SCR[0]. */
        EWRITE1(iot, scr_ioh, ESS_SCR_INDEX, 0);
        EWRITE1(iot, scr_ioh, ESS_SCR_DATA, scr_value);

        /* Lock the SCR. */
        EWRITE1(iot, scr_access_ioh, ESS_SCR_LOCK, 0);

        /* Unmap the SCR access ports and the SCR data ports. */
        bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
        bus_space_unmap(iot, scr_ioh, ESS_SCR_PORTS);

        return 0;
}


/*
 * Configure the ESS chip for the desired IRQ and DMA channels.
 * ESS  ISA
 * --------
 * IRQA irq9
 * IRQB irq5
 * IRQC irq7
 * IRQD irq10
 * IRQE irq15
 *
 * DRQA drq0
 * DRQB drq1
 * DRQC drq3
 * DRQD drq5
 */
void
ess_config_irq(struct ess_softc *sc)
{
        int v;

        DPRINTFN(2,("ess_config_irq\n"));

        if (sc->sc_model == ESS_1887 &&
            sc->sc_audio1.irq == sc->sc_audio2.irq &&
            sc->sc_audio1.irq != -1) {
                /* Use new method, both interrupts are the same. */
                v = ESS_IS_SELECT_IRQ;  /* enable intrs */
                switch (sc->sc_audio1.irq) {
                case 5:
                        v |= ESS_IS_INTRB;
                        break;
                case 7:
                        v |= ESS_IS_INTRC;
                        break;
                case 9:
                        v |= ESS_IS_INTRA;
                        break;
                case 10:
                        v |= ESS_IS_INTRD;
                        break;
                case 15:
                        v |= ESS_IS_INTRE;
                        break;
#ifdef DIAGNOSTIC
                default:
                        printf("ess_config_irq: configured irq %d not supported for Audio 1\n",
                               sc->sc_audio1.irq);
                        return;
#endif
                }
                /* Set the IRQ */
                ess_write_mix_reg(sc, ESS_MREG_INTR_ST, v);
                return;
        }

        if (sc->sc_model == ESS_1887) {
                /* Tell the 1887 to use the old interrupt method. */
                ess_write_mix_reg(sc, ESS_MREG_INTR_ST, ESS_IS_ES1888);
        }

        if (sc->sc_audio1.polled) {
                /* Turn off Audio1 interrupts. */
                v = 0;
        } else {
                /* Configure Audio 1 for the appropriate IRQ line. */
                v = ESS_IRQ_CTRL_MASK | ESS_IRQ_CTRL_EXT; /* All intrs on */
                switch (sc->sc_audio1.irq) {
                case 5:
                        v |= ESS_IRQ_CTRL_INTRB;
                        break;
                case 7:
                        v |= ESS_IRQ_CTRL_INTRC;
                        break;
                case 9:
                        v |= ESS_IRQ_CTRL_INTRA;
                        break;
                case 10:
                        v |= ESS_IRQ_CTRL_INTRD;
                        break;
#ifdef DIAGNOSTIC
                default:
                        printf("ess: configured irq %d not supported for Audio 1\n",
                               sc->sc_audio1.irq);
                        return;
#endif
                }
        }
        ess_write_x_reg(sc, ESS_XCMD_IRQ_CTRL, v);

        if (ESS_USE_AUDIO1(sc->sc_model))
                return;

        if (sc->sc_audio2.polled) {
                /* Turn off Audio2 interrupts. */
                ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
                                    ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
        } else {
                /* Audio2 is hardwired to INTRE in this mode. */
                ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
                                  ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
        }
}


void
ess_config_drq(struct ess_softc *sc)
{
        int v;

        DPRINTFN(2,("ess_config_drq\n"));

        /* Configure Audio 1 (record) for DMA on the appropriate channel. */
        v = ESS_DRQ_CTRL_PU | ESS_DRQ_CTRL_EXT;
        switch (sc->sc_audio1.drq) {
        case 0:
                v |= ESS_DRQ_CTRL_DRQA;
                break;
        case 1:
                v |= ESS_DRQ_CTRL_DRQB;
                break;
        case 3:
                v |= ESS_DRQ_CTRL_DRQC;
                break;
#ifdef DIAGNOSTIC
        default:
                printf("ess_config_drq: configured DMA chan %d not supported for Audio 1\n",
                       sc->sc_audio1.drq);
                return;
#endif
        }
        /* Set DRQ1 */
        ess_write_x_reg(sc, ESS_XCMD_DRQ_CTRL, v);

        if (ESS_USE_AUDIO1(sc->sc_model))
                return;

        /* Configure DRQ2 */
        v = ESS_AUDIO2_CTRL3_DRQ_PD;
        switch (sc->sc_audio2.drq) {
        case 0:
                v |= ESS_AUDIO2_CTRL3_DRQA;
                break;
        case 1:
                v |= ESS_AUDIO2_CTRL3_DRQB;
                break;
        case 3:
                v |= ESS_AUDIO2_CTRL3_DRQC;
                break;
        case 5:
                v |= ESS_AUDIO2_CTRL3_DRQD;
                break;
#ifdef DIAGNOSTIC
        default:
                printf("ess_config_drq: configured DMA chan %d not supported for Audio 2\n",
                       sc->sc_audio2.drq);
                return;
#endif
        }
        ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL3, v);
        /* Enable DMA 2 */
        ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
                          ESS_AUDIO2_CTRL2_DMA_ENABLE);
}

/*
 * Set up registers after a reset.
 */
void
ess_setup(struct ess_softc *sc)
{

        ess_config_irq(sc);
        ess_config_drq(sc);

        DPRINTFN(2,("ess_setup: done\n"));
}

/*
 * Determine the model of ESS chip we are talking to.  Currently we
 * only support ES1888, ES1887 and ES888.  The method of determining
 * the chip is based on the information on page 27 of the ES1887 data
 * sheet.
 *
 * This routine sets the values of sc->sc_model and sc->sc_version.
 */
int
ess_identify(struct ess_softc *sc)
{
        u_char reg1;
        u_char reg2;
        u_char reg3;
        u_int8_t ident[4];

        sc->sc_model = ESS_UNSUPPORTED;
        sc->sc_version = 0;

        memset(ident, 0, sizeof(ident));

        /*
         * 1. Check legacy ID bytes.  These should be 0x68 0x8n, where
         *    n >= 8 for an ES1887 or an ES888.  Other values indicate
         *    earlier (unsupported) chips.
         */
        ess_wdsp(sc, ESS_ACMD_LEGACY_ID);

        if ((reg1 = ess_rdsp(sc)) != 0x68) {
                printf("ess: First ID byte wrong (0x%02x)\n", reg1);
                return 1;
        }

        reg2 = ess_rdsp(sc);
        if (((reg2 & 0xf0) != 0x80) ||
            ((reg2 & 0x0f) < 8)) {
                sc->sc_model = ESS_688;
                return 0;
        }

        /*
         * Store the ID bytes as the version.
         */
        sc->sc_version = (reg1 << 8) + reg2;


        /*
         * 2. Verify we can change bit 2 in mixer register 0x64.  This
         *    should be possible on all supported chips.
         */
        reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
        reg2 = reg1 ^ 0x04;  /* toggle bit 2 */

        ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);

        if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) != reg2) {
                switch (sc->sc_version) {
                case 0x688b:
                        sc->sc_model = ESS_1688;
                        break;
                default:
                        printf("ess: Hardware error (unable to toggle bit 2 of mixer register 0x64)\n");
                        return 1;
                }
                return 0;
        }

        /*
         * Restore the original value of mixer register 0x64.
         */
        ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);


        /*
         * 3. Verify we can change the value of mixer register
         *    ESS_MREG_SAMPLE_RATE.
         *    This is possible on the 1888/1887/888, but not on the 1788.
         *    It is not necessary to restore the value of this mixer register.
         */
        reg1 = ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE);
        reg2 = reg1 ^ 0xff;  /* toggle all bits */

        ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, reg2);

        if (ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE) != reg2) {
                /* If we got this far before failing, it's a 1788. */
                sc->sc_model = ESS_1788;

                /*
                 * Identify ESS model for ES18[67]8.
                 */
                ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
                if(ident[0] == 0x18) {
                        switch(ident[1]) {
                        case 0x68:
                                sc->sc_model = ESS_1868;
                                break;
                        case 0x78:
                                sc->sc_model = ESS_1878;
                                break;
                        }
                }

                return 0;
        }

        /*
         * 4. Determine if we can change bit 5 in mixer register 0x64.
         *    This determines whether we have an ES1887:
         *
         *    - can change indicates ES1887
         *    - can't change indicates ES1888 or ES888
         */
        reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
        reg2 = reg1 ^ 0x20;  /* toggle bit 5 */

        ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);

        if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) == reg2) {
                sc->sc_model = ESS_1887;

                /*
                 * Restore the original value of mixer register 0x64.
                 */
                ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);

                /*
                 * Identify ESS model for ES18[67]9.
                 */
                ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
                if(ident[0] == 0x18) {
                        switch(ident[1]) {
                        case 0x69:
                                sc->sc_model = ESS_1869;
                                break;
                        case 0x79:
                                sc->sc_model = ESS_1879;
                                break;
                        }
                }

                return 0;
        }

        /*
         * 5. Determine if we can change the value of mixer
         *    register 0x69 independently of mixer register
         *    0x68. This determines which chip we have:
         *
         *    - can modify independently indicates ES888
         *    - register 0x69 is an alias of 0x68 indicates ES1888
         */
        reg1 = ess_read_mix_reg(sc, 0x68);
        reg2 = ess_read_mix_reg(sc, 0x69);
        reg3 = reg2 ^ 0xff;  /* toggle all bits */

        /*
         * Write different values to each register.
         */
        ess_write_mix_reg(sc, 0x68, reg2);
        ess_write_mix_reg(sc, 0x69, reg3);

        if (ess_read_mix_reg(sc, 0x68) == reg2 &&
            ess_read_mix_reg(sc, 0x69) == reg3)
                sc->sc_model = ESS_888;
        else
                sc->sc_model = ESS_1888;

        /*
         * Restore the original value of the registers.
         */
        ess_write_mix_reg(sc, 0x68, reg1);
        ess_write_mix_reg(sc, 0x69, reg2);

        return 0;
}


int
ess_setup_sc(struct ess_softc *sc, int doinit)
{

        /* Reset the chip. */
        if (ess_reset(sc) != 0) {
                DPRINTF(("ess_setup_sc: couldn't reset chip\n"));
                return 1;
        }

        /* Identify the ESS chip, and check that it is supported. */
        if (ess_identify(sc)) {
                DPRINTF(("ess_setup_sc: couldn't identify\n"));
                return 1;
        }

        return 0;
}

/*
 * Probe for the ESS hardware.
 */
int
essmatch(struct ess_softc *sc)
{
        if (!ESS_BASE_VALID(sc->sc_iobase)) {
                printf("ess: configured iobase 0x%x invalid\n", sc->sc_iobase);
                return 0;
        }

        if (ess_setup_sc(sc, 1))
                return 0;

        if (sc->sc_model == ESS_UNSUPPORTED) {
                DPRINTF(("ess: Unsupported model\n"));
                return 0;
        }

        /* Check that requested DMA channels are valid and different. */
        if (!ESS_DRQ1_VALID(sc->sc_audio1.drq)) {
                printf("ess: record drq %d invalid\n", sc->sc_audio1.drq);
                return 0;
        }
        if (!isa_drq_isfree(sc->sc_ic, sc->sc_audio1.drq))
                return 0;
        if (!ESS_USE_AUDIO1(sc->sc_model)) {
                if (!ESS_DRQ2_VALID(sc->sc_audio2.drq)) {
                        printf("ess: play drq %d invalid\n", sc->sc_audio2.drq);
                        return 0;
                }
                if (sc->sc_audio1.drq == sc->sc_audio2.drq) {
                        printf("ess: play and record drq both %d\n",
                               sc->sc_audio1.drq);
                        return 0;
                }
                if (!isa_drq_isfree(sc->sc_ic, sc->sc_audio2.drq))
                        return 0;
        }

        /*
         * The 1887 has an additional IRQ mode where both channels are mapped
         * to the same IRQ.
         */
        if (sc->sc_model == ESS_1887 &&
            sc->sc_audio1.irq == sc->sc_audio2.irq &&
            sc->sc_audio1.irq != -1 &&
            ESS_IRQ12_VALID(sc->sc_audio1.irq))
                goto irq_not1888;

        /* Check that requested IRQ lines are valid and different. */
        if (sc->sc_audio1.irq != -1 &&
            !ESS_IRQ1_VALID(sc->sc_audio1.irq)) {
                printf("ess: record irq %d invalid\n", sc->sc_audio1.irq);
                return 0;
        }
        if (!ESS_USE_AUDIO1(sc->sc_model)) {
                if (sc->sc_audio2.irq != -1 &&
                    !ESS_IRQ2_VALID(sc->sc_audio2.irq)) {
                        printf("ess: play irq %d invalid\n", sc->sc_audio2.irq);
                        return 0;
                }
                if (sc->sc_audio1.irq == sc->sc_audio2.irq &&
                    sc->sc_audio1.irq != -1) {
                        printf("ess: play and record irq both %d\n",
                               sc->sc_audio1.irq);
                        return 0;
                }
        }

irq_not1888:
        /* XXX should we check IRQs as well? */

        return 2; /* beat "sb" */
}


/*
 * Attach hardware to driver, attach hardware driver to audio
 * pseudo-device driver.
 */
void
essattach(struct ess_softc *sc, int enablejoy)
{
        struct audio_attach_args arg;
        int i;
        u_int v;

        if (ess_setup_sc(sc, 0)) {
                aprint_error(": setup failed\n");
                return;
        }

        aprint_normal("ESS Technology ES%s [version 0x%04x]\n",
            essmodel[sc->sc_model], sc->sc_version);

        callout_init(&sc->sc_poll1_ch, CALLOUT_MPSAFE);
        callout_init(&sc->sc_poll2_ch, CALLOUT_MPSAFE);
        mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
        mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_AUDIO);

        sc->sc_audio1.polled = sc->sc_audio1.irq == -1;
        if (!sc->sc_audio1.polled) {
                sc->sc_audio1.ih = isa_intr_establish(sc->sc_ic,
                    sc->sc_audio1.irq, sc->sc_audio1.ist, IPL_AUDIO,
                    ess_audio1_intr, sc);
                aprint_normal_dev(sc->sc_dev,
                    "audio1 interrupting at irq %d\n", sc->sc_audio1.irq);
        } else
                aprint_normal_dev(sc->sc_dev, "audio1 polled\n");
        sc->sc_audio1.maxsize = isa_dmamaxsize(sc->sc_ic, sc->sc_audio1.drq);

        if (isa_drq_alloc(sc->sc_ic, sc->sc_audio1.drq) != 0) {
                aprint_error_dev(sc->sc_dev, "can't reserve drq %d\n",
                    sc->sc_audio1.drq);
                goto fail;
        }

        if (isa_dmamap_create(sc->sc_ic, sc->sc_audio1.drq,
            sc->sc_audio1.maxsize, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
                aprint_error_dev(sc->sc_dev, "can't create map for drq %d\n",
                    sc->sc_audio1.drq);
                goto fail;
        }

        if (!ESS_USE_AUDIO1(sc->sc_model)) {
                sc->sc_audio2.polled = sc->sc_audio2.irq == -1;
                if (!sc->sc_audio2.polled) {
                        sc->sc_audio2.ih = isa_intr_establish(sc->sc_ic,
                            sc->sc_audio2.irq, sc->sc_audio2.ist, IPL_AUDIO,
                            ess_audio2_intr, sc);
                        aprint_normal_dev(sc->sc_dev,
                            "audio2 interrupting at irq %d\n",
                            sc->sc_audio2.irq);
                } else
                        aprint_normal_dev(sc->sc_dev, "audio2 polled\n");
                sc->sc_audio2.maxsize = isa_dmamaxsize(sc->sc_ic,
                    sc->sc_audio2.drq);

                if (isa_drq_alloc(sc->sc_ic, sc->sc_audio2.drq) != 0) {
                        aprint_error_dev(sc->sc_dev, "can't reserve drq %d\n",
                            sc->sc_audio2.drq);
                        goto fail;
                }

                if (isa_dmamap_create(sc->sc_ic, sc->sc_audio2.drq,
                    sc->sc_audio2.maxsize, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
                        aprint_error_dev(sc->sc_dev,
                            "can't create map for drq %d\n",
                            sc->sc_audio2.drq);
                        goto fail;
                }
        }

        /* Do a hardware reset on the mixer. */
        ess_write_mix_reg(sc, ESS_MIX_RESET, ESS_MIX_RESET);

        /*
         * Set volume of Audio 1 to zero and disable Audio 1 DAC input
         * to playback mixer, since playback is always through Audio 2.
         */
        if (!ESS_USE_AUDIO1(sc->sc_model))
                ess_write_mix_reg(sc, ESS_MREG_VOLUME_VOICE, 0);
        ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);

        if (ESS_USE_AUDIO1(sc->sc_model)) {
                ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIC);
                sc->in_port = ESS_SOURCE_MIC;
                if (ESS_IS_ES18X9(sc->sc_model)) {
                        sc->ndevs = ESS_18X9_NDEVS;
                        sc->sc_spatializer = 0;
                        ess_set_mreg_bits(sc, ESS_MREG_MODE,
                            ESS_MODE_ASYNC_MODE | ESS_MODE_NEWREG);
                        ess_set_mreg_bits(sc, ESS_MREG_SPATIAL_CTRL,
                            ESS_SPATIAL_CTRL_RESET);
                        ess_clear_mreg_bits(sc, ESS_MREG_SPATIAL_CTRL,
                            ESS_SPATIAL_CTRL_ENABLE | ESS_SPATIAL_CTRL_MONO);
                } else
                        sc->ndevs = ESS_1788_NDEVS;
        } else {
                /*
                 * Set hardware record source to use output of the record
                 * mixer. We do the selection of record source in software by
                 * setting the gain of the unused sources to zero. (See
                 * ess_set_in_ports.)
                 */
                ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIXER);
                sc->in_mask = 1 << ESS_MIC_REC_VOL;
                sc->ndevs = ESS_1888_NDEVS;
                ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x10);
                ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x08);
        }

        /*
         * Set gain on each mixer device to a sensible value.
         * Devices not normally used are turned off, and other devices
         * are set to 50% volume.
         */
        for (i = 0; i < sc->ndevs; i++) {
                if (ESS_IS_ES18X9(sc->sc_model)) {
                        switch (i) {
                        case ESS_SPATIALIZER:
                        case ESS_SPATIALIZER_ENABLE:
                                v = 0;
                                goto skip;
                        }
                }
                switch (i) {
                case ESS_MIC_PLAY_VOL:
                case ESS_LINE_PLAY_VOL:
                case ESS_CD_PLAY_VOL:
                case ESS_AUXB_PLAY_VOL:
                case ESS_DAC_REC_VOL:
                case ESS_LINE_REC_VOL:
                case ESS_SYNTH_REC_VOL:
                case ESS_CD_REC_VOL:
                case ESS_AUXB_REC_VOL:
                        v = 0;
                        break;
                default:
                        v = ESS_4BIT_GAIN(AUDIO_MAX_GAIN / 2);
                        break;
                }
skip:
                sc->gain[i][ESS_LEFT] = sc->gain[i][ESS_RIGHT] = v;
                ess_set_gain(sc, i, 1);
        }

        ess_setup(sc);

        /* Disable the speaker until the device is opened.  */
        ess_speaker_off(sc);
        sc->spkr_state = SPKR_OFF;

        snprintf(ess_device.name, sizeof(ess_device.name), "ES%s",
            essmodel[sc->sc_model]);
        snprintf(ess_device.version, sizeof(ess_device.version), "0x%04x",
            sc->sc_version);

        if (ESS_USE_AUDIO1(sc->sc_model))
                audio_attach_mi(&ess_1788_hw_if, sc, sc->sc_dev);
        else
                audio_attach_mi(&ess_1888_hw_if, sc, sc->sc_dev);

        arg.type = AUDIODEV_TYPE_OPL;
        arg.hwif = 0;
        arg.hdl = 0;
        (void)config_found(sc->sc_dev, &arg, audioprint,
            CFARGS(.iattr = "ess"));

#if NJOY_ESS > 0
        if (sc->sc_model == ESS_1888 && enablejoy) {
                unsigned char m40;

                m40 = ess_read_mix_reg(sc, 0x40);
                m40 |= 2;
                ess_write_mix_reg(sc, 0x40, m40);

                arg.type = AUDIODEV_TYPE_AUX;
                (void)config_found(sc->sc_dev, &arg, audioprint,
                    CFARGS(.iattr = "ess"));
        }
#endif

#ifdef AUDIO_DEBUG
        if (essdebug > 0)
                ess_printsc(sc);
#endif

        return;

 fail:
        callout_destroy(&sc->sc_poll1_ch);
        callout_destroy(&sc->sc_poll2_ch);
        mutex_destroy(&sc->sc_lock);
        mutex_destroy(&sc->sc_intr_lock);
}

/*
 * Various routines to interface to higher level audio driver
 */

void
ess_close(void *addr)
{
        struct ess_softc *sc;

        sc = addr;
        DPRINTF(("ess_close: sc=%p\n", sc));

        ess_speaker_off(sc);
        sc->spkr_state = SPKR_OFF;

        DPRINTF(("ess_close: closed\n"));
}

/* XXX should use reference count */
int
ess_speaker_ctl(void *addr, int newstate)
{
        struct ess_softc *sc;

        sc = addr;
        if ((newstate == SPKR_ON) && (sc->spkr_state == SPKR_OFF)) {
                ess_speaker_on(sc);
                sc->spkr_state = SPKR_ON;
        }
        if ((newstate == SPKR_OFF) && (sc->spkr_state == SPKR_ON)) {
                ess_speaker_off(sc);
                sc->spkr_state = SPKR_OFF;
        }
        return 0;
}

int
ess_getdev(void *addr, struct audio_device *retp)
{

        *retp = ess_device;
        return 0;
}

int
ess_query_format(void *addr, audio_format_query_t *afp)
{

        return audio_query_format(ess_formats, ESS_NFORMATS, afp);
}

int
ess_set_format(void *addr, int setmode,
        const audio_params_t *play, const audio_params_t *rec,
        audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
        struct ess_softc *sc;
        int rate;

        DPRINTF(("%s: set=%d\n", __func__, setmode));
        sc = addr;

        /* *play and *rec are the identical because !AUDIO_PROP_INDEPENDENT. */

        rate = play->sample_rate;
        ess_write_x_reg(sc, ESS_XCMD_SAMPLE_RATE, ess_srtotc(sc, rate));
        ess_write_x_reg(sc, ESS_XCMD_FILTER_CLOCK, ess_srtofc(rate));

        if (!ESS_USE_AUDIO1(sc->sc_model)) {
                ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE,
                    ess_srtotc(sc, rate));
                ess_write_mix_reg(sc, ESS_MREG_FILTER_CLOCK, ess_srtofc(rate));
        }

        return 0;
}

int
ess_audio1_trigger_output(
        void *addr,
        void *start, void *end,
        int blksize,
        void (*intr)(void *),
        void *arg,
        const audio_params_t *param)
{
        struct ess_softc *sc;
        u_int8_t reg;

        sc = addr;
        DPRINTFN(1, ("ess_audio1_trigger_output: sc=%p start=%p end=%p "
            "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));

        if (sc->sc_audio1.active)
                panic("ess_audio1_trigger_output: already running");

        sc->sc_audio1.active = 1;
        sc->sc_audio1.intr = intr;
        sc->sc_audio1.arg = arg;
        if (sc->sc_audio1.polled) {
                sc->sc_audio1.dmapos = 0;
                sc->sc_audio1.buffersize = (char *)end - (char *)start;
                sc->sc_audio1.dmacount = 0;
                sc->sc_audio1.blksize = blksize;
                callout_reset(&sc->sc_poll1_ch, hz / 30,
                    ess_audio1_poll, sc);
        }

        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
        if (param->channels == 2) {
                reg &= ~ESS_AUDIO_CTRL_MONO;
                reg |= ESS_AUDIO_CTRL_STEREO;
        } else {
                reg |= ESS_AUDIO_CTRL_MONO;
                reg &= ~ESS_AUDIO_CTRL_STEREO;
        }
        ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);

        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
        if (param->precision == 16)
                reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
        if (param->channels == 2)
                reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
        if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
            param->encoding == AUDIO_ENCODING_SLINEAR_LE)
                reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
        reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
        ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);

        isa_dmastart(sc->sc_ic, sc->sc_audio1.drq, start,
                     (char *)end - (char *)start, NULL,
            DMAMODE_WRITE | DMAMODE_LOOPDEMAND, BUS_DMA_NOWAIT);

        /* Program transfer count registers with 2's complement of count. */
        blksize = -blksize;
        ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
        ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);

        /* Use 4 bytes per output DMA. */
        ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);

        /* Start auto-init DMA */
        ess_wdsp(sc, ESS_ACMD_ENABLE_SPKR);
        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
        reg &= ~(ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE);
        reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
        ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);

        return 0;
}

int
ess_audio2_trigger_output(
        void *addr,
        void *start, void *end,
        int blksize,
        void (*intr)(void *),
        void *arg,
        const audio_params_t *param)
{
        struct ess_softc *sc;
        u_int8_t reg;

        sc = addr;
        DPRINTFN(1, ("ess_audio2_trigger_output: sc=%p start=%p end=%p "
            "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));

        if (sc->sc_audio2.active)
                panic("ess_audio2_trigger_output: already running");

        sc->sc_audio2.active = 1;
        sc->sc_audio2.intr = intr;
        sc->sc_audio2.arg = arg;
        if (sc->sc_audio2.polled) {
                sc->sc_audio2.dmapos = 0;
                sc->sc_audio2.buffersize = (char *)end - (char *)start;
                sc->sc_audio2.dmacount = 0;
                sc->sc_audio2.blksize = blksize;
                callout_reset(&sc->sc_poll2_ch, hz / 30,
                    ess_audio2_poll, sc);
        }

        reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
        if (param->precision == 16)
                reg |= ESS_AUDIO2_CTRL2_FIFO_SIZE;
        else
                reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIZE;
        if (param->channels == 2)
                reg |= ESS_AUDIO2_CTRL2_CHANNELS;
        else
                reg &= ~ESS_AUDIO2_CTRL2_CHANNELS;
        if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
            param->encoding == AUDIO_ENCODING_SLINEAR_LE)
                reg |= ESS_AUDIO2_CTRL2_FIFO_SIGNED;
        else
                reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIGNED;
        ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);

        isa_dmastart(sc->sc_ic, sc->sc_audio2.drq, start,
                     (char *)end - (char *)start, NULL,
            DMAMODE_WRITE | DMAMODE_LOOPDEMAND, BUS_DMA_NOWAIT);

        if (IS16BITDRQ(sc->sc_audio2.drq))
                blksize >>= 1;  /* use word count for 16 bit DMA */
        /* Program transfer count registers with 2's complement of count. */
        blksize = -blksize;
        ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTLO, blksize);
        ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTHI, blksize >> 8);

        reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1);
        if (IS16BITDRQ(sc->sc_audio2.drq))
                reg |= ESS_AUDIO2_CTRL1_XFER_SIZE;
        else
                reg &= ~ESS_AUDIO2_CTRL1_XFER_SIZE;
        reg |= ESS_AUDIO2_CTRL1_DEMAND_8;
        reg |= ESS_AUDIO2_CTRL1_DAC_ENABLE | ESS_AUDIO2_CTRL1_FIFO_ENABLE |
               ESS_AUDIO2_CTRL1_AUTO_INIT;
        ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1, reg);

        return (0);
}

int
ess_audio1_trigger_input(
        void *addr,
        void *start, void *end,
        int blksize,
        void (*intr)(void *),
        void *arg,
        const audio_params_t *param)
{
        struct ess_softc *sc;
        u_int8_t reg;

        sc = addr;
        DPRINTFN(1, ("ess_audio1_trigger_input: sc=%p start=%p end=%p "
            "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg));

        if (sc->sc_audio1.active)
                panic("ess_audio1_trigger_input: already running");

        sc->sc_audio1.active = 1;
        sc->sc_audio1.intr = intr;
        sc->sc_audio1.arg = arg;
        if (sc->sc_audio1.polled) {
                sc->sc_audio1.dmapos = 0;
                sc->sc_audio1.buffersize = (char *)end - (char *)start;
                sc->sc_audio1.dmacount = 0;
                sc->sc_audio1.blksize = blksize;
                callout_reset(&sc->sc_poll1_ch, hz / 30,
                    ess_audio1_poll, sc);
        }

        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
        if (param->channels == 2) {
                reg &= ~ESS_AUDIO_CTRL_MONO;
                reg |= ESS_AUDIO_CTRL_STEREO;
        } else {
                reg |= ESS_AUDIO_CTRL_MONO;
                reg &= ~ESS_AUDIO_CTRL_STEREO;
        }
        ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);

        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
        if (param->precision == 16)
                reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
        if (param->channels == 2)
                reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
        if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
            param->encoding == AUDIO_ENCODING_SLINEAR_LE)
                reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
        else
                reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
        reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
        ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);

        isa_dmastart(sc->sc_ic, sc->sc_audio1.drq, start,
                     (char *)end - (char *)start, NULL,
            DMAMODE_READ | DMAMODE_LOOPDEMAND, BUS_DMA_NOWAIT);

        /* Program transfer count registers with 2's complement of count. */
        blksize = -blksize;
        ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
        ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);

        /* Use 4 bytes per input DMA. */
        ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);

        /* Start auto-init DMA */
        ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
        reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
        reg |= ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE;
        reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
        ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);

        return 0;
}

int
ess_audio1_halt(void *addr)
{
        struct ess_softc *sc;

        sc = addr;
        DPRINTF(("ess_audio1_halt: sc=%p\n", sc));

        if (sc->sc_audio1.active) {
                ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO1_CTRL2,
                    ESS_AUDIO1_CTRL2_FIFO_ENABLE);
                isa_dmaabort(sc->sc_ic, sc->sc_audio1.drq);
                if (sc->sc_audio1.polled)
                        callout_stop(&sc->sc_poll1_ch);
                sc->sc_audio1.active = 0;
        }

        return 0;
}

int
ess_audio2_halt(void *addr)
{
        struct ess_softc *sc;

        sc = addr;
        DPRINTF(("ess_audio2_halt: sc=%p\n", sc));

        if (sc->sc_audio2.active) {
                ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL1,
                    ESS_AUDIO2_CTRL1_DAC_ENABLE |
                    ESS_AUDIO2_CTRL1_FIFO_ENABLE);
                isa_dmaabort(sc->sc_ic, sc->sc_audio2.drq);
                if (sc->sc_audio2.polled)
                        callout_stop(&sc->sc_poll2_ch);
                sc->sc_audio2.active = 0;
        }

        return 0;
}

int
ess_audio1_intr(void *arg)
{
        struct ess_softc *sc;
        uint8_t reg;
        int rv;

        sc = arg;
        DPRINTFN(1,("ess_audio1_intr: intr=%p\n", sc->sc_audio1.intr));

        mutex_spin_enter(&sc->sc_intr_lock);

        /* Check and clear interrupt on Audio1. */
        reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS);
        if ((reg & ESS_DSP_READ_OFLOW) == 0) {
                mutex_spin_exit(&sc->sc_intr_lock);
                return 0;
        }
        reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_CLEAR_INTR);

        sc->sc_audio1.nintr++;

        if (sc->sc_audio1.active) {
                (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
                rv = 1;
        } else
                rv = 0;

        mutex_spin_exit(&sc->sc_intr_lock);

        return rv;
}

int
ess_audio2_intr(void *arg)
{
        struct ess_softc *sc;
        uint8_t reg;
        int rv;

        sc = arg;
        DPRINTFN(1,("ess_audio2_intr: intr=%p\n", sc->sc_audio2.intr));

        mutex_spin_enter(&sc->sc_intr_lock);

        /* Check and clear interrupt on Audio2. */
        reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
        if ((reg & ESS_AUDIO2_CTRL2_IRQ_LATCH) == 0) {
                mutex_spin_exit(&sc->sc_intr_lock);
                return 0;
        }
        reg &= ~ESS_AUDIO2_CTRL2_IRQ_LATCH;
        ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);

        sc->sc_audio2.nintr++;

        if (sc->sc_audio2.active) {
                (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
                rv = 1;
        } else
                rv = 0;

        mutex_spin_exit(&sc->sc_intr_lock);

        return rv;
}

void
ess_audio1_poll(void *addr)
{
        struct ess_softc *sc;
        int dmapos, dmacount;

        sc = addr;
        mutex_spin_enter(&sc->sc_intr_lock);

        if (!sc->sc_audio1.active) {
                mutex_spin_exit(&sc->sc_intr_lock);
                return;
        }

        sc->sc_audio1.nintr++;

        dmapos = isa_dmacount(sc->sc_ic, sc->sc_audio1.drq);
        dmacount = sc->sc_audio1.dmapos - dmapos;
        if (dmacount < 0)
                dmacount += sc->sc_audio1.buffersize;
        sc->sc_audio1.dmapos = dmapos;
#if 1
        dmacount += sc->sc_audio1.dmacount;
        while (dmacount > sc->sc_audio1.blksize) {
                dmacount -= sc->sc_audio1.blksize;
                (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
        }
        sc->sc_audio1.dmacount = dmacount;
#else
        (*sc->sc_audio1.intr)(sc->sc_audio1.arg, dmacount);
#endif

        mutex_spin_exit(&sc->sc_intr_lock);
        callout_reset(&sc->sc_poll1_ch, hz / 30, ess_audio1_poll, sc);
}

void
ess_audio2_poll(void *addr)
{
        struct ess_softc *sc;
        int dmapos, dmacount;

        sc = addr;
        mutex_spin_enter(&sc->sc_intr_lock);

        if (!sc->sc_audio2.active) {
                mutex_spin_exit(&sc->sc_intr_lock);
                return;
        }

        sc->sc_audio2.nintr++;

        dmapos = isa_dmacount(sc->sc_ic, sc->sc_audio2.drq);
        dmacount = sc->sc_audio2.dmapos - dmapos;
        if (dmacount < 0)
                dmacount += sc->sc_audio2.buffersize;
        sc->sc_audio2.dmapos = dmapos;
#if 1
        dmacount += sc->sc_audio2.dmacount;
        while (dmacount > sc->sc_audio2.blksize) {
                dmacount -= sc->sc_audio2.blksize;
                (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
        }
        sc->sc_audio2.dmacount = dmacount;
#else
        (*sc->sc_audio2.intr)(sc->sc_audio2.arg, dmacount);
#endif

        mutex_spin_exit(&sc->sc_intr_lock);
        callout_reset(&sc->sc_poll2_ch, hz / 30, ess_audio2_poll, sc);
}

int
ess_round_blocksize(void *addr, int blk, int mode,
    const audio_params_t *param)
{

        return blk & -8;        /* round for max DMA size */
}

int
ess_set_port(void *addr, mixer_ctrl_t *cp)
{
        struct ess_softc *sc;
        int lgain, rgain;

        sc = addr;
        DPRINTFN(5,("ess_set_port: port=%d num_channels=%d\n",
                    cp->dev, cp->un.value.num_channels));

        switch (cp->dev) {
        /*
         * The following mixer ports are all stereo. If we get a
         * single-channel gain value passed in, then we duplicate it
         * to both left and right channels.
         */
        case ESS_MASTER_VOL:
        case ESS_DAC_PLAY_VOL:
        case ESS_MIC_PLAY_VOL:
        case ESS_LINE_PLAY_VOL:
        case ESS_SYNTH_PLAY_VOL:
        case ESS_CD_PLAY_VOL:
        case ESS_AUXB_PLAY_VOL:
        case ESS_RECORD_VOL:
                if (cp->type != AUDIO_MIXER_VALUE)
                        return EINVAL;

                switch (cp->un.value.num_channels) {
                case 1:
                        lgain = rgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
                        break;
                case 2:
                        lgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
                        rgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
                        break;
                default:
                        return EINVAL;
                }

                sc->gain[cp->dev][ESS_LEFT]  = lgain;
                sc->gain[cp->dev][ESS_RIGHT] = rgain;
                ess_set_gain(sc, cp->dev, 1);
                return 0;

        /*
         * The PC speaker port is mono. If we get a stereo gain value
         * passed in, then we return EINVAL.
         */
        case ESS_PCSPEAKER_VOL:
                if (cp->un.value.num_channels != 1)
                        return EINVAL;

                sc->gain[cp->dev][ESS_LEFT] = sc->gain[cp->dev][ESS_RIGHT] =
                  ESS_3BIT_GAIN(cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
                ess_set_gain(sc, cp->dev, 1);
                return 0;

        case ESS_RECORD_SOURCE:
                if (ESS_USE_AUDIO1(sc->sc_model)) {
                        if (cp->type == AUDIO_MIXER_ENUM)
                                return ess_set_in_port(sc, cp->un.ord);
                        else
                                return EINVAL;
                } else {
                        if (cp->type == AUDIO_MIXER_SET)
                                return ess_set_in_ports(sc, cp->un.mask);
                        else
                                return EINVAL;
                }
                return 0;

        case ESS_RECORD_MONITOR:
                if (cp->type != AUDIO_MIXER_ENUM)
                        return EINVAL;

                if (cp->un.ord)
                        /* Enable monitor */
                        ess_set_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
                                          ESS_AUDIO_CTRL_MONITOR);
                else
                        /* Disable monitor */
                        ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
                                            ESS_AUDIO_CTRL_MONITOR);
                return 0;
        }

        if (ESS_IS_ES18X9(sc->sc_model)) {

                switch (cp->dev) {
                case ESS_SPATIALIZER:
                        if (cp->type != AUDIO_MIXER_VALUE ||
                            cp->un.value.num_channels != 1)
                                return EINVAL;

                        sc->gain[cp->dev][ESS_LEFT] =
                                sc->gain[cp->dev][ESS_RIGHT] = ESS_6BIT_GAIN(
                                    cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
                        ess_set_gain(sc, cp->dev, 1);
                        return 0;

                case ESS_SPATIALIZER_ENABLE:
                        if (cp->type != AUDIO_MIXER_ENUM)
                                return EINVAL;

                        sc->sc_spatializer = (cp->un.ord != 0);
                        if (sc->sc_spatializer)
                                ess_set_mreg_bits(sc, ESS_MREG_SPATIAL_CTRL,
                                    ESS_SPATIAL_CTRL_ENABLE);
                        else
                                ess_clear_mreg_bits(sc, ESS_MREG_SPATIAL_CTRL,
                                    ESS_SPATIAL_CTRL_ENABLE);
                        return 0;
                }
        }

        if (ESS_USE_AUDIO1(sc->sc_model))
                return EINVAL;

        switch (cp->dev) {
        case ESS_DAC_REC_VOL:
        case ESS_MIC_REC_VOL:
        case ESS_LINE_REC_VOL:
        case ESS_SYNTH_REC_VOL:
        case ESS_CD_REC_VOL:
        case ESS_AUXB_REC_VOL:
                if (cp->type != AUDIO_MIXER_VALUE)
                        return EINVAL;

                switch (cp->un.value.num_channels) {
                case 1:
                        lgain = rgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
                        break;
                case 2:
                        lgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
                        rgain = ESS_4BIT_GAIN(
                          cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
                        break;
                default:
                        return EINVAL;
                }

                sc->gain[cp->dev][ESS_LEFT]  = lgain;
                sc->gain[cp->dev][ESS_RIGHT] = rgain;
                ess_set_gain(sc, cp->dev, 1);
                return 0;

        case ESS_MIC_PREAMP:
                if (cp->type != AUDIO_MIXER_ENUM)
                        return EINVAL;

                if (cp->un.ord)
                        /* Enable microphone preamp */
                        ess_set_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
                                          ESS_PREAMP_CTRL_ENABLE);
                else
                        /* Disable microphone preamp */
                        ess_clear_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
                                          ESS_PREAMP_CTRL_ENABLE);
                return 0;
        }

        return EINVAL;
}

int
ess_get_port(void *addr, mixer_ctrl_t *cp)
{
        struct ess_softc *sc;

        sc = addr;
        DPRINTFN(5,("ess_get_port: port=%d\n", cp->dev));

        switch (cp->dev) {
        case ESS_MASTER_VOL:
        case ESS_DAC_PLAY_VOL:
        case ESS_MIC_PLAY_VOL:
        case ESS_LINE_PLAY_VOL:
        case ESS_SYNTH_PLAY_VOL:
        case ESS_CD_PLAY_VOL:
        case ESS_AUXB_PLAY_VOL:
        case ESS_RECORD_VOL:
                switch (cp->un.value.num_channels) {
                case 1:
                        cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
                                sc->gain[cp->dev][ESS_LEFT];
                        break;
                case 2:
                        cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
                                sc->gain[cp->dev][ESS_LEFT];
                        cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
                                sc->gain[cp->dev][ESS_RIGHT];
                        break;
                default:
                        return EINVAL;
                }
                return 0;

        case ESS_PCSPEAKER_VOL:
                if (cp->un.value.num_channels != 1)
                        return EINVAL;

                cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
                        sc->gain[cp->dev][ESS_LEFT];
                return 0;

        case ESS_RECORD_SOURCE:
                if (ESS_USE_AUDIO1(sc->sc_model))
                        cp->un.ord = sc->in_port;
                else
                        cp->un.mask = sc->in_mask;
                return 0;

        case ESS_RECORD_MONITOR:
                cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL) &
                              ESS_AUDIO_CTRL_MONITOR) ? 1 : 0;
                return 0;
        }

        if (ESS_IS_ES18X9(sc->sc_model)) {

                switch (cp->dev) {
                case ESS_SPATIALIZER:
                        if (cp->un.value.num_channels != 1)
                                return EINVAL;

                        cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
                                sc->gain[cp->dev][ESS_LEFT];
                        return 0;

                case ESS_SPATIALIZER_ENABLE:
                        cp->un.ord = sc->sc_spatializer;
                        return 0;
                }
        }

        if (ESS_USE_AUDIO1(sc->sc_model))
                return EINVAL;

        switch (cp->dev) {
        case ESS_DAC_REC_VOL:
        case ESS_MIC_REC_VOL:
        case ESS_LINE_REC_VOL:
        case ESS_SYNTH_REC_VOL:
        case ESS_CD_REC_VOL:
        case ESS_AUXB_REC_VOL:
                switch (cp->un.value.num_channels) {
                case 1:
                        cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
                                sc->gain[cp->dev][ESS_LEFT];
                        break;
                case 2:
                        cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
                                sc->gain[cp->dev][ESS_LEFT];
                        cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
                                sc->gain[cp->dev][ESS_RIGHT];
                        break;
                default:
                        return EINVAL;
                }
                return 0;

        case ESS_MIC_PREAMP:
                cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL) &
                              ESS_PREAMP_CTRL_ENABLE) ? 1 : 0;
                return 0;
        }

        return EINVAL;
}

int
ess_query_devinfo(void *addr, mixer_devinfo_t *dip)
{
        struct ess_softc *sc;

        sc = addr;
        DPRINTFN(5,("ess_query_devinfo: model=%d index=%d\n",
                    sc->sc_model, dip->index));

        /*
         * REVISIT: There are some slight differences between the
         *          mixers on the different ESS chips, which can
         *          be sorted out using the chip model rather than a
         *          separate mixer model.
         *          This is currently coded assuming an ES1887; we
         *          need to work out which bits are not applicable to
         *          the other models (1888 and 888).
         */
        switch (dip->index) {
        case ESS_DAC_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNdac);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_MIC_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->prev = AUDIO_MIXER_LAST;
                if (ESS_USE_AUDIO1(sc->sc_model))
                        dip->next = AUDIO_MIXER_LAST;
                else
                        dip->next = ESS_MIC_PREAMP;
                strcpy(dip->label.name, AudioNmicrophone);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_LINE_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNline);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_SYNTH_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNfmsynth);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_CD_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNcd);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_AUXB_PLAY_VOL:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, "auxb");
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_INPUT_CLASS:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioCinputs);
                dip->type = AUDIO_MIXER_CLASS;
                return 0;

        case ESS_MASTER_VOL:
                dip->mixer_class = ESS_OUTPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNmaster);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_PCSPEAKER_VOL:
                dip->mixer_class = ESS_OUTPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, "pc_speaker");
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 1;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_OUTPUT_CLASS:
                dip->mixer_class = ESS_OUTPUT_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioCoutputs);
                dip->type = AUDIO_MIXER_CLASS;
                return 0;

        case ESS_RECORD_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNrecord);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_RECORD_SOURCE:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNsource);
                if (ESS_USE_AUDIO1(sc->sc_model)) {
                        /*
                         * The 1788 doesn't use the input mixer control that
                         * the 1888 uses, because it's a pain when you only
                         * have one mixer.
                         * Perhaps it could be emulated by keeping both sets of
                         * gain values, and doing a `context switch' of the
                         * mixer registers when shifting from playing to
                         * recording.
                         */
                        dip->type = AUDIO_MIXER_ENUM;
                        dip->un.e.num_mem = 4;
                        strcpy(dip->un.e.member[0].label.name, AudioNmicrophone);
                        dip->un.e.member[0].ord = ESS_SOURCE_MIC;
                        strcpy(dip->un.e.member[1].label.name, AudioNline);
                        dip->un.e.member[1].ord = ESS_SOURCE_LINE;
                        strcpy(dip->un.e.member[2].label.name, AudioNcd);
                        dip->un.e.member[2].ord = ESS_SOURCE_CD;
                        strcpy(dip->un.e.member[3].label.name, AudioNmixerout);
                        dip->un.e.member[3].ord = ESS_SOURCE_MIXER;
                } else {
                        dip->type = AUDIO_MIXER_SET;
                        dip->un.s.num_mem = 6;
                        strcpy(dip->un.s.member[0].label.name, AudioNdac);
                        dip->un.s.member[0].mask = 1 << ESS_DAC_REC_VOL;
                        strcpy(dip->un.s.member[1].label.name, AudioNmicrophone);
                        dip->un.s.member[1].mask = 1 << ESS_MIC_REC_VOL;
                        strcpy(dip->un.s.member[2].label.name, AudioNline);
                        dip->un.s.member[2].mask = 1 << ESS_LINE_REC_VOL;
                        strcpy(dip->un.s.member[3].label.name, AudioNfmsynth);
                        dip->un.s.member[3].mask = 1 << ESS_SYNTH_REC_VOL;
                        strcpy(dip->un.s.member[4].label.name, AudioNcd);
                        dip->un.s.member[4].mask = 1 << ESS_CD_REC_VOL;
                        strcpy(dip->un.s.member[5].label.name, "auxb");
                        dip->un.s.member[5].mask = 1 << ESS_AUXB_REC_VOL;
                }
                return 0;

        case ESS_RECORD_CLASS:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioCrecord);
                dip->type = AUDIO_MIXER_CLASS;
                return 0;

        case ESS_RECORD_MONITOR:
                dip->prev = dip->next = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNmute);
                dip->type = AUDIO_MIXER_ENUM;
                dip->mixer_class = ESS_MONITOR_CLASS;
                dip->un.e.num_mem = 2;
                strcpy(dip->un.e.member[0].label.name, AudioNoff);
                dip->un.e.member[0].ord = 0;
                strcpy(dip->un.e.member[1].label.name, AudioNon);
                dip->un.e.member[1].ord = 1;
                return 0;

        case ESS_MONITOR_CLASS:
                dip->mixer_class = ESS_MONITOR_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioCmonitor);
                dip->type = AUDIO_MIXER_CLASS;
                return 0;
        }

        if (ESS_IS_ES18X9(sc->sc_model)) {

                switch (dip->index) {
                case ESS_SPATIALIZER:
                        dip->mixer_class = ESS_OUTPUT_CLASS;
                        dip->prev = AUDIO_MIXER_LAST;
                        dip->next = ESS_SPATIALIZER_ENABLE;
                        strcpy(dip->label.name, AudioNspatial);
                        dip->type = AUDIO_MIXER_VALUE;
                        dip->un.v.num_channels = 1;
                        strcpy(dip->un.v.units.name, "level");
                        return 0;

                case ESS_SPATIALIZER_ENABLE:
                        dip->mixer_class = ESS_OUTPUT_CLASS;
                        dip->prev = ESS_SPATIALIZER;
                        dip->next = AUDIO_MIXER_LAST;
                        strcpy(dip->label.name, "enable");
                        dip->type = AUDIO_MIXER_ENUM;
                        dip->un.e.num_mem = 2;
                        strcpy(dip->un.e.member[0].label.name, AudioNoff);
                        dip->un.e.member[0].ord = 0;
                        strcpy(dip->un.e.member[1].label.name, AudioNon);
                        dip->un.e.member[1].ord = 1;
                        return 0;
                }
        }

        if (ESS_USE_AUDIO1(sc->sc_model))
                return ENXIO;

        switch (dip->index) {
        case ESS_DAC_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNdac);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_MIC_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNmicrophone);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_LINE_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNline);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_SYNTH_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNfmsynth);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_CD_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNcd);
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_AUXB_REC_VOL:
                dip->mixer_class = ESS_RECORD_CLASS;
                dip->next = dip->prev = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, "auxb");
                dip->type = AUDIO_MIXER_VALUE;
                dip->un.v.num_channels = 2;
                strcpy(dip->un.v.units.name, AudioNvolume);
                return 0;

        case ESS_MIC_PREAMP:
                dip->mixer_class = ESS_INPUT_CLASS;
                dip->prev = ESS_MIC_PLAY_VOL;
                dip->next = AUDIO_MIXER_LAST;
                strcpy(dip->label.name, AudioNpreamp);
                dip->type = AUDIO_MIXER_ENUM;
                dip->un.e.num_mem = 2;
                strcpy(dip->un.e.member[0].label.name, AudioNoff);
                dip->un.e.member[0].ord = 0;
                strcpy(dip->un.e.member[1].label.name, AudioNon);
                dip->un.e.member[1].ord = 1;
                return 0;
        }

        return ENXIO;
}

void *
ess_malloc(void *addr, int direction, size_t size)
{
        struct ess_softc *sc;
        int drq;

        sc = addr;
        if ((!ESS_USE_AUDIO1(sc->sc_model)) && direction == AUMODE_PLAY)
                drq = sc->sc_audio2.drq;
        else
                drq = sc->sc_audio1.drq;
        return (isa_malloc(sc->sc_ic, drq, size, M_DEVBUF, M_WAITOK));
}

void
ess_free(void *addr, void *ptr, size_t size)
{

        isa_free(ptr, M_DEVBUF);
}

size_t
ess_round_buffersize(void *addr, int direction, size_t size)
{
        struct ess_softc *sc;
        bus_size_t maxsize;

        sc = addr;
        if ((!ESS_USE_AUDIO1(sc->sc_model)) && direction == AUMODE_PLAY)
                maxsize = sc->sc_audio2.maxsize;
        else
                maxsize = sc->sc_audio1.maxsize;

        if (size > maxsize)
                size = maxsize;
        return size;
}

int
ess_1788_get_props(void *addr)
{

        return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE;
}

int
ess_1888_get_props(void *addr)
{

        return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE |
            AUDIO_PROP_FULLDUPLEX;
}

void
ess_get_locks(void *addr, kmutex_t **intr, kmutex_t **thread)
{
        struct ess_softc *sc;

        sc = addr;
        *intr = &sc->sc_intr_lock;
        *thread = &sc->sc_lock;
}


/* ============================================
 * Generic functions for ess, not used by audio h/w i/f
 * =============================================
 */

/*
 * Reset the chip.
 * Return non-zero if the chip isn't detected.
 */
int
ess_reset(struct ess_softc *sc)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        sc->sc_audio1.active = 0;
        sc->sc_audio2.active = 0;

        EWRITE1(iot, ioh, ESS_DSP_RESET, ESS_RESET_EXT);
        delay(10000);           /* XXX shouldn't delay so long */
        EWRITE1(iot, ioh, ESS_DSP_RESET, 0);
        if (ess_rdsp(sc) != ESS_MAGIC)
                return 1;

        /* Enable access to the ESS extension commands. */
        ess_wdsp(sc, ESS_ACMD_ENABLE_EXT);

        return 0;
}

void
ess_set_gain(struct ess_softc *sc, int port, int on)
{
        int gain, left, right;
        int mix;
        int src;
        int stereo;

        /*
         * Most gain controls are found in the mixer registers and
         * are stereo. Any that are not, must set mix and stereo as
         * required.
         */
        mix = 1;
        stereo = 1;

        if (ESS_IS_ES18X9(sc->sc_model)) {
                switch (port) {
                case ESS_SPATIALIZER:
                        src = ESS_MREG_SPATIAL_LEVEL;
                        stereo = -1;
                        goto skip;
                case ESS_SPATIALIZER_ENABLE:
                        return;
                }
        }
        switch (port) {
        case ESS_MASTER_VOL:
                src = ESS_MREG_VOLUME_MASTER;
                break;
        case ESS_DAC_PLAY_VOL:
                if (ESS_USE_AUDIO1(sc->sc_model))
                        src = ESS_MREG_VOLUME_VOICE;
                else
                        src = 0x7C;
                break;
        case ESS_MIC_PLAY_VOL:
                src = ESS_MREG_VOLUME_MIC;
                break;
        case ESS_LINE_PLAY_VOL:
                src = ESS_MREG_VOLUME_LINE;
                break;
        case ESS_SYNTH_PLAY_VOL:
                src = ESS_MREG_VOLUME_SYNTH;
                break;
        case ESS_CD_PLAY_VOL:
                src = ESS_MREG_VOLUME_CD;
                break;
        case ESS_AUXB_PLAY_VOL:
                src = ESS_MREG_VOLUME_AUXB;
                break;
        case ESS_PCSPEAKER_VOL:
                src = ESS_MREG_VOLUME_PCSPKR;
                stereo = 0;
                break;
        case ESS_DAC_REC_VOL:
                src = 0x69;
                break;
        case ESS_MIC_REC_VOL:
                src = 0x68;
                break;
        case ESS_LINE_REC_VOL:
                src = 0x6E;
                break;
        case ESS_SYNTH_REC_VOL:
                src = 0x6B;
                break;
        case ESS_CD_REC_VOL:
                src = 0x6A;
                break;
        case ESS_AUXB_REC_VOL:
                src = 0x6C;
                break;
        case ESS_RECORD_VOL:
                src = ESS_XCMD_VOLIN_CTRL;
                mix = 0;
                break;
        default:
                return;
        }
skip:

        /* 1788 doesn't have a separate recording mixer */
        if (ESS_USE_AUDIO1(sc->sc_model) && mix && src > 0x62)
                return;

        if (on) {
                left = sc->gain[port][ESS_LEFT];
                right = sc->gain[port][ESS_RIGHT];
        } else {
                left = right = 0;
        }

        if (stereo == -1)
                gain = ESS_SPATIAL_GAIN(left);
        else if (stereo)
                gain = ESS_STEREO_GAIN(left, right);
        else
                gain = ESS_MONO_GAIN(left);

        if (mix)
                ess_write_mix_reg(sc, src, gain);
        else
                ess_write_x_reg(sc, src, gain);
}

/* Set the input device on devices without an input mixer. */
int
ess_set_in_port(struct ess_softc *sc, int ord)
{
        mixer_devinfo_t di;
        int i;

        DPRINTF(("ess_set_in_port: ord=0x%x\n", ord));

        /*
         * Get the device info for the record source control,
         * including the list of available sources.
         */
        di.index = ESS_RECORD_SOURCE;
        if (ess_query_devinfo(sc, &di))
                return EINVAL;

        /* See if the given ord value was anywhere in the list. */
        for (i = 0; i < di.un.e.num_mem; i++) {
                if (ord == di.un.e.member[i].ord)
                        break;
        }
        if (i == di.un.e.num_mem)
                return EINVAL;

        ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ord);

        sc->in_port = ord;
        return 0;
}

/* Set the input device levels on input-mixer-enabled devices. */
int
ess_set_in_ports(struct ess_softc *sc, int mask)
{
        mixer_devinfo_t di;
        int i, port;

        DPRINTF(("ess_set_in_ports: mask=0x%x\n", mask));

        /*
         * Get the device info for the record source control,
         * including the list of available sources.
         */
        di.index = ESS_RECORD_SOURCE;
        if (ess_query_devinfo(sc, &di))
                return EINVAL;

        /*
         * Set or disable the record volume control for each of the
         * possible sources.
         */
        for (i = 0; i < di.un.s.num_mem; i++) {
                /*
                 * Calculate the source port number from its mask.
                 */
                port = ffs(di.un.s.member[i].mask);

                /*
                 * Set the source gain:
                 *      to the current value if source is enabled
                 *      to zero if source is disabled
                 */
                ess_set_gain(sc, port, mask & di.un.s.member[i].mask);
        }

        sc->in_mask = mask;
        return 0;
}

void
ess_speaker_on(struct ess_softc *sc)
{

        /* Unmute the DAC. */
        ess_set_gain(sc, ESS_DAC_PLAY_VOL, 1);
}

void
ess_speaker_off(struct ess_softc *sc)
{

        /* Mute the DAC. */
        ess_set_gain(sc, ESS_DAC_PLAY_VOL, 0);
}

/*
 * Calculate the time constant for the requested sampling rate.
 */
u_int
ess_srtotc(struct ess_softc *sc, u_int rate)
{
        u_int tc;

        /* The following formulae are from the ESS data sheet. */
        if (ESS_IS_ES18X9(sc->sc_model)) {
                if ((rate % 8000) != 0)
                        tc = 128 - 793800L / rate;
                else
                        tc = 256 - 768000L / rate;
        } else {
                if (rate <= 22050)
                        tc = 128 - 397700L / rate;
                else
                        tc = 256 - 795500L / rate;
        }

        return tc;
}


/*
 * Calculate the filter constant for the requested sampling rate.
 */
u_int
ess_srtofc(u_int rate)
{
        /*
         * The following formula is derived from the information in
         * the ES1887 data sheet, based on a roll-off frequency of
         * 87%.
         */
        return 256 - 200279L / rate;
}


/*
 * Return the status of the DSP.
 */
u_char
ess_get_dsp_status(struct ess_softc *sc)
{
        return EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS);
}


/*
 * Return the read status of the DSP:   1 -> DSP ready for reading
 *                                      0 -> DSP not ready for reading
 */
u_char
ess_dsp_read_ready(struct ess_softc *sc)
{

        return (ess_get_dsp_status(sc) & ESS_DSP_READ_READY) ? 1 : 0;
}


/*
 * Return the write status of the DSP:  1 -> DSP ready for writing
 *                                      0 -> DSP not ready for writing
 */
u_char
ess_dsp_write_ready(struct ess_softc *sc)
{
        return (ess_get_dsp_status(sc) & ESS_DSP_WRITE_BUSY) ? 0 : 1;
}


/*
 * Read a byte from the DSP.
 */
int
ess_rdsp(struct ess_softc *sc)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;
        int i;

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        for (i = ESS_READ_TIMEOUT; i > 0; --i) {
                if (ess_dsp_read_ready(sc)) {
                        i = EREAD1(iot, ioh, ESS_DSP_READ);
                        DPRINTFN(8,("ess_rdsp() = 0x%02x\n", i));
                        return i;
                } else
                        delay(10);
        }

        DPRINTF(("ess_rdsp: timed out\n"));
        return -1;
}

/*
 * Write a byte to the DSP.
 */
int
ess_wdsp(struct ess_softc *sc, u_char v)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;
        int i;

        DPRINTFN(8,("ess_wdsp(0x%02x)\n", v));

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        for (i = ESS_WRITE_TIMEOUT; i > 0; --i) {
                if (ess_dsp_write_ready(sc)) {
                        EWRITE1(iot, ioh, ESS_DSP_WRITE, v);
                        return 0;
                } else
                        delay(10);
        }

        DPRINTF(("ess_wdsp(0x%02x): timed out\n", v));
        return -1;
}

/*
 * Write a value to one of the ESS extended registers.
 */
int
ess_write_x_reg(struct ess_softc *sc, u_char reg, u_char val)
{
        int error;

        DPRINTFN(2,("ess_write_x_reg: %02x=%02x\n", reg, val));
        if ((error = ess_wdsp(sc, reg)) == 0)
                error = ess_wdsp(sc, val);

        return error;
}

/*
 * Read the value of one of the ESS extended registers.
 */
u_char
ess_read_x_reg(struct ess_softc *sc, u_char reg)
{
        int error;
        int val;

        if ((error = ess_wdsp(sc, 0xC0)) == 0)
                error = ess_wdsp(sc, reg);
        if (error) {
                DPRINTF(("Error reading extended register 0x%02x\n", reg));
        }
/* REVISIT: what if an error is returned above? */
        val = ess_rdsp(sc);
        DPRINTFN(2,("ess_read_x_reg: %02x=%02x\n", reg, val));
        return val;
}

void
ess_clear_xreg_bits(struct ess_softc *sc, u_char reg, u_char mask)
{
        if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) & ~mask) == -1) {
                DPRINTF(("Error clearing bits in extended register 0x%02x\n",
                         reg));
        }
}

void
ess_set_xreg_bits(struct ess_softc *sc, u_char reg, u_char mask)
{
        if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) | mask) == -1) {
                DPRINTF(("Error setting bits in extended register 0x%02x\n",
                         reg));
        }
}


/*
 * Write a value to one of the ESS mixer registers.
 */
void
ess_write_mix_reg(struct ess_softc *sc, u_char reg, u_char val)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;

        DPRINTFN(2,("ess_write_mix_reg: %x=%x\n", reg, val));

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
        EWRITE1(iot, ioh, ESS_MIX_REG_DATA, val);
}

/*
 * Read the value of one of the ESS mixer registers.
 */
u_char
ess_read_mix_reg(struct ess_softc *sc, u_char reg)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;
        u_char val;

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
        val = EREAD1(iot, ioh, ESS_MIX_REG_DATA);

        DPRINTFN(2,("ess_read_mix_reg: %x=%x\n", reg, val));
        return val;
}

void
ess_clear_mreg_bits(struct ess_softc *sc, u_char reg, u_char mask)
{

        ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) & ~mask);
}

void
ess_set_mreg_bits(struct ess_softc *sc, u_char reg, u_char mask)
{

        ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) | mask);
}

void
ess_read_multi_mix_reg(struct ess_softc *sc, u_char reg,
                       uint8_t *datap, bus_size_t count)
{
        bus_space_tag_t iot;
        bus_space_handle_t ioh;

        iot = sc->sc_iot;
        ioh = sc->sc_ioh;
        EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
        bus_space_read_multi_1(iot, ioh, ESS_MIX_REG_DATA, datap, count);
}