Merge branch 'next' into for-linus

30 files changed, 1299 insertions, 615 deletions

diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 37856f7c7781..848bfb84c04c 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -31,6 +31,19 @@ config PCI_DEBUG
 
           When in doubt, say N.
 
+config PCI_REALLOC_ENABLE_AUTO
+        bool "Enable PCI resource re-allocation detection"
+        depends on PCI
+        help
+          Say Y here if you want the PCI core to detect if PCI resource
+          re-allocation needs to be enabled. You can always use pci=realloc=on
+          or pci=realloc=off to override it.  Note this feature is a no-op
+          unless PCI_IOV support is also enabled; in that case it will
+          automatically re-allocate PCI resources if SR-IOV BARs have not
+          been allocated by the BIOS.
+
+          When in doubt, say N.
+
 config PCI_STUB
         tristate "PCI Stub driver"
         depends on PCI
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 398f5d859791..4ce5ef2f2826 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -18,28 +18,36 @@
 
 #include "pci.h"
 
-void pci_add_resource(struct list_head *resources, struct resource *res)
+void pci_add_resource_offset(struct list_head *resources, struct resource *res,
+                             resource_size_t offset)
 {
-        struct pci_bus_resource *bus_res;
+        struct pci_host_bridge_window *window;
 
-        bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL);
-        if (!bus_res) {
-                printk(KERN_ERR "PCI: can't add bus resource %pR\n", res);
+        window = kzalloc(sizeof(struct pci_host_bridge_window), GFP_KERNEL);
+        if (!window) {
+                printk(KERN_ERR "PCI: can't add host bridge window %pR\n", res);
                 return;
         }
 
-        bus_res->res = res;
-        list_add_tail(&bus_res->list, resources);
+        window->res = res;
+        window->offset = offset;
+        list_add_tail(&window->list, resources);
+}
+EXPORT_SYMBOL(pci_add_resource_offset);
+
+void pci_add_resource(struct list_head *resources, struct resource *res)
+{
+        pci_add_resource_offset(resources, res, 0);
 }
 EXPORT_SYMBOL(pci_add_resource);
 
 void pci_free_resource_list(struct list_head *resources)
 {
-        struct pci_bus_resource *bus_res, *tmp;
+        struct pci_host_bridge_window *window, *tmp;
 
-        list_for_each_entry_safe(bus_res, tmp, resources, list) {
-                list_del(&bus_res->list);
-                kfree(bus_res);
+        list_for_each_entry_safe(window, tmp, resources, list) {
+                list_del(&window->list);
+                kfree(window);
         }
 }
 EXPORT_SYMBOL(pci_free_resource_list);
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 9ddf69e3bbef..806c44fa645a 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -800,20 +800,10 @@ static int __ref enable_device(struct acpiphp_slot *slot)
         if (slot->flags & SLOT_ENABLED)
                 goto err_exit;
 
-        /* sanity check: dev should be NULL when hot-plugged in */
-        dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0));
-        if (dev) {
-                /* This case shouldn't happen */
-                err("pci_dev structure already exists.\n");
-                pci_dev_put(dev);
-                retval = -1;
-                goto err_exit;
-        }
-
         num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0));
         if (num == 0) {
-                err("No new device found\n");
-                retval = -1;
+                /* Maybe only part of funcs are added. */
+                dbg("No new device found\n");
                 goto err_exit;
         }
 
@@ -848,11 +838,16 @@ static int __ref enable_device(struct acpiphp_slot *slot)
 
         pci_bus_add_devices(bus);
 
+        slot->flags |= SLOT_ENABLED;
         list_for_each_entry(func, &slot->funcs, sibling) {
                 dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
                                                   func->function));
-                if (!dev)
+                if (!dev) {
+                        /* Do not set SLOT_ENABLED flag if some funcs
+                           are not added. */
+                        slot->flags &= (~SLOT_ENABLED);
                         continue;
+                }
 
                 if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
                     dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) {
@@ -867,7 +862,6 @@ static int __ref enable_device(struct acpiphp_slot *slot)
                 pci_dev_put(dev);
         }
 
-        slot->flags |= SLOT_ENABLED;
 
  err_exit:
         return retval;
@@ -892,9 +886,12 @@ static int disable_device(struct acpiphp_slot *slot)
 {
         struct acpiphp_func *func;
         struct pci_dev *pdev;
+        struct pci_bus *bus = slot->bridge->pci_bus;
 
-        /* is this slot already disabled? */
-        if (!(slot->flags & SLOT_ENABLED))
+        /* The slot will be enabled when func 0 is added, so check
+           func 0 before disable the slot. */
+        pdev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0));
+        if (!pdev)
                 goto err_exit;
 
         list_for_each_entry(func, &slot->funcs, sibling) {
@@ -913,7 +910,7 @@ static int disable_device(struct acpiphp_slot *slot)
                                 disable_bridges(pdev->subordinate);
                                 pci_disable_device(pdev);
                         }
-                        pci_remove_bus_device(pdev);
+                        __pci_remove_bus_device(pdev);
                         pci_dev_put(pdev);
                 }
         }
@@ -1070,7 +1067,7 @@ static void acpiphp_sanitize_bus(struct pci_bus *bus)
                                         res->end) {
                                 /* Could not assign a required resources
                                  * for this device, remove it */
-                                pci_remove_bus_device(dev);
+                                pci_stop_and_remove_bus_device(dev);
                                 break;
                         }
                 }
diff --git a/drivers/pci/hotplug/cpci_hotplug_pci.c b/drivers/pci/hotplug/cpci_hotplug_pci.c
index 829c327cfb5e..ae853ccd0cd5 100644
--- a/drivers/pci/hotplug/cpci_hotplug_pci.c
+++ b/drivers/pci/hotplug/cpci_hotplug_pci.c
@@ -341,7 +341,7 @@ int cpci_unconfigure_slot(struct slot* slot)
                 dev = pci_get_slot(slot->bus,
                                     PCI_DEVFN(PCI_SLOT(slot->devfn), i));
                 if (dev) {
-                        pci_remove_bus_device(dev);
+                        pci_stop_and_remove_bus_device(dev);
                         pci_dev_put(dev);
                 }
         }
diff --git a/drivers/pci/hotplug/cpcihp_generic.c b/drivers/pci/hotplug/cpcihp_generic.c
index fb3f84661bdc..81af764c629b 100644
--- a/drivers/pci/hotplug/cpcihp_generic.c
+++ b/drivers/pci/hotplug/cpcihp_generic.c
@@ -62,7 +62,7 @@
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
 
 /* local variables */
-static int debug;
+static bool debug;
 static char *bridge;
 static u8 bridge_busnr;
 static u8 bridge_slot;
diff --git a/drivers/pci/hotplug/cpqphp_pci.c b/drivers/pci/hotplug/cpqphp_pci.c
index 6173b9a4544e..1c8494021a42 100644
--- a/drivers/pci/hotplug/cpqphp_pci.c
+++ b/drivers/pci/hotplug/cpqphp_pci.c
@@ -127,7 +127,7 @@ int cpqhp_unconfigure_device(struct pci_func* func)
                 struct pci_dev* temp = pci_get_bus_and_slot(func->bus, PCI_DEVFN(func->device, j));
                 if (temp) {
                         pci_dev_put(temp);
-                        pci_remove_bus_device(temp);
+                        pci_stop_and_remove_bus_device(temp);
                 }
         }
         return 0;
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 17d10e2e8fb6..a019c9a712be 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -40,7 +40,7 @@ static ssize_t legacy_show(struct kobject *kobj, struct attribute *attr,
 
 static void remove_callback(void *data)
 {
-        pci_remove_bus_device((struct pci_dev *)data);
+        pci_stop_and_remove_bus_device((struct pci_dev *)data);
 }
 
 static ssize_t legacy_store(struct kobject *kobj, struct attribute *attr,
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 5506e0e8fbc0..4fda7e6a86a7 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -721,7 +721,7 @@ static void ibm_unconfigure_device(struct pci_func *func)
         for (j = 0; j < 0x08; j++) {
                 temp = pci_get_bus_and_slot(func->busno, (func->device << 3) | j);
                 if (temp) {
-                        pci_remove_bus_device(temp);
+                        pci_stop_and_remove_bus_device(temp);
                         pci_dev_put(temp);
                 }
         }
diff --git a/drivers/pci/hotplug/ibmphp_ebda.c b/drivers/pci/hotplug/ibmphp_ebda.c
index 2850e64dedae..714ca5c4ed50 100644
--- a/drivers/pci/hotplug/ibmphp_ebda.c
+++ b/drivers/pci/hotplug/ibmphp_ebda.c
@@ -368,8 +368,10 @@ int __init ibmphp_access_ebda (void)
                         debug ("rio blk id: %x\n", blk_id);
 
                         rio_table_ptr = kzalloc(sizeof(struct rio_table_hdr), GFP_KERNEL);
-                        if (!rio_table_ptr)
-                                return -ENOMEM; 
+                        if (!rio_table_ptr) {
+                                rc = -ENOMEM;
+                                goto out;
+                        }
                         rio_table_ptr->ver_num = readb (io_mem + offset);
                         rio_table_ptr->scal_count = readb (io_mem + offset + 1);
                         rio_table_ptr->riodev_count = readb (io_mem + offset + 2);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index bcdbb1643621..a960faec1021 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -241,34 +241,79 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
         return retval;
 }
 
-static inline int check_link_active(struct controller *ctrl)
+static bool check_link_active(struct controller *ctrl)
 {
-        u16 link_status;
+        bool ret = false;
+        u16 lnk_status;
 
-        if (pciehp_readw(ctrl, PCI_EXP_LNKSTA, &link_status))
-                return 0;
-        return !!(link_status & PCI_EXP_LNKSTA_DLLLA);
+        if (pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status))
+                return ret;
+
+        ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
+
+        if (ret)
+                ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
+
+        return ret;
 }
 
-static void pcie_wait_link_active(struct controller *ctrl)
+static void __pcie_wait_link_active(struct controller *ctrl, bool active)
 {
         int timeout = 1000;
 
-        if (check_link_active(ctrl))
+        if (check_link_active(ctrl) == active)
                 return;
         while (timeout > 0) {
                 msleep(10);
                 timeout -= 10;
-                if (check_link_active(ctrl))
+                if (check_link_active(ctrl) == active)
                         return;
         }
-        ctrl_dbg(ctrl, "Data Link Layer Link Active not set in 1000 msec\n");
+        ctrl_dbg(ctrl, "Data Link Layer Link Active not %s in 1000 msec\n",
+                        active ? "set" : "cleared");
+}
+
+static void pcie_wait_link_active(struct controller *ctrl)
+{
+        __pcie_wait_link_active(ctrl, true);
+}
+
+static void pcie_wait_link_not_active(struct controller *ctrl)
+{
+        __pcie_wait_link_active(ctrl, false);
+}
+
+static bool pci_bus_check_dev(struct pci_bus *bus, int devfn)
+{
+        u32 l;
+        int count = 0;
+        int delay = 1000, step = 20;
+        bool found = false;
+
+        do {
+                found = pci_bus_read_dev_vendor_id(bus, devfn, &l, 0);
+                count++;
+
+                if (found)
+                        break;
+
+                msleep(step);
+                delay -= step;
+        } while (delay > 0);
+
+        if (count > 1 && pciehp_debug)
+                printk(KERN_DEBUG "pci %04x:%02x:%02x.%d id reading try %d times with interval %d ms to get %08x\n",
+                        pci_domain_nr(bus), bus->number, PCI_SLOT(devfn),
+                        PCI_FUNC(devfn), count, step, l);
+
+        return found;
 }
 
 int pciehp_check_link_status(struct controller *ctrl)
 {
         u16 lnk_status;
         int retval = 0;
+        bool found = false;
 
         /*
          * Data Link Layer Link Active Reporting must be capable for
@@ -280,13 +325,10 @@ int pciehp_check_link_status(struct controller *ctrl)
         else
                 msleep(1000);
 
-        /*
-         * Need to wait for 1000 ms after Data Link Layer Link Active
-         * (DLLLA) bit reads 1b before sending configuration request.
-         * We need it before checking Link Training (LT) bit becuase
-         * LT is still set even after DLLLA bit is set on some platform.
-         */
-        msleep(1000);
+        /* wait 100ms before read pci conf, and try in 1s */
+        msleep(100);
+        found = pci_bus_check_dev(ctrl->pcie->port->subordinate,
+                                        PCI_DEVFN(0, 0));
 
         retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
         if (retval) {
@@ -302,19 +344,50 @@ int pciehp_check_link_status(struct controller *ctrl)
                 return retval;
         }
 
-        /*
-         * If the port supports Link speeds greater than 5.0 GT/s, we
-         * must wait for 100 ms after Link training completes before
-         * sending configuration request.
-         */
-        if (ctrl->pcie->port->subordinate->max_bus_speed > PCIE_SPEED_5_0GT)
-                msleep(100);
-
         pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
 
+        if (!found && !retval)
+                retval = -1;
+
         return retval;
 }
 
+static int __pciehp_link_set(struct controller *ctrl, bool enable)
+{
+        u16 lnk_ctrl;
+        int retval = 0;
+
+        retval = pciehp_readw(ctrl, PCI_EXP_LNKCTL, &lnk_ctrl);
+        if (retval) {
+                ctrl_err(ctrl, "Cannot read LNKCTRL register\n");
+                return retval;
+        }
+
+        if (enable)
+                lnk_ctrl &= ~PCI_EXP_LNKCTL_LD;
+        else
+                lnk_ctrl |= PCI_EXP_LNKCTL_LD;
+
+        retval = pciehp_writew(ctrl, PCI_EXP_LNKCTL, lnk_ctrl);
+        if (retval) {
+                ctrl_err(ctrl, "Cannot write LNKCTRL register\n");
+                return retval;
+        }
+        ctrl_dbg(ctrl, "%s: lnk_ctrl = %x\n", __func__, lnk_ctrl);
+
+        return retval;
+}
+
+static int pciehp_link_enable(struct controller *ctrl)
+{
+        return __pciehp_link_set(ctrl, true);
+}
+
+static int pciehp_link_disable(struct controller *ctrl)
+{
+        return __pciehp_link_set(ctrl, false);
+}
+
 int pciehp_get_attention_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
