[ALSA] Remove xxx_t typedefs: Controls

Modules: Control Midlevel

Remove xxx_t typedefs from the core controls.

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

2 files changed, 186 insertions, 161 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index 212c46a94376..1a14338bd516 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -34,12 +34,10 @@
 /* max number of user-defined controls */
 #define MAX_USER_CONTROLS       32
 
-typedef struct _snd_kctl_ioctl {
+struct snd_kctl_ioctl {
         struct list_head list;          /* list of all ioctls */
         snd_kctl_ioctl_func_t fioctl;
-} snd_kctl_ioctl_t;
-
-#define snd_kctl_ioctl(n) list_entry(n, snd_kctl_ioctl_t, list)
+};
 
 static DECLARE_RWSEM(snd_ioctl_rwsem);
 static LIST_HEAD(snd_control_ioctls);
@@ -51,8 +49,8 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
 {
         int cardnum = SNDRV_MINOR_CARD(iminor(inode));
         unsigned long flags;
-        snd_card_t *card;
-        snd_ctl_file_t *ctl;
+        struct snd_card *card;
+        struct snd_ctl_file *ctl;
         int err;
 
         card = snd_cards[cardnum];
@@ -93,9 +91,9 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
         return err;
 }
 
-static void snd_ctl_empty_read_queue(snd_ctl_file_t * ctl)
+static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
 {
-        snd_kctl_event_t *cread;
+        struct snd_kctl_event *cread;
         
         spin_lock(&ctl->read_lock);
         while (!list_empty(&ctl->events)) {
@@ -110,9 +108,9 @@ static int snd_ctl_release(struct inode *inode, struct file *file)
 {
         unsigned long flags;
         struct list_head *list;
-        snd_card_t *card;
-        snd_ctl_file_t *ctl;
-        snd_kcontrol_t *control;
+        struct snd_card *card;
+        struct snd_ctl_file *ctl;
+        struct snd_kcontrol *control;
         unsigned int idx;
 
         ctl = file->private_data;
@@ -137,12 +135,13 @@ static int snd_ctl_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id)
+void snd_ctl_notify(struct snd_card *card, unsigned int mask,
+                    struct snd_ctl_elem_id *id)
 {
         unsigned long flags;
         struct list_head *flist;
-        snd_ctl_file_t *ctl;
-        snd_kctl_event_t *ev;
+        struct snd_ctl_file *ctl;
+        struct snd_kctl_event *ev;
         
         snd_assert(card != NULL && id != NULL, return);
         read_lock(&card->ctl_files_rwlock);
@@ -183,19 +182,19 @@ void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id)
  * @control: the control template
  * @access: the default control access
  *
- * Allocates a new snd_kcontrol_t instance and copies the given template 
+ * Allocates a new struct snd_kcontrol instance and copies the given template 
  * to the new instance. It does not copy volatile data (access).
  *
  * Returns the pointer of the new instance, or NULL on failure.
  */
-snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access)
+struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int access)
 {
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
         unsigned int idx;
         
         snd_assert(control != NULL, return NULL);
         snd_assert(control->count > 0, return NULL);
-        kctl = kzalloc(sizeof(*kctl) + sizeof(snd_kcontrol_volatile_t) * control->count, GFP_KERNEL);
+        kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
         if (kctl == NULL)
                 return NULL;
         *kctl = *control;
@@ -209,15 +208,16 @@ snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access)
  * @ncontrol: the initialization record
  * @private_data: the private data to set
  *
- * Allocates a new snd_kcontrol_t instance and initialize from the given 
+ * Allocates a new struct snd_kcontrol instance and initialize from the given 
  * template.  When the access field of ncontrol is 0, it's assumed as
  * READWRITE access. When the count field is 0, it's assumes as one.
  *
  * Returns the pointer of the newly generated instance, or NULL on failure.
  */
-snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * ncontrol, void *private_data)
+struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
+                                  void *private_data)
 {
-        snd_kcontrol_t kctl;
+        struct snd_kcontrol kctl;
         unsigned int access;
         
         snd_assert(ncontrol != NULL, return NULL);
@@ -249,7 +249,7 @@ snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * ncontrol, void *private_
  * or snd_ctl_new1().
  * Don't call this after the control was added to the card.
  */
-void snd_ctl_free_one(snd_kcontrol_t * kcontrol)
+void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
 {
         if (kcontrol) {
                 if (kcontrol->private_free)
@@ -258,11 +258,11 @@ void snd_ctl_free_one(snd_kcontrol_t * kcontrol)
         }
 }
 
-static unsigned int snd_ctl_hole_check(snd_card_t * card,
+static unsigned int snd_ctl_hole_check(struct snd_card *card,
                                        unsigned int count)
 {
         struct list_head *list;
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
 
         list_for_each(list, &card->controls) {
                 kctl = snd_kcontrol(list);
@@ -275,7 +275,7 @@ static unsigned int snd_ctl_hole_check(snd_card_t * card,
         return card->last_numid;
 }
 
-static int snd_ctl_find_hole(snd_card_t * card, unsigned int count)
+static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
 {
         unsigned int last_numid, iter = 100000;
 
@@ -304,9 +304,9 @@ static int snd_ctl_find_hole(snd_card_t * card, unsigned int count)
  *
  * It frees automatically the control which cannot be added.
  */
-int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol)
+int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
 {
-        snd_ctl_elem_id_t id;
+        struct snd_ctl_elem_id id;
         unsigned int idx;
 
         snd_assert(card != NULL && kcontrol != NULL, return -EINVAL);
@@ -350,9 +350,9 @@ int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol)
  * 
  * Returns 0 if successful, or a negative error code on failure.
  */
-int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol)
+int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 {
-        snd_ctl_elem_id_t id;
+        struct snd_ctl_elem_id id;
         unsigned int idx;
 
         snd_assert(card != NULL && kcontrol != NULL, return -EINVAL);
@@ -375,9 +375,9 @@ int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol)
  * 
  * Returns 0 if successful, or a negative error code on failure.
  */
-int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id)
+int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
 {
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
         int ret;
 
         down_write(&card->controls_rwsem);
@@ -401,10 +401,11 @@ int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id)
  * 
  * Returns 0 if successful, or a negative error code on failure.
  */
-static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *id)
+static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file,
+                                      struct snd_ctl_elem_id *id)
 {
-        snd_card_t *card = file->card;
-        snd_kcontrol_t *kctl;
+        struct snd_card *card = file->card;
+        struct snd_kcontrol *kctl;
         int idx, ret;
 
         down_write(&card->controls_rwsem);
@@ -434,9 +435,10 @@ static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *
  *
  * Returns zero if successful, or a negative error code on failure.
  */
-int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id)
+int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
+                      struct snd_ctl_elem_id *dst_id)
 {
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
 
         down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, src_id);
@@ -463,10 +465,10 @@ int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem
  * The caller must down card->controls_rwsem before calling this function
  * (if the race condition can happen).
  */
-snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid)
+struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
 {
         struct list_head *list;
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
 
         snd_assert(card != NULL && numid != 0, return NULL);
         list_for_each(list, &card->controls) {
@@ -489,10 +491,11 @@ snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid)
  * The caller must down card->controls_rwsem before calling this function
  * (if the race condition can happen).
  */
-snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id)
+struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
+                                     struct snd_ctl_elem_id *id)
 {
         struct list_head *list;
-        snd_kcontrol_t *kctl;
+        struct snd_kcontrol *kctl;
 
         snd_assert(card != NULL && id != NULL, return NULL);
         if (id->numid != 0)
@@ -516,10 +519,10 @@ snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id)
         return NULL;
 }
 
