Merge tag 'pci-v3.14-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci

Pull PCI updates from Bjorn Helgaas:
 "PCI changes for the v3.14 merge window:

  Resource management
    - Change pci_bus_region addresses to dma_addr_t (Bjorn Helgaas)
    - Support 64-bit AGP BARs (Bjorn Helgaas, Yinghai Lu)
    - Add pci_bus_address() to get bus address of a BAR (Bjorn Helgaas)
    - Use pci_resource_start() for CPU address of AGP BARs (Bjorn Helgaas)
    - Enforce bus address limits in resource allocation (Yinghai Lu)
    - Allocate 64-bit BARs above 4G when possible (Yinghai Lu)
    - Convert pcibios_resource_to_bus() to take pci_bus, not pci_dev (Yinghai Lu)

  PCI device hotplug
    - Major rescan/remove locking update (Rafael J. Wysocki)
    - Make ioapic builtin only (not modular) (Yinghai Lu)
    - Fix release/free issues (Yinghai Lu)
    - Clean up pciehp (Bjorn Helgaas)
    - Announce pciehp slot info during enumeration (Bjorn Helgaas)

  MSI
    - Add pci_msi_vec_count(), pci_msix_vec_count() (Alexander Gordeev)
    - Add pci_enable_msi_range(), pci_enable_msix_range() (Alexander Gordeev)
    - Deprecate "tri-state" interfaces: fail/success/fail+info (Alexander Gordeev)
    - Export MSI mode using attributes, not kobjects (Greg Kroah-Hartman)
    - Drop "irq" param from *_restore_msi_irqs() (DuanZhenzhong)

  SR-IOV
    - Clear NumVFs when disabling SR-IOV in sriov_init() (ethan.zhao)

  Virtualization
    - Add support for save/restore of extended capabilities (Alex Williamson)
    - Add Virtual Channel to save/restore support (Alex Williamson)
    - Never treat a VF as a multifunction device (Alex Williamson)
    - Add pci_try_reset_function(), et al (Alex Williamson)

  AER
    - Ignore non-PCIe error sources (Betty Dall)
    - Support ACPI HEST error sources for domains other than 0 (Betty Dall)
    - Consolidate HEST error source parsers (Bjorn Helgaas)
    - Add a TLP header print helper (Borislav Petkov)

  Freescale i.MX6
    - Remove unnecessary code (Fabio Estevam)
    - Make reset-gpio optional (Marek Vasut)
    - Report "link up" only after link training completes (Marek Vasut)
    - Start link in Gen1 before negotiating for Gen2 mode (Marek Vasut)
    - Fix PCIe startup code (Richard Zhu)

  Marvell MVEBU
    - Remove duplicate of_clk_get_by_name() call (Andrew Lunn)
    - Drop writes to bridge Secondary Status register (Jason Gunthorpe)
    - Obey bridge PCI_COMMAND_MEM and PCI_COMMAND_IO bits (Jason Gunthorpe)
    - Support a bridge with no IO port window (Jason Gunthorpe)
    - Use max_t() instead of max(resource_size_t,) (Jingoo Han)
    - Remove redundant of_match_ptr (Sachin Kamat)
    - Call pci_ioremap_io() at startup instead of dynamically (Thomas Petazzoni)

  NVIDIA Tegra
    - Disable Gen2 for Tegra20 and Tegra30 (Eric Brower)

  Renesas R-Car
    - Add runtime PM support (Valentine Barshak)
    - Fix rcar_pci_probe() return value check (Wei Yongjun)

  Synopsys DesignWare
    - Fix crash in dw_msi_teardown_irq() (Bjørn Erik Nilsen)
    - Remove redundant call to pci_write_config_word() (Bjørn Erik Nilsen)
    - Fix missing MSI IRQs (Harro Haan)
    - Add dw_pcie prefix before cfg_read/write (Pratyush Anand)
    - Fix I/O transfers by using CPU (not realio) address (Pratyush Anand)
    - Whitespace cleanup (Jingoo Han)

  EISA
    - Call put_device() if device_register() fails (Levente Kurusa)
    - Revert EISA initialization breakage ((Bjorn Helgaas)

  Miscellaneous
    - Remove unused code, including PCIe 3.0 interfaces (Stephen Hemminger)
    - Prevent bus conflicts while checking for bridge apertures (Bjorn Helgaas)
    - Stop clearing bridge Secondary Status when setting up I/O aperture (Bjorn Helgaas)
    - Use dev_is_pci() to identify PCI devices (Yijing Wang)
    - Deprecate DEFINE_PCI_DEVICE_TABLE (Joe Perches)
    - Update documentation 00-INDEX (Erik Ekman)"

* tag 'pci-v3.14-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci: (119 commits)
  Revert "EISA: Initialize device before its resources"
  Revert "EISA: Log device resources in dmesg"
  vfio-pci: Use pci "try" reset interface
  PCI: Check parent kobject in pci_destroy_dev()
  xen/pcifront: Use global PCI rescan-remove locking
  powerpc/eeh: Use global PCI rescan-remove locking
  PCI: Fix pci_check_and_unmask_intx() comment typos
  PCI: Add pci_try_reset_function(), pci_try_reset_slot(), pci_try_reset_bus()
  MPT / PCI: Use pci_stop_and_remove_bus_device_locked()
  platform / x86: Use global PCI rescan-remove locking
  PCI: hotplug: Use global PCI rescan-remove locking
  pcmcia: Use global PCI rescan-remove locking
  ACPI / hotplug / PCI: Use global PCI rescan-remove locking
  ACPI / PCI: Use global PCI rescan-remove locking in PCI root hotplug
  PCI: Add global pci_lock_rescan_remove()
  PCI: Cleanup pci.h whitespace
  PCI: Reorder so actual code comes before stubs
  PCI/AER: Support ACPI HEST AER error sources for PCI domains other than 0
  ACPICA: Add helper macros to extract bus/segment numbers from HEST table.
  PCI: Make local functions static
  ...

16 files changed, 304 insertions, 356 deletions

diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index 1592dbe4f904..b6162be4df40 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -77,6 +77,8 @@ struct acpiphp_bridge {
 
         /* PCI-to-PCI bridge device */
         struct pci_dev *pci_dev;
+
+        bool is_going_away;
 };
 
 
@@ -150,6 +152,7 @@ struct acpiphp_attention_info
 /* slot flags */
 
 #define SLOT_ENABLED            (0x00000001)
+#define SLOT_IS_GOING_AWAY      (0x00000002)
 
 /* function flags */
 
@@ -169,7 +172,7 @@ void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *slot);
 typedef int (*acpiphp_callback)(struct acpiphp_slot *slot, void *data);
 
 int acpiphp_enable_slot(struct acpiphp_slot *slot);
