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

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

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

~ [ 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