control.c 39.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *  Routines for driver control interface
3
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/threads.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/time.h>
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/info.h>
#include <sound/control.h>

/* max number of user-defined controls */
#define MAX_USER_CONTROLS	32
34
#define MAX_CONTROL_COUNT	1028
L
Linus Torvalds 已提交
35

36
struct snd_kctl_ioctl {
L
Linus Torvalds 已提交
37 38
	struct list_head list;		/* list of all ioctls */
	snd_kctl_ioctl_func_t fioctl;
39
};
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49

static DECLARE_RWSEM(snd_ioctl_rwsem);
static LIST_HEAD(snd_control_ioctls);
#ifdef CONFIG_COMPAT
static LIST_HEAD(snd_control_compat_ioctls);
#endif

static int snd_ctl_open(struct inode *inode, struct file *file)
{
	unsigned long flags;
50 51
	struct snd_card *card;
	struct snd_ctl_file *ctl;
L
Linus Torvalds 已提交
52 53
	int err;

T
Takashi Iwai 已提交
54 55 56 57
	err = nonseekable_open(inode, file);
	if (err < 0)
		return err;

58
	card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
L
Linus Torvalds 已提交
59 60 61 62 63 64 65 66 67 68 69 70 71
	if (!card) {
		err = -ENODEV;
		goto __error1;
	}
	err = snd_card_file_add(card, file);
	if (err < 0) {
		err = -ENODEV;
		goto __error1;
	}
	if (!try_module_get(card->module)) {
		err = -EFAULT;
		goto __error2;
	}
72
	ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
L
Linus Torvalds 已提交
73 74 75 76 77 78 79 80
	if (ctl == NULL) {
		err = -ENOMEM;
		goto __error;
	}
	INIT_LIST_HEAD(&ctl->events);
	init_waitqueue_head(&ctl->change_sleep);
	spin_lock_init(&ctl->read_lock);
	ctl->card = card;
81 82
	ctl->prefer_pcm_subdevice = -1;
	ctl->prefer_rawmidi_subdevice = -1;
83
	ctl->pid = get_pid(task_pid(current));
L
Linus Torvalds 已提交
84 85 86 87 88 89 90 91 92 93 94 95 96 97
	file->private_data = ctl;
	write_lock_irqsave(&card->ctl_files_rwlock, flags);
	list_add_tail(&ctl->list, &card->ctl_files);
	write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
	return 0;

      __error:
	module_put(card->module);
      __error2:
	snd_card_file_remove(card, file);
      __error1:
      	return err;
}

98
static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
L
Linus Torvalds 已提交
99
{
100
	unsigned long flags;
101
	struct snd_kctl_event *cread;
L
Linus Torvalds 已提交
102
	
103
	spin_lock_irqsave(&ctl->read_lock, flags);
L
Linus Torvalds 已提交
104 105 106 107 108
	while (!list_empty(&ctl->events)) {
		cread = snd_kctl_event(ctl->events.next);
		list_del(&cread->list);
		kfree(cread);
	}
109
	spin_unlock_irqrestore(&ctl->read_lock, flags);
L
Linus Torvalds 已提交
110 111 112 113 114
}

static int snd_ctl_release(struct inode *inode, struct file *file)
{
	unsigned long flags;
115 116 117
	struct snd_card *card;
	struct snd_ctl_file *ctl;
	struct snd_kcontrol *control;
L
Linus Torvalds 已提交
118 119 120 121 122 123 124 125 126
	unsigned int idx;

	ctl = file->private_data;
	file->private_data = NULL;
	card = ctl->card;
	write_lock_irqsave(&card->ctl_files_rwlock, flags);
	list_del(&ctl->list);
	write_unlock_irqrestore(&card->ctl_files_rwlock, flags);
	down_write(&card->controls_rwsem);
127
	list_for_each_entry(control, &card->controls, list)
L
Linus Torvalds 已提交
128 129 130 131 132
		for (idx = 0; idx < control->count; idx++)
			if (control->vd[idx].owner == ctl)
				control->vd[idx].owner = NULL;
	up_write(&card->controls_rwsem);
	snd_ctl_empty_read_queue(ctl);
133
	put_pid(ctl->pid);
L
Linus Torvalds 已提交
134 135 136 137 138 139
	kfree(ctl);
	module_put(card->module);
	snd_card_file_remove(card, file);
	return 0;
}

140 141
void snd_ctl_notify(struct snd_card *card, unsigned int mask,
		    struct snd_ctl_elem_id *id)
L
Linus Torvalds 已提交
142 143
{
	unsigned long flags;
144 145
	struct snd_ctl_file *ctl;
	struct snd_kctl_event *ev;
L
Linus Torvalds 已提交
146
	
147 148
	if (snd_BUG_ON(!card || !id))
		return;
L
Linus Torvalds 已提交
149 150 151 152
	read_lock(&card->ctl_files_rwlock);
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
	card->mixer_oss_change_count++;
#endif
153
	list_for_each_entry(ctl, &card->ctl_files, list) {
L
Linus Torvalds 已提交
154 155 156
		if (!ctl->subscribed)
			continue;
		spin_lock_irqsave(&ctl->read_lock, flags);
157
		list_for_each_entry(ev, &ctl->events, list) {
L
Linus Torvalds 已提交
158 159 160 161 162
			if (ev->id.numid == id->numid) {
				ev->mask |= mask;
				goto _found;
			}
		}
163
		ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
L
Linus Torvalds 已提交
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
		if (ev) {
			ev->id = *id;
			ev->mask = mask;
			list_add_tail(&ev->list, &ctl->events);
		} else {
			snd_printk(KERN_ERR "No memory available to allocate event\n");
		}
	_found:
		wake_up(&ctl->change_sleep);
		spin_unlock_irqrestore(&ctl->read_lock, flags);
		kill_fasync(&ctl->fasync, SIGIO, POLL_IN);
	}
	read_unlock(&card->ctl_files_rwlock);
}

179 180
EXPORT_SYMBOL(snd_ctl_notify);

L
Linus Torvalds 已提交
181 182 183 184 185
/**
 * snd_ctl_new - create a control instance from the template
 * @control: the control template
 * @access: the default control access
 *
186
 * Allocates a new struct snd_kcontrol instance and copies the given template 
L
Linus Torvalds 已提交
187 188 189 190
 * to the new instance. It does not copy volatile data (access).
 *
 * Returns the pointer of the new instance, or NULL on failure.
 */
191 192
static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
					unsigned int access)