-int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot);
+int acpiphp_disable_slot(struct acpiphp_slot *slot);
 u8 acpiphp_get_power_status(struct acpiphp_slot *slot);
 u8 acpiphp_get_attention_status(struct acpiphp_slot *slot);
 u8 acpiphp_get_latch_status(struct acpiphp_slot *slot);
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index dca66bc44578..728c31f4c2c5 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -156,7 +156,7 @@ static int disable_slot(struct hotplug_slot *hotplug_slot)
         pr_debug("%s - physical_slot = %s\n", __func__, slot_name(slot));
 
         /* disable the specified slot */
-        return acpiphp_disable_and_eject_slot(slot->acpi_slot);
+        return acpiphp_disable_slot(slot->acpi_slot);
 }
 
 
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index e86439283a5d..ee26bac2d378 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -432,6 +432,7 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
                                         pr_err("failed to remove notify handler\n");
                         }
                 }
+                slot->flags |= SLOT_IS_GOING_AWAY;
                 if (slot->slot)
                         acpiphp_unregister_hotplug_slot(slot);
         }
@@ -439,6 +440,8 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
         mutex_lock(&bridge_mutex);
         list_del(&bridge->list);
         mutex_unlock(&bridge_mutex);
+
+        bridge->is_going_away = true;
 }
 
 /**
@@ -757,6 +760,10 @@ static void acpiphp_check_bridge(struct acpiphp_bridge *bridge)
 {
         struct acpiphp_slot *slot;
 
+        /* Bail out if the bridge is going away. */
+        if (bridge->is_going_away)
+                return;
+
         list_for_each_entry(slot, &bridge->slots, node) {
                 struct pci_bus *bus = slot->bus;
                 struct pci_dev *dev, *tmp;
@@ -827,6 +834,8 @@ void acpiphp_check_host_bridge(acpi_handle handle)
         }
 }
 
+static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot);
+
 static void hotplug_event(acpi_handle handle, u32 type, void *data)
 {
         struct acpiphp_context *context = data;
@@ -856,6 +865,9 @@ static void hotplug_event(acpi_handle handle, u32 type, void *data)
                 } else {
                         struct acpiphp_slot *slot = func->slot;
 
+                        if (slot->flags & SLOT_IS_GOING_AWAY)
+                                break;
+
                         mutex_lock(&slot->crit_sect);
                         enable_slot(slot);
                         mutex_unlock(&slot->crit_sect);
@@ -871,6 +883,9 @@ static void hotplug_event(acpi_handle handle, u32 type, void *data)
                         struct acpiphp_slot *slot = func->slot;
                         int ret;
 
+                        if (slot->flags & SLOT_IS_GOING_AWAY)
+                                break;
+
                         /*
                          * Check if anything has changed in the slot and rescan
                          * from the parent if that's the case.
@@ -900,9 +915,11 @@ static void hotplug_event_work(void *data, u32 type)
         acpi_handle handle = context->handle;
 
         acpi_scan_lock_acquire();
+        pci_lock_rescan_remove();
 
         hotplug_event(handle, type, context);
 
+        pci_unlock_rescan_remove();
         acpi_scan_lock_release();
         acpi_evaluate_hotplug_ost(handle, type, ACPI_OST_SC_SUCCESS, NULL);
         put_bridge(context->func.parent);
@@ -1070,12 +1087,19 @@ void acpiphp_remove_slots(struct pci_bus *bus)
  */
 int acpiphp_enable_slot(struct acpiphp_slot *slot)
 {
+        pci_lock_rescan_remove();
+
+        if (slot->flags & SLOT_IS_GOING_AWAY)
+                return -ENODEV;
+
         mutex_lock(&slot->crit_sect);
         /* configure all functions */
         if (!(slot->flags & SLOT_ENABLED))
                 enable_slot(slot);
 
         mutex_unlock(&slot->crit_sect);
+
+        pci_unlock_rescan_remove();
         return 0;
 }
 
@@ -1083,10 +1107,12 @@ int acpiphp_enable_slot(struct acpiphp_slot *slot)
  * acpiphp_disable_and_eject_slot - power off and eject slot
  * @slot: ACPI PHP slot
  */
-int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
+static int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
 {
         struct acpiphp_func *func;
-        int retval = 0;
+
+        if (slot->flags & SLOT_IS_GOING_AWAY)
+                return -ENODEV;
 
         mutex_lock(&slot->crit_sect);
 
@@ -1104,9 +1130,18 @@ int acpiphp_disable_and_eject_slot(struct acpiphp_slot *slot)
                 }
 
         mutex_unlock(&slot->crit_sect);
-        return retval;
+        return 0;
 }
 
