ALSA: hda/common: Use guard() for mutex locks

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

Only code refactoring, and no behavior change.

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

diff --git a/sound/hda/common/codec.c b/sound/hda/common/codec.c
index 3e692dd6725e17703813c8df14a6c3c1d043857f..022086f8d4df606c265f5986c5aa2f980c245f57 100644 (file)
--- a/sound/hda/common/codec.c
+++ b/sound/hda/common/codec.c
@@ -39,13 +39,12 @@ static int call_exec_verb(struct hda_bus *bus, struct hda_codec *codec,
        int err;
 
        CLASS(snd_hda_power_pm, pm)(codec);
-       mutex_lock(&bus->core.cmd_mutex);
+       guard(mutex)(&bus->core.cmd_mutex);
        if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
                bus->no_response_fallback = 1;
        err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
                                              cmd, res);
        bus->no_response_fallback = 0;
-       mutex_unlock(&bus->core.cmd_mutex);
        return err;
 }
 
@@ -531,11 +530,11 @@ unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
 #ifdef CONFIG_SND_HDA_RECONFIG
        {
                unsigned int cfg = 0;
-               mutex_lock(&codec->user_mutex);
-               pin = look_up_pincfg(codec, &codec->user_pins, nid);
-               if (pin)
-                       cfg = pin->cfg;
-               mutex_unlock(&codec->user_mutex);
+               scoped_guard(mutex, &codec->user_mutex) {
+                       pin = look_up_pincfg(codec, &codec->user_pins, nid);
+                       if (pin)
+                               cfg = pin->cfg;
+               }
                if (cfg)
                        return cfg;
        }
@@ -2179,13 +2178,12 @@ static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return -EINVAL;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        ucontrol->value.iec958.status[0] = spdif->status & 0xff;
        ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
        ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
        ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
-       mutex_unlock(&codec->spdif_mutex);
 
        return 0;
 }
@@ -2288,7 +2286,7 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return -EINVAL;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        nid = spdif->nid;
        spdif->status = ucontrol->value.iec958.status[0] |
@@ -2301,7 +2299,6 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
        spdif->ctls = val;
        if (change && nid != (u16)-1)
                set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
-       mutex_unlock(&codec->spdif_mutex);
        return change;
 }
 
@@ -2316,10 +2313,9 @@ static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return -EINVAL;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 
@@ -2346,7 +2342,7 @@ static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return -EINVAL;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        nid = spdif->nid;
        val = spdif->ctls & ~AC_DIG1_ENABLE;
@@ -2356,7 +2352,6 @@ static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
        spdif->ctls = val;
        if (change && nid != (u16)-1)
                set_spdif_ctls(codec, nid, val & 0xff, -1);
-       mutex_unlock(&codec->spdif_mutex);
        return change;
 }
 
@@ -2501,10 +2496,9 @@ void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        spdif->nid = (u16)-1;
-       mutex_unlock(&codec->spdif_mutex);
 }
 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
 
@@ -2523,14 +2517,13 @@ void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
 
        if (WARN_ON(codec->spdif_out.used <= idx))
                return;
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        spdif = snd_array_elem(&codec->spdif_out, idx);
        if (spdif->nid != nid) {
                spdif->nid = nid;
                val = spdif->ctls;
                set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
        }
-       mutex_unlock(&codec->spdif_mutex);
 }
 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
 
@@ -2605,14 +2598,13 @@ static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
        unsigned int val = !!ucontrol->value.integer.value[0];
        int change;
 
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        change = codec->spdif_in_enable != val;
        if (change) {
                codec->spdif_in_enable = val;
                snd_hdac_regmap_write(&codec->core, nid,
                                      AC_VERB_SET_DIGI_CONVERT_1, val);
        }
-       mutex_unlock(&codec->spdif_mutex);
        return change;
 }
 
@@ -3182,7 +3174,8 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
                          struct snd_pcm_substream *substream)
 {
        int ret;
-       mutex_lock(&codec->bus->prepare_mutex);
+
+       guard(mutex)(&codec->bus->prepare_mutex);
        if (hinfo->ops.prepare)
                ret = hinfo->ops.prepare(hinfo, codec, stream, format,
                                         substream);
@@ -3190,7 +3183,6 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
                ret = -ENODEV;
        if (ret >= 0)
                purify_inactive_streams(codec);
-       mutex_unlock(&codec->bus->prepare_mutex);
        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
@@ -3207,10 +3199,9 @@ void snd_hda_codec_cleanup(struct hda_codec *codec,
                           struct hda_pcm_stream *hinfo,
                           struct snd_pcm_substream *substream)
 {
-       mutex_lock(&codec->bus->prepare_mutex);
+       guard(mutex)(&codec->bus->prepare_mutex);
        if (hinfo->ops.cleanup)
                hinfo->ops.cleanup(hinfo, codec, substream);
-       mutex_unlock(&codec->bus->prepare_mutex);
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
 
@@ -3640,12 +3631,11 @@ static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
                               struct hda_multi_out *mout)
 {
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
                /* already opened as analog dup; reset it once */
                cleanup_dig_out_stream(codec, mout->dig_out_nid);
        mout->dig_out_used = HDA_DIG_EXCLUSIVE;
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
@@ -3664,9 +3654,8 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
                                  unsigned int format,
                                  struct snd_pcm_substream *substream)
 {
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
@@ -3679,9 +3668,8 @@ EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
                                  struct hda_multi_out *mout)
 {
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        cleanup_dig_out_stream(codec, mout->dig_out_nid);
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
@@ -3694,9 +3682,8 @@ EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
                                struct hda_multi_out *mout)
 {
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        mout->dig_out_used = 0;
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
@@ -3736,7 +3723,7 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
                                                    NULL,
                                                    &mout->spdif_maxbps);
                }
-               mutex_lock(&codec->spdif_mutex);
+               guard(mutex)(&codec->spdif_mutex);
                if (mout->share_spdif) {
                        if ((runtime->hw.rates & mout->spdif_rates) &&
                            (runtime->hw.formats & mout->spdif_formats)) {
@@ -3749,7 +3736,6 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
                                /* FIXME: need notify? */
                        }
                }
-               mutex_unlock(&codec->spdif_mutex);
        }
        return snd_pcm_hw_constraint_step(substream->runtime, 0,
                                          SNDRV_PCM_HW_PARAM_CHANNELS, 2);
@@ -3778,23 +3764,23 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
        struct hda_spdif_out *spdif;
        int i;
 
