Merge branch 'pci/pm' into next

* pci/pm:
  PCI: Avoid unnecessary resume after direct-complete
  PCI: Recognize D3cold in pci_update_current_state()
  PCI: Query platform firmware for device power state
  PCI: Afford direct-complete to devices with non-standard PM

4 files changed, 73 insertions, 19 deletions

diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 9a033e8ee9a4..d966d47c9e80 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -452,6 +452,27 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
         return error;
 }
 
+static pci_power_t acpi_pci_get_power_state(struct pci_dev *dev)
+{
+        struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
+        static const pci_power_t state_conv[] = {
+                [ACPI_STATE_D0]      = PCI_D0,
+                [ACPI_STATE_D1]      = PCI_D1,
+                [ACPI_STATE_D2]      = PCI_D2,
+                [ACPI_STATE_D3_HOT]  = PCI_D3hot,
+                [ACPI_STATE_D3_COLD] = PCI_D3cold,
+        };
+        int state;
+
+        if (!adev || !acpi_device_power_manageable(adev))
+                return PCI_UNKNOWN;
+
+        if (acpi_device_get_power(adev, &state) || state == ACPI_STATE_UNKNOWN)
+                return PCI_UNKNOWN;
+
+        return state_conv[state];
+}
+
 static bool acpi_pci_can_wakeup(struct pci_dev *dev)
 {
         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
@@ -534,6 +555,7 @@ static bool acpi_pci_need_resume(struct pci_dev *dev)
 static const struct pci_platform_pm_ops acpi_pci_platform_pm = {
         .is_manageable = acpi_pci_power_manageable,
         .set_state = acpi_pci_set_power_state,
+        .get_state = acpi_pci_get_power_state,
         .choose_state = acpi_pci_choose_state,
         .sleep_wake = acpi_pci_sleep_wake,
         .run_wake = acpi_pci_run_wake,
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index edd78e04b693..1ccce1cd6aca 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -682,8 +682,19 @@ static int pci_pm_prepare(struct device *dev)
 
 static void pci_pm_complete(struct device *dev)
 {
-        pci_dev_complete_resume(to_pci_dev(dev));
-        pm_complete_with_resume_check(dev);
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+
+        pci_dev_complete_resume(pci_dev);
+        pm_generic_complete(dev);
+
+        /* Resume device if platform firmware has put it in reset-power-on */
+        if (dev->power.direct_complete && pm_resume_via_firmware()) {
+                pci_power_t pre_sleep_state = pci_dev->current_state;
+
+                pci_update_current_state(pci_dev, pci_dev->current_state);
+                if (pci_dev->current_state < pre_sleep_state)
+                        pm_request_resume(dev);
+        }
 }
 
 #else /* !CONFIG_PM_SLEEP */
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index aab9d5115a5f..b2be8957a290 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -552,8 +552,9 @@ static const struct pci_platform_pm_ops *pci_platform_pm;
 
 int pci_set_platform_pm(const struct pci_platform_pm_ops *ops)
 {
-        if (!ops->is_manageable || !ops->set_state || !ops->choose_state ||
-            !ops->sleep_wake || !ops->run_wake || !ops->need_resume)
+        if (!ops->is_manageable || !ops->set_state  || !ops->get_state ||
+            !ops->choose_state  || !ops->sleep_wake || !ops->run_wake  ||
+            !ops->need_resume)
                 return -EINVAL;
         pci_platform_pm = ops;
         return 0;
@@ -570,6 +571,11 @@ static inline int platform_pci_set_power_state(struct pci_dev *dev,
         return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;
 }
 
+static inline pci_power_t platform_pci_get_power_state(struct pci_dev *dev)
+{
+        return pci_platform_pm ? pci_platform_pm->get_state(dev) : PCI_UNKNOWN;
+}
+
 static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
 {
         return pci_platform_pm ?
@@ -701,26 +707,25 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
 }
 
 /**
- * pci_update_current_state - Read PCI power state of given device from its
- *                            PCI PM registers and cache it
+ * pci_update_current_state - Read power state of given device and cache it
  * @dev: PCI device to handle.
  * @state: State to cache in case the device doesn't have the PM capability
+ *
+ * The power state is read from the PMCSR register, which however is
+ * inaccessible in D3cold.  The platform firmware is therefore queried first
+ * to detect accessibility of the register.  In case the platform firmware
+ * reports an incorrect state or the device isn't power manageable by the
+ * platform at all, we try to detect D3cold by testing accessibility of the
+ * vendor ID in config space.
  */
 void pci_update_current_state(struct pci_dev *dev, pci_power_t state)
 {
-        if (dev->pm_cap) {
+        if (platform_pci_get_power_state(dev) == PCI_D3cold ||
+            !pci_device_is_present(dev)) {
+                dev->current_state = PCI_D3cold;
+        } else if (dev->pm_cap) {
                 u16 pmcsr;
 
-                /*
-                 * Configuration space is not accessible for device in
-                 * D3cold, so just keep or set D3cold for safety
-                 */
-                if (dev->current_state == PCI_D3cold)
-                        return;
-                if (state == PCI_D3cold) {
-                        dev->current_state = PCI_D3cold;
-                        return;
-                }
                 pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
                 dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
         } else {
@@ -1959,9 +1964,22 @@ static pci_power_t pci_target_state(struct pci_dev *dev)
                 default:
                         target_state = state;
                 }
-        } else if (!dev->pm_cap) {
+
+                return target_state;
+        }
+
+        if (!dev->pm_cap)
                 target_state = PCI_D0;
-        } else if (device_may_wakeup(&dev->dev)) {
+
+        /*
+         * If the device is in D3cold even though it's not power-manageable by
+         * the platform, it may have been powered down by non-standard means.
+         * Best to let it slumber.
+         */
+        if (dev->current_state == PCI_D3cold)
+                target_state = PCI_D3cold;
+
+        if (device_may_wakeup(&dev->dev)) {
                 /*
                  * Find the deepest state from which the device can generate
                  * wake-up events, make it the target state and enable device
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 194521bfb1a3..451856210e18 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -42,6 +42,8 @@ int pci_probe_reset_function(struct pci_dev *dev);
  *
  * @set_state: invokes the platform firmware to set the device's power state
  *
+ * @get_state: queries the platform firmware for a device's current power state
+ *
  * @choose_state: returns PCI power state of given device preferred by the
  *                platform; to be used during system-wide transitions from a
  *                sleeping state to the working state and vice versa
@@ -62,6 +64,7 @@ int pci_probe_reset_function(struct pci_dev *dev);
 struct pci_platform_pm_ops {
         bool (*is_manageable)(struct pci_dev *dev);
         int (*set_state)(struct pci_dev *dev, pci_power_t state);
+        pci_power_t (*get_state)(struct pci_dev *dev);
         pci_power_t (*choose_state)(struct pci_dev *dev);
         int (*sleep_wake)(struct pci_dev *dev, bool enable);
         int (*run_wake)(struct pci_dev *dev, bool enable);