X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sound%2Fcore%2Fsound.c;h=108e430b50362dc10f65f97e73ecdc0992d93b62;hb=43bc926fffd92024b46cafaf7350d669ba9ca884;hp=7790d08b99c54b4c77fac7ea4d7664eda4d6d9ab;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/sound/core/sound.c b/sound/core/sound.c index 7790d08b9..108e430b5 100644 --- a/sound/core/sound.c +++ b/sound/core/sound.c @@ -23,6 +23,8 @@ #include #include #include +#include +#include #include #include #include @@ -31,7 +33,7 @@ #include #include #include -#include +#include #define SNDRV_OS_MINORS 256 @@ -43,19 +45,13 @@ static int device_mode = S_IFCHR | S_IRUGO | S_IWUGO; MODULE_AUTHOR("Jaroslav Kysela "); MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards."); MODULE_LICENSE("GPL"); -MODULE_CLASSES("{sound}"); -MODULE_SUPPORTED_DEVICE("sound"); -MODULE_PARM(major, "i"); +module_param(major, int, 0444); MODULE_PARM_DESC(major, "Major # for sound driver."); -MODULE_PARM_SYNTAX(major, "default:116,skill:devel"); -MODULE_PARM(cards_limit, "i"); +module_param(cards_limit, int, 0444); MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards."); -MODULE_PARM_SYNTAX(cards_limit, "default:8,skill:advanced"); -MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); #ifdef CONFIG_DEVFS_FS -MODULE_PARM(device_mode, "i"); +module_param(device_mode, int, 0444); MODULE_PARM_DESC(device_mode, "Device file permission mask for devfs."); -MODULE_PARM_SYNTAX(device_mode, "default:0666,base:8"); #endif MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); @@ -65,11 +61,10 @@ MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); */ int snd_ecards_limit; -static struct list_head snd_minors_hash[SNDRV_CARDS]; +static struct snd_minor *snd_minors[SNDRV_OS_MINORS]; +static DEFINE_MUTEX(sound_mutex); -static DECLARE_MUTEX(sound_mutex); - -extern struct class_simple *sound_class; +extern struct class *sound_class; #ifdef CONFIG_KMOD @@ -113,44 +108,61 @@ static void snd_request_other(int minor) #endif /* request_module support */ -static snd_minor_t *snd_minor_search(int minor) +/** + * snd_lookup_minor_data - get user data of a registered device + * @minor: the minor number + * @type: device type (SNDRV_DEVICE_TYPE_XXX) + * + * Checks that a minor device with the specified type is registered, and returns + * its user data pointer. + */ +void *snd_lookup_minor_data(unsigned int minor, int type) { - struct list_head *list; - snd_minor_t *mptr; - - list_for_each(list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]) { - mptr = list_entry(list, snd_minor_t, list); - if (mptr->number == minor) - return mptr; - } - return NULL; + struct snd_minor *mreg; + void *private_data; + + if (minor >= ARRAY_SIZE(snd_minors)) + return NULL; + mutex_lock(&sound_mutex); + mreg = snd_minors[minor]; + if (mreg && mreg->type == type) + private_data = mreg->private_data; + else + private_data = NULL; + mutex_unlock(&sound_mutex); + return private_data; } static int snd_open(struct inode *inode, struct file *file) { - int minor = iminor(inode); - int card = SNDRV_MINOR_CARD(minor); - int dev = SNDRV_MINOR_DEVICE(minor); - snd_minor_t *mptr = NULL; - struct file_operations *old_fops; + unsigned int minor = iminor(inode); + struct snd_minor *mptr = NULL; + const struct file_operations *old_fops; int err = 0; - if (dev != SNDRV_MINOR_SEQUENCER && dev != SNDRV_MINOR_TIMER) { - if (snd_cards[card] == NULL) { + if (minor >= ARRAY_SIZE(snd_minors)) + return -ENODEV; + mptr = snd_minors[minor]; + if (mptr == NULL) { #ifdef CONFIG_KMOD - snd_request_card(card); + int dev = SNDRV_MINOR_DEVICE(minor); + if (dev == SNDRV_MINOR_CONTROL) { + /* /dev/aloadC? */ + int card = SNDRV_MINOR_CARD(minor); if (snd_cards[card] == NULL) -#endif - return -ENODEV; - } - } else { -#ifdef CONFIG_KMOD - if ((mptr = snd_minor_search(minor)) == NULL) + snd_request_card(card); + } else if (dev == SNDRV_MINOR_GLOBAL) { + /* /dev/aloadSEQ */ snd_request_other(minor); + } +#ifndef CONFIG_SND_DYNAMIC_MINORS + /* /dev/snd/{controlC?,seq} */ + mptr = snd_minors[minor]; + if (mptr == NULL) +#endif #endif + return -ENODEV; } - if (mptr == NULL && (mptr = snd_minor_search(minor)) == NULL) - return -ENODEV; old_fops = file->f_op; file->f_op = fops_get(mptr->f_ops); if (file->f_op->open) @@ -163,13 +175,29 @@ static int snd_open(struct inode *inode, struct file *file) return err; } -struct file_operations snd_fops = +static struct file_operations snd_fops = { .owner = THIS_MODULE, .open = snd_open }; -static int snd_kernel_minor(int type, snd_card_t * card, int dev) +#ifdef CONFIG_SND_DYNAMIC_MINORS +static int snd_find_free_minor(void) +{ + int minor; + + for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { + /* skip minors still used statically for autoloading devices */ + if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL || + minor == SNDRV_MINOR_SEQUENCER) + continue; + if (!snd_minors[minor]) + return minor; + } + return -EBUSY; +} +#else +static int snd_kernel_minor(int type, struct snd_card *card, int dev) { int minor; @@ -195,13 +223,15 @@ static int snd_kernel_minor(int type, snd_card_t * card, int dev) snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); return minor; } +#endif /** * snd_register_device - Register the ALSA device file for the card * @type: the device type, SNDRV_DEVICE_TYPE_XXX * @card: the card instance * @dev: the device index - * @reg: the snd_minor_t record + * @f_ops: the file operations + * @private_data: user pointer for f_ops->open() * @name: the device file name * * Registers an ALSA device file for the given card. @@ -209,37 +239,45 @@ static int snd_kernel_minor(int type, snd_card_t * card, int dev) * * Retrurns zero if successful, or a negative error code on failure. */ -int snd_register_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, const char *name) +int snd_register_device(int type, struct snd_card *card, int dev, + const struct file_operations *f_ops, void *private_data, + const char *name) { - int minor = snd_kernel_minor(type, card, dev); - snd_minor_t *preg; + int minor; + struct snd_minor *preg; struct device *device = NULL; - if (minor < 0) - return minor; snd_assert(name, return -EINVAL); - preg = (snd_minor_t *)kmalloc(sizeof(snd_minor_t) + strlen(name) + 1, GFP_KERNEL); + preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL); if (preg == NULL) return -ENOMEM; - *preg = *reg; - preg->number = minor; + preg->type = type; + preg->card = card ? card->number : -1; preg->device = dev; + preg->f_ops = f_ops; + preg->private_data = private_data; strcpy(preg->name, name); - down(&sound_mutex); - if (snd_minor_search(minor)) { - up(&sound_mutex); + mutex_lock(&sound_mutex); +#ifdef CONFIG_SND_DYNAMIC_MINORS + minor = snd_find_free_minor(); +#else + minor = snd_kernel_minor(type, card, dev); + if (minor >= 0 && snd_minors[minor]) + minor = -EBUSY; +#endif + if (minor < 0) { + mutex_unlock(&sound_mutex); kfree(preg); - return -EBUSY; + return minor; } - list_add_tail(&preg->list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]); - if (strncmp(name, "controlC", 8) || card->number >= cards_limit) { + snd_minors[minor] = preg; + if (type != SNDRV_DEVICE_TYPE_CONTROL || preg->card >= cards_limit) devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name); - if (card) - device = card->dev; - class_simple_device_add(sound_class, MKDEV(major, minor), device, name); - } + if (card) + device = card->dev; + class_device_create(sound_class, NULL, MKDEV(major, minor), device, "%s", name); - up(&sound_mutex); + mutex_unlock(&sound_mutex); return 0; } @@ -254,62 +292,92 @@ int snd_register_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, * * Returns zero if sucecessful, or a negative error code on failure */ -int snd_unregister_device(int type, snd_card_t * card, int dev) +int snd_unregister_device(int type, struct snd_card *card, int dev) { - int minor = snd_kernel_minor(type, card, dev); - snd_minor_t *mptr; - - if (minor < 0) - return minor; - down(&sound_mutex); - if ((mptr = snd_minor_search(minor)) == NULL) { - up(&sound_mutex); + int cardnum, minor; + struct snd_minor *mptr; + + cardnum = card ? card->number : -1; + mutex_lock(&sound_mutex); + for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) + if ((mptr = snd_minors[minor]) != NULL && + mptr->type == type && + mptr->card == cardnum && + mptr->device == dev) + break; + if (minor == ARRAY_SIZE(snd_minors)) { + mutex_unlock(&sound_mutex); return -EINVAL; } - if (strncmp(mptr->name, "controlC", 8) || card->number >= cards_limit) { /* created in sound.c */ + if (mptr->type != SNDRV_DEVICE_TYPE_CONTROL || + mptr->card >= cards_limit) /* created in sound.c */ devfs_remove("snd/%s", mptr->name); - class_simple_device_remove(MKDEV(major, minor)); - } + class_device_destroy(sound_class, MKDEV(major, minor)); - list_del(&mptr->list); - up(&sound_mutex); + snd_minors[minor] = NULL; + mutex_unlock(&sound_mutex); kfree(mptr); return 0; } +#ifdef CONFIG_PROC_FS /* * INFO PART */ -static snd_info_entry_t *snd_minor_info_entry = NULL; +static struct snd_info_entry *snd_minor_info_entry = NULL; -static void snd_minor_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) +static const char *snd_device_type_name(int type) { - int card, device; - struct list_head *list; - snd_minor_t *mptr; - - down(&sound_mutex); - for (card = 0; card < SNDRV_CARDS; card++) { - list_for_each(list, &snd_minors_hash[card]) { - mptr = list_entry(list, snd_minor_t, list); - if (SNDRV_MINOR_DEVICE(mptr->number) != SNDRV_MINOR_SEQUENCER) { - if ((device = mptr->device) >= 0) - snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, device, mptr->comment); - else - snd_iprintf(buffer, "%3i: [%i] : %s\n", mptr->number, card, mptr->comment); - } else { - snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); - } - } + switch (type) { + case SNDRV_DEVICE_TYPE_CONTROL: + return "control"; + case SNDRV_DEVICE_TYPE_HWDEP: + return "hardware dependent"; + case SNDRV_DEVICE_TYPE_RAWMIDI: + return "raw midi"; + case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: + return "digital audio playback"; + case SNDRV_DEVICE_TYPE_PCM_CAPTURE: + return "digital audio capture"; + case SNDRV_DEVICE_TYPE_SEQUENCER: + return "sequencer"; + case SNDRV_DEVICE_TYPE_TIMER: + return "timer"; + default: + return "?"; } - up(&sound_mutex); +} + +static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +{ + int minor; + struct snd_minor *mptr; + + mutex_lock(&sound_mutex); + for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) { + if (!(mptr = snd_minors[minor])) + continue; + if (mptr->card >= 0) { + if (mptr->device >= 0) + snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n", + minor, mptr->card, mptr->device, + snd_device_type_name(mptr->type)); + else + snd_iprintf(buffer, "%3i: [%2i] : %s\n", + minor, mptr->card, + snd_device_type_name(mptr->type)); + } else + snd_iprintf(buffer, "%3i: : %s\n", minor, + snd_device_type_name(mptr->type)); + } + mutex_unlock(&sound_mutex); } int __init snd_minor_info_init(void) { - snd_info_entry_t *entry; + struct snd_info_entry *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); if (entry) { @@ -330,6 +398,7 @@ int __exit snd_minor_info_done(void) snd_info_unregister(snd_minor_info_entry); return 0; } +#endif /* CONFIG_PROC_FS */ /* * INIT PART @@ -338,43 +407,23 @@ int __exit snd_minor_info_done(void) static int __init alsa_sound_init(void) { short controlnum; -#ifdef CONFIG_SND_OSSEMUL - int err; -#endif - int card; snd_major = major; snd_ecards_limit = cards_limit; - for (card = 0; card < SNDRV_CARDS; card++) - INIT_LIST_HEAD(&snd_minors_hash[card]); -#ifdef CONFIG_SND_OSSEMUL - if ((err = snd_oss_init_module()) < 0) - return err; -#endif devfs_mk_dir("snd"); if (register_chrdev(major, "alsa", &snd_fops)) { snd_printk(KERN_ERR "unable to register native major device number %d\n", major); devfs_remove("snd"); return -EIO; } -#ifdef CONFIG_SND_DEBUG_MEMORY - snd_memory_init(); -#endif if (snd_info_init() < 0) { -#ifdef CONFIG_SND_DEBUG_MEMORY - snd_memory_done(); -#endif unregister_chrdev(major, "alsa"); devfs_remove("snd"); return -ENOMEM; } -#ifdef CONFIG_SND_OSSEMUL snd_info_minor_register(); -#endif - for (controlnum = 0; controlnum < cards_limit; controlnum++) { + for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_mk_cdev(MKDEV(major, controlnum<<5), S_IFCHR | device_mode, "snd/controlC%d", controlnum); - class_simple_device_add(sound_class, MKDEV(major, controlnum<<5), NULL, "controlC%d", controlnum); - } #ifndef MODULE printk(KERN_INFO "Advanced Linux Sound Architecture Driver Version " CONFIG_SND_VERSION CONFIG_SND_DATE ".\n"); #endif @@ -385,18 +434,11 @@ static void __exit alsa_sound_exit(void) { short controlnum; - for (controlnum = 0; controlnum < cards_limit; controlnum++) { + for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_remove("snd/controlC%d", controlnum); - class_simple_device_remove(MKDEV(major, controlnum<<5)); - } -#ifdef CONFIG_SND_OSSEMUL snd_info_minor_unregister(); -#endif snd_info_done(); -#ifdef CONFIG_SND_DEBUG_MEMORY - snd_memory_done(); -#endif if (unregister_chrdev(major, "alsa") != 0) snd_printk(KERN_ERR "unable to unregister major device number %d\n", major); devfs_remove("snd"); @@ -405,24 +447,6 @@ static void __exit alsa_sound_exit(void) module_init(alsa_sound_init) module_exit(alsa_sound_exit) -#ifndef MODULE - -/* format is: snd=major,cards_limit[,device_mode] */ - -static int __init alsa_sound_setup(char *str) -{ - (void)(get_option(&str,&major) == 2 && - get_option(&str,&cards_limit) == 2); -#ifdef CONFIG_DEVFS_FS - (void)(get_option(&str,&device_mode) == 2); -#endif - return 1; -} - -__setup("snd=", alsa_sound_setup); - -#endif /* ifndef MODULE */ - /* sound.c */ EXPORT_SYMBOL(snd_major); EXPORT_SYMBOL(snd_ecards_limit); @@ -431,26 +455,16 @@ EXPORT_SYMBOL(snd_request_card); #endif EXPORT_SYMBOL(snd_register_device); EXPORT_SYMBOL(snd_unregister_device); +EXPORT_SYMBOL(snd_lookup_minor_data); #if defined(CONFIG_SND_OSSEMUL) EXPORT_SYMBOL(snd_register_oss_device); EXPORT_SYMBOL(snd_unregister_oss_device); +EXPORT_SYMBOL(snd_lookup_oss_minor_data); #endif /* memory.c */ -#ifdef CONFIG_SND_DEBUG_MEMORY -EXPORT_SYMBOL(snd_hidden_kmalloc); -EXPORT_SYMBOL(snd_hidden_kfree); -EXPORT_SYMBOL(snd_hidden_vmalloc); -EXPORT_SYMBOL(snd_hidden_vfree); -EXPORT_SYMBOL(_snd_magic_kmalloc); -EXPORT_SYMBOL(_snd_magic_kcalloc); -EXPORT_SYMBOL(snd_magic_kfree); -#endif -EXPORT_SYMBOL(snd_kcalloc); -EXPORT_SYMBOL(snd_kmalloc_strdup); EXPORT_SYMBOL(copy_to_user_fromio); EXPORT_SYMBOL(copy_from_user_toio); /* init.c */ -EXPORT_SYMBOL(snd_cards_count); EXPORT_SYMBOL(snd_cards); #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) EXPORT_SYMBOL(snd_mixer_oss_notify_callback); @@ -470,9 +484,8 @@ EXPORT_SYMBOL(snd_power_wait); EXPORT_SYMBOL(snd_device_new); EXPORT_SYMBOL(snd_device_register); EXPORT_SYMBOL(snd_device_free); -EXPORT_SYMBOL(snd_device_free_all); /* isadma.c */ -#ifdef CONFIG_ISA +#ifdef CONFIG_ISA_DMA_API EXPORT_SYMBOL(snd_dma_program); EXPORT_SYMBOL(snd_dma_disable); EXPORT_SYMBOL(snd_dma_pointer); @@ -480,8 +493,6 @@ EXPORT_SYMBOL(snd_dma_pointer); /* info.c */ #ifdef CONFIG_PROC_FS EXPORT_SYMBOL(snd_seq_root); -EXPORT_SYMBOL(snd_create_proc_entry); -EXPORT_SYMBOL(snd_remove_proc_entry); EXPORT_SYMBOL(snd_iprintf); EXPORT_SYMBOL(snd_info_get_line); EXPORT_SYMBOL(snd_info_get_str); @@ -509,18 +520,17 @@ EXPORT_SYMBOL(snd_ctl_find_id); EXPORT_SYMBOL(snd_ctl_notify); EXPORT_SYMBOL(snd_ctl_register_ioctl); EXPORT_SYMBOL(snd_ctl_unregister_ioctl); +#ifdef CONFIG_COMPAT +EXPORT_SYMBOL(snd_ctl_register_ioctl_compat); +EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat); +#endif +EXPORT_SYMBOL(snd_ctl_elem_read); +EXPORT_SYMBOL(snd_ctl_elem_write); /* misc.c */ -EXPORT_SYMBOL(snd_task_name); +EXPORT_SYMBOL(release_and_free_resource); #ifdef CONFIG_SND_VERBOSE_PRINTK EXPORT_SYMBOL(snd_verbose_printk); #endif #if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK) EXPORT_SYMBOL(snd_verbose_printd); -#endif - /* wrappers */ -#ifdef CONFIG_SND_DEBUG_MEMORY -EXPORT_SYMBOL(snd_wrapper_kmalloc); -EXPORT_SYMBOL(snd_wrapper_kfree); -EXPORT_SYMBOL(snd_wrapper_vmalloc); -EXPORT_SYMBOL(snd_wrapper_vfree); #endif