iio: light: gp2ap020a00f: simplify locking with guard()

Use the guard() cleanup handler to manage the device lock.
This simplifies the code by removing the need for manual unlocking
and goto error handling paths.

Suggested-by: Jonathan Cameron <jic23@kernel.org>
Signed-off-by: Ethan Tidmore <ethantidmore06@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/light/gp2ap020a00f.c b/drivers/iio/light/gp2ap020a00f.c
index c7df4b258e2c269a84f5767568fb4a5c7ae1484d..7cee15db3a1a8ab8c26d110581fc46aed30e3e1d 100644 (file)
--- a/drivers/iio/light/gp2ap020a00f.c
+++ b/drivers/iio/light/gp2ap020a00f.c
@@ -31,6 +31,7 @@
  * the other one.
  */
 
+#include <linux/cleanup.h>
 #include <linux/debugfs.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
@@ -1024,17 +1025,13 @@ static int gp2ap020a00f_write_event_val(struct iio_dev *indio_dev,
        bool event_en = false;
        u8 thresh_val_id;
        u8 thresh_reg_l;
-       int err = 0;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
        thresh_val_id = GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l);
-
-       if (thresh_val_id > GP2AP020A00F_THRESH_PH) {
-               err = -EINVAL;
-               goto error_unlock;
-       }
+       if (thresh_val_id > GP2AP020A00F_THRESH_PH)
+               return -EINVAL;
 
        switch (thresh_reg_l) {
        case GP2AP020A00F_TH_L_REG:
@@ -1046,30 +1043,23 @@ static int gp2ap020a00f_write_event_val(struct iio_dev *indio_dev,
                                                        &data->flags);
                break;
        case GP2AP020A00F_PH_L_REG:
-               if (val == 0) {
-                       err = -EINVAL;
-                       goto error_unlock;
-               }
+               if (val == 0)
+                       return -EINVAL;
+
                event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
                                                        &data->flags);
                break;
        case GP2AP020A00F_PL_L_REG:
-               if (val == 0) {
-                       err = -EINVAL;
-                       goto error_unlock;
-               }
+               if (val == 0)
+                       return -EINVAL;
+
                event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
                                                        &data->flags);
                break;
        }
 
        data->thresh_val[thresh_val_id] = val;
-       err =  gp2ap020a00f_write_event_threshold(data, thresh_val_id,
-                                                       event_en);
-error_unlock:
-       mutex_unlock(&data->lock);
-
-       return err;
+       return gp2ap020a00f_write_event_threshold(data, thresh_val_id, event_en);
 }
 
 static int gp2ap020a00f_read_event_val(struct iio_dev *indio_dev,
@@ -1081,23 +1071,16 @@ static int gp2ap020a00f_read_event_val(struct iio_dev *indio_dev,
 {
        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
        u8 thresh_reg_l;
-       int err = IIO_VAL_INT;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
-
-       if (thresh_reg_l > GP2AP020A00F_PH_L_REG) {
-               err = -EINVAL;
-               goto error_unlock;
-       }
+       if (thresh_reg_l > GP2AP020A00F_PH_L_REG)
+               return -EINVAL;
 
        *val = data->thresh_val[GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l)];
 
-error_unlock:
-       mutex_unlock(&data->lock);
-
-       return err;
+       return IIO_VAL_INT;
 }
 
 static int gp2ap020a00f_write_prox_event_config(struct iio_dev *indio_dev,
@@ -1163,32 +1146,25 @@ static int gp2ap020a00f_write_event_config(struct iio_dev *indio_dev,
 {
        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
        enum gp2ap020a00f_cmd cmd;
-       int err;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        switch (chan->type) {
        case IIO_PROXIMITY:
-               err = gp2ap020a00f_write_prox_event_config(indio_dev, state);
-               break;
+               return gp2ap020a00f_write_prox_event_config(indio_dev, state);
        case IIO_LIGHT:
                if (dir == IIO_EV_DIR_RISING) {
                        cmd = state ? GP2AP020A00F_CMD_ALS_HIGH_EV_EN :
                                      GP2AP020A00F_CMD_ALS_HIGH_EV_DIS;
-                       err = gp2ap020a00f_exec_cmd(data, cmd);
+                       return gp2ap020a00f_exec_cmd(data, cmd);
                } else {
                        cmd = state ? GP2AP020A00F_CMD_ALS_LOW_EV_EN :
                                      GP2AP020A00F_CMD_ALS_LOW_EV_DIS;
-                       err = gp2ap020a00f_exec_cmd(data, cmd);
+                       return gp2ap020a00f_exec_cmd(data, cmd);
                }
-               break;
        default:
-               err = -EINVAL;
+               return -EINVAL;
        }
-
-       mutex_unlock(&data->lock);
-
-       return err;
 }
 
 static int gp2ap020a00f_read_event_config(struct iio_dev *indio_dev,
@@ -1197,35 +1173,23 @@ static int gp2ap020a00f_read_event_config(struct iio_dev *indio_dev,
                                           enum iio_event_direction dir)
 {
        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
-       int event_en = 0;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        switch (chan->type) {
        case IIO_PROXIMITY:
                if (dir == IIO_EV_DIR_RISING)
-                       event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
-                                                               &data->flags);
+                       return test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags);
                else
-                       event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
-                                                               &data->flags);
-               break;
+                       return test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
        case IIO_LIGHT:
                if (dir == IIO_EV_DIR_RISING)
-                       event_en = test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV,
-                                                               &data->flags);
+                       return test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags);
                else
-                       event_en = test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV,
-                                                               &data->flags);
-               break;
+                       return test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
        default:
-               event_en = -EINVAL;
-               break;
+               return -EINVAL;
        }
-
-       mutex_unlock(&data->lock);
-
-       return event_en;
 }
 
 static int gp2ap020a00f_read_channel(struct gp2ap020a00f_data *data,
@@ -1385,7 +1349,7 @@ static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev)
        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
        int i, err = 0;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        /*
         * Enable triggers according to the scan_mask. Enabling either
@@ -1413,16 +1377,13 @@ static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev)
        }
 
        if (err < 0)
-               goto error_unlock;
+               return err;
 
        data->buffer = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
        if (!data->buffer)
-               err = -ENOMEM;
-
-error_unlock:
-       mutex_unlock(&data->lock);
+               return -ENOMEM;
 
-       return err;
+       return 0;
 }
 
 static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev)
@@ -1430,7 +1391,7 @@ static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev)
        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
        int i, err = 0;
 
-       mutex_lock(&data->lock);
+       guard(mutex)(&data->lock);
 
        iio_for_each_active_channel(indio_dev, i) {
                switch (i) {
@@ -1449,12 +1410,11 @@ static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev)
                }
        }
 
-       if (err == 0)
-               kfree(data->buffer);
-
-       mutex_unlock(&data->lock);
+       if (err)
+               return err;
 
-       return err;
+       kfree(data->buffer);
+       return 0;
 }
 
 static const struct iio_buffer_setup_ops gp2ap020a00f_buffer_setup_ops = {