This is a new ALSA driver driver for Rockwell WaveArtist RWA010 chips found
on some (rare) ISA sound cards, such as DCS Multimedia S717.
I wasn't able to get the old OSS WaveArtist driver to work with my card but it
was a great source of information about the chip (as the full datasheet is not
available - only a brief one and a design guide).
However, the OSS driver only supports few of the mixer registers so I had to
install the card in Windows and dump mixer registers while changing the mixer
settings. Then tried what the rest of the registers do and the result is a
fully working mixer which even supports more controls than the Windows driver.
Someone with a NetWinder can add support for it to this driver and then remove
the old OSS one.
Signed-off-by: Ondrej Zary <linux(a)rainbow-software.org>
---
include/sound/mpu401.h | 1 +
sound/isa/Kconfig | 11 +
sound/isa/Makefile | 2 +
sound/isa/waveartist.c | 1399 ++++++++++++++++++++++++++++++++++++++++++++++++
sound/isa/waveartist.h | 74 +++
5 files changed, 1487 insertions(+)
create mode 100644 sound/isa/waveartist.c
create mode 100644 sound/isa/waveartist.h
diff --git a/include/sound/mpu401.h b/include/sound/mpu401.h
index e942096..8fceeba 100644
--- a/include/sound/mpu401.h
+++ b/include/sound/mpu401.h
@@ -44,6 +44,7 @@
#define MPU401_HW_INTEL8X0 17 /* Intel8x0 driver */
#define MPU401_HW_PC98II 18 /* Roland PC98II */
#define MPU401_HW_AUREAL 19 /* Aureal Vortex */
+#define MPU401_HW_WAVEARTIST 20 /* Rockwell WaveArtist */
#define MPU401_INFO_INPUT (1 << 0) /* input stream */
#define MPU401_INFO_OUTPUT (1 << 1) /* output stream */
diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig
index 0216475..7a3b4a2 100644
--- a/sound/isa/Kconfig
+++ b/sound/isa/Kconfig
@@ -454,5 +454,16 @@ config SND_MSND_CLASSIC
To compile this driver as a module, choose M here: the module
will be called snd-msnd-classic.
+config SND_WAVEARTIST
+ tristate "Rockwell WaveArtist RWA010"
+ select SND_OPL3_LIB
+ select SND_MPU401_UART
+ select SND_PCM
+ help
+ Say Y here to include support for Rockwell WaveArtist RWA010 chips.
+
+ To compile this driver as a module, choose M here: the module
+ will be called snd-waveartist.
+
endif # SND_ISA
diff --git a/sound/isa/Makefile b/sound/isa/Makefile
index 9a15f14..23e11e2 100644
--- a/sound/isa/Makefile
+++ b/sound/isa/Makefile
@@ -12,6 +12,7 @@ snd-es18xx-objs := es18xx.o
snd-opl3sa2-objs := opl3sa2.o
snd-sc6000-objs := sc6000.o
snd-sscape-objs := sscape.o
+snd-waveartist-objs := waveartist.o
# Toplevel Module Dependency
obj-$(CONFIG_SND_ADLIB) += snd-adlib.o
@@ -23,6 +24,7 @@ obj-$(CONFIG_SND_ES18XX) += snd-es18xx.o
obj-$(CONFIG_SND_OPL3SA2) += snd-opl3sa2.o
obj-$(CONFIG_SND_SC6000) += snd-sc6000.o
obj-$(CONFIG_SND_SSCAPE) += snd-sscape.o
+obj-$(CONFIG_SND_WAVEARTIST) += snd-waveartist.o
obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ galaxy/ gus/ msnd/ opti9xx/ \
sb/ wavefront/ wss/
diff --git a/sound/isa/waveartist.c b/sound/isa/waveartist.c
new file mode 100644
index 0000000..e5bda5c
--- /dev/null
+++ b/sound/isa/waveartist.c
@@ -0,0 +1,1399 @@
+/*
+ * Driver for Rockwell WaveArtist RWA010 soundcards
+ *
+ * Copyright (c) 2015 Ondrej Zary
+ *
+ * HW-related parts based on OSS WaveArtist driver by Hannu Savolainen
+ *
+ * ALSA code based on ES18xx driver by Christian Fischbach & Abramo Bagnara
+ * and also by OPL3-SA2 driver by Jaroslav Kysela
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/isa.h>
+#include <linux/pnp.h>
+#include <linux/isapnp.h>
+#include <asm/dma.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/mpu401.h>
+#include <sound/opl3.h>
+#include <sound/initval.h>
+#include "waveartist.h"
+
+MODULE_AUTHOR("Ondrej Zary");
+MODULE_DESCRIPTION("Driver for Rockwell WaveArtist RWA010 sound cards");
+MODULE_LICENSE("GPL");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
+#ifdef CONFIG_PNP
+static bool isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
+#endif
+static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x250-0x3f0 */
+static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x388-0x3f0 */
+static long midi_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* 0x300-0x3f0 */
+static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,10,11 */
+static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 5,6,7 */
+static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3 */
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for WaveArtist soundcard.");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string for WaveArtist soundcard.");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "Enable WaveArtist soundcard.");
+#ifdef CONFIG_PNP
+module_param_array(isapnp, bool, NULL, 0444);
+MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
+#endif
+module_param_array(port, long, NULL, 0444);
+MODULE_PARM_DESC(port, "Port # for WaveArtist driver.");
+module_param_array(fm_port, long, NULL, 0444);
+MODULE_PARM_DESC(fm_port, "FM port # for WaveArtist driver.");
+module_param_array(midi_port, long, NULL, 0444);
+MODULE_PARM_DESC(midi_port, "MIDI port # for WaveArtist driver.");
+module_param_array(irq, int, NULL, 0444);
+MODULE_PARM_DESC(irq, "IRQ # for WaveArtist driver.");
+module_param_array(dma1, int, NULL, 0444);
+MODULE_PARM_DESC(dma1, "DMA1 # for WaveArtist driver.");
+module_param_array(dma2, int, NULL, 0444);
+MODULE_PARM_DESC(dma2, "DMA2 # for WaveArtist driver.");
+
+#ifdef CONFIG_PNP
+static int isa_registered;
+static int pnp_registered;
+#endif
+
+#define PFX "waveartist: "
+
+#ifdef CONFIG_PNP
+#define WA_DEVICE(pnpid) { \
+ .id = pnpid, \
+ .devs = { {"RSS5000"}, {"RSS5001"}, {"RSS5002"} } \
+}
+/*
+ * RSS5000 = WaveArtist, RSS5001 = SB, RSS5002 = MPU-401, RSS5003 = IDE,
+ * RSS5004 = gameport, RSS5005 = modem, RSS5006 = 3D
+ */
+
+static struct pnp_card_device_id snd_waveartist_pnpids[] = {
+ WA_DEVICE("RSS5000"), /* 16-bit decode */
+ WA_DEVICE("RSS5100"), /* 16-bit decode + modem */
+ WA_DEVICE("RSS5200"), /* 10-bit decode + modem */
+ WA_DEVICE("RSS5300"), /* 10-bit decode */
+ WA_DEVICE("RSS5400"), /* 16-bit decode + IDE */
+ WA_DEVICE("RSS5500"), /* 16-bit decode + modem + IDE */
+ WA_DEVICE("RSS5600"), /* 10-bit decode + IDE */
+ WA_DEVICE("RSS5700"), /* 10-bit decode + modem + IDE */
+ WA_DEVICE("RSS5800"), /* 10-bit decode + modem + 3D */
+ WA_DEVICE("RSS5900"), /* 10-bit decode + 3D */
+ WA_DEVICE("RSS5A00"), /* 16-bit decode + modem + 3D */
+ WA_DEVICE("RSS5B00"), /* 16-bit decode + 3D */
+ { .id = "" } /* end */
+};
+MODULE_DEVICE_TABLE(pnp_card, snd_waveartist_pnpids);
+#endif /* CONFIG_PNP */
+
+struct snd_waveartist {
+#ifdef CONFIG_PNP
+ struct pnp_dev *wa; /* WaveArtist device */
+ struct pnp_dev *sb; /* SB emulation device */
+ struct pnp_dev *mpu; /* MPU-401 device */
+#endif
+ unsigned long port; /* base port */
+ struct resource *res_port; /* base port resource */
+ int irq;
+ int dma_playback;
+ int dma_capture;
+
+ struct snd_card *card;
+ struct snd_pcm *pcm;
+ struct snd_pcm_substream *playback_substream;
+ struct snd_pcm_substream *capture_substream;
+
+ spinlock_t reg_lock;
+ struct snd_hwdep *synth;
+ struct snd_rawmidi *rmidi;
+
+ u16 image[20]; /* mixer registers image */
+};
+
+static inline void wa_outb(struct snd_waveartist *chip, u8 reg, u8 val)
+{
+ outb(val, chip->port + reg);
+}
+
+static inline u8 wa_inb(struct snd_waveartist *chip, u8 reg)
+{
+ return inb(chip->port + reg);
+}
+
+static inline void wa_outw(struct snd_waveartist *chip, u8 reg, u16 val)
+{
+ outw(val, chip->port + reg);
+}
+
+static inline u16 wa_inw(struct snd_waveartist *chip, u8 reg)
+{
+ return inw(chip->port + reg);
+}
+
+static inline void waveartist_set_ctlr(struct snd_waveartist *chip, u8 clear,
+ u8 set)
+{
+ clear = ~clear & wa_inb(chip, CTLR);
+ wa_outb(chip, CTLR, clear | set);
+}
+
+/* acknowledge IRQ */
+static inline void waveartist_iack(struct snd_waveartist *chip)
+{
+ u8 old_ctlr = wa_inb(chip, CTLR) & ~IRQ_ACK;
+
+ wa_outb(chip, CTLR, old_ctlr | IRQ_ACK);
+ wa_outb(chip, CTLR, old_ctlr);
+}
+
+static int waveartist_reset(struct snd_waveartist *chip)
+{
+ unsigned int timeout, res = -1;
+
+ waveartist_set_ctlr(chip, -1, RESET);
+ msleep(200);
+ waveartist_set_ctlr(chip, RESET, 0);
+
+ timeout = 500;
+ do {
+ mdelay(2);
+
+ if (wa_inb(chip, STATR) & CMD_RF) {
+ res = wa_inw(chip, CMDR);
+ if (res == 0x55aa)
+ break;
+ }
+ } while (--timeout);
+
+ if (timeout == 0) {
+ dev_warn(chip->card->dev, "WaveArtist: reset timeout (res=0x%x)\n",
+ res);
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Helper function to send and receive words
+ * from WaveArtist. It handles all the handshaking
+ * and can send or receive multiple words.
+ */
+static int waveartist_cmd(struct snd_waveartist *chip,
+ int nr_cmd, u16 *cmd,
+ int nr_resp, u16 *resp)
+{
+ unsigned long flags;
+ unsigned int timed_out = 0, i;
+
+ spin_lock_irqsave(&chip->reg_lock, flags);
+ /*
+ * The chip can hang if we access the STATR register too quickly
+ * after a write. Do a dummy read to slow down.
+ */
+ wa_inb(chip, CTLR);
+
+ if (wa_inb(chip, STATR) & CMD_RF) {
+ /* flush the port */
+ wa_inw(chip, CMDR);
+ udelay(10);
+ }
+
+ for (i = 0; !timed_out && i < nr_cmd; i++) {
+ int count;
+
+ for (count = 5000; count; count--)
+ if (wa_inb(chip, STATR) & CMD_WE)
+ break;
+
+ if (!count)
+ timed_out = 1;
+ else
+ wa_outw(chip, CMDR, cmd[i]);
+ /* Another dummy read */
+ wa_inb(chip, CTLR);
+ }
+
+ for (i = 0; !timed_out && i < nr_resp; i++) {
+ int count;
+
+ for (count = 5000; count; count--)
+ if (wa_inb(chip, STATR) & CMD_RF)
+ break;
+
+ if (!count)
+ timed_out = 1;
+ else
+ resp[i] = wa_inw(chip, CMDR);
+ }
+ spin_unlock_irqrestore(&chip->reg_lock, flags);
+
+ return timed_out ? 1 : 0;
+}
+
+/* Send one command word */
+static inline int waveartist_cmd1(struct snd_waveartist *chip, u16 cmd)
+{
+ return waveartist_cmd(chip, 1, &cmd, 0, NULL);
+}
+
+/* Send one command, receive one word */
+static inline u16 waveartist_cmd1_r(struct snd_waveartist *chip, u16 cmd)
+{
+ u16 ret;
+
+ waveartist_cmd(chip, 1, &cmd, 1, &ret);
+
+ return ret;
+}
+
+/* Send a double command, receive one word (and throw it away) */
+static inline int waveartist_cmd2(struct snd_waveartist *chip, u16 cmd, u16 arg)
+{
+ u16 vals[2] = { cmd, arg };
+
+ return waveartist_cmd(chip, 2, vals, 1, vals);
+}
+
+/* Send a triple command */
+static inline int waveartist_cmd3(struct snd_waveartist *chip, u16 cmd,
+ u16 arg1, u16 arg2)
+{
+ u16 vals[3] = { cmd, arg1, arg2 };
+
+ return waveartist_cmd(chip, 3, vals, 0, NULL);
+}
+
+static u16 waveartist_getrev(struct snd_waveartist *chip)
+{
+ u16 temp[2];
+ u16 cmd = WACMD_GETREV;
+
+ waveartist_cmd(chip, 1, &cmd, 2, temp);
+
+ return temp[0];
+}
+
+static irqreturn_t snd_waveartist_interrupt(int irq, void *dev_id)
+{
+ u8 status, irqstatus;
+ struct snd_card *card = dev_id;
+ struct snd_waveartist *chip;
+
+ if (card == NULL)
+ return IRQ_NONE;
+
+ chip = card->private_data;
+
+ irqstatus = wa_inb(chip, IRQSTAT);
+ status = wa_inb(chip, STATR);
+
+ if (status & IRQ_REQ) /* clear interrupt */
+ waveartist_iack(chip);
+
+ if (irqstatus & IRQ_PCM) { /* PCM buffer done */
+ if ((status & DMA1) && chip->playback_substream)
+ snd_pcm_period_elapsed(chip->playback_substream);
+ if ((status & DMA0) && chip->capture_substream)
+ snd_pcm_period_elapsed(chip->capture_substream);
+ if (!(status & (DMA0 | DMA1)))
+ dev_warn(chip->card->dev, "Unknown PCM interrupt\n");
+ }
+
+ if (irqstatus & IRQ_SB) /* we do not use SB mode */
+ dev_warn(chip->card->dev, "Unexpected SB interrupt\n");
+
+ if ((irqstatus & IRQ_MPU) && chip->rmidi)
+ snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
+
+ return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_PM
+static int snd_waveartist_suspend(struct snd_card *card, pm_message_t state)
+{
+ struct snd_waveartist *chip = card->private_data;
+ int i;
+
+ if (!card)
+ return 0;
+
+ snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+ snd_pcm_suspend_all(chip->pcm);
+
+ /* save mixer registers */
+ for (i = 0; i < ARRAY_SIZE(chip->image); i++)
+ chip->image[i] = waveartist_cmd1_r(chip,
+ WACMD_GET_LEVEL | i << 8);
+
+ return 0;
+}
+
+static int snd_waveartist_resume(struct snd_card *card)
+{
+ struct snd_waveartist *chip;
+ int i;
+
+ if (!card)
+ return 0;
+
+ chip = card->private_data;
+
+ /* restore mixer registers */
+ for (i = 0; i < 10; i += 2)
+ waveartist_cmd3(chip, WACMD_SET_MIXER,
+ chip->image[i], chip->image[i + 1]);
+ for (i = 10; i < ARRAY_SIZE(chip->image); i += 2)
+ waveartist_cmd3(chip, WACMD_SET_LEVEL |
+ ((i - 10) / 2) << 8,
+ chip->image[i], chip->image[i + 1]);
+
+
+ snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+
+ return 0;
+}
+#endif /* CONFIG_PM */
+
+#ifdef CONFIG_PNP
+static void snd_waveartist_set_irq(struct pnp_dev *pdev, int irq)
+{
+ if (!pdev->active)
+ return;
+ isapnp_cfg_begin(isapnp_card_number(pdev), isapnp_csn_number(pdev));
+ isapnp_write_byte(0x70, irq); /* ISAPNP_CFG_IRQ */
+ isapnp_cfg_end();
+}
+
+static int snd_waveartist_pnp(int dev, struct snd_waveartist *chip,
+ struct pnp_card_link *card,
+ const struct pnp_card_device_id *id)
+{
+ chip->wa = pnp_request_card_device(card, id->devs[0].id, NULL);
+ if (!chip->wa)
+ return -EBUSY;
+
+ chip->sb = pnp_request_card_device(card, id->devs[1].id, NULL);
+ if (!chip->sb)
+ return -EBUSY;
+
+ chip->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
+ if (!chip->mpu)
+ return -EBUSY;
+
+ if (pnp_activate_dev(chip->wa) < 0) {
+ dev_err(chip->card->dev, "WA PnP configure failure\n");
+ return -EBUSY;
+ }
+ if (pnp_activate_dev(chip->sb) < 0) {
+ dev_err(chip->card->dev, "SB PnP configure failure\n");
+ return -EBUSY;
+ }
+ port[dev] = pnp_port_start(chip->wa, 0);
+ dma2[dev] = pnp_dma(chip->wa, 0);
+ fm_port[dev] = pnp_port_start(chip->sb, 1);
+ dma1[dev] = pnp_dma(chip->sb, 0);
+ irq[dev] = pnp_irq(chip->sb, 0);
+
+ /*
+ * The card uses only one IRQ (listed in the resources of SB device)
+ * which needs to be shared by WaveArtist and MPU-401 devices. They
+ * don't have an IRQ resource so it must be forced.
+ */
+ snd_waveartist_set_irq(chip->wa, irq[dev]);
+
+ /* allocate MPU-401 resources */
+ if (pnp_activate_dev(chip->mpu) < 0)
+ dev_err(chip->card->dev, "MPU-401 PnP configure failure: will be disabled\n");
+ else {
+ midi_port[dev] = pnp_port_start(chip->mpu, 0);
+ snd_waveartist_set_irq(chip->mpu, irq[dev]);
+ }
+
+ dev_dbg(chip->card->dev, "PnP WaveArtist: port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
+ port[dev], fm_port[dev], midi_port[dev]);
+ dev_dbg(chip->card->dev, "PnP WaveArtist: dma1=%i, dma2=%i, irq=%i\n",
+ dma1[dev], dma2[dev], irq[dev]);
+
+ return 0;
+}
+#endif /* CONFIG_PNP */
+
+static int snd_waveartist_playback_hw_params(
+ struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *hw_params)
+{
+ int err = snd_pcm_lib_malloc_pages(substream,
+ params_buffer_bytes(hw_params));
+
+ if (err < 0)
+ return err;
+
+ return 0;
+}
+
+static int snd_waveartist_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+ return snd_pcm_lib_free_pages(substream);
+}
+
+static enum wa_format waveartist_format(snd_pcm_format_t format)
+{
+ if (snd_pcm_format_width(format) == 16)
+ return WA_FMT_S16;
+ if (snd_pcm_format_unsigned(format))
+ return WA_FMT_U8;
+ else
+ return WA_FMT_S8;
+}
+
+static u16 waveartist_rate(struct snd_pcm_runtime *runtime)
+{
+ return (runtime->rate << 16) / 44100;
+}
+
+static int snd_waveartist_playback_prepare(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
+ unsigned int size = snd_pcm_lib_buffer_bytes(substream);
+ unsigned int count = snd_pcm_lib_period_bytes(substream);
+
+ /* Set rate */
+ if (waveartist_cmd2(chip, WACMD_OUTPUTSPEED, waveartist_rate(runtime)))
+ dev_warn(chip->card->dev, "error setting playback rate %dHz\n",
+ runtime->rate);
+ /* Set channel count */
+ if (waveartist_cmd2(chip, WACMD_OUTPUTCHANNELS, runtime->channels))
+ dev_warn(chip->card->dev, "error setting playback %d channels\n",
+ runtime->channels);
+ /* Set DMA channel */
+ if (waveartist_cmd2(chip, WACMD_OUTPUTDMA,
+ chip->dma_playback > 3 ? WA_DMA_16BIT : WA_DMA_8BIT))
+ dev_warn(chip->card->dev, "error setting playback data path\n");
+ /* Set format */
+ if (waveartist_cmd2(chip, WACMD_OUTPUTFORMAT,
+ waveartist_format(runtime->format)))
+ dev_warn(chip->card->dev, "error setting playback format %d\n",
+ runtime->format);
+ /* Set sample count */
+ if (waveartist_cmd2(chip, WACMD_OUTPUTSIZE, count - 1))
+ dev_warn(chip->card->dev, "error setting playback count %d\n",
+ count);
+ /* Configure DMA controller */
+ snd_dma_program(chip->dma_playback, runtime->dma_addr, size,
+ DMA_MODE_WRITE | DMA_AUTOINIT);
+
+ return 0;
+}
+
+static int snd_waveartist_playback_trigger(struct snd_pcm_substream *substream,
+ int cmd)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ case SNDRV_PCM_TRIGGER_RESUME:
+ waveartist_cmd1(chip, WACMD_OUTPUTSTART);
+ break;
+ case SNDRV_PCM_TRIGGER_STOP:
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ waveartist_cmd1(chip, WACMD_OUTPUTSTOP);
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ waveartist_cmd1(chip, WACMD_OUTPUTPAUSE);
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ waveartist_cmd1(chip, WACMD_OUTPUTRESUME);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int snd_waveartist_capture_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *hw_params)
+{
+ int err = snd_pcm_lib_malloc_pages(substream,
+ params_buffer_bytes(hw_params));
+
+ if (err < 0)
+ return err;
+
+ return 0;
+}
+
+static int snd_waveartist_capture_prepare(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
+ unsigned int size = snd_pcm_lib_buffer_bytes(substream);
+ unsigned int count = snd_pcm_lib_period_bytes(substream);
+
+ /* Set rate */
+ if (waveartist_cmd2(chip, WACMD_INPUTSPEED, waveartist_rate(runtime)))
+ dev_warn(chip->card->dev, "error setting capture rate %dHz\n",
+ runtime->rate);
+ /* Set channel count */
+ if (waveartist_cmd2(chip, WACMD_INPUTCHANNELS, runtime->channels))
+ dev_warn(chip->card->dev, "error setting capture %d channels\n",
+ runtime->channels);
+ /* Set DMA channel */
+ if (waveartist_cmd2(chip, WACMD_INPUTDMA,
+ chip->dma_capture > 3 ? WA_DMA_16BIT : WA_DMA_8BIT))
+ dev_warn(chip->card->dev, "error setting capture data path\n");
+ /* Set format */
+ if (waveartist_cmd2(chip, WACMD_INPUTFORMAT,
+ waveartist_format(runtime->format)))
+ dev_warn(chip->card->dev, "error setting capture format %d\n",
+ runtime->format);
+ /* Set sample count */
+ if (waveartist_cmd2(chip, WACMD_INPUTSIZE, count - 1))
+ dev_warn(chip->card->dev, "error setting capture count %d\n",
+ count);
+ /* Configure DMA controller */
+ snd_dma_program(chip->dma_capture, runtime->dma_addr, size,
+ DMA_MODE_READ | DMA_AUTOINIT);
+
+ return 0;
+}
+
+static int snd_waveartist_capture_trigger(struct snd_pcm_substream *substream,
+ int cmd)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ case SNDRV_PCM_TRIGGER_RESUME:
+ waveartist_cmd1(chip, WACMD_INPUTSTART);
+ break;
+ case SNDRV_PCM_TRIGGER_STOP:
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ waveartist_cmd1(chip, WACMD_INPUTSTOP);
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ waveartist_cmd1(chip, WACMD_INPUTPAUSE);
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ waveartist_cmd1(chip, WACMD_INPUTRESUME);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static snd_pcm_uframes_t snd_waveartist_playback_pointer(
+ struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+ size_t size = snd_pcm_lib_buffer_bytes(substream);
+ size_t ptr = snd_dma_pointer(chip->dma_playback, size);
+
+ return bytes_to_frames(substream->runtime, ptr);
+}
+
+static snd_pcm_uframes_t snd_waveartist_capture_pointer(
+ struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+ size_t size = snd_pcm_lib_buffer_bytes(substream);
+ size_t ptr = snd_dma_pointer(chip->dma_capture, size);
+
+ return bytes_to_frames(substream->runtime, ptr);
+}
+
+static struct snd_pcm_hardware snd_waveartist_playback = {
+ .info = SNDRV_PCM_INFO_MMAP |
+ SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_PAUSE |
+ SNDRV_PCM_INFO_MMAP_VALID,
+ .formats = SNDRV_PCM_FMTBIT_U8 |
+ SNDRV_PCM_FMTBIT_S8 |
+ SNDRV_PCM_FMTBIT_S16_LE,
+ .rates = SNDRV_PCM_RATE_CONTINUOUS |
+ SNDRV_PCM_RATE_8000_44100,
+ .rate_min = 4000,
+ .rate_max = 44100,
+ .channels_min = 1,
+ .channels_max = 2,
+ .buffer_bytes_max = (128*1024),
+ .period_bytes_min = 64,
+ .period_bytes_max = (128*1024),
+ .periods_min = 1,
+ .periods_max = 1024,
+};
+
+static struct snd_pcm_hardware snd_waveartist_capture = {
+ .info = SNDRV_PCM_INFO_MMAP |
+ SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_PAUSE |
+ SNDRV_PCM_INFO_MMAP_VALID,
+ .formats = SNDRV_PCM_FMTBIT_U8 |
+ SNDRV_PCM_FMTBIT_S8 |
+ SNDRV_PCM_FMTBIT_S16_LE,
+ .rates = SNDRV_PCM_RATE_CONTINUOUS |
+ SNDRV_PCM_RATE_8000_44100,
+ .rate_min = 4000,
+ .rate_max = 44100,
+ .channels_min = 1,
+ .channels_max = 2,
+ .buffer_bytes_max = (128*1024),
+ .period_bytes_min = 64,
+ .period_bytes_max = (128*1024),
+ .periods_min = 1,
+ .periods_max = 1024,
+};
+
+static int snd_waveartist_playback_open(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ chip->playback_substream = substream;
+ substream->runtime->hw = snd_waveartist_playback;
+
+ snd_pcm_limit_isa_dma_size(chip->dma_playback,
+ &substream->runtime->hw.buffer_bytes_max);
+ snd_pcm_limit_isa_dma_size(chip->dma_playback,
+ &substream->runtime->hw.period_bytes_max);
+
+ return 0;
+}
+
+static int snd_waveartist_capture_open(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ chip->capture_substream = substream;
+ substream->runtime->hw = snd_waveartist_capture;
+
+ snd_pcm_limit_isa_dma_size(chip->dma_capture,
+ &substream->runtime->hw.buffer_bytes_max);
+ snd_pcm_limit_isa_dma_size(chip->dma_capture,
+ &substream->runtime->hw.period_bytes_max);
+
+ return 0;
+}
+
+static int snd_waveartist_playback_close(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ chip->playback_substream = NULL;
+ snd_pcm_lib_free_pages(substream);
+
+ return 0;
+}
+
+static int snd_waveartist_capture_close(struct snd_pcm_substream *substream)
+{
+ struct snd_waveartist *chip = snd_pcm_substream_chip(substream);
+
+ chip->capture_substream = NULL;
+ snd_pcm_lib_free_pages(substream);
+
+ return 0;
+}
+
+static struct snd_pcm_ops snd_waveartist_playback_ops = {
+ .open = snd_waveartist_playback_open,
+ .close = snd_waveartist_playback_close,
+ .ioctl = snd_pcm_lib_ioctl,
+ .hw_params = snd_waveartist_playback_hw_params,
+ .hw_free = snd_waveartist_pcm_hw_free,
+ .prepare = snd_waveartist_playback_prepare,
+ .trigger = snd_waveartist_playback_trigger,
+ .pointer = snd_waveartist_playback_pointer,
+};
+
+static struct snd_pcm_ops snd_waveartist_capture_ops = {
+ .open = snd_waveartist_capture_open,
+ .close = snd_waveartist_capture_close,
+ .ioctl = snd_pcm_lib_ioctl,
+ .hw_params = snd_waveartist_capture_hw_params,
+ .hw_free = snd_waveartist_pcm_hw_free,
+ .prepare = snd_waveartist_capture_prepare,
+ .trigger = snd_waveartist_capture_trigger,
+ .pointer = snd_waveartist_capture_pointer,
+};
+
+static int snd_waveartist_pcm(struct snd_card *card)
+{
+ struct snd_waveartist *chip = card->private_data;
+ struct snd_pcm *pcm;
+ int err;
+
+ err = snd_pcm_new(card, "WaveArtist", 0, 1, 1, &pcm);
+ if (err < 0)
+ return err;
+
+ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+ &snd_waveartist_playback_ops);
+ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+ &snd_waveartist_capture_ops);
+
+ /* global setup */
+ pcm->private_data = chip;
+ pcm->info_flags = 0;
+ if (chip->dma_playback == chip->dma_capture)
+ pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
+ strcpy(pcm->name, card->shortname);
+ chip->pcm = pcm;
+
+ snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+ snd_dma_isa_data(), 64 * 1024,
+ chip->dma_playback > 3 || chip->dma_capture > 3 ?
+ 128 * 1024 : 64 * 1024);
+
+ return 0;
+}
+
+static void snd_waveartist_free(struct snd_card *card)
+{
+ struct snd_waveartist *chip = card->private_data;
+
+ release_and_free_resource(chip->res_port);
+ if (chip->irq >= 0)
+ free_irq(chip->irq, card);
+ if (chip->dma_playback >= 0) {
+ disable_dma(chip->dma_playback);
+ free_dma(chip->dma_playback);
+ }
+ if (chip->dma_capture >= 0 && chip->dma_capture != chip->dma_playback) {
+ disable_dma(chip->dma_capture);
+ free_dma(chip->dma_capture);
+ }
+}
+
+static int snd_waveartist_dev_free(struct snd_device *device)
+{
+ snd_waveartist_free(device->card);
+
+ return 0;
+}
+
+static int snd_waveartist_init(struct snd_waveartist *chip)
+{
+ if (waveartist_reset(chip))
+ return -ENODEV;
+ dev_dbg(chip->card->dev, "chip rev. 0x%x\n", waveartist_getrev(chip));
+
+ waveartist_cmd1(chip, WACMD_RST_MIXER); /* reset mixer */
+ waveartist_iack(chip); /* clear any pending interrupt */
+ waveartist_set_ctlr(chip, 0, DMA1_IE | DMA0_IE); /* enable DMA IRQs */
+ waveartist_iack(chip); /* clear any pending interrupt */
+
+ return 0;
+}
+
+static int snd_waveartist_new_device(struct snd_card *card,
+ unsigned long port,
+ unsigned long mpu_port,
+ unsigned long fm_port,
+ int irq, int dma1, int dma2)
+{
+ struct snd_waveartist *chip = card->private_data;
+ static struct snd_device_ops ops = {
+ .dev_free = snd_waveartist_dev_free,
+ };
+ int err;
+
+ spin_lock_init(&chip->reg_lock);
+ chip->card = card;
+ chip->port = port;
+ chip->irq = -1;
+ chip->dma_playback = -1;
+ chip->dma_capture = -1;
+
+ chip->res_port = request_region(port, 16, "WaveArtist");
+ if (!chip->res_port) {
+ snd_waveartist_free(card);
+ dev_err(chip->card->dev, "unable to grab ports 0x%lx-0x%lx\n",
+ port, port + 16 - 1);
+ return -EBUSY;
+ }
+
+ if (snd_waveartist_init(chip) < 0) {
+ snd_waveartist_free(card);
+ return -ENODEV;
+ }
+
+ if (request_irq(irq, snd_waveartist_interrupt, 0, "WaveArtist", card)) {
+ snd_waveartist_free(card);
+ dev_err(chip->card->dev, "unable to grab IRQ %d\n", irq);
+ return -EBUSY;
+ }
+ chip->irq = irq;
+
+ if (dma1 == dma2 || dma1 == SNDRV_AUTO_DMA || dma2 == SNDRV_AUTO_DMA) {
+ /* we have only one DMA channel */
+ if (dma1 == SNDRV_AUTO_DMA)
+ dma1 = dma2;
+ if (request_dma(dma1, "WaveArtist")) {
+ snd_waveartist_free(card);
+ dev_err(chip->card->dev, "unable to grab DMA %d\n",
+ dma1);
+ return -EBUSY;
+ }
+ chip->dma_playback = chip->dma_capture = dma1;
+ } else {
+ /*
+ * 2 channels: use 16-bit for playback and 8-bit for capture as
+ * full-duplex works better this way. However, the chip seems to
+ * have some band-width limit so full-duplex at 44kHz/16-bit/2ch
+ * is not possible - some frames are dropped during capture,
+ * resulting in too-fast recording. If capture is done using
+ * lower rate or 8-bit or mono, everything is fine.
+ */
+ if (dma2 > 3)
+ swap(dma1, dma2);
+
+ if (request_dma(dma1, "WaveArtist playback")) {
+ snd_waveartist_free(card);
+ dev_err(chip->card->dev, "unable to grab playback DMA %d\n",
+ dma1);
+ return -EBUSY;
+ }
+ chip->dma_playback = dma1;
+
+ if (dma2 != dma1 && request_dma(dma2, "WaveArtist capture")) {
+ snd_waveartist_free(card);
+ dev_err(chip->card->dev, "unable to grab capture DMA %d\n",
+ dma2);
+ return -EBUSY;
+ }
+ chip->dma_capture = dma2;
+ }
+
+ err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+ if (err < 0) {
+ snd_waveartist_free(card);
+ return err;
+ }
+
+ return 0;
+}
+
+static int snd_waveartist_card_new(struct device *pdev, int dev,
+ struct snd_card **cardp)
+{
+ return snd_card_new(pdev, index[dev], id[dev], THIS_MODULE,
+ sizeof(struct snd_waveartist), cardp);
+}
+
+static int snd_waveartist_info_single(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ int mask = (kcontrol->private_value >> 16) & 0xff;
+
+ uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
+ SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 1;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = mask;
+
+ return 0;
+}
+
+static int snd_waveartist_get_single(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ int reg = kcontrol->private_value & 0xff;
+ int shift = (kcontrol->private_value >> 8) & 0xff;
+ int mask = (kcontrol->private_value >> 16) & 0xff;
+ u16 val;
+
+ val = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | reg << 8);
+ ucontrol->value.integer.value[0] = (val >> shift) & mask;
+
+ return 0;
+}
+
+static int snd_waveartist_put_single(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ int reg = kcontrol->private_value & 0xff;
+ int shift = (kcontrol->private_value >> 8) & 0xff;
+ int mask = (kcontrol->private_value >> 16) & 0xff;
+ u16 val, old_val, new_val;
+
+ val = (ucontrol->value.integer.value[0] & mask);
+ mask <<= shift;
+ val <<= shift;
+
+ old_val = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | reg << 8);
+ new_val = (old_val & ~mask) | (val & mask);
+
+ if (new_val == old_val)
+ return 0;
+
+ /* new_val already contains register number (bits 12..15), bit 11 set */
+ waveartist_cmd3(chip, WACMD_SET_MIXER, new_val, new_val);
+
+ return 1;
+}
+
+static int snd_waveartist_info_double(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ int mask = (kcontrol->private_value >> 24) & 0xff;
+
+ uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
+ SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = mask ? mask : 0x7fff;
+
+ return 0;
+}
+
+static int snd_waveartist_get_double(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ int left_reg = kcontrol->private_value & 0xff;
+ int right_reg = (kcontrol->private_value >> 8) & 0xff;
+ int shift_left = (kcontrol->private_value >> 16) & 0x0f;
+ int shift_right = (kcontrol->private_value >> 20) & 0x0f;
+ int mask = (kcontrol->private_value >> 24) & 0xff;
+ u16 left, right;
+
+ if (mask == 0)
+ mask = 0x7fff;
+
+ left = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | left_reg << 8);
+ if (left_reg != right_reg)
+ right = waveartist_cmd1_r(chip, WACMD_GET_LEVEL |
+ right_reg << 8);
+ else
+ right = left;
+
+ ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
+ ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
+
+ return 0;
+}
+
+static int snd_waveartist_put_double(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ int left_reg = kcontrol->private_value & 0xff;
+ int right_reg = (kcontrol->private_value >> 8) & 0xff;
+ int shift_left = (kcontrol->private_value >> 16) & 0x0f;
+ int shift_right = (kcontrol->private_value >> 20) & 0x0f;
+ int mask = (kcontrol->private_value >> 24) & 0xff;
+ u16 val1, val2, mask1, mask2;
+ u16 old_left, old_right, new_left, new_right;
+
+ if (mask == 0)
+ mask = 0x7fff;
+
+ val1 = ucontrol->value.integer.value[0] & mask;
+ val2 = ucontrol->value.integer.value[1] & mask;
+ val1 <<= shift_left;
+ val2 <<= shift_right;
+ mask1 = mask << shift_left;
+ mask2 = mask << shift_right;
+
+ old_left = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | left_reg << 8);
+ if (left_reg != right_reg)
+ old_right = waveartist_cmd1_r(chip, WACMD_GET_LEVEL |
+ right_reg << 8);
+ else
+ old_right = old_left;
+
+ new_left = (old_left & ~mask1) | (val1 & mask1);
+ new_right = (old_right & ~mask2) | (val2 & mask2);
+
+ if (new_left == old_left && new_right == old_right)
+ return 0;
+
+ if (left_reg < 10)
+ /* new_* already contain reg. num. (bits 12..15), bit 11 set */
+ waveartist_cmd3(chip, WACMD_SET_MIXER, new_left, new_right);
+ else
+ waveartist_cmd3(chip, WACMD_SET_LEVEL |
+ ((left_reg - 10) / 2) << 8,
+ new_left, new_right);
+
+ return 1;
+}
+
+static int snd_waveartist_info_mux(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ static const char * const mux_texts[] = {
+ "None", "Mix", "Line", "Phone", "CD", "Mic"
+ };
+
+ return snd_ctl_enum_info(uinfo, 2, ARRAY_SIZE(mux_texts), mux_texts);
+}
+
+static int snd_waveartist_get_mux(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ int mux = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | 0x08 << 8);
+
+ ucontrol->value.enumerated.item[0] = mux & 0x07;
+ ucontrol->value.enumerated.item[1] = (mux >> 3) & 0x07;
+
+ return 0;
+}
+
+static int snd_waveartist_put_mux(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_waveartist *chip = snd_kcontrol_chip(kcontrol);
+ u16 old_val, new_val;
+ u16 val1 = ucontrol->value.enumerated.item[0];
+ u16 val2 = ucontrol->value.enumerated.item[1];
+
+ old_val = waveartist_cmd1_r(chip, WACMD_GET_LEVEL | 0x08 << 8);
+ new_val = (old_val & ~0x3f) | (val1 & 0x07) | ((val2 & 0x07) << 3);
+ if (new_val == old_val)
+ return 0;
+
+ /* new_val already contains register number (bits 12..15), bit 11 set */
+ waveartist_cmd3(chip, WACMD_SET_MIXER, new_val, new_val);
+
+ return 1;
+}
+
+#define WAVEARTIST_SINGLE(xname, reg, shift, mask) \
+{ \
+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+ .info = snd_waveartist_info_single, \
+ .get = snd_waveartist_get_single, .put = snd_waveartist_put_single, \
+ .private_value = reg | (shift << 8) | (mask << 16) \
+}
+
+#define WAVEARTIST_DOUBLE(xname, left_reg, right_reg, shift_left, shift_right, \
+ mask) \
+{ \
+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+ .info = snd_waveartist_info_double, \
+ .get = snd_waveartist_get_double, .put = snd_waveartist_put_double, \
+ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | \
+ (shift_right << 20) | (mask << 24) \
+}
+
+static struct snd_kcontrol_new snd_waveartist_controls[] = {
+WAVEARTIST_DOUBLE("Master Playback Volume", 2, 6, 1, 1, 0x07),
+WAVEARTIST_DOUBLE("Master Playback Switch", 0, 4, 0, 0, 1),
+WAVEARTIST_DOUBLE("PCM Playback Volume", 10, 11, 0, 0, 0x00),/* 0x00 = 0x7fff */
+WAVEARTIST_DOUBLE("FM Playback Volume", 12, 13, 0, 0, 0x00),/* 0x00 = 0x7fff */
+/* WAVEARTIST_DOUBLE("Wavetable? Playback Volume", 14, 15, 0, 0, 0x00), */
+/* WAVEARTIST_DOUBLE("? Playback Volume", 16, 17, 0, 0, 0x00), */
+/* WAVEARTIST_DOUBLE("? Playback Volume", 18, 19, 0, 0, 0x00), */
+WAVEARTIST_DOUBLE("Digital Playback Switch", 3, 7, 10, 10, 1), /* PCM + FM */
+WAVEARTIST_DOUBLE("CD Playback Volume", 0, 4, 1, 1, 0x1f),
+WAVEARTIST_DOUBLE("CD Playback Switch", 3, 7, 6, 6, 1),
+WAVEARTIST_DOUBLE("Line Playback Volume", 0, 4, 6, 6, 0x1f),
+WAVEARTIST_DOUBLE("Line Playback Switch", 3, 7, 4, 4, 1),
+WAVEARTIST_DOUBLE("Phone Playback Volume", 1, 5, 6, 6, 0x1f),
+WAVEARTIST_DOUBLE("Phone Playback Switch", 3, 7, 5, 5, 1),
+WAVEARTIST_SINGLE("Mono Playback Volume", 8, 5, 0x1f),
+WAVEARTIST_DOUBLE("Mono Playback Switch", 3, 7, 9, 9, 1),
+WAVEARTIST_DOUBLE("Mic Playback Volume", 2, 6, 6, 6, 0x1f),
+WAVEARTIST_DOUBLE("Mic 2 Playback Volume", 1, 5, 1, 1, 0x1f),
+WAVEARTIST_DOUBLE("Mic Playback Switch", 3, 7, 7, 7, 1),
+WAVEARTIST_DOUBLE("Mic 2 Playback Switch", 3, 7, 8, 8, 1),
+WAVEARTIST_DOUBLE("Mic Gain", 2, 6, 4, 4, 0x03),
+WAVEARTIST_DOUBLE("Capture Volume", 3, 7, 0, 0, 0x0f),
+WAVEARTIST_SINGLE("Mono Output Playback Switch", 1, 0, 1),
+{
+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+ .name = "Capture Source",
+ .info = snd_waveartist_info_mux,
+ .get = snd_waveartist_get_mux,
+ .put = snd_waveartist_put_mux,
+}
+};
+
+static int snd_waveartist_mixer(struct snd_card *card)
+{
+ struct snd_waveartist *chip = card->private_data;
+ int err;
+ unsigned int idx;
+
+ strcpy(card->mixername, chip->pcm->name);
+
+ for (idx = 0; idx < ARRAY_SIZE(snd_waveartist_controls); idx++) {
+ struct snd_kcontrol *kctl;
+
+ kctl = snd_ctl_new1(&snd_waveartist_controls[idx], chip);
+ err = snd_ctl_add(card, kctl);
+ if (err < 0)
+ return err;
+ }
+
+ return 0;
+}
+
+static int snd_waveartist_probe(struct snd_card *card, int dev)
+{
+ struct snd_waveartist *chip = card->private_data;
+ struct snd_opl3 *opl3;
+ int err;
+
+ err = snd_waveartist_new_device(card,
+ port[dev], midi_port[dev], fm_port[dev],
+ irq[dev], dma1[dev], dma2[dev]);
+ if (err < 0)
+ return err;
+
+ strcpy(card->driver, "WaveArtist");
+ strcpy(card->shortname, "Rockwell WaveArtist RWA010");
+ sprintf(card->longname, "%s at 0x%lx, irq %d, dma1 %d, dma2 %d",
+ card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);
+
+ err = snd_waveartist_pcm(card);
+ if (err < 0)
+ return err;
+ err = snd_waveartist_mixer(card);
+ if (err < 0)
+ return err;
+
+ if (fm_port[dev] >= 0x388 && fm_port[dev] < 0x3f0) {
+ err = snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2,
+ OPL3_HW_OPL3, 0, &opl3);
+ if (err < 0)
+ return err;
+ err = snd_opl3_timer_new(opl3, 1, 2);
+ if (err < 0)
+ return err;
+ err = snd_opl3_hwdep_new(opl3, 0, 1, &chip->synth);
+ if (err < 0)
+ return err;
+ }
+ if (midi_port[dev] >= 0x300 && midi_port[dev] < 0x3f0) {
+ err = snd_mpu401_uart_new(card, 0, MPU401_HW_WAVEARTIST,
+ midi_port[dev], MPU401_INFO_IRQ_HOOK,
+ -1, &chip->rmidi);
+ if (err < 0)
+ return err;
+ }
+
+ return snd_card_register(card);
+}
+
+static int snd_waveartist_isa_match(struct device *pdev,
+ unsigned int dev)
+{
+ if (!enable[dev])
+ return 0;
+#ifdef CONFIG_PNP
+ if (isapnp[dev])
+ return 0;
+#endif
+ if (port[dev] == SNDRV_AUTO_PORT) {
+ dev_err(pdev, "specify port\n");
+ return 0;
+ }
+ if (irq[dev] == SNDRV_AUTO_IRQ) {
+ dev_err(pdev, "specify irq\n");
+ return 0;
+ }
+ if (dma1[dev] == SNDRV_AUTO_DMA) {
+ dev_err(pdev, "specify dma1\n");
+ return 0;
+ }
+
+ return 1;
+}
+
+static int snd_waveartist_isa_probe(struct device *pdev,
+ unsigned int dev)
+{
+ struct snd_card *card;
+ int err;
+
+ err = snd_waveartist_card_new(pdev, dev, &card);
+ if (err < 0)
+ return err;
+ err = snd_waveartist_probe(card, dev);
+ if (err < 0) {
+ snd_card_free(card);
+ return err;
+ }
+ dev_set_drvdata(pdev, card);
+
+ return 0;
+}
+
+static int snd_waveartist_isa_remove(struct device *devptr,
+ unsigned int dev)
+{
+ snd_card_free(dev_get_drvdata(devptr));
+
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int snd_waveartist_isa_suspend(struct device *dev, unsigned int n,
+ pm_message_t state)
+{
+ return snd_waveartist_suspend(dev_get_drvdata(dev), state);
+}
+
+static int snd_waveartist_isa_resume(struct device *dev, unsigned int n)
+{
+ return snd_waveartist_resume(dev_get_drvdata(dev));
+}
+#endif
+
+static struct isa_driver waveartist_isa_driver = {
+ .match = snd_waveartist_isa_match,
+ .probe = snd_waveartist_isa_probe,
+ .remove = snd_waveartist_isa_remove,
+#ifdef CONFIG_PM
+ .suspend = snd_waveartist_isa_suspend,
+ .resume = snd_waveartist_isa_resume,
+#endif
+ .driver = { .name = "waveartist" },
+};
+
+#ifdef CONFIG_PNP
+static int snd_waveartist_pnp_detect(struct pnp_card_link *pcard,
+ const struct pnp_card_device_id *pid)
+{
+ static int dev;
+ int err;
+ struct snd_card *card;
+
+ for (; dev < SNDRV_CARDS; dev++) {
+ if (enable[dev] && isapnp[dev])
+ break;
+ }
+ if (dev >= SNDRV_CARDS)
+ return -ENODEV;
+
+ err = snd_waveartist_card_new(&pcard->card->dev, dev, &card);
+ if (err < 0)
+ return err;
+ err = snd_waveartist_pnp(dev, card->private_data, pcard, pid);
+ if (err < 0) {
+ dev_err(&pcard->card->dev, "PnP detection failed\n");
+ snd_card_free(card);
+ return err;
+ }
+ err = snd_waveartist_probe(card, dev);
+ if (err < 0) {
+ snd_card_free(card);
+ return err;
+ }
+ pnp_set_card_drvdata(pcard, card);
+ dev++;
+
+ return 0;
+}
+
+static void snd_waveartist_pnp_remove(struct pnp_card_link *pcard)
+{
+ struct snd_card *card = pnp_get_card_drvdata(pcard);
+ struct snd_waveartist *chip = card->private_data;
+
+ /* disable forced IRQs */
+ snd_waveartist_set_irq(chip->wa, 0);
+ snd_waveartist_set_irq(chip->mpu, 0);
+
+ snd_card_free(pnp_get_card_drvdata(pcard));
+ pnp_set_card_drvdata(pcard, NULL);
+}
+
+#ifdef CONFIG_PM
+static int snd_waveartist_pnp_suspend(struct pnp_card_link *pcard,
+ pm_message_t state)
+{
+ struct snd_card *card = pnp_get_card_drvdata(pcard);
+ struct snd_waveartist *chip = card->private_data;
+
+ snd_waveartist_suspend(card, state);
+
+ /* disable forced IRQs to prevent opps */
+ snd_waveartist_set_irq(chip->wa, 0);
+ snd_waveartist_set_irq(chip->mpu, 0);
+
+ return 0;
+}
+static int snd_waveartist_pnp_resume(struct pnp_card_link *pcard)
+{
+ struct snd_card *card = pnp_get_card_drvdata(pcard);
+ struct snd_waveartist *chip = card->private_data;
+
+ /* re-enable forced IRQs */
+ snd_waveartist_set_irq(chip->wa, chip->irq);
+ snd_waveartist_set_irq(chip->mpu, chip->irq);
+
+ return snd_waveartist_resume(pnp_get_card_drvdata(pcard));
+}
+#endif
+
+static struct pnp_card_driver waveartist_pnpc_driver = {
+ .flags = PNP_DRIVER_RES_DISABLE,
+ .name = "waveartist",
+ .id_table = snd_waveartist_pnpids,
+ .probe = snd_waveartist_pnp_detect,
+ .remove = snd_waveartist_pnp_remove,
+#ifdef CONFIG_PM
+ .suspend = snd_waveartist_pnp_suspend,
+ .resume = snd_waveartist_pnp_resume,
+#endif
+};
+#endif /* CONFIG_PNP */
+
+static int __init alsa_card_waveartist_init(void)
+{
+ int err;
+
+ err = isa_register_driver(&waveartist_isa_driver, SNDRV_CARDS);
+#ifdef CONFIG_PNP
+ if (!err)
+ isa_registered = 1;
+
+ err = pnp_register_card_driver(&waveartist_pnpc_driver);
+ if (!err)
+ pnp_registered = 1;
+
+ if (isa_registered)
+ err = 0;
+#endif
+ return err;
+}
+
+static void __exit alsa_card_waveartist_exit(void)
+{
+#ifdef CONFIG_PNP
+ if (pnp_registered)
+ pnp_unregister_card_driver(&waveartist_pnpc_driver);
+
+ if (isa_registered)
+#endif
+ isa_unregister_driver(&waveartist_isa_driver);
+}
+
+module_init(alsa_card_waveartist_init)
+module_exit(alsa_card_waveartist_exit)
diff --git a/sound/isa/waveartist.h b/sound/isa/waveartist.h
new file mode 100644
index 0000000..72254cf
--- /dev/null
+++ b/sound/isa/waveartist.h
@@ -0,0 +1,74 @@
+/*
+ * Rockwell WaveArtist RWA010 chip register definitions
+ *
+ * Based on OSS WaveArtist driver by Hannu Savolainen
+ */
+
+/* registers */
+#define CMDR 0 /* command (16-bit) */
+#define DATR 2 /* data (for PIO?) (16-bit) */
+#define CTLR 4 /* control */
+#define STATR 5 /* status */
+#define EXPCR1 6 /* expansion control 1 */
+#define EXPCR2 7 /* expansion control 2 */
+#define EXPDAT1 8 /* expansion data 1 (16-bit) */
+#define EXPDAT2 10 /* expansion data 2 (16-bit) */
+#define IRQSTAT 12 /* IRQ status */
+
+/* STATR register bit definitions */
+#define CMD_WE BIT(7) /* CMDR write empty (ready for write) */
+#define CMD_RF BIT(6) /* CMDR read full (ready for read) */
+#define DAT_WE BIT(5) /* DATR write empty (ready for write) */
+#define DAT_RF BIT(4) /* DATR read full (ready for read) */
+#define IRQ_REQ BIT(3) /* IRQ was requested */
+#define DMA1 BIT(2) /* DMA1 IRQ was requested */
+#define DMA0 BIT(1) /* DMA0 IRQ was requested */
+
+/* CTLR register bit definitions */
+#define CMD_WEIE BIT(7) /* CMDR write empty interrupt enable */
+#define CMD_RFIE BIT(6) /* CMDR read full interrupt enable */
+#define DAT_WEIE BIT(5) /* DATR write empty interrupt enable */
+#define DAT_RFIE BIT(4) /* DATR read full interrupt enable */
+#define RESET BIT(3) /* chip reset */
+#define DMA1_IE BIT(2) /* DMA1 interrupt enable */
+#define DMA0_IE BIT(1) /* DMA0 interrupt enable */
+#define IRQ_ACK BIT(0) /* IRQ acknowlege */
+
+/* IRQSTAT register bit definitions */
+#define IRQ_MPU BIT(2) /* MPU-401 */
+#define IRQ_SB BIT(1) /* SB emulation */
+#define IRQ_PCM BIT(0) /* native PCM */
+
+/* commands */
+#define WACMD_GETREV 0x00
+
+#define WACMD_INPUTFORMAT 0x10 /* 0=S8, 1=S16, 2=U8 */
+#define WACMD_INPUTCHANNELS 0x11 /* 1=mono, 2=Stereo */
+#define WACMD_INPUTSPEED 0x12 /* sampling rate */
+#define WACMD_INPUTDMA 0x13 /* 0=8bit, 1=16bit, 2=PIO */
+#define WACMD_INPUTSIZE 0x14 /* samples to interrupt */
+#define WACMD_INPUTSTART 0x15 /* start ADC */
+#define WACMD_INPUTPAUSE 0x16 /* pause ADC */
+#define WACMD_INPUTSTOP 0x17 /* stop ADC */
+#define WACMD_INPUTRESUME 0x18 /* resume ADC */
+#define WACMD_INPUTPIO 0x19 /* PIO ADC */
+
+#define WACMD_OUTPUTFORMAT 0x20 /* 0=S8, 1=S16, 2=U8 */
+#define WACMD_OUTPUTCHANNELS 0x21 /* 1=mono, 2=stereo */
+#define WACMD_OUTPUTSPEED 0x22 /* sampling rate */
+#define WACMD_OUTPUTDMA 0x23 /* 0=8bit, 1=16bit, 2=PIO */
+#define WACMD_OUTPUTSIZE 0x24 /* samples to interrupt */
+#define WACMD_OUTPUTSTART 0x25 /* start DAC */
+#define WACMD_OUTPUTPAUSE 0x26 /* pause DAC */
+#define WACMD_OUTPUTSTOP 0x27 /* stop DAC */
+#define WACMD_OUTPUTRESUME 0x28 /* resume DAC */
+#define WACMD_OUTPUTPIO 0x29 /* PIO DAC */
+
+#define WACMD_GET_LEVEL 0x30 /* read mixer reg */
+#define WACMD_SET_LEVEL 0x31 /* set mixer regs (10..19) */
+#define WACMD_SET_MIXER 0x32 /* set mixer regs (0..9) */
+#define WACMD_RST_MIXER 0x33 /* mixer reset */
+#define WACMD_SET_MONO 0x34 /* set mono mode (|0x000=L, |0x100=R) */
+
+enum wa_format { WA_FMT_S8 = 0, WA_FMT_S16, WA_FMT_U8 };
+enum wa_dma { WA_DMA_8BIT = 0, WA_DMA_16BIT, WA_DMA_PIO };
--
Ondrej Zary
