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/moduleparam.h>
11	#include <linux/slab.h>
12	#include <linux/vmalloc.h>
13	#include <linux/time.h>
14	#include <linux/mm.h>
15	#include <linux/math64.h>
16	#include <linux/sched/signal.h>
17	#include <sound/core.h>
18	#include <sound/minors.h>
19	#include <sound/info.h>
20	#include <sound/control.h>
21
22	// Max allocation size for user controls.
23	static int max_user_ctl_alloc_size = 8 * 1024 * 1024;
24	module_param_named(max_user_ctl_alloc_size, max_user_ctl_alloc_size, int, 0444);
25	MODULE_PARM_DESC(max_user_ctl_alloc_size, "Max allocation size for user controls");
26
27	#define MAX_CONTROL_COUNT 1028
28
29	struct snd_kctl_ioctl {
30	struct list_head list; /* list of all ioctls */
31	snd_kctl_ioctl_func_t fioctl;
32	};
33
34	static DECLARE_RWSEM(snd_ioctl_rwsem);
35	static DECLARE_RWSEM(snd_ctl_layer_rwsem);
36	static LIST_HEAD(snd_control_ioctls);
37	#ifdef CONFIG_COMPAT
38	static LIST_HEAD(snd_control_compat_ioctls);
39	#endif
40	static struct snd_ctl_layer_ops *snd_ctl_layer;
41
42	static int snd_ctl_remove_locked(struct snd_card *card,
43	struct snd_kcontrol *kcontrol);
44
45	static int snd_ctl_open(struct inode *inode, struct file *file)
46	{
47	unsigned long flags;
48	struct snd_card *card;
49	struct snd_ctl_file *ctl;
50	int i, err;
51
52	err = stream_open(inode, filp: file);
53	if (err < 0)
54	return err;
55
56	card = snd_lookup_minor_data(minor: iminor(inode), type: SNDRV_DEVICE_TYPE_CONTROL);
57	if (!card) {
58	err = -ENODEV;
59	goto __error1;
60	}
61	err = snd_card_file_add(card, file);
62	if (err < 0) {
63	err = -ENODEV;
64	goto __error1;
65	}
66	if (!try_module_get(module: card->module)) {
67	err = -EFAULT;
68	goto __error2;
69	}
70	ctl = kzalloc(size: sizeof(*ctl), GFP_KERNEL);
71	if (ctl == NULL) {
72	err = -ENOMEM;
73	goto __error;
74	}
75	INIT_LIST_HEAD(list: &ctl->events);
76	init_waitqueue_head(&ctl->change_sleep);
77	spin_lock_init(&ctl->read_lock);
78	ctl->card = card;
79	for (i = 0; i < SND_CTL_SUBDEV_ITEMS; i++)
80	ctl->preferred_subdevice[i] = -1;
81	ctl->pid = get_pid(pid: task_pid(current));
82	file->private_data = ctl;
83	write_lock_irqsave(&card->ctl_files_rwlock, flags);
84	list_add_tail(new: &ctl->list, head: &card->ctl_files);
85	write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
86	snd_card_unref(card);
87	return 0;
88
89	__error:
90	module_put(module: card->module);
91	__error2:
92	snd_card_file_remove(card, file);
93	__error1:
94	if (card)
95	snd_card_unref(card);
96	return err;
97	}
98
99	static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
100	{
101	unsigned long flags;
102	struct snd_kctl_event *cread;
103
104	spin_lock_irqsave(&ctl->read_lock, flags);
105	while (!list_empty(head: &ctl->events)) {
106	cread = snd_kctl_event(ctl->events.next);
107	list_del(entry: &cread->list);
108	kfree(objp: cread);
109	}
110	spin_unlock_irqrestore(lock: &ctl->read_lock, flags);
111	}
112
113	static int snd_ctl_release(struct inode *inode, struct file *file)
114	{
115	unsigned long flags;
116	struct snd_card *card;
117	struct snd_ctl_file *ctl;
118	struct snd_kcontrol *control;
119	unsigned int idx;
120
121	ctl = file->private_data;
122	file->private_data = NULL;
123	card = ctl->card;
124	write_lock_irqsave(&card->ctl_files_rwlock, flags);
125	list_del(entry: &ctl->list);
126	write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
127	down_write(sem: &card->controls_rwsem);
128	list_for_each_entry(control, &card->controls, list)
129	for (idx = 0; idx < control->count; idx++)
130	if (control->vd[idx].owner == ctl)
131	control->vd[idx].owner = NULL;
132	up_write(sem: &card->controls_rwsem);
133	snd_fasync_free(fasync: ctl->fasync);
134	snd_ctl_empty_read_queue(ctl);
135	put_pid(pid: ctl->pid);
136	kfree(objp: ctl);
137	module_put(module: card->module);
138	snd_card_file_remove(card, file);
139	return 0;
140	}
141
142	/**
143	* snd_ctl_notify - Send notification to user-space for a control change
144	* @card: the card to send notification
145	* @mask: the event mask, SNDRV_CTL_EVENT_*
146	* @id: the ctl element id to send notification
147	*
148	* This function adds an event record with the given id and mask, appends
149	* to the list and wakes up the user-space for notification. This can be
150	* called in the atomic context.
151	*/
152	void snd_ctl_notify(struct snd_card *card, unsigned int mask,
153	struct snd_ctl_elem_id *id)
154	{
155	unsigned long flags;
156	struct snd_ctl_file *ctl;
157	struct snd_kctl_event *ev;
158
159	if (snd_BUG_ON(!card || !id))
160	return;
161	if (card->shutdown)
162	return;
163	read_lock_irqsave(&card->ctl_files_rwlock, flags);
164	#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
165	card->mixer_oss_change_count++;
166	#endif
167	list_for_each_entry(ctl, &card->ctl_files, list) {
168	if (!ctl->subscribed)
169	continue;
170	spin_lock(lock: &ctl->read_lock);
171	list_for_each_entry(ev, &ctl->events, list) {
172	if (ev->id.numid == id->numid) {
173	ev->mask |= mask;
174	goto _found;
175	}
176	}
177	ev = kzalloc(size: sizeof(*ev), GFP_ATOMIC);
178	if (ev) {
179	ev->id = *id;
180	ev->mask = mask;
181	list_add_tail(new: &ev->list, head: &ctl->events);
182	} else {
183	dev_err(card->dev, "No memory available to allocate event\n");
184	}
185	_found:
186	wake_up(&ctl->change_sleep);
187	spin_unlock(lock: &ctl->read_lock);
188	snd_kill_fasync(fasync: ctl->fasync, SIGIO, POLL_IN);
189	}
190	read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
191	}
192	EXPORT_SYMBOL(snd_ctl_notify);
193
194	/**
195	* snd_ctl_notify_one - Send notification to user-space for a control change
196	* @card: the card to send notification
197	* @mask: the event mask, SNDRV_CTL_EVENT_*
198	* @kctl: the pointer with the control instance
199	* @ioff: the additional offset to the control index
200	*
201	* This function calls snd_ctl_notify() and does additional jobs
202	* like LED state changes.
203	*/
204	void snd_ctl_notify_one(struct snd_card *card, unsigned int mask,
205	struct snd_kcontrol *kctl, unsigned int ioff)
206	{
207	struct snd_ctl_elem_id id = kctl->id;
208	struct snd_ctl_layer_ops *lops;
209
210	id.index += ioff;
211	id.numid += ioff;
212	snd_ctl_notify(card, mask, &id);
213	down_read(sem: &snd_ctl_layer_rwsem);
214	for (lops = snd_ctl_layer; lops; lops = lops->next)
215	lops->lnotify(card, mask, kctl, ioff);
216	up_read(sem: &snd_ctl_layer_rwsem);
217	}
218	EXPORT_SYMBOL(snd_ctl_notify_one);
219
220	/**
221	* snd_ctl_new - create a new control instance with some elements
222	* @kctl: the pointer to store new control instance
223	* @count: the number of elements in this control
224	* @access: the default access flags for elements in this control
225	* @file: given when locking these elements
226	*
227	* Allocates a memory object for a new control instance. The instance has
228	* elements as many as the given number (@count). Each element has given
229	* access permissions (@access). Each element is locked when @file is given.
230	*
231	* Return: 0 on success, error code on failure
232	*/
233	static int snd_ctl_new(struct snd_kcontrol **kctl, unsigned int count,
234	unsigned int access, struct snd_ctl_file *file)
235	{
236	unsigned int idx;
237
238	if (count == 0 || count > MAX_CONTROL_COUNT)
239	return -EINVAL;
240
241	*kctl = kzalloc(struct_size(*kctl, vd, count), GFP_KERNEL);
242	if (!*kctl)
243	return -ENOMEM;
244
245	for (idx = 0; idx < count; idx++) {
246	(*kctl)->vd[idx].access = access;
247	(*kctl)->vd[idx].owner = file;
248	}
249	(*kctl)->count = count;
250
251	return 0;
252	}
253
254	/**
255	* snd_ctl_new1 - create a control instance from the template
256	* @ncontrol: the initialization record
257	* @private_data: the private data to set
258	*
259	* Allocates a new struct snd_kcontrol instance and initialize from the given
260	* template. When the access field of ncontrol is 0, it's assumed as
261	* READWRITE access. When the count field is 0, it's assumes as one.
262	*
263	* Return: The pointer of the newly generated instance, or %NULL on failure.
264	*/
265	struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
266	void *private_data)
267	{
268	struct snd_kcontrol *kctl;
269	unsigned int count;
270	unsigned int access;
271	int err;
272
273	if (snd_BUG_ON(!ncontrol || !ncontrol->info))
274	return NULL;
275
276	count = ncontrol->count;
277	if (count == 0)
278	count = 1;
279
280	access = ncontrol->access;
281	if (access == 0)
282	access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
283	access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE |
284	SNDRV_CTL_ELEM_ACCESS_VOLATILE |
285	SNDRV_CTL_ELEM_ACCESS_INACTIVE |
286	SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE |
287	SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND |
288	SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK |
289	SNDRV_CTL_ELEM_ACCESS_LED_MASK |
290	SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK);
291
292	err = snd_ctl_new(kctl: &kctl, count, access, NULL);
293	if (err < 0)
294	return NULL;
295
296	/* The 'numid' member is decided when calling snd_ctl_add(). */
297	kctl->id.iface = ncontrol->iface;
298	kctl->id.device = ncontrol->device;
299	kctl->id.subdevice = ncontrol->subdevice;
300	if (ncontrol->name) {
301	strscpy(p: kctl->id.name, q: ncontrol->name, size: sizeof(kctl->id.name));
302	if (strcmp(ncontrol->name, kctl->id.name) != 0)
303	pr_warn("ALSA: Control name '%s' truncated to '%s'\n",
304	ncontrol->name, kctl->id.name);
305	}
306	kctl->id.index = ncontrol->index;
307
308	kctl->info = ncontrol->info;
309	kctl->get = ncontrol->get;
310	kctl->put = ncontrol->put;
311	kctl->tlv.p = ncontrol->tlv.p;
312
313	kctl->private_value = ncontrol->private_value;
314	kctl->private_data = private_data;
315
316	return kctl;
317	}
318	EXPORT_SYMBOL(snd_ctl_new1);
319
320	/**
321	* snd_ctl_free_one - release the control instance
322	* @kcontrol: the control instance
323	*
324	* Releases the control instance created via snd_ctl_new()
325	* or snd_ctl_new1().
326	* Don't call this after the control was added to the card.
327	*/
328	void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
329	{
330	if (kcontrol) {
331	if (kcontrol->private_free)
332	kcontrol->private_free(kcontrol);
333	kfree(objp: kcontrol);
334	}
335	}
336	EXPORT_SYMBOL(snd_ctl_free_one);
337
338	static bool snd_ctl_remove_numid_conflict(struct snd_card *card,
339	unsigned int count)
340	{
341	struct snd_kcontrol *kctl;
342
343	/* Make sure that the ids assigned to the control do not wrap around */
344	if (card->last_numid >= UINT_MAX - count)
345	card->last_numid = 0;
346
347	list_for_each_entry(kctl, &card->controls, list) {
348	if (kctl->id.numid < card->last_numid + 1 + count &&
349	kctl->id.numid + kctl->count > card->last_numid + 1) {
350	card->last_numid = kctl->id.numid + kctl->count - 1;
351	return true;
352	}
353	}
354	return false;
355	}
356
357	static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
358	{
359	unsigned int iter = 100000;
360
361	while (snd_ctl_remove_numid_conflict(card, count)) {
362	if (--iter == 0) {
363	/* this situation is very unlikely */
364	dev_err(card->dev, "unable to allocate new control numid\n");
365	return -ENOMEM;
366	}
367	}
368	return 0;
369	}
370
371	/* check whether the given id is contained in the given kctl */
372	static bool elem_id_matches(const struct snd_kcontrol *kctl,
373	const struct snd_ctl_elem_id *id)
374	{
375	return kctl->id.iface == id->iface &&
376	kctl->id.device == id->device &&
377	kctl->id.subdevice == id->subdevice &&
378	!strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)) &&
379	kctl->id.index <= id->index &&
380	kctl->id.index + kctl->count > id->index;
381	}
382
383	#ifdef CONFIG_SND_CTL_FAST_LOOKUP
384	/* Compute a hash key for the corresponding ctl id
385	* It's for the name lookup, hence the numid is excluded.
386	* The hash key is bound in LONG_MAX to be used for Xarray key.
387	*/
388	#define MULTIPLIER 37
389	static unsigned long get_ctl_id_hash(const struct snd_ctl_elem_id *id)
390	{
391	int i;
392	unsigned long h;
393
394	h = id->iface;
395	h = MULTIPLIER * h + id->device;
396	h = MULTIPLIER * h + id->subdevice;
397	for (i = 0; i < SNDRV_CTL_ELEM_ID_NAME_MAXLEN && id->name[i]; i++)
398	h = MULTIPLIER * h + id->name[i];
399	h = MULTIPLIER * h + id->index;
400	h &= LONG_MAX;
401	return h;
402	}
403
404	/* add hash entries to numid and ctl xarray tables */
405	static void add_hash_entries(struct snd_card *card,
406	struct snd_kcontrol *kcontrol)
407	{
408	struct snd_ctl_elem_id id = kcontrol->id;
409	int i;
410
411	xa_store_range(&card->ctl_numids, first: kcontrol->id.numid,
412	last: kcontrol->id.numid + kcontrol->count - 1,
413	entry: kcontrol, GFP_KERNEL);
414
415	for (i = 0; i < kcontrol->count; i++) {
416	id.index = kcontrol->id.index + i;
417	if (xa_insert(xa: &card->ctl_hash, index: get_ctl_id_hash(id: &id),
418	entry: kcontrol, GFP_KERNEL)) {
419	/* skip hash for this entry, noting we had collision */
420	card->ctl_hash_collision = true;
421	dev_dbg(card->dev, "ctl_hash collision %d:%s:%d\n",
422	id.iface, id.name, id.index);
423	}
424	}
425	}
426
427	/* remove hash entries that have been added */
428	static void remove_hash_entries(struct snd_card *card,
429	struct snd_kcontrol *kcontrol)
430	{
431	struct snd_ctl_elem_id id = kcontrol->id;
432	struct snd_kcontrol *matched;
433	unsigned long h;
434	int i;
435
436	for (i = 0; i < kcontrol->count; i++) {
437	xa_erase(&card->ctl_numids, index: id.numid);
438	h = get_ctl_id_hash(id: &id);
439	matched = xa_load(&card->ctl_hash, index: h);
440	if (matched && (matched == kcontrol ||
441	elem_id_matches(kctl: matched, id: &id)))
442	xa_erase(&card->ctl_hash, index: h);
443	id.index++;
444	id.numid++;
445	}
446	}
447	#else /* CONFIG_SND_CTL_FAST_LOOKUP */
448	static inline void add_hash_entries(struct snd_card *card,
449	struct snd_kcontrol *kcontrol)
450	{
451	}
452	static inline void remove_hash_entries(struct snd_card *card,
453	struct snd_kcontrol *kcontrol)
454	{
455	}
456	#endif /* CONFIG_SND_CTL_FAST_LOOKUP */
457
458	enum snd_ctl_add_mode {
459	CTL_ADD_EXCLUSIVE, CTL_REPLACE, CTL_ADD_ON_REPLACE,
460	};
461
462	/* add/replace a new kcontrol object; call with card->controls_rwsem locked */
463	static int __snd_ctl_add_replace(struct snd_card *card,
464	struct snd_kcontrol *kcontrol,
465	enum snd_ctl_add_mode mode)
466	{
467	struct snd_ctl_elem_id id;
468	unsigned int idx;
469	struct snd_kcontrol *old;
470	int err;
471
472	lockdep_assert_held_write(&card->controls_rwsem);
473
474	id = kcontrol->id;
475	if (id.index > UINT_MAX - kcontrol->count)
476	return -EINVAL;
477
478	old = snd_ctl_find_id_locked(card, id: &id);
479	if (!old) {
480	if (mode == CTL_REPLACE)
481	return -EINVAL;
482	} else {
483	if (mode == CTL_ADD_EXCLUSIVE) {
484	dev_err(card->dev,
485	"control %i:%i:%i:%s:%i is already present\n",
486	id.iface, id.device, id.subdevice, id.name,
487	id.index);
488	return -EBUSY;
489	}
490
491	err = snd_ctl_remove_locked(card, kcontrol: old);
492	if (err < 0)
493	return err;
494	}
495
496	if (snd_ctl_find_hole(card, count: kcontrol->count) < 0)
497	return -ENOMEM;
498
499	list_add_tail(new: &kcontrol->list, head: &card->controls);
500	card->controls_count += kcontrol->count;
501	kcontrol->id.numid = card->last_numid + 1;
502	card->last_numid += kcontrol->count;
503
504	add_hash_entries(card, kcontrol);
505
506	for (idx = 0; idx < kcontrol->count; idx++)
507	snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_ADD, kcontrol, idx);
508
509	return 0;
510	}
511
512	static int snd_ctl_add_replace(struct snd_card *card,
513	struct snd_kcontrol *kcontrol,
514	enum snd_ctl_add_mode mode)
515	{
516	int err = -EINVAL;
517
518	if (! kcontrol)
519	return err;
520	if (snd_BUG_ON(!card || !kcontrol->info))
521	goto error;
522
523	down_write(sem: &card->controls_rwsem);
524	err = __snd_ctl_add_replace(card, kcontrol, mode);
525	up_write(sem: &card->controls_rwsem);
526	if (err < 0)
527	goto error;
528	return 0;
529
530	error:
531	snd_ctl_free_one(kcontrol);
532	return err;
533	}
534
535	/**
536	* snd_ctl_add - add the control instance to the card
537	* @card: the card instance
538	* @kcontrol: the control instance to add
539	*
540	* Adds the control instance created via snd_ctl_new() or
541	* snd_ctl_new1() to the given card. Assigns also an unique
542	* numid used for fast search.
543	*
544	* It frees automatically the control which cannot be added.
545	*
546	* Return: Zero if successful, or a negative error code on failure.
547	*
548	*/
549	int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
550	{
551	return snd_ctl_add_replace(card, kcontrol, mode: CTL_ADD_EXCLUSIVE);
552	}
553	EXPORT_SYMBOL(snd_ctl_add);
554
555	/**
556	* snd_ctl_replace - replace the control instance of the card
557	* @card: the card instance
558	* @kcontrol: the control instance to replace
559	* @add_on_replace: add the control if not already added
560	*
561	* Replaces the given control. If the given control does not exist
562	* and the add_on_replace flag is set, the control is added. If the
563	* control exists, it is destroyed first.
564	*
565	* It frees automatically the control which cannot be added or replaced.
566	*
567	* Return: Zero if successful, or a negative error code on failure.
568	*/
569	int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol,
570	bool add_on_replace)
571	{
572	return snd_ctl_add_replace(card, kcontrol,
573	mode: add_on_replace ? CTL_ADD_ON_REPLACE : CTL_REPLACE);
574	}
575	EXPORT_SYMBOL(snd_ctl_replace);
576
577	static int __snd_ctl_remove(struct snd_card *card,
578	struct snd_kcontrol *kcontrol,
579	bool remove_hash)
580	{
581	unsigned int idx;
582
583	lockdep_assert_held_write(&card->controls_rwsem);
584
585	if (snd_BUG_ON(!card || !kcontrol))
586	return -EINVAL;
587	list_del(entry: &kcontrol->list);
588
589	if (remove_hash)
590	remove_hash_entries(card, kcontrol);
591
592	card->controls_count -= kcontrol->count;
593	for (idx = 0; idx < kcontrol->count; idx++)
594	snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_REMOVE, kcontrol, idx);
595	snd_ctl_free_one(kcontrol);
596	return 0;
597	}
598
599	static inline int snd_ctl_remove_locked(struct snd_card *card,
600	struct snd_kcontrol *kcontrol)
601	{
602	return __snd_ctl_remove(card, kcontrol, remove_hash: true);
603	}
604
605	/**
606	* snd_ctl_remove - remove the control from the card and release it
607	* @card: the card instance
608	* @kcontrol: the control instance to remove
609	*
610	* Removes the control from the card and then releases the instance.
611	* You don't need to call snd_ctl_free_one().
612	*
613	* Return: 0 if successful, or a negative error code on failure.
614	*
615	* Note that this function takes card->controls_rwsem lock internally.
616	*/
617	int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
618	{
619	int ret;
620
621	down_write(sem: &card->controls_rwsem);
622	ret = snd_ctl_remove_locked(card, kcontrol);
623	up_write(sem: &card->controls_rwsem);
624	return ret;
625	}
626	EXPORT_SYMBOL(snd_ctl_remove);
627
628	/**
629	* snd_ctl_remove_id - remove the control of the given id and release it
630	* @card: the card instance
631	* @id: the control id to remove
632	*
633	* Finds the control instance with the given id, removes it from the
634	* card list and releases it.
635	*
636	* Return: 0 if successful, or a negative error code on failure.
637	*/
638	int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
639	{
640	struct snd_kcontrol *kctl;
641	int ret;
642
643	down_write(sem: &card->controls_rwsem);
644	kctl = snd_ctl_find_id_locked(card, id);
645	if (kctl == NULL) {
646	up_write(sem: &card->controls_rwsem);
647	return -ENOENT;
648	}
649	ret = snd_ctl_remove_locked(card, kcontrol: kctl);
650	up_write(sem: &card->controls_rwsem);
651	return ret;
652	}
653	EXPORT_SYMBOL(snd_ctl_remove_id);
654
655	/**
656	* snd_ctl_remove_user_ctl - remove and release the unlocked user control
657	* @file: active control handle
658	* @id: the control id to remove
659	*
660	* Finds the control instance with the given id, removes it from the
661	* card list and releases it.
662	*
663	* Return: 0 if successful, or a negative error code on failure.
664	*/
665	static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
666	struct snd_ctl_elem_id *id)
667	{
668	struct snd_card *card = file->card;
669	struct snd_kcontrol *kctl;
670	int idx, ret;
671
672	down_write(sem: &card->controls_rwsem);
673	kctl = snd_ctl_find_id_locked(card, id);
674	if (kctl == NULL) {
675	ret = -ENOENT;
676	goto error;
677	}
678	if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
679	ret = -EINVAL;
680	goto error;
681	}
682	for (idx = 0; idx < kctl->count; idx++)
683	if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
684	ret = -EBUSY;
685	goto error;
686	}
687	ret = snd_ctl_remove_locked(card, kcontrol: kctl);
688	error:
689	up_write(sem: &card->controls_rwsem);
690	return ret;
691	}
692
693	/**
694	* snd_ctl_activate_id - activate/inactivate the control of the given id
695	* @card: the card instance
696	* @id: the control id to activate/inactivate
697	* @active: non-zero to activate
698	*
699	* Finds the control instance with the given id, and activate or
700	* inactivate the control together with notification, if changed.
701	* The given ID data is filled with full information.
702	*
703	* Return: 0 if unchanged, 1 if changed, or a negative error code on failure.
704	*/
705	int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
706	int active)
707	{
708	struct snd_kcontrol *kctl;
709	struct snd_kcontrol_volatile *vd;
710	unsigned int index_offset;
711	int ret;
712
713	down_write(sem: &card->controls_rwsem);
714	kctl = snd_ctl_find_id_locked(card, id);
715	if (kctl == NULL) {
716	ret = -ENOENT;
717	goto unlock;
718	}
719	index_offset = snd_ctl_get_ioff(kctl, id);
720	vd = &kctl->vd[index_offset];
721	ret = 0;
722	if (active) {
723	if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE))
724	goto unlock;
725	vd->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
726	} else {
727	if (vd->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE)
728	goto unlock;
729	vd->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
730	}
731	snd_ctl_build_ioff(dst_id: id, src_kctl: kctl, offset: index_offset);
732	downgrade_write(sem: &card->controls_rwsem);
733	snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_INFO, kctl, index_offset);
734	up_read(sem: &card->controls_rwsem);
735	return 1;
736
737	unlock:
738	up_write(sem: &card->controls_rwsem);
739	return ret;
740	}
741	EXPORT_SYMBOL_GPL(snd_ctl_activate_id);
742
743	/**
744	* snd_ctl_rename_id - replace the id of a control on the card
745	* @card: the card instance
746	* @src_id: the old id
747	* @dst_id: the new id
748	*
749	* Finds the control with the old id from the card, and replaces the
750	* id with the new one.
751	*
752	* The function tries to keep the already assigned numid while replacing
753	* the rest.
754	*
755	* Note that this function should be used only in the card initialization
756	* phase. Calling after the card instantiation may cause issues with
757	* user-space expecting persistent numids.
758	*
759	* Return: Zero if successful, or a negative error code on failure.
760	*/
761	int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
762	struct snd_ctl_elem_id *dst_id)
763	{
764	struct snd_kcontrol *kctl;
765	int saved_numid;
766
767	down_write(sem: &card->controls_rwsem);
768	kctl = snd_ctl_find_id_locked(card, id: src_id);
769	if (kctl == NULL) {
770	up_write(sem: &card->controls_rwsem);
771	return -ENOENT;
772	}
773	saved_numid = kctl->id.numid;
774	remove_hash_entries(card, kcontrol: kctl);
775	kctl->id = *dst_id;
776	kctl->id.numid = saved_numid;
777	add_hash_entries(card, kcontrol: kctl);
778	up_write(sem: &card->controls_rwsem);
779	return 0;
780	}
781	EXPORT_SYMBOL(snd_ctl_rename_id);
782
783	/**
784	* snd_ctl_rename - rename the control on the card
785	* @card: the card instance
786	* @kctl: the control to rename
787	* @name: the new name
788	*
789	* Renames the specified control on the card to the new name.
790	*
791	* Note that this function takes card->controls_rwsem lock internally.
792	*/
793	void snd_ctl_rename(struct snd_card *card, struct snd_kcontrol *kctl,
794	const char *name)
795	{
796	down_write(sem: &card->controls_rwsem);
797	remove_hash_entries(card, kcontrol: kctl);
798
799	if (strscpy(p: kctl->id.name, q: name, size: sizeof(kctl->id.name)) < 0)
800	pr_warn("ALSA: Renamed control new name '%s' truncated to '%s'\n",
801	name, kctl->id.name);
802
803	add_hash_entries(card, kcontrol: kctl);
804	up_write(sem: &card->controls_rwsem);
805	}
806	EXPORT_SYMBOL(snd_ctl_rename);
807
808	#ifndef CONFIG_SND_CTL_FAST_LOOKUP
809	static struct snd_kcontrol *
810	snd_ctl_find_numid_slow(struct snd_card *card, unsigned int numid)
811	{
812	struct snd_kcontrol *kctl;
813
814	list_for_each_entry(kctl, &card->controls, list) {
815	if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
816	return kctl;
817	}
818	return NULL;
819	}
820	#endif /* !CONFIG_SND_CTL_FAST_LOOKUP */
821
822	/**
823	* snd_ctl_find_numid_locked - find the control instance with the given number-id
824	* @card: the card instance
825	* @numid: the number-id to search
826	*
827	* Finds the control instance with the given number-id from the card.
828	*
829	* The caller must down card->controls_rwsem before calling this function
830	* (if the race condition can happen).
831	*
832	* Return: The pointer of the instance if found, or %NULL if not.
833	*/
834	struct snd_kcontrol *
835	snd_ctl_find_numid_locked(struct snd_card *card, unsigned int numid)
836	{
837	if (snd_BUG_ON(!card || !numid))
838	return NULL;
839	lockdep_assert_held(&card->controls_rwsem);
840	#ifdef CONFIG_SND_CTL_FAST_LOOKUP
841	return xa_load(&card->ctl_numids, index: numid);
842	#else
843	return snd_ctl_find_numid_slow(card, numid);
844	#endif
845	}
846	EXPORT_SYMBOL(snd_ctl_find_numid_locked);
847
848	/**
849	* snd_ctl_find_numid - find the control instance with the given number-id
850	* @card: the card instance
851	* @numid: the number-id to search
852	*
853	* Finds the control instance with the given number-id from the card.
854	*
855	* Return: The pointer of the instance if found, or %NULL if not.
856	*
857	* Note that this function takes card->controls_rwsem lock internally.
858	*/
859	struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card,
860	unsigned int numid)
861	{
862	struct snd_kcontrol *kctl;
863
864	down_read(sem: &card->controls_rwsem);
865	kctl = snd_ctl_find_numid_locked(card, numid);
866	up_read(sem: &card->controls_rwsem);
867	return kctl;
868	}
869	EXPORT_SYMBOL(snd_ctl_find_numid);
870
871	/**
872	* snd_ctl_find_id_locked - find the control instance with the given id
873	* @card: the card instance
874	* @id: the id to search
875	*
876	* Finds the control instance with the given id from the card.
877	*
878	* The caller must down card->controls_rwsem before calling this function
879	* (if the race condition can happen).
880	*
881	* Return: The pointer of the instance if found, or %NULL if not.
882	*/
883	struct snd_kcontrol *snd_ctl_find_id_locked(struct snd_card *card,
884	const struct snd_ctl_elem_id *id)
885	{
886	struct snd_kcontrol *kctl;
887
888	if (snd_BUG_ON(!card || !id))
889	return NULL;
890	lockdep_assert_held(&card->controls_rwsem);
891	if (id->numid != 0)
892	return snd_ctl_find_numid_locked(card, id->numid);
893	#ifdef CONFIG_SND_CTL_FAST_LOOKUP
894	kctl = xa_load(&card->ctl_hash, index: get_ctl_id_hash(id));
895	if (kctl && elem_id_matches(kctl, id))
896	return kctl;
897	if (!card->ctl_hash_collision)
898	return NULL; /* we can rely on only hash table */
899	#endif
900	/* no matching in hash table - try all as the last resort */
901	list_for_each_entry(kctl, &card->controls, list)
902	if (elem_id_matches(kctl, id))
903	return kctl;
904
905	return NULL;
906	}
907	EXPORT_SYMBOL(snd_ctl_find_id_locked);
908
909	/**
910	* snd_ctl_find_id - find the control instance with the given id
911	* @card: the card instance
912	* @id: the id to search
913	*
914	* Finds the control instance with the given id from the card.
915	*
916	* Return: The pointer of the instance if found, or %NULL if not.
917	*
918	* Note that this function takes card->controls_rwsem lock internally.
919	*/
920	struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
921	const struct snd_ctl_elem_id *id)
922	{
923	struct snd_kcontrol *kctl;
924
925	down_read(sem: &card->controls_rwsem);
926	kctl = snd_ctl_find_id_locked(card, id);
927	up_read(sem: &card->controls_rwsem);
928	return kctl;
929	}
930	EXPORT_SYMBOL(snd_ctl_find_id);
931
932	static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
933	unsigned int cmd, void __user *arg)
934	{
935	struct snd_ctl_card_info *info;
936
937	info = kzalloc(size: sizeof(*info), GFP_KERNEL);
938	if (! info)
939	return -ENOMEM;
940	down_read(sem: &snd_ioctl_rwsem);
941	info->card = card->number;
942	strscpy(p: info->id, q: card->id, size: sizeof(info->id));
943	strscpy(p: info->driver, q: card->driver, size: sizeof(info->driver));
944	strscpy(p: info->name, q: card->shortname, size: sizeof(info->name));
945	strscpy(p: info->longname, q: card->longname, size: sizeof(info->longname));
946	strscpy(p: info->mixername, q: card->mixername, size: sizeof(info->mixername));
947	strscpy(p: info->components, q: card->components, size: sizeof(info->components));
948	up_read(sem: &snd_ioctl_rwsem);
949	if (copy_to_user(to: arg, from: info, n: sizeof(struct snd_ctl_card_info))) {
950	kfree(objp: info);
951	return -EFAULT;
952	}
953	kfree(objp: info);
954	return 0;
955	}
956
957	static int snd_ctl_elem_list(struct snd_card *card,
958	struct snd_ctl_elem_list *list)
959	{
960	struct snd_kcontrol *kctl;
961	struct snd_ctl_elem_id id;
962	unsigned int offset, space, jidx;
963	int err = 0;
964
965	offset = list->offset;
966	space = list->space;
967
968	down_read(sem: &card->controls_rwsem);
969	list->count = card->controls_count;
970	list->used = 0;
971	if (space > 0) {
972	list_for_each_entry(kctl, &card->controls, list) {
973	if (offset >= kctl->count) {
974	offset -= kctl->count;
975	continue;
976	}
977	for (jidx = offset; jidx < kctl->count; jidx++) {
978	snd_ctl_build_ioff(dst_id: &id, src_kctl: kctl, offset: jidx);
979	if (copy_to_user(to: list->pids + list->used, from: &id,
980	n: sizeof(id))) {
981	err = -EFAULT;
982	goto out;
983	}
984	list->used++;
985	if (!--space)
986	goto out;
987	}
988	offset = 0;
989	}
990	}
991	out:
992	up_read(sem: &card->controls_rwsem);
993	return err;
994	}
995
996	static int snd_ctl_elem_list_user(struct snd_card *card,
997	struct snd_ctl_elem_list __user *_list)
998	{
999	struct snd_ctl_elem_list list;
1000	int err;
1001
1002	if (copy_from_user(to: &list, from: _list, n: sizeof(list)))
1003	return -EFAULT;
1004	err = snd_ctl_elem_list(card, list: &list);
1005	if (err)
1006	return err;
1007	if (copy_to_user(to: _list, from: &list, n: sizeof(list)))
1008	return -EFAULT;
1009
1010	return 0;
1011	}
1012
1013	/* Check whether the given kctl info is valid */
1014	static int snd_ctl_check_elem_info(struct snd_card *card,
1015	const struct snd_ctl_elem_info *info)
1016	{
1017	static const unsigned int max_value_counts[] = {
1018	[SNDRV_CTL_ELEM_TYPE_BOOLEAN] = 128,
1019	[SNDRV_CTL_ELEM_TYPE_INTEGER] = 128,
1020	[SNDRV_CTL_ELEM_TYPE_ENUMERATED] = 128,
1021	[SNDRV_CTL_ELEM_TYPE_BYTES] = 512,
1022	[SNDRV_CTL_ELEM_TYPE_IEC958] = 1,
1023	[SNDRV_CTL_ELEM_TYPE_INTEGER64] = 64,
1024	};
1025
1026	if (info->type < SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
1027	info->type > SNDRV_CTL_ELEM_TYPE_INTEGER64) {
1028	if (card)
1029	dev_err(card->dev,
1030	"control %i:%i:%i:%s:%i: invalid type %d\n",
1031	info->id.iface, info->id.device,
1032	info->id.subdevice, info->id.name,
1033	info->id.index, info->type);
1034	return -EINVAL;
1035	}
1036	if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED &&
1037	info->value.enumerated.items == 0) {
1038	if (card)
1039	dev_err(card->dev,
1040	"control %i:%i:%i:%s:%i: zero enum items\n",
1041	info->id.iface, info->id.device,
1042	info->id.subdevice, info->id.name,
1043	info->id.index);
1044	return -EINVAL;
1045	}
1046	if (info->count > max_value_counts[info->type]) {
1047	if (card)
1048	dev_err(card->dev,
1049	"control %i:%i:%i:%s:%i: invalid count %d\n",
1050	info->id.iface, info->id.device,
1051	info->id.subdevice, info->id.name,
1052	info->id.index, info->count);
1053	return -EINVAL;
1054	}
1055
1056	return 0;
1057	}
1058
1059	/* The capacity of struct snd_ctl_elem_value.value.*/
1060	static const unsigned int value_sizes[] = {
1061	[SNDRV_CTL_ELEM_TYPE_BOOLEAN] = sizeof(long),
1062	[SNDRV_CTL_ELEM_TYPE_INTEGER] = sizeof(long),
1063	[SNDRV_CTL_ELEM_TYPE_ENUMERATED] = sizeof(unsigned int),
1064	[SNDRV_CTL_ELEM_TYPE_BYTES] = sizeof(unsigned char),
1065	[SNDRV_CTL_ELEM_TYPE_IEC958] = sizeof(struct snd_aes_iec958),
1066	[SNDRV_CTL_ELEM_TYPE_INTEGER64] = sizeof(long long),
1067	};
1068
1069	/* fill the remaining snd_ctl_elem_value data with the given pattern */
1070	static void fill_remaining_elem_value(struct snd_ctl_elem_value *control,
1071	struct snd_ctl_elem_info *info,
1072	u32 pattern)
1073	{
1074	size_t offset = value_sizes[info->type] * info->count;
1075
1076	offset = DIV_ROUND_UP(offset, sizeof(u32));
1077	memset32(s: (u32 *)control->value.bytes.data + offset, v: pattern,
1078	n: sizeof(control->value) / sizeof(u32) - offset);
1079	}
1080
1081	/* check whether the given integer ctl value is valid */
1082	static int sanity_check_int_value(struct snd_card *card,
1083	const struct snd_ctl_elem_value *control,
1084	const struct snd_ctl_elem_info *info,
1085	int i, bool print_error)
1086	{
1087	long long lval, lmin, lmax, lstep;
1088	u64 rem;
1089
1090	switch (info->type) {
1091	default:
1092	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1093	lval = control->value.integer.value[i];
1094	lmin = 0;
1095	lmax = 1;
1096	lstep = 0;
1097	break;
1098	case SNDRV_CTL_ELEM_TYPE_INTEGER:
1099	lval = control->value.integer.value[i];
1100	lmin = info->value.integer.min;
1101	lmax = info->value.integer.max;
1102	lstep = info->value.integer.step;
1103	break;
1104	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1105	lval = control->value.integer64.value[i];
1106	lmin = info->value.integer64.min;
1107	lmax = info->value.integer64.max;
1108	lstep = info->value.integer64.step;
1109	break;
1110	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
1111	lval = control->value.enumerated.item[i];
1112	lmin = 0;
1113	lmax = info->value.enumerated.items - 1;
1114	lstep = 0;
1115	break;
1116	}
1117
1118	if (lval < lmin || lval > lmax) {
1119	if (print_error)
1120	dev_err(card->dev,
1121	"control %i:%i:%i:%s:%i: value out of range %lld (%lld/%lld) at count %i\n",
1122	control->id.iface, control->id.device,
1123	control->id.subdevice, control->id.name,
1124	control->id.index, lval, lmin, lmax, i);
1125	return -EINVAL;
1126	}
1127	if (lstep) {
1128	div64_u64_rem(dividend: lval, divisor: lstep, remainder: &rem);
1129	if (rem) {
1130	if (print_error)
1131	dev_err(card->dev,
1132	"control %i:%i:%i:%s:%i: unaligned value %lld (step %lld) at count %i\n",
1133	control->id.iface, control->id.device,
1134	control->id.subdevice, control->id.name,
1135	control->id.index, lval, lstep, i);
1136	return -EINVAL;
1137	}
1138	}
1139
1140	return 0;
1141	}
1142
1143	/* check whether the all input values are valid for the given elem value */
1144	static int sanity_check_input_values(struct snd_card *card,
1145	const struct snd_ctl_elem_value *control,
1146	const struct snd_ctl_elem_info *info,
1147	bool print_error)
1148	{
1149	int i, ret;
1150
1151	switch (info->type) {
1152	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
1153	case SNDRV_CTL_ELEM_TYPE_INTEGER:
1154	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
1155	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
1156	for (i = 0; i < info->count; i++) {
1157	ret = sanity_check_int_value(card, control, info, i,
1158	print_error);
1159	if (ret < 0)
1160	return ret;
1161	}
1162	break;
1163	default:
1164	break;
1165	}
1166
1167	return 0;
1168	}
1169
1170	/* perform sanity checks to the given snd_ctl_elem_value object */
1171	static int sanity_check_elem_value(struct snd_card *card,
1172	const struct snd_ctl_elem_value *control,
1173	const struct snd_ctl_elem_info *info,
1174	u32 pattern)
1175	{
1176	size_t offset;
1177	int ret;
1178	u32 *p;
1179
1180	ret = sanity_check_input_values(card, control, info, print_error: true);
1181	if (ret < 0)
1182	return ret;
1183
1184	/* check whether the remaining area kept untouched */
1185	offset = value_sizes[info->type] * info->count;
1186	offset = DIV_ROUND_UP(offset, sizeof(u32));
1187	p = (u32 *)control->value.bytes.data + offset;
1188	for (; offset < sizeof(control->value) / sizeof(u32); offset++, p++) {
1189	if (*p != pattern) {
1190	ret = -EINVAL;
1191	break;
1192	}
1193	*p = 0; /* clear the checked area */
1194	}
1195
1196	return ret;
1197	}
1198
1199	static int __snd_ctl_elem_info(struct snd_card *card,
1200	struct snd_kcontrol *kctl,
1201	struct snd_ctl_elem_info *info,
1202	struct snd_ctl_file *ctl)
1203	{
1204	struct snd_kcontrol_volatile *vd;
1205	unsigned int index_offset;
1206	int result;
1207
1208	#ifdef CONFIG_SND_DEBUG
1209	info->access = 0;
1210	#endif
1211	result = snd_power_ref_and_wait(card);
1212	if (!result)
1213	result = kctl->info(kctl, info);
1214	snd_power_unref(card);
1215	if (result >= 0) {
1216	snd_BUG_ON(info->access);
1217	index_offset = snd_ctl_get_ioff(kctl, id: &info->id);
1218	vd = &kctl->vd[index_offset];
1219	snd_ctl_build_ioff(dst_id: &info->id, src_kctl: kctl, offset: index_offset);
1220	info->access = vd->access;
1221	if (vd->owner) {
1222	info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
1223	if (vd->owner == ctl)
1224	info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
1225	info->owner = pid_vnr(pid: vd->owner->pid);
1226	} else {
1227	info->owner = -1;
1228	}
1229	if (!snd_ctl_skip_validation(info) &&
1230	snd_ctl_check_elem_info(card, info) < 0)
1231	result = -EINVAL;
1232	}
1233	return result;
1234	}
1235
1236	static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
1237	struct snd_ctl_elem_info *info)
1238	{
1239	struct snd_card *card = ctl->card;
1240	struct snd_kcontrol *kctl;
1241	int result;
1242
1243	down_read(sem: &card->controls_rwsem);
1244	kctl = snd_ctl_find_id_locked(card, &info->id);
1245	if (kctl == NULL)
1246	result = -ENOENT;
1247	else
1248	result = __snd_ctl_elem_info(card, kctl, info, ctl);
1249	up_read(sem: &card->controls_rwsem);
1250	return result;
1251	}
1252
1253	static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
1254	struct snd_ctl_elem_info __user *_info)
1255	{
1256	struct snd_ctl_elem_info info;
1257	int result;
1258
1259	if (copy_from_user(to: &info, from: _info, n: sizeof(info)))
1260	return -EFAULT;
1261	result = snd_ctl_elem_info(ctl, info: &info);
1262	if (result < 0)
1263	return result;
1264	/* drop internal access flags */
1265	info.access &= ~(SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK|
1266	SNDRV_CTL_ELEM_ACCESS_LED_MASK);
1267	if (copy_to_user(to: _info, from: &info, n: sizeof(info)))
1268	return -EFAULT;
1269	return result;
1270	}
1271
1272	static int snd_ctl_elem_read(struct snd_card *card,
1273	struct snd_ctl_elem_value *control)
1274	{
1275	struct snd_kcontrol *kctl;
1276	struct snd_kcontrol_volatile *vd;
1277	unsigned int index_offset;
1278	struct snd_ctl_elem_info info;
1279	const u32 pattern = 0xdeadbeef;
1280	int ret;
1281
1282	down_read(sem: &card->controls_rwsem);
1283	kctl = snd_ctl_find_id_locked(card, &control->id);
1284	if (kctl == NULL) {
1285	ret = -ENOENT;
1286	goto unlock;
1287	}
1288
1289	index_offset = snd_ctl_get_ioff(kctl, id: &control->id);
1290	vd = &kctl->vd[index_offset];
1291	if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_READ) || kctl->get == NULL) {
1292	ret = -EPERM;
1293	goto unlock;
1294	}
1295
1296	snd_ctl_build_ioff(dst_id: &control->id, src_kctl: kctl, offset: index_offset);
1297
1298	#ifdef CONFIG_SND_CTL_DEBUG
1299	/* info is needed only for validation */
1300	memset(&info, 0, sizeof(info));
1301	info.id = control->id;
1302	ret = __snd_ctl_elem_info(card, kctl, info: &info, NULL);
1303	if (ret < 0)
1304	goto unlock;
1305	#endif
1306
1307	if (!snd_ctl_skip_validation(&info))
1308	fill_remaining_elem_value(control, info: &info, pattern);
1309	ret = snd_power_ref_and_wait(card);
1310	if (!ret)
1311	ret = kctl->get(kctl, control);
1312	snd_power_unref(card);
1313	if (ret < 0)
1314	goto unlock;
1315	if (!snd_ctl_skip_validation(&info) &&
1316	sanity_check_elem_value(card, control, info: &info, pattern) < 0) {
1317	dev_err(card->dev,
1318	"control %i:%i:%i:%s:%i: access overflow\n",
1319	control->id.iface, control->id.device,
1320	control->id.subdevice, control->id.name,
1321	control->id.index);
1322	ret = -EINVAL;
1323	goto unlock;
1324	}
1325	unlock:
1326	up_read(sem: &card->controls_rwsem);
1327	return ret;
1328	}
1329
1330	static int snd_ctl_elem_read_user(struct snd_card *card,
1331	struct snd_ctl_elem_value __user *_control)
1332	{
1333	struct snd_ctl_elem_value *control;
1334	int result;
1335
1336	control = memdup_user(_control, sizeof(*control));
1337	if (IS_ERR(ptr: control))
1338	return PTR_ERR(ptr: control);
1339
1340	result = snd_ctl_elem_read(card, control);
1341	if (result < 0)
1342	goto error;
1343
1344	if (copy_to_user(to: _control, from: control, n: sizeof(*control)))
1345	result = -EFAULT;
1346	error:
1347	kfree(objp: control);
1348	return result;
1349	}
1350
1351	static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
1352	struct snd_ctl_elem_value *control)
1353	{
1354	struct snd_kcontrol *kctl;
1355	struct snd_kcontrol_volatile *vd;
1356	unsigned int index_offset;
1357	int result;
1358
1359	down_write(sem: &card->controls_rwsem);
1360	kctl = snd_ctl_find_id_locked(card, &control->id);
1361	if (kctl == NULL) {
1362	up_write(sem: &card->controls_rwsem);
1363	return -ENOENT;
1364	}
1365
1366	index_offset = snd_ctl_get_ioff(kctl, id: &control->id);
1367	vd = &kctl->vd[index_offset];
1368	if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) || kctl->put == NULL ||
1369	(file && vd->owner && vd->owner != file)) {
1370	up_write(sem: &card->controls_rwsem);
1371	return -EPERM;
1372	}
1373
1374	snd_ctl_build_ioff(dst_id: &control->id, src_kctl: kctl, offset: index_offset);
1375	result = snd_power_ref_and_wait(card);
1376	/* validate input values */
1377	if (IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION) && !result) {
1378	struct snd_ctl_elem_info info;
1379
1380	memset(&info, 0, sizeof(info));
1381	info.id = control->id;
1382	result = __snd_ctl_elem_info(card, kctl, info: &info, NULL);
1383	if (!result)
1384	result = sanity_check_input_values(card, control, info: &info,
1385	print_error: false);
1386	}
1387	if (!result)
1388	result = kctl->put(kctl, control);
1389	snd_power_unref(card);
1390	if (result < 0) {
1391	up_write(sem: &card->controls_rwsem);
1392	return result;
1393	}
1394
1395	if (result > 0) {
1396	downgrade_write(sem: &card->controls_rwsem);
1397	snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, index_offset);
1398	up_read(sem: &card->controls_rwsem);
1399	} else {
1400	up_write(sem: &card->controls_rwsem);
1401	}
1402
1403	return 0;
1404	}
1405
1406	static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
1407	struct snd_ctl_elem_value __user *_control)
1408	{
1409	struct snd_ctl_elem_value *control;
1410	struct snd_card *card;
1411	int result;
1412
1413	control = memdup_user(_control, sizeof(*control));
1414	if (IS_ERR(ptr: control))
1415	return PTR_ERR(ptr: control);
1416
1417	card = file->card;
1418	result = snd_ctl_elem_write(card, file, control);
1419	if (result < 0)
1420	goto error;
1421
1422	if (copy_to_user(to: _control, from: control, n: sizeof(*control)))
1423	result = -EFAULT;
1424	error:
1425	kfree(objp: control);
1426	return result;
1427	}
1428
1429	static int snd_ctl_elem_lock(struct snd_ctl_file *file,
1430	struct snd_ctl_elem_id __user *_id)
1431	{
1432	struct snd_card *card = file->card;
1433	struct snd_ctl_elem_id id;
1434	struct snd_kcontrol *kctl;
1435	struct snd_kcontrol_volatile *vd;
1436	int result;
1437
1438	if (copy_from_user(to: &id, from: _id, n: sizeof(id)))
1439	return -EFAULT;
1440	down_write(sem: &card->controls_rwsem);
1441	kctl = snd_ctl_find_id_locked(card, &id);
1442	if (kctl == NULL) {
1443	result = -ENOENT;
1444	} else {
1445	vd = &kctl->vd[snd_ctl_get_ioff(kctl, id: &id)];
1446	if (vd->owner != NULL)
1447	result = -EBUSY;
1448	else {
1449	vd->owner = file;
1450	result = 0;
1451	}
1452	}
1453	up_write(sem: &card->controls_rwsem);
1454	return result;
1455	}
1456
1457	static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
1458	struct snd_ctl_elem_id __user *_id)
1459	{
1460	struct snd_card *card = file->card;
1461	struct snd_ctl_elem_id id;
1462	struct snd_kcontrol *kctl;
1463	struct snd_kcontrol_volatile *vd;
1464	int result;
1465
1466	if (copy_from_user(to: &id, from: _id, n: sizeof(id)))
1467	return -EFAULT;
1468	down_write(sem: &card->controls_rwsem);
1469	kctl = snd_ctl_find_id_locked(card, &id);
1470	if (kctl == NULL) {
1471	result = -ENOENT;
1472	} else {
1473	vd = &kctl->vd[snd_ctl_get_ioff(kctl, id: &id)];
1474	if (vd->owner == NULL)
1475	result = -EINVAL;
1476	else if (vd->owner != file)
1477	result = -EPERM;
1478	else {
1479	vd->owner = NULL;
1480	result = 0;
1481	}
1482	}
1483	up_write(sem: &card->controls_rwsem);
1484	return result;
1485	}
1486
1487	struct user_element {
1488	struct snd_ctl_elem_info info;
1489	struct snd_card *card;
1490	char *elem_data; /* element data */
1491	unsigned long elem_data_size; /* size of element data in bytes */
1492	void *tlv_data; /* TLV data */
1493	unsigned long tlv_data_size; /* TLV data size */
1494	void *priv_data; /* private data (like strings for enumerated type) */
1495	};
1496
1497	// check whether the addition (in bytes) of user ctl element may overflow the limit.
1498	static bool check_user_elem_overflow(struct snd_card *card, ssize_t add)
1499	{
1500	return (ssize_t)card->user_ctl_alloc_size + add > max_user_ctl_alloc_size;
1501	}
1502
1503	static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
1504	struct snd_ctl_elem_info *uinfo)
1505	{
1506	struct user_element *ue = kcontrol->private_data;
1507	unsigned int offset;
1508
1509	offset = snd_ctl_get_ioff(kctl: kcontrol, id: &uinfo->id);
1510	*uinfo = ue->info;
1511	snd_ctl_build_ioff(dst_id: &uinfo->id, src_kctl: kcontrol, offset);
1512
1513	return 0;
1514	}
1515
1516	static int snd_ctl_elem_user_enum_info(struct snd_kcontrol *kcontrol,
1517	struct snd_ctl_elem_info *uinfo)
1518	{
1519	struct user_element *ue = kcontrol->private_data;
1520	const char *names;
1521	unsigned int item;
1522	unsigned int offset;
1523
1524	item = uinfo->value.enumerated.item;
1525
1526	offset = snd_ctl_get_ioff(kctl: kcontrol, id: &uinfo->id);
1527	*uinfo = ue->info;
1528	snd_ctl_build_ioff(dst_id: &uinfo->id, src_kctl: kcontrol, offset);
1529
1530	item = min(item, uinfo->value.enumerated.items - 1);
1531	uinfo->value.enumerated.item = item;
1532
1533	names = ue->priv_data;
1534	for (; item > 0; --item)
1535	names += strlen(names) + 1;
1536	strcpy(p: uinfo->value.enumerated.name, q: names);
1537
1538	return 0;
1539	}
1540
1541	static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
1542	struct snd_ctl_elem_value *ucontrol)
1543	{
1544	struct user_element *ue = kcontrol->private_data;
1545	unsigned int size = ue->elem_data_size;
1546	char *src = ue->elem_data +
1547	snd_ctl_get_ioff(kctl: kcontrol, id: &ucontrol->id) * size;
1548
1549	memcpy(&ucontrol->value, src, size);
1550	return 0;
1551	}
1552
1553	static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
1554	struct snd_ctl_elem_value *ucontrol)
1555	{
1556	int change;
1557	struct user_element *ue = kcontrol->private_data;
1558	unsigned int size = ue->elem_data_size;
1559	char *dst = ue->elem_data +
1560	snd_ctl_get_ioff(kctl: kcontrol, id: &ucontrol->id) * size;
1561
1562	change = memcmp(p: &ucontrol->value, q: dst, size) != 0;
1563	if (change)
1564	memcpy(dst, &ucontrol->value, size);
1565	return change;
1566	}
1567
1568	/* called in controls_rwsem write lock */
1569	static int replace_user_tlv(struct snd_kcontrol *kctl, unsigned int __user *buf,
1570	unsigned int size)
1571	{
1572	struct user_element *ue = kctl->private_data;
1573	unsigned int *container;
1574	unsigned int mask = 0;
1575	int i;
1576	int change;
1577
1578	lockdep_assert_held_write(&ue->card->controls_rwsem);
1579
1580	if (size > 1024 * 128) /* sane value */
1581	return -EINVAL;
1582
1583	// does the TLV size change cause overflow?
1584	if (check_user_elem_overflow(card: ue->card, add: (ssize_t)(size - ue->tlv_data_size)))
1585	return -ENOMEM;
1586
1587	container = vmemdup_user(buf, size);
1588	if (IS_ERR(ptr: container))
1589	return PTR_ERR(ptr: container);
1590
1591	change = ue->tlv_data_size != size;
1592	if (!change)
1593	change = memcmp(p: ue->tlv_data, q: container, size) != 0;
1594	if (!change) {
1595	kvfree(addr: container);
1596	return 0;
1597	}
1598
1599	if (ue->tlv_data == NULL) {
1600	/* Now TLV data is available. */
1601	for (i = 0; i < kctl->count; ++i)
1602	kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1603	mask = SNDRV_CTL_EVENT_MASK_INFO;
1604	} else {
1605	ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
1606	ue->tlv_data_size = 0;
1607	kvfree(addr: ue->tlv_data);
1608	}
1609
1610	ue->tlv_data = container;
1611	ue->tlv_data_size = size;
1612	// decremented at private_free.
1613	ue->card->user_ctl_alloc_size += size;
1614
1615	mask |= SNDRV_CTL_EVENT_MASK_TLV;
1616	for (i = 0; i < kctl->count; ++i)
1617	snd_ctl_notify_one(ue->card, mask, kctl, i);
1618
1619	return change;
1620	}
1621
1622	static int read_user_tlv(struct snd_kcontrol *kctl, unsigned int __user *buf,
1623	unsigned int size)
1624	{
1625	struct user_element *ue = kctl->private_data;
1626
1627	if (ue->tlv_data_size == 0 || ue->tlv_data == NULL)
1628	return -ENXIO;
1629
1630	if (size < ue->tlv_data_size)
1631	return -ENOSPC;
1632
1633	if (copy_to_user(to: buf, from: ue->tlv_data, n: ue->tlv_data_size))
1634	return -EFAULT;
1635
1636	return 0;
1637	}
1638
1639	static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kctl, int op_flag,
1640	unsigned int size, unsigned int __user *buf)
1641	{
1642	if (op_flag == SNDRV_CTL_TLV_OP_WRITE)
1643	return replace_user_tlv(kctl, buf, size);
1644	else
1645	return read_user_tlv(kctl, buf, size);
1646	}
1647
1648	/* called in controls_rwsem write lock */
1649	static int snd_ctl_elem_init_enum_names(struct user_element *ue)
1650	{
1651	char *names, *p;
1652	size_t buf_len, name_len;
1653	unsigned int i;
1654	const uintptr_t user_ptrval = ue->info.value.enumerated.names_ptr;
1655
1656	lockdep_assert_held_write(&ue->card->controls_rwsem);
1657
1658	buf_len = ue->info.value.enumerated.names_length;
1659	if (buf_len > 64 * 1024)
1660	return -EINVAL;
1661
1662	if (check_user_elem_overflow(card: ue->card, add: buf_len))
1663	return -ENOMEM;
1664	names = vmemdup_user((const void __user *)user_ptrval, buf_len);
1665	if (IS_ERR(ptr: names))
1666	return PTR_ERR(ptr: names);
1667
1668	/* check that there are enough valid names */
1669	p = names;
1670	for (i = 0; i < ue->info.value.enumerated.items; ++i) {
1671	name_len = strnlen(p, maxlen: buf_len);
1672	if (name_len == 0 || name_len >= 64 || name_len == buf_len) {
1673	kvfree(addr: names);
1674	return -EINVAL;
1675	}
1676	p += name_len + 1;
1677	buf_len -= name_len + 1;
1678	}
1679
1680	ue->priv_data = names;
1681	ue->info.value.enumerated.names_ptr = 0;
1682	// increment the allocation size; decremented again at private_free.
1683	ue->card->user_ctl_alloc_size += ue->info.value.enumerated.names_length;
1684
1685	return 0;
1686	}
1687
1688	static size_t compute_user_elem_size(size_t size, unsigned int count)
1689	{
1690	return sizeof(struct user_element) + size * count;
1691	}
1692
1693	static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
1694	{
1695	struct user_element *ue = kcontrol->private_data;
1696
1697	// decrement the allocation size.
1698	ue->card->user_ctl_alloc_size -= compute_user_elem_size(size: ue->elem_data_size, count: kcontrol->count);
1699	ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
1700	if (ue->priv_data)
1701	ue->card->user_ctl_alloc_size -= ue->info.value.enumerated.names_length;
1702
1703	kvfree(addr: ue->tlv_data);
1704	kvfree(addr: ue->priv_data);
1705	kfree(objp: ue);
1706	}
1707
1708	static int snd_ctl_elem_add(struct snd_ctl_file *file,
1709	struct snd_ctl_elem_info *info, int replace)
1710	{
1711	struct snd_card *card = file->card;
1712	struct snd_kcontrol *kctl;
1713	unsigned int count;
1714	unsigned int access;
1715	long private_size;
1716	size_t alloc_size;
1717	struct user_element *ue;
1718	unsigned int offset;
1719	int err;
1720
1721	if (!*info->id.name)
1722	return -EINVAL;
1723	if (strnlen(p: info->id.name, maxlen: sizeof(info->id.name)) >= sizeof(info->id.name))
1724	return -EINVAL;
1725
1726	/* Delete a control to replace them if needed. */
1727	if (replace) {
1728	info->id.numid = 0;
1729	err = snd_ctl_remove_user_ctl(file, id: &info->id);
1730	if (err)
1731	return err;
1732	}
1733
1734	/* Check the number of elements for this userspace control. */
1735	count = info->owner;
1736	if (count == 0)
1737	count = 1;
1738
1739	/* Arrange access permissions if needed. */
1740	access = info->access;
1741	if (access == 0)
1742	access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1743	access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1744	SNDRV_CTL_ELEM_ACCESS_INACTIVE |
1745	SNDRV_CTL_ELEM_ACCESS_TLV_WRITE);
1746
1747	/* In initial state, nothing is available as TLV container. */
1748	if (access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
1749	access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1750	access |= SNDRV_CTL_ELEM_ACCESS_USER;
1751
1752	/*
1753	* Check information and calculate the size of data specific to
1754	* this userspace control.
1755	*/
1756	/* pass NULL to card for suppressing error messages */
1757	err = snd_ctl_check_elem_info(NULL, info);
1758	if (err < 0)
1759	return err;
1760	/* user-space control doesn't allow zero-size data */
1761	if (info->count < 1)
1762	return -EINVAL;
1763	private_size = value_sizes[info->type] * info->count;
1764	alloc_size = compute_user_elem_size(size: private_size, count);
1765
1766	down_write(sem: &card->controls_rwsem);
1767	if (check_user_elem_overflow(card, add: alloc_size)) {
1768	err = -ENOMEM;
1769	goto unlock;
1770	}
1771
1772	/*
1773	* Keep memory object for this userspace control. After passing this
1774	* code block, the instance should be freed by snd_ctl_free_one().
1775	*
1776	* Note that these elements in this control are locked.
1777	*/
1778	err = snd_ctl_new(kctl: &kctl, count, access, file);
1779	if (err < 0)
1780	goto unlock;
1781	memcpy(&kctl->id, &info->id, sizeof(kctl->id));
1782	ue = kzalloc(size: alloc_size, GFP_KERNEL);
1783	if (!ue) {
1784	kfree(objp: kctl);
1785	err = -ENOMEM;
1786	goto unlock;
1787	}
1788	kctl->private_data = ue;
1789	kctl->private_free = snd_ctl_elem_user_free;
1790
1791	// increment the allocated size; decremented again at private_free.
1792	card->user_ctl_alloc_size += alloc_size;
1793
1794	/* Set private data for this userspace control. */
1795	ue->card = card;
1796	ue->info = *info;
1797	ue->info.access = 0;
1798	ue->elem_data = (char *)ue + sizeof(*ue);
1799	ue->elem_data_size = private_size;
1800	if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
1801	err = snd_ctl_elem_init_enum_names(ue);
1802	if (err < 0) {
1803	snd_ctl_free_one(kctl);
1804	goto unlock;
1805	}
1806	}
1807
1808	/* Set callback functions. */
1809	if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED)
1810	kctl->info = snd_ctl_elem_user_enum_info;
1811	else
1812	kctl->info = snd_ctl_elem_user_info;
1813	if (access & SNDRV_CTL_ELEM_ACCESS_READ)
1814	kctl->get = snd_ctl_elem_user_get;
1815	if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
1816	kctl->put = snd_ctl_elem_user_put;
1817	if (access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
1818	kctl->tlv.c = snd_ctl_elem_user_tlv;
1819
1820	/* This function manage to free the instance on failure. */
1821	err = __snd_ctl_add_replace(card, kcontrol: kctl, mode: CTL_ADD_EXCLUSIVE);
1822	if (err < 0) {
1823	snd_ctl_free_one(kctl);
1824	goto unlock;
1825	}
1826	offset = snd_ctl_get_ioff(kctl, id: &info->id);
1827	snd_ctl_build_ioff(dst_id: &info->id, src_kctl: kctl, offset);
1828	/*
1829	* Here we cannot fill any field for the number of elements added by
1830	* this operation because there're no specific fields. The usage of
1831	* 'owner' field for this purpose may cause any bugs to userspace
1832	* applications because the field originally means PID of a process
1833	* which locks the element.
1834	*/
1835	unlock:
1836	up_write(sem: &card->controls_rwsem);
1837	return err;
1838	}
1839
1840	static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
1841	struct snd_ctl_elem_info __user *_info, int replace)
1842	{
1843	struct snd_ctl_elem_info info;
1844	int err;
1845
1846	if (copy_from_user(to: &info, from: _info, n: sizeof(info)))
1847	return -EFAULT;
1848	err = snd_ctl_elem_add(file, info: &info, replace);
1849	if (err < 0)
1850	return err;
1851	if (copy_to_user(to: _info, from: &info, n: sizeof(info))) {
1852	snd_ctl_remove_user_ctl(file, id: &info.id);
1853	return -EFAULT;
1854	}
1855
1856	return 0;
1857	}
1858
1859	static int snd_ctl_elem_remove(struct snd_ctl_file *file,
1860	struct snd_ctl_elem_id __user *_id)
1861	{
1862	struct snd_ctl_elem_id id;
1863
1864	if (copy_from_user(to: &id, from: _id, n: sizeof(id)))
1865	return -EFAULT;
1866	return snd_ctl_remove_user_ctl(file, id: &id);
1867	}
1868
1869	static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
1870	{
1871	int subscribe;
1872	if (get_user(subscribe, ptr))
1873	return -EFAULT;
1874	if (subscribe < 0) {
1875	subscribe = file->subscribed;
1876	if (put_user(subscribe, ptr))
1877	return -EFAULT;
1878	return 0;
1879	}
1880	if (subscribe) {
1881	file->subscribed = 1;
1882	return 0;
1883	} else if (file->subscribed) {
1884	snd_ctl_empty_read_queue(ctl: file);
1885	file->subscribed = 0;
1886	}
1887	return 0;
1888	}
1889
1890	static int call_tlv_handler(struct snd_ctl_file *file, int op_flag,
1891	struct snd_kcontrol *kctl,
1892	struct snd_ctl_elem_id *id,
1893	unsigned int __user *buf, unsigned int size)
1894	{
1895	static const struct {
1896	int op;
1897	int perm;
1898	} pairs[] = {
1899	{SNDRV_CTL_TLV_OP_READ, SNDRV_CTL_ELEM_ACCESS_TLV_READ},
1900	{SNDRV_CTL_TLV_OP_WRITE, SNDRV_CTL_ELEM_ACCESS_TLV_WRITE},
1901	{SNDRV_CTL_TLV_OP_CMD, SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND},
1902	};
1903	struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)];
1904	int i, ret;
1905
1906	/* Check support of the request for this element. */
1907	for (i = 0; i < ARRAY_SIZE(pairs); ++i) {
1908	if (op_flag == pairs[i].op && (vd->access & pairs[i].perm))
1909	break;
1910	}
1911	if (i == ARRAY_SIZE(pairs))
1912	return -ENXIO;
1913
1914	if (kctl->tlv.c == NULL)
1915	return -ENXIO;
1916
1917	/* Write and command operations are not allowed for locked element. */
1918	if (op_flag != SNDRV_CTL_TLV_OP_READ &&
1919	vd->owner != NULL && vd->owner != file)
1920	return -EPERM;
1921
1922	ret = snd_power_ref_and_wait(card: file->card);
1923	if (!ret)
1924	ret = kctl->tlv.c(kctl, op_flag, size, buf);
1925	snd_power_unref(card: file->card);
1926	return ret;
1927	}
1928
1929	static int read_tlv_buf(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id,
1930	unsigned int __user *buf, unsigned int size)
1931	{
1932	struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)];
1933	unsigned int len;
1934
1935	if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ))
1936	return -ENXIO;
1937
1938	if (kctl->tlv.p == NULL)
1939	return -ENXIO;
1940
1941	len = sizeof(unsigned int) * 2 + kctl->tlv.p[1];
1942	if (size < len)
1943	return -ENOMEM;
1944
1945	if (copy_to_user(to: buf, from: kctl->tlv.p, n: len))
1946	return -EFAULT;
1947
1948	return 0;
1949	}
1950
1951	static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
1952	struct snd_ctl_tlv __user *buf,
1953	int op_flag)
1954	{
1955	struct snd_ctl_tlv header;
1956	unsigned int __user *container;
1957	unsigned int container_size;
1958	struct snd_kcontrol *kctl;
1959	struct snd_ctl_elem_id id;
1960	struct snd_kcontrol_volatile *vd;
1961
1962	lockdep_assert_held(&file->card->controls_rwsem);
1963
1964	if (copy_from_user(to: &header, from: buf, n: sizeof(header)))
1965	return -EFAULT;
1966
1967	/* In design of control core, numerical ID starts at 1. */
1968	if (header.numid == 0)
1969	return -EINVAL;
1970
1971	/* At least, container should include type and length fields. */
1972	if (header.length < sizeof(unsigned int) * 2)
1973	return -EINVAL;
1974	container_size = header.length;
1975	container = buf->tlv;
1976
1977	kctl = snd_ctl_find_numid_locked(file->card, header.numid);
1978	if (kctl == NULL)
1979	return -ENOENT;
1980
1981	/* Calculate index of the element in this set. */
1982	id = kctl->id;
1983	snd_ctl_build_ioff(dst_id: &id, src_kctl: kctl, offset: header.numid - id.numid);
1984	vd = &kctl->vd[snd_ctl_get_ioff(kctl, id: &id)];
1985
1986	if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1987	return call_tlv_handler(file, op_flag, kctl, id: &id, buf: container,
1988	size: container_size);
1989	} else {
1990	if (op_flag == SNDRV_CTL_TLV_OP_READ) {
1991	return read_tlv_buf(kctl, id: &id, buf: container,
1992	size: container_size);
1993	}
1994	}
1995
1996	/* Not supported. */
1997	return -ENXIO;
1998	}
1999
2000	static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2001	{
2002	struct snd_ctl_file *ctl;
2003	struct snd_card *card;
2004	struct snd_kctl_ioctl *p;
2005	void __user *argp = (void __user *)arg;
2006	int __user *ip = argp;
2007	int err;
2008
2009	ctl = file->private_data;
2010	card = ctl->card;
2011	if (snd_BUG_ON(!card))
2012	return -ENXIO;
2013	switch (cmd) {
2014	case SNDRV_CTL_IOCTL_PVERSION:
2015	return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
2016	case SNDRV_CTL_IOCTL_CARD_INFO:
2017	return snd_ctl_card_info(card, ctl, cmd, arg: argp);
2018	case SNDRV_CTL_IOCTL_ELEM_LIST:
2019	return snd_ctl_elem_list_user(card, list: argp);
2020	case SNDRV_CTL_IOCTL_ELEM_INFO:
2021	return snd_ctl_elem_info_user(ctl, info: argp);
2022	case SNDRV_CTL_IOCTL_ELEM_READ:
2023	return snd_ctl_elem_read_user(card, control: argp);
2024	case SNDRV_CTL_IOCTL_ELEM_WRITE:
2025	return snd_ctl_elem_write_user(file: ctl, control: argp);
2026	case SNDRV_CTL_IOCTL_ELEM_LOCK:
2027	return snd_ctl_elem_lock(file: ctl, id: argp);
2028	case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
2029	return snd_ctl_elem_unlock(file: ctl, id: argp);
2030	case SNDRV_CTL_IOCTL_ELEM_ADD:
2031	return snd_ctl_elem_add_user(file: ctl, info: argp, replace: 0);
2032	case SNDRV_CTL_IOCTL_ELEM_REPLACE:
2033	return snd_ctl_elem_add_user(file: ctl, info: argp, replace: 1);
2034	case SNDRV_CTL_IOCTL_ELEM_REMOVE:
2035	return snd_ctl_elem_remove(file: ctl, id: argp);
2036	case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
2037	return snd_ctl_subscribe_events(file: ctl, ptr: ip);
2038	case SNDRV_CTL_IOCTL_TLV_READ:
2039	down_read(sem: &ctl->card->controls_rwsem);
2040	err = snd_ctl_tlv_ioctl(file: ctl, buf: argp, op_flag: SNDRV_CTL_TLV_OP_READ);
2041	up_read(sem: &ctl->card->controls_rwsem);
2042	return err;
2043	case SNDRV_CTL_IOCTL_TLV_WRITE:
2044	down_write(sem: &ctl->card->controls_rwsem);
2045	err = snd_ctl_tlv_ioctl(file: ctl, buf: argp, op_flag: SNDRV_CTL_TLV_OP_WRITE);
2046	up_write(sem: &ctl->card->controls_rwsem);
2047	return err;
2048	case SNDRV_CTL_IOCTL_TLV_COMMAND:
2049	down_write(sem: &ctl->card->controls_rwsem);
2050	err = snd_ctl_tlv_ioctl(file: ctl, buf: argp, op_flag: SNDRV_CTL_TLV_OP_CMD);
2051	up_write(sem: &ctl->card->controls_rwsem);
2052	return err;
2053	case SNDRV_CTL_IOCTL_POWER:
2054	return -ENOPROTOOPT;
2055	case SNDRV_CTL_IOCTL_POWER_STATE:
2056	return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
2057	}
2058	down_read(sem: &snd_ioctl_rwsem);
2059	list_for_each_entry(p, &snd_control_ioctls, list) {
2060	err = p->fioctl(card, ctl, cmd, arg);
2061	if (err != -ENOIOCTLCMD) {
2062	up_read(sem: &snd_ioctl_rwsem);
2063	return err;
2064	}
2065	}
2066	up_read(sem: &snd_ioctl_rwsem);
2067	dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd);
2068	return -ENOTTY;
2069	}
2070
2071	static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
2072	size_t count, loff_t * offset)
2073	{
2074	struct snd_ctl_file *ctl;
2075	int err = 0;
2076	ssize_t result = 0;
2077
2078	ctl = file->private_data;
2079	if (snd_BUG_ON(!ctl || !ctl->card))
2080	return -ENXIO;
2081	if (!ctl->subscribed)
2082	return -EBADFD;
2083	if (count < sizeof(struct snd_ctl_event))
2084	return -EINVAL;
2085	spin_lock_irq(lock: &ctl->read_lock);
2086	while (count >= sizeof(struct snd_ctl_event)) {
2087	struct snd_ctl_event ev;
2088	struct snd_kctl_event *kev;
2089	while (list_empty(head: &ctl->events)) {
2090	wait_queue_entry_t wait;
2091	if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
2092	err = -EAGAIN;
2093	goto __end_lock;
2094	}
2095	init_waitqueue_entry(wq_entry: &wait, current);
2096	add_wait_queue(wq_head: &ctl->change_sleep, wq_entry: &wait);
2097	set_current_state(TASK_INTERRUPTIBLE);
2098	spin_unlock_irq(lock: &ctl->read_lock);
2099	schedule();
2100	remove_wait_queue(wq_head: &ctl->change_sleep, wq_entry: &wait);
2101	if (ctl->card->shutdown)
2102	return -ENODEV;
2103	if (signal_pending(current))
2104	return -ERESTARTSYS;
2105	spin_lock_irq(lock: &ctl->read_lock);
2106	}
2107	kev = snd_kctl_event(ctl->events.next);
2108	ev.type = SNDRV_CTL_EVENT_ELEM;
2109	ev.data.elem.mask = kev->mask;
2110	ev.data.elem.id = kev->id;
2111	list_del(entry: &kev->list);
2112	spin_unlock_irq(lock: &ctl->read_lock);
2113	kfree(objp: kev);
2114	if (copy_to_user(to: buffer, from: &ev, n: sizeof(struct snd_ctl_event))) {
2115	err = -EFAULT;
2116	goto __end;
2117	}
2118	spin_lock_irq(lock: &ctl->read_lock);
2119	buffer += sizeof(struct snd_ctl_event);
2120	count -= sizeof(struct snd_ctl_event);
2121	result += sizeof(struct snd_ctl_event);
2122	}
2123	__end_lock:
2124	spin_unlock_irq(lock: &ctl->read_lock);
2125	__end:
2126	return result > 0 ? result : err;
2127	}
2128
2129	static __poll_t snd_ctl_poll(struct file *file, poll_table * wait)
2130	{
2131	__poll_t mask;
2132	struct snd_ctl_file *ctl;
2133
2134	ctl = file->private_data;
2135	if (!ctl->subscribed)
2136	return 0;
2137	poll_wait(filp: file, wait_address: &ctl->change_sleep, p: wait);
2138
2139	mask = 0;
2140	if (!list_empty(head: &ctl->events))
2141	mask |= EPOLLIN | EPOLLRDNORM;
2142
2143	return mask;
2144	}
2145
2146	/*
2147	* register the device-specific control-ioctls.
2148	* called from each device manager like pcm.c, hwdep.c, etc.
2149	*/
2150	static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
2151	{
2152	struct snd_kctl_ioctl *pn;
2153
2154	pn = kzalloc(size: sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
2155	if (pn == NULL)
2156	return -ENOMEM;
2157	pn->fioctl = fcn;
2158	down_write(sem: &snd_ioctl_rwsem);
2159	list_add_tail(new: &pn->list, head: lists);
2160	up_write(sem: &snd_ioctl_rwsem);
2161	return 0;
2162	}
2163
2164	/**
2165	* snd_ctl_register_ioctl - register the device-specific control-ioctls
2166	* @fcn: ioctl callback function
2167	*
2168	* called from each device manager like pcm.c, hwdep.c, etc.
2169	*
2170	* Return: zero if successful, or a negative error code
2171	*/
2172	int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
2173	{
2174	return _snd_ctl_register_ioctl(fcn, lists: &snd_control_ioctls);
2175	}
2176	EXPORT_SYMBOL(snd_ctl_register_ioctl);
2177
2178	#ifdef CONFIG_COMPAT
2179	/**
2180	* snd_ctl_register_ioctl_compat - register the device-specific 32bit compat
2181	* control-ioctls
2182	* @fcn: ioctl callback function
2183	*
2184	* Return: zero if successful, or a negative error code
2185	*/
2186	int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2187	{
2188	return _snd_ctl_register_ioctl(fcn, lists: &snd_control_compat_ioctls);
2189	}
2190	EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
2191	#endif
2192
2193	/*
2194	* de-register the device-specific control-ioctls.
2195	*/
2196	static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
2197	struct list_head *lists)
2198	{
2199	struct snd_kctl_ioctl *p;
2200
2201	if (snd_BUG_ON(!fcn))
2202	return -EINVAL;
2203	down_write(sem: &snd_ioctl_rwsem);
2204	list_for_each_entry(p, lists, list) {
2205	if (p->fioctl == fcn) {
2206	list_del(entry: &p->list);
2207	up_write(sem: &snd_ioctl_rwsem);
2208	kfree(objp: p);
2209	return 0;
2210	}
2211	}
2212	up_write(sem: &snd_ioctl_rwsem);
2213	snd_BUG();
2214	return -EINVAL;
2215	}
2216
2217	/**
2218	* snd_ctl_unregister_ioctl - de-register the device-specific control-ioctls
2219	* @fcn: ioctl callback function to unregister
2220	*
2221	* Return: zero if successful, or a negative error code
2222	*/
2223	int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
2224	{
2225	return _snd_ctl_unregister_ioctl(fcn, lists: &snd_control_ioctls);
2226	}
2227	EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
2228
2229	#ifdef CONFIG_COMPAT
2230	/**
2231	* snd_ctl_unregister_ioctl_compat - de-register the device-specific compat
2232	* 32bit control-ioctls
2233	* @fcn: ioctl callback function to unregister
2234	*
2235	* Return: zero if successful, or a negative error code
2236	*/
2237	int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2238	{
2239	return _snd_ctl_unregister_ioctl(fcn, lists: &snd_control_compat_ioctls);
2240	}
2241	EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
2242	#endif
2243
2244	static int snd_ctl_fasync(int fd, struct file * file, int on)
2245	{
2246	struct snd_ctl_file *ctl;
2247
2248	ctl = file->private_data;
2249	return snd_fasync_helper(fd, file, on, fasyncp: &ctl->fasync);
2250	}
2251
2252	/* return the preferred subdevice number if already assigned;
2253	* otherwise return -1
2254	*/
2255	int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type)
2256	{
2257	struct snd_ctl_file *kctl;
2258	int subdevice = -1;
2259	unsigned long flags;
2260
2261	read_lock_irqsave(&card->ctl_files_rwlock, flags);
2262	list_for_each_entry(kctl, &card->ctl_files, list) {
2263	if (kctl->pid == task_pid(current)) {
2264	subdevice = kctl->preferred_subdevice[type];
2265	if (subdevice != -1)
2266	break;
2267	}
2268	}
2269	read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
2270	return subdevice;
2271	}
2272	EXPORT_SYMBOL_GPL(snd_ctl_get_preferred_subdevice);
2273
2274	/*
2275	* ioctl32 compat
2276	*/
2277	#ifdef CONFIG_COMPAT
2278	#include "control_compat.c"
2279	#else
2280	#define snd_ctl_ioctl_compat NULL
2281	#endif
2282
2283	/*
2284	* control layers (audio LED etc.)
2285	*/
2286
2287	/**
2288	* snd_ctl_request_layer - request to use the layer
2289	* @module_name: Name of the kernel module (NULL == build-in)
2290	*
2291	* Return: zero if successful, or an error code when the module cannot be loaded
2292	*/
2293	int snd_ctl_request_layer(const char *module_name)
2294	{
2295	struct snd_ctl_layer_ops *lops;
2296
2297	if (module_name == NULL)
2298	return 0;
2299	down_read(sem: &snd_ctl_layer_rwsem);
2300	for (lops = snd_ctl_layer; lops; lops = lops->next)
2301	if (strcmp(lops->module_name, module_name) == 0)
2302	break;
2303	up_read(sem: &snd_ctl_layer_rwsem);
2304	if (lops)
2305	return 0;
2306	return request_module(module_name);
2307	}
2308	EXPORT_SYMBOL_GPL(snd_ctl_request_layer);
2309
2310	/**
2311	* snd_ctl_register_layer - register new control layer
2312	* @lops: operation structure
2313	*
2314	* The new layer can track all control elements and do additional
2315	* operations on top (like audio LED handling).
2316	*/
2317	void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops)
2318	{
2319	struct snd_card *card;
2320	int card_number;
2321
2322	down_write(sem: &snd_ctl_layer_rwsem);
2323	lops->next = snd_ctl_layer;
2324	snd_ctl_layer = lops;
2325	up_write(sem: &snd_ctl_layer_rwsem);
2326	for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
2327	card = snd_card_ref(card: card_number);
2328	if (card) {
2329	down_read(sem: &card->controls_rwsem);
2330	lops->lregister(card);
2331	up_read(sem: &card->controls_rwsem);
2332	snd_card_unref(card);
2333	}
2334	}
2335	}
2336	EXPORT_SYMBOL_GPL(snd_ctl_register_layer);
2337
2338	/**
2339	* snd_ctl_disconnect_layer - disconnect control layer
2340	* @lops: operation structure
2341	*
2342	* It is expected that the information about tracked cards
2343	* is freed before this call (the disconnect callback is
2344	* not called here).
2345	*/
2346	void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops)
2347	{
2348	struct snd_ctl_layer_ops *lops2, *prev_lops2;
2349
2350	down_write(sem: &snd_ctl_layer_rwsem);
2351	for (lops2 = snd_ctl_layer, prev_lops2 = NULL; lops2; lops2 = lops2->next) {
2352	if (lops2 == lops) {
2353	if (!prev_lops2)
2354	snd_ctl_layer = lops->next;
2355	else
2356	prev_lops2->next = lops->next;
2357	break;
2358	}
2359	prev_lops2 = lops2;
2360	}
2361	up_write(sem: &snd_ctl_layer_rwsem);
2362	}
2363	EXPORT_SYMBOL_GPL(snd_ctl_disconnect_layer);
2364
2365	/*
2366	* INIT PART
2367	*/
2368
2369	static const struct file_operations snd_ctl_f_ops =
2370	{
2371	.owner = THIS_MODULE,
2372	.read = snd_ctl_read,
2373	.open = snd_ctl_open,
2374	.release = snd_ctl_release,
2375	.llseek = no_llseek,
2376	.poll = snd_ctl_poll,
2377	.unlocked_ioctl = snd_ctl_ioctl,
2378	.compat_ioctl = snd_ctl_ioctl_compat,
2379	.fasync = snd_ctl_fasync,
2380	};
2381
2382	/*
2383	* registration of the control device
2384	*/
2385	static int snd_ctl_dev_register(struct snd_device *device)
2386	{
2387	struct snd_card *card = device->device_data;
2388	struct snd_ctl_layer_ops *lops;
2389	int err;
2390
2391	err = snd_register_device(type: SNDRV_DEVICE_TYPE_CONTROL, card, dev: -1,
2392	f_ops: &snd_ctl_f_ops, private_data: card, device: card->ctl_dev);
2393	if (err < 0)
2394	return err;
2395	down_read(sem: &card->controls_rwsem);
2396	down_read(sem: &snd_ctl_layer_rwsem);
2397	for (lops = snd_ctl_layer; lops; lops = lops->next)
2398	lops->lregister(card);
2399	up_read(sem: &snd_ctl_layer_rwsem);
2400	up_read(sem: &card->controls_rwsem);
2401	return 0;
2402	}
2403
2404	/*
2405	* disconnection of the control device
2406	*/
2407	static int snd_ctl_dev_disconnect(struct snd_device *device)
2408	{
2409	struct snd_card *card = device->device_data;
2410	struct snd_ctl_file *ctl;
2411	struct snd_ctl_layer_ops *lops;
2412	unsigned long flags;
2413
2414	read_lock_irqsave(&card->ctl_files_rwlock, flags);
2415	list_for_each_entry(ctl, &card->ctl_files, list) {
2416	wake_up(&ctl->change_sleep);
2417	snd_kill_fasync(fasync: ctl->fasync, SIGIO, POLL_ERR);
2418	}
2419	read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
2420
2421	down_read(sem: &card->controls_rwsem);
2422	down_read(sem: &snd_ctl_layer_rwsem);
2423	for (lops = snd_ctl_layer; lops; lops = lops->next)
2424	lops->ldisconnect(card);
2425	up_read(sem: &snd_ctl_layer_rwsem);
2426	up_read(sem: &card->controls_rwsem);
2427
2428	return snd_unregister_device(dev: card->ctl_dev);
2429	}
2430
2431	/*
2432	* free all controls
2433	*/
2434	static int snd_ctl_dev_free(struct snd_device *device)
2435	{
2436	struct snd_card *card = device->device_data;
2437	struct snd_kcontrol *control;
2438
2439	down_write(sem: &card->controls_rwsem);
2440	while (!list_empty(head: &card->controls)) {
2441	control = snd_kcontrol(card->controls.next);
2442	__snd_ctl_remove(card, kcontrol: control, remove_hash: false);
2443	}
2444
2445	#ifdef CONFIG_SND_CTL_FAST_LOOKUP
2446	xa_destroy(&card->ctl_numids);
2447	xa_destroy(&card->ctl_hash);
2448	#endif
2449	up_write(sem: &card->controls_rwsem);
2450	put_device(dev: card->ctl_dev);
2451	return 0;
2452	}
2453
2454	/*
2455	* create control core:
2456	* called from init.c
2457	*/
2458	int snd_ctl_create(struct snd_card *card)
2459	{
2460	static const struct snd_device_ops ops = {
2461	.dev_free = snd_ctl_dev_free,
2462	.dev_register = snd_ctl_dev_register,
2463	.dev_disconnect = snd_ctl_dev_disconnect,
2464	};
2465	int err;
2466
2467	if (snd_BUG_ON(!card))
2468	return -ENXIO;
2469	if (snd_BUG_ON(card->number < 0 || card->number >= SNDRV_CARDS))
2470	return -ENXIO;
2471
2472	err = snd_device_alloc(dev_p: &card->ctl_dev, card);
2473	if (err < 0)
2474	return err;
2475	dev_set_name(dev: card->ctl_dev, name: "controlC%d", card->number);
2476
2477	err = snd_device_new(card, type: SNDRV_DEV_CONTROL, device_data: card, ops: &ops);
2478	if (err < 0)
2479	put_device(dev: card->ctl_dev);
2480	return err;
2481	}
2482
2483	/*
2484	* Frequently used control callbacks/helpers
2485	*/
2486
2487	/**
2488	* snd_ctl_boolean_mono_info - Helper function for a standard boolean info
2489	* callback with a mono channel
2490	* @kcontrol: the kcontrol instance
2491	* @uinfo: info to store
2492	*
2493	* This is a function that can be used as info callback for a standard
2494	* boolean control with a single mono channel.
2495	*
2496	* Return: Zero (always successful)
2497	*/
2498	int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
2499	struct snd_ctl_elem_info *uinfo)
2500	{
2501	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2502	uinfo->count = 1;
2503	uinfo->value.integer.min = 0;
2504	uinfo->value.integer.max = 1;
2505	return 0;
2506	}
2507	EXPORT_SYMBOL(snd_ctl_boolean_mono_info);
2508
2509	/**
2510	* snd_ctl_boolean_stereo_info - Helper function for a standard boolean info
2511	* callback with stereo two channels
2512	* @kcontrol: the kcontrol instance
2513	* @uinfo: info to store
2514	*
2515	* This is a function that can be used as info callback for a standard
2516	* boolean control with stereo two channels.
2517	*
2518	* Return: Zero (always successful)
2519	*/
2520	int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
2521	struct snd_ctl_elem_info *uinfo)
2522	{
2523	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2524	uinfo->count = 2;
2525	uinfo->value.integer.min = 0;
2526	uinfo->value.integer.max = 1;
2527	return 0;
2528	}
2529	EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);
2530
2531	/**
2532	* snd_ctl_enum_info - fills the info structure for an enumerated control
2533	* @info: the structure to be filled
2534	* @channels: the number of the control's channels; often one
2535	* @items: the number of control values; also the size of @names
2536	* @names: an array containing the names of all control values
2537	*
2538	* Sets all required fields in @info to their appropriate values.
2539	* If the control's accessibility is not the default (readable and writable),
2540	* the caller has to fill @info->access.
2541	*
2542	* Return: Zero (always successful)
2543	*/
2544	int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
2545	unsigned int items, const char *const names[])
2546	{
2547	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2548	info->count = channels;
2549	info->value.enumerated.items = items;
2550	if (!items)
2551	return 0;
2552	if (info->value.enumerated.item >= items)
2553	info->value.enumerated.item = items - 1;
2554	WARN(strlen(names[info->value.enumerated.item]) >= sizeof(info->value.enumerated.name),
2555	"ALSA: too long item name '%s'\n",
2556	names[info->value.enumerated.item]);
2557	strscpy(p: info->value.enumerated.name,
2558	q: names[info->value.enumerated.item],
2559	size: sizeof(info->value.enumerated.name));
2560	return 0;
2561	}
2562	EXPORT_SYMBOL(snd_ctl_enum_info);
2563