L
Linus Torvalds 已提交
193
{
194
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
195 196
	unsigned int idx;
	
197 198
	if (snd_BUG_ON(!control || !control->count))
		return NULL;
199 200 201 202

	if (control->count > MAX_CONTROL_COUNT)
		return NULL;

203
	kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
T
Takashi Iwai 已提交
204 205
	if (kctl == NULL) {
		snd_printk(KERN_ERR "Cannot allocate control instance\n");
L
Linus Torvalds 已提交
206
		return NULL;
T
Takashi Iwai 已提交
207
	}
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217 218
	*kctl = *control;
	for (idx = 0; idx < kctl->count; idx++)
		kctl->vd[idx].access = access;
	return kctl;
}

/**
 * snd_ctl_new1 - create a control instance from the template
 * @ncontrol: the initialization record
 * @private_data: the private data to set
 *
219
 * Allocates a new struct snd_kcontrol instance and initialize from the given 
L
Linus Torvalds 已提交
220 221 222 223 224
 * template.  When the access field of ncontrol is 0, it's assumed as
 * READWRITE access. When the count field is 0, it's assumes as one.
 *
 * Returns the pointer of the newly generated instance, or NULL on failure.
 */
225 226
struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
				  void *private_data)
L
Linus Torvalds 已提交
227
{
228
	struct snd_kcontrol kctl;
L
Linus Torvalds 已提交
229 230
	unsigned int access;
	
231 232
	if (snd_BUG_ON(!ncontrol || !ncontrol->info))
		return NULL;
L
Linus Torvalds 已提交
233 234 235 236
	memset(&kctl, 0, sizeof(kctl));
	kctl.id.iface = ncontrol->iface;
	kctl.id.device = ncontrol->device;
	kctl.id.subdevice = ncontrol->subdevice;
237
	if (ncontrol->name) {
L
Linus Torvalds 已提交
238
		strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
239 240 241 242 243
		if (strcmp(ncontrol->name, kctl.id.name) != 0)
			snd_printk(KERN_WARNING
				   "Control name '%s' truncated to '%s'\n",
				   ncontrol->name, kctl.id.name);
	}
L
Linus Torvalds 已提交
244 245 246
	kctl.id.index = ncontrol->index;
	kctl.count = ncontrol->count ? ncontrol->count : 1;
	access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
247 248
		 (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
				      SNDRV_CTL_ELEM_ACCESS_INACTIVE|
249 250 251
				      SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
				      SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND|
				      SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
L
Linus Torvalds 已提交
252 253 254
	kctl.info = ncontrol->info;
	kctl.get = ncontrol->get;
	kctl.put = ncontrol->put;
255
	kctl.tlv.p = ncontrol->tlv.p;
L
Linus Torvalds 已提交
256 257 258 259 260
	kctl.private_value = ncontrol->private_value;
	kctl.private_data = private_data;
	return snd_ctl_new(&kctl, access);
}

261 262
EXPORT_SYMBOL(snd_ctl_new1);

L
Linus Torvalds 已提交
263 264 265 266 267 268 269 270
/**
 * snd_ctl_free_one - release the control instance
 * @kcontrol: the control instance
 *
 * Releases the control instance created via snd_ctl_new()
 * or snd_ctl_new1().
 * Don't call this after the control was added to the card.
 */
271
void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
L
Linus Torvalds 已提交
272 273 274 275 276 277 278 279
{
	if (kcontrol) {
		if (kcontrol->private_free)
			kcontrol->private_free(kcontrol);
		kfree(kcontrol);
	}
}

280 281
EXPORT_SYMBOL(snd_ctl_free_one);

282
static unsigned int snd_ctl_hole_check(struct snd_card *card,
L
Linus Torvalds 已提交
283 284
				       unsigned int count)
{
285
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
286

287
	list_for_each_entry(kctl, &card->controls, list) {
288 289
		if (kctl->id.numid < card->last_numid + 1 + count &&
		    kctl->id.numid + kctl->count > card->last_numid + 1)
L
Linus Torvalds 已提交
290 291 292 293 294
		    	return card->last_numid = kctl->id.numid + kctl->count - 1;
	}
	return card->last_numid;
}

295
static int snd_ctl_find_hole(struct snd_card *card, unsigned int count)
L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
{
	unsigned int last_numid, iter = 100000;

	last_numid = card->last_numid;
	while (last_numid != snd_ctl_hole_check(card, count)) {
		if (--iter == 0) {
			/* this situation is very unlikely */
			snd_printk(KERN_ERR "unable to allocate new control numid\n");
			return -ENOMEM;
		}
		last_numid = card->last_numid;
	}
	return 0;
}

/**
 * snd_ctl_add - add the control instance to the card
 * @card: the card instance
 * @kcontrol: the control instance to add
 *
 * Adds the control instance created via snd_ctl_new() or
 * snd_ctl_new1() to the given card. Assigns also an unique
 * numid used for fast search.
 *
 * Returns zero if successful, or a negative error code on failure.
 *
 * It frees automatically the control which cannot be added.
 */
324
int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
L
Linus Torvalds 已提交
325
{
326
	struct snd_ctl_elem_id id;
L
Linus Torvalds 已提交
327
	unsigned int idx;
328
	int err = -EINVAL;
L
Linus Torvalds 已提交
329

T
Takashi Iwai 已提交
330
	if (! kcontrol)
331
		return err;
332 333
	if (snd_BUG_ON(!card || !kcontrol->info))
		goto error;
L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341 342 343
	id = kcontrol->id;
	down_write(&card->controls_rwsem);
	if (snd_ctl_find_id(card, &id)) {
		up_write(&card->controls_rwsem);
		snd_printd(KERN_ERR "control %i:%i:%i:%s:%i is already present\n",
					id.iface,
					id.device,
					id.subdevice,
					id.name,
					id.index);
344 345
		err = -EBUSY;
		goto error;
L
Linus Torvalds 已提交
346 347 348
	}
	if (snd_ctl_find_hole(card, kcontrol->count) < 0) {
		up_write(&card->controls_rwsem);
349 350
		err = -ENOMEM;
		goto error;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358 359
	}
	list_add_tail(&kcontrol->list, &card->controls);
	card->controls_count += kcontrol->count;
	kcontrol->id.numid = card->last_numid + 1;
	card->last_numid += kcontrol->count;
	up_write(&card->controls_rwsem);
	for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
	return 0;
360 361 362 363

 error:
	snd_ctl_free_one(kcontrol);
	return err;
L
Linus Torvalds 已提交
364 365
}

366 367
EXPORT_SYMBOL(snd_ctl_add);

L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375 376 377 378
/**
 * snd_ctl_remove - remove the control from the card and release it
 * @card: the card instance
 * @kcontrol: the control instance to remove
 *
 * Removes the control from the card and then releases the instance.
 * You don't need to call snd_ctl_free_one(). You must be in
 * the write lock - down_write(&card->controls_rwsem).
 * 
 * Returns 0 if successful, or a negative error code on failure.
 */
379
int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
L
Linus Torvalds 已提交
380
{
381
	struct snd_ctl_elem_id id;
L
Linus Torvalds 已提交
382 383
	unsigned int idx;

384 385
	if (snd_BUG_ON(!card || !kcontrol))
		return -EINVAL;
L
Linus Torvalds 已提交
386 387 388 389 390 391 392 393 394
	list_del(&kcontrol->list);
	card->controls_count -= kcontrol->count;
	id = kcontrol->id;
	for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
	snd_ctl_free_one(kcontrol);
	return 0;
}

395 396
EXPORT_SYMBOL(snd_ctl_remove);

L
Linus Torvalds 已提交
397 398 399 400 401 402 403 404 405 406
/**
 * snd_ctl_remove_id - remove the control of the given id and release it
 * @card: the card instance
 * @id: the control id to remove
 *
 * Finds the control instance with the given id, removes it from the
 * card list and releases it.
 * 
 * Returns 0 if successful, or a negative error code on failure.
 */
407
int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
L
Linus Torvalds 已提交
408
{
409
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
410 411 412 413 414 415 416 417 418 419 420 421 422
	int ret;

	down_write(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, id);
	if (kctl == NULL) {
		up_write(&card->controls_rwsem);
		return -ENOENT;
	}
	ret = snd_ctl_remove(card, kctl);
	up_write(&card->controls_rwsem);
	return ret;
}

423 424
EXPORT_SYMBOL(snd_ctl_remove_id);

L
Linus Torvalds 已提交
425
/**
426
 * snd_ctl_remove_user_ctl - remove and release the unlocked user control
L
Linus Torvalds 已提交
427 428 429 430 431 432 433 434
 * @file: active control handle
 * @id: the control id to remove
 *
 * Finds the control instance with the given id, removes it from the
 * card list and releases it.
 * 
 * Returns 0 if successful, or a negative error code on failure.
 */
435 436
static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
				   struct snd_ctl_elem_id *id)