-       mutex_lock(&codec->spdif_mutex);
-       spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
-       if (mout->dig_out_nid && mout->share_spdif &&
-           mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
-               if (chs == 2 && spdif != NULL &&
-                   snd_hda_is_supported_format(codec, mout->dig_out_nid,
-                                               format) &&
-                   !(spdif->status & IEC958_AES0_NONAUDIO)) {
-                       mout->dig_out_used = HDA_DIG_ANALOG_DUP;
-                       setup_dig_out_stream(codec, mout->dig_out_nid,
-                                            stream_tag, format);
-               } else {
-                       mout->dig_out_used = 0;
-                       cleanup_dig_out_stream(codec, mout->dig_out_nid);
+       scoped_guard(mutex, &codec->spdif_mutex) {
+               spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
+               if (mout->dig_out_nid && mout->share_spdif &&
+                   mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
+                       if (chs == 2 && spdif != NULL &&
+                           snd_hda_is_supported_format(codec, mout->dig_out_nid,
+                                                       format) &&
+                           !(spdif->status & IEC958_AES0_NONAUDIO)) {
+                               mout->dig_out_used = HDA_DIG_ANALOG_DUP;
+                               setup_dig_out_stream(codec, mout->dig_out_nid,
+                                                    stream_tag, format);
+                       } else {
+                               mout->dig_out_used = 0;
+                               cleanup_dig_out_stream(codec, mout->dig_out_nid);
+                       }
                }
        }
-       mutex_unlock(&codec->spdif_mutex);
 
        /* front */
        snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
@@ -3861,12 +3847,11 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
                if (mout->extra_out_nid[i])
                        snd_hda_codec_cleanup_stream(codec,
                                                     mout->extra_out_nid[i]);
-       mutex_lock(&codec->spdif_mutex);
+       guard(mutex)(&codec->spdif_mutex);
        if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
                cleanup_dig_out_stream(codec, mout->dig_out_nid);
                mout->dig_out_used = 0;
        }
-       mutex_unlock(&codec->spdif_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);

diff --git a/sound/hda/common/controller.c b/sound/hda/common/controller.c
index ceab8625bb1f520033c87e849fbcde4c4a7b581c..a5693c9ca400c30af2360bbafbcaa9c7548c88ec 100644 (file)
--- a/sound/hda/common/controller.c
+++ b/sound/hda/common/controller.c
@@ -96,12 +96,12 @@ static int azx_pcm_close(struct snd_pcm_substream *substream)
        struct azx_dev *azx_dev = get_azx_dev(substream);
 
        trace_azx_pcm_close(chip, azx_dev);
-       mutex_lock(&chip->open_mutex);
-       azx_release_device(azx_dev);
-       if (hinfo->ops.close)
-               hinfo->ops.close(hinfo, apcm->codec, substream);
-       snd_hda_power_down(apcm->codec);
-       mutex_unlock(&chip->open_mutex);
+       scoped_guard(mutex, &chip->open_mutex) {
+               azx_release_device(azx_dev);
+               if (hinfo->ops.close)
+                       hinfo->ops.close(hinfo, apcm->codec, substream);
+               snd_hda_power_down(apcm->codec);
+       }
        snd_hda_codec_pcm_put(apcm->info);
        return 0;
 }
@@ -1129,12 +1129,12 @@ static int probe_codec(struct azx *chip, int addr)
        int err;
        unsigned int res = -1;
 
-       mutex_lock(&bus->cmd_mutex);
-       chip->probing = 1;
-       azx_send_cmd(bus, cmd);
-       err = azx_get_response(bus, addr, &res);
-       chip->probing = 0;
-       mutex_unlock(&bus->cmd_mutex);
+       scoped_guard(mutex, &bus->cmd_mutex) {
+               chip->probing = 1;
+               azx_send_cmd(bus, cmd);
+               err = azx_get_response(bus, addr, &res);
+               chip->probing = 0;
+       }
        if (err < 0 || res == -1)
                return -EIO;
        dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr);

diff --git a/sound/hda/common/sysfs.c b/sound/hda/common/sysfs.c
index 0d464d4dd7c94c183d8b66627912fb8f853fea41..555c16ea60a5ba0c51b9786e3471b3e380b807ef 100644 (file)
--- a/sound/hda/common/sysfs.c
+++ b/sound/hda/common/sysfs.c
@@ -81,12 +81,12 @@ static ssize_t pin_configs_show(struct hda_codec *codec,
 {
        const struct hda_pincfg *pin;
        int i, len = 0;
-       mutex_lock(&codec->user_mutex);
+
+       guard(mutex)(&codec->user_mutex);
        snd_array_for_each(list, i, pin) {
                len += sysfs_emit_at(buf, len, "0x%02x 0x%08x\n",
                                     pin->nid, pin->cfg);
        }
-       mutex_unlock(&codec->user_mutex);
        return len;
 }
 
@@ -215,12 +215,12 @@ static ssize_t init_verbs_show(struct device *dev,
        struct hda_codec *codec = dev_get_drvdata(dev);
        const struct hda_verb *v;
        int i, len = 0;
-       mutex_lock(&codec->user_mutex);
+
+       guard(mutex)(&codec->user_mutex);
        snd_array_for_each(&codec->init_verbs, i, v) {
                len += sysfs_emit_at(buf, len, "0x%02x 0x%03x 0x%04x\n",
                                     v->nid, v->verb, v->param);
        }
-       mutex_unlock(&codec->user_mutex);
        return len;
 }
 
@@ -233,16 +233,13 @@ static int parse_init_verbs(struct hda_codec *codec, const char *buf)
                return -EINVAL;
        if (!nid || !verb)
                return -EINVAL;
-       mutex_lock(&codec->user_mutex);
+       guard(mutex)(&codec->user_mutex);
        v = snd_array_new(&codec->init_verbs);
-       if (!v) {
-               mutex_unlock(&codec->user_mutex);
+       if (!v)
                return -ENOMEM;
-       }
        v->nid = nid;
        v->verb = verb;
        v->param = param;
-       mutex_unlock(&codec->user_mutex);
        return 0;
 }
 
