Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6: (34 commits)
  PCI: Only build PCI syscalls on architectures that want them
  PCI: limit pci_get_bus_and_slot to domain 0
  PCI: hotplug: acpiphp: avoid acpiphp "cannot get bridge info" PCI hotplug failure
  PCI: hotplug: acpiphp: remove hot plug parameter write to PCI host bridge
  PCI: hotplug: acpiphp: fix slot poweroff problem on systems without _PS3
  PCI: hotplug: pciehp: wait for 1 second after power off slot
  PCI: pci_set_power_state(): check for PM capabilities earlier
  PCI: cpci_hotplug: Convert to use the kthread API
  PCI: add pci_try_set_mwi
  PCI: pcie: remove SPIN_LOCK_UNLOCKED
  PCI: ROUND_UP macro cleanup in drivers/pci
  PCI: remove pci_dac_dma_... APIs
  PCI: pci-x-pci-express-read-control-interfaces cleanups
  PCI: Fix typo in include/linux/pci.h
  PCI: pci_ids, remove double or more empty lines
  PCI: pci_ids, add atheros and 3com_2 vendors
  PCI: pci_ids, reorder some entries
  PCI: i386: traps, change VENDOR to DEVICE
  PCI: ATM: lanai, change VENDOR to DEVICE
  PCI: Change all drivers to use pci_device->revision
  ...

9 files changed, 196 insertions, 148 deletions

diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index ddbadd95387e..f6cc0c5b5657 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -211,6 +211,7 @@ typedef int (*acpiphp_callback)(struct acpiphp_slot *slot, void *data);
 
 extern int acpiphp_enable_slot (struct acpiphp_slot *slot);
 extern int acpiphp_disable_slot (struct acpiphp_slot *slot);
+extern int acpiphp_eject_slot (struct acpiphp_slot *slot);
 extern u8 acpiphp_get_power_status (struct acpiphp_slot *slot);
 extern u8 acpiphp_get_attention_status (struct acpiphp_slot *slot);
 extern 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 fa5c0197d571..a0ca63adad5a 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -156,11 +156,15 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
 static int disable_slot(struct hotplug_slot *hotplug_slot)
 {
         struct slot *slot = hotplug_slot->private;
+        int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
         /* disable the specified slot */
-        return acpiphp_disable_slot(slot->acpi_slot);
+        retval = acpiphp_disable_slot(slot->acpi_slot);
+        if (!retval)
+                retval = acpiphp_eject_slot(slot->acpi_slot);
+        return retval;
 }
 
 
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 9ef4e989afc4..1e125b56c9a9 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -1282,7 +1282,7 @@ static unsigned int get_slot_status(struct acpiphp_slot *slot)
 /**
  * acpiphp_eject_slot - physically eject the slot
  */
-static int acpiphp_eject_slot(struct acpiphp_slot *slot)
+int acpiphp_eject_slot(struct acpiphp_slot *slot)
 {
         acpi_status status;
         struct acpiphp_func *func;
@@ -1368,6 +1368,9 @@ static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
                         (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
                 return;
 
+        if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
+                return;
+
         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE,
                         bridge->hpp.t0->cache_line_size);
         pci_write_config_byte(dev, PCI_LATENCY_TIMER,
@@ -1502,6 +1505,37 @@ static void handle_bridge_insertion(acpi_handle handle, u32 type)
  * ACPI event handlers
  */
 
+static acpi_status
+count_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int *count = (int *)context;
+        struct acpiphp_bridge *bridge;
+
+        bridge = acpiphp_handle_to_bridge(handle);
+        if (bridge)
+                (*count)++;
+        return AE_OK ;
+}
+
+static acpi_status
+check_sub_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        struct acpiphp_bridge *bridge;
+        char objname[64];
+        struct acpi_buffer buffer = { .length = sizeof(objname),
+                                      .pointer = objname };
+
+        bridge = acpiphp_handle_to_bridge(handle);
+        if (bridge) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
+                dbg("%s: re-enumerating slots under %s\n",
+                        __FUNCTION__, objname);
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
+                acpiphp_check_bridge(bridge);
+        }
+        return AE_OK ;
+}
+
 /**
  * handle_hotplug_event_bridge - handle ACPI event on bridges
  *
@@ -1519,6 +1553,7 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont
         struct acpi_buffer buffer = { .length = sizeof(objname),
                                       .pointer = objname };
         struct acpi_device *device;
+        int num_sub_bridges = 0;
 
         if (acpi_bus_get_device(handle, &device)) {
                 /* This bridge must have just been physically inserted */
