text: /*	$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);
  }
  