2 * Routines for driver control interface
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/driver.h>
23 #include <linux/threads.h>
24 #include <linux/interrupt.h>
25 #include <linux/smp_lock.h>
26 #include <linux/slab.h>
27 #include <linux/vmalloc.h>
28 #include <linux/time.h>
29 #include <sound/core.h>
30 #include <sound/minors.h>
31 #include <sound/info.h>
32 #include <sound/control.h>
34 /* max number of user-defined controls */
35 #define MAX_USER_CONTROLS 32
37 typedef struct _snd_kctl_ioctl {
38 struct list_head list; /* list of all ioctls */
39 snd_kctl_ioctl_func_t fioctl;
42 #define snd_kctl_ioctl(n) list_entry(n, snd_kctl_ioctl_t, list)
44 static DECLARE_RWSEM(snd_ioctl_rwsem);
45 static LIST_HEAD(snd_control_ioctls);
47 static int snd_ctl_open(struct inode *inode, struct file *file)
49 int cardnum = SNDRV_MINOR_CARD(iminor(inode));
55 card = snd_cards[cardnum];
60 err = snd_card_file_add(card, file);
65 if (!try_module_get(card->module)) {
69 ctl = kcalloc(1, sizeof(*ctl), GFP_KERNEL);
74 INIT_LIST_HEAD(&ctl->events);
75 init_waitqueue_head(&ctl->change_sleep);
76 spin_lock_init(&ctl->read_lock);
78 ctl->pid = current->pid;
79 file->private_data = ctl;
80 write_lock_irqsave(&card->ctl_files_rwlock, flags);
81 list_add_tail(&ctl->list, &card->ctl_files);
82 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
86 module_put(card->module);
88 snd_card_file_remove(card, file);
93 static void snd_ctl_empty_read_queue(snd_ctl_file_t * ctl)
95 snd_kctl_event_t *cread;
97 spin_lock(&ctl->read_lock);
98 while (!list_empty(&ctl->events)) {
99 cread = snd_kctl_event(ctl->events.next);
100 list_del(&cread->list);
103 spin_unlock(&ctl->read_lock);
106 static int snd_ctl_release(struct inode *inode, struct file *file)
109 struct list_head *list;
112 snd_kcontrol_t *control;
115 ctl = file->private_data;
116 fasync_helper(-1, file, 0, &ctl->fasync);
117 file->private_data = NULL;
119 write_lock_irqsave(&card->ctl_files_rwlock, flags);
120 list_del(&ctl->list);
121 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
122 down_write(&card->controls_rwsem);
123 list_for_each(list, &card->controls) {
124 control = snd_kcontrol(list);
125 for (idx = 0; idx < control->count; idx++)
126 if (control->vd[idx].owner == ctl)
127 control->vd[idx].owner = NULL;
129 up_write(&card->controls_rwsem);
130 snd_ctl_empty_read_queue(ctl);
132 module_put(card->module);
133 snd_card_file_remove(card, file);
137 void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id)
140 struct list_head *flist;
142 snd_kctl_event_t *ev;
144 snd_runtime_check(card != NULL && id != NULL, return);
145 read_lock(&card->ctl_files_rwlock);
146 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
147 card->mixer_oss_change_count++;
149 list_for_each(flist, &card->ctl_files) {
150 struct list_head *elist;
151 ctl = snd_ctl_file(flist);
152 if (!ctl->subscribed)
154 spin_lock_irqsave(&ctl->read_lock, flags);
155 list_for_each(elist, &ctl->events) {
156 ev = snd_kctl_event(elist);
157 if (ev->id.numid == id->numid) {
162 ev = kcalloc(1, sizeof(*ev), GFP_ATOMIC);
166 list_add_tail(&ev->list, &ctl->events);
168 snd_printk(KERN_ERR "No memory available to allocate event\n");
171 wake_up(&ctl->change_sleep);
172 spin_unlock_irqrestore(&ctl->read_lock, flags);
173 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
175 read_unlock(&card->ctl_files_rwlock);
179 * snd_ctl_new - create a control instance from the template
180 * @control: the control template
181 * @access: the default control access
183 * Allocates a new snd_kcontrol_t instance and copies the given template
184 * to the new instance. It does not copy volatile data (access).
186 * Returns the pointer of the new instance, or NULL on failure.
188 snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access)
190 snd_kcontrol_t *kctl;
193 snd_runtime_check(control != NULL, return NULL);
194 snd_runtime_check(control->count > 0, return NULL);
195 kctl = kcalloc(1, sizeof(*kctl) + sizeof(snd_kcontrol_volatile_t) * control->count, GFP_KERNEL);
199 for (idx = 0; idx < kctl->count; idx++)
200 kctl->vd[idx].access = access;
205 * snd_ctl_new1 - create a control instance from the template
206 * @ncontrol: the initialization record
207 * @private_data: the private data to set
209 * Allocates a new snd_kcontrol_t instance and initialize from the given
210 * template. When the access field of ncontrol is 0, it's assumed as
211 * READWRITE access. When the count field is 0, it's assumes as one.
213 * Returns the pointer of the newly generated instance, or NULL on failure.
215 snd_kcontrol_t *snd_ctl_new1(snd_kcontrol_new_t * ncontrol, void *private_data)
220 snd_runtime_check(ncontrol != NULL, return NULL);
221 snd_assert(ncontrol->info != NULL, return NULL);
222 memset(&kctl, 0, sizeof(kctl));
223 kctl.id.iface = ncontrol->iface;
224 kctl.id.device = ncontrol->device;
225 kctl.id.subdevice = ncontrol->subdevice;
227 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
228 kctl.id.index = ncontrol->index;
229 kctl.count = ncontrol->count ? ncontrol->count : 1;
230 access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
231 (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE|
232 SNDRV_CTL_ELEM_ACCESS_DINDIRECT|SNDRV_CTL_ELEM_ACCESS_INDIRECT));
233 kctl.info = ncontrol->info;
234 kctl.get = ncontrol->get;
235 kctl.put = ncontrol->put;
236 kctl.private_value = ncontrol->private_value;
237 kctl.private_data = private_data;
238 return snd_ctl_new(&kctl, access);
242 * snd_ctl_free_one - release the control instance
243 * @kcontrol: the control instance
245 * Releases the control instance created via snd_ctl_new()
247 * Don't call this after the control was added to the card.
249 void snd_ctl_free_one(snd_kcontrol_t * kcontrol)
252 if (kcontrol->private_free)
253 kcontrol->private_free(kcontrol);
258 static unsigned int snd_ctl_hole_check(snd_card_t * card,
261 struct list_head *list;
262 snd_kcontrol_t *kctl;
264 list_for_each(list, &card->controls) {
265 kctl = snd_kcontrol(list);
266 if ((kctl->id.numid <= card->last_numid &&
267 kctl->id.numid + kctl->count > card->last_numid) ||
268 (kctl->id.numid <= card->last_numid + count - 1 &&
269 kctl->id.numid + kctl->count > card->last_numid + count - 1))
270 return card->last_numid = kctl->id.numid + kctl->count - 1;
272 return card->last_numid;
275 static int snd_ctl_find_hole(snd_card_t * card, unsigned int count)
277 unsigned int last_numid, iter = 100000;
279 last_numid = card->last_numid;
280 while (last_numid != snd_ctl_hole_check(card, count)) {
282 /* this situation is very unlikely */
283 snd_printk(KERN_ERR "unable to allocate new control numid\n");
286 last_numid = card->last_numid;
292 * snd_ctl_add - add the control instance to the card
293 * @card: the card instance
294 * @kcontrol: the control instance to add
296 * Adds the control instance created via snd_ctl_new() or
297 * snd_ctl_new1() to the given card. Assigns also an unique
298 * numid used for fast search.
300 * Returns zero if successful, or a negative error code on failure.
302 * It frees automatically the control which cannot be added.
304 int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol)
306 snd_ctl_elem_id_t id;
309 snd_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
310 snd_assert(kcontrol->info != NULL, return -EINVAL);
312 down_write(&card->controls_rwsem);
313 if (snd_ctl_find_id(card, &id)) {
314 up_write(&card->controls_rwsem);
315 snd_ctl_free_one(kcontrol);
316 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
324 if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
325 up_write(&card->controls_rwsem);
326 snd_ctl_free_one(kcontrol);
329 list_add_tail(&kcontrol->list, &card->controls);
330 card->controls_count += kcontrol->count;
331 kcontrol->id.numid = card->last_numid + 1;
332 card->last_numid += kcontrol->count;
333 up_write(&card->controls_rwsem);
334 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
335 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
340 * snd_ctl_remove - remove the control from the card and release it
341 * @card: the card instance
342 * @kcontrol: the control instance to remove
344 * Removes the control from the card and then releases the instance.
345 * You don't need to call snd_ctl_free_one(). You must be in
346 * the write lock - down_write(&card->controls_rwsem).
348 * Returns 0 if successful, or a negative error code on failure.
350 int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol)
352 snd_ctl_elem_id_t id;
355 snd_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
356 list_del(&kcontrol->list);
357 card->controls_count -= kcontrol->count;
359 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
360 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
361 snd_ctl_free_one(kcontrol);
366 * snd_ctl_remove_id - remove the control of the given id and release it
367 * @card: the card instance
368 * @id: the control id to remove
370 * Finds the control instance with the given id, removes it from the
371 * card list and releases it.
373 * Returns 0 if successful, or a negative error code on failure.
375 int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id)
377 snd_kcontrol_t *kctl;
380 down_write(&card->controls_rwsem);
381 kctl = snd_ctl_find_id(card, id);
383 up_write(&card->controls_rwsem);
386 ret = snd_ctl_remove(card, kctl);
387 up_write(&card->controls_rwsem);
392 * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
393 * @file: active control handle
394 * @id: the control id to remove
396 * Finds the control instance with the given id, removes it from the
397 * card list and releases it.
399 * Returns 0 if successful, or a negative error code on failure.
401 static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *id)
403 snd_card_t *card = file->card;
404 snd_kcontrol_t *kctl;
407 down_write(&card->controls_rwsem);
408 kctl = snd_ctl_find_id(card, id);
410 up_write(&card->controls_rwsem);
413 for (idx = 0; idx < kctl->count; idx++)
414 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
415 up_write(&card->controls_rwsem);
418 ret = snd_ctl_remove(card, kctl);
419 up_write(&card->controls_rwsem);
424 * snd_ctl_rename_id - replace the id of a control on the card
425 * @card: the card instance
426 * @src_id: the old id
427 * @dst_id: the new id
429 * Finds the control with the old id from the card, and replaces the
430 * id with the new one.
432 * Returns zero if successful, or a negative error code on failure.
434 int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id)
436 snd_kcontrol_t *kctl;
438 down_write(&card->controls_rwsem);
439 kctl = snd_ctl_find_id(card, src_id);
441 up_write(&card->controls_rwsem);
445 kctl->id.numid = card->last_numid + 1;
446 card->last_numid += kctl->count;
447 up_write(&card->controls_rwsem);
452 * snd_ctl_find_numid - find the control instance with the given number-id
453 * @card: the card instance
454 * @numid: the number-id to search
456 * Finds the control instance with the given number-id from the card.
458 * Returns the pointer of the instance if found, or NULL if not.
460 * The caller must down card->controls_rwsem before calling this function
461 * (if the race condition can happen).
463 snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid)
465 struct list_head *list;
466 snd_kcontrol_t *kctl;
468 snd_runtime_check(card != NULL && numid != 0, return NULL);
469 list_for_each(list, &card->controls) {
470 kctl = snd_kcontrol(list);
471 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
478 * snd_ctl_find_id - find the control instance with the given id
479 * @card: the card instance
480 * @id: the id to search
482 * Finds the control instance with the given id from the card.
484 * Returns the pointer of the instance if found, or NULL if not.
486 * The caller must down card->controls_rwsem before calling this function
487 * (if the race condition can happen).
489 snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id)
491 struct list_head *list;
492 snd_kcontrol_t *kctl;
494 snd_runtime_check(card != NULL && id != NULL, return NULL);
496 return snd_ctl_find_numid(card, id->numid);
497 list_for_each(list, &card->controls) {
498 kctl = snd_kcontrol(list);
499 if (kctl->id.iface != id->iface)
501 if (kctl->id.device != id->device)
503 if (kctl->id.subdevice != id->subdevice)
505 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
507 if (kctl->id.index > id->index)
509 if (kctl->id.index + kctl->count <= id->index)
516 static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
517 unsigned int cmd, void __user *arg)
519 snd_ctl_card_info_t info;
521 memset(&info, 0, sizeof(info));
522 down_read(&snd_ioctl_rwsem);
523 info.card = card->number;
524 strlcpy(info.id, card->id, sizeof(info.id));
525 strlcpy(info.driver, card->driver, sizeof(info.driver));
526 strlcpy(info.name, card->shortname, sizeof(info.name));
527 strlcpy(info.longname, card->longname, sizeof(info.longname));
528 strlcpy(info.mixername, card->mixername, sizeof(info.mixername));
529 strlcpy(info.components, card->components, sizeof(info.components));
530 up_read(&snd_ioctl_rwsem);
531 if (copy_to_user(arg, &info, sizeof(snd_ctl_card_info_t)))
536 static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list)
538 struct list_head *plist;
539 snd_ctl_elem_list_t list;
540 snd_kcontrol_t *kctl;
541 snd_ctl_elem_id_t *dst, *id;
542 unsigned int offset, space, first, jidx;
544 if (copy_from_user(&list, _list, sizeof(list)))
546 offset = list.offset;
549 /* try limit maximum space */
553 /* allocate temporary buffer for atomic operation */
554 dst = vmalloc(space * sizeof(snd_ctl_elem_id_t));
557 down_read(&card->controls_rwsem);
558 list.count = card->controls_count;
559 plist = card->controls.next;
560 while (plist != &card->controls) {
563 kctl = snd_kcontrol(plist);
564 if (offset < kctl->count)
566 offset -= kctl->count;
571 while (space > 0 && plist != &card->controls) {
572 kctl = snd_kcontrol(plist);
573 for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
574 snd_ctl_build_ioff(id, kctl, jidx);
582 up_read(&card->controls_rwsem);
583 if (list.used > 0 && copy_to_user(list.pids, dst, list.used * sizeof(snd_ctl_elem_id_t))) {
589 down_read(&card->controls_rwsem);
590 list.count = card->controls_count;
591 up_read(&card->controls_rwsem);
593 if (copy_to_user(_list, &list, sizeof(list)))
598 static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __user *_info)
600 snd_card_t *card = ctl->card;
601 snd_ctl_elem_info_t info;
602 snd_kcontrol_t *kctl;
603 snd_kcontrol_volatile_t *vd;
604 unsigned int index_offset;
607 if (copy_from_user(&info, _info, sizeof(info)))
609 down_read(&card->controls_rwsem);
610 kctl = snd_ctl_find_id(card, &info.id);
612 up_read(&card->controls_rwsem);
615 #ifdef CONFIG_SND_DEBUG
618 result = kctl->info(kctl, &info);
620 snd_assert(info.access == 0, );
621 index_offset = snd_ctl_get_ioff(kctl, &info.id);
622 vd = &kctl->vd[index_offset];
623 snd_ctl_build_ioff(&info.id, kctl, index_offset);
624 info.access = vd->access;
626 info.access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
627 if (vd->owner == ctl)
628 info.access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
629 info.owner = vd->owner_pid;
634 up_read(&card->controls_rwsem);
636 if (copy_to_user(_info, &info, sizeof(info)))
641 int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control)
643 snd_kcontrol_t *kctl;
644 snd_kcontrol_volatile_t *vd;
645 unsigned int index_offset;
646 int result, indirect;
648 down_read(&card->controls_rwsem);
649 kctl = snd_ctl_find_id(card, &control->id);
653 index_offset = snd_ctl_get_ioff(kctl, &control->id);
654 vd = &kctl->vd[index_offset];
655 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
656 if (control->indirect != indirect) {
659 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) && kctl->get != NULL) {
660 snd_ctl_build_ioff(&control->id, kctl, index_offset);
661 result = kctl->get(kctl, control);
667 up_read(&card->controls_rwsem);
671 static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user *_control)
673 snd_ctl_elem_value_t *control;
676 control = kmalloc(sizeof(*control), GFP_KERNEL);
679 if (copy_from_user(control, _control, sizeof(*control))) {
683 result = snd_ctl_elem_read(card, control);
685 if (copy_to_user(_control, control, sizeof(*control)))
691 int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_value_t *control)
693 snd_kcontrol_t *kctl;
694 snd_kcontrol_volatile_t *vd;
695 unsigned int index_offset;
696 int result, indirect;
698 down_read(&card->controls_rwsem);
699 kctl = snd_ctl_find_id(card, &control->id);
703 index_offset = snd_ctl_get_ioff(kctl, &control->id);
704 vd = &kctl->vd[index_offset];
705 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
706 if (control->indirect != indirect) {
709 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
711 (file && vd->owner != NULL && vd->owner != file)) {
714 snd_ctl_build_ioff(&control->id, kctl, index_offset);
715 result = kctl->put(kctl, control);
718 up_read(&card->controls_rwsem);
719 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
724 up_read(&card->controls_rwsem);
728 static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __user *_control)
730 snd_ctl_elem_value_t *control;
733 control = kmalloc(sizeof(*control), GFP_KERNEL);
736 if (copy_from_user(control, _control, sizeof(*control))) {
740 result = snd_ctl_elem_write(file->card, file, control);
742 if (copy_to_user(_control, control, sizeof(*control)))
748 static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
750 snd_card_t *card = file->card;
751 snd_ctl_elem_id_t id;
752 snd_kcontrol_t *kctl;
753 snd_kcontrol_volatile_t *vd;
756 if (copy_from_user(&id, _id, sizeof(id)))
758 down_write(&card->controls_rwsem);
759 kctl = snd_ctl_find_id(card, &id);
763 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
764 if (vd->owner != NULL)
768 vd->owner_pid = current->pid;
772 up_write(&card->controls_rwsem);
776 static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
778 snd_card_t *card = file->card;
779 snd_ctl_elem_id_t id;
780 snd_kcontrol_t *kctl;
781 snd_kcontrol_volatile_t *vd;
784 if (copy_from_user(&id, _id, sizeof(id)))
786 down_write(&card->controls_rwsem);
787 kctl = snd_ctl_find_id(card, &id);
791 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
792 if (vd->owner == NULL)
794 else if (vd->owner != file)
802 up_write(&card->controls_rwsem);
806 struct user_element {
807 snd_ctl_elem_info_t info;
808 void *elem_data; /* element data */
809 unsigned long elem_data_size; /* size of element data in bytes */
810 void *priv_data; /* private data (like strings for enumerated type) */
811 unsigned long priv_data_size; /* size of private data in bytes */
814 static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
816 struct user_element *ue = kcontrol->private_data;
819 if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
820 uinfo->value.enumerated.items = ue->info.value.enumerated.items;
821 if (uinfo->value.enumerated.item >= ue->info.value.enumerated.items)
822 uinfo->value.enumerated.item = 0;
823 strlcpy(uinfo->value.enumerated.name,
824 (char *)ue->priv_data + uinfo->value.enumerated.item * 64,
830 static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
832 struct user_element *ue = kcontrol->private_data;
834 memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
838 static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
841 struct user_element *ue = kcontrol->private_data;
843 change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
845 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
849 static void snd_ctl_elem_user_free(snd_kcontrol_t * kcontrol)
851 kfree(kcontrol->private_data);
854 static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t __user *_info, int replace)
856 snd_card_t *card = file->card;
857 snd_ctl_elem_info_t info;
858 snd_kcontrol_t kctl, *_kctl;
860 long private_size, extra_size;
861 struct user_element *ue;
864 if (card->user_ctl_count >= MAX_USER_CONTROLS)
866 if (copy_from_user(&info, _info, sizeof(info)))
868 if (info.count > 1024)
870 access = info.access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
871 (info.access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE));
873 memset(&kctl, 0, sizeof(kctl));
874 down_write(&card->controls_rwsem);
875 _kctl = snd_ctl_find_id(card, &info.id);
879 err = snd_ctl_remove(card, _kctl);
886 up_write(&card->controls_rwsem);
889 memcpy(&kctl.id, &info.id, sizeof(info.id));
890 kctl.count = info.owner ? info.owner : 1;
891 access |= SNDRV_CTL_ELEM_ACCESS_USER;
892 kctl.info = snd_ctl_elem_user_info;
893 if (access & SNDRV_CTL_ELEM_ACCESS_READ)
894 kctl.get = snd_ctl_elem_user_get;
895 if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
896 kctl.put = snd_ctl_elem_user_put;
899 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
900 private_size = sizeof(char);
901 if (info.count > 128)
904 case SNDRV_CTL_ELEM_TYPE_INTEGER:
905 private_size = sizeof(long);
906 if (info.count > 128)
909 case SNDRV_CTL_ELEM_TYPE_INTEGER64:
910 private_size = sizeof(long long);
914 case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
915 private_size = sizeof(unsigned int);
916 if (info.count > 128)
918 if (info.value.enumerated.items > 128)
920 extra_size = info.value.enumerated.items * 64;
922 case SNDRV_CTL_ELEM_TYPE_BYTES:
923 private_size = sizeof(unsigned char);
924 if (info.count > 512)
927 case SNDRV_CTL_ELEM_TYPE_IEC958:
928 private_size = sizeof(struct sndrv_aes_iec958);
935 private_size *= info.count;
936 ue = kcalloc(1, sizeof(struct user_element) + private_size + extra_size, GFP_KERNEL);
940 ue->elem_data = (char *)ue + sizeof(ue);
941 ue->elem_data_size = private_size;
943 ue->priv_data = (char *)ue + sizeof(ue) + private_size;
944 ue->priv_data_size = extra_size;
945 if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
946 if (copy_from_user(ue->priv_data, *(char __user **)info.value.enumerated.name, extra_size))
950 kctl.private_free = snd_ctl_elem_user_free;
951 _kctl = snd_ctl_new(&kctl, access);
953 kfree(_kctl->private_data);
956 _kctl->private_data = ue;
957 for (idx = 0; idx < _kctl->count; idx++)
958 _kctl->vd[idx].owner = file;
959 err = snd_ctl_add(card, _kctl);
961 snd_ctl_free_one(_kctl);
965 down_write(&card->controls_rwsem);
966 card->user_ctl_count++;
967 up_write(&card->controls_rwsem);
972 static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
974 snd_ctl_elem_id_t id;
977 if (copy_from_user(&id, _id, sizeof(id)))
979 err = snd_ctl_remove_unlocked_id(file, &id);
981 snd_card_t *card = file->card;
982 down_write(&card->controls_rwsem);
983 card->user_ctl_count--;
984 up_write(&card->controls_rwsem);
989 static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr)
992 if (get_user(subscribe, ptr))
995 subscribe = file->subscribed;
996 if (put_user(subscribe, ptr))
1001 file->subscribed = 1;
1003 } else if (file->subscribed) {
1004 snd_ctl_empty_read_queue(file);
1005 file->subscribed = 0;
1012 * change the power state
1014 static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state)
1016 switch (power_state) {
1017 case SNDRV_CTL_POWER_D0:
1018 if (card->power_state != power_state) {
1019 /* FIXME: pass the correct state value */
1020 card->pm_resume(card, 0);
1021 snd_power_change_state(card, power_state);
1024 case SNDRV_CTL_POWER_D3hot:
1025 if (card->power_state != power_state) {
1026 /* FIXME: pass the correct state value */
1027 card->pm_suspend(card, 0);
1028 snd_power_change_state(card, power_state);
1031 case SNDRV_CTL_POWER_D1:
1032 case SNDRV_CTL_POWER_D2:
1033 case SNDRV_CTL_POWER_D3cold:
1034 /* not supported yet */
1042 static inline int _snd_ctl_ioctl(struct inode *inode, struct file *file,
1043 unsigned int cmd, unsigned long arg)
1045 snd_ctl_file_t *ctl;
1047 struct list_head *list;
1048 snd_kctl_ioctl_t *p;
1049 void __user *argp = (void __user *)arg;
1050 int __user *ip = argp;
1053 ctl = file->private_data;
1055 snd_assert(card != NULL, return -ENXIO);
1057 case SNDRV_CTL_IOCTL_PVERSION:
1058 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1059 case SNDRV_CTL_IOCTL_CARD_INFO:
1060 return snd_ctl_card_info(card, ctl, cmd, argp);
1061 case SNDRV_CTL_IOCTL_ELEM_LIST:
1062 return snd_ctl_elem_list(ctl->card, argp);
1063 case SNDRV_CTL_IOCTL_ELEM_INFO:
1064 return snd_ctl_elem_info(ctl, argp);
1065 case SNDRV_CTL_IOCTL_ELEM_READ:
1066 return snd_ctl_elem_read_user(ctl->card, argp);
1067 case SNDRV_CTL_IOCTL_ELEM_WRITE:
1068 return snd_ctl_elem_write_user(ctl, argp);
1069 case SNDRV_CTL_IOCTL_ELEM_LOCK:
1070 return snd_ctl_elem_lock(ctl, argp);
1071 case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1072 return snd_ctl_elem_unlock(ctl, argp);
1073 case SNDRV_CTL_IOCTL_ELEM_ADD:
1074 return snd_ctl_elem_add(ctl, argp, 0);
1075 case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1076 return snd_ctl_elem_add(ctl, argp, 1);
1077 case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1078 return snd_ctl_elem_remove(ctl, argp);
1079 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1080 return snd_ctl_subscribe_events(ctl, ip);
1081 case SNDRV_CTL_IOCTL_POWER:
1082 if (get_user(err, ip))
1084 if (!capable(CAP_SYS_ADMIN))
1087 if (card->pm_suspend && card->pm_resume) {
1088 snd_power_lock(card);
1089 err = snd_ctl_set_power_state(card, err);
1090 snd_power_unlock(card);
1095 case SNDRV_CTL_IOCTL_POWER_STATE:
1097 return put_user(card->power_state, ip) ? -EFAULT : 0;
1099 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1102 down_read(&snd_ioctl_rwsem);
1103 list_for_each(list, &snd_control_ioctls) {
1104 p = list_entry(list, snd_kctl_ioctl_t, list);
1105 err = p->fioctl(card, ctl, cmd, arg);
1106 if (err != -ENOIOCTLCMD) {
1107 up_read(&snd_ioctl_rwsem);
1111 up_read(&snd_ioctl_rwsem);
1112 snd_printd("unknown ioctl = 0x%x\n", cmd);
1116 /* FIXME: need to unlock BKL to allow preemption */
1117 static int snd_ctl_ioctl(struct inode *inode, struct file *file,
1118 unsigned int cmd, unsigned long arg)
1122 err = _snd_ctl_ioctl(inode, file, cmd, arg);
1127 static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count, loff_t * offset)
1129 snd_ctl_file_t *ctl;
1133 ctl = file->private_data;
1134 snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO);
1135 if (!ctl->subscribed)
1137 if (count < sizeof(snd_ctl_event_t))
1139 spin_lock_irq(&ctl->read_lock);
1140 while (count >= sizeof(snd_ctl_event_t)) {
1142 snd_kctl_event_t *kev;
1143 while (list_empty(&ctl->events)) {
1145 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1149 init_waitqueue_entry(&wait, current);
1150 add_wait_queue(&ctl->change_sleep, &wait);
1151 set_current_state(TASK_INTERRUPTIBLE);
1152 spin_unlock_irq(&ctl->read_lock);
1154 remove_wait_queue(&ctl->change_sleep, &wait);
1155 if (signal_pending(current))
1156 return result > 0 ? result : -ERESTARTSYS;
1157 spin_lock_irq(&ctl->read_lock);
1159 kev = snd_kctl_event(ctl->events.next);
1160 ev.type = SNDRV_CTL_EVENT_ELEM;
1161 ev.data.elem.mask = kev->mask;
1162 ev.data.elem.id = kev->id;
1163 list_del(&kev->list);
1164 spin_unlock_irq(&ctl->read_lock);
1166 if (copy_to_user(buffer, &ev, sizeof(snd_ctl_event_t))) {
1170 spin_lock_irq(&ctl->read_lock);
1171 buffer += sizeof(snd_ctl_event_t);
1172 count -= sizeof(snd_ctl_event_t);
1173 result += sizeof(snd_ctl_event_t);
1176 spin_unlock_irq(&ctl->read_lock);
1178 return result > 0 ? result : err;
1181 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1184 snd_ctl_file_t *ctl;
1186 ctl = file->private_data;
1187 if (!ctl->subscribed)
1189 poll_wait(file, &ctl->change_sleep, wait);
1192 if (!list_empty(&ctl->events))
1193 mask |= POLLIN | POLLRDNORM;
1199 * register the device-specific control-ioctls.
1200 * called from each device manager like pcm.c, hwdep.c, etc.
1202 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1204 snd_kctl_ioctl_t *pn;
1206 pn = kcalloc(1, sizeof(snd_kctl_ioctl_t), GFP_KERNEL);
1210 down_write(&snd_ioctl_rwsem);
1211 list_add_tail(&pn->list, &snd_control_ioctls);
1212 up_write(&snd_ioctl_rwsem);
1217 * de-register the device-specific control-ioctls.
1219 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1221 struct list_head *list;
1222 snd_kctl_ioctl_t *p;
1224 snd_runtime_check(fcn != NULL, return -EINVAL);
1225 down_write(&snd_ioctl_rwsem);
1226 list_for_each(list, &snd_control_ioctls) {
1227 p = list_entry(list, snd_kctl_ioctl_t, list);
1228 if (p->fioctl == fcn) {
1230 up_write(&snd_ioctl_rwsem);
1235 up_write(&snd_ioctl_rwsem);
1240 static int snd_ctl_fasync(int fd, struct file * file, int on)
1242 snd_ctl_file_t *ctl;
1244 ctl = file->private_data;
1245 err = fasync_helper(fd, file, on, &ctl->fasync);
1255 static struct file_operations snd_ctl_f_ops =
1257 .owner = THIS_MODULE,
1258 .read = snd_ctl_read,
1259 .open = snd_ctl_open,
1260 .release = snd_ctl_release,
1261 .poll = snd_ctl_poll,
1262 .ioctl = snd_ctl_ioctl,
1263 .fasync = snd_ctl_fasync,
1266 static snd_minor_t snd_ctl_reg =
1269 .f_ops = &snd_ctl_f_ops,
1273 * registration of the control device
1275 static int snd_ctl_dev_register(snd_device_t *device)
1277 snd_card_t *card = device->device_data;
1281 snd_assert(card != NULL, return -ENXIO);
1282 cardnum = card->number;
1283 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1284 sprintf(name, "controlC%i", cardnum);
1285 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL,
1286 card, 0, &snd_ctl_reg, name)) < 0)
1292 * disconnection of the control device
1294 static int snd_ctl_dev_disconnect(snd_device_t *device)
1296 snd_card_t *card = device->device_data;
1297 struct list_head *flist;
1298 snd_ctl_file_t *ctl;
1300 down_read(&card->controls_rwsem);
1301 list_for_each(flist, &card->ctl_files) {
1302 ctl = snd_ctl_file(flist);
1303 wake_up(&ctl->change_sleep);
1304 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1306 up_read(&card->controls_rwsem);
1313 static int snd_ctl_dev_free(snd_device_t *device)
1315 snd_card_t *card = device->device_data;
1316 snd_kcontrol_t *control;
1318 down_write(&card->controls_rwsem);
1319 while (!list_empty(&card->controls)) {
1320 control = snd_kcontrol(card->controls.next);
1321 snd_ctl_remove(card, control);
1323 up_write(&card->controls_rwsem);
1328 * de-registration of the control device
1330 static int snd_ctl_dev_unregister(snd_device_t *device)
1332 snd_card_t *card = device->device_data;
1335 snd_assert(card != NULL, return -ENXIO);
1336 cardnum = card->number;
1337 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1338 if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, card, 0)) < 0)
1340 return snd_ctl_dev_free(device);
1344 * create control core:
1345 * called from init.c
1347 int snd_ctl_create(snd_card_t *card)
1349 static snd_device_ops_t ops = {
1350 .dev_free = snd_ctl_dev_free,
1351 .dev_register = snd_ctl_dev_register,
1352 .dev_disconnect = snd_ctl_dev_disconnect,
1353 .dev_unregister = snd_ctl_dev_unregister
1356 snd_assert(card != NULL, return -ENXIO);
1357 return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);