9 files changed, 148 insertions, 102 deletions

diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 3d6d4fd1e3c5..a951c22921d1 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -734,34 +734,24 @@ static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
  */
 static int acpiphp_bus_add(struct acpiphp_func *func)
 {
-        acpi_handle phandle;
-        struct acpi_device *device, *pdevice;
+        struct acpi_device *device;
         int ret_val;
 
-        acpi_get_parent(func->handle, &phandle);
-        if (acpi_bus_get_device(phandle, &pdevice)) {
-                dbg("no parent device, assuming NULL\n");
-                pdevice = NULL;
-        }
         if (!acpi_bus_get_device(func->handle, &device)) {
                 dbg("bus exists... trim\n");
                 /* this shouldn't be in here, so remove
                  * the bus then re-add it...
                  */
-                ret_val = acpi_bus_trim(device, 1);
-                dbg("acpi_bus_trim return %x\n", ret_val);
+                acpi_bus_trim(device);
         }
 
-        ret_val = acpi_bus_add(&device, pdevice, func->handle,
-                ACPI_BUS_TYPE_DEVICE);
-        if (ret_val) {
-                dbg("error adding bus, %x\n",
-                        -ret_val);
-                goto acpiphp_bus_add_out;
-        }
-        ret_val = acpi_bus_start(device);
+        ret_val = acpi_bus_scan(func->handle);
+        if (!ret_val)
+                ret_val = acpi_bus_get_device(func->handle, &device);
+
+        if (ret_val)
+                dbg("error adding bus, %x\n", -ret_val);
 
-acpiphp_bus_add_out:
         return ret_val;
 }
 
@@ -781,11 +771,8 @@ static int acpiphp_bus_trim(acpi_handle handle)
                 return retval;
         }
 
-        retval = acpi_bus_trim(device, 1);
-        if (retval)
-                err("cannot remove from acpi list\n");
-
-        return retval;
+        acpi_bus_trim(device);
+        return 0;
 }
 
 static void acpiphp_set_acpi_region(struct acpiphp_slot *slot)
@@ -1130,8 +1117,7 @@ static int acpiphp_configure_bridge (acpi_handle handle)
 
 static void handle_bridge_insertion(acpi_handle handle, u32 type)
 {
-        struct acpi_device *device, *pdevice;
-        acpi_handle phandle;
+        struct acpi_device *device;
 
         if ((type != ACPI_NOTIFY_BUS_CHECK) &&
                         (type != ACPI_NOTIFY_DEVICE_CHECK)) {
@@ -1139,17 +1125,15 @@ static void handle_bridge_insertion(acpi_handle handle, u32 type)
                 return;
         }
 
-        acpi_get_parent(handle, &phandle);
-        if (acpi_bus_get_device(phandle, &pdevice)) {
-                dbg("no parent device, assuming NULL\n");
-                pdevice = NULL;
-        }
-        if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) {
+        if (acpi_bus_scan(handle)) {
                 err("cannot add bridge to acpi list\n");
                 return;
         }
-        if (!acpiphp_configure_bridge(handle) &&
-                !acpi_bus_start(device))
+        if (acpi_bus_get_device(handle, &device)) {
+                err("ACPI device object missing\n");
+                return;
+        }
+        if (!acpiphp_configure_bridge(handle))
                 add_bridge(handle);
         else
                 err("cannot configure and start bridge\n");
@@ -1234,6 +1218,8 @@ static void _handle_hotplug_event_bridge(struct work_struct *work)
         handle = hp_work->handle;
         type = hp_work->type;
 
+        acpi_scan_lock_acquire();
+
         if (acpi_bus_get_device(handle, &device)) {
                 /* This bridge must have just been physically inserted */
                 handle_bridge_insertion(handle, type);
@@ -1311,6 +1297,7 @@ static void _handle_hotplug_event_bridge(struct work_struct *work)
         }
 
 out:
+        acpi_scan_lock_release();
         kfree(hp_work); /* allocated in handle_hotplug_event_bridge */
 }
 
@@ -1357,6 +1344,8 @@ static void _handle_hotplug_event_func(struct work_struct *work)
 
         func = (struct acpiphp_func *)context;
 
+        acpi_scan_lock_acquire();
+
         switch (type) {
         case ACPI_NOTIFY_BUS_CHECK:
                 /* bus re-enumerate */
@@ -1387,6 +1376,7 @@ static void _handle_hotplug_event_func(struct work_struct *work)
                 break;
         }
 
