/*	$NetBSD: esl.c,v 1.9 2001/12/25 04:05:34 jmcneill Exp $	*/

/*
 * Copyright (c) 2001 Jared D. McNeill <jmcneill@invisible.yi.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Jared D. McNeill.
 * 4. Neither the name of the author nor the names of any contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: esl.c,v 1.9 2001/12/25 04:05:34 jmcneill 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/audioio.h>

#include <machine/cpu.h>
#include <machine/intr.h>
#include <machine/bus.h>
#include <machine/pio.h>

#include <dev/audio_if.h>
#include <dev/auconv.h>
#include <dev/mulaw.h>

#include <dev/pcmcia/pcmciavar.h>

#include <dev/isa/essreg.h>
#include <dev/pcmcia/eslvar.h>

int	esl_open(void *, int);
void	esl_close(void *);
int	esl_query_encoding(void *, struct audio_encoding *);
int	esl_set_params(void *, int, int, struct audio_params *,
					struct audio_params *);
int	esl_round_blocksize(void *, int);
int	esl_halt_output(void *);
int	esl_halt_input(void *);
int	esl_speaker_ctl(void *, int);
int	esl_getdev(void *, struct audio_device *);
int	esl_set_port(void *, mixer_ctrl_t *);
int	esl_get_port(void *, mixer_ctrl_t *);
int	esl_query_devinfo(void *, mixer_devinfo_t *);
int	esl_get_props(void *);
int	esl_trigger_output(void *, void *, void *, int, void (*)(void *),
				void *, struct audio_params *);

/* Supporting subroutines */
int	esl_reset(struct esl_pcmcia_softc *);
void	esl_setup(struct esl_pcmcia_softc *);
void	esl_set_gain(struct esl_pcmcia_softc *, int, int);
void	esl_speaker_on(struct esl_pcmcia_softc *);
void	esl_speaker_off(struct esl_pcmcia_softc *);
int	esl_identify(struct esl_pcmcia_softc *);
int	esl_rdsp(struct esl_pcmcia_softc *);
int	esl_wdsp(struct esl_pcmcia_softc *, u_char);
u_char	esl_dsp_read_ready(struct esl_pcmcia_softc *);
u_char	esl_dsp_write_ready(struct esl_pcmcia_softc *);
u_char	esl_get_dsp_status(struct esl_pcmcia_softc *);
u_char	esl_read_x_reg(struct esl_pcmcia_softc *, u_char);
int	esl_write_x_reg(struct esl_pcmcia_softc *, u_char, u_char);
void	esl_clear_xreg_bits(struct esl_pcmcia_softc *, u_char, u_char);
void	esl_set_xreg_bits(struct esl_pcmcia_softc *, u_char, u_char);
u_char	esl_read_mix_reg(struct esl_pcmcia_softc *, u_char);
void	esl_write_mix_reg(struct esl_pcmcia_softc *, u_char, u_char);
void	esl_clear_mreg_bits(struct esl_pcmcia_softc *, u_char, u_char);
void	esl_set_mreg_bits(struct esl_pcmcia_softc *, u_char, u_char);
void	esl_read_multi_mix_reg(struct esl_pcmcia_softc *, u_char,
				    u_int8_t *, bus_size_t);
u_int	esl_srtotc(u_int);
u_int	esl_srtofc(u_int);

struct audio_device esl_device = {
	"AudioDrive",
	"",
	"esl"
};

struct audio_hw_if esl_hw_if = {
	esl_open,
	esl_close,
	NULL,
	esl_query_encoding,
	esl_set_params,
	esl_round_blocksize,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	esl_halt_output,
	esl_halt_input,
	esl_speaker_ctl,
	esl_getdev,
	NULL,
	esl_set_port,
	esl_get_port,
	esl_query_devinfo,
	NULL,
	NULL,
	NULL,
	NULL,
	esl_get_props,
	esl_trigger_output,
	NULL,
	NULL,
};

