Merge branch 'linus' into release

16 files changed, 400 insertions, 389 deletions

diff --git a/drivers/pci/hotplug/Makefile b/drivers/pci/hotplug/Makefile
index 9bdbe1a6688f..e31fb91652ce 100644
--- a/drivers/pci/hotplug/Makefile
+++ b/drivers/pci/hotplug/Makefile
@@ -55,6 +55,9 @@ pciehp-objs		:=	pciehp_core.o	\
                                 pciehp_ctrl.o   \
                                 pciehp_pci.o    \
                                 pciehp_hpc.o
+ifdef CONFIG_ACPI
+pciehp-objs             +=      pciehp_acpi.o
+endif
 
 shpchp-objs             :=      shpchp_core.o   \
                                 shpchp_ctrl.o   \
diff --git a/drivers/pci/hotplug/acpi_pcihp.c b/drivers/pci/hotplug/acpi_pcihp.c
index 2c981cbb0719..1c1141801060 100644
--- a/drivers/pci/hotplug/acpi_pcihp.c
+++ b/drivers/pci/hotplug/acpi_pcihp.c
@@ -500,5 +500,74 @@ int acpi_root_bridge(acpi_handle handle)
 }
 EXPORT_SYMBOL_GPL(acpi_root_bridge);
 
+
+static int is_ejectable(acpi_handle handle)
+{
+        acpi_status status;
+        acpi_handle tmp;
+        unsigned long long removable;
+        status = acpi_get_handle(handle, "_ADR", &tmp);
+        if (ACPI_FAILURE(status))
+                return 0;
+        status = acpi_get_handle(handle, "_EJ0", &tmp);
+        if (ACPI_SUCCESS(status))
+                return 1;
+        status = acpi_evaluate_integer(handle, "_RMV", NULL, &removable);
+        if (ACPI_SUCCESS(status) && removable)
+                return 1;
+        return 0;
+}
+
+/**
+ * acpi_pcihp_check_ejectable - check if handle is ejectable ACPI PCI slot
+ * @pbus: the PCI bus of the PCI slot corresponding to 'handle'
+ * @handle: ACPI handle to check
+ *
+ * Return 1 if handle is ejectable PCI slot, 0 otherwise.
+ */
+int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle)
+{
+        acpi_handle bridge_handle, parent_handle;
+
+        if (!(bridge_handle = acpi_pci_get_bridge_handle(pbus)))
+                return 0;
+        if ((ACPI_FAILURE(acpi_get_parent(handle, &parent_handle))))
+                return 0;
+        if (bridge_handle != parent_handle)
+                return 0;
+        return is_ejectable(handle);
+}
+EXPORT_SYMBOL_GPL(acpi_pci_check_ejectable);
+
+static acpi_status
+check_hotplug(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int *found = (int *)context;
+        if (is_ejectable(handle)) {
+                *found = 1;
+                return AE_CTRL_TERMINATE;
+        }
+        return AE_OK;
+}
+
+/**
+ * acpi_pci_detect_ejectable - check if the PCI bus has ejectable slots
+ * @pbus - PCI bus to scan
+ *
+ * Returns 1 if the PCI bus has ACPI based ejectable slots, 0 otherwise.
+ */
+int acpi_pci_detect_ejectable(struct pci_bus *pbus)
+{
+        acpi_handle handle;
+        int found = 0;
+
+        if (!(handle = acpi_pci_get_bridge_handle(pbus)))
+                return 0;
+        acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                            check_hotplug, (void *)&found, NULL);
+        return found;
+}
+EXPORT_SYMBOL_GPL(acpi_pci_detect_ejectable);
+
 module_param(debug_acpi, bool, 0644);
 MODULE_PARM_DESC(debug_acpi, "Debugging mode for ACPI enabled or not");
diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index 9bcb6cbd5aa9..4fc168b70095 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -44,7 +44,7 @@
         do {                                                    \
                 if (acpiphp_debug)                              \
                         printk(KERN_DEBUG "%s: " format,        \
-                                MY_NAME , ## arg);              \
+                                MY_NAME , ## arg);              \
         } while (0)
 #define err(format, arg...) printk(KERN_ERR "%s: " format, MY_NAME , ## arg)
 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 3affc6472e65..f09b1010d477 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -46,6 +46,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
+#include <linux/pci-acpi.h>
 #include <linux/mutex.h>
 
 #include "../pci.h"
@@ -62,61 +63,6 @@ static void acpiphp_sanitize_bus(struct pci_bus *bus);
 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus);
 static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context);
 
-
-/*
- * initialization & terminatation routines
- */
-
-/**
- * is_ejectable - determine if a slot is ejectable
- * @handle: handle to acpi namespace
- *
- * Ejectable slot should satisfy at least these conditions:
- *
- *  1. has _ADR method
- *  2. has _EJ0 method
- *
- * optionally
- *
- *  1. has _STA method
- *  2. has _PS0 method
- *  3. has _PS3 method
- *  4. ..
- */
-static int is_ejectable(acpi_handle handle)
-{
-        acpi_status status;
-        acpi_handle tmp;
-
-        status = acpi_get_handle(handle, "_ADR", &tmp);
-        if (ACPI_FAILURE(status)) {
-                return 0;
-        }
-
-        status = acpi_get_handle(handle, "_EJ0", &tmp);
-        if (ACPI_FAILURE(status)) {
-                return 0;
-        }
-
-        return 1;
-}
-
-
-/* callback routine to check for the existence of ejectable slots */
-static acpi_status
-is_ejectable_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
-{
-        int *count = (int *)context;
-
-        if (is_ejectable(handle)) {
-                (*count)++;
-                /* only one ejectable slot is enough */
-                return AE_CTRL_TERMINATE;
-        } else {
-                return AE_OK;
-        }
-}
-
 /* callback routine to check for the existence of a pci dock device */
 static acpi_status
 is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
@@ -131,9 +77,6 @@ is_pci_dock_device(acpi_handle handle, u32 lvl, void *context, void **rv)
         }
 }
 
