~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/core/control.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  Routines for driver control interface
  3  *  Copyright (c) by Jaroslav Kysela <perex@perex.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 <linux/threads.h>
 23 #include <linux/interrupt.h>
 24 #include <linux/module.h>
 25 #include <linux/slab.h>
 26 #include <linux/vmalloc.h>
 27 #include <linux/time.h>
 28 #include <sound/core.h>
 29 #include <sound/minors.h>
 30 #include <sound/info.h>
 31 #include <sound/control.h>
 32 
 33 /* max number of user-defined controls */
 34 #define MAX_USER_CONTROLS       32
 35 #define MAX_CONTROL_COUNT       1028
 36 
 37 struct snd_kctl_ioctl {
 38         struct list_head list;          /* list of all ioctls */
 39         snd_kctl_ioctl_func_t fioctl;
 40 };
 41 
 42 static DECLARE_RWSEM(snd_ioctl_rwsem);
 43 static LIST_HEAD(snd_control_ioctls);
 44 #ifdef CONFIG_COMPAT
 45 static LIST_HEAD(snd_control_compat_ioctls);
 46 #endif
 47 
 48 static int snd_ctl_open(struct inode *inode, struct file *file)
 49 {
 50         unsigned long flags;
 51         struct snd_card *card;
 52         struct snd_ctl_file *ctl;
 53         int err;
 54 
 55         err = nonseekable_open(inode, file);
 56         if (err < 0)
 57                 return err;
 58 
 59         card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
 60         if (!card) {
 61                 err = -ENODEV;
 62                 goto __error1;
 63         }
 64         err = snd_card_file_add(card, file);
 65         if (err < 0) {
 66                 err = -ENODEV;
 67                 goto __error1;
 68         }
 69         if (!try_module_get(card->module)) {
 70                 err = -EFAULT;
 71                 goto __error2;
 72         }
 73         ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
 74         if (ctl == NULL) {
 75                 err = -ENOMEM;
 76                 goto __error;
 77         }
 78         INIT_LIST_HEAD(&ctl->events);
 79         init_waitqueue_head(&ctl->change_sleep);
 80         spin_lock_init(&ctl->read_lock);
 81         ctl->card = card;
 82         ctl->prefer_pcm_subdevice = -1;
 83         ctl->prefer_rawmidi_subdevice = -1;
 84         ctl->pid = get_pid(task_pid(current));
 85         file->private_data = ctl;
 86         write_lock_irqsave(&card->ctl_files_rwlock, flags);
 87         list_add_tail(&ctl->list, &card->ctl_files);
 88         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 89         return 0;
 90 
 91       __error:
 92         module_put(card->module);
 93       __error2:
 94         snd_card_file_remove(card, file);
 95       __error1:
 96         return err;
 97 }
 98 
 99 static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