static char *eslmodel[] = {
	"1688",
	"688",
};

int
esl_open(void *hdl, int flags)
{

	struct esl_pcmcia_softc *sc = hdl;
	int i;

	if (sc->sc_esl.sc_open != 0)
		return (EBUSY);

	if ((*sc->sc_enable)(sc))
		return (ENXIO);

	if (esl_reset(sc) != 0) {
		printf("%s: esl_open: esl_reset failed\n",
		    sc->sc_esl.sc_dev.dv_xname);
		return (ENXIO);
	}

	/* because we did a reset */
	esl_setup(sc);

	/* Set all mixer controls to sane values (since we just did a reset) */
	for (i = 0; i < ESS_MAX_NDEVS; i++)
		esl_set_gain(sc, i, 1);

	sc->sc_esl.sc_open = 1;

	/* XXX: Delay a bit */
	delay(10000);

	return (0);
}


void
esl_close(void *hdl)
{
	struct esl_pcmcia_softc *sc = hdl;

	esl_speaker_off(sc);

	(*sc->sc_disable)(sc);

	sc->sc_esl.sc_open = 0;

	return;
}

int
esl_query_encoding(void *hdl, struct audio_encoding *ae)
{

	switch (ae->index) {
	case 0:
		strcpy(ae->name, AudioEulinear);
		ae->encoding = AUDIO_ENCODING_ULINEAR;
		ae->precision = 8;
		ae->flags = 0;
		return (0);
	case 1:
		strcpy(ae->name, AudioEmulaw);
		ae->encoding = AUDIO_ENCODING_ULAW;
		ae->precision = 8;
		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
		return (0);
	case 2:
		strcpy(ae->name, AudioEalaw);
		ae->encoding = AUDIO_ENCODING_ALAW;
		ae->precision = 8;
		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
		return (0);
	case 3:
		strcpy(ae->name, AudioEslinear);
		ae->encoding = AUDIO_ENCODING_SLINEAR;
		ae->precision = 8;
		ae->flags = 0;
		return (0);
	case 4:
		strcpy(ae->name, AudioEslinear_le);
		ae->encoding = AUDIO_ENCODING_SLINEAR_LE;
		ae->precision = 16;
		ae->flags = 0;
		return (0);
	case 5:
		strcpy(ae->name, AudioEulinear_le);
		ae->encoding = AUDIO_ENCODING_ULINEAR_LE;
		ae->precision = 16;
		ae->flags = 0;
		return (0);
	case 6:
		strcpy(ae->name, AudioEslinear_be);
		ae->encoding = AUDIO_ENCODING_SLINEAR_BE;
		ae->precision = 16;
		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
		return (0);
	case 7:
		strcpy(ae->name, AudioEulinear_be);
		ae->encoding = AUDIO_ENCODING_ULINEAR_BE;
		ae->precision = 16;
		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
		return (0);
	default:
		return EINVAL;
	}
	return (0);
}

int
esl_set_params(void *hdl, int setmode, int usemode,
		struct audio_params *play, struct audio_params *rec)
{
	struct esl_pcmcia_softc *sc = hdl;
	int rate;

	if (play->sample_rate < ESS_MINRATE ||
	    play->sample_rate > ESS_MAXRATE ||
	    (play->precision != 8 && play->precision != 16) ||
	    (play->channels != 1 && play->channels != 2))
		return (EINVAL);

	play->factor = 1;
	play->sw_code = NULL;
	switch (play->encoding) {
	case AUDIO_ENCODING_SLINEAR_BE:
	case AUDIO_ENCODING_ULINEAR_BE:
		if (play->precision == 16)
			play->sw_code = swap_bytes;
		break;
	case AUDIO_ENCODING_SLINEAR_LE:
	case AUDIO_ENCODING_ULINEAR_LE:
		break;
	case AUDIO_ENCODING_ULAW:
		play->factor = 2;
		play->sw_code = mulaw_to_ulinear16_le;
		break;
	case AUDIO_ENCODING_ALAW:
		play->factor = 2;
		play->sw_code = alaw_to_ulinear16_le;
		break;
	default:
		return (EINVAL);
	}

	rate = play->sample_rate;

	esl_write_x_reg(sc, ESS_XCMD_SAMPLE_RATE, esl_srtotc(rate));
	esl_write_x_reg(sc, ESS_XCMD_FILTER_CLOCK, esl_srtofc(rate));

	return (0);
}

int
esl_round_blocksize(void *hdl, int bs)
{

	return ((bs / 128) * 128);
}


int
esl_halt_output(void *hdl)
{
	struct esl_pcmcia_softc *sc = hdl;

	if (sc->sc_esl.active) {
		esl_clear_xreg_bits(sc, ESS_XCMD_AUDIO1_CTRL2,
		    ESS_AUDIO1_CTRL2_FIFO_ENABLE);
		sc->sc_esl.active = 0;
	}

	return (0);
}

int
esl_halt_input(void *hdl)
{

	return (0);
}

int
esl_speaker_ctl(void *hdl, int on)
{

	return (0);
}

int
esl_getdev(void *hdl, struct audio_device *ret)
{

	*ret = esl_device;
	return (0);
}

int
esl_set_port(void *hdl, mixer_ctrl_t *mc)
{
	struct esl_pcmcia_softc *sc = hdl;
	int lgain, rgain;

	switch(mc->dev) {
	case ESS_MASTER_VOL:
	case ESS_DAC_PLAY_VOL:
	case ESS_SYNTH_PLAY_VOL:
		if (mc->type != AUDIO_MIXER_VALUE)
			return (EINVAL);

		switch(mc->un.value.num_channels) {
		case 1:
			lgain = rgain = ESS_4BIT_GAIN(
			    mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
			break;
		case 2:
			lgain = ESS_4BIT_GAIN(
			    mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
			rgain = ESS_4BIT_GAIN(
			    mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
			break;
		default:
			return (EINVAL);
		}
		sc->sc_esl.gain[mc->dev][ESS_LEFT] = lgain;
		sc->sc_esl.gain[mc->dev][ESS_RIGHT] = rgain;
		esl_set_gain(sc, mc->dev, 1);
		return (0);
		break;
	default:
		/* FALLTHROUGH */
	}

	return (EINVAL);
}

int
esl_get_port(void *hdl, mixer_ctrl_t *mc)
{
	struct esl_pcmcia_softc *sc = hdl;

	switch(mc->dev) {
	case ESS_MASTER_VOL:
	case ESS_DAC_PLAY_VOL:
	case ESS_SYNTH_PLAY_VOL:
		switch(mc->un.value.num_channels) {
		case 1:
			mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
			    sc->sc_esl.gain[mc->dev][ESS_LEFT];
			break;
		case 2:
			mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
			    sc->sc_esl.gain[mc->dev][ESS_LEFT];
			mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
			    sc->sc_esl.gain[mc->dev][ESS_RIGHT];
			break;
		default:
			return (EINVAL);
		}
		return (0);
	default:
		/* FALLTHROUGH */
	}

	return (EINVAL);
}

int
esl_query_devinfo(void *hdl, mixer_devinfo_t *di)
{

	switch(di->index) {
	case ESS_DAC_PLAY_VOL:
		di->mixer_class = ESS_INPUT_CLASS;
		di->next = di->prev = AUDIO_MIXER_LAST;
		strcpy(di->label.name, AudioNdac);
		di->type = AUDIO_MIXER_VALUE;
		di->un.v.num_channels = 2;
		strcpy(di->un.v.units.name, AudioNvolume);
		return (0);
	case ESS_SYNTH_PLAY_VOL:
		di->mixer_class = ESS_INPUT_CLASS;
		di->next = di->prev = AUDIO_MIXER_LAST;
		strcpy(di->label.name, AudioNfmsynth);
		di->type = AUDIO_MIXER_VALUE;
		di->un.v.num_channels = 2;
		strcpy(di->un.v.units.name, AudioNvolume);
		return (0);
	case ESS_INPUT_CLASS:
		di->mixer_class = ESS_INPUT_CLASS;
		di->next = di->prev = AUDIO_MIXER_LAST;
		strcpy(di->label.name, AudioCinputs);
		di->type = AUDIO_MIXER_CLASS;
		return (0);
	case ESS_MASTER_VOL:
		di->mixer_class = ESS_OUTPUT_CLASS;
		di->next = di->prev = AUDIO_MIXER_LAST;
		strcpy(di->label.name, AudioNmaster);
		di->type = AUDIO_MIXER_VALUE;
		di->un.v.num_channels = 2;
		strcpy(di->un.v.units.name, AudioNvolume);
		return (0);
	case ESS_OUTPUT_CLASS:
		di->mixer_class = ESS_OUTPUT_CLASS;
		di->next = di->prev = AUDIO_MIXER_LAST;
		strcpy(di->label.name, AudioCoutputs);
		di->type = AUDIO_MIXER_CLASS;
		return (0);
	default:
		/* FALLTHROUGH */
	}

	return (ENXIO);
}

int
esl_get_props(void *hdl)
{

	return (AUDIO_PROP_MMAP);
}

int
esl_trigger_output(void *hdl, void *start, void *end, int blksize,
		   void (*intr)(void *), void *intrarg,
		   struct audio_params *param)
{
	struct esl_pcmcia_softc *sc = hdl;
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
	int bs;
	int cnt;
	u_int8_t reg;

	if (sc->sc_esl.active) {
		printf("%s: esl_trigger_output: already running\n",
		    sc->sc_esl.sc_dev.dv_xname);
		return (1);
	}

	sc->sc_esl.active = 1;
	sc->sc_esl.intr = intr;
	sc->sc_esl.arg = intrarg;

	/* Stereo or Mono selection */
	reg = esl_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;
	}
	esl_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);

	/* Program the FIFO (16-bit/8-bit, signed/unsigned, stereo/mono) */
	reg = esl_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
	if (param->precision * param->factor == 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;
	esl_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);

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

	esl_wdsp(sc, ESS_ACMD_ENABLE_SPKR);
	reg = esl_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;
	esl_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);
	cnt = (char *)end - (char *)start;
	if (cnt == 0)
		printf("%s: no count left\n", sc->sc_esl.sc_dev.dv_xname);

	sc->sc_esl.sc_dmaaddr = sc->sc_esl.sc_dmastart = start;
	sc->sc_esl.sc_dmaend = end;
	sc->sc_esl.sc_blksize = blksize;
	sc->sc_esl.sc_blkpos = 0;

	/* XXX: Delay a bit */
	delay(10000);

	/* Prime the FIFO */
	bus_space_write_multi_1(iot, ioh, ESS_FIFO_WRITE, start, ESS_FIFO_SIZE);
	sc->sc_esl.sc_dmaaddr += ESS_FIFO_SIZE;
	sc->sc_esl.sc_blkpos += ESS_FIFO_SIZE;

	return (0);
}