@@ -1527,7 +1562,12 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont
         }
 
         bridge = acpiphp_handle_to_bridge(handle);
-        if (!bridge) {
+        if (type == ACPI_NOTIFY_BUS_CHECK) {
+                acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, ACPI_UINT32_MAX,
+                        count_sub_bridges, &num_sub_bridges, NULL);
+        }
+
+        if (!bridge && !num_sub_bridges) {
                 err("cannot get bridge info\n");
                 return;
         }
@@ -1538,7 +1578,14 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont
         case ACPI_NOTIFY_BUS_CHECK:
                 /* bus re-enumerate */
                 dbg("%s: Bus check notify on %s\n", __FUNCTION__, objname);
-                acpiphp_check_bridge(bridge);
+                if (bridge) {
+                        dbg("%s: re-enumerating slots under %s\n",
+                                __FUNCTION__, objname);
+                        acpiphp_check_bridge(bridge);
+                }
+                if (num_sub_bridges)
+                        acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
+                                ACPI_UINT32_MAX, check_sub_bridges, NULL, NULL);
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK:
diff --git a/drivers/pci/hotplug/cpci_hotplug_core.c b/drivers/pci/hotplug/cpci_hotplug_core.c
index 684551559d44..ed4d44e3332c 100644
--- a/drivers/pci/hotplug/cpci_hotplug_core.c
+++ b/drivers/pci/hotplug/cpci_hotplug_core.c
@@ -35,6 +35,7 @@
 #include <linux/smp_lock.h>
 #include <asm/atomic.h>
 #include <linux/delay.h>
+#include <linux/kthread.h>
 #include "cpci_hotplug.h"
 
 #define DRIVER_AUTHOR   "Scott Murray <scottm@somanetworks.com>"
@@ -59,9 +60,8 @@ static int slots;
 static atomic_t extracting;
 int cpci_debug;
 static struct cpci_hp_controller *controller;
-static struct semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
-static struct semaphore thread_exit;            /* guard ensure thread has exited before calling it quits */
-static int thread_finished = 1;
+static struct task_struct *cpci_thread;
+static int thread_finished;
 
 static int enable_slot(struct hotplug_slot *slot);
 static int disable_slot(struct hotplug_slot *slot);
@@ -357,9 +357,7 @@ cpci_hp_intr(int irq, void *data)
         controller->ops->disable_irq();
 
         /* Trigger processing by the event thread */
-        dbg("Signal event_semaphore");
-        up(&event_semaphore);
-        dbg("exited cpci_hp_intr");
+        wake_up_process(cpci_thread);
         return IRQ_HANDLED;
 }
 
@@ -521,17 +519,12 @@ event_thread(void *data)
 {
         int rc;
 
-        lock_kernel();
-        daemonize("cpci_hp_eventd");
-        unlock_kernel();
-
         dbg("%s - event thread started", __FUNCTION__);
         while (1) {
                 dbg("event thread sleeping");
-                down_interruptible(&event_semaphore);
-                dbg("event thread woken, thread_finished = %d",
-                    thread_finished);
-                if (thread_finished || signal_pending(current))
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule();
+                if (kthread_should_stop())
                         break;
                 do {
                         rc = check_slots();
@@ -541,18 +534,17 @@ event_thread(void *data)
                         } else if (rc < 0) {
                                 dbg("%s - error checking slots", __FUNCTION__);
                                 thread_finished = 1;
-                                break;
+                                goto out;
                         }
-                } while (atomic_read(&extracting) && !thread_finished);
-                if (thread_finished)
+                } while (atomic_read(&extracting) && !kthread_should_stop());
+                if (kthread_should_stop())
                         break;
 
                 /* Re-enable ENUM# interrupt */
                 dbg("%s - re-enabling irq", __FUNCTION__);
                 controller->ops->enable_irq();
         }
