PM / Runtime: Rework the "runtime idle" helper routine

The "runtime idle" helper routine, rpm_idle(), currently ignores
return values from .runtime_idle() callbacks executed by it.
However, it turns out that many subsystems use
pm_generic_runtime_idle() which checks the return value of the
driver's callback and executes pm_runtime_suspend() for the device
unless that value is not 0.  If that logic is moved to rpm_idle()
instead, pm_generic_runtime_idle() can be dropped and its users
will not need any .runtime_idle() callbacks any more.

Moreover, the PCI, SCSI, and SATA subsystems' .runtime_idle()
routines, pci_pm_runtime_idle(), scsi_runtime_idle(), and
ata_port_runtime_idle(), respectively, as well as a few drivers'
ones may be simplified if rpm_idle() calls rpm_suspend() after 0 has
been returned by the .runtime_idle() callback executed by it.

To reduce overall code bloat, make the changes described above.

Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Tested-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Kevin Hilman <khilman@linaro.org>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Acked-by: Alan Stern <stern@rowland.harvard.edu>

4 files changed, 5 insertions, 32 deletions

diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 9eda84246ffd..96a930387ebc 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -888,7 +888,6 @@ int platform_pm_restore(struct device *dev)
 static const struct dev_pm_ops platform_dev_pm_ops = {
         .runtime_suspend = pm_generic_runtime_suspend,
         .runtime_resume = pm_generic_runtime_resume,
-        .runtime_idle = pm_generic_runtime_idle,
         USE_PLATFORM_PM_SLEEP_OPS
 };
 
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index 7072404c8b6d..bfb8955c406c 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -2143,7 +2143,6 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
         genpd->max_off_time_changed = true;
         genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
         genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
-        genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
         genpd->domain.ops.prepare = pm_genpd_prepare;
         genpd->domain.ops.suspend = pm_genpd_suspend;
         genpd->domain.ops.suspend_late = pm_genpd_suspend_late;
diff --git a/drivers/base/power/generic_ops.c b/drivers/base/power/generic_ops.c
index bfd898b8988e..5ee030a864f9 100644
--- a/drivers/base/power/generic_ops.c
+++ b/drivers/base/power/generic_ops.c
@@ -12,29 +12,6 @@
 
 #ifdef CONFIG_PM_RUNTIME
 /**
- * pm_generic_runtime_idle - Generic runtime idle callback for subsystems.
- * @dev: Device to handle.
- *
- * If PM operations are defined for the @dev's driver and they include
- * ->runtime_idle(), execute it and return its error code, if nonzero.
- * Otherwise, execute pm_runtime_suspend() for the device and return 0.
- */
-int pm_generic_runtime_idle(struct device *dev)
-{
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-
-        if (pm && pm->runtime_idle) {
-                int ret = pm->runtime_idle(dev);
-                if (ret)
-                        return ret;
-        }
-
-        pm_runtime_suspend(dev);
-        return 0;
-}
-EXPORT_SYMBOL_GPL(pm_generic_runtime_idle);
-
-/**
  * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
  * @dev: Device to suspend.
  *
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index ef13ad08afb2..268a35097578 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -293,11 +293,8 @@ static int rpm_idle(struct device *dev, int rpmflags)
         /* Pending requests need to be canceled. */
         dev->power.request = RPM_REQ_NONE;
 
-        if (dev->power.no_callbacks) {
-                /* Assume ->runtime_idle() callback would have suspended. */
-                retval = rpm_suspend(dev, rpmflags);
+        if (dev->power.no_callbacks)
                 goto out;
-        }
 
         /* Carry out an asynchronous or a synchronous idle notification. */
         if (rpmflags & RPM_ASYNC) {
@@ -306,7 +303,8 @@ static int rpm_idle(struct device *dev, int rpmflags)
                         dev->power.request_pending = true;
                         queue_work(pm_wq, &dev->power.work);
                 }
-                goto out;
+                trace_rpm_return_int(dev, _THIS_IP_, 0);
+                return 0;
         }
 
         dev->power.idle_notification = true;
@@ -326,14 +324,14 @@ static int rpm_idle(struct device *dev, int rpmflags)
                 callback = dev->driver->pm->runtime_idle;
 
         if (callback)
-                __rpm_callback(callback, dev);
+                retval = __rpm_callback(callback, dev);
 
         dev->power.idle_notification = false;
         wake_up_all(&dev->power.wait_queue);
 
  out:
         trace_rpm_return_int(dev, _THIS_IP_, retval);
-        return retval;
+        return retval ? retval : rpm_suspend(dev, rpmflags);
 }
 
 /**