-
-
-
 /*
  * the _DCK method can do funny things... and sometimes not
  * hah-hah funny.
@@ -160,9 +103,9 @@ static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
 
         if (((buses >> 8) & 0xff) != bus->secondary) {
                 buses = (buses & 0xff000000)
-                        | ((unsigned int)(bus->primary)     <<  0)
-                        | ((unsigned int)(bus->secondary)   <<  8)
-                        | ((unsigned int)(bus->subordinate) << 16);
+                        | ((unsigned int)(bus->primary)     <<  0)
+                        | ((unsigned int)(bus->secondary)   <<  8)
+                        | ((unsigned int)(bus->subordinate) << 16);
                 pci_write_config_dword(bus->self, PCI_PRIMARY_BUS, buses);
         }
         return NOTIFY_OK;
@@ -184,17 +127,12 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         acpi_status status = AE_OK;
         unsigned long long adr, sun;
         int device, function, retval;
+        struct pci_bus *pbus = bridge->pci_bus;
 
-        status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
-
-        if (ACPI_FAILURE(status))
-                return AE_OK;
-
-        status = acpi_get_handle(handle, "_EJ0", &tmp);
-
-        if (ACPI_FAILURE(status) && !(is_dock_device(handle)))
+        if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle))
                 return AE_OK;
 
+        acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
         device = (adr >> 16) & 0xffff;
         function = adr & 0xffff;
 
@@ -205,7 +143,8 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         INIT_LIST_HEAD(&newfunc->sibling);
         newfunc->handle = handle;
         newfunc->function = function;
-        if (ACPI_SUCCESS(status))
+
+        if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
                 newfunc->flags = FUNC_HAS_EJ0;
 
         if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
@@ -256,8 +195,7 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
                 bridge->nr_slots++;
 
                 dbg("found ACPI PCI Hotplug slot %llu at PCI %04x:%02x:%02x\n",
-                                slot->sun, pci_domain_nr(bridge->pci_bus),
-                                bridge->pci_bus->number, slot->device);
+                    slot->sun, pci_domain_nr(pbus), pbus->number, device);
                 retval = acpiphp_register_hotplug_slot(slot);
                 if (retval) {
                         if (retval == -EBUSY)
@@ -274,8 +212,7 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         list_add_tail(&newfunc->sibling, &slot->funcs);
 
         /* associate corresponding pci_dev */
-        newfunc->pci_dev = pci_get_slot(bridge->pci_bus,
-                                         PCI_DEVFN(device, function));
+        newfunc->pci_dev = pci_get_slot(pbus, PCI_DEVFN(device, function));
         if (newfunc->pci_dev) {
                 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
         }
@@ -324,27 +261,15 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 
 
 /* see if it's worth looking at this bridge */
-static int detect_ejectable_slots(acpi_handle *bridge_handle)
+static int detect_ejectable_slots(struct pci_bus *pbus)
 {
-        acpi_status status;
-        int count;
-
-        count = 0;
-
-        /* only check slots defined directly below bridge object */
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1,
-                                     is_ejectable_slot, (void *)&count, NULL);
-
-        /*
-         * we also need to add this bridge if there is a dock bridge or
-         * other pci device on a dock station (removable)
-         */
-        if (!count)
-                status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle,
-                                (u32)1, is_pci_dock_device, (void *)&count,
-                                NULL);
-
-        return count;
+        int found = acpi_pci_detect_ejectable(pbus);
+        if (!found) {
+                acpi_handle bridge_handle = acpi_pci_get_bridge_handle(pbus);
+                acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1,
+                                    is_pci_dock_device, (void *)&found, NULL);
+        }
+        return found;
 }
 
 
@@ -554,7 +479,7 @@ find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
                 goto out;
 
         /* check if this bridge has ejectable slots */
-        if ((detect_ejectable_slots(handle) > 0)) {
+        if ((detect_ejectable_slots(dev->subordinate) > 0)) {
                 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev));
                 add_p2p_bridge(handle, dev);
         }
@@ -615,7 +540,7 @@ static int add_bridge(acpi_handle handle)
         }
 
         /* check if this bridge has ejectable slots */
-        if (detect_ejectable_slots(handle) > 0) {
+        if (detect_ejectable_slots(pci_bus) > 0) {
                 dbg("found PCI host-bus bridge with hot-pluggable slots\n");
                 add_host_bridge(handle, pci_bus);
         }
diff --git a/drivers/pci/hotplug/acpiphp_ibm.c b/drivers/pci/hotplug/acpiphp_ibm.c
index 881fdd2b7313..5befa7e379b7 100644
--- a/drivers/pci/hotplug/acpiphp_ibm.c
+++ b/drivers/pci/hotplug/acpiphp_ibm.c
@@ -271,7 +271,7 @@ static void ibm_handle_events(acpi_handle handle, u32 event, void *context)
                 dbg("%s: generationg bus event\n", __func__);
                 acpi_bus_generate_proc_event(note->device, note->event, detail);
                 acpi_bus_generate_netlink_event(note->device->pnp.device_class,
-                                                  note->device->dev.bus_id,
+                                                  dev_name(&note->device->dev),
                                                   note->event, detail);
         } else
                 note->event = event;
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 8514c3a1746a..c2e1bcbb28a7 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -45,7 +45,7 @@
 
 #include "cpqphp.h"
 #include "cpqphp_nvram.h"
-#include "../../../arch/x86/pci/pci.h"  /* horrible hack showing how processor dependent we are... */
+#include <asm/pci_x86.h>
 
 
 /* Global variables */
diff --git a/drivers/pci/hotplug/cpqphp_ctrl.c b/drivers/pci/hotplug/cpqphp_ctrl.c
index a60a25290995..cc227a8c4b11 100644
--- a/drivers/pci/hotplug/cpqphp_ctrl.c
+++ b/drivers/pci/hotplug/cpqphp_ctrl.c
@@ -1954,7 +1954,7 @@ void cpqhp_pushbutton_thread(unsigned long slot)
                         return ;
                 }
 