/* Additional subroutines used by the above (NOT required by audio(9)) */

int
esl_init(struct esl_pcmcia_softc *sc)
{
	const int ENABLE[] = { 0x0, 0x9, 0xb };
	const int ENABLE_ORDER[] = { 1, 1, 1, 2, 1, 2, 1, 1, 2, 1, 0, -1 };
	struct audio_attach_args aa;
	int i;
	int model;
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
	
	sc->sc_esl.sc_open = 0;

	/* Initialization sequence */
	for (i = 0; ENABLE_ORDER[i] != -1; i++)
		bus_space_read_1(iot, ioh, ENABLE[i]);
	if (esl_reset(sc)) {
		printf("%s: esl_init: esl_reset failed\n",
		    sc->sc_esl.sc_dev.dv_xname);
		return (1);
	}

	if (esl_identify(sc)) {
		printf("%s: esl_init: esl_identify failed\n",
		    sc->sc_esl.sc_dev.dv_xname);
		return (1);
	}

	if (!sc->sc_esl.sc_version)
		return (1);	/* Probably a Sound Blaster */

	model = ESS_UNSUPPORTED;

	switch (sc->sc_esl.sc_version & 0xfff0) {
	case 0x6880:
		if ((sc->sc_esl.sc_version & 0x0f) >= 8) {
			model = ESS_1688;
		} else {
			model = ESS_688;
		}
		break;
	}

	if (model == ESS_UNSUPPORTED) {
		printf("%s: unknown model 0x%04x\n",
		    sc->sc_esl.sc_dev.dv_xname, sc->sc_esl.sc_version);
		return (1);
	}

	printf("%s: ESS AudioDrive %s [version 0x%04x]\n",
	    sc->sc_esl.sc_dev.dv_xname, eslmodel[model],
	    sc->sc_esl.sc_version);

	/* Set volumes to 50% */
	for (i = 0; i < ESS_MAX_NDEVS; i++) {
		sc->sc_esl.gain[i][ESS_LEFT] =
		    sc->sc_esl.gain[i][ESS_RIGHT] =
		    ESS_4BIT_GAIN(AUDIO_MAX_GAIN / 2);
		esl_set_gain(sc, i, 1);
	}

	sc->sc_audiodev = audio_attach_mi(&esl_hw_if, sc, &sc->sc_esl.sc_dev);

	/* Attach the OPL device */
	aa.type = AUDIODEV_TYPE_OPL;
	aa.hwif = 0;
	aa.hdl = 0;

	sc->sc_opldev = config_found(&sc->sc_esl.sc_dev, &aa, audioprint);

	/* Disable speaker until device is opened */
	esl_speaker_off(sc);

	sc->sc_esl.sc_open = 0;

	return (0);
}