@@ -533,6 +606,10 @@ int pciehp_power_on_slot(struct slot * slot)
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
 
+        retval = pciehp_link_enable(ctrl);
+        if (retval)
+                ctrl_err(ctrl, "%s: Can not enable the link!\n", __func__);
+
         return retval;
 }
 
@@ -543,6 +620,14 @@ int pciehp_power_off_slot(struct slot * slot)
         u16 cmd_mask;
         int retval;
 
+        /* Disable the link at first */
+        pciehp_link_disable(ctrl);
+        /* wait the link is down */
+        if (ctrl->link_active_reporting)
+                pcie_wait_link_not_active(ctrl);
+        else
+                msleep(1000);
+
         slot_cmd = POWER_OFF;
         cmd_mask = PCI_EXP_SLTCTL_PCC;
         retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index a4031dfe938e..47d9dc06b109 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -141,7 +141,7 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                                 break;
                         }
                 }
-                pci_remove_bus_device(temp);
+                pci_stop_and_remove_bus_device(temp);
                 /*
                  * Ensure that no new Requests will be generated from
                  * the device.
diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index c56a9413e1af..1e117c2a3cad 100644
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -389,7 +389,7 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
         BUG_ON(!bus->self);
         pr_debug("PCI: Now removing bridge device %s\n", pci_name(bus->self));
         eeh_remove_bus_device(bus->self);
-        pci_remove_bus_device(bus->self);
+        pci_stop_and_remove_bus_device(bus->self);
 
         return 0;
 }
diff --git a/drivers/pci/hotplug/sgi_hotplug.c b/drivers/pci/hotplug/sgi_hotplug.c
index 72d507b6a2aa..de573113c102 100644
--- a/drivers/pci/hotplug/sgi_hotplug.c
+++ b/drivers/pci/hotplug/sgi_hotplug.c
@@ -554,7 +554,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                                              PCI_FUNC(func)));
                 if (dev) {
                         sn_bus_free_data(dev);
-                        pci_remove_bus_device(dev);
+                        pci_stop_and_remove_bus_device(dev);
                         pci_dev_put(dev);
                 }
         }
diff --git a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c
index a2ccfcd3c298..df7e4bfadae3 100644
--- a/drivers/pci/hotplug/shpchp_pci.c
+++ b/drivers/pci/hotplug/shpchp_pci.c
@@ -124,7 +124,7 @@ int shpchp_unconfigure_device(struct slot *p_slot)
                                 break;
                         }
                 }
-                pci_remove_bus_device(temp);
+                pci_stop_and_remove_bus_device(temp);
                 pci_dev_put(temp);
         }
         return rc;
diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index 0dab5ecf61bb..6554e1a0f634 100644
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -142,7 +142,7 @@ failed2:
 failed1:
         pci_dev_put(dev);
         mutex_lock(&iov->dev->sriov->lock);
-        pci_remove_bus_device(virtfn);
+        pci_stop_and_remove_bus_device(virtfn);
         virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
         mutex_unlock(&iov->dev->sriov->lock);
 
@@ -173,10 +173,16 @@ static void virtfn_remove(struct pci_dev *dev, int id, int reset)
 
         sprintf(buf, "virtfn%u", id);
         sysfs_remove_link(&dev->dev.kobj, buf);
-        sysfs_remove_link(&virtfn->dev.kobj, "physfn");
+        /*
+         * pci_stop_dev() could have been called for this virtfn already,
+         * so the directory for the virtfn may have been removed before.
+         * Double check to avoid spurious sysfs warnings.
+         */
+        if (virtfn->dev.kobj.sd)
+                sysfs_remove_link(&virtfn->dev.kobj, "physfn");
 
         mutex_lock(&iov->dev->sriov->lock);
-        pci_remove_bus_device(virtfn);
+        pci_stop_and_remove_bus_device(virtfn);
         virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
         mutex_unlock(&iov->dev->sriov->lock);
 
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 060fd22a1103..0f150f271c2a 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -277,40 +277,6 @@ static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
         return 0;
 }
 
-/**
- * acpi_dev_run_wake - Enable/disable wake-up for given device.
- * @phys_dev: Device to enable/disable the platform to wake-up the system for.
- * @enable: Whether enable or disable the wake-up functionality.
- *
- * Find the ACPI device object corresponding to @pci_dev and try to
- * enable/disable the GPE associated with it.
- */
-static int acpi_dev_run_wake(struct device *phys_dev, bool enable)
-{
-        struct acpi_device *dev;
-        acpi_handle handle;
-
-        if (!device_run_wake(phys_dev))
-                return -EINVAL;
-
-        handle = DEVICE_ACPI_HANDLE(phys_dev);
-        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) {
-                dev_dbg(phys_dev, "ACPI handle has no context in %s!\n",
-                        __func__);
-                return -ENODEV;
-        }
-
-        if (enable) {
-                acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0);
-                acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
-        } else {
-                acpi_disable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
-                acpi_disable_wakeup_device_power(dev);
-        }
-
-        return 0;
-}
-
 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
 {
         while (bus->parent) {
@@ -318,14 +284,14 @@ static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
 
                 if (bridge->pme_interrupt)
                         return;
-                if (!acpi_dev_run_wake(&bridge->dev, enable))
+                if (!acpi_pm_device_run_wake(&bridge->dev, enable))
                         return;
                 bus = bus->parent;
         }
 
         /* We have reached the root bus. */
         if (bus->bridge)
-                acpi_dev_run_wake(bus->bridge, enable);
+                acpi_pm_device_run_wake(bus->bridge, enable);
 }
 
 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
@@ -333,7 +299,7 @@ static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
         if (dev->pme_interrupt)
                 return 0;
 
-        if (!acpi_dev_run_wake(&dev->dev, enable))
+        if (!acpi_pm_device_run_wake(&dev->dev, enable))
                 return 0;
 
         acpi_pci_propagate_run_wake(dev->bus, enable);
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 3623d65f8b86..6b54b23b990b 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -72,9 +72,7 @@ int pci_add_dynid(struct pci_driver *drv,
         list_add_tail(&dynid->node, &drv->dynids.list);
         spin_unlock(&drv->dynids.lock);
 
-        get_driver(&drv->driver);
         retval = driver_attach(&drv->driver);
-        put_driver(&drv->driver);
 
         return retval;
 }
@@ -190,43 +188,34 @@ store_remove_id(struct device_driver *driver, const char *buf, size_t count)
 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 
 static int
-pci_create_newid_file(struct pci_driver *drv)
+pci_create_newid_files(struct pci_driver *drv)
 {
         int error = 0;
-        if (drv->probe != NULL)
-                error = driver_create_file(&drv->driver, &driver_attr_new_id);
-        return error;
-}
 
-static void pci_remove_newid_file(struct pci_driver *drv)
-{
-        driver_remove_file(&drv->driver, &driver_attr_new_id);
-}
-
-static int
-pci_create_removeid_file(struct pci_driver *drv)
-{
-        int error = 0;
-        if (drv->probe != NULL)
-                error = driver_create_file(&drv->driver,&driver_attr_remove_id);
+        if (drv->probe != NULL) {
+                error = driver_create_file(&drv->driver, &driver_attr_new_id);
+                if (error == 0) {
+                        error = driver_create_file(&drv->driver,
+                                        &driver_attr_remove_id);
+                        if (error)
+                                driver_remove_file(&drv->driver,
+                                                &driver_attr_new_id);
+                }
+        }
         return error;
 }
 
-static void pci_remove_removeid_file(struct pci_driver *drv)
+static void pci_remove_newid_files(struct pci_driver *drv)
 {
         driver_remove_file(&drv->driver, &driver_attr_remove_id);
+        driver_remove_file(&drv->driver, &driver_attr_new_id);
 }
 #else /* !CONFIG_HOTPLUG */
-static inline int pci_create_newid_file(struct pci_driver *drv)
-{
-        return 0;
-}
-static inline void pci_remove_newid_file(struct pci_driver *drv) {}
-static inline int pci_create_removeid_file(struct pci_driver *drv)
+static inline int pci_create_newid_files(struct pci_driver *drv)
 {
         return 0;
 }
-static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
+static inline void pci_remove_newid_files(struct pci_driver *drv) {}
 #endif
 
 /**
@@ -430,6 +419,16 @@ static void pci_device_shutdown(struct device *dev)
                 drv->shutdown(pci_dev);
         pci_msi_shutdown(pci_dev);
         pci_msix_shutdown(pci_dev);
+
+        /*
+         * Devices may be enabled to wake up by runtime PM, but they need not
+         * be supposed to wake up the system from its "power off" state (e.g.
+         * ACPI S5).  Therefore disable wakeup for all devices that aren't
+         * supposed to wake up the system at this point.  The state argument
+         * will be ignored by pci_enable_wake().
+         */
+        if (!device_may_wakeup(dev))
+                pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
 }
 
 #ifdef CONFIG_PM
@@ -1138,18 +1137,12 @@ int __pci_register_driver(struct pci_driver *drv, struct module *owner,
         if (error)
                 goto out;
 
-        error = pci_create_newid_file(drv);
+        error = pci_create_newid_files(drv);
         if (error)
                 goto out_newid;
-
-        error = pci_create_removeid_file(drv);
-        if (error)
-                goto out_removeid;
 out:
         return error;
 
-out_removeid:
-        pci_remove_newid_file(drv);
 out_newid:
         driver_unregister(&drv->driver);
         goto out;
@@ -1168,8 +1161,7 @@ out_newid:
 void
 pci_unregister_driver(struct pci_driver *drv)
 {
-        pci_remove_removeid_file(drv);
-        pci_remove_newid_file(drv);
+        pci_remove_newid_files(drv);
         driver_unregister(&drv->driver);
         pci_free_dynids(drv);
 }
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index a3cd8cad532a..a55e248618cd 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -330,7 +330,7 @@ static void remove_callback(struct device *dev)
         struct pci_dev *pdev = to_pci_dev(dev);
 
         mutex_lock(&pci_remove_rescan_mutex);
-        pci_remove_bus_device(pdev);
+        pci_stop_and_remove_bus_device(pdev);
         mutex_unlock(&pci_remove_rescan_mutex);
 }
 
@@ -366,7 +366,10 @@ dev_bus_rescan_store(struct device *dev, struct device_attribute *attr,
 
         if (val) {
                 mutex_lock(&pci_remove_rescan_mutex);
-                pci_rescan_bus(bus);
+                if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
+                        pci_rescan_bus_bridge_resize(bus->self);
+                else
+                        pci_rescan_bus(bus);
                 mutex_unlock(&pci_remove_rescan_mutex);
         }
         return count;
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index af295bb21d62..111569ccab43 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -94,6 +94,9 @@ u8 pci_cache_line_size;
  */
 unsigned int pcibios_max_latency = 255;
 
+/* If set, the PCIe ARI capability will not be used. */
+static bool pcie_ari_disabled;
+
 /**
  * pci_bus_max_busnr - returns maximum PCI bus number of given bus' children
  * @bus: pointer to PCI bus structure to search
@@ -825,6 +828,19 @@ EXPORT_SYMBOL(pci_choose_state);
 #define pcie_cap_has_sltctl2(type, flags)               \
                 ((flags & PCI_EXP_FLAGS_VERS) > 1)
 
+static struct pci_cap_saved_state *pci_find_saved_cap(
+        struct pci_dev *pci_dev, char cap)
+{
+        struct pci_cap_saved_state *tmp;
+        struct hlist_node *pos;
+
+        hlist_for_each_entry(tmp, pos, &pci_dev->saved_cap_space, next) {
+                if (tmp->cap.cap_nr == cap)
+                        return tmp;
+        }
+        return NULL;
+}
+
 static int pci_save_pcie_state(struct pci_dev *dev)
 {
         int pos, i = 0;
@@ -951,15 +967,59 @@ pci_save_state(struct pci_dev *dev)
         return 0;
 }
 
+static void pci_restore_config_dword(struct pci_dev *pdev, int offset,
+                                     u32 saved_val, int retry)
+{
+        u32 val;
+
+        pci_read_config_dword(pdev, offset, &val);
+        if (val == saved_val)
+                return;
+
+        for (;;) {
+                dev_dbg(&pdev->dev, "restoring config space at offset "
+                        "%#x (was %#x, writing %#x)\n", offset, val, saved_val);
+                pci_write_config_dword(pdev, offset, saved_val);
+                if (retry-- <= 0)
+                        return;
+
+                pci_read_config_dword(pdev, offset, &val);
+                if (val == saved_val)
+                        return;
+
+                mdelay(1);
+        }
+}
+
+static void pci_restore_config_space_range(struct pci_dev *pdev,
+                                           int start, int end, int retry)
+{
+        int index;
+
+        for (index = end; index >= start; index--)
+                pci_restore_config_dword(pdev, 4 * index,
+                                         pdev->saved_config_space[index],
+                                         retry);
+}
+
+static void pci_restore_config_space(struct pci_dev *pdev)
+{
+        if (pdev->hdr_type == PCI_HEADER_TYPE_NORMAL) {
+                pci_restore_config_space_range(pdev, 10, 15, 0);
+                /* Restore BARs before the command register. */
+                pci_restore_config_space_range(pdev, 4, 9, 10);
+                pci_restore_config_space_range(pdev, 0, 3, 0);
+        } else {
+                pci_restore_config_space_range(pdev, 0, 15, 0);
+        }
+}
+
 /** 
  * pci_restore_state - Restore the saved state of a PCI device
  * @dev: - PCI device that we're dealing with
  */
 void pci_restore_state(struct pci_dev *dev)
 {
-        int i;
-        u32 val;
-
         if (!dev->state_saved)
                 return;
 
@@ -967,20 +1027,8 @@ void pci_restore_state(struct pci_dev *dev)
         pci_restore_pcie_state(dev);
         pci_restore_ats_state(dev);
 
-        /*
-         * The Base Address register should be programmed before the command
-         * register(s)
-         */
-        for (i = 15; i >= 0; i--) {
-                pci_read_config_dword(dev, i * 4, &val);
-                if (val != dev->saved_config_space[i]) {
-                        dev_dbg(&dev->dev, "restoring config "
-                                "space at offset %#x (was %#x, writing %#x)\n",
-                                i, val, (int)dev->saved_config_space[i]);
-                        pci_write_config_dword(dev,i * 4,
-                                dev->saved_config_space[i]);
-                }
-        }
+        pci_restore_config_space(dev);
+
         pci_restore_pcix_state(dev);
         pci_restore_msi_state(dev);
         pci_restore_iov_state(dev);
@@ -1864,6 +1912,12 @@ void platform_pci_wakeup_init(struct pci_dev *dev)
         platform_pci_sleep_wake(dev, false);
 }
 
