12 files changed, 225 insertions, 57 deletions

diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index f9e244da30ae..9bcb6cbd5aa9 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -113,7 +113,7 @@ struct acpiphp_slot {
 
         u8              device;         /* pci device# */
 
-        u32             sun;            /* ACPI _SUN (slot unique number) */
+        unsigned long long sun;         /* ACPI _SUN (slot unique number) */
         u32             flags;          /* see below */
 };
 
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index 95b536a23d25..43c10bd261b4 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -337,7 +337,7 @@ int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
         slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
 
         acpiphp_slot->slot = slot;
-        snprintf(name, SLOT_NAME_SIZE, "%u", slot->acpi_slot->sun);
+        snprintf(name, SLOT_NAME_SIZE, "%llu", slot->acpi_slot->sun);
 
         retval = pci_hp_register(slot->hotplug_slot,
                                         acpiphp_slot->bridge->pci_bus,
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 955aae4071f7..3affc6472e65 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -255,13 +255,13 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 
                 bridge->nr_slots++;
 
-                dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n",
+                dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
                                 slot->sun, pci_domain_nr(bridge->pci_bus),
                                 bridge->pci_bus->number, slot->device);
                 retval = acpiphp_register_hotplug_slot(slot);
                 if (retval) {
                         if (retval == -EBUSY)
-                                warn("Slot %d already registered by another "
+                                warn("Slot %llu already registered by another "
                                         "hotplug driver\n", slot->sun);
                         else
                                 warn("acpiphp_register_hotplug_slot failed "
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index c892daae74d6..633e743442ac 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -1402,10 +1402,6 @@ static int __init ibmphp_init(void)
                 goto error;
         }
 
-        /* lock ourselves into memory with a module 
-         * count of -1 so that no one can unload us. */
-        module_put(THIS_MODULE);
-
 exit:
         return rc;
 
@@ -1423,4 +1419,3 @@ static void __exit ibmphp_exit(void)
 }
 
 module_init(ibmphp_init);
-module_exit(ibmphp_exit);
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 4b23bc39b11e..39cf248d24e3 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -432,18 +432,19 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
                 goto err_out_release_ctlr;
         }
 
+        /* Check if slot is occupied */
         t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
-
-        t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */
-        if (value && pciehp_force) {
-                rc = pciehp_enable_slot(t_slot);
-                if (rc) /* -ENODEV: shouldn't happen, but deal with it */
-                        value = 0;
-        }
-        if ((POWER_CTRL(ctrl)) && !value) {
-                rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/
-                if (rc)
-                        goto err_out_free_ctrl_slot;
+        t_slot->hpc_ops->get_adapter_status(t_slot, &value);
+        if (value) {
+                if (pciehp_force)
+                        pciehp_enable_slot(t_slot);
+        } else {
+                /* Power off slot if not occupied */
+                if (POWER_CTRL(ctrl)) {
+                        rc = t_slot->hpc_ops->power_off_slot(t_slot);
+                        if (rc)
+                                goto err_out_free_ctrl_slot;
+                }
         }
 
         return 0;
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index a2692724b68f..5c8baa43ac9c 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -1655,12 +1655,14 @@ int __init init_dmars(void)
                         iommu->flush.flush_context = __iommu_flush_context;
                         iommu->flush.flush_iotlb = __iommu_flush_iotlb;
                         printk(KERN_INFO "IOMMU 0x%Lx: using Register based "
-                               "invalidation\n", drhd->reg_base_addr);
+                               "invalidation\n",
+                               (unsigned long long)drhd->reg_base_addr);
                 } else {
                         iommu->flush.flush_context = qi_flush_context;
                         iommu->flush.flush_iotlb = qi_flush_iotlb;
                         printk(KERN_INFO "IOMMU 0x%Lx: using Queued "
-                               "invalidation\n", drhd->reg_base_addr);
+                               "invalidation\n",
+                               (unsigned long long)drhd->reg_base_addr);
                 }
         }
 
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index b3a63edb6901..ae5ec76dca77 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -63,7 +63,7 @@ static acpi_status acpi_run_osc(acpi_handle handle,
         union acpi_object in_params[4];
         struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
         union acpi_object *out_obj;
-        u32 osc_dw0, flags = osc_args->capbuf[OSC_QUERY_TYPE];
+        u32 errors, flags = osc_args->capbuf[OSC_QUERY_TYPE];
 
         /* Setting up input parameters */
         input.count = 4;
@@ -92,15 +92,16 @@ static acpi_status acpi_run_osc(acpi_handle handle,
                 status = AE_TYPE;
                 goto out_kfree;
         }
-        osc_dw0 = *((u32 *)out_obj->buffer.pointer);
-        if (osc_dw0) {
-                if (osc_dw0 & OSC_REQUEST_ERROR)
+        /* Need to ignore the bit0 in result code */
+        errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
+        if (errors) {
+                if (errors & OSC_REQUEST_ERROR)
                         printk(KERN_DEBUG "_OSC request fails\n"); 
-                if (osc_dw0 & OSC_INVALID_UUID_ERROR)
+                if (errors & OSC_INVALID_UUID_ERROR)
                         printk(KERN_DEBUG "_OSC invalid UUID\n"); 
-                if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
+                if (errors & OSC_INVALID_REVISION_ERROR)
                         printk(KERN_DEBUG "_OSC invalid revision\n"); 
-                if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
+                if (errors & OSC_CAPABILITIES_MASK_ERROR) {
                         if (flags & OSC_QUERY_ENABLE)
                                 goto out_success;
                         printk(KERN_DEBUG "_OSC FW not grant req. control\n");
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 21f2ac639cab..061d1ee0046a 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1832,7 +1832,7 @@ int pci_reset_function(struct pci_dev *dev)
         if (!(cap & PCI_EXP_DEVCAP_FLR))
                 return -ENOTTY;
 
-        if (!dev->msi_enabled && !dev->msix_enabled)
+        if (!dev->msi_enabled && !dev->msix_enabled && dev->irq != 0)
                 disable_irq(dev->irq);
         pci_save_state(dev);
 
@@ -1841,7 +1841,7 @@ int pci_reset_function(struct pci_dev *dev)
         r = pci_execute_reset_function(dev);
 
         pci_restore_state(dev);
-        if (!dev->msi_enabled && !dev->msix_enabled)
+        if (!dev->msi_enabled && !dev->msix_enabled && dev->irq != 0)
                 enable_irq(dev->irq);
 
         return r;
@@ -2042,7 +2042,7 @@ static int __devinit pci_init(void)
         return 0;
 }
 
-static int __devinit pci_setup(char *str)
+static int __init pci_setup(char *str)
 {
         while (str) {
                 char *k = strchr(str, ',');
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index dfc63d01f20a..aac7006949f1 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -252,7 +252,7 @@ static void report_resume(struct pci_dev *dev, void *data)
 
         if (!dev->driver ||
                 !dev->driver->err_handler ||
-                !dev->driver->err_handler->slot_reset)
+                !dev->driver->err_handler->resume)
                 return;
 
         err_handler = dev->driver->err_handler;
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index 8f63f4c6b85f..9aad608bcf3f 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -16,6 +16,7 @@
 #include <linux/pm.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/jiffies.h>
 #include <linux/pci-aspm.h>
 #include "../pci.h"
 
@@ -161,11 +162,12 @@ static void pcie_check_clock_pm(struct pci_dev *pdev)
  */
 static void pcie_aspm_configure_common_clock(struct pci_dev *pdev)
 {
-        int pos, child_pos;
+        int pos, child_pos, i = 0;
         u16 reg16 = 0;
         struct pci_dev *child_dev;
         int same_clock = 1;
-
+        unsigned long start_jiffies;
+        u16 child_regs[8], parent_reg;
         /*
          * all functions of a slot should have the same Slot Clock
          * Configuration, so just check one function
@@ -191,16 +193,19 @@ static void pcie_aspm_configure_common_clock(struct pci_dev *pdev)
                 child_pos = pci_find_capability(child_dev, PCI_CAP_ID_EXP);
                 pci_read_config_word(child_dev, child_pos + PCI_EXP_LNKCTL,
                         &reg16);
+                child_regs[i] = reg16;
                 if (same_clock)
                         reg16 |= PCI_EXP_LNKCTL_CCC;
                 else
                         reg16 &= ~PCI_EXP_LNKCTL_CCC;
                 pci_write_config_word(child_dev, child_pos + PCI_EXP_LNKCTL,
                         reg16);
+                i++;
         }
 
         /* Configure upstream component */
         pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
+        parent_reg = reg16;
         if (same_clock)
                 reg16 |= PCI_EXP_LNKCTL_CCC;
         else
@@ -212,12 +217,30 @@ static void pcie_aspm_configure_common_clock(struct pci_dev *pdev)
         pci_write_config_word(pdev, pos + PCI_EXP_LNKCTL, reg16);
 
         /* Wait for link training end */
-        while (1) {
+        /* break out after waiting for 1 second */
+        start_jiffies = jiffies;
+        while ((jiffies - start_jiffies) < HZ) {
                 pci_read_config_word(pdev, pos + PCI_EXP_LNKSTA, &reg16);
                 if (!(reg16 & PCI_EXP_LNKSTA_LT))
                         break;
                 cpu_relax();
         }
+        /* training failed -> recover */
+        if ((jiffies - start_jiffies) >= HZ) {
+                dev_printk (KERN_ERR, &pdev->dev, "ASPM: Could not configure"
+                            " common clock\n");
+                i = 0;
+                list_for_each_entry(child_dev, &pdev->subordinate->devices,
+                                    bus_list) {
+                        child_pos = pci_find_capability(child_dev,
+                                                        PCI_CAP_ID_EXP);
+                        pci_write_config_word(child_dev,
+                                              child_pos + PCI_EXP_LNKCTL,
+                                              child_regs[i]);
+                        i++;
+                }
+                pci_write_config_word(pdev, pos + PCI_EXP_LNKCTL, parent_reg);
+        }
 }
 
 /*
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 5049a47030ac..ce0985615133 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -22,6 +22,7 @@
 #include <linux/delay.h>
 #include <linux/acpi.h>
 #include <linux/kallsyms.h>
+#include <linux/dmi.h>
 #include "pci.h"
 
 int isa_dma_bridge_buggy;
@@ -605,27 +606,6 @@ static void __init quirk_ioapic_rmw(struct pci_dev *dev)
                 sis_apic_bug = 1;
 }
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_SI,       PCI_ANY_ID,                     quirk_ioapic_rmw);
-
-#define AMD8131_revA0        0x01
-#define AMD8131_revB0        0x11
-#define AMD8131_MISC         0x40
-#define AMD8131_NIOAMODE_BIT 0
-static void quirk_amd_8131_ioapic(struct pci_dev *dev)
-{ 
-        unsigned char tmp;
-        
-        if (nr_ioapics == 0) 
-                return;
-
-        if (dev->revision == AMD8131_revA0 || dev->revision == AMD8131_revB0) {
-                dev_info(&dev->dev, "Fixing up AMD8131 IOAPIC mode\n");
-                pci_read_config_byte( dev, AMD8131_MISC, &tmp);
-                tmp &= ~(1 << AMD8131_NIOAMODE_BIT);
-                pci_write_config_byte( dev, AMD8131_MISC, tmp);
-        }
-} 
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_amd_8131_ioapic);
-DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_amd_8131_ioapic);
 #endif /* CONFIG_X86_IO_APIC */
 
 /*
@@ -1422,6 +1402,155 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,	0x2609, quirk_intel_pcie_pm);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    0x260a, quirk_intel_pcie_pm);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    0x260b, quirk_intel_pcie_pm);
 
+#ifdef CONFIG_X86_IO_APIC
+/*
+ * Boot interrupts on some chipsets cannot be turned off. For these chipsets,
+ * remap the original interrupt in the linux kernel to the boot interrupt, so
+ * that a PCI device's interrupt handler is installed on the boot interrupt
+ * line instead.
+ */
+static void quirk_reroute_to_boot_interrupts_intel(struct pci_dev *dev)
+{
+        if (noioapicquirk || noioapicreroute)
+                return;
+
+        dev->irq_reroute_variant = INTEL_IRQ_REROUTE_VARIANT;
+
+        printk(KERN_INFO "PCI quirk: reroute interrupts for 0x%04x:0x%04x\n",
+                        dev->vendor, dev->device);
+        return;
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_80333_0,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_80333_1,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_ESB2_0,     quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_PXH_0,      quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_PXH_1,      quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_PXHV,       quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_80332_0,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_80332_1,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_80333_0,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_80333_1,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_ESB2_0,     quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_PXH_0,      quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_PXH_1,      quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_PXHV,       quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_80332_0,    quirk_reroute_to_boot_interrupts_intel);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_80332_1,    quirk_reroute_to_boot_interrupts_intel);
+
+/*
+ * On some chipsets we can disable the generation of legacy INTx boot
+ * interrupts.
+ */
+
+/*
+ * IO-APIC1 on 6300ESB generates boot interrupts, see intel order no
+ * 300641-004US, section 5.7.3.
+ */
+#define INTEL_6300_IOAPIC_ABAR          0x40
+#define INTEL_6300_DISABLE_BOOT_IRQ     (1<<14)
+
+static void quirk_disable_intel_boot_interrupt(struct pci_dev *dev)
+{
+        u16 pci_config_word;
+
+        if (noioapicquirk)
+                return;
+
+        pci_read_config_word(dev, INTEL_6300_IOAPIC_ABAR, &pci_config_word);
+        pci_config_word |= INTEL_6300_DISABLE_BOOT_IRQ;
+        pci_write_config_word(dev, INTEL_6300_IOAPIC_ABAR, pci_config_word);
+
+        printk(KERN_INFO "disabled boot interrupt on device 0x%04x:0x%04x\n",
+                dev->vendor, dev->device);
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_ESB_10,      quirk_disable_intel_boot_interrupt);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_ESB_10,     quirk_disable_intel_boot_interrupt);
+
+/*
+ * disable boot interrupts on HT-1000
+ */
+#define BC_HT1000_FEATURE_REG           0x64
+#define BC_HT1000_PIC_REGS_ENABLE       (1<<0)
+#define BC_HT1000_MAP_IDX               0xC00
+#define BC_HT1000_MAP_DATA              0xC01
+
+static void quirk_disable_broadcom_boot_interrupt(struct pci_dev *dev)
+{
+        u32 pci_config_dword;
+        u8 irq;
+
+        if (noioapicquirk)
+                return;
+
+        pci_read_config_dword(dev, BC_HT1000_FEATURE_REG, &pci_config_dword);
+        pci_write_config_dword(dev, BC_HT1000_FEATURE_REG, pci_config_dword |
+                        BC_HT1000_PIC_REGS_ENABLE);
+
+        for (irq = 0x10; irq < 0x10 + 32; irq++) {
+                outb(irq, BC_HT1000_MAP_IDX);
+                outb(0x00, BC_HT1000_MAP_DATA);
+        }
+
+        pci_write_config_dword(dev, BC_HT1000_FEATURE_REG, pci_config_dword);
+
+        printk(KERN_INFO "disabled boot interrupts on PCI device"
+                        "0x%04x:0x%04x\n", dev->vendor, dev->device);
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_SERVERWORKS,   PCI_DEVICE_ID_SERVERWORKS_HT1000SB,        quirk_disable_broadcom_boot_interrupt);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_SERVERWORKS,   PCI_DEVICE_ID_SERVERWORKS_HT1000SB,       quirk_disable_broadcom_boot_interrupt);
+
+/*
+ * disable boot interrupts on AMD and ATI chipsets
+ */
+/*
+ * NOIOAMODE needs to be disabled to disable "boot interrupts". For AMD 8131
+ * rev. A0 and B0, NOIOAMODE needs to be disabled anyway to fix IO-APIC mode
+ * (due to an erratum).
+ */
+#define AMD_813X_MISC                   0x40
+#define AMD_813X_NOIOAMODE              (1<<0)
+
+static void quirk_disable_amd_813x_boot_interrupt(struct pci_dev *dev)
+{
+        u32 pci_config_dword;
+
+        if (noioapicquirk)
+                return;
+
+        pci_read_config_dword(dev, AMD_813X_MISC, &pci_config_dword);
+        pci_config_dword &= ~AMD_813X_NOIOAMODE;
+        pci_write_config_dword(dev, AMD_813X_MISC, pci_config_dword);
+
+        printk(KERN_INFO "disabled boot interrupts on PCI device "
+                        "0x%04x:0x%04x\n", dev->vendor, dev->device);
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD,   PCI_DEVICE_ID_AMD_8131_BRIDGE,     quirk_disable_amd_813x_boot_interrupt);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_AMD,   PCI_DEVICE_ID_AMD_8132_BRIDGE,    quirk_disable_amd_813x_boot_interrupt);
+
+#define AMD_8111_PCI_IRQ_ROUTING        0x56
+
+static void quirk_disable_amd_8111_boot_interrupt(struct pci_dev *dev)
+{
+        u16 pci_config_word;
+
+        if (noioapicquirk)
+                return;
+
+        pci_read_config_word(dev, AMD_8111_PCI_IRQ_ROUTING, &pci_config_word);
+        if (!pci_config_word) {
+                printk(KERN_INFO "boot interrupts on PCI device 0x%04x:0x%04x "
+                                "already disabled\n",
+                                dev->vendor, dev->device);
+                return;
+        }
+        pci_write_config_word(dev, AMD_8111_PCI_IRQ_ROUTING, 0);
+        printk(KERN_INFO "disabled boot interrupts on PCI device "
+                        "0x%04x:0x%04x\n", dev->vendor, dev->device);
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD,   PCI_DEVICE_ID_AMD_8111_SMBUS,      quirk_disable_amd_8111_boot_interrupt);
+DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_AMD,   PCI_DEVICE_ID_AMD_8111_SMBUS,     quirk_disable_amd_8111_boot_interrupt);
+#endif /* CONFIG_X86_IO_APIC */
+
 /*
  * Toshiba TC86C001 IDE controller reports the standard 8-byte BAR0 size
  * but the PIO transfers won't work if BAR0 falls at the odd 8 bytes.
@@ -1828,6 +1957,22 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS,
                          PCI_DEVICE_ID_SERVERWORKS_HT1000_PXB,
                          ht_enable_msi_mapping);
 
+/* The P5N32-SLI Premium motherboard from Asus has a problem with msi
+ * for the MCP55 NIC. It is not yet determined whether the msi problem
+ * also affects other devices. As for now, turn off msi for this device.
+ */
+static void __devinit nvenet_msi_disable(struct pci_dev *dev)
+{
+        if (dmi_name_in_vendors("P5N32-SLI PREMIUM")) {
+                dev_info(&dev->dev,
+                         "Disabling msi for MCP55 NIC on P5N32-SLI Premium\n");
+                dev->no_msi = 1;
+        }
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA,
+                        PCI_DEVICE_ID_NVIDIA_NVENET_15,
+                        nvenet_msi_disable);
+
 static void __devinit nv_msi_ht_cap_quirk(struct pci_dev *dev)
 {
         struct pci_dev *host_bridge;
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index 4dd1c3e157ae..5a8ccb4f604d 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -253,6 +253,7 @@ placeholder:
                  __func__, pci_domain_nr(parent), parent->number, slot_nr);
 
 out:
+        kfree(slot_name);
         up_write(&pci_bus_sem);
         return slot;
 err: