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