+static void pci_add_saved_cap(struct pci_dev *pci_dev,
+        struct pci_cap_saved_state *new_cap)
+{
+        hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
+}
+
 /**
  * pci_add_save_buffer - allocate buffer for saving given capability registers
  * @dev: the PCI device
@@ -1911,6 +1965,15 @@ void pci_allocate_cap_save_buffers(struct pci_dev *dev)
                         "unable to preallocate PCI-X save buffer\n");
 }
 
+void pci_free_cap_save_buffers(struct pci_dev *dev)
+{
+        struct pci_cap_saved_state *tmp;
+        struct hlist_node *pos, *n;
+
+        hlist_for_each_entry_safe(tmp, pos, n, &dev->saved_cap_space, next)
+                kfree(tmp);
+}
+
 /**
  * pci_enable_ari - enable ARI forwarding if hardware support it
  * @dev: the PCI device
@@ -1922,7 +1985,7 @@ void pci_enable_ari(struct pci_dev *dev)
         u16 flags, ctrl;
         struct pci_dev *bridge;
 
-        if (!pci_is_pcie(dev) || dev->devfn)
+        if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
                 return;
 
         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
@@ -3163,6 +3226,31 @@ int __pci_reset_function(struct pci_dev *dev)
 EXPORT_SYMBOL_GPL(__pci_reset_function);
 
 /**
+ * __pci_reset_function_locked - reset a PCI device function while holding
+ * the @dev mutex lock.
+ * @dev: PCI device to reset
+ *
+ * Some devices allow an individual function to be reset without affecting
+ * other functions in the same device.  The PCI device must be responsive
+ * to PCI config space in order to use this function.
+ *
+ * The device function is presumed to be unused and the caller is holding
+ * the device mutex lock when this function is called.
+ * Resetting the device will make the contents of PCI configuration space
+ * random, so any caller of this must be prepared to reinitialise the
+ * device including MSI, bus mastering, BARs, decoding IO and memory spaces,
+ * etc.
+ *
+ * Returns 0 if the device function was successfully reset or negative if the
+ * device doesn't support resetting a single function.
+ */
+int __pci_reset_function_locked(struct pci_dev *dev)
+{
+        return pci_dev_reset(dev, 1);
+}
+EXPORT_SYMBOL_GPL(__pci_reset_function_locked);
+
+/**
  * pci_probe_reset_function - check whether the device can be safely reset
  * @dev: PCI device to reset
  *
@@ -3636,6 +3724,68 @@ int pci_is_reassigndev(struct pci_dev *dev)
         return (pci_specified_resource_alignment(dev) != 0);
 }
 
+/*
+ * This function disables memory decoding and releases memory resources
+ * of the device specified by kernel's boot parameter 'pci=resource_alignment='.
+ * It also rounds up size to specified alignment.
+ * Later on, the kernel will assign page-aligned memory resource back
+ * to the device.
+ */
+void pci_reassigndev_resource_alignment(struct pci_dev *dev)
+{
+        int i;
+        struct resource *r;
+        resource_size_t align, size;
+        u16 command;
+
+        if (!pci_is_reassigndev(dev))
+                return;
+
+        if (dev->hdr_type == PCI_HEADER_TYPE_NORMAL &&
+            (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
+                dev_warn(&dev->dev,
+                        "Can't reassign resources to host bridge.\n");
+                return;
+        }
+
+        dev_info(&dev->dev,
+                "Disabling memory decoding and releasing memory resources.\n");
+        pci_read_config_word(dev, PCI_COMMAND, &command);
+        command &= ~PCI_COMMAND_MEMORY;
+        pci_write_config_word(dev, PCI_COMMAND, command);
+
+        align = pci_specified_resource_alignment(dev);
+        for (i = 0; i < PCI_BRIDGE_RESOURCES; i++) {
+                r = &dev->resource[i];
+                if (!(r->flags & IORESOURCE_MEM))
+                        continue;
+                size = resource_size(r);
+                if (size < align) {
+                        size = align;
+                        dev_info(&dev->dev,
+                                "Rounding up size of resource #%d to %#llx.\n",
+                                i, (unsigned long long)size);
+                }
+                r->end = size - 1;
+                r->start = 0;
+        }
+        /* Need to disable bridge's resource window,
+         * to enable the kernel to reassign new resource
+         * window later on.
+         */
+        if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE &&
+            (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
+                for (i = PCI_BRIDGE_RESOURCES; i < PCI_NUM_RESOURCES; i++) {
+                        r = &dev->resource[i];
+                        if (!(r->flags & IORESOURCE_MEM))
+                                continue;
+                        r->end = resource_size(r) - 1;
+                        r->start = 0;
+                }
+                pci_disable_bridge_window(dev);
+        }
+}
+
 ssize_t pci_set_resource_alignment_param(const char *buf, size_t count)
 {
         if (count > RESOURCE_ALIGNMENT_PARAM_SIZE - 1)
@@ -3714,10 +3864,14 @@ static int __init pci_setup(char *str)
                                 pci_no_msi();
                         } else if (!strcmp(str, "noaer")) {
                                 pci_no_aer();
+                        } else if (!strncmp(str, "realloc=", 8)) {
+                                pci_realloc_get_opt(str + 8);
                         } else if (!strncmp(str, "realloc", 7)) {
-                                pci_realloc();
+                                pci_realloc_get_opt("on");
                         } else if (!strcmp(str, "nodomains")) {
                                 pci_no_domains();
+                        } else if (!strncmp(str, "noari", 5)) {
+                                pcie_ari_disabled = true;
                         } else if (!strncmp(str, "cbiosize=", 9)) {
                                 pci_cardbus_io_size = memparse(str + 9, &str);
                         } else if (!strncmp(str, "cbmemsize=", 10)) {
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 1009a5e88e53..e4943479b234 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -73,6 +73,7 @@ extern int __pci_pme_wakeup(struct pci_dev *dev, void *ign);
 extern void pci_pm_init(struct pci_dev *dev);
 extern void platform_pci_wakeup_init(struct pci_dev *dev);
 extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
+void pci_free_cap_save_buffers(struct pci_dev *dev);
 
 static inline void pci_wakeup_event(struct pci_dev *dev)
 {
@@ -148,7 +149,7 @@ static inline void pci_no_msi(void) { }
 static inline void pci_msi_init_pci_dev(struct pci_dev *dev) { }
 #endif
 
-extern void pci_realloc(void);
+void pci_realloc_get_opt(char *);
 
 static inline int pci_no_d1d2(struct pci_dev *dev)
 {
@@ -207,6 +208,8 @@ enum pci_bar_type {
         pci_bar_mem64,          /* A 64-bit memory BAR */
 };
 
+bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *pl,
+                                int crs_timeout);
 extern int pci_setup_device(struct pci_dev *dev);
 extern int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                                 struct resource *res, unsigned int reg);
@@ -225,11 +228,8 @@ static inline int pci_ari_enabled(struct pci_bus *bus)
         return bus->self && bus->self->ari_enabled;
 }
 
-#ifdef CONFIG_PCI_QUIRKS
-extern int pci_is_reassigndev(struct pci_dev *dev);
-resource_size_t pci_specified_resource_alignment(struct pci_dev *dev);
+void pci_reassigndev_resource_alignment(struct pci_dev *dev);
 extern void pci_disable_bridge_window(struct pci_dev *dev);
-#endif
 
 /* Single Root I/O Virtualization */
 struct pci_sriov {
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index 72962cc92e0a..6c8bc5809787 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -55,6 +55,31 @@ config PCIEASPM_DEBUG
           This enables PCI Express ASPM debug support. It will add per-device
           interface to control ASPM.
 
+choice
+        prompt "Default ASPM policy"
+        default PCIEASPM_DEFAULT
+        depends on PCIEASPM
+
+config PCIEASPM_DEFAULT
+        bool "BIOS default"
+        depends on PCIEASPM
+        help
+          Use the BIOS defaults for PCI Express ASPM.
+
+config PCIEASPM_POWERSAVE
+        bool "Powersave"
+        depends on PCIEASPM
+        help
+          Enable PCI Express ASPM L0s and L1 where possible, even if the
+          BIOS did not.
+
+config PCIEASPM_PERFORMANCE
+        bool "Performance"
+        depends on PCIEASPM
+        help
+          Disable PCI Express ASPM L0s and L1, even if the BIOS enabled them.
+endchoice
+
 config PCIE_PME
         def_bool y
         depends on PCIEPORTBUS && PM_RUNTIME && EXPERIMENTAL && ACPI
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index 1cfbf228fbb1..b500840a143b 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -76,7 +76,15 @@ static LIST_HEAD(link_list);
 #define POLICY_DEFAULT 0        /* BIOS default setting */
 #define POLICY_PERFORMANCE 1    /* high performance */
 #define POLICY_POWERSAVE 2      /* high power saving */
+
+#ifdef CONFIG_PCIEASPM_PERFORMANCE
+static int aspm_policy = POLICY_PERFORMANCE;
+#elif defined CONFIG_PCIEASPM_POWERSAVE
+static int aspm_policy = POLICY_POWERSAVE;
+#else
 static int aspm_policy;
+#endif
+
 static const char *policy_str[] = {
         [POLICY_DEFAULT] = "default",
         [POLICY_PERFORMANCE] = "performance",
@@ -508,6 +516,16 @@ static int pcie_aspm_sanity_check(struct pci_dev *pdev)
                 pos = pci_pcie_cap(child);
                 if (!pos)
                         return -EINVAL;
+
+                /*
+                 * If ASPM is disabled then we're not going to change
+                 * the BIOS state. It's safe to continue even if it's a
+                 * pre-1.1 device
+                 */
+
+                if (aspm_disabled)
+                        continue;
+
                 /*
                  * Disable ASPM for pre-1.1 PCIe device, we follow MS to use
                  * RBER bit to determine if a function is 1.1 version device
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index bd00a01aef14..eea2ca2375e6 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -34,6 +34,18 @@ struct pci_dev;
 
 extern void pcie_clear_root_pme_status(struct pci_dev *dev);
 
+#ifdef CONFIG_HOTPLUG_PCI_PCIE
+extern bool pciehp_msi_disabled;
+
+static inline bool pciehp_no_msi(void)
+{
+        return pciehp_msi_disabled;
+}
+
+#else  /* !CONFIG_HOTPLUG_PCI_PCIE */
+static inline bool pciehp_no_msi(void) { return false; }
+#endif /* !CONFIG_HOTPLUG_PCI_PCIE */
+
 #ifdef CONFIG_PCIE_PME
 extern bool pcie_pme_msi_disabled;
 
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 595654a1a6a6..2f589a54f9bd 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -19,6 +19,17 @@
 #include "../pci.h"
 #include "portdrv.h"
 
+bool pciehp_msi_disabled;
+
+static int __init pciehp_setup(char *str)
+{
+        if (!strncmp(str, "nomsi", 5))
+                pciehp_msi_disabled = true;
+
+        return 1;
+}
+__setup("pcie_hp=", pciehp_setup);
+
 /**
  * release_pcie_device - free PCI Express port service device structure
  * @dev: Port service device to release
@@ -189,8 +200,9 @@ static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
 {
         int i, irq = -1;
 
-        /* We have to use INTx if MSI cannot be used for PCIe PME. */
-        if ((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) {
+        /* We have to use INTx if MSI cannot be used for PCIe PME or pciehp. */
+        if (((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) ||
+            ((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())) {
                 if (dev->pin)
                         irq = dev->irq;
                 goto no_msi;
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 71eac9cd724d..5e1ca3c58a7d 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -15,6 +15,8 @@
 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
 #define CARDBUS_RESERVE_BUSNR   3
 
+static LIST_HEAD(pci_host_bridges);
+
 /* Ugh.  Need to stop exporting this to modules. */
 LIST_HEAD(pci_root_buses);
 EXPORT_SYMBOL(pci_root_buses);
@@ -42,6 +44,82 @@ int no_pci_devices(void)
 }
 EXPORT_SYMBOL(no_pci_devices);
 
+static struct pci_host_bridge *pci_host_bridge(struct pci_dev *dev)
+{
+        struct pci_bus *bus;
+        struct pci_host_bridge *bridge;
+
+        bus = dev->bus;
+        while (bus->parent)
+                bus = bus->parent;
+
+        list_for_each_entry(bridge, &pci_host_bridges, list) {
+                if (bridge->bus == bus)
+                        return bridge;
+        }
+
+        return NULL;
+}
+
+static bool resource_contains(struct resource *res1, struct resource *res2)
+{
+        return res1->start <= res2->start && res1->end >= res2->end;
+}
+
+void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                             struct resource *res)
+{
+        struct pci_host_bridge *bridge = pci_host_bridge(dev);
+        struct pci_host_bridge_window *window;
+        resource_size_t offset = 0;
+
+        list_for_each_entry(window, &bridge->windows, list) {
+                if (resource_type(res) != resource_type(window->res))
+                        continue;
+
+                if (resource_contains(window->res, res)) {
+                        offset = window->offset;
+                        break;
+                }
+        }
+
+        region->start = res->start - offset;
+        region->end = res->end - offset;
+}
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+
+static bool region_contains(struct pci_bus_region *region1,
+                            struct pci_bus_region *region2)
+{
+        return region1->start <= region2->start && region1->end >= region2->end;
+}
+
+void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                             struct pci_bus_region *region)
+{
+        struct pci_host_bridge *bridge = pci_host_bridge(dev);
+        struct pci_host_bridge_window *window;
+        struct pci_bus_region bus_region;
+        resource_size_t offset = 0;
+
+        list_for_each_entry(window, &bridge->windows, list) {
+                if (resource_type(res) != resource_type(window->res))
+                        continue;
+
+                bus_region.start = window->res->start - window->offset;
+                bus_region.end = window->res->end - window->offset;
+
+                if (region_contains(&bus_region, region)) {
+                        offset = window->offset;
+                        break;
+                }
+        }
+
+        res->start = region->start + offset;
+        res->end = region->end + offset;
+}
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+
 /*
  * PCI Bus Class
  */
@@ -135,6 +213,7 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 {
         u32 l, sz, mask;
         u16 orig_cmd;
+        struct pci_bus_region region;
 
         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 
@@ -214,11 +293,13 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                         /* Address above 32-bit boundary; disable the BAR */
                         pci_write_config_dword(dev, pos, 0);
                         pci_write_config_dword(dev, pos + 4, 0);
-                        res->start = 0;
-                        res->end = sz64;
+                        region.start = 0;
+                        region.end = sz64;
+                        pcibios_bus_to_resource(dev, res, &region);
                 } else {
-                        res->start = l64;
-                        res->end = l64 + sz64;
+                        region.start = l64;
+                        region.end = l64 + sz64;
+                        pcibios_bus_to_resource(dev, res, &region);
                         dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
                                    pos, res);
                 }
@@ -228,8 +309,9 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                 if (!sz)
                         goto fail;
 
-                res->start = l;
-                res->end = l + sz;
+                region.start = l;
+                region.end = l + sz;
+                pcibios_bus_to_resource(dev, res, &region);
 
                 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
         }
@@ -266,7 +348,8 @@ static void __devinit pci_read_bridge_io(struct pci_bus *child)
         struct pci_dev *dev = child->self;
         u8 io_base_lo, io_limit_lo;
         unsigned long base, limit;
-        struct resource *res;
+        struct pci_bus_region region;
+        struct resource *res, res2;
 
         res = child->resource[0];
         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
@@ -284,10 +367,14 @@ static void __devinit pci_read_bridge_io(struct pci_bus *child)
 
         if (base && base <= limit) {
                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
+                res2.flags = res->flags;
+                region.start = base;
+                region.end = limit + 0xfff;
+                pcibios_bus_to_resource(dev, &res2, &region);
                 if (!res->start)
-                        res->start = base;
+                        res->start = res2.start;
                 if (!res->end)
-                        res->end = limit + 0xfff;
+                        res->end = res2.end;
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
         }
 }
@@ -297,6 +384,7 @@ static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
         struct pci_dev *dev = child->self;
         u16 mem_base_lo, mem_limit_lo;
         unsigned long base, limit;
+        struct pci_bus_region region;
         struct resource *res;
 
         res = child->resource[1];
@@ -306,8 +394,9 @@ static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
         if (base && base <= limit) {
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
-                res->start = base;
-                res->end = limit + 0xfffff;
+                region.start = base;
+                region.end = limit + 0xfffff;
+                pcibios_bus_to_resource(dev, res, &region);
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
         }
 }
@@ -317,6 +406,7 @@ static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
         struct pci_dev *dev = child->self;
         u16 mem_base_lo, mem_limit_lo;
         unsigned long base, limit;
+        struct pci_bus_region region;
         struct resource *res;
 
         res = child->resource[2];
@@ -353,8 +443,9 @@ static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
                         res->flags |= IORESOURCE_MEM_64;
-                res->start = base;
-                res->end = limit + 0xfffff;
+                region.start = base;
+                region.end = limit + 0xfffff;
+                pcibios_bus_to_resource(dev, res, &region);
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
         }
 }