int
esl_intr(void *hdl)
{
	struct esl_pcmcia_softc *sc = hdl;
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
	u_int8_t reg;
	u_char *pos;

	/* Clear interrupt */
	reg = bus_space_read_1(iot, ioh, ESS_CLEAR_INTR);

	if (sc->sc_esl.active) {
		reg = bus_space_read_1(iot, ioh, ESS_DSP_RW_STATUS);
		while (reg & ESS_DSP_READ_HALF) {
			pos = sc->sc_esl.sc_dmaaddr;
			bus_space_write_multi_1(iot, ioh, ESS_FIFO_WRITE, pos,
			    ESS_FIFO_SIZE / 2);

			sc->sc_esl.sc_blkpos += (ESS_FIFO_SIZE / 2);
			if (sc->sc_esl.sc_blkpos >= sc->sc_esl.sc_blksize) {
				(*sc->sc_esl.intr)(sc->sc_esl.arg);
				sc->sc_esl.sc_blkpos -= sc->sc_esl.sc_blksize;
			}
			pos += (ESS_FIFO_SIZE / 2);
			if (pos >= sc->sc_esl.sc_dmaend)
				pos = sc->sc_esl.sc_dmastart;

			sc->sc_esl.sc_dmaaddr = pos;
			reg = bus_space_read_1(iot, ioh, ESS_DSP_RW_STATUS);
		}
	}

	return (1);
}

