PCI / PM: Take SMART_SUSPEND driver flag into account

Make the PCI bus type take DPM_FLAG_SMART_SUSPEND into account in its
system-wide PM callbacks and make sure that all code that should not
run in parallel with pci_pm_runtime_resume() is executed in the "late"
phases of system suspend, freeze and poweroff transitions.

[Note that the pm_runtime_suspended() check in pci_dev_keep_suspended()
is an optimization, because if is not passed, all of the subsequent
checks may be skipped and some of them are much more overhead in
general.]

Also use the observation that if the device is in runtime suspend
at the beginning of the "late" phase of a system-wide suspend-like
transition, its state cannot change going forward (runtime PM is
disabled for it at that time) until the transition is over and the
subsequent system-wide PM callbacks should be skipped for it (as
they generally assume the device to not be suspended), so add checks
for that in pci_pm_suspend_late/noirq(), pci_pm_freeze_late/noirq()
and pci_pm_poweroff_late/noirq().

Moreover, if pci_pm_resume_noirq() or pci_pm_restore_noirq() is
called during the subsequent system-wide resume transition and if
the device was left in runtime suspend previously, its runtime PM
status needs to be changed to "active" as it is going to be put
into the full-power state, so add checks for that too to these
functions.

In turn, if pci_pm_thaw_noirq() runs after the device has been
left in runtime suspend, the subsequent "thaw" callbacks need
to be skipped for it (as they may not work correctly with a
suspended device), so set the power.direct_complete flag for the
device then to make the PM core skip those callbacks.

In addition to the above add a core helper for checking if
DPM_FLAG_SMART_SUSPEND is set and the device runtime PM status is
"suspended" at the same time, which is done quite often in the new
code (and will be done elsewhere going forward too).

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: Bjorn Helgaas <bhelgaas@google.com>

diff --git a/Documentation/power/pci.txt b/Documentation/power/pci.txt
index ab4e7d0540c15e3d7cdcdb7a20d1349a00f70228..304162ea377eddd3c2b133fbda1f23378e8f6967 100644 (file)
--- a/Documentation/power/pci.txt
+++ b/Documentation/power/pci.txt
@@ -980,6 +980,20 @@ positive value from pci_pm_prepare() if the ->prepare callback provided by the
 driver of the device returns a positive value.  That allows the driver to opt
 out from using the direct-complete mechanism dynamically.
 
+The DPM_FLAG_SMART_SUSPEND flag tells the PCI bus type that from the driver's
+perspective the device can be safely left in runtime suspend during system
+suspend.  That causes pci_pm_suspend(), pci_pm_freeze() and pci_pm_poweroff()
+to skip resuming the device from runtime suspend unless there are PCI-specific
+reasons for doing that.  Also, it causes pci_pm_suspend_late/noirq(),
+pci_pm_freeze_late/noirq() and pci_pm_poweroff_late/noirq() to return early
+if the device remains in runtime suspend in the beginning of the "late" phase
+of the system-wide transition under way.  Moreover, if the device is in
+runtime suspend in pci_pm_resume_noirq() or pci_pm_restore_noirq(), its runtime
+power management status will be changed to "active" (as it is going to be put
+into D0 going forward), but if it is in runtime suspend in pci_pm_thaw_noirq(),
+the function will set the power.direct_complete flag for it (to make the PM core
+skip the subsequent "thaw" callbacks for it) and return.
+
 3.2. Device Runtime Power Management
 ------------------------------------
 In addition to providing device power management callbacks PCI device drivers

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 8d9024017645daeec1c69aa406dd96d22d853a92..6c6f1c74c24cdee9250a1e90b2352e80636bb61b 100644 (file)
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -1861,3 +1861,9 @@ void device_pm_check_callbacks(struct device *dev)
                 !dev->driver->suspend && !dev->driver->resume));
        spin_unlock_irq(&dev->power.lock);
 }
+
+bool dev_pm_smart_suspend_and_suspended(struct device *dev)
+{
+       return dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) &&
+               pm_runtime_status_suspended(dev);
+}

diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index c1aeeb10539e416d566a4a3e6af15cec72fb7367..d19bd54d337e4a5175c74411b62e910b40b7c829 100644 (file)
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -734,18 +734,25 @@ static int pci_pm_suspend(struct device *dev)
 
        if (!pm) {
                pci_pm_default_suspend(pci_dev);
-               goto Fixup;
+               return 0;
        }
 
        /*
-        * PCI devices suspended at run time need to be resumed at this point,
-        * because in general it is necessary to reconfigure them for system
-        * suspend.  Namely, if the device is supposed to wake up the system
-        * from the sleep state, we may need to reconfigure it for this purpose.
-        * In turn, if the device is not supposed to wake up the system from the
-        * sleep state, we'll have to prevent it from signaling wake-up.
+        * PCI devices suspended at run time may need to be resumed at this
+        * point, because in general it may be necessary to reconfigure them for
+        * system suspend.  Namely, if the device is expected to wake up the
+        * system from the sleep state, it may have to be reconfigured for this
+        * purpose, or if the device is not expected to wake up the system from
+        * the sleep state, it should be prevented from signaling wakeup events
+        * going forward.
+        *
+        * Also if the driver of the device does not indicate that its system
+        * suspend callbacks can cope with runtime-suspended devices, it is
+        * better to resume the device from runtime suspend here.
         */
-       pm_runtime_resume(dev);
+       if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
+           !pci_dev_keep_suspended(pci_dev))
+               pm_runtime_resume(dev);
 
        pci_dev->state_saved = false;
        if (pm->suspend) {
@@ -765,17 +772,27 @@ static int pci_pm_suspend(struct device *dev)
                }
        }
 
- Fixup:
-       pci_fixup_device(pci_fixup_suspend, pci_dev);
-
        return 0;
 }
 
+static int pci_pm_suspend_late(struct device *dev)
+{
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
+       pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
+
+       return pm_generic_suspend_late(dev);
+}
+
 static int pci_pm_suspend_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
        if (pci_has_legacy_pm_support(pci_dev))
                return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 
@@ -834,6 +851,14 @@ static int pci_pm_resume_noirq(struct device *dev)
        struct device_driver *drv = dev->driver;
        int error = 0;
 
+       /*
+        * Devices with DPM_FLAG_SMART_SUSPEND may be left in runtime suspend
+        * during system suspend, so update their runtime PM status to "active"
+        * as they are going to be put into D0 shortly.
+        */
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               pm_runtime_set_active(dev);
+
        pci_pm_default_resume_early(pci_dev);
 
        if (pci_has_legacy_pm_support(pci_dev))
@@ -876,6 +901,7 @@ static int pci_pm_resume(struct device *dev)
 #else /* !CONFIG_SUSPEND */
 
 #define pci_pm_suspend         NULL
+#define pci_pm_suspend_late    NULL
 #define pci_pm_suspend_noirq   NULL
 #define pci_pm_resume          NULL
 #define pci_pm_resume_noirq    NULL
@@ -910,7 +936,8 @@ static int pci_pm_freeze(struct device *dev)
         * devices should not be touched during freeze/thaw transitions,
         * however.
         */
-       pm_runtime_resume(dev);
+       if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND))
+               pm_runtime_resume(dev);
 
        pci_dev->state_saved = false;
        if (pm->freeze) {
@@ -925,11 +952,22 @@ static int pci_pm_freeze(struct device *dev)
        return 0;
 }
 
+static int pci_pm_freeze_late(struct device *dev)
+{
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
+       return pm_generic_freeze_late(dev);;
+}
+
 static int pci_pm_freeze_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
 
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
        if (pci_has_legacy_pm_support(pci_dev))
                return pci_legacy_suspend_late(dev, PMSG_FREEZE);
 
@@ -959,6 +997,16 @@ static int pci_pm_thaw_noirq(struct device *dev)
        struct device_driver *drv = dev->driver;
        int error = 0;
 
