Skip to contentSkip to conversation

iio: proximity: sx93xx: keep the IRQ balanced across suspend and resume

PATCH Superseded Arnav Kapoor 2 participants 6 messages Nov 1 – Nov 12 IIO

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v4 cover iio: proximity: sx93xx: keep the IRQ balanced across suspend and resume

sx9310, sx9324 and sx9360 disable the interrupt in suspend before anything that can fail, and don't enable it again when suspend or resume fails. One patch per driver, as the Fixes tags differ.

Changes in v4:
- Enable the interrupt first in resume, so resume mirrors suspend (Jonathan). This also drops the sx9310_wake_up() helper from v3.
- Drop the IRQ 0 wording from the commit messages (Jonathan)
- Drop Joshua's Reviewed-by, as resume changed

v3: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/all/[email protected]/
v1:
https://lore.kernel.org/all/[email protected]/
https://lore.kernel.org/all/[email protected]/
https://lore.kernel.org/all/[email protected]/

Compile-tested only (W=1); I don't have the hardware and haven't reproduced a failing suspend.

Arnav Kapoor (3):
iio: proximity: sx9310: keep the IRQ balanced across suspend and
resume
iio: proximity: sx9324: keep the IRQ balanced across suspend and
resume
iio: proximity: sx9360: keep the IRQ balanced across suspend and
resume

 drivers/iio/proximity/sx9310.c | 32 ++++++++++++++++++--------------
 drivers/iio/proximity/sx9324.c | 28 ++++++++++++++++------------
 drivers/iio/proximity/sx9360.c | 30 +++++++++++++++++-------------
 3 files changed, 51 insertions(+), 39 deletions(-)

base-commit: 2ef6f5c4ee56e90c237c5f7687f09e635f7d30a9

Signature · 1 line
2.53.0
#1 lore raw

PATCH v4 1/3 iio: proximity: sx9310: keep the IRQ balanced across suspend and resume

sx9310_suspend() disables the interrupt first and returns with it still disabled if a register access fails. Resume isn't called after a failed suspend, so the interrupt is never enabled again. sx9310_resume() also returns without enabling it on error.

Make the two mirror images: disable the interrupt as the last step of suspend and enable it as the first step of resume, before anything can fail. The driver works without an interrupt line, so skip both calls when client->irq is 0, as sx_common already does.

Fixes 72ad02b15d63 ("iio: Add SEMTECH SX9310/9311 sensor driver")
---
 drivers/iio/proximity/sx9310.c | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)
drivers/iio/proximity/sx9310.c +18 -14
index 79ba46d8a0aa..373037ca67d1 100644
@@ -943,8 +943,6 @@ static int sx9310_suspend(struct device *dev)
 	u8 ctrl0;
 	int ret;
 
-	disable_irq_nosync(data->client->irq);
-
 	guard(mutex)(&data->mutex);
 	ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0,
 			  &data->suspend_ctrl);
@@ -956,27 +954,33 @@ static int sx9310_suspend(struct device *dev)
 	if (ret)
 		return ret;
 
-	return regmap_write(data->regmap, SX9310_REG_PAUSE, 0);
+	ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 0);
+	if (ret)
+		return ret;
+
+	/* Last, as resume isn't called if suspend fails. */
+	if (data->client->irq)
+		disable_irq_nosync(data->client->irq);
+
+	return 0;
 }
 
 static int sx9310_resume(struct device *dev)
 {
 	struct sx_common_data *data = iio_priv(dev_get_drvdata(dev));
+	struct regmap *map = data->regmap;
 	int ret;
 
-	scoped_guard(mutex, &data->mutex) {
-		ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 1);
-		if (ret)
-			return ret;
+	if (data->client->irq)
+		enable_irq(data->client->irq);
 
-		ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
-				   data->suspend_ctrl);
-		if (ret)
-			return ret;
-	}
+	guard(mutex)(&data->mutex);
 
-	enable_irq(data->client->irq);
-	return 0;
+	ret = regmap_write(map, SX9310_REG_PAUSE, 1);
+	if (ret)
+		return ret;
+
+	return regmap_write(map, SX9310_REG_PROX_CTRL0, data->suspend_ctrl);
 }
 
 static DEFINE_SIMPLE_DEV_PM_OPS(sx9310_pm_ops, sx9310_suspend, sx9310_resume);
