4 files changed, 33 insertions, 21 deletions

diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index d36f41ea8cbf..cd3c4f1cdf1b 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -46,6 +46,9 @@ static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
         struct pci_dev *pci_dev = context;
 
         if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_dev) {
+                if (pci_dev->pme_poll)
+                        pci_dev->pme_poll = false;
+
                 pci_wakeup_event(pci_dev);
                 pci_check_pme_status(pci_dev);
                 pm_runtime_resume(&pci_dev->dev);
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index e9651f0a8817..7cd417e94058 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1407,13 +1407,16 @@ bool pci_check_pme_status(struct pci_dev *dev)
 /**
  * pci_pme_wakeup - Wake up a PCI device if its PME Status bit is set.
  * @dev: Device to handle.
- * @ign: Ignored.
+ * @pme_poll_reset: Whether or not to reset the device's pme_poll flag.
  *
  * Check if @dev has generated PME and queue a resume request for it in that
  * case.
  */
-static int pci_pme_wakeup(struct pci_dev *dev, void *ign)
+static int pci_pme_wakeup(struct pci_dev *dev, void *pme_poll_reset)
 {
+        if (pme_poll_reset && dev->pme_poll)
+                dev->pme_poll = false;
+
         if (pci_check_pme_status(dev)) {
                 pci_wakeup_event(dev);
                 pm_request_resume(&dev->dev);
@@ -1428,7 +1431,7 @@ static int pci_pme_wakeup(struct pci_dev *dev, void *ign)
 void pci_pme_wakeup_bus(struct pci_bus *bus)
 {
         if (bus)
-                pci_walk_bus(bus, pci_pme_wakeup, NULL);
+                pci_walk_bus(bus, pci_pme_wakeup, (void *)true);
 }
 
 /**
@@ -1446,31 +1449,26 @@ bool pci_pme_capable(struct pci_dev *dev, pci_power_t state)
 
 static void pci_pme_list_scan(struct work_struct *work)
 {
-        struct pci_pme_device *pme_dev;
+        struct pci_pme_device *pme_dev, *n;
 
         mutex_lock(&pci_pme_list_mutex);
         if (!list_empty(&pci_pme_list)) {
-                list_for_each_entry(pme_dev, &pci_pme_list, list)
-                        pci_pme_wakeup(pme_dev->dev, NULL);
-                schedule_delayed_work(&pci_pme_work, msecs_to_jiffies(PME_TIMEOUT));
+                list_for_each_entry_safe(pme_dev, n, &pci_pme_list, list) {
+                        if (pme_dev->dev->pme_poll) {
+                                pci_pme_wakeup(pme_dev->dev, NULL);
+                        } else {
+                                list_del(&pme_dev->list);
+                                kfree(pme_dev);
+                        }
+                }
+                if (!list_empty(&pci_pme_list))
+                        schedule_delayed_work(&pci_pme_work,
+                                              msecs_to_jiffies(PME_TIMEOUT));
         }
         mutex_unlock(&pci_pme_list_mutex);
 }
 
 /**
- * pci_external_pme - is a device an external PCI PME source?
- * @dev: PCI device to check
- *
- */
-
-static bool pci_external_pme(struct pci_dev *dev)
-{
-        if (pci_is_pcie(dev) || dev->bus->number == 0)
-                return false;
-        return true;
-}
-
-/**
  * pci_pme_active - enable or disable PCI device's PME# function
  * @dev: PCI device to handle.
  * @enable: 'true' to enable PME# generation; 'false' to disable it.
@@ -1503,7 +1501,7 @@ void pci_pme_active(struct pci_dev *dev, bool enable)
            hit, and the power savings from the devices will still be a
            win. */
 
-        if (pci_external_pme(dev)) {
+        if (dev->pme_poll) {
                 struct pci_pme_device *pme_dev;
                 if (enable) {
                         pme_dev = kmalloc(sizeof(struct pci_pme_device),
@@ -1821,6 +1819,7 @@ void pci_pm_init(struct pci_dev *dev)
                          (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
                          (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
                 dev->pme_support = pmc >> PCI_PM_CAP_PME_SHIFT;
+                dev->pme_poll = true;
                 /*
                  * Make device's PM flags reflect the wake-up capability, but
                  * let the user space enable it to wake up the system as needed.
diff --git a/drivers/pci/pcie/pme.c b/drivers/pci/pcie/pme.c
index 0057344a3fcb..001f1b78f39c 100644
--- a/drivers/pci/pcie/pme.c
+++ b/drivers/pci/pcie/pme.c
@@ -84,6 +84,9 @@ static bool pcie_pme_walk_bus(struct pci_bus *bus)
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 /* Skip PCIe devices in case we started from a root port. */
                 if (!pci_is_pcie(dev) && pci_check_pme_status(dev)) {
+                        if (dev->pme_poll)
+                                dev->pme_poll = false;
+
                         pci_wakeup_event(dev);
                         pm_request_resume(&dev->dev);
                         ret = true;
@@ -142,6 +145,9 @@ static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id)
 
         /* First, check if the PME is from the root port itself. */
         if (port->devfn == devfn && port->bus->number == busnr) {
+                if (port->pme_poll)
+                        port->pme_poll = false;
+
                 if (pci_check_pme_status(port)) {
                         pm_request_resume(&port->dev);
                         found = true;
@@ -187,6 +193,9 @@ static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id)
                 /* The device is there, but we have to check its PME status. */
                 found = pci_check_pme_status(dev);
                 if (found) {
+                        if (dev->pme_poll)
+                                dev->pme_poll = false;
+
                         pci_wakeup_event(dev);
                         pm_request_resume(&dev->dev);
                 }
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 4ff6d4e9455c..176c981a90d4 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -273,6 +273,7 @@ struct pci_dev {
         unsigned int    pme_support:5;  /* Bitmask of states from which PME#
                                            can be generated */
         unsigned int    pme_interrupt:1;
+        unsigned int    pme_poll:1;     /* Poll device's PME status bit */
         unsigned int    d1_support:1;   /* Low power state D1 is supported */
         unsigned int    d2_support:1;   /* Low power state D2 is supported */
         unsigned int    no_d1d2:1;      /* Only allow D0 and D3 */