Merge branch 'linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes/pci-2.6

* 'linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes/pci-2.6: (36 commits)
  PCI: hotplug: pciehp: Removed check for hotplug of display devices
  PCI: read memory ranges out of Broadcom CNB20LE host bridge
  PCI: Allow manual resource allocation for PCI hotplug bridges
  x86/PCI: make ACPI MCFG reserved error messages ACPI specific
  PCI hotplug: Use kmemdup
  PM/PCI: Update PCI power management documentation
  PCI: output FW warning in pci_read/write_vpd
  PCI: fix typos pci_device_dis/enable to pci_dis/enable_device in comments
  PCI quirks: disable msi on AMD rs4xx internal gfx bridges
  PCI: Disable MSI for MCP55 on P5N32-E SLI
  x86/PCI: irq and pci_ids patch for additional Intel Cougar Point DeviceIDs
  PCI: aerdrv: trivial cleanup for aerdrv_core.c
  PCI: aerdrv: trivial cleanup for aerdrv.c
  PCI: aerdrv: introduce default_downstream_reset_link
  PCI: aerdrv: rework find_aer_service
  PCI: aerdrv: remove is_downstream
  PCI: aerdrv: remove magical ROOT_ERR_STATUS_MASKS
  PCI: aerdrv: redefine PCI_ERR_ROOT_*_SRC
  PCI: aerdrv: rework do_recovery
  PCI: aerdrv: rework get_e_source()
  ...

12 files changed, 508 insertions, 417 deletions

diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 7858a117e80b..34ef70d562b2 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -19,7 +19,7 @@ config PCI_MSI
            by using the 'pci=nomsi' option.  This disables MSI for the
            entire system.
 
-           If you don't know what to do here, say N.
+           If you don't know what to do here, say Y.
 
 config PCI_DEBUG
         bool "PCI Debugging"
diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index 2f646fe1260f..531bc697d800 100644
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -13,7 +13,7 @@
  * configuration space.
  */
 
-static DEFINE_SPINLOCK(pci_lock);
+static DEFINE_RAW_SPINLOCK(pci_lock);
 
 /*
  *  Wrappers for all PCI configuration access functions.  They just check
@@ -33,10 +33,10 @@ int pci_bus_read_config_##size \
         unsigned long flags;                                            \
         u32 data = 0;                                                   \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irqsave(&pci_lock, flags);                            \
+        raw_spin_lock_irqsave(&pci_lock, flags);                        \
         res = bus->ops->read(bus, devfn, pos, len, &data);              \
         *value = (type)data;                                            \
-        spin_unlock_irqrestore(&pci_lock, flags);                       \
+        raw_spin_unlock_irqrestore(&pci_lock, flags);           \
         return res;                                                     \
 }
 
@@ -47,9 +47,9 @@ int pci_bus_write_config_##size \
         int res;                                                        \
         unsigned long flags;                                            \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irqsave(&pci_lock, flags);                            \
+        raw_spin_lock_irqsave(&pci_lock, flags);                        \
         res = bus->ops->write(bus, devfn, pos, len, value);             \
-        spin_unlock_irqrestore(&pci_lock, flags);                       \
+        raw_spin_unlock_irqrestore(&pci_lock, flags);           \
         return res;                                                     \
 }
 
@@ -79,10 +79,10 @@ struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops)
         struct pci_ops *old_ops;
         unsigned long flags;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
         old_ops = bus->ops;
         bus->ops = ops;
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
         return old_ops;
 }
 EXPORT_SYMBOL(pci_bus_set_ops);
@@ -136,9 +136,9 @@ static noinline void pci_wait_ucfg(struct pci_dev *dev)
         __add_wait_queue(&pci_ucfg_wait, &wait);
         do {
                 set_current_state(TASK_UNINTERRUPTIBLE);
-                spin_unlock_irq(&pci_lock);
+                raw_spin_unlock_irq(&pci_lock);
                 schedule();
-                spin_lock_irq(&pci_lock);
+                raw_spin_lock_irq(&pci_lock);
         } while (dev->block_ucfg_access);
         __remove_wait_queue(&pci_ucfg_wait, &wait);
 }
@@ -150,11 +150,11 @@ int pci_user_read_config_##size						\
         int ret = 0;                                                    \
         u32 data = -1;                                                  \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irq(&pci_lock);                                       \
+        raw_spin_lock_irq(&pci_lock);                           \
         if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);       \
         ret = dev->bus->ops->read(dev->bus, dev->devfn,                 \
                                         pos, sizeof(type), &data);      \
-        spin_unlock_irq(&pci_lock);                                     \
+        raw_spin_unlock_irq(&pci_lock);                         \
         *val = (type)data;                                              \
         return ret;                                                     \
 }
@@ -165,11 +165,11 @@ int pci_user_write_config_##size					\
 {                                                                       \
         int ret = -EIO;                                                 \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irq(&pci_lock);                                       \
+        raw_spin_lock_irq(&pci_lock);                           \
         if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);       \
         ret = dev->bus->ops->write(dev->bus, dev->devfn,                \
                                         pos, sizeof(type), val);        \
-        spin_unlock_irq(&pci_lock);                                     \
+        raw_spin_unlock_irq(&pci_lock);                         \
         return ret;                                                     \
 }
 
@@ -220,8 +220,13 @@ static int pci_vpd_pci22_wait(struct pci_dev *dev)
                         return 0;
                 }
 
-                if (time_after(jiffies, timeout))
+                if (time_after(jiffies, timeout)) {
+                        dev_printk(KERN_DEBUG, &dev->dev,
+                                   "vpd r/w failed.  This is likely a firmware "
+                                   "bug on this device.  Contact the card "
+                                   "vendor for a firmware update.");
                         return -ETIMEDOUT;
+                }
                 if (fatal_signal_pending(current))
                         return -EINTR;
                 if (!cond_resched())
@@ -396,10 +401,10 @@ void pci_block_user_cfg_access(struct pci_dev *dev)
         unsigned long flags;
         int was_blocked;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
         was_blocked = dev->block_ucfg_access;
         dev->block_ucfg_access = 1;
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
 
         /* If we BUG() inside the pci_lock, we're guaranteed to hose
          * the machine */
@@ -417,7 +422,7 @@ void pci_unblock_user_cfg_access(struct pci_dev *dev)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
 
         /* This indicates a problem in the caller, but we don't need
          * to kill them, unlike a double-block above. */
@@ -425,6 +430,6 @@ void pci_unblock_user_cfg_access(struct pci_dev *dev)
 
         dev->block_ucfg_access = 0;
         wake_up_all(&pci_ucfg_wait);
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
 }
 EXPORT_SYMBOL_GPL(pci_unblock_user_cfg_access);
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 6644337d63d6..b3e5580c837b 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -1075,13 +1075,12 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         /* make our own copy of the pci bus structure,
          * as we like tweaking it a lot */
