25 files changed, 458 insertions, 71 deletions
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index 0b51857fbaf7..dc1aa0922868 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -55,6 +55,9 @@ obj-$(CONFIG_MICROBLAZE) += setup-bus.o
 #
 obj-$(CONFIG_ACPI)    += pci-acpi.o
+# SMBIOS provided firmware instance and labels
+obj-$(CONFIG_DMI)    += pci-label.o
 # Cardbus & CompactPCI use setup-bus
 obj-$(CONFIG_HOTPLUG) += setup-bus.o
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 628ea20a8841..7f0af0e9b826 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -56,7 +56,7 @@ void pci_bus_remove_resources(struct pci_bus *bus)
        int i;
        for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
-                bus->resource[i] = 0;
+                bus->resource[i] = NULL;
        list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) {
                list_del(&bus_res->list);
@@ -240,6 +240,8 @@ void pci_enable_bridges(struct pci_bus *bus)
                if (dev->subordinate) {
                        if (!pci_is_enabled(dev)) {
                                retval = pci_enable_device(dev);
+                                if (retval)
+                                        dev_err(&dev->dev, "Error enabling bridge (%d), continuing\n", retval);
                                pci_set_master(dev);
                        }
                        pci_enable_bridges(dev->subordinate);
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 5317e4d7d96e..17d10e2e8fb6 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -135,7 +135,7 @@ static int __init init_legacy(void)
        struct pci_dev *pdev = NULL;
        /* Add existing devices */
-        while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)))
+        for_each_pci_dev(pdev)
                legacy_add_slot(pdev);
        /* Be alerted of any new ones */
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 2fce726758d2..a4031dfe938e 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -137,7 +137,7 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                                         "Cannot remove display device %s\n",
                                         pci_name(temp));
                                pci_dev_put(temp);
-                                rc = EINVAL;
+                                rc = -EINVAL;
                                break;
                        }
                }
diff --git a/drivers/pci/hotplug/shpchp_hpc.c b/drivers/pci/hotplug/shpchp_hpc.c
index 5f5e8d2e3552..d3985e7deab7 100644
--- a/drivers/pci/hotplug/shpchp_hpc.c
+++ b/drivers/pci/hotplug/shpchp_hpc.c
@@ -113,7 +113,7 @@
 #define CON_PFAULT_INTR_MASK    (1 << 28)
 #define MRL_CHANGE_SERR_MASK    (1 << 29)
 #define CON_PFAULT_SERR_MASK    (1 << 30)
-#define SLOT_REG_RSVDZ_MASK     (1 << 15) | (7 << 21)
+#define SLOT_REG_RSVDZ_MASK     ((1 << 15) | (7 << 21))
 /*
 * SHPC Command Code definitnions
diff --git a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c
index 8c3d3219f227..a2ccfcd3c298 100644
--- a/drivers/pci/hotplug/shpchp_pci.c
+++ b/drivers/pci/hotplug/shpchp_pci.c
@@ -60,12 +60,6 @@ int __ref shpchp_configure_device(struct slot *p_slot)
                dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, fn));
                if (!dev)
                        continue;
-                if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
-                        ctrl_err(ctrl, "Cannot hot-add display device %s\n",
-                                 pci_name(dev));
-                        pci_dev_put(dev);
-                        continue;
-                }
                if ((dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) ||
                                (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
                        /* Find an unused bus number for the new bridge */
@@ -114,17 +108,11 @@ int shpchp_unconfigure_device(struct slot *p_slot)
        ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:%02x\n",
                 __func__, pci_domain_nr(parent), p_slot->bus, p_slot->device);
-        for (j=0; j<8 ; j++) {
+        for (j = 0; j < 8 ; j++) {
-                struct pci_dev* temp = pci_get_slot(parent,
+                struct pci_dev *temp = pci_get_slot(parent,
                                (p_slot->device << 3) | j);
                if (!temp)
                        continue;
-                if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
-                        ctrl_err(ctrl, "Cannot remove display device %s\n",
-                                 pci_name(temp));
-                        pci_dev_put(temp);
-                        continue;
-                }
                if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
                        pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
                        if (bctl & PCI_BRIDGE_CTL_VGA) {
@@ -132,7 +120,8 @@ int shpchp_unconfigure_device(struct slot *p_slot)
                                         "Cannot remove display device %s\n",
                                         pci_name(temp));
                                pci_dev_put(temp);
-                                continue;
+                                rc = -EINVAL;
+                                break;
                        }
                }
                pci_remove_bus_device(temp);
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index 603cdc0c854a..c3ceebb5be84 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -3030,6 +3030,34 @@ static void __init iommu_exit_mempool(void)
 }
