[ALSA] Remove spinlocks around proc prints

[pandora-kernel.git] / sound / core / pcm.c

diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 28ca61e..4f52041 100644 (file)
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -23,6 +23,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/time.h>
+#include <linux/mutex.h>
 #include <sound/core.h>
 #include <sound/minors.h>
 #include <sound/pcm.h>
@@ -35,7 +36,7 @@ MODULE_LICENSE("GPL");
 
 static LIST_HEAD(snd_pcm_devices);
 static LIST_HEAD(snd_pcm_notify_list);
-static DECLARE_MUTEX(register_mutex);
+static DEFINE_MUTEX(register_mutex);
 
 static int snd_pcm_free(struct snd_pcm *pcm);
 static int snd_pcm_dev_free(struct snd_device *device);
@@ -67,7 +68,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
 
                        if (get_user(device, (int __user *)arg))
                                return -EFAULT;
-                       down(&register_mutex);
+                       mutex_lock(&register_mutex);
                        device = device < 0 ? 0 : device + 1;
                        while (device < SNDRV_PCM_DEVICES) {
                                if (snd_pcm_search(card, device))
@@ -76,7 +77,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
                        }
                        if (device == SNDRV_PCM_DEVICES)
                                device = -1;
-                       up(&register_mutex);
+                       mutex_unlock(&register_mutex);
                        if (put_user(device, (int __user *)arg))
                                return -EFAULT;
                        return 0;
@@ -100,7 +101,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
                                return -EINVAL;
                        if (get_user(subdevice, &info->subdevice))
                                return -EFAULT;
-                       down(&register_mutex);
+                       mutex_lock(&register_mutex);
                        pcm = snd_pcm_search(card, device);
                        if (pcm == NULL) {
                                err = -ENXIO;
@@ -125,7 +126,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
                        }
                        err = snd_pcm_info_user(substream, info);
                _error:
-                       up(&register_mutex);
+                       mutex_unlock(&register_mutex);
                        return err;
                }
        case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
@@ -140,6 +141,9 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
        }
        return -ENOIOCTLCMD;
 }
+
+#ifdef CONFIG_SND_VERBOSE_PROCFS
+
 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
 #define READY(v) [SNDRV_PCM_READY_##v] = #v
@@ -192,12 +196,11 @@ static char *snd_pcm_format_names[] = {
        FORMAT(U18_3BE),
 };
 
-const char *snd_pcm_format_name(snd_pcm_format_t format)
+static const char *snd_pcm_format_name(snd_pcm_format_t format)
 {
        return snd_pcm_format_names[format];
 }
 
-#ifdef CONFIG_PROC_FS
 static char *snd_pcm_stream_names[] = {
        STREAM(PLAYBACK),
        STREAM(CAPTURE),
@@ -260,6 +263,7 @@ static const char *snd_pcm_state_name(snd_pcm_state_t state)
 
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 #include <linux/soundcard.h>
+
 static const char *snd_pcm_oss_format_name(int format)
 {
        switch (format) {
@@ -347,10 +351,8 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
                snd_iprintf(buffer, "closed\n");
                return;
        }
-       snd_pcm_stream_lock_irq(substream);
        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
                snd_iprintf(buffer, "no setup\n");
-               snd_pcm_stream_unlock_irq(substream);
                return;
        }
        snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
@@ -371,7 +373,6 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
                snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
        }
 #endif
-       snd_pcm_stream_unlock_irq(substream);
 }
 
 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
@@ -383,10 +384,8 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
                snd_iprintf(buffer, "closed\n");
                return;
        }
-       snd_pcm_stream_lock_irq(substream);
        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
                snd_iprintf(buffer, "no setup\n");
-               snd_pcm_stream_unlock_irq(substream);
                return;
        }
        snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
@@ -399,7 +398,6 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
        snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
        snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
        snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
-       snd_pcm_stream_unlock_irq(substream);
 }
 
 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
@@ -432,7 +430,7 @@ static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
        snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
 }
 
-#ifdef CONFIG_SND_DEBUG
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
                                    struct snd_info_buffer *buffer)
 {
@@ -468,7 +466,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
        pstr->proc_root = entry;
 
        if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
-               snd_info_set_text_ops(entry, pstr, 256, snd_pcm_stream_proc_info_read);
+               snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -476,12 +474,10 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
        }
        pstr->proc_info_entry = entry;
 
