redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

[ALSA] Remove xxx_t typedefs: Controls

Browse source 
Modules: Control Midlevel

Remove xxx_t typedefs from the core controls.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2005-11-17 13:53:23 +01:00 committed by Jaroslav Kysela
parent 512bbd6a85
commit 82e9bae6fd
3 changed files with 228 additions and 213 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
include/sound/control.h
View file

@ -24,24 +24,14 @@
#include <sound/asound.h> #include <sound/asound.h>
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
typedef struct sndrv_ctl_card_info snd_ctl_card_info_t;
typedef enum sndrv_ctl_elem_type snd_ctl_elem_type_t;
typedef enum sndrv_ctl_elem_iface snd_ctl_elem_iface_t;
typedef struct sndrv_ctl_elem_id snd_ctl_elem_id_t;
typedef struct sndrv_ctl_elem_list snd_ctl_elem_list_t;
typedef struct sndrv_ctl_elem_info snd_ctl_elem_info_t;
typedef struct sndrv_ctl_elem_value snd_ctl_elem_value_t;
typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
typedef struct sndrv_ctl_event snd_ctl_event_t;
#define snd_kcontrol_chip(kcontrol) ((kcontrol)->private_data) #define snd_kcontrol_chip(kcontrol) ((kcontrol)->private_data)
typedef int (snd_kcontrol_info_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo); struct snd_kcontrol;
typedef int (snd_kcontrol_get_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); typedef int (snd_kcontrol_info_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_info * uinfo);
typedef int (snd_kcontrol_put_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); typedef int (snd_kcontrol_get_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol);
typedef int (snd_kcontrol_put_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol);
typedef struct _snd_kcontrol_new { struct snd_kcontrol_new {
snd_ctl_elem_iface_t iface; /* interface identifier */ snd_ctl_elem_iface_t iface; /* interface identifier */
unsigned int device; /* device/client number */ unsigned int device; /* device/client number */
unsigned int subdevice; /* subdevice (substream) number */ unsigned int subdevice; /* subdevice (substream) number */
@ -53,40 +43,40 @@ typedef struct _snd_kcontrol_new {
snd_kcontrol_get_t *get; snd_kcontrol_get_t *get;
snd_kcontrol_put_t *put; snd_kcontrol_put_t *put;
unsigned long private_value; unsigned long private_value;
} snd_kcontrol_new_t; };
typedef struct _snd_kcontrol_volatile { struct snd_kcontrol_volatile {
snd_ctl_file_t *owner; /* locked */ struct snd_ctl_file *owner; /* locked */
pid_t owner_pid; pid_t owner_pid;
unsigned int access; /* access rights */ unsigned int access; /* access rights */
} snd_kcontrol_volatile_t; };
struct _snd_kcontrol { struct snd_kcontrol {
struct list_head list; /* list of controls */ struct list_head list; /* list of controls */
snd_ctl_elem_id_t id; struct snd_ctl_elem_id id;
unsigned int count; /* count of same elements */ unsigned int count; /* count of same elements */
snd_kcontrol_info_t *info; snd_kcontrol_info_t *info;
snd_kcontrol_get_t *get; snd_kcontrol_get_t *get;
snd_kcontrol_put_t *put; snd_kcontrol_put_t *put;
unsigned long private_value; unsigned long private_value;
void *private_data; void *private_data;
void (*private_free)(snd_kcontrol_t *kcontrol); void (*private_free)(struct snd_kcontrol *kcontrol);
snd_kcontrol_volatile_t vd[0]; /* volatile data */ struct snd_kcontrol_volatile vd[0]; /* volatile data */
}; };
#define snd_kcontrol(n) list_entry(n, snd_kcontrol_t, list) #define snd_kcontrol(n) list_entry(n, struct snd_kcontrol, list)
typedef struct _snd_kctl_event { struct snd_kctl_event {
struct list_head list; /* list of events */ struct list_head list; /* list of events */
snd_ctl_elem_id_t id; struct snd_ctl_elem_id id;
unsigned int mask; unsigned int mask;
} snd_kctl_event_t; };
#define snd_kctl_event(n) list_entry(n, snd_kctl_event_t, list) #define snd_kctl_event(n) list_entry(n, struct snd_kctl_event, list)
struct _snd_ctl_file { struct snd_ctl_file {
struct list_head list; /* list of all control files */ struct list_head list; /* list of all control files */
snd_card_t *card; struct snd_card *card;
pid_t pid; pid_t pid;
int prefer_pcm_subdevice; int prefer_pcm_subdevice;
int prefer_rawmidi_subdevice; int prefer_rawmidi_subdevice;
@ -97,25 +87,25 @@ struct _snd_ctl_file {
struct list_head events; /* waiting events for read */ struct list_head events; /* waiting events for read */
}; };
#define snd_ctl_file(n) list_entry(n, snd_ctl_file_t, list) #define snd_ctl_file(n) list_entry(n, struct snd_ctl_file, list)
typedef int (*snd_kctl_ioctl_func_t) (snd_card_t * card, typedef int (*snd_kctl_ioctl_func_t) (struct snd_card * card,
snd_ctl_file_t * control, struct snd_ctl_file * control,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
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);
snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * kcontrol, unsigned int access); struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol * kcontrol, unsigned int access);
snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * kcontrolnew, void * private_data); struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new * kcontrolnew, void * private_data);
void snd_ctl_free_one(snd_kcontrol_t * kcontrol); void snd_ctl_free_one(struct snd_kcontrol * kcontrol);
int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol); int snd_ctl_add(struct snd_card * card, struct snd_kcontrol * kcontrol);
int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol); int snd_ctl_remove(struct snd_card * card, struct snd_kcontrol * kcontrol);
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);
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 *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);
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);
int snd_ctl_create(snd_card_t *card); int snd_ctl_create(struct snd_card *card);
int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn); int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn);
int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn); int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn);
@ -127,20 +117,20 @@ int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn);
#define snd_ctl_unregister_ioctl_compat(fcn) #define snd_ctl_unregister_ioctl_compat(fcn)
#endif #endif
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);
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);
static inline unsigned int snd_ctl_get_ioffnum(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) static inline unsigned int snd_ctl_get_ioffnum(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id)
{ {
return id->numid - kctl->id.numid; return id->numid - kctl->id.numid;
} }
static inline unsigned int snd_ctl_get_ioffidx(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) static inline unsigned int snd_ctl_get_ioffidx(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id)
{ {
return id->index - kctl->id.index; return id->index - kctl->id.index;
} }
static inline unsigned int snd_ctl_get_ioff(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) static inline unsigned int snd_ctl_get_ioff(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id)
{ {
if (id->numid) { if (id->numid) {
return snd_ctl_get_ioffnum(kctl, id); return snd_ctl_get_ioffnum(kctl, id);
@ -149,8 +139,8 @@ static inline unsigned int snd_ctl_get_ioff(snd_kcontrol_t *kctl, snd_ctl_elem_i
} }
} }
static inline snd_ctl_elem_id_t *snd_ctl_build_ioff(snd_ctl_elem_id_t *dst_id, static inline struct snd_ctl_elem_id *snd_ctl_build_ioff(struct snd_ctl_elem_id *dst_id,
snd_kcontrol_t *src_kctl, struct snd_kcontrol *src_kctl,
unsigned int offset) unsigned int offset)
{ {
*dst_id = src_kctl->id; *dst_id = src_kctl->id;

274
sound/core/control.c
View file

@ -34,12 +34,10 @@
/* max number of user-defined controls */ /* max number of user-defined controls */
#define MAX_USER_CONTROLS 32 #define MAX_USER_CONTROLS 32
typedef struct _snd_kctl_ioctl { struct snd_kctl_ioctl {
struct list_head list; /* list of all ioctls */ struct list_head list; /* list of all ioctls */
snd_kctl_ioctl_func_t fioctl; 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 DECLARE_RWSEM(snd_ioctl_rwsem);
static LIST_HEAD(snd_control_ioctls); 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)); int cardnum = SNDRV_MINOR_CARD(iminor(inode));
unsigned long flags; unsigned long flags;
snd_card_t *card; struct snd_card *card;
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
int err; int err;
card = snd_cards[cardnum]; card = snd_cards[cardnum];
@ -93,9 +91,9 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
return err; 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); spin_lock(&ctl->read_lock);
while (!list_empty(&ctl->events)) { while (!list_empty(&ctl->events)) {
@ -110,9 +108,9 @@ static int snd_ctl_release(struct inode *inode, struct file *file)
{ {
unsigned long flags; unsigned long flags;
struct list_head *list; struct list_head *list;
snd_card_t *card; struct snd_card *card;
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
snd_kcontrol_t *control; struct snd_kcontrol *control;
unsigned int idx; unsigned int idx;
ctl = file->private_data; ctl = file->private_data;
@ -137,12 +135,13 @@ static int snd_ctl_release(struct inode *inode, struct file *file)
return 0; 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; unsigned long flags;
struct list_head *flist; struct list_head *flist;
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
snd_kctl_event_t *ev; struct snd_kctl_event *ev;
snd_assert(card != NULL && id != NULL, return); snd_assert(card != NULL && id != NULL, return);
read_lock(&card->ctl_files_rwlock); 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 * @control: the control template
* @access: the default control access * @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). * to the new instance. It does not copy volatile data (access).
* *
* Returns the pointer of the new instance, or NULL on failure. * 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; unsigned int idx;
snd_assert(control != NULL, return NULL); snd_assert(control != NULL, return NULL);
snd_assert(control->count > 0, 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) if (kctl == NULL)
return NULL; return NULL;
*kctl = *control; *kctl = *control;
@ -209,15 +208,16 @@ snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access)
* @ncontrol: the initialization record * @ncontrol: the initialization record
* @private_data: the private data to set * @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 * 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. * 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. * 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; unsigned int access;
snd_assert(ncontrol != NULL, return NULL); 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(). * or snd_ctl_new1().
* Don't call this after the control was added to the card. * 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) {
if (kcontrol->private_free) 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) unsigned int count)
{ {
struct list_head *list; struct list_head *list;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
list_for_each(list, &card->controls) { list_for_each(list, &card->controls) {
kctl = snd_kcontrol(list); kctl = snd_kcontrol(list);
@ -275,7 +275,7 @@ static unsigned int snd_ctl_hole_check(snd_card_t * card,
return card->last_numid; 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; 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. * 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; unsigned int idx;
snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); 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. * 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; unsigned int idx;
snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); 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. * 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; int ret;
down_write(&card->controls_rwsem); 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. * 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; struct snd_card *card = file->card;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
int idx, ret; int idx, ret;
down_write(&card->controls_rwsem); 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. * 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); down_write(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, src_id); 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 * The caller must down card->controls_rwsem before calling this function
* (if the race condition can happen). * (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; struct list_head *list;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_assert(card != NULL && numid != 0, return NULL); snd_assert(card != NULL && numid != 0, return NULL);
list_for_each(list, &card->controls) { 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 * The caller must down card->controls_rwsem before calling this function
* (if the race condition can happen). * (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; struct list_head *list;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_assert(card != NULL && id != NULL, return NULL); snd_assert(card != NULL && id != NULL, return NULL);
if (id->numid != 0) 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; 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) unsigned int cmd, void __user *arg)
{ {
snd_ctl_card_info_t *info; struct snd_ctl_card_info *info;
info = kzalloc(sizeof(*info), GFP_KERNEL); info = kzalloc(sizeof(*info), GFP_KERNEL);
if (! info) 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->mixername, card->mixername, sizeof(info->mixername));
strlcpy(info->components, card->components, sizeof(info->components)); strlcpy(info->components, card->components, sizeof(info->components));
up_read(&snd_ioctl_rwsem); 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); kfree(info);
return -EFAULT; return -EFAULT;
} }
@ -541,12 +544,13 @@ static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
return 0; 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; struct list_head *plist;
snd_ctl_elem_list_t list; struct snd_ctl_elem_list list;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_ctl_elem_id_t *dst, *id; struct snd_ctl_elem_id *dst, *id;
unsigned int offset, space, first, jidx; unsigned int offset, space, first, jidx;
if (copy_from_user(&list, _list, sizeof(list))) 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; return -ENOMEM;
if (space > 0) { if (space > 0) {
/* allocate temporary buffer for atomic operation */ /* 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) if (dst == NULL)
return -ENOMEM; return -ENOMEM;
down_read(&card->controls_rwsem); 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; offset = 0;
} }
up_read(&card->controls_rwsem); 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); vfree(dst);
return -EFAULT; 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; 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; struct snd_card *card = ctl->card;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_kcontrol_volatile_t *vd; struct snd_kcontrol_volatile *vd;
unsigned int index_offset; unsigned int index_offset;
int result; 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; 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; int result;
if (copy_from_user(&info, _info, sizeof(info))) 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; 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; struct snd_kcontrol *kctl;
snd_kcontrol_volatile_t *vd; struct snd_kcontrol_volatile *vd;
unsigned int index_offset; unsigned int index_offset;
int result, indirect; int result, indirect;
@ -684,9 +692,10 @@ int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control)
return result; 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; int result;
control = kmalloc(sizeof(*control), GFP_KERNEL); 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; 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; struct snd_kcontrol *kctl;
snd_kcontrol_volatile_t *vd; struct snd_kcontrol_volatile *vd;
unsigned int index_offset; unsigned int index_offset;
int result, indirect; 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; 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; int result;
control = kmalloc(sizeof(*control), GFP_KERNEL); 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; 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; struct snd_card *card = file->card;
snd_ctl_elem_id_t id; struct snd_ctl_elem_id id;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_kcontrol_volatile_t *vd; struct snd_kcontrol_volatile *vd;
int result; int result;
if (copy_from_user(&id, _id, sizeof(id))) 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; 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; struct snd_card *card = file->card;
snd_ctl_elem_id_t id; struct snd_ctl_elem_id id;
snd_kcontrol_t *kctl; struct snd_kcontrol *kctl;
snd_kcontrol_volatile_t *vd; struct snd_kcontrol_volatile *vd;
int result; int result;
if (copy_from_user(&id, _id, sizeof(id))) 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 { struct user_element {
snd_ctl_elem_info_t info; struct snd_ctl_elem_info info;
void *elem_data; /* element data */ void *elem_data; /* element data */
unsigned long elem_data_size; /* size of element data in bytes */ unsigned long elem_data_size; /* size of element data in bytes */
void *priv_data; /* private data (like strings for enumerated type) */ void *priv_data; /* private data (like strings for enumerated type) */
unsigned long priv_data_size; /* size of private data in bytes */ 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; 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; 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; 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; 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; int change;
struct user_element *ue = kcontrol->private_data; 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; 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); 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; struct snd_card *card = file->card;
snd_kcontrol_t kctl, *_kctl; struct snd_kcontrol kctl, *_kctl;
unsigned int access; unsigned int access;
long private_size; long private_size;
struct user_element *ue; 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) if (info->count > 1024)
return -EINVAL; return -EINVAL;
access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE : 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; info->id.numid = 0;
memset(&kctl, 0, sizeof(kctl)); memset(&kctl, 0, sizeof(kctl));
down_write(&card->controls_rwsem); 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; return -EINVAL;
break; break;
case SNDRV_CTL_ELEM_TYPE_IEC958: case SNDRV_CTL_ELEM_TYPE_IEC958:
private_size = sizeof(struct sndrv_aes_iec958); private_size = sizeof(struct snd_aes_iec958);
if (info->count != 1) if (info->count != 1)
return -EINVAL; return -EINVAL;
break; 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; 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))) if (copy_from_user(&info, _info, sizeof(info)))
return -EFAULT; return -EFAULT;
return snd_ctl_elem_add(file, &info, replace); 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; int err;
if (copy_from_user(&id, _id, sizeof(id))) if (copy_from_user(&id, _id, sizeof(id)))
return -EFAULT; return -EFAULT;
err = snd_ctl_remove_unlocked_id(file, &id); err = snd_ctl_remove_unlocked_id(file, &id);
if (! err) { if (! err) {
snd_card_t *card = file->card; struct snd_card *card = file->card;
down_write(&card->controls_rwsem); down_write(&card->controls_rwsem);
card->user_ctl_count--; card->user_ctl_count--;
up_write(&card->controls_rwsem); 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; 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; int subscribe;
if (get_user(subscribe, ptr)) 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 * 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) { switch (power_state) {
case SNDRV_CTL_POWER_D0: 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) static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
snd_card_t *card; struct snd_card *card;
struct list_head *list; struct list_head *list;
snd_kctl_ioctl_t *p; struct snd_kctl_ioctl *p;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
int __user *ip = argp; int __user *ip = argp;
int err; 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); down_read(&snd_ioctl_rwsem);
list_for_each(list, &snd_control_ioctls) { 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); err = p->fioctl(card, ctl, cmd, arg);
if (err != -ENOIOCTLCMD) { if (err != -ENOIOCTLCMD) {
up_read(&snd_ioctl_rwsem); 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; 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; int err = 0;
ssize_t result = 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); snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO);
if (!ctl->subscribed) if (!ctl->subscribed)
return -EBADFD; return -EBADFD;
if (count < sizeof(snd_ctl_event_t)) if (count < sizeof(struct snd_ctl_event))
return -EINVAL; return -EINVAL;
spin_lock_irq(&ctl->read_lock); spin_lock_irq(&ctl->read_lock);
while (count >= sizeof(snd_ctl_event_t)) { while (count >= sizeof(struct snd_ctl_event)) {
snd_ctl_event_t ev; struct snd_ctl_event ev;
snd_kctl_event_t *kev; struct snd_kctl_event *kev;
while (list_empty(&ctl->events)) { while (list_empty(&ctl->events)) {
wait_queue_t wait; wait_queue_t wait;
if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 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); list_del(&kev->list);
spin_unlock_irq(&ctl->read_lock); spin_unlock_irq(&ctl->read_lock);
kfree(kev); 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; err = -EFAULT;
goto __end; goto __end;
} }
spin_lock_irq(&ctl->read_lock); spin_lock_irq(&ctl->read_lock);
buffer += sizeof(snd_ctl_event_t); buffer += sizeof(struct snd_ctl_event);
count -= sizeof(snd_ctl_event_t); count -= sizeof(struct snd_ctl_event);
result += sizeof(snd_ctl_event_t); result += sizeof(struct snd_ctl_event);
} }
__end_lock: __end_lock:
spin_unlock_irq(&ctl->read_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) static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
{ {
unsigned int mask; unsigned int mask;
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
ctl = file->private_data; ctl = file->private_data;
if (!ctl->subscribed) 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) 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) if (pn == NULL)
return -ENOMEM; return -ENOMEM;
pn->fioctl = fcn; 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. * 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; struct list_head *list;
snd_kctl_ioctl_t *p; struct snd_kctl_ioctl *p;
snd_assert(fcn != NULL, return -EINVAL); snd_assert(fcn != NULL, return -EINVAL);
down_write(&snd_ioctl_rwsem); down_write(&snd_ioctl_rwsem);
list_for_each(list, lists) { 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) { if (p->fioctl == fcn) {
list_del(&p->list); list_del(&p->list);
up_write(&snd_ioctl_rwsem); 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) static int snd_ctl_fasync(int fd, struct file * file, int on)
{ {
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
int err; int err;
ctl = file->private_data; ctl = file->private_data;
err = fasync_helper(fd, file, on, &ctl->fasync); err = fasync_helper(fd, file, on, &ctl->fasync);
@ -1280,7 +1302,7 @@ static struct file_operations snd_ctl_f_ops =
.fasync = snd_ctl_fasync, .fasync = snd_ctl_fasync,
}; };
static snd_minor_t snd_ctl_reg = static struct snd_minor snd_ctl_reg =
{ {
.comment = "ctl", .comment = "ctl",
.f_ops = &snd_ctl_f_ops, .f_ops = &snd_ctl_f_ops,
@ -1289,9 +1311,9 @@ static snd_minor_t snd_ctl_reg =
/* /*
* registration of the control device * 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; int err, cardnum;
char name[16]; char name[16];
@ -1308,11 +1330,11 @@ static int snd_ctl_dev_register(snd_device_t *device)
/* /*
* disconnection of the control 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; struct list_head *flist;
snd_ctl_file_t *ctl; struct snd_ctl_file *ctl;
down_read(&card->controls_rwsem); down_read(&card->controls_rwsem);
list_for_each(flist, &card->ctl_files) { list_for_each(flist, &card->ctl_files) {
@ -1327,10 +1349,10 @@ static int snd_ctl_dev_disconnect(snd_device_t *device)
/* /*
* free all controls * 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; struct snd_card *card = device->device_data;
snd_kcontrol_t *control; struct snd_kcontrol *control;
down_write(&card->controls_rwsem); down_write(&card->controls_rwsem);
while (!list_empty(&card->controls)) { 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 * 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; int err, cardnum;
snd_assert(card != NULL, return -ENXIO); snd_assert(card != NULL, return -ENXIO);
@ -1361,9 +1383,9 @@ static int snd_ctl_dev_unregister(snd_device_t *device)
* create control core: * create control core:
* called from init.c * 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_free = snd_ctl_dev_free,
.dev_register = snd_ctl_dev_register, .dev_register = snd_ctl_dev_register,
.dev_disconnect = snd_ctl_dev_disconnect, .dev_disconnect = snd_ctl_dev_disconnect,

73
sound/core/control_compat.c
View file

@ -22,7 +22,7 @@
#include <linux/compat.h> #include <linux/compat.h>
struct sndrv_ctl_elem_list32 { struct snd_ctl_elem_list32 {
u32 offset; u32 offset;
u32 space; u32 space;
u32 used; u32 used;
@ -31,9 +31,10 @@ struct sndrv_ctl_elem_list32 {
unsigned char reserved[50]; unsigned char reserved[50];
} /* don't set packed attribute here */; } /* 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; compat_caddr_t ptr;
int err; 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.. * it uses union, so the things are not easy..
*/ */
struct sndrv_ctl_elem_info32 { struct snd_ctl_elem_info32 {
struct sndrv_ctl_elem_id id; // the size of struct is same struct snd_ctl_elem_id id; // the size of struct is same
s32 type; s32 type;
u32 access; u32 access;
u32 count; u32 count;
@ -87,9 +88,10 @@ struct sndrv_ctl_elem_info32 {
unsigned char reserved[64]; unsigned char reserved[64];
} __attribute__((packed)); } __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; int err;
data = kzalloc(sizeof(*data), GFP_KERNEL); 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 */ /* read / write */
struct sndrv_ctl_elem_value32 { struct snd_ctl_elem_value32 {
struct sndrv_ctl_elem_id id; struct snd_ctl_elem_id id;
unsigned int indirect; /* bit-field causes misalignment */ unsigned int indirect; /* bit-field causes misalignment */
union { union {
s32 integer[128]; s32 integer[128];
@ -161,10 +163,11 @@ struct sndrv_ctl_elem_value32 {
/* get the value type and count of the control */ /* 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; struct snd_kcontrol *kctl;
snd_ctl_elem_info_t info; struct snd_ctl_elem_info info;
int err; int err;
down_read(&card->controls_rwsem); down_read(&card->controls_rwsem);
@ -193,15 +196,15 @@ static int get_elem_size(int type, int count)
case SNDRV_CTL_ELEM_TYPE_BYTES: case SNDRV_CTL_ELEM_TYPE_BYTES:
return 512; return 512;
case SNDRV_CTL_ELEM_TYPE_IEC958: case SNDRV_CTL_ELEM_TYPE_IEC958:
return sizeof(struct sndrv_aes_iec958); return sizeof(struct snd_aes_iec958);
default: default:
return -1; return -1;
} }
} }
static int copy_ctl_value_from_user(snd_card_t *card, static int copy_ctl_value_from_user(struct snd_card *card,
struct sndrv_ctl_elem_value *data, struct snd_ctl_elem_value *data,
struct sndrv_ctl_elem_value32 __user *data32, struct snd_ctl_elem_value32 __user *data32,
int *typep, int *countp) int *typep, int *countp)
{ {
int i, type, count, size; 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 */ /* restore the value to 32bit */
static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32, static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32,
struct sndrv_ctl_elem_value *data, struct snd_ctl_elem_value *data,
int type, int count) int type, int count)
{ {
int i, size; int i, size;
@ -265,10 +268,10 @@ static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32,
return 0; return 0;
} }
static int snd_ctl_elem_read_user_compat(snd_card_t *card, static int snd_ctl_elem_read_user_compat(struct snd_card *card,
struct sndrv_ctl_elem_value32 __user *data32) struct snd_ctl_elem_value32 __user *data32)
{ {
struct sndrv_ctl_elem_value *data; struct snd_ctl_elem_value *data;
int err, type, count; int err, type, count;
data = kzalloc(sizeof(*data), GFP_KERNEL); data = kzalloc(sizeof(*data), GFP_KERNEL);
@ -285,10 +288,10 @@ static int snd_ctl_elem_read_user_compat(snd_card_t *card,
return err; return err;
} }
static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file, static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file,
struct sndrv_ctl_elem_value32 __user *data32) struct snd_ctl_elem_value32 __user *data32)
{ {
struct sndrv_ctl_elem_value *data; struct snd_ctl_elem_value *data;
int err, type, count; int err, type, count;
data = kzalloc(sizeof(*data), GFP_KERNEL); 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 */ /* add or replace a user control */
static int snd_ctl_elem_add_compat(snd_ctl_file_t *file, static int snd_ctl_elem_add_compat(struct snd_ctl_file *file,
struct sndrv_ctl_elem_info32 __user *data32, struct snd_ctl_elem_info32 __user *data32,
int replace) int replace)
{ {
struct sndrv_ctl_elem_info *data; struct snd_ctl_elem_info *data;
int err; int err;
data = kzalloc(sizeof(*data), GFP_KERNEL); data = kzalloc(sizeof(*data), GFP_KERNEL);
@ -355,17 +358,17 @@ static int snd_ctl_elem_add_compat(snd_ctl_file_t *file,
} }
enum { enum {
SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct sndrv_ctl_elem_list32), SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct snd_ctl_elem_list32),
SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct sndrv_ctl_elem_info32), SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct snd_ctl_elem_info32),
SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct sndrv_ctl_elem_value32), SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct snd_ctl_elem_value32),
SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct sndrv_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 sndrv_ctl_elem_info32), SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct snd_ctl_elem_info32),
SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct sndrv_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) 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; struct list_head *list;
void __user *argp = compat_ptr(arg); void __user *argp = compat_ptr(arg);
int err; 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); down_read(&snd_ioctl_rwsem);
list_for_each(list, &snd_control_compat_ioctls) { 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) { if (p->fioctl) {
err = p->fioctl(ctl->card, ctl, cmd, arg); err = p->fioctl(ctl->card, ctl, cmd, arg);
if (err != -ENOIOCTLCMD) { if (err != -ENOIOCTLCMD) {