+static void quirk_ioat_snb_local_iommu(struct pci_dev *pdev)
+{
+        struct dmar_drhd_unit *drhd;
+        u32 vtbar;
+        int rc;
+        /* We know that this device on this chipset has its own IOMMU.
+         * If we find it under a different IOMMU, then the BIOS is lying
+         * to us. Hope that the IOMMU for this device is actually
+         * disabled, and it needs no translation...
+         */
+        rc = pci_bus_read_config_dword(pdev->bus, PCI_DEVFN(0, 0), 0xb0, &vtbar);
+        if (rc) {
+                /* "can't" happen */
+                dev_info(&pdev->dev, "failed to run vt-d quirk\n");
+                return;
+        }
+        vtbar &= 0xffff0000;
+        /* we know that the this iommu should be at offset 0xa000 from vtbar */
+        drhd = dmar_find_matched_drhd_unit(pdev);
+        if (WARN_TAINT_ONCE(!drhd || drhd->reg_base_addr - vtbar != 0xa000,
+                            TAINT_FIRMWARE_WORKAROUND,
+                            "BIOS assigned incorrect VT-d unit for Intel(R) QuickData Technology device\n"))
+                pdev->dev.archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO;
+}
+DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB, quirk_ioat_snb_local_iommu);
 static void __init init_no_remapping_devices(void)
 {
        struct dmar_drhd_unit *drhd;
@@ -3698,6 +3726,8 @@ static int intel_iommu_domain_has_cap(struct iommu_domain *domain,
        if (cap == IOMMU_CAP_CACHE_COHERENCY)
                return dmar_domain->iommu_snooping;
+        if (cap == IOMMU_CAP_INTR_REMAP)
+                return intr_remapping_enabled;
        return 0;
 }
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 45478ef7dd74..fd1d2867cdcc 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -329,8 +329,8 @@ int modify_irte(int irq, struct irte *irte_modified)
        index = irq_iommu->irte_index + irq_iommu->sub_handle;
        irte = &iommu->ir_table->base[index];
-        set_64bit((unsigned long *)&irte->low, irte_modified->low);
+        set_64bit(&irte->low, irte_modified->low);
-        set_64bit((unsigned long *)&irte->high, irte_modified->high);
+        set_64bit(&irte->high, irte_modified->high);
        __iommu_flush_cache(iommu, irte, sizeof(*irte));
        rc = qi_flush_iec(iommu, index, 0);
@@ -411,8 +411,8 @@ static int clear_entries(struct irq_2_iommu *irq_iommu)
        end = start + (1 << irq_iommu->irte_mask);
        for (entry = start; entry < end; entry++) {
-                set_64bit((unsigned long *)&entry->low, 0);
+                set_64bit(&entry->low, 0);
-                set_64bit((unsigned long *)&entry->high, 0);
+                set_64bit(&entry->high, 0);
        }
        return qi_flush_iec(iommu, index, irq_iommu->irte_mask);
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 77b68eaf021e..69b7be33b3a2 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -196,6 +196,9 @@ void unmask_msi_irq(unsigned int irq)
 void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 {
        struct msi_desc *entry = get_irq_desc_msi(desc);
+        BUG_ON(entry->dev->current_state != PCI_D0);
        if (entry->msi_attrib.is_msix) {
                void __iomem *base = entry->mask_base +
                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
@@ -229,10 +232,32 @@ void read_msi_msg(unsigned int irq, struct msi_msg *msg)
        read_msi_msg_desc(desc, msg);
 }
+void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+{
+        struct msi_desc *entry = get_irq_desc_msi(desc);
+        /* Assert that the cache is valid, assuming that
+         * valid messages are not all-zeroes. */
+        BUG_ON(!(entry->msg.address_hi | entry->msg.address_lo |
+                 entry->msg.data));
+        *msg = entry->msg;
+}
+void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        get_cached_msi_msg_desc(desc, msg);
+}
 void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 {
        struct msi_desc *entry = get_irq_desc_msi(desc);
-        if (entry->msi_attrib.is_msix) {
+        if (entry->dev->current_state != PCI_D0) {
+                /* Don't touch the hardware now */
+        } else if (entry->msi_attrib.is_msix) {
                void __iomem *base;
                base = entry->mask_base +
                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
@@ -435,7 +460,7 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
 static void __iomem *msix_map_region(struct pci_dev *dev, unsigned pos,
                                                        unsigned nr_entries)
 {
-        unsigned long phys_addr;
+        resource_size_t phys_addr;
        u32 table_offset;
        u8 bir;
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 2e7a3bf13824..24e19c594e57 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -48,6 +48,7 @@ static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
        if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_dev) {
                pci_check_pme_status(pci_dev);
                pm_runtime_resume(&pci_dev->dev);
+                pci_wakeup_event(pci_dev);
                if (pci_dev->subordinate)
                        pci_pme_wakeup_bus(pci_dev->subordinate);
        }
@@ -295,14 +296,12 @@ static int acpi_dev_run_wake(struct device *phys_dev, bool enable)
                if (!dev->wakeup.run_wake_count++) {
                        acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0);
                        acpi_enable_gpe(dev->wakeup.gpe_device,
-                                        dev->wakeup.gpe_number,
+                                        dev->wakeup.gpe_number);
-                                        ACPI_GPE_TYPE_RUNTIME);
                }
        } else if (dev->wakeup.run_wake_count > 0) {
                if (!--dev->wakeup.run_wake_count) {
                        acpi_disable_gpe(dev->wakeup.gpe_device,
-                                         dev->wakeup.gpe_number,
+                                         dev->wakeup.gpe_number);
-                                         ACPI_GPE_TYPE_RUNTIME);
                        acpi_disable_wakeup_device_power(dev);
                }
        } else {
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index f9a0aec3abcf..8a6f797de8e5 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -289,8 +289,26 @@ struct drv_dev_and_id {
 static long local_pci_probe(void *_ddi)
 {
        struct drv_dev_and_id *ddi = _ddi;
+        struct device *dev = &ddi->dev->dev;
-        return ddi->drv->probe(ddi->dev, ddi->id);
+        int rc;
+        /* Unbound PCI devices are always set to disabled and suspended.
+         * During probe, the device is set to enabled and active and the
+         * usage count is incremented.  If the driver supports runtime PM,
+         * it should call pm_runtime_put_noidle() in its probe routine and
+         * pm_runtime_get_noresume() in its remove routine.
+         */
+        pm_runtime_get_noresume(dev);
+        pm_runtime_set_active(dev);
+        pm_runtime_enable(dev);
+        rc = ddi->drv->probe(ddi->dev, ddi->id);
+        if (rc) {
+                pm_runtime_disable(dev);
+                pm_runtime_set_suspended(dev);
+                pm_runtime_put_noidle(dev);
+        }
+        return rc;
 }
 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
@@ -369,11 +387,19 @@ static int pci_device_remove(struct device * dev)
        struct pci_driver * drv = pci_dev->driver;
        if (drv) {
-                if (drv->remove)
+                if (drv->remove) {
+                        pm_runtime_get_sync(dev);
                        drv->remove(pci_dev);
+                        pm_runtime_put_noidle(dev);
+                }
                pci_dev->driver = NULL;
        }
+        /* Undo the runtime PM settings in local_pci_probe() */
+        pm_runtime_disable(dev);
+        pm_runtime_set_suspended(dev);
+        pm_runtime_put_noidle(dev);
        /*
         * If the device is still on, set the power state as "unknown",
         * since it might change by the next time we load the driver.
diff --git a/drivers/pci/pci-label.c b/drivers/pci/pci-label.c
new file mode 100644
index 000000000000..90c0a729cd3a
--- /dev/null
+++ b/drivers/pci/pci-label.c
@@ -0,0 +1,143 @@
+/*
+ * Purpose: Export the firmware instance and label associated with
+ * a pci device to sysfs
+ * Copyright (C) 2010 Dell Inc.
+ * by Narendra K <Narendra_K@dell.com>,
+ * Jordan Hargrave <Jordan_Hargrave@dell.com>
+ *
+ * SMBIOS defines type 41 for onboard pci devices. This code retrieves
+ * the instance number and string from the type 41 record and exports
+ * it to sysfs.
+ *
+ * Please see http://linux.dell.com/wiki/index.php/Oss/libnetdevname for more
+ * information.
+ */
+#include <linux/dmi.h>
+#include <linux/sysfs.h>
+#include <linux/pci.h>
+#include <linux/pci_ids.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include "pci.h"
+enum smbios_attr_enum {
+        SMBIOS_ATTR_NONE = 0,
+        SMBIOS_ATTR_LABEL_SHOW,
+        SMBIOS_ATTR_INSTANCE_SHOW,
+};
+static mode_t
+find_smbios_instance_string(struct pci_dev *pdev, char *buf,
+                            enum smbios_attr_enum attribute)
+{
+        const struct dmi_device *dmi;
+        struct dmi_dev_onboard *donboard;
+        int bus;
+        int devfn;
+        bus = pdev->bus->number;
+        devfn = pdev->devfn;
+        dmi = NULL;
+        while ((dmi = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD,
+                                      NULL, dmi)) != NULL) {
+                donboard = dmi->device_data;
+                if (donboard && donboard->bus == bus &&
+                                        donboard->devfn == devfn) {
+                        if (buf) {
+                                if (attribute == SMBIOS_ATTR_INSTANCE_SHOW)
+                                        return scnprintf(buf, PAGE_SIZE,
+                                                         "%d\n",
+                                                         donboard->instance);
+                                else if (attribute == SMBIOS_ATTR_LABEL_SHOW)
+                                        return scnprintf(buf, PAGE_SIZE,
+                                                         "%s\n",
+                                                         dmi->name);
+                        }
+                        return strlen(dmi->name);
+                }
+        }
+        return 0;
+}
+static mode_t
+smbios_instance_string_exist(struct kobject *kobj, struct attribute *attr,
+                             int n)
+{
+        struct device *dev;
+        struct pci_dev *pdev;
+        dev = container_of(kobj, struct device, kobj);
+        pdev = to_pci_dev(dev);
+        return find_smbios_instance_string(pdev, NULL, SMBIOS_ATTR_NONE) ?
+                                           S_IRUGO : 0;
+}
+static ssize_t
+smbioslabel_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct pci_dev *pdev;
+        pdev = to_pci_dev(dev);
+        return find_smbios_instance_string(pdev, buf,
+                                           SMBIOS_ATTR_LABEL_SHOW);
+}
+static ssize_t
+smbiosinstance_show(struct device *dev,
+                    struct device_attribute *attr, char *buf)
+{
+        struct pci_dev *pdev;
+        pdev = to_pci_dev(dev);
+        return find_smbios_instance_string(pdev, buf,
+                                           SMBIOS_ATTR_INSTANCE_SHOW);
+}
+static struct device_attribute smbios_attr_label = {
+        .attr = {.name = "label", .mode = 0444},
+        .show = smbioslabel_show,
+};
+static struct device_attribute smbios_attr_instance = {
+        .attr = {.name = "index", .mode = 0444},
+        .show = smbiosinstance_show,
+};
+static struct attribute *smbios_attributes[] = {
+        &smbios_attr_label.attr,
+        &smbios_attr_instance.attr,
+        NULL,
+};
+static struct attribute_group smbios_attr_group = {
+        .attrs = smbios_attributes,
+        .is_visible = smbios_instance_string_exist,
+};
+static int
+pci_create_smbiosname_file(struct pci_dev *pdev)
+{
+        if (!sysfs_create_group(&pdev->dev.kobj, &smbios_attr_group))
+                return 0;
+        return -ENODEV;
+}
+static void
+pci_remove_smbiosname_file(struct pci_dev *pdev)
+{
+        sysfs_remove_group(&pdev->dev.kobj, &smbios_attr_group);
+}
+void pci_create_firmware_label_files(struct pci_dev *pdev)
+{
+        if (!pci_create_smbiosname_file(pdev))
+                ;
+}
+void pci_remove_firmware_label_files(struct pci_dev *pdev)
+{
+        pci_remove_smbiosname_file(pdev);
+}
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index c9957f68ac9b..b5a7d9bfcb24 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -734,7 +734,7 @@ pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
 {
        struct pci_dev *pdev = to_pci_dev(container_of(kobj,
                                                       struct device, kobj));
-        struct resource *res = (struct resource *)attr->private;
+        struct resource *res = attr->private;
        enum pci_mmap_state mmap_type;
        resource_size_t start, end;
        int i;
@@ -778,6 +778,70 @@ pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
        return pci_mmap_resource(kobj, attr, vma, 1);
 }
