summaryrefslogtreecommitdiff
path: root/sys/dev/isa
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/isa')
-rw-r--r--sys/dev/isa/ess.c2642
-rw-r--r--sys/dev/isa/ess_isapnp.c105
-rw-r--r--sys/dev/isa/essreg.h306
-rw-r--r--sys/dev/isa/essvar.h159
-rw-r--r--sys/dev/isa/files.isa9
-rw-r--r--sys/dev/isa/files.isapnp5
-rw-r--r--sys/dev/isa/opl_ess.c105
-rw-r--r--sys/dev/isa/pnpdevs8
8 files changed, 3333 insertions, 6 deletions
diff --git a/sys/dev/isa/ess.c b/sys/dev/isa/ess.c
new file mode 100644
index 00000000000..f623751350d
--- /dev/null
+++ b/sys/dev/isa/ess.c
@@ -0,0 +1,2642 @@
+/* $OpenBSD: ess.c,v 1.1 1999/06/22 16:20:03 niklas Exp $ */
+/* $NetBSD: ess.c,v 1.44 1999/03/19 12:40:21 mycroft 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/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 <machine/cpu.h>
+#include <machine/intr.h>
+#include <machine/bus.h>
+
+#include <sys/audioio.h>
+#include <dev/audio_if.h>
+#include <dev/auconv.h>
+#include <dev/mulaw.h>
+
+#include <dev/isa/isavar.h>
+#include <dev/isa/isadmavar.h>
+
+#include <dev/isa/essvar.h>
+#include <dev/isa/essreg.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
+
+struct cfdriver ess_cd = {
+ NULL, "ess", DV_DULL
+};
+
+int ess_setup_sc __P((struct ess_softc *, int));
+
+int ess_open __P((void *, int));
+void ess_1788_close __P((void *));
+void ess_1888_close __P((void *));
+int ess_getdev __P((void *, struct audio_device *));
+int ess_drain __P((void *));
+
+int ess_query_encoding __P((void *, struct audio_encoding *));
+
+int ess_set_params __P((void *, int, int, struct audio_params *,
+ struct audio_params *));
+
+int ess_round_blocksize __P((void *, int));
+
+int ess_audio1_trigger_output __P((void *, void *, void *, int,
+ void (*)(void *), void *, struct audio_params *));
+int ess_audio2_trigger_output __P((void *, void *, void *, int,
+ void (*)(void *), void *, struct audio_params *));
+int ess_audio1_trigger_input __P((void *, void *, void *, int,
+ void (*)(void *), void *, struct audio_params *));
+int ess_audio1_halt __P((void *));
+int ess_audio2_halt __P((void *));
+int ess_audio1_intr __P((void *));
+int ess_audio2_intr __P((void *));
+void ess_audio1_poll __P((void *));
+void ess_audio2_poll __P((void *));
+
+int ess_speaker_ctl __P((void *, int));
+
+int ess_getdev __P((void *, struct audio_device *));
+
+int ess_set_port __P((void *, mixer_ctrl_t *));
+int ess_get_port __P((void *, mixer_ctrl_t *));
+
+void *ess_malloc __P((void *, unsigned long, int, int));
+void ess_free __P((void *, void *, int));
+unsigned long ess_round_buffersize __P((void *, unsigned long));
+int ess_mappage __P((void *, void *, int, int));
+
+
+int ess_query_devinfo __P((void *, mixer_devinfo_t *));
+int ess_1788_get_props __P((void *));
+int ess_1888_get_props __P((void *));
+
+void ess_speaker_on __P((struct ess_softc *));
+void ess_speaker_off __P((struct ess_softc *));
+
+int ess_config_addr __P((struct ess_softc *));
+void ess_config_irq __P((struct ess_softc *));
+void ess_config_drq __P((struct ess_softc *));
+void ess_setup __P((struct ess_softc *));
+int ess_identify __P((struct ess_softc *));
+
+int ess_reset __P((struct ess_softc *));
+void ess_set_gain __P((struct ess_softc *, int, int));
+int ess_set_in_port __P((struct ess_softc *, int));
+int ess_set_in_ports __P((struct ess_softc *, int));
+u_int ess_srtotc __P((u_int));
+u_int ess_srtofc __P((u_int));
+u_char ess_get_dsp_status __P((struct ess_softc *));
+u_char ess_dsp_read_ready __P((struct ess_softc *));
+u_char ess_dsp_write_ready __P((struct ess_softc *sc));
+int ess_rdsp __P((struct ess_softc *));
+int ess_wdsp __P((struct ess_softc *, u_char));
+u_char ess_read_x_reg __P((struct ess_softc *, u_char));
+int ess_write_x_reg __P((struct ess_softc *, u_char, u_char));
+void ess_clear_xreg_bits __P((struct ess_softc *, u_char, u_char));
+void ess_set_xreg_bits __P((struct ess_softc *, u_char, u_char));
+u_char ess_read_mix_reg __P((struct ess_softc *, u_char));
+void ess_write_mix_reg __P((struct ess_softc *, u_char, u_char));
+void ess_clear_mreg_bits __P((struct ess_softc *, u_char, u_char));
+void ess_set_mreg_bits __P((struct ess_softc *, u_char, u_char));
+
+static char *essmodel[] = {
+ "unsupported",
+ "1888",
+ "1887",
+ "888",
+ "1788"
+};
+
+struct audio_device ess_device = {
+ "ESS Technology",
+ "x",
+ "ess"
+};
+
+/*
+ * Define our interface to the higher level audio driver.
+ */
+
+struct audio_hw_if ess_1788_hw_if = {
+ ess_open,
+ ess_1788_close,
+ ess_drain,
+ ess_query_encoding,
+ ess_set_params,
+ ess_round_blocksize,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ ess_audio1_halt,
+ ess_audio1_halt,
+ ess_speaker_ctl,
+ ess_getdev,
+ NULL,
+ ess_set_port,
+ ess_get_port,
+ ess_query_devinfo,
+ ess_malloc,
+ ess_free,
+ ess_round_buffersize,
+ ess_mappage,
+ ess_1788_get_props,
+ ess_audio1_trigger_output,
+ ess_audio1_trigger_input,
+};
+
+struct audio_hw_if ess_1888_hw_if = {
+ ess_open,
+ ess_1888_close,
+ ess_drain,
+ ess_query_encoding,
+ ess_set_params,
+ ess_round_blocksize,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ ess_audio2_halt,
+ ess_audio1_halt,
+ ess_speaker_ctl,
+ ess_getdev,
+ NULL,
+ ess_set_port,
+ ess_get_port,
+ ess_query_devinfo,
+ ess_malloc,
+ ess_free,
+ ess_round_buffersize,
+ ess_mappage,
+ ess_1888_get_props,
+ ess_audio2_trigger_output,
+ ess_audio1_trigger_input,
+};
+
+#ifdef AUDIO_DEBUG
+void ess_printsc __P((struct ess_softc *));
+void ess_dump_mixer __P((struct ess_softc *));
+
+void
+ess_printsc(sc)
+ struct ess_softc *sc;
+{
+ int i;
+
+ printf("open %d iobase 0x%x outport %u inport %u speaker %s\n",
+ (int)sc->sc_open, sc->sc_iobase, sc->out_port,
+ sc->in_port, sc->spkr_state ? "on" : "off");
+
+ printf("audio1: dmachan %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 (sc->sc_model != ESS_1788) {
+ printf("audio2: dmachan %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(sc)
+ 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(sc)
+ struct ess_softc *sc;
+{
+ int iobase = sc->sc_iobase;
+ bus_space_tag_t iot = sc->sc_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;
+
+ /*
+ * 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(sc)
+ 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 (sc->sc_model == ESS_1788)
+ 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(sc)
+ 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 (sc->sc_model == ESS_1788)
+ 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(sc)
+ 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(sc)
+ struct ess_softc *sc;
+{
+ u_char reg1;
+ u_char reg2;
+ u_char reg3;
+
+ sc->sc_model = ESS_UNSUPPORTED;
+ sc->sc_version = 0;
+
+
+ /*
+ * 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)) {
+ printf("ess: Second ID byte wrong (0x%02x)\n", reg2);
+ return 1;
+ }
+
+ /*
+ * 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) {
+ printf("ess: Hardware error (unable to toggle bit 2 of mixer register 0x64)\n");
+ return 1;
+ }
+
+ /*
+ * 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;
+ } else {
+ /*
+ * 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);
+ } else {
+ /*
+ * 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 idependently 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(sc, doinit)
+ 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(sc)
+ struct ess_softc *sc;
+{
+ if (!ESS_BASE_VALID(sc->sc_iobase)) {
+ printf("ess: configured iobase 0x%x invalid\n", sc->sc_iobase);
+ return (0);
+ }
+
+ /* Configure the ESS chip for the desired audio base address. */
+ if (ess_config_addr(sc))
+ 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_isa, sc->sc_audio1.drq))
+ return (0);
+ if (sc->sc_model != ESS_1788) {
+ 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_isa, 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 (sc->sc_model != ESS_1788) {
+ 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 (1);
+}
+
+
+/*
+ * Attach hardware to driver, attach hardware driver to audio
+ * pseudo-device driver.
+ */
+void
+essattach(sc)
+ struct ess_softc *sc;
+{
+ struct audio_attach_args arg;
+ struct audio_params pparams, rparams;
+ int i;
+ u_int v;
+
+ if (ess_setup_sc(sc, 0)) {
+ printf(": setup failed\n");
+ return;
+ }
+
+ printf(": ESS Technology ES%s [version 0x%04x]\n",
+ essmodel[sc->sc_model], sc->sc_version);
+
+ sc->sc_audio1.irq = -1;
+ sc->sc_audio2.irq = -1;
+
+ 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, sc->sc_dev.dv_xname);
+ printf("%s: audio1 interrupting at irq %d\n",
+ sc->sc_dev.dv_xname, sc->sc_audio1.irq);
+ } else
+ printf("%s: audio1 polled\n", sc->sc_dev.dv_xname);
+ if (isa_dmamap_create(sc->sc_isa, sc->sc_audio1.drq,
+ MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
+ printf("%s: can't create map for drq %d\n",
+ sc->sc_dev.dv_xname, sc->sc_audio1.drq);
+ return;
+ }
+
+ if (sc->sc_model != ESS_1788) {
+ 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, sc->sc_dev.dv_xname);
+ printf("%s: audio2 interrupting at irq %d\n",
+ sc->sc_dev.dv_xname, sc->sc_audio2.irq);
+ } else
+ printf("%s: audio2 polled\n", sc->sc_dev.dv_xname);
+ if (isa_dmamap_create(sc->sc_isa, sc->sc_audio2.drq,
+ MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
+ printf("%s: can't create map for drq %d\n",
+ sc->sc_dev.dv_xname, sc->sc_audio2.drq);
+ return;
+ }
+ }
+
+ /*
+ * Set record and play parameters to default values defined in
+ * generic audio driver.
+ */
+ pparams = audio_default;
+ rparams = audio_default;
+ ess_set_params(sc, AUMODE_RECORD|AUMODE_PLAY, 0, &pparams, &rparams);
+
+ /* 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 (sc->sc_model != ESS_1788)
+ ess_write_mix_reg(sc, ESS_MREG_VOLUME_VOICE, 0);
+ ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
+
+ if (sc->sc_model == ESS_1788) {
+ ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIC);
+ sc->in_port = ESS_SOURCE_MIC;
+ 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++) {
+ 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;
+ }
+ 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;
+
+ sprintf(ess_device.name, "ES%s", essmodel[sc->sc_model]);
+ sprintf(ess_device.version, "0x%04x", sc->sc_version);
+
+ if (sc->sc_model == ESS_1788)
+ 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);
+
+#ifdef AUDIO_DEBUG
+ if (essdebug > 0)
+ ess_printsc(sc);
+#endif
+}
+
+/*
+ * Various routines to interface to higher level audio driver
+ */
+
+int
+ess_open(addr, flags)
+ void *addr;
+ int flags;
+{
+ struct ess_softc *sc = addr;
+
+ DPRINTF(("ess_open: sc=%p\n", sc));
+
+ if (sc->sc_open != 0 || ess_reset(sc) != 0)
+ return ENXIO;
+
+ ess_setup(sc); /* because we did a reset */
+
+ sc->sc_open = 1;
+
+ DPRINTF(("ess_open: opened\n"));
+
+ return (0);
+}
+
+void
+ess_1788_close(addr)
+ void *addr;
+{
+ struct ess_softc *sc = addr;
+
+ DPRINTF(("ess_1788_close: sc=%p\n", sc));
+
+ ess_speaker_off(sc);
+ sc->spkr_state = SPKR_OFF;
+
+ ess_audio1_halt(sc);
+
+ sc->sc_open = 0;
+ DPRINTF(("ess_1788_close: closed\n"));
+}
+
+void
+ess_1888_close(addr)
+ void *addr;
+{
+ struct ess_softc *sc = addr;
+
+ DPRINTF(("ess_1888_close: sc=%p\n", sc));
+
+ ess_speaker_off(sc);
+ sc->spkr_state = SPKR_OFF;
+
+ ess_audio1_halt(sc);
+ ess_audio2_halt(sc);
+
+ sc->sc_open = 0;
+ DPRINTF(("ess_1888_close: closed\n"));
+}
+
+/*
+ * Wait for FIFO to drain, and analog section to settle.
+ * XXX should check FIFO empty bit.
+ */
+int
+ess_drain(addr)
+ void *addr;
+{
+ tsleep(addr, PWAIT | PCATCH, "essdr", hz/20); /* XXX */
+ return (0);
+}
+
+/* XXX should use reference count */
+int
+ess_speaker_ctl(addr, newstate)
+ void *addr;
+ int newstate;
+{
+ struct ess_softc *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(addr, retp)
+ void *addr;
+ struct audio_device *retp;
+{
+ *retp = ess_device;
+ return (0);
+}
+
+int
+ess_query_encoding(addr, fp)
+ void *addr;
+ struct audio_encoding *fp;
+{
+ /*struct ess_softc *sc = addr;*/
+
+ switch (fp->index) {
+ case 0:
+ strcpy(fp->name, AudioEulinear);
+ fp->encoding = AUDIO_ENCODING_ULINEAR;
+ fp->precision = 8;
+ fp->flags = 0;
+ return (0);
+ case 1:
+ strcpy(fp->name, AudioEmulaw);
+ fp->encoding = AUDIO_ENCODING_ULAW;
+ fp->precision = 8;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 2:
+ strcpy(fp->name, AudioEalaw);
+ fp->encoding = AUDIO_ENCODING_ALAW;
+ fp->precision = 8;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 3:
+ strcpy(fp->name, AudioEslinear);
+ fp->encoding = AUDIO_ENCODING_SLINEAR;
+ fp->precision = 8;
+ fp->flags = 0;
+ return (0);
+ case 4:
+ strcpy(fp->name, AudioEslinear_le);
+ fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
+ fp->precision = 16;
+ fp->flags = 0;
+ return (0);
+ case 5:
+ strcpy(fp->name, AudioEulinear_le);
+ fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
+ fp->precision = 16;
+ fp->flags = 0;
+ return (0);
+ case 6:
+ strcpy(fp->name, AudioEslinear_be);
+ fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
+ fp->precision = 16;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ case 7:
+ strcpy(fp->name, AudioEulinear_be);
+ fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
+ fp->precision = 16;
+ fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
+ return (0);
+ default:
+ return EINVAL;
+ }
+ return (0);
+}
+
+int
+ess_set_params(addr, setmode, usemode, play, rec)
+ void *addr;
+ int setmode, usemode;
+ struct audio_params *play, *rec;
+{
+ struct ess_softc *sc = addr;
+ struct audio_params *p;
+ int mode;
+ int rate;
+
+ DPRINTF(("ess_set_params: set=%d use=%d\n", setmode, usemode));
+
+ /*
+ * The ES1887 manual (page 39, `Full-Duplex DMA Mode') claims that in
+ * full-duplex operation the sample rates must be the same for both
+ * channels. This appears to be false; the only bit in common is the
+ * clock source selection. However, we'll be conservative here.
+ * - mycroft
+ */
+ if (play->sample_rate != rec->sample_rate &&
+ usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
+ if (setmode == AUMODE_PLAY) {
+ rec->sample_rate = play->sample_rate;
+ setmode |= AUMODE_RECORD;
+ } else if (setmode == AUMODE_RECORD) {
+ play->sample_rate = rec->sample_rate;
+ setmode |= AUMODE_PLAY;
+ } else
+ return (EINVAL);
+ }
+
+ for (mode = AUMODE_RECORD; mode != -1;
+ mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
+ if ((setmode & mode) == 0)
+ continue;
+
+ p = mode == AUMODE_PLAY ? play : rec;
+
+ if (p->sample_rate < ESS_MINRATE ||
+ p->sample_rate > ESS_MAXRATE ||
+ (p->precision != 8 && p->precision != 16) ||
+ (p->channels != 1 && p->channels != 2))
+ return (EINVAL);
+
+ p->factor = 1;
+ p->sw_code = 0;
+ switch (p->encoding) {
+ case AUDIO_ENCODING_SLINEAR_BE:
+ case AUDIO_ENCODING_ULINEAR_BE:
+ if (p->precision == 16)
+ p->sw_code = swap_bytes;
+ break;
+ case AUDIO_ENCODING_SLINEAR_LE:
+ case AUDIO_ENCODING_ULINEAR_LE:
+ break;
+ case AUDIO_ENCODING_ULAW:
+ if (mode == AUMODE_PLAY) {
+ p->factor = 2;
+ p->sw_code = mulaw_to_ulinear16;
+ } else
+ p->sw_code = ulinear8_to_mulaw;
+ break;
+ case AUDIO_ENCODING_ALAW:
+ if (mode == AUMODE_PLAY) {
+ p->factor = 2;
+ p->sw_code = alaw_to_ulinear16;
+ } else
+ p->sw_code = ulinear8_to_alaw;
+ break;
+ default:
+ return (EINVAL);
+ }
+ }
+
+ if (usemode == AUMODE_RECORD)
+ rate = rec->sample_rate;
+ else
+ rate = play->sample_rate;
+
+ ess_write_x_reg(sc, ESS_XCMD_SAMPLE_RATE, ess_srtotc(rate));
+ ess_write_x_reg(sc, ESS_XCMD_FILTER_CLOCK, ess_srtofc(rate));
+
+ if (sc->sc_model != ESS_1788) {
+ ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, ess_srtotc(rate));
+ ess_write_mix_reg(sc, ESS_MREG_FILTER_CLOCK, ess_srtofc(rate));
+ }
+
+ return (0);
+}
+
+int
+ess_audio1_trigger_output(addr, start, end, blksize, intr, arg, param)
+ void *addr;
+ void *start, *end;
+ int blksize;
+ void (*intr) __P((void *));
+ void *arg;
+ struct audio_params *param;
+{
+ struct ess_softc *sc = addr;
+ u_int8_t reg;
+
+ 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;
+ timeout(ess_audio1_poll, sc, hz/30);
+ }
+
+ 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 * 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;
+ ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
+
+ isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
+ (char *)end - (char *)start, NULL,
+ DMAMODE_WRITE | DMAMODE_LOOP, 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(addr, start, end, blksize, intr, arg, param)
+ void *addr;
+ void *start, *end;
+ int blksize;
+ void (*intr) __P((void *));
+ void *arg;
+ struct audio_params *param;
+{
+ struct ess_softc *sc = addr;
+ u_int8_t reg;
+
+ 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;
+ timeout(ess_audio2_poll, sc, hz/30);
+ }
+
+ reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
+ if (param->precision * param->factor == 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_isa, sc->sc_audio2.drq, start,
+ (char *)end - (char *)start, NULL,
+ DMAMODE_WRITE | DMAMODE_LOOP, 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(addr, start, end, blksize, intr, arg, param)
+ void *addr;
+ void *start, *end;
+ int blksize;
+ void (*intr) __P((void *));
+ void *arg;
+ struct audio_params *param;
+{
+ struct ess_softc *sc = addr;
+ u_int8_t reg;
+
+ 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;
+ timeout(ess_audio1_poll, sc, hz/30);
+ }
+
+ 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 * 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;
+ ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
+
+ isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
+ (char *)end - (char *)start, NULL,
+ DMAMODE_READ | DMAMODE_LOOP, 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(addr)
+ void *addr;
+{
+ struct ess_softc *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_isa, sc->sc_audio1.drq);
+ if (sc->sc_audio1.polled)
+ untimeout(ess_audio1_poll, sc);
+ sc->sc_audio1.active = 0;
+ }
+
+ return (0);
+}
+
+int
+ess_audio2_halt(addr)
+ void *addr;
+{
+ struct ess_softc *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_isa, sc->sc_audio2.drq);
+ if (sc->sc_audio2.polled)
+ untimeout(ess_audio2_poll, sc);
+ sc->sc_audio2.active = 0;
+ }
+
+ return (0);
+}
+
+int
+ess_audio1_intr(arg)
+ void *arg;
+{
+ struct ess_softc *sc = arg;
+ u_int8_t reg;
+
+ DPRINTFN(1,("ess_audio1_intr: intr=%p\n", sc->sc_audio1.intr));
+
+ /* 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)
+ 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);
+ return (1);
+ } else
+ return (0);
+}
+
+int
+ess_audio2_intr(arg)
+ void *arg;
+{
+ struct ess_softc *sc = arg;
+ u_int8_t reg;
+
+ DPRINTFN(1,("ess_audio2_intr: intr=%p\n", sc->sc_audio2.intr));
+
+ /* Check and clear interrupt on Audio2. */
+ reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
+ if ((reg & ESS_AUDIO2_CTRL2_IRQ_LATCH) == 0)
+ 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);
+ return (1);
+ } else
+ return (0);
+}
+
+void
+ess_audio1_poll(addr)
+ void *addr;
+{
+ struct ess_softc *sc = addr;
+ int dmapos, dmacount;
+
+ if (!sc->sc_audio1.active)
+ return;
+
+ sc->sc_audio1.nintr++;
+
+ dmapos = isa_dmacount(sc->sc_isa, 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
+
+ timeout(ess_audio1_poll, sc, hz/30);
+}
+
+void
+ess_audio2_poll(addr)
+ void *addr;
+{
+ struct ess_softc *sc = addr;
+ int dmapos, dmacount;
+
+ if (!sc->sc_audio2.active)
+ return;
+
+ sc->sc_audio2.nintr++;
+
+ dmapos = isa_dmacount(sc->sc_isa, 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
+
+ timeout(ess_audio2_poll, sc, hz/30);
+}
+
+int
+ess_round_blocksize(addr, blk)
+ void *addr;
+ int blk;
+{
+ return (blk & -8); /* round for max DMA size */
+}
+
+int
+ess_set_port(addr, cp)
+ void *addr;
+ mixer_ctrl_t *cp;
+{
+ struct ess_softc *sc = addr;
+ int lgain, rgain;
+
+ 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 (sc->sc_model == ESS_1788) {
+ 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 (sc->sc_model == ESS_1788)
+ 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(addr, cp)
+ void *addr;
+ mixer_ctrl_t *cp;
+{
+ struct ess_softc *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 (sc->sc_model == ESS_1788)
+ 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 (sc->sc_model == ESS_1788)
+ 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(addr, dip)
+ void *addr;
+ mixer_devinfo_t *dip;
+{
+ struct ess_softc *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 (sc->sc_model == ESS_1788)
+ 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 (sc->sc_model == ESS_1788) {
+ /*
+ * 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, AudioNmonitor);
+ 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 (sc->sc_model == ESS_1788)
+ 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(addr, size, pool, flags)
+ void *addr;
+ unsigned long size;
+ int pool, flags;
+{
+ struct ess_softc *sc = addr;
+ int drq;
+
+ if (sc->sc_model != ESS_1788)
+ drq = sc->sc_audio2.drq;
+ else
+ drq = sc->sc_audio1.drq;
+ return (isa_malloc(sc->sc_isa, drq, size, pool, flags));
+}
+
+void
+ess_free(addr, ptr, pool)
+ void *addr;
+ void *ptr;
+ int pool;
+{
+ isa_free(ptr, pool);
+}
+
+unsigned long
+ess_round_buffersize(addr, size)
+ void *addr;
+ unsigned long size;
+{
+ if (size > MAX_ISADMA)
+ size = MAX_ISADMA;
+ return (size);
+}
+
+int
+ess_mappage(addr, mem, off, prot)
+ void *addr;
+ void *mem;
+ int off;
+ int prot;
+{
+ return (isa_mappage(mem, off, prot));
+}
+
+int
+ess_1788_get_props(addr)
+ void *addr;
+{
+
+ return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT);
+}
+
+int
+ess_1888_get_props(addr)
+ void *addr;
+{
+
+ return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX);
+}
+
+/* ============================================
+ * 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(sc)
+ struct ess_softc *sc;
+{
+ bus_space_tag_t iot = sc->sc_iot;
+ bus_space_handle_t 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);
+ 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(sc, port, on)
+ 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;
+
+ switch (port) {
+ case ESS_MASTER_VOL:
+ src = ESS_MREG_VOLUME_MASTER;
+ break;
+ case ESS_DAC_PLAY_VOL:
+ if (sc->sc_model == ESS_1788)
+ 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;
+ }
+
+ /* 1788 doesn't have a separate recording mixer */
+ if (sc->sc_model == ESS_1788 && mix && src > 0x62)
+ return;
+
+ if (on) {
+ left = sc->gain[port][ESS_LEFT];
+ right = sc->gain[port][ESS_RIGHT];
+ } else {
+ left = right = 0;
+ }
+
+ 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(sc, ord)
+ 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(sc, mask)
+ 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(sc)
+ struct ess_softc *sc;
+{
+ /* Disable mute on left- and right-master volume. */
+ ess_clear_mreg_bits(sc, ESS_MREG_VOLUME_LEFT, ESS_VOLUME_MUTE);
+ ess_clear_mreg_bits(sc, ESS_MREG_VOLUME_RIGHT, ESS_VOLUME_MUTE);
+}
+
+void
+ess_speaker_off(sc)
+ struct ess_softc *sc;
+{
+ /* Enable mute on left- and right-master volume. */
+ ess_set_mreg_bits(sc, ESS_MREG_VOLUME_LEFT, ESS_VOLUME_MUTE);
+ ess_set_mreg_bits(sc, ESS_MREG_VOLUME_RIGHT, ESS_VOLUME_MUTE);
+}
+
+/*
+ * Calculate the time constant for the requested sampling rate.
+ */
+u_int
+ess_srtotc(rate)
+ u_int rate;
+{
+ u_int tc;
+
+ /* The following formulae 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 reuqested sampling rate.
+ */
+u_int
+ess_srtofc(rate)
+ 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(sc)
+ 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(sc)
+ 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(sc)
+ 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(sc)
+ struct ess_softc *sc;
+{
+ bus_space_tag_t iot = sc->sc_iot;
+ bus_space_handle_t ioh = sc->sc_ioh;
+ int i;
+
+ 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(sc, v)
+ struct ess_softc *sc;
+ u_char v;
+{
+ bus_space_tag_t iot = sc->sc_iot;
+ bus_space_handle_t ioh = sc->sc_ioh;
+ int i;
+
+ DPRINTFN(8,("ess_wdsp(0x%02x)\n", v));
+
+ 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(sc, reg, val)
+ 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(sc, 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(sc, reg, mask)
+ 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(sc, reg, mask)
+ 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(sc, reg, val)
+ struct ess_softc *sc;
+ u_char reg;
+ u_char val;
+{
+ bus_space_tag_t iot = sc->sc_iot;
+ bus_space_handle_t ioh = sc->sc_ioh;
+ int s;
+
+ DPRINTFN(2,("ess_write_mix_reg: %x=%x\n", reg, val));
+
+ s = splaudio();
+ EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
+ EWRITE1(iot, ioh, ESS_MIX_REG_DATA, val);
+ splx(s);
+}
+
+/*
+ * Read the value of one of the ESS mixer registers.
+ */
+u_char
+ess_read_mix_reg(sc, reg)
+ struct ess_softc *sc;
+ u_char reg;
+{
+ bus_space_tag_t iot = sc->sc_iot;
+ bus_space_handle_t ioh = sc->sc_ioh;
+ int s;
+ u_char val;
+
+ s = splaudio();
+ EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
+ val = EREAD1(iot, ioh, ESS_MIX_REG_DATA);
+ splx(s);
+
+ DPRINTFN(2,("ess_read_mix_reg: %x=%x\n", reg, val));
+ return val;
+}
+
+void
+ess_clear_mreg_bits(sc, reg, mask)
+ 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(sc, reg, mask)
+ struct ess_softc *sc;
+ u_char reg;
+ u_char mask;
+{
+ ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) | mask);
+}
diff --git a/sys/dev/isa/ess_isapnp.c b/sys/dev/isa/ess_isapnp.c
new file mode 100644
index 00000000000..5e1179df724
--- /dev/null
+++ b/sys/dev/isa/ess_isapnp.c
@@ -0,0 +1,105 @@
+/* $OpenBSD: ess_isapnp.c,v 1.1 1999/06/22 16:20:03 niklas Exp $ */
+/* $NetBSD: ess_isa.c,v 1.4 1999/03/18 20:57:11 mycroft Exp $ */
+
+/*-
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Nathan J. Williams.
+ *
+ * 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 the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+
+#include <machine/cpu.h>
+#include <machine/bus.h>
+
+#include <dev/isa/isavar.h>
+
+#include <dev/isa/essreg.h>
+#include <dev/isa/essvar.h>
+
+#ifdef ESS_ISAPNP_DEBUG
+#define DPRINTF(x) printf x
+#else
+#define DPRINTF(x)
+#endif
+
+int ess_isapnp_probe __P((struct device *, void *, void *));
+void ess_isapnp_attach __P((struct device *, struct device *, void *));
+
+struct cfattach ess_isapnp_ca = {
+ sizeof(struct ess_softc), ess_isapnp_probe, ess_isapnp_attach
+};
+
+int
+ess_isapnp_probe(parent, match, aux)
+ struct device *parent;
+ void *match, *aux;
+{
+ return 1;
+}
+
+void ess_isapnp_attach(parent, self, aux)
+ struct device *parent, *self;
+ void *aux;
+{
+ struct ess_softc *sc = (void *)self;
+ struct isa_attach_args *ia = aux;
+
+ printf("\n");
+
+ sc->sc_ic = ia->ia_ic;
+ sc->sc_iot = ia->ia_iot;
+ sc->sc_ioh = ia->ipa_io[0].h;
+ sc->sc_iobase = ia->ipa_io[0].base;
+
+ sc->sc_audio1.irq = ia->ipa_irq[0].num;
+ sc->sc_audio1.ist = ia->ipa_irq[0].type;
+ sc->sc_audio1.drq = ia->ipa_drq[0].num;
+ sc->sc_audio2.irq = ia->ipa_irq[0].num;
+ sc->sc_audio2.ist = ia->ipa_irq[0].type;
+ sc->sc_audio2.drq = ia->ipa_drq[1].num;
+
+ sc->sc_isa = parent->dv_parent;
+
+ if (!essmatch(sc)) {
+ printf("%s: essmatch failed\n", sc->sc_dev.dv_xname);
+ return;
+ }
+
+ printf("%s:", sc->sc_dev.dv_xname);
+
+ essattach(sc);
+}
diff --git a/sys/dev/isa/essreg.h b/sys/dev/isa/essreg.h
new file mode 100644
index 00000000000..77ac01b2919
--- /dev/null
+++ b/sys/dev/isa/essreg.h
@@ -0,0 +1,306 @@
+/* $OpenBSD: essreg.h,v 1.1 1999/06/22 16:20:03 niklas Exp $ */
+/* $NetBSD: essreg.h,v 1.11 1999/03/19 12:40:21 mycroft 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.
+ */
+
+/*
+** @(#) $RCSfile: essreg.h,v $ $Revision: 1.1 $ (SHARK) $Date: 1999/06/22 16:20:03 $
+**
+**++
+**
+** essreg.h
+**
+** FACILITY:
+**
+** DIGITAL Network Appliance Reference Design (DNARD)
+**
+** MODULE DESCRIPTION:
+**
+** This module contains the constant definitions for the device
+** registers on the ESS Technologies 1888/1887/888 sound chip.
+**
+** AUTHORS:
+**
+** Blair Fidler Software Engineering Australia
+** Gold Coast, Australia.
+**
+** CREATION DATE:
+**
+** March 10, 1997.
+**
+** MODIFICATION HISTORY:
+**
+**--
+*/
+
+/*
+ * DSP commands. This unit handles MIDI and audio capabilities.
+ * The DSP can be reset, data/commands can be read or written to it,
+ * and it can generate interrupts. Interrupts are generated for MIDI
+ * input or DMA completion. They seem to have neglected the fact
+ * that it would be nice to have a MIDI transmission complete interrupt.
+ * Worse, the DMA engine is half-duplex. This means you need to do
+ * (timed) programmed I/O to be able to record and play simulataneously.
+ */
+#define ESS_ACMD_DAC8WRITE 0x10 /* direct-mode 8-bit DAC write */
+#define ESS_ACMD_DAC16WRITE 0x11 /* direct-mode 16-bit DAC write */
+#define ESS_ACMD_DMA8OUT 0x14 /* 8-bit linear DMA output */
+#define ESS_ACMD_DMA16OUT 0x15 /* 16-bit linear DMA output */
+#define ESS_ACMD_AUTODMA8OUT 0x1C /* auto-init 8-bit linear DMA output */
+#define ESS_ACMD_AUTODMA16OUT 0x1D /* auto-init 16-bit linear DMA output */
+#define ESS_ACMD_ADC8READ 0x20 /* direct-mode 8-bit ADC read */
+#define ESS_ACMD_ADC16READ 0x21 /* direct-mode 16-bit ADC read */
+#define ESS_ACMD_DMA8IN 0x24 /* 8-bit linear DMA input */
+#define ESS_ACMD_DMA16IN 0x25 /* 16-bit linear DMA input */
+#define ESS_ACMD_AUTODMA8IN 0x2C /* auto-init 8-bit linear DMA input */
+#define ESS_ACMD_AUTODMA16IN 0x2D /* auto-init 16-bit linear DMA input */
+#define ESS_ACMD_SETTIMECONST1 0x40 /* set time constant (1MHz base) */
+#define ESS_ACMD_SETTIMECONST15 0x41 /* set time constant (1.5MHz base) */
+#define ESS_ACMD_SETFILTER 0x42 /* set filter clock independently */
+#define ESS_ACMD_BLOCKSIZE 0x48 /* set blk size for high speed xfer */
+
+#define ESS_ACMD_DMA4OUT 0x74 /* 4-bit ADPCM DMA output */
+#define ESS_ACMD_DMA4OUTREF 0x75 /* 4-bit ADPCM DMA output with ref */
+#define ESS_ACMD_DMA2_6OUT 0x76 /* 2.6-bit ADPCM DMA output */
+#define ESS_ACMD_DMA2_6OUTREF 0x77 /* 2.6-bit ADPCM DMA output with ref */
+#define ESS_ACMD_DMA2OUT 0x7A /* 2-bit ADPCM DMA output */
+#define ESS_ACMD_DMA2OUTREF 0x7B /* 2-bit ADPCM DMA output with ref */
+#define ESS_ACMD_SILENCEOUT 0x80 /* output a block of silence */
+#define ESS_ACMD_START_AUTO_OUT 0x90 /* start auto-init 8-bit DMA output */
+#define ESS_ACMD_START_OUT 0x91 /* start 8-bit DMA output */
+#define ESS_ACMD_START_AUTO_IN 0x98 /* start auto-init 8-bit DMA input */
+#define ESS_ACMD_START_IN 0x99 /* start 8-bit DMA input */
+
+#define ESS_XCMD_SAMPLE_RATE 0xA1 /* sample rate for Audio1 channel */
+#define ESS_XCMD_FILTER_CLOCK 0xA2 /* filter clock for Audio1 channel*/
+#define ESS_XCMD_XFER_COUNTLO 0xA4 /* */
+#define ESS_XCMD_XFER_COUNTHI 0xA5 /* */
+#define ESS_XCMD_AUDIO_CTRL 0xA8 /* */
+#define ESS_AUDIO_CTRL_MONITOR 0x08 /* 0=disable/1=enable */
+#define ESS_AUDIO_CTRL_MONO 0x02 /* 0=disable/1=enable */
+#define ESS_AUDIO_CTRL_STEREO 0x01 /* 0=disable/1=enable */
+#define ESS_XCMD_PREAMP_CTRL 0xA9 /* */
+#define ESS_PREAMP_CTRL_ENABLE 0x04
+
+#define ESS_XCMD_IRQ_CTRL 0xB1 /* legacy audio interrupt control */
+#define ESS_IRQ_CTRL_INTRA 0x00
+#define ESS_IRQ_CTRL_INTRB 0x04
+#define ESS_IRQ_CTRL_INTRC 0x08
+#define ESS_IRQ_CTRL_INTRD 0x0C
+#define ESS_IRQ_CTRL_MASK 0x10
+#define ESS_IRQ_CTRL_EXT 0x40
+#define ESS_XCMD_DRQ_CTRL 0xB2 /* audio DRQ control */
+#define ESS_DRQ_CTRL_DRQA 0x04
+#define ESS_DRQ_CTRL_DRQB 0x08
+#define ESS_DRQ_CTRL_DRQC 0x0C
+#define ESS_DRQ_CTRL_PU 0x10
+#define ESS_DRQ_CTRL_EXT 0x40
+#define ESS_XCMD_VOLIN_CTRL 0xB4 /* stereo input volume control */
+#define ESS_1788_XCMD_AUDIO_CTRL0 0xB6
+#define ESS_CTRL0_SIGNED 0x00
+#define ESS_CTRL0_UNSIGNED 0x80
+#define ESS_XCMD_AUDIO1_CTRL1 0xB7 /* */
+#define ESS_AUDIO1_CTRL1_FIFO_CONNECT 0x80 /* 1=connected */
+#define ESS_AUDIO1_CTRL1_FIFO_MONO 0x40 /* 0=stereo/1=mono */
+#define ESS_AUDIO1_CTRL1_FIFO_SIGNED 0x20 /* 0=unsigned/1=signed */
+#define ESS_AUDIO1_CTRL1_FIFO_STEREO 0x08 /* 0=mono/1=stereo */
+#define ESS_AUDIO1_CTRL1_FIFO_SIZE 0x04 /* 0=8-bit/1=16-bit */
+#define ESS_XCMD_AUDIO1_CTRL2 0xB8 /* */
+#define ESS_AUDIO1_CTRL2_FIFO_ENABLE 0x01 /* 0=disable/1=enable */
+#define ESS_AUDIO1_CTRL2_DMA_READ 0x02 /* 0=DMA write/1=DMA read */
+#define ESS_AUDIO1_CTRL2_AUTO_INIT 0x04
+#define ESS_AUDIO1_CTRL2_ADC_ENABLE 0x08 /* 0=DAC mode/1=ADC mode */
+#define ESS_XCMD_DEMAND_CTRL 0xB9 /* */
+#define ESS_DEMAND_CTRL_SINGLE 0x00 /* 1-byte transfers */
+#define ESS_DEMAND_CTRL_DEMAND_2 0x01 /* 2-byte transfers */
+#define ESS_DEMAND_CTRL_DEMAND_4 0x02 /* 4-byte transfers */
+
+#define ESS_ACMD_ENABLE_EXT 0xC6 /* enable ESS extension commands */
+#define ESS_ACMD_DISABLE_EXT 0xC7 /* enable ESS extension commands */
+
+#define ESS_ACMD_PAUSE_DMA 0xD0 /* pause DMA */
+#define ESS_ACMD_ENABLE_SPKR 0xD1 /* enable Audio1 DAC input to mixer */
+#define ESS_ACMD_DISABLE_SPKR 0xD3 /* disable Audio1 DAC input to mixer */
+#define ESS_ACMD_CONT_DMA 0xD4 /* continue paused DMA */
+#define ESS_ACMD_SPKR_STATUS 0xD8 /* return Audio1 DAC status: */
+#define ESS_SPKR_OFF 0x00
+#define ESS_SPKR_ON 0xFF
+#define ESS_ACMD_VERSION 0xE1 /* get version number */
+#define ESS_ACMD_LEGACY_ID 0xE7 /* get legacy ES688/ES1688 ID bytes */
+
+#define ESS_MINRATE 4000
+#define ESS_MAXRATE 44100
+
+/*
+ * Macros to detect valid hardware configuration data.
+ */
+#define ESS_BASE_VALID(base) ((base) == 0x220 || (base) == 0x230 || (base) == 0x240 || (base) == 0x250)
+#define ESS_IRQ1_VALID(irq) ((irq) == 5 || (irq) == 7 || (irq) == 9 || (irq) == 10)
+
+#define ESS_IRQ2_VALID(irq) ((irq) == 15)
+
+#define ESS_IRQ12_VALID(irq) ((irq) == 5 || (irq) == 7 || (irq) == 9 || (irq) == 10 || (irq) == 15)
+
+#define ESS_DRQ1_VALID(chan) ((chan) == 0 || (chan) == 1 || (chan) == 3)
+
+#define ESS_DRQ2_VALID(chan) ((chan) == 0 || (chan) == 1 || (chan) == 3 || (chan) == 5)
+
+#define ESS_BASE_VALID(base) ((base) == 0x220 || (base) == 0x230 || (base) == 0x240 || (base) == 0x250)
+
+/*
+ * Macros to manipulate gain values
+ */
+#define ESS_4BIT_GAIN(x) ((x) & 0xf0)
+#define ESS_3BIT_GAIN(x) (((x) & 0xe0) >> 1)
+#define ESS_STEREO_GAIN(l, r) ((l) | ((r) >> 4))
+#define ESS_MONO_GAIN(x) ((x) >> 4)
+
+#ifdef ESS_AMODE_LOW
+/*
+ * Registers used to configure ESS chip via Read Key Sequence
+ */
+#define ESS_CONFIG_KEY_BASE 0x229
+#define ESS_CONFIG_KEY_PORTS 3
+#else
+/*
+ * Registers used to configure ESS chip via System Control Register (SCR)
+ */
+#define ESS_SCR_ACCESS_BASE 0xF9
+#define ESS_SCR_ACCESS_PORTS 3
+#define ESS_SCR_LOCK 0
+#define ESS_SCR_UNLOCK 2
+
+#define ESS_SCR_BASE 0xE0
+#define ESS_SCR_PORTS 2
+#define ESS_SCR_INDEX 0
+#define ESS_SCR_DATA 1
+
+/*
+ * Bit definitions for SCR
+ */
+#define ESS_SCR_AUDIO_ENABLE 0x04
+#define ESS_SCR_AUDIO_220 0x00
+#define ESS_SCR_AUDIO_230 0x01
+#define ESS_SCR_AUDIO_240 0x02
+#define ESS_SCR_AUDIO_250 0x03
+#endif
+
+/*****************************************************************************/
+/* DSP Timeout Definitions */
+/*****************************************************************************/
+#define ESS_READ_TIMEOUT 5000 /* number of times to try a read, 5ms*/
+#define ESS_WRITE_TIMEOUT 5000 /* number of times to try a write, 5ms */
+
+
+#define ESS_NPORT 16
+#define ESS_DSP_RESET 0x06
+#define ESS_RESET_EXT 0x03 /* reset and use second DMA */
+#define ESS_MAGIC 0xAA /* response to successful reset */
+
+#define ESS_DSP_READ 0x0A
+#define ESS_DSP_WRITE 0x0C
+
+#define ESS_CLEAR_INTR 0x0E
+
+#define ESS_DSP_RW_STATUS 0x0C
+#define ESS_DSP_WRITE_BUSY 0x80
+#define ESS_DSP_READ_READY 0x40
+#define ESS_DSP_READ_FULL 0x20 /* FIFO full */
+#define ESS_DSP_READ_EMPTY 0x10 /* FIFO empty */
+#define ESS_DSP_READ_HALF 0x08 /* FIFO half-empty */
+#define ESS_DSP_READ_IRQ 0x04 /* IRQ generated */
+#define ESS_DSP_READ_HALF_IRQ 0x02 /* " from half-empty flag change */
+#define ESS_DSP_READ_OFLOW 0x01 /* " from DMA counter overflow */
+#define ESS_DSP_READ_ANYIRQ (ESS_DSP_READ_IRQ | \
+ ESS_DSP_READ_HALF_IRQ | \
+ ESS_DSP_READ_OFLOW)
+
+#define ESS_MIX_REG_SELECT 0x04
+#define ESS_MIX_REG_DATA 0x05
+#define ESS_MIX_RESET 0x00 /* mixer reset port and value */
+
+
+/*
+ * ESS Mixer registers
+ */
+#define ESS_MREG_VOLUME_VOICE 0x14
+#define ESS_MREG_VOLUME_MIC 0x1A
+#define ESS_MREG_ADC_SOURCE 0x1C
+#define ESS_SOURCE_MIC 0x00
+#define ESS_SOURCE_CD 0x02
+#define ESS_SOURCE_LINE 0x06
+#define ESS_SOURCE_MIXER 0x07
+#define ESS_MREG_VOLUME_MASTER 0x32
+#define ESS_MREG_VOLUME_SYNTH 0x36
+#define ESS_MREG_VOLUME_CD 0x38
+#define ESS_MREG_VOLUME_AUXB 0x3A
+#define ESS_MREG_VOLUME_PCSPKR 0x3C
+#define ESS_MREG_VOLUME_LINE 0x3E
+#define ESS_MREG_VOLUME_LEFT 0x60
+#define ESS_MREG_VOLUME_RIGHT 0x62
+#define ESS_VOLUME_MUTE 0x40
+#define ESS_MREG_VOLUME_CTRL 0x64
+#define ESS_MREG_SAMPLE_RATE 0x70 /* sample rate for Audio2 channel */
+#define ESS_MREG_FILTER_CLOCK 0x72 /* filter clock for Audio2 channel */
+#define ESS_MREG_XFER_COUNTLO 0x74 /* low-byte of DMA transfer size */
+#define ESS_MREG_XFER_COUNTHI 0x76 /* high-byte of DMA transfer size */
+#define ESS_MREG_AUDIO2_CTRL1 0x78 /* control register 1 for Audio2: */
+#define ESS_AUDIO2_CTRL1_SINGLE 0x00
+#define ESS_AUDIO2_CTRL1_DEMAND_2 0x40
+#define ESS_AUDIO2_CTRL1_DEMAND_4 0x80
+#define ESS_AUDIO2_CTRL1_DEMAND_8 0xC0
+#define ESS_AUDIO2_CTRL1_XFER_SIZE 0x20 /* 0=8-bit/1=16-bit */
+#define ESS_AUDIO2_CTRL1_AUTO_INIT 0x10
+#define ESS_AUDIO2_CTRL1_FIFO_ENABLE 0x02 /* 0=disable/1=enable */
+#define ESS_AUDIO2_CTRL1_DAC_ENABLE 0x01 /* 0=disable/1=enable */
+#define ESS_MREG_AUDIO2_CTRL2 0x7A /* control register 2 for Audio2: */
+#define ESS_AUDIO2_CTRL2_FIFO_SIZE 0x01 /* 0=8-bit/1=16-bit */
+#define ESS_AUDIO2_CTRL2_CHANNELS 0x02 /* 0=mono/1=stereo */
+#define ESS_AUDIO2_CTRL2_FIFO_SIGNED 0x04 /* 0=unsigned/1=signed */
+#define ESS_AUDIO2_CTRL2_DMA_ENABLE 0x20 /* 0=disable/1=enable */
+#define ESS_AUDIO2_CTRL2_IRQ2_ENABLE 0x40
+#define ESS_AUDIO2_CTRL2_IRQ_LATCH 0x80
+#define ESS_MREG_AUDIO2_CTRL3 0x7D
+#define ESS_AUDIO2_CTRL3_DRQA 0x00
+#define ESS_AUDIO2_CTRL3_DRQB 0x01
+#define ESS_AUDIO2_CTRL3_DRQC 0x02
+#define ESS_AUDIO2_CTRL3_DRQD 0x03
+#define ESS_AUDIO2_CTRL3_DRQ_PD 0x04
+#define ESS_MREG_INTR_ST 0x7F
+#define ESS_IS_SELECT_IRQ 0x01
+#define ESS_IS_ES1888 0x00
+#define ESS_IS_INTRA 0x02
+#define ESS_IS_INTRB 0x04
+#define ESS_IS_INTRC 0x06
+#define ESS_IS_INTRD 0x08
+#define ESS_IS_INTRE 0x0A
diff --git a/sys/dev/isa/essvar.h b/sys/dev/isa/essvar.h
new file mode 100644
index 00000000000..d48b129302f
--- /dev/null
+++ b/sys/dev/isa/essvar.h
@@ -0,0 +1,159 @@
+/* $OpenBSD: essvar.h,v 1.1 1999/06/22 16:20:03 niklas Exp $ */
+/* $NetBSD: essvar.h,v 1.14 1999/03/18 06:03:31 mycroft 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.
+ */
+
+/*
+** @(#) $RCSfile: essvar.h,v $ $Revision: 1.1 $ (SHARK) $Date: 1999/06/22 16:20:03 $
+**
+**++
+**
+** essvar.h
+**
+** FACILITY:
+**
+** DIGITAL Network Appliance Reference Design (DNARD)
+**
+** MODULE DESCRIPTION:
+**
+** This module contains the structure definitions and function
+** prototypes for the ESS Technologies 1887/888 sound chip
+** driver.
+**
+** AUTHORS:
+**
+** Blair Fidler Software Engineering Australia
+** Gold Coast, Australia.
+**
+** CREATION DATE:
+**
+** May 12, 1997.
+**
+** MODIFICATION HISTORY:
+**
+**--
+*/
+#define ESS_DAC_PLAY_VOL 0
+#define ESS_MIC_PLAY_VOL 1
+#define ESS_LINE_PLAY_VOL 2
+#define ESS_SYNTH_PLAY_VOL 3
+#define ESS_CD_PLAY_VOL 4
+#define ESS_AUXB_PLAY_VOL 5
+#define ESS_INPUT_CLASS 6
+
+#define ESS_MASTER_VOL 7
+#define ESS_PCSPEAKER_VOL 8
+#define ESS_OUTPUT_CLASS 9
+
+#define ESS_RECORD_MONITOR 10
+#define ESS_MONITOR_CLASS 11
+
+#define ESS_RECORD_VOL 12
+#define ESS_RECORD_SOURCE 13
+#define ESS_RECORD_CLASS 14
+
+#define ESS_1788_NDEVS 15
+
+#define ESS_DAC_REC_VOL 15
+#define ESS_MIC_REC_VOL 16
+#define ESS_LINE_REC_VOL 17
+#define ESS_SYNTH_REC_VOL 18
+#define ESS_CD_REC_VOL 19
+#define ESS_AUXB_REC_VOL 20
+#define ESS_MIC_PREAMP 21
+
+#define ESS_1888_NDEVS 22
+#define ESS_MAX_NDEVS 22
+
+struct ess_audio_channel
+{
+ int drq; /* DMA channel */
+#define IS16BITDRQ(drq) ((drq) >= 4)
+ int irq; /* IRQ line for this DMA channel */
+ int ist;
+ void *ih; /* interrupt vectoring */
+ u_long nintr; /* number of interrupts taken */
+ void (*intr)__P((void*)); /* ISR for DMA complete */
+ void *arg; /* arg for intr() */
+
+ /* Status information */
+ int active; /* boolean: channel in use? */
+
+ /* Polling state */
+ int polled; /* 1 if channel is polled */
+ int dmapos; /* last DMA pointer */
+ int buffersize; /* size of DMA buffer */
+ /* (The following is only needed due to the stupid block interface.) */
+ int dmacount; /* leftover partial block */
+ int blksize; /* current block size */
+};
+
+struct ess_softc
+{
+ struct device sc_dev; /* base device */
+ struct device *sc_isa;
+ isa_chipset_tag_t sc_ic;
+ bus_space_tag_t sc_iot; /* tag */
+ bus_space_handle_t sc_ioh; /* handle */
+
+ int sc_iobase; /* I/O port base address */
+
+ u_short sc_open; /* reference count of open calls */
+
+ int ndevs;
+ u_char gain[ESS_MAX_NDEVS][2]; /* kept in input levels */
+#define ESS_LEFT 0
+#define ESS_RIGHT 1
+
+ u_int out_port; /* output port */
+ u_int in_mask; /* input ports */
+ u_int in_port; /* XXX needed for MI interface */
+
+ u_int spkr_state; /* non-null is on */
+
+ struct ess_audio_channel sc_audio1; /* audio channel for record */
+ struct ess_audio_channel sc_audio2; /* audio channel for playback */
+
+ u_int sc_model;
+#define ESS_UNSUPPORTED 0
+#define ESS_1888 1
+#define ESS_1887 2
+#define ESS_888 3
+#define ESS_1788 4
+
+ u_int sc_version; /* Legacy ES688/ES1688 ID */
+};
+
+int essmatch __P((struct ess_softc *));
+void essattach __P((struct ess_softc *));
+
diff --git a/sys/dev/isa/files.isa b/sys/dev/isa/files.isa
index 415610fd485..bed6e32209b 100644
--- a/sys/dev/isa/files.isa
+++ b/sys/dev/isa/files.isa
@@ -1,4 +1,4 @@
-# $OpenBSD: files.isa,v 1.52 1999/03/02 08:12:44 deraadt Exp $
+# $OpenBSD: files.isa,v 1.53 1999/06/22 16:20:04 niklas Exp $
# $NetBSD: files.isa,v 1.21 1996/05/16 03:45:55 mycroft Exp $
#
# Config file and device description for machine-independent ISA code.
@@ -283,6 +283,13 @@ file dev/isa/wss.c wss needs-flag
attach wss at isa with wss_isa
file dev/isa/wss_isa.c wss & (wss_isa | wss_isapnp) needs-flag
+# ESS Technology ES1887/ES888/ES1888
+device ess { } : audio, isa_dma, mulaw, auconv, midibus
+file dev/isa/ess.c ess needs-flag
+
+attach opl at ess with opl_ess
+file dev/isa/opl_ess.c opl_ess
+
# Gravis UltraSound & UltraSound MAX.
# Use the "flags" keyword in a config file to specify an extra DMA
# channel for full-duplex operation.
diff --git a/sys/dev/isa/files.isapnp b/sys/dev/isa/files.isapnp
index 034f0cc571c..75cfa74129c 100644
--- a/sys/dev/isa/files.isapnp
+++ b/sys/dev/isa/files.isapnp
@@ -1,4 +1,4 @@
-# $OpenBSD: files.isapnp,v 1.14 1999/03/04 22:14:35 deraadt Exp $
+# $OpenBSD: files.isapnp,v 1.15 1999/06/22 16:20:03 niklas Exp $
# $NetBSD: files.isapnp,v 1.7 1997/10/16 17:16:36 matt Exp $
#
# Config file and device description for machine-independent ISAPnP code.
@@ -28,6 +28,9 @@ file dev/isa/sb_isapnp.c sb & (sb_isa | sb_isapnp) needs-flag
attach wss at isapnp with wss_isapnp
file dev/isa/wss_isapnp.c wss & (wss_isa | wss_isapnp) needs-flag
+attach ess at isapnp with ess_isapnp
+file dev/isa/ess_isapnp.c ess & ess_isapnp needs-flag
+
attach le at isapnp with le_isapnp
file dev/isa/if_le_isapnp.c le_isapnp
diff --git a/sys/dev/isa/opl_ess.c b/sys/dev/isa/opl_ess.c
new file mode 100644
index 00000000000..9dc327fb938
--- /dev/null
+++ b/sys/dev/isa/opl_ess.c
@@ -0,0 +1,105 @@
+/* $OpenBSD: opl_ess.c,v 1.1 1999/06/22 16:20:04 niklas Exp $ */
+/* $NetBSD: opl_ess.c,v 1.3 1998/12/08 14:26:57 augustss Exp $ */
+
+/*
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Author: Lennart Augustsson
+ *
+ * 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 the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/errno.h>
+#include <sys/device.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+#include <sys/conf.h>
+#include <sys/select.h>
+#include <sys/audioio.h>
+#include <sys/midiio.h>
+
+#include <machine/bus.h>
+
+#include <dev/audio_if.h>
+#include <dev/midi_if.h>
+#include <dev/ic/oplreg.h>
+#include <dev/ic/oplvar.h>
+
+#include <dev/isa/isavar.h>
+#include <dev/isa/essvar.h>
+
+extern int ess_speaker_ctl __P((void *, int));
+
+int opl_ess_match __P((struct device *, void *, void *));
+void opl_ess_attach __P((struct device *, struct device *, void *));
+
+struct cfattach opl_ess_ca = {
+ sizeof (struct opl_softc), opl_ess_match, opl_ess_attach
+};
+
+int
+opl_ess_match(parent, match, aux)
+ struct device *parent;
+ void *match;
+ void *aux;
+{
+ struct audio_attach_args *aa = (struct audio_attach_args *)aux;
+ struct ess_softc *ssc = (struct ess_softc *)parent;
+ struct opl_softc sc;
+
+ if (aa->type != AUDIODEV_TYPE_OPL)
+ return (0);
+ memset(&sc, 0, sizeof sc);
+ sc.ioh = ssc->sc_ioh;
+ sc.iot = ssc->sc_iot;
+ return (opl_find(&sc));
+}
+
+void
+opl_ess_attach(parent, self, aux)
+ struct device *parent;
+ struct device *self;
+ void *aux;
+{
+ struct ess_softc *ssc = (struct ess_softc *)parent;
+ struct opl_softc *sc = (struct opl_softc *)self;
+
+ sc->ioh = ssc->sc_ioh;
+ sc->iot = ssc->sc_iot;
+ sc->offs = 0;
+ sc->spkrctl = ess_speaker_ctl;
+ sc->spkrarg = ssc;
+ strcpy(sc->syn.name, "ESS ");
+
+ opl_attach(sc);
+}
diff --git a/sys/dev/isa/pnpdevs b/sys/dev/isa/pnpdevs
index 755228fab14..d86cec56009 100644
--- a/sys/dev/isa/pnpdevs
+++ b/sys/dev/isa/pnpdevs
@@ -1,4 +1,4 @@
-# $OpenBSD: pnpdevs,v 1.73 1999/06/16 06:57:51 deraadt Exp $
+# $OpenBSD: pnpdevs,v 1.74 1999/06/22 16:20:04 niklas Exp $
#
# NOTE: All `com' devices also need pccom identifiers.
@@ -444,9 +444,9 @@ sb CTL0042 # SB AWE64 Value
sb CTL0043 # Creative ViBRA16X PnP
sb CTL0044 # SB AWE64 Gold
sb CTL0045 # SB AWE64 Value
-sb ESS1868 # ESS ES1868 Plug and Play AudioD
-sb ESS1869 # ESS ES1869 Plug and Play AudioD
-sb ESS1878 # ESS ES1878 Plug and Play AudioD
+ess ESS1868 # ESS ES1868 Plug and Play AudioD
+ess ESS1869 # ESS ES1869 Plug and Play AudioD
+ess ESS1878 # ESS ES1878 Plug and Play AudioD
wss OPT9310 # OPTi Audio 16 (possibly a wss instead of sb)
ym @@@1001 # ALS100+
ym YMH0021 # OPL3-SA2 Sound Board
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-04 20:06:51 +0000