L
Linus Torvalds 已提交
437
{
438 439
	struct snd_card *card = file->card;
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
440 441 442 443 444
	int idx, ret;

	down_write(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, id);
	if (kctl == NULL) {
445 446
		ret = -ENOENT;
		goto error;
L
Linus Torvalds 已提交
447
	}
448 449 450 451
	if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
		ret = -EINVAL;
		goto error;
	}
L
Linus Torvalds 已提交
452 453
	for (idx = 0; idx < kctl->count; idx++)
		if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
454 455
			ret = -EBUSY;
			goto error;
L
Linus Torvalds 已提交
456 457
		}
	ret = snd_ctl_remove(card, kctl);
458 459 460
	if (ret < 0)
		goto error;
	card->user_ctl_count--;
461
error:
L
Linus Torvalds 已提交
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
	up_write(&card->controls_rwsem);
	return ret;
}

/**
 * snd_ctl_rename_id - replace the id of a control on the card
 * @card: the card instance
 * @src_id: the old id
 * @dst_id: the new id
 *
 * Finds the control with the old id from the card, and replaces the
 * id with the new one.
 *
 * Returns zero if successful, or a negative error code on failure.
 */
477 478
int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
		      struct snd_ctl_elem_id *dst_id)
L
Linus Torvalds 已提交
479
{
480
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494

	down_write(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, src_id);
	if (kctl == NULL) {
		up_write(&card->controls_rwsem);
		return -ENOENT;
	}
	kctl->id = *dst_id;
	kctl->id.numid = card->last_numid + 1;
	card->last_numid += kctl->count;
	up_write(&card->controls_rwsem);
	return 0;
}

495 496
EXPORT_SYMBOL(snd_ctl_rename_id);

L
Linus Torvalds 已提交
497 498 499 500 501 502 503 504 505 506 507 508
/**
 * snd_ctl_find_numid - find the control instance with the given number-id
 * @card: the card instance
 * @numid: the number-id to search
 *
 * Finds the control instance with the given number-id from the card.
 *
 * Returns the pointer of the instance if found, or NULL if not.
 *
 * The caller must down card->controls_rwsem before calling this function
 * (if the race condition can happen).
 */
509
struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
L
Linus Torvalds 已提交
510
{
511
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
512

513 514
	if (snd_BUG_ON(!card || !numid))
		return NULL;
515
	list_for_each_entry(kctl, &card->controls, list) {
L
Linus Torvalds 已提交
516 517 518 519 520 521
		if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
			return kctl;
	}
	return NULL;
}

522 523
EXPORT_SYMBOL(snd_ctl_find_numid);

L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531 532 533 534 535
/**
 * snd_ctl_find_id - find the control instance with the given id
 * @card: the card instance
 * @id: the id to search
 *
 * Finds the control instance with the given id from the card.
 *
 * Returns the pointer of the instance if found, or NULL if not.
 *
 * The caller must down card->controls_rwsem before calling this function
 * (if the race condition can happen).
 */
536 537
struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
				     struct snd_ctl_elem_id *id)
L
Linus Torvalds 已提交
538
{
539
	struct snd_kcontrol *kctl;
L
Linus Torvalds 已提交
540

541 542
	if (snd_BUG_ON(!card || !id))
		return NULL;
L
Linus Torvalds 已提交
543 544
	if (id->numid != 0)
		return snd_ctl_find_numid(card, id->numid);
545
	list_for_each_entry(kctl, &card->controls, list) {
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
		if (kctl->id.iface != id->iface)
			continue;
		if (kctl->id.device != id->device)
			continue;
		if (kctl->id.subdevice != id->subdevice)
			continue;
		if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
			continue;
		if (kctl->id.index > id->index)
			continue;
		if (kctl->id.index + kctl->count <= id->index)
			continue;
		return kctl;
	}
	return NULL;
}

563 564
EXPORT_SYMBOL(snd_ctl_find_id);

565
static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
L
Linus Torvalds 已提交
566 567
			     unsigned int cmd, void __user *arg)
{
568
	struct snd_ctl_card_info *info;
L
Linus Torvalds 已提交
569

570
	info = kzalloc(sizeof(*info), GFP_KERNEL);
L
Linus Torvalds 已提交
571 572 573 574 575 576 577 578 579 580 581
	if (! info)
		return -ENOMEM;
	down_read(&snd_ioctl_rwsem);
	info->card = card->number;
	strlcpy(info->id, card->id, sizeof(info->id));
	strlcpy(info->driver, card->driver, sizeof(info->driver));
	strlcpy(info->name, card->shortname, sizeof(info->name));
	strlcpy(info->longname, card->longname, sizeof(info->longname));
	strlcpy(info->mixername, card->mixername, sizeof(info->mixername));
	strlcpy(info->components, card->components, sizeof(info->components));
	up_read(&snd_ioctl_rwsem);
582
	if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
L
Linus Torvalds 已提交
583 584 585 586 587 588 589
		kfree(info);
		return -EFAULT;
	}
	kfree(info);
	return 0;
}

