From b7da7b3e2a22ad30c7ec0d0ab03b49c19e4b3db4 Mon Sep 17 00:00:00 2001 From: John-Mark Gurney Date: Sun, 14 Sep 1997 21:42:12 +0000 Subject: [PATCH] Import of Luigi Rizzo's sound code. For more information about the driver check out the README that is included. Submitted by: Luigi Rizzo --- sys/dev/pcm/isa/mss.c | 1509 ++++++++++++++++++++++++++++++++ sys/dev/pcm/isa/mss.h | 250 ++++++ sys/dev/pcm/isa/sb.c | 1080 +++++++++++++++++++++++ sys/dev/pcm/isa/sb.h | 387 ++++++++ sys/dev/sound/isa/mss.c | 1509 ++++++++++++++++++++++++++++++++ sys/dev/sound/isa/mss.h | 250 ++++++ sys/dev/sound/isa/sb.c | 1080 +++++++++++++++++++++++ sys/dev/sound/isa/sb.h | 387 ++++++++ sys/dev/sound/isa/sb16.c | 1080 +++++++++++++++++++++++ sys/dev/sound/isa/sb8.c | 1080 +++++++++++++++++++++++ sys/i386/isa/snd/README | 78 ++ sys/i386/isa/snd/ad1848.c | 1509 ++++++++++++++++++++++++++++++++ sys/i386/isa/snd/clones.c | 262 ++++++ sys/i386/isa/snd/dmabuf.c | 864 ++++++++++++++++++ sys/i386/isa/snd/dmabuf_auto.c | 802 +++++++++++++++++ sys/i386/isa/snd/mss.h | 250 ++++++ sys/i386/isa/snd/sb_dsp.c | 1080 +++++++++++++++++++++++ sys/i386/isa/snd/sbcard.h | 387 ++++++++ sys/i386/isa/snd/sound.c | 1254 ++++++++++++++++++++++++++ sys/i386/isa/snd/sound.h | 492 +++++++++++ sys/i386/isa/snd/soundcard.h | 1297 +++++++++++++++++++++++++++ sys/i386/isa/snd/ulaw.h | 93 ++ 22 files changed, 16980 insertions(+) create mode 100644 sys/dev/pcm/isa/mss.c create mode 100644 sys/dev/pcm/isa/mss.h create mode 100644 sys/dev/pcm/isa/sb.c create mode 100644 sys/dev/pcm/isa/sb.h create mode 100644 sys/dev/sound/isa/mss.c create mode 100644 sys/dev/sound/isa/mss.h create mode 100644 sys/dev/sound/isa/sb.c create mode 100644 sys/dev/sound/isa/sb.h create mode 100644 sys/dev/sound/isa/sb16.c create mode 100644 sys/dev/sound/isa/sb8.c create mode 100644 sys/i386/isa/snd/README create mode 100644 sys/i386/isa/snd/ad1848.c create mode 100644 sys/i386/isa/snd/clones.c create mode 100644 sys/i386/isa/snd/dmabuf.c create mode 100644 sys/i386/isa/snd/dmabuf_auto.c create mode 100644 sys/i386/isa/snd/mss.h create mode 100644 sys/i386/isa/snd/sb_dsp.c create mode 100644 sys/i386/isa/snd/sbcard.h create mode 100644 sys/i386/isa/snd/sound.c create mode 100644 sys/i386/isa/snd/sound.h create mode 100644 sys/i386/isa/snd/soundcard.h create mode 100644 sys/i386/isa/snd/ulaw.h diff --git a/sys/dev/pcm/isa/mss.c b/sys/dev/pcm/isa/mss.c new file mode 100644 index 000000000000..97b328d098fe --- /dev/null +++ b/sys/dev/pcm/isa/mss.c @@ -0,0 +1,1509 @@ +/* + * sound/ad1848.c + * + * Modified by Luigi Rizzo (luigi@iet.unipi.it) + * + * Driver for Microsoft Sound System/Windows Sound System (mss) + * -compatible boards. This includes: + * + * AD1848, CS4248 + * + * CS4231, used in the GUS MAX and some other cards; + * AD1845, CS4231A (CS4231-like) + * CS4232 (CS4231+SB and MPU, PnP) + * CS4236 (upgrade of the CS4232, has a better mixer) + * OPTi931 (WSS compatible, full duplex, some differences from CS42xx) + * + * Copyright Luigi Rizzo, 1997 + * Copyright by Hannu Savolainen 1994, 1995 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * + * Full data sheets in PDF format for the MSS-compatible chips + * are available at + * + * http://www.crystal.com/ for the CS42XX series, or + * http://www.opti.com/ for the OPTi931 + * + * The OPTi931 appears to be quite buggy. + */ + +#include +#if NPCM > 0 + +/* + * board-specific include files + */ + +#include + +/* + * prototypes for procedures exported in the device descriptor + */ + +static int mss_probe(struct isa_device *dev); +static int mss_attach(struct isa_device *dev); + +static d_open_t mss_open; +static d_close_t mss_close; +static d_ioctl_t mss_ioctl; +static irq_proc_t mss_intr; +static irq_proc_t opti931_intr; +static snd_callback_t mss_callback; + +/* + * prototypes for local functions + */ + +static void mss_reinit(snddev_info *d); +static int AD_WAIT_INIT(snddev_info *d, int x); +static int mss_mixer_set(snddev_info *d, int dev, int value); +static int mss_set_recsrc(snddev_info *d, int mask); +static void ad1848_mixer_reset(snddev_info *d); + +static void opti_write(int io_base, u_char reg, u_char data); +static u_char opti_read(int io_base, u_char reg); +static void ad_write(snddev_info *d, int reg, u_char data); +static void ad_write_cnt(snddev_info *d, int reg, u_short data); +static int ad_read(snddev_info *d, int reg); + +/* + * device descriptors for the boards supported by this module. + */ +snddev_info mss_op_desc = { + "mss", + + SNDCARD_MSS, + mss_probe, + mss_attach, + + mss_open, + mss_close, + NULL /* mss_read */, + NULL /* mss_write */, + mss_ioctl, + sndselect /* mss_select */, + + mss_intr, + mss_callback , + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | + AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW, /* audio formats */ + /* + * the enhanced boards also have AFMT_IMA_ADPCM | AFMT_S16_BE + */ +} ; + +/* + * this is the probe routine. Note, it is not necessary to + * go through this for PnP devices, since they are already + * indentified precisely using their PnP id. + * + * The base address supplied in the device refers to the old MSS + * specs where the four 4 registers in io space contain configuration + * information. Some boards (as an example, early MSS boards) + * has such a block of registers, whereas others (generally CS42xx) + * do not. In order to distinguish between the two and do not have + * to supply two separate probe routines, the flags entry in isa_device + * has a bit to mark this. + * + */ + +static int +mss_probe(struct isa_device *dev) +{ + u_char tmp; + int irq = ffs(dev->id_irq) - 1; + + if (dev->id_iobase == -1) { + dev->id_iobase = 0x530; + printf("mss_probe: no address supplied, try default 0x%x\n", + dev->id_iobase); + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if ( !(dev->id_flags & DV_F_TRUE_MSS) ) /* Has no IRQ/DMA registers */ + goto mss_probe_end; + + /* + * Check if the IO port returns valid signature. The original MS + * Sound system returns 0x04 while some cards + * (AudioTriX Pro for example) return 0x00 or 0x0f. + */ + + tmp = inb(dev->id_iobase + 3); + if (tmp == 0xff) { /* Bus float */ + DDB(printf("I/O address inactive (%x), try pseudo_mss\n", tmp)); + dev->id_flags &= ~DV_F_TRUE_MSS ; + goto mss_probe_end; + } + tmp &= 0x3f ; + if (tmp != 0x04 && tmp != 0x0f && tmp != 0x00) { + DDB(printf("No MSS signature detected on port 0x%x (0x%x)\n", + dev->id_iobase, inb(dev->id_iobase + 3))); + return 0; + } + if (irq > 11) { + printf("MSS: Bad IRQ %d\n", irq); + return 0; + } + if (dev->id_drq != 0 && dev->id_drq != 1 && dev->id_drq != 3) { + printf("MSS: Bad DMA %d\n", dev->id_drq); + return 0; + } + if (inb(dev->id_iobase + 3) & 0x80) { + /* 8-bit board: only drq1/3 and irq7/9 */ + if (dev->id_drq == 0) { + printf("MSS: Can't use DMA0 with a 8 bit card/slot\n"); + return 0; + } + if (irq != 7 && irq != 9) { + printf("MSS: Can't use IRQ%d with a 8 bit card/slot\n", irq); + return 0; + } + } +mss_probe_end: + return mss_detect(dev) ? 8 : 0 ; /* mss uses 8 regs */ +} + +/* + * the address passed as io_base for mss_attach is also the old + * MSS base address (e.g. 0x530). The codec is four locations ahead. + * Note that the attach routine for PnP devices might support + * device-specific initializations. + */ + +static int +mss_attach(struct isa_device *dev) +{ + snddev_info *d = &(pcm_info[dev->id_unit]); + + printf("mss_attach <%s>%d at 0x%x irq %d dma %d:%d flags 0x%x\n", + d->name, dev->id_unit, + d->io_base, d->irq, d->dma1, d->dma2, dev->id_flags); + + if ( dev->id_flags & DV_F_TRUE_MSS ) { + /* has IRQ/DMA registers, set IRQ and DMA addr */ + static char interrupt_bits[12] = { + -1, -1, -1, -1, -1, 0x28, -1, 0x08, -1, 0x10, 0x18, 0x20 + }; + static char dma_bits[4] = { 1, 2, 0, 3 }; + char bits ; + + if (d->irq == -1 || (bits = interrupt_bits[d->irq]) == -1) { + dev->id_irq = 0 ; /* makk invalid irq */ + return 0 ; + } + + outb(dev->id_iobase, bits | 0x40); /* config port */ + if ((inb(dev->id_iobase + 3) & 0x40) == 0) /* version port */ + printf("[IRQ Conflict?]"); + + /* Write IRQ+DMA setup */ + if (d->dma1 == d->dma2) /* single chan dma */ + outb(dev->id_iobase, bits | dma_bits[d->dma1]); + else { + if (d->dma1 == 0 && d->dma2 == 1) + bits |= 5 ; + else if (d->dma1 == 1 && d->dma2 == 0) + bits |= 6 ; + else if (d->dma1 == 3 && d->dma2 == 0) + bits |= 7 ; + else { + printf("invalid dual dma config %d:%d\n", + d->dma1, d->dma2); + dev->id_irq = 0 ; + return 0 ; + } + outb(dev->id_iobase, bits ); + } + } + mss_reinit(d); + ad1848_mixer_reset(d); + return 0; +} + +static int +mss_open(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf ; + d = &pcm_info[unit] ; + + s = spltty(); + /* + * This was meant to support up to 2 open descriptors for the + * some device, and check proper device usage on open. + * Unfortunately, the kernel will trap all close() calls but + * the last one, with the consequence that we cannot really + * keep track of which channels are busy. + * So, the correct tests cannot be done :( and we must rely + * on the locks on concurrent operations of the same type and + * on some approximate tests... + */ + + if (dev == SND_DEV_AUDIO) + d->flags |= SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags |= SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags |= SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY) ) { + /* + * device was idle. Do the necessary initialization, + * but no need keep interrupts blocked since this device + * will not get them + */ + + splx(s); + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + d->flags |= SND_F_BUSY ; + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + switch (dev) { + default : + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + case SND_DEV_DSP16 : + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + } + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + ask_init(d); + } + splx(s); + return 0 ; +} + +static int +mss_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf; + d = &pcm_info[unit] ; + + /* + * We will only get a single close call when the last reference + * to the device is gone. But we must handle ourselves references + * through different devices. + */ + + s = spltty(); + + if (dev == SND_DEV_AUDIO) + d->flags &= ~SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags &= ~SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags &= ~SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY_ANY) ) { /* last one ... */ + d->flags |= SND_F_CLOSING ; + splx(s); /* is this ok here ? */ + snd_flush(d); + outb(io_Status(d), 0); /* Clear interrupt status */ + d->flags = 0 ; + } + splx(s); + return 0 ; +} + +static int +mss_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + snddev_info *d; + int unit; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) { + cmd &= 0xff ; + if (cmd == SOUND_MIXER_RECSRC) + return mss_set_recsrc(d, *(int *)arg) ; + else + return mss_mixer_set(d, cmd, *(int *)arg) ; + } + + return ENOSYS ; /* fallback to the default ioctl handler */ +} + + +/* + * the callback routine to handle all dma ops etc. + */ + +static int +mss_callback(snddev_info *d, int reason) +{ + u_long s; + u_char m; + int retry, wr, cnt; + + DEB(printf("-- mss_callback reason 0x%03x\n", reason)); + wr = reason & SND_CB_WR ; + reason &= SND_CB_REASON_MASK ; + switch (reason) { + case SND_CB_INIT : /* called with int enabled and no pending I/O */ + /* + * perform all necessary initializations for i/o + */ + d->rec_fmt = d->play_fmt ; /* no split format on the WSS */ + snd_set_blocksize(d); + mss_reinit(d); + return 1 ; + break ; + + case SND_CB_START : + /* fallthrough */ + case SND_CB_RESTART : + s = spltty(); + cnt = wr ? d->dbuf_out.dl0 : d->dbuf_in.dl0 ; + if (d->play_fmt == AFMT_S16_LE) + cnt /= 2; + if (d->flags & SND_F_STEREO) + cnt /= 2; + cnt-- ; + + DEB(printf("-- (re)start cnt %d\n", cnt)); + m = ad_read(d,9) ; + DDB( if (m & 4) printf("OUCH! reg 9 0x%02x\n", m); ); + m |= wr ? I9_PEN : I9_CEN ; /* enable DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry; retry--) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to set bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, cnt); + else + ad_write_cnt(d, 30, cnt); + + splx(s); + break ; + case SND_CB_STOP : + case SND_CB_ABORT : /* XXX check this... */ + s = spltty(); + m = ad_read(d,9) ; + m &= wr ? ~I9_PEN : ~I9_CEN ; /* Stop DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry ; retry-- ) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to clear bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + + /* disable DMA by clearing count registers. */ + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, 0); + else + ad_write_cnt(d, 30, 0); + splx(s); + break; + } + return 0 ; +} + +/* + * main irq handler for the CS423x. The OPTi931 code is + * a separate one. + */ + +static void +mss_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char i11, c; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + + i11 = ad_read(d, 11); + reason = inb(io_Status(d)); + + if ( ! (reason & 1) ) /* no int, maybe a shared line ? */ + return; + /* get exact reason */ + c = (d->dma1 == d->dma2) ? 0x10 : ad_read(d, 24); + if ( (d->flags & SND_F_WR_DMA) && (c & 0x10) ) + dsp_wrintr(d); + c = (d->dma1 == d->dma2) ? 0x20 : ad_read(d, 24); + if ( (d->flags & SND_F_RD_DMA) && (c & 0x20) ) + dsp_rdintr(d); + /* XXX check this on the 4236... */ + if (d->dma1 == d->dma2) + outb(io_Status(d), 0); /* Clear interrupt status */ + else + ad_write(d, 24, ~c); /* ack selectively */ +} + +/* + * the opti931 seems to miss interrupts when working in full + * duplex. god know why... + */ +static void +opti931_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char masked=0, i11, mc11, c=0; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + int loops = 10; + int w_miss=0, r_miss=0; + static int misses=0; /* XXX kludge */ + +#if 0 + reason = inb(io_Status(d)); + if ( ! (reason & 1) ) {/* no int, maybe a shared line ? */ + printf("opti931_intr: flag 0, mcir11 0x%02x\n", ad_read(d,11)); + return; + } +#endif + i11 = ad_read(d, 11); /* XXX what's for ? */ +again: + + c=mc11 = (d->dma1 == d->dma2) ? 0xc : opti_read(d->conf_base, 11); + mc11 &= 0x0c ; + if (c & 0x10) { + printf("Warning CD interrupt\n"); + mc11 |= 0x10 ; + } + if (c & 0x20) { + printf("Warning MPU interrupt\n"); + mc11 |= 0x20 ; + } + if (mc11 & masked) + printf("irq reset failed, mc11 0x%02x, masked 0x%02x\n", mc11, masked); + masked |= mc11 ; + if ( mc11 == 0 ) { /* perhaps can return ... */ + reason = inb(io_Status(d)); + if (reason & 1) { + printf("one more try...\n"); + goto again; + } + if (w_miss || r_miss ) { + misses++; + if ( (misses & 0xff) == 1 ) + printf("opti931: %d missed irq (now %s%s)\n", + misses, w_miss?"play ":"", + r_miss?"capture ":""); + } + if (loops==10) + printf("ouch, intr but nothing in mcir11 0x%02x\n", mc11); + if (w_miss) mc11 |= 4 ; + if (r_miss) mc11 |= 8 ; + if (mc11==0) + return; + } + + if ( (d->flags & SND_F_RD_DMA) && (mc11 & 8) ) { + dsp_rdintr(d); + r_miss = 0 ; + } + else if (isa_dmastatus1(d->dma2) == 0 && (d->flags & SND_F_RD_DMA) ) + r_miss = 1 ; + + if ( (d->flags & SND_F_WR_DMA) && (mc11 & 4) ) { + if (isa_dmastatus1(d->dma1) != 0) + printf("opti931_intr: wr dma %d\n", + isa_dmastatus1(d->dma1)); + dsp_wrintr(d); + w_miss = 0 ; + } + else if (isa_dmastatus1(d->dma1) == 0 && (d->flags & SND_F_WR_DMA) ) + w_miss = 1 ; + + opti_write(d->conf_base, 11, ~mc11); /* ack */ + if (--loops) goto again; + printf("xxx too many loops\n"); +} + +/* + * Second part of the file: functions local to this module. + * in this section a few routines to access MSS registers + * + */ + +static void +opti_write(int io_base, u_char reg, u_char value) +{ + outb(io_base, reg); + outb(io_base+1, value); +} + +static u_char +opti_read(int io_base, u_char reg) +{ + outb(io_base, reg); + return inb(io_base+1); +} +/* + * AD_WAIT_INIT waits if we are initializing the board and + * we cannot modify its settings + */ +static int +AD_WAIT_INIT(snddev_info *d, int x) +{ + int n = 0; /* to shut up the compiler... */ + for (; x-- ; ) + if ( (n=inb(io_Index_Addr(d))) & IA_BUSY) + DELAY(10); + else + return n ; + printf("AD_WAIT_INIT FAILED 0x%02x\n", n); + return n ; +} + +static int +ad_read(snddev_info *d, int reg) +{ + u_long flags; + int x; + + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + x = inb(io_Indexed_Data(d)); + splx(flags); + return x; +} + +static void +ad_write(snddev_info *d, int reg, u_char data) +{ + u_long flags; + + int x ; + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + outb(io_Indexed_Data(d), data); + splx(flags); +} + +static void +ad_write_cnt(snddev_info *d, int reg, u_short cnt) +{ + ad_write(d, reg+1, cnt & 0xff ); + ad_write(d, reg, cnt >> 8 ); /* upper base must be last */ +} + +static void +wait_for_calibration(snddev_info *d) +{ + int n, t; + + /* + * Wait until the auto calibration process has finished. + * + * 1) Wait until the chip becomes ready (reads don't return 0x80). + * 2) Wait until the ACI bit of I11 gets on + * 3) Wait until the ACI bit of I11 gets off + */ + + n = AD_WAIT_INIT(d, 1000); + if (n & IA_BUSY) + printf("mss: Auto calibration timed out(1).\n"); + + for (t = 100 ; t>0 && (ad_read(d, 11) & 0x20) == 0 ; t--) + DELAY(100); + for (t = 100 ; t>0 && ad_read(d, 11) & 0x20 ; t--) + DELAY(100); +} + +#if 0 /* unused right now... */ +static void +ad_mute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) | I6_MUTE); + ad_write(d, 7, ad_read(d,7) | I6_MUTE); +} + +static void +ad_unmute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); +} +#endif + +static void +ad_enter_MCE(snddev_info *d) +{ + int prev; + + d->bd_flags |= BD_F_MCE_BIT; + AD_WAIT_INIT(d, 100); + prev = inb(io_Index_Addr(d)); + outb(io_Index_Addr(d), prev | IA_MCE | IA_TRD ) ; +} + +static void +ad_leave_MCE(snddev_info *d) +{ + u_long flags; + u_char prev; + + if ( (d->bd_flags & BD_F_MCE_BIT) == 0 ) { + printf("--- hey, leave_MCE: MCE bit was not set!\n"); + return; + } + + AD_WAIT_INIT(d, 1000); + + flags = spltty(); + d->bd_flags &= ~BD_F_MCE_BIT; + + prev = inb(io_Index_Addr(d)); + + outb(io_Index_Addr(d), (prev & ~IA_MCE) | IA_TRD); /* Clear the MCE bit */ + wait_for_calibration(d); + splx(flags); +} + +/* + * only one source can be set... + * + * fixed -- lr 970725 + */ +static int +mss_set_recsrc(snddev_info *d, int mask) +{ + u_char recdev; + + mask &= d->mix_rec_devs; + switch (mask) { + case SOUND_MASK_LINE: + case SOUND_MASK_LINE3: + recdev = 0; + break; + + case SOUND_MASK_CD: + case SOUND_MASK_LINE1: + recdev = 0x40; + break; + + case SOUND_MASK_IMIX: + recdev = 0xc0; + break; + + case SOUND_MASK_MIC: + default: + mask = SOUND_MASK_MIC; + recdev = 0x80; + } + + ad_write(d, 0, (ad_read(d, 0) & 0x3f) | recdev); + ad_write(d, 1, (ad_read(d, 1) & 0x3f) | recdev); + + d->mix_recsrc = mask; + return 0; +} + +/* + * mixer conversion table: from 0..100 scale to codec values + * + * I don't understand what's this for... maybe achieve a log-scale + * volume control ? + */ + +static char mix_cvt[101] = { + 0, 0, 3, 7,10,13,16,19,21,23,26,28,30,32,34,35,37,39,40,42, + 43,45,46,47,49,50,51,52,53,55,56,57,58,59,60,61,62,63,64,65, + 65,66,67,68,69,70,70,71,72,73,73,74,75,75,76,77,77,78,79,79, + 80,81,81,82,82,83,84,84,85,85,86,86,87,87,88,88,89,89,90,90, + 91,91,92,92,93,93,94,94,95,95,96,96,96,97,97,98,98,98,99,99, + 100 +}; + +/* + * there are differences in the mixer depending on the actual sound + * card. + */ +static int +mss_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + + int regoffs; + mixer_tab *mix_d = &mix_devices; + + u_char old, val; + + if (dev > 31) + return EINVAL; + + if (!(d->mix_devs & (1 << dev))) + return EINVAL; + + if (d->bd_id == MD_OPTI931) + mix_d = &(opti931_devices); + + if ((*mix_d)[dev][LEFT_CHN].nbits == 0) { + DDB(printf("nbits = 0 for dev %d\n", dev) ); + return EINVAL; + } + + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + + if ( (*mix_d)[dev][RIGHT_CHN].nbits == 0) /* Mono control */ + right = left; + + d->mix_levels[dev] = left | (right << 8); + + /* Scale volumes */ + left = mix_cvt[left]; + right = mix_cvt[right]; + + /* + * Set the left channel + */ + + regoffs = (*mix_d)[dev][LEFT_CHN].regno; + old = val = ad_read(d, regoffs); + if (regoffs != 0) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, LEFT_CHN, left); + ad_write(d, regoffs, val); + DEB(printf("dev %d reg %d old 0x%02x new 0x%02x\n", + dev, regoffs, old, val)); + + if ((*mix_d)[dev][RIGHT_CHN].nbits != 0) { /* have stereo */ + /* + * Set the right channel + */ + regoffs = (*mix_d)[dev][RIGHT_CHN].regno; + val = ad_read(d, regoffs); + if (regoffs != 1) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, RIGHT_CHN, right); + ad_write(d, regoffs, val); + } + return 0; /* success */ +} + +static void +ad1848_mixer_reset(snddev_info *d) +{ + int i; + + if (d->bd_id == MD_OPTI931) + d->mix_devs = OPTI931_MIXER_DEVICES; + else if (d->bd_id != MD_AD1848) + d->mix_devs = MODE2_MIXER_DEVICES; + else + d->mix_devs = MODE1_MIXER_DEVICES; + + d->mix_rec_devs = MODE1_REC_DEVICES; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + if (d->mix_devs & (1 << i)) + mss_mixer_set(d, i, default_mixer_levels[i]); + mss_set_recsrc(d, SOUND_MASK_MIC); +} + +/* + * mss_speed processes the value in play_speed finding the + * matching one. As a side effect, it returns the value to + * be written in the speed bits of the codec. It does _NOT_ + * set the speed of the device (but it should!) + * + * fixed lr970724 + */ + +static int +mss_speed(snddev_info *d) +{ + /* + * In the CS4231, the low 4 bits of I8 are used to hold the + * sample rate. Only a fixed number of values is allowed. This + * table lists them. The speed-setting routines scans the table + * looking for the closest match. This is the only supported method. + * + * In the CS4236, there is an alternate metod (which we do not + * support yet) which provides almost arbitrary frequency setting. + * In the AD1845, it looks like the sample rate can be + * almost arbitrary, and written directly to a register. + * In the OPTi931, there is a SB command which provides for + * almost arbitrary frequency setting. + * + */ + static int speeds[] = { + 8000, 5512, 16000, 11025, 27429, 18900, 32000, 22050, + -1, 37800, -1, 44100, 48000, 33075, 9600, 6615 + }; + + int arg, i, sel = 0; /* assume entry 0 does not contain -1 */ + + arg = d->play_speed ; + + for (i=1; i < 16 ; i++) + if (speeds[i] >0 && abs(arg-speeds[i]) < abs(arg-speeds[sel]) ) + sel = i ; + + d->play_speed = d->rec_speed = speeds[sel] ; + return sel ; +} + +/* + * mss_format checks that the format is supported (or defaults to AFMT_U8) + * and returns the bit setting for the 1848 register corresponding to + * the desired format. + * + * fixed lr970724 + */ + +static int +mss_format(snddev_info *d) +{ + int i, arg = d->play_fmt ; + + /* + * The data format uses 3 bits (just 2 on the 1848). For each + * bit setting, the following array returns the corresponding format. + * The code scans the array looking for a suitable format. In + * case it is not found, default to AFMT_U8 (not such a good + * choice, but let's do it for compatibility...). + */ + + static int fmts[] = { + AFMT_U8, AFMT_MU_LAW, AFMT_S16_LE, AFMT_A_LAW, + -1, AFMT_IMA_ADPCM, AFMT_U16_BE, -1 + }; + + if ( (arg & d->audio_fmt) == 0 ) /* unsupported fmt, default to AFMT_U8 */ + arg = AFMT_U8 ; + + /* ulaw/alaw seems broken on the opti931... */ + if (d->bd_id == MD_OPTI931) { + if (arg == AFMT_MU_LAW) { + arg = AFMT_U8 ; + d->flags |= SND_F_XLAT8 ; + } else + d->flags &= ~SND_F_XLAT8 ; + } + /* + * check that arg is one of the supported formats in d->format; + * otherwise fallback to AFMT_U8 + */ + + for (i=0 ; i<8 ; i++) + if (arg == fmts[i]) break; + if (i==8) { /* not found, default to AFMT_U8 */ + arg = AFMT_U8 ; + i = 0 ; + } + d->play_fmt = d->rec_fmt = arg; + + return i ; +} + +/* + * mss_detect can be used in the probe and the attach routine. + * + * We store probe information in pcm_info[unit]. This descriptor + * is reinitialized just before the attach, so all relevant + * information is lost, and mss_detect must be run again in + * the attach routine if necessary. + */ + +int +mss_detect(struct isa_device *dev) +{ + int i; + u_char tmp, tmp1, tmp2 ; + snddev_info *d = &(pcm_info[dev->id_unit]); + char *name; + + d->io_base = dev->id_iobase; + d->bd_flags |= BD_F_MCE_BIT ; + if (d->bd_id != 0) { + printf("preselected bd_id 0x%04x -- %s\n", + d->bd_id, d->name ? d->name : "???"); + return 1; + } + + name = "AD1848" ; + d->bd_id = MD_AD1848; /* AD1848 or CS4248 */ + + /* + * Check that the I/O address is in use. + * + * bit 7 of the base I/O port is known to be 0 after the chip has + * performed it's power on initialization. Just assume this has + * happened before the OS is starting. + * + * If the I/O address is unused, it typically returns 0xff. + */ + + for (i=0; i<10; i++) + if (inb(io_Index_Addr(d)) & IA_BUSY) + DELAY(10000); /* maybe busy, wait & retry later */ + else + break ; + if ((inb(io_Index_Addr(d)) & IA_BUSY) != 0x00) { /* Not a AD1848 */ + DDB(printf("mss_detect error, busy still set (0x%02x)\n", + inb(io_Index_Addr(d)))); + return 0; + } + /* + * Test if it's possible to change contents of the indirect + * registers. Registers 0 and 1 are ADC volume registers. The bit + * 0x10 is read only so try to avoid using it. + */ + + ad_write(d, 0, 0xaa); + ad_write(d, 1, 0x45);/* 0x55 with bit 0x10 clear */ + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + if ( tmp1 != 0xaa || tmp2 != 0x45) { + DDB(printf("mss_detect error - IREG (0x%02x/0x%02x) want 0xaa/0x45\n", + tmp1, tmp2)); + return 0; + } + + ad_write(d, 0, 0x45); + ad_write(d, 1, 0xaa); + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + + if (tmp1 != 0x45 || tmp2 != 0xaa) { + DDB(printf("mss_detect error - IREG2 (%x/%x)\n", tmp1, tmp2)); + return 0; + } + + /* + * The indirect register I12 has some read only bits. Lets try to + * change them. + */ + + tmp = ad_read(d, 12); + ad_write(d, 12, (~tmp) & 0x0f); + tmp1 = ad_read(d, 12); + + if ((tmp & 0x0f) != (tmp1 & 0x0f)) { + DDB(printf("mss_detect error - I12 (0x%02x was 0x%02x)\n", + tmp1, tmp)); + return 0; + } + + /* + * NOTE! Last 4 bits of the reg I12 tell the chip revision. + * 0x01=RevB + * 0x0A=RevC. also CS4231/CS4231A and OPTi931 + */ + + printf("mss_detect - chip revision 0x%02x\n", tmp & 0x0f); + + /* + * The original AD1848/CS4248 has just 16 indirect registers. This + * means that I0 and I16 should return the same value (etc.). Ensure + * that the Mode2 enable bit of I12 is 0. Otherwise this test fails + * with new parts. + */ + + ad_write(d, 12, 0); /* Mode2=disabled */ + + for (i = 0; i < 16; i++) + if ((tmp1 = ad_read(d, i)) != (tmp2 = ad_read(d, i + 16))) { + DDB(printf("mss_detect warning - I%d: 0x%02x/0x%02x\n", + i, tmp1, tmp2)); + /* + * note - this seems to fail on the 4232 on I11. So we just break + * rather than fail. + */ + break ; /* return 0; */ + } + /* + * Try to switch the chip to mode2 (CS4231) by setting the MODE2 bit + * (0x40). The bit 0x80 is always 1 in CS4248 and CS4231. + * + * On the OPTi931, however, I12 is readonly and only contains the + * chip revision ID (as in the CS4231A). The upper bits return 0. + */ + + ad_write(d, 12, 0x40); /* Set mode2, clear 0x80 */ + + tmp1 = ad_read(d, 12); + if (tmp1 & 0x80) { + name = "CS4248" ; /* Our best knowledge just now */ + } + if ((tmp1 & 0xf0) == 0x00) { + printf("this should be an OPTi931\n"); + } else if ((tmp1 & 0xc0) == 0xC0) { + /* + * The 4231 has bit7=1 always, and bit6 we just set to 1. + * We want to check that this is really a CS4231 + * Verify that setting I0 doesn't change I16. + */ + ad_write(d, 16, 0); /* Set I16 to known value */ + + ad_write(d, 0, 0x45); + if ((tmp1 = ad_read(d, 16)) != 0x45) { /* No change -> CS4231? */ + + ad_write(d, 0, 0xaa); + if ((tmp1 = ad_read(d, 16)) == 0xaa) { /* Rotten bits? */ + DDB(printf("mss_detect error - step H(%x)\n", tmp1)); + return 0; + } + /* + * Verify that some bits of I25 are read only. + */ + + DDB(printf("mss_detect() - step I\n")); + tmp1 = ad_read(d, 25); /* Original bits */ + ad_write(d, 25, ~tmp1); /* Invert all bits */ + if ((ad_read(d, 25) & 0xe7) == (tmp1 & 0xe7)) { + int id; + + /* + * It's at least CS4231 + */ + name = "CS4231" ; + d->bd_id = MD_CS4231; + + /* + * It could be an AD1845 or CS4231A as well. + * CS4231 and AD1845 report the same revision info in I25 + * while the CS4231A reports different. + */ + + id = ad_read(d, 25) & 0xe7; + /* + * b7-b5 = version number; + * 100 : all CS4231 + * 101 : CS4231A + * + * b2-b0 = chip id; + */ + switch (id) { + + case 0xa0: + name = "CS4231A" ; + d->bd_id = MD_CS4231A; + break; + + case 0xa2: + name = "CS4232" ; + d->bd_id = MD_CS4232; + break; + + case 0xb2: + /* strange: the 4231 data sheet says b4-b3 are XX + * so this should be the same as 0xa2 + */ + name = "CS4232A" ; + d->bd_id = MD_CS4232A; + break; + + case 0x80: + /* + * It must be a CS4231 or AD1845. The register I23 + * of CS4231 is undefined and it appears to be read + * only. AD1845 uses I23 for setting sample rate. + * Assume the chip is AD1845 if I23 is changeable. + */ + + tmp = ad_read(d, 23); + + ad_write(d, 23, ~tmp); + if (ad_read(d, 23) != tmp) { /* AD1845 ? */ + name = "AD1845" ; + d->bd_id = MD_AD1845; + } + ad_write(d, 23, tmp); /* Restore */ + break; + + case 0x83: /* CS4236 */ + name = "CS4236"; + d->bd_id = MD_CS4236; + break ; + + default: /* Assume CS4231 */ + printf("unknown id 0x%02x, assuming CS4231\n", id); + d->bd_id = MD_CS4231; + + } + } + ad_write(d, 25, tmp1); /* Restore bits */ + + } + } + DDB(printf("mss_detect() - Detected %s\n", name)); + strcpy(d->name, name); + dev->id_flags &= ~DV_F_DEV_MASK ; + dev->id_flags |= (d->bd_id << DV_F_DEV_SHIFT) & DV_F_DEV_MASK ; + return 1; +} + + +/* + * mss_reinit resets registers of the codec + */ +static void +mss_reinit(snddev_info *d) +{ + u_char r; + + r = mss_speed(d) ; + r |= (mss_format(d) << 5) ; + if (d->flags & SND_F_STEREO) + r |= 0x10 ; + /* XXX check if MCE is necessary... */ + ad_enter_MCE(d); + + /* + * perhaps this is not the place to set mode2, should be done + * only once at attach time... + */ + if ( d->dma1 != d->dma2 && d->bd_id != MD_OPTI931) + /* + * set mode2 bit for dual dma op. This bit is not implemented + * on the OPTi931 + */ + ad_write(d, 12, ad_read(d, 12) | 0x40 /* mode 2 on the CS42xx */ ); + + /* + * XXX this should really go into mss-speed... + */ + if (d->bd_id == MD_AD1845) { /* Use alternate speed select regs */ + r &= 0xf0; /* Mask off the rate select bits */ + + ad_write(d, 22, (d->play_speed >> 8) & 0xff); /* Speed MSB */ + ad_write(d, 23, d->play_speed & 0xff); /* Speed LSB */ + /* + * XXX must also do something in I27 for the ad1845 + */ + } + + ad_write(d, 8, r) ; + if (d->dma1 != d->dma2) { + ad_write(d, 28, r & 0xf0 ) ; /* capture mode */ + ad_write(d, 9, 0 /* no capture, no playback, dual dma */) ; + } else + ad_write(d, 9, 4 /* no capture, no playback, single dma */) ; + ad_leave_MCE(d); + ad_write_cnt(d, 14, 0 ); /* playback count */ + if (d->dma1 != d->dma2) + ad_write_cnt(d, 30, 0 ); /* rec. count on dual dma */ + + ad_write(d, 10, 2 /* int enable */) ; + outb(io_Status(d), 0); /* Clear interrupt status */ + /* the following seem required on the CS4232 */ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); + + snd_set_blocksize(d); /* update blocksize if user did not force it */ +} + +/* + * here we have support for PnP cards + * + */ + +#if NPNP > 0 + +static char * cs4236_probe(u_long csn, u_long vend_id); +static void cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device cs4236 = { + "cs423x", + cs4236_probe, + cs4236_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, cs4236); + +static char * +cs4236_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x3742630e) + s = "CS4237" ; + else if (vend_id == 0x3642630e) + s = "CS4236" ; + else if (vend_id == 0x3242630e) + s = "CS4232" ; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s; + } + + return NULL ; +} + +extern snddev_info sb_op_desc; + +static void +cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int ldn = 0 ; + + if (read_pnp_parms ( &d , ldn ) == 0 ) { + printf("failed to read pnp parms\n"); + return ; + } + snddev_last_probed = &tmp_d; +#if 0 + /* sb-compatible codec */ + dev->id_iobase = d.port[2] ; + tmp_d = sb_op_desc ; + tmp_d.alt_base = d.port[0] - 4; + d.drq[1] = 4 ; /* disable, it is not used ... */ + d.drq[0] = 0 ; /* remap ... */ +#else + /* mss-compatible codec */ + dev->id_iobase = d.port[0] -4 ; /* XXX old mss have 4 bytes before... */ + tmp_d = mss_op_desc ; + tmp_d.bd_id = MD_CS4232 ; /* to short-circuit the detect routine */ + tmp_d.alt_base = d.port[2]; + strcpy(tmp_d.name, name); + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; +#endif + write_pnp_parms( &d, ldn ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; /* during the probe... */ + snddev_last_probed->probe(dev); + + pcmattach(dev); +} + +static char *opti931_probe(u_long csn, u_long vend_id); +static void opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device opti931 = { + "OPTi931", + opti931_probe, + opti931_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti931); + +static char * +opti931_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x3109143e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 1); + if (d.enable == 0) { + printf("This is an OPTi931, but LDN 1 is disabled\n"); + return NULL ; + } + return "OPTi931" ; + } + return NULL ; +} + +static void +opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int p; + int sb_mode = 0 ; /* XXX still not work in SB mode */ + + read_pnp_parms ( &d , 3 ); /* free resources taken by LDN 3 */ + d.irq[0]=0; /* free irq... */ + d.port[0]=0; /* free address... */ + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + write_pnp_parms( &d, 1 ); + enable_pnp_card(); + + snddev_last_probed = &tmp_d; + tmp_d = sb_mode ? sb_op_desc : mss_op_desc ; + + strcpy(tmp_d.name, name); + + /* + * My MED3931 v.1.0 allocates 3 bytes for the config space, + * whereas v.2.0 allocates 4 bytes. What I know for sure is that the + * upper two ports must be used, and they should end on a boundary + * of 4 bytes. So I need the following trick... + */ + p = tmp_d.conf_base = (d.port[3] & ~3) + 2; /* config port */ + + /* + * now set default values for both modes. + */ + dev->id_iobase = d.port[0] - 4 ; /* old mss have 4 bytes before... */ + tmp_d.io_base = dev->id_iobase; /* needed for ad_write to work... */ + tmp_d.alt_base = d.port[2]; + opti_write(p, 4, 0x56 /* fifo 1/2, OPL3, audio enable, SB3.2 */ ); + ad_write (&tmp_d, 10, 2); /* enable interrupts */ + + if (sb_mode) { /* sb-compatible codec */ + /* + * the 931 is not a real SB, it has important pieces of + * hardware controlled by both the WSS and the SB port... + */ + opti_write(p, 6, 1); /* MCIR6 wss disable, sb enable */ + /* + * swap the main and alternate iobase address since we want + * to work in sb mode. + */ + dev->id_iobase = d.port[2] ; + tmp_d.alt_base = d.port[0] - 4; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + } else { /* mss-compatible codec */ + tmp_d.bd_id = MD_OPTI931 ; /* to short-circuit the detect routine */ + opti_write(p, 6 , 2); /* MCIR6: wss enable, sb disable */ +#if 0 /* not working yet... */ + opti_write(p, 5, 0x0 /* codec in single mode */ ); + dev->id_flags = 0 ; +#else + opti_write(p, 5, 0x28); /* MCIR5: codec in exp. mode,fifo */ + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; +#endif + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; /* not really well... */ + tmp_d.isr = opti931_intr; + } + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + pcmattach(dev); +} + +static char *guspnp_probe(u_long csn, u_long vend_id); +static void guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device guspnp = { + "GusPnP", + guspnp_probe, + guspnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, guspnp); + +static char * +guspnp_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x0100561e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a GusPnP, but LDN 0 is disabled\n"); + return NULL ; + } + return "GusPnP" ; + } + return NULL ; +} + +static void +guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + read_pnp_parms ( &d , 0 ) ; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + tmp_d = mss_op_desc ; + snddev_last_probed = &tmp_d; + + dev->id_iobase = d.port[2] - 4 ; /* room for 4 mss registers */ + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + + tmp_d.alt_base = d.port[0]; + + pcmattach(dev); +} +#endif /* NPNP > 0 */ +#endif /* NPCM > 0 */ diff --git a/sys/dev/pcm/isa/mss.h b/sys/dev/pcm/isa/mss.h new file mode 100644 index 000000000000..4b34e51ab713 --- /dev/null +++ b/sys/dev/pcm/isa/mss.h @@ -0,0 +1,250 @@ +/* + * file: mss.h + * + * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it) + * + * This file contains information and macro definitions for + * AD1848-compatible devices, used in the MSS/WSS compatible boards. + * + */ + +/* + * + +The codec part of the board is seen as a set of 4 registers mapped +at the base address for the board (default 0x534). Note that some +(early) boards implemented 4 additional registers 4 location before +(usually 0x530) to store configuration information. This is a source +of confusion in that one never knows what address to specify. The +(current) convention is to use the old address (0x530) in the kernel +configuration file and consider MSS registers start four location +ahead. + + * + */ + +/* + * The four visible registers of the MSS : + * + */ + +#define io_Index_Addr(d) ((d)->io_base + 4) +#define IA_BUSY 0x80 /* readonly, set when busy */ +#define IA_MCE 0x40 /* the MCE bit. */ + /* + * the MCE bit must be set whenever the current mode of the + * codec is changed; this in particular is true for the + * Data Format (I8, I28) and Interface Config(I9) registers. + * Only exception are CEN and PEN which can be changed on the fly. + * The DAC output is muted when MCE is set. + */ +#define IA_TRD 0x20 /* Transfer request disable */ + /* + * When TRD is set, DMA transfers cease when the INT bit in + * the MSS status reg is set. Must be cleared for automode + * DMA, set otherwise. + */ +#define IA_AMASK 0x1f /* mask for indirect address */ + +#define io_Indexed_Data(d) ((d)->io_base+1+4) + /* + * data to be transferred to the indirect register addressed + * by index addr. During init and sw. powerdown, cannot be + * written to, and is always read as 0x80 (consistent with the + * busy flag). + */ + +#define io_Status(d) ((d)->io_base+2+4) + +#define IS_CUL 0x80 /* capture upper/lower */ +#define IS_CLR 0x40 /* capture left/right */ +#define IS_CRDY 0x20 /* capture ready for programmed i/o */ +#define IS_SER 0x10 /* sample error (overrun/underrun) */ +#define IS_PUL 0x08 /* playback upper/lower */ +#define IS_PLR 0x04 /* playback left/right */ +#define IS_PRDY 0x02 /* playback ready for programmed i/o */ +#define IS_INT 0x01 /* int status (1 = active) */ + /* + * IS_INT is clreared by any write to the status register. + */ + +#define io_Polled_IO(d) ((d)->io_base+3+4) + /* + * this register is used in case of polled i/o + */ + +/* + * The MSS has a set of 16 (or 32 depending on the model) indirect + * registers accessible through the data port by specifying the + * appropriate address in the address register. + * + * The 16 low registers are uniformly handled in AD1848/CS4248 compatible + * mode (often called MODE1). For the upper 16 registers there are + * some differences among different products, mainly Crystal uses them + * differently from OPTi. + * + */ + +/* + * volume registers + */ + +#define I6_MUTE 0x80 + +/* + * register I9 -- interface configuration. + */ + +#define I9_PEN 0x01 /* playback enable */ +#define I9_CEN 0x02 /* capture enable */ + +/* + * values used in bd_flags + */ +#define BD_F_MCE_BIT 0x0001 +#define BD_F_IRQ_OK 0x0002 +#define BD_F_TMR_RUN 0x0004 + + +/* + * sound/ad1848_mixer.h + * + * Definitions for the mixer of AD1848 and compatible codecs. + * + * Copyright by Hannu Savolainen 1994 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * The AD1848 codec has generic input lines called Line, Aux1 and Aux2. + * Soundcard manufacturers have connected actual inputs (CD, synth, line, + * etc) to these inputs in different order. Therefore it's difficult + * to assign mixer channels to to these inputs correctly. The following + * contains two alternative mappings. The first one is for GUS MAX and + * the second is just a generic one (line1, line2 and line3). + * (Actually this is not a mapping but rather some kind of interleaving + * solution). + */ +#define GUSMAX_MIXER +#ifdef GUSMAX_MIXER +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM|SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_SPEAKER | SOUND_MASK_IGAIN | \ + SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#else /* Generic mapping */ + +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE3 | SOUND_MASK_MIC | SOUND_MASK_LINE1|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_LINE3 | SOUND_MASK_SPEAKER | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) +#endif + +#define OPTI931_MIXER_DEVICES \ + (SOUND_MASK_VOLUME | SOUND_MASK_SYNTH | SOUND_MASK_PCM | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_IGAIN ) + +/* + * Most of the mixer entries work in backwards. Setting the polarity field + * makes them to work correctly. + * + * The channel numbering used by individual soundcards is not fixed. + * Some cards have assigned different meanings for the AUX1, AUX2 + * and LINE inputs. Some have different features... + * The current version doesn't try to compensate this. + * + */ + +mixer_ent mix_devices[32][2] = { /* As used in GUS MAX */ +MIX_ENT(SOUND_MIXER_VOLUME, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 6, 7, 1, 0, 6), +MIX_ENT(SOUND_MIXER_SPEAKER, 26, 1, 0, 4, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 0, 5, 19, 1, 0, 5), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_IMIX, 13, 1, 2, 6, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +mixer_ent opti931_devices[32][2] = { /* for the opti931 */ +MIX_ENT(SOUND_MIXER_VOLUME, 22, 1, 1, 5, 23, 1, 1, 5), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 1, 4, 5, 1, 1, 4), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 5, 7, 1, 0, 5), +MIX_ENT(SOUND_MIXER_SPEAKER, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 1, 4, 19, 1, 1, 4), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 1, 4, 3, 1, 1, 4), +MIX_ENT(SOUND_MIXER_IMIX, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +static u_short default_mixer_levels[SOUND_MIXER_NRDEVICES] = { + 0x5a5a, /* Master Volume */ + 0x3232, /* Bass */ + 0x3232, /* Treble */ + 0x4b4b, /* FM */ + 0x4040, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x2020, /* Ext Line */ + 0x4040, /* Mic */ + 0x4b4b, /* CD */ + 0x0000, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x2525, /* Input gain */ + 0x0000, /* Output gain */ + /* 0x4040, Line1 */ + 0x0000, /* Line1 */ + 0x0000, /* Line2 */ + 0x1515 /* Line3 (usually line in)*/ +}; + diff --git a/sys/dev/pcm/isa/sb.c b/sys/dev/pcm/isa/sb.c new file mode 100644 index 000000000000..4ca1f1f507fa --- /dev/null +++ b/sys/dev/pcm/isa/sb.c @@ -0,0 +1,1080 @@ +/* + * sound/sb_dsp.c + * + * driver for the SoundBlaster and clones. + * + * Copyright 1997 Luigi Rizzo. + * + * Derived from files in the Voxware 3.5 distribution, + * Copyright by Hannu Savolainen 1994, under the same copyright + * conditions. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* + * use this as a template file for board-specific drivers. + * The next two lines (and the final #endif) are in all drivers: + */ + +#include +#if NPCM > 0 + +/* + * Begin with the board-specific include files... + */ + +#define __SB_MIXER_C__ /* XXX warning... */ +#include + +/* + * then prototypes of functions which go in the snddev_info + * (usually static, unless they are shared by other modules)... + */ + +static int sb_probe(struct isa_device *dev); +static int sb_attach(struct isa_device *dev); + +static d_open_t sb_dsp_open; +static d_close_t sb_dsp_close; +static d_ioctl_t sb_dsp_ioctl; +static irq_proc_t sbintr; +static snd_callback_t sb_callback; + +/* + * and prototypes for other private functions defined in this module. + */ + +static void sb_dsp_init(snddev_info *d, struct isa_device *dev); +static void sb_mix_init(snddev_info *d); +static int sb_mixer_set(snddev_info *d, int dev, int value); +static int dsp_speed(snddev_info *d); +static void sb_mixer_reset(snddev_info *d); + +u_int sb_get_byte(int io_base); + +/* + * Then put here the descriptors for the various boards supported + * by this module, properly initialized. + */ + +snddev_info sb_op_desc = { + "basic soundblaster", + + SNDCARD_SB, + sb_probe, + sb_attach, + + sb_dsp_open, + sb_dsp_close /* sb_close */, + NULL /* use generic sndread */, + NULL /* use generic sndwrite */, + sb_dsp_ioctl, + sndselect, + + sbintr, + sb_callback, + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | AFMT_U8, /* audio format */ + +} ; + +/* + * Then the file continues with the body of all functions + * directly referenced in the descriptor. + */ + +/* + * the probe routine for the SoundBlaster only consists in + * resetting the dsp and testing if it is there. + * Version detection etc. will be done at attach time. + * + * Remebber, isa probe routines are supposed to return the + * size of io space used. + */ + +static int +sb_probe(struct isa_device *dev) +{ + if (dev->id_iobase == -1) { + dev->id_iobase = 0x220; + printf("sb_probe: no address supplied, try defaults (0x220,0x240)\n"); + if (snd_conflict(dev->id_iobase)) + dev->id_iobase = 0x240; + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if (sb_reset_dsp(dev->id_iobase)) + return 16 ; /* the SB uses 16 registers... */ + else + return 0; +} + +static int +sb_attach(struct isa_device *dev) +{ + snddev_info *d = &pcm_info[dev->id_unit] ; + + sb_dsp_init(d, dev); + return 0 ; +} + +/* + * here are the main routines from the switches. + */ + +static int +sb_dsp_open(dev_t dev, int flags, int mode, struct proc * p) +{ + snddev_info *d; + int unit ; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + DEB(printf("<%s>%d : open\n", d->name, unit)); + + if (d->flags & SND_F_BUSY) { + printf("<%s>%d open: device busy\n", d->name, unit); + return EBUSY ; + } + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + d->flags = 0 ; + d->bd_flags &= ~BD_F_HISPEED ; + + switch ( dev & 0xf ) { + case SND_DEV_DSP16 : + if ((d->audio_fmt & AFMT_S16_LE) == 0) { + printf("sorry, 16-bit not supported on SB %d.%02d\n", + (d->bd_id >>8) & 0xff, d->bd_id & 0xff); + return ENXIO; + } + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + } + + d->flags |= SND_F_BUSY ; + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + sb_reset_dsp(d->io_base); + ask_init(d); + + return 0; +} + +static int +sb_dsp_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + s = spltty(); + d->flags |= SND_F_CLOSING ; + splx(s); + snd_flush(d); + + sb_cmd(d->io_base, DSP_CMD_SPKOFF ); /* XXX useless ? */ + + d->flags = 0 ; + return 0 ; +} + +static int +sb_dsp_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) + return sb_mixer_set(d, cmd & 0xff, *(int *)arg) ; + + /* + * for the remaining functions, use the default handler. + */ + + return ENOSYS ; +} + +static void +sbintr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + int reason = 3, c=1, io_base = d->io_base; + + DEB(printf("got sbintr for unit %d, flags 0x%08x\n", unit, d->flags)); + + /* + * SB < 4.0 is half duplex and has only 1 bit for int source, + * so we fake it. SB 4.x (SB16) has the int source in a separate + * register. + */ +again: + if (d->bd_flags & BD_F_SB16) { + c = sb_getmixer(io_base, IRQ_STAT); + /* this tells us if the source is 8-bit or 16-bit dma. We + * have to check the io channel to map it to read or write... + */ + reason = 0 ; + if ( c & 1 ) { /* 8-bit dma */ + if (d->dma1 < 4) + reason |= 1; + if (d->dma2 < 4) + reason |= 2; + } + if ( c & 2 ) { /* 16-bit dma */ + if (d->dma1 >= 4) + reason |= 1; + if (d->dma2 >= 4) + reason |= 2; + } + } + if ( c & 2 ) + inb(DSP_DATA_AVL16); /* 16-bit int ack */ + if (c & 1) + inb(DSP_DATA_AVAIL); /* 8-bit int ack */ + +DEB(printf("sbintr, flags 0x%08x reason %d\n", d->flags, reason)); + if ( (d->flags & SND_F_WR_DMA) && (reason & 1) ) + dsp_wrintr(d); + if ( (d->flags & SND_F_RD_DMA) && (reason & 2) ) + dsp_rdintr(d); + + /* + * the sb16 might have multiple sources etc. + */ + if (d->bd_flags & BD_F_SB16 && (c & 3) ) + goto again; +} + +/* + * device-specific function called back from the dma module. + * The reason of the callback is the second argument. + * NOTE: during operations, some ioctl can be done to change + * settings (e.g. speed, channels, format), and the default + * ioctl handler will just record the change and set the + * flag SND_F_INIT. The callback routine is in charge of applying + * the changes at the next convenient time (typically, at the + * start of operations). For full duplex devices, in some cases the + * init requires both channels to be idle. + */ +static int +sb_callback(snddev_info *d, int reason) +{ + u_long s ; + int rd = reason & SND_CB_RD ; + int l = (rd) ? d->dbuf_in.dl0 : d->dbuf_out.dl0 ; + + switch (reason & SND_CB_REASON_MASK) { + case SND_CB_INIT : /* called with int enabled and no pending io */ + dsp_speed(d); + snd_set_blocksize(d); + if (d->play_fmt & AFMT_MU_LAW) + d->flags |= SND_F_XLAT8 ; + else + d->flags &= ~SND_F_XLAT8 ; + return 1; + break ; + + case SND_CB_START : /* called with int disabled */ + sb_cmd(d->io_base, rd ? DSP_CMD_SPKOFF : DSP_CMD_SPKON); + d->flags &= ~SND_F_INIT ; + if (d->bd_flags & BD_F_SB16) { + /* the SB16 can do full duplex using one 16-bit channel + * and one 8-bit channel. It needs to be programmed to + * use split format though. + */ + int b16 ; + int swap = 0 ; + + b16 = (rd) ? d->rec_fmt : d->play_fmt ; + b16 = (b16 == AFMT_S16_LE) ? 1 : 0; + /* + * check if I have to swap dma channels. Swap if + * - !rd, dma1 <4, b16 + * - !rd, dma1 >=4, !b16 + * - rd, dma2 <4, b16 + * - rd, dma2 >=4, !b16 + */ + if (!rd) { + if ( (d->dma1 <4 && b16) || (d->dma1 >=4 && !b16) ) swap = 1; + } else { + if ( (d->dma2 <4 && b16) || (d->dma2 >=4 && !b16) ) swap = 1; + } + /* + * before swapping should make sure that there is no + * pending DMA on the other channel... + */ + if (swap) { + int c = d->dma2 ; + d->dma2 = d->dma1; + d->dma1 = c ; + } + DEB(printf("sb_init: play %d rec %d dma1 %d dma2 %d\n", + d->play_fmt, d->rec_fmt, d->dma1, d->dma2)); + } + /* fallthrough */ + case SND_CB_RESTART: + if (d->bd_flags & BD_F_SB16) { + u_char c, c1 ; + /* + * SB16 support still not completely working!!! + * + * in principle, on the SB16, I could support simultaneous + * play & rec. + * However, there is no way to ask explicitly for 8 or + * 16 bit transfer. As a consequence, if we do 8-bit, + * we need to use the 8-bit channel, and if we do 16-bit, + * we need to use the other one. The only way I find to + * do this is to swap d->dma1 and d->dma2 ... + * + */ + + if (rd) { + c = ((d->dma2 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_ADC ; + c1 = (d->play_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->rec_fmt == AFMT_S16_LE) + l /= 2 ; + } else { + c = ((d->dma1 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_DAC ; + c1 = (d->rec_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->play_fmt == AFMT_S16_LE) + l /= 2 ; + } + + if (d->flags & SND_F_STEREO) + c1 |= DSP_F16_STEREO ; + + sb_cmd(d->io_base, c ); + sb_cmd3(d->io_base, c1 , l - 1) ; + } else { + u_char c ; + if (d->bd_flags & BD_F_HISPEED) + c = (rd) ? DSP_CMD_HSADC : DSP_CMD_HSDAC ; + else + c = (rd) ? DSP_CMD_ADC8 : DSP_CMD_DAC8 ; + sb_cmd3(d->io_base, c , l - 1) ; + } + break; + + case SND_CB_STOP : + /* sb_cmd(d->io_base, DSP_CMD_SPKOFF); /* speaker off */ + break ; + + } + return 0 ; +} + +/* + * The second part of the file contains all functions specific to + * the board and (usually) not exported to other modules. + */ + +int +sb_reset_dsp(int io_base) +{ + int loopc; + + outb(DSP_RESET, 1); + DELAY(100); + outb(DSP_RESET, 0); + for (loopc = 0; loopc<100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++) + DELAY(30); + + if (inb(DSP_READ) != 0xAA) { + DEB(printf("sb_reset_dsp failed\n")); + return 0; /* Sorry */ + } + return 1; +} + +/* + * only used in sb_attach from here. + */ + +static void +sb_dsp_init(snddev_info *d, struct isa_device *dev) +{ + int i, x; + char *fmt = NULL ; + int io_base = dev->id_iobase ; + + d->bd_id = 0 ; + + sb_reset_dsp(io_base); + sb_cmd(io_base, DSP_CMD_GETVER); /* Get version */ + + for (i = 10000; i; i--) { /* perhaps wait longer on a fast machine ? */ + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if ( (d->bd_id & 0xff00) == 0) + d->bd_id = inb(DSP_READ) << 8; /* major */ + else { + d->bd_id |= inb(DSP_READ); /* minor */ + break; + } + } else + DELAY(20); + } + + /* + * now do various initializations depending on board id. + */ + + fmt = "SoundBlaster %d.%d" ; /* default */ + + switch ( d->bd_id >> 8 ) { + case 0 : + printf("\n\nFailed to get SB version (%x) - possible I/O conflict\n\n", + inb(DSP_DATA_AVAIL)); + d->bd_id = 0x100; + case 1 : /* old sound blaster has nothing... */ + break ; + + case 2 : + d->dma2 = d->dma1 ; /* half duplex */ + d->bd_flags |= BD_F_DUP_MIDI ; + + if (d->bd_id == 0x200) + break ; /* no mixer on the 2.0 */ + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1335 ; + + break ; + case 4 : + fmt = "SoundBlaster 16 %d.%d"; + d->audio_fmt |= AFMT_FULLDUPLEX | AFMT_WEIRD | AFMT_S8 | AFMT_S16_LE; + d->bd_flags |= BD_F_SB16; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1745 ; + + /* soft irq/dma configuration */ + x = -1 ; + if (d->irq == 5) x = 2; + else if (d->irq == 7) x = 4; + else if (d->irq == 9) x = 1; + else if (d->irq == 10) x = 8; + if (x == -1) + printf("<%s>%d: bad irq %d (only 5,7,9,10 allowed)\n", + d->name, dev->id_unit, d->irq); + else + sb_setmixer(io_base, IRQ_NR, x); + + sb_setmixer(io_base, DMA_NR, (1 << d->dma1) | (1 << d->dma2)); + break ; + + case 3 : + d->dma2 = d->dma1 ; /* half duplex */ + fmt = "SoundBlaster Pro %d.%d"; + d->bd_flags |= BD_F_DUP_MIDI ; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1345 ; + if (d->bd_id == 0x301) { + int ess_major = 0, ess_minor = 0; + + /* + * Try to detect ESS chips. + */ + + sb_cmd(io_base, DSP_CMD_GETID); /* Return ident. bytes. */ + + for (i = 1000; i; i--) { + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if (ess_major == 0) + ess_major = inb(DSP_READ); + else { + ess_minor = inb(DSP_READ); + break; + } + } + } + + if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS488 based card (rev %d)\n", + ess_minor & 0x0f); + else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS688 based card (rev %d)\n", + ess_minor & 0x0f); + } + + if (d->bd_flags & BD_F_JAZZ16) { + if (d->bd_flags & BD_F_JAZZ16_2) + fmt = "SoundMan Wave %d.%d"; + else + fmt = "MV Jazz16 %d.%d"; + d->audio_fmt |= AFMT_S16_LE; /* 16 bits */ + } + } + + sprintf(d->name, fmt, (d->bd_id >> 8) &0xff, d->bd_id & 0xff); + + sb_mix_init(d); +} + +static void +sb_mix_init(snddev_info *d) +{ + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : /* SB 3.0 has 1345 mixer */ + + d->mix_devs = SBPRO_MIXER_DEVICES ; + d->mix_rec_devs = SBPRO_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + + sb_setmixer(d->io_base, 0, 1 ); /* reset mixer */ + sb_setmixer(d->io_base, MIC_VOL , 0x6 ); /* mic volume max */ + sb_setmixer(d->io_base, RECORD_SRC , 0x0 ); /* mic source */ + sb_setmixer(d->io_base, FM_VOL , 0x0 ); /* no midi */ + break ; + + case BD_F_MIX_CT1745 : /* SB16 mixer ... */ + + d->mix_devs = SB16_MIXER_DEVICES ; + d->mix_rec_devs = SB16_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + } + sb_mixer_reset(d); +} + +/* + * Common code for the midi and pcm functions + */ + +int +sb_cmd(int io_base, u_char val) +{ + int i; + + for (i = 0; i < 1000 ; i++) { + if ((inb(DSP_STATUS) & 0x80) == 0) { + outb(DSP_COMMAND, val); + return 1; + } + if (i > 10) + DELAY (i > 100 ? 1000 : 10 ); + } + + printf("SoundBlaster: DSP Command(0x%02x) timeout. IRQ conflict ?\n", val); + return 0; +} + +int +sb_cmd3(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + sb_cmd(io_base, (val>>8) & 0xff ); + return 1 ; + } else + return 0; +} + +int +sb_cmd2(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + return 1 ; + } else + return 0; +} + +void +sb_setmixer(int io_base, u_int port, u_int value) +{ + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + outb(MIXER_DATA, (u_char) (value & 0xff)); + DELAY(10); + splx(flags); +} + +u_int +sb_get_byte(int io_base) +{ + int i; + + for (i = 1000; i; i--) + if (inb(DSP_DATA_AVAIL) & 0x80) + return inb(DSP_READ); + else + DELAY(20); + return 0xffff; +} + +int +sb_getmixer(int io_base, u_int port) +{ + int val; + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + val = inb(MIXER_DATA); + DELAY(10); + splx(flags); + + return val; +} + + +/* + * various utility functions for the DSP + */ + +/* + * dsp_speed updates the speed setting from the descriptor. make sure + * it is called at spltty(). + * Besides, it takes care of stereo setting. + */ +static int +dsp_speed(snddev_info *d) +{ + u_char tconst; + u_long flags; + int max_speed = 44100, speed = d->play_speed ; + + if (d->bd_flags & BD_F_SB16) { + RANGE (speed, 5000, 45000); + d->play_speed = d->rec_speed = speed ; + sb_cmd(d->io_base, 0x41); + sb_cmd(d->io_base, d->play_speed >> 8 ); + sb_cmd(d->io_base, d->play_speed & 0xff ); + sb_cmd(d->io_base, 0x42); + sb_cmd(d->io_base, d->rec_speed >> 8 ); + sb_cmd(d->io_base, d->rec_speed & 0xff ); + return speed ; + } + /* + * only some models can do stereo, and only if not + * simultaneously using midi. + */ + if ( (d->bd_id & 0xff00) < 0x300 || d->bd_flags & BD_F_MIDIBUSY) + d->flags &= ~SND_F_STEREO; + + /* + * here enforce speed limitations. + */ + if (d->bd_id <= 0x200) + max_speed = 22050; /* max 22050 on SB 1.X */ + + /* + * SB models earlier than SB Pro have low limit for the + * input rate. Note that this is only for input, but since + * we do not support separate values for rec & play.... + */ + if (d->bd_id <= 0x200) + max_speed = 13000; + else if (d->bd_id < 0x300) + max_speed = 15000; + + RANGE(speed, 4000, max_speed); + + /* + * Logitech SoundMan Games and Jazz16 cards can support 44.1kHz + * stereo + */ +#if !defined (SM_GAMES) + /* + * Max. stereo speed is 22050 + */ + if (d->flags & SND_F_STEREO && speed > 22050 && !(d->bd_flags & BD_F_JAZZ16)) + speed = 22050; +#endif + + if ((speed > 22050) && d->bd_flags & BD_F_MIDIBUSY) + speed = 22050; + + if (d->flags & SND_F_STEREO) + speed *= 2; + + /* + * Now the speed should be valid. Compute the value to be + * programmed into the board. + */ + + if (speed > 22050) { /* High speed mode on 2.01/3.xx */ + int tmp; + + tconst = (u_char) ((65536 - ((256000000 + speed / 2) / speed)) >> 8); + d->bd_flags |= BD_F_HISPEED ; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 65536 - (tconst << 8); + speed = (256000000 + tmp / 2) / tmp; + } else { + int tmp; + + d->bd_flags &= ~BD_F_HISPEED ; + tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 256 - tconst; + speed = (1000000 + tmp / 2) / tmp; + } + + if (d->flags & SND_F_STEREO) + speed /= 2; + + d->play_speed = d->rec_speed = speed; + return speed; +} + +/* + * mixer support, originally in sb_mixer.c + */ + +static void +sb_set_recsrc(snddev_info *d, int mask) +{ + u_char outmask; + u_char recdev ; + + mask &= d->mix_rec_devs; + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : + if (mask == SOUND_MASK_LINE) + recdev = 6 ; + else if (mask == SOUND_MASK_CD) + recdev = 2 ; + else { /* default: mic */ + mask = SOUND_MASK_MIC ; + recdev = 0 ; + } + sb_setmixer(d->io_base, RECORD_SRC, + recdev | (sb_getmixer(d->io_base, RECORD_SRC) & ~7 )); + break ; + case BD_F_MIX_CT1745 : /* sb16 */ + if (mask == 0) + mask = SOUND_MASK_MIC ; /* XXX For compatibility. Bug ? */ + recdev = 0 ; + if (mask & SOUND_MASK_MIC) + recdev |= 1 ; + if (mask & SOUND_MASK_CD) + recdev |= 6 ; /* l+r cd */ + if (mask & SOUND_MASK_LINE) + recdev |= 0x18 ; /* l+r line */ + if (mask & SOUND_MASK_SYNTH) + recdev |= 0x60 ; /* l+r midi */ + sb_setmixer(d->io_base, SB16_IMASK_L, recdev); + sb_setmixer(d->io_base, SB16_IMASK_R, recdev); + /* + * since the same volume controls apply to the input and + * output sections, the best approach to have a consistent + * behaviour among cards would be to disable the output path + * on devices which are used to record. + * However, since users like to have feedback, we only disable + * the mike -- permanently. + */ + sb_setmixer(d->io_base, SB16_OMASK, 0x1f & ~1); + break ; + } + d->mix_recsrc = mask; +} + +static void +sb_mixer_reset(snddev_info *d) +{ + int i; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + sb_mixer_set(d, i, levels[i]); + if (d->bd_flags & BD_F_SB16) { + sb_setmixer(d->io_base, 0x3c, 0x1f); /* make all output active */ + sb_setmixer(d->io_base, 0x3d, 0); /* make all inputs-l off */ + sb_setmixer(d->io_base, 0x3e, 0); /* make all inputs-r off */ + } + sb_set_recsrc(d, SOUND_MASK_MIC); +} + +static int +sb_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + int regoffs; + u_char val; + mixer_tab *iomap; + +#ifdef JAZZ16 + if (d->bd_flags & BD_F_JAZZ16 && d->bd_flags & BD_F_JAZZ16_2) + return smw_mixer_set(dev, value); +#endif + + if (dev == SOUND_MIXER_RECSRC) { + sb_set_recsrc(d, value); + return 0 ; + } + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + if (dev > 31) + return EINVAL ; + + if (!(d->mix_devs & (1 << dev))) /* Not supported */ + return EINVAL; + + switch ( d->bd_flags & BD_F_MIX_MASK ) { + default: + /* mixer unknown, fail... */ + return EINVAL ;/* XXX change this */ + case BD_F_MIX_CT1345 : + iomap = &sbpro_mix ; + break; + case BD_F_MIX_CT1745 : + iomap = &sb16_mix ; + break; + /* XXX how about the SG NX Pro, iomap = sgnxpro_mix */ + } + regoffs = (*iomap)[dev][LEFT_CHN].regno; + if (regoffs == 0) + return EINVAL; + + val = sb_getmixer(d->io_base, regoffs); + + change_bits(iomap, &val, dev, LEFT_CHN, left); + + d->mix_levels[dev] = left | (left << 8); + + if ((*iomap)[dev][RIGHT_CHN].regno != regoffs) { /* Change register */ + sb_setmixer(d->io_base, regoffs, val); /* Save the old one */ + regoffs = (*iomap)[dev][RIGHT_CHN].regno; + + if (regoffs == 0) + return 0 ; /* Just left channel present */ + + val = sb_getmixer(d->io_base, regoffs); /* Read the new one */ + } + change_bits(iomap, &val, dev, RIGHT_CHN, right); + + sb_setmixer(d->io_base, regoffs, val); + + d->mix_levels[dev] = left | (right << 8); + return 0 ; /* ok */ +} + +/* + * now support for some PnP boards. + */ + +#if NPNP > 0 +static char *opti925_probe(u_long csn, u_long vend_id); +static void opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device opti925 = { + "opti925", + opti925_probe, + opti925_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti925); + +static char * +opti925_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x2509143e) { + struct pnp_cinfo d ; + read_pnp_parms ( &d , 1 ) ; + if (d.enable == 0) { + printf("This is an OPTi925, but LDN 1 is disabled\n"); + return NULL; + } + return "OPTi925" ; + } + return NULL ; +} + +static void +opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int the_irq = 0 ; + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 3 ); /* disable LDN 3 */ + the_irq = d.irq[0]; + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + d.irq[0] = the_irq ; + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 1 ); + enable_pnp_card(); + + tmp_d.conf_base = d.port[3]; + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); + +} + +/* + * A driver for some SB16pnp and compatibles... + * + * Avance Asound 100 -- 0x01009305 + * xxx -- 0x2b008c0e + * + */ + +static char *sb16pnp_probe(u_long csn, u_long vend_id); +static void sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device sb16pnp = { + "SB16pnp", + sb16pnp_probe, + sb16pnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, sb16pnp); + +static char * +sb16pnp_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x01009305) + s = "Avance Asound 100" ; + if (vend_id == 0x2b008c0e) + s = "SB16 Value PnP" ; + /* + * The SB16/AWE64 cards seem to differ in the fourth byte of + * the vendor id, so I have just masked it for the time being... + * Reported values are: + * SB16 Value PnP: 0x2b008c0e + * SB AWE64 PnP: 0x39008c0e 0x9d008c0e 0xc3008c0e + */ + if ( (vend_id & 0xffffff) == (0x9d008c0e & 0xffffff) ) + s = "SB AWE64 PnP"; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s ; + } + return NULL ; +} + +static void +sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 0 ) ; + d.port[1] = 0 ; /* only the first address is used */ + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); +} +#endif /* NPNP */ + +#endif diff --git a/sys/dev/pcm/isa/sb.h b/sys/dev/pcm/isa/sb.h new file mode 100644 index 000000000000..8548997353d2 --- /dev/null +++ b/sys/dev/pcm/isa/sb.h @@ -0,0 +1,387 @@ +/* + * file: sbcard.h + */ + +typedef struct _sbdev_info { + +} sbdev_info ; + +extern int sbc_major, sbc_minor ; +/* + * sound blaster registers + */ + +#define DSP_RESET (io_base + 0x6) +#define DSP_READ (io_base + 0xA) +#define DSP_WRITE (io_base + 0xC) +#define DSP_COMMAND (io_base + 0xC) +#define DSP_STATUS (io_base + 0xC) +#define DSP_DATA_AVAIL (io_base + 0xE) +#define DSP_DATA_AVL16 (io_base + 0xF) +#define MIXER_ADDR (io_base + 0x4) +#define MIXER_DATA (io_base + 0x5) +#define OPL3_LEFT (io_base + 0x0) +#define OPL3_RIGHT (io_base + 0x2) +#define OPL3_BOTH (io_base + 0x8) + +/* + * DSP Commands. There are many, and in many cases they are used explicitly + */ + +#define DSP_DAC8 0x10 /* direct DAC output */ +#define DSP_CMD_DAC8 0x14 /* single cycle 8-bit dma out */ +#define DSP_CMD_DAC2 0x16 /* 2-bit adpcm dma out (cont) */ +#define DSP_CMD_DAC2S 0x17 /* 2-bit adpcm dma out (start) */ + +#define DSP_CMD_DAC8_A 0x1c /* auto 8-bit dma out */ +#define DSP_CMD_DAC2S_A 0x1f /* auto 2-bit adpcm dma out (start) */ + +#define DSP_ADC8 0x20 /* direct ADC input */ + +#define DSP_CMD_ADC8 0x24 /* single cycle 8-bit dma in */ +#define DSP_CMD_ADC8_A 0x2c /* auto 8-bit dma out */ + +#define DSP_CMD_O16 0xb0 +#define DSP_CMD_I16 0xb8 +#define DSP_CMD_O8 0xc0 +#define DSP_CMD_I8 0xc8 + +#define DSP_MODE_U8MONO 0x00 +#define DSP_MODE_U8STEREO 0x20 +#define DSP_MODE_S16MONO 0x10 +#define DSP_MODE_S16STEREO 0x30 + +#define DSP_CMD_SPKON 0xD1 +#define DSP_CMD_SPKOFF 0xD3 +#define DSP_CMD_SPKR(on) (0xD1 | (on ? 0:2)) +#define DSP_CMD_DMAON 0xD0 /* ??? the comment says Halt DMA */ +#define DSP_CMD_DMAOFF 0xD4 /* ??? comment says continue dma */ + +#define DSP_CMD_DMAHALT 0xD0 +#define DSP_CMD_TCONST 0x40 /* set time constant */ +#define DSP_CMD_HSSIZE 0x48 /* high speed dma count */ +#define DSP_CMD_HSDAC 0x91 /* high speed dac */ +#define DSP_CMD_HSADC 0x99 /* high speed adc */ + +#define DSP_CMD_GETVER 0xE1 +#define DSP_CMD_GETID 0xE7 /* return id bytes */ + + /* prepare for dma input */ +#define DSP_CMD_DMAMODE(stereo, bit16) (0xA0 | (stereo ? 8:0) | (bit16 ? 4:0)) + +#define DSP_CMD_OUT16 0x41 /* send parms for dma out on sb16 */ +#define DSP_CMD_IN16 0x42 /* send parms for dma in on sb16 */ +#if 0 /*** unknown ***/ + /* + * D9 and D5 are used on the sb16 on close... maybe a reset of + * some subsystem ? + */ +#define DSP_CMD_D9 0xD9 +#define DSP_CMD_D5 0xD5 +#define DSP_CMD_FA 0xFA /* get version from prosonic*/ +#define DSP_CMD_FB 0xFB /* set irq/dma for prosonic*/ +#endif + +/* + * in fact, for the SB16, dma commands are as follows: + * + * cmd, mode, len_low, len_high. + * + * cmd is a combination of DSP_DMA16 or DSP_DMA8 and + */ + +#define DSP_DMA16 0xb0 +#define DSP_DMA8 0xc0 +# define DSP_F16_DAC 0x00 +# define DSP_F16_ADC 0x08 +# define DSP_F16_AUTO 0x04 +# define DSP_F16_FIFO_ON 0x02 + +/* + * mode is a combination of the following: + */ +#define DSP_F16_STEREO 0x20 +#define DSP_F16_SIGNED 0x10 + +#define IMODE_NONE 0 +#define IMODE_OUTPUT PCM_ENABLE_OUTPUT +#define IMODE_INPUT PCM_ENABLE_INPUT +#define IMODE_INIT 3 +#define IMODE_MIDI 4 + +#define NORMAL_MIDI 0 +#define UART_MIDI 1 + +/* + * values used for bd_flags in SoundBlaster driver + */ +#define BD_F_HISPEED 0x0001 /* doing high speed ... */ + +#define BD_F_JAZZ16 0x0002 /* jazz16 detected */ +#define BD_F_JAZZ16_2 0x0004 /* jazz16 type 2 */ + +#define BD_F_DUP_MIDI 0x0008 /* duplex midi */ + +#define BD_F_MIX_MASK 0x0070 /* up to 8 mixers (I know of 3) */ +#define BD_F_MIX_CT1335 0x0010 /* CT1335 */ +#define BD_F_MIX_CT1345 0x0020 /* CT1345 */ +#define BD_F_MIX_CT1745 0x0030 /* CT1745 */ + +#define BD_F_SB16 0x0100 /* this is a SB16 */ +#define BD_F_NOREC 0x0200 /* recording not supported on this board */ +#define BD_F_MIDIBUSY 0x0400 /* midi busy */ + + +/* + * sound/sb_mixer.h + * + * Definitions for the SB Pro and SB16 mixers + * + * Copyright by Hannu Savolainen 1993 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Modified: Hunyue Yau Jan 6 1994 Added defines for the Sound Galaxy NX Pro + * mixer. + * + */ + +#define SBPRO_RECORDING_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +/* Same as SB Pro, unless I find otherwise */ +#define SGNXPRO_RECORDING_DEVICES SBPRO_RECORDING_DEVICES + +#define SBPRO_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_VOLUME) + +/* + * SG NX Pro has treble and bass settings on the mixer. The 'speaker' channel + * is the COVOX/DisneySoundSource emulation volume control on the mixer. It + * does NOT control speaker volume. Should have own mask eventually? + */ +#define SGNXPRO_MIXER_DEVICES \ + (SBPRO_MIXER_DEVICES | SOUND_MASK_BASS | \ + SOUND_MASK_TREBLE | SOUND_MASK_SPEAKER ) + +#define SB16_RECORDING_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +#define SB16_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | \ + SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE) + +/* + * Mixer registers + * + * NOTE! RECORD_SRC == IN_FILTER + */ + +/* + * Mixer registers of SB Pro + */ +#define VOC_VOL 0x04 +#define MIC_VOL 0x0A +#define MIC_MIX 0x0A +#define RECORD_SRC 0x0C +#define IN_FILTER 0x0C +#define OUT_FILTER 0x0E +#define MASTER_VOL 0x22 +#define FM_VOL 0x26 +#define CD_VOL 0x28 +#define LINE_VOL 0x2E +#define IRQ_NR 0x80 +#define DMA_NR 0x81 +#define IRQ_STAT 0x82 + +/* + * Additional registers on the SG NX Pro + */ +#define COVOX_VOL 0x42 +#define TREBLE_LVL 0x44 +#define BASS_LVL 0x46 + +#define FREQ_HI (1 << 3)/* Use High-frequency ANFI filters */ +#define FREQ_LOW 0 /* Use Low-frequency ANFI filters */ +#define FILT_ON 0 /* Yes, 0 to turn it on, 1 for off */ +#define FILT_OFF (1 << 5) + +#define MONO_DAC 0x00 +#define STEREO_DAC 0x02 + +/* + * Mixer registers of SB16 + */ +#define SB16_IMASK_L 0x3d +#define SB16_IMASK_R 0x3e +#define SB16_OMASK 0x3c + + +#ifndef __SB_MIXER_C__ +mixer_tab sbpro_mix; +mixer_tab sb16_mix; +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix; +#endif +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES]; +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES]; +#else /* __SB_MIXER_C__ defined */ +mixer_tab sbpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0) +}; + +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x42, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0) +}; +#endif + +mixer_tab sb16_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x30, 3, 5, 0x31, 3, 5), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 4, 4, 0x47, 4, 4), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 4, 4, 0x45, 4, 4), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x34, 3, 5, 0x35, 3, 5), + PMIX_ENT(SOUND_MIXER_PCM, 0x32, 3, 5, 0x33, 3, 5), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x3b, 6, 2, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x38, 3, 5, 0x39, 3, 5), + PMIX_ENT(SOUND_MIXER_MIC, 0x3a, 3, 5, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x36, 3, 5, 0x37, 3, 5), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x3f, 6, 2, 0x40, 6, 2), /* Obsol,Use IGAIN*/ + PMIX_ENT(SOUND_MIXER_IGAIN, 0x3f, 6, 2, 0x40, 6, 2), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x41, 6, 2, 0x42, 6, 2) +}; + +#ifdef SM_GAMES /* Master volume is lower and PCM & FM + * volumes higher than with SB Pro. This + * improves the sound quality */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x2020, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x6464, /* FM */ + 0x6464, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x0000, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ + +#else /* If the user selected just plain SB Pro */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x5a5a, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x4b4b, /* FM */ + 0x4b4b, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x1010, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ +#endif /* SM_GAMES */ + +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x40, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x10, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x04, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x20, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x08, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x02, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +/* + * Recording sources (SB Pro) + */ +#endif /* __SB_MIXER_C__ */ + +#define SRC_MIC 1 /* Select Microphone recording source */ +#define SRC_CD 3 /* Select CD recording source */ +#define SRC_LINE 7 /* Use Line-in for recording source */ + + diff --git a/sys/dev/sound/isa/mss.c b/sys/dev/sound/isa/mss.c new file mode 100644 index 000000000000..97b328d098fe --- /dev/null +++ b/sys/dev/sound/isa/mss.c @@ -0,0 +1,1509 @@ +/* + * sound/ad1848.c + * + * Modified by Luigi Rizzo (luigi@iet.unipi.it) + * + * Driver for Microsoft Sound System/Windows Sound System (mss) + * -compatible boards. This includes: + * + * AD1848, CS4248 + * + * CS4231, used in the GUS MAX and some other cards; + * AD1845, CS4231A (CS4231-like) + * CS4232 (CS4231+SB and MPU, PnP) + * CS4236 (upgrade of the CS4232, has a better mixer) + * OPTi931 (WSS compatible, full duplex, some differences from CS42xx) + * + * Copyright Luigi Rizzo, 1997 + * Copyright by Hannu Savolainen 1994, 1995 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * + * Full data sheets in PDF format for the MSS-compatible chips + * are available at + * + * http://www.crystal.com/ for the CS42XX series, or + * http://www.opti.com/ for the OPTi931 + * + * The OPTi931 appears to be quite buggy. + */ + +#include +#if NPCM > 0 + +/* + * board-specific include files + */ + +#include + +/* + * prototypes for procedures exported in the device descriptor + */ + +static int mss_probe(struct isa_device *dev); +static int mss_attach(struct isa_device *dev); + +static d_open_t mss_open; +static d_close_t mss_close; +static d_ioctl_t mss_ioctl; +static irq_proc_t mss_intr; +static irq_proc_t opti931_intr; +static snd_callback_t mss_callback; + +/* + * prototypes for local functions + */ + +static void mss_reinit(snddev_info *d); +static int AD_WAIT_INIT(snddev_info *d, int x); +static int mss_mixer_set(snddev_info *d, int dev, int value); +static int mss_set_recsrc(snddev_info *d, int mask); +static void ad1848_mixer_reset(snddev_info *d); + +static void opti_write(int io_base, u_char reg, u_char data); +static u_char opti_read(int io_base, u_char reg); +static void ad_write(snddev_info *d, int reg, u_char data); +static void ad_write_cnt(snddev_info *d, int reg, u_short data); +static int ad_read(snddev_info *d, int reg); + +/* + * device descriptors for the boards supported by this module. + */ +snddev_info mss_op_desc = { + "mss", + + SNDCARD_MSS, + mss_probe, + mss_attach, + + mss_open, + mss_close, + NULL /* mss_read */, + NULL /* mss_write */, + mss_ioctl, + sndselect /* mss_select */, + + mss_intr, + mss_callback , + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | + AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW, /* audio formats */ + /* + * the enhanced boards also have AFMT_IMA_ADPCM | AFMT_S16_BE + */ +} ; + +/* + * this is the probe routine. Note, it is not necessary to + * go through this for PnP devices, since they are already + * indentified precisely using their PnP id. + * + * The base address supplied in the device refers to the old MSS + * specs where the four 4 registers in io space contain configuration + * information. Some boards (as an example, early MSS boards) + * has such a block of registers, whereas others (generally CS42xx) + * do not. In order to distinguish between the two and do not have + * to supply two separate probe routines, the flags entry in isa_device + * has a bit to mark this. + * + */ + +static int +mss_probe(struct isa_device *dev) +{ + u_char tmp; + int irq = ffs(dev->id_irq) - 1; + + if (dev->id_iobase == -1) { + dev->id_iobase = 0x530; + printf("mss_probe: no address supplied, try default 0x%x\n", + dev->id_iobase); + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if ( !(dev->id_flags & DV_F_TRUE_MSS) ) /* Has no IRQ/DMA registers */ + goto mss_probe_end; + + /* + * Check if the IO port returns valid signature. The original MS + * Sound system returns 0x04 while some cards + * (AudioTriX Pro for example) return 0x00 or 0x0f. + */ + + tmp = inb(dev->id_iobase + 3); + if (tmp == 0xff) { /* Bus float */ + DDB(printf("I/O address inactive (%x), try pseudo_mss\n", tmp)); + dev->id_flags &= ~DV_F_TRUE_MSS ; + goto mss_probe_end; + } + tmp &= 0x3f ; + if (tmp != 0x04 && tmp != 0x0f && tmp != 0x00) { + DDB(printf("No MSS signature detected on port 0x%x (0x%x)\n", + dev->id_iobase, inb(dev->id_iobase + 3))); + return 0; + } + if (irq > 11) { + printf("MSS: Bad IRQ %d\n", irq); + return 0; + } + if (dev->id_drq != 0 && dev->id_drq != 1 && dev->id_drq != 3) { + printf("MSS: Bad DMA %d\n", dev->id_drq); + return 0; + } + if (inb(dev->id_iobase + 3) & 0x80) { + /* 8-bit board: only drq1/3 and irq7/9 */ + if (dev->id_drq == 0) { + printf("MSS: Can't use DMA0 with a 8 bit card/slot\n"); + return 0; + } + if (irq != 7 && irq != 9) { + printf("MSS: Can't use IRQ%d with a 8 bit card/slot\n", irq); + return 0; + } + } +mss_probe_end: + return mss_detect(dev) ? 8 : 0 ; /* mss uses 8 regs */ +} + +/* + * the address passed as io_base for mss_attach is also the old + * MSS base address (e.g. 0x530). The codec is four locations ahead. + * Note that the attach routine for PnP devices might support + * device-specific initializations. + */ + +static int +mss_attach(struct isa_device *dev) +{ + snddev_info *d = &(pcm_info[dev->id_unit]); + + printf("mss_attach <%s>%d at 0x%x irq %d dma %d:%d flags 0x%x\n", + d->name, dev->id_unit, + d->io_base, d->irq, d->dma1, d->dma2, dev->id_flags); + + if ( dev->id_flags & DV_F_TRUE_MSS ) { + /* has IRQ/DMA registers, set IRQ and DMA addr */ + static char interrupt_bits[12] = { + -1, -1, -1, -1, -1, 0x28, -1, 0x08, -1, 0x10, 0x18, 0x20 + }; + static char dma_bits[4] = { 1, 2, 0, 3 }; + char bits ; + + if (d->irq == -1 || (bits = interrupt_bits[d->irq]) == -1) { + dev->id_irq = 0 ; /* makk invalid irq */ + return 0 ; + } + + outb(dev->id_iobase, bits | 0x40); /* config port */ + if ((inb(dev->id_iobase + 3) & 0x40) == 0) /* version port */ + printf("[IRQ Conflict?]"); + + /* Write IRQ+DMA setup */ + if (d->dma1 == d->dma2) /* single chan dma */ + outb(dev->id_iobase, bits | dma_bits[d->dma1]); + else { + if (d->dma1 == 0 && d->dma2 == 1) + bits |= 5 ; + else if (d->dma1 == 1 && d->dma2 == 0) + bits |= 6 ; + else if (d->dma1 == 3 && d->dma2 == 0) + bits |= 7 ; + else { + printf("invalid dual dma config %d:%d\n", + d->dma1, d->dma2); + dev->id_irq = 0 ; + return 0 ; + } + outb(dev->id_iobase, bits ); + } + } + mss_reinit(d); + ad1848_mixer_reset(d); + return 0; +} + +static int +mss_open(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf ; + d = &pcm_info[unit] ; + + s = spltty(); + /* + * This was meant to support up to 2 open descriptors for the + * some device, and check proper device usage on open. + * Unfortunately, the kernel will trap all close() calls but + * the last one, with the consequence that we cannot really + * keep track of which channels are busy. + * So, the correct tests cannot be done :( and we must rely + * on the locks on concurrent operations of the same type and + * on some approximate tests... + */ + + if (dev == SND_DEV_AUDIO) + d->flags |= SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags |= SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags |= SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY) ) { + /* + * device was idle. Do the necessary initialization, + * but no need keep interrupts blocked since this device + * will not get them + */ + + splx(s); + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + d->flags |= SND_F_BUSY ; + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + switch (dev) { + default : + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + case SND_DEV_DSP16 : + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + } + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + ask_init(d); + } + splx(s); + return 0 ; +} + +static int +mss_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf; + d = &pcm_info[unit] ; + + /* + * We will only get a single close call when the last reference + * to the device is gone. But we must handle ourselves references + * through different devices. + */ + + s = spltty(); + + if (dev == SND_DEV_AUDIO) + d->flags &= ~SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags &= ~SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags &= ~SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY_ANY) ) { /* last one ... */ + d->flags |= SND_F_CLOSING ; + splx(s); /* is this ok here ? */ + snd_flush(d); + outb(io_Status(d), 0); /* Clear interrupt status */ + d->flags = 0 ; + } + splx(s); + return 0 ; +} + +static int +mss_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + snddev_info *d; + int unit; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) { + cmd &= 0xff ; + if (cmd == SOUND_MIXER_RECSRC) + return mss_set_recsrc(d, *(int *)arg) ; + else + return mss_mixer_set(d, cmd, *(int *)arg) ; + } + + return ENOSYS ; /* fallback to the default ioctl handler */ +} + + +/* + * the callback routine to handle all dma ops etc. + */ + +static int +mss_callback(snddev_info *d, int reason) +{ + u_long s; + u_char m; + int retry, wr, cnt; + + DEB(printf("-- mss_callback reason 0x%03x\n", reason)); + wr = reason & SND_CB_WR ; + reason &= SND_CB_REASON_MASK ; + switch (reason) { + case SND_CB_INIT : /* called with int enabled and no pending I/O */ + /* + * perform all necessary initializations for i/o + */ + d->rec_fmt = d->play_fmt ; /* no split format on the WSS */ + snd_set_blocksize(d); + mss_reinit(d); + return 1 ; + break ; + + case SND_CB_START : + /* fallthrough */ + case SND_CB_RESTART : + s = spltty(); + cnt = wr ? d->dbuf_out.dl0 : d->dbuf_in.dl0 ; + if (d->play_fmt == AFMT_S16_LE) + cnt /= 2; + if (d->flags & SND_F_STEREO) + cnt /= 2; + cnt-- ; + + DEB(printf("-- (re)start cnt %d\n", cnt)); + m = ad_read(d,9) ; + DDB( if (m & 4) printf("OUCH! reg 9 0x%02x\n", m); ); + m |= wr ? I9_PEN : I9_CEN ; /* enable DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry; retry--) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to set bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, cnt); + else + ad_write_cnt(d, 30, cnt); + + splx(s); + break ; + case SND_CB_STOP : + case SND_CB_ABORT : /* XXX check this... */ + s = spltty(); + m = ad_read(d,9) ; + m &= wr ? ~I9_PEN : ~I9_CEN ; /* Stop DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry ; retry-- ) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to clear bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + + /* disable DMA by clearing count registers. */ + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, 0); + else + ad_write_cnt(d, 30, 0); + splx(s); + break; + } + return 0 ; +} + +/* + * main irq handler for the CS423x. The OPTi931 code is + * a separate one. + */ + +static void +mss_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char i11, c; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + + i11 = ad_read(d, 11); + reason = inb(io_Status(d)); + + if ( ! (reason & 1) ) /* no int, maybe a shared line ? */ + return; + /* get exact reason */ + c = (d->dma1 == d->dma2) ? 0x10 : ad_read(d, 24); + if ( (d->flags & SND_F_WR_DMA) && (c & 0x10) ) + dsp_wrintr(d); + c = (d->dma1 == d->dma2) ? 0x20 : ad_read(d, 24); + if ( (d->flags & SND_F_RD_DMA) && (c & 0x20) ) + dsp_rdintr(d); + /* XXX check this on the 4236... */ + if (d->dma1 == d->dma2) + outb(io_Status(d), 0); /* Clear interrupt status */ + else + ad_write(d, 24, ~c); /* ack selectively */ +} + +/* + * the opti931 seems to miss interrupts when working in full + * duplex. god know why... + */ +static void +opti931_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char masked=0, i11, mc11, c=0; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + int loops = 10; + int w_miss=0, r_miss=0; + static int misses=0; /* XXX kludge */ + +#if 0 + reason = inb(io_Status(d)); + if ( ! (reason & 1) ) {/* no int, maybe a shared line ? */ + printf("opti931_intr: flag 0, mcir11 0x%02x\n", ad_read(d,11)); + return; + } +#endif + i11 = ad_read(d, 11); /* XXX what's for ? */ +again: + + c=mc11 = (d->dma1 == d->dma2) ? 0xc : opti_read(d->conf_base, 11); + mc11 &= 0x0c ; + if (c & 0x10) { + printf("Warning CD interrupt\n"); + mc11 |= 0x10 ; + } + if (c & 0x20) { + printf("Warning MPU interrupt\n"); + mc11 |= 0x20 ; + } + if (mc11 & masked) + printf("irq reset failed, mc11 0x%02x, masked 0x%02x\n", mc11, masked); + masked |= mc11 ; + if ( mc11 == 0 ) { /* perhaps can return ... */ + reason = inb(io_Status(d)); + if (reason & 1) { + printf("one more try...\n"); + goto again; + } + if (w_miss || r_miss ) { + misses++; + if ( (misses & 0xff) == 1 ) + printf("opti931: %d missed irq (now %s%s)\n", + misses, w_miss?"play ":"", + r_miss?"capture ":""); + } + if (loops==10) + printf("ouch, intr but nothing in mcir11 0x%02x\n", mc11); + if (w_miss) mc11 |= 4 ; + if (r_miss) mc11 |= 8 ; + if (mc11==0) + return; + } + + if ( (d->flags & SND_F_RD_DMA) && (mc11 & 8) ) { + dsp_rdintr(d); + r_miss = 0 ; + } + else if (isa_dmastatus1(d->dma2) == 0 && (d->flags & SND_F_RD_DMA) ) + r_miss = 1 ; + + if ( (d->flags & SND_F_WR_DMA) && (mc11 & 4) ) { + if (isa_dmastatus1(d->dma1) != 0) + printf("opti931_intr: wr dma %d\n", + isa_dmastatus1(d->dma1)); + dsp_wrintr(d); + w_miss = 0 ; + } + else if (isa_dmastatus1(d->dma1) == 0 && (d->flags & SND_F_WR_DMA) ) + w_miss = 1 ; + + opti_write(d->conf_base, 11, ~mc11); /* ack */ + if (--loops) goto again; + printf("xxx too many loops\n"); +} + +/* + * Second part of the file: functions local to this module. + * in this section a few routines to access MSS registers + * + */ + +static void +opti_write(int io_base, u_char reg, u_char value) +{ + outb(io_base, reg); + outb(io_base+1, value); +} + +static u_char +opti_read(int io_base, u_char reg) +{ + outb(io_base, reg); + return inb(io_base+1); +} +/* + * AD_WAIT_INIT waits if we are initializing the board and + * we cannot modify its settings + */ +static int +AD_WAIT_INIT(snddev_info *d, int x) +{ + int n = 0; /* to shut up the compiler... */ + for (; x-- ; ) + if ( (n=inb(io_Index_Addr(d))) & IA_BUSY) + DELAY(10); + else + return n ; + printf("AD_WAIT_INIT FAILED 0x%02x\n", n); + return n ; +} + +static int +ad_read(snddev_info *d, int reg) +{ + u_long flags; + int x; + + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + x = inb(io_Indexed_Data(d)); + splx(flags); + return x; +} + +static void +ad_write(snddev_info *d, int reg, u_char data) +{ + u_long flags; + + int x ; + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + outb(io_Indexed_Data(d), data); + splx(flags); +} + +static void +ad_write_cnt(snddev_info *d, int reg, u_short cnt) +{ + ad_write(d, reg+1, cnt & 0xff ); + ad_write(d, reg, cnt >> 8 ); /* upper base must be last */ +} + +static void +wait_for_calibration(snddev_info *d) +{ + int n, t; + + /* + * Wait until the auto calibration process has finished. + * + * 1) Wait until the chip becomes ready (reads don't return 0x80). + * 2) Wait until the ACI bit of I11 gets on + * 3) Wait until the ACI bit of I11 gets off + */ + + n = AD_WAIT_INIT(d, 1000); + if (n & IA_BUSY) + printf("mss: Auto calibration timed out(1).\n"); + + for (t = 100 ; t>0 && (ad_read(d, 11) & 0x20) == 0 ; t--) + DELAY(100); + for (t = 100 ; t>0 && ad_read(d, 11) & 0x20 ; t--) + DELAY(100); +} + +#if 0 /* unused right now... */ +static void +ad_mute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) | I6_MUTE); + ad_write(d, 7, ad_read(d,7) | I6_MUTE); +} + +static void +ad_unmute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); +} +#endif + +static void +ad_enter_MCE(snddev_info *d) +{ + int prev; + + d->bd_flags |= BD_F_MCE_BIT; + AD_WAIT_INIT(d, 100); + prev = inb(io_Index_Addr(d)); + outb(io_Index_Addr(d), prev | IA_MCE | IA_TRD ) ; +} + +static void +ad_leave_MCE(snddev_info *d) +{ + u_long flags; + u_char prev; + + if ( (d->bd_flags & BD_F_MCE_BIT) == 0 ) { + printf("--- hey, leave_MCE: MCE bit was not set!\n"); + return; + } + + AD_WAIT_INIT(d, 1000); + + flags = spltty(); + d->bd_flags &= ~BD_F_MCE_BIT; + + prev = inb(io_Index_Addr(d)); + + outb(io_Index_Addr(d), (prev & ~IA_MCE) | IA_TRD); /* Clear the MCE bit */ + wait_for_calibration(d); + splx(flags); +} + +/* + * only one source can be set... + * + * fixed -- lr 970725 + */ +static int +mss_set_recsrc(snddev_info *d, int mask) +{ + u_char recdev; + + mask &= d->mix_rec_devs; + switch (mask) { + case SOUND_MASK_LINE: + case SOUND_MASK_LINE3: + recdev = 0; + break; + + case SOUND_MASK_CD: + case SOUND_MASK_LINE1: + recdev = 0x40; + break; + + case SOUND_MASK_IMIX: + recdev = 0xc0; + break; + + case SOUND_MASK_MIC: + default: + mask = SOUND_MASK_MIC; + recdev = 0x80; + } + + ad_write(d, 0, (ad_read(d, 0) & 0x3f) | recdev); + ad_write(d, 1, (ad_read(d, 1) & 0x3f) | recdev); + + d->mix_recsrc = mask; + return 0; +} + +/* + * mixer conversion table: from 0..100 scale to codec values + * + * I don't understand what's this for... maybe achieve a log-scale + * volume control ? + */ + +static char mix_cvt[101] = { + 0, 0, 3, 7,10,13,16,19,21,23,26,28,30,32,34,35,37,39,40,42, + 43,45,46,47,49,50,51,52,53,55,56,57,58,59,60,61,62,63,64,65, + 65,66,67,68,69,70,70,71,72,73,73,74,75,75,76,77,77,78,79,79, + 80,81,81,82,82,83,84,84,85,85,86,86,87,87,88,88,89,89,90,90, + 91,91,92,92,93,93,94,94,95,95,96,96,96,97,97,98,98,98,99,99, + 100 +}; + +/* + * there are differences in the mixer depending on the actual sound + * card. + */ +static int +mss_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + + int regoffs; + mixer_tab *mix_d = &mix_devices; + + u_char old, val; + + if (dev > 31) + return EINVAL; + + if (!(d->mix_devs & (1 << dev))) + return EINVAL; + + if (d->bd_id == MD_OPTI931) + mix_d = &(opti931_devices); + + if ((*mix_d)[dev][LEFT_CHN].nbits == 0) { + DDB(printf("nbits = 0 for dev %d\n", dev) ); + return EINVAL; + } + + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + + if ( (*mix_d)[dev][RIGHT_CHN].nbits == 0) /* Mono control */ + right = left; + + d->mix_levels[dev] = left | (right << 8); + + /* Scale volumes */ + left = mix_cvt[left]; + right = mix_cvt[right]; + + /* + * Set the left channel + */ + + regoffs = (*mix_d)[dev][LEFT_CHN].regno; + old = val = ad_read(d, regoffs); + if (regoffs != 0) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, LEFT_CHN, left); + ad_write(d, regoffs, val); + DEB(printf("dev %d reg %d old 0x%02x new 0x%02x\n", + dev, regoffs, old, val)); + + if ((*mix_d)[dev][RIGHT_CHN].nbits != 0) { /* have stereo */ + /* + * Set the right channel + */ + regoffs = (*mix_d)[dev][RIGHT_CHN].regno; + val = ad_read(d, regoffs); + if (regoffs != 1) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, RIGHT_CHN, right); + ad_write(d, regoffs, val); + } + return 0; /* success */ +} + +static void +ad1848_mixer_reset(snddev_info *d) +{ + int i; + + if (d->bd_id == MD_OPTI931) + d->mix_devs = OPTI931_MIXER_DEVICES; + else if (d->bd_id != MD_AD1848) + d->mix_devs = MODE2_MIXER_DEVICES; + else + d->mix_devs = MODE1_MIXER_DEVICES; + + d->mix_rec_devs = MODE1_REC_DEVICES; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + if (d->mix_devs & (1 << i)) + mss_mixer_set(d, i, default_mixer_levels[i]); + mss_set_recsrc(d, SOUND_MASK_MIC); +} + +/* + * mss_speed processes the value in play_speed finding the + * matching one. As a side effect, it returns the value to + * be written in the speed bits of the codec. It does _NOT_ + * set the speed of the device (but it should!) + * + * fixed lr970724 + */ + +static int +mss_speed(snddev_info *d) +{ + /* + * In the CS4231, the low 4 bits of I8 are used to hold the + * sample rate. Only a fixed number of values is allowed. This + * table lists them. The speed-setting routines scans the table + * looking for the closest match. This is the only supported method. + * + * In the CS4236, there is an alternate metod (which we do not + * support yet) which provides almost arbitrary frequency setting. + * In the AD1845, it looks like the sample rate can be + * almost arbitrary, and written directly to a register. + * In the OPTi931, there is a SB command which provides for + * almost arbitrary frequency setting. + * + */ + static int speeds[] = { + 8000, 5512, 16000, 11025, 27429, 18900, 32000, 22050, + -1, 37800, -1, 44100, 48000, 33075, 9600, 6615 + }; + + int arg, i, sel = 0; /* assume entry 0 does not contain -1 */ + + arg = d->play_speed ; + + for (i=1; i < 16 ; i++) + if (speeds[i] >0 && abs(arg-speeds[i]) < abs(arg-speeds[sel]) ) + sel = i ; + + d->play_speed = d->rec_speed = speeds[sel] ; + return sel ; +} + +/* + * mss_format checks that the format is supported (or defaults to AFMT_U8) + * and returns the bit setting for the 1848 register corresponding to + * the desired format. + * + * fixed lr970724 + */ + +static int +mss_format(snddev_info *d) +{ + int i, arg = d->play_fmt ; + + /* + * The data format uses 3 bits (just 2 on the 1848). For each + * bit setting, the following array returns the corresponding format. + * The code scans the array looking for a suitable format. In + * case it is not found, default to AFMT_U8 (not such a good + * choice, but let's do it for compatibility...). + */ + + static int fmts[] = { + AFMT_U8, AFMT_MU_LAW, AFMT_S16_LE, AFMT_A_LAW, + -1, AFMT_IMA_ADPCM, AFMT_U16_BE, -1 + }; + + if ( (arg & d->audio_fmt) == 0 ) /* unsupported fmt, default to AFMT_U8 */ + arg = AFMT_U8 ; + + /* ulaw/alaw seems broken on the opti931... */ + if (d->bd_id == MD_OPTI931) { + if (arg == AFMT_MU_LAW) { + arg = AFMT_U8 ; + d->flags |= SND_F_XLAT8 ; + } else + d->flags &= ~SND_F_XLAT8 ; + } + /* + * check that arg is one of the supported formats in d->format; + * otherwise fallback to AFMT_U8 + */ + + for (i=0 ; i<8 ; i++) + if (arg == fmts[i]) break; + if (i==8) { /* not found, default to AFMT_U8 */ + arg = AFMT_U8 ; + i = 0 ; + } + d->play_fmt = d->rec_fmt = arg; + + return i ; +} + +/* + * mss_detect can be used in the probe and the attach routine. + * + * We store probe information in pcm_info[unit]. This descriptor + * is reinitialized just before the attach, so all relevant + * information is lost, and mss_detect must be run again in + * the attach routine if necessary. + */ + +int +mss_detect(struct isa_device *dev) +{ + int i; + u_char tmp, tmp1, tmp2 ; + snddev_info *d = &(pcm_info[dev->id_unit]); + char *name; + + d->io_base = dev->id_iobase; + d->bd_flags |= BD_F_MCE_BIT ; + if (d->bd_id != 0) { + printf("preselected bd_id 0x%04x -- %s\n", + d->bd_id, d->name ? d->name : "???"); + return 1; + } + + name = "AD1848" ; + d->bd_id = MD_AD1848; /* AD1848 or CS4248 */ + + /* + * Check that the I/O address is in use. + * + * bit 7 of the base I/O port is known to be 0 after the chip has + * performed it's power on initialization. Just assume this has + * happened before the OS is starting. + * + * If the I/O address is unused, it typically returns 0xff. + */ + + for (i=0; i<10; i++) + if (inb(io_Index_Addr(d)) & IA_BUSY) + DELAY(10000); /* maybe busy, wait & retry later */ + else + break ; + if ((inb(io_Index_Addr(d)) & IA_BUSY) != 0x00) { /* Not a AD1848 */ + DDB(printf("mss_detect error, busy still set (0x%02x)\n", + inb(io_Index_Addr(d)))); + return 0; + } + /* + * Test if it's possible to change contents of the indirect + * registers. Registers 0 and 1 are ADC volume registers. The bit + * 0x10 is read only so try to avoid using it. + */ + + ad_write(d, 0, 0xaa); + ad_write(d, 1, 0x45);/* 0x55 with bit 0x10 clear */ + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + if ( tmp1 != 0xaa || tmp2 != 0x45) { + DDB(printf("mss_detect error - IREG (0x%02x/0x%02x) want 0xaa/0x45\n", + tmp1, tmp2)); + return 0; + } + + ad_write(d, 0, 0x45); + ad_write(d, 1, 0xaa); + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + + if (tmp1 != 0x45 || tmp2 != 0xaa) { + DDB(printf("mss_detect error - IREG2 (%x/%x)\n", tmp1, tmp2)); + return 0; + } + + /* + * The indirect register I12 has some read only bits. Lets try to + * change them. + */ + + tmp = ad_read(d, 12); + ad_write(d, 12, (~tmp) & 0x0f); + tmp1 = ad_read(d, 12); + + if ((tmp & 0x0f) != (tmp1 & 0x0f)) { + DDB(printf("mss_detect error - I12 (0x%02x was 0x%02x)\n", + tmp1, tmp)); + return 0; + } + + /* + * NOTE! Last 4 bits of the reg I12 tell the chip revision. + * 0x01=RevB + * 0x0A=RevC. also CS4231/CS4231A and OPTi931 + */ + + printf("mss_detect - chip revision 0x%02x\n", tmp & 0x0f); + + /* + * The original AD1848/CS4248 has just 16 indirect registers. This + * means that I0 and I16 should return the same value (etc.). Ensure + * that the Mode2 enable bit of I12 is 0. Otherwise this test fails + * with new parts. + */ + + ad_write(d, 12, 0); /* Mode2=disabled */ + + for (i = 0; i < 16; i++) + if ((tmp1 = ad_read(d, i)) != (tmp2 = ad_read(d, i + 16))) { + DDB(printf("mss_detect warning - I%d: 0x%02x/0x%02x\n", + i, tmp1, tmp2)); + /* + * note - this seems to fail on the 4232 on I11. So we just break + * rather than fail. + */ + break ; /* return 0; */ + } + /* + * Try to switch the chip to mode2 (CS4231) by setting the MODE2 bit + * (0x40). The bit 0x80 is always 1 in CS4248 and CS4231. + * + * On the OPTi931, however, I12 is readonly and only contains the + * chip revision ID (as in the CS4231A). The upper bits return 0. + */ + + ad_write(d, 12, 0x40); /* Set mode2, clear 0x80 */ + + tmp1 = ad_read(d, 12); + if (tmp1 & 0x80) { + name = "CS4248" ; /* Our best knowledge just now */ + } + if ((tmp1 & 0xf0) == 0x00) { + printf("this should be an OPTi931\n"); + } else if ((tmp1 & 0xc0) == 0xC0) { + /* + * The 4231 has bit7=1 always, and bit6 we just set to 1. + * We want to check that this is really a CS4231 + * Verify that setting I0 doesn't change I16. + */ + ad_write(d, 16, 0); /* Set I16 to known value */ + + ad_write(d, 0, 0x45); + if ((tmp1 = ad_read(d, 16)) != 0x45) { /* No change -> CS4231? */ + + ad_write(d, 0, 0xaa); + if ((tmp1 = ad_read(d, 16)) == 0xaa) { /* Rotten bits? */ + DDB(printf("mss_detect error - step H(%x)\n", tmp1)); + return 0; + } + /* + * Verify that some bits of I25 are read only. + */ + + DDB(printf("mss_detect() - step I\n")); + tmp1 = ad_read(d, 25); /* Original bits */ + ad_write(d, 25, ~tmp1); /* Invert all bits */ + if ((ad_read(d, 25) & 0xe7) == (tmp1 & 0xe7)) { + int id; + + /* + * It's at least CS4231 + */ + name = "CS4231" ; + d->bd_id = MD_CS4231; + + /* + * It could be an AD1845 or CS4231A as well. + * CS4231 and AD1845 report the same revision info in I25 + * while the CS4231A reports different. + */ + + id = ad_read(d, 25) & 0xe7; + /* + * b7-b5 = version number; + * 100 : all CS4231 + * 101 : CS4231A + * + * b2-b0 = chip id; + */ + switch (id) { + + case 0xa0: + name = "CS4231A" ; + d->bd_id = MD_CS4231A; + break; + + case 0xa2: + name = "CS4232" ; + d->bd_id = MD_CS4232; + break; + + case 0xb2: + /* strange: the 4231 data sheet says b4-b3 are XX + * so this should be the same as 0xa2 + */ + name = "CS4232A" ; + d->bd_id = MD_CS4232A; + break; + + case 0x80: + /* + * It must be a CS4231 or AD1845. The register I23 + * of CS4231 is undefined and it appears to be read + * only. AD1845 uses I23 for setting sample rate. + * Assume the chip is AD1845 if I23 is changeable. + */ + + tmp = ad_read(d, 23); + + ad_write(d, 23, ~tmp); + if (ad_read(d, 23) != tmp) { /* AD1845 ? */ + name = "AD1845" ; + d->bd_id = MD_AD1845; + } + ad_write(d, 23, tmp); /* Restore */ + break; + + case 0x83: /* CS4236 */ + name = "CS4236"; + d->bd_id = MD_CS4236; + break ; + + default: /* Assume CS4231 */ + printf("unknown id 0x%02x, assuming CS4231\n", id); + d->bd_id = MD_CS4231; + + } + } + ad_write(d, 25, tmp1); /* Restore bits */ + + } + } + DDB(printf("mss_detect() - Detected %s\n", name)); + strcpy(d->name, name); + dev->id_flags &= ~DV_F_DEV_MASK ; + dev->id_flags |= (d->bd_id << DV_F_DEV_SHIFT) & DV_F_DEV_MASK ; + return 1; +} + + +/* + * mss_reinit resets registers of the codec + */ +static void +mss_reinit(snddev_info *d) +{ + u_char r; + + r = mss_speed(d) ; + r |= (mss_format(d) << 5) ; + if (d->flags & SND_F_STEREO) + r |= 0x10 ; + /* XXX check if MCE is necessary... */ + ad_enter_MCE(d); + + /* + * perhaps this is not the place to set mode2, should be done + * only once at attach time... + */ + if ( d->dma1 != d->dma2 && d->bd_id != MD_OPTI931) + /* + * set mode2 bit for dual dma op. This bit is not implemented + * on the OPTi931 + */ + ad_write(d, 12, ad_read(d, 12) | 0x40 /* mode 2 on the CS42xx */ ); + + /* + * XXX this should really go into mss-speed... + */ + if (d->bd_id == MD_AD1845) { /* Use alternate speed select regs */ + r &= 0xf0; /* Mask off the rate select bits */ + + ad_write(d, 22, (d->play_speed >> 8) & 0xff); /* Speed MSB */ + ad_write(d, 23, d->play_speed & 0xff); /* Speed LSB */ + /* + * XXX must also do something in I27 for the ad1845 + */ + } + + ad_write(d, 8, r) ; + if (d->dma1 != d->dma2) { + ad_write(d, 28, r & 0xf0 ) ; /* capture mode */ + ad_write(d, 9, 0 /* no capture, no playback, dual dma */) ; + } else + ad_write(d, 9, 4 /* no capture, no playback, single dma */) ; + ad_leave_MCE(d); + ad_write_cnt(d, 14, 0 ); /* playback count */ + if (d->dma1 != d->dma2) + ad_write_cnt(d, 30, 0 ); /* rec. count on dual dma */ + + ad_write(d, 10, 2 /* int enable */) ; + outb(io_Status(d), 0); /* Clear interrupt status */ + /* the following seem required on the CS4232 */ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); + + snd_set_blocksize(d); /* update blocksize if user did not force it */ +} + +/* + * here we have support for PnP cards + * + */ + +#if NPNP > 0 + +static char * cs4236_probe(u_long csn, u_long vend_id); +static void cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device cs4236 = { + "cs423x", + cs4236_probe, + cs4236_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, cs4236); + +static char * +cs4236_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x3742630e) + s = "CS4237" ; + else if (vend_id == 0x3642630e) + s = "CS4236" ; + else if (vend_id == 0x3242630e) + s = "CS4232" ; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s; + } + + return NULL ; +} + +extern snddev_info sb_op_desc; + +static void +cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int ldn = 0 ; + + if (read_pnp_parms ( &d , ldn ) == 0 ) { + printf("failed to read pnp parms\n"); + return ; + } + snddev_last_probed = &tmp_d; +#if 0 + /* sb-compatible codec */ + dev->id_iobase = d.port[2] ; + tmp_d = sb_op_desc ; + tmp_d.alt_base = d.port[0] - 4; + d.drq[1] = 4 ; /* disable, it is not used ... */ + d.drq[0] = 0 ; /* remap ... */ +#else + /* mss-compatible codec */ + dev->id_iobase = d.port[0] -4 ; /* XXX old mss have 4 bytes before... */ + tmp_d = mss_op_desc ; + tmp_d.bd_id = MD_CS4232 ; /* to short-circuit the detect routine */ + tmp_d.alt_base = d.port[2]; + strcpy(tmp_d.name, name); + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; +#endif + write_pnp_parms( &d, ldn ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; /* during the probe... */ + snddev_last_probed->probe(dev); + + pcmattach(dev); +} + +static char *opti931_probe(u_long csn, u_long vend_id); +static void opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device opti931 = { + "OPTi931", + opti931_probe, + opti931_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti931); + +static char * +opti931_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x3109143e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 1); + if (d.enable == 0) { + printf("This is an OPTi931, but LDN 1 is disabled\n"); + return NULL ; + } + return "OPTi931" ; + } + return NULL ; +} + +static void +opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int p; + int sb_mode = 0 ; /* XXX still not work in SB mode */ + + read_pnp_parms ( &d , 3 ); /* free resources taken by LDN 3 */ + d.irq[0]=0; /* free irq... */ + d.port[0]=0; /* free address... */ + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + write_pnp_parms( &d, 1 ); + enable_pnp_card(); + + snddev_last_probed = &tmp_d; + tmp_d = sb_mode ? sb_op_desc : mss_op_desc ; + + strcpy(tmp_d.name, name); + + /* + * My MED3931 v.1.0 allocates 3 bytes for the config space, + * whereas v.2.0 allocates 4 bytes. What I know for sure is that the + * upper two ports must be used, and they should end on a boundary + * of 4 bytes. So I need the following trick... + */ + p = tmp_d.conf_base = (d.port[3] & ~3) + 2; /* config port */ + + /* + * now set default values for both modes. + */ + dev->id_iobase = d.port[0] - 4 ; /* old mss have 4 bytes before... */ + tmp_d.io_base = dev->id_iobase; /* needed for ad_write to work... */ + tmp_d.alt_base = d.port[2]; + opti_write(p, 4, 0x56 /* fifo 1/2, OPL3, audio enable, SB3.2 */ ); + ad_write (&tmp_d, 10, 2); /* enable interrupts */ + + if (sb_mode) { /* sb-compatible codec */ + /* + * the 931 is not a real SB, it has important pieces of + * hardware controlled by both the WSS and the SB port... + */ + opti_write(p, 6, 1); /* MCIR6 wss disable, sb enable */ + /* + * swap the main and alternate iobase address since we want + * to work in sb mode. + */ + dev->id_iobase = d.port[2] ; + tmp_d.alt_base = d.port[0] - 4; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + } else { /* mss-compatible codec */ + tmp_d.bd_id = MD_OPTI931 ; /* to short-circuit the detect routine */ + opti_write(p, 6 , 2); /* MCIR6: wss enable, sb disable */ +#if 0 /* not working yet... */ + opti_write(p, 5, 0x0 /* codec in single mode */ ); + dev->id_flags = 0 ; +#else + opti_write(p, 5, 0x28); /* MCIR5: codec in exp. mode,fifo */ + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; +#endif + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; /* not really well... */ + tmp_d.isr = opti931_intr; + } + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + pcmattach(dev); +} + +static char *guspnp_probe(u_long csn, u_long vend_id); +static void guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device guspnp = { + "GusPnP", + guspnp_probe, + guspnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, guspnp); + +static char * +guspnp_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x0100561e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a GusPnP, but LDN 0 is disabled\n"); + return NULL ; + } + return "GusPnP" ; + } + return NULL ; +} + +static void +guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + read_pnp_parms ( &d , 0 ) ; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + tmp_d = mss_op_desc ; + snddev_last_probed = &tmp_d; + + dev->id_iobase = d.port[2] - 4 ; /* room for 4 mss registers */ + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + + tmp_d.alt_base = d.port[0]; + + pcmattach(dev); +} +#endif /* NPNP > 0 */ +#endif /* NPCM > 0 */ diff --git a/sys/dev/sound/isa/mss.h b/sys/dev/sound/isa/mss.h new file mode 100644 index 000000000000..4b34e51ab713 --- /dev/null +++ b/sys/dev/sound/isa/mss.h @@ -0,0 +1,250 @@ +/* + * file: mss.h + * + * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it) + * + * This file contains information and macro definitions for + * AD1848-compatible devices, used in the MSS/WSS compatible boards. + * + */ + +/* + * + +The codec part of the board is seen as a set of 4 registers mapped +at the base address for the board (default 0x534). Note that some +(early) boards implemented 4 additional registers 4 location before +(usually 0x530) to store configuration information. This is a source +of confusion in that one never knows what address to specify. The +(current) convention is to use the old address (0x530) in the kernel +configuration file and consider MSS registers start four location +ahead. + + * + */ + +/* + * The four visible registers of the MSS : + * + */ + +#define io_Index_Addr(d) ((d)->io_base + 4) +#define IA_BUSY 0x80 /* readonly, set when busy */ +#define IA_MCE 0x40 /* the MCE bit. */ + /* + * the MCE bit must be set whenever the current mode of the + * codec is changed; this in particular is true for the + * Data Format (I8, I28) and Interface Config(I9) registers. + * Only exception are CEN and PEN which can be changed on the fly. + * The DAC output is muted when MCE is set. + */ +#define IA_TRD 0x20 /* Transfer request disable */ + /* + * When TRD is set, DMA transfers cease when the INT bit in + * the MSS status reg is set. Must be cleared for automode + * DMA, set otherwise. + */ +#define IA_AMASK 0x1f /* mask for indirect address */ + +#define io_Indexed_Data(d) ((d)->io_base+1+4) + /* + * data to be transferred to the indirect register addressed + * by index addr. During init and sw. powerdown, cannot be + * written to, and is always read as 0x80 (consistent with the + * busy flag). + */ + +#define io_Status(d) ((d)->io_base+2+4) + +#define IS_CUL 0x80 /* capture upper/lower */ +#define IS_CLR 0x40 /* capture left/right */ +#define IS_CRDY 0x20 /* capture ready for programmed i/o */ +#define IS_SER 0x10 /* sample error (overrun/underrun) */ +#define IS_PUL 0x08 /* playback upper/lower */ +#define IS_PLR 0x04 /* playback left/right */ +#define IS_PRDY 0x02 /* playback ready for programmed i/o */ +#define IS_INT 0x01 /* int status (1 = active) */ + /* + * IS_INT is clreared by any write to the status register. + */ + +#define io_Polled_IO(d) ((d)->io_base+3+4) + /* + * this register is used in case of polled i/o + */ + +/* + * The MSS has a set of 16 (or 32 depending on the model) indirect + * registers accessible through the data port by specifying the + * appropriate address in the address register. + * + * The 16 low registers are uniformly handled in AD1848/CS4248 compatible + * mode (often called MODE1). For the upper 16 registers there are + * some differences among different products, mainly Crystal uses them + * differently from OPTi. + * + */ + +/* + * volume registers + */ + +#define I6_MUTE 0x80 + +/* + * register I9 -- interface configuration. + */ + +#define I9_PEN 0x01 /* playback enable */ +#define I9_CEN 0x02 /* capture enable */ + +/* + * values used in bd_flags + */ +#define BD_F_MCE_BIT 0x0001 +#define BD_F_IRQ_OK 0x0002 +#define BD_F_TMR_RUN 0x0004 + + +/* + * sound/ad1848_mixer.h + * + * Definitions for the mixer of AD1848 and compatible codecs. + * + * Copyright by Hannu Savolainen 1994 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * The AD1848 codec has generic input lines called Line, Aux1 and Aux2. + * Soundcard manufacturers have connected actual inputs (CD, synth, line, + * etc) to these inputs in different order. Therefore it's difficult + * to assign mixer channels to to these inputs correctly. The following + * contains two alternative mappings. The first one is for GUS MAX and + * the second is just a generic one (line1, line2 and line3). + * (Actually this is not a mapping but rather some kind of interleaving + * solution). + */ +#define GUSMAX_MIXER +#ifdef GUSMAX_MIXER +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM|SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_SPEAKER | SOUND_MASK_IGAIN | \ + SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#else /* Generic mapping */ + +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE3 | SOUND_MASK_MIC | SOUND_MASK_LINE1|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_LINE3 | SOUND_MASK_SPEAKER | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) +#endif + +#define OPTI931_MIXER_DEVICES \ + (SOUND_MASK_VOLUME | SOUND_MASK_SYNTH | SOUND_MASK_PCM | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_IGAIN ) + +/* + * Most of the mixer entries work in backwards. Setting the polarity field + * makes them to work correctly. + * + * The channel numbering used by individual soundcards is not fixed. + * Some cards have assigned different meanings for the AUX1, AUX2 + * and LINE inputs. Some have different features... + * The current version doesn't try to compensate this. + * + */ + +mixer_ent mix_devices[32][2] = { /* As used in GUS MAX */ +MIX_ENT(SOUND_MIXER_VOLUME, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 6, 7, 1, 0, 6), +MIX_ENT(SOUND_MIXER_SPEAKER, 26, 1, 0, 4, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 0, 5, 19, 1, 0, 5), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_IMIX, 13, 1, 2, 6, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +mixer_ent opti931_devices[32][2] = { /* for the opti931 */ +MIX_ENT(SOUND_MIXER_VOLUME, 22, 1, 1, 5, 23, 1, 1, 5), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 1, 4, 5, 1, 1, 4), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 5, 7, 1, 0, 5), +MIX_ENT(SOUND_MIXER_SPEAKER, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 1, 4, 19, 1, 1, 4), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 1, 4, 3, 1, 1, 4), +MIX_ENT(SOUND_MIXER_IMIX, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +static u_short default_mixer_levels[SOUND_MIXER_NRDEVICES] = { + 0x5a5a, /* Master Volume */ + 0x3232, /* Bass */ + 0x3232, /* Treble */ + 0x4b4b, /* FM */ + 0x4040, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x2020, /* Ext Line */ + 0x4040, /* Mic */ + 0x4b4b, /* CD */ + 0x0000, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x2525, /* Input gain */ + 0x0000, /* Output gain */ + /* 0x4040, Line1 */ + 0x0000, /* Line1 */ + 0x0000, /* Line2 */ + 0x1515 /* Line3 (usually line in)*/ +}; + diff --git a/sys/dev/sound/isa/sb.c b/sys/dev/sound/isa/sb.c new file mode 100644 index 000000000000..4ca1f1f507fa --- /dev/null +++ b/sys/dev/sound/isa/sb.c @@ -0,0 +1,1080 @@ +/* + * sound/sb_dsp.c + * + * driver for the SoundBlaster and clones. + * + * Copyright 1997 Luigi Rizzo. + * + * Derived from files in the Voxware 3.5 distribution, + * Copyright by Hannu Savolainen 1994, under the same copyright + * conditions. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* + * use this as a template file for board-specific drivers. + * The next two lines (and the final #endif) are in all drivers: + */ + +#include +#if NPCM > 0 + +/* + * Begin with the board-specific include files... + */ + +#define __SB_MIXER_C__ /* XXX warning... */ +#include + +/* + * then prototypes of functions which go in the snddev_info + * (usually static, unless they are shared by other modules)... + */ + +static int sb_probe(struct isa_device *dev); +static int sb_attach(struct isa_device *dev); + +static d_open_t sb_dsp_open; +static d_close_t sb_dsp_close; +static d_ioctl_t sb_dsp_ioctl; +static irq_proc_t sbintr; +static snd_callback_t sb_callback; + +/* + * and prototypes for other private functions defined in this module. + */ + +static void sb_dsp_init(snddev_info *d, struct isa_device *dev); +static void sb_mix_init(snddev_info *d); +static int sb_mixer_set(snddev_info *d, int dev, int value); +static int dsp_speed(snddev_info *d); +static void sb_mixer_reset(snddev_info *d); + +u_int sb_get_byte(int io_base); + +/* + * Then put here the descriptors for the various boards supported + * by this module, properly initialized. + */ + +snddev_info sb_op_desc = { + "basic soundblaster", + + SNDCARD_SB, + sb_probe, + sb_attach, + + sb_dsp_open, + sb_dsp_close /* sb_close */, + NULL /* use generic sndread */, + NULL /* use generic sndwrite */, + sb_dsp_ioctl, + sndselect, + + sbintr, + sb_callback, + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | AFMT_U8, /* audio format */ + +} ; + +/* + * Then the file continues with the body of all functions + * directly referenced in the descriptor. + */ + +/* + * the probe routine for the SoundBlaster only consists in + * resetting the dsp and testing if it is there. + * Version detection etc. will be done at attach time. + * + * Remebber, isa probe routines are supposed to return the + * size of io space used. + */ + +static int +sb_probe(struct isa_device *dev) +{ + if (dev->id_iobase == -1) { + dev->id_iobase = 0x220; + printf("sb_probe: no address supplied, try defaults (0x220,0x240)\n"); + if (snd_conflict(dev->id_iobase)) + dev->id_iobase = 0x240; + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if (sb_reset_dsp(dev->id_iobase)) + return 16 ; /* the SB uses 16 registers... */ + else + return 0; +} + +static int +sb_attach(struct isa_device *dev) +{ + snddev_info *d = &pcm_info[dev->id_unit] ; + + sb_dsp_init(d, dev); + return 0 ; +} + +/* + * here are the main routines from the switches. + */ + +static int +sb_dsp_open(dev_t dev, int flags, int mode, struct proc * p) +{ + snddev_info *d; + int unit ; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + DEB(printf("<%s>%d : open\n", d->name, unit)); + + if (d->flags & SND_F_BUSY) { + printf("<%s>%d open: device busy\n", d->name, unit); + return EBUSY ; + } + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + d->flags = 0 ; + d->bd_flags &= ~BD_F_HISPEED ; + + switch ( dev & 0xf ) { + case SND_DEV_DSP16 : + if ((d->audio_fmt & AFMT_S16_LE) == 0) { + printf("sorry, 16-bit not supported on SB %d.%02d\n", + (d->bd_id >>8) & 0xff, d->bd_id & 0xff); + return ENXIO; + } + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + } + + d->flags |= SND_F_BUSY ; + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + sb_reset_dsp(d->io_base); + ask_init(d); + + return 0; +} + +static int +sb_dsp_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + s = spltty(); + d->flags |= SND_F_CLOSING ; + splx(s); + snd_flush(d); + + sb_cmd(d->io_base, DSP_CMD_SPKOFF ); /* XXX useless ? */ + + d->flags = 0 ; + return 0 ; +} + +static int +sb_dsp_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) + return sb_mixer_set(d, cmd & 0xff, *(int *)arg) ; + + /* + * for the remaining functions, use the default handler. + */ + + return ENOSYS ; +} + +static void +sbintr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + int reason = 3, c=1, io_base = d->io_base; + + DEB(printf("got sbintr for unit %d, flags 0x%08x\n", unit, d->flags)); + + /* + * SB < 4.0 is half duplex and has only 1 bit for int source, + * so we fake it. SB 4.x (SB16) has the int source in a separate + * register. + */ +again: + if (d->bd_flags & BD_F_SB16) { + c = sb_getmixer(io_base, IRQ_STAT); + /* this tells us if the source is 8-bit or 16-bit dma. We + * have to check the io channel to map it to read or write... + */ + reason = 0 ; + if ( c & 1 ) { /* 8-bit dma */ + if (d->dma1 < 4) + reason |= 1; + if (d->dma2 < 4) + reason |= 2; + } + if ( c & 2 ) { /* 16-bit dma */ + if (d->dma1 >= 4) + reason |= 1; + if (d->dma2 >= 4) + reason |= 2; + } + } + if ( c & 2 ) + inb(DSP_DATA_AVL16); /* 16-bit int ack */ + if (c & 1) + inb(DSP_DATA_AVAIL); /* 8-bit int ack */ + +DEB(printf("sbintr, flags 0x%08x reason %d\n", d->flags, reason)); + if ( (d->flags & SND_F_WR_DMA) && (reason & 1) ) + dsp_wrintr(d); + if ( (d->flags & SND_F_RD_DMA) && (reason & 2) ) + dsp_rdintr(d); + + /* + * the sb16 might have multiple sources etc. + */ + if (d->bd_flags & BD_F_SB16 && (c & 3) ) + goto again; +} + +/* + * device-specific function called back from the dma module. + * The reason of the callback is the second argument. + * NOTE: during operations, some ioctl can be done to change + * settings (e.g. speed, channels, format), and the default + * ioctl handler will just record the change and set the + * flag SND_F_INIT. The callback routine is in charge of applying + * the changes at the next convenient time (typically, at the + * start of operations). For full duplex devices, in some cases the + * init requires both channels to be idle. + */ +static int +sb_callback(snddev_info *d, int reason) +{ + u_long s ; + int rd = reason & SND_CB_RD ; + int l = (rd) ? d->dbuf_in.dl0 : d->dbuf_out.dl0 ; + + switch (reason & SND_CB_REASON_MASK) { + case SND_CB_INIT : /* called with int enabled and no pending io */ + dsp_speed(d); + snd_set_blocksize(d); + if (d->play_fmt & AFMT_MU_LAW) + d->flags |= SND_F_XLAT8 ; + else + d->flags &= ~SND_F_XLAT8 ; + return 1; + break ; + + case SND_CB_START : /* called with int disabled */ + sb_cmd(d->io_base, rd ? DSP_CMD_SPKOFF : DSP_CMD_SPKON); + d->flags &= ~SND_F_INIT ; + if (d->bd_flags & BD_F_SB16) { + /* the SB16 can do full duplex using one 16-bit channel + * and one 8-bit channel. It needs to be programmed to + * use split format though. + */ + int b16 ; + int swap = 0 ; + + b16 = (rd) ? d->rec_fmt : d->play_fmt ; + b16 = (b16 == AFMT_S16_LE) ? 1 : 0; + /* + * check if I have to swap dma channels. Swap if + * - !rd, dma1 <4, b16 + * - !rd, dma1 >=4, !b16 + * - rd, dma2 <4, b16 + * - rd, dma2 >=4, !b16 + */ + if (!rd) { + if ( (d->dma1 <4 && b16) || (d->dma1 >=4 && !b16) ) swap = 1; + } else { + if ( (d->dma2 <4 && b16) || (d->dma2 >=4 && !b16) ) swap = 1; + } + /* + * before swapping should make sure that there is no + * pending DMA on the other channel... + */ + if (swap) { + int c = d->dma2 ; + d->dma2 = d->dma1; + d->dma1 = c ; + } + DEB(printf("sb_init: play %d rec %d dma1 %d dma2 %d\n", + d->play_fmt, d->rec_fmt, d->dma1, d->dma2)); + } + /* fallthrough */ + case SND_CB_RESTART: + if (d->bd_flags & BD_F_SB16) { + u_char c, c1 ; + /* + * SB16 support still not completely working!!! + * + * in principle, on the SB16, I could support simultaneous + * play & rec. + * However, there is no way to ask explicitly for 8 or + * 16 bit transfer. As a consequence, if we do 8-bit, + * we need to use the 8-bit channel, and if we do 16-bit, + * we need to use the other one. The only way I find to + * do this is to swap d->dma1 and d->dma2 ... + * + */ + + if (rd) { + c = ((d->dma2 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_ADC ; + c1 = (d->play_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->rec_fmt == AFMT_S16_LE) + l /= 2 ; + } else { + c = ((d->dma1 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_DAC ; + c1 = (d->rec_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->play_fmt == AFMT_S16_LE) + l /= 2 ; + } + + if (d->flags & SND_F_STEREO) + c1 |= DSP_F16_STEREO ; + + sb_cmd(d->io_base, c ); + sb_cmd3(d->io_base, c1 , l - 1) ; + } else { + u_char c ; + if (d->bd_flags & BD_F_HISPEED) + c = (rd) ? DSP_CMD_HSADC : DSP_CMD_HSDAC ; + else + c = (rd) ? DSP_CMD_ADC8 : DSP_CMD_DAC8 ; + sb_cmd3(d->io_base, c , l - 1) ; + } + break; + + case SND_CB_STOP : + /* sb_cmd(d->io_base, DSP_CMD_SPKOFF); /* speaker off */ + break ; + + } + return 0 ; +} + +/* + * The second part of the file contains all functions specific to + * the board and (usually) not exported to other modules. + */ + +int +sb_reset_dsp(int io_base) +{ + int loopc; + + outb(DSP_RESET, 1); + DELAY(100); + outb(DSP_RESET, 0); + for (loopc = 0; loopc<100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++) + DELAY(30); + + if (inb(DSP_READ) != 0xAA) { + DEB(printf("sb_reset_dsp failed\n")); + return 0; /* Sorry */ + } + return 1; +} + +/* + * only used in sb_attach from here. + */ + +static void +sb_dsp_init(snddev_info *d, struct isa_device *dev) +{ + int i, x; + char *fmt = NULL ; + int io_base = dev->id_iobase ; + + d->bd_id = 0 ; + + sb_reset_dsp(io_base); + sb_cmd(io_base, DSP_CMD_GETVER); /* Get version */ + + for (i = 10000; i; i--) { /* perhaps wait longer on a fast machine ? */ + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if ( (d->bd_id & 0xff00) == 0) + d->bd_id = inb(DSP_READ) << 8; /* major */ + else { + d->bd_id |= inb(DSP_READ); /* minor */ + break; + } + } else + DELAY(20); + } + + /* + * now do various initializations depending on board id. + */ + + fmt = "SoundBlaster %d.%d" ; /* default */ + + switch ( d->bd_id >> 8 ) { + case 0 : + printf("\n\nFailed to get SB version (%x) - possible I/O conflict\n\n", + inb(DSP_DATA_AVAIL)); + d->bd_id = 0x100; + case 1 : /* old sound blaster has nothing... */ + break ; + + case 2 : + d->dma2 = d->dma1 ; /* half duplex */ + d->bd_flags |= BD_F_DUP_MIDI ; + + if (d->bd_id == 0x200) + break ; /* no mixer on the 2.0 */ + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1335 ; + + break ; + case 4 : + fmt = "SoundBlaster 16 %d.%d"; + d->audio_fmt |= AFMT_FULLDUPLEX | AFMT_WEIRD | AFMT_S8 | AFMT_S16_LE; + d->bd_flags |= BD_F_SB16; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1745 ; + + /* soft irq/dma configuration */ + x = -1 ; + if (d->irq == 5) x = 2; + else if (d->irq == 7) x = 4; + else if (d->irq == 9) x = 1; + else if (d->irq == 10) x = 8; + if (x == -1) + printf("<%s>%d: bad irq %d (only 5,7,9,10 allowed)\n", + d->name, dev->id_unit, d->irq); + else + sb_setmixer(io_base, IRQ_NR, x); + + sb_setmixer(io_base, DMA_NR, (1 << d->dma1) | (1 << d->dma2)); + break ; + + case 3 : + d->dma2 = d->dma1 ; /* half duplex */ + fmt = "SoundBlaster Pro %d.%d"; + d->bd_flags |= BD_F_DUP_MIDI ; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1345 ; + if (d->bd_id == 0x301) { + int ess_major = 0, ess_minor = 0; + + /* + * Try to detect ESS chips. + */ + + sb_cmd(io_base, DSP_CMD_GETID); /* Return ident. bytes. */ + + for (i = 1000; i; i--) { + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if (ess_major == 0) + ess_major = inb(DSP_READ); + else { + ess_minor = inb(DSP_READ); + break; + } + } + } + + if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS488 based card (rev %d)\n", + ess_minor & 0x0f); + else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS688 based card (rev %d)\n", + ess_minor & 0x0f); + } + + if (d->bd_flags & BD_F_JAZZ16) { + if (d->bd_flags & BD_F_JAZZ16_2) + fmt = "SoundMan Wave %d.%d"; + else + fmt = "MV Jazz16 %d.%d"; + d->audio_fmt |= AFMT_S16_LE; /* 16 bits */ + } + } + + sprintf(d->name, fmt, (d->bd_id >> 8) &0xff, d->bd_id & 0xff); + + sb_mix_init(d); +} + +static void +sb_mix_init(snddev_info *d) +{ + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : /* SB 3.0 has 1345 mixer */ + + d->mix_devs = SBPRO_MIXER_DEVICES ; + d->mix_rec_devs = SBPRO_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + + sb_setmixer(d->io_base, 0, 1 ); /* reset mixer */ + sb_setmixer(d->io_base, MIC_VOL , 0x6 ); /* mic volume max */ + sb_setmixer(d->io_base, RECORD_SRC , 0x0 ); /* mic source */ + sb_setmixer(d->io_base, FM_VOL , 0x0 ); /* no midi */ + break ; + + case BD_F_MIX_CT1745 : /* SB16 mixer ... */ + + d->mix_devs = SB16_MIXER_DEVICES ; + d->mix_rec_devs = SB16_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + } + sb_mixer_reset(d); +} + +/* + * Common code for the midi and pcm functions + */ + +int +sb_cmd(int io_base, u_char val) +{ + int i; + + for (i = 0; i < 1000 ; i++) { + if ((inb(DSP_STATUS) & 0x80) == 0) { + outb(DSP_COMMAND, val); + return 1; + } + if (i > 10) + DELAY (i > 100 ? 1000 : 10 ); + } + + printf("SoundBlaster: DSP Command(0x%02x) timeout. IRQ conflict ?\n", val); + return 0; +} + +int +sb_cmd3(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + sb_cmd(io_base, (val>>8) & 0xff ); + return 1 ; + } else + return 0; +} + +int +sb_cmd2(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + return 1 ; + } else + return 0; +} + +void +sb_setmixer(int io_base, u_int port, u_int value) +{ + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + outb(MIXER_DATA, (u_char) (value & 0xff)); + DELAY(10); + splx(flags); +} + +u_int +sb_get_byte(int io_base) +{ + int i; + + for (i = 1000; i; i--) + if (inb(DSP_DATA_AVAIL) & 0x80) + return inb(DSP_READ); + else + DELAY(20); + return 0xffff; +} + +int +sb_getmixer(int io_base, u_int port) +{ + int val; + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + val = inb(MIXER_DATA); + DELAY(10); + splx(flags); + + return val; +} + + +/* + * various utility functions for the DSP + */ + +/* + * dsp_speed updates the speed setting from the descriptor. make sure + * it is called at spltty(). + * Besides, it takes care of stereo setting. + */ +static int +dsp_speed(snddev_info *d) +{ + u_char tconst; + u_long flags; + int max_speed = 44100, speed = d->play_speed ; + + if (d->bd_flags & BD_F_SB16) { + RANGE (speed, 5000, 45000); + d->play_speed = d->rec_speed = speed ; + sb_cmd(d->io_base, 0x41); + sb_cmd(d->io_base, d->play_speed >> 8 ); + sb_cmd(d->io_base, d->play_speed & 0xff ); + sb_cmd(d->io_base, 0x42); + sb_cmd(d->io_base, d->rec_speed >> 8 ); + sb_cmd(d->io_base, d->rec_speed & 0xff ); + return speed ; + } + /* + * only some models can do stereo, and only if not + * simultaneously using midi. + */ + if ( (d->bd_id & 0xff00) < 0x300 || d->bd_flags & BD_F_MIDIBUSY) + d->flags &= ~SND_F_STEREO; + + /* + * here enforce speed limitations. + */ + if (d->bd_id <= 0x200) + max_speed = 22050; /* max 22050 on SB 1.X */ + + /* + * SB models earlier than SB Pro have low limit for the + * input rate. Note that this is only for input, but since + * we do not support separate values for rec & play.... + */ + if (d->bd_id <= 0x200) + max_speed = 13000; + else if (d->bd_id < 0x300) + max_speed = 15000; + + RANGE(speed, 4000, max_speed); + + /* + * Logitech SoundMan Games and Jazz16 cards can support 44.1kHz + * stereo + */ +#if !defined (SM_GAMES) + /* + * Max. stereo speed is 22050 + */ + if (d->flags & SND_F_STEREO && speed > 22050 && !(d->bd_flags & BD_F_JAZZ16)) + speed = 22050; +#endif + + if ((speed > 22050) && d->bd_flags & BD_F_MIDIBUSY) + speed = 22050; + + if (d->flags & SND_F_STEREO) + speed *= 2; + + /* + * Now the speed should be valid. Compute the value to be + * programmed into the board. + */ + + if (speed > 22050) { /* High speed mode on 2.01/3.xx */ + int tmp; + + tconst = (u_char) ((65536 - ((256000000 + speed / 2) / speed)) >> 8); + d->bd_flags |= BD_F_HISPEED ; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 65536 - (tconst << 8); + speed = (256000000 + tmp / 2) / tmp; + } else { + int tmp; + + d->bd_flags &= ~BD_F_HISPEED ; + tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 256 - tconst; + speed = (1000000 + tmp / 2) / tmp; + } + + if (d->flags & SND_F_STEREO) + speed /= 2; + + d->play_speed = d->rec_speed = speed; + return speed; +} + +/* + * mixer support, originally in sb_mixer.c + */ + +static void +sb_set_recsrc(snddev_info *d, int mask) +{ + u_char outmask; + u_char recdev ; + + mask &= d->mix_rec_devs; + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : + if (mask == SOUND_MASK_LINE) + recdev = 6 ; + else if (mask == SOUND_MASK_CD) + recdev = 2 ; + else { /* default: mic */ + mask = SOUND_MASK_MIC ; + recdev = 0 ; + } + sb_setmixer(d->io_base, RECORD_SRC, + recdev | (sb_getmixer(d->io_base, RECORD_SRC) & ~7 )); + break ; + case BD_F_MIX_CT1745 : /* sb16 */ + if (mask == 0) + mask = SOUND_MASK_MIC ; /* XXX For compatibility. Bug ? */ + recdev = 0 ; + if (mask & SOUND_MASK_MIC) + recdev |= 1 ; + if (mask & SOUND_MASK_CD) + recdev |= 6 ; /* l+r cd */ + if (mask & SOUND_MASK_LINE) + recdev |= 0x18 ; /* l+r line */ + if (mask & SOUND_MASK_SYNTH) + recdev |= 0x60 ; /* l+r midi */ + sb_setmixer(d->io_base, SB16_IMASK_L, recdev); + sb_setmixer(d->io_base, SB16_IMASK_R, recdev); + /* + * since the same volume controls apply to the input and + * output sections, the best approach to have a consistent + * behaviour among cards would be to disable the output path + * on devices which are used to record. + * However, since users like to have feedback, we only disable + * the mike -- permanently. + */ + sb_setmixer(d->io_base, SB16_OMASK, 0x1f & ~1); + break ; + } + d->mix_recsrc = mask; +} + +static void +sb_mixer_reset(snddev_info *d) +{ + int i; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + sb_mixer_set(d, i, levels[i]); + if (d->bd_flags & BD_F_SB16) { + sb_setmixer(d->io_base, 0x3c, 0x1f); /* make all output active */ + sb_setmixer(d->io_base, 0x3d, 0); /* make all inputs-l off */ + sb_setmixer(d->io_base, 0x3e, 0); /* make all inputs-r off */ + } + sb_set_recsrc(d, SOUND_MASK_MIC); +} + +static int +sb_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + int regoffs; + u_char val; + mixer_tab *iomap; + +#ifdef JAZZ16 + if (d->bd_flags & BD_F_JAZZ16 && d->bd_flags & BD_F_JAZZ16_2) + return smw_mixer_set(dev, value); +#endif + + if (dev == SOUND_MIXER_RECSRC) { + sb_set_recsrc(d, value); + return 0 ; + } + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + if (dev > 31) + return EINVAL ; + + if (!(d->mix_devs & (1 << dev))) /* Not supported */ + return EINVAL; + + switch ( d->bd_flags & BD_F_MIX_MASK ) { + default: + /* mixer unknown, fail... */ + return EINVAL ;/* XXX change this */ + case BD_F_MIX_CT1345 : + iomap = &sbpro_mix ; + break; + case BD_F_MIX_CT1745 : + iomap = &sb16_mix ; + break; + /* XXX how about the SG NX Pro, iomap = sgnxpro_mix */ + } + regoffs = (*iomap)[dev][LEFT_CHN].regno; + if (regoffs == 0) + return EINVAL; + + val = sb_getmixer(d->io_base, regoffs); + + change_bits(iomap, &val, dev, LEFT_CHN, left); + + d->mix_levels[dev] = left | (left << 8); + + if ((*iomap)[dev][RIGHT_CHN].regno != regoffs) { /* Change register */ + sb_setmixer(d->io_base, regoffs, val); /* Save the old one */ + regoffs = (*iomap)[dev][RIGHT_CHN].regno; + + if (regoffs == 0) + return 0 ; /* Just left channel present */ + + val = sb_getmixer(d->io_base, regoffs); /* Read the new one */ + } + change_bits(iomap, &val, dev, RIGHT_CHN, right); + + sb_setmixer(d->io_base, regoffs, val); + + d->mix_levels[dev] = left | (right << 8); + return 0 ; /* ok */ +} + +/* + * now support for some PnP boards. + */ + +#if NPNP > 0 +static char *opti925_probe(u_long csn, u_long vend_id); +static void opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device opti925 = { + "opti925", + opti925_probe, + opti925_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti925); + +static char * +opti925_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x2509143e) { + struct pnp_cinfo d ; + read_pnp_parms ( &d , 1 ) ; + if (d.enable == 0) { + printf("This is an OPTi925, but LDN 1 is disabled\n"); + return NULL; + } + return "OPTi925" ; + } + return NULL ; +} + +static void +opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int the_irq = 0 ; + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 3 ); /* disable LDN 3 */ + the_irq = d.irq[0]; + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + d.irq[0] = the_irq ; + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 1 ); + enable_pnp_card(); + + tmp_d.conf_base = d.port[3]; + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); + +} + +/* + * A driver for some SB16pnp and compatibles... + * + * Avance Asound 100 -- 0x01009305 + * xxx -- 0x2b008c0e + * + */ + +static char *sb16pnp_probe(u_long csn, u_long vend_id); +static void sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device sb16pnp = { + "SB16pnp", + sb16pnp_probe, + sb16pnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, sb16pnp); + +static char * +sb16pnp_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x01009305) + s = "Avance Asound 100" ; + if (vend_id == 0x2b008c0e) + s = "SB16 Value PnP" ; + /* + * The SB16/AWE64 cards seem to differ in the fourth byte of + * the vendor id, so I have just masked it for the time being... + * Reported values are: + * SB16 Value PnP: 0x2b008c0e + * SB AWE64 PnP: 0x39008c0e 0x9d008c0e 0xc3008c0e + */ + if ( (vend_id & 0xffffff) == (0x9d008c0e & 0xffffff) ) + s = "SB AWE64 PnP"; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s ; + } + return NULL ; +} + +static void +sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 0 ) ; + d.port[1] = 0 ; /* only the first address is used */ + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); +} +#endif /* NPNP */ + +#endif diff --git a/sys/dev/sound/isa/sb.h b/sys/dev/sound/isa/sb.h new file mode 100644 index 000000000000..8548997353d2 --- /dev/null +++ b/sys/dev/sound/isa/sb.h @@ -0,0 +1,387 @@ +/* + * file: sbcard.h + */ + +typedef struct _sbdev_info { + +} sbdev_info ; + +extern int sbc_major, sbc_minor ; +/* + * sound blaster registers + */ + +#define DSP_RESET (io_base + 0x6) +#define DSP_READ (io_base + 0xA) +#define DSP_WRITE (io_base + 0xC) +#define DSP_COMMAND (io_base + 0xC) +#define DSP_STATUS (io_base + 0xC) +#define DSP_DATA_AVAIL (io_base + 0xE) +#define DSP_DATA_AVL16 (io_base + 0xF) +#define MIXER_ADDR (io_base + 0x4) +#define MIXER_DATA (io_base + 0x5) +#define OPL3_LEFT (io_base + 0x0) +#define OPL3_RIGHT (io_base + 0x2) +#define OPL3_BOTH (io_base + 0x8) + +/* + * DSP Commands. There are many, and in many cases they are used explicitly + */ + +#define DSP_DAC8 0x10 /* direct DAC output */ +#define DSP_CMD_DAC8 0x14 /* single cycle 8-bit dma out */ +#define DSP_CMD_DAC2 0x16 /* 2-bit adpcm dma out (cont) */ +#define DSP_CMD_DAC2S 0x17 /* 2-bit adpcm dma out (start) */ + +#define DSP_CMD_DAC8_A 0x1c /* auto 8-bit dma out */ +#define DSP_CMD_DAC2S_A 0x1f /* auto 2-bit adpcm dma out (start) */ + +#define DSP_ADC8 0x20 /* direct ADC input */ + +#define DSP_CMD_ADC8 0x24 /* single cycle 8-bit dma in */ +#define DSP_CMD_ADC8_A 0x2c /* auto 8-bit dma out */ + +#define DSP_CMD_O16 0xb0 +#define DSP_CMD_I16 0xb8 +#define DSP_CMD_O8 0xc0 +#define DSP_CMD_I8 0xc8 + +#define DSP_MODE_U8MONO 0x00 +#define DSP_MODE_U8STEREO 0x20 +#define DSP_MODE_S16MONO 0x10 +#define DSP_MODE_S16STEREO 0x30 + +#define DSP_CMD_SPKON 0xD1 +#define DSP_CMD_SPKOFF 0xD3 +#define DSP_CMD_SPKR(on) (0xD1 | (on ? 0:2)) +#define DSP_CMD_DMAON 0xD0 /* ??? the comment says Halt DMA */ +#define DSP_CMD_DMAOFF 0xD4 /* ??? comment says continue dma */ + +#define DSP_CMD_DMAHALT 0xD0 +#define DSP_CMD_TCONST 0x40 /* set time constant */ +#define DSP_CMD_HSSIZE 0x48 /* high speed dma count */ +#define DSP_CMD_HSDAC 0x91 /* high speed dac */ +#define DSP_CMD_HSADC 0x99 /* high speed adc */ + +#define DSP_CMD_GETVER 0xE1 +#define DSP_CMD_GETID 0xE7 /* return id bytes */ + + /* prepare for dma input */ +#define DSP_CMD_DMAMODE(stereo, bit16) (0xA0 | (stereo ? 8:0) | (bit16 ? 4:0)) + +#define DSP_CMD_OUT16 0x41 /* send parms for dma out on sb16 */ +#define DSP_CMD_IN16 0x42 /* send parms for dma in on sb16 */ +#if 0 /*** unknown ***/ + /* + * D9 and D5 are used on the sb16 on close... maybe a reset of + * some subsystem ? + */ +#define DSP_CMD_D9 0xD9 +#define DSP_CMD_D5 0xD5 +#define DSP_CMD_FA 0xFA /* get version from prosonic*/ +#define DSP_CMD_FB 0xFB /* set irq/dma for prosonic*/ +#endif + +/* + * in fact, for the SB16, dma commands are as follows: + * + * cmd, mode, len_low, len_high. + * + * cmd is a combination of DSP_DMA16 or DSP_DMA8 and + */ + +#define DSP_DMA16 0xb0 +#define DSP_DMA8 0xc0 +# define DSP_F16_DAC 0x00 +# define DSP_F16_ADC 0x08 +# define DSP_F16_AUTO 0x04 +# define DSP_F16_FIFO_ON 0x02 + +/* + * mode is a combination of the following: + */ +#define DSP_F16_STEREO 0x20 +#define DSP_F16_SIGNED 0x10 + +#define IMODE_NONE 0 +#define IMODE_OUTPUT PCM_ENABLE_OUTPUT +#define IMODE_INPUT PCM_ENABLE_INPUT +#define IMODE_INIT 3 +#define IMODE_MIDI 4 + +#define NORMAL_MIDI 0 +#define UART_MIDI 1 + +/* + * values used for bd_flags in SoundBlaster driver + */ +#define BD_F_HISPEED 0x0001 /* doing high speed ... */ + +#define BD_F_JAZZ16 0x0002 /* jazz16 detected */ +#define BD_F_JAZZ16_2 0x0004 /* jazz16 type 2 */ + +#define BD_F_DUP_MIDI 0x0008 /* duplex midi */ + +#define BD_F_MIX_MASK 0x0070 /* up to 8 mixers (I know of 3) */ +#define BD_F_MIX_CT1335 0x0010 /* CT1335 */ +#define BD_F_MIX_CT1345 0x0020 /* CT1345 */ +#define BD_F_MIX_CT1745 0x0030 /* CT1745 */ + +#define BD_F_SB16 0x0100 /* this is a SB16 */ +#define BD_F_NOREC 0x0200 /* recording not supported on this board */ +#define BD_F_MIDIBUSY 0x0400 /* midi busy */ + + +/* + * sound/sb_mixer.h + * + * Definitions for the SB Pro and SB16 mixers + * + * Copyright by Hannu Savolainen 1993 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Modified: Hunyue Yau Jan 6 1994 Added defines for the Sound Galaxy NX Pro + * mixer. + * + */ + +#define SBPRO_RECORDING_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +/* Same as SB Pro, unless I find otherwise */ +#define SGNXPRO_RECORDING_DEVICES SBPRO_RECORDING_DEVICES + +#define SBPRO_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_VOLUME) + +/* + * SG NX Pro has treble and bass settings on the mixer. The 'speaker' channel + * is the COVOX/DisneySoundSource emulation volume control on the mixer. It + * does NOT control speaker volume. Should have own mask eventually? + */ +#define SGNXPRO_MIXER_DEVICES \ + (SBPRO_MIXER_DEVICES | SOUND_MASK_BASS | \ + SOUND_MASK_TREBLE | SOUND_MASK_SPEAKER ) + +#define SB16_RECORDING_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +#define SB16_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | \ + SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE) + +/* + * Mixer registers + * + * NOTE! RECORD_SRC == IN_FILTER + */ + +/* + * Mixer registers of SB Pro + */ +#define VOC_VOL 0x04 +#define MIC_VOL 0x0A +#define MIC_MIX 0x0A +#define RECORD_SRC 0x0C +#define IN_FILTER 0x0C +#define OUT_FILTER 0x0E +#define MASTER_VOL 0x22 +#define FM_VOL 0x26 +#define CD_VOL 0x28 +#define LINE_VOL 0x2E +#define IRQ_NR 0x80 +#define DMA_NR 0x81 +#define IRQ_STAT 0x82 + +/* + * Additional registers on the SG NX Pro + */ +#define COVOX_VOL 0x42 +#define TREBLE_LVL 0x44 +#define BASS_LVL 0x46 + +#define FREQ_HI (1 << 3)/* Use High-frequency ANFI filters */ +#define FREQ_LOW 0 /* Use Low-frequency ANFI filters */ +#define FILT_ON 0 /* Yes, 0 to turn it on, 1 for off */ +#define FILT_OFF (1 << 5) + +#define MONO_DAC 0x00 +#define STEREO_DAC 0x02 + +/* + * Mixer registers of SB16 + */ +#define SB16_IMASK_L 0x3d +#define SB16_IMASK_R 0x3e +#define SB16_OMASK 0x3c + + +#ifndef __SB_MIXER_C__ +mixer_tab sbpro_mix; +mixer_tab sb16_mix; +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix; +#endif +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES]; +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES]; +#else /* __SB_MIXER_C__ defined */ +mixer_tab sbpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0) +}; + +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x42, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0) +}; +#endif + +mixer_tab sb16_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x30, 3, 5, 0x31, 3, 5), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 4, 4, 0x47, 4, 4), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 4, 4, 0x45, 4, 4), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x34, 3, 5, 0x35, 3, 5), + PMIX_ENT(SOUND_MIXER_PCM, 0x32, 3, 5, 0x33, 3, 5), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x3b, 6, 2, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x38, 3, 5, 0x39, 3, 5), + PMIX_ENT(SOUND_MIXER_MIC, 0x3a, 3, 5, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x36, 3, 5, 0x37, 3, 5), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x3f, 6, 2, 0x40, 6, 2), /* Obsol,Use IGAIN*/ + PMIX_ENT(SOUND_MIXER_IGAIN, 0x3f, 6, 2, 0x40, 6, 2), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x41, 6, 2, 0x42, 6, 2) +}; + +#ifdef SM_GAMES /* Master volume is lower and PCM & FM + * volumes higher than with SB Pro. This + * improves the sound quality */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x2020, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x6464, /* FM */ + 0x6464, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x0000, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ + +#else /* If the user selected just plain SB Pro */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x5a5a, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x4b4b, /* FM */ + 0x4b4b, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x1010, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ +#endif /* SM_GAMES */ + +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x40, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x10, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x04, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x20, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x08, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x02, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +/* + * Recording sources (SB Pro) + */ +#endif /* __SB_MIXER_C__ */ + +#define SRC_MIC 1 /* Select Microphone recording source */ +#define SRC_CD 3 /* Select CD recording source */ +#define SRC_LINE 7 /* Use Line-in for recording source */ + + diff --git a/sys/dev/sound/isa/sb16.c b/sys/dev/sound/isa/sb16.c new file mode 100644 index 000000000000..4ca1f1f507fa --- /dev/null +++ b/sys/dev/sound/isa/sb16.c @@ -0,0 +1,1080 @@ +/* + * sound/sb_dsp.c + * + * driver for the SoundBlaster and clones. + * + * Copyright 1997 Luigi Rizzo. + * + * Derived from files in the Voxware 3.5 distribution, + * Copyright by Hannu Savolainen 1994, under the same copyright + * conditions. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* + * use this as a template file for board-specific drivers. + * The next two lines (and the final #endif) are in all drivers: + */ + +#include +#if NPCM > 0 + +/* + * Begin with the board-specific include files... + */ + +#define __SB_MIXER_C__ /* XXX warning... */ +#include + +/* + * then prototypes of functions which go in the snddev_info + * (usually static, unless they are shared by other modules)... + */ + +static int sb_probe(struct isa_device *dev); +static int sb_attach(struct isa_device *dev); + +static d_open_t sb_dsp_open; +static d_close_t sb_dsp_close; +static d_ioctl_t sb_dsp_ioctl; +static irq_proc_t sbintr; +static snd_callback_t sb_callback; + +/* + * and prototypes for other private functions defined in this module. + */ + +static void sb_dsp_init(snddev_info *d, struct isa_device *dev); +static void sb_mix_init(snddev_info *d); +static int sb_mixer_set(snddev_info *d, int dev, int value); +static int dsp_speed(snddev_info *d); +static void sb_mixer_reset(snddev_info *d); + +u_int sb_get_byte(int io_base); + +/* + * Then put here the descriptors for the various boards supported + * by this module, properly initialized. + */ + +snddev_info sb_op_desc = { + "basic soundblaster", + + SNDCARD_SB, + sb_probe, + sb_attach, + + sb_dsp_open, + sb_dsp_close /* sb_close */, + NULL /* use generic sndread */, + NULL /* use generic sndwrite */, + sb_dsp_ioctl, + sndselect, + + sbintr, + sb_callback, + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | AFMT_U8, /* audio format */ + +} ; + +/* + * Then the file continues with the body of all functions + * directly referenced in the descriptor. + */ + +/* + * the probe routine for the SoundBlaster only consists in + * resetting the dsp and testing if it is there. + * Version detection etc. will be done at attach time. + * + * Remebber, isa probe routines are supposed to return the + * size of io space used. + */ + +static int +sb_probe(struct isa_device *dev) +{ + if (dev->id_iobase == -1) { + dev->id_iobase = 0x220; + printf("sb_probe: no address supplied, try defaults (0x220,0x240)\n"); + if (snd_conflict(dev->id_iobase)) + dev->id_iobase = 0x240; + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if (sb_reset_dsp(dev->id_iobase)) + return 16 ; /* the SB uses 16 registers... */ + else + return 0; +} + +static int +sb_attach(struct isa_device *dev) +{ + snddev_info *d = &pcm_info[dev->id_unit] ; + + sb_dsp_init(d, dev); + return 0 ; +} + +/* + * here are the main routines from the switches. + */ + +static int +sb_dsp_open(dev_t dev, int flags, int mode, struct proc * p) +{ + snddev_info *d; + int unit ; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + DEB(printf("<%s>%d : open\n", d->name, unit)); + + if (d->flags & SND_F_BUSY) { + printf("<%s>%d open: device busy\n", d->name, unit); + return EBUSY ; + } + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + d->flags = 0 ; + d->bd_flags &= ~BD_F_HISPEED ; + + switch ( dev & 0xf ) { + case SND_DEV_DSP16 : + if ((d->audio_fmt & AFMT_S16_LE) == 0) { + printf("sorry, 16-bit not supported on SB %d.%02d\n", + (d->bd_id >>8) & 0xff, d->bd_id & 0xff); + return ENXIO; + } + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + } + + d->flags |= SND_F_BUSY ; + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + sb_reset_dsp(d->io_base); + ask_init(d); + + return 0; +} + +static int +sb_dsp_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + s = spltty(); + d->flags |= SND_F_CLOSING ; + splx(s); + snd_flush(d); + + sb_cmd(d->io_base, DSP_CMD_SPKOFF ); /* XXX useless ? */ + + d->flags = 0 ; + return 0 ; +} + +static int +sb_dsp_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) + return sb_mixer_set(d, cmd & 0xff, *(int *)arg) ; + + /* + * for the remaining functions, use the default handler. + */ + + return ENOSYS ; +} + +static void +sbintr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + int reason = 3, c=1, io_base = d->io_base; + + DEB(printf("got sbintr for unit %d, flags 0x%08x\n", unit, d->flags)); + + /* + * SB < 4.0 is half duplex and has only 1 bit for int source, + * so we fake it. SB 4.x (SB16) has the int source in a separate + * register. + */ +again: + if (d->bd_flags & BD_F_SB16) { + c = sb_getmixer(io_base, IRQ_STAT); + /* this tells us if the source is 8-bit or 16-bit dma. We + * have to check the io channel to map it to read or write... + */ + reason = 0 ; + if ( c & 1 ) { /* 8-bit dma */ + if (d->dma1 < 4) + reason |= 1; + if (d->dma2 < 4) + reason |= 2; + } + if ( c & 2 ) { /* 16-bit dma */ + if (d->dma1 >= 4) + reason |= 1; + if (d->dma2 >= 4) + reason |= 2; + } + } + if ( c & 2 ) + inb(DSP_DATA_AVL16); /* 16-bit int ack */ + if (c & 1) + inb(DSP_DATA_AVAIL); /* 8-bit int ack */ + +DEB(printf("sbintr, flags 0x%08x reason %d\n", d->flags, reason)); + if ( (d->flags & SND_F_WR_DMA) && (reason & 1) ) + dsp_wrintr(d); + if ( (d->flags & SND_F_RD_DMA) && (reason & 2) ) + dsp_rdintr(d); + + /* + * the sb16 might have multiple sources etc. + */ + if (d->bd_flags & BD_F_SB16 && (c & 3) ) + goto again; +} + +/* + * device-specific function called back from the dma module. + * The reason of the callback is the second argument. + * NOTE: during operations, some ioctl can be done to change + * settings (e.g. speed, channels, format), and the default + * ioctl handler will just record the change and set the + * flag SND_F_INIT. The callback routine is in charge of applying + * the changes at the next convenient time (typically, at the + * start of operations). For full duplex devices, in some cases the + * init requires both channels to be idle. + */ +static int +sb_callback(snddev_info *d, int reason) +{ + u_long s ; + int rd = reason & SND_CB_RD ; + int l = (rd) ? d->dbuf_in.dl0 : d->dbuf_out.dl0 ; + + switch (reason & SND_CB_REASON_MASK) { + case SND_CB_INIT : /* called with int enabled and no pending io */ + dsp_speed(d); + snd_set_blocksize(d); + if (d->play_fmt & AFMT_MU_LAW) + d->flags |= SND_F_XLAT8 ; + else + d->flags &= ~SND_F_XLAT8 ; + return 1; + break ; + + case SND_CB_START : /* called with int disabled */ + sb_cmd(d->io_base, rd ? DSP_CMD_SPKOFF : DSP_CMD_SPKON); + d->flags &= ~SND_F_INIT ; + if (d->bd_flags & BD_F_SB16) { + /* the SB16 can do full duplex using one 16-bit channel + * and one 8-bit channel. It needs to be programmed to + * use split format though. + */ + int b16 ; + int swap = 0 ; + + b16 = (rd) ? d->rec_fmt : d->play_fmt ; + b16 = (b16 == AFMT_S16_LE) ? 1 : 0; + /* + * check if I have to swap dma channels. Swap if + * - !rd, dma1 <4, b16 + * - !rd, dma1 >=4, !b16 + * - rd, dma2 <4, b16 + * - rd, dma2 >=4, !b16 + */ + if (!rd) { + if ( (d->dma1 <4 && b16) || (d->dma1 >=4 && !b16) ) swap = 1; + } else { + if ( (d->dma2 <4 && b16) || (d->dma2 >=4 && !b16) ) swap = 1; + } + /* + * before swapping should make sure that there is no + * pending DMA on the other channel... + */ + if (swap) { + int c = d->dma2 ; + d->dma2 = d->dma1; + d->dma1 = c ; + } + DEB(printf("sb_init: play %d rec %d dma1 %d dma2 %d\n", + d->play_fmt, d->rec_fmt, d->dma1, d->dma2)); + } + /* fallthrough */ + case SND_CB_RESTART: + if (d->bd_flags & BD_F_SB16) { + u_char c, c1 ; + /* + * SB16 support still not completely working!!! + * + * in principle, on the SB16, I could support simultaneous + * play & rec. + * However, there is no way to ask explicitly for 8 or + * 16 bit transfer. As a consequence, if we do 8-bit, + * we need to use the 8-bit channel, and if we do 16-bit, + * we need to use the other one. The only way I find to + * do this is to swap d->dma1 and d->dma2 ... + * + */ + + if (rd) { + c = ((d->dma2 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_ADC ; + c1 = (d->play_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->rec_fmt == AFMT_S16_LE) + l /= 2 ; + } else { + c = ((d->dma1 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_DAC ; + c1 = (d->rec_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->play_fmt == AFMT_S16_LE) + l /= 2 ; + } + + if (d->flags & SND_F_STEREO) + c1 |= DSP_F16_STEREO ; + + sb_cmd(d->io_base, c ); + sb_cmd3(d->io_base, c1 , l - 1) ; + } else { + u_char c ; + if (d->bd_flags & BD_F_HISPEED) + c = (rd) ? DSP_CMD_HSADC : DSP_CMD_HSDAC ; + else + c = (rd) ? DSP_CMD_ADC8 : DSP_CMD_DAC8 ; + sb_cmd3(d->io_base, c , l - 1) ; + } + break; + + case SND_CB_STOP : + /* sb_cmd(d->io_base, DSP_CMD_SPKOFF); /* speaker off */ + break ; + + } + return 0 ; +} + +/* + * The second part of the file contains all functions specific to + * the board and (usually) not exported to other modules. + */ + +int +sb_reset_dsp(int io_base) +{ + int loopc; + + outb(DSP_RESET, 1); + DELAY(100); + outb(DSP_RESET, 0); + for (loopc = 0; loopc<100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++) + DELAY(30); + + if (inb(DSP_READ) != 0xAA) { + DEB(printf("sb_reset_dsp failed\n")); + return 0; /* Sorry */ + } + return 1; +} + +/* + * only used in sb_attach from here. + */ + +static void +sb_dsp_init(snddev_info *d, struct isa_device *dev) +{ + int i, x; + char *fmt = NULL ; + int io_base = dev->id_iobase ; + + d->bd_id = 0 ; + + sb_reset_dsp(io_base); + sb_cmd(io_base, DSP_CMD_GETVER); /* Get version */ + + for (i = 10000; i; i--) { /* perhaps wait longer on a fast machine ? */ + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if ( (d->bd_id & 0xff00) == 0) + d->bd_id = inb(DSP_READ) << 8; /* major */ + else { + d->bd_id |= inb(DSP_READ); /* minor */ + break; + } + } else + DELAY(20); + } + + /* + * now do various initializations depending on board id. + */ + + fmt = "SoundBlaster %d.%d" ; /* default */ + + switch ( d->bd_id >> 8 ) { + case 0 : + printf("\n\nFailed to get SB version (%x) - possible I/O conflict\n\n", + inb(DSP_DATA_AVAIL)); + d->bd_id = 0x100; + case 1 : /* old sound blaster has nothing... */ + break ; + + case 2 : + d->dma2 = d->dma1 ; /* half duplex */ + d->bd_flags |= BD_F_DUP_MIDI ; + + if (d->bd_id == 0x200) + break ; /* no mixer on the 2.0 */ + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1335 ; + + break ; + case 4 : + fmt = "SoundBlaster 16 %d.%d"; + d->audio_fmt |= AFMT_FULLDUPLEX | AFMT_WEIRD | AFMT_S8 | AFMT_S16_LE; + d->bd_flags |= BD_F_SB16; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1745 ; + + /* soft irq/dma configuration */ + x = -1 ; + if (d->irq == 5) x = 2; + else if (d->irq == 7) x = 4; + else if (d->irq == 9) x = 1; + else if (d->irq == 10) x = 8; + if (x == -1) + printf("<%s>%d: bad irq %d (only 5,7,9,10 allowed)\n", + d->name, dev->id_unit, d->irq); + else + sb_setmixer(io_base, IRQ_NR, x); + + sb_setmixer(io_base, DMA_NR, (1 << d->dma1) | (1 << d->dma2)); + break ; + + case 3 : + d->dma2 = d->dma1 ; /* half duplex */ + fmt = "SoundBlaster Pro %d.%d"; + d->bd_flags |= BD_F_DUP_MIDI ; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1345 ; + if (d->bd_id == 0x301) { + int ess_major = 0, ess_minor = 0; + + /* + * Try to detect ESS chips. + */ + + sb_cmd(io_base, DSP_CMD_GETID); /* Return ident. bytes. */ + + for (i = 1000; i; i--) { + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if (ess_major == 0) + ess_major = inb(DSP_READ); + else { + ess_minor = inb(DSP_READ); + break; + } + } + } + + if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS488 based card (rev %d)\n", + ess_minor & 0x0f); + else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS688 based card (rev %d)\n", + ess_minor & 0x0f); + } + + if (d->bd_flags & BD_F_JAZZ16) { + if (d->bd_flags & BD_F_JAZZ16_2) + fmt = "SoundMan Wave %d.%d"; + else + fmt = "MV Jazz16 %d.%d"; + d->audio_fmt |= AFMT_S16_LE; /* 16 bits */ + } + } + + sprintf(d->name, fmt, (d->bd_id >> 8) &0xff, d->bd_id & 0xff); + + sb_mix_init(d); +} + +static void +sb_mix_init(snddev_info *d) +{ + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : /* SB 3.0 has 1345 mixer */ + + d->mix_devs = SBPRO_MIXER_DEVICES ; + d->mix_rec_devs = SBPRO_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + + sb_setmixer(d->io_base, 0, 1 ); /* reset mixer */ + sb_setmixer(d->io_base, MIC_VOL , 0x6 ); /* mic volume max */ + sb_setmixer(d->io_base, RECORD_SRC , 0x0 ); /* mic source */ + sb_setmixer(d->io_base, FM_VOL , 0x0 ); /* no midi */ + break ; + + case BD_F_MIX_CT1745 : /* SB16 mixer ... */ + + d->mix_devs = SB16_MIXER_DEVICES ; + d->mix_rec_devs = SB16_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + } + sb_mixer_reset(d); +} + +/* + * Common code for the midi and pcm functions + */ + +int +sb_cmd(int io_base, u_char val) +{ + int i; + + for (i = 0; i < 1000 ; i++) { + if ((inb(DSP_STATUS) & 0x80) == 0) { + outb(DSP_COMMAND, val); + return 1; + } + if (i > 10) + DELAY (i > 100 ? 1000 : 10 ); + } + + printf("SoundBlaster: DSP Command(0x%02x) timeout. IRQ conflict ?\n", val); + return 0; +} + +int +sb_cmd3(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + sb_cmd(io_base, (val>>8) & 0xff ); + return 1 ; + } else + return 0; +} + +int +sb_cmd2(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + return 1 ; + } else + return 0; +} + +void +sb_setmixer(int io_base, u_int port, u_int value) +{ + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + outb(MIXER_DATA, (u_char) (value & 0xff)); + DELAY(10); + splx(flags); +} + +u_int +sb_get_byte(int io_base) +{ + int i; + + for (i = 1000; i; i--) + if (inb(DSP_DATA_AVAIL) & 0x80) + return inb(DSP_READ); + else + DELAY(20); + return 0xffff; +} + +int +sb_getmixer(int io_base, u_int port) +{ + int val; + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + val = inb(MIXER_DATA); + DELAY(10); + splx(flags); + + return val; +} + + +/* + * various utility functions for the DSP + */ + +/* + * dsp_speed updates the speed setting from the descriptor. make sure + * it is called at spltty(). + * Besides, it takes care of stereo setting. + */ +static int +dsp_speed(snddev_info *d) +{ + u_char tconst; + u_long flags; + int max_speed = 44100, speed = d->play_speed ; + + if (d->bd_flags & BD_F_SB16) { + RANGE (speed, 5000, 45000); + d->play_speed = d->rec_speed = speed ; + sb_cmd(d->io_base, 0x41); + sb_cmd(d->io_base, d->play_speed >> 8 ); + sb_cmd(d->io_base, d->play_speed & 0xff ); + sb_cmd(d->io_base, 0x42); + sb_cmd(d->io_base, d->rec_speed >> 8 ); + sb_cmd(d->io_base, d->rec_speed & 0xff ); + return speed ; + } + /* + * only some models can do stereo, and only if not + * simultaneously using midi. + */ + if ( (d->bd_id & 0xff00) < 0x300 || d->bd_flags & BD_F_MIDIBUSY) + d->flags &= ~SND_F_STEREO; + + /* + * here enforce speed limitations. + */ + if (d->bd_id <= 0x200) + max_speed = 22050; /* max 22050 on SB 1.X */ + + /* + * SB models earlier than SB Pro have low limit for the + * input rate. Note that this is only for input, but since + * we do not support separate values for rec & play.... + */ + if (d->bd_id <= 0x200) + max_speed = 13000; + else if (d->bd_id < 0x300) + max_speed = 15000; + + RANGE(speed, 4000, max_speed); + + /* + * Logitech SoundMan Games and Jazz16 cards can support 44.1kHz + * stereo + */ +#if !defined (SM_GAMES) + /* + * Max. stereo speed is 22050 + */ + if (d->flags & SND_F_STEREO && speed > 22050 && !(d->bd_flags & BD_F_JAZZ16)) + speed = 22050; +#endif + + if ((speed > 22050) && d->bd_flags & BD_F_MIDIBUSY) + speed = 22050; + + if (d->flags & SND_F_STEREO) + speed *= 2; + + /* + * Now the speed should be valid. Compute the value to be + * programmed into the board. + */ + + if (speed > 22050) { /* High speed mode on 2.01/3.xx */ + int tmp; + + tconst = (u_char) ((65536 - ((256000000 + speed / 2) / speed)) >> 8); + d->bd_flags |= BD_F_HISPEED ; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 65536 - (tconst << 8); + speed = (256000000 + tmp / 2) / tmp; + } else { + int tmp; + + d->bd_flags &= ~BD_F_HISPEED ; + tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 256 - tconst; + speed = (1000000 + tmp / 2) / tmp; + } + + if (d->flags & SND_F_STEREO) + speed /= 2; + + d->play_speed = d->rec_speed = speed; + return speed; +} + +/* + * mixer support, originally in sb_mixer.c + */ + +static void +sb_set_recsrc(snddev_info *d, int mask) +{ + u_char outmask; + u_char recdev ; + + mask &= d->mix_rec_devs; + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : + if (mask == SOUND_MASK_LINE) + recdev = 6 ; + else if (mask == SOUND_MASK_CD) + recdev = 2 ; + else { /* default: mic */ + mask = SOUND_MASK_MIC ; + recdev = 0 ; + } + sb_setmixer(d->io_base, RECORD_SRC, + recdev | (sb_getmixer(d->io_base, RECORD_SRC) & ~7 )); + break ; + case BD_F_MIX_CT1745 : /* sb16 */ + if (mask == 0) + mask = SOUND_MASK_MIC ; /* XXX For compatibility. Bug ? */ + recdev = 0 ; + if (mask & SOUND_MASK_MIC) + recdev |= 1 ; + if (mask & SOUND_MASK_CD) + recdev |= 6 ; /* l+r cd */ + if (mask & SOUND_MASK_LINE) + recdev |= 0x18 ; /* l+r line */ + if (mask & SOUND_MASK_SYNTH) + recdev |= 0x60 ; /* l+r midi */ + sb_setmixer(d->io_base, SB16_IMASK_L, recdev); + sb_setmixer(d->io_base, SB16_IMASK_R, recdev); + /* + * since the same volume controls apply to the input and + * output sections, the best approach to have a consistent + * behaviour among cards would be to disable the output path + * on devices which are used to record. + * However, since users like to have feedback, we only disable + * the mike -- permanently. + */ + sb_setmixer(d->io_base, SB16_OMASK, 0x1f & ~1); + break ; + } + d->mix_recsrc = mask; +} + +static void +sb_mixer_reset(snddev_info *d) +{ + int i; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + sb_mixer_set(d, i, levels[i]); + if (d->bd_flags & BD_F_SB16) { + sb_setmixer(d->io_base, 0x3c, 0x1f); /* make all output active */ + sb_setmixer(d->io_base, 0x3d, 0); /* make all inputs-l off */ + sb_setmixer(d->io_base, 0x3e, 0); /* make all inputs-r off */ + } + sb_set_recsrc(d, SOUND_MASK_MIC); +} + +static int +sb_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + int regoffs; + u_char val; + mixer_tab *iomap; + +#ifdef JAZZ16 + if (d->bd_flags & BD_F_JAZZ16 && d->bd_flags & BD_F_JAZZ16_2) + return smw_mixer_set(dev, value); +#endif + + if (dev == SOUND_MIXER_RECSRC) { + sb_set_recsrc(d, value); + return 0 ; + } + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + if (dev > 31) + return EINVAL ; + + if (!(d->mix_devs & (1 << dev))) /* Not supported */ + return EINVAL; + + switch ( d->bd_flags & BD_F_MIX_MASK ) { + default: + /* mixer unknown, fail... */ + return EINVAL ;/* XXX change this */ + case BD_F_MIX_CT1345 : + iomap = &sbpro_mix ; + break; + case BD_F_MIX_CT1745 : + iomap = &sb16_mix ; + break; + /* XXX how about the SG NX Pro, iomap = sgnxpro_mix */ + } + regoffs = (*iomap)[dev][LEFT_CHN].regno; + if (regoffs == 0) + return EINVAL; + + val = sb_getmixer(d->io_base, regoffs); + + change_bits(iomap, &val, dev, LEFT_CHN, left); + + d->mix_levels[dev] = left | (left << 8); + + if ((*iomap)[dev][RIGHT_CHN].regno != regoffs) { /* Change register */ + sb_setmixer(d->io_base, regoffs, val); /* Save the old one */ + regoffs = (*iomap)[dev][RIGHT_CHN].regno; + + if (regoffs == 0) + return 0 ; /* Just left channel present */ + + val = sb_getmixer(d->io_base, regoffs); /* Read the new one */ + } + change_bits(iomap, &val, dev, RIGHT_CHN, right); + + sb_setmixer(d->io_base, regoffs, val); + + d->mix_levels[dev] = left | (right << 8); + return 0 ; /* ok */ +} + +/* + * now support for some PnP boards. + */ + +#if NPNP > 0 +static char *opti925_probe(u_long csn, u_long vend_id); +static void opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device opti925 = { + "opti925", + opti925_probe, + opti925_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti925); + +static char * +opti925_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x2509143e) { + struct pnp_cinfo d ; + read_pnp_parms ( &d , 1 ) ; + if (d.enable == 0) { + printf("This is an OPTi925, but LDN 1 is disabled\n"); + return NULL; + } + return "OPTi925" ; + } + return NULL ; +} + +static void +opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int the_irq = 0 ; + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 3 ); /* disable LDN 3 */ + the_irq = d.irq[0]; + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + d.irq[0] = the_irq ; + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 1 ); + enable_pnp_card(); + + tmp_d.conf_base = d.port[3]; + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); + +} + +/* + * A driver for some SB16pnp and compatibles... + * + * Avance Asound 100 -- 0x01009305 + * xxx -- 0x2b008c0e + * + */ + +static char *sb16pnp_probe(u_long csn, u_long vend_id); +static void sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device sb16pnp = { + "SB16pnp", + sb16pnp_probe, + sb16pnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, sb16pnp); + +static char * +sb16pnp_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x01009305) + s = "Avance Asound 100" ; + if (vend_id == 0x2b008c0e) + s = "SB16 Value PnP" ; + /* + * The SB16/AWE64 cards seem to differ in the fourth byte of + * the vendor id, so I have just masked it for the time being... + * Reported values are: + * SB16 Value PnP: 0x2b008c0e + * SB AWE64 PnP: 0x39008c0e 0x9d008c0e 0xc3008c0e + */ + if ( (vend_id & 0xffffff) == (0x9d008c0e & 0xffffff) ) + s = "SB AWE64 PnP"; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s ; + } + return NULL ; +} + +static void +sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 0 ) ; + d.port[1] = 0 ; /* only the first address is used */ + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); +} +#endif /* NPNP */ + +#endif diff --git a/sys/dev/sound/isa/sb8.c b/sys/dev/sound/isa/sb8.c new file mode 100644 index 000000000000..4ca1f1f507fa --- /dev/null +++ b/sys/dev/sound/isa/sb8.c @@ -0,0 +1,1080 @@ +/* + * sound/sb_dsp.c + * + * driver for the SoundBlaster and clones. + * + * Copyright 1997 Luigi Rizzo. + * + * Derived from files in the Voxware 3.5 distribution, + * Copyright by Hannu Savolainen 1994, under the same copyright + * conditions. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* + * use this as a template file for board-specific drivers. + * The next two lines (and the final #endif) are in all drivers: + */ + +#include +#if NPCM > 0 + +/* + * Begin with the board-specific include files... + */ + +#define __SB_MIXER_C__ /* XXX warning... */ +#include + +/* + * then prototypes of functions which go in the snddev_info + * (usually static, unless they are shared by other modules)... + */ + +static int sb_probe(struct isa_device *dev); +static int sb_attach(struct isa_device *dev); + +static d_open_t sb_dsp_open; +static d_close_t sb_dsp_close; +static d_ioctl_t sb_dsp_ioctl; +static irq_proc_t sbintr; +static snd_callback_t sb_callback; + +/* + * and prototypes for other private functions defined in this module. + */ + +static void sb_dsp_init(snddev_info *d, struct isa_device *dev); +static void sb_mix_init(snddev_info *d); +static int sb_mixer_set(snddev_info *d, int dev, int value); +static int dsp_speed(snddev_info *d); +static void sb_mixer_reset(snddev_info *d); + +u_int sb_get_byte(int io_base); + +/* + * Then put here the descriptors for the various boards supported + * by this module, properly initialized. + */ + +snddev_info sb_op_desc = { + "basic soundblaster", + + SNDCARD_SB, + sb_probe, + sb_attach, + + sb_dsp_open, + sb_dsp_close /* sb_close */, + NULL /* use generic sndread */, + NULL /* use generic sndwrite */, + sb_dsp_ioctl, + sndselect, + + sbintr, + sb_callback, + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | AFMT_U8, /* audio format */ + +} ; + +/* + * Then the file continues with the body of all functions + * directly referenced in the descriptor. + */ + +/* + * the probe routine for the SoundBlaster only consists in + * resetting the dsp and testing if it is there. + * Version detection etc. will be done at attach time. + * + * Remebber, isa probe routines are supposed to return the + * size of io space used. + */ + +static int +sb_probe(struct isa_device *dev) +{ + if (dev->id_iobase == -1) { + dev->id_iobase = 0x220; + printf("sb_probe: no address supplied, try defaults (0x220,0x240)\n"); + if (snd_conflict(dev->id_iobase)) + dev->id_iobase = 0x240; + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if (sb_reset_dsp(dev->id_iobase)) + return 16 ; /* the SB uses 16 registers... */ + else + return 0; +} + +static int +sb_attach(struct isa_device *dev) +{ + snddev_info *d = &pcm_info[dev->id_unit] ; + + sb_dsp_init(d, dev); + return 0 ; +} + +/* + * here are the main routines from the switches. + */ + +static int +sb_dsp_open(dev_t dev, int flags, int mode, struct proc * p) +{ + snddev_info *d; + int unit ; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + DEB(printf("<%s>%d : open\n", d->name, unit)); + + if (d->flags & SND_F_BUSY) { + printf("<%s>%d open: device busy\n", d->name, unit); + return EBUSY ; + } + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + d->flags = 0 ; + d->bd_flags &= ~BD_F_HISPEED ; + + switch ( dev & 0xf ) { + case SND_DEV_DSP16 : + if ((d->audio_fmt & AFMT_S16_LE) == 0) { + printf("sorry, 16-bit not supported on SB %d.%02d\n", + (d->bd_id >>8) & 0xff, d->bd_id & 0xff); + return ENXIO; + } + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + } + + d->flags |= SND_F_BUSY ; + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + sb_reset_dsp(d->io_base); + ask_init(d); + + return 0; +} + +static int +sb_dsp_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + s = spltty(); + d->flags |= SND_F_CLOSING ; + splx(s); + snd_flush(d); + + sb_cmd(d->io_base, DSP_CMD_SPKOFF ); /* XXX useless ? */ + + d->flags = 0 ; + return 0 ; +} + +static int +sb_dsp_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) + return sb_mixer_set(d, cmd & 0xff, *(int *)arg) ; + + /* + * for the remaining functions, use the default handler. + */ + + return ENOSYS ; +} + +static void +sbintr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + int reason = 3, c=1, io_base = d->io_base; + + DEB(printf("got sbintr for unit %d, flags 0x%08x\n", unit, d->flags)); + + /* + * SB < 4.0 is half duplex and has only 1 bit for int source, + * so we fake it. SB 4.x (SB16) has the int source in a separate + * register. + */ +again: + if (d->bd_flags & BD_F_SB16) { + c = sb_getmixer(io_base, IRQ_STAT); + /* this tells us if the source is 8-bit or 16-bit dma. We + * have to check the io channel to map it to read or write... + */ + reason = 0 ; + if ( c & 1 ) { /* 8-bit dma */ + if (d->dma1 < 4) + reason |= 1; + if (d->dma2 < 4) + reason |= 2; + } + if ( c & 2 ) { /* 16-bit dma */ + if (d->dma1 >= 4) + reason |= 1; + if (d->dma2 >= 4) + reason |= 2; + } + } + if ( c & 2 ) + inb(DSP_DATA_AVL16); /* 16-bit int ack */ + if (c & 1) + inb(DSP_DATA_AVAIL); /* 8-bit int ack */ + +DEB(printf("sbintr, flags 0x%08x reason %d\n", d->flags, reason)); + if ( (d->flags & SND_F_WR_DMA) && (reason & 1) ) + dsp_wrintr(d); + if ( (d->flags & SND_F_RD_DMA) && (reason & 2) ) + dsp_rdintr(d); + + /* + * the sb16 might have multiple sources etc. + */ + if (d->bd_flags & BD_F_SB16 && (c & 3) ) + goto again; +} + +/* + * device-specific function called back from the dma module. + * The reason of the callback is the second argument. + * NOTE: during operations, some ioctl can be done to change + * settings (e.g. speed, channels, format), and the default + * ioctl handler will just record the change and set the + * flag SND_F_INIT. The callback routine is in charge of applying + * the changes at the next convenient time (typically, at the + * start of operations). For full duplex devices, in some cases the + * init requires both channels to be idle. + */ +static int +sb_callback(snddev_info *d, int reason) +{ + u_long s ; + int rd = reason & SND_CB_RD ; + int l = (rd) ? d->dbuf_in.dl0 : d->dbuf_out.dl0 ; + + switch (reason & SND_CB_REASON_MASK) { + case SND_CB_INIT : /* called with int enabled and no pending io */ + dsp_speed(d); + snd_set_blocksize(d); + if (d->play_fmt & AFMT_MU_LAW) + d->flags |= SND_F_XLAT8 ; + else + d->flags &= ~SND_F_XLAT8 ; + return 1; + break ; + + case SND_CB_START : /* called with int disabled */ + sb_cmd(d->io_base, rd ? DSP_CMD_SPKOFF : DSP_CMD_SPKON); + d->flags &= ~SND_F_INIT ; + if (d->bd_flags & BD_F_SB16) { + /* the SB16 can do full duplex using one 16-bit channel + * and one 8-bit channel. It needs to be programmed to + * use split format though. + */ + int b16 ; + int swap = 0 ; + + b16 = (rd) ? d->rec_fmt : d->play_fmt ; + b16 = (b16 == AFMT_S16_LE) ? 1 : 0; + /* + * check if I have to swap dma channels. Swap if + * - !rd, dma1 <4, b16 + * - !rd, dma1 >=4, !b16 + * - rd, dma2 <4, b16 + * - rd, dma2 >=4, !b16 + */ + if (!rd) { + if ( (d->dma1 <4 && b16) || (d->dma1 >=4 && !b16) ) swap = 1; + } else { + if ( (d->dma2 <4 && b16) || (d->dma2 >=4 && !b16) ) swap = 1; + } + /* + * before swapping should make sure that there is no + * pending DMA on the other channel... + */ + if (swap) { + int c = d->dma2 ; + d->dma2 = d->dma1; + d->dma1 = c ; + } + DEB(printf("sb_init: play %d rec %d dma1 %d dma2 %d\n", + d->play_fmt, d->rec_fmt, d->dma1, d->dma2)); + } + /* fallthrough */ + case SND_CB_RESTART: + if (d->bd_flags & BD_F_SB16) { + u_char c, c1 ; + /* + * SB16 support still not completely working!!! + * + * in principle, on the SB16, I could support simultaneous + * play & rec. + * However, there is no way to ask explicitly for 8 or + * 16 bit transfer. As a consequence, if we do 8-bit, + * we need to use the 8-bit channel, and if we do 16-bit, + * we need to use the other one. The only way I find to + * do this is to swap d->dma1 and d->dma2 ... + * + */ + + if (rd) { + c = ((d->dma2 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_ADC ; + c1 = (d->play_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->rec_fmt == AFMT_S16_LE) + l /= 2 ; + } else { + c = ((d->dma1 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_DAC ; + c1 = (d->rec_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->play_fmt == AFMT_S16_LE) + l /= 2 ; + } + + if (d->flags & SND_F_STEREO) + c1 |= DSP_F16_STEREO ; + + sb_cmd(d->io_base, c ); + sb_cmd3(d->io_base, c1 , l - 1) ; + } else { + u_char c ; + if (d->bd_flags & BD_F_HISPEED) + c = (rd) ? DSP_CMD_HSADC : DSP_CMD_HSDAC ; + else + c = (rd) ? DSP_CMD_ADC8 : DSP_CMD_DAC8 ; + sb_cmd3(d->io_base, c , l - 1) ; + } + break; + + case SND_CB_STOP : + /* sb_cmd(d->io_base, DSP_CMD_SPKOFF); /* speaker off */ + break ; + + } + return 0 ; +} + +/* + * The second part of the file contains all functions specific to + * the board and (usually) not exported to other modules. + */ + +int +sb_reset_dsp(int io_base) +{ + int loopc; + + outb(DSP_RESET, 1); + DELAY(100); + outb(DSP_RESET, 0); + for (loopc = 0; loopc<100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++) + DELAY(30); + + if (inb(DSP_READ) != 0xAA) { + DEB(printf("sb_reset_dsp failed\n")); + return 0; /* Sorry */ + } + return 1; +} + +/* + * only used in sb_attach from here. + */ + +static void +sb_dsp_init(snddev_info *d, struct isa_device *dev) +{ + int i, x; + char *fmt = NULL ; + int io_base = dev->id_iobase ; + + d->bd_id = 0 ; + + sb_reset_dsp(io_base); + sb_cmd(io_base, DSP_CMD_GETVER); /* Get version */ + + for (i = 10000; i; i--) { /* perhaps wait longer on a fast machine ? */ + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if ( (d->bd_id & 0xff00) == 0) + d->bd_id = inb(DSP_READ) << 8; /* major */ + else { + d->bd_id |= inb(DSP_READ); /* minor */ + break; + } + } else + DELAY(20); + } + + /* + * now do various initializations depending on board id. + */ + + fmt = "SoundBlaster %d.%d" ; /* default */ + + switch ( d->bd_id >> 8 ) { + case 0 : + printf("\n\nFailed to get SB version (%x) - possible I/O conflict\n\n", + inb(DSP_DATA_AVAIL)); + d->bd_id = 0x100; + case 1 : /* old sound blaster has nothing... */ + break ; + + case 2 : + d->dma2 = d->dma1 ; /* half duplex */ + d->bd_flags |= BD_F_DUP_MIDI ; + + if (d->bd_id == 0x200) + break ; /* no mixer on the 2.0 */ + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1335 ; + + break ; + case 4 : + fmt = "SoundBlaster 16 %d.%d"; + d->audio_fmt |= AFMT_FULLDUPLEX | AFMT_WEIRD | AFMT_S8 | AFMT_S16_LE; + d->bd_flags |= BD_F_SB16; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1745 ; + + /* soft irq/dma configuration */ + x = -1 ; + if (d->irq == 5) x = 2; + else if (d->irq == 7) x = 4; + else if (d->irq == 9) x = 1; + else if (d->irq == 10) x = 8; + if (x == -1) + printf("<%s>%d: bad irq %d (only 5,7,9,10 allowed)\n", + d->name, dev->id_unit, d->irq); + else + sb_setmixer(io_base, IRQ_NR, x); + + sb_setmixer(io_base, DMA_NR, (1 << d->dma1) | (1 << d->dma2)); + break ; + + case 3 : + d->dma2 = d->dma1 ; /* half duplex */ + fmt = "SoundBlaster Pro %d.%d"; + d->bd_flags |= BD_F_DUP_MIDI ; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1345 ; + if (d->bd_id == 0x301) { + int ess_major = 0, ess_minor = 0; + + /* + * Try to detect ESS chips. + */ + + sb_cmd(io_base, DSP_CMD_GETID); /* Return ident. bytes. */ + + for (i = 1000; i; i--) { + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if (ess_major == 0) + ess_major = inb(DSP_READ); + else { + ess_minor = inb(DSP_READ); + break; + } + } + } + + if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS488 based card (rev %d)\n", + ess_minor & 0x0f); + else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS688 based card (rev %d)\n", + ess_minor & 0x0f); + } + + if (d->bd_flags & BD_F_JAZZ16) { + if (d->bd_flags & BD_F_JAZZ16_2) + fmt = "SoundMan Wave %d.%d"; + else + fmt = "MV Jazz16 %d.%d"; + d->audio_fmt |= AFMT_S16_LE; /* 16 bits */ + } + } + + sprintf(d->name, fmt, (d->bd_id >> 8) &0xff, d->bd_id & 0xff); + + sb_mix_init(d); +} + +static void +sb_mix_init(snddev_info *d) +{ + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : /* SB 3.0 has 1345 mixer */ + + d->mix_devs = SBPRO_MIXER_DEVICES ; + d->mix_rec_devs = SBPRO_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + + sb_setmixer(d->io_base, 0, 1 ); /* reset mixer */ + sb_setmixer(d->io_base, MIC_VOL , 0x6 ); /* mic volume max */ + sb_setmixer(d->io_base, RECORD_SRC , 0x0 ); /* mic source */ + sb_setmixer(d->io_base, FM_VOL , 0x0 ); /* no midi */ + break ; + + case BD_F_MIX_CT1745 : /* SB16 mixer ... */ + + d->mix_devs = SB16_MIXER_DEVICES ; + d->mix_rec_devs = SB16_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + } + sb_mixer_reset(d); +} + +/* + * Common code for the midi and pcm functions + */ + +int +sb_cmd(int io_base, u_char val) +{ + int i; + + for (i = 0; i < 1000 ; i++) { + if ((inb(DSP_STATUS) & 0x80) == 0) { + outb(DSP_COMMAND, val); + return 1; + } + if (i > 10) + DELAY (i > 100 ? 1000 : 10 ); + } + + printf("SoundBlaster: DSP Command(0x%02x) timeout. IRQ conflict ?\n", val); + return 0; +} + +int +sb_cmd3(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + sb_cmd(io_base, (val>>8) & 0xff ); + return 1 ; + } else + return 0; +} + +int +sb_cmd2(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + return 1 ; + } else + return 0; +} + +void +sb_setmixer(int io_base, u_int port, u_int value) +{ + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + outb(MIXER_DATA, (u_char) (value & 0xff)); + DELAY(10); + splx(flags); +} + +u_int +sb_get_byte(int io_base) +{ + int i; + + for (i = 1000; i; i--) + if (inb(DSP_DATA_AVAIL) & 0x80) + return inb(DSP_READ); + else + DELAY(20); + return 0xffff; +} + +int +sb_getmixer(int io_base, u_int port) +{ + int val; + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + val = inb(MIXER_DATA); + DELAY(10); + splx(flags); + + return val; +} + + +/* + * various utility functions for the DSP + */ + +/* + * dsp_speed updates the speed setting from the descriptor. make sure + * it is called at spltty(). + * Besides, it takes care of stereo setting. + */ +static int +dsp_speed(snddev_info *d) +{ + u_char tconst; + u_long flags; + int max_speed = 44100, speed = d->play_speed ; + + if (d->bd_flags & BD_F_SB16) { + RANGE (speed, 5000, 45000); + d->play_speed = d->rec_speed = speed ; + sb_cmd(d->io_base, 0x41); + sb_cmd(d->io_base, d->play_speed >> 8 ); + sb_cmd(d->io_base, d->play_speed & 0xff ); + sb_cmd(d->io_base, 0x42); + sb_cmd(d->io_base, d->rec_speed >> 8 ); + sb_cmd(d->io_base, d->rec_speed & 0xff ); + return speed ; + } + /* + * only some models can do stereo, and only if not + * simultaneously using midi. + */ + if ( (d->bd_id & 0xff00) < 0x300 || d->bd_flags & BD_F_MIDIBUSY) + d->flags &= ~SND_F_STEREO; + + /* + * here enforce speed limitations. + */ + if (d->bd_id <= 0x200) + max_speed = 22050; /* max 22050 on SB 1.X */ + + /* + * SB models earlier than SB Pro have low limit for the + * input rate. Note that this is only for input, but since + * we do not support separate values for rec & play.... + */ + if (d->bd_id <= 0x200) + max_speed = 13000; + else if (d->bd_id < 0x300) + max_speed = 15000; + + RANGE(speed, 4000, max_speed); + + /* + * Logitech SoundMan Games and Jazz16 cards can support 44.1kHz + * stereo + */ +#if !defined (SM_GAMES) + /* + * Max. stereo speed is 22050 + */ + if (d->flags & SND_F_STEREO && speed > 22050 && !(d->bd_flags & BD_F_JAZZ16)) + speed = 22050; +#endif + + if ((speed > 22050) && d->bd_flags & BD_F_MIDIBUSY) + speed = 22050; + + if (d->flags & SND_F_STEREO) + speed *= 2; + + /* + * Now the speed should be valid. Compute the value to be + * programmed into the board. + */ + + if (speed > 22050) { /* High speed mode on 2.01/3.xx */ + int tmp; + + tconst = (u_char) ((65536 - ((256000000 + speed / 2) / speed)) >> 8); + d->bd_flags |= BD_F_HISPEED ; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 65536 - (tconst << 8); + speed = (256000000 + tmp / 2) / tmp; + } else { + int tmp; + + d->bd_flags &= ~BD_F_HISPEED ; + tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 256 - tconst; + speed = (1000000 + tmp / 2) / tmp; + } + + if (d->flags & SND_F_STEREO) + speed /= 2; + + d->play_speed = d->rec_speed = speed; + return speed; +} + +/* + * mixer support, originally in sb_mixer.c + */ + +static void +sb_set_recsrc(snddev_info *d, int mask) +{ + u_char outmask; + u_char recdev ; + + mask &= d->mix_rec_devs; + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : + if (mask == SOUND_MASK_LINE) + recdev = 6 ; + else if (mask == SOUND_MASK_CD) + recdev = 2 ; + else { /* default: mic */ + mask = SOUND_MASK_MIC ; + recdev = 0 ; + } + sb_setmixer(d->io_base, RECORD_SRC, + recdev | (sb_getmixer(d->io_base, RECORD_SRC) & ~7 )); + break ; + case BD_F_MIX_CT1745 : /* sb16 */ + if (mask == 0) + mask = SOUND_MASK_MIC ; /* XXX For compatibility. Bug ? */ + recdev = 0 ; + if (mask & SOUND_MASK_MIC) + recdev |= 1 ; + if (mask & SOUND_MASK_CD) + recdev |= 6 ; /* l+r cd */ + if (mask & SOUND_MASK_LINE) + recdev |= 0x18 ; /* l+r line */ + if (mask & SOUND_MASK_SYNTH) + recdev |= 0x60 ; /* l+r midi */ + sb_setmixer(d->io_base, SB16_IMASK_L, recdev); + sb_setmixer(d->io_base, SB16_IMASK_R, recdev); + /* + * since the same volume controls apply to the input and + * output sections, the best approach to have a consistent + * behaviour among cards would be to disable the output path + * on devices which are used to record. + * However, since users like to have feedback, we only disable + * the mike -- permanently. + */ + sb_setmixer(d->io_base, SB16_OMASK, 0x1f & ~1); + break ; + } + d->mix_recsrc = mask; +} + +static void +sb_mixer_reset(snddev_info *d) +{ + int i; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + sb_mixer_set(d, i, levels[i]); + if (d->bd_flags & BD_F_SB16) { + sb_setmixer(d->io_base, 0x3c, 0x1f); /* make all output active */ + sb_setmixer(d->io_base, 0x3d, 0); /* make all inputs-l off */ + sb_setmixer(d->io_base, 0x3e, 0); /* make all inputs-r off */ + } + sb_set_recsrc(d, SOUND_MASK_MIC); +} + +static int +sb_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + int regoffs; + u_char val; + mixer_tab *iomap; + +#ifdef JAZZ16 + if (d->bd_flags & BD_F_JAZZ16 && d->bd_flags & BD_F_JAZZ16_2) + return smw_mixer_set(dev, value); +#endif + + if (dev == SOUND_MIXER_RECSRC) { + sb_set_recsrc(d, value); + return 0 ; + } + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + if (dev > 31) + return EINVAL ; + + if (!(d->mix_devs & (1 << dev))) /* Not supported */ + return EINVAL; + + switch ( d->bd_flags & BD_F_MIX_MASK ) { + default: + /* mixer unknown, fail... */ + return EINVAL ;/* XXX change this */ + case BD_F_MIX_CT1345 : + iomap = &sbpro_mix ; + break; + case BD_F_MIX_CT1745 : + iomap = &sb16_mix ; + break; + /* XXX how about the SG NX Pro, iomap = sgnxpro_mix */ + } + regoffs = (*iomap)[dev][LEFT_CHN].regno; + if (regoffs == 0) + return EINVAL; + + val = sb_getmixer(d->io_base, regoffs); + + change_bits(iomap, &val, dev, LEFT_CHN, left); + + d->mix_levels[dev] = left | (left << 8); + + if ((*iomap)[dev][RIGHT_CHN].regno != regoffs) { /* Change register */ + sb_setmixer(d->io_base, regoffs, val); /* Save the old one */ + regoffs = (*iomap)[dev][RIGHT_CHN].regno; + + if (regoffs == 0) + return 0 ; /* Just left channel present */ + + val = sb_getmixer(d->io_base, regoffs); /* Read the new one */ + } + change_bits(iomap, &val, dev, RIGHT_CHN, right); + + sb_setmixer(d->io_base, regoffs, val); + + d->mix_levels[dev] = left | (right << 8); + return 0 ; /* ok */ +} + +/* + * now support for some PnP boards. + */ + +#if NPNP > 0 +static char *opti925_probe(u_long csn, u_long vend_id); +static void opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device opti925 = { + "opti925", + opti925_probe, + opti925_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti925); + +static char * +opti925_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x2509143e) { + struct pnp_cinfo d ; + read_pnp_parms ( &d , 1 ) ; + if (d.enable == 0) { + printf("This is an OPTi925, but LDN 1 is disabled\n"); + return NULL; + } + return "OPTi925" ; + } + return NULL ; +} + +static void +opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int the_irq = 0 ; + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 3 ); /* disable LDN 3 */ + the_irq = d.irq[0]; + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + d.irq[0] = the_irq ; + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 1 ); + enable_pnp_card(); + + tmp_d.conf_base = d.port[3]; + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); + +} + +/* + * A driver for some SB16pnp and compatibles... + * + * Avance Asound 100 -- 0x01009305 + * xxx -- 0x2b008c0e + * + */ + +static char *sb16pnp_probe(u_long csn, u_long vend_id); +static void sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device sb16pnp = { + "SB16pnp", + sb16pnp_probe, + sb16pnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, sb16pnp); + +static char * +sb16pnp_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x01009305) + s = "Avance Asound 100" ; + if (vend_id == 0x2b008c0e) + s = "SB16 Value PnP" ; + /* + * The SB16/AWE64 cards seem to differ in the fourth byte of + * the vendor id, so I have just masked it for the time being... + * Reported values are: + * SB16 Value PnP: 0x2b008c0e + * SB AWE64 PnP: 0x39008c0e 0x9d008c0e 0xc3008c0e + */ + if ( (vend_id & 0xffffff) == (0x9d008c0e & 0xffffff) ) + s = "SB AWE64 PnP"; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s ; + } + return NULL ; +} + +static void +sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 0 ) ; + d.port[1] = 0 ; /* only the first address is used */ + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); +} +#endif /* NPNP */ + +#endif diff --git a/sys/i386/isa/snd/README b/sys/i386/isa/snd/README new file mode 100644 index 000000000000..70e3c110c3fc --- /dev/null +++ b/sys/i386/isa/snd/README @@ -0,0 +1,78 @@ + --- A new FreeBSD sound driver --- + by Luigi Rizzo (luigi@iet.unipi.it) + + +This is an experimental version of the sound driver for FreeBSD. +I have almost completely rewritten the main parts of the code, +starting from the Voxware 3.5-alpha release with patches from +Amancio Hasty. The only file which is largely similar to the original +ones is "soundcard.h" (for compatibility reasons, since it contains +the definition of all the ioctls). + +Visit http://www.iet.unipi.it/~luigi/FreeBSD.html for the latest +information on the drivers. There you can obtain the latest source +package that includes documentation on the design of the driver. + + +CARD SUPPORT INFORMATION: + +For PnP cards, I also include the vendor_id and serial numbers of +cards I have encountered. + +CS4236: PnP id 0x3642630e + + works like a charm. All modes, including full duplex, supported in + MSS mode. + +CS4237: PnP id 0x3742630e + + I had early reports of success with this board, which is almost + the same as the CS4236. + +CS4232: PnP id 0x3242630e + + this chip is reported as broken in the OSS documentation. As a + matter of fact, on my Intel Zappa motherboard, I have problems in + make it use the secondary DMA channel. I have it working in + half duplex (both capture and playback) in SB3.2 emulation, + and working in playback mode in MSS emulation. + +OPTi931: PnP id 0x3109143e + + The data sheets of this chip are very cryptic. I have it working + in full duplex in all modes _except_ capture of uLAW/ALAW data. + I am strongly convinced of a bug in the chip. I have sent email + to OPTI but got no reply so far. In SB emulation mode the + driver does not work yet (maybe I do not initialize it the + right way). + + Another bug seems to affect full duplex operation -- it appears + that at times DMA transfer are requested but not counted by + the device. In normal DMA mode this causes deadlocks. The only + solution I have found is to fetch the count from the ISA DMA + registers, but this does not seem to work very well either. + +SB16 PnP: PnP id 0xXX008c0e + + There are many such cards (plain SB16 PnP, AWE32, AWE64, Vibra16, + etc. all differing in the PnP id (and with different synthesis + devices, which we do not support anyways). + + Since 970903 the driver supports them all, both capture and + playback, 8 and 16 bits. + +GusPnP: PnP id 0x0100561e + + I have code to recognize the board as MSS, but have not tested it + since I don't own the board. Hopefully someone will test it soon. + +OPTI925: PnP id 0x2509143e + + there is code to recognize it as a SB clone. I have reports that + it probes ok, but not sure if it works. + +OPTI930: + + should work as an MSS clone, but support for it is not implemented + yet. + diff --git a/sys/i386/isa/snd/ad1848.c b/sys/i386/isa/snd/ad1848.c new file mode 100644 index 000000000000..97b328d098fe --- /dev/null +++ b/sys/i386/isa/snd/ad1848.c @@ -0,0 +1,1509 @@ +/* + * sound/ad1848.c + * + * Modified by Luigi Rizzo (luigi@iet.unipi.it) + * + * Driver for Microsoft Sound System/Windows Sound System (mss) + * -compatible boards. This includes: + * + * AD1848, CS4248 + * + * CS4231, used in the GUS MAX and some other cards; + * AD1845, CS4231A (CS4231-like) + * CS4232 (CS4231+SB and MPU, PnP) + * CS4236 (upgrade of the CS4232, has a better mixer) + * OPTi931 (WSS compatible, full duplex, some differences from CS42xx) + * + * Copyright Luigi Rizzo, 1997 + * Copyright by Hannu Savolainen 1994, 1995 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * + * Full data sheets in PDF format for the MSS-compatible chips + * are available at + * + * http://www.crystal.com/ for the CS42XX series, or + * http://www.opti.com/ for the OPTi931 + * + * The OPTi931 appears to be quite buggy. + */ + +#include +#if NPCM > 0 + +/* + * board-specific include files + */ + +#include + +/* + * prototypes for procedures exported in the device descriptor + */ + +static int mss_probe(struct isa_device *dev); +static int mss_attach(struct isa_device *dev); + +static d_open_t mss_open; +static d_close_t mss_close; +static d_ioctl_t mss_ioctl; +static irq_proc_t mss_intr; +static irq_proc_t opti931_intr; +static snd_callback_t mss_callback; + +/* + * prototypes for local functions + */ + +static void mss_reinit(snddev_info *d); +static int AD_WAIT_INIT(snddev_info *d, int x); +static int mss_mixer_set(snddev_info *d, int dev, int value); +static int mss_set_recsrc(snddev_info *d, int mask); +static void ad1848_mixer_reset(snddev_info *d); + +static void opti_write(int io_base, u_char reg, u_char data); +static u_char opti_read(int io_base, u_char reg); +static void ad_write(snddev_info *d, int reg, u_char data); +static void ad_write_cnt(snddev_info *d, int reg, u_short data); +static int ad_read(snddev_info *d, int reg); + +/* + * device descriptors for the boards supported by this module. + */ +snddev_info mss_op_desc = { + "mss", + + SNDCARD_MSS, + mss_probe, + mss_attach, + + mss_open, + mss_close, + NULL /* mss_read */, + NULL /* mss_write */, + mss_ioctl, + sndselect /* mss_select */, + + mss_intr, + mss_callback , + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | + AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW, /* audio formats */ + /* + * the enhanced boards also have AFMT_IMA_ADPCM | AFMT_S16_BE + */ +} ; + +/* + * this is the probe routine. Note, it is not necessary to + * go through this for PnP devices, since they are already + * indentified precisely using their PnP id. + * + * The base address supplied in the device refers to the old MSS + * specs where the four 4 registers in io space contain configuration + * information. Some boards (as an example, early MSS boards) + * has such a block of registers, whereas others (generally CS42xx) + * do not. In order to distinguish between the two and do not have + * to supply two separate probe routines, the flags entry in isa_device + * has a bit to mark this. + * + */ + +static int +mss_probe(struct isa_device *dev) +{ + u_char tmp; + int irq = ffs(dev->id_irq) - 1; + + if (dev->id_iobase == -1) { + dev->id_iobase = 0x530; + printf("mss_probe: no address supplied, try default 0x%x\n", + dev->id_iobase); + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if ( !(dev->id_flags & DV_F_TRUE_MSS) ) /* Has no IRQ/DMA registers */ + goto mss_probe_end; + + /* + * Check if the IO port returns valid signature. The original MS + * Sound system returns 0x04 while some cards + * (AudioTriX Pro for example) return 0x00 or 0x0f. + */ + + tmp = inb(dev->id_iobase + 3); + if (tmp == 0xff) { /* Bus float */ + DDB(printf("I/O address inactive (%x), try pseudo_mss\n", tmp)); + dev->id_flags &= ~DV_F_TRUE_MSS ; + goto mss_probe_end; + } + tmp &= 0x3f ; + if (tmp != 0x04 && tmp != 0x0f && tmp != 0x00) { + DDB(printf("No MSS signature detected on port 0x%x (0x%x)\n", + dev->id_iobase, inb(dev->id_iobase + 3))); + return 0; + } + if (irq > 11) { + printf("MSS: Bad IRQ %d\n", irq); + return 0; + } + if (dev->id_drq != 0 && dev->id_drq != 1 && dev->id_drq != 3) { + printf("MSS: Bad DMA %d\n", dev->id_drq); + return 0; + } + if (inb(dev->id_iobase + 3) & 0x80) { + /* 8-bit board: only drq1/3 and irq7/9 */ + if (dev->id_drq == 0) { + printf("MSS: Can't use DMA0 with a 8 bit card/slot\n"); + return 0; + } + if (irq != 7 && irq != 9) { + printf("MSS: Can't use IRQ%d with a 8 bit card/slot\n", irq); + return 0; + } + } +mss_probe_end: + return mss_detect(dev) ? 8 : 0 ; /* mss uses 8 regs */ +} + +/* + * the address passed as io_base for mss_attach is also the old + * MSS base address (e.g. 0x530). The codec is four locations ahead. + * Note that the attach routine for PnP devices might support + * device-specific initializations. + */ + +static int +mss_attach(struct isa_device *dev) +{ + snddev_info *d = &(pcm_info[dev->id_unit]); + + printf("mss_attach <%s>%d at 0x%x irq %d dma %d:%d flags 0x%x\n", + d->name, dev->id_unit, + d->io_base, d->irq, d->dma1, d->dma2, dev->id_flags); + + if ( dev->id_flags & DV_F_TRUE_MSS ) { + /* has IRQ/DMA registers, set IRQ and DMA addr */ + static char interrupt_bits[12] = { + -1, -1, -1, -1, -1, 0x28, -1, 0x08, -1, 0x10, 0x18, 0x20 + }; + static char dma_bits[4] = { 1, 2, 0, 3 }; + char bits ; + + if (d->irq == -1 || (bits = interrupt_bits[d->irq]) == -1) { + dev->id_irq = 0 ; /* makk invalid irq */ + return 0 ; + } + + outb(dev->id_iobase, bits | 0x40); /* config port */ + if ((inb(dev->id_iobase + 3) & 0x40) == 0) /* version port */ + printf("[IRQ Conflict?]"); + + /* Write IRQ+DMA setup */ + if (d->dma1 == d->dma2) /* single chan dma */ + outb(dev->id_iobase, bits | dma_bits[d->dma1]); + else { + if (d->dma1 == 0 && d->dma2 == 1) + bits |= 5 ; + else if (d->dma1 == 1 && d->dma2 == 0) + bits |= 6 ; + else if (d->dma1 == 3 && d->dma2 == 0) + bits |= 7 ; + else { + printf("invalid dual dma config %d:%d\n", + d->dma1, d->dma2); + dev->id_irq = 0 ; + return 0 ; + } + outb(dev->id_iobase, bits ); + } + } + mss_reinit(d); + ad1848_mixer_reset(d); + return 0; +} + +static int +mss_open(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf ; + d = &pcm_info[unit] ; + + s = spltty(); + /* + * This was meant to support up to 2 open descriptors for the + * some device, and check proper device usage on open. + * Unfortunately, the kernel will trap all close() calls but + * the last one, with the consequence that we cannot really + * keep track of which channels are busy. + * So, the correct tests cannot be done :( and we must rely + * on the locks on concurrent operations of the same type and + * on some approximate tests... + */ + + if (dev == SND_DEV_AUDIO) + d->flags |= SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags |= SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags |= SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY) ) { + /* + * device was idle. Do the necessary initialization, + * but no need keep interrupts blocked since this device + * will not get them + */ + + splx(s); + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + d->flags |= SND_F_BUSY ; + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + switch (dev) { + default : + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + case SND_DEV_DSP16 : + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + } + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + ask_init(d); + } + splx(s); + return 0 ; +} + +static int +mss_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + dev &= 0xf; + d = &pcm_info[unit] ; + + /* + * We will only get a single close call when the last reference + * to the device is gone. But we must handle ourselves references + * through different devices. + */ + + s = spltty(); + + if (dev == SND_DEV_AUDIO) + d->flags &= ~SND_F_BUSY_AUDIO ; + else if (dev == SND_DEV_DSP) + d->flags &= ~SND_F_BUSY_DSP ; + else if (dev == SND_DEV_DSP16) + d->flags &= ~SND_F_BUSY_DSP16 ; + if ( ! (d->flags & SND_F_BUSY_ANY) ) { /* last one ... */ + d->flags |= SND_F_CLOSING ; + splx(s); /* is this ok here ? */ + snd_flush(d); + outb(io_Status(d), 0); /* Clear interrupt status */ + d->flags = 0 ; + } + splx(s); + return 0 ; +} + +static int +mss_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + snddev_info *d; + int unit; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) { + cmd &= 0xff ; + if (cmd == SOUND_MIXER_RECSRC) + return mss_set_recsrc(d, *(int *)arg) ; + else + return mss_mixer_set(d, cmd, *(int *)arg) ; + } + + return ENOSYS ; /* fallback to the default ioctl handler */ +} + + +/* + * the callback routine to handle all dma ops etc. + */ + +static int +mss_callback(snddev_info *d, int reason) +{ + u_long s; + u_char m; + int retry, wr, cnt; + + DEB(printf("-- mss_callback reason 0x%03x\n", reason)); + wr = reason & SND_CB_WR ; + reason &= SND_CB_REASON_MASK ; + switch (reason) { + case SND_CB_INIT : /* called with int enabled and no pending I/O */ + /* + * perform all necessary initializations for i/o + */ + d->rec_fmt = d->play_fmt ; /* no split format on the WSS */ + snd_set_blocksize(d); + mss_reinit(d); + return 1 ; + break ; + + case SND_CB_START : + /* fallthrough */ + case SND_CB_RESTART : + s = spltty(); + cnt = wr ? d->dbuf_out.dl0 : d->dbuf_in.dl0 ; + if (d->play_fmt == AFMT_S16_LE) + cnt /= 2; + if (d->flags & SND_F_STEREO) + cnt /= 2; + cnt-- ; + + DEB(printf("-- (re)start cnt %d\n", cnt)); + m = ad_read(d,9) ; + DDB( if (m & 4) printf("OUCH! reg 9 0x%02x\n", m); ); + m |= wr ? I9_PEN : I9_CEN ; /* enable DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry; retry--) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to set bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, cnt); + else + ad_write_cnt(d, 30, cnt); + + splx(s); + break ; + case SND_CB_STOP : + case SND_CB_ABORT : /* XXX check this... */ + s = spltty(); + m = ad_read(d,9) ; + m &= wr ? ~I9_PEN : ~I9_CEN ; /* Stop DMA */ + /* + * on the OPTi931 the enable bit seems hard to set... + */ + for (retry = 10; retry ; retry-- ) { + ad_write(d, 9, m ); + if (ad_read(d,9) ==m) break; + } + if (retry == 0) + printf("start dma, failed to clear bit 0x%02x 0x%02x\n", + m, ad_read(d, 9) ) ; + + /* disable DMA by clearing count registers. */ + if (wr || (d->dma1 == d->dma2) ) + ad_write_cnt(d, 14, 0); + else + ad_write_cnt(d, 30, 0); + splx(s); + break; + } + return 0 ; +} + +/* + * main irq handler for the CS423x. The OPTi931 code is + * a separate one. + */ + +static void +mss_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char i11, c; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + + i11 = ad_read(d, 11); + reason = inb(io_Status(d)); + + if ( ! (reason & 1) ) /* no int, maybe a shared line ? */ + return; + /* get exact reason */ + c = (d->dma1 == d->dma2) ? 0x10 : ad_read(d, 24); + if ( (d->flags & SND_F_WR_DMA) && (c & 0x10) ) + dsp_wrintr(d); + c = (d->dma1 == d->dma2) ? 0x20 : ad_read(d, 24); + if ( (d->flags & SND_F_RD_DMA) && (c & 0x20) ) + dsp_rdintr(d); + /* XXX check this on the 4236... */ + if (d->dma1 == d->dma2) + outb(io_Status(d), 0); /* Clear interrupt status */ + else + ad_write(d, 24, ~c); /* ack selectively */ +} + +/* + * the opti931 seems to miss interrupts when working in full + * duplex. god know why... + */ +static void +opti931_intr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + u_char masked=0, i11, mc11, c=0; + u_char reason; /* b0 = playback, b1 = capture, b2 = timer */ + int loops = 10; + int w_miss=0, r_miss=0; + static int misses=0; /* XXX kludge */ + +#if 0 + reason = inb(io_Status(d)); + if ( ! (reason & 1) ) {/* no int, maybe a shared line ? */ + printf("opti931_intr: flag 0, mcir11 0x%02x\n", ad_read(d,11)); + return; + } +#endif + i11 = ad_read(d, 11); /* XXX what's for ? */ +again: + + c=mc11 = (d->dma1 == d->dma2) ? 0xc : opti_read(d->conf_base, 11); + mc11 &= 0x0c ; + if (c & 0x10) { + printf("Warning CD interrupt\n"); + mc11 |= 0x10 ; + } + if (c & 0x20) { + printf("Warning MPU interrupt\n"); + mc11 |= 0x20 ; + } + if (mc11 & masked) + printf("irq reset failed, mc11 0x%02x, masked 0x%02x\n", mc11, masked); + masked |= mc11 ; + if ( mc11 == 0 ) { /* perhaps can return ... */ + reason = inb(io_Status(d)); + if (reason & 1) { + printf("one more try...\n"); + goto again; + } + if (w_miss || r_miss ) { + misses++; + if ( (misses & 0xff) == 1 ) + printf("opti931: %d missed irq (now %s%s)\n", + misses, w_miss?"play ":"", + r_miss?"capture ":""); + } + if (loops==10) + printf("ouch, intr but nothing in mcir11 0x%02x\n", mc11); + if (w_miss) mc11 |= 4 ; + if (r_miss) mc11 |= 8 ; + if (mc11==0) + return; + } + + if ( (d->flags & SND_F_RD_DMA) && (mc11 & 8) ) { + dsp_rdintr(d); + r_miss = 0 ; + } + else if (isa_dmastatus1(d->dma2) == 0 && (d->flags & SND_F_RD_DMA) ) + r_miss = 1 ; + + if ( (d->flags & SND_F_WR_DMA) && (mc11 & 4) ) { + if (isa_dmastatus1(d->dma1) != 0) + printf("opti931_intr: wr dma %d\n", + isa_dmastatus1(d->dma1)); + dsp_wrintr(d); + w_miss = 0 ; + } + else if (isa_dmastatus1(d->dma1) == 0 && (d->flags & SND_F_WR_DMA) ) + w_miss = 1 ; + + opti_write(d->conf_base, 11, ~mc11); /* ack */ + if (--loops) goto again; + printf("xxx too many loops\n"); +} + +/* + * Second part of the file: functions local to this module. + * in this section a few routines to access MSS registers + * + */ + +static void +opti_write(int io_base, u_char reg, u_char value) +{ + outb(io_base, reg); + outb(io_base+1, value); +} + +static u_char +opti_read(int io_base, u_char reg) +{ + outb(io_base, reg); + return inb(io_base+1); +} +/* + * AD_WAIT_INIT waits if we are initializing the board and + * we cannot modify its settings + */ +static int +AD_WAIT_INIT(snddev_info *d, int x) +{ + int n = 0; /* to shut up the compiler... */ + for (; x-- ; ) + if ( (n=inb(io_Index_Addr(d))) & IA_BUSY) + DELAY(10); + else + return n ; + printf("AD_WAIT_INIT FAILED 0x%02x\n", n); + return n ; +} + +static int +ad_read(snddev_info *d, int reg) +{ + u_long flags; + int x; + + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + x = inb(io_Indexed_Data(d)); + splx(flags); + return x; +} + +static void +ad_write(snddev_info *d, int reg, u_char data) +{ + u_long flags; + + int x ; + flags = spltty(); + AD_WAIT_INIT(d, 100); + x = inb(io_Index_Addr(d)) & ~IA_AMASK ; + outb(io_Index_Addr(d), (u_char) (reg & IA_AMASK) | x ) ; + outb(io_Indexed_Data(d), data); + splx(flags); +} + +static void +ad_write_cnt(snddev_info *d, int reg, u_short cnt) +{ + ad_write(d, reg+1, cnt & 0xff ); + ad_write(d, reg, cnt >> 8 ); /* upper base must be last */ +} + +static void +wait_for_calibration(snddev_info *d) +{ + int n, t; + + /* + * Wait until the auto calibration process has finished. + * + * 1) Wait until the chip becomes ready (reads don't return 0x80). + * 2) Wait until the ACI bit of I11 gets on + * 3) Wait until the ACI bit of I11 gets off + */ + + n = AD_WAIT_INIT(d, 1000); + if (n & IA_BUSY) + printf("mss: Auto calibration timed out(1).\n"); + + for (t = 100 ; t>0 && (ad_read(d, 11) & 0x20) == 0 ; t--) + DELAY(100); + for (t = 100 ; t>0 && ad_read(d, 11) & 0x20 ; t--) + DELAY(100); +} + +#if 0 /* unused right now... */ +static void +ad_mute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) | I6_MUTE); + ad_write(d, 7, ad_read(d,7) | I6_MUTE); +} + +static void +ad_unmute(snddev_info *d) +{ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); +} +#endif + +static void +ad_enter_MCE(snddev_info *d) +{ + int prev; + + d->bd_flags |= BD_F_MCE_BIT; + AD_WAIT_INIT(d, 100); + prev = inb(io_Index_Addr(d)); + outb(io_Index_Addr(d), prev | IA_MCE | IA_TRD ) ; +} + +static void +ad_leave_MCE(snddev_info *d) +{ + u_long flags; + u_char prev; + + if ( (d->bd_flags & BD_F_MCE_BIT) == 0 ) { + printf("--- hey, leave_MCE: MCE bit was not set!\n"); + return; + } + + AD_WAIT_INIT(d, 1000); + + flags = spltty(); + d->bd_flags &= ~BD_F_MCE_BIT; + + prev = inb(io_Index_Addr(d)); + + outb(io_Index_Addr(d), (prev & ~IA_MCE) | IA_TRD); /* Clear the MCE bit */ + wait_for_calibration(d); + splx(flags); +} + +/* + * only one source can be set... + * + * fixed -- lr 970725 + */ +static int +mss_set_recsrc(snddev_info *d, int mask) +{ + u_char recdev; + + mask &= d->mix_rec_devs; + switch (mask) { + case SOUND_MASK_LINE: + case SOUND_MASK_LINE3: + recdev = 0; + break; + + case SOUND_MASK_CD: + case SOUND_MASK_LINE1: + recdev = 0x40; + break; + + case SOUND_MASK_IMIX: + recdev = 0xc0; + break; + + case SOUND_MASK_MIC: + default: + mask = SOUND_MASK_MIC; + recdev = 0x80; + } + + ad_write(d, 0, (ad_read(d, 0) & 0x3f) | recdev); + ad_write(d, 1, (ad_read(d, 1) & 0x3f) | recdev); + + d->mix_recsrc = mask; + return 0; +} + +/* + * mixer conversion table: from 0..100 scale to codec values + * + * I don't understand what's this for... maybe achieve a log-scale + * volume control ? + */ + +static char mix_cvt[101] = { + 0, 0, 3, 7,10,13,16,19,21,23,26,28,30,32,34,35,37,39,40,42, + 43,45,46,47,49,50,51,52,53,55,56,57,58,59,60,61,62,63,64,65, + 65,66,67,68,69,70,70,71,72,73,73,74,75,75,76,77,77,78,79,79, + 80,81,81,82,82,83,84,84,85,85,86,86,87,87,88,88,89,89,90,90, + 91,91,92,92,93,93,94,94,95,95,96,96,96,97,97,98,98,98,99,99, + 100 +}; + +/* + * there are differences in the mixer depending on the actual sound + * card. + */ +static int +mss_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + + int regoffs; + mixer_tab *mix_d = &mix_devices; + + u_char old, val; + + if (dev > 31) + return EINVAL; + + if (!(d->mix_devs & (1 << dev))) + return EINVAL; + + if (d->bd_id == MD_OPTI931) + mix_d = &(opti931_devices); + + if ((*mix_d)[dev][LEFT_CHN].nbits == 0) { + DDB(printf("nbits = 0 for dev %d\n", dev) ); + return EINVAL; + } + + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + + if ( (*mix_d)[dev][RIGHT_CHN].nbits == 0) /* Mono control */ + right = left; + + d->mix_levels[dev] = left | (right << 8); + + /* Scale volumes */ + left = mix_cvt[left]; + right = mix_cvt[right]; + + /* + * Set the left channel + */ + + regoffs = (*mix_d)[dev][LEFT_CHN].regno; + old = val = ad_read(d, regoffs); + if (regoffs != 0) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, LEFT_CHN, left); + ad_write(d, regoffs, val); + DEB(printf("dev %d reg %d old 0x%02x new 0x%02x\n", + dev, regoffs, old, val)); + + if ((*mix_d)[dev][RIGHT_CHN].nbits != 0) { /* have stereo */ + /* + * Set the right channel + */ + regoffs = (*mix_d)[dev][RIGHT_CHN].regno; + val = ad_read(d, regoffs); + if (regoffs != 1) + val = old & 0x7f ; /* clear mute bit. */ + change_bits(mix_d, &val, dev, RIGHT_CHN, right); + ad_write(d, regoffs, val); + } + return 0; /* success */ +} + +static void +ad1848_mixer_reset(snddev_info *d) +{ + int i; + + if (d->bd_id == MD_OPTI931) + d->mix_devs = OPTI931_MIXER_DEVICES; + else if (d->bd_id != MD_AD1848) + d->mix_devs = MODE2_MIXER_DEVICES; + else + d->mix_devs = MODE1_MIXER_DEVICES; + + d->mix_rec_devs = MODE1_REC_DEVICES; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + if (d->mix_devs & (1 << i)) + mss_mixer_set(d, i, default_mixer_levels[i]); + mss_set_recsrc(d, SOUND_MASK_MIC); +} + +/* + * mss_speed processes the value in play_speed finding the + * matching one. As a side effect, it returns the value to + * be written in the speed bits of the codec. It does _NOT_ + * set the speed of the device (but it should!) + * + * fixed lr970724 + */ + +static int +mss_speed(snddev_info *d) +{ + /* + * In the CS4231, the low 4 bits of I8 are used to hold the + * sample rate. Only a fixed number of values is allowed. This + * table lists them. The speed-setting routines scans the table + * looking for the closest match. This is the only supported method. + * + * In the CS4236, there is an alternate metod (which we do not + * support yet) which provides almost arbitrary frequency setting. + * In the AD1845, it looks like the sample rate can be + * almost arbitrary, and written directly to a register. + * In the OPTi931, there is a SB command which provides for + * almost arbitrary frequency setting. + * + */ + static int speeds[] = { + 8000, 5512, 16000, 11025, 27429, 18900, 32000, 22050, + -1, 37800, -1, 44100, 48000, 33075, 9600, 6615 + }; + + int arg, i, sel = 0; /* assume entry 0 does not contain -1 */ + + arg = d->play_speed ; + + for (i=1; i < 16 ; i++) + if (speeds[i] >0 && abs(arg-speeds[i]) < abs(arg-speeds[sel]) ) + sel = i ; + + d->play_speed = d->rec_speed = speeds[sel] ; + return sel ; +} + +/* + * mss_format checks that the format is supported (or defaults to AFMT_U8) + * and returns the bit setting for the 1848 register corresponding to + * the desired format. + * + * fixed lr970724 + */ + +static int +mss_format(snddev_info *d) +{ + int i, arg = d->play_fmt ; + + /* + * The data format uses 3 bits (just 2 on the 1848). For each + * bit setting, the following array returns the corresponding format. + * The code scans the array looking for a suitable format. In + * case it is not found, default to AFMT_U8 (not such a good + * choice, but let's do it for compatibility...). + */ + + static int fmts[] = { + AFMT_U8, AFMT_MU_LAW, AFMT_S16_LE, AFMT_A_LAW, + -1, AFMT_IMA_ADPCM, AFMT_U16_BE, -1 + }; + + if ( (arg & d->audio_fmt) == 0 ) /* unsupported fmt, default to AFMT_U8 */ + arg = AFMT_U8 ; + + /* ulaw/alaw seems broken on the opti931... */ + if (d->bd_id == MD_OPTI931) { + if (arg == AFMT_MU_LAW) { + arg = AFMT_U8 ; + d->flags |= SND_F_XLAT8 ; + } else + d->flags &= ~SND_F_XLAT8 ; + } + /* + * check that arg is one of the supported formats in d->format; + * otherwise fallback to AFMT_U8 + */ + + for (i=0 ; i<8 ; i++) + if (arg == fmts[i]) break; + if (i==8) { /* not found, default to AFMT_U8 */ + arg = AFMT_U8 ; + i = 0 ; + } + d->play_fmt = d->rec_fmt = arg; + + return i ; +} + +/* + * mss_detect can be used in the probe and the attach routine. + * + * We store probe information in pcm_info[unit]. This descriptor + * is reinitialized just before the attach, so all relevant + * information is lost, and mss_detect must be run again in + * the attach routine if necessary. + */ + +int +mss_detect(struct isa_device *dev) +{ + int i; + u_char tmp, tmp1, tmp2 ; + snddev_info *d = &(pcm_info[dev->id_unit]); + char *name; + + d->io_base = dev->id_iobase; + d->bd_flags |= BD_F_MCE_BIT ; + if (d->bd_id != 0) { + printf("preselected bd_id 0x%04x -- %s\n", + d->bd_id, d->name ? d->name : "???"); + return 1; + } + + name = "AD1848" ; + d->bd_id = MD_AD1848; /* AD1848 or CS4248 */ + + /* + * Check that the I/O address is in use. + * + * bit 7 of the base I/O port is known to be 0 after the chip has + * performed it's power on initialization. Just assume this has + * happened before the OS is starting. + * + * If the I/O address is unused, it typically returns 0xff. + */ + + for (i=0; i<10; i++) + if (inb(io_Index_Addr(d)) & IA_BUSY) + DELAY(10000); /* maybe busy, wait & retry later */ + else + break ; + if ((inb(io_Index_Addr(d)) & IA_BUSY) != 0x00) { /* Not a AD1848 */ + DDB(printf("mss_detect error, busy still set (0x%02x)\n", + inb(io_Index_Addr(d)))); + return 0; + } + /* + * Test if it's possible to change contents of the indirect + * registers. Registers 0 and 1 are ADC volume registers. The bit + * 0x10 is read only so try to avoid using it. + */ + + ad_write(d, 0, 0xaa); + ad_write(d, 1, 0x45);/* 0x55 with bit 0x10 clear */ + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + if ( tmp1 != 0xaa || tmp2 != 0x45) { + DDB(printf("mss_detect error - IREG (0x%02x/0x%02x) want 0xaa/0x45\n", + tmp1, tmp2)); + return 0; + } + + ad_write(d, 0, 0x45); + ad_write(d, 1, 0xaa); + tmp1 = ad_read(d, 0) ; + tmp2 = ad_read(d, 1) ; + + if (tmp1 != 0x45 || tmp2 != 0xaa) { + DDB(printf("mss_detect error - IREG2 (%x/%x)\n", tmp1, tmp2)); + return 0; + } + + /* + * The indirect register I12 has some read only bits. Lets try to + * change them. + */ + + tmp = ad_read(d, 12); + ad_write(d, 12, (~tmp) & 0x0f); + tmp1 = ad_read(d, 12); + + if ((tmp & 0x0f) != (tmp1 & 0x0f)) { + DDB(printf("mss_detect error - I12 (0x%02x was 0x%02x)\n", + tmp1, tmp)); + return 0; + } + + /* + * NOTE! Last 4 bits of the reg I12 tell the chip revision. + * 0x01=RevB + * 0x0A=RevC. also CS4231/CS4231A and OPTi931 + */ + + printf("mss_detect - chip revision 0x%02x\n", tmp & 0x0f); + + /* + * The original AD1848/CS4248 has just 16 indirect registers. This + * means that I0 and I16 should return the same value (etc.). Ensure + * that the Mode2 enable bit of I12 is 0. Otherwise this test fails + * with new parts. + */ + + ad_write(d, 12, 0); /* Mode2=disabled */ + + for (i = 0; i < 16; i++) + if ((tmp1 = ad_read(d, i)) != (tmp2 = ad_read(d, i + 16))) { + DDB(printf("mss_detect warning - I%d: 0x%02x/0x%02x\n", + i, tmp1, tmp2)); + /* + * note - this seems to fail on the 4232 on I11. So we just break + * rather than fail. + */ + break ; /* return 0; */ + } + /* + * Try to switch the chip to mode2 (CS4231) by setting the MODE2 bit + * (0x40). The bit 0x80 is always 1 in CS4248 and CS4231. + * + * On the OPTi931, however, I12 is readonly and only contains the + * chip revision ID (as in the CS4231A). The upper bits return 0. + */ + + ad_write(d, 12, 0x40); /* Set mode2, clear 0x80 */ + + tmp1 = ad_read(d, 12); + if (tmp1 & 0x80) { + name = "CS4248" ; /* Our best knowledge just now */ + } + if ((tmp1 & 0xf0) == 0x00) { + printf("this should be an OPTi931\n"); + } else if ((tmp1 & 0xc0) == 0xC0) { + /* + * The 4231 has bit7=1 always, and bit6 we just set to 1. + * We want to check that this is really a CS4231 + * Verify that setting I0 doesn't change I16. + */ + ad_write(d, 16, 0); /* Set I16 to known value */ + + ad_write(d, 0, 0x45); + if ((tmp1 = ad_read(d, 16)) != 0x45) { /* No change -> CS4231? */ + + ad_write(d, 0, 0xaa); + if ((tmp1 = ad_read(d, 16)) == 0xaa) { /* Rotten bits? */ + DDB(printf("mss_detect error - step H(%x)\n", tmp1)); + return 0; + } + /* + * Verify that some bits of I25 are read only. + */ + + DDB(printf("mss_detect() - step I\n")); + tmp1 = ad_read(d, 25); /* Original bits */ + ad_write(d, 25, ~tmp1); /* Invert all bits */ + if ((ad_read(d, 25) & 0xe7) == (tmp1 & 0xe7)) { + int id; + + /* + * It's at least CS4231 + */ + name = "CS4231" ; + d->bd_id = MD_CS4231; + + /* + * It could be an AD1845 or CS4231A as well. + * CS4231 and AD1845 report the same revision info in I25 + * while the CS4231A reports different. + */ + + id = ad_read(d, 25) & 0xe7; + /* + * b7-b5 = version number; + * 100 : all CS4231 + * 101 : CS4231A + * + * b2-b0 = chip id; + */ + switch (id) { + + case 0xa0: + name = "CS4231A" ; + d->bd_id = MD_CS4231A; + break; + + case 0xa2: + name = "CS4232" ; + d->bd_id = MD_CS4232; + break; + + case 0xb2: + /* strange: the 4231 data sheet says b4-b3 are XX + * so this should be the same as 0xa2 + */ + name = "CS4232A" ; + d->bd_id = MD_CS4232A; + break; + + case 0x80: + /* + * It must be a CS4231 or AD1845. The register I23 + * of CS4231 is undefined and it appears to be read + * only. AD1845 uses I23 for setting sample rate. + * Assume the chip is AD1845 if I23 is changeable. + */ + + tmp = ad_read(d, 23); + + ad_write(d, 23, ~tmp); + if (ad_read(d, 23) != tmp) { /* AD1845 ? */ + name = "AD1845" ; + d->bd_id = MD_AD1845; + } + ad_write(d, 23, tmp); /* Restore */ + break; + + case 0x83: /* CS4236 */ + name = "CS4236"; + d->bd_id = MD_CS4236; + break ; + + default: /* Assume CS4231 */ + printf("unknown id 0x%02x, assuming CS4231\n", id); + d->bd_id = MD_CS4231; + + } + } + ad_write(d, 25, tmp1); /* Restore bits */ + + } + } + DDB(printf("mss_detect() - Detected %s\n", name)); + strcpy(d->name, name); + dev->id_flags &= ~DV_F_DEV_MASK ; + dev->id_flags |= (d->bd_id << DV_F_DEV_SHIFT) & DV_F_DEV_MASK ; + return 1; +} + + +/* + * mss_reinit resets registers of the codec + */ +static void +mss_reinit(snddev_info *d) +{ + u_char r; + + r = mss_speed(d) ; + r |= (mss_format(d) << 5) ; + if (d->flags & SND_F_STEREO) + r |= 0x10 ; + /* XXX check if MCE is necessary... */ + ad_enter_MCE(d); + + /* + * perhaps this is not the place to set mode2, should be done + * only once at attach time... + */ + if ( d->dma1 != d->dma2 && d->bd_id != MD_OPTI931) + /* + * set mode2 bit for dual dma op. This bit is not implemented + * on the OPTi931 + */ + ad_write(d, 12, ad_read(d, 12) | 0x40 /* mode 2 on the CS42xx */ ); + + /* + * XXX this should really go into mss-speed... + */ + if (d->bd_id == MD_AD1845) { /* Use alternate speed select regs */ + r &= 0xf0; /* Mask off the rate select bits */ + + ad_write(d, 22, (d->play_speed >> 8) & 0xff); /* Speed MSB */ + ad_write(d, 23, d->play_speed & 0xff); /* Speed LSB */ + /* + * XXX must also do something in I27 for the ad1845 + */ + } + + ad_write(d, 8, r) ; + if (d->dma1 != d->dma2) { + ad_write(d, 28, r & 0xf0 ) ; /* capture mode */ + ad_write(d, 9, 0 /* no capture, no playback, dual dma */) ; + } else + ad_write(d, 9, 4 /* no capture, no playback, single dma */) ; + ad_leave_MCE(d); + ad_write_cnt(d, 14, 0 ); /* playback count */ + if (d->dma1 != d->dma2) + ad_write_cnt(d, 30, 0 ); /* rec. count on dual dma */ + + ad_write(d, 10, 2 /* int enable */) ; + outb(io_Status(d), 0); /* Clear interrupt status */ + /* the following seem required on the CS4232 */ + ad_write(d, 6, ad_read(d,6) & ~I6_MUTE); + ad_write(d, 7, ad_read(d,7) & ~I6_MUTE); + + snd_set_blocksize(d); /* update blocksize if user did not force it */ +} + +/* + * here we have support for PnP cards + * + */ + +#if NPNP > 0 + +static char * cs4236_probe(u_long csn, u_long vend_id); +static void cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device cs4236 = { + "cs423x", + cs4236_probe, + cs4236_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, cs4236); + +static char * +cs4236_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x3742630e) + s = "CS4237" ; + else if (vend_id == 0x3642630e) + s = "CS4236" ; + else if (vend_id == 0x3242630e) + s = "CS4232" ; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s; + } + + return NULL ; +} + +extern snddev_info sb_op_desc; + +static void +cs4236_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int ldn = 0 ; + + if (read_pnp_parms ( &d , ldn ) == 0 ) { + printf("failed to read pnp parms\n"); + return ; + } + snddev_last_probed = &tmp_d; +#if 0 + /* sb-compatible codec */ + dev->id_iobase = d.port[2] ; + tmp_d = sb_op_desc ; + tmp_d.alt_base = d.port[0] - 4; + d.drq[1] = 4 ; /* disable, it is not used ... */ + d.drq[0] = 0 ; /* remap ... */ +#else + /* mss-compatible codec */ + dev->id_iobase = d.port[0] -4 ; /* XXX old mss have 4 bytes before... */ + tmp_d = mss_op_desc ; + tmp_d.bd_id = MD_CS4232 ; /* to short-circuit the detect routine */ + tmp_d.alt_base = d.port[2]; + strcpy(tmp_d.name, name); + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; +#endif + write_pnp_parms( &d, ldn ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; /* during the probe... */ + snddev_last_probed->probe(dev); + + pcmattach(dev); +} + +static char *opti931_probe(u_long csn, u_long vend_id); +static void opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device opti931 = { + "OPTi931", + opti931_probe, + opti931_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti931); + +static char * +opti931_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x3109143e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 1); + if (d.enable == 0) { + printf("This is an OPTi931, but LDN 1 is disabled\n"); + return NULL ; + } + return "OPTi931" ; + } + return NULL ; +} + +static void +opti931_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int p; + int sb_mode = 0 ; /* XXX still not work in SB mode */ + + read_pnp_parms ( &d , 3 ); /* free resources taken by LDN 3 */ + d.irq[0]=0; /* free irq... */ + d.port[0]=0; /* free address... */ + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + write_pnp_parms( &d, 1 ); + enable_pnp_card(); + + snddev_last_probed = &tmp_d; + tmp_d = sb_mode ? sb_op_desc : mss_op_desc ; + + strcpy(tmp_d.name, name); + + /* + * My MED3931 v.1.0 allocates 3 bytes for the config space, + * whereas v.2.0 allocates 4 bytes. What I know for sure is that the + * upper two ports must be used, and they should end on a boundary + * of 4 bytes. So I need the following trick... + */ + p = tmp_d.conf_base = (d.port[3] & ~3) + 2; /* config port */ + + /* + * now set default values for both modes. + */ + dev->id_iobase = d.port[0] - 4 ; /* old mss have 4 bytes before... */ + tmp_d.io_base = dev->id_iobase; /* needed for ad_write to work... */ + tmp_d.alt_base = d.port[2]; + opti_write(p, 4, 0x56 /* fifo 1/2, OPL3, audio enable, SB3.2 */ ); + ad_write (&tmp_d, 10, 2); /* enable interrupts */ + + if (sb_mode) { /* sb-compatible codec */ + /* + * the 931 is not a real SB, it has important pieces of + * hardware controlled by both the WSS and the SB port... + */ + opti_write(p, 6, 1); /* MCIR6 wss disable, sb enable */ + /* + * swap the main and alternate iobase address since we want + * to work in sb mode. + */ + dev->id_iobase = d.port[2] ; + tmp_d.alt_base = d.port[0] - 4; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + } else { /* mss-compatible codec */ + tmp_d.bd_id = MD_OPTI931 ; /* to short-circuit the detect routine */ + opti_write(p, 6 , 2); /* MCIR6: wss enable, sb disable */ +#if 0 /* not working yet... */ + opti_write(p, 5, 0x0 /* codec in single mode */ ); + dev->id_flags = 0 ; +#else + opti_write(p, 5, 0x28); /* MCIR5: codec in exp. mode,fifo */ + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; +#endif + tmp_d.audio_fmt |= AFMT_FULLDUPLEX ; /* not really well... */ + tmp_d.isr = opti931_intr; + } + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + pcmattach(dev); +} + +static char *guspnp_probe(u_long csn, u_long vend_id); +static void guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); +static struct pnp_device guspnp = { + "GusPnP", + guspnp_probe, + guspnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, guspnp); + +static char * +guspnp_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x0100561e) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a GusPnP, but LDN 0 is disabled\n"); + return NULL ; + } + return "GusPnP" ; + } + return NULL ; +} + +static void +guspnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + read_pnp_parms ( &d , 0 ) ; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + tmp_d = mss_op_desc ; + snddev_last_probed = &tmp_d; + + dev->id_iobase = d.port[2] - 4 ; /* room for 4 mss registers */ + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | d.drq[1] ; + + tmp_d.alt_base = d.port[0]; + + pcmattach(dev); +} +#endif /* NPNP > 0 */ +#endif /* NPCM > 0 */ diff --git a/sys/i386/isa/snd/clones.c b/sys/i386/isa/snd/clones.c new file mode 100644 index 000000000000..edb64f68e14e --- /dev/null +++ b/sys/i386/isa/snd/clones.c @@ -0,0 +1,262 @@ +/* + * sound/clones.c + * + * init code for enabling clone cards to work in sb/mss emulation. + * + * Note -- this code is currently unused! + * + * Copyright by Luigi Rizzo - 1997 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * This file has been written using information from various sources + * in the Voxware 3.5 distribution. + */ + +#include +#if NPCM > 0 + +/* + * Known clones card include: + * + * Trix (emulating MSS) + * MAD16 (emulating MSS) + * OPTi930 -- same as the OPTi931, but no PnP ? + */ + + +#ifdef JAZZ16 + +/* + * Initialization of a Media Vision ProSonic 16 Soundcard. The function + * initializes a ProSonic 16 like PROS.EXE does for DOS. It sets the base + * address, the DMA-channels, interrupts and enables the joystickport. + * + * Also used by Jazz 16 (same card, different name) + * + * written 1994 by Rainer Vranken E-Mail: + * rvranken@polaris.informatik.uni-essen.de + */ + +#ifdef SM_WAVE +/* + * Logitech Soundman Wave detection and initialization by Hannu Savolainen. + * + * There is a microcontroller (8031) in the SM Wave card for MIDI emulation. + * it's located at address MPU_BASE+4. MPU_BASE+7 is a SM Wave specific + * control register for MC reset, SCSI, OPL4 and DSP (future expansion) + * address decoding. Otherwise the SM Wave is just a ordinary MV Jazz16 based + * soundcard. + */ + +static void +smw_putmem(int base, int addr, u_char val) +{ + u_long s; + + s = spltty(); + + outb(base + 1, addr & 0xff); /* Low address bits */ + outb(base + 2, addr >> 8); /* High address bits */ + outb(base, val); /* Data */ + + splx(s); +} + +static u_char +smw_getmem(int base, int addr) +{ + u_long s; + u_char val; + + s = spltty(); + + outb(base + 1, addr & 0xff); /* Low address bits */ + outb(base + 2, addr >> 8); /* High address bits */ + val = inb(base); /* Data */ + + splx(s); + return val; +} + +#ifdef SMW_MIDI0001_INCLUDED +#include +#else +u_char *smw_ucode = NULL; +int smw_ucodeLen = 0; +#endif /* SWM_MIDI0001_INCLUDED */ + +static int +initialize_smw(int mpu_base) +{ + + int i, mp_base = mpu_base + 4; /* Microcontroller base */ + u_char control; + + /* + * Reset the microcontroller so that the RAM can be accessed + */ + + control = inb(mpu_base + 7); + outb(mpu_base + 7, control | 3); /* Set last two bits to 1 (?) */ + outb(mpu_base + 7, (control & 0xfe) | 2); /* xxxxxxx0 resets the mc */ + DELAY(3000); /* Wait at least 1ms */ + + outb(mpu_base + 7, control & 0xfc); /* xxxxxx00 enables RAM */ + + /* + * Detect microcontroller by probing the 8k RAM area + */ + smw_putmem(mp_base, 0, 0x00); + smw_putmem(mp_base, 1, 0xff); + DELAY(10); + + if (smw_getmem(mp_base, 0) != 0x00 || smw_getmem(mp_base, 1) != 0xff) { + printf("\nSM Wave: No microcontroller RAM detected (%02x, %02x)\n", + smw_getmem(mp_base, 0), smw_getmem(mp_base, 1)); + return 0; /* No RAM */ + } + /* + * There is RAM so assume it's really a SM Wave + */ + + if (smw_ucodeLen > 0) { + if (smw_ucodeLen != 8192) { + printf("\nSM Wave: Invalid microcode (MIDI0001.BIN) length\n"); + return 1; + } + /* + * Download microcode + */ + + for (i = 0; i < 8192; i++) + smw_putmem(mp_base, i, smw_ucode[i]); + + /* + * Verify microcode + */ + + for (i = 0; i < 8192; i++) + if (smw_getmem(mp_base, i) != smw_ucode[i]) { + printf("SM Wave: Microcode verification failed\n"); + return 0; + } + } + control = 0; +#ifdef SMW_SCSI_IRQ + /* + * Set the SCSI interrupt (IRQ2/9, IRQ3 or IRQ10). The SCSI interrupt + * is disabled by default. + * + * Btw the Zilog 5380 SCSI controller is located at MPU base + 0x10. + */ + { + static u_char scsi_irq_bits[] = + {0, 0, 3, 1, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0}; + + control |= scsi_irq_bits[SMW_SCSI_IRQ] << 6; + } +#endif + +#ifdef SMW_OPL4_ENABLE + /* + * Make the OPL4 chip visible on the PC bus at 0x380. + * + * There is no need to enable this feature since VoxWare doesn't support + * OPL4 yet. Also there is no RAM in SM Wave so enabling OPL4 is + * pretty useless. + */ + control |= 0x10; /* Uses IRQ12 if bit 0x20 == 0 */ + /* control |= 0x20; Uncomment this if you want to use IRQ7 */ +#endif + + outb(mpu_base + 7, control | 0x03); /* xxxxxx11 restarts */ + return 1; +} + +#endif + +/* + * this is only called during the probe. Variables are found in + * sb_probed. + */ +static sbdev_info sb_probed ; +static int +initialize_ProSonic16(snddev_info *d) +{ + int x; + static u_char int_translat[16] = + {0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6}, + dma_translat[8] = + {0, 1, 0, 2, 0, 3, 0, 4}; + + struct address_info *mpu_config; + + int mpu_base, mpu_irq; + + if ((mpu_config = NULL)) { + mpu_base = mpu_config->io_base; + mpu_irq = mpu_config->irq; + } else { + mpu_base = mpu_irq = 0; + } + + outb(0x201, 0xAF); /* ProSonic/Jazz16 wakeup */ + DELAY(15000); /* wait at least 10 milliseconds */ + outb(0x201, 0x50); + outb(0x201, (sb_probed.io_base & 0x70) | ((mpu_base & 0x30) >> 4)); + + if (sb_reset_dsp(sb_probed.io_base)) { /* OK. We have at least a SB */ + + /* Check the version number of ProSonic (I guess) */ + + if (!sb_cmd(sb_probed.io_base, 0xFA)) + return 1; + if (sb_get_byte(sb_probed.io_base) != 0x12) + return 1; + + if (sb_cmd(sb_probed.io_base, 0xFB) && /* set DMA and irq */ + sb_cmd(sb_probed.io_base, + (dma_translat[JAZZ_DMA16]<<4)|dma_translat[sb_probed.dma1]) && + sb_cmd(sb_probed.io_base, + (int_translat[mpu_irq]<<4)|int_translat[sb_probed.irq])) { + d->bf_flags |= BD_F_JAZZ16 ; + if (mpu_base == 0) + printf("Jazz16: No MPU401 devices configured " + "- MIDI port not initialized\n"); + +#ifdef SM_WAVE + if (mpu_base != 0) + if (initialize_smw(mpu_base)) + d->bf_flags |= BD_F_JAZZ16_2 ; +#endif + /* sb_dsp_disable_midi(); */ + } + return 1; /* There was at least a SB */ + } + return 0; /* No SB or ProSonic16 detected */ +} + +#endif /* ifdef JAZZ16 */ + +#endif /* NPCM */ diff --git a/sys/i386/isa/snd/dmabuf.c b/sys/i386/isa/snd/dmabuf.c new file mode 100644 index 000000000000..d4ac55ef5448 --- /dev/null +++ b/sys/i386/isa/snd/dmabuf.c @@ -0,0 +1,864 @@ +/* + * snd/dmabuf.c + * + * New DMA routines -- Luigi Rizzo, 19 jul 97 + * This file implements the new DMA routines for the sound driver. + * + * Copyright by Luigi Rizzo - 1997 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#include +#include + +#define MIN_CHUNK_SIZE 256 /* for uiomove etc. */ +#define DMA_ALIGN_BITS 2 /* i.e. 4 bytes */ +#define DMA_ALIGN_THRESHOLD (1<< DMA_ALIGN_BITS) +#define DMA_ALIGN_MASK (~ (DMA_ALIGN_THRESHOLD - 1)) + +static void dsp_wr_dmadone(snddev_info *d); +static void dsp_rd_dmadone(snddev_info *d); + +/* + * + +SOUND OUTPUT + +We use a circular buffer to store samples directed to the DAC. +The buffer is split into three variable-size regions, each identified +by an offset in the buffer (dp,rp,fp) and a lenght (dl,rl,fl). + + 0 dp,dl rp,rl fp,fl bufsize + |__________|_____>______|_____________|________| + FREE DMA READY FREE + + READY region: contains data written from the process and ready + to be sent to the DAC; + + FREE region: is the empty region of the buffer, where a process + can write new data. + + DMA region: contains data being sent to the DAC by the DMA engine. + the actual boundary between the FREE and READY regions is in + fact within the DMA region (indicated by the > symbol above), + and advances as the DMA engine makes progress. + +Both the "READY" and "FREE" regions can wrap around the end of the +buffer. The "DMA" region can only wrap if AUTO DMA is used, otherwise +it cannot cross the end of the buffer. + +Since dl can be updated on the fly, dl0 marks the value used when the +operation was started. When using AUTO DMA, bufsize-(count in the ISA DMA +register) directly reflects the position of dp. + +At initialization, DMA and READY are empty, and FREE takes all the +available space: + + dp = rp = fp = 0 ; -- beginning of buffer + dl0 = dl = 0 ; -- meaning no dma activity + rl = 0 ; -- meaning no data ready + fl = bufsize ; + +The DMA region is also empty whenever there is no DMA activity, for +whatever reason (e.g. no ready data, or output is paused). +The code works as follows: the user write routine dsp_write_body() +fills up the READY region with new data (reclaiming space from the +FREE region) and starts the write DMA engine if inactive (activity +is indicated by d->flags & SND_F_WR_DMA ). The size of each +DMA transfer is chosen according to a series of rules which will be +discussed later. When a DMA transfer is complete, an interrupt causes +dsp_wrintr() to be called which empties the DMA region, extends +the FREE region and possibly starts the next transfer. + +In some cases, the code tries to track the current status of DMA +operations by calling isa_dmastatus() and advancing the boundary +between FREE and DMA regions accordingly. + +The size of a DMA transfer is selected according to the following +rules: + + 1. when not using AUTO DMA, do not wrap around the end of the + buffer, and do not let fp move too close to the end of the + buffer; + + 2. do not use more than half of the buffer size. + This serves to allow room for a next write operation concurrent + with the dma transfer, and to reduce the time which is necessary + to wait before a pending dma will end (optionally, the max + size could be further limited to a fixed amount of play time, + depending on number of channels, sample size and sample speed); + + 3. use the current blocksize (either specified by the user, or + corresponding roughly to 0.25s of data); + + * + */ + + +/* + * dsp_wr_dmadone moves the write DMA region into the FREE region. + * It is assumed to be called at spltty() and with a write dma + * previously started. + */ +static void +dsp_wr_dmadone(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + + isa_dmadone(B_WRITE, b->buf + b->dp, b->dl, d->dma1); + b->fl += b->dl ; /* make dl bytes free */ + /* + * XXX here it would be more efficient to record if there + * actually is a sleeping process, but this should still work. + */ + wakeup(b); /* wakeup possible sleepers */ + if (d->wsel.si_pid && + ( !(d->flags & SND_F_HAS_SIZE) || b->fl >= d->play_blocksize ) ) + selwakeup( & d->wsel ); + b->dp = b->rp ; + b->dl0 = b->dl = 0 ; +} + +/* + * The following function tracks the status of a (write) dma transfer, + * and moves the boundary between the FREE and the DMA regions. + * It works under the following assumptions: + * - the DMA engine is running; + * - the routine is called with interrupts blocked. + * BEWARE: when using AUTO DMA, dl can go negative! We assume that it + * does not wrap! + */ +void +dsp_wr_dmaupdate(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + int tmp; + + tmp = b->dl - isa_dmastatus1(d->dma1) ; + tmp &= DMA_ALIGN_MASK; /* align... */ + if (tmp > 0) { /* we have some new data */ + b->dp += tmp; + if (b->dp >= b->bufsize) + b->dp -= b->bufsize; + b->dl -= tmp ; + b->fl += tmp ; + } +} + +/* + * Write interrupt routine. Can be called from other places, but + * with interrupts disabled. + */ +void +dsp_wrintr(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + int cb_reason = SND_CB_WR ; + + DEB(printf("dsp_wrintr: start on dl %d, rl %d, fl %d\n", + b->dl, b->rl, b->fl)); + if (d->flags & SND_F_WR_DMA) { /* dma was active */ + b->int_count++; + d->flags &= ~SND_F_WR_DMA; + cb_reason = SND_CB_WR | SND_CB_RESTART ; + dsp_wr_dmadone(d); + } else + cb_reason = SND_CB_WR | SND_CB_START ; + + /* + * start another dma operation only if have ready data in the + * buffer, there is no pending abort, have a full-duplex device + * (dma1 != dma2) or have half duplex device and there is no + * pending op on the other side. + * + * Force transfer to be aligned to a boundary of 4, which is + * needed when doing stereo and 16-bit. We could make this + * adaptive, but why bother for now... + */ + if ( b->rl >= DMA_ALIGN_THRESHOLD && + ! (d->flags & SND_F_ABORTING) && + ( (d->dma1 != d->dma2) || ! (d->flags & SND_F_READING) ) ) { + b->dl = min(b->rl, b->bufsize - b->rp ) ; /* do not wrap */ + b->dl = min(b->dl, d->play_blocksize ); /* avoid too large transfer */ + b->dl &= DMA_ALIGN_MASK ; /* realign things */ + b->rl -= b->dl ; + b->rp += b->dl ; + if (b->rp == b->bufsize) + b->rp = 0 ; + /* + * now try to avoid too small dma transfers in the near future. + * This can happen if I let rp start too close to the end of + * the buffer. If this happens, and have enough data, try to + * split the available block in two approx. equal parts. + * XXX this code can go when we use auto dma. + */ + if (b->bufsize - b->rp < MIN_CHUNK_SIZE && + b->bufsize - b->dp > 2*MIN_CHUNK_SIZE) { + b->dl = (b->bufsize - b->dp) / 2; + b->dl &= ~3 ; /* align to a boundary of 4 */ + b->rl += (b->rp - (b->dp + b->dl) ) ; + b->rp = b->dp + b->dl ; /* no need to check for wraps */ + } + /* + * how important is the order of operations ? + */ + if (b->dl == 0) { + printf("ouch... want to start for 0 bytes!\n"); + goto ferma; + } + b->dl0 = b->dl ; /* XXX */ + if (d->callback) + d->callback(d, cb_reason ); /* start/restart dma */ + isa_dmastart( B_WRITE , b->buf + b->dp, b->dl, d->dma1); + d->flags |= SND_F_WR_DMA; + } else { +ferma: + if (d->callback && (cb_reason & SND_CB_REASON_MASK) == SND_CB_RESTART ) + d->callback(d, SND_CB_WR | SND_CB_STOP ); /* stop dma */ + /* + * if switching to read, should start the read dma... + */ + if ( d->dma1 == d->dma2 && (d->flags & SND_F_READING) ) + dsp_rdintr(d); + DEB(printf("cannot start wr-dma flags 0x%08x dma_dl %d rl %d\n", + d->flags, isa_dmastatus1(d->dma1), b->rl)); + } +} + +/* + * user write routine + * + * advance the boundary between READY and FREE, fill the space with + * uiomove(), and possibly start DMA. Do the above until the transfer + * is complete. + * + * To minimize latency in case a pending DMA transfer is about to end, + * we do the transfer in pieces of increasing sizes, extending the + * READY area at every checkpoint. In the (necessary) assumption that + * memory bandwidth is larger than the rate at which the dma consumes + * data, we reduce the latency to something proportional to the length + * of the first piece, while keeping the overhead low and being able + * to feed the DMA with large blocks. + */ + +int +dsp_write_body(snddev_info *d, struct uio *buf) +{ + int timeout = 1, n, l, bsz, ret = 0 ; + long s; + snd_dbuf *b = & (d->dbuf_out) ; + + /* assume d->flags |= SND_F_WRITING ; has been done before */ + /* + * bsz is the max size for the next transfer. If the dma was + * idle, we want it as large as possible. Otherwise, start with + * a small block to avoid underruns if we are close to the end of + * the previous operation. + */ + bsz = (d->flags & SND_F_WR_DMA) ? MIN_CHUNK_SIZE : b->bufsize ; + while ( n = buf->uio_resid ) { + l = min (n, bsz); /* at most n bytes ... */ + s = spltty(); /* no interrupts here ... */ + /* + * if i) the dma engine is running, ii) we do not have enough space + * in the FREE region, and iii) the current DMA transfer might let + * us complete the _whole_ transfer without sleeping, or we are doing + * non-blocking I/O, then try to extend the FREE region. + * Otherwise do not bother, we will need to sleep anyways, and + * make the timeout longer. + */ + + if ( d->flags & SND_F_WR_DMA && b->fl < l && + ( b->fl + b->dl >= n || d->flags & SND_F_NBIO ) ) + dsp_wr_dmaupdate(d); /* should really change timeout... */ + else + timeout = hz; + l = min( l, b->fl ); /* no more than avail. space */ + l = min( l, b->bufsize - b->fp ); /* do not wrap ... */ + DEB(printf("dsp_write_body: prepare %d bytes out of %d\n", l,n)); + /* + * at this point, we assume that if l==0 the dma engine + * must (or will, in cause it is paused) be running. + */ + if (l == 0) { /* no space, must sleep */ + if (d->flags & SND_F_NBIO) { + /* unless of course we are doing non-blocking i/o */ + splx(s); + break; + } + DEB(printf("dsp_write_body: l=0, (fl %d) sleeping\n", b->fl)); + ret = tsleep( (caddr_t)b, PRIBIO|PCATCH, "dspwr", timeout); + if (ret == EINTR) + d->flags |= SND_F_ABORTING ; + splx(s); + if (ret == ERESTART || ret == EINTR) + break ; + timeout = min(2*timeout, hz); + continue; + } + splx(s); + timeout = 1 ; /* we got some data... */ + + /* + * copy data to the buffer, and possibly do format + * conversions (here, from ULAW to U8). + * NOTE: I can use fp here since it is not modified by the + * interrupt routines. + */ + ret = uiomove(b->buf + b->fp, l, buf) ; + if (ret !=0 ) { /* an error occurred ... */ + printf("uiomove error %d\n", ret); + break ; + } + if (d->flags & SND_F_XLAT8) + translate_bytes(ulaw_dsp, b->buf + b->fp, l); + + s = spltty(); /* no interrupts here ... */ + b->rl += l ; /* this more ready bytes */ + b->fl -= l ; /* this less free bytes */ + b->fp += l ; + if (b->fp >= b->bufsize) /* handle wraps */ + b->fp -= b->bufsize ; + if ( !(d->flags & SND_F_WR_DMA) ) {/* dma was idle, restart it */ + if ( (d->flags & (SND_F_INIT|SND_F_WR_DMA|SND_F_RD_DMA)) == + SND_F_INIT) { + /* want to init but no pending DMA activity */ + splx(s); + d->callback(d, SND_CB_INIT); /* this is slow! */ + s = spltty(); + } + dsp_wrintr(d) ; + } + splx(s) ; + bsz = min(b->bufsize, bsz*2); + } + s = spltty(); /* no interrupts here ... */ + d->flags &= ~SND_F_WRITING ; + if (d->flags & SND_F_ABORTING) { + d->flags &= ~SND_F_ABORTING; + splx(s); + dsp_wrabort(d); + } + splx(s) ; + return ret ; +} + +/* + * SOUND INPUT + * + +The input part is similar to the output one. The only difference is in +the ordering of regions, which is the following: + + 0 rp,rl dp,dl fp,fl bufsize + |__________|____________|______>______|________| + FREE READY DMA FREE + +and the fact that input data are in the READY region. + +At initialization, as for the write routine, DMA and READY are empty, +and FREE takes all the space: + + dp = rp = fp = 0 ; -- beginning of buffer + dl0 = dl = 0 ; -- meaning no dma activity + rl = 0 ; -- meaning no data ready + fl = bufsize ; + +Operation is as follows: upon user read (dsp_read_body()) a DMA read +is started if not already active (marked by d->flags & SND_F_RD_DMA), +then as soon as data are available in the READY region they are +transferred to the user buffer, thus advancing the boundary between FREE +and READY. Upon interrupts, caused by a completion of a DMA transfer, +the READY region is extended and possibly a new transfer is started. + +When necessary, isa_dmastatus() is called to advance the boundary +between READY and DMA to the real position. + +The rules to choose the size of the new DMA area are similar to +the other case, i.e: + + 1. if not using AUTO mode, do not wrap around the end of the + buffer, and do not let fp move too close to the end of the + buffer; + + 2. do not use more than half the buffer size; this serves to + leave room for the next dma operation. + + 3. use the default blocksize, either user-specified, or + corresponding to 0.25s of data; + + * + */ + +/* + * dsp_rd_dmadone moves bytes in the input buffer from DMA region to + * READY region. We assume it is called at spltty() and with dl>0 + */ +static void +dsp_rd_dmadone(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + + isa_dmadone(B_READ, b->buf + b->dp, b->dl, d->dma2); + b->rl += b->dl ; /* make dl bytes available */ + wakeup(b) ; /* wakeup possibly sleeping processes */ + if (d->rsel.si_pid && + ( !(d->flags & SND_F_HAS_SIZE) || b->rl >= d->rec_blocksize ) ) + selwakeup( & d->rsel ); + b->dp = b->fp ; + b->dl0 = b->dl = 0 ; +} + +/* + * The following function tracks the status of a (read) dma transfer, + * and moves the boundary between the READY and the DMA regions. + * It works under the following assumptions: + * - the DMA engine is running; + * - the function is called with interrupts blocked. + */ +void +dsp_rd_dmaupdate(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + int tmp ; + + tmp = b->dl - isa_dmastatus1(d->dma2) ; + tmp &= DMA_ALIGN_MASK; /* align... */ + if (tmp > 0) { /* we have some data */ + b->dp += tmp; + if (b->dp >= b->bufsize) + b->dp -= b->bufsize; + b->dl -= tmp ; + b->rl += tmp ; + } +} + +/* + * read interrupt routine. Must be called with interrupts blocked. + */ +void +dsp_rdintr(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + int cb_reason = SND_CB_RD ; + + DEB(printf("dsp_rdintr: start dl = %d fp %d blocksize %d\n", + b->dl, b->fp, d->rec_blocksize)); + if (d->flags & SND_F_RD_DMA) { /* dma was active */ + b->int_count++; + d->flags &= ~SND_F_RD_DMA; + cb_reason = SND_CB_RD | SND_CB_RESTART ; + dsp_rd_dmadone(d); + } else + cb_reason = SND_CB_RD | SND_CB_START ; + /* + * Same checks as in the write case (mutatis mutandis) to decide + * whether or not to restart a dma transfer. + */ + if ( b->fl >= DMA_ALIGN_THRESHOLD && + ((d->flags & (SND_F_ABORTING|SND_F_CLOSING)) == 0) && + ( (d->dma1 != d->dma2) || ( (d->flags & SND_F_WRITING) == 0) ) ) { + b->dl = min(b->fl, b->bufsize - b->fp ) ; /* do not wrap */ + b->dl = min(b->dl, d->rec_blocksize ); + b->dl &= DMA_ALIGN_MASK ; /* realign sizes */ + b->fl -= b->dl ; + b->fp += b->dl ; + if (b->fp == b->bufsize) + b->fp = 0 ; + /* + * now try to avoid too small dma transfers in the near future. + * This can happen if I let fp start too close to the end of + * the buffer. If this happens, and have enough data, try to + * split the available block in two approx. equal parts. + */ + if (b->bufsize - b->fp < MIN_CHUNK_SIZE && + b->bufsize - b->dp > 2*MIN_CHUNK_SIZE) { + b->dl = (b->bufsize - b->dp) / 2; + b->dl &= DMA_ALIGN_MASK ; /* align to multiples of 3 */ + b->fl += (b->fp - (b->dp + b->dl) ) ; + b->fp = b->dp + b->dl ; /* no need to check that fp wraps */ + } + if (b->dl == 0) { + printf("ouch! want to read 0 bytes\n"); + goto ferma; + } + b->dl0 = b->dl ; /* XXX */ + if (d->callback) + d->callback(d, cb_reason); /* restart_dma(); */ + isa_dmastart( B_READ , b->buf + b->dp, b->dl, d->dma2); + d->flags |= SND_F_RD_DMA; + } else { +ferma: + if (d->callback && (cb_reason & SND_CB_REASON_MASK) == SND_CB_RESTART) + d->callback(d, SND_CB_RD | SND_CB_STOP); + /* + * if switching to write, start write dma engine + */ + if ( d->dma1 == d->dma2 && (d->flags & SND_F_WRITING) ) + dsp_wrintr(d) ; + DEB(printf("cannot start rd-dma flags 0x%08x dma_dl %d fl %d\n", + d->flags, isa_dmastatus1(d->dma2), b->fl)); + } +} + +/* + * body of user-read routine + * + * Start DMA if not active; wait for READY not empty. + * Transfer data from READY region using uiomove(), advance boundary + * between FREE and READY. Repeat until transfer is complete. + * + * To avoid excessive latency in freeing up space for the DMA + * engine, transfers are done in blocks of increasing size, so that + * the latency is proportional to the size of the smallest block, but + * we have a low overhead and are able to feed the dma engine with + * large blocks. + * + * When we enter this routine, we assume that d->flags |= SND_F_READING + * was done before. + * + * NOTE: in the current version, read will not return more than + * blocksize bytes at once (unless more are already available), to + * avoid that requests using very large buffers block for too long. + */ + +int +dsp_read_body(snddev_info *d, struct uio *buf) +{ + int limit, l, n, bsz, ret = 0 ; + long s; + snd_dbuf *b = & (d->dbuf_in) ; + + int timeout = 1 ; /* counter of how many ticks we sleep */ + + /* + * "limit" serves to return after at most one blocksize of data + * (unless more are already available). Otherwise, things like + * cat /dev/audio would use a 64K buffer and would start returning + * data after a _very_ long time... + * Note -- some applications depend on reads not returning short + * blocks. But I believe these apps are broken, since interrupted + * system calls might return short reads anyways, and the + * application should better check that. + */ + + if (buf->uio_resid > d->rec_blocksize) + limit = buf->uio_resid - d->rec_blocksize; + else + limit = 0; + bsz = MIN_CHUNK_SIZE ; /* the current transfer (doubles at each step) */ + while ( (n = buf->uio_resid) > limit ) { + DEB(printf("dsp_read_body: start waiting for %d bytes\n", n)); + /* + * here compute how many bytes to transfer, enforcing various + * limitations: + */ + l = min (n, bsz); /* 1': at most bsz bytes ... */ + s = spltty(); /* no interrupts here ! */ + /* + * if i) the dma engine is running, ii) we do not have enough + * ready bytes, and iii) the current DMA transfer could give + * us what we need, or we are doing non-blocking IO, then try + * to extend the READY region. + * Otherwise do not bother, we will need to sleep anyways, + * and make the timeout longer. + */ + + if ( d->flags & SND_F_RD_DMA && b->rl < l && + ( d->flags & SND_F_NBIO || b->rl + b->dl >= n - limit ) ) + dsp_rd_dmaupdate(d); + else + timeout = hz ; + l = min( l, b->rl ); /* 2': no more than avail. data */ + l = min( l, b->bufsize - b->rp ); /* 3': do not wrap buffer. */ + /* the above limitation can be removed if we use auto DMA + * on the ISA controller. But then we have to make a check + * when doing the uiomove... + */ + if ( !(d->flags & SND_F_RD_DMA) ) { /* dma was idle, start it */ + /* + * There are two reasons the dma can be idle: either this + * is the first read, or the buffer has become full. In + * the latter case, the dma cannot be restarted until + * we have removed some data, which will be true at the + * second round. + * + * Call dsp_rdintr to start the dma. It would be nice to + * have a "need" field in the snd_dbuf, so that we do + * not start a long operation unnecessarily. However, + * the restart code will ask for at most d->blocksize + * bytes, and since we are sure we are the only reader, + * and the routine is not interrupted, we patch and + * restore d->blocksize around the call. A bit dirty, + * but it works, and saves some overhead :) + */ + + int old_bs = d->rec_blocksize; + + if ( (d->flags & (SND_F_INIT|SND_F_WR_DMA|SND_F_RD_DMA)) == + SND_F_INIT) { + /* want to init but no pending DMA activity */ + splx(s); + d->callback(d, SND_CB_INIT); /* this is slow! */ + s = spltty(); + } + if (l < MIN_CHUNK_SIZE) + d->rec_blocksize = MIN_CHUNK_SIZE ; + else if (l < d->rec_blocksize) + d->rec_blocksize = l ; + dsp_rdintr(d); + d->rec_blocksize = old_bs ; + } + + if (l == 0) { + /* + * If, after all these efforts, we still have no data ready, + * then we must sleep (unless of course we have doing + * non-blocking i/o. But use exponential delays, starting + * at 1 tick and doubling each time. + */ + if (d->flags & SND_F_NBIO) { + splx(s); + break; + } + DEB(printf("dsp_read_body: sleeping %d waiting for %d bytes\n", + timeout, buf->uio_resid)); + ret = tsleep( (caddr_t)b, PRIBIO | PCATCH , "dsprd", timeout ) ; + if (ret == EINTR) + d->flags |= SND_F_ABORTING ; + splx(s); /* necessary before the goto again... */ + if (ret == ERESTART || ret == EINTR) + break ; + DEB(printf("woke up, ret %d, rl %d\n", ret, b->rl)); + timeout = min(timeout*2, hz); + continue; + } + splx(s); + + timeout = 1 ; /* we got some data, so reset exp. wait */ + /* + * if we are using /dev/audio and the device does not + * support it natively, we should do a format conversion. + * (in this case from uLAW to natural format). + * This can be messy in that it can require an intermediate + * buffer, and also screw up the byte count. + */ + /* + * NOTE: I _can_ use rp here because it is not modified by the + * interrupt routines. + */ + if (d->flags & SND_F_XLAT8) + translate_bytes(dsp_ulaw, b->buf + b->rp, l); + ret = uiomove(b->buf + b->rp, l, buf) ; + if (ret !=0 ) /* an error occurred ... */ + break ; + + s = spltty(); /* no interrupts here ... */ + b->fl += l ; /* this more free bytes */ + b->rl -= l ; /* this less ready bytes */ + b->rp += l ; /* advance ready pointer */ + if (b->rp == b->bufsize) /* handle wraps */ + b->rp = 0 ; + splx(s) ; + bsz = min(b->bufsize, bsz*2); + } + s = spltty(); /* no interrupts here ... */ + d->flags &= ~SND_F_READING ; + if (d->flags & SND_F_ABORTING) { + d->flags |= ~SND_F_ABORTING; + splx(s); + dsp_rdabort(d); + } + splx(s) ; + return ret ; +} + + +/* + * short routine to initialize a dma buffer descriptor (usually + * located in the XXX_desc structure). The first parameter is + * the buffer size, the second one specifies the dma channel in use + * At the moment we do not support more than 64K, since for some + * cards I need to switch between dma1 and dma2. The channel is + * unused. + */ +void +alloc_dbuf(snd_dbuf *b, int size, int chan) +{ + if (size > 0x10000) + panic("max supported size is 64k"); + b->buf = contigmalloc(size, M_DEVBUF, M_NOWAIT, + 0ul, 0xfffffful, 1ul, 0x10000ul); + /* should check that it does not fail... */ + b->dp = b->rp = b->fp = 0 ; + b->dl0 = b->dl = b->rl = 0 ; + b->bufsize = b->fl = size ; +} + +void +reset_dbuf(snd_dbuf *b) +{ + b->dp = b->rp = b->fp = 0 ; + b->dl0 = b->dl = b->rl = 0 ; + b->fl = b->bufsize ; +} + +/* + * snd_sync waits until the space in the given channel goes above + * a threshold. chan = 1 : play, 2: capture. The threshold is + * checked against fl or rl respectively. + * Assume that the condition can become true, do not check here... + */ +int +snd_sync(snddev_info *d, int chan, int threshold) +{ + u_long s; + int ret; + snd_dbuf *b; + + b = (chan == 1) ? &(d->dbuf_out ) : &(d->dbuf_in ) ; + + for (;;) { + s=spltty(); + if ( chan==1 ) + dsp_wr_dmaupdate(d); + else + dsp_rd_dmaupdate(d); + if ( (chan == 1 && b->fl <= threshold) || + (chan == 2 && b->rl <= threshold) ) { + ret = tsleep((caddr_t)b, PRIBIO|PCATCH, "sndsyn", 1); + splx(s); + if (ret == ERESTART || ret == EINTR) { + printf("tsleep returns %d\n", ret); + return -1 ; + } + } else + break; + } + splx(s); + return 0 ; +} + +/* + * dsp_wrabort(d) and dsp_rdabort(d) are non-blocking functions + * which abort a pending DMA transfer and flush the buffers. + */ +int +dsp_wrabort(snddev_info *d) +{ + long s; + int missing = 0; + snd_dbuf *b = & (d->dbuf_out) ; + + s = spltty(); + if ( d->flags & SND_F_WR_DMA ) { + d->flags &= ~(SND_F_WR_DMA | SND_F_WRITING); + if (d->callback) + d->callback(d, SND_CB_WR | SND_CB_ABORT); + missing = isa_dmastop(d->dma1) ; /* this many missing bytes... */ + + b->rl += missing ; /* which are part of the ready area */ + b->rp -= missing ; + if (b->rp < 0) + b->rp += b->bufsize; + DEB(printf("dsp_wrabort: stopped after %d bytes out of %d\n", + b->dl - missing, b->dl)); + b->dl -= missing; + dsp_wr_dmadone(d); + missing = b->rl; + } + reset_dbuf(b); + splx(s); + return missing; +} + +int +dsp_rdabort(snddev_info *d) +{ + long s; + int missing = 0; + snd_dbuf *b = & (d->dbuf_in) ; + + s = spltty(); + if ( d->flags & SND_F_RD_DMA ) { + d->flags &= ~(SND_F_RD_DMA | SND_F_READING); + if (d->callback) + d->callback(d, SND_CB_RD | SND_CB_ABORT); + missing = isa_dmastop(d->dma2) ; /* this many missing bytes... */ + + b->fl += missing ; /* which are part of the free area */ + b->fp -= missing ; + if (b->fp < 0) + b->fp += b->bufsize; + DEB(printf("dsp_rdabort: stopped after %d bytes out of %d\n", + b->dl - missing, b->dl)); + b->dl -= missing; + dsp_rd_dmadone(d); + missing = b->rl ; + } + reset_dbuf(b); + splx(s); + return missing; +} + +/* + * this routine tries to flush the dma transfer. It is called + * on a close. The caller must set SND_F_CLOSING, and insure that + * interrupts are enabled. We immediately abort any read DMA + * operation, and then wait for the play buffer to drain. + */ + +int +snd_flush(snddev_info *d) +{ + int ret, res, res1; + int count=10; + +DEB(printf("snd_flush d->flags 0x%08x\n", d->flags)); + dsp_rdabort(d); + if ( d->flags & SND_F_WR_DMA ) { + /* close write */ + while ( d->flags & SND_F_WR_DMA ) { + /* + * still pending output data. + */ + ret = tsleep( (caddr_t)&(d->dbuf_out), PRIBIO|PCATCH, "dmafl1", hz); + if (ret == ERESTART || ret == EINTR) { + printf("tsleep returns %d\n", ret); + return -1 ; + } + if ( ret && --count == 0) { + printf("timeout flushing dma1, cnt 0x%x flags 0x%08x\n", + isa_dmastatus1(d->dma1), d->flags); + return -1 ; + } + } + d->flags &= ~SND_F_CLOSING ; + } + reset_dbuf(& (d->dbuf_out) ); + return 0 ; +} + +/* + * end of new code for dma buffer handling + */ diff --git a/sys/i386/isa/snd/dmabuf_auto.c b/sys/i386/isa/snd/dmabuf_auto.c new file mode 100644 index 000000000000..3972be8c41f5 --- /dev/null +++ b/sys/i386/isa/snd/dmabuf_auto.c @@ -0,0 +1,802 @@ +/* + * snd/dmabuf.c + * + * New DMA routines -- Luigi Rizzo, 05 sep 97 + * This file implements the new DMA routines for the sound driver. + * AUTO DMA MODE (ISA DMA SIDE). + * + * Copyright by Luigi Rizzo - 1997 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include +#include + +#define MIN_CHUNK_SIZE 256 /* for uiomove etc. */ +#define DMA_ALIGN_BITS 2 /* i.e. 4 bytes */ +#define DMA_ALIGN_THRESHOLD (1<< DMA_ALIGN_BITS) +#define DMA_ALIGN_MASK (~ (DMA_ALIGN_THRESHOLD - 1)) + +static void dsp_wr_dmadone(snddev_info *d); +static void dsp_rd_dmadone(snddev_info *d); + +/* + * + +SOUND OUTPUT + +We use a circular buffer to store samples directed to the DAC. +The buffer is split into two variable-size regions, each identified +by an offset in the buffer (rp,fp) and a lenght (rl,fl). + + 0 rp,rl fp,fl bufsize + |__________|____________|________| + FREE d> READY w> FREE + + READY region: contains data written from the process and ready + to be sent to the DAC; + + FREE region: is the empty region of the buffer, where a process + can write new data. + +The first block of the READY region is used for DMA transfers. The +transfer is started at rp and with chunks of length dl0 computed +according to some rules. During DMA operations, rp advances (d>) +and rl,fl are updated by dsp_wr_dmaupdate(). When a new block is +written, fp advances (w>) and rl,fl are updated accordingly. + +Both the "READY" and "FREE" regions can wrap around the end of the +buffer. + +At initialization, READY is empty, FREE takes all the +available space, and dma is idle + +dl0 contains the new blocksize to be used in dma transfers (passed to +the callback). dl contains the previous blocksize (needed when the +codec uses AUTO DMA). + + rp = fp = 0 ; -- beginning of buffer + dl0 = dl = 0 ; + rl = 0 ; -- meaning no data ready + fl = bufsize ; + +The code works as follows: the user write routine dsp_write_body() +fills up the READY region with new data (reclaiming space from the +FREE region) and starts the write DMA engine if inactive (activity +is indicated by d->flags & SND_F_WR_DMA ). The size of each +DMA transfer is chosen according to a series of rules which will be +discussed later. When a DMA transfer is complete, an interrupt causes +dsp_wrintr() to be called which empties the DMA region, extends +the FREE region and possibly starts the next transfer. + +In some cases, the code tries to track the current status of DMA +operations by calling isa_dmastatus() and advancing the boundary +between FREE and DMA regions accordingly. + +The size of a DMA transfer is selected according to the following +rules: + + 1. when not using AUTO DMA, do not wrap around the end of the + buffer, and do not let fp move too close to the end of the + buffer; + + 2. do not use more than half of the buffer size. + This serves to allow room for a next write operation concurrent + with the dma transfer, and to reduce the time which is necessary + to wait before a pending dma will end (optionally, the max + size could be further limited to a fixed amount of play time, + depending on number of channels, sample size and sample speed); + + 3. use the current blocksize (either specified by the user, or + corresponding roughly to 0.25s of data); + + * + */ + + +/* + * dsp_wr_dmadone moves the write DMA region into the FREE region. + * It is assumed to be called at spltty() and with a write dma + * previously started. + */ +static void +dsp_wr_dmadone(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + + dsp_wr_dmaupdate(d); + /* + * XXX here it would be more efficient to record if there + * actually is a sleeping process, but this should still work. + */ + wakeup(b); /* wakeup possible sleepers */ + if (d->wsel.si_pid && + ( !(d->flags & SND_F_HAS_SIZE) || b->fl >= d->play_blocksize ) ) + selwakeup( & d->wsel ); +} + +/* + * The following function tracks the status of a (write) dma transfer, + * and moves the boundary between the FREE and the DMA regions. + * It works under the following assumptions: + * - the DMA engine is active; + * - the routine is called with interrupts blocked. + */ +void +dsp_wr_dmaupdate(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + int tmp, delta; + + tmp = b->bufsize - isa_dmastatus1(d->dma1) ; + tmp &= DMA_ALIGN_MASK; /* align... */ + delta = tmp - b->rp; + if (delta < 0) /* wrapped */ + delta += b->bufsize ; + b->rp = tmp; + b->rl -= delta ; + b->fl += delta ; +} + +/* + * Write interrupt routine. Can be called from other places, but + * with interrupts disabled. + */ +void +dsp_wrintr(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_out) ; + + DEB(printf("dsp_wrintr: start on dl %d, rl %d, fl %d\n", + b->dl, b->rl, b->fl)); + if (d->flags & SND_F_WR_DMA) { /* dma was active */ + b->int_count++; + d->flags &= ~SND_F_WR_DMA; + dsp_wr_dmadone(d); + } else + b->dl = 0 ; + + /* + * start another dma operation only if have ready data in the + * buffer, there is no pending abort, have a full-duplex device + * (dma1 != dma2) or have half duplex device and there is no + * pending op on the other side. + * + * Force transfer to be aligned to a boundary of 4, which is + * needed when doing stereo and 16-bit. We could make this + * adaptive, but why bother for now... + */ + if ( b->rl >= DMA_ALIGN_THRESHOLD && + ! (d->flags & SND_F_ABORTING) && + ( (d->dma1 != d->dma2) || ! (d->flags & SND_F_READING) ) ) { + int l = min(b->rl, d->play_blocksize ); /* avoid too large transfer */ + l &= DMA_ALIGN_MASK ; /* realign things */ + + b->dl0 = l ; + if (d->callback) + d->callback(d, SND_CB_WR | SND_CB_START ); + d->flags |= SND_F_WR_DMA; + b->dl = b->dl0; + } else { + if (b->dl > 0) { /* was active */ + b->dl0 = 0; + d->callback(d, SND_CB_WR | SND_CB_STOP ); /* stop dma */ + } + /* + * if switching to read, should start the read dma... + */ + if ( d->dma1 == d->dma2 && (d->flags & SND_F_READING) ) + dsp_rdintr(d); + DEB(printf("cannot start wr-dma flags 0x%08x dma_dl %d rl %d\n", + d->flags, isa_dmastatus1(d->dma1), b->rl)); + } +} + +/* + * user write routine + * + * advance the boundary between READY and FREE, fill the space with + * uiomove(), and possibly start DMA. Do the above until the transfer + * is complete. + * + * To minimize latency in case a pending DMA transfer is about to end, + * we do the transfer in pieces of increasing sizes, extending the + * READY area at every checkpoint. In the (necessary) assumption that + * memory bandwidth is larger than the rate at which the dma consumes + * data, we reduce the latency to something proportional to the length + * of the first piece, while keeping the overhead low and being able + * to feed the DMA with large blocks. + */ + +int +dsp_write_body(snddev_info *d, struct uio *buf) +{ + int timeout = 1, n, l, bsz, ret = 0 ; + long s; + snd_dbuf *b = & (d->dbuf_out) ; + + /* assume d->flags |= SND_F_WRITING ; has been done before */ + /* + * bsz is the max size for the next transfer. If the dma was + * idle, we want it as large as possible. Otherwise, start with + * a small block to avoid underruns if we are close to the end of + * the previous operation. + */ + bsz = (d->flags & SND_F_WR_DMA) ? MIN_CHUNK_SIZE : b->bufsize ; + while ( n = buf->uio_resid ) { + l = min (n, bsz); /* at most n bytes ... */ + s = spltty(); /* no interrupts here ... */ + /* + * if i) the dma engine is running, ii) we do not have enough space + * in the FREE region, and iii) the current DMA transfer might let + * us complete the _whole_ transfer without sleeping, or we are doing + * non-blocking I/O, then try to extend the FREE region. + * Otherwise do not bother, we will need to sleep anyways, and + * make the timeout longer. + * Note that the check for iii) is only approximate since we + * might have fewer than dl0 residual bytes. + */ + + if ( d->flags & SND_F_WR_DMA && b->fl < l && + ( b->fl + b->dl0 >= n || d->flags & SND_F_NBIO ) ) + dsp_wr_dmaupdate(d); /* should really change timeout... */ + else + timeout = hz; + l = min( l, b->fl ); /* no more than avail. space */ + DEB(printf("dsp_write_body: prepare %d bytes out of %d\n", l,n)); + /* + * at this point, we assume that if l==0 the dma engine + * must (or will, in cause it is paused) be running. + */ + if (l == 0) { /* no space, must sleep */ + if (d->flags & SND_F_NBIO) { + /* unless of course we are doing non-blocking i/o */ + splx(s); + break; + } + DEB(printf("dsp_write_body: l=0, (fl %d) sleeping\n", b->fl)); + ret = tsleep( (caddr_t)b, PRIBIO|PCATCH, "dspwr", timeout); + if (ret == EINTR) + d->flags |= SND_F_ABORTING ; + splx(s); + if (ret == ERESTART || ret == EINTR) + break ; + timeout = min(2*timeout, hz); + continue; + } + splx(s); + timeout = 1 ; /* we got some data... */ + + /* + * copy data to the buffer, and possibly do format + * conversions (here, from ULAW to U8). + * NOTE: I can use fp here since it is not modified by the + * interrupt routines. + */ + if (b->fp + l > b->bufsize) { + int l1 = b->bufsize - b->fp ; + uiomove(b->buf + b->fp, l1, buf) ; + uiomove(b->buf, l - l1, buf) ; + if (d->flags & SND_F_XLAT8) { + translate_bytes(ulaw_dsp, b->buf + b->fp, l1); + translate_bytes(ulaw_dsp, b->buf , l - l1); + } + } else { + uiomove(b->buf + b->fp, l, buf) ; + if (d->flags & SND_F_XLAT8) + translate_bytes(ulaw_dsp, b->buf + b->fp, l); + } + + s = spltty(); /* no interrupts here ... */ + b->rl += l ; /* this more ready bytes */ + b->fl -= l ; /* this less free bytes */ + b->fp += l ; + if (b->fp >= b->bufsize) /* handle wraps */ + b->fp -= b->bufsize ; + if ( !(d->flags & SND_F_WR_DMA) ) /* dma was idle, restart it */ + dsp_wrintr(d) ; + splx(s) ; + bsz = min(b->bufsize, bsz*2); + } + s = spltty(); /* no interrupts here ... */ + d->flags &= ~SND_F_WRITING ; + if (d->flags & SND_F_ABORTING) { + d->flags &= ~SND_F_ABORTING; + splx(s); + dsp_wrabort(d); + } + splx(s) ; + return ret ; +} + +/* + * SOUND INPUT + * + +The input part is similar to the output one. The only difference is in +the ordering of regions, which is the following: + + 0 rp,rl fp,fl bufsize + |__________|____________|________| + FREE r> READY d> FREE + +and the fact that input data are in the READY region. + +At initialization, as for the write routine, READY is empty, +and FREE takes all the space: + + rp = fp = 0 ; -- beginning of buffer + dl0 = dl = 0 ; + rl = 0 ; -- meaning no data ready + fl = bufsize ; + +Operation is as follows: upon user read (dsp_read_body()) a DMA read +is started if not already active (marked by d->flags & SND_F_RD_DMA), +then as soon as data are available in the READY region they are +transferred to the user buffer, thus advancing the boundary between FREE +and READY. Upon interrupts, caused by a completion of a DMA transfer, +the READY region is extended and possibly a new transfer is started. + +When necessary, dsp_rd_dmaupdate() is called to advance fp (and update +rl,fl accordingly). Upon user reads, rp is advanced and rl,fl are +updated accordingly. + + +The rules to choose the size of the new DMA area are similar to +the other case, i.e: + + 1. if not using AUTO mode, do not wrap around the end of the + buffer, and do not let fp move too close to the end of the + buffer; + + 2. do not use more than half the buffer size; this serves to + leave room for the next dma operation. + + 3. use the default blocksize, either user-specified, or + corresponding to 0.25s of data; + + * + */ + +/* + * dsp_rd_dmadone moves bytes in the input buffer from DMA region to + * READY region. We assume it is called at spltty() and with dl>0 + */ +static void +dsp_rd_dmadone(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + + dsp_rd_dmaupdate(d); + b->rl += b->dl ; /* make dl bytes available */ + wakeup(b) ; /* wakeup possibly sleeping processes */ + if (d->rsel.si_pid && + ( !(d->flags & SND_F_HAS_SIZE) || b->rl >= d->rec_blocksize ) ) + selwakeup( & d->rsel ); + b->dp = b->fp ; + b->dl0 = b->dl = 0 ; +} + +/* + * The following function tracks the status of a (read) dma transfer, + * and moves the boundary between the READY and the DMA regions. + * It works under the following assumptions: + * - the DMA engine is running; + * - the function is called with interrupts blocked. + */ +void +dsp_rd_dmaupdate(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + int tmp ; + + tmp = b->bufsize - isa_dmastatus1(d->dma2) ; + tmp &= DMA_ALIGN_MASK; /* align... */ + delta = tmp - b->fp; + if (delta < 0) /* wrapped */ + delta += b->bufsize ; + b->fp = tmp; + b->fl -= delta ; + b->rl += delta ; +} + +/* + * read interrupt routine. Must be called with interrupts blocked. + */ +void +dsp_rdintr(snddev_info *d) +{ + snd_dbuf *b = & (d->dbuf_in) ; + + if (d->flags & SND_F_RD_DMA) { /* dma was active */ + b->int_count++; + d->flags &= ~SND_F_RD_DMA; + dsp_rd_dmadone(d); + } else + b->dl = 0 ; + /* + * Same checks as in the write case (mutatis mutandis) to decide + * whether or not to restart a dma transfer. + */ + if ( b->fl >= DMA_ALIGN_THRESHOLD && + ((d->flags & (SND_F_ABORTING|SND_F_CLOSING)) == 0) && + ( (d->dma1 != d->dma2) || ( (d->flags & SND_F_WRITING) == 0) ) ) { + int l = min(b->fl, d->rec_blocksize); + l &= DMA_ALIGN_MASK ; /* realign sizes */ + b->dl0 = l ; + if (d->callback) + d->callback(d, SND_CB_RD | SND_CB_START ); + d->flags |= SND_F_RD_DMA; + b->dl = b->dl0; + } else { + if (b->dl > 0) { + b->dl0 = 0 ; /* was active */ + d->callback(d, SND_CB_RD | SND_CB_STOP); + } + /* + * if switching to write, start write dma engine + */ + if ( d->dma1 == d->dma2 && (d->flags & SND_F_WRITING) ) + dsp_wrintr(d) ; + DEB(printf("cannot start rd-dma flags 0x%08x dma_dl %d fl %d\n", + d->flags, isa_dmastatus1(d->dma2), b->fl)); + } +} + +/* + * body of user-read routine + * + * Start DMA if not active; wait for READY not empty. + * Transfer data from READY region using uiomove(), advance boundary + * between FREE and READY. Repeat until transfer is complete. + * + * To avoid excessive latency in freeing up space for the DMA + * engine, transfers are done in blocks of increasing size, so that + * the latency is proportional to the size of the smallest block, but + * we have a low overhead and are able to feed the dma engine with + * large blocks. + * + * When we enter this routine, we assume that d->flags |= SND_F_READING + * was done before. + * + * NOTE: in the current version, read will not return more than + * blocksize bytes at once (unless more are already available), to + * avoid that requests using very large buffers block for too long. + */ + +int +dsp_read_body(snddev_info *d, struct uio *buf) +{ + int limit, l, n, bsz, ret = 0 ; + long s; + snd_dbuf *b = & (d->dbuf_in) ; + + int timeout = 1 ; /* counter of how many ticks we sleep */ + + /* + * "limit" serves to return after at most one blocksize of data + * (unless more are already available). Otherwise, things like + * cat /dev/audio would use a 64K buffer and would start returning + * data after a _very_ long time... + * Note -- some applications depend on reads not returning short + * blocks. But I believe these apps are broken, since interrupted + * system calls might return short reads anyways, and the + * application should better check that. + */ + + if (buf->uio_resid > d->rec_blocksize) + limit = buf->uio_resid - d->rec_blocksize; + else + limit = 0; + bsz = MIN_CHUNK_SIZE ; /* the current transfer (doubles at each step) */ + while ( (n = buf->uio_resid) > limit ) { + DEB(printf("dsp_read_body: start waiting for %d bytes\n", n)); + /* + * here compute how many bytes to transfer, enforcing various + * limitations: + */ + l = min (n, bsz); /* 1': at most bsz bytes ... */ + s = spltty(); /* no interrupts here ! */ + /* + * if i) the dma engine is running, ii) we do not have enough + * ready bytes, and iii) the current DMA transfer could give + * us what we need, or we are doing non-blocking IO, then try + * to extend the READY region. + * Otherwise do not bother, we will need to sleep anyways, + * and make the timeout longer. + */ + + if ( d->flags & SND_F_RD_DMA && b->rl < l && + ( d->flags & SND_F_NBIO || b->rl + b->dl >= n - limit ) ) + dsp_rd_dmaupdate(d); + else + timeout = hz ; + l = min( l, b->rl ); /* 2': no more than avail. data */ + if ( !(d->flags & SND_F_RD_DMA) ) { /* dma was idle, start it */ + /* + * There are two reasons the dma can be idle: either this + * is the first read, or the buffer has become full. In + * the latter case, the dma cannot be restarted until + * we have removed some data, which will be true at the + * second round. + * + * Call dsp_rdintr to start the dma. It would be nice to + * have a "need" field in the snd_dbuf, so that we do + * not start a long operation unnecessarily. However, + * the restart code will ask for at most d->blocksize + * bytes, and since we are sure we are the only reader, + * and the routine is not interrupted, we patch and + * restore d->blocksize around the call. A bit dirty, + * but it works, and saves some overhead :) + */ + + int old_bs = d->rec_blocksize; + if ( (d->flags & (SND_F_INIT|SND_F_WR_DMA|SND_F_RD_DMA)) == + SND_F_INIT) { + /* want to init but no pending DMA activity */ + splx(s); + d->callback(d, SND_CB_INIT); /* this is slow! */ + s = spltty(); + } + if (l < MIN_CHUNK_SIZE) + d->rec_blocksize = MIN_CHUNK_SIZE ; + else if (l < d->rec_blocksize) + d->rec_blocksize = l ; + d->dl0 = d->rec_blocksize ; + dsp_rdintr(d); + d->rec_blocksize = old_bs ; + } + + if (l == 0) { + /* + * If, after all these efforts, we still have no data ready, + * then we must sleep (unless of course we have doing + * non-blocking i/o. But use exponential delays, starting + * at 1 tick and doubling each time. + */ + if (d->flags & SND_F_NBIO) { + splx(s); + break; + } + DEB(printf("dsp_read_body: sleeping %d waiting for %d bytes\n", + timeout, buf->uio_resid)); + ret = tsleep( (caddr_t)b, PRIBIO | PCATCH , "dsprd", timeout ) ; + if (ret == EINTR) + d->flags |= SND_F_ABORTING ; + splx(s); /* necessary before the goto again... */ + if (ret == ERESTART || ret == EINTR) + break ; + DEB(printf("woke up, ret %d, rl %d\n", ret, b->rl)); + timeout = min(timeout*2, hz); + continue; + } + splx(s); + + timeout = 1 ; /* we got some data, so reset exp. wait */ + /* + * if we are using /dev/audio and the device does not + * support it natively, we should do a format conversion. + * (in this case from uLAW to natural format). + * This can be messy in that it can require an intermediate + * buffer, and also screw up the byte count. + */ + /* + * NOTE: I _can_ use rp here because it is not modified by the + * interrupt routines. + */ + if (d->flags & SND_F_XLAT8) + translate_bytes(dsp_ulaw, b->buf + b->rp, l); + ret = uiomove(b->buf + b->rp, l, buf) ; + if (ret !=0 ) /* an error occurred ... */ + break ; + + s = spltty(); /* no interrupts here ... */ + b->fl += l ; /* this more free bytes */ + b->rl -= l ; /* this less ready bytes */ + b->rp += l ; /* advance ready pointer */ + if (b->rp == b->bufsize) /* handle wraps */ + b->rp = 0 ; + splx(s) ; + bsz = min(b->bufsize, bsz*2); + } + s = spltty(); /* no interrupts here ... */ + d->flags &= ~SND_F_READING ; + if (d->flags & SND_F_ABORTING) { + d->flags |= ~SND_F_ABORTING; + splx(s); + dsp_rdabort(d); + } + splx(s) ; + return ret ; +} + + +/* + * short routine to initialize a dma buffer descriptor (usually + * located in the XXX_desc structure). The first parameter is + * the buffer size, the second one specifies that a 16-bit dma channel + * is used (hence the buffer must be properly aligned). + */ +void +alloc_dbuf(snd_dbuf *b, int size, int chan) +{ + if (size > 0x10000) + panic("max supported size is 64k"); + b->buf = contigmalloc(size, M_DEVBUF, M_NOWAIT, + 0ul, 0xfffffful, 1ul, 0x10000ul); + /* should check that it does not fail... */ + b->dp = b->rp = b->fp = 0 ; + b->dl0 = b->dl = b->rl = 0 ; + b->bufsize = b->fl = size ; +} + +void +reset_dbuf(snd_dbuf *b) +{ + b->dp = b->rp = b->fp = 0 ; + b->dl0 = b->dl = b->rl = 0 ; + b->fl = b->bufsize ; +} + +/* + * snd_sync waits until the space in the given channel goes above + * a threshold. chan = 1 : play, 2: capture. The threshold is + * checked against fl or rl respectively. + * Assume that the condition can become true, do not check here... + */ +int +snd_sync(snddev_info *d, int chan, int threshold) +{ + u_long s; + int ret; + snd_dbuf *b; + + b = (chan == 1) ? &(d->dbuf_out ) : &(d->dbuf_in ) ; + + for (;;) { + s=spltty(); + if ( chan==1 ) + dsp_wr_dmaupdate(d); + else + dsp_rd_dmaupdate(d); + if ( (chan == 1 && b->fl <= threshold) || + (chan == 2 && b->rl <= threshold) ) { + ret = tsleep((caddr_t)b, PRIBIO|PCATCH, "sndsyn", 1); + splx(s); + if (ret == ERESTART || ret == EINTR) { + printf("tsleep returns %d\n", ret); + return -1 ; + } + } else + break; + } + splx(s); + return 0 ; +} + +/* + * dsp_wrabort(d) and dsp_rdabort(d) are non-blocking functions + * which abort a pending DMA transfer and flush the buffers. + */ +int +dsp_wrabort(snddev_info *d) +{ + long s; + int missing = 0; + snd_dbuf *b = & (d->dbuf_out) ; + + s = spltty(); + if ( d->flags & SND_F_WR_DMA ) { + d->flags &= ~ ( SND_F_WR_DMA | SND_F_WRITING ) ; + if (d->callback) + d->callback(d, SND_CB_WR | SND_CB_ABORT); + missing = isa_dmastop(d->dma1) ; /* this many missing bytes... */ + + b->rl += missing ; /* which are part of the ready area */ + b->rp -= missing ; + if (b->rp < 0) + b->rp += b->bufsize; + DEB(printf("dsp_wrabort: stopped after %d bytes out of %d\n", + b->dl - missing, b->dl)); + b->dl -= missing; + dsp_wr_dmadone(d); + missing = b->rl; + } + reset_dbuf(b); + splx(s); + return missing; +} + +int +dsp_rdabort(snddev_info *d) +{ + long s; + int missing = 0; + snd_dbuf *b = & (d->dbuf_in) ; + + s = spltty(); + if ( d->flags & SND_F_RD_DMA ) { + d->flags &= ~ ( SND_F_RD_DMA | SND_F_READING ) ; + if (d->callback) + d->callback(d, SND_CB_RD | SND_CB_ABORT); + missing = isa_dmastop(d->dma2) ; /* this many missing bytes... */ + + b->fl += missing ; /* which are part of the free area */ + b->fp -= missing ; + if (b->fp < 0) + b->fp += b->bufsize; + DEB(printf("dsp_rdabort: stopped after %d bytes out of %d\n", + b->dl - missing, b->dl)); + b->dl -= missing; + dsp_rd_dmadone(d); + missing = b->rl ; + } + reset_dbuf(b); + splx(s); + return missing; +} + +/* + * this routine tries to flush the dma transfer. It is called + * on a close. The caller must set SND_F_CLOSING, and insure that + * interrupts are enabled. We immediately abort any read DMA + * operation, and then wait for the play buffer to drain. + */ + +int +snd_flush(snddev_info *d) +{ + int ret, res, res1; + int count=10; + + DEB(printf("snd_flush d->flags 0x%08x\n", d->flags)); + dsp_rdabort(d); + if ( d->flags & SND_F_WR_DMA ) { + /* close write */ + while ( d->flags & SND_F_WR_DMA ) { + /* + * still pending output data. + */ + ret = tsleep( (caddr_t)&(d->dbuf_out), PRIBIO|PCATCH, "dmafl1", hz); + if (ret == ERESTART || ret == EINTR) { + printf("tsleep returns %d\n", ret); + return -1 ; + } + if ( ret && --count == 0) { + printf("timeout flushing dma1, cnt 0x%x flags 0x%08x\n", + isa_dmastatus1(d->dma1), d->flags); + return -1 ; + } + } + d->flags &= ~SND_F_CLOSING ; + } + reset_dbuf(& (d->dbuf_out) ); + return 0 ; +} + +/* + * end of new code for dma buffer handling + */ diff --git a/sys/i386/isa/snd/mss.h b/sys/i386/isa/snd/mss.h new file mode 100644 index 000000000000..4b34e51ab713 --- /dev/null +++ b/sys/i386/isa/snd/mss.h @@ -0,0 +1,250 @@ +/* + * file: mss.h + * + * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it) + * + * This file contains information and macro definitions for + * AD1848-compatible devices, used in the MSS/WSS compatible boards. + * + */ + +/* + * + +The codec part of the board is seen as a set of 4 registers mapped +at the base address for the board (default 0x534). Note that some +(early) boards implemented 4 additional registers 4 location before +(usually 0x530) to store configuration information. This is a source +of confusion in that one never knows what address to specify. The +(current) convention is to use the old address (0x530) in the kernel +configuration file and consider MSS registers start four location +ahead. + + * + */ + +/* + * The four visible registers of the MSS : + * + */ + +#define io_Index_Addr(d) ((d)->io_base + 4) +#define IA_BUSY 0x80 /* readonly, set when busy */ +#define IA_MCE 0x40 /* the MCE bit. */ + /* + * the MCE bit must be set whenever the current mode of the + * codec is changed; this in particular is true for the + * Data Format (I8, I28) and Interface Config(I9) registers. + * Only exception are CEN and PEN which can be changed on the fly. + * The DAC output is muted when MCE is set. + */ +#define IA_TRD 0x20 /* Transfer request disable */ + /* + * When TRD is set, DMA transfers cease when the INT bit in + * the MSS status reg is set. Must be cleared for automode + * DMA, set otherwise. + */ +#define IA_AMASK 0x1f /* mask for indirect address */ + +#define io_Indexed_Data(d) ((d)->io_base+1+4) + /* + * data to be transferred to the indirect register addressed + * by index addr. During init and sw. powerdown, cannot be + * written to, and is always read as 0x80 (consistent with the + * busy flag). + */ + +#define io_Status(d) ((d)->io_base+2+4) + +#define IS_CUL 0x80 /* capture upper/lower */ +#define IS_CLR 0x40 /* capture left/right */ +#define IS_CRDY 0x20 /* capture ready for programmed i/o */ +#define IS_SER 0x10 /* sample error (overrun/underrun) */ +#define IS_PUL 0x08 /* playback upper/lower */ +#define IS_PLR 0x04 /* playback left/right */ +#define IS_PRDY 0x02 /* playback ready for programmed i/o */ +#define IS_INT 0x01 /* int status (1 = active) */ + /* + * IS_INT is clreared by any write to the status register. + */ + +#define io_Polled_IO(d) ((d)->io_base+3+4) + /* + * this register is used in case of polled i/o + */ + +/* + * The MSS has a set of 16 (or 32 depending on the model) indirect + * registers accessible through the data port by specifying the + * appropriate address in the address register. + * + * The 16 low registers are uniformly handled in AD1848/CS4248 compatible + * mode (often called MODE1). For the upper 16 registers there are + * some differences among different products, mainly Crystal uses them + * differently from OPTi. + * + */ + +/* + * volume registers + */ + +#define I6_MUTE 0x80 + +/* + * register I9 -- interface configuration. + */ + +#define I9_PEN 0x01 /* playback enable */ +#define I9_CEN 0x02 /* capture enable */ + +/* + * values used in bd_flags + */ +#define BD_F_MCE_BIT 0x0001 +#define BD_F_IRQ_OK 0x0002 +#define BD_F_TMR_RUN 0x0004 + + +/* + * sound/ad1848_mixer.h + * + * Definitions for the mixer of AD1848 and compatible codecs. + * + * Copyright by Hannu Savolainen 1994 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * The AD1848 codec has generic input lines called Line, Aux1 and Aux2. + * Soundcard manufacturers have connected actual inputs (CD, synth, line, + * etc) to these inputs in different order. Therefore it's difficult + * to assign mixer channels to to these inputs correctly. The following + * contains two alternative mappings. The first one is for GUS MAX and + * the second is just a generic one (line1, line2 and line3). + * (Actually this is not a mapping but rather some kind of interleaving + * solution). + */ +#define GUSMAX_MIXER +#ifdef GUSMAX_MIXER +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM|SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_SPEAKER | SOUND_MASK_IGAIN | \ + SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#else /* Generic mapping */ + +#define MODE1_REC_DEVICES \ + (SOUND_MASK_LINE3 | SOUND_MASK_MIC | SOUND_MASK_LINE1|SOUND_MASK_IMIX) + +#define MODE1_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) + +#define MODE2_MIXER_DEVICES \ + (SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_LINE2 | \ + SOUND_MASK_LINE3 | SOUND_MASK_SPEAKER | \ + SOUND_MASK_IGAIN | SOUND_MASK_PCM | SOUND_MASK_IMIX) +#endif + +#define OPTI931_MIXER_DEVICES \ + (SOUND_MASK_VOLUME | SOUND_MASK_SYNTH | SOUND_MASK_PCM | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_IGAIN ) + +/* + * Most of the mixer entries work in backwards. Setting the polarity field + * makes them to work correctly. + * + * The channel numbering used by individual soundcards is not fixed. + * Some cards have assigned different meanings for the AUX1, AUX2 + * and LINE inputs. Some have different features... + * The current version doesn't try to compensate this. + * + */ + +mixer_ent mix_devices[32][2] = { /* As used in GUS MAX */ +MIX_ENT(SOUND_MIXER_VOLUME, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 6, 7, 1, 0, 6), +MIX_ENT(SOUND_MIXER_SPEAKER, 26, 1, 0, 4, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 0, 5, 19, 1, 0, 5), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_IMIX, 13, 1, 2, 6, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +mixer_ent opti931_devices[32][2] = { /* for the opti931 */ +MIX_ENT(SOUND_MIXER_VOLUME, 22, 1, 1, 5, 23, 1, 1, 5), +MIX_ENT(SOUND_MIXER_BASS, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_TREBLE, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_SYNTH, 4, 1, 1, 4, 5, 1, 1, 4), +MIX_ENT(SOUND_MIXER_PCM, 6, 1, 0, 5, 7, 1, 0, 5), +MIX_ENT(SOUND_MIXER_SPEAKER, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE, 18, 1, 1, 4, 19, 1, 1, 4), +MIX_ENT(SOUND_MIXER_MIC, 0, 0, 5, 1, 1, 0, 5, 1), +MIX_ENT(SOUND_MIXER_CD, 2, 1, 1, 4, 3, 1, 1, 4), +MIX_ENT(SOUND_MIXER_IMIX, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_ALTPCM, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_RECLEV, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_IGAIN, 0, 0, 0, 4, 1, 0, 0, 4), +MIX_ENT(SOUND_MIXER_OGAIN, 0, 0, 0, 0, 0, 0, 0, 0), +MIX_ENT(SOUND_MIXER_LINE1, 2, 1, 0, 5, 3, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE2, 4, 1, 0, 5, 5, 1, 0, 5), +MIX_ENT(SOUND_MIXER_LINE3, 18, 1, 0, 5, 19, 1, 0, 5) +}; + +static u_short default_mixer_levels[SOUND_MIXER_NRDEVICES] = { + 0x5a5a, /* Master Volume */ + 0x3232, /* Bass */ + 0x3232, /* Treble */ + 0x4b4b, /* FM */ + 0x4040, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x2020, /* Ext Line */ + 0x4040, /* Mic */ + 0x4b4b, /* CD */ + 0x0000, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x2525, /* Input gain */ + 0x0000, /* Output gain */ + /* 0x4040, Line1 */ + 0x0000, /* Line1 */ + 0x0000, /* Line2 */ + 0x1515 /* Line3 (usually line in)*/ +}; + diff --git a/sys/i386/isa/snd/sb_dsp.c b/sys/i386/isa/snd/sb_dsp.c new file mode 100644 index 000000000000..4ca1f1f507fa --- /dev/null +++ b/sys/i386/isa/snd/sb_dsp.c @@ -0,0 +1,1080 @@ +/* + * sound/sb_dsp.c + * + * driver for the SoundBlaster and clones. + * + * Copyright 1997 Luigi Rizzo. + * + * Derived from files in the Voxware 3.5 distribution, + * Copyright by Hannu Savolainen 1994, under the same copyright + * conditions. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* + * use this as a template file for board-specific drivers. + * The next two lines (and the final #endif) are in all drivers: + */ + +#include +#if NPCM > 0 + +/* + * Begin with the board-specific include files... + */ + +#define __SB_MIXER_C__ /* XXX warning... */ +#include + +/* + * then prototypes of functions which go in the snddev_info + * (usually static, unless they are shared by other modules)... + */ + +static int sb_probe(struct isa_device *dev); +static int sb_attach(struct isa_device *dev); + +static d_open_t sb_dsp_open; +static d_close_t sb_dsp_close; +static d_ioctl_t sb_dsp_ioctl; +static irq_proc_t sbintr; +static snd_callback_t sb_callback; + +/* + * and prototypes for other private functions defined in this module. + */ + +static void sb_dsp_init(snddev_info *d, struct isa_device *dev); +static void sb_mix_init(snddev_info *d); +static int sb_mixer_set(snddev_info *d, int dev, int value); +static int dsp_speed(snddev_info *d); +static void sb_mixer_reset(snddev_info *d); + +u_int sb_get_byte(int io_base); + +/* + * Then put here the descriptors for the various boards supported + * by this module, properly initialized. + */ + +snddev_info sb_op_desc = { + "basic soundblaster", + + SNDCARD_SB, + sb_probe, + sb_attach, + + sb_dsp_open, + sb_dsp_close /* sb_close */, + NULL /* use generic sndread */, + NULL /* use generic sndwrite */, + sb_dsp_ioctl, + sndselect, + + sbintr, + sb_callback, + + DSP_BUFFSIZE, /* bufsize */ + + AFMT_STEREO | AFMT_U8, /* audio format */ + +} ; + +/* + * Then the file continues with the body of all functions + * directly referenced in the descriptor. + */ + +/* + * the probe routine for the SoundBlaster only consists in + * resetting the dsp and testing if it is there. + * Version detection etc. will be done at attach time. + * + * Remebber, isa probe routines are supposed to return the + * size of io space used. + */ + +static int +sb_probe(struct isa_device *dev) +{ + if (dev->id_iobase == -1) { + dev->id_iobase = 0x220; + printf("sb_probe: no address supplied, try defaults (0x220,0x240)\n"); + if (snd_conflict(dev->id_iobase)) + dev->id_iobase = 0x240; + } + if (snd_conflict(dev->id_iobase)) + return 0 ; + + if (sb_reset_dsp(dev->id_iobase)) + return 16 ; /* the SB uses 16 registers... */ + else + return 0; +} + +static int +sb_attach(struct isa_device *dev) +{ + snddev_info *d = &pcm_info[dev->id_unit] ; + + sb_dsp_init(d, dev); + return 0 ; +} + +/* + * here are the main routines from the switches. + */ + +static int +sb_dsp_open(dev_t dev, int flags, int mode, struct proc * p) +{ + snddev_info *d; + int unit ; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + DEB(printf("<%s>%d : open\n", d->name, unit)); + + if (d->flags & SND_F_BUSY) { + printf("<%s>%d open: device busy\n", d->name, unit); + return EBUSY ; + } + + d->wsel.si_pid = 0; + d->wsel.si_flags = 0; + + d->rsel.si_pid = 0; + d->rsel.si_flags = 0; + + d->esel.si_pid = 0; + d->esel.si_flags = 0; + + d->flags = 0 ; + d->bd_flags &= ~BD_F_HISPEED ; + + switch ( dev & 0xf ) { + case SND_DEV_DSP16 : + if ((d->audio_fmt & AFMT_S16_LE) == 0) { + printf("sorry, 16-bit not supported on SB %d.%02d\n", + (d->bd_id >>8) & 0xff, d->bd_id & 0xff); + return ENXIO; + } + d->play_fmt = d->rec_fmt = AFMT_S16_LE ; + break; + case SND_DEV_AUDIO : + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + break ; + case SND_DEV_DSP : + d->play_fmt = d->rec_fmt = AFMT_U8 ; + break ; + } + + d->flags |= SND_F_BUSY ; + d->play_speed = d->rec_speed = DSP_DEFAULT_SPEED ; + + if (flags & O_NONBLOCK) + d->flags |= SND_F_NBIO ; + + reset_dbuf(& (d->dbuf_in) ); + reset_dbuf(& (d->dbuf_out) ); + sb_reset_dsp(d->io_base); + ask_init(d); + + return 0; +} + +static int +sb_dsp_close(dev_t dev, int flags, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + u_long s; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + s = spltty(); + d->flags |= SND_F_CLOSING ; + splx(s); + snd_flush(d); + + sb_cmd(d->io_base, DSP_CMD_SPKOFF ); /* XXX useless ? */ + + d->flags = 0 ; + return 0 ; +} + +static int +sb_dsp_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int unit; + snddev_info *d; + + dev = minor(dev); + unit = dev >> 4 ; + d = &pcm_info[unit] ; + + /* + * handle mixer calls first. Reads are in the default handler, + * so do not bother about them. + */ + if ( (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0) ) + return sb_mixer_set(d, cmd & 0xff, *(int *)arg) ; + + /* + * for the remaining functions, use the default handler. + */ + + return ENOSYS ; +} + +static void +sbintr(int unit) +{ + snddev_info *d = &pcm_info[unit]; + int reason = 3, c=1, io_base = d->io_base; + + DEB(printf("got sbintr for unit %d, flags 0x%08x\n", unit, d->flags)); + + /* + * SB < 4.0 is half duplex and has only 1 bit for int source, + * so we fake it. SB 4.x (SB16) has the int source in a separate + * register. + */ +again: + if (d->bd_flags & BD_F_SB16) { + c = sb_getmixer(io_base, IRQ_STAT); + /* this tells us if the source is 8-bit or 16-bit dma. We + * have to check the io channel to map it to read or write... + */ + reason = 0 ; + if ( c & 1 ) { /* 8-bit dma */ + if (d->dma1 < 4) + reason |= 1; + if (d->dma2 < 4) + reason |= 2; + } + if ( c & 2 ) { /* 16-bit dma */ + if (d->dma1 >= 4) + reason |= 1; + if (d->dma2 >= 4) + reason |= 2; + } + } + if ( c & 2 ) + inb(DSP_DATA_AVL16); /* 16-bit int ack */ + if (c & 1) + inb(DSP_DATA_AVAIL); /* 8-bit int ack */ + +DEB(printf("sbintr, flags 0x%08x reason %d\n", d->flags, reason)); + if ( (d->flags & SND_F_WR_DMA) && (reason & 1) ) + dsp_wrintr(d); + if ( (d->flags & SND_F_RD_DMA) && (reason & 2) ) + dsp_rdintr(d); + + /* + * the sb16 might have multiple sources etc. + */ + if (d->bd_flags & BD_F_SB16 && (c & 3) ) + goto again; +} + +/* + * device-specific function called back from the dma module. + * The reason of the callback is the second argument. + * NOTE: during operations, some ioctl can be done to change + * settings (e.g. speed, channels, format), and the default + * ioctl handler will just record the change and set the + * flag SND_F_INIT. The callback routine is in charge of applying + * the changes at the next convenient time (typically, at the + * start of operations). For full duplex devices, in some cases the + * init requires both channels to be idle. + */ +static int +sb_callback(snddev_info *d, int reason) +{ + u_long s ; + int rd = reason & SND_CB_RD ; + int l = (rd) ? d->dbuf_in.dl0 : d->dbuf_out.dl0 ; + + switch (reason & SND_CB_REASON_MASK) { + case SND_CB_INIT : /* called with int enabled and no pending io */ + dsp_speed(d); + snd_set_blocksize(d); + if (d->play_fmt & AFMT_MU_LAW) + d->flags |= SND_F_XLAT8 ; + else + d->flags &= ~SND_F_XLAT8 ; + return 1; + break ; + + case SND_CB_START : /* called with int disabled */ + sb_cmd(d->io_base, rd ? DSP_CMD_SPKOFF : DSP_CMD_SPKON); + d->flags &= ~SND_F_INIT ; + if (d->bd_flags & BD_F_SB16) { + /* the SB16 can do full duplex using one 16-bit channel + * and one 8-bit channel. It needs to be programmed to + * use split format though. + */ + int b16 ; + int swap = 0 ; + + b16 = (rd) ? d->rec_fmt : d->play_fmt ; + b16 = (b16 == AFMT_S16_LE) ? 1 : 0; + /* + * check if I have to swap dma channels. Swap if + * - !rd, dma1 <4, b16 + * - !rd, dma1 >=4, !b16 + * - rd, dma2 <4, b16 + * - rd, dma2 >=4, !b16 + */ + if (!rd) { + if ( (d->dma1 <4 && b16) || (d->dma1 >=4 && !b16) ) swap = 1; + } else { + if ( (d->dma2 <4 && b16) || (d->dma2 >=4 && !b16) ) swap = 1; + } + /* + * before swapping should make sure that there is no + * pending DMA on the other channel... + */ + if (swap) { + int c = d->dma2 ; + d->dma2 = d->dma1; + d->dma1 = c ; + } + DEB(printf("sb_init: play %d rec %d dma1 %d dma2 %d\n", + d->play_fmt, d->rec_fmt, d->dma1, d->dma2)); + } + /* fallthrough */ + case SND_CB_RESTART: + if (d->bd_flags & BD_F_SB16) { + u_char c, c1 ; + /* + * SB16 support still not completely working!!! + * + * in principle, on the SB16, I could support simultaneous + * play & rec. + * However, there is no way to ask explicitly for 8 or + * 16 bit transfer. As a consequence, if we do 8-bit, + * we need to use the 8-bit channel, and if we do 16-bit, + * we need to use the other one. The only way I find to + * do this is to swap d->dma1 and d->dma2 ... + * + */ + + if (rd) { + c = ((d->dma2 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_ADC ; + c1 = (d->play_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->rec_fmt == AFMT_S16_LE) + l /= 2 ; + } else { + c = ((d->dma1 > 3) ? DSP_DMA16 : DSP_DMA8) | + DSP_F16_FIFO_ON | DSP_F16_DAC ; + c1 = (d->rec_fmt == AFMT_U8) ? 0 : DSP_F16_SIGNED ; + if (d->play_fmt == AFMT_MU_LAW) c1 = 0 ; + if (d->play_fmt == AFMT_S16_LE) + l /= 2 ; + } + + if (d->flags & SND_F_STEREO) + c1 |= DSP_F16_STEREO ; + + sb_cmd(d->io_base, c ); + sb_cmd3(d->io_base, c1 , l - 1) ; + } else { + u_char c ; + if (d->bd_flags & BD_F_HISPEED) + c = (rd) ? DSP_CMD_HSADC : DSP_CMD_HSDAC ; + else + c = (rd) ? DSP_CMD_ADC8 : DSP_CMD_DAC8 ; + sb_cmd3(d->io_base, c , l - 1) ; + } + break; + + case SND_CB_STOP : + /* sb_cmd(d->io_base, DSP_CMD_SPKOFF); /* speaker off */ + break ; + + } + return 0 ; +} + +/* + * The second part of the file contains all functions specific to + * the board and (usually) not exported to other modules. + */ + +int +sb_reset_dsp(int io_base) +{ + int loopc; + + outb(DSP_RESET, 1); + DELAY(100); + outb(DSP_RESET, 0); + for (loopc = 0; loopc<100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++) + DELAY(30); + + if (inb(DSP_READ) != 0xAA) { + DEB(printf("sb_reset_dsp failed\n")); + return 0; /* Sorry */ + } + return 1; +} + +/* + * only used in sb_attach from here. + */ + +static void +sb_dsp_init(snddev_info *d, struct isa_device *dev) +{ + int i, x; + char *fmt = NULL ; + int io_base = dev->id_iobase ; + + d->bd_id = 0 ; + + sb_reset_dsp(io_base); + sb_cmd(io_base, DSP_CMD_GETVER); /* Get version */ + + for (i = 10000; i; i--) { /* perhaps wait longer on a fast machine ? */ + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if ( (d->bd_id & 0xff00) == 0) + d->bd_id = inb(DSP_READ) << 8; /* major */ + else { + d->bd_id |= inb(DSP_READ); /* minor */ + break; + } + } else + DELAY(20); + } + + /* + * now do various initializations depending on board id. + */ + + fmt = "SoundBlaster %d.%d" ; /* default */ + + switch ( d->bd_id >> 8 ) { + case 0 : + printf("\n\nFailed to get SB version (%x) - possible I/O conflict\n\n", + inb(DSP_DATA_AVAIL)); + d->bd_id = 0x100; + case 1 : /* old sound blaster has nothing... */ + break ; + + case 2 : + d->dma2 = d->dma1 ; /* half duplex */ + d->bd_flags |= BD_F_DUP_MIDI ; + + if (d->bd_id == 0x200) + break ; /* no mixer on the 2.0 */ + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1335 ; + + break ; + case 4 : + fmt = "SoundBlaster 16 %d.%d"; + d->audio_fmt |= AFMT_FULLDUPLEX | AFMT_WEIRD | AFMT_S8 | AFMT_S16_LE; + d->bd_flags |= BD_F_SB16; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1745 ; + + /* soft irq/dma configuration */ + x = -1 ; + if (d->irq == 5) x = 2; + else if (d->irq == 7) x = 4; + else if (d->irq == 9) x = 1; + else if (d->irq == 10) x = 8; + if (x == -1) + printf("<%s>%d: bad irq %d (only 5,7,9,10 allowed)\n", + d->name, dev->id_unit, d->irq); + else + sb_setmixer(io_base, IRQ_NR, x); + + sb_setmixer(io_base, DMA_NR, (1 << d->dma1) | (1 << d->dma2)); + break ; + + case 3 : + d->dma2 = d->dma1 ; /* half duplex */ + fmt = "SoundBlaster Pro %d.%d"; + d->bd_flags |= BD_F_DUP_MIDI ; + d->bd_flags &= ~BD_F_MIX_MASK ; + d->bd_flags |= BD_F_MIX_CT1345 ; + if (d->bd_id == 0x301) { + int ess_major = 0, ess_minor = 0; + + /* + * Try to detect ESS chips. + */ + + sb_cmd(io_base, DSP_CMD_GETID); /* Return ident. bytes. */ + + for (i = 1000; i; i--) { + if (inb(DSP_DATA_AVAIL) & 0x80) { /* wait for Data Ready */ + if (ess_major == 0) + ess_major = inb(DSP_READ); + else { + ess_minor = inb(DSP_READ); + break; + } + } + } + + if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS488 based card (rev %d)\n", + ess_minor & 0x0f); + else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) + printf("Hmm... Could this be an ESS688 based card (rev %d)\n", + ess_minor & 0x0f); + } + + if (d->bd_flags & BD_F_JAZZ16) { + if (d->bd_flags & BD_F_JAZZ16_2) + fmt = "SoundMan Wave %d.%d"; + else + fmt = "MV Jazz16 %d.%d"; + d->audio_fmt |= AFMT_S16_LE; /* 16 bits */ + } + } + + sprintf(d->name, fmt, (d->bd_id >> 8) &0xff, d->bd_id & 0xff); + + sb_mix_init(d); +} + +static void +sb_mix_init(snddev_info *d) +{ + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : /* SB 3.0 has 1345 mixer */ + + d->mix_devs = SBPRO_MIXER_DEVICES ; + d->mix_rec_devs = SBPRO_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + + sb_setmixer(d->io_base, 0, 1 ); /* reset mixer */ + sb_setmixer(d->io_base, MIC_VOL , 0x6 ); /* mic volume max */ + sb_setmixer(d->io_base, RECORD_SRC , 0x0 ); /* mic source */ + sb_setmixer(d->io_base, FM_VOL , 0x0 ); /* no midi */ + break ; + + case BD_F_MIX_CT1745 : /* SB16 mixer ... */ + + d->mix_devs = SB16_MIXER_DEVICES ; + d->mix_rec_devs = SB16_RECORDING_DEVICES ; + d->mix_recsrc = SOUND_MASK_MIC ; + } + sb_mixer_reset(d); +} + +/* + * Common code for the midi and pcm functions + */ + +int +sb_cmd(int io_base, u_char val) +{ + int i; + + for (i = 0; i < 1000 ; i++) { + if ((inb(DSP_STATUS) & 0x80) == 0) { + outb(DSP_COMMAND, val); + return 1; + } + if (i > 10) + DELAY (i > 100 ? 1000 : 10 ); + } + + printf("SoundBlaster: DSP Command(0x%02x) timeout. IRQ conflict ?\n", val); + return 0; +} + +int +sb_cmd3(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + sb_cmd(io_base, (val>>8) & 0xff ); + return 1 ; + } else + return 0; +} + +int +sb_cmd2(int io_base, u_char cmd, int val) +{ + if (sb_cmd(io_base, cmd)) { + sb_cmd(io_base, val & 0xff ); + return 1 ; + } else + return 0; +} + +void +sb_setmixer(int io_base, u_int port, u_int value) +{ + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + outb(MIXER_DATA, (u_char) (value & 0xff)); + DELAY(10); + splx(flags); +} + +u_int +sb_get_byte(int io_base) +{ + int i; + + for (i = 1000; i; i--) + if (inb(DSP_DATA_AVAIL) & 0x80) + return inb(DSP_READ); + else + DELAY(20); + return 0xffff; +} + +int +sb_getmixer(int io_base, u_int port) +{ + int val; + u_long flags; + + flags = spltty(); + outb(MIXER_ADDR, (u_char) (port & 0xff)); /* Select register */ + DELAY(10); + val = inb(MIXER_DATA); + DELAY(10); + splx(flags); + + return val; +} + + +/* + * various utility functions for the DSP + */ + +/* + * dsp_speed updates the speed setting from the descriptor. make sure + * it is called at spltty(). + * Besides, it takes care of stereo setting. + */ +static int +dsp_speed(snddev_info *d) +{ + u_char tconst; + u_long flags; + int max_speed = 44100, speed = d->play_speed ; + + if (d->bd_flags & BD_F_SB16) { + RANGE (speed, 5000, 45000); + d->play_speed = d->rec_speed = speed ; + sb_cmd(d->io_base, 0x41); + sb_cmd(d->io_base, d->play_speed >> 8 ); + sb_cmd(d->io_base, d->play_speed & 0xff ); + sb_cmd(d->io_base, 0x42); + sb_cmd(d->io_base, d->rec_speed >> 8 ); + sb_cmd(d->io_base, d->rec_speed & 0xff ); + return speed ; + } + /* + * only some models can do stereo, and only if not + * simultaneously using midi. + */ + if ( (d->bd_id & 0xff00) < 0x300 || d->bd_flags & BD_F_MIDIBUSY) + d->flags &= ~SND_F_STEREO; + + /* + * here enforce speed limitations. + */ + if (d->bd_id <= 0x200) + max_speed = 22050; /* max 22050 on SB 1.X */ + + /* + * SB models earlier than SB Pro have low limit for the + * input rate. Note that this is only for input, but since + * we do not support separate values for rec & play.... + */ + if (d->bd_id <= 0x200) + max_speed = 13000; + else if (d->bd_id < 0x300) + max_speed = 15000; + + RANGE(speed, 4000, max_speed); + + /* + * Logitech SoundMan Games and Jazz16 cards can support 44.1kHz + * stereo + */ +#if !defined (SM_GAMES) + /* + * Max. stereo speed is 22050 + */ + if (d->flags & SND_F_STEREO && speed > 22050 && !(d->bd_flags & BD_F_JAZZ16)) + speed = 22050; +#endif + + if ((speed > 22050) && d->bd_flags & BD_F_MIDIBUSY) + speed = 22050; + + if (d->flags & SND_F_STEREO) + speed *= 2; + + /* + * Now the speed should be valid. Compute the value to be + * programmed into the board. + */ + + if (speed > 22050) { /* High speed mode on 2.01/3.xx */ + int tmp; + + tconst = (u_char) ((65536 - ((256000000 + speed / 2) / speed)) >> 8); + d->bd_flags |= BD_F_HISPEED ; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 65536 - (tconst << 8); + speed = (256000000 + tmp / 2) / tmp; + } else { + int tmp; + + d->bd_flags &= ~BD_F_HISPEED ; + tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; + + flags = spltty(); + sb_cmd2(d->io_base, DSP_CMD_TCONST, tconst); + splx(flags); + + tmp = 256 - tconst; + speed = (1000000 + tmp / 2) / tmp; + } + + if (d->flags & SND_F_STEREO) + speed /= 2; + + d->play_speed = d->rec_speed = speed; + return speed; +} + +/* + * mixer support, originally in sb_mixer.c + */ + +static void +sb_set_recsrc(snddev_info *d, int mask) +{ + u_char outmask; + u_char recdev ; + + mask &= d->mix_rec_devs; + switch (d->bd_flags & BD_F_MIX_MASK) { + case BD_F_MIX_CT1345 : + if (mask == SOUND_MASK_LINE) + recdev = 6 ; + else if (mask == SOUND_MASK_CD) + recdev = 2 ; + else { /* default: mic */ + mask = SOUND_MASK_MIC ; + recdev = 0 ; + } + sb_setmixer(d->io_base, RECORD_SRC, + recdev | (sb_getmixer(d->io_base, RECORD_SRC) & ~7 )); + break ; + case BD_F_MIX_CT1745 : /* sb16 */ + if (mask == 0) + mask = SOUND_MASK_MIC ; /* XXX For compatibility. Bug ? */ + recdev = 0 ; + if (mask & SOUND_MASK_MIC) + recdev |= 1 ; + if (mask & SOUND_MASK_CD) + recdev |= 6 ; /* l+r cd */ + if (mask & SOUND_MASK_LINE) + recdev |= 0x18 ; /* l+r line */ + if (mask & SOUND_MASK_SYNTH) + recdev |= 0x60 ; /* l+r midi */ + sb_setmixer(d->io_base, SB16_IMASK_L, recdev); + sb_setmixer(d->io_base, SB16_IMASK_R, recdev); + /* + * since the same volume controls apply to the input and + * output sections, the best approach to have a consistent + * behaviour among cards would be to disable the output path + * on devices which are used to record. + * However, since users like to have feedback, we only disable + * the mike -- permanently. + */ + sb_setmixer(d->io_base, SB16_OMASK, 0x1f & ~1); + break ; + } + d->mix_recsrc = mask; +} + +static void +sb_mixer_reset(snddev_info *d) +{ + int i; + + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + sb_mixer_set(d, i, levels[i]); + if (d->bd_flags & BD_F_SB16) { + sb_setmixer(d->io_base, 0x3c, 0x1f); /* make all output active */ + sb_setmixer(d->io_base, 0x3d, 0); /* make all inputs-l off */ + sb_setmixer(d->io_base, 0x3e, 0); /* make all inputs-r off */ + } + sb_set_recsrc(d, SOUND_MASK_MIC); +} + +static int +sb_mixer_set(snddev_info *d, int dev, int value) +{ + int left = value & 0x000000ff; + int right = (value & 0x0000ff00) >> 8; + int regoffs; + u_char val; + mixer_tab *iomap; + +#ifdef JAZZ16 + if (d->bd_flags & BD_F_JAZZ16 && d->bd_flags & BD_F_JAZZ16_2) + return smw_mixer_set(dev, value); +#endif + + if (dev == SOUND_MIXER_RECSRC) { + sb_set_recsrc(d, value); + return 0 ; + } + if (left > 100) + left = 100; + if (right > 100) + right = 100; + + if (dev > 31) + return EINVAL ; + + if (!(d->mix_devs & (1 << dev))) /* Not supported */ + return EINVAL; + + switch ( d->bd_flags & BD_F_MIX_MASK ) { + default: + /* mixer unknown, fail... */ + return EINVAL ;/* XXX change this */ + case BD_F_MIX_CT1345 : + iomap = &sbpro_mix ; + break; + case BD_F_MIX_CT1745 : + iomap = &sb16_mix ; + break; + /* XXX how about the SG NX Pro, iomap = sgnxpro_mix */ + } + regoffs = (*iomap)[dev][LEFT_CHN].regno; + if (regoffs == 0) + return EINVAL; + + val = sb_getmixer(d->io_base, regoffs); + + change_bits(iomap, &val, dev, LEFT_CHN, left); + + d->mix_levels[dev] = left | (left << 8); + + if ((*iomap)[dev][RIGHT_CHN].regno != regoffs) { /* Change register */ + sb_setmixer(d->io_base, regoffs, val); /* Save the old one */ + regoffs = (*iomap)[dev][RIGHT_CHN].regno; + + if (regoffs == 0) + return 0 ; /* Just left channel present */ + + val = sb_getmixer(d->io_base, regoffs); /* Read the new one */ + } + change_bits(iomap, &val, dev, RIGHT_CHN, right); + + sb_setmixer(d->io_base, regoffs, val); + + d->mix_levels[dev] = left | (right << 8); + return 0 ; /* ok */ +} + +/* + * now support for some PnP boards. + */ + +#if NPNP > 0 +static char *opti925_probe(u_long csn, u_long vend_id); +static void opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device opti925 = { + "opti925", + opti925_probe, + opti925_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, opti925); + +static char * +opti925_probe(u_long csn, u_long vend_id) +{ + if (vend_id == 0x2509143e) { + struct pnp_cinfo d ; + read_pnp_parms ( &d , 1 ) ; + if (d.enable == 0) { + printf("This is an OPTi925, but LDN 1 is disabled\n"); + return NULL; + } + return "OPTi925" ; + } + return NULL ; +} + +static void +opti925_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + int the_irq = 0 ; + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 3 ); /* disable LDN 3 */ + the_irq = d.irq[0]; + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 3 ); + + read_pnp_parms ( &d , 2 ); /* disable LDN 2 */ + d.port[0] = 0 ; + d.enable = 0 ; + write_pnp_parms ( &d , 2 ); + + read_pnp_parms ( &d , 1 ) ; + d.irq[0] = the_irq ; + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 1 ); + enable_pnp_card(); + + tmp_d.conf_base = d.port[3]; + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); + +} + +/* + * A driver for some SB16pnp and compatibles... + * + * Avance Asound 100 -- 0x01009305 + * xxx -- 0x2b008c0e + * + */ + +static char *sb16pnp_probe(u_long csn, u_long vend_id); +static void sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev); + +static struct pnp_device sb16pnp = { + "SB16pnp", + sb16pnp_probe, + sb16pnp_attach, + &nsnd, /* use this for all sound cards */ + &tty_imask /* imask */ +}; +DATA_SET (pnpdevice_set, sb16pnp); + +static char * +sb16pnp_probe(u_long csn, u_long vend_id) +{ + char *s = NULL ; + if (vend_id == 0x01009305) + s = "Avance Asound 100" ; + if (vend_id == 0x2b008c0e) + s = "SB16 Value PnP" ; + /* + * The SB16/AWE64 cards seem to differ in the fourth byte of + * the vendor id, so I have just masked it for the time being... + * Reported values are: + * SB16 Value PnP: 0x2b008c0e + * SB AWE64 PnP: 0x39008c0e 0x9d008c0e 0xc3008c0e + */ + if ( (vend_id & 0xffffff) == (0x9d008c0e & 0xffffff) ) + s = "SB AWE64 PnP"; + if (s) { + struct pnp_cinfo d; + read_pnp_parms(&d, 0); + if (d.enable == 0) { + printf("This is a %s, but LDN 0 is disabled\n", s); + return NULL ; + } + return s ; + } + return NULL ; +} + +static void +sb16pnp_attach(u_long csn, u_long vend_id, char *name, + struct isa_device *dev) +{ + struct pnp_cinfo d ; + snddev_info tmp_d ; /* patched copy of the basic snddev_info */ + + tmp_d = sb_op_desc; + snddev_last_probed = &tmp_d; + + read_pnp_parms ( &d , 0 ) ; + d.port[1] = 0 ; /* only the first address is used */ + dev->id_iobase = d.port[0]; + write_pnp_parms ( &d , 0 ); + enable_pnp_card(); + + dev->id_drq = d.drq[0] ; /* primary dma */ + dev->id_irq = (1 << d.irq[0] ) ; + dev->id_intr = pcmintr ; + dev->id_flags = DV_F_DUAL_DMA | (d.drq[1] ) ; + + pcm_info[dev->id_unit] = tmp_d; + snddev_last_probed->probe(dev); /* not really necessary but doesn't harm */ + + pcmattach(dev); +} +#endif /* NPNP */ + +#endif diff --git a/sys/i386/isa/snd/sbcard.h b/sys/i386/isa/snd/sbcard.h new file mode 100644 index 000000000000..8548997353d2 --- /dev/null +++ b/sys/i386/isa/snd/sbcard.h @@ -0,0 +1,387 @@ +/* + * file: sbcard.h + */ + +typedef struct _sbdev_info { + +} sbdev_info ; + +extern int sbc_major, sbc_minor ; +/* + * sound blaster registers + */ + +#define DSP_RESET (io_base + 0x6) +#define DSP_READ (io_base + 0xA) +#define DSP_WRITE (io_base + 0xC) +#define DSP_COMMAND (io_base + 0xC) +#define DSP_STATUS (io_base + 0xC) +#define DSP_DATA_AVAIL (io_base + 0xE) +#define DSP_DATA_AVL16 (io_base + 0xF) +#define MIXER_ADDR (io_base + 0x4) +#define MIXER_DATA (io_base + 0x5) +#define OPL3_LEFT (io_base + 0x0) +#define OPL3_RIGHT (io_base + 0x2) +#define OPL3_BOTH (io_base + 0x8) + +/* + * DSP Commands. There are many, and in many cases they are used explicitly + */ + +#define DSP_DAC8 0x10 /* direct DAC output */ +#define DSP_CMD_DAC8 0x14 /* single cycle 8-bit dma out */ +#define DSP_CMD_DAC2 0x16 /* 2-bit adpcm dma out (cont) */ +#define DSP_CMD_DAC2S 0x17 /* 2-bit adpcm dma out (start) */ + +#define DSP_CMD_DAC8_A 0x1c /* auto 8-bit dma out */ +#define DSP_CMD_DAC2S_A 0x1f /* auto 2-bit adpcm dma out (start) */ + +#define DSP_ADC8 0x20 /* direct ADC input */ + +#define DSP_CMD_ADC8 0x24 /* single cycle 8-bit dma in */ +#define DSP_CMD_ADC8_A 0x2c /* auto 8-bit dma out */ + +#define DSP_CMD_O16 0xb0 +#define DSP_CMD_I16 0xb8 +#define DSP_CMD_O8 0xc0 +#define DSP_CMD_I8 0xc8 + +#define DSP_MODE_U8MONO 0x00 +#define DSP_MODE_U8STEREO 0x20 +#define DSP_MODE_S16MONO 0x10 +#define DSP_MODE_S16STEREO 0x30 + +#define DSP_CMD_SPKON 0xD1 +#define DSP_CMD_SPKOFF 0xD3 +#define DSP_CMD_SPKR(on) (0xD1 | (on ? 0:2)) +#define DSP_CMD_DMAON 0xD0 /* ??? the comment says Halt DMA */ +#define DSP_CMD_DMAOFF 0xD4 /* ??? comment says continue dma */ + +#define DSP_CMD_DMAHALT 0xD0 +#define DSP_CMD_TCONST 0x40 /* set time constant */ +#define DSP_CMD_HSSIZE 0x48 /* high speed dma count */ +#define DSP_CMD_HSDAC 0x91 /* high speed dac */ +#define DSP_CMD_HSADC 0x99 /* high speed adc */ + +#define DSP_CMD_GETVER 0xE1 +#define DSP_CMD_GETID 0xE7 /* return id bytes */ + + /* prepare for dma input */ +#define DSP_CMD_DMAMODE(stereo, bit16) (0xA0 | (stereo ? 8:0) | (bit16 ? 4:0)) + +#define DSP_CMD_OUT16 0x41 /* send parms for dma out on sb16 */ +#define DSP_CMD_IN16 0x42 /* send parms for dma in on sb16 */ +#if 0 /*** unknown ***/ + /* + * D9 and D5 are used on the sb16 on close... maybe a reset of + * some subsystem ? + */ +#define DSP_CMD_D9 0xD9 +#define DSP_CMD_D5 0xD5 +#define DSP_CMD_FA 0xFA /* get version from prosonic*/ +#define DSP_CMD_FB 0xFB /* set irq/dma for prosonic*/ +#endif + +/* + * in fact, for the SB16, dma commands are as follows: + * + * cmd, mode, len_low, len_high. + * + * cmd is a combination of DSP_DMA16 or DSP_DMA8 and + */ + +#define DSP_DMA16 0xb0 +#define DSP_DMA8 0xc0 +# define DSP_F16_DAC 0x00 +# define DSP_F16_ADC 0x08 +# define DSP_F16_AUTO 0x04 +# define DSP_F16_FIFO_ON 0x02 + +/* + * mode is a combination of the following: + */ +#define DSP_F16_STEREO 0x20 +#define DSP_F16_SIGNED 0x10 + +#define IMODE_NONE 0 +#define IMODE_OUTPUT PCM_ENABLE_OUTPUT +#define IMODE_INPUT PCM_ENABLE_INPUT +#define IMODE_INIT 3 +#define IMODE_MIDI 4 + +#define NORMAL_MIDI 0 +#define UART_MIDI 1 + +/* + * values used for bd_flags in SoundBlaster driver + */ +#define BD_F_HISPEED 0x0001 /* doing high speed ... */ + +#define BD_F_JAZZ16 0x0002 /* jazz16 detected */ +#define BD_F_JAZZ16_2 0x0004 /* jazz16 type 2 */ + +#define BD_F_DUP_MIDI 0x0008 /* duplex midi */ + +#define BD_F_MIX_MASK 0x0070 /* up to 8 mixers (I know of 3) */ +#define BD_F_MIX_CT1335 0x0010 /* CT1335 */ +#define BD_F_MIX_CT1345 0x0020 /* CT1345 */ +#define BD_F_MIX_CT1745 0x0030 /* CT1745 */ + +#define BD_F_SB16 0x0100 /* this is a SB16 */ +#define BD_F_NOREC 0x0200 /* recording not supported on this board */ +#define BD_F_MIDIBUSY 0x0400 /* midi busy */ + + +/* + * sound/sb_mixer.h + * + * Definitions for the SB Pro and SB16 mixers + * + * Copyright by Hannu Savolainen 1993 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Modified: Hunyue Yau Jan 6 1994 Added defines for the Sound Galaxy NX Pro + * mixer. + * + */ + +#define SBPRO_RECORDING_DEVICES \ + (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +/* Same as SB Pro, unless I find otherwise */ +#define SGNXPRO_RECORDING_DEVICES SBPRO_RECORDING_DEVICES + +#define SBPRO_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_MIC | \ + SOUND_MASK_CD | SOUND_MASK_VOLUME) + +/* + * SG NX Pro has treble and bass settings on the mixer. The 'speaker' channel + * is the COVOX/DisneySoundSource emulation volume control on the mixer. It + * does NOT control speaker volume. Should have own mask eventually? + */ +#define SGNXPRO_MIXER_DEVICES \ + (SBPRO_MIXER_DEVICES | SOUND_MASK_BASS | \ + SOUND_MASK_TREBLE | SOUND_MASK_SPEAKER ) + +#define SB16_RECORDING_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD) + +#define SB16_MIXER_DEVICES \ + (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | \ + SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | \ + SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | \ + SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE) + +/* + * Mixer registers + * + * NOTE! RECORD_SRC == IN_FILTER + */ + +/* + * Mixer registers of SB Pro + */ +#define VOC_VOL 0x04 +#define MIC_VOL 0x0A +#define MIC_MIX 0x0A +#define RECORD_SRC 0x0C +#define IN_FILTER 0x0C +#define OUT_FILTER 0x0E +#define MASTER_VOL 0x22 +#define FM_VOL 0x26 +#define CD_VOL 0x28 +#define LINE_VOL 0x2E +#define IRQ_NR 0x80 +#define DMA_NR 0x81 +#define IRQ_STAT 0x82 + +/* + * Additional registers on the SG NX Pro + */ +#define COVOX_VOL 0x42 +#define TREBLE_LVL 0x44 +#define BASS_LVL 0x46 + +#define FREQ_HI (1 << 3)/* Use High-frequency ANFI filters */ +#define FREQ_LOW 0 /* Use Low-frequency ANFI filters */ +#define FILT_ON 0 /* Yes, 0 to turn it on, 1 for off */ +#define FILT_OFF (1 << 5) + +#define MONO_DAC 0x00 +#define STEREO_DAC 0x02 + +/* + * Mixer registers of SB16 + */ +#define SB16_IMASK_L 0x3d +#define SB16_IMASK_R 0x3e +#define SB16_OMASK 0x3c + + +#ifndef __SB_MIXER_C__ +mixer_tab sbpro_mix; +mixer_tab sb16_mix; +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix; +#endif +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES]; +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES]; +#else /* __SB_MIXER_C__ defined */ +mixer_tab sbpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0) +}; + +#ifdef __SGNXPRO__ +mixer_tab sgnxpro_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4), + PMIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x42, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4), + PMIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0) +}; +#endif + +mixer_tab sb16_mix = { + PMIX_ENT(SOUND_MIXER_VOLUME, 0x30, 3, 5, 0x31, 3, 5), + PMIX_ENT(SOUND_MIXER_BASS, 0x46, 4, 4, 0x47, 4, 4), + PMIX_ENT(SOUND_MIXER_TREBLE, 0x44, 4, 4, 0x45, 4, 4), + PMIX_ENT(SOUND_MIXER_SYNTH, 0x34, 3, 5, 0x35, 3, 5), + PMIX_ENT(SOUND_MIXER_PCM, 0x32, 3, 5, 0x33, 3, 5), + PMIX_ENT(SOUND_MIXER_SPEAKER, 0x3b, 6, 2, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_LINE, 0x38, 3, 5, 0x39, 3, 5), + PMIX_ENT(SOUND_MIXER_MIC, 0x3a, 3, 5, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_CD, 0x36, 3, 5, 0x37, 3, 5), + PMIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0), + PMIX_ENT(SOUND_MIXER_RECLEV, 0x3f, 6, 2, 0x40, 6, 2), /* Obsol,Use IGAIN*/ + PMIX_ENT(SOUND_MIXER_IGAIN, 0x3f, 6, 2, 0x40, 6, 2), + PMIX_ENT(SOUND_MIXER_OGAIN, 0x41, 6, 2, 0x42, 6, 2) +}; + +#ifdef SM_GAMES /* Master volume is lower and PCM & FM + * volumes higher than with SB Pro. This + * improves the sound quality */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x2020, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x6464, /* FM */ + 0x6464, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x0000, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ + +#else /* If the user selected just plain SB Pro */ + +static u_short levels[SOUND_MIXER_NRDEVICES] = +{ + 0x5a5a, /* Master Volume */ + 0x4b4b, /* Bass */ + 0x4b4b, /* Treble */ + 0x4b4b, /* FM */ + 0x4b4b, /* PCM */ + 0x4b4b, /* PC Speaker */ + 0x4b4b, /* Ext Line */ + 0x1010, /* Mic */ + 0x4b4b, /* CD */ + 0x4b4b, /* Recording monitor */ + 0x4b4b, /* SB PCM */ + 0x4b4b, /* Recording level */ + 0x4b4b, /* Input gain */ +0x4b4b}; /* Output gain */ +#endif /* SM_GAMES */ + +static u_char sb16_recmasks_L[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x40, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x10, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x04, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +static u_char sb16_recmasks_R[SOUND_MIXER_NRDEVICES] = +{ + 0x00, /* SOUND_MIXER_VOLUME */ + 0x00, /* SOUND_MIXER_BASS */ + 0x00, /* SOUND_MIXER_TREBLE */ + 0x20, /* SOUND_MIXER_SYNTH */ + 0x00, /* SOUND_MIXER_PCM */ + 0x00, /* SOUND_MIXER_SPEAKER */ + 0x08, /* SOUND_MIXER_LINE */ + 0x01, /* SOUND_MIXER_MIC */ + 0x02, /* SOUND_MIXER_CD */ + 0x00, /* SOUND_MIXER_IMIX */ + 0x00, /* SOUND_MIXER_ALTPCM */ + 0x00, /* SOUND_MIXER_RECLEV */ + 0x00, /* SOUND_MIXER_IGAIN */ + 0x00 /* SOUND_MIXER_OGAIN */ +}; + +/* + * Recording sources (SB Pro) + */ +#endif /* __SB_MIXER_C__ */ + +#define SRC_MIC 1 /* Select Microphone recording source */ +#define SRC_CD 3 /* Select CD recording source */ +#define SRC_LINE 7 /* Use Line-in for recording source */ + + diff --git a/sys/i386/isa/snd/sound.c b/sys/i386/isa/snd/sound.c new file mode 100644 index 000000000000..a9b5fd556669 --- /dev/null +++ b/sys/i386/isa/snd/sound.c @@ -0,0 +1,1254 @@ +/* + * sound/sound.c + * + * Main sound driver for FreeBSD. This file provides the main + * entry points for probe/attach and all i/o demultiplexing, including + * default routines for generic devices. + * + * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it) + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS + * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + * For each board type a template "snddev_info" structure contains + * all the relevant parameters, both for configuration and runtime. + * + * In this file we build tables of pointers to the descriptors for + * the various supported boards. The generic probe routine scans + * the table(s) looking for a matching entry, then invokes the + * board-specific probe routine. If successful, a pointer to the + * correct snddev_info is stored in snddev_last_probed, for subsequent + * use in the attach routine. The generic attach routine copies + * the template to a permanent descriptor (pcm_info[unit] and + * friends), initializes all generic parameters, and calls the + * board-specific attach routine. + * + * On device calls, the generic routines do the checks on unit and + * device parameters, then call the board-specific routines if + * available, or try to perform the task using the default code. + * + */ + +#include + +#if NPCM > 0 /* from "snd.h" */ + +#define SNDSTAT_BUF_SIZE 4000 +static char status_buf[SNDSTAT_BUF_SIZE] ; +static int status_len = 0 ; +static void init_status(snddev_info *d); + +static d_open_t sndopen; +static d_close_t sndclose; +static d_ioctl_t sndioctl; +static d_read_t sndread; +static d_write_t sndwrite; +static d_mmap_t sndmmap; + +#define CDEV_MAJOR 30 +static struct cdevsw snd_cdevsw = { + sndopen, sndclose, sndread, sndwrite, + sndioctl, nxstop, nxreset, nxdevtotty, + sndselect, sndmmap, nxstrategy, "snd", + NULL, -1, +}; + +/* + * descriptors for active devices. + * + */ +snddev_info pcm_info[NPCM_MAX] ; +snddev_info midi_info[NPCM_MAX] ; +snddev_info synth_info[NPCM_MAX] ; + +u_long nsnd = NPCM ; /* total number of sound devices */ + +/* + * the probe routine can only return an int to the upper layer. Hence, + * it leaves the pointer to the last successfully + * probed device descriptor in snddev_last_probed + */ +snddev_info *snddev_last_probed = NULL ; + +static void print_isadev_info(struct isa_device *d, char *s); +static snddev_info * +generic_snd_probe(struct isa_device * dev, snddev_info **p[], char *s); + +/* + * here are the lists of known devices. Similar devices (e.g. all + * sb clones, all mss clones, ... are in the same array. + * All lists of devices of the same type (eg. all pcm, all midi...) + * are in the same array. + * Each probe for a device type gets the pointer to the main array + * and then scans the sublists. + * + * XXX should use DATA_SET to create a linker set for sb_devs and other + * such structures. + */ + +extern snddev_info sb_op_desc; +extern snddev_info mss_op_desc; + +static snddev_info *sb_devs[] = { + &sb_op_desc, + NULL, +} ; + +static snddev_info *mss_devs[] = { + /* MSS-like devices */ + &mss_op_desc, + NULL, +} ; + +static snddev_info **pcm_devslist[] = { + /* all pcm devices */ + mss_devs, + sb_devs, + NULL +} ; + + +int +pcmprobe(struct isa_device * dev) +{ + bzero(&pcm_info[dev->id_unit], sizeof(pcm_info[dev->id_unit]) ); + return generic_snd_probe(dev, pcm_devslist, "pcm") ? 1 : 0 ; +} + +static snddev_info **midi_devslist[] = { + /* all midi devices */ + NULL +} ; + +int +midiprobe(struct isa_device * dev) +{ + bzero(&midi_info[dev->id_unit], sizeof(midi_info[dev->id_unit]) ); + return 0 ; + return generic_snd_probe(dev, midi_devslist, "midi") ? 1 : 0 ; +} + +int +synthprobe(struct isa_device * dev) +{ + bzero(&synth_info[dev->id_unit], sizeof(synth_info[dev->id_unit]) ); + return 0 ; +} + +/* + * this is the generic attach routine + */ + +int +pcmattach(struct isa_device * dev) +{ + snddev_info *d = NULL ; + struct isa_device *dvp; + int stat = 0; + dev_t isadev; + + if ( (dev->id_unit >= NPCM_MAX) || /* too many devs */ + (snddev_last_probed == NULL) || /* last probe failed */ + (snddev_last_probed->attach==NULL) ) /* no attach routine */ + return 0 ; /* fail */ + + /* + * default initialization: copy generic parameters for the routine, + * initialize from the isa_device structure, and allocate memory. + * If everything succeeds, then call the attach routine for + * further initialization. + */ + pcm_info[dev->id_unit] = *snddev_last_probed ; + d = &pcm_info[dev->id_unit] ; + + d->io_base = dev->id_iobase ; + d->irq = ffs(dev->id_irq) - 1 ; + d->dma1 = dev->id_drq ; + if (dev->id_flags != -1 && dev->id_flags & DV_F_DUAL_DMA) /* enable dma2 */ + d->dma2 = dev->id_flags & DV_F_DRQ_MASK ; + else + d->dma2 = d->dma1 ; + /* XXX should also set bd_id from flags ? */ + d->status_ptr = 0; + + /* + * Allocates memory and initializes the dma structs properly. We + * use independent buffers for each channel. For the time being, + * this is done independently of the dma setting. In future + * revisions, if we see that we have a single dma, we might decide + * to use a single buffer to save memory. + */ + alloc_dbuf( &(d->dbuf_out), d->bufsize, d->dma1 ); + alloc_dbuf( &(d->dbuf_in), d->bufsize, d->dma2 ); + + isa_dma_acquire(d->dma1); + if (d->dma2 != d->dma1) + isa_dma_acquire(d->dma2); + /* + * initialize standard parameters for the device. This can be + * overridden by device-specific configurations but better do + * here the generic things. + */ + + d->play_speed = d->rec_speed = 8000 ; + d->play_blocksize = d->rec_blocksize = 2048 ; + d->play_fmt = d->rec_fmt = AFMT_MU_LAW ; + + isadev = makedev(CDEV_MAJOR, 0); + cdevsw_add(&isadev, &snd_cdevsw, NULL); + + /* + * should try and find a suitable value for id_id, otherwise + * the interrupt is not registered and dispatched properly. + * This is important for PnP devices, where "dev" is built on + * the fly and many field are not initialized. + */ + if (dev->id_driver == NULL) { + dev->id_driver = &pcmdriver ; + dvp=find_isadev(isa_devtab_tty, &pcmdriver, 0); + if (dvp) + dev->id_id = dvp->id_id; + } + + /* + * and finally, call the device attach routine + */ + stat = snddev_last_probed->attach(dev); + snddev_last_probed = NULL ; + + return stat ; +} + +int midiattach(struct isa_device * dev) { return 0 ; } +int synthattach(struct isa_device * dev) { return 0 ; } + +struct isa_driver pcmdriver = { pcmprobe, pcmattach, "pcm" } ; + +struct isa_driver mididriver = { midiprobe, midiattach, "midi" } ; +struct isa_driver synthdriver = { synthprobe, synthattach, "synth" } ; + +void +pcmintr(int unit) +{ + DEB(printf("__/\\/ pcmintr -- unit %d\n", unit)); + pcm_info[unit].interrupts++; + if (pcm_info[unit].isr) + pcm_info[unit].isr(unit); + if (midi_info[unit].isr) + midi_info[unit].isr(unit); + if (synth_info[unit].isr) + synth_info[unit].isr(unit); +} + +static void +print_isadev_info(struct isa_device *d, char *s) +{ + if (d == NULL ) + return ; + printf("%s%d at 0x%x irq %d drq %d mem 0x%x flags 0x%x en %d confl %d\n", + d->id_driver ? d->id_driver->name : "NONAME", + d->id_unit, + (u_short)(d->id_iobase), ffs(d->id_irq) - 1 , + d->id_drq, d->id_maddr, d->id_flags, + d->id_enabled, d->id_conflicts); +} + + +static snddev_info * +generic_snd_probe(struct isa_device * dev, snddev_info **p[], char *s) +{ + snddev_info **q ; + struct isa_device saved_dev ; + + snddev_last_probed = NULL ; + + print_isadev_info(dev, s); + + saved_dev = *dev ; /* the probe routine might alter parameters */ + + for ( ; p[0] != NULL ; p++ ) + for ( q = *p ; q[0] ; q++ ) + if (q[0]->probe && q[0]->probe(dev)) + return (snddev_last_probed = q[0]) ; + else + *dev = saved_dev ; + + return NULL ; +} + + +/* + * a small utility function which, given a device number, returns + * a pointer to the associated snddev_info struct, and sets the unit + * number. + */ +static snddev_info * +get_snddev_info(dev_t dev, int *unit) +{ + int u; + snddev_info *d = NULL ; + + dev = minor(dev); + u = dev >> 4 ; + if (unit) + *unit = u ; + + if (u > NPCM_MAX) + return NULL ; + switch(dev & 0x0f) { + case SND_DEV_CTL : /* /dev/mixer handled by pcm */ + case SND_DEV_STATUS : /* /dev/sndstat handled by pcm */ + case SND_DEV_SNDPROC : /* /dev/sndproc handled by pcm */ + case SND_DEV_DSP : + case SND_DEV_DSP16 : + case SND_DEV_AUDIO : + d = & pcm_info[u] ; + break ; + case SND_DEV_SEQ : + case SND_DEV_SEQ2 : + d = & synth_info[u] ; + break ; + case SND_DEV_MIDIN: + d = & midi_info[u] ; + break ; + default: + return NULL ; + } + return d ; +} + +/* + * here are the switches for the main functions. The switches do + * all necessary checks on the device number to make sure + * that the device is configured. They also provide some default + * functionalities so that device-specific drivers have to deal + * only with special cases. + */ + +static int +sndopen(dev_t i_dev, int flags, int mode, struct proc * p) +{ + int dev, unit ; + snddev_info *d; + + dev = minor(i_dev); + d = get_snddev_info(dev, &unit); + + DEB(printf("open snd%d subdev %d flags 0x%08x mode 0x%08x\n", + unit, dev & 0xf, flags, mode)); + + if (d == NULL) { + printf("open: unit %d dev %d not configured, perhaps you want unit %d ?\n", + unit, dev & 0xf, unit + 1 ); + return (ENXIO) ; + } + + switch(dev & 0x0f) { + case SND_DEV_CTL : /* mixer ... */ + return 0 ; /* always succeed */ + + case SND_DEV_STATUS : /* implemented right here */ + init_status(&pcm_info[unit]); + d->status_ptr = 0 ; + return 0 ; + + default: + if (d->open == NULL) { + printf("open: missing for unit %d\n", unit ); + return (ENXIO) ; + } else + return d->open(i_dev, flags, mode, p); + } + return ENXIO ; +} + +static int +sndclose(dev_t i_dev, int flags, int mode, struct proc * p) +{ + int dev, unit ; + snddev_info *d; + + dev = minor(i_dev); + d = get_snddev_info(dev, &unit); + + DEB(printf("close snd%d subdev %d\n", unit, dev & 0xf)); + + if (d == NULL) { + printf("close: unit %d dev %d not configured\n", unit, dev & 0xf ); + return (ENXIO) ; + } + switch(dev & 0x0f) { /* only those for which close makes sense */ + case SND_DEV_AUDIO : + case SND_DEV_DSP : + case SND_DEV_DSP16 : + case SND_DEV_SEQ: + case SND_DEV_SEQ2: + case SND_DEV_MIDIN: + if (d->close) + return d->close(i_dev, flags, mode, p); + } + return 0 ; +} + +static int +sndread(dev_t i_dev, struct uio * buf, int flag) +{ + int ret, dev, unit; + snddev_info *d ; + u_long s; + + dev = minor(i_dev); + + d = get_snddev_info(dev, &unit); + DEB(printf("read snd%d subdev %d flag 0x%08x\n", unit, dev & 0xf, flag)); + + if (d == NULL) { + printf("read: unit %d not configured\n", unit ); + return ENXIO ; + } + if ( (dev & 0x0f) == SND_DEV_STATUS ) { + int l, c; + u_char *p; + + l = buf->uio_resid; + s=spltty(); + c = status_len - d->status_ptr ; + if (c < 0) /* should not happen! */ + c = 0 ; + if (c < l) + l = c ; + p = status_buf + d->status_ptr ; + d->status_ptr += l ; + splx(s); + ret = uiomove(p, l, buf) ; + if (ret) + printf("pcm-stat: bad copyout\n"); + return ret ; + } + if (d->read) /* device-specific read */ + return d->read(i_dev, buf, flag); + + /* + * the generic read routine. device-specific stuff should only + * be in the dma-handling procedures. + */ + s = spltty(); + if ( d->flags & SND_F_READING ) { + /* another reader is in, deny request */ + splx(s); + DDB(printf("read denied, another reader is in\n")); + return EBUSY ; + } + if (d->dma1 == d->dma2) { /* half duplex */ + if ( d->flags & SND_F_WRITING ) { + /* another writer is in, deny request */ + splx(s); + DDB(printf("read denied, half duplex and a writer is in\n")); + return EBUSY ; + } + while ( d->flags & SND_F_WR_DMA ) { + /* + * we have a pending dma operation, post a read request + * and wait for the write to complete. + */ + d->flags |= SND_F_READING ; + DDB(printf("sndread: sleeping waiting for write to end\n")); + ret = tsleep( (caddr_t)&(d->dbuf_out), + PRIBIO | PCATCH , "sndrdw", hz ) ; + if (ret == ERESTART || ret == EINTR) { + d->flags &= ~SND_F_READING ; + splx(s); + return EINTR ; + } + } + } + d->flags |= SND_F_READING ; + splx(s); + + return dsp_read_body(d, buf); +} + +static int +sndwrite(dev_t i_dev, struct uio * buf, int flag) +{ + int ret, dev, unit; + snddev_info *d; + u_long s; + + dev = minor(i_dev); + d = get_snddev_info(dev, &unit); + + DEB(printf("write snd%d subdev %d flag 0x%08x\n", unit, dev & 0xf, flag)); + + if (d == NULL) { + printf("write: unit %d not configured\n", unit ); + return (ENXIO) ; + } + switch( dev & 0x0f) { /* only writeable devices */ + case SND_DEV_MIDIN: /* XXX is this writable ? */ + case SND_DEV_SEQ : + case SND_DEV_SEQ2 : + case SND_DEV_DSP : + case SND_DEV_DSP16 : + case SND_DEV_AUDIO : + break ; + default: + return EPERM ; /* for non-writeable devices ; */ + } + if (d->write) + return d->write(i_dev, buf, flag); + + /* + * Otherwise, use the generic write routine. device-specific + * stuff should only be in the dma-handling procedures. + */ + + s = spltty(); + if ( d->flags & SND_F_WRITING ) { + /* another writer is in, deny request */ + splx(s); + DDB(printf("write denied, another writer is in\n")); + return EBUSY ; + } + if (d->dma1 == d->dma2) { /* half duplex */ + if ( d->flags & SND_F_READING ) { + DDB(printf("write denied, half duplex and a reader is in\n")); + /* another reader is in, deny request */ + splx(s); + return EBUSY ; + } + while ( d->flags & SND_F_RD_DMA ) { + /* + * we have a pending read dma. Post a write request + * and wait for the read to complete (in fact I could + * abort the read dma... + */ + d->flags |= SND_F_WRITING ; + DEB(printf("sndwrite: sleeping waiting for read to end\n")); + ret = tsleep( (caddr_t)&(d->dbuf_out), + PRIBIO | PCATCH , "sndwr", hz ) ; + if (ret == ERESTART || ret == EINTR) { + d->flags &= ~SND_F_WRITING ; + splx(s); + return EINTR ; + } + } + } + d->flags |= SND_F_WRITING ; + splx(s); + + return dsp_write_body(d, buf); +} + +/* + * generic sound ioctl. Functions of the default driver can be + * overridden by the device-specific ioctl call. + * If a device-specific call returns ENOSYS (Function not implemented), + * the default driver is called. Otherwise, the returned value + * is passed up. + * + * The default handler, for many parameters, sets the value in the + * descriptor, sets SND_F_INIT, and calls the callback function with + * reason INIT. If successful, the callback returns 1 and the caller + * can update the parameter. + */ + +static int +sndioctl(dev_t i_dev, int cmd, caddr_t arg, int mode, struct proc * p) +{ + int ret = ENOSYS, dev, unit ; + snddev_info *d; + u_long s; + + dev = minor(i_dev); + d = get_snddev_info(dev, &unit); + + if (d == NULL) { + printf("ioctl: unit %d not configured\n", unit ); + return (ENXIO) ; + } + if (d->ioctl) + ret = d->ioctl(dev, cmd, arg, mode, p); + if (ret != ENOSYS) + return ret ; + + /* + * pass control to the default ioctl handler. Set ret to 0 now. + */ + ret = 0 ; + + /* + * The linux ioctl interface for the sound driver has a thousand + * different calls, and it is unpractical to put the names in + * the switch(). So we have some tests before for common routines, + * such as the ones related to the mixer. But we really ought + * to redesign the interface! + * + * Reading from the mixer just requires to look at the cached + * copy in d->mix_levels[dev], so this routine should cover + * practically all needs for mixer reading. + */ + if ( (cmd & MIXER_READ(0)) == MIXER_READ(0) && (cmd & 0xff) < 32 ) { + int dev = cmd & 0x1f ; + if ( d->mix_devs & (1<mix_levels[dev]; + return 0 ; + } else + return EINVAL ; + } + + /* + * all routines are called with int. blocked. Make sure that + * ints are re-enabled when calling slow or blocking functions! + */ + s = spltty(); + switch(cmd) { + + /* + * we start with the new ioctl interface. + */ + case AIONWRITE : /* how many bytes can write ? */ + if (d->flags & SND_F_WR_DMA) + dsp_wr_dmaupdate(d); + *(int *)arg = d->dbuf_out.fl; + break; + + case AIOSSIZE : /* set the current blocksize */ + { + struct snd_size *p = (struct snd_size *)arg; + if (p->play_size <= 1 && p->rec_size <= 1) { /* means no blocks */ + d->flags &= ~SND_F_HAS_SIZE ; + } else { + RANGE (p->play_size, 40, d->bufsize /4); + d->play_blocksize = p->play_size & ~3 ; + RANGE (p->rec_size, 40, d->bufsize /4); + d->rec_blocksize = p->rec_size & ~3 ; + d->flags |= SND_F_HAS_SIZE ; + } + } + splx(s); + ask_init(d); + /* FALLTHROUGH */ + case AIOGSIZE : /* get the current blocksize */ + { + struct snd_size *p = (struct snd_size *)arg; + p->play_size = d->play_blocksize ; + p->rec_size = d->rec_blocksize ; + } + break ; + + case AIOSFMT : + { + snd_chan_param *p = (snd_chan_param *)arg; + /* + * at the moment, only support same format on play & rec + */ + d->play_speed = p->play_rate; + d->rec_speed = p->play_rate; /* XXX */ + if (p->play_format & SND_F_STEREO) + d->flags |= SND_F_STEREO ; + else + d->flags &= ~SND_F_STEREO ; + d->play_fmt = p->play_format & ~AFMT_STEREO ; + d->rec_fmt = p->rec_format & ~AFMT_STEREO ; + } + splx(s); + if (!ask_init(d)) + break ; /* could not reinit */ + /* FALLTHROUGH */ + + case AIOGFMT : + { + snd_chan_param *p = (snd_chan_param *)arg; + p->play_rate = d->play_speed; + p->rec_rate = d->rec_speed; + p->play_format = d->play_fmt; + p->rec_format = d->rec_fmt; + if (d->flags & SND_F_STEREO) { + p->play_format |= AFMT_STEREO ; + p->rec_format |= AFMT_STEREO ; + } + } + break; + + case AIOGCAP : /* get capabilities */ + /* this should really be implemented by the driver */ + { + snd_capabilities *p = (snd_capabilities *)arg; + p->rate_min = 5000; + p->rate_max = 48000; /* default */ + p->bufsize = d->bufsize; + p->formats = d->audio_fmt; /* default */ + p->mixers = 1 ; /* default: one mixer */ + p->inputs = d->mix_devs ; + p->left = p->right = 255 ; + } + break ; + + case AIOSTOP: + if (*(int *)arg == AIOSYNC_PLAY) /* play */ + *(int *)arg = dsp_wrabort(d); + else if (*(int *)arg == AIOSYNC_CAPTURE) + *(int *)arg = dsp_rdabort(d); + else { + splx(s); + printf("AIOSTOP: bad channel 0x%x\n", *(int *)arg); + *(int *)arg = 0 ; + } + break ; + + case AIOSYNC: + printf("AIOSYNC chan 0x%03x pos %d unimplemented\n", + ((snd_sync_parm *)arg)->chan, + ((snd_sync_parm *)arg)->pos); + break; + /* + * here follow the standard ioctls (filio.h etc.) + */ + case FIONREAD : /* get # bytes to read */ + if ( d->flags & SND_F_RD_DMA ) + dsp_rd_dmaupdate(d); + *(int *)arg = d->dbuf_in.rl; + break; + + case FIOASYNC: /*set/clear async i/o */ + printf("FIOASYNC\n"); + break; + + case SNDCTL_DSP_NONBLOCK : + case FIONBIO : /* set/clear non-blocking i/o */ + if ( *(int *)arg == 0 ) + d->flags &= ~SND_F_NBIO ; + else + d->flags |= SND_F_NBIO ; + break ; + + /* + * Finally, here is the linux-compatible ioctl interface + */ + case SNDCTL_DSP_GETBLKSIZE: + *(int *) arg = d->play_blocksize ; + break ; + + case SNDCTL_DSP_SETBLKSIZE : + { + int t = *(int *)arg; + if (t <= 1) { /* means no blocks */ + d->flags &= ~SND_F_HAS_SIZE ; + } else { + RANGE (t, 40, d->bufsize /4); + d->play_blocksize = + d->rec_blocksize = t & ~3 ; /* align to multiple of 4 */ + d->flags |= SND_F_HAS_SIZE ; + } + } + splx(s); + ask_init(d); + break ; + case SNDCTL_DSP_RESET: + printf("dsp reset\n"); + dsp_wrabort(d); + dsp_rdabort(d); + break ; + + case SNDCTL_DSP_SYNC: + printf("dsp sync\n"); + splx(s); + snd_sync(d, 1, d->bufsize - 4); /* DMA does not start with <4 bytes */ + break ; + + case SNDCTL_DSP_SPEED: + d->play_speed = d->rec_speed = *(int *)arg ; + splx(s); + if (ask_init(d)) + *(int *)arg = d->play_speed ; + break ; + + case SNDCTL_DSP_STEREO: + if ( *(int *)arg == 0 ) + d->flags &= ~SND_F_STEREO ; /* mono */ + else if ( *(int *)arg == 1 ) + d->flags |= SND_F_STEREO ; /* stereo */ + else { + printf("dsp stereo: %d is invalid, assuming 1\n", *(int *)arg ); + d->flags |= SND_F_STEREO ; /* stereo */ + } + splx(s); + if (ask_init(d)) + *(int *)arg = (d->flags & SND_F_STEREO) ? 1 : 0 ; + break ; + + case SOUND_PCM_WRITE_CHANNELS: + printf("dsp write channels %d\n", *(int *)arg); + if ( *(int *)arg == 1) + d->flags &= ~SND_F_STEREO ; /* mono */ + else if ( *(int *)arg == 2) + d->flags |= SND_F_STEREO ; /* stereo */ + else { + ret = EINVAL ; + break ; + } + splx(s); + if (ask_init(d)) + *(int *)arg = (d->flags & SND_F_STEREO) ? 2 : 1 ; + break ; + + case SOUND_PCM_READ_RATE: + *(int *)arg = d->play_speed; + break ; + + case SOUND_PCM_READ_CHANNELS: + *(int *)arg = (d->flags & SND_F_STEREO) ? 2 : 1; + break ; + + case SNDCTL_DSP_GETFMTS: /* returns a mask of supported fmts */ + *(int *)arg = (int)d->audio_fmt ; + break ; + + case SNDCTL_DSP_SETFMT: /* sets _one_ format */ + d->play_fmt = d->rec_fmt = *(int *)arg ; + splx(s); + if (ask_init(d)) + *(int *)arg = d->play_fmt ; + break ; + + case SNDCTL_DSP_SUBDIVIDE: + /* XXX watch out, this is RW! */ + printf("SNDCTL_DSP_SUBDIVIDE yet unimplemented\n"); + break; + + case SNDCTL_DSP_SETFRAGMENT: + /* XXX watch out, this is RW! */ + printf("SNDCTL_DSP_SETFRAGMENT 0x%08x\n", *(int *)arg); + { + int bytes, count; + bytes = *(int *)arg & 0xffff ; + count = ( *(int *)arg >> 16) & 0xffff ; + if (bytes < 7 || bytes > 15) + return EINVAL ; + d->play_blocksize = + d->rec_blocksize = min ( 1<< bytes, d->dbuf_in.bufsize) ; + count = d->dbuf_in.bufsize / d->play_blocksize ; + bytes = ffs(d->play_blocksize) - 1; +#if 0 + /* + * don't change arg, since it's fake anyways and some + * programs might fail if we do. + */ + *(int *)arg = (count << 16) | bytes ; +#endif + } + break ; + + case SNDCTL_DSP_GETISPACE: + /* return space available in the input queue */ + ((audio_buf_info *)arg)->bytes = d->dbuf_in.fl ; + ((audio_buf_info *)arg)->fragments = 1 ; + ((audio_buf_info *)arg)->fragstotal = + d->bufsize / d->play_blocksize ; + ((audio_buf_info *)arg)->fragsize = d->play_blocksize ; + break ; + + case SNDCTL_DSP_GETOSPACE: + /* return space available in the output queue */ + ((audio_buf_info *)arg)->bytes = d->dbuf_out.fl ; + ((audio_buf_info *)arg)->fragments = 1 ; + ((audio_buf_info *)arg)->fragstotal = + d->bufsize / d->play_blocksize ; + ((audio_buf_info *)arg)->fragsize = d->play_blocksize ; + break ; + + case SNDCTL_DSP_GETCAPS : + printf("dsp getcaps\n"); + break ; + + case SOUND_PCM_READ_BITS: + if (d->play_fmt == AFMT_S16_LE) + *(int *) arg = 16 ; + else + *(int *) arg = 8 ; + break ; + + /* + * mixer calls + */ + + case SOUND_MIXER_READ_DEVMASK : + case SOUND_MIXER_READ_STEREODEVS : + *(int *)arg = d->mix_devs; + break ; + + case SOUND_MIXER_READ_RECMASK : + *(int *)arg = d->mix_rec_devs; + break ; + + case SOUND_MIXER_READ_RECSRC : + *(int *)arg = d->mix_recsrc ; + break; + + default: + DEB(printf("default ioctl snd%d subdev %d fn 0x%08x fail\n", + unit, dev & 0xf, cmd)); + ret = EINVAL; + break ; + } + splx(s); + return ret ; +} + +int +sndselect(dev_t i_dev, int rw, struct proc * p) +{ + int dev, unit, c = 1 /* default: success */ ; + snddev_info *d ; + u_long flags; + + dev = minor(i_dev); + d = get_snddev_info(dev, &unit); + DEB(printf("sndselect dev 0x%04x rw 0x%08x\n",i_dev, rw)); + if (d == NULL ) { + printf("select: unit %d not configured\n", unit ); + return (ENXIO) ; + } + if (d->select == NULL) + return 1 ; /* always success ? */ + else if (d->select != sndselect ) + return d->select(i_dev, rw, p); + else { + /* handle it here with the generic code */ + + int lim ; + + /* + * if the user selected a block size, then we want to use the + * device as a block device, and select will return ready when + * we have a full block. + * In all other cases, select will return when 1 byte is ready. + */ + lim = 1; + switch(rw) { + case FWRITE : + if ( d->flags & SND_F_HAS_SIZE ) + lim = d->play_blocksize ; + /* XXX fix the test here for half duplex devices */ + if (1 /* write is compatible with current mode */) { + flags = spltty(); + if (d->flags & SND_F_WR_DMA) + dsp_wr_dmaupdate(d); + c = d->dbuf_out.fl ; + if (c < lim) /* no space available */ + selrecord(p, & (d->wsel)); + splx(flags); + } + return c < lim ? 0 : 1 ; + + case FREAD : + if ( d->flags & SND_F_HAS_SIZE ) + lim = d->rec_blocksize ; + /* XXX fix the test here */ + if (1 /* read is compatible with current mode */) { + flags = spltty(); + if ( !(d->flags & SND_F_RD_DMA) ) /* dma idle, restart it */ + dsp_rdintr(d); + else + dsp_rd_dmaupdate(d); + c = d->dbuf_in.rl ; + if (c < lim) /* no data available */ + selrecord(p, & (d->rsel)); + splx(flags); + } + DEB(printf("sndselect on read: %d >= %d flags 0x%08x\n", + c, lim, d->flags)); + return c < lim ? 0 : 1 ; + + case 0 : + DDB(printf("select on exceptions, unimplemented\n")); + return 1; + } + } + return ENXIO ; /* notreached */ +} + +/* + * The mmap interface allows access to the play and read buffer, + * plus the device descriptor. + * The various blocks are accessible at the following offsets: + * + * 0x00000000 ( 0 ) : write buffer ; + * 0x01000000 (16 MB) : read buffer ; + * 0x02000000 (32 MB) : device descriptor (dangerous!) + * + * WARNING: the mmap routines assume memory areas are aligned. This + * is true (probably) for the dma buffers, but likely false for the + * device descriptor. As a consequence, we do not know where it is + * located in the requested area. + */ +#include +#include +#include +#include +#include +#include + +static int +sndmmap(dev_t dev, int offset, int nprot) +{ + snddev_info *d = get_snddev_info(dev, NULL); + + DEB(printf("sndmmap d 0x%08x dev 0x%04x ofs 0x%08x nprot 0x%08x\n", + d, dev, offset, nprot)); + + if (d == NULL || nprot & PROT_EXEC) + return -1 ; /* forbidden */ + + if (offset > d->bufsize && (nprot & PROT_WRITE) ) + return -1 ; /* can only write to the first block */ + + if (offset < d->bufsize) + return i386_btop(vtophys(d->dbuf_out.buf + offset)); + offset -= 1 << 24; + if ( (offset >= 0) && (offset < d->bufsize)) + return i386_btop(vtophys(d->dbuf_in.buf + offset)); + offset -= 1 << 24; + if ( (offset >= 0) && (offset < 0x2000)) { + printf("name %s\n", d->name); + return i386_btop(vtophys( ((int)d & ~0xfff) + offset)); + } + return -1 ; +} + + +/* + * ask_init sets the init flag in the device descriptor, and + * possibly calls the appropriate callback routine, returning 1 + * if the callback was successful. This enables ioctls handler for + * rw parameters to read back the updated value. + * Since the init callback can be slow, ask_init() should be called + * with interrupts enabled. + */ + +int +ask_init(snddev_info *d) +{ + u_long s; + + if ( d->callback == NULL ) + return 0 ; + s = spltty(); + if ( d->flags & SND_F_PENDING_IO ) { + /* cannot do it now, record the request and return */ + d->flags |= SND_F_INIT ; + splx(s); + return 0 ; + } else { + splx(s); + d->callback(d, SND_CB_INIT ); + return 1; + } +} + +/* + * these are the functions for the soundstat device. We copy parameters + * from the device info structure to static variables, and from there + * back to the structure when done. + */ + +static void +init_status(snddev_info *d) +{ + /* + * Write the status information to the status_buf and update + * status_len. There is a limit of SNDSTAT_BUF_SIZE bytes for the data. + * put_status handles this and returns 0 in case of failure. Since + * it never oveflows the buffer, we do not care to check. + */ + + int i; + + if (status_len != 0) /* only do init once */ + return ; + sprintf(status_buf, + "FreeBSD Sound Driver " __DATE__ " " __TIME__ "\n" + "Installed devices:\n"); + + for (i = 0; i < NPCM_MAX; i++) { + if (pcm_info[i].open) + sprintf(status_buf + strlen(status_buf), + "pcm%d: <%s> at 0x%x irq %d dma %d:%d\n", + i, pcm_info[i].name, pcm_info[i].io_base, + pcm_info[i].irq, + pcm_info[i].dma1, pcm_info[i].dma2); + if (midi_info[i].open) + sprintf(status_buf + strlen(status_buf), + "midi%d: <%s> at 0x%x irq %d dma %d:%d\n", + i, midi_info[i].name, midi_info[i].io_base, + midi_info[i].irq, + midi_info[i].dma1, midi_info[i].dma2); + if (synth_info[i].open) + sprintf(status_buf + strlen(status_buf), + "synth%d: <%s> at 0x%x irq %d dma %d:%d\n", + i, synth_info[i].name, synth_info[i].io_base, + synth_info[i].irq, + synth_info[i].dma1, synth_info[i].dma2); + } + status_len = strlen(status_buf) ; +} + +/* + * finally, some "libraries" + */ + +/* + * isa_dmastatus1() is a wrapper for isa_dmastatus(), which + * might return -1 or -2 in some cases (errors). Since for the + * user code it is more comfortable not to check for these cases, + * negative values are mapped back to 0 (which is reasonable). + */ + +int +isa_dmastatus1(int channel) +{ + int r = isa_dmastatus(channel); + if (r<0) r = 0; + return r; +} + +/* + * snd_conflict scans already-attached boards to see if + * the current address is conflicting with one of the already + * assigned ones. Returns 1 if a conflict is detected. + */ +int +snd_conflict(int io_base) +{ + int i; + for (i=0; i< NPCM_MAX ; i++) { + if ( (io_base == pcm_info[i].io_base ) || + (io_base == pcm_info[i].alt_base ) || + (io_base == pcm_info[i].conf_base) || + (io_base == pcm_info[i].mix_base ) || + (io_base == pcm_info[i].midi_base) || + (io_base == pcm_info[i].synth_base) ) { + printf("device at 0x%x already attached as unit %d\n", + io_base, i); + return 1 ; + } + } + return 0; +} + +void +snd_set_blocksize(snddev_info *d) +{ + /* + * now set the blocksize so as to guarantee approx 1/4s + * between callbacks. + */ + if ( (d->flags & SND_F_HAS_SIZE) == 0) { + /* make blocksize adaptive to 250ms or max 1/4 of the buf */ + int tmp ; + tmp = d->play_speed; + if (d->flags & SND_F_STEREO) tmp += tmp; + if (d->play_fmt & (AFMT_S16_LE|AFMT_U16_LE)) tmp += tmp; + d->play_blocksize = (tmp / 4) & ~3; /* 0.25s, aligned to 4 */ + RANGE (d->play_blocksize, 1024, (d->bufsize / 4) & ~3); + + tmp = d->rec_speed; + if (d->flags & SND_F_STEREO) tmp += tmp; + if (d->rec_fmt & (AFMT_S16_LE|AFMT_U16_LE)) tmp += tmp; + d->rec_blocksize = (tmp / 4) & ~3; /* 0.25s, aligned to 4 */ + RANGE (d->rec_blocksize, 1024, (d->bufsize / 4) & ~3); + } +} + +/* + * The various mixers use a variety of bitmasks etc. The Voxware + * driver had a very nice technique to describe a mixer and interface + * to it. A table defines, for each channel, which register, bits, + * offset, polarity to use. This procedure creates the new value + * using the table and the old value. + */ + +void +change_bits(mixer_tab *t, u_char *regval, int dev, int chn, int newval) +{ + u_char mask; + int shift; + + DEB(printf("ch_bits dev %d ch %d val %d old 0x%02x " + "r %d p %d bit %d off %d\n", + dev, chn, newval, *regval, + (*t)[dev][chn].regno, (*t)[dev][chn].polarity, + (*t)[dev][chn].nbits, (*t)[dev][chn].bitoffs ) ); + + if ( (*t)[dev][chn].polarity == 1) /* reverse */ + newval = 100 - newval ; + + mask = (1 << (*t)[dev][chn].nbits) - 1; + newval = (int) ((newval * mask) + 50) / 100; /* Scale it */ + shift = (*t)[dev][chn].bitoffs /*- (*t)[dev][LEFT_CHN].nbits + 1*/; + + *regval &= ~(mask << shift); /* Filter out the previous value */ + *regval |= (newval & mask) << shift; /* Set the new value */ +} + + +/* + * code for translating between U8 and ULAW. Needed to support + * /dev/audio on the SoundBlaster. Actually, we would also need + * ulaw -> 16 bits (for the soundblaster as well, when used in + * full-duplex) + */ + +#if 1 +void +translate_bytes (u_char *table, u_char *buff, int n) +{ + u_long i; + + if (n <= 0) + return; + + for (i = 0; i < n; ++i) + buff[i] = table[buff[i]]; +} +#else +/* inline */ +void +translate_bytes (const void *table, void *buff, int n) +{ + if (n > 0) { + __asm__ ( " cld\n" + "1: lodsb\n" + " xlatb\n" + " stosb\n" + " loop 1b\n": + : "b" ((long) table), "c" (n), "D" ((long) buff), "S" ((long) buff) + : "bx", "cx", "di", "si", "ax"); + } +} + +#endif + +#endif /* NPCM > 0 */ diff --git a/sys/i386/isa/snd/sound.h b/sys/i386/isa/snd/sound.h new file mode 100644 index 000000000000..00e15ed713ac --- /dev/null +++ b/sys/i386/isa/snd/sound.h @@ -0,0 +1,492 @@ +/* + * sound.h + * + * include file for kernel sources, sound driver. + * + * Copyright by Hannu Savolainen 1995 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#include "pcm.h" +#if NPCM > 0 + +/* + * first, include kernel header files. + */ + +#ifndef _OS_H_ +#define _OS_H_ + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include /* for DATA_SET */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include /* for DELAY */ + +typedef void (irq_proc_t) (int irq); + +#endif /* _OS_H_ */ + +/* + * descriptor of a dma buffer. See dmabuf.c for documentation. + * (rp,rl) and (fp,fl) identify the READY and FREE regions of the + * buffer. (dp,dl) identify the region currently used by the DMA. + * Only dmabuf.c should test the value of dl. The reason is that + * in auto-dma mode looking at dl alone does not make much sense, + * since the transfer potentially spans the entire buffer. + */ + +typedef struct _snd_dbuf { + char *buf; + int bufsize ; + volatile int dp, rp, fp; + volatile int dl, rl, fl; + volatile int dl0; /* value used last time in dl */ + int int_count; +} snd_dbuf ; + +/* + * descriptor of audio operations ... + * + */ +typedef struct _snddev_info snddev_info ; +typedef int (snd_callback_t)(snddev_info *d, int reason); + +struct _snddev_info { + + /* + * the first part of the descriptor is filled up from a + * template. + */ + char name[64]; + + int type ; + + int (*probe)(struct isa_device * dev); + int (*attach)(struct isa_device * dev) ; + d_open_t *open ; + d_close_t *close ; + d_read_t *read ; + d_write_t *write ; + d_ioctl_t *ioctl ; + d_select_t *select ; + irq_proc_t *isr ; + snd_callback_t *callback; + + int bufsize; /* space used for buffers */ + + u_long audio_fmt ; /* supported audio formats */ + + + /* + * combinations of the following flags are used as second argument in + * the callback from the dma module to the device-specific routines. + */ + +#define SND_CB_RD 0x100 /* read callback */ +#define SND_CB_WR 0x200 /* write callback */ +#define SND_CB_REASON_MASK 0xff +#define SND_CB_START 0x01 /* start dma op */ +#define SND_CB_RESTART 0x02 /* restart dma op */ +#define SND_CB_STOP 0x03 /* stop dma op */ +#define SND_CB_ABORT 0x04 /* abort dma op */ +#define SND_CB_INIT 0x05 /* init board parameters */ + /* init can only be called with int enabled and + * no pending DMA activity. + */ + + /* + * whereas from here, parameters are set at runtime. + */ + + int io_base ; /* primary I/O address for the board */ + int alt_base ; /* some codecs are accessible as SB+WSS... */ + int conf_base ; /* and the opti931 also has a config space */ + int mix_base ; /* base for the mixer... */ + int midi_base ; /* base for the midi */ + int synth_base ; /* base for the synth */ + + int irq ; + int dma1, dma2 ; /* dma2=dma1 for half-duplex cards */ + + int bd_id ; /* used to hold board-id info, eg. sb version, + * mss codec type, etc. etc. + */ + + snd_dbuf dbuf_out, dbuf_in; + + int status_ptr; /* used to implement sndstat */ + + /* + * these parameters describe the operation of the board. + * Generic things like busy flag, speed, etc are here. + */ + + volatile u_long flags ; /* 32 bits, used for various purposes. */ + + /* + * we have separate flags for read and write, although in some + * cases this is probably not necessary (e.g. because we cannot + * know how many processes are using the device, we cannot + * distinguish if open, close, abort are for a write or for a + * read). + */ + + /* + * the following flag is used by open-close routines + * to mark the status of the device. + */ +#define SND_F_BUSY 0x0001 /* has been opened */ + /* + * Only the last close for a device will propagate to the driver. + * Unfortunately, voxware uses 3 different minor numbers + * (dsp, dsp16 and audio) to access the same unit. So, if + * we want to support multiple opens and still keep track of + * what is happening, we also need a separate flag for each minor + * number. These are below... + */ +#define SND_F_BUSY_AUDIO 0x10000000 +#define SND_F_BUSY_DSP 0x20000000 +#define SND_F_BUSY_DSP16 0x40000000 +#define SND_F_BUSY_ANY 0x70000000 + /* + * the next two are used to allow only one pending operation of + * each type. + */ +#define SND_F_READING 0x0004 /* have a pending read */ +#define SND_F_WRITING 0x0008 /* have a pending write */ + /* + * these mark pending DMA operations. When you have pending dma ops, + * you might get interrupts, so some manipulations of the + * descriptors must be done with interrupts blocked. + */ +#define SND_F_RD_DMA 0x0010 /* read-dma active */ +#define SND_F_WR_DMA 0x0020 /* write-dma active */ + +#define SND_F_PENDING_IN (SND_F_READING | SND_F_RD_DMA) +#define SND_F_PENDING_OUT (SND_F_WRITING | SND_F_WR_DMA) +#define SND_F_PENDING_IO (SND_F_PENDING_IN | SND_F_PENDING_OUT) + + /* + * flag used to mark a pending close. + */ +#define SND_F_CLOSING 0x0040 /* a pending close */ + + /* + * if user has not set block size, then make it adaptive + * (0.25s, or the perhaps last read/write ?) + */ +#define SND_F_HAS_SIZE 0x0080 /* user set block size */ + /* + * assorted flags related to operating mode. + */ +#define SND_F_STEREO 0x0100 /* doing stereo */ +#define SND_F_NBIO 0x0200 /* do non-blocking i/o */ + + /* + * the user requested ulaw, but the board does not support it + * natively, so a (software) format conversion is necessary. + * The kernel is not really the place to do this, but since + * many applications expect to use /dev/audio , we do it for + * portability. + */ +#define SND_F_XLAT8 0x0400 /* u-law <--> 8-bit unsigned */ +#define SND_F_XLAT16 0x0800 /* u-law <--> 16-bit signed */ + + /* + * these flags mark a pending abort on a r/w operation. + */ +#define SND_F_ABORTING 0x1000 /* a pending abort */ + + /* + * this is used to mark that board initialization is needed, e.g. + * because of a change in sampling rate, format, etc. -- It will + * be done at the next convenient time. + */ +#define SND_F_INIT 0x4000 /* changed parameters. need init */ +#define SND_F_AUTO_DMA 0x8000 /* use auto-dma */ + + u_long bd_flags; /* board-specific flags */ + int play_speed, rec_speed; + + int play_blocksize, rec_blocksize; /* blocksize for io and dma ops */ + u_long play_fmt, rec_fmt ; /* current audio format */ + + /* + * mixer parameters + */ + u_long mix_devs; /* existing devices for mixer */ + u_long mix_rec_devs; /* possible recording sources */ + u_long mix_recsrc; /* current recording source(s) */ + u_short mix_levels[32]; + + struct selinfo wsel, rsel, esel ; + u_long interrupts; /* counter of interrupts */ + void *device_data ; /* just in case it is needed...*/ +} ; + +/* + * then ioctls and other stuff + */ + +#define NPCM_MAX 8 /* Number of supported devices */ + +/* + * Supported card ID numbers (were in soundcard.h...) + */ + +#define SNDCARD_ADLIB 1 +#define SNDCARD_SB 2 +#define SNDCARD_PAS 3 +#define SNDCARD_GUS 4 +#define SNDCARD_MPU401 5 +#define SNDCARD_SB16 6 +#define SNDCARD_SB16MIDI 7 +#define SNDCARD_UART6850 8 +#define SNDCARD_GUS16 9 +#define SNDCARD_MSS 10 +#define SNDCARD_PSS 11 +#define SNDCARD_SSCAPE 12 +#define SNDCARD_PSS_MPU 13 +#define SNDCARD_PSS_MSS 14 +#define SNDCARD_SSCAPE_MSS 15 +#define SNDCARD_TRXPRO 16 +#define SNDCARD_TRXPRO_SB 17 +#define SNDCARD_TRXPRO_MPU 18 +#define SNDCARD_MAD16 19 +#define SNDCARD_MAD16_MPU 20 +#define SNDCARD_CS4232 21 +#define SNDCARD_CS4232_MPU 22 +#define SNDCARD_MAUI 23 +#define SNDCARD_PSEUDO_MSS 24 /* MSS without WSS regs.*/ +#define SNDCARD_AWE32 25 + +/* + * values used in bd_id for the mss boards + */ +#define MD_AD1848 0x91 +#define MD_AD1845 0x92 +#define MD_CS4248 0xA1 +#define MD_CS4231 0xA2 +#define MD_CS4231A 0xA3 +#define MD_CS4232 0xA4 +#define MD_CS4232A 0xA5 +#define MD_CS4236 0xA6 +#define MD_OPTI931 0xB1 + +/* + * TODO: add some card classes rather than specific types. + */ +#include + +/* + * many variables should be reduced to a range. Here define a macro + */ + +#define RANGE(var, low, high) (var) = \ + ((var)<(low)?(low) : (var)>(high)?(high) : (var)) + +/* + * finally, all default parameters + */ +#define DSP_BUFFSIZE 65536 /* XXX */ + +#if 1 /* prepare for pnp support! */ +#include "pnp.h" +#if NPNP > 0 +#include /* XXX pnp support */ +#endif +#endif + +/* + * Minor numbers for the sound driver. + * + * Unfortunately Creative called the codec chip of SB as a DSP. For this + * reason the /dev/dsp is reserved for digitized audio use. There is a + * device for true DSP processors but it will be called something else. + * In v3.0 it's /dev/sndproc but this could be a temporary solution. + */ + + +#define SND_DEV_CTL 0 /* Control port /dev/mixer */ +#define SND_DEV_SEQ 1 /* Sequencer output /dev/sequencer (FM + synthesizer and MIDI output) */ +#define SND_DEV_MIDIN 2 /* Raw midi access */ +#define SND_DEV_DSP 3 /* Digitized voice /dev/dsp */ +#define SND_DEV_AUDIO 4 /* Sparc compatible /dev/audio */ +#define SND_DEV_DSP16 5 /* Like /dev/dsp but 16 bits/sample */ +#define SND_DEV_STATUS 6 /* /dev/sndstat */ + /* #7 not in use now. Was in 2.4. Free for use after v3.0. */ +#define SND_DEV_SEQ2 8 /* /dev/sequencer, level 2 interface */ +#define SND_DEV_SNDPROC 9 /* /dev/sndproc for programmable devices */ +#define SND_DEV_PSS SND_DEV_SNDPROC + +#define DSP_DEFAULT_SPEED 8000 + +#define ON 1 +#define OFF 0 + + +#define SYNTH_MAX_VOICES 32 + +struct voice_alloc_info { + int max_voice; + int used_voices; + int ptr; /* For device specific use */ + u_short map[SYNTH_MAX_VOICES]; /* (ch << 8) | (note+1) */ + int timestamp; + int alloc_times[SYNTH_MAX_VOICES]; +}; + +struct channel_info { + int pgm_num; + int bender_value; + u_char controllers[128]; +}; + +/* + * mixer description structure and macros + */ + +struct mixer_def { + u_int regno:7; + u_int polarity:1; /* 1 means reversed */ + u_int bitoffs:4; + u_int nbits:4; +}; +typedef struct mixer_def mixer_ent; +typedef struct mixer_def mixer_tab[32][2]; + +#define MIX_ENT(name, reg_l, pol_l, pos_l, len_l, reg_r, pol_r, pos_r, len_r) \ + {{reg_l, pol_l, pos_l, len_l}, {reg_r, pol_r, pos_r, len_r}} +#define PMIX_ENT(name, reg_l, pos_l, len_l, reg_r, pos_r, len_r) \ + {{reg_l, 0, pos_l, len_l}, {reg_r, 0, pos_r, len_r}} + +#define DDB(x) x /* XXX */ + +#ifndef DEB +#define DEB(x) +#endif +#ifndef DDB +#define DDB(x) +#endif + +extern snddev_info pcm_info[NPCM_MAX] ; +extern snddev_info midi_info[NPCM_MAX] ; +extern snddev_info synth_info[NPCM_MAX] ; + +extern u_long nsnd ; +extern snddev_info *snddev_last_probed; + +int pcmprobe(struct isa_device * dev); +int midiprobe(struct isa_device * dev); +int synthprobe(struct isa_device * dev); +int pcmattach(struct isa_device * dev); +int midiattach(struct isa_device * dev); +int synthattach(struct isa_device * dev); + +/* + * functions in isa.c + */ + +int isa_dmastatus(int chan); +int isa_dmastop(int chan); +/* + * DMA buffer calls + */ + +void dsp_wrintr(snddev_info *d); +void dsp_rdintr(snddev_info *d); +int dsp_write_body(snddev_info *d, struct uio *buf); +int dsp_read_body(snddev_info *d, struct uio *buf); +void alloc_dbuf(snd_dbuf *d, int size, int b16); +void reset_dbuf(snd_dbuf *b); +int snd_flush(snddev_info *d); +int snd_sync(snddev_info *d, int chan, int threshold); +int dsp_wrabort(snddev_info *d); +int dsp_rdabort(snddev_info *d); +void dsp_wr_dmaupdate(snddev_info *d); +void dsp_rd_dmaupdate(snddev_info *d); + +d_select_t sndselect; + +/* + * library functions (in sound.c) + */ + +int ask_init(snddev_info *d); +void translate_bytes(u_char *table, u_char *buff, int n); +void change_bits(mixer_tab *t, u_char *regval, int dev, int chn, int newval); +int snd_conflict(int io_base); +void snd_set_blocksize(snddev_info *d); +int isa_dmastatus1(int channel); +/* + * routines in ad1848.c and sb_dsp.c which others might use + */ +int mss_detect (struct isa_device *dev); +int sb_cmd (int io_base, u_char cmd); +int sb_cmd2 (int io_base, u_char cmd, int val); +int sb_cmd3 (int io_base, u_char cmd, int val); +int sb_reset_dsp (int io_base); +void sb_setmixer (int io_base, u_int port, u_int value); +int sb_getmixer (int io_base, u_int port); + + +/* + * usage of flags in device config entry (config file) + */ + +#define DV_F_DRQ_MASK 0x00000007 /* mask for secondary drq */ +#define DV_F_DUAL_DMA 0x00000010 /* set to use secondary dma channel */ +#define DV_F_DEV_MASK 0x0000ff00 /* force device type/class */ +#define DV_F_DEV_SHIFT 8 /* force device type/class */ + +/* + * some flags are used in a device-specific manner, so that values can + * be used multiple times. + */ + +#define DV_F_TRUE_MSS 0x00010000 /* mss _with_ base regs */ + /* almost all modern cards do not have this set of registers, + * so it is better to make this the default behaviour + */ + +#endif diff --git a/sys/i386/isa/snd/soundcard.h b/sys/i386/isa/snd/soundcard.h new file mode 100644 index 000000000000..276b936a222c --- /dev/null +++ b/sys/i386/isa/snd/soundcard.h @@ -0,0 +1,1297 @@ +/* + * soundcard.h + * + * Copyright by Hannu Savolainen 1993 + * Modified for the new FreeBSD sound driver by Luigi Rizzo, 1997 + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SOUNDCARD_H +#define SOUNDCARD_H + /* + * If you make modifications to this file, please contact me before + * distributing the modified version. There is already enough + * diversity in the world. + * + * Regards, + * Hannu Savolainen + * hannu@voxware.pp.fi + * + ********************************************************************** + * PS. The Hacker's Guide to VoxWare available from + * nic.funet.fi:pub/OS/Linux/ALPHA/sound. The file is + * snd-sdk-doc-0.1.ps.gz (gzipped postscript). It contains + * some useful information about programming with VoxWare. + * (NOTE! The pub/OS/Linux/ALPHA/ directories are hidden. You have + * to cd inside them before the files are accessible.) + ********************************************************************** + */ + +#include +#ifndef _IOWR +#include +#endif /* !_IOWR */ + +/* + * The first part of this file contains the new FreeBSD sound ioctl + * interface. Tries to minimize the number of different ioctls, and + * to be reasonably general. + * + * 970821: some of the new calls have not been implemented yet. + */ + +/* + * the following three calls extend the generic file descriptor + * interface. AIONWRITE is the dual of FIONREAD, i.e. returns the max + * number of bytes for a write operation to be non-blocking. + * + * AIOGSIZE/AIOSSIZE are used to change the behaviour of the device, + * from a character device (default) to a block device. In block mode, + * (not to be confused with blocking mode) the main difference for the + * application is that select() will return only when a complete + * block can be read/written to the device, whereas in character mode + * select will return true when one byte can be exchanged. For audio + * devices, character mode makes select almost useless since one byte + * will always be ready by the next sample time (which is often only a + * handful of microseconds away). + * Use a size of 0 or 1 to return to character mode. + */ +#define AIONWRITE _IOR('A', 10, int) /* get # bytes to write */ +struct snd_size { + int play_size; + int rec_size; +}; +#define AIOGSIZE _IOR('A', 11, struct snd_size)/* read current blocksize */ +#define AIOSSIZE _IOWR('A', 11, struct snd_size) /* sets blocksize */ + +/* + * The following constants define supported audio formats. The + * encoding follows voxware conventions, i.e. 1 bit for each supported + * format. We extend it by using bit 31 (RO) to indicate full-duplex + * capability, and bit 29 (RO) to indicate that the card supports/ + * needs different formats on capture & playback channels. + * Bit 29 (RW) is used to indicate/ask stereo. + */ + +# define AFMT_QUERY 0x00000000 /* Return current fmt */ +# define AFMT_MU_LAW 0x00000001 +# define AFMT_A_LAW 0x00000002 +# define AFMT_IMA_ADPCM 0x00000004 +# define AFMT_U8 0x00000008 +# define AFMT_S16_LE 0x00000010 /* Little endian signed 16*/ +# define AFMT_S16_BE 0x00000020 /* Big endian signed 16 */ +# define AFMT_S8 0x00000040 +# define AFMT_U16_LE 0x00000080 /* Little endian U16 */ +# define AFMT_U16_BE 0x00000100 /* Big endian U16 */ +# define AFMT_MPEG 0x00000200 /* MPEG (2) audio */ + +# define AFMT_STEREO 0x10000000 /* can do/want stereo */ + +/* + * the following are really capabilities + */ +# define AFMT_WEIRD 0x20000000 /* weird hardware... */ + /* + * AFMT_WEIRD reports that the hardware might need to operate + * with different formats in the playback and capture + * channels when operating in full duplex. + * As an example, SoundBlaster16 cards only support U8 in one + * direction and S16 in the other one, and applications should + * be aware of this limitation. + */ +# define AFMT_FULLDUPLEX 0x80000000 /* can do full duplex */ + +/* + * The following structure is used to get/set format and sampling rate. + * While it would be better to have things such as stereo, bits per + * sample, endiannes, etc split in different variables, it turns out + * that formats are not that many, and not all combinations are possible. + * So we followed the Voxware approach of associating one bit to each + * format. + */ + +typedef struct _snd_chan_param { + u_long play_rate; /* sampling rate */ + u_long rec_rate; /* sampling rate */ + u_long play_format; /* everything describing the format */ + u_long rec_format; /* everything describing the format */ +} snd_chan_param; +#define AIOGFMT _IOR('f', 12, snd_chan_param) /* get format */ +#define AIOSFMT _IOWR('f', 12, snd_chan_param) /* sets format */ + +/* + * The following structure is used to get/set the mixer setting. + * Up to 32 mixers are supported, each one with up to 32 channels. + */ +typedef struct _snd_mix_param { + u_char subdev; /* which output */ + u_char line; /* which input */ + u_char left,right; /* volumes, 0..255, 0 = mute */ +} snd_mix_param ; + +/* XXX AIOGMIX, AIOSMIX not implemented yet */ +#define AIOGMIX _IOWR('A', 13, snd_mix_param) /* return mixer status */ +#define AIOSMIX _IOWR('A', 14, snd_mix_param) /* sets mixer status */ + +/* + * channel specifiers used in AIOSTOP and AIOSYNC + */ +#define AIOSYNC_PLAY 0x1 /* play chan */ +#define AIOSYNC_CAPTURE 0x2 /* capture chan */ +/* AIOSTOP stop & flush a channel, returns the residual count */ +#define AIOSTOP _IOWR ('A', 15, int) + +/* alternate method used to notify the sync condition */ +#define AIOSYNC_SIGNAL 0x100 +#define AIOSYNC_SELECT 0x200 + +/* what the 'pos' field refers to */ +#define AIOSYNC_READY 0x400 +#define AIOSYNC_FREE 0x800 + +typedef struct _snd_sync_parm { + long chan ; /* play or capture channel, plus modifier */ + long pos; +} snd_sync_parm; +#define AIOSYNC _IOWR ('A', 15, snd_sync_parm) /* misc. synchronization */ + +/* + * The following is used to return device capabilities. If the structure + * passed to the ioctl is zeroed, default values are returned for rate + * and formats, a bitmap of available mixers is returned, and values + * (inputs, different levels) for the first one are returned. + * + * If formats, mixers, inputs are instantiated, then detailed info + * are returned depending on the call. + */ +typedef struct _snd_capabilities { + u_long rate_min, rate_max; /* min-max sampling rate */ + u_long formats; + u_long bufsize; /* DMA buffer size */ + u_long mixers; /* bitmap of available mixers */ + u_long inputs; /* bitmap of available inputs (per mixer) */ + u_short left, right; /* how many levels are supported */ +} snd_capabilities; +#define AIOGCAP _IOWR('A', 15, snd_capabilities) /* get capabilities */ + +/* + * here is the old (Voxware) ioctl interface + */ + +/* + * IOCTL Commands for /dev/sequencer + */ + +#define SNDCTL_SEQ_RESET _IO ('Q', 0) +#define SNDCTL_SEQ_SYNC _IO ('Q', 1) +#define SNDCTL_SYNTH_INFO _IOWR('Q', 2, struct synth_info) +#define SNDCTL_SEQ_CTRLRATE _IOWR('Q', 3, int) /* Set/get timer res.(hz) */ +#define SNDCTL_SEQ_GETOUTCOUNT _IOR ('Q', 4, int) +#define SNDCTL_SEQ_GETINCOUNT _IOR ('Q', 5, int) +#define SNDCTL_SEQ_PERCMODE _IOW ('Q', 6, int) +#define SNDCTL_FM_LOAD_INSTR _IOW ('Q', 7, struct sbi_instrument) /* Valid for FM only */ +#define SNDCTL_SEQ_TESTMIDI _IOW ('Q', 8, int) +#define SNDCTL_SEQ_RESETSAMPLES _IOW ('Q', 9, int) +#define SNDCTL_SEQ_NRSYNTHS _IOR ('Q',10, int) +#define SNDCTL_SEQ_NRMIDIS _IOR ('Q',11, int) +#define SNDCTL_MIDI_INFO _IOWR('Q',12, struct midi_info) +#define SNDCTL_SEQ_THRESHOLD _IOW ('Q',13, int) +#define SNDCTL_SEQ_TRESHOLD SNDCTL_SEQ_THRESHOLD /* there was once a typo */ +#define SNDCTL_SYNTH_MEMAVL _IOWR('Q',14, int) /* in=dev#, out=memsize */ +#define SNDCTL_FM_4OP_ENABLE _IOW ('Q',15, int) /* in=dev# */ +#define SNDCTL_PMGR_ACCESS _IOWR('Q',16, struct patmgr_info) +#define SNDCTL_SEQ_PANIC _IO ('Q',17) +#define SNDCTL_SEQ_OUTOFBAND _IOW ('Q',18, struct seq_event_rec) + +struct seq_event_rec { + u_char arr[8]; +}; + +#define SNDCTL_TMR_TIMEBASE _IOWR('T', 1, int) +#define SNDCTL_TMR_START _IO ('T', 2) +#define SNDCTL_TMR_STOP _IO ('T', 3) +#define SNDCTL_TMR_CONTINUE _IO ('T', 4) +#define SNDCTL_TMR_TEMPO _IOWR('T', 5, int) +#define SNDCTL_TMR_SOURCE _IOWR('T', 6, int) +# define TMR_INTERNAL 0x00000001 +# define TMR_EXTERNAL 0x00000002 +# define TMR_MODE_MIDI 0x00000010 +# define TMR_MODE_FSK 0x00000020 +# define TMR_MODE_CLS 0x00000040 +# define TMR_MODE_SMPTE 0x00000080 +#define SNDCTL_TMR_METRONOME _IOW ('T', 7, int) +#define SNDCTL_TMR_SELECT _IOW ('T', 8, int) + +/* + * Endian aware patch key generation algorithm. + */ + +#if defined(_AIX) || defined(AIX) +# define _PATCHKEY(id) (0xfd00|id) +#else +# define _PATCHKEY(id) ((id<<8)|0xfd) +#endif + +/* + * Sample loading mechanism for internal synthesizers (/dev/sequencer) + * The following patch_info structure has been designed to support + * Gravis UltraSound. It tries to be universal format for uploading + * sample based patches but is propably too limited. + */ + +struct patch_info { +/* u_short key; Use GUS_PATCH here */ + short key; /* Use GUS_PATCH here */ +#define GUS_PATCH _PATCHKEY(0x04) +#define OBSOLETE_GUS_PATCH _PATCHKEY(0x02) + + short device_no; /* Synthesizer number */ + short instr_no; /* Midi pgm# */ + + u_long mode; +/* + * The least significant byte has the same format than the GUS .PAT + * files + */ +#define WAVE_16_BITS 0x01 /* bit 0 = 8 or 16 bit wave data. */ +#define WAVE_UNSIGNED 0x02 /* bit 1 = Signed - Unsigned data. */ +#define WAVE_LOOPING 0x04 /* bit 2 = looping enabled-1. */ +#define WAVE_BIDIR_LOOP 0x08 /* bit 3 = Set is bidirectional looping. */ +#define WAVE_LOOP_BACK 0x10 /* bit 4 = Set is looping backward. */ +#define WAVE_SUSTAIN_ON 0x20 /* bit 5 = Turn sustaining on. (Env. pts. 3)*/ +#define WAVE_ENVELOPES 0x40 /* bit 6 = Enable envelopes - 1 */ + /* (use the env_rate/env_offs fields). */ +/* Linux specific bits */ +#define WAVE_VIBRATO 0x00010000 /* The vibrato info is valid */ +#define WAVE_TREMOLO 0x00020000 /* The tremolo info is valid */ +#define WAVE_SCALE 0x00040000 /* The scaling info is valid */ +/* Other bits must be zeroed */ + + long len; /* Size of the wave data in bytes */ + long loop_start, loop_end; /* Byte offsets from the beginning */ + +/* + * The base_freq and base_note fields are used when computing the + * playback speed for a note. The base_note defines the tone frequency + * which is heard if the sample is played using the base_freq as the + * playback speed. + * + * The low_note and high_note fields define the minimum and maximum note + * frequencies for which this sample is valid. It is possible to define + * more than one samples for a instrument number at the same time. The + * low_note and high_note fields are used to select the most suitable one. + * + * The fields base_note, high_note and low_note should contain + * the note frequency multiplied by 1000. For example value for the + * middle A is 440*1000. + */ + + u_int base_freq; + u_long base_note; + u_long high_note; + u_long low_note; + int panning; /* -128=left, 127=right */ + int detuning; + +/* New fields introduced in version 1.99.5 */ + + /* Envelope. Enabled by mode bit WAVE_ENVELOPES */ + u_char env_rate[ 6 ]; /* GUS HW ramping rate */ + u_char env_offset[ 6 ]; /* 255 == 100% */ + + /* + * The tremolo, vibrato and scale info are not supported yet. + * Enable by setting the mode bits WAVE_TREMOLO, WAVE_VIBRATO or + * WAVE_SCALE + */ + + u_char tremolo_sweep; + u_char tremolo_rate; + u_char tremolo_depth; + + u_char vibrato_sweep; + u_char vibrato_rate; + u_char vibrato_depth; + + int scale_frequency; + u_int scale_factor; /* from 0 to 2048 or 0 to 2 */ + + int volume; + int spare[4]; + char data[1]; /* The waveform data starts here */ +}; + +struct sysex_info { + short key; /* Use GUS_PATCH here */ +#define SYSEX_PATCH _PATCHKEY(0x05) +#define MAUI_PATCH _PATCHKEY(0x06) + short device_no; /* Synthesizer number */ + long len; /* Size of the sysex data in bytes */ + u_char data[1]; /* Sysex data starts here */ +}; + +/* + * Patch management interface (/dev/sequencer, /dev/patmgr#) + * Don't use these calls if you want to maintain compatibility with + * the future versions of the driver. + */ + +#define PS_NO_PATCHES 0 /* No patch support on device */ +#define PS_MGR_NOT_OK 1 /* Plain patch support (no mgr) */ +#define PS_MGR_OK 2 /* Patch manager supported */ +#define PS_MANAGED 3 /* Patch manager running */ + +#define SNDCTL_PMGR_IFACE _IOWR('P', 1, struct patmgr_info) + +/* + * The patmgr_info is a fixed size structure which is used for two + * different purposes. The intended use is for communication between + * the application using /dev/sequencer and the patch manager daemon + * associated with a synthesizer device (ioctl(SNDCTL_PMGR_ACCESS)). + * + * This structure is also used with ioctl(SNDCTL_PGMR_IFACE) which allows + * a patch manager daemon to read and write device parameters. This + * ioctl available through /dev/sequencer also. Avoid using it since it's + * extremely hardware dependent. In addition access trough /dev/sequencer + * may confuse the patch manager daemon. + */ + +struct patmgr_info { /* Note! size must be < 4k since kmalloc() is used */ + u_long key; /* Don't worry. Reserved for communication + between the patch manager and the driver. */ +#define PM_K_EVENT 1 /* Event from the /dev/sequencer driver */ +#define PM_K_COMMAND 2 /* Request from a application */ +#define PM_K_RESPONSE 3 /* From patmgr to application */ +#define PM_ERROR 4 /* Error returned by the patmgr */ + int device; + int command; + +/* + * Commands 0x000 to 0xfff reserved for patch manager programs + */ +#define PM_GET_DEVTYPE 1 /* Returns type of the patch mgr interface of dev */ +#define PMTYPE_FM2 1 /* 2 OP fm */ +#define PMTYPE_FM4 2 /* Mixed 4 or 2 op FM (OPL-3) */ +#define PMTYPE_WAVE 3 /* Wave table synthesizer (GUS) */ +#define PM_GET_NRPGM 2 /* Returns max # of midi programs in parm1 */ +#define PM_GET_PGMMAP 3 /* Returns map of loaded midi programs in data8 */ +#define PM_GET_PGM_PATCHES 4 /* Return list of patches of a program (parm1) */ +#define PM_GET_PATCH 5 /* Return patch header of patch parm1 */ +#define PM_SET_PATCH 6 /* Set patch header of patch parm1 */ +#define PM_READ_PATCH 7 /* Read patch (wave) data */ +#define PM_WRITE_PATCH 8 /* Write patch (wave) data */ + +/* + * Commands 0x1000 to 0xffff are for communication between the patch manager + * and the client + */ +#define _PM_LOAD_PATCH 0x100 + +/* + * Commands above 0xffff reserved for device specific use + */ + + long parm1; + long parm2; + long parm3; + + union { + u_char data8[4000]; + u_short data16[2000]; + u_long data32[1000]; + struct patch_info patch; + } data; +}; + +/* + * When a patch manager daemon is present, it will be informed by the + * driver when something important happens. For example when the + * /dev/sequencer is opened or closed. A record with key == PM_K_EVENT is + * returned. The command field contains the event type: + */ +#define PM_E_OPENED 1 /* /dev/sequencer opened */ +#define PM_E_CLOSED 2 /* /dev/sequencer closed */ +#define PM_E_PATCH_RESET 3 /* SNDCTL_RESETSAMPLES called */ +#define PM_E_PATCH_LOADED 4 /* A patch has been loaded by appl */ + +/* + * /dev/sequencer input events. + * + * The data written to the /dev/sequencer is a stream of events. Events + * are records of 4 or 8 bytes. The first byte defines the size. + * Any number of events can be written with a write call. There + * is a set of macros for sending these events. Use these macros if you + * want to maximize portability of your program. + * + * Events SEQ_WAIT, SEQ_MIDIPUTC and SEQ_ECHO. Are also input events. + * (All input events are currently 4 bytes long. Be prepared to support + * 8 byte events also. If you receive any event having first byte >= 128, + * it's a 8 byte event. + * + * The events are documented at the end of this file. + * + * Normal events (4 bytes) + * There is also a 8 byte version of most of the 4 byte events. The + * 8 byte one is recommended. + */ +#define SEQ_NOTEOFF 0 +#define SEQ_FMNOTEOFF SEQ_NOTEOFF /* Just old name */ +#define SEQ_NOTEON 1 +#define SEQ_FMNOTEON SEQ_NOTEON +#define SEQ_WAIT TMR_WAIT_ABS +#define SEQ_PGMCHANGE 3 +#define SEQ_FMPGMCHANGE SEQ_PGMCHANGE +#define SEQ_SYNCTIMER TMR_START +#define SEQ_MIDIPUTC 5 +#define SEQ_DRUMON 6 /*** OBSOLETE ***/ +#define SEQ_DRUMOFF 7 /*** OBSOLETE ***/ +#define SEQ_ECHO TMR_ECHO /* For synching programs with output */ +#define SEQ_AFTERTOUCH 9 +#define SEQ_CONTROLLER 10 + +/* + * Midi controller numbers + * + * Controllers 0 to 31 (0x00 to 0x1f) and 32 to 63 (0x20 to 0x3f) + * are continuous controllers. + * In the MIDI 1.0 these controllers are sent using two messages. + * Controller numbers 0 to 31 are used to send the MSB and the + * controller numbers 32 to 63 are for the LSB. Note that just 7 bits + * are used in MIDI bytes. + */ + +#define CTL_BANK_SELECT 0x00 +#define CTL_MODWHEEL 0x01 +#define CTL_BREATH 0x02 +/* undefined 0x03 */ +#define CTL_FOOT 0x04 +#define CTL_PORTAMENTO_TIME 0x05 +#define CTL_DATA_ENTRY 0x06 +#define CTL_MAIN_VOLUME 0x07 +#define CTL_BALANCE 0x08 +/* undefined 0x09 */ +#define CTL_PAN 0x0a +#define CTL_EXPRESSION 0x0b +/* undefined 0x0c - 0x0f */ +#define CTL_GENERAL_PURPOSE1 0x10 +#define CTL_GENERAL_PURPOSE2 0x11 +#define CTL_GENERAL_PURPOSE3 0x12 +#define CTL_GENERAL_PURPOSE4 0x13 +/* undefined 0x14 - 0x1f */ + +/* undefined 0x20 */ + +/* + * The controller numbers 0x21 to 0x3f are reserved for the + * least significant bytes of the controllers 0x00 to 0x1f. + * These controllers are not recognised by the driver. + * + * Controllers 64 to 69 (0x40 to 0x45) are on/off switches. + * 0=OFF and 127=ON (intermediate values are possible) + */ +#define CTL_DAMPER_PEDAL 0x40 +#define CTL_SUSTAIN CTL_DAMPER_PEDAL /* Alias */ +#define CTL_HOLD CTL_DAMPER_PEDAL /* Alias */ +#define CTL_PORTAMENTO 0x41 +#define CTL_SOSTENUTO 0x42 +#define CTL_SOFT_PEDAL 0x43 +/* undefined 0x44 */ +#define CTL_HOLD2 0x45 +/* undefined 0x46 - 0x4f */ + +#define CTL_GENERAL_PURPOSE5 0x50 +#define CTL_GENERAL_PURPOSE6 0x51 +#define CTL_GENERAL_PURPOSE7 0x52 +#define CTL_GENERAL_PURPOSE8 0x53 +/* undefined 0x54 - 0x5a */ +#define CTL_EXT_EFF_DEPTH 0x5b +#define CTL_TREMOLO_DEPTH 0x5c +#define CTL_CHORUS_DEPTH 0x5d +#define CTL_DETUNE_DEPTH 0x5e +#define CTL_CELESTE_DEPTH CTL_DETUNE_DEPTH /* Alias for the above one */ +#define CTL_PHASER_DEPTH 0x5f +#define CTL_DATA_INCREMENT 0x60 +#define CTL_DATA_DECREMENT 0x61 +#define CTL_NONREG_PARM_NUM_LSB 0x62 +#define CTL_NONREG_PARM_NUM_MSB 0x63 +#define CTL_REGIST_PARM_NUM_LSB 0x64 +#define CTL_REGIST_PARM_NUM_MSB 0x65 +/* undefined 0x66 - 0x78 */ +/* reserved 0x79 - 0x7f */ + +/* Pseudo controllers (not midi compatible) */ +#define CTRL_PITCH_BENDER 255 +#define CTRL_PITCH_BENDER_RANGE 254 +#define CTRL_EXPRESSION 253 /* Obsolete */ +#define CTRL_MAIN_VOLUME 252 /* Obsolete */ + +#define SEQ_BALANCE 11 +#define SEQ_VOLMODE 12 + +/* + * Volume mode decides how volumes are used + */ + +#define VOL_METHOD_ADAGIO 1 +#define VOL_METHOD_LINEAR 2 + +/* + * Note! SEQ_WAIT, SEQ_MIDIPUTC and SEQ_ECHO are used also as + * input events. + */ + +/* + * Event codes 0xf0 to 0xfc are reserved for future extensions. + */ + +#define SEQ_FULLSIZE 0xfd /* Long events */ +/* + * SEQ_FULLSIZE events are used for loading patches/samples to the + * synthesizer devices. These events are passed directly to the driver + * of the associated synthesizer device. There is no limit to the size + * of the extended events. These events are not queued but executed + * immediately when the write() is called (execution can take several + * seconds of time). + * + * When a SEQ_FULLSIZE message is written to the device, it must + * be written using exactly one write() call. Other events cannot + * be mixed to the same write. + * + * For FM synths (YM3812/OPL3) use struct sbi_instrument and write + * it to the /dev/sequencer. Don't write other data together with + * the instrument structure Set the key field of the structure to + * FM_PATCH. The device field is used to route the patch to the + * corresponding device. + * + * For Gravis UltraSound use struct patch_info. Initialize the key field + * to GUS_PATCH. + */ +#define SEQ_PRIVATE 0xfe /* Low level HW dependent events (8 bytes) */ +#define SEQ_EXTENDED 0xff /* Extended events (8 bytes) OBSOLETE */ + +/* + * Record for FM patches + */ + +typedef u_char sbi_instr_data[32]; + +struct sbi_instrument { + u_short key; /* FM_PATCH or OPL3_PATCH */ +#define FM_PATCH _PATCHKEY(0x01) +#define OPL3_PATCH _PATCHKEY(0x03) + short device; /* Synth# (0-4) */ + int channel; /* Program# to be initialized */ + sbi_instr_data operators; /* Reg. settings for operator cells + * (.SBI format) */ +}; + +struct synth_info { /* Read only */ + char name[30]; + int device; /* 0-N. INITIALIZE BEFORE CALLING */ + int synth_type; +#define SYNTH_TYPE_FM 0 +#define SYNTH_TYPE_SAMPLE 1 +#define SYNTH_TYPE_MIDI 2 /* Midi interface */ + + int synth_subtype; +#define FM_TYPE_ADLIB 0x00 +#define FM_TYPE_OPL3 0x01 + +#define SAMPLE_TYPE_GUS 0x10 + + int perc_mode; /* No longer supported */ + int nr_voices; + int nr_drums; /* Obsolete field */ + int instr_bank_size; + u_long capabilities; +#define SYNTH_CAP_PERCMODE 0x00000001 /* No longer used */ +#define SYNTH_CAP_OPL3 0x00000002 /* Set if OPL3 supported */ +#define SYNTH_CAP_INPUT 0x00000004 /* Input (MIDI) device */ + int dummies[19]; /* Reserve space */ +}; + +struct sound_timer_info { + char name[32]; + int caps; +}; + +#define MIDI_CAP_MPU401 1 /* MPU-401 intelligent mode */ + +struct midi_info { + char name[30]; + int device; /* 0-N. INITIALIZE BEFORE CALLING */ + u_long capabilities; /* To be defined later */ + int dev_type; + int dummies[18]; /* Reserve space */ +}; + +/* + * ioctl commands for the /dev/midi## + */ +typedef struct { + u_char cmd; + char nr_args, nr_returns; + u_char data[30]; +} mpu_command_rec; + +#define SNDCTL_MIDI_PRETIME _IOWR('m', 0, int) +#define SNDCTL_MIDI_MPUMODE _IOWR('m', 1, int) +#define SNDCTL_MIDI_MPUCMD _IOWR('m', 2, mpu_command_rec) + +/* + * IOCTL commands for /dev/dsp and /dev/audio + */ + +#define SNDCTL_DSP_RESET _IO ('P', 0) +#define SNDCTL_DSP_SYNC _IO ('P', 1) +#define SNDCTL_DSP_SPEED _IOWR('P', 2, int) +#define SNDCTL_DSP_STEREO _IOWR('P', 3, int) +#define SNDCTL_DSP_GETBLKSIZE _IOR('P', 4, int) +#define SNDCTL_DSP_SETBLKSIZE _IOW('P', 4, int) +#define SNDCTL_DSP_SETFMT _IOWR('P',5, int) /* Selects ONE fmt*/ + +/* + * SOUND_PCM_WRITE_CHANNELS is not that different + * from SNDCTL_DSP_STEREO + */ +#define SOUND_PCM_WRITE_CHANNELS _IOWR('P', 6, int) +#define SOUND_PCM_WRITE_FILTER _IOWR('P', 7, int) +#define SNDCTL_DSP_POST _IO ('P', 8) + +/* + * SNDCTL_DSP_SETBLKSIZE and the following two calls mostly do + * the same thing, i.e. set the block size used in DMA transfers. + */ +#define SNDCTL_DSP_SUBDIVIDE _IOWR('P', 9, int) +#define SNDCTL_DSP_SETFRAGMENT _IOWR('P',10, int) + + +#define SNDCTL_DSP_GETFMTS _IOR ('P',11, int) /* Returns a mask */ +/* + * Buffer status queries. + */ +typedef struct audio_buf_info { + int fragments; /* # of avail. frags (partly used ones not counted) */ + int fragstotal; /* Total # of fragments allocated */ + int fragsize; /* Size of a fragment in bytes */ + + int bytes; /* Avail. space in bytes (includes partly used fragments) */ + /* Note! 'bytes' could be more than fragments*fragsize */ +} audio_buf_info; + +#define SNDCTL_DSP_GETOSPACE _IOR ('P',12, audio_buf_info) +#define SNDCTL_DSP_GETISPACE _IOR ('P',13, audio_buf_info) + +/* + * SNDCTL_DSP_NONBLOCK is the same (but less powerful, since the + * action cannot be undone) of FIONBIO. The same can be achieved + * by opening the device with O_NDELAY + */ +#define SNDCTL_DSP_NONBLOCK _IO ('P',14) + +#define SNDCTL_DSP_GETCAPS _IOR ('P',15, int) +#define DSP_CAP_REVISION 0x000000ff /* revision level (0 to 255) */ +#define DSP_CAP_DUPLEX 0x00000100 /* Full duplex record/playback */ +#define DSP_CAP_REALTIME 0x00000200 /* Real time capability */ +#define DSP_CAP_BATCH 0x00000400 + /* + * Device has some kind of internal buffers which may + * cause some delays and decrease precision of timing + */ +#define DSP_CAP_COPROC 0x00000800 + /* Has a coprocessor, sometimes it's a DSP but usually not */ +#define DSP_CAP_TRIGGER 0x00001000 /* Supports SETTRIGGER */ + +/* + * What do these function do ? + */ +#define SNDCTL_DSP_GETTRIGGER _IOR ('P',16, int) +#define SNDCTL_DSP_SETTRIGGER _IOW ('P',16, int) +#define PCM_ENABLE_INPUT 0x00000001 +#define PCM_ENABLE_OUTPUT 0x00000002 + +typedef struct count_info { + int bytes; /* Total # of bytes processed */ + int blocks; /* # of fragment transitions since last time */ + int ptr; /* Current DMA pointer value */ +} count_info; + +/* + * GETIPTR and GETISPACE are not that different... same for out. + */ +#define SNDCTL_DSP_GETIPTR _IOR ('P',17, count_info) +#define SNDCTL_DSP_GETOPTR _IOR ('P',18, count_info) + +typedef struct buffmem_desc { + caddr_t buffer; + int size; +} buffmem_desc; + +#define SNDCTL_DSP_MAPINBUF _IOR ('P', 19, buffmem_desc) +#define SNDCTL_DSP_MAPOUTBUF _IOR ('P', 20, buffmem_desc) +#define SNDCTL_DSP_SETSYNCRO _IO ('P', 21) + +/* + * I guess these are the readonly version of the same + * functions that exist above as SNDCTL_DSP_... + */ +#define SOUND_PCM_READ_RATE _IOR ('P', 2, int) +#define SOUND_PCM_READ_CHANNELS _IOR ('P', 6, int) +#define SOUND_PCM_READ_BITS _IOR ('P', 5, int) +#define SOUND_PCM_READ_FILTER _IOR ('P', 7, int) + +/* + * ioctl calls to be used in communication with coprocessors and + * DSP chips. + */ + +typedef struct copr_buffer { + int command; /* Set to 0 if not used */ + int flags; +#define CPF_NONE 0x0000 +#define CPF_FIRST 0x0001 /* First block */ +#define CPF_LAST 0x0002 /* Last block */ + int len; + int offs; /* If required by the device (0 if not used) */ + + u_char data[4000]; /* NOTE! 4000 is not 4k */ +} copr_buffer; + +typedef struct copr_debug_buf { + int command; /* Used internally. Set to 0 */ + int parm1; + int parm2; + int flags; + int len; /* Length of data in bytes */ +} copr_debug_buf; + +typedef struct copr_msg { + int len; + u_char data[4000]; +} copr_msg; + +#define SNDCTL_COPR_RESET _IO ('C', 0) +#define SNDCTL_COPR_LOAD _IOWR('C', 1, copr_buffer) +#define SNDCTL_COPR_RDATA _IOWR('C', 2, copr_debug_buf) +#define SNDCTL_COPR_RCODE _IOWR('C', 3, copr_debug_buf) +#define SNDCTL_COPR_WDATA _IOW ('C', 4, copr_debug_buf) +#define SNDCTL_COPR_WCODE _IOW ('C', 5, copr_debug_buf) +#define SNDCTL_COPR_RUN _IOWR('C', 6, copr_debug_buf) +#define SNDCTL_COPR_HALT _IOWR('C', 7, copr_debug_buf) +#define SNDCTL_COPR_SENDMSG _IOW ('C', 8, copr_msg) +#define SNDCTL_COPR_RCVMSG _IOR ('C', 9, copr_msg) + +/* + * IOCTL commands for /dev/mixer + */ + +/* + * Mixer devices + * + * There can be up to 20 different analog mixer channels. The + * SOUND_MIXER_NRDEVICES gives the currently supported maximum. + * The SOUND_MIXER_READ_DEVMASK returns a bitmask which tells + * the devices supported by the particular mixer. + */ + +#define SOUND_MIXER_NRDEVICES 17 +#define SOUND_MIXER_VOLUME 0 +#define SOUND_MIXER_BASS 1 +#define SOUND_MIXER_TREBLE 2 +#define SOUND_MIXER_SYNTH 3 +#define SOUND_MIXER_PCM 4 +#define SOUND_MIXER_SPEAKER 5 +#define SOUND_MIXER_LINE 6 +#define SOUND_MIXER_MIC 7 +#define SOUND_MIXER_CD 8 +#define SOUND_MIXER_IMIX 9 /* Recording monitor */ +#define SOUND_MIXER_ALTPCM 10 +#define SOUND_MIXER_RECLEV 11 /* Recording level */ +#define SOUND_MIXER_IGAIN 12 /* Input gain */ +#define SOUND_MIXER_OGAIN 13 /* Output gain */ +/* + * The AD1848 codec and compatibles have three line level inputs + * (line, aux1 and aux2). Since each card manufacturer have assigned + * different meanings to these inputs, it's inpractical to assign + * specific meanings (line, cd, synth etc.) to them. + */ +#define SOUND_MIXER_LINE1 14 /* Input source 1 (aux1) */ +#define SOUND_MIXER_LINE2 15 /* Input source 2 (aux2) */ +#define SOUND_MIXER_LINE3 16 /* Input source 3 (line) */ + +/* + * Some on/off settings (SOUND_SPECIAL_MIN - SOUND_SPECIAL_MAX) + * Not counted to SOUND_MIXER_NRDEVICES, but use the same number space + */ +#define SOUND_ONOFF_MIN 28 +#define SOUND_ONOFF_MAX 30 +#define SOUND_MIXER_MUTE 28 /* 0 or 1 */ +#define SOUND_MIXER_ENHANCE 29 /* Enhanced stereo (0, 40, 60 or 80) */ +#define SOUND_MIXER_LOUD 30 /* 0 or 1 */ + +/* Note! Number 31 cannot be used since the sign bit is reserved */ + +#define SOUND_DEVICE_LABELS { \ + "Vol ", "Bass ", "Trebl", "Synth", "Pcm ", "Spkr ", "Line ", \ + "Mic ", "CD ", "Mix ", "Pcm2 ", "Rec ", "IGain", "OGain", \ + "Line1", "Line2", "Line3"} + +#define SOUND_DEVICE_NAMES { \ + "vol", "bass", "treble", "synth", "pcm", "speaker", "line", \ + "mic", "cd", "mix", "pcm2", "rec", "igain", "ogain", \ + "line1", "line2", "line3"} + +/* Device bitmask identifiers */ + +#define SOUND_MIXER_RECSRC 0xff /* 1 bit per recording source */ +#define SOUND_MIXER_DEVMASK 0xfe /* 1 bit per supported device */ +#define SOUND_MIXER_RECMASK 0xfd /* 1 bit per supp. recording source */ +#define SOUND_MIXER_CAPS 0xfc +#define SOUND_CAP_EXCL_INPUT 0x00000001 /* Only 1 rec. src at a time */ +#define SOUND_MIXER_STEREODEVS 0xfb /* Mixer channels supporting stereo */ + +/* Device mask bits */ + +#define SOUND_MASK_VOLUME (1 << SOUND_MIXER_VOLUME) +#define SOUND_MASK_BASS (1 << SOUND_MIXER_BASS) +#define SOUND_MASK_TREBLE (1 << SOUND_MIXER_TREBLE) +#define SOUND_MASK_SYNTH (1 << SOUND_MIXER_SYNTH) +#define SOUND_MASK_PCM (1 << SOUND_MIXER_PCM) +#define SOUND_MASK_SPEAKER (1 << SOUND_MIXER_SPEAKER) +#define SOUND_MASK_LINE (1 << SOUND_MIXER_LINE) +#define SOUND_MASK_MIC (1 << SOUND_MIXER_MIC) +#define SOUND_MASK_CD (1 << SOUND_MIXER_CD) +#define SOUND_MASK_IMIX (1 << SOUND_MIXER_IMIX) +#define SOUND_MASK_ALTPCM (1 << SOUND_MIXER_ALTPCM) +#define SOUND_MASK_RECLEV (1 << SOUND_MIXER_RECLEV) +#define SOUND_MASK_IGAIN (1 << SOUND_MIXER_IGAIN) +#define SOUND_MASK_OGAIN (1 << SOUND_MIXER_OGAIN) +#define SOUND_MASK_LINE1 (1 << SOUND_MIXER_LINE1) +#define SOUND_MASK_LINE2 (1 << SOUND_MIXER_LINE2) +#define SOUND_MASK_LINE3 (1 << SOUND_MIXER_LINE3) + +#define SOUND_MASK_MUTE (1 << SOUND_MIXER_MUTE) +#define SOUND_MASK_ENHANCE (1 << SOUND_MIXER_ENHANCE) +#define SOUND_MASK_LOUD (1 << SOUND_MIXER_LOUD) + +#define MIXER_READ(dev) _IOR('M', dev, int) +#define SOUND_MIXER_READ_VOLUME MIXER_READ(SOUND_MIXER_VOLUME) +#define SOUND_MIXER_READ_BASS MIXER_READ(SOUND_MIXER_BASS) +#define SOUND_MIXER_READ_TREBLE MIXER_READ(SOUND_MIXER_TREBLE) +#define SOUND_MIXER_READ_SYNTH MIXER_READ(SOUND_MIXER_SYNTH) +#define SOUND_MIXER_READ_PCM MIXER_READ(SOUND_MIXER_PCM) +#define SOUND_MIXER_READ_SPEAKER MIXER_READ(SOUND_MIXER_SPEAKER) +#define SOUND_MIXER_READ_LINE MIXER_READ(SOUND_MIXER_LINE) +#define SOUND_MIXER_READ_MIC MIXER_READ(SOUND_MIXER_MIC) +#define SOUND_MIXER_READ_CD MIXER_READ(SOUND_MIXER_CD) +#define SOUND_MIXER_READ_IMIX MIXER_READ(SOUND_MIXER_IMIX) +#define SOUND_MIXER_READ_ALTPCM MIXER_READ(SOUND_MIXER_ALTPCM) +#define SOUND_MIXER_READ_RECLEV MIXER_READ(SOUND_MIXER_RECLEV) +#define SOUND_MIXER_READ_IGAIN MIXER_READ(SOUND_MIXER_IGAIN) +#define SOUND_MIXER_READ_OGAIN MIXER_READ(SOUND_MIXER_OGAIN) +#define SOUND_MIXER_READ_LINE1 MIXER_READ(SOUND_MIXER_LINE1) +#define SOUND_MIXER_READ_LINE2 MIXER_READ(SOUND_MIXER_LINE2) +#define SOUND_MIXER_READ_LINE3 MIXER_READ(SOUND_MIXER_LINE3) +#define SOUND_MIXER_READ_MUTE MIXER_READ(SOUND_MIXER_MUTE) +#define SOUND_MIXER_READ_ENHANCE MIXER_READ(SOUND_MIXER_ENHANCE) +#define SOUND_MIXER_READ_LOUD MIXER_READ(SOUND_MIXER_LOUD) + +#define SOUND_MIXER_READ_RECSRC MIXER_READ(SOUND_MIXER_RECSRC) +#define SOUND_MIXER_READ_DEVMASK MIXER_READ(SOUND_MIXER_DEVMASK) +#define SOUND_MIXER_READ_RECMASK MIXER_READ(SOUND_MIXER_RECMASK) +#define SOUND_MIXER_READ_STEREODEVS MIXER_READ(SOUND_MIXER_STEREODEVS) +#define SOUND_MIXER_READ_CAPS MIXER_READ(SOUND_MIXER_CAPS) + +#define MIXER_WRITE(dev) _IOWR('M', dev, int) +#define SOUND_MIXER_WRITE_VOLUME MIXER_WRITE(SOUND_MIXER_VOLUME) +#define SOUND_MIXER_WRITE_BASS MIXER_WRITE(SOUND_MIXER_BASS) +#define SOUND_MIXER_WRITE_TREBLE MIXER_WRITE(SOUND_MIXER_TREBLE) +#define SOUND_MIXER_WRITE_SYNTH MIXER_WRITE(SOUND_MIXER_SYNTH) +#define SOUND_MIXER_WRITE_PCM MIXER_WRITE(SOUND_MIXER_PCM) +#define SOUND_MIXER_WRITE_SPEAKER MIXER_WRITE(SOUND_MIXER_SPEAKER) +#define SOUND_MIXER_WRITE_LINE MIXER_WRITE(SOUND_MIXER_LINE) +#define SOUND_MIXER_WRITE_MIC MIXER_WRITE(SOUND_MIXER_MIC) +#define SOUND_MIXER_WRITE_CD MIXER_WRITE(SOUND_MIXER_CD) +#define SOUND_MIXER_WRITE_IMIX MIXER_WRITE(SOUND_MIXER_IMIX) +#define SOUND_MIXER_WRITE_ALTPCM MIXER_WRITE(SOUND_MIXER_ALTPCM) +#define SOUND_MIXER_WRITE_RECLEV MIXER_WRITE(SOUND_MIXER_RECLEV) +#define SOUND_MIXER_WRITE_IGAIN MIXER_WRITE(SOUND_MIXER_IGAIN) +#define SOUND_MIXER_WRITE_OGAIN MIXER_WRITE(SOUND_MIXER_OGAIN) +#define SOUND_MIXER_WRITE_LINE1 MIXER_WRITE(SOUND_MIXER_LINE1) +#define SOUND_MIXER_WRITE_LINE2 MIXER_WRITE(SOUND_MIXER_LINE2) +#define SOUND_MIXER_WRITE_LINE3 MIXER_WRITE(SOUND_MIXER_LINE3) +#define SOUND_MIXER_WRITE_MUTE MIXER_WRITE(SOUND_MIXER_MUTE) +#define SOUND_MIXER_WRITE_ENHANCE MIXER_WRITE(SOUND_MIXER_ENHANCE) +#define SOUND_MIXER_WRITE_LOUD MIXER_WRITE(SOUND_MIXER_LOUD) + +#define SOUND_MIXER_WRITE_RECSRC MIXER_WRITE(SOUND_MIXER_RECSRC) + +#define LEFT_CHN 0 +#define RIGHT_CHN 1 + +/* + * Level 2 event types for /dev/sequencer + */ + +/* + * The 4 most significant bits of byte 0 specify the class of + * the event: + * + * 0x8X = system level events, + * 0x9X = device/port specific events, event[1] = device/port, + * The last 4 bits give the subtype: + * 0x02 = Channel event (event[3] = chn). + * 0x01 = note event (event[4] = note). + * (0x01 is not used alone but always with bit 0x02). + * event[2] = MIDI message code (0x80=note off etc.) + * + */ + +#define EV_SEQ_LOCAL 0x80 +#define EV_TIMING 0x81 +#define EV_CHN_COMMON 0x92 +#define EV_CHN_VOICE 0x93 +#define EV_SYSEX 0x94 +/* + * Event types 200 to 220 are reserved for application use. + * These numbers will not be used by the driver. + */ + +/* + * Events for event type EV_CHN_VOICE + */ + +#define MIDI_NOTEOFF 0x80 +#define MIDI_NOTEON 0x90 +#define MIDI_KEY_PRESSURE 0xA0 + +/* + * Events for event type EV_CHN_COMMON + */ + +#define MIDI_CTL_CHANGE 0xB0 +#define MIDI_PGM_CHANGE 0xC0 +#define MIDI_CHN_PRESSURE 0xD0 +#define MIDI_PITCH_BEND 0xE0 + +#define MIDI_SYSTEM_PREFIX 0xF0 + +/* + * Timer event types + */ +#define TMR_WAIT_REL 1 /* Time relative to the prev time */ +#define TMR_WAIT_ABS 2 /* Absolute time since TMR_START */ +#define TMR_STOP 3 +#define TMR_START 4 +#define TMR_CONTINUE 5 +#define TMR_TEMPO 6 +#define TMR_ECHO 8 +#define TMR_CLOCK 9 /* MIDI clock */ +#define TMR_SPP 10 /* Song position pointer */ +#define TMR_TIMESIG 11 /* Time signature */ + +/* + * Local event types + */ +#define LOCL_STARTAUDIO 1 + +#if (!defined(__KERNEL__) && !defined(KERNEL) && !defined(INKERNEL) && !defined(_KERNEL)) || defined(USE_SEQ_MACROS) +/* + * Some convenience macros to simplify programming of the + * /dev/sequencer interface + * + * These macros define the API which should be used when possible. + */ + +#ifndef USE_SIMPLE_MACROS +void seqbuf_dump(void); /* This function must be provided by programs */ + +/* Sample seqbuf_dump() implementation: + * + * SEQ_DEFINEBUF (2048); -- Defines a buffer for 2048 bytes + * + * int seqfd; -- The file descriptor for /dev/sequencer. + * + * void + * seqbuf_dump () + * { + * if (_seqbufptr) + * if (write (seqfd, _seqbuf, _seqbufptr) == -1) + * { + * perror ("write /dev/sequencer"); + * exit (-1); + * } + * _seqbufptr = 0; + * } + */ + +#define SEQ_DEFINEBUF(len) \ + u_char _seqbuf[len]; int _seqbuflen = len;int _seqbufptr = 0 +#define SEQ_USE_EXTBUF() \ + extern u_char _seqbuf[]; \ + extern int _seqbuflen;extern int _seqbufptr +#define SEQ_DECLAREBUF() SEQ_USE_EXTBUF() +#define SEQ_PM_DEFINES struct patmgr_info _pm_info +#define _SEQ_NEEDBUF(len) \ + if ((_seqbufptr+(len)) > _seqbuflen) \ + seqbuf_dump() +#define _SEQ_ADVBUF(len) _seqbufptr += len +#define SEQ_DUMPBUF seqbuf_dump +#else +/* + * This variation of the sequencer macros is used just to format one event + * using fixed buffer. + * + * The program using the macro library must define the following macros before + * using this library. + * + * #define _seqbuf name of the buffer (u_char[]) + * #define _SEQ_ADVBUF(len) If the applic needs to know the exact + * size of the event, this macro can be used. + * Otherwise this must be defined as empty. + * #define _seqbufptr Define the name of index variable or 0 if + * not required. + */ +#define _SEQ_NEEDBUF(len) /* empty */ +#endif + +#define PM_LOAD_PATCH(dev, bank, pgm) \ + (SEQ_DUMPBUF(), _pm_info.command = _PM_LOAD_PATCH, \ + _pm_info.device=dev, _pm_info.data.data8[0]=pgm, \ + _pm_info.parm1 = bank, _pm_info.parm2 = 1, \ + ioctl(seqfd, SNDCTL_PMGR_ACCESS, &_pm_info)) +#define PM_LOAD_PATCHES(dev, bank, pgm) \ + (SEQ_DUMPBUF(), _pm_info.command = _PM_LOAD_PATCH, \ + _pm_info.device=dev, bcopy( pgm, _pm_info.data.data8, 128), \ + _pm_info.parm1 = bank, _pm_info.parm2 = 128, \ + ioctl(seqfd, SNDCTL_PMGR_ACCESS, &_pm_info)) + +#define SEQ_VOLUME_MODE(dev, mode) { \ + _SEQ_NEEDBUF(8);\ + _seqbuf[_seqbufptr] = SEQ_EXTENDED;\ + _seqbuf[_seqbufptr+1] = SEQ_VOLMODE;\ + _seqbuf[_seqbufptr+2] = (dev);\ + _seqbuf[_seqbufptr+3] = (mode);\ + _seqbuf[_seqbufptr+4] = 0;\ + _seqbuf[_seqbufptr+5] = 0;\ + _seqbuf[_seqbufptr+6] = 0;\ + _seqbuf[_seqbufptr+7] = 0;\ + _SEQ_ADVBUF(8);} + +/* + * Midi voice messages + */ + +#define _CHN_VOICE(dev, event, chn, note, parm) { \ + _SEQ_NEEDBUF(8);\ + _seqbuf[_seqbufptr] = EV_CHN_VOICE;\ + _seqbuf[_seqbufptr+1] = (dev);\ + _seqbuf[_seqbufptr+2] = (event);\ + _seqbuf[_seqbufptr+3] = (chn);\ + _seqbuf[_seqbufptr+4] = (note);\ + _seqbuf[_seqbufptr+5] = (parm);\ + _seqbuf[_seqbufptr+6] = (0);\ + _seqbuf[_seqbufptr+7] = 0;\ + _SEQ_ADVBUF(8);} + +#define SEQ_START_NOTE(dev, chn, note, vol) \ + _CHN_VOICE(dev, MIDI_NOTEON, chn, note, vol) + +#define SEQ_STOP_NOTE(dev, chn, note, vol) \ + _CHN_VOICE(dev, MIDI_NOTEOFF, chn, note, vol) + +#define SEQ_KEY_PRESSURE(dev, chn, note, pressure) \ + _CHN_VOICE(dev, MIDI_KEY_PRESSURE, chn, note, pressure) + +/* + * Midi channel messages + */ + +#define _CHN_COMMON(dev, event, chn, p1, p2, w14) { \ + _SEQ_NEEDBUF(8);\ + _seqbuf[_seqbufptr] = EV_CHN_COMMON;\ + _seqbuf[_seqbufptr+1] = (dev);\ + _seqbuf[_seqbufptr+2] = (event);\ + _seqbuf[_seqbufptr+3] = (chn);\ + _seqbuf[_seqbufptr+4] = (p1);\ + _seqbuf[_seqbufptr+5] = (p2);\ + *(short *)&_seqbuf[_seqbufptr+6] = (w14);\ + _SEQ_ADVBUF(8);} +/* + * SEQ_SYSEX permits sending of sysex messages. (It may look that it permits + * sending any MIDI bytes but it's absolutely not possible. Trying to do + * so _will_ cause problems with MPU401 intelligent mode). + * + * Sysex messages are sent in blocks of 1 to 6 bytes. Longer messages must be + * sent by calling SEQ_SYSEX() several times (there must be no other events + * between them). First sysex fragment must have 0xf0 in the first byte + * and the last byte (buf[len-1] of the last fragment must be 0xf7. No byte + * between these sysex start and end markers cannot be larger than 0x7f. Also + * lengths of each fragments (except the last one) must be 6. + * + * Breaking the above rules may work with some MIDI ports but is likely to + * cause fatal problems with some other devices (such as MPU401). + */ +#define SEQ_SYSEX(dev, buf, len) { \ + int i, l=(len); if (l>6)l=6;\ + _SEQ_NEEDBUF(8);\ + _seqbuf[_seqbufptr] = EV_SYSEX;\ + for(i=0;i