ALSA: aloop: Use guard() for mutex locks

Replace the manual mutex lock/unlock pairs with guard() for code
simplification.

Only code refactoring, and no behavior change.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20250829150026.6379-2-tiwai@suse.de

diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c
index a8902dc45dc117b44b7b4dad2d9b9f874c701f21..79e7f03e51e9ccc0c1c78975b38f5bf01ce60032 100644 (file)
--- a/sound/drivers/aloop.c
+++ b/sound/drivers/aloop.c
@@ -511,13 +511,12 @@ static int loopback_prepare(struct snd_pcm_substream *substream)
        dpcm->pcm_salign = salign;
        dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size);
 
-       mutex_lock(&dpcm->loopback->cable_lock);
+       guard(mutex)(&dpcm->loopback->cable_lock);
        if (!(cable->valid & ~(1 << substream->stream)) ||
             (get_setup(dpcm)->notify &&
             substream->stream == SNDRV_PCM_STREAM_PLAYBACK))
                params_change(substream);
        cable->valid |= 1 << substream->stream;
-       mutex_unlock(&dpcm->loopback->cable_lock);
 
        return 0;
 }
@@ -958,9 +957,8 @@ static int loopback_hw_free(struct snd_pcm_substream *substream)
        struct loopback_pcm *dpcm = runtime->private_data;
        struct loopback_cable *cable = dpcm->cable;
 
-       mutex_lock(&dpcm->loopback->cable_lock);
+       guard(mutex)(&dpcm->loopback->cable_lock);
        cable->valid &= ~(1 << substream->stream);
-       mutex_unlock(&dpcm->loopback->cable_lock);
        return 0;
 }
 
@@ -980,10 +978,10 @@ static int rule_format(struct snd_pcm_hw_params *params,
        struct snd_mask m;
 
        snd_mask_none(&m);
-       mutex_lock(&dpcm->loopback->cable_lock);
-       m.bits[0] = (u_int32_t)cable->hw.formats;
-       m.bits[1] = (u_int32_t)(cable->hw.formats >> 32);
-       mutex_unlock(&dpcm->loopback->cable_lock);
+       scoped_guard(mutex, &dpcm->loopback->cable_lock) {
+               m.bits[0] = (u_int32_t)cable->hw.formats;
+               m.bits[1] = (u_int32_t)(cable->hw.formats >> 32);
+       }
        return snd_mask_refine(hw_param_mask(params, rule->var), &m);
 }
 
@@ -994,10 +992,10 @@ static int rule_rate(struct snd_pcm_hw_params *params,
        struct loopback_cable *cable = dpcm->cable;
        struct snd_interval t;
 
-       mutex_lock(&dpcm->loopback->cable_lock);
-       t.min = cable->hw.rate_min;
-       t.max = cable->hw.rate_max;
-       mutex_unlock(&dpcm->loopback->cable_lock);
+       scoped_guard(mutex, &dpcm->loopback->cable_lock) {
+               t.min = cable->hw.rate_min;
+               t.max = cable->hw.rate_max;
+       }
         t.openmin = t.openmax = 0;
         t.integer = 0;
        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
@@ -1010,10 +1008,10 @@ static int rule_channels(struct snd_pcm_hw_params *params,
        struct loopback_cable *cable = dpcm->cable;
        struct snd_interval t;
 
-       mutex_lock(&dpcm->loopback->cable_lock);
-       t.min = cable->hw.channels_min;
-       t.max = cable->hw.channels_max;
-       mutex_unlock(&dpcm->loopback->cable_lock);
+       scoped_guard(mutex, &dpcm->loopback->cable_lock) {
+               t.min = cable->hw.channels_min;
+               t.max = cable->hw.channels_max;
+       }
         t.openmin = t.openmax = 0;
         t.integer = 0;
        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
@@ -1026,10 +1024,10 @@ static int rule_period_bytes(struct snd_pcm_hw_params *params,
        struct loopback_cable *cable = dpcm->cable;
        struct snd_interval t;
 
-       mutex_lock(&dpcm->loopback->cable_lock);
-       t.min = cable->hw.period_bytes_min;
-       t.max = cable->hw.period_bytes_max;
-       mutex_unlock(&dpcm->loopback->cable_lock);
+       scoped_guard(mutex, &dpcm->loopback->cable_lock) {
+               t.min = cable->hw.period_bytes_min;
+               t.max = cable->hw.period_bytes_max;
+       }
        t.openmin = 0;
        t.openmax = 0;
        t.integer = 0;
@@ -1238,12 +1236,10 @@ static int loopback_open(struct snd_pcm_substream *substream)
        int err = 0;
        int dev = get_cable_index(substream);
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
-       if (!dpcm) {
-               err = -ENOMEM;
-               goto unlock;
-       }
+       if (!dpcm)
+               return -ENOMEM;
        dpcm->loopback = loopback;
        dpcm->substream = substream;
 
@@ -1326,7 +1322,6 @@ static int loopback_open(struct snd_pcm_substream *substream)
                free_cable(substream);
                kfree(dpcm);
        }
-       mutex_unlock(&loopback->cable_lock);
        return err;
 }
 
@@ -1338,9 +1333,8 @@ static int loopback_close(struct snd_pcm_substream *substream)
 
        if (dpcm->cable->ops->close_substream)
                err = dpcm->cable->ops->close_substream(dpcm);
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        free_cable(substream);
-       mutex_unlock(&loopback->cable_lock);
        return err;
 }
 
