mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Uwe Kleine-König](/assets/img/avatar_default.png)
The .remove() callback for a platform driver returns an int which makes many driver authors wrongly assume it's possible to do error handling by returning an error code. However the value returned is (mostly) ignored and this typically results in resource leaks. To improve here there is a quest to make the remove callback return void. In the first step of this quest all drivers are converted to .remove_new() which already returns void. Trivially convert this driver from always returning zero in the remove callback to the void returning variant. Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Acked-by: Takashi Iwai <tiwai@suse.de> Acked-by: Nicolas Ferre <nicolas.ferre@microchip.com> Link: https://lore.kernel.org/r/20230315150745.67084-9-u.kleine-koenig@pengutronix.de Signed-off-by: Mark Brown <broonie@kernel.org>
926 lines
25 KiB
C
926 lines
25 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Sound driver for Silicon Graphics O2 Workstations A/V board audio.
|
|
*
|
|
* Copyright 2003 Vivien Chappelier <vivien.chappelier@linux-mips.org>
|
|
* Copyright 2008 Thomas Bogendoerfer <tsbogend@alpha.franken.de>
|
|
* Mxier part taken from mace_audio.c:
|
|
* Copyright 2007 Thorben Jändling <tj.trevelyan@gmail.com>
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/io.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <asm/ip32/ip32_ints.h>
|
|
#include <asm/ip32/mace.h>
|
|
|
|
#include <sound/core.h>
|
|
#include <sound/control.h>
|
|
#include <sound/pcm.h>
|
|
#define SNDRV_GET_ID
|
|
#include <sound/initval.h>
|
|
#include <sound/ad1843.h>
|
|
|
|
|
|
MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>");
|
|
MODULE_DESCRIPTION("SGI O2 Audio");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
|
|
static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
|
|
|
|
module_param(index, int, 0444);
|
|
MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard.");
|
|
module_param(id, charp, 0444);
|
|
MODULE_PARM_DESC(id, "ID string for SGI O2 soundcard.");
|
|
|
|
|
|
#define AUDIO_CONTROL_RESET BIT(0) /* 1: reset audio interface */
|
|
#define AUDIO_CONTROL_CODEC_PRESENT BIT(1) /* 1: codec detected */
|
|
|
|
#define CODEC_CONTROL_WORD_SHIFT 0
|
|
#define CODEC_CONTROL_READ BIT(16)
|
|
#define CODEC_CONTROL_ADDRESS_SHIFT 17
|
|
|
|
#define CHANNEL_CONTROL_RESET BIT(10) /* 1: reset channel */
|
|
#define CHANNEL_DMA_ENABLE BIT(9) /* 1: enable DMA transfer */
|
|
#define CHANNEL_INT_THRESHOLD_DISABLED (0 << 5) /* interrupt disabled */
|
|
#define CHANNEL_INT_THRESHOLD_25 (1 << 5) /* int on buffer >25% full */
|
|
#define CHANNEL_INT_THRESHOLD_50 (2 << 5) /* int on buffer >50% full */
|
|
#define CHANNEL_INT_THRESHOLD_75 (3 << 5) /* int on buffer >75% full */
|
|
#define CHANNEL_INT_THRESHOLD_EMPTY (4 << 5) /* int on buffer empty */
|
|
#define CHANNEL_INT_THRESHOLD_NOT_EMPTY (5 << 5) /* int on buffer !empty */
|
|
#define CHANNEL_INT_THRESHOLD_FULL (6 << 5) /* int on buffer empty */
|
|
#define CHANNEL_INT_THRESHOLD_NOT_FULL (7 << 5) /* int on buffer !empty */
|
|
|
|
#define CHANNEL_RING_SHIFT 12
|
|
#define CHANNEL_RING_SIZE (1 << CHANNEL_RING_SHIFT)
|
|
#define CHANNEL_RING_MASK (CHANNEL_RING_SIZE - 1)
|
|
|
|
#define CHANNEL_LEFT_SHIFT 40
|
|
#define CHANNEL_RIGHT_SHIFT 8
|
|
|
|
struct snd_sgio2audio_chan {
|
|
int idx;
|
|
struct snd_pcm_substream *substream;
|
|
int pos;
|
|
snd_pcm_uframes_t size;
|
|
spinlock_t lock;
|
|
};
|
|
|
|
/* definition of the chip-specific record */
|
|
struct snd_sgio2audio {
|
|
struct snd_card *card;
|
|
|
|
/* codec */
|
|
struct snd_ad1843 ad1843;
|
|
spinlock_t ad1843_lock;
|
|
|
|
/* channels */
|
|
struct snd_sgio2audio_chan channel[3];
|
|
|
|
/* resources */
|
|
void *ring_base;
|
|
dma_addr_t ring_base_dma;
|
|
};
|
|
|
|
/* AD1843 access */
|
|
|
|
/*
|
|
* read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
|
|
*
|
|
* Returns unsigned register value on success, -errno on failure.
|
|
*/
|
|
static int read_ad1843_reg(void *priv, int reg)
|
|
{
|
|
struct snd_sgio2audio *chip = priv;
|
|
int val;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&chip->ad1843_lock, flags);
|
|
|
|
writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
|
|
CODEC_CONTROL_READ, &mace->perif.audio.codec_control);
|
|
wmb();
|
|
val = readq(&mace->perif.audio.codec_control); /* flush bus */
|
|
udelay(200);
|
|
|
|
val = readq(&mace->perif.audio.codec_read);
|
|
|
|
spin_unlock_irqrestore(&chip->ad1843_lock, flags);
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
* write_ad1843_reg writes the specified value to a 16 bit AD1843 register.
|
|
*/
|
|
static int write_ad1843_reg(void *priv, int reg, int word)
|
|
{
|
|
struct snd_sgio2audio *chip = priv;
|
|
int val;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&chip->ad1843_lock, flags);
|
|
|
|
writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
|
|
(word << CODEC_CONTROL_WORD_SHIFT),
|
|
&mace->perif.audio.codec_control);
|
|
wmb();
|
|
val = readq(&mace->perif.audio.codec_control); /* flush bus */
|
|
udelay(200);
|
|
|
|
spin_unlock_irqrestore(&chip->ad1843_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
static int sgio2audio_gain_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 2;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = ad1843_get_gain_max(&chip->ad1843,
|
|
(int)kcontrol->private_value);
|
|
return 0;
|
|
}
|
|
|
|
static int sgio2audio_gain_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
|
|
int vol;
|
|
|
|
vol = ad1843_get_gain(&chip->ad1843, (int)kcontrol->private_value);
|
|
|
|
ucontrol->value.integer.value[0] = (vol >> 8) & 0xFF;
|
|
ucontrol->value.integer.value[1] = vol & 0xFF;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sgio2audio_gain_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
|
|
int newvol, oldvol;
|
|
|
|
oldvol = ad1843_get_gain(&chip->ad1843, kcontrol->private_value);
|
|
newvol = (ucontrol->value.integer.value[0] << 8) |
|
|
ucontrol->value.integer.value[1];
|
|
|
|
newvol = ad1843_set_gain(&chip->ad1843, kcontrol->private_value,
|
|
newvol);
|
|
|
|
return newvol != oldvol;
|
|
}
|
|
|
|
static int sgio2audio_source_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
static const char * const texts[3] = {
|
|
"Cam Mic", "Mic", "Line"
|
|
};
|
|
return snd_ctl_enum_info(uinfo, 1, 3, texts);
|
|
}
|
|
|
|
static int sgio2audio_source_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.enumerated.item[0] = ad1843_get_recsrc(&chip->ad1843);
|
|
return 0;
|
|
}
|
|
|
|
static int sgio2audio_source_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
|
|
int newsrc, oldsrc;
|
|
|
|
oldsrc = ad1843_get_recsrc(&chip->ad1843);
|
|
newsrc = ad1843_set_recsrc(&chip->ad1843,
|
|
ucontrol->value.enumerated.item[0]);
|
|
|
|
return newsrc != oldsrc;
|
|
}
|
|
|
|
/* dac1/pcm0 mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_pcm0 = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "PCM Playback Volume",
|
|
.index = 0,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_PCM_0,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
/* dac2/pcm1 mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_pcm1 = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "PCM Playback Volume",
|
|
.index = 1,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_PCM_1,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
/* record level mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_reclevel = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Capture Volume",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_RECLEV,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
/* record level source control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_recsource = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Capture Source",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.info = sgio2audio_source_info,
|
|
.get = sgio2audio_source_get,
|
|
.put = sgio2audio_source_put,
|
|
};
|
|
|
|
/* line mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_line = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Line Playback Volume",
|
|
.index = 0,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_LINE,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
/* cd mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_cd = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Line Playback Volume",
|
|
.index = 1,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_LINE_2,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
/* mic mixer control */
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_mic = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Mic Playback Volume",
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
.private_value = AD1843_GAIN_MIC,
|
|
.info = sgio2audio_gain_info,
|
|
.get = sgio2audio_gain_get,
|
|
.put = sgio2audio_gain_put,
|
|
};
|
|
|
|
|
|
static int snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip)
|
|
{
|
|
int err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_pcm0, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_pcm1, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_reclevel, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_recsource, chip));
|
|
if (err < 0)
|
|
return err;
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_line, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_cd, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_ctl_add(chip->card,
|
|
snd_ctl_new1(&sgio2audio_ctrl_mic, chip));
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* low-level audio interface DMA */
|
|
|
|
/* get data out of bounce buffer, count must be a multiple of 32 */
|
|
/* returns 1 if a period has elapsed */
|
|
static int snd_sgio2audio_dma_pull_frag(struct snd_sgio2audio *chip,
|
|
unsigned int ch, unsigned int count)
|
|
{
|
|
int ret;
|
|
unsigned long src_base, src_pos, dst_mask;
|
|
unsigned char *dst_base;
|
|
int dst_pos;
|
|
u64 *src;
|
|
s16 *dst;
|
|
u64 x;
|
|
unsigned long flags;
|
|
struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
|
|
|
|
spin_lock_irqsave(&chip->channel[ch].lock, flags);
|
|
|
|
src_base = (unsigned long) chip->ring_base | (ch << CHANNEL_RING_SHIFT);
|
|
src_pos = readq(&mace->perif.audio.chan[ch].read_ptr);
|
|
dst_base = runtime->dma_area;
|
|
dst_pos = chip->channel[ch].pos;
|
|
dst_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
|
|
|
|
/* check if a period has elapsed */
|
|
chip->channel[ch].size += (count >> 3); /* in frames */
|
|
ret = chip->channel[ch].size >= runtime->period_size;
|
|
chip->channel[ch].size %= runtime->period_size;
|
|
|
|
while (count) {
|
|
src = (u64 *)(src_base + src_pos);
|
|
dst = (s16 *)(dst_base + dst_pos);
|
|
|
|
x = *src;
|
|
dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff;
|
|
dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff;
|
|
|
|
src_pos = (src_pos + sizeof(u64)) & CHANNEL_RING_MASK;
|
|
dst_pos = (dst_pos + 2 * sizeof(s16)) & dst_mask;
|
|
count -= sizeof(u64);
|
|
}
|
|
|
|
writeq(src_pos, &mace->perif.audio.chan[ch].read_ptr); /* in bytes */
|
|
chip->channel[ch].pos = dst_pos;
|
|
|
|
spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
/* put some DMA data in bounce buffer, count must be a multiple of 32 */
|
|
/* returns 1 if a period has elapsed */
|
|
static int snd_sgio2audio_dma_push_frag(struct snd_sgio2audio *chip,
|
|
unsigned int ch, unsigned int count)
|
|
{
|
|
int ret;
|
|
s64 l, r;
|
|
unsigned long dst_base, dst_pos, src_mask;
|
|
unsigned char *src_base;
|
|
int src_pos;
|
|
u64 *dst;
|
|
s16 *src;
|
|
unsigned long flags;
|
|
struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
|
|
|
|
spin_lock_irqsave(&chip->channel[ch].lock, flags);
|
|
|
|
dst_base = (unsigned long)chip->ring_base | (ch << CHANNEL_RING_SHIFT);
|
|
dst_pos = readq(&mace->perif.audio.chan[ch].write_ptr);
|
|
src_base = runtime->dma_area;
|
|
src_pos = chip->channel[ch].pos;
|
|
src_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
|
|
|
|
/* check if a period has elapsed */
|
|
chip->channel[ch].size += (count >> 3); /* in frames */
|
|
ret = chip->channel[ch].size >= runtime->period_size;
|
|
chip->channel[ch].size %= runtime->period_size;
|
|
|
|
while (count) {
|
|
src = (s16 *)(src_base + src_pos);
|
|
dst = (u64 *)(dst_base + dst_pos);
|
|
|
|
l = src[0]; /* sign extend */
|
|
r = src[1]; /* sign extend */
|
|
|
|
*dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) |
|
|
((r & 0x00ffffff) << CHANNEL_RIGHT_SHIFT);
|
|
|
|
dst_pos = (dst_pos + sizeof(u64)) & CHANNEL_RING_MASK;
|
|
src_pos = (src_pos + 2 * sizeof(s16)) & src_mask;
|
|
count -= sizeof(u64);
|
|
}
|
|
|
|
writeq(dst_pos, &mace->perif.audio.chan[ch].write_ptr); /* in bytes */
|
|
chip->channel[ch].pos = src_pos;
|
|
|
|
spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
static int snd_sgio2audio_dma_start(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
|
|
int ch = chan->idx;
|
|
|
|
/* reset DMA channel */
|
|
writeq(CHANNEL_CONTROL_RESET, &mace->perif.audio.chan[ch].control);
|
|
udelay(10);
|
|
writeq(0, &mace->perif.audio.chan[ch].control);
|
|
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
|
|
/* push a full buffer */
|
|
snd_sgio2audio_dma_push_frag(chip, ch, CHANNEL_RING_SIZE - 32);
|
|
}
|
|
/* set DMA to wake on 50% empty and enable interrupt */
|
|
writeq(CHANNEL_DMA_ENABLE | CHANNEL_INT_THRESHOLD_50,
|
|
&mace->perif.audio.chan[ch].control);
|
|
return 0;
|
|
}
|
|
|
|
static int snd_sgio2audio_dma_stop(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
|
|
|
|
writeq(0, &mace->perif.audio.chan[chan->idx].control);
|
|
return 0;
|
|
}
|
|
|
|
static irqreturn_t snd_sgio2audio_dma_in_isr(int irq, void *dev_id)
|
|
{
|
|
struct snd_sgio2audio_chan *chan = dev_id;
|
|
struct snd_pcm_substream *substream;
|
|
struct snd_sgio2audio *chip;
|
|
int count, ch;
|
|
|
|
substream = chan->substream;
|
|
chip = snd_pcm_substream_chip(substream);
|
|
ch = chan->idx;
|
|
|
|
/* empty the ring */
|
|
count = CHANNEL_RING_SIZE -
|
|
readq(&mace->perif.audio.chan[ch].depth) - 32;
|
|
if (snd_sgio2audio_dma_pull_frag(chip, ch, count))
|
|
snd_pcm_period_elapsed(substream);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t snd_sgio2audio_dma_out_isr(int irq, void *dev_id)
|
|
{
|
|
struct snd_sgio2audio_chan *chan = dev_id;
|
|
struct snd_pcm_substream *substream;
|
|
struct snd_sgio2audio *chip;
|
|
int count, ch;
|
|
|
|
substream = chan->substream;
|
|
chip = snd_pcm_substream_chip(substream);
|
|
ch = chan->idx;
|
|
/* fill the ring */
|
|
count = CHANNEL_RING_SIZE -
|
|
readq(&mace->perif.audio.chan[ch].depth) - 32;
|
|
if (snd_sgio2audio_dma_push_frag(chip, ch, count))
|
|
snd_pcm_period_elapsed(substream);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t snd_sgio2audio_error_isr(int irq, void *dev_id)
|
|
{
|
|
struct snd_sgio2audio_chan *chan = dev_id;
|
|
struct snd_pcm_substream *substream;
|
|
|
|
substream = chan->substream;
|
|
snd_sgio2audio_dma_stop(substream);
|
|
snd_sgio2audio_dma_start(substream);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/* PCM part */
|
|
/* PCM hardware definition */
|
|
static const struct snd_pcm_hardware snd_sgio2audio_pcm_hw = {
|
|
.info = (SNDRV_PCM_INFO_MMAP |
|
|
SNDRV_PCM_INFO_MMAP_VALID |
|
|
SNDRV_PCM_INFO_INTERLEAVED |
|
|
SNDRV_PCM_INFO_BLOCK_TRANSFER),
|
|
.formats = SNDRV_PCM_FMTBIT_S16_BE,
|
|
.rates = SNDRV_PCM_RATE_8000_48000,
|
|
.rate_min = 8000,
|
|
.rate_max = 48000,
|
|
.channels_min = 2,
|
|
.channels_max = 2,
|
|
.buffer_bytes_max = 65536,
|
|
.period_bytes_min = 32768,
|
|
.period_bytes_max = 65536,
|
|
.periods_min = 1,
|
|
.periods_max = 1024,
|
|
};
|
|
|
|
/* PCM playback open callback */
|
|
static int snd_sgio2audio_playback1_open(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->hw = snd_sgio2audio_pcm_hw;
|
|
runtime->private_data = &chip->channel[1];
|
|
return 0;
|
|
}
|
|
|
|
static int snd_sgio2audio_playback2_open(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->hw = snd_sgio2audio_pcm_hw;
|
|
runtime->private_data = &chip->channel[2];
|
|
return 0;
|
|
}
|
|
|
|
/* PCM capture open callback */
|
|
static int snd_sgio2audio_capture_open(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->hw = snd_sgio2audio_pcm_hw;
|
|
runtime->private_data = &chip->channel[0];
|
|
return 0;
|
|
}
|
|
|
|
/* PCM close callback */
|
|
static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->private_data = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/* prepare callback */
|
|
static int snd_sgio2audio_pcm_prepare(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
|
|
int ch = chan->idx;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&chip->channel[ch].lock, flags);
|
|
|
|
/* Setup the pseudo-dma transfer pointers. */
|
|
chip->channel[ch].pos = 0;
|
|
chip->channel[ch].size = 0;
|
|
chip->channel[ch].substream = substream;
|
|
|
|
/* set AD1843 format */
|
|
/* hardware format is always S16_LE */
|
|
switch (substream->stream) {
|
|
case SNDRV_PCM_STREAM_PLAYBACK:
|
|
ad1843_setup_dac(&chip->ad1843,
|
|
ch - 1,
|
|
runtime->rate,
|
|
SNDRV_PCM_FORMAT_S16_LE,
|
|
runtime->channels);
|
|
break;
|
|
case SNDRV_PCM_STREAM_CAPTURE:
|
|
ad1843_setup_adc(&chip->ad1843,
|
|
runtime->rate,
|
|
SNDRV_PCM_FORMAT_S16_LE,
|
|
runtime->channels);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
/* trigger callback */
|
|
static int snd_sgio2audio_pcm_trigger(struct snd_pcm_substream *substream,
|
|
int cmd)
|
|
{
|
|
switch (cmd) {
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
/* start the PCM engine */
|
|
snd_sgio2audio_dma_start(substream);
|
|
break;
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
/* stop the PCM engine */
|
|
snd_sgio2audio_dma_stop(substream);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* pointer callback */
|
|
static snd_pcm_uframes_t
|
|
snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
|
|
struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
|
|
|
|
/* get the current hardware pointer */
|
|
return bytes_to_frames(substream->runtime,
|
|
chip->channel[chan->idx].pos);
|
|
}
|
|
|
|
/* operators */
|
|
static const struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
|
|
.open = snd_sgio2audio_playback1_open,
|
|
.close = snd_sgio2audio_pcm_close,
|
|
.prepare = snd_sgio2audio_pcm_prepare,
|
|
.trigger = snd_sgio2audio_pcm_trigger,
|
|
.pointer = snd_sgio2audio_pcm_pointer,
|
|
};
|
|
|
|
static const struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
|
|
.open = snd_sgio2audio_playback2_open,
|
|
.close = snd_sgio2audio_pcm_close,
|
|
.prepare = snd_sgio2audio_pcm_prepare,
|
|
.trigger = snd_sgio2audio_pcm_trigger,
|
|
.pointer = snd_sgio2audio_pcm_pointer,
|
|
};
|
|
|
|
static const struct snd_pcm_ops snd_sgio2audio_capture_ops = {
|
|
.open = snd_sgio2audio_capture_open,
|
|
.close = snd_sgio2audio_pcm_close,
|
|
.prepare = snd_sgio2audio_pcm_prepare,
|
|
.trigger = snd_sgio2audio_pcm_trigger,
|
|
.pointer = snd_sgio2audio_pcm_pointer,
|
|
};
|
|
|
|
/*
|
|
* definitions of capture are omitted here...
|
|
*/
|
|
|
|
/* create a pcm device */
|
|
static int snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip)
|
|
{
|
|
struct snd_pcm *pcm;
|
|
int err;
|
|
|
|
/* create first pcm device with one outputs and one input */
|
|
err = snd_pcm_new(chip->card, "SGI O2 Audio", 0, 1, 1, &pcm);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
pcm->private_data = chip;
|
|
strcpy(pcm->name, "SGI O2 DAC1");
|
|
|
|
/* set operators */
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
|
|
&snd_sgio2audio_playback1_ops);
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
|
|
&snd_sgio2audio_capture_ops);
|
|
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
|
|
|
|
/* create second pcm device with one outputs and no input */
|
|
err = snd_pcm_new(chip->card, "SGI O2 Audio", 1, 1, 0, &pcm);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
pcm->private_data = chip;
|
|
strcpy(pcm->name, "SGI O2 DAC2");
|
|
|
|
/* set operators */
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
|
|
&snd_sgio2audio_playback2_ops);
|
|
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct {
|
|
int idx;
|
|
int irq;
|
|
irqreturn_t (*isr)(int, void *);
|
|
const char *desc;
|
|
} snd_sgio2_isr_table[] = {
|
|
{
|
|
.idx = 0,
|
|
.irq = MACEISA_AUDIO1_DMAT_IRQ,
|
|
.isr = snd_sgio2audio_dma_in_isr,
|
|
.desc = "Capture DMA Channel 0"
|
|
}, {
|
|
.idx = 0,
|
|
.irq = MACEISA_AUDIO1_OF_IRQ,
|
|
.isr = snd_sgio2audio_error_isr,
|
|
.desc = "Capture Overflow"
|
|
}, {
|
|
.idx = 1,
|
|
.irq = MACEISA_AUDIO2_DMAT_IRQ,
|
|
.isr = snd_sgio2audio_dma_out_isr,
|
|
.desc = "Playback DMA Channel 1"
|
|
}, {
|
|
.idx = 1,
|
|
.irq = MACEISA_AUDIO2_MERR_IRQ,
|
|
.isr = snd_sgio2audio_error_isr,
|
|
.desc = "Memory Error Channel 1"
|
|
}, {
|
|
.idx = 2,
|
|
.irq = MACEISA_AUDIO3_DMAT_IRQ,
|
|
.isr = snd_sgio2audio_dma_out_isr,
|
|
.desc = "Playback DMA Channel 2"
|
|
}, {
|
|
.idx = 2,
|
|
.irq = MACEISA_AUDIO3_MERR_IRQ,
|
|
.isr = snd_sgio2audio_error_isr,
|
|
.desc = "Memory Error Channel 2"
|
|
}
|
|
};
|
|
|
|
/* ALSA driver */
|
|
|
|
static int snd_sgio2audio_free(struct snd_sgio2audio *chip)
|
|
{
|
|
int i;
|
|
|
|
/* reset interface */
|
|
writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
|
|
udelay(1);
|
|
writeq(0, &mace->perif.audio.control);
|
|
|
|
/* release IRQ's */
|
|
for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++)
|
|
free_irq(snd_sgio2_isr_table[i].irq,
|
|
&chip->channel[snd_sgio2_isr_table[i].idx]);
|
|
|
|
dma_free_coherent(chip->card->dev, MACEISA_RINGBUFFERS_SIZE,
|
|
chip->ring_base, chip->ring_base_dma);
|
|
|
|
/* release card data */
|
|
kfree(chip);
|
|
return 0;
|
|
}
|
|
|
|
static int snd_sgio2audio_dev_free(struct snd_device *device)
|
|
{
|
|
struct snd_sgio2audio *chip = device->device_data;
|
|
|
|
return snd_sgio2audio_free(chip);
|
|
}
|
|
|
|
static const struct snd_device_ops ops = {
|
|
.dev_free = snd_sgio2audio_dev_free,
|
|
};
|
|
|
|
static int snd_sgio2audio_create(struct snd_card *card,
|
|
struct snd_sgio2audio **rchip)
|
|
{
|
|
struct snd_sgio2audio *chip;
|
|
int i, err;
|
|
|
|
*rchip = NULL;
|
|
|
|
/* check if a codec is attached to the interface */
|
|
/* (Audio or Audio/Video board present) */
|
|
if (!(readq(&mace->perif.audio.control) & AUDIO_CONTROL_CODEC_PRESENT))
|
|
return -ENOENT;
|
|
|
|
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
|
|
if (chip == NULL)
|
|
return -ENOMEM;
|
|
|
|
chip->card = card;
|
|
|
|
chip->ring_base = dma_alloc_coherent(card->dev,
|
|
MACEISA_RINGBUFFERS_SIZE,
|
|
&chip->ring_base_dma, GFP_KERNEL);
|
|
if (chip->ring_base == NULL) {
|
|
printk(KERN_ERR
|
|
"sgio2audio: could not allocate ring buffers\n");
|
|
kfree(chip);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
spin_lock_init(&chip->ad1843_lock);
|
|
|
|
/* initialize channels */
|
|
for (i = 0; i < 3; i++) {
|
|
spin_lock_init(&chip->channel[i].lock);
|
|
chip->channel[i].idx = i;
|
|
}
|
|
|
|
/* allocate IRQs */
|
|
for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) {
|
|
if (request_irq(snd_sgio2_isr_table[i].irq,
|
|
snd_sgio2_isr_table[i].isr,
|
|
0,
|
|
snd_sgio2_isr_table[i].desc,
|
|
&chip->channel[snd_sgio2_isr_table[i].idx])) {
|
|
snd_sgio2audio_free(chip);
|
|
printk(KERN_ERR "sgio2audio: cannot allocate irq %d\n",
|
|
snd_sgio2_isr_table[i].irq);
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
|
|
/* reset the interface */
|
|
writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
|
|
udelay(1);
|
|
writeq(0, &mace->perif.audio.control);
|
|
msleep_interruptible(1); /* give time to recover */
|
|
|
|
/* set ring base */
|
|
writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase);
|
|
|
|
/* attach the AD1843 codec */
|
|
chip->ad1843.read = read_ad1843_reg;
|
|
chip->ad1843.write = write_ad1843_reg;
|
|
chip->ad1843.chip = chip;
|
|
|
|
/* initialize the AD1843 codec */
|
|
err = ad1843_init(&chip->ad1843);
|
|
if (err < 0) {
|
|
snd_sgio2audio_free(chip);
|
|
return err;
|
|
}
|
|
|
|
err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
|
|
if (err < 0) {
|
|
snd_sgio2audio_free(chip);
|
|
return err;
|
|
}
|
|
*rchip = chip;
|
|
return 0;
|
|
}
|
|
|
|
static int snd_sgio2audio_probe(struct platform_device *pdev)
|
|
{
|
|
struct snd_card *card;
|
|
struct snd_sgio2audio *chip;
|
|
int err;
|
|
|
|
err = snd_card_new(&pdev->dev, index, id, THIS_MODULE, 0, &card);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_sgio2audio_create(card, &chip);
|
|
if (err < 0) {
|
|
snd_card_free(card);
|
|
return err;
|
|
}
|
|
|
|
err = snd_sgio2audio_new_pcm(chip);
|
|
if (err < 0) {
|
|
snd_card_free(card);
|
|
return err;
|
|
}
|
|
err = snd_sgio2audio_new_mixer(chip);
|
|
if (err < 0) {
|
|
snd_card_free(card);
|
|
return err;
|
|
}
|
|
|
|
strcpy(card->driver, "SGI O2 Audio");
|
|
strcpy(card->shortname, "SGI O2 Audio");
|
|
sprintf(card->longname, "%s irq %i-%i",
|
|
card->shortname,
|
|
MACEISA_AUDIO1_DMAT_IRQ,
|
|
MACEISA_AUDIO3_MERR_IRQ);
|
|
|
|
err = snd_card_register(card);
|
|
if (err < 0) {
|
|
snd_card_free(card);
|
|
return err;
|
|
}
|
|
platform_set_drvdata(pdev, card);
|
|
return 0;
|
|
}
|
|
|
|
static void snd_sgio2audio_remove(struct platform_device *pdev)
|
|
{
|
|
struct snd_card *card = platform_get_drvdata(pdev);
|
|
|
|
snd_card_free(card);
|
|
}
|
|
|
|
static struct platform_driver sgio2audio_driver = {
|
|
.probe = snd_sgio2audio_probe,
|
|
.remove_new = snd_sgio2audio_remove,
|
|
.driver = {
|
|
.name = "sgio2audio",
|
|
}
|
|
};
|
|
|
|
module_platform_driver(sgio2audio_driver);
|