int
esl_reset(struct esl_pcmcia_softc *sc)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;

	bus_space_write_1(iot, ioh, ESS_DSP_RESET, ESS_RESET_EXT);
	delay(10000);	/* XXX: Ugly, but ess.c does this too */
	bus_space_write_1(iot, ioh, ESS_DSP_RESET, 0);
	if (esl_rdsp(sc) != ESS_MAGIC)
		return (1);

	/* Enable access to the extended command set */
	esl_wdsp(sc, ESS_ACMD_ENABLE_EXT);

	return (0);
}

void
esl_setup(struct esl_pcmcia_softc *sc)
{
	u_char reg;

	/*
	 * Configure IRQ. Set bit 5 of B1h high to enable interrupt on
	 * FIFOHE, and keep bit 6 low.
	 */
	reg = ESS_IRQ_CTRL_MASK | 0x20 | ESS_IRQ_CTRL_INTRA;
	esl_write_x_reg(sc, ESS_XCMD_IRQ_CTRL, reg);

	/*
	 * "Config DRQ", well not really. Instead of configuring a DRQ,
	 * we leave bits 7 and 5 of B2h low.
	 */
	reg = 0x10 | 0x40;
	esl_write_x_reg(sc, ESS_XCMD_DRQ_CTRL, reg);

	return;
}

void
esl_set_gain(struct esl_pcmcia_softc *sc, int port, int on)
{
	int gain, left, right;
	int src;

	switch(port) {
	case ESS_MASTER_VOL:
		src = ESS_MREG_VOLUME_MASTER;
		break;
	case ESS_DAC_PLAY_VOL:
		src = ESS_MREG_VOLUME_VOICE;
		break;
	case ESS_SYNTH_PLAY_VOL:
		src = ESS_MREG_VOLUME_SYNTH;
		break;
	default:
		return;
	}

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

	gain = ESS_STEREO_GAIN(left, right);

	esl_write_mix_reg(sc, src, gain);

	return;
}

void
esl_speaker_on(struct esl_pcmcia_softc *sc)
{

	/* Unmute the DAC */
	esl_set_gain(sc, ESS_DAC_PLAY_VOL, 1);

	return;
}

void
esl_speaker_off(struct esl_pcmcia_softc *sc)
{

	/* Mute the DAC */
	esl_set_gain(sc, ESS_DAC_PLAY_VOL, 0);

	return;
}

int
esl_identify(struct esl_pcmcia_softc *sc)
{
	u_char reg1, reg2;
	int i;

	esl_wdsp(sc, ESS_ACMD_LEGACY_ID);
	for (i = 1000, reg1 = reg2 = 0; i; i--)
		if (esl_dsp_read_ready(sc)) {
			if (reg1 == 0)
				reg1 = esl_rdsp(sc);
			else
				reg2 = esl_rdsp(sc);
		}	

	sc->sc_esl.sc_version = (reg1 << 8) + reg2;

	return (0);
}

/* Read a byte from the DSP */
int
esl_rdsp(struct esl_pcmcia_softc *sc)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
	int i;

	for (i = ESS_READ_TIMEOUT; i > 0; --i) {
		if (esl_dsp_read_ready(sc)) {
			i = bus_space_read_1(iot, ioh, ESS_DSP_READ);
			return (i);
		} else
			delay(10);
	}

	printf("esl_rdsp: timed out\n");
	return (-1);
}

/* Write a byte to the DSP */
int
esl_wdsp(struct esl_pcmcia_softc *sc, u_char v)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
	int i;

	for (i = ESS_WRITE_TIMEOUT; i > 0; --i) {
		if (esl_dsp_write_ready(sc)) {
			bus_space_write_1(iot, ioh, ESS_DSP_WRITE, v);
			return (0);
		} else
			delay(10);
	}

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

