[ALSA] Remove xxx_t typedefs: PCI CA0106

Modules: CA0106 driver

Remove xxx_t typedefs from the PCI CA0106 driver.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 118 insertions, 116 deletions

diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 0120c4683c79..744f97183723 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -164,7 +164,7 @@ MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard.");
 
 #include "ca0106.h"
 
-static ca0106_details_t ca0106_chip_details[] = {
+static struct snd_ca0106_details ca0106_chip_details[] = {
          /* AudigyLS[SB0310] */
          { .serial = 0x10021102,
            .name   = "AudigyLS [SB0310]",
@@ -201,7 +201,7 @@ static ca0106_details_t ca0106_chip_details[] = {
 };
 
 /* hardware definition */
-static snd_pcm_hardware_t snd_ca0106_playback_hw = {
+static struct snd_pcm_hardware snd_ca0106_playback_hw = {
         .info =                 (SNDRV_PCM_INFO_MMAP | 
                                  SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -221,7 +221,7 @@ static snd_pcm_hardware_t snd_ca0106_playback_hw = {
         .fifo_size =            0,
 };
 
-static snd_pcm_hardware_t snd_ca0106_capture_hw = {
+static struct snd_pcm_hardware snd_ca0106_capture_hw = {
         .info =                 (SNDRV_PCM_INFO_MMAP | 
                                  SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -241,7 +241,7 @@ static snd_pcm_hardware_t snd_ca0106_capture_hw = {
         .fifo_size =            0,
 };
 
-unsigned int snd_ca0106_ptr_read(ca0106_t * emu, 
+unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, 
                                           unsigned int reg, 
                                           unsigned int chn)
 {
@@ -257,7 +257,7 @@ unsigned int snd_ca0106_ptr_read(ca0106_t * emu,
         return val;
 }
 
-void snd_ca0106_ptr_write(ca0106_t *emu, 
+void snd_ca0106_ptr_write(struct snd_ca0106 *emu, 
                                    unsigned int reg, 
                                    unsigned int chn, 
                                    unsigned int data)
@@ -273,7 +273,7 @@ void snd_ca0106_ptr_write(ca0106_t *emu,
         spin_unlock_irqrestore(&emu->emu_lock, flags);
 }
 
-int snd_ca0106_i2c_write(ca0106_t *emu,
+int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
                                 u32 reg,
                                 u32 value)
 {
@@ -325,7 +325,7 @@ int snd_ca0106_i2c_write(ca0106_t *emu,
 }
 
 
-static void snd_ca0106_intr_enable(ca0106_t *emu, unsigned int intrenb)
+static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb)
 {
         unsigned long flags;
         unsigned int enable;
@@ -336,7 +336,7 @@ static void snd_ca0106_intr_enable(ca0106_t *emu, unsigned int intrenb)
         spin_unlock_irqrestore(&emu->emu_lock, flags);
 }
 
-static void snd_ca0106_intr_disable(ca0106_t *emu, unsigned int intrenb)
+static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb)
 {
         unsigned long flags;
         unsigned int enable;
@@ -348,18 +348,19 @@ static void snd_ca0106_intr_disable(ca0106_t *emu, unsigned int intrenb)
 }
 
 
-static void snd_ca0106_pcm_free_substream(snd_pcm_runtime_t *runtime)
+static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime)
 {
         kfree(runtime->private_data);
 }
 
 /* open_playback callback */
-static int snd_ca0106_pcm_open_playback_channel(snd_pcm_substream_t *substream, int channel_id)
+static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
+                                                int channel_id)
 {
-        ca0106_t *chip = snd_pcm_substream_chip(substream);
-        ca0106_channel_t *channel = &(chip->playback_channels[channel_id]);
-        ca0106_pcm_t *epcm;
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
+        struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]);
+        struct snd_ca0106_pcm *epcm;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
@@ -390,43 +391,44 @@ static int snd_ca0106_pcm_open_playback_channel(snd_pcm_substream_t *substream,
 }
 
 /* close callback */
-static int snd_ca0106_pcm_close_playback(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream)
 {
-        ca0106_t *chip = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
-        chip->playback_channels[epcm->channel_id].use=0;
-/* FIXME: maybe zero others */
+        struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
+        chip->playback_channels[epcm->channel_id].use = 0;
+        /* FIXME: maybe zero others */
         return 0;
 }
 
-static int snd_ca0106_pcm_open_playback_front(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
 }
 
-static int snd_ca0106_pcm_open_playback_center_lfe(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL);
 }
 
-static int snd_ca0106_pcm_open_playback_unknown(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL);
 }
 
-static int snd_ca0106_pcm_open_playback_rear(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL);
 }
 
 /* open_capture callback */
-static int snd_ca0106_pcm_open_capture_channel(snd_pcm_substream_t *substream, int channel_id)
+static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream,
+                                               int channel_id)
 {
-        ca0106_t *chip = snd_pcm_substream_chip(substream);
-        ca0106_channel_t *channel = &(chip->capture_channels[channel_id]);
-        ca0106_pcm_t *epcm;
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
+        struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]);
+        struct snd_ca0106_pcm *epcm;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
@@ -449,7 +451,7 @@ static int snd_ca0106_pcm_open_capture_channel(snd_pcm_substream_t *substream, i
         channel->use = 1;
         //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
-        channel->epcm = epcm;
+        channel->epcm = epcm;
         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
                 return err;
         //snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_capture_period_sizes);
@@ -459,70 +461,70 @@ static int snd_ca0106_pcm_open_capture_channel(snd_pcm_substream_t *substream, i
 }
 
 /* close callback */
-static int snd_ca0106_pcm_close_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream)
 {
-        ca0106_t *chip = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
-        chip->capture_channels[epcm->channel_id].use=0;
-/* FIXME: maybe zero others */
+        struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
+        chip->capture_channels[epcm->channel_id].use = 0;
+        /* FIXME: maybe zero others */
         return 0;
 }
 
-static int snd_ca0106_pcm_open_0_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_capture_channel(substream, 0);
 }
 
-static int snd_ca0106_pcm_open_1_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_capture_channel(substream, 1);
 }
 
-static int snd_ca0106_pcm_open_2_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_capture_channel(substream, 2);
 }
 
-static int snd_ca0106_pcm_open_3_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream)
 {
         return snd_ca0106_pcm_open_capture_channel(substream, 3);
 }
 
 /* hw_params callback */
-static int snd_ca0106_pcm_hw_params_playback(snd_pcm_substream_t *substream,
-                                      snd_pcm_hw_params_t * hw_params)
+static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_hw_params *hw_params)
 {
         return snd_pcm_lib_malloc_pages(substream,
                                         params_buffer_bytes(hw_params));
 }
 
 /* hw_free callback */
-static int snd_ca0106_pcm_hw_free_playback(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream)
 {
         return snd_pcm_lib_free_pages(substream);
 }
 
 /* hw_params callback */
-static int snd_ca0106_pcm_hw_params_capture(snd_pcm_substream_t *substream,
-                                      snd_pcm_hw_params_t * hw_params)
+static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_hw_params *hw_params)
 {
         return snd_pcm_lib_malloc_pages(substream,
                                         params_buffer_bytes(hw_params));
 }
 
 /* hw_free callback */
-static int snd_ca0106_pcm_hw_free_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream)
 {
         return snd_pcm_lib_free_pages(substream);
 }
 
 /* prepare playback callback */
-static int snd_ca0106_pcm_prepare_playback(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
         int channel = epcm->channel_id;
         u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel));
         u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
@@ -619,11 +621,11 @@ static int snd_ca0106_pcm_prepare_playback(snd_pcm_substream_t *substream)
 }
 
 /* prepare capture callback */
-static int snd_ca0106_pcm_prepare_capture(snd_pcm_substream_t *substream)
+static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
         int channel = epcm->channel_id;
         u32 hcfg_mask = HCFG_CAPTURE_S32_LE;
         u32 hcfg_set = 0x00000000;
@@ -690,16 +692,16 @@ static int snd_ca0106_pcm_prepare_capture(snd_pcm_substream_t *substream)
 }
 
 /* trigger_playback callback */