+int acpiphp_disable_slot(struct acpiphp_slot *slot)
+{
+        int ret;
+
+        pci_lock_rescan_remove();
+        ret = acpiphp_disable_and_eject_slot(slot);
+        pci_unlock_rescan_remove();
+        return ret;
+}
 
 /*
  * slot enabled:  1
@@ -1117,7 +1152,6 @@ u8 acpiphp_get_power_status(struct acpiphp_slot *slot)
         return (slot->flags & SLOT_ENABLED);
 }
 
-
 /*
  * latch   open:  1
  * latch closed:  0
@@ -1127,7 +1161,6 @@ u8 acpiphp_get_latch_status(struct acpiphp_slot *slot)
         return !(get_slot_status(slot) & ACPI_STA_DEVICE_UI);
 }
 
-
 /*
  * adapter presence : 1
  *          absence : 0
diff --git a/drivers/pci/hotplug/cpci_hotplug_pci.c b/drivers/pci/hotplug/cpci_hotplug_pci.c
index d3add9819f63..8c1464851768 100644
--- a/drivers/pci/hotplug/cpci_hotplug_pci.c
+++ b/drivers/pci/hotplug/cpci_hotplug_pci.c
@@ -254,9 +254,12 @@ int __ref cpci_configure_slot(struct slot *slot)
 {
         struct pci_dev *dev;
         struct pci_bus *parent;
+        int ret = 0;
 
         dbg("%s - enter", __func__);
 
+        pci_lock_rescan_remove();
+
         if (slot->dev == NULL) {
                 dbg("pci_dev null, finding %02x:%02x:%x",
                     slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn));
@@ -277,7 +280,8 @@ int __ref cpci_configure_slot(struct slot *slot)
                 slot->dev = pci_get_slot(slot->bus, slot->devfn);
                 if (slot->dev == NULL) {
                         err("Could not find PCI device for slot %02x", slot->number);
-                        return -ENODEV;
+                        ret = -ENODEV;
+                        goto out;
                 }
         }
         parent = slot->dev->bus;
@@ -294,8 +298,10 @@ int __ref cpci_configure_slot(struct slot *slot)
 
         pci_bus_add_devices(parent);
 
+ out:
+        pci_unlock_rescan_remove();
         dbg("%s - exit", __func__);
-        return 0;
+        return ret;
 }
 
 int cpci_unconfigure_slot(struct slot* slot)
@@ -308,6 +314,8 @@ int cpci_unconfigure_slot(struct slot* slot)
                 return -ENODEV;
         }
 
+        pci_lock_rescan_remove();
+
         list_for_each_entry_safe(dev, temp, &slot->bus->devices, bus_list) {
                 if (PCI_SLOT(dev->devfn) != PCI_SLOT(slot->devfn))
                         continue;
@@ -318,6 +326,8 @@ int cpci_unconfigure_slot(struct slot* slot)
         pci_dev_put(slot->dev);
         slot->dev = NULL;
 
+        pci_unlock_rescan_remove();
+
         dbg("%s - exit", __func__);
         return 0;
 }
diff --git a/drivers/pci/hotplug/cpqphp_pci.c b/drivers/pci/hotplug/cpqphp_pci.c
index 6e4a12c91adb..a3e3c2002b58 100644
--- a/drivers/pci/hotplug/cpqphp_pci.c
+++ b/drivers/pci/hotplug/cpqphp_pci.c
@@ -86,6 +86,8 @@ int cpqhp_configure_device (struct controller* ctrl, struct pci_func* func)
         struct pci_bus *child;
         int num;
 
+        pci_lock_rescan_remove();
+
         if (func->pci_dev == NULL)
                 func->pci_dev = pci_get_bus_and_slot(func->bus,PCI_DEVFN(func->device, func->function));
 
@@ -100,7 +102,7 @@ int cpqhp_configure_device (struct controller* ctrl, struct pci_func* func)
                 func->pci_dev = pci_get_bus_and_slot(func->bus, PCI_DEVFN(func->device, func->function));
                 if (func->pci_dev == NULL) {
                         dbg("ERROR: pci_dev still null\n");
-                        return 0;
+                        goto out;
                 }
         }
 
@@ -113,6 +115,8 @@ int cpqhp_configure_device (struct controller* ctrl, struct pci_func* func)
 
         pci_dev_put(func->pci_dev);
 
+ out:
+        pci_unlock_rescan_remove();
         return 0;
 }
 
@@ -123,6 +127,7 @@ int cpqhp_unconfigure_device(struct pci_func* func)
 
         dbg("%s: bus/dev/func = %x/%x/%x\n", __func__, func->bus, func->device, func->function);
 
+        pci_lock_rescan_remove();
         for (j=0; j<8 ; j++) {
                 struct pci_dev* temp = pci_get_bus_and_slot(func->bus, PCI_DEVFN(func->device, j));
                 if (temp) {
@@ -130,6 +135,7 @@ int cpqhp_unconfigure_device(struct pci_func* func)
                         pci_stop_and_remove_bus_device(temp);
                 }
         }
+        pci_unlock_rescan_remove();
         return 0;
 }
 
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index efdc13adbe41..cf3ac1e4b099 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -718,6 +718,8 @@ static void ibm_unconfigure_device(struct pci_func *func)
                                         func->device, func->function);
         debug("func->device << 3 | 0x0  = %x\n", func->device << 3 | 0x0);
 
+        pci_lock_rescan_remove();
+
         for (j = 0; j < 0x08; j++) {
                 temp = pci_get_bus_and_slot(func->busno, (func->device << 3) | j);
                 if (temp) {
@@ -725,7 +727,10 @@ static void ibm_unconfigure_device(struct pci_func *func)
                         pci_dev_put(temp);
                 }
         }
+
         pci_dev_put(func->dev);
+
+        pci_unlock_rescan_remove();
 }
 
 /*
@@ -780,6 +785,8 @@ static int ibm_configure_device(struct pci_func *func)
         int flag = 0;   /* this is to make sure we don't double scan the bus,
                                         for bridged devices primarily */
 
+        pci_lock_rescan_remove();
+
         if (!(bus_structure_fixup(func->busno)))
                 flag = 1;
         if (func->dev == NULL)
@@ -789,7 +796,7 @@ static int ibm_configure_device(struct pci_func *func)
         if (func->dev == NULL) {
                 struct pci_bus *bus = pci_find_bus(0, func->busno);
                 if (!bus)
-                        return 0;
+                        goto out;
 
                 num = pci_scan_slot(bus,
                                 PCI_DEVFN(func->device, func->function));
@@ -800,7 +807,7 @@ static int ibm_configure_device(struct pci_func *func)
                                 PCI_DEVFN(func->device, func->function));
                 if (func->dev == NULL) {
                         err("ERROR... : pci_dev still NULL\n");
-                        return 0;
+                        goto out;
                 }
         }
         if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
@@ -810,6 +817,8 @@ static int ibm_configure_device(struct pci_func *func)
                         pci_bus_add_devices(child);
         }
 
+ out:
+        pci_unlock_rescan_remove();
         return 0;
 }
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 21e865ded1dc..ccb0925bcd7b 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -43,7 +43,6 @@
 extern bool pciehp_poll_mode;
 extern int pciehp_poll_time;
 extern bool pciehp_debug;
-extern bool pciehp_force;
 
 #define dbg(format, arg...)                                             \
 do {                                                                    \
@@ -140,15 +139,15 @@ struct controller *pcie_init(struct pcie_device *dev);
 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);
+void 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);
+void pciehp_power_off_slot(struct slot *slot);
+void pciehp_get_power_status(struct slot *slot, u8 *status);
+void 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);
+void pciehp_set_attention_status(struct slot *slot, u8 status);
+void pciehp_get_latch_status(struct slot *slot, u8 *status);
+void pciehp_get_adapter_status(struct slot *slot, u8 *status);
 int pciehp_query_power_fault(struct slot *slot);
 void pciehp_green_led_on(struct slot *slot);
 void pciehp_green_led_off(struct slot *slot);
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index bbd48bbe4e9b..53b58debc288 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -41,7 +41,7 @@
 bool pciehp_debug;
 bool pciehp_poll_mode;
 int pciehp_poll_time;
-bool pciehp_force;
+static bool pciehp_force;
 
 #define DRIVER_VERSION  "0.4"
 #define DRIVER_AUTHOR   "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
@@ -160,7 +160,8 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
                   __func__, slot_name(slot));
 
-        return pciehp_set_attention_status(slot, status);
+        pciehp_set_attention_status(slot, status);
+        return 0;
 }
 
 
@@ -192,7 +193,8 @@ 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));
 
-        return pciehp_get_power_status(slot, value);
+        pciehp_get_power_status(slot, value);
+        return 0;
 }
 
 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -202,7 +204,8 @@ 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));
 
-        return pciehp_get_attention_status(slot, value);
+        pciehp_get_attention_status(slot, value);
+        return 0;
 }
 
 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -212,7 +215,8 @@ 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));
 
-        return pciehp_get_latch_status(slot, value);
+        pciehp_get_latch_status(slot, value);
+        return 0;
 }
 
 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