@@ -900,6 +991,8 @@ int pci_setup_device(struct pci_dev *dev)
         u8 hdr_type;
         struct pci_slot *slot;
         int pos = 0;
+        struct pci_bus_region region;
+        struct resource *res;
 
         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
                 return -EIO;
@@ -926,12 +1019,10 @@ int pci_setup_device(struct pci_dev *dev)
 
         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
         dev->revision = class & 0xff;
-        class >>= 8;                                /* upper 3 bytes */
-        dev->class = class;
-        class >>= 8;
+        dev->class = class >> 8;                    /* upper 3 bytes */
 
-        dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %d class %#08x\n",
-                   dev->vendor, dev->device, dev->hdr_type, class);
+        dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
+                   dev->vendor, dev->device, dev->hdr_type, dev->class);
 
         /* need to have dev->class ready */
         dev->cfg_size = pci_cfg_space_size(dev);
@@ -963,20 +1054,28 @@ int pci_setup_device(struct pci_dev *dev)
                         u8 progif;
                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
                         if ((progif & 1) == 0) {
-                                dev->resource[0].start = 0x1F0;
-                                dev->resource[0].end = 0x1F7;
-                                dev->resource[0].flags = LEGACY_IO_RESOURCE;
-                                dev->resource[1].start = 0x3F6;
-                                dev->resource[1].end = 0x3F6;
-                                dev->resource[1].flags = LEGACY_IO_RESOURCE;
+                                region.start = 0x1F0;
+                                region.end = 0x1F7;
+                                res = &dev->resource[0];
+                                res->flags = LEGACY_IO_RESOURCE;
+                                pcibios_bus_to_resource(dev, res, &region);
+                                region.start = 0x3F6;
+                                region.end = 0x3F6;
+                                res = &dev->resource[1];
+                                res->flags = LEGACY_IO_RESOURCE;
+                                pcibios_bus_to_resource(dev, res, &region);
                         }
                         if ((progif & 4) == 0) {
-                                dev->resource[2].start = 0x170;
-                                dev->resource[2].end = 0x177;
-                                dev->resource[2].flags = LEGACY_IO_RESOURCE;
-                                dev->resource[3].start = 0x376;
-                                dev->resource[3].end = 0x376;
-                                dev->resource[3].flags = LEGACY_IO_RESOURCE;
+                                region.start = 0x170;
+                                region.end = 0x177;
+                                res = &dev->resource[2];
+                                res->flags = LEGACY_IO_RESOURCE;
+                                pcibios_bus_to_resource(dev, res, &region);
+                                region.start = 0x376;
+                                region.end = 0x376;
+                                res = &dev->resource[3];
+                                res->flags = LEGACY_IO_RESOURCE;
+                                pcibios_bus_to_resource(dev, res, &region);
                         }
                 }
                 break;
@@ -1013,8 +1112,8 @@ int pci_setup_device(struct pci_dev *dev)
                 return -EIO;
 
         bad:
-                dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
-                        "type %02x)\n", class, dev->hdr_type);
+                dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
+                        "type %02x)\n", dev->class, dev->hdr_type);
                 dev->class = PCI_CLASS_NOT_DEFINED;
         }
 
@@ -1026,6 +1125,7 @@ static void pci_release_capabilities(struct pci_dev *dev)
 {
         pci_vpd_release(dev);
         pci_iov_release(dev);
+        pci_free_cap_save_buffers(dev);
 }
 
 /**
@@ -1118,40 +1218,54 @@ struct pci_dev *alloc_pci_dev(void)
 }
 EXPORT_SYMBOL(alloc_pci_dev);
 
-/*
- * Read the config data for a PCI device, sanity-check it
- * and fill in the dev structure...
- */
-static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
+bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
+                                 int crs_timeout)
 {
-        struct pci_dev *dev;
-        u32 l;
         int delay = 1;
 
-        if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
-                return NULL;
+        if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
+                return false;
 
         /* some broken boards return 0 or ~0 if a slot is empty: */
-        if (l == 0xffffffff || l == 0x00000000 ||
-            l == 0x0000ffff || l == 0xffff0000)
-                return NULL;
+        if (*l == 0xffffffff || *l == 0x00000000 ||
+            *l == 0x0000ffff || *l == 0xffff0000)
+                return false;
 
         /* Configuration request Retry Status */
-        while (l == 0xffff0001) {
+        while (*l == 0xffff0001) {
+                if (!crs_timeout)
+                        return false;
+
                 msleep(delay);
                 delay *= 2;
-                if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
-                        return NULL;
+                if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
+                        return false;
                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
-                if (delay > 60 * 1000) {
+                if (delay > crs_timeout) {
                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
                                         "responding\n", pci_domain_nr(bus),
                                         bus->number, PCI_SLOT(devfn),
                                         PCI_FUNC(devfn));
-                        return NULL;
+                        return false;
                 }
         }
 
+        return true;
+}
+EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
+
+/*
+ * Read the config data for a PCI device, sanity-check it
+ * and fill in the dev structure...
+ */
+static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
+{
+        struct pci_dev *dev;
+        u32 l;
+
+        if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
+                return NULL;
+
         dev = alloc_pci_dev();
         if (!dev)
                 return NULL;
@@ -1212,6 +1326,9 @@ void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
         /* Fix up broken headers */
         pci_fixup_device(pci_fixup_header, dev);
 
+        /* moved out from quirk header fixup code */
+        pci_reassigndev_resource_alignment(dev);
+
         /* Clear the state_saved flag. */
         dev->state_saved = false;
 
@@ -1530,21 +1647,27 @@ unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
 {
-        int error, i;
+        int error;
+        struct pci_host_bridge *bridge;
         struct pci_bus *b, *b2;
         struct device *dev;
-        struct pci_bus_resource *bus_res, *n;
+        struct pci_host_bridge_window *window, *n;
         struct resource *res;
+        resource_size_t offset;
+        char bus_addr[64];
+        char *fmt;
+
+        bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
+        if (!bridge)
+                return NULL;
 
         b = pci_alloc_bus();
         if (!b)
-                return NULL;
+                goto err_bus;
 
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (!dev) {
-                kfree(b);
-                return NULL;
-        }
+        if (!dev)
+                goto err_dev;
 
         b->sysdata = sysdata;
         b->ops = ops;
@@ -1556,10 +1679,6 @@ struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
                 goto err_out;
         }
 
-        down_write(&pci_bus_sem);
-        list_add_tail(&b->node, &pci_root_buses);
-        up_write(&pci_bus_sem);
-
         dev->parent = parent;
         dev->release = pci_release_bus_bridge_dev;
         dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
@@ -1585,31 +1704,53 @@ struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
 
         b->number = b->secondary = bus;
 
-        /* Add initial resources to the bus */
-        list_for_each_entry_safe(bus_res, n, resources, list)
-                list_move_tail(&bus_res->list, &b->resources);
+        bridge->bus = b;
+        INIT_LIST_HEAD(&bridge->windows);
 
         if (parent)
                 dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
         else
                 printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));
 
-        pci_bus_for_each_resource(b, res, i) {
-                if (res)
-                        dev_info(&b->dev, "root bus resource %pR\n", res);
+        /* Add initial resources to the bus */
+        list_for_each_entry_safe(window, n, resources, list) {
+                list_move_tail(&window->list, &bridge->windows);
+                res = window->res;
+                offset = window->offset;
+                pci_bus_add_resource(b, res, 0);
+                if (offset) {
+                        if (resource_type(res) == IORESOURCE_IO)
+                                fmt = " (bus address [%#06llx-%#06llx])";
+                        else
+                                fmt = " (bus address [%#010llx-%#010llx])";
+                        snprintf(bus_addr, sizeof(bus_addr), fmt,
+                                 (unsigned long long) (res->start - offset),
+                                 (unsigned long long) (res->end - offset));
+                } else
+                        bus_addr[0] = '\0';
+                dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
         }
 
+        down_write(&pci_bus_sem);
+        list_add_tail(&bridge->list, &pci_host_bridges);
+        list_add_tail(&b->node, &pci_root_buses);
+        up_write(&pci_bus_sem);
+
         return b;
 
 class_dev_reg_err:
         device_unregister(dev);
 dev_reg_err:
         down_write(&pci_bus_sem);
+        list_del(&bridge->list);
         list_del(&b->node);
         up_write(&pci_bus_sem);
 err_out:
         kfree(dev);
+err_dev:
         kfree(b);
+err_bus:
+        kfree(bridge);
         return NULL;
 }
 
@@ -1667,36 +1808,29 @@ EXPORT_SYMBOL(pci_scan_bus);
 
 #ifdef CONFIG_HOTPLUG
 /**
- * pci_rescan_bus - scan a PCI bus for devices.
- * @bus: PCI bus to scan
+ * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
+ * @bridge: PCI bridge for the bus to scan
  *
- * Scan a PCI bus and child buses for new devices, adds them,
- * and enables them.
+ * Scan a PCI bus and child buses for new devices, add them,
+ * and enable them, resizing bridge mmio/io resource if necessary
+ * and possible.  The caller must ensure the child devices are already
+ * removed for resizing to occur.
  *
  * Returns the max number of subordinate bus discovered.
  */
-unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
+unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
 {
         unsigned int max;
-        struct pci_dev *dev;
+        struct pci_bus *bus = bridge->subordinate;
 
         max = pci_scan_child_bus(bus);
 
-        down_read(&pci_bus_sem);
-        list_for_each_entry(dev, &bus->devices, bus_list)
-                if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
-                    dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
-                        if (dev->subordinate)
-                                pci_bus_size_bridges(dev->subordinate);
-        up_read(&pci_bus_sem);
+        pci_assign_unassigned_bridge_resources(bridge);
 
-        pci_bus_assign_resources(bus);
-        pci_enable_bridges(bus);
         pci_bus_add_devices(bus);
 
         return max;
 }