-                if (func != NULL && ctrl != NULL) {
+                if (ctrl != NULL) {
                         if (cpqhp_process_SI(ctrl, func) != 0) {
                                 amber_LED_on(ctrl, hp_slot);
                                 green_LED_off(ctrl, hp_slot);
@@ -2604,7 +2604,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
                         for (cloop = 0; cloop < 4; cloop++) {
                                 if (irqs.valid_INT & (0x01 << cloop)) {
                                         rc = cpqhp_set_irq(func->bus, func->device,
-                                                           0x0A + cloop, irqs.interrupt[cloop]);
+                                                           cloop + 1, irqs.interrupt[cloop]);
                                         if (rc)
                                                 goto free_and_out;
                                 }
@@ -2945,7 +2945,7 @@ static int configure_new_function(struct controller *ctrl, struct pci_func *func
                 }
 
                 if (!behind_bridge) {
-                        rc = cpqhp_set_irq(func->bus, func->device, temp_byte + 0x09, IRQ);
+                        rc = cpqhp_set_irq(func->bus, func->device, temp_byte, IRQ);
                         if (rc)
                                 return 1;
                 } else {
diff --git a/drivers/pci/hotplug/cpqphp_pci.c b/drivers/pci/hotplug/cpqphp_pci.c
index 09021930589f..6c0ed0fcb8ee 100644
--- a/drivers/pci/hotplug/cpqphp_pci.c
+++ b/drivers/pci/hotplug/cpqphp_pci.c
@@ -37,7 +37,7 @@
 #include "../pci.h"
 #include "cpqphp.h"
 #include "cpqphp_nvram.h"
-#include "../../../arch/x86/pci/pci.h"  /* horrible hack showing how processor dependent we are... */
+#include <asm/pci_x86.h>
 
 
 u8 cpqhp_nic_irq;
@@ -171,7 +171,7 @@ int cpqhp_set_irq (u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num)
                 fakebus->number = bus_num;
                 dbg("%s: dev %d, bus %d, pin %d, num %d\n",
                     __func__, dev_num, bus_num, int_pin, irq_num);
-                rc = pcibios_set_irq_routing(fakedev, int_pin - 0x0a, irq_num);
+                rc = pcibios_set_irq_routing(fakedev, int_pin - 1, irq_num);
                 kfree(fakedev);
                 kfree(fakebus);
                 dbg("%s: rc %d\n", __func__, rc);
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 3a2637a00934..b0e7de9e536d 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -324,6 +324,7 @@ static int disable_slot(struct hotplug_slot *slot)
 
                 if (test_and_set_bit(0, &dslot->removed)) {
                         dbg("Slot already scheduled for removal\n");
+                        pci_dev_put(dev);
                         return -ENODEV;
                 }
 
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 633e743442ac..dd18f857dfb0 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -35,7 +35,7 @@
 #include <linux/delay.h>
 #include <linux/wait.h>
 #include "../pci.h"
-#include "../../../arch/x86/pci/pci.h"  /* for struct irq_routing_table */
+#include <asm/pci_x86.h>                /* for struct irq_routing_table */
 #include "ibmphp.h"
 
 #define attn_on(sl)  ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON)
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 7072952ea1d2..db85284ffb62 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -219,11 +219,23 @@ struct hpc_ops {
 #include <acpi/acpi_bus.h>
 #include <linux/pci-acpi.h>
 
+extern void __init pciehp_acpi_slot_detection_init(void);
+extern int pciehp_acpi_slot_detection_check(struct pci_dev *dev);
+
+static inline void pciehp_firmware_init(void)
+{
+        pciehp_acpi_slot_detection_init();
+}
+
 static inline int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)
 {
+        int retval;
         u32 flags = (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |
                      OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
-        return acpi_get_hp_hw_control_from_firmware(dev, flags);
+        retval = acpi_get_hp_hw_control_from_firmware(dev, flags);
+        if (retval)
+                return retval;
+        return pciehp_acpi_slot_detection_check(dev);
 }
 
 static inline int pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
@@ -234,6 +246,7 @@ static inline int pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
         return 0;
 }
 #else
+#define pciehp_firmware_init()                          do {} while (0)
 #define pciehp_get_hp_hw_control_from_firmware(dev)     0
 #define pciehp_get_hp_params_from_firmware(dev, hpp)    (-ENODEV)
 #endif                          /* CONFIG_ACPI */
diff --git a/drivers/pci/hotplug/pciehp_acpi.c b/drivers/pci/hotplug/pciehp_acpi.c
new file mode 100644
index 000000000000..438d795f9fe3
--- /dev/null
+++ b/drivers/pci/hotplug/pciehp_acpi.c
@@ -0,0 +1,141 @@
+/*
+ * ACPI related functions for PCI Express Hot Plug driver.
+ *
+ * Copyright (C) 2008 Kenji Kaneshige
+ * Copyright (C) 2008 Fujitsu Limited.
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/acpi.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+#include "pciehp.h"
+
+#define PCIEHP_DETECT_PCIE      (0)
+#define PCIEHP_DETECT_ACPI      (1)
+#define PCIEHP_DETECT_AUTO      (2)
+#define PCIEHP_DETECT_DEFAULT   PCIEHP_DETECT_AUTO
+
+static int slot_detection_mode;
+static char *pciehp_detect_mode;
+module_param(pciehp_detect_mode, charp, 0444);
+MODULE_PARM_DESC(pciehp_detect_mode,
+         "Slot detection mode: pcie, acpi, auto\n"
+         "  pcie          - Use PCIe based slot detection\n"
+         "  acpi          - Use ACPI for slot detection\n"
+         "  auto(default) - Auto select mode. Use acpi option if duplicate\n"
+         "                  slot ids are found. Otherwise, use pcie option\n");
+
+int pciehp_acpi_slot_detection_check(struct pci_dev *dev)
+{
+        if (slot_detection_mode != PCIEHP_DETECT_ACPI)
+                return 0;
+        if (acpi_pci_detect_ejectable(dev->subordinate))
+                return 0;
+        return -ENODEV;
+}
+
+static int __init parse_detect_mode(void)
+{
+        if (!pciehp_detect_mode)
+                return PCIEHP_DETECT_DEFAULT;
+        if (!strcmp(pciehp_detect_mode, "pcie"))
+                return PCIEHP_DETECT_PCIE;
+        if (!strcmp(pciehp_detect_mode, "acpi"))
+                return PCIEHP_DETECT_ACPI;
+        if (!strcmp(pciehp_detect_mode, "auto"))
+                return PCIEHP_DETECT_AUTO;
+        warn("bad specifier '%s' for pciehp_detect_mode. Use default\n",
+             pciehp_detect_mode);
+        return PCIEHP_DETECT_DEFAULT;
+}
+
+static struct pcie_port_service_id __initdata port_pci_ids[] = {
+        {
+                .vendor = PCI_ANY_ID,
+                .device = PCI_ANY_ID,
+                .port_type = PCIE_ANY_PORT,
+                .service_type = PCIE_PORT_SERVICE_HP,
+                .driver_data =  0,
+        }, { /* end: all zeroes */ }
+};
+
+static int __initdata dup_slot_id;
+static int __initdata acpi_slot_detected;
+static struct list_head __initdata dummy_slots = LIST_HEAD_INIT(dummy_slots);
+
+/* Dummy driver for dumplicate name detection */
+static int __init dummy_probe(struct pcie_device *dev,
+                              const struct pcie_port_service_id *id)
+{
+        int pos;
+        u32 slot_cap;
+        struct slot *slot, *tmp;
+        struct pci_dev *pdev = dev->port;
+        struct pci_bus *pbus = pdev->subordinate;
+        if (!(slot = kzalloc(sizeof(*slot), GFP_KERNEL)))
+                return -ENOMEM;
+        /* Note: pciehp_detect_mode != PCIEHP_DETECT_ACPI here */
+        if (pciehp_get_hp_hw_control_from_firmware(pdev))
+                return -ENODEV;
+        if (!(pos = pci_find_capability(pdev, PCI_CAP_ID_EXP)))
+                return -ENODEV;
+        pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &slot_cap);
+        slot->number = slot_cap >> 19;
+        list_for_each_entry(tmp, &dummy_slots, slot_list) {
+                if (tmp->number == slot->number)
+                        dup_slot_id++;
+        }
+        list_add_tail(&slot->slot_list, &dummy_slots);
+        if (!acpi_slot_detected && acpi_pci_detect_ejectable(pbus))
+                acpi_slot_detected = 1;
+        return -ENODEV;         /* dummy driver always returns error */
+}
+
+static struct pcie_port_service_driver __initdata dummy_driver = {
+        .name           = "pciehp_dummy",
+        .id_table       = port_pci_ids,
+        .probe          = dummy_probe,
+};
+
+static int __init select_detection_mode(void)
+{
+        struct slot *slot, *tmp;
+        pcie_port_service_register(&dummy_driver);
+        pcie_port_service_unregister(&dummy_driver);
+        list_for_each_entry_safe(slot, tmp, &dummy_slots, slot_list) {
+                list_del(&slot->slot_list);
+                kfree(slot);
+        }
+        if (acpi_slot_detected && dup_slot_id)
+                return PCIEHP_DETECT_ACPI;
+        return PCIEHP_DETECT_PCIE;
+}
+
+void __init pciehp_acpi_slot_detection_init(void)
+{
+        slot_detection_mode = parse_detect_mode();
+        if (slot_detection_mode != PCIEHP_DETECT_AUTO)
+                goto out;
+        slot_detection_mode = select_detection_mode();
+out:
+        if (slot_detection_mode == PCIEHP_DETECT_ACPI)
+                info("Using ACPI for slot detection.\n");
+}
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 39cf248d24e3..5482d4ed8256 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -522,6 +522,7 @@ static int __init pcied_init(void)
 {
         int retval = 0;
 
+        pciehp_firmware_init();
         retval = pcie_port_service_register(&hpdriver_portdrv);
         dbg("pcie_port_service_register = %d\n", retval);
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index fead63c6b49e..ff4034502d24 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -178,15 +178,14 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
                                  "Issue of Slot Power Off command failed\n");
                         return;
                 }
