[PATCH v5] Input: drv260x: Fix suspend and resume sequencing
From: Maurizio Casciano
Date: Sun Aug 30 2026 - 21:00:36 EST
Force-feedback playback is queued asynchronously, but system suspend can
cut power while the worker is pending. Disable and drain the work item
before entering standby, and keep force-feedback quiesced until resume has
restored communication.
The enable GPIO gates I2C access without resetting the device. Raise it and
observe the startup delay before leaving standby after resume or a failed
regulator shutdown.
Use explicit locking and goto-based error unwinding. Keep the work item
disabled after a resume failure. Track whether it is already disabled
under the input mutex, so another suspend or a direct resume retry does not
increment the disable count and a later successful resume balances it
exactly once. Skip close-time register access while recovery remains
pending.
Reported-by: Sashiko AI review <sashiko-bot@xxxxxxxxxx>
Link: https://lore.kernel.org/linux-input/20260829230740.126461F000E9@xxxxxxxxxxxxxxx/
Link: https://lore.kernel.org/linux-input/20260830143050.03E081F000E9@xxxxxxxxxxxxxxx/
Suggested-by: Dmitry Torokhov <dmitry.torokhov@xxxxxxxxx>
Link: https://lore.kernel.org/linux-input/apLD91vzHIrLOPWC@xxxxxxxxxx/
Assisted-by: Codex:gpt-5.6-sol [sparse]
Signed-off-by: Maurizio Casciano <mauriziocasciano7@xxxxxxxxx>
---
Changes in v5:
- Keep the work item disabled after every resume failure, so force-feedback
cannot reach hardware whose regulator is off.
- Track the disabled state to avoid incrementing the work disable count again
on a later suspend or direct resume retry.
- Enable the work item only after resume has fully restored the regulator,
enable GPIO, and standby state, balancing the disable count exactly once.
- Avoid close-time register access while PM recovery is pending.
drivers/input/misc/drv260x.c | 80 ++++++++++++++++++++++++++++++------
1 file changed, 67 insertions(+), 13 deletions(-)
diff --git a/drivers/input/misc/drv260x.c b/drivers/input/misc/drv260x.c
index 6c5c4c53753b..f261bb32fdc0 100644
--- a/drivers/input/misc/drv260x.c
+++ b/drivers/input/misc/drv260x.c
@@ -181,6 +181,7 @@
* @work: Work item used to off load the enable/disable of the vibration
* @enable_gpio: Pointer to the gpio used for enable/disabling
* @regulator: Pointer to the regulator for the IC
+ * @work_disabled: Whether playback work is disabled pending PM recovery
* @magnitude: Magnitude of the vibration event
* @mode: The operating mode of the IC (LRA_NO_CAL, ERM or LRA)
* @library: The vibration library to be used
@@ -194,6 +195,7 @@ struct drv260x_data {
struct work_struct work;
struct gpio_desc *enable_gpio;
struct regulator *regulator;
+ bool work_disabled;
u8 magnitude;
u32 mode;
u32 library;
@@ -215,6 +217,24 @@ static int drv260x_calculate_voltage(unsigned int voltage)
return (voltage * 255 / 5600);
}
+static void drv260x_disable_work(struct drv260x_data *haptics)
+{
+ if (haptics->work_disabled)
+ return;
+
+ disable_work_sync(&haptics->work);
+ haptics->work_disabled = true;
+}
+
+static void drv260x_enable_work(struct drv260x_data *haptics)
+{
+ if (!haptics->work_disabled)
+ return;
+
+ enable_work(&haptics->work);
+ haptics->work_disabled = false;
+}
+
static void drv260x_worker(struct work_struct *work)
{
struct drv260x_data *haptics = container_of(work, struct drv260x_data, work);
@@ -263,6 +283,10 @@ static void drv260x_close(struct input_dev *input)
struct drv260x_data *haptics = input_get_drvdata(input);
int error;
+ /* PM has not restored register access yet. */
+ if (haptics->work_disabled)
+ return;
+
cancel_work_sync(&haptics->work);
error = regmap_write(haptics->regmap, DRV260X_MODE, DRV260X_STANDBY);
@@ -569,18 +593,22 @@ static int drv260x_probe(struct i2c_client *client)
static int drv260x_suspend(struct device *dev)
{
struct drv260x_data *haptics = dev_get_drvdata(dev);
- int error;
+ bool restore_work = false;
+ int error, restore_error;
- guard(mutex)(&haptics->input_dev->mutex);
+ mutex_lock(&haptics->input_dev->mutex);
if (input_device_enabled(haptics->input_dev)) {
+ restore_work = !haptics->work_disabled;
+ drv260x_disable_work(haptics);
+
error = regmap_update_bits(haptics->regmap,
DRV260X_MODE,
DRV260X_STANDBY_MASK,
DRV260X_STANDBY);
if (error) {
dev_err(dev, "Failed to set standby mode\n");
- return error;
+ goto err_enable_work;
}
gpiod_set_value(haptics->enable_gpio, 0);
@@ -588,14 +616,28 @@ static int drv260x_suspend(struct device *dev)
error = regulator_disable(haptics->regulator);
if (error) {
dev_err(dev, "Failed to disable regulator\n");
- regmap_update_bits(haptics->regmap,
- DRV260X_MODE,
- DRV260X_STANDBY_MASK, 0);
- return error;
+ goto err_leave_standby;
}
}
+ mutex_unlock(&haptics->input_dev->mutex);
return 0;
+
+err_leave_standby:
+ gpiod_set_value(haptics->enable_gpio, 1);
+ fsleep(250);
+ restore_error = regmap_update_bits(haptics->regmap,
+ DRV260X_MODE,
+ DRV260X_STANDBY_MASK, 0);
+ if (restore_error) {
+ dev_err(dev, "Failed to leave standby mode: %d\n", restore_error);
+ restore_work = false;
+ }
+err_enable_work:
+ if (restore_work)
+ drv260x_enable_work(haptics);
+ mutex_unlock(&haptics->input_dev->mutex);
+ return error;
}
static int drv260x_resume(struct device *dev)
@@ -603,28 +645,40 @@ static int drv260x_resume(struct device *dev)
struct drv260x_data *haptics = dev_get_drvdata(dev);
int error;
- guard(mutex)(&haptics->input_dev->mutex);
+ mutex_lock(&haptics->input_dev->mutex);
if (input_device_enabled(haptics->input_dev)) {
+ drv260x_disable_work(haptics);
+
error = regulator_enable(haptics->regulator);
if (error) {
dev_err(dev, "Failed to enable regulator\n");
- return error;
+ goto err_unlock;
}
+ gpiod_set_value(haptics->enable_gpio, 1);
+ fsleep(250);
+
error = regmap_update_bits(haptics->regmap,
DRV260X_MODE,
DRV260X_STANDBY_MASK, 0);
if (error) {
- dev_err(dev, "Failed to unset standby mode\n");
- regulator_disable(haptics->regulator);
- return error;
+ dev_err(dev, "Failed to leave standby mode: %d\n", error);
+ goto err_disable_regulator;
}
- gpiod_set_value(haptics->enable_gpio, 1);
+ drv260x_enable_work(haptics);
}
+ mutex_unlock(&haptics->input_dev->mutex);
return 0;
+
+err_disable_regulator:
+ gpiod_set_value(haptics->enable_gpio, 0);
+ regulator_disable(haptics->regulator);
+err_unlock:
+ mutex_unlock(&haptics->input_dev->mutex);
+ return error;
}
static DEFINE_SIMPLE_DEV_PM_OPS(drv260x_pm_ops, drv260x_suspend, drv260x_resume);
--
2.53.0