@@ -1391,11 +1385,10 @@ static int loopback_rate_shift_get(struct snd_kcontrol *kcontrol,
 {
        struct loopback *loopback = snd_kcontrol_chip(kcontrol);
        
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        ucontrol->value.integer.value[0] =
                loopback->setup[kcontrol->id.subdevice]
                               [kcontrol->id.device].rate_shift;
-       mutex_unlock(&loopback->cable_lock);
        return 0;
 }
 
@@ -1411,14 +1404,13 @@ static int loopback_rate_shift_put(struct snd_kcontrol *kcontrol,
                val = 80000;
        if (val > 120000)
                val = 120000;   
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        if (val != loopback->setup[kcontrol->id.subdevice]
                                  [kcontrol->id.device].rate_shift) {
                loopback->setup[kcontrol->id.subdevice]
                               [kcontrol->id.device].rate_shift = val;
                change = 1;
        }
-       mutex_unlock(&loopback->cable_lock);
        return change;
 }
 
@@ -1427,11 +1419,10 @@ static int loopback_notify_get(struct snd_kcontrol *kcontrol,
 {
        struct loopback *loopback = snd_kcontrol_chip(kcontrol);
        
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        ucontrol->value.integer.value[0] =
                loopback->setup[kcontrol->id.subdevice]
                               [kcontrol->id.device].notify;
-       mutex_unlock(&loopback->cable_lock);
        return 0;
 }
 
@@ -1443,14 +1434,13 @@ static int loopback_notify_put(struct snd_kcontrol *kcontrol,
        int change = 0;
 
        val = ucontrol->value.integer.value[0] ? 1 : 0;
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        if (val != loopback->setup[kcontrol->id.subdevice]
                                [kcontrol->id.device].notify) {
                loopback->setup[kcontrol->id.subdevice]
                        [kcontrol->id.device].notify = val;
                change = 1;
        }
-       mutex_unlock(&loopback->cable_lock);
        return change;
 }
 
@@ -1462,14 +1452,13 @@ static int loopback_active_get(struct snd_kcontrol *kcontrol,
 
        unsigned int val = 0;
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        cable = loopback->cables[kcontrol->id.subdevice][kcontrol->id.device ^ 1];
        if (cable != NULL) {
                unsigned int running = cable->running ^ cable->pause;
 
                val = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 1 : 0;
        }
-       mutex_unlock(&loopback->cable_lock);
        ucontrol->value.integer.value[0] = val;
        return 0;
 }
@@ -1512,11 +1501,10 @@ static int loopback_rate_get(struct snd_kcontrol *kcontrol,
 {
        struct loopback *loopback = snd_kcontrol_chip(kcontrol);
        
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        ucontrol->value.integer.value[0] =
                loopback->setup[kcontrol->id.subdevice]
                               [kcontrol->id.device].rate;
-       mutex_unlock(&loopback->cable_lock);
        return 0;
 }
 
@@ -1536,11 +1524,10 @@ static int loopback_channels_get(struct snd_kcontrol *kcontrol,
 {
        struct loopback *loopback = snd_kcontrol_chip(kcontrol);
        
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        ucontrol->value.integer.value[0] =
                loopback->setup[kcontrol->id.subdevice]
                               [kcontrol->id.device].channels;
-       mutex_unlock(&loopback->cable_lock);
        return 0;
 }
 
@@ -1558,12 +1545,11 @@ static int loopback_access_get(struct snd_kcontrol *kcontrol,
        struct loopback *loopback = snd_kcontrol_chip(kcontrol);
        snd_pcm_access_t access;
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        access = loopback->setup[kcontrol->id.subdevice][kcontrol->id.device].access;
 
        ucontrol->value.enumerated.item[0] = !is_access_interleaved(access);
 
-       mutex_unlock(&loopback->cable_lock);
        return 0;
 }
 
@@ -1731,12 +1717,11 @@ static void print_cable_info(struct snd_info_entry *entry,
        struct loopback *loopback = entry->private_data;
        int sub, num;
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        num = entry->name[strlen(entry->name)-1];
        num = num == '0' ? 0 : 1;
        for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++)
                print_substream_info(buffer, loopback, sub, num);
-       mutex_unlock(&loopback->cable_lock);
 }
 
 static int loopback_cable_proc_new(struct loopback *loopback, int cidx)
@@ -1765,10 +1750,9 @@ static void print_timer_source_info(struct snd_info_entry *entry,
 {
        struct loopback *loopback = entry->private_data;
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        snd_iprintf(buffer, "%s\n",
                    loopback->timer_source ? loopback->timer_source : "");
-       mutex_unlock(&loopback->cable_lock);
 }
 
 static void change_timer_source_info(struct snd_info_entry *entry,
@@ -1777,10 +1761,9 @@ static void change_timer_source_info(struct snd_info_entry *entry,
        struct loopback *loopback = entry->private_data;
        char line[64];
 
-       mutex_lock(&loopback->cable_lock);
+       guard(mutex)(&loopback->cable_lock);
        if (!snd_info_get_line(buffer, line, sizeof(line)))
                loopback_set_timer_source(loopback, strim(line));
-       mutex_unlock(&loopback->cable_lock);
 }
 
 static int loopback_timer_source_proc_new(struct loopback *loopback)