12 files changed, 203 insertions, 333 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 0c138ba86526..e797c4d48cf1 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -257,12 +257,6 @@ W:	http://www.lesswatts.org/projects/acpi/
 S:      Supported
 F:      drivers/acpi/fan.c
 
-ACPI PCI HOTPLUG DRIVER
-M:      Kristen Carlson Accardi <kristen.c.accardi@intel.com>
-L:      linux-pci@vger.kernel.org
-S:      Supported
-F:      drivers/pci/hotplug/acpi*
-
 ACPI THERMAL DRIVER
 M:      Zhang Rui <rui.zhang@intel.com>
 L:      linux-acpi@vger.kernel.org
@@ -4005,11 +3999,11 @@ F:	Documentation/PCI/
 F:      drivers/pci/
 F:      include/linux/pci*
 
-PCIE HOTPLUG DRIVER
-M:      Kristen Carlson Accardi <kristen.c.accardi@intel.com>
+PCI HOTPLUG
+M:      Jesse Barnes <jbarnes@virtuousgeek.org>
 L:      linux-pci@vger.kernel.org
 S:      Supported
-F:      drivers/pci/pcie/
+F:      drivers/pci/hotplug
 
 PCMCIA SUBSYSTEM
 P:      Linux PCMCIA Team
@@ -4672,12 +4666,6 @@ F:	drivers/serial/serial_lh7a40x.c
 F:      drivers/usb/gadget/lh7a40*
 F:      drivers/usb/host/ohci-lh7a40*
 
-SHPC HOTPLUG DRIVER
-M:      Kristen Carlson Accardi <kristen.c.accardi@intel.com>
-L:      linux-pci@vger.kernel.org
-S:      Supported
-F:      drivers/pci/hotplug/shpchp*
-
 SIMPLE FIRMWARE INTERFACE (SFI)
 P:      Len Brown
 M:      lenb@kernel.org
@@ -4689,7 +4677,6 @@ F:	arch/x86/kernel/*sfi*
 F:      drivers/sfi/
 F:      include/linux/sfi*.h
 
-
 SIMTEC EB110ATX (Chalice CATS)
 P:      Ben Dooks
 M:      Vincent Sanders <support@simtec.co.uk>
diff --git a/arch/x86/include/asm/pci.h b/arch/x86/include/asm/pci.h
index f76a162c082c..ada8c201d513 100644
--- a/arch/x86/include/asm/pci.h
+++ b/arch/x86/include/asm/pci.h
@@ -143,7 +143,11 @@ static inline int __pcibus_to_node(const struct pci_bus *bus)
 static inline const struct cpumask *
 cpumask_of_pcibus(const struct pci_bus *bus)
 {
-        return cpumask_of_node(__pcibus_to_node(bus));
+        int node;
+
+        node = __pcibus_to_node(bus);
+        return (node == -1) ? cpu_online_mask :
+                              cpumask_of_node(node);
 }
 #endif
 
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
index 5db96d4304de..1331fcf26143 100644
--- a/arch/x86/pci/common.c
+++ b/arch/x86/pci/common.c
@@ -646,7 +646,7 @@ int get_mp_bus_to_node(int busnum)
 
 #else /* CONFIG_X86_32 */
 
