]> err.no Git - linux-2.6/commitdiff
[ALSA] Remove xxx_t typedefs: ISA SB8/SB16/SBAWE
authorTakashi Iwai <tiwai@suse.de>
Thu, 17 Nov 2005 13:34:36 +0000 (14:34 +0100)
committerJaroslav Kysela <perex@suse.cz>
Tue, 3 Jan 2006 11:18:25 +0000 (12:18 +0100)
Remove xxx_t typedefs from the ISA SB8/SB16/SBAWE drivers.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
18 files changed:
include/sound/emu8000.h
include/sound/sb.h
include/sound/sb16_csp.h
sound/isa/sb/emu8000.c
sound/isa/sb/emu8000_callback.c
sound/isa/sb/emu8000_local.h
sound/isa/sb/emu8000_patch.c
sound/isa/sb/emu8000_pcm.c
sound/isa/sb/emu8000_synth.c
sound/isa/sb/es968.c
sound/isa/sb/sb16.c
sound/isa/sb/sb16_csp.c
sound/isa/sb/sb16_main.c
sound/isa/sb/sb8.c
sound/isa/sb/sb8_main.c
sound/isa/sb/sb8_midi.c
sound/isa/sb/sb_common.c
sound/isa/sb/sb_mixer.c

index 4362c54e09d0732aec3e3c5f9f1ad172b19aa952..c8f66bde6d9580202b6a094e129e8c927a0ba385 100644 (file)
@@ -56,9 +56,9 @@ enum {
  * some of the channels may be used for other things so max_channels is
  * the number in use for wave voices.
  */
-typedef struct snd_emu8000 {
+struct snd_emu8000 {
 
-       snd_emux_t *emu;
+       struct snd_emux *emu;
 
        int index;              /* sequencer client index */
        int seq_ports;          /* number of sequencer ports */
@@ -77,44 +77,45 @@ typedef struct snd_emu8000 {
 
        int dram_checked;
 
-       snd_card_t *card;               /* The card that this belongs to */
+       struct snd_card *card;          /* The card that this belongs to */
 
        int chorus_mode;
        int reverb_mode;
        int bass_level;
        int treble_level;
 
-       snd_util_memhdr_t *memhdr;
+       struct snd_util_memhdr *memhdr;
 
        spinlock_t control_lock;
-       snd_kcontrol_t *controls[EMU8000_NUM_CONTROLS];
+       struct snd_kcontrol *controls[EMU8000_NUM_CONTROLS];
 
-       snd_pcm_t *pcm; /* pcm on emu8000 wavetable */
+       struct snd_pcm *pcm; /* pcm on emu8000 wavetable */
 
-} emu8000_t;
+};
 
 /* sequencer device id */
 #define SNDRV_SEQ_DEV_ID_EMU8000       "emu8000-synth"
 
 
 /* exported functions */
-int snd_emu8000_new(snd_card_t *card, int device, long port, int seq_ports, snd_seq_device_t **ret);
-void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg,
+int snd_emu8000_new(struct snd_card *card, int device, long port, int seq_ports,
+                   struct snd_seq_device **ret);
+void snd_emu8000_poke(struct snd_emu8000 *emu, unsigned int port, unsigned int reg,
                      unsigned int val);
-unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port,
+unsigned short snd_emu8000_peek(struct snd_emu8000 *emu, unsigned int port,
                                unsigned int reg);
-void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg,
+void snd_emu8000_poke_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg,
                         unsigned int val);
-unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port,
+unsigned int snd_emu8000_peek_dw(struct snd_emu8000 *emu, unsigned int port,
                                 unsigned int reg);
-void snd_emu8000_dma_chan(emu8000_t *emu, int ch, int mode);
+void snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode);
 
-void snd_emu8000_init_fm(emu8000_t *emu);
+void snd_emu8000_init_fm(struct snd_emu8000 *emu);
 
-void snd_emu8000_update_chorus_mode(emu8000_t *emu);
-void snd_emu8000_update_reverb_mode(emu8000_t *emu);
-void snd_emu8000_update_equalizer(emu8000_t *emu);
-int snd_emu8000_load_chorus_fx(emu8000_t *emu, int mode, const void __user *buf, long len);
-int snd_emu8000_load_reverb_fx(emu8000_t *emu, int mode, const void __user *buf, long len);
+void snd_emu8000_update_chorus_mode(struct snd_emu8000 *emu);
+void snd_emu8000_update_reverb_mode(struct snd_emu8000 *emu);
+void snd_emu8000_update_equalizer(struct snd_emu8000 *emu);
+int snd_emu8000_load_chorus_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len);
+int snd_emu8000_load_reverb_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len);
 
 #endif /* __SOUND_EMU8000_H */
index 7960452445e63ebfc4f55b9683bc9941de1f818c..8e82460c4d34c64453877b25de323d432614ed05 100644 (file)
@@ -60,7 +60,7 @@ enum sb_hw_type {
 
 #define SB_MPU_INPUT           1
 
-struct _snd_sb {
+struct snd_sb {
        unsigned long port;             /* base port of DSP chip */
        struct resource *res_port;
        unsigned long mpu_port;         /* MPU port for SB DSP 4.0+ */
@@ -92,25 +92,23 @@ struct _snd_sb {
 
        void *csp; /* used only when CONFIG_SND_SB16_CSP is set */
 
-       snd_card_t *card;
-       snd_pcm_t *pcm;
-       snd_pcm_substream_t *playback_substream;
-       snd_pcm_substream_t *capture_substream;
+       struct snd_card *card;
+       struct snd_pcm *pcm;
+       struct snd_pcm_substream *playback_substream;
+       struct snd_pcm_substream *capture_substream;
 
-       snd_rawmidi_t *rmidi;
-       snd_rawmidi_substream_t *midi_substream_input;
-       snd_rawmidi_substream_t *midi_substream_output;
+       struct snd_rawmidi *rmidi;
+       struct snd_rawmidi_substream *midi_substream_input;
+       struct snd_rawmidi_substream *midi_substream_output;
        irqreturn_t (*rmidi_callback)(int irq, void *dev_id, struct pt_regs *regs);
 
        spinlock_t reg_lock;
        spinlock_t open_lock;
        spinlock_t midi_input_lock;
 
-       snd_info_entry_t *proc_entry;
+       struct snd_info_entry *proc_entry;
 };
 
-typedef struct _snd_sb sb_t;
-
 /* I/O ports */
 
 #define SBP(chip, x)           ((chip)->port + s_b_SB_##x)
@@ -267,48 +265,48 @@ typedef struct _snd_sb sb_t;
  *
  */
 
-static inline void snd_sb_ack_8bit(sb_t *chip)
+static inline void snd_sb_ack_8bit(struct snd_sb *chip)
 {
        inb(SBP(chip, DATA_AVAIL));
 }
 
-static inline void snd_sb_ack_16bit(sb_t *chip)
+static inline void snd_sb_ack_16bit(struct snd_sb *chip)
 {
        inb(SBP(chip, DATA_AVAIL_16));
 }
 
 /* sb_common.c */
-int snd_sbdsp_command(sb_t *chip, unsigned char val);
-int snd_sbdsp_get_byte(sb_t *chip);
-int snd_sbdsp_reset(sb_t *chip);
-int snd_sbdsp_create(snd_card_t *card,
+int snd_sbdsp_command(struct snd_sb *chip, unsigned char val);
+int snd_sbdsp_get_byte(struct snd_sb *chip);
+int snd_sbdsp_reset(struct snd_sb *chip);
+int snd_sbdsp_create(struct snd_card *card,
                     unsigned long port,
                     int irq,
                     irqreturn_t (*irq_handler)(int, void *, struct pt_regs *),
                     int dma8, int dma16,
                     unsigned short hardware,
-                    sb_t **r_chip);
+                    struct snd_sb **r_chip);
 /* sb_mixer.c */
-void snd_sbmixer_write(sb_t *chip, unsigned char reg, unsigned char data);
-unsigned char snd_sbmixer_read(sb_t *chip, unsigned char reg);
-int snd_sbmixer_new(sb_t *chip);
+void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char data);
+unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg);
+int snd_sbmixer_new(struct snd_sb *chip);
 
 /* sb8_init.c */
-int snd_sb8dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm);
+int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm);
 /* sb8.c */
-irqreturn_t snd_sb8dsp_interrupt(sb_t *chip);
-int snd_sb8_playback_open(snd_pcm_substream_t *substream);
-int snd_sb8_capture_open(snd_pcm_substream_t *substream);
-int snd_sb8_playback_close(snd_pcm_substream_t *substream);
-int snd_sb8_capture_close(snd_pcm_substream_t *substream);
+irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip);
+int snd_sb8_playback_open(struct snd_pcm_substream *substream);
+int snd_sb8_capture_open(struct snd_pcm_substream *substream);
+int snd_sb8_playback_close(struct snd_pcm_substream *substream);
+int snd_sb8_capture_close(struct snd_pcm_substream *substream);
 /* midi8.c */
-irqreturn_t snd_sb8dsp_midi_interrupt(sb_t *chip);
-int snd_sb8dsp_midi(sb_t *chip, int device, snd_rawmidi_t ** rrawmidi);
+irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip);
+int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi);
 
 /* sb16_init.c */
-int snd_sb16dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm);
-const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction);
-int snd_sb16dsp_configure(sb_t *chip);
+int snd_sb16dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm);
+const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction);
+int snd_sb16dsp_configure(struct snd_sb *chip);
 /* sb16.c */
 irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 
@@ -328,7 +326,7 @@ enum {
 #define SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) \
   ((reg1) | ((reg2) << 8) | ((left_shift) << 16) | ((right_shift) << 24))
 
-int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsigned long value);
+int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int type, unsigned long value);
 
 /* for ease of use */
 struct sbmix_elem {
@@ -352,7 +350,7 @@ struct sbmix_elem {
   .type = SB_MIX_INPUT_SW, \
   .private_value = SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) }
 
-static inline int snd_sbmixer_add_ctl_elem(sb_t *chip, const struct sbmix_elem *c)
+static inline int snd_sbmixer_add_ctl_elem(struct snd_sb *chip, const struct sbmix_elem *c)
 {
        return snd_sbmixer_add_ctl(chip, c->name, 0, c->type, c->private_value);
 }
index eb8368b56b161f8a2fce8a9deb676680f05bceb8..3b44d4b370f5fe2fd6eb3108c5eab67fba7e1f06 100644 (file)
 #define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE   0x3000
 
 /* microcode header */
-typedef struct snd_sb_csp_mc_header {
+struct snd_sb_csp_mc_header {
        char codec_name[16];            /* id name of codec */
        unsigned short func_req;        /* requested function */
-} snd_sb_csp_mc_header_t;
+};
 
 /* microcode to be loaded */
-typedef struct snd_sb_csp_microcode {
-       snd_sb_csp_mc_header_t info;
+struct snd_sb_csp_microcode {
+       struct snd_sb_csp_mc_header info;
        unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE];
-} snd_sb_csp_microcode_t;
+};
 
 /* start CSP with sample_width in mono/stereo */
-typedef struct snd_sb_csp_start {
+struct snd_sb_csp_start {
        int sample_width;       /* sample width, look above */
        int channels;           /* channels, look above */
-} snd_sb_csp_start_t;
+};
 
 /* CSP information */
-typedef struct snd_sb_csp_info {
+struct snd_sb_csp_info {
        char codec_name[16];            /* id name of codec */
        unsigned short func_nr;         /* function number */
        unsigned int acc_format;        /* accepted PCM formats */
@@ -93,17 +93,17 @@ typedef struct snd_sb_csp_info {
        unsigned short run_width;       /* current sample width */
        unsigned short version;         /* version id: 0x10 - 0x1f */
        unsigned short state;           /* state bits */
-} snd_sb_csp_info_t;
+};
 
 /* HWDEP controls */
 /* get CSP information */
-#define SNDRV_SB_CSP_IOCTL_INFO                _IOR('H', 0x10, snd_sb_csp_info_t)
+#define SNDRV_SB_CSP_IOCTL_INFO                _IOR('H', 0x10, struct snd_sb_csp_info)
 /* load microcode to CSP */
-#define SNDRV_SB_CSP_IOCTL_LOAD_CODE   _IOW('H', 0x11, snd_sb_csp_microcode_t)
+#define SNDRV_SB_CSP_IOCTL_LOAD_CODE   _IOW('H', 0x11, struct snd_sb_csp_microcode)
 /* unload microcode from CSP */
 #define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12)
 /* start CSP */
-#define SNDRV_SB_CSP_IOCTL_START               _IOW('H', 0x13, snd_sb_csp_start_t)
+#define SNDRV_SB_CSP_IOCTL_START               _IOW('H', 0x13, struct snd_sb_csp_start)
 /* stop CSP */
 #define SNDRV_SB_CSP_IOCTL_STOP                _IO('H', 0x14)
 /* pause CSP and DMA transfer */
@@ -115,25 +115,25 @@ typedef struct snd_sb_csp_info {
 #include "sb.h"
 #include "hwdep.h"
 
-typedef struct snd_sb_csp snd_sb_csp_t;
+struct snd_sb_csp;
 
 /*
  * CSP operators
  */
-typedef struct {
-       int (*csp_use) (snd_sb_csp_t * p);
-       int (*csp_unuse) (snd_sb_csp_t * p);
-       int (*csp_autoload) (snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode);
-       int (*csp_start) (snd_sb_csp_t * p, int sample_width, int channels);
-       int (*csp_stop) (snd_sb_csp_t * p);
-       int (*csp_qsound_transfer) (snd_sb_csp_t * p);
-} snd_sb_csp_ops_t;
+struct snd_sb_csp_ops {
+       int (*csp_use) (struct snd_sb_csp * p);
+       int (*csp_unuse) (struct snd_sb_csp * p);
+       int (*csp_autoload) (struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode);
+       int (*csp_start) (struct snd_sb_csp * p, int sample_width, int channels);
+       int (*csp_stop) (struct snd_sb_csp * p);
+       int (*csp_qsound_transfer) (struct snd_sb_csp * p);
+};
 
 /*
  * CSP private data
  */
 struct snd_sb_csp {
-       sb_t *chip;             /* SB16 DSP */
+       struct snd_sb *chip;            /* SB16 DSP */
        int used;               /* usage flag - exclusive */
        char codec_name[16];    /* name of codec */
        unsigned short func_nr; /* function number */
@@ -147,7 +147,7 @@ struct snd_sb_csp {
        int version;            /* CSP version (0x10 - 0x1f) */
        int running;            /* running state */
 
-       snd_sb_csp_ops_t ops;   /* operators */
+       struct snd_sb_csp_ops ops;      /* operators */
 
        spinlock_t q_lock;      /* locking */
        int q_enabled;          /* enabled flag */
@@ -155,13 +155,13 @@ struct snd_sb_csp {
        int qpos_right;         /* right position */
        int qpos_changed;       /* position changed flag */
 
-       snd_kcontrol_t *qsound_switch;
-       snd_kcontrol_t *qsound_space;
+       struct snd_kcontrol *qsound_switch;
+       struct snd_kcontrol *qsound_space;
 
        struct semaphore access_mutex;  /* locking */
 };
 
-int snd_sb_csp_new(sb_t *chip, int device, snd_hwdep_t ** rhwdep);
+int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep);
 #endif
 
 #endif /* __SOUND_SB16_CSP */
index b09c6575e01ae4dbc2975506d0927e17b3779369..c0b8d61b75e712782973aeac756967b8ea7e7c07 100644 (file)
@@ -45,7 +45,7 @@
  * directly.  The macros handle the port number and command word.
  */
 /* Write a word */
-void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val)
+void snd_emu8000_poke(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, unsigned int val)
 {
        unsigned long flags;
        spin_lock_irqsave(&emu->reg_lock, flags);
@@ -58,7 +58,7 @@ void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, unsig
 }
 
 /* Read a word */
-unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, unsigned int reg)
+unsigned short snd_emu8000_peek(struct snd_emu8000 *emu, unsigned int port, unsigned int reg)
 {
        unsigned short res;
        unsigned long flags;
@@ -73,7 +73,7 @@ unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, unsigned int
 }
 
 /* Write a double word */
-void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val)
+void snd_emu8000_poke_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, unsigned int val)
 {
        unsigned long flags;
        spin_lock_irqsave(&emu->reg_lock, flags);
@@ -87,7 +87,7 @@ void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, un
 }
 
 /* Read a double word */
-unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, unsigned int reg)
+unsigned int snd_emu8000_peek_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg)
 {
        unsigned short low;
        unsigned int res;
@@ -107,7 +107,7 @@ unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, unsigned int
  * Set up / close a channel to be used for DMA.
  */
 /*exported*/ void
-snd_emu8000_dma_chan(emu8000_t *emu, int ch, int mode)
+snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode)
 {
        unsigned right_bit = (mode & EMU8000_RAM_RIGHT) ? 0x01000000 : 0;
        mode &= EMU8000_RAM_MODE_MASK;
@@ -132,7 +132,7 @@ snd_emu8000_dma_chan(emu8000_t *emu, int ch, int mode)
 /*
  */
 static void __init
-snd_emu8000_read_wait(emu8000_t *emu)
+snd_emu8000_read_wait(struct snd_emu8000 *emu)
 {
        while ((EMU8000_SMALR_READ(emu) & 0x80000000) != 0) {
                schedule_timeout_interruptible(1);
@@ -144,7 +144,7 @@ snd_emu8000_read_wait(emu8000_t *emu)
 /*
  */
 static void __init
-snd_emu8000_write_wait(emu8000_t *emu)
+snd_emu8000_write_wait(struct snd_emu8000 *emu)
 {
        while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
                schedule_timeout_interruptible(1);
@@ -157,7 +157,7 @@ snd_emu8000_write_wait(emu8000_t *emu)
  * detect a card at the given port
  */
 static int __init
-snd_emu8000_detect(emu8000_t *emu)
+snd_emu8000_detect(struct snd_emu8000 *emu)
 {
        /* Initialise */
        EMU8000_HWCF1_WRITE(emu, 0x0059);
@@ -183,7 +183,7 @@ snd_emu8000_detect(emu8000_t *emu)
  * intiailize audio channels
  */
 static void __init
-init_audio(emu8000_t *emu)
+init_audio(struct snd_emu8000 *emu)
 {
        int ch;
 
@@ -224,7 +224,7 @@ init_audio(emu8000_t *emu)
  * initialize DMA address
  */
 static void __init
-init_dma(emu8000_t *emu)
+init_dma(struct snd_emu8000 *emu)
 {
        EMU8000_SMALR_WRITE(emu, 0);
        EMU8000_SMARR_WRITE(emu, 0);
@@ -328,7 +328,7 @@ static unsigned short init4[128] /*__devinitdata*/ = {
  * is meant to work
  */
 static void __init
-send_array(emu8000_t *emu, unsigned short *data, int size)
+send_array(struct snd_emu8000 *emu, unsigned short *data, int size)
 {
        int i;
        unsigned short *p;
@@ -350,7 +350,7 @@ send_array(emu8000_t *emu, unsigned short *data, int size)
  * initialisation sequence in the adip.
  */
 static void __init
-init_arrays(emu8000_t *emu)
+init_arrays(struct snd_emu8000 *emu)
 {
        send_array(emu, init1, ARRAY_SIZE(init1)/4);
 
@@ -376,7 +376,7 @@ init_arrays(emu8000_t *emu)
  * reallocating between read and write.
  */
 static void __init
-size_dram(emu8000_t *emu)
+size_dram(struct snd_emu8000 *emu)
 {
        int i, size;
 
@@ -455,7 +455,7 @@ size_dram(emu8000_t *emu)
  * and therefore lose 2 voices.
  */
 /*exported*/ void
-snd_emu8000_init_fm(emu8000_t *emu)
+snd_emu8000_init_fm(struct snd_emu8000 *emu)
 {
        unsigned long flags;
 
@@ -501,7 +501,7 @@ snd_emu8000_init_fm(emu8000_t *emu)
  * The main initialization routine.
  */
 static void __init
-snd_emu8000_init_hw(emu8000_t *emu)
+snd_emu8000_init_hw(struct snd_emu8000 *emu)
 {
        int i;
 
@@ -585,7 +585,7 @@ static unsigned short treble_parm[12][9] = {
  * set Emu8000 digital equalizer; from 0 to 11 [-12dB - 12dB]
  */
 /*exported*/ void
-snd_emu8000_update_equalizer(emu8000_t *emu)
+snd_emu8000_update_equalizer(struct snd_emu8000 *emu)
 {
        unsigned short w;
        int bass = emu->bass_level;
@@ -628,17 +628,17 @@ snd_emu8000_update_equalizer(emu8000_t *emu)
 /* user can define chorus modes up to 32 */
 #define SNDRV_EMU8000_CHORUS_NUMBERS   32
 
-typedef struct soundfont_chorus_fx_t {
+struct soundfont_chorus_fx {
        unsigned short feedback;        /* feedback level (0xE600-0xE6FF) */
        unsigned short delay_offset;    /* delay (0-0x0DA3) [1/44100 sec] */
        unsigned short lfo_depth;       /* LFO depth (0xBC00-0xBCFF) */
        unsigned int delay;     /* right delay (0-0xFFFFFFFF) [1/256/44100 sec] */
        unsigned int lfo_freq;          /* LFO freq LFO freq (0-0xFFFFFFFF) */
-} soundfont_chorus_fx_t;
+};
 
 /* 5 parameters for each chorus mode; 3 x 16bit, 2 x 32bit */
 static char chorus_defined[SNDRV_EMU8000_CHORUS_NUMBERS];
-static soundfont_chorus_fx_t chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = {
+static struct soundfont_chorus_fx chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = {
        {0xE600, 0x03F6, 0xBC2C ,0x00000000, 0x0000006D}, /* chorus 1 */
        {0xE608, 0x031A, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 2 */
        {0xE610, 0x031A, 0xBC84, 0x00000000, 0x00000083}, /* chorus 3 */
@@ -650,9 +650,9 @@ static soundfont_chorus_fx_t chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = {
 };
 
 /*exported*/ int
-snd_emu8000_load_chorus_fx(emu8000_t *emu, int mode, const void __user *buf, long len)
+snd_emu8000_load_chorus_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len)
 {
-       soundfont_chorus_fx_t rec;
+       struct soundfont_chorus_fx rec;
        if (mode < SNDRV_EMU8000_CHORUS_PREDEFINED || mode >= SNDRV_EMU8000_CHORUS_NUMBERS) {
                snd_printk(KERN_WARNING "invalid chorus mode %d for uploading\n", mode);
                return -EINVAL;
@@ -665,7 +665,7 @@ snd_emu8000_load_chorus_fx(emu8000_t *emu, int mode, const void __user *buf, lon
 }
 
 /*exported*/ void
-snd_emu8000_update_chorus_mode(emu8000_t *emu)
+snd_emu8000_update_chorus_mode(struct snd_emu8000 *emu)
 {
        int effect = emu->chorus_mode;
        if (effect < 0 || effect >= SNDRV_EMU8000_CHORUS_NUMBERS ||
@@ -699,15 +699,15 @@ snd_emu8000_update_chorus_mode(emu8000_t *emu)
 /* user can define reverb modes up to 32 */
 #define SNDRV_EMU8000_REVERB_NUMBERS   32
 
-typedef struct soundfont_reverb_fx_t {
+struct soundfont_reverb_fx {
        unsigned short parms[28];
-} soundfont_reverb_fx_t;
+};
 
 /* reverb mode settings; write the following 28 data of 16 bit length
  *   on the corresponding ports in the reverb_cmds array
  */
 static char reverb_defined[SNDRV_EMU8000_CHORUS_NUMBERS];
-static soundfont_reverb_fx_t reverb_parm[SNDRV_EMU8000_REVERB_NUMBERS] = {
+static struct soundfont_reverb_fx reverb_parm[SNDRV_EMU8000_REVERB_NUMBERS] = {
 {{  /* room 1 */
        0xB488, 0xA450, 0x9550, 0x84B5, 0x383A, 0x3EB5, 0x72F4,
        0x72A4, 0x7254, 0x7204, 0x7204, 0x7204, 0x4416, 0x4516,
@@ -777,9 +777,9 @@ static struct reverb_cmd_pair {
 };
 
 /*exported*/ int
-snd_emu8000_load_reverb_fx(emu8000_t *emu, int mode, const void __user *buf, long len)
+snd_emu8000_load_reverb_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len)
 {
-       soundfont_reverb_fx_t rec;
+       struct soundfont_reverb_fx rec;
 
        if (mode < SNDRV_EMU8000_REVERB_PREDEFINED || mode >= SNDRV_EMU8000_REVERB_NUMBERS) {
                snd_printk(KERN_WARNING "invalid reverb mode %d for uploading\n", mode);
@@ -793,7 +793,7 @@ snd_emu8000_load_reverb_fx(emu8000_t *emu, int mode, const void __user *buf, lon
 }
 
 /*exported*/ void
-snd_emu8000_update_reverb_mode(emu8000_t *emu)
+snd_emu8000_update_reverb_mode(struct snd_emu8000 *emu)
 {
        int effect = emu->reverb_mode;
        int i;
@@ -819,7 +819,7 @@ snd_emu8000_update_reverb_mode(emu8000_t *emu)
 /*
  * bass/treble
  */
-static int mixer_bass_treble_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int mixer_bass_treble_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 1;
@@ -828,17 +828,17 @@ static int mixer_bass_treble_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
        return 0;
 }
 
-static int mixer_bass_treble_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_bass_treble_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        
        ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->treble_level : emu->bass_level;
        return 0;
 }
 
-static int mixer_bass_treble_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_bass_treble_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned short val1;
@@ -857,7 +857,7 @@ static int mixer_bass_treble_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
        return change;
 }
 
-static snd_kcontrol_new_t mixer_bass_control =
+static struct snd_kcontrol_new mixer_bass_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "Synth Tone Control - Bass",
@@ -867,7 +867,7 @@ static snd_kcontrol_new_t mixer_bass_control =
        .private_value = 0,
 };
 
-static snd_kcontrol_new_t mixer_treble_control =
+static struct snd_kcontrol_new mixer_treble_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "Synth Tone Control - Treble",
@@ -880,7 +880,7 @@ static snd_kcontrol_new_t mixer_treble_control =
 /*
  * chorus/reverb mode
  */
-static int mixer_chorus_reverb_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int mixer_chorus_reverb_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 1;
@@ -889,17 +889,17 @@ static int mixer_chorus_reverb_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_
        return 0;
 }
 
-static int mixer_chorus_reverb_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_chorus_reverb_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        
        ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->chorus_mode : emu->reverb_mode;
        return 0;
 }
 
-static int mixer_chorus_reverb_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_chorus_reverb_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned short val1;
@@ -924,7 +924,7 @@ static int mixer_chorus_reverb_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value
        return change;
 }
 
-static snd_kcontrol_new_t mixer_chorus_mode_control =
+static struct snd_kcontrol_new mixer_chorus_mode_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "Chorus Mode",
@@ -934,7 +934,7 @@ static snd_kcontrol_new_t mixer_chorus_mode_control =
        .private_value = 1,
 };
 
-static snd_kcontrol_new_t mixer_reverb_mode_control =
+static struct snd_kcontrol_new mixer_reverb_mode_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "Reverb Mode",
@@ -947,7 +947,7 @@ static snd_kcontrol_new_t mixer_reverb_mode_control =
 /*
  * FM OPL3 chorus/reverb depth
  */
-static int mixer_fm_depth_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int mixer_fm_depth_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 1;
@@ -956,17 +956,17 @@ static int mixer_fm_depth_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * u
        return 0;
 }
 
-static int mixer_fm_depth_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_fm_depth_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        
        ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->fm_chorus_depth : emu->fm_reverb_depth;
        return 0;
 }
 
-static int mixer_fm_depth_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int mixer_fm_depth_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       emu8000_t *emu = snd_kcontrol_chip(kcontrol);
+       struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned short val1;
@@ -986,7 +986,7 @@ static int mixer_fm_depth_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *
        return change;
 }
 
-static snd_kcontrol_new_t mixer_fm_chorus_depth_control =
+static struct snd_kcontrol_new mixer_fm_chorus_depth_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "FM Chorus Depth",
@@ -996,7 +996,7 @@ static snd_kcontrol_new_t mixer_fm_chorus_depth_control =
        .private_value = 1,
 };
 
-static snd_kcontrol_new_t mixer_fm_reverb_depth_control =
+static struct snd_kcontrol_new mixer_fm_reverb_depth_control =
 {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "FM Reverb Depth",
@@ -1007,7 +1007,7 @@ static snd_kcontrol_new_t mixer_fm_reverb_depth_control =
 };
 
 
-static snd_kcontrol_new_t *mixer_defs[EMU8000_NUM_CONTROLS] = {
+static struct snd_kcontrol_new *mixer_defs[EMU8000_NUM_CONTROLS] = {
        &mixer_bass_control,
        &mixer_treble_control,
        &mixer_chorus_mode_control,
@@ -1020,7 +1020,7 @@ static snd_kcontrol_new_t *mixer_defs[EMU8000_NUM_CONTROLS] = {
  * create and attach mixer elements for WaveTable treble/bass controls
  */
 static int __init
-snd_emu8000_create_mixer(snd_card_t *card, emu8000_t *emu)
+snd_emu8000_create_mixer(struct snd_card *card, struct snd_emu8000 *emu)
 {
        int i, err = 0;
 
@@ -1049,7 +1049,7 @@ __error:
 /*
  * free resources
  */
-static int snd_emu8000_free(emu8000_t *hw)
+static int snd_emu8000_free(struct snd_emu8000 *hw)
 {
        release_and_free_resource(hw->res_port1);
        release_and_free_resource(hw->res_port2);
@@ -1060,9 +1060,9 @@ static int snd_emu8000_free(emu8000_t *hw)
 
 /*
  */
-static int snd_emu8000_dev_free(snd_device_t *device)
+static int snd_emu8000_dev_free(struct snd_device *device)
 {
-       emu8000_t *hw = device->device_data;
+       struct snd_emu8000 *hw = device->device_data;
        return snd_emu8000_free(hw);
 }
 
@@ -1070,12 +1070,13 @@ static int snd_emu8000_dev_free(snd_device_t *device)
  * initialize and register emu8000 synth device.
  */
 int __init
-snd_emu8000_new(snd_card_t *card, int index, long port, int seq_ports, snd_seq_device_t **awe_ret)
+snd_emu8000_new(struct snd_card *card, int index, long port, int seq_ports,
+               struct snd_seq_device **awe_ret)
 {
-       snd_seq_device_t *awe;
-       emu8000_t *hw;
+       struct snd_seq_device *awe;
+       struct snd_emu8000 *hw;
        int err;
-       static snd_device_ops_t ops = {
+       static struct snd_device_ops ops = {
                .dev_free = snd_emu8000_dev_free,
        };
 
@@ -1127,9 +1128,9 @@ snd_emu8000_new(snd_card_t *card, int index, long port, int seq_ports, snd_seq_d
        }
 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
        if (snd_seq_device_new(card, index, SNDRV_SEQ_DEV_ID_EMU8000,
-                              sizeof(emu8000_t*), &awe) >= 0) {
+                              sizeof(struct snd_emu8000*), &awe) >= 0) {
                strcpy(awe->name, "EMU-8000");
-               *(emu8000_t**)SNDRV_SEQ_DEVICE_ARGPTR(awe) = hw;
+               *(struct snd_emu8000 **)SNDRV_SEQ_DEVICE_ARGPTR(awe) = hw;
        }
 #else
        awe = NULL;
index 1cc4101a17a4b77549d78b69c9bf5270ac34d1da..9a3c71cc2e07c69e832d04583ef1394a715a7a04 100644 (file)
 /*
  * prototypes
  */
-static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port);
-static int start_voice(snd_emux_voice_t *vp);
-static void trigger_voice(snd_emux_voice_t *vp);
-static void release_voice(snd_emux_voice_t *vp);
-static void update_voice(snd_emux_voice_t *vp, int update);
-static void reset_voice(snd_emux_t *emu, int ch);
-static void terminate_voice(snd_emux_voice_t *vp);
-static void sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset);
+static struct snd_emux_voice *get_voice(struct snd_emux *emu,
+                                       struct snd_emux_port *port);
+static int start_voice(struct snd_emux_voice *vp);
+static void trigger_voice(struct snd_emux_voice *vp);
+static void release_voice(struct snd_emux_voice *vp);
+static void update_voice(struct snd_emux_voice *vp, int update);
+static void reset_voice(struct snd_emux *emu, int ch);
+static void terminate_voice(struct snd_emux_voice *vp);
+static void sysex(struct snd_emux *emu, char *buf, int len, int parsed,
+                 struct snd_midi_channel_set *chset);
 #ifdef CONFIG_SND_SEQUENCER_OSS
-static int oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2);
+static int oss_ioctl(struct snd_emux *emu, int cmd, int p1, int p2);
 #endif
-static int load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len);
-
-static void set_pitch(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_volume(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_pan(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp);
-static void set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp);
-static void snd_emu8000_tweak_voice(emu8000_t *emu, int ch);
+static int load_fx(struct snd_emux *emu, int type, int mode,
+                  const void __user *buf, long len);
+
+static void set_pitch(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_volume(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_pan(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_fmmod(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_tremfreq(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_fm2frq2(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void set_filterQ(struct snd_emu8000 *hw, struct snd_emux_voice *vp);
+static void snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int ch);
 
 /*
  * Ensure a value is between two points
@@ -58,7 +61,7 @@ static void snd_emu8000_tweak_voice(emu8000_t *emu, int ch);
 /*
  * set up operators
  */
-static snd_emux_operators_t emu8000_ops = {
+static struct snd_emux_operators emu8000_ops = {
        .owner =        THIS_MODULE,
        .get_voice =    get_voice,
        .prepare =      start_voice,
@@ -78,7 +81,7 @@ static snd_emux_operators_t emu8000_ops = {
 };
 
 void
-snd_emu8000_ops_setup(emu8000_t *hw)
+snd_emu8000_ops_setup(struct snd_emu8000 *hw)
 {
        hw->emu->ops = emu8000_ops;
 }
@@ -89,10 +92,10 @@ snd_emu8000_ops_setup(emu8000_t *hw)
  * Terminate a voice
  */
 static void
-release_voice(snd_emux_voice_t *vp)
+release_voice(struct snd_emux_voice *vp)
 {
        int dcysusv;
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = vp->hw;
        dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
@@ -105,9 +108,9 @@ release_voice(snd_emux_voice_t *vp)
 /*
  */
 static void
-terminate_voice(snd_emux_voice_t *vp)
+terminate_voice(struct snd_emux_voice *vp)
 {
-       emu8000_t *hw; 
+       struct snd_emu8000 *hw; 
 
        hw = vp->hw;
        EMU8000_DCYSUSV_WRITE(hw, vp->ch, 0x807F);
@@ -117,9 +120,9 @@ terminate_voice(snd_emux_voice_t *vp)
 /*
  */
 static void
-update_voice(snd_emux_voice_t *vp, int update)
+update_voice(struct snd_emux_voice *vp, int update)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = vp->hw;
        if (update & SNDRV_EMUX_UPDATE_VOLUME)
@@ -149,12 +152,12 @@ update_voice(snd_emux_voice_t *vp, int update)
  * The channel index (vp->ch) must be initialized in this routine.
  * In Emu8k, it is identical with the array index.
  */
-static snd_emux_voice_t *
-get_voice(snd_emux_t *emu, snd_emux_port_t *port)
+static struct snd_emux_voice *
+get_voice(struct snd_emux *emu, struct snd_emux_port *port)
 {
        int  i;
-       snd_emux_voice_t *vp;
-       emu8000_t *hw;
+       struct snd_emux_voice *vp;
+       struct snd_emu8000 *hw;
 
        /* what we are looking for, in order of preference */
        enum {
@@ -227,13 +230,13 @@ get_voice(snd_emux_t *emu, snd_emux_port_t *port)
 /*
  */
 static int
-start_voice(snd_emux_voice_t *vp)
+start_voice(struct snd_emux_voice *vp)
 {
        unsigned int temp;
        int ch;
        int addr;
-       snd_midi_channel_t *chan;
-       emu8000_t *hw;
+       struct snd_midi_channel *chan;
+       struct snd_emu8000 *hw;
 
        hw = vp->hw;
        ch = vp->ch;
@@ -307,11 +310,11 @@ start_voice(snd_emux_voice_t *vp)
  * Start envelope
  */
 static void
-trigger_voice(snd_emux_voice_t *vp)
+trigger_voice(struct snd_emux_voice *vp)
 {
        int ch = vp->ch;
        unsigned int temp;
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = vp->hw;
 
@@ -329,9 +332,9 @@ trigger_voice(snd_emux_voice_t *vp)
  * reset voice parameters
  */
 static void
-reset_voice(snd_emux_t *emu, int ch)
+reset_voice(struct snd_emux *emu, int ch)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = emu->hw;
        EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F);
@@ -342,7 +345,7 @@ reset_voice(snd_emux_t *emu, int ch)
  * Set the pitch of a possibly playing note.
  */
 static void
-set_pitch(emu8000_t *hw, snd_emux_voice_t *vp)
+set_pitch(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        EMU8000_IP_WRITE(hw, vp->ch, vp->apitch);
 }
@@ -351,7 +354,7 @@ set_pitch(emu8000_t *hw, snd_emux_voice_t *vp)
  * Set the volume of a possibly already playing note
  */
 static void
-set_volume(emu8000_t *hw, snd_emux_voice_t *vp)
+set_volume(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        int  ifatn;
 
@@ -365,7 +368,7 @@ set_volume(emu8000_t *hw, snd_emux_voice_t *vp)
  * Set pan and loop start address.
  */
 static void
-set_pan(emu8000_t *hw, snd_emux_voice_t *vp)
+set_pan(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        unsigned int temp;
 
@@ -376,7 +379,7 @@ set_pan(emu8000_t *hw, snd_emux_voice_t *vp)
 #define MOD_SENSE 18
 
 static void
-set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp)
+set_fmmod(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        unsigned short fmmod;
        short pitch;
@@ -394,14 +397,14 @@ set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp)
 
 /* set tremolo (lfo1) volume & frequency */
 static void
-set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp)
+set_tremfreq(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        EMU8000_TREMFRQ_WRITE(hw, vp->ch, vp->reg.parm.tremfrq);
 }
 
 /* set lfo2 pitch & frequency */
 static void
-set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp)
+set_fm2frq2(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        unsigned short fm2frq2;
        short pitch;
@@ -419,7 +422,7 @@ set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp)
 
 /* set filterQ */
 static void
-set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp)
+set_filterQ(struct snd_emu8000 *hw, struct snd_emux_voice *vp)
 {
        unsigned int addr;
        addr = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff;
@@ -431,7 +434,7 @@ set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp)
  * set the envelope & LFO parameters to the default values
  */
 static void
-snd_emu8000_tweak_voice(emu8000_t *emu, int i)
+snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int i)
 {
        /* set all mod/vol envelope shape to minimum */
        EMU8000_ENVVOL_WRITE(emu, i, 0x8000);
@@ -453,9 +456,9 @@ snd_emu8000_tweak_voice(emu8000_t *emu, int i)
  * sysex callback
  */
 static void
-sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset)
+sysex(struct snd_emux *emu, char *buf, int len, int parsed, struct snd_midi_channel_set *chset)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = emu->hw;
 
@@ -478,9 +481,9 @@ sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *c
  * OSS ioctl callback
  */
 static int
-oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2)
+oss_ioctl(struct snd_emux *emu, int cmd, int p1, int p2)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        hw = emu->hw;
 
@@ -523,9 +526,9 @@ oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2)
  */
 
 static int
-load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len)
+load_fx(struct snd_emux *emu, int type, int mode, const void __user *buf, long len)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
        hw = emu->hw;
 
        /* skip header */
index ea4996a895fc5d3636de1a9fb55be2ccc197c55c..2ac77f10bb4e4e56b81b7f170eaa64d9aee972bf 100644 (file)
 #include <sound/emu8000_reg.h>
 
 /* emu8000_patch.c */
-int snd_emu8000_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr, const void __user *data, long count);
-int snd_emu8000_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr);
-void snd_emu8000_sample_reset(snd_emux_t *rec);
+int snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
+                          struct snd_util_memhdr *hdr,
+                          const void __user *data, long count);
+int snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp,
+                           struct snd_util_memhdr *hdr);
+void snd_emu8000_sample_reset(struct snd_emux *rec);
 
 /* emu8000_callback.c */
-void snd_emu8000_ops_setup(emu8000_t *emu);
+void snd_emu8000_ops_setup(struct snd_emu8000 *emu);
 
 /* emu8000_pcm.c */
-int snd_emu8000_pcm_new(snd_card_t *card, emu8000_t *emu, int index);
+int snd_emu8000_pcm_new(struct snd_card *card, struct snd_emu8000 *emu, int index);
 
 #endif /* __EMU8000_LOCAL_H */
index 2fea67e71c78294dc987a87a2e7f2f26f56469d6..80b1cf84a1ae28269b07d73db15fb3cf926815d5 100644 (file)
@@ -32,7 +32,7 @@ MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes sl
  * Open up channels.
  */
 static int
-snd_emu8000_open_dma(emu8000_t *emu, int write)
+snd_emu8000_open_dma(struct snd_emu8000 *emu, int write)
 {
        int i;
 
@@ -59,7 +59,7 @@ snd_emu8000_open_dma(emu8000_t *emu, int write)
  * Close all dram channels.
  */
 static void
-snd_emu8000_close_dma(emu8000_t *emu)
+snd_emu8000_close_dma(struct snd_emu8000 *emu)
 {
        int i;
 
@@ -106,7 +106,7 @@ read_word(const void __user *buf, int offset, int mode)
 /*
  */
 static void
-snd_emu8000_write_wait(emu8000_t *emu)
+snd_emu8000_write_wait(struct snd_emu8000 *emu)
 {
        while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
                schedule_timeout_interruptible(1);
@@ -128,7 +128,7 @@ snd_emu8000_write_wait(emu8000_t *emu)
  * working.
  */
 static inline void
-write_word(emu8000_t *emu, int *offset, unsigned short data)
+write_word(struct snd_emu8000 *emu, int *offset, unsigned short data)
 {
        if (emu8000_reset_addr) {
                if (emu8000_reset_addr > 1)
@@ -144,15 +144,16 @@ write_word(emu8000_t *emu, int *offset, unsigned short data)
  * the generic soundfont routines as a callback.
  */
 int
-snd_emu8000_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp,
-                      snd_util_memhdr_t *hdr, const void __user *data, long count)
+snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
+                      struct snd_util_memhdr *hdr,
+                      const void __user *data, long count)
 {
        int  i;
        int  rc;
        int  offset;
        int  truesize;
        int  dram_offset, dram_start;
-       emu8000_t *emu;
+       struct snd_emu8000 *emu;
 
        emu = rec->hw;
        snd_assert(sp != NULL, return -EINVAL);
@@ -282,7 +283,8 @@ snd_emu8000_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp,
  * free a sample block
  */
 int
-snd_emu8000_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr)
+snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp,
+                       struct snd_util_memhdr *hdr)
 {
        if (sp->block) {
                snd_util_mem_free(hdr, sp->block);
@@ -296,7 +298,7 @@ snd_emu8000_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t
  * sample_reset callback - terminate voices
  */
 void
-snd_emu8000_sample_reset(snd_emux_t *rec)
+snd_emu8000_sample_reset(struct snd_emux *rec)
 {
        snd_emux_terminate_all(rec);
 }
index b323beeeda156b8e9448fedcc161d5348c5b56ac..91dc3d83e2cf8e9d1f01a4a92c20ad1865ccc2c7 100644 (file)
  */
 
 
-typedef struct snd_emu8k_pcm emu8k_pcm_t;
-
 struct snd_emu8k_pcm {
-       emu8000_t *emu;
-       snd_pcm_substream_t *substream;
+       struct snd_emu8000 *emu;
+       struct snd_pcm_substream *substream;
 
        unsigned int allocated_bytes;
-       snd_util_memblk_t *block;
+       struct snd_util_memblk *block;
        unsigned int offset;
        unsigned int buf_size;
        unsigned int period_size;
@@ -77,7 +75,7 @@ struct snd_emu8k_pcm {
  * open up channels for the simultaneous data transfer and playback
  */
 static int
-emu8k_open_dram_for_pcm(emu8000_t *emu, int channels)
+emu8k_open_dram_for_pcm(struct snd_emu8000 *emu, int channels)
 {
        int i;
 
@@ -113,7 +111,7 @@ emu8k_open_dram_for_pcm(emu8000_t *emu, int channels)
 /*
  */
 static void
-snd_emu8000_write_wait(emu8000_t *emu, int can_schedule)
+snd_emu8000_write_wait(struct snd_emu8000 *emu, int can_schedule)
 {
        while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
                if (can_schedule) {
@@ -128,7 +126,7 @@ snd_emu8000_write_wait(emu8000_t *emu, int can_schedule)
  * close all channels
  */
 static void
-emu8k_close_dram(emu8000_t *emu)
+emu8k_close_dram(struct snd_emu8000 *emu)
 {
        int i;
 
@@ -156,7 +154,7 @@ static int calc_rate_offset(int hz)
 /*
  */
 
-static snd_pcm_hardware_t emu8k_pcm_hw = {
+static struct snd_pcm_hardware emu8k_pcm_hw = {
 #ifdef USE_NONINTERLEAVE
        .info =                 SNDRV_PCM_INFO_NONINTERLEAVED,
 #else
@@ -180,7 +178,7 @@ static snd_pcm_hardware_t emu8k_pcm_hw = {
 /*
  * get the current position at the given channel from CCCA register
  */
-static inline int emu8k_get_curpos(emu8k_pcm_t *rec, int ch)
+static inline int emu8k_get_curpos(struct snd_emu8k_pcm *rec, int ch)
 {
        int val = EMU8000_CCCA_READ(rec->emu, ch) & 0xfffffff;
        val -= rec->loop_start[ch] - 1;
@@ -194,7 +192,7 @@ static inline int emu8k_get_curpos(emu8k_pcm_t *rec, int ch)
  */
 static void emu8k_pcm_timer_func(unsigned long data)
 {
-       emu8k_pcm_t *rec = (emu8k_pcm_t *)data;
+       struct snd_emu8k_pcm *rec = (struct snd_emu8k_pcm *)data;
        int ptr, delta;
 
        spin_lock(&rec->timer_lock);
@@ -226,11 +224,11 @@ static void emu8k_pcm_timer_func(unsigned long data)
  * open pcm
  * creating an instance here
  */
-static int emu8k_pcm_open(snd_pcm_substream_t *subs)
+static int emu8k_pcm_open(struct snd_pcm_substream *subs)
 {
-       emu8000_t *emu = snd_pcm_substream_chip(subs);
-       emu8k_pcm_t *rec;
-       snd_pcm_runtime_t *runtime = subs->runtime;
+       struct snd_emu8000 *emu = snd_pcm_substream_chip(subs);
+       struct snd_emu8k_pcm *rec;
+       struct snd_pcm_runtime *runtime = subs->runtime;
 
        rec = kzalloc(sizeof(*rec), GFP_KERNEL);
        if (! rec)
@@ -256,9 +254,9 @@ static int emu8k_pcm_open(snd_pcm_substream_t *subs)
        return 0;
 }
 
-static int emu8k_pcm_close(snd_pcm_substream_t *subs)
+static int emu8k_pcm_close(struct snd_pcm_substream *subs)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
        kfree(rec);
        subs->runtime->private_data = NULL;
        return 0;
@@ -281,9 +279,9 @@ static int calc_pitch_target(int pitch)
 /*
  * set up the voice
  */
-static void setup_voice(emu8k_pcm_t *rec, int ch)
+static void setup_voice(struct snd_emu8k_pcm *rec, int ch)
 {
-       emu8000_t *hw = rec->emu;
+       struct snd_emu8000 *hw = rec->emu;
        unsigned int temp;
 
        /* channel to be silent and idle */
@@ -334,10 +332,10 @@ static void setup_voice(emu8k_pcm_t *rec, int ch)
 /*
  * trigger the voice
  */
-static void start_voice(emu8k_pcm_t *rec, int ch)
+static void start_voice(struct snd_emu8k_pcm *rec, int ch)
 {
        unsigned long flags;
-       emu8000_t *hw = rec->emu;
+       struct snd_emu8000 *hw = rec->emu;
        unsigned int temp, aux;
        int pt = calc_pitch_target(rec->pitch);
 
@@ -370,10 +368,10 @@ static void start_voice(emu8k_pcm_t *rec, int ch)
 /*
  * stop the voice immediately
  */
-static void stop_voice(emu8k_pcm_t *rec, int ch)
+static void stop_voice(struct snd_emu8k_pcm *rec, int ch)
 {
        unsigned long flags;
-       emu8000_t *hw = rec->emu;
+       struct snd_emu8000 *hw = rec->emu;
 
        EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F);
 
@@ -386,9 +384,9 @@ static void stop_voice(emu8k_pcm_t *rec, int ch)
        spin_unlock_irqrestore(&rec->timer_lock, flags);
 }
 
-static int emu8k_pcm_trigger(snd_pcm_substream_t *subs, int cmd)
+static int emu8k_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
        int ch;
 
        switch (cmd) {
@@ -428,7 +426,7 @@ do { \
 
 #ifdef USE_NONINTERLEAVE
 /* copy one channel block */
-static int emu8k_transfer_block(emu8000_t *emu, int offset, unsigned short *buf, int count)
+static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned short *buf, int count)
 {
        EMU8000_SMALW_WRITE(emu, offset);
        while (count > 0) {
@@ -442,14 +440,14 @@ static int emu8k_transfer_block(emu8000_t *emu, int offset, unsigned short *buf,
        return 0;
 }
 
-static int emu8k_pcm_copy(snd_pcm_substream_t *subs,
+static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
                          int voice,
                          snd_pcm_uframes_t pos,
                          void *src,
                          snd_pcm_uframes_t count)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
-       emu8000_t *emu = rec->emu;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
+       struct snd_emu8000 *emu = rec->emu;
 
        snd_emu8000_write_wait(emu, 1);
        if (voice == -1) {
@@ -469,7 +467,7 @@ static int emu8k_pcm_copy(snd_pcm_substream_t *subs,
 }
 
 /* make a channel block silence */
-static int emu8k_silence_block(emu8000_t *emu, int offset, int count)
+static int emu8k_silence_block(struct snd_emu8000 *emu, int offset, int count)
 {
        EMU8000_SMALW_WRITE(emu, offset);
        while (count > 0) {
@@ -480,13 +478,13 @@ static int emu8k_silence_block(emu8000_t *emu, int offset, int count)
        return 0;
 }
 
-static int emu8k_pcm_silence(snd_pcm_substream_t *subs,
+static int emu8k_pcm_silence(struct snd_pcm_substream *subs,
                             int voice,
                             snd_pcm_uframes_t pos,
                             snd_pcm_uframes_t count)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
-       emu8000_t *emu = rec->emu;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
+       struct snd_emu8000 *emu = rec->emu;
 
        snd_emu8000_write_wait(emu, 1);
        if (voice == -1 && rec->voices == 1)
@@ -508,14 +506,14 @@ static int emu8k_pcm_silence(snd_pcm_substream_t *subs,
  * copy the interleaved data can be done easily by using
  * DMA "left" and "right" channels on emu8k engine.
  */
-static int emu8k_pcm_copy(snd_pcm_substream_t *subs,
+static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
                          int voice,
                          snd_pcm_uframes_t pos,
                          void __user *src,
                          snd_pcm_uframes_t count)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
-       emu8000_t *emu = rec->emu;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
+       struct snd_emu8000 *emu = rec->emu;
        unsigned short __user *buf = src;
 
        snd_emu8000_write_wait(emu, 1);
@@ -539,13 +537,13 @@ static int emu8k_pcm_copy(snd_pcm_substream_t *subs,
        return 0;
 }
 
-static int emu8k_pcm_silence(snd_pcm_substream_t *subs,
+static int emu8k_pcm_silence(struct snd_pcm_substream *subs,
                             int voice,
                             snd_pcm_uframes_t pos,
                             snd_pcm_uframes_t count)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
-       emu8000_t *emu = rec->emu;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
+       struct snd_emu8000 *emu = rec->emu;
 
        snd_emu8000_write_wait(emu, 1);
        EMU8000_SMALW_WRITE(emu, rec->loop_start[0] + pos);
@@ -567,10 +565,10 @@ static int emu8k_pcm_silence(snd_pcm_substream_t *subs,
 /*
  * allocate a memory block
  */
-static int emu8k_pcm_hw_params(snd_pcm_substream_t *subs,
-                              snd_pcm_hw_params_t *hw_params)
+static int emu8k_pcm_hw_params(struct snd_pcm_substream *subs,
+                              struct snd_pcm_hw_params *hw_params)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
 
        if (rec->block) {
                /* reallocation - release the old block */
@@ -592,9 +590,9 @@ static int emu8k_pcm_hw_params(snd_pcm_substream_t *subs,
 /*
  * free the memory block
  */
-static int emu8k_pcm_hw_free(snd_pcm_substream_t *subs)
+static int emu8k_pcm_hw_free(struct snd_pcm_substream *subs)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
 
        if (rec->block) {
                int ch;
@@ -610,9 +608,9 @@ static int emu8k_pcm_hw_free(snd_pcm_substream_t *subs)
 
 /*
  */
-static int emu8k_pcm_prepare(snd_pcm_substream_t *subs)
+static int emu8k_pcm_prepare(struct snd_pcm_substream *subs)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
 
        rec->pitch = 0xe000 + calc_rate_offset(subs->runtime->rate);
        rec->last_ptr = 0;
@@ -656,16 +654,16 @@ static int emu8k_pcm_prepare(snd_pcm_substream_t *subs)
        return 0;
 }
 
-static snd_pcm_uframes_t emu8k_pcm_pointer(snd_pcm_substream_t *subs)
+static snd_pcm_uframes_t emu8k_pcm_pointer(struct snd_pcm_substream *subs)
 {
-       emu8k_pcm_t *rec = subs->runtime->private_data;
+       struct snd_emu8k_pcm *rec = subs->runtime->private_data;
        if (rec->running)
                return emu8k_get_curpos(rec, 0);
        return 0;
 }
 
 
-static snd_pcm_ops_t emu8k_pcm_ops = {
+static struct snd_pcm_ops emu8k_pcm_ops = {
        .open =         emu8k_pcm_open,
        .close =        emu8k_pcm_close,
        .ioctl =        snd_pcm_lib_ioctl,
@@ -679,15 +677,15 @@ static snd_pcm_ops_t emu8k_pcm_ops = {
 };
 
 
-static void snd_emu8000_pcm_free(snd_pcm_t *pcm)
+static void snd_emu8000_pcm_free(struct snd_pcm *pcm)
 {
-       emu8000_t *emu = pcm->private_data;
+       struct snd_emu8000 *emu = pcm->private_data;
        emu->pcm = NULL;
 }
 
-int snd_emu8000_pcm_new(snd_card_t *card, emu8000_t *emu, int index)
+int snd_emu8000_pcm_new(struct snd_card *card, struct snd_emu8000 *emu, int index)
 {
-       snd_pcm_t *pcm;
+       struct snd_pcm *pcm;
        int err;
 
        if ((err = snd_pcm_new(card, "Emu8000 PCM", index, 1, 0, &pcm)) < 0)
index f68e217416a6f8ad8a8228739f5a129e910e86f9..3d72742b342fad200f351199e5806adb2f4f4dda 100644 (file)
@@ -33,12 +33,12 @@ MODULE_LICENSE("GPL");
 /*
  * create a new hardware dependent device for Emu8000
  */
-static int snd_emu8000_new_device(snd_seq_device_t *dev)
+static int snd_emu8000_new_device(struct snd_seq_device *dev)
 {
-       emu8000_t *hw;
-       snd_emux_t *emu;
+       struct snd_emu8000 *hw;
+       struct snd_emux *emu;
 
-       hw = *(emu8000_t**)SNDRV_SEQ_DEVICE_ARGPTR(dev);
+       hw = *(struct snd_emu8000**)SNDRV_SEQ_DEVICE_ARGPTR(dev);
        if (hw == NULL)
                return -EINVAL;
 
@@ -92,9 +92,9 @@ static int snd_emu8000_new_device(snd_seq_device_t *dev)
 /*
  * free all resources
  */
-static int snd_emu8000_delete_device(snd_seq_device_t *dev)
+static int snd_emu8000_delete_device(struct snd_seq_device *dev)
 {
-       emu8000_t *hw;
+       struct snd_emu8000 *hw;
 
        if (dev->driver_data == NULL)
                return 0; /* no synth was allocated actually */
@@ -118,11 +118,12 @@ static int snd_emu8000_delete_device(snd_seq_device_t *dev)
 static int __init alsa_emu8000_init(void)
 {
        
-       static snd_seq_dev_ops_t ops = {
+       static struct snd_seq_dev_ops ops = {
                snd_emu8000_new_device,
                snd_emu8000_delete_device,
        };
-       return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU8000, &ops, sizeof(emu8000_t*));
+       return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU8000, &ops,
+                                             sizeof(struct snd_emu8000*));
 }
 
 static void __exit alsa_emu8000_exit(void)
index c859917c14dba2c089555c4ad41c1fe94181d73c..f7d1afe83dfeed340395c711056ce03dcb2581f8 100644 (file)
@@ -72,7 +72,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_es968_pnpids);
 static irqreturn_t snd_card_es968_interrupt(int irq, void *dev_id,
                                            struct pt_regs *regs)
 {
-       sb_t *chip = dev_id;
+       struct snd_sb *chip = dev_id;
 
        if (chip->open & SB_OPEN_PCM) {
                return snd_sb8dsp_interrupt(chip);
@@ -128,8 +128,8 @@ static int __init snd_card_es968_probe(int dev,
                                        const struct pnp_card_device_id *pid)
 {
        int error;
-       sb_t *chip;
-       snd_card_t *card;
+       struct snd_sb *chip;
+       struct snd_card *card;
        struct snd_card_es968 *acard;
 
        if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
@@ -200,7 +200,7 @@ static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card,
 
 static void __devexit snd_es968_pnp_remove(struct pnp_card_link * pcard)
 {
-       snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+       struct snd_card *card = (struct snd_card *) pnp_get_card_drvdata(pcard);
 
        snd_card_disconnect(card);
        snd_card_free_in_thread(card);
index c2fa451bc8f05c293531e93cc23fdd7598957552..96e4013334373dc903df2bb1461157a81e10d341 100644 (file)
@@ -138,7 +138,7 @@ struct snd_card_sb16 {
 #endif
 };
 
-static snd_card_t *snd_sb16_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+static struct snd_card *snd_sb16_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
 
 #ifdef CONFIG_PNP
 
@@ -339,7 +339,7 @@ __wt_error:
 
 #endif /* CONFIG_PNP */
 
-static void snd_sb16_free(snd_card_t *card)
+static void snd_sb16_free(struct snd_card *card)
 {
        struct snd_card_sb16 *acard = (struct snd_card_sb16 *)card->private_data;
         
@@ -362,13 +362,13 @@ static int __init snd_sb16_probe(int dev,
        static int possible_dmas8[] = {1, 3, 0, -1};
        static int possible_dmas16[] = {5, 6, 7, -1};
        int xirq, xdma8, xdma16;
-       sb_t *chip;
-       snd_card_t *card;
+       struct snd_sb *chip;
+       struct snd_card *card;
        struct snd_card_sb16 *acard;
-       opl3_t *opl3;
-       snd_hwdep_t *synth = NULL;
+       struct snd_opl3 *opl3;
+       struct snd_hwdep *synth = NULL;
 #ifdef CONFIG_SND_SB16_CSP
-       snd_hwdep_t *xcsp = NULL;
+       struct snd_hwdep *xcsp = NULL;
 #endif
        unsigned long flags;
        int err;
@@ -583,7 +583,7 @@ static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *card,
 
 static void __devexit snd_sb16_pnp_remove(struct pnp_card_link * pcard)
 {
-       snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+       struct snd_card *card = (struct snd_card *) pnp_get_card_drvdata(pcard);
 
        snd_card_disconnect(card);
        snd_card_free_in_thread(card);
index 7192d4c758e6026015c42d58aa9c5517c1361f2f..9c2b5efbacbf518035e55d2f6895b280cc101766 100644 (file)
@@ -72,46 +72,47 @@ struct desc_header {
 /*
  * prototypes
  */
-static void snd_sb_csp_free(snd_hwdep_t *hw);
-static int snd_sb_csp_open(snd_hwdep_t * hw, struct file *file);
-static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg);
-static int snd_sb_csp_release(snd_hwdep_t * hw, struct file *file);
-
-static int csp_detect(sb_t *chip, int *version);
-static int set_codec_parameter(sb_t *chip, unsigned char par, unsigned char val);
-static int set_register(sb_t *chip, unsigned char reg, unsigned char val);
-static int read_register(sb_t *chip, unsigned char reg);
-static int set_mode_register(sb_t *chip, unsigned char mode);
-static int get_version(sb_t *chip);
-
-static int snd_sb_csp_riff_load(snd_sb_csp_t * p, snd_sb_csp_microcode_t __user * code);
-static int snd_sb_csp_unload(snd_sb_csp_t * p);
-static int snd_sb_csp_load_user(snd_sb_csp_t * p, const unsigned char __user *buf, int size, int load_flags);
-static int snd_sb_csp_autoload(snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode);
-static int snd_sb_csp_check_version(snd_sb_csp_t * p);
-
-static int snd_sb_csp_use(snd_sb_csp_t * p);
-static int snd_sb_csp_unuse(snd_sb_csp_t * p);
-static int snd_sb_csp_start(snd_sb_csp_t * p, int sample_width, int channels);
-static int snd_sb_csp_stop(snd_sb_csp_t * p);
-static int snd_sb_csp_pause(snd_sb_csp_t * p);
-static int snd_sb_csp_restart(snd_sb_csp_t * p);
-
-static int snd_sb_qsound_build(snd_sb_csp_t * p);
-static void snd_sb_qsound_destroy(snd_sb_csp_t * p);
-static int snd_sb_csp_qsound_transfer(snd_sb_csp_t * p);
-
-static int init_proc_entry(snd_sb_csp_t * p, int device);
-static void info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer);
+static void snd_sb_csp_free(struct snd_hwdep *hw);
+static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file);
+static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg);
+static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file);
+
+static int csp_detect(struct snd_sb *chip, int *version);
+static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val);
+static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val);
+static int read_register(struct snd_sb *chip, unsigned char reg);
+static int set_mode_register(struct snd_sb *chip, unsigned char mode);
+static int get_version(struct snd_sb *chip);
+
+static int snd_sb_csp_riff_load(struct snd_sb_csp * p,
+                               struct snd_sb_csp_microcode __user * code);
+static int snd_sb_csp_unload(struct snd_sb_csp * p);
+static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags);
+static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode);
+static int snd_sb_csp_check_version(struct snd_sb_csp * p);
+
+static int snd_sb_csp_use(struct snd_sb_csp * p);
+static int snd_sb_csp_unuse(struct snd_sb_csp * p);
+static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channels);
+static int snd_sb_csp_stop(struct snd_sb_csp * p);
+static int snd_sb_csp_pause(struct snd_sb_csp * p);
+static int snd_sb_csp_restart(struct snd_sb_csp * p);
+
+static int snd_sb_qsound_build(struct snd_sb_csp * p);
+static void snd_sb_qsound_destroy(struct snd_sb_csp * p);
+static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p);
+
+static int init_proc_entry(struct snd_sb_csp * p, int device);
+static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer);
 
 /*
  * Detect CSP chip and create a new instance
  */
-int snd_sb_csp_new(sb_t *chip, int device, snd_hwdep_t ** rhwdep)
+int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep)
 {
-       snd_sb_csp_t *p;
+       struct snd_sb_csp *p;
        int version, err;
-       snd_hwdep_t *hw;
+       struct snd_hwdep *hw;
 
        if (rhwdep)
                *rhwdep = NULL;
@@ -158,9 +159,9 @@ int snd_sb_csp_new(sb_t *chip, int device, snd_hwdep_t ** rhwdep)
 /*
  * free_private for hwdep instance
  */
-static void snd_sb_csp_free(snd_hwdep_t *hwdep)
+static void snd_sb_csp_free(struct snd_hwdep *hwdep)
 {
-       snd_sb_csp_t *p = hwdep->private_data;
+       struct snd_sb_csp *p = hwdep->private_data;
        if (p) {
                if (p->running & SNDRV_SB_CSP_ST_RUNNING)
                        snd_sb_csp_stop(p);
@@ -173,20 +174,20 @@ static void snd_sb_csp_free(snd_hwdep_t *hwdep)
 /*
  * open the device exclusively
  */
-static int snd_sb_csp_open(snd_hwdep_t * hw, struct file *file)
+static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file)
 {
-       snd_sb_csp_t *p = hw->private_data;
+       struct snd_sb_csp *p = hw->private_data;
        return (snd_sb_csp_use(p));
 }
 
 /*
  * ioctl for hwdep device:
  */
-static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg)
+static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg)
 {
-       snd_sb_csp_t *p = hw->private_data;
-       snd_sb_csp_info_t info;
-       snd_sb_csp_start_t start_info;
+       struct snd_sb_csp *p = hw->private_data;
+       struct snd_sb_csp_info info;
+       struct snd_sb_csp_start start_info;
        int err;
 
        snd_assert(p != NULL, return -EINVAL);
@@ -217,7 +218,7 @@ static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cm
                /* load CSP microcode */
        case SNDRV_SB_CSP_IOCTL_LOAD_CODE:
                err = (p->running & SNDRV_SB_CSP_ST_RUNNING ?
-                      -EBUSY : snd_sb_csp_riff_load(p, (snd_sb_csp_microcode_t __user *) arg));
+                      -EBUSY : snd_sb_csp_riff_load(p, (struct snd_sb_csp_microcode __user *) arg));
                break;
        case SNDRV_SB_CSP_IOCTL_UNLOAD_CODE:
                err = (p->running & SNDRV_SB_CSP_ST_RUNNING ?
@@ -251,9 +252,9 @@ static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cm
 /*
  * close the device
  */
-static int snd_sb_csp_release(snd_hwdep_t * hw, struct file *file)
+static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file)
 {
-       snd_sb_csp_t *p = hw->private_data;
+       struct snd_sb_csp *p = hw->private_data;
        return (snd_sb_csp_unuse(p));
 }
 
@@ -262,7 +263,7 @@ static int snd_sb_csp_release(snd_hwdep_t * hw, struct file *file)
 /*
  * acquire device
  */
-static int snd_sb_csp_use(snd_sb_csp_t * p)
+static int snd_sb_csp_use(struct snd_sb_csp * p)
 {
        down(&p->access_mutex);
        if (p->used) {
@@ -279,7 +280,7 @@ static int snd_sb_csp_use(snd_sb_csp_t * p)
 /*
  * release device
  */
-static int snd_sb_csp_unuse(snd_sb_csp_t * p)
+static int snd_sb_csp_unuse(struct snd_sb_csp * p)
 {
        down(&p->access_mutex);
        p->used--;
@@ -292,9 +293,10 @@ static int snd_sb_csp_unuse(snd_sb_csp_t * p)
  * load microcode via ioctl: 
  * code is user-space pointer
  */
-static int snd_sb_csp_riff_load(snd_sb_csp_t * p, snd_sb_csp_microcode_t __user * mcode)
+static int snd_sb_csp_riff_load(struct snd_sb_csp * p,
+                               struct snd_sb_csp_microcode __user * mcode)
 {
-       snd_sb_csp_mc_header_t info;
+       struct snd_sb_csp_mc_header info;
 
        unsigned char __user *data_ptr;
        unsigned char __user *data_end;
@@ -449,7 +451,7 @@ static int snd_sb_csp_riff_load(snd_sb_csp_t * p, snd_sb_csp_microcode_t __user
 /*
  * unload CSP microcode
  */
-static int snd_sb_csp_unload(snd_sb_csp_t * p)
+static int snd_sb_csp_unload(struct snd_sb_csp * p)
 {
        if (p->running & SNDRV_SB_CSP_ST_RUNNING)
                return -EBUSY;
@@ -472,7 +474,7 @@ static int snd_sb_csp_unload(snd_sb_csp_t * p)
 /*
  * send command sequence to DSP
  */
-static inline int command_seq(sb_t *chip, const unsigned char *seq, int size)
+static inline int command_seq(struct snd_sb *chip, const unsigned char *seq, int size)
 {
        int i;
        for (i = 0; i < size; i++) {
@@ -485,7 +487,7 @@ static inline int command_seq(sb_t *chip, const unsigned char *seq, int size)
 /*
  * set CSP codec parameter
  */
-static int set_codec_parameter(sb_t *chip, unsigned char par, unsigned char val)
+static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val)
 {
        unsigned char dsp_cmd[3];
 
@@ -502,7 +504,7 @@ static int set_codec_parameter(sb_t *chip, unsigned char par, unsigned char val)
 /*
  * set CSP register
  */
-static int set_register(sb_t *chip, unsigned char reg, unsigned char val)
+static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val)
 {
        unsigned char dsp_cmd[3];
 
@@ -516,7 +518,7 @@ static int set_register(sb_t *chip, unsigned char reg, unsigned char val)
  * read CSP register
  * return < 0 -> error
  */
-static int read_register(sb_t *chip, unsigned char reg)
+static int read_register(struct snd_sb *chip, unsigned char reg)
 {
        unsigned char dsp_cmd[2];
 
@@ -529,7 +531,7 @@ static int read_register(sb_t *chip, unsigned char reg)
 /*
  * set CSP mode register
  */
-static int set_mode_register(sb_t *chip, unsigned char mode)
+static int set_mode_register(struct snd_sb *chip, unsigned char mode)
 {
        unsigned char dsp_cmd[2];
 
@@ -542,7 +544,7 @@ static int set_mode_register(sb_t *chip, unsigned char mode)
  * Detect CSP
  * return 0 if CSP exists.
  */
-static int csp_detect(sb_t *chip, int *version)
+static int csp_detect(struct snd_sb *chip, int *version)
 {
        unsigned char csp_test1, csp_test2;
        unsigned long flags;
@@ -579,7 +581,7 @@ static int csp_detect(sb_t *chip, int *version)
 /*
  * get CSP version number
  */
-static int get_version(sb_t *chip)
+static int get_version(struct snd_sb *chip)
 {
        unsigned char dsp_cmd[2];
 
@@ -593,7 +595,7 @@ static int get_version(sb_t *chip)
 /*
  * check if the CSP version is valid
  */
-static int snd_sb_csp_check_version(snd_sb_csp_t * p)
+static int snd_sb_csp_check_version(struct snd_sb_csp * p)
 {
        if (p->version < 0x10 || p->version > 0x1f) {
                snd_printd("%s: Invalid CSP version: 0x%x\n", __FUNCTION__, p->version);
@@ -605,7 +607,7 @@ static int snd_sb_csp_check_version(snd_sb_csp_t * p)
 /*
  * download microcode to CSP (microcode should have one "main" block).
  */
-static int snd_sb_csp_load(snd_sb_csp_t * p, const unsigned char *buf, int size, int load_flags)
+static int snd_sb_csp_load(struct snd_sb_csp * p, const unsigned char *buf, int size, int load_flags)
 {
        int status, i;
        int err;
@@ -671,7 +673,7 @@ static int snd_sb_csp_load(snd_sb_csp_t * p, const unsigned char *buf, int size,
        return result;
 }
  
-static int snd_sb_csp_load_user(snd_sb_csp_t * p, const unsigned char __user *buf, int size, int load_flags)
+static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags)
 {
        int err = -ENOMEM;
        unsigned char *kbuf = kmalloc(size, GFP_KERNEL);
@@ -691,7 +693,7 @@ static int snd_sb_csp_load_user(snd_sb_csp_t * p, const unsigned char __user *bu
  * autoload hardware codec if necessary
  * return 0 if CSP is loaded and ready to run (p->running != 0)
  */
-static int snd_sb_csp_autoload(snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode)
+static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode)
 {
        unsigned long flags;
        int err = 0;
@@ -763,7 +765,7 @@ static int snd_sb_csp_autoload(snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode
 /*
  * start CSP
  */
-static int snd_sb_csp_start(snd_sb_csp_t * p, int sample_width, int channels)
+static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channels)
 {
        unsigned char s_type;   /* sample type */
        unsigned char mixL, mixR;
@@ -842,7 +844,7 @@ static int snd_sb_csp_start(snd_sb_csp_t * p, int sample_width, int channels)
 /*
  * stop CSP
  */
-static int snd_sb_csp_stop(snd_sb_csp_t * p)
+static int snd_sb_csp_stop(struct snd_sb_csp * p)
 {
        int result;
        unsigned char mixL, mixR;
@@ -883,7 +885,7 @@ static int snd_sb_csp_stop(snd_sb_csp_t * p)
 /*
  * pause CSP codec and hold DMA transfer
  */
-static int snd_sb_csp_pause(snd_sb_csp_t * p)
+static int snd_sb_csp_pause(struct snd_sb_csp * p)
 {
        int result;
        unsigned long flags;
@@ -903,7 +905,7 @@ static int snd_sb_csp_pause(snd_sb_csp_t * p)
 /*
  * restart CSP codec and resume DMA transfer
  */
-static int snd_sb_csp_restart(snd_sb_csp_t * p)
+static int snd_sb_csp_restart(struct snd_sb_csp * p)
 {
        int result;
        unsigned long flags;
@@ -926,7 +928,7 @@ static int snd_sb_csp_restart(snd_sb_csp_t * p)
  * QSound mixer control for PCM
  */
 
-static int snd_sb_qsound_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sb_qsound_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        uinfo->count = 1;
@@ -935,17 +937,17 @@ static int snd_sb_qsound_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info
        return 0;
 }
 
-static int snd_sb_qsound_switch_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb_qsound_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol);
+       struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol);
        
        ucontrol->value.integer.value[0] = p->q_enabled ? 1 : 0;
        return 0;
 }
 
-static int snd_sb_qsound_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb_qsound_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol);
+       struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned char nval;
@@ -958,7 +960,7 @@ static int snd_sb_qsound_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_valu
        return change;
 }
 
-static int snd_sb_qsound_space_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sb_qsound_space_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 2;
@@ -967,9 +969,9 @@ static int snd_sb_qsound_space_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_
        return 0;
 }
 
-static int snd_sb_qsound_space_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb_qsound_space_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol);
+       struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        
        spin_lock_irqsave(&p->q_lock, flags);
@@ -979,9 +981,9 @@ static int snd_sb_qsound_space_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value
        return 0;
 }
 
-static int snd_sb_qsound_space_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb_qsound_space_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol);
+       struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned char nval1, nval2;
@@ -1001,7 +1003,7 @@ static int snd_sb_qsound_space_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value
        return change;
 }
 
-static snd_kcontrol_new_t snd_sb_qsound_switch = {
+static struct snd_kcontrol_new snd_sb_qsound_switch = {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "3D Control - Switch",
        .info = snd_sb_qsound_switch_info,
@@ -1009,7 +1011,7 @@ static snd_kcontrol_new_t snd_sb_qsound_switch = {
        .put = snd_sb_qsound_switch_put
 };
 
-static snd_kcontrol_new_t snd_sb_qsound_space = {
+static struct snd_kcontrol_new snd_sb_qsound_space = {
        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
        .name = "3D Control - Space",
        .info = snd_sb_qsound_space_info,
@@ -1017,9 +1019,9 @@ static snd_kcontrol_new_t snd_sb_qsound_space = {
        .put = snd_sb_qsound_space_put
 };
 
-static int snd_sb_qsound_build(snd_sb_csp_t * p)
+static int snd_sb_qsound_build(struct snd_sb_csp * p)
 {
-       snd_card_t * card;
+       struct snd_card *card;
        int err;
 
        snd_assert(p != NULL, return -EINVAL);
@@ -1042,9 +1044,9 @@ static int snd_sb_qsound_build(snd_sb_csp_t * p)
        return err;
 }
 
-static void snd_sb_qsound_destroy(snd_sb_csp_t * p)
+static void snd_sb_qsound_destroy(struct snd_sb_csp * p)
 {
-       snd_card_t * card;
+       struct snd_card *card;
        unsigned long flags;
 
        snd_assert(p != NULL, return);
@@ -1068,7 +1070,7 @@ static void snd_sb_qsound_destroy(snd_sb_csp_t * p)
  * Transfer qsound parameters to CSP,
  * function should be called from interrupt routine
  */
-static int snd_sb_csp_qsound_transfer(snd_sb_csp_t * p)
+static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p)
 {
        int err = -ENXIO;
 
@@ -1093,19 +1095,19 @@ static int snd_sb_csp_qsound_transfer(snd_sb_csp_t * p)
 /*
  * proc interface
  */
-static int init_proc_entry(snd_sb_csp_t * p, int device)
+static int init_proc_entry(struct snd_sb_csp * p, int device)
 {
        char name[16];
-       snd_info_entry_t *entry;
+       struct snd_info_entry *entry;
        sprintf(name, "cspD%d", device);
        if (! snd_card_proc_new(p->chip->card, name, &entry))
                snd_info_set_text_ops(entry, p, 1024, info_read);
        return 0;
 }
 
-static void info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
+static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
-       snd_sb_csp_t *p = entry->private_data;
+       struct snd_sb_csp *p = entry->private_data;
 
        snd_iprintf(buffer, "Creative Signal Processor [v%d.%d]\n", (p->version >> 4), (p->version & 0x0f));
        snd_iprintf(buffer, "State: %cx%c%c%c\n", ((p->running & SNDRV_SB_CSP_ST_QSOUND) ? 'Q' : '-'),
index 17312e060a171cb764b98c12f9e980e33a16b18d..97786ed37dd69e4b35a01b226bd28361e3fcc63d 100644 (file)
@@ -50,10 +50,10 @@ MODULE_DESCRIPTION("Routines for control of 16-bit SoundBlaster cards and clones
 MODULE_LICENSE("GPL");
 
 #ifdef CONFIG_SND_SB16_CSP
-static void snd_sb16_csp_playback_prepare(sb_t *chip, snd_pcm_runtime_t *runtime)
+static void snd_sb16_csp_playback_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
 {
        if (chip->hardware == SB_HW_16CSP) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
                        /* manually loaded codec */
@@ -98,10 +98,10 @@ static void snd_sb16_csp_playback_prepare(sb_t *chip, snd_pcm_runtime_t *runtime
        }
 }
 
-static void snd_sb16_csp_capture_prepare(sb_t *chip, snd_pcm_runtime_t *runtime)
+static void snd_sb16_csp_capture_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
 {
        if (chip->hardware == SB_HW_16CSP) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
                        /* manually loaded codec */
@@ -136,10 +136,10 @@ static void snd_sb16_csp_capture_prepare(sb_t *chip, snd_pcm_runtime_t *runtime)
        }
 }
 
-static void snd_sb16_csp_update(sb_t *chip)
+static void snd_sb16_csp_update(struct snd_sb *chip)
 {
        if (chip->hardware == SB_HW_16CSP) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->qpos_changed) {
                        spin_lock(&chip->reg_lock);
@@ -149,11 +149,11 @@ static void snd_sb16_csp_update(sb_t *chip)
        }
 }
 
-static void snd_sb16_csp_playback_open(sb_t *chip, snd_pcm_runtime_t *runtime)
+static void snd_sb16_csp_playback_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
 {
        /* CSP decoders (QSound excluded) support only 16bit transfers */
        if (chip->hardware == SB_HW_16CSP) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
                        /* manually loaded codec */
@@ -168,10 +168,10 @@ static void snd_sb16_csp_playback_open(sb_t *chip, snd_pcm_runtime_t *runtime)
        }
 }
 
-static void snd_sb16_csp_playback_close(sb_t *chip)
+static void snd_sb16_csp_playback_close(struct snd_sb *chip)
 {
        if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_WRITE)) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->ops.csp_stop(csp) == 0) {
                        csp->ops.csp_unuse(csp);
@@ -180,11 +180,11 @@ static void snd_sb16_csp_playback_close(sb_t *chip)
        }
 }
 
-static void snd_sb16_csp_capture_open(sb_t *chip, snd_pcm_runtime_t *runtime)
+static void snd_sb16_csp_capture_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
 {
        /* CSP coders support only 16bit transfers */
        if (chip->hardware == SB_HW_16CSP) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
                        /* manually loaded codec */
@@ -199,10 +199,10 @@ static void snd_sb16_csp_capture_open(sb_t *chip, snd_pcm_runtime_t *runtime)
        }
 }
 
-static void snd_sb16_csp_capture_close(sb_t *chip)
+static void snd_sb16_csp_capture_close(struct snd_sb *chip)
 {
        if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_READ)) {
-               snd_sb_csp_t *csp = chip->csp;
+               struct snd_sb_csp *csp = chip->csp;
 
                if (csp->ops.csp_stop(csp) == 0) {
                        csp->ops.csp_unuse(csp);
@@ -221,7 +221,7 @@ static void snd_sb16_csp_capture_close(sb_t *chip)
 #endif
 
 
-static void snd_sb16_setup_rate(sb_t *chip,
+static void snd_sb16_setup_rate(struct snd_sb *chip,
                                unsigned short rate,
                                int channel)
 {
@@ -244,23 +244,23 @@ static void snd_sb16_setup_rate(sb_t *chip,
        spin_unlock_irqrestore(&chip->reg_lock, flags);
 }
 
-static int snd_sb16_hw_params(snd_pcm_substream_t * substream,
-                             snd_pcm_hw_params_t * hw_params)
+static int snd_sb16_hw_params(struct snd_pcm_substream *substream,
+                             struct snd_pcm_hw_params *hw_params)
 {
        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 }
 
-static int snd_sb16_hw_free(snd_pcm_substream_t * substream)
+static int snd_sb16_hw_free(struct snd_pcm_substream *substream)
 {
        snd_pcm_lib_free_pages(substream);
        return 0;
 }
 
-static int snd_sb16_playback_prepare(snd_pcm_substream_t * substream)
+static int snd_sb16_playback_prepare(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned char format;
        unsigned int size, count, dma;
 
@@ -298,10 +298,10 @@ static int snd_sb16_playback_prepare(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb16_playback_trigger(snd_pcm_substream_t * substream,
+static int snd_sb16_playback_trigger(struct snd_pcm_substream *substream,
                                     int cmd)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        int result = 0;
 
        spin_lock(&chip->reg_lock);
@@ -324,11 +324,11 @@ static int snd_sb16_playback_trigger(snd_pcm_substream_t * substream,
        return result;
 }
 
-static int snd_sb16_capture_prepare(snd_pcm_substream_t * substream)
+static int snd_sb16_capture_prepare(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned char format;
        unsigned int size, count, dma;
 
@@ -365,10 +365,10 @@ static int snd_sb16_capture_prepare(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb16_capture_trigger(snd_pcm_substream_t * substream,
+static int snd_sb16_capture_trigger(struct snd_pcm_substream *substream,
                                    int cmd)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        int result = 0;
 
        spin_lock(&chip->reg_lock);
@@ -393,7 +393,7 @@ static int snd_sb16_capture_trigger(snd_pcm_substream_t * substream,
 
 irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
-       sb_t *chip = dev_id;
+       struct snd_sb *chip = dev_id;
        unsigned char status;
        int ok;
 
@@ -443,9 +443,9 @@ irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
  */
 
-static snd_pcm_uframes_t snd_sb16_playback_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_sb16_playback_pointer(struct snd_pcm_substream *substream)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int dma;
        size_t ptr;
 
@@ -454,9 +454,9 @@ static snd_pcm_uframes_t snd_sb16_playback_pointer(snd_pcm_substream_t * substre
        return bytes_to_frames(substream->runtime, ptr);
 }
 
-static snd_pcm_uframes_t snd_sb16_capture_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_sb16_capture_pointer(struct snd_pcm_substream *substream)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int dma;
        size_t ptr;
 
@@ -469,7 +469,7 @@ static snd_pcm_uframes_t snd_sb16_capture_pointer(snd_pcm_substream_t * substrea
 
  */
 
-static snd_pcm_hardware_t snd_sb16_playback =
+static struct snd_pcm_hardware snd_sb16_playback =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
@@ -487,7 +487,7 @@ static snd_pcm_hardware_t snd_sb16_playback =
        .fifo_size =            0,
 };
 
-static snd_pcm_hardware_t snd_sb16_capture =
+static struct snd_pcm_hardware snd_sb16_capture =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
@@ -509,11 +509,11 @@ static snd_pcm_hardware_t snd_sb16_capture =
  *  open/close
  */
 
-static int snd_sb16_playback_open(snd_pcm_substream_t * substream)
+static int snd_sb16_playback_open(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        spin_lock_irqsave(&chip->open_lock, flags);
        if (chip->mode & SB_MODE_PLAYBACK) {
@@ -566,10 +566,10 @@ static int snd_sb16_playback_open(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb16_playback_close(snd_pcm_substream_t * substream)
+static int snd_sb16_playback_close(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
 
        snd_sb16_csp_playback_close(chip);
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -579,11 +579,11 @@ static int snd_sb16_playback_close(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb16_capture_open(snd_pcm_substream_t * substream)
+static int snd_sb16_capture_open(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        spin_lock_irqsave(&chip->open_lock, flags);
        if (chip->mode & SB_MODE_CAPTURE) {
@@ -636,10 +636,10 @@ static int snd_sb16_capture_open(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb16_capture_close(snd_pcm_substream_t * substream)
+static int snd_sb16_capture_close(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
 
        snd_sb16_csp_capture_close(chip);
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -653,7 +653,7 @@ static int snd_sb16_capture_close(snd_pcm_substream_t * substream)
  *  DMA control interface
  */
 
-static int snd_sb16_set_dma_mode(sb_t *chip, int what)
+static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what)
 {
        if (chip->dma8 < 0 || chip->dma16 < 0) {
                snd_assert(what == 0, return -EINVAL);
@@ -671,7 +671,7 @@ static int snd_sb16_set_dma_mode(sb_t *chip, int what)
        return 0;
 }
 
-static int snd_sb16_get_dma_mode(sb_t *chip)
+static int snd_sb16_get_dma_mode(struct snd_sb *chip)
 {
        if (chip->dma8 < 0 || chip->dma16 < 0)
                return 0;
@@ -685,7 +685,7 @@ static int snd_sb16_get_dma_mode(sb_t *chip)
        }
 }
 
-static int snd_sb16_dma_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sb16_dma_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        static char *texts[3] = {
                "Auto", "Playback", "Capture"
@@ -700,9 +700,9 @@ static int snd_sb16_dma_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info
        return 0;
 }
 
-static int snd_sb16_dma_control_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb16_dma_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *chip = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        
        spin_lock_irqsave(&chip->reg_lock, flags);
@@ -711,9 +711,9 @@ static int snd_sb16_dma_control_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_valu
        return 0;
 }
 
-static int snd_sb16_dma_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb16_dma_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *chip = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        unsigned char nval, oval;
        int change;
@@ -728,7 +728,7 @@ static int snd_sb16_dma_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_valu
        return change;
 }
 
-static snd_kcontrol_new_t snd_sb16_dma_control = {
+static struct snd_kcontrol_new snd_sb16_dma_control = {
        .iface = SNDRV_CTL_ELEM_IFACE_CARD,
        .name = "16-bit DMA Allocation",
        .info = snd_sb16_dma_control_info,
@@ -740,7 +740,7 @@ static snd_kcontrol_new_t snd_sb16_dma_control = {
  *  Initialization part
  */
  
-int snd_sb16dsp_configure(sb_t * chip)
+int snd_sb16dsp_configure(struct snd_sb * chip)
 {
        unsigned long flags;
        unsigned char irqreg = 0, dmareg = 0, mpureg;
@@ -829,7 +829,7 @@ int snd_sb16dsp_configure(sb_t * chip)
        return 0;
 }
 
-static snd_pcm_ops_t snd_sb16_playback_ops = {
+static struct snd_pcm_ops snd_sb16_playback_ops = {
        .open =         snd_sb16_playback_open,
        .close =        snd_sb16_playback_close,
        .ioctl =        snd_pcm_lib_ioctl,
@@ -840,7 +840,7 @@ static snd_pcm_ops_t snd_sb16_playback_ops = {
        .pointer =      snd_sb16_playback_pointer,
 };
 
-static snd_pcm_ops_t snd_sb16_capture_ops = {
+static struct snd_pcm_ops snd_sb16_capture_ops = {
        .open =         snd_sb16_capture_open,
        .close =        snd_sb16_capture_close,
        .ioctl =        snd_pcm_lib_ioctl,
@@ -851,10 +851,10 @@ static snd_pcm_ops_t snd_sb16_capture_ops = {
        .pointer =      snd_sb16_capture_pointer,
 };
 
-int snd_sb16dsp_pcm(sb_t * chip, int device, snd_pcm_t ** rpcm)
+int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm)
 {
-       snd_card_t *card = chip->card;
-       snd_pcm_t *pcm;
+       struct snd_card *card = chip->card;
+       struct snd_pcm *pcm;
        int err;
 
        if (rpcm)
@@ -882,7 +882,7 @@ int snd_sb16dsp_pcm(sb_t * chip, int device, snd_pcm_t ** rpcm)
        return 0;
 }
 
-const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction)
+const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction)
 {
        return direction == SNDRV_PCM_STREAM_PLAYBACK ?
                &snd_sb16_playback_ops : &snd_sb16_capture_ops;
index 0bc0a3afdabc0cf73b267e4477a0a1dca2bc51a4..5116038fcb4a96fd4cb771a2db62e005f14d1f11 100644 (file)
@@ -59,11 +59,11 @@ struct snd_sb8 {
        struct resource *fm_res;        /* used to block FM i/o region for legacy cards */
 };
 
-static snd_card_t *snd_sb8_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+static struct snd_card *snd_sb8_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
 
 static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
-       sb_t *chip = dev_id;
+       struct snd_sb *chip = dev_id;
 
        if (chip->open & SB_OPEN_PCM) {
                return snd_sb8dsp_interrupt(chip);
@@ -72,7 +72,7 @@ static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs
        }
 }
 
-static void snd_sb8_free(snd_card_t *card)
+static void snd_sb8_free(struct snd_card *card)
 {
        struct snd_sb8 *acard = (struct snd_sb8 *)card->private_data;
 
@@ -83,10 +83,10 @@ static void snd_sb8_free(snd_card_t *card)
 
 static int __init snd_sb8_probe(int dev)
 {
-       sb_t *chip;
-       snd_card_t *card;
+       struct snd_sb *chip;
+       struct snd_card *card;
        struct snd_sb8 *acard;
-       opl3_t *opl3;
+       struct snd_opl3 *opl3;
        int err;
 
        card = snd_card_new(index[dev], id[dev], THIS_MODULE,
index 28d8afdf68910c3edf0e8aa8776c8a341d60af89..aea9e5ec7b36eaaf3c6977665841e670acdf80b7 100644 (file)
@@ -46,19 +46,19 @@ MODULE_LICENSE("GPL");
 #define SB8_DEN(v)     ((SB8_CLOCK + (v) / 2) / (v))
 #define SB8_RATE(v)    (SB8_CLOCK / SB8_DEN(v))
 
-static ratnum_t clock = {
+static struct snd_ratnum clock = {
        .num = SB8_CLOCK,
        .den_min = 1,
        .den_max = 256,
        .den_step = 1,
 };
 
-static snd_pcm_hw_constraint_ratnums_t hw_constraints_clock = {
+static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {
        .nrats = 1,
        .rats = &clock,
 };
 
-static ratnum_t stereo_clocks[] = {
+static struct snd_ratnum stereo_clocks[] = {
        {
                .num = SB8_CLOCK,
                .den_min = SB8_DEN(22050),
@@ -73,10 +73,10 @@ static ratnum_t stereo_clocks[] = {
        }
 };
 
-static int snd_sb8_hw_constraint_rate_channels(snd_pcm_hw_params_t *params,
-                                              snd_pcm_hw_rule_t *rule)
+static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params,
+                                              struct snd_pcm_hw_rule *rule)
 {
-       snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+       struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
        if (c->min > 1) {
                unsigned int num = 0, den = 0;
                int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE),
@@ -90,22 +90,22 @@ static int snd_sb8_hw_constraint_rate_channels(snd_pcm_hw_params_t *params,
        return 0;
 }
 
-static int snd_sb8_hw_constraint_channels_rate(snd_pcm_hw_params_t *params,
-                                              snd_pcm_hw_rule_t *rule)
+static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params,
+                                              struct snd_pcm_hw_rule *rule)
 {
-       snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+       struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
        if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) {
-               snd_interval_t t = { .min = 1, .max = 1 };
+               struct snd_interval t = { .min = 1, .max = 1 };
                return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);
        }
        return 0;
 }
 
-static int snd_sb8_playback_prepare(snd_pcm_substream_t * substream)
+static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned int mixreg, rate, size, count;
 
        rate = runtime->rate;
@@ -178,11 +178,11 @@ static int snd_sb8_playback_prepare(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb8_playback_trigger(snd_pcm_substream_t * substream,
+static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,
                                    int cmd)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int count;
 
        spin_lock_irqsave(&chip->reg_lock, flags);
@@ -197,7 +197,7 @@ static int snd_sb8_playback_trigger(snd_pcm_substream_t * substream,
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) {
-                       snd_pcm_runtime_t *runtime = substream->runtime;
+                       struct snd_pcm_runtime *runtime = substream->runtime;
                        snd_sbdsp_reset(chip);
                        if (runtime->channels > 1) {
                                spin_lock(&chip->mixer_lock);
@@ -215,23 +215,23 @@ static int snd_sb8_playback_trigger(snd_pcm_substream_t * substream,
        return 0;
 }
 
-static int snd_sb8_hw_params(snd_pcm_substream_t * substream,
-                            snd_pcm_hw_params_t * hw_params)
+static int snd_sb8_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *hw_params)
 {
        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 }
 
-static int snd_sb8_hw_free(snd_pcm_substream_t * substream)
+static int snd_sb8_hw_free(struct snd_pcm_substream *substream)
 {
        snd_pcm_lib_free_pages(substream);
        return 0;
 }
 
-static int snd_sb8_capture_prepare(snd_pcm_substream_t * substream)
+static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned int mixreg, rate, size, count;
 
        rate = runtime->rate;
@@ -290,11 +290,11 @@ static int snd_sb8_capture_prepare(snd_pcm_substream_t * substream)
        return 0;
 }
 
-static int snd_sb8_capture_trigger(snd_pcm_substream_t * substream,
+static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,
                                   int cmd)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int count;
 
        spin_lock_irqsave(&chip->reg_lock, flags);
@@ -309,7 +309,7 @@ static int snd_sb8_capture_trigger(snd_pcm_substream_t * substream,
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) {
-                       snd_pcm_runtime_t *runtime = substream->runtime;
+                       struct snd_pcm_runtime *runtime = substream->runtime;
                        snd_sbdsp_reset(chip);
                        if (runtime->channels > 1) {
                                /* restore input filter status */
@@ -329,10 +329,10 @@ static int snd_sb8_capture_trigger(snd_pcm_substream_t * substream,
        return 0;
 }
 
-irqreturn_t snd_sb8dsp_interrupt(sb_t *chip)
+irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)
 {
-       snd_pcm_substream_t *substream;
-       snd_pcm_runtime_t *runtime;
+       struct snd_pcm_substream *substream;
+       struct snd_pcm_runtime *runtime;
 
        snd_sb_ack_8bit(chip);
        switch (chip->mode) {
@@ -354,9 +354,9 @@ irqreturn_t snd_sb8dsp_interrupt(sb_t *chip)
        return IRQ_HANDLED;
 }
 
-static snd_pcm_uframes_t snd_sb8_playback_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        size_t ptr;
 
        if (chip->mode != SB_MODE_PLAYBACK_8)
@@ -365,9 +365,9 @@ static snd_pcm_uframes_t snd_sb8_playback_pointer(snd_pcm_substream_t * substrea
        return bytes_to_frames(substream->runtime, ptr);
 }
 
-static snd_pcm_uframes_t snd_sb8_capture_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
        size_t ptr;
 
        if (chip->mode != SB_MODE_CAPTURE_8)
@@ -380,7 +380,7 @@ static snd_pcm_uframes_t snd_sb8_capture_pointer(snd_pcm_substream_t * substream
 
  */
 
-static snd_pcm_hardware_t snd_sb8_playback =
+static struct snd_pcm_hardware snd_sb8_playback =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
@@ -399,7 +399,7 @@ static snd_pcm_hardware_t snd_sb8_playback =
        .fifo_size =            0,
 };
 
-static snd_pcm_hardware_t snd_sb8_capture =
+static struct snd_pcm_hardware snd_sb8_capture =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
@@ -422,10 +422,10 @@ static snd_pcm_hardware_t snd_sb8_capture =
  *
  */
  
-static int snd_sb8_open(snd_pcm_substream_t *substream)
+static int snd_sb8_open(struct snd_pcm_substream *substream)
 {
-       sb_t *chip = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
+       struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned long flags;
 
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -468,10 +468,10 @@ static int snd_sb8_open(snd_pcm_substream_t *substream)
        return 0;       
 }
 
-static int snd_sb8_close(snd_pcm_substream_t *substream)
+static int snd_sb8_close(struct snd_pcm_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip = snd_pcm_substream_chip(substream);
+       struct snd_sb *chip = snd_pcm_substream_chip(substream);
 
        chip->playback_substream = NULL;
        chip->capture_substream = NULL;
@@ -485,7 +485,7 @@ static int snd_sb8_close(snd_pcm_substream_t *substream)
  *  Initialization part
  */
  
-static snd_pcm_ops_t snd_sb8_playback_ops = {
+static struct snd_pcm_ops snd_sb8_playback_ops = {
        .open =                 snd_sb8_open,
        .close =                snd_sb8_close,
        .ioctl =                snd_pcm_lib_ioctl,
@@ -496,7 +496,7 @@ static snd_pcm_ops_t snd_sb8_playback_ops = {
        .pointer =              snd_sb8_playback_pointer,
 };
 
-static snd_pcm_ops_t snd_sb8_capture_ops = {
+static struct snd_pcm_ops snd_sb8_capture_ops = {
        .open =                 snd_sb8_open,
        .close =                snd_sb8_close,
        .ioctl =                snd_pcm_lib_ioctl,
@@ -507,10 +507,10 @@ static snd_pcm_ops_t snd_sb8_capture_ops = {
        .pointer =              snd_sb8_capture_pointer,
 };
 
-int snd_sb8dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm)
+int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
 {
-       snd_card_t *card = chip->card;
-       snd_pcm_t *pcm;
+       struct snd_card *card = chip->card;
+       struct snd_pcm *pcm;
        int err;
 
        if (rpcm)
index d2c633a40e743e904e6071989748cd0d3c1c90a6..c549aceea2944ae6a3236301495d443f8dfa5309 100644 (file)
@@ -36,9 +36,9 @@
 
  */
 
-irqreturn_t snd_sb8dsp_midi_interrupt(sb_t * chip)
+irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip)
 {
-       snd_rawmidi_t *rmidi;
+       struct snd_rawmidi *rmidi;
        int max = 64;
        char byte;
 
@@ -63,10 +63,10 @@ irqreturn_t snd_sb8dsp_midi_interrupt(sb_t * chip)
 
  */
 
-static int snd_sb8dsp_midi_input_open(snd_rawmidi_substream_t * substream)
+static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
        unsigned int valid_open_flags;
 
        chip = substream->rmidi->private_data;
@@ -90,10 +90,10 @@ static int snd_sb8dsp_midi_input_open(snd_rawmidi_substream_t * substream)
        return 0;
 }
 
-static int snd_sb8dsp_midi_output_open(snd_rawmidi_substream_t * substream)
+static int snd_sb8dsp_midi_output_open(struct snd_rawmidi_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
        unsigned int valid_open_flags;
 
        chip = substream->rmidi->private_data;
@@ -117,10 +117,10 @@ static int snd_sb8dsp_midi_output_open(snd_rawmidi_substream_t * substream)
        return 0;
 }
 
-static int snd_sb8dsp_midi_input_close(snd_rawmidi_substream_t * substream)
+static int snd_sb8dsp_midi_input_close(struct snd_rawmidi_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
 
        chip = substream->rmidi->private_data;
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -135,10 +135,10 @@ static int snd_sb8dsp_midi_input_close(snd_rawmidi_substream_t * substream)
        return 0;
 }
 
-static int snd_sb8dsp_midi_output_close(snd_rawmidi_substream_t * substream)
+static int snd_sb8dsp_midi_output_close(struct snd_rawmidi_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
 
        chip = substream->rmidi->private_data;
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -153,10 +153,10 @@ static int snd_sb8dsp_midi_output_close(snd_rawmidi_substream_t * substream)
        return 0;
 }
 
-static void snd_sb8dsp_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
+static void snd_sb8dsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
 
        chip = substream->rmidi->private_data;
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -176,10 +176,10 @@ static void snd_sb8dsp_midi_input_trigger(snd_rawmidi_substream_t * substream, i
        spin_unlock_irqrestore(&chip->open_lock, flags);
 }
 
-static void snd_sb8dsp_midi_output_write(snd_rawmidi_substream_t * substream)
+static void snd_sb8dsp_midi_output_write(struct snd_rawmidi_substream *substream)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
        char byte;
        int max = 32;
 
@@ -214,8 +214,8 @@ static void snd_sb8dsp_midi_output_write(snd_rawmidi_substream_t * substream)
 
 static void snd_sb8dsp_midi_output_timer(unsigned long data)
 {
-       snd_rawmidi_substream_t * substream = (snd_rawmidi_substream_t *) data;
-       sb_t * chip = substream->rmidi->private_data;
+       struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *) data;
+       struct snd_sb * chip = substream->rmidi->private_data;
        unsigned long flags;
 
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -225,10 +225,10 @@ static void snd_sb8dsp_midi_output_timer(unsigned long data)
        snd_sb8dsp_midi_output_write(substream);
 }
 
-static void snd_sb8dsp_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
+static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
 {
        unsigned long flags;
-       sb_t *chip;
+       struct snd_sb *chip;
 
        chip = substream->rmidi->private_data;
        spin_lock_irqsave(&chip->open_lock, flags);
@@ -256,23 +256,23 @@ static void snd_sb8dsp_midi_output_trigger(snd_rawmidi_substream_t * substream,
 
  */
 
-static snd_rawmidi_ops_t snd_sb8dsp_midi_output =
+static struct snd_rawmidi_ops snd_sb8dsp_midi_output =
 {
        .open =         snd_sb8dsp_midi_output_open,
        .close =        snd_sb8dsp_midi_output_close,
        .trigger =      snd_sb8dsp_midi_output_trigger,
 };
 
-static snd_rawmidi_ops_t snd_sb8dsp_midi_input =
+static struct snd_rawmidi_ops snd_sb8dsp_midi_input =
 {
        .open =         snd_sb8dsp_midi_input_open,
        .close =        snd_sb8dsp_midi_input_close,
        .trigger =      snd_sb8dsp_midi_input_trigger,
 };
 
-int snd_sb8dsp_midi(sb_t *chip, int device, snd_rawmidi_t ** rrawmidi)
+int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi)
 {
-       snd_rawmidi_t *rmidi;
+       struct snd_rawmidi *rmidi;
        int err;
 
        if (rrawmidi)
index 603e923b5d2f84288ae0cdd0d7a6a8dfe04dba6b..eb86b4456eef65898bffdebf6b9c2aeca47d6b4c 100644 (file)
@@ -41,7 +41,7 @@ MODULE_LICENSE("GPL");
 
 #undef IO_DEBUG
 
-int snd_sbdsp_command(sb_t *chip, unsigned char val)
+int snd_sbdsp_command(struct snd_sb *chip, unsigned char val)
 {
        int i;
 #ifdef IO_DEBUG
@@ -56,7 +56,7 @@ int snd_sbdsp_command(sb_t *chip, unsigned char val)
        return 0;
 }
 
-int snd_sbdsp_get_byte(sb_t *chip)
+int snd_sbdsp_get_byte(struct snd_sb *chip)
 {
        int val;
        int i;
@@ -73,7 +73,7 @@ int snd_sbdsp_get_byte(sb_t *chip)
        return -ENODEV;
 }
 
-int snd_sbdsp_reset(sb_t *chip)
+int snd_sbdsp_reset(struct snd_sb *chip)
 {
        int i;
 
@@ -92,7 +92,7 @@ int snd_sbdsp_reset(sb_t *chip)
        return -ENODEV;
 }
 
-static int snd_sbdsp_version(sb_t * chip)
+static int snd_sbdsp_version(struct snd_sb * chip)
 {
        unsigned int result = -ENODEV;
 
@@ -102,7 +102,7 @@ static int snd_sbdsp_version(sb_t * chip)
        return result;
 }
 
-static int snd_sbdsp_probe(sb_t * chip)
+static int snd_sbdsp_probe(struct snd_sb * chip)
 {
        int version;
        int major, minor;
@@ -176,7 +176,7 @@ static int snd_sbdsp_probe(sb_t * chip)
        return 0;
 }
 
-static int snd_sbdsp_free(sb_t *chip)
+static int snd_sbdsp_free(struct snd_sb *chip)
 {
        if (chip->res_port)
                release_and_free_resource(chip->res_port);
@@ -196,24 +196,24 @@ static int snd_sbdsp_free(sb_t *chip)
        return 0;
 }
 
-static int snd_sbdsp_dev_free(snd_device_t *device)
+static int snd_sbdsp_dev_free(struct snd_device *device)
 {
-       sb_t *chip = device->device_data;
+       struct snd_sb *chip = device->device_data;
        return snd_sbdsp_free(chip);
 }
 
-int snd_sbdsp_create(snd_card_t *card,
+int snd_sbdsp_create(struct snd_card *card,
                     unsigned long port,
                     int irq,
                     irqreturn_t (*irq_handler)(int, void *, struct pt_regs *),
                     int dma8,
                     int dma16,
                     unsigned short hardware,
-                    sb_t **r_chip)
+                    struct snd_sb **r_chip)
 {
-       sb_t *chip;
+       struct snd_sb *chip;
        int err;
-       static snd_device_ops_t ops = {
+       static struct snd_device_ops ops = {
                .dev_free =     snd_sbdsp_dev_free,
        };
 
index 23cfa6a6a0af451583b68532cd535cb35641a8c3..6e0b935a8b85df154ae2052303f4af9522bdd95c 100644 (file)
@@ -29,7 +29,7 @@
 
 #undef IO_DEBUG
 
-void snd_sbmixer_write(sb_t *chip, unsigned char reg, unsigned char data)
+void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char data)
 {
        outb(reg, SBP(chip, MIXER_ADDR));
        udelay(10);
@@ -40,7 +40,7 @@ void snd_sbmixer_write(sb_t *chip, unsigned char reg, unsigned char data)
 #endif
 }
 
-unsigned char snd_sbmixer_read(sb_t *chip, unsigned char reg)
+unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg)
 {
        unsigned char result;
 
@@ -58,7 +58,7 @@ unsigned char snd_sbmixer_read(sb_t *chip, unsigned char reg)
  * Single channel mixer element
  */
 
-static int snd_sbmixer_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sbmixer_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        int mask = (kcontrol->private_value >> 24) & 0xff;
 
@@ -69,9 +69,9 @@ static int snd_sbmixer_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
        return 0;
 }
 
-static int snd_sbmixer_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sbmixer_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int reg = kcontrol->private_value & 0xff;
        int shift = (kcontrol->private_value >> 16) & 0xff;
@@ -85,9 +85,9 @@ static int snd_sbmixer_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_
        return 0;
 }
 
-static int snd_sbmixer_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sbmixer_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int reg = kcontrol->private_value & 0xff;
        int shift = (kcontrol->private_value >> 16) & 0x07;
@@ -110,7 +110,7 @@ static int snd_sbmixer_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_
  * Double channel mixer element
  */
 
-static int snd_sbmixer_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sbmixer_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        int mask = (kcontrol->private_value >> 24) & 0xff;
 
@@ -121,9 +121,9 @@ static int snd_sbmixer_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
        return 0;
 }
 
-static int snd_sbmixer_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sbmixer_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int left_reg = kcontrol->private_value & 0xff;
        int right_reg = (kcontrol->private_value >> 8) & 0xff;
@@ -141,9 +141,9 @@ static int snd_sbmixer_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_
        return 0;
 }
 
-static int snd_sbmixer_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sbmixer_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int left_reg = kcontrol->private_value & 0xff;
        int right_reg = (kcontrol->private_value >> 8) & 0xff;
@@ -181,7 +181,7 @@ static int snd_sbmixer_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_
  * DT-019x / ALS-007 capture/input switch
  */
 
-static int snd_dt019x_input_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_dt019x_input_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        static char *texts[5] = {
                "CD", "Mic", "Line", "Synth", "Master"
@@ -196,9 +196,9 @@ static int snd_dt019x_input_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_
        return 0;
 }
 
-static int snd_dt019x_input_sw_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_dt019x_input_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        unsigned char oval;
        
@@ -232,9 +232,9 @@ static int snd_dt019x_input_sw_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value
        return 0;
 }
 
-static int snd_dt019x_input_sw_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_dt019x_input_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned char nval, oval;
@@ -273,7 +273,7 @@ static int snd_dt019x_input_sw_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value
  * SBPRO input multiplexer
  */
 
-static int snd_sb8mixer_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sb8mixer_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        static char *texts[3] = {
                "Mic", "CD", "Line"
@@ -289,9 +289,9 @@ static int snd_sb8mixer_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *
 }
 
 
-static int snd_sb8mixer_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb8mixer_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        unsigned char oval;
        
@@ -312,9 +312,9 @@ static int snd_sb8mixer_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
        return 0;
 }
 
-static int snd_sb8mixer_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb8mixer_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int change;
        unsigned char nval, oval;
@@ -346,7 +346,7 @@ static int snd_sb8mixer_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
  * SB16 input switch
  */
 
-static int snd_sb16mixer_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_sb16mixer_info_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        uinfo->count = 4;
@@ -355,9 +355,9 @@ static int snd_sb16mixer_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_i
        return 0;
 }
 
-static int snd_sb16mixer_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb16mixer_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int reg1 = kcontrol->private_value & 0xff;
        int reg2 = (kcontrol->private_value >> 8) & 0xff;
@@ -376,9 +376,9 @@ static int snd_sb16mixer_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_va
        return 0;
 }                                                                                                                   
 
-static int snd_sb16mixer_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_sb16mixer_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-       sb_t *sb = snd_kcontrol_chip(kcontrol);
+       struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
        unsigned long flags;
        int reg1 = kcontrol->private_value & 0xff;
        int reg2 = (kcontrol->private_value >> 8) & 0xff;
@@ -410,9 +410,9 @@ static int snd_sb16mixer_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_va
  */
 /*
  */
-int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsigned long value)
+int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int type, unsigned long value)
 {
-       static snd_kcontrol_new_t newctls[] = {
+       static struct snd_kcontrol_new newctls[] = {
                [SB_MIX_SINGLE] = {
                        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                        .info = snd_sbmixer_info_single,
@@ -444,7 +444,7 @@ int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsig
                        .put = snd_dt019x_input_sw_put,
                },
        };
-       snd_kcontrol_t *ctl;
+       struct snd_kcontrol *ctl;
        int err;
 
        ctl = snd_ctl_new1(&newctls[type], chip);
@@ -758,7 +758,7 @@ static unsigned char snd_als4000_init_values[][2] = {
 
 /*
  */
-static int snd_sbmixer_init(sb_t *chip,
+static int snd_sbmixer_init(struct snd_sb *chip,
                            struct sbmix_elem **controls,
                            int controls_count,
                            unsigned char map[][2],
@@ -766,7 +766,7 @@ static int snd_sbmixer_init(sb_t *chip,
                            char *name)
 {
        unsigned long flags;
-       snd_card_t *card = chip->card;
+       struct snd_card *card = chip->card;
        int idx, err;
 
        /* mixer reset */
@@ -790,9 +790,9 @@ static int snd_sbmixer_init(sb_t *chip,
        return 0;
 }
 
-int snd_sbmixer_new(sb_t *chip)
+int snd_sbmixer_new(struct snd_sb *chip)
 {
-       snd_card_t * card;
+       struct snd_card *card;
        int err;
 
        snd_assert(chip != NULL && chip->card != NULL, return -EINVAL);