-#ifdef CONFIG_SND_DEBUG
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
        if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
                                                pstr->proc_root)) != NULL) {
-               entry->c.text.read_size = 64;
                entry->c.text.read = snd_pcm_xrun_debug_read;
-               entry->c.text.write_size = 64;
                entry->c.text.write = snd_pcm_xrun_debug_write;
                entry->mode |= S_IWUSR;
                entry->private_data = pstr;
@@ -497,7 +493,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
 
 static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
 {
-#ifdef CONFIG_SND_DEBUG
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
        if (pstr->proc_xrun_debug_entry) {
                snd_info_unregister(pstr->proc_xrun_debug_entry);
                pstr->proc_xrun_debug_entry = NULL;
@@ -533,7 +529,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
        substream->proc_root = entry;
 
        if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
-               snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_info_read);
+               snd_info_set_text_ops(entry, substream,
+                                     snd_pcm_substream_proc_info_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -542,7 +539,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
        substream->proc_info_entry = entry;
 
        if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
-               snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_hw_params_read);
+               snd_info_set_text_ops(entry, substream,
+                                     snd_pcm_substream_proc_hw_params_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -551,7 +549,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
        substream->proc_hw_params_entry = entry;
 
        if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
-               snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_sw_params_read);
+               snd_info_set_text_ops(entry, substream,
+                                     snd_pcm_substream_proc_sw_params_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -560,7 +559,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
        substream->proc_sw_params_entry = entry;
 
        if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
-               snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_status_read);
+               snd_info_set_text_ops(entry, substream,
+                                     snd_pcm_substream_proc_status_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -595,12 +595,12 @@ static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream)
        }
        return 0;
 }
-#else /* !CONFIG_PROC_FS */
+#else /* !CONFIG_SND_VERBOSE_PROCFS */
 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; }
