OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[ALSA] Remove xxx_t typedefs: ISA AD1848 

Modules: AD1848 driver

Remove xxx_t typedefs from the ISA AD1848 driver.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2005-11-17 14:29:37 +01:00 committed by Jaroslav Kysela
parent cbdd0dd15f
commit c8ff6647bb
3 changed files with 105 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/sound/ad1848.h
View File

@ -127,7 +127,7 @@
#define AD1848_THINKPAD_CTL_PORT2 0x15e9 #define AD1848_THINKPAD_CTL_PORT2 0x15e9
#define AD1848_THINKPAD_CS4248_ENABLE_BIT 0x02 #define AD1848_THINKPAD_CS4248_ENABLE_BIT 0x02
struct _snd_ad1848 { struct snd_ad1848 {
unsigned long port; /* i/o port */ unsigned long port; /* i/o port */
struct resource *res_port; struct resource *res_port;
int irq; /* IRQ line */ int irq; /* IRQ line */
@ -137,10 +137,10 @@ struct _snd_ad1848 {
unsigned short hardware; /* see to AD1848_HW_XXXX */ unsigned short hardware; /* see to AD1848_HW_XXXX */
unsigned short single_dma:1; /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */ unsigned short single_dma:1; /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */
snd_pcm_t *pcm; struct snd_pcm *pcm;
snd_pcm_substream_t *playback_substream; struct snd_pcm_substream *playback_substream;
snd_pcm_substream_t *capture_substream; struct snd_pcm_substream *capture_substream;
snd_card_t *card; struct snd_card *card;
unsigned char image[32]; /* SGalaxy needs an access to extended registers */ unsigned char image[32]; /* SGalaxy needs an access to extended registers */
int mce_bit; int mce_bit;
@ -152,21 +152,19 @@ struct _snd_ad1848 {
struct semaphore open_mutex; struct semaphore open_mutex;
}; };
typedef struct _snd_ad1848 ad1848_t;
/* exported functions */ /* exported functions */
void snd_ad1848_out(ad1848_t *chip, unsigned char reg, unsigned char value); void snd_ad1848_out(struct snd_ad1848 *chip, unsigned char reg, unsigned char value);
int snd_ad1848_create(snd_card_t * card, int snd_ad1848_create(struct snd_card *card,
unsigned long port, unsigned long port,
int irq, int dma, int irq, int dma,
unsigned short hardware, unsigned short hardware,
ad1848_t ** chip); struct snd_ad1848 ** chip);
int snd_ad1848_pcm(ad1848_t * chip, int device, snd_pcm_t **rpcm); int snd_ad1848_pcm(struct snd_ad1848 * chip, int device, struct snd_pcm **rpcm);
const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction); const struct snd_pcm_ops *snd_ad1848_get_pcm_ops(int direction);
int snd_ad1848_mixer(ad1848_t * chip); int snd_ad1848_mixer(struct snd_ad1848 * chip);
/* exported mixer stuffs */ /* exported mixer stuffs */
enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE }; enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE };
@ -176,7 +174,7 @@ enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE };
#define AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) \ #define AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) \
((left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22)) ((left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22))
int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value); int snd_ad1848_add_ctl(struct snd_ad1848 *chip, const char *name, int index, int type, unsigned long value);
/* for ease of use */ /* for ease of use */
struct ad1848_mix_elem { struct ad1848_mix_elem {
@ -198,7 +196,7 @@ struct ad1848_mix_elem {
.type = AD1848_MIX_DOUBLE, \ .type = AD1848_MIX_DOUBLE, \
.private_value = AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) } .private_value = AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) }
static inline int snd_ad1848_add_ctl_elem(ad1848_t *chip, const struct ad1848_mix_elem *c) static inline int snd_ad1848_add_ctl_elem(struct snd_ad1848 *chip, const struct ad1848_mix_elem *c)
{ {
return snd_ad1848_add_ctl(chip, c->name, c->index, c->type, c->private_value); return snd_ad1848_add_ctl(chip, c->name, c->index, c->type, c->private_value);
} }

8
sound/isa/ad1848/ad1848.c
View File