Signature · 1 line
2.53.0
#2 lore raw

PATCH v4 2/3 iio: proximity: sx9324: keep the IRQ balanced across suspend and resume

In reply to Arnav Kapoor

sx9324_suspend() disables the interrupt first and returns with it still disabled if a register access fails. Resume isn't called after a failed suspend, so the interrupt is never enabled again. sx9324_resume() also returns without enabling it on error.

Make the two mirror images: disable the interrupt as the last step of suspend and enable it as the first step of resume, before anything can fail. The driver works without an interrupt line, so skip both calls when client->irq is 0, as sx_common already does.

Fixes 4c18a890dff8 ("iio:proximity:sx9324: Add SX9324 support")
---
 drivers/iio/proximity/sx9324.c | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)
drivers/iio/proximity/sx9324.c +16 -12
index 255a36976ac4..a76c49dda354 100644
@@ -1088,8 +1088,6 @@ static int sx9324_suspend(struct device *dev)
 	unsigned int regval;
 	int ret;
 
-	disable_irq_nosync(data->client->irq);
-
 	guard(mutex)(&data->mutex);
 	ret = regmap_read(data->regmap, SX9324_REG_GNRL_CTRL1, &regval);
 	if (ret < 0)
@@ -1100,23 +1098,29 @@ static int sx9324_suspend(struct device *dev)
 
 
 	/* Disable all phases, send the device to sleep. */
-	return regmap_write(data->regmap, SX9324_REG_GNRL_CTRL1, 0);
+	ret = regmap_write(data->regmap, SX9324_REG_GNRL_CTRL1, 0);
+	if (ret)
+		return ret;
+
+	/* Last, as resume isn't called if suspend fails. */
+	if (data->client->irq)
+		disable_irq_nosync(data->client->irq);
+
+	return 0;
 }
 
 static int sx9324_resume(struct device *dev)
 {
 	struct sx_common_data *data = iio_priv(dev_get_drvdata(dev));
 
-	scoped_guard(mutex, &data->mutex) {
-		int ret = regmap_write(data->regmap, SX9324_REG_GNRL_CTRL1,
-				       data->suspend_ctrl |
-				       SX9324_REG_GNRL_CTRL1_PAUSECTRL);
-		if (ret)
-			return ret;
-	}
+	if (data->client->irq)
+		enable_irq(data->client->irq);
 
-	enable_irq(data->client->irq);
-	return 0;
+	guard(mutex)(&data->mutex);
+
+	return regmap_write(data->regmap, SX9324_REG_GNRL_CTRL1,
+			    data->suspend_ctrl |
+			    SX9324_REG_GNRL_CTRL1_PAUSECTRL);
 }
 
 static DEFINE_SIMPLE_DEV_PM_OPS(sx9324_pm_ops, sx9324_suspend, sx9324_resume);
Signature · 1 line
2.53.0
#3 lore raw

PATCH v4 3/3 iio: proximity: sx9360: keep the IRQ balanced across suspend and resume

In reply to Arnav Kapoor

sx9360_suspend() disables the interrupt first and returns with it still disabled if a register access fails. Resume isn't called after a failed suspend, so the interrupt is never enabled again. sx9360_resume() also returns without enabling it on error.

Make the two mirror images: disable the interrupt as the last step of suspend and enable it as the first step of resume, before anything can fail. The driver works without an interrupt line, so skip both calls when client->irq is 0, as sx_common already does.

Fixes 1cdb4c47f7f5 ("iio:proximity:sx9360: Add sx9360 support")
---
 drivers/iio/proximity/sx9360.c | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)
drivers/iio/proximity/sx9360.c +17 -13
index ed83d809ecf5..f89c556e0989 100644
@@ -797,8 +797,6 @@ static int sx9360_suspend(struct device *dev)
 	unsigned int regval;
 	int ret;
 
-	disable_irq_nosync(data->client->irq);
-
 	guard(mutex)(&data->mutex);
 	ret = regmap_read(data->regmap, SX9360_REG_GNRL_CTRL0, &regval);
 	if (ret < 0)
@@ -809,23 +807,29 @@ static int sx9360_suspend(struct device *dev)
 
 
 	/* Disable all phases, send the device to sleep. */
