[ALSA] semaphore -> mutex (core part)
[linux-2.6.git] / sound / core / sound.c
1 /*
2  *  Advanced Linux Sound Architecture
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/slab.h>
25 #include <linux/time.h>
26 #include <linux/device.h>
27 #include <linux/moduleparam.h>
28 #include <sound/core.h>
29 #include <sound/minors.h>
30 #include <sound/info.h>
31 #include <sound/version.h>
32 #include <sound/control.h>
33 #include <sound/initval.h>
34 #include <linux/kmod.h>
35 #include <linux/devfs_fs_kernel.h>
36 #include <linux/mutex.h>
37
38 #define SNDRV_OS_MINORS 256
39
40 static int major = CONFIG_SND_MAJOR;
41 int snd_major;
42 static int cards_limit = 1;
43 static int device_mode = S_IFCHR | S_IRUGO | S_IWUGO;
44
45 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
46 MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
47 MODULE_LICENSE("GPL");
48 module_param(major, int, 0444);
49 MODULE_PARM_DESC(major, "Major # for sound driver.");
50 module_param(cards_limit, int, 0444);
51 MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards.");
52 #ifdef CONFIG_DEVFS_FS
53 module_param(device_mode, int, 0444);
54 MODULE_PARM_DESC(device_mode, "Device file permission mask for devfs.");
55 #endif
56 MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);
57
58 /* this one holds the actual max. card number currently available.
59  * as default, it's identical with cards_limit option.  when more
60  * modules are loaded manually, this limit number increases, too.
61  */
62 int snd_ecards_limit;
63
64 static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
65 static DEFINE_MUTEX(sound_mutex);
66
67 extern struct class *sound_class;
68
69
70 #ifdef CONFIG_KMOD
71
72 /**
73  * snd_request_card - try to load the card module
74  * @card: the card number
75  *
76  * Tries to load the module "snd-card-X" for the given card number
77  * via KMOD.  Returns immediately if already loaded.
78  */
79 void snd_request_card(int card)
80 {
81         int locked;
82
83         if (! current->fs->root)
84                 return;
85         read_lock(&snd_card_rwlock);
86         locked = snd_cards_lock & (1 << card);
87         read_unlock(&snd_card_rwlock);
88         if (locked)
89                 return;
90         if (card < 0 || card >= cards_limit)
91                 return;
92         request_module("snd-card-%i", card);
93 }
94
95 static void snd_request_other(int minor)
96 {
97         char *str;
98
99         if (! current->fs->root)
100                 return;
101         switch (minor) {
102         case SNDRV_MINOR_SEQUENCER:     str = "snd-seq";        break;
103         case SNDRV_MINOR_TIMER:         str = "snd-timer";      break;
104         default:                        return;
105         }
106         request_module(str);
107 }
108
109 #endif                          /* request_module support */
110
111 /**
112  * snd_lookup_minor_data - get user data of a registered device
113  * @minor: the minor number
114  * @type: device type (SNDRV_DEVICE_TYPE_XXX)
115  *
116  * Checks that a minor device with the specified type is registered, and returns
117  * its user data pointer.
118  */
119 void *snd_lookup_minor_data(unsigned int minor, int type)
120 {
121         struct snd_minor *mreg;
122         void *private_data;
123
124         if (minor > ARRAY_SIZE(snd_minors))
125                 return NULL;
126         mutex_lock(&sound_mutex);
127         mreg = snd_minors[minor];
128         if (mreg && mreg->type == type)
129                 private_data = mreg->private_data;
130         else
131                 private_data = NULL;
132         mutex_unlock(&sound_mutex);
133         return private_data;
134 }
135
136 static int snd_open(struct inode *inode, struct file *file)
137 {
138         unsigned int minor = iminor(inode);
139         struct snd_minor *mptr = NULL;
140         struct file_operations *old_fops;
141         int err = 0;
142
143         if (minor > ARRAY_SIZE(snd_minors))
144                 return -ENODEV;
145         mptr = snd_minors[minor];
146         if (mptr == NULL) {
147 #ifdef CONFIG_KMOD
148                 int dev = SNDRV_MINOR_DEVICE(minor);
149                 if (dev == SNDRV_MINOR_CONTROL) {
150                         /* /dev/aloadC? */
151                         int card = SNDRV_MINOR_CARD(minor);
152                         if (snd_cards[card] == NULL)
153                                 snd_request_card(card);
154                 } else if (dev == SNDRV_MINOR_GLOBAL) {
155                         /* /dev/aloadSEQ */
156                         snd_request_other(minor);
157                 }
158 #ifndef CONFIG_SND_DYNAMIC_MINORS
159                 /* /dev/snd/{controlC?,seq} */
160                 mptr = snd_minors[minor];
161                 if (mptr == NULL)
162 #endif
163 #endif
164                         return -ENODEV;
165         }
166         old_fops = file->f_op;
167         file->f_op = fops_get(mptr->f_ops);
168         if (file->f_op->open)
169                 err = file->f_op->open(inode, file);
170         if (err) {
171                 fops_put(file->f_op);
172                 file->f_op = fops_get(old_fops);
173         }
174         fops_put(old_fops);
175         return err;
176 }
177
178 static struct file_operations snd_fops =
179 {
180         .owner =        THIS_MODULE,
181         .open =         snd_open
182 };
183
184 #ifdef CONFIG_SND_DYNAMIC_MINORS
185 static int snd_find_free_minor(void)
186 {
187         int minor;
188
189         for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
190                 /* skip minors still used statically for autoloading devices */
191                 if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL ||
192                     minor == SNDRV_MINOR_SEQUENCER)
193                         continue;
194                 if (!snd_minors[minor])
195                         return minor;
196         }
197         return -EBUSY;
198 }
199 #else
200 static int snd_kernel_minor(int type, struct snd_card *card, int dev)
201 {
202         int minor;
203
204         switch (type) {
205         case SNDRV_DEVICE_TYPE_SEQUENCER:
206         case SNDRV_DEVICE_TYPE_TIMER:
207                 minor = type;
208                 break;
209         case SNDRV_DEVICE_TYPE_CONTROL:
210                 snd_assert(card != NULL, return -EINVAL);
211                 minor = SNDRV_MINOR(card->number, type);
212                 break;
213         case SNDRV_DEVICE_TYPE_HWDEP:
214         case SNDRV_DEVICE_TYPE_RAWMIDI:
215         case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
216         case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
217                 snd_assert(card != NULL, return -EINVAL);
218                 minor = SNDRV_MINOR(card->number, type + dev);
219                 break;
220         default:
221                 return -EINVAL;
222         }
223         snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL);
224         return minor;
225 }
226 #endif
227
228 /**
229  * snd_register_device - Register the ALSA device file for the card
230  * @type: the device type, SNDRV_DEVICE_TYPE_XXX
231  * @card: the card instance
232  * @dev: the device index
233  * @f_ops: the file operations
234  * @private_data: user pointer for f_ops->open()
235  * @name: the device file name
236  *
237  * Registers an ALSA device file for the given card.
238  * The operators have to be set in reg parameter.
239  *
240  * Retrurns zero if successful, or a negative error code on failure.
241  */
242 int snd_register_device(int type, struct snd_card *card, int dev,
243                         struct file_operations *f_ops, void *private_data,
244                         const char *name)
245 {
246         int minor;
247         struct snd_minor *preg;
248         struct device *device = NULL;
249
250         snd_assert(name, return -EINVAL);
251         preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL);
252         if (preg == NULL)
253                 return -ENOMEM;
254         preg->type = type;
255         preg->card = card ? card->number : -1;
256         preg->device = dev;
257         preg->f_ops = f_ops;
258         preg->private_data = private_data;
259         strcpy(preg->name, name);
260         mutex_lock(&sound_mutex);
261 #ifdef CONFIG_SND_DYNAMIC_MINORS
262         minor = snd_find_free_minor();
263 #else
264         minor = snd_kernel_minor(type, card, dev);
265         if (minor >= 0 && snd_minors[minor])
266                 minor = -EBUSY;
267 #endif
268         if (minor < 0) {
269                 mutex_unlock(&sound_mutex);
270                 kfree(preg);
271                 return minor;
272         }
273         snd_minors[minor] = preg;
274         if (type != SNDRV_DEVICE_TYPE_CONTROL || preg->card >= cards_limit)
275                 devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name);
276         if (card)
277                 device = card->dev;
278         class_device_create(sound_class, NULL, MKDEV(major, minor), device, "%s", name);
279
280         mutex_unlock(&sound_mutex);
281         return 0;
282 }
283
284 /**
285  * snd_unregister_device - unregister the device on the given card
286  * @type: the device type, SNDRV_DEVICE_TYPE_XXX
287  * @card: the card instance
288  * @dev: the device index
289  *
290  * Unregisters the device file already registered via
291  * snd_register_device().
292  *
293  * Returns zero if sucecessful, or a negative error code on failure
294  */
295 int snd_unregister_device(int type, struct snd_card *card, int dev)
296 {
297         int cardnum, minor;
298         struct snd_minor *mptr;
299
300         cardnum = card ? card->number : -1;
301         mutex_lock(&sound_mutex);
302         for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
303                 if ((mptr = snd_minors[minor]) != NULL &&
304                     mptr->type == type &&
305                     mptr->card == cardnum &&
306                     mptr->device == dev)
307                         break;
308         if (minor == ARRAY_SIZE(snd_minors)) {
309                 mutex_unlock(&sound_mutex);
310                 return -EINVAL;
311         }
312
313         if (mptr->type != SNDRV_DEVICE_TYPE_CONTROL ||
314             mptr->card >= cards_limit)                  /* created in sound.c */
315                 devfs_remove("snd/%s", mptr->name);
316         class_device_destroy(sound_class, MKDEV(major, minor));
317
318         snd_minors[minor] = NULL;
319         mutex_unlock(&sound_mutex);
320         kfree(mptr);
321         return 0;
322 }
323
324 #ifdef CONFIG_PROC_FS
325 /*
326  *  INFO PART
327  */
328
329 static struct snd_info_entry *snd_minor_info_entry = NULL;
330
331 static const char *snd_device_type_name(int type)
332 {
333         switch (type) {
334         case SNDRV_DEVICE_TYPE_CONTROL:
335                 return "control";
336         case SNDRV_DEVICE_TYPE_HWDEP:
337                 return "hardware dependent";
338         case SNDRV_DEVICE_TYPE_RAWMIDI:
339                 return "raw midi";
340         case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
341                 return "digital audio playback";
342         case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
343                 return "digital audio capture";
344         case SNDRV_DEVICE_TYPE_SEQUENCER:
345                 return "sequencer";
346         case SNDRV_DEVICE_TYPE_TIMER:
347                 return "timer";
348         default:
349                 return "?";
350         }
351 }
352
353 static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
354 {
355         int minor;
356         struct snd_minor *mptr;
357
358         mutex_lock(&sound_mutex);
359         for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
360                 if (!(mptr = snd_minors[minor]))
361                         continue;
362                 if (mptr->card >= 0) {
363                         if (mptr->device >= 0)
364                                 snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
365                                             minor, mptr->card, mptr->device,
366                                             snd_device_type_name(mptr->type));
367                         else
368                                 snd_iprintf(buffer, "%3i: [%2i]   : %s\n",
369                                             minor, mptr->card,
370                                             snd_device_type_name(mptr->type));
371                 } else
372                         snd_iprintf(buffer, "%3i:        : %s\n", minor,
373                                     snd_device_type_name(mptr->type));
374         }
375         mutex_unlock(&sound_mutex);
376 }
377
378 int __init snd_minor_info_init(void)
379 {
380         struct snd_info_entry *entry;
381
382         entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
383         if (entry) {
384                 entry->c.text.read_size = PAGE_SIZE;
385                 entry->c.text.read = snd_minor_info_read;
386                 if (snd_info_register(entry) < 0) {
387                         snd_info_free_entry(entry);
388                         entry = NULL;
389                 }
390         }
391         snd_minor_info_entry = entry;
392         return 0;
393 }
394
395 int __exit snd_minor_info_done(void)
396 {
397         if (snd_minor_info_entry)
398                 snd_info_unregister(snd_minor_info_entry);
399         return 0;
400 }
401 #endif /* CONFIG_PROC_FS */
402
403 /*
404  *  INIT PART
405  */
406
407 static int __init alsa_sound_init(void)
408 {
409         short controlnum;
410
411         snd_major = major;
412         snd_ecards_limit = cards_limit;
413         devfs_mk_dir("snd");
414         if (register_chrdev(major, "alsa", &snd_fops)) {
415                 snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
416                 devfs_remove("snd");
417                 return -EIO;
418         }
419         if (snd_info_init() < 0) {
420                 unregister_chrdev(major, "alsa");
421                 devfs_remove("snd");
422                 return -ENOMEM;
423         }
424         snd_info_minor_register();
425         for (controlnum = 0; controlnum < cards_limit; controlnum++)
426                 devfs_mk_cdev(MKDEV(major, controlnum<<5), S_IFCHR | device_mode, "snd/controlC%d", controlnum);
427 #ifndef MODULE
428         printk(KERN_INFO "Advanced Linux Sound Architecture Driver Version " CONFIG_SND_VERSION CONFIG_SND_DATE ".\n");
429 #endif
430         return 0;
431 }
432
433 static void __exit alsa_sound_exit(void)
434 {
435         short controlnum;
436
437         for (controlnum = 0; controlnum < cards_limit; controlnum++)
438                 devfs_remove("snd/controlC%d", controlnum);
439
440         snd_info_minor_unregister();
441         snd_info_done();
442         if (unregister_chrdev(major, "alsa") != 0)
443                 snd_printk(KERN_ERR "unable to unregister major device number %d\n", major);
444         devfs_remove("snd");
445 }
446
447 module_init(alsa_sound_init)
448 module_exit(alsa_sound_exit)
449
450   /* sound.c */
451 EXPORT_SYMBOL(snd_major);
452 EXPORT_SYMBOL(snd_ecards_limit);
453 #if defined(CONFIG_KMOD)
454 EXPORT_SYMBOL(snd_request_card);
455 #endif
456 EXPORT_SYMBOL(snd_register_device);
457 EXPORT_SYMBOL(snd_unregister_device);
458 EXPORT_SYMBOL(snd_lookup_minor_data);
459 #if defined(CONFIG_SND_OSSEMUL)
460 EXPORT_SYMBOL(snd_register_oss_device);
461 EXPORT_SYMBOL(snd_unregister_oss_device);
462 EXPORT_SYMBOL(snd_lookup_oss_minor_data);
463 #endif
464   /* memory.c */
465 EXPORT_SYMBOL(copy_to_user_fromio);
466 EXPORT_SYMBOL(copy_from_user_toio);
467   /* init.c */
468 EXPORT_SYMBOL(snd_cards);
469 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
470 EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
471 #endif
472 EXPORT_SYMBOL(snd_card_new);
473 EXPORT_SYMBOL(snd_card_disconnect);
474 EXPORT_SYMBOL(snd_card_free);
475 EXPORT_SYMBOL(snd_card_free_in_thread);
476 EXPORT_SYMBOL(snd_card_register);
477 EXPORT_SYMBOL(snd_component_add);
478 EXPORT_SYMBOL(snd_card_file_add);
479 EXPORT_SYMBOL(snd_card_file_remove);
480 #ifdef CONFIG_PM
481 EXPORT_SYMBOL(snd_power_wait);
482 #endif
483   /* device.c */
484 EXPORT_SYMBOL(snd_device_new);
485 EXPORT_SYMBOL(snd_device_register);
486 EXPORT_SYMBOL(snd_device_free);
487   /* isadma.c */
488 #ifdef CONFIG_ISA_DMA_API
489 EXPORT_SYMBOL(snd_dma_program);
490 EXPORT_SYMBOL(snd_dma_disable);
491 EXPORT_SYMBOL(snd_dma_pointer);
492 #endif
493   /* info.c */
494 #ifdef CONFIG_PROC_FS
495 EXPORT_SYMBOL(snd_seq_root);
496 EXPORT_SYMBOL(snd_iprintf);
497 EXPORT_SYMBOL(snd_info_get_line);
498 EXPORT_SYMBOL(snd_info_get_str);
499 EXPORT_SYMBOL(snd_info_create_module_entry);
500 EXPORT_SYMBOL(snd_info_create_card_entry);
501 EXPORT_SYMBOL(snd_info_free_entry);
502 EXPORT_SYMBOL(snd_info_register);
503 EXPORT_SYMBOL(snd_info_unregister);
504 EXPORT_SYMBOL(snd_card_proc_new);
505 #endif
506   /* info_oss.c */
507 #if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
508 EXPORT_SYMBOL(snd_oss_info_register);
509 #endif
510   /* control.c */
511 EXPORT_SYMBOL(snd_ctl_new);
512 EXPORT_SYMBOL(snd_ctl_new1);
513 EXPORT_SYMBOL(snd_ctl_free_one);
514 EXPORT_SYMBOL(snd_ctl_add);
515 EXPORT_SYMBOL(snd_ctl_remove);
516 EXPORT_SYMBOL(snd_ctl_remove_id);
517 EXPORT_SYMBOL(snd_ctl_rename_id);
518 EXPORT_SYMBOL(snd_ctl_find_numid);
519 EXPORT_SYMBOL(snd_ctl_find_id);
520 EXPORT_SYMBOL(snd_ctl_notify);
521 EXPORT_SYMBOL(snd_ctl_register_ioctl);
522 EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
523 #ifdef CONFIG_COMPAT
524 EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
525 EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
526 #endif
527 EXPORT_SYMBOL(snd_ctl_elem_read);
528 EXPORT_SYMBOL(snd_ctl_elem_write);
529   /* misc.c */
530 EXPORT_SYMBOL(release_and_free_resource);
531 #ifdef CONFIG_SND_VERBOSE_PRINTK
532 EXPORT_SYMBOL(snd_verbose_printk);
533 #endif
534 #if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
535 EXPORT_SYMBOL(snd_verbose_printd);
536 #endif