#include <sound/driver.h>
#include <linux/threads.h>
#include <linux/interrupt.h>
+#include <linux/smp_lock.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/time.h>
#include <sound/info.h>
#include <sound/control.h>
-typedef struct _snd_kctl_ioctl {
+/* max number of user-defined controls */
+#define MAX_USER_CONTROLS 32
+
+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);
+#ifdef CONFIG_COMPAT
+static LIST_HEAD(snd_control_compat_ioctls);
+#endif
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;
err = -EFAULT;
goto __error2;
}
- ctl = snd_magic_kcalloc(snd_ctl_file_t, 0, GFP_KERNEL);
+ ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
if (ctl == NULL) {
err = -ENOMEM;
goto __error;
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)) {
{
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 = snd_magic_cast(snd_ctl_file_t, file->private_data, return -ENXIO);
+ ctl = file->private_data;
fasync_helper(-1, file, 0, &ctl->fasync);
file->private_data = NULL;
card = ctl->card;
}
up_write(&card->controls_rwsem);
snd_ctl_empty_read_queue(ctl);
- snd_magic_kfree(ctl);
+ kfree(ctl);
module_put(card->module);
snd_card_file_remove(card, 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_runtime_check(card != NULL && id != NULL, return);
+ snd_assert(card != NULL && id != NULL, return);
read_lock(&card->ctl_files_rwlock);
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
card->mixer_oss_change_count++;
goto _found;
}
}
- ev = snd_kcalloc(sizeof(*ev), GFP_ATOMIC);
+ ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
if (ev) {
ev->id = *id;
ev->mask = mask;
* @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_runtime_check(control != NULL, return NULL);
- snd_runtime_check(control->count > 0, return NULL);
- kctl = (snd_kcontrol_t *)snd_magic_kcalloc(snd_kcontrol_t,
- sizeof(snd_kcontrol_volatile_t) * control->count,
- GFP_KERNEL);
- if (kctl == NULL)
+ snd_assert(control != NULL, return NULL);
+ snd_assert(control->count > 0, return 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;
* @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(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_runtime_check(ncontrol != NULL, return NULL);
+ snd_assert(ncontrol != NULL, return NULL);
snd_assert(ncontrol->info != NULL, return NULL);
memset(&kctl, 0, sizeof(kctl));
kctl.id.iface = ncontrol->iface;
* 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)
kcontrol->private_free(kcontrol);
- snd_magic_kfree(kcontrol);
+ kfree(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);
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;
*
* 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;
+ int err = -EINVAL;
- snd_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
- snd_assert(kcontrol->info != NULL, return -EINVAL);
+ if (! kcontrol)
+ return err;
+ snd_assert(card != NULL, goto error);
+ snd_assert(kcontrol->info != NULL, goto error);
id = kcontrol->id;
down_write(&card->controls_rwsem);
if (snd_ctl_find_id(card, &id)) {
up_write(&card->controls_rwsem);
- snd_ctl_free_one(kcontrol);
snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
id.iface,
id.device,
id.subdevice,
id.name,
id.index);
- return -EBUSY;
+ err = -EBUSY;
+ goto error;
}
if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
up_write(&card->controls_rwsem);
- snd_ctl_free_one(kcontrol);
- return -ENOMEM;
+ err = -ENOMEM;
+ goto error;
}
list_add_tail(&kcontrol->list, &card->controls);
card->controls_count += kcontrol->count;
for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
return 0;
+
+ error:
+ snd_ctl_free_one(kcontrol);
+ return err;
}
/**
*
* 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_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
+ snd_assert(card != NULL && kcontrol != NULL, return -EINVAL);
list_del(&kcontrol->list);
card->controls_count -= kcontrol->count;
id = kcontrol->id;
*
* 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);
*
* 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);
*
* 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);
* 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_runtime_check(card != NULL && numid != 0, return NULL);
+ snd_assert(card != NULL && numid != 0, return NULL);
list_for_each(list, &card->controls) {
kctl = snd_kcontrol(list);
if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > 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_runtime_check(card != NULL && id != NULL, return NULL);
+ snd_assert(card != NULL && id != NULL, return NULL);
if (id->numid != 0)
return snd_ctl_find_numid(card, id->numid);
list_for_each(list, &card->controls) {
return NULL;
}
-static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
- unsigned int cmd, unsigned long arg)
+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;
- memset(&info, 0, sizeof(info));
+ info = kzalloc(sizeof(*info), GFP_KERNEL);
+ if (! info)
+ return -ENOMEM;
down_read(&snd_ioctl_rwsem);
- info.card = card->number;
- strlcpy(info.id, card->id, sizeof(info.id));
- strlcpy(info.driver, card->driver, sizeof(info.driver));
- strlcpy(info.name, card->shortname, sizeof(info.name));
- strlcpy(info.longname, card->longname, sizeof(info.longname));
- strlcpy(info.mixername, card->mixername, sizeof(info.mixername));
- strlcpy(info.components, card->components, sizeof(info.components));
+ info->card = card->number;
+ strlcpy(info->id, card->id, sizeof(info->id));
+ strlcpy(info->driver, card->driver, sizeof(info->driver));
+ strlcpy(info->name, card->shortname, sizeof(info->name));
+ strlcpy(info->longname, card->longname, sizeof(info->longname));
+ 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((void *) arg, &info, sizeof(snd_ctl_card_info_t)))
+ if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
+ kfree(info);
return -EFAULT;
+ }
+ kfree(info);
return 0;
}
-static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t *_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)))
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);
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;
}
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_ctl_elem_info_t info;
- 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;
- if (copy_from_user(&info, _info, sizeof(info)))
- return -EFAULT;
down_read(&card->controls_rwsem);
- kctl = snd_ctl_find_id(card, &info.id);
+ kctl = snd_ctl_find_id(card, &info->id);
if (kctl == NULL) {
up_read(&card->controls_rwsem);
return -ENOENT;
}
#ifdef CONFIG_SND_DEBUG
- info.access = 0;
+ info->access = 0;
#endif
- result = kctl->info(kctl, &info);
+ result = kctl->info(kctl, info);
if (result >= 0) {
- snd_assert(info.access == 0, );
- index_offset = snd_ctl_get_ioff(kctl, &info.id);
+ snd_assert(info->access == 0, );
+ index_offset = snd_ctl_get_ioff(kctl, &info->id);
vd = &kctl->vd[index_offset];
- snd_ctl_build_ioff(&info.id, kctl, index_offset);
- info.access = vd->access;
+ snd_ctl_build_ioff(&info->id, kctl, index_offset);
+ info->access = vd->access;
if (vd->owner) {
- info.access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
+ info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
if (vd->owner == ctl)
- info.access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
- info.owner = vd->owner_pid;
+ info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
+ info->owner = vd->owner_pid;
} else {
- info.owner = -1;
+ info->owner = -1;
}
}
up_read(&card->controls_rwsem);
+ return result;
+}
+
+static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
+ struct snd_ctl_elem_info __user *_info)
+{
+ struct snd_ctl_elem_info info;
+ int result;
+
+ if (copy_from_user(&info, _info, sizeof(info)))
+ return -EFAULT;
+ snd_power_lock(ctl->card);
+ result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0);
+ if (result >= 0)
+ result = snd_ctl_elem_info(ctl, &info);
+ snd_power_unlock(ctl->card);
if (result >= 0)
if (copy_to_user(_info, &info, sizeof(info)))
return -EFAULT;
return result;
}
-static 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_ctl_elem_value_t *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;
-
- control = kmalloc(sizeof(*control), GFP_KERNEL);
- if (control == NULL)
- return -ENOMEM;
- if (copy_from_user(control, _control, sizeof(*control)))
- return -EFAULT;
+
down_read(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, &control->id);
if (kctl == NULL) {
}
}
up_read(&card->controls_rwsem);
+ return result;
+}
+
+static int snd_ctl_elem_read_user(struct snd_card *card,
+ struct snd_ctl_elem_value __user *_control)
+{
+ struct snd_ctl_elem_value *control;
+ int result;
+
+ control = kmalloc(sizeof(*control), GFP_KERNEL);
+ if (control == NULL)
+ return -ENOMEM;
+ if (copy_from_user(control, _control, sizeof(*control))) {
+ kfree(control);
+ return -EFAULT;
+ }
+ snd_power_lock(card);
+ result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
+ if (result >= 0)
+ result = snd_ctl_elem_read(card, control);
+ snd_power_unlock(card);
if (result >= 0)
if (copy_to_user(_control, control, sizeof(*control)))
- return -EFAULT;
+ result = -EFAULT;
kfree(control);
return result;
}
-static int snd_ctl_elem_write(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_card_t *card = file->card;
- snd_ctl_elem_value_t *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;
- control = kmalloc(sizeof(*control), GFP_KERNEL);
- if (control == NULL)
- return -ENOMEM;
- if (copy_from_user(control, _control, sizeof(*control)))
- return -EFAULT;
down_read(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, &control->id);
if (kctl == NULL) {
} else {
if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
kctl->put == NULL ||
- (vd->owner != NULL && vd->owner != file)) {
+ (file && vd->owner != NULL && vd->owner != file)) {
result = -EPERM;
} else {
snd_ctl_build_ioff(&control->id, kctl, index_offset);
if (result > 0) {
up_read(&card->controls_rwsem);
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
- result = 0;
- goto __unlocked;
+ return 0;
}
}
}
up_read(&card->controls_rwsem);
- __unlocked:
+ return result;
+}
+
+static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
+ struct snd_ctl_elem_value __user *_control)
+{
+ struct snd_ctl_elem_value *control;
+ struct snd_card *card;
+ int result;
+
+ control = kmalloc(sizeof(*control), GFP_KERNEL);
+ if (control == NULL)
+ return -ENOMEM;
+ if (copy_from_user(control, _control, sizeof(*control))) {
+ kfree(control);
+ return -EFAULT;
+ }
+ card = file->card;
+ snd_power_lock(card);
+ result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
+ if (result >= 0)
+ result = snd_ctl_elem_write(card, file, control);
+ snd_power_unlock(card);
if (result >= 0)
if (copy_to_user(_control, control, sizeof(*control)))
- return -EFAULT;
+ result = -EFAULT;
kfree(control);
return result;
}
-static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t *_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)))
return result;
}
-static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t *_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)))
}
struct user_element {
- enum sndrv_ctl_elem_type type; /* element type */
- unsigned int elem_count; /* count of elements */
- union {
- struct {
- unsigned int items;
- } enumerated;
- } u;
+ 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 */
- unsigned short dimen_count; /* count of dimensions */
- unsigned short dimen[0]; /* array of dimensions */
};
-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;
- uinfo->type = ue->type;
- uinfo->count = ue->elem_count;
- if (ue->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
- uinfo->value.enumerated.items = ue->u.enumerated.items;
- if (uinfo->value.enumerated.item >= ue->u.enumerated.items)
- uinfo->value.enumerated.item = 0;
- strlcpy(uinfo->value.enumerated.name,
- (char *)ue->priv_data + uinfo->value.enumerated.item * 64,
- 64);
- }
+ *uinfo = ue->info;
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;
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;
- change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size);
- memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
- return !!change;
+ change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
+ if (change)
+ memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
+ 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_ctl_elem_info_t info;
- snd_kcontrol_t kctl, *_kctl;
+ struct snd_card *card = file->card;
+ struct snd_kcontrol kctl, *_kctl;
unsigned int access;
- long private_size, dimen_size, extra_size;
+ long private_size;
struct user_element *ue;
int idx, err;
- if (copy_from_user(&info, _info, sizeof(info)))
- return -EFAULT;
- 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|
- SNDRV_CTL_ELEM_ACCESS_DINDIRECT|SNDRV_CTL_ELEM_ACCESS_INDIRECT));
- if (access & (SNDRV_CTL_ELEM_ACCESS_DINDIRECT | SNDRV_CTL_ELEM_ACCESS_INDIRECT))
+ if (card->user_ctl_count >= MAX_USER_CONTROLS)
+ return -ENOMEM;
+ if (info->count > 1024)
return -EINVAL;
- info.id.numid = 0;
+ access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
+ (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);
- if (!!((_kctl = snd_ctl_find_id(card, &info.id)) != NULL) ^ replace) {
- up_write(&card->controls_rwsem);
- return !replace ? -EBUSY : -ENOENT;
- }
- if (replace) {
- err = snd_ctl_remove(card, _kctl);
- if (err < 0) {
- up_write(&card->controls_rwsem);
- return err;
- }
+ _kctl = snd_ctl_find_id(card, &info->id);
+ err = 0;
+ if (_kctl) {
+ if (replace)
+ err = snd_ctl_remove(card, _kctl);
+ else
+ err = -EBUSY;
+ } else {
+ if (replace)
+ err = -ENOENT;
}
up_write(&card->controls_rwsem);
- memcpy(&kctl.id, &info.id, sizeof(info.id));
- kctl.count = info.owner ? info.owner : 1;
+ if (err < 0)
+ return err;
+ memcpy(&kctl.id, &info->id, sizeof(info->id));
+ kctl.count = info->owner ? info->owner : 1;
access |= SNDRV_CTL_ELEM_ACCESS_USER;
kctl.info = snd_ctl_elem_user_info;
if (access & SNDRV_CTL_ELEM_ACCESS_READ)
kctl.get = snd_ctl_elem_user_get;
if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
kctl.put = snd_ctl_elem_user_put;
- extra_size = 0;
- switch (info.type) {
+ switch (info->type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
private_size = sizeof(char);
- if (info.count > 128)
+ if (info->count > 128)
return -EINVAL;
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER:
private_size = sizeof(long);
- if (info.count > 128)
+ if (info->count > 128)
return -EINVAL;
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER64:
private_size = sizeof(long long);
- if (info.count > 64)
+ if (info->count > 64)
return -EINVAL;
break;
- case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
- private_size = sizeof(unsigned int);
- if (info.count > 128)
- return -EINVAL;
- if (info.value.enumerated.items > 1024)
- return -EINVAL;
- extra_size = info.value.enumerated.items * 64;
- break;
case SNDRV_CTL_ELEM_TYPE_BYTES:
private_size = sizeof(unsigned char);
- if (info.count > 512)
+ if (info->count > 512)
return -EINVAL;
break;
case SNDRV_CTL_ELEM_TYPE_IEC958:
- private_size = sizeof(struct sndrv_aes_iec958);
- if (info.count != 1)
+ private_size = sizeof(struct snd_aes_iec958);
+ if (info->count != 1)
return -EINVAL;
break;
default:
return -EINVAL;
}
- private_size *= info.count;
- if (private_size > 1024 * 1024)
- return -EINVAL;
- dimen_size = 0;
- if (!(info.access & SNDRV_CTL_ELEM_ACCESS_DINDIRECT))
- for (idx = 0; idx < 4 && info.dimen.d[idx]; idx++)
- dimen_size += sizeof(unsigned short);
- ue = snd_kcalloc(sizeof(struct user_element) + dimen_size + private_size + extra_size, GFP_KERNEL);
+ private_size *= info->count;
+ ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
if (ue == NULL)
return -ENOMEM;
- ue->type = info.type;
- ue->elem_count = info.count;
- if (!(info.access & SNDRV_CTL_ELEM_ACCESS_DINDIRECT)) {
- for (idx = 0; idx < 4 && info.dimen.d[idx]; idx++)
- ue->dimen[idx] = info.dimen.d[idx];
- ue->dimen_count = dimen_size / sizeof(unsigned short);
- }
- ue->elem_data = (char *)ue + sizeof(ue) + dimen_size;
+ ue->info = *info;
+ ue->elem_data = (char *)ue + sizeof(*ue);
ue->elem_data_size = private_size;
- if (extra_size) {
- ue->priv_data = (char *)ue + sizeof(ue) + dimen_size + private_size;
- ue->priv_data_size = extra_size;
- if (ue->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
- if (copy_from_user(ue->priv_data, *(char **)info.value.enumerated.name, extra_size))
- return -EFAULT;
- ue->u.enumerated.items = info.value.enumerated.items;
- }
- }
kctl.private_free = snd_ctl_elem_user_free;
_kctl = snd_ctl_new(&kctl, access);
if (_kctl == NULL) {
- kfree(_kctl->private_data);
+ kfree(ue);
return -ENOMEM;
}
_kctl->private_data = ue;
for (idx = 0; idx < _kctl->count; idx++)
_kctl->vd[idx].owner = file;
err = snd_ctl_add(card, _kctl);
- if (err < 0) {
- snd_ctl_free_one(_kctl);
+ if (err < 0)
return err;
- }
+
+ down_write(&card->controls_rwsem);
+ card->user_ctl_count++;
+ up_write(&card->controls_rwsem);
+
return 0;
}
-static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t *_id)
+static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
+ struct snd_ctl_elem_info __user *_info, int replace)
+{
+ 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(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;
- return snd_ctl_remove_unlocked_id(file, &id);
+ err = snd_ctl_remove_unlocked_id(file, &id);
+ if (! err) {
+ struct snd_card *card = file->card;
+ down_write(&card->controls_rwsem);
+ card->user_ctl_count--;
+ up_write(&card->controls_rwsem);
+ }
+ return err;
}
-static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int *ptr)
+static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
{
int subscribe;
if (get_user(subscribe, ptr))
return 0;
}
-static int snd_ctl_ioctl(struct inode *inode, 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;
- 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;
- ctl = snd_magic_cast(snd_ctl_file_t, file->private_data, return -ENXIO);
+ ctl = file->private_data;
card = ctl->card;
snd_assert(card != NULL, return -ENXIO);
switch (cmd) {
case SNDRV_CTL_IOCTL_PVERSION:
- return put_user(SNDRV_CTL_VERSION, (int *)arg) ? -EFAULT : 0;
+ return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
case SNDRV_CTL_IOCTL_CARD_INFO:
- return snd_ctl_card_info(card, ctl, cmd, arg);
+ return snd_ctl_card_info(card, ctl, cmd, argp);
case SNDRV_CTL_IOCTL_ELEM_LIST:
- return snd_ctl_elem_list(ctl->card, (snd_ctl_elem_list_t *) arg);
+ return snd_ctl_elem_list(ctl->card, argp);
case SNDRV_CTL_IOCTL_ELEM_INFO:
- return snd_ctl_elem_info(ctl, (snd_ctl_elem_info_t *) arg);
+ return snd_ctl_elem_info_user(ctl, argp);
case SNDRV_CTL_IOCTL_ELEM_READ:
- return snd_ctl_elem_read(ctl->card, (snd_ctl_elem_value_t *) arg);
+ return snd_ctl_elem_read_user(ctl->card, argp);
case SNDRV_CTL_IOCTL_ELEM_WRITE:
- return snd_ctl_elem_write(ctl, (snd_ctl_elem_value_t *) arg);
+ return snd_ctl_elem_write_user(ctl, argp);
case SNDRV_CTL_IOCTL_ELEM_LOCK:
- return snd_ctl_elem_lock(ctl, (snd_ctl_elem_id_t *) arg);
+ return snd_ctl_elem_lock(ctl, argp);
case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
- return snd_ctl_elem_unlock(ctl, (snd_ctl_elem_id_t *) arg);
+ return snd_ctl_elem_unlock(ctl, argp);
case SNDRV_CTL_IOCTL_ELEM_ADD:
- return snd_ctl_elem_add(ctl, (snd_ctl_elem_info_t *) arg, 0);
+ return snd_ctl_elem_add_user(ctl, argp, 0);
case SNDRV_CTL_IOCTL_ELEM_REPLACE:
- return snd_ctl_elem_add(ctl, (snd_ctl_elem_info_t *) arg, 1);
+ return snd_ctl_elem_add_user(ctl, argp, 1);
case SNDRV_CTL_IOCTL_ELEM_REMOVE:
- return snd_ctl_elem_remove(ctl, (snd_ctl_elem_id_t *) arg);
+ return snd_ctl_elem_remove(ctl, argp);
case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
- return snd_ctl_subscribe_events(ctl, (int *) arg);
+ return snd_ctl_subscribe_events(ctl, ip);
case SNDRV_CTL_IOCTL_POWER:
- if (get_user(err, (int *)arg))
- return -EFAULT;
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
-#ifdef CONFIG_PM
- if (card->set_power_state) {
- snd_power_lock(card);
- err = card->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, (int *)arg) ? -EFAULT : 0;
+ return put_user(card->power_state, ip) ? -EFAULT : 0;
#else
- return put_user(SNDRV_CTL_POWER_D0, (int *)arg) ? -EFAULT : 0;
+ return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
#endif
}
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);
}
}
up_read(&snd_ioctl_rwsem);
- snd_printd("unknown ioctl = 0x%x\n", cmd);
+ snd_printdd("unknown ioctl = 0x%x\n", cmd);
return -ENOTTY;
}
-static ssize_t snd_ctl_read(struct file *file, char *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;
- ctl = snd_magic_cast(snd_ctl_file_t, file->private_data, return -ENXIO);
+ ctl = file->private_data;
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) {
err = -EAGAIN;
- goto __end;
+ goto __end_lock;
}
init_waitqueue_entry(&wait, current);
add_wait_queue(&ctl->change_sleep, &wait);
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:
+ __end_lock:
spin_unlock_irq(&ctl->read_lock);
+ __end:
return result > 0 ? result : err;
}
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 = snd_magic_cast(snd_ctl_file_t, file->private_data, return 0);
+ ctl = file->private_data;
if (!ctl->subscribed)
return 0;
poll_wait(file, &ctl->change_sleep, wait);
* register the device-specific control-ioctls.
* called from each device manager like pcm.c, hwdep.c, etc.
*/
-int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
+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 = (snd_kctl_ioctl_t *)
- snd_kcalloc(sizeof(snd_kctl_ioctl_t), GFP_KERNEL);
+ pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
if (pn == NULL)
return -ENOMEM;
pn->fioctl = fcn;
down_write(&snd_ioctl_rwsem);
- list_add_tail(&pn->list, &snd_control_ioctls);
+ list_add_tail(&pn->list, lists);
up_write(&snd_ioctl_rwsem);
return 0;
}
+int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
+{
+ return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
+}
+
+#ifdef CONFIG_COMPAT
+int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
+{
+ return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
+}
+#endif
+
/*
* de-register the device-specific control-ioctls.
*/
-int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
+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_runtime_check(fcn != NULL, return -EINVAL);
+ snd_assert(fcn != NULL, return -EINVAL);
down_write(&snd_ioctl_rwsem);
- list_for_each(list, &snd_control_ioctls) {
- p = list_entry(list, snd_kctl_ioctl_t, list);
+ list_for_each(list, lists) {
+ p = list_entry(list, struct snd_kctl_ioctl, list);
if (p->fioctl == fcn) {
list_del(&p->list);
up_write(&snd_ioctl_rwsem);
return -EINVAL;
}
+int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
+{
+ return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
+}
+
+#ifdef CONFIG_COMPAT
+int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
+{
+ return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
+}
+
+#endif
+
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 = snd_magic_cast(snd_ctl_file_t, file->private_data, return -ENXIO);
+ ctl = file->private_data;
err = fasync_helper(fd, file, on, &ctl->fasync);
if (err < 0)
return err;
return 0;
}
+/*
+ * ioctl32 compat
+ */
+#ifdef CONFIG_COMPAT
+#include "control_compat.c"
+#else
+#define snd_ctl_ioctl_compat NULL
+#endif
+
/*
* INIT PART
*/
.open = snd_ctl_open,
.release = snd_ctl_release,
.poll = snd_ctl_poll,
- .ioctl = snd_ctl_ioctl,
+ .unlocked_ioctl = snd_ctl_ioctl,
+ .compat_ioctl = snd_ctl_ioctl_compat,
.fasync = snd_ctl_fasync,
};
-static snd_minor_t snd_ctl_reg =
-{
- .comment = "ctl",
- .f_ops = &snd_ctl_f_ops,
-};
-
/*
- * registration of the control device:
- * called from init.c
+ * registration of the control device
*/
-int snd_ctl_register(snd_card_t *card)
+static int snd_ctl_dev_register(struct snd_device *device)
{
+ struct snd_card *card = device->device_data;
int err, cardnum;
char name[16];
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;
}
/*
- * disconnection of the control device:
- * called from init.c
+ * disconnection of the control device
*/
-int snd_ctl_disconnect(snd_card_t *card)
+static int snd_ctl_dev_disconnect(struct snd_device *device)
{
+ 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) {
}
/*
- * de-registration of the control device:
- * called from init.c
+ * free all controls
*/
-int snd_ctl_unregister(snd_card_t *card)
+static int snd_ctl_dev_free(struct snd_device *device)
{
- int err, cardnum;
- snd_kcontrol_t *control;
+ struct snd_card *card = device->device_data;
+ struct snd_kcontrol *control;
- 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)
- return err;
down_write(&card->controls_rwsem);
while (!list_empty(&card->controls)) {
control = snd_kcontrol(card->controls.next);
up_write(&card->controls_rwsem);
return 0;
}
+
+/*
+ * de-registration of the control device
+ */
+static int snd_ctl_dev_unregister(struct snd_device *device)
+{
+ 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, -1)) < 0)
+ return err;
+ return snd_ctl_dev_free(device);
+}
+
+/*
+ * create control core:
+ * called from init.c
+ */
+int snd_ctl_create(struct snd_card *card)
+{
+ static struct snd_device_ops ops = {
+ .dev_free = snd_ctl_dev_free,
+ .dev_register = snd_ctl_dev_register,
+ .dev_disconnect = snd_ctl_dev_disconnect,
+ .dev_unregister = snd_ctl_dev_unregister
+ };
+
+ snd_assert(card != NULL, return -ENXIO);
+ return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
+}
git://git.onelab.eu / linux-2.6.git / blobdiff