blob: 41e224986f35e7306e5a8fda52bdf91a0860c81c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Initialization routines
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
4 *
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
22#include <sound/driver.h>
23#include <linux/init.h>
24#include <linux/sched.h>
25#include <linux/file.h>
26#include <linux/slab.h>
27#include <linux/time.h>
28#include <linux/ctype.h>
29#include <linux/pci.h>
30#include <linux/pm.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010031#include <linux/platform_device.h>
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <sound/core.h>
34#include <sound/control.h>
35#include <sound/info.h>
36
37struct snd_shutdown_f_ops {
38 struct file_operations f_ops;
39 struct snd_shutdown_f_ops *next;
40};
41
42unsigned int snd_cards_lock = 0; /* locked for registering/using */
43snd_card_t *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL};
44DEFINE_RWLOCK(snd_card_rwlock);
45
46#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
47int (*snd_mixer_oss_notify_callback)(snd_card_t *card, int free_flag);
48#endif
49
50static void snd_card_id_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
51{
52 snd_iprintf(buffer, "%s\n", entry->card->id);
53}
54
55static void snd_card_free_thread(void * __card);
56
57/**
58 * snd_card_new - create and initialize a soundcard structure
59 * @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
60 * @xid: card identification (ASCII string)
61 * @module: top level module for locking
62 * @extra_size: allocate this extra size after the main soundcard structure
63 *
64 * Creates and initializes a soundcard structure.
65 *
66 * Returns kmallocated snd_card_t structure. Creates the ALSA control interface
67 * (which is blocked until snd_card_register function is called).
68 */
69snd_card_t *snd_card_new(int idx, const char *xid,
70 struct module *module, int extra_size)
71{
72 snd_card_t *card;
73 int err;
74
75 if (extra_size < 0)
76 extra_size = 0;
Takashi Iwaica2c0962005-09-09 14:20:23 +020077 card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 if (card == NULL)
79 return NULL;
80 if (xid) {
81 if (!snd_info_check_reserved_words(xid))
82 goto __error;
83 strlcpy(card->id, xid, sizeof(card->id));
84 }
85 err = 0;
86 write_lock(&snd_card_rwlock);
87 if (idx < 0) {
88 int idx2;
89 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
90 if (~snd_cards_lock & idx & 1<<idx2) {
91 idx = idx2;
92 if (idx >= snd_ecards_limit)
93 snd_ecards_limit = idx + 1;
94 break;
95 }
96 } else if (idx < snd_ecards_limit) {
97 if (snd_cards_lock & (1 << idx))
98 err = -ENODEV; /* invalid */
99 } else if (idx < SNDRV_CARDS)
100 snd_ecards_limit = idx + 1; /* increase the limit */
101 else
102 err = -ENODEV;
103 if (idx < 0 || err < 0) {
104 write_unlock(&snd_card_rwlock);
105 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i)\n", idx, snd_ecards_limit - 1);
106 goto __error;
107 }
108 snd_cards_lock |= 1 << idx; /* lock it */
109 write_unlock(&snd_card_rwlock);
110 card->number = idx;
111 card->module = module;
112 INIT_LIST_HEAD(&card->devices);
113 init_rwsem(&card->controls_rwsem);
114 rwlock_init(&card->ctl_files_rwlock);
115 INIT_LIST_HEAD(&card->controls);
116 INIT_LIST_HEAD(&card->ctl_files);
117 spin_lock_init(&card->files_lock);
118 init_waitqueue_head(&card->shutdown_sleep);
119 INIT_WORK(&card->free_workq, snd_card_free_thread, card);
120#ifdef CONFIG_PM
121 init_MUTEX(&card->power_lock);
122 init_waitqueue_head(&card->power_sleep);
123#endif
124 /* the control interface cannot be accessed from the user space until */
125 /* snd_cards_bitmask and snd_cards are set with snd_card_register */
126 if ((err = snd_ctl_create(card)) < 0) {
127 snd_printd("unable to register control minors\n");
128 goto __error;
129 }
130 if ((err = snd_info_card_create(card)) < 0) {
131 snd_printd("unable to create card info\n");
132 goto __error_ctl;
133 }
134 if (extra_size > 0)
135 card->private_data = (char *)card + sizeof(snd_card_t);
136 return card;
137
138 __error_ctl:
139 snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
140 __error:
141 kfree(card);
142 return NULL;
143}
144
145static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
146{
147 return POLLERR | POLLNVAL;
148}
149
150/**
151 * snd_card_disconnect - disconnect all APIs from the file-operations (user space)
152 * @card: soundcard structure
153 *
154 * Disconnects all APIs from the file-operations (user space).
155 *
156 * Returns zero, otherwise a negative error code.
157 *
158 * Note: The current implementation replaces all active file->f_op with special
159 * dummy file operations (they do nothing except release).
160 */
161int snd_card_disconnect(snd_card_t * card)
162{
163 struct snd_monitor_file *mfile;
164 struct file *file;
165 struct snd_shutdown_f_ops *s_f_ops;
166 struct file_operations *f_ops, *old_f_ops;
167 int err;
168
169 spin_lock(&card->files_lock);
170 if (card->shutdown) {
171 spin_unlock(&card->files_lock);
172 return 0;
173 }
174 card->shutdown = 1;
175 spin_unlock(&card->files_lock);
176
177 /* phase 1: disable fops (user space) operations for ALSA API */
178 write_lock(&snd_card_rwlock);
179 snd_cards[card->number] = NULL;
180 write_unlock(&snd_card_rwlock);
181
182 /* phase 2: replace file->f_op with special dummy operations */
183
184 spin_lock(&card->files_lock);
185 mfile = card->files;
186 while (mfile) {
187 file = mfile->file;
188
189 /* it's critical part, use endless loop */
190 /* we have no room to fail */
191 s_f_ops = kmalloc(sizeof(struct snd_shutdown_f_ops), GFP_ATOMIC);
192 if (s_f_ops == NULL)
193 panic("Atomic allocation failed for snd_shutdown_f_ops!");
194
195 f_ops = &s_f_ops->f_ops;
196
197 memset(f_ops, 0, sizeof(*f_ops));
198 f_ops->owner = file->f_op->owner;
199 f_ops->release = file->f_op->release;
200 f_ops->poll = snd_disconnect_poll;
201
202 s_f_ops->next = card->s_f_ops;
203 card->s_f_ops = s_f_ops;
204
205 f_ops = fops_get(f_ops);
206
207 old_f_ops = file->f_op;
208 file->f_op = f_ops; /* must be atomic */
209 fops_put(old_f_ops);
210
211 mfile = mfile->next;
212 }
213 spin_unlock(&card->files_lock);
214
215 /* phase 3: notify all connected devices about disconnection */
216 /* at this point, they cannot respond to any calls except release() */
217
218#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
219 if (snd_mixer_oss_notify_callback)
220 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
221#endif
222
223 /* notify all devices that we are disconnected */
224 err = snd_device_disconnect_all(card);
225 if (err < 0)
226 snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);
227
228 return 0;
229}
230
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200231#ifdef CONFIG_SND_GENERIC_DRIVER
232static void snd_generic_device_unregister(snd_card_t *card);
233#else
234#define snd_generic_device_unregister(x) /*NOP*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235#endif
236
237/**
238 * snd_card_free - frees given soundcard structure
239 * @card: soundcard structure
240 *
241 * This function releases the soundcard structure and the all assigned
242 * devices automatically. That is, you don't have to release the devices
243 * by yourself.
244 *
245 * Returns zero. Frees all associated devices and frees the control
246 * interface associated to given soundcard.
247 */
248int snd_card_free(snd_card_t * card)
249{
250 struct snd_shutdown_f_ops *s_f_ops;
251
252 if (card == NULL)
253 return -EINVAL;
254 write_lock(&snd_card_rwlock);
255 snd_cards[card->number] = NULL;
256 write_unlock(&snd_card_rwlock);
257
258#ifdef CONFIG_PM
259 wake_up(&card->power_sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 /* wait, until all devices are ready for the free operation */
262 wait_event(card->shutdown_sleep, card->files == NULL);
263
264#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
265 if (snd_mixer_oss_notify_callback)
266 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
267#endif
268 if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
269 snd_printk(KERN_ERR "unable to free all devices (pre)\n");
270 /* Fatal, but this situation should never occur */
271 }
272 if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
273 snd_printk(KERN_ERR "unable to free all devices (normal)\n");
274 /* Fatal, but this situation should never occur */
275 }
276 if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
277 snd_printk(KERN_ERR "unable to free all devices (post)\n");
278 /* Fatal, but this situation should never occur */
279 }
280 if (card->private_free)
281 card->private_free(card);
282 if (card->proc_id)
283 snd_info_unregister(card->proc_id);
284 if (snd_info_card_free(card) < 0) {
285 snd_printk(KERN_WARNING "unable to free card info\n");
286 /* Not fatal error */
287 }
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200288 snd_generic_device_unregister(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 while (card->s_f_ops) {
290 s_f_ops = card->s_f_ops;
291 card->s_f_ops = s_f_ops->next;
292 kfree(s_f_ops);
293 }
294 write_lock(&snd_card_rwlock);
295 snd_cards_lock &= ~(1 << card->number);
296 write_unlock(&snd_card_rwlock);
297 kfree(card);
298 return 0;
299}
300
301static void snd_card_free_thread(void * __card)
302{
303 snd_card_t *card = __card;
304 struct module * module = card->module;
305
306 if (!try_module_get(module)) {
307 snd_printk(KERN_ERR "unable to lock toplevel module for card %i in free thread\n", card->number);
308 module = NULL;
309 }
310
311 snd_card_free(card);
312
313 module_put(module);
314}
315
316/**
317 * snd_card_free_in_thread - call snd_card_free() in thread
318 * @card: soundcard structure
319 *
320 * This function schedules the call of snd_card_free() function in a
321 * work queue. When all devices are released (non-busy), the work
322 * is woken up and calls snd_card_free().
323 *
324 * When a card can be disconnected at any time by hotplug service,
325 * this function should be used in disconnect (or detach) callback
326 * instead of calling snd_card_free() directly.
327 *
328 * Returns - zero otherwise a negative error code if the start of thread failed.
329 */
330int snd_card_free_in_thread(snd_card_t * card)
331{
332 if (card->files == NULL) {
333 snd_card_free(card);
334 return 0;
335 }
336
337 if (schedule_work(&card->free_workq))
338 return 0;
339
340 snd_printk(KERN_ERR "schedule_work() failed in snd_card_free_in_thread for card %i\n", card->number);
341 /* try to free the structure immediately */
342 snd_card_free(card);
343 return -EFAULT;
344}
345
346static void choose_default_id(snd_card_t * card)
347{
348 int i, len, idx_flag = 0, loops = 8;
349 char *id, *spos;
350
351 id = spos = card->shortname;
352 while (*id != '\0') {
353 if (*id == ' ')
354 spos = id + 1;
355 id++;
356 }
357 id = card->id;
358 while (*spos != '\0' && !isalnum(*spos))
359 spos++;
360 if (isdigit(*spos))
361 *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
362 while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
363 if (isalnum(*spos))
364 *id++ = *spos;
365 spos++;
366 }
367 *id = '\0';
368
369 id = card->id;
370
371 if (*id == '\0')
372 strcpy(id, "default");
373
374 while (1) {
375 if (loops-- == 0) {
376 snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
377 strcpy(card->id, card->proc_root->name);
378 return;
379 }
380 if (!snd_info_check_reserved_words(id))
381 goto __change;
382 for (i = 0; i < snd_ecards_limit; i++) {
383 if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
384 goto __change;
385 }
386 break;
387
388 __change:
389 len = strlen(id);
390 if (idx_flag)
391 id[len-1]++;
392 else if ((size_t)len <= sizeof(card->id) - 3) {
393 strcat(id, "_1");
394 idx_flag++;
395 } else {
396 spos = id + len - 2;
397 if ((size_t)len <= sizeof(card->id) - 2)
398 spos++;
399 *spos++ = '_';
400 *spos++ = '1';
401 *spos++ = '\0';
402 idx_flag++;
403 }
404 }
405}
406
407/**
408 * snd_card_register - register the soundcard
409 * @card: soundcard structure
410 *
411 * This function registers all the devices assigned to the soundcard.
412 * Until calling this, the ALSA control interface is blocked from the
413 * external accesses. Thus, you should call this function at the end
414 * of the initialization of the card.
415 *
416 * Returns zero otherwise a negative error code if the registrain failed.
417 */
418int snd_card_register(snd_card_t * card)
419{
420 int err;
421 snd_info_entry_t *entry;
422
423 snd_runtime_check(card != NULL, return -EINVAL);
424 if ((err = snd_device_register_all(card)) < 0)
425 return err;
426 write_lock(&snd_card_rwlock);
427 if (snd_cards[card->number]) {
428 /* already registered */
429 write_unlock(&snd_card_rwlock);
430 return 0;
431 }
432 if (card->id[0] == '\0')
433 choose_default_id(card);
434 snd_cards[card->number] = card;
435 write_unlock(&snd_card_rwlock);
436 if ((err = snd_info_card_register(card)) < 0) {
437 snd_printd("unable to create card info\n");
438 goto __skip_info;
439 }
440 if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
441 snd_printd("unable to create card entry\n");
442 goto __skip_info;
443 }
444 entry->c.text.read_size = PAGE_SIZE;
445 entry->c.text.read = snd_card_id_read;
446 if (snd_info_register(entry) < 0) {
447 snd_info_free_entry(entry);
448 entry = NULL;
449 }
450 card->proc_id = entry;
451 __skip_info:
452#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
453 if (snd_mixer_oss_notify_callback)
454 snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
455#endif
456 return 0;
457}
458
459static snd_info_entry_t *snd_card_info_entry = NULL;
460
461static void snd_card_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
462{
463 int idx, count;
464 snd_card_t *card;
465
466 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
467 read_lock(&snd_card_rwlock);
468 if ((card = snd_cards[idx]) != NULL) {
469 count++;
470 snd_iprintf(buffer, "%i [%-15s]: %s - %s\n",
471 idx,
472 card->id,
473 card->driver,
474 card->shortname);
475 snd_iprintf(buffer, " %s\n",
476 card->longname);
477 }
478 read_unlock(&snd_card_rwlock);
479 }
480 if (!count)
481 snd_iprintf(buffer, "--- no soundcards ---\n");
482}
483
484#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
485
486void snd_card_info_read_oss(snd_info_buffer_t * buffer)
487{
488 int idx, count;
489 snd_card_t *card;
490
491 for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
492 read_lock(&snd_card_rwlock);
493 if ((card = snd_cards[idx]) != NULL) {
494 count++;
495 snd_iprintf(buffer, "%s\n", card->longname);
496 }
497 read_unlock(&snd_card_rwlock);
498 }
499 if (!count) {
500 snd_iprintf(buffer, "--- no soundcards ---\n");
501 }
502}
503
504#endif
505
506#ifdef MODULE
507static snd_info_entry_t *snd_card_module_info_entry;
508static void snd_card_module_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
509{
510 int idx;
511 snd_card_t *card;
512
513 for (idx = 0; idx < SNDRV_CARDS; idx++) {
514 read_lock(&snd_card_rwlock);
515 if ((card = snd_cards[idx]) != NULL)
516 snd_iprintf(buffer, "%i %s\n", idx, card->module->name);
517 read_unlock(&snd_card_rwlock);
518 }
519}
520#endif
521
522int __init snd_card_info_init(void)
523{
524 snd_info_entry_t *entry;
525
526 entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
527 snd_runtime_check(entry != NULL, return -ENOMEM);
528 entry->c.text.read_size = PAGE_SIZE;
529 entry->c.text.read = snd_card_info_read;
530 if (snd_info_register(entry) < 0) {
531 snd_info_free_entry(entry);
532 return -ENOMEM;
533 }
534 snd_card_info_entry = entry;
535
536#ifdef MODULE
537 entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
538 if (entry) {
539 entry->c.text.read_size = PAGE_SIZE;
540 entry->c.text.read = snd_card_module_info_read;
541 if (snd_info_register(entry) < 0)
542 snd_info_free_entry(entry);
543 else
544 snd_card_module_info_entry = entry;
545 }
546#endif
547
548 return 0;
549}
550
551int __exit snd_card_info_done(void)
552{
553 if (snd_card_info_entry)
554 snd_info_unregister(snd_card_info_entry);
555#ifdef MODULE
556 if (snd_card_module_info_entry)
557 snd_info_unregister(snd_card_module_info_entry);
558#endif
559 return 0;
560}
561
562/**
563 * snd_component_add - add a component string
564 * @card: soundcard structure
565 * @component: the component id string
566 *
567 * This function adds the component id string to the supported list.
568 * The component can be referred from the alsa-lib.
569 *
570 * Returns zero otherwise a negative error code.
571 */
572
573int snd_component_add(snd_card_t *card, const char *component)
574{
575 char *ptr;
576 int len = strlen(component);
577
578 ptr = strstr(card->components, component);
579 if (ptr != NULL) {
580 if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
581 return 1;
582 }
583 if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
584 snd_BUG();
585 return -ENOMEM;
586 }
587 if (card->components[0] != '\0')
588 strcat(card->components, " ");
589 strcat(card->components, component);
590 return 0;
591}
592
593/**
594 * snd_card_file_add - add the file to the file list of the card
595 * @card: soundcard structure
596 * @file: file pointer
597 *
598 * This function adds the file to the file linked-list of the card.
599 * This linked-list is used to keep tracking the connection state,
600 * and to avoid the release of busy resources by hotplug.
601 *
602 * Returns zero or a negative error code.
603 */
604int snd_card_file_add(snd_card_t *card, struct file *file)
605{
606 struct snd_monitor_file *mfile;
607
608 mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
609 if (mfile == NULL)
610 return -ENOMEM;
611 mfile->file = file;
612 mfile->next = NULL;
613 spin_lock(&card->files_lock);
614 if (card->shutdown) {
615 spin_unlock(&card->files_lock);
616 kfree(mfile);
617 return -ENODEV;
618 }
619 mfile->next = card->files;
620 card->files = mfile;
621 spin_unlock(&card->files_lock);
622 return 0;
623}
624
625/**
626 * snd_card_file_remove - remove the file from the file list
627 * @card: soundcard structure
628 * @file: file pointer
629 *
630 * This function removes the file formerly added to the card via
631 * snd_card_file_add() function.
632 * If all files are removed and the release of the card is
633 * scheduled, it will wake up the the thread to call snd_card_free()
634 * (see snd_card_free_in_thread() function).
635 *
636 * Returns zero or a negative error code.
637 */
638int snd_card_file_remove(snd_card_t *card, struct file *file)
639{
640 struct snd_monitor_file *mfile, *pfile = NULL;
641
642 spin_lock(&card->files_lock);
643 mfile = card->files;
644 while (mfile) {
645 if (mfile->file == file) {
646 if (pfile)
647 pfile->next = mfile->next;
648 else
649 card->files = mfile->next;
650 break;
651 }
652 pfile = mfile;
653 mfile = mfile->next;
654 }
655 spin_unlock(&card->files_lock);
656 if (card->files == NULL)
657 wake_up(&card->shutdown_sleep);
658 if (!mfile) {
659 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
660 return -ENOENT;
661 }
662 kfree(mfile);
663 return 0;
664}
665
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200666#ifdef CONFIG_SND_GENERIC_DRIVER
667/*
668 * generic device without a proper bus using platform_device
669 * (e.g. ISA)
670 */
671struct snd_generic_device {
672 struct platform_device pdev;
673 snd_card_t *card;
674};
675
676#define get_snd_generic_card(dev) container_of(to_platform_device(dev), struct snd_generic_device, pdev)->card
677
678#define SND_GENERIC_NAME "snd_generic"
679
680#ifdef CONFIG_PM
Russell King9480e302005-10-28 09:52:56 -0700681static int snd_generic_suspend(struct device *dev, pm_message_t state);
682static int snd_generic_resume(struct device *dev);
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200683#endif
684
685/* initialized in sound.c */
686struct device_driver snd_generic_driver = {
687 .name = SND_GENERIC_NAME,
688 .bus = &platform_bus_type,
689#ifdef CONFIG_PM
690 .suspend = snd_generic_suspend,
691 .resume = snd_generic_resume,
692#endif
693};
694
695void snd_generic_device_release(struct device *dev)
696{
697}
698
699static int snd_generic_device_register(snd_card_t *card)
700{
701 struct snd_generic_device *dev;
702 int err;
703
704 if (card->generic_dev)
705 return 0; /* already registered */
706
Takashi Iwaica2c0962005-09-09 14:20:23 +0200707 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200708 if (! dev) {
709 snd_printk(KERN_ERR "can't allocate generic_device\n");
710 return -ENOMEM;
711 }
712
713 dev->pdev.name = SND_GENERIC_NAME;
714 dev->pdev.id = card->number;
715 dev->pdev.dev.release = snd_generic_device_release;
716 dev->card = card;
717 if ((err = platform_device_register(&dev->pdev)) < 0) {
718 kfree(dev);
719 return err;
720 }
721 card->generic_dev = dev;
722 return 0;
723}
724
725static void snd_generic_device_unregister(snd_card_t *card)
726{
727 struct snd_generic_device *dev = card->generic_dev;
728 if (dev) {
729 platform_device_unregister(&dev->pdev);
730 kfree(dev);
731 card->generic_dev = NULL;
732 }
733}
734
735/**
736 * snd_card_set_generic_dev - assign the generic device to the card
737 * @card: soundcard structure
738 *
739 * Assigns a generic device to the card. This function is provided as the
740 * last resort, for devices without any proper bus. Thus this won't override
741 * the device already assigned to the card.
742 *
743 * Returns zero if successful, or a negative error code.
744 */
745int snd_card_set_generic_dev(snd_card_t *card)
746{
747 int err;
748 if ((err = snd_generic_device_register(card)) < 0)
749 return err;
750 if (! card->dev)
751 snd_card_set_dev(card, &card->generic_dev->pdev.dev);
752 return 0;
753}
754#endif /* CONFIG_SND_GENERIC_DRIVER */
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756#ifdef CONFIG_PM
757/**
758 * snd_power_wait - wait until the power-state is changed.
759 * @card: soundcard structure
760 * @power_state: expected power state
761 * @file: file structure for the O_NONBLOCK check (optional)
762 *
763 * Waits until the power-state is changed.
764 *
765 * Note: the power lock must be active before call.
766 */
767int snd_power_wait(snd_card_t *card, unsigned int power_state, struct file *file)
768{
769 wait_queue_t wait;
770 int result = 0;
771
772 /* fastpath */
773 if (snd_power_get_state(card) == power_state)
774 return 0;
775 init_waitqueue_entry(&wait, current);
776 add_wait_queue(&card->power_sleep, &wait);
777 while (1) {
778 if (card->shutdown) {
779 result = -ENODEV;
780 break;
781 }
782 if (snd_power_get_state(card) == power_state)
783 break;
784#if 0 /* block all devices */
785 if (file && (file->f_flags & O_NONBLOCK)) {
786 result = -EAGAIN;
787 break;
788 }
789#endif
790 set_current_state(TASK_UNINTERRUPTIBLE);
791 snd_power_unlock(card);
792 schedule_timeout(30 * HZ);
793 snd_power_lock(card);
794 }
795 remove_wait_queue(&card->power_sleep, &wait);
796 return result;
797}
798
799/**
800 * snd_card_set_pm_callback - set the PCI power-management callbacks
801 * @card: soundcard structure
802 * @suspend: suspend callback function
803 * @resume: resume callback function
804 * @private_data: private data to pass to the callback functions
805 *
806 * Sets the power-management callback functions of the card.
807 * These callbacks are called from ALSA's common PCI suspend/resume
808 * handler and from the control API.
809 */
810int snd_card_set_pm_callback(snd_card_t *card,
811 int (*suspend)(snd_card_t *, pm_message_t),
812 int (*resume)(snd_card_t *),
813 void *private_data)
814{
815 card->pm_suspend = suspend;
816 card->pm_resume = resume;
817 card->pm_private_data = private_data;
818 return 0;
819}
820
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200821#ifdef CONFIG_SND_GENERIC_DRIVER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822/* suspend/resume callbacks for snd_generic platform device */
Russell King9480e302005-10-28 09:52:56 -0700823static int snd_generic_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
825 snd_card_t *card;
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 card = get_snd_generic_card(dev);
828 if (card->power_state == SNDRV_CTL_POWER_D3hot)
829 return 0;
Takashi Iwaid5c5d8f2005-10-24 18:16:50 +0200830 if (card->pm_suspend)
831 card->pm_suspend(card, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
833 return 0;
834}
835
Russell King9480e302005-10-28 09:52:56 -0700836static int snd_generic_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
838 snd_card_t *card;
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 card = get_snd_generic_card(dev);
841 if (card->power_state == SNDRV_CTL_POWER_D0)
842 return 0;
Takashi Iwaid5c5d8f2005-10-24 18:16:50 +0200843 if (card->pm_suspend)
844 card->pm_resume(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
846 return 0;
847}
848
849/**
850 * snd_card_set_generic_pm_callback - set the generic power-management callbacks
851 * @card: soundcard structure
852 * @suspend: suspend callback function
853 * @resume: resume callback function
854 * @private_data: private data to pass to the callback functions
855 *
856 * Registers the power-management and sets the lowlevel callbacks for
857 * the given card. These callbacks are called from the ALSA's common
858 * PM handler and from the control API.
859 */
860int snd_card_set_generic_pm_callback(snd_card_t *card,
861 int (*suspend)(snd_card_t *, pm_message_t),
862 int (*resume)(snd_card_t *),
863 void *private_data)
864{
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200865 int err;
866 if ((err = snd_generic_device_register(card)) < 0)
867 return err;
868 return snd_card_set_pm_callback(card, suspend, resume, private_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
Takashi Iwaiecbcfe32005-09-05 17:15:37 +0200870#endif /* CONFIG_SND_GENERIC_DRIVER */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872#ifdef CONFIG_PCI
873int snd_card_pci_suspend(struct pci_dev *dev, pm_message_t state)
874{
875 snd_card_t *card = pci_get_drvdata(dev);
876 int err;
877 if (! card || ! card->pm_suspend)
878 return 0;
879 if (card->power_state == SNDRV_CTL_POWER_D3hot)
880 return 0;
881 err = card->pm_suspend(card, PMSG_SUSPEND);
882 pci_save_state(dev);
883 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
884 return err;
885}
886
887int snd_card_pci_resume(struct pci_dev *dev)
888{
889 snd_card_t *card = pci_get_drvdata(dev);
890 if (! card || ! card->pm_resume)
891 return 0;
892 if (card->power_state == SNDRV_CTL_POWER_D0)
893 return 0;
894 /* restore the PCI config space */
895 pci_restore_state(dev);
896 card->pm_resume(card);
897 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
898 return 0;
899}
900#endif
901
902#endif /* CONFIG_PM */