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