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