diff options
Diffstat (limited to 'sound/core/control.c')
| -rw-r--r-- | sound/core/control.c | 338 |
1 files changed, 158 insertions, 180 deletions
diff --git a/sound/core/control.c b/sound/core/control.c index 212c46a94376..abd62f943726 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); @@ -49,13 +47,12 @@ static LIST_HEAD(snd_control_compat_ioctls); 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]; + card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL); if (!card) { err = -ENODEV; goto __error1; @@ -93,9 +90,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 +107,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 +134,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,21 +181,23 @@ 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); - if (kctl == NULL) + kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); + if (kctl == NULL) { + snd_printk(KERN_ERR "Cannot allocate control instance\n"); return NULL; + } *kctl = *control; for (idx = 0; idx < kctl->count; idx++) kctl->vd[idx].access = access; @@ -209,15 +209,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 +250,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 +259,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 +276,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,12 +305,14 @@ 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); + snd_assert(card != NULL, return -EINVAL); + if (! kcontrol) + return -EINVAL; snd_assert(kcontrol->info != NULL, return -EINVAL); id = kcontrol->id; down_write(&card->controls_rwsem); @@ -350,9 +353,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 +378,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 +404,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 +438,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 +468,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 +494,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 +522,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 +539,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 +547,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 +566,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 +595,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 +612,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 +650,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 +665,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 +695,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 +716,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 +754,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 +775,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 +804,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 +836,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 +852,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 +861,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 +873,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 +893,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 +942,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 +978,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 +1005,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)) @@ -1003,42 +1026,12 @@ static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr) return 0; } -#ifdef CONFIG_PM -/* - * change the power state - */ -static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state) -{ - switch (power_state) { - case SNDRV_CTL_POWER_D0: - if (card->power_state != power_state) { - card->pm_resume(card); - snd_power_change_state(card, power_state); - } - break; - case SNDRV_CTL_POWER_D3hot: - if (card->power_state != power_state) { - card->pm_suspend(card, PMSG_SUSPEND); - snd_power_change_state(card, power_state); - } - break; - case SNDRV_CTL_POWER_D1: - case SNDRV_CTL_POWER_D2: - case SNDRV_CTL_POWER_D3cold: - /* not supported yet */ - default: - return -EINVAL; - } - return 0; -} -#endif - 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; @@ -1072,19 +1065,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: return snd_ctl_subscribe_events(ctl, ip); case SNDRV_CTL_IOCTL_POWER: - if (get_user(err, ip)) - return -EFAULT; - if (!capable(CAP_SYS_ADMIN)) - return -EPERM; -#ifdef CONFIG_PM - if (card->pm_suspend && card->pm_resume) { - snd_power_lock(card); - err = snd_ctl_set_power_state(card, err); - snd_power_unlock(card); - } else -#endif - err = -ENOPROTOOPT; - return err; + return -ENOPROTOOPT; case SNDRV_CTL_IOCTL_POWER_STATE: #ifdef CONFIG_PM return put_user(card->power_state, ip) ? -EFAULT : 0; @@ -1094,7 +1075,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 +1087,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 +1098,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 +1127,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 +1145,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 +1165,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 +1192,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 +1229,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,18 +1263,12 @@ static struct file_operations snd_ctl_f_ops = .fasync = snd_ctl_fasync, }; -static snd_minor_t snd_ctl_reg = -{ - .comment = "ctl", - .f_ops = &snd_ctl_f_ops, -}; - /* * 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]; @@ -1299,8 +1276,8 @@ static int snd_ctl_dev_register(snd_device_t *device) cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); sprintf(name, "controlC%i", cardnum); - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, - card, 0, &snd_ctl_reg, name)) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, + &snd_ctl_f_ops, card, name)) < 0) return err; return 0; } @@ -1308,11 +1285,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 +1304,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,15 +1321,16 @@ 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); cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); - if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, card, 0)) < 0) + if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, + card, -1)) < 0) return err; return snd_ctl_dev_free(device); } @@ -1361,9 +1339,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, |