iio: adc: ad7280a: use cleanup helpers guard() and scoped_guard() for mutex locking

Replace open-coded mutex_lock/unlock pairs with the cleanup-based
guard() and scoped_guard() helpers in ad7280a_write_thresh(),
ad7280_show_balance_timer(), ad7280_store_balance_sw(),
ad7280_store_balance_timer() and ad7280_read_raw().

This removes the need for the err_unlock label and explicit
mutex_unlock() calls, as the lock is now automatically released
when the function returns or the guarded scope exits, regardless
of the exit path.

Signed-off-by: Lucas Ivars Cadima Ciziks <lucas@ciziks.com>
Co-developed-by: Matheus Giarola <matheusgiarola@usp.br>
Signed-off-by: Matheus Giarola <matheusgiarola@usp.br>
Co-developed-by: Felipe Ribeiro de Souza <felipers@usp.br>
Signed-off-by: Felipe Ribeiro de Souza <felipers@usp.br>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Jonathan Cameron <jic23@kernel.org>

diff --git a/drivers/iio/adc/ad7280a.c b/drivers/iio/adc/ad7280a.c
index 5a01c3fc7cbbe4ef1ddf576335a45913a06371f2..01c2f55a680cf8380492a3a48c7cc16eb5b087f3 100644 (file)
--- a/drivers/iio/adc/ad7280a.c
+++ b/drivers/iio/adc/ad7280a.c
@@ -496,7 +496,8 @@ static ssize_t ad7280_store_balance_sw(struct iio_dev *indio_dev,
        devaddr = chan->address >> 8;
        ch = chan->address & 0xFF;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        if (readin)
                st->cb_mask[devaddr] |= BIT(ch);
        else
@@ -505,7 +506,6 @@ static ssize_t ad7280_store_balance_sw(struct iio_dev *indio_dev,
        ret = ad7280_write(st, devaddr, AD7280A_CELL_BALANCE_REG, 0,
                           FIELD_PREP(AD7280A_CELL_BALANCE_CHAN_BITMAP_MSK,
                                      st->cb_mask[devaddr]));
-       mutex_unlock(&st->lock);
 
        return ret ? ret : len;
 }
@@ -521,10 +521,8 @@ static ssize_t ad7280_show_balance_timer(struct iio_dev *indio_dev,
        unsigned int msecs;
        int ret;
 
-       mutex_lock(&st->lock);
-       ret = ad7280_read_reg(st, devaddr, ch + AD7280A_CB1_TIMER_REG);
-       mutex_unlock(&st->lock);
-
+       scoped_guard(mutex, &st->lock)
+               ret = ad7280_read_reg(st, devaddr, ch + AD7280A_CB1_TIMER_REG);
        if (ret < 0)
                return ret;
 
@@ -554,10 +552,10 @@ static ssize_t ad7280_store_balance_timer(struct iio_dev *indio_dev,
        if (val > 31)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        ret = ad7280_write(st, devaddr, ch + AD7280A_CB1_TIMER_REG, 0,
                           FIELD_PREP(AD7280A_CB_TIMER_VAL_MSK, val));
-       mutex_unlock(&st->lock);
 
        return ret ? ret : len;
 }
@@ -739,7 +737,8 @@ static int ad7280a_write_thresh(struct iio_dev *indio_dev,
        if (val2 != 0)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
+
        switch (chan->type) {
        case IIO_VOLTAGE:
                value = ((val - 1000) * 100) / 1568; /* LSB 15.68mV */
@@ -750,22 +749,20 @@ static int ad7280a_write_thresh(struct iio_dev *indio_dev,
                        ret = ad7280_write(st, AD7280A_DEVADDR_MASTER, addr,
                                           1, value);
                        if (ret)
-                               break;
+                               return ret;
                        st->cell_threshhigh = value;
-                       break;
+                       return 0;
                case IIO_EV_DIR_FALLING:
                        addr = AD7280A_CELL_UNDERVOLTAGE_REG;
                        ret = ad7280_write(st, AD7280A_DEVADDR_MASTER, addr,
                                           1, value);
                        if (ret)
-                               break;
+                               return ret;
                        st->cell_threshlow = value;
-                       break;
+                       return 0;
                default:
-                       ret = -EINVAL;
-                       goto err_unlock;
+                       return -EINVAL;
                }
-               break;
        case IIO_TEMP:
                value = (val * 10) / 196; /* LSB 19.6mV */
                value = clamp(value, 0L, 0xFFL);
@@ -775,31 +772,23 @@ static int ad7280a_write_thresh(struct iio_dev *indio_dev,
                        ret = ad7280_write(st, AD7280A_DEVADDR_MASTER, addr,
                                           1, value);
                        if (ret)
-                               break;
+                               return ret;
                        st->aux_threshhigh = value;
-                       break;
+                       return 0;
                case IIO_EV_DIR_FALLING:
                        addr = AD7280A_AUX_ADC_UNDERVOLTAGE_REG;
                        ret = ad7280_write(st, AD7280A_DEVADDR_MASTER, addr,
                                           1, value);
                        if (ret)
-                               break;
+                               return ret;
                        st->aux_threshlow = value;
-                       break;
+                       return 0;
                default:
-                       ret = -EINVAL;
-                       goto err_unlock;
+                       return -EINVAL;
                }
-               break;
        default:
-               ret = -EINVAL;
-               goto err_unlock;
+               return -EINVAL;
        }
-
-err_unlock:
-       mutex_unlock(&st->lock);
-
-       return ret;
 }
 
 static irqreturn_t ad7280_event_handler(int irq, void *private)
@@ -888,13 +877,13 @@ static int ad7280_read_raw(struct iio_dev *indio_dev,
        int ret;
 
        switch (m) {
-       case IIO_CHAN_INFO_RAW:
-               mutex_lock(&st->lock);
+       case IIO_CHAN_INFO_RAW: {
+               guard(mutex)(&st->lock);
+
                if (chan->address == AD7280A_ALL_CELLS)
                        ret = ad7280_read_all_channels(st, st->scan_cnt, NULL);
                else
                        ret = ad7280_read_channel(st, devaddr, ch);
-               mutex_unlock(&st->lock);
 
                if (ret < 0)
                        return ret;
@@ -902,6 +891,7 @@ static int ad7280_read_raw(struct iio_dev *indio_dev,
                *val = ret;
 
                return IIO_VAL_INT;
+       }
        case IIO_CHAN_INFO_SCALE:
                if (ch <= AD7280A_CELL_VOLTAGE_6_REG)
                        *val = 4000;