-        ctrl->pci_bus = kmalloc(sizeof(*ctrl->pci_bus), GFP_KERNEL);
+        ctrl->pci_bus = kmemdup(pdev->bus, sizeof(*ctrl->pci_bus), GFP_KERNEL);
         if (!ctrl->pci_bus) {
                 err("out of memory\n");
                 rc = -ENOMEM;
                 goto err_free_ctrl;
         }
-        memcpy(ctrl->pci_bus, pdev->bus, sizeof(*ctrl->pci_bus));
 
         ctrl->bus = pdev->bus->number;
         ctrl->rev = pdev->revision;
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 0a16444c14c9..2fce726758d2 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -84,12 +84,6 @@ int pciehp_configure_device(struct slot *p_slot)
                 dev = pci_get_slot(parent, PCI_DEVFN(0, 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)) {
                         pciehp_add_bridge(dev);
@@ -133,15 +127,9 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                 presence = 0;
 
         for (j = 0; j < 8; j++) {
-                struct pci_dev* temp = pci_get_slot(parent, PCI_DEVFN(0, j));
+                struct pci_dev *temp = pci_get_slot(parent, PCI_DEVFN(0, 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 && presence) {
                         pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
                         if (bctl & PCI_BRIDGE_CTL_VGA) {
@@ -149,7 +137,8 @@ int pciehp_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/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 6309c5a2528f..afd2fbf7d797 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -979,7 +979,12 @@ static ssize_t reset_store(struct device *dev,
 
         if (val != 1)
                 return -EINVAL;
-        return pci_reset_function(pdev);
+
+        result = pci_reset_function(pdev);
+        if (result < 0)
+                return result;
+
+        return count;
 }
 
 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
@@ -1030,6 +1035,39 @@ error:
         return retval;
 }
 
+static void pci_remove_slot_links(struct pci_dev *dev)
+{
+        char func[10];
+        struct pci_slot *slot;
+
+        sysfs_remove_link(&dev->dev.kobj, "slot");
+        list_for_each_entry(slot, &dev->bus->slots, list) {
+                if (slot->number != PCI_SLOT(dev->devfn))
+                        continue;
+                snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
+                sysfs_remove_link(&slot->kobj, func);
+        }
+}
+
+static int pci_create_slot_links(struct pci_dev *dev)
+{
+        int result = 0;
+        char func[10];
+        struct pci_slot *slot;
+
+        list_for_each_entry(slot, &dev->bus->slots, list) {
+                if (slot->number != PCI_SLOT(dev->devfn))
+                        continue;
+                result = sysfs_create_link(&dev->dev.kobj, &slot->kobj, "slot");
+                if (result)
+                        goto out;
+                snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
+                result = sysfs_create_link(&slot->kobj, &dev->dev.kobj, func);
+        }
+out:
+        return result;
+}
+
 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
 {
         int retval;
@@ -1092,6 +1130,8 @@ int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
         if (retval)
                 goto err_vga_file;
 
+        pci_create_slot_links(pdev);
+
         return 0;
 
 err_vga_file:
@@ -1141,6 +1181,8 @@ void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
         if (!sysfs_initialized)
                 return;
 
+        pci_remove_slot_links(pdev);
+
         pci_remove_capabilities_sysfs(pdev);
 
         if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 1df7c508814e..60f30e7f1c8c 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1193,7 +1193,7 @@ void pci_disable_enabled_device(struct pci_dev *dev)
  * anymore.  This only involves disabling PCI bus-mastering, if active.
  *
  * Note we don't actually disable the device until all callers of
- * pci_device_enable() have called pci_device_disable().
+ * pci_enable_device() have called pci_disable_device().
  */
 void
 pci_disable_device(struct pci_dev *dev)
@@ -1631,7 +1631,6 @@ void pci_pm_init(struct pci_dev *dev)
                  * let the user space enable it to wake up the system as needed.
                  */
                 device_set_wakeup_capable(&dev->dev, true);
-                device_set_wakeup_enable(&dev->dev, false);
                 /* Disable the PME# generation functionality */
                 pci_pme_active(dev, false);
         } else {
@@ -1655,7 +1654,6 @@ void platform_pci_wakeup_init(struct pci_dev *dev)
                 return;
 
         device_set_wakeup_capable(&dev->dev, true);
-        device_set_wakeup_enable(&dev->dev, false);
         platform_pci_sleep_wake(dev, false);
 }
 
diff --git a/drivers/pci/pcie/aer/aer_inject.c b/drivers/pci/pcie/aer/aer_inject.c
index f8f425b8731d..909924692b8a 100644
--- a/drivers/pci/pcie/aer/aer_inject.c
+++ b/drivers/pci/pcie/aer/aer_inject.c
@@ -168,7 +168,7 @@ static u32 *find_pci_config_dword(struct aer_error *err, int where,
                 target = &err->root_status;
                 rw1cs = 1;
                 break;
-        case PCI_ERR_ROOT_COR_SRC:
+        case PCI_ERR_ROOT_ERR_SRC:
                 target = &err->source_id;
                 break;
         }
diff --git a/drivers/pci/pcie/aer/aerdrv.c b/drivers/pci/pcie/aer/aerdrv.c
index 7a711ee314b7..484cc55194b8 100644
--- a/drivers/pci/pcie/aer/aerdrv.c
+++ b/drivers/pci/pcie/aer/aerdrv.c
@@ -72,13 +72,120 @@ void pci_no_aer(void)
         pcie_aer_disable = 1;   /* has priority over 'forceload' */
 }
 
+static int set_device_error_reporting(struct pci_dev *dev, void *data)
+{
+        bool enable = *((bool *)data);
+
+        if ((dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) ||
+            (dev->pcie_type == PCI_EXP_TYPE_UPSTREAM) ||
+            (dev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)) {
+                if (enable)
+                        pci_enable_pcie_error_reporting(dev);
+                else
+                        pci_disable_pcie_error_reporting(dev);
+        }
+
+        if (enable)
+                pcie_set_ecrc_checking(dev);
+
+        return 0;
+}
+
+/**
+ * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
+ * @dev: pointer to root port's pci_dev data structure
+ * @enable: true = enable error reporting, false = disable error reporting.
+ */
+static void set_downstream_devices_error_reporting(struct pci_dev *dev,
+                                                   bool enable)
+{
+        set_device_error_reporting(dev, &enable);
+
+        if (!dev->subordinate)
+                return;
+        pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
+}
+
+/**
+ * aer_enable_rootport - enable Root Port's interrupts when receiving messages
+ * @rpc: pointer to a Root Port data structure
+ *
+ * Invoked when PCIe bus loads AER service driver.
+ */
+static void aer_enable_rootport(struct aer_rpc *rpc)
+{
+        struct pci_dev *pdev = rpc->rpd->port;
+        int pos, aer_pos;
+        u16 reg16;
+        u32 reg32;
+
+        pos = pci_pcie_cap(pdev);
+        /* Clear PCIe Capability's Device Status */
+        pci_read_config_word(pdev, pos+PCI_EXP_DEVSTA, &reg16);
+        pci_write_config_word(pdev, pos+PCI_EXP_DEVSTA, reg16);
+
+        /* Disable system error generation in response to error messages */
+        pci_read_config_word(pdev, pos + PCI_EXP_RTCTL, &reg16);
+        reg16 &= ~(SYSTEM_ERROR_INTR_ON_MESG_MASK);
+        pci_write_config_word(pdev, pos + PCI_EXP_RTCTL, reg16);
+
+        aer_pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
+        /* Clear error status */
+        pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
+        pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
+        pci_read_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, &reg32);
+        pci_write_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, reg32);
+        pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
+        pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
+
+        /*
+         * Enable error reporting for the root port device and downstream port
+         * devices.
+         */
+        set_downstream_devices_error_reporting(pdev, true);
+
+        /* Enable Root Port's interrupt in response to error messages */
+        pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, &reg32);
+        reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
+        pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, reg32);
+}
+
+/**
+ * aer_disable_rootport - disable Root Port's interrupts when receiving messages
+ * @rpc: pointer to a Root Port data structure
+ *
+ * Invoked when PCIe bus unloads AER service driver.
+ */
+static void aer_disable_rootport(struct aer_rpc *rpc)
+{
+        struct pci_dev *pdev = rpc->rpd->port;
+        u32 reg32;
+        int pos;
+
+        /*
+         * Disable error reporting for the root port device and downstream port
+         * devices.
+         */
+        set_downstream_devices_error_reporting(pdev, false);
+
+        pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
+        /* Disable Root's interrupt in response to error messages */
+        pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
+        reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
+        pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, reg32);
+
+        /* Clear Root's error status reg */
+        pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, &reg32);
+        pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, reg32);
+}
+
 /**
  * aer_irq - Root Port's ISR
  * @irq: IRQ assigned to Root Port
  * @context: pointer to Root Port data structure
  *
  * Invoked when Root Port detects AER messages.
- **/
+ */
 irqreturn_t aer_irq(int irq, void *context)
 {
         unsigned int status, id;
@@ -97,13 +204,13 @@ irqreturn_t aer_irq(int irq, void *context)
 
         /* Read error status */
         pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, &status);