-        dbg("%s - event thread signals exit", __FUNCTION__);
-        up(&thread_exit);
+ out:
         return 0;
 }
 
@@ -562,12 +554,8 @@ poll_thread(void *data)
 {
         int rc;
 
-        lock_kernel();
-        daemonize("cpci_hp_polld");
-        unlock_kernel();
-
         while (1) {
-                if (thread_finished || signal_pending(current))
+                if (kthread_should_stop() || signal_pending(current))
                         break;
                 if (controller->ops->query_enum()) {
                         do {
@@ -578,48 +566,36 @@ poll_thread(void *data)
                                 } else if (rc < 0) {
                                         dbg("%s - error checking slots", __FUNCTION__);
                                         thread_finished = 1;
-                                        break;
+                                        goto out;
                                 }
-                        } while (atomic_read(&extracting) && !thread_finished);
+                        } while (atomic_read(&extracting) && !kthread_should_stop());
                 }
                 msleep(100);
         }
-        dbg("poll thread signals exit");
-        up(&thread_exit);
+ out:
         return 0;
 }
 
 static int
 cpci_start_thread(void)
 {
-        int pid;
-
-        /* initialize our semaphores */
-        init_MUTEX_LOCKED(&event_semaphore);
-        init_MUTEX_LOCKED(&thread_exit);
-        thread_finished = 0;
-
         if (controller->irq)
-                pid = kernel_thread(event_thread, NULL, 0);
+                cpci_thread = kthread_run(event_thread, NULL, "cpci_hp_eventd");
         else
-                pid = kernel_thread(poll_thread, NULL, 0);
-        if (pid < 0) {
+                cpci_thread = kthread_run(poll_thread, NULL, "cpci_hp_polld");
+        if (IS_ERR(cpci_thread)) {
                 err("Can't start up our thread");
-                return -1;
+                return PTR_ERR(cpci_thread);
         }
-        dbg("Our thread pid = %d", pid);
+        thread_finished = 0;
         return 0;
 }
 
 static void
 cpci_stop_thread(void)
 {
+        kthread_stop(cpci_thread);
         thread_finished = 1;
-        dbg("thread finish command given");
-        if (controller->irq)
-                up(&event_semaphore);
-        dbg("wait for thread to exit");
-        down(&thread_exit);
 }
 
 int
diff --git a/drivers/pci/hotplug/cpci_hotplug_pci.c b/drivers/pci/hotplug/cpci_hotplug_pci.c
index 7b1beaad2752..5e9be44817cb 100644
--- a/drivers/pci/hotplug/cpci_hotplug_pci.c
+++ b/drivers/pci/hotplug/cpci_hotplug_pci.c
@@ -45,8 +45,6 @@ extern int cpci_debug;
 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
 
-#define ROUND_UP(x, a)          (((x) + (a) - 1) & ~((a) - 1))
-
 
 u8 cpci_get_attention_status(struct slot* slot)
 {
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 5617cfdadc5c..d590a99930fa 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -796,7 +796,6 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 num_of_slots = 0;
         u8 hp_slot = 0;
         u8 device;
-        u8 rev;
         u8 bus_cap;
         u16 temp_word;
         u16 vendor_id;
@@ -823,9 +822,8 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
         dbg("Vendor ID: %x\n", vendor_id);
 
-        rc = pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
-        dbg("revision: %d\n", rev);
-        if (rc || ((vendor_id == PCI_VENDOR_ID_COMPAQ) && (!rev))) {
+        dbg("revision: %d\n", pdev->revision);
+        if ((vendor_id == PCI_VENDOR_ID_COMPAQ) && (!pdev->revision)) {
                 err(msg_HPC_rev_error);
                 rc = -ENODEV;
                 goto err_disable_device;
@@ -836,7 +834,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
          * For Intel, each SSID bit identifies a PHP capability.
          * Also Intel HPC's may have RID=0.
          */
-        if ((rev > 2) || (vendor_id == PCI_VENDOR_ID_INTEL)) {
+        if ((pdev->revision > 2) || (vendor_id == PCI_VENDOR_ID_INTEL)) {
                 // TODO: This code can be made to support non-Compaq or Intel subsystem IDs
                 rc = pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vid);
                 if (rc) {
@@ -870,7 +868,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
                 switch (subsystem_vid) {
                         case PCI_VENDOR_ID_COMPAQ:
-                                if (rev >= 0x13) { /* CIOBX */
+                                if (pdev->revision >= 0x13) { /* CIOBX */
                                         ctrl->push_flag = 1;
                                         ctrl->slot_switch_type = 1;
                                         ctrl->push_button = 1;
@@ -1075,7 +1073,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         memcpy(ctrl->pci_bus, pdev->bus, sizeof(*ctrl->pci_bus));
 
         ctrl->bus = pdev->bus->number;
-        ctrl->rev = rev;
+        ctrl->rev = pdev->revision;
         dbg("bus device function rev: %d %d %d %d\n", ctrl->bus,
                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn), ctrl->rev);
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index ccc57627201e..7959c222dc24 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -103,6 +103,7 @@ struct controller {
         u8 cap_base;
         struct timer_list poll_timer;
         volatile int cmd_busy;
+        spinlock_t lock;
 };
 
 #define INT_BUTTON_IGNORE               0
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 7f22caa70178..98e541ffef3d 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -197,6 +197,12 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
                             __FUNCTION__);
                         return;
                 }
+                /*
+                 * After turning power off, we must wait for at least
+                 * 1 second before taking any action that relies on
+                 * power having been removed from the slot/adapter.
+                 */
+                msleep(1000);
         }
 }
 
@@ -615,6 +621,12 @@ int pciehp_disable_slot(struct slot *p_slot)
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
+                /*
+                 * After turning power off, we must wait for at least
+                 * 1 second before taking any action that relies on
+                 * power having been removed from the slot/adapter.
+                 */
+                msleep(1000);
         }
 
         ret = remove_board(p_slot);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 9aac6a87eb53..016eea94a8a5 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -275,11 +275,19 @@ static inline int pcie_wait_cmd(struct controller *ctrl)
         return retval;
 }
 
-static int pcie_write_cmd(struct slot *slot, u16 cmd)
+/**
+ * pcie_write_cmd - Issue controller command
+ * @slot: slot to which the command is issued
+ * @cmd:  command value written to slot control register
+ * @mask: bitmask of slot control register to be modified
+ */
+static int pcie_write_cmd(struct slot *slot, u16 cmd, u16 mask)
 {
         struct controller *ctrl = slot->ctrl;
         int retval = 0;
         u16 slot_status;
+        u16 slot_ctrl;
+        unsigned long flags;
 
         DBG_ENTER_ROUTINE 
 
@@ -299,17 +307,29 @@ static int pcie_write_cmd(struct slot *slot, u16 cmd)
                     __FUNCTION__);
         }
 
-        ctrl->cmd_busy = 1;
-        retval = pciehp_writew(ctrl, SLOTCTRL, (cmd | CMD_CMPL_INTR_ENABLE));
+        spin_lock_irqsave(&ctrl->lock, flags);
+        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
-                err("%s: Cannot write to SLOTCTRL register\n", __FUNCTION__);
-                goto out;
+                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
+                goto out_spin_unlock;
         }
 