-static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
+static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
                              unsigned int cmd, void __user *arg)
 {
-        snd_ctl_card_info_t *info;
+        struct snd_ctl_card_info *info;
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (! info)
@@ -533,7 +536,7 @@ static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
         strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
         strlcpy(info->components, card->components, sizeof(info->components));
         up_read(&snd_ioctl_rwsem);
-        if (copy_to_user(arg, info, sizeof(snd_ctl_card_info_t))) {
+        if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
                 kfree(info);
                 return -EFAULT;
         }
@@ -541,12 +544,13 @@ static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
         return 0;
 }
 
-static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list)
+static int snd_ctl_elem_list(struct snd_card *card,
+                             struct snd_ctl_elem_list __user *_list)
 {
         struct list_head *plist;
-        snd_ctl_elem_list_t list;
-        snd_kcontrol_t *kctl;
-        snd_ctl_elem_id_t *dst, *id;
+        struct snd_ctl_elem_list list;
+        struct snd_kcontrol *kctl;
+        struct snd_ctl_elem_id *dst, *id;
         unsigned int offset, space, first, jidx;
         
         if (copy_from_user(&list, _list, sizeof(list)))
@@ -559,7 +563,7 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list
                 return -ENOMEM;
         if (space > 0) {
                 /* allocate temporary buffer for atomic operation */
-                dst = vmalloc(space * sizeof(snd_ctl_elem_id_t));
+                dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
                 if (dst == NULL)
                         return -ENOMEM;
                 down_read(&card->controls_rwsem);
@@ -588,7 +592,9 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list
                         offset = 0;
                 }
                 up_read(&card->controls_rwsem);
-                if (list.used > 0 && copy_to_user(list.pids, dst, list.used * sizeof(snd_ctl_elem_id_t))) {
+                if (list.used > 0 &&
+                    copy_to_user(list.pids, dst,
+                                 list.used * sizeof(struct snd_ctl_elem_id))) {
                         vfree(dst);
                         return -EFAULT;
                 }
@@ -603,11 +609,12 @@ static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list
         return 0;
 }
 
-static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t *info)
+static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
+                             struct snd_ctl_elem_info *info)
 {
-        snd_card_t *card = ctl->card;
-        snd_kcontrol_t *kctl;
-        snd_kcontrol_volatile_t *vd;
+        struct snd_card *card = ctl->card;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
         int result;
         
@@ -640,9 +647,10 @@ static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t *info)
         return result;
 }
 
-static int snd_ctl_elem_info_user(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __user *_info)
+static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
+                                  struct snd_ctl_elem_info __user *_info)
 {
-        snd_ctl_elem_info_t info;
+        struct snd_ctl_elem_info info;
         int result;
 
         if (copy_from_user(&info, _info, sizeof(info)))
@@ -654,10 +662,10 @@ static int snd_ctl_elem_info_user(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __use
         return result;
 }
 
-int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control)
+int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
 {
-        snd_kcontrol_t *kctl;
-        snd_kcontrol_volatile_t *vd;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
         int result, indirect;
 
@@ -684,9 +692,10 @@ int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control)
         return result;
 }
 
-static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user *_control)
+static int snd_ctl_elem_read_user(struct snd_card *card,
+                                  struct snd_ctl_elem_value __user *_control)
 {
-        snd_ctl_elem_value_t *control;
+        struct snd_ctl_elem_value *control;
         int result;
         
         control = kmalloc(sizeof(*control), GFP_KERNEL);
@@ -704,10 +713,11 @@ static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user
         return result;
 }
 
-int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_value_t *control)
+int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
+                       struct snd_ctl_elem_value *control)
 {
-        snd_kcontrol_t *kctl;
-        snd_kcontrol_volatile_t *vd;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
         int result, indirect;
 
@@ -741,9 +751,10 @@ int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_valu
         return result;
 }
 