-        if (!(status & ROOT_ERR_STATUS_MASKS)) {
+        if (!(status & (PCI_ERR_ROOT_UNCOR_RCV|PCI_ERR_ROOT_COR_RCV))) {
                 spin_unlock_irqrestore(&rpc->e_lock, flags);
                 return IRQ_NONE;
         }
 
         /* Read error source and clear error status */
-        pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_COR_SRC, &id);
+        pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_ERR_SRC, &id);
         pci_write_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, status);
 
         /* Store error source for later DPC handler */
@@ -135,7 +242,7 @@ EXPORT_SYMBOL_GPL(aer_irq);
  * @dev: pointer to the pcie_dev data structure
  *
  * Invoked when Root Port's AER service is loaded.
- **/
+ */
 static struct aer_rpc *aer_alloc_rpc(struct pcie_device *dev)
 {
         struct aer_rpc *rpc;
@@ -144,15 +251,11 @@ static struct aer_rpc *aer_alloc_rpc(struct pcie_device *dev)
         if (!rpc)
                 return NULL;
 
-        /*
-         * Initialize Root lock access, e_lock, to Root Error Status Reg,
-         * Root Error ID Reg, and Root error producer/consumer index.
-         */
+        /* Initialize Root lock access, e_lock, to Root Error Status Reg */
         spin_lock_init(&rpc->e_lock);
 
         rpc->rpd = dev;
         INIT_WORK(&rpc->dpc_handler, aer_isr);
-        rpc->prod_idx = rpc->cons_idx = 0;
         mutex_init(&rpc->rpc_mutex);
         init_waitqueue_head(&rpc->wait_release);
 
@@ -167,7 +270,7 @@ static struct aer_rpc *aer_alloc_rpc(struct pcie_device *dev)
  * @dev: pointer to the pcie_dev data structure
  *
  * Invoked when PCI Express bus unloads or AER probe fails.
- **/
+ */
 static void aer_remove(struct pcie_device *dev)
 {
         struct aer_rpc *rpc = get_service_data(dev);
@@ -179,7 +282,8 @@ static void aer_remove(struct pcie_device *dev)
 
                 wait_event(rpc->wait_release, rpc->prod_idx == rpc->cons_idx);
 
-                aer_delete_rootport(rpc);
+                aer_disable_rootport(rpc);
+                kfree(rpc);
                 set_service_data(dev, NULL);
         }
 }
@@ -190,7 +294,7 @@ static void aer_remove(struct pcie_device *dev)
  * @id: pointer to the service id data structure
  *
  * Invoked when PCI Express bus loads AER service driver.
- **/
+ */
 static int __devinit aer_probe(struct pcie_device *dev)
 {
         int status;
@@ -230,47 +334,30 @@ static int __devinit aer_probe(struct pcie_device *dev)
  * @dev: pointer to Root Port's pci_dev data structure
  *
  * Invoked by Port Bus driver when performing link reset at Root Port.
- **/
+ */
 static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
 {
-        u16 p2p_ctrl;
-        u32 status;
+        u32 reg32;
         int pos;
 
         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 
         /* Disable Root's interrupt in response to error messages */
-        pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, 0);
-
-        /* Assert Secondary Bus Reset */
-        pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &p2p_ctrl);
-        p2p_ctrl |= PCI_BRIDGE_CTL_BUS_RESET;
-        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, p2p_ctrl);
-
-        /*
-         * we should send hot reset message for 2ms to allow it time to
-         * propogate to all downstream ports
-         */
-        msleep(2);
-
-        /* De-assert Secondary Bus Reset */
-        p2p_ctrl &= ~PCI_BRIDGE_CTL_BUS_RESET;
-        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, p2p_ctrl);
+        pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
+        reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
+        pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
 
-        /*
-         * System software must wait for at least 100ms from the end
-         * of a reset of one or more device before it is permitted
-         * to issue Configuration Requests to those devices.
-         */
-        msleep(200);
+        aer_do_secondary_bus_reset(dev);
         dev_printk(KERN_DEBUG, &dev->dev, "Root Port link has been reset\n");
 