/* Get the read status of the DSP: 1 == Ready, 0 == Not Ready */
u_char
esl_dsp_read_ready(struct esl_pcmcia_softc *sc)
{

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

/* Get the write status of the DSP: 1 == Ready, 0 == Not Ready */
u_char
esl_dsp_write_ready(struct esl_pcmcia_softc *sc)
{

	return ((esl_get_dsp_status(sc) & ESS_DSP_WRITE_BUSY) ? 0 : 1);
}

/* Return the status of the DSP */
u_char
esl_get_dsp_status(struct esl_pcmcia_softc *sc)
{

	return (bus_space_read_1(sc->sc_pcioh.iot, sc->sc_pcioh.ioh,
	    ESS_DSP_RW_STATUS));
}

/* Read a value from one of the extended registers */
u_char
esl_read_x_reg(struct esl_pcmcia_softc *sc, u_char reg)
{
	int error;

	if ((error = esl_wdsp(sc, 0xC0)) == 0)
		error = esl_wdsp(sc, reg);
	if (error)
		printf("esl_read_x_reg: error reading 0x%02x\n", reg);
	return (esl_rdsp(sc));
}

/* Write a value to one of the extended registers */
int
esl_write_x_reg(struct esl_pcmcia_softc *sc, u_char reg, u_char val)
{
	int error;

	if ((error = esl_wdsp(sc, reg)) == 0)
		error = esl_wdsp(sc, val);

	return (error);
}

void
esl_clear_xreg_bits(struct esl_pcmcia_softc *sc, u_char reg, u_char mask)
{

	esl_write_x_reg(sc, reg, esl_read_x_reg(sc, reg) & ~mask);

	return;
}

void
esl_set_xreg_bits(struct esl_pcmcia_softc *sc, u_char reg, u_char mask)
{

	esl_write_x_reg(sc, reg, esl_read_x_reg(sc, reg) | mask);
}

u_char
esl_read_mix_reg(struct esl_pcmcia_softc *sc, u_char reg)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
#if 0
	int s;
#endif
	u_char val;

#if 0
	s = splaudio();
#endif
	bus_space_write_1(iot, ioh, ESS_MIX_REG_SELECT, reg);
	val = bus_space_read_1(iot, ioh, ESS_MIX_REG_DATA);
#if 0
	splx(s);
#endif

	return (val);
}

void
esl_write_mix_reg(struct esl_pcmcia_softc *sc, u_char reg, u_char val)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
#if 0
	int s;
#endif

#if 0
	s = splaudio();
#endif
	bus_space_write_1(iot, ioh, ESS_MIX_REG_SELECT, reg);
	bus_space_write_1(iot, ioh, ESS_MIX_REG_DATA, val);
#if 0
	splx(s);
#endif

	return;
}

void
esl_clear_mreg_bits(struct esl_pcmcia_softc *sc, u_char reg, u_char mask)
{

	esl_write_mix_reg(sc, reg, esl_read_mix_reg(sc, reg) & ~mask);

	return;
}

void
esl_set_mreg_bits(struct esl_pcmcia_softc *sc, u_char reg, u_char mask)
{

	esl_write_mix_reg(sc, reg, esl_read_mix_reg(sc, reg) | mask);

	return;
}

void
esl_read_multi_mix_reg(struct esl_pcmcia_softc *sc, u_char reg,
		u_int8_t *datap, bus_size_t count)
{
	bus_space_tag_t iot = sc->sc_pcioh.iot;
	bus_space_handle_t ioh = sc->sc_pcioh.ioh;
#if 0
	int s;
#endif

#if 0
	s = splaudio();
#endif
	bus_space_write_1(iot, ioh, ESS_MIX_REG_SELECT, reg);
	bus_space_read_multi_1(iot, ioh, ESS_MIX_REG_DATA, datap, count);
#if 0
	splx(s);
#endif

	return;
}

/* Calculate the time constant for the requested sampling rate */
u_int
esl_srtotc(u_int rate)
{
	u_int tc;

	/* The following formulas are from the ESS data sheet. */
	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
esl_srtofc(u_int rate)
{

	/* From dev/isa/ess.c:ess_srtofc() rev 1.53 */
	return (256 - 200279L / rate);
}