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