+static ssize_t
+pci_resource_io(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr, char *buf,
+                loff_t off, size_t count, bool write)
+{
+        struct pci_dev *pdev = to_pci_dev(container_of(kobj,
+                                                       struct device, kobj));
+        struct resource *res = attr->private;
+        unsigned long port = off;
+        int i;
+        for (i = 0; i < PCI_ROM_RESOURCE; i++)
+                if (res == &pdev->resource[i])
+                        break;
+        if (i >= PCI_ROM_RESOURCE)
+                return -ENODEV;
+        port += pci_resource_start(pdev, i);
+        if (port > pci_resource_end(pdev, i))
+                return 0;
+        if (port + count - 1 > pci_resource_end(pdev, i))
+                return -EINVAL;
+        switch (count) {
+        case 1:
+                if (write)
+                        outb(*(u8 *)buf, port);
+                else
+                        *(u8 *)buf = inb(port);
+                return 1;
+        case 2:
+                if (write)
+                        outw(*(u16 *)buf, port);
+                else
+                        *(u16 *)buf = inw(port);
+                return 2;
+        case 4:
+                if (write)
+                        outl(*(u32 *)buf, port);
+                else
+                        *(u32 *)buf = inl(port);
+                return 4;
+        }
+        return -EINVAL;
+}
+static ssize_t
+pci_read_resource_io(struct file *filp, struct kobject *kobj,
+                     struct bin_attribute *attr, char *buf,
+                     loff_t off, size_t count)
+{
+        return pci_resource_io(filp, kobj, attr, buf, off, count, false);
+}
+static ssize_t
+pci_write_resource_io(struct file *filp, struct kobject *kobj,
+                      struct bin_attribute *attr, char *buf,
+                      loff_t off, size_t count)
+{
+        return pci_resource_io(filp, kobj, attr, buf, off, count, true);
+}
 /**
 * pci_remove_resource_files - cleanup resource files
 * @pdev: dev to cleanup
@@ -828,6 +892,10 @@ static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
                        sprintf(res_attr_name, "resource%d", num);
                        res_attr->mmap = pci_mmap_resource_uc;
                }
+                if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
+                        res_attr->read = pci_read_resource_io;
+                        res_attr->write = pci_write_resource_io;
+                }
                res_attr->attr.name = res_attr_name;
                res_attr->attr.mode = S_IRUSR | S_IWUSR;
                res_attr->size = pci_resource_len(pdev, num);
@@ -1097,6 +1165,8 @@ int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
        if (retval)
                goto err_vga_file;
+        pci_create_firmware_label_files(pdev);
        return 0;
 err_vga_file:
@@ -1164,6 +1234,9 @@ void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
                sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
                kfree(pdev->rom_attr);
        }
+        pci_remove_firmware_label_files(pdev);
 }
 static int __init pci_sysfs_init(void)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 740fb4ea9669..7fa3cbd742c5 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1275,6 +1275,22 @@ bool pci_check_pme_status(struct pci_dev *dev)
        return ret;
 }
+/*
+ * Time to wait before the system can be put into a sleep state after reporting
+ * a wakeup event signaled by a PCI device.
+ */
+#define PCI_WAKEUP_COOLDOWN     100
+/**
+ * pci_wakeup_event - Report a wakeup event related to a given PCI device.
+ * @dev: Device to report the wakeup event for.
+ */
+void pci_wakeup_event(struct pci_dev *dev)
+{
+        if (device_may_wakeup(&dev->dev))
+                pm_wakeup_event(&dev->dev, PCI_WAKEUP_COOLDOWN);
+}
 /**
 * pci_pme_wakeup - Wake up a PCI device if its PME Status bit is set.
 * @dev: Device to handle.
@@ -1285,8 +1301,10 @@ bool pci_check_pme_status(struct pci_dev *dev)
 */
 static int pci_pme_wakeup(struct pci_dev *dev, void *ign)
 {
-        if (pci_check_pme_status(dev))
+        if (pci_check_pme_status(dev)) {
                pm_request_resume(&dev->dev);
+                pci_wakeup_event(dev);
+        }
        return 0;
 }