@@ -222,7 +226,8 @@ 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));
 
-        return pciehp_get_adapter_status(slot, value);
+        pciehp_get_adapter_status(slot, value);
+        return 0;
 }
 
 static int reset_slot(struct hotplug_slot *hotplug_slot, int probe)
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 38f018679175..50628487597d 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -158,11 +158,8 @@ 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 (pciehp_power_off_slot(pslot)) {
-                        ctrl_err(ctrl,
-                                 "Issue of Slot Power Off command failed\n");
-                        return;
-                }
+                pciehp_power_off_slot(pslot);
+
                 /*
                  * After turning power off, we must wait for at least 1 second
                  * before taking any action that relies on power having been
@@ -171,16 +168,8 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
                 msleep(1000);
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_off(pslot);
-
-        if (ATTN_LED(ctrl)) {
-                if (pciehp_set_attention_status(pslot, 1)) {
-                        ctrl_err(ctrl,
-                                 "Issue of Set Attention Led command failed\n");
-                        return;
-                }
-        }
+        pciehp_green_led_off(pslot);
+        pciehp_set_attention_status(pslot, 1);
 }
 
 /**
@@ -203,8 +192,7 @@ static int board_added(struct slot *p_slot)
                         return retval;
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_blink(p_slot);
+        pciehp_green_led_blink(p_slot);
 
         /* Check link training status */
         retval = pciehp_check_link_status(ctrl);
@@ -227,9 +215,7 @@ static int board_added(struct slot *p_slot)
                 goto err_exit;
         }
 
-        if (PWR_LED(ctrl))
-                pciehp_green_led_on(p_slot);
-
+        pciehp_green_led_on(p_slot);
         return 0;
 
 err_exit:
@@ -243,7 +229,7 @@ err_exit:
  */
 static int remove_board(struct slot *p_slot)
 {
-        int retval = 0;
+        int retval;
         struct controller *ctrl = p_slot->ctrl;
 
         retval = pciehp_unconfigure_device(p_slot);
@@ -251,13 +237,8 @@ static int remove_board(struct slot *p_slot)
                 return retval;
 
         if (POWER_CTRL(ctrl)) {
-                /* power off slot */
-                retval = pciehp_power_off_slot(p_slot);
-                if (retval) {
-                        ctrl_err(ctrl,
-                                 "Issue of Slot Disable command failed\n");
-                        return retval;
-                }
+                pciehp_power_off_slot(p_slot);
+
                 /*
                  * After turning power off, we must wait for at least 1 second
                  * before taking any action that relies on power having been
@@ -267,9 +248,7 @@ static int remove_board(struct slot *p_slot)
         }
 
         /* turn off Green LED */
-        if (PWR_LED(ctrl))
-                pciehp_green_led_off(p_slot);
-
+        pciehp_green_led_off(p_slot);
         return 0;
 }
 
@@ -305,7 +284,7 @@ static void pciehp_power_thread(struct work_struct *work)
                 break;
         case POWERON_STATE:
                 mutex_unlock(&p_slot->lock);
-                if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
+                if (pciehp_enable_slot(p_slot))
                         pciehp_green_led_off(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
@@ -372,11 +351,8 @@ static void handle_button_press_event(struct slot *p_slot)
                                   "press.\n", slot_name(p_slot));
                 }
                 /* blink green LED and turn off amber */
-                if (PWR_LED(ctrl))
-                        pciehp_green_led_blink(p_slot);
-                if (ATTN_LED(ctrl))
-                        pciehp_set_attention_status(p_slot, 0);
-
+                pciehp_green_led_blink(p_slot);
+                pciehp_set_attention_status(p_slot, 0);
                 queue_delayed_work(p_slot->wq, &p_slot->work, 5*HZ);
                 break;
         case BLINKINGOFF_STATE:
@@ -389,14 +365,11 @@ static void handle_button_press_event(struct slot *p_slot)
                 ctrl_info(ctrl, "Button cancel on Slot(%s)\n", slot_name(p_slot));
                 cancel_delayed_work(&p_slot->work);
                 if (p_slot->state == BLINKINGOFF_STATE) {
-                        if (PWR_LED(ctrl))
-                                pciehp_green_led_on(p_slot);
+                        pciehp_green_led_on(p_slot);
                 } else {
-                        if (PWR_LED(ctrl))
-                                pciehp_green_led_off(p_slot);
+                        pciehp_green_led_off(p_slot);
                 }
-                if (ATTN_LED(ctrl))
-                        pciehp_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;
@@ -456,10 +429,8 @@ static void interrupt_event_handler(struct work_struct *work)
         case INT_POWER_FAULT:
                 if (!POWER_CTRL(ctrl))
                         break;
-                if (ATTN_LED(ctrl))
-                        pciehp_set_attention_status(p_slot, 1);
-                if (PWR_LED(ctrl))
-                        pciehp_green_led_off(p_slot);
+                pciehp_set_attention_status(p_slot, 1);
+                pciehp_green_led_off(p_slot);
                 break;
         case INT_PRESENCE_ON:
         case INT_PRESENCE_OFF:
@@ -482,14 +453,14 @@ int pciehp_enable_slot(struct slot *p_slot)
         int rc;
         struct controller *ctrl = p_slot->ctrl;
 
-        rc = pciehp_get_adapter_status(p_slot, &getstatus);
-        if (rc || !getstatus) {
+        pciehp_get_adapter_status(p_slot, &getstatus);
+        if (!getstatus) {
                 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
                 return -ENODEV;
         }
         if (MRL_SENS(p_slot->ctrl)) {
-                rc = pciehp_get_latch_status(p_slot, &getstatus);
-                if (rc || getstatus) {
+                pciehp_get_latch_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -497,8 +468,8 @@ int pciehp_enable_slot(struct slot *p_slot)
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                rc = pciehp_get_power_status(p_slot, &getstatus);
-                if (rc || getstatus) {
+                pciehp_get_power_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Already enabled on slot(%s)\n",
                                   slot_name(p_slot));
                         return -EINVAL;
@@ -518,15 +489,14 @@ int pciehp_enable_slot(struct slot *p_slot)
 int pciehp_disable_slot(struct slot *p_slot)
 {
         u8 getstatus = 0;
-        int ret = 0;
         struct controller *ctrl = p_slot->ctrl;
 
         if (!p_slot->ctrl)
                 return 1;
 
         if (!HP_SUPR_RM(p_slot->ctrl)) {
-                ret = pciehp_get_adapter_status(p_slot, &getstatus);
-                if (ret || !getstatus) {
+                pciehp_get_adapter_status(p_slot, &getstatus);
+                if (!getstatus) {
                         ctrl_info(ctrl, "No adapter on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -534,8 +504,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         }
 
         if (MRL_SENS(p_slot->ctrl)) {
-                ret = pciehp_get_latch_status(p_slot, &getstatus);
-                if (ret || getstatus) {
+                pciehp_get_latch_status(p_slot, &getstatus);
+                if (getstatus) {
                         ctrl_info(ctrl, "Latch open on slot(%s)\n",
                                   slot_name(p_slot));
                         return -ENODEV;
@@ -543,8 +513,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         }
 
         if (POWER_CTRL(p_slot->ctrl)) {
-                ret = pciehp_get_power_status(p_slot, &getstatus);
-                if (ret || !getstatus) {
+                pciehp_get_power_status(p_slot, &getstatus);
+                if (!getstatus) {
                         ctrl_info(ctrl, "Already disabled on slot(%s)\n",
                                   slot_name(p_slot));
                         return -EINVAL;
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 3eea3fdd4b0b..14acfccb7670 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -41,34 +41,11 @@
 #include "../pci.h"
 #include "pciehp.h"
 
-static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
+static inline struct pci_dev *ctrl_dev(struct controller *ctrl)
 {
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_read_word(dev, reg, value);
+        return ctrl->pcie->port;
 }
 
-static inline int pciehp_readl(struct controller *ctrl, int reg, u32 *value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_read_dword(dev, reg, value);
-}
-
-static inline int pciehp_writew(struct controller *ctrl, int reg, u16 value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_write_word(dev, reg, value);
-}
-
-static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
-{
-        struct pci_dev *dev = ctrl->pcie->port;
-        return pcie_capability_write_dword(dev, reg, value);
-}
-
-/* Power Control Command */
-#define POWER_ON        0
-#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);
 
@@ -129,20 +106,23 @@ static inline void pciehp_free_irq(struct controller *ctrl)
 
 static int pcie_poll_cmd(struct controller *ctrl)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
-        int err, timeout = 1000;
+        int timeout = 1000;
 
-        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);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+        if (slot_status & PCI_EXP_SLTSTA_CC) {
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_CC);
                 return 1;
         }
         while (timeout > 0) {
                 msleep(10);
                 timeout -= 10;
-                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);
+                pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+                if (slot_status & PCI_EXP_SLTSTA_CC) {
+                        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                                   PCI_EXP_SLTSTA_CC);
                         return 1;
                 }
         }
@@ -169,21 +149,15 @@ static void pcie_wait_cmd(struct controller *ctrl, int poll)
  * @cmd:  command value written to slot control register
  * @mask: bitmask of slot control register to be modified
  */
-static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
+static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
 {
-        int retval = 0;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
         u16 slot_ctrl;
 
         mutex_lock(&ctrl->ctrl_lock);
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                goto out;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         if (slot_status & PCI_EXP_SLTSTA_CC) {
                 if (!ctrl->no_cmd_complete) {
                         /*
@@ -207,24 +181,17 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                 }
         }
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                goto out;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         slot_ctrl &= ~mask;
         slot_ctrl |= (cmd & mask);
         ctrl->cmd_busy = 1;
         smp_mb();
-        retval = pciehp_writew(ctrl, PCI_EXP_SLTCTL, slot_ctrl);
-        if (retval)
-                ctrl_err(ctrl, "Cannot write to SLOTCTRL register\n");
+        pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, slot_ctrl);
 
         /*
          * Wait for command completion.
          */
-        if (!retval && !ctrl->no_cmd_complete) {
+        if (!ctrl->no_cmd_complete) {
                 int poll = 0;
                 /*
                  * if hotplug interrupt is not enabled or command
@@ -236,19 +203,16 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                         poll = 1;
                 pcie_wait_cmd(ctrl, poll);
         }
- out:
         mutex_unlock(&ctrl->ctrl_lock);
-        return retval;
 }
 
 static bool check_link_active(struct controller *ctrl)
 {
-        bool ret = false;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 lnk_status;
+        bool ret;
 
-        if (pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status))
-                return ret;
-
+        pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
         ret = !!(lnk_status & PCI_EXP_LNKSTA_DLLLA);
 
         if (ret)
@@ -311,9 +275,9 @@ static bool pci_bus_check_dev(struct pci_bus *bus, int devfn)
 
 int pciehp_check_link_status(struct controller *ctrl)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
+        bool found;
         u16 lnk_status;
-        int retval = 0;
-        bool found = false;
 
         /*
          * Data Link Layer Link Active Reporting must be capable for
@@ -330,52 +294,37 @@ int pciehp_check_link_status(struct controller *ctrl)
         found = pci_bus_check_dev(ctrl->pcie->port->subordinate,
                                         PCI_DEVFN(0, 0));
 
-        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot read LNKSTATUS register\n");
-                return retval;
-        }
-
+        pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lnk_status);
         ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
         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;
+                return -1;
         }
 
         pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
 
-        if (!found && !retval)
-                retval = -1;
+        if (!found)
+                return -1;
 
-        return retval;
+        return 0;
 }
 
 static int __pciehp_link_set(struct controller *ctrl, bool enable)
 {
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 lnk_ctrl;
-        int retval = 0;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_LNKCTL, &lnk_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot read LNKCTRL register\n");
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &lnk_ctrl);
 
         if (enable)
                 lnk_ctrl &= ~PCI_EXP_LNKCTL_LD;
         else
                 lnk_ctrl |= PCI_EXP_LNKCTL_LD;
 
-        retval = pciehp_writew(ctrl, PCI_EXP_LNKCTL, lnk_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot write LNKCTRL register\n");
-                return retval;
-        }
+        pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, lnk_ctrl);
         ctrl_dbg(ctrl, "%s: lnk_ctrl = %x\n", __func__, lnk_ctrl);
-
-        return retval;
+        return 0;
 }
 
 static int pciehp_link_enable(struct controller *ctrl)
@@ -388,223 +337,165 @@ static int pciehp_link_disable(struct controller *ctrl)
         return __pciehp_link_set(ctrl, false);
 }
 
-int pciehp_get_attention_status(struct slot *slot, u8 *status)
+void pciehp_get_attention_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_ctrl;
-        u8 atten_led_state;
-        int retval = 0;
-
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                return retval;
-        }
 
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
 
-        atten_led_state = (slot_ctrl & PCI_EXP_SLTCTL_AIC) >> 6;
-
-        switch (atten_led_state) {
-        case 0:
-                *status = 0xFF; /* Reserved */
-                break;
-        case 1:
+        switch (slot_ctrl & PCI_EXP_SLTCTL_AIC) {
+        case PCI_EXP_SLTCTL_ATTN_IND_ON:
                 *status = 1;    /* On */
                 break;
-        case 2:
+        case PCI_EXP_SLTCTL_ATTN_IND_BLINK:
                 *status = 2;    /* Blink */
                 break;
-        case 3:
+        case PCI_EXP_SLTCTL_ATTN_IND_OFF:
                 *status = 0;    /* Off */
                 break;
         default:
                 *status = 0xFF;
                 break;
         }
-
-        return 0;
 }
 
-int pciehp_get_power_status(struct slot *slot, u8 *status)
+void pciehp_get_power_status(struct slot *slot, u8 *status)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_ctrl;
-        u8 pwr_state;
-        int     retval = 0;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTCTL, &slot_ctrl);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_ctrl);
 
-        pwr_state = (slot_ctrl & PCI_EXP_SLTCTL_PCC) >> 10;
-
-        switch (pwr_state) {
-        case 0:
-                *status = 1;
+        switch (slot_ctrl & PCI_EXP_SLTCTL_PCC) {
+        case PCI_EXP_SLTCTL_PWR_ON:
+                *status = 1;    /* On */
                 break;
-        case 1:
-                *status = 0;
+        case PCI_EXP_SLTCTL_PWR_OFF:
+                *status = 0;    /* Off */
                 break;
         default:
                 *status = 0xFF;
                 break;
         }
-
-        return retval;
 }
 
-int pciehp_get_latch_status(struct slot *slot, u8 *status)
+void pciehp_get_latch_status(struct slot *slot, u8 *status)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         *status = !!(slot_status & PCI_EXP_SLTSTA_MRLSS);
-        return 0;
 }
 
-int pciehp_get_adapter_status(struct slot *slot, u8 *status)
+void pciehp_get_adapter_status(struct slot *slot, u8 *status)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
-                         __func__);
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         *status = !!(slot_status & PCI_EXP_SLTSTA_PDS);
-        return 0;
 }
 
 int pciehp_query_power_fault(struct slot *slot)
 {
-        struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(slot->ctrl);
         u16 slot_status;
-        int retval;
 
-        retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
-        if (retval) {
-                ctrl_err(ctrl, "Cannot check for power fault\n");
-                return retval;
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
         return !!(slot_status & PCI_EXP_SLTSTA_PFD);
 }
 
-int pciehp_set_attention_status(struct slot *slot, u8 value)
+void pciehp_set_attention_status(struct slot *slot, u8 value)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 cmd_mask;
 
-        cmd_mask = PCI_EXP_SLTCTL_AIC;
+        if (!ATTN_LED(ctrl))
+                return;
+
         switch (value) {
         case 0 :        /* turn off */
-                slot_cmd = 0x00C0;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_OFF;
                 break;
         case 1:         /* turn on */
-                slot_cmd = 0x0040;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_ON;
                 break;
         case 2:         /* turn blink */
-                slot_cmd = 0x0080;
+                slot_cmd = PCI_EXP_SLTCTL_ATTN_IND_BLINK;
                 break;
         default:
-                return -EINVAL;
+                return;
         }
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
-        return pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        pcie_write_cmd(ctrl, slot_cmd, PCI_EXP_SLTCTL_AIC);
 }
 
 void pciehp_green_led_on(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0100;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_ON);
 }
 
 void pciehp_green_led_off(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0300;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_OFF);
 }
 
 void pciehp_green_led_blink(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
 
-        slot_cmd = 0x0200;
-        cmd_mask = PCI_EXP_SLTCTL_PIC;
-        pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
+        if (!PWR_LED(ctrl))
+                return;
+
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK, PCI_EXP_SLTCTL_PIC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_IND_BLINK);
 }
 
 int pciehp_power_on_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         u16 slot_status;
-        int retval = 0;
+        int retval;
 
         /* Clear sticky power-fault bit from previous power failures */
-        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 &= PCI_EXP_SLTSTA_PFD;
-        if (slot_status) {
-                retval = pciehp_writew(ctrl, PCI_EXP_SLTSTA, slot_status);
-                if (retval) {
-                        ctrl_err(ctrl,
-                                 "%s: Cannot write to SLOTSTATUS register\n",
-                                 __func__);
-                        return retval;
-                }
-        }
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &slot_status);
+        if (slot_status & PCI_EXP_SLTSTA_PFD)
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_PFD);
         ctrl->power_fault_detected = 0;
 
-        slot_cmd = POWER_ON;
-        cmd_mask = PCI_EXP_SLTCTL_PCC;
-        retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        if (retval) {
-                ctrl_err(ctrl, "Write %x command failed!\n", slot_cmd);
-                return retval;
-        }
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_ON, PCI_EXP_SLTCTL_PCC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_ON);
 
         retval = pciehp_link_enable(ctrl);
         if (retval)
@@ -613,12 +504,9 @@ int pciehp_power_on_slot(struct slot * slot)
         return retval;
 }
 
-int pciehp_power_off_slot(struct slot * slot)
+void pciehp_power_off_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd;
-        u16 cmd_mask;
-        int retval;
 
         /* Disable the link at first */
         pciehp_link_disable(ctrl);
@@ -628,21 +516,16 @@ int pciehp_power_off_slot(struct slot * slot)
         else
                 msleep(1000);
 
-        slot_cmd = POWER_OFF;
-        cmd_mask = PCI_EXP_SLTCTL_PCC;
-        retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        if (retval) {
-                ctrl_err(ctrl, "Write command failed!\n");
-                return retval;
-        }
+        pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_OFF, PCI_EXP_SLTCTL_PCC);
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
-                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
-        return 0;
+                 pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL,
+                 PCI_EXP_SLTCTL_PWR_OFF);
 }
 
 static irqreturn_t pcie_isr(int irq, void *dev_id)
 {
         struct controller *ctrl = (struct controller *)dev_id;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
         struct slot *slot = ctrl->slot;
         u16 detected, intr_loc;
 
@@ -653,11 +536,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
          */
         intr_loc = 0;
         do {
-                if (pciehp_readw(ctrl, PCI_EXP_SLTSTA, &detected)) {
-                        ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS\n",
-                                 __func__);
-                        return IRQ_NONE;
-                }
+                pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &detected);
 
                 detected &= (PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
                              PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
@@ -666,11 +545,9 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 intr_loc |= detected;
                 if (!intr_loc)
                         return IRQ_NONE;
-                if (detected && pciehp_writew(ctrl, PCI_EXP_SLTSTA, intr_loc)) {
-                        ctrl_err(ctrl, "%s: Cannot write to SLOTSTATUS\n",
-                                 __func__);
-                        return IRQ_NONE;
-                }
+                if (detected)
+                        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                                   intr_loc);
         } while (detected);
 
         ctrl_dbg(ctrl, "%s: intr_loc %x\n", __func__, intr_loc);
