i2c: tegra: Fix NOIRQ suspend/resume

The Tegra I2C driver relies on runtime PM to wake up the controller before
each transfer. However, runtime PM is disabled between the system suspend
and NOIRQ suspend. If an I2C device initiates a transfer during this
window, the I2C controller fails to wake up and the transfer fails. To
handle this, the controller must be kept available for this period to
allow transfers.

Rework the I2C controller's system PM callbacks such that the controller
is resumed from runtime suspend during system suspend and it stays
RPM_ACTIVE throughout the suspend-resume cycle until it is runtime
suspended back in the system resume. The clocks are disabled in NOIRQ
suspend and enabled back in NOIRQ resume by calling the controller's
runtime PM functions directly.

Fixes: 8ebf15e9c869 ("i2c: tegra: Move suspend handling to NOIRQ phase")
Assisted-by: Cursor:claude-4.6-opus
Signed-off-by: Akhil R <akhilrajeev@nvidia.com>
Cc: <stable@vger.kernel.org> # v5.4+
Reviewed-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Andi Shyti <andi.shyti@kernel.org>
Link: https://lore.kernel.org/r/20260518114013.62065-5-akhilrajeev@nvidia.com

diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
index efe93c5a7bb8f3b84e0a861cc4db2170e6d46b41..400c9089daf0d79fa32be660e8723c9067476896 100644 (file)
--- a/drivers/i2c/busses/i2c-tegra.c
+++ b/drivers/i2c/busses/i2c-tegra.c
@@ -2401,29 +2401,38 @@ static int __maybe_unused tegra_i2c_runtime_suspend(struct device *dev)
 }
 
 static int __maybe_unused tegra_i2c_suspend(struct device *dev)
+{
+       /*
+        * Bring the controller up and hold a usage count so it stays
+        * available until the noirq phase.
+        */
+       return pm_runtime_resume_and_get(dev);
+}
+
+static int __maybe_unused tegra_i2c_suspend_noirq(struct device *dev)
 {
        struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
-       int err;
 
        i2c_mark_adapter_suspended(&i2c_dev->adapter);
 
-       if (!pm_runtime_status_suspended(dev)) {
-               err = tegra_i2c_runtime_suspend(dev);
-               if (err)
-                       return err;
-       }
-
-       return 0;
+       /*
+        * Runtime PM is already disabled at this point, so invoke the
+        * runtime_suspend callback directly to put the controller down.
+        */
+       return tegra_i2c_runtime_suspend(dev);
 }
 
-static int __maybe_unused tegra_i2c_resume(struct device *dev)
+static int __maybe_unused tegra_i2c_resume_noirq(struct device *dev)
 {
        struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
        int err;
 
        /*
-        * We need to ensure that clocks are enabled so that registers can be
-        * restored in tegra_i2c_init().
+        * Runtime PM is still disabled at this point, so invoke the
+        * runtime_resume callback directly to bring the controller back up
+        * before re-initializing the hardware. The adapter is then marked
+        * resumed so that consumers can issue transfers from their own
+        * resume_noirq() handlers and onwards.
         */
        err = tegra_i2c_runtime_resume(dev);
        if (err)
@@ -2433,24 +2442,22 @@ static int __maybe_unused tegra_i2c_resume(struct device *dev)
        if (err)
                return err;
 
-       /*
-        * In case we are runtime suspended, disable clocks again so that we
-        * don't unbalance the clock reference counts during the next runtime
-        * resume transition.
-        */
-       if (pm_runtime_status_suspended(dev)) {
-               err = tegra_i2c_runtime_suspend(dev);
-               if (err)
-                       return err;
-       }
-
        i2c_mark_adapter_resumed(&i2c_dev->adapter);
 
        return 0;
 }
 
+static int __maybe_unused tegra_i2c_resume(struct device *dev)
+{
+       pm_runtime_put(dev);
+
+       return 0;
+}
+
 static const struct dev_pm_ops tegra_i2c_pm = {
-       SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(tegra_i2c_suspend, tegra_i2c_resume)
+       SET_SYSTEM_SLEEP_PM_OPS(tegra_i2c_suspend, tegra_i2c_resume)
+       SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(tegra_i2c_suspend_noirq,
+                                     tegra_i2c_resume_noirq)
        SET_RUNTIME_PM_OPS(tegra_i2c_runtime_suspend, tegra_i2c_runtime_resume,
                           NULL)
 };