@@ -2294,21 +2312,17 @@ void pci_msi_off(struct pci_dev *dev)
 }
 EXPORT_SYMBOL_GPL(pci_msi_off);
-#ifndef HAVE_ARCH_PCI_SET_DMA_MAX_SEGMENT_SIZE
 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size)
 {
        return dma_set_max_seg_size(&dev->dev, size);
 }
 EXPORT_SYMBOL(pci_set_dma_max_seg_size);
-#endif
-#ifndef HAVE_ARCH_PCI_SET_DMA_SEGMENT_BOUNDARY
 int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask)
 {
        return dma_set_seg_boundary(&dev->dev, mask);
 }
 EXPORT_SYMBOL(pci_set_dma_seg_boundary);
-#endif
 static int pcie_flr(struct pci_dev *dev, int probe)
 {
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index f8077b3c8c8c..679c39de6a89 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -11,6 +11,15 @@
 extern int pci_uevent(struct device *dev, struct kobj_uevent_env *env);
 extern int pci_create_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_remove_sysfs_dev_files(struct pci_dev *pdev);
+#ifndef CONFIG_DMI
+static inline void pci_create_firmware_label_files(struct pci_dev *pdev)
+{ return; }
+static inline void pci_remove_firmware_label_files(struct pci_dev *pdev)
+{ return; }
+#else
+extern void pci_create_firmware_label_files(struct pci_dev *pdev);
+extern void pci_remove_firmware_label_files(struct pci_dev *pdev);
+#endif
 extern void pci_cleanup_rom(struct pci_dev *dev);
 #ifdef HAVE_PCI_MMAP
 extern int pci_mmap_fits(struct pci_dev *pdev, int resno,
@@ -56,6 +65,7 @@ extern void pci_update_current_state(struct pci_dev *dev, pci_power_t state);
 extern void pci_disable_enabled_device(struct pci_dev *dev);
 extern bool pci_check_pme_status(struct pci_dev *dev);
 extern int pci_finish_runtime_suspend(struct pci_dev *dev);
+extern void pci_wakeup_event(struct pci_dev *dev);
 extern int __pci_pme_wakeup(struct pci_dev *dev, void *ign);
 extern void pci_pme_wakeup_bus(struct pci_bus *bus);
 extern void pci_pm_init(struct pci_dev *dev);
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index b8b494b3e0d0..dda70981b7a6 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -31,14 +31,22 @@ source "drivers/pci/pcie/aer/Kconfig"
 # PCI Express ASPM
 #
 config PCIEASPM
-        bool "PCI Express ASPM support(Experimental)"
+        bool "PCI Express ASPM control" if EMBEDDED
-        depends on PCI && EXPERIMENTAL && PCIEPORTBUS
+        depends on PCI && PCIEPORTBUS
-        default n
+        default y
        help
-          This enables PCI Express ASPM (Active State Power Management) and
+          This enables OS control over PCI Express ASPM (Active State
-          Clock Power Management. ASPM supports state L0/L0s/L1.
+          Power Management) and Clock Power Management. ASPM supports
+          state L0/L0s/L1.
-          When in doubt, say N.
+          ASPM is initially set up the the firmware. With this option enabled,
+          Linux can modify this state in order to disable ASPM on known-bad
+          hardware or configurations and enable it when known-safe.
+          ASPM can be disabled or enabled at runtime via
+          /sys/module/pcie_aspm/parameters/policy
+          When in doubt, say Y.
 config PCIEASPM_DEBUG
        bool "Debug PCI Express ASPM"
        depends on PCIEASPM
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index 8af4f619bba2..fc0b5a93e1de 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -727,20 +727,21 @@ static void aer_isr_one_error(struct pcie_device *p_device,
 static int get_e_source(struct aer_rpc *rpc, struct aer_err_source *e_src)
 {
        unsigned long flags;
-        int ret = 0;
        /* Lock access to Root error producer/consumer index */
        spin_lock_irqsave(&rpc->e_lock, flags);
-        if (rpc->prod_idx != rpc->cons_idx) {
+        if (rpc->prod_idx == rpc->cons_idx) {
-                *e_src = rpc->e_sources[rpc->cons_idx];
+                spin_unlock_irqrestore(&rpc->e_lock, flags);
-                rpc->cons_idx++;
+                return 0;
-                if (rpc->cons_idx == AER_ERROR_SOURCES_MAX)
-                        rpc->cons_idx = 0;
-                ret = 1;
        }
+        *e_src = rpc->e_sources[rpc->cons_idx];
+        rpc->cons_idx++;
+        if (rpc->cons_idx == AER_ERROR_SOURCES_MAX)
+                rpc->cons_idx = 0;
        spin_unlock_irqrestore(&rpc->e_lock, flags);
-        return ret;
+        return 1;
 }
 /**
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index be53d98fa384..71222814c1ec 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -588,11 +588,23 @@ void pcie_aspm_init_link_state(struct pci_dev *pdev)
         * update through pcie_aspm_cap_init().
         */
        pcie_aspm_cap_init(link, blacklist);
-        pcie_config_aspm_path(link);
        /* Setup initial Clock PM state */
        pcie_clkpm_cap_init(link, blacklist);
-        pcie_set_clkpm(link, policy_to_clkpm_state(link));
+        /*
+         * At this stage drivers haven't had an opportunity to change the
+         * link policy setting. Enabling ASPM on broken hardware can cripple
+         * it even before the driver has had a chance to disable ASPM, so
+         * default to a safe level right now. If we're enabling ASPM beyond
+         * the BIOS's expectation, we'll do so once pci_enable_device() is
+         * called.
+         */
+        if (aspm_policy != POLICY_POWERSAVE) {
+                pcie_config_aspm_path(link);
+                pcie_set_clkpm(link, policy_to_clkpm_state(link));
+        }
 unlock:
        mutex_unlock(&aspm_lock);
 out:
diff --git a/drivers/pci/pcie/pme/pcie_pme.c b/drivers/pci/pcie/pme/pcie_pme.c
index d672a0a63816..bbdea18693d9 100644
--- a/drivers/pci/pcie/pme/pcie_pme.c
+++ b/drivers/pci/pcie/pme/pcie_pme.c
@@ -154,6 +154,7 @@ static bool pcie_pme_walk_bus(struct pci_bus *bus)
                /* Skip PCIe devices in case we started from a root port. */
                if (!pci_is_pcie(dev) && pci_check_pme_status(dev)) {
                        pm_request_resume(&dev->dev);
+                        pci_wakeup_event(dev);
                        ret = true;
                }
@@ -254,8 +255,10 @@ static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id)
        if (found) {
                /* The device is there, but we have to check its PME status. */
                found = pci_check_pme_status(dev);
-                if (found)
+                if (found) {
                        pm_request_resume(&dev->dev);
+                        pci_wakeup_event(dev);
+                }
                pci_dev_put(dev);
        } else if (devfn) {
                /*
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index f4adba2d1dd3..12625d90f8b5 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -163,9 +163,16 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                        struct resource *res, unsigned int pos)
 {
        u32 l, sz, mask;
+        u16 orig_cmd;
        mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
+        if (!dev->mmio_always_on) {
+                pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
+                pci_write_config_word(dev, PCI_COMMAND,
+                        orig_cmd & ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
+        }
        res->name = pci_name(dev);
        pci_read_config_dword(dev, pos, &l);
@@ -173,6 +180,9 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
        pci_read_config_dword(dev, pos, &sz);
        pci_write_config_dword(dev, pos, l);
+        if (!dev->mmio_always_on)
+                pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
        /*
         * All bits set in sz means the device isn't working properly.
         * If the BAR isn't implemented, all bits must be 0.  If it's a
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index 449e890267a2..01f0306525a5 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -431,8 +431,6 @@ int pci_proc_detach_device(struct pci_dev *dev)
        struct proc_dir_entry *e;
        if ((e = dev->procent)) {
-                if (atomic_read(&e->count) > 1)
-                        return -EBUSY;
                remove_proc_entry(e->name, dev->bus->procdir);
                dev->procent = NULL;
        }
@@ -485,9 +483,9 @@ static int __init pci_proc_init(void)
        proc_create("devices", 0, proc_bus_pci_dir,
                    &proc_bus_pci_dev_operations);
        proc_initialized = 1;
-        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev)
                pci_proc_attach_device(dev);
-        }
        return 0;
 }
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 477345d41641..89ed181cd90c 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -91,6 +91,19 @@ static void __devinit quirk_resource_alignment(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, quirk_resource_alignment);
+/*
+ * Decoding should be disabled for a PCI device during BAR sizing to avoid
+ * conflict. But doing so may cause problems on host bridge and perhaps other
+ * key system devices. For devices that need to have mmio decoding always-on,
+ * we need to set the dev->mmio_always_on bit.
+ */
+static void __devinit quirk_mmio_always_on(struct pci_dev *dev)
+{
+        if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
+                dev->mmio_always_on = 1;
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, quirk_mmio_always_on);
 /* The Mellanox Tavor device gives false positive parity errors
 * Mark this device with a broken_parity_status, to allow
 * PCI scanning code to "skip" this now blacklisted device.
@@ -1459,6 +1472,7 @@ static void quirk_jmicron_ata(struct pci_dev *pdev)
        switch (pdev->device) {
        case PCI_DEVICE_ID_JMICRON_JMB360: /* SATA single port */
        case PCI_DEVICE_ID_JMICRON_JMB362: /* SATA dual ports */
+        case PCI_DEVICE_ID_JMICRON_JMB364: /* SATA dual ports */
                /* The controller should be in single function ahci mode */
                conf1 |= 0x0002A100; /* Set 8, 13, 15, 17 */
                break;
@@ -1470,6 +1484,7 @@ static void quirk_jmicron_ata(struct pci_dev *pdev)
                /* Fall through */
        case PCI_DEVICE_ID_JMICRON_JMB361:
        case PCI_DEVICE_ID_JMICRON_JMB363:
+        case PCI_DEVICE_ID_JMICRON_JMB369:
                /* Enable dual function mode, AHCI on fn 0, IDE fn1 */
                /* Set the class codes correctly and then direct IDE 0 */
                conf1 |= 0x00C2A1B3; /* Set 0, 1, 4, 5, 7, 8, 13, 15, 17, 22, 23 */
@@ -1496,16 +1511,20 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB360, qui
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB362, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363, quirk_jmicron_ata);
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB364, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368, quirk_jmicron_ata);
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB369, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB360, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB362, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363, quirk_jmicron_ata);
+DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB364, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366, quirk_jmicron_ata);
 DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368, quirk_jmicron_ata);
+DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB369, quirk_jmicron_ata);
 #endif
@@ -2115,6 +2134,7 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_RS480, quirk_disabl
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3336, quirk_disable_all_msi);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3351, quirk_disable_all_msi);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3364, quirk_disable_all_msi);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8380_0, quirk_disable_all_msi);
 /* Disable MSI on chipsets that are known to not support it */
 static void __devinit quirk_disable_msi(struct pci_dev *dev)
@@ -2126,12 +2146,29 @@ static void __devinit quirk_disable_msi(struct pci_dev *dev)
        }
 }
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_disable_msi);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, 0x9602, quirk_disable_msi);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ASUSTEK, 0x9602, quirk_disable_msi);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AI, 0x9602, quirk_disable_msi);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, 0xa238, quirk_disable_msi);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x5a3f, quirk_disable_msi);
+/*
+ * The APC bridge device in AMD 780 family northbridges has some random
+ * OEM subsystem ID in its vendor ID register (erratum 18), so instead
+ * we use the possible vendor/device IDs of the host bridge for the
+ * declared quirk, and search for the APC bridge by slot number.
+ */
+static void __devinit quirk_amd_780_apc_msi(struct pci_dev *host_bridge)
+{
+        struct pci_dev *apc_bridge;
+        apc_bridge = pci_get_slot(host_bridge->bus, PCI_DEVFN(1, 0));
+        if (apc_bridge) {
+                if (apc_bridge->device == 0x9602)
+                        quirk_disable_msi(apc_bridge);
+                pci_dev_put(apc_bridge);
+        }
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, 0x9600, quirk_amd_780_apc_msi);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, 0x9601, quirk_amd_780_apc_msi);
 /* Go through the list of Hypertransport capabilities and
 * return 1 if a HT MSI capability is found and enabled */
 static int __devinit msi_ht_cap_enabled(struct pci_dev *dev)