-#endif /* CONFIG_PROC_FS */
+#endif /* CONFIG_SND_VERBOSE_PROCFS */
 
 /**
  * snd_pcm_new_stream - create a new PCM stream
@@ -622,7 +622,7 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
        struct snd_pcm_substream *substream, *prev;
 
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
-       init_MUTEX(&pstr->oss.setup_mutex);
+       mutex_init(&pstr->oss.setup_mutex);
 #endif
        pstr->stream = stream;
        pstr->pcm = pcm;
@@ -667,6 +667,8 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
        return 0;
 }                              
 
+EXPORT_SYMBOL(snd_pcm_new_stream);
+
 /**
  * snd_pcm_new - create a new PCM instance
  * @card: the card instance
@@ -716,7 +718,7 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
                snd_pcm_free(pcm);
                return err;
        }
-       init_MUTEX(&pcm->open_mutex);
+       mutex_init(&pcm->open_mutex);
        init_waitqueue_head(&pcm->open_wait);
        if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {
                snd_pcm_free(pcm);
@@ -726,6 +728,8 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_new);
+
 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 {
        struct snd_pcm_substream *substream, *substream_next;
@@ -773,8 +777,9 @@ static void snd_pcm_tick_timer_func(unsigned long data)
        snd_pcm_tick_elapsed(substream);
 }
 
-int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
-                          struct snd_pcm_substream **rsubstream)
+int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
+                            struct file *file,
+                            struct snd_pcm_substream **rsubstream)
 {
        struct snd_pcm_str * pstr;
        struct snd_pcm_substream *substream;
@@ -789,7 +794,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
        *rsubstream = NULL;
        snd_assert(pcm != NULL, return -ENXIO);
        pstr = &pcm->streams[stream];
-       if (pstr->substream == NULL)
+       if (pstr->substream == NULL || pstr->substream_count == 0)
                return -ENODEV;
 
        card = pcm->card;
@@ -803,8 +808,6 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
        }
        up_read(&card->controls_rwsem);
 
-       if (pstr->substream_count == 0)
-               return -ENODEV;
        switch (stream) {
        case SNDRV_PCM_STREAM_PLAYBACK:
                if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
@@ -870,12 +873,13 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
 
        substream->runtime = runtime;
        substream->private_data = pcm->private_data;
+       substream->ffile = file;
        pstr->substream_opened++;
        *rsubstream = substream;
        return 0;
 }
 
-void snd_pcm_release_substream(struct snd_pcm_substream *substream)
+void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
 {
        struct snd_pcm_runtime *runtime;
        substream->file = NULL;
@@ -902,9 +906,9 @@ static int snd_pcm_dev_register(struct snd_device *device)
        struct snd_pcm *pcm = device->device_data;
 
        snd_assert(pcm != NULL && device != NULL, return -ENXIO);
-       down(&register_mutex);
+       mutex_lock(&register_mutex);
        if (snd_pcm_search(pcm->card, pcm->device)) {
-               up(&register_mutex);
+               mutex_unlock(&register_mutex);
                return -EBUSY;
        }
        list_add_tail(&pcm->list, &snd_pcm_devices);
@@ -928,7 +932,7 @@ static int snd_pcm_dev_register(struct snd_device *device)
                                               pcm, str)) < 0)
                {
                        list_del(&pcm->list);
-                       up(&register_mutex);
+                       mutex_unlock(&register_mutex);
                        return err;
                }
                for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
@@ -939,7 +943,7 @@ static int snd_pcm_dev_register(struct snd_device *device)
                notify = list_entry(list, struct snd_pcm_notify, list);
                notify->n_register(pcm);
        }
-       up(&register_mutex);
+       mutex_unlock(&register_mutex);
        return 0;
 }
 
@@ -950,7 +954,7 @@ static int snd_pcm_dev_disconnect(struct snd_device *device)
        struct snd_pcm_substream *substream;
        int cidx;
 
-       down(&register_mutex);
+       mutex_lock(&register_mutex);
        list_del_init(&pcm->list);
        for (cidx = 0; cidx < 2; cidx++)
                for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
@@ -961,7 +965,7 @@ static int snd_pcm_dev_disconnect(struct snd_device *device)
                notify = list_entry(list, struct snd_pcm_notify, list);
                notify->n_disconnect(pcm);
        }
-       up(&register_mutex);
+       mutex_unlock(&register_mutex);
        return 0;
 }
 
@@ -973,7 +977,7 @@ static int snd_pcm_dev_unregister(struct snd_device *device)
        struct snd_pcm *pcm = device->device_data;
 
        snd_assert(pcm != NULL, return -ENXIO);
-       down(&register_mutex);
+       mutex_lock(&register_mutex);
        list_del(&pcm->list);
        for (cidx = 0; cidx < 2; cidx++) {
                devtype = -1;
@@ -994,7 +998,7 @@ static int snd_pcm_dev_unregister(struct snd_device *device)
                notify = list_entry(list, struct snd_pcm_notify, list);
                notify->n_unregister(pcm);
        }
-       up(&register_mutex);
+       mutex_unlock(&register_mutex);
        return snd_pcm_free(pcm);
 }
 
@@ -1003,7 +1007,7 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
        struct list_head *p;
 
        snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL);
-       down(&register_mutex);
+       mutex_lock(&register_mutex);
        if (nfree) {
                list_del(&notify->list);
                list_for_each(p, &snd_pcm_devices)
@@ -1014,10 +1018,12 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
                list_for_each(p, &snd_pcm_devices)
                        notify->n_register(list_entry(p, struct snd_pcm, list));
        }
-       up(&register_mutex);
+       mutex_unlock(&register_mutex);
        return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_notify);
+
 #ifdef CONFIG_PROC_FS
 /*
  *  Info interface
@@ -1029,7 +1035,7 @@ static void snd_pcm_proc_read(struct snd_info_entry *entry,
        struct list_head *p;
        struct snd_pcm *pcm;
 
-       down(&register_mutex);
+       mutex_lock(&register_mutex);
        list_for_each(p, &snd_pcm_devices) {
                pcm = list_entry(p, struct snd_pcm, list);
                snd_iprintf(buffer, "%02i-%02i: %s : %s",
@@ -1042,7 +1048,7 @@ static void snd_pcm_proc_read(struct snd_info_entry *entry,
                                    pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
                snd_iprintf(buffer, "\n");
        }
-       up(&register_mutex);
+       mutex_unlock(&register_mutex);
 }
 
 static struct snd_info_entry *snd_pcm_proc_entry = NULL;
@@ -1052,8 +1058,7 @@ static void snd_pcm_proc_init(void)
        struct snd_info_entry *entry;
 
        if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
-               snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128,
-                                     snd_pcm_proc_read);
+               snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
                if (snd_info_register(entry) < 0) {
                        snd_info_free_entry(entry);
                        entry = NULL;
@@ -1095,36 +1100,3 @@ static void __exit alsa_pcm_exit(void)
 
 module_init(alsa_pcm_init)
 module_exit(alsa_pcm_exit)
-
-EXPORT_SYMBOL(snd_pcm_new);
-EXPORT_SYMBOL(snd_pcm_new_stream);
-EXPORT_SYMBOL(snd_pcm_notify);
-EXPORT_SYMBOL(snd_pcm_open_substream);
-EXPORT_SYMBOL(snd_pcm_release_substream);
-EXPORT_SYMBOL(snd_pcm_format_name);
-  /* pcm_native.c */
-EXPORT_SYMBOL(snd_pcm_link_rwlock);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_pcm_suspend);
-EXPORT_SYMBOL(snd_pcm_suspend_all);
-#endif
-EXPORT_SYMBOL(snd_pcm_kernel_playback_ioctl);
-EXPORT_SYMBOL(snd_pcm_kernel_capture_ioctl);
-EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
-EXPORT_SYMBOL(snd_pcm_mmap_data);
-#if SNDRV_PCM_INFO_MMAP_IOMEM
-EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
-#endif
- /* pcm_misc.c */
-EXPORT_SYMBOL(snd_pcm_format_signed);
-EXPORT_SYMBOL(snd_pcm_format_unsigned);
-EXPORT_SYMBOL(snd_pcm_format_linear);
-EXPORT_SYMBOL(snd_pcm_format_little_endian);
-EXPORT_SYMBOL(snd_pcm_format_big_endian);
-EXPORT_SYMBOL(snd_pcm_format_width);
-EXPORT_SYMBOL(snd_pcm_format_physical_width);
-EXPORT_SYMBOL(snd_pcm_format_size);
-EXPORT_SYMBOL(snd_pcm_format_silence_64);
-EXPORT_SYMBOL(snd_pcm_format_set_silence);
-EXPORT_SYMBOL(snd_pcm_build_linear_format);
-EXPORT_SYMBOL(snd_pcm_limit_hw_rates);