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