+        acpi_scan_lock_release();
         kfree(hp_work); /* allocated in handle_hotplug_event_func */
 }
 
diff --git a/drivers/pci/hotplug/sgi_hotplug.c b/drivers/pci/hotplug/sgi_hotplug.c
index f64ca92253da..574421bc2fa6 100644
--- a/drivers/pci/hotplug/sgi_hotplug.c
+++ b/drivers/pci/hotplug/sgi_hotplug.c
@@ -412,7 +412,6 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
         if (SN_ACPI_BASE_SUPPORT() && ssdt) {
                 unsigned long long adr;
                 struct acpi_device *pdevice;
-                struct acpi_device *device;
                 acpi_handle phandle;
                 acpi_handle chandle = NULL;
                 acpi_handle rethandle;
@@ -426,6 +425,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                         pdevice = NULL;
                 }
 
+                acpi_scan_lock_acquire();
                 /*
                  * Walk the rootbus node's immediate children looking for
                  * the slot's device node(s). There can be more than
@@ -448,20 +448,18 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                         if (ACPI_SUCCESS(ret) &&
                             (adr>>16) == (slot->device_num + 1)) {
 
-                                ret = acpi_bus_add(&device, pdevice, chandle,
-                                                   ACPI_BUS_TYPE_DEVICE);
+                                ret = acpi_bus_scan(chandle);
                                 if (ACPI_FAILURE(ret)) {
-                                        printk(KERN_ERR "%s: acpi_bus_add "
+                                        printk(KERN_ERR "%s: acpi_bus_scan "
                                                "failed (0x%x) for slot %d "
                                                "func %d\n", __func__,
                                                ret, (int)(adr>>16),
                                                (int)(adr&0xffff));
                                         /* try to continue on */
-                                } else {
-                                        acpi_bus_start(device);
                                 }
                         }
                 }
+                acpi_scan_lock_release();
         }
 
         /* Call the driver for the new device */
@@ -512,6 +510,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                 /* Get the rootbus node pointer */
                 phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
 
+                acpi_scan_lock_acquire();
                 /*
                  * Walk the rootbus node's immediate children looking for
                  * the slot's device node(s). There can be more than
@@ -539,10 +538,10 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                                 ret = acpi_bus_get_device(chandle,
                                                           &device);
                                 if (ACPI_SUCCESS(ret))
-                                        acpi_bus_trim(device, 1);
+                                        acpi_bus_trim(device);
                         }
                 }
-
+                acpi_scan_lock_release();
         }
 
         /* Free the SN resources assigned to the Linux device.*/
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 5099636a6e5f..00cc78c7aa04 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -845,6 +845,32 @@ int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
 }
 EXPORT_SYMBOL(pci_enable_msi_block);
 
+int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
+{
+        int ret, pos, nvec;
+        u16 msgctl;
+
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
+        if (!pos)
+                return -EINVAL;
+
+        pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &msgctl);
+        ret = 1 << ((msgctl & PCI_MSI_FLAGS_QMASK) >> 1);
+
+        if (maxvec)
+                *maxvec = ret;
+
+        do {
+                nvec = ret;
+                ret = pci_enable_msi_block(dev, nvec);
+        } while (ret > 0);
+
+        if (ret < 0)
+                return ret;
+        return nvec;
+}
+EXPORT_SYMBOL(pci_enable_msi_block_auto);
+
 void pci_msi_shutdown(struct pci_dev *dev)
 {
         struct msi_desc *desc;
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 1af4008182fd..e407c61559ca 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -283,7 +283,6 @@ static struct pci_platform_pm_ops acpi_pci_platform_pm = {
         .is_manageable = acpi_pci_power_manageable,
         .set_state = acpi_pci_set_power_state,
         .choose_state = acpi_pci_choose_state,
-        .can_wakeup = acpi_pci_can_wakeup,
         .sleep_wake = acpi_pci_sleep_wake,
         .run_wake = acpi_pci_run_wake,
 };
@@ -321,10 +320,65 @@ static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
         return 0;
 }
 
