Linux Audio

Check our new training course

Loading...
v5.4
   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);
v6.8
   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.
  23static int max_user_ctl_alloc_size = 8 * 1024 * 1024;
  24module_param_named(max_user_ctl_alloc_size, max_user_ctl_alloc_size, int, 0444);
  25MODULE_PARM_DESC(max_user_ctl_alloc_size, "Max allocation size for user controls");
  26
  27#define MAX_CONTROL_COUNT	1028
  28
  29struct snd_kctl_ioctl {
  30	struct list_head list;		/* list of all ioctls */
  31	snd_kctl_ioctl_func_t fioctl;
  32};
  33
  34static DECLARE_RWSEM(snd_ioctl_rwsem);
  35static DECLARE_RWSEM(snd_ctl_layer_rwsem);
  36static LIST_HEAD(snd_control_ioctls);
  37#ifdef CONFIG_COMPAT
  38static LIST_HEAD(snd_control_compat_ioctls);
  39#endif
  40static struct snd_ctl_layer_ops *snd_ctl_layer;
  41
  42static int snd_ctl_remove_locked(struct snd_card *card,
  43				 struct snd_kcontrol *kcontrol);
  44
  45static 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, file);
  53	if (err < 0)
  54		return err;
  55
  56	card = snd_lookup_minor_data(iminor(inode), 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(card->module)) {
  67		err = -EFAULT;
  68		goto __error2;
  69	}
  70	ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
  71	if (ctl == NULL) {
  72		err = -ENOMEM;
  73		goto __error;
  74	}
  75	INIT_LIST_HEAD(&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(task_pid(current));
  82	file->private_data = ctl;
  83	write_lock_irqsave(&card->ctl_files_rwlock, flags);
  84	list_add_tail(&ctl->list, &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(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
  99static 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(&ctl->events)) {
 106		cread = snd_kctl_event(ctl->events.next);
 107		list_del(&cread->list);
 108		kfree(cread);
 109	}
 110	spin_unlock_irqrestore(&ctl->read_lock, flags);
 111}
 112
 113static 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(&ctl->list);
 126	write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 127	down_write(&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(&card->controls_rwsem);
 133	snd_fasync_free(ctl->fasync);
 134	snd_ctl_empty_read_queue(ctl);
 135	put_pid(ctl->pid);
 136	kfree(ctl);
 137	module_put(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 */
 152void 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(&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(sizeof(*ev), GFP_ATOMIC);
 178		if (ev) {
 179			ev->id = *id;
 180			ev->mask = mask;
 181			list_add_tail(&ev->list, &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(&ctl->read_lock);
 188		snd_kill_fasync(ctl->fasync, SIGIO, POLL_IN);
 189	}
 190	read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
 191}
 192EXPORT_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 */
 204void 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(&snd_ctl_layer_rwsem);
 214	for (lops = snd_ctl_layer; lops; lops = lops->next)
 215		lops->lnotify(card, mask, kctl, ioff);
 216	up_read(&snd_ctl_layer_rwsem);
 217}
 218EXPORT_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 */
 233static 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 */
 265struct 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, 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(kctl->id.name, ncontrol->name, 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}
 318EXPORT_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 */
 328void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
 329{
 330	if (kcontrol) {
 331		if (kcontrol->private_free)
 332			kcontrol->private_free(kcontrol);
 333		kfree(kcontrol);
 334	}
 335}
 336EXPORT_SYMBOL(snd_ctl_free_one);
 337
 338static 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
 357static 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 */
 372static 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
 389static 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 */
 405static 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, kcontrol->id.numid,
 412		       kcontrol->id.numid + kcontrol->count - 1,
 413		       kcontrol, GFP_KERNEL);
 414
 415	for (i = 0; i < kcontrol->count; i++) {
 416		id.index = kcontrol->id.index + i;
 417		if (xa_insert(&card->ctl_hash, get_ctl_id_hash(&id),
 418			      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 */
 428static 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, id.numid);
 438		h = get_ctl_id_hash(&id);
 439		matched = xa_load(&card->ctl_hash, h);
 440		if (matched && (matched == kcontrol ||
 441				elem_id_matches(matched, &id)))
 442			xa_erase(&card->ctl_hash, h);
 443		id.index++;
 444		id.numid++;
 445	}
 446}
 447#else /* CONFIG_SND_CTL_FAST_LOOKUP */
 448static inline void add_hash_entries(struct snd_card *card,
 449				    struct snd_kcontrol *kcontrol)
 450{
 451}
 452static inline void remove_hash_entries(struct snd_card *card,
 453				       struct snd_kcontrol *kcontrol)
 454{
 455}
 456#endif /* CONFIG_SND_CTL_FAST_LOOKUP */
 457
 458enum 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 */
 463static 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);
 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, old);
 492		if (err < 0)
 493			return err;
 494	}
 495
 496	if (snd_ctl_find_hole(card, kcontrol->count) < 0)
 497		return -ENOMEM;
 498
 499	list_add_tail(&kcontrol->list, &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
 512static 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(&card->controls_rwsem);
 524	err = __snd_ctl_add_replace(card, kcontrol, mode);
 525	up_write(&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 */
 549int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
 550{
 551	return snd_ctl_add_replace(card, kcontrol, CTL_ADD_EXCLUSIVE);
 552}
 553EXPORT_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 */
 569int 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				   add_on_replace ? CTL_ADD_ON_REPLACE : CTL_REPLACE);
 574}
 575EXPORT_SYMBOL(snd_ctl_replace);
 576
 577static 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(&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
 599static inline int snd_ctl_remove_locked(struct snd_card *card,
 600					struct snd_kcontrol *kcontrol)
 601{
 602	return __snd_ctl_remove(card, kcontrol, 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 */
 617int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 618{
 619	int ret;
 
 620
 621	down_write(&card->controls_rwsem);
 622	ret = snd_ctl_remove_locked(card, kcontrol);
 623	up_write(&card->controls_rwsem);
 624	return ret;
 
 
 
 
 
 625}
 626EXPORT_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 */
 638int 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(&card->controls_rwsem);
 644	kctl = snd_ctl_find_id_locked(card, id);
 645	if (kctl == NULL) {
 646		up_write(&card->controls_rwsem);
 647		return -ENOENT;
 648	}
 649	ret = snd_ctl_remove_locked(card, kctl);
 650	up_write(&card->controls_rwsem);
 651	return ret;
 652}
 653EXPORT_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 */
 665static 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(&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, kctl);
 
 
 
 688error:
 689	up_write(&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 */
 705int 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(&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(id, kctl, index_offset);
 732	downgrade_write(&card->controls_rwsem);
 733	snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_INFO, kctl, index_offset);
 734	up_read(&card->controls_rwsem);
 735	return 1;
 736
 737 unlock:
 738	up_write(&card->controls_rwsem);
 
 
 739	return ret;
 740}
 741EXPORT_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 */
 761int 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(&card->controls_rwsem);
 768	kctl = snd_ctl_find_id_locked(card, src_id);
 769	if (kctl == NULL) {
 770		up_write(&card->controls_rwsem);
 771		return -ENOENT;
 772	}
 773	saved_numid = kctl->id.numid;
 774	remove_hash_entries(card, kctl);
 775	kctl->id = *dst_id;
 776	kctl->id.numid = saved_numid;
 777	add_hash_entries(card, kctl);
 778	up_write(&card->controls_rwsem);
 779	return 0;
 780}
 781EXPORT_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 */
 793void snd_ctl_rename(struct snd_card *card, struct snd_kcontrol *kctl,
 794		    const char *name)
 795{
 796	down_write(&card->controls_rwsem);
 797	remove_hash_entries(card, kctl);
 798
 799	if (strscpy(kctl->id.name, name, 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, kctl);
 804	up_write(&card->controls_rwsem);
 805}
 806EXPORT_SYMBOL(snd_ctl_rename);
 807
 808#ifndef CONFIG_SND_CTL_FAST_LOOKUP
 809static struct snd_kcontrol *
 810snd_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 */
 834struct snd_kcontrol *
 835snd_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, numid);
 842#else
 843	return snd_ctl_find_numid_slow(card, numid);
 844#endif
 845}
 846EXPORT_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 */
 859struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card,
 860					unsigned int numid)
 861{
 862	struct snd_kcontrol *kctl;
 863
 864	down_read(&card->controls_rwsem);
 865	kctl = snd_ctl_find_numid_locked(card, numid);
 866	up_read(&card->controls_rwsem);
 867	return kctl;
 
 
 
 868}
 869EXPORT_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 */
 883struct 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, 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}
 907EXPORT_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 */
 920struct 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(&card->controls_rwsem);
 926	kctl = snd_ctl_find_id_locked(card, id);
 927	up_read(&card->controls_rwsem);
 928	return kctl;
 929}
 930EXPORT_SYMBOL(snd_ctl_find_id);
 931
 932static 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(sizeof(*info), GFP_KERNEL);
 938	if (! info)
 939		return -ENOMEM;
 940	down_read(&snd_ioctl_rwsem);
 941	info->card = card->number;
 942	strscpy(info->id, card->id, sizeof(info->id));
 943	strscpy(info->driver, card->driver, sizeof(info->driver));
 944	strscpy(info->name, card->shortname, sizeof(info->name));
 945	strscpy(info->longname, card->longname, sizeof(info->longname));
 946	strscpy(info->mixername, card->mixername, sizeof(info->mixername));
 947	strscpy(info->components, card->components, sizeof(info->components));
 948	up_read(&snd_ioctl_rwsem);
 949	if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
 950		kfree(info);
 951		return -EFAULT;
 952	}
 953	kfree(info);
 954	return 0;
 955}
 956
 957static 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(&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(&id, kctl, jidx);
 979				if (copy_to_user(list->pids + list->used, &id,
 980						 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(&card->controls_rwsem);
 
 
 993	return err;
 994}
 995
 996static 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(&list, _list, sizeof(list)))
1003		return -EFAULT;
1004	err = snd_ctl_elem_list(card, &list);
1005	if (err)
1006		return err;
1007	if (copy_to_user(_list, &list, sizeof(list)))
1008		return -EFAULT;
1009
1010	return 0;
1011}
1012
1013/* Check whether the given kctl info is valid */
1014static 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.*/
1060static 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 */
1070static 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((u32 *)control->value.bytes.data + offset, pattern,
1078		 sizeof(control->value) / sizeof(u32) - offset);
1079}
1080
1081/* check whether the given integer ctl value is valid */
1082static 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(lval, lstep, &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 */
1144static 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 */
1171static 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, 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
1199static 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, &info->id);
1218		vd = &kctl->vd[index_offset];
1219		snd_ctl_build_ioff(&info->id, kctl, 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(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
1236static 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(&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(&card->controls_rwsem);
1250	return result;
1251}
1252
1253static 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(&info, _info, sizeof(info)))
1260		return -EFAULT;
 
 
 
1261	result = snd_ctl_elem_info(ctl, &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(_info, &info, sizeof(info)))
1268		return -EFAULT;
1269	return result;
1270}
1271
1272static 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(&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, &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(&control->id, kctl, 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, 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, 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, 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	}
1325unlock:
1326	up_read(&card->controls_rwsem);
1327	return ret;
1328}
1329
1330static 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(control))
1338		return PTR_ERR(control);
1339
 
 
 
 
 