100 {
101         unsigned long flags;
102         struct snd_kctl_event *cread;
103         
104         spin_lock_irqsave(&ctl->read_lock, flags);
105         while (!list_empty(&ctl->events)) {
106                 cread = snd_kctl_event(ctl->events.next);
107                 list_del(&cread->list);
108                 kfree(cread);
109         }
110         spin_unlock_irqrestore(&ctl->read_lock, flags);
111 }
112 
113 static int snd_ctl_release(struct inode *inode, struct file *file)
114 {
115         unsigned long flags;
116         struct snd_card *card;
117         struct snd_ctl_file *ctl;
118         struct snd_kcontrol *control;
119         unsigned int idx;
120 
121         ctl = file->private_data;
122         file->private_data = NULL;
123         card = ctl->card;
124         write_lock_irqsave(&card->ctl_files_rwlock, flags);
125         list_del(&ctl->list);
126         write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
127         down_write(&card->controls_rwsem);
128         list_for_each_entry(control, &card->controls, list)
129                 for (idx = 0; idx < control->count; idx++)
130                         if (control->vd[idx].owner == ctl)
131                                 control->vd[idx].owner = NULL;
132         up_write(&card->controls_rwsem);
133         snd_ctl_empty_read_queue(ctl);
134         put_pid(ctl->pid);
135         kfree(ctl);
136         module_put(card->module);
137         snd_card_file_remove(card, file);
138         return 0;
139 }
140 
141 void snd_ctl_notify(struct snd_card *card, unsigned int mask,
142                     struct snd_ctl_elem_id *id)
143 {
144         unsigned long flags;
145         struct snd_ctl_file *ctl;
146         struct snd_kctl_event *ev;
147         
148         if (snd_BUG_ON(!card || !id))
149                 return;
150         read_lock(&card->ctl_files_rwlock);
151 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
152         card->mixer_oss_change_count++;
153 #endif
154         list_for_each_entry(ctl, &card->ctl_files, list) {
155                 if (!ctl->subscribed)
156                         continue;
157                 spin_lock_irqsave(&ctl->read_lock, flags);
158                 list_for_each_entry(ev, &ctl->events, list) {
159                         if (ev->id.numid == id->numid) {
160                                 ev->mask |= mask;
161                                 goto _found;
162                         }
163                 }
164                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
165                 if (ev) {
166                         ev->id = *id;
167                         ev->mask = mask;
168                         list_add_tail(&ev->list, &ctl->events);
169                 } else {
170                         snd_printk(KERN_ERR "No memory available to allocate event\n");
171                 }
172         _found:
173                 wake_up(&ctl->change_sleep);
174                 spin_unlock_irqrestore(&ctl->read_lock, flags);
175                 kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
176         }
177         read_unlock(&card->ctl_files_rwlock);
178 }
179 
180 EXPORT_SYMBOL(snd_ctl_notify);
181 
182 /**
183  * snd_ctl_new - create a control instance from the template
184  * @control: the control template
185  * @access: the default control access
186  *
187  * Allocates a new struct snd_kcontrol instance and copies the given template 
188  * to the new instance. It does not copy volatile data (access).
189  *
190  * Returns the pointer of the new instance, or NULL on failure.
191  */
192 static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
193                                         unsigned int access)
194 {
195         struct snd_kcontrol *kctl;
196         unsigned int idx;
197         
198         if (snd_BUG_ON(!control || !control->count))
199                 return NULL;
200 
201         if (control->count > MAX_CONTROL_COUNT)
202                 return NULL;
203 
204         kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
205         if (kctl == NULL) {
206                 snd_printk(KERN_ERR "Cannot allocate control instance\n");
207                 return NULL;
208         }
209         *kctl = *control;
210         for (idx = 0; idx < kctl->count; idx++)
211                 kctl->vd[idx].access = access;
212         return kctl;
213 }
214 
215 /**
216  * snd_ctl_new1 - create a control instance from the template
217  * @ncontrol: the initialization record
218  * @private_data: the private data to set
219  *
220  * Allocates a new struct snd_kcontrol instance and initialize from the given 
221  * template.  When the access field of ncontrol is 0, it's assumed as
222  * READWRITE access. When the count field is 0, it's assumes as one.
223  *
224  * Returns the pointer of the newly generated instance, or NULL on failure.
225  */
226 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
227                                   void *private_data)
228 {
229         struct snd_kcontrol kctl;
230         unsigned int access;
231         
232         if (snd_BUG_ON(!ncontrol || !ncontrol->info))
233                 return NULL;
234         memset(&kctl, 0, sizeof(kctl));
235         kctl.id.iface = ncontrol->iface;
236         kctl.id.device = ncontrol->device;
237         kctl.id.subdevice = ncontrol->subdevice;
238         if (ncontrol->name) {
239                 strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
240                 if (strcmp(ncontrol->name, kctl.id.name) != 0)
241                         snd_printk(KERN_WARNING
242                                    "Control name '%s' truncated to '%s'\n",
243                                    ncontrol->name, kctl.id.name);
244         }
245         kctl.id.index = ncontrol->index;
246         kctl.count = ncontrol->count ? ncontrol->count : 1;
247         access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
248                  (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
249                                       SNDRV_CTL_ELEM_ACCESS_INACTIVE|
250                                       SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
251                                       SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND|
252                                       SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
253         kctl.info = ncontrol->info;
254         kctl.get = ncontrol->get;
255         kctl.put = ncontrol->put;
256         kctl.tlv.p = ncontrol->tlv.p;
257         kctl.private_value = ncontrol->private_value;
258         kctl.private_data = private_data;
259         return snd_ctl_new(&kctl, access);
260 }
261 
262 EXPORT_SYMBOL(snd_ctl_new1);
263 
264 /**
265  * snd_ctl_free_one - release the control instance
266  * @kcontrol: the control instance
267  *
268  * Releases the control instance created via snd_ctl_new()
269  * or snd_ctl_new1().
270  * Don't call this after the control was added to the card.
271  */
272 void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
273 {
274         if (kcontrol) {
275                 if (kcontrol->private_free)
276                         kcontrol->private_free(kcontrol);
277                 kfree(kcontrol);
278         }
279 }
280 
281 EXPORT_SYMBOL(snd_ctl_free_one);
282 
283 static bool snd_ctl_remove_numid_conflict(struct snd_card *card,
284                                           unsigned int count)
285 {
286         struct snd_kcontrol *kctl;
287 
288         list_for_each_entry(kctl, &card->controls, list) {
289                 if (kctl->id.numid < card->last_numid + 1 + count &&
290                     kctl->id.numid + kctl->count > card->last_numid + 1) {
291                         card->last_numid = kctl->id.numid + kctl->count - 1;
292                         return true;
293                 }
294         }
295         return false;
296 }
297 
298 static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
299 {
300         unsigned int iter = 100000;
301 
302         while (snd_ctl_remove_numid_conflict(card, count)) {
303                 if (--iter == 0) {
304                         /* this situation is very unlikely */
305                         snd_printk(KERN_ERR "unable to allocate new control numid\n");
306                         return -ENOMEM;
307                 }
308         }
309         return 0;
310 }
311 
312 /**
313  * snd_ctl_add - add the control instance to the card
314  * @card: the card instance
315  * @kcontrol: the control instance to add
316  *
317  * Adds the control instance created via snd_ctl_new() or
318  * snd_ctl_new1() to the given card. Assigns also an unique
319  * numid used for fast search.
320  *
321  * Returns zero if successful, or a negative error code on failure.
322  *
323  * It frees automatically the control which cannot be added.
324  */
325 int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
326 {
327         struct snd_ctl_elem_id id;
328         unsigned int idx;
329         int err = -EINVAL;
330 
331         if (! kcontrol)
332                 return err;
333         if (snd_BUG_ON(!card || !kcontrol->info))
334                 goto error;
335         id = kcontrol->id;
336         down_write(&card->controls_rwsem);
337         if (snd_ctl_find_id(card, &id)) {
338                 up_write(&card->controls_rwsem);
339                 snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
340                                         id.iface,
341                                         id.device,
342                                         id.subdevice,
343                                         id.name,
344                                         id.index);
345                 err = -EBUSY;
346                 goto error;
347         }
348         if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
349                 up_write(&card->controls_rwsem);
350                 err = -ENOMEM;
351                 goto error;
352         }
353         list_add_tail(&kcontrol->list, &card->controls);
354         card->controls_count += kcontrol->count;
355         kcontrol->id.numid = card->last_numid + 1;
356         card->last_numid += kcontrol->count;
357         up_write(&card->controls_rwsem);
358         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
359                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
360         return 0;
361 
362  error:
363         snd_ctl_free_one(kcontrol);
364         return err;
365 }
366 
367 EXPORT_SYMBOL(snd_ctl_add);
368 
369 /**
370  * snd_ctl_replace - replace the control instance of the card
371  * @card: the card instance
372  * @kcontrol: the control instance to replace
373  * @add_on_replace: add the control if not already added
374  *
375  * Replaces the given control.  If the given control does not exist
376  * and the add_on_replace flag is set, the control is added.  If the
377  * control exists, it is destroyed first.
378  *
379  * Returns zero if successful, or a negative error code on failure.
380  *
381  * It frees automatically the control which cannot be added or replaced.
382  */
383 int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol,
384                     bool add_on_replace)
385 {
386         struct snd_ctl_elem_id id;
387         unsigned int idx;
388         struct snd_kcontrol *old;
389         int ret;
390 
391         if (!kcontrol)
392                 return -EINVAL;
393         if (snd_BUG_ON(!card || !kcontrol->info)) {
394                 ret = -EINVAL;
395                 goto error;
396         }
397         id = kcontrol->id;
398         down_write(&card->controls_rwsem);
399         old = snd_ctl_find_id(card, &id);
400         if (!old) {
401                 if (add_on_replace)
402                         goto add;
403                 up_write(&card->controls_rwsem);
404                 ret = -EINVAL;
405                 goto error;
406         }
407         ret = snd_ctl_remove(card, old);
408         if (ret < 0) {
409                 up_write(&card->controls_rwsem);
410                 goto error;
411         }
412 add:
413         if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
414                 up_write(&card->controls_rwsem);
415                 ret = -ENOMEM;
416                 goto error;
417         }
418         list_add_tail(&kcontrol->list, &card->controls);
419         card->controls_count += kcontrol->count;
420         kcontrol->id.numid = card->last_numid + 1;
421         card->last_numid += kcontrol->count;
422         up_write(&card->controls_rwsem);
423         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
424                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
425         return 0;
426 
427 error:
428         snd_ctl_free_one(kcontrol);
429         return ret;
430 }
431 EXPORT_SYMBOL(snd_ctl_replace);
432 
433 /**
434  * snd_ctl_remove - remove the control from the card and release it
435  * @card: the card instance
436  * @kcontrol: the control instance to remove
437  *
438  * Removes the control from the card and then releases the instance.
439  * You don't need to call snd_ctl_free_one(). You must be in
440  * the write lock - down_write(&card->controls_rwsem).
441  * 
442  * Returns 0 if successful, or a negative error code on failure.
443  */
444 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
445 {
446         struct snd_ctl_elem_id id;
447         unsigned int idx;
448 
449         if (snd_BUG_ON(!card || !kcontrol))
450                 return -EINVAL;
451         list_del(&kcontrol->list);
452         card->controls_count -= kcontrol->count;
453         id = kcontrol->id;
454         for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
455                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
456         snd_ctl_free_one(kcontrol);
457         return 0;
458 }
459 
460 EXPORT_SYMBOL(snd_ctl_remove);
461 
462 /**
463  * snd_ctl_remove_id - remove the control of the given id and release it
464  * @card: the card instance
465  * @id: the control id to remove
466  *
467  * Finds the control instance with the given id, removes it from the
468  * card list and releases it.
469  * 
470  * Returns 0 if successful, or a negative error code on failure.
471  */
472 int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
473 {
474         struct snd_kcontrol *kctl;
475         int ret;
476 
477         down_write(&card->controls_rwsem);
478         kctl = snd_ctl_find_id(card, id);
479         if (kctl == NULL) {
480                 up_write(&card->controls_rwsem);
481                 return -ENOENT;
482         }
483         ret = snd_ctl_remove(card, kctl);
484         up_write(&card->controls_rwsem);
485         return ret;
486 }
487 
488 EXPORT_SYMBOL(snd_ctl_remove_id);
489 
490 /**
491  * snd_ctl_remove_user_ctl - remove and release the unlocked user control
492  * @file: active control handle
493  * @id: the control id to remove
494  *
495  * Finds the control instance with the given id, removes it from the
496  * card list and releases it.
497  * 
498  * Returns 0 if successful, or a negative error code on failure.
499  */
500 static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
501                                    struct snd_ctl_elem_id *id)
502 {
503         struct snd_card *card = file->card;
504         struct snd_kcontrol *kctl;
505         int idx, ret;
506 
507         down_write(&card->controls_rwsem);
508         kctl = snd_ctl_find_id(card, id);
509         if (kctl == NULL) {
510                 ret = -ENOENT;
511                 goto error;
512         }
513         if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
514                 ret = -EINVAL;
515                 goto error;
516         }
517         for (idx = 0; idx < kctl->count; idx++)
518                 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
519                         ret = -EBUSY;
520                         goto error;
521                 }
522         ret = snd_ctl_remove(card, kctl);
523         if (ret < 0)
524                 goto error;
525         card->user_ctl_count--;
526 error:
527         up_write(&card->controls_rwsem);
528         return ret;
529 }
530 
531 /**
532  * snd_ctl_activate_id - activate/inactivate the control of the given id
533  * @card: the card instance
534  * @id: the control id to activate/inactivate
535  * @active: non-zero to activate
536  *
537  * Finds the control instance with the given id, and activate or
538  * inactivate the control together with notification, if changed.
539  *
540  * Returns 0 if unchanged, 1 if changed, or a negative error code on failure.
541  */
542 int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
543                         int active)
544 {
545         struct snd_kcontrol *kctl;
546         struct snd_kcontrol_volatile *vd;
547         unsigned int index_offset;
548         int ret;
549 
550         down_write(&card->controls_rwsem);
551         kctl = snd_ctl_find_id(card, id);
552         if (kctl == NULL) {
553                 ret = -ENOENT;
554                 goto unlock;
555         }
556         index_offset = snd_ctl_get_ioff(kctl, &kctl->id);
557         vd = &kctl->vd[index_offset];
558         ret = 0;
559         if (active) {
560                 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE))
561                         goto unlock;
562                 vd->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
563         } else {
564                 if (vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE)
565                         goto unlock;
566                 vd->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
567         }
568         ret = 1;
569  unlock:
570         up_write(&card->controls_rwsem);
571         if (ret > 0)
572                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, id);
573         return ret;
574 }
575 EXPORT_SYMBOL_GPL(snd_ctl_activate_id);
576 
577 /**
578  * snd_ctl_rename_id - replace the id of a control on the card
579  * @card: the card instance
580  * @src_id: the old id
581  * @dst_id: the new id
582  *
583  * Finds the control with the old id from the card, and replaces the
584  * id with the new one.
585  *
586  * Returns zero if successful, or a negative error code on failure.
587  */
588 int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
589                       struct snd_ctl_elem_id *dst_id)
590 {
591         struct snd_kcontrol *kctl;
592 
593         down_write(&card->controls_rwsem);
594         kctl = snd_ctl_find_id(card, src_id);
595         if (kctl == NULL) {
596                 up_write(&card->controls_rwsem);
597                 return -ENOENT;
598         }
599         kctl->id = *dst_id;
600         kctl->id.numid = card->last_numid + 1;
601         card->last_numid += kctl->count;
602         up_write(&card->controls_rwsem);
603         return 0;
604 }
605 
606 EXPORT_SYMBOL(snd_ctl_rename_id);
607 
608 /**
609  * snd_ctl_find_numid - find the control instance with the given number-id
610  * @card: the card instance
611  * @numid: the number-id to search
612  *
613  * Finds the control instance with the given number-id from the card.
614  *
615  * Returns the pointer of the instance if found, or NULL if not.
616  *
617  * The caller must down card->controls_rwsem before calling this function
618  * (if the race condition can happen).
619  */
620 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
621 {
622         struct snd_kcontrol *kctl;
623 
624         if (snd_BUG_ON(!card || !numid))
625                 return NULL;
626         list_for_each_entry(kctl, &card->controls, list) {
627                 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
628                         return kctl;
629         }
630         return NULL;
631 }
632 
633 EXPORT_SYMBOL(snd_ctl_find_numid);
634 
635 /**
636  * snd_ctl_find_id - find the control instance with the given id
637  * @card: the card instance
638  * @id: the id to search
639  *
640  * Finds the control instance with the given id from the card.
641  *
642  * Returns the pointer of the instance if found, or NULL if not.
643  *
644  * The caller must down card->controls_rwsem before calling this function
645  * (if the race condition can happen).
646  */
647 struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
648                                      struct snd_ctl_elem_id *id)
649 {
650         struct snd_kcontrol *kctl;
651 
652         if (snd_BUG_ON(!card || !id))
653                 return NULL;
654         if (id->numid != 0)
655                 return snd_ctl_find_numid(card, id->numid);
656         list_for_each_entry(kctl, &card->controls, list) {
657                 if (kctl->id.iface != id->iface)
658                         continue;
659                 if (kctl->id.device != id->device)
660                         continue;
661                 if (kctl->id.subdevice != id->subdevice)
662                         continue;
663                 if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
664                         continue;
665                 if (kctl->id.index > id->index)
666                         continue;
667                 if (kctl->id.index + kctl->count <= id->index)
668                         continue;
669                 return kctl;
670         }
671         return NULL;
672 }
673 
674 EXPORT_SYMBOL(snd_ctl_find_id);
675 
676 static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
677                              unsigned int cmd, void __user *arg)
678 {
679         struct snd_ctl_card_info *info;
680 
681         info = kzalloc(sizeof(*info), GFP_KERNEL);
682         if (! info)
683                 return -ENOMEM;
684         down_read(&snd_ioctl_rwsem);
685         info->card = card->number;
686         strlcpy(info->id, card->id, sizeof(info->id));
687         strlcpy(info->driver, card->driver, sizeof(info->driver));
688         strlcpy(info->name, card->shortname, sizeof(info->name));
689         strlcpy(info->longname, card->longname, sizeof(info->longname));
690         strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
691         strlcpy(info->components, card->components, sizeof(info->components));
692         up_read(&snd_ioctl_rwsem);
693         if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
694                 kfree(info);
695                 return -EFAULT;
696         }
697         kfree(info);
698         return 0;
699 }
700 
701 static int snd_ctl_elem_list(struct snd_card *card,
702                              struct snd_ctl_elem_list __user *_list)
703 {
704         struct list_head *plist;
705         struct snd_ctl_elem_list list;
706         struct snd_kcontrol *kctl;
707         struct snd_ctl_elem_id *dst, *id;
708         unsigned int offset, space, jidx;
709         
710         if (copy_from_user(&list, _list, sizeof(list)))
711                 return -EFAULT;
712         offset = list.offset;
713         space = list.space;
714         /* try limit maximum space */
715         if (space > 16384)
716                 return -ENOMEM;
717         if (space > 0) {
718                 /* allocate temporary buffer for atomic operation */
719                 dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
720                 if (dst == NULL)
721                         return -ENOMEM;
722                 down_read(&card->controls_rwsem);
723                 list.count = card->controls_count;
724                 plist = card->controls.next;
725                 while (plist != &card->controls) {
726                         if (offset == 0)
727                                 break;
728                         kctl = snd_kcontrol(plist);
729                         if (offset < kctl->count)
730                                 break;
731                         offset -= kctl->count;
732                         plist = plist->next;
733                 }
734                 list.used = 0;
735                 id = dst;
736                 while (space > 0 && plist != &card->controls) {
737                         kctl = snd_kcontrol(plist);
738                         for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
739                                 snd_ctl_build_ioff(id, kctl, jidx);
740                                 id++;
741                                 space--;
742                                 list.used++;
743                         }
744                         plist = plist->next;
745                         offset = 0;
746                 }
747                 up_read(&card->controls_rwsem);
748                 if (list.used > 0 &&
749                     copy_to_user(list.pids, dst,
750                                  list.used * sizeof(struct snd_ctl_elem_id))) {
751                         vfree(dst);
752                         return -EFAULT;
753                 }
754                 vfree(dst);
755         } else {
756                 down_read(&card->controls_rwsem);
757                 list.count = card->controls_count;
758                 up_read(&card->controls_rwsem);
759         }
760         if (copy_to_user(_list, &list, sizeof(list)))
761                 return -EFAULT;
762         return 0;
763 }
764 
765 static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
766                              struct snd_ctl_elem_info *info)
767 {
768         struct snd_card *card = ctl->card;
769         struct snd_kcontrol *kctl;
770         struct snd_kcontrol_volatile *vd;
771         unsigned int index_offset;
772         int result;
773         
774         down_read(&card->controls_rwsem);
775         kctl = snd_ctl_find_id(card, &info->id);
776         if (kctl == NULL) {
777                 up_read(&card->controls_rwsem);
778                 return -ENOENT;
779         }
780 #ifdef CONFIG_SND_DEBUG
781         info->access = 0;
782 #endif
783         result = kctl->info(kctl, info);
784         if (result >= 0) {
785                 snd_BUG_ON(info->access);
786                 index_offset = snd_ctl_get_ioff(kctl, &info->id);
787                 vd = &kctl->vd[index_offset];
788                 snd_ctl_build_ioff(&info->id, kctl, index_offset);
789                 info->access = vd->access;
790                 if (vd->owner) {
791                         info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
792                         if (vd->owner == ctl)
793                                 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
794                         info->owner = pid_vnr(vd->owner->pid);
795                 } else {
796                         info->owner = -1;
797                 }
798         }
799         up_read(&card->controls_rwsem);
800         return result;
801 }
802 
803 static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
804                                   struct snd_ctl_elem_info __user *_info)
805 {
806         struct snd_ctl_elem_info info;
807         int result;
808 
809         if (copy_from_user(&info, _info, sizeof(info)))
810                 return -EFAULT;
811         snd_power_lock(ctl->card);
812         result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0);
813         if (result >= 0)
814                 result = snd_ctl_elem_info(ctl, &info);
815         snd_power_unlock(ctl->card);
816         if (result >= 0)
817                 if (copy_to_user(_info, &info, sizeof(info)))
818                         return -EFAULT;
819         return result;
820 }
821 
822 static int snd_ctl_elem_read(struct snd_card *card,
823                              struct snd_ctl_elem_value *control)
824 {
825         struct snd_kcontrol *kctl;
826         struct snd_kcontrol_volatile *vd;
827         unsigned int index_offset;
828         int result;
829 
830         down_read(&card->controls_rwsem);
831         kctl = snd_ctl_find_id(card, &control->id);
832         if (kctl == NULL) {
833                 result = -ENOENT;
834         } else {
835                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
836                 vd = &kctl->vd[index_offset];
837                 if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) &&
838                     kctl->get != NULL) {
839                         snd_ctl_build_ioff(&control->id, kctl, index_offset);
840                         result = kctl->get(kctl, control);
841                 } else
842                         result = -EPERM;
843         }
844         up_read(&card->controls_rwsem);
845         return result;
846 }
847 
848 static int snd_ctl_elem_read_user(struct snd_card *card,
849                                   struct snd_ctl_elem_value __user *_control)
850 {
851         struct snd_ctl_elem_value *control;
852         int result;
853 
854         control = memdup_user(_control, sizeof(*control));
855         if (IS_ERR(control))
856                 return PTR_ERR(control);
857 
858         snd_power_lock(card);
859         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
860         if (result >= 0)
861                 result = snd_ctl_elem_read(card, control);
862         snd_power_unlock(card);
863         if (result >= 0)
864                 if (copy_to_user(_control, control, sizeof(*control)))
865                         result = -EFAULT;
866         kfree(control);
867         return result;
868 }
869 
870 static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
871                               struct snd_ctl_elem_value *control)
872 {
873         struct snd_kcontrol *kctl;
874         struct snd_kcontrol_volatile *vd;
875         unsigned int index_offset;
876         int result;
877 
878         down_read(&card->controls_rwsem);
879         kctl = snd_ctl_find_id(card, &control->id);
880         if (kctl == NULL) {
881                 result = -ENOENT;
882         } else {
883                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
884                 vd = &kctl->vd[index_offset];
885                 if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
886                     kctl->put == NULL ||
887                     (file && vd->owner && vd->owner != file)) {
888                         result = -EPERM;
889                 } else {
890                         snd_ctl_build_ioff(&control->id, kctl, index_offset);
891                         result = kctl->put(kctl, control);
892                 }
893                 if (result > 0) {
894                         up_read(&card->controls_rwsem);
895                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
896                                        &control->id);
897                         return 0;
898                 }
899         }
900         up_read(&card->controls_rwsem);
901         return result;
902 }
903 
904 static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
905                                    struct snd_ctl_elem_value __user *_control)
906 {
907         struct snd_ctl_elem_value *control;
908         struct snd_card *card;
909         int result;
910 
911         control = memdup_user(_control, sizeof(*control));
912         if (IS_ERR(control))
913                 return PTR_ERR(control);
914 
915         card = file->card;
916         snd_power_lock(card);
917         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
918         if (result >= 0)
919                 result = snd_ctl_elem_write(card, file, control);
920         snd_power_unlock(card);
921         if (result >= 0)
922                 if (copy_to_user(_control, control, sizeof(*control)))
923                         result = -EFAULT;
924         kfree(control);
925         return result;
926 }
927 
928 static int snd_ctl_elem_lock(struct snd_ctl_file *file,
929                              struct snd_ctl_elem_id __user *_id)
930 {
931         struct snd_card *card = file->card;
932         struct snd_ctl_elem_id id;
933         struct snd_kcontrol *kctl;
934         struct snd_kcontrol_volatile *vd;
935         int result;
936         
937         if (copy_from_user(&id, _id, sizeof(id)))
938                 return -EFAULT;
939         down_write(&card->controls_rwsem);
940         kctl = snd_ctl_find_id(card, &id);
941         if (kctl == NULL) {
942                 result = -ENOENT;
943         } else {
944                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
945                 if (vd->owner != NULL)
946                         result = -EBUSY;
947                 else {
948                         vd->owner = file;
949                         result = 0;
950                 }
951         }
952         up_write(&card->controls_rwsem);
953         return result;
954 }
955 
956 static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
957                                struct snd_ctl_elem_id __user *_id)
958 {
959         struct snd_card *card = file->card;
960         struct snd_ctl_elem_id id;
961         struct snd_kcontrol *kctl;
962         struct snd_kcontrol_volatile *vd;
963         int result;
964         
965         if (copy_from_user(&id, _id, sizeof(id)))
966                 return -EFAULT;
967         down_write(&card->controls_rwsem);
968         kctl = snd_ctl_find_id(card, &id);
969         if (kctl == NULL) {
970                 result = -ENOENT;
971         } else {
972                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
973                 if (vd->owner == NULL)
974                         result = -EINVAL;
975                 else if (vd->owner != file)
976                         result = -EPERM;
977                 else {
978                         vd->owner = NULL;
979                         result = 0;
980                 }
981         }
982         up_write(&card->controls_rwsem);
983         return result;
984 }
985 
986 struct user_element {
987         struct snd_ctl_elem_info info;
988         void *elem_data;                /* element data */
989         unsigned long elem_data_size;   /* size of element data in bytes */
990         void *tlv_data;                 /* TLV data */
991         unsigned long tlv_data_size;    /* TLV data size */
992         void *priv_data;                /* private data (like strings for enumerated type) */
993 };
994 
995 static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
996                                   struct snd_ctl_elem_info *uinfo)
997 {
998         struct user_element *ue = kcontrol->private_data;
999 
1000         *uinfo = ue->info;
1001         return 0;
1002 }
1003 
1004 static int snd_ctl_elem_user_enum_info(struct snd_kcontrol *kcontrol,
1005                                        struct snd_ctl_elem_info *uinfo)
1006 {
1007         struct user_element *ue = kcontrol->private_data;
1008         const char *names;
1009         unsigned int item;
1010 
1011         item = uinfo->value.enumerated.item;
1012 
1013         *uinfo = ue->info;
1014 
1015         item = min(item, uinfo->value.enumerated.items - 1);
1016         uinfo->value.enumerated.item = item;
1017 
1018         names = ue->priv_data;
1019         for (; item > 0; --item)
1020                 names += strlen(names) + 1;
1021         strcpy(uinfo->value.enumerated.name, names);
1022 
1023         return 0;
1024 }
1025 
1026 static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
1027                                  struct snd_ctl_elem_value *ucontrol)
1028 {
1029         struct user_element *ue = kcontrol->private_data;
1030 
1031         memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
1032         return 0;
1033 }
1034 
1035 static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
1036                                  struct snd_ctl_elem_value *ucontrol)
1037 {
1038         int change;
1039         struct user_element *ue = kcontrol->private_data;
1040         
1041         change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
1042         if (change)
1043                 memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
1044         return change;
1045 }
1046 
1047 static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol,
1048                                  int op_flag,
1049                                  unsigned int size,
1050                                  unsigned int __user *tlv)
1051 {
1052         struct user_element *ue = kcontrol->private_data;
1053         int change = 0;
1054         void *new_data;
1055 
1056         if (op_flag > 0) {
1057                 if (size > 1024 * 128)  /* sane value */
1058                         return -EINVAL;
1059 
1060                 new_data = memdup_user(tlv, size);
1061                 if (IS_ERR(new_data))
1062                         return PTR_ERR(new_data);
1063                 change = ue->tlv_data_size != size;
1064                 if (!change)
1065                         change = memcmp(ue->tlv_data, new_data, size);
1066                 kfree(ue->tlv_data);
1067                 ue->tlv_data = new_data;
1068                 ue->tlv_data_size = size;
1069         } else {
1070                 if (! ue->tlv_data_size || ! ue->tlv_data)
1071                         return -ENXIO;
1072                 if (size < ue->tlv_data_size)
1073                         return -ENOSPC;
1074                 if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size))
1075                         return -EFAULT;
1076         }
1077         return change;
1078 }
1079 
1080 static int snd_ctl_elem_init_enum_names(struct user_element *ue)
1081 {
1082         char *names, *p;
1083         size_t buf_len, name_len;
1084         unsigned int i;
1085         const uintptr_t user_ptrval = ue->info.value.enumerated.names_ptr;
1086 
1087         if (ue->info.value.enumerated.names_length > 64 * 1024)
1088                 return -EINVAL;
1089 
1090         names = memdup_user((const void __user *)user_ptrval,
1091                 ue->info.value.enumerated.names_length);
1092         if (IS_ERR(names))
1093                 return PTR_ERR(names);
1094 
1095         /* check that there are enough valid names */
1096         buf_len = ue->info.value.enumerated.names_length;
1097         p = names;
1098         for (i = 0; i < ue->info.value.enumerated.items; ++i) {
1099                 name_len = strnlen(p, buf_len);
1100                 if (name_len == 0 || name_len >= 64 || name_len == buf_len) {
1101                         kfree(names);
1102                         return -EINVAL;
1103                 }
1104                 p += name_len + 1;
1105                 buf_len -= name_len + 1;
1106         }
1107 
1108         ue->priv_data = names;
1109         ue->info.value.enumerated.names_ptr = 0;
1110 
1111         return 0;
1112 }
1113 
1114 static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
1115 {
1116         struct user_element *ue = kcontrol->private_data;
1117 
1118         kfree(ue->tlv_data);
1119         kfree(ue->priv_data);
1120         kfree(ue);
1121 }
1122 
1123 static int snd_ctl_elem_add(struct snd_ctl_file *file,
1124                             struct snd_ctl_elem_info *info, int replace)
1125 {
1126         struct snd_card *card = file->card;
1127         struct snd_kcontrol kctl, *_kctl;
1128         unsigned int access;
1129         long private_size;
1130         struct user_element *ue;
1131         int idx, err;
1132 
1133         if (!replace && card->user_ctl_count >= MAX_USER_CONTROLS)
1134                 return -ENOMEM;
1135         if (info->count < 1)
1136                 return -EINVAL;
1137         access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
1138                 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
1139                                  SNDRV_CTL_ELEM_ACCESS_INACTIVE|
1140                                  SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE));
1141         info->id.numid = 0;
1142         memset(&kctl, 0, sizeof(kctl));
1143         down_write(&card->controls_rwsem);
1144         _kctl = snd_ctl_find_id(card, &info->id);
1145         err = 0;
1146         if (_kctl) {
1147                 if (replace)
1148                         err = snd_ctl_remove(card, _kctl);
1149                 else
1150                         err = -EBUSY;
1151         } else {
1152                 if (replace)
1153                         err = -ENOENT;
1154         }
1155         up_write(&card->controls_rwsem);
1156         if (err < 0)
1157                 return err;
1158         memcpy(&kctl.id, &info->id, sizeof(info->id));
1159         kctl.count = info->owner ? info->owner : 1;
1160         access |= SNDRV_CTL_ELEM_ACCESS_USER;
1161         if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED)
1162                 kctl.info = snd_ctl_elem_user_enum_info;
1163         else
1164                 kctl.info = snd_ctl_elem_user_info;
1165         if (access & SNDRV_CTL_ELEM_ACCESS_READ)
1166                 kctl.get = snd_ctl_elem_user_get;
1167         if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
1168                 kctl.put = snd_ctl_elem_user_put;
1169         if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
1170                 kctl.tlv.c = snd_ctl_elem_user_tlv;
1171                 access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1172         }
1173         switch (info->type) {
1174         case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1175         case SNDRV_CTL_ELEM_TYPE_INTEGER:
1176                 private_size = sizeof(long);
1177                 if (info->count > 128)
1178                         return -EINVAL;
1179                 break;
1180         case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1181                 private_size = sizeof(long long);
1182                 if (info->count > 64)
1183                         return -EINVAL;
1184                 break;
1185         case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
1186                 private_size = sizeof(unsigned int);
1187                 if (info->count > 128 || info->value.enumerated.items == 0)
1188                         return -EINVAL;
1189                 break;
1190         case SNDRV_CTL_ELEM_TYPE_BYTES:
1191                 private_size = sizeof(unsigned char);
1192                 if (info->count > 512)
1193                         return -EINVAL;
1194                 break;
1195         case SNDRV_CTL_ELEM_TYPE_IEC958:
1196                 private_size = sizeof(struct snd_aes_iec958);
1197                 if (info->count != 1)
1198                         return -EINVAL;
1199                 break;
1200         default:
1201                 return -EINVAL;
1202         }
1203         private_size *= info->count;
1204         ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
1205         if (ue == NULL)
1206                 return -ENOMEM;
1207         ue->info = *info;
1208         ue->info.access = 0;
1209         ue->elem_data = (char *)ue + sizeof(*ue);
1210         ue->elem_data_size = private_size;
1211         if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
1212                 err = snd_ctl_elem_init_enum_names(ue);
1213                 if (err < 0) {
1214                         kfree(ue);
1215                         return err;
1216                 }
1217         }
1218         kctl.private_free = snd_ctl_elem_user_free;
1219         _kctl = snd_ctl_new(&kctl, access);
1220         if (_kctl == NULL) {
1221                 kfree(ue->priv_data);
1222                 kfree(ue);
1223                 return -ENOMEM;
1224         }
1225         _kctl->private_data = ue;
1226         for (idx = 0; idx < _kctl->count; idx++)
1227                 _kctl->vd[idx].owner = file;
1228         err = snd_ctl_add(card, _kctl);
1229         if (err < 0)
1230                 return err;
1231 
1232         down_write(&card->controls_rwsem);
1233         card->user_ctl_count++;
1234         up_write(&card->controls_rwsem);
1235 
1236         return 0;
1237 }
1238 
1239 static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
1240                                  struct snd_ctl_elem_info __user *_info, int replace)
1241 {
1242         struct snd_ctl_elem_info info;
1243         if (copy_from_user(&info, _info, sizeof(info)))
1244                 return -EFAULT;
1245         return snd_ctl_elem_add(file, &info, replace);
1246 }
1247 
1248 static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1249                                struct snd_ctl_elem_id __user *_id)
1250 {
1251         struct snd_ctl_elem_id id;
1252 
1253         if (copy_from_user(&id, _id, sizeof(id)))
1254                 return -EFAULT;
1255         return snd_ctl_remove_user_ctl(file, &id);
1256 }
1257 
1258 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
1259 {
1260         int subscribe;
1261         if (get_user(subscribe, ptr))
1262                 return -EFAULT;
1263         if (subscribe < 0) {
1264                 subscribe = file->subscribed;
1265                 if (put_user(subscribe, ptr))
1266                         return -EFAULT;
1267                 return 0;
1268         }
1269         if (subscribe) {
1270                 file->subscribed = 1;
1271                 return 0;
1272         } else if (file->subscribed) {
1273                 snd_ctl_empty_read_queue(file);
1274                 file->subscribed = 0;
1275         }
1276         return 0;
1277 }
1278 
1279 static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
1280                              struct snd_ctl_tlv __user *_tlv,
1281                              int op_flag)
1282 {
1283         struct snd_card *card = file->card;
1284         struct snd_ctl_tlv tlv;
1285         struct snd_kcontrol *kctl;
1286         struct snd_kcontrol_volatile *vd;
1287         unsigned int len;
1288         int err = 0;
1289 
1290         if (copy_from_user(&tlv, _tlv, sizeof(tlv)))
1291                 return -EFAULT;
1292         if (tlv.length < sizeof(unsigned int) * 2)
1293                 return -EINVAL;
1294         down_read(&card->controls_rwsem);
1295         kctl = snd_ctl_find_numid(card, tlv.numid);
1296         if (kctl == NULL) {
1297                 err = -ENOENT;
1298                 goto __kctl_end;
1299         }
1300         if (kctl->tlv.p == NULL) {
1301                 err = -ENXIO;
1302                 goto __kctl_end;
1303         }
1304         vd = &kctl->vd[tlv.numid - kctl->id.numid];
1305         if ((op_flag == 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) == 0) ||
1306             (op_flag > 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) == 0) ||
1307             (op_flag < 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) == 0)) {
1308                 err = -ENXIO;
1309                 goto __kctl_end;
1310         }
1311         if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1312                 if (vd->owner != NULL && vd->owner != file) {
1313                         err = -EPERM;
1314                         goto __kctl_end;
1315                 }
1316                 err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv);
1317                 if (err > 0) {
1318                         up_read(&card->controls_rwsem);
1319                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &kctl->id);
1320                         return 0;
1321                 }
1322         } else {
1323                 if (op_flag) {
1324                         err = -ENXIO;
1325                         goto __kctl_end;
1326                 }
1327                 len = kctl->tlv.p[1] + 2 * sizeof(unsigned int);
1328                 if (tlv.length < len) {
1329                         err = -ENOMEM;
1330                         goto __kctl_end;
1331                 }
1332                 if (copy_to_user(_tlv->tlv, kctl->tlv.p, len))
1333                         err = -EFAULT;
1334         }
1335       __kctl_end:
1336         up_read(&card->controls_rwsem);
1337         return err;
1338 }
1339 
1340 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1341 {
1342         struct snd_ctl_file *ctl;
1343         struct snd_card *card;
1344         struct snd_kctl_ioctl *p;
1345         void __user *argp = (void __user *)arg;
1346         int __user *ip = argp;
1347         int err;
1348 
1349         ctl = file->private_data;
1350         card = ctl->card;
1351         if (snd_BUG_ON(!card))
1352                 return -ENXIO;
1353         switch (cmd) {
1354         case SNDRV_CTL_IOCTL_PVERSION:
1355                 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
1356         case SNDRV_CTL_IOCTL_CARD_INFO:
1357                 return snd_ctl_card_info(card, ctl, cmd, argp);
1358         case SNDRV_CTL_IOCTL_ELEM_LIST:
1359                 return snd_ctl_elem_list(card, argp);
1360         case SNDRV_CTL_IOCTL_ELEM_INFO:
1361                 return snd_ctl_elem_info_user(ctl, argp);
1362         case SNDRV_CTL_IOCTL_ELEM_READ:
1363                 return snd_ctl_elem_read_user(card, argp);
1364         case SNDRV_CTL_IOCTL_ELEM_WRITE:
1365                 return snd_ctl_elem_write_user(ctl, argp);
1366         case SNDRV_CTL_IOCTL_ELEM_LOCK:
1367                 return snd_ctl_elem_lock(ctl, argp);
1368         case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
1369                 return snd_ctl_elem_unlock(ctl, argp);
1370         case SNDRV_CTL_IOCTL_ELEM_ADD:
1371                 return snd_ctl_elem_add_user(ctl, argp, 0);
1372         case SNDRV_CTL_IOCTL_ELEM_REPLACE:
1373                 return snd_ctl_elem_add_user(ctl, argp, 1);
1374         case SNDRV_CTL_IOCTL_ELEM_REMOVE:
1375                 return snd_ctl_elem_remove(ctl, argp);
1376         case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
1377                 return snd_ctl_subscribe_events(ctl, ip);
1378         case SNDRV_CTL_IOCTL_TLV_READ:
1379                 return snd_ctl_tlv_ioctl(ctl, argp, 0);
1380         case SNDRV_CTL_IOCTL_TLV_WRITE:
1381                 return snd_ctl_tlv_ioctl(ctl, argp, 1);
1382         case SNDRV_CTL_IOCTL_TLV_COMMAND:
1383                 return snd_ctl_tlv_ioctl(ctl, argp, -1);
1384         case SNDRV_CTL_IOCTL_POWER:
1385                 return -ENOPROTOOPT;
1386         case SNDRV_CTL_IOCTL_POWER_STATE:
1387 #ifdef CONFIG_PM
1388                 return put_user(card->power_state, ip) ? -EFAULT : 0;
1389 #else
1390                 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
1391 #endif
1392         }
1393         down_read(&snd_ioctl_rwsem);
1394         list_for_each_entry(p, &snd_control_ioctls, list) {
1395                 err = p->fioctl(card, ctl, cmd, arg);
1396                 if (err != -ENOIOCTLCMD) {
1397                         up_read(&snd_ioctl_rwsem);
1398                         return err;
1399                 }
1400         }
1401         up_read(&snd_ioctl_rwsem);
1402         snd_printdd("unknown ioctl = 0x%x\n", cmd);
1403         return -ENOTTY;
1404 }
1405 
1406 static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1407                             size_t count, loff_t * offset)
1408 {
1409         struct snd_ctl_file *ctl;
1410         int err = 0;
1411         ssize_t result = 0;
1412 
1413         ctl = file->private_data;
1414         if (snd_BUG_ON(!ctl || !ctl->card))
1415                 return -ENXIO;
1416         if (!ctl->subscribed)
1417                 return -EBADFD;
1418         if (count < sizeof(struct snd_ctl_event))
1419                 return -EINVAL;
1420         spin_lock_irq(&ctl->read_lock);
1421         while (count >= sizeof(struct snd_ctl_event)) {
1422                 struct snd_ctl_event ev;
1423                 struct snd_kctl_event *kev;
1424                 while (list_empty(&ctl->events)) {
1425                         wait_queue_t wait;
1426                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1427                                 err = -EAGAIN;
1428                                 goto __end_lock;
1429                         }
1430                         init_waitqueue_entry(&wait, current);
1431                         add_wait_queue(&ctl->change_sleep, &wait);
1432                         set_current_state(TASK_INTERRUPTIBLE);
1433                         spin_unlock_irq(&ctl->read_lock);
1434                         schedule();
1435                         remove_wait_queue(&ctl->change_sleep, &wait);
1436                         if (signal_pending(current))
1437                                 return -ERESTARTSYS;
1438                         spin_lock_irq(&ctl->read_lock);
1439                 }
1440                 kev = snd_kctl_event(ctl->events.next);
1441                 ev.type = SNDRV_CTL_EVENT_ELEM;
1442                 ev.data.elem.mask = kev->mask;
1443                 ev.data.elem.id = kev->id;
1444                 list_del(&kev->list);
1445                 spin_unlock_irq(&ctl->read_lock);
1446                 kfree(kev);
1447                 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
1448                         err = -EFAULT;
1449                         goto __end;
1450                 }
1451                 spin_lock_irq(&ctl->read_lock);
1452                 buffer += sizeof(struct snd_ctl_event);
1453                 count -= sizeof(struct snd_ctl_event);
1454                 result += sizeof(struct snd_ctl_event);
1455         }
1456       __end_lock:
1457         spin_unlock_irq(&ctl->read_lock);
1458       __end:
1459         return result > 0 ? result : err;
1460 }
1461 
1462 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
1463 {
1464         unsigned int mask;
1465         struct snd_ctl_file *ctl;
1466 
1467         ctl = file->private_data;
1468         if (!ctl->subscribed)
1469                 return 0;
1470         poll_wait(file, &ctl->change_sleep, wait);
1471 
1472         mask = 0;
1473         if (!list_empty(&ctl->events))
1474                 mask |= POLLIN | POLLRDNORM;
1475 
1476         return mask;
1477 }
1478 
1479 /*
1480  * register the device-specific control-ioctls.
1481  * called from each device manager like pcm.c, hwdep.c, etc.
1482  */
1483 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
1484 {
1485         struct snd_kctl_ioctl *pn;
1486 
1487         pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
1488         if (pn == NULL)
1489                 return -ENOMEM;
1490         pn->fioctl = fcn;
1491         down_write(&snd_ioctl_rwsem);
1492         list_add_tail(&pn->list, lists);
1493         up_write(&snd_ioctl_rwsem);
1494         return 0;
1495 }
1496 
1497 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
1498 {
1499         return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
1500 }
1501 
1502 EXPORT_SYMBOL(snd_ctl_register_ioctl);
1503 
1504 #ifdef CONFIG_COMPAT
1505 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1506 {
1507         return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
1508 }
1509 
1510 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
1511 #endif
1512 
1513 /*
1514  * de-register the device-specific control-ioctls.
1515  */
1516 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1517                                      struct list_head *lists)
1518 {
1519         struct snd_kctl_ioctl *p;
1520 
1521         if (snd_BUG_ON(!fcn))
1522                 return -EINVAL;
1523         down_write(&snd_ioctl_rwsem);
1524         list_for_each_entry(p, lists, list) {
1525                 if (p->fioctl == fcn) {
1526                         list_del(&p->list);
1527                         up_write(&snd_ioctl_rwsem);
1528                         kfree(p);
1529                         return 0;
1530                 }
1531         }
1532         up_write(&snd_ioctl_rwsem);
1533         snd_BUG();
1534         return -EINVAL;
1535 }
1536 
1537 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
1538 {
1539         return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
1540 }
1541 
1542 EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
1543 
1544 #ifdef CONFIG_COMPAT
1545 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
1546 {
1547         return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
1548 }
1549 
1550 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
1551 #endif
1552 
1553 static int snd_ctl_fasync(int fd, struct file * file, int on)
1554 {
1555         struct snd_ctl_file *ctl;
1556 
1557         ctl = file->private_data;
1558         return fasync_helper(fd, file, on, &ctl->fasync);
1559 }
1560 
1561 /*
1562  * ioctl32 compat
1563  */
1564 #ifdef CONFIG_COMPAT
1565 #include "control_compat.c"
1566 #else
1567 #define snd_ctl_ioctl_compat    NULL
1568 #endif
1569 
1570 /*
1571  *  INIT PART
1572  */
1573 
1574 static const struct file_operations snd_ctl_f_ops =
1575 {
1576         .owner =        THIS_MODULE,
1577         .read =         snd_ctl_read,
1578         .open =         snd_ctl_open,
1579         .release =      snd_ctl_release,
1580         .llseek =       no_llseek,
1581         .poll =         snd_ctl_poll,
1582         .unlocked_ioctl =       snd_ctl_ioctl,
1583         .compat_ioctl = snd_ctl_ioctl_compat,
1584         .fasync =       snd_ctl_fasync,
1585 };
1586 
1587 /*
1588  * registration of the control device
1589  */
1590 static int snd_ctl_dev_register(struct snd_device *device)
1591 {
1592         struct snd_card *card = device->device_data;
1593         int err, cardnum;
1594         char name[16];
1595 
1596         if (snd_BUG_ON(!card))
1597                 return -ENXIO;
1598         cardnum = card->number;
1599         if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1600                 return -ENXIO;
1601         sprintf(name, "controlC%i", cardnum);
1602         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1603                                        &snd_ctl_f_ops, card, name)) < 0)
1604                 return err;
1605         return 0;
1606 }
1607 
1608 /*
1609  * disconnection of the control device
1610  */
1611 static int snd_ctl_dev_disconnect(struct snd_device *device)
1612 {
1613         struct snd_card *card = device->device_data;
1614         struct snd_ctl_file *ctl;
1615         int err, cardnum;
1616 
1617         if (snd_BUG_ON(!card))
1618                 return -ENXIO;
1619         cardnum = card->number;
1620         if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1621                 return -ENXIO;
1622 
1623         read_lock(&card->ctl_files_rwlock);
1624         list_for_each_entry(ctl, &card->ctl_files, list) {
1625                 wake_up(&ctl->change_sleep);
1626                 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
1627         }
1628         read_unlock(&card->ctl_files_rwlock);
1629 
1630         if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
1631                                          card, -1)) < 0)
1632                 return err;
1633         return 0;
1634 }
1635 
1636 /*
1637  * free all controls
1638  */
1639 static int snd_ctl_dev_free(struct snd_device *device)
1640 {
1641         struct snd_card *card = device->device_data;
1642         struct snd_kcontrol *control;
1643 
1644         down_write(&card->controls_rwsem);
1645         while (!list_empty(&card->controls)) {
1646                 control = snd_kcontrol(card->controls.next);
1647                 snd_ctl_remove(card, control);
1648         }
1649         up_write(&card->controls_rwsem);
1650         return 0;
1651 }
1652 
1653 /*
1654  * create control core:
1655  * called from init.c
1656  */
1657 int snd_ctl_create(struct snd_card *card)
1658 {
1659         static struct snd_device_ops ops = {
1660                 .dev_free = snd_ctl_dev_free,
1661                 .dev_register = snd_ctl_dev_register,
1662                 .dev_disconnect = snd_ctl_dev_disconnect,
1663         };
1664 
1665         if (snd_BUG_ON(!card))
1666                 return -ENXIO;
1667         return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1668 }
1669 
1670 /*
1671  * Frequently used control callbacks/helpers
1672  */
1673 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
1674                               struct snd_ctl_elem_info *uinfo)
1675 {
1676         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1677         uinfo->count = 1;
1678         uinfo->value.integer.min = 0;
1679         uinfo->value.integer.max = 1;
1680         return 0;
1681 }
1682 
1683 EXPORT_SYMBOL(snd_ctl_boolean_mono_info);
1684 
1685 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
1686                                 struct snd_ctl_elem_info *uinfo)
1687 {
1688         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1689         uinfo->count = 2;
1690         uinfo->value.integer.min = 0;
1691         uinfo->value.integer.max = 1;
1692         return 0;
1693 }
1694 
1695 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);
1696 
1697 /**
1698  * snd_ctl_enum_info - fills the info structure for an enumerated control
1699  * @info: the structure to be filled
1700  * @channels: the number of the control's channels; often one
1701  * @items: the number of control values; also the size of @names
1702  * @names: an array containing the names of all control values
1703  *
1704  * Sets all required fields in @info to their appropriate values.
1705  * If the control's accessibility is not the default (readable and writable),
1706  * the caller has to fill @info->access.
1707  */
1708 int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
1709                       unsigned int items, const char *const names[])
1710 {
1711         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1712         info->count = channels;
1713         info->value.enumerated.items = items;
1714         if (info->value.enumerated.item >= items)
1715                 info->value.enumerated.item = items - 1;
1716         strlcpy(info->value.enumerated.name,
1717                 names[info->value.enumerated.item],
1718                 sizeof(info->value.enumerated.name));
1719         return 0;
1720 }
1721 EXPORT_SYMBOL(snd_ctl_enum_info);
1722 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp