blob: 0d5520c415d3ad77258221cc4ebbdc25f6799def [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/**
124 * snd_card_new - create and initialize a soundcard structure
125 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
126 * @xid: card identification (ASCII string)
127 * @module: top level module for locking
128 * @extra_size: allocate this extra size after the main soundcard structure
129 *
130 * Creates and initializes a soundcard structure.
131 *
Takashi Iwai512bbd62005-11-17 13:51:18 +0100132 * Returns kmallocated snd_card structure. Creates the ALSA control interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * (which is blocked until snd_card_register function is called).
134 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100135struct snd_card *snd_card_new(int idx, const char *xid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 struct module *module, int extra_size)
137{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100138 struct snd_card *card;
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200139 int err, idx2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
141 if (extra_size < 0)
142 extra_size = 0;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200143 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 if (card == NULL)
145 return NULL;
146 if (xid) {
147 if (!snd_info_check_reserved_words(xid))
148 goto __error;
149 strlcpy(card->id, xid, sizeof(card->id));
150 }
151 err = 0;
Takashi Iwai746df942006-05-15 19:49:05 +0200152 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 if (idx < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100155 /* idx == -1 == 0xffff means: take any free slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (~snd_cards_lock & idx & 1<<idx2) {
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200157 if (module_slot_match(module, idx2)) {
158 idx = idx2;
159 break;
160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100162 }
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200163 if (idx < 0) {
164 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
165 /* idx == -1 == 0xffff means: take any free slot */
166 if (~snd_cards_lock & idx & 1<<idx2) {
167 if (!slots[idx2] || !*slots[idx2]) {
168 idx = idx2;
169 break;
170 }
171 }
172 }
173 if (idx < 0)
174 err = -ENODEV;
175 else if (idx < snd_ecards_limit) {
176 if (snd_cards_lock & (1 << idx))
177 err = -EBUSY; /* invalid */
178 } else if (idx >= SNDRV_CARDS)
179 err = -ENODEV;
180 if (err < 0) {
Takashi Iwai746df942006-05-15 19:49:05 +0200181 mutex_unlock(&snd_card_mutex);
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100182 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
183 idx, snd_ecards_limit - 1, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 goto __error;
185 }
186 snd_cards_lock |= 1 << idx; /* lock it */
Takashi Iwaia93bbaa2008-05-27 17:59:24 +0200187 if (idx >= snd_ecards_limit)
188 snd_ecards_limit = idx + 1; /* increase the limit */
Takashi Iwai746df942006-05-15 19:49:05 +0200189 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 card->number = idx;
191 card->module = module;
192 INIT_LIST_HEAD(&card->devices);
193 init_rwsem(&card->controls_rwsem);
194 rwlock_init(&card->ctl_files_rwlock);
195 INIT_LIST_HEAD(&card->controls);
196 INIT_LIST_HEAD(&card->ctl_files);
197 spin_lock_init(&card->files_lock);
198 init_waitqueue_head(&card->shutdown_sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199#ifdef CONFIG_PM
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100200 mutex_init(&card->power_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 init_waitqueue_head(&card->power_sleep);
202#endif
203 /* the control interface cannot be accessed from the user space until */
204 /* snd_cards_bitmask and snd_cards are set with snd_card_register */
205 if ((err = snd_ctl_create(card)) < 0) {
206 snd_printd("unable to register control minors\n");
207 goto __error;
208 }
209 if ((err = snd_info_card_create(card)) < 0) {
210 snd_printd("unable to create card info\n");
211 goto __error_ctl;
212 }
213 if (extra_size > 0)
Takashi Iwai512bbd62005-11-17 13:51:18 +0100214 card->private_data = (char *)card + sizeof(struct snd_card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 return card;
216
217 __error_ctl:
218 snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
219 __error:
220 kfree(card);
221 return NULL;
222}
223
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200224EXPORT_SYMBOL(snd_card_new);
225
Takashi Iwai746df942006-05-15 19:49:05 +0200226/* return non-zero if a card is already locked */
227int snd_card_locked(int card)
228{
229 int locked;
230
231 mutex_lock(&snd_card_mutex);
232 locked = snd_cards_lock & (1 << card);
233 mutex_unlock(&snd_card_mutex);
234 return locked;
235}
236
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100237static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
238{
239 return -ENODEV;
240}
241
242static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
243 size_t count, loff_t *offset)
244{
245 return -ENODEV;
246}
247
248static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
249 size_t count, loff_t *offset)
250{
251 return -ENODEV;
252}
253
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200254static int snd_disconnect_release(struct inode *inode, struct file *file)
255{
256 struct snd_monitor_file *df = NULL, *_df;
257
258 spin_lock(&shutdown_lock);
259 list_for_each_entry(_df, &shutdown_files, shutdown_list) {
260 if (_df->file == file) {
261 df = _df;
262 break;
263 }
264 }
265 spin_unlock(&shutdown_lock);
266
Al Viro233e70f2008-10-31 23:28:30 +0000267 if (likely(df)) {
268 if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
269 df->disconnected_f_op->fasync(-1, file, 0);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200270 return df->disconnected_f_op->release(inode, file);
Al Viro233e70f2008-10-31 23:28:30 +0000271 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200272
Harvey Harrison9bf8e7d2008-03-03 15:32:18 -0800273 panic("%s(%p, %p) failed!", __func__, inode, file);
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200274}
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
277{
278 return POLLERR | POLLNVAL;
279}
280
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100281static long snd_disconnect_ioctl(struct file *file,
282 unsigned int cmd, unsigned long arg)
283{
284 return -ENODEV;
285}
286
287static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
288{
289 return -ENODEV;
290}
291
292static int snd_disconnect_fasync(int fd, struct file *file, int on)
293{
294 return -ENODEV;
295}
296
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -0800297static const struct file_operations snd_shutdown_f_ops =
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200298{
299 .owner = THIS_MODULE,
300 .llseek = snd_disconnect_llseek,
301 .read = snd_disconnect_read,
302 .write = snd_disconnect_write,
303 .release = snd_disconnect_release,
304 .poll = snd_disconnect_poll,
305 .unlocked_ioctl = snd_disconnect_ioctl,
306#ifdef CONFIG_COMPAT
307 .compat_ioctl = snd_disconnect_ioctl,
308#endif
309 .mmap = snd_disconnect_mmap,
310 .fasync = snd_disconnect_fasync
311};
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313/**
314 * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
315 * @card: soundcard structure
316 *
317 * Disconnects all APIs from the file-operations (user space).
318 *
319 * Returns zero, otherwise a negative error code.
320 *
321 * Note: The current implementation replaces all active file->f_op with special
322 * dummy file operations (they do nothing except release).
323 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100324int snd_card_disconnect(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
326 struct snd_monitor_file *mfile;
327 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 int err;
329
Takashi Iwaif18638d2008-04-17 12:52:02 +0200330 if (!card)
331 return -EINVAL;
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 spin_lock(&card->files_lock);
334 if (card->shutdown) {
335 spin_unlock(&card->files_lock);
336 return 0;
337 }
338 card->shutdown = 1;
339 spin_unlock(&card->files_lock);
340
341 /* phase 1: disable fops (user space) operations for ALSA API */
Takashi Iwai746df942006-05-15 19:49:05 +0200342 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 snd_cards[card->number] = NULL;
Takashi Iwaif18638d2008-04-17 12:52:02 +0200344 snd_cards_lock &= ~(1 << card->number);
Takashi Iwai746df942006-05-15 19:49:05 +0200345 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 /* phase 2: replace file->f_op with special dummy operations */
348
349 spin_lock(&card->files_lock);
350 mfile = card->files;
351 while (mfile) {
352 file = mfile->file;
353
354 /* it's critical part, use endless loop */
355 /* we have no room to fail */
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200356 mfile->disconnected_f_op = mfile->file->f_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200358 spin_lock(&shutdown_lock);
359 list_add(&mfile->shutdown_list, &shutdown_files);
360 spin_unlock(&shutdown_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200362 mfile->file->f_op = &snd_shutdown_f_ops;
Miguel Botonbc9abce2008-01-13 12:03:53 +0100363 fops_get(mfile->file->f_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 mfile = mfile->next;
366 }
367 spin_unlock(&card->files_lock);
368
369 /* phase 3: notify all connected devices about disconnection */
370 /* at this point, they cannot respond to any calls except release() */
371
372#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
373 if (snd_mixer_oss_notify_callback)
374 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
375#endif
376
377 /* notify all devices that we are disconnected */
378 err = snd_device_disconnect_all(card);
379 if (err < 0)
380 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
381
Takashi Iwai746d4a02006-06-23 14:37:59 +0200382 snd_info_card_disconnect(card);
Takashi Iwai73d38b12008-04-17 12:50:47 +0200383#ifndef CONFIG_SYSFS_DEPRECATED
384 if (card->card_dev) {
385 device_unregister(card->card_dev);
386 card->card_dev = NULL;
387 }
388#endif
Takashi Iwaif18638d2008-04-17 12:52:02 +0200389#ifdef CONFIG_PM
390 wake_up(&card->power_sleep);
391#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return 0;
393}
394
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200395EXPORT_SYMBOL(snd_card_disconnect);
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397/**
398 * snd_card_free - frees given soundcard structure
399 * @card: soundcard structure
400 *
401 * This function releases the soundcard structure and the all assigned
402 * devices automatically. That is, you don't have to release the devices
403 * by yourself.
404 *
405 * Returns zero. Frees all associated devices and frees the control
406 * interface associated to given soundcard.
407 */
Takashi Iwaic4614822006-06-23 14:38:23 +0200408static int snd_card_do_free(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
411 if (snd_mixer_oss_notify_callback)
412 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
413#endif
414 if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
415 snd_printk(KERN_ERR "unable to free all devices (pre)\n");
416 /* Fatal, but this situation should never occur */
417 }
418 if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
419 snd_printk(KERN_ERR "unable to free all devices (normal)\n");
420 /* Fatal, but this situation should never occur */
421 }
422 if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
423 snd_printk(KERN_ERR "unable to free all devices (post)\n");
424 /* Fatal, but this situation should never occur */
425 }
426 if (card->private_free)
427 card->private_free(card);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200428 snd_info_free_entry(card->proc_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 if (snd_info_card_free(card) < 0) {
430 snd_printk(KERN_WARNING "unable to free card info\n");
431 /* Not fatal error */
432 }
Takashi Iwaic4614822006-06-23 14:38:23 +0200433 kfree(card);
434 return 0;
435}
436
Takashi Iwaic4614822006-06-23 14:38:23 +0200437int snd_card_free_when_closed(struct snd_card *card)
438{
439 int free_now = 0;
Takashi Iwaif18638d2008-04-17 12:52:02 +0200440 int ret = snd_card_disconnect(card);
Takashi Iwaic4614822006-06-23 14:38:23 +0200441 if (ret)
442 return ret;
443
444 spin_lock(&card->files_lock);
445 if (card->files == NULL)
446 free_now = 1;
447 else
448 card->free_on_last_close = 1;
449 spin_unlock(&card->files_lock);
450
451 if (free_now)
452 snd_card_do_free(card);
453 return 0;
454}
455
456EXPORT_SYMBOL(snd_card_free_when_closed);
457
458int snd_card_free(struct snd_card *card)
459{
Takashi Iwaif18638d2008-04-17 12:52:02 +0200460 int ret = snd_card_disconnect(card);
Takashi Iwaic4614822006-06-23 14:38:23 +0200461 if (ret)
462 return ret;
463
464 /* wait, until all devices are ready for the free operation */
465 wait_event(card->shutdown_sleep, card->files == NULL);
466 snd_card_do_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 return 0;
468}
469
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200470EXPORT_SYMBOL(snd_card_free);
471
Takashi Iwai512bbd62005-11-17 13:51:18 +0100472static void choose_default_id(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
Clemens Ladischd0015442005-11-20 14:09:05 +0100474 int i, len, idx_flag = 0, loops = SNDRV_CARDS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 char *id, *spos;
476
477 id = spos = card->shortname;
478 while (*id != '\0') {
479 if (*id == ' ')
480 spos = id + 1;
481 id++;
482 }
483 id = card->id;
484 while (*spos != '\0' && !isalnum(*spos))
485 spos++;
486 if (isdigit(*spos))
487 *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
488 while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
489 if (isalnum(*spos))
490 *id++ = *spos;
491 spos++;
492 }
493 *id = '\0';
494
495 id = card->id;
496
497 if (*id == '\0')
498 strcpy(id, "default");
499
500 while (1) {
501 if (loops-- == 0) {
502 snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
503 strcpy(card->id, card->proc_root->name);
504 return;
505 }
506 if (!snd_info_check_reserved_words(id))
507 goto __change;
508 for (i = 0; i < snd_ecards_limit; i++) {
509 if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
510 goto __change;
511 }
512 break;
513
514 __change:
515 len = strlen(id);
Clemens Ladischd0015442005-11-20 14:09:05 +0100516 if (idx_flag) {
517 if (id[len-1] != '9')
518 id[len-1]++;
519 else
520 id[len-1] = 'A';
521 } else if ((size_t)len <= sizeof(card->id) - 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 strcat(id, "_1");
523 idx_flag++;
524 } else {
525 spos = id + len - 2;
526 if ((size_t)len <= sizeof(card->id) - 2)
527 spos++;
528 *spos++ = '_';
529 *spos++ = '1';
530 *spos++ = '\0';
531 idx_flag++;
532 }
533 }
534}
535
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100536#ifndef CONFIG_SYSFS_DEPRECATED
537static ssize_t
538card_id_show_attr(struct device *dev,
539 struct device_attribute *attr, char *buf)
540{
541 struct snd_card *card = dev_get_drvdata(dev);
542 return snprintf(buf, PAGE_SIZE, "%s\n", card ? card->id : "(null)");
543}
544
545static ssize_t
546card_id_store_attr(struct device *dev, struct device_attribute *attr,
547 const char *buf, size_t count)
548{
549 struct snd_card *card = dev_get_drvdata(dev);
550 char buf1[sizeof(card->id)];
551 size_t copy = count > sizeof(card->id) - 1 ?
552 sizeof(card->id) - 1 : count;
553 size_t idx;
554 int c;
555
556 for (idx = 0; idx < copy; idx++) {
557 c = buf[idx];
558 if (!isalnum(c) && c != '_' && c != '-')
559 return -EINVAL;
560 }
561 memcpy(buf1, buf, copy);
562 buf1[copy] = '\0';
563 mutex_lock(&snd_card_mutex);
564 if (!snd_info_check_reserved_words(buf1)) {
565 __exist:
566 mutex_unlock(&snd_card_mutex);
567 return -EEXIST;
568 }
569 for (idx = 0; idx < snd_ecards_limit; idx++) {
570 if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1))
571 goto __exist;
572 }
573 strcpy(card->id, buf1);
Jaroslav Kyselac2eb9c42008-11-12 16:31:37 +0100574 snd_info_card_id_change(card);
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100575 mutex_unlock(&snd_card_mutex);
576
577 return count;
578}
579
580static struct device_attribute card_id_attrs =
581 __ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
582
583static ssize_t
584card_number_show_attr(struct device *dev,
585 struct device_attribute *attr, char *buf)
586{
587 struct snd_card *card = dev_get_drvdata(dev);
588 return snprintf(buf, PAGE_SIZE, "%i\n", card ? card->number : -1);
589}
590
591static struct device_attribute card_number_attrs =
592 __ATTR(number, S_IRUGO, card_number_show_attr, NULL);
593#endif /* CONFIG_SYSFS_DEPRECATED */
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595/**
596 * snd_card_register - register the soundcard
597 * @card: soundcard structure
598 *
599 * This function registers all the devices assigned to the soundcard.
600 * Until calling this, the ALSA control interface is blocked from the
601 * external accesses. Thus, you should call this function at the end
602 * of the initialization of the card.
603 *
604 * Returns zero otherwise a negative error code if the registrain failed.
605 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100606int snd_card_register(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200610 if (snd_BUG_ON(!card))
611 return -EINVAL;
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100612#ifndef CONFIG_SYSFS_DEPRECATED
613 if (!card->card_dev) {
Greg Kroah-Hartmanabe9ab82008-07-21 20:03:34 -0700614 card->card_dev = device_create(sound_class, card->dev,
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100615 MKDEV(0, 0), card,
Greg Kroah-Hartmanabe9ab82008-07-21 20:03:34 -0700616 "card%i", card->number);
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100617 if (IS_ERR(card->card_dev))
618 card->card_dev = NULL;
Greg Kroah-Hartmand80f19f2006-08-07 22:19:37 -0700619 }
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100620#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if ((err = snd_device_register_all(card)) < 0)
622 return err;
Takashi Iwai746df942006-05-15 19:49:05 +0200623 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 if (snd_cards[card->number]) {
625 /* already registered */
Takashi Iwai746df942006-05-15 19:49:05 +0200626 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 return 0;
628 }
629 if (card->id[0] == '\0')
630 choose_default_id(card);
631 snd_cards[card->number] = card;
Takashi Iwai746df942006-05-15 19:49:05 +0200632 mutex_unlock(&snd_card_mutex);
Takashi Iwaie28563c2005-12-01 10:42:42 +0100633 init_info_for_card(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
635 if (snd_mixer_oss_notify_callback)
636 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
637#endif
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100638#ifndef CONFIG_SYSFS_DEPRECATED
639 if (card->card_dev) {
Hannes Eder2af75292008-11-18 12:25:06 -0500640 err = device_create_file(card->card_dev, &card_id_attrs);
641 if (err < 0)
642 return err;
643 err = device_create_file(card->card_dev, &card_number_attrs);
644 if (err < 0)
645 return err;
Jaroslav Kysela9fb61982008-11-11 16:51:02 +0100646 }
647#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 return 0;
649}
650
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200651EXPORT_SYMBOL(snd_card_register);
652
Takashi Iwaie28563c2005-12-01 10:42:42 +0100653#ifdef CONFIG_PROC_FS
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200654static struct snd_info_entry *snd_card_info_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
Takashi Iwaia381a7a2005-11-17 15:55:49 +0100656static void snd_card_info_read(struct snd_info_entry *entry,
657 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658{
659 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100660 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200663 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if ((card = snd_cards[idx]) != NULL) {
665 count++;
Clemens Ladischd0015442005-11-20 14:09:05 +0100666 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 idx,
668 card->id,
669 card->driver,
670 card->shortname);
Clemens Ladischd0015442005-11-20 14:09:05 +0100671 snd_iprintf(buffer, " %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 card->longname);
673 }
Takashi Iwai746df942006-05-15 19:49:05 +0200674 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676 if (!count)
677 snd_iprintf(buffer, "--- no soundcards ---\n");
678}
679
Takashi Iwaie28563c2005-12-01 10:42:42 +0100680#ifdef CONFIG_SND_OSSEMUL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Takashi Iwai512bbd62005-11-17 13:51:18 +0100682void snd_card_info_read_oss(struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
684 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100685 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200688 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if ((card = snd_cards[idx]) != NULL) {
690 count++;
691 snd_iprintf(buffer, "%s\n", card->longname);
692 }
Takashi Iwai746df942006-05-15 19:49:05 +0200693 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
695 if (!count) {
696 snd_iprintf(buffer, "--- no soundcards ---\n");
697 }
698}
699
700#endif
701
702#ifdef MODULE
Takashi Iwai512bbd62005-11-17 13:51:18 +0100703static struct snd_info_entry *snd_card_module_info_entry;
704static void snd_card_module_info_read(struct snd_info_entry *entry,
705 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
707 int idx;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100708 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
710 for (idx = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200711 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if ((card = snd_cards[idx]) != NULL)
Clemens Ladischd0015442005-11-20 14:09:05 +0100713 snd_iprintf(buffer, "%2i %s\n",
714 idx, card->module->name);
Takashi Iwai746df942006-05-15 19:49:05 +0200715 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
717}
718#endif
719
720int __init snd_card_info_init(void)
721{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100722 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200725 if (! entry)
726 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 entry->c.text.read = snd_card_info_read;
728 if (snd_info_register(entry) < 0) {
729 snd_info_free_entry(entry);
730 return -ENOMEM;
731 }
732 snd_card_info_entry = entry;
733
734#ifdef MODULE
735 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
736 if (entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 entry->c.text.read = snd_card_module_info_read;
738 if (snd_info_register(entry) < 0)
739 snd_info_free_entry(entry);
740 else
741 snd_card_module_info_entry = entry;
742 }
743#endif
744
745 return 0;
746}
747
748int __exit snd_card_info_done(void)
749{
Takashi Iwai746d4a02006-06-23 14:37:59 +0200750 snd_info_free_entry(snd_card_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751#ifdef MODULE
Takashi Iwai746d4a02006-06-23 14:37:59 +0200752 snd_info_free_entry(snd_card_module_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753#endif
754 return 0;
755}
756
Takashi Iwaie28563c2005-12-01 10:42:42 +0100757#endif /* CONFIG_PROC_FS */
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759/**
760 * snd_component_add - add a component string
761 * @card: soundcard structure
762 * @component: the component id string
763 *
764 * This function adds the component id string to the supported list.
765 * The component can be referred from the alsa-lib.
766 *
767 * Returns zero otherwise a negative error code.
768 */
769
Takashi Iwai512bbd62005-11-17 13:51:18 +0100770int snd_component_add(struct snd_card *card, const char *component)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771{
772 char *ptr;
773 int len = strlen(component);
774
775 ptr = strstr(card->components, component);
776 if (ptr != NULL) {
777 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
778 return 1;
779 }
780 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
781 snd_BUG();
782 return -ENOMEM;
783 }
784 if (card->components[0] != '\0')
785 strcat(card->components, " ");
786 strcat(card->components, component);
787 return 0;
788}
789
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200790EXPORT_SYMBOL(snd_component_add);
791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792/**
793 * snd_card_file_add - add the file to the file list of the card
794 * @card: soundcard structure
795 * @file: file pointer
796 *
797 * This function adds the file to the file linked-list of the card.
798 * This linked-list is used to keep tracking the connection state,
799 * and to avoid the release of busy resources by hotplug.
800 *
801 * Returns zero or a negative error code.
802 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100803int snd_card_file_add(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805 struct snd_monitor_file *mfile;
806
807 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
808 if (mfile == NULL)
809 return -ENOMEM;
810 mfile->file = file;
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200811 mfile->disconnected_f_op = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 mfile->next = NULL;
813 spin_lock(&card->files_lock);
814 if (card->shutdown) {
815 spin_unlock(&card->files_lock);
816 kfree(mfile);
817 return -ENODEV;
818 }
819 mfile->next = card->files;
820 card->files = mfile;
821 spin_unlock(&card->files_lock);
822 return 0;
823}
824
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200825EXPORT_SYMBOL(snd_card_file_add);
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827/**
828 * snd_card_file_remove - remove the file from the file list
829 * @card: soundcard structure
830 * @file: file pointer
831 *
832 * This function removes the file formerly added to the card via
833 * snd_card_file_add() function.
Takashi Iwai2b29b132006-06-23 14:38:26 +0200834 * If all files are removed and snd_card_free_when_closed() was
835 * called beforehand, it processes the pending release of
836 * resources.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 *
838 * Returns zero or a negative error code.
839 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100840int snd_card_file_remove(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841{
842 struct snd_monitor_file *mfile, *pfile = NULL;
Takashi Iwaic4614822006-06-23 14:38:23 +0200843 int last_close = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845 spin_lock(&card->files_lock);
846 mfile = card->files;
847 while (mfile) {
848 if (mfile->file == file) {
849 if (pfile)
850 pfile->next = mfile->next;
851 else
852 card->files = mfile->next;
853 break;
854 }
855 pfile = mfile;
856 mfile = mfile->next;
857 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200858 if (mfile && mfile->disconnected_f_op) {
859 fops_put(mfile->disconnected_f_op);
860 spin_lock(&shutdown_lock);
861 list_del(&mfile->shutdown_list);
862 spin_unlock(&shutdown_lock);
863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 if (card->files == NULL)
Takashi Iwaic4614822006-06-23 14:38:23 +0200865 last_close = 1;
866 spin_unlock(&card->files_lock);
867 if (last_close) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 wake_up(&card->shutdown_sleep);
Takashi Iwaic4614822006-06-23 14:38:23 +0200869 if (card->free_on_last_close)
870 snd_card_do_free(card);
871 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (!mfile) {
873 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
874 return -ENOENT;
875 }
876 kfree(mfile);
877 return 0;
878}
879
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200880EXPORT_SYMBOL(snd_card_file_remove);
881
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882#ifdef CONFIG_PM
883/**
884 * snd_power_wait - wait until the power-state is changed.
885 * @card: soundcard structure
886 * @power_state: expected power state
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 *
888 * Waits until the power-state is changed.
889 *
890 * Note: the power lock must be active before call.
891 */
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200892int snd_power_wait(struct snd_card *card, unsigned int power_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 wait_queue_t wait;
895 int result = 0;
896
897 /* fastpath */
898 if (snd_power_get_state(card) == power_state)
899 return 0;
900 init_waitqueue_entry(&wait, current);
901 add_wait_queue(&card->power_sleep, &wait);
902 while (1) {
903 if (card->shutdown) {
904 result = -ENODEV;
905 break;
906 }
907 if (snd_power_get_state(card) == power_state)
908 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 set_current_state(TASK_UNINTERRUPTIBLE);
910 snd_power_unlock(card);
911 schedule_timeout(30 * HZ);
912 snd_power_lock(card);
913 }
914 remove_wait_queue(&card->power_sleep, &wait);
915 return result;
916}
917
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200918EXPORT_SYMBOL(snd_power_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919#endif /* CONFIG_PM */