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 typedef struct _snd_kctl_ioctl {
35 struct list_head list; /* list of all ioctls */
36 snd_kctl_ioctl_func_t fioctl;
39 #define snd_kctl_ioctl(n) list_entry(n, snd_kctl_ioctl_t, list)
41 static DECLARE_RWSEM(snd_ioctl_rwsem);
42 static LIST_HEAD(snd_control_ioctls);
44 static int snd_ctl_open(struct inode *inode, struct file *file)
46 int cardnum = SNDRV_MINOR_CARD(iminor(inode));
52 card = snd_cards[cardnum];
57 err = snd_card_file_add(card, file);
62 if (!try_module_get(card->module)) {
66 ctl = kcalloc(1, sizeof(*ctl), GFP_KERNEL);
71 INIT_LIST_HEAD(&ctl->events);
72 init_waitqueue_head(&ctl->change_sleep);
73 spin_lock_init(&ctl->read_lock);
75 ctl->pid = current->pid;
76 file->private_data = ctl;
77 write_lock_irqsave(&card->ctl_files_rwlock, flags);
78 list_add_tail(&ctl->list, &card->ctl_files);
79 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
83 module_put(card->module);
85 snd_card_file_remove(card, file);
90 static void snd_ctl_empty_read_queue(snd_ctl_file_t * ctl)
92 snd_kctl_event_t *cread;
94 spin_lock(&ctl->read_lock);
95 while (!list_empty(&ctl->events)) {
96 cread = snd_kctl_event(ctl->events.next);
97 list_del(&cread->list);
100 spin_unlock(&ctl->read_lock);
103 static int snd_ctl_release(struct inode *inode, struct file *file)
106 struct list_head *list;
109 snd_kcontrol_t *control;
112 ctl = file->private_data;
113 fasync_helper(-1, file, 0, &ctl->fasync);
114 file->private_data = NULL;
116 write_lock_irqsave(&card->ctl_files_rwlock, flags);
117 list_del(&ctl->list);
118 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
119 down_write(&card->controls_rwsem);
120 list_for_each(list, &card->controls) {
121 control = snd_kcontrol(list);
122 for (idx = 0; idx < control->count; idx++)
123 if (control->vd[idx].owner == ctl)
124 control->vd[idx].owner = NULL;
126 up_write(&card->controls_rwsem);
127 snd_ctl_empty_read_queue(ctl);
129 module_put(card->module);
130 snd_card_file_remove(card, file);
134 void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id)
137 struct list_head *flist;
139 snd_kctl_event_t *ev;
141 snd_runtime_check(card != NULL && id != NULL, return);
142 read_lock(&card->ctl_files_rwlock);
143 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
144 card->mixer_oss_change_count++;
146 list_for_each(flist, &card->ctl_files) {
147 struct list_head *elist;
148 ctl = snd_ctl_file(flist);
149 if (!ctl->subscribed)
151 spin_lock_irqsave(&ctl->read_lock, flags);
152 list_for_each(elist, &ctl->events) {
153 ev = snd_kctl_event(elist);
154 if (ev->id.numid == id->numid) {
159 ev = kcalloc(1, sizeof(*ev), GFP_ATOMIC);
163 list_add_tail(&ev->list, &ctl->events);
165 snd_printk(KERN_ERR "No memory available to allocate event\n");
168 wake_up(&ctl->change_sleep);
169 spin_unlock_irqrestore(&ctl->read_lock, flags);
170 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
172 read_unlock(&card->ctl_files_rwlock);
176 * snd_ctl_new - create a control instance from the template
177 * @control: the control template
178 * @access: the default control access
180 * Allocates a new snd_kcontrol_t instance and copies the given template
181 * to the new instance. It does not copy volatile data (access).
183 * Returns the pointer of the new instance, or NULL on failure.
185 snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access)
187 snd_kcontrol_t *kctl;
190 snd_runtime_check(control != NULL, return NULL);
191 snd_runtime_check(control->count > 0, return NULL);
192 kctl = kcalloc(1, sizeof(*kctl) + sizeof(snd_kcontrol_volatile_t) * control->count, GFP_KERNEL);
196 for (idx = 0; idx < kctl->count; idx++)
197 kctl->vd[idx].access = access;
202 * snd_ctl_new1 - create a control instance from the template
203 * @ncontrol: the initialization record
204 * @private_data: the private data to set
206 * Allocates a new snd_kcontrol_t instance and initialize from the given
207 * template. When the access field of ncontrol is 0, it's assumed as
208 * READWRITE access. When the count field is 0, it's assumes as one.
210 * Returns the pointer of the newly generated instance, or NULL on failure.
212 snd_kcontrol_t *snd_ctl_new1(snd_kcontrol_new_t * ncontrol, void *private_data)
217 snd_runtime_check(ncontrol != NULL, return NULL);
218 snd_assert(ncontrol->info != NULL, return NULL);
219 memset(&kctl, 0, sizeof(kctl));
220 kctl.id.iface = ncontrol->iface;
221 kctl.id.device = ncontrol->device;
222 kctl.id.subdevice = ncontrol->subdevice;
224 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
225 kctl.id.index = ncontrol->index;
226 kctl.count = ncontrol->count ? ncontrol->count : 1;
227 access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
228 (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE|
229 SNDRV_CTL_ELEM_ACCESS_DINDIRECT|SNDRV_CTL_ELEM_ACCESS_INDIRECT));
230 kctl.info = ncontrol->info;
231 kctl.get = ncontrol->get;
232 kctl.put = ncontrol->put;
233 kctl.private_value = ncontrol->private_value;
234 kctl.private_data = private_data;
235 return snd_ctl_new(&kctl, access);
239 * snd_ctl_free_one - release the control instance
240 * @kcontrol: the control instance
242 * Releases the control instance created via snd_ctl_new()
244 * Don't call this after the control was added to the card.
246 void snd_ctl_free_one(snd_kcontrol_t * kcontrol)
249 if (kcontrol->private_free)
250 kcontrol->private_free(kcontrol);
255 static unsigned int snd_ctl_hole_check(snd_card_t * card,
258 struct list_head *list;
259 snd_kcontrol_t *kctl;
261 list_for_each(list, &card->controls) {
262 kctl = snd_kcontrol(list);
263 if ((kctl->id.numid <= card->last_numid &&
264 kctl->id.numid + kctl->count > card->last_numid) ||
265 (kctl->id.numid <= card->last_numid + count - 1 &&
266 kctl->id.numid + kctl->count > card->last_numid + count - 1))
267 return card->last_numid = kctl->id.numid + kctl->count - 1;
269 return card->last_numid;
272 static int snd_ctl_find_hole(snd_card_t * card, unsigned int count)
274 unsigned int last_numid, iter = 100000;
276 last_numid = card->last_numid;
277 while (last_numid != snd_ctl_hole_check(card, count)) {
279 /* this situation is very unlikely */
280 snd_printk(KERN_ERR "unable to allocate new control numid\n");
283 last_numid = card->last_numid;
289 * snd_ctl_add - add the control instance to the card
290 * @card: the card instance
291 * @kcontrol: the control instance to add
293 * Adds the control instance created via snd_ctl_new() or
294 * snd_ctl_new1() to the given card. Assigns also an unique
295 * numid used for fast search.
297 * Returns zero if successful, or a negative error code on failure.
299 * It frees automatically the control which cannot be added.
301 int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol)
303 snd_ctl_elem_id_t id;
306 snd_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
307 snd_assert(kcontrol->info != NULL, return -EINVAL);
309 down_write(&card->controls_rwsem);
310 if (snd_ctl_find_id(card, &id)) {
311 up_write(&card->controls_rwsem);
312 snd_ctl_free_one(kcontrol);
313 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
321 if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
322 up_write(&card->controls_rwsem);
323 snd_ctl_free_one(kcontrol);
326 list_add_tail(&kcontrol->list, &card->controls);
327 card->controls_count += kcontrol->count;
328 kcontrol->id.numid = card->last_numid + 1;
329 card->last_numid += kcontrol->count;
330 up_write(&card->controls_rwsem);
331 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
332 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
337 * snd_ctl_remove - remove the control from the card and release it
338 * @card: the card instance
339 * @kcontrol: the control instance to remove
341 * Removes the control from the card and then releases the instance.
342 * You don't need to call snd_ctl_free_one(). You must be in
343 * the write lock - down_write(&card->controls_rwsem).
345 * Returns 0 if successful, or a negative error code on failure.
347 int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol)
349 snd_ctl_elem_id_t id;
352 snd_runtime_check(card != NULL && kcontrol != NULL, return -EINVAL);
353 list_del(&kcontrol->list);
354 card->controls_count -= kcontrol->count;
356 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
357 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
358 snd_ctl_free_one(kcontrol);
363 * snd_ctl_remove_id - remove the control of the given id and release it
364 * @card: the card instance
365 * @id: the control id to remove
367 * Finds the control instance with the given id, removes it from the
368 * card list and releases it.
370 * Returns 0 if successful, or a negative error code on failure.
372 int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id)
374 snd_kcontrol_t *kctl;
377 down_write(&card->controls_rwsem);
378 kctl = snd_ctl_find_id(card, id);
380 up_write(&card->controls_rwsem);
383 ret = snd_ctl_remove(card, kctl);
384 up_write(&card->controls_rwsem);
389 * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
390 * @file: active control handle
391 * @id: the control id to remove
393 * Finds the control instance with the given id, removes it from the
394 * card list and releases it.
396 * Returns 0 if successful, or a negative error code on failure.
398 static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *id)
400 snd_card_t *card = file->card;
401 snd_kcontrol_t *kctl;
404 down_write(&card->controls_rwsem);
405 kctl = snd_ctl_find_id(card, id);
407 up_write(&card->controls_rwsem);
410 for (idx = 0; idx < kctl->count; idx++)
411 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
412 up_write(&card->controls_rwsem);
415 ret = snd_ctl_remove(card, kctl);
416 up_write(&card->controls_rwsem);
421 * snd_ctl_rename_id - replace the id of a control on the card
422 * @card: the card instance
423 * @src_id: the old id
424 * @dst_id: the new id
426 * Finds the control with the old id from the card, and replaces the
427 * id with the new one.
429 * Returns zero if successful, or a negative error code on failure.
431 int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id)
433 snd_kcontrol_t *kctl;
435 down_write(&card->controls_rwsem);
436 kctl = snd_ctl_find_id(card, src_id);
438 up_write(&card->controls_rwsem);
442 kctl->id.numid = card->last_numid + 1;
443 card->last_numid += kctl->count;
444 up_write(&card->controls_rwsem);
449 * snd_ctl_find_numid - find the control instance with the given number-id
450 * @card: the card instance
451 * @numid: the number-id to search
453 * Finds the control instance with the given number-id from the card.
455 * Returns the pointer of the instance if found, or NULL if not.
457 * The caller must down card->controls_rwsem before calling this function
458 * (if the race condition can happen).
460 snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid)
462 struct list_head *list;
463 snd_kcontrol_t *kctl;
465 snd_runtime_check(card != NULL && numid != 0, return NULL);
466 list_for_each(list, &card->controls) {
467 kctl = snd_kcontrol(list);
468 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
475 * snd_ctl_find_id - find the control instance with the given id
476 * @card: the card instance
477 * @id: the id to search
479 * Finds the control instance with the given id from the card.
481 * Returns the pointer of the instance if found, or NULL if not.
483 * The caller must down card->controls_rwsem before calling this function
484 * (if the race condition can happen).
486 snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id)
488 struct list_head *list;
489 snd_kcontrol_t *kctl;
491 snd_runtime_check(card != NULL && id != NULL, return NULL);
493 return snd_ctl_find_numid(card, id->numid);
494 list_for_each(list, &card->controls) {
495 kctl = snd_kcontrol(list);
496 if (kctl->id.iface != id->iface)
498 if (kctl->id.device != id->device)
500 if (kctl->id.subdevice != id->subdevice)
502 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
504 if (kctl->id.index > id->index)
506 if (kctl->id.index + kctl->count <= id->index)
513 static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl,
514 unsigned int cmd, void __user *arg)
516 snd_ctl_card_info_t info;
518 memset(&info, 0, sizeof(info));
519 down_read(&snd_ioctl_rwsem);
520 info.card = card->number;
521 strlcpy(info.id, card->id, sizeof(info.id));
522 strlcpy(info.driver, card->driver, sizeof(info.driver));
523 strlcpy(info.name, card->shortname, sizeof(info.name));
524 strlcpy(info.longname, card->longname, sizeof(info.longname));
525 strlcpy(info.mixername, card->mixername, sizeof(info.mixername));
526 strlcpy(info.components, card->components, sizeof(info.components));
527 up_read(&snd_ioctl_rwsem);
528 if (copy_to_user(arg, &info, sizeof(snd_ctl_card_info_t)))
533 static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list)
535 struct list_head *plist;
536 snd_ctl_elem_list_t list;
537 snd_kcontrol_t *kctl;
538 snd_ctl_elem_id_t *dst, *id;
539 unsigned int offset, space, first, jidx;
541 if (copy_from_user(&list, _list, sizeof(list)))
543 offset = list.offset;
546 /* try limit maximum space */
550 /* allocate temporary buffer for atomic operation */
551 dst = vmalloc(space * sizeof(snd_ctl_elem_id_t));
554 down_read(&card->controls_rwsem);
555 list.count = card->controls_count;
556 plist = card->controls.next;
557 while (plist != &card->controls) {
560 kctl = snd_kcontrol(plist);
561 if (offset < kctl->count)
563 offset -= kctl->count;
568 while (space > 0 && plist != &card->controls) {
569 kctl = snd_kcontrol(plist);
570 for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
571 snd_ctl_build_ioff(id, kctl, jidx);
579 up_read(&card->controls_rwsem);
580 if (list.used > 0 && copy_to_user(list.pids, dst, list.used * sizeof(snd_ctl_elem_id_t))) {
586 down_read(&card->controls_rwsem);
587 list.count = card->controls_count;
588 up_read(&card->controls_rwsem);
590 if (copy_to_user(_list, &list, sizeof(list)))
595 static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __user *_info)
597 snd_card_t *card = ctl->card;
598 snd_ctl_elem_info_t info;
599 snd_kcontrol_t *kctl;
600 snd_kcontrol_volatile_t *vd;
601 unsigned int index_offset;
604 if (copy_from_user(&info, _info, sizeof(info)))
606 down_read(&card->controls_rwsem);
607 kctl = snd_ctl_find_id(card, &info.id);
609 up_read(&card->controls_rwsem);
612 #ifdef CONFIG_SND_DEBUG
615 result = kctl->info(kctl, &info);
617 snd_assert(info.access == 0, );
618 index_offset = snd_ctl_get_ioff(kctl, &info.id);
619 vd = &kctl->vd[index_offset];
620 snd_ctl_build_ioff(&info.id, kctl, index_offset);
621 info.access = vd->access;
623 info.access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
624 if (vd->owner == ctl)
625 info.access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
626 info.owner = vd->owner_pid;
631 up_read(&card->controls_rwsem);
633 if (copy_to_user(_info, &info, sizeof(info)))
638 int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control)
640 snd_kcontrol_t *kctl;
641 snd_kcontrol_volatile_t *vd;
642 unsigned int index_offset;
643 int result, indirect;
645 down_read(&card->controls_rwsem);
646 kctl = snd_ctl_find_id(card, &control->id);
650 index_offset = snd_ctl_get_ioff(kctl, &control->id);
651 vd = &kctl->vd[index_offset];
652 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
653 if (control->indirect != indirect) {
656 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) && kctl->get != NULL) {
657 snd_ctl_build_ioff(&control->id, kctl, index_offset);
658 result = kctl->get(kctl, control);
664 up_read(&card->controls_rwsem);
668 static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user *_control)
670 snd_ctl_elem_value_t *control;
673 control = kmalloc(sizeof(*control), GFP_KERNEL);
676 if (copy_from_user(control, _control, sizeof(*control))) {
680 result = snd_ctl_elem_read(card, control);
682 if (copy_to_user(_control, control, sizeof(*control)))
688 int snd_ctl_elem_write(snd_ctl_file_t *file, snd_ctl_elem_value_t *control)
690 snd_card_t *card = file->card;
691 snd_kcontrol_t *kctl;
692 snd_kcontrol_volatile_t *vd;
693 unsigned int index_offset;
694 int result, indirect;
696 down_read(&card->controls_rwsem);
697 kctl = snd_ctl_find_id(card, &control->id);
701 index_offset = snd_ctl_get_ioff(kctl, &control->id);
702 vd = &kctl->vd[index_offset];
703 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
704 if (control->indirect != indirect) {
707 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
709 (vd->owner != NULL && vd->owner != file)) {
712 snd_ctl_build_ioff(&control->id, kctl, index_offset);
713 result = kctl->put(kctl, control);
716 up_read(&card->controls_rwsem);
717 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
722 up_read(&card->controls_rwsem);
726 static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __user *_control)
728 snd_ctl_elem_value_t *control;
731 control = kmalloc(sizeof(*control), GFP_KERNEL);
734 if (copy_from_user(control, _control, sizeof(*control))) {
738 result = snd_ctl_elem_write(file, control);
740 if (copy_to_user(_control, control, sizeof(*control)))
746 static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
748 snd_card_t *card = file->card;
749 snd_ctl_elem_id_t id;
750 snd_kcontrol_t *kctl;
751 snd_kcontrol_volatile_t *vd;
754 if (copy_from_user(&id, _id, sizeof(id)))
756 down_write(&card->controls_rwsem);
757 kctl = snd_ctl_find_id(card, &id);
761 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
762 if (vd->owner != NULL)
766 vd->owner_pid = current->pid;
770 up_write(&card->controls_rwsem);
774 static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
776 snd_card_t *card = file->card;
777 snd_ctl_elem_id_t id;
778 snd_kcontrol_t *kctl;
779 snd_kcontrol_volatile_t *vd;
782 if (copy_from_user(&id, _id, sizeof(id)))
784 down_write(&card->controls_rwsem);
785 kctl = snd_ctl_find_id(card, &id);
789 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
790 if (vd->owner == NULL)
792 else if (vd->owner != file)
800 up_write(&card->controls_rwsem);
804 struct user_element {
805 enum sndrv_ctl_elem_type type; /* element type */
806 unsigned int elem_count; /* count of elements */
812 void *elem_data; /* element data */
813 unsigned long elem_data_size; /* size of element data in bytes */
814 void *priv_data; /* private data (like strings for enumerated type) */
815 unsigned long priv_data_size; /* size of private data in bytes */
816 unsigned short dimen_count; /* count of dimensions */
817 unsigned short dimen[0]; /* array of dimensions */
820 static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
822 struct user_element *ue = kcontrol->private_data;
824 uinfo->type = ue->type;
825 uinfo->count = ue->elem_count;
826 if (ue->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
827 uinfo->value.enumerated.items = ue->u.enumerated.items;
828 if (uinfo->value.enumerated.item >= ue->u.enumerated.items)
829 uinfo->value.enumerated.item = 0;
830 strlcpy(uinfo->value.enumerated.name,
831 (char *)ue->priv_data + uinfo->value.enumerated.item * 64,
837 static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
839 struct user_element *ue = kcontrol->private_data;
841 memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
845 static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
848 struct user_element *ue = kcontrol->private_data;
850 change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size);
851 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
855 static void snd_ctl_elem_user_free(snd_kcontrol_t * kcontrol)
857 kfree(kcontrol->private_data);
860 static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t __user *_info, int replace)
862 snd_card_t *card = file->card;
863 snd_ctl_elem_info_t info;
864 snd_kcontrol_t kctl, *_kctl;
866 long private_size, dimen_size, extra_size;
867 struct user_element *ue;
870 if (copy_from_user(&info, _info, sizeof(info)))
872 if (info.count > 1024)
874 access = info.access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
875 (info.access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE|
876 SNDRV_CTL_ELEM_ACCESS_DINDIRECT|SNDRV_CTL_ELEM_ACCESS_INDIRECT));
877 if (access & (SNDRV_CTL_ELEM_ACCESS_DINDIRECT | SNDRV_CTL_ELEM_ACCESS_INDIRECT))
880 memset(&kctl, 0, sizeof(kctl));
881 down_write(&card->controls_rwsem);
882 if (!!((_kctl = snd_ctl_find_id(card, &info.id)) != NULL) ^ replace) {
883 up_write(&card->controls_rwsem);
884 return !replace ? -EBUSY : -ENOENT;
887 err = snd_ctl_remove(card, _kctl);
889 up_write(&card->controls_rwsem);
893 up_write(&card->controls_rwsem);
894 memcpy(&kctl.id, &info.id, sizeof(info.id));
895 kctl.count = info.owner ? info.owner : 1;
896 access |= SNDRV_CTL_ELEM_ACCESS_USER;
897 kctl.info = snd_ctl_elem_user_info;
898 if (access & SNDRV_CTL_ELEM_ACCESS_READ)
899 kctl.get = snd_ctl_elem_user_get;
900 if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
901 kctl.put = snd_ctl_elem_user_put;
904 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
905 private_size = sizeof(char);
906 if (info.count > 128)
909 case SNDRV_CTL_ELEM_TYPE_INTEGER:
910 private_size = sizeof(long);
911 if (info.count > 128)
914 case SNDRV_CTL_ELEM_TYPE_INTEGER64:
915 private_size = sizeof(long long);
919 case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
920 private_size = sizeof(unsigned int);
921 if (info.count > 128)
923 if (info.value.enumerated.items > 1024)
925 extra_size = info.value.enumerated.items * 64;
927 case SNDRV_CTL_ELEM_TYPE_BYTES:
928 private_size = sizeof(unsigned char);
929 if (info.count > 512)
932 case SNDRV_CTL_ELEM_TYPE_IEC958:
933 private_size = sizeof(struct sndrv_aes_iec958);
940 private_size *= info.count;
941 if (private_size > 1024 * 1024)
944 if (!(info.access & SNDRV_CTL_ELEM_ACCESS_DINDIRECT))
945 for (idx = 0; idx < 4 && info.dimen.d[idx]; idx++)
946 dimen_size += sizeof(unsigned short);
947 ue = kcalloc(1, sizeof(struct user_element) + dimen_size + private_size + extra_size, GFP_KERNEL);
950 ue->type = info.type;
951 ue->elem_count = info.count;
952 if (!(info.access & SNDRV_CTL_ELEM_ACCESS_DINDIRECT)) {
953 for (idx = 0; idx < 4 && info.dimen.d[idx]; idx++)
954 ue->dimen[idx] = info.dimen.d[idx];
955 ue->dimen_count = dimen_size / sizeof(unsigned short);
957 ue->elem_data = (char *)ue + sizeof(ue) + dimen_size;
958 ue->elem_data_size = private_size;
960 ue->priv_data = (char *)ue + sizeof(ue) + dimen_size + private_size;
961 ue->priv_data_size = extra_size;
962 if (ue->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
963 if (copy_from_user(ue->priv_data, *(char **)info.value.enumerated.name, extra_size))
965 ue->u.enumerated.items = info.value.enumerated.items;
968 kctl.private_free = snd_ctl_elem_user_free;
969 _kctl = snd_ctl_new(&kctl, access);
971 kfree(_kctl->private_data);
974 _kctl->private_data = ue;
975 for (idx = 0; idx < _kctl->count; idx++)
976 _kctl->vd[idx].owner = file;
977 err = snd_ctl_add(card, _kctl);
979 snd_ctl_free_one(_kctl);
985 static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id)
987 snd_ctl_elem_id_t id;
989 if (copy_from_user(&id, _id, sizeof(id)))
991 return snd_ctl_remove_unlocked_id(file, &id);
994 static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr)
997 if (get_user(subscribe, ptr))
1000 subscribe = file->subscribed;
1001 if (put_user(subscribe, ptr))
1006 file->subscribed = 1;
1008 } else if (file->subscribed) {
1009 snd_ctl_empty_read_queue(file);
1010 file->subscribed = 0;
1017 * change the power state
1019 static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state)
1021 switch (power_state) {
1022 case SNDRV_CTL_POWER_D0:
1023 case SNDRV_CTL_POWER_D1:
1024 case SNDRV_CTL_POWER_D2:
1025 if (card->power_state != power_state)
1026 /* FIXME: pass the correct state value */
1027 card->pm_resume(card, 0);
1029 case SNDRV_CTL_POWER_D3hot:
1030 case SNDRV_CTL_POWER_D3cold:
1031 if (card->power_state != power_state)
1032 /* FIXME: pass the correct state value */
1033 card->pm_suspend(card, 0);
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:
1274 * called from init.c
1276 int snd_ctl_register(snd_card_t *card)
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:
1293 * called from init.c
1295 int snd_ctl_disconnect(snd_card_t *card)
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);
1311 * de-registration of the control device:
1312 * called from init.c
1314 int snd_ctl_unregister(snd_card_t *card)
1317 snd_kcontrol_t *control;
1319 snd_assert(card != NULL, return -ENXIO);
1320 cardnum = card->number;
1321 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1322 if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, card, 0)) < 0)
1324 down_write(&card->controls_rwsem);
1325 while (!list_empty(&card->controls)) {
1326 control = snd_kcontrol(card->controls.next);
1327 snd_ctl_remove(card, control);
1329 up_write(&card->controls_rwsem);