@@ -705,7 +582,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-int pcie_enable_notification(struct controller *ctrl)
+void pcie_enable_notification(struct controller *ctrl)
 {
         u16 cmd, mask;
 
@@ -731,22 +608,18 @@ int pcie_enable_notification(struct controller *ctrl)
                 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");
-                return -1;
-        }
-        return 0;
+        pcie_write_cmd(ctrl, cmd, mask);
 }
 
 static void pcie_disable_notification(struct controller *ctrl)
 {
         u16 mask;
+
         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 |
                 PCI_EXP_SLTCTL_DLLSCE);
-        if (pcie_write_cmd(ctrl, 0, mask))
-                ctrl_warn(ctrl, "Cannot disable software notification\n");
+        pcie_write_cmd(ctrl, 0, mask);
 }
 
 /*
@@ -758,6 +631,7 @@ static void pcie_disable_notification(struct controller *ctrl)
 int pciehp_reset_slot(struct slot *slot, int probe)
 {
         struct controller *ctrl = slot->ctrl;
+        struct pci_dev *pdev = ctrl_dev(ctrl);
 
         if (probe)
                 return 0;
@@ -771,7 +645,8 @@ int pciehp_reset_slot(struct slot *slot, int probe)
         pci_reset_bridge_secondary_bus(ctrl->pcie->port);
 
         if (HP_SUPR_RM(ctrl)) {
-                pciehp_writew(ctrl, PCI_EXP_SLTSTA, PCI_EXP_SLTSTA_PDC);
+                pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                                           PCI_EXP_SLTSTA_PDC);
                 pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PDCE, PCI_EXP_SLTCTL_PDCE);
                 if (pciehp_poll_mode)
                         int_poll_timeout(ctrl->poll_timer.data);
@@ -784,10 +659,7 @@ int pcie_init_notification(struct controller *ctrl)
 {
         if (pciehp_request_irq(ctrl))
                 return -1;
-        if (pcie_enable_notification(ctrl)) {
-                pciehp_free_irq(ctrl);
-                return -1;
-        }
+        pcie_enable_notification(ctrl);
         ctrl->notification_enabled = 1;
         return 0;
 }
@@ -875,12 +747,14 @@ 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, PCI_EXP_SLTSTA, &reg16);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &reg16);
         ctrl_info(ctrl, "Slot Status            : 0x%04x\n", reg16);
-        pciehp_readw(ctrl, PCI_EXP_SLTCTL, &reg16);
+        pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &reg16);
         ctrl_info(ctrl, "Slot Control           : 0x%04x\n", reg16);
 }
 
+#define FLAG(x,y)       (((x) & (y)) ? '+' : '-')
+
 struct controller *pcie_init(struct pcie_device *dev)
 {
         struct controller *ctrl;
@@ -893,11 +767,7 @@ struct controller *pcie_init(struct pcie_device *dev)
                 goto abort;
         }
         ctrl->pcie = dev;
-        if (pciehp_readl(ctrl, PCI_EXP_SLTCAP, &slot_cap)) {
-                ctrl_err(ctrl, "Cannot read SLOTCAP register\n");
-                goto abort_ctrl;
-        }
-
+        pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &slot_cap);
         ctrl->slot_cap = slot_cap;
         mutex_init(&ctrl->ctrl_lock);
         init_waitqueue_head(&ctrl->queue);
@@ -913,25 +783,31 @@ 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, PCI_EXP_LNKCAP, &link_cap)) {
-                ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
-                goto abort_ctrl;
-        }
+        pcie_capability_read_dword(pdev, PCI_EXP_LNKCAP, &link_cap);
         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, PCI_EXP_SLTSTA, 0x1f))
-                goto abort_ctrl;
+        pcie_capability_write_word(pdev, PCI_EXP_SLTSTA,
+                PCI_EXP_SLTSTA_ABP | PCI_EXP_SLTSTA_PFD |
+                PCI_EXP_SLTSTA_MRLSC | PCI_EXP_SLTSTA_PDC |
+                PCI_EXP_SLTSTA_CC);
 
         /* Disable software notification */
         pcie_disable_notification(ctrl);
 