+        /* Clear Root Error Status */
+        pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &reg32);
+        pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, reg32);
+
         /* Enable Root Port's interrupt in response to error messages */
-        pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &status);
-        pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, status);
-        pci_write_config_dword(dev,
-                pos + PCI_ERR_ROOT_COMMAND,
-                ROOT_PORT_INTR_ON_MESG_MASK);
+        pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
+        reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
+        pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
 
         return PCI_ERS_RESULT_RECOVERED;
 }
@@ -281,7 +368,7 @@ static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
  * @error: error severity being notified by port bus
  *
  * Invoked by Port Bus driver during error recovery.
- **/
+ */
 static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
                         enum pci_channel_state error)
 {
@@ -294,7 +381,7 @@ static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
  * @dev: pointer to Root Port's pci_dev data structure
  *
  * Invoked by Port Bus driver during nonfatal recovery.
- **/
+ */
 static void aer_error_resume(struct pci_dev *dev)
 {
         int pos;
@@ -321,7 +408,7 @@ static void aer_error_resume(struct pci_dev *dev)
  * aer_service_init - register AER root service driver
  *
  * Invoked when AER root service driver is loaded.
- **/
+ */
 static int __init aer_service_init(void)
 {
         if (pcie_aer_disable)
@@ -335,7 +422,7 @@ static int __init aer_service_init(void)
  * aer_service_exit - unregister AER root service driver
  *
  * Invoked when AER root service driver is unloaded.
- **/
+ */
 static void __exit aer_service_exit(void)
 {
         pcie_port_service_unregister(&aerdriver);
diff --git a/drivers/pci/pcie/aer/aerdrv.h b/drivers/pci/pcie/aer/aerdrv.h
index bd833ea3ba49..7aaae2d2bd67 100644
--- a/drivers/pci/pcie/aer/aerdrv.h
+++ b/drivers/pci/pcie/aer/aerdrv.h
@@ -17,9 +17,6 @@
 #define AER_FATAL                       1
 #define AER_CORRECTABLE                 2
 
-/* Root Error Status Register Bits */
-#define ROOT_ERR_STATUS_MASKS           0x0f
-
 #define SYSTEM_ERROR_INTR_ON_MESG_MASK  (PCI_EXP_RTCTL_SECEE|   \
                                         PCI_EXP_RTCTL_SENFEE|   \
                                         PCI_EXP_RTCTL_SEFEE)
@@ -117,8 +114,7 @@ static inline pci_ers_result_t merge_result(enum pci_ers_result orig,
 }
 
 extern struct bus_type pcie_port_bus_type;
-extern void aer_enable_rootport(struct aer_rpc *rpc);
-extern void aer_delete_rootport(struct aer_rpc *rpc);
+extern void aer_do_secondary_bus_reset(struct pci_dev *dev);
 extern int aer_init(struct pcie_device *dev);
 extern void aer_isr(struct work_struct *work);
 extern void aer_print_error(struct pci_dev *dev, struct aer_err_info *info);
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index aceb04b67b60..df2d686fe3dd 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -47,13 +47,12 @@ int pci_enable_pcie_error_reporting(struct pci_dev *dev)
         if (!pos)
                 return -EIO;
 
-        pci_read_config_word(dev, pos+PCI_EXP_DEVCTL, &reg16);
-        reg16 = reg16 |
-                PCI_EXP_DEVCTL_CERE |
+        pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &reg16);
+        reg16 |= (PCI_EXP_DEVCTL_CERE |
                 PCI_EXP_DEVCTL_NFERE |
                 PCI_EXP_DEVCTL_FERE |
-                PCI_EXP_DEVCTL_URRE;
-        pci_write_config_word(dev, pos+PCI_EXP_DEVCTL, reg16);
+                PCI_EXP_DEVCTL_URRE);
+        pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, reg16);
 
         return 0;
 }
@@ -71,12 +70,12 @@ int pci_disable_pcie_error_reporting(struct pci_dev *dev)
         if (!pos)
                 return -EIO;
 
-        pci_read_config_word(dev, pos+PCI_EXP_DEVCTL, &reg16);
-        reg16 = reg16 & ~(PCI_EXP_DEVCTL_CERE |
-                        PCI_EXP_DEVCTL_NFERE |
-                        PCI_EXP_DEVCTL_FERE |
-                        PCI_EXP_DEVCTL_URRE);
-        pci_write_config_word(dev, pos+PCI_EXP_DEVCTL, reg16);
+        pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &reg16);
+        reg16 &= ~(PCI_EXP_DEVCTL_CERE |
+                PCI_EXP_DEVCTL_NFERE |
+                PCI_EXP_DEVCTL_FERE |
+                PCI_EXP_DEVCTL_URRE);
+        pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, reg16);
 
         return 0;
 }
@@ -99,99 +98,46 @@ int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
 }
 EXPORT_SYMBOL_GPL(pci_cleanup_aer_uncorrect_error_status);
 
-static int set_device_error_reporting(struct pci_dev *dev, void *data)
-{
-        bool enable = *((bool *)data);
-
-        if ((dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) ||
-            (dev->pcie_type == PCI_EXP_TYPE_UPSTREAM) ||
-            (dev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)) {
-                if (enable)
-                        pci_enable_pcie_error_reporting(dev);
-                else
-                        pci_disable_pcie_error_reporting(dev);
-        }
-
-        if (enable)
-                pcie_set_ecrc_checking(dev);
-
-        return 0;
-}
-
 /**
- * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
- * @dev: pointer to root port's pci_dev data structure
- * @enable: true = enable error reporting, false = disable error reporting.
+ * add_error_device - list device to be handled
+ * @e_info: pointer to error info
+ * @dev: pointer to pci_dev to be added
  */
-static void set_downstream_devices_error_reporting(struct pci_dev *dev,
-                                                   bool enable)
-{
-        set_device_error_reporting(dev, &enable);
-
-        if (!dev->subordinate)
-                return;
-        pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
-}
-
-static inline int compare_device_id(struct pci_dev *dev,
-                        struct aer_err_info *e_info)
-{
-        if (e_info->id == ((dev->bus->number << 8) | dev->devfn)) {
-                /*
-                 * Device ID match
-                 */
-                return 1;
-        }
-
-        return 0;
-}
-
 static int add_error_device(struct aer_err_info *e_info, struct pci_dev *dev)
 {
         if (e_info->error_dev_num < AER_MAX_MULTI_ERR_DEVICES) {
                 e_info->dev[e_info->error_dev_num] = dev;
                 e_info->error_dev_num++;
-                return 1;
+                return 0;
         }
-
-        return 0;
+        return -ENOSPC;
 }
 
-
 #define PCI_BUS(x)      (((x) >> 8) & 0xff)
 
