blob: 268ab7471224a5e42fe4f448df75c7ad4ad7094e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Routines for driver control interface
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02003 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 *
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.
10 *
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.
15 *
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
19 *
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/threads.h>
23#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/slab.h>
25#include <linux/vmalloc.h>
26#include <linux/time.h>
27#include <sound/core.h>
28#include <sound/minors.h>
29#include <sound/info.h>
30#include <sound/control.h>
31
32/* max number of user-defined controls */
33#define MAX_USER_CONTROLS 32
34
Takashi Iwai82e9bae2005-11-17 13:53:23 +010035struct snd_kctl_ioctl {
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 struct list_head list; /* list of all ioctls */
37 snd_kctl_ioctl_func_t fioctl;
Takashi Iwai82e9bae2005-11-17 13:53:23 +010038};
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40static DECLARE_RWSEM(snd_ioctl_rwsem);
41static LIST_HEAD(snd_control_ioctls);
42#ifdef CONFIG_COMPAT
43static LIST_HEAD(snd_control_compat_ioctls);
44#endif
45
46static int snd_ctl_open(struct inode *inode, struct file *file)
47{
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 unsigned long flags;
Takashi Iwai82e9bae2005-11-17 13:53:23 +010049 struct snd_card *card;
50 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 int err;
52
Clemens Ladischf87135f2005-11-20 14:06:59 +010053 card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 if (!card) {
55 err = -ENODEV;
56 goto __error1;
57 }
58 err = snd_card_file_add(card, file);
59 if (err < 0) {
60 err = -ENODEV;
61 goto __error1;
62 }
63 if (!try_module_get(card->module)) {
64 err = -EFAULT;
65 goto __error2;
66 }
Takashi Iwaica2c0962005-09-09 14:20:23 +020067 ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 if (ctl == NULL) {
69 err = -ENOMEM;
70 goto __error;
71 }
72 INIT_LIST_HEAD(&ctl->events);
73 init_waitqueue_head(&ctl->change_sleep);
74 spin_lock_init(&ctl->read_lock);
75 ctl->card = card;
Takashi Iwai2529bba2006-08-04 12:57:19 +020076 ctl->prefer_pcm_subdevice = -1;
77 ctl->prefer_rawmidi_subdevice = -1;
Clemens Ladisch25d27ed2009-11-02 09:35:44 +010078 ctl->pid = get_pid(task_pid(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 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);
83 return 0;
84
85 __error:
86 module_put(card->module);
87 __error2:
88 snd_card_file_remove(card, file);
89 __error1:
90 return err;
91}
92
Takashi Iwai82e9bae2005-11-17 13:53:23 +010093static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
Borislav Petkov7507e8d2007-10-22 17:11:09 +020095 unsigned long flags;
Takashi Iwai82e9bae2005-11-17 13:53:23 +010096 struct snd_kctl_event *cread;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Borislav Petkov7507e8d2007-10-22 17:11:09 +020098 spin_lock_irqsave(&ctl->read_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 while (!list_empty(&ctl->events)) {
100 cread = snd_kctl_event(ctl->events.next);
101 list_del(&cread->list);
102 kfree(cread);
103 }
Borislav Petkov7507e8d2007-10-22 17:11:09 +0200104 spin_unlock_irqrestore(&ctl->read_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
106
107static int snd_ctl_release(struct inode *inode, struct file *file)
108{
109 unsigned long flags;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100110 struct snd_card *card;
111 struct snd_ctl_file *ctl;
112 struct snd_kcontrol *control;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 unsigned int idx;
114
115 ctl = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 file->private_data = NULL;
117 card = ctl->card;
118 write_lock_irqsave(&card->ctl_files_rwlock, flags);
119 list_del(&ctl->list);
120 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
121 down_write(&card->controls_rwsem);
Johannes Berg9244b2c2006-10-05 16:02:22 +0200122 list_for_each_entry(control, &card->controls, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 for (idx = 0; idx < control->count; idx++)
124 if (control->vd[idx].owner == ctl)
125 control->vd[idx].owner = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 up_write(&card->controls_rwsem);
127 snd_ctl_empty_read_queue(ctl);
Clemens Ladisch25d27ed2009-11-02 09:35:44 +0100128 put_pid(ctl->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 kfree(ctl);
130 module_put(card->module);
131 snd_card_file_remove(card, file);
132 return 0;
133}
134
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100135void snd_ctl_notify(struct snd_card *card, unsigned int mask,
136 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
138 unsigned long flags;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100139 struct snd_ctl_file *ctl;
140 struct snd_kctl_event *ev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200142 if (snd_BUG_ON(!card || !id))
143 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 read_lock(&card->ctl_files_rwlock);
145#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
146 card->mixer_oss_change_count++;
147#endif
Johannes Berg9244b2c2006-10-05 16:02:22 +0200148 list_for_each_entry(ctl, &card->ctl_files, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 if (!ctl->subscribed)
150 continue;
151 spin_lock_irqsave(&ctl->read_lock, flags);
Johannes Berg9244b2c2006-10-05 16:02:22 +0200152 list_for_each_entry(ev, &ctl->events, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 if (ev->id.numid == id->numid) {
154 ev->mask |= mask;
155 goto _found;
156 }
157 }
Takashi Iwaica2c0962005-09-09 14:20:23 +0200158 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if (ev) {
160 ev->id = *id;
161 ev->mask = mask;
162 list_add_tail(&ev->list, &ctl->events);
163 } else {
164 snd_printk(KERN_ERR "No memory available to allocate event\n");
165 }
166 _found:
167 wake_up(&ctl->change_sleep);
168 spin_unlock_irqrestore(&ctl->read_lock, flags);
169 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
170 }
171 read_unlock(&card->ctl_files_rwlock);
172}
173
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200174EXPORT_SYMBOL(snd_ctl_notify);
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176/**
177 * snd_ctl_new - create a control instance from the template
178 * @control: the control template
179 * @access: the default control access
180 *
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100181 * Allocates a new struct snd_kcontrol instance and copies the given template
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * to the new instance. It does not copy volatile data (access).
183 *
184 * Returns the pointer of the new instance, or NULL on failure.
185 */
Adrian Bunk0b51ba02006-11-20 17:50:17 +0100186static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
187 unsigned int access)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100189 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 unsigned int idx;
191
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200192 if (snd_BUG_ON(!control || !control->count))
193 return NULL;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100194 kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100195 if (kctl == NULL) {
196 snd_printk(KERN_ERR "Cannot allocate control instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return NULL;
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100198 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 *kctl = *control;
200 for (idx = 0; idx < kctl->count; idx++)
201 kctl->vd[idx].access = access;
202 return kctl;
203}
204
205/**
206 * snd_ctl_new1 - create a control instance from the template
207 * @ncontrol: the initialization record
208 * @private_data: the private data to set
209 *
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100210 * Allocates a new struct snd_kcontrol instance and initialize from the given
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 * template. When the access field of ncontrol is 0, it's assumed as
212 * READWRITE access. When the count field is 0, it's assumes as one.
213 *
214 * Returns the pointer of the newly generated instance, or NULL on failure.
215 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100216struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
217 void *private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100219 struct snd_kcontrol kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 unsigned int access;
221
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200222 if (snd_BUG_ON(!ncontrol || !ncontrol->info))
223 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 memset(&kctl, 0, sizeof(kctl));
225 kctl.id.iface = ncontrol->iface;
226 kctl.id.device = ncontrol->device;
227 kctl.id.subdevice = ncontrol->subdevice;
Mark Brown366840d2008-10-29 14:40:30 +0000228 if (ncontrol->name) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
Mark Brown366840d2008-10-29 14:40:30 +0000230 if (strcmp(ncontrol->name, kctl.id.name) != 0)
231 snd_printk(KERN_WARNING
232 "Control name '%s' truncated to '%s'\n",
233 ncontrol->name, kctl.id.name);
234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 kctl.id.index = ncontrol->index;
236 kctl.count = ncontrol->count ? ncontrol->count : 1;
237 access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200238 (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
239 SNDRV_CTL_ELEM_ACCESS_INACTIVE|
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200240 SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
241 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 kctl.info = ncontrol->info;
243 kctl.get = ncontrol->get;
244 kctl.put = ncontrol->put;
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200245 kctl.tlv.p = ncontrol->tlv.p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 kctl.private_value = ncontrol->private_value;
247 kctl.private_data = private_data;
248 return snd_ctl_new(&kctl, access);
249}
250
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200251EXPORT_SYMBOL(snd_ctl_new1);
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253/**
254 * snd_ctl_free_one - release the control instance
255 * @kcontrol: the control instance
256 *
257 * Releases the control instance created via snd_ctl_new()
258 * or snd_ctl_new1().
259 * Don't call this after the control was added to the card.
260 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100261void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 if (kcontrol) {
264 if (kcontrol->private_free)
265 kcontrol->private_free(kcontrol);
266 kfree(kcontrol);
267 }
268}
269
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200270EXPORT_SYMBOL(snd_ctl_free_one);
271
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100272static unsigned int snd_ctl_hole_check(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 unsigned int count)
274{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100275 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Johannes Berg9244b2c2006-10-05 16:02:22 +0200277 list_for_each_entry(kctl, &card->controls, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 if ((kctl->id.numid <= card->last_numid &&
279 kctl->id.numid + kctl->count > card->last_numid) ||
280 (kctl->id.numid <= card->last_numid + count - 1 &&
281 kctl->id.numid + kctl->count > card->last_numid + count - 1))
282 return card->last_numid = kctl->id.numid + kctl->count - 1;
283 }
284 return card->last_numid;
285}
286
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100287static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 unsigned int last_numid, iter = 100000;
290
291 last_numid = card->last_numid;
292 while (last_numid != snd_ctl_hole_check(card, count)) {
293 if (--iter == 0) {
294 /* this situation is very unlikely */
295 snd_printk(KERN_ERR "unable to allocate new control numid\n");
296 return -ENOMEM;
297 }
298 last_numid = card->last_numid;
299 }
300 return 0;
301}
302
303/**
304 * snd_ctl_add - add the control instance to the card
305 * @card: the card instance
306 * @kcontrol: the control instance to add
307 *
308 * Adds the control instance created via snd_ctl_new() or
309 * snd_ctl_new1() to the given card. Assigns also an unique
310 * numid used for fast search.
311 *
312 * Returns zero if successful, or a negative error code on failure.
313 *
314 * It frees automatically the control which cannot be added.
315 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100316int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100318 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 unsigned int idx;
Takashi Iwaic6077b32006-03-21 16:07:13 +0100320 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100322 if (! kcontrol)
Takashi Iwaic6077b32006-03-21 16:07:13 +0100323 return err;
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200324 if (snd_BUG_ON(!card || !kcontrol->info))
325 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 id = kcontrol->id;
327 down_write(&card->controls_rwsem);
328 if (snd_ctl_find_id(card, &id)) {
329 up_write(&card->controls_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
331 id.iface,
332 id.device,
333 id.subdevice,
334 id.name,
335 id.index);
Takashi Iwaic6077b32006-03-21 16:07:13 +0100336 err = -EBUSY;
337 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339 if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
340 up_write(&card->controls_rwsem);
Takashi Iwaic6077b32006-03-21 16:07:13 +0100341 err = -ENOMEM;
342 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 }
344 list_add_tail(&kcontrol->list, &card->controls);
345 card->controls_count += kcontrol->count;
346 kcontrol->id.numid = card->last_numid + 1;
347 card->last_numid += kcontrol->count;
348 up_write(&card->controls_rwsem);
349 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
350 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
351 return 0;
Takashi Iwaic6077b32006-03-21 16:07:13 +0100352
353 error:
354 snd_ctl_free_one(kcontrol);
355 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
357
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200358EXPORT_SYMBOL(snd_ctl_add);
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360/**
361 * snd_ctl_remove - remove the control from the card and release it
362 * @card: the card instance
363 * @kcontrol: the control instance to remove
364 *
365 * Removes the control from the card and then releases the instance.
366 * You don't need to call snd_ctl_free_one(). You must be in
367 * the write lock - down_write(&card->controls_rwsem).
368 *
369 * Returns 0 if successful, or a negative error code on failure.
370 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100371int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100373 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 unsigned int idx;
375
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200376 if (snd_BUG_ON(!card || !kcontrol))
377 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 list_del(&kcontrol->list);
379 card->controls_count -= kcontrol->count;
380 id = kcontrol->id;
381 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
382 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
383 snd_ctl_free_one(kcontrol);
384 return 0;
385}
386
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200387EXPORT_SYMBOL(snd_ctl_remove);
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389/**
390 * snd_ctl_remove_id - remove the control of the given id and release it
391 * @card: the card instance
392 * @id: the control id to remove
393 *
394 * Finds the control instance with the given id, removes it from the
395 * card list and releases it.
396 *
397 * Returns 0 if successful, or a negative error code on failure.
398 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100399int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100401 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 int ret;
403
404 down_write(&card->controls_rwsem);
405 kctl = snd_ctl_find_id(card, id);
406 if (kctl == NULL) {
407 up_write(&card->controls_rwsem);
408 return -ENOENT;
409 }
410 ret = snd_ctl_remove(card, kctl);
411 up_write(&card->controls_rwsem);
412 return ret;
413}
414
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200415EXPORT_SYMBOL(snd_ctl_remove_id);
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417/**
Clemens Ladischf217ac52009-08-17 12:27:22 +0200418 * snd_ctl_remove_user_ctl - remove and release the unlocked user control
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 * @file: active control handle
420 * @id: the control id to remove
421 *
422 * Finds the control instance with the given id, removes it from the
423 * card list and releases it.
424 *
425 * Returns 0 if successful, or a negative error code on failure.
426 */
Clemens Ladischf217ac52009-08-17 12:27:22 +0200427static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
428 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100430 struct snd_card *card = file->card;
431 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 int idx, ret;
433
434 down_write(&card->controls_rwsem);
435 kctl = snd_ctl_find_id(card, id);
436 if (kctl == NULL) {
Clemens Ladisch317b8082009-08-17 12:26:34 +0200437 ret = -ENOENT;
438 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 }
Clemens Ladisch18dd0aa2009-08-17 12:28:09 +0200440 if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
441 ret = -EINVAL;
442 goto error;
443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 for (idx = 0; idx < kctl->count; idx++)
445 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
Clemens Ladisch317b8082009-08-17 12:26:34 +0200446 ret = -EBUSY;
447 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
449 ret = snd_ctl_remove(card, kctl);
Clemens Ladischf217ac52009-08-17 12:27:22 +0200450 if (ret < 0)
451 goto error;
452 card->user_ctl_count--;
Clemens Ladisch317b8082009-08-17 12:26:34 +0200453error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 up_write(&card->controls_rwsem);
455 return ret;
456}
457
458/**
459 * snd_ctl_rename_id - replace the id of a control on the card
460 * @card: the card instance
461 * @src_id: the old id
462 * @dst_id: the new id
463 *
464 * Finds the control with the old id from the card, and replaces the
465 * id with the new one.
466 *
467 * Returns zero if successful, or a negative error code on failure.
468 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100469int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
470 struct snd_ctl_elem_id *dst_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100472 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474 down_write(&card->controls_rwsem);
475 kctl = snd_ctl_find_id(card, src_id);
476 if (kctl == NULL) {
477 up_write(&card->controls_rwsem);
478 return -ENOENT;
479 }
480 kctl->id = *dst_id;
481 kctl->id.numid = card->last_numid + 1;
482 card->last_numid += kctl->count;
483 up_write(&card->controls_rwsem);
484 return 0;
485}
486
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200487EXPORT_SYMBOL(snd_ctl_rename_id);
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489/**
490 * snd_ctl_find_numid - find the control instance with the given number-id
491 * @card: the card instance
492 * @numid: the number-id to search
493 *
494 * Finds the control instance with the given number-id from the card.
495 *
496 * Returns the pointer of the instance if found, or NULL if not.
497 *
498 * The caller must down card->controls_rwsem before calling this function
499 * (if the race condition can happen).
500 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100501struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100503 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200505 if (snd_BUG_ON(!card || !numid))
506 return NULL;
Johannes Berg9244b2c2006-10-05 16:02:22 +0200507 list_for_each_entry(kctl, &card->controls, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
509 return kctl;
510 }
511 return NULL;
512}
513
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200514EXPORT_SYMBOL(snd_ctl_find_numid);
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516/**
517 * snd_ctl_find_id - find the control instance with the given id
518 * @card: the card instance
519 * @id: the id to search
520 *
521 * Finds the control instance with the given id from the card.
522 *
523 * Returns the pointer of the instance if found, or NULL if not.
524 *
525 * The caller must down card->controls_rwsem before calling this function
526 * (if the race condition can happen).
527 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100528struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
529 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100531 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200533 if (snd_BUG_ON(!card || !id))
534 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (id->numid != 0)
536 return snd_ctl_find_numid(card, id->numid);
Johannes Berg9244b2c2006-10-05 16:02:22 +0200537 list_for_each_entry(kctl, &card->controls, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (kctl->id.iface != id->iface)
539 continue;
540 if (kctl->id.device != id->device)
541 continue;
542 if (kctl->id.subdevice != id->subdevice)
543 continue;
544 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
545 continue;
546 if (kctl->id.index > id->index)
547 continue;
548 if (kctl->id.index + kctl->count <= id->index)
549 continue;
550 return kctl;
551 }
552 return NULL;
553}
554
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200555EXPORT_SYMBOL(snd_ctl_find_id);
556
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100557static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 unsigned int cmd, void __user *arg)
559{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100560 struct snd_ctl_card_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Takashi Iwaica2c0962005-09-09 14:20:23 +0200562 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (! info)
564 return -ENOMEM;
565 down_read(&snd_ioctl_rwsem);
566 info->card = card->number;
567 strlcpy(info->id, card->id, sizeof(info->id));
568 strlcpy(info->driver, card->driver, sizeof(info->driver));
569 strlcpy(info->name, card->shortname, sizeof(info->name));
570 strlcpy(info->longname, card->longname, sizeof(info->longname));
571 strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
572 strlcpy(info->components, card->components, sizeof(info->components));
573 up_read(&snd_ioctl_rwsem);
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100574 if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 kfree(info);
576 return -EFAULT;
577 }
578 kfree(info);
579 return 0;
580}
581
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100582static int snd_ctl_elem_list(struct snd_card *card,
583 struct snd_ctl_elem_list __user *_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
585 struct list_head *plist;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100586 struct snd_ctl_elem_list list;
587 struct snd_kcontrol *kctl;
588 struct snd_ctl_elem_id *dst, *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 unsigned int offset, space, first, jidx;
590
591 if (copy_from_user(&list, _list, sizeof(list)))
592 return -EFAULT;
593 offset = list.offset;
594 space = list.space;
595 first = 0;
596 /* try limit maximum space */
597 if (space > 16384)
598 return -ENOMEM;
599 if (space > 0) {
600 /* allocate temporary buffer for atomic operation */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100601 dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 if (dst == NULL)
603 return -ENOMEM;
604 down_read(&card->controls_rwsem);
605 list.count = card->controls_count;
606 plist = card->controls.next;
607 while (plist != &card->controls) {
608 if (offset == 0)
609 break;
610 kctl = snd_kcontrol(plist);
611 if (offset < kctl->count)
612 break;
613 offset -= kctl->count;
614 plist = plist->next;
615 }
616 list.used = 0;
617 id = dst;
618 while (space > 0 && plist != &card->controls) {
619 kctl = snd_kcontrol(plist);
620 for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
621 snd_ctl_build_ioff(id, kctl, jidx);
622 id++;
623 space--;
624 list.used++;
625 }
626 plist = plist->next;
627 offset = 0;
628 }
629 up_read(&card->controls_rwsem);
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100630 if (list.used > 0 &&
631 copy_to_user(list.pids, dst,
632 list.used * sizeof(struct snd_ctl_elem_id))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 vfree(dst);
634 return -EFAULT;
635 }
636 vfree(dst);
637 } else {
638 down_read(&card->controls_rwsem);
639 list.count = card->controls_count;
640 up_read(&card->controls_rwsem);
641 }
642 if (copy_to_user(_list, &list, sizeof(list)))
643 return -EFAULT;
644 return 0;
645}
646
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100647static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
648 struct snd_ctl_elem_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100650 struct snd_card *card = ctl->card;
651 struct snd_kcontrol *kctl;
652 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 unsigned int index_offset;
654 int result;
655
656 down_read(&card->controls_rwsem);
657 kctl = snd_ctl_find_id(card, &info->id);
658 if (kctl == NULL) {
659 up_read(&card->controls_rwsem);
660 return -ENOENT;
661 }
662#ifdef CONFIG_SND_DEBUG
663 info->access = 0;
664#endif
665 result = kctl->info(kctl, info);
666 if (result >= 0) {
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200667 snd_BUG_ON(info->access);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 index_offset = snd_ctl_get_ioff(kctl, &info->id);
669 vd = &kctl->vd[index_offset];
670 snd_ctl_build_ioff(&info->id, kctl, index_offset);
671 info->access = vd->access;
672 if (vd->owner) {
673 info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
674 if (vd->owner == ctl)
675 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
Clemens Ladisch25d27ed2009-11-02 09:35:44 +0100676 info->owner = pid_vnr(vd->owner->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 } else {
678 info->owner = -1;
679 }
680 }
681 up_read(&card->controls_rwsem);
682 return result;
683}
684
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100685static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
686 struct snd_ctl_elem_info __user *_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100688 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 int result;
690
691 if (copy_from_user(&info, _info, sizeof(info)))
692 return -EFAULT;
Giuliano Pochini64649402006-03-13 14:11:11 +0100693 snd_power_lock(ctl->card);
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200694 result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0);
Giuliano Pochini64649402006-03-13 14:11:11 +0100695 if (result >= 0)
696 result = snd_ctl_elem_info(ctl, &info);
697 snd_power_unlock(ctl->card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 if (result >= 0)
699 if (copy_to_user(_info, &info, sizeof(info)))
700 return -EFAULT;
701 return result;
702}
703
Takashi Iwaid3bd67c2008-06-12 18:17:26 +0200704static int snd_ctl_elem_read(struct snd_card *card,
705 struct snd_ctl_elem_value *control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100707 struct snd_kcontrol *kctl;
708 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 unsigned int index_offset;
Takashi Iwai8ace4f32008-01-08 17:57:26 +0100710 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
712 down_read(&card->controls_rwsem);
713 kctl = snd_ctl_find_id(card, &control->id);
714 if (kctl == NULL) {
715 result = -ENOENT;
716 } else {
717 index_offset = snd_ctl_get_ioff(kctl, &control->id);
718 vd = &kctl->vd[index_offset];
Takashi Iwai8ace4f32008-01-08 17:57:26 +0100719 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) &&
720 kctl->get != NULL) {
721 snd_ctl_build_ioff(&control->id, kctl, index_offset);
722 result = kctl->get(kctl, control);
723 } else
724 result = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726 up_read(&card->controls_rwsem);
727 return result;
728}
729
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100730static int snd_ctl_elem_read_user(struct snd_card *card,
731 struct snd_ctl_elem_value __user *_control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100733 struct snd_ctl_elem_value *control;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 int result;
Li Zefanef44a1e2009-04-10 09:43:08 +0800735
736 control = memdup_user(_control, sizeof(*control));
737 if (IS_ERR(control))
738 return PTR_ERR(control);
739
Giuliano Pochini64649402006-03-13 14:11:11 +0100740 snd_power_lock(card);
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200741 result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
Giuliano Pochini64649402006-03-13 14:11:11 +0100742 if (result >= 0)
743 result = snd_ctl_elem_read(card, control);
744 snd_power_unlock(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 if (result >= 0)
746 if (copy_to_user(_control, control, sizeof(*control)))
747 result = -EFAULT;
748 kfree(control);
749 return result;
750}
751
Takashi Iwaid3bd67c2008-06-12 18:17:26 +0200752static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
753 struct snd_ctl_elem_value *control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100755 struct snd_kcontrol *kctl;
756 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 unsigned int index_offset;
Takashi Iwai8ace4f32008-01-08 17:57:26 +0100758 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 down_read(&card->controls_rwsem);
761 kctl = snd_ctl_find_id(card, &control->id);
762 if (kctl == NULL) {
763 result = -ENOENT;
764 } else {
765 index_offset = snd_ctl_get_ioff(kctl, &control->id);
766 vd = &kctl->vd[index_offset];
Takashi Iwai8ace4f32008-01-08 17:57:26 +0100767 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
768 kctl->put == NULL ||
769 (file && vd->owner && vd->owner != file)) {
770 result = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 } else {
Takashi Iwai8ace4f32008-01-08 17:57:26 +0100772 snd_ctl_build_ioff(&control->id, kctl, index_offset);
773 result = kctl->put(kctl, control);
774 }
775 if (result > 0) {
776 up_read(&card->controls_rwsem);
777 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
778 &control->id);
779 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 }
781 }
782 up_read(&card->controls_rwsem);
783 return result;
784}
785
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100786static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
787 struct snd_ctl_elem_value __user *_control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100789 struct snd_ctl_elem_value *control;
Giuliano Pochini64649402006-03-13 14:11:11 +0100790 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 int result;
792
Li Zefanef44a1e2009-04-10 09:43:08 +0800793 control = memdup_user(_control, sizeof(*control));
794 if (IS_ERR(control))
795 return PTR_ERR(control);
796
Giuliano Pochini64649402006-03-13 14:11:11 +0100797 card = file->card;
798 snd_power_lock(card);
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200799 result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
Giuliano Pochini64649402006-03-13 14:11:11 +0100800 if (result >= 0)
801 result = snd_ctl_elem_write(card, file, control);
802 snd_power_unlock(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 if (result >= 0)
804 if (copy_to_user(_control, control, sizeof(*control)))
805 result = -EFAULT;
806 kfree(control);
807 return result;
808}
809
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100810static int snd_ctl_elem_lock(struct snd_ctl_file *file,
811 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100813 struct snd_card *card = file->card;
814 struct snd_ctl_elem_id id;
815 struct snd_kcontrol *kctl;
816 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 int result;
818
819 if (copy_from_user(&id, _id, sizeof(id)))
820 return -EFAULT;
821 down_write(&card->controls_rwsem);
822 kctl = snd_ctl_find_id(card, &id);
823 if (kctl == NULL) {
824 result = -ENOENT;
825 } else {
826 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
827 if (vd->owner != NULL)
828 result = -EBUSY;
829 else {
830 vd->owner = file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 result = 0;
832 }
833 }
834 up_write(&card->controls_rwsem);
835 return result;
836}
837
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100838static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
839 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100841 struct snd_card *card = file->card;
842 struct snd_ctl_elem_id id;
843 struct snd_kcontrol *kctl;
844 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 int result;
846
847 if (copy_from_user(&id, _id, sizeof(id)))
848 return -EFAULT;
849 down_write(&card->controls_rwsem);
850 kctl = snd_ctl_find_id(card, &id);
851 if (kctl == NULL) {
852 result = -ENOENT;
853 } else {
854 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
855 if (vd->owner == NULL)
856 result = -EINVAL;
857 else if (vd->owner != file)
858 result = -EPERM;
859 else {
860 vd->owner = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 result = 0;
862 }
863 }
864 up_write(&card->controls_rwsem);
865 return result;
866}
867
868struct user_element {
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100869 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 void *elem_data; /* element data */
871 unsigned long elem_data_size; /* size of element data in bytes */
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200872 void *tlv_data; /* TLV data */
873 unsigned long tlv_data_size; /* TLV data size */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 void *priv_data; /* private data (like strings for enumerated type) */
875 unsigned long priv_data_size; /* size of private data in bytes */
876};
877
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100878static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
879 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
881 struct user_element *ue = kcontrol->private_data;
882
883 *uinfo = ue->info;
884 return 0;
885}
886
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100887static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
888 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
890 struct user_element *ue = kcontrol->private_data;
891
892 memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
893 return 0;
894}
895
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100896static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
897 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898{
899 int change;
900 struct user_element *ue = kcontrol->private_data;
901
902 change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
903 if (change)
904 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
905 return change;
906}
907
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200908static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol,
909 int op_flag,
910 unsigned int size,
911 unsigned int __user *tlv)
912{
913 struct user_element *ue = kcontrol->private_data;
914 int change = 0;
915 void *new_data;
916
917 if (op_flag > 0) {
918 if (size > 1024 * 128) /* sane value */
919 return -EINVAL;
Li Zefanef44a1e2009-04-10 09:43:08 +0800920
921 new_data = memdup_user(tlv, size);
922 if (IS_ERR(new_data))
923 return PTR_ERR(new_data);
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200924 change = ue->tlv_data_size != size;
925 if (!change)
926 change = memcmp(ue->tlv_data, new_data, size);
927 kfree(ue->tlv_data);
928 ue->tlv_data = new_data;
929 ue->tlv_data_size = size;
930 } else {
Takashi Iwai18c1c3f2006-08-25 11:39:34 +0200931 if (! ue->tlv_data_size || ! ue->tlv_data)
932 return -ENXIO;
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200933 if (size < ue->tlv_data_size)
934 return -ENOSPC;
935 if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size))
936 return -EFAULT;
937 }
938 return change;
939}
940
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100941static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942{
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200943 struct user_element *ue = kcontrol->private_data;
944 if (ue->tlv_data)
945 kfree(ue->tlv_data);
946 kfree(ue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947}
948
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100949static int snd_ctl_elem_add(struct snd_ctl_file *file,
950 struct snd_ctl_elem_info *info, int replace)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100952 struct snd_card *card = file->card;
953 struct snd_kcontrol kctl, *_kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 unsigned int access;
955 long private_size;
956 struct user_element *ue;
957 int idx, err;
958
959 if (card->user_ctl_count >= MAX_USER_CONTROLS)
960 return -ENOMEM;
Clemens Ladisch2a031ae2009-08-17 12:25:52 +0200961 if (info->count < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 return -EINVAL;
963 access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100964 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200965 SNDRV_CTL_ELEM_ACCESS_INACTIVE|
966 SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 info->id.numid = 0;
968 memset(&kctl, 0, sizeof(kctl));
969 down_write(&card->controls_rwsem);
970 _kctl = snd_ctl_find_id(card, &info->id);
971 err = 0;
972 if (_kctl) {
973 if (replace)
974 err = snd_ctl_remove(card, _kctl);
975 else
976 err = -EBUSY;
977 } else {
978 if (replace)
979 err = -ENOENT;
980 }
981 up_write(&card->controls_rwsem);
982 if (err < 0)
983 return err;
984 memcpy(&kctl.id, &info->id, sizeof(info->id));
985 kctl.count = info->owner ? info->owner : 1;
986 access |= SNDRV_CTL_ELEM_ACCESS_USER;
987 kctl.info = snd_ctl_elem_user_info;
988 if (access & SNDRV_CTL_ELEM_ACCESS_READ)
989 kctl.get = snd_ctl_elem_user_get;
990 if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
991 kctl.put = snd_ctl_elem_user_put;
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +0200992 if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
993 kctl.tlv.c = snd_ctl_elem_user_tlv;
994 access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 switch (info->type) {
997 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 case SNDRV_CTL_ELEM_TYPE_INTEGER:
999 private_size = sizeof(long);
1000 if (info->count > 128)
1001 return -EINVAL;
1002 break;
1003 case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1004 private_size = sizeof(long long);
1005 if (info->count > 64)
1006 return -EINVAL;
1007 break;
1008 case SNDRV_CTL_ELEM_TYPE_BYTES:
1009 private_size = sizeof(unsigned char);
1010 if (info->count > 512)
1011 return -EINVAL;
1012 break;
1013 case SNDRV_CTL_ELEM_TYPE_IEC958:
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001014 private_size = sizeof(struct snd_aes_iec958);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (info->count != 1)
1016 return -EINVAL;
1017 break;
1018 default:
1019 return -EINVAL;
1020 }
1021 private_size *= info->count;
Takashi Iwaica2c0962005-09-09 14:20:23 +02001022 ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 if (ue == NULL)
1024 return -ENOMEM;
1025 ue->info = *info;
Takashi Iwai86148e82006-08-24 12:36:36 +02001026 ue->info.access = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 ue->elem_data = (char *)ue + sizeof(*ue);
1028 ue->elem_data_size = private_size;
1029 kctl.private_free = snd_ctl_elem_user_free;
1030 _kctl = snd_ctl_new(&kctl, access);
1031 if (_kctl == NULL) {
Takashi Iwai2fbf1822006-03-06 15:42:51 -08001032 kfree(ue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 return -ENOMEM;
1034 }
1035 _kctl->private_data = ue;
1036 for (idx = 0; idx < _kctl->count; idx++)
1037 _kctl->vd[idx].owner = file;
1038 err = snd_ctl_add(card, _kctl);
Takashi Iwai2fbf1822006-03-06 15:42:51 -08001039 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
1042 down_write(&card->controls_rwsem);
1043 card->user_ctl_count++;
1044 up_write(&card->controls_rwsem);
1045
1046 return 0;
1047}
1048
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001049static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
1050 struct snd_ctl_elem_info __user *_info, int replace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001052 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (copy_from_user(&info, _info, sizeof(info)))
1054 return -EFAULT;
1055 return snd_ctl_elem_add(file, &info, replace);
1056}
1057
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001058static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1059 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001061 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
1063 if (copy_from_user(&id, _id, sizeof(id)))
1064 return -EFAULT;
Clemens Ladischf217ac52009-08-17 12:27:22 +02001065 return snd_ctl_remove_user_ctl(file, &id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066}
1067
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001068static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
1070 int subscribe;
1071 if (get_user(subscribe, ptr))
1072 return -EFAULT;
1073 if (subscribe < 0) {
1074 subscribe = file->subscribed;
1075 if (put_user(subscribe, ptr))
1076 return -EFAULT;
1077 return 0;
1078 }
1079 if (subscribe) {
1080 file->subscribed = 1;
1081 return 0;
1082 } else if (file->subscribed) {
1083 snd_ctl_empty_read_queue(file);
1084 file->subscribed = 0;
1085 }
1086 return 0;
1087}
1088
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001089static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
1090 struct snd_ctl_tlv __user *_tlv,
1091 int op_flag)
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001092{
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001093 struct snd_card *card = file->card;
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001094 struct snd_ctl_tlv tlv;
1095 struct snd_kcontrol *kctl;
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001096 struct snd_kcontrol_volatile *vd;
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001097 unsigned int len;
1098 int err = 0;
1099
1100 if (copy_from_user(&tlv, _tlv, sizeof(tlv)))
1101 return -EFAULT;
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001102 if (tlv.length < sizeof(unsigned int) * 3)
1103 return -EINVAL;
1104 down_read(&card->controls_rwsem);
1105 kctl = snd_ctl_find_numid(card, tlv.numid);
1106 if (kctl == NULL) {
1107 err = -ENOENT;
1108 goto __kctl_end;
1109 }
1110 if (kctl->tlv.p == NULL) {
1111 err = -ENXIO;
1112 goto __kctl_end;
1113 }
1114 vd = &kctl->vd[tlv.numid - kctl->id.numid];
1115 if ((op_flag == 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) == 0) ||
1116 (op_flag > 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) == 0) ||
1117 (op_flag < 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) == 0)) {
1118 err = -ENXIO;
1119 goto __kctl_end;
1120 }
1121 if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
Dan Carpenterbec145a2009-11-18 10:31:57 +02001122 if (vd->owner != NULL && vd->owner != file) {
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001123 err = -EPERM;
1124 goto __kctl_end;
1125 }
1126 err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv);
1127 if (err > 0) {
1128 up_read(&card->controls_rwsem);
1129 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &kctl->id);
1130 return 0;
1131 }
1132 } else {
1133 if (op_flag) {
1134 err = -ENXIO;
1135 goto __kctl_end;
1136 }
1137 len = kctl->tlv.p[1] + 2 * sizeof(unsigned int);
1138 if (tlv.length < len) {
1139 err = -ENOMEM;
1140 goto __kctl_end;
1141 }
1142 if (copy_to_user(_tlv->tlv, kctl->tlv.p, len))
1143 err = -EFAULT;
1144 }
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001145 __kctl_end:
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001146 up_read(&card->controls_rwsem);
1147 return err;
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001148}
1149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1151{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001152 struct snd_ctl_file *ctl;
1153 struct snd_card *card;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001154 struct snd_kctl_ioctl *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 void __user *argp = (void __user *)arg;
1156 int __user *ip = argp;
1157 int err;
1158
1159 ctl = file->private_data;
1160 card = ctl->card;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001161 if (snd_BUG_ON(!card))
1162 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 switch (cmd) {
1164 case SNDRV_CTL_IOCTL_PVERSION:
1165 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1166 case SNDRV_CTL_IOCTL_CARD_INFO:
1167 return snd_ctl_card_info(card, ctl, cmd, argp);
1168 case SNDRV_CTL_IOCTL_ELEM_LIST:
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001169 return snd_ctl_elem_list(card, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 case SNDRV_CTL_IOCTL_ELEM_INFO:
1171 return snd_ctl_elem_info_user(ctl, argp);
1172 case SNDRV_CTL_IOCTL_ELEM_READ:
Jaroslav Kysela42750b02006-06-01 18:34:01 +02001173 return snd_ctl_elem_read_user(card, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 case SNDRV_CTL_IOCTL_ELEM_WRITE:
1175 return snd_ctl_elem_write_user(ctl, argp);
1176 case SNDRV_CTL_IOCTL_ELEM_LOCK:
1177 return snd_ctl_elem_lock(ctl, argp);
1178 case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1179 return snd_ctl_elem_unlock(ctl, argp);
1180 case SNDRV_CTL_IOCTL_ELEM_ADD:
1181 return snd_ctl_elem_add_user(ctl, argp, 0);
1182 case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1183 return snd_ctl_elem_add_user(ctl, argp, 1);
1184 case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1185 return snd_ctl_elem_remove(ctl, argp);
1186 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1187 return snd_ctl_subscribe_events(ctl, ip);
Jaroslav Kysela8aa9b582006-07-05 17:34:51 +02001188 case SNDRV_CTL_IOCTL_TLV_READ:
1189 return snd_ctl_tlv_ioctl(ctl, argp, 0);
1190 case SNDRV_CTL_IOCTL_TLV_WRITE:
1191 return snd_ctl_tlv_ioctl(ctl, argp, 1);
1192 case SNDRV_CTL_IOCTL_TLV_COMMAND:
1193 return snd_ctl_tlv_ioctl(ctl, argp, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 case SNDRV_CTL_IOCTL_POWER:
Takashi Iwaia381a7a2005-11-17 15:55:49 +01001195 return -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 case SNDRV_CTL_IOCTL_POWER_STATE:
1197#ifdef CONFIG_PM
1198 return put_user(card->power_state, ip) ? -EFAULT : 0;
1199#else
1200 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1201#endif
1202 }
1203 down_read(&snd_ioctl_rwsem);
Johannes Berg9244b2c2006-10-05 16:02:22 +02001204 list_for_each_entry(p, &snd_control_ioctls, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 err = p->fioctl(card, ctl, cmd, arg);
1206 if (err != -ENOIOCTLCMD) {
1207 up_read(&snd_ioctl_rwsem);
1208 return err;
1209 }
1210 }
1211 up_read(&snd_ioctl_rwsem);
Takashi Iwai6d85be62005-05-15 14:32:50 +02001212 snd_printdd("unknown ioctl = 0x%x\n", cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 return -ENOTTY;
1214}
1215
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001216static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1217 size_t count, loff_t * offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001219 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 int err = 0;
1221 ssize_t result = 0;
1222
1223 ctl = file->private_data;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001224 if (snd_BUG_ON(!ctl || !ctl->card))
1225 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 if (!ctl->subscribed)
1227 return -EBADFD;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001228 if (count < sizeof(struct snd_ctl_event))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 return -EINVAL;
1230 spin_lock_irq(&ctl->read_lock);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001231 while (count >= sizeof(struct snd_ctl_event)) {
1232 struct snd_ctl_event ev;
1233 struct snd_kctl_event *kev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 while (list_empty(&ctl->events)) {
1235 wait_queue_t wait;
1236 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1237 err = -EAGAIN;
1238 goto __end_lock;
1239 }
1240 init_waitqueue_entry(&wait, current);
1241 add_wait_queue(&ctl->change_sleep, &wait);
1242 set_current_state(TASK_INTERRUPTIBLE);
1243 spin_unlock_irq(&ctl->read_lock);
1244 schedule();
1245 remove_wait_queue(&ctl->change_sleep, &wait);
1246 if (signal_pending(current))
Adrian Bunk0e5d7202006-11-07 13:42:54 +01001247 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 spin_lock_irq(&ctl->read_lock);
1249 }
1250 kev = snd_kctl_event(ctl->events.next);
1251 ev.type = SNDRV_CTL_EVENT_ELEM;
1252 ev.data.elem.mask = kev->mask;
1253 ev.data.elem.id = kev->id;
1254 list_del(&kev->list);
1255 spin_unlock_irq(&ctl->read_lock);
1256 kfree(kev);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001257 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 err = -EFAULT;
1259 goto __end;
1260 }
1261 spin_lock_irq(&ctl->read_lock);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001262 buffer += sizeof(struct snd_ctl_event);
1263 count -= sizeof(struct snd_ctl_event);
1264 result += sizeof(struct snd_ctl_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 }
1266 __end_lock:
1267 spin_unlock_irq(&ctl->read_lock);
1268 __end:
1269 return result > 0 ? result : err;
1270}
1271
1272static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1273{
1274 unsigned int mask;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001275 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
1277 ctl = file->private_data;
1278 if (!ctl->subscribed)
1279 return 0;
1280 poll_wait(file, &ctl->change_sleep, wait);
1281
1282 mask = 0;
1283 if (!list_empty(&ctl->events))
1284 mask |= POLLIN | POLLRDNORM;
1285
1286 return mask;
1287}
1288
1289/*
1290 * register the device-specific control-ioctls.
1291 * called from each device manager like pcm.c, hwdep.c, etc.
1292 */
1293static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
1294{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001295 struct snd_kctl_ioctl *pn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001297 pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (pn == NULL)
1299 return -ENOMEM;
1300 pn->fioctl = fcn;
1301 down_write(&snd_ioctl_rwsem);
1302 list_add_tail(&pn->list, lists);
1303 up_write(&snd_ioctl_rwsem);
1304 return 0;
1305}
1306
1307int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1308{
1309 return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
1310}
1311
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001312EXPORT_SYMBOL(snd_ctl_register_ioctl);
1313
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314#ifdef CONFIG_COMPAT
1315int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1316{
1317 return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
1318}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001319
1320EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321#endif
1322
1323/*
1324 * de-register the device-specific control-ioctls.
1325 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001326static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1327 struct list_head *lists)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001329 struct snd_kctl_ioctl *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001331 if (snd_BUG_ON(!fcn))
1332 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 down_write(&snd_ioctl_rwsem);
Johannes Berg9244b2c2006-10-05 16:02:22 +02001334 list_for_each_entry(p, lists, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 if (p->fioctl == fcn) {
1336 list_del(&p->list);
1337 up_write(&snd_ioctl_rwsem);
1338 kfree(p);
1339 return 0;
1340 }
1341 }
1342 up_write(&snd_ioctl_rwsem);
1343 snd_BUG();
1344 return -EINVAL;
1345}
1346
1347int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1348{
1349 return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
1350}
1351
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001352EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
1353
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354#ifdef CONFIG_COMPAT
1355int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1356{
1357 return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
1358}
1359
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001360EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361#endif
1362
1363static int snd_ctl_fasync(int fd, struct file * file, int on)
1364{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001365 struct snd_ctl_file *ctl;
Jonathan Corbet60aa4922009-02-01 14:52:56 -07001366
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 ctl = file->private_data;
Jonathan Corbet60aa4922009-02-01 14:52:56 -07001368 return fasync_helper(fd, file, on, &ctl->fasync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369}
1370
1371/*
1372 * ioctl32 compat
1373 */
1374#ifdef CONFIG_COMPAT
1375#include "control_compat.c"
1376#else
1377#define snd_ctl_ioctl_compat NULL
1378#endif
1379
1380/*
1381 * INIT PART
1382 */
1383
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -08001384static const struct file_operations snd_ctl_f_ops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
1386 .owner = THIS_MODULE,
1387 .read = snd_ctl_read,
1388 .open = snd_ctl_open,
1389 .release = snd_ctl_release,
1390 .poll = snd_ctl_poll,
1391 .unlocked_ioctl = snd_ctl_ioctl,
1392 .compat_ioctl = snd_ctl_ioctl_compat,
1393 .fasync = snd_ctl_fasync,
1394};
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396/*
1397 * registration of the control device
1398 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001399static int snd_ctl_dev_register(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001401 struct snd_card *card = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 int err, cardnum;
1403 char name[16];
1404
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001405 if (snd_BUG_ON(!card))
1406 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 cardnum = card->number;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001408 if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1409 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 sprintf(name, "controlC%i", cardnum);
Clemens Ladischf87135f2005-11-20 14:06:59 +01001411 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1412 &snd_ctl_f_ops, card, name)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 return err;
1414 return 0;
1415}
1416
1417/*
1418 * disconnection of the control device
1419 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001420static int snd_ctl_dev_disconnect(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001422 struct snd_card *card = device->device_data;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001423 struct snd_ctl_file *ctl;
Takashi Iwaic4614822006-06-23 14:38:23 +02001424 int err, cardnum;
1425
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001426 if (snd_BUG_ON(!card))
1427 return -ENXIO;
Takashi Iwaic4614822006-06-23 14:38:23 +02001428 cardnum = card->number;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001429 if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1430 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Takashi Iwaid8009882008-09-07 12:51:13 +02001432 read_lock(&card->ctl_files_rwlock);
Johannes Berg9244b2c2006-10-05 16:02:22 +02001433 list_for_each_entry(ctl, &card->ctl_files, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 wake_up(&ctl->change_sleep);
1435 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1436 }
Takashi Iwaid8009882008-09-07 12:51:13 +02001437 read_unlock(&card->ctl_files_rwlock);
Takashi Iwaic4614822006-06-23 14:38:23 +02001438
1439 if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
1440 card, -1)) < 0)
1441 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 return 0;
1443}
1444
1445/*
1446 * free all controls
1447 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001448static int snd_ctl_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001450 struct snd_card *card = device->device_data;
1451 struct snd_kcontrol *control;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
1453 down_write(&card->controls_rwsem);
1454 while (!list_empty(&card->controls)) {
1455 control = snd_kcontrol(card->controls.next);
1456 snd_ctl_remove(card, control);
1457 }
1458 up_write(&card->controls_rwsem);
1459 return 0;
1460}
1461
1462/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 * create control core:
1464 * called from init.c
1465 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001466int snd_ctl_create(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001468 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 .dev_free = snd_ctl_dev_free,
1470 .dev_register = snd_ctl_dev_register,
1471 .dev_disconnect = snd_ctl_dev_disconnect,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 };
1473
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001474 if (snd_BUG_ON(!card))
1475 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1477}
Takashi Iwaib9ed4f22007-07-23 15:41:34 +02001478
1479/*
1480 * Frequently used control callbacks
1481 */
1482int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
1483 struct snd_ctl_elem_info *uinfo)
1484{
1485 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1486 uinfo->count = 1;
1487 uinfo->value.integer.min = 0;
1488 uinfo->value.integer.max = 1;
1489 return 0;
1490}
1491
1492EXPORT_SYMBOL(snd_ctl_boolean_mono_info);
1493
1494int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
1495 struct snd_ctl_elem_info *uinfo)
1496{
1497 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1498 uinfo->count = 2;
1499 uinfo->value.integer.min = 0;
1500 uinfo->value.integer.max = 1;
1501 return 0;
1502}
1503
1504EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);