@@ -2390,6 +2427,9 @@ static void __devinit __nv_msi_ht_cap_quirk(struct pci_dev *dev, int all)
        int pos;
        int found;
+        if (!pci_msi_enabled())
+                return;
        /* check if there is HT MSI cap or enabled on this device */
        found = ht_check_msi_mapping(dev);
@@ -2742,7 +2782,7 @@ static int __init pci_apply_final_quirks(void)
                printk(KERN_DEBUG "PCI: CLS %u bytes\n",
                       pci_cache_line_size << 2);
-        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev) {
                pci_fixup_device(pci_fixup_final, dev);
                /*
                 * If arch hasn't set it explicitly yet, use the CLS
diff --git a/drivers/pci/search.c b/drivers/pci/search.c
index 20d03f772289..9d75dc8ca602 100644
--- a/drivers/pci/search.c
+++ b/drivers/pci/search.c
@@ -169,7 +169,7 @@ struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
 {
        struct pci_dev *dev = NULL;
-        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev) {
                if (pci_domain_nr(dev->bus) == domain &&
                    (dev->bus->number == bus && dev->devfn == devfn))
                        return dev;
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 19b111383f62..66cb8f4cc5f4 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -874,19 +874,16 @@ void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
 again:
        pci_bus_size_bridges(parent);
        __pci_bridge_assign_resources(bridge, &head);
-        retval = pci_reenable_device(bridge);
-        pci_set_master(bridge);
-        pci_enable_bridges(parent);
        tried_times++;
        if (!head.next)
-                return;
+                goto enable_all;
        if (tried_times >= 2) {
                /* still fail, don't need to try more */
                free_failed_list(&head);
-                return;
+                goto enable_all;
        }
        printk(KERN_DEBUG "PCI: No. %d try to assign unassigned res\n",
@@ -919,5 +916,10 @@ again:
        free_failed_list(&head);
        goto again;
+enable_all:
+        retval = pci_reenable_device(bridge);
+        pci_set_master(bridge);
+        pci_enable_bridges(parent);
 }
 EXPORT_SYMBOL_GPL(pci_assign_unassigned_bridge_resources);
diff --git a/drivers/pci/setup-irq.c b/drivers/pci/setup-irq.c
index aa795fd428de..eec9738f3492 100644
--- a/drivers/pci/setup-irq.c
+++ b/drivers/pci/setup-irq.c
@@ -59,7 +59,6 @@ pci_fixup_irqs(u8 (*swizzle)(struct pci_dev *, u8 *),
               int (*map_irq)(struct pci_dev *, u8, u8))
 {
        struct pci_dev *dev = NULL;
-        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev)
                pdev_fixup_irq(dev, swizzle, map_irq);
-        }
 }