-	return regmap_write(data->regmap, SX9360_REG_GNRL_CTRL0, 0);
+	ret = regmap_write(data->regmap, SX9360_REG_GNRL_CTRL0, 0);
+	if (ret)
+		return ret;
+
+	/* Last, as resume isn't called if suspend fails. */
+	if (data->client->irq)
+		disable_irq_nosync(data->client->irq);
+
+	return 0;
 }
 
 static int sx9360_resume(struct device *dev)
 {
 	struct sx_common_data *data = iio_priv(dev_get_drvdata(dev));
 
-	scoped_guard(mutex, &data->mutex) {
-		int ret = regmap_update_bits(data->regmap,
-					     SX9360_REG_GNRL_CTRL0,
-					     SX9360_REG_GNRL_CTRL0_PHEN_MASK,
-					     data->suspend_ctrl);
-		if (ret)
-			return ret;
-	}
-	enable_irq(data->client->irq);
-	return 0;
+	if (data->client->irq)
+		enable_irq(data->client->irq);
+
+	guard(mutex)(&data->mutex);
+
+	return regmap_update_bits(data->regmap, SX9360_REG_GNRL_CTRL0,
+				  SX9360_REG_GNRL_CTRL0_PHEN_MASK,
+				  data->suspend_ctrl);
 }
 
 static DEFINE_SIMPLE_DEV_PM_OPS(sx9360_pm_ops, sx9360_suspend, sx9360_resume);
Signature · 1 line
2.53.0
maintainer
#4 lore raw
In reply to Arnav Kapoor
Quoted 9 lines · On Sun, 1 Nov 2026 15:55:01 +0530 Arnav Kapoor <[email protected]> wrote:

sx9310, sx9324 and sx9360 disable the interrupt in suspend before anything that can fail, and don't enable it again when suspend or resume fails. One patch per driver, as the Fixes tags differ.

Changes in v4:
- Enable the interrupt first in resume, so resume mirrors suspend (Jonathan). This also drops the sx9310_wake_up() helper from v3.
- Drop the IRQ 0 wording from the commit messages (Jonathan)
- Drop Joshua's Reviewed-by, as resume changed

All 3 of these look fine to me, but given they aren't totally trivial I'm going to leave them for a while in the hope someone will test at least one of them! If it looks like that's not happening I may pick them up in a week or two.

Thanks,

Jonathan

Quoted 26 lines

v3: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/all/[email protected]/
v1:
https://lore.kernel.org/all/[email protected]/
https://lore.kernel.org/all/[email protected]/
https://lore.kernel.org/all/[email protected]/

Compile-tested only (W=1); I don't have the hardware and haven't reproduced a failing suspend.

Arnav Kapoor (3):
iio: proximity: sx9310: keep the IRQ balanced across suspend and
resume
iio: proximity: sx9324: keep the IRQ balanced across suspend and
resume
iio: proximity: sx9360: keep the IRQ balanced across suspend and
resume

 drivers/iio/proximity/sx9310.c | 32 ++++++++++++++++++--------------
 drivers/iio/proximity/sx9324.c | 28 ++++++++++++++++------------
 drivers/iio/proximity/sx9360.c | 30 +++++++++++++++++-------------
 3 files changed, 51 insertions(+), 39 deletions(-)

base-commit: 2ef6f5c4ee56e90c237c5f7687f09e635f7d30a9

#5 lore raw
Quoted 4 lines · Jonathan Cameron

All 3 of these look fine to me, but given they aren't totally trivial I'm going to leave them for a while in the hope someone will test at least one of them! If it looks like that's not happening I may pick them up in a week or two.

Please don't pick these up yet, I found a problem with v4.

Moving disable_irq_nosync() to the end of suspend leaves the interrupt enabled while suspend holds data->mutex for the register writes. If the sensor fires then, the threaded handler blocks on the mutex, and since disable_irq_nosync() doesn't wait for it, it runs once suspend returns, against a paused sensor. Sashiko pointed this out on sx9310, and sx9324 and sx9360 have the same pattern.

I'll send v5 that calls disable_irq() before taking the mutex and enables the interrupt again if suspend fails.

Thanks,
Arnav