-EXPORT_SYMBOL_GPL(pci_rescan_bus);
 
 EXPORT_SYMBOL(pci_add_new_bus);
 EXPORT_SYMBOL(pci_scan_slot);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 64765474676f..4bf71028556b 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -26,73 +26,12 @@
 #include <linux/dmi.h>
 #include <linux/pci-aspm.h>
 #include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/ktime.h>
 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
 /*
- * This quirk function disables memory decoding and releases memory resources
- * of the device specified by kernel's boot parameter 'pci=resource_alignment='.
- * It also rounds up size to specified alignment.
- * Later on, the kernel will assign page-aligned memory resource back
- * to the device.
- */
-static void __devinit quirk_resource_alignment(struct pci_dev *dev)
-{
-        int i;
-        struct resource *r;
-        resource_size_t align, size;
-        u16 command;
-
-        if (!pci_is_reassigndev(dev))
-                return;
-
-        if (dev->hdr_type == PCI_HEADER_TYPE_NORMAL &&
-            (dev->class >> 8) == PCI_CLASS_BRIDGE_HOST) {
-                dev_warn(&dev->dev,
-                        "Can't reassign resources to host bridge.\n");
-                return;
-        }
-
-        dev_info(&dev->dev,
-                "Disabling memory decoding and releasing memory resources.\n");
-        pci_read_config_word(dev, PCI_COMMAND, &command);
-        command &= ~PCI_COMMAND_MEMORY;
-        pci_write_config_word(dev, PCI_COMMAND, command);
-
-        align = pci_specified_resource_alignment(dev);
-        for (i=0; i < PCI_BRIDGE_RESOURCES; i++) {
-                r = &dev->resource[i];
-                if (!(r->flags & IORESOURCE_MEM))
-                        continue;
-                size = resource_size(r);
-                if (size < align) {
-                        size = align;
-                        dev_info(&dev->dev,
-                                "Rounding up size of resource #%d to %#llx.\n",
-                                i, (unsigned long long)size);
-                }
-                r->end = size - 1;
-                r->start = 0;
-        }
-        /* Need to disable bridge's resource window,
-         * to enable the kernel to reassign new resource
-         * window later on.
-         */
-        if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE &&
-            (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
-                for (i = PCI_BRIDGE_RESOURCES; i < PCI_NUM_RESOURCES; i++) {
-                        r = &dev->resource[i];
-                        if (!(r->flags & IORESOURCE_MEM))
-                                continue;
-                        r->end = resource_size(r) - 1;
-                        r->start = 0;
-                }
-                pci_disable_bridge_window(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,
@@ -100,10 +39,10 @@ DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, quirk_resource_alignment);
  */
 static void __devinit quirk_mmio_always_on(struct pci_dev *dev)
 {
-        if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
-                dev->mmio_always_on = 1;
+        dev->mmio_always_on = 1;
 }
-DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, quirk_mmio_always_on);
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_ANY_ID, PCI_ANY_ID,
+                                PCI_CLASS_BRIDGE_HOST, 8, quirk_mmio_always_on);
 
 /* The Mellanox Tavor device gives false positive parity errors
  * Mark this device with a broken_parity_status, to allow
@@ -1002,12 +941,12 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA,	PCI_DEVICE_ID_VIA_82C597_0,	quirk_vt
  */
 static void quirk_cardbus_legacy(struct pci_dev *dev)
 {
-        if ((PCI_CLASS_BRIDGE_CARDBUS << 8) ^ dev->class)
-                return;
         pci_write_config_dword(dev, PCI_CB_LEGACY_MODE_BASE, 0);
 }
-DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, quirk_cardbus_legacy);
-DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_ANY_ID, PCI_ANY_ID, quirk_cardbus_legacy);
+DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_ANY_ID, PCI_ANY_ID,
+                        PCI_CLASS_BRIDGE_CARDBUS, 8, quirk_cardbus_legacy);
+DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(PCI_ANY_ID, PCI_ANY_ID,
+                        PCI_CLASS_BRIDGE_CARDBUS, 8, quirk_cardbus_legacy);
 
 /*
  * Following the PCI ordering rules is optional on the AMD762. I'm not
@@ -1164,17 +1103,20 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_10, qui
 
 static void __devinit quirk_no_ata_d3(struct pci_dev *pdev)
 {
-        /* Quirk the legacy ATA devices only. The AHCI ones are ok */
-        if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
-                pdev->dev_flags |= PCI_DEV_FLAGS_NO_D3;
+        pdev->dev_flags |= PCI_DEV_FLAGS_NO_D3;
 }
-DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_SERVERWORKS, PCI_ANY_ID, quirk_no_ata_d3);
-DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_ATI, PCI_ANY_ID, quirk_no_ata_d3);
+/* Quirk the legacy ATA devices only. The AHCI ones are ok */
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_SERVERWORKS, PCI_ANY_ID,
+                                PCI_CLASS_STORAGE_IDE, 8, quirk_no_ata_d3);
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_ATI, PCI_ANY_ID,
+                                PCI_CLASS_STORAGE_IDE, 8, quirk_no_ata_d3);
 /* ALi loses some register settings that we cannot then restore */
-DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_AL, PCI_ANY_ID, quirk_no_ata_d3);
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_AL, PCI_ANY_ID,
+                                PCI_CLASS_STORAGE_IDE, 8, quirk_no_ata_d3);
 /* VIA comes back fine but we need to keep it alive or ACPI GTM failures
    occur when mode detecting */
-DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_VIA, PCI_ANY_ID, quirk_no_ata_d3);
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_VIA, PCI_ANY_ID,
+                                PCI_CLASS_STORAGE_IDE, 8, quirk_no_ata_d3);
 
 /* This was originally an Alpha specific thing, but it really fits here.
  * The i82375 PCI/EISA bridge appears as non-classified. Fix that.
@@ -1873,8 +1815,7 @@ static void __devinit quirk_netmos(struct pci_dev *dev)
         case PCI_DEVICE_ID_NETMOS_9745:
         case PCI_DEVICE_ID_NETMOS_9845:
         case PCI_DEVICE_ID_NETMOS_9855:
-                if ((dev->class >> 8) == PCI_CLASS_COMMUNICATION_SERIAL &&
-                    num_parallel) {
+                if (num_parallel) {
                         dev_info(&dev->dev, "Netmos %04x (%u parallel, "
                                 "%u serial); changing class SERIAL to OTHER "
                                 "(use parport_serial)\n",
@@ -1884,7 +1825,8 @@ static void __devinit quirk_netmos(struct pci_dev *dev)
                 }
         }
 }
-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NETMOS, PCI_ANY_ID, quirk_netmos);
+DECLARE_PCI_FIXUP_CLASS_HEADER(PCI_VENDOR_ID_NETMOS, PCI_ANY_ID,
+                         PCI_CLASS_COMMUNICATION_SERIAL, 8, quirk_netmos);
 
 static void __devinit quirk_e100_interrupt(struct pci_dev *dev)
 {
@@ -1952,7 +1894,8 @@ static void __devinit quirk_e100_interrupt(struct pci_dev *dev)
 
         iounmap(csr);
 }
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_ANY_ID, quirk_e100_interrupt);
+DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
+                        PCI_CLASS_NETWORK_ETHERNET, 8, quirk_e100_interrupt);
 
 /*
  * The 82575 and 82598 may experience data corruption issues when transitioning
@@ -2161,6 +2104,24 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_BROADCOM,
                         PCI_DEVICE_ID_NX2_5709S,
                         quirk_brcm_570x_limit_vpd);
 
+static void __devinit quirk_brcm_5719_limit_mrrs(struct pci_dev *dev)
+{
+        u32 rev;
+
+        pci_read_config_dword(dev, 0xf4, &rev);
+
+        /* Only CAP the MRRS if the device is a 5719 A0 */
+        if (rev == 0x05719000) {
+                int readrq = pcie_get_readrq(dev);
+                if (readrq > 2048)
+                        pcie_set_readrq(dev, 2048);
+        }
+}
+
+DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_TIGON3_5719,
+                         quirk_brcm_5719_limit_mrrs);
+
 /* Originally in EDAC sources for i82875P:
  * Intel tells BIOS developers to hide device 6 which
  * configures the overflow device access containing
@@ -2816,12 +2777,11 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x3c28, vtd_mask_spec_errors);
 static void __devinit fixup_ti816x_class(struct pci_dev* dev)
 {
         /* TI 816x devices do not have class code set when in PCIe boot mode */
-        if (dev->class == PCI_CLASS_NOT_DEFINED) {
-                dev_info(&dev->dev, "Setting PCI class for 816x PCIe device\n");
-                dev->class = PCI_CLASS_MULTIMEDIA_VIDEO;
-        }
+        dev_info(&dev->dev, "Setting PCI class for 816x PCIe device\n");
+        dev->class = PCI_CLASS_MULTIMEDIA_VIDEO;
 }
-DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_TI, 0xb800, fixup_ti816x_class);
+DECLARE_PCI_FIXUP_CLASS_EARLY(PCI_VENDOR_ID_TI, 0xb800,
+                                 PCI_CLASS_NOT_DEFINED, 0, fixup_ti816x_class);
 
 /* Some PCIe devices do not work reliably with the claimed maximum
  * payload size supported.
@@ -2906,17 +2866,73 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x65f8, quirk_intel_mc_errata);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x65f9, quirk_intel_mc_errata);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x65fa, quirk_intel_mc_errata);
 
+
+static void do_one_fixup_debug(void (*fn)(struct pci_dev *dev), struct pci_dev *dev)
+{
+        ktime_t calltime, delta, rettime;
+        unsigned long long duration;
+
+        printk(KERN_DEBUG "calling  %pF @ %i for %s\n",
+                        fn, task_pid_nr(current), dev_name(&dev->dev));
+        calltime = ktime_get();
+        fn(dev);
+        rettime = ktime_get();
+        delta = ktime_sub(rettime, calltime);
+        duration = (unsigned long long) ktime_to_ns(delta) >> 10;
+        printk(KERN_DEBUG "pci fixup %pF returned after %lld usecs for %s\n",
+                        fn, duration, dev_name(&dev->dev));
+}
+
+/*
+ * Some BIOS implementations leave the Intel GPU interrupts enabled,
+ * even though no one is handling them (f.e. i915 driver is never loaded).
+ * Additionally the interrupt destination is not set up properly
+ * and the interrupt ends up -somewhere-.
+ *
+ * These spurious interrupts are "sticky" and the kernel disables
+ * the (shared) interrupt line after 100.000+ generated interrupts.
+ *
+ * Fix it by disabling the still enabled interrupts.
+ * This resolves crashes often seen on monitor unplug.
+ */
+#define I915_DEIER_REG 0x4400c
+static void __devinit disable_igfx_irq(struct pci_dev *dev)
+{
+        void __iomem *regs = pci_iomap(dev, 0, 0);
+        if (regs == NULL) {
+                dev_warn(&dev->dev, "igfx quirk: Can't iomap PCI device\n");
+                return;
+        }
+
+        /* Check if any interrupt line is still enabled */
+        if (readl(regs + I915_DEIER_REG) != 0) {
+                dev_warn(&dev->dev, "BIOS left Intel GPU interrupts enabled; "
+                        "disabling\n");
+
+                writel(0, regs + I915_DEIER_REG);
+        }
+
+        pci_iounmap(dev, regs);
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0102, disable_igfx_irq);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x010a, disable_igfx_irq);
+
 static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
                           struct pci_fixup *end)
 {
-        while (f < end) {
-                if ((f->vendor == dev->vendor || f->vendor == (u16) PCI_ANY_ID) &&
-                    (f->device == dev->device || f->device == (u16) PCI_ANY_ID)) {
+        for (; f < end; f++)
+                if ((f->class == (u32) (dev->class >> f->class_shift) ||
+                     f->class == (u32) PCI_ANY_ID) &&
+                    (f->vendor == dev->vendor ||
+                     f->vendor == (u16) PCI_ANY_ID) &&
+                    (f->device == dev->device ||
+                     f->device == (u16) PCI_ANY_ID)) {
                         dev_dbg(&dev->dev, "calling %pF\n", f->hook);
-                        f->hook(dev);
+                        if (initcall_debug)
+                                do_one_fixup_debug(f->hook, dev);
+                        else
+                                f->hook(dev);
                 }
-                f++;
-        }
 }
 
 extern struct pci_fixup __start_pci_fixups_early[];
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index ef8b18c48f26..fd77e2bde2e8 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -79,7 +79,7 @@ EXPORT_SYMBOL(pci_remove_bus);
 
 static void __pci_remove_behind_bridge(struct pci_dev *dev);
 /**
- * pci_remove_bus_device - remove a PCI device and any children
+ * pci_stop_and_remove_bus_device - remove a PCI device and any children
  * @dev: the device to remove
  *
  * Remove a PCI device from the device lists, informing the drivers
@@ -90,7 +90,7 @@ static void __pci_remove_behind_bridge(struct pci_dev *dev);
  * device lists, remove the /proc entry, and notify userspace
  * (/sbin/hotplug).
  */
-static void __pci_remove_bus_device(struct pci_dev *dev)
+void __pci_remove_bus_device(struct pci_dev *dev)
 {
         if (dev->subordinate) {
                 struct pci_bus *b = dev->subordinate;
@@ -102,7 +102,9 @@ static void __pci_remove_bus_device(struct pci_dev *dev)
 
         pci_destroy_dev(dev);
 }
-void pci_remove_bus_device(struct pci_dev *dev)
+EXPORT_SYMBOL(__pci_remove_bus_device);
+
+void pci_stop_and_remove_bus_device(struct pci_dev *dev)
 {
         pci_stop_bus_device(dev);
         __pci_remove_bus_device(dev);
@@ -127,14 +129,15 @@ static void pci_stop_behind_bridge(struct pci_dev *dev)
 }
 
 /**
- * pci_remove_behind_bridge - remove all devices behind a PCI bridge
+ * pci_stop_and_remove_behind_bridge - stop and remove all devices behind
+ *                                       a PCI bridge
  * @dev: PCI bridge device
  *
  * Remove all devices on the bus, except for the parent bridge.
  * This also removes any child buses, and any devices they may
  * contain in a depth-first manner.
  */
-void pci_remove_behind_bridge(struct pci_dev *dev)
+void pci_stop_and_remove_behind_bridge(struct pci_dev *dev)
 {
         pci_stop_behind_bridge(dev);
         __pci_remove_behind_bridge(dev);
@@ -144,7 +147,15 @@ static void pci_stop_bus_devices(struct pci_bus *bus)
 {
         struct list_head *l, *n;
 
-        list_for_each_safe(l, n, &bus->devices) {
+        /*
+         * VFs could be removed by pci_stop_and_remove_bus_device() in the
+         *  pci_stop_bus_devices() code path for PF.
+         *  aka, bus->devices get updated in the process.
+         * but VFs are inserted after PFs when SRIOV is enabled for PF,
+         * We can iterate the list backwards to get prev valid PF instead
+         *  of removed VF.
+         */
+        list_for_each_prev_safe(l, n, &bus->devices) {
                 struct pci_dev *dev = pci_dev_b(l);
                 pci_stop_bus_device(dev);
         }
@@ -166,6 +177,6 @@ void pci_stop_bus_device(struct pci_dev *dev)
         pci_stop_dev(dev);
 }
 
-EXPORT_SYMBOL(pci_remove_bus_device);
-EXPORT_SYMBOL(pci_remove_behind_bridge);
+EXPORT_SYMBOL(pci_stop_and_remove_bus_device);
+EXPORT_SYMBOL(pci_stop_and_remove_behind_bridge);
 EXPORT_SYMBOL_GPL(pci_stop_bus_device);
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 86b69f85f900..8fa2d4be88de 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -25,10 +25,13 @@
 #include <linux/ioport.h>
 #include <linux/cache.h>
 #include <linux/slab.h>
+#include <asm-generic/pci-bridge.h>
 #include "pci.h"
 
-struct resource_list_x {
-        struct resource_list_x *next;
+unsigned int pci_flags;
+
+struct pci_dev_resource {
+        struct list_head list;
         struct resource *res;
         struct pci_dev *dev;
         resource_size_t start;
@@ -38,21 +41,14 @@ struct resource_list_x {
         unsigned long flags;
 };
 
-#define free_list(type, head) do {                      \
-        struct type *list, *tmp;                        \
-        for (list = (head)->next; list;) {              \
-                tmp = list;                             \
-                list = list->next;                      \
-                kfree(tmp);                             \
-        }                                               \
-        (head)->next = NULL;                            \
-} while (0)
-
-int pci_realloc_enable = 0;
-#define pci_realloc_enabled() pci_realloc_enable
-void pci_realloc(void)
+static void free_list(struct list_head *head)
 {
-        pci_realloc_enable = 1;
+        struct pci_dev_resource *dev_res, *tmp;
+
+        list_for_each_entry_safe(dev_res, tmp, head, list) {
+                list_del(&dev_res->list);
+                kfree(dev_res);
+        }
 }
 
 /**
@@ -64,21 +60,18 @@ void pci_realloc(void)
  * @add_size:   additional size to be optionally added
  *              to the resource
  */
-static void add_to_list(struct resource_list_x *head,
+static int add_to_list(struct list_head *head,
                  struct pci_dev *dev, struct resource *res,
                  resource_size_t add_size, resource_size_t min_align)
 {
-        struct resource_list_x *list = head;
-        struct resource_list_x *ln = list->next;
-        struct resource_list_x *tmp;
+        struct pci_dev_resource *tmp;
 
-        tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
+        tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
         if (!tmp) {
                 pr_warning("add_to_list: kmalloc() failed!\n");
-                return;
+                return -ENOMEM;
         }
 
-        tmp->next = ln;
         tmp->res = res;
         tmp->dev = dev;
         tmp->start = res->start;
@@ -86,19 +79,100 @@ static void add_to_list(struct resource_list_x *head,
         tmp->flags = res->flags;
         tmp->add_size = add_size;
         tmp->min_align = min_align;
-        list->next = tmp;
+
+        list_add(&tmp->list, head);
+
+        return 0;
 }
 
-static void add_to_failed_list(struct resource_list_x *head,
-                                struct pci_dev *dev, struct resource *res)
+static void remove_from_list(struct list_head *head,
+                                 struct resource *res)
 {
-        add_to_list(head, dev, res,
-                        0 /* dont care */,
-                        0 /* dont care */);
+        struct pci_dev_resource *dev_res, *tmp;
+
+        list_for_each_entry_safe(dev_res, tmp, head, list) {
+                if (dev_res->res == res) {
+                        list_del(&dev_res->list);
+                        kfree(dev_res);
+                        break;
+                }
+        }
+}
+
+static resource_size_t get_res_add_size(struct list_head *head,
+                                        struct resource *res)
+{
+        struct pci_dev_resource *dev_res;
+
+        list_for_each_entry(dev_res, head, list) {
+                if (dev_res->res == res) {
+                        int idx = res - &dev_res->dev->resource[0];
+
+                        dev_printk(KERN_DEBUG, &dev_res->dev->dev,
+                                 "res[%d]=%pR get_res_add_size add_size %llx\n",
+                                 idx, dev_res->res,
+                                 (unsigned long long)dev_res->add_size);
+
+                        return dev_res->add_size;
+                }
+        }
+
+        return 0;
+}
+
+/* Sort resources by alignment */
+static void pdev_sort_resources(struct pci_dev *dev, struct list_head *head)
+{
+        int i;
+
+        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
+                struct resource *r;
+                struct pci_dev_resource *dev_res, *tmp;
+                resource_size_t r_align;
+                struct list_head *n;
+
+                r = &dev->resource[i];
+
+                if (r->flags & IORESOURCE_PCI_FIXED)
+                        continue;
+
+                if (!(r->flags) || r->parent)
+                        continue;
+
+                r_align = pci_resource_alignment(dev, r);
+                if (!r_align) {
+                        dev_warn(&dev->dev, "BAR %d: %pR has bogus alignment\n",
+                                 i, r);
+                        continue;
+                }
+
+                tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
+                if (!tmp)
+                        panic("pdev_sort_resources(): "
+                              "kmalloc() failed!\n");
+                tmp->res = r;
+                tmp->dev = dev;
+
+                /* fallback is smallest one or list is empty*/
+                n = head;
+                list_for_each_entry(dev_res, head, list) {
+                        resource_size_t align;
+
+                        align = pci_resource_alignment(dev_res->dev,
+                                                         dev_res->res);
+
+                        if (r_align > align) {
+                                n = &dev_res->list;
+                                break;
+                        }
+                }
+                /* Insert it just before n*/
+                list_add_tail(&tmp->list, n);
+        }
 }
 
 static void __dev_sort_resources(struct pci_dev *dev,
-                                 struct resource_list *head)
+                                 struct list_head *head)
 {
         u16 class = dev->class >> 8;
 
@@ -136,49 +210,54 @@ static inline void reset_resource(struct resource *res)
  * additional resources for the element, provided the element
  * is in the head list.
  */
-static void reassign_resources_sorted(struct resource_list_x *realloc_head,
-                struct resource_list *head)
+static void reassign_resources_sorted(struct list_head *realloc_head,
+                struct list_head *head)
 {
         struct resource *res;
-        struct resource_list_x *list, *tmp, *prev;
-        struct resource_list *hlist;
+        struct pci_dev_resource *add_res, *tmp;
+        struct pci_dev_resource *dev_res;
         resource_size_t add_size;
         int idx;
 
-        prev = realloc_head;
-        for (list = realloc_head->next; list;) {
-                res = list->res;
+        list_for_each_entry_safe(add_res, tmp, realloc_head, list) {
+                bool found_match = false;
+
+                res = add_res->res;
                 /* skip resource that has been reset */
                 if (!res->flags)
                         goto out;
 
                 /* skip this resource if not found in head list */
-                for (hlist = head->next; hlist && hlist->res != res;
-                                hlist = hlist->next);
-                if (!hlist) { /* just skip */
-                        prev = list;
-                        list = list->next;
-                        continue;
+                list_for_each_entry(dev_res, head, list) {
+                        if (dev_res->res == res) {
+                                found_match = true;
+                                break;
+                        }
                 }
+                if (!found_match)/* just skip */
+                        continue;
 
-                idx = res - &list->dev->resource[0];
-                add_size=list->add_size;
+                idx = res - &add_res->dev->resource[0];
+                add_size = add_res->add_size;
                 if (!resource_size(res)) {
-                        res->start = list->start;
+                        res->start = add_res->start;
                         res->end = res->start + add_size - 1;
-                        if(pci_assign_resource(list->dev, idx))
+                        if (pci_assign_resource(add_res->dev, idx))
                                 reset_resource(res);
                 } else {
-                        resource_size_t align = list->min_align;
-                        res->flags |= list->flags & (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
-                        if (pci_reassign_resource(list->dev, idx, add_size, align))
-                                dev_printk(KERN_DEBUG, &list->dev->dev, "failed to add optional resources res=%pR\n",
-                                                        res);
+                        resource_size_t align = add_res->min_align;
+                        res->flags |= add_res->flags &
+                                 (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
+                        if (pci_reassign_resource(add_res->dev, idx,
+                                                  add_size, align))
+                                dev_printk(KERN_DEBUG, &add_res->dev->dev,
+                                           "failed to add %llx res[%d]=%pR\n",
+                                           (unsigned long long)add_size,
+                                           idx, res);
                 }
 out:
-                tmp = list;
-                prev->next = list = list->next;
-                kfree(tmp);
+                list_del(&add_res->list);
+                kfree(add_res);
         }
 }
 
@@ -192,35 +271,99 @@ out:
  * Satisfy resource requests of each element in the list. Add
  * requests that could not satisfied to the failed_list.
  */
-static void assign_requested_resources_sorted(struct resource_list *head,
-                                 struct resource_list_x *fail_head)
+static void assign_requested_resources_sorted(struct list_head *head,
+                                 struct list_head *fail_head)
 {
         struct resource *res;
-        struct resource_list *list;
+        struct pci_dev_resource *dev_res;
         int idx;
 
-        for (list = head->next; list; list = list->next) {
-                res = list->res;
-                idx = res - &list->dev->resource[0];
-                if (resource_size(res) && pci_assign_resource(list->dev, idx)) {
-                        if (fail_head && !pci_is_root_bus(list->dev->bus)) {
+        list_for_each_entry(dev_res, head, list) {
+                res = dev_res->res;
+                idx = res - &dev_res->dev->resource[0];
+                if (resource_size(res) &&
+                    pci_assign_resource(dev_res->dev, idx)) {
+                        if (fail_head && !pci_is_root_bus(dev_res->dev->bus)) {
                                 /*
                                  * if the failed res is for ROM BAR, and it will
                                  * be enabled later, don't add it to the list
                                  */
                                 if (!((idx == PCI_ROM_RESOURCE) &&
                                       (!(res->flags & IORESOURCE_ROM_ENABLE))))
-                                        add_to_failed_list(fail_head, list->dev, res);
+                                        add_to_list(fail_head,
+                                                    dev_res->dev, res,
+                                                    0 /* dont care */,
+                                                    0 /* dont care */);
                         }
                         reset_resource(res);
                 }
         }
 }
 
-static void __assign_resources_sorted(struct resource_list *head,
-                                 struct resource_list_x *realloc_head,
-                                 struct resource_list_x *fail_head)
+static void __assign_resources_sorted(struct list_head *head,
+                                 struct list_head *realloc_head,
+                                 struct list_head *fail_head)
 {
+        /*
+         * Should not assign requested resources at first.
+         *   they could be adjacent, so later reassign can not reallocate
+         *   them one by one in parent resource window.
+         * Try to assign requested + add_size at begining
+         *  if could do that, could get out early.
+         *  if could not do that, we still try to assign requested at first,
+         *    then try to reassign add_size for some resources.
+         */
+        LIST_HEAD(save_head);
+        LIST_HEAD(local_fail_head);
+        struct pci_dev_resource *save_res;
+        struct pci_dev_resource *dev_res;
+
+        /* Check if optional add_size is there */
+        if (!realloc_head || list_empty(realloc_head))
+                goto requested_and_reassign;
+
+        /* Save original start, end, flags etc at first */
+        list_for_each_entry(dev_res, head, list) {
+                if (add_to_list(&save_head, dev_res->dev, dev_res->res, 0, 0)) {
+                        free_list(&save_head);
+                        goto requested_and_reassign;
+                }
+        }
+
+        /* Update res in head list with add_size in realloc_head list */
+        list_for_each_entry(dev_res, head, list)
+                dev_res->res->end += get_res_add_size(realloc_head,
+                                                        dev_res->res);
+
+        /* Try updated head list with add_size added */
+        assign_requested_resources_sorted(head, &local_fail_head);
+
+        /* all assigned with add_size ? */
+        if (list_empty(&local_fail_head)) {
+                /* Remove head list from realloc_head list */
+                list_for_each_entry(dev_res, head, list)
+                        remove_from_list(realloc_head, dev_res->res);
+                free_list(&save_head);
+                free_list(head);
+                return;
+        }
+
+        free_list(&local_fail_head);
+        /* Release assigned resource */
+        list_for_each_entry(dev_res, head, list)
+                if (dev_res->res->parent)
+                        release_resource(dev_res->res);
+        /* Restore start/end/flags from saved list */
+        list_for_each_entry(save_res, &save_head, list) {
+                struct resource *res = save_res->res;
+
+                res->start = save_res->start;
+                res->end = save_res->end;
+                res->flags = save_res->flags;
+        }
+        free_list(&save_head);
+
+requested_and_reassign:
         /* Satisfy the must-have resource requests */
         assign_requested_resources_sorted(head, fail_head);
 
@@ -228,28 +371,27 @@ static void __assign_resources_sorted(struct resource_list *head,
                 requests */
         if (realloc_head)
                 reassign_resources_sorted(realloc_head, head);
-        free_list(resource_list, head);
+        free_list(head);
 }
 
 static void pdev_assign_resources_sorted(struct pci_dev *dev,
-                                 struct resource_list_x *fail_head)
+                                 struct list_head *add_head,
+                                 struct list_head *fail_head)
 {
-        struct resource_list head;
+        LIST_HEAD(head);
 
-        head.next = NULL;
         __dev_sort_resources(dev, &head);
-        __assign_resources_sorted(&head, NULL, fail_head);
+        __assign_resources_sorted(&head, add_head, fail_head);
 
 }
 
 static void pbus_assign_resources_sorted(const struct pci_bus *bus,
-                                         struct resource_list_x *realloc_head,
-                                         struct resource_list_x *fail_head)
+                                         struct list_head *realloc_head,
+                                         struct list_head *fail_head)
 {
         struct pci_dev *dev;
-        struct resource_list head;
+        LIST_HEAD(head);
 
-        head.next = NULL;
         list_for_each_entry(dev, &bus->devices, bus_list)
                 __dev_sort_resources(dev, &head);
 
@@ -548,20 +690,6 @@ static resource_size_t calculate_memsize(resource_size_t size,
         return size;
 }
 
-static resource_size_t get_res_add_size(struct resource_list_x *realloc_head,
-                                        struct resource *res)
-{
-        struct resource_list_x *list;
-
-        /* check if it is in realloc_head list */
-        for (list = realloc_head->next; list && list->res != res;
-                        list = list->next);
-        if (list)
-                return list->add_size;
-
-        return 0;
-}
-
 /**
  * pbus_size_io() - size the io window of a given bus
  *
@@ -576,7 +704,7 @@ static resource_size_t get_res_add_size(struct resource_list_x *realloc_head,
  * We must be careful with the ISA aliasing though.
  */
 static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
-                resource_size_t add_size, struct resource_list_x *realloc_head)
+                resource_size_t add_size, struct list_head *realloc_head)
 {
         struct pci_dev *dev;
         struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO);
@@ -612,7 +740,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
         if (children_add_size > add_size)
                 add_size = children_add_size;
         size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
-                calculate_iosize(size, min_size+add_size, size1,
+                calculate_iosize(size, min_size, add_size + size1,
                         resource_size(b_res), 4096);
         if (!size0 && !size1) {
                 if (b_res->start || b_res->end)
@@ -626,8 +754,12 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
         b_res->start = 4096;
         b_res->end = b_res->start + size0 - 1;
         b_res->flags |= IORESOURCE_STARTALIGN;
-        if (size1 > size0 && realloc_head)
+        if (size1 > size0 && realloc_head) {
                 add_to_list(realloc_head, bus->self, b_res, size1-size0, 4096);
+                dev_printk(KERN_DEBUG, &bus->self->dev, "bridge window "
+                                 "%pR to [bus %02x-%02x] add_size %lx\n", b_res,
+                                 bus->secondary, bus->subordinate, size1-size0);
+        }
 }
 
 /**
@@ -644,7 +776,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
 static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                          unsigned long type, resource_size_t min_size,
                         resource_size_t add_size,
-                        struct resource_list_x *realloc_head)
+                        struct list_head *realloc_head)
 {
         struct pci_dev *dev;
         resource_size_t min_align, align, size, size0, size1;
@@ -726,7 +858,7 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         if (children_add_size > add_size)
                 add_size = children_add_size;
         size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
-                calculate_memsize(size, min_size+add_size, 0,
+                calculate_memsize(size, min_size, add_size,
                                 resource_size(b_res), min_align);
         if (!size0 && !size1) {
                 if (b_res->start || b_res->end)
@@ -739,8 +871,12 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         b_res->start = min_align;
         b_res->end = size0 + min_align - 1;
         b_res->flags |= IORESOURCE_STARTALIGN | mem64_mask;
-        if (size1 > size0 && realloc_head)
+        if (size1 > size0 && realloc_head) {
                 add_to_list(realloc_head, bus->self, b_res, size1-size0, min_align);
+                dev_printk(KERN_DEBUG, &bus->self->dev, "bridge window "
+                                 "%pR to [bus %02x-%02x] add_size %llx\n", b_res,
+                                 bus->secondary, bus->subordinate, (unsigned long long)size1-size0);
+        }
         return 1;
 }
 
@@ -754,25 +890,48 @@ unsigned long pci_cardbus_resource_alignment(struct resource *res)
 }
 
 static void pci_bus_size_cardbus(struct pci_bus *bus,
-                        struct resource_list_x *realloc_head)
+                        struct list_head *realloc_head)
 {
         struct pci_dev *bridge = bus->self;
         struct resource *b_res = &bridge->resource[PCI_BRIDGE_RESOURCES];
+        resource_size_t b_res_3_size = pci_cardbus_mem_size * 2;
         u16 ctrl;
 
+        if (b_res[0].parent)
+                goto handle_b_res_1;
         /*
          * Reserve some resources for CardBus.  We reserve
          * a fixed amount of bus space for CardBus bridges.
          */
-        b_res[0].start = 0;
-        b_res[0].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
-        if (realloc_head)
-                add_to_list(realloc_head, bridge, b_res, pci_cardbus_io_size, 0 /* dont care */);
+        b_res[0].start = pci_cardbus_io_size;
+        b_res[0].end = b_res[0].start + pci_cardbus_io_size - 1;
+        b_res[0].flags |= IORESOURCE_IO | IORESOURCE_STARTALIGN;
+        if (realloc_head) {
+                b_res[0].end -= pci_cardbus_io_size;
+                add_to_list(realloc_head, bridge, b_res, pci_cardbus_io_size,
+                                pci_cardbus_io_size);
+        }
 
-        b_res[1].start = 0;
-        b_res[1].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
-        if (realloc_head)
-                add_to_list(realloc_head, bridge, b_res+1, pci_cardbus_io_size, 0 /* dont care */);
+handle_b_res_1:
+        if (b_res[1].parent)
+                goto handle_b_res_2;
+        b_res[1].start = pci_cardbus_io_size;
+        b_res[1].end = b_res[1].start + pci_cardbus_io_size - 1;
+        b_res[1].flags |= IORESOURCE_IO | IORESOURCE_STARTALIGN;
+        if (realloc_head) {
+                b_res[1].end -= pci_cardbus_io_size;
+                add_to_list(realloc_head, bridge, b_res+1, pci_cardbus_io_size,
+                                 pci_cardbus_io_size);
+        }
+
+handle_b_res_2:
+        /* MEM1 must not be pref mmio */
+        pci_read_config_word(bridge, PCI_CB_BRIDGE_CONTROL, &ctrl);
+        if (ctrl & PCI_CB_BRIDGE_CTL_PREFETCH_MEM1) {
+                ctrl &= ~PCI_CB_BRIDGE_CTL_PREFETCH_MEM1;
+                pci_write_config_word(bridge, PCI_CB_BRIDGE_CONTROL, ctrl);
+                pci_read_config_word(bridge, PCI_CB_BRIDGE_CONTROL, &ctrl);
+        }
 
         /*
          * Check whether prefetchable memory is supported
@@ -785,38 +944,46 @@ static void pci_bus_size_cardbus(struct pci_bus *bus,
                 pci_read_config_word(bridge, PCI_CB_BRIDGE_CONTROL, &ctrl);
         }
 
+        if (b_res[2].parent)
+                goto handle_b_res_3;
         /*
          * If we have prefetchable memory support, allocate
          * two regions.  Otherwise, allocate one region of
          * twice the size.
          */
         if (ctrl & PCI_CB_BRIDGE_CTL_PREFETCH_MEM0) {
-                b_res[2].start = 0;
-                b_res[2].flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH | IORESOURCE_SIZEALIGN;
-                if (realloc_head)
-                        add_to_list(realloc_head, bridge, b_res+2, pci_cardbus_mem_size, 0 /* dont care */);
-
-                b_res[3].start = 0;
-                b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
-                if (realloc_head)
-                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size, 0 /* dont care */);
-        } else {
-                b_res[3].start = 0;
-                b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
-                if (realloc_head)
-                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size * 2, 0 /* dont care */);
+                b_res[2].start = pci_cardbus_mem_size;
+                b_res[2].end = b_res[2].start + pci_cardbus_mem_size - 1;
+                b_res[2].flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH |
+                                  IORESOURCE_STARTALIGN;
+                if (realloc_head) {
+                        b_res[2].end -= pci_cardbus_mem_size;
+                        add_to_list(realloc_head, bridge, b_res+2,
+                                 pci_cardbus_mem_size, pci_cardbus_mem_size);
+                }
+
+                /* reduce that to half */
+                b_res_3_size = pci_cardbus_mem_size;
+        }
+
+handle_b_res_3:
+        if (b_res[3].parent)
+                goto handle_done;
+        b_res[3].start = pci_cardbus_mem_size;
+        b_res[3].end = b_res[3].start + b_res_3_size - 1;
+        b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_STARTALIGN;
+        if (realloc_head) {
+                b_res[3].end -= b_res_3_size;
+                add_to_list(realloc_head, bridge, b_res+3, b_res_3_size,
+                                 pci_cardbus_mem_size);
         }
 
-        /* set the size of the resource to zero, so that the resource does not
-         * get assigned during required-resource allocation cycle but gets assigned
-         * during the optional-resource allocation cycle.
-         */
-        b_res[0].start = b_res[1].start = b_res[2].start = b_res[3].start = 1;
-        b_res[0].end = b_res[1].end = b_res[2].end = b_res[3].end = 0;
+handle_done:
+        ;
 }
 
 void __ref __pci_bus_size_bridges(struct pci_bus *bus,
-                        struct resource_list_x *realloc_head)
+                        struct list_head *realloc_head)
 {
         struct pci_dev *dev;
         unsigned long mask, prefmask;
@@ -858,7 +1025,8 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                  * Follow thru
                  */
         default:
-                pbus_size_io(bus, 0, additional_io_size, realloc_head);
+                pbus_size_io(bus, realloc_head ? 0 : additional_io_size,
+                             additional_io_size, realloc_head);
                 /* If the bridge supports prefetchable range, size it
                    separately. If it doesn't, or its prefetchable window
                    has already been allocated by arch code, try
@@ -866,11 +1034,15 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                    resources. */
                 mask = IORESOURCE_MEM;
                 prefmask = IORESOURCE_MEM | IORESOURCE_PREFETCH;
-                if (pbus_size_mem(bus, prefmask, prefmask, 0, additional_mem_size, realloc_head))
+                if (pbus_size_mem(bus, prefmask, prefmask,
+                                  realloc_head ? 0 : additional_mem_size,
+                                  additional_mem_size, realloc_head))
                         mask = prefmask; /* Success, size non-prefetch only. */
                 else
                         additional_mem_size += additional_mem_size;
-                pbus_size_mem(bus, mask, IORESOURCE_MEM, 0, additional_mem_size, realloc_head);
+                pbus_size_mem(bus, mask, IORESOURCE_MEM,
+                                realloc_head ? 0 : additional_mem_size,
+                                additional_mem_size, realloc_head);
                 break;
         }
 }
@@ -882,8 +1054,8 @@ void __ref pci_bus_size_bridges(struct pci_bus *bus)
 EXPORT_SYMBOL(pci_bus_size_bridges);
 
 static void __ref __pci_bus_assign_resources(const struct pci_bus *bus,
-                                         struct resource_list_x *realloc_head,
-                                         struct resource_list_x *fail_head)
+                                         struct list_head *realloc_head,
+                                         struct list_head *fail_head)
 {
         struct pci_bus *b;
         struct pci_dev *dev;
@@ -922,17 +1094,19 @@ void __ref pci_bus_assign_resources(const struct pci_bus *bus)
 EXPORT_SYMBOL(pci_bus_assign_resources);
 
 static void __ref __pci_bridge_assign_resources(const struct pci_dev *bridge,
-                                         struct resource_list_x *fail_head)
+                                         struct list_head *add_head,
+                                         struct list_head *fail_head)
 {
         struct pci_bus *b;
 
-        pdev_assign_resources_sorted((struct pci_dev *)bridge, fail_head);
+        pdev_assign_resources_sorted((struct pci_dev *)bridge,
+                                         add_head, fail_head);
 
         b = bridge->subordinate;
         if (!b)
                 return;
 
-        __pci_bus_assign_resources(b, NULL, fail_head);
+        __pci_bus_assign_resources(b, add_head, fail_head);
 
         switch (bridge->class >> 8) {
         case PCI_CLASS_BRIDGE_PCI:
@@ -1095,6 +1269,58 @@ static int __init pci_get_max_depth(void)
         return depth;
 }
 
+/*
+ * -1: undefined, will auto detect later
+ *  0: disabled by user
+ *  1: disabled by auto detect
+ *  2: enabled by user
+ *  3: enabled by auto detect
+ */
+enum enable_type {
+        undefined = -1,
+        user_disabled,
+        auto_disabled,
+        user_enabled,
+        auto_enabled,
+};
+
+static enum enable_type pci_realloc_enable __initdata = undefined;
+void __init pci_realloc_get_opt(char *str)
+{
+        if (!strncmp(str, "off", 3))
+                pci_realloc_enable = user_disabled;
+        else if (!strncmp(str, "on", 2))
+                pci_realloc_enable = user_enabled;
+}
+static bool __init pci_realloc_enabled(void)
+{
+        return pci_realloc_enable >= user_enabled;
+}
+
+static void __init pci_realloc_detect(void)
+{
+#if defined(CONFIG_PCI_IOV) && defined(CONFIG_PCI_REALLOC_ENABLE_AUTO)
+        struct pci_dev *dev = NULL;
+
+        if (pci_realloc_enable != undefined)
+                return;
+
+        for_each_pci_dev(dev) {
+                int i;
+
+                for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++) {
+                        struct resource *r = &dev->resource[i];
+
+                        /* Not assigned, or rejected by kernel ? */
+                        if (r->flags && !r->start) {
+                                pci_realloc_enable = auto_enabled;
+
+                                return;
+                        }
+                }
+        }
+#endif
+}
 
 /*
  * first try will not touch pci bridge res
@@ -1105,59 +1331,57 @@ void __init
 pci_assign_unassigned_resources(void)
 {
         struct pci_bus *bus;
-        struct resource_list_x realloc_list; /* list of resources that
+        LIST_HEAD(realloc_head); /* list of resources that
                                         want additional resources */
+        struct list_head *add_list = NULL;
         int tried_times = 0;
         enum release_type rel_type = leaf_only;
-        struct resource_list_x head, *list;
+        LIST_HEAD(fail_head);
+        struct pci_dev_resource *fail_res;
         unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
                                   IORESOURCE_PREFETCH;
-        unsigned long failed_type;
-        int max_depth = pci_get_max_depth();
-        int pci_try_num;
-
+        int pci_try_num = 1;
 
-        head.next = NULL;
-        realloc_list.next = NULL;
+        /* don't realloc if asked to do so */
+        pci_realloc_detect();
+        if (pci_realloc_enabled()) {
+                int max_depth = pci_get_max_depth();
 
-        pci_try_num = max_depth + 1;
-        printk(KERN_DEBUG "PCI: max bus depth: %d pci_try_num: %d\n",
-                 max_depth, pci_try_num);
+                pci_try_num = max_depth + 1;
+                printk(KERN_DEBUG "PCI: max bus depth: %d pci_try_num: %d\n",
+                         max_depth, pci_try_num);
+        }
 
 again:
+        /*
+         * last try will use add_list, otherwise will try good to have as
+         * must have, so can realloc parent bridge resource
+         */
+        if (tried_times + 1 == pci_try_num)
+                add_list = &realloc_head;
         /* Depth first, calculate sizes and alignments of all
            subordinate buses. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_size_bridges(bus, &realloc_list);
+                __pci_bus_size_bridges(bus, add_list);
 
         /* Depth last, allocate resources and update the hardware. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_assign_resources(bus, &realloc_list, &head);
-        BUG_ON(realloc_list.next);
+                __pci_bus_assign_resources(bus, add_list, &fail_head);
+        if (add_list)
+                BUG_ON(!list_empty(add_list));
         tried_times++;
 
         /* any device complain? */
-        if (!head.next)
+        if (list_empty(&fail_head))
                 goto enable_and_dump;
 
-        /* don't realloc if asked to do so */
-        if (!pci_realloc_enabled()) {
-                free_list(resource_list_x, &head);
-                goto enable_and_dump;
-        }
+        if (tried_times >= pci_try_num) {
+                if (pci_realloc_enable == undefined)
+                        printk(KERN_INFO "Some PCI device resources are unassigned, try booting with pci=realloc\n");
+                else if (pci_realloc_enable == auto_enabled)
+                        printk(KERN_INFO "Automatically enabled pci realloc, if you have problem, try booting with pci=realloc=off\n");
 
-        failed_type = 0;
-        for (list = head.next; list;) {
-                failed_type |= list->flags;
-                list = list->next;
-        }
-        /*
-         * io port are tight, don't try extra
-         * or if reach the limit, don't want to try more
-         */
-        failed_type &= type_mask;
-        if ((failed_type == IORESOURCE_IO) || (tried_times >= pci_try_num)) {
-                free_list(resource_list_x, &head);
+                free_list(&fail_head);
                 goto enable_and_dump;
         }
 
@@ -1172,25 +1396,23 @@ again:
          * Try to release leaf bridge's resources that doesn't fit resource of
          * child device under that bridge
          */
-        for (list = head.next; list;) {
-                bus = list->dev->bus;
-                pci_bus_release_bridge_resources(bus, list->flags & type_mask,
-                                                  rel_type);
-                list = list->next;
+        list_for_each_entry(fail_res, &fail_head, list) {
+                bus = fail_res->dev->bus;
+                pci_bus_release_bridge_resources(bus,
+                                                 fail_res->flags & type_mask,
+                                                 rel_type);
         }
         /* restore size and flags */
-        for (list = head.next; list;) {
-                struct resource *res = list->res;
+        list_for_each_entry(fail_res, &fail_head, list) {
+                struct resource *res = fail_res->res;
 
-                res->start = list->start;
-                res->end = list->end;
-                res->flags = list->flags;
-                if (list->dev->subordinate)
+                res->start = fail_res->start;
+                res->end = fail_res->end;
+                res->flags = fail_res->flags;
+                if (fail_res->dev->subordinate)
                         res->flags = 0;
-
-                list = list->next;
         }
-        free_list(resource_list_x, &head);
+        free_list(&fail_head);
 
         goto again;
 
@@ -1207,26 +1429,27 @@ enable_and_dump:
 void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
 {
         struct pci_bus *parent = bridge->subordinate;
+        LIST_HEAD(add_list); /* list of resources that
+                                        want additional resources */
         int tried_times = 0;
-        struct resource_list_x head, *list;
+        LIST_HEAD(fail_head);
+        struct pci_dev_resource *fail_res;
         int retval;
         unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
                                   IORESOURCE_PREFETCH;
 
-        head.next = NULL;
-
 again:
-        pci_bus_size_bridges(parent);
-        __pci_bridge_assign_resources(bridge, &head);
-
+        __pci_bus_size_bridges(parent, &add_list);
+        __pci_bridge_assign_resources(bridge, &add_list, &fail_head);
+        BUG_ON(!list_empty(&add_list));
         tried_times++;
 
-        if (!head.next)
+        if (list_empty(&fail_head))
                 goto enable_all;
 
         if (tried_times >= 2) {
                 /* still fail, don't need to try more */
-                free_list(resource_list_x, &head);
+                free_list(&fail_head);
                 goto enable_all;
         }
 
@@ -1237,27 +1460,24 @@ again:
          * Try to release leaf bridge's resources that doesn't fit resource of
          * child device under that bridge
          */
-        for (list = head.next; list;) {
-                struct pci_bus *bus = list->dev->bus;
-                unsigned long flags = list->flags;
+        list_for_each_entry(fail_res, &fail_head, list) {
+                struct pci_bus *bus = fail_res->dev->bus;
+                unsigned long flags = fail_res->flags;
 
                 pci_bus_release_bridge_resources(bus, flags & type_mask,
                                                  whole_subtree);
-                list = list->next;
         }
         /* restore size and flags */
-        for (list = head.next; list;) {
-                struct resource *res = list->res;
+        list_for_each_entry(fail_res, &fail_head, list) {
+                struct resource *res = fail_res->res;
 
-                res->start = list->start;
-                res->end = list->end;
-                res->flags = list->flags;
-                if (list->dev->subordinate)
+                res->start = fail_res->start;
+                res->end = fail_res->end;
+                res->flags = fail_res->flags;
+                if (fail_res->dev->subordinate)
                         res->flags = 0;
-
-                list = list->next;
         }
-        free_list(resource_list_x, &head);
+        free_list(&fail_head);
 
         goto again;
 
@@ -1267,3 +1487,41 @@ enable_all:
         pci_enable_bridges(parent);
 }
 EXPORT_SYMBOL_GPL(pci_assign_unassigned_bridge_resources);
+
+#ifdef CONFIG_HOTPLUG
+/**
+ * pci_rescan_bus - scan a PCI bus for devices.
+ * @bus: PCI bus to scan
+ *
+ * Scan a PCI bus and child buses for new devices, adds them,
+ * and enables them.
+ *
+ * Returns the max number of subordinate bus discovered.
+ */
+unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
+{
+        unsigned int max;
+        struct pci_dev *dev;
+        LIST_HEAD(add_list); /* list of resources that
+                                        want additional resources */
+
+        max = pci_scan_child_bus(bus);
+
+        down_read(&pci_bus_sem);
+        list_for_each_entry(dev, &bus->devices, bus_list)
+                if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
+                    dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
+                        if (dev->subordinate)
+                                __pci_bus_size_bridges(dev->subordinate,
+                                                         &add_list);
+        up_read(&pci_bus_sem);
+        __pci_bus_assign_resources(bus, &add_list, NULL);
+        BUG_ON(!list_empty(&add_list));
+
+        pci_enable_bridges(bus);
+        pci_bus_add_devices(bus);
+
+        return max;
+}
+EXPORT_SYMBOL_GPL(pci_rescan_bus);
+#endif
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index b66bfdbd21f7..eea85dafc763 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -114,7 +114,6 @@ int pci_claim_resource(struct pci_dev *dev, int resource)
 }
 EXPORT_SYMBOL(pci_claim_resource);
 
-#ifdef CONFIG_PCI_QUIRKS
 void pci_disable_bridge_window(struct pci_dev *dev)
 {
         dev_info(&dev->dev, "disabling bridge mem windows\n");
@@ -127,9 +126,6 @@ void pci_disable_bridge_window(struct pci_dev *dev)
         pci_write_config_dword(dev, PCI_PREF_MEMORY_BASE, 0x0000fff0);
         pci_write_config_dword(dev, PCI_PREF_BASE_UPPER32, 0xffffffff);
 }
-#endif  /* CONFIG_PCI_QUIRKS */
-
-
 
 static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
                 int resno, resource_size_t size, resource_size_t align)
@@ -158,22 +154,44 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
         return ret;
 }
 
+/*
+ * Generic function that returns a value indicating that the device's
+ * original BIOS BAR address was not saved and so is not available for
+ * reinstatement.
+ *
+ * Can be over-ridden by architecture specific code that implements
+ * reinstatement functionality rather than leaving it disabled when
+ * normal allocation attempts fail.
+ */
+resource_size_t __weak pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx)
+{
+        return 0;
+}
+
 static int pci_revert_fw_address(struct resource *res, struct pci_dev *dev, 
                 int resno, resource_size_t size)
 {
         struct resource *root, *conflict;
-        resource_size_t start, end;
+        resource_size_t fw_addr, start, end;
         int ret = 0;
 
-        if (res->flags & IORESOURCE_IO)
-                root = &ioport_resource;
-        else
-                root = &iomem_resource;
+        fw_addr = pcibios_retrieve_fw_addr(dev, resno);
+        if (!fw_addr)
+                return 1;
 
         start = res->start;
         end = res->end;
-        res->start = dev->fw_addr[resno];
+        res->start = fw_addr;
         res->end = res->start + size - 1;
+
+        root = pci_find_parent_resource(dev, res);
+        if (!root) {
+                if (res->flags & IORESOURCE_IO)
+                        root = &ioport_resource;
+                else
+                        root = &iomem_resource;
+        }
+
         dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
                  resno, res);
         conflict = request_resource_conflict(root, res);
@@ -228,16 +246,17 @@ int pci_reassign_resource(struct pci_dev *dev, int resno, resource_size_t addsiz
         int ret;
 
         if (!res->parent) {
-                dev_info(&dev->dev, "BAR %d: can't reassign an unassigned resouce %pR "
+                dev_info(&dev->dev, "BAR %d: can't reassign an unassigned resource %pR "
                          "\n", resno, res);
                 return -EINVAL;
         }
 
-        new_size = resource_size(res) + addsize + min_align;
+        /* already aligned with min_align */
+        new_size = resource_size(res) + addsize;
         ret = _pci_assign_resource(dev, resno, new_size, min_align);
         if (!ret) {
                 res->flags &= ~IORESOURCE_STARTALIGN;
-                dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
+                dev_info(&dev->dev, "BAR %d: reassigned %pR\n", resno, res);
                 if (resno < PCI_BRIDGE_RESOURCES)
                         pci_update_resource(dev, resno);
         }
@@ -267,7 +286,7 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
          * where firmware left it.  That at least has a chance of
          * working, which is better than just leaving it disabled.
          */
-        if (ret < 0 && dev->fw_addr[resno])
+        if (ret < 0)
                 ret = pci_revert_fw_address(res, dev, resno, size);
 
         if (!ret) {
@@ -279,53 +298,6 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         return ret;
 }
 
-
-/* Sort resources by alignment */
-void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
-{
-        int i;
-
-        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
-                struct resource *r;
-                struct resource_list *list, *tmp;
-                resource_size_t r_align;
-
-                r = &dev->resource[i];
-
-                if (r->flags & IORESOURCE_PCI_FIXED)
-                        continue;
-
-                if (!(r->flags) || r->parent)
-                        continue;
-
-                r_align = pci_resource_alignment(dev, r);
-                if (!r_align) {
-                        dev_warn(&dev->dev, "BAR %d: %pR has bogus alignment\n",
-                                 i, r);
-                        continue;
-                }
-                for (list = head; ; list = list->next) {
-                        resource_size_t align = 0;
-                        struct resource_list *ln = list->next;
-
-                        if (ln)
-                                align = pci_resource_alignment(ln->dev, ln->res);
-
-                        if (r_align > align) {
-                                tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
-                                if (!tmp)
-                                        panic("pdev_sort_resources(): "
-                                              "kmalloc() failed!\n");
-                                tmp->next = ln;
-                                tmp->res = r;
-                                tmp->dev = dev;
-                                list->next = tmp;
-                                break;
-                        }
-                }
-        }
-}
-
 int pci_enable_resources(struct pci_dev *dev, int mask)
 {
         u16 cmd, old_cmd;
diff --git a/drivers/pci/xen-pcifront.c b/drivers/pci/xen-pcifront.c
index 1620088a0e7e..d6cc62cb4cf7 100644
--- a/drivers/pci/xen-pcifront.c
+++ b/drivers/pci/xen-pcifront.c
@@ -290,6 +290,7 @@ static int pci_frontend_enable_msix(struct pci_dev *dev,
                 } else {
                         printk(KERN_DEBUG "enable msix get value %x\n",
                                 op.value);
+                        err = op.value;
                 }
         } else {
                 dev_err(&dev->dev, "enable msix get err %x\n", err);
@@ -544,7 +545,7 @@ static void free_root_bus_devs(struct pci_bus *bus)
                 dev = container_of(bus->devices.next, struct pci_dev,
                                    bus_list);
                 dev_dbg(&dev->dev, "removing device\n");
-                pci_remove_bus_device(dev);
+                pci_stop_and_remove_bus_device(dev);
         }
 }
 
@@ -593,7 +594,7 @@ static pci_ers_result_t pcifront_common_process(int cmd,
         }
         pdrv = pcidev->driver;
 
-        if (get_driver(&pdrv->driver)) {
+        if (pdrv) {
                 if (pdrv->err_handler && pdrv->err_handler->error_detected) {
                         dev_dbg(&pcidev->dev,
                                 "trying to call AER service\n");
@@ -623,7 +624,6 @@ static pci_ers_result_t pcifront_common_process(int cmd,
                                 }
                         }
                 }
-                put_driver(&pdrv->driver);
         }
         if (!flag)
                 result = PCI_ERS_RESULT_NONE;
@@ -1045,7 +1045,7 @@ static int pcifront_detach_devices(struct pcifront_device *pdev)
                                 domain, bus, slot, func);
                         continue;
                 }
-                pci_remove_bus_device(pci_dev);
+                pci_stop_and_remove_bus_device(pci_dev);
                 pci_dev_put(pci_dev);
 
                 dev_dbg(&pdev->xdev->dev,