blob: e3338d6071efb993ae9370bf634fdf28ebb27e42 [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
49/* return non-zero if the given index is already reserved for another
50 * module via slots option
51 */
52static int module_slot_mismatch(struct module *module, int idx)
53{
54#ifdef MODULE
55 char *s1, *s2;
56 if (!module || !module->name || !slots[idx])
57 return 0;
58 s1 = slots[idx];
59 s2 = module->name;
60 /* compare module name strings
61 * hyphens are handled as equivalent with underscore
62 */
63 for (;;) {
64 char c1 = *s1++;
65 char c2 = *s2++;
66 if (c1 == '-')
67 c1 = '_';
68 if (c2 == '-')
69 c2 = '_';
70 if (c1 != c2)
71 return 1;
72 if (!c1)
73 break;
74 }
75#endif
76 return 0;
77}
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
Takashi Iwai512bbd62005-11-17 13:51:18 +010080int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
Takashi Iwaic0d3fb32006-04-28 15:13:39 +020081EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#endif
83
Takashi Iwaie28563c2005-12-01 10:42:42 +010084#ifdef CONFIG_PROC_FS
Takashi Iwai512bbd62005-11-17 13:51:18 +010085static void snd_card_id_read(struct snd_info_entry *entry,
86 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
88 snd_iprintf(buffer, "%s\n", entry->card->id);
89}
90
Takashi Iwaie28563c2005-12-01 10:42:42 +010091static inline int init_info_for_card(struct snd_card *card)
92{
93 int err;
94 struct snd_info_entry *entry;
95
96 if ((err = snd_info_card_register(card)) < 0) {
97 snd_printd("unable to create card info\n");
98 return err;
99 }
100 if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
101 snd_printd("unable to create card entry\n");
102 return err;
103 }
Takashi Iwaie28563c2005-12-01 10:42:42 +0100104 entry->c.text.read = snd_card_id_read;
105 if (snd_info_register(entry) < 0) {
106 snd_info_free_entry(entry);
107 entry = NULL;
108 }
109 card->proc_id = entry;
110 return 0;
111}
112#else /* !CONFIG_PROC_FS */
113#define init_info_for_card(card)
114#endif
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116/**
117 * snd_card_new - create and initialize a soundcard structure
118 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
119 * @xid: card identification (ASCII string)
120 * @module: top level module for locking
121 * @extra_size: allocate this extra size after the main soundcard structure
122 *
123 * Creates and initializes a soundcard structure.
124 *
Takashi Iwai512bbd62005-11-17 13:51:18 +0100125 * Returns kmallocated snd_card structure. Creates the ALSA control interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 * (which is blocked until snd_card_register function is called).
127 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100128struct snd_card *snd_card_new(int idx, const char *xid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 struct module *module, int extra_size)
130{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100131 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 int err;
133
134 if (extra_size < 0)
135 extra_size = 0;
Takashi Iwaica2c0962005-09-09 14:20:23 +0200136 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 if (card == NULL)
138 return NULL;
139 if (xid) {
140 if (!snd_info_check_reserved_words(xid))
141 goto __error;
142 strlcpy(card->id, xid, sizeof(card->id));
143 }
144 err = 0;
Takashi Iwai746df942006-05-15 19:49:05 +0200145 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 if (idx < 0) {
147 int idx2;
148 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100149 /* idx == -1 == 0xffff means: take any free slot */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (~snd_cards_lock & idx & 1<<idx2) {
Takashi Iwai304cd072007-10-26 15:10:15 +0200151 if (module_slot_mismatch(module, idx2))
152 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 idx = idx2;
154 if (idx >= snd_ecards_limit)
155 snd_ecards_limit = idx + 1;
156 break;
157 }
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100158 } else {
159 if (idx < snd_ecards_limit) {
160 if (snd_cards_lock & (1 << idx))
161 err = -EBUSY; /* invalid */
162 } else {
163 if (idx < SNDRV_CARDS)
164 snd_ecards_limit = idx + 1; /* increase the limit */
165 else
166 err = -ENODEV;
167 }
168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 if (idx < 0 || err < 0) {
Takashi Iwai746df942006-05-15 19:49:05 +0200170 mutex_unlock(&snd_card_mutex);
Oliver Neukum5c33dd72007-01-16 17:49:21 +0100171 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
172 idx, snd_ecards_limit - 1, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 goto __error;
174 }
175 snd_cards_lock |= 1 << idx; /* lock it */
Takashi Iwai746df942006-05-15 19:49:05 +0200176 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 card->number = idx;
178 card->module = module;
179 INIT_LIST_HEAD(&card->devices);
180 init_rwsem(&card->controls_rwsem);
181 rwlock_init(&card->ctl_files_rwlock);
182 INIT_LIST_HEAD(&card->controls);
183 INIT_LIST_HEAD(&card->ctl_files);
184 spin_lock_init(&card->files_lock);
185 init_waitqueue_head(&card->shutdown_sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186#ifdef CONFIG_PM
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100187 mutex_init(&card->power_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 init_waitqueue_head(&card->power_sleep);
189#endif
190 /* the control interface cannot be accessed from the user space until */
191 /* snd_cards_bitmask and snd_cards are set with snd_card_register */
192 if ((err = snd_ctl_create(card)) < 0) {
193 snd_printd("unable to register control minors\n");
194 goto __error;
195 }
196 if ((err = snd_info_card_create(card)) < 0) {
197 snd_printd("unable to create card info\n");
198 goto __error_ctl;
199 }
200 if (extra_size > 0)
Takashi Iwai512bbd62005-11-17 13:51:18 +0100201 card->private_data = (char *)card + sizeof(struct snd_card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return card;
203
204 __error_ctl:
205 snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
206 __error:
207 kfree(card);
208 return NULL;
209}
210
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200211EXPORT_SYMBOL(snd_card_new);
212
Takashi Iwai746df942006-05-15 19:49:05 +0200213/* return non-zero if a card is already locked */
214int snd_card_locked(int card)
215{
216 int locked;
217
218 mutex_lock(&snd_card_mutex);
219 locked = snd_cards_lock & (1 << card);
220 mutex_unlock(&snd_card_mutex);
221 return locked;
222}
223
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100224static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
225{
226 return -ENODEV;
227}
228
229static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
230 size_t count, loff_t *offset)
231{
232 return -ENODEV;
233}
234
235static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
236 size_t count, loff_t *offset)
237{
238 return -ENODEV;
239}
240
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200241static int snd_disconnect_release(struct inode *inode, struct file *file)
242{
243 struct snd_monitor_file *df = NULL, *_df;
244
245 spin_lock(&shutdown_lock);
246 list_for_each_entry(_df, &shutdown_files, shutdown_list) {
247 if (_df->file == file) {
248 df = _df;
249 break;
250 }
251 }
252 spin_unlock(&shutdown_lock);
253
254 if (likely(df))
255 return df->disconnected_f_op->release(inode, file);
256
257 panic("%s(%p, %p) failed!", __FUNCTION__, inode, file);
258}
259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
261{
262 return POLLERR | POLLNVAL;
263}
264
Clemens Ladischb3b0abe2006-03-03 14:08:43 +0100265static long snd_disconnect_ioctl(struct file *file,
266 unsigned int cmd, unsigned long arg)
267{
268 return -ENODEV;
269}
270
271static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
272{
273 return -ENODEV;
274}
275
276static int snd_disconnect_fasync(int fd, struct file *file, int on)
277{
278 return -ENODEV;
279}
280
Arjan van de Ven9c2e08c2007-02-12 00:55:37 -0800281static const struct file_operations snd_shutdown_f_ops =
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200282{
283 .owner = THIS_MODULE,
284 .llseek = snd_disconnect_llseek,
285 .read = snd_disconnect_read,
286 .write = snd_disconnect_write,
287 .release = snd_disconnect_release,
288 .poll = snd_disconnect_poll,
289 .unlocked_ioctl = snd_disconnect_ioctl,
290#ifdef CONFIG_COMPAT
291 .compat_ioctl = snd_disconnect_ioctl,
292#endif
293 .mmap = snd_disconnect_mmap,
294 .fasync = snd_disconnect_fasync
295};
296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297/**
298 * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
299 * @card: soundcard structure
300 *
301 * Disconnects all APIs from the file-operations (user space).
302 *
303 * Returns zero, otherwise a negative error code.
304 *
305 * Note: The current implementation replaces all active file->f_op with special
306 * dummy file operations (they do nothing except release).
307 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100308int snd_card_disconnect(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
310 struct snd_monitor_file *mfile;
311 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 int err;
313
314 spin_lock(&card->files_lock);
315 if (card->shutdown) {
316 spin_unlock(&card->files_lock);
317 return 0;
318 }
319 card->shutdown = 1;
320 spin_unlock(&card->files_lock);
321
322 /* phase 1: disable fops (user space) operations for ALSA API */
Takashi Iwai746df942006-05-15 19:49:05 +0200323 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 snd_cards[card->number] = NULL;
Takashi Iwai746df942006-05-15 19:49:05 +0200325 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 /* phase 2: replace file->f_op with special dummy operations */
328
329 spin_lock(&card->files_lock);
330 mfile = card->files;
331 while (mfile) {
332 file = mfile->file;
333
334 /* it's critical part, use endless loop */
335 /* we have no room to fail */
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200336 mfile->disconnected_f_op = mfile->file->f_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200338 spin_lock(&shutdown_lock);
339 list_add(&mfile->shutdown_list, &shutdown_files);
340 spin_unlock(&shutdown_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200342 mfile->file->f_op = &snd_shutdown_f_ops;
Miguel Botonbc9abce2008-01-13 12:03:53 +0100343 fops_get(mfile->file->f_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 mfile = mfile->next;
346 }
347 spin_unlock(&card->files_lock);
348
349 /* phase 3: notify all connected devices about disconnection */
350 /* at this point, they cannot respond to any calls except release() */
351
352#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
353 if (snd_mixer_oss_notify_callback)
354 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
355#endif
356
357 /* notify all devices that we are disconnected */
358 err = snd_device_disconnect_all(card);
359 if (err < 0)
360 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
361
Takashi Iwai746d4a02006-06-23 14:37:59 +0200362 snd_info_card_disconnect(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return 0;
364}
365
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200366EXPORT_SYMBOL(snd_card_disconnect);
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368/**
369 * snd_card_free - frees given soundcard structure
370 * @card: soundcard structure
371 *
372 * This function releases the soundcard structure and the all assigned
373 * devices automatically. That is, you don't have to release the devices
374 * by yourself.
375 *
376 * Returns zero. Frees all associated devices and frees the control
377 * interface associated to given soundcard.
378 */
Takashi Iwaic4614822006-06-23 14:38:23 +0200379static int snd_card_do_free(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
382 if (snd_mixer_oss_notify_callback)
383 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
384#endif
385 if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
386 snd_printk(KERN_ERR "unable to free all devices (pre)\n");
387 /* Fatal, but this situation should never occur */
388 }
389 if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
390 snd_printk(KERN_ERR "unable to free all devices (normal)\n");
391 /* Fatal, but this situation should never occur */
392 }
393 if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
394 snd_printk(KERN_ERR "unable to free all devices (post)\n");
395 /* Fatal, but this situation should never occur */
396 }
397 if (card->private_free)
398 card->private_free(card);
Takashi Iwai746d4a02006-06-23 14:37:59 +0200399 snd_info_free_entry(card->proc_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (snd_info_card_free(card) < 0) {
401 snd_printk(KERN_WARNING "unable to free card info\n");
402 /* Not fatal error */
403 }
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100404#ifndef CONFIG_SYSFS_DEPRECATED
405 if (card->card_dev)
406 device_unregister(card->card_dev);
407#endif
Takashi Iwaic4614822006-06-23 14:38:23 +0200408 kfree(card);
409 return 0;
410}
411
412static int snd_card_free_prepare(struct snd_card *card)
413{
414 if (card == NULL)
415 return -EINVAL;
416 (void) snd_card_disconnect(card);
Takashi Iwai746df942006-05-15 19:49:05 +0200417 mutex_lock(&snd_card_mutex);
Takashi Iwaic4614822006-06-23 14:38:23 +0200418 snd_cards[card->number] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 snd_cards_lock &= ~(1 << card->number);
Takashi Iwai746df942006-05-15 19:49:05 +0200420 mutex_unlock(&snd_card_mutex);
Takashi Iwaic4614822006-06-23 14:38:23 +0200421#ifdef CONFIG_PM
422 wake_up(&card->power_sleep);
423#endif
424 return 0;
425}
426
427int snd_card_free_when_closed(struct snd_card *card)
428{
429 int free_now = 0;
430 int ret = snd_card_free_prepare(card);
431 if (ret)
432 return ret;
433
434 spin_lock(&card->files_lock);
435 if (card->files == NULL)
436 free_now = 1;
437 else
438 card->free_on_last_close = 1;
439 spin_unlock(&card->files_lock);
440
441 if (free_now)
442 snd_card_do_free(card);
443 return 0;
444}
445
446EXPORT_SYMBOL(snd_card_free_when_closed);
447
448int snd_card_free(struct snd_card *card)
449{
450 int ret = snd_card_free_prepare(card);
451 if (ret)
452 return ret;
453
454 /* wait, until all devices are ready for the free operation */
455 wait_event(card->shutdown_sleep, card->files == NULL);
456 snd_card_do_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return 0;
458}
459
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200460EXPORT_SYMBOL(snd_card_free);
461
Takashi Iwai512bbd62005-11-17 13:51:18 +0100462static void choose_default_id(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
Clemens Ladischd0015442005-11-20 14:09:05 +0100464 int i, len, idx_flag = 0, loops = SNDRV_CARDS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 char *id, *spos;
466
467 id = spos = card->shortname;
468 while (*id != '\0') {
469 if (*id == ' ')
470 spos = id + 1;
471 id++;
472 }
473 id = card->id;
474 while (*spos != '\0' && !isalnum(*spos))
475 spos++;
476 if (isdigit(*spos))
477 *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
478 while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
479 if (isalnum(*spos))
480 *id++ = *spos;
481 spos++;
482 }
483 *id = '\0';
484
485 id = card->id;
486
487 if (*id == '\0')
488 strcpy(id, "default");
489
490 while (1) {
491 if (loops-- == 0) {
492 snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
493 strcpy(card->id, card->proc_root->name);
494 return;
495 }
496 if (!snd_info_check_reserved_words(id))
497 goto __change;
498 for (i = 0; i < snd_ecards_limit; i++) {
499 if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
500 goto __change;
501 }
502 break;
503
504 __change:
505 len = strlen(id);
Clemens Ladischd0015442005-11-20 14:09:05 +0100506 if (idx_flag) {
507 if (id[len-1] != '9')
508 id[len-1]++;
509 else
510 id[len-1] = 'A';
511 } else if ((size_t)len <= sizeof(card->id) - 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 strcat(id, "_1");
513 idx_flag++;
514 } else {
515 spos = id + len - 2;
516 if ((size_t)len <= sizeof(card->id) - 2)
517 spos++;
518 *spos++ = '_';
519 *spos++ = '1';
520 *spos++ = '\0';
521 idx_flag++;
522 }
523 }
524}
525
526/**
527 * snd_card_register - register the soundcard
528 * @card: soundcard structure
529 *
530 * This function registers all the devices assigned to the soundcard.
531 * Until calling this, the ALSA control interface is blocked from the
532 * external accesses. Thus, you should call this function at the end
533 * of the initialization of the card.
534 *
535 * Returns zero otherwise a negative error code if the registrain failed.
536 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100537int snd_card_register(struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
539 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200541 snd_assert(card != NULL, return -EINVAL);
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100542#ifndef CONFIG_SYSFS_DEPRECATED
543 if (!card->card_dev) {
544 card->card_dev = device_create(sound_class, card->dev, 0,
545 "card%i", card->number);
546 if (IS_ERR(card->card_dev))
547 card->card_dev = NULL;
Greg Kroah-Hartmand80f19f2006-08-07 22:19:37 -0700548 }
Takashi Iwai7d2aae12007-01-26 12:40:31 +0100549#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if ((err = snd_device_register_all(card)) < 0)
551 return err;
Takashi Iwai746df942006-05-15 19:49:05 +0200552 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 if (snd_cards[card->number]) {
554 /* already registered */
Takashi Iwai746df942006-05-15 19:49:05 +0200555 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 return 0;
557 }
558 if (card->id[0] == '\0')
559 choose_default_id(card);
560 snd_cards[card->number] = card;
Takashi Iwai746df942006-05-15 19:49:05 +0200561 mutex_unlock(&snd_card_mutex);
Takashi Iwaie28563c2005-12-01 10:42:42 +0100562 init_info_for_card(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
564 if (snd_mixer_oss_notify_callback)
565 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
566#endif
567 return 0;
568}
569
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200570EXPORT_SYMBOL(snd_card_register);
571
Takashi Iwaie28563c2005-12-01 10:42:42 +0100572#ifdef CONFIG_PROC_FS
Takashi Iwai6581f4e2006-05-17 17:14:51 +0200573static struct snd_info_entry *snd_card_info_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Takashi Iwaia381a7a2005-11-17 15:55:49 +0100575static void snd_card_info_read(struct snd_info_entry *entry,
576 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
578 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100579 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200582 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if ((card = snd_cards[idx]) != NULL) {
584 count++;
Clemens Ladischd0015442005-11-20 14:09:05 +0100585 snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 idx,
587 card->id,
588 card->driver,
589 card->shortname);
Clemens Ladischd0015442005-11-20 14:09:05 +0100590 snd_iprintf(buffer, " %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 card->longname);
592 }
Takashi Iwai746df942006-05-15 19:49:05 +0200593 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 }
595 if (!count)
596 snd_iprintf(buffer, "--- no soundcards ---\n");
597}
598
Takashi Iwaie28563c2005-12-01 10:42:42 +0100599#ifdef CONFIG_SND_OSSEMUL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Takashi Iwai512bbd62005-11-17 13:51:18 +0100601void snd_card_info_read_oss(struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 int idx, count;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100604 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200607 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if ((card = snd_cards[idx]) != NULL) {
609 count++;
610 snd_iprintf(buffer, "%s\n", card->longname);
611 }
Takashi Iwai746df942006-05-15 19:49:05 +0200612 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
614 if (!count) {
615 snd_iprintf(buffer, "--- no soundcards ---\n");
616 }
617}
618
619#endif
620
621#ifdef MODULE
Takashi Iwai512bbd62005-11-17 13:51:18 +0100622static struct snd_info_entry *snd_card_module_info_entry;
623static void snd_card_module_info_read(struct snd_info_entry *entry,
624 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 int idx;
Takashi Iwai512bbd62005-11-17 13:51:18 +0100627 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 for (idx = 0; idx < SNDRV_CARDS; idx++) {
Takashi Iwai746df942006-05-15 19:49:05 +0200630 mutex_lock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if ((card = snd_cards[idx]) != NULL)
Clemens Ladischd0015442005-11-20 14:09:05 +0100632 snd_iprintf(buffer, "%2i %s\n",
633 idx, card->module->name);
Takashi Iwai746df942006-05-15 19:49:05 +0200634 mutex_unlock(&snd_card_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636}
637#endif
638
639int __init snd_card_info_init(void)
640{
Takashi Iwai512bbd62005-11-17 13:51:18 +0100641 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200644 if (! entry)
645 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 entry->c.text.read = snd_card_info_read;
647 if (snd_info_register(entry) < 0) {
648 snd_info_free_entry(entry);
649 return -ENOMEM;
650 }
651 snd_card_info_entry = entry;
652
653#ifdef MODULE
654 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
655 if (entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 entry->c.text.read = snd_card_module_info_read;
657 if (snd_info_register(entry) < 0)
658 snd_info_free_entry(entry);
659 else
660 snd_card_module_info_entry = entry;
661 }
662#endif
663
664 return 0;
665}
666
667int __exit snd_card_info_done(void)
668{
Takashi Iwai746d4a02006-06-23 14:37:59 +0200669 snd_info_free_entry(snd_card_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670#ifdef MODULE
Takashi Iwai746d4a02006-06-23 14:37:59 +0200671 snd_info_free_entry(snd_card_module_info_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672#endif
673 return 0;
674}
675
Takashi Iwaie28563c2005-12-01 10:42:42 +0100676#endif /* CONFIG_PROC_FS */
677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678/**
679 * snd_component_add - add a component string
680 * @card: soundcard structure
681 * @component: the component id string
682 *
683 * This function adds the component id string to the supported list.
684 * The component can be referred from the alsa-lib.
685 *
686 * Returns zero otherwise a negative error code.
687 */
688
Takashi Iwai512bbd62005-11-17 13:51:18 +0100689int snd_component_add(struct snd_card *card, const char *component)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
691 char *ptr;
692 int len = strlen(component);
693
694 ptr = strstr(card->components, component);
695 if (ptr != NULL) {
696 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
697 return 1;
698 }
699 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
700 snd_BUG();
701 return -ENOMEM;
702 }
703 if (card->components[0] != '\0')
704 strcat(card->components, " ");
705 strcat(card->components, component);
706 return 0;
707}
708
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200709EXPORT_SYMBOL(snd_component_add);
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711/**
712 * snd_card_file_add - add the file to the file list of the card
713 * @card: soundcard structure
714 * @file: file pointer
715 *
716 * This function adds the file to the file linked-list of the card.
717 * This linked-list is used to keep tracking the connection state,
718 * and to avoid the release of busy resources by hotplug.
719 *
720 * Returns zero or a negative error code.
721 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100722int snd_card_file_add(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
724 struct snd_monitor_file *mfile;
725
726 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
727 if (mfile == NULL)
728 return -ENOMEM;
729 mfile->file = file;
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200730 mfile->disconnected_f_op = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 mfile->next = NULL;
732 spin_lock(&card->files_lock);
733 if (card->shutdown) {
734 spin_unlock(&card->files_lock);
735 kfree(mfile);
736 return -ENODEV;
737 }
738 mfile->next = card->files;
739 card->files = mfile;
740 spin_unlock(&card->files_lock);
741 return 0;
742}
743
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200744EXPORT_SYMBOL(snd_card_file_add);
745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746/**
747 * snd_card_file_remove - remove the file from the file list
748 * @card: soundcard structure
749 * @file: file pointer
750 *
751 * This function removes the file formerly added to the card via
752 * snd_card_file_add() function.
Takashi Iwai2b29b132006-06-23 14:38:26 +0200753 * If all files are removed and snd_card_free_when_closed() was
754 * called beforehand, it processes the pending release of
755 * resources.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 *
757 * Returns zero or a negative error code.
758 */
Takashi Iwai512bbd62005-11-17 13:51:18 +0100759int snd_card_file_remove(struct snd_card *card, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
761 struct snd_monitor_file *mfile, *pfile = NULL;
Takashi Iwaic4614822006-06-23 14:38:23 +0200762 int last_close = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
764 spin_lock(&card->files_lock);
765 mfile = card->files;
766 while (mfile) {
767 if (mfile->file == file) {
768 if (pfile)
769 pfile->next = mfile->next;
770 else
771 card->files = mfile->next;
772 break;
773 }
774 pfile = mfile;
775 mfile = mfile->next;
776 }
Karsten Wiesea9edfc62006-10-06 16:08:27 +0200777 if (mfile && mfile->disconnected_f_op) {
778 fops_put(mfile->disconnected_f_op);
779 spin_lock(&shutdown_lock);
780 list_del(&mfile->shutdown_list);
781 spin_unlock(&shutdown_lock);
782 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 if (card->files == NULL)
Takashi Iwaic4614822006-06-23 14:38:23 +0200784 last_close = 1;
785 spin_unlock(&card->files_lock);
786 if (last_close) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 wake_up(&card->shutdown_sleep);
Takashi Iwaic4614822006-06-23 14:38:23 +0200788 if (card->free_on_last_close)
789 snd_card_do_free(card);
790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 if (!mfile) {
792 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
793 return -ENOENT;
794 }
795 kfree(mfile);
796 return 0;
797}
798
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200799EXPORT_SYMBOL(snd_card_file_remove);
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801#ifdef CONFIG_PM
802/**
803 * snd_power_wait - wait until the power-state is changed.
804 * @card: soundcard structure
805 * @power_state: expected power state
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 *
807 * Waits until the power-state is changed.
808 *
809 * Note: the power lock must be active before call.
810 */
Takashi Iwaicbac4b02006-03-27 12:38:07 +0200811int snd_power_wait(struct snd_card *card, unsigned int power_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 wait_queue_t wait;
814 int result = 0;
815
816 /* fastpath */
817 if (snd_power_get_state(card) == power_state)
818 return 0;
819 init_waitqueue_entry(&wait, current);
820 add_wait_queue(&card->power_sleep, &wait);
821 while (1) {
822 if (card->shutdown) {
823 result = -ENODEV;
824 break;
825 }
826 if (snd_power_get_state(card) == power_state)
827 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 set_current_state(TASK_UNINTERRUPTIBLE);
829 snd_power_unlock(card);
830 schedule_timeout(30 * HZ);
831 snd_power_lock(card);
832 }
833 remove_wait_queue(&card->power_sleep, &wait);
834 return result;
835}
836
Takashi Iwaic0d3fb32006-04-28 15:13:39 +0200837EXPORT_SYMBOL(snd_power_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838#endif /* CONFIG_PM */