1340	result = snd_ctl_elem_read(card, control);
 
1341	if (result < 0)
1342		goto error;
1343
1344	if (copy_to_user(_control, control, sizeof(*control)))
1345		result = -EFAULT;
1346 error:
1347	kfree(control);
1348	return result;
1349}
1350
1351static 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(&card->controls_rwsem);
1360	kctl = snd_ctl_find_id_locked(card, &control->id);
1361	if (kctl == NULL) {
1362		up_write(&card->controls_rwsem);
1363		return -ENOENT;
1364	}
1365
1366	index_offset = snd_ctl_get_ioff(kctl, &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(&card->controls_rwsem);
1371		return -EPERM;
1372	}
1373
1374	snd_ctl_build_ioff(&control->id, kctl, 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, NULL);
1383		if (!result)
1384			result = sanity_check_input_values(card, control, &info,
1385							   false);
1386	}
1387	if (!result)
1388		result = kctl->put(kctl, control);
1389	snd_power_unref(card);
1390	if (result < 0) {
1391		up_write(&card->controls_rwsem);
1392		return result;
1393	}
1394
1395	if (result > 0) {
1396		downgrade_write(&card->controls_rwsem);
1397		snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, index_offset);
1398		up_read(&card->controls_rwsem);
1399	} else {
1400		up_write(&card->controls_rwsem);
1401	}
1402
1403	return 0;
1404}
1405
1406static 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(control))
1415		return PTR_ERR(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(_control, control, sizeof(*control)))
1423		result = -EFAULT;
1424 error:
1425	kfree(control);
1426	return result;
1427}
1428
1429static 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(&id, _id, sizeof(id)))
1439		return -EFAULT;
1440	down_write(&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)];
1446		if (vd->owner != NULL)
1447			result = -EBUSY;
1448		else {
1449			vd->owner = file;
1450			result = 0;
1451		}
1452	}
1453	up_write(&card->controls_rwsem);
1454	return result;
1455}
1456
1457static 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(&id, _id, sizeof(id)))
1467		return -EFAULT;
1468	down_write(&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)];
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(&card->controls_rwsem);
1484	return result;
1485}
1486
1487struct 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.
1498static 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
1503static 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(kcontrol, &uinfo->id);
1510	*uinfo = ue->info;
1511	snd_ctl_build_ioff(&uinfo->id, kcontrol, offset);
1512
1513	return 0;
1514}
1515
1516static 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(kcontrol, &uinfo->id);
1527	*uinfo = ue->info;
1528	snd_ctl_build_ioff(&uinfo->id, 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(uinfo->value.enumerated.name, names);
1537
1538	return 0;
1539}
1540
1541static 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(kcontrol, &ucontrol->id) * size;
1548
1549	memcpy(&ucontrol->value, src, size);
1550	return 0;
1551}
1552
1553static 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(kcontrol, &ucontrol->id) * size;
1561
1562	change = memcmp(&ucontrol->value, dst, size) != 0;
1563	if (change)
1564		memcpy(dst, &ucontrol->value, size);
1565	return change;
1566}
1567
1568/* called in controls_rwsem write lock */
1569static 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(ue->card, (ssize_t)(size - ue->tlv_data_size)))
1585		return -ENOMEM;
1586
1587	container = vmemdup_user(buf, size);
1588	if (IS_ERR(container))
1589		return PTR_ERR(container);
1590
1591	change = ue->tlv_data_size != size;
1592	if (!change)
1593		change = memcmp(ue->tlv_data, container, size) != 0;
1594	if (!change) {
1595		kvfree(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(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
1622static 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(buf, ue->tlv_data, ue->tlv_data_size))
1634		return -EFAULT;
1635
1636	return 0;
1637}
1638
1639static 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 */
1649static 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(ue->card, buf_len))
1663		return -ENOMEM;
1664	names = vmemdup_user((const void __user *)user_ptrval, buf_len);
1665	if (IS_ERR(names))
1666		return PTR_ERR(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, buf_len);
1672		if (name_len == 0 || name_len >= 64 || name_len == buf_len) {
1673			kvfree(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
1688static size_t compute_user_elem_size(size_t size, unsigned int count)
1689{
1690	return sizeof(struct user_element) + size * count;
1691}
1692
1693static 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(ue->elem_data_size, 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(ue->tlv_data);
1704	kvfree(ue->priv_data);
1705	kfree(ue);
1706}
1707
1708static 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(info->id.name, 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, &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(private_size, count);
1765
1766	down_write(&card->controls_rwsem);
1767	if (check_user_elem_overflow(card, 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, count, access, file);
1779	if (err < 0)
1780		goto unlock;
1781	memcpy(&kctl->id, &info->id, sizeof(kctl->id));
1782	ue = kzalloc(alloc_size, GFP_KERNEL);
1783	if (!ue) {
 
1784		kfree(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, kctl, CTL_ADD_EXCLUSIVE);
1822	if (err < 0) {
1823		snd_ctl_free_one(kctl);
1824		goto unlock;
1825	}
1826	offset = snd_ctl_get_ioff(kctl, &info->id);
1827	snd_ctl_build_ioff(&info->id, 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(&card->controls_rwsem);
1837	return err;
1838}
1839
1840static 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(&info, _info, sizeof(info)))
1847		return -EFAULT;
1848	err = snd_ctl_elem_add(file, &info, replace);
1849	if (err < 0)
1850		return err;
1851	if (copy_to_user(_info, &info, sizeof(info))) {
1852		snd_ctl_remove_user_ctl(file, &info.id);
1853		return -EFAULT;
1854	}
1855
1856	return 0;
1857}
1858
1859static 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(&id, _id, sizeof(id)))
1865		return -EFAULT;
1866	return snd_ctl_remove_user_ctl(file, &id);
1867}
1868
1869static 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(file);
1885		file->subscribed = 0;
1886	}
1887	return 0;
1888}
1889
1890static 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(file->card);
1923	if (!ret)
1924		ret = kctl->tlv.c(kctl, op_flag, size, buf);
1925	snd_power_unref(file->card);
1926	return ret;
1927}
1928
1929static 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(buf, kctl->tlv.p, len))
1946		return -EFAULT;
1947
1948	return 0;
1949}
1950
1951static 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(&header, buf, 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(&id, kctl, header.numid - id.numid);
1984	vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
1985
1986	if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1987		return call_tlv_handler(file, op_flag, kctl, &id, container,
1988					container_size);
1989	} else {
1990		if (op_flag == SNDRV_CTL_TLV_OP_READ) {
1991			return read_tlv_buf(kctl, &id, container,
1992					    container_size);
1993		}
1994	}
1995
1996	/* Not supported. */
1997	return -ENXIO;
1998}
1999
2000static 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, argp);
2018	case SNDRV_CTL_IOCTL_ELEM_LIST:
2019		return snd_ctl_elem_list_user(card, argp);
2020	case SNDRV_CTL_IOCTL_ELEM_INFO:
2021		return snd_ctl_elem_info_user(ctl, argp);
2022	case SNDRV_CTL_IOCTL_ELEM_READ:
2023		return snd_ctl_elem_read_user(card, argp);
2024	case SNDRV_CTL_IOCTL_ELEM_WRITE:
2025		return snd_ctl_elem_write_user(ctl, argp);
2026	case SNDRV_CTL_IOCTL_ELEM_LOCK:
2027		return snd_ctl_elem_lock(ctl, argp);
2028	case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
2029		return snd_ctl_elem_unlock(ctl, argp);
2030	case SNDRV_CTL_IOCTL_ELEM_ADD:
2031		return snd_ctl_elem_add_user(ctl, argp, 0);
2032	case SNDRV_CTL_IOCTL_ELEM_REPLACE:
2033		return snd_ctl_elem_add_user(ctl, argp, 1);
2034	case SNDRV_CTL_IOCTL_ELEM_REMOVE:
2035		return snd_ctl_elem_remove(ctl, argp);
2036	case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
2037		return snd_ctl_subscribe_events(ctl, ip);
2038	case SNDRV_CTL_IOCTL_TLV_READ:
2039		down_read(&ctl->card->controls_rwsem);
2040		err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ);
2041		up_read(&ctl->card->controls_rwsem);
2042		return err;
2043	case SNDRV_CTL_IOCTL_TLV_WRITE:
2044		down_write(&ctl->card->controls_rwsem);
2045		err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE);
2046		up_write(&ctl->card->controls_rwsem);
2047		return err;
2048	case SNDRV_CTL_IOCTL_TLV_COMMAND:
2049		down_write(&ctl->card->controls_rwsem);
2050		err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD);
2051		up_write(&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(&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(&snd_ioctl_rwsem);
2063			return err;
2064		}
2065	}
2066	up_read(&snd_ioctl_rwsem);
2067	dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd);
2068	return -ENOTTY;
2069}
2070
2071static 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(&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(&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(&wait, current);
2096			add_wait_queue(&ctl->change_sleep, &wait);
2097			set_current_state(TASK_INTERRUPTIBLE);
2098			spin_unlock_irq(&ctl->read_lock);
2099			schedule();
2100			remove_wait_queue(&ctl->change_sleep, &wait);
2101			if (ctl->card->shutdown)
2102				return -ENODEV;
2103			if (signal_pending(current))
2104				return -ERESTARTSYS;
2105			spin_lock_irq(&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(&kev->list);
2112		spin_unlock_irq(&ctl->read_lock);
2113		kfree(kev);
2114		if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
2115			err = -EFAULT;
2116			goto __end;
2117		}
2118		spin_lock_irq(&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(&ctl->read_lock);
2125      __end:
2126      	return result > 0 ? result : err;
2127}
2128
2129static __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(file, &ctl->change_sleep, wait);
2138
2139	mask = 0;
2140	if (!list_empty(&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 */
2150static 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(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
2155	if (pn == NULL)
2156		return -ENOMEM;
2157	pn->fioctl = fcn;
2158	down_write(&snd_ioctl_rwsem);
2159	list_add_tail(&pn->list, lists);
2160	up_write(&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 */
2172int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
2173{
2174	return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
2175}
2176EXPORT_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 */
2186int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2187{
2188	return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
2189}
2190EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
2191#endif
2192
2193/*
2194 * de-register the device-specific control-ioctls.
2195 */
2196static 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(&snd_ioctl_rwsem);
2204	list_for_each_entry(p, lists, list) {
2205		if (p->fioctl == fcn) {
2206			list_del(&p->list);
2207			up_write(&snd_ioctl_rwsem);
2208			kfree(p);
2209			return 0;
2210		}
2211	}
2212	up_write(&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 */
2223int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
2224{
2225	return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
2226}
2227EXPORT_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 */
2237int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
2238{
2239	return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
2240}
2241EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
2242#endif
2243
2244static 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, &ctl->fasync);
2250}
2251
2252/* return the preferred subdevice number if already assigned;
2253 * otherwise return -1
2254 */
2255int 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}
2272EXPORT_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 */
2293int 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(&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(&snd_ctl_layer_rwsem);
2304	if (lops)
2305		return 0;
2306	return request_module(module_name);
2307}
2308EXPORT_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 */
2317void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops)
2318{
2319	struct snd_card *card;
2320	int card_number;
2321
2322	down_write(&snd_ctl_layer_rwsem);
2323	lops->next = snd_ctl_layer;
2324	snd_ctl_layer = lops;
2325	up_write(&snd_ctl_layer_rwsem);
2326	for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
2327		card = snd_card_ref(card_number);
2328		if (card) {
2329			down_read(&card->controls_rwsem);
2330			lops->lregister(card);
2331			up_read(&card->controls_rwsem);
2332			snd_card_unref(card);
2333		}
2334	}
2335}
2336EXPORT_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 */
2346void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops)
2347{
2348	struct snd_ctl_layer_ops *lops2, *prev_lops2;
2349
2350	down_write(&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(&snd_ctl_layer_rwsem);
2362}
2363EXPORT_SYMBOL_GPL(snd_ctl_disconnect_layer);
2364
2365/*
2366 *  INIT PART
2367 */
2368
2369static 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 */
2385static 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(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
2392				  &snd_ctl_f_ops, card, card->ctl_dev);
2393	if (err < 0)
2394		return err;
2395	down_read(&card->controls_rwsem);
2396	down_read(&snd_ctl_layer_rwsem);
2397	for (lops = snd_ctl_layer; lops; lops = lops->next)
2398		lops->lregister(card);
2399	up_read(&snd_ctl_layer_rwsem);
2400	up_read(&card->controls_rwsem);
2401	return 0;
2402}
2403
2404/*
2405 * disconnection of the control device
2406 */
2407static 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(ctl->fasync, SIGIO, POLL_ERR);
2418	}
2419	read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
2420
2421	down_read(&card->controls_rwsem);
2422	down_read(&snd_ctl_layer_rwsem);
2423	for (lops = snd_ctl_layer; lops; lops = lops->next)
2424		lops->ldisconnect(card);
2425	up_read(&snd_ctl_layer_rwsem);
2426	up_read(&card->controls_rwsem);
2427
2428	return snd_unregister_device(card->ctl_dev);
2429}
2430
2431/*
2432 * free all controls
2433 */
2434static 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(&card->controls_rwsem);
2440	while (!list_empty(&card->controls)) {
2441		control = snd_kcontrol(card->controls.next);
2442		__snd_ctl_remove(card, control, 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(&card->controls_rwsem);
2450	put_device(card->ctl_dev);
2451	return 0;
2452}
2453
2454/*
2455 * create control core:
2456 * called from init.c
2457 */
2458int 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(&card->ctl_dev, card);
2473	if (err < 0)
2474		return err;
2475	dev_set_name(card->ctl_dev, "controlC%d", card->number);
2476
2477	err = snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
2478	if (err < 0)
2479		put_device(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 */
2498int 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}
2507EXPORT_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 */
2520int 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}
2529EXPORT_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 */
2544int 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(info->value.enumerated.name,
2558		names[info->value.enumerated.item],
2559		sizeof(info->value.enumerated.name));
2560	return 0;
2561}
2562EXPORT_SYMBOL(snd_ctl_enum_info);