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