iio: proximity: sx93xx: keep the IRQ balanced across suspend and resume
v2 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. Without an interrupt line they also act on IRQ 0. One patch per driver, as the Fixes tags differ.
Changes in v2:
- Send as a series with a cover letter (Joshua)
- sx9310: move the wake-up register writes into a helper that uses guard(), so resume can use the usual early returns (Andy)
- sx9324, sx9360: no changes
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 | 41 ++++++++++++++++++++++------------ drivers/iio/proximity/sx9324.c | 31 +++++++++++++++---------- drivers/iio/proximity/sx9360.c | 33 ++++++++++++++++----------- 3 files changed, 66 insertions(+), 39 deletions(-)
base-commit: 2ef6f5c4ee56e90c237c5f7687f09e635f7d30a9
Signature · 1 line
2.53.0
PATCH v2 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. Without an interrupt line, client->irq is 0 and both callbacks act on IRQ 0, which the driver doesn't own.
Disable the interrupt only once the device is asleep, always enable it in resume, and skip both when there is no interrupt.
--- drivers/iio/proximity/sx9310.c | 41 ++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 14 deletions(-)
drivers/iio/proximity/sx9310.c +27 -14
@@ -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,7 +954,28 @@ 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; + +/* Only once nothing can fail, as resume isn't called on failure. */ +if (data->client->irq) +disable_irq_nosync (data->client->irq); + +return 0 ; +} + +static int sx9310_wake_up (struct sx_common_data *data) +{ +int ret; + +guard (mutex)(&data->mutex); + ret =regmap_write (data->regmap,SX9310_REG_PAUSE ,1 ); +if (ret) +return ret; + +return regmap_write (data->regmap,SX9310_REG_PROX_CTRL0 , + data->suspend_ctrl); }static int sx9310_resume (struct device *dev)
@@ -964,19 +983,13 @@ static int sx9310_resume(struct device *dev)struct sx_common_data *data =iio_priv (dev_get_drvdata (dev));int ret; - scoped_guard(mutex, &data->mutex) { - ret =regmap_write (data->regmap,SX9310_REG_PAUSE ,1 ); -if (ret) -return ret; + ret =sx9310_wake_up (data); - ret =regmap_write (data->regmap,SX9310_REG_PROX_CTRL0 , - data->suspend_ctrl); -if (ret) -return ret; - } +/* Balance the suspend even if the device couldn't be woken up. */ +if (data->client->irq) +enable_irq (data->client->irq); -enable_irq (data->client->irq); -return 0 ; +return ret; } static DEFINE_SIMPLE_DEV_PM_OPS(sx9310_pm_ops, sx9310_suspend, sx9310_resume);
Signature · 1 line
2.53.0
Re: [PATCH v2 1/3] iio: proximity: sx9310: keep the IRQ balanced across suspend and resume
Quoted 9 lines · Arnav Kapoor
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. Without an interrupt line,client->irqis 0 and both callbacks act on IRQ 0, which the driver doesn't own.Disable the interrupt only once the device is asleep, always enable it in resume, and skip both when there is no interrupt.
...
drivers/iio/proximity/sx9310.c static int sx9310_suspend(struct device *dev) · line 972
Quoted 5 lines
drivers/iio/proximity/sx9310.c +5
-0+static int sx9310_wake_up (struct sx_common_data *data) +{ +int ret; + +guard (mutex)(&data->mutex);
Add a blank line here.
*Yes, I saw other guard()() calls without blank lines in this file,
but that can be addressed afterwards)
drivers/iio/proximity/sx9310.c static int sx9310_suspend(struct device *dev) · line 978
Quoted 6 lines
drivers/iio/proximity/sx9310.c +6
-0+ ret =regmap_write (data->regmap,SX9310_REG_PAUSE ,1 ); +if (ret) +return ret; + +return regmap_write (data->regmap,SX9310_REG_PROX_CTRL0 , + data->suspend_ctrl);
With
struct regmap *map = data->regmap;
at the top of the function these become
ret = regmap_write(map, SX9310_REG_PAUSE, 1); if (ret) return ret; return regmap_write(map, SX9310_REG_PROX_CTRL0, data->suspend_ctrl);
Quoted 1 line
}
Signature · 2 lines
With Best Regards, Andy Shevchenko
PATCH v2 2/3 iio: proximity: sx9324: keep the IRQ balanced across suspend and resume
In reply to Arnav Kapoorsx9324_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. Without an interrupt line, client->irq is 0 and both callbacks act on IRQ 0, which the driver doesn't own.
Disable the interrupt only once the device is asleep, always enable it in resume, and skip both when there is no interrupt.
--- drivers/iio/proximity/sx9324.c | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-)
drivers/iio/proximity/sx9324.c +19 -12
@@ -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 , ®val);if (ret <0 )
@@ -1100,23 +1098,32 @@ 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; + +/* Only once nothing can fail, as resume isn't called on failure. */ +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)); +int ret; - 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; - } +scoped_guard (mutex, &data->mutex) + ret = regmap_write(data->regmap, SX9324_REG_GNRL_CTRL1, + data->suspend_ctrl | +SX9324_REG_GNRL_CTRL1_PAUSECTRL ); -enable_irq (data->client->irq); -return 0 ; +/* Balance the suspend even if the device couldn't be woken up. */ +if (data->client->irq) +enable_irq (data->client->irq); + +return ret; } static DEFINE_SIMPLE_DEV_PM_OPS(sx9324_pm_ops, sx9324_suspend, sx9324_resume);
Signature · 1 line
2.53.0
PATCH v2 3/3 iio: proximity: sx9360: keep the IRQ balanced across suspend and resume
In reply to Arnav Kapoorsx9360_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. Without an interrupt line, client->irq is 0 and both callbacks act on IRQ 0, which the driver doesn't own.
Disable the interrupt only once the device is asleep, always enable it in resume, and skip both when there is no interrupt.
--- drivers/iio/proximity/sx9360.c | 33 ++++++++++++++++++++------------- 1 file changed, 20 insertions(+), 13 deletions(-)
drivers/iio/proximity/sx9360.c +20 -13
@@ -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 , ®val);if (ret <0 )
@@ -809,23 +807,32 @@ 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; + +/* Only once nothing can fail, as resume isn't called on failure. */ +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)); +int ret; - 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 ; +scoped_guard (mutex, &data->mutex) + ret = regmap_update_bits(data->regmap, SX9360_REG_GNRL_CTRL0, +SX9360_REG_GNRL_CTRL0_PHEN_MASK , + data->suspend_ctrl); + +/* Balance the suspend even if the device couldn't be woken up. */ +if (data->client->irq) +enable_irq (data->client->irq); + +return ret; } static DEFINE_SIMPLE_DEV_PM_OPS(sx9360_pm_ops, sx9360_suspend, sx9360_resume);
Signature · 1 line
2.53.0
Quoted 11 lines · On Mon, 26 Oct 2026 16:53:03 +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. Without an interrupt line they also act on IRQ 0. One patch per driver, as the Fixes tags differ.
Changes in v2:
- Send as a series with a cover letter (Joshua)
- sx9310: move the wake-up register writes into a helper that usesguard(), so resume can use the usual early returns (Andy)
- sx9324, sx9360: no changes
Quoted 7 lines
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.
The code seems good, would be great if someone could test this.
Signature · 2 lines
Kind regards, Joshua Crofts