mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH v2 0/2] iio: light: adux1020: guard() conversion and follow-up cleanup
@ 2026-11-17  7:11 Raffaele Tranfaglia via B4 Relay
  2026-11-17  7:11 ` [PATCH v2 1/2] iio: light: adux1020: use guard() to simplify lock handling Raffaele Tranfaglia via B4 Relay
  2026-11-17  7:11 ` [PATCH v2 2/2] iio: light: adux1020: return early on unsupported channel types Raffaele Tranfaglia via B4 Relay
  0 siblings, 2 replies; 3+ messages in thread
From: Raffaele Tranfaglia via B4 Relay @ 2026-11-17  7:11 UTC (permalink / raw)
  To: Nuno Sá,
	Michael Hennerich, Jonathan Cameron, David Lechner,
	Andy Shevchenko
  Cc: linux, linux-iio, linux-kernel, Raffaele Tranfaglia,
	Joshua Crofts, Andy Shevchenko

Patch 1 converts the driver to guard(mutex), as Jonathan suggested
when applying the sampling frequency hardening patch. Patch 2 uses the
direct returns this allows to flatten the channel type checks in
adux1020_read_raw() and adux1020_write_raw().

Tested on arm64 QEMU with i2c-stub and lockdep enabled: reading and
writing the sampling frequency (valid and invalid values), reading the
LED current, reading in_proximity_raw and enabling the threshold
event. No lockdep warnings and no hangs after the error paths.

I prepared these patches with the help of an AI coding assistant, and
reviewed and tested them myself.

Signed-off-by: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
---
Changes in v2:
- Drop the unreferenced Link tag (Andy)
- Move ret to the end of the declarations in adux1020_read_raw() (Andy)
- New patch 2: return early on unsupported channel types instead of
  nesting (Jonathan)
- Link to v1: https://patch.msgid.link/20261108-adux1020-guard-v1-1-db9c582f1eea@gmail.com

---
Raffaele Tranfaglia (2):
      iio: light: adux1020: use guard() to simplify lock handling
      iio: light: adux1020: return early on unsupported channel types

 drivers/iio/light/adux1020.c | 189 ++++++++++++++++++-------------------------
 1 file changed, 77 insertions(+), 112 deletions(-)
---
base-commit: d922ed738439e1d5b4701df7f4cdd49a09925624
change-id: 20261108-adux1020-guard-3820ce794843

Best regards,
--  
Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>



^ permalink raw reply	[flat|nested] 3+ messages in thread

* [PATCH v2 1/2] iio: light: adux1020: use guard() to simplify lock handling
  2026-11-17  7:11 [PATCH v2 0/2] iio: light: adux1020: guard() conversion and follow-up cleanup Raffaele Tranfaglia via B4 Relay
@ 2026-11-17  7:11 ` Raffaele Tranfaglia via B4 Relay
  2026-11-17  7:11 ` [PATCH v2 2/2] iio: light: adux1020: return early on unsupported channel types Raffaele Tranfaglia via B4 Relay
  1 sibling, 0 replies; 3+ messages in thread
From: Raffaele Tranfaglia via B4 Relay @ 2026-11-17  7:11 UTC (permalink / raw)
  To: Nuno Sá,
	Michael Hennerich, Jonathan Cameron, David Lechner,
	Andy Shevchenko
  Cc: linux, linux-iio, linux-kernel, Raffaele Tranfaglia,
	Joshua Crofts, Andy Shevchenko

From: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>

Use guard(mutex) in adux1020_read_raw(), adux1020_write_raw() and
adux1020_write_event_config() so the lock is released automatically on
return. This allows returning directly instead of jumping to a common
unlock label, and lets adux1020_write_raw() drop its ret variable.

No functional change intended.

Suggested-by: Jonathan Cameron <jic23@kernel.org>
Reviewed-by: Joshua Crofts <crofts@kernel.org>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Signed-off-by: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
---
 drivers/iio/light/adux1020.c | 104 ++++++++++++++++---------------------------
 1 file changed, 39 insertions(+), 65 deletions(-)

