[ALSA] snd-dummy - Code clean-up

Modules: Generic drivers

Clean up snd-dummy driver code.
- Make common PCM callbacks
- Simplify open callback
- Remove unnecessary irqsave in control callbacks

Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 47 insertions, 79 deletions

diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index 64ef7f62851d..8dfe5d49eafc 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -172,47 +172,33 @@ typedef struct snd_card_dummy_pcm {
 static snd_card_t *snd_dummy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
 
 
-static void snd_card_dummy_pcm_timer_start(snd_pcm_substream_t * substream)
+static inline void snd_card_dummy_pcm_timer_start(snd_card_dummy_pcm_t *dpcm)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_card_dummy_pcm_t *dpcm = runtime->private_data;
-
         dpcm->timer.expires = 1 + jiffies;
         add_timer(&dpcm->timer);
 }
 
-static void snd_card_dummy_pcm_timer_stop(snd_pcm_substream_t * substream)
+static inline void snd_card_dummy_pcm_timer_stop(snd_card_dummy_pcm_t *dpcm)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_card_dummy_pcm_t *dpcm = runtime->private_data;
-
         del_timer(&dpcm->timer);
 }
 
-static int snd_card_dummy_playback_trigger(snd_pcm_substream_t * substream,
-                                           int cmd)
+static int snd_card_dummy_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
 {
-        if (cmd == SNDRV_PCM_TRIGGER_START) {
-                snd_card_dummy_pcm_timer_start(substream);
-        } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
-                snd_card_dummy_pcm_timer_stop(substream);
-        } else {
-                return -EINVAL;
-        }
-        return 0;
-}
+        snd_pcm_runtime_t *runtime = substream->runtime;
+        snd_dummy_card_pcm_t *dpcm = runtime->private_data;
+        int err = 0;
 
-static int snd_card_dummy_capture_trigger(snd_pcm_substream_t * substream,
-                                          int cmd)
-{
+        spin_lock(&dpcm->lock);
         if (cmd == SNDRV_PCM_TRIGGER_START) {
-                snd_card_dummy_pcm_timer_start(substream);
+                snd_card_dummy_pcm_timer_start(dpcm);
         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
-                snd_card_dummy_pcm_timer_stop(substream);
+                snd_card_dummy_pcm_timer_stop(dpcm);
         } else {
-                return -EINVAL;
+                err = -EINVAL;
         }
-        return 0;
+        spin_unlock(&dpcm->lock);
+        return err;
 }
 
 static int snd_card_dummy_pcm_prepare(snd_pcm_substream_t * substream)
@@ -235,42 +221,26 @@ static int snd_card_dummy_pcm_prepare(snd_pcm_substream_t * substream)
         return 0;
 }
 
-static int snd_card_dummy_playback_prepare(snd_pcm_substream_t * substream)
-{
-        return snd_card_dummy_pcm_prepare(substream);
-}
-
-static int snd_card_dummy_capture_prepare(snd_pcm_substream_t * substream)
-{
-        return snd_card_dummy_pcm_prepare(substream);
-}
-
 static void snd_card_dummy_pcm_timer_function(unsigned long data)
 {
         snd_card_dummy_pcm_t *dpcm = (snd_card_dummy_pcm_t *)data;
         
+        spin_lock(&dpcm->lock);
         dpcm->timer.expires = 1 + jiffies;
         add_timer(&dpcm->timer);
-        spin_lock_irq(&dpcm->lock);
         dpcm->pcm_irq_pos += dpcm->pcm_jiffie;
         dpcm->pcm_buf_pos += dpcm->pcm_jiffie;
         dpcm->pcm_buf_pos %= dpcm->pcm_size;
         if (dpcm->pcm_irq_pos >= dpcm->pcm_count) {
                 dpcm->pcm_irq_pos %= dpcm->pcm_count;
+                spin_unlock(&dpcm->lock);
                 snd_pcm_period_elapsed(dpcm->substream);
+                spin_lock(&dpcm->lock);
         }
-        spin_unlock_irq(&dpcm->lock);   
+        spin_unlock(&dpcm->lock);
 }
 