+                /*
+                 * After turning power off, we must wait for at least 1 second
+                 * before taking any action that relies on power having been
+                 * removed from the slot/adapter.
+                 */
+                msleep(1000);
         }
 
-        /*
-         * After turning power off, we must wait for at least 1 second
-         * before taking any action that relies on power having been
-         * removed from the slot/adapter.
-         */
-        msleep(1000);
-
         if (PWR_LED(ctrl))
                 pslot->hpc_ops->green_led_off(pslot);
 
@@ -286,15 +285,14 @@ static int remove_board(struct slot *p_slot)
                                  "Issue of Slot Disable command failed\n");
                         return retval;
                 }
+                /*
+                 * After turning power off, we must wait for at least 1 second
+                 * before taking any action that relies on power having been
+                 * removed from the slot/adapter.
+                 */
+                msleep(1000);
         }
 
-        /*
-         * After turning power off, we must wait for at least 1 second
-         * before taking any action that relies on power having been
-         * removed from the slot/adapter.
-         */
-        msleep(1000);
-
         if (PWR_LED(ctrl))
                 /* turn off Green LED */
                 p_slot->hpc_ops->green_led_off(p_slot);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index b643ca13e4f1..71a8012886b0 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -42,42 +42,6 @@
 
 static atomic_t pciehp_num_controllers = ATOMIC_INIT(0);
 
-struct ctrl_reg {
-        u8 cap_id;
-        u8 nxt_ptr;
-        u16 cap_reg;
-        u32 dev_cap;
-        u16 dev_ctrl;
-        u16 dev_status;
-        u32 lnk_cap;
-        u16 lnk_ctrl;
-        u16 lnk_status;
-        u32 slot_cap;
-        u16 slot_ctrl;
-        u16 slot_status;
-        u16 root_ctrl;
-        u16 rsvp;
-        u32 root_status;
-} __attribute__ ((packed));
-
-/* offsets to the controller registers based on the above structure layout */
-enum ctrl_offsets {
-        PCIECAPID       =       offsetof(struct ctrl_reg, cap_id),
-        NXTCAPPTR       =       offsetof(struct ctrl_reg, nxt_ptr),
-        CAPREG          =       offsetof(struct ctrl_reg, cap_reg),
-        DEVCAP          =       offsetof(struct ctrl_reg, dev_cap),
-        DEVCTRL         =       offsetof(struct ctrl_reg, dev_ctrl),
-        DEVSTATUS       =       offsetof(struct ctrl_reg, dev_status),
-        LNKCAP          =       offsetof(struct ctrl_reg, lnk_cap),
-        LNKCTRL         =       offsetof(struct ctrl_reg, lnk_ctrl),
-        LNKSTATUS       =       offsetof(struct ctrl_reg, lnk_status),
-        SLOTCAP         =       offsetof(struct ctrl_reg, slot_cap),
-        SLOTCTRL        =       offsetof(struct ctrl_reg, slot_ctrl),
-        SLOTSTATUS      =       offsetof(struct ctrl_reg, slot_status),
-        ROOTCTRL        =       offsetof(struct ctrl_reg, root_ctrl),
-        ROOTSTATUS      =       offsetof(struct ctrl_reg, root_status),
-};
-
 static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
 {
         struct pci_dev *dev = ctrl->pci_dev;
@@ -102,95 +66,9 @@ static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
         return pci_write_config_dword(dev, ctrl->cap_base + reg, value);
 }
 