590 591
static int snd_ctl_elem_list(struct snd_card *card,
			     struct snd_ctl_elem_list __user *_list)
L
Linus Torvalds 已提交
592 593
{
	struct list_head *plist;
594 595 596
	struct snd_ctl_elem_list list;
	struct snd_kcontrol *kctl;
	struct snd_ctl_elem_id *dst, *id;
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604 605 606 607 608
	unsigned int offset, space, first, jidx;
	
	if (copy_from_user(&list, _list, sizeof(list)))
		return -EFAULT;
	offset = list.offset;
	space = list.space;
	first = 0;
	/* try limit maximum space */
	if (space > 16384)
		return -ENOMEM;
	if (space > 0) {
		/* allocate temporary buffer for atomic operation */
609
		dst = vmalloc(space * sizeof(struct snd_ctl_elem_id));
L
Linus Torvalds 已提交
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
		if (dst == NULL)
			return -ENOMEM;
		down_read(&card->controls_rwsem);
		list.count = card->controls_count;
		plist = card->controls.next;
		while (plist != &card->controls) {
			if (offset == 0)
				break;
			kctl = snd_kcontrol(plist);
			if (offset < kctl->count)
				break;
			offset -= kctl->count;
			plist = plist->next;
		}
		list.used = 0;
		id = dst;
		while (space > 0 && plist != &card->controls) {
			kctl = snd_kcontrol(plist);
			for (jidx = offset; space > 0 && jidx < kctl->count; jidx++) {
				snd_ctl_build_ioff(id, kctl, jidx);
				id++;
				space--;
				list.used++;
			}
			plist = plist->next;
			offset = 0;
		}
		up_read(&card->controls_rwsem);
638 639 640
		if (list.used > 0 &&
		    copy_to_user(list.pids, dst,
				 list.used * sizeof(struct snd_ctl_elem_id))) {
L
Linus Torvalds 已提交
641 642 643 644 645 646 647 648 649 650 651 652 653 654
			vfree(dst);
			return -EFAULT;
		}
		vfree(dst);
	} else {
		down_read(&card->controls_rwsem);
		list.count = card->controls_count;
		up_read(&card->controls_rwsem);
	}
	if (copy_to_user(_list, &list, sizeof(list)))
		return -EFAULT;
	return 0;
}

655 656
static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
			     struct snd_ctl_elem_info *info)
L
Linus Torvalds 已提交
657
{
658 659 660
	struct snd_card *card = ctl->card;
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_volatile *vd;
L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669 670 671 672 673 674
	unsigned int index_offset;
	int result;
	
	down_read(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, &info->id);
	if (kctl == NULL) {
		up_read(&card->controls_rwsem);
		return -ENOENT;
	}
#ifdef CONFIG_SND_DEBUG
	info->access = 0;
#endif
	result = kctl->info(kctl, info);
	if (result >= 0) {
675
		snd_BUG_ON(info->access);
L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683
		index_offset = snd_ctl_get_ioff(kctl, &info->id);
		vd = &kctl->vd[index_offset];
		snd_ctl_build_ioff(&info->id, kctl, index_offset);
		info->access = vd->access;
		if (vd->owner) {
			info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
			if (vd->owner == ctl)
				info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
684
			info->owner = pid_vnr(vd->owner->pid);
L
Linus Torvalds 已提交
685 686 687 688 689 690 691 692
		} else {
			info->owner = -1;
		}
	}
	up_read(&card->controls_rwsem);
	return result;
}

693 694
static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
				  struct snd_ctl_elem_info __user *_info)
L
Linus Torvalds 已提交
695
{
696
	struct snd_ctl_elem_info info;
L
Linus Torvalds 已提交
697 698 699 700
	int result;

	if (copy_from_user(&info, _info, sizeof(info)))
		return -EFAULT;
701
	snd_power_lock(ctl->card);
702
	result = snd_power_wait(ctl->card, SNDRV_CTL_POWER_D0);
703 704 705
	if (result >= 0)
		result = snd_ctl_elem_info(ctl, &info);
	snd_power_unlock(ctl->card);
L
Linus Torvalds 已提交
706 707 708 709 710 711
	if (result >= 0)
		if (copy_to_user(_info, &info, sizeof(info)))
			return -EFAULT;
	return result;
}

712 713
static int snd_ctl_elem_read(struct snd_card *card,
			     struct snd_ctl_elem_value *control)
L
Linus Torvalds 已提交
714
{
715 716
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_volatile *vd;
L
Linus Torvalds 已提交
717
	unsigned int index_offset;
718
	int result;
L
Linus Torvalds 已提交
719 720 721 722 723 724 725 726

	down_read(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, &control->id);
	if (kctl == NULL) {
		result = -ENOENT;
	} else {
		index_offset = snd_ctl_get_ioff(kctl, &control->id);
		vd = &kctl->vd[index_offset];
727 728 729 730 731 732
		if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) &&
		    kctl->get != NULL) {
			snd_ctl_build_ioff(&control->id, kctl, index_offset);
			result = kctl->get(kctl, control);
		} else
			result = -EPERM;
L
Linus Torvalds 已提交
733 734 735 736 737
	}
	up_read(&card->controls_rwsem);
	return result;
}

738 739
static int snd_ctl_elem_read_user(struct snd_card *card,
				  struct snd_ctl_elem_value __user *_control)
L
Linus Torvalds 已提交
740
{
741
	struct snd_ctl_elem_value *control;
L
Linus Torvalds 已提交
742
	int result;
L
Li Zefan 已提交
743 744 745 746 747

	control = memdup_user(_control, sizeof(*control));
	if (IS_ERR(control))
		return PTR_ERR(control);

748
	snd_power_lock(card);
749
	result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
750 751 752
	if (result >= 0)
		result = snd_ctl_elem_read(card, control);
	snd_power_unlock(card);
L
Linus Torvalds 已提交
753 754 755 756 757 758 759
	if (result >= 0)
		if (copy_to_user(_control, control, sizeof(*control)))
			result = -EFAULT;
	kfree(control);
	return result;
}

760 761
static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
			      struct snd_ctl_elem_value *control)
