microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

[ALSA] Remove xxx_t typedefs: VXdriver 

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 коммит произвёл Jaroslav Kysela
Родитель 9f38945fab
Коммит af26367f69
13 изменённых файлов: 410 добавлений и 389 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

123
include/sound/vx_core.h
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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
Просмотреть файл

@ -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) */