[PATCH] iio: dac: m62332: Use guard(mutex) for locking

[PATCH] iio: dac: m62332: Use guard(mutex) for locking

[Erick Henrique]

Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
simplify locking and make cleanup automatic when the lock goes out
of scope.

Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
---
 drivers/iio/dac/m62332.c | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
index 3497513854d7..233a179d234b 100644
--- a/drivers/iio/dac/m62332.c
+++ b/drivers/iio/dac/m62332.c
@@ -41,33 +41,27 @@ static int m62332_set_value(struct iio_dev *indio_dev, u8 val, int channel)
 	outbuf[0] = channel;
 	outbuf[1] = val;
 
-	mutex_lock(&data->mutex);
+	guard(mutex)(&data->mutex);
 
 	if (val) {
 		res = regulator_enable(data->vcc);
 		if (res)
-			goto out;
+			return res;
 	}
 
 	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
 	if (res >= 0 && res != ARRAY_SIZE(outbuf))
 		res = -EIO;
 	if (res < 0)
-		goto out;
+		return res;
 
 	data->raw[channel] = val;
 
 	if (!val)
 		regulator_disable(data->vcc);
 
-	mutex_unlock(&data->mutex);
-
 	return 0;
 
-out:
-	mutex_unlock(&data->mutex);
-
-	return res;
 }
 
 static int m62332_read_raw(struct iio_dev *indio_dev,
-- 
2.51.0

Re: [PATCH] iio: dac: m62332: Use guard(mutex) for locking

[Andy Shevchenko]

On Tue, Apr 14, 2026 at 08:39:10PM -0300, Erick Henrique wrote:
> Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
> simplify locking and make cleanup automatic when the lock goes out
> of scope.

...

>  	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
>  	if (res >= 0 && res != ARRAY_SIZE(outbuf))
>  		res = -EIO;
>  	if (res < 0)
> -		goto out;
> +		return res;

Now it may be rewritten to drop for additional < 0 check:

	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
	if (res < 0)
		return res;
	if (res != ARRAY_SIZE(outbuf))
		return -EIO;

-- 
With Best Regards,
Andy Shevchenko

[PATCH v2] iio: dac: m62332: Use guard(mutex) for locking

[Erick Henrique]

Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
simplify locking and make cleanup automatic when the lock goes out
of scope.

Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
---
v2: split combined condition in i2c_master_send error handling
    into two separate early returns
---
 drivers/iio/dac/m62332.c | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
index 3497513854d7..4cf06e50c1ec 100644
--- a/drivers/iio/dac/m62332.c
+++ b/drivers/iio/dac/m62332.c
@@ -41,33 +41,27 @@ static int m62332_set_value(struct iio_dev *indio_dev, u8 val, int channel)
 	outbuf[0] = channel;
 	outbuf[1] = val;
 
-	mutex_lock(&data->mutex);
+	guard(mutex)(&data->mutex);
 
 	if (val) {
 		res = regulator_enable(data->vcc);
 		if (res)
-			goto out;
+			return res;
 	}
 
 	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
-	if (res >= 0 && res != ARRAY_SIZE(outbuf))
-		res = -EIO;
 	if (res < 0)
-		goto out;
+		return res;
+	if (res != ARRAY_SIZE(outbuf))
+		return -EIO;
 
 	data->raw[channel] = val;
 
 	if (!val)
 		regulator_disable(data->vcc);
 
-	mutex_unlock(&data->mutex);
-
 	return 0;
 
-out:
-	mutex_unlock(&data->mutex);
-
-	return res;
 }
 
 static int m62332_read_raw(struct iio_dev *indio_dev,
-- 
2.51.0

Re: [PATCH v2] iio: dac: m62332: Use guard(mutex) for locking

[Andy Shevchenko]

On Wed, Apr 15, 2026 at 08:01:18PM -0300, Erick Henrique wrote:
> Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
> simplify locking and make cleanup automatic when the lock goes out
> of scope.

...

> -	mutex_lock(&data->mutex);
> +	guard(mutex)(&data->mutex);

This is defined in the header that the patch missed to include.

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v2] iio: dac: m62332: Use guard(mutex) for locking

