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