summaryrefslogtreecommitdiffstats
path: root/sound/core/control.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/core/control.c')
-rw-r--r--sound/core/control.c338
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,
OpenPOWER on IntegriCloud