[Andy Shevchenko]

On Fri, Apr 17, 2026 at 10:58:29AM +0300, Andy Shevchenko wrote:
> On Wed, Apr 15, 2026 at 08:01:18PM -0300, Erick Henrique wrote:
> > Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
> > simplify locking and make cleanup automatic when the lock goes out
> > of scope.

...

> > -	mutex_lock(&data->mutex);
> > +	guard(mutex)(&data->mutex);
> 
> This is defined in the header that the patch missed to include.

I recommend to add a prerequisite patch that follows IWYU in the header block
and sort them alphabetically. With that done it will be easier to add any new
functionality that requires any additional header(s).

-- 
With Best Regards,
Andy Shevchenko

[PATCH v3 0/2] iio: dac: m62332: Use guard(mutex) for locking

[Erick Henrique]

This series refactors the m62332 driver to use guard(mutex) for
simpler locking, preceded by a header cleanup as suggested by
Andy Shevchenko.

Patch 1 applies IWYU to the header block, removes unused slab.h,
and sorts the includes alphabetically.

Patch 2 replaces mutex_lock()/mutex_unlock() pairs with guard(mutex)
and simplifies i2c_master_send() error handling. This patch also
adds <linux/cleanup.h> which is required by the guard() macro.

Changes since v2:
- Split into a two-patch series per Andy's suggestion
- Added missing <linux/cleanup.h> include
- Cleaned up header block (IWYU, alphabetical order)

Changes since v1:
- Split combined condition in i2c_master_send() error handling
  into two separate early returns

Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>

Erick Henrique (2):
  iio: dac: m62332: Clean up header includes
  iio: dac: m62332: Use guard(mutex) for locking

 drivers/iio/dac/m62332.c | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

-- 
2.51.0

[PATCH v3 1/2] iio: dac: m62332: Clean up header includes

[Erick Henrique]

Follow IWYU principle: explicitly include headers for symbols used
in this file, remove unused slab.h, and sort alphabetically.

This prepares the driver for adding new functionality that requires
additional headers.

Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
---
 drivers/iio/dac/m62332.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
index 3497513854d7..4b139904e818 100644
--- a/drivers/iio/dac/m62332.c
+++ b/drivers/iio/dac/m62332.c
@@ -8,13 +8,18 @@
  *  Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
  */
 
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
+#include <linux/array_size.h>
+#include <linux/bits.h>
+#include <linux/device.h>
 #include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/pm.h>
+#include <linux/types.h>
 
-#include <linux/iio/iio.h>
 #include <linux/iio/driver.h>
+#include <linux/iio/iio.h>
 
 #include <linux/regulator/consumer.h>
 
-- 
2.51.0

[PATCH v3 2/2] iio: dac: m62332: Use guard(mutex) for locking

[Erick Henrique]

Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
simplify locking and make cleanup automatic when the lock goes out
of scope. Also simplify the i2c_master_send() error handling by
using sequential early returns instead of a combined condition.

Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
---
 drivers/iio/dac/m62332.c | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
index 4b139904e818..a9bb6c307431 100644
--- a/drivers/iio/dac/m62332.c
+++ b/drivers/iio/dac/m62332.c
@@ -10,6 +10,7 @@
 
 #include <linux/array_size.h>
 #include <linux/bits.h>
+#include <linux/cleanup.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/i2c.h>
@@ -46,33 +47,26 @@ static int m62332_set_value(struct iio_dev *indio_dev, u8 val, int channel)
 	outbuf[0] = channel;
 	outbuf[1] = val;
 
-	mutex_lock(&data->mutex);
+	guard(mutex)(&data->mutex);
 
 	if (val) {
 		res = regulator_enable(data->vcc);
 		if (res)
-			goto out;
+			return res;
 	}
 
 	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
