adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 03:36:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

[ALSA] Remove xxx_t typedefs: VXdriver

Browse source 
Remove xxx_t typedefs from the VXdriver codes
(vx_core support, vx222 and vxpocket).

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2005-11-17 14:46:59 +01:00 committed by Jaroslav Kysela
parent 9f38945fab
commit af26367f69
13 changed files with 410 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
include/sound/vx_core.h
View file

@ -36,9 +36,6 @@
struct firmware;
struct device;
typedef struct snd_vx_core vx_core_t;
typedef struct vx_pipe vx_pipe_t;
#define VX_DRIVER_VERSION 0x010000 /* 1.0.0 */
/*
@ -76,7 +73,7 @@ struct vx_pipe {
int channels;
unsigned int differed_type;
pcx_time_t pcx_time;
snd_pcm_substream_t *substream;
struct snd_pcm_substream *substream;
int hbuf_size; /* H-buffer size in bytes */
int buffer_bytes; /* the ALSA pcm buffer size in bytes */
@ -88,36 +85,38 @@ struct vx_pipe {
u64 cur_count; /* current sample position (for playback) */
unsigned int references; /* an output pipe may be used for monitoring and/or playback */
vx_pipe_t *monitoring_pipe; /* pointer to the monitoring pipe (capture pipe only)*/
struct vx_pipe *monitoring_pipe; /* pointer to the monitoring pipe (capture pipe only)*/
struct tasklet_struct start_tq;
};
struct vx_core;
struct snd_vx_ops {
/* low-level i/o */
unsigned char (*in8)(vx_core_t *chip, int reg);
unsigned int (*in32)(vx_core_t *chip, int reg);
void (*out8)(vx_core_t *chip, int reg, unsigned char val);
void (*out32)(vx_core_t *chip, int reg, unsigned int val);
unsigned char (*in8)(struct vx_core *chip, int reg);
unsigned int (*in32)(struct vx_core *chip, int reg);
void (*out8)(struct vx_core *chip, int reg, unsigned char val);
void (*out32)(struct vx_core *chip, int reg, unsigned int val);
/* irq */
int (*test_and_ack)(vx_core_t *chip);
void (*validate_irq)(vx_core_t *chip, int enable);
int (*test_and_ack)(struct vx_core *chip);
void (*validate_irq)(struct vx_core *chip, int enable);
/* codec */
void (*write_codec)(vx_core_t *chip, int codec, unsigned int data);
void (*akm_write)(vx_core_t *chip, int reg, unsigned int data);
void (*reset_codec)(vx_core_t *chip);
void (*change_audio_source)(vx_core_t *chip, int src);
void (*set_clock_source)(vx_core_t *chp, int src);
void (*write_codec)(struct vx_core *chip, int codec, unsigned int data);
void (*akm_write)(struct vx_core *chip, int reg, unsigned int data);
void (*reset_codec)(struct vx_core *chip);
void (*change_audio_source)(struct vx_core *chip, int src);
void (*set_clock_source)(struct vx_core *chp, int src);
/* chip init */
int (*load_dsp)(vx_core_t *chip, int idx, const struct firmware *fw);
void (*reset_dsp)(vx_core_t *chip);
void (*reset_board)(vx_core_t *chip, int cold_reset);
int (*add_controls)(vx_core_t *chip);
int (*load_dsp)(struct vx_core *chip, int idx, const struct firmware *fw);
void (*reset_dsp)(struct vx_core *chip);
void (*reset_board)(struct vx_core *chip, int cold_reset);
int (*add_controls)(struct vx_core *chip);
/* pcm */
void (*dma_write)(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count);
void (*dma_read)(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count);
void (*dma_write)(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count);
void (*dma_read)(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count);
};
struct snd_vx_hardware {
@ -158,10 +157,10 @@ enum {
/* min/max values for analog output for old codecs */
#define VX_ANALOG_OUT_LEVEL_MAX 0xe3
struct snd_vx_core {
struct vx_core {
/* ALSA stuff */
snd_card_t *card;
snd_pcm_t *pcm[VX_MAX_CODECS];
struct snd_card *card;
struct snd_pcm *pcm[VX_MAX_CODECS];
int type; /* VX_TYPE_XXX */
int irq;
@ -179,7 +178,7 @@ struct snd_vx_core {
unsigned int pcm_running;
struct device *dev;
snd_hwdep_t *hwdep;
struct snd_hwdep *hwdep;
struct vx_rmh irq_rmh; /* RMH used in interrupts */
@ -216,14 +215,14 @@ struct snd_vx_core {
/*
* constructor
*/
vx_core_t *snd_vx_create(snd_card_t *card, struct snd_vx_hardware *hw,
struct snd_vx_ops *ops, int extra_size);
int snd_vx_setup_firmware(vx_core_t *chip);
int snd_vx_load_boot_image(vx_core_t *chip, const struct firmware *dsp);
int snd_vx_dsp_boot(vx_core_t *chip, const struct firmware *dsp);
int snd_vx_dsp_load(vx_core_t *chip, const struct firmware *dsp);
struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw,
struct snd_vx_ops *ops, int extra_size);
int snd_vx_setup_firmware(struct vx_core *chip);
int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *dsp);
int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *dsp);
int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp);
void snd_vx_free_firmware(vx_core_t *chip);
void snd_vx_free_firmware(struct vx_core *chip);
/*
* interrupt handler; exported for pcmcia
@ -233,37 +232,37 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs);
/*
* lowlevel functions
*/
static inline int vx_test_and_ack(vx_core_t *chip)
static inline int vx_test_and_ack(struct vx_core *chip)
{
snd_assert(chip->ops->test_and_ack, return -ENXIO);
return chip->ops->test_and_ack(chip);
}
static inline void vx_validate_irq(vx_core_t *chip, int enable)
static inline void vx_validate_irq(struct vx_core *chip, int enable)
{
snd_assert(chip->ops->validate_irq, return);
chip->ops->validate_irq(chip, enable);
}
static inline unsigned char snd_vx_inb(vx_core_t *chip, int reg)
static inline unsigned char snd_vx_inb(struct vx_core *chip, int reg)
{
snd_assert(chip->ops->in8, return 0);
return chip->ops->in8(chip, reg);
}
static inline unsigned int snd_vx_inl(vx_core_t *chip, int reg)
static inline unsigned int snd_vx_inl(struct vx_core *chip, int reg)
{
snd_assert(chip->ops->in32, return 0);
return chip->ops->in32(chip, reg);
}
static inline void snd_vx_outb(vx_core_t *chip, int reg, unsigned char val)
static inline void snd_vx_outb(struct vx_core *chip, int reg, unsigned char val)
{
snd_assert(chip->ops->out8, return);
chip->ops->out8(chip, reg, val);
}
static inline void snd_vx_outl(vx_core_t *chip, int reg, unsigned int val)
static inline void snd_vx_outl(struct vx_core *chip, int reg, unsigned int val)
{
snd_assert(chip->ops->out32, return);
chip->ops->out32(chip, reg, val);
@ -274,25 +273,25 @@ static inline void snd_vx_outl(vx_core_t *chip, int reg, unsigned int val)
#define vx_inl(chip,reg) snd_vx_inl(chip, VX_##reg)
#define vx_outl(chip,reg,val) snd_vx_outl(chip, VX_##reg,val)
static inline void vx_reset_dsp(vx_core_t *chip)
static inline void vx_reset_dsp(struct vx_core *chip)
{
snd_assert(chip->ops->reset_dsp, return);
chip->ops->reset_dsp(chip);
}
int vx_send_msg(vx_core_t *chip, struct vx_rmh *rmh);
int vx_send_msg_nolock(vx_core_t *chip, struct vx_rmh *rmh);
int vx_send_rih(vx_core_t *chip, int cmd);
int vx_send_rih_nolock(vx_core_t *chip, int cmd);
int vx_send_msg(struct vx_core *chip, struct vx_rmh *rmh);
int vx_send_msg_nolock(struct vx_core *chip, struct vx_rmh *rmh);
int vx_send_rih(struct vx_core *chip, int cmd);
int vx_send_rih_nolock(struct vx_core *chip, int cmd);
void vx_reset_codec(vx_core_t *chip, int cold_reset);
void vx_reset_codec(struct vx_core *chip, int cold_reset);
/*
* check the bit on the specified register
* returns zero if a bit matches, or a negative error code.
* exported for vxpocket driver
*/
int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time);
int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int time);
#define vx_check_isr(chip,mask,bit,time) snd_vx_check_reg_bit(chip, VX_ISR, mask, bit, time)
#define vx_wait_isr_bit(chip,bit) vx_check_isr(chip, bit, bit, 200)
#define vx_wait_for_rx_full(chip) vx_wait_isr_bit(chip, ISR_RX_FULL)
@ -301,15 +300,15 @@ int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time);
/*
* pseudo-DMA transfer
*/
static inline void vx_pseudo_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static inline void vx_pseudo_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
snd_assert(chip->ops->dma_write, return);
chip->ops->dma_write(chip, runtime, pipe, count);
}
static inline void vx_pseudo_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static inline void vx_pseudo_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
snd_assert(chip->ops->dma_read, return);
chip->ops->dma_read(chip, runtime, pipe, count);
@ -327,24 +326,24 @@ static inline void vx_pseudo_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtim
/*
* pcm stuff
*/
int snd_vx_pcm_new(vx_core_t *chip);
void vx_pcm_update_intr(vx_core_t *chip, unsigned int events);
int snd_vx_pcm_new(struct vx_core *chip);
void vx_pcm_update_intr(struct vx_core *chip, unsigned int events);
/*
* mixer stuff
*/
int snd_vx_mixer_new(vx_core_t *chip);
void vx_toggle_dac_mute(vx_core_t *chip, int mute);
int vx_sync_audio_source(vx_core_t *chip);
int vx_set_monitor_level(vx_core_t *chip, int audio, int level, int active);
int snd_vx_mixer_new(struct vx_core *chip);
void vx_toggle_dac_mute(struct vx_core *chip, int mute);
int vx_sync_audio_source(struct vx_core *chip);
int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active);
/*
* IEC958 & clock stuff
*/
void vx_set_iec958_status(vx_core_t *chip, unsigned int bits);
int vx_set_clock(vx_core_t *chip, unsigned int freq);
void vx_set_internal_clock(vx_core_t *chip, unsigned int freq);
int vx_change_frequency(vx_core_t *chip);
void vx_set_iec958_status(struct vx_core *chip, unsigned int bits);
int vx_set_clock(struct vx_core *chip, unsigned int freq);
void vx_set_internal_clock(struct vx_core *chip, unsigned int freq);
int vx_change_frequency(struct vx_core *chip);
/*

58
sound/drivers/vx/vx_core.c
View file

@ -49,7 +49,7 @@ MODULE_LICENSE("GPL");
*
* returns zero if a bit matches, or a negative error code.
*/
int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time)
int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int time)
{
unsigned long end_time = jiffies + (time * HZ + 999) / 1000;
#ifdef CONFIG_SND_DEBUG
@ -78,7 +78,7 @@ int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time)
* returns 0 if successful, or a negative error code.
*
*/
static int vx_send_irq_dsp(vx_core_t *chip, int num)
static int vx_send_irq_dsp(struct vx_core *chip, int num)
{
int nirq;
@ -99,7 +99,7 @@ static int vx_send_irq_dsp(vx_core_t *chip, int num)
*
* returns 0 if successful, or a negative error code.
*/
static int vx_reset_chk(vx_core_t *chip)
static int vx_reset_chk(struct vx_core *chip)
{
/* Reset irq CHK */
if (vx_send_irq_dsp(chip, IRQ_RESET_CHK) < 0)
@ -118,7 +118,7 @@ static int vx_reset_chk(vx_core_t *chip)
* the error code can be VX-specific, retrieved via vx_get_error().
* NB: call with spinlock held!
*/
static int vx_transfer_end(vx_core_t *chip, int cmd)
static int vx_transfer_end(struct vx_core *chip, int cmd)
{
int err;
@ -156,7 +156,7 @@ static int vx_transfer_end(vx_core_t *chip, int cmd)
* the error code can be VX-specific, retrieved via vx_get_error().
* NB: call with spinlock held!
*/
static int vx_read_status(vx_core_t *chip, struct vx_rmh *rmh)
static int vx_read_status(struct vx_core *chip, struct vx_rmh *rmh)
{
int i, err, val, size;
@ -236,7 +236,7 @@ static int vx_read_status(vx_core_t *chip, struct vx_rmh *rmh)
*
* this function doesn't call spinlock at all.
*/
int vx_send_msg_nolock(vx_core_t *chip, struct vx_rmh *rmh)
int vx_send_msg_nolock(struct vx_core *chip, struct vx_rmh *rmh)
{
int i, err;
@ -341,7 +341,7 @@ int vx_send_msg_nolock(vx_core_t *chip, struct vx_rmh *rmh)
* returns 0 if successful, or a negative error code.
* see vx_send_msg_nolock().
*/
int vx_send_msg(vx_core_t *chip, struct vx_rmh *rmh)
int vx_send_msg(struct vx_core *chip, struct vx_rmh *rmh)
{
unsigned long flags;
int err;
@ -364,7 +364,7 @@ int vx_send_msg(vx_core_t *chip, struct vx_rmh *rmh)
*
* unlike RMH, no command is sent to DSP.
*/
int vx_send_rih_nolock(vx_core_t *chip, int cmd)
int vx_send_rih_nolock(struct vx_core *chip, int cmd)
{
int err;
@ -401,7 +401,7 @@ int vx_send_rih_nolock(vx_core_t *chip, int cmd)
*
* see vx_send_rih_nolock().
*/
int vx_send_rih(vx_core_t *chip, int cmd)
int vx_send_rih(struct vx_core *chip, int cmd)
{
unsigned long flags;
int err;
@ -418,7 +418,7 @@ int vx_send_rih(vx_core_t *chip, int cmd)
* snd_vx_boot_xilinx - boot up the xilinx interface
* @boot: the boot record to load
*/
int snd_vx_load_boot_image(vx_core_t *chip, const struct firmware *boot)
int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *boot)
{
unsigned int i;
int no_fillup = vx_has_new_dsp(chip);
@ -470,7 +470,7 @@ int snd_vx_load_boot_image(vx_core_t *chip, const struct firmware *boot)
*
* called from irq handler only
*/
static int vx_test_irq_src(vx_core_t *chip, unsigned int *ret)
static int vx_test_irq_src(struct vx_core *chip, unsigned int *ret)
{
int err;
@ -491,7 +491,7 @@ static int vx_test_irq_src(vx_core_t *chip, unsigned int *ret)
*/
static void vx_interrupt(unsigned long private_data)
{
vx_core_t *chip = (vx_core_t *) private_data;
struct vx_core *chip = (struct vx_core *) private_data;
unsigned int events;
if (chip->chip_status & VX_STAT_IS_STALE)
@ -535,7 +535,7 @@ static void vx_interrupt(unsigned long private_data)
*/
irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs)
{
vx_core_t *chip = dev;
struct vx_core *chip = dev;
if (! (chip->chip_status & VX_STAT_CHIP_INIT) ||
(chip->chip_status & VX_STAT_IS_STALE))
@ -548,7 +548,7 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs)
/*
*/
static void vx_reset_board(vx_core_t *chip, int cold_reset)
static void vx_reset_board(struct vx_core *chip, int cold_reset)
{
snd_assert(chip->ops->reset_board, return);
@ -587,9 +587,9 @@ static void vx_reset_board(vx_core_t *chip, int cold_reset)
* proc interface
*/
static void vx_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
static void vx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
{
vx_core_t *chip = entry->private_data;
struct vx_core *chip = entry->private_data;
static char *audio_src_vxp[] = { "Line", "Mic", "Digital" };
static char *audio_src_vx2[] = { "Analog", "Analog", "Digital" };
static char *clock_mode[] = { "Auto", "Internal", "External" };
@ -630,9 +630,9 @@ static void vx_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
chip->ibl.granularity);
}
static void vx_proc_init(vx_core_t *chip)
static void vx_proc_init(struct vx_core *chip)
{
snd_info_entry_t *entry;
struct snd_info_entry *entry;
if (! snd_card_proc_new(chip->card, "vx-status", &entry))
snd_info_set_text_ops(entry, chip, 1024, vx_proc_read);
@ -642,7 +642,7 @@ static void vx_proc_init(vx_core_t *chip)
/**
* snd_vx_dsp_boot - load the DSP boot
*/
int snd_vx_dsp_boot(vx_core_t *chip, const struct firmware *boot)
int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *boot)
{
int err;
int cold_reset = !(chip->chip_status & VX_STAT_DEVICE_INIT);
@ -660,7 +660,7 @@ int snd_vx_dsp_boot(vx_core_t *chip, const struct firmware *boot)
/**
* snd_vx_dsp_load - load the DSP image
*/
int snd_vx_dsp_load(vx_core_t *chip, const struct firmware *dsp)
int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp)
{
unsigned int i;
int err;
@ -709,9 +709,9 @@ int snd_vx_dsp_load(vx_core_t *chip, const struct firmware *dsp)
/*
* suspend
*/
static int snd_vx_suspend(snd_card_t *card, pm_message_t state)
static int snd_vx_suspend(struct snd_card *card, pm_message_t state)
{
vx_core_t *chip = card->pm_private_data;
struct vx_core *chip = card->pm_private_data;
unsigned int i;
snd_assert(chip, return -EINVAL);
@ -726,9 +726,9 @@ static int snd_vx_suspend(snd_card_t *card, pm_message_t state)
/*
* resume
*/
static int snd_vx_resume(snd_card_t *card)
static int snd_vx_resume(struct snd_card *card)
{
vx_core_t *chip = card->pm_private_data;
struct vx_core *chip = card->pm_private_data;
int i, err;
snd_assert(chip, return -EINVAL);
@ -754,7 +754,7 @@ static int snd_vx_resume(snd_card_t *card)
#endif
/**
* snd_vx_create - constructor for vx_core_t
* snd_vx_create - constructor for struct vx_core
* @hw: hardware specific record
*
* this function allocates the instance and prepare for the hardware
@ -762,11 +762,11 @@ static int snd_vx_resume(snd_card_t *card)
*
* return the instance pointer if successful, NULL in error.
*/
vx_core_t *snd_vx_create(snd_card_t *card, struct snd_vx_hardware *hw,
struct snd_vx_ops *ops,
int extra_size)
struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw,
struct snd_vx_ops *ops,
int extra_size)
{
vx_core_t *chip;
struct vx_core *chip;
snd_assert(card && hw && ops, return NULL);

24
sound/drivers/vx/vx_hwdep.c
View file

@ -30,7 +30,7 @@
#ifdef SND_VX_FW_LOADER
int snd_vx_setup_firmware(vx_core_t *chip)
int snd_vx_setup_firmware(struct vx_core *chip)
{
static char *fw_files[VX_TYPE_NUMS][4] = {
[VX_TYPE_BOARD] = {
@ -95,7 +95,7 @@ int snd_vx_setup_firmware(vx_core_t *chip)
}
/* exported */
void snd_vx_free_firmware(vx_core_t *chip)
void snd_vx_free_firmware(struct vx_core *chip)
{
#ifdef CONFIG_PM
int i;
@ -106,17 +106,18 @@ void snd_vx_free_firmware(vx_core_t *chip)
#else /* old style firmware loading */
static int vx_hwdep_open(snd_hwdep_t *hw, struct file *file)
static int vx_hwdep_open(struct snd_hwdep *hw, struct file *file)
{
return 0;
}
static int vx_hwdep_release(snd_hwdep_t *hw, struct file *file)
static int vx_hwdep_release(struct snd_hwdep *hw, struct file *file)
{
return 0;
}
static int vx_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t *info)
static int vx_hwdep_dsp_status(struct snd_hwdep *hw,
struct snd_hwdep_dsp_status *info)
{
static char *type_ids[VX_TYPE_NUMS] = {
[VX_TYPE_BOARD] = "vxboard",
@ -125,7 +126,7 @@ static int vx_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t *info)
[VX_TYPE_VXPOCKET] = "vxpocket",
[VX_TYPE_VXP440] = "vxp440",
};
vx_core_t *vx = hw->private_data;
struct vx_core *vx = hw->private_data;
snd_assert(type_ids[vx->type], return -EINVAL);
strcpy(info->id, type_ids[vx->type]);
@ -147,9 +148,10 @@ static void free_fw(const struct firmware *fw)
}
}
static int vx_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp)
static int vx_hwdep_dsp_load(struct snd_hwdep *hw,
struct snd_hwdep_dsp_image *dsp)
{
vx_core_t *vx = hw->private_data;
struct vx_core *vx = hw->private_data;
int index, err;
struct firmware *fw;
@ -216,10 +218,10 @@ static int vx_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp)
/* exported */
int snd_vx_setup_firmware(vx_core_t *chip)
int snd_vx_setup_firmware(struct vx_core *chip)
{
int err;
snd_hwdep_t *hw;
struct snd_hwdep *hw;
if ((err = snd_hwdep_new(chip->card, SND_VX_HWDEP_ID, 0, &hw)) < 0)
return err;
@ -238,7 +240,7 @@ int snd_vx_setup_firmware(vx_core_t *chip)
}
/* exported */
void snd_vx_free_firmware(vx_core_t *chip)
void snd_vx_free_firmware(struct vx_core *chip)
{
#ifdef CONFIG_PM
int i;

162
sound/drivers/vx/vx_mixer.c
View file

@ -30,7 +30,7 @@
/*
* write a codec data (24bit)
*/
static void vx_write_codec_reg(vx_core_t *chip, int codec, unsigned int data)
static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int data)
{
unsigned long flags;
@ -47,7 +47,7 @@ static void vx_write_codec_reg(vx_core_t *chip, int codec, unsigned int data)
/*
* Data type used to access the Codec
*/
typedef union {
union vx_codec_data {
u32 l;
#ifdef SNDRV_BIG_ENDIAN
struct w {
@ -72,7 +72,7 @@ typedef union {
u8 hh;
} b;
#endif
} vx_codec_data_t;
};
#define SET_CDC_DATA_SEL(di,s) ((di).b.mh = (u8) (s))
#define SET_CDC_DATA_REG(di,r) ((di).b.ml = (u8) (r))
@ -85,9 +85,9 @@ typedef union {
* @reg: register index
* @val: data value
*/
static void vx_set_codec_reg(vx_core_t *chip, int codec, int reg, int val)
static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val)
{
vx_codec_data_t data;
union vx_codec_data data;
/* DAC control register */
SET_CDC_DATA_INIT(data);
SET_CDC_DATA_REG(data, reg);
@ -102,7 +102,7 @@ static void vx_set_codec_reg(vx_core_t *chip, int codec, int reg, int val)
* @left: left output level, 0 = mute
* @right: right output level
*/
static void vx_set_analog_output_level(vx_core_t *chip, int codec, int left, int right)
static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left, int right)
{
left = chip->hw->output_level_max - left;
right = chip->hw->output_level_max - right;
@ -126,7 +126,7 @@ static void vx_set_analog_output_level(vx_core_t *chip, int codec, int left, int
#define DAC_ATTEN_MIN 0x08
#define DAC_ATTEN_MAX 0x38
void vx_toggle_dac_mute(vx_core_t *chip, int mute)
void vx_toggle_dac_mute(struct vx_core *chip, int mute)
{
unsigned int i;
for (i = 0; i < chip->hw->num_codecs; i++) {
@ -141,7 +141,7 @@ void vx_toggle_dac_mute(vx_core_t *chip, int mute)
/*
* vx_reset_codec - reset and initialize the codecs
*/
void vx_reset_codec(vx_core_t *chip, int cold_reset)
void vx_reset_codec(struct vx_core *chip, int cold_reset)
{
unsigned int i;
int port = chip->type >= VX_TYPE_VXPOCKET ? 0x75 : 0x65;
@ -175,7 +175,7 @@ void vx_reset_codec(vx_core_t *chip, int cold_reset)
* change the audio input source
* @src: the target source (VX_AUDIO_SRC_XXX)
*/
static void vx_change_audio_source(vx_core_t *chip, int src)
static void vx_change_audio_source(struct vx_core *chip, int src)
{
unsigned long flags;
@ -192,7 +192,7 @@ static void vx_change_audio_source(vx_core_t *chip, int src)
* change the audio source if necessary and possible
* returns 1 if the source is actually changed.
*/
int vx_sync_audio_source(vx_core_t *chip)
int vx_sync_audio_source(struct vx_core *chip)
{
if (chip->audio_source_target == chip->audio_source ||
chip->pcm_running)
@ -217,7 +217,7 @@ struct vx_audio_level {
short monitor_level;
};
static int vx_adjust_audio_level(vx_core_t *chip, int audio, int capture,
static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture,
struct vx_audio_level *info)
{
struct vx_rmh rmh;
@ -256,7 +256,7 @@ static int vx_adjust_audio_level(vx_core_t *chip, int audio, int capture,
#if 0 // not used
static int vx_read_audio_level(vx_core_t *chip, int audio, int capture,
static int vx_read_audio_level(struct vx_core *chip, int audio, int capture,
struct vx_audio_level *info)
{
int err;
@ -283,7 +283,7 @@ static int vx_read_audio_level(vx_core_t *chip, int audio, int capture,
* set the monitoring level and mute state of the given audio
* no more static, because must be called from vx_pcm to demute monitoring
*/
int vx_set_monitor_level(vx_core_t *chip, int audio, int level, int active)
int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active)
{
struct vx_audio_level info;
@ -301,7 +301,7 @@ int vx_set_monitor_level(vx_core_t *chip, int audio, int level, int active)
/*
* set the mute status of the given audio
*/
static int vx_set_audio_switch(vx_core_t *chip, int audio, int active)
static int vx_set_audio_switch(struct vx_core *chip, int audio, int active)
{
struct vx_audio_level info;
@ -315,7 +315,7 @@ static int vx_set_audio_switch(vx_core_t *chip, int audio, int active)
/*
* set the mute status of the given audio
*/
static int vx_set_audio_gain(vx_core_t *chip, int audio, int capture, int level)
static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int level)
{
struct vx_audio_level info;
@ -329,7 +329,7 @@ static int vx_set_audio_gain(vx_core_t *chip, int audio, int capture, int level)
/*
* reset all audio levels
*/
static void vx_reset_audio_levels(vx_core_t *chip)
static void vx_reset_audio_levels(struct vx_core *chip)
{
unsigned int i, c;
struct vx_audio_level info;
@ -375,7 +375,7 @@ struct vx_vu_meter {
* @capture: 0 = playback, 1 = capture operation
* @info: the array of vx_vu_meter records (size = 2).
*/
static int vx_get_audio_vu_meter(vx_core_t *chip, int audio, int capture, struct vx_vu_meter *info)
static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, struct vx_vu_meter *info)
{
struct vx_rmh rmh;
int i, err;
@ -413,9 +413,9 @@ static int vx_get_audio_vu_meter(vx_core_t *chip, int audio, int capture, struct
/*
* output level control
*/
static int vx_output_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
uinfo->value.integer.min = 0;
@ -423,9 +423,9 @@ static int vx_output_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *u
return 0;
}
static int vx_output_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int codec = kcontrol->id.index;
down(&chip->mixer_mutex);
ucontrol->value.integer.value[0] = chip->output_level[codec][0];
@ -434,9 +434,9 @@ static int vx_output_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
return 0;
}
static int vx_output_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int codec = kcontrol->id.index;
down(&chip->mixer_mutex);
if (ucontrol->value.integer.value[0] != chip->output_level[codec][0] ||
@ -453,7 +453,7 @@ static int vx_output_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
return 0;
}
static snd_kcontrol_new_t vx_control_output_level = {
static struct snd_kcontrol_new vx_control_output_level = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Master Playback Volume",
.info = vx_output_level_info,
@ -464,7 +464,7 @@ static snd_kcontrol_new_t vx_control_output_level = {
/*
* audio source select
*/
static int vx_audio_src_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
static char *texts_mic[3] = {
"Digital", "Line", "Mic"
@ -472,7 +472,7 @@ static int vx_audio_src_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinf
static char *texts_vx2[2] = {
"Digital", "Analog"
};
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
@ -492,16 +492,16 @@ static int vx_audio_src_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinf
return 0;
}
static int vx_audio_src_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = chip->audio_source_target;
return 0;
}
static int vx_audio_src_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
down(&chip->mixer_mutex);
if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) {
chip->audio_source_target = ucontrol->value.enumerated.item[0];
@ -513,7 +513,7 @@ static int vx_audio_src_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucon
return 0;
}
static snd_kcontrol_new_t vx_control_audio_src = {
static struct snd_kcontrol_new vx_control_audio_src = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Capture Source",
.info = vx_audio_src_info,
@ -524,7 +524,7 @@ static snd_kcontrol_new_t vx_control_audio_src = {
/*
* clock mode selection
*/
static int vx_clock_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
static char *texts[3] = {
"Auto", "Internal", "External"
@ -540,16 +540,16 @@ static int vx_clock_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uin
return 0;
}
static int vx_clock_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = chip->clock_mode;
return 0;
}
static int vx_clock_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
down(&chip->mixer_mutex);
if (chip->clock_mode != ucontrol->value.enumerated.item[0]) {
chip->clock_mode = ucontrol->value.enumerated.item[0];
@ -561,7 +561,7 @@ static int vx_clock_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static snd_kcontrol_new_t vx_control_clock_mode = {
static struct snd_kcontrol_new vx_control_clock_mode = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Clock Mode",
.info = vx_clock_mode_info,
@ -572,7 +572,7 @@ static snd_kcontrol_new_t vx_control_clock_mode = {
/*
* Audio Gain
*/
static int vx_audio_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
@ -581,9 +581,9 @@ static int vx_audio_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uin
return 0;
}
static int vx_audio_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
int capture = (kcontrol->private_value >> 8) & 1;
@ -594,9 +594,9 @@ static int vx_audio_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static int vx_audio_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
int capture = (kcontrol->private_value >> 8) & 1;
@ -612,9 +612,9 @@ static int vx_audio_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static int vx_audio_monitor_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -624,9 +624,9 @@ static int vx_audio_monitor_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *
return 0;
}
static int vx_audio_monitor_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -643,7 +643,7 @@ static int vx_audio_monitor_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *
return 0;
}
static int vx_audio_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_audio_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 2;
@ -652,9 +652,9 @@ static int vx_audio_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo
return 0;
}
static int vx_audio_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -664,9 +664,9 @@ static int vx_audio_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucont
return 0;
}
static int vx_audio_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -681,9 +681,9 @@ static int vx_audio_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucont
return 0;
}
static int vx_monitor_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -693,9 +693,9 @@ static int vx_monitor_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static int vx_monitor_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
int audio = kcontrol->private_value & 0xff;
down(&chip->mixer_mutex);
@ -712,28 +712,28 @@ static int vx_monitor_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static snd_kcontrol_new_t vx_control_audio_gain = {
static struct snd_kcontrol_new vx_control_audio_gain = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
/* name will be filled later */
.info = vx_audio_gain_info,
.get = vx_audio_gain_get,
.put = vx_audio_gain_put
};
static snd_kcontrol_new_t vx_control_output_switch = {
static struct snd_kcontrol_new vx_control_output_switch = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Playback Switch",
.info = vx_audio_sw_info,
.get = vx_audio_sw_get,
.put = vx_audio_sw_put
};
static snd_kcontrol_new_t vx_control_monitor_gain = {
static struct snd_kcontrol_new vx_control_monitor_gain = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Monitoring Volume",
.info = vx_audio_gain_info, /* shared */
.get = vx_audio_monitor_get,
.put = vx_audio_monitor_put
};
static snd_kcontrol_new_t vx_control_monitor_switch = {
static struct snd_kcontrol_new vx_control_monitor_switch = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Monitoring Switch",
.info = vx_audio_sw_info, /* shared */
@ -745,16 +745,16 @@ static snd_kcontrol_new_t vx_control_monitor_switch = {
/*
* IEC958 status bits
*/
static int vx_iec958_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
uinfo->count = 1;
return 0;
}
static int vx_iec958_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
down(&chip->mixer_mutex);
ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff;
@ -765,7 +765,7 @@ static int vx_iec958_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontro
return 0;
}
static int vx_iec958_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
ucontrol->value.iec958.status[0] = 0xff;
ucontrol->value.iec958.status[1] = 0xff;
@ -774,9 +774,9 @@ static int vx_iec958_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *u
return 0;
}
static int vx_iec958_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
unsigned int val;
val = (ucontrol->value.iec958.status[0] << 0) |
@ -794,7 +794,7 @@ static int vx_iec958_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontro
return 0;
}
static snd_kcontrol_new_t vx_control_iec958_mask = {
static struct snd_kcontrol_new vx_control_iec958_mask = {
.access = SNDRV_CTL_ELEM_ACCESS_READ,
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
@ -802,7 +802,7 @@ static snd_kcontrol_new_t vx_control_iec958_mask = {
.get = vx_iec958_mask_get,
};
static snd_kcontrol_new_t vx_control_iec958 = {
static struct snd_kcontrol_new vx_control_iec958 = {
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
.info = vx_iec958_info,
@ -818,7 +818,7 @@ static snd_kcontrol_new_t vx_control_iec958 = {
#define METER_MAX 0xff
#define METER_SHIFT 16
static int vx_vu_meter_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
@ -827,9 +827,9 @@ static int vx_vu_meter_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo
return 0;
}
static int vx_vu_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
struct vx_vu_meter meter[2];
int audio = kcontrol->private_value & 0xff;
int capture = (kcontrol->private_value >> 8) & 1;
@ -840,9 +840,9 @@ static int vx_vu_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucont
return 0;
}
static int vx_peak_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
struct vx_vu_meter meter[2];
int audio = kcontrol->private_value & 0xff;
int capture = (kcontrol->private_value >> 8) & 1;
@ -853,7 +853,7 @@ static int vx_peak_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static int vx_saturation_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_saturation_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 2;
@ -862,9 +862,9 @@ static int vx_saturation_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uin
return 0;
}
static int vx_saturation_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *chip = snd_kcontrol_chip(kcontrol);
struct vx_core *chip = snd_kcontrol_chip(kcontrol);
struct vx_vu_meter meter[2];
int audio = kcontrol->private_value & 0xff;
@ -874,7 +874,7 @@ static int vx_saturation_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uco
return 0;
}
static snd_kcontrol_new_t vx_control_vu_meter = {
static struct snd_kcontrol_new vx_control_vu_meter = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
/* name will be filled later */
@ -882,7 +882,7 @@ static snd_kcontrol_new_t vx_control_vu_meter = {
.get = vx_vu_meter_get,
};
static snd_kcontrol_new_t vx_control_peak_meter = {
static struct snd_kcontrol_new vx_control_peak_meter = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
/* name will be filled later */
@ -890,7 +890,7 @@ static snd_kcontrol_new_t vx_control_peak_meter = {
.get = vx_peak_meter_get,
};
static snd_kcontrol_new_t vx_control_saturation = {
static struct snd_kcontrol_new vx_control_saturation = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Input Saturation",
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
@ -904,12 +904,12 @@ static snd_kcontrol_new_t vx_control_saturation = {
*
*/
int snd_vx_mixer_new(vx_core_t *chip)
int snd_vx_mixer_new(struct vx_core *chip)
{
unsigned int i, c;
int err;
snd_kcontrol_new_t temp;
snd_card_t *card = chip->card;
struct snd_kcontrol_new temp;
struct snd_card *card = chip->card;
char name[32];
strcpy(card->mixername, card->driver);

200
sound/drivers/vx/vx_pcm.c
View file

@ -61,7 +61,8 @@
*/
/* get the physical page pointer on the given offset */
static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned long offset)
static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
unsigned long offset)
{
void *pageptr = subs->runtime->dma_area + offset;
return vmalloc_to_page(pageptr);
@ -72,9 +73,9 @@ static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned
* called from hw_params
* NOTE: this may be called not only once per pcm open!
*/
static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
{
snd_pcm_runtime_t *runtime = subs->runtime;
struct snd_pcm_runtime *runtime = subs->runtime;
if (runtime->dma_area) {
/* already allocated */
if (runtime->dma_bytes >= size)
@ -94,9 +95,9 @@ static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
* called from hw_free callback
* NOTE: this may be called not only once per pcm open!
*/
static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
{
snd_pcm_runtime_t *runtime = subs->runtime;
struct snd_pcm_runtime *runtime = subs->runtime;
if (runtime->dma_area) {
vfree(runtime->dma_area);
runtime->dma_area = NULL;
@ -108,7 +109,8 @@ static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
/*
* read three pending pcm bytes via inb()
*/
static void vx_pcm_read_per_bytes(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe)
static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe)
{
int offset = pipe->hw_ptr;
unsigned char *buf = (unsigned char *)(runtime->dma_area + offset);
@ -135,7 +137,8 @@ static void vx_pcm_read_per_bytes(vx_core_t *chip, snd_pcm_runtime_t *runtime, v
* @pc_time: the pointer for the PC-time to set
* @dsp_time: the pointer for RMH status time array
*/
static void vx_set_pcx_time(vx_core_t *chip, pcx_time_t *pc_time, unsigned int *dsp_time)
static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time,
unsigned int *dsp_time)
{
dsp_time[0] = (unsigned int)((*pc_time) >> 24) & PCX_TIME_HI_MASK;
dsp_time[1] = (unsigned int)(*pc_time) & MASK_DSP_WORD;
@ -151,7 +154,8 @@ static void vx_set_pcx_time(vx_core_t *chip, pcx_time_t *pc_time, unsigned int *
*
* returns the increase of the command length.
*/
static int vx_set_differed_time(vx_core_t *chip, struct vx_rmh *rmh, vx_pipe_t *pipe)
static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh,
struct vx_pipe *pipe)
{
/* Update The length added to the RMH command by the timestamp */
if (! (pipe->differed_type & DC_DIFFERED_DELAY))
@ -184,7 +188,8 @@ static int vx_set_differed_time(vx_core_t *chip, struct vx_rmh *rmh, vx_pipe_t *
* @pipe: the affected pipe
* @data: format bitmask
*/
static int vx_set_stream_format(vx_core_t *chip, vx_pipe_t *pipe, unsigned int data)
static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe,
unsigned int data)
{
struct vx_rmh rmh;
@ -210,8 +215,8 @@ static int vx_set_stream_format(vx_core_t *chip, vx_pipe_t *pipe, unsigned int d
*
* returns 0 if successful, or a negative error code.
*/
static int vx_set_format(vx_core_t *chip, vx_pipe_t *pipe,
snd_pcm_runtime_t *runtime)
static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe,
struct snd_pcm_runtime *runtime)
{
unsigned int header = HEADER_FMT_BASE;
@ -239,7 +244,7 @@ static int vx_set_format(vx_core_t *chip, vx_pipe_t *pipe,
/*
* set / query the IBL size
*/
static int vx_set_ibl(vx_core_t *chip, struct vx_ibl_info *info)
static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info)
{
int err;
struct vx_rmh rmh;
@ -269,7 +274,7 @@ static int vx_set_ibl(vx_core_t *chip, struct vx_ibl_info *info)
*
* called from trigger callback only
*/
static int vx_get_pipe_state(vx_core_t *chip, vx_pipe_t *pipe, int *state)
static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *state)
{
int err;
struct vx_rmh rmh;
@ -294,7 +299,7 @@ static int vx_get_pipe_state(vx_core_t *chip, vx_pipe_t *pipe, int *state)
* you'll need to disconnect the host to get back to the
* normal mode.
*/
static int vx_query_hbuffer_size(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe)
{
int result;
struct vx_rmh rmh;
@ -318,7 +323,7 @@ static int vx_query_hbuffer_size(vx_core_t *chip, vx_pipe_t *pipe)
*
* called from trigger callback only
*/
static int vx_pipe_can_start(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe)
{
int err;
struct vx_rmh rmh;
@ -339,7 +344,7 @@ static int vx_pipe_can_start(vx_core_t *chip, vx_pipe_t *pipe)
* vx_conf_pipe - tell the pipe to stand by and wait for IRQA.
* @pipe: the pipe to be configured
*/
static int vx_conf_pipe(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe)
{
struct vx_rmh rmh;
@ -353,7 +358,7 @@ static int vx_conf_pipe(vx_core_t *chip, vx_pipe_t *pipe)
/*
* vx_send_irqa - trigger IRQA
*/
static int vx_send_irqa(vx_core_t *chip)
static int vx_send_irqa(struct vx_core *chip)
{
struct vx_rmh rmh;
@ -378,7 +383,7 @@ static int vx_send_irqa(vx_core_t *chip)
* called from trigger callback only
*
*/
static int vx_toggle_pipe(vx_core_t *chip, vx_pipe_t *pipe, int state)
static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state)
{
int err, i, cur_state;
@ -431,7 +436,7 @@ static int vx_toggle_pipe(vx_core_t *chip, vx_pipe_t *pipe, int state)
*
* called from trigger callback only
*/
static int vx_stop_pipe(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe)
{
struct vx_rmh rmh;
vx_init_rmh(&rmh, CMD_STOP_PIPE);
@ -449,12 +454,12 @@ static int vx_stop_pipe(vx_core_t *chip, vx_pipe_t *pipe)
*
* return 0 on success, or a negative error code.
*/
static int vx_alloc_pipe(vx_core_t *chip, int capture,
static int vx_alloc_pipe(struct vx_core *chip, int capture,
int audioid, int num_audio,
vx_pipe_t **pipep)
struct vx_pipe **pipep)
{
int err;
vx_pipe_t *pipe;
struct vx_pipe *pipe;
struct vx_rmh rmh;
int data_mode;
@ -499,7 +504,7 @@ static int vx_alloc_pipe(vx_core_t *chip, int capture,
* vx_free_pipe - release a pipe
* @pipe: pipe to be released
*/
static int vx_free_pipe(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe)
{
struct vx_rmh rmh;
@ -517,7 +522,7 @@ static int vx_free_pipe(vx_core_t *chip, vx_pipe_t *pipe)
*
* called from trigger callback only
*/
static int vx_start_stream(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe)
{
struct vx_rmh rmh;
@ -533,7 +538,7 @@ static int vx_start_stream(vx_core_t *chip, vx_pipe_t *pipe)
*
* called from trigger callback only
*/
static int vx_stop_stream(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe)
{
struct vx_rmh rmh;
@ -547,11 +552,12 @@ static int vx_stop_stream(vx_core_t *chip, vx_pipe_t *pipe)
* playback hw information
*/
static snd_pcm_hardware_t vx_pcm_playback_hw = {
static struct snd_pcm_hardware vx_pcm_playback_hw = {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
/*SNDRV_PCM_INFO_RESUME*/),
.formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
.formats = (/*SNDRV_PCM_FMTBIT_U8 |*/
SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
.rate_min = 5000,
.rate_max = 48000,
@ -571,11 +577,11 @@ static void vx_pcm_delayed_start(unsigned long arg);
/*
* vx_pcm_playback_open - open callback for playback
*/
static int vx_pcm_playback_open(snd_pcm_substream_t *subs)
static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
{
snd_pcm_runtime_t *runtime = subs->runtime;
vx_core_t *chip = snd_pcm_substream_chip(subs);
vx_pipe_t *pipe = NULL;
struct snd_pcm_runtime *runtime = subs->runtime;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct vx_pipe *pipe = NULL;
unsigned int audio;
int err;
@ -615,10 +621,10 @@ static int vx_pcm_playback_open(snd_pcm_substream_t *subs)
/*
* vx_pcm_playback_close - close callback for playback
*/
static int vx_pcm_playback_close(snd_pcm_substream_t *subs)
static int vx_pcm_playback_close(struct snd_pcm_substream *subs)
{
vx_core_t *chip = snd_pcm_substream_chip(subs);
vx_pipe_t *pipe;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct vx_pipe *pipe;
if (! subs->runtime->private_data)
return -EINVAL;
@ -641,7 +647,7 @@ static int vx_pcm_playback_close(snd_pcm_substream_t *subs)
*
* NB: call with a certain lock.
*/
static int vx_notify_end_of_buffer(vx_core_t *chip, vx_pipe_t *pipe)
static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe)
{
int err;
struct vx_rmh rmh; /* use a temporary rmh here */
@ -669,7 +675,9 @@ static int vx_notify_end_of_buffer(vx_core_t *chip, vx_pipe_t *pipe)
*
* return 0 if ok.
*/
static int vx_pcm_playback_transfer_chunk(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe, int size)
static int vx_pcm_playback_transfer_chunk(struct vx_core *chip,
struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int size)
{
int space, err = 0;
@ -705,7 +713,9 @@ static int vx_pcm_playback_transfer_chunk(vx_core_t *chip, snd_pcm_runtime_t *ru
* so that the caller can check the total transferred size later
* (to call snd_pcm_period_elapsed).
*/
static int vx_update_pipe_position(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe)
static int vx_update_pipe_position(struct vx_core *chip,
struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe)
{
struct vx_rmh rmh;
int err, update;
@ -731,10 +741,12 @@ static int vx_update_pipe_position(vx_core_t *chip, snd_pcm_runtime_t *runtime,
* transfer the pending playback buffer data to DSP
* called from interrupt handler
*/
static void vx_pcm_playback_transfer(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe, int nchunks)
static void vx_pcm_playback_transfer(struct vx_core *chip,
struct snd_pcm_substream *subs,
struct vx_pipe *pipe, int nchunks)
{
int i, err;
snd_pcm_runtime_t *runtime = subs->runtime;
struct snd_pcm_runtime *runtime = subs->runtime;
if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
return;
@ -749,10 +761,12 @@ static void vx_pcm_playback_transfer(vx_core_t *chip, snd_pcm_substream_t *subs,
* update the playback position and call snd_pcm_period_elapsed() if necessary
* called from interrupt handler
*/
static void vx_pcm_playback_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe)
static void vx_pcm_playback_update(struct vx_core *chip,
struct snd_pcm_substream *subs,
struct vx_pipe *pipe)
{
int err;
snd_pcm_runtime_t *runtime = subs->runtime;
struct snd_pcm_runtime *runtime = subs->runtime;
if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) {
if ((err = vx_update_pipe_position(chip, runtime, pipe)) < 0)
@ -771,9 +785,9 @@ static void vx_pcm_playback_update(vx_core_t *chip, snd_pcm_substream_t *subs, v
*/
static void vx_pcm_delayed_start(unsigned long arg)
{
snd_pcm_substream_t *subs = (snd_pcm_substream_t *)arg;
vx_core_t *chip = subs->pcm->private_data;
vx_pipe_t *pipe = subs->runtime->private_data;
struct snd_pcm_substream *subs = (struct snd_pcm_substream *)arg;
struct vx_core *chip = subs->pcm->private_data;
struct vx_pipe *pipe = subs->runtime->private_data;
int err;
/* printk( KERN_DEBUG "DDDD tasklet delayed start jiffies = %ld\n", jiffies);*/
@ -792,10 +806,10 @@ static void vx_pcm_delayed_start(unsigned long arg)
/*
* vx_pcm_playback_trigger - trigger callback for playback
*/
static int vx_pcm_trigger(snd_pcm_substream_t *subs, int cmd)
static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
{
vx_core_t *chip = snd_pcm_substream_chip(subs);
vx_pipe_t *pipe = subs->runtime->private_data;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct vx_pipe *pipe = subs->runtime->private_data;
int err;
if (chip->chip_status & VX_STAT_IS_STALE)
@ -839,18 +853,18 @@ static int vx_pcm_trigger(snd_pcm_substream_t *subs, int cmd)
/*
* vx_pcm_playback_pointer - pointer callback for playback
*/
static snd_pcm_uframes_t vx_pcm_playback_pointer(snd_pcm_substream_t *subs)
static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs)
{
snd_pcm_runtime_t *runtime = subs->runtime;
vx_pipe_t *pipe = runtime->private_data;
struct snd_pcm_runtime *runtime = subs->runtime;
struct vx_pipe *pipe = runtime->private_data;
return pipe->position;
}
/*
* vx_pcm_hw_params - hw_params callback for playback and capture
*/
static int vx_pcm_hw_params(snd_pcm_substream_t *subs,
snd_pcm_hw_params_t *hw_params)
static int vx_pcm_hw_params(struct snd_pcm_substream *subs,
struct snd_pcm_hw_params *hw_params)
{
return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params));
}
@ -858,7 +872,7 @@ static int vx_pcm_hw_params(snd_pcm_substream_t *subs,
/*
* vx_pcm_hw_free - hw_free callback for playback and capture
*/
static int vx_pcm_hw_free(snd_pcm_substream_t *subs)
static int vx_pcm_hw_free(struct snd_pcm_substream *subs)
{
return snd_pcm_free_vmalloc_buffer(subs);
}
@ -866,11 +880,11 @@ static int vx_pcm_hw_free(snd_pcm_substream_t *subs)
/*
* vx_pcm_prepare - prepare callback for playback and capture
*/
static int vx_pcm_prepare(snd_pcm_substream_t *subs)
static int vx_pcm_prepare(struct snd_pcm_substream *subs)
{
vx_core_t *chip = snd_pcm_substream_chip(subs);
snd_pcm_runtime_t *runtime = subs->runtime;
vx_pipe_t *pipe = runtime->private_data;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct snd_pcm_runtime *runtime = subs->runtime;
struct vx_pipe *pipe = runtime->private_data;
int err, data_mode;
// int max_size, nchunks;
@ -897,7 +911,8 @@ static int vx_pcm_prepare(snd_pcm_substream_t *subs)
}
if (chip->pcm_running && chip->freq != runtime->rate) {
snd_printk(KERN_ERR "vx: cannot set different clock %d from the current %d\n", runtime->rate, chip->freq);
snd_printk(KERN_ERR "vx: cannot set different clock %d "
"from the current %d\n", runtime->rate, chip->freq);
return -EINVAL;
}
vx_set_clock(chip, runtime->rate);
@ -930,7 +945,7 @@ static int vx_pcm_prepare(snd_pcm_substream_t *subs)
/*
* operators for PCM playback
*/
static snd_pcm_ops_t vx_pcm_playback_ops = {
static struct snd_pcm_ops vx_pcm_playback_ops = {
.open = vx_pcm_playback_open,
.close = vx_pcm_playback_close,
.ioctl = snd_pcm_lib_ioctl,
@ -947,11 +962,12 @@ static snd_pcm_ops_t vx_pcm_playback_ops = {
* playback hw information
*/
static snd_pcm_hardware_t vx_pcm_capture_hw = {
static struct snd_pcm_hardware vx_pcm_capture_hw = {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
/*SNDRV_PCM_INFO_RESUME*/),
.formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
.formats = (/*SNDRV_PCM_FMTBIT_U8 |*/
SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
.rate_min = 5000,
.rate_max = 48000,
@ -969,12 +985,12 @@ static snd_pcm_hardware_t vx_pcm_capture_hw = {
/*
* vx_pcm_capture_open - open callback for capture
*/
static int vx_pcm_capture_open(snd_pcm_substream_t *subs)
static int vx_pcm_capture_open(struct snd_pcm_substream *subs)
{
snd_pcm_runtime_t *runtime = subs->runtime;
vx_core_t *chip = snd_pcm_substream_chip(subs);
vx_pipe_t *pipe;
vx_pipe_t *pipe_out_monitoring = NULL;
struct snd_pcm_runtime *runtime = subs->runtime;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct vx_pipe *pipe;
struct vx_pipe *pipe_out_monitoring = NULL;
unsigned int audio;
int err;
@ -1005,9 +1021,11 @@ static int vx_pcm_capture_open(snd_pcm_substream_t *subs)
if an output pipe is available, it's audios still may need to be
unmuted. hence we'll have to call a mixer entry point.
*/
vx_set_monitor_level(chip, audio, chip->audio_monitor[audio], chip->audio_monitor_active[audio]);
vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
chip->audio_monitor_active[audio]);
/* assuming stereo */
vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1], chip->audio_monitor_active[audio+1]);
vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
chip->audio_monitor_active[audio+1]);
}
pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */
@ -1026,11 +1044,11 @@ static int vx_pcm_capture_open(snd_pcm_substream_t *subs)
/*
* vx_pcm_capture_close - close callback for capture
*/
static int vx_pcm_capture_close(snd_pcm_substream_t *subs)
static int vx_pcm_capture_close(struct snd_pcm_substream *subs)
{
vx_core_t *chip = snd_pcm_substream_chip(subs);
vx_pipe_t *pipe;
vx_pipe_t *pipe_out_monitoring;
struct vx_core *chip = snd_pcm_substream_chip(subs);
struct vx_pipe *pipe;
struct vx_pipe *pipe_out_monitoring;
if (! subs->runtime->private_data)
return -EINVAL;
@ -1062,10 +1080,11 @@ static int vx_pcm_capture_close(snd_pcm_substream_t *subs)
/*
* vx_pcm_capture_update - update the capture buffer
*/
static void vx_pcm_capture_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe)
static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs,
struct vx_pipe *pipe)
{
int size, space, count;
snd_pcm_runtime_t *runtime = subs->runtime;
struct snd_pcm_runtime *runtime = subs->runtime;
if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
return;
@ -1135,17 +1154,17 @@ static void vx_pcm_capture_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx
/*
* vx_pcm_capture_pointer - pointer callback for capture
*/
static snd_pcm_uframes_t vx_pcm_capture_pointer(snd_pcm_substream_t *subs)
static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs)
{
snd_pcm_runtime_t *runtime = subs->runtime;
vx_pipe_t *pipe = runtime->private_data;
struct snd_pcm_runtime *runtime = subs->runtime;
struct vx_pipe *pipe = runtime->private_data;
return bytes_to_frames(runtime, pipe->hw_ptr);
}
/*
* operators for PCM capture
*/
static snd_pcm_ops_t vx_pcm_capture_ops = {
static struct snd_pcm_ops vx_pcm_capture_ops = {
.open = vx_pcm_capture_open,
.close = vx_pcm_capture_close,
.ioctl = snd_pcm_lib_ioctl,
@ -1161,10 +1180,10 @@ static snd_pcm_ops_t vx_pcm_capture_ops = {
/*
* interrupt handler for pcm streams
*/
void vx_pcm_update_intr(vx_core_t *chip, unsigned int events)
void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
{
unsigned int i;
vx_pipe_t *pipe;
struct vx_pipe *pipe;
#define EVENT_MASK (END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING)
@ -1218,7 +1237,7 @@ void vx_pcm_update_intr(vx_core_t *chip, unsigned int events)
/*
* vx_init_audio_io - check the availabe audio i/o and allocate pipe arrays
*/
static int vx_init_audio_io(vx_core_t *chip)
static int vx_init_audio_io(struct vx_core *chip)
{
struct vx_rmh rmh;
int preferred;
@ -1234,19 +1253,20 @@ static int vx_init_audio_io(vx_core_t *chip)
chip->audio_info = rmh.Stat[1];
/* allocate pipes */
chip->playback_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_outs, GFP_KERNEL);
chip->capture_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_ins, GFP_KERNEL);
chip->playback_pipes = kmalloc(sizeof(struct vx_pipe *) * chip->audio_outs, GFP_KERNEL);
chip->capture_pipes = kmalloc(sizeof(struct vx_pipe *) * chip->audio_ins, GFP_KERNEL);
if (! chip->playback_pipes || ! chip->capture_pipes)
return -ENOMEM;
memset(chip->playback_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_outs);
memset(chip->capture_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_ins);
memset(chip->playback_pipes, 0, sizeof(struct vx_pipe *) * chip->audio_outs);
memset(chip->capture_pipes, 0, sizeof(struct vx_pipe *) * chip->audio_ins);
preferred = chip->ibl.size;
chip->ibl.size = 0;
vx_set_ibl(chip, &chip->ibl); /* query the info */
if (preferred > 0) {
chip->ibl.size = ((preferred + chip->ibl.granularity - 1) / chip->ibl.granularity) * chip->ibl.granularity;
chip->ibl.size = ((preferred + chip->ibl.granularity - 1) /
chip->ibl.granularity) * chip->ibl.granularity;
if (chip->ibl.size > chip->ibl.max_size)
chip->ibl.size = chip->ibl.max_size;
} else
@ -1260,9 +1280,9 @@ static int vx_init_audio_io(vx_core_t *chip)
/*
* free callback for pcm
*/
static void snd_vx_pcm_free(snd_pcm_t *pcm)
static void snd_vx_pcm_free(struct snd_pcm *pcm)
{
vx_core_t *chip = pcm->private_data;
struct vx_core *chip = pcm->private_data;
chip->pcm[pcm->device] = NULL;
kfree(chip->playback_pipes);
chip->playback_pipes = NULL;
@ -1273,9 +1293,9 @@ static void snd_vx_pcm_free(snd_pcm_t *pcm)
/*
* snd_vx_pcm_new - create and initialize a pcm
*/
int snd_vx_pcm_new(vx_core_t *chip)
int snd_vx_pcm_new(struct vx_core *chip)
{
snd_pcm_t *pcm;
struct snd_pcm *pcm;
unsigned int i;
int err;

22
sound/drivers/vx/vx_uer.c
View file

@ -31,7 +31,7 @@
* vx_modify_board_clock - tell the board that its clock has been modified
* @sync: DSP needs to resynchronize its FIFO
*/
static int vx_modify_board_clock(vx_core_t *chip, int sync)
static int vx_modify_board_clock(struct vx_core *chip, int sync)
{
struct vx_rmh rmh;
@ -45,7 +45,7 @@ static int vx_modify_board_clock(vx_core_t *chip, int sync)
/*
* vx_modify_board_inputs - resync audio inputs
*/
static int vx_modify_board_inputs(vx_core_t *chip)
static int vx_modify_board_inputs(struct vx_core *chip)
{
struct vx_rmh rmh;
@ -59,7 +59,7 @@ static int vx_modify_board_inputs(vx_core_t *chip)
* @index: the bit index
* returns 0 or 1.
*/
static int vx_read_one_cbit(vx_core_t *chip, int index)
static int vx_read_one_cbit(struct vx_core *chip, int index)
{
unsigned long flags;
int val;
@ -82,7 +82,7 @@ static int vx_read_one_cbit(vx_core_t *chip, int index)
* @index: the bit index
* @val: bit value, 0 or 1
*/
static void vx_write_one_cbit(vx_core_t *chip, int index, int val)
static void vx_write_one_cbit(struct vx_core *chip, int index, int val)
{
unsigned long flags;
val = !!val; /* 0 or 1 */
@ -104,7 +104,7 @@ static void vx_write_one_cbit(vx_core_t *chip, int index, int val)
* returns the frequency of UER, or 0 if not sync,
* or a negative error code.
*/
static int vx_read_uer_status(vx_core_t *chip, int *mode)
static int vx_read_uer_status(struct vx_core *chip, int *mode)
{
int val, freq;
@ -160,7 +160,7 @@ static int vx_read_uer_status(vx_core_t *chip, int *mode)
* default : HexFreq = (dword) ((double) 28224000 / (double) (Frequency*4)) - 0x000001FF
*/
static int vx_calc_clock_from_freq(vx_core_t *chip, int freq)
static int vx_calc_clock_from_freq(struct vx_core *chip, int freq)
{
int hexfreq;
@ -187,7 +187,7 @@ static int vx_calc_clock_from_freq(vx_core_t *chip, int freq)
* vx_change_clock_source - change the clock source
* @source: the new source
*/
static void vx_change_clock_source(vx_core_t *chip, int source)
static void vx_change_clock_source(struct vx_core *chip, int source)
{
unsigned long flags;
@ -205,7 +205,7 @@ static void vx_change_clock_source(vx_core_t *chip, int source)
/*
* set the internal clock
*/
void vx_set_internal_clock(vx_core_t *chip, unsigned int freq)
void vx_set_internal_clock(struct vx_core *chip, unsigned int freq)
{
int clock;
unsigned long flags;
@ -228,7 +228,7 @@ void vx_set_internal_clock(vx_core_t *chip, unsigned int freq)
* set the iec958 status bits
* @bits: 32-bit status bits
*/
void vx_set_iec958_status(vx_core_t *chip, unsigned int bits)
void vx_set_iec958_status(struct vx_core *chip, unsigned int bits)
{
int i;
@ -243,7 +243,7 @@ void vx_set_iec958_status(vx_core_t *chip, unsigned int bits)
/*
* vx_set_clock - change the clock and audio source if necessary
*/
int vx_set_clock(vx_core_t *chip, unsigned int freq)
int vx_set_clock(struct vx_core *chip, unsigned int freq)
{
int src_changed = 0;
@ -285,7 +285,7 @@ int vx_set_clock(vx_core_t *chip, unsigned int freq)
/*
* vx_change_frequency - called from interrupt handler
*/
int vx_change_frequency(vx_core_t *chip)
int vx_change_frequency(struct vx_core *chip)
{
int freq;

16
sound/pci/vx222/vx222.c
View file

@ -108,7 +108,7 @@ static struct snd_vx_hardware vx222_mic_hw = {
/*
*/
static int snd_vx222_free(vx_core_t *chip)
static int snd_vx222_free(struct vx_core *chip)
{
struct snd_vx222 *vx = (struct snd_vx222 *)chip;
@ -121,21 +121,21 @@ static int snd_vx222_free(vx_core_t *chip)
return 0;
}
static int snd_vx222_dev_free(snd_device_t *device)
static int snd_vx222_dev_free(struct snd_device *device)
{
vx_core_t *chip = device->device_data;
struct vx_core *chip = device->device_data;
return snd_vx222_free(chip);
}
static int __devinit snd_vx222_create(snd_card_t *card, struct pci_dev *pci,
static int __devinit snd_vx222_create(struct snd_card *card, struct pci_dev *pci,
struct snd_vx_hardware *hw,
struct snd_vx222 **rchip)
{
vx_core_t *chip;
struct vx_core *chip;
struct snd_vx222 *vx;
int i, err;
static snd_device_ops_t ops = {
static struct snd_device_ops ops = {
.dev_free = snd_vx222_dev_free,
};
struct snd_vx_ops *vx_ops;
@ -147,7 +147,7 @@ static int __devinit snd_vx222_create(snd_card_t *card, struct pci_dev *pci,
vx_ops = hw->type == VX_TYPE_BOARD ? &vx222_old_ops : &vx222_ops;
chip = snd_vx_create(card, hw, vx_ops,
sizeof(struct snd_vx222) - sizeof(vx_core_t));
sizeof(struct snd_vx222) - sizeof(struct vx_core));
if (! chip) {
pci_disable_device(pci);
return -ENOMEM;
@ -186,7 +186,7 @@ static int __devinit snd_vx222_probe(struct pci_dev *pci,
const struct pci_device_id *pci_id)
{
static int dev;
snd_card_t *card;
struct snd_card *card;
struct snd_vx_hardware *hw;
struct snd_vx222 *vx;
int err;

2
sound/pci/vx222/vx222.h
View file

@ -25,7 +25,7 @@
struct snd_vx222 {
vx_core_t core;
struct vx_core core;
/* h/w config; for PLX and for DSP */
struct pci_dev *pci;

84
sound/pci/vx222/vx222_ops.c
View file

@ -82,7 +82,7 @@ static int vx2_reg_index[VX_REG_MAX] = {
[VX_GPIOC] = 0, /* on the PLX */
};
static inline unsigned long vx2_reg_addr(vx_core_t *_chip, int reg)
static inline unsigned long vx2_reg_addr(struct vx_core *_chip, int reg)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
return chip->port[vx2_reg_index[reg]] + vx2_reg_offset[reg];
@ -92,7 +92,7 @@ static inline unsigned long vx2_reg_addr(vx_core_t *_chip, int reg)
* snd_vx_inb - read a byte from the register
* @offset: register enum
*/
static unsigned char vx2_inb(vx_core_t *chip, int offset)
static unsigned char vx2_inb(struct vx_core *chip, int offset)
{
return inb(vx2_reg_addr(chip, offset));
}
@ -102,7 +102,7 @@ static unsigned char vx2_inb(vx_core_t *chip, int offset)
* @offset: the register offset
* @val: the value to write
*/
static void vx2_outb(vx_core_t *chip, int offset, unsigned char val)
static void vx2_outb(struct vx_core *chip, int offset, unsigned char val)
{
outb(val, vx2_reg_addr(chip, offset));
//printk("outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
@ -112,7 +112,7 @@ static void vx2_outb(vx_core_t *chip, int offset, unsigned char val)
* snd_vx_inl - read a 32bit word from the register
* @offset: register enum
*/
static unsigned int vx2_inl(vx_core_t *chip, int offset)
static unsigned int vx2_inl(struct vx_core *chip, int offset)
{
return inl(vx2_reg_addr(chip, offset));
}
@ -122,7 +122,7 @@ static unsigned int vx2_inl(vx_core_t *chip, int offset)
* @offset: the register enum
* @val: the value to write
*/
static void vx2_outl(vx_core_t *chip, int offset, unsigned int val)
static void vx2_outl(struct vx_core *chip, int offset, unsigned int val)
{
// printk("outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
outl(val, vx2_reg_addr(chip, offset));
@ -132,13 +132,13 @@ static void vx2_outl(vx_core_t *chip, int offset, unsigned int val)
* redefine macros to call directly
*/
#undef vx_inb
#define vx_inb(chip,reg) vx2_inb((vx_core_t*)(chip), VX_##reg)
#define vx_inb(chip,reg) vx2_inb((struct vx_core*)(chip), VX_##reg)
#undef vx_outb
#define vx_outb(chip,reg,val) vx2_outb((vx_core_t*)(chip), VX_##reg, val)
#define vx_outb(chip,reg,val) vx2_outb((struct vx_core*)(chip), VX_##reg, val)
#undef vx_inl
#define vx_inl(chip,reg) vx2_inl((vx_core_t*)(chip), VX_##reg)
#define vx_inl(chip,reg) vx2_inl((struct vx_core*)(chip), VX_##reg)
#undef vx_outl
#define vx_outl(chip,reg,val) vx2_outl((vx_core_t*)(chip), VX_##reg, val)
#define vx_outl(chip,reg,val) vx2_outl((struct vx_core*)(chip), VX_##reg, val)
/*
@ -147,7 +147,7 @@ static void vx2_outl(vx_core_t *chip, int offset, unsigned int val)
#define XX_DSP_RESET_WAIT_TIME 2 /* ms */
static void vx2_reset_dsp(vx_core_t *_chip)
static void vx2_reset_dsp(struct vx_core *_chip)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -162,7 +162,7 @@ static void vx2_reset_dsp(vx_core_t *_chip)
}
static int vx2_test_xilinx(vx_core_t *_chip)
static int vx2_test_xilinx(struct vx_core *_chip)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
unsigned int data;
@ -219,7 +219,7 @@ static int vx2_test_xilinx(vx_core_t *_chip)
* vx_setup_pseudo_dma - set up the pseudo dma read/write mode.
* @do_write: 0 = read, 1 = set up for DMA write
*/
static void vx2_setup_pseudo_dma(vx_core_t *chip, int do_write)
static void vx2_setup_pseudo_dma(struct vx_core *chip, int do_write)
{
/* Interrupt mode and HREQ pin enabled for host transmit data transfers
* (in case of the use of the pseudo-dma facility).
@ -235,7 +235,7 @@ static void vx2_setup_pseudo_dma(vx_core_t *chip, int do_write)
/*
* vx_release_pseudo_dma - disable the pseudo-DMA mode
*/
static inline void vx2_release_pseudo_dma(vx_core_t *chip)
static inline void vx2_release_pseudo_dma(struct vx_core *chip)
{
/* HREQ pin disabled. */
vx_outl(chip, ICR, 0);
@ -244,8 +244,8 @@ static inline void vx2_release_pseudo_dma(vx_core_t *chip)
/* pseudo-dma write */
static void vx2_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
unsigned long port = vx2_reg_addr(chip, VX_DMA);
int offset = pipe->hw_ptr;
@ -282,8 +282,8 @@ static void vx2_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime,
/* pseudo dma read */
static void vx2_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
int offset = pipe->hw_ptr;
u32 *addr = (u32 *)(runtime->dma_area + offset);
@ -321,7 +321,7 @@ static void vx2_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime,
/*
* transfer counts bits to PLX
*/
static int put_xilinx_data(vx_core_t *chip, unsigned int port, unsigned int counts, unsigned char data)
static int put_xilinx_data(struct vx_core *chip, unsigned int port, unsigned int counts, unsigned char data)
{
unsigned int i;
@ -353,7 +353,7 @@ static int put_xilinx_data(vx_core_t *chip, unsigned int port, unsigned int coun
/*
* load the xilinx image
*/
static int vx2_load_xilinx_binary(vx_core_t *chip, const struct firmware *xilinx)
static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *xilinx)
{
unsigned int i;
unsigned int port;
@ -400,7 +400,7 @@ static int vx2_load_xilinx_binary(vx_core_t *chip, const struct firmware *xilinx
/*
* load the boot/dsp images
*/
static int vx2_load_dsp(vx_core_t *vx, int index, const struct firmware *dsp)
static int vx2_load_dsp(struct vx_core *vx, int index, const struct firmware *dsp)
{
int err;
@ -432,7 +432,7 @@ static int vx2_load_dsp(vx_core_t *vx, int index, const struct firmware *dsp)
*
* spinlock held!
*/
static int vx2_test_and_ack(vx_core_t *chip)
static int vx2_test_and_ack(struct vx_core *chip)
{
/* not booted yet? */
if (! (chip->chip_status & VX_STAT_XILINX_LOADED))
@ -463,7 +463,7 @@ static int vx2_test_and_ack(vx_core_t *chip)
/*
* vx_validate_irq - enable/disable IRQ
*/
static void vx2_validate_irq(vx_core_t *_chip, int enable)
static void vx2_validate_irq(struct vx_core *_chip, int enable)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -484,7 +484,7 @@ static void vx2_validate_irq(vx_core_t *_chip, int enable)
/*
* write an AKM codec data (24bit)
*/
static void vx2_write_codec_reg(vx_core_t *chip, unsigned int data)
static void vx2_write_codec_reg(struct vx_core *chip, unsigned int data)
{
unsigned int i;
@ -660,7 +660,7 @@ static const u8 vx2_akm_gains_lut[VX2_AKM_LEVEL_MAX+1] = {
/*
* pseudo-codec write entry
*/
static void vx2_write_akm(vx_core_t *chip, int reg, unsigned int data)
static void vx2_write_akm(struct vx_core *chip, int reg, unsigned int data)
{
unsigned int val;
@ -695,7 +695,7 @@ static void vx2_write_akm(vx_core_t *chip, int reg, unsigned int data)
/*
* write codec bit for old VX222 board
*/
static void vx2_old_write_codec_bit(vx_core_t *chip, int codec, unsigned int data)
static void vx2_old_write_codec_bit(struct vx_core *chip, int codec, unsigned int data)
{
int i;
@ -713,7 +713,7 @@ static void vx2_old_write_codec_bit(vx_core_t *chip, int codec, unsigned int dat
/*
* reset codec bit
*/
static void vx2_reset_codec(vx_core_t *_chip)
static void vx2_reset_codec(struct vx_core *_chip)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -755,7 +755,7 @@ static void vx2_reset_codec(vx_core_t *_chip)
/*
* change the audio source
*/
static void vx2_change_audio_source(vx_core_t *_chip, int src)
static void vx2_change_audio_source(struct vx_core *_chip, int src)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -774,7 +774,7 @@ static void vx2_change_audio_source(vx_core_t *_chip, int src)
/*
* set the clock source
*/
static void vx2_set_clock_source(vx_core_t *_chip, int source)
static void vx2_set_clock_source(struct vx_core *_chip, int source)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -788,7 +788,7 @@ static void vx2_set_clock_source(vx_core_t *_chip, int source)
/*
* reset the board
*/
static void vx2_reset_board(vx_core_t *_chip, int cold_reset)
static void vx2_reset_board(struct vx_core *_chip, int cold_reset)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
@ -848,7 +848,7 @@ static void vx2_set_input_level(struct snd_vx222 *chip)
*/
/* input levels */
static int vx_input_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_input_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
@ -857,9 +857,9 @@ static int vx_input_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *ui
return 0;
}
static int vx_input_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_input_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
down(&_chip->mixer_mutex);
ucontrol->value.integer.value[0] = chip->input_level[0];
@ -868,9 +868,9 @@ static int vx_input_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uc
return 0;
}
static int vx_input_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
down(&_chip->mixer_mutex);
if (chip->input_level[0] != ucontrol->value.integer.value[0] ||
@ -886,7 +886,7 @@ static int vx_input_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uc
}
/* mic level */
static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
@ -895,17 +895,17 @@ static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinf
return 0;
}
static int vx_mic_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
ucontrol->value.integer.value[0] = chip->mic_level;
return 0;
}
static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
down(&_chip->mixer_mutex);
if (chip->mic_level != ucontrol->value.integer.value[0]) {
@ -918,7 +918,7 @@ static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucon
return 0;
}
static snd_kcontrol_new_t vx_control_input_level = {
static struct snd_kcontrol_new vx_control_input_level = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Capture Volume",
.info = vx_input_level_info,
@ -926,7 +926,7 @@ static snd_kcontrol_new_t vx_control_input_level = {
.put = vx_input_level_put,
};
static snd_kcontrol_new_t vx_control_mic_level = {
static struct snd_kcontrol_new vx_control_mic_level = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Mic Capture Volume",
.info = vx_mic_level_info,
@ -938,7 +938,7 @@ static snd_kcontrol_new_t vx_control_mic_level = {
* FIXME: compressor/limiter implementation is missing yet...
*/
static int vx2_add_mic_controls(vx_core_t *_chip)
static int vx2_add_mic_controls(struct vx_core *_chip)
{
struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
int err;

26
sound/pcmcia/vx/vxp_mixer.c
View file

@ -31,7 +31,7 @@
/*
* mic level control (for VXPocket)
*/
static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
@ -40,17 +40,17 @@ static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinf
return 0;
}
static int vx_mic_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
ucontrol->value.integer.value[0] = chip->mic_level;
return 0;
}
static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
down(&_chip->mixer_mutex);
if (chip->mic_level != ucontrol->value.integer.value[0]) {
@ -63,7 +63,7 @@ static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucon
return 0;
}
static snd_kcontrol_new_t vx_control_mic_level = {
static struct snd_kcontrol_new vx_control_mic_level = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Mic Capture Volume",
.info = vx_mic_level_info,
@ -74,7 +74,7 @@ static snd_kcontrol_new_t vx_control_mic_level = {
/*
* mic boost level control (for VXP440)
*/
static int vx_mic_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
static int vx_mic_boost_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1;
@ -83,17 +83,17 @@ static int vx_mic_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinf
return 0;
}
static int vx_mic_boost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_boost_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
ucontrol->value.integer.value[0] = chip->mic_level;
return 0;
}
static int vx_mic_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
static int vx_mic_boost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
vx_core_t *_chip = snd_kcontrol_chip(kcontrol);
struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
down(&_chip->mixer_mutex);
if (chip->mic_level != ucontrol->value.integer.value[0]) {
@ -106,7 +106,7 @@ static int vx_mic_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucon
return 0;
}
static snd_kcontrol_new_t vx_control_mic_boost = {
static struct snd_kcontrol_new vx_control_mic_boost = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Mic Boost",
.info = vx_mic_boost_info,
@ -115,7 +115,7 @@ static snd_kcontrol_new_t vx_control_mic_boost = {
};
int vxp_add_mic_controls(vx_core_t *_chip)
int vxp_add_mic_controls(struct vx_core *_chip)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
int err;

48
sound/pcmcia/vx/vxp_ops.c
View file

@ -49,7 +49,7 @@ static int vxp_reg_offset[VX_REG_MAX] = {
};
static inline unsigned long vxp_reg_addr(vx_core_t *_chip, int reg)
static inline unsigned long vxp_reg_addr(struct vx_core *_chip, int reg)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
return chip->port + vxp_reg_offset[reg];
@ -59,7 +59,7 @@ static inline unsigned long vxp_reg_addr(vx_core_t *_chip, int reg)
* snd_vx_inb - read a byte from the register
* @offset: register offset
*/
static unsigned char vxp_inb(vx_core_t *chip, int offset)
static unsigned char vxp_inb(struct vx_core *chip, int offset)
{
return inb(vxp_reg_addr(chip, offset));
}
@ -69,7 +69,7 @@ static unsigned char vxp_inb(vx_core_t *chip, int offset)
* @offset: the register offset
* @val: the value to write
*/
static void vxp_outb(vx_core_t *chip, int offset, unsigned char val)
static void vxp_outb(struct vx_core *chip, int offset, unsigned char val)
{
outb(val, vxp_reg_addr(chip, offset));
}
@ -78,9 +78,9 @@ static void vxp_outb(vx_core_t *chip, int offset, unsigned char val)
* redefine macros to call directly
*/
#undef vx_inb
#define vx_inb(chip,reg) vxp_inb((vx_core_t*)(chip), VX_##reg)
#define vx_inb(chip,reg) vxp_inb((struct vx_core *)(chip), VX_##reg)
#undef vx_outb
#define vx_outb(chip,reg,val) vxp_outb((vx_core_t*)(chip), VX_##reg,val)
#define vx_outb(chip,reg,val) vxp_outb((struct vx_core *)(chip), VX_##reg,val)
/*
@ -88,7 +88,7 @@ static void vxp_outb(vx_core_t *chip, int offset, unsigned char val)
*
* returns zero if a magic word is detected, or a negative error code.
*/
static int vx_check_magic(vx_core_t *chip)
static int vx_check_magic(struct vx_core *chip)
{
unsigned long end_time = jiffies + HZ / 5;
int c;
@ -109,7 +109,7 @@ static int vx_check_magic(vx_core_t *chip)
#define XX_DSP_RESET_WAIT_TIME 2 /* ms */
static void vxp_reset_dsp(vx_core_t *_chip)
static void vxp_reset_dsp(struct vx_core *_chip)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -127,7 +127,7 @@ static void vxp_reset_dsp(vx_core_t *_chip)
/*
* reset codec bit
*/
static void vxp_reset_codec(vx_core_t *_chip)
static void vxp_reset_codec(struct vx_core *_chip)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -146,7 +146,7 @@ static void vxp_reset_codec(vx_core_t *_chip)
* vx_load_xilinx_binary - load the xilinx binary image
* the binary image is the binary array converted from the bitstream file.
*/
static int vxp_load_xilinx_binary(vx_core_t *_chip, const struct firmware *fw)
static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware *fw)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
unsigned int i;
@ -244,7 +244,7 @@ static int vxp_load_xilinx_binary(vx_core_t *_chip, const struct firmware *fw)
/*
* vxp_load_dsp - load_dsp callback
*/
static int vxp_load_dsp(vx_core_t *vx, int index, const struct firmware *fw)
static int vxp_load_dsp(struct vx_core *vx, int index, const struct firmware *fw)
{
int err;
@ -279,7 +279,7 @@ static int vxp_load_dsp(vx_core_t *vx, int index, const struct firmware *fw)
*
* spinlock held!
*/
static int vxp_test_and_ack(vx_core_t *_chip)
static int vxp_test_and_ack(struct vx_core *_chip)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -306,7 +306,7 @@ static int vxp_test_and_ack(vx_core_t *_chip)
/*
* vx_validate_irq - enable/disable IRQ
*/
static void vxp_validate_irq(vx_core_t *_chip, int enable)
static void vxp_validate_irq(struct vx_core *_chip, int enable)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -322,7 +322,7 @@ static void vxp_validate_irq(vx_core_t *_chip, int enable)
* vx_setup_pseudo_dma - set up the pseudo dma read/write mode.
* @do_write: 0 = read, 1 = set up for DMA write
*/
static void vx_setup_pseudo_dma(vx_core_t *_chip, int do_write)
static void vx_setup_pseudo_dma(struct vx_core *_chip, int do_write)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -342,7 +342,7 @@ static void vx_setup_pseudo_dma(vx_core_t *_chip, int do_write)
/*
* vx_release_pseudo_dma - disable the pseudo-DMA mode
*/
static void vx_release_pseudo_dma(vx_core_t *_chip)
static void vx_release_pseudo_dma(struct vx_core *_chip)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -362,8 +362,8 @@ static void vx_release_pseudo_dma(vx_core_t *_chip)
* data size must be aligned to 6 bytes to ensure the 24bit alignment on DSP.
* NB: call with a certain lock!
*/
static void vxp_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
long port = vxp_reg_addr(chip, VX_DMA);
int offset = pipe->hw_ptr;
@ -401,8 +401,8 @@ static void vxp_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime,
* the read length must be aligned to 6 bytes, as well as write.
* NB: call with a certain lock!
*/
static void vxp_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime,
vx_pipe_t *pipe, int count)
static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
struct vx_pipe *pipe, int count)
{
struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip;
long port = vxp_reg_addr(chip, VX_DMA);
@ -442,7 +442,7 @@ static void vxp_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime,
/*
* write a codec data (24bit)
*/
static void vxp_write_codec_reg(vx_core_t *chip, int codec, unsigned int data)
static void vxp_write_codec_reg(struct vx_core *chip, int codec, unsigned int data)
{
int i;
@ -465,7 +465,7 @@ static void vxp_write_codec_reg(vx_core_t *chip, int codec, unsigned int data)
* vx_set_mic_boost - set mic boost level (on vxp440 only)
* @boost: 0 = 20dB, 1 = +38dB
*/
void vx_set_mic_boost(vx_core_t *chip, int boost)
void vx_set_mic_boost(struct vx_core *chip, int boost)
{
struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip;
unsigned long flags;
@ -508,7 +508,7 @@ static int vx_compute_mic_level(int level)
* vx_set_mic_level - set mic level (on vxpocket only)
* @level: the mic level = 0 - 8 (max)
*/
void vx_set_mic_level(vx_core_t *chip, int level)
void vx_set_mic_level(struct vx_core *chip, int level)
{
struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip;
unsigned long flags;
@ -528,7 +528,7 @@ void vx_set_mic_level(vx_core_t *chip, int level)
/*
* change the input audio source
*/
static void vxp_change_audio_source(vx_core_t *_chip, int src)
static void vxp_change_audio_source(struct vx_core *_chip, int src)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -568,7 +568,7 @@ static void vxp_change_audio_source(vx_core_t *_chip, int src)
* change the clock source
* source = INTERNAL_QUARTZ or UER_SYNC
*/
static void vxp_set_clock_source(vx_core_t *_chip, int source)
static void vxp_set_clock_source(struct vx_core *_chip, int source)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;
@ -583,7 +583,7 @@ static void vxp_set_clock_source(vx_core_t *_chip, int source)
/*
* reset the board
*/
static void vxp_reset_board(vx_core_t *_chip, int cold_reset)
static void vxp_reset_board(struct vx_core *_chip, int cold_reset)
{
struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip;

26
sound/pcmcia/vx/vxpocket.c
View file

@ -83,9 +83,9 @@ static void vxpocket_release(dev_link_t *link)
/*
* destructor, called from snd_card_free_in_thread()
*/
static int snd_vxpocket_dev_free(snd_device_t *device)
static int snd_vxpocket_dev_free(struct snd_device *device)
{
vx_core_t *chip = device->device_data;
struct vx_core *chip = device->device_data;
snd_vx_free_firmware(chip);
kfree(chip);
@ -142,19 +142,19 @@ static struct snd_vx_hardware vxp440_hw = {
/*
* create vxpocket instance
*/
static struct snd_vxpocket *snd_vxpocket_new(snd_card_t *card, int ibl)
static struct snd_vxpocket *snd_vxpocket_new(struct snd_card *card, int ibl)
{
client_reg_t client_reg; /* Register with cardmgr */
dev_link_t *link; /* Info for cardmgr */
vx_core_t *chip;
struct vx_core *chip;
struct snd_vxpocket *vxp;
int ret;
static snd_device_ops_t ops = {
static struct snd_device_ops ops = {
.dev_free = snd_vxpocket_dev_free,
};
chip = snd_vx_create(card, &vxpocket_hw, &snd_vxpocket_ops,
sizeof(struct snd_vxpocket) - sizeof(vx_core_t));
sizeof(struct snd_vxpocket) - sizeof(struct vx_core));
if (! chip)
return NULL;
@ -218,10 +218,10 @@ static struct snd_vxpocket *snd_vxpocket_new(snd_card_t *card, int ibl)
*
* returns 0 if successful, or a negative error code.
*/
static int snd_vxpocket_assign_resources(vx_core_t *chip, int port, int irq)
static int snd_vxpocket_assign_resources(struct vx_core *chip, int port, int irq)
{
int err;
snd_card_t *card = chip->card;
struct snd_card *card = chip->card;
struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip;
snd_printdd(KERN_DEBUG "vxpocket assign resources: port = 0x%x, irq = %d\n", port, irq);
@ -250,7 +250,7 @@ do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
static void vxpocket_config(dev_link_t *link)
{
client_handle_t handle = link->handle;
vx_core_t *chip = link->priv;
struct vx_core *chip = link->priv;
struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip;
tuple_t tuple;
cisparse_t *parse;
@ -324,7 +324,7 @@ failed:
static int vxpocket_event(event_t event, int priority, event_callback_args_t *args)
{
dev_link_t *link = args->client_data;
vx_core_t *chip = link->priv;
struct vx_core *chip = link->priv;
switch (event) {
case CS_EVENT_CARD_REMOVAL:
@ -379,7 +379,7 @@ static int vxpocket_event(event_t event, int priority, event_callback_args_t *ar
*/
static dev_link_t *vxpocket_attach(void)
{
snd_card_t *card;
struct snd_card *card;
struct snd_vxpocket *vxp;
int i;
@ -421,14 +421,14 @@ static dev_link_t *vxpocket_attach(void)
static void vxpocket_detach(dev_link_t *link)
{
struct snd_vxpocket *vxp;
vx_core_t *chip;
struct vx_core *chip;
dev_link_t **linkp;
if (! link)
return;
vxp = link->priv;
chip = (vx_core_t *)vxp;
chip = (struct vx_core *)vxp;
card_alloc &= ~(1 << vxp->index);
/* Remove the interface data from the linked list */

8
sound/pcmcia/vx/vxpocket.h
View file

@ -30,7 +30,7 @@
struct snd_vxpocket {
vx_core_t core;
struct vx_core core;
unsigned long port;
@ -48,10 +48,10 @@ struct snd_vxpocket {
extern struct snd_vx_ops snd_vxpocket_ops;
void vx_set_mic_boost(vx_core_t *chip, int boost);
void vx_set_mic_level(vx_core_t *chip, int level);
void vx_set_mic_boost(struct vx_core *chip, int boost);
void vx_set_mic_level(struct vx_core *chip, int level);
int vxp_add_mic_controls(vx_core_t *chip);
int vxp_add_mic_controls(struct vx_core *chip);
/* Constants used to access the CDSP register (0x08). */
#define CDSP_MAGIC 0xA7 /* magic value (for read) */