2 * Routines for driver control interface
3 * Copyright (c) by Jaroslav Kysela <perex@perex.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 <linux/threads.h>
23 #include <linux/interrupt.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/time.h>
28 #include <linux/sched/signal.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
36 #define MAX_CONTROL_COUNT 1028
38 struct snd_kctl_ioctl
{
39 struct list_head list
; /* list of all ioctls */
40 snd_kctl_ioctl_func_t fioctl
;
43 static DECLARE_RWSEM(snd_ioctl_rwsem
);
44 static LIST_HEAD(snd_control_ioctls
);
46 static LIST_HEAD(snd_control_compat_ioctls
);
49 static int snd_ctl_open(struct inode
*inode
, struct file
*file
)
52 struct snd_card
*card
;
53 struct snd_ctl_file
*ctl
;
56 err
= nonseekable_open(inode
, file
);
60 card
= snd_lookup_minor_data(iminor(inode
), SNDRV_DEVICE_TYPE_CONTROL
);
65 err
= snd_card_file_add(card
, file
);
70 if (!try_module_get(card
->module
)) {
74 ctl
= kzalloc(sizeof(*ctl
), GFP_KERNEL
);
79 INIT_LIST_HEAD(&ctl
->events
);
80 init_waitqueue_head(&ctl
->change_sleep
);
81 spin_lock_init(&ctl
->read_lock
);
83 for (i
= 0; i
< SND_CTL_SUBDEV_ITEMS
; i
++)
84 ctl
->preferred_subdevice
[i
] = -1;
85 ctl
->pid
= get_pid(task_pid(current
));
86 file
->private_data
= ctl
;
87 write_lock_irqsave(&card
->ctl_files_rwlock
, flags
);
88 list_add_tail(&ctl
->list
, &card
->ctl_files
);
89 write_unlock_irqrestore(&card
->ctl_files_rwlock
, flags
);
94 module_put(card
->module
);
96 snd_card_file_remove(card
, file
);
103 static void snd_ctl_empty_read_queue(struct snd_ctl_file
* ctl
)
106 struct snd_kctl_event
*cread
;
108 spin_lock_irqsave(&ctl
->read_lock
, flags
);
109 while (!list_empty(&ctl
->events
)) {
110 cread
= snd_kctl_event(ctl
->events
.next
);
111 list_del(&cread
->list
);
114 spin_unlock_irqrestore(&ctl
->read_lock
, flags
);
117 static int snd_ctl_release(struct inode
*inode
, struct file
*file
)
120 struct snd_card
*card
;
121 struct snd_ctl_file
*ctl
;
122 struct snd_kcontrol
*control
;
125 ctl
= file
->private_data
;
126 file
->private_data
= NULL
;
128 write_lock_irqsave(&card
->ctl_files_rwlock
, flags
);
129 list_del(&ctl
->list
);
130 write_unlock_irqrestore(&card
->ctl_files_rwlock
, flags
);
131 down_write(&card
->controls_rwsem
);
132 list_for_each_entry(control
, &card
->controls
, list
)
133 for (idx
= 0; idx
< control
->count
; idx
++)
134 if (control
->vd
[idx
].owner
== ctl
)
135 control
->vd
[idx
].owner
= NULL
;
136 up_write(&card
->controls_rwsem
);
137 snd_ctl_empty_read_queue(ctl
);
140 module_put(card
->module
);
141 snd_card_file_remove(card
, file
);
146 * snd_ctl_notify - Send notification to user-space for a control change
147 * @card: the card to send notification
148 * @mask: the event mask, SNDRV_CTL_EVENT_*
149 * @id: the ctl element id to send notification
151 * This function adds an event record with the given id and mask, appends
152 * to the list and wakes up the user-space for notification. This can be
153 * called in the atomic context.
155 void snd_ctl_notify(struct snd_card
*card
, unsigned int mask
,
156 struct snd_ctl_elem_id
*id
)
159 struct snd_ctl_file
*ctl
;
160 struct snd_kctl_event
*ev
;
162 if (snd_BUG_ON(!card
|| !id
))
166 read_lock(&card
->ctl_files_rwlock
);
167 #if IS_ENABLED(CONFIG_SND_MIXER_OSS)
168 card
->mixer_oss_change_count
++;
170 list_for_each_entry(ctl
, &card
->ctl_files
, list
) {
171 if (!ctl
->subscribed
)
173 spin_lock_irqsave(&ctl
->read_lock
, flags
);
174 list_for_each_entry(ev
, &ctl
->events
, list
) {
175 if (ev
->id
.numid
== id
->numid
) {
180 ev
= kzalloc(sizeof(*ev
), GFP_ATOMIC
);
184 list_add_tail(&ev
->list
, &ctl
->events
);
186 dev_err(card
->dev
, "No memory available to allocate event\n");
189 wake_up(&ctl
->change_sleep
);
190 spin_unlock_irqrestore(&ctl
->read_lock
, flags
);
191 kill_fasync(&ctl
->fasync
, SIGIO
, POLL_IN
);
193 read_unlock(&card
->ctl_files_rwlock
);
195 EXPORT_SYMBOL(snd_ctl_notify
);
198 * snd_ctl_new - create a new control instance with some elements
199 * @kctl: the pointer to store new control instance
200 * @count: the number of elements in this control
201 * @access: the default access flags for elements in this control
202 * @file: given when locking these elements
204 * Allocates a memory object for a new control instance. The instance has
205 * elements as many as the given number (@count). Each element has given
206 * access permissions (@access). Each element is locked when @file is given.
208 * Return: 0 on success, error code on failure
210 static int snd_ctl_new(struct snd_kcontrol
**kctl
, unsigned int count
,
211 unsigned int access
, struct snd_ctl_file
*file
)
216 if (count
== 0 || count
> MAX_CONTROL_COUNT
)
219 size
= sizeof(struct snd_kcontrol
);
220 size
+= sizeof(struct snd_kcontrol_volatile
) * count
;
222 *kctl
= kzalloc(size
, GFP_KERNEL
);
226 for (idx
= 0; idx
< count
; idx
++) {
227 (*kctl
)->vd
[idx
].access
= access
;
228 (*kctl
)->vd
[idx
].owner
= file
;
230 (*kctl
)->count
= count
;
236 * snd_ctl_new1 - create a control instance from the template
237 * @ncontrol: the initialization record
238 * @private_data: the private data to set
240 * Allocates a new struct snd_kcontrol instance and initialize from the given
241 * template. When the access field of ncontrol is 0, it's assumed as
242 * READWRITE access. When the count field is 0, it's assumes as one.
244 * Return: The pointer of the newly generated instance, or %NULL on failure.
246 struct snd_kcontrol
*snd_ctl_new1(const struct snd_kcontrol_new
*ncontrol
,
249 struct snd_kcontrol
*kctl
;
254 if (snd_BUG_ON(!ncontrol
|| !ncontrol
->info
))
257 count
= ncontrol
->count
;
261 access
= ncontrol
->access
;
263 access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
;
264 access
&= (SNDRV_CTL_ELEM_ACCESS_READWRITE
|
265 SNDRV_CTL_ELEM_ACCESS_VOLATILE
|
266 SNDRV_CTL_ELEM_ACCESS_INACTIVE
|
267 SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
|
268 SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND
|
269 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
);
271 err
= snd_ctl_new(&kctl
, count
, access
, NULL
);
275 /* The 'numid' member is decided when calling snd_ctl_add(). */
276 kctl
->id
.iface
= ncontrol
->iface
;
277 kctl
->id
.device
= ncontrol
->device
;
278 kctl
->id
.subdevice
= ncontrol
->subdevice
;
279 if (ncontrol
->name
) {
280 strlcpy(kctl
->id
.name
, ncontrol
->name
, sizeof(kctl
->id
.name
));
281 if (strcmp(ncontrol
->name
, kctl
->id
.name
) != 0)
282 pr_warn("ALSA: Control name '%s' truncated to '%s'\n",
283 ncontrol
->name
, kctl
->id
.name
);
285 kctl
->id
.index
= ncontrol
->index
;
287 kctl
->info
= ncontrol
->info
;
288 kctl
->get
= ncontrol
->get
;
289 kctl
->put
= ncontrol
->put
;
290 kctl
->tlv
.p
= ncontrol
->tlv
.p
;
292 kctl
->private_value
= ncontrol
->private_value
;
293 kctl
->private_data
= private_data
;
297 EXPORT_SYMBOL(snd_ctl_new1
);
300 * snd_ctl_free_one - release the control instance
301 * @kcontrol: the control instance
303 * Releases the control instance created via snd_ctl_new()
305 * Don't call this after the control was added to the card.
307 void snd_ctl_free_one(struct snd_kcontrol
*kcontrol
)
310 if (kcontrol
->private_free
)
311 kcontrol
->private_free(kcontrol
);
315 EXPORT_SYMBOL(snd_ctl_free_one
);
317 static bool snd_ctl_remove_numid_conflict(struct snd_card
*card
,
320 struct snd_kcontrol
*kctl
;
322 /* Make sure that the ids assigned to the control do not wrap around */
323 if (card
->last_numid
>= UINT_MAX
- count
)
324 card
->last_numid
= 0;
326 list_for_each_entry(kctl
, &card
->controls
, list
) {
327 if (kctl
->id
.numid
< card
->last_numid
+ 1 + count
&&
328 kctl
->id
.numid
+ kctl
->count
> card
->last_numid
+ 1) {
329 card
->last_numid
= kctl
->id
.numid
+ kctl
->count
- 1;
336 static int snd_ctl_find_hole(struct snd_card
*card
, unsigned int count
)
338 unsigned int iter
= 100000;
340 while (snd_ctl_remove_numid_conflict(card
, count
)) {
342 /* this situation is very unlikely */
343 dev_err(card
->dev
, "unable to allocate new control numid\n");
350 /* add a new kcontrol object; call with card->controls_rwsem locked */
351 static int __snd_ctl_add(struct snd_card
*card
, struct snd_kcontrol
*kcontrol
)
353 struct snd_ctl_elem_id id
;
358 if (id
.index
> UINT_MAX
- kcontrol
->count
)
361 if (snd_ctl_find_id(card
, &id
)) {
363 "control %i:%i:%i:%s:%i is already present\n",
364 id
.iface
, id
.device
, id
.subdevice
, id
.name
, id
.index
);
368 if (snd_ctl_find_hole(card
, kcontrol
->count
) < 0)
371 list_add_tail(&kcontrol
->list
, &card
->controls
);
372 card
->controls_count
+= kcontrol
->count
;
373 kcontrol
->id
.numid
= card
->last_numid
+ 1;
374 card
->last_numid
+= kcontrol
->count
;
377 count
= kcontrol
->count
;
378 for (idx
= 0; idx
< count
; idx
++, id
.index
++, id
.numid
++)
379 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_ADD
, &id
);
385 * snd_ctl_add - add the control instance to the card
386 * @card: the card instance
387 * @kcontrol: the control instance to add
389 * Adds the control instance created via snd_ctl_new() or
390 * snd_ctl_new1() to the given card. Assigns also an unique
391 * numid used for fast search.
393 * It frees automatically the control which cannot be added.
395 * Return: Zero if successful, or a negative error code on failure.
398 int snd_ctl_add(struct snd_card
*card
, struct snd_kcontrol
*kcontrol
)
404 if (snd_BUG_ON(!card
|| !kcontrol
->info
))
407 down_write(&card
->controls_rwsem
);
408 err
= __snd_ctl_add(card
, kcontrol
);
409 up_write(&card
->controls_rwsem
);
415 snd_ctl_free_one(kcontrol
);
418 EXPORT_SYMBOL(snd_ctl_add
);
421 * snd_ctl_replace - replace the control instance of the card
422 * @card: the card instance
423 * @kcontrol: the control instance to replace
424 * @add_on_replace: add the control if not already added
426 * Replaces the given control. If the given control does not exist
427 * and the add_on_replace flag is set, the control is added. If the
428 * control exists, it is destroyed first.
430 * It frees automatically the control which cannot be added or replaced.
432 * Return: Zero if successful, or a negative error code on failure.
434 int snd_ctl_replace(struct snd_card
*card
, struct snd_kcontrol
*kcontrol
,
437 struct snd_ctl_elem_id id
;
440 struct snd_kcontrol
*old
;
445 if (snd_BUG_ON(!card
|| !kcontrol
->info
)) {
450 down_write(&card
->controls_rwsem
);
451 old
= snd_ctl_find_id(card
, &id
);
455 up_write(&card
->controls_rwsem
);
459 ret
= snd_ctl_remove(card
, old
);
461 up_write(&card
->controls_rwsem
);
465 if (snd_ctl_find_hole(card
, kcontrol
->count
) < 0) {
466 up_write(&card
->controls_rwsem
);
470 list_add_tail(&kcontrol
->list
, &card
->controls
);
471 card
->controls_count
+= kcontrol
->count
;
472 kcontrol
->id
.numid
= card
->last_numid
+ 1;
473 card
->last_numid
+= kcontrol
->count
;
475 count
= kcontrol
->count
;
476 up_write(&card
->controls_rwsem
);
477 for (idx
= 0; idx
< count
; idx
++, id
.index
++, id
.numid
++)
478 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_ADD
, &id
);
482 snd_ctl_free_one(kcontrol
);
485 EXPORT_SYMBOL(snd_ctl_replace
);
488 * snd_ctl_remove - remove the control from the card and release it
489 * @card: the card instance
490 * @kcontrol: the control instance to remove
492 * Removes the control from the card and then releases the instance.
493 * You don't need to call snd_ctl_free_one(). You must be in
494 * the write lock - down_write(&card->controls_rwsem).
496 * Return: 0 if successful, or a negative error code on failure.
498 int snd_ctl_remove(struct snd_card
*card
, struct snd_kcontrol
*kcontrol
)
500 struct snd_ctl_elem_id id
;
503 if (snd_BUG_ON(!card
|| !kcontrol
))
505 list_del(&kcontrol
->list
);
506 card
->controls_count
-= kcontrol
->count
;
508 for (idx
= 0; idx
< kcontrol
->count
; idx
++, id
.index
++, id
.numid
++)
509 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_REMOVE
, &id
);
510 snd_ctl_free_one(kcontrol
);
513 EXPORT_SYMBOL(snd_ctl_remove
);
516 * snd_ctl_remove_id - remove the control of the given id and release it
517 * @card: the card instance
518 * @id: the control id to remove
520 * Finds the control instance with the given id, removes it from the
521 * card list and releases it.
523 * Return: 0 if successful, or a negative error code on failure.
525 int snd_ctl_remove_id(struct snd_card
*card
, struct snd_ctl_elem_id
*id
)
527 struct snd_kcontrol
*kctl
;
530 down_write(&card
->controls_rwsem
);
531 kctl
= snd_ctl_find_id(card
, id
);
533 up_write(&card
->controls_rwsem
);
536 ret
= snd_ctl_remove(card
, kctl
);
537 up_write(&card
->controls_rwsem
);
540 EXPORT_SYMBOL(snd_ctl_remove_id
);
543 * snd_ctl_remove_user_ctl - remove and release the unlocked user control
544 * @file: active control handle
545 * @id: the control id to remove
547 * Finds the control instance with the given id, removes it from the
548 * card list and releases it.
550 * Return: 0 if successful, or a negative error code on failure.
552 static int snd_ctl_remove_user_ctl(struct snd_ctl_file
* file
,
553 struct snd_ctl_elem_id
*id
)
555 struct snd_card
*card
= file
->card
;
556 struct snd_kcontrol
*kctl
;
559 down_write(&card
->controls_rwsem
);
560 kctl
= snd_ctl_find_id(card
, id
);
565 if (!(kctl
->vd
[0].access
& SNDRV_CTL_ELEM_ACCESS_USER
)) {
569 for (idx
= 0; idx
< kctl
->count
; idx
++)
570 if (kctl
->vd
[idx
].owner
!= NULL
&& kctl
->vd
[idx
].owner
!= file
) {
574 ret
= snd_ctl_remove(card
, kctl
);
577 card
->user_ctl_count
--;
579 up_write(&card
->controls_rwsem
);
584 * snd_ctl_activate_id - activate/inactivate the control of the given id
585 * @card: the card instance
586 * @id: the control id to activate/inactivate
587 * @active: non-zero to activate
589 * Finds the control instance with the given id, and activate or
590 * inactivate the control together with notification, if changed.
591 * The given ID data is filled with full information.
593 * Return: 0 if unchanged, 1 if changed, or a negative error code on failure.
595 int snd_ctl_activate_id(struct snd_card
*card
, struct snd_ctl_elem_id
*id
,
598 struct snd_kcontrol
*kctl
;
599 struct snd_kcontrol_volatile
*vd
;
600 unsigned int index_offset
;
603 down_write(&card
->controls_rwsem
);
604 kctl
= snd_ctl_find_id(card
, id
);
609 index_offset
= snd_ctl_get_ioff(kctl
, id
);
610 vd
= &kctl
->vd
[index_offset
];
613 if (!(vd
->access
& SNDRV_CTL_ELEM_ACCESS_INACTIVE
))
615 vd
->access
&= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
617 if (vd
->access
& SNDRV_CTL_ELEM_ACCESS_INACTIVE
)
619 vd
->access
|= SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
621 snd_ctl_build_ioff(id
, kctl
, index_offset
);
624 up_write(&card
->controls_rwsem
);
626 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_INFO
, id
);
629 EXPORT_SYMBOL_GPL(snd_ctl_activate_id
);
632 * snd_ctl_rename_id - replace the id of a control on the card
633 * @card: the card instance
634 * @src_id: the old id
635 * @dst_id: the new id
637 * Finds the control with the old id from the card, and replaces the
638 * id with the new one.
640 * Return: Zero if successful, or a negative error code on failure.
642 int snd_ctl_rename_id(struct snd_card
*card
, struct snd_ctl_elem_id
*src_id
,
643 struct snd_ctl_elem_id
*dst_id
)
645 struct snd_kcontrol
*kctl
;
647 down_write(&card
->controls_rwsem
);
648 kctl
= snd_ctl_find_id(card
, src_id
);
650 up_write(&card
->controls_rwsem
);
654 kctl
->id
.numid
= card
->last_numid
+ 1;
655 card
->last_numid
+= kctl
->count
;
656 up_write(&card
->controls_rwsem
);
659 EXPORT_SYMBOL(snd_ctl_rename_id
);
662 * snd_ctl_find_numid - find the control instance with the given number-id
663 * @card: the card instance
664 * @numid: the number-id to search
666 * Finds the control instance with the given number-id from the card.
668 * The caller must down card->controls_rwsem before calling this function
669 * (if the race condition can happen).
671 * Return: The pointer of the instance if found, or %NULL if not.
674 struct snd_kcontrol
*snd_ctl_find_numid(struct snd_card
*card
, unsigned int numid
)
676 struct snd_kcontrol
*kctl
;
678 if (snd_BUG_ON(!card
|| !numid
))
680 list_for_each_entry(kctl
, &card
->controls
, list
) {
681 if (kctl
->id
.numid
<= numid
&& kctl
->id
.numid
+ kctl
->count
> numid
)
686 EXPORT_SYMBOL(snd_ctl_find_numid
);
689 * snd_ctl_find_id - find the control instance with the given id
690 * @card: the card instance
691 * @id: the id to search
693 * Finds the control instance with the given id from the card.
695 * The caller must down card->controls_rwsem before calling this function
696 * (if the race condition can happen).
698 * Return: The pointer of the instance if found, or %NULL if not.
701 struct snd_kcontrol
*snd_ctl_find_id(struct snd_card
*card
,
702 struct snd_ctl_elem_id
*id
)
704 struct snd_kcontrol
*kctl
;
706 if (snd_BUG_ON(!card
|| !id
))
709 return snd_ctl_find_numid(card
, id
->numid
);
710 list_for_each_entry(kctl
, &card
->controls
, list
) {
711 if (kctl
->id
.iface
!= id
->iface
)
713 if (kctl
->id
.device
!= id
->device
)
715 if (kctl
->id
.subdevice
!= id
->subdevice
)
717 if (strncmp(kctl
->id
.name
, id
->name
, sizeof(kctl
->id
.name
)))
719 if (kctl
->id
.index
> id
->index
)
721 if (kctl
->id
.index
+ kctl
->count
<= id
->index
)
727 EXPORT_SYMBOL(snd_ctl_find_id
);
729 static int snd_ctl_card_info(struct snd_card
*card
, struct snd_ctl_file
* ctl
,
730 unsigned int cmd
, void __user
*arg
)
732 struct snd_ctl_card_info
*info
;
734 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
737 down_read(&snd_ioctl_rwsem
);
738 info
->card
= card
->number
;
739 strlcpy(info
->id
, card
->id
, sizeof(info
->id
));
740 strlcpy(info
->driver
, card
->driver
, sizeof(info
->driver
));
741 strlcpy(info
->name
, card
->shortname
, sizeof(info
->name
));
742 strlcpy(info
->longname
, card
->longname
, sizeof(info
->longname
));
743 strlcpy(info
->mixername
, card
->mixername
, sizeof(info
->mixername
));
744 strlcpy(info
->components
, card
->components
, sizeof(info
->components
));
745 up_read(&snd_ioctl_rwsem
);
746 if (copy_to_user(arg
, info
, sizeof(struct snd_ctl_card_info
))) {
754 static int snd_ctl_elem_list(struct snd_card
*card
,
755 struct snd_ctl_elem_list __user
*_list
)
757 struct snd_ctl_elem_list list
;
758 struct snd_kcontrol
*kctl
;
759 struct snd_ctl_elem_id id
;
760 unsigned int offset
, space
, jidx
;
763 if (copy_from_user(&list
, _list
, sizeof(list
)))
765 offset
= list
.offset
;
768 down_read(&card
->controls_rwsem
);
769 list
.count
= card
->controls_count
;
772 list_for_each_entry(kctl
, &card
->controls
, list
) {
773 if (offset
>= kctl
->count
) {
774 offset
-= kctl
->count
;
777 for (jidx
= offset
; jidx
< kctl
->count
; jidx
++) {
778 snd_ctl_build_ioff(&id
, kctl
, jidx
);
779 if (copy_to_user(list
.pids
+ list
.used
, &id
,
792 up_read(&card
->controls_rwsem
);
793 if (!err
&& copy_to_user(_list
, &list
, sizeof(list
)))
798 static bool validate_element_member_dimension(struct snd_ctl_elem_info
*info
)
800 unsigned int members
;
803 if (info
->dimen
.d
[0] == 0)
807 for (i
= 0; i
< ARRAY_SIZE(info
->dimen
.d
); ++i
) {
808 if (info
->dimen
.d
[i
] == 0)
810 members
*= info
->dimen
.d
[i
];
813 * info->count should be validated in advance, to guarantee
814 * calculation soundness.
816 if (members
> info
->count
)
820 for (++i
; i
< ARRAY_SIZE(info
->dimen
.d
); ++i
) {
821 if (info
->dimen
.d
[i
] > 0)
825 return members
== info
->count
;
828 static int snd_ctl_elem_info(struct snd_ctl_file
*ctl
,
829 struct snd_ctl_elem_info
*info
)
831 struct snd_card
*card
= ctl
->card
;
832 struct snd_kcontrol
*kctl
;
833 struct snd_kcontrol_volatile
*vd
;
834 unsigned int index_offset
;
837 down_read(&card
->controls_rwsem
);
838 kctl
= snd_ctl_find_id(card
, &info
->id
);
840 up_read(&card
->controls_rwsem
);
843 #ifdef CONFIG_SND_DEBUG
846 result
= kctl
->info(kctl
, info
);
848 snd_BUG_ON(info
->access
);
849 index_offset
= snd_ctl_get_ioff(kctl
, &info
->id
);
850 vd
= &kctl
->vd
[index_offset
];
851 snd_ctl_build_ioff(&info
->id
, kctl
, index_offset
);
852 info
->access
= vd
->access
;
854 info
->access
|= SNDRV_CTL_ELEM_ACCESS_LOCK
;
855 if (vd
->owner
== ctl
)
856 info
->access
|= SNDRV_CTL_ELEM_ACCESS_OWNER
;
857 info
->owner
= pid_vnr(vd
->owner
->pid
);
862 up_read(&card
->controls_rwsem
);
866 static int snd_ctl_elem_info_user(struct snd_ctl_file
*ctl
,
867 struct snd_ctl_elem_info __user
*_info
)
869 struct snd_ctl_elem_info info
;
872 if (copy_from_user(&info
, _info
, sizeof(info
)))
874 result
= snd_power_wait(ctl
->card
, SNDRV_CTL_POWER_D0
);
877 result
= snd_ctl_elem_info(ctl
, &info
);
880 if (copy_to_user(_info
, &info
, sizeof(info
)))
885 static int snd_ctl_elem_read(struct snd_card
*card
,
886 struct snd_ctl_elem_value
*control
)
888 struct snd_kcontrol
*kctl
;
889 struct snd_kcontrol_volatile
*vd
;
890 unsigned int index_offset
;
892 kctl
= snd_ctl_find_id(card
, &control
->id
);
896 index_offset
= snd_ctl_get_ioff(kctl
, &control
->id
);
897 vd
= &kctl
->vd
[index_offset
];
898 if (!(vd
->access
& SNDRV_CTL_ELEM_ACCESS_READ
) || kctl
->get
== NULL
)
901 snd_ctl_build_ioff(&control
->id
, kctl
, index_offset
);
902 return kctl
->get(kctl
, control
);
905 static int snd_ctl_elem_read_user(struct snd_card
*card
,
906 struct snd_ctl_elem_value __user
*_control
)
908 struct snd_ctl_elem_value
*control
;
911 control
= memdup_user(_control
, sizeof(*control
));
913 return PTR_ERR(control
);
915 result
= snd_power_wait(card
, SNDRV_CTL_POWER_D0
);
919 down_read(&card
->controls_rwsem
);
920 result
= snd_ctl_elem_read(card
, control
);
921 up_read(&card
->controls_rwsem
);
925 if (copy_to_user(_control
, control
, sizeof(*control
)))
932 static int snd_ctl_elem_write(struct snd_card
*card
, struct snd_ctl_file
*file
,
933 struct snd_ctl_elem_value
*control
)
935 struct snd_kcontrol
*kctl
;
936 struct snd_kcontrol_volatile
*vd
;
937 unsigned int index_offset
;
940 kctl
= snd_ctl_find_id(card
, &control
->id
);
944 index_offset
= snd_ctl_get_ioff(kctl
, &control
->id
);
945 vd
= &kctl
->vd
[index_offset
];
946 if (!(vd
->access
& SNDRV_CTL_ELEM_ACCESS_WRITE
) || kctl
->put
== NULL
||
947 (file
&& vd
->owner
&& vd
->owner
!= file
)) {
951 snd_ctl_build_ioff(&control
->id
, kctl
, index_offset
);
952 result
= kctl
->put(kctl
, control
);
957 struct snd_ctl_elem_id id
= control
->id
;
958 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
, &id
);
964 static int snd_ctl_elem_write_user(struct snd_ctl_file
*file
,
965 struct snd_ctl_elem_value __user
*_control
)
967 struct snd_ctl_elem_value
*control
;
968 struct snd_card
*card
;
971 control
= memdup_user(_control
, sizeof(*control
));
973 return PTR_ERR(control
);
976 result
= snd_power_wait(card
, SNDRV_CTL_POWER_D0
);
980 down_write(&card
->controls_rwsem
);
981 result
= snd_ctl_elem_write(card
, file
, control
);
982 up_write(&card
->controls_rwsem
);
986 if (copy_to_user(_control
, control
, sizeof(*control
)))
993 static int snd_ctl_elem_lock(struct snd_ctl_file
*file
,
994 struct snd_ctl_elem_id __user
*_id
)
996 struct snd_card
*card
= file
->card
;
997 struct snd_ctl_elem_id id
;
998 struct snd_kcontrol
*kctl
;
999 struct snd_kcontrol_volatile
*vd
;
1002 if (copy_from_user(&id
, _id
, sizeof(id
)))
1004 down_write(&card
->controls_rwsem
);
1005 kctl
= snd_ctl_find_id(card
, &id
);
1009 vd
= &kctl
->vd
[snd_ctl_get_ioff(kctl
, &id
)];
1010 if (vd
->owner
!= NULL
)
1017 up_write(&card
->controls_rwsem
);
1021 static int snd_ctl_elem_unlock(struct snd_ctl_file
*file
,
1022 struct snd_ctl_elem_id __user
*_id
)
1024 struct snd_card
*card
= file
->card
;
1025 struct snd_ctl_elem_id id
;
1026 struct snd_kcontrol
*kctl
;
1027 struct snd_kcontrol_volatile
*vd
;
1030 if (copy_from_user(&id
, _id
, sizeof(id
)))
1032 down_write(&card
->controls_rwsem
);
1033 kctl
= snd_ctl_find_id(card
, &id
);
1037 vd
= &kctl
->vd
[snd_ctl_get_ioff(kctl
, &id
)];
1038 if (vd
->owner
== NULL
)
1040 else if (vd
->owner
!= file
)
1047 up_write(&card
->controls_rwsem
);
1051 struct user_element
{
1052 struct snd_ctl_elem_info info
;
1053 struct snd_card
*card
;
1054 char *elem_data
; /* element data */
1055 unsigned long elem_data_size
; /* size of element data in bytes */
1056 void *tlv_data
; /* TLV data */
1057 unsigned long tlv_data_size
; /* TLV data size */
1058 void *priv_data
; /* private data (like strings for enumerated type) */
1061 static int snd_ctl_elem_user_info(struct snd_kcontrol
*kcontrol
,
1062 struct snd_ctl_elem_info
*uinfo
)
1064 struct user_element
*ue
= kcontrol
->private_data
;
1065 unsigned int offset
;
1067 offset
= snd_ctl_get_ioff(kcontrol
, &uinfo
->id
);
1069 snd_ctl_build_ioff(&uinfo
->id
, kcontrol
, offset
);
1074 static int snd_ctl_elem_user_enum_info(struct snd_kcontrol
*kcontrol
,
1075 struct snd_ctl_elem_info
*uinfo
)
1077 struct user_element
*ue
= kcontrol
->private_data
;
1080 unsigned int offset
;
1082 item
= uinfo
->value
.enumerated
.item
;
1084 offset
= snd_ctl_get_ioff(kcontrol
, &uinfo
->id
);
1086 snd_ctl_build_ioff(&uinfo
->id
, kcontrol
, offset
);
1088 item
= min(item
, uinfo
->value
.enumerated
.items
- 1);
1089 uinfo
->value
.enumerated
.item
= item
;
1091 names
= ue
->priv_data
;
1092 for (; item
> 0; --item
)
1093 names
+= strlen(names
) + 1;
1094 strcpy(uinfo
->value
.enumerated
.name
, names
);
1099 static int snd_ctl_elem_user_get(struct snd_kcontrol
*kcontrol
,
1100 struct snd_ctl_elem_value
*ucontrol
)
1102 struct user_element
*ue
= kcontrol
->private_data
;
1103 unsigned int size
= ue
->elem_data_size
;
1104 char *src
= ue
->elem_data
+
1105 snd_ctl_get_ioff(kcontrol
, &ucontrol
->id
) * size
;
1107 memcpy(&ucontrol
->value
, src
, size
);
1111 static int snd_ctl_elem_user_put(struct snd_kcontrol
*kcontrol
,
1112 struct snd_ctl_elem_value
*ucontrol
)
1115 struct user_element
*ue
= kcontrol
->private_data
;
1116 unsigned int size
= ue
->elem_data_size
;
1117 char *dst
= ue
->elem_data
+
1118 snd_ctl_get_ioff(kcontrol
, &ucontrol
->id
) * size
;
1120 change
= memcmp(&ucontrol
->value
, dst
, size
) != 0;
1122 memcpy(dst
, &ucontrol
->value
, size
);
1126 static int replace_user_tlv(struct snd_kcontrol
*kctl
, unsigned int __user
*buf
,
1129 struct user_element
*ue
= kctl
->private_data
;
1130 unsigned int *container
;
1131 struct snd_ctl_elem_id id
;
1132 unsigned int mask
= 0;
1136 if (size
> 1024 * 128) /* sane value */
1139 container
= memdup_user(buf
, size
);
1140 if (IS_ERR(container
))
1141 return PTR_ERR(container
);
1143 change
= ue
->tlv_data_size
!= size
;
1145 change
= memcmp(ue
->tlv_data
, container
, size
) != 0;
1151 if (ue
->tlv_data
== NULL
) {
1152 /* Now TLV data is available. */
1153 for (i
= 0; i
< kctl
->count
; ++i
)
1154 kctl
->vd
[i
].access
|= SNDRV_CTL_ELEM_ACCESS_TLV_READ
;
1155 mask
= SNDRV_CTL_EVENT_MASK_INFO
;
1158 kfree(ue
->tlv_data
);
1159 ue
->tlv_data
= container
;
1160 ue
->tlv_data_size
= size
;
1162 mask
|= SNDRV_CTL_EVENT_MASK_TLV
;
1163 for (i
= 0; i
< kctl
->count
; ++i
) {
1164 snd_ctl_build_ioff(&id
, kctl
, i
);
1165 snd_ctl_notify(ue
->card
, mask
, &id
);
1171 static int read_user_tlv(struct snd_kcontrol
*kctl
, unsigned int __user
*buf
,
1174 struct user_element
*ue
= kctl
->private_data
;
1176 if (ue
->tlv_data_size
== 0 || ue
->tlv_data
== NULL
)
1179 if (size
< ue
->tlv_data_size
)
1182 if (copy_to_user(buf
, ue
->tlv_data
, ue
->tlv_data_size
))
1188 static int snd_ctl_elem_user_tlv(struct snd_kcontrol
*kctl
, int op_flag
,
1189 unsigned int size
, unsigned int __user
*buf
)
1191 if (op_flag
== SNDRV_CTL_TLV_OP_WRITE
)
1192 return replace_user_tlv(kctl
, buf
, size
);
1194 return read_user_tlv(kctl
, buf
, size
);
1197 static int snd_ctl_elem_init_enum_names(struct user_element
*ue
)
1200 size_t buf_len
, name_len
;
1202 const uintptr_t user_ptrval
= ue
->info
.value
.enumerated
.names_ptr
;
1204 if (ue
->info
.value
.enumerated
.names_length
> 64 * 1024)
1207 names
= memdup_user((const void __user
*)user_ptrval
,
1208 ue
->info
.value
.enumerated
.names_length
);
1210 return PTR_ERR(names
);
1212 /* check that there are enough valid names */
1213 buf_len
= ue
->info
.value
.enumerated
.names_length
;
1215 for (i
= 0; i
< ue
->info
.value
.enumerated
.items
; ++i
) {
1216 name_len
= strnlen(p
, buf_len
);
1217 if (name_len
== 0 || name_len
>= 64 || name_len
== buf_len
) {
1222 buf_len
-= name_len
+ 1;
1225 ue
->priv_data
= names
;
1226 ue
->info
.value
.enumerated
.names_ptr
= 0;
1231 static void snd_ctl_elem_user_free(struct snd_kcontrol
*kcontrol
)
1233 struct user_element
*ue
= kcontrol
->private_data
;
1235 kfree(ue
->tlv_data
);
1236 kfree(ue
->priv_data
);
1240 static int snd_ctl_elem_add(struct snd_ctl_file
*file
,
1241 struct snd_ctl_elem_info
*info
, int replace
)
1243 /* The capacity of struct snd_ctl_elem_value.value.*/
1244 static const unsigned int value_sizes
[] = {
1245 [SNDRV_CTL_ELEM_TYPE_BOOLEAN
] = sizeof(long),
1246 [SNDRV_CTL_ELEM_TYPE_INTEGER
] = sizeof(long),
1247 [SNDRV_CTL_ELEM_TYPE_ENUMERATED
] = sizeof(unsigned int),
1248 [SNDRV_CTL_ELEM_TYPE_BYTES
] = sizeof(unsigned char),
1249 [SNDRV_CTL_ELEM_TYPE_IEC958
] = sizeof(struct snd_aes_iec958
),
1250 [SNDRV_CTL_ELEM_TYPE_INTEGER64
] = sizeof(long long),
1252 static const unsigned int max_value_counts
[] = {
1253 [SNDRV_CTL_ELEM_TYPE_BOOLEAN
] = 128,
1254 [SNDRV_CTL_ELEM_TYPE_INTEGER
] = 128,
1255 [SNDRV_CTL_ELEM_TYPE_ENUMERATED
] = 128,
1256 [SNDRV_CTL_ELEM_TYPE_BYTES
] = 512,
1257 [SNDRV_CTL_ELEM_TYPE_IEC958
] = 1,
1258 [SNDRV_CTL_ELEM_TYPE_INTEGER64
] = 64,
1260 struct snd_card
*card
= file
->card
;
1261 struct snd_kcontrol
*kctl
;
1263 unsigned int access
;
1265 struct user_element
*ue
;
1266 unsigned int offset
;
1269 if (!*info
->id
.name
)
1271 if (strnlen(info
->id
.name
, sizeof(info
->id
.name
)) >= sizeof(info
->id
.name
))
1274 /* Delete a control to replace them if needed. */
1277 err
= snd_ctl_remove_user_ctl(file
, &info
->id
);
1283 * The number of userspace controls are counted control by control,
1284 * not element by element.
1286 if (card
->user_ctl_count
+ 1 > MAX_USER_CONTROLS
)
1289 /* Check the number of elements for this userspace control. */
1290 count
= info
->owner
;
1294 /* Arrange access permissions if needed. */
1295 access
= info
->access
;
1297 access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
;
1298 access
&= (SNDRV_CTL_ELEM_ACCESS_READWRITE
|
1299 SNDRV_CTL_ELEM_ACCESS_INACTIVE
|
1300 SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
);
1302 /* In initial state, nothing is available as TLV container. */
1303 if (access
& SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
)
1304 access
|= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
;
1305 access
|= SNDRV_CTL_ELEM_ACCESS_USER
;
1308 * Check information and calculate the size of data specific to
1309 * this userspace control.
1311 if (info
->type
< SNDRV_CTL_ELEM_TYPE_BOOLEAN
||
1312 info
->type
> SNDRV_CTL_ELEM_TYPE_INTEGER64
)
1314 if (info
->type
== SNDRV_CTL_ELEM_TYPE_ENUMERATED
&&
1315 info
->value
.enumerated
.items
== 0)
1317 if (info
->count
< 1 ||
1318 info
->count
> max_value_counts
[info
->type
])
1320 if (!validate_element_member_dimension(info
))
1322 private_size
= value_sizes
[info
->type
] * info
->count
;
1325 * Keep memory object for this userspace control. After passing this
1326 * code block, the instance should be freed by snd_ctl_free_one().
1328 * Note that these elements in this control are locked.
1330 err
= snd_ctl_new(&kctl
, count
, access
, file
);
1333 memcpy(&kctl
->id
, &info
->id
, sizeof(kctl
->id
));
1334 kctl
->private_data
= kzalloc(sizeof(struct user_element
) + private_size
* count
,
1336 if (kctl
->private_data
== NULL
) {
1340 kctl
->private_free
= snd_ctl_elem_user_free
;
1342 /* Set private data for this userspace control. */
1343 ue
= (struct user_element
*)kctl
->private_data
;
1346 ue
->info
.access
= 0;
1347 ue
->elem_data
= (char *)ue
+ sizeof(*ue
);
1348 ue
->elem_data_size
= private_size
;
1349 if (ue
->info
.type
== SNDRV_CTL_ELEM_TYPE_ENUMERATED
) {
1350 err
= snd_ctl_elem_init_enum_names(ue
);
1352 snd_ctl_free_one(kctl
);
1357 /* Set callback functions. */
1358 if (info
->type
== SNDRV_CTL_ELEM_TYPE_ENUMERATED
)
1359 kctl
->info
= snd_ctl_elem_user_enum_info
;
1361 kctl
->info
= snd_ctl_elem_user_info
;
1362 if (access
& SNDRV_CTL_ELEM_ACCESS_READ
)
1363 kctl
->get
= snd_ctl_elem_user_get
;
1364 if (access
& SNDRV_CTL_ELEM_ACCESS_WRITE
)
1365 kctl
->put
= snd_ctl_elem_user_put
;
1366 if (access
& SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
)
1367 kctl
->tlv
.c
= snd_ctl_elem_user_tlv
;
1369 /* This function manage to free the instance on failure. */
1370 down_write(&card
->controls_rwsem
);
1371 err
= __snd_ctl_add(card
, kctl
);
1373 snd_ctl_free_one(kctl
);
1376 offset
= snd_ctl_get_ioff(kctl
, &info
->id
);
1377 snd_ctl_build_ioff(&info
->id
, kctl
, offset
);
1379 * Here we cannot fill any field for the number of elements added by
1380 * this operation because there're no specific fields. The usage of
1381 * 'owner' field for this purpose may cause any bugs to userspace
1382 * applications because the field originally means PID of a process
1383 * which locks the element.
1386 card
->user_ctl_count
++;
1389 up_write(&card
->controls_rwsem
);
1393 static int snd_ctl_elem_add_user(struct snd_ctl_file
*file
,
1394 struct snd_ctl_elem_info __user
*_info
, int replace
)
1396 struct snd_ctl_elem_info info
;
1399 if (copy_from_user(&info
, _info
, sizeof(info
)))
1401 err
= snd_ctl_elem_add(file
, &info
, replace
);
1404 if (copy_to_user(_info
, &info
, sizeof(info
))) {
1405 snd_ctl_remove_user_ctl(file
, &info
.id
);
1412 static int snd_ctl_elem_remove(struct snd_ctl_file
*file
,
1413 struct snd_ctl_elem_id __user
*_id
)
1415 struct snd_ctl_elem_id id
;
1417 if (copy_from_user(&id
, _id
, sizeof(id
)))
1419 return snd_ctl_remove_user_ctl(file
, &id
);
1422 static int snd_ctl_subscribe_events(struct snd_ctl_file
*file
, int __user
*ptr
)
1425 if (get_user(subscribe
, ptr
))
1427 if (subscribe
< 0) {
1428 subscribe
= file
->subscribed
;
1429 if (put_user(subscribe
, ptr
))
1434 file
->subscribed
= 1;
1436 } else if (file
->subscribed
) {
1437 snd_ctl_empty_read_queue(file
);
1438 file
->subscribed
= 0;
1443 static int call_tlv_handler(struct snd_ctl_file
*file
, int op_flag
,
1444 struct snd_kcontrol
*kctl
,
1445 struct snd_ctl_elem_id
*id
,
1446 unsigned int __user
*buf
, unsigned int size
)
1448 static const struct {
1452 {SNDRV_CTL_TLV_OP_READ
, SNDRV_CTL_ELEM_ACCESS_TLV_READ
},
1453 {SNDRV_CTL_TLV_OP_WRITE
, SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
},
1454 {SNDRV_CTL_TLV_OP_CMD
, SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND
},
1456 struct snd_kcontrol_volatile
*vd
= &kctl
->vd
[snd_ctl_get_ioff(kctl
, id
)];
1459 /* Check support of the request for this element. */
1460 for (i
= 0; i
< ARRAY_SIZE(pairs
); ++i
) {
1461 if (op_flag
== pairs
[i
].op
&& (vd
->access
& pairs
[i
].perm
))
1464 if (i
== ARRAY_SIZE(pairs
))
1467 if (kctl
->tlv
.c
== NULL
)
1470 /* When locked, this is unavailable. */
1471 if (vd
->owner
!= NULL
&& vd
->owner
!= file
)
1474 return kctl
->tlv
.c(kctl
, op_flag
, size
, buf
);
1477 static int read_tlv_buf(struct snd_kcontrol
*kctl
, struct snd_ctl_elem_id
*id
,
1478 unsigned int __user
*buf
, unsigned int size
)
1480 struct snd_kcontrol_volatile
*vd
= &kctl
->vd
[snd_ctl_get_ioff(kctl
, id
)];
1483 if (!(vd
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_READ
))
1486 if (kctl
->tlv
.p
== NULL
)
1489 len
= sizeof(unsigned int) * 2 + kctl
->tlv
.p
[1];
1493 if (copy_to_user(buf
, kctl
->tlv
.p
, len
))
1499 static int snd_ctl_tlv_ioctl(struct snd_ctl_file
*file
,
1500 struct snd_ctl_tlv __user
*buf
,
1503 struct snd_ctl_tlv header
;
1504 unsigned int *container
;
1505 unsigned int container_size
;
1506 struct snd_kcontrol
*kctl
;
1507 struct snd_ctl_elem_id id
;
1508 struct snd_kcontrol_volatile
*vd
;
1510 if (copy_from_user(&header
, buf
, sizeof(header
)))
1513 /* In design of control core, numerical ID starts at 1. */
1514 if (header
.numid
== 0)
1517 /* At least, container should include type and length fields. */
1518 if (header
.length
< sizeof(unsigned int) * 2)
1520 container_size
= header
.length
;
1521 container
= buf
->tlv
;
1523 kctl
= snd_ctl_find_numid(file
->card
, header
.numid
);
1527 /* Calculate index of the element in this set. */
1529 snd_ctl_build_ioff(&id
, kctl
, header
.numid
- id
.numid
);
1530 vd
= &kctl
->vd
[snd_ctl_get_ioff(kctl
, &id
)];
1532 if (vd
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
) {
1533 return call_tlv_handler(file
, op_flag
, kctl
, &id
, container
,
1536 if (op_flag
== SNDRV_CTL_TLV_OP_READ
) {
1537 return read_tlv_buf(kctl
, &id
, container
,
1542 /* Not supported. */
1546 static long snd_ctl_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1548 struct snd_ctl_file
*ctl
;
1549 struct snd_card
*card
;
1550 struct snd_kctl_ioctl
*p
;
1551 void __user
*argp
= (void __user
*)arg
;
1552 int __user
*ip
= argp
;
1555 ctl
= file
->private_data
;
1557 if (snd_BUG_ON(!card
))
1560 case SNDRV_CTL_IOCTL_PVERSION
:
1561 return put_user(SNDRV_CTL_VERSION
, ip
) ? -EFAULT
: 0;
1562 case SNDRV_CTL_IOCTL_CARD_INFO
:
1563 return snd_ctl_card_info(card
, ctl
, cmd
, argp
);
1564 case SNDRV_CTL_IOCTL_ELEM_LIST
:
1565 return snd_ctl_elem_list(card
, argp
);
1566 case SNDRV_CTL_IOCTL_ELEM_INFO
:
1567 return snd_ctl_elem_info_user(ctl
, argp
);
1568 case SNDRV_CTL_IOCTL_ELEM_READ
:
1569 return snd_ctl_elem_read_user(card
, argp
);
1570 case SNDRV_CTL_IOCTL_ELEM_WRITE
:
1571 return snd_ctl_elem_write_user(ctl
, argp
);
1572 case SNDRV_CTL_IOCTL_ELEM_LOCK
:
1573 return snd_ctl_elem_lock(ctl
, argp
);
1574 case SNDRV_CTL_IOCTL_ELEM_UNLOCK
:
1575 return snd_ctl_elem_unlock(ctl
, argp
);
1576 case SNDRV_CTL_IOCTL_ELEM_ADD
:
1577 return snd_ctl_elem_add_user(ctl
, argp
, 0);
1578 case SNDRV_CTL_IOCTL_ELEM_REPLACE
:
1579 return snd_ctl_elem_add_user(ctl
, argp
, 1);
1580 case SNDRV_CTL_IOCTL_ELEM_REMOVE
:
1581 return snd_ctl_elem_remove(ctl
, argp
);
1582 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS
:
1583 return snd_ctl_subscribe_events(ctl
, ip
);
1584 case SNDRV_CTL_IOCTL_TLV_READ
:
1585 down_read(&ctl
->card
->controls_rwsem
);
1586 err
= snd_ctl_tlv_ioctl(ctl
, argp
, SNDRV_CTL_TLV_OP_READ
);
1587 up_read(&ctl
->card
->controls_rwsem
);
1589 case SNDRV_CTL_IOCTL_TLV_WRITE
:
1590 down_write(&ctl
->card
->controls_rwsem
);
1591 err
= snd_ctl_tlv_ioctl(ctl
, argp
, SNDRV_CTL_TLV_OP_WRITE
);
1592 up_write(&ctl
->card
->controls_rwsem
);
1594 case SNDRV_CTL_IOCTL_TLV_COMMAND
:
1595 down_write(&ctl
->card
->controls_rwsem
);
1596 err
= snd_ctl_tlv_ioctl(ctl
, argp
, SNDRV_CTL_TLV_OP_CMD
);
1597 up_write(&ctl
->card
->controls_rwsem
);
1599 case SNDRV_CTL_IOCTL_POWER
:
1600 return -ENOPROTOOPT
;
1601 case SNDRV_CTL_IOCTL_POWER_STATE
:
1603 return put_user(card
->power_state
, ip
) ? -EFAULT
: 0;
1605 return put_user(SNDRV_CTL_POWER_D0
, ip
) ? -EFAULT
: 0;
1608 down_read(&snd_ioctl_rwsem
);
1609 list_for_each_entry(p
, &snd_control_ioctls
, list
) {
1610 err
= p
->fioctl(card
, ctl
, cmd
, arg
);
1611 if (err
!= -ENOIOCTLCMD
) {
1612 up_read(&snd_ioctl_rwsem
);
1616 up_read(&snd_ioctl_rwsem
);
1617 dev_dbg(card
->dev
, "unknown ioctl = 0x%x\n", cmd
);
1621 static ssize_t
snd_ctl_read(struct file
*file
, char __user
*buffer
,
1622 size_t count
, loff_t
* offset
)
1624 struct snd_ctl_file
*ctl
;
1628 ctl
= file
->private_data
;
1629 if (snd_BUG_ON(!ctl
|| !ctl
->card
))
1631 if (!ctl
->subscribed
)
1633 if (count
< sizeof(struct snd_ctl_event
))
1635 spin_lock_irq(&ctl
->read_lock
);
1636 while (count
>= sizeof(struct snd_ctl_event
)) {
1637 struct snd_ctl_event ev
;
1638 struct snd_kctl_event
*kev
;
1639 while (list_empty(&ctl
->events
)) {
1640 wait_queue_entry_t wait
;
1641 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
1645 init_waitqueue_entry(&wait
, current
);
1646 add_wait_queue(&ctl
->change_sleep
, &wait
);
1647 set_current_state(TASK_INTERRUPTIBLE
);
1648 spin_unlock_irq(&ctl
->read_lock
);
1650 remove_wait_queue(&ctl
->change_sleep
, &wait
);
1651 if (ctl
->card
->shutdown
)
1653 if (signal_pending(current
))
1654 return -ERESTARTSYS
;
1655 spin_lock_irq(&ctl
->read_lock
);
1657 kev
= snd_kctl_event(ctl
->events
.next
);
1658 ev
.type
= SNDRV_CTL_EVENT_ELEM
;
1659 ev
.data
.elem
.mask
= kev
->mask
;
1660 ev
.data
.elem
.id
= kev
->id
;
1661 list_del(&kev
->list
);
1662 spin_unlock_irq(&ctl
->read_lock
);
1664 if (copy_to_user(buffer
, &ev
, sizeof(struct snd_ctl_event
))) {
1668 spin_lock_irq(&ctl
->read_lock
);
1669 buffer
+= sizeof(struct snd_ctl_event
);
1670 count
-= sizeof(struct snd_ctl_event
);
1671 result
+= sizeof(struct snd_ctl_event
);
1674 spin_unlock_irq(&ctl
->read_lock
);
1676 return result
> 0 ? result
: err
;
1679 static unsigned int snd_ctl_poll(struct file
*file
, poll_table
* wait
)
1682 struct snd_ctl_file
*ctl
;
1684 ctl
= file
->private_data
;
1685 if (!ctl
->subscribed
)
1687 poll_wait(file
, &ctl
->change_sleep
, wait
);
1690 if (!list_empty(&ctl
->events
))
1691 mask
|= POLLIN
| POLLRDNORM
;
1697 * register the device-specific control-ioctls.
1698 * called from each device manager like pcm.c, hwdep.c, etc.
1700 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn
, struct list_head
*lists
)
1702 struct snd_kctl_ioctl
*pn
;
1704 pn
= kzalloc(sizeof(struct snd_kctl_ioctl
), GFP_KERNEL
);
1708 down_write(&snd_ioctl_rwsem
);
1709 list_add_tail(&pn
->list
, lists
);
1710 up_write(&snd_ioctl_rwsem
);
1715 * snd_ctl_register_ioctl - register the device-specific control-ioctls
1716 * @fcn: ioctl callback function
1718 * called from each device manager like pcm.c, hwdep.c, etc.
1720 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn
)
1722 return _snd_ctl_register_ioctl(fcn
, &snd_control_ioctls
);
1724 EXPORT_SYMBOL(snd_ctl_register_ioctl
);
1726 #ifdef CONFIG_COMPAT
1728 * snd_ctl_register_ioctl_compat - register the device-specific 32bit compat
1730 * @fcn: ioctl callback function
1732 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn
)
1734 return _snd_ctl_register_ioctl(fcn
, &snd_control_compat_ioctls
);
1736 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat
);
1740 * de-register the device-specific control-ioctls.
1742 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn
,
1743 struct list_head
*lists
)
1745 struct snd_kctl_ioctl
*p
;
1747 if (snd_BUG_ON(!fcn
))
1749 down_write(&snd_ioctl_rwsem
);
1750 list_for_each_entry(p
, lists
, list
) {
1751 if (p
->fioctl
== fcn
) {
1753 up_write(&snd_ioctl_rwsem
);
1758 up_write(&snd_ioctl_rwsem
);
1764 * snd_ctl_unregister_ioctl - de-register the device-specific control-ioctls
1765 * @fcn: ioctl callback function to unregister
1767 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn
)
1769 return _snd_ctl_unregister_ioctl(fcn
, &snd_control_ioctls
);
1771 EXPORT_SYMBOL(snd_ctl_unregister_ioctl
);
1773 #ifdef CONFIG_COMPAT
1775 * snd_ctl_unregister_ioctl - de-register the device-specific compat 32bit
1777 * @fcn: ioctl callback function to unregister
1779 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn
)
1781 return _snd_ctl_unregister_ioctl(fcn
, &snd_control_compat_ioctls
);
1783 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat
);
1786 static int snd_ctl_fasync(int fd
, struct file
* file
, int on
)
1788 struct snd_ctl_file
*ctl
;
1790 ctl
= file
->private_data
;
1791 return fasync_helper(fd
, file
, on
, &ctl
->fasync
);
1794 /* return the preferred subdevice number if already assigned;
1795 * otherwise return -1
1797 int snd_ctl_get_preferred_subdevice(struct snd_card
*card
, int type
)
1799 struct snd_ctl_file
*kctl
;
1802 read_lock(&card
->ctl_files_rwlock
);
1803 list_for_each_entry(kctl
, &card
->ctl_files
, list
) {
1804 if (kctl
->pid
== task_pid(current
)) {
1805 subdevice
= kctl
->preferred_subdevice
[type
];
1806 if (subdevice
!= -1)
1810 read_unlock(&card
->ctl_files_rwlock
);
1813 EXPORT_SYMBOL_GPL(snd_ctl_get_preferred_subdevice
);
1818 #ifdef CONFIG_COMPAT
1819 #include "control_compat.c"
1821 #define snd_ctl_ioctl_compat NULL
1828 static const struct file_operations snd_ctl_f_ops
=
1830 .owner
= THIS_MODULE
,
1831 .read
= snd_ctl_read
,
1832 .open
= snd_ctl_open
,
1833 .release
= snd_ctl_release
,
1834 .llseek
= no_llseek
,
1835 .poll
= snd_ctl_poll
,
1836 .unlocked_ioctl
= snd_ctl_ioctl
,
1837 .compat_ioctl
= snd_ctl_ioctl_compat
,
1838 .fasync
= snd_ctl_fasync
,
1842 * registration of the control device
1844 static int snd_ctl_dev_register(struct snd_device
*device
)
1846 struct snd_card
*card
= device
->device_data
;
1848 return snd_register_device(SNDRV_DEVICE_TYPE_CONTROL
, card
, -1,
1849 &snd_ctl_f_ops
, card
, &card
->ctl_dev
);
1853 * disconnection of the control device
1855 static int snd_ctl_dev_disconnect(struct snd_device
*device
)
1857 struct snd_card
*card
= device
->device_data
;
1858 struct snd_ctl_file
*ctl
;
1860 read_lock(&card
->ctl_files_rwlock
);
1861 list_for_each_entry(ctl
, &card
->ctl_files
, list
) {
1862 wake_up(&ctl
->change_sleep
);
1863 kill_fasync(&ctl
->fasync
, SIGIO
, POLL_ERR
);
1865 read_unlock(&card
->ctl_files_rwlock
);
1867 return snd_unregister_device(&card
->ctl_dev
);
1873 static int snd_ctl_dev_free(struct snd_device
*device
)
1875 struct snd_card
*card
= device
->device_data
;
1876 struct snd_kcontrol
*control
;
1878 down_write(&card
->controls_rwsem
);
1879 while (!list_empty(&card
->controls
)) {
1880 control
= snd_kcontrol(card
->controls
.next
);
1881 snd_ctl_remove(card
, control
);
1883 up_write(&card
->controls_rwsem
);
1884 put_device(&card
->ctl_dev
);
1889 * create control core:
1890 * called from init.c
1892 int snd_ctl_create(struct snd_card
*card
)
1894 static struct snd_device_ops ops
= {
1895 .dev_free
= snd_ctl_dev_free
,
1896 .dev_register
= snd_ctl_dev_register
,
1897 .dev_disconnect
= snd_ctl_dev_disconnect
,
1901 if (snd_BUG_ON(!card
))
1903 if (snd_BUG_ON(card
->number
< 0 || card
->number
>= SNDRV_CARDS
))
1906 snd_device_initialize(&card
->ctl_dev
, card
);
1907 dev_set_name(&card
->ctl_dev
, "controlC%d", card
->number
);
1909 err
= snd_device_new(card
, SNDRV_DEV_CONTROL
, card
, &ops
);
1911 put_device(&card
->ctl_dev
);
1916 * Frequently used control callbacks/helpers
1920 * snd_ctl_boolean_mono_info - Helper function for a standard boolean info
1921 * callback with a mono channel
1922 * @kcontrol: the kcontrol instance
1923 * @uinfo: info to store
1925 * This is a function that can be used as info callback for a standard
1926 * boolean control with a single mono channel.
1928 int snd_ctl_boolean_mono_info(struct snd_kcontrol
*kcontrol
,
1929 struct snd_ctl_elem_info
*uinfo
)
1931 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1933 uinfo
->value
.integer
.min
= 0;
1934 uinfo
->value
.integer
.max
= 1;
1937 EXPORT_SYMBOL(snd_ctl_boolean_mono_info
);
1940 * snd_ctl_boolean_stereo_info - Helper function for a standard boolean info
1941 * callback with stereo two channels
1942 * @kcontrol: the kcontrol instance
1943 * @uinfo: info to store
1945 * This is a function that can be used as info callback for a standard
1946 * boolean control with stereo two channels.
1948 int snd_ctl_boolean_stereo_info(struct snd_kcontrol
*kcontrol
,
1949 struct snd_ctl_elem_info
*uinfo
)
1951 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1953 uinfo
->value
.integer
.min
= 0;
1954 uinfo
->value
.integer
.max
= 1;
1957 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info
);
1960 * snd_ctl_enum_info - fills the info structure for an enumerated control
1961 * @info: the structure to be filled
1962 * @channels: the number of the control's channels; often one
1963 * @items: the number of control values; also the size of @names
1964 * @names: an array containing the names of all control values
1966 * Sets all required fields in @info to their appropriate values.
1967 * If the control's accessibility is not the default (readable and writable),
1968 * the caller has to fill @info->access.
1972 int snd_ctl_enum_info(struct snd_ctl_elem_info
*info
, unsigned int channels
,
1973 unsigned int items
, const char *const names
[])
1975 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1976 info
->count
= channels
;
1977 info
->value
.enumerated
.items
= items
;
1980 if (info
->value
.enumerated
.item
>= items
)
1981 info
->value
.enumerated
.item
= items
- 1;
1982 WARN(strlen(names
[info
->value
.enumerated
.item
]) >= sizeof(info
->value
.enumerated
.name
),
1983 "ALSA: too long item name '%s'\n",
1984 names
[info
->value
.enumerated
.item
]);
1985 strlcpy(info
->value
.enumerated
.name
,
1986 names
[info
->value
.enumerated
.item
],
1987 sizeof(info
->value
.enumerated
.name
));
1990 EXPORT_SYMBOL(snd_ctl_enum_info
);