-/* Field definitions in PCI Express Capabilities Register */
-#define CAP_VER                 0x000F
-#define DEV_PORT_TYPE           0x00F0
-#define SLOT_IMPL               0x0100
-#define MSG_NUM                 0x3E00
-
-/* Device or Port Type */
-#define NAT_ENDPT               0x00
-#define LEG_ENDPT               0x01
-#define ROOT_PORT               0x04
-#define UP_STREAM               0x05
-#define DN_STREAM               0x06
-#define PCIE_PCI_BRDG           0x07
-#define PCI_PCIE_BRDG           0x10
-
-/* Field definitions in Device Capabilities Register */
-#define DATTN_BUTTN_PRSN        0x1000
-#define DATTN_LED_PRSN          0x2000
-#define DPWR_LED_PRSN           0x4000
-
-/* Field definitions in Link Capabilities Register */
-#define MAX_LNK_SPEED           0x000F
-#define MAX_LNK_WIDTH           0x03F0
-#define LINK_ACTIVE_REPORTING   0x00100000
-
-/* Link Width Encoding */
-#define LNK_X1          0x01
-#define LNK_X2          0x02
-#define LNK_X4          0x04
-#define LNK_X8          0x08
-#define LNK_X12         0x0C
-#define LNK_X16         0x10
-#define LNK_X32         0x20
-
-/*Field definitions of Link Status Register */
-#define LNK_SPEED       0x000F
-#define NEG_LINK_WD     0x03F0
-#define LNK_TRN_ERR     0x0400
-#define LNK_TRN         0x0800
-#define SLOT_CLK_CONF   0x1000
-#define LINK_ACTIVE     0x2000
-
-/* Field definitions in Slot Capabilities Register */
-#define ATTN_BUTTN_PRSN 0x00000001
-#define PWR_CTRL_PRSN   0x00000002
-#define MRL_SENS_PRSN   0x00000004
-#define ATTN_LED_PRSN   0x00000008
-#define PWR_LED_PRSN    0x00000010
-#define HP_SUPR_RM_SUP  0x00000020
-#define HP_CAP          0x00000040
-#define SLOT_PWR_VALUE  0x000003F8
-#define SLOT_PWR_LIMIT  0x00000C00
-#define PSN             0xFFF80000      /* PSN: Physical Slot Number */
-
-/* Field definitions in Slot Control Register */
-#define ATTN_BUTTN_ENABLE               0x0001
-#define PWR_FAULT_DETECT_ENABLE         0x0002
-#define MRL_DETECT_ENABLE               0x0004
-#define PRSN_DETECT_ENABLE              0x0008
-#define CMD_CMPL_INTR_ENABLE            0x0010
-#define HP_INTR_ENABLE                  0x0020
-#define ATTN_LED_CTRL                   0x00C0
-#define PWR_LED_CTRL                    0x0300
-#define PWR_CTRL                        0x0400
-#define EMI_CTRL                        0x0800
-
-/* Attention indicator and Power indicator states */
-#define LED_ON          0x01
-#define LED_BLINK       0x10
-#define LED_OFF         0x11
-
 /* Power Control Command */
 #define POWER_ON        0
-#define POWER_OFF       0x0400
-
-/* EMI Status defines */
-#define EMI_DISENGAGED  0
-#define EMI_ENGAGED     1
-
-/* Field definitions in Slot Status Register */
-#define ATTN_BUTTN_PRESSED      0x0001
-#define PWR_FAULT_DETECTED      0x0002
-#define MRL_SENS_CHANGED        0x0004
-#define PRSN_DETECT_CHANGED     0x0008
-#define CMD_COMPLETED           0x0010
-#define MRL_STATE               0x0020
-#define PRSN_STATE              0x0040
-#define EMI_STATE               0x0080
-#define EMI_STATUS_BIT          7
+#define POWER_OFF       PCI_EXP_SLTCTL_PCC
 
 static irqreturn_t pcie_isr(int irq, void *dev_id);
 static void start_int_poll_timer(struct controller *ctrl, int sec);
@@ -253,22 +131,20 @@ static inline void pciehp_free_irq(struct controller *ctrl)
 static int pcie_poll_cmd(struct controller *ctrl)
 {
         u16 slot_status;
-        int timeout = 1000;
+        int err, timeout = 1000;
 
-        if (!pciehp_readw(ctrl, SLOTSTATUS, &slot_status)) {
-                if (slot_status & CMD_COMPLETED) {
-                        pciehp_writew(ctrl, SLOTSTATUS, CMD_COMPLETED);
-                        return 1;
-                }
+        err = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
+        if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
+                pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_CC);
+                return 1;
         }
         while (timeout > 0) {
                 msleep(10);
                 timeout -= 10;
-                if (!pciehp_readw(ctrl, SLOTSTATUS, &slot_status)) {
-                        if (slot_status & CMD_COMPLETED) {
-                                pciehp_writew(ctrl, SLOTSTATUS, CMD_COMPLETED);
-                                return 1;
-                        }
+                err = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
+                if (!err && (slot_status & PCI_EXP_SLTSTA_CC)) {
+                        pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_CC);
+                        return 1;
                 }
         }
         return 0;       /* timeout */
@@ -302,14 +178,14 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
 
         mutex_lock(&ctrl->ctrl_lock);
 
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
                          __func__);
                 goto out;
         }
 
-        if (slot_status & CMD_COMPLETED) {
+        if (slot_status & PCI_EXP_SLTSTA_CC) {
                 if (!ctrl->no_cmd_complete) {
                         /*
                          * After 1 sec and CMD_COMPLETED still not set, just
@@ -332,7 +208,7 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                 }
         }
 
-        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 goto out;
@@ -342,7 +218,7 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
         slot_ctrl |= (cmd & mask);
         ctrl->cmd_busy = 1;
         smp_mb();
-        retval = pciehp_writew(ctrl, SLOTCTRL, slot_ctrl);
+        retval = pciehp_writew(ctrl, PCI_EXP_SLTCTL, slot_ctrl);
         if (retval)
                 ctrl_err(ctrl, "Cannot write to SLOTCTRL register\n");
 
@@ -356,8 +232,8 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                  * completed interrupt is not enabled, we need to poll
                  * command completed event.
                  */
-                if (!(slot_ctrl & HP_INTR_ENABLE) ||
-                    !(slot_ctrl & CMD_CMPL_INTR_ENABLE))
+                if (!(slot_ctrl & PCI_EXP_SLTCTL_HPIE) ||
+                    !(slot_ctrl & PCI_EXP_SLTCTL_CCIE))
                         poll = 1;
                 pcie_wait_cmd(ctrl, poll);
         }
@@ -370,9 +246,9 @@ static inline int check_link_active(struct controller *ctrl)
 {
         u16 link_status;
 
-        if (pciehp_readw(ctrl, LNKSTATUS, &link_status))
+        if (pciehp_readw(ctrl, PCI_EXP_LNKSTA, &link_status))
                 return 0;
-        return !!(link_status & LINK_ACTIVE);
+        return !!(link_status & PCI_EXP_LNKSTA_DLLLA);
 }
 
 static void pcie_wait_link_active(struct controller *ctrl)
@@ -412,15 +288,15 @@ static int hpc_check_lnk_status(struct controller *ctrl)
         } else
                 msleep(1000);
 
-        retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
         if (retval) {
                 ctrl_err(ctrl, "Cannot read LNKSTATUS register\n");
                 return retval;
         }
 
         ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
-        if ( (lnk_status & LNK_TRN) || (lnk_status & LNK_TRN_ERR) ||
-                !(lnk_status & NEG_LINK_WD)) {
+        if ((lnk_status & PCI_EXP_LNKSTA_LT) ||
+            !(lnk_status & PCI_EXP_LNKSTA_NLW)) {
                 ctrl_err(ctrl, "Link Training Error occurs \n");
                 retval = -1;
                 return retval;
@@ -436,16 +312,16 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
         u8 atten_led_state;
         int retval = 0;
 
-        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 return retval;
         }
 
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_ctrl);
 
-        atten_led_state = (slot_ctrl & ATTN_LED_CTRL) >> 6;
+        atten_led_state = (slot_ctrl & PCI_EXP_SLTCTL_AIC) >> 6;
 
         switch (atten_led_state) {
         case 0:
@@ -475,15 +351,15 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
         u8 pwr_state;
         int     retval = 0;
 
-        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 return retval;
         }
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_ctrl);
 
