1 /* 2 * Initialization routines 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/init.h> 23 #include <linux/sched.h> 24 #include <linux/file.h> 25 #include <linux/slab.h> 26 #include <linux/time.h> 27 #include <linux/ctype.h> 28 #include <linux/pm.h> 29 30 #include <sound/core.h> 31 #include <sound/control.h> 32 #include <sound/info.h> 33 34 static DEFINE_SPINLOCK(shutdown_lock); 35 static LIST_HEAD(shutdown_files); 36 37 static const struct file_operations snd_shutdown_f_ops; 38 39 static unsigned int snd_cards_lock; /* locked for registering/using */ 40 struct snd_card *snd_cards[SNDRV_CARDS]; 41 EXPORT_SYMBOL(snd_cards); 42 43 static DEFINE_MUTEX(snd_card_mutex); 44 45 static char *slots[SNDRV_CARDS]; 46 module_param_array(slots, charp, NULL, 0444); 47 MODULE_PARM_DESC(slots, "Module names assigned to the slots."); 48 49 /* return non-zero if the given index is reserved for the given 50 * module via slots option 51 */ 52 static int module_slot_match(struct module *module, int idx) 53 { 54 int match = 1; 55 #ifdef MODULE 56 const char *s1, *s2; 57 58 if (!module || !module->name || !slots[idx]) 59 return 0; 60 61 s1 = module->name; 62 s2 = slots[idx]; 63 if (*s2 == '!') { 64 match = 0; /* negative match */ 65 s2++; 66 } 67 /* compare module name strings 68 * hyphens are handled as equivalent with underscore 69 */ 70 for (;;) { 71 char c1 = *s1++; 72 char c2 = *s2++; 73 if (c1 == '-') 74 c1 = '_'; 75 if (c2 == '-') 76 c2 = '_'; 77 if (c1 != c2) 78 return !match; 79 if (!c1) 80 break; 81 } 82 #endif /* MODULE */ 83 return match; 84 } 85 86 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) 87 int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag); 88 EXPORT_SYMBOL(snd_mixer_oss_notify_callback); 89 #endif 90 91 #ifdef CONFIG_PROC_FS 92 static void snd_card_id_read(struct snd_info_entry *entry, 93 struct snd_info_buffer *buffer) 94 { 95 snd_iprintf(buffer, "%s\n", entry->card->id); 96 } 97 98 static inline int init_info_for_card(struct snd_card *card) 99 { 100 int err; 101 struct snd_info_entry *entry; 102 103 if ((err = snd_info_card_register(card)) < 0) { 104 snd_printd("unable to create card info\n"); 105 return err; 106 } 107 if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) { 108 snd_printd("unable to create card entry\n"); 109 return err; 110 } 111 entry->c.text.read = snd_card_id_read; 112 if (snd_info_register(entry) < 0) { 113 snd_info_free_entry(entry); 114 entry = NULL; 115 } 116 card->proc_id = entry; 117 return 0; 118 } 119 #else /* !CONFIG_PROC_FS */ 120 #define init_info_for_card(card) 121 #endif 122 123 /** 124 * snd_card_new - create and initialize a soundcard structure 125 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)] 126 * @xid: card identification (ASCII string) 127 * @module: top level module for locking 128 * @extra_size: allocate this extra size after the main soundcard structure 129 * 130 * Creates and initializes a soundcard structure. 131 * 132 * Returns kmallocated snd_card structure. Creates the ALSA control interface 133 * (which is blocked until snd_card_register function is called). 134 */ 135 struct snd_card *snd_card_new(int idx, const char *xid, 136 struct module *module, int extra_size) 137 { 138 struct snd_card *card; 139 int err, idx2; 140 141 if (extra_size < 0) 142 extra_size = 0; 143 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL); 144 if (card == NULL) 145 return NULL; 146 if (xid) { 147 if (!snd_info_check_reserved_words(xid)) 148 goto __error; 149 strlcpy(card->id, xid, sizeof(card->id)); 150 } 151 err = 0; 152 mutex_lock(&snd_card_mutex); 153 if (idx < 0) { 154 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++) 155 /* idx == -1 == 0xffff means: take any free slot */ 156 if (~snd_cards_lock & idx & 1<<idx2) { 157 if (module_slot_match(module, idx2)) { 158 idx = idx2; 159 break; 160 } 161 } 162 } 163 if (idx < 0) { 164 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++) 165 /* idx == -1 == 0xffff means: take any free slot */ 166 if (~snd_cards_lock & idx & 1<<idx2) { 167 if (!slots[idx2] || !*slots[idx2]) { 168 idx = idx2; 169 break; 170 } 171 } 172 } 173 if (idx < 0) 174 err = -ENODEV; 175 else if (idx < snd_ecards_limit) { 176 if (snd_cards_lock & (1 << idx)) 177 err = -EBUSY; /* invalid */ 178 } else if (idx >= SNDRV_CARDS) 179 err = -ENODEV; 180 if (err < 0) { 181 mutex_unlock(&snd_card_mutex); 182 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n", 183 idx, snd_ecards_limit - 1, err); 184 goto __error; 185 } 186 snd_cards_lock |= 1 << idx; /* lock it */ 187 if (idx >= snd_ecards_limit) 188 snd_ecards_limit = idx + 1; /* increase the limit */ 189 mutex_unlock(&snd_card_mutex); 190 card->number = idx; 191 card->module = module; 192 INIT_LIST_HEAD(&card->devices); 193 init_rwsem(&card->controls_rwsem); 194 rwlock_init(&card->ctl_files_rwlock); 195 INIT_LIST_HEAD(&card->controls); 196 INIT_LIST_HEAD(&card->ctl_files); 197 spin_lock_init(&card->files_lock); 198 init_waitqueue_head(&card->shutdown_sleep); 199 #ifdef CONFIG_PM 200 mutex_init(&card->power_lock); 201 init_waitqueue_head(&card->power_sleep); 202 #endif 203 /* the control interface cannot be accessed from the user space until */ 204 /* snd_cards_bitmask and snd_cards are set with snd_card_register */ 205 if ((err = snd_ctl_create(card)) < 0) { 206 snd_printd("unable to register control minors\n"); 207 goto __error; 208 } 209 if ((err = snd_info_card_create(card)) < 0) { 210 snd_printd("unable to create card info\n"); 211 goto __error_ctl; 212 } 213 if (extra_size > 0) 214 card->private_data = (char *)card + sizeof(struct snd_card); 215 return card; 216 217 __error_ctl: 218 snd_device_free_all(card, SNDRV_DEV_CMD_PRE); 219 __error: 220 kfree(card); 221 return NULL; 222 } 223 224 EXPORT_SYMBOL(snd_card_new); 225 226 /* return non-zero if a card is already locked */ 227 int snd_card_locked(int card) 228 { 229 int locked; 230 231 mutex_lock(&snd_card_mutex); 232 locked = snd_cards_lock & (1 << card); 233 mutex_unlock(&snd_card_mutex); 234 return locked; 235 } 236 237 static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig) 238 { 239 return -ENODEV; 240 } 241 242 static ssize_t snd_disconnect_read(struct file *file, char __user *buf, 243 size_t count, loff_t *offset) 244 { 245 return -ENODEV; 246 } 247 248 static ssize_t snd_disconnect_write(struct file *file, const char __user *buf, 249 size_t count, loff_t *offset) 250 { 251 return -ENODEV; 252 } 253 254 static int snd_disconnect_release(struct inode *inode, struct file *file) 255 { 256 struct snd_monitor_file *df = NULL, *_df; 257 258 spin_lock(&shutdown_lock); 259 list_for_each_entry(_df, &shutdown_files, shutdown_list) { 260 if (_df->file == file) { 261 df = _df; 262 break; 263 } 264 } 265 spin_unlock(&shutdown_lock); 266 267 if (likely(df)) { 268 if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync) 269 df->disconnected_f_op->fasync(-1, file, 0); 270 return df->disconnected_f_op->release(inode, file); 271 } 272 273 panic("%s(%p, %p) failed!", __func__, inode, file); 274 } 275 276 static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait) 277 { 278 return POLLERR | POLLNVAL; 279 } 280 281 static long snd_disconnect_ioctl(struct file *file, 282 unsigned int cmd, unsigned long arg) 283 { 284 return -ENODEV; 285 } 286 287 static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma) 288 { 289 return -ENODEV; 290 } 291 292 static int snd_disconnect_fasync(int fd, struct file *file, int on) 293 { 294 return -ENODEV; 295 } 296 297 static const struct file_operations snd_shutdown_f_ops = 298 { 299 .owner = THIS_MODULE, 300 .llseek = snd_disconnect_llseek, 301 .read = snd_disconnect_read, 302 .write = snd_disconnect_write, 303 .release = snd_disconnect_release, 304 .poll = snd_disconnect_poll, 305 .unlocked_ioctl = snd_disconnect_ioctl, 306 #ifdef CONFIG_COMPAT 307 .compat_ioctl = snd_disconnect_ioctl, 308 #endif 309 .mmap = snd_disconnect_mmap, 310 .fasync = snd_disconnect_fasync 311 }; 312 313 /** 314 * snd_card_disconnect - disconnect all APIs from the file-operations (user space) 315 * @card: soundcard structure 316 * 317 * Disconnects all APIs from the file-operations (user space). 318 * 319 * Returns zero, otherwise a negative error code. 320 * 321 * Note: The current implementation replaces all active file->f_op with special 322 * dummy file operations (they do nothing except release). 323 */ 324 int snd_card_disconnect(struct snd_card *card) 325 { 326 struct snd_monitor_file *mfile; 327 struct file *file; 328 int err; 329 330 if (!card) 331 return -EINVAL; 332 333 spin_lock(&card->files_lock); 334 if (card->shutdown) { 335 spin_unlock(&card->files_lock); 336 return 0; 337 } 338 card->shutdown = 1; 339 spin_unlock(&card->files_lock); 340 341 /* phase 1: disable fops (user space) operations for ALSA API */ 342 mutex_lock(&snd_card_mutex); 343 snd_cards[card->number] = NULL; 344 snd_cards_lock &= ~(1 << card->number); 345 mutex_unlock(&snd_card_mutex); 346 347 /* phase 2: replace file->f_op with special dummy operations */ 348 349 spin_lock(&card->files_lock); 350 mfile = card->files; 351 while (mfile) { 352 file = mfile->file; 353 354 /* it's critical part, use endless loop */ 355 /* we have no room to fail */ 356 mfile->disconnected_f_op = mfile->file->f_op; 357 358 spin_lock(&shutdown_lock); 359 list_add(&mfile->shutdown_list, &shutdown_files); 360 spin_unlock(&shutdown_lock); 361 362 mfile->file->f_op = &snd_shutdown_f_ops; 363 fops_get(mfile->file->f_op); 364 365 mfile = mfile->next; 366 } 367 spin_unlock(&card->files_lock); 368 369 /* phase 3: notify all connected devices about disconnection */ 370 /* at this point, they cannot respond to any calls except release() */ 371 372 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) 373 if (snd_mixer_oss_notify_callback) 374 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT); 375 #endif 376 377 /* notify all devices that we are disconnected */ 378 err = snd_device_disconnect_all(card); 379 if (err < 0) 380 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number); 381 382 snd_info_card_disconnect(card); 383 #ifndef CONFIG_SYSFS_DEPRECATED 384 if (card->card_dev) { 385 device_unregister(card->card_dev); 386 card->card_dev = NULL; 387 } 388 #endif 389 #ifdef CONFIG_PM 390 wake_up(&card->power_sleep); 391 #endif 392 return 0; 393 } 394 395 EXPORT_SYMBOL(snd_card_disconnect); 396 397 /** 398 * snd_card_free - frees given soundcard structure 399 * @card: soundcard structure 400 * 401 * This function releases the soundcard structure and the all assigned 402 * devices automatically. That is, you don't have to release the devices 403 * by yourself. 404 * 405 * Returns zero. Frees all associated devices and frees the control 406 * interface associated to given soundcard. 407 */ 408 static int snd_card_do_free(struct snd_card *card) 409 { 410 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) 411 if (snd_mixer_oss_notify_callback) 412 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE); 413 #endif 414 if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) { 415 snd_printk(KERN_ERR "unable to free all devices (pre)\n"); 416 /* Fatal, but this situation should never occur */ 417 } 418 if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) { 419 snd_printk(KERN_ERR "unable to free all devices (normal)\n"); 420 /* Fatal, but this situation should never occur */ 421 } 422 if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) { 423 snd_printk(KERN_ERR "unable to free all devices (post)\n"); 424 /* Fatal, but this situation should never occur */ 425 } 426 if (card->private_free) 427 card->private_free(card); 428 snd_info_free_entry(card->proc_id); 429 if (snd_info_card_free(card) < 0) { 430 snd_printk(KERN_WARNING "unable to free card info\n"); 431 /* Not fatal error */ 432 } 433 kfree(card); 434 return 0; 435 } 436 437 int snd_card_free_when_closed(struct snd_card *card) 438 { 439 int free_now = 0; 440 int ret = snd_card_disconnect(card); 441 if (ret) 442 return ret; 443 444 spin_lock(&card->files_lock); 445 if (card->files == NULL) 446 free_now = 1; 447 else 448 card->free_on_last_close = 1; 449 spin_unlock(&card->files_lock); 450 451 if (free_now) 452 snd_card_do_free(card); 453 return 0; 454 } 455 456 EXPORT_SYMBOL(snd_card_free_when_closed); 457 458 int snd_card_free(struct snd_card *card) 459 { 460 int ret = snd_card_disconnect(card); 461 if (ret) 462 return ret; 463 464 /* wait, until all devices are ready for the free operation */ 465 wait_event(card->shutdown_sleep, card->files == NULL); 466 snd_card_do_free(card); 467 return 0; 468 } 469 470 EXPORT_SYMBOL(snd_card_free); 471 472 static void choose_default_id(struct snd_card *card) 473 { 474 int i, len, idx_flag = 0, loops = SNDRV_CARDS; 475 char *id, *spos; 476 477 id = spos = card->shortname; 478 while (*id != '\0') { 479 if (*id == ' ') 480 spos = id + 1; 481 id++; 482 } 483 id = card->id; 484 while (*spos != '\0' && !isalnum(*spos)) 485 spos++; 486 if (isdigit(*spos)) 487 *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D'; 488 while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) { 489 if (isalnum(*spos)) 490 *id++ = *spos; 491 spos++; 492 } 493 *id = '\0'; 494 495 id = card->id; 496 497 if (*id == '\0') 498 strcpy(id, "default"); 499 500 while (1) { 501 if (loops-- == 0) { 502 snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id); 503 strcpy(card->id, card->proc_root->name); 504 return; 505 } 506 if (!snd_info_check_reserved_words(id)) 507 goto __change; 508 for (i = 0; i < snd_ecards_limit; i++) { 509 if (snd_cards[i] && !strcmp(snd_cards[i]->id, id)) 510 goto __change; 511 } 512 break; 513 514 __change: 515 len = strlen(id); 516 if (idx_flag) { 517 if (id[len-1] != '9') 518 id[len-1]++; 519 else 520 id[len-1] = 'A'; 521 } else if ((size_t)len <= sizeof(card->id) - 3) { 522 strcat(id, "_1"); 523 idx_flag++; 524 } else { 525 spos = id + len - 2; 526 if ((size_t)len <= sizeof(card->id) - 2) 527 spos++; 528 *spos++ = '_'; 529 *spos++ = '1'; 530 *spos++ = '\0'; 531 idx_flag++; 532 } 533 } 534 } 535 536 /** 537 * snd_card_register - register the soundcard 538 * @card: soundcard structure 539 * 540 * This function registers all the devices assigned to the soundcard. 541 * Until calling this, the ALSA control interface is blocked from the 542 * external accesses. Thus, you should call this function at the end 543 * of the initialization of the card. 544 * 545 * Returns zero otherwise a negative error code if the registrain failed. 546 */ 547 int snd_card_register(struct snd_card *card) 548 { 549 int err; 550 551 if (snd_BUG_ON(!card)) 552 return -EINVAL; 553 #ifndef CONFIG_SYSFS_DEPRECATED 554 if (!card->card_dev) { 555 card->card_dev = device_create(sound_class, card->dev, 556 MKDEV(0, 0), NULL, 557 "card%i", card->number); 558 if (IS_ERR(card->card_dev)) 559 card->card_dev = NULL; 560 } 561 #endif 562 if ((err = snd_device_register_all(card)) < 0) 563 return err; 564 mutex_lock(&snd_card_mutex); 565 if (snd_cards[card->number]) { 566 /* already registered */ 567 mutex_unlock(&snd_card_mutex); 568 return 0; 569 } 570 if (card->id[0] == '\0') 571 choose_default_id(card); 572 snd_cards[card->number] = card; 573 mutex_unlock(&snd_card_mutex); 574 init_info_for_card(card); 575 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) 576 if (snd_mixer_oss_notify_callback) 577 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER); 578 #endif 579 return 0; 580 } 581 582 EXPORT_SYMBOL(snd_card_register); 583 584 #ifdef CONFIG_PROC_FS 585 static struct snd_info_entry *snd_card_info_entry; 586 587 static void snd_card_info_read(struct snd_info_entry *entry, 588 struct snd_info_buffer *buffer) 589 { 590 int idx, count; 591 struct snd_card *card; 592 593 for (idx = count = 0; idx < SNDRV_CARDS; idx++) { 594 mutex_lock(&snd_card_mutex); 595 if ((card = snd_cards[idx]) != NULL) { 596 count++; 597 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n", 598 idx, 599 card->id, 600 card->driver, 601 card->shortname); 602 snd_iprintf(buffer, " %s\n", 603 card->longname); 604 } 605 mutex_unlock(&snd_card_mutex); 606 } 607 if (!count) 608 snd_iprintf(buffer, "--- no soundcards ---\n"); 609 } 610 611 #ifdef CONFIG_SND_OSSEMUL 612 613 void snd_card_info_read_oss(struct snd_info_buffer *buffer) 614 { 615 int idx, count; 616 struct snd_card *card; 617 618 for (idx = count = 0; idx < SNDRV_CARDS; idx++) { 619 mutex_lock(&snd_card_mutex); 620 if ((card = snd_cards[idx]) != NULL) { 621 count++; 622 snd_iprintf(buffer, "%s\n", card->longname); 623 } 624 mutex_unlock(&snd_card_mutex); 625 } 626 if (!count) { 627 snd_iprintf(buffer, "--- no soundcards ---\n"); 628 } 629 } 630 631 #endif 632 633 #ifdef MODULE 634 static struct snd_info_entry *snd_card_module_info_entry; 635 static void snd_card_module_info_read(struct snd_info_entry *entry, 636 struct snd_info_buffer *buffer) 637 { 638 int idx; 639 struct snd_card *card; 640 641 for (idx = 0; idx < SNDRV_CARDS; idx++) { 642 mutex_lock(&snd_card_mutex); 643 if ((card = snd_cards[idx]) != NULL) 644 snd_iprintf(buffer, "%2i %s\n", 645 idx, card->module->name); 646 mutex_unlock(&snd_card_mutex); 647 } 648 } 649 #endif 650 651 int __init snd_card_info_init(void) 652 { 653 struct snd_info_entry *entry; 654 655 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL); 656 if (! entry) 657 return -ENOMEM; 658 entry->c.text.read = snd_card_info_read; 659 if (snd_info_register(entry) < 0) { 660 snd_info_free_entry(entry); 661 return -ENOMEM; 662 } 663 snd_card_info_entry = entry; 664 665 #ifdef MODULE 666 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL); 667 if (entry) { 668 entry->c.text.read = snd_card_module_info_read; 669 if (snd_info_register(entry) < 0) 670 snd_info_free_entry(entry); 671 else 672 snd_card_module_info_entry = entry; 673 } 674 #endif 675 676 return 0; 677 } 678 679 int __exit snd_card_info_done(void) 680 { 681 snd_info_free_entry(snd_card_info_entry); 682 #ifdef MODULE 683 snd_info_free_entry(snd_card_module_info_entry); 684 #endif 685 return 0; 686 } 687 688 #endif /* CONFIG_PROC_FS */ 689 690 /** 691 * snd_component_add - add a component string 692 * @card: soundcard structure 693 * @component: the component id string 694 * 695 * This function adds the component id string to the supported list. 696 * The component can be referred from the alsa-lib. 697 * 698 * Returns zero otherwise a negative error code. 699 */ 700 701 int snd_component_add(struct snd_card *card, const char *component) 702 { 703 char *ptr; 704 int len = strlen(component); 705 706 ptr = strstr(card->components, component); 707 if (ptr != NULL) { 708 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */ 709 return 1; 710 } 711 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) { 712 snd_BUG(); 713 return -ENOMEM; 714 } 715 if (card->components[0] != '\0') 716 strcat(card->components, " "); 717 strcat(card->components, component); 718 return 0; 719 } 720 721 EXPORT_SYMBOL(snd_component_add); 722 723 /** 724 * snd_card_file_add - add the file to the file list of the card 725 * @card: soundcard structure 726 * @file: file pointer 727 * 728 * This function adds the file to the file linked-list of the card. 729 * This linked-list is used to keep tracking the connection state, 730 * and to avoid the release of busy resources by hotplug. 731 * 732 * Returns zero or a negative error code. 733 */ 734 int snd_card_file_add(struct snd_card *card, struct file *file) 735 { 736 struct snd_monitor_file *mfile; 737 738 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL); 739 if (mfile == NULL) 740 return -ENOMEM; 741 mfile->file = file; 742 mfile->disconnected_f_op = NULL; 743 mfile->next = NULL; 744 spin_lock(&card->files_lock); 745 if (card->shutdown) { 746 spin_unlock(&card->files_lock); 747 kfree(mfile); 748 return -ENODEV; 749 } 750 mfile->next = card->files; 751 card->files = mfile; 752 spin_unlock(&card->files_lock); 753 return 0; 754 } 755 756 EXPORT_SYMBOL(snd_card_file_add); 757 758 /** 759 * snd_card_file_remove - remove the file from the file list 760 * @card: soundcard structure 761 * @file: file pointer 762 * 763 * This function removes the file formerly added to the card via 764 * snd_card_file_add() function. 765 * If all files are removed and snd_card_free_when_closed() was 766 * called beforehand, it processes the pending release of 767 * resources. 768 * 769 * Returns zero or a negative error code. 770 */ 771 int snd_card_file_remove(struct snd_card *card, struct file *file) 772 { 773 struct snd_monitor_file *mfile, *pfile = NULL; 774 int last_close = 0; 775 776 spin_lock(&card->files_lock); 777 mfile = card->files; 778 while (mfile) { 779 if (mfile->file == file) { 780 if (pfile) 781 pfile->next = mfile->next; 782 else 783 card->files = mfile->next; 784 break; 785 } 786 pfile = mfile; 787 mfile = mfile->next; 788 } 789 if (mfile && mfile->disconnected_f_op) { 790 fops_put(mfile->disconnected_f_op); 791 spin_lock(&shutdown_lock); 792 list_del(&mfile->shutdown_list); 793 spin_unlock(&shutdown_lock); 794 } 795 if (card->files == NULL) 796 last_close = 1; 797 spin_unlock(&card->files_lock); 798 if (last_close) { 799 wake_up(&card->shutdown_sleep); 800 if (card->free_on_last_close) 801 snd_card_do_free(card); 802 } 803 if (!mfile) { 804 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file); 805 return -ENOENT; 806 } 807 kfree(mfile); 808 return 0; 809 } 810 811 EXPORT_SYMBOL(snd_card_file_remove); 812 813 #ifdef CONFIG_PM 814 /** 815 * snd_power_wait - wait until the power-state is changed. 816 * @card: soundcard structure 817 * @power_state: expected power state 818 * 819 * Waits until the power-state is changed. 820 * 821 * Note: the power lock must be active before call. 822 */ 823 int snd_power_wait(struct snd_card *card, unsigned int power_state) 824 { 825 wait_queue_t wait; 826 int result = 0; 827 828 /* fastpath */ 829 if (snd_power_get_state(card) == power_state) 830 return 0; 831 init_waitqueue_entry(&wait, current); 832 add_wait_queue(&card->power_sleep, &wait); 833 while (1) { 834 if (card->shutdown) { 835 result = -ENODEV; 836 break; 837 } 838 if (snd_power_get_state(card) == power_state) 839 break; 840 set_current_state(TASK_UNINTERRUPTIBLE); 841 snd_power_unlock(card); 842 schedule_timeout(30 * HZ); 843 snd_power_lock(card); 844 } 845 remove_wait_queue(&card->power_sleep, &wait); 846 return result; 847 } 848 849 EXPORT_SYMBOL(snd_power_wait); 850 #endif /* CONFIG_PM */ 851