@ -60,14 +60,14 @@ MODULE_PARM_DESC(dma1, "DMA1 # for AD1848 driver.");
module_param_array(thinkpad, bool, NULL, 0444); module_param_array(thinkpad, bool, NULL, 0444);
MODULE_PARM_DESC(thinkpad, "Enable only for the onboard CS4248 of IBM Thinkpad 360/750/755 series."); MODULE_PARM_DESC(thinkpad, "Enable only for the onboard CS4248 of IBM Thinkpad 360/750/755 series.");
static snd_card_t *snd_ad1848_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static struct snd_card *snd_ad1848_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
static int __init snd_card_ad1848_probe(int dev) static int __init snd_card_ad1848_probe(int dev)
{ {
snd_card_t *card; struct snd_card *card;
ad1848_t *chip; struct snd_ad1848 *chip;
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
if (port[dev] == SNDRV_AUTO_PORT) { if (port[dev] == SNDRV_AUTO_PORT) {

176
sound/isa/ad1848/ad1848_lib.c
View File

@ -69,7 +69,7 @@ static unsigned int rates[14] = {
27042, 32000, 33075, 37800, 44100, 48000 27042, 32000, 33075, 37800, 44100, 48000
}; };
static snd_pcm_hw_constraint_list_t hw_constraints_rates = { static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
.count = 14, .count = 14,
.list = rates, .list = rates,
.mask = 0, .mask = 0,
@ -99,7 +99,7 @@ static unsigned char snd_ad1848_original_image[16] =
* Basic I/O functions * Basic I/O functions
*/ */
void snd_ad1848_out(ad1848_t *chip, void snd_ad1848_out(struct snd_ad1848 *chip,
unsigned char reg, unsigned char reg,
unsigned char value) unsigned char value)
{ {
@ -119,7 +119,7 @@ void snd_ad1848_out(ad1848_t *chip,
#endif #endif
} }
static void snd_ad1848_dout(ad1848_t *chip, static void snd_ad1848_dout(struct snd_ad1848 *chip,
unsigned char reg, unsigned char value) unsigned char reg, unsigned char value)
{ {
int timeout; int timeout;
@ -131,7 +131,7 @@ static void snd_ad1848_dout(ad1848_t *chip,
mb(); mb();
} }
static unsigned char snd_ad1848_in(ad1848_t *chip, unsigned char reg) static unsigned char snd_ad1848_in(struct snd_ad1848 *chip, unsigned char reg)
{ {
int timeout; int timeout;
@ -148,7 +148,7 @@ static unsigned char snd_ad1848_in(ad1848_t *chip, unsigned char reg)
#if 0 #if 0
static void snd_ad1848_debug(ad1848_t *chip) static void snd_ad1848_debug(struct snd_ad1848 *chip)
{ {
printk("AD1848 REGS: INDEX = 0x%02x ", inb(AD1848P(chip, REGSEL))); printk("AD1848 REGS: INDEX = 0x%02x ", inb(AD1848P(chip, REGSEL)));
printk(" STATUS = 0x%02x\n", inb(AD1848P(chip, STATUS))); printk(" STATUS = 0x%02x\n", inb(AD1848P(chip, STATUS)));
@ -176,7 +176,7 @@ static void snd_ad1848_debug(ad1848_t *chip)
* AD1848 detection / MCE routines * AD1848 detection / MCE routines
*/ */
static void snd_ad1848_mce_up(ad1848_t *chip) static void snd_ad1848_mce_up(struct snd_ad1848 *chip)
{ {
unsigned long flags; unsigned long flags;
int timeout; int timeout;
@ -197,7 +197,7 @@ static void snd_ad1848_mce_up(ad1848_t *chip)
spin_unlock_irqrestore(&chip->reg_lock, flags); spin_unlock_irqrestore(&chip->reg_lock, flags);
} }
static void snd_ad1848_mce_down(ad1848_t *chip) static void snd_ad1848_mce_down(struct snd_ad1848 *chip)
{ {
unsigned long flags; unsigned long flags;
int timeout; int timeout;
@ -279,7 +279,7 @@ static unsigned int snd_ad1848_get_count(unsigned char format,
return size; return size;
} }
static int snd_ad1848_trigger(ad1848_t *chip, unsigned char what, static int snd_ad1848_trigger(struct snd_ad1848 *chip, unsigned char what,
int channel, int cmd) int channel, int cmd)
{ {
int result = 0; int result = 0;
@ -324,7 +324,7 @@ static unsigned char snd_ad1848_get_rate(unsigned int rate)
return freq_bits[13]; return freq_bits[13];
} }
static int snd_ad1848_ioctl(snd_pcm_substream_t * substream, static int snd_ad1848_ioctl(struct snd_pcm_substream *substream,
unsigned int cmd, void *arg) unsigned int cmd, void *arg)
{ {
return snd_pcm_lib_ioctl(substream, cmd, arg); return snd_pcm_lib_ioctl(substream, cmd, arg);
@ -348,7 +348,7 @@ static unsigned char snd_ad1848_get_format(int format, int channels)
return rformat; return rformat;
} }
static void snd_ad1848_calibrate_mute(ad1848_t *chip, int mute) static void snd_ad1848_calibrate_mute(struct snd_ad1848 *chip, int mute)
{ {
unsigned long flags; unsigned long flags;
@ -372,7 +372,7 @@ static void snd_ad1848_calibrate_mute(ad1848_t *chip, int mute)
spin_unlock_irqrestore(&chip->reg_lock, flags); spin_unlock_irqrestore(&chip->reg_lock, flags);
} }
static void snd_ad1848_set_data_format(ad1848_t *chip, snd_pcm_hw_params_t *hw_params) static void snd_ad1848_set_data_format(struct snd_ad1848 *chip, struct snd_pcm_hw_params *hw_params)
{ {
if (hw_params == NULL) { if (hw_params == NULL) {
chip->image[AD1848_DATA_FORMAT] = 0x20; chip->image[AD1848_DATA_FORMAT] = 0x20;
@ -384,7 +384,7 @@ static void snd_ad1848_set_data_format(ad1848_t *chip, snd_pcm_hw_params_t *hw_p
// snd_printk(">>> pmode = 0x%x, dfr = 0x%x\n", pstr->mode, chip->image[AD1848_DATA_FORMAT]); // snd_printk(">>> pmode = 0x%x, dfr = 0x%x\n", pstr->mode, chip->image[AD1848_DATA_FORMAT]);
} }
static int snd_ad1848_open(ad1848_t *chip, unsigned int mode) static int snd_ad1848_open(struct snd_ad1848 *chip, unsigned int mode)
{ {
unsigned long flags; unsigned long flags;
@ -438,7 +438,7 @@ static int snd_ad1848_open(ad1848_t *chip, unsigned int mode)
return 0; return 0;
} }
static void snd_ad1848_close(ad1848_t *chip) static void snd_ad1848_close(struct snd_ad1848 *chip)
{ {
unsigned long flags; unsigned long flags;
@ -479,24 +479,24 @@ static void snd_ad1848_close(ad1848_t *chip)
* ok.. exported functions.. * ok.. exported functions..
*/ */
static int snd_ad1848_playback_trigger(snd_pcm_substream_t * substream, static int snd_ad1848_playback_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
return snd_ad1848_trigger(chip, AD1848_PLAYBACK_ENABLE, SNDRV_PCM_STREAM_PLAYBACK, cmd); return snd_ad1848_trigger(chip, AD1848_PLAYBACK_ENABLE, SNDRV_PCM_STREAM_PLAYBACK, cmd);
} }
static int snd_ad1848_capture_trigger(snd_pcm_substream_t * substream, static int snd_ad1848_capture_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
return snd_ad1848_trigger(chip, AD1848_CAPTURE_ENABLE, SNDRV_PCM_STREAM_CAPTURE, cmd); return snd_ad1848_trigger(chip, AD1848_CAPTURE_ENABLE, SNDRV_PCM_STREAM_CAPTURE, cmd);
} }
static int snd_ad1848_playback_hw_params(snd_pcm_substream_t * substream, static int snd_ad1848_playback_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
unsigned long flags; unsigned long flags;
int err; int err;
@ -513,15 +513,15 @@ static int snd_ad1848_playback_hw_params(snd_pcm_substream_t * substream,
return 0; return 0;
} }
static int snd_ad1848_playback_hw_free(snd_pcm_substream_t * substream) static int snd_ad1848_playback_hw_free(struct snd_pcm_substream *substream)
{ {
return snd_pcm_lib_free_pages(substream); return snd_pcm_lib_free_pages(substream);
} }
static int snd_ad1848_playback_prepare(snd_pcm_substream_t * substream) static int snd_ad1848_playback_prepare(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags; unsigned long flags;
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);
@ -537,10 +537,10 @@ static int snd_ad1848_playback_prepare(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_ad1848_capture_hw_params(snd_pcm_substream_t * substream, static int snd_ad1848_capture_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
unsigned long flags; unsigned long flags;
int err; int err;
@ -557,15 +557,15 @@ static int snd_ad1848_capture_hw_params(snd_pcm_substream_t * substream,
return 0; return 0;
} }
static int snd_ad1848_capture_hw_free(snd_pcm_substream_t * substream) static int snd_ad1848_capture_hw_free(struct snd_pcm_substream *substream)
{ {
return snd_pcm_lib_free_pages(substream); return snd_pcm_lib_free_pages(substream);
} }
static int snd_ad1848_capture_prepare(snd_pcm_substream_t * substream) static int snd_ad1848_capture_prepare(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags; unsigned long flags;
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);
@ -583,7 +583,7 @@ static int snd_ad1848_capture_prepare(snd_pcm_substream_t * substream)
static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{ {
ad1848_t *chip = dev_id; struct snd_ad1848 *chip = dev_id;
if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream && if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream &&
(chip->mode & AD1848_MODE_RUNNING)) (chip->mode & AD1848_MODE_RUNNING))
@ -595,9 +595,9 @@ static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *r
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static snd_pcm_uframes_t snd_ad1848_playback_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_ad1848_playback_pointer(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
size_t ptr; size_t ptr;
if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_PLAYBACK_ENABLE)) if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_PLAYBACK_ENABLE))
@ -606,9 +606,9 @@ static snd_pcm_uframes_t snd_ad1848_playback_pointer(snd_pcm_substream_t * subst
return bytes_to_frames(substream->runtime, ptr); return bytes_to_frames(substream->runtime, ptr);
} }
static snd_pcm_uframes_t snd_ad1848_capture_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_ad1848_capture_pointer(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
size_t ptr; size_t ptr;
if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_CAPTURE_ENABLE)) if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_CAPTURE_ENABLE))
@ -621,7 +621,7 @@ static snd_pcm_uframes_t snd_ad1848_capture_pointer(snd_pcm_substream_t * substr
*/ */
static void snd_ad1848_thinkpad_twiddle(ad1848_t *chip, int on) { static void snd_ad1848_thinkpad_twiddle(struct snd_ad1848 *chip, int on) {
int tmp; int tmp;
@ -642,9 +642,9 @@ static void snd_ad1848_thinkpad_twiddle(ad1848_t *chip, int on) {
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM
static int snd_ad1848_suspend(snd_card_t *card, pm_message_t state) static int snd_ad1848_suspend(struct snd_card *card, pm_message_t state)
{ {
ad1848_t *chip = card->pm_private_data; struct snd_ad1848 *chip = card->pm_private_data;
snd_pcm_suspend_all(chip->pcm); snd_pcm_suspend_all(chip->pcm);
/* FIXME: save registers? */ /* FIXME: save registers? */
@ -655,9 +655,9 @@ static int snd_ad1848_suspend(snd_card_t *card, pm_message_t state)
return 0; return 0;
} }
static int snd_ad1848_resume(snd_card_t *card) static int snd_ad1848_resume(struct snd_card *card)
{ {
ad1848_t *chip = card->pm_private_data; struct snd_ad1848 *chip = card->pm_private_data;
if (chip->thinkpad_flag) if (chip->thinkpad_flag)
snd_ad1848_thinkpad_twiddle(chip, 1); snd_ad1848_thinkpad_twiddle(chip, 1);
@ -668,7 +668,7 @@ static int snd_ad1848_resume(snd_card_t *card)
} }
#endif /* CONFIG_PM */ #endif /* CONFIG_PM */
static int snd_ad1848_probe(ad1848_t * chip) static int snd_ad1848_probe(struct snd_ad1848 * chip)
{ {
unsigned long flags; unsigned long flags;
int i, id, rev, ad1847; int i, id, rev, ad1847;
@ -748,7 +748,7 @@ static int snd_ad1848_probe(ad1848_t * chip)
*/ */
static snd_pcm_hardware_t snd_ad1848_playback = static struct snd_pcm_hardware snd_ad1848_playback =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_MMAP_VALID), SNDRV_PCM_INFO_MMAP_VALID),
@ -767,7 +767,7 @@ static snd_pcm_hardware_t snd_ad1848_playback =
.fifo_size = 0, .fifo_size = 0,
}; };
static snd_pcm_hardware_t snd_ad1848_capture = static struct snd_pcm_hardware snd_ad1848_capture =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_MMAP_VALID), SNDRV_PCM_INFO_MMAP_VALID),
@ -790,10 +790,10 @@ static snd_pcm_hardware_t snd_ad1848_capture =
*/ */
static int snd_ad1848_playback_open(snd_pcm_substream_t * substream) static int snd_ad1848_playback_open(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int err; int err;
if ((err = snd_ad1848_open(chip, AD1848_MODE_PLAY)) < 0) if ((err = snd_ad1848_open(chip, AD1848_MODE_PLAY)) < 0)
@ -806,10 +806,10 @@ static int snd_ad1848_playback_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_ad1848_capture_open(snd_pcm_substream_t * substream) static int snd_ad1848_capture_open(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int err; int err;
if ((err = snd_ad1848_open(chip, AD1848_MODE_CAPTURE)) < 0) if ((err = snd_ad1848_open(chip, AD1848_MODE_CAPTURE)) < 0)
@ -822,9 +822,9 @@ static int snd_ad1848_capture_open(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_ad1848_playback_close(snd_pcm_substream_t * substream) static int snd_ad1848_playback_close(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
chip->mode &= ~AD1848_MODE_PLAY; chip->mode &= ~AD1848_MODE_PLAY;
chip->playback_substream = NULL; chip->playback_substream = NULL;
@ -832,9 +832,9 @@ static int snd_ad1848_playback_close(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_ad1848_capture_close(snd_pcm_substream_t * substream) static int snd_ad1848_capture_close(struct snd_pcm_substream *substream)
{ {
ad1848_t *chip = snd_pcm_substream_chip(substream); struct snd_ad1848 *chip = snd_pcm_substream_chip(substream);
chip->mode &= ~AD1848_MODE_CAPTURE; chip->mode &= ~AD1848_MODE_CAPTURE;
chip->capture_substream = NULL; chip->capture_substream = NULL;
@ -842,7 +842,7 @@ static int snd_ad1848_capture_close(snd_pcm_substream_t * substream)
return 0; return 0;
} }
static int snd_ad1848_free(ad1848_t *chip) static int snd_ad1848_free(struct snd_ad1848 *chip)
{ {
release_and_free_resource(chip->res_port); release_and_free_resource(chip->res_port);
if (chip->irq >= 0) if (chip->irq >= 0)
@ -855,13 +855,13 @@ static int snd_ad1848_free(ad1848_t *chip)
return 0; return 0;
} }
static int snd_ad1848_dev_free(snd_device_t *device) static int snd_ad1848_dev_free(struct snd_device *device)
{ {
ad1848_t *chip = device->device_data; struct snd_ad1848 *chip = device->device_data;
return snd_ad1848_free(chip); return snd_ad1848_free(chip);
} }
static const char *snd_ad1848_chip_id(ad1848_t *chip) static const char *snd_ad1848_chip_id(struct snd_ad1848 *chip)
{ {
switch (chip->hardware) { switch (chip->hardware) {
case AD1848_HW_AD1847: return "AD1847"; case AD1848_HW_AD1847: return "AD1847";
@ -872,16 +872,16 @@ static const char *snd_ad1848_chip_id(ad1848_t *chip)
} }
} }
int snd_ad1848_create(snd_card_t * card, int snd_ad1848_create(struct snd_card *card,
unsigned long port, unsigned long port,
int irq, int dma, int irq, int dma,
unsigned short hardware, unsigned short hardware,
ad1848_t ** rchip) struct snd_ad1848 ** rchip)
{ {
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_ad1848_dev_free, .dev_free = snd_ad1848_dev_free,
}; };
ad1848_t *chip; struct snd_ad1848 *chip;
int err; int err;
*rchip = NULL; *rchip = NULL;
@ -937,7 +937,7 @@ int snd_ad1848_create(snd_card_t * card,
return 0; return 0;
} }
static snd_pcm_ops_t snd_ad1848_playback_ops = { static struct snd_pcm_ops snd_ad1848_playback_ops = {
.open = snd_ad1848_playback_open, .open = snd_ad1848_playback_open,
.close = snd_ad1848_playback_close, .close = snd_ad1848_playback_close,
.ioctl = snd_ad1848_ioctl, .ioctl = snd_ad1848_ioctl,
@ -948,7 +948,7 @@ static snd_pcm_ops_t snd_ad1848_playback_ops = {
.pointer = snd_ad1848_playback_pointer, .pointer = snd_ad1848_playback_pointer,
}; };
static snd_pcm_ops_t snd_ad1848_capture_ops = { static struct snd_pcm_ops snd_ad1848_capture_ops = {
.open = snd_ad1848_capture_open, .open = snd_ad1848_capture_open,
.close = snd_ad1848_capture_close, .close = snd_ad1848_capture_close,
.ioctl = snd_ad1848_ioctl, .ioctl = snd_ad1848_ioctl,
@ -959,9 +959,9 @@ static snd_pcm_ops_t snd_ad1848_capture_ops = {
.pointer = snd_ad1848_capture_pointer, .pointer = snd_ad1848_capture_pointer,
}; };
int snd_ad1848_pcm(ad1848_t *chip, int device, snd_pcm_t **rpcm) int snd_ad1848_pcm(struct snd_ad1848 *chip, int device, struct snd_pcm **rpcm)
{ {
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
if ((err = snd_pcm_new(chip->card, "AD1848", device, 1, 1, &pcm)) < 0) if ((err = snd_pcm_new(chip->card, "AD1848", device, 1, 1, &pcm)) < 0)
@ -984,7 +984,7 @@ int snd_ad1848_pcm(ad1848_t *chip, int device, snd_pcm_t **rpcm)
return 0; return 0;
} }
const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction) const struct snd_pcm_ops *snd_ad1848_get_pcm_ops(int direction)
{ {
return direction == SNDRV_PCM_STREAM_PLAYBACK ? return direction == SNDRV_PCM_STREAM_PLAYBACK ?
&snd_ad1848_playback_ops : &snd_ad1848_capture_ops; &snd_ad1848_playback_ops : &snd_ad1848_capture_ops;
@ -994,7 +994,7 @@ const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction)
* MIXER part * MIXER part
*/ */
static int snd_ad1848_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_ad1848_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{ {
static char *texts[4] = { static char *texts[4] = {
"Line", "Aux", "Mic", "Mix" "Line", "Aux", "Mic", "Mix"
@ -1009,9 +1009,9 @@ static int snd_ad1848_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * u
return 0; return 0;
} }
static int snd_ad1848_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&chip->reg_lock, flags); spin_lock_irqsave(&chip->reg_lock, flags);
@ -1021,9 +1021,9 @@ static int snd_ad1848_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *
return 0; return 0;
} }
static int snd_ad1848_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
unsigned short left, right; unsigned short left, right;
int change; int change;
@ -1044,7 +1044,7 @@ static int snd_ad1848_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *
return change; return change;
} }
static int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_ad1848_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;
@ -1055,9 +1055,9 @@ static int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
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;
@ -1072,9 +1072,9 @@ static int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
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;
@ -1095,7 +1095,7 @@ static int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return change; return change;
} }
static int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_ad1848_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;
@ -1106,9 +1106,9 @@ static int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
return 0; return 0;
} }
static int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
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;
@ -1128,9 +1128,9 @@ static int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
return 0; return 0;
} }
static int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) static int snd_ad1848_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{ {
ad1848_t *chip = snd_kcontrol_chip(kcontrol); struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol);
unsigned long flags; unsigned long flags;
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;
@ -1167,9 +1167,9 @@ static int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
/* /*
*/ */
int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value) int snd_ad1848_add_ctl(struct snd_ad1848 *chip, const char *name, int index, int type, unsigned long value)
{ {
static snd_kcontrol_new_t newctls[] = { static struct snd_kcontrol_new newctls[] = {
[AD1848_MIX_SINGLE] = { [AD1848_MIX_SINGLE] = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.info = snd_ad1848_info_single, .info = snd_ad1848_info_single,
@ -1189,7 +1189,7 @@ int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, un
.put = snd_ad1848_put_mux, .put = snd_ad1848_put_mux,
}, },
}; };
snd_kcontrol_t *ctl; struct snd_kcontrol *ctl;
int err; int err;
ctl = snd_ctl_new1(&newctls[type], chip); ctl = snd_ctl_new1(&newctls[type], chip);
@ -1222,10 +1222,10 @@ AD1848_SINGLE("Loopback Capture Switch", 0, AD1848_LOOPBACK, 0, 1, 0),
AD1848_SINGLE("Loopback Capture Volume", 0, AD1848_LOOPBACK, 1, 63, 0) AD1848_SINGLE("Loopback Capture Volume", 0, AD1848_LOOPBACK, 1, 63, 0)
}; };
int snd_ad1848_mixer(ad1848_t *chip) int snd_ad1848_mixer(struct snd_ad1848 *chip)
{ {
snd_card_t *card; struct snd_card *card;
snd_pcm_t *pcm; struct snd_pcm *pcm;
unsigned int idx; unsigned int idx;
int err; int err;