diff options
Diffstat (limited to 'sys/arch')
| -rw-r--r-- | sys/arch/sparc64/dev/ce4231.c | 1508 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/ce4231var.h | 90 |
2 files changed, 1598 insertions, 0 deletions
diff --git a/sys/arch/sparc64/dev/ce4231.c b/sys/arch/sparc64/dev/ce4231.c new file mode 100644 index 00000000000..1ad2dfd3d4f --- /dev/null +++ b/sys/arch/sparc64/dev/ce4231.c @@ -0,0 +1,1508 @@ +/* $OpenBSD: ce4231.c,v 1.1 2001/10/01 18:10:32 jason Exp $ */ + +/* + * Copyright (c) 1999 Jason L. Wright (jason@thought.net) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Jason L. Wright + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR 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. + */ + +/* + * Driver for CS4231 based audio found in some sun4m systems (cs4231) + * based on ideas from the S/Linux project and the NetBSD project. + */ + +#include "audio.h" +#if NAUDIO > 0 + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/errno.h> +#include <sys/ioctl.h> +#include <sys/device.h> +#include <sys/proc.h> +#include <sys/malloc.h> + +#include <machine/cpu.h> +#include <machine/bus.h> +#include <machine/intr.h> +#include <machine/autoconf.h> + +#include <sys/audioio.h> +#include <dev/audio_if.h> +#include <dev/auconv.h> + +#include <sparc64/dev/ebusreg.h> +#include <sparc64/dev/ebusvar.h> +#include <sparc64/dev/ce4231var.h> + +#include <dev/ic/ad1848reg.h> +#include <dev/ic/cs4231reg.h> + +#define CSAUDIO_DAC_LVL 0 +#define CSAUDIO_LINE_IN_LVL 1 +#define CSAUDIO_MIC_LVL 2 +#define CSAUDIO_CD_LVL 3 +#define CSAUDIO_MONITOR_LVL 4 +#define CSAUDIO_OUTPUT_LVL 5 +#define CSAUDIO_LINE_IN_MUTE 6 +#define CSAUDIO_DAC_MUTE 7 +#define CSAUDIO_CD_MUTE 8 +#define CSAUDIO_MIC_MUTE 9 +#define CSAUDIO_MONITOR_MUTE 10 +#define CSAUDIO_OUTPUT_MUTE 11 +#define CSAUDIO_REC_LVL 12 +#define CSAUDIO_RECORD_SOURCE 13 +#define CSAUDIO_OUTPUT 14 +#define CSAUDIO_INPUT_CLASS 15 +#define CSAUDIO_OUTPUT_CLASS 16 +#define CSAUDIO_RECORD_CLASS 17 +#define CSAUDIO_MONITOR_CLASS 18 + +#define CSPORT_AUX2 0 +#define CSPORT_AUX1 1 +#define CSPORT_DAC 2 +#define CSPORT_LINEIN 3 +#define CSPORT_MONO 4 +#define CSPORT_MONITOR 5 +#define CSPORT_SPEAKER 6 +#define CSPORT_LINEOUT 7 +#define CSPORT_HEADPHONE 8 + +#define MIC_IN_PORT 0 +#define LINE_IN_PORT 1 +#define AUX1_IN_PORT 2 +#define DAC_IN_PORT 3 + +#ifdef AUDIO_DEBUG +#define DPRINTF(x) printf x +#else +#define DPRINTF(x) +#endif + +#define CS_TIMEOUT 90000 + +#define CS_PC_LINEMUTE XCTL0_ENABLE +#define CS_PC_HDPHMUTE XCTL1_ENABLE +#define CS_AFS_PI 0x10 + +/* Read/write CS4231 direct registers */ +#define CS_WRITE(sc,r,v) \ + bus_space_write_1((sc)->sc_bustag, (sc)->sc_cshandle, (r) << 2, (v)) +#define CS_READ(sc,r) \ + bus_space_read_1((sc)->sc_bustag, (sc)->sc_cshandle, (r) << 2) + +/* Read/write EBDMA playback registers */ +#define P_WRITE(sc,r,v) \ + bus_space_write_4((sc)->sc_bustag, (sc)->sc_pdmahandle, (r), (v)) +#define P_READ(sc,r) \ + bus_space_read_4((sc)->sc_bustag, (sc)->sc_pdmahandle, (r)) + +/* Read/write EBDMA capture registers */ +#define C_WRITE(sc,r,v) \ + bus_space_write_4((sc)->sc_bustag, (sc)->sc_cdmahandle, (r), (v)) +#define C_READ(sc,r) \ + bus_space_read_4((sc)->sc_bustag, (sc)->sc_cdmahandle, (r)) + +int ce4231_match __P((struct device *, void *, void *)); +void ce4231_attach __P((struct device *, struct device *, void *)); +int ce4231_cintr __P((void *)); +int ce4231_pintr __P((void *)); + +int ce4231_set_speed __P((struct ce4231_softc *, u_long *)); +void ce4231_setup_output __P((struct ce4231_softc *sc)); + +void ce4231_write __P((struct ce4231_softc *, u_int8_t, u_int8_t)); +u_int8_t ce4231_read __P((struct ce4231_softc *, u_int8_t)); + +/* Audio interface */ +int ce4231_open __P((void *, int)); +void ce4231_close __P((void *)); +int ce4231_query_encoding __P((void *, struct audio_encoding *)); +int ce4231_set_params __P((void *, int, int, struct audio_params *, + struct audio_params *)); +int ce4231_round_blocksize __P((void *, int)); +int ce4231_commit_settings __P((void *)); +int ce4231_halt_output __P((void *)); +int ce4231_halt_input __P((void *)); +int ce4231_getdev __P((void *, struct audio_device *)); +int ce4231_set_port __P((void *, mixer_ctrl_t *)); +int ce4231_get_port __P((void *, mixer_ctrl_t *)); +int ce4231_query_devinfo __P((void *addr, mixer_devinfo_t *)); +void * ce4231_alloc __P((void *, u_long, int, int)); +void ce4231_free __P((void *, void *, int)); +u_long ce4231_round_buffersize __P((void *, u_long)); +int ce4231_get_props __P((void *)); +int ce4231_trigger_output __P((void *, void *, void *, int, + void (*intr)__P((void *)), void *arg, struct audio_params *)); +int ce4231_trigger_input __P((void *, void *, void *, int, + void (*intr)__P((void *)), void *arg, struct audio_params *)); + +struct audio_hw_if ce4231_sa_hw_if = { + ce4231_open, + ce4231_close, + 0, + ce4231_query_encoding, + ce4231_set_params, + ce4231_round_blocksize, + ce4231_commit_settings, + 0, + 0, + 0, + 0, + ce4231_halt_output, + ce4231_halt_input, + 0, + ce4231_getdev, + 0, + ce4231_set_port, + ce4231_get_port, + ce4231_query_devinfo, + ce4231_alloc, + ce4231_free, + ce4231_round_buffersize, + 0, + ce4231_get_props, + ce4231_trigger_output, + ce4231_trigger_input +}; + +struct cfattach audioce_ca = { + sizeof (struct ce4231_softc), ce4231_match, ce4231_attach +}; + +struct cfdriver audioce_cd = { + NULL, "audioce", DV_DULL +}; + +struct audio_device ce4231_device = { + "SUNW,CS4231", + "b", + "onboard1", +}; + +int +ce4231_match(parent, vcf, aux) + struct device *parent; + void *vcf, *aux; +{ + struct ebus_attach_args *ea = aux; + + return (strcmp("SUNW,CS4231", ea->ea_name) == 0); +} + +void +ce4231_attach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct ebus_attach_args *ea = aux; + struct ce4231_softc *sc = (struct ce4231_softc *)self; + int node; + + node = ea->ea_node; + + sc->sc_last_format = 0xffffffff; + + /* Pass on the bus tags */ + sc->sc_bustag = ea->ea_bustag; + sc->sc_dmatag = ea->ea_dmatag; + + /* Make sure things are sane. */ + if (ea->ea_nintrs != 2) { + printf(": expected 2 interrupts, got %d\n", ea->ea_nintrs); + return; + } + if (ea->ea_nregs != 4) { + printf(": expected 4 register set, got %d\n", + ea->ea_nregs); + return; + } + + if (bus_intr_establish(ea->ea_bustag, ea->ea_intrs[0], IPL_AUDIO, 0, + ce4231_cintr, sc) == NULL) { + printf(": couldn't establish interrupt1\n"); + return; + } + if (bus_intr_establish(ea->ea_bustag, ea->ea_intrs[1], IPL_AUDIO, 0, + ce4231_pintr, sc) == NULL) { + printf(": couldn't establish interrupt1\n"); + return; + } + + /* XXX what if prom has already mapped?! */ + + if (ebus_bus_map(ea->ea_bustag, 0, + EBUS_PADDR_FROM_REG(&ea->ea_regs[0]), ea->ea_regs[0].size, + BUS_SPACE_MAP_LINEAR, 0, &sc->sc_cshandle) != 0) { + printf(": couldn't map cs4231 registers\n"); + return; + } + + if (ebus_bus_map(ea->ea_bustag, 0, + EBUS_PADDR_FROM_REG(&ea->ea_regs[1]), ea->ea_regs[1].size, + BUS_SPACE_MAP_LINEAR, 0, &sc->sc_pdmahandle) != 0) { + printf(": couldn't map dma1 registers\n"); + return; + } + + if (ebus_bus_map(ea->ea_bustag, 0, + EBUS_PADDR_FROM_REG(&ea->ea_regs[2]), ea->ea_regs[2].size, + BUS_SPACE_MAP_LINEAR, 0, &sc->sc_cdmahandle) != 0) { + printf(": couldn't map dma2 registers\n"); + return; + } + + if (ebus_bus_map(ea->ea_bustag, 0, + EBUS_PADDR_FROM_REG(&ea->ea_regs[3]), ea->ea_regs[3].size, + BUS_SPACE_MAP_LINEAR, 0, &sc->sc_auxhandle) != 0) { + printf(": couldn't map aux registers\n"); + return; + } + + printf(": nvaddrs %d\n", ea->ea_nvaddrs); + + evcnt_attach(&sc->sc_dev, "intr", &sc->sc_intrcnt); + + audio_attach_mi(&ce4231_sa_hw_if, sc, &sc->sc_dev); + + /* Default to speaker, unmuted, reasonable volume */ + sc->sc_out_port = CSPORT_SPEAKER; + sc->sc_mute[CSPORT_SPEAKER] = 1; + sc->sc_mute[CSPORT_MONITOR] = 1; + sc->sc_volume[CSPORT_SPEAKER].left = 192; + sc->sc_volume[CSPORT_SPEAKER].right = 192; + + /* XXX get real burst... */ + sc->sc_burst = EBDCSR_BURST_8; +} + +/* + * Write to one of the indexed registers of cs4231. + */ +void +ce4231_write(sc, r, v) + struct ce4231_softc *sc; + u_int8_t r, v; +{ + CS_WRITE(sc, AD1848_IADDR, r); + CS_WRITE(sc, AD1848_IDATA, v); +} + +/* + * Read from one of the indexed registers of cs4231. + */ +u_int8_t +ce4231_read(sc, r) + struct ce4231_softc *sc; + u_int8_t r; +{ + CS_WRITE(sc, AD1848_IADDR, r); + return (CS_READ(sc, AD1848_IDATA)); +} + +int +ce4231_set_speed(sc, argp) + struct ce4231_softc *sc; + u_long *argp; + +{ + /* + * The available speeds are in the following table. Keep the speeds in + * the increasing order. + */ + typedef struct { + int speed; + u_char bits; + } speed_struct; + u_long arg = *argp; + + static speed_struct speed_table[] = { + {5510, (0 << 1) | CLOCK_XTAL2}, + {5510, (0 << 1) | CLOCK_XTAL2}, + {6620, (7 << 1) | CLOCK_XTAL2}, + {8000, (0 << 1) | CLOCK_XTAL1}, + {9600, (7 << 1) | CLOCK_XTAL1}, + {11025, (1 << 1) | CLOCK_XTAL2}, + {16000, (1 << 1) | CLOCK_XTAL1}, + {18900, (2 << 1) | CLOCK_XTAL2}, + {22050, (3 << 1) | CLOCK_XTAL2}, + {27420, (2 << 1) | CLOCK_XTAL1}, + {32000, (3 << 1) | CLOCK_XTAL1}, + {33075, (6 << 1) | CLOCK_XTAL2}, + {33075, (4 << 1) | CLOCK_XTAL2}, + {44100, (5 << 1) | CLOCK_XTAL2}, + {48000, (6 << 1) | CLOCK_XTAL1}, + }; + + int i, n, selected = -1; + + n = sizeof(speed_table) / sizeof(speed_struct); + + if (arg < speed_table[0].speed) + selected = 0; + if (arg > speed_table[n - 1].speed) + selected = n - 1; + + for (i = 1; selected == -1 && i < n; i++) { + if (speed_table[i].speed == arg) + selected = i; + else if (speed_table[i].speed > arg) { + int diff1, diff2; + + diff1 = arg - speed_table[i - 1].speed; + diff2 = speed_table[i].speed - arg; + if (diff1 < diff2) + selected = i - 1; + else + selected = i; + } + } + + if (selected == -1) { + printf("%s: can't find speed\n", sc->sc_dev.dv_xname); + selected = 3; + } + + sc->sc_speed_bits = speed_table[selected].bits; + sc->sc_need_commit = 1; + *argp = speed_table[selected].speed; + + return (0); +} + +/* + * Audio interface functions + */ +int +ce4231_open(addr, flags) + void *addr; + int flags; +{ + struct ce4231_softc *sc = addr; + int tries; + + if (sc->sc_open) + return (EBUSY); + sc->sc_open = 1; + sc->sc_locked = 0; + sc->sc_rintr = 0; + sc->sc_rarg = 0; + sc->sc_pintr = 0; + sc->sc_parg = 0; + + P_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET); + C_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET); + P_WRITE(sc, EBDMA_DCSR, sc->sc_burst); + C_WRITE(sc, EBDMA_DCSR, sc->sc_burst); + + DELAY(20); + + for (tries = CS_TIMEOUT; + tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--) + DELAY(10); + if (tries == 0) + printf("%s: timeout waiting for reset\n", sc->sc_dev.dv_xname); + + /* Turn on cs4231 mode */ + ce4231_write(sc, SP_MISC_INFO, + ce4231_read(sc, SP_MISC_INFO) | MODE2); + + ce4231_setup_output(sc); + return (0); +} + +void +ce4231_setup_output(sc) + struct ce4231_softc *sc; +{ + u_int8_t pc, mi, rm, lm; + + pc = ce4231_read(sc, SP_PIN_CONTROL) | CS_PC_HDPHMUTE | CS_PC_LINEMUTE; + + mi = ce4231_read(sc, CS_MONO_IO_CONTROL) | MONO_OUTPUT_MUTE; + + lm = ce4231_read(sc, SP_LEFT_OUTPUT_CONTROL); + lm &= ~OUTPUT_ATTEN_BITS; + lm |= ((~(sc->sc_volume[CSPORT_SPEAKER].left >> 2)) & + OUTPUT_ATTEN_BITS) | OUTPUT_MUTE; + + rm = ce4231_read(sc, SP_RIGHT_OUTPUT_CONTROL); + rm &= ~OUTPUT_ATTEN_BITS; + rm |= ((~(sc->sc_volume[CSPORT_SPEAKER].right >> 2)) & + OUTPUT_ATTEN_BITS) | OUTPUT_MUTE; + + if (sc->sc_mute[CSPORT_MONITOR]) { + lm &= ~OUTPUT_MUTE; + rm &= ~OUTPUT_MUTE; + } + + switch (sc->sc_out_port) { + case CSPORT_HEADPHONE: + if (sc->sc_mute[CSPORT_SPEAKER]) + pc &= ~CS_PC_HDPHMUTE; + break; + case CSPORT_SPEAKER: + if (sc->sc_mute[CSPORT_SPEAKER]) + mi &= ~MONO_OUTPUT_MUTE; + break; + case CSPORT_LINEOUT: + if (sc->sc_mute[CSPORT_SPEAKER]) + pc &= ~CS_PC_LINEMUTE; + break; + } + + ce4231_write(sc, SP_LEFT_OUTPUT_CONTROL, lm); + ce4231_write(sc, SP_RIGHT_OUTPUT_CONTROL, rm); + ce4231_write(sc, SP_PIN_CONTROL, pc); + ce4231_write(sc, CS_MONO_IO_CONTROL, mi); +} + +void +ce4231_close(addr) + void *addr; +{ + struct ce4231_softc *sc = addr; + + ce4231_halt_input(sc); + ce4231_halt_output(sc); + sc->sc_open = 0; +} + +int +ce4231_query_encoding(addr, fp) + void *addr; + struct audio_encoding *fp; +{ + int err = 0; + + switch (fp->index) { + case 0: + strcpy(fp->name, AudioEmulaw); + fp->encoding = AUDIO_ENCODING_ULAW; + fp->precision = 8; + fp->flags = 0; + break; + case 1: + strcpy(fp->name, AudioEalaw); + fp->encoding = AUDIO_ENCODING_ALAW; + fp->precision = 8; + fp->flags = 0; + break; + case 2: + strcpy(fp->name, AudioEslinear_le); + fp->encoding = AUDIO_ENCODING_SLINEAR_LE; + fp->precision = 16; + fp->flags = 0; + break; + case 3: + strcpy(fp->name, AudioEulinear); + fp->encoding = AUDIO_ENCODING_ULINEAR; + fp->precision = 8; + fp->flags = 0; + break; + case 4: + strcpy(fp->name, AudioEslinear_be); + fp->encoding = AUDIO_ENCODING_SLINEAR_BE; + fp->precision = 16; + fp->flags = 0; + break; + case 5: + strcpy(fp->name, AudioEslinear); + fp->encoding = AUDIO_ENCODING_SLINEAR; + fp->precision = 8; + fp->flags = AUDIO_ENCODINGFLAG_EMULATED; + break; + case 6: + strcpy(fp->name, AudioEulinear_le); + fp->encoding = AUDIO_ENCODING_ULINEAR_LE; + fp->precision = 16; + fp->flags = AUDIO_ENCODINGFLAG_EMULATED; + break; + case 7: + strcpy(fp->name, AudioEulinear_be); + fp->encoding = AUDIO_ENCODING_ULINEAR_BE; + fp->precision = 16; + fp->flags = AUDIO_ENCODINGFLAG_EMULATED; + break; + case 8: + strcpy(fp->name, AudioEadpcm); + fp->encoding = AUDIO_ENCODING_ADPCM; + fp->precision = 8; + fp->flags = 0; + break; + default: + err = EINVAL; + } + return (err); +} + +int +ce4231_set_params(addr, setmode, usemode, p, r) + void *addr; + int setmode, usemode; + struct audio_params *p, *r; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + int err, bits, enc; + void (*pswcode) __P((void *, u_char *, int cnt)); + void (*rswcode) __P((void *, u_char *, int cnt)); + + enc = p->encoding; + pswcode = rswcode = 0; + switch (enc) { + case AUDIO_ENCODING_SLINEAR_LE: + if (p->precision == 8) { + enc = AUDIO_ENCODING_ULINEAR_LE; + pswcode = rswcode = change_sign8; + } + break; + case AUDIO_ENCODING_ULINEAR_LE: + if (p->precision == 16) { + enc = AUDIO_ENCODING_SLINEAR_LE; + pswcode = rswcode = change_sign16; + } + break; + case AUDIO_ENCODING_ULINEAR_BE: + if (p->precision == 16) { + enc = AUDIO_ENCODING_SLINEAR_BE; + pswcode = rswcode = change_sign16; + } + break; + } + + switch (enc) { + case AUDIO_ENCODING_ULAW: + bits = FMT_ULAW >> 5; + break; + case AUDIO_ENCODING_ALAW: + bits = FMT_ALAW >> 5; + break; + case AUDIO_ENCODING_ADPCM: + bits = FMT_ADPCM >> 5; + break; + case AUDIO_ENCODING_SLINEAR_LE: + if (p->precision == 16) + bits = FMT_TWOS_COMP >> 5; + else + return (EINVAL); + break; + case AUDIO_ENCODING_SLINEAR_BE: + if (p->precision == 16) + bits = FMT_TWOS_COMP_BE >> 5; + else + return (EINVAL); + break; + case AUDIO_ENCODING_ULINEAR_LE: + if (p->precision == 8) + bits = FMT_PCM8 >> 5; + else + return (EINVAL); + break; + default: + return (EINVAL); + } + + if (p->channels != 1 && p->channels != 2) + return (EINVAL); + + err = ce4231_set_speed(sc, &p->sample_rate); + if (err) + return (err); + + p->sw_code = pswcode; + r->sw_code = rswcode; + + sc->sc_format_bits = bits; + sc->sc_channels = p->channels; + sc->sc_precision = p->precision; + sc->sc_need_commit = 1; + return (0); +} + +int +ce4231_round_blocksize(addr, blk) + void *addr; + int blk; +{ + return (blk & (-4)); +} + +int +ce4231_commit_settings(addr) + void *addr; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + int s, tries; + u_int8_t r, fs; + + if (sc->sc_need_commit == 0) + return (0); + + fs = sc->sc_speed_bits | (sc->sc_format_bits << 5); + if (sc->sc_channels == 2) + fs |= FMT_STEREO; + + if (sc->sc_last_format == fs) { + sc->sc_need_commit = 0; + return (0); + } + + s = splaudio(); + + r = ce4231_read(sc, SP_INTERFACE_CONFIG) | AUTO_CAL_ENABLE; + CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE); + CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | SP_INTERFACE_CONFIG); + CS_WRITE(sc, AD1848_IDATA, r); + + CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | SP_CLOCK_DATA_FORMAT); + CS_WRITE(sc, AD1848_IDATA, fs); + CS_READ(sc, AD1848_IDATA); + CS_READ(sc, AD1848_IDATA); + tries = CS_TIMEOUT; + for (tries = CS_TIMEOUT; + tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--) + DELAY(10); + if (tries == 0) + printf("%s: timeout committing fspb\n", sc->sc_dev.dv_xname); + + CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | CS_REC_FORMAT); + CS_WRITE(sc, AD1848_IDATA, fs); + CS_READ(sc, AD1848_IDATA); + CS_READ(sc, AD1848_IDATA); + for (tries = CS_TIMEOUT; + tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--) + DELAY(10); + if (tries == 0) + printf("%s: timeout committing cdf\n", sc->sc_dev.dv_xname); + + CS_WRITE(sc, AD1848_IADDR, 0); + for (tries = CS_TIMEOUT; + tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--) + DELAY(10); + if (tries == 0) + printf("%s: timeout waiting for !mce\n", sc->sc_dev.dv_xname); + + CS_WRITE(sc, AD1848_IADDR, SP_TEST_AND_INIT); + for (tries = CS_TIMEOUT; + tries && CS_READ(sc, AD1848_IDATA) & AUTO_CAL_IN_PROG; tries--) + DELAY(10); + if (tries == 0) + printf("%s: timeout waiting for autocalibration\n", + sc->sc_dev.dv_xname); + + splx(s); + + sc->sc_need_commit = 0; + return (0); +} + +int +ce4231_halt_output(addr) + void *addr; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + + P_WRITE(sc, EBDMA_DCSR, + P_READ(sc, EBDMA_DCSR) & ~EBDCSR_DMAEN); + ce4231_write(sc, SP_INTERFACE_CONFIG, + ce4231_read(sc, SP_INTERFACE_CONFIG) & (~PLAYBACK_ENABLE)); + sc->sc_locked = 0; + return (0); +} + +int +ce4231_halt_input(addr) + void *addr; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + + C_WRITE(sc, EBDMA_DCSR, + C_READ(sc, EBDMA_DCSR) & ~EBDCSR_DMAEN); + ce4231_write(sc, SP_INTERFACE_CONFIG, + ce4231_read(sc, SP_INTERFACE_CONFIG) & (~CAPTURE_ENABLE)); + sc->sc_locked = 0; + return (0); +} + +int +ce4231_getdev(addr, retp) + void *addr; + struct audio_device *retp; +{ + *retp = ce4231_device; + return (0); +} + +int +ce4231_set_port(addr, cp) + void *addr; + mixer_ctrl_t *cp; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + int error = EINVAL; + + DPRINTF(("ce4231_set_port: port=%d type=%d\n", cp->dev, cp->type)); + + switch (cp->dev) { + case CSAUDIO_DAC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + ce4231_write(sc, SP_LEFT_AUX1_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] & + LINE_INPUT_ATTEN_BITS); + else if (cp->un.value.num_channels == 2) { + ce4231_write(sc, SP_LEFT_AUX1_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] & + LINE_INPUT_ATTEN_BITS); + ce4231_write(sc, SP_RIGHT_AUX1_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] & + LINE_INPUT_ATTEN_BITS); + } else + break; + error = 0; + break; + case CSAUDIO_LINE_IN_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + ce4231_write(sc, CS_LEFT_LINE_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] & + AUX_INPUT_ATTEN_BITS); + else if (cp->un.value.num_channels == 2) { + ce4231_write(sc, CS_LEFT_LINE_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] & + AUX_INPUT_ATTEN_BITS); + ce4231_write(sc, CS_RIGHT_LINE_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] & + AUX_INPUT_ATTEN_BITS); + } else + break; + error = 0; + break; + case CSAUDIO_MIC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) { +#if 0 + ce4231_write(sc, CS_MONO_IO_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] & + MONO_INPUT_ATTEN_BITS); +#endif + } else + break; + error = 0; + break; + case CSAUDIO_CD_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) { + ce4231_write(sc, SP_LEFT_AUX2_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] & + LINE_INPUT_ATTEN_BITS); + } else if (cp->un.value.num_channels == 2) { + ce4231_write(sc, SP_LEFT_AUX2_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] & + LINE_INPUT_ATTEN_BITS); + ce4231_write(sc, SP_RIGHT_AUX2_CONTROL, + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] & + LINE_INPUT_ATTEN_BITS); + } else + break; + error = 0; + break; + case CSAUDIO_MONITOR_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + ce4231_write(sc, SP_DIGITAL_MIX, + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] << 2); + else + break; + error = 0; + break; + case CSAUDIO_OUTPUT_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) { + sc->sc_volume[CSPORT_SPEAKER].left = + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]; + sc->sc_volume[CSPORT_SPEAKER].right = + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]; + } + else if (cp->un.value.num_channels == 2) { + sc->sc_volume[CSPORT_SPEAKER].left = + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; + sc->sc_volume[CSPORT_SPEAKER].right = + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; + } + else + break; + + ce4231_setup_output(sc); + error = 0; + break; + case CSAUDIO_OUTPUT: + if (cp->un.ord != CSPORT_LINEOUT && + cp->un.ord != CSPORT_SPEAKER && + cp->un.ord != CSPORT_HEADPHONE) + return (EINVAL); + sc->sc_out_port = cp->un.ord; + ce4231_setup_output(sc); + error = 0; + break; + case CSAUDIO_LINE_IN_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_LINEIN] = cp->un.ord ? 1 : 0; + error = 0; + break; + case CSAUDIO_DAC_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_AUX1] = cp->un.ord ? 1 : 0; + error = 0; + break; + case CSAUDIO_CD_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_AUX2] = cp->un.ord ? 1 : 0; + error = 0; + break; + case CSAUDIO_MIC_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_MONO] = cp->un.ord ? 1 : 0; + error = 0; + break; + case CSAUDIO_MONITOR_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_MONITOR] = cp->un.ord ? 1 : 0; + error = 0; + break; + case CSAUDIO_OUTPUT_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + sc->sc_mute[CSPORT_SPEAKER] = cp->un.ord ? 1 : 0; + ce4231_setup_output(sc); + error = 0; + break; + case CSAUDIO_REC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + break; + case CSAUDIO_RECORD_SOURCE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + break; + } + + return (error); +} + +int +ce4231_get_port(addr, cp) + void *addr; + mixer_ctrl_t *cp; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + int error = EINVAL; + + DPRINTF(("ce4231_get_port: port=%d type=%d\n", cp->dev, cp->type)); + + switch (cp->dev) { + case CSAUDIO_DAC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]= + ce4231_read(sc, SP_LEFT_AUX1_CONTROL) & + LINE_INPUT_ATTEN_BITS; + else if (cp->un.value.num_channels == 2) { + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = + ce4231_read(sc, SP_LEFT_AUX1_CONTROL) & + LINE_INPUT_ATTEN_BITS; + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = + ce4231_read(sc, SP_RIGHT_AUX1_CONTROL) & + LINE_INPUT_ATTEN_BITS; + } else + break; + error = 0; + break; + case CSAUDIO_LINE_IN_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + ce4231_read(sc, CS_LEFT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS; + else if (cp->un.value.num_channels == 2) { + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = + ce4231_read(sc, CS_LEFT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS; + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = + ce4231_read(sc, CS_RIGHT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS; + } else + break; + error = 0; + break; + case CSAUDIO_MIC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) { +#if 0 + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + ce4231_read(sc, CS_MONO_IO_CONTROL) & + MONO_INPUT_ATTEN_BITS; +#endif + } else + break; + error = 0; + break; + case CSAUDIO_CD_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + ce4231_read(sc, SP_LEFT_AUX2_CONTROL) & + LINE_INPUT_ATTEN_BITS; + else if (cp->un.value.num_channels == 2) { + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = + ce4231_read(sc, SP_LEFT_AUX2_CONTROL) & + LINE_INPUT_ATTEN_BITS; + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = + ce4231_read(sc, SP_RIGHT_AUX2_CONTROL) & + LINE_INPUT_ATTEN_BITS; + } + else + break; + error = 0; + break; + case CSAUDIO_MONITOR_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels != 1) + break; + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + ce4231_read(sc, SP_DIGITAL_MIX) >> 2; + error = 0; + break; + case CSAUDIO_OUTPUT_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + sc->sc_volume[CSPORT_SPEAKER].left; + else if (cp->un.value.num_channels == 2) { + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = + sc->sc_volume[CSPORT_SPEAKER].left; + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = + sc->sc_volume[CSPORT_SPEAKER].right; + } + else + break; + error = 0; + break; + case CSAUDIO_LINE_IN_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_LINEIN] ? 1 : 0; + error = 0; + break; + case CSAUDIO_DAC_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_AUX1] ? 1 : 0; + error = 0; + break; + case CSAUDIO_CD_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_AUX2] ? 1 : 0; + error = 0; + break; + case CSAUDIO_MIC_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_MONO] ? 1 : 0; + error = 0; + break; + case CSAUDIO_MONITOR_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_MONITOR] ? 1 : 0; + error = 0; + break; + case CSAUDIO_OUTPUT_MUTE: + if (cp->type != AUDIO_MIXER_ENUM) + break; + cp->un.ord = sc->sc_mute[CSPORT_SPEAKER] ? 1 : 0; + error = 0; + break; + case CSAUDIO_REC_LVL: + if (cp->type != AUDIO_MIXER_VALUE) + break; + if (cp->un.value.num_channels == 1) { + cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = + AUDIO_MIN_GAIN; + } else if (cp->un.value.num_channels == 2) { + cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = + AUDIO_MIN_GAIN; + cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = + AUDIO_MIN_GAIN; + } else + break; + error = 0; + break; + case CSAUDIO_RECORD_SOURCE: + if (cp->type != AUDIO_MIXER_ENUM) break; + cp->un.ord = MIC_IN_PORT; + error = 0; + break; + case CSAUDIO_OUTPUT: + if (cp->type != AUDIO_MIXER_ENUM) break; + cp->un.ord = sc->sc_out_port; + error = 0; + break; + default: + printf("Invalid kind!\n"); + } + return (error); +} + +int +ce4231_query_devinfo(addr, dip) + void *addr; + mixer_devinfo_t *dip; +{ + int err = 0; + + switch (dip->index) { + case CSAUDIO_MIC_LVL: /* mono/microphone mixer */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_MIC_MUTE; + strcpy(dip->label.name, AudioNmicrophone); + dip->un.v.num_channels = 1; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_DAC_LVL: /* dacout */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_DAC_MUTE; + strcpy(dip->label.name, AudioNdac); + dip->un.v.num_channels = 2; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_LINE_IN_LVL: /* line */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_LINE_IN_MUTE; + strcpy(dip->label.name, AudioNline); + dip->un.v.num_channels = 2; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_CD_LVL: /* cd */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_CD_MUTE; + strcpy(dip->label.name, AudioNcd); + dip->un.v.num_channels = 2; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_MONITOR_LVL: /* monitor level */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_MONITOR_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_MONITOR_MUTE; + strcpy(dip->label.name, AudioNmonitor); + dip->un.v.num_channels = 1; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_OUTPUT_LVL: + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_OUTPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_OUTPUT_MUTE; + strcpy(dip->label.name, AudioNoutput); + dip->un.v.num_channels = 2; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_LINE_IN_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = CSAUDIO_LINE_IN_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + case CSAUDIO_DAC_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = CSAUDIO_DAC_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + case CSAUDIO_CD_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = CSAUDIO_CD_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + case CSAUDIO_MIC_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = CSAUDIO_MIC_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + case CSAUDIO_MONITOR_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_OUTPUT_CLASS; + dip->prev = CSAUDIO_MONITOR_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + case CSAUDIO_OUTPUT_MUTE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_OUTPUT_CLASS; + dip->prev = CSAUDIO_OUTPUT_LVL; + dip->next = AUDIO_MIXER_LAST; + goto mute; + + mute: + strcpy(dip->label.name, AudioNmute); + dip->un.e.num_mem = 2; + strcpy(dip->un.e.member[0].label.name, AudioNon); + dip->un.e.member[0].ord = 0; + strcpy(dip->un.e.member[1].label.name, AudioNoff); + dip->un.e.member[1].ord = 1; + break; + case CSAUDIO_REC_LVL: /* record level */ + dip->type = AUDIO_MIXER_VALUE; + dip->mixer_class = CSAUDIO_RECORD_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = CSAUDIO_RECORD_SOURCE; + strcpy(dip->label.name, AudioNrecord); + dip->un.v.num_channels = 2; + strcpy(dip->un.v.units.name, AudioNvolume); + break; + case CSAUDIO_RECORD_SOURCE: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_RECORD_CLASS; + dip->prev = CSAUDIO_REC_LVL; + dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioNsource); + dip->un.e.num_mem = 3; + strcpy(dip->un.e.member[0].label.name, AudioNcd); + dip->un.e.member[0].ord = DAC_IN_PORT; + strcpy(dip->un.e.member[1].label.name, AudioNmicrophone); + dip->un.e.member[1].ord = MIC_IN_PORT; + strcpy(dip->un.e.member[2].label.name, AudioNdac); + dip->un.e.member[2].ord = AUX1_IN_PORT; + strcpy(dip->un.e.member[3].label.name, AudioNline); + dip->un.e.member[3].ord = LINE_IN_PORT; + break; + case CSAUDIO_OUTPUT: + dip->type = AUDIO_MIXER_ENUM; + dip->mixer_class = CSAUDIO_MONITOR_CLASS; + dip->prev = dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioNoutput); + dip->un.e.num_mem = 3; + strcpy(dip->un.e.member[0].label.name, AudioNspeaker); + dip->un.e.member[0].ord = CSPORT_SPEAKER; + strcpy(dip->un.e.member[1].label.name, AudioNline); + dip->un.e.member[1].ord = CSPORT_LINEOUT; + strcpy(dip->un.e.member[2].label.name, AudioNheadphone); + dip->un.e.member[2].ord = CSPORT_HEADPHONE; + break; + case CSAUDIO_INPUT_CLASS: /* input class descriptor */ + dip->type = AUDIO_MIXER_CLASS; + dip->mixer_class = CSAUDIO_INPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioCinputs); + break; + case CSAUDIO_OUTPUT_CLASS: /* output class descriptor */ + dip->type = AUDIO_MIXER_CLASS; + dip->mixer_class = CSAUDIO_OUTPUT_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioCoutputs); + break; + case CSAUDIO_MONITOR_CLASS: /* monitor class descriptor */ + dip->type = AUDIO_MIXER_CLASS; + dip->mixer_class = CSAUDIO_MONITOR_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioCmonitor); + break; + case CSAUDIO_RECORD_CLASS: /* record class descriptor */ + dip->type = AUDIO_MIXER_CLASS; + dip->mixer_class = CSAUDIO_RECORD_CLASS; + dip->prev = AUDIO_MIXER_LAST; + dip->next = AUDIO_MIXER_LAST; + strcpy(dip->label.name, AudioCrecord); + break; + default: + err = ENXIO; + } + + return (err); +} + +u_long +ce4231_round_buffersize(addr, size) + void *addr; + u_long size; +{ + return (size); +} + +int +ce4231_get_props(addr) + void *addr; +{ + return (AUDIO_PROP_FULLDUPLEX); +} + +/* + * Hardware interrupt handler + */ +int +ce4231_cintr(v) + void *v; +{ + return (0); +} + +int +ce4231_pintr(v) + void *v; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)v; + u_int32_t csr; + u_int8_t reg, status; + struct cs_dma *p; + int r = 0; + + csr = P_READ(sc, EBDMA_DCSR); + status = CS_READ(sc, AD1848_STATUS); + if (status & (INTERRUPT_STATUS | SAMPLE_ERROR)) { + reg = ce4231_read(sc, CS_IRQ_STATUS); + if (reg & CS_AFS_PI) { + ce4231_write(sc, SP_LOWER_BASE_COUNT, 0xff); + ce4231_write(sc, SP_UPPER_BASE_COUNT, 0xff); + } + CS_WRITE(sc, AD1848_STATUS, 0); + } + + P_WRITE(sc, EBDMA_DCSR, csr); + + if (csr & EBDCSR_INT) + r = 1; + + if ((csr & EBDCSR_TC) || ((csr & EBDCSR_A_LOADED) == 0)) { + u_long nextaddr, togo; + + p = sc->sc_nowplaying; + togo = sc->sc_playsegsz - sc->sc_playcnt; + if (togo == 0) { + nextaddr = (u_int32_t)p->dmamap->dm_segs[0].ds_addr; + sc->sc_playcnt = togo = sc->sc_blksz; + } else { + nextaddr = P_READ(sc, EBDMA_DADDR) + sc->sc_blksz; + if (togo > sc->sc_blksz) + togo = sc->sc_blksz; + sc->sc_playcnt += togo; + } + + P_WRITE(sc, EBDMA_DCNT, togo); + P_WRITE(sc, EBDMA_DADDR, nextaddr); + + if (sc->sc_pintr != NULL) + (*sc->sc_pintr)(sc->sc_parg); + r = 1; + } + + return (r); +} + +void * +ce4231_alloc(addr, size, pool, flags) + void *addr; + u_long size; + int pool; + int flags; +{ + struct ce4231_softc *sc = (struct ce4231_softc *)addr; + bus_dma_tag_t dmat = sc->sc_dmatag; + struct cs_dma *p; + + p = (struct cs_dma *)malloc(sizeof(struct cs_dma), pool, flags); + if (p == NULL) + goto fail; + + if (bus_dmamap_create(dmat, size, 1, size, 0, + BUS_DMA_NOWAIT, &p->dmamap) != 0) + goto fail; + + p->size = size; + + if (bus_dmamem_alloc(dmat, size, 64*1024, 0, p->segs, + sizeof(p->segs)/sizeof(p->segs[0]), &p->nsegs, + BUS_DMA_NOWAIT) != 0) + goto fail1; + + if (bus_dmamem_map(dmat, p->segs, p->nsegs, p->size, + &p->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT) != 0) + goto fail2; + + if (bus_dmamap_load(dmat, p->dmamap, p->addr, size, NULL, + BUS_DMA_NOWAIT) != 0) + goto fail3; + + p->next = sc->sc_dmas; + sc->sc_dmas = p; + return (p->addr); + +fail3: + bus_dmamem_unmap(dmat, p->addr, p->size); +fail2: + bus_dmamem_free(dmat, p->segs, p->nsegs); +fail1: + bus_dmamap_destroy(dmat, p->dmamap); +fail: + return (NULL); +} + +void +ce4231_free(addr, ptr, pool) + void *addr; + void *ptr; + int pool; +{ + struct ce4231_softc *sc = addr; + bus_dma_tag_t dmat = sc->sc_dmatag; + struct cs_dma *p, **pp; + + for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) { + if (p->addr != ptr) + continue; + bus_dmamap_unload(dmat, p->dmamap); + bus_dmamem_unmap(dmat, p->addr, p->size); + bus_dmamem_free(dmat, p->segs, p->nsegs); + bus_dmamap_destroy(dmat, p->dmamap); + *pp = p->next; + free(p, pool); + return; + } + printf("%s: attempt to free rogue pointer\n", sc->sc_dev.dv_xname); +} + +int +ce4231_trigger_output(addr, start, end, blksize, intr, arg, param) + void *addr, *start, *end; + int blksize; + void (*intr) __P((void *)); + void *arg; + struct audio_params *param; +{ + struct ce4231_softc *sc = addr; + struct cs_dma *p; + u_int32_t csr; + vaddr_t n; + + if (sc->sc_locked != 0) { + printf("%s: trigger_output: already running\n", + sc->sc_dev.dv_xname); + return (EINVAL); + } + + sc->sc_locked = 1; + sc->sc_pintr = intr; + sc->sc_parg = arg; + + for (p = sc->sc_dmas; p->addr != start; p = p->next) + /*EMPTY*/; + if (p == NULL) { + printf("%s: trigger_output: bad addr: %x\n", + sc->sc_dev.dv_xname, start); + return (EINVAL); + } + + n = (char *)end - (char *)start; + + /* + * Do only `blksize' at a time, so audio_pint() is kept + * synchronous with us... + */ + sc->sc_blksz = blksize; + sc->sc_nowplaying = p; + sc->sc_playsegsz = n; + + if (n > sc->sc_blksz) + n = sc->sc_blksz; + + sc->sc_playcnt = n; + + csr = P_READ(sc, EBDMA_DCSR); + if (csr & EBDCSR_DMAEN) { + P_WRITE(sc, EBDMA_DCNT, (u_long)n); + P_WRITE(sc, EBDMA_DADDR, + (u_long)p->dmamap->dm_segs[0].ds_addr); + } else { + P_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET); + P_WRITE(sc, EBDMA_DCSR, sc->sc_burst); + + P_WRITE(sc, EBDMA_DCNT, (u_long)n); + P_WRITE(sc, EBDMA_DADDR, + (u_long)p->dmamap->dm_segs[0].ds_addr); + + P_WRITE(sc, EBDMA_DCSR, sc->sc_burst | EBDCSR_DMAEN | + EBDCSR_INTEN | EBDCSR_CNTEN | EBDCSR_NEXTEN); + + ce4231_write(sc, SP_LOWER_BASE_COUNT, 0xff); + ce4231_write(sc, SP_UPPER_BASE_COUNT, 0xff); + ce4231_write(sc, SP_INTERFACE_CONFIG, + ce4231_read(sc, SP_INTERFACE_CONFIG) | PLAYBACK_ENABLE); + } + + return (0); +} + +int +ce4231_trigger_input(addr, start, end, blksize, intr, arg, param) + void *addr, *start, *end; + int blksize; + void (*intr) __P((void *)); + void *arg; + struct audio_params *param; +{ + return (ENXIO); +} + +#endif /* NAUDIO > 0 */ diff --git a/sys/arch/sparc64/dev/ce4231var.h b/sys/arch/sparc64/dev/ce4231var.h new file mode 100644 index 00000000000..7bb2bf825e0 --- /dev/null +++ b/sys/arch/sparc64/dev/ce4231var.h @@ -0,0 +1,90 @@ +/* $OpenBSD: ce4231var.h,v 1.1 2001/10/01 18:10:32 jason Exp $ */ + +/* + * Copyright (c) 1999 Jason L. Wright (jason@thought.net) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Jason L. Wright + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR 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. + */ + +/* + * Driver for CS4231/EBDMA based audio found in some sun4u systems + */ + +/* + * List of device memory allocations (see ce4231_malloc/ce4231_free). + */ +struct cs_dma { + struct cs_dma * next; + caddr_t addr; + bus_dmamap_t dmamap; + bus_dma_segment_t segs[1]; + int nsegs; + size_t size; +}; + +struct cs_volume { + u_int8_t left; + u_int8_t right; +}; + +struct ce4231_softc { + struct device sc_dev; /* base device */ + struct sbusdev sc_sd; /* sbus device */ + struct intrhand sc_ih; /* interrupt vectoring */ + bus_dma_tag_t sc_dmatag; + bus_space_tag_t sc_bustag; /* CS4231/DMA register tag */ + bus_space_handle_t sc_cshandle; /* CS4231 handle */ + bus_space_handle_t sc_cdmahandle; /* capture DMA handle */ + bus_space_handle_t sc_pdmahandle; /* playback DMA handle */ + bus_space_handle_t sc_auxhandle; /* AUX handle */ + struct evcnt sc_intrcnt; /* statistics */ + int sc_open; /* already open? */ + int sc_locked; /* locked? */ + + void (*sc_rintr)(void*); /* input completion intr handler */ + void * sc_rarg; /* arg for sc_rintr() */ + void (*sc_pintr)(void*); /* output completion intr handler */ + void * sc_parg; /* arg for sc_pintr() */ + + char sc_mute[9]; /* which devs are muted */ + u_int8_t sc_out_port; /* output port */ + struct cs_volume sc_volume[9]; /* software volume */ + + int sc_format_bits; + int sc_speed_bits; + int sc_precision; + int sc_need_commit; + int sc_channels; + u_int sc_last_format; + u_int32_t sc_blksz; + u_int32_t sc_playcnt; + u_int32_t sc_playsegsz; + u_int32_t sc_burst; + struct cs_dma *sc_dmas; /* dma list */ + struct cs_dma *sc_nowplaying; +}; |