+static void pci_acpi_setup(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        acpi_handle handle = ACPI_HANDLE(dev);
+        struct acpi_device *adev;
+        acpi_status status;
+        acpi_handle dummy;
+
+        /*
+         * Evaluate and parse _PRT, if exists.  This code allows parsing of
+         * _PRT objects within the scope of non-bridge devices.  Note that
+         * _PRTs within the scope of a PCI bridge assume the bridge's
+         * subordinate bus number.
+         *
+         * TBD: Can _PRTs exist within the scope of non-bridge PCI devices?
+         */
+        status = acpi_get_handle(handle, METHOD_NAME__PRT, &dummy);
+        if (ACPI_SUCCESS(status)) {
+                unsigned char bus;
+
+                bus = pci_dev->subordinate ?
+                        pci_dev->subordinate->number : pci_dev->bus->number;
+                acpi_pci_irq_add_prt(handle, pci_domain_nr(pci_dev->bus), bus);
+        }
+
+        if (acpi_bus_get_device(handle, &adev) || !adev->wakeup.flags.valid)
+                return;
+
+        device_set_wakeup_capable(dev, true);
+        acpi_pci_sleep_wake(pci_dev, false);
+
+        pci_acpi_add_pm_notifier(adev, pci_dev);
+        if (adev->wakeup.flags.run_wake)
+                device_set_run_wake(dev, true);
+}
+
+static void pci_acpi_cleanup(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        acpi_handle handle = ACPI_HANDLE(dev);
+        struct acpi_device *adev;
+
+        if (!acpi_bus_get_device(handle, &adev) && adev->wakeup.flags.valid) {
+                device_set_wakeup_capable(dev, false);
+                device_set_run_wake(dev, false);
+                pci_acpi_remove_pm_notifier(adev);
+        }
+
+        if (pci_dev->subordinate)
+                acpi_pci_irq_del_prt(pci_domain_nr(pci_dev->bus),
+                                     pci_dev->subordinate->number);
+}
+
 static struct acpi_bus_type acpi_pci_bus = {
         .bus = &pci_bus_type,
         .find_device = acpi_pci_find_device,
         .find_bridge = acpi_pci_find_root_bridge,
+        .setup = pci_acpi_setup,
+        .cleanup = pci_acpi_cleanup,
 };
 
 static int __init acpi_pci_init(void)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 5cb5820fae40..0c4f641b7be1 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -450,7 +450,7 @@ static struct pci_platform_pm_ops *pci_platform_pm;
 int pci_set_platform_pm(struct pci_platform_pm_ops *ops)
 {
         if (!ops->is_manageable || !ops->set_state || !ops->choose_state
-            || !ops->sleep_wake || !ops->can_wakeup)
+            || !ops->sleep_wake)
                 return -EINVAL;
         pci_platform_pm = ops;
         return 0;
@@ -473,11 +473,6 @@ static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)
                         pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
 }
 
-static inline bool platform_pci_can_wakeup(struct pci_dev *dev)
-{
-        return pci_platform_pm ? pci_platform_pm->can_wakeup(dev) : false;
-}
-
 static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
 {
         return pci_platform_pm ?
@@ -1985,25 +1980,6 @@ void pci_pm_init(struct pci_dev *dev)
         }
 }
 
-/**
- * platform_pci_wakeup_init - init platform wakeup if present
- * @dev: PCI device
- *
- * Some devices don't have PCI PM caps but can still generate wakeup
- * events through platform methods (like ACPI events).  If @dev supports
- * platform wakeup events, set the device flag to indicate as much.  This
- * may be redundant if the device also supports PCI PM caps, but double
- * initialization should be safe in that case.
- */
-void platform_pci_wakeup_init(struct pci_dev *dev)
-{
-        if (!platform_pci_can_wakeup(dev))
-                return;
-
-        device_set_wakeup_capable(&dev->dev, true);
-        platform_pci_sleep_wake(dev, false);
-}
-
 static void pci_add_saved_cap(struct pci_dev *pci_dev,
         struct pci_cap_saved_state *new_cap)
 {
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index e8518292826f..adfd172c5b9b 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -43,9 +43,6 @@ int pci_probe_reset_function(struct pci_dev *dev);
  *                platform; to be used during system-wide transitions from a
  *                sleeping state to the working state and vice versa
  *
- * @can_wakeup: returns 'true' if given device is capable of waking up the
- *              system from a sleeping state
- *
  * @sleep_wake: enables/disables the system wake up capability of given device
  *
  * @run_wake: enables/disables the platform to generate run-time wake-up events
@@ -59,7 +56,6 @@ 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 (*choose_state)(struct pci_dev *dev);
-        bool (*can_wakeup)(struct pci_dev *dev);
         int (*sleep_wake)(struct pci_dev *dev, bool enable);
         int (*run_wake)(struct pci_dev *dev, bool enable);
 };