-static int find_device_iter(struct pci_dev *dev, void *data)
+/**
+ * is_error_source - check whether the device is source of reported error
+ * @dev: pointer to pci_dev to be checked
+ * @e_info: pointer to reported error info
+ */
+static bool is_error_source(struct pci_dev *dev, struct aer_err_info *e_info)
 {
         int pos;
-        u32 status;
-        u32 mask;
+        u32 status, mask;
         u16 reg16;
-        int result;
-        struct aer_err_info *e_info = (struct aer_err_info *)data;
 
         /*
          * When bus id is equal to 0, it might be a bad id
          * reported by root port.
          */
         if (!nosourceid && (PCI_BUS(e_info->id) != 0)) {
-                result = compare_device_id(dev, e_info);
-                if (result)
-                        add_error_device(e_info, dev);
+                /* Device ID match? */
+                if (e_info->id == ((dev->bus->number << 8) | dev->devfn))
+                        return true;
 
-                /*
-                 * If there is no multiple error, we stop
-                 * or continue based on the id comparing.
-                 */
+                /* Continue id comparing if there is no multiple error */
                 if (!e_info->multi_error_valid)
-                        return result;
-
-                /*
-                 * If there are multiple errors and id does match,
-                 * We need continue to search other devices under
-                 * the root port. Return 0 means that.
-                 */
-                if (result)
-                        return 0;
+                        return false;
         }
 
         /*
@@ -200,71 +146,94 @@ static int find_device_iter(struct pci_dev *dev, void *data)
          *      2) bus id is equal to 0. Some ports might lose the bus
          *              id of error source id;
          *      3) There are multiple errors and prior id comparing fails;
-         * We check AER status registers to find the initial reporter.
+         * We check AER status registers to find possible reporter.
          */
         if (atomic_read(&dev->enable_cnt) == 0)
-                return 0;
+                return false;
         pos = pci_pcie_cap(dev);
         if (!pos)
-                return 0;
+                return false;
+
         /* Check if AER is enabled */
-        pci_read_config_word(dev, pos+PCI_EXP_DEVCTL, &reg16);
+        pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &reg16);
         if (!(reg16 & (
                 PCI_EXP_DEVCTL_CERE |
                 PCI_EXP_DEVCTL_NFERE |
                 PCI_EXP_DEVCTL_FERE |
                 PCI_EXP_DEVCTL_URRE)))
-                return 0;
+                return false;
         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
         if (!pos)
-                return 0;
+                return false;
 
-        status = 0;
-        mask = 0;
+        /* Check if error is recorded */
         if (e_info->severity == AER_CORRECTABLE) {
                 pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &status);
                 pci_read_config_dword(dev, pos + PCI_ERR_COR_MASK, &mask);
-                if (status & ~mask) {
-                        add_error_device(e_info, dev);
-                        goto added;
-                }
         } else {
                 pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &status);
                 pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, &mask);
-                if (status & ~mask) {
-                        add_error_device(e_info, dev);
-                        goto added;
-                }
         }
+        if (status & ~mask)
+                return true;
 
-        return 0;
+        return false;
+}
 
-added:
-        if (e_info->multi_error_valid)
-                return 0;
-        else
-                return 1;
+static int find_device_iter(struct pci_dev *dev, void *data)
+{
+        struct aer_err_info *e_info = (struct aer_err_info *)data;
+
+        if (is_error_source(dev, e_info)) {
+                /* List this device */
+                if (add_error_device(e_info, dev)) {
+                        /* We cannot handle more... Stop iteration */
+                        /* TODO: Should print error message here? */
+                        return 1;
+                }
+
+                /* If there is only a single error, stop iteration */
+                if (!e_info->multi_error_valid)
+                        return 1;
+        }
+        return 0;
 }
 
 /**
  * find_source_device - search through device hierarchy for source device
  * @parent: pointer to Root Port pci_dev data structure
- * @err_info: including detailed error information such like id
+ * @e_info: including detailed error information such like id
  *
- * Invoked when error is detected at the Root Port.
+ * Return true if found.
+ *
+ * Invoked by DPC when error is detected at the Root Port.
+ * Caller of this function must set id, severity, and multi_error_valid of
+ * struct aer_err_info pointed by @e_info properly.  This function must fill
+ * e_info->error_dev_num and e_info->dev[], based on the given information.
  */
-static void find_source_device(struct pci_dev *parent,
+static bool find_source_device(struct pci_dev *parent,
                 struct aer_err_info *e_info)
 {
         struct pci_dev *dev = parent;
         int result;
 
+        /* Must reset in this function */
+        e_info->error_dev_num = 0;
+
         /* Is Root Port an agent that sends error message? */
         result = find_device_iter(dev, e_info);
         if (result)
-                return;
+                return true;
 
         pci_walk_bus(parent->subordinate, find_device_iter, e_info);
+
+        if (!e_info->error_dev_num) {
+                dev_printk(KERN_DEBUG, &parent->dev,
+                                "can't find device of ID%04x\n",
+                                e_info->id);
+                return false;
+        }
+        return true;
 }
 
 static int report_error_detected(struct pci_dev *dev, void *data)
@@ -403,43 +372,77 @@ static pci_ers_result_t broadcast_error_message(struct pci_dev *dev,
         return result_data.result;
 }
 
-struct find_aer_service_data {
-        struct pcie_port_service_driver *aer_driver;
-        int is_downstream;
-};
-
-static int find_aer_service_iter(struct device *device, void *data)
+/**
+ * aer_do_secondary_bus_reset - perform secondary bus reset
+ * @dev: pointer to bridge's pci_dev data structure
+ *
+ * Invoked when performing link reset at Root Port or Downstream Port.
+ */
+void aer_do_secondary_bus_reset(struct pci_dev *dev)
 {
-        struct device_driver *driver;
-        struct pcie_port_service_driver *service_driver;
-        struct find_aer_service_data *result;
+        u16 p2p_ctrl;
+
+        /* Assert Secondary Bus Reset */
+        pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &p2p_ctrl);
+        p2p_ctrl |= PCI_BRIDGE_CTL_BUS_RESET;
+        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, p2p_ctrl);
+
+        /*
+         * we should send hot reset message for 2ms to allow it time to
+         * propagate to all downstream ports
+         */
+        msleep(2);
+
+        /* De-assert Secondary Bus Reset */
+        p2p_ctrl &= ~PCI_BRIDGE_CTL_BUS_RESET;
+        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, p2p_ctrl);
+
+        /*
+         * System software must wait for at least 100ms from the end
+         * of a reset of one or more device before it is permitted
+         * to issue Configuration Requests to those devices.
+         */
+        msleep(200);
+}
 
