blob: dc4b80c7f311b9fc5e15d30fa96da09a11e81462 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Initialization routines
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02003 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/init.h>
23#include <linux/sched.h>
24#include <linux/file.h>
25#include <linux/slab.h>
26#include <linux/time.h>
27#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/pm.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010029
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <sound/core.h>
31#include <sound/control.h>
32#include <sound/info.h>
33
Karsten Wiesea9edfc62006-10-06 16:08:27 +020034static DEFINE_SPINLOCK(shutdown_lock);
35static LIST_HEAD(shutdown_files);
36
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -080037static const struct file_operations snd_shutdown_f_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Takashi Iwai6581f4e2006-05-17 17:14:51 +020039static unsigned int snd_cards_lock; /* locked for registering/using */
40struct snd_card *snd_cards[SNDRV_CARDS];
Takashi Iwaic0d3fb32006-04-28 15:13:39 +020041EXPORT_SYMBOL(snd_cards);
42
Takashi Iwai746df942006-05-15 19:49:05 +020043static DEFINE_MUTEX(snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Takashi Iwai304cd072007-10-26 15:10:15 +020045static char *slots[SNDRV_CARDS];
46module_param_array(slots, charp, NULL, 0444);
47MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
48
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020049/* return non-zero if the given index is reserved for the given
Takashi Iwai304cd072007-10-26 15:10:15 +020050 * module via slots option
51 */
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020052static int module_slot_match(struct module *module, int idx)
Takashi Iwai304cd072007-10-26 15:10:15 +020053{
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020054 int match = 1;
Takashi Iwai304cd072007-10-26 15:10:15 +020055#ifdef MODULE
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020056 const char *s1, *s2;
57
Takashi Iwai304cd072007-10-26 15:10:15 +020058 if (!module || !module->name || !slots[idx])
59 return 0;
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020060
61 s1 = module->name;
62 s2 = slots[idx];
63 if (*s2 == '!') {
64 match = 0; /* negative match */
65 s2++;
66 }
Takashi Iwai304cd072007-10-26 15:10:15 +020067 /* compare module name strings
68 * hyphens are handled as equivalent with underscore
69 */
70 for (;;) {
71 char c1 = *s1++;
72 char c2 = *s2++;
73 if (c1 == '-')
74 c1 = '_';
75 if (c2 == '-')
76 c2 = '_';
77 if (c1 != c2)
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020078 return !match;
Takashi Iwai304cd072007-10-26 15:10:15 +020079 if (!c1)
80 break;
81 }
Takashi Iwaia93bbaa2008-05-27 17:59:24 +020082#endif /* MODULE */
83 return match;
Takashi Iwai304cd072007-10-26 15:10:15 +020084}
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
Takashi Iwai512bbd62005-11-17 13:51:18 +010087int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
Takashi Iwaic0d3fb32006-04-28 15:13:39 +020088EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#endif
90
Takashi Iwaie28563c2005-12-01 10:42:42 +010091#ifdef CONFIG_PROC_FS
Takashi Iwai512bbd62005-11-17 13:51:18 +010092static void snd_card_id_read(struct snd_info_entry *entry,
93 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 snd_iprintf(buffer, "%s\n", entry->card->id);
96}
97
Takashi Iwaie28563c2005-12-01 10:42:42 +010098static inline int init_info_for_card(struct snd_card *card)
99{
100 int err;
101 struct snd_info_entry *entry;
102
103 if ((err = snd_info_card_register(card)) < 0) {
104 snd_printd("unable to create card info\n");
105 return err;
106 }
107 if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
108 snd_printd("unable to create card entry\n");
109 return err;
110 }
Takashi Iwaie28563c2005-12-01 10:42:42 +0100111 entry->c.text.read = snd_card_id_read;
112 if (snd_info_register(entry) < 0) {
113 snd_info_free_entry(entry);
114 entry = NULL;
115 }
116 card->proc_id = entry;
117 return 0;
118}
119#else /* !CONFIG_PROC_FS */
120#define init_info_for_card(card)
121#endif
122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123/**
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100124 * snd_card_create - create and initialize a soundcard structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
126 * @xid: card identification (ASCII string)
127 * @module: top level module for locking
128 * @extra_size: allocate this extra size after the main soundcard structure
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100129 * @card_ret: the pointer to store the created card instance
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 *
131 * Creates and initializes a soundcard structure.
132 *
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100133 * The function allocates snd_card instance via kzalloc with the given
134 * space for the driver to use freely. The allocated struct is stored
135 * in the given card_ret pointer.
136 *
137 * Returns zero if successful or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 */
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100139int snd_card_create(int idx, const char *xid,
140 struct module *module, int extra_size,
141 struct snd_card **card_ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100143 struct snd_card *card;
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200144 int err, idx2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100146 if (snd_BUG_ON(!card_ret))
147 return -EINVAL;
148 *card_ret = NULL;
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (extra_size < 0)
151 extra_size = 0;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200152 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100153 if (!card)
154 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (xid) {
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100156 if (!snd_info_check_reserved_words(xid)) {
157 snd_printk(KERN_ERR
158 "given id string '%s' is reserved.\n", xid);
159 err = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 goto __error;
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 strlcpy(card->id, xid, sizeof(card->id));
163 }
164 err = 0;
Takashi Iwai746df942006-05-15 19:49:05 +0200165 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 if (idx < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100168 /* idx == -1 == 0xffff means: take any free slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 if (~snd_cards_lock & idx & 1<<idx2) {
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200170 if (module_slot_match(module, idx2)) {
171 idx = idx2;
172 break;
173 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 }
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100175 }
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200176 if (idx < 0) {
177 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
178 /* idx == -1 == 0xffff means: take any free slot */
179 if (~snd_cards_lock & idx & 1<<idx2) {
180 if (!slots[idx2] || !*slots[idx2]) {
181 idx = idx2;
182 break;
183 }
184 }
185 }
186 if (idx < 0)
187 err = -ENODEV;
188 else if (idx < snd_ecards_limit) {
189 if (snd_cards_lock & (1 << idx))
190 err = -EBUSY; /* invalid */
191 } else if (idx >= SNDRV_CARDS)
192 err = -ENODEV;
193 if (err < 0) {
Takashi Iwai746df942006-05-15 19:49:05 +0200194 mutex_unlock(&snd_card_mutex);
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100195 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
196 idx, snd_ecards_limit - 1, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 goto __error;
198 }
199 snd_cards_lock |= 1 << idx; /* lock it */
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200200 if (idx >= snd_ecards_limit)
201 snd_ecards_limit = idx + 1; /* increase the limit */
Takashi Iwai746df942006-05-15 19:49:05 +0200202 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 card->number = idx;
204 card->module = module;
205 INIT_LIST_HEAD(&card->devices);
206 init_rwsem(&card->controls_rwsem);
207 rwlock_init(&card->ctl_files_rwlock);
208 INIT_LIST_HEAD(&card->controls);
209 INIT_LIST_HEAD(&card->ctl_files);
210 spin_lock_init(&card->files_lock);
211 init_waitqueue_head(&card->shutdown_sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212#ifdef CONFIG_PM
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100213 mutex_init(&card->power_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 init_waitqueue_head(&card->power_sleep);
215#endif
216 /* the control interface cannot be accessed from the user space until */
217 /* snd_cards_bitmask and snd_cards are set with snd_card_register */
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100218 err = snd_ctl_create(card);
219 if (err < 0) {
220 snd_printk(KERN_ERR "unable to register control minors\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 goto __error;
222 }
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100223 err = snd_info_card_create(card);
224 if (err < 0) {
225 snd_printk(KERN_ERR "unable to create card info\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 goto __error_ctl;
227 }
228 if (extra_size > 0)
Takashi Iwai512bbd62005-11-17 13:51:18 +0100229 card->private_data = (char *)card + sizeof(struct snd_card);
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100230 *card_ret = card;
231 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 __error_ctl:
234 snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
235 __error:
236 kfree(card);
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100237 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
Takashi Iwai53fb1e62008-12-28 16:32:08 +0100239EXPORT_SYMBOL(snd_card_create);
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200240
Takashi Iwai746df942006-05-15 19:49:05 +0200241/* return non-zero if a card is already locked */
242int snd_card_locked(int card)
243{
244 int locked;
245
246 mutex_lock(&snd_card_mutex);
247 locked = snd_cards_lock & (1 << card);
248 mutex_unlock(&snd_card_mutex);
249 return locked;
250}
251
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100252static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
253{
254 return -ENODEV;
255}
256
257static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
258 size_t count, loff_t *offset)
259{
260 return -ENODEV;
261}
262
263static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
264 size_t count, loff_t *offset)
265{
266 return -ENODEV;
267}
268
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200269static int snd_disconnect_release(struct inode *inode, struct file *file)
270{
271 struct snd_monitor_file *df = NULL, *_df;
272
273 spin_lock(&shutdown_lock);
274 list_for_each_entry(_df, &shutdown_files, shutdown_list) {
275 if (_df->file == file) {
276 df = _df;
277 break;
278 }
279 }
280 spin_unlock(&shutdown_lock);
281
Al Viro233e70f2008-10-31 23:28:30 +0000282 if (likely(df)) {
283 if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
284 df->disconnected_f_op->fasync(-1, file, 0);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200285 return df->disconnected_f_op->release(inode, file);
Al Viro233e70f2008-10-31 23:28:30 +0000286 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200287
Harvey Harrison9bf8e7d2008-03-03 15:32:18 -0800288 panic("%s(%p, %p) failed!", __func__, inode, file);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200289}
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
292{
293 return POLLERR | POLLNVAL;
294}
295
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100296static long snd_disconnect_ioctl(struct file *file,
297 unsigned int cmd, unsigned long arg)
298{
299 return -ENODEV;
300}
301
302static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
303{
304 return -ENODEV;
305}
306
307static int snd_disconnect_fasync(int fd, struct file *file, int on)
308{
309 return -ENODEV;
310}
311
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -0800312static const struct file_operations snd_shutdown_f_ops =
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200313{
314 .owner = THIS_MODULE,
315 .llseek = snd_disconnect_llseek,
316 .read = snd_disconnect_read,
317 .write = snd_disconnect_write,
318 .release = snd_disconnect_release,
319 .poll = snd_disconnect_poll,
320 .unlocked_ioctl = snd_disconnect_ioctl,
321#ifdef CONFIG_COMPAT
322 .compat_ioctl = snd_disconnect_ioctl,
323#endif
324 .mmap = snd_disconnect_mmap,
325 .fasync = snd_disconnect_fasync
326};
327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328/**
329 * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
330 * @card: soundcard structure
331 *
332 * Disconnects all APIs from the file-operations (user space).
333 *
334 * Returns zero, otherwise a negative error code.
335 *
336 * Note: The current implementation replaces all active file->f_op with special
337 * dummy file operations (they do nothing except release).
338 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100339int snd_card_disconnect(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 struct snd_monitor_file *mfile;
342 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 int err;
344
Takashi Iwaif18638d2008-04-17 12:52:02 +0200345 if (!card)
346 return -EINVAL;
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 spin_lock(&card->files_lock);
349 if (card->shutdown) {
350 spin_unlock(&card->files_lock);
351 return 0;
352 }
353 card->shutdown = 1;
354 spin_unlock(&card->files_lock);
355
356 /* phase 1: disable fops (user space) operations for ALSA API */
Takashi Iwai746df942006-05-15 19:49:05 +0200357 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 snd_cards[card->number] = NULL;
Takashi Iwaif18638d2008-04-17 12:52:02 +0200359 snd_cards_lock &= ~(1 << card->number);
Takashi Iwai746df942006-05-15 19:49:05 +0200360 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 /* phase 2: replace file->f_op with special dummy operations */
363
364 spin_lock(&card->files_lock);
365 mfile = card->files;
366 while (mfile) {
367 file = mfile->file;
368
369 /* it's critical part, use endless loop */
370 /* we have no room to fail */
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200371 mfile->disconnected_f_op = mfile->file->f_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200373 spin_lock(&shutdown_lock);
374 list_add(&mfile->shutdown_list, &shutdown_files);
375 spin_unlock(&shutdown_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200377 mfile->file->f_op = &snd_shutdown_f_ops;
Miguel Botonbc9abce2008-01-13 12:03:53 +0100378 fops_get(mfile->file->f_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 mfile = mfile->next;
381 }
382 spin_unlock(&card->files_lock);
383
384 /* phase 3: notify all connected devices about disconnection */
385 /* at this point, they cannot respond to any calls except release() */
386
387#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
388 if (snd_mixer_oss_notify_callback)
389 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
390#endif
391
392 /* notify all devices that we are disconnected */
393 err = snd_device_disconnect_all(card);
394 if (err < 0)
395 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
396
Takashi Iwai746d4a02006-06-23 14:37:59 +0200397 snd_info_card_disconnect(card);
Takashi Iwai73d38b12008-04-17 12:50:47 +0200398#ifndef CONFIG_SYSFS_DEPRECATED
399 if (card->card_dev) {
400 device_unregister(card->card_dev);
401 card->card_dev = NULL;
402 }
403#endif
Takashi Iwaif18638d2008-04-17 12:52:02 +0200404#ifdef CONFIG_PM
405 wake_up(&card->power_sleep);
406#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return 0;
408}
409
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200410EXPORT_SYMBOL(snd_card_disconnect);
411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412/**
413 * snd_card_free - frees given soundcard structure
414 * @card: soundcard structure
415 *
416 * This function releases the soundcard structure and the all assigned
417 * devices automatically. That is, you don't have to release the devices
418 * by yourself.
419 *
420 * Returns zero. Frees all associated devices and frees the control
421 * interface associated to given soundcard.
422 */
Takashi Iwaic4614822006-06-23 14:38:23 +0200423static int snd_card_do_free(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
426 if (snd_mixer_oss_notify_callback)
427 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
428#endif
429 if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
430 snd_printk(KERN_ERR "unable to free all devices (pre)\n");
431 /* Fatal, but this situation should never occur */
432 }
433 if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
434 snd_printk(KERN_ERR "unable to free all devices (normal)\n");
435 /* Fatal, but this situation should never occur */
436 }
437 if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
438 snd_printk(KERN_ERR "unable to free all devices (post)\n");
439 /* Fatal, but this situation should never occur */
440 }
441 if (card->private_free)
442 card->private_free(card);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200443 snd_info_free_entry(card->proc_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 if (snd_info_card_free(card) < 0) {
445 snd_printk(KERN_WARNING "unable to free card info\n");
446 /* Not fatal error */
447 }
Takashi Iwaic4614822006-06-23 14:38:23 +0200448 kfree(card);
449 return 0;
450}
451
Takashi Iwaic4614822006-06-23 14:38:23 +0200452int snd_card_free_when_closed(struct snd_card *card)
453{
454 int free_now = 0;
Takashi Iwaif18638d2008-04-17 12:52:02 +0200455 int ret = snd_card_disconnect(card);
Takashi Iwaic4614822006-06-23 14:38:23 +0200456 if (ret)
457 return ret;
458
459 spin_lock(&card->files_lock);
460 if (card->files == NULL)
461 free_now = 1;
462 else
463 card->free_on_last_close = 1;
464 spin_unlock(&card->files_lock);
465
466 if (free_now)
467 snd_card_do_free(card);
468 return 0;
469}
470
471EXPORT_SYMBOL(snd_card_free_when_closed);
472
473int snd_card_free(struct snd_card *card)
474{
Takashi Iwaif18638d2008-04-17 12:52:02 +0200475 int ret = snd_card_disconnect(card);
Takashi Iwaic4614822006-06-23 14:38:23 +0200476 if (ret)
477 return ret;
478
479 /* wait, until all devices are ready for the free operation */
480 wait_event(card->shutdown_sleep, card->files == NULL);
481 snd_card_do_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return 0;
483}
484
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200485EXPORT_SYMBOL(snd_card_free);
486
Takashi Iwai512bbd62005-11-17 13:51:18 +0100487static void choose_default_id(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
Clemens Ladischd0015442005-11-20 14:09:05 +0100489 int i, len, idx_flag = 0, loops = SNDRV_CARDS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 char *id, *spos;
491
492 id = spos = card->shortname;
493 while (*id != '\0') {
494 if (*id == ' ')
495 spos = id + 1;
496 id++;
497 }
498 id = card->id;
499 while (*spos != '\0' && !isalnum(*spos))
500 spos++;
501 if (isdigit(*spos))
502 *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
503 while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
504 if (isalnum(*spos))
505 *id++ = *spos;
506 spos++;
507 }
508 *id = '\0';
509
510 id = card->id;
511
512 if (*id == '\0')
513 strcpy(id, "default");
514
515 while (1) {
516 if (loops-- == 0) {
517 snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
518 strcpy(card->id, card->proc_root->name);
519 return;
520 }
521 if (!snd_info_check_reserved_words(id))
522 goto __change;
523 for (i = 0; i < snd_ecards_limit; i++) {
524 if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
525 goto __change;
526 }
527 break;
528
529 __change:
530 len = strlen(id);
Clemens Ladischd0015442005-11-20 14:09:05 +0100531 if (idx_flag) {
532 if (id[len-1] != '9')
533 id[len-1]++;
534 else
535 id[len-1] = 'A';
536 } else if ((size_t)len <= sizeof(card->id) - 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 strcat(id, "_1");
538 idx_flag++;
539 } else {
540 spos = id + len - 2;
541 if ((size_t)len <= sizeof(card->id) - 2)
542 spos++;
543 *spos++ = '_';
544 *spos++ = '1';
545 *spos++ = '\0';
546 idx_flag++;
547 }
548 }
549}
550
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100551#ifndef CONFIG_SYSFS_DEPRECATED
552static ssize_t
553card_id_show_attr(struct device *dev,
554 struct device_attribute *attr, char *buf)
555{
556 struct snd_card *card = dev_get_drvdata(dev);
557 return snprintf(buf, PAGE_SIZE, "%s\n", card ? card->id : "(null)");
558}
559
560static ssize_t
561card_id_store_attr(struct device *dev, struct device_attribute *attr,
562 const char *buf, size_t count)
563{
564 struct snd_card *card = dev_get_drvdata(dev);
565 char buf1[sizeof(card->id)];
566 size_t copy = count > sizeof(card->id) - 1 ?
567 sizeof(card->id) - 1 : count;
568 size_t idx;
569 int c;
570
571 for (idx = 0; idx < copy; idx++) {
572 c = buf[idx];
573 if (!isalnum(c) && c != '_' && c != '-')
574 return -EINVAL;
575 }
576 memcpy(buf1, buf, copy);
577 buf1[copy] = '\0';
578 mutex_lock(&snd_card_mutex);
579 if (!snd_info_check_reserved_words(buf1)) {
580 __exist:
581 mutex_unlock(&snd_card_mutex);
582 return -EEXIST;
583 }
584 for (idx = 0; idx < snd_ecards_limit; idx++) {
585 if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1))
586 goto __exist;
587 }
588 strcpy(card->id, buf1);
Jaroslav Kyselac2eb9c42008-11-12 16:31:37 +0100589 snd_info_card_id_change(card);
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100590 mutex_unlock(&snd_card_mutex);
591
592 return count;
593}
594
595static struct device_attribute card_id_attrs =
596 __ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
597
598static ssize_t
599card_number_show_attr(struct device *dev,
600 struct device_attribute *attr, char *buf)
601{
602 struct snd_card *card = dev_get_drvdata(dev);
603 return snprintf(buf, PAGE_SIZE, "%i\n", card ? card->number : -1);
604}
605
606static struct device_attribute card_number_attrs =
607 __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
608#endif /* CONFIG_SYSFS_DEPRECATED */
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610/**
611 * snd_card_register - register the soundcard
612 * @card: soundcard structure
613 *
614 * This function registers all the devices assigned to the soundcard.
615 * Until calling this, the ALSA control interface is blocked from the
616 * external accesses. Thus, you should call this function at the end
617 * of the initialization of the card.
618 *
619 * Returns zero otherwise a negative error code if the registrain failed.
620 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100621int snd_card_register(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
623 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200625 if (snd_BUG_ON(!card))
626 return -EINVAL;
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100627#ifndef CONFIG_SYSFS_DEPRECATED
628 if (!card->card_dev) {
Greg Kroah-Hartmanabe9ab82008-07-21 20:03:34 -0700629 card->card_dev = device_create(sound_class, card->dev,
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100630 MKDEV(0, 0), card,
Greg Kroah-Hartmanabe9ab82008-07-21 20:03:34 -0700631 "card%i", card->number);
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100632 if (IS_ERR(card->card_dev))
633 card->card_dev = NULL;
Greg Kroah-Hartmand80f19f2006-08-07 22:19:37 -0700634 }
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100635#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if ((err = snd_device_register_all(card)) < 0)
637 return err;
Takashi Iwai746df942006-05-15 19:49:05 +0200638 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 if (snd_cards[card->number]) {
640 /* already registered */
Takashi Iwai746df942006-05-15 19:49:05 +0200641 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return 0;
643 }
644 if (card->id[0] == '\0')
645 choose_default_id(card);
646 snd_cards[card->number] = card;
Takashi Iwai746df942006-05-15 19:49:05 +0200647 mutex_unlock(&snd_card_mutex);
Takashi Iwaie28563c2005-12-01 10:42:42 +0100648 init_info_for_card(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
650 if (snd_mixer_oss_notify_callback)
651 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
652#endif
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100653#ifndef CONFIG_SYSFS_DEPRECATED
654 if (card->card_dev) {
Hannes Eder2af75292008-11-18 12:25:06 -0500655 err = device_create_file(card->card_dev, &card_id_attrs);
656 if (err < 0)
657 return err;
658 err = device_create_file(card->card_dev, &card_number_attrs);
659 if (err < 0)
660 return err;
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100661 }
662#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 return 0;
664}
665
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200666EXPORT_SYMBOL(snd_card_register);
667
Takashi Iwaie28563c2005-12-01 10:42:42 +0100668#ifdef CONFIG_PROC_FS
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200669static struct snd_info_entry *snd_card_info_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Takashi Iwaia381a7a2005-11-17 15:55:49 +0100671static void snd_card_info_read(struct snd_info_entry *entry,
672 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100675 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
677 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200678 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 if ((card = snd_cards[idx]) != NULL) {
680 count++;
Clemens Ladischd0015442005-11-20 14:09:05 +0100681 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 idx,
683 card->id,
684 card->driver,
685 card->shortname);
Clemens Ladischd0015442005-11-20 14:09:05 +0100686 snd_iprintf(buffer, " %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 card->longname);
688 }
Takashi Iwai746df942006-05-15 19:49:05 +0200689 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 }
691 if (!count)
692 snd_iprintf(buffer, "--- no soundcards ---\n");
693}
694
Takashi Iwaie28563c2005-12-01 10:42:42 +0100695#ifdef CONFIG_SND_OSSEMUL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Takashi Iwai512bbd62005-11-17 13:51:18 +0100697void snd_card_info_read_oss(struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698{
699 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100700 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200703 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 if ((card = snd_cards[idx]) != NULL) {
705 count++;
706 snd_iprintf(buffer, "%s\n", card->longname);
707 }
Takashi Iwai746df942006-05-15 19:49:05 +0200708 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 }
710 if (!count) {
711 snd_iprintf(buffer, "--- no soundcards ---\n");
712 }
713}
714
715#endif
716
717#ifdef MODULE
Takashi Iwai512bbd62005-11-17 13:51:18 +0100718static struct snd_info_entry *snd_card_module_info_entry;
719static void snd_card_module_info_read(struct snd_info_entry *entry,
720 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 int idx;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100723 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 for (idx = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200726 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 if ((card = snd_cards[idx]) != NULL)
Clemens Ladischd0015442005-11-20 14:09:05 +0100728 snd_iprintf(buffer, "%2i %s\n",
729 idx, card->module->name);
Takashi Iwai746df942006-05-15 19:49:05 +0200730 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 }
732}
733#endif
734
735int __init snd_card_info_init(void)
736{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100737 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200740 if (! entry)
741 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 entry->c.text.read = snd_card_info_read;
743 if (snd_info_register(entry) < 0) {
744 snd_info_free_entry(entry);
745 return -ENOMEM;
746 }
747 snd_card_info_entry = entry;
748
749#ifdef MODULE
750 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
751 if (entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 entry->c.text.read = snd_card_module_info_read;
753 if (snd_info_register(entry) < 0)
754 snd_info_free_entry(entry);
755 else
756 snd_card_module_info_entry = entry;
757 }
758#endif
759
760 return 0;
761}
762
763int __exit snd_card_info_done(void)
764{
Takashi Iwai746d4a02006-06-23 14:37:59 +0200765 snd_info_free_entry(snd_card_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766#ifdef MODULE
Takashi Iwai746d4a02006-06-23 14:37:59 +0200767 snd_info_free_entry(snd_card_module_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768#endif
769 return 0;
770}
771
Takashi Iwaie28563c2005-12-01 10:42:42 +0100772#endif /* CONFIG_PROC_FS */
773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774/**
775 * snd_component_add - add a component string
776 * @card: soundcard structure
777 * @component: the component id string
778 *
779 * This function adds the component id string to the supported list.
780 * The component can be referred from the alsa-lib.
781 *
782 * Returns zero otherwise a negative error code.
783 */
784
Takashi Iwai512bbd62005-11-17 13:51:18 +0100785int snd_component_add(struct snd_card *card, const char *component)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 char *ptr;
788 int len = strlen(component);
789
790 ptr = strstr(card->components, component);
791 if (ptr != NULL) {
792 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
793 return 1;
794 }
795 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
796 snd_BUG();
797 return -ENOMEM;
798 }
799 if (card->components[0] != '\0')
800 strcat(card->components, " ");
801 strcat(card->components, component);
802 return 0;
803}
804
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200805EXPORT_SYMBOL(snd_component_add);
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807/**
808 * snd_card_file_add - add the file to the file list of the card
809 * @card: soundcard structure
810 * @file: file pointer
811 *
812 * This function adds the file to the file linked-list of the card.
813 * This linked-list is used to keep tracking the connection state,
814 * and to avoid the release of busy resources by hotplug.
815 *
816 * Returns zero or a negative error code.
817 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100818int snd_card_file_add(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 struct snd_monitor_file *mfile;
821
822 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
823 if (mfile == NULL)
824 return -ENOMEM;
825 mfile->file = file;
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200826 mfile->disconnected_f_op = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 mfile->next = NULL;
828 spin_lock(&card->files_lock);
829 if (card->shutdown) {
830 spin_unlock(&card->files_lock);
831 kfree(mfile);
832 return -ENODEV;
833 }
834 mfile->next = card->files;
835 card->files = mfile;
836 spin_unlock(&card->files_lock);
837 return 0;
838}
839
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200840EXPORT_SYMBOL(snd_card_file_add);
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842/**
843 * snd_card_file_remove - remove the file from the file list
844 * @card: soundcard structure
845 * @file: file pointer
846 *
847 * This function removes the file formerly added to the card via
848 * snd_card_file_add() function.
Takashi Iwai2b29b132006-06-23 14:38:26 +0200849 * If all files are removed and snd_card_free_when_closed() was
850 * called beforehand, it processes the pending release of
851 * resources.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 *
853 * Returns zero or a negative error code.
854 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100855int snd_card_file_remove(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
857 struct snd_monitor_file *mfile, *pfile = NULL;
Takashi Iwaic4614822006-06-23 14:38:23 +0200858 int last_close = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 spin_lock(&card->files_lock);
861 mfile = card->files;
862 while (mfile) {
863 if (mfile->file == file) {
864 if (pfile)
865 pfile->next = mfile->next;
866 else
867 card->files = mfile->next;
868 break;
869 }
870 pfile = mfile;
871 mfile = mfile->next;
872 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200873 if (mfile && mfile->disconnected_f_op) {
874 fops_put(mfile->disconnected_f_op);
875 spin_lock(&shutdown_lock);
876 list_del(&mfile->shutdown_list);
877 spin_unlock(&shutdown_lock);
878 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (card->files == NULL)
Takashi Iwaic4614822006-06-23 14:38:23 +0200880 last_close = 1;
881 spin_unlock(&card->files_lock);
882 if (last_close) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 wake_up(&card->shutdown_sleep);
Takashi Iwaic4614822006-06-23 14:38:23 +0200884 if (card->free_on_last_close)
885 snd_card_do_free(card);
886 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 if (!mfile) {
888 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
889 return -ENOENT;
890 }
891 kfree(mfile);
892 return 0;
893}
894
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200895EXPORT_SYMBOL(snd_card_file_remove);
896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897#ifdef CONFIG_PM
898/**
899 * snd_power_wait - wait until the power-state is changed.
900 * @card: soundcard structure
901 * @power_state: expected power state
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 *
903 * Waits until the power-state is changed.
904 *
905 * Note: the power lock must be active before call.
906 */
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200907int snd_power_wait(struct snd_card *card, unsigned int power_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908{
909 wait_queue_t wait;
910 int result = 0;
911
912 /* fastpath */
913 if (snd_power_get_state(card) == power_state)
914 return 0;
915 init_waitqueue_entry(&wait, current);
916 add_wait_queue(&card->power_sleep, &wait);
917 while (1) {
918 if (card->shutdown) {
919 result = -ENODEV;
920 break;
921 }
922 if (snd_power_get_state(card) == power_state)
923 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 set_current_state(TASK_UNINTERRUPTIBLE);
925 snd_power_unlock(card);
926 schedule_timeout(30 * HZ);
927 snd_power_lock(card);
928 }
929 remove_wait_queue(&card->power_sleep, &wait);
930 return result;
931}
932
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200933EXPORT_SYMBOL(snd_power_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934#endif /* CONFIG_PM */