1
2
3
4
5
6
7#include <linux/init.h>
8#include <linux/sched.h>
9#include <linux/module.h>
10#include <linux/device.h>
11#include <linux/file.h>
12#include <linux/slab.h>
13#include <linux/time.h>
14#include <linux/ctype.h>
15#include <linux/pm.h>
16#include <linux/completion.h>
17
18#include <sound/core.h>
19#include <sound/control.h>
20#include <sound/info.h>
21
22
23struct snd_monitor_file {
24 struct file *file;
25 const struct file_operations *disconnected_f_op;
26 struct list_head shutdown_list;
27 struct list_head list;
28};
29
30static DEFINE_SPINLOCK(shutdown_lock);
31static LIST_HEAD(shutdown_files);
32
33static const struct file_operations snd_shutdown_f_ops;
34
35
36static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
37static struct snd_card *snd_cards[SNDRV_CARDS];
38
39static DEFINE_MUTEX(snd_card_mutex);
40
41static char *slots[SNDRV_CARDS];
42module_param_array(slots, charp, NULL, 0444);
43MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
44
45
46
47
48static int module_slot_match(struct module *module, int idx)
49{
50 int match = 1;
51#ifdef MODULE
52 const char *s1, *s2;
53
54 if (!module || !*module->name || !slots[idx])
55 return 0;
56
57 s1 = module->name;
58 s2 = slots[idx];
59 if (*s2 == '!') {
60 match = 0;
61 s2++;
62 }
63
64
65
66 for (;;) {
67 char c1 = *s1++;
68 char c2 = *s2++;
69 if (c1 == '-')
70 c1 = '_';
71 if (c2 == '-')
72 c2 = '_';
73 if (c1 != c2)
74 return !match;
75 if (!c1)
76 break;
77 }
78#endif
79 return match;
80}
81
82#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
83int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
84EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
85#endif
86
87static int check_empty_slot(struct module *module, int slot)
88{
89 return !slots[slot] || !*slots[slot];
90}
91
92
93
94
95
96static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
97 struct module *module)
98{
99 int slot;
100
101 for (slot = 0; slot < SNDRV_CARDS; slot++) {
102 if (slot < 32 && !(mask & (1U << slot)))
103 continue;
104 if (!test_bit(slot, snd_cards_lock)) {
105 if (check(module, slot))
106 return slot;
107 }
108 }
109 return mask;
110}
111
112
113
114
115
116static void default_release(struct device *dev)
117{
118}
119
120
121
122
123
124
125void snd_device_initialize(struct device *dev, struct snd_card *card)
126{
127 device_initialize(dev);
128 if (card)
129 dev->parent = &card->card_dev;
130 dev->class = sound_class;
131 dev->release = default_release;
132}
133EXPORT_SYMBOL_GPL(snd_device_initialize);
134
135static int snd_card_do_free(struct snd_card *card);
136static const struct attribute_group card_dev_attr_group;
137
138static void release_card_device(struct device *dev)
139{
140 snd_card_do_free(dev_to_snd_card(dev));
141}
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160int snd_card_new(struct device *parent, int idx, const char *xid,
161 struct module *module, int extra_size,
162 struct snd_card **card_ret)
163{
164 struct snd_card *card;
165 int err;
166
167 if (snd_BUG_ON(!card_ret))
168 return -EINVAL;
169 *card_ret = NULL;
170
171 if (extra_size < 0)
172 extra_size = 0;
173 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
174 if (!card)
175 return -ENOMEM;
176 if (extra_size > 0)
177 card->private_data = (char *)card + sizeof(struct snd_card);
178 if (xid)
179 strlcpy(card->id, xid, sizeof(card->id));
180 err = 0;
181 mutex_lock(&snd_card_mutex);
182 if (idx < 0)
183 idx = get_slot_from_bitmask(idx, module_slot_match, module);
184 if (idx < 0)
185 idx = get_slot_from_bitmask(idx, check_empty_slot, module);
186 if (idx < 0)
187 err = -ENODEV;
188 else if (idx < snd_ecards_limit) {
189 if (test_bit(idx, snd_cards_lock))
190 err = -EBUSY;
191 } else if (idx >= SNDRV_CARDS)
192 err = -ENODEV;
193 if (err < 0) {
194 mutex_unlock(&snd_card_mutex);
195 dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
196 idx, snd_ecards_limit - 1, err);
197 kfree(card);
198 return err;
199 }
200 set_bit(idx, snd_cards_lock);
201 if (idx >= snd_ecards_limit)
202 snd_ecards_limit = idx + 1;
203 mutex_unlock(&snd_card_mutex);
204 card->dev = parent;
205 card->number = idx;
206#ifdef MODULE
207 WARN_ON(!module);
208 card->module = module;
209#endif
210 INIT_LIST_HEAD(&card->devices);
211 init_rwsem(&card->controls_rwsem);
212 rwlock_init(&card->ctl_files_rwlock);
213 INIT_LIST_HEAD(&card->controls);
214 INIT_LIST_HEAD(&card->ctl_files);
215 spin_lock_init(&card->files_lock);
216 INIT_LIST_HEAD(&card->files_list);
217 mutex_init(&card->memory_mutex);
218#ifdef CONFIG_PM
219 init_waitqueue_head(&card->power_sleep);
220#endif
221 init_waitqueue_head(&card->remove_sleep);
222 card->sync_irq = -1;
223
224 device_initialize(&card->card_dev);
225 card->card_dev.parent = parent;
226 card->card_dev.class = sound_class;
227 card->card_dev.release = release_card_device;
228 card->card_dev.groups = card->dev_groups;
229 card->dev_groups[0] = &card_dev_attr_group;
230 err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
231 if (err < 0)
232 goto __error;
233
234 snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
235 dev_driver_string(card->dev), dev_name(&card->card_dev));
236
237
238
239 err = snd_ctl_create(card);
240 if (err < 0) {
241 dev_err(parent, "unable to register control minors\n");
242 goto __error;
243 }
244 err = snd_info_card_create(card);
245 if (err < 0) {
246 dev_err(parent, "unable to create card info\n");
247 goto __error_ctl;
248 }
249 *card_ret = card;
250 return 0;
251
252 __error_ctl:
253 snd_device_free_all(card);
254 __error:
255 put_device(&card->card_dev);
256 return err;
257}
258EXPORT_SYMBOL(snd_card_new);
259
260
261
262
263
264
265
266
267struct snd_card *snd_card_ref(int idx)
268{
269 struct snd_card *card;
270
271 mutex_lock(&snd_card_mutex);
272 card = snd_cards[idx];
273 if (card)
274 get_device(&card->card_dev);
275 mutex_unlock(&snd_card_mutex);
276 return card;
277}
278EXPORT_SYMBOL_GPL(snd_card_ref);
279
280
281int snd_card_locked(int card)
282{
283 int locked;
284
285 mutex_lock(&snd_card_mutex);
286 locked = test_bit(card, snd_cards_lock);
287 mutex_unlock(&snd_card_mutex);
288 return locked;
289}
290
291static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
292{
293 return -ENODEV;
294}
295
296static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
297 size_t count, loff_t *offset)
298{
299 return -ENODEV;
300}
301
302static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
303 size_t count, loff_t *offset)
304{
305 return -ENODEV;
306}
307
308static int snd_disconnect_release(struct inode *inode, struct file *file)
309{
310 struct snd_monitor_file *df = NULL, *_df;
311
312 spin_lock(&shutdown_lock);
313 list_for_each_entry(_df, &shutdown_files, shutdown_list) {
314 if (_df->file == file) {
315 df = _df;
316 list_del_init(&df->shutdown_list);
317 break;
318 }
319 }
320 spin_unlock(&shutdown_lock);
321
322 if (likely(df)) {
323 if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
324 df->disconnected_f_op->fasync(-1, file, 0);
325 return df->disconnected_f_op->release(inode, file);
326 }
327
328 panic("%s(%p, %p) failed!", __func__, inode, file);
329}
330
331static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
332{
333 return EPOLLERR | EPOLLNVAL;
334}
335
336static long snd_disconnect_ioctl(struct file *file,
337 unsigned int cmd, unsigned long arg)
338{
339 return -ENODEV;
340}
341
342static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
343{
344 return -ENODEV;
345}
346
347static int snd_disconnect_fasync(int fd, struct file *file, int on)
348{
349 return -ENODEV;
350}
351
352static const struct file_operations snd_shutdown_f_ops =
353{
354 .owner = THIS_MODULE,
355 .llseek = snd_disconnect_llseek,
356 .read = snd_disconnect_read,
357 .write = snd_disconnect_write,
358 .release = snd_disconnect_release,
359 .poll = snd_disconnect_poll,
360 .unlocked_ioctl = snd_disconnect_ioctl,
361#ifdef CONFIG_COMPAT
362 .compat_ioctl = snd_disconnect_ioctl,
363#endif
364 .mmap = snd_disconnect_mmap,
365 .fasync = snd_disconnect_fasync
366};
367
368
369
370
371
372
373
374
375
376
377
378
379int snd_card_disconnect(struct snd_card *card)
380{
381 struct snd_monitor_file *mfile;
382
383 if (!card)
384 return -EINVAL;
385
386 spin_lock(&card->files_lock);
387 if (card->shutdown) {
388 spin_unlock(&card->files_lock);
389 return 0;
390 }
391 card->shutdown = 1;
392 spin_unlock(&card->files_lock);
393
394
395 spin_lock(&card->files_lock);
396 list_for_each_entry(mfile, &card->files_list, list) {
397
398
399 mfile->disconnected_f_op = mfile->file->f_op;
400
401 spin_lock(&shutdown_lock);
402 list_add(&mfile->shutdown_list, &shutdown_files);
403 spin_unlock(&shutdown_lock);
404
405 mfile->file->f_op = &snd_shutdown_f_ops;
406 fops_get(mfile->file->f_op);
407 }
408 spin_unlock(&card->files_lock);
409
410
411
412
413#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
414 if (snd_mixer_oss_notify_callback)
415 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
416#endif
417
418
419 snd_device_disconnect_all(card);
420
421 snd_info_card_disconnect(card);
422 if (card->registered) {
423 device_del(&card->card_dev);
424 card->registered = false;
425 }
426
427
428 mutex_lock(&snd_card_mutex);
429 snd_cards[card->number] = NULL;
430 clear_bit(card->number, snd_cards_lock);
431 mutex_unlock(&snd_card_mutex);
432
433#ifdef CONFIG_PM
434 wake_up(&card->power_sleep);
435#endif
436 return 0;
437}
438EXPORT_SYMBOL(snd_card_disconnect);
439
440
441
442
443
444
445
446
447
448
449void snd_card_disconnect_sync(struct snd_card *card)
450{
451 int err;
452
453 err = snd_card_disconnect(card);
454 if (err < 0) {
455 dev_err(card->dev,
456 "snd_card_disconnect error (%d), skipping sync\n",
457 err);
458 return;
459 }
460
461 spin_lock_irq(&card->files_lock);
462 wait_event_lock_irq(card->remove_sleep,
463 list_empty(&card->files_list),
464 card->files_lock);
465 spin_unlock_irq(&card->files_lock);
466}
467EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
468
469static int snd_card_do_free(struct snd_card *card)
470{
471#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
472 if (snd_mixer_oss_notify_callback)
473 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
474#endif
475 snd_device_free_all(card);
476 if (card->private_free)
477 card->private_free(card);
478 if (snd_info_card_free(card) < 0) {
479 dev_warn(card->dev, "unable to free card info\n");
480
481 }
482 if (card->release_completion)
483 complete(card->release_completion);
484 kfree(card);
485 return 0;
486}
487
488
489
490
491
492
493
494
495
496
497int snd_card_free_when_closed(struct snd_card *card)
498{
499 int ret = snd_card_disconnect(card);
500 if (ret)
501 return ret;
502 put_device(&card->card_dev);
503 return 0;
504}
505EXPORT_SYMBOL(snd_card_free_when_closed);
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520int snd_card_free(struct snd_card *card)
521{
522 DECLARE_COMPLETION_ONSTACK(released);
523 int ret;
524
525 card->release_completion = &released;
526 ret = snd_card_free_when_closed(card);
527 if (ret)
528 return ret;
529
530 wait_for_completion(&released);
531 return 0;
532}
533EXPORT_SYMBOL(snd_card_free);
534
535
536static const char *retrieve_id_from_card_name(const char *name)
537{
538 const char *spos = name;
539
540 while (*name) {
541 if (isspace(*name) && isalnum(name[1]))
542 spos = name + 1;
543 name++;
544 }
545 return spos;
546}
547
548
549static bool card_id_ok(struct snd_card *card, const char *id)
550{
551 int i;
552 if (!snd_info_check_reserved_words(id))
553 return false;
554 for (i = 0; i < snd_ecards_limit; i++) {
555 if (snd_cards[i] && snd_cards[i] != card &&
556 !strcmp(snd_cards[i]->id, id))
557 return false;
558 }
559 return true;
560}
561
562
563static void copy_valid_id_string(struct snd_card *card, const char *src,
564 const char *nid)
565{
566 char *id = card->id;
567
568 while (*nid && !isalnum(*nid))
569 nid++;
570 if (isdigit(*nid))
571 *id++ = isalpha(*src) ? *src : 'D';
572 while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
573 if (isalnum(*nid))
574 *id++ = *nid;
575 nid++;
576 }
577 *id = 0;
578}
579
580
581
582
583static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
584 const char *nid)
585{
586 int len, loops;
587 bool is_default = false;
588 char *id;
589
590 copy_valid_id_string(card, src, nid);
591 id = card->id;
592
593 again:
594
595
596
597 if (!*id || !strncmp(id, "card", 4)) {
598 strcpy(id, "Default");
599 is_default = true;
600 }
601
602 len = strlen(id);
603 for (loops = 0; loops < SNDRV_CARDS; loops++) {
604 char *spos;
605 char sfxstr[5];
606 int sfxlen;
607
608 if (card_id_ok(card, id))
609 return;
610
611
612 sprintf(sfxstr, "_%X", loops + 1);
613 sfxlen = strlen(sfxstr);
614 if (len + sfxlen >= sizeof(card->id))
615 spos = id + sizeof(card->id) - sfxlen - 1;
616 else
617 spos = id + len;
618 strcpy(spos, sfxstr);
619 }
620
621 if (!is_default) {
622 *id = 0;
623 goto again;
624 }
625
626 dev_err(card->dev, "unable to set card id (%s)\n", id);
627 if (card->proc_root->name)
628 strlcpy(card->id, card->proc_root->name, sizeof(card->id));
629}
630
631
632
633
634
635
636
637
638
639void snd_card_set_id(struct snd_card *card, const char *nid)
640{
641
642 if (card->id[0] != '\0')
643 return;
644 mutex_lock(&snd_card_mutex);
645 snd_card_set_id_no_lock(card, nid, nid);
646 mutex_unlock(&snd_card_mutex);
647}
648EXPORT_SYMBOL(snd_card_set_id);
649
650static ssize_t
651card_id_show_attr(struct device *dev,
652 struct device_attribute *attr, char *buf)
653{
654 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
655 return scnprintf(buf, PAGE_SIZE, "%s\n", card->id);
656}
657
658static ssize_t
659card_id_store_attr(struct device *dev, struct device_attribute *attr,
660 const char *buf, size_t count)
661{
662 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
663 char buf1[sizeof(card->id)];
664 size_t copy = count > sizeof(card->id) - 1 ?
665 sizeof(card->id) - 1 : count;
666 size_t idx;
667 int c;
668
669 for (idx = 0; idx < copy; idx++) {
670 c = buf[idx];
671 if (!isalnum(c) && c != '_' && c != '-')
672 return -EINVAL;
673 }
674 memcpy(buf1, buf, copy);
675 buf1[copy] = '\0';
676 mutex_lock(&snd_card_mutex);
677 if (!card_id_ok(NULL, buf1)) {
678 mutex_unlock(&snd_card_mutex);
679 return -EEXIST;
680 }
681 strcpy(card->id, buf1);
682 snd_info_card_id_change(card);
683 mutex_unlock(&snd_card_mutex);
684
685 return count;
686}
687
688static DEVICE_ATTR(id, 0644, card_id_show_attr, card_id_store_attr);
689
690static ssize_t
691card_number_show_attr(struct device *dev,
692 struct device_attribute *attr, char *buf)
693{
694 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
695 return scnprintf(buf, PAGE_SIZE, "%i\n", card->number);
696}
697
698static DEVICE_ATTR(number, 0444, card_number_show_attr, NULL);
699
700static struct attribute *card_dev_attrs[] = {
701 &dev_attr_id.attr,
702 &dev_attr_number.attr,
703 NULL
704};
705
706static const struct attribute_group card_dev_attr_group = {
707 .attrs = card_dev_attrs,
708};
709
710
711
712
713
714
715int snd_card_add_dev_attr(struct snd_card *card,
716 const struct attribute_group *group)
717{
718 int i;
719
720
721 for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
722 if (!card->dev_groups[i]) {
723 card->dev_groups[i] = group;
724 return 0;
725 }
726 }
727
728 dev_err(card->dev, "Too many groups assigned\n");
729 return -ENOSPC;
730}
731EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
732
733
734
735
736
737
738
739
740
741
742
743
744int snd_card_register(struct snd_card *card)
745{
746 int err;
747
748 if (snd_BUG_ON(!card))
749 return -EINVAL;
750
751 if (!card->registered) {
752 err = device_add(&card->card_dev);
753 if (err < 0)
754 return err;
755 card->registered = true;
756 }
757
758 if ((err = snd_device_register_all(card)) < 0)
759 return err;
760 mutex_lock(&snd_card_mutex);
761 if (snd_cards[card->number]) {
762
763 mutex_unlock(&snd_card_mutex);
764 return snd_info_card_register(card);
765 }
766 if (*card->id) {
767
768 char tmpid[sizeof(card->id)];
769 memcpy(tmpid, card->id, sizeof(card->id));
770 snd_card_set_id_no_lock(card, tmpid, tmpid);
771 } else {
772
773 const char *src;
774 src = *card->shortname ? card->shortname : card->longname;
775 snd_card_set_id_no_lock(card, src,
776 retrieve_id_from_card_name(src));
777 }
778 snd_cards[card->number] = card;
779 mutex_unlock(&snd_card_mutex);
780 err = snd_info_card_register(card);
781 if (err < 0)
782 return err;
783
784#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
785 if (snd_mixer_oss_notify_callback)
786 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
787#endif
788 return 0;
789}
790EXPORT_SYMBOL(snd_card_register);
791
792#ifdef CONFIG_SND_PROC_FS
793static void snd_card_info_read(struct snd_info_entry *entry,
794 struct snd_info_buffer *buffer)
795{
796 int idx, count;
797 struct snd_card *card;
798
799 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
800 mutex_lock(&snd_card_mutex);
801 if ((card = snd_cards[idx]) != NULL) {
802 count++;
803 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
804 idx,
805 card->id,
806 card->driver,
807 card->shortname);
808 snd_iprintf(buffer, " %s\n",
809 card->longname);
810 }
811 mutex_unlock(&snd_card_mutex);
812 }
813 if (!count)
814 snd_iprintf(buffer, "--- no soundcards ---\n");
815}
816
817#ifdef CONFIG_SND_OSSEMUL
818void snd_card_info_read_oss(struct snd_info_buffer *buffer)
819{
820 int idx, count;
821 struct snd_card *card;
822
823 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
824 mutex_lock(&snd_card_mutex);
825 if ((card = snd_cards[idx]) != NULL) {
826 count++;
827 snd_iprintf(buffer, "%s\n", card->longname);
828 }
829 mutex_unlock(&snd_card_mutex);
830 }
831 if (!count) {
832 snd_iprintf(buffer, "--- no soundcards ---\n");
833 }
834}
835
836#endif
837
838#ifdef MODULE
839static void snd_card_module_info_read(struct snd_info_entry *entry,
840 struct snd_info_buffer *buffer)
841{
842 int idx;
843 struct snd_card *card;
844
845 for (idx = 0; idx < SNDRV_CARDS; idx++) {
846 mutex_lock(&snd_card_mutex);
847 if ((card = snd_cards[idx]) != NULL)
848 snd_iprintf(buffer, "%2i %s\n",
849 idx, card->module->name);
850 mutex_unlock(&snd_card_mutex);
851 }
852}
853#endif
854
855int __init snd_card_info_init(void)
856{
857 struct snd_info_entry *entry;
858
859 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
860 if (! entry)
861 return -ENOMEM;
862 entry->c.text.read = snd_card_info_read;
863 if (snd_info_register(entry) < 0)
864 return -ENOMEM;
865
866#ifdef MODULE
867 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
868 if (!entry)
869 return -ENOMEM;
870 entry->c.text.read = snd_card_module_info_read;
871 if (snd_info_register(entry) < 0)
872 return -ENOMEM;
873#endif
874
875 return 0;
876}
877#endif
878
879
880
881
882
883
884
885
886
887
888
889
890int snd_component_add(struct snd_card *card, const char *component)
891{
892 char *ptr;
893 int len = strlen(component);
894
895 ptr = strstr(card->components, component);
896 if (ptr != NULL) {
897 if (ptr[len] == '\0' || ptr[len] == ' ')
898 return 1;
899 }
900 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
901 snd_BUG();
902 return -ENOMEM;
903 }
904 if (card->components[0] != '\0')
905 strcat(card->components, " ");
906 strcat(card->components, component);
907 return 0;
908}
909EXPORT_SYMBOL(snd_component_add);
910
911
912
913
914
915
916
917
918
919
920
921
922int snd_card_file_add(struct snd_card *card, struct file *file)
923{
924 struct snd_monitor_file *mfile;
925
926 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
927 if (mfile == NULL)
928 return -ENOMEM;
929 mfile->file = file;
930 mfile->disconnected_f_op = NULL;
931 INIT_LIST_HEAD(&mfile->shutdown_list);
932 spin_lock(&card->files_lock);
933 if (card->shutdown) {
934 spin_unlock(&card->files_lock);
935 kfree(mfile);
936 return -ENODEV;
937 }
938 list_add(&mfile->list, &card->files_list);
939 get_device(&card->card_dev);
940 spin_unlock(&card->files_lock);
941 return 0;
942}
943EXPORT_SYMBOL(snd_card_file_add);
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958int snd_card_file_remove(struct snd_card *card, struct file *file)
959{
960 struct snd_monitor_file *mfile, *found = NULL;
961
962 spin_lock(&card->files_lock);
963 list_for_each_entry(mfile, &card->files_list, list) {
964 if (mfile->file == file) {
965 list_del(&mfile->list);
966 spin_lock(&shutdown_lock);
967 list_del(&mfile->shutdown_list);
968 spin_unlock(&shutdown_lock);
969 if (mfile->disconnected_f_op)
970 fops_put(mfile->disconnected_f_op);
971 found = mfile;
972 break;
973 }
974 }
975 if (list_empty(&card->files_list))
976 wake_up_all(&card->remove_sleep);
977 spin_unlock(&card->files_lock);
978 if (!found) {
979 dev_err(card->dev, "card file remove problem (%p)\n", file);
980 return -ENOENT;
981 }
982 kfree(found);
983 put_device(&card->card_dev);
984 return 0;
985}
986EXPORT_SYMBOL(snd_card_file_remove);
987
988#ifdef CONFIG_PM
989
990
991
992
993
994
995
996
997
998int snd_power_wait(struct snd_card *card, unsigned int power_state)
999{
1000 wait_queue_entry_t wait;
1001 int result = 0;
1002
1003
1004 if (snd_power_get_state(card) == power_state)
1005 return 0;
1006 init_waitqueue_entry(&wait, current);
1007 add_wait_queue(&card->power_sleep, &wait);
1008 while (1) {
1009 if (card->shutdown) {
1010 result = -ENODEV;
1011 break;
1012 }
1013 if (snd_power_get_state(card) == power_state)
1014 break;
1015 set_current_state(TASK_UNINTERRUPTIBLE);
1016 schedule_timeout(30 * HZ);
1017 }
1018 remove_wait_queue(&card->power_sleep, &wait);
1019 return result;
1020}
1021EXPORT_SYMBOL(snd_power_wait);
1022#endif
1023