-static snd_pcm_uframes_t snd_card_dummy_playback_pointer(snd_pcm_substream_t * substream)
-{
-        snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_card_dummy_pcm_t *dpcm = runtime->private_data;
-
-        return bytes_to_frames(runtime, dpcm->pcm_buf_pos);
-}
-
-static snd_pcm_uframes_t snd_card_dummy_capture_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(snd_pcm_substream_t * substream)
 {
         snd_pcm_runtime_t *runtime = substream->runtime;
         snd_card_dummy_pcm_t *dpcm = runtime->private_data;
@@ -316,8 +286,7 @@ static snd_pcm_hardware_t snd_card_dummy_capture =
 
 static void snd_card_dummy_runtime_free(snd_pcm_runtime_t *runtime)
 {
-        snd_card_dummy_pcm_t *dpcm = runtime->private_data;
-        kfree(dpcm);
+        kfree(runtime->private_data);
 }
 
 static int snd_card_dummy_hw_params(snd_pcm_substream_t * substream,
@@ -331,20 +300,29 @@ static int snd_card_dummy_hw_free(snd_pcm_substream_t * substream)
         return snd_pcm_lib_free_pages(substream);
 }
 
-static int snd_card_dummy_playback_open(snd_pcm_substream_t * substream)
+static snd_card_dummy_pcm_t *new_pcm_stream(snd_pcm_substream_t *substream)
 {
-        snd_pcm_runtime_t *runtime = substream->runtime;
         snd_card_dummy_pcm_t *dpcm;
-        int err;
 
         dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
-        if (dpcm == NULL)
-                return -ENOMEM;
+        if (! dpcm)
+                return dpcm;
         init_timer(&dpcm->timer);
         dpcm->timer.data = (unsigned long) dpcm;
         dpcm->timer.function = snd_card_dummy_pcm_timer_function;
         spin_lock_init(&dpcm->lock);
         dpcm->substream = substream;
+        return dpcm;
+}
+
+static int snd_card_dummy_playback_open(snd_pcm_substream_t * substream)
+{
+        snd_pcm_runtime_t *runtime = substream->runtime;
+        snd_card_dummy_pcm_t *dpcm;
+        int err;
+
+        if ((dpcm = new_pcm_stream(substream)) == NULL)
+                return -ENOMEM;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_dummy_runtime_free;
         runtime->hw = snd_card_dummy_playback;
@@ -368,14 +346,8 @@ static int snd_card_dummy_capture_open(snd_pcm_substream_t * substream)
         snd_card_dummy_pcm_t *dpcm;
         int err;
 
-        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
-        if (dpcm == NULL)
+        if ((dpcm = new_pcm_stream(substream)) == NULL)
                 return -ENOMEM;
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_dummy_pcm_timer_function;
-        spin_lock_init(&dpcm->lock);
-        dpcm->substream = substream;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_dummy_runtime_free;
         runtime->hw = snd_card_dummy_capture;
@@ -409,9 +381,9 @@ static snd_pcm_ops_t snd_card_dummy_playback_ops = {
         .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_card_dummy_hw_params,
         .hw_free =              snd_card_dummy_hw_free,
-        .prepare =              snd_card_dummy_playback_prepare,
-        .trigger =              snd_card_dummy_playback_trigger,
-        .pointer =              snd_card_dummy_playback_pointer,
+        .prepare =              snd_card_dummy_pcm_prepare,
+        .trigger =              snd_card_dummy_pcm_trigger,
+        .pointer =              snd_card_dummy_pcm_pointer,
 };
 
 static snd_pcm_ops_t snd_card_dummy_capture_ops = {
@@ -420,9 +392,9 @@ static snd_pcm_ops_t snd_card_dummy_capture_ops = {
         .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_card_dummy_hw_params,
         .hw_free =              snd_card_dummy_hw_free,
-        .prepare =              snd_card_dummy_capture_prepare,
-        .trigger =              snd_card_dummy_capture_trigger,
-        .pointer =              snd_card_dummy_capture_pointer,
+        .prepare =              snd_card_dummy_pcm_prepare,
+        .trigger =              snd_card_dummy_pcm_trigger,
+        .pointer =              snd_card_dummy_pcm_pointer,
 };
 
 static int __init snd_card_dummy_pcm(snd_card_dummy_t *dummy, int device, int substreams)
@@ -461,20 +433,18 @@ static int snd_dummy_volume_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t
 static int snd_dummy_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int addr = kcontrol->private_value;
 
-        spin_lock_irqsave(&dummy->mixer_lock, flags);
+        spin_lock_irq(&dummy->mixer_lock);
         ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0];
         ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1];
-        spin_unlock_irqrestore(&dummy->mixer_lock, flags);
+        spin_unlock_irq(&dummy->mixer_lock);
         return 0;
 }
 
 static int snd_dummy_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int change, addr = kcontrol->private_value;
         int left, right;
 
@@ -488,12 +458,12 @@ static int snd_dummy_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t
                 right = -50;
         if (right > 100)
                 right = 100;
-        spin_lock_irqsave(&dummy->mixer_lock, flags);
+        spin_lock_irq(&dummy->mixer_lock);
         change = dummy->mixer_volume[addr][0] != left ||
                  dummy->mixer_volume[addr][1] != right;
         dummy->mixer_volume[addr][0] = left;
         dummy->mixer_volume[addr][1] = right;
-        spin_unlock_irqrestore(&dummy->mixer_lock, flags);
+        spin_unlock_irq(&dummy->mixer_lock);
         return change;
 }
 
@@ -515,31 +485,29 @@ static int snd_dummy_capsrc_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t
 static int snd_dummy_capsrc_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int addr = kcontrol->private_value;
 
-        spin_lock_irqsave(&dummy->mixer_lock, flags);
+        spin_lock_irq(&dummy->mixer_lock);
         ucontrol->value.integer.value[0] = dummy->capture_source[addr][0];
         ucontrol->value.integer.value[1] = dummy->capture_source[addr][1];
-        spin_unlock_irqrestore(&dummy->mixer_lock, flags);
+        spin_unlock_irq(&dummy->mixer_lock);
         return 0;
 }
 
 static int snd_dummy_capsrc_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int change, addr = kcontrol->private_value;
         int left, right;
 
         left = ucontrol->value.integer.value[0] & 1;
         right = ucontrol->value.integer.value[1] & 1;
-        spin_lock_irqsave(&dummy->mixer_lock, flags);
+        spin_lock_irq(&dummy->mixer_lock);
         change = dummy->capture_source[addr][0] != left &&
                  dummy->capture_source[addr][1] != right;
         dummy->capture_source[addr][0] = left;
         dummy->capture_source[addr][1] = right;
-        spin_unlock_irqrestore(&dummy->mixer_lock, flags);
+        spin_unlock_irq(&dummy->mixer_lock);
         return change;
 }