staging: iio: resolver: ad2s1210: simplify code with guard(mutex)

We can simplify the code and get rid of most of the gotos by using
guard(mutex) from cleanup.h.

Signed-off-by: David Lechner <dlechner@baylibre.com>
Link: https://lore.kernel.org/r/20231010-ad2s1210-mainline-v5-3-35a0f6ffa04a@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/staging/iio/resolver/ad2s1210.c b/drivers/staging/iio/resolver/ad2s1210.c
index cf40184344473e8bd19a6745f74a3376d0fe3487..bd4a90c222b58014fbcd6d250f5569ed150b8f6a 100644 (file)
--- a/drivers/staging/iio/resolver/ad2s1210.c
+++ b/drivers/staging/iio/resolver/ad2s1210.c
@@ -47,6 +47,7 @@
 
 #include <linux/bitfield.h>
 #include <linux/bits.h>
+#include <linux/cleanup.h>
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/device.h>
@@ -447,7 +448,8 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
        s64 timestamp;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        ad2s1210_toggle_sample_line(st);
        timestamp = iio_get_time_ns(indio_dev);
 
@@ -459,14 +461,13 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
                ret = ad2s1210_set_mode(st, MOD_VEL);
                break;
        default:
-               ret = -EINVAL;
-               break;
+               return -EINVAL;
        }
        if (ret < 0)
-               goto error_ret;
+               return ret;
        ret = spi_read(st->sdev, &st->sample, 3);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
        switch (chan->type) {
        case IIO_ANGL:
@@ -478,14 +479,11 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
                ret = IIO_VAL_INT;
                break;
        default:
-               ret = -EINVAL;
-               break;
+               return -EINVAL;
        }
 
        ad2s1210_push_events(indio_dev, st->sample.fault, timestamp);
 
-error_ret:
-       mutex_unlock(&st->lock);
        return ret;
 }
 
@@ -493,11 +491,9 @@ static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val)
 {
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,
                               AD2S1210_ENABLE_HYSTERESIS);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -507,15 +503,10 @@ static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val)
 
 static int ad2s1210_set_hysteresis(struct ad2s1210_state *st, int val)
 {
-       int ret;
-
-       mutex_lock(&st->lock);
-       ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
-                                AD2S1210_ENABLE_HYSTERESIS,
-                                val ? AD2S1210_ENABLE_HYSTERESIS : 0);
-       mutex_unlock(&st->lock);
-
-       return ret;
+       guard(mutex)(&st->lock);
+       return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
+                                 AD2S1210_ENABLE_HYSTERESIS,
+                                 val ? AD2S1210_ENABLE_HYSTERESIS : 0);
 }
 
 static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
@@ -523,11 +514,9 @@ static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
 {
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,
                               AD2S1210_PHASE_LOCK_RANGE_44);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -547,7 +536,7 @@ static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
 static int ad2s1210_set_phase_lock_range(struct ad2s1210_state *st,
                                         int val, int val2)
 {
-       int deg, ret;
+       int deg;
 
        /* convert radians to degrees - only two allowable values */
        if (val == PHASE_44_DEG_TO_RAD_INT && val2 == PHASE_44_DEG_TO_RAD_MICRO)
@@ -558,12 +547,10 @@ static int ad2s1210_set_phase_lock_range(struct ad2s1210_state *st,
        else
                return -EINVAL;
 
-       mutex_lock(&st->lock);
-       ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
-                                AD2S1210_PHASE_LOCK_RANGE_44,
-                                deg == 44 ? AD2S1210_PHASE_LOCK_RANGE_44 : 0);
-       mutex_unlock(&st->lock);
-       return ret;
+       guard(mutex)(&st->lock);
+       return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
+                                 AD2S1210_PHASE_LOCK_RANGE_44,
+                                 deg == 44 ? AD2S1210_PHASE_LOCK_RANGE_44 : 0);
 }
 
 /* map resolution to microradians/LSB for LOT registers */
