diff options
| -rw-r--r-- | sys/dev/isa/ess.c | 2642 | ||||
| -rw-r--r-- | sys/dev/isa/ess_isapnp.c | 105 | ||||
| -rw-r--r-- | sys/dev/isa/essreg.h | 306 | ||||
| -rw-r--r-- | sys/dev/isa/essvar.h | 159 | ||||
| -rw-r--r-- | sys/dev/isa/files.isa | 9 | ||||
| -rw-r--r-- | sys/dev/isa/files.isapnp | 5 | ||||
| -rw-r--r-- | sys/dev/isa/opl_ess.c | 105 | ||||
| -rw-r--r-- | sys/dev/isa/pnpdevs | 8 |
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 |