-	if (res >= 0 && res != ARRAY_SIZE(outbuf))
-		res = -EIO;
 	if (res < 0)
-		goto out;
+		return res;
+	if (res != ARRAY_SIZE(outbuf))
+		return -EIO;
 
 	data->raw[channel] = val;
 
 	if (!val)
 		regulator_disable(data->vcc);
 
-	mutex_unlock(&data->mutex);
-
 	return 0;
-
-out:
-	mutex_unlock(&data->mutex);
-
-	return res;
 }
 
 static int m62332_read_raw(struct iio_dev *indio_dev,
-- 
2.51.0

Re: [PATCH v3 0/2] iio: dac: m62332: Use guard(mutex) for locking

[Jonathan Cameron]

On Sat, 18 Apr 2026 10:03:20 -0300
Erick Henrique <erick.henrique.rodrigues@usp.br> wrote:

> This series refactors the m62332 driver to use guard(mutex) for
> simpler locking, preceded by a header cleanup as suggested by
> Andy Shevchenko.
> 
> Patch 1 applies IWYU to the header block, removes unused slab.h,
> and sorts the includes alphabetically.
> 
> Patch 2 replaces mutex_lock()/mutex_unlock() pairs with guard(mutex)
> and simplifies i2c_master_send() error handling. This patch also
> adds <linux/cleanup.h> which is required by the guard() macro.
> 
> Changes since v2:
> - Split into a two-patch series per Andy's suggestion
> - Added missing <linux/cleanup.h> include
> - Cleaned up header block (IWYU, alphabetical order)
> 
> Changes since v1:
> - Split combined condition in i2c_master_send() error handling
>   into two separate early returns
> 
> Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
> 
> Erick Henrique (2):
>   iio: dac: m62332: Clean up header includes
>   iio: dac: m62332: Use guard(mutex) for locking
> 
>  drivers/iio/dac/m62332.c | 31 +++++++++++++++----------------
>  1 file changed, 15 insertions(+), 16 deletions(-)
> 
Hi Erick,

A process comment.  Don't send new versions with the reply-to set.
They should be new threads not burried under an earlier discussion.
Combination of naming and version numbers is enough to associate
the versions though a nice convention is to also include a link
to the lore.kernel.org archive for the previous version.

One practical reason for this is many reviewers and maintainers
tend to catch up with their backlog starting with the latest
email threads (as often earlier versions have been superceeded!)
So I only found this 'in order' because I'm using patch work
as well for tracking purposes.

Thanks

Jonathan

Re: [PATCH v3 1/2] iio: dac: m62332: Clean up header includes

[Jonathan Cameron]

On Sat, 18 Apr 2026 10:03:21 -0300
Erick Henrique <erick.henrique.rodrigues@usp.br> wrote:

> Follow IWYU principle: explicitly include headers for symbols used
> in this file, remove unused slab.h, and sort alphabetically.
> 
> This prepares the driver for adding new functionality that requires
> additional headers.
> 
> Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
Hi Erick,

A few comments inline.

Thanks!

Jonathan

> ---
>  drivers/iio/dac/m62332.c | 13 +++++++++----
>  1 file changed, 9 insertions(+), 4 deletions(-)
> 
> diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
> index 3497513854d7..4b139904e818 100644
> --- a/drivers/iio/dac/m62332.c
> +++ b/drivers/iio/dac/m62332.c
> @@ -8,13 +8,18 @@
>   *  Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
>   */
>  
> -#include <linux/module.h>
> -#include <linux/slab.h>
> -#include <linux/i2c.h>

Resorting and new includes in one go does make it harder to see what
is done. Generally I'd prefer that as two patches when we have more than 
a very small number of includes. Sort first, then add / remove headers
as needed.

> +#include <linux/array_size.h>
> +#include <linux/bits.h>
> +#include <linux/device.h>
This is one of the more complex corners of applying IWYU to kernel code.
device.h is a bit of a legacy 'catch all' and much like kernel.h the
general direction of travel is to include more specific headers instead.

You probably need a forwards definition of
struct device;
just after the includes however as the pointer type is used.
I'm not immediately spotting any other use of device.h rather various
more specific headers but I might be missing it.

>  #include <linux/err.h>
> +#include <linux/i2c.h>
> +#include <linux/module.h>

I'd expect to see
mod_devicetable.h in pretty much any IIO driver as that's where the ID
tables are coming from.

> +#include <linux/mutex.h>
> +#include <linux/pm.h>
> +#include <linux/types.h>
>  
> -#include <linux/iio/iio.h>
>  #include <linux/iio/driver.h>
> +#include <linux/iio/iio.h>
>  
>  #include <linux/regulator/consumer.h>
>  

Re: [PATCH v3 2/2] iio: dac: m62332: Use guard(mutex) for locking

[Jonathan Cameron]

On Sat, 18 Apr 2026 10:03:22 -0300
Erick Henrique <erick.henrique.rodrigues@usp.br> wrote:

> Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
> simplify locking and make cleanup automatic when the lock goes out
> of scope. Also simplify the i2c_master_send() error handling by
> using sequential early returns instead of a combined condition.
> 
> Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
Looks good to me.

thanks,

Jonathan

Re: [PATCH v3 2/2] iio: dac: m62332: Use guard(mutex) for locking

[Jonathan Cameron]

On Sat, 18 Apr 2026 10:03:22 -0300
Erick Henrique <erick.henrique.rodrigues@usp.br> wrote:

> Replace mutex_lock()/mutex_unlock() calls with guard(mutex)() to
> simplify locking and make cleanup automatic when the lock goes out
> of scope. Also simplify the i2c_master_send() error handling by
> using sequential early returns instead of a combined condition.
> 
> Signed-off-by: Erick Henrique <erick.henrique.rodrigues@usp.br>
> ---
>  drivers/iio/dac/m62332.c | 18 ++++++------------
>  1 file changed, 6 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/iio/dac/m62332.c b/drivers/iio/dac/m62332.c
> index 4b139904e818..a9bb6c307431 100644
> --- a/drivers/iio/dac/m62332.c
> +++ b/drivers/iio/dac/m62332.c
> @@ -10,6 +10,7 @@
>  
>  #include <linux/array_size.h>
>  #include <linux/bits.h>
> +#include <linux/cleanup.h>
>  #include <linux/device.h>
>  #include <linux/err.h>
>  #include <linux/i2c.h>
> @@ -46,33 +47,26 @@ static int m62332_set_value(struct iio_dev *indio_dev, u8 val, int channel)
>  	outbuf[0] = channel;
>  	outbuf[1] = val;
>  
> -	mutex_lock(&data->mutex);
> +	guard(mutex)(&data->mutex);
>  
>  	if (val) {
>  		res = regulator_enable(data->vcc);
>  		if (res)
> -			goto out;
> +			return res;
>  	}
>  
>  	res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
> -	if (res >= 0 && res != ARRAY_SIZE(outbuf))
> -		res = -EIO;
>  	if (res < 0)
> -		goto out;
> +		return res;
> +	if (res != ARRAY_SIZE(outbuf))
> +		return -EIO;
>  
>  	data->raw[channel] = val;
>  
>  	if (!val)
>  		regulator_disable(data->vcc);
Not related to this patch, but sashiko is raising what looks to me
to be a valid point about this regulator handling.
https://sashiko.dev/#/patchset/20260418130322.106769-1-erick.henrique.rodrigues%40usp.br
(note some of the other 'bugs' reported' aren't bugs, but this one looks like it is
real to me)

The point is that a transition from val = 1, to val = 2 will enable
the regulator twice and then a transition to val = 0 will disable it only once
leaving the regulator (which is reference counted) turned on

J
>  
> -	mutex_unlock(&data->mutex);
> -
>  	return 0;
> -
> -out:
> -	mutex_unlock(&data->mutex);
> -
> -	return res;
>  }
>  
>  static int m62332_read_raw(struct iio_dev *indio_dev,