ALSA: hda/core: 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-9-tiwai@suse.de

diff --git a/sound/hda/core/bus.c b/sound/hda/core/bus.c
index d497414a5538fab86717a5a58f087fe4b454cbd7..9b196c915f37837011f26fa27d85d518958be675 100644 (file)
--- a/sound/hda/core/bus.c
+++ b/sound/hda/core/bus.c
@@ -87,12 +87,8 @@ EXPORT_SYMBOL_GPL(snd_hdac_bus_exit);
 int snd_hdac_bus_exec_verb(struct hdac_bus *bus, unsigned int addr,
                           unsigned int cmd, unsigned int *res)
 {
-       int err;
-
-       mutex_lock(&bus->cmd_mutex);
-       err = snd_hdac_bus_exec_verb_unlocked(bus, addr, cmd, res);
-       mutex_unlock(&bus->cmd_mutex);
-       return err;
+       guard(mutex)(&bus->cmd_mutex);
+       return snd_hdac_bus_exec_verb_unlocked(bus, addr, cmd, res);
 }
 
 /**

diff --git a/sound/hda/core/component.c b/sound/hda/core/component.c
index 9c82a2864a2fbe2fd06bc6c21541d9a8b8ffbdf8..04755903880e6bb0b31cf537c9799cc4aca85a63 100644 (file)
--- a/sound/hda/core/component.c
+++ b/sound/hda/core/component.c
@@ -69,14 +69,14 @@ void snd_hdac_display_power(struct hdac_bus *bus, unsigned int idx, bool enable)
 
        dev_dbg(bus->dev, "display power %s\n", str_enable_disable(enable));
 
-       mutex_lock(&bus->lock);
+       guard(mutex)(&bus->lock);
        if (enable)
                set_bit(idx, &bus->display_power_status);
        else
                clear_bit(idx, &bus->display_power_status);
 
        if (!acomp || !acomp->ops)
-               goto unlock;
+               return;
 
        if (bus->display_power_status) {
                if (!bus->display_power_active) {
@@ -99,8 +99,6 @@ void snd_hdac_display_power(struct hdac_bus *bus, unsigned int idx, bool enable)
                        bus->display_power_active = 0;
                }
        }
- unlock:
-       mutex_unlock(&bus->lock);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_display_power);
 

diff --git a/sound/hda/core/device.c b/sound/hda/core/device.c
index 018f9e176b1b8b7badf438178547179b5c0bdfd4..160c8d0453b0e438f14581134baa6a0d463b794f 100644 (file)
--- a/sound/hda/core/device.c
+++ b/sound/hda/core/device.c
@@ -147,9 +147,9 @@ int snd_hdac_device_register(struct hdac_device *codec)
        err = device_add(&codec->dev);
        if (err < 0)
                return err;
-       mutex_lock(&codec->widget_lock);
-       err = hda_widget_sysfs_init(codec);
-       mutex_unlock(&codec->widget_lock);
+       scoped_guard(mutex, &codec->widget_lock) {
+               err = hda_widget_sysfs_init(codec);
+       }
        if (err < 0) {
                device_del(&codec->dev);
                return err;
@@ -166,9 +166,9 @@ EXPORT_SYMBOL_GPL(snd_hdac_device_register);
 void snd_hdac_device_unregister(struct hdac_device *codec)
 {
        if (device_is_registered(&codec->dev)) {
-               mutex_lock(&codec->widget_lock);
-               hda_widget_sysfs_exit(codec);
-               mutex_unlock(&codec->widget_lock);
+               scoped_guard(mutex, &codec->widget_lock) {
+                       hda_widget_sysfs_exit(codec);
+               }
                device_del(&codec->dev);
                snd_hdac_bus_remove_device(codec->bus, codec);
        }
@@ -411,25 +411,22 @@ int snd_hdac_refresh_widgets(struct hdac_device *codec)
         * Serialize against multiple threads trying to update the sysfs
         * widgets array.
         */
-       mutex_lock(&codec->widget_lock);
+       guard(mutex)(&codec->widget_lock);
        nums = snd_hdac_get_sub_nodes(codec, codec->afg, &start_nid);
        if (!start_nid || nums <= 0 || nums >= 0xff) {
                dev_err(&codec->dev, "cannot read sub nodes for FG 0x%02x\n",
                        codec->afg);
-               err = -EINVAL;
-               goto unlock;
+               return -EINVAL;
        }
 
        err = hda_widget_sysfs_reinit(codec, start_nid, nums);
        if (err < 0)
-               goto unlock;
+               return err;
 
        codec->num_nodes = nums;
        codec->start_nid = start_nid;
        codec->end_nid = start_nid + nums;
-unlock:
-       mutex_unlock(&codec->widget_lock);
-       return err;
+       return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_refresh_widgets);
 