diff --git a/drivers/iio/light/adux1020.c b/drivers/iio/light/adux1020.c
index 6b32c5be4753..b595faf4abc5 100644
--- a/drivers/iio/light/adux1020.c
+++ b/drivers/iio/light/adux1020.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/bitfield.h>
+#include <linux/cleanup.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/i2c.h>
@@ -362,10 +363,10 @@ static int adux1020_read_raw(struct iio_dev *indio_dev,
 {
 	struct adux1020_data *data = iio_priv(indio_dev);
 	u16 buf[3];
-	int ret = -EINVAL;
 	unsigned int regval;
+	int ret;
 
-	mutex_lock(&data->lock);
+	guard(mutex)(&data->lock);
 
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
@@ -373,69 +374,56 @@ static int adux1020_read_raw(struct iio_dev *indio_dev,
 		case IIO_PROXIMITY:
 			ret = adux1020_set_mode(data, ADUX1020_MODE_PROX_I);
 			if (ret < 0)
-				goto fail;
+				return ret;
 
 			ret = adux1020_measure(data, ADUX1020_MODE_PROX_I, buf);
 			if (ret < 0)
-				goto fail;
+				return ret;
 
 			*val = buf[0];
-			ret = IIO_VAL_INT;
-			break;
+			return IIO_VAL_INT;
 		default:
-			break;
+			return -EINVAL;
 		}
-		break;
 	case IIO_CHAN_INFO_PROCESSED:
 		switch (chan->type) {
 		case IIO_CURRENT:
 			ret = regmap_read(data->regmap,
 					  ADUX1020_REG_LED_CURRENT, &regval);
 			if (ret < 0)
-				goto fail;
+				return ret;
 
 			regval = regval & ADUX1020_LED_CURRENT_MASK;
 
 			*val = adux1020_led_currents[regval][0];
 			*val2 = adux1020_led_currents[regval][1];
 
-			ret = IIO_VAL_INT_PLUS_MICRO;
-			break;
+			return IIO_VAL_INT_PLUS_MICRO;
 		default:
-			break;
+			return -EINVAL;
 		}
-		break;
 	case IIO_CHAN_INFO_SAMP_FREQ:
 		switch (chan->type) {
 		case IIO_PROXIMITY:
 			ret = regmap_read(data->regmap, ADUX1020_REG_FREQUENCY,
 					  &regval);
 			if (ret < 0)
-				goto fail;
+				return ret;
 
 			regval = FIELD_GET(ADUX1020_PROX_FREQ_MASK, regval);
-			if (regval >= ARRAY_SIZE(adux1020_rates)) {
-				ret = -EINVAL;
-				goto fail;
-			}
+			if (regval >= ARRAY_SIZE(adux1020_rates))
+				return -EINVAL;
 
 			*val = adux1020_rates[regval][0];
 			*val2 = adux1020_rates[regval][1];
 
-			ret = IIO_VAL_INT_PLUS_MICRO;
-			break;
+			return IIO_VAL_INT_PLUS_MICRO;
 		default:
-			break;
+			return -EINVAL;
 		}
-		break;
 	default:
-		break;
+		return -EINVAL;
 	}
-
-fail:
-	mutex_unlock(&data->lock);
-
-	return ret;
 };
 
 static inline int adux1020_find_index(const int array[][2], int count, int val,
@@ -455,9 +443,9 @@ static int adux1020_write_raw(struct iio_dev *indio_dev,
 			      int val, int val2, long mask)
 {
 	struct adux1020_data *data = iio_priv(indio_dev);
-	int i, ret = -EINVAL;
+	int i;
 
-	mutex_lock(&data->lock);
+	guard(mutex)(&data->lock);
 
 	switch (mask) {
 	case IIO_CHAN_INFO_SAMP_FREQ:
@@ -465,15 +453,13 @@ static int adux1020_write_raw(struct iio_dev *indio_dev,
 			i = adux1020_find_index(adux1020_rates,
 						ARRAY_SIZE(adux1020_rates),
 						val, val2);
-			if (i < 0) {
-				ret = i;
-				goto fail;
-			}
-
-			ret = regmap_update_bits(data->regmap,
-						 ADUX1020_REG_FREQUENCY,
-						 ADUX1020_PROX_FREQ_MASK,
-						 ADUX1020_PROX_FREQ(i));
+			if (i < 0)
+				return i;
+
+			return regmap_update_bits(data->regmap,
+						  ADUX1020_REG_FREQUENCY,
+						  ADUX1020_PROX_FREQ_MASK,
+						  ADUX1020_PROX_FREQ(i));
 		}
 		break;
 	case IIO_CHAN_INFO_PROCESSED:
@@ -481,24 +467,19 @@ static int adux1020_write_raw(struct iio_dev *indio_dev,
 			i = adux1020_find_index(adux1020_led_currents,
 					ARRAY_SIZE(adux1020_led_currents),
 					val, val2);
-			if (i < 0) {
-				ret = i;
-				goto fail;
-			}
-
-			ret = regmap_update_bits(data->regmap,
-						 ADUX1020_REG_LED_CURRENT,
-						 ADUX1020_LED_CURRENT_MASK, i);
+			if (i < 0)
+				return i;
+
+			return regmap_update_bits(data->regmap,
+						  ADUX1020_REG_LED_CURRENT,
+						  ADUX1020_LED_CURRENT_MASK, i);
 		}
 		break;
 	default:
 		break;
 	}
 
-fail:
-	mutex_unlock(&data->lock);
-
-	return ret;
+	return -EINVAL;
 }
 
 static int adux1020_write_event_config(struct iio_dev *indio_dev,
@@ -510,16 +491,16 @@ static int adux1020_write_event_config(struct iio_dev *indio_dev,
 	struct adux1020_data *data = iio_priv(indio_dev);
 	int ret, mask;
 
-	mutex_lock(&data->lock);
+	guard(mutex)(&data->lock);
 
 	ret = regmap_write(data->regmap, ADUX1020_REG_INT_ENABLE,
 			   ADUX1020_INT_ENABLE);
 	if (ret < 0)
-		goto fail;
+		return ret;
 
 	ret = regmap_write(data->regmap, ADUX1020_REG_INT_POLARITY, 0);
 	if (ret < 0)
-		goto fail;
+		return ret;
 
 	switch (chan->type) {
 	case IIO_PROXIMITY:
@@ -535,7 +516,7 @@ static int adux1020_write_event_config(struct iio_dev *indio_dev,
 			ret = regmap_set_bits(data->regmap,
 					      ADUX1020_REG_INT_MASK, mask);
 		if (ret < 0)
-			goto fail;
+			return ret;
 
 		/*
 		 * Trigger proximity interrupt when the intensity is above
@@ -544,20 +525,13 @@ static int adux1020_write_event_config(struct iio_dev *indio_dev,
 		ret = regmap_set_bits(data->regmap, ADUX1020_REG_PROX_TYPE,
 				      ADUX1020_PROX_TYPE);
 		if (ret < 0)
-			goto fail;
+			return ret;
 
 		/* Set proximity mode */
-		ret = adux1020_set_mode(data, ADUX1020_MODE_PROX_I);
-		break;
+		return adux1020_set_mode(data, ADUX1020_MODE_PROX_I);
 	default:
-		ret = -EINVAL;
-		break;
+		return -EINVAL;
 	}
-
-fail:
-	mutex_unlock(&data->lock);
-
-	return ret;
 }
 
 static int adux1020_read_event_config(struct iio_dev *indio_dev,

-- 
2.56.0



^ permalink raw reply	[flat|nested] 3+ messages in thread

* [PATCH v2 2/2] iio: light: adux1020: return early on unsupported channel types
  2026-11-17  7:11 [PATCH v2 0/2] iio: light: adux1020: guard() conversion and follow-up cleanup Raffaele Tranfaglia via B4 Relay
  2026-11-17  7:11 ` [PATCH v2 1/2] iio: light: adux1020: use guard() to simplify lock handling Raffaele Tranfaglia via B4 Relay
@ 2026-11-17  7:11 ` Raffaele Tranfaglia via B4 Relay
  1 sibling, 0 replies; 3+ messages in thread
From: Raffaele Tranfaglia via B4 Relay @ 2026-11-17  7:11 UTC (permalink / raw)
  To: Nuno Sá,
	Michael Hennerich, Jonathan Cameron, David Lechner,
	Andy Shevchenko
  Cc: linux, linux-iio, linux-kernel, Raffaele Tranfaglia

From: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>

Now that adux1020_read_raw() and adux1020_write_raw() can return
directly, check the channel type with an inverted condition and return
-EINVAL early instead of nesting the work in an inner switch or if
block. This removes one level of indentation and makes the two
functions consistent with each other.

While at it, drop the stray semicolon after the closing brace of
adux1020_read_raw().

No functional change intended.

Suggested-by: Jonathan Cameron <jic23@kernel.org>
Signed-off-by: Raffaele Tranfaglia <raffaele.tranfaglia@gmail.com>
---
 drivers/iio/light/adux1020.c | 131 ++++++++++++++++++++-----------------------
 1 file changed, 61 insertions(+), 70 deletions(-)

diff --git a/drivers/iio/light/adux1020.c b/drivers/iio/light/adux1020.c
index b595faf4abc5..afb0798a2894 100644
--- a/drivers/iio/light/adux1020.c
+++ b/drivers/iio/light/adux1020.c
@@ -370,61 +370,56 @@ static int adux1020_read_raw(struct iio_dev *indio_dev,
 
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
-		switch (chan->type) {
-		case IIO_PROXIMITY:
-			ret = adux1020_set_mode(data, ADUX1020_MODE_PROX_I);
-			if (ret < 0)
-				return ret;
-
-			ret = adux1020_measure(data, ADUX1020_MODE_PROX_I, buf);
-			if (ret < 0)
-				return ret;
-
-			*val = buf[0];
-			return IIO_VAL_INT;
-		default:
+		if (chan->type != IIO_PROXIMITY)
 			return -EINVAL;
-		}
-	case IIO_CHAN_INFO_PROCESSED:
-		switch (chan->type) {
-		case IIO_CURRENT:
-			ret = regmap_read(data->regmap,
-					  ADUX1020_REG_LED_CURRENT, &regval);
-			if (ret < 0)
-				return ret;
 
-			regval = regval & ADUX1020_LED_CURRENT_MASK;
+		ret = adux1020_set_mode(data, ADUX1020_MODE_PROX_I);
+		if (ret < 0)
+			return ret;
+
+		ret = adux1020_measure(data, ADUX1020_MODE_PROX_I, buf);
+		if (ret < 0)
+			return ret;
 
-			*val = adux1020_led_currents[regval][0];
-			*val2 = adux1020_led_currents[regval][1];
+		*val = buf[0];
 
-			return IIO_VAL_INT_PLUS_MICRO;
-		default:
+		return IIO_VAL_INT;
+	case IIO_CHAN_INFO_PROCESSED:
+		if (chan->type != IIO_CURRENT)
 			return -EINVAL;
-		}
+
+		ret = regmap_read(data->regmap, ADUX1020_REG_LED_CURRENT,
+				  &regval);
+		if (ret < 0)
+			return ret;
+
+		regval = regval & ADUX1020_LED_CURRENT_MASK;
+
+		*val = adux1020_led_currents[regval][0];
+		*val2 = adux1020_led_currents[regval][1];
+
+		return IIO_VAL_INT_PLUS_MICRO;
 	case IIO_CHAN_INFO_SAMP_FREQ:
-		switch (chan->type) {
-		case IIO_PROXIMITY:
-			ret = regmap_read(data->regmap, ADUX1020_REG_FREQUENCY,
-					  &regval);
-			if (ret < 0)
-				return ret;
-
-			regval = FIELD_GET(ADUX1020_PROX_FREQ_MASK, regval);
-			if (regval >= ARRAY_SIZE(adux1020_rates))
-				return -EINVAL;
-
-			*val = adux1020_rates[regval][0];
-			*val2 = adux1020_rates[regval][1];
-
-			return IIO_VAL_INT_PLUS_MICRO;
-		default:
+		if (chan->type != IIO_PROXIMITY)
 			return -EINVAL;
-		}
+
+		ret = regmap_read(data->regmap, ADUX1020_REG_FREQUENCY,
+				  &regval);
+		if (ret < 0)
+			return ret;
+
+		regval = FIELD_GET(ADUX1020_PROX_FREQ_MASK, regval);
+		if (regval >= ARRAY_SIZE(adux1020_rates))
+			return -EINVAL;
+
+		*val = adux1020_rates[regval][0];
+		*val2 = adux1020_rates[regval][1];
+
+		return IIO_VAL_INT_PLUS_MICRO;
 	default:
 		return -EINVAL;
 	}
-};
+}
 
 static inline int adux1020_find_index(const int array[][2], int count, int val,
 				      int val2)
@@ -449,37 +444,33 @@ static int adux1020_write_raw(struct iio_dev *indio_dev,
 
 	switch (mask) {
 	case IIO_CHAN_INFO_SAMP_FREQ:
-		if (chan->type == IIO_PROXIMITY) {
-			i = adux1020_find_index(adux1020_rates,
-						ARRAY_SIZE(adux1020_rates),
-						val, val2);
-			if (i < 0)
-				return i;
-
-			return regmap_update_bits(data->regmap,
-						  ADUX1020_REG_FREQUENCY,
-						  ADUX1020_PROX_FREQ_MASK,
-						  ADUX1020_PROX_FREQ(i));
-		}
-		break;
+		if (chan->type != IIO_PROXIMITY)
+			return -EINVAL;
+
+		i = adux1020_find_index(adux1020_rates,
+					ARRAY_SIZE(adux1020_rates), val, val2);
+		if (i < 0)
+			return i;
+
+		return regmap_update_bits(data->regmap, ADUX1020_REG_FREQUENCY,
+					  ADUX1020_PROX_FREQ_MASK,
+					  ADUX1020_PROX_FREQ(i));
 	case IIO_CHAN_INFO_PROCESSED:
-		if (chan->type == IIO_CURRENT) {
-			i = adux1020_find_index(adux1020_led_currents,
+		if (chan->type != IIO_CURRENT)
+			return -EINVAL;
+
+		i = adux1020_find_index(adux1020_led_currents,
 					ARRAY_SIZE(adux1020_led_currents),
 					val, val2);
-			if (i < 0)
-				return i;
+		if (i < 0)
+			return i;
 
-			return regmap_update_bits(data->regmap,
-						  ADUX1020_REG_LED_CURRENT,
-						  ADUX1020_LED_CURRENT_MASK, i);
-		}
-		break;
+		return regmap_update_bits(data->regmap,
+					  ADUX1020_REG_LED_CURRENT,
+					  ADUX1020_LED_CURRENT_MASK, i);
 	default:
-		break;
+		return -EINVAL;
 	}
-
-	return -EINVAL;
 }
 
 static int adux1020_write_event_config(struct iio_dev *indio_dev,

-- 
2.56.0



^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-17  7:11 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-17  7:11 [PATCH v2 0/2] iio: light: adux1020: guard() conversion and follow-up cleanup Raffaele Tranfaglia via B4 Relay
2026-11-17  7:11 ` [PATCH v2 1/2] iio: light: adux1020: use guard() to simplify lock handling Raffaele Tranfaglia via B4 Relay
2026-11-17  7:11 ` [PATCH v2 2/2] iio: light: adux1020: return early on unsupported channel types Raffaele Tranfaglia via B4 Relay

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®