Skip to content

L
linux
Commit e571f594 authored by Takashi Iwai's avatar Takashi Iwai Committed by Jaroslav Kysela
Browse files
Options

[ALSA] Remove xxx_t typedefs: PCI ES1938 

Modules: ES1938 driver

Remove xxx_t typedefs from the PCI ES1938 driver.
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent eb3414b4
Hide whitespace changes
Inline Side-by-side
Showing with 173 additions and 147 deletions
sound/pci/es1938.c
View file @ e571f594
...@@ -191,11 +191,9 @@ MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard."); ...@@ -191,11 +191,9 @@ MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
*/ */
typedef struct _snd_es1938 es1938_t;
#define SAVED_REG_SIZE 32 /* max. number of registers to save */ #define SAVED_REG_SIZE 32 /* max. number of registers to save */
struct _snd_es1938 { struct es1938 {
int irq; int irq;
unsigned long io_port; unsigned long io_port;
...@@ -208,19 +206,18 @@ struct _snd_es1938 { ...@@ -208,19 +206,18 @@ struct _snd_es1938 {
unsigned char irqmask; unsigned char irqmask;
unsigned char revision; unsigned char revision;
snd_kcontrol_t *hw_volume; struct snd_kcontrol *hw_volume;
snd_kcontrol_t *hw_switch; struct snd_kcontrol *hw_switch;
snd_kcontrol_t *master_volume; struct snd_kcontrol *master_volume;
snd_kcontrol_t *master_switch; struct snd_kcontrol *master_switch;
struct pci_dev *pci; struct pci_dev *pci;
snd_card_t *card; struct snd_card *card;
snd_pcm_t *pcm; struct snd_pcm *pcm;
snd_pcm_substream_t *capture_substream; struct snd_pcm_substream *capture_substream;
snd_pcm_substream_t *playback1_substream; struct snd_pcm_substream *playback1_substream;
snd_pcm_substream_t *playback2_substream; struct snd_pcm_substream *playback2_substream;
snd_kmixer_t *mixer; struct snd_rawmidi *rmidi;
snd_rawmidi_t *rmidi;
unsigned int dma1_size; unsigned int dma1_size;
unsigned int dma2_size; unsigned int dma2_size;
...@@ -232,7 +229,7 @@ struct _snd_es1938 { ...@@ -232,7 +229,7 @@ struct _snd_es1938 {
spinlock_t reg_lock; spinlock_t reg_lock;
spinlock_t mixer_lock; spinlock_t mixer_lock;
snd_info_entry_t *proc_entry; struct snd_info_entry *proc_entry;
#ifdef SUPPORT_JOYSTICK #ifdef SUPPORT_JOYSTICK
struct gameport *gameport; struct gameport *gameport;
...@@ -259,7 +256,7 @@ MODULE_DEVICE_TABLE(pci, snd_es1938_ids); ...@@ -259,7 +256,7 @@ MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Write to a mixer register * Write to a mixer register
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val) static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val)
{ {
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&chip->mixer_lock, flags); spin_lock_irqsave(&chip->mixer_lock, flags);
...@@ -274,7 +271,7 @@ static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned c ...@@ -274,7 +271,7 @@ static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned c
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Read from a mixer register * Read from a mixer register
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg) static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
{ {
int data; int data;
unsigned long flags; unsigned long flags;
...@@ -291,7 +288,8 @@ static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg) ...@@ -291,7 +288,8 @@ static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Write to some bits of a mixer register (return old value) * Write to some bits of a mixer register (return old value)
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
unsigned char mask, unsigned char val)
{ {
unsigned long flags; unsigned long flags;
unsigned char old, new, oval; unsigned char old, new, oval;
...@@ -314,7 +312,7 @@ static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned cha ...@@ -314,7 +312,7 @@ static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned cha
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Write command to Controller Registers * Write command to Controller Registers
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd) static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
{ {
int i; int i;
unsigned char v; unsigned char v;
...@@ -330,7 +328,7 @@ static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd) ...@@ -330,7 +328,7 @@ static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Read the Read Data Buffer * Read the Read Data Buffer
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static int snd_es1938_get_byte(es1938_t *chip) static int snd_es1938_get_byte(struct es1938 *chip)
{ {
int i; int i;
unsigned char v; unsigned char v;
...@@ -344,7 +342,7 @@ static int snd_es1938_get_byte(es1938_t *chip) ...@@ -344,7 +342,7 @@ static int snd_es1938_get_byte(es1938_t *chip)
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Write value cmd register * Write value cmd register
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val) static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val)
{ {
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&chip->reg_lock, flags); spin_lock_irqsave(&chip->reg_lock, flags);
...@@ -359,7 +357,7 @@ static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char va ...@@ -359,7 +357,7 @@ static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char va
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Read data from cmd register and return it * Read data from cmd register and return it
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg) static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
{ {
unsigned char val; unsigned char val;
unsigned long flags; unsigned long flags;
...@@ -377,7 +375,8 @@ static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg) ...@@ -377,7 +375,8 @@ static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Write data to cmd register and return old value * Write data to cmd register and return old value
* -----------------------------------------------------------------*/ * -----------------------------------------------------------------*/
static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask,
unsigned char val)
{ {
unsigned long flags; unsigned long flags;
unsigned char old, new, oval; unsigned char old, new, oval;
...@@ -402,7 +401,7 @@ static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask ...@@ -402,7 +401,7 @@ static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask
/* -------------------------------------------------------------------- /* --------------------------------------------------------------------
* Reset the chip * Reset the chip
* --------------------------------------------------------------------*/ * --------------------------------------------------------------------*/
static void snd_es1938_reset(es1938_t *chip) static void snd_es1938_reset(struct es1938 *chip)
{ {
int i; int i;
...@@ -441,13 +440,13 @@ static void snd_es1938_reset(es1938_t *chip) ...@@ -441,13 +440,13 @@ static void snd_es1938_reset(es1938_t *chip)
/* -------------------------------------------------------------------- /* --------------------------------------------------------------------
* Reset the FIFOs * Reset the FIFOs
* --------------------------------------------------------------------*/ * --------------------------------------------------------------------*/
static void snd_es1938_reset_fifo(es1938_t *chip) static void snd_es1938_reset_fifo(struct es1938 *chip)
{ {
outb(2, SLSB_REG(chip, RESET)); outb(2, SLSB_REG(chip, RESET));
outb(0, SLSB_REG(chip, RESET)); outb(0, SLSB_REG(chip, RESET));
} }
static ratnum_t clocks[2] = { static struct snd_ratnum clocks[2] = {
{ {
.num = 793800, .num = 793800,
.den_min = 1, .den_min = 1,
...@@ -462,18 +461,18 @@ static ratnum_t clocks[2] = { ...@@ -462,18 +461,18 @@ static ratnum_t clocks[2] = {
} }
}; };
static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
.nrats = 2, .nrats = 2,
.rats = clocks, .rats = clocks,
}; };
static void snd_es1938_rate_set(es1938_t *chip, static void snd_es1938_rate_set(struct es1938 *chip,
snd_pcm_substream_t *substream, struct snd_pcm_substream *substream,
int mode) int mode)
{ {
unsigned int bits, div0; unsigned int bits, div0;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
if (runtime->rate_num == clocks[0].num) if (runtime->rate_num == clocks[0].num)
bits = 128 - runtime->rate_den; bits = 128 - runtime->rate_den;
else else
...@@ -495,7 +494,7 @@ static void snd_es1938_rate_set(es1938_t *chip, ...@@ -495,7 +494,7 @@ static void snd_es1938_rate_set(es1938_t *chip,
* Configure Solo1 builtin DMA Controller * Configure Solo1 builtin DMA Controller
* --------------------------------------------------------------------*/ * --------------------------------------------------------------------*/
static void snd_es1938_playback1_setdma(es1938_t *chip) static void snd_es1938_playback1_setdma(struct es1938 *chip)
{ {
outb(0x00, SLIO_REG(chip, AUDIO2MODE)); outb(0x00, SLIO_REG(chip, AUDIO2MODE));
outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR)); outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
...@@ -503,7 +502,7 @@ static void snd_es1938_playback1_setdma(es1938_t *chip) ...@@ -503,7 +502,7 @@ static void snd_es1938_playback1_setdma(es1938_t *chip)
outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT)); outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
} }
static void snd_es1938_playback2_setdma(es1938_t *chip) static void snd_es1938_playback2_setdma(struct es1938 *chip)
{ {
/* Enable DMA controller */ /* Enable DMA controller */
outb(0xc4, SLDM_REG(chip, DMACOMMAND)); outb(0xc4, SLDM_REG(chip, DMACOMMAND));
...@@ -518,7 +517,7 @@ static void snd_es1938_playback2_setdma(es1938_t *chip) ...@@ -518,7 +517,7 @@ static void snd_es1938_playback2_setdma(es1938_t *chip)
outb(0, SLDM_REG(chip, DMAMASK)); outb(0, SLDM_REG(chip, DMAMASK));
} }
static void snd_es1938_capture_setdma(es1938_t *chip) static void snd_es1938_capture_setdma(struct es1938 *chip)
{ {
/* Enable DMA controller */ /* Enable DMA controller */
outb(0xc4, SLDM_REG(chip, DMACOMMAND)); outb(0xc4, SLDM_REG(chip, DMACOMMAND));
...@@ -538,10 +537,10 @@ static void snd_es1938_capture_setdma(es1938_t *chip) ...@@ -538,10 +537,10 @@ static void snd_es1938_capture_setdma(es1938_t *chip)
* *** PCM part *** * *** PCM part ***
*/ */
static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream, static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
int val; int val;
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
...@@ -561,10 +560,10 @@ static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream, ...@@ -561,10 +560,10 @@ static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
return 0; return 0;
} }
static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream, static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_RESUME:
...@@ -591,10 +590,10 @@ static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream, ...@@ -591,10 +590,10 @@ static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
return 0; return 0;
} }
static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream, static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
int val; int val;
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
...@@ -614,7 +613,7 @@ static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream, ...@@ -614,7 +613,7 @@ static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream,
return 0; return 0;
} }
static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream, static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
switch (substream->number) { switch (substream->number) {
...@@ -630,10 +629,10 @@ static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream, ...@@ -630,10 +629,10 @@ static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
/* -------------------------------------------------------------------- /* --------------------------------------------------------------------
* First channel for Extended Mode Audio 1 ADC Operation * First channel for Extended Mode Audio 1 ADC Operation
* --------------------------------------------------------------------*/ * --------------------------------------------------------------------*/
static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream) static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int u, is8, mono; int u, is8, mono;
unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int size = snd_pcm_lib_buffer_bytes(substream);
unsigned int count = snd_pcm_lib_period_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream);
...@@ -678,10 +677,10 @@ static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream) ...@@ -678,10 +677,10 @@ static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
/* ------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------
* Second Audio channel DAC Operation * Second Audio channel DAC Operation
* ------------------------------------------------------------------------------*/ * ------------------------------------------------------------------------------*/
static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream) static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int u, is8, mono; int u, is8, mono;
unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int size = snd_pcm_lib_buffer_bytes(substream);
unsigned int count = snd_pcm_lib_period_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream);
...@@ -706,7 +705,8 @@ static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream) ...@@ -706,7 +705,8 @@ static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8); snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
/* initialize and configure Audio 2 DAC */ /* initialize and configure Audio 2 DAC */
snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1)); snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) |
(mono ? 0 : 2) | (is8 ? 0 : 1));
/* program DMA */ /* program DMA */
snd_es1938_playback1_setdma(chip); snd_es1938_playback1_setdma(chip);
...@@ -714,10 +714,10 @@ static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream) ...@@ -714,10 +714,10 @@ static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream) static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int u, is8, mono; int u, is8, mono;
unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int size = snd_pcm_lib_buffer_bytes(substream);
unsigned int count = snd_pcm_lib_period_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream);
...@@ -756,7 +756,7 @@ static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream) ...@@ -756,7 +756,7 @@ static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream) static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream)
{ {
switch (substream->number) { switch (substream->number) {
case 0: case 0:
...@@ -768,9 +768,9 @@ static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream) ...@@ -768,9 +768,9 @@ static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
return -EINVAL; return -EINVAL;
} }
static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
size_t ptr; size_t ptr;
size_t old, new; size_t old, new;
#if 1 #if 1
...@@ -785,9 +785,9 @@ static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substr ...@@ -785,9 +785,9 @@ static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substr
return ptr >> chip->dma1_shift; return ptr >> chip->dma1_shift;
} }
static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
size_t ptr; size_t ptr;
#if 1 #if 1
ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT)); ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
...@@ -797,9 +797,9 @@ static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * subs ...@@ -797,9 +797,9 @@ static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * subs
return ptr >> chip->dma2_shift; return ptr >> chip->dma2_shift;
} }
static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
size_t ptr; size_t ptr;
size_t old, new; size_t old, new;
#if 1 #if 1
...@@ -814,7 +814,7 @@ static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * subs ...@@ -814,7 +814,7 @@ static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * subs
return ptr >> chip->dma1_shift; return ptr >> chip->dma1_shift;
} }
static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream) static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream)
{ {
switch (substream->number) { switch (substream->number) {
case 0: case 0:
...@@ -826,14 +826,14 @@ static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substr ...@@ -826,14 +826,14 @@ static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substr
return -EINVAL; return -EINVAL;
} }
static int snd_es1938_capture_copy(snd_pcm_substream_t *substream, static int snd_es1938_capture_copy(struct snd_pcm_substream *substream,
int channel, int channel,
snd_pcm_uframes_t pos, snd_pcm_uframes_t pos,
void __user *dst, void __user *dst,
snd_pcm_uframes_t count) snd_pcm_uframes_t count)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
pos <<= chip->dma1_shift; pos <<= chip->dma1_shift;
count <<= chip->dma1_shift; count <<= chip->dma1_shift;
snd_assert(pos + count <= chip->dma1_size, return -EINVAL); snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
...@@ -852,8 +852,8 @@ static int snd_es1938_capture_copy(snd_pcm_substream_t *substream, ...@@ -852,8 +852,8 @@ static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
/* /*
* buffer management * buffer management
*/ */
static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream, static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
int err; int err;
...@@ -863,7 +863,7 @@ static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream, ...@@ -863,7 +863,7 @@ static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
return 0; return 0;
} }
static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream) static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream)
{ {
return snd_pcm_lib_free_pages(substream); return snd_pcm_lib_free_pages(substream);
} }
...@@ -871,11 +871,12 @@ static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream) ...@@ -871,11 +871,12 @@ static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Audio1 Capture (ADC) * Audio1 Capture (ADC)
* ----------------------------------------------------------------------*/ * ----------------------------------------------------------------------*/
static snd_pcm_hardware_t snd_es1938_capture = static struct snd_pcm_hardware snd_es1938_capture =
{ {
.info = (SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER), SNDRV_PCM_INFO_BLOCK_TRANSFER),
.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
.rate_min = 6000, .rate_min = 6000,
.rate_max = 48000, .rate_max = 48000,
...@@ -892,12 +893,13 @@ static snd_pcm_hardware_t snd_es1938_capture = ...@@ -892,12 +893,13 @@ static snd_pcm_hardware_t snd_es1938_capture =
/* ----------------------------------------------------------------------- /* -----------------------------------------------------------------------
* Audio2 Playback (DAC) * Audio2 Playback (DAC)
* -----------------------------------------------------------------------*/ * -----------------------------------------------------------------------*/
static snd_pcm_hardware_t snd_es1938_playback = static struct snd_pcm_hardware snd_es1938_playback =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
SNDRV_PCM_INFO_MMAP_VALID), SNDRV_PCM_INFO_MMAP_VALID),
.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
.rate_min = 6000, .rate_min = 6000,
.rate_max = 48000, .rate_max = 48000,
...@@ -911,10 +913,10 @@ static snd_pcm_hardware_t snd_es1938_playback = ...@@ -911,10 +913,10 @@ static snd_pcm_hardware_t snd_es1938_playback =
.fifo_size = 256, .fifo_size = 256,
}; };
static int snd_es1938_capture_open(snd_pcm_substream_t * substream) static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
if (chip->playback2_substream) if (chip->playback2_substream)
return -EAGAIN; return -EAGAIN;
...@@ -926,10 +928,10 @@ static int snd_es1938_capture_open(snd_pcm_substream_t * substream) ...@@ -926,10 +928,10 @@ static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_es1938_playback_open(snd_pcm_substream_t * substream) static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
switch (substream->number) { switch (substream->number) {
case 0: case 0:
...@@ -951,17 +953,17 @@ static int snd_es1938_playback_open(snd_pcm_substream_t * substream) ...@@ -951,17 +953,17 @@ static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_es1938_capture_close(snd_pcm_substream_t * substream) static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
chip->capture_substream = NULL; chip->capture_substream = NULL;
return 0; return 0;
} }
static int snd_es1938_playback_close(snd_pcm_substream_t * substream) static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
{ {
es1938_t *chip = snd_pcm_substream_chip(substream); struct es1938 *chip = snd_pcm_substream_chip(substream);
switch (substream->number) { switch (substream->number) {
case 0: case 0:
...@@ -977,7 +979,7 @@ static int snd_es1938_playback_close(snd_pcm_substream_t * substream) ...@@ -977,7 +979,7 @@ static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static snd_pcm_ops_t snd_es1938_playback_ops = { static struct snd_pcm_ops snd_es1938_playback_ops = {
.open = snd_es1938_playback_open, .open = snd_es1938_playback_open,
.close = snd_es1938_playback_close, .close = snd_es1938_playback_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
...@@ -988,7 +990,7 @@ static snd_pcm_ops_t snd_es1938_playback_ops = { ...@@ -988,7 +990,7 @@ static snd_pcm_ops_t snd_es1938_playback_ops = {
.pointer = snd_es1938_playback_pointer, .pointer = snd_es1938_playback_pointer,
}; };
static snd_pcm_ops_t snd_es1938_capture_ops = { static struct snd_pcm_ops snd_es1938_capture_ops = {
.open = snd_es1938_capture_open, .open = snd_es1938_capture_open,
.close = snd_es1938_capture_close, .close = snd_es1938_capture_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
...@@ -1000,9 +1002,9 @@ static snd_pcm_ops_t snd_es1938_capture_ops = { ...@@ -1000,9 +1002,9 @@ static snd_pcm_ops_t snd_es1938_capture_ops = {
.copy = snd_es1938_capture_copy, .copy = snd_es1938_capture_copy,
}; };
static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device) static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device)
{ {
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0) if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
...@@ -1026,7 +1028,8 @@ static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device) ...@@ -1026,7 +1028,8 @@ static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device)
* *** Mixer part *** * *** Mixer part ***
*/ */
static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
static char *texts[8] = { static char *texts[8] = {
"Mic", "Mic Master", "CD", "AOUT", "Mic", "Mic Master", "CD", "AOUT",
...@@ -1042,16 +1045,18 @@ static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * u ...@@ -1042,16 +1045,18 @@ static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * u
return 0; return 0;
} }
static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07; ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
return 0; return 0;
} }
static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
unsigned char val = ucontrol->value.enumerated.item[0]; unsigned char val = ucontrol->value.enumerated.item[0];
if (val > 7) if (val > 7)
...@@ -1059,7 +1064,8 @@ static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ...@@ -1059,7 +1064,8 @@ static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *
return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val; return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
} }
static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1; uinfo->count = 1;
...@@ -1068,17 +1074,19 @@ static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_ ...@@ -1068,17 +1074,19 @@ static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_
return 0; return 0;
} }
static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
unsigned char val = snd_es1938_mixer_read(chip, 0x50); unsigned char val = snd_es1938_mixer_read(chip, 0x50);
ucontrol->value.integer.value[0] = !!(val & 8); ucontrol->value.integer.value[0] = !!(val & 8);
return 0; return 0;
} }
static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
unsigned char oval, nval; unsigned char oval, nval;
int change; int change;
nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04; nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
...@@ -1091,7 +1099,8 @@ static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_ ...@@ -1091,7 +1099,8 @@ static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_
return change; return change;
} }
static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2; uinfo->count = 2;
...@@ -1100,15 +1109,17 @@ static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info ...@@ -1100,15 +1109,17 @@ static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info
return 0; return 0;
} }
static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f; ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f; ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
return 0; return 0;
} }
static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 2; uinfo->count = 2;
...@@ -1117,24 +1128,25 @@ static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info ...@@ -1117,24 +1128,25 @@ static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info
return 0; return 0;
} }
static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40); ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40); ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
return 0; return 0;
} }
static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol) static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
chip->master_volume = NULL; chip->master_volume = NULL;
chip->master_switch = NULL; chip->master_switch = NULL;
chip->hw_volume = NULL; chip->hw_volume = NULL;
chip->hw_switch = NULL; chip->hw_switch = NULL;
} }
static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg, static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
unsigned char mask, unsigned char val) unsigned char mask, unsigned char val)
{ {
if (reg < 0xa0) if (reg < 0xa0)
...@@ -1143,7 +1155,7 @@ static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg, ...@@ -1143,7 +1155,7 @@ static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg,
return snd_es1938_bits(chip, reg, mask, val); return snd_es1938_bits(chip, reg, mask, val);
} }
static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg) static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
{ {
if (reg < 0xa0) if (reg < 0xa0)
return snd_es1938_mixer_read(chip, reg); return snd_es1938_mixer_read(chip, reg);
...@@ -1157,7 +1169,8 @@ static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg) ...@@ -1157,7 +1169,8 @@ static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg)
.get = snd_es1938_get_single, .put = snd_es1938_put_single, \ .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
.private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
int mask = (kcontrol->private_value >> 16) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff;
...@@ -1168,9 +1181,10 @@ static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t ...@@ -1168,9 +1181,10 @@ static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
int reg = kcontrol->private_value & 0xff; int reg = kcontrol->private_value & 0xff;
int shift = (kcontrol->private_value >> 8) & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff;
int mask = (kcontrol->private_value >> 16) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff;
...@@ -1184,9 +1198,10 @@ static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t ...@@ -1184,9 +1198,10 @@ static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
int reg = kcontrol->private_value & 0xff; int reg = kcontrol->private_value & 0xff;
int shift = (kcontrol->private_value >> 8) & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff;
int mask = (kcontrol->private_value >> 16) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff;
...@@ -1207,7 +1222,8 @@ static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t ...@@ -1207,7 +1222,8 @@ static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
.get = snd_es1938_get_double, .put = snd_es1938_put_double, \ .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
.private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
int mask = (kcontrol->private_value >> 24) & 0xff; int mask = (kcontrol->private_value >> 24) & 0xff;
...@@ -1218,9 +1234,10 @@ static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t ...@@ -1218,9 +1234,10 @@ static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
int left_reg = kcontrol->private_value & 0xff; int left_reg = kcontrol->private_value & 0xff;
int right_reg = (kcontrol->private_value >> 8) & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff;
int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_left = (kcontrol->private_value >> 16) & 0x07;
...@@ -1243,9 +1260,10 @@ static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t ...@@ -1243,9 +1260,10 @@ static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{ {
es1938_t *chip = snd_kcontrol_chip(kcontrol); struct es1938 *chip = snd_kcontrol_chip(kcontrol);
int left_reg = kcontrol->private_value & 0xff; int left_reg = kcontrol->private_value & 0xff;
int right_reg = (kcontrol->private_value >> 8) & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff;
int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_left = (kcontrol->private_value >> 16) & 0x07;
...@@ -1278,7 +1296,7 @@ static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t ...@@ -1278,7 +1296,7 @@ static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return change; return change;
} }
static snd_kcontrol_new_t snd_es1938_controls[] = { static struct snd_kcontrol_new snd_es1938_controls[] = {
ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0), ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1), ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
{ {
...@@ -1341,7 +1359,7 @@ ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0) ...@@ -1341,7 +1359,7 @@ ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
/* /*
* initialize the chip - used by resume callback, too * initialize the chip - used by resume callback, too
*/ */
static void snd_es1938_chip_init(es1938_t *chip) static void snd_es1938_chip_init(struct es1938 *chip)
{ {
/* reset chip */ /* reset chip */
snd_es1938_reset(chip); snd_es1938_reset(chip);
...@@ -1380,9 +1398,9 @@ static unsigned char saved_regs[SAVED_REG_SIZE+1] = { ...@@ -1380,9 +1398,9 @@ static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
}; };
static int es1938_suspend(snd_card_t *card, pm_message_t state) static int es1938_suspend(struct snd_card *card, pm_message_t state)
{ {
es1938_t *chip = card->pm_private_data; struct es1938 *chip = card->pm_private_data;
unsigned char *s, *d; unsigned char *s, *d;
snd_pcm_suspend_all(chip->pcm); snd_pcm_suspend_all(chip->pcm);
...@@ -1393,19 +1411,19 @@ static int es1938_suspend(snd_card_t *card, pm_message_t state) ...@@ -1393,19 +1411,19 @@ static int es1938_suspend(snd_card_t *card, pm_message_t state)
outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */ outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
if (chip->irq >= 0) if (chip->irq >= 0)
free_irq(chip->irq, (void *)chip); free_irq(chip->irq, chip);
pci_disable_device(chip->pci); pci_disable_device(chip->pci);
return 0; return 0;
} }
static int es1938_resume(snd_card_t *card) static int es1938_resume(struct snd_card *card)
{ {
es1938_t *chip = card->pm_private_data; struct es1938 *chip = card->pm_private_data;
unsigned char *s, *d; unsigned char *s, *d;
pci_enable_device(chip->pci); pci_enable_device(chip->pci);
request_irq(chip->pci->irq, snd_es1938_interrupt, request_irq(chip->pci->irq, snd_es1938_interrupt,
SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip); SA_INTERRUPT|SA_SHIRQ, "ES1938", chip);
chip->irq = chip->pci->irq; chip->irq = chip->pci->irq;
snd_es1938_chip_init(chip); snd_es1938_chip_init(chip);
...@@ -1422,7 +1440,7 @@ static int es1938_resume(snd_card_t *card) ...@@ -1422,7 +1440,7 @@ static int es1938_resume(snd_card_t *card)
#endif /* CONFIG_PM */ #endif /* CONFIG_PM */
#ifdef SUPPORT_JOYSTICK #ifdef SUPPORT_JOYSTICK
static int __devinit snd_es1938_create_gameport(es1938_t *chip) static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
{ {
struct gameport *gp; struct gameport *gp;
...@@ -1442,7 +1460,7 @@ static int __devinit snd_es1938_create_gameport(es1938_t *chip) ...@@ -1442,7 +1460,7 @@ static int __devinit snd_es1938_create_gameport(es1938_t *chip)
return 0; return 0;
} }
static void snd_es1938_free_gameport(es1938_t *chip) static void snd_es1938_free_gameport(struct es1938 *chip)
{ {
if (chip->gameport) { if (chip->gameport) {
gameport_unregister_port(chip->gameport); gameport_unregister_port(chip->gameport);
...@@ -1450,11 +1468,11 @@ static void snd_es1938_free_gameport(es1938_t *chip) ...@@ -1450,11 +1468,11 @@ static void snd_es1938_free_gameport(es1938_t *chip)
} }
} }
#else #else
static inline int snd_es1938_create_gameport(es1938_t *chip) { return -ENOSYS; } static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
static inline void snd_es1938_free_gameport(es1938_t *chip) { } static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
#endif /* SUPPORT_JOYSTICK */ #endif /* SUPPORT_JOYSTICK */
static int snd_es1938_free(es1938_t *chip) static int snd_es1938_free(struct es1938 *chip)
{ {
/* disable irqs */ /* disable irqs */
outb(0x00, SLIO_REG(chip, IRQCONTROL)); outb(0x00, SLIO_REG(chip, IRQCONTROL));
...@@ -1464,26 +1482,26 @@ static int snd_es1938_free(es1938_t *chip) ...@@ -1464,26 +1482,26 @@ static int snd_es1938_free(es1938_t *chip)
snd_es1938_free_gameport(chip); snd_es1938_free_gameport(chip);
if (chip->irq >= 0) if (chip->irq >= 0)
free_irq(chip->irq, (void *)chip); free_irq(chip->irq, chip);
pci_release_regions(chip->pci); pci_release_regions(chip->pci);
pci_disable_device(chip->pci); pci_disable_device(chip->pci);
kfree(chip); kfree(chip);
return 0; return 0;
} }
static int snd_es1938_dev_free(snd_device_t *device) static int snd_es1938_dev_free(struct snd_device *device)
{ {
es1938_t *chip = device->device_data; struct es1938 *chip = device->device_data;
return snd_es1938_free(chip); return snd_es1938_free(chip);
} }
static int __devinit snd_es1938_create(snd_card_t * card, static int __devinit snd_es1938_create(struct snd_card *card,
struct pci_dev * pci, struct pci_dev * pci,
es1938_t ** rchip) struct es1938 ** rchip)
{ {
es1938_t *chip; struct es1938 *chip;
int err; int err;
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_es1938_dev_free, .dev_free = snd_es1938_dev_free,
}; };
...@@ -1519,7 +1537,8 @@ static int __devinit snd_es1938_create(snd_card_t * card, ...@@ -1519,7 +1537,8 @@ static int __devinit snd_es1938_create(snd_card_t * card,
chip->vc_port = pci_resource_start(pci, 2); chip->vc_port = pci_resource_start(pci, 2);
chip->mpu_port = pci_resource_start(pci, 3); chip->mpu_port = pci_resource_start(pci, 3);
chip->game_port = pci_resource_start(pci, 4); chip->game_port = pci_resource_start(pci, 4);
if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) { if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
"ES1938", chip)) {
snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
snd_es1938_free(chip); snd_es1938_free(chip);
return -EBUSY; return -EBUSY;
...@@ -1552,7 +1571,7 @@ static int __devinit snd_es1938_create(snd_card_t * card, ...@@ -1552,7 +1571,7 @@ static int __devinit snd_es1938_create(snd_card_t * card,
* -------------------------------------------------------------------- */ * -------------------------------------------------------------------- */
static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{ {
es1938_t *chip = dev_id; struct es1938 *chip = dev_id;
unsigned char status, audiostatus; unsigned char status, audiostatus;
int handled = 0; int handled = 0;
...@@ -1565,9 +1584,12 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r ...@@ -1565,9 +1584,12 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r
if (status & 0x10) { if (status & 0x10) {
#if 0 #if 0
printk("Es1938debug - AUDIO channel 1 interrupt\n"); printk("Es1938debug - AUDIO channel 1 interrupt\n");
printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT))); printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR))); inw(SLDM_REG(chip, DMACOUNT)));
printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS))); printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
inl(SLDM_REG(chip, DMAADDR)));
printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
inl(SLDM_REG(chip, DMASTATUS)));
#endif #endif
/* clear irq */ /* clear irq */
handled = 1; handled = 1;
...@@ -1582,8 +1604,10 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r ...@@ -1582,8 +1604,10 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r
if (status & 0x20) { if (status & 0x20) {
#if 0 #if 0
printk("Es1938debug - AUDIO channel 2 interrupt\n"); printk("Es1938debug - AUDIO channel 2 interrupt\n");
printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT))); printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR))); inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
inl(SLIO_REG(chip, AUDIO2DMAADDR)));
#endif #endif
/* clear irq */ /* clear irq */
...@@ -1600,8 +1624,10 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r ...@@ -1600,8 +1624,10 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id); snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id); snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
if (!split) { if (!split) {
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id); snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id); &chip->master_switch->id);
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
&chip->master_volume->id);
} }
/* ack interrupt */ /* ack interrupt */
snd_es1938_mixer_write(chip, 0x66, 0x00); snd_es1938_mixer_write(chip, 0x66, 0x00);
...@@ -1623,9 +1649,9 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r ...@@ -1623,9 +1649,9 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r
#define ES1938_DMA_SIZE 64 #define ES1938_DMA_SIZE 64
static int __devinit snd_es1938_mixer(es1938_t *chip) static int __devinit snd_es1938_mixer(struct es1938 *chip)
{ {
snd_card_t *card; struct snd_card *card;
unsigned int idx; unsigned int idx;
int err; int err;
...@@ -1634,7 +1660,7 @@ static int __devinit snd_es1938_mixer(es1938_t *chip) ...@@ -1634,7 +1660,7 @@ static int __devinit snd_es1938_mixer(es1938_t *chip)
strcpy(card->mixername, "ESS Solo-1"); strcpy(card->mixername, "ESS Solo-1");
for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) { for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip); kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
switch (idx) { switch (idx) {
case 0: case 0:
...@@ -1665,9 +1691,9 @@ static int __devinit snd_es1938_probe(struct pci_dev *pci, ...@@ -1665,9 +1691,9 @@ static int __devinit snd_es1938_probe(struct pci_dev *pci,
const struct pci_device_id *pci_id) const struct pci_device_id *pci_id)
{ {
static int dev; static int dev;
snd_card_t *card; struct snd_card *card;
es1938_t *chip; struct es1938 *chip;
opl3_t *opl3; struct snd_opl3 *opl3;
int idx, err; int idx, err;
if (dev >= SNDRV_CARDS) if (dev >= SNDRV_CARDS)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7