+       /*
+        * If the device is in runtime suspend, the code below may not work
+        * correctly with it, so skip that code and make the PM core skip all of
+        * the subsequent "thaw" callbacks for the device.
+        */
+       if (dev_pm_smart_suspend_and_suspended(dev)) {
+               dev->power.direct_complete = true;
+               return 0;
+       }
+
        if (pcibios_pm_ops.thaw_noirq) {
                error = pcibios_pm_ops.thaw_noirq(dev);
                if (error)
@@ -1008,11 +1056,13 @@ static int pci_pm_poweroff(struct device *dev)
 
        if (!pm) {
                pci_pm_default_suspend(pci_dev);
-               goto Fixup;
+               return 0;
        }
 
        /* The reason to do that is the same as in pci_pm_suspend(). */
-       pm_runtime_resume(dev);
+       if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
+           !pci_dev_keep_suspended(pci_dev))
+               pm_runtime_resume(dev);
 
        pci_dev->state_saved = false;
        if (pm->poweroff) {
@@ -1024,17 +1074,27 @@ static int pci_pm_poweroff(struct device *dev)
                        return error;
        }
 
- Fixup:
-       pci_fixup_device(pci_fixup_suspend, pci_dev);
-
        return 0;
 }
 
+static int pci_pm_poweroff_late(struct device *dev)
+{
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
+       pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
+
+       return pm_generic_poweroff_late(dev);
+}
+
 static int pci_pm_poweroff_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
 
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               return 0;
+
        if (pci_has_legacy_pm_support(to_pci_dev(dev)))
                return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 
@@ -1076,6 +1136,10 @@ static int pci_pm_restore_noirq(struct device *dev)
        struct device_driver *drv = dev->driver;
        int error = 0;
 
+       /* This is analogous to the pci_pm_resume_noirq() case. */
+       if (dev_pm_smart_suspend_and_suspended(dev))
+               pm_runtime_set_active(dev);
+
        if (pcibios_pm_ops.restore_noirq) {
                error = pcibios_pm_ops.restore_noirq(dev);
                if (error)
@@ -1124,10 +1188,12 @@ static int pci_pm_restore(struct device *dev)
 #else /* !CONFIG_HIBERNATE_CALLBACKS */
 
 #define pci_pm_freeze          NULL
+#define pci_pm_freeze_late     NULL
 #define pci_pm_freeze_noirq    NULL
 #define pci_pm_thaw            NULL
 #define pci_pm_thaw_noirq      NULL
 #define pci_pm_poweroff                NULL
+#define pci_pm_poweroff_late   NULL
 #define pci_pm_poweroff_noirq  NULL
 #define pci_pm_restore         NULL
 #define pci_pm_restore_noirq   NULL
@@ -1243,10 +1309,13 @@ static const struct dev_pm_ops pci_dev_pm_ops = {
        .prepare = pci_pm_prepare,
        .complete = pci_pm_complete,
        .suspend = pci_pm_suspend,
+       .suspend_late = pci_pm_suspend_late,
        .resume = pci_pm_resume,
        .freeze = pci_pm_freeze,
+       .freeze_late = pci_pm_freeze_late,
        .thaw = pci_pm_thaw,
        .poweroff = pci_pm_poweroff,
+       .poweroff_late = pci_pm_poweroff_late,
        .restore = pci_pm_restore,
        .suspend_noirq = pci_pm_suspend_noirq,
        .resume_noirq = pci_pm_resume_noirq,

diff --git a/include/linux/pm.h b/include/linux/pm.h
index 43b5418e05bb0ee8db693c5437c7fd2149801a59..65d39115f06d8780399e469ed44fc1c90f074e69 100644 (file)
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -765,6 +765,8 @@ extern int pm_generic_poweroff_late(struct device *dev);
 extern int pm_generic_poweroff(struct device *dev);
 extern void pm_generic_complete(struct device *dev);
 
+extern bool dev_pm_smart_suspend_and_suspended(struct device *dev);
+
 #else /* !CONFIG_PM_SLEEP */
 
 #define device_pm_lock() do {} while (0)