-        ctrl_info(ctrl, "HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
-                  pdev->vendor, pdev->device, pdev->subsystem_vendor,
-                  pdev->subsystem_device);
+        ctrl_info(ctrl, "Slot #%d AttnBtn%c AttnInd%c PwrInd%c PwrCtrl%c MRL%c Interlock%c NoCompl%c LLActRep%c\n",
+                (slot_cap & PCI_EXP_SLTCAP_PSN) >> 19,
+                FLAG(slot_cap, PCI_EXP_SLTCAP_ABP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_AIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_PIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_PCP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_MRLSP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_EIP),
+                FLAG(slot_cap, PCI_EXP_SLTCAP_NCCS),
+                FLAG(link_cap, PCI_EXP_LNKCAP_DLLLARC));
 
         if (pcie_init_slot(ctrl))
                 goto abort_ctrl;
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 0e0d0f7f63fd..b07d7cc2d697 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -39,22 +39,26 @@ int pciehp_configure_device(struct slot *p_slot)
         struct pci_dev *dev;
         struct pci_dev *bridge = p_slot->ctrl->pcie->port;
         struct pci_bus *parent = bridge->subordinate;
-        int num;
+        int num, ret = 0;
         struct controller *ctrl = p_slot->ctrl;
 
+        pci_lock_rescan_remove();
+
         dev = pci_get_slot(parent, PCI_DEVFN(0, 0));
         if (dev) {
                 ctrl_err(ctrl, "Device %s already exists "
                          "at %04x:%02x:00, cannot hot-add\n", pci_name(dev),
                          pci_domain_nr(parent), parent->number);
                 pci_dev_put(dev);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         num = pci_scan_slot(parent, PCI_DEVFN(0, 0));
         if (num == 0) {
                 ctrl_err(ctrl, "No new device found\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto out;
         }
 
         list_for_each_entry(dev, &parent->devices, bus_list)
@@ -73,12 +77,14 @@ int pciehp_configure_device(struct slot *p_slot)
 
         pci_bus_add_devices(parent);
 
-        return 0;
+ out:
+        pci_unlock_rescan_remove();
+        return ret;
 }
 
 int pciehp_unconfigure_device(struct slot *p_slot)
 {
-        int ret, rc = 0;
+        int rc = 0;
         u8 bctl = 0;
         u8 presence = 0;
         struct pci_dev *dev, *temp;
@@ -88,9 +94,9 @@ int pciehp_unconfigure_device(struct slot *p_slot)
 
         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;
+        pciehp_get_adapter_status(p_slot, &presence);
+
+        pci_lock_rescan_remove();
 
         /*
          * Stopping an SR-IOV PF device removes all the associated VFs,
@@ -126,5 +132,6 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                 pci_dev_put(dev);
         }
 
+        pci_unlock_rescan_remove();
         return rc;
 }
diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index e9c044d15add..4fcdeedda31b 100644
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -354,10 +354,15 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
 {
         struct pci_bus *bus;
         struct slot *slot;
+        int ret = 0;
+
+        pci_lock_rescan_remove();
 
         bus = pcibios_find_pci_bus(dn);
-        if (!bus)
-                return -EINVAL;
+        if (!bus) {
+                ret = -EINVAL;
+                goto out;
+        }
 
         pr_debug("PCI: Removing PCI slot below EADS bridge %s\n",
                  bus->self ? pci_name(bus->self) : "<!PHB!>");
@@ -371,7 +376,8 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
                         printk(KERN_ERR
                                 "%s: unable to remove hotplug slot %s\n",
                                 __func__, drc_name);
-                        return -EIO;
+                        ret = -EIO;
+                        goto out;
                 }
         }
 
@@ -382,7 +388,8 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
         if (pcibios_unmap_io_space(bus)) {
                 printk(KERN_ERR "%s: failed to unmap bus range\n",
                         __func__);
-                return -ERANGE;
+                ret = -ERANGE;
+                goto out;
         }
 
         /* Remove the EADS bridge device itself */
@@ -390,7 +397,9 @@ int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
         pr_debug("PCI: Now removing bridge device %s\n", pci_name(bus->self));
         pci_stop_and_remove_bus_device(bus->self);
 
-        return 0;
+ out:
+        pci_unlock_rescan_remove();
+        return ret;
 }
 
 /**
diff --git a/drivers/pci/hotplug/rpaphp_core.c b/drivers/pci/hotplug/rpaphp_core.c
index b7fc5c9255a5..4796c15fba94 100644
--- a/drivers/pci/hotplug/rpaphp_core.c
+++ b/drivers/pci/hotplug/rpaphp_core.c
@@ -398,7 +398,9 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
                 return retval;
 
         if (state == PRESENT) {
+                pci_lock_rescan_remove();
                 pcibios_add_pci_devices(slot->bus);
+                pci_unlock_rescan_remove();
                 slot->state = CONFIGURED;
         } else if (state == EMPTY) {
                 slot->state = EMPTY;
@@ -418,7 +420,9 @@ static int disable_slot(struct hotplug_slot *hotplug_slot)
         if (slot->state == NOT_CONFIGURED)
                 return -EINVAL;
 
+        pci_lock_rescan_remove();
         pcibios_remove_pci_devices(slot->bus);
+        pci_unlock_rescan_remove();
         vm_unmap_aliases();
 
         slot->state = NOT_CONFIGURED;
diff --git a/drivers/pci/hotplug/s390_pci_hpc.c b/drivers/pci/hotplug/s390_pci_hpc.c
index 3c7eb5dd91c6..8d2ce22151eb 100644
--- a/drivers/pci/hotplug/s390_pci_hpc.c
+++ b/drivers/pci/hotplug/s390_pci_hpc.c
@@ -80,7 +80,9 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
                 goto out_deconfigure;
 
         pci_scan_slot(slot->zdev->bus, ZPCI_DEVFN);
+        pci_lock_rescan_remove();
         pci_bus_add_devices(slot->zdev->bus);
+        pci_unlock_rescan_remove();
 
         return rc;
 
@@ -98,7 +100,7 @@ static int disable_slot(struct hotplug_slot *hotplug_slot)
                 return -EIO;
 
         if (slot->zdev->pdev)
-                pci_stop_and_remove_bus_device(slot->zdev->pdev);
+                pci_stop_and_remove_bus_device_locked(slot->zdev->pdev);
 
         rc = zpci_disable_device(slot->zdev);
         if (rc)
diff --git a/drivers/pci/hotplug/sgi_hotplug.c b/drivers/pci/hotplug/sgi_hotplug.c
index 5b05a68cca6c..613043f7576f 100644
--- a/drivers/pci/hotplug/sgi_hotplug.c
+++ b/drivers/pci/hotplug/sgi_hotplug.c
@@ -459,12 +459,15 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                 acpi_scan_lock_release();
         }
 
+        pci_lock_rescan_remove();
+
         /* Call the driver for the new device */
         pci_bus_add_devices(slot->pci_bus);
         /* Call the drivers for the new devices subordinate to PPB */
         if (new_ppb)
                 pci_bus_add_devices(new_bus);
 
+        pci_unlock_rescan_remove();
         mutex_unlock(&sn_hotplug_mutex);
 
         if (rc == 0)
@@ -540,6 +543,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                 acpi_scan_lock_release();
         }
 