-        pwr_state = (slot_ctrl & PWR_CTRL) >> 10;
+        pwr_state = (slot_ctrl & PCI_EXP_SLTCTL_PCC) >> 10;
 
         switch (pwr_state) {
         case 0:
@@ -504,17 +380,15 @@ static int hpc_get_latch_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
-        int retval = 0;
+        int retval;
 
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
                          __func__);
                 return retval;
         }
-
-        *status = (((slot_status & MRL_STATE) >> 5) == 0) ? 0 : 1;
-
+        *status = !!(slot_status & PCI_EXP_SLTSTA_MRLSS);
         return 0;
 }
 
@@ -522,18 +396,15 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
-        u8 card_state;
-        int retval = 0;
+        int retval;
 
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
                          __func__);
                 return retval;
         }
-        card_state = (u8)((slot_status & PRSN_STATE) >> 6);
-        *status = (card_state == 1) ? 1 : 0;
-
+        *status = !!(slot_status & PCI_EXP_SLTSTA_PDS);
         return 0;
 }
 
@@ -541,32 +412,28 @@ static int hpc_query_power_fault(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
-        u8 pwr_fault;
-        int retval = 0;
+        int retval;
 
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "Cannot check for power fault\n");
                 return retval;
         }
-        pwr_fault = (u8)((slot_status & PWR_FAULT_DETECTED) >> 1);
-
-        return pwr_fault;
+        return !!(slot_status & PCI_EXP_SLTSTA_PFD);
 }
 
 static int hpc_get_emi_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
-        int retval = 0;
+        int retval;
 
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "Cannot check EMI status\n");
                 return retval;
         }
-        *status = (slot_status & EMI_STATE) >> EMI_STATUS_BIT;
-
+        *status = !!(slot_status & PCI_EXP_SLTSTA_EIS);
         return retval;
 }
 
@@ -576,8 +443,8 @@ static int hpc_toggle_emi(struct slot *slot)
         u16 cmd_mask;
         int rc;
 
-        slot_cmd = EMI_CTRL;
-        cmd_mask = EMI_CTRL;
+        slot_cmd = PCI_EXP_SLTCTL_EIC;
+        cmd_mask = PCI_EXP_SLTCTL_EIC;
         rc = pcie_write_cmd(slot->ctrl, slot_cmd, cmd_mask);
         slot->last_emi_toggle = get_seconds();
 
@@ -591,7 +458,7 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
         u16 cmd_mask;
         int rc;
 
-        cmd_mask = ATTN_LED_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_AIC;
         switch (value) {
                 case 0 :        /* turn off */
                         slot_cmd = 0x00C0;
@@ -607,7 +474,7 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
         }
         rc = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 
         return rc;
 }
@@ -619,10 +486,10 @@ static void hpc_set_green_led_on(struct slot *slot)
         u16 cmd_mask;
 
         slot_cmd = 0x0100;
-        cmd_mask = PWR_LED_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_PIC;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
 static void hpc_set_green_led_off(struct slot *slot)
@@ -632,10 +499,10 @@ static void hpc_set_green_led_off(struct slot *slot)
         u16 cmd_mask;
 
         slot_cmd = 0x0300;
-        cmd_mask = PWR_LED_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_PIC;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
 static void hpc_set_green_led_blink(struct slot *slot)
@@ -645,10 +512,10 @@ static void hpc_set_green_led_blink(struct slot *slot)
         u16 cmd_mask;
 
         slot_cmd = 0x0200;
-        cmd_mask = PWR_LED_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_PIC;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
 static int hpc_power_on_slot(struct slot * slot)
@@ -662,15 +529,15 @@ static int hpc_power_on_slot(struct slot * slot)
         ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
 
         /* Clear sticky power-fault bit from previous power failures */
-        retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
                          __func__);
                 return retval;
         }
-        slot_status &= PWR_FAULT_DETECTED;
+        slot_status &= PCI_EXP_SLTSTA_PFD;
         if (slot_status) {
-                retval = pciehp_writew(ctrl, SLOTSTATUS, slot_status);
+                retval = pciehp_writew(ctrl, PCI_EXP_SLTSTA, slot_status);
                 if (retval) {
                         ctrl_err(ctrl,
                                  "%s: Cannot write to SLOTSTATUS register\n",
@@ -680,13 +547,13 @@ static int hpc_power_on_slot(struct slot * slot)
         }
 
         slot_cmd = POWER_ON;
-        cmd_mask = PWR_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_PCC;
         /* Enable detection that we turned off at slot power-off time */
         if (!pciehp_poll_mode) {
-                slot_cmd |= (PWR_FAULT_DETECT_ENABLE | MRL_DETECT_ENABLE |
-                             PRSN_DETECT_ENABLE);
-                cmd_mask |= (PWR_FAULT_DETECT_ENABLE | MRL_DETECT_ENABLE |
-                             PRSN_DETECT_ENABLE);
+                slot_cmd |= (PCI_EXP_SLTCTL_PFDE | PCI_EXP_SLTCTL_MRLSCE |
+                             PCI_EXP_SLTCTL_PDCE);
+                cmd_mask |= (PCI_EXP_SLTCTL_PFDE | PCI_EXP_SLTCTL_MRLSCE |
+                             PCI_EXP_SLTCTL_PDCE);
         }
 
         retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
@@ -696,7 +563,7 @@ static int hpc_power_on_slot(struct slot * slot)
                 return -1;
         }
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 
         return retval;
 }
@@ -753,7 +620,7 @@ static int hpc_power_off_slot(struct slot * slot)
         changed = pcie_mask_bad_dllp(ctrl);
 
         slot_cmd = POWER_OFF;
-        cmd_mask = PWR_CTRL;
+        cmd_mask = PCI_EXP_SLTCTL_PCC;
         /*
          * If we get MRL or presence detect interrupts now, the isr
          * will notice the sticky power-fault bit too and issue power
@@ -762,10 +629,10 @@ static int hpc_power_off_slot(struct slot * slot)
          * till the slot is powered on again.
          */
         if (!pciehp_poll_mode) {
-                slot_cmd &= ~(PWR_FAULT_DETECT_ENABLE | MRL_DETECT_ENABLE |
-                              PRSN_DETECT_ENABLE);
-                cmd_mask |= (PWR_FAULT_DETECT_ENABLE | MRL_DETECT_ENABLE |
-                             PRSN_DETECT_ENABLE);
+                slot_cmd &= ~(PCI_EXP_SLTCTL_PFDE | PCI_EXP_SLTCTL_MRLSCE |
+                              PCI_EXP_SLTCTL_PDCE);
+                cmd_mask |= (PCI_EXP_SLTCTL_PFDE | PCI_EXP_SLTCTL_MRLSCE |
+                             PCI_EXP_SLTCTL_PDCE);
         }
 
         retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