-static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __user *_control)
+static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
+                                   struct snd_ctl_elem_value __user *_control)
 {
-        snd_ctl_elem_value_t *control;
+        struct snd_ctl_elem_value *control;
         int result;
 
         control = kmalloc(sizeof(*control), GFP_KERNEL);
@@ -761,12 +772,13 @@ static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __
         return result;
 }
 
-static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
+static int snd_ctl_elem_lock(struct snd_ctl_file *file,
+                             struct snd_ctl_elem_id __user *_id)
 {
-        snd_card_t *card = file->card;
-        snd_ctl_elem_id_t id;
-        snd_kcontrol_t *kctl;
-        snd_kcontrol_volatile_t *vd;
+        struct snd_card *card = file->card;
+        struct snd_ctl_elem_id id;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
         int result;
         
         if (copy_from_user(&id, _id, sizeof(id)))
@@ -789,12 +801,13 @@ static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id
         return result;
 }
 
-static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
+static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
+                               struct snd_ctl_elem_id __user *_id)
 {
-        snd_card_t *card = file->card;
-        snd_ctl_elem_id_t id;
-        snd_kcontrol_t *kctl;
-        snd_kcontrol_volatile_t *vd;
+        struct snd_card *card = file->card;
+        struct snd_ctl_elem_id id;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_volatile *vd;
         int result;
         
         if (copy_from_user(&id, _id, sizeof(id)))
@@ -820,14 +833,15 @@ static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_
 }
 
 struct user_element {
-        snd_ctl_elem_info_t info;
+        struct snd_ctl_elem_info info;
         void *elem_data;                /* element data */
         unsigned long elem_data_size;   /* size of element data in bytes */
         void *priv_data;                /* private data (like strings for enumerated type) */
         unsigned long priv_data_size;   /* size of private data in bytes */
 };
 
-static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_info *uinfo)
 {
         struct user_element *ue = kcontrol->private_data;
 
@@ -835,7 +849,8 @@ static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
         return 0;
 }
 
-static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
 {
         struct user_element *ue = kcontrol->private_data;
 
@@ -843,7 +858,8 @@ static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
         return 0;
 }
 
-static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
 {
         int change;
         struct user_element *ue = kcontrol->private_data;
@@ -854,15 +870,16 @@ static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
         return change;
 }
 
-static void snd_ctl_elem_user_free(snd_kcontrol_t * kcontrol)
+static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
 {
         kfree(kcontrol->private_data);
 }
 
-static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int replace)
+static int snd_ctl_elem_add(struct snd_ctl_file *file,
+                            struct snd_ctl_elem_info *info, int replace)
 {
-        snd_card_t *card = file->card;
-        snd_kcontrol_t kctl, *_kctl;
+        struct snd_card *card = file->card;
+        struct snd_kcontrol kctl, *_kctl;
         unsigned int access;
         long private_size;
         struct user_element *ue;
@@ -873,7 +890,8 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int
         if (info->count > 1024)
                 return -EINVAL;
         access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
-                (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE));
+                (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
+                                 SNDRV_CTL_ELEM_ACCESS_INACTIVE));
         info->id.numid = 0;
         memset(&kctl, 0, sizeof(kctl));
         down_write(&card->controls_rwsem);
@@ -921,7 +939,7 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int
                         return -EINVAL;
                 break;
         case SNDRV_CTL_ELEM_TYPE_IEC958:
-                private_size = sizeof(struct sndrv_aes_iec958);
+                private_size = sizeof(struct snd_aes_iec958);
                 if (info->count != 1)
                         return -EINVAL;
                 break;
@@ -957,24 +975,26 @@ static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int
         return 0;
 }
 
-static int snd_ctl_elem_add_user(snd_ctl_file_t *file, snd_ctl_elem_info_t __user *_info, int replace)
+static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
+                                 struct snd_ctl_elem_info __user *_info, int replace)
 {
-        snd_ctl_elem_info_t info;
+        struct snd_ctl_elem_info info;
         if (copy_from_user(&info, _info, sizeof(info)))
                 return -EFAULT;
         return snd_ctl_elem_add(file, &info, replace);
 }
 
-static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
+static int snd_ctl_elem_remove(struct snd_ctl_file *file,
+                               struct snd_ctl_elem_id __user *_id)
 {
-        snd_ctl_elem_id_t id;
+        struct snd_ctl_elem_id id;
         int err;
 
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
         err = snd_ctl_remove_unlocked_id(file, &id);
         if (! err) {
-                snd_card_t *card = file->card;
+                struct snd_card *card = file->card;
                 down_write(&card->controls_rwsem);
                 card->user_ctl_count--;
                 up_write(&card->controls_rwsem);
@@ -982,7 +1002,7 @@ static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_
         return err;
 }
 
-static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr)
+static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
 {
         int subscribe;
         if (get_user(subscribe, ptr))
@@ -1007,7 +1027,7 @@ static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr)
 /*
  * change the power state
  */
-static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state)
+static int snd_ctl_set_power_state(struct snd_card *card, unsigned int power_state)
 {
         switch (power_state) {
         case SNDRV_CTL_POWER_D0:
@@ -1035,10 +1055,10 @@ static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state)
 
 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        snd_ctl_file_t *ctl;
-        snd_card_t *card;
+        struct snd_ctl_file *ctl;
+        struct snd_card *card;
         struct list_head *list;
-        snd_kctl_ioctl_t *p;
+        struct snd_kctl_ioctl *p;
         void __user *argp = (void __user *)arg;
         int __user *ip = argp;
         int err;
@@ -1094,7 +1114,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg
         }
         down_read(&snd_ioctl_rwsem);
         list_for_each(list, &snd_control_ioctls) {
-                p = list_entry(list, snd_kctl_ioctl_t, list);
+                p = list_entry(list, struct snd_kctl_ioctl, list);
                 err = p->fioctl(card, ctl, cmd, arg);
                 if (err != -ENOIOCTLCMD) {
                         up_read(&snd_ioctl_rwsem);
@@ -1106,9 +1126,10 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg
         return -ENOTTY;
 }
 
-static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count, loff_t * offset)
+static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
+                            size_t count, loff_t * offset)
 {
-        snd_ctl_file_t *ctl;
+        struct snd_ctl_file *ctl;
         int err = 0;
         ssize_t result = 0;
 
@@ -1116,12 +1137,12 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count
         snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO);
         if (!ctl->subscribed)
                 return -EBADFD;
-        if (count < sizeof(snd_ctl_event_t))
+        if (count < sizeof(struct snd_ctl_event))
                 return -EINVAL;
         spin_lock_irq(&ctl->read_lock);