+        pci_lock_rescan_remove();
         /* Free the SN resources assigned to the Linux device.*/
         list_for_each_entry_safe(dev, temp, &slot->pci_bus->devices, bus_list) {
                 if (PCI_SLOT(dev->devfn) != slot->device_num + 1)
@@ -550,6 +554,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                 pci_stop_and_remove_bus_device(dev);
                 pci_dev_put(dev);
         }
+        pci_unlock_rescan_remove();
 
         /* Remove the SSDT for the slot from the ACPI namespace */
         if (SN_ACPI_BASE_SUPPORT() && ssdt_id) {
diff --git a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c
index b0e83132542e..2bf69fe1926c 100644
--- a/drivers/pci/hotplug/shpchp_pci.c
+++ b/drivers/pci/hotplug/shpchp_pci.c
@@ -40,7 +40,9 @@ int __ref shpchp_configure_device(struct slot *p_slot)
         struct controller *ctrl = p_slot->ctrl;
         struct pci_dev *bridge = ctrl->pci_dev;
         struct pci_bus *parent = bridge->subordinate;
-        int num;
+        int num, ret = 0;
+
+        pci_lock_rescan_remove();
 
         dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
         if (dev) {
@@ -48,13 +50,15 @@ int __ref shpchp_configure_device(struct slot *p_slot)
                          "at %04x:%02x:%02x, cannot hot-add\n", pci_name(dev),
                          pci_domain_nr(parent), p_slot->bus, p_slot->device);
                 pci_dev_put(dev);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
         if (num == 0) {
                 ctrl_err(ctrl, "No new device found\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto out;
         }
 
         list_for_each_entry(dev, &parent->devices, bus_list) {
@@ -75,7 +79,9 @@ int __ref shpchp_configure_device(struct slot *p_slot)
 
         pci_bus_add_devices(parent);
 
-        return 0;
+ out:
+        pci_unlock_rescan_remove();
+        return ret;
 }
 
 int shpchp_unconfigure_device(struct slot *p_slot)
@@ -89,6 +95,8 @@ int shpchp_unconfigure_device(struct slot *p_slot)
         ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:%02x\n",
                  __func__, pci_domain_nr(parent), p_slot->bus, p_slot->device);
 
+        pci_lock_rescan_remove();
+
         list_for_each_entry_safe(dev, temp, &parent->devices, bus_list) {
                 if (PCI_SLOT(dev->devfn) != p_slot->device)
                         continue;
@@ -108,6 +116,8 @@ int shpchp_unconfigure_device(struct slot *p_slot)
                 pci_stop_and_remove_bus_device(dev);
                 pci_dev_put(dev);
         }
+
+        pci_unlock_rescan_remove();
         return rc;
 }