@@ -580,10 +567,8 @@ static int ad2s1210_get_voltage_threshold(struct ad2s1210_state *st,
        unsigned int reg_val;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_read(st->regmap, reg, &reg_val);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -595,15 +580,11 @@ static int ad2s1210_set_voltage_threshold(struct ad2s1210_state *st,
                                          unsigned int reg, int val)
 {
        unsigned int reg_val;
-       int ret;
 
        reg_val = val / THRESHOLD_MILLIVOLT_PER_LSB;
 
-       mutex_lock(&st->lock);
-       ret = regmap_write(st->regmap, reg, reg_val);
-       mutex_unlock(&st->lock);
-
-       return ret;
+       guard(mutex)(&st->lock);
+       return regmap_write(st->regmap, reg, reg_val);
 }
 
 static int ad2s1210_get_lot_high_threshold(struct ad2s1210_state *st,
@@ -612,10 +593,8 @@ static int ad2s1210_get_lot_high_threshold(struct ad2s1210_state *st,
        unsigned int reg_val;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -634,18 +613,18 @@ static int ad2s1210_set_lot_high_threshold(struct ad2s1210_state *st,
        if (val != 0)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        /*
         * We need to read both high and low registers first so we can preserve
         * the hysteresis.
         */
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
        hysteresis = high_reg_val - low_reg_val;
        high_reg_val = val2 / ad2s1210_lot_threshold_urad_per_lsb[st->resolution];
@@ -653,14 +632,9 @@ static int ad2s1210_set_lot_high_threshold(struct ad2s1210_state *st,
 
        ret = regmap_write(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, high_reg_val);
        if (ret < 0)
-               goto error_ret;
-
-       ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);
-
-error_ret:
-       mutex_unlock(&st->lock);
+               return ret;
 
-       return ret;
+       return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);
 }
 
 static int ad2s1210_get_lot_low_threshold(struct ad2s1210_state *st,
@@ -669,16 +643,13 @@ static int ad2s1210_get_lot_low_threshold(struct ad2s1210_state *st,
        unsigned int high_reg_val, low_reg_val;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);
-
-error_ret:
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -701,18 +672,14 @@ static int ad2s1210_set_lot_low_threshold(struct ad2s1210_state *st,
 
        hysteresis = val2 / ad2s1210_lot_threshold_urad_per_lsb[st->resolution];
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
-       ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,
+       return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,
                           reg_val - hysteresis);
-
-error_ret:
-       mutex_unlock(&st->lock);
-
-       return ret;
 }
 
 static int ad2s1210_get_excitation_frequency(struct ad2s1210_state *st, int *val)
@@ -720,31 +687,23 @@ static int ad2s1210_get_excitation_frequency(struct ad2s1210_state *st, int *val
        unsigned int reg_val;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        ret = regmap_read(st->regmap, AD2S1210_REG_EXCIT_FREQ, &reg_val);
        if (ret < 0)
-               goto error_ret;
+               return ret;
 
        *val = reg_val * st->clkin_hz / (1 << 15);
-       ret = IIO_VAL_INT;
-
-error_ret:
-       mutex_unlock(&st->lock);
-       return ret;
+       return IIO_VAL_INT;
 }
 
 static int ad2s1210_set_excitation_frequency(struct ad2s1210_state *st, int val)
 {
-       int ret;
-
        if (val < AD2S1210_MIN_EXCIT || val > AD2S1210_MAX_EXCIT)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
-       ret = ad2s1210_reinit_excitation_frequency(st, val);
-       mutex_unlock(&st->lock);
-
-       return ret;
+       guard(mutex)(&st->lock);
+       return ad2s1210_reinit_excitation_frequency(st, val);
 }
 
 static const int ad2s1210_velocity_scale[] = {
@@ -1020,10 +979,8 @@ static ssize_t event_attr_voltage_reg_show(struct device *dev,
        unsigned int value;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_read(st->regmap, iattr->address, &value);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -1043,11 +1000,9 @@ static ssize_t event_attr_voltage_reg_store(struct device *dev,
        if (ret)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        ret = regmap_write(st->regmap, iattr->address,
                           data / THRESHOLD_MILLIVOLT_PER_LSB);
-       mutex_unlock(&st->lock);
-
        if (ret < 0)
                return ret;
 
@@ -1121,7 +1076,7 @@ static int ad2s1210_initial(struct ad2s1210_state *st)
        unsigned int data;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
 
        /* Use default config register value plus resolution from devicetree. */
        data = FIELD_PREP(AD2S1210_PHASE_LOCK_RANGE_44, 1);
@@ -1131,13 +1086,9 @@ static int ad2s1210_initial(struct ad2s1210_state *st)
 
        ret = regmap_write(st->regmap, AD2S1210_REG_CONTROL, data);
        if (ret < 0)
-               goto error_ret;
-
-       ret = ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);
+               return ret;
 
-error_ret:
-       mutex_unlock(&st->lock);
-       return ret;
+       return ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);
 }
 
 static int ad2s1210_read_label(struct iio_dev *indio_dev,
@@ -1281,18 +1232,13 @@ static int ad2s1210_debugfs_reg_access(struct iio_dev *indio_dev,
                                       unsigned int *readval)
 {
        struct ad2s1210_state *st = iio_priv(indio_dev);
-       int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
 
        if (readval)
-               ret = regmap_read(st->regmap, reg, readval);
-       else
-               ret = regmap_write(st->regmap, reg, writeval);
-
-       mutex_unlock(&st->lock);
+               return regmap_read(st->regmap, reg, readval);
 
-       return ret;
+       return regmap_write(st->regmap, reg, writeval);
 }
 
 static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
@@ -1303,7 +1249,7 @@ static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
        size_t chan = 0;
        int ret;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
 
        memset(&st->scan, 0, sizeof(st->scan));
        ad2s1210_toggle_sample_line(st);
@@ -1336,7 +1282,6 @@ static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
        iio_push_to_buffers_with_timestamp(indio_dev, &st->scan, pf->timestamp);
 
 error_ret:
-       mutex_unlock(&st->lock);
        iio_trigger_notify_done(indio_dev->trig);
 
        return IRQ_HANDLED;