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