blob: 45f4b01de23fb41b9ee1f0a09d4efc438a0df448 [file] [log] [blame]
Thomas Gleixner1a59d1b82019-05-27 08:55:05 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Initialization routines
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02004 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/init.h>
8#include <linux/sched.h>
Paul Gortmakerda155d52011-07-15 12:38:28 -04009#include <linux/module.h>
Paul Gortmaker51990e82012-01-22 11:23:42 -050010#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/file.h>
12#include <linux/slab.h>
13#include <linux/time.h>
14#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/pm.h>
Hui Wang2d670ea2021-01-27 16:56:39 +080016#include <linux/debugfs.h>
Takashi Iwaif2464062014-01-29 12:13:43 +010017#include <linux/completion.h>
Takashi Iwai29bb2742021-02-06 21:36:53 +010018#include <linux/interrupt.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010019
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <sound/core.h>
21#include <sound/control.h>
22#include <sound/info.h>
23
Takashi Iwai82a783f2009-09-07 15:50:18 +020024/* monitor files for graceful shutdown (hotplug) */
25struct snd_monitor_file {
26 struct file *file;
27 const struct file_operations *disconnected_f_op;
28 struct list_head shutdown_list; /* still need to shutdown */
29 struct list_head list; /* link of monitor files */
30};
31
Karsten Wiesea9edfc62006-10-06 16:08:27 +020032static DEFINE_SPINLOCK(shutdown_lock);
33static LIST_HEAD(shutdown_files);
34
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -080035static const struct file_operations snd_shutdown_f_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Takashi Iwai7bb24912013-05-15 08:46:39 +020037/* locked for registering/using */
38static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
Takashi Iwaif4fa9682019-04-16 18:18:47 +020039static struct snd_card *snd_cards[SNDRV_CARDS];
Takashi Iwaic0d3fb32006-04-28 15:13:39 +020040
Takashi Iwai746df9482006-05-15 19:49:05 +020041static DEFINE_MUTEX(snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Takashi Iwai304cd072007-10-26 15:10:15 +020043static char *slots[SNDRV_CARDS];
44module_param_array(slots, charp, NULL, 0444);
45MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
46
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020047/* return non-zero if the given index is reserved for the given
Takashi Iwai304cd072007-10-26 15:10:15 +020048 * module via slots option
49 */
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020050static int module_slot_match(struct module *module, int idx)
Takashi Iwai304cd072007-10-26 15:10:15 +020051{
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020052 int match = 1;
Takashi Iwai304cd072007-10-26 15:10:15 +020053#ifdef MODULE
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020054 const char *s1, *s2;
55
Takashi Iwai60f6fef2013-10-28 12:54:52 +010056 if (!module || !*module->name || !slots[idx])
Takashi Iwai304cd072007-10-26 15:10:15 +020057 return 0;
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020058
59 s1 = module->name;
60 s2 = slots[idx];
61 if (*s2 == '!') {
62 match = 0; /* negative match */
63 s2++;
64 }
Takashi Iwai304cd072007-10-26 15:10:15 +020065 /* compare module name strings
66 * hyphens are handled as equivalent with underscore
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)
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020076 return !match;
Takashi Iwai304cd072007-10-26 15:10:15 +020077 if (!c1)
78 break;
79 }
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020080#endif /* MODULE */
81 return match;
Takashi Iwai304cd072007-10-26 15:10:15 +020082}
83
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +010084#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
Takashi Iwai512bbd62005-11-17 13:51:18 +010085int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
Takashi Iwaic0d3fb32006-04-28 15:13:39 +020086EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087#endif
88
Takashi Iwaideb65962014-01-23 11:02:15 +010089static int check_empty_slot(struct module *module, int slot)
90{
91 return !slots[slot] || !*slots[slot];
92}
93
94/* return an empty slot number (>= 0) found in the given bitmask @mask.
95 * @mask == -1 == 0xffffffff means: take any free slot up to 32
96 * when no slot is available, return the original @mask as is.
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; /* found */
109 }
110 }
111 return mask; /* unchanged */
112}
113
Takashi Iwai4b440be2015-01-29 21:32:47 +0100114/* the default release callback set in snd_device_initialize() below;
115 * this is just NOP for now, as almost all jobs are already done in
116 * dev_free callback of snd_device chain instead.
117 */
118static void default_release(struct device *dev)
119{
120}
121
122/**
123 * snd_device_initialize - Initialize struct device for sound devices
124 * @dev: device to initialize
125 * @card: card to assign, optional
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
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100137static int snd_card_do_free(struct snd_card *card);
Takashi Iwai6bbc7fe2015-01-30 12:27:43 +0100138static const struct attribute_group card_dev_attr_group;
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100139
140static void release_card_device(struct device *dev)
141{
142 snd_card_do_free(dev_to_snd_card(dev));
143}
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145/**
Takashi Iwai393aa9c2014-01-29 12:51:12 +0100146 * snd_card_new - create and initialize a soundcard structure
147 * @parent: the parent device object
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
149 * @xid: card identification (ASCII string)
150 * @module: top level module for locking
151 * @extra_size: allocate this extra size after the main soundcard structure
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100152 * @card_ret: the pointer to store the created card instance
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 *
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100154 * The function allocates snd_card instance via kzalloc with the given
155 * space for the driver to use freely. The allocated struct is stored
156 * in the given card_ret pointer.
157 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100158 * Return: Zero if successful or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 */
Takashi Iwai393aa9c2014-01-29 12:51:12 +0100160int snd_card_new(struct device *parent, int idx, const char *xid,
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100161 struct module *module, int extra_size,
162 struct snd_card **card_ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100164 struct snd_card *card;
Takashi Iwaideb65962014-01-23 11:02:15 +0100165 int err;
Hui Wang2d670ea2021-01-27 16:56:39 +0800166#ifdef CONFIG_SND_DEBUG
167 char name[8];
168#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100170 if (snd_BUG_ON(!card_ret))
171 return -EINVAL;
172 *card_ret = NULL;
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (extra_size < 0)
175 extra_size = 0;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200176 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100177 if (!card)
178 return -ENOMEM;
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100179 if (extra_size > 0)
180 card->private_data = (char *)card + sizeof(struct snd_card);
Jaroslav Kysela10a8ebb2009-06-02 12:02:38 +0200181 if (xid)
Joe Perches75b1a8f2021-01-04 09:17:34 -0800182 strscpy(card->id, xid, sizeof(card->id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 err = 0;
Takashi Iwai746df9482006-05-15 19:49:05 +0200184 mutex_lock(&snd_card_mutex);
Takashi Iwaideb65962014-01-23 11:02:15 +0100185 if (idx < 0) /* first check the matching module-name slot */
186 idx = get_slot_from_bitmask(idx, module_slot_match, module);
187 if (idx < 0) /* if not matched, assign an empty slot */
188 idx = get_slot_from_bitmask(idx, check_empty_slot, module);
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200189 if (idx < 0)
190 err = -ENODEV;
191 else if (idx < snd_ecards_limit) {
Takashi Iwai7bb24912013-05-15 08:46:39 +0200192 if (test_bit(idx, snd_cards_lock))
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200193 err = -EBUSY; /* invalid */
194 } else if (idx >= SNDRV_CARDS)
195 err = -ENODEV;
196 if (err < 0) {
Takashi Iwai746df9482006-05-15 19:49:05 +0200197 mutex_unlock(&snd_card_mutex);
Takashi Iwaif2f93072014-02-04 18:21:03 +0100198 dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100199 idx, snd_ecards_limit - 1, err);
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100200 kfree(card);
201 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 }
Takashi Iwai7bb24912013-05-15 08:46:39 +0200203 set_bit(idx, snd_cards_lock); /* lock it */
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200204 if (idx >= snd_ecards_limit)
205 snd_ecards_limit = idx + 1; /* increase the limit */
Takashi Iwai746df9482006-05-15 19:49:05 +0200206 mutex_unlock(&snd_card_mutex);
Takashi Iwai393aa9c2014-01-29 12:51:12 +0100207 card->dev = parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 card->number = idx;
Takashi Iwai81033c62020-06-24 18:03:00 +0200209#ifdef MODULE
210 WARN_ON(!module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 card->module = module;
Takashi Iwai81033c62020-06-24 18:03:00 +0200212#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 INIT_LIST_HEAD(&card->devices);
214 init_rwsem(&card->controls_rwsem);
215 rwlock_init(&card->ctl_files_rwlock);
216 INIT_LIST_HEAD(&card->controls);
217 INIT_LIST_HEAD(&card->ctl_files);
218 spin_lock_init(&card->files_lock);
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100219 INIT_LIST_HEAD(&card->files_list);
Takashi Iwaid4cfb302020-01-20 13:44:22 +0100220 mutex_init(&card->memory_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 init_waitqueue_head(&card->power_sleep);
223#endif
Takashi Iwaic44027c2017-10-11 06:36:13 +0000224 init_waitqueue_head(&card->remove_sleep);
Takashi Iwaifabb26d2019-11-17 09:53:07 +0100225 card->sync_irq = -1;
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100226
227 device_initialize(&card->card_dev);
228 card->card_dev.parent = parent;
229 card->card_dev.class = sound_class;
230 card->card_dev.release = release_card_device;
Takashi Iwai6bbc7fe2015-01-30 12:27:43 +0100231 card->card_dev.groups = card->dev_groups;
232 card->dev_groups[0] = &card_dev_attr_group;
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100233 err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
234 if (err < 0)
235 goto __error;
236
Heiner Kallweitde653602015-12-22 19:09:05 +0100237 snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
238 dev_driver_string(card->dev), dev_name(&card->card_dev));
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 /* the control interface cannot be accessed from the user space until */
241 /* snd_cards_bitmask and snd_cards are set with snd_card_register */
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100242 err = snd_ctl_create(card);
243 if (err < 0) {
Takashi Iwaif2f93072014-02-04 18:21:03 +0100244 dev_err(parent, "unable to register control minors\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 goto __error;
246 }
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100247 err = snd_info_card_create(card);
248 if (err < 0) {
Takashi Iwaif2f93072014-02-04 18:21:03 +0100249 dev_err(parent, "unable to create card info\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 goto __error_ctl;
251 }
Hui Wang2d670ea2021-01-27 16:56:39 +0800252
253#ifdef CONFIG_SND_DEBUG
254 sprintf(name, "card%d", idx);
255 card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
256#endif
257
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100258 *card_ret = card;
259 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 __error_ctl:
Takashi Iwai289ca022014-01-29 15:53:35 +0100262 snd_device_free_all(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 __error:
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100264 put_device(&card->card_dev);
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100265 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266}
Takashi Iwai393aa9c2014-01-29 12:51:12 +0100267EXPORT_SYMBOL(snd_card_new);
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200268
Takashi Iwaif4fa9682019-04-16 18:18:47 +0200269/**
270 * snd_card_ref - Get the card object from the index
271 * @idx: the card index
272 *
273 * Returns a card object corresponding to the given index or NULL if not found.
274 * Release the object via snd_card_unref().
275 */
276struct snd_card *snd_card_ref(int idx)
277{
278 struct snd_card *card;
279
280 mutex_lock(&snd_card_mutex);
281 card = snd_cards[idx];
282 if (card)
283 get_device(&card->card_dev);
284 mutex_unlock(&snd_card_mutex);
285 return card;
286}
287EXPORT_SYMBOL_GPL(snd_card_ref);
288
Takashi Iwai746df9482006-05-15 19:49:05 +0200289/* return non-zero if a card is already locked */
290int snd_card_locked(int card)
291{
292 int locked;
293
294 mutex_lock(&snd_card_mutex);
Takashi Iwai7bb24912013-05-15 08:46:39 +0200295 locked = test_bit(card, snd_cards_lock);
Takashi Iwai746df9482006-05-15 19:49:05 +0200296 mutex_unlock(&snd_card_mutex);
297 return locked;
298}
299
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100300static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
301{
302 return -ENODEV;
303}
304
305static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
306 size_t count, loff_t *offset)
307{
308 return -ENODEV;
309}
310
311static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
312 size_t count, loff_t *offset)
313{
314 return -ENODEV;
315}
316
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200317static int snd_disconnect_release(struct inode *inode, struct file *file)
318{
319 struct snd_monitor_file *df = NULL, *_df;
320
321 spin_lock(&shutdown_lock);
322 list_for_each_entry(_df, &shutdown_files, shutdown_list) {
323 if (_df->file == file) {
324 df = _df;
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100325 list_del_init(&df->shutdown_list);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200326 break;
327 }
328 }
329 spin_unlock(&shutdown_lock);
330
Al Viro233e70f2008-10-31 23:28:30 +0000331 if (likely(df)) {
332 if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
333 df->disconnected_f_op->fasync(-1, file, 0);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200334 return df->disconnected_f_op->release(inode, file);
Al Viro233e70f2008-10-31 23:28:30 +0000335 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200336
Harvey Harrison9bf8e7d2008-03-03 15:32:18 -0800337 panic("%s(%p, %p) failed!", __func__, inode, file);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200338}
339
Al Viro680ef722017-07-02 23:27:36 -0400340static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800342 return EPOLLERR | EPOLLNVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100345static long snd_disconnect_ioctl(struct file *file,
346 unsigned int cmd, unsigned long arg)
347{
348 return -ENODEV;
349}
350
351static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
352{
353 return -ENODEV;
354}
355
356static int snd_disconnect_fasync(int fd, struct file *file, int on)
357{
358 return -ENODEV;
359}
360
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -0800361static const struct file_operations snd_shutdown_f_ops =
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200362{
363 .owner = THIS_MODULE,
364 .llseek = snd_disconnect_llseek,
365 .read = snd_disconnect_read,
366 .write = snd_disconnect_write,
367 .release = snd_disconnect_release,
368 .poll = snd_disconnect_poll,
369 .unlocked_ioctl = snd_disconnect_ioctl,
370#ifdef CONFIG_COMPAT
371 .compat_ioctl = snd_disconnect_ioctl,
372#endif
373 .mmap = snd_disconnect_mmap,
374 .fasync = snd_disconnect_fasync
375};
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377/**
378 * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
379 * @card: soundcard structure
380 *
381 * Disconnects all APIs from the file-operations (user space).
382 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100383 * Return: Zero, otherwise a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 *
385 * Note: The current implementation replaces all active file->f_op with special
386 * dummy file operations (they do nothing except release).
387 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100388int snd_card_disconnect(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
390 struct snd_monitor_file *mfile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Takashi Iwaif18638d2008-04-17 12:52:02 +0200392 if (!card)
393 return -EINVAL;
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 spin_lock(&card->files_lock);
396 if (card->shutdown) {
397 spin_unlock(&card->files_lock);
398 return 0;
399 }
400 card->shutdown = 1;
401 spin_unlock(&card->files_lock);
402
Takashi Iwai2a3f7222019-04-16 17:06:33 +0200403 /* replace file->f_op with special dummy operations */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 spin_lock(&card->files_lock);
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100405 list_for_each_entry(mfile, &card->files_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 /* it's critical part, use endless loop */
407 /* we have no room to fail */
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200408 mfile->disconnected_f_op = mfile->file->f_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200410 spin_lock(&shutdown_lock);
411 list_add(&mfile->shutdown_list, &shutdown_files);
412 spin_unlock(&shutdown_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200414 mfile->file->f_op = &snd_shutdown_f_ops;
Miguel Botonbc9abce2008-01-13 12:03:53 +0100415 fops_get(mfile->file->f_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
417 spin_unlock(&card->files_lock);
418
Takashi Iwai2a3f7222019-04-16 17:06:33 +0200419 /* notify all connected devices about disconnection */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 /* at this point, they cannot respond to any calls except release() */
421
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +0100422#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (snd_mixer_oss_notify_callback)
424 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
425#endif
426
427 /* notify all devices that we are disconnected */
Takashi Iwaie086e302015-02-27 18:01:22 +0100428 snd_device_disconnect_all(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Takashi Iwai29bb2742021-02-06 21:36:53 +0100430 if (card->sync_irq > 0)
431 synchronize_irq(card->sync_irq);
432
Takashi Iwai746d4a02006-06-23 14:37:59 +0200433 snd_info_card_disconnect(card);
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100434 if (card->registered) {
435 device_del(&card->card_dev);
436 card->registered = false;
Takashi Iwai73d38b12008-04-17 12:50:47 +0200437 }
Takashi Iwai2a3f7222019-04-16 17:06:33 +0200438
439 /* disable fops (user space) operations for ALSA API */
440 mutex_lock(&snd_card_mutex);
441 snd_cards[card->number] = NULL;
442 clear_bit(card->number, snd_cards_lock);
443 mutex_unlock(&snd_card_mutex);
444
Takashi Iwaif18638d2008-04-17 12:52:02 +0200445#ifdef CONFIG_PM
446 wake_up(&card->power_sleep);
447#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return 0;
449}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200450EXPORT_SYMBOL(snd_card_disconnect);
451
Takashi Iwaic44027c2017-10-11 06:36:13 +0000452/**
453 * snd_card_disconnect_sync - disconnect card and wait until files get closed
454 * @card: card object to disconnect
455 *
456 * This calls snd_card_disconnect() for disconnecting all belonging components
457 * and waits until all pending files get closed.
458 * It assures that all accesses from user-space finished so that the driver
459 * can release its resources gracefully.
460 */
461void snd_card_disconnect_sync(struct snd_card *card)
462{
463 int err;
464
465 err = snd_card_disconnect(card);
466 if (err < 0) {
467 dev_err(card->dev,
468 "snd_card_disconnect error (%d), skipping sync\n",
469 err);
470 return;
471 }
472
473 spin_lock_irq(&card->files_lock);
474 wait_event_lock_irq(card->remove_sleep,
475 list_empty(&card->files_list),
476 card->files_lock);
477 spin_unlock_irq(&card->files_lock);
478}
479EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
480
Takashi Iwaic4614822006-06-23 14:38:23 +0200481static int snd_card_do_free(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +0100483#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (snd_mixer_oss_notify_callback)
485 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
486#endif
Takashi Iwai72620d62014-02-04 11:36:11 +0100487 snd_device_free_all(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 if (card->private_free)
489 card->private_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 if (snd_info_card_free(card) < 0) {
Takashi Iwaif2f93072014-02-04 18:21:03 +0100491 dev_warn(card->dev, "unable to free card info\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 /* Not fatal error */
493 }
Takashi Iwai3c4ab492021-02-02 23:56:29 +0100494#ifdef CONFIG_SND_DEBUG
495 debugfs_remove(card->debugfs_root);
496 card->debugfs_root = NULL;
497#endif
Takashi Iwaif2464062014-01-29 12:13:43 +0100498 if (card->release_completion)
499 complete(card->release_completion);
Takashi Iwaic4614822006-06-23 14:38:23 +0200500 kfree(card);
501 return 0;
502}
503
Takashi Iwaieb9c38d2014-10-30 15:19:43 +0100504/**
505 * snd_card_free_when_closed - Disconnect the card, free it later eventually
506 * @card: soundcard structure
507 *
508 * Unlike snd_card_free(), this function doesn't try to release the card
509 * resource immediately, but tries to disconnect at first. When the card
510 * is still in use, the function returns before freeing the resources.
511 * The card resources will be freed when the refcount gets to zero.
512 */
Takashi Iwaic4614822006-06-23 14:38:23 +0200513int snd_card_free_when_closed(struct snd_card *card)
514{
Takashi Iwaif18638d2008-04-17 12:52:02 +0200515 int ret = snd_card_disconnect(card);
Takashi Iwaic4614822006-06-23 14:38:23 +0200516 if (ret)
517 return ret;
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100518 put_device(&card->card_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return 0;
520}
Takashi Iwaif2464062014-01-29 12:13:43 +0100521EXPORT_SYMBOL(snd_card_free_when_closed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Takashi Iwaieb9c38d2014-10-30 15:19:43 +0100523/**
524 * snd_card_free - frees given soundcard structure
525 * @card: soundcard structure
526 *
527 * This function releases the soundcard structure and the all assigned
528 * devices automatically. That is, you don't have to release the devices
529 * by yourself.
530 *
531 * This function waits until the all resources are properly released.
532 *
533 * Return: Zero. Frees all associated devices and frees the control
534 * interface associated to given soundcard.
535 */
Takashi Iwaif2464062014-01-29 12:13:43 +0100536int snd_card_free(struct snd_card *card)
537{
Pierre-Louis Bossartbec206d2020-09-02 16:21:23 -0500538 DECLARE_COMPLETION_ONSTACK(released);
Takashi Iwaif2464062014-01-29 12:13:43 +0100539 int ret;
540
Takashi Iwaif2464062014-01-29 12:13:43 +0100541 card->release_completion = &released;
542 ret = snd_card_free_when_closed(card);
543 if (ret)
544 return ret;
545 /* wait, until all devices are ready for the free operation */
546 wait_for_completion(&released);
Hui Wang2d670ea2021-01-27 16:56:39 +0800547
Takashi Iwaif2464062014-01-29 12:13:43 +0100548 return 0;
549}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200550EXPORT_SYMBOL(snd_card_free);
551
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100552/* retrieve the last word of shortname or longname */
553static const char *retrieve_id_from_card_name(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554{
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100555 const char *spos = name;
556
557 while (*name) {
558 if (isspace(*name) && isalnum(name[1]))
559 spos = name + 1;
560 name++;
561 }
562 return spos;
563}
564
565/* return true if the given id string doesn't conflict any other card ids */
566static bool card_id_ok(struct snd_card *card, const char *id)
567{
568 int i;
569 if (!snd_info_check_reserved_words(id))
570 return false;
571 for (i = 0; i < snd_ecards_limit; i++) {
572 if (snd_cards[i] && snd_cards[i] != card &&
573 !strcmp(snd_cards[i]->id, id))
574 return false;
575 }
576 return true;
577}
578
579/* copy to card->id only with valid letters from nid */
580static void copy_valid_id_string(struct snd_card *card, const char *src,
581 const char *nid)
582{
583 char *id = card->id;
584
585 while (*nid && !isalnum(*nid))
586 nid++;
587 if (isdigit(*nid))
588 *id++ = isalpha(*src) ? *src : 'D';
589 while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
590 if (isalnum(*nid))
591 *id++ = *nid;
592 nid++;
593 }
594 *id = 0;
595}
596
597/* Set card->id from the given string
598 * If the string conflicts with other ids, add a suffix to make it unique.
599 */
600static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
601 const char *nid)
602{
603 int len, loops;
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100604 bool is_default = false;
Jaroslav Kysela10a8ebb2009-06-02 12:02:38 +0200605 char *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100607 copy_valid_id_string(card, src, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 id = card->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100610 again:
611 /* use "Default" for obviously invalid strings
612 * ("card" conflicts with proc directories)
613 */
614 if (!*id || !strncmp(id, "card", 4)) {
Takashi Iwaid8e4f9a2011-04-04 12:43:23 +0200615 strcpy(id, "Default");
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100616 is_default = true;
617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Takashi Iwai8edbb192013-05-24 16:30:39 +0200619 len = strlen(id);
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100620 for (loops = 0; loops < SNDRV_CARDS; loops++) {
Takashi Iwai8edbb192013-05-24 16:30:39 +0200621 char *spos;
622 char sfxstr[5]; /* "_012" */
623 int sfxlen;
624
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100625 if (card_id_ok(card, id))
626 return; /* OK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Takashi Iwai8edbb192013-05-24 16:30:39 +0200628 /* Add _XYZ suffix */
629 sprintf(sfxstr, "_%X", loops + 1);
630 sfxlen = strlen(sfxstr);
631 if (len + sfxlen >= sizeof(card->id))
632 spos = id + sizeof(card->id) - sfxlen - 1;
633 else
634 spos = id + len;
635 strcpy(spos, sfxstr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 }
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100637 /* fallback to the default id */
638 if (!is_default) {
639 *id = 0;
640 goto again;
641 }
642 /* last resort... */
Takashi Iwaif2f93072014-02-04 18:21:03 +0100643 dev_err(card->dev, "unable to set card id (%s)\n", id);
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100644 if (card->proc_root->name)
Joe Perches75b1a8f2021-01-04 09:17:34 -0800645 strscpy(card->id, card->proc_root->name, sizeof(card->id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
Mark Brown872c7822009-06-03 20:43:29 +0100648/**
649 * snd_card_set_id - set card identification name
650 * @card: soundcard structure
651 * @nid: new identification string
652 *
653 * This function sets the card identification and checks for name
654 * collisions.
655 */
656void snd_card_set_id(struct snd_card *card, const char *nid)
657{
Jaroslav Kysela5fdc18d2009-06-04 00:12:18 +0200658 /* check if user specified own card->id */
659 if (card->id[0] != '\0')
660 return;
661 mutex_lock(&snd_card_mutex);
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100662 snd_card_set_id_no_lock(card, nid, nid);
Jaroslav Kysela5fdc18d2009-06-04 00:12:18 +0200663 mutex_unlock(&snd_card_mutex);
Mark Brown872c7822009-06-03 20:43:29 +0100664}
Jaroslav Kysela10a8ebb2009-06-02 12:02:38 +0200665EXPORT_SYMBOL(snd_card_set_id);
666
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100667static ssize_t
668card_id_show_attr(struct device *dev,
669 struct device_attribute *attr, char *buf)
670{
Takashi Iwaib203dba2014-02-19 11:18:10 +0100671 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
Jaejoong Kimef21e172018-02-27 11:15:59 +0900672 return scnprintf(buf, PAGE_SIZE, "%s\n", card->id);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100673}
674
675static ssize_t
676card_id_store_attr(struct device *dev, struct device_attribute *attr,
677 const char *buf, size_t count)
678{
Takashi Iwaib203dba2014-02-19 11:18:10 +0100679 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100680 char buf1[sizeof(card->id)];
681 size_t copy = count > sizeof(card->id) - 1 ?
682 sizeof(card->id) - 1 : count;
683 size_t idx;
684 int c;
685
686 for (idx = 0; idx < copy; idx++) {
687 c = buf[idx];
688 if (!isalnum(c) && c != '_' && c != '-')
689 return -EINVAL;
690 }
691 memcpy(buf1, buf, copy);
692 buf1[copy] = '\0';
693 mutex_lock(&snd_card_mutex);
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100694 if (!card_id_ok(NULL, buf1)) {
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100695 mutex_unlock(&snd_card_mutex);
696 return -EEXIST;
697 }
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100698 strcpy(card->id, buf1);
Jaroslav Kyselac2eb9c42008-11-12 16:31:37 +0100699 snd_info_card_id_change(card);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100700 mutex_unlock(&snd_card_mutex);
701
702 return count;
703}
704
Joe Perches6a73cf42018-05-23 12:20:59 -0700705static DEVICE_ATTR(id, 0644, card_id_show_attr, card_id_store_attr);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100706
707static ssize_t
708card_number_show_attr(struct device *dev,
709 struct device_attribute *attr, char *buf)
710{
Takashi Iwaib203dba2014-02-19 11:18:10 +0100711 struct snd_card *card = container_of(dev, struct snd_card, card_dev);
Jaejoong Kimef21e172018-02-27 11:15:59 +0900712 return scnprintf(buf, PAGE_SIZE, "%i\n", card->number);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100713}
714
Joe Perches6a73cf42018-05-23 12:20:59 -0700715static DEVICE_ATTR(number, 0444, card_number_show_attr, NULL);
Takashi Iwai34356db2014-01-29 11:54:10 +0100716
717static struct attribute *card_dev_attrs[] = {
718 &dev_attr_id.attr,
719 &dev_attr_number.attr,
720 NULL
721};
722
Takashi Iwai6bbc7fe2015-01-30 12:27:43 +0100723static const struct attribute_group card_dev_attr_group = {
Takashi Iwai34356db2014-01-29 11:54:10 +0100724 .attrs = card_dev_attrs,
725};
726
Takashi Iwai6bbc7fe2015-01-30 12:27:43 +0100727/**
728 * snd_card_add_dev_attr - Append a new sysfs attribute group to card
729 * @card: card instance
730 * @group: attribute group to append
731 */
732int snd_card_add_dev_attr(struct snd_card *card,
733 const struct attribute_group *group)
734{
735 int i;
736
737 /* loop for (arraysize-1) here to keep NULL at the last entry */
738 for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
739 if (!card->dev_groups[i]) {
740 card->dev_groups[i] = group;
741 return 0;
742 }
743 }
744
745 dev_err(card->dev, "Too many groups assigned\n");
746 return -ENOSPC;
Takashi Iwai35f80012017-06-16 16:16:33 +0200747}
Takashi Iwai6bbc7fe2015-01-30 12:27:43 +0100748EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
Jaroslav Kysela9fb6198e2008-11-11 16:51:02 +0100749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750/**
751 * snd_card_register - register the soundcard
752 * @card: soundcard structure
753 *
754 * This function registers all the devices assigned to the soundcard.
755 * Until calling this, the ALSA control interface is blocked from the
756 * external accesses. Thus, you should call this function at the end
757 * of the initialization of the card.
758 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100759 * Return: Zero otherwise a negative error code if the registration failed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100761int snd_card_register(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
763 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200765 if (snd_BUG_ON(!card))
766 return -EINVAL;
Kay Sievers39aba962010-09-04 22:33:14 -0700767
Takashi Iwai8bfb1812014-01-29 11:46:11 +0100768 if (!card->registered) {
769 err = device_add(&card->card_dev);
770 if (err < 0)
771 return err;
772 card->registered = true;
Greg Kroah-Hartmand80f19f2006-08-07 22:19:37 -0700773 }
Kay Sievers39aba962010-09-04 22:33:14 -0700774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 if ((err = snd_device_register_all(card)) < 0)
776 return err;
Takashi Iwai746df9482006-05-15 19:49:05 +0200777 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 if (snd_cards[card->number]) {
779 /* already registered */
Takashi Iwai746df9482006-05-15 19:49:05 +0200780 mutex_unlock(&snd_card_mutex);
Takashi Iwai2471b6c2015-05-18 09:20:24 +0200781 return snd_info_card_register(card); /* register pending info */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
Takashi Iwaie7df2a32012-03-09 17:41:53 +0100783 if (*card->id) {
784 /* make a unique id name from the given string */
785 char tmpid[sizeof(card->id)];
786 memcpy(tmpid, card->id, sizeof(card->id));
787 snd_card_set_id_no_lock(card, tmpid, tmpid);
788 } else {
789 /* create an id from either shortname or longname */
790 const char *src;
791 src = *card->shortname ? card->shortname : card->longname;
792 snd_card_set_id_no_lock(card, src,
793 retrieve_id_from_card_name(src));
794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 snd_cards[card->number] = card;
Takashi Iwai746df9482006-05-15 19:49:05 +0200796 mutex_unlock(&snd_card_mutex);
Takashi Iwai29b26252019-02-05 16:26:06 +0100797 err = snd_info_card_register(card);
798 if (err < 0)
799 return err;
800
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +0100801#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (snd_mixer_oss_notify_callback)
803 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
804#endif
805 return 0;
806}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200807EXPORT_SYMBOL(snd_card_register);
808
Jie Yangcd6a6502015-05-27 19:45:45 +0800809#ifdef CONFIG_SND_PROC_FS
Takashi Iwaia381a7a2005-11-17 15:55:49 +0100810static void snd_card_info_read(struct snd_info_entry *entry,
811 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100814 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
816 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df9482006-05-15 19:49:05 +0200817 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 if ((card = snd_cards[idx]) != NULL) {
819 count++;
Clemens Ladischd0015442005-11-20 14:09:05 +0100820 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 idx,
822 card->id,
823 card->driver,
824 card->shortname);
Clemens Ladischd0015442005-11-20 14:09:05 +0100825 snd_iprintf(buffer, " %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 card->longname);
827 }
Takashi Iwai746df9482006-05-15 19:49:05 +0200828 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
830 if (!count)
831 snd_iprintf(buffer, "--- no soundcards ---\n");
832}
833
Takashi Iwaie28563c2005-12-01 10:42:42 +0100834#ifdef CONFIG_SND_OSSEMUL
Takashi Iwai512bbd62005-11-17 13:51:18 +0100835void snd_card_info_read_oss(struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
837 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100838 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
840 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df9482006-05-15 19:49:05 +0200841 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if ((card = snd_cards[idx]) != NULL) {
843 count++;
844 snd_iprintf(buffer, "%s\n", card->longname);
845 }
Takashi Iwai746df9482006-05-15 19:49:05 +0200846 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 }
848 if (!count) {
849 snd_iprintf(buffer, "--- no soundcards ---\n");
850 }
851}
852
853#endif
854
855#ifdef MODULE
Takashi Iwai512bbd62005-11-17 13:51:18 +0100856static void snd_card_module_info_read(struct snd_info_entry *entry,
857 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
859 int idx;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100860 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
862 for (idx = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df9482006-05-15 19:49:05 +0200863 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 if ((card = snd_cards[idx]) != NULL)
Clemens Ladischd0015442005-11-20 14:09:05 +0100865 snd_iprintf(buffer, "%2i %s\n",
866 idx, card->module->name);
Takashi Iwai746df9482006-05-15 19:49:05 +0200867 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 }
869}
870#endif
871
872int __init snd_card_info_init(void)
873{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100874 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
876 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200877 if (! entry)
878 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 entry->c.text.read = snd_card_info_read;
Takashi Iwaib591b6e2015-04-22 22:29:10 +0200880 if (snd_info_register(entry) < 0)
881 return -ENOMEM; /* freed in error path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883#ifdef MODULE
884 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
Takashi Iwaib591b6e2015-04-22 22:29:10 +0200885 if (!entry)
886 return -ENOMEM;
887 entry->c.text.read = snd_card_module_info_read;
888 if (snd_info_register(entry) < 0)
889 return -ENOMEM; /* freed in error path */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890#endif
891
892 return 0;
893}
Jie Yangcd6a6502015-05-27 19:45:45 +0800894#endif /* CONFIG_SND_PROC_FS */
Takashi Iwaie28563c2005-12-01 10:42:42 +0100895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896/**
897 * snd_component_add - add a component string
898 * @card: soundcard structure
899 * @component: the component id string
900 *
901 * This function adds the component id string to the supported list.
902 * The component can be referred from the alsa-lib.
903 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100904 * Return: Zero otherwise a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 */
906
Takashi Iwai512bbd62005-11-17 13:51:18 +0100907int snd_component_add(struct snd_card *card, const char *component)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908{
909 char *ptr;
910 int len = strlen(component);
911
912 ptr = strstr(card->components, component);
913 if (ptr != NULL) {
914 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
915 return 1;
916 }
917 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
918 snd_BUG();
919 return -ENOMEM;
920 }
921 if (card->components[0] != '\0')
922 strcat(card->components, " ");
923 strcat(card->components, component);
924 return 0;
925}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200926EXPORT_SYMBOL(snd_component_add);
927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928/**
929 * snd_card_file_add - add the file to the file list of the card
930 * @card: soundcard structure
931 * @file: file pointer
932 *
933 * This function adds the file to the file linked-list of the card.
934 * This linked-list is used to keep tracking the connection state,
935 * and to avoid the release of busy resources by hotplug.
936 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100937 * Return: zero or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100939int snd_card_file_add(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940{
941 struct snd_monitor_file *mfile;
942
943 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
944 if (mfile == NULL)
945 return -ENOMEM;
946 mfile->file = file;
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200947 mfile->disconnected_f_op = NULL;
Takashi Iwaia45e3d62011-03-24 09:50:15 +0100948 INIT_LIST_HEAD(&mfile->shutdown_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 spin_lock(&card->files_lock);
950 if (card->shutdown) {
951 spin_unlock(&card->files_lock);
952 kfree(mfile);
953 return -ENODEV;
954 }
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100955 list_add(&mfile->list, &card->files_list);
Takashi Iwaif2464062014-01-29 12:13:43 +0100956 get_device(&card->card_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 spin_unlock(&card->files_lock);
958 return 0;
959}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200960EXPORT_SYMBOL(snd_card_file_add);
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962/**
963 * snd_card_file_remove - remove the file from the file list
964 * @card: soundcard structure
965 * @file: file pointer
966 *
967 * This function removes the file formerly added to the card via
968 * snd_card_file_add() function.
Takashi Iwai2b29b132006-06-23 14:38:26 +0200969 * If all files are removed and snd_card_free_when_closed() was
970 * called beforehand, it processes the pending release of
971 * resources.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100973 * Return: Zero or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100975int snd_card_file_remove(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100977 struct snd_monitor_file *mfile, *found = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 spin_lock(&card->files_lock);
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100980 list_for_each_entry(mfile, &card->files_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 if (mfile->file == file) {
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100982 list_del(&mfile->list);
Takashi Iwaia45e3d62011-03-24 09:50:15 +0100983 spin_lock(&shutdown_lock);
984 list_del(&mfile->shutdown_list);
985 spin_unlock(&shutdown_lock);
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100986 if (mfile->disconnected_f_op)
987 fops_put(mfile->disconnected_f_op);
988 found = mfile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 break;
990 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 }
Takashi Iwaic44027c2017-10-11 06:36:13 +0000992 if (list_empty(&card->files_list))
993 wake_up_all(&card->remove_sleep);
Takashi Iwaic4614822006-06-23 14:38:23 +0200994 spin_unlock(&card->files_lock);
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100995 if (!found) {
Takashi Iwaif2f93072014-02-04 18:21:03 +0100996 dev_err(card->dev, "card file remove problem (%p)\n", file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 return -ENOENT;
998 }
Takashi Iwai118dd6b2009-02-23 16:35:21 +0100999 kfree(found);
Takashi Iwaif2464062014-01-29 12:13:43 +01001000 put_device(&card->card_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return 0;
1002}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001003EXPORT_SYMBOL(snd_card_file_remove);
1004
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005#ifdef CONFIG_PM
1006/**
1007 * snd_power_wait - wait until the power-state is changed.
1008 * @card: soundcard structure
1009 * @power_state: expected power state
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 *
1011 * Waits until the power-state is changed.
1012 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001013 * Return: Zero if successful, or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 */
Takashi Iwaicbac4b02006-03-27 12:38:07 +02001015int snd_power_wait(struct snd_card *card, unsigned int power_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
Ingo Molnarac6424b2017-06-20 12:06:13 +02001017 wait_queue_entry_t wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 int result = 0;
1019
1020 /* fastpath */
1021 if (snd_power_get_state(card) == power_state)
1022 return 0;
1023 init_waitqueue_entry(&wait, current);
1024 add_wait_queue(&card->power_sleep, &wait);
1025 while (1) {
1026 if (card->shutdown) {
1027 result = -ENODEV;
1028 break;
1029 }
1030 if (snd_power_get_state(card) == power_state)
1031 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 set_current_state(TASK_UNINTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 schedule_timeout(30 * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
1035 remove_wait_queue(&card->power_sleep, &wait);
1036 return result;
1037}
Takashi Iwaic0d3fb32006-04-28 15:13:39 +02001038EXPORT_SYMBOL(snd_power_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039#endif /* CONFIG_PM */