L
Linus Torvalds 已提交
762
{
763 764
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_volatile *vd;
L
Linus Torvalds 已提交
765
	unsigned int index_offset;
766
	int result;
L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774

	down_read(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, &control->id);
	if (kctl == NULL) {
		result = -ENOENT;
	} else {
		index_offset = snd_ctl_get_ioff(kctl, &control->id);
		vd = &kctl->vd[index_offset];
775 776 777 778
		if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
		    kctl->put == NULL ||
		    (file && vd->owner && vd->owner != file)) {
			result = -EPERM;
L
Linus Torvalds 已提交
779
		} else {
780 781 782 783 784 785 786 787
			snd_ctl_build_ioff(&control->id, kctl, index_offset);
			result = kctl->put(kctl, control);
		}
		if (result > 0) {
			up_read(&card->controls_rwsem);
			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
				       &control->id);
			return 0;
L
Linus Torvalds 已提交
788 789 790 791 792 793
		}
	}
	up_read(&card->controls_rwsem);
	return result;
}

794 795
static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
				   struct snd_ctl_elem_value __user *_control)
L
Linus Torvalds 已提交
796
{
797
	struct snd_ctl_elem_value *control;
798
	struct snd_card *card;
L
Linus Torvalds 已提交
799 800
	int result;

L
Li Zefan 已提交
801 802 803 804
	control = memdup_user(_control, sizeof(*control));
	if (IS_ERR(control))
		return PTR_ERR(control);

805 806
	card = file->card;
	snd_power_lock(card);
807
	result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
808 809 810
	if (result >= 0)
		result = snd_ctl_elem_write(card, file, control);
	snd_power_unlock(card);
L
Linus Torvalds 已提交
811 812 813 814 815 816 817
	if (result >= 0)
		if (copy_to_user(_control, control, sizeof(*control)))
			result = -EFAULT;
	kfree(control);
	return result;
}

818 819
static int snd_ctl_elem_lock(struct snd_ctl_file *file,
			     struct snd_ctl_elem_id __user *_id)
L
Linus Torvalds 已提交
820
{
821 822 823 824
	struct snd_card *card = file->card;
	struct snd_ctl_elem_id id;
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_volatile *vd;
L
Linus Torvalds 已提交
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
	int result;
	
	if (copy_from_user(&id, _id, sizeof(id)))
		return -EFAULT;
	down_write(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, &id);
	if (kctl == NULL) {
		result = -ENOENT;
	} else {
		vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
		if (vd->owner != NULL)
			result = -EBUSY;
		else {
			vd->owner = file;
			result = 0;
		}
	}
	up_write(&card->controls_rwsem);
	return result;
}

846 847
static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
			       struct snd_ctl_elem_id __user *_id)
L
Linus Torvalds 已提交
848
{
849 850 851 852
	struct snd_card *card = file->card;
	struct snd_ctl_elem_id id;
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_volatile *vd;
L
Linus Torvalds 已提交
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
	int result;
	
	if (copy_from_user(&id, _id, sizeof(id)))
		return -EFAULT;
	down_write(&card->controls_rwsem);
	kctl = snd_ctl_find_id(card, &id);
	if (kctl == NULL) {
		result = -ENOENT;
	} else {
		vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
		if (vd->owner == NULL)
			result = -EINVAL;
		else if (vd->owner != file)
			result = -EPERM;
		else {
			vd->owner = NULL;
			result = 0;
		}
	}
	up_write(&card->controls_rwsem);
	return result;
}

struct user_element {
877
	struct snd_ctl_elem_info info;
L
Linus Torvalds 已提交
878 879
	void *elem_data;		/* element data */
	unsigned long elem_data_size;	/* size of element data in bytes */
880 881
	void *tlv_data;			/* TLV data */
	unsigned long tlv_data_size;	/* TLV data size */
L
Linus Torvalds 已提交
882 883 884 885
	void *priv_data;		/* private data (like strings for enumerated type) */
	unsigned long priv_data_size;	/* size of private data in bytes */
};

886 887
static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
888 889 890 891 892 893 894
{
	struct user_element *ue = kcontrol->private_data;

	*uinfo = ue->info;
	return 0;
}

895 896
static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
897 898 899 900 901 902 903
{
	struct user_element *ue = kcontrol->private_data;

	memcpy(&ucontrol->value, ue->elem_data, ue->elem_data_size);
	return 0;
}

904 905
static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
906 907 908 909 910 911 912 913 914 915
{
	int change;
	struct user_element *ue = kcontrol->private_data;
	
	change = memcmp(&ucontrol->value, ue->elem_data, ue->elem_data_size) != 0;
	if (change)
		memcpy(ue->elem_data, &ucontrol->value, ue->elem_data_size);
	return change;
}

916 917 918 919 920 921 922 923 924 925 926 927
static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol,
				 int op_flag,
				 unsigned int size,
				 unsigned int __user *tlv)
{
	struct user_element *ue = kcontrol->private_data;
	int change = 0;
	void *new_data;

	if (op_flag > 0) {
		if (size > 1024 * 128)	/* sane value */
			return -EINVAL;
L
Li Zefan 已提交
928 929 930 931

		new_data = memdup_user(tlv, size);
		if (IS_ERR(new_data))
			return PTR_ERR(new_data);
932 933 934 935 936 937 938
		change = ue->tlv_data_size != size;
		if (!change)
			change = memcmp(ue->tlv_data, new_data, size);
		kfree(ue->tlv_data);
		ue->tlv_data = new_data;
		ue->tlv_data_size = size;
	} else {
939 940
		if (! ue->tlv_data_size || ! ue->tlv_data)
			return -ENXIO;
941 942 943 944 945 946 947 948
		if (size < ue->tlv_data_size)
			return -ENOSPC;
		if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size))
			return -EFAULT;
	}
	return change;
}

949
static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol)
L
Linus Torvalds 已提交
950
{
951 952 953 954
	struct user_element *ue = kcontrol->private_data;
	if (ue->tlv_data)
		kfree(ue->tlv_data);
	kfree(ue);
L
Linus Torvalds 已提交
955 956
}

957 958
static int snd_ctl_elem_add(struct snd_ctl_file *file,
			    struct snd_ctl_elem_info *info, int replace)
L
Linus Torvalds 已提交
959
{
960 961
	struct snd_card *card = file->card;
	struct snd_kcontrol kctl, *_kctl;
L
Linus Torvalds 已提交
962 963 964 965 966 967 968
	unsigned int access;
	long private_size;
	struct user_element *ue;
	int idx, err;
	
	if (card->user_ctl_count >= MAX_USER_CONTROLS)
		return -ENOMEM;
969
	if (info->count < 1)
L
Linus Torvalds 已提交
970 971
		return -EINVAL;
	access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
972
		(info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
973 974
				 SNDRV_CTL_ELEM_ACCESS_INACTIVE|
				 SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE));
