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