iio: magnetometer: bmc150_magn: use automated cleanup for mutex

Use guard() and scoped_guard() to replace manual mutex lock/unlock
calls. This simplifies error handling and ensures RAII-style cleanup.

guard() is used in read_raw, write_raw, trig_reen, and
trigger_set_state. Case blocks using guard() in read_raw and write_raw
are wrapped in braces at the case label level to ensure clear scope for
the cleanup guards.

A bmc150_magn_set_power_mode_locked() helper is added to deduplicate
the lock-call-unlock pattern used by remove, runtime_suspend, suspend,
and resume.

The trigger_handler function is left unchanged as mixing guard() with
goto error paths can be fragile.

Signed-off-by: Neel Bullywon <neelb2403@gmail.com>
Acked-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/magnetometer/bmc150_magn.c b/drivers/iio/magnetometer/bmc150_magn.c
index 04c4619dfc24e6c7e7c9975e26a22a27546bf9bd..bf255198800897755db8b786978597731afa4fa1 100644 (file)
--- a/drivers/iio/magnetometer/bmc150_magn.c
+++ b/drivers/iio/magnetometer/bmc150_magn.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
+#include <linux/cleanup.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/pm.h>
@@ -257,6 +258,13 @@ static int bmc150_magn_set_power_mode(struct bmc150_magn_data *data,
        return -EINVAL;
 }
 