L
Linus Torvalds 已提交
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
	info->id.numid = 0;
	memset(&kctl, 0, sizeof(kctl));
	down_write(&card->controls_rwsem);
	_kctl = snd_ctl_find_id(card, &info->id);
	err = 0;
	if (_kctl) {
		if (replace)
			err = snd_ctl_remove(card, _kctl);
		else
			err = -EBUSY;
	} else {
		if (replace)
			err = -ENOENT;
	}
	up_write(&card->controls_rwsem);
	if (err < 0)
		return err;
	memcpy(&kctl.id, &info->id, sizeof(info->id));
	kctl.count = info->owner ? info->owner : 1;
	access |= SNDRV_CTL_ELEM_ACCESS_USER;
	kctl.info = snd_ctl_elem_user_info;
	if (access & SNDRV_CTL_ELEM_ACCESS_READ)
		kctl.get = snd_ctl_elem_user_get;
	if (access & SNDRV_CTL_ELEM_ACCESS_WRITE)
		kctl.put = snd_ctl_elem_user_put;
1000 1001 1002 1003
	if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
		kctl.tlv.c = snd_ctl_elem_user_tlv;
		access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
	}
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
	switch (info->type) {
	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
	case SNDRV_CTL_ELEM_TYPE_INTEGER:
		private_size = sizeof(long);
		if (info->count > 128)
			return -EINVAL;
		break;
	case SNDRV_CTL_ELEM_TYPE_INTEGER64:
		private_size = sizeof(long long);
		if (info->count > 64)
			return -EINVAL;
		break;
	case SNDRV_CTL_ELEM_TYPE_BYTES:
		private_size = sizeof(unsigned char);
		if (info->count > 512)
			return -EINVAL;
		break;
	case SNDRV_CTL_ELEM_TYPE_IEC958:
1022
		private_size = sizeof(struct snd_aes_iec958);
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029
		if (info->count != 1)
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	}
	private_size *= info->count;
1030
	ue = kzalloc(sizeof(struct user_element) + private_size, GFP_KERNEL);
L
Linus Torvalds 已提交
1031 1032 1033
	if (ue == NULL)
		return -ENOMEM;
	ue->info = *info;
1034
	ue->info.access = 0;
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039
	ue->elem_data = (char *)ue + sizeof(*ue);
	ue->elem_data_size = private_size;
	kctl.private_free = snd_ctl_elem_user_free;
	_kctl = snd_ctl_new(&kctl, access);
	if (_kctl == NULL) {
1040
		kfree(ue);
L
Linus Torvalds 已提交
1041 1042 1043 1044 1045 1046
		return -ENOMEM;
	}
	_kctl->private_data = ue;
	for (idx = 0; idx < _kctl->count; idx++)
		_kctl->vd[idx].owner = file;
	err = snd_ctl_add(card, _kctl);
1047
	if (err < 0)
L
Linus Torvalds 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056
		return err;

	down_write(&card->controls_rwsem);
	card->user_ctl_count++;
	up_write(&card->controls_rwsem);

	return 0;
}

1057 1058
static int snd_ctl_elem_add_user(struct snd_ctl_file *file,
				 struct snd_ctl_elem_info __user *_info, int replace)
L
Linus Torvalds 已提交
1059
{
1060
	struct snd_ctl_elem_info info;
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065
	if (copy_from_user(&info, _info, sizeof(info)))
		return -EFAULT;
	return snd_ctl_elem_add(file, &info, replace);
}

1066 1067
static int snd_ctl_elem_remove(struct snd_ctl_file *file,
			       struct snd_ctl_elem_id __user *_id)
L
Linus Torvalds 已提交
1068
{
1069
	struct snd_ctl_elem_id id;
L
Linus Torvalds 已提交
1070 1071 1072

	if (copy_from_user(&id, _id, sizeof(id)))
		return -EFAULT;
1073
	return snd_ctl_remove_user_ctl(file, &id);
L
Linus Torvalds 已提交
1074 1075
}

1076
static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
{
	int subscribe;
	if (get_user(subscribe, ptr))
		return -EFAULT;
	if (subscribe < 0) {
		subscribe = file->subscribed;
		if (put_user(subscribe, ptr))
			return -EFAULT;
		return 0;
	}
	if (subscribe) {
		file->subscribed = 1;
		return 0;
	} else if (file->subscribed) {
		snd_ctl_empty_read_queue(file);
		file->subscribed = 0;
	}
	return 0;
}

1097 1098 1099
static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
                             struct snd_ctl_tlv __user *_tlv,
                             int op_flag)
1100
{
1101
	struct snd_card *card = file->card;
1102 1103
	struct snd_ctl_tlv tlv;
	struct snd_kcontrol *kctl;
1104
	struct snd_kcontrol_volatile *vd;
1105 1106 1107 1108 1109
	unsigned int len;
	int err = 0;

	if (copy_from_user(&tlv, _tlv, sizeof(tlv)))
		return -EFAULT;
1110
	if (tlv.length < sizeof(unsigned int) * 2)
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
		return -EINVAL;
	down_read(&card->controls_rwsem);
	kctl = snd_ctl_find_numid(card, tlv.numid);
	if (kctl == NULL) {
		err = -ENOENT;
		goto __kctl_end;
	}
	if (kctl->tlv.p == NULL) {
		err = -ENXIO;
		goto __kctl_end;
	}
	vd = &kctl->vd[tlv.numid - kctl->id.numid];
	if ((op_flag == 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) == 0) ||
	    (op_flag > 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) == 0) ||
	    (op_flag < 0 && (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) == 0)) {
	    	err = -ENXIO;
	    	goto __kctl_end;
	}
	if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1130
		if (vd->owner != NULL && vd->owner != file) {
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
			err = -EPERM;
			goto __kctl_end;
		}
		err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv); 
		if (err > 0) {
			up_read(&card->controls_rwsem);
			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &kctl->id);
			return 0;
		}
	} else {
		if (op_flag) {
			err = -ENXIO;
			goto __kctl_end;
		}
		len = kctl->tlv.p[1] + 2 * sizeof(unsigned int);
		if (tlv.length < len) {
			err = -ENOMEM;
			goto __kctl_end;
		}
		if (copy_to_user(_tlv->tlv, kctl->tlv.p, len))
			err = -EFAULT;
	}
1153
      __kctl_end:
1154 1155
	up_read(&card->controls_rwsem);
	return err;
1156 1157
}

L
Linus Torvalds 已提交
1158 1159
static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
1160 1161 1162
	struct snd_ctl_file *ctl;
	struct snd_card *card;
	struct snd_kctl_ioctl *p;
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168
	void __user *argp = (void __user *)arg;
	int __user *ip = argp;
	int err;

	ctl = file->private_data;
	card = ctl->card;