@@ -264,12 +261,12 @@ static ssize_t hints_show(struct device *dev,
        struct hda_codec *codec = dev_get_drvdata(dev);
        const struct hda_hint *hint;
        int i, len = 0;
-       mutex_lock(&codec->user_mutex);
+
+       guard(mutex)(&codec->user_mutex);
        snd_array_for_each(&codec->hints, i, hint) {
                len += sysfs_emit_at(buf, len, "%s = %s\n",
                                     hint->key, hint->val);
        }
-       mutex_unlock(&codec->user_mutex);
        return len;
 }
 
@@ -324,7 +321,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
        val = skip_spaces(val);
        remove_trail_spaces(key);
        remove_trail_spaces(val);
-       mutex_lock(&codec->user_mutex);
+       guard(mutex)(&codec->user_mutex);
        hint = get_hint(codec, key);
        if (hint) {
                /* replace */
@@ -345,7 +342,6 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
                err = -ENOMEM;
        }
  unlock:
-       mutex_unlock(&codec->user_mutex);
        if (err)
                kfree(key);
        return err;
@@ -372,16 +368,14 @@ static ssize_t user_pin_configs_show(struct device *dev,
 
 static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)
 {
-       int nid, cfg, err;
+       int nid, cfg;
 
        if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
                return -EINVAL;
        if (!nid)
                return -EINVAL;
-       mutex_lock(&codec->user_mutex);
-       err = snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
-       mutex_unlock(&codec->user_mutex);
-       return err;
+       guard(mutex)(&codec->user_mutex);
+       return snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
 }
 
 static ssize_t user_pin_configs_store(struct device *dev,
@@ -429,26 +423,19 @@ EXPORT_SYMBOL_GPL(snd_hda_get_hint);
 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
 {
        const char *p;
-       int ret;
 
-       mutex_lock(&codec->user_mutex);
+       guard(mutex)(&codec->user_mutex);
        p = snd_hda_get_hint(codec, key);
        if (!p || !*p)
-               ret = -ENOENT;
-       else {
-               switch (toupper(*p)) {
-               case 'T': /* true */
-               case 'Y': /* yes */
-               case '1':
-                       ret = 1;
-                       break;
-               default:
-                       ret = 0;
-                       break;
-               }
+               return -ENOENT;
+       switch (toupper(*p)) {
+       case 'T': /* true */
+       case 'Y': /* yes */
+       case '1':
+               return 1;
+       default:
+               return 0;
        }
-       mutex_unlock(&codec->user_mutex);
-       return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hda_get_bool_hint);
 
@@ -466,20 +453,17 @@ int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
 {
        const char *p;
        unsigned long val;
-       int ret;
 
-       mutex_lock(&codec->user_mutex);
+       guard(mutex)(&codec->user_mutex);
        p = snd_hda_get_hint(codec, key);
        if (!p)
-               ret = -ENOENT;
+               return -ENOENT;
        else if (kstrtoul(p, 0, &val))
-               ret = -EINVAL;
+               return -EINVAL;
        else {
                *valp = val;
-               ret = 0;
+               return 0;
        }
-       mutex_unlock(&codec->user_mutex);
-       return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hda_get_int_hint);
 #endif /* CONFIG_SND_HDA_RECONFIG */