Skip to content

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

[ALSA] Remove xxx_t typedefs: PCI Trident 

Modules: Trident driver

Remove xxx_t typedefs from the PCI Trident driver.
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent abfd67bd
Hide whitespace changes
Inline Side-by-side
Showing with 592 additions and 522 deletions
include/sound/trident.h
View file @ bee1a5be
...@@ -253,43 +253,43 @@ enum serial_intf_ctrl_bits { ...@@ -253,43 +253,43 @@ enum serial_intf_ctrl_bits {
#define T4D_DEFAULT_PCM_RVOL 127 /* 0 - 127 */ #define T4D_DEFAULT_PCM_RVOL 127 /* 0 - 127 */
#define T4D_DEFAULT_PCM_CVOL 127 /* 0 - 127 */ #define T4D_DEFAULT_PCM_CVOL 127 /* 0 - 127 */
typedef struct _snd_trident trident_t; struct snd_trident;
typedef struct _snd_trident_voice snd_trident_voice_t; struct snd_trident_voice;
typedef struct _snd_trident_pcm_mixer snd_trident_pcm_mixer_t; struct snd_trident_pcm_mixer;
typedef struct { struct snd_trident_sample_ops {
void (*sample_start)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_position_t position); void (*sample_start)(struct snd_trident *gus, struct snd_trident_voice *voice, snd_seq_position_t position);
void (*sample_stop)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_stop_mode_t mode); void (*sample_stop)(struct snd_trident *gus, struct snd_trident_voice *voice, int mode);
void (*sample_freq)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_frequency_t freq); void (*sample_freq)(struct snd_trident *gus, struct snd_trident_voice *voice, snd_seq_frequency_t freq);
void (*sample_volume)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_ev_volume_t *volume); void (*sample_volume)(struct snd_trident *gus, struct snd_trident_voice *voice, struct snd_seq_ev_volume *volume);
void (*sample_loop)(trident_t *card, snd_trident_voice_t *voice, snd_seq_ev_loop_t *loop); void (*sample_loop)(struct snd_trident *card, struct snd_trident_voice *voice, struct snd_seq_ev_loop *loop);
void (*sample_pos)(trident_t *card, snd_trident_voice_t *voice, snd_seq_position_t position); void (*sample_pos)(struct snd_trident *card, struct snd_trident_voice *voice, snd_seq_position_t position);
void (*sample_private1)(trident_t *card, snd_trident_voice_t *voice, unsigned char *data); void (*sample_private1)(struct snd_trident *card, struct snd_trident_voice *voice, unsigned char *data);
} snd_trident_sample_ops_t; };
typedef struct { struct snd_trident_port {
snd_midi_channel_set_t * chset; struct snd_midi_channel_set * chset;
trident_t * trident; struct snd_trident * trident;
int mode; /* operation mode */ int mode; /* operation mode */
int client; /* sequencer client number */ int client; /* sequencer client number */
int port; /* sequencer port number */ int port; /* sequencer port number */
unsigned int midi_has_voices: 1; unsigned int midi_has_voices: 1;
} snd_trident_port_t; };
typedef struct snd_trident_memblk_arg { struct snd_trident_memblk_arg {
short first_page, last_page; short first_page, last_page;
} snd_trident_memblk_arg_t; };
typedef struct { struct snd_trident_tlb {
unsigned int * entries; /* 16k-aligned TLB table */ unsigned int * entries; /* 16k-aligned TLB table */
dma_addr_t entries_dmaaddr; /* 16k-aligned PCI address to TLB table */ dma_addr_t entries_dmaaddr; /* 16k-aligned PCI address to TLB table */
unsigned long * shadow_entries; /* shadow entries with virtual addresses */ unsigned long * shadow_entries; /* shadow entries with virtual addresses */
struct snd_dma_buffer buffer; struct snd_dma_buffer buffer;
snd_util_memhdr_t * memhdr; /* page allocation list */ struct snd_util_memhdr * memhdr; /* page allocation list */
struct snd_dma_buffer silent_page; struct snd_dma_buffer silent_page;
} snd_trident_tlb_t; };
struct _snd_trident_voice { struct snd_trident_voice {
unsigned int number; unsigned int number;
unsigned int use: 1, unsigned int use: 1,
pcm: 1, pcm: 1,
...@@ -300,8 +300,8 @@ struct _snd_trident_voice { ...@@ -300,8 +300,8 @@ struct _snd_trident_voice {
unsigned char port; unsigned char port;
unsigned char index; unsigned char index;
snd_seq_instr_t instr; struct snd_seq_instr instr;
snd_trident_sample_ops_t *sample_ops; struct snd_trident_sample_ops *sample_ops;
/* channel parameters */ /* channel parameters */
unsigned int CSO; /* 24 bits (16 on DX) */ unsigned int CSO; /* 24 bits (16 on DX) */
...@@ -323,13 +323,13 @@ struct _snd_trident_voice { ...@@ -323,13 +323,13 @@ struct _snd_trident_voice {
unsigned int negCSO; /* nonzero - use negative CSO */ unsigned int negCSO; /* nonzero - use negative CSO */
snd_util_memblk_t *memblk; /* memory block if TLB enabled */ struct snd_util_memblk *memblk; /* memory block if TLB enabled */
/* PCM data */ /* PCM data */
trident_t *trident; struct snd_trident *trident;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
snd_trident_voice_t *extra; /* extra PCM voice (acts as interrupt generator) */ struct snd_trident_voice *extra; /* extra PCM voice (acts as interrupt generator) */
unsigned int running: 1, unsigned int running: 1,
capture: 1, capture: 1,
spdif: 1, spdif: 1,
...@@ -347,25 +347,25 @@ struct _snd_trident_voice { ...@@ -347,25 +347,25 @@ struct _snd_trident_voice {
/* --- */ /* --- */
void *private_data; void *private_data;
void (*private_free)(snd_trident_voice_t *voice); void (*private_free)(struct snd_trident_voice *voice);
}; };
struct _snd_4dwave { struct snd_4dwave {
int seq_client; int seq_client;
snd_trident_port_t seq_ports[4]; struct snd_trident_port seq_ports[4];
snd_simple_ops_t simple_ops; struct snd_simple_ops simple_ops;
snd_seq_kinstr_list_t *ilist; struct snd_seq_kinstr_list *ilist;
snd_trident_voice_t voices[64]; struct snd_trident_voice voices[64];
int ChanSynthCount; /* number of allocated synth channels */ int ChanSynthCount; /* number of allocated synth channels */
int max_size; /* maximum synth memory size in bytes */ int max_size; /* maximum synth memory size in bytes */
int current_size; /* current allocated synth mem in bytes */ int current_size; /* current allocated synth mem in bytes */
}; };
struct _snd_trident_pcm_mixer { struct snd_trident_pcm_mixer {
snd_trident_voice_t *voice; /* active voice */ struct snd_trident_voice *voice; /* active voice */
unsigned short vol; /* front volume */ unsigned short vol; /* front volume */
unsigned char pan; /* pan control */ unsigned char pan; /* pan control */
unsigned char rvol; /* rear volume */ unsigned char rvol; /* rear volume */
...@@ -373,7 +373,7 @@ struct _snd_trident_pcm_mixer { ...@@ -373,7 +373,7 @@ struct _snd_trident_pcm_mixer {
unsigned char pad; unsigned char pad;
}; };
struct _snd_trident { struct snd_trident {
int irq; int irq;
unsigned int device; /* device ID */ unsigned int device; /* device ID */
...@@ -386,13 +386,13 @@ struct _snd_trident { ...@@ -386,13 +386,13 @@ struct _snd_trident {
unsigned int spurious_irq_count; unsigned int spurious_irq_count;
unsigned int spurious_irq_max_delta; unsigned int spurious_irq_max_delta;
snd_trident_tlb_t tlb; /* TLB entries for NX cards */ struct snd_trident_tlb tlb; /* TLB entries for NX cards */
unsigned char spdif_ctrl; unsigned char spdif_ctrl;
unsigned char spdif_pcm_ctrl; unsigned char spdif_pcm_ctrl;
unsigned int spdif_bits; unsigned int spdif_bits;
unsigned int spdif_pcm_bits; unsigned int spdif_pcm_bits;
snd_kcontrol_t *spdif_pcm_ctl; /* S/PDIF settings */ struct snd_kcontrol *spdif_pcm_ctl; /* S/PDIF settings */
unsigned int ac97_ctrl; unsigned int ac97_ctrl;
unsigned int ChanMap[2]; /* allocation map for hardware channels */ unsigned int ChanMap[2]; /* allocation map for hardware channels */
...@@ -403,7 +403,7 @@ struct _snd_trident { ...@@ -403,7 +403,7 @@ struct _snd_trident {
unsigned int ac97_detect: 1; /* 1 = AC97 in detection phase */ unsigned int ac97_detect: 1; /* 1 = AC97 in detection phase */
unsigned int in_suspend: 1; /* 1 during suspend/resume */ unsigned int in_suspend: 1; /* 1 during suspend/resume */
struct _snd_4dwave synth; /* synth specific variables */ struct snd_4dwave synth; /* synth specific variables */
spinlock_t event_lock; spinlock_t event_lock;
spinlock_t voice_alloc; spinlock_t voice_alloc;
...@@ -411,52 +411,55 @@ struct _snd_trident { ...@@ -411,52 +411,55 @@ struct _snd_trident {
struct snd_dma_device dma_dev; struct snd_dma_device dma_dev;
struct pci_dev *pci; struct pci_dev *pci;
snd_card_t *card; struct snd_card *card;
snd_pcm_t *pcm; /* ADC/DAC PCM */ struct snd_pcm *pcm; /* ADC/DAC PCM */
snd_pcm_t *foldback; /* Foldback PCM */ struct snd_pcm *foldback; /* Foldback PCM */
snd_pcm_t *spdif; /* SPDIF PCM */ struct snd_pcm *spdif; /* SPDIF PCM */
snd_rawmidi_t *rmidi; struct snd_rawmidi *rmidi;
snd_seq_device_t *seq_dev; struct snd_seq_device *seq_dev;
ac97_bus_t *ac97_bus; struct snd_ac97_bus *ac97_bus;
ac97_t *ac97; struct snd_ac97 *ac97;
ac97_t *ac97_sec; struct snd_ac97 *ac97_sec;
unsigned int musicvol_wavevol; unsigned int musicvol_wavevol;
snd_trident_pcm_mixer_t pcm_mixer[32]; struct snd_trident_pcm_mixer pcm_mixer[32];
snd_kcontrol_t *ctl_vol; /* front volume */ struct snd_kcontrol *ctl_vol; /* front volume */
snd_kcontrol_t *ctl_pan; /* pan */ struct snd_kcontrol *ctl_pan; /* pan */
snd_kcontrol_t *ctl_rvol; /* rear volume */ struct snd_kcontrol *ctl_rvol; /* rear volume */
snd_kcontrol_t *ctl_cvol; /* center volume */ struct snd_kcontrol *ctl_cvol; /* center volume */
spinlock_t reg_lock; spinlock_t reg_lock;
struct gameport *gameport; struct gameport *gameport;
}; };
int snd_trident_create(snd_card_t * card, int snd_trident_create(struct snd_card *card,
struct pci_dev *pci, struct pci_dev *pci,
int pcm_streams, int pcm_streams,
int pcm_spdif_device, int pcm_spdif_device,
int max_wavetable_size, int max_wavetable_size,
trident_t ** rtrident); struct snd_trident ** rtrident);
int snd_trident_create_gameport(trident_t *trident); int snd_trident_create_gameport(struct snd_trident *trident);
int snd_trident_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); int snd_trident_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
int snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); int snd_trident_foldback_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
int snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); int snd_trident_spdif_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
int snd_trident_attach_synthesizer(trident_t * trident); int snd_trident_attach_synthesizer(struct snd_trident * trident);
snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port); struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type,
void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice); int client, int port);
void snd_trident_start_voice(trident_t * trident, unsigned int voice); void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice);
void snd_trident_stop_voice(trident_t * trident, unsigned int voice); void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice);
void snd_trident_write_voice_regs(trident_t * trident, snd_trident_voice_t *voice); void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice);
void snd_trident_write_voice_regs(struct snd_trident * trident, struct snd_trident_voice *voice);
/* TLB memory allocation */ /* TLB memory allocation */
snd_util_memblk_t *snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream); struct snd_util_memblk *snd_trident_alloc_pages(struct snd_trident *trident,
int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk); struct snd_pcm_substream *substream);
snd_util_memblk_t *snd_trident_synth_alloc(trident_t *trident, unsigned int size); int snd_trident_free_pages(struct snd_trident *trident, struct snd_util_memblk *blk);
int snd_trident_synth_free(trident_t *trident, snd_util_memblk_t *blk); struct snd_util_memblk *snd_trident_synth_alloc(struct snd_trident *trident, unsigned int size);
int snd_trident_synth_copy_from_user(trident_t *trident, snd_util_memblk_t *blk, int offset, const char __user *data, int size); int snd_trident_synth_free(struct snd_trident *trident, struct snd_util_memblk *blk);
int snd_trident_synth_copy_from_user(struct snd_trident *trident, struct snd_util_memblk *blk,
int offset, const char __user *data, int size);
#endif /* __SOUND_TRIDENT_H */ #endif /* __SOUND_TRIDENT_H */
sound/pci/trident/trident.c
View file @ bee1a5be
...@@ -76,8 +76,8 @@ static int __devinit snd_trident_probe(struct pci_dev *pci, ...@@ -76,8 +76,8 @@ static int __devinit snd_trident_probe(struct pci_dev *pci,
const struct pci_device_id *pci_id) const struct pci_device_id *pci_id)
{ {
static int dev; static int dev;
snd_card_t *card; struct snd_card *card;
trident_t *trident; struct snd_trident *trident;
const char *str; const char *str;
int err, pcm_dev = 0; int err, pcm_dev = 0;
......
sound/pci/trident/trident_main.c
View file @ bee1a5be
...@@ -44,17 +44,23 @@ ...@@ -44,17 +44,23 @@
#include <asm/io.h> #include <asm/io.h>
static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream); static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream); struct snd_trident_voice * voice,
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs); struct snd_pcm_substream *substream);
static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
struct snd_trident_voice * voice,
struct snd_pcm_substream *substream);
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id,
struct pt_regs *regs);
#ifdef CONFIG_PM #ifdef CONFIG_PM
static int snd_trident_suspend(snd_card_t *card, pm_message_t state); static int snd_trident_suspend(struct snd_card *card, pm_message_t state);
static int snd_trident_resume(snd_card_t *card); static int snd_trident_resume(struct snd_card *card);
#endif #endif
static int snd_trident_sis_reset(trident_t *trident); static int snd_trident_sis_reset(struct snd_trident *trident);
static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max); static void snd_trident_clear_voices(struct snd_trident * trident,
static int snd_trident_free(trident_t *trident); unsigned short v_min, unsigned short v_max);
static int snd_trident_free(struct snd_trident *trident);
/* /*
* common I/O routines * common I/O routines
...@@ -62,7 +68,7 @@ static int snd_trident_free(trident_t *trident); ...@@ -62,7 +68,7 @@ static int snd_trident_free(trident_t *trident);
#if 0 #if 0
static void snd_trident_print_voice_regs(trident_t *trident, int voice) static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
{ {
unsigned int val, tmp; unsigned int val, tmp;
...@@ -104,7 +110,7 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice) ...@@ -104,7 +110,7 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice)
#endif #endif
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
Description: This routine will do all of the reading from the external Description: This routine will do all of the reading from the external
CODEC (AC97). CODEC (AC97).
...@@ -115,12 +121,12 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice) ...@@ -115,12 +121,12 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice)
returns: 16 bit value read from the AC97. returns: 16 bit value read from the AC97.
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
{ {
unsigned int data = 0, treg; unsigned int data = 0, treg;
unsigned short count = 0xffff; unsigned short count = 0xffff;
unsigned long flags; unsigned long flags;
trident_t *trident = ac97->private_data; struct snd_trident *trident = ac97->private_data;
spin_lock_irqsave(&trident->reg_lock, flags); spin_lock_irqsave(&trident->reg_lock, flags);
if (trident->device == TRIDENT_DEVICE_ID_DX) { if (trident->device == TRIDENT_DEVICE_ID_DX) {
...@@ -153,7 +159,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) ...@@ -153,7 +159,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
} }
if (count == 0 && !trident->ac97_detect) { if (count == 0 && !trident->ac97_detect) {
snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n", reg, data); snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
reg, data);
data = 0; data = 0;
} }
...@@ -162,7 +169,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) ...@@ -162,7 +169,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata) void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
unsigned short wdata)
Description: This routine will do all of the writing to the external Description: This routine will do all of the writing to the external
CODEC (AC97). CODEC (AC97).
...@@ -174,12 +182,13 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) ...@@ -174,12 +182,13 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
returns: TRUE if everything went ok, else FALSE. returns: TRUE if everything went ok, else FALSE.
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata) static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
unsigned short wdata)
{ {
unsigned int address, data; unsigned int address, data;
unsigned short count = 0xffff; unsigned short count = 0xffff;
unsigned long flags; unsigned long flags;
trident_t *trident = ac97->private_data; struct snd_trident *trident = ac97->private_data;
data = ((unsigned long) wdata) << 16; data = ((unsigned long) wdata) << 16;
...@@ -230,7 +239,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s ...@@ -230,7 +239,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
void snd_trident_enable_eso(trident_t *trident) void snd_trident_enable_eso(struct snd_trident *trident)
Description: This routine will enable end of loop interrupts. Description: This routine will enable end of loop interrupts.
End of loop interrupts will occur when a running End of loop interrupts will occur when a running
...@@ -241,7 +250,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s ...@@ -241,7 +250,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_enable_eso(trident_t * trident) static void snd_trident_enable_eso(struct snd_trident * trident)
{ {
unsigned int val; unsigned int val;
...@@ -254,7 +263,7 @@ static void snd_trident_enable_eso(trident_t * trident) ...@@ -254,7 +263,7 @@ static void snd_trident_enable_eso(trident_t * trident)
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
void snd_trident_disable_eso(trident_t *trident) void snd_trident_disable_eso(struct snd_trident *trident)
Description: This routine will disable end of loop interrupts. Description: This routine will disable end of loop interrupts.
End of loop interrupts will occur when a running End of loop interrupts will occur when a running
...@@ -268,7 +277,7 @@ static void snd_trident_enable_eso(trident_t * trident) ...@@ -268,7 +277,7 @@ static void snd_trident_enable_eso(trident_t * trident)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_disable_eso(trident_t * trident) static void snd_trident_disable_eso(struct snd_trident * trident)
{ {
unsigned int tmp; unsigned int tmp;
...@@ -279,7 +288,7 @@ static void snd_trident_disable_eso(trident_t * trident) ...@@ -279,7 +288,7 @@ static void snd_trident_disable_eso(trident_t * trident)
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
void snd_trident_start_voice(trident_t * trident, unsigned int voice) void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
Description: Start a voice, any channel 0 thru 63. Description: Start a voice, any channel 0 thru 63.
This routine automatically handles the fact that there are This routine automatically handles the fact that there are
...@@ -292,7 +301,7 @@ static void snd_trident_disable_eso(trident_t * trident) ...@@ -292,7 +301,7 @@ static void snd_trident_disable_eso(trident_t * trident)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
void snd_trident_start_voice(trident_t * trident, unsigned int voice) void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
{ {
unsigned int mask = 1 << (voice & 0x1f); unsigned int mask = 1 << (voice & 0x1f);
unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A; unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
...@@ -301,7 +310,7 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice) ...@@ -301,7 +310,7 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice)
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
void snd_trident_stop_voice(trident_t * trident, unsigned int voice) void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
Description: Stop a voice, any channel 0 thru 63. Description: Stop a voice, any channel 0 thru 63.
This routine automatically handles the fact that there are This routine automatically handles the fact that there are
...@@ -314,7 +323,7 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice) ...@@ -314,7 +323,7 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
void snd_trident_stop_voice(trident_t * trident, unsigned int voice) void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
{ {
unsigned int mask = 1 << (voice & 0x1f); unsigned int mask = 1 << (voice & 0x1f);
unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A; unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
...@@ -323,7 +332,7 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice) ...@@ -323,7 +332,7 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice)
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
int snd_trident_allocate_pcm_channel(trident_t *trident) int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
Description: Allocate hardware channel in Bank B (32-63). Description: Allocate hardware channel in Bank B (32-63).
...@@ -333,7 +342,7 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice) ...@@ -333,7 +342,7 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_allocate_pcm_channel(trident_t * trident) static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
{ {
int idx; int idx;
...@@ -361,7 +370,7 @@ static int snd_trident_allocate_pcm_channel(trident_t * trident) ...@@ -361,7 +370,7 @@ static int snd_trident_allocate_pcm_channel(trident_t * trident)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_free_pcm_channel(trident_t *trident, int channel) static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
{ {
if (channel < 32 || channel > 63) if (channel < 32 || channel > 63)
return; return;
...@@ -383,7 +392,7 @@ static void snd_trident_free_pcm_channel(trident_t *trident, int channel) ...@@ -383,7 +392,7 @@ static void snd_trident_free_pcm_channel(trident_t *trident, int channel)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_allocate_synth_channel(trident_t * trident) static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
{ {
int idx; int idx;
...@@ -409,7 +418,7 @@ static int snd_trident_allocate_synth_channel(trident_t * trident) ...@@ -409,7 +418,7 @@ static int snd_trident_allocate_synth_channel(trident_t * trident)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_free_synth_channel(trident_t *trident, int channel) static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
{ {
if (channel < 0 || channel > 31) if (channel < 0 || channel > 31)
return; return;
...@@ -432,8 +441,8 @@ static void snd_trident_free_synth_channel(trident_t *trident, int channel) ...@@ -432,8 +441,8 @@ static void snd_trident_free_synth_channel(trident_t *trident, int channel)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
void snd_trident_write_voice_regs(trident_t * trident, void snd_trident_write_voice_regs(struct snd_trident * trident,
snd_trident_voice_t * voice) struct snd_trident_voice * voice)
{ {
unsigned int FmcRvolCvol; unsigned int FmcRvolCvol;
unsigned int regs[5]; unsigned int regs[5];
...@@ -452,14 +461,16 @@ void snd_trident_write_voice_regs(trident_t * trident, ...@@ -452,14 +461,16 @@ void snd_trident_write_voice_regs(trident_t * trident,
(voice->Vol & 0x000003ff) : (voice->Vol & 0x000003ff) :
((voice->Vol & 0x00003fc) << (16-2)) | ((voice->Vol & 0x00003fc) << (16-2)) |
(voice->EC & 0x00000fff); (voice->EC & 0x00000fff);
regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | (voice->FMS & 0x0000000f); regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
(voice->FMS & 0x0000000f);
regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
regs[3] = (voice->Attribute << 16) | FmcRvolCvol; regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
break; break;
case TRIDENT_DEVICE_ID_DX: case TRIDENT_DEVICE_ID_DX:
regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
(voice->EC & 0x00000fff); (voice->EC & 0x00000fff);
regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | (voice->FMS & 0x0000000f); regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
(voice->FMS & 0x0000000f);
regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
regs[3] = FmcRvolCvol; regs[3] = FmcRvolCvol;
break; break;
...@@ -467,8 +478,10 @@ void snd_trident_write_voice_regs(trident_t * trident, ...@@ -467,8 +478,10 @@ void snd_trident_write_voice_regs(trident_t * trident,
regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
(voice->EC & 0x00000fff); (voice->EC & 0x00000fff);
regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff); regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);
regs[2] = ((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff); regs[2] = ((voice->Delta << 16) & 0xff000000) |
regs[3] = (voice->Alpha << 20) | ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol; (voice->ESO & 0x00ffffff);
regs[3] = (voice->Alpha << 20) |
((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
break; break;
default: default:
snd_BUG(); snd_BUG();
...@@ -504,14 +517,17 @@ void snd_trident_write_voice_regs(trident_t * trident, ...@@ -504,14 +517,17 @@ void snd_trident_write_voice_regs(trident_t * trident,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CSO) static void snd_trident_write_cso_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int CSO)
{ {
voice->CSO = CSO; voice->CSO = CSO;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
if (trident->device != TRIDENT_DEVICE_ID_NX) { if (trident->device != TRIDENT_DEVICE_ID_NX) {
outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2); outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
} else { } else {
outl((voice->Delta << 24) | (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO)); outl((voice->Delta << 24) |
(voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
} }
} }
...@@ -527,14 +543,17 @@ static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t * ...@@ -527,14 +543,17 @@ static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t *
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int ESO) static void snd_trident_write_eso_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int ESO)
{ {
voice->ESO = ESO; voice->ESO = ESO;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
if (trident->device != TRIDENT_DEVICE_ID_NX) { if (trident->device != TRIDENT_DEVICE_ID_NX) {
outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2); outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
} else { } else {
outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_ESO)); outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
TRID_REG(trident, CH_NX_DELTA_ESO));
} }
} }
...@@ -550,7 +569,9 @@ static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t * ...@@ -550,7 +569,9 @@ static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t *
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Vol) static void snd_trident_write_vol_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int Vol)
{ {
voice->Vol = Vol; voice->Vol = Vol;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
...@@ -561,7 +582,8 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t * ...@@ -561,7 +582,8 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t *
break; break;
case TRIDENT_DEVICE_ID_SI7018: case TRIDENT_DEVICE_ID_SI7018:
// printk("voice->Vol = 0x%x\n", voice->Vol); // printk("voice->Vol = 0x%x\n", voice->Vol);
outw((voice->CTRL << 12) | voice->Vol, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); outw((voice->CTRL << 12) | voice->Vol,
TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
break; break;
} }
} }
...@@ -578,11 +600,14 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t * ...@@ -578,11 +600,14 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t *
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Pan) static void snd_trident_write_pan_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int Pan)
{ {
voice->Pan = Pan; voice->Pan = Pan;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f), TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3)); outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
...@@ -597,12 +622,16 @@ static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t * ...@@ -597,12 +622,16 @@ static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t *
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int RVol) static void snd_trident_write_rvol_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int RVol)
{ {
voice->RVol = RVol; voice->RVol = RVol;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | (voice->CVol & 0x007f), outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); (voice->CVol & 0x007f),
TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
...@@ -617,12 +646,16 @@ static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t ...@@ -617,12 +646,16 @@ static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static void snd_trident_write_cvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CVol) static void snd_trident_write_cvol_reg(struct snd_trident * trident,
struct snd_trident_voice * voice,
unsigned int CVol)
{ {
voice->CVol = CVol; voice->CVol = CVol;
outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | (voice->CVol & 0x007f), outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); (voice->CVol & 0x007f),
TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
} }
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
...@@ -696,7 +729,8 @@ static unsigned int snd_trident_convert_adc_rate(unsigned int rate) ...@@ -696,7 +729,8 @@ static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
Returns: Delta value. Returns: Delta value.
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned int period_size) static unsigned int snd_trident_spurious_threshold(unsigned int rate,
unsigned int period_size)
{ {
unsigned int res = (rate * period_size) / 48000; unsigned int res = (rate * period_size) / 48000;
if (res < 64) if (res < 64)
...@@ -717,10 +751,10 @@ static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned i ...@@ -717,10 +751,10 @@ static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned i
Returns: Control value. Returns: Control value.
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream) static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
{ {
unsigned int CTRL; unsigned int CTRL;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
/* set ctrl mode /* set ctrl mode
CTRL default: 8-bit (unsigned) mono, loop mode enabled CTRL default: 8-bit (unsigned) mono, loop mode enabled
...@@ -752,7 +786,7 @@ static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream) ...@@ -752,7 +786,7 @@ static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_ioctl(snd_pcm_substream_t * substream, static int snd_trident_ioctl(struct snd_pcm_substream *substream,
unsigned int cmd, unsigned int cmd,
void *arg) void *arg)
{ {
...@@ -774,12 +808,12 @@ static int snd_trident_ioctl(snd_pcm_substream_t * substream, ...@@ -774,12 +808,12 @@ static int snd_trident_ioctl(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream, static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
int err; int err;
if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
...@@ -808,13 +842,13 @@ static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream, ...@@ -808,13 +842,13 @@ static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream, static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice->extra; struct snd_trident_voice *evoice = voice->extra;
/* voice management */ /* voice management */
...@@ -848,8 +882,8 @@ static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream, ...@@ -848,8 +882,8 @@ static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_hw_params(snd_pcm_substream_t * substream, static int snd_trident_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
int err; int err;
...@@ -870,12 +904,12 @@ static int snd_trident_hw_params(snd_pcm_substream_t * substream, ...@@ -870,12 +904,12 @@ static int snd_trident_hw_params(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_hw_free(snd_pcm_substream_t * substream) static int snd_trident_hw_free(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice ? voice->extra : NULL; struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
if (trident->tlb.entries) { if (trident->tlb.entries) {
if (voice && voice->memblk) { if (voice && voice->memblk) {
...@@ -902,13 +936,13 @@ static int snd_trident_hw_free(snd_pcm_substream_t * substream) ...@@ -902,13 +936,13 @@ static int snd_trident_hw_free(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_playback_prepare(snd_pcm_substream_t * substream) static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice->extra; struct snd_trident_voice *evoice = voice->extra;
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -988,8 +1022,8 @@ static int snd_trident_playback_prepare(snd_pcm_substream_t * substream) ...@@ -988,8 +1022,8 @@ static int snd_trident_playback_prepare(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream, static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
return snd_trident_allocate_pcm_mem(substream, hw_params); return snd_trident_allocate_pcm_mem(substream, hw_params);
} }
...@@ -1005,11 +1039,11 @@ static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream, ...@@ -1005,11 +1039,11 @@ static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_capture_prepare(snd_pcm_substream_t * substream) static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
unsigned int val, ESO_bytes; unsigned int val, ESO_bytes;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -1097,8 +1131,8 @@ static int snd_trident_capture_prepare(snd_pcm_substream_t * substream) ...@@ -1097,8 +1131,8 @@ static int snd_trident_capture_prepare(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream, static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
int err; int err;
...@@ -1119,12 +1153,12 @@ static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream, ...@@ -1119,12 +1153,12 @@ static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream) static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice ? voice->extra : NULL; struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
snd_pcm_lib_free_pages(substream); snd_pcm_lib_free_pages(substream);
if (evoice != NULL) { if (evoice != NULL) {
...@@ -1145,12 +1179,12 @@ static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream) ...@@ -1145,12 +1179,12 @@ static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream) static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice->extra; struct snd_trident_voice *evoice = voice->extra;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -1216,12 +1250,12 @@ static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream) ...@@ -1216,12 +1250,12 @@ static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream) static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice->extra; struct snd_trident_voice *evoice = voice->extra;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -1294,10 +1328,10 @@ static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream) ...@@ -1294,10 +1328,10 @@ static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream, static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
snd_pcm_hw_params_t * hw_params) struct snd_pcm_hw_params *hw_params)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
unsigned int old_bits = 0, change = 0; unsigned int old_bits = 0, change = 0;
int err; int err;
...@@ -1359,13 +1393,13 @@ static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream, ...@@ -1359,13 +1393,13 @@ static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream) static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_voice_t *evoice = voice->extra; struct snd_trident_voice *evoice = voice->extra;
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
unsigned int RESO, LBAO; unsigned int RESO, LBAO;
unsigned int temp; unsigned int temp;
...@@ -1498,15 +1532,15 @@ static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream) ...@@ -1498,15 +1532,15 @@ static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_trigger(snd_pcm_substream_t *substream, static int snd_trident_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
struct list_head *pos; struct list_head *pos;
snd_pcm_substream_t *s; struct snd_pcm_substream *s;
unsigned int what, whati, capture_flag, spdif_flag; unsigned int what, whati, capture_flag, spdif_flag;
snd_trident_voice_t *voice, *evoice; struct snd_trident_voice *voice, *evoice;
unsigned int val, go; unsigned int val, go;
switch (cmd) { switch (cmd) {
...@@ -1528,8 +1562,8 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream, ...@@ -1528,8 +1562,8 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream,
val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
snd_pcm_group_for_each(pos, substream) { snd_pcm_group_for_each(pos, substream) {
s = snd_pcm_group_substream_entry(pos); s = snd_pcm_group_substream_entry(pos);
if ((trident_t *) snd_pcm_substream_chip(s) == trident) { if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
voice = (snd_trident_voice_t *) s->runtime->private_data; voice = s->runtime->private_data;
evoice = voice->extra; evoice = voice->extra;
what |= 1 << (voice->number & 0x1f); what |= 1 << (voice->number & 0x1f);
if (evoice == NULL) { if (evoice == NULL) {
...@@ -1596,11 +1630,11 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream, ...@@ -1596,11 +1630,11 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
unsigned int cso; unsigned int cso;
if (!voice->running) if (!voice->running)
...@@ -1635,11 +1669,11 @@ static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * subs ...@@ -1635,11 +1669,11 @@ static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * subs
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
unsigned int result; unsigned int result;
if (!voice->running) if (!voice->running)
...@@ -1665,11 +1699,11 @@ static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * subst ...@@ -1665,11 +1699,11 @@ static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * subst
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substream) static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
unsigned int result; unsigned int result;
if (!voice->running) if (!voice->running)
...@@ -1684,7 +1718,7 @@ static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substre ...@@ -1684,7 +1718,7 @@ static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substre
* Playback support device description * Playback support device description
*/ */
static snd_pcm_hardware_t snd_trident_playback = static struct snd_pcm_hardware snd_trident_playback =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
...@@ -1709,7 +1743,7 @@ static snd_pcm_hardware_t snd_trident_playback = ...@@ -1709,7 +1743,7 @@ static snd_pcm_hardware_t snd_trident_playback =
* Capture support device description * Capture support device description
*/ */
static snd_pcm_hardware_t snd_trident_capture = static struct snd_pcm_hardware snd_trident_capture =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
...@@ -1734,7 +1768,7 @@ static snd_pcm_hardware_t snd_trident_capture = ...@@ -1734,7 +1768,7 @@ static snd_pcm_hardware_t snd_trident_capture =
* Foldback capture support device description * Foldback capture support device description
*/ */
static snd_pcm_hardware_t snd_trident_foldback = static struct snd_pcm_hardware snd_trident_foldback =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
...@@ -1758,7 +1792,7 @@ static snd_pcm_hardware_t snd_trident_foldback = ...@@ -1758,7 +1792,7 @@ static snd_pcm_hardware_t snd_trident_foldback =
* SPDIF playback support device description * SPDIF playback support device description
*/ */
static snd_pcm_hardware_t snd_trident_spdif = static struct snd_pcm_hardware snd_trident_spdif =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
...@@ -1779,7 +1813,7 @@ static snd_pcm_hardware_t snd_trident_spdif = ...@@ -1779,7 +1813,7 @@ static snd_pcm_hardware_t snd_trident_spdif =
.fifo_size = 0, .fifo_size = 0,
}; };
static snd_pcm_hardware_t snd_trident_spdif_7018 = static struct snd_pcm_hardware snd_trident_spdif_7018 =
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_BLOCK_TRANSFER |
...@@ -1799,10 +1833,10 @@ static snd_pcm_hardware_t snd_trident_spdif_7018 = ...@@ -1799,10 +1833,10 @@ static snd_pcm_hardware_t snd_trident_spdif_7018 =
.fifo_size = 0, .fifo_size = 0,
}; };
static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime) static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
{ {
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
trident_t *trident; struct snd_trident *trident;
if (voice) { if (voice) {
trident = voice->trident; trident = voice->trident;
...@@ -1810,11 +1844,11 @@ static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime) ...@@ -1810,11 +1844,11 @@ static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime)
} }
} }
static int snd_trident_playback_open(snd_pcm_substream_t * substream) static int snd_trident_playback_open(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
if (voice == NULL) if (voice == NULL)
...@@ -1838,11 +1872,11 @@ static int snd_trident_playback_open(snd_pcm_substream_t * substream) ...@@ -1838,11 +1872,11 @@ static int snd_trident_playback_open(snd_pcm_substream_t * substream)
Parameters: substream - PCM substream class Parameters: substream - PCM substream class
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_playback_close(snd_pcm_substream_t * substream) static int snd_trident_playback_close(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; struct snd_trident_voice *voice = runtime->private_data;
snd_trident_pcm_mixer_free(trident, voice, substream); snd_trident_pcm_mixer_free(trident, voice, substream);
return 0; return 0;
...@@ -1859,11 +1893,11 @@ static int snd_trident_playback_close(snd_pcm_substream_t * substream) ...@@ -1859,11 +1893,11 @@ static int snd_trident_playback_close(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_open(snd_pcm_substream_t * substream) static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
if (voice == NULL) if (voice == NULL)
...@@ -1900,9 +1934,9 @@ static int snd_trident_spdif_open(snd_pcm_substream_t * substream) ...@@ -1900,9 +1934,9 @@ static int snd_trident_spdif_open(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_close(snd_pcm_substream_t * substream) static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
unsigned int temp; unsigned int temp;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -1938,11 +1972,11 @@ static int snd_trident_spdif_close(snd_pcm_substream_t * substream) ...@@ -1938,11 +1972,11 @@ static int snd_trident_spdif_close(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_capture_open(snd_pcm_substream_t * substream) static int snd_trident_capture_open(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
if (voice == NULL) if (voice == NULL)
...@@ -1966,7 +2000,7 @@ static int snd_trident_capture_open(snd_pcm_substream_t * substream) ...@@ -1966,7 +2000,7 @@ static int snd_trident_capture_open(snd_pcm_substream_t * substream)
Parameters: substream - PCM substream class Parameters: substream - PCM substream class
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_capture_close(snd_pcm_substream_t * substream) static int snd_trident_capture_close(struct snd_pcm_substream *substream)
{ {
return 0; return 0;
} }
...@@ -1982,11 +2016,11 @@ static int snd_trident_capture_close(snd_pcm_substream_t * substream) ...@@ -1982,11 +2016,11 @@ static int snd_trident_capture_close(snd_pcm_substream_t * substream)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_foldback_open(snd_pcm_substream_t * substream) static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
if (voice == NULL) if (voice == NULL)
...@@ -2009,12 +2043,12 @@ static int snd_trident_foldback_open(snd_pcm_substream_t * substream) ...@@ -2009,12 +2043,12 @@ static int snd_trident_foldback_open(snd_pcm_substream_t * substream)
Parameters: substream - PCM substream class Parameters: substream - PCM substream class
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_foldback_close(snd_pcm_substream_t * substream) static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
{ {
trident_t *trident = snd_pcm_substream_chip(substream); struct snd_trident *trident = snd_pcm_substream_chip(substream);
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
voice = (snd_trident_voice_t *) runtime->private_data; voice = runtime->private_data;
/* stop capture channel */ /* stop capture channel */
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -2027,7 +2061,7 @@ static int snd_trident_foldback_close(snd_pcm_substream_t * substream) ...@@ -2027,7 +2061,7 @@ static int snd_trident_foldback_close(snd_pcm_substream_t * substream)
PCM operations PCM operations
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static snd_pcm_ops_t snd_trident_playback_ops = { static struct snd_pcm_ops snd_trident_playback_ops = {
.open = snd_trident_playback_open, .open = snd_trident_playback_open,
.close = snd_trident_playback_close, .close = snd_trident_playback_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2038,7 +2072,7 @@ static snd_pcm_ops_t snd_trident_playback_ops = { ...@@ -2038,7 +2072,7 @@ static snd_pcm_ops_t snd_trident_playback_ops = {
.pointer = snd_trident_playback_pointer, .pointer = snd_trident_playback_pointer,
}; };
static snd_pcm_ops_t snd_trident_nx_playback_ops = { static struct snd_pcm_ops snd_trident_nx_playback_ops = {
.open = snd_trident_playback_open, .open = snd_trident_playback_open,
.close = snd_trident_playback_close, .close = snd_trident_playback_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2050,7 +2084,7 @@ static snd_pcm_ops_t snd_trident_nx_playback_ops = { ...@@ -2050,7 +2084,7 @@ static snd_pcm_ops_t snd_trident_nx_playback_ops = {
.page = snd_pcm_sgbuf_ops_page, .page = snd_pcm_sgbuf_ops_page,
}; };
static snd_pcm_ops_t snd_trident_capture_ops = { static struct snd_pcm_ops snd_trident_capture_ops = {
.open = snd_trident_capture_open, .open = snd_trident_capture_open,
.close = snd_trident_capture_close, .close = snd_trident_capture_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2061,7 +2095,7 @@ static snd_pcm_ops_t snd_trident_capture_ops = { ...@@ -2061,7 +2095,7 @@ static snd_pcm_ops_t snd_trident_capture_ops = {
.pointer = snd_trident_capture_pointer, .pointer = snd_trident_capture_pointer,
}; };
static snd_pcm_ops_t snd_trident_si7018_capture_ops = { static struct snd_pcm_ops snd_trident_si7018_capture_ops = {
.open = snd_trident_capture_open, .open = snd_trident_capture_open,
.close = snd_trident_capture_close, .close = snd_trident_capture_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2072,7 +2106,7 @@ static snd_pcm_ops_t snd_trident_si7018_capture_ops = { ...@@ -2072,7 +2106,7 @@ static snd_pcm_ops_t snd_trident_si7018_capture_ops = {
.pointer = snd_trident_playback_pointer, .pointer = snd_trident_playback_pointer,
}; };
static snd_pcm_ops_t snd_trident_foldback_ops = { static struct snd_pcm_ops snd_trident_foldback_ops = {
.open = snd_trident_foldback_open, .open = snd_trident_foldback_open,
.close = snd_trident_foldback_close, .close = snd_trident_foldback_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2083,7 +2117,7 @@ static snd_pcm_ops_t snd_trident_foldback_ops = { ...@@ -2083,7 +2117,7 @@ static snd_pcm_ops_t snd_trident_foldback_ops = {
.pointer = snd_trident_playback_pointer, .pointer = snd_trident_playback_pointer,
}; };
static snd_pcm_ops_t snd_trident_nx_foldback_ops = { static struct snd_pcm_ops snd_trident_nx_foldback_ops = {
.open = snd_trident_foldback_open, .open = snd_trident_foldback_open,
.close = snd_trident_foldback_close, .close = snd_trident_foldback_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2095,7 +2129,7 @@ static snd_pcm_ops_t snd_trident_nx_foldback_ops = { ...@@ -2095,7 +2129,7 @@ static snd_pcm_ops_t snd_trident_nx_foldback_ops = {
.page = snd_pcm_sgbuf_ops_page, .page = snd_pcm_sgbuf_ops_page,
}; };
static snd_pcm_ops_t snd_trident_spdif_ops = { static struct snd_pcm_ops snd_trident_spdif_ops = {
.open = snd_trident_spdif_open, .open = snd_trident_spdif_open,
.close = snd_trident_spdif_close, .close = snd_trident_spdif_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2106,7 +2140,7 @@ static snd_pcm_ops_t snd_trident_spdif_ops = { ...@@ -2106,7 +2140,7 @@ static snd_pcm_ops_t snd_trident_spdif_ops = {
.pointer = snd_trident_spdif_pointer, .pointer = snd_trident_spdif_pointer,
}; };
static snd_pcm_ops_t snd_trident_spdif_7018_ops = { static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
.open = snd_trident_spdif_open, .open = snd_trident_spdif_open,
.close = snd_trident_spdif_close, .close = snd_trident_spdif_close,
.ioctl = snd_trident_ioctl, .ioctl = snd_trident_ioctl,
...@@ -2128,9 +2162,10 @@ static snd_pcm_ops_t snd_trident_spdif_7018_ops = { ...@@ -2128,9 +2162,10 @@ static snd_pcm_ops_t snd_trident_spdif_7018_ops = {
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) int __devinit snd_trident_pcm(struct snd_trident * trident,
int device, struct snd_pcm ** rpcm)
{ {
snd_pcm_t *pcm; struct snd_pcm *pcm;
int err; int err;
if (rpcm) if (rpcm)
...@@ -2156,7 +2191,7 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm ...@@ -2156,7 +2191,7 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm
trident->pcm = pcm; trident->pcm = pcm;
if (trident->tlb.entries) { if (trident->tlb.entries) {
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
snd_dma_pci_data(trident->pci), snd_dma_pci_data(trident->pci),
...@@ -2185,12 +2220,13 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm ...@@ -2185,12 +2220,13 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
int device, struct snd_pcm ** rpcm)
{ {
snd_pcm_t *foldback; struct snd_pcm *foldback;
int err; int err;
int num_chan = 3; int num_chan = 3;
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
if (rpcm) if (rpcm)
*rpcm = NULL; *rpcm = NULL;
...@@ -2241,9 +2277,10 @@ int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_ ...@@ -2241,9 +2277,10 @@ int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
int device, struct snd_pcm ** rpcm)
{ {
snd_pcm_t *spdif; struct snd_pcm *spdif;
int err; int err;
if (rpcm) if (rpcm)
...@@ -2279,7 +2316,8 @@ int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t * ...@@ -2279,7 +2316,8 @@ int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t *
Description: enable/disable S/PDIF out from ac97 mixer Description: enable/disable S/PDIF out from ac97 mixer
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_spdif_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1; uinfo->count = 1;
...@@ -2288,10 +2326,10 @@ static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem ...@@ -2288,10 +2326,10 @@ static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem
return 0; return 0;
} }
static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned char val; unsigned char val;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -2301,10 +2339,10 @@ static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol, ...@@ -2301,10 +2339,10 @@ static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned char val; unsigned char val;
int change; int change;
...@@ -2332,7 +2370,7 @@ static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol, ...@@ -2332,7 +2370,7 @@ static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata = static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
...@@ -2348,17 +2386,18 @@ static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata = ...@@ -2348,17 +2386,18 @@ static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata =
Description: put/get the S/PDIF default settings Description: put/get the S/PDIF default settings
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
uinfo->count = 1; uinfo->count = 1;
return 0; return 0;
} }
static int snd_trident_spdif_default_get(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff; ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
...@@ -2369,10 +2408,10 @@ static int snd_trident_spdif_default_get(snd_kcontrol_t * kcontrol, ...@@ -2369,10 +2408,10 @@ static int snd_trident_spdif_default_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned int val; unsigned int val;
int change; int change;
...@@ -2394,7 +2433,7 @@ static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol, ...@@ -2394,7 +2433,7 @@ static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata = static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_PCM, .iface = SNDRV_CTL_ELEM_IFACE_PCM,
.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
...@@ -2409,15 +2448,16 @@ static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata = ...@@ -2409,15 +2448,16 @@ static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata =
Description: put/get the S/PDIF mask Description: put/get the S/PDIF mask
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
uinfo->count = 1; uinfo->count = 1;
return 0; return 0;
} }
static int snd_trident_spdif_mask_get(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[0] = 0xff;
ucontrol->value.iec958.status[1] = 0xff; ucontrol->value.iec958.status[1] = 0xff;
...@@ -2426,7 +2466,7 @@ static int snd_trident_spdif_mask_get(snd_kcontrol_t * kcontrol, ...@@ -2426,7 +2466,7 @@ static int snd_trident_spdif_mask_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata = static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata =
{ {
.access = SNDRV_CTL_ELEM_ACCESS_READ, .access = SNDRV_CTL_ELEM_ACCESS_READ,
.iface = SNDRV_CTL_ELEM_IFACE_PCM, .iface = SNDRV_CTL_ELEM_IFACE_PCM,
...@@ -2441,17 +2481,18 @@ static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata = ...@@ -2441,17 +2481,18 @@ static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata =
Description: put/get the S/PDIF stream settings Description: put/get the S/PDIF stream settings
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
uinfo->count = 1; uinfo->count = 1;
return 0; return 0;
} }
static int snd_trident_spdif_stream_get(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff; ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
...@@ -2462,10 +2503,10 @@ static int snd_trident_spdif_stream_get(snd_kcontrol_t * kcontrol, ...@@ -2462,10 +2503,10 @@ static int snd_trident_spdif_stream_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol, static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned int val; unsigned int val;
int change; int change;
...@@ -2487,7 +2528,7 @@ static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol, ...@@ -2487,7 +2528,7 @@ static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata = static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata =
{ {
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
.iface = SNDRV_CTL_ELEM_IFACE_PCM, .iface = SNDRV_CTL_ELEM_IFACE_PCM,
...@@ -2503,7 +2544,8 @@ static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata = ...@@ -2503,7 +2544,8 @@ static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata =
Description: enable/disable rear path for ac97 Description: enable/disable rear path for ac97
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_ac97_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1; uinfo->count = 1;
...@@ -2512,10 +2554,10 @@ static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_ ...@@ -2512,10 +2554,10 @@ static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_
return 0; return 0;
} }
static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned char val; unsigned char val;
spin_lock_irq(&trident->reg_lock); spin_lock_irq(&trident->reg_lock);
...@@ -2525,10 +2567,10 @@ static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol, ...@@ -2525,10 +2567,10 @@ static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned char val; unsigned char val;
int change = 0; int change = 0;
...@@ -2544,7 +2586,7 @@ static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol, ...@@ -2544,7 +2586,7 @@ static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata = static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Rear Path", .name = "Rear Path",
...@@ -2560,7 +2602,8 @@ static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata = ...@@ -2560,7 +2602,8 @@ static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata =
Description: wave & music volume control Description: wave & music volume control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2; uinfo->count = 2;
...@@ -2569,10 +2612,10 @@ static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_i ...@@ -2569,10 +2612,10 @@ static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_i
return 0; return 0;
} }
static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned int val; unsigned int val;
val = trident->musicvol_wavevol; val = trident->musicvol_wavevol;
...@@ -2581,10 +2624,10 @@ static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol, ...@@ -2581,10 +2624,10 @@ static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
unsigned int val; unsigned int val;
int change = 0; int change = 0;
...@@ -2599,7 +2642,7 @@ static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol, ...@@ -2599,7 +2642,7 @@ static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata = static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Music Playback Volume", .name = "Music Playback Volume",
...@@ -2609,7 +2652,7 @@ static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata = ...@@ -2609,7 +2652,7 @@ static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata =
.private_value = 16, .private_value = 16,
}; };
static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata = static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Wave Playback Volume", .name = "Wave Playback Volume",
...@@ -2625,9 +2668,10 @@ static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata = ...@@ -2625,9 +2668,10 @@ static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata =
Description: PCM front volume control Description: PCM front volume control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1; uinfo->count = 1;
...@@ -2638,11 +2682,11 @@ static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el ...@@ -2638,11 +2682,11 @@ static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el
return 0; return 0;
} }
static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
if (trident->device == TRIDENT_DEVICE_ID_SI7018) { if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
ucontrol->value.integer.value[0] = 1023 - mix->vol; ucontrol->value.integer.value[0] = 1023 - mix->vol;
...@@ -2652,11 +2696,11 @@ static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol, ...@@ -2652,11 +2696,11 @@ static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned int val; unsigned int val;
int change = 0; int change = 0;
...@@ -2674,7 +2718,7 @@ static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol, ...@@ -2674,7 +2718,7 @@ static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata = static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Front Playback Volume", .name = "PCM Front Playback Volume",
...@@ -2691,7 +2735,8 @@ static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata = ...@@ -2691,7 +2735,8 @@ static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata =
Description: PCM front pan control Description: PCM front pan control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1; uinfo->count = 1;
...@@ -2700,11 +2745,11 @@ static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el ...@@ -2700,11 +2745,11 @@ static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el
return 0; return 0;
} }
static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
ucontrol->value.integer.value[0] = mix->pan; ucontrol->value.integer.value[0] = mix->pan;
if (ucontrol->value.integer.value[0] & 0x40) { if (ucontrol->value.integer.value[0] & 0x40) {
...@@ -2715,11 +2760,11 @@ static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol, ...@@ -2715,11 +2760,11 @@ static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol,
return 0; return 0;
} }
static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned char val; unsigned char val;
int change = 0; int change = 0;
...@@ -2736,7 +2781,7 @@ static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol, ...@@ -2736,7 +2781,7 @@ static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata = static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Pan Playback Control", .name = "PCM Pan Playback Control",
...@@ -2753,7 +2798,8 @@ static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata = ...@@ -2753,7 +2798,8 @@ static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata =
Description: PCM reverb volume control Description: PCM reverb volume control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1; uinfo->count = 1;
...@@ -2762,21 +2808,21 @@ static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e ...@@ -2762,21 +2808,21 @@ static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e
return 0; return 0;
} }
static int snd_trident_pcm_rvol_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
ucontrol->value.integer.value[0] = 127 - mix->rvol; ucontrol->value.integer.value[0] = 127 - mix->rvol;
return 0; return 0;
} }
static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned short val; unsigned short val;
int change = 0; int change = 0;
...@@ -2790,7 +2836,7 @@ static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol, ...@@ -2790,7 +2836,7 @@ static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata = static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Reverb Playback Volume", .name = "PCM Reverb Playback Volume",
...@@ -2807,7 +2853,8 @@ static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata = ...@@ -2807,7 +2853,8 @@ static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata =
Description: PCM chorus volume control Description: PCM chorus volume control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{ {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1; uinfo->count = 1;
...@@ -2816,21 +2863,21 @@ static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e ...@@ -2816,21 +2863,21 @@ static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e
return 0; return 0;
} }
static int snd_trident_pcm_cvol_control_get(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
ucontrol->value.integer.value[0] = 127 - mix->cvol; ucontrol->value.integer.value[0] = 127 - mix->cvol;
return 0; return 0;
} }
static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol, static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
snd_ctl_elem_value_t * ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
trident_t *trident = snd_kcontrol_chip(kcontrol); struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
unsigned short val; unsigned short val;
int change = 0; int change = 0;
...@@ -2844,7 +2891,7 @@ static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol, ...@@ -2844,7 +2891,7 @@ static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol,
return change; return change;
} }
static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata = static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata =
{ {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Chorus Playback Volume", .name = "PCM Chorus Playback Volume",
...@@ -2855,9 +2902,11 @@ static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata = ...@@ -2855,9 +2902,11 @@ static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata =
.put = snd_trident_pcm_cvol_control_put, .put = snd_trident_pcm_cvol_control_put,
}; };
static void snd_trident_notify_pcm_change1(snd_card_t * card, snd_kcontrol_t *kctl, int num, int activate) static void snd_trident_notify_pcm_change1(struct snd_card *card,
struct snd_kcontrol *kctl,
int num, int activate)
{ {
snd_ctl_elem_id_t id; struct snd_ctl_elem_id id;
if (! kctl) if (! kctl)
return; return;
...@@ -2870,7 +2919,9 @@ static void snd_trident_notify_pcm_change1(snd_card_t * card, snd_kcontrol_t *kc ...@@ -2870,7 +2919,9 @@ static void snd_trident_notify_pcm_change1(snd_card_t * card, snd_kcontrol_t *kc
snd_ctl_build_ioff(&id, kctl, num)); snd_ctl_build_ioff(&id, kctl, num));
} }
static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mixer_t *tmix, int num, int activate) static void snd_trident_notify_pcm_change(struct snd_trident *trident,
struct snd_trident_pcm_mixer *tmix,
int num, int activate)
{ {
snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate); snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate); snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
...@@ -2878,9 +2929,11 @@ static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mi ...@@ -2878,9 +2929,11 @@ static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mi
snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate); snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
} }
static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream) static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
struct snd_trident_voice *voice,
struct snd_pcm_substream *substream)
{ {
snd_trident_pcm_mixer_t *tmix; struct snd_trident_pcm_mixer *tmix;
snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL); snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL);
tmix = &trident->pcm_mixer[substream->number]; tmix = &trident->pcm_mixer[substream->number];
...@@ -2893,9 +2946,9 @@ static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t * ...@@ -2893,9 +2946,9 @@ static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *
return 0; return 0;
} }
static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream) static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
{ {
snd_trident_pcm_mixer_t *tmix; struct snd_trident_pcm_mixer *tmix;
snd_assert(trident != NULL && substream != NULL, return -EINVAL); snd_assert(trident != NULL && substream != NULL, return -EINVAL);
tmix = &trident->pcm_mixer[substream->number]; tmix = &trident->pcm_mixer[substream->number];
...@@ -2915,14 +2968,14 @@ static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *v ...@@ -2915,14 +2968,14 @@ static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *v
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device) static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)
{ {
ac97_template_t _ac97; struct snd_ac97_template _ac97;
snd_card_t * card = trident->card; struct snd_card *card = trident->card;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_ctl_elem_value_t *uctl; struct snd_ctl_elem_value *uctl;
int idx, err, retries = 2; int idx, err, retries = 2;
static ac97_bus_ops_t ops = { static struct snd_ac97_bus_ops ops = {
.write = snd_trident_codec_write, .write = snd_trident_codec_write,
.read = snd_trident_codec_read, .read = snd_trident_codec_read,
}; };
...@@ -2959,7 +3012,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device ...@@ -2959,7 +3012,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n"); snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n");
#if 0 // only for my testing purpose --jk #if 0 // only for my testing purpose --jk
{ {
ac97_t *mc97; struct snd_ac97 *mc97;
err = snd_ac97_modem(trident->card, &_ac97, &mc97); err = snd_ac97_modem(trident->card, &_ac97, &mc97);
if (err < 0) if (err < 0)
snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err); snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err);
...@@ -2982,7 +3035,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device ...@@ -2982,7 +3035,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
} }
for (idx = 0; idx < 32; idx++) { for (idx = 0; idx < 32; idx++) {
snd_trident_pcm_mixer_t *tmix; struct snd_trident_pcm_mixer *tmix;
tmix = &trident->pcm_mixer[idx]; tmix = &trident->pcm_mixer[idx];
tmix->voice = NULL; tmix->voice = NULL;
...@@ -3080,7 +3133,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device ...@@ -3080,7 +3133,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
static unsigned char snd_trident_gameport_read(struct gameport *gameport) static unsigned char snd_trident_gameport_read(struct gameport *gameport)
{ {
trident_t *chip = gameport_get_port_data(gameport); struct snd_trident *chip = gameport_get_port_data(gameport);
snd_assert(chip, return 0); snd_assert(chip, return 0);
return inb(TRID_REG(chip, GAMEPORT_LEGACY)); return inb(TRID_REG(chip, GAMEPORT_LEGACY));
...@@ -3088,7 +3141,7 @@ static unsigned char snd_trident_gameport_read(struct gameport *gameport) ...@@ -3088,7 +3141,7 @@ static unsigned char snd_trident_gameport_read(struct gameport *gameport)
static void snd_trident_gameport_trigger(struct gameport *gameport) static void snd_trident_gameport_trigger(struct gameport *gameport)
{ {
trident_t *chip = gameport_get_port_data(gameport); struct snd_trident *chip = gameport_get_port_data(gameport);
snd_assert(chip, return); snd_assert(chip, return);
outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY)); outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
...@@ -3096,7 +3149,7 @@ static void snd_trident_gameport_trigger(struct gameport *gameport) ...@@ -3096,7 +3149,7 @@ static void snd_trident_gameport_trigger(struct gameport *gameport)
static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
{ {
trident_t *chip = gameport_get_port_data(gameport); struct snd_trident *chip = gameport_get_port_data(gameport);
int i; int i;
snd_assert(chip, return 0); snd_assert(chip, return 0);
...@@ -3113,7 +3166,7 @@ static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes ...@@ -3113,7 +3166,7 @@ static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes
static int snd_trident_gameport_open(struct gameport *gameport, int mode) static int snd_trident_gameport_open(struct gameport *gameport, int mode)
{ {
trident_t *chip = gameport_get_port_data(gameport); struct snd_trident *chip = gameport_get_port_data(gameport);
snd_assert(chip, return 0); snd_assert(chip, return 0);
...@@ -3130,7 +3183,7 @@ static int snd_trident_gameport_open(struct gameport *gameport, int mode) ...@@ -3130,7 +3183,7 @@ static int snd_trident_gameport_open(struct gameport *gameport, int mode)
} }
} }
int __devinit snd_trident_create_gameport(trident_t *chip) int __devinit snd_trident_create_gameport(struct snd_trident *chip)
{ {
struct gameport *gp; struct gameport *gp;
...@@ -3156,7 +3209,7 @@ int __devinit snd_trident_create_gameport(trident_t *chip) ...@@ -3156,7 +3209,7 @@ int __devinit snd_trident_create_gameport(trident_t *chip)
return 0; return 0;
} }
static inline void snd_trident_free_gameport(trident_t *chip) static inline void snd_trident_free_gameport(struct snd_trident *chip)
{ {
if (chip->gameport) { if (chip->gameport) {
gameport_unregister_port(chip->gameport); gameport_unregister_port(chip->gameport);
...@@ -3164,14 +3217,14 @@ static inline void snd_trident_free_gameport(trident_t *chip) ...@@ -3164,14 +3217,14 @@ static inline void snd_trident_free_gameport(trident_t *chip)
} }
} }
#else #else
int __devinit snd_trident_create_gameport(trident_t *chip) { return -ENOSYS; } int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
static inline void snd_trident_free_gameport(trident_t *chip) { } static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
#endif /* CONFIG_GAMEPORT */ #endif /* CONFIG_GAMEPORT */
/* /*
* delay for 1 tick * delay for 1 tick
*/ */
static inline void do_delay(trident_t *chip) static inline void do_delay(struct snd_trident *chip)
{ {
schedule_timeout_uninterruptible(1); schedule_timeout_uninterruptible(1);
} }
...@@ -3180,7 +3233,7 @@ static inline void do_delay(trident_t *chip) ...@@ -3180,7 +3233,7 @@ static inline void do_delay(trident_t *chip)
* SiS reset routine * SiS reset routine
*/ */
static int snd_trident_sis_reset(trident_t *trident) static int snd_trident_sis_reset(struct snd_trident *trident)
{ {
unsigned long end_time; unsigned long end_time;
unsigned int i; unsigned int i;
...@@ -3233,10 +3286,10 @@ static int snd_trident_sis_reset(trident_t *trident) ...@@ -3233,10 +3286,10 @@ static int snd_trident_sis_reset(trident_t *trident)
* /proc interface * /proc interface
*/ */
static void snd_trident_proc_read(snd_info_entry_t *entry, static void snd_trident_proc_read(struct snd_info_entry *entry,
snd_info_buffer_t * buffer) struct snd_info_buffer *buffer)
{ {
trident_t *trident = entry->private_data; struct snd_trident *trident = entry->private_data;
char *s; char *s;
switch (trident->device) { switch (trident->device) {
...@@ -3274,9 +3327,9 @@ static void snd_trident_proc_read(snd_info_entry_t *entry, ...@@ -3274,9 +3327,9 @@ static void snd_trident_proc_read(snd_info_entry_t *entry,
#endif #endif
} }
static void __devinit snd_trident_proc_init(trident_t * trident) static void __devinit snd_trident_proc_init(struct snd_trident * trident)
{ {
snd_info_entry_t *entry; struct snd_info_entry *entry;
const char *s = "trident"; const char *s = "trident";
if (trident->device == TRIDENT_DEVICE_ID_SI7018) if (trident->device == TRIDENT_DEVICE_ID_SI7018)
...@@ -3285,9 +3338,9 @@ static void __devinit snd_trident_proc_init(trident_t * trident) ...@@ -3285,9 +3338,9 @@ static void __devinit snd_trident_proc_init(trident_t * trident)
snd_info_set_text_ops(entry, trident, 1024, snd_trident_proc_read); snd_info_set_text_ops(entry, trident, 1024, snd_trident_proc_read);
} }
static int snd_trident_dev_free(snd_device_t *device) static int snd_trident_dev_free(struct snd_device *device)
{ {
trident_t *trident = device->device_data; struct snd_trident *trident = device->device_data;
return snd_trident_free(trident); return snd_trident_free(trident);
} }
...@@ -3303,7 +3356,7 @@ static int snd_trident_dev_free(snd_device_t *device) ...@@ -3303,7 +3356,7 @@ static int snd_trident_dev_free(snd_device_t *device)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int __devinit snd_trident_tlb_alloc(trident_t *trident) static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
{ {
int i; int i;
...@@ -3318,7 +3371,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident) ...@@ -3318,7 +3371,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
trident->tlb.entries = (unsigned int*)(((unsigned long)trident->tlb.buffer.area + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1)); trident->tlb.entries = (unsigned int*)(((unsigned long)trident->tlb.buffer.area + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1));
trident->tlb.entries_dmaaddr = (trident->tlb.buffer.addr + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1); trident->tlb.entries_dmaaddr = (trident->tlb.buffer.addr + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1);
/* allocate shadow TLB page table (virtual addresses) */ /* allocate shadow TLB page table (virtual addresses) */
trident->tlb.shadow_entries = (unsigned long *)vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
if (trident->tlb.shadow_entries == NULL) { if (trident->tlb.shadow_entries == NULL) {
snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n"); snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n");
return -ENOMEM; return -ENOMEM;
...@@ -3340,7 +3393,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident) ...@@ -3340,7 +3393,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
if (trident->tlb.memhdr == NULL) if (trident->tlb.memhdr == NULL)
return -ENOMEM; return -ENOMEM;
trident->tlb.memhdr->block_extra_size = sizeof(snd_trident_memblk_arg_t); trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
return 0; return 0;
} }
...@@ -3348,7 +3401,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident) ...@@ -3348,7 +3401,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
* initialize 4D DX chip * initialize 4D DX chip
*/ */
static void snd_trident_stop_all_voices(trident_t *trident) static void snd_trident_stop_all_voices(struct snd_trident *trident)
{ {
outl(0xffffffff, TRID_REG(trident, T4D_STOP_A)); outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
outl(0xffffffff, TRID_REG(trident, T4D_STOP_B)); outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
...@@ -3356,7 +3409,7 @@ static void snd_trident_stop_all_voices(trident_t *trident) ...@@ -3356,7 +3409,7 @@ static void snd_trident_stop_all_voices(trident_t *trident)
outl(0, TRID_REG(trident, T4D_AINTEN_B)); outl(0, TRID_REG(trident, T4D_AINTEN_B));
} }
static int snd_trident_4d_dx_init(trident_t *trident) static int snd_trident_4d_dx_init(struct snd_trident *trident)
{ {
struct pci_dev *pci = trident->pci; struct pci_dev *pci = trident->pci;
unsigned long end_time; unsigned long end_time;
...@@ -3396,7 +3449,7 @@ static int snd_trident_4d_dx_init(trident_t *trident) ...@@ -3396,7 +3449,7 @@ static int snd_trident_4d_dx_init(trident_t *trident)
/* /*
* initialize 4D NX chip * initialize 4D NX chip
*/ */
static int snd_trident_4d_nx_init(trident_t *trident) static int snd_trident_4d_nx_init(struct snd_trident *trident)
{ {
struct pci_dev *pci = trident->pci; struct pci_dev *pci = trident->pci;
unsigned long end_time; unsigned long end_time;
...@@ -3453,7 +3506,7 @@ static int snd_trident_4d_nx_init(trident_t *trident) ...@@ -3453,7 +3506,7 @@ static int snd_trident_4d_nx_init(trident_t *trident)
/* /*
* initialize sis7018 chip * initialize sis7018 chip
*/ */
static int snd_trident_sis_init(trident_t *trident) static int snd_trident_sis_init(struct snd_trident *trident)
{ {
int err; int err;
...@@ -3484,18 +3537,18 @@ static int snd_trident_sis_init(trident_t *trident) ...@@ -3484,18 +3537,18 @@ static int snd_trident_sis_init(trident_t *trident)
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int __devinit snd_trident_create(snd_card_t * card, int __devinit snd_trident_create(struct snd_card *card,
struct pci_dev *pci, struct pci_dev *pci,
int pcm_streams, int pcm_streams,
int pcm_spdif_device, int pcm_spdif_device,
int max_wavetable_size, int max_wavetable_size,
trident_t ** rtrident) struct snd_trident ** rtrident)
{ {
trident_t *trident; struct snd_trident *trident;
int i, err; int i, err;
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
snd_trident_pcm_mixer_t *tmix; struct snd_trident_pcm_mixer *tmix;
static snd_device_ops_t ops = { static struct snd_device_ops ops = {
.dev_free = snd_trident_dev_free, .dev_free = snd_trident_dev_free,
}; };
...@@ -3543,7 +3596,8 @@ int __devinit snd_trident_create(snd_card_t * card, ...@@ -3543,7 +3596,8 @@ int __devinit snd_trident_create(snd_card_t * card,
} }
trident->port = pci_resource_start(pci, 0); trident->port = pci_resource_start(pci, 0);
if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, "Trident Audio", (void *) trident)) { if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ,
"Trident Audio", trident)) {
snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
snd_trident_free(trident); snd_trident_free(trident);
return -EBUSY; return -EBUSY;
...@@ -3627,7 +3681,7 @@ int __devinit snd_trident_create(snd_card_t * card, ...@@ -3627,7 +3681,7 @@ int __devinit snd_trident_create(snd_card_t * card,
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
static int snd_trident_free(trident_t *trident) static int snd_trident_free(struct snd_trident *trident)
{ {
snd_trident_free_gameport(trident); snd_trident_free_gameport(trident);
snd_trident_disable_eso(trident); snd_trident_disable_eso(trident);
...@@ -3647,7 +3701,7 @@ static int snd_trident_free(trident_t *trident) ...@@ -3647,7 +3701,7 @@ static int snd_trident_free(trident_t *trident)
snd_dma_free_pages(&trident->tlb.buffer); snd_dma_free_pages(&trident->tlb.buffer);
} }
if (trident->irq >= 0) if (trident->irq >= 0)
free_irq(trident->irq, (void *)trident); free_irq(trident->irq, trident);
pci_release_regions(trident->pci); pci_release_regions(trident->pci);
pci_disable_device(trident->pci); pci_disable_device(trident->pci);
kfree(trident); kfree(trident);
...@@ -3674,10 +3728,10 @@ static int snd_trident_free(trident_t *trident) ...@@ -3674,10 +3728,10 @@ static int snd_trident_free(trident_t *trident)
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{ {
trident_t *trident = dev_id; struct snd_trident *trident = dev_id;
unsigned int audio_int, chn_int, stimer, channel, mask, tmp; unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
int delta; int delta;
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
audio_int = inl(TRID_REG(trident, T4D_MISCINT)); audio_int = inl(TRID_REG(trident, T4D_MISCINT));
if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0) if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
...@@ -3779,21 +3833,21 @@ static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs * ...@@ -3779,21 +3833,21 @@ static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *
Returns: None. Returns: None.
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int snd_trident_attach_synthesizer(trident_t *trident) int snd_trident_attach_synthesizer(struct snd_trident *trident)
{ {
#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT, if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT,
sizeof(trident_t*), &trident->seq_dev) >= 0) { sizeof(struct snd_trident *), &trident->seq_dev) >= 0) {
strcpy(trident->seq_dev->name, "4DWave"); strcpy(trident->seq_dev->name, "4DWave");
*(trident_t**)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident; *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident;
} }
#endif #endif
return 0; return 0;
} }
snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port) struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
{ {
snd_trident_voice_t *pvoice; struct snd_trident_voice *pvoice;
unsigned long flags; unsigned long flags;
int idx; int idx;
...@@ -3835,10 +3889,10 @@ snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int ...@@ -3835,10 +3889,10 @@ snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int
return NULL; return NULL;
} }
void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice) void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
{ {
unsigned long flags; unsigned long flags;
void (*private_free)(snd_trident_voice_t *); void (*private_free)(struct snd_trident_voice *);
void *private_data; void *private_data;
if (voice == NULL || !voice->use) if (voice == NULL || !voice->use)
...@@ -3863,7 +3917,7 @@ void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice) ...@@ -3863,7 +3917,7 @@ void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice)
private_free(voice); private_free(voice);
} }
static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max) static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
{ {
unsigned int i, val, mask[2] = { 0, 0 }; unsigned int i, val, mask[2] = { 0, 0 };
...@@ -3884,9 +3938,9 @@ static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, ...@@ -3884,9 +3938,9 @@ static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min,
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM
static int snd_trident_suspend(snd_card_t *card, pm_message_t state) static int snd_trident_suspend(struct snd_card *card, pm_message_t state)
{ {
trident_t *trident = card->pm_private_data; struct snd_trident *trident = card->pm_private_data;
trident->in_suspend = 1; trident->in_suspend = 1;
snd_pcm_suspend_all(trident->pcm); snd_pcm_suspend_all(trident->pcm);
...@@ -3910,9 +3964,9 @@ static int snd_trident_suspend(snd_card_t *card, pm_message_t state) ...@@ -3910,9 +3964,9 @@ static int snd_trident_suspend(snd_card_t *card, pm_message_t state)
return 0; return 0;
} }
static int snd_trident_resume(snd_card_t *card) static int snd_trident_resume(struct snd_card *card)
{ {
trident_t *trident = card->pm_private_data; struct snd_trident *trident = card->pm_private_data;
pci_enable_device(trident->pci); pci_enable_device(trident->pci);
if (pci_set_dma_mask(trident->pci, 0x3fffffff) < 0 || if (pci_set_dma_mask(trident->pci, 0x3fffffff) < 0 ||
......
sound/pci/trident/trident_memory.c
View file @ bee1a5be
...@@ -68,13 +68,14 @@ ...@@ -68,13 +68,14 @@
#define page_to_addr(trident,page) __tlb_to_addr(trident, (page) << 1) #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) << 1)
/* fill TLB entries -- we need to fill two entries */ /* fill TLB entries -- we need to fill two entries */
static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr) static inline void set_tlb_bus(struct snd_trident *trident, int page,
unsigned long ptr, dma_addr_t addr)
{ {
page <<= 1; page <<= 1;
__set_tlb_bus(trident, page, ptr, addr); __set_tlb_bus(trident, page, ptr, addr);
__set_tlb_bus(trident, page+1, ptr + SNDRV_TRIDENT_PAGE_SIZE, addr + SNDRV_TRIDENT_PAGE_SIZE); __set_tlb_bus(trident, page+1, ptr + SNDRV_TRIDENT_PAGE_SIZE, addr + SNDRV_TRIDENT_PAGE_SIZE);
} }
static inline void set_silent_tlb(trident_t *trident, int page) static inline void set_silent_tlb(struct snd_trident *trident, int page)
{ {
page <<= 1; page <<= 1;
__set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr); __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr);
...@@ -97,7 +98,8 @@ static inline void set_silent_tlb(trident_t *trident, int page) ...@@ -97,7 +98,8 @@ static inline void set_silent_tlb(trident_t *trident, int page)
#define page_to_addr(trident,page) __tlb_to_addr(trident, (page) * UNIT_PAGES) #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) * UNIT_PAGES)
/* fill TLB entries -- UNIT_PAGES entries must be filled */ /* fill TLB entries -- UNIT_PAGES entries must be filled */
static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr) static inline void set_tlb_bus(struct snd_trident *trident, int page,
unsigned long ptr, dma_addr_t addr)
{ {
int i; int i;
page *= UNIT_PAGES; page *= UNIT_PAGES;
...@@ -107,7 +109,7 @@ static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, ...@@ -107,7 +109,7 @@ static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr,
addr += SNDRV_TRIDENT_PAGE_SIZE; addr += SNDRV_TRIDENT_PAGE_SIZE;
} }
} }
static inline void set_silent_tlb(trident_t *trident, int page) static inline void set_silent_tlb(struct snd_trident *trident, int page)
{ {
int i; int i;
page *= UNIT_PAGES; page *= UNIT_PAGES;
...@@ -118,7 +120,7 @@ static inline void set_silent_tlb(trident_t *trident, int page) ...@@ -118,7 +120,7 @@ static inline void set_silent_tlb(trident_t *trident, int page)
#endif /* PAGE_SIZE */ #endif /* PAGE_SIZE */
/* calculate buffer pointer from offset address */ /* calculate buffer pointer from offset address */
static inline void *offset_ptr(trident_t *trident, int offset) static inline void *offset_ptr(struct snd_trident *trident, int offset)
{ {
char *ptr; char *ptr;
ptr = page_to_ptr(trident, get_aligned_page(offset)); ptr = page_to_ptr(trident, get_aligned_page(offset));
...@@ -127,16 +129,16 @@ static inline void *offset_ptr(trident_t *trident, int offset) ...@@ -127,16 +129,16 @@ static inline void *offset_ptr(trident_t *trident, int offset)
} }
/* first and last (aligned) pages of memory block */ /* first and last (aligned) pages of memory block */
#define firstpg(blk) (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->first_page) #define firstpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->first_page)
#define lastpg(blk) (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->last_page) #define lastpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->last_page)
/* /*
* search empty pages which may contain given size * search empty pages which may contain given size
*/ */
static snd_util_memblk_t * static struct snd_util_memblk *
search_empty(snd_util_memhdr_t *hdr, int size) search_empty(struct snd_util_memhdr *hdr, int size)
{ {
snd_util_memblk_t *blk, *prev; struct snd_util_memblk *blk, *prev;
int page, psize; int page, psize;
struct list_head *p; struct list_head *p;
...@@ -144,7 +146,7 @@ search_empty(snd_util_memhdr_t *hdr, int size) ...@@ -144,7 +146,7 @@ search_empty(snd_util_memhdr_t *hdr, int size)
prev = NULL; prev = NULL;
page = 0; page = 0;
list_for_each(p, &hdr->block) { list_for_each(p, &hdr->block) {
blk = list_entry(p, snd_util_memblk_t, list); blk = list_entry(p, struct snd_util_memblk, list);
if (page + psize <= firstpg(blk)) if (page + psize <= firstpg(blk))
goto __found_pages; goto __found_pages;
page = lastpg(blk) + 1; page = lastpg(blk) + 1;
...@@ -183,12 +185,13 @@ static int is_valid_page(unsigned long ptr) ...@@ -183,12 +185,13 @@ static int is_valid_page(unsigned long ptr)
/* /*
* page allocation for DMA (Scatter-Gather version) * page allocation for DMA (Scatter-Gather version)
*/ */
static snd_util_memblk_t * static struct snd_util_memblk *
snd_trident_alloc_sg_pages(trident_t *trident, snd_pcm_substream_t *substream) snd_trident_alloc_sg_pages(struct snd_trident *trident,
struct snd_pcm_substream *substream)
{ {
snd_util_memhdr_t *hdr; struct snd_util_memhdr *hdr;
snd_util_memblk_t *blk; struct snd_util_memblk *blk;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int idx, page; int idx, page;
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
...@@ -230,13 +233,14 @@ snd_trident_alloc_sg_pages(trident_t *trident, snd_pcm_substream_t *substream) ...@@ -230,13 +233,14 @@ snd_trident_alloc_sg_pages(trident_t *trident, snd_pcm_substream_t *substream)
/* /*
* page allocation for DMA (contiguous version) * page allocation for DMA (contiguous version)
*/ */
static snd_util_memblk_t * static struct snd_util_memblk *
snd_trident_alloc_cont_pages(trident_t *trident, snd_pcm_substream_t *substream) snd_trident_alloc_cont_pages(struct snd_trident *trident,
struct snd_pcm_substream *substream)
{ {
snd_util_memhdr_t *hdr; struct snd_util_memhdr *hdr;
snd_util_memblk_t *blk; struct snd_util_memblk *blk;
int page; int page;
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
dma_addr_t addr; dma_addr_t addr;
unsigned long ptr; unsigned long ptr;
...@@ -270,8 +274,9 @@ snd_trident_alloc_cont_pages(trident_t *trident, snd_pcm_substream_t *substream) ...@@ -270,8 +274,9 @@ snd_trident_alloc_cont_pages(trident_t *trident, snd_pcm_substream_t *substream)
/* /*
* page allocation for DMA * page allocation for DMA
*/ */
snd_util_memblk_t * struct snd_util_memblk *
snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream) snd_trident_alloc_pages(struct snd_trident *trident,
struct snd_pcm_substream *substream)
{ {
snd_assert(trident != NULL, return NULL); snd_assert(trident != NULL, return NULL);
snd_assert(substream != NULL, return NULL); snd_assert(substream != NULL, return NULL);
...@@ -285,9 +290,10 @@ snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream) ...@@ -285,9 +290,10 @@ snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream)
/* /*
* release DMA buffer from page table * release DMA buffer from page table
*/ */
int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk) int snd_trident_free_pages(struct snd_trident *trident,
struct snd_util_memblk *blk)
{ {
snd_util_memhdr_t *hdr; struct snd_util_memhdr *hdr;
int page; int page;
snd_assert(trident != NULL, return -EINVAL); snd_assert(trident != NULL, return -EINVAL);
...@@ -314,17 +320,17 @@ int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk) ...@@ -314,17 +320,17 @@ int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk)
/* /*
*/ */
static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk); static int synth_alloc_pages(struct snd_trident *hw, struct snd_util_memblk *blk);
static int synth_free_pages(trident_t *hw, snd_util_memblk_t *blk); static int synth_free_pages(struct snd_trident *hw, struct snd_util_memblk *blk);
/* /*
* allocate a synth sample area * allocate a synth sample area
*/ */
snd_util_memblk_t * struct snd_util_memblk *
snd_trident_synth_alloc(trident_t *hw, unsigned int size) snd_trident_synth_alloc(struct snd_trident *hw, unsigned int size)
{ {
snd_util_memblk_t *blk; struct snd_util_memblk *blk;
snd_util_memhdr_t *hdr = hw->tlb.memhdr; struct snd_util_memhdr *hdr = hw->tlb.memhdr;
down(&hdr->block_mutex); down(&hdr->block_mutex);
blk = __snd_util_mem_alloc(hdr, size); blk = __snd_util_mem_alloc(hdr, size);
...@@ -346,9 +352,9 @@ snd_trident_synth_alloc(trident_t *hw, unsigned int size) ...@@ -346,9 +352,9 @@ snd_trident_synth_alloc(trident_t *hw, unsigned int size)
* free a synth sample area * free a synth sample area
*/ */
int int
snd_trident_synth_free(trident_t *hw, snd_util_memblk_t *blk) snd_trident_synth_free(struct snd_trident *hw, struct snd_util_memblk *blk)
{ {
snd_util_memhdr_t *hdr = hw->tlb.memhdr; struct snd_util_memhdr *hdr = hw->tlb.memhdr;
down(&hdr->block_mutex); down(&hdr->block_mutex);
synth_free_pages(hw, blk); synth_free_pages(hw, blk);
...@@ -361,7 +367,7 @@ snd_trident_synth_free(trident_t *hw, snd_util_memblk_t *blk) ...@@ -361,7 +367,7 @@ snd_trident_synth_free(trident_t *hw, snd_util_memblk_t *blk)
/* /*
* reset TLB entry and free kernel page * reset TLB entry and free kernel page
*/ */
static void clear_tlb(trident_t *trident, int page) static void clear_tlb(struct snd_trident *trident, int page)
{ {
void *ptr = page_to_ptr(trident, page); void *ptr = page_to_ptr(trident, page);
dma_addr_t addr = page_to_addr(trident, page); dma_addr_t addr = page_to_addr(trident, page);
...@@ -378,20 +384,22 @@ static void clear_tlb(trident_t *trident, int page) ...@@ -378,20 +384,22 @@ static void clear_tlb(trident_t *trident, int page)
} }
/* check new allocation range */ /* check new allocation range */
static void get_single_page_range(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk, int *first_page_ret, int *last_page_ret) static void get_single_page_range(struct snd_util_memhdr *hdr,
struct snd_util_memblk *blk,
int *first_page_ret, int *last_page_ret)
{ {
struct list_head *p; struct list_head *p;
snd_util_memblk_t *q; struct snd_util_memblk *q;
int first_page, last_page; int first_page, last_page;
first_page = firstpg(blk); first_page = firstpg(blk);
if ((p = blk->list.prev) != &hdr->block) { if ((p = blk->list.prev) != &hdr->block) {
q = list_entry(p, snd_util_memblk_t, list); q = list_entry(p, struct snd_util_memblk, list);
if (lastpg(q) == first_page) if (lastpg(q) == first_page)
first_page++; /* first page was already allocated */ first_page++; /* first page was already allocated */
} }
last_page = lastpg(blk); last_page = lastpg(blk);
if ((p = blk->list.next) != &hdr->block) { if ((p = blk->list.next) != &hdr->block) {
q = list_entry(p, snd_util_memblk_t, list); q = list_entry(p, struct snd_util_memblk, list);
if (firstpg(q) == last_page) if (firstpg(q) == last_page)
last_page--; /* last page was already allocated */ last_page--; /* last page was already allocated */
} }
...@@ -402,7 +410,7 @@ static void get_single_page_range(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk ...@@ -402,7 +410,7 @@ static void get_single_page_range(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk
/* /*
* allocate kernel pages and assign them to TLB * allocate kernel pages and assign them to TLB
*/ */
static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk) static int synth_alloc_pages(struct snd_trident *hw, struct snd_util_memblk *blk)
{ {
int page, first_page, last_page; int page, first_page, last_page;
struct snd_dma_buffer dmab; struct snd_dma_buffer dmab;
...@@ -438,7 +446,7 @@ static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk) ...@@ -438,7 +446,7 @@ static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk)
/* /*
* free pages * free pages
*/ */
static int synth_free_pages(trident_t *trident, snd_util_memblk_t *blk) static int synth_free_pages(struct snd_trident *trident, struct snd_util_memblk *blk)
{ {
int page, first_page, last_page; int page, first_page, last_page;
...@@ -452,7 +460,9 @@ static int synth_free_pages(trident_t *trident, snd_util_memblk_t *blk) ...@@ -452,7 +460,9 @@ static int synth_free_pages(trident_t *trident, snd_util_memblk_t *blk)
/* /*
* copy_from_user(blk + offset, data, size) * copy_from_user(blk + offset, data, size)
*/ */
int snd_trident_synth_copy_from_user(trident_t *trident, snd_util_memblk_t *blk, int offset, const char __user *data, int size) int snd_trident_synth_copy_from_user(struct snd_trident *trident,
struct snd_util_memblk *blk,
int offset, const char __user *data, int size)
{ {
int page, nextofs, end_offset, temp, temp1; int page, nextofs, end_offset, temp, temp1;
......
sound/pci/trident/trident_synth.c
View file @ bee1a5be
...@@ -192,15 +192,15 @@ static unsigned short log_from_linear( unsigned short value ) ...@@ -192,15 +192,15 @@ static unsigned short log_from_linear( unsigned short value )
* Sample handling operations * Sample handling operations
*/ */
static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position);
static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode); static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode);
static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq); static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq);
static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume); static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_volume * volume);
static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop); static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_loop * loop);
static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position);
static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data); static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data);
static snd_trident_sample_ops_t sample_ops = static struct snd_trident_sample_ops sample_ops =
{ {
sample_start, sample_start,
sample_stop, sample_stop,
...@@ -211,7 +211,7 @@ static snd_trident_sample_ops_t sample_ops = ...@@ -211,7 +211,7 @@ static snd_trident_sample_ops_t sample_ops =
sample_private1 sample_private1
}; };
static void snd_trident_simple_init(snd_trident_voice_t * voice) static void snd_trident_simple_init(struct snd_trident_voice * voice)
{ {
//voice->handler_wave = interrupt_wave; //voice->handler_wave = interrupt_wave;
//voice->handler_volume = interrupt_volume; //voice->handler_volume = interrupt_volume;
...@@ -220,10 +220,10 @@ static void snd_trident_simple_init(snd_trident_voice_t * voice) ...@@ -220,10 +220,10 @@ static void snd_trident_simple_init(snd_trident_voice_t * voice)
voice->sample_ops = &sample_ops; voice->sample_ops = &sample_ops;
} }
static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position)
{ {
simple_instrument_t *simple; struct simple_instrument *simple;
snd_seq_kinstr_t *instr; struct snd_seq_kinstr *instr;
unsigned long flags; unsigned long flags;
unsigned int loop_start, loop_end, sample_start, sample_end, start_offset; unsigned int loop_start, loop_end, sample_start, sample_end, start_offset;
unsigned int value; unsigned int value;
...@@ -305,7 +305,7 @@ static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_s ...@@ -305,7 +305,7 @@ static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_s
snd_seq_instr_free_use(trident->synth.ilist, instr); snd_seq_instr_free_use(trident->synth.ilist, instr);
} }
static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode) static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode)
{ {
unsigned long flags; unsigned long flags;
...@@ -329,7 +329,7 @@ static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_se ...@@ -329,7 +329,7 @@ static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_se
} }
} }
static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq) static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq)
{ {
unsigned long flags; unsigned long flags;
freq >>= 4; freq >>= 4;
...@@ -355,7 +355,7 @@ static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_se ...@@ -355,7 +355,7 @@ static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_se
spin_unlock_irqrestore(&trident->reg_lock, flags); spin_unlock_irqrestore(&trident->reg_lock, flags);
} }
static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume) static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_volume * volume)
{ {
unsigned long flags; unsigned long flags;
unsigned short value; unsigned short value;
...@@ -407,11 +407,11 @@ static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_ ...@@ -407,11 +407,11 @@ static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_
spin_unlock_irqrestore(&trident->reg_lock, flags); spin_unlock_irqrestore(&trident->reg_lock, flags);
} }
static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop) static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_loop * loop)
{ {
unsigned long flags; unsigned long flags;
simple_instrument_t *simple; struct simple_instrument *simple;
snd_seq_kinstr_t *instr; struct snd_seq_kinstr *instr;
unsigned int loop_start, loop_end; unsigned int loop_start, loop_end;
instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1);
...@@ -446,11 +446,11 @@ static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_se ...@@ -446,11 +446,11 @@ static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_se
snd_seq_instr_free_use(trident->synth.ilist, instr); snd_seq_instr_free_use(trident->synth.ilist, instr);
} }
static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position)
{ {
unsigned long flags; unsigned long flags;
simple_instrument_t *simple; struct simple_instrument *simple;
snd_seq_kinstr_t *instr; struct snd_seq_kinstr *instr;
unsigned int value; unsigned int value;
instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1);
...@@ -496,7 +496,7 @@ static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq ...@@ -496,7 +496,7 @@ static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq
snd_seq_instr_free_use(trident->synth.ilist, instr); snd_seq_instr_free_use(trident->synth.ilist, instr);
} }
static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data) static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data)
{ {
} }
...@@ -504,10 +504,11 @@ static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, un ...@@ -504,10 +504,11 @@ static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, un
* Memory management / sample loading * Memory management / sample loading
*/ */
static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t * instr, static int snd_trident_simple_put_sample(void *private_data,
struct simple_instrument * instr,
char __user *data, long len, int atomic) char __user *data, long len, int atomic)
{ {
trident_t *trident = private_data; struct snd_trident *trident = private_data;
int size = instr->size; int size = instr->size;
int shift = 0; int shift = 0;
...@@ -529,7 +530,7 @@ static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t ...@@ -529,7 +530,7 @@ static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t
return -EFAULT; return -EFAULT;
if (trident->tlb.entries) { if (trident->tlb.entries) {
snd_util_memblk_t *memblk; struct snd_util_memblk *memblk;
memblk = snd_trident_synth_alloc(trident, size); memblk = snd_trident_synth_alloc(trident, size);
if (memblk == NULL) if (memblk == NULL)
return -ENOMEM; return -ENOMEM;
...@@ -557,10 +558,11 @@ static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t ...@@ -557,10 +558,11 @@ static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t
return 0; return 0;
} }
static int snd_trident_simple_get_sample(void *private_data, simple_instrument_t * instr, static int snd_trident_simple_get_sample(void *private_data,
struct simple_instrument * instr,
char __user *data, long len, int atomic) char __user *data, long len, int atomic)
{ {
//trident_t *trident = private_data; //struct snd_trident *trident = private_data;
int size = instr->size; int size = instr->size;
int shift = 0; int shift = 0;
...@@ -578,10 +580,11 @@ static int snd_trident_simple_get_sample(void *private_data, simple_instrument_t ...@@ -578,10 +580,11 @@ static int snd_trident_simple_get_sample(void *private_data, simple_instrument_t
return -EBUSY; return -EBUSY;
} }
static int snd_trident_simple_remove_sample(void *private_data, simple_instrument_t * instr, static int snd_trident_simple_remove_sample(void *private_data,
struct simple_instrument * instr,
int atomic) int atomic)
{ {
trident_t *trident = private_data; struct snd_trident *trident = private_data;
int size = instr->size; int size = instr->size;
if (instr->format & SIMPLE_WAVE_16BIT) if (instr->format & SIMPLE_WAVE_16BIT)
...@@ -590,7 +593,7 @@ static int snd_trident_simple_remove_sample(void *private_data, simple_instrumen ...@@ -590,7 +593,7 @@ static int snd_trident_simple_remove_sample(void *private_data, simple_instrumen
size <<= 1; size <<= 1;
if (trident->tlb.entries) { if (trident->tlb.entries) {
snd_util_memblk_t *memblk = (snd_util_memblk_t*)instr->address.ptr; struct snd_util_memblk *memblk = (struct snd_util_memblk *)instr->address.ptr;
if (memblk) if (memblk)
snd_trident_synth_free(trident, memblk); snd_trident_synth_free(trident, memblk);
else else
...@@ -612,9 +615,9 @@ static int snd_trident_simple_remove_sample(void *private_data, simple_instrumen ...@@ -612,9 +615,9 @@ static int snd_trident_simple_remove_sample(void *private_data, simple_instrumen
return 0; return 0;
} }
static void select_instrument(trident_t * trident, snd_trident_voice_t * v) static void select_instrument(struct snd_trident * trident, struct snd_trident_voice * v)
{ {
snd_seq_kinstr_t *instr; struct snd_seq_kinstr *instr;
instr = snd_seq_instr_find(trident->synth.ilist, &v->instr, 0, 1); instr = snd_seq_instr_find(trident->synth.ilist, &v->instr, 0, 1);
if (instr != NULL) { if (instr != NULL) {
if (instr->ops) { if (instr->ops) {
...@@ -629,7 +632,7 @@ static void select_instrument(trident_t * trident, snd_trident_voice_t * v) ...@@ -629,7 +632,7 @@ static void select_instrument(trident_t * trident, snd_trident_voice_t * v)
*/ */
static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_sample(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_stop) if (v->sample_ops && v->sample_ops->sample_stop)
v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY);
...@@ -643,7 +646,7 @@ static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_tride ...@@ -643,7 +646,7 @@ static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_tride
select_instrument(p->trident, v); select_instrument(p->trident, v);
} }
static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_cluster(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_stop) if (v->sample_ops && v->sample_ops->sample_stop)
v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY);
...@@ -651,49 +654,49 @@ static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trid ...@@ -651,49 +654,49 @@ static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trid
select_instrument(p->trident, v); select_instrument(p->trident, v);
} }
static void event_start(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_start(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_start) if (v->sample_ops && v->sample_ops->sample_start)
v->sample_ops->sample_start(p->trident, v, ev->data.sample.param.position); v->sample_ops->sample_start(p->trident, v, ev->data.sample.param.position);
} }
static void event_stop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_stop(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_stop) if (v->sample_ops && v->sample_ops->sample_stop)
v->sample_ops->sample_stop(p->trident, v, ev->data.sample.param.stop_mode); v->sample_ops->sample_stop(p->trident, v, ev->data.sample.param.stop_mode);
} }
static void event_freq(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_freq(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_freq) if (v->sample_ops && v->sample_ops->sample_freq)
v->sample_ops->sample_freq(p->trident, v, ev->data.sample.param.frequency); v->sample_ops->sample_freq(p->trident, v, ev->data.sample.param.frequency);
} }
static void event_volume(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_volume(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_volume) if (v->sample_ops && v->sample_ops->sample_volume)
v->sample_ops->sample_volume(p->trident, v, &ev->data.sample.param.volume); v->sample_ops->sample_volume(p->trident, v, &ev->data.sample.param.volume);
} }
static void event_loop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_loop(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_loop) if (v->sample_ops && v->sample_ops->sample_loop)
v->sample_ops->sample_loop(p->trident, v, &ev->data.sample.param.loop); v->sample_ops->sample_loop(p->trident, v, &ev->data.sample.param.loop);
} }
static void event_position(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_position(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_pos) if (v->sample_ops && v->sample_ops->sample_pos)
v->sample_ops->sample_pos(p->trident, v, ev->data.sample.param.position); v->sample_ops->sample_pos(p->trident, v, ev->data.sample.param.position);
} }
static void event_private1(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) static void event_private1(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
{ {
if (v->sample_ops && v->sample_ops->sample_private1) if (v->sample_ops && v->sample_ops->sample_private1)
v->sample_ops->sample_private1(p->trident, v, (unsigned char *) &ev->data.sample.param.raw8); v->sample_ops->sample_private1(p->trident, v, (unsigned char *) &ev->data.sample.param.raw8);
} }
typedef void (trident_sample_event_handler_t) (snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v); typedef void (trident_sample_event_handler_t) (struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v);
static trident_sample_event_handler_t *trident_sample_event_handlers[9] = static trident_sample_event_handler_t *trident_sample_event_handlers[9] =
{ {
...@@ -708,11 +711,11 @@ static trident_sample_event_handler_t *trident_sample_event_handlers[9] = ...@@ -708,11 +711,11 @@ static trident_sample_event_handler_t *trident_sample_event_handlers[9] =
event_private1 event_private1
}; };
static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t * p) static void snd_trident_sample_event(struct snd_seq_event * ev, struct snd_trident_port * p)
{ {
int idx, voice; int idx, voice;
trident_t *trident = p->trident; struct snd_trident *trident = p->trident;
snd_trident_voice_t *v; struct snd_trident_voice *v;
unsigned long flags; unsigned long flags;
idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE; idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE;
...@@ -735,10 +738,10 @@ static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t * ...@@ -735,10 +738,10 @@ static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t *
*/ */
static void snd_trident_synth_free_voices(trident_t * trident, int client, int port) static void snd_trident_synth_free_voices(struct snd_trident * trident, int client, int port)
{ {
int idx; int idx;
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
for (idx = 0; idx < 32; idx++) { for (idx = 0; idx < 32; idx++) {
voice = &trident->synth.voices[idx]; voice = &trident->synth.voices[idx];
...@@ -747,11 +750,11 @@ static void snd_trident_synth_free_voices(trident_t * trident, int client, int p ...@@ -747,11 +750,11 @@ static void snd_trident_synth_free_voices(trident_t * trident, int client, int p
} }
} }
static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t * info) static int snd_trident_synth_use(void *private_data, struct snd_seq_port_subscribe * info)
{ {
snd_trident_port_t *port = (snd_trident_port_t *) private_data; struct snd_trident_port *port = private_data;
trident_t *trident = port->trident; struct snd_trident *trident = port->trident;
snd_trident_voice_t *voice; struct snd_trident_voice *voice;
unsigned int idx; unsigned int idx;
unsigned long flags; unsigned long flags;
...@@ -786,10 +789,10 @@ static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t * ...@@ -786,10 +789,10 @@ static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t *
return 0; return 0;
} }
static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t * info) static int snd_trident_synth_unuse(void *private_data, struct snd_seq_port_subscribe * info)
{ {
snd_trident_port_t *port = (snd_trident_port_t *) private_data; struct snd_trident_port *port = private_data;
trident_t *trident = port->trident; struct snd_trident *trident = port->trident;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&trident->reg_lock, flags); spin_lock_irqsave(&trident->reg_lock, flags);
...@@ -802,18 +805,18 @@ static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t ...@@ -802,18 +805,18 @@ static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t
*/ */
static void snd_trident_synth_free_private_instruments(snd_trident_port_t * p, int client) static void snd_trident_synth_free_private_instruments(struct snd_trident_port * p, int client)
{ {
snd_seq_instr_header_t ifree; struct snd_seq_instr_header ifree;
memset(&ifree, 0, sizeof(ifree)); memset(&ifree, 0, sizeof(ifree));
ifree.cmd = SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE; ifree.cmd = SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE;
snd_seq_instr_list_free_cond(p->trident->synth.ilist, &ifree, client, 0); snd_seq_instr_list_free_cond(p->trident->synth.ilist, &ifree, client, 0);
} }
static int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) static int snd_trident_synth_event_input(struct snd_seq_event * ev, int direct, void *private_data, int atomic, int hop)
{ {
snd_trident_port_t *p = (snd_trident_port_t *) private_data; struct snd_trident_port *p = (struct snd_trident_port *) private_data;
if (p == NULL) if (p == NULL)
return -EINVAL; return -EINVAL;
...@@ -841,12 +844,12 @@ static int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void ...@@ -841,12 +844,12 @@ static int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void
} }
static void snd_trident_synth_instr_notify(void *private_data, static void snd_trident_synth_instr_notify(void *private_data,
snd_seq_kinstr_t * instr, struct snd_seq_kinstr * instr,
int what) int what)
{ {
int idx; int idx;
trident_t *trident = private_data; struct snd_trident *trident = private_data;
snd_trident_voice_t *pvoice; struct snd_trident_voice *pvoice;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&trident->event_lock, flags); spin_lock_irqsave(&trident->event_lock, flags);
...@@ -870,16 +873,16 @@ static void snd_trident_synth_instr_notify(void *private_data, ...@@ -870,16 +873,16 @@ static void snd_trident_synth_instr_notify(void *private_data,
static void snd_trident_synth_free_port(void *private_data) static void snd_trident_synth_free_port(void *private_data)
{ {
snd_trident_port_t *p = (snd_trident_port_t *) private_data; struct snd_trident_port *p = (struct snd_trident_port *) private_data;
if (p) if (p)
snd_midi_channel_free_set(p->chset); snd_midi_channel_free_set(p->chset);
} }
static int snd_trident_synth_create_port(trident_t * trident, int idx) static int snd_trident_synth_create_port(struct snd_trident * trident, int idx)
{ {
snd_trident_port_t *p; struct snd_trident_port *p;
snd_seq_port_callback_t callbacks; struct snd_seq_port_callback callbacks;
char name[32]; char name[32];
char *str; char *str;
int result; int result;
...@@ -927,17 +930,17 @@ static int snd_trident_synth_create_port(trident_t * trident, int idx) ...@@ -927,17 +930,17 @@ static int snd_trident_synth_create_port(trident_t * trident, int idx)
*/ */
static int snd_trident_synth_new_device(snd_seq_device_t *dev) static int snd_trident_synth_new_device(struct snd_seq_device *dev)
{ {
trident_t *trident; struct snd_trident *trident;
int client, i; int client, i;
snd_seq_client_callback_t callbacks; struct snd_seq_client_callback callbacks;
snd_seq_client_info_t cinfo; struct snd_seq_client_info cinfo;
snd_seq_port_subscribe_t sub; struct snd_seq_port_subscribe sub;
snd_simple_ops_t *simpleops; struct snd_simple_ops *simpleops;
char *str; char *str;
trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
if (trident == NULL) if (trident == NULL)
return -EINVAL; return -EINVAL;
...@@ -993,11 +996,11 @@ static int snd_trident_synth_new_device(snd_seq_device_t *dev) ...@@ -993,11 +996,11 @@ static int snd_trident_synth_new_device(snd_seq_device_t *dev)
return 0; return 0;
} }
static int snd_trident_synth_delete_device(snd_seq_device_t *dev) static int snd_trident_synth_delete_device(struct snd_seq_device *dev)
{ {
trident_t *trident; struct snd_trident *trident;
trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
if (trident == NULL) if (trident == NULL)
return -EINVAL; return -EINVAL;
...@@ -1012,14 +1015,14 @@ static int snd_trident_synth_delete_device(snd_seq_device_t *dev) ...@@ -1012,14 +1015,14 @@ static int snd_trident_synth_delete_device(snd_seq_device_t *dev)
static int __init alsa_trident_synth_init(void) static int __init alsa_trident_synth_init(void)
{ {
static snd_seq_dev_ops_t ops = static struct snd_seq_dev_ops ops =
{ {
snd_trident_synth_new_device, snd_trident_synth_new_device,
snd_trident_synth_delete_device snd_trident_synth_delete_device
}; };
return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_TRIDENT, &ops, return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_TRIDENT, &ops,
sizeof(trident_t*)); sizeof(struct snd_trident *));
} }
static void __exit alsa_trident_synth_exit(void) static void __exit alsa_trident_synth_exit(void)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7