@@ -775,7 +642,7 @@ static int hpc_power_off_slot(struct slot * slot)
                 goto out;
         }
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
-                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+                 __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
  out:
         if (changed)
                 pcie_unmask_bad_dllp(ctrl);
@@ -796,19 +663,19 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
          */
         intr_loc = 0;
         do {
-                if (pciehp_readw(ctrl, SLOTSTATUS, &detected)) {
+                if (pciehp_readw(ctrl, PCI_EXP_SLTSTA, &detected)) {
                         ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS\n",
                                  __func__);
                         return IRQ_NONE;
                 }
 
-                detected &= (ATTN_BUTTN_PRESSED | PWR_FAULT_DETECTED |
-                             MRL_SENS_CHANGED | PRSN_DETECT_CHANGED |
-                             CMD_COMPLETED);
+                detected &= (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
+                             PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
+                             PCI_EXP_SLTSTA_CC);
                 intr_loc |= detected;
                 if (!intr_loc)
                         return IRQ_NONE;
-                if (detected && pciehp_writew(ctrl, SLOTSTATUS, detected)) {
+                if (detected && pciehp_writew(ctrl, PCI_EXP_SLTSTA, detected)) {
                         ctrl_err(ctrl, "%s: Cannot write to SLOTSTATUS\n",
                                  __func__);
                         return IRQ_NONE;
@@ -818,31 +685,31 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         ctrl_dbg(ctrl, "%s: intr_loc %x\n", __func__, intr_loc);
 
         /* Check Command Complete Interrupt Pending */
-        if (intr_loc & CMD_COMPLETED) {
+        if (intr_loc & PCI_EXP_SLTSTA_CC) {
                 ctrl->cmd_busy = 0;
                 smp_mb();
                 wake_up(&ctrl->queue);
         }
 
-        if (!(intr_loc & ~CMD_COMPLETED))
+        if (!(intr_loc & ~PCI_EXP_SLTSTA_CC))
                 return IRQ_HANDLED;
 
         p_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
 
         /* Check MRL Sensor Changed */
-        if (intr_loc & MRL_SENS_CHANGED)
+        if (intr_loc & PCI_EXP_SLTSTA_MRLSC)
                 pciehp_handle_switch_change(p_slot);
 
         /* Check Attention Button Pressed */
-        if (intr_loc & ATTN_BUTTN_PRESSED)
+        if (intr_loc & PCI_EXP_SLTSTA_ABP)
                 pciehp_handle_attention_button(p_slot);
 
         /* Check Presence Detect Changed */
-        if (intr_loc & PRSN_DETECT_CHANGED)
+        if (intr_loc & PCI_EXP_SLTSTA_PDC)
                 pciehp_handle_presence_change(p_slot);
 
         /* Check Power Fault Detected */
-        if (intr_loc & PWR_FAULT_DETECTED)
+        if (intr_loc & PCI_EXP_SLTSTA_PFD)
                 pciehp_handle_power_fault(p_slot);
 
         return IRQ_HANDLED;
@@ -855,7 +722,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         u32     lnk_cap;
         int retval = 0;
 
-        retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
+        retval = pciehp_readl(ctrl, PCI_EXP_LNKCAP, &lnk_cap);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
                 return retval;
@@ -884,13 +751,13 @@ static int hpc_get_max_lnk_width(struct slot *slot,
         u32     lnk_cap;
         int retval = 0;
 
-        retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
+        retval = pciehp_readl(ctrl, PCI_EXP_LNKCAP, &lnk_cap);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
                 return retval;
         }
 
-        switch ((lnk_cap & 0x03F0) >> 4){
+        switch ((lnk_cap & PCI_EXP_LNKSTA_NLW) >> 4){
         case 0:
                 lnk_wdth = PCIE_LNK_WIDTH_RESRV;
                 break;
@@ -933,14 +800,14 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         int retval = 0;
         u16 lnk_status;
 
-        retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
                          __func__);
                 return retval;
         }
 
-        switch (lnk_status & 0x0F) {
+        switch (lnk_status & PCI_EXP_LNKSTA_CLS) {
         case 1:
                 lnk_speed = PCIE_2PT5GB;
                 break;
@@ -963,14 +830,14 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
         int retval = 0;
         u16 lnk_status;
 
-        retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
+        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
         if (retval) {
                 ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
                          __func__);
                 return retval;
         }
 
-        switch ((lnk_status & 0x03F0) >> 4){
+        switch ((lnk_status & PCI_EXP_LNKSTA_NLW) >> 4){
         case 0:
                 lnk_wdth = PCIE_LNK_WIDTH_RESRV;
                 break;
@@ -1036,18 +903,19 @@ int pcie_enable_notification(struct controller *ctrl)
 {
         u16 cmd, mask;
 
-        cmd = PRSN_DETECT_ENABLE;
+        cmd = PCI_EXP_SLTCTL_PDCE;
         if (ATTN_BUTTN(ctrl))
-                cmd |= ATTN_BUTTN_ENABLE;
+                cmd |= PCI_EXP_SLTCTL_ABPE;
         if (POWER_CTRL(ctrl))
-                cmd |= PWR_FAULT_DETECT_ENABLE;
+                cmd |= PCI_EXP_SLTCTL_PFDE;
         if (MRL_SENS(ctrl))
-                cmd |= MRL_DETECT_ENABLE;
+                cmd |= PCI_EXP_SLTCTL_MRLSCE;
         if (!pciehp_poll_mode)
-                cmd |= HP_INTR_ENABLE | CMD_CMPL_INTR_ENABLE;
+                cmd |= PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE;
 
-        mask = PRSN_DETECT_ENABLE | ATTN_BUTTN_ENABLE | MRL_DETECT_ENABLE |
-               PWR_FAULT_DETECT_ENABLE | HP_INTR_ENABLE | CMD_CMPL_INTR_ENABLE;
+        mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
+                PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
+                PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE);
 
         if (pcie_write_cmd(ctrl, cmd, mask)) {
                 ctrl_err(ctrl, "Cannot enable software notification\n");
@@ -1059,8 +927,9 @@ int pcie_enable_notification(struct controller *ctrl)
 static void pcie_disable_notification(struct controller *ctrl)
 {
         u16 mask;
-        mask = PRSN_DETECT_ENABLE | ATTN_BUTTN_ENABLE | MRL_DETECT_ENABLE |
-               PWR_FAULT_DETECT_ENABLE | HP_INTR_ENABLE | CMD_CMPL_INTR_ENABLE;
+        mask = (PCI_EXP_SLTCTL_PDCE | PCI_EXP_SLTCTL_ABPE |
+                PCI_EXP_SLTCTL_MRLSCE | PCI_EXP_SLTCTL_PFDE |
+                PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE);
         if (pcie_write_cmd(ctrl, 0, mask))
                 ctrl_warn(ctrl, "Cannot disable software notification\n");
 }
@@ -1157,9 +1026,9 @@ static inline void dbg_ctrl(struct controller *ctrl)
                   EMI(ctrl)        ? "yes" : "no");
         ctrl_info(ctrl, "  Command Completed    : %3s\n",
                   NO_CMD_CMPL(ctrl) ? "no" : "yes");
-        pciehp_readw(ctrl, SLOTSTATUS, &reg16);
+        pciehp_readw(ctrl, PCI_EXP_SLTSTA, &reg16);
         ctrl_info(ctrl, "Slot Status            : 0x%04x\n", reg16);
-        pciehp_readw(ctrl, SLOTCTRL, &reg16);
+        pciehp_readw(ctrl, PCI_EXP_SLTCTL, &reg16);
         ctrl_info(ctrl, "Slot Control           : 0x%04x\n", reg16);
 }
 
@@ -1183,7 +1052,7 @@ struct controller *pcie_init(struct pcie_device *dev)
                 ctrl_err(ctrl, "Cannot find PCI Express capability\n");
                 goto abort_ctrl;
         }
-        if (pciehp_readl(ctrl, SLOTCAP, &slot_cap)) {
+        if (pciehp_readl(ctrl, PCI_EXP_SLTCAP, &slot_cap)) {
                 ctrl_err(ctrl, "Cannot read SLOTCAP register\n");
                 goto abort_ctrl;
         }
@@ -1208,17 +1077,17 @@ struct controller *pcie_init(struct pcie_device *dev)
             ctrl->no_cmd_complete = 1;
 
         /* Check if Data Link Layer Link Active Reporting is implemented */
-        if (pciehp_readl(ctrl, LNKCAP, &link_cap)) {
+        if (pciehp_readl(ctrl, PCI_EXP_LNKCAP, &link_cap)) {
                 ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
                 goto abort_ctrl;
         }
-        if (link_cap & LINK_ACTIVE_REPORTING) {
+        if (link_cap & PCI_EXP_LNKCAP_DLLLARC) {
                 ctrl_dbg(ctrl, "Link Active Reporting supported\n");
                 ctrl->link_active_reporting = 1;
         }
 
         /* Clear all remaining event bits in Slot Status register */
-        if (pciehp_writew(ctrl, SLOTSTATUS, 0x1f))
+        if (pciehp_writew(ctrl, PCI_EXP_SLTSTA, 0x1f))
                 goto abort_ctrl;
 
         /* Disable sotfware notification */
diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index 9c2a22fed18b..4e3e0382c16e 100644
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -14,6 +14,9 @@
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
+
+#undef DEBUG
+
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/string.h>
@@ -151,20 +154,20 @@ static void dlpar_pci_add_bus(struct device_node *dn)
                 return;
         }
 
+        /* Scan below the new bridge */
         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
                 of_scan_pci_bridge(dn, dev);
 
-        pcibios_fixup_new_pci_devices(dev->subordinate);
-
-        /* Claim new bus resources */
-        pcibios_claim_one_bus(dev->bus);
-
         /* Map IO space for child bus, which may or may not succeed */
         pcibios_map_io_space(dev->subordinate);
 
-        /* Add new devices to global lists.  Register in proc, sysfs. */
-        pci_bus_add_devices(phb->bus);
+        /* Finish adding it : resource allocation, adding devices, etc...
+         * Note that we need to perform the finish pass on the -parent-
+         * bus of the EADS bridge so the bridge device itself gets
+         * properly added
+         */
+        pcibios_finish_adding_to_bus(phb->bus);
 }
 
 static int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
@@ -203,27 +206,6 @@ static int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
         return 0;
 }
 
-static int dlpar_remove_root_bus(struct pci_controller *phb)
-{
-        struct pci_bus *phb_bus;
-        int rc;
-
-        phb_bus = phb->bus;
-        if (!(list_empty(&phb_bus->children) &&
-              list_empty(&phb_bus->devices))) {
-                return -EBUSY;
-        }
-
-        rc = pcibios_remove_root_bus(phb);
-        if (rc)
-                return -EIO;
-
-        device_unregister(phb_bus->bridge);
-        pci_remove_bus(phb_bus);
-
-        return 0;
-}
-
 static int dlpar_remove_phb(char *drc_name, struct device_node *dn)
 {
         struct slot *slot;
@@ -235,18 +217,15 @@ static int dlpar_remove_phb(char *drc_name, struct device_node *dn)
 
         /* If pci slot is hotplugable, use hotplug to remove it */
         slot = find_php_slot(dn);
-        if (slot) {
-                if (rpaphp_deregister_slot(slot)) {
-                        printk(KERN_ERR
-                                "%s: unable to remove hotplug slot %s\n",
-                                __func__, drc_name);
-                        return -EIO;
-                }
+        if (slot && rpaphp_deregister_slot(slot)) {
+                printk(KERN_ERR "%s: unable to remove hotplug slot %s\n",
+                       __func__, drc_name);
+                return -EIO;
         }
 
         pdn = dn->data;
         BUG_ON(!pdn || !pdn->phb);
-        rc = dlpar_remove_root_bus(pdn->phb);
+        rc = remove_phb_dynamic(pdn->phb);
         if (rc < 0)
                 return rc;
 
@@ -378,26 +357,38 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
         if (!bus)
                 return -EINVAL;
 
-        /* If pci slot is hotplugable, use hotplug to remove it */
+        pr_debug("PCI: Removing PCI slot below EADS bridge %s\n",
+                 bus->self ? pci_name(bus->self) : "<!PHB!>");
+
         slot = find_php_slot(dn);
         if (slot) {
+                pr_debug("PCI: Removing hotplug slot for %04x:%02x...\n",
+                         pci_domain_nr(bus), bus->number);
+
                 if (rpaphp_deregister_slot(slot)) {
                         printk(KERN_ERR
                                 "%s: unable to remove hotplug slot %s\n",
                                 __func__, drc_name);
                         return -EIO;
                 }
-        } else
-                pcibios_remove_pci_devices(bus);
+        }
+
+        /* Remove all devices below slot */
+        pcibios_remove_pci_devices(bus);
 
+        /* Unmap PCI IO space */
         if (pcibios_unmap_io_space(bus)) {
                 printk(KERN_ERR "%s: failed to unmap bus range\n",
                         __func__);
                 return -ERANGE;
         }
 
+        /* Remove the EADS bridge device itself */
         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);
+
         return 0;
 }