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