-static int snd_ca0106_pcm_trigger_playback(snd_pcm_substream_t *substream,
+static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
                                     int cmd)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime;
-        ca0106_pcm_t *epcm;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime;
+        struct snd_ca0106_pcm *epcm;
         int channel;
         int result = 0;
         struct list_head *pos;
-        snd_pcm_substream_t *s;
+        struct snd_pcm_substream *s;
         u32 basic = 0;
         u32 extended = 0;
         int running=0;
@@ -743,12 +745,12 @@ static int snd_ca0106_pcm_trigger_playback(snd_pcm_substream_t *substream,
 }
 
 /* trigger_capture callback */
-static int snd_ca0106_pcm_trigger_capture(snd_pcm_substream_t *substream,
+static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
                                     int cmd)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
         int channel = epcm->channel_id;
         int result = 0;
 
@@ -772,11 +774,11 @@ static int snd_ca0106_pcm_trigger_capture(snd_pcm_substream_t *substream,
 
 /* pointer_playback callback */
 static snd_pcm_uframes_t
-snd_ca0106_pcm_pointer_playback(snd_pcm_substream_t *substream)
+snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
         snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
         int channel = epcm->channel_id;
 
@@ -799,11 +801,11 @@ snd_ca0106_pcm_pointer_playback(snd_pcm_substream_t *substream)
 
 /* pointer_capture callback */
 static snd_pcm_uframes_t
-snd_ca0106_pcm_pointer_capture(snd_pcm_substream_t *substream)
+snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
 {
-        ca0106_t *emu = snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        ca0106_pcm_t *epcm = runtime->private_data;
+        struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_ca0106_pcm *epcm = runtime->private_data;
         snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
         int channel = channel=epcm->channel_id;
 
@@ -821,7 +823,7 @@ snd_ca0106_pcm_pointer_capture(snd_pcm_substream_t *substream)
 }
 
 /* operators */
-static snd_pcm_ops_t snd_ca0106_playback_front_ops = {
+static struct snd_pcm_ops snd_ca0106_playback_front_ops = {
         .open =        snd_ca0106_pcm_open_playback_front,
         .close =       snd_ca0106_pcm_close_playback,
         .ioctl =       snd_pcm_lib_ioctl,
@@ -832,7 +834,7 @@ static snd_pcm_ops_t snd_ca0106_playback_front_ops = {
         .pointer =     snd_ca0106_pcm_pointer_playback,
 };
 
-static snd_pcm_ops_t snd_ca0106_capture_0_ops = {
+static struct snd_pcm_ops snd_ca0106_capture_0_ops = {
         .open =        snd_ca0106_pcm_open_0_capture,
         .close =       snd_ca0106_pcm_close_capture,
         .ioctl =       snd_pcm_lib_ioctl,
@@ -843,7 +845,7 @@ static snd_pcm_ops_t snd_ca0106_capture_0_ops = {
         .pointer =     snd_ca0106_pcm_pointer_capture,
 };
 
-static snd_pcm_ops_t snd_ca0106_capture_1_ops = {
+static struct snd_pcm_ops snd_ca0106_capture_1_ops = {
         .open =        snd_ca0106_pcm_open_1_capture,
         .close =       snd_ca0106_pcm_close_capture,
         .ioctl =       snd_pcm_lib_ioctl,
@@ -854,7 +856,7 @@ static snd_pcm_ops_t snd_ca0106_capture_1_ops = {
         .pointer =     snd_ca0106_pcm_pointer_capture,
 };
 
-static snd_pcm_ops_t snd_ca0106_capture_2_ops = {
+static struct snd_pcm_ops snd_ca0106_capture_2_ops = {
         .open =        snd_ca0106_pcm_open_2_capture,
         .close =       snd_ca0106_pcm_close_capture,
         .ioctl =       snd_pcm_lib_ioctl,
@@ -865,7 +867,7 @@ static snd_pcm_ops_t snd_ca0106_capture_2_ops = {
         .pointer =     snd_ca0106_pcm_pointer_capture,
 };
 
-static snd_pcm_ops_t snd_ca0106_capture_3_ops = {
+static struct snd_pcm_ops snd_ca0106_capture_3_ops = {
         .open =        snd_ca0106_pcm_open_3_capture,
         .close =       snd_ca0106_pcm_close_capture,
         .ioctl =       snd_pcm_lib_ioctl,
@@ -876,7 +878,7 @@ static snd_pcm_ops_t snd_ca0106_capture_3_ops = {
         .pointer =     snd_ca0106_pcm_pointer_capture,
 };
 
-static snd_pcm_ops_t snd_ca0106_playback_center_lfe_ops = {
+static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
         .open =         snd_ca0106_pcm_open_playback_center_lfe,
         .close =        snd_ca0106_pcm_close_playback,
         .ioctl =        snd_pcm_lib_ioctl,
@@ -887,7 +889,7 @@ static snd_pcm_ops_t snd_ca0106_playback_center_lfe_ops = {
         .pointer =      snd_ca0106_pcm_pointer_playback, 
 };
 
-static snd_pcm_ops_t snd_ca0106_playback_unknown_ops = {
+static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
         .open =         snd_ca0106_pcm_open_playback_unknown,
         .close =        snd_ca0106_pcm_close_playback,
         .ioctl =        snd_pcm_lib_ioctl,
@@ -898,7 +900,7 @@ static snd_pcm_ops_t snd_ca0106_playback_unknown_ops = {
         .pointer =      snd_ca0106_pcm_pointer_playback, 
 };
 
-static snd_pcm_ops_t snd_ca0106_playback_rear_ops = {
+static struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
         .open =         snd_ca0106_pcm_open_playback_rear,
         .close =        snd_ca0106_pcm_close_playback,
         .ioctl =        snd_pcm_lib_ioctl,
@@ -910,10 +912,10 @@ static snd_pcm_ops_t snd_ca0106_playback_rear_ops = {
 };
 
 
-static unsigned short snd_ca0106_ac97_read(ac97_t *ac97,
+static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
                                              unsigned short reg)
 {
-        ca0106_t *emu = ac97->private_data;
+        struct snd_ca0106 *emu = ac97->private_data;
         unsigned long flags;
         unsigned short val;
 
@@ -924,10 +926,10 @@ static unsigned short snd_ca0106_ac97_read(ac97_t *ac97,
         return val;
 }
 
-static void snd_ca0106_ac97_write(ac97_t *ac97,
+static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
                                     unsigned short reg, unsigned short val)
 {
-        ca0106_t *emu = ac97->private_data;
+        struct snd_ca0106 *emu = ac97->private_data;
         unsigned long flags;
   
         spin_lock_irqsave(&emu->emu_lock, flags);
@@ -936,12 +938,12 @@ static void snd_ca0106_ac97_write(ac97_t *ac97,
         spin_unlock_irqrestore(&emu->emu_lock, flags);
 }
 
-static int snd_ca0106_ac97(ca0106_t *chip)
+static int snd_ca0106_ac97(struct snd_ca0106 *chip)
 {
-        ac97_bus_t *pbus;
-        ac97_template_t ac97;
+        struct snd_ac97_bus *pbus;
+        struct snd_ac97_template ac97;
         int err;
-        static ac97_bus_ops_t ops = {
+        static struct snd_ac97_bus_ops ops = {
                 .write = snd_ca0106_ac97_write,
                 .read = snd_ca0106_ac97_read,
         };
@@ -956,7 +958,7 @@ static int snd_ca0106_ac97(ca0106_t *chip)
         return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
 }
 
-static int snd_ca0106_free(ca0106_t *chip)
+static int snd_ca0106_free(struct snd_ca0106 *chip)
 {
         if (chip->res_port != NULL) {    /* avoid access to already used hardware */
                 // disable interrupts
@@ -989,9 +991,9 @@ static int snd_ca0106_free(ca0106_t *chip)
         return 0;
 }
 
-static int snd_ca0106_dev_free(snd_device_t *device)
+static int snd_ca0106_dev_free(struct snd_device *device)
 {
-        ca0106_t *chip = device->device_data;
+        struct snd_ca0106 *chip = device->device_data;
         return snd_ca0106_free(chip);
 }
 
@@ -1000,14 +1002,13 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id,
 {
         unsigned int status;
 
-        ca0106_t *chip = dev_id;
+        struct snd_ca0106 *chip = dev_id;
         int i;
         int mask;
         unsigned int stat76;
-        ca0106_channel_t *pchannel;
+        struct snd_ca0106_channel *pchannel;
 
         status = inl(chip->port + IPR);
-
         if (! status)
                 return IRQ_NONE;
 
@@ -1059,10 +1060,10 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id,
         return IRQ_HANDLED;
 }
 
-static int __devinit snd_ca0106_pcm(ca0106_t *emu, int device, snd_pcm_t **rpcm)
+static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm)
 {
-        snd_pcm_t *pcm;
-        snd_pcm_substream_t *substream;
+        struct snd_pcm *pcm;
+        struct snd_pcm_substream *substream;
         int err;
   
         if (rpcm)
@@ -1122,15 +1123,15 @@ static int __devinit snd_ca0106_pcm(ca0106_t *emu, int device, snd_pcm_t **rpcm)
         return 0;
 }
 
-static int __devinit snd_ca0106_create(snd_card_t *card,
+static int __devinit snd_ca0106_create(struct snd_card *card,
                                          struct pci_dev *pci,
-                                         ca0106_t **rchip)
+                                         struct snd_ca0106 **rchip)
 {
-        ca0106_t *chip;
-        ca0106_details_t *c;
+        struct snd_ca0106 *chip;
+        struct snd_ca0106_details *c;
         int err;
         int ch;
-        static snd_device_ops_t ops = {
+        static struct snd_device_ops ops = {
                 .dev_free = snd_ca0106_dev_free,
         };
   
@@ -1314,39 +1315,40 @@ static int __devinit snd_ca0106_create(snd_card_t *card,
 }
 
 
-static void ca0106_midi_interrupt_enable(ca_midi_t *midi, int intr)
+static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
 {
-        snd_ca0106_intr_enable((ca0106_t *)(midi->dev_id), intr);
+        snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
 }
 
-static void ca0106_midi_interrupt_disable(ca_midi_t *midi, int intr)
+static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
 {
-        snd_ca0106_intr_disable((ca0106_t *)(midi->dev_id), intr);
+        snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
 }
 
-static unsigned char ca0106_midi_read(ca_midi_t *midi, int idx)
+static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
 {
-        return (unsigned char)snd_ca0106_ptr_read((ca0106_t *)(midi->dev_id), midi->port + idx, 0);
+        return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
+                                                  midi->port + idx, 0);
 }
 
-static void ca0106_midi_write(ca_midi_t *midi, int data, int idx)
+static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
 {
-        snd_ca0106_ptr_write((ca0106_t *)(midi->dev_id), midi->port + idx, 0, data);
+        snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
 }
 
-static snd_card_t *ca0106_dev_id_card(void *dev_id)
+static struct snd_card *ca0106_dev_id_card(void *dev_id)
 {
-        return ((ca0106_t *)dev_id)->card;
+        return ((struct snd_ca0106 *)dev_id)->card;
 }
 
 static int ca0106_dev_id_port(void *dev_id)
 {
-        return ((ca0106_t *)dev_id)->port;
+        return ((struct snd_ca0106 *)dev_id)->port;
 }
 
-static int __devinit snd_ca0106_midi(ca0106_t *chip, unsigned int channel)
+static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
 {
-        ca_midi_t *midi;
+        struct snd_ca_midi *midi;
         char *name;
         int err;
 
@@ -1399,8 +1401,8 @@ static int __devinit snd_ca0106_probe(struct pci_dev *pci,
                                         const struct pci_device_id *pci_id)
 {
         static int dev;
-        snd_card_t *card;
-        ca0106_t *chip;
+        struct snd_card *card;
+        struct snd_ca0106 *chip;
         int err;
 
         if (dev >= SNDRV_CARDS)