-        result = (struct find_aer_service_data *) data;
+/**
+ * default_downstream_reset_link - default reset function for Downstream Port
+ * @dev: pointer to downstream port's pci_dev data structure
+ *
+ * Invoked when performing link reset at Downstream Port w/ no aer driver.
+ */
+static pci_ers_result_t default_downstream_reset_link(struct pci_dev *dev)
+{
+        aer_do_secondary_bus_reset(dev);
+        dev_printk(KERN_DEBUG, &dev->dev,
+                "Downstream Port link has been reset\n");
+        return PCI_ERS_RESULT_RECOVERED;
+}
 
-        if (device->bus == &pcie_port_bus_type) {
-                struct pcie_device *pcie = to_pcie_device(device);
+static int find_aer_service_iter(struct device *device, void *data)
+{
+        struct pcie_port_service_driver *service_driver, **drv;
 
-                if (pcie->port->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
-                        result->is_downstream = 1;
+        drv = (struct pcie_port_service_driver **) data;
 
-                driver = device->driver;
-                if (driver) {
-                        service_driver = to_service_driver(driver);
-                        if (service_driver->service == PCIE_PORT_SERVICE_AER) {
-                                result->aer_driver = service_driver;
-                                return 1;
-                        }
+        if (device->bus == &pcie_port_bus_type && device->driver) {
+                service_driver = to_service_driver(device->driver);
+                if (service_driver->service == PCIE_PORT_SERVICE_AER) {
+                        *drv = service_driver;
+                        return 1;
                 }
         }
 
         return 0;
 }
 
-static void find_aer_service(struct pci_dev *dev,
-                struct find_aer_service_data *data)
+static struct pcie_port_service_driver *find_aer_service(struct pci_dev *dev)
 {
-        int retval;
-        retval = device_for_each_child(&dev->dev, data, find_aer_service_iter);
+        struct pcie_port_service_driver *drv = NULL;
+
+        device_for_each_child(&dev->dev, &drv, find_aer_service_iter);
+
+        return drv;
 }
 
 static pci_ers_result_t reset_link(struct pcie_device *aerdev,
@@ -447,38 +450,34 @@ static pci_ers_result_t reset_link(struct pcie_device *aerdev,
 {
         struct pci_dev *udev;
         pci_ers_result_t status;
-        struct find_aer_service_data data;
+        struct pcie_port_service_driver *driver;
 
-        if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE)
+        if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE) {
+                /* Reset this port for all subordinates */
                 udev = dev;
-        else
+        } else {
+                /* Reset the upstream component (likely downstream port) */
                 udev = dev->bus->self;
+        }
 
-        data.is_downstream = 0;
-        data.aer_driver = NULL;
-        find_aer_service(udev, &data);
+        /* Use the aer driver of the component firstly */
+        driver = find_aer_service(udev);
 
-        /*
-         * Use the aer driver of the error agent firstly.
-         * If it hasn't the aer driver, use the root port's
-         */
-        if (!data.aer_driver || !data.aer_driver->reset_link) {
-                if (data.is_downstream &&
-                        aerdev->device.driver &&
-                        to_service_driver(aerdev->device.driver)->reset_link) {
-                        data.aer_driver =
-                                to_service_driver(aerdev->device.driver);
-                } else {
-                        dev_printk(KERN_DEBUG, &dev->dev, "no link-reset "
-                                   "support\n");
-                        return PCI_ERS_RESULT_DISCONNECT;
-                }
+        if (driver && driver->reset_link) {
+                status = driver->reset_link(udev);
+        } else if (udev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM) {
+                status = default_downstream_reset_link(udev);
+        } else {
+                dev_printk(KERN_DEBUG, &dev->dev,
+                        "no link-reset support at upstream device %s\n",
+                        pci_name(udev));
+                return PCI_ERS_RESULT_DISCONNECT;
         }
 
-        status = data.aer_driver->reset_link(udev);
         if (status != PCI_ERS_RESULT_RECOVERED) {
-                dev_printk(KERN_DEBUG, &dev->dev, "link reset at upstream "
-                           "device %s failed\n", pci_name(udev));
+                dev_printk(KERN_DEBUG, &dev->dev,
+                        "link reset at upstream device %s failed\n",
+                        pci_name(udev));
                 return PCI_ERS_RESULT_DISCONNECT;
         }
 
@@ -495,8 +494,7 @@ static pci_ers_result_t reset_link(struct pcie_device *aerdev,
  * error detected message to all downstream drivers within a hierarchy in
  * question and return the returned code.
  */
-static pci_ers_result_t do_recovery(struct pcie_device *aerdev,
-                struct pci_dev *dev,
+static void do_recovery(struct pcie_device *aerdev, struct pci_dev *dev,
                 int severity)
 {
         pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED;
@@ -514,10 +512,8 @@ static pci_ers_result_t do_recovery(struct pcie_device *aerdev,
 
         if (severity == AER_FATAL) {
                 result = reset_link(aerdev, dev);
-                if (result != PCI_ERS_RESULT_RECOVERED) {
-                        /* TODO: Should panic here? */
-                        return result;
-                }
+                if (result != PCI_ERS_RESULT_RECOVERED)
+                        goto failed;
         }
 
         if (status == PCI_ERS_RESULT_CAN_RECOVER)
@@ -538,13 +534,22 @@ static pci_ers_result_t do_recovery(struct pcie_device *aerdev,
                                 report_slot_reset);
         }
 
-        if (status == PCI_ERS_RESULT_RECOVERED)
-                broadcast_error_message(dev,
+        if (status != PCI_ERS_RESULT_RECOVERED)
+                goto failed;
+
+        broadcast_error_message(dev,
                                 state,
                                 "resume",
                                 report_resume);
 
-        return status;
+        dev_printk(KERN_DEBUG, &dev->dev,
+                "AER driver successfully recovered\n");
+        return;
+
+failed:
+        /* TODO: Should kernel panic here? */
+        dev_printk(KERN_DEBUG, &dev->dev,
+                "AER driver didn't recover\n");
 }
 
 /**
@@ -559,7 +564,6 @@ static void handle_error_source(struct pcie_device *aerdev,
         struct pci_dev *dev,
         struct aer_err_info *info)
 {
-        pci_ers_result_t status = 0;
         int pos;
 
         if (info->severity == AER_CORRECTABLE) {
@@ -571,114 +575,8 @@ static void handle_error_source(struct pcie_device *aerdev,
                 if (pos)
                         pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS,
                                         info->status);
-        } else {
-                status = do_recovery(aerdev, dev, info->severity);
-                if (status == PCI_ERS_RESULT_RECOVERED) {
-                        dev_printk(KERN_DEBUG, &dev->dev, "AER driver "
-                                   "successfully recovered\n");
-                } else {
-                        /* TODO: Should kernel panic here? */
-                        dev_printk(KERN_DEBUG, &dev->dev, "AER driver didn't "
-                                   "recover\n");
-                }
-        }
-}
-
-/**
- * aer_enable_rootport - enable Root Port's interrupts when receiving messages
- * @rpc: pointer to a Root Port data structure
- *
- * Invoked when PCIe bus loads AER service driver.
- */
-void aer_enable_rootport(struct aer_rpc *rpc)
-{
-        struct pci_dev *pdev = rpc->rpd->port;
-        int pos, aer_pos;
-        u16 reg16;
-        u32 reg32;
-
-        pos = pci_pcie_cap(pdev);
-        /* Clear PCIe Capability's Device Status */
-        pci_read_config_word(pdev, pos+PCI_EXP_DEVSTA, &reg16);
-        pci_write_config_word(pdev, pos+PCI_EXP_DEVSTA, reg16);
-
-        /* Disable system error generation in response to error messages */
-        pci_read_config_word(pdev, pos + PCI_EXP_RTCTL, &reg16);
-        reg16 &= ~(SYSTEM_ERROR_INTR_ON_MESG_MASK);
-        pci_write_config_word(pdev, pos + PCI_EXP_RTCTL, reg16);
-
-        aer_pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
-        /* Clear error status */
-        pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
-        pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
-        pci_read_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, &reg32);
-        pci_write_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, reg32);
-        pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
-        pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
-
-        /*
-         * Enable error reporting for the root port device and downstream port
-         * devices.
-         */
-        set_downstream_devices_error_reporting(pdev, true);
-
-        /* Enable Root Port's interrupt in response to error messages */
-        pci_write_config_dword(pdev,
-                aer_pos + PCI_ERR_ROOT_COMMAND,
-                ROOT_PORT_INTR_ON_MESG_MASK);
-}
-
-/**
- * disable_root_aer - disable Root Port's interrupts when receiving messages
- * @rpc: pointer to a Root Port data structure
- *
- * Invoked when PCIe bus unloads AER service driver.
- */
-static void disable_root_aer(struct aer_rpc *rpc)
-{
-        struct pci_dev *pdev = rpc->rpd->port;
-        u32 reg32;
-        int pos;
-
-        /*
-         * Disable error reporting for the root port device and downstream port
-         * devices.
-         */
-        set_downstream_devices_error_reporting(pdev, false);
-
-        pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
-        /* Disable Root's interrupt in response to error messages */
-        pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, 0);
-
-        /* Clear Root's error status reg */
-        pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, &reg32);
-        pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, reg32);
-}
-
-/**
- * get_e_source - retrieve an error source
- * @rpc: pointer to the root port which holds an error
- *
- * Invoked by DPC handler to consume an error.
- */
-static struct aer_err_source *get_e_source(struct aer_rpc *rpc)
-{
-        struct aer_err_source *e_source;
-        unsigned long flags;
-
-        /* Lock access to Root error producer/consumer index */
-        spin_lock_irqsave(&rpc->e_lock, flags);
-        if (rpc->prod_idx == rpc->cons_idx) {
-                spin_unlock_irqrestore(&rpc->e_lock, flags);
-                return NULL;
-        }
-        e_source = &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 e_source;
+        } else
+                do_recovery(aerdev, dev, info->severity);
 }
 
 /**
@@ -687,11 +585,14 @@ static struct aer_err_source *get_e_source(struct aer_rpc *rpc)
  * @info: pointer to structure to store the error record
  *
  * Return 1 on success, 0 on error.
+ *
+ * Note that @info is reused among all error devices. Clear fields properly.
  */
 static int get_device_error_info(struct pci_dev *dev, struct aer_err_info *info)
 {
         int pos, temp;
 
+        /* Must reset in this function */
         info->status = 0;
         info->tlp_header_valid = 0;
 
@@ -744,12 +645,6 @@ static inline void aer_process_err_devices(struct pcie_device *p_device,
 {
         int i;
 
-        if (!e_info->dev[0]) {
-                dev_printk(KERN_DEBUG, &p_device->port->dev,
-                                "can't find device of ID%04x\n",
-                                e_info->id);
-        }
-
         /* Report all before handle them, not to lost records by reset etc. */
         for (i = 0; i < e_info->error_dev_num && e_info->dev[i]; i++) {
                 if (get_device_error_info(e_info->dev[i], e_info))
@@ -770,11 +665,10 @@ static void aer_isr_one_error(struct pcie_device *p_device,
                 struct aer_err_source *e_src)
 {
         struct aer_err_info *e_info;
-        int i;
 
         /* struct aer_err_info might be big, so we allocate it with slab */
         e_info = kmalloc(sizeof(struct aer_err_info), GFP_KERNEL);
-        if (e_info == NULL) {
+        if (!e_info) {
                 dev_printk(KERN_DEBUG, &p_device->port->dev,
                         "Can't allocate mem when processing AER errors\n");
                 return;
@@ -784,37 +678,72 @@ static void aer_isr_one_error(struct pcie_device *p_device,
          * There is a possibility that both correctable error and
          * uncorrectable error being logged. Report correctable error first.
          */
-        for (i = 1; i & ROOT_ERR_STATUS_MASKS ; i <<= 2) {
-                if (i > 4)
-                        break;
-                if (!(e_src->status & i))
-                        continue;
-
-                memset(e_info, 0, sizeof(struct aer_err_info));
-
-                /* Init comprehensive error information */
-                if (i & PCI_ERR_ROOT_COR_RCV) {
-                        e_info->id = ERR_COR_ID(e_src->id);
-                        e_info->severity = AER_CORRECTABLE;
-                } else {
-                        e_info->id = ERR_UNCOR_ID(e_src->id);
-                        e_info->severity = ((e_src->status >> 6) & 1);
-                }
-                if (e_src->status &
-                        (PCI_ERR_ROOT_MULTI_COR_RCV |
-                         PCI_ERR_ROOT_MULTI_UNCOR_RCV))
+        if (e_src->status & PCI_ERR_ROOT_COR_RCV) {
+                e_info->id = ERR_COR_ID(e_src->id);
+                e_info->severity = AER_CORRECTABLE;
+
+                if (e_src->status & PCI_ERR_ROOT_MULTI_COR_RCV)
                         e_info->multi_error_valid = 1;
+                else
+                        e_info->multi_error_valid = 0;
+
+                aer_print_port_info(p_device->port, e_info);
+
+                if (find_source_device(p_device->port, e_info))
+                        aer_process_err_devices(p_device, e_info);
+        }
+
+        if (e_src->status & PCI_ERR_ROOT_UNCOR_RCV) {
+                e_info->id = ERR_UNCOR_ID(e_src->id);
+
+                if (e_src->status & PCI_ERR_ROOT_FATAL_RCV)
+                        e_info->severity = AER_FATAL;
+                else
+                        e_info->severity = AER_NONFATAL;
+
+                if (e_src->status & PCI_ERR_ROOT_MULTI_UNCOR_RCV)
+                        e_info->multi_error_valid = 1;
+                else
+                        e_info->multi_error_valid = 0;
 
                 aer_print_port_info(p_device->port, e_info);
 
-                find_source_device(p_device->port, e_info);
-                aer_process_err_devices(p_device, e_info);
+                if (find_source_device(p_device->port, e_info))
+                        aer_process_err_devices(p_device, e_info);
         }
 
         kfree(e_info);
 }
 
 /**
+ * get_e_source - retrieve an error source
+ * @rpc: pointer to the root port which holds an error
+ * @e_src: pointer to store retrieved error source
+ *
+ * Return 1 if an error source is retrieved, otherwise 0.
+ *
+ * Invoked by DPC handler to consume an error.
+ */
+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) {
+                *e_src = rpc->e_sources[rpc->cons_idx];
+                rpc->cons_idx++;
+                if (rpc->cons_idx == AER_ERROR_SOURCES_MAX)
+                        rpc->cons_idx = 0;
+                ret = 1;
+        }
+        spin_unlock_irqrestore(&rpc->e_lock, flags);
+
+        return ret;
+}
+
+/**
  * aer_isr - consume errors detected by root port
  * @work: definition of this work item
  *
@@ -824,34 +753,17 @@ void aer_isr(struct work_struct *work)
 {
         struct aer_rpc *rpc = container_of(work, struct aer_rpc, dpc_handler);
         struct pcie_device *p_device = rpc->rpd;
-        struct aer_err_source *e_src;
+        struct aer_err_source e_src;
 
         mutex_lock(&rpc->rpc_mutex);
-        e_src = get_e_source(rpc);
-        while (e_src) {
-                aer_isr_one_error(p_device, e_src);
-                e_src = get_e_source(rpc);
-        }
+        while (get_e_source(rpc, &e_src))
+                aer_isr_one_error(p_device, &e_src);
         mutex_unlock(&rpc->rpc_mutex);
 
         wake_up(&rpc->wait_release);
 }
 
 /**
- * aer_delete_rootport - disable root port aer and delete service data
- * @rpc: pointer to a root port device being deleted
- *
- * Invoked when AER service unloaded on a specific Root Port
- */
-void aer_delete_rootport(struct aer_rpc *rpc)
-{
-        /* Disable root port AER itself */
-        disable_root_aer(rpc);
-
-        kfree(rpc);
-}
-
-/**
  * aer_init - provide AER initialization
  * @dev: pointer to AER pcie device
  *
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 27c0e6eb7136..b7512cf08c58 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -2127,6 +2127,7 @@ 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);
 
 /* Go through the list of Hypertransport capabilities and
  * return 1 if a HT MSI capability is found and enabled */
@@ -2218,15 +2219,16 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS,
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8132_BRIDGE,
                          ht_enable_msi_mapping);
 
-/* The P5N32-SLI Premium motherboard from Asus has a problem with msi
+/* The P5N32-SLI motherboards from Asus have 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")) {
+        if (dmi_name_in_vendors("P5N32-SLI PREMIUM") ||
+            dmi_name_in_vendors("P5N32-E SLI")) {
                 dev_info(&dev->dev,
-                         "Disabling msi for MCP55 NIC on P5N32-SLI Premium\n");
+                         "Disabling msi for MCP55 NIC on P5N32-SLI\n");
                 dev->no_msi = 1;
         }
 }
@@ -2552,6 +2554,19 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x1518, quirk_i82576_sriov);
 
 #endif  /* CONFIG_PCI_IOV */
 
+/* Allow manual resource allocation for PCI hotplug bridges
+ * via pci=hpmemsize=nnM and pci=hpiosize=nnM parameters. For
+ * some PCI-PCI hotplug bridges, like PLX 6254 (former HINT HB6),
+ * kernel fails to allocate resources when hotplug device is 
+ * inserted and PCI bus is rescanned.
+ */
+static void __devinit quirk_hotplug_bridge(struct pci_dev *dev)
+{
+        dev->is_hotplug_bridge = 1;
+}
+
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_HINT, 0x0020, quirk_hotplug_bridge);
+
 /*
  * This is a quirk for the Ricoh MMC controller found as a part of
  * some mulifunction chips.
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index 659eaa0fc48f..e0189cf7c558 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -97,6 +97,50 @@ static ssize_t cur_speed_read_file(struct pci_slot *slot, char *buf)
         return bus_speed_read(slot->bus->cur_bus_speed, buf);
 }
 
+static void remove_sysfs_files(struct pci_slot *slot)
+{
+        char func[10];
+        struct list_head *tmp;
+
+        list_for_each(tmp, &slot->bus->devices) {
+                struct pci_dev *dev = pci_dev_b(tmp);
+                if (PCI_SLOT(dev->devfn) != slot->number)
+                        continue;
+                sysfs_remove_link(&dev->dev.kobj, "slot");
+
+                snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
+                sysfs_remove_link(&slot->kobj, func);
+        }
+}
+
+static int create_sysfs_files(struct pci_slot *slot)
+{
+        int result;
+        char func[10];
+        struct list_head *tmp;
+
+        list_for_each(tmp, &slot->bus->devices) {
+                struct pci_dev *dev = pci_dev_b(tmp);
+                if (PCI_SLOT(dev->devfn) != slot->number)
+                        continue;
+
+                result = sysfs_create_link(&dev->dev.kobj, &slot->kobj, "slot");
+                if (result)
+                        goto fail;
+
+                snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
+                result = sysfs_create_link(&slot->kobj, &dev->dev.kobj, func);
+                if (result)
+                        goto fail;
+        }
+
+        return 0;
+
+fail:
+        remove_sysfs_files(slot);
+        return result;
+}
+
 static void pci_slot_release(struct kobject *kobj)
 {
         struct pci_dev *dev;
@@ -109,6 +153,8 @@ static void pci_slot_release(struct kobject *kobj)
                 if (PCI_SLOT(dev->devfn) == slot->number)
                         dev->slot = NULL;
 
+        remove_sysfs_files(slot);
+
         list_del(&slot->list);
 
         kfree(slot);
@@ -300,6 +346,8 @@ placeholder:
         INIT_LIST_HEAD(&slot->list);
         list_add(&slot->list, &parent->slots);
 
+        create_sysfs_files(slot);
+
         list_for_each_entry(dev, &parent->devices, bus_list)
                 if (PCI_SLOT(dev->devfn) == slot_nr)
                         dev->slot = slot;