diff --git a/sound/hda/core/ext/controller.c b/sound/hda/core/ext/controller.c
index c84754434d1627af3a0e2977ee7b03a8a7234492..9eea3ea2dae0d55281f4a829ea7ca44237fb874d 100644 (file)
--- a/sound/hda/core/ext/controller.c
+++ b/sound/hda/core/ext/controller.c
@@ -300,7 +300,7 @@ int snd_hdac_ext_bus_link_get(struct hdac_bus *bus,
        unsigned long codec_mask;
        int ret = 0;
 
-       mutex_lock(&bus->lock);
+       guard(mutex)(&bus->lock);
 
        /*
         * if we move from 0 to 1, count will be 1 so power up this link
@@ -331,7 +331,6 @@ int snd_hdac_ext_bus_link_get(struct hdac_bus *bus,
                        bus->codec_mask = codec_mask;
        }
 
-       mutex_unlock(&bus->lock);
        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_get);
@@ -343,7 +342,7 @@ int snd_hdac_ext_bus_link_put(struct hdac_bus *bus,
        struct hdac_ext_link *hlink_tmp;
        bool link_up = false;
 
-       mutex_lock(&bus->lock);
+       guard(mutex)(&bus->lock);
 
        /*
         * if we move from 1 to 0, count will be 0
@@ -369,7 +368,6 @@ int snd_hdac_ext_bus_link_put(struct hdac_bus *bus,
                }
        }
 
-       mutex_unlock(&bus->lock);
        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_put);

diff --git a/sound/hda/core/regmap.c b/sound/hda/core/regmap.c
index 97cee096a2864fcd6740946ac1ac96e9d1a7fcfc..e7b866fc52c1575b1d5ab26c855901117d624816 100644 (file)
--- a/sound/hda/core/regmap.c
+++ b/sound/hda/core/regmap.c
@@ -425,15 +425,11 @@ EXPORT_SYMBOL_GPL(snd_hdac_regmap_add_vendor_verb);
 static int reg_raw_write(struct hdac_device *codec, unsigned int reg,
                         unsigned int val)
 {
-       int err;
-
-       mutex_lock(&codec->regmap_lock);
+       guard(mutex)(&codec->regmap_lock);
        if (!codec->regmap)
-               err = hda_reg_write(codec, reg, val);
+               return hda_reg_write(codec, reg, val);
        else
-               err = regmap_write(codec->regmap, reg, val);
-       mutex_unlock(&codec->regmap_lock);
-       return err;
+               return regmap_write(codec->regmap, reg, val);
 }
 
 /* a helper macro to call @func_call; retry with power-up if failed */
@@ -466,15 +462,11 @@ EXPORT_SYMBOL_GPL(snd_hdac_regmap_write_raw);
 static int reg_raw_read(struct hdac_device *codec, unsigned int reg,
                        unsigned int *val, bool uncached)
 {
-       int err;
-
-       mutex_lock(&codec->regmap_lock);
+       guard(mutex)(&codec->regmap_lock);
        if (uncached || !codec->regmap)
-               err = hda_reg_read(codec, reg, val);
+               return hda_reg_read(codec, reg, val);
        else
-               err = regmap_read(codec->regmap, reg, val);
-       mutex_unlock(&codec->regmap_lock);
-       return err;
+               return regmap_read(codec->regmap, reg, val);
 }
 
 static int __snd_hdac_regmap_read_raw(struct hdac_device *codec,
@@ -515,7 +507,7 @@ static int reg_raw_update(struct hdac_device *codec, unsigned int reg,
        bool change;
        int err;
 
-       mutex_lock(&codec->regmap_lock);
+       guard(mutex)(&codec->regmap_lock);
        if (codec->regmap) {
                err = regmap_update_bits_check(codec->regmap, reg, mask, val,
                                               &change);
@@ -533,7 +525,6 @@ static int reg_raw_update(struct hdac_device *codec, unsigned int reg,
                        }
                }
        }
-       mutex_unlock(&codec->regmap_lock);
        return err;
 }
 
@@ -556,17 +547,14 @@ EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw);
 static int reg_raw_update_once(struct hdac_device *codec, unsigned int reg,
                               unsigned int mask, unsigned int val)
 {
-       int err = 0;
-
        if (!codec->regmap)
                return reg_raw_update(codec, reg, mask, val);
 
-       mutex_lock(&codec->regmap_lock);
+       guard(mutex)(&codec->regmap_lock);
        /* Discard any updates to already initialised registers. */
        if (!regcache_reg_cached(codec->regmap, reg))
-               err = regmap_update_bits(codec->regmap, reg, mask, val);
-       mutex_unlock(&codec->regmap_lock);
-       return err;
+               return regmap_update_bits(codec->regmap, reg, mask, val);
+       return 0;
 }
 
 /**
@@ -593,9 +581,8 @@ EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw_once);
  */
 void snd_hdac_regmap_sync(struct hdac_device *codec)
 {
-       mutex_lock(&codec->regmap_lock);
+       guard(mutex)(&codec->regmap_lock);
        if (codec->regmap)
                regcache_sync(codec->regmap);
-       mutex_unlock(&codec->regmap_lock);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_regmap_sync);