iio: adc: max1363: Use automatic cleanup for locks and iio mode claiming.

This simplifies error return paths.

Reviewed-by: Nuno Sa <nuno.a@analog.com>
Link: https://lore.kernel.org/r/20240128150537.44592-6-jic23@kernel.org
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/max1363.c b/drivers/iio/adc/max1363.c
index 7c2a98b8c3a961d1e10ec1068e889f84857c857b..8b5bc96cb9fbf129f91ac0103f30daa6cdf76944 100644 (file)
--- a/drivers/iio/adc/max1363.c
+++ b/drivers/iio/adc/max1363.c
@@ -357,62 +357,55 @@ static int max1363_read_single_chan(struct iio_dev *indio_dev,
                                    int *val,
                                    long m)
 {
-       int ret = 0;
-       s32 data;
-       u8 rxbuf[2];
-       struct max1363_state *st = iio_priv(indio_dev);
-       struct i2c_client *client = st->client;
-
-       ret = iio_device_claim_direct_mode(indio_dev);
-       if (ret)
-               return ret;
-       mutex_lock(&st->lock);
-
-       /*
-        * If monitor mode is enabled, the method for reading a single
-        * channel will have to be rather different and has not yet
-        * been implemented.
-        *
-        * Also, cannot read directly if buffered capture enabled.
-        */
-       if (st->monitor_on) {
-               ret = -EBUSY;
-               goto error_ret;
-       }
-
-       /* Check to see if current scan mode is correct */
-       if (st->current_mode != &max1363_mode_table[chan->address]) {
-               /* Update scan mode if needed */
-               st->current_mode = &max1363_mode_table[chan->address];
-               ret = max1363_set_scan_mode(st);
-               if (ret < 0)
-                       goto error_ret;
-       }
-       if (st->chip_info->bits != 8) {
-               /* Get reading */
-               data = st->recv(client, rxbuf, 2);
-               if (data < 0) {
-                       ret = data;
-                       goto error_ret;
+       iio_device_claim_direct_scoped(return -EBUSY, indio_dev) {
+               s32 data;
+               u8 rxbuf[2];
+               struct max1363_state *st = iio_priv(indio_dev);
+               struct i2c_client *client = st->client;
+
+               guard(mutex)(&st->lock);
+
+               /*
+                * If monitor mode is enabled, the method for reading a single
+                * channel will have to be rather different and has not yet
+                * been implemented.
+                *
+                * Also, cannot read directly if buffered capture enabled.
+                */
+               if (st->monitor_on)
+                       return -EBUSY;
+
+               /* Check to see if current scan mode is correct */
+               if (st->current_mode != &max1363_mode_table[chan->address]) {
+                       int ret;
+
+                       /* Update scan mode if needed */
+                       st->current_mode = &max1363_mode_table[chan->address];
+                       ret = max1363_set_scan_mode(st);
+                       if (ret < 0)
+                               return ret;
                }
-               data = (rxbuf[1] | rxbuf[0] << 8) &
-                 ((1 << st->chip_info->bits) - 1);
-       } else {
-               /* Get reading */
-               data = st->recv(client, rxbuf, 1);
-               if (data < 0) {
-                       ret = data;
-                       goto error_ret;
+               if (st->chip_info->bits != 8) {
+                       /* Get reading */
+                       data = st->recv(client, rxbuf, 2);
+                       if (data < 0)
+                               return data;
+
+                       data = (rxbuf[1] | rxbuf[0] << 8) &
+                               ((1 << st->chip_info->bits) - 1);
+               } else {
+                       /* Get reading */
+                       data = st->recv(client, rxbuf, 1);
+                       if (data < 0)
+                               return data;
+
+                       data = rxbuf[0];
                }
-               data = rxbuf[0];
-       }
-       *val = data;
-
-error_ret:
-       mutex_unlock(&st->lock);
-       iio_device_release_direct_mode(indio_dev);
-       return ret;
+               *val = data;
 
+               return 0;
+       }
+       unreachable();
 }
 
 static int max1363_read_raw(struct iio_dev *indio_dev,
@@ -710,9 +703,8 @@ static ssize_t max1363_monitor_store_freq(struct device *dev,
        if (!found)
                return -EINVAL;
 
-       mutex_lock(&st->lock);
-       st->monitor_speed = i;
-       mutex_unlock(&st->lock);
+       scoped_guard(mutex, &st->lock)
+               st->monitor_speed = i;
 
        return 0;
 }
@@ -815,12 +807,11 @@ static int max1363_read_event_config(struct iio_dev *indio_dev,
        int val;
        int number = chan->channel;
 
-       mutex_lock(&st->lock);
+       guard(mutex)(&st->lock);
        if (dir == IIO_EV_DIR_FALLING)
                val = (1 << number) & st->mask_low;
        else
                val = (1 << number) & st->mask_high;
-       mutex_unlock(&st->lock);
 
        return val;
 }
@@ -962,46 +953,42 @@ static int max1363_write_event_config(struct iio_dev *indio_dev,
        const struct iio_chan_spec *chan, enum iio_event_type type,
        enum iio_event_direction dir, int state)
 {
-       int ret = 0;
        struct max1363_state *st = iio_priv(indio_dev);
-       u16 unifiedmask;
-       int number = chan->channel;
 
-       ret = iio_device_claim_direct_mode(indio_dev);
-       if (ret)
-               return ret;
-       mutex_lock(&st->lock);
-
-       unifiedmask = st->mask_low | st->mask_high;
-       if (dir == IIO_EV_DIR_FALLING) {
-
-               if (state == 0)
-                       st->mask_low &= ~(1 << number);
-               else {
-                       ret = __max1363_check_event_mask((1 << number),
-                                                        unifiedmask);
-                       if (ret)
-                               goto error_ret;
-                       st->mask_low |= (1 << number);
-               }
-       } else {
-               if (state == 0)
-                       st->mask_high &= ~(1 << number);
-               else {
-                       ret = __max1363_check_event_mask((1 << number),
-                                                        unifiedmask);
-                       if (ret)
-                               goto error_ret;
-                       st->mask_high |= (1 << number);
+       iio_device_claim_direct_scoped(return -EBUSY, indio_dev) {
+               int number = chan->channel;
+               u16 unifiedmask;
+               int ret;
+
+               guard(mutex)(&st->lock);
+
+               unifiedmask = st->mask_low | st->mask_high;
+               if (dir == IIO_EV_DIR_FALLING) {
+
+                       if (state == 0)
+                               st->mask_low &= ~(1 << number);
+                       else {
+                               ret = __max1363_check_event_mask((1 << number),
+                                                                unifiedmask);
+                               if (ret)
+                                       return ret;
+                               st->mask_low |= (1 << number);
+                       }
+               } else {
+                       if (state == 0)
+                               st->mask_high &= ~(1 << number);
+                       else {
+                               ret = __max1363_check_event_mask((1 << number),
+                                                                unifiedmask);
+                               if (ret)
+                                       return ret;
+                               st->mask_high |= (1 << number);
+                       }
                }
        }
-
        max1363_monitor_mode_update(st, !!(st->mask_high | st->mask_low));
-error_ret:
-       mutex_unlock(&st->lock);
-       iio_device_release_direct_mode(indio_dev);
 
-       return ret;
+       return 0;
 }
 
 /*