+        slot_ctrl &= ~mask;
+        slot_ctrl |= ((cmd & mask) | CMD_CMPL_INTR_ENABLE);
+
+        ctrl->cmd_busy = 1;
+        retval = pciehp_writew(ctrl, SLOTCTRL, slot_ctrl);
+        if (retval)
+                err("%s: Cannot write to SLOTCTRL register\n", __FUNCTION__);
+
+ out_spin_unlock:
+        spin_unlock_irqrestore(&ctrl->lock, flags);
+
         /*
          * Wait for command completion.
          */
-        retval = pcie_wait_cmd(ctrl);
+        if (!retval)
+                retval = pcie_wait_cmd(ctrl);
  out:
         mutex_unlock(&ctrl->ctrl_lock);
         DBG_LEAVE_ROUTINE 
@@ -502,25 +522,20 @@ static int hpc_get_emi_status(struct slot *slot, u8 *status)
 
 static int hpc_toggle_emi(struct slot *slot)
 {
-        struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd = 0;
-        u16 slot_ctrl;
-        int rc = 0;
+        u16 slot_cmd;
+        u16 cmd_mask;
+        int rc;
 
         DBG_ENTER_ROUTINE
 
-        rc = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (rc) {
-                err("%s : hp_register_read_word SLOT_CTRL failed\n",
-                        __FUNCTION__);
-                return rc;
-        }
-
-        slot_cmd = (slot_ctrl | EMI_CTRL);
-        if (!pciehp_poll_mode)
+        slot_cmd = EMI_CTRL;
+        cmd_mask = EMI_CTRL;
+        if (!pciehp_poll_mode) {
                 slot_cmd = slot_cmd | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask | HP_INTR_ENABLE;
+        }
 
-        pcie_write_cmd(slot, slot_cmd);
+        rc = pcie_write_cmd(slot, slot_cmd, cmd_mask);
         slot->last_emi_toggle = get_seconds();
         DBG_LEAVE_ROUTINE
         return rc;
@@ -529,35 +544,32 @@ static int hpc_toggle_emi(struct slot *slot)
 static int hpc_set_attention_status(struct slot *slot, u8 value)
 {
         struct controller *ctrl = slot->ctrl;
-        u16 slot_cmd = 0;
-        u16 slot_ctrl;
-        int rc = 0;
+        u16 slot_cmd;
+        u16 cmd_mask;
+        int rc;
 
         DBG_ENTER_ROUTINE
 
-        rc = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (rc) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return rc;
-        }
-
+        cmd_mask = ATTN_LED_CTRL;
         switch (value) {
                 case 0 :        /* turn off */
-                        slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x00C0;
+                        slot_cmd = 0x00C0;
                         break;
                 case 1:         /* turn on */
-                        slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x0040;
+                        slot_cmd = 0x0040;
                         break;
                 case 2:         /* turn blink */
-                        slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x0080;
+                        slot_cmd = 0x0080;
                         break;
                 default:
                         return -1;
         }
-        if (!pciehp_poll_mode)
-                slot_cmd = slot_cmd | HP_INTR_ENABLE; 
+        if (!pciehp_poll_mode) {
+                slot_cmd = slot_cmd | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask | HP_INTR_ENABLE;
+        }
 
-        pcie_write_cmd(slot, slot_cmd);
+        rc = pcie_write_cmd(slot, slot_cmd, cmd_mask);
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
         
@@ -570,21 +582,18 @@ static void hpc_set_green_led_on(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 slot_ctrl;
-        int rc = 0;
+        u16 cmd_mask;
         
         DBG_ENTER_ROUTINE
 
-        rc = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (rc) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return;
+        slot_cmd = 0x0100;
+        cmd_mask = PWR_LED_CTRL;
+        if (!pciehp_poll_mode) {
+                slot_cmd = slot_cmd | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask | HP_INTR_ENABLE;
         }
-        slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0100;
-        if (!pciehp_poll_mode)
-                slot_cmd = slot_cmd | HP_INTR_ENABLE; 
 
-        pcie_write_cmd(slot, slot_cmd);
+        pcie_write_cmd(slot, slot_cmd, cmd_mask);
 
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
@@ -596,22 +605,18 @@ static void hpc_set_green_led_off(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 slot_ctrl;
-        int rc = 0;
+        u16 cmd_mask;
 
         DBG_ENTER_ROUTINE
 
-        rc = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (rc) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return;
+        slot_cmd = 0x0300;
+        cmd_mask = PWR_LED_CTRL;
+        if (!pciehp_poll_mode) {
+                slot_cmd = slot_cmd | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask | HP_INTR_ENABLE;
         }
 
-        slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0300;
-
-        if (!pciehp_poll_mode)
-                slot_cmd = slot_cmd | HP_INTR_ENABLE; 
-        pcie_write_cmd(slot, slot_cmd);
+        pcie_write_cmd(slot, slot_cmd, cmd_mask);
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 
@@ -623,22 +628,18 @@ static void hpc_set_green_led_blink(struct slot *slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 slot_ctrl;
-        int rc = 0; 
+        u16 cmd_mask;
         
         DBG_ENTER_ROUTINE
 
-        rc = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (rc) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return;
+        slot_cmd = 0x0200;
+        cmd_mask = PWR_LED_CTRL;
+        if (!pciehp_poll_mode) {
+                slot_cmd = slot_cmd | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask | HP_INTR_ENABLE;
         }
 
-        slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0200;
-
-        if (!pciehp_poll_mode)
-                slot_cmd = slot_cmd | HP_INTR_ENABLE; 
-        pcie_write_cmd(slot, slot_cmd);
+        pcie_write_cmd(slot, slot_cmd, cmd_mask);
 
         dbg("%s: SLOTCTRL %x write cmd %x\n",
             __FUNCTION__, ctrl->cap_base + SLOTCTRL, slot_cmd);
@@ -669,7 +670,8 @@ static int hpc_power_on_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 slot_ctrl, slot_status;
+        u16 cmd_mask;
+        u16 slot_status;
         int retval = 0;
 
         DBG_ENTER_ROUTINE 
@@ -692,23 +694,23 @@ static int hpc_power_on_slot(struct slot * slot)
                 }
         }
 
-        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (retval) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return retval;
-        }
-
-        slot_cmd = (slot_ctrl & ~PWR_CTRL) | POWER_ON;
-
+        slot_cmd = POWER_ON;
+        cmd_mask = PWR_CTRL;
         /* Enable detection that we turned off at slot power-off time */
-        if (!pciehp_poll_mode)
+        if (!pciehp_poll_mode) {
                 slot_cmd = slot_cmd |
                            PWR_FAULT_DETECT_ENABLE |
                            MRL_DETECT_ENABLE |
                            PRSN_DETECT_ENABLE |
                            HP_INTR_ENABLE;
+                cmd_mask = cmd_mask |
+                           PWR_FAULT_DETECT_ENABLE |
+                           MRL_DETECT_ENABLE |
+                           PRSN_DETECT_ENABLE |
+                           HP_INTR_ENABLE;
+        }
 
-        retval = pcie_write_cmd(slot, slot_cmd);
+        retval = pcie_write_cmd(slot, slot_cmd, cmd_mask);
 
         if (retval) {
                 err("%s: Write %x command failed!\n", __FUNCTION__, slot_cmd);
@@ -726,21 +728,15 @@ static int hpc_power_off_slot(struct slot * slot)
 {
         struct controller *ctrl = slot->ctrl;
         u16 slot_cmd;
-        u16 slot_ctrl;
+        u16 cmd_mask;
         int retval = 0;
 
         DBG_ENTER_ROUTINE 
 
         dbg("%s: slot->hp_slot %x\n", __FUNCTION__, slot->hp_slot);
 
-        retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
-        if (retval) {
-                err("%s: Cannot read SLOTCTRL register\n", __FUNCTION__);
-                return retval;
-        }
-
-        slot_cmd = (slot_ctrl & ~PWR_CTRL) | POWER_OFF;
-
+        slot_cmd = POWER_OFF;
+        cmd_mask = PWR_CTRL;
         /*
          * If we get MRL or presence detect interrupts now, the isr
          * will notice the sticky power-fault bit too and issue power
@@ -748,14 +744,19 @@ static int hpc_power_off_slot(struct slot * slot)
          * of command completions, since the power-fault bit remains on
          * till the slot is powered on again.
          */
-        if (!pciehp_poll_mode)
+        if (!pciehp_poll_mode) {
                 slot_cmd = (slot_cmd &
                             ~PWR_FAULT_DETECT_ENABLE &
                             ~MRL_DETECT_ENABLE &
                             ~PRSN_DETECT_ENABLE) | HP_INTR_ENABLE;
+                cmd_mask = cmd_mask |
+                           PWR_FAULT_DETECT_ENABLE |
+                           MRL_DETECT_ENABLE |
+                           PRSN_DETECT_ENABLE |
+                           HP_INTR_ENABLE;
+        }
 
-        retval = pcie_write_cmd(slot, slot_cmd);
-
+        retval = pcie_write_cmd(slot, slot_cmd, cmd_mask);
         if (retval) {
                 err("%s: Write command failed!\n", __FUNCTION__);
                 return -1;
@@ -775,6 +776,7 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         u16 temp_word;
         int hp_slot = 0;        /* only 1 slot per PCI Express port */
         int rc = 0;
+        unsigned long flags;
 
         rc = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (rc) {
@@ -794,10 +796,12 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         dbg("%s: intr_loc %x\n", __FUNCTION__, intr_loc);
         /* Mask Hot-plug Interrupt Enable */
         if (!pciehp_poll_mode) {
+                spin_lock_irqsave(&ctrl->lock, flags);
                 rc = pciehp_readw(ctrl, SLOTCTRL, &temp_word);
                 if (rc) {
                         err("%s: Cannot read SLOT_CTRL register\n",
                             __FUNCTION__);
+                        spin_unlock_irqrestore(&ctrl->lock, flags);
                         return IRQ_NONE;
                 }
 
@@ -808,8 +812,10 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 if (rc) {
                         err("%s: Cannot write to SLOTCTRL register\n",
                             __FUNCTION__);
+                        spin_unlock_irqrestore(&ctrl->lock, flags);
                         return IRQ_NONE;
                 }
+                spin_unlock_irqrestore(&ctrl->lock, flags);
 
                 rc = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
                 if (rc) {
@@ -859,10 +865,12 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         }
         /* Unmask Hot-plug Interrupt Enable */
         if (!pciehp_poll_mode) {
+                spin_lock_irqsave(&ctrl->lock, flags);
                 rc = pciehp_readw(ctrl, SLOTCTRL, &temp_word);
                 if (rc) {
                         err("%s: Cannot read SLOTCTRL register\n",
                             __FUNCTION__);
+                        spin_unlock_irqrestore(&ctrl->lock, flags);
                         return IRQ_NONE;
                 }
 
@@ -873,8 +881,10 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 if (rc) {
                         err("%s: Cannot write to SLOTCTRL register\n",
                             __FUNCTION__);
+                        spin_unlock_irqrestore(&ctrl->lock, flags);
                         return IRQ_NONE;
                 }
+                spin_unlock_irqrestore(&ctrl->lock, flags);
 
                 rc = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
                 if (rc) {
@@ -1237,6 +1247,7 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 
         mutex_init(&ctrl->crit_sect);
         mutex_init(&ctrl->ctrl_lock);
+        spin_lock_init(&ctrl->lock);
 
         /* setup wait queue */
         init_waitqueue_head(&ctrl->queue);