-static unsigned char mp_bus_to_node[BUS_NR] = {
+static int mp_bus_to_node[BUS_NR] = {
         [0 ... BUS_NR - 1] = -1
 };
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 36faa9a8e18f..3070f77eb56a 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -72,15 +72,9 @@ do {									\
 
 #define SLOT_NAME_SIZE 10
 struct slot {
-        u8 bus;
-        u8 device;
         u8 state;
-        u8 hp_slot;
-        u32 number;
         struct controller *ctrl;
-        struct hpc_ops *hpc_ops;
         struct hotplug_slot *hotplug_slot;
-        struct list_head        slot_list;
         struct delayed_work work;       /* work for button event */
         struct mutex lock;
 };
@@ -92,18 +86,10 @@ struct event_info {
 };
 
 struct controller {
-        struct mutex crit_sect;         /* critical section mutex */
         struct mutex ctrl_lock;         /* controller lock */
-        int num_slots;                  /* Number of slots on ctlr */
-        int slot_num_inc;               /* 1 or -1 */
-        struct pci_dev *pci_dev;
         struct pcie_device *pcie;       /* PCI Express port service */
-        struct list_head slot_list;
-        struct hpc_ops *hpc_ops;
+        struct slot *slot;
         wait_queue_head_t queue;        /* sleep & wake process */
-        u8 slot_device_offset;
-        u32 first_slot;         /* First physical slot number */  /* PCIE only has 1 slot */
-        u8 slot_bus;            /* Bus where the slots handled by this controller sit */
         u32 slot_cap;
         u8 cap_base;
         struct timer_list poll_timer;
@@ -131,40 +117,20 @@ struct controller {
 #define POWERON_STATE                   3
 #define POWEROFF_STATE                  4
 
-/* Error messages */
-#define INTERLOCK_OPEN                  0x00000002
-#define ADD_NOT_SUPPORTED               0x00000003
-#define CARD_FUNCTIONING                0x00000005
-#define ADAPTER_NOT_SAME                0x00000006
-#define NO_ADAPTER_PRESENT              0x00000009
-#define NOT_ENOUGH_RESOURCES            0x0000000B
-#define DEVICE_TYPE_NOT_SUPPORTED       0x0000000C
-#define WRONG_BUS_FREQUENCY             0x0000000D
-#define POWER_FAILURE                   0x0000000E
-
-/* 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 EMI_PRSN        0x00020000
-#define NO_CMD_CMPL_SUP 0x00040000
-
-#define ATTN_BUTTN(ctrl)        ((ctrl)->slot_cap & ATTN_BUTTN_PRSN)
-#define POWER_CTRL(ctrl)        ((ctrl)->slot_cap & PWR_CTRL_PRSN)
-#define MRL_SENS(ctrl)          ((ctrl)->slot_cap & MRL_SENS_PRSN)
-#define ATTN_LED(ctrl)          ((ctrl)->slot_cap & ATTN_LED_PRSN)
-#define PWR_LED(ctrl)           ((ctrl)->slot_cap & PWR_LED_PRSN)
-#define HP_SUPR_RM(ctrl)        ((ctrl)->slot_cap & HP_SUPR_RM_SUP)
-#define EMI(ctrl)               ((ctrl)->slot_cap & EMI_PRSN)
-#define NO_CMD_CMPL(ctrl)       ((ctrl)->slot_cap & NO_CMD_CMPL_SUP)
+#define ATTN_BUTTN(ctrl)        ((ctrl)->slot_cap & PCI_EXP_SLTCAP_ABP)
+#define POWER_CTRL(ctrl)        ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PCP)
+#define MRL_SENS(ctrl)          ((ctrl)->slot_cap & PCI_EXP_SLTCAP_MRLSP)
+#define ATTN_LED(ctrl)          ((ctrl)->slot_cap & PCI_EXP_SLTCAP_AIP)
+#define PWR_LED(ctrl)           ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PIP)
+#define HP_SUPR_RM(ctrl)        ((ctrl)->slot_cap & PCI_EXP_SLTCAP_HPS)
+#define EMI(ctrl)               ((ctrl)->slot_cap & PCI_EXP_SLTCAP_EIP)
+#define NO_CMD_CMPL(ctrl)       ((ctrl)->slot_cap & PCI_EXP_SLTCAP_NCCS)
+#define PSN(ctrl)               ((ctrl)->slot_cap >> 19)
 
 extern int pciehp_sysfs_enable_slot(struct slot *slot);
 extern int pciehp_sysfs_disable_slot(struct slot *slot);
 extern u8 pciehp_handle_attention_button(struct slot *p_slot);
-  extern u8 pciehp_handle_switch_change(struct slot *p_slot);
+extern u8 pciehp_handle_switch_change(struct slot *p_slot);
 extern u8 pciehp_handle_presence_change(struct slot *p_slot);
 extern u8 pciehp_handle_power_fault(struct slot *p_slot);
 extern int pciehp_configure_device(struct slot *p_slot);
@@ -175,45 +141,30 @@ int pcie_init_notification(struct controller *ctrl);
 int pciehp_enable_slot(struct slot *p_slot);
 int pciehp_disable_slot(struct slot *p_slot);
 int pcie_enable_notification(struct controller *ctrl);
+int pciehp_power_on_slot(struct slot *slot);
+int pciehp_power_off_slot(struct slot *slot);
+int pciehp_get_power_status(struct slot *slot, u8 *status);
+int pciehp_get_attention_status(struct slot *slot, u8 *status);
+
+int pciehp_set_attention_status(struct slot *slot, u8 status);
+int pciehp_get_latch_status(struct slot *slot, u8 *status);
+int pciehp_get_adapter_status(struct slot *slot, u8 *status);
+int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *speed);
+int pciehp_get_max_link_width(struct slot *slot, enum pcie_link_width *val);
+int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *speed);
+int pciehp_get_cur_link_width(struct slot *slot, enum pcie_link_width *val);
+int pciehp_query_power_fault(struct slot *slot);
+void pciehp_green_led_on(struct slot *slot);
+void pciehp_green_led_off(struct slot *slot);
+void pciehp_green_led_blink(struct slot *slot);
+int pciehp_check_link_status(struct controller *ctrl);
+void pciehp_release_ctrl(struct controller *ctrl);
 
 static inline const char *slot_name(struct slot *slot)
 {
         return hotplug_slot_name(slot->hotplug_slot);
 }
 
-static inline struct slot *pciehp_find_slot(struct controller *ctrl, u8 device)
-{
-        struct slot *slot;
-
-        list_for_each_entry(slot, &ctrl->slot_list, slot_list) {
-                if (slot->device == device)
-                        return slot;
-        }
-
-        ctrl_err(ctrl, "Slot (device=0x%02x) not found\n", device);
-        return NULL;
-}
-
-struct hpc_ops {
-        int (*power_on_slot)(struct slot *slot);
-        int (*power_off_slot)(struct slot *slot);
-        int (*get_power_status)(struct slot *slot, u8 *status);
-        int (*get_attention_status)(struct slot *slot, u8 *status);
-        int (*set_attention_status)(struct slot *slot, u8 status);
-        int (*get_latch_status)(struct slot *slot, u8 *status);
-        int (*get_adapter_status)(struct slot *slot, u8 *status);
-        int (*get_max_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
-        int (*get_cur_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
-        int (*get_max_lnk_width)(struct slot *slot, enum pcie_link_width *val);
-        int (*get_cur_lnk_width)(struct slot *slot, enum pcie_link_width *val);
-        int (*query_power_fault)(struct slot *slot);
-        void (*green_led_on)(struct slot *slot);
-        void (*green_led_off)(struct slot *slot);
-        void (*green_led_blink)(struct slot *slot);
-        void (*release_ctlr)(struct controller *ctrl);
-        int (*check_lnk_status)(struct controller *ctrl);
-};
-
 #ifdef CONFIG_ACPI
 #include <acpi/acpi.h>
 #include <acpi/acpi_bus.h>
diff --git a/drivers/pci/hotplug/pciehp_acpi.c b/drivers/pci/hotplug/pciehp_acpi.c
index 7163e6a6cfae..37c8d3d0323e 100644
--- a/drivers/pci/hotplug/pciehp_acpi.c
+++ b/drivers/pci/hotplug/pciehp_acpi.c
@@ -33,6 +33,11 @@
 #define PCIEHP_DETECT_AUTO      (2)
 #define PCIEHP_DETECT_DEFAULT   PCIEHP_DETECT_AUTO
 
+struct dummy_slot {
+        u32 number;
+        struct list_head list;
+};
+
 static int slot_detection_mode;
 static char *pciehp_detect_mode;
 module_param(pciehp_detect_mode, charp, 0444);
@@ -77,7 +82,7 @@ static int __init dummy_probe(struct pcie_device *dev)
         int pos;
         u32 slot_cap;
         acpi_handle handle;
-        struct slot *slot, *tmp;
+        struct dummy_slot *slot, *tmp;
         struct pci_dev *pdev = dev->port;
         /* Note: pciehp_detect_mode != PCIEHP_DETECT_ACPI here */
         if (pciehp_get_hp_hw_control_from_firmware(pdev))
@@ -89,11 +94,11 @@ static int __init dummy_probe(struct pcie_device *dev)
         if (!slot)
                 return -ENOMEM;
         slot->number = slot_cap >> 19;
-        list_for_each_entry(tmp, &dummy_slots, slot_list) {
+        list_for_each_entry(tmp, &dummy_slots, list) {
                 if (tmp->number == slot->number)
                         dup_slot_id++;
         }
-        list_add_tail(&slot->slot_list, &dummy_slots);
+        list_add_tail(&slot->list, &dummy_slots);
         handle = DEVICE_ACPI_HANDLE(&pdev->dev);
         if (!acpi_slot_detected && acpi_pci_detect_ejectable(handle))
                 acpi_slot_detected = 1;
@@ -109,11 +114,11 @@ static struct pcie_port_service_driver __initdata dummy_driver = {
 
 static int __init select_detection_mode(void)
 {
-        struct slot *slot, *tmp;
+        struct dummy_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);
+        list_for_each_entry_safe(slot, tmp, &dummy_slots, list) {
+                list_del(&slot->list);
                 kfree(slot);
         }
         if (acpi_slot_detected && dup_slot_id)
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 2317557fdee6..bc234719b1df 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -99,65 +99,55 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
         kfree(hotplug_slot);
 }
 
-static int init_slots(struct controller *ctrl)
+static int init_slot(struct controller *ctrl)
 {
-        struct slot *slot;
-        struct hotplug_slot *hotplug_slot;
-        struct hotplug_slot_info *info;
+        struct slot *slot = ctrl->slot;
+        struct hotplug_slot *hotplug = NULL;
+        struct hotplug_slot_info *info = NULL;
         char name[SLOT_NAME_SIZE];
         int retval = -ENOMEM;
 
-        list_for_each_entry(slot, &ctrl->slot_list, slot_list) {
-                hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
-                if (!hotplug_slot)
-                        goto error;
-
-                info = kzalloc(sizeof(*info), GFP_KERNEL);
-                if (!info)
-                        goto error_hpslot;
-
-                /* register this slot with the hotplug pci core */
-                hotplug_slot->info = info;
-                hotplug_slot->private = slot;
-                hotplug_slot->release = &release_slot;
-                hotplug_slot->ops = &pciehp_hotplug_slot_ops;
-                slot->hotplug_slot = hotplug_slot;
-                snprintf(name, SLOT_NAME_SIZE, "%u", slot->number);
-
-                ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:%02x "
-                         "hp_slot=%x sun=%x slot_device_offset=%x\n",
-                         pci_domain_nr(ctrl->pci_dev->subordinate),
-                         slot->bus, slot->device, slot->hp_slot, slot->number,
-                         ctrl->slot_device_offset);
-                retval = pci_hp_register(hotplug_slot,
-                                         ctrl->pci_dev->subordinate,
-                                         slot->device,
-                                         name);
-                if (retval) {
-                        ctrl_err(ctrl, "pci_hp_register failed with error %d\n",
-                                 retval);
-                        goto error_info;
-                }
-                get_power_status(hotplug_slot, &info->power_status);
-                get_attention_status(hotplug_slot, &info->attention_status);
-                get_latch_status(hotplug_slot, &info->latch_status);
-                get_adapter_status(hotplug_slot, &info->adapter_status);
+        hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
+        if (!hotplug)
+                goto out;
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                goto out;
+
+        /* register this slot with the hotplug pci core */
+        hotplug->info = info;
+        hotplug->private = slot;
+        hotplug->release = &release_slot;
+        hotplug->ops = &pciehp_hotplug_slot_ops;
+        slot->hotplug_slot = hotplug;
+        snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
+
+        ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:00 sun=%x\n",
+                 pci_domain_nr(ctrl->pcie->port->subordinate),
+                 ctrl->pcie->port->subordinate->number, PSN(ctrl));
+        retval = pci_hp_register(hotplug,
+                                 ctrl->pcie->port->subordinate, 0, name);
+        if (retval) {
+                ctrl_err(ctrl,
+                         "pci_hp_register failed with error %d\n", retval);
+                goto out;
+        }
+        get_power_status(hotplug, &info->power_status);
+        get_attention_status(hotplug, &info->attention_status);
+        get_latch_status(hotplug, &info->latch_status);
+        get_adapter_status(hotplug, &info->adapter_status);
+out:
+        if (retval) {
+                kfree(info);
+                kfree(hotplug);
         }
-
-        return 0;
-error_info:
-        kfree(info);
-error_hpslot:
-        kfree(hotplug_slot);
-error:
         return retval;
 }
 
-static void cleanup_slots(struct controller *ctrl)
+static void cleanup_slot(struct controller *ctrl)
 {
-        struct slot *slot;
-        list_for_each_entry(slot, &ctrl->slot_list, slot_list)
-                pci_hp_deregister(slot->hotplug_slot);
+        pci_hp_deregister(ctrl->slot->hotplug_slot);
 }
 
 /*
@@ -173,7 +163,7 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
         hotplug_slot->info->attention_status = status;
 
         if (ATTN_LED(slot->ctrl))
-                slot->hpc_ops->set_attention_status(slot, status);
+                pciehp_set_attention_status(slot, status);
 
         return 0;
 }
@@ -208,7 +198,7 @@ static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_power_status(slot, value);
+        retval = pciehp_get_power_status(slot, value);
         if (retval < 0)
                 *value = hotplug_slot->info->power_status;
 
@@ -223,7 +213,7 @@ static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_attention_status(slot, value);
+        retval = pciehp_get_attention_status(slot, value);
         if (retval < 0)
                 *value = hotplug_slot->info->attention_status;
 
@@ -238,7 +228,7 @@ static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_latch_status(slot, value);
+        retval = pciehp_get_latch_status(slot, value);
         if (retval < 0)
                 *value = hotplug_slot->info->latch_status;
 
@@ -253,7 +243,7 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_adapter_status(slot, value);
+        retval = pciehp_get_adapter_status(slot, value);
         if (retval < 0)
                 *value = hotplug_slot->info->adapter_status;
 
@@ -269,7 +259,7 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_max_bus_speed(slot, value);
+        retval = pciehp_get_max_link_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
 
@@ -284,7 +274,7 @@ static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                  __func__, slot_name(slot));
 
-        retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
+        retval = pciehp_get_cur_link_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
 
@@ -295,7 +285,7 @@ static int pciehp_probe(struct pcie_device *dev)
 {
         int rc;
         struct controller *ctrl;
-        struct slot *t_slot;
+        struct slot *slot;
         u8 value;
         struct pci_dev *pdev = dev->port;
 
@@ -314,7 +304,7 @@ static int pciehp_probe(struct pcie_device *dev)
         set_service_data(dev, ctrl);
 
         /* Setup the slot information structures */
-        rc = init_slots(ctrl);
+        rc = init_slot(ctrl);
         if (rc) {
                 if (rc == -EBUSY)
                         ctrl_warn(ctrl, "Slot already registered by another "
@@ -332,15 +322,15 @@ static int pciehp_probe(struct pcie_device *dev)
         }
 
         /* Check if slot is occupied */
-        t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
-        t_slot->hpc_ops->get_adapter_status(t_slot, &value);
+        slot = ctrl->slot;
+        pciehp_get_adapter_status(slot, &value);
         if (value) {
                 if (pciehp_force)
-                        pciehp_enable_slot(t_slot);
+                        pciehp_enable_slot(slot);
         } else {
                 /* Power off slot if not occupied */
                 if (POWER_CTRL(ctrl)) {
-                        rc = t_slot->hpc_ops->power_off_slot(t_slot);
+                        rc = pciehp_power_off_slot(slot);
                         if (rc)
                                 goto err_out_free_ctrl_slot;
                 }
@@ -349,19 +339,19 @@ static int pciehp_probe(struct pcie_device *dev)
         return 0;
 
 err_out_free_ctrl_slot:
-        cleanup_slots(ctrl);
+        cleanup_slot(ctrl);
 err_out_release_ctlr:
-        ctrl->hpc_ops->release_ctlr(ctrl);
+        pciehp_release_ctrl(ctrl);
 err_out_none:
         return -ENODEV;
 }
 
-static void pciehp_remove (struct pcie_device *dev)
+static void pciehp_remove(struct pcie_device *dev)
 {
         struct controller *ctrl = get_service_data(dev);
 
-        cleanup_slots(ctrl);
-        ctrl->hpc_ops->release_ctlr(ctrl);
+        cleanup_slot(ctrl);
+        pciehp_release_ctrl(ctrl);
 }
 
 #ifdef CONFIG_PM
@@ -376,20 +366,20 @@ static int pciehp_resume (struct pcie_device *dev)
         dev_info(&dev->device, "%s ENTRY\n", __func__);
         if (pciehp_force) {
                 struct controller *ctrl = get_service_data(dev);
-                struct slot *t_slot;
+                struct slot *slot;
                 u8 status;
 
                 /* reinitialize the chipset's event detection logic */
                 pcie_enable_notification(ctrl);
 
-                t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
+                slot = ctrl->slot;
 
                 /* Check if slot is occupied */
-                t_slot->hpc_ops->get_adapter_status(t_slot, &status);
+                pciehp_get_adapter_status(slot, &status);
                 if (status)
-                        pciehp_enable_slot(t_slot);
+                        pciehp_enable_slot(slot);
                 else
-                        pciehp_disable_slot(t_slot);
+                        pciehp_disable_slot(slot);
         }
         return 0;
 }
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index b97cb4c3e0fe..84487d126e4d 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -82,7 +82,7 @@ u8 pciehp_handle_switch_change(struct slot *p_slot)
         /* Switch Change */
         ctrl_dbg(ctrl, "Switch interrupt received\n");
 
-        p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+        pciehp_get_latch_status(p_slot, &getstatus);
         if (getstatus) {
                 /*
                  * Switch opened
@@ -114,7 +114,7 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
         /* Switch is open, assume a presence change
          * Save the presence state
          */
-        p_slot->hpc_ops->get_adapter_status(p_slot, &presence_save);
+        pciehp_get_adapter_status(p_slot, &presence_save);
         if (presence_save) {
                 /*
                  * Card Present
@@ -143,7 +143,7 @@ u8 pciehp_handle_power_fault(struct slot *p_slot)
         /* power fault */
         ctrl_dbg(ctrl, "Power fault interrupt received\n");
 
-        if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
+        if (!pciehp_query_power_fault(p_slot)) {
                 /*
                  * power fault Cleared
                  */
@@ -172,7 +172,7 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 {
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl)) {
-                if (pslot->hpc_ops->power_off_slot(pslot)) {
+                if (pciehp_power_off_slot(pslot)) {
                         ctrl_err(ctrl,
                                  "Issue of Slot Power Off command failed\n");
                         return;
@@ -186,10 +186,10 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
         }
 
         if (PWR_LED(ctrl))
-                pslot->hpc_ops->green_led_off(pslot);
+                pciehp_green_led_off(pslot);
 
         if (ATTN_LED(ctrl)) {
-                if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
+                if (pciehp_set_attention_status(pslot, 1)) {
                         ctrl_err(ctrl,
                                  "Issue of Set Attention Led command failed\n");
                         return;
@@ -208,24 +208,20 @@ static int board_added(struct slot *p_slot)
 {
         int retval = 0;
         struct controller *ctrl = p_slot->ctrl;
-        struct pci_bus *parent = ctrl->pci_dev->subordinate;
-
-        ctrl_dbg(ctrl, "%s: slot device, slot offset, hp slot = %d, %d, %d\n",
-                 __func__, p_slot->device, ctrl->slot_device_offset,
-                 p_slot->hp_slot);
+        struct pci_bus *parent = ctrl->pcie->port->subordinate;
 
         if (POWER_CTRL(ctrl)) {
                 /* Power on slot */
-                retval = p_slot->hpc_ops->power_on_slot(p_slot);
+                retval = pciehp_power_on_slot(p_slot);
                 if (retval)
                         return retval;
         }
 
         if (PWR_LED(ctrl))
-                p_slot->hpc_ops->green_led_blink(p_slot);
+                pciehp_green_led_blink(p_slot);
 
         /* Check link training status */
-        retval = p_slot->hpc_ops->check_lnk_status(ctrl);
+        retval = pciehp_check_link_status(ctrl);
         if (retval) {
                 ctrl_err(ctrl, "Failed to check link status\n");
                 set_slot_off(ctrl, p_slot);
@@ -233,21 +229,21 @@ static int board_added(struct slot *p_slot)
         }
 
         /* Check for a power fault */
-        if (p_slot->hpc_ops->query_power_fault(p_slot)) {
+        if (pciehp_query_power_fault(p_slot)) {
                 ctrl_dbg(ctrl, "Power fault detected\n");
-                retval = POWER_FAILURE;
+                retval = -EIO;
                 goto err_exit;
         }
 
         retval = pciehp_configure_device(p_slot);
         if (retval) {
-                ctrl_err(ctrl, "Cannot add device at %04x:%02x:%02x\n",
-                         pci_domain_nr(parent), p_slot->bus, p_slot->device);
+                ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
+                         pci_domain_nr(parent), parent->number);
                 goto err_exit;
         }
 
         if (PWR_LED(ctrl))
-                p_slot->hpc_ops->green_led_on(p_slot);
+                pciehp_green_led_on(p_slot);
 
         return 0;
 
@@ -269,11 +265,9 @@ static int remove_board(struct slot *p_slot)
         if (retval)
                 return retval;
 
-        ctrl_dbg(ctrl, "%s: hp_slot = %d\n", __func__, p_slot->hp_slot);
-
         if (POWER_CTRL(ctrl)) {
                 /* power off slot */
-                retval = p_slot->hpc_ops->power_off_slot(p_slot);
+                retval = pciehp_power_off_slot(p_slot);
                 if (retval) {
                         ctrl_err(ctrl,
                                  "Issue of Slot Disable command failed\n");
@@ -287,9 +281,9 @@ static int remove_board(struct slot *p_slot)
                 msleep(1000);
         }
 
+        /* turn off Green LED */
         if (PWR_LED(ctrl))
-                /* turn off Green LED */
-                p_slot->hpc_ops->green_led_off(p_slot);
+                pciehp_green_led_off(p_slot);
 
         return 0;
 }
@@ -317,18 +311,17 @@ static void pciehp_power_thread(struct work_struct *work)
         case POWEROFF_STATE:
                 mutex_unlock(&p_slot->lock);
                 ctrl_dbg(p_slot->ctrl,
-                         "Disabling domain:bus:device=%04x:%02x:%02x\n",
-                         pci_domain_nr(p_slot->ctrl->pci_dev->subordinate),
-                         p_slot->bus, p_slot->device);
+                         "Disabling domain:bus:device=%04x:%02x:00\n",
+                         pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
+                         p_slot->ctrl->pcie->port->subordinate->number);
                 pciehp_disable_slot(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
                 break;
         case POWERON_STATE:
                 mutex_unlock(&p_slot->lock);
-                if (pciehp_enable_slot(p_slot) &&
-                    PWR_LED(p_slot->ctrl))
-                        p_slot->hpc_ops->green_led_off(p_slot);
+                if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
+                        pciehp_green_led_off(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
                 break;
@@ -379,10 +372,10 @@ static int update_slot_info(struct slot *slot)
         if (!info)
                 return -ENOMEM;
 
-        slot->hpc_ops->get_power_status(slot, &(info->power_status));
-        slot->hpc_ops->get_attention_status(slot, &(info->attention_status));
-        slot->hpc_ops->get_latch_status(slot, &(info->latch_status));
-        slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status));
+        pciehp_get_power_status(slot, &info->power_status);
+        pciehp_get_attention_status(slot, &info->attention_status);
+        pciehp_get_latch_status(slot, &info->latch_status);
+        pciehp_get_adapter_status(slot, &info->adapter_status);
 
         result = pci_hp_change_slot_info(slot->hotplug_slot, info);
         kfree (info);
@@ -399,7 +392,7 @@ static void handle_button_press_event(struct slot *p_slot)
 
         switch (p_slot->state) {
         case STATIC_STATE:
-                p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                pciehp_get_power_status(p_slot, &getstatus);
                 if (getstatus) {
                         p_slot->state = BLINKINGOFF_STATE;
                         ctrl_info(ctrl,
@@ -413,9 +406,9 @@ static void handle_button_press_event(struct slot *p_slot)
                 }
                 /* blink green LED and turn off amber */
                 if (PWR_LED(ctrl))
-                        p_slot->hpc_ops->green_led_blink(p_slot);
+                        pciehp_green_led_blink(p_slot);
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 0);
+                        pciehp_set_attention_status(p_slot, 0);
 
                 schedule_delayed_work(&p_slot->work, 5*HZ);
                 break;
@@ -430,13 +423,13 @@ static void handle_button_press_event(struct slot *p_slot)
                 cancel_delayed_work(&p_slot->work);
                 if (p_slot->state == BLINKINGOFF_STATE) {
                         if (PWR_LED(ctrl))
-                                p_slot->hpc_ops->green_led_on(p_slot);
+                                pciehp_green_led_on(p_slot);
                 } else {
                         if (PWR_LED(ctrl))
-                                p_slot->hpc_ops->green_led_off(p_slot);
+                                pciehp_green_led_off(p_slot);
                 }
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 0);
+                        pciehp_set_attention_status(p_slot, 0);
                 ctrl_info(ctrl, "PCI slot #%s - action canceled "
                           "due to button press\n", slot_name(p_slot));
                 p_slot->state = STATIC_STATE;
@@ -474,7 +467,7 @@ static void handle_surprise_event(struct slot *p_slot)
         info->p_slot = p_slot;
         INIT_WORK(&info->work, pciehp_power_thread);
 
-        p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+        pciehp_get_adapter_status(p_slot, &getstatus);
         if (!getstatus)
                 p_slot->state = POWEROFF_STATE;
         else
@@ -498,9 +491,9 @@ static void interrupt_event_handler(struct work_struct *work)
                 if (!POWER_CTRL(ctrl))
                         break;
                 if (ATTN_LED(ctrl))
-                        p_slot->hpc_ops->set_attention_status(p_slot, 1);
+                        pciehp_set_attention_status(p_slot, 1);
                 if (PWR_LED(ctrl))
-                        p_slot->hpc_ops->green_led_off(p_slot);
+                        pciehp_green_led_off(p_slot);
                 break;
         case INT_PRESENCE_ON:
         case INT_PRESENCE_OFF:
@@ -525,45 +518,38 @@ int pciehp_enable_slot(struct slot *p_slot)
         int rc;
         struct controller *ctrl = p_slot->ctrl;
 
-        /* Check to see if (latch closed, card present, power off) */
-        mutex_lock(&p_slot->ctrl->crit_sect);
-
-        rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+        rc = pciehp_get_adapter_status(p_slot, &getstatus);
         if (rc || !getstatus) {
                 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
-                mutex_unlock(&p_slot->ctrl->crit_sect);
                 return -ENODEV;
         }
         if (MRL_SENS(p_slot->ctrl)) {
-                rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                rc = pciehp_get_latch_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                rc = pciehp_get_power_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         ctrl_info(ctrl, "Already enabled on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
         }
 
-        p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+        pciehp_get_latch_status(p_slot, &getstatus);
 
         rc = board_added(p_slot);
         if (rc) {
-                p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                pciehp_get_latch_status(p_slot, &getstatus);
         }
 
         update_slot_info(p_slot);
 
-        mutex_unlock(&p_slot->ctrl->crit_sect);
         return rc;
 }
 
@@ -577,35 +563,29 @@ int pciehp_disable_slot(struct slot *p_slot)
         if (!p_slot->ctrl)
                 return 1;
 
-        /* Check to see if (latch closed, card present, power on) */
-        mutex_lock(&p_slot->ctrl->crit_sect);
-
         if (!HP_SUPR_RM(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+                ret = pciehp_get_adapter_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         ctrl_info(ctrl, "No adapter on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (MRL_SENS(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+                ret = pciehp_get_latch_status(p_slot, &getstatus);
                 if (ret || getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                ret = pciehp_get_power_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         ctrl_info(ctrl, "Already disabled on slot(%s)\n",
                                   slot_name(p_slot));
-                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
         }
@@ -613,7 +593,6 @@ int pciehp_disable_slot(struct slot *p_slot)
         ret = remove_board(p_slot);
         update_slot_info(p_slot);
 
-        mutex_unlock(&p_slot->ctrl->crit_sect);
         return ret;
 }
 
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 271f917b6f2c..9ef4605c1ef6 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -44,25 +44,25 @@ static atomic_t pciehp_num_controllers = ATOMIC_INIT(0);
 
 static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         return pci_read_config_word(dev, ctrl->cap_base + reg, value);
 }
 
 static inline int pciehp_readl(struct controller *ctrl, int reg, u32 *value)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         return pci_read_config_dword(dev, ctrl->cap_base + reg, value);
 }
 
 static inline int pciehp_writew(struct controller *ctrl, int reg, u16 value)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         return pci_write_config_word(dev, ctrl->cap_base + reg, value);
 }
 
 static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         return pci_write_config_dword(dev, ctrl->cap_base + reg, value);
 }
 
@@ -266,7 +266,7 @@ static void pcie_wait_link_active(struct controller *ctrl)
         ctrl_dbg(ctrl, "Data Link Layer Link Active not set in 1000 msec\n");
 }
 
-static int hpc_check_lnk_status(struct controller *ctrl)
+int pciehp_check_link_status(struct controller *ctrl)
 {
         u16 lnk_status;
         int retval = 0;
@@ -305,7 +305,7 @@ static int hpc_check_lnk_status(struct controller *ctrl)
         return retval;
 }
 
-static int hpc_get_attention_status(struct slot *slot, u8 *status)
+int pciehp_get_attention_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_ctrl;
@@ -344,7 +344,7 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
         return 0;
 }
 
-static int hpc_get_power_status(struct slot *slot, u8 *status)
+int pciehp_get_power_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_ctrl;
@@ -376,7 +376,7 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
         return retval;
 }
 
-static int hpc_get_latch_status(struct slot *slot, u8 *status)
+int pciehp_get_latch_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
@@ -392,7 +392,7 @@ static int hpc_get_latch_status(struct slot *slot, u8 *status)
         return 0;
 }
 
-static int hpc_get_adapter_status(struct slot *slot, u8 *status)
+int pciehp_get_adapter_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
@@ -408,7 +408,7 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
         return 0;
 }
 
-static int hpc_query_power_fault(struct slot *slot)
+int pciehp_query_power_fault(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_status;
@@ -422,7 +422,7 @@ static int hpc_query_power_fault(struct slot *slot)
         return !!(slot_status & PCI_EXP_SLTSTA_PFD);
 }
 
-static int hpc_set_attention_status(struct slot *slot, u8 value)
+int pciehp_set_attention_status(struct slot *slot, u8 value)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -450,7 +450,7 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
         return rc;
 }
 
-static void hpc_set_green_led_on(struct slot *slot)
+void pciehp_green_led_on(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -463,7 +463,7 @@ static void hpc_set_green_led_on(struct slot *slot)
                  __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
-static void hpc_set_green_led_off(struct slot *slot)
+void pciehp_green_led_off(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -476,7 +476,7 @@ static void hpc_set_green_led_off(struct slot *slot)
                  __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
-static void hpc_set_green_led_blink(struct slot *slot)
+void pciehp_green_led_blink(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -489,7 +489,7 @@ static void hpc_set_green_led_blink(struct slot *slot)
                  __func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
 }
 
-static int hpc_power_on_slot(struct slot * slot)
+int pciehp_power_on_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -497,8 +497,6 @@ static int hpc_power_on_slot(struct slot * slot)
         u16 slot_status;
         int retval = 0;
 
-        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, PCI_EXP_SLTSTA, &slot_status);
         if (retval) {
@@ -539,7 +537,7 @@ static int hpc_power_on_slot(struct slot * slot)
 
 static inline int pcie_mask_bad_dllp(struct controller *ctrl)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         int pos;
         u32 reg;
 
@@ -556,7 +554,7 @@ static inline int pcie_mask_bad_dllp(struct controller *ctrl)
 
 static inline void pcie_unmask_bad_dllp(struct controller *ctrl)
 {
-        struct pci_dev *dev = ctrl->pci_dev;
+        struct pci_dev *dev = ctrl->pcie->port;
         u32 reg;
         int pos;
 
@@ -570,7 +568,7 @@ static inline void pcie_unmask_bad_dllp(struct controller *ctrl)
         pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg);
 }
 
-static int hpc_power_off_slot(struct slot * slot)
+int pciehp_power_off_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
@@ -578,8 +576,6 @@ static int hpc_power_off_slot(struct slot * slot)
         int retval = 0;
         int changed;
 
-        ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
-
         /*
          * Set Bad DLLP Mask bit in Correctable Error Mask
          * Register. This is the workaround against Bad DLLP error
@@ -614,8 +610,8 @@ static int hpc_power_off_slot(struct slot * slot)
 static irqreturn_t pcie_isr(int irq, void *dev_id)
 {
         struct controller *ctrl = (struct controller *)dev_id;
+        struct slot *slot = ctrl->slot;
         u16 detected, intr_loc;
-        struct slot *p_slot;
 
         /*
          * In order to guarantee that all interrupt events are
@@ -656,29 +652,27 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         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 & PCI_EXP_SLTSTA_MRLSC)
-                pciehp_handle_switch_change(p_slot);
+                pciehp_handle_switch_change(slot);
 
         /* Check Attention Button Pressed */
         if (intr_loc & PCI_EXP_SLTSTA_ABP)
-                pciehp_handle_attention_button(p_slot);
+                pciehp_handle_attention_button(slot);
 
         /* Check Presence Detect Changed */
         if (intr_loc & PCI_EXP_SLTSTA_PDC)
-                pciehp_handle_presence_change(p_slot);
+                pciehp_handle_presence_change(slot);
 
         /* Check Power Fault Detected */
         if ((intr_loc & PCI_EXP_SLTSTA_PFD) && !ctrl->power_fault_detected) {
                 ctrl->power_fault_detected = 1;
-                pciehp_handle_power_fault(p_slot);
+                pciehp_handle_power_fault(slot);
         }
         return IRQ_HANDLED;
 }
 
-static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
+int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_speed lnk_speed;
@@ -709,7 +703,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         return retval;
 }
 
-static int hpc_get_max_lnk_width(struct slot *slot,
+int pciehp_get_max_lnk_width(struct slot *slot,
                                  enum pcie_link_width *value)
 {
         struct controller *ctrl = slot->ctrl;
@@ -759,7 +753,7 @@ static int hpc_get_max_lnk_width(struct slot *slot,
         return retval;
 }
 
-static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
+int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *value)
 {
         struct controller *ctrl = slot->ctrl;
         enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
@@ -791,7 +785,7 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         return retval;
 }
 
-static int hpc_get_cur_lnk_width(struct slot *slot,
+int pciehp_get_cur_lnk_width(struct slot *slot,
                                  enum pcie_link_width *value)
 {
         struct controller *ctrl = slot->ctrl;
@@ -842,30 +836,6 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
         return retval;
 }
 
-static void pcie_release_ctrl(struct controller *ctrl);
-static struct hpc_ops pciehp_hpc_ops = {
-        .power_on_slot                  = hpc_power_on_slot,
-        .power_off_slot                 = hpc_power_off_slot,
-        .set_attention_status           = hpc_set_attention_status,
-        .get_power_status               = hpc_get_power_status,
-        .get_attention_status           = hpc_get_attention_status,
-        .get_latch_status               = hpc_get_latch_status,
-        .get_adapter_status             = hpc_get_adapter_status,
-
-        .get_max_bus_speed              = hpc_get_max_lnk_speed,
-        .get_cur_bus_speed              = hpc_get_cur_lnk_speed,
-        .get_max_lnk_width              = hpc_get_max_lnk_width,
-        .get_cur_lnk_width              = hpc_get_cur_lnk_width,
-
-        .query_power_fault              = hpc_query_power_fault,
-        .green_led_on                   = hpc_set_green_led_on,
-        .green_led_off                  = hpc_set_green_led_off,
-        .green_led_blink                = hpc_set_green_led_blink,
-
-        .release_ctlr                   = pcie_release_ctrl,
-        .check_lnk_status               = hpc_check_lnk_status,
-};
-
 int pcie_enable_notification(struct controller *ctrl)
 {
         u16 cmd, mask;
@@ -930,23 +900,16 @@ static int pcie_init_slot(struct controller *ctrl)
         if (!slot)
                 return -ENOMEM;
 
-        slot->hp_slot = 0;
         slot->ctrl = ctrl;
-        slot->bus = ctrl->pci_dev->subordinate->number;
-        slot->device = ctrl->slot_device_offset + slot->hp_slot;
-        slot->hpc_ops = ctrl->hpc_ops;
-        slot->number = ctrl->first_slot;
         mutex_init(&slot->lock);
         INIT_DELAYED_WORK(&slot->work, pciehp_queue_pushbutton_work);
-        list_add(&slot->slot_list, &ctrl->slot_list);
+        ctrl->slot = slot;
         return 0;
 }
 
 static void pcie_cleanup_slot(struct controller *ctrl)
 {
-        struct slot *slot;
-        slot = list_first_entry(&ctrl->slot_list, struct slot, slot_list);
-        list_del(&slot->slot_list);
+        struct slot *slot = ctrl->slot;
         cancel_delayed_work(&slot->work);
         flush_scheduled_work();
         flush_workqueue(pciehp_wq);
@@ -957,7 +920,7 @@ static inline void dbg_ctrl(struct controller *ctrl)
 {
         int i;
         u16 reg16;
-        struct pci_dev *pdev = ctrl->pci_dev;
+        struct pci_dev *pdev = ctrl->pcie->port;
 
         if (!pciehp_debug)
                 return;
@@ -980,7 +943,7 @@ static inline void dbg_ctrl(struct controller *ctrl)
                           (unsigned long long)pci_resource_start(pdev, i));
         }
         ctrl_info(ctrl, "Slot Capabilities      : 0x%08x\n", ctrl->slot_cap);
-        ctrl_info(ctrl, "  Physical Slot Number : %d\n", ctrl->first_slot);
+        ctrl_info(ctrl, "  Physical Slot Number : %d\n", PSN(ctrl));
         ctrl_info(ctrl, "  Attention Button     : %3s\n",
                   ATTN_BUTTN(ctrl) ? "yes" : "no");
         ctrl_info(ctrl, "  Power Controller     : %3s\n",
@@ -1014,10 +977,7 @@ struct controller *pcie_init(struct pcie_device *dev)
                 dev_err(&dev->device, "%s: Out of memory\n", __func__);
                 goto abort;
         }
-        INIT_LIST_HEAD(&ctrl->slot_list);
-
         ctrl->pcie = dev;
-        ctrl->pci_dev = pdev;
         ctrl->cap_base = pci_find_capability(pdev, PCI_CAP_ID_EXP);
         if (!ctrl->cap_base) {
                 ctrl_err(ctrl, "Cannot find PCI Express capability\n");
@@ -1029,11 +989,6 @@ struct controller *pcie_init(struct pcie_device *dev)
         }
 
         ctrl->slot_cap = slot_cap;
-        ctrl->first_slot = slot_cap >> 19;
-        ctrl->slot_device_offset = 0;
-        ctrl->num_slots = 1;
-        ctrl->hpc_ops = &pciehp_hpc_ops;
-        mutex_init(&ctrl->crit_sect);
         mutex_init(&ctrl->ctrl_lock);
         init_waitqueue_head(&ctrl->queue);
         dbg_ctrl(ctrl);
@@ -1089,7 +1044,7 @@ abort:
         return NULL;
 }
 
-void pcie_release_ctrl(struct controller *ctrl)
+void pciehp_release_ctrl(struct controller *ctrl)
 {
         pcie_shutdown_notification(ctrl);
         pcie_cleanup_slot(ctrl);
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 02e24d63b3ee..21733108adde 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -63,27 +63,27 @@ static int __ref pciehp_add_bridge(struct pci_dev *dev)
 int pciehp_configure_device(struct slot *p_slot)
 {
         struct pci_dev *dev;
-        struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
+        struct pci_bus *parent = p_slot->ctrl->pcie->port->subordinate;
         int num, fn;
         struct controller *ctrl = p_slot->ctrl;
 
-        dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
+        dev = pci_get_slot(parent, PCI_DEVFN(0, 0));
         if (dev) {
                 ctrl_err(ctrl, "Device %s already exists "
-                         "at %04x:%02x:%02x, cannot hot-add\n", pci_name(dev),
-                         pci_domain_nr(parent), p_slot->bus, p_slot->device);
+                         "at %04x:%02x:00, cannot hot-add\n", pci_name(dev),
+                         pci_domain_nr(parent), parent->number);
                 pci_dev_put(dev);
                 return -EINVAL;
         }
 
-        num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
+        num = pci_scan_slot(parent, PCI_DEVFN(0, 0));
         if (num == 0) {
                 ctrl_err(ctrl, "No new device found\n");
                 return -ENODEV;
         }
 
         for (fn = 0; fn < 8; fn++) {
-                dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, fn));
+                dev = pci_get_slot(parent, PCI_DEVFN(0, fn));
                 if (!dev)
                         continue;
                 if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
@@ -111,19 +111,18 @@ int pciehp_unconfigure_device(struct slot *p_slot)
         int j;
         u8 bctl = 0;
         u8 presence = 0;
-        struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
+        struct pci_bus *parent = p_slot->ctrl->pcie->port->subordinate;
         u16 command;
         struct controller *ctrl = p_slot->ctrl;
 
-        ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:%02x\n",
-                 __func__, pci_domain_nr(parent), p_slot->bus, p_slot->device);
-        ret = p_slot->hpc_ops->get_adapter_status(p_slot, &presence);
+        ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:00\n",
+                 __func__, pci_domain_nr(parent), parent->number);
+        ret = pciehp_get_adapter_status(p_slot, &presence);
         if (ret)
                 presence = 0;
 
         for (j = 0; j < 8; j++) {
-                struct pci_dev* temp = pci_get_slot(parent,
-                                (p_slot->device << 3) | j);
+                struct pci_dev* temp = pci_get_slot(parent, PCI_DEVFN(0, j));
                 if (!temp)
                         continue;
                 if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
diff --git a/drivers/pci/pcie/aer/aerdrv.c b/drivers/pci/pcie/aer/aerdrv.c
index 10c0e62bd5a8..2ce8f9ccc66e 100644
--- a/drivers/pci/pcie/aer/aerdrv.c
+++ b/drivers/pci/pcie/aer/aerdrv.c
@@ -318,6 +318,8 @@ static int __init aer_service_init(void)
 {
         if (pcie_aer_disable)
                 return -ENXIO;
+        if (!pci_msi_enabled())
+                return -ENXIO;
         return pcie_port_service_register(&aerdriver);
 }
 
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index f289ca9bf18d..745402e8e498 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -303,9 +303,6 @@ static void pcie_get_aspm_reg(struct pci_dev *pdev,
         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
         pci_read_config_dword(pdev, pos + PCI_EXP_LNKCAP, &reg32);
         info->support = (reg32 & PCI_EXP_LNKCAP_ASPMS) >> 10;
-        /* 00b and 10b are defined as "Reserved". */
-        if (info->support == PCIE_LINK_STATE_L1)
-                info->support = 0;
         info->latency_encoding_l0s = (reg32 & PCI_EXP_LNKCAP_L0SEL) >> 12;
         info->latency_encoding_l1  = (reg32 & PCI_EXP_LNKCAP_L1EL) >> 15;
         pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
diff --git a/include/linux/vgaarb.h b/include/linux/vgaarb.h
index 923f9040ea20..2dfaa293ae8c 100644
--- a/include/linux/vgaarb.h
+++ b/include/linux/vgaarb.h
@@ -1,5 +1,6 @@
 /*
- * vgaarb.c
+ * The VGA aribiter manages VGA space routing and VGA resource decode to
+ * allow multiple VGA devices to be used in a system in a safe way.
  *
  * (C) Copyright 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>
  * (C) Copyright 2007 Paulo R. Zanoni <przanoni@gmail.com>