2019-05-27 00:55:05 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-07-12 14:43:50 -06:00
|
|
|
/*
|
|
|
|
* 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 cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2011-07-15 10:38:28 -06:00
|
|
|
#include <linux/module.h>
|
2008-07-12 14:43:50 -06:00
|
|
|
|
|
|
|
#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");
|
|
|
|
MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}");
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2014-10-20 10:15:16 -06:00
|
|
|
static const char * const texts[3] = {
|
2008-07-12 14:43:50 -06:00
|
|
|
"Cam Mic", "Mic", "Line"
|
|
|
|
};
|
2014-10-20 10:15:16 -06:00
|
|
|
return snd_ctl_enum_info(uinfo, 1, 3, texts);
|
2008-07-12 14:43:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_pcm0 = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_pcm1 = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_reclevel = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_recsource = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_line = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_cd = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-05-27 08:46:15 -06:00
|
|
|
static const struct snd_kcontrol_new sgio2audio_ctrl_mic = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2012-12-06 10:35:15 -07:00
|
|
|
static int snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip)
|
2008-07-12 14:43:50 -06:00
|
|
|
{
|
|
|
|
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 */
|
2017-08-17 03:15:53 -06:00
|
|
|
static const struct snd_pcm_hardware snd_sgio2audio_pcm_hw = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2017-08-18 01:45:14 -06:00
|
|
|
static const struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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,
|
|
|
|
};
|
|
|
|
|
2017-08-18 01:45:14 -06:00
|
|
|
static const struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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,
|
|
|
|
};
|
|
|
|
|
2017-08-18 01:45:14 -06:00
|
|
|
static const struct snd_pcm_ops snd_sgio2audio_capture_ops = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.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 */
|
2012-12-06 10:35:15 -07:00
|
|
|
static int snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip)
|
2008-07-12 14:43:50 -06:00
|
|
|
{
|
|
|
|
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);
|
2019-12-09 02:48:49 -07:00
|
|
|
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
|
2008-07-12 14:43:50 -06:00
|
|
|
|
|
|
|
/* 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);
|
2019-12-09 02:48:49 -07:00
|
|
|
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
|
2008-07-12 14:43:50 -06:00
|
|
|
|
|
|
|
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]);
|
|
|
|
|
2019-02-01 01:48:01 -07:00
|
|
|
dma_free_coherent(chip->card->dev, MACEISA_RINGBUFFERS_SIZE,
|
2008-07-12 14:43:50 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2020-01-03 01:16:28 -07:00
|
|
|
static const struct snd_device_ops ops = {
|
2008-07-12 14:43:50 -06:00
|
|
|
.dev_free = snd_sgio2audio_dev_free,
|
|
|
|
};
|
|
|
|
|
2012-12-06 10:35:15 -07:00
|
|
|
static int snd_sgio2audio_create(struct snd_card *card,
|
|
|
|
struct snd_sgio2audio **rchip)
|
2008-07-12 14:43:50 -06:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2017-11-11 12:02:07 -07:00
|
|
|
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
|
2008-07-12 14:43:50 -06:00
|
|
|
if (chip == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
chip->card = card;
|
|
|
|
|
2019-02-01 01:48:01 -07:00
|
|
|
chip->ring_base = dma_alloc_coherent(card->dev,
|
|
|
|
MACEISA_RINGBUFFERS_SIZE,
|
|
|
|
&chip->ring_base_dma, GFP_KERNEL);
|
2008-07-12 14:43:50 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:15 -07:00
|
|
|
static int snd_sgio2audio_probe(struct platform_device *pdev)
|
2008-07-12 14:43:50 -06:00
|
|
|
{
|
|
|
|
struct snd_card *card;
|
|
|
|
struct snd_sgio2audio *chip;
|
|
|
|
int err;
|
|
|
|
|
2014-01-29 06:34:47 -07:00
|
|
|
err = snd_card_new(&pdev->dev, index, id, THIS_MODULE, 0, &card);
|
2008-12-28 08:45:02 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2008-07-12 14:43:50 -06:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:15 -07:00
|
|
|
static int snd_sgio2audio_remove(struct platform_device *pdev)
|
2008-07-12 14:43:50 -06:00
|
|
|
{
|
|
|
|
struct snd_card *card = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
snd_card_free(card);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver sgio2audio_driver = {
|
|
|
|
.probe = snd_sgio2audio_probe,
|
2012-12-06 10:35:15 -07:00
|
|
|
.remove = snd_sgio2audio_remove,
|
2008-07-12 14:43:50 -06:00
|
|
|
.driver = {
|
|
|
|
.name = "sgio2audio",
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-11-24 03:47:25 -07:00
|
|
|
module_platform_driver(sgio2audio_driver);
|