blob: 574745314e7045ed2c5df082dc4bccd02a788a3f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Routines for driver control interface
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
4 *
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
22#include <sound/driver.h>
23#include <linux/threads.h>
24#include <linux/interrupt.h>
25#include <linux/smp_lock.h>
26#include <linux/slab.h>
27#include <linux/vmalloc.h>
28#include <linux/time.h>
29#include <sound/core.h>
30#include <sound/minors.h>
31#include <sound/info.h>
32#include <sound/control.h>
33
34/* max number of user-defined controls */
35#define MAX_USER_CONTROLS 32
36
Takashi Iwai82e9bae2005-11-17 13:53:23 +010037struct snd_kctl_ioctl {
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 struct list_head list; /* list of all ioctls */
39 snd_kctl_ioctl_func_t fioctl;
Takashi Iwai82e9bae2005-11-17 13:53:23 +010040};
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42static DECLARE_RWSEM(snd_ioctl_rwsem);
43static LIST_HEAD(snd_control_ioctls);
44#ifdef CONFIG_COMPAT
45static LIST_HEAD(snd_control_compat_ioctls);
46#endif
47
48static int snd_ctl_open(struct inode *inode, struct file *file)
49{
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 unsigned long flags;
Takashi Iwai82e9bae2005-11-17 13:53:23 +010051 struct snd_card *card;
52 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 int err;
54
Clemens Ladischf87135f2005-11-20 14:06:59 +010055 card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 if (!card) {
57 err = -ENODEV;
58 goto __error1;
59 }
60 err = snd_card_file_add(card, file);
61 if (err < 0) {
62 err = -ENODEV;
63 goto __error1;
64 }
65 if (!try_module_get(card->module)) {
66 err = -EFAULT;
67 goto __error2;
68 }
Takashi Iwaica2c0962005-09-09 14:20:23 +020069 ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 if (ctl == NULL) {
71 err = -ENOMEM;
72 goto __error;
73 }
74 INIT_LIST_HEAD(&ctl->events);
75 init_waitqueue_head(&ctl->change_sleep);
76 spin_lock_init(&ctl->read_lock);
77 ctl->card = card;
78 ctl->pid = current->pid;
79 file->private_data = ctl;
80 write_lock_irqsave(&card->ctl_files_rwlock, flags);
81 list_add_tail(&ctl->list, &card->ctl_files);
82 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
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{
Takashi Iwai82e9bae2005-11-17 13:53:23 +010095 struct snd_kctl_event *cread;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97 spin_lock(&ctl->read_lock);
98 while (!list_empty(&ctl->events)) {
99 cread = snd_kctl_event(ctl->events.next);
100 list_del(&cread->list);
101 kfree(cread);
102 }
103 spin_unlock(&ctl->read_lock);
104}
105
106static int snd_ctl_release(struct inode *inode, struct file *file)
107{
108 unsigned long flags;
109 struct list_head *list;
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;
116 fasync_helper(-1, file, 0, &ctl->fasync);
117 file->private_data = NULL;
118 card = ctl->card;
119 write_lock_irqsave(&card->ctl_files_rwlock, flags);
120 list_del(&ctl->list);
121 write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
122 down_write(&card->controls_rwsem);
123 list_for_each(list, &card->controls) {
124 control = snd_kcontrol(list);
125 for (idx = 0; idx < control->count; idx++)
126 if (control->vd[idx].owner == ctl)
127 control->vd[idx].owner = NULL;
128 }
129 up_write(&card->controls_rwsem);
130 snd_ctl_empty_read_queue(ctl);
131 kfree(ctl);
132 module_put(card->module);
133 snd_card_file_remove(card, file);
134 return 0;
135}
136
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100137void snd_ctl_notify(struct snd_card *card, unsigned int mask,
138 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
140 unsigned long flags;
141 struct list_head *flist;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100142 struct snd_ctl_file *ctl;
143 struct snd_kctl_event *ev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200145 snd_assert(card != NULL && id != NULL, return);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 read_lock(&card->ctl_files_rwlock);
147#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
148 card->mixer_oss_change_count++;
149#endif
150 list_for_each(flist, &card->ctl_files) {
151 struct list_head *elist;
152 ctl = snd_ctl_file(flist);
153 if (!ctl->subscribed)
154 continue;
155 spin_lock_irqsave(&ctl->read_lock, flags);
156 list_for_each(elist, &ctl->events) {
157 ev = snd_kctl_event(elist);
158 if (ev->id.numid == id->numid) {
159 ev->mask |= mask;
160 goto _found;
161 }
162 }
Takashi Iwaica2c0962005-09-09 14:20:23 +0200163 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 if (ev) {
165 ev->id = *id;
166 ev->mask = mask;
167 list_add_tail(&ev->list, &ctl->events);
168 } else {
169 snd_printk(KERN_ERR "No memory available to allocate event\n");
170 }
171 _found:
172 wake_up(&ctl->change_sleep);
173 spin_unlock_irqrestore(&ctl->read_lock, flags);
174 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
175 }
176 read_unlock(&card->ctl_files_rwlock);
177}
178
179/**
180 * snd_ctl_new - create a control instance from the template
181 * @control: the control template
182 * @access: the default control access
183 *
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100184 * Allocates a new struct snd_kcontrol instance and copies the given template
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 * to the new instance. It does not copy volatile data (access).
186 *
187 * Returns the pointer of the new instance, or NULL on failure.
188 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100189struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int access)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100191 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 unsigned int idx;
193
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200194 snd_assert(control != NULL, return NULL);
195 snd_assert(control->count > 0, return NULL);
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100196 kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100197 if (kctl == NULL) {
198 snd_printk(KERN_ERR "Cannot allocate control instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 return NULL;
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100200 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 *kctl = *control;
202 for (idx = 0; idx < kctl->count; idx++)
203 kctl->vd[idx].access = access;
204 return kctl;
205}
206
207/**
208 * snd_ctl_new1 - create a control instance from the template
209 * @ncontrol: the initialization record
210 * @private_data: the private data to set
211 *
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100212 * Allocates a new struct snd_kcontrol instance and initialize from the given
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 * template. When the access field of ncontrol is 0, it's assumed as
214 * READWRITE access. When the count field is 0, it's assumes as one.
215 *
216 * Returns the pointer of the newly generated instance, or NULL on failure.
217 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100218struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
219 void *private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100221 struct snd_kcontrol kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 unsigned int access;
223
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200224 snd_assert(ncontrol != NULL, return NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 snd_assert(ncontrol->info != NULL, return NULL);
226 memset(&kctl, 0, sizeof(kctl));
227 kctl.id.iface = ncontrol->iface;
228 kctl.id.device = ncontrol->device;
229 kctl.id.subdevice = ncontrol->subdevice;
230 if (ncontrol->name)
231 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
232 kctl.id.index = ncontrol->index;
233 kctl.count = ncontrol->count ? ncontrol->count : 1;
234 access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
235 (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE|
236 SNDRV_CTL_ELEM_ACCESS_DINDIRECT|SNDRV_CTL_ELEM_ACCESS_INDIRECT));
237 kctl.info = ncontrol->info;
238 kctl.get = ncontrol->get;
239 kctl.put = ncontrol->put;
240 kctl.private_value = ncontrol->private_value;
241 kctl.private_data = private_data;
242 return snd_ctl_new(&kctl, access);
243}
244
245/**
246 * snd_ctl_free_one - release the control instance
247 * @kcontrol: the control instance
248 *
249 * Releases the control instance created via snd_ctl_new()
250 * or snd_ctl_new1().
251 * Don't call this after the control was added to the card.
252 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100253void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 if (kcontrol) {
256 if (kcontrol->private_free)
257 kcontrol->private_free(kcontrol);
258 kfree(kcontrol);
259 }
260}
261
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100262static unsigned int snd_ctl_hole_check(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 unsigned int count)
264{
265 struct list_head *list;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100266 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 list_for_each(list, &card->controls) {
269 kctl = snd_kcontrol(list);
270 if ((kctl->id.numid <= card->last_numid &&
271 kctl->id.numid + kctl->count > card->last_numid) ||
272 (kctl->id.numid <= card->last_numid + count - 1 &&
273 kctl->id.numid + kctl->count > card->last_numid + count - 1))
274 return card->last_numid = kctl->id.numid + kctl->count - 1;
275 }
276 return card->last_numid;
277}
278
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100279static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280{
281 unsigned int last_numid, iter = 100000;
282
283 last_numid = card->last_numid;
284 while (last_numid != snd_ctl_hole_check(card, count)) {
285 if (--iter == 0) {
286 /* this situation is very unlikely */
287 snd_printk(KERN_ERR "unable to allocate new control numid\n");
288 return -ENOMEM;
289 }
290 last_numid = card->last_numid;
291 }
292 return 0;
293}
294
295/**
296 * snd_ctl_add - add the control instance to the card
297 * @card: the card instance
298 * @kcontrol: the control instance to add
299 *
300 * Adds the control instance created via snd_ctl_new() or
301 * snd_ctl_new1() to the given card. Assigns also an unique
302 * numid used for fast search.
303 *
304 * Returns zero if successful, or a negative error code on failure.
305 *
306 * It frees automatically the control which cannot be added.
307 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100308int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100310 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 unsigned int idx;
Takashi Iwaic6077b32006-03-21 16:07:13 +0100312 int err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Takashi Iwai73e77ba2005-11-17 17:44:01 +0100314 if (! kcontrol)
Takashi Iwaic6077b32006-03-21 16:07:13 +0100315 return err;
316 snd_assert(card != NULL, goto error);
317 snd_assert(kcontrol->info != NULL, goto error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 id = kcontrol->id;
319 down_write(&card->controls_rwsem);
320 if (snd_ctl_find_id(card, &id)) {
321 up_write(&card->controls_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
323 id.iface,
324 id.device,
325 id.subdevice,
326 id.name,
327 id.index);
Takashi Iwaic6077b32006-03-21 16:07:13 +0100328 err = -EBUSY;
329 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
331 if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
332 up_write(&card->controls_rwsem);
Takashi Iwaic6077b32006-03-21 16:07:13 +0100333 err = -ENOMEM;
334 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
336 list_add_tail(&kcontrol->list, &card->controls);
337 card->controls_count += kcontrol->count;
338 kcontrol->id.numid = card->last_numid + 1;
339 card->last_numid += kcontrol->count;
340 up_write(&card->controls_rwsem);
341 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
342 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
343 return 0;
Takashi Iwaic6077b32006-03-21 16:07:13 +0100344
345 error:
346 snd_ctl_free_one(kcontrol);
347 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
350/**
351 * snd_ctl_remove - remove the control from the card and release it
352 * @card: the card instance
353 * @kcontrol: the control instance to remove
354 *
355 * Removes the control from the card and then releases the instance.
356 * You don't need to call snd_ctl_free_one(). You must be in
357 * the write lock - down_write(&card->controls_rwsem).
358 *
359 * Returns 0 if successful, or a negative error code on failure.
360 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100361int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100363 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 unsigned int idx;
365
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200366 snd_assert(card != NULL && kcontrol != NULL, return -EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 list_del(&kcontrol->list);
368 card->controls_count -= kcontrol->count;
369 id = kcontrol->id;
370 for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
371 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
372 snd_ctl_free_one(kcontrol);
373 return 0;
374}
375
376/**
377 * snd_ctl_remove_id - remove the control of the given id and release it
378 * @card: the card instance
379 * @id: the control id to remove
380 *
381 * Finds the control instance with the given id, removes it from the
382 * card list and releases it.
383 *
384 * Returns 0 if successful, or a negative error code on failure.
385 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100386int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100388 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 int ret;
390
391 down_write(&card->controls_rwsem);
392 kctl = snd_ctl_find_id(card, id);
393 if (kctl == NULL) {
394 up_write(&card->controls_rwsem);
395 return -ENOENT;
396 }
397 ret = snd_ctl_remove(card, kctl);
398 up_write(&card->controls_rwsem);
399 return ret;
400}
401
402/**
403 * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
404 * @file: active control handle
405 * @id: the control id to remove
406 *
407 * Finds the control instance with the given id, removes it from the
408 * card list and releases it.
409 *
410 * Returns 0 if successful, or a negative error code on failure.
411 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100412static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file,
413 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100415 struct snd_card *card = file->card;
416 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 int idx, ret;
418
419 down_write(&card->controls_rwsem);
420 kctl = snd_ctl_find_id(card, id);
421 if (kctl == NULL) {
422 up_write(&card->controls_rwsem);
423 return -ENOENT;
424 }
425 for (idx = 0; idx < kctl->count; idx++)
426 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
427 up_write(&card->controls_rwsem);
428 return -EBUSY;
429 }
430 ret = snd_ctl_remove(card, kctl);
431 up_write(&card->controls_rwsem);
432 return ret;
433}
434
435/**
436 * snd_ctl_rename_id - replace the id of a control on the card
437 * @card: the card instance
438 * @src_id: the old id
439 * @dst_id: the new id
440 *
441 * Finds the control with the old id from the card, and replaces the
442 * id with the new one.
443 *
444 * Returns zero if successful, or a negative error code on failure.
445 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100446int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
447 struct snd_ctl_elem_id *dst_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100449 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 down_write(&card->controls_rwsem);
452 kctl = snd_ctl_find_id(card, src_id);
453 if (kctl == NULL) {
454 up_write(&card->controls_rwsem);
455 return -ENOENT;
456 }
457 kctl->id = *dst_id;
458 kctl->id.numid = card->last_numid + 1;
459 card->last_numid += kctl->count;
460 up_write(&card->controls_rwsem);
461 return 0;
462}
463
464/**
465 * snd_ctl_find_numid - find the control instance with the given number-id
466 * @card: the card instance
467 * @numid: the number-id to search
468 *
469 * Finds the control instance with the given number-id from the card.
470 *
471 * Returns the pointer of the instance if found, or NULL if not.
472 *
473 * The caller must down card->controls_rwsem before calling this function
474 * (if the race condition can happen).
475 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100476struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
478 struct list_head *list;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100479 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200481 snd_assert(card != NULL && numid != 0, return NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 list_for_each(list, &card->controls) {
483 kctl = snd_kcontrol(list);
484 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
485 return kctl;
486 }
487 return NULL;
488}
489
490/**
491 * snd_ctl_find_id - find the control instance with the given id
492 * @card: the card instance
493 * @id: the id to search
494 *
495 * Finds the control instance with the given id from the card.
496 *
497 * Returns the pointer of the instance if found, or NULL if not.
498 *
499 * The caller must down card->controls_rwsem before calling this function
500 * (if the race condition can happen).
501 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100502struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
503 struct snd_ctl_elem_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
505 struct list_head *list;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100506 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200508 snd_assert(card != NULL && id != NULL, return NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (id->numid != 0)
510 return snd_ctl_find_numid(card, id->numid);
511 list_for_each(list, &card->controls) {
512 kctl = snd_kcontrol(list);
513 if (kctl->id.iface != id->iface)
514 continue;
515 if (kctl->id.device != id->device)
516 continue;
517 if (kctl->id.subdevice != id->subdevice)
518 continue;
519 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
520 continue;
521 if (kctl->id.index > id->index)
522 continue;
523 if (kctl->id.index + kctl->count <= id->index)
524 continue;
525 return kctl;
526 }
527 return NULL;
528}
529
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100530static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 unsigned int cmd, void __user *arg)
532{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100533 struct snd_ctl_card_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Takashi Iwaica2c0962005-09-09 14:20:23 +0200535 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (! info)
537 return -ENOMEM;
538 down_read(&snd_ioctl_rwsem);
539 info->card = card->number;
540 strlcpy(info->id, card->id, sizeof(info->id));
541 strlcpy(info->driver, card->driver, sizeof(info->driver));
542 strlcpy(info->name, card->shortname, sizeof(info->name));
543 strlcpy(info->longname, card->longname, sizeof(info->longname));
544 strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
545 strlcpy(info->components, card->components, sizeof(info->components));
546 up_read(&snd_ioctl_rwsem);
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100547 if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 kfree(info);
549 return -EFAULT;
550 }
551 kfree(info);
552 return 0;
553}
554
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100555static int snd_ctl_elem_list(struct snd_card *card,
556 struct snd_ctl_elem_list __user *_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
558 struct list_head *plist;
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100559 struct snd_ctl_elem_list list;
560 struct snd_kcontrol *kctl;
561 struct snd_ctl_elem_id *dst, *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 unsigned int offset, space, first, jidx;
563
564 if (copy_from_user(&list, _list, sizeof(list)))
565 return -EFAULT;
566 offset = list.offset;
567 space = list.space;
568 first = 0;
569 /* try limit maximum space */
570 if (space > 16384)
571 return -ENOMEM;
572 if (space > 0) {
573 /* allocate temporary buffer for atomic operation */
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100574 dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (dst == NULL)
576 return -ENOMEM;
577 down_read(&card->controls_rwsem);
578 list.count = card->controls_count;
579 plist = card->controls.next;
580 while (plist != &card->controls) {
581 if (offset == 0)
582 break;
583 kctl = snd_kcontrol(plist);
584 if (offset < kctl->count)
585 break;
586 offset -= kctl->count;
587 plist = plist->next;
588 }
589 list.used = 0;
590 id = dst;
591 while (space > 0 && plist != &card->controls) {
592 kctl = snd_kcontrol(plist);
593 for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
594 snd_ctl_build_ioff(id, kctl, jidx);
595 id++;
596 space--;
597 list.used++;
598 }
599 plist = plist->next;
600 offset = 0;
601 }
602 up_read(&card->controls_rwsem);
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100603 if (list.used > 0 &&
604 copy_to_user(list.pids, dst,
605 list.used * sizeof(struct snd_ctl_elem_id))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 vfree(dst);
607 return -EFAULT;
608 }
609 vfree(dst);
610 } else {
611 down_read(&card->controls_rwsem);
612 list.count = card->controls_count;
613 up_read(&card->controls_rwsem);
614 }
615 if (copy_to_user(_list, &list, sizeof(list)))
616 return -EFAULT;
617 return 0;
618}
619
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100620static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
621 struct snd_ctl_elem_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100623 struct snd_card *card = ctl->card;
624 struct snd_kcontrol *kctl;
625 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 unsigned int index_offset;
627 int result;
628
629 down_read(&card->controls_rwsem);
630 kctl = snd_ctl_find_id(card, &info->id);
631 if (kctl == NULL) {
632 up_read(&card->controls_rwsem);
633 return -ENOENT;
634 }
635#ifdef CONFIG_SND_DEBUG
636 info->access = 0;
637#endif
638 result = kctl->info(kctl, info);
639 if (result >= 0) {
640 snd_assert(info->access == 0, );
641 index_offset = snd_ctl_get_ioff(kctl, &info->id);
642 vd = &kctl->vd[index_offset];
643 snd_ctl_build_ioff(&info->id, kctl, index_offset);
644 info->access = vd->access;
645 if (vd->owner) {
646 info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
647 if (vd->owner == ctl)
648 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
649 info->owner = vd->owner_pid;
650 } else {
651 info->owner = -1;
652 }
653 }
654 up_read(&card->controls_rwsem);
655 return result;
656}
657
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100658static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
659 struct snd_ctl_elem_info __user *_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100661 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 int result;
663
664 if (copy_from_user(&info, _info, sizeof(info)))
665 return -EFAULT;
Giuliano Pochini64649402006-03-13 14:11:11 +0100666 snd_power_lock(ctl->card);
667 result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0, NULL);
668 if (result >= 0)
669 result = snd_ctl_elem_info(ctl, &info);
670 snd_power_unlock(ctl->card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 if (result >= 0)
672 if (copy_to_user(_info, &info, sizeof(info)))
673 return -EFAULT;
674 return result;
675}
676
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100677int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100679 struct snd_kcontrol *kctl;
680 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 unsigned int index_offset;
682 int result, indirect;
683
684 down_read(&card->controls_rwsem);
685 kctl = snd_ctl_find_id(card, &control->id);
686 if (kctl == NULL) {
687 result = -ENOENT;
688 } else {
689 index_offset = snd_ctl_get_ioff(kctl, &control->id);
690 vd = &kctl->vd[index_offset];
691 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
692 if (control->indirect != indirect) {
693 result = -EACCES;
694 } else {
695 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) && kctl->get != NULL) {
696 snd_ctl_build_ioff(&control->id, kctl, index_offset);
697 result = kctl->get(kctl, control);
698 } else {
699 result = -EPERM;
700 }
701 }
702 }
703 up_read(&card->controls_rwsem);
704 return result;
705}
706
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100707static int snd_ctl_elem_read_user(struct snd_card *card,
708 struct snd_ctl_elem_value __user *_control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100710 struct snd_ctl_elem_value *control;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 int result;
712
713 control = kmalloc(sizeof(*control), GFP_KERNEL);
714 if (control == NULL)
715 return -ENOMEM;
716 if (copy_from_user(control, _control, sizeof(*control))) {
717 kfree(control);
718 return -EFAULT;
719 }
Giuliano Pochini64649402006-03-13 14:11:11 +0100720 snd_power_lock(card);
721 result = snd_power_wait(card, SNDRV_CTL_POWER_D0, NULL);
722 if (result >= 0)
723 result = snd_ctl_elem_read(card, control);
724 snd_power_unlock(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (result >= 0)
726 if (copy_to_user(_control, control, sizeof(*control)))
727 result = -EFAULT;
728 kfree(control);
729 return result;
730}
731
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100732int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
733 struct snd_ctl_elem_value *control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100735 struct snd_kcontrol *kctl;
736 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 unsigned int index_offset;
738 int result, indirect;
739
740 down_read(&card->controls_rwsem);
741 kctl = snd_ctl_find_id(card, &control->id);
742 if (kctl == NULL) {
743 result = -ENOENT;
744 } else {
745 index_offset = snd_ctl_get_ioff(kctl, &control->id);
746 vd = &kctl->vd[index_offset];
747 indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
748 if (control->indirect != indirect) {
749 result = -EACCES;
750 } else {
751 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
752 kctl->put == NULL ||
753 (file && vd->owner != NULL && vd->owner != file)) {
754 result = -EPERM;
755 } else {
756 snd_ctl_build_ioff(&control->id, kctl, index_offset);
757 result = kctl->put(kctl, control);
758 }
759 if (result > 0) {
760 up_read(&card->controls_rwsem);
761 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
762 return 0;
763 }
764 }
765 }
766 up_read(&card->controls_rwsem);
767 return result;
768}
769
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100770static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
771 struct snd_ctl_elem_value __user *_control)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100773 struct snd_ctl_elem_value *control;
Giuliano Pochini64649402006-03-13 14:11:11 +0100774 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 int result;
776
777 control = kmalloc(sizeof(*control), GFP_KERNEL);
778 if (control == NULL)
779 return -ENOMEM;
780 if (copy_from_user(control, _control, sizeof(*control))) {
781 kfree(control);
782 return -EFAULT;
783 }
Giuliano Pochini64649402006-03-13 14:11:11 +0100784 card = file->card;
785 snd_power_lock(card);
786 result = snd_power_wait(card, SNDRV_CTL_POWER_D0, NULL);
787 if (result >= 0)
788 result = snd_ctl_elem_write(card, file, control);
789 snd_power_unlock(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 if (result >= 0)
791 if (copy_to_user(_control, control, sizeof(*control)))
792 result = -EFAULT;
793 kfree(control);
794 return result;
795}
796
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100797static int snd_ctl_elem_lock(struct snd_ctl_file *file,
798 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100800 struct snd_card *card = file->card;
801 struct snd_ctl_elem_id id;
802 struct snd_kcontrol *kctl;
803 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 int result;
805
806 if (copy_from_user(&id, _id, sizeof(id)))
807 return -EFAULT;
808 down_write(&card->controls_rwsem);
809 kctl = snd_ctl_find_id(card, &id);
810 if (kctl == NULL) {
811 result = -ENOENT;
812 } else {
813 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
814 if (vd->owner != NULL)
815 result = -EBUSY;
816 else {
817 vd->owner = file;
818 vd->owner_pid = current->pid;
819 result = 0;
820 }
821 }
822 up_write(&card->controls_rwsem);
823 return result;
824}
825
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100826static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
827 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100829 struct snd_card *card = file->card;
830 struct snd_ctl_elem_id id;
831 struct snd_kcontrol *kctl;
832 struct snd_kcontrol_volatile *vd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 int result;
834
835 if (copy_from_user(&id, _id, sizeof(id)))
836 return -EFAULT;
837 down_write(&card->controls_rwsem);
838 kctl = snd_ctl_find_id(card, &id);
839 if (kctl == NULL) {
840 result = -ENOENT;
841 } else {
842 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
843 if (vd->owner == NULL)
844 result = -EINVAL;
845 else if (vd->owner != file)
846 result = -EPERM;
847 else {
848 vd->owner = NULL;
849 vd->owner_pid = 0;
850 result = 0;
851 }
852 }
853 up_write(&card->controls_rwsem);
854 return result;
855}
856
857struct user_element {
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100858 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 void *elem_data; /* element data */
860 unsigned long elem_data_size; /* size of element data in bytes */
861 void *priv_data; /* private data (like strings for enumerated type) */
862 unsigned long priv_data_size; /* size of private data in bytes */
863};
864
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100865static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
866 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
868 struct user_element *ue = kcontrol->private_data;
869
870 *uinfo = ue->info;
871 return 0;
872}
873
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100874static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
875 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
877 struct user_element *ue = kcontrol->private_data;
878
879 memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
880 return 0;
881}
882
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100883static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
884 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
886 int change;
887 struct user_element *ue = kcontrol->private_data;
888
889 change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
890 if (change)
891 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
892 return change;
893}
894
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100895static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
897 kfree(kcontrol->private_data);
898}
899
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100900static int snd_ctl_elem_add(struct snd_ctl_file *file,
901 struct snd_ctl_elem_info *info, int replace)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902{
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100903 struct snd_card *card = file->card;
904 struct snd_kcontrol kctl, *_kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 unsigned int access;
906 long private_size;
907 struct user_element *ue;
908 int idx, err;
909
910 if (card->user_ctl_count >= MAX_USER_CONTROLS)
911 return -ENOMEM;
912 if (info->count > 1024)
913 return -EINVAL;
914 access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100915 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
916 SNDRV_CTL_ELEM_ACCESS_INACTIVE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 info->id.numid = 0;
918 memset(&kctl, 0, sizeof(kctl));
919 down_write(&card->controls_rwsem);
920 _kctl = snd_ctl_find_id(card, &info->id);
921 err = 0;
922 if (_kctl) {
923 if (replace)
924 err = snd_ctl_remove(card, _kctl);
925 else
926 err = -EBUSY;
927 } else {
928 if (replace)
929 err = -ENOENT;
930 }
931 up_write(&card->controls_rwsem);
932 if (err < 0)
933 return err;
934 memcpy(&kctl.id, &info->id, sizeof(info->id));
935 kctl.count = info->owner ? info->owner : 1;
936 access |= SNDRV_CTL_ELEM_ACCESS_USER;
937 kctl.info = snd_ctl_elem_user_info;
938 if (access & SNDRV_CTL_ELEM_ACCESS_READ)
939 kctl.get = snd_ctl_elem_user_get;
940 if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
941 kctl.put = snd_ctl_elem_user_put;
942 switch (info->type) {
943 case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
944 private_size = sizeof(char);
945 if (info->count > 128)
946 return -EINVAL;
947 break;
948 case SNDRV_CTL_ELEM_TYPE_INTEGER:
949 private_size = sizeof(long);
950 if (info->count > 128)
951 return -EINVAL;
952 break;
953 case SNDRV_CTL_ELEM_TYPE_INTEGER64:
954 private_size = sizeof(long long);
955 if (info->count > 64)
956 return -EINVAL;
957 break;
958 case SNDRV_CTL_ELEM_TYPE_BYTES:
959 private_size = sizeof(unsigned char);
960 if (info->count > 512)
961 return -EINVAL;
962 break;
963 case SNDRV_CTL_ELEM_TYPE_IEC958:
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100964 private_size = sizeof(struct snd_aes_iec958);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (info->count != 1)
966 return -EINVAL;
967 break;
968 default:
969 return -EINVAL;
970 }
971 private_size *= info->count;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200972 ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (ue == NULL)
974 return -ENOMEM;
975 ue->info = *info;
976 ue->elem_data = (char *)ue + sizeof(*ue);
977 ue->elem_data_size = private_size;
978 kctl.private_free = snd_ctl_elem_user_free;
979 _kctl = snd_ctl_new(&kctl, access);
980 if (_kctl == NULL) {
Takashi Iwai2fbf1822006-03-06 15:42:51 -0800981 kfree(ue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 return -ENOMEM;
983 }
984 _kctl->private_data = ue;
985 for (idx = 0; idx < _kctl->count; idx++)
986 _kctl->vd[idx].owner = file;
987 err = snd_ctl_add(card, _kctl);
Takashi Iwai2fbf1822006-03-06 15:42:51 -0800988 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 down_write(&card->controls_rwsem);
992 card->user_ctl_count++;
993 up_write(&card->controls_rwsem);
994
995 return 0;
996}
997
Takashi Iwai82e9bae2005-11-17 13:53:23 +0100998static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
999 struct snd_ctl_elem_info __user *_info, int replace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001001 struct snd_ctl_elem_info info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 if (copy_from_user(&info, _info, sizeof(info)))
1003 return -EFAULT;
1004 return snd_ctl_elem_add(file, &info, replace);
1005}
1006
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001007static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1008 struct snd_ctl_elem_id __user *_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001010 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 int err;
1012
1013 if (copy_from_user(&id, _id, sizeof(id)))
1014 return -EFAULT;
1015 err = snd_ctl_remove_unlocked_id(file, &id);
1016 if (! err) {
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001017 struct snd_card *card = file->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 down_write(&card->controls_rwsem);
1019 card->user_ctl_count--;
1020 up_write(&card->controls_rwsem);
1021 }
1022 return err;
1023}
1024
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001025static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026{
1027 int subscribe;
1028 if (get_user(subscribe, ptr))
1029 return -EFAULT;
1030 if (subscribe < 0) {
1031 subscribe = file->subscribed;
1032 if (put_user(subscribe, ptr))
1033 return -EFAULT;
1034 return 0;
1035 }
1036 if (subscribe) {
1037 file->subscribed = 1;
1038 return 0;
1039 } else if (file->subscribed) {
1040 snd_ctl_empty_read_queue(file);
1041 file->subscribed = 0;
1042 }
1043 return 0;
1044}
1045
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1047{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001048 struct snd_ctl_file *ctl;
1049 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 struct list_head *list;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001051 struct snd_kctl_ioctl *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 void __user *argp = (void __user *)arg;
1053 int __user *ip = argp;
1054 int err;
1055
1056 ctl = file->private_data;
1057 card = ctl->card;
1058 snd_assert(card != NULL, return -ENXIO);
1059 switch (cmd) {
1060 case SNDRV_CTL_IOCTL_PVERSION:
1061 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1062 case SNDRV_CTL_IOCTL_CARD_INFO:
1063 return snd_ctl_card_info(card, ctl, cmd, argp);
1064 case SNDRV_CTL_IOCTL_ELEM_LIST:
1065 return snd_ctl_elem_list(ctl->card, argp);
1066 case SNDRV_CTL_IOCTL_ELEM_INFO:
1067 return snd_ctl_elem_info_user(ctl, argp);
1068 case SNDRV_CTL_IOCTL_ELEM_READ:
1069 return snd_ctl_elem_read_user(ctl->card, argp);
1070 case SNDRV_CTL_IOCTL_ELEM_WRITE:
1071 return snd_ctl_elem_write_user(ctl, argp);
1072 case SNDRV_CTL_IOCTL_ELEM_LOCK:
1073 return snd_ctl_elem_lock(ctl, argp);
1074 case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1075 return snd_ctl_elem_unlock(ctl, argp);
1076 case SNDRV_CTL_IOCTL_ELEM_ADD:
1077 return snd_ctl_elem_add_user(ctl, argp, 0);
1078 case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1079 return snd_ctl_elem_add_user(ctl, argp, 1);
1080 case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1081 return snd_ctl_elem_remove(ctl, argp);
1082 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1083 return snd_ctl_subscribe_events(ctl, ip);
1084 case SNDRV_CTL_IOCTL_POWER:
Takashi Iwaia381a7a2005-11-17 15:55:49 +01001085 return -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 case SNDRV_CTL_IOCTL_POWER_STATE:
1087#ifdef CONFIG_PM
1088 return put_user(card->power_state, ip) ? -EFAULT : 0;
1089#else
1090 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1091#endif
1092 }
1093 down_read(&snd_ioctl_rwsem);
1094 list_for_each(list, &snd_control_ioctls) {
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001095 p = list_entry(list, struct snd_kctl_ioctl, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 err = p->fioctl(card, ctl, cmd, arg);
1097 if (err != -ENOIOCTLCMD) {
1098 up_read(&snd_ioctl_rwsem);
1099 return err;
1100 }
1101 }
1102 up_read(&snd_ioctl_rwsem);
Takashi Iwai6d85be62005-05-15 14:32:50 +02001103 snd_printdd("unknown ioctl = 0x%x\n", cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 return -ENOTTY;
1105}
1106
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001107static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1108 size_t count, loff_t * offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001110 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 int err = 0;
1112 ssize_t result = 0;
1113
1114 ctl = file->private_data;
1115 snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO);
1116 if (!ctl->subscribed)
1117 return -EBADFD;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001118 if (count < sizeof(struct snd_ctl_event))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 return -EINVAL;
1120 spin_lock_irq(&ctl->read_lock);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001121 while (count >= sizeof(struct snd_ctl_event)) {
1122 struct snd_ctl_event ev;
1123 struct snd_kctl_event *kev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 while (list_empty(&ctl->events)) {
1125 wait_queue_t wait;
1126 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1127 err = -EAGAIN;
1128 goto __end_lock;
1129 }
1130 init_waitqueue_entry(&wait, current);
1131 add_wait_queue(&ctl->change_sleep, &wait);
1132 set_current_state(TASK_INTERRUPTIBLE);
1133 spin_unlock_irq(&ctl->read_lock);
1134 schedule();
1135 remove_wait_queue(&ctl->change_sleep, &wait);
1136 if (signal_pending(current))
1137 return result > 0 ? result : -ERESTARTSYS;
1138 spin_lock_irq(&ctl->read_lock);
1139 }
1140 kev = snd_kctl_event(ctl->events.next);
1141 ev.type = SNDRV_CTL_EVENT_ELEM;
1142 ev.data.elem.mask = kev->mask;
1143 ev.data.elem.id = kev->id;
1144 list_del(&kev->list);
1145 spin_unlock_irq(&ctl->read_lock);
1146 kfree(kev);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001147 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 err = -EFAULT;
1149 goto __end;
1150 }
1151 spin_lock_irq(&ctl->read_lock);
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001152 buffer += sizeof(struct snd_ctl_event);
1153 count -= sizeof(struct snd_ctl_event);
1154 result += sizeof(struct snd_ctl_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 }
1156 __end_lock:
1157 spin_unlock_irq(&ctl->read_lock);
1158 __end:
1159 return result > 0 ? result : err;
1160}
1161
1162static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1163{
1164 unsigned int mask;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001165 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 ctl = file->private_data;
1168 if (!ctl->subscribed)
1169 return 0;
1170 poll_wait(file, &ctl->change_sleep, wait);
1171
1172 mask = 0;
1173 if (!list_empty(&ctl->events))
1174 mask |= POLLIN | POLLRDNORM;
1175
1176 return mask;
1177}
1178
1179/*
1180 * register the device-specific control-ioctls.
1181 * called from each device manager like pcm.c, hwdep.c, etc.
1182 */
1183static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
1184{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001185 struct snd_kctl_ioctl *pn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001187 pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 if (pn == NULL)
1189 return -ENOMEM;
1190 pn->fioctl = fcn;
1191 down_write(&snd_ioctl_rwsem);
1192 list_add_tail(&pn->list, lists);
1193 up_write(&snd_ioctl_rwsem);
1194 return 0;
1195}
1196
1197int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1198{
1199 return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
1200}
1201
1202#ifdef CONFIG_COMPAT
1203int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1204{
1205 return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
1206}
1207#endif
1208
1209/*
1210 * de-register the device-specific control-ioctls.
1211 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001212static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1213 struct list_head *lists)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214{
1215 struct list_head *list;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001216 struct snd_kctl_ioctl *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
Takashi Iwai7c22f1a2005-10-10 11:46:31 +02001218 snd_assert(fcn != NULL, return -EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 down_write(&snd_ioctl_rwsem);
1220 list_for_each(list, lists) {
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001221 p = list_entry(list, struct snd_kctl_ioctl, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 if (p->fioctl == fcn) {
1223 list_del(&p->list);
1224 up_write(&snd_ioctl_rwsem);
1225 kfree(p);
1226 return 0;
1227 }
1228 }
1229 up_write(&snd_ioctl_rwsem);
1230 snd_BUG();
1231 return -EINVAL;
1232}
1233
1234int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1235{
1236 return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
1237}
1238
1239#ifdef CONFIG_COMPAT
1240int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1241{
1242 return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
1243}
1244
1245#endif
1246
1247static int snd_ctl_fasync(int fd, struct file * file, int on)
1248{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001249 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 int err;
1251 ctl = file->private_data;
1252 err = fasync_helper(fd, file, on, &ctl->fasync);
1253 if (err < 0)
1254 return err;
1255 return 0;
1256}
1257
1258/*
1259 * ioctl32 compat
1260 */
1261#ifdef CONFIG_COMPAT
1262#include "control_compat.c"
1263#else
1264#define snd_ctl_ioctl_compat NULL
1265#endif
1266
1267/*
1268 * INIT PART
1269 */
1270
1271static struct file_operations snd_ctl_f_ops =
1272{
1273 .owner = THIS_MODULE,
1274 .read = snd_ctl_read,
1275 .open = snd_ctl_open,
1276 .release = snd_ctl_release,
1277 .poll = snd_ctl_poll,
1278 .unlocked_ioctl = snd_ctl_ioctl,
1279 .compat_ioctl = snd_ctl_ioctl_compat,
1280 .fasync = snd_ctl_fasync,
1281};
1282
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283/*
1284 * registration of the control device
1285 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001286static int snd_ctl_dev_register(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001288 struct snd_card *card = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 int err, cardnum;
1290 char name[16];
1291
1292 snd_assert(card != NULL, return -ENXIO);
1293 cardnum = card->number;
1294 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
1295 sprintf(name, "controlC%i", cardnum);
Clemens Ladischf87135f2005-11-20 14:06:59 +01001296 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1297 &snd_ctl_f_ops, card, name)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 return err;
1299 return 0;
1300}
1301
1302/*
1303 * disconnection of the control device
1304 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001305static int snd_ctl_dev_disconnect(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001307 struct snd_card *card = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 struct list_head *flist;
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001309 struct snd_ctl_file *ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
1311 down_read(&card->controls_rwsem);
1312 list_for_each(flist, &card->ctl_files) {
1313 ctl = snd_ctl_file(flist);
1314 wake_up(&ctl->change_sleep);
1315 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1316 }
1317 up_read(&card->controls_rwsem);
1318 return 0;
1319}
1320
1321/*
1322 * free all controls
1323 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001324static int snd_ctl_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001326 struct snd_card *card = device->device_data;
1327 struct snd_kcontrol *control;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
1329 down_write(&card->controls_rwsem);
1330 while (!list_empty(&card->controls)) {
1331 control = snd_kcontrol(card->controls.next);
1332 snd_ctl_remove(card, control);
1333 }
1334 up_write(&card->controls_rwsem);
1335 return 0;
1336}
1337
1338/*
1339 * de-registration of the control device
1340 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001341static int snd_ctl_dev_unregister(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001343 struct snd_card *card = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 int err, cardnum;
1345
1346 snd_assert(card != NULL, return -ENXIO);
1347 cardnum = card->number;
1348 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
Clemens Ladisch2af677f2005-11-20 14:03:48 +01001349 if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
1350 card, -1)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return err;
1352 return snd_ctl_dev_free(device);
1353}
1354
1355/*
1356 * create control core:
1357 * called from init.c
1358 */
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001359int snd_ctl_create(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360{
Takashi Iwai82e9bae2005-11-17 13:53:23 +01001361 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 .dev_free = snd_ctl_dev_free,
1363 .dev_register = snd_ctl_dev_register,
1364 .dev_disconnect = snd_ctl_dev_disconnect,
1365 .dev_unregister = snd_ctl_dev_unregister
1366 };
1367
1368 snd_assert(card != NULL, return -ENXIO);
1369 return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1370}