1169 1170
	if (snd_BUG_ON(!card))
		return -ENXIO;
L
Linus Torvalds 已提交
1171 1172 1173 1174 1175 1176
	switch (cmd) {
	case SNDRV_CTL_IOCTL_PVERSION:
		return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
	case SNDRV_CTL_IOCTL_CARD_INFO:
		return snd_ctl_card_info(card, ctl, cmd, argp);
	case SNDRV_CTL_IOCTL_ELEM_LIST:
1177
		return snd_ctl_elem_list(card, argp);
L
Linus Torvalds 已提交
1178 1179 1180
	case SNDRV_CTL_IOCTL_ELEM_INFO:
		return snd_ctl_elem_info_user(ctl, argp);
	case SNDRV_CTL_IOCTL_ELEM_READ:
1181
		return snd_ctl_elem_read_user(card, argp);
L
Linus Torvalds 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
	case SNDRV_CTL_IOCTL_ELEM_WRITE:
		return snd_ctl_elem_write_user(ctl, argp);
	case SNDRV_CTL_IOCTL_ELEM_LOCK:
		return snd_ctl_elem_lock(ctl, argp);
	case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
		return snd_ctl_elem_unlock(ctl, argp);
	case SNDRV_CTL_IOCTL_ELEM_ADD:
		return snd_ctl_elem_add_user(ctl, argp, 0);
	case SNDRV_CTL_IOCTL_ELEM_REPLACE:
		return snd_ctl_elem_add_user(ctl, argp, 1);
	case SNDRV_CTL_IOCTL_ELEM_REMOVE:
		return snd_ctl_elem_remove(ctl, argp);
	case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
		return snd_ctl_subscribe_events(ctl, ip);
1196 1197 1198 1199 1200 1201
	case SNDRV_CTL_IOCTL_TLV_READ:
		return snd_ctl_tlv_ioctl(ctl, argp, 0);
	case SNDRV_CTL_IOCTL_TLV_WRITE:
		return snd_ctl_tlv_ioctl(ctl, argp, 1);
	case SNDRV_CTL_IOCTL_TLV_COMMAND:
		return snd_ctl_tlv_ioctl(ctl, argp, -1);
L
Linus Torvalds 已提交
1202
	case SNDRV_CTL_IOCTL_POWER:
T
Takashi Iwai 已提交
1203
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209 1210 1211
	case SNDRV_CTL_IOCTL_POWER_STATE:
#ifdef CONFIG_PM
		return put_user(card->power_state, ip) ? -EFAULT : 0;
#else
		return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
#endif
	}
	down_read(&snd_ioctl_rwsem);
1212
	list_for_each_entry(p, &snd_control_ioctls, list) {
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218 1219
		err = p->fioctl(card, ctl, cmd, arg);
		if (err != -ENOIOCTLCMD) {
			up_read(&snd_ioctl_rwsem);
			return err;
		}
	}
	up_read(&snd_ioctl_rwsem);
T
Takashi Iwai 已提交
1220
	snd_printdd("unknown ioctl = 0x%x\n", cmd);
L
Linus Torvalds 已提交
1221 1222 1223
	return -ENOTTY;
}

1224 1225
static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
			    size_t count, loff_t * offset)
L
Linus Torvalds 已提交
1226
{
1227
	struct snd_ctl_file *ctl;
L
Linus Torvalds 已提交
1228 1229 1230 1231
	int err = 0;
	ssize_t result = 0;

	ctl = file->private_data;
1232 1233
	if (snd_BUG_ON(!ctl || !ctl->card))
		return -ENXIO;
L
Linus Torvalds 已提交
1234 1235
	if (!ctl->subscribed)
		return -EBADFD;
1236
	if (count < sizeof(struct snd_ctl_event))
L
Linus Torvalds 已提交
1237 1238
		return -EINVAL;
	spin_lock_irq(&ctl->read_lock);
1239 1240 1241
	while (count >= sizeof(struct snd_ctl_event)) {
		struct snd_ctl_event ev;
		struct snd_kctl_event *kev;
L
Linus Torvalds 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
		while (list_empty(&ctl->events)) {
			wait_queue_t wait;
			if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
				err = -EAGAIN;
				goto __end_lock;
			}
			init_waitqueue_entry(&wait, current);
			add_wait_queue(&ctl->change_sleep, &wait);
			set_current_state(TASK_INTERRUPTIBLE);
			spin_unlock_irq(&ctl->read_lock);
			schedule();
			remove_wait_queue(&ctl->change_sleep, &wait);
			if (signal_pending(current))
1255
				return -ERESTARTSYS;
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264
			spin_lock_irq(&ctl->read_lock);
		}
		kev = snd_kctl_event(ctl->events.next);
		ev.type = SNDRV_CTL_EVENT_ELEM;
		ev.data.elem.mask = kev->mask;
		ev.data.elem.id = kev->id;
		list_del(&kev->list);
		spin_unlock_irq(&ctl->read_lock);
		kfree(kev);
1265
		if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) {
L
Linus Torvalds 已提交
1266 1267 1268 1269
			err = -EFAULT;
			goto __end;
		}
		spin_lock_irq(&ctl->read_lock);
1270 1271 1272
		buffer += sizeof(struct snd_ctl_event);
		count -= sizeof(struct snd_ctl_event);
		result += sizeof(struct snd_ctl_event);
L
Linus Torvalds 已提交
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
	}
      __end_lock:
	spin_unlock_irq(&ctl->read_lock);
      __end:
      	return result > 0 ? result : err;
}

static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
{
	unsigned int mask;
1283
	struct snd_ctl_file *ctl;
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

	ctl = file->private_data;
	if (!ctl->subscribed)
		return 0;
	poll_wait(file, &ctl->change_sleep, wait);

	mask = 0;
	if (!list_empty(&ctl->events))
		mask |= POLLIN | POLLRDNORM;

	return mask;
}

/*
 * register the device-specific control-ioctls.
 * called from each device manager like pcm.c, hwdep.c, etc.
 */
static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists)
{
1303
	struct snd_kctl_ioctl *pn;
L
Linus Torvalds 已提交
1304

1305
	pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL);
L
Linus Torvalds 已提交
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
	if (pn == NULL)
		return -ENOMEM;
	pn->fioctl = fcn;
	down_write(&snd_ioctl_rwsem);
	list_add_tail(&pn->list, lists);
	up_write(&snd_ioctl_rwsem);
	return 0;
}

int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
{
	return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
}

1320 1321
EXPORT_SYMBOL(snd_ctl_register_ioctl);

L
Linus Torvalds 已提交
1322 1323 1324 1325 1326
#ifdef CONFIG_COMPAT
int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
{
	return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
}
1327 1328

EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
L
Linus Torvalds 已提交
1329 1330 1331 1332 1333
#endif

/*
 * de-register the device-specific control-ioctls.
 */
1334 1335
static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
				     struct list_head *lists)
L
Linus Torvalds 已提交
1336
{
1337
	struct snd_kctl_ioctl *p;
L
Linus Torvalds 已提交
1338

1339 1340
	if (snd_BUG_ON(!fcn))
		return -EINVAL;
L
Linus Torvalds 已提交
1341
	down_write(&snd_ioctl_rwsem);
1342
	list_for_each_entry(p, lists, list) {
L
Linus Torvalds 已提交
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
		if (p->fioctl == fcn) {
			list_del(&p->list);
			up_write(&snd_ioctl_rwsem);
			kfree(p);
			return 0;
		}
	}
	up_write(&snd_ioctl_rwsem);
	snd_BUG();
	return -EINVAL;
}

int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
{
	return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
}

1360 1361
EXPORT_SYMBOL(snd_ctl_unregister_ioctl);

L
Linus Torvalds 已提交
1362 1363 1364 1365 1366 1367
#ifdef CONFIG_COMPAT
int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
{
	return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
}

1368
EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
L
Linus Torvalds 已提交
1369 1370 1371 1372
#endif

static int snd_ctl_fasync(int fd, struct file * file, int on)
{
1373
	struct snd_ctl_file *ctl;
1374

L
Linus Torvalds 已提交
1375
	ctl = file->private_data;
1376
	return fasync_helper(fd, file, on, &ctl->fasync);
L
Linus Torvalds 已提交
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
}

/*
 * ioctl32 compat
 */
#ifdef CONFIG_COMPAT
#include "control_compat.c"
#else
#define snd_ctl_ioctl_compat	NULL
#endif

/*
 *  INIT PART
 */

1392
static const struct file_operations snd_ctl_f_ops =
L
Linus Torvalds 已提交
1393 1394 1395 1396 1397
{
	.owner =	THIS_MODULE,
	.read =		snd_ctl_read,
	.open =		snd_ctl_open,
	.release =	snd_ctl_release,
T
Takashi Iwai 已提交
1398
	.llseek =	no_llseek,
L
Linus Torvalds 已提交
1399 1400 1401 1402 1403 1404 1405 1406 1407
	.poll =		snd_ctl_poll,
	.unlocked_ioctl =	snd_ctl_ioctl,
	.compat_ioctl =	snd_ctl_ioctl_compat,
	.fasync =	snd_ctl_fasync,
};

/*
 * registration of the control device
 */
1408
static int snd_ctl_dev_register(struct snd_device *device)
L
Linus Torvalds 已提交
1409
{
1410
	struct snd_card *card = device->device_data;
L
Linus Torvalds 已提交
1411 1412 1413
	int err, cardnum;
	char name[16];

1414 1415
	if (snd_BUG_ON(!card))
		return -ENXIO;
L
Linus Torvalds 已提交
1416
	cardnum = card->number;
1417 1418
	if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
		return -ENXIO;
L
Linus Torvalds 已提交
1419
	sprintf(name, "controlC%i", cardnum);
1420 1421
	if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
				       &snd_ctl_f_ops, card, name)) < 0)
L
Linus Torvalds 已提交
1422 1423 1424 1425 1426 1427 1428
		return err;
	return 0;
}

/*
 * disconnection of the control device
 */
1429
static int snd_ctl_dev_disconnect(struct snd_device *device)
L
Linus Torvalds 已提交
1430
{
1431 1432
	struct snd_card *card = device->device_data;
	struct snd_ctl_file *ctl;
1433 1434
	int err, cardnum;

1435 1436
	if (snd_BUG_ON(!card))
		return -ENXIO;
1437
	cardnum = card->number;
1438 1439
	if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
		return -ENXIO;
L
Linus Torvalds 已提交
1440

1441
	read_lock(&card->ctl_files_rwlock);
1442
	list_for_each_entry(ctl, &card->ctl_files, list) {
L
Linus Torvalds 已提交
1443 1444 1445
		wake_up(&ctl->change_sleep);
		kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
	}
1446
	read_unlock(&card->ctl_files_rwlock);
1447 1448 1449 1450

	if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
					 card, -1)) < 0)
		return err;
L
Linus Torvalds 已提交
1451 1452 1453 1454 1455 1456
	return 0;
}

/*
 * free all controls
 */
1457
static int snd_ctl_dev_free(struct snd_device *device)
L
Linus Torvalds 已提交
1458
{
1459 1460
	struct snd_card *card = device->device_data;
	struct snd_kcontrol *control;
L
Linus Torvalds 已提交
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474

	down_write(&card->controls_rwsem);
	while (!list_empty(&card->controls)) {
		control = snd_kcontrol(card->controls.next);
		snd_ctl_remove(card, control);
	}
	up_write(&card->controls_rwsem);
	return 0;
}

/*
 * create control core:
 * called from init.c
 */
1475
int snd_ctl_create(struct snd_card *card)
L
Linus Torvalds 已提交
1476
{
1477
	static struct snd_device_ops ops = {
L
Linus Torvalds 已提交
1478 1479 1480 1481 1482
		.dev_free = snd_ctl_dev_free,
		.dev_register =	snd_ctl_dev_register,
		.dev_disconnect = snd_ctl_dev_disconnect,
	};

1483 1484
	if (snd_BUG_ON(!card))
		return -ENXIO;
L
Linus Torvalds 已提交
1485 1486
	return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
}
1487 1488

/*
1489
 * Frequently used control callbacks/helpers
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
 */
int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
			      struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

EXPORT_SYMBOL(snd_ctl_boolean_mono_info);

int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = 2;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

EXPORT_SYMBOL(snd_ctl_boolean_stereo_info);
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539

/**
 * snd_ctl_enum_info - fills the info structure for an enumerated control
 * @info: the structure to be filled
 * @channels: the number of the control's channels; often one
 * @items: the number of control values; also the size of @names
 * @names: an array containing the names of all control values
 *
 * Sets all required fields in @info to their appropriate values.
 * If the control's accessibility is not the default (readable and writable),
 * the caller has to fill @info->access.
 */
int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
		      unsigned int items, const char *const names[])
{
	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	info->count = channels;
	info->value.enumerated.items = items;
	if (info->value.enumerated.item >= items)
		info->value.enumerated.item = items - 1;
	strlcpy(info->value.enumerated.name,
		names[info->value.enumerated.item],
		sizeof(info->value.enumerated.name));
	return 0;
}
EXPORT_SYMBOL(snd_ctl_enum_info);