-        while (count >= sizeof(snd_ctl_event_t)) {
-                snd_ctl_event_t ev;
-                snd_kctl_event_t *kev;
+        while (count >= sizeof(struct snd_ctl_event)) {
+                struct snd_ctl_event ev;
+                struct snd_kctl_event *kev;
                 while (list_empty(&ctl->events)) {
                         wait_queue_t wait;
                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
@@ -1145,14 +1166,14 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count
                 list_del(&kev->list);
                 spin_unlock_irq(&ctl->read_lock);
                 kfree(kev);
-                if (copy_to_user(buffer, &ev, sizeof(snd_ctl_event_t))) {
+                if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
                         err = -EFAULT;
                         goto __end;
                 }
                 spin_lock_irq(&ctl->read_lock);
-                buffer += sizeof(snd_ctl_event_t);
-                count -= sizeof(snd_ctl_event_t);
-                result += sizeof(snd_ctl_event_t);
+                buffer += sizeof(struct snd_ctl_event);
+                count -= sizeof(struct snd_ctl_event);
+                result += sizeof(struct snd_ctl_event);
         }
       __end_lock:
         spin_unlock_irq(&ctl->read_lock);
@@ -1163,7 +1184,7 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count
 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
 {
         unsigned int mask;
-        snd_ctl_file_t *ctl;
+        struct snd_ctl_file *ctl;
 
         ctl = file->private_data;
         if (!ctl->subscribed)
@@ -1183,9 +1204,9 @@ static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
  */
 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
 {
-        snd_kctl_ioctl_t *pn;
+        struct snd_kctl_ioctl *pn;
 
-        pn = kzalloc(sizeof(snd_kctl_ioctl_t), GFP_KERNEL);
+        pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
         if (pn == NULL)
                 return -ENOMEM;
         pn->fioctl = fcn;
@@ -1210,15 +1231,16 @@ int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
 /*
  * de-register the device-specific control-ioctls.
  */
-static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
+static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
+                                     struct list_head *lists)
 {
         struct list_head *list;
-        snd_kctl_ioctl_t *p;
+        struct snd_kctl_ioctl *p;
 
         snd_assert(fcn != NULL, return -EINVAL);
         down_write(&snd_ioctl_rwsem);
         list_for_each(list, lists) {
-                p = list_entry(list, snd_kctl_ioctl_t, list);
+                p = list_entry(list, struct snd_kctl_ioctl, list);
                 if (p->fioctl == fcn) {
                         list_del(&p->list);
                         up_write(&snd_ioctl_rwsem);
@@ -1246,7 +1268,7 @@ int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
 
 static int snd_ctl_fasync(int fd, struct file * file, int on)
 {
-        snd_ctl_file_t *ctl;
+        struct snd_ctl_file *ctl;
         int err;
         ctl = file->private_data;
         err = fasync_helper(fd, file, on, &ctl->fasync);
@@ -1280,7 +1302,7 @@ static struct file_operations snd_ctl_f_ops =
         .fasync =       snd_ctl_fasync,
 };
 
-static snd_minor_t snd_ctl_reg =
+static struct snd_minor snd_ctl_reg =
 {
         .comment =      "ctl",
         .f_ops =        &snd_ctl_f_ops,
@@ -1289,9 +1311,9 @@ static snd_minor_t snd_ctl_reg =
 /*
  * registration of the control device
  */
-static int snd_ctl_dev_register(snd_device_t *device)
+static int snd_ctl_dev_register(struct snd_device *device)
 {
-        snd_card_t *card = device->device_data;
+        struct snd_card *card = device->device_data;
         int err, cardnum;
         char name[16];
 
@@ -1308,11 +1330,11 @@ static int snd_ctl_dev_register(snd_device_t *device)
 /*
  * disconnection of the control device
  */
-static int snd_ctl_dev_disconnect(snd_device_t *device)
+static int snd_ctl_dev_disconnect(struct snd_device *device)
 {
-        snd_card_t *card = device->device_data;
+        struct snd_card *card = device->device_data;
         struct list_head *flist;
-        snd_ctl_file_t *ctl;
+        struct snd_ctl_file *ctl;
 
         down_read(&card->controls_rwsem);
         list_for_each(flist, &card->ctl_files) {
@@ -1327,10 +1349,10 @@ static int snd_ctl_dev_disconnect(snd_device_t *device)
 /*
  * free all controls
  */
-static int snd_ctl_dev_free(snd_device_t *device)
+static int snd_ctl_dev_free(struct snd_device *device)
 {
-        snd_card_t *card = device->device_data;
-        snd_kcontrol_t *control;
+        struct snd_card *card = device->device_data;
+        struct snd_kcontrol *control;
 
         down_write(&card->controls_rwsem);
         while (!list_empty(&card->controls)) {
@@ -1344,9 +1366,9 @@ static int snd_ctl_dev_free(snd_device_t *device)
 /*
  * de-registration of the control device
  */
-static int snd_ctl_dev_unregister(snd_device_t *device)
+static int snd_ctl_dev_unregister(struct snd_device *device)
 {
-        snd_card_t *card = device->device_data;
+        struct snd_card *card = device->device_data;
         int err, cardnum;
 
         snd_assert(card != NULL, return -ENXIO);
@@ -1361,9 +1383,9 @@ static int snd_ctl_dev_unregister(snd_device_t *device)
  * create control core:
  * called from init.c
  */
-int snd_ctl_create(snd_card_t *card)
+int snd_ctl_create(struct snd_card *card)
 {
-        static snd_device_ops_t ops = {
+        static struct snd_device_ops ops = {
                 .dev_free = snd_ctl_dev_free,
                 .dev_register = snd_ctl_dev_register,
                 .dev_disconnect = snd_ctl_dev_disconnect,
diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c
index 207c7de5129c..418c6d4e5daf 100644
--- a/sound/core/control_compat.c
+++ b/sound/core/control_compat.c
@@ -22,7 +22,7 @@
 
 #include <linux/compat.h>
 
-struct sndrv_ctl_elem_list32 {
+struct snd_ctl_elem_list32 {
         u32 offset;
         u32 space;
         u32 used;
@@ -31,9 +31,10 @@ struct sndrv_ctl_elem_list32 {
         unsigned char reserved[50];
 } /* don't set packed attribute here */;
 
-static int snd_ctl_elem_list_compat(snd_card_t *card, struct sndrv_ctl_elem_list32 __user *data32)
+static int snd_ctl_elem_list_compat(struct snd_card *card,
+                                    struct snd_ctl_elem_list32 __user *data32)
 {
-        struct sndrv_ctl_elem_list __user *data;
+        struct snd_ctl_elem_list __user *data;
         compat_caddr_t ptr;
         int err;
 
@@ -60,8 +61,8 @@ static int snd_ctl_elem_list_compat(snd_card_t *card, struct sndrv_ctl_elem_list
  * it uses union, so the things are not easy..
  */
 
-struct sndrv_ctl_elem_info32 {
-        struct sndrv_ctl_elem_id id; // the size of struct is same
+struct snd_ctl_elem_info32 {
+        struct snd_ctl_elem_id id; // the size of struct is same
         s32 type;
         u32 access;
         u32 count;
@@ -87,9 +88,10 @@ struct sndrv_ctl_elem_info32 {
         unsigned char reserved[64];
 } __attribute__((packed));
 
-static int snd_ctl_elem_info_compat(snd_ctl_file_t *ctl, struct sndrv_ctl_elem_info32 __user *data32)
+static int snd_ctl_elem_info_compat(struct snd_ctl_file *ctl,
+                                    struct snd_ctl_elem_info32 __user *data32)
 {
-        struct sndrv_ctl_elem_info *data;
+        struct snd_ctl_elem_info *data;
         int err;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -146,8 +148,8 @@ static int snd_ctl_elem_info_compat(snd_ctl_file_t *ctl, struct sndrv_ctl_elem_i
 }
 
 /* read / write */
-struct sndrv_ctl_elem_value32 {
-        struct sndrv_ctl_elem_id id;
+struct snd_ctl_elem_value32 {
+        struct snd_ctl_elem_id id;
         unsigned int indirect;  /* bit-field causes misalignment */
         union {
                 s32 integer[128];
@@ -161,10 +163,11 @@ struct sndrv_ctl_elem_value32 {
 
 
 /* get the value type and count of the control */
-static int get_ctl_type(snd_card_t *card, snd_ctl_elem_id_t *id, int *countp)
+static int get_ctl_type(struct snd_card *card, struct snd_ctl_elem_id *id,
+                        int *countp)
 {
-        snd_kcontrol_t *kctl;
-        snd_ctl_elem_info_t info;
+        struct snd_kcontrol *kctl;
+        struct snd_ctl_elem_info info;
         int err;
 
         down_read(&card->controls_rwsem);
@@ -193,15 +196,15 @@ static int get_elem_size(int type, int count)
         case SNDRV_CTL_ELEM_TYPE_BYTES:
                 return 512;
         case SNDRV_CTL_ELEM_TYPE_IEC958:
-                return sizeof(struct sndrv_aes_iec958);
+                return sizeof(struct snd_aes_iec958);
         default:
                 return -1;
         }
 }
 
-static int copy_ctl_value_from_user(snd_card_t *card,
-                                    struct sndrv_ctl_elem_value *data,
-                                    struct sndrv_ctl_elem_value32 __user *data32,
+static int copy_ctl_value_from_user(struct snd_card *card,
+                                    struct snd_ctl_elem_value *data,
+                                    struct snd_ctl_elem_value32 __user *data32,
                                     int *typep, int *countp)
 {
         int i, type, count, size;
@@ -242,8 +245,8 @@ static int copy_ctl_value_from_user(snd_card_t *card,
 }
 
 /* restore the value to 32bit */
-static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32,
-                                  struct sndrv_ctl_elem_value *data,
+static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32,
+                                  struct snd_ctl_elem_value *data,
                                   int type, int count)
 {
         int i, size;
@@ -265,10 +268,10 @@ static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32,
         return 0;
 }
 
-static int snd_ctl_elem_read_user_compat(snd_card_t *card, 
-                                         struct sndrv_ctl_elem_value32 __user *data32)
+static int snd_ctl_elem_read_user_compat(struct snd_card *card, 
+                                         struct snd_ctl_elem_value32 __user *data32)
 {
-        struct sndrv_ctl_elem_value *data;
+        struct snd_ctl_elem_value *data;
         int err, type, count;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -285,10 +288,10 @@ static int snd_ctl_elem_read_user_compat(snd_card_t *card,
         return err;
 }
 
-static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file,
-                                          struct sndrv_ctl_elem_value32 __user *data32)
+static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file,
+                                          struct snd_ctl_elem_value32 __user *data32)
 {
-        struct sndrv_ctl_elem_value *data;
+        struct snd_ctl_elem_value *data;
         int err, type, count;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -306,11 +309,11 @@ static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file,
 }
 
 /* add or replace a user control */
-static int snd_ctl_elem_add_compat(snd_ctl_file_t *file,
-                                   struct sndrv_ctl_elem_info32 __user *data32,
+static int snd_ctl_elem_add_compat(struct snd_ctl_file *file,
+                                   struct snd_ctl_elem_info32 __user *data32,
                                    int replace)
 {
-        struct sndrv_ctl_elem_info *data;
+        struct snd_ctl_elem_info *data;
         int err;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
@@ -355,17 +358,17 @@ static int snd_ctl_elem_add_compat(snd_ctl_file_t *file,
 }  
 
 enum {
-        SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct sndrv_ctl_elem_list32),
-        SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct sndrv_ctl_elem_info32),
-        SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct sndrv_ctl_elem_value32),
-        SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct sndrv_ctl_elem_value32),
-        SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct sndrv_ctl_elem_info32),
-        SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct sndrv_ctl_elem_info32),
+        SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct snd_ctl_elem_list32),
+        SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct snd_ctl_elem_info32),
+        SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct snd_ctl_elem_value32),
+        SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct snd_ctl_elem_value32),
+        SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct snd_ctl_elem_info32),
+        SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct snd_ctl_elem_info32),
 };
 
 static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        snd_ctl_file_t *ctl;
+        struct snd_ctl_file *ctl;
         struct list_head *list;
         void __user *argp = compat_ptr(arg);
         int err;
@@ -398,7 +401,7 @@ static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, uns
 
         down_read(&snd_ioctl_rwsem);
         list_for_each(list, &snd_control_compat_ioctls) {
-                snd_kctl_ioctl_t *p = list_entry(list, snd_kctl_ioctl_t, list);
+                struct snd_kctl_ioctl *p = list_entry(list, struct snd_kctl_ioctl, list);
                 if (p->fioctl) {
                         err = p->fioctl(ctl->card, ctl, cmd, arg);
                         if (err != -ENOIOCTLCMD) {