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 mutex_lock(&ue->card->user_ctl_lock); 1099 memcpy(&ucontrol->value, src, size); 1100 mutex_unlock(&ue->card->user_ctl_lock); 1101 return 0; 1102 } 1103 1104 static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol, 1105 struct snd_ctl_elem_value *ucontrol) 1106 { 1107 int change; 1108 struct user_element *ue = kcontrol->private_data; 1109 unsigned int size = ue->elem_data_size; 1110 char *dst = ue->elem_data + 1111 snd_ctl_get_ioff(kcontrol, &ucontrol->id) * size; 1112 1113 mutex_lock(&ue->card->user_ctl_lock); 1114 change = memcmp(&ucontrol->value, dst, size) != 0; 1115 if (change) 1116 memcpy(dst, &ucontrol->value, size); 1117 mutex_unlock(&ue->card->user_ctl_lock); 1118 return change; 1119 } 1120 1121 static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol, 1122 int op_flag, 1123 unsigned int size, 1124 unsigned int __user *tlv) 1125 { 1126 struct user_element *ue = kcontrol->private_data; 1127 int change = 0; 1128 void *new_data; 1129 1130 if (op_flag == SNDRV_CTL_TLV_OP_WRITE) { 1131 if (size > 1024 * 128) /* sane value */ 1132 return -EINVAL; 1133 1134 new_data = memdup_user(tlv, size); 1135 if (IS_ERR(new_data)) 1136 return PTR_ERR(new_data); 1137 mutex_lock(&ue->card->user_ctl_lock); 1138 change = ue->tlv_data_size != size; 1139 if (!change) 1140 change = memcmp(ue->tlv_data, new_data, size); 1141 kfree(ue->tlv_data); 1142 ue->tlv_data = new_data; 1143 ue->tlv_data_size = size; 1144 mutex_unlock(&ue->card->user_ctl_lock); 1145 } else { 1146 int ret = 0; 1147 1148 mutex_lock(&ue->card->user_ctl_lock); 1149 if (!ue->tlv_data_size || !ue->tlv_data) { 1150 ret = -ENXIO; 1151 goto err_unlock; 1152 } 1153 if (size < ue->tlv_data_size) { 1154 ret = -ENOSPC; 1155 goto err_unlock; 1156 } 1157 if (copy_to_user(tlv, ue->tlv_data, ue->tlv_data_size)) 1158 ret = -EFAULT; 1159 err_unlock: 1160 mutex_unlock(&ue->card->user_ctl_lock); 1161 if (ret) 1162 return ret; 1163 } 1164 return change; 1165 } 1166 1167 static int snd_ctl_elem_init_enum_names(struct user_element *ue) 1168 { 1169 char *names, *p; 1170 size_t buf_len, name_len; 1171 unsigned int i; 1172 const uintptr_t user_ptrval = ue->info.value.enumerated.names_ptr; 1173 1174 if (ue->info.value.enumerated.names_length > 64 * 1024) 1175 return -EINVAL; 1176 1177 names = memdup_user((const void __user *)user_ptrval, 1178 ue->info.value.enumerated.names_length); 1179 if (IS_ERR(names)) 1180 return PTR_ERR(names); 1181 1182 /* check that there are enough valid names */ 1183 buf_len = ue->info.value.enumerated.names_length; 1184 p = names; 1185 for (i = 0; i < ue->info.value.enumerated.items; ++i) { 1186 name_len = strnlen(p, buf_len); 1187 if (name_len == 0 || name_len >= 64 || name_len == buf_len) { 1188 kfree(names); 1189 return -EINVAL; 1190 } 1191 p += name_len + 1; 1192 buf_len -= name_len + 1; 1193 } 1194 1195 ue->priv_data = names; 1196 ue->info.value.enumerated.names_ptr = 0; 1197 1198 return 0; 1199 } 1200 1201 static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol) 1202 { 1203 struct user_element *ue = kcontrol->private_data; 1204 1205 kfree(ue->tlv_data); 1206 kfree(ue->priv_data); 1207 kfree(ue); 1208 } 1209 1210 static int snd_ctl_elem_add(struct snd_ctl_file *file, 1211 struct snd_ctl_elem_info *info, int replace) 1212 { 1213 /* The capacity of struct snd_ctl_elem_value.value.*/ 1214 static const unsigned int value_sizes[] = { 1215 [SNDRV_CTL_ELEM_TYPE_BOOLEAN] = sizeof(long), 1216 [SNDRV_CTL_ELEM_TYPE_INTEGER] = sizeof(long), 1217 [SNDRV_CTL_ELEM_TYPE_ENUMERATED] = sizeof(unsigned int), 1218 [SNDRV_CTL_ELEM_TYPE_BYTES] = sizeof(unsigned char), 1219 [SNDRV_CTL_ELEM_TYPE_IEC958] = sizeof(struct snd_aes_iec958), 1220 [SNDRV_CTL_ELEM_TYPE_INTEGER64] = sizeof(long long), 1221 }; 1222 static const unsigned int max_value_counts[] = { 1223 [SNDRV_CTL_ELEM_TYPE_BOOLEAN] = 128, 1224 [SNDRV_CTL_ELEM_TYPE_INTEGER] = 128, 1225 [SNDRV_CTL_ELEM_TYPE_ENUMERATED] = 128, 1226 [SNDRV_CTL_ELEM_TYPE_BYTES] = 512, 1227 [SNDRV_CTL_ELEM_TYPE_IEC958] = 1, 1228 [SNDRV_CTL_ELEM_TYPE_INTEGER64] = 64, 1229 }; 1230 struct snd_card *card = file->card; 1231 struct snd_kcontrol *kctl; 1232 unsigned int count; 1233 unsigned int access; 1234 long private_size; 1235 struct user_element *ue; 1236 unsigned int offset; 1237 int err; 1238 1239 if (!*info->id.name) 1240 return -EINVAL; 1241 if (strnlen(info->id.name, sizeof(info->id.name)) >= sizeof(info->id.name)) 1242 return -EINVAL; 1243 1244 /* Delete a control to replace them if needed. */ 1245 if (replace) { 1246 info->id.numid = 0; 1247 err = snd_ctl_remove_user_ctl(file, &info->id); 1248 if (err) 1249 return err; 1250 } 1251 1252 /* 1253 * The number of userspace controls are counted control by control, 1254 * not element by element. 1255 */ 1256 if (card->user_ctl_count + 1 > MAX_USER_CONTROLS) 1257 return -ENOMEM; 1258 1259 /* Check the number of elements for this userspace control. */ 1260 count = info->owner; 1261 if (count == 0) 1262 count = 1; 1263 1264 /* Arrange access permissions if needed. */ 1265 access = info->access; 1266 if (access == 0) 1267 access = SNDRV_CTL_ELEM_ACCESS_READWRITE; 1268 access &= (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1269 SNDRV_CTL_ELEM_ACCESS_INACTIVE | 1270 SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE); 1271 if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) 1272 access |= SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 1273 access |= SNDRV_CTL_ELEM_ACCESS_USER; 1274 1275 /* 1276 * Check information and calculate the size of data specific to 1277 * this userspace control. 1278 */ 1279 if (info->type < SNDRV_CTL_ELEM_TYPE_BOOLEAN || 1280 info->type > SNDRV_CTL_ELEM_TYPE_INTEGER64) 1281 return -EINVAL; 1282 if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED && 1283 info->value.enumerated.items == 0) 1284 return -EINVAL; 1285 if (info->count < 1 || 1286 info->count > max_value_counts[info->type]) 1287 return -EINVAL; 1288 if (!validate_element_member_dimension(info)) 1289 return -EINVAL; 1290 private_size = value_sizes[info->type] * info->count; 1291 1292 /* 1293 * Keep memory object for this userspace control. After passing this 1294 * code block, the instance should be freed by snd_ctl_free_one(). 1295 * 1296 * Note that these elements in this control are locked. 1297 */ 1298 err = snd_ctl_new(&kctl, count, access, file); 1299 if (err < 0) 1300 return err; 1301 memcpy(&kctl->id, &info->id, sizeof(kctl->id)); 1302 kctl->private_data = kzalloc(sizeof(struct user_element) + private_size * count, 1303 GFP_KERNEL); 1304 if (kctl->private_data == NULL) { 1305 kfree(kctl); 1306 return -ENOMEM; 1307 } 1308 kctl->private_free = snd_ctl_elem_user_free; 1309 1310 /* Set private data for this userspace control. */ 1311 ue = (struct user_element *)kctl->private_data; 1312 ue->card = card; 1313 ue->info = *info; 1314 ue->info.access = 0; 1315 ue->elem_data = (char *)ue + sizeof(*ue); 1316 ue->elem_data_size = private_size; 1317 if (ue->info.type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) { 1318 err = snd_ctl_elem_init_enum_names(ue); 1319 if (err < 0) { 1320 snd_ctl_free_one(kctl); 1321 return err; 1322 } 1323 } 1324 1325 /* Set callback functions. */ 1326 if (info->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) 1327 kctl->info = snd_ctl_elem_user_enum_info; 1328 else 1329 kctl->info = snd_ctl_elem_user_info; 1330 if (access & SNDRV_CTL_ELEM_ACCESS_READ) 1331 kctl->get = snd_ctl_elem_user_get; 1332 if (access & SNDRV_CTL_ELEM_ACCESS_WRITE) 1333 kctl->put = snd_ctl_elem_user_put; 1334 if (access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) 1335 kctl->tlv.c = snd_ctl_elem_user_tlv; 1336 1337 /* This function manage to free the instance on failure. */ 1338 err = snd_ctl_add(card, kctl); 1339 if (err < 0) 1340 return err; 1341 offset = snd_ctl_get_ioff(kctl, &info->id); 1342 snd_ctl_build_ioff(&info->id, kctl, offset); 1343 /* 1344 * Here we cannot fill any field for the number of elements added by 1345 * this operation because there're no specific fields. The usage of 1346 * 'owner' field for this purpose may cause any bugs to userspace 1347 * applications because the field originally means PID of a process 1348 * which locks the element. 1349 */ 1350 1351 down_write(&card->controls_rwsem); 1352 card->user_ctl_count++; 1353 up_write(&card->controls_rwsem); 1354 1355 return 0; 1356 } 1357 1358 static int snd_ctl_elem_add_user(struct snd_ctl_file *file, 1359 struct snd_ctl_elem_info __user *_info, int replace) 1360 { 1361 struct snd_ctl_elem_info info; 1362 int err; 1363 1364 if (copy_from_user(&info, _info, sizeof(info))) 1365 return -EFAULT; 1366 err = snd_ctl_elem_add(file, &info, replace); 1367 if (err < 0) 1368 return err; 1369 if (copy_to_user(_info, &info, sizeof(info))) { 1370 snd_ctl_remove_user_ctl(file, &info.id); 1371 return -EFAULT; 1372 } 1373 1374 return 0; 1375 } 1376 1377 static int snd_ctl_elem_remove(struct snd_ctl_file *file, 1378 struct snd_ctl_elem_id __user *_id) 1379 { 1380 struct snd_ctl_elem_id id; 1381 1382 if (copy_from_user(&id, _id, sizeof(id))) 1383 return -EFAULT; 1384 return snd_ctl_remove_user_ctl(file, &id); 1385 } 1386 1387 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr) 1388 { 1389 int subscribe; 1390 if (get_user(subscribe, ptr)) 1391 return -EFAULT; 1392 if (subscribe < 0) { 1393 subscribe = file->subscribed; 1394 if (put_user(subscribe, ptr)) 1395 return -EFAULT; 1396 return 0; 1397 } 1398 if (subscribe) { 1399 file->subscribed = 1; 1400 return 0; 1401 } else if (file->subscribed) { 1402 snd_ctl_empty_read_queue(file); 1403 file->subscribed = 0; 1404 } 1405 return 0; 1406 } 1407 1408 static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file, 1409 struct snd_ctl_tlv __user *_tlv, 1410 int op_flag) 1411 { 1412 struct snd_card *card = file->card; 1413 struct snd_ctl_tlv tlv; 1414 struct snd_kcontrol *kctl; 1415 struct snd_kcontrol_volatile *vd; 1416 unsigned int len; 1417 int err = 0; 1418 1419 if (copy_from_user(&tlv, _tlv, sizeof(tlv))) 1420 return -EFAULT; 1421 if (tlv.length < sizeof(unsigned int) * 2) 1422 return -EINVAL; 1423 if (!tlv.numid) 1424 return -EINVAL; 1425 down_read(&card->controls_rwsem); 1426 kctl = snd_ctl_find_numid(card, tlv.numid); 1427 if (kctl == NULL) { 1428 err = -ENOENT; 1429 goto __kctl_end; 1430 } 1431 if (kctl->tlv.p == NULL) { 1432 err = -ENXIO; 1433 goto __kctl_end; 1434 } 1435 vd = &kctl->vd[tlv.numid - kctl->id.numid]; 1436 if ((op_flag == SNDRV_CTL_TLV_OP_READ && 1437 (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) == 0) || 1438 (op_flag == SNDRV_CTL_TLV_OP_WRITE && 1439 (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) == 0) || 1440 (op_flag == SNDRV_CTL_TLV_OP_CMD && 1441 (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) == 0)) { 1442 err = -ENXIO; 1443 goto __kctl_end; 1444 } 1445 if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) { 1446 if (vd->owner != NULL && vd->owner != file) { 1447 err = -EPERM; 1448 goto __kctl_end; 1449 } 1450 err = kctl->tlv.c(kctl, op_flag, tlv.length, _tlv->tlv); 1451 if (err > 0) { 1452 struct snd_ctl_elem_id id = kctl->id; 1453 up_read(&card->controls_rwsem); 1454 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_TLV, &id); 1455 return 0; 1456 } 1457 } else { 1458 if (op_flag != SNDRV_CTL_TLV_OP_READ) { 1459 err = -ENXIO; 1460 goto __kctl_end; 1461 } 1462 len = kctl->tlv.p[1] + 2 * sizeof(unsigned int); 1463 if (tlv.length < len) { 1464 err = -ENOMEM; 1465 goto __kctl_end; 1466 } 1467 if (copy_to_user(_tlv->tlv, kctl->tlv.p, len)) 1468 err = -EFAULT; 1469 } 1470 __kctl_end: 1471 up_read(&card->controls_rwsem); 1472 return err; 1473 } 1474 1475 static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 1476 { 1477 struct snd_ctl_file *ctl; 1478 struct snd_card *card; 1479 struct snd_kctl_ioctl *p; 1480 void __user *argp = (void __user *)arg; 1481 int __user *ip = argp; 1482 int err; 1483 1484 ctl = file->private_data; 1485 card = ctl->card; 1486 if (snd_BUG_ON(!card)) 1487 return -ENXIO; 1488 switch (cmd) { 1489 case SNDRV_CTL_IOCTL_PVERSION: 1490 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0; 1491 case SNDRV_CTL_IOCTL_CARD_INFO: 1492 return snd_ctl_card_info(card, ctl, cmd, argp); 1493 case SNDRV_CTL_IOCTL_ELEM_LIST: 1494 return snd_ctl_elem_list(card, argp); 1495 case SNDRV_CTL_IOCTL_ELEM_INFO: 1496 return snd_ctl_elem_info_user(ctl, argp); 1497 case SNDRV_CTL_IOCTL_ELEM_READ: 1498 return snd_ctl_elem_read_user(card, argp); 1499 case SNDRV_CTL_IOCTL_ELEM_WRITE: 1500 return snd_ctl_elem_write_user(ctl, argp); 1501 case SNDRV_CTL_IOCTL_ELEM_LOCK: 1502 return snd_ctl_elem_lock(ctl, argp); 1503 case SNDRV_CTL_IOCTL_ELEM_UNLOCK: 1504 return snd_ctl_elem_unlock(ctl, argp); 1505 case SNDRV_CTL_IOCTL_ELEM_ADD: 1506 return snd_ctl_elem_add_user(ctl, argp, 0); 1507 case SNDRV_CTL_IOCTL_ELEM_REPLACE: 1508 return snd_ctl_elem_add_user(ctl, argp, 1); 1509 case SNDRV_CTL_IOCTL_ELEM_REMOVE: 1510 return snd_ctl_elem_remove(ctl, argp); 1511 case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: 1512 return snd_ctl_subscribe_events(ctl, ip); 1513 case SNDRV_CTL_IOCTL_TLV_READ: 1514 return snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ); 1515 case SNDRV_CTL_IOCTL_TLV_WRITE: 1516 return snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE); 1517 case SNDRV_CTL_IOCTL_TLV_COMMAND: 1518 return snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD); 1519 case SNDRV_CTL_IOCTL_POWER: 1520 return -ENOPROTOOPT; 1521 case SNDRV_CTL_IOCTL_POWER_STATE: 1522 #ifdef CONFIG_PM 1523 return put_user(card->power_state, ip) ? -EFAULT : 0; 1524 #else 1525 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0; 1526 #endif 1527 } 1528 down_read(&snd_ioctl_rwsem); 1529 list_for_each_entry(p, &snd_control_ioctls, list) { 1530 err = p->fioctl(card, ctl, cmd, arg); 1531 if (err != -ENOIOCTLCMD) { 1532 up_read(&snd_ioctl_rwsem); 1533 return err; 1534 } 1535 } 1536 up_read(&snd_ioctl_rwsem); 1537 dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd); 1538 return -ENOTTY; 1539 } 1540 1541 static ssize_t snd_ctl_read(struct file *file, char __user *buffer, 1542 size_t count, loff_t * offset) 1543 { 1544 struct snd_ctl_file *ctl; 1545 int err = 0; 1546 ssize_t result = 0; 1547 1548 ctl = file->private_data; 1549 if (snd_BUG_ON(!ctl || !ctl->card)) 1550 return -ENXIO; 1551 if (!ctl->subscribed) 1552 return -EBADFD; 1553 if (count < sizeof(struct snd_ctl_event)) 1554 return -EINVAL; 1555 spin_lock_irq(&ctl->read_lock); 1556 while (count >= sizeof(struct snd_ctl_event)) { 1557 struct snd_ctl_event ev; 1558 struct snd_kctl_event *kev; 1559 while (list_empty(&ctl->events)) { 1560 wait_queue_entry_t wait; 1561 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 1562 err = -EAGAIN; 1563 goto __end_lock; 1564 } 1565 init_waitqueue_entry(&wait, current); 1566 add_wait_queue(&ctl->change_sleep, &wait); 1567 set_current_state(TASK_INTERRUPTIBLE); 1568 spin_unlock_irq(&ctl->read_lock); 1569 schedule(); 1570 remove_wait_queue(&ctl->change_sleep, &wait); 1571 if (ctl->card->shutdown) 1572 return -ENODEV; 1573 if (signal_pending(current)) 1574 return -ERESTARTSYS; 1575 spin_lock_irq(&ctl->read_lock); 1576 } 1577 kev = snd_kctl_event(ctl->events.next); 1578 ev.type = SNDRV_CTL_EVENT_ELEM; 1579 ev.data.elem.mask = kev->mask; 1580 ev.data.elem.id = kev->id; 1581 list_del(&kev->list); 1582 spin_unlock_irq(&ctl->read_lock); 1583 kfree(kev); 1584 if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) { 1585 err = -EFAULT; 1586 goto __end; 1587 } 1588 spin_lock_irq(&ctl->read_lock); 1589 buffer += sizeof(struct snd_ctl_event); 1590 count -= sizeof(struct snd_ctl_event); 1591 result += sizeof(struct snd_ctl_event); 1592 } 1593 __end_lock: 1594 spin_unlock_irq(&ctl->read_lock); 1595 __end: 1596 return result > 0 ? result : err; 1597 } 1598 1599 static unsigned int snd_ctl_poll(struct file *file, poll_table * wait) 1600 { 1601 unsigned int mask; 1602 struct snd_ctl_file *ctl; 1603 1604 ctl = file->private_data; 1605 if (!ctl->subscribed) 1606 return 0; 1607 poll_wait(file, &ctl->change_sleep, wait); 1608 1609 mask = 0; 1610 if (!list_empty(&ctl->events)) 1611 mask |= POLLIN | POLLRDNORM; 1612 1613 return mask; 1614 } 1615 1616 /* 1617 * register the device-specific control-ioctls. 1618 * called from each device manager like pcm.c, hwdep.c, etc. 1619 */ 1620 static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists) 1621 { 1622 struct snd_kctl_ioctl *pn; 1623 1624 pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL); 1625 if (pn == NULL) 1626 return -ENOMEM; 1627 pn->fioctl = fcn; 1628 down_write(&snd_ioctl_rwsem); 1629 list_add_tail(&pn->list, lists); 1630 up_write(&snd_ioctl_rwsem); 1631 return 0; 1632 } 1633 1634 /** 1635 * snd_ctl_register_ioctl - register the device-specific control-ioctls 1636 * @fcn: ioctl callback function 1637 * 1638 * called from each device manager like pcm.c, hwdep.c, etc. 1639 */ 1640 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn) 1641 { 1642 return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls); 1643 } 1644 EXPORT_SYMBOL(snd_ctl_register_ioctl); 1645 1646 #ifdef CONFIG_COMPAT 1647 /** 1648 * snd_ctl_register_ioctl_compat - register the device-specific 32bit compat 1649 * control-ioctls 1650 * @fcn: ioctl callback function 1651 */ 1652 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn) 1653 { 1654 return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls); 1655 } 1656 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat); 1657 #endif 1658 1659 /* 1660 * de-register the device-specific control-ioctls. 1661 */ 1662 static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, 1663 struct list_head *lists) 1664 { 1665 struct snd_kctl_ioctl *p; 1666 1667 if (snd_BUG_ON(!fcn)) 1668 return -EINVAL; 1669 down_write(&snd_ioctl_rwsem); 1670 list_for_each_entry(p, lists, list) { 1671 if (p->fioctl == fcn) { 1672 list_del(&p->list); 1673 up_write(&snd_ioctl_rwsem); 1674 kfree(p); 1675 return 0; 1676 } 1677 } 1678 up_write(&snd_ioctl_rwsem); 1679 snd_BUG(); 1680 return -EINVAL; 1681 } 1682 1683 /** 1684 * snd_ctl_unregister_ioctl - de-register the device-specific control-ioctls 1685 * @fcn: ioctl callback function to unregister 1686 */ 1687 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn) 1688 { 1689 return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls); 1690 } 1691 EXPORT_SYMBOL(snd_ctl_unregister_ioctl); 1692 1693 #ifdef CONFIG_COMPAT 1694 /** 1695 * snd_ctl_unregister_ioctl - de-register the device-specific compat 32bit 1696 * control-ioctls 1697 * @fcn: ioctl callback function to unregister 1698 */ 1699 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn) 1700 { 1701 return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls); 1702 } 1703 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat); 1704 #endif 1705 1706 static int snd_ctl_fasync(int fd, struct file * file, int on) 1707 { 1708 struct snd_ctl_file *ctl; 1709 1710 ctl = file->private_data; 1711 return fasync_helper(fd, file, on, &ctl->fasync); 1712 } 1713 1714 /* return the preferred subdevice number if already assigned; 1715 * otherwise return -1 1716 */ 1717 int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type) 1718 { 1719 struct snd_ctl_file *kctl; 1720 int subdevice = -1; 1721 1722 read_lock(&card->ctl_files_rwlock); 1723 list_for_each_entry(kctl, &card->ctl_files, list) { 1724 if (kctl->pid == task_pid(current)) { 1725 subdevice = kctl->preferred_subdevice[type]; 1726 if (subdevice != -1) 1727 break; 1728 } 1729 } 1730 read_unlock(&card->ctl_files_rwlock); 1731 return subdevice; 1732 } 1733 EXPORT_SYMBOL_GPL(snd_ctl_get_preferred_subdevice); 1734 1735 /* 1736 * ioctl32 compat 1737 */ 1738 #ifdef CONFIG_COMPAT 1739 #include "control_compat.c" 1740 #else 1741 #define snd_ctl_ioctl_compat NULL 1742 #endif 1743 1744 /* 1745 * INIT PART 1746 */ 1747 1748 static const struct file_operations snd_ctl_f_ops = 1749 { 1750 .owner = THIS_MODULE, 1751 .read = snd_ctl_read, 1752 .open = snd_ctl_open, 1753 .release = snd_ctl_release, 1754 .llseek = no_llseek, 1755 .poll = snd_ctl_poll, 1756 .unlocked_ioctl = snd_ctl_ioctl, 1757 .compat_ioctl = snd_ctl_ioctl_compat, 1758 .fasync = snd_ctl_fasync, 1759 }; 1760 1761 /* 1762 * registration of the control device 1763 */ 1764 static int snd_ctl_dev_register(struct snd_device *device) 1765 { 1766 struct snd_card *card = device->device_data; 1767 1768 return snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, 1769 &snd_ctl_f_ops, card, &card->ctl_dev); 1770 } 1771 1772 /* 1773 * disconnection of the control device 1774 */ 1775 static int snd_ctl_dev_disconnect(struct snd_device *device) 1776 { 1777 struct snd_card *card = device->device_data; 1778 struct snd_ctl_file *ctl; 1779 1780 read_lock(&card->ctl_files_rwlock); 1781 list_for_each_entry(ctl, &card->ctl_files, list) { 1782 wake_up(&ctl->change_sleep); 1783 kill_fasync(&ctl->fasync, SIGIO, POLL_ERR); 1784 } 1785 read_unlock(&card->ctl_files_rwlock); 1786 1787 return snd_unregister_device(&card->ctl_dev); 1788 } 1789 1790 /* 1791 * free all controls 1792 */ 1793 static int snd_ctl_dev_free(struct snd_device *device) 1794 { 1795 struct snd_card *card = device->device_data; 1796 struct snd_kcontrol *control; 1797 1798 down_write(&card->controls_rwsem); 1799 while (!list_empty(&card->controls)) { 1800 control = snd_kcontrol(card->controls.next); 1801 snd_ctl_remove(card, control); 1802 } 1803 up_write(&card->controls_rwsem); 1804 put_device(&card->ctl_dev); 1805 return 0; 1806 } 1807 1808 /* 1809 * create control core: 1810 * called from init.c 1811 */ 1812 int snd_ctl_create(struct snd_card *card) 1813 { 1814 static struct snd_device_ops ops = { 1815 .dev_free = snd_ctl_dev_free, 1816 .dev_register = snd_ctl_dev_register, 1817 .dev_disconnect = snd_ctl_dev_disconnect, 1818 }; 1819 int err; 1820 1821 if (snd_BUG_ON(!card)) 1822 return -ENXIO; 1823 if (snd_BUG_ON(card->number < 0 || card->number >= SNDRV_CARDS)) 1824 return -ENXIO; 1825 1826 snd_device_initialize(&card->ctl_dev, card); 1827 dev_set_name(&card->ctl_dev, "controlC%d", card->number); 1828 1829 err = snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops); 1830 if (err < 0) 1831 put_device(&card->ctl_dev); 1832 return err; 1833 } 1834 1835 /* 1836 * Frequently used control callbacks/helpers 1837 */ 1838 1839 /** 1840 * snd_ctl_boolean_mono_info - Helper function for a standard boolean info 1841 * callback with a mono channel 1842 * @kcontrol: the kcontrol instance 1843 * @uinfo: info to store 1844 * 1845 * This is a function that can be used as info callback for a standard 1846 * boolean control with a single mono channel. 1847 */ 1848 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol, 1849 struct snd_ctl_elem_info *uinfo) 1850 { 1851 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1852 uinfo->count = 1; 1853 uinfo->value.integer.min = 0; 1854 uinfo->value.integer.max = 1; 1855 return 0; 1856 } 1857 EXPORT_SYMBOL(snd_ctl_boolean_mono_info); 1858 1859 /** 1860 * snd_ctl_boolean_stereo_info - Helper function for a standard boolean info 1861 * callback with stereo two channels 1862 * @kcontrol: the kcontrol instance 1863 * @uinfo: info to store 1864 * 1865 * This is a function that can be used as info callback for a standard 1866 * boolean control with stereo two channels. 1867 */ 1868 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol, 1869 struct snd_ctl_elem_info *uinfo) 1870 { 1871 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1872 uinfo->count = 2; 1873 uinfo->value.integer.min = 0; 1874 uinfo->value.integer.max = 1; 1875 return 0; 1876 } 1877 EXPORT_SYMBOL(snd_ctl_boolean_stereo_info); 1878 1879 /** 1880 * snd_ctl_enum_info - fills the info structure for an enumerated control 1881 * @info: the structure to be filled 1882 * @channels: the number of the control's channels; often one 1883 * @items: the number of control values; also the size of @names 1884 * @names: an array containing the names of all control values 1885 * 1886 * Sets all required fields in @info to their appropriate values. 1887 * If the control's accessibility is not the default (readable and writable), 1888 * the caller has to fill @info->access. 1889 * 1890 * Return: Zero. 1891 */ 1892 int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels, 1893 unsigned int items, const char *const names[]) 1894 { 1895 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1896 info->count = channels; 1897 info->value.enumerated.items = items; 1898 if (!items) 1899 return 0; 1900 if (info->value.enumerated.item >= items) 1901 info->value.enumerated.item = items - 1; 1902 WARN(strlen(names[info->value.enumerated.item]) >= sizeof(info->value.enumerated.name), 1903 "ALSA: too long item name '%s'\n", 1904 names[info->value.enumerated.item]); 1905 strlcpy(info->value.enumerated.name, 1906 names[info->value.enumerated.item], 1907 sizeof(info->value.enumerated.name)); 1908 return 0; 1909 } 1910 EXPORT_SYMBOL(snd_ctl_enum_info); 1911