+static int bmc150_magn_set_power_mode_locked(struct bmc150_magn_data *data,
+                                            enum bmc150_magn_power_modes mode)
+{
+       guard(mutex)(&data->mutex);
+       return bmc150_magn_set_power_mode(data, mode, true);
+}
+
 static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on)
 {
        int ret = 0;
@@ -455,33 +463,29 @@ static int bmc150_magn_read_raw(struct iio_dev *indio_dev,
        s32 values[AXIS_XYZ_MAX];
 
        switch (mask) {
-       case IIO_CHAN_INFO_RAW:
+       case IIO_CHAN_INFO_RAW: {
                if (iio_buffer_enabled(indio_dev))
                        return -EBUSY;
-               mutex_lock(&data->mutex);
+
+               guard(mutex)(&data->mutex);
 
                ret = bmc150_magn_set_power_state(data, true);
-               if (ret < 0) {
-                       mutex_unlock(&data->mutex);
+               if (ret < 0)
                        return ret;
-               }
 
                ret = bmc150_magn_read_xyz(data, values);
                if (ret < 0) {
                        bmc150_magn_set_power_state(data, false);
-                       mutex_unlock(&data->mutex);
                        return ret;
                }
                *val = values[chan->scan_index];
 
                ret = bmc150_magn_set_power_state(data, false);
-               if (ret < 0) {
-                       mutex_unlock(&data->mutex);
+               if (ret < 0)
                        return ret;
-               }
 
-               mutex_unlock(&data->mutex);
                return IIO_VAL_INT;
+       }
        case IIO_CHAN_INFO_SCALE:
                /*
                 * The API/driver performs an off-chip temperature
@@ -529,48 +533,39 @@ static int bmc150_magn_write_raw(struct iio_dev *indio_dev,
        int ret;
 
        switch (mask) {
-       case IIO_CHAN_INFO_SAMP_FREQ:
+       case IIO_CHAN_INFO_SAMP_FREQ: {
                if (val > data->max_odr)
                        return -EINVAL;
-               mutex_lock(&data->mutex);
-               ret = bmc150_magn_set_odr(data, val);
-               mutex_unlock(&data->mutex);
-               return ret;
+               guard(mutex)(&data->mutex);
+               return bmc150_magn_set_odr(data, val);
+       }
        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
                switch (chan->channel2) {
                case IIO_MOD_X:
-               case IIO_MOD_Y:
+               case IIO_MOD_Y: {
                        if (val < 1 || val > 511)
                                return -EINVAL;
-                       mutex_lock(&data->mutex);
+                       guard(mutex)(&data->mutex);
                        ret = bmc150_magn_set_max_odr(data, val, 0, 0);
-                       if (ret < 0) {
-                               mutex_unlock(&data->mutex);
+                       if (ret < 0)
                                return ret;
-                       }
-                       ret = regmap_update_bits(data->regmap,
+                       return regmap_update_bits(data->regmap,
                                                 BMC150_MAGN_REG_REP_XY,
                                                 BMC150_MAGN_REG_REP_DATAMASK,
-                                                BMC150_MAGN_REPXY_TO_REGVAL
-                                                (val));
-                       mutex_unlock(&data->mutex);
-                       return ret;
-               case IIO_MOD_Z:
+                                                BMC150_MAGN_REPXY_TO_REGVAL(val));
+               }
+               case IIO_MOD_Z: {
                        if (val < 1 || val > 256)
                                return -EINVAL;
-                       mutex_lock(&data->mutex);
+                       guard(mutex)(&data->mutex);
                        ret = bmc150_magn_set_max_odr(data, 0, val, 0);
-                       if (ret < 0) {
-                               mutex_unlock(&data->mutex);
+                       if (ret < 0)
                                return ret;
-                       }
-                       ret = regmap_update_bits(data->regmap,
+                       return regmap_update_bits(data->regmap,
                                                 BMC150_MAGN_REG_REP_Z,
                                                 BMC150_MAGN_REG_REP_DATAMASK,
-                                                BMC150_MAGN_REPZ_TO_REGVAL
-                                                (val));
-                       mutex_unlock(&data->mutex);
-                       return ret;
+                                                BMC150_MAGN_REPZ_TO_REGVAL(val));
+               }
                default:
                        return -EINVAL;
                }
@@ -785,9 +780,8 @@ static void bmc150_magn_trig_reen(struct iio_trigger *trig)
        if (!data->dready_trigger_on)
                return;
 
-       mutex_lock(&data->mutex);
+       guard(mutex)(&data->mutex);
        ret = bmc150_magn_reset_intr(data);
-       mutex_unlock(&data->mutex);
        if (ret)
                dev_err(data->dev, "Failed to reset interrupt\n");
 }
@@ -797,32 +791,28 @@ static int bmc150_magn_data_rdy_trigger_set_state(struct iio_trigger *trig,
 {
        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
-       int ret = 0;
+       int ret;
+
+       guard(mutex)(&data->mutex);
 
-       mutex_lock(&data->mutex);
        if (state == data->dready_trigger_on)
-               goto err_unlock;
+               return 0;
 
        ret = regmap_update_bits(data->regmap, BMC150_MAGN_REG_INT_DRDY,
                                 BMC150_MAGN_MASK_DRDY_EN,
                                 state << BMC150_MAGN_SHIFT_DRDY_EN);
        if (ret < 0)
-               goto err_unlock;
+               return ret;
 
        data->dready_trigger_on = state;
 
        if (state) {
                ret = bmc150_magn_reset_intr(data);
                if (ret < 0)
-                       goto err_unlock;
+                       return ret;
        }
-       mutex_unlock(&data->mutex);
 
        return 0;
-
-err_unlock:
-       mutex_unlock(&data->mutex);
-       return ret;
 }
 
 static const struct iio_trigger_ops bmc150_magn_trigger_ops = {
@@ -980,9 +970,7 @@ void bmc150_magn_remove(struct device *dev)
        if (data->dready_trig)
                iio_trigger_unregister(data->dready_trig);
 
-       mutex_lock(&data->mutex);
-       bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SUSPEND, true);
-       mutex_unlock(&data->mutex);
+       bmc150_magn_set_power_mode_locked(data, BMC150_MAGN_POWER_MODE_SUSPEND);
 
        regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators);
 }
@@ -995,10 +983,8 @@ static int bmc150_magn_runtime_suspend(struct device *dev)
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        int ret;
 
-       mutex_lock(&data->mutex);
-       ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SLEEP,
-                                        true);
-       mutex_unlock(&data->mutex);
+       ret = bmc150_magn_set_power_mode_locked(data,
+                                               BMC150_MAGN_POWER_MODE_SLEEP);
        if (ret < 0) {
                dev_err(dev, "powering off device failed\n");
                return ret;
@@ -1024,28 +1010,18 @@ static int bmc150_magn_suspend(struct device *dev)
 {
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
-       int ret;
 
-       mutex_lock(&data->mutex);
-       ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SLEEP,
-                                        true);
-       mutex_unlock(&data->mutex);
-
-       return ret;
+       return bmc150_magn_set_power_mode_locked(data,
+                                                BMC150_MAGN_POWER_MODE_SLEEP);
 }
 
 static int bmc150_magn_resume(struct device *dev)
 {
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
-       int ret;
 
-       mutex_lock(&data->mutex);
-       ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_NORMAL,
-                                        true);
-       mutex_unlock(&data->mutex);
-
-       return ret;
+       return bmc150_magn_set_power_mode_locked(data,
+                                                BMC150_MAGN_POWER_MODE_NORMAL);
 }
 #endif