@@ -74,7 +70,6 @@ extern void pci_wakeup_bus(struct pci_bus *bus);
 extern void pci_config_pm_runtime_get(struct pci_dev *dev);
 extern void pci_config_pm_runtime_put(struct pci_dev *dev);
 extern void pci_pm_init(struct pci_dev *dev);
-extern void platform_pci_wakeup_init(struct pci_dev *dev);
 extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
 void pci_free_cap_save_buffers(struct pci_dev *dev);
 
diff --git a/drivers/pci/pcie/aer/aerdrv_errprint.c b/drivers/pci/pcie/aer/aerdrv_errprint.c
index 3ea51736f18d..5ab14251839d 100644
--- a/drivers/pci/pcie/aer/aerdrv_errprint.c
+++ b/drivers/pci/pcie/aer/aerdrv_errprint.c
@@ -23,6 +23,9 @@
 
 #include "aerdrv.h"
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/ras.h>
+
 #define AER_AGENT_RECEIVER              0
 #define AER_AGENT_REQUESTER             1
 #define AER_AGENT_COMPLETER             2
@@ -121,12 +124,11 @@ static const char *aer_agent_string[] = {
         "Transmitter ID"
 };
 
-static void __aer_print_error(const char *prefix,
+static void __aer_print_error(struct pci_dev *dev,
                               struct aer_err_info *info)
 {
         int i, status;
         const char *errmsg = NULL;
-
         status = (info->status & ~info->mask);
 
         for (i = 0; i < 32; i++) {
@@ -141,26 +143,22 @@ static void __aer_print_error(const char *prefix,
                                 aer_uncorrectable_error_string[i] : NULL;
 
                 if (errmsg)
-                        printk("%s""   [%2d] %-22s%s\n", prefix, i, errmsg,
+                        dev_err(&dev->dev, "   [%2d] %-22s%s\n", i, errmsg,
                                 info->first_error == i ? " (First)" : "");
                 else
-                        printk("%s""   [%2d] Unknown Error Bit%s\n", prefix, i,
-                                info->first_error == i ? " (First)" : "");
+                        dev_err(&dev->dev, "   [%2d] Unknown Error Bit%s\n",
+                                i, info->first_error == i ? " (First)" : "");
         }
 }
 
 void aer_print_error(struct pci_dev *dev, struct aer_err_info *info)
 {
         int id = ((dev->bus->number << 8) | dev->devfn);
-        char prefix[44];
-
-        snprintf(prefix, sizeof(prefix), "%s%s %s: ",
-                 (info->severity == AER_CORRECTABLE) ? KERN_WARNING : KERN_ERR,
-                 dev_driver_string(&dev->dev), dev_name(&dev->dev));
 
         if (info->status == 0) {
-                printk("%s""PCIe Bus Error: severity=%s, type=Unaccessible, "
-                        "id=%04x(Unregistered Agent ID)\n", prefix,
+                dev_err(&dev->dev,
+                        "PCIe Bus Error: severity=%s, type=Unaccessible, "
+                        "id=%04x(Unregistered Agent ID)\n",
                         aer_error_severity_string[info->severity], id);
         } else {
                 int layer, agent;
@@ -168,22 +166,24 @@ void aer_print_error(struct pci_dev *dev, struct aer_err_info *info)
                 layer = AER_GET_LAYER_ERROR(info->severity, info->status);
                 agent = AER_GET_AGENT(info->severity, info->status);
 
-                printk("%s""PCIe Bus Error: severity=%s, type=%s, id=%04x(%s)\n",
-                        prefix, aer_error_severity_string[info->severity],
+                dev_err(&dev->dev,
+                        "PCIe Bus Error: severity=%s, type=%s, id=%04x(%s)\n",
+                        aer_error_severity_string[info->severity],
                         aer_error_layer[layer], id, aer_agent_string[agent]);
 
-                printk("%s""  device [%04x:%04x] error status/mask=%08x/%08x\n",
-                        prefix, dev->vendor, dev->device,
+                dev_err(&dev->dev,
+                        "  device [%04x:%04x] error status/mask=%08x/%08x\n",
+                        dev->vendor, dev->device,
                         info->status, info->mask);
 
-                __aer_print_error(prefix, info);
+                __aer_print_error(dev, info);
 
                 if (info->tlp_header_valid) {
                         unsigned char *tlp = (unsigned char *) &info->tlp;
-                        printk("%s""  TLP Header:"
+                        dev_err(&dev->dev, "  TLP Header:"
                                 " %02x%02x%02x%02x %02x%02x%02x%02x"
                                 " %02x%02x%02x%02x %02x%02x%02x%02x\n",
-                                prefix, *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
+                                *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
                                 *(tlp + 7), *(tlp + 6), *(tlp + 5), *(tlp + 4),
                                 *(tlp + 11), *(tlp + 10), *(tlp + 9),
                                 *(tlp + 8), *(tlp + 15), *(tlp + 14),
@@ -192,8 +192,11 @@ void aer_print_error(struct pci_dev *dev, struct aer_err_info *info)
         }
 
         if (info->id && info->error_dev_num > 1 && info->id == id)
-                printk("%s""  Error of this Agent(%04x) is reported first\n",
-                        prefix, id);
+                dev_err(&dev->dev,
+                           "  Error of this Agent(%04x) is reported first\n",
+                        id);
+        trace_aer_event(dev_name(&dev->dev), (info->status & ~info->mask),
+                        info->severity);
 }
 
 void aer_print_port_info(struct pci_dev *dev, struct aer_err_info *info)
@@ -217,7 +220,7 @@ int cper_severity_to_aer(int cper_severity)
 }
 EXPORT_SYMBOL_GPL(cper_severity_to_aer);
 
-void cper_print_aer(const char *prefix, int cper_severity,
+void cper_print_aer(const char *prefix, struct pci_dev *dev, int cper_severity,
                     struct aer_capability_regs *aer)
 {
         int aer_severity, layer, agent, status_strs_size, tlp_header_valid = 0;
@@ -239,25 +242,27 @@ void cper_print_aer(const char *prefix, int cper_severity,
         }
         layer = AER_GET_LAYER_ERROR(aer_severity, status);
         agent = AER_GET_AGENT(aer_severity, status);
-        printk("%s""aer_status: 0x%08x, aer_mask: 0x%08x\n",
-               prefix, status, mask);
+        dev_err(&dev->dev, "aer_status: 0x%08x, aer_mask: 0x%08x\n",
+               status, mask);
         cper_print_bits(prefix, status, status_strs, status_strs_size);
-        printk("%s""aer_layer=%s, aer_agent=%s\n", prefix,
+        dev_err(&dev->dev, "aer_layer=%s, aer_agent=%s\n",
                aer_error_layer[layer], aer_agent_string[agent]);
         if (aer_severity != AER_CORRECTABLE)
-                printk("%s""aer_uncor_severity: 0x%08x\n",
-                       prefix, aer->uncor_severity);
+                dev_err(&dev->dev, "aer_uncor_severity: 0x%08x\n",
+                       aer->uncor_severity);
         if (tlp_header_valid) {
                 const unsigned char *tlp;
                 tlp = (const unsigned char *)&aer->header_log;
-                printk("%s""aer_tlp_header:"
+                dev_err(&dev->dev, "aer_tlp_header:"
                         " %02x%02x%02x%02x %02x%02x%02x%02x"
                         " %02x%02x%02x%02x %02x%02x%02x%02x\n",
-                        prefix, *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
+                        *(tlp + 3), *(tlp + 2), *(tlp + 1), *tlp,
                         *(tlp + 7), *(tlp + 6), *(tlp + 5), *(tlp + 4),
                         *(tlp + 11), *(tlp + 10), *(tlp + 9),
                         *(tlp + 8), *(tlp + 15), *(tlp + 14),
                         *(tlp + 13), *(tlp + 12));
         }
+        trace_aer_event(dev_name(&dev->dev), (status & ~mask),
+                        aer_severity);
 }
 #endif
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 6186f03d84f3..2dcd22d9c816 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -1280,7 +1280,6 @@ static void pci_init_capabilities(struct pci_dev *dev)
 
         /* Power Management */
         pci_pm_init(dev);
-        platform_pci_wakeup_init(dev);
 
         /* Vital Product Data */
         pci_vpd_pci22_init(dev);
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index 7c0fd9252e6f..84954a726a94 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -19,6 +19,8 @@ static void pci_free_resources(struct pci_dev *dev)
 
 static void pci_stop_dev(struct pci_dev *dev)
 {
+        pci_pme_active(dev, false);
+
         if (dev->is_added) {
                 pci_proc_detach_device(dev);
                 pci_remove_sysfs_dev_files(dev);