25 files changed, 488 insertions, 239 deletions

diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index e3beb784406f..006054a40995 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -41,9 +41,7 @@ obj-$(CONFIG_ACPI)    += pci-acpi.o
 # Cardbus & CompactPCI use setup-bus
 obj-$(CONFIG_HOTPLUG) += setup-bus.o
 
-ifndef CONFIG_X86
-obj-y += syscall.o
-endif
+obj-$(CONFIG_PCI_SYSCALL) += syscall.o
 
 ifeq ($(CONFIG_PCI_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
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);
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index b5ac810404c0..c8062494009f 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -55,8 +55,6 @@ acpi_query_osc (
 
         status = acpi_evaluate_object(handle, "_OSC", &input, &output);
         if (ACPI_FAILURE (status)) {
-                printk(KERN_DEBUG  
-                        "Evaluate _OSC Set fails. Status = 0x%04x\n", status);
                 *ret_status = status;
                 return status;
         }
@@ -124,11 +122,9 @@ acpi_run_osc (
         in_params[3].buffer.pointer     = (u8 *)context;
 
         status = acpi_evaluate_object(handle, "_OSC", &input, &output);
-        if (ACPI_FAILURE (status)) {
-                printk(KERN_DEBUG  
-                        "Evaluate _OSC Set fails. Status = 0x%04x\n", status);
+        if (ACPI_FAILURE (status))
                 return status;
-        }
+
         out_obj = output.pointer;
         if (out_obj->type != ACPI_TYPE_BUFFER) {
                 printk(KERN_DEBUG  
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 6543cbe83be5..10dbdec80416 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -603,6 +603,11 @@ static struct bin_attribute pcie_config_attr = {
         .write = pci_write_config,
 };
 
+int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
+{
+        return 0;
+}
+
 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
 {
         struct bin_attribute *rom_attr = NULL;
@@ -642,10 +647,14 @@ int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
                 }
         }
         /* add platform-specific attributes */
-        pcibios_add_platform_entries(pdev);
+        if (pcibios_add_platform_entries(pdev))
+                goto err_rom_file;
 
         return 0;
 
+err_rom_file:
+        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
+                sysfs_remove_bin_file(&pdev->dev.kobj, rom_attr);
 err_rom:
         kfree(rom_attr);
 err_resource_files:
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index fd47ac0c4730..03fd59e80fef 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -406,6 +406,13 @@ pci_set_power_state(struct pci_dev *dev, pci_power_t state)
         if ((state == PCI_D1 || state == PCI_D2) && pci_no_d1d2(dev))
                 return 0;
 
+        /* find PCI PM capability in list */
+        pm = pci_find_capability(dev, PCI_CAP_ID_PM);
+
+        /* abort if the device doesn't support PM capabilities */
+        if (!pm)
+                return -EIO;
+
         /* Validate current state:
          * Can enter D0 from any state, but if we can only go deeper 
          * to sleep if we're already in a low power state
@@ -418,13 +425,6 @@ pci_set_power_state(struct pci_dev *dev, pci_power_t state)
                 return 0;        /* we're already there */
 
 
-        /* find PCI PM capability in list */
-        pm = pci_find_capability(dev, PCI_CAP_ID_PM);
-        
-        /* abort if the device doesn't support PM capabilities */
-        if (!pm)
-                return -EIO; 
-
         pci_read_config_word(dev,pm + PCI_PM_PMC,&pmc);
         if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
                 printk(KERN_DEBUG
@@ -1186,6 +1186,11 @@ int pci_set_mwi(struct pci_dev *dev)
         return 0;
 }
 
+int pci_try_set_mwi(struct pci_dev *dev)
+{
+        return 0;
+}
+
 void pci_clear_mwi(struct pci_dev *dev)
 {
 }
@@ -1242,9 +1247,7 @@ pci_set_cacheline_size(struct pci_dev *dev)
  * pci_set_mwi - enables memory-write-invalidate PCI transaction
  * @dev: the PCI device for which MWI is enabled
  *
- * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND,
- * and then calls @pcibios_set_mwi to do the needed arch specific
- * operations or a generic mwi-prep function.
+ * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
  *
  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
  */
@@ -1260,7 +1263,8 @@ pci_set_mwi(struct pci_dev *dev)
 
         pci_read_config_word(dev, PCI_COMMAND, &cmd);
         if (! (cmd & PCI_COMMAND_INVALIDATE)) {
-                pr_debug("PCI: Enabling Mem-Wr-Inval for device %s\n", pci_name(dev));
+                pr_debug("PCI: Enabling Mem-Wr-Inval for device %s\n",
+                        pci_name(dev));
                 cmd |= PCI_COMMAND_INVALIDATE;
                 pci_write_config_word(dev, PCI_COMMAND, cmd);
         }
@@ -1269,6 +1273,21 @@ pci_set_mwi(struct pci_dev *dev)
 }
 
 /**
+ * pci_try_set_mwi - enables memory-write-invalidate PCI transaction
+ * @dev: the PCI device for which MWI is enabled
+ *
+ * Enables the Memory-Write-Invalidate transaction in %PCI_COMMAND.
+ * Callers are not required to check the return value.
+ *
+ * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
+ */
+int pci_try_set_mwi(struct pci_dev *dev)
+{
+        int rc = pci_set_mwi(dev);
+        return rc;
+}
+
+/**
  * pci_clear_mwi - disables Memory-Write-Invalidate for device dev
  * @dev: the PCI device to disable
  *
@@ -1375,6 +1394,164 @@ pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 #endif
 
 /**
+ * pcix_get_max_mmrbc - get PCI-X maximum designed memory read byte count
+ * @dev: PCI device to query
+ *
+ * Returns mmrbc: maximum designed memory read count in bytes
+ *    or appropriate error value.
+ */
+int pcix_get_max_mmrbc(struct pci_dev *dev)
+{
+        int err, cap;
+        u32 stat;
+
+        cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
+        if (!cap)
+                return -EINVAL;
+
+        err = pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat);
+        if (err)
+                return -EINVAL;
+
+        return (stat & PCI_X_STATUS_MAX_READ) >> 12;
+}
+EXPORT_SYMBOL(pcix_get_max_mmrbc);
+
+/**
+ * pcix_get_mmrbc - get PCI-X maximum memory read byte count
+ * @dev: PCI device to query
+ *
+ * Returns mmrbc: maximum memory read count in bytes
+ *    or appropriate error value.
+ */
+int pcix_get_mmrbc(struct pci_dev *dev)
+{
+        int ret, cap;
+        u32 cmd;
+
+        cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
+        if (!cap)
+                return -EINVAL;
+
+        ret = pci_read_config_dword(dev, cap + PCI_X_CMD, &cmd);
+        if (!ret)
+                ret = 512 << ((cmd & PCI_X_CMD_MAX_READ) >> 2);
+
+        return ret;
+}
+EXPORT_SYMBOL(pcix_get_mmrbc);
+
+/**
+ * pcix_set_mmrbc - set PCI-X maximum memory read byte count
+ * @dev: PCI device to query
+ * @mmrbc: maximum memory read count in bytes
+ *    valid values are 512, 1024, 2048, 4096
+ *
+ * If possible sets maximum memory read byte count, some bridges have erratas
+ * that prevent this.
+ */
+int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc)
+{
+        int cap, err = -EINVAL;
+        u32 stat, cmd, v, o;
+
+        if (mmrbc < 512 || mmrbc > 4096 || (mmrbc & (mmrbc-1)))
+                goto out;
+
+        v = ffs(mmrbc) - 10;
+
+        cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
+        if (!cap)
+                goto out;
+
+        err = pci_read_config_dword(dev, cap + PCI_X_STATUS, &stat);
+        if (err)
+                goto out;
+
+        if (v > (stat & PCI_X_STATUS_MAX_READ) >> 21)
+                return -E2BIG;
+
+        err = pci_read_config_dword(dev, cap + PCI_X_CMD, &cmd);
+        if (err)
+                goto out;
+
+        o = (cmd & PCI_X_CMD_MAX_READ) >> 2;
+        if (o != v) {
+                if (v > o && dev->bus &&
+                   (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MMRBC))
+                        return -EIO;
+
+                cmd &= ~PCI_X_CMD_MAX_READ;
+                cmd |= v << 2;
+                err = pci_write_config_dword(dev, cap + PCI_X_CMD, cmd);
+        }
+out:
+        return err;
+}
+EXPORT_SYMBOL(pcix_set_mmrbc);
+
+/**
+ * pcie_get_readrq - get PCI Express read request size
+ * @dev: PCI device to query
+ *
+ * Returns maximum memory read request in bytes
+ *    or appropriate error value.
+ */
+int pcie_get_readrq(struct pci_dev *dev)
+{
+        int ret, cap;
+        u16 ctl;
+
+        cap = pci_find_capability(dev, PCI_CAP_ID_EXP);
+        if (!cap)
+                return -EINVAL;
+
+        ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (!ret)
+        ret = 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
+
+        return ret;
+}
+EXPORT_SYMBOL(pcie_get_readrq);
+
+/**
+ * pcie_set_readrq - set PCI Express maximum memory read request
+ * @dev: PCI device to query
+ * @count: maximum memory read count in bytes
+ *    valid values are 128, 256, 512, 1024, 2048, 4096
+ *
+ * If possible sets maximum read byte count
+ */
+int pcie_set_readrq(struct pci_dev *dev, int rq)
+{
+        int cap, err = -EINVAL;
+        u16 ctl, v;
+
+        if (rq < 128 || rq > 4096 || (rq & (rq-1)))
+                goto out;
+
+        v = (ffs(rq) - 8) << 12;
+
+        cap = pci_find_capability(dev, PCI_CAP_ID_EXP);
+        if (!cap)
+                goto out;
+
+        err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (err)
+                goto out;
+
+        if ((ctl & PCI_EXP_DEVCTL_READRQ) != v) {
+                ctl &= ~PCI_EXP_DEVCTL_READRQ;
+                ctl |= v;
+                err = pci_write_config_dword(dev, cap + PCI_EXP_DEVCTL, ctl);
+        }
+
+out:
+        return err;
+}
+EXPORT_SYMBOL(pcie_set_readrq);
+
+/**
  * pci_select_bars - Make BAR mask from the type of resource
  * @dev: the PCI device for which BAR mask is made
  * @flags: resource type mask to be selected
@@ -1442,6 +1619,7 @@ EXPORT_SYMBOL(pci_release_selected_regions);
 EXPORT_SYMBOL(pci_request_selected_regions);
 EXPORT_SYMBOL(pci_set_master);
 EXPORT_SYMBOL(pci_set_mwi);
+EXPORT_SYMBOL(pci_try_set_mwi);
 EXPORT_SYMBOL(pci_clear_mwi);
 EXPORT_SYMBOL_GPL(pci_intx);
 EXPORT_SYMBOL(pci_set_dma_mask);
diff --git a/drivers/pci/pcie/aer/Kconfig b/drivers/pci/pcie/aer/Kconfig
index 3f37a60a6438..c3bde588aa13 100644
--- a/drivers/pci/pcie/aer/Kconfig
+++ b/drivers/pci/pcie/aer/Kconfig
@@ -4,7 +4,7 @@
 
 config PCIEAER
         boolean "Root Port Advanced Error Reporting support"
-        depends on PCIEPORTBUS && ACPI
+        depends on PCIEPORTBUS
         default y
         help
           This enables PCI Express Root Port Advanced Error Reporting
diff --git a/drivers/pci/pcie/aer/Makefile b/drivers/pci/pcie/aer/Makefile
index 15a4f40d520b..8da3bd8455a8 100644
--- a/drivers/pci/pcie/aer/Makefile
+++ b/drivers/pci/pcie/aer/Makefile
@@ -4,5 +4,6 @@
 
 obj-$(CONFIG_PCIEAER) += aerdriver.o
 
-aerdriver-objs := aerdrv_errprint.o aerdrv_core.o aerdrv.o aerdrv_acpi.o
+aerdriver-objs := aerdrv_errprint.o aerdrv_core.o aerdrv.o
+aerdriver-$(CONFIG_ACPI) += aerdrv_acpi.o
 
diff --git a/drivers/pci/pcie/aer/aerdrv.c b/drivers/pci/pcie/aer/aerdrv.c
index db6ad8e763ac..6846fb42b399 100644
--- a/drivers/pci/pcie/aer/aerdrv.c
+++ b/drivers/pci/pcie/aer/aerdrv.c
@@ -157,7 +157,7 @@ static struct aer_rpc* aer_alloc_rpc(struct pcie_device *dev)
          * Initialize Root lock access, e_lock, to Root Error Status Reg,
          * Root Error ID Reg, and Root error producer/consumer index.
          */
-        rpc->e_lock = SPIN_LOCK_UNLOCKED;
+        spin_lock_init(&rpc->e_lock);
 
         rpc->rpd = dev;
         INIT_WORK(&rpc->dpc_handler, aer_isr);
diff --git a/drivers/pci/pcie/aer/aerdrv.h b/drivers/pci/pcie/aer/aerdrv.h
index 5cca394d5999..c7ad68b6c6d6 100644
--- a/drivers/pci/pcie/aer/aerdrv.h
+++ b/drivers/pci/pcie/aer/aerdrv.h
@@ -19,10 +19,6 @@
 #define AER_ERROR_MASK                  0x001fffff
 #define AER_ERROR(d)                    (d & AER_ERROR_MASK)
 
-#define OSC_METHOD_RUN_SUCCESS          0
-#define OSC_METHOD_NOT_SUPPORTED        1
-#define OSC_METHOD_RUN_FAILURE          2
-
 /* Root Error Status Register Bits */
 #define ROOT_ERR_STATUS_MASKS                   0x0f
 
@@ -121,6 +117,14 @@ extern void aer_delete_rootport(struct aer_rpc *rpc);
 extern int aer_init(struct pcie_device *dev);
 extern void aer_isr(struct work_struct *work);
 extern void aer_print_error(struct pci_dev *dev, struct aer_err_info *info);
-extern int aer_osc_setup(struct pci_dev *dev);
+
+#ifdef CONFIG_ACPI
+extern int aer_osc_setup(struct pcie_device *pciedev);
+#else
+static inline int aer_osc_setup(struct pcie_device *pciedev)
+{
+        return 0;
+}
+#endif
 
 #endif //_AERDRV_H_
diff --git a/drivers/pci/pcie/aer/aerdrv_acpi.c b/drivers/pci/pcie/aer/aerdrv_acpi.c
index fa68e89ebec9..1a1eb45a779e 100644
--- a/drivers/pci/pcie/aer/aerdrv_acpi.c
+++ b/drivers/pci/pcie/aer/aerdrv_acpi.c
@@ -20,19 +20,18 @@
 
 /**
  * aer_osc_setup - run ACPI _OSC method
+ * @pciedev: pcie_device which AER is being enabled on
  *
- * Return:
- *      Zero if success. Nonzero for otherwise.
+ * @return: Zero on success. Nonzero otherwise.
  *
  * Invoked when PCIE bus loads AER service driver. To avoid conflict with
  * BIOS AER support requires BIOS to yield AER control to OS native driver.
  **/
-int aer_osc_setup(struct pci_dev *dev)
+int aer_osc_setup(struct pcie_device *pciedev)
 {
-        int retval = OSC_METHOD_RUN_SUCCESS;
-        acpi_status status;
-        acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
-        struct pci_dev *pdev = dev;
+        acpi_status status = AE_NOT_FOUND;
+        struct pci_dev *pdev = pciedev->port;
+        acpi_handle handle = DEVICE_ACPI_HANDLE(&pdev->dev);
         struct pci_bus *parent;
 
         while (!handle) {
@@ -50,19 +49,20 @@ int aer_osc_setup(struct pci_dev *dev)
                 pdev = parent->self;
         }
 
-        if (!handle)
-                return OSC_METHOD_NOT_SUPPORTED;
+        if (handle) {
+                pci_osc_support_set(OSC_EXT_PCI_CONFIG_SUPPORT);
+                status = pci_osc_control_set(handle,
+                                        OSC_PCI_EXPRESS_AER_CONTROL |
+                                        OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
+        }
 
-        pci_osc_support_set(OSC_EXT_PCI_CONFIG_SUPPORT);
-        status = pci_osc_control_set(handle, OSC_PCI_EXPRESS_AER_CONTROL |
-                OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
         if (ACPI_FAILURE(status)) {
-                if (status == AE_SUPPORT)
-                        retval = OSC_METHOD_NOT_SUPPORTED;
-                else
-                        retval = OSC_METHOD_RUN_FAILURE;
+                printk(KERN_DEBUG "AER service couldn't init device %s - %s\n",
+                    pciedev->device.bus_id,
+                    (status == AE_SUPPORT || status == AE_NOT_FOUND) ?
+                    "no _OSC support" : "Run ACPI _OSC fails");
+                return -1;
         }
 
-        return retval;
+        return 0;
 }
-
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index 08e13033ced8..92a8469b21ba 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -22,8 +22,6 @@
 #include <linux/errno.h>
 #include <linux/pm.h>
 #include <linux/suspend.h>
-#include <linux/acpi.h>
-#include <linux/pci-acpi.h>
 #include <linux/delay.h>
 #include "aerdrv.h"
 
@@ -119,6 +117,21 @@ int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
         return 0;
 }
 
+int pci_cleanup_aer_correct_error_status(struct pci_dev *dev)
+{
+        int pos;
+        u32 status;
+
+        pos = pci_find_aer_capability(dev);
+        if (!pos)
+                return -EIO;
+
+        pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &status);
+        pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS, status);
+
+        return 0;
+}
+
 static int find_device_iter(struct device *device, void *data)
 {
         struct pci_dev *dev;
@@ -733,20 +746,8 @@ void aer_delete_rootport(struct aer_rpc *rpc)
  **/
 int aer_init(struct pcie_device *dev)
 {
-        int status;
-
-        /* Run _OSC Method */
-        status = aer_osc_setup(dev->port);
-
-        if(status != OSC_METHOD_RUN_SUCCESS) {
-                printk(KERN_DEBUG "%s: AER service init fails - %s\n",
-                __FUNCTION__,
-                (status == OSC_METHOD_NOT_SUPPORTED) ?
-                        "No ACPI _OSC support" : "Run ACPI _OSC fails");
-
-                if (!forceload)
-                        return status;
-        }
+        if (aer_osc_setup(dev) && !forceload)
+                return -ENXIO;
 
         return AER_SUCCESS;
 }
@@ -755,4 +756,5 @@ EXPORT_SYMBOL_GPL(pci_find_aer_capability);
 EXPORT_SYMBOL_GPL(pci_enable_pcie_error_reporting);
 EXPORT_SYMBOL_GPL(pci_disable_pcie_error_reporting);
 EXPORT_SYMBOL_GPL(pci_cleanup_aer_uncorrect_error_status);
+EXPORT_SYMBOL_GPL(pci_cleanup_aer_correct_error_status);
 
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 08783bd381f5..a7bce75c6732 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -654,7 +654,7 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass
                                pcibios_assign_all_busses() ? " " :
                                " (try 'pci=assign-busses')");
                         printk(KERN_WARNING "Please report the result to "
-                               "linux-kernel to fix this permanently\n");
+                               "<bk@suse.de> to fix this permanently\n");
                 }
                 bus = bus->parent;
         }
@@ -700,6 +700,7 @@ static int pci_setup_device(struct pci_dev * dev)
                 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 
         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
+        dev->revision = class & 0xff;
         class >>= 8;                                /* upper 3 bytes */
         dev->class = class;
         class >>= 8;
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index 0425a7b7350d..cfa0dfe61b1a 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -480,7 +480,6 @@ static int __init pci_proc_init(void)
 __initcall(pci_proc_init);
 
 #ifdef CONFIG_HOTPLUG
-EXPORT_SYMBOL(pci_proc_attach_device);
 EXPORT_SYMBOL(pci_proc_detach_bus);
 #endif
 
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 01d8f8a8843c..c559085c89a5 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -587,10 +587,7 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_VIA,	PCI_DEVICE_ID_VIA_8237,		quirk_via_v
  */
 static void __devinit quirk_amd_ioapic(struct pci_dev *dev)
 {
-        u8 rev;
-
-        pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
-        if (rev >= 0x02) {
+        if (dev->revision >= 0x02) {
                 printk(KERN_WARNING "I/O APIC: AMD Erratum #22 may be present. In the event of instability try\n");
                 printk(KERN_WARNING "        : booting with the \"noapic\" option.\n");
         }
@@ -610,13 +607,12 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_SI,	PCI_ANY_ID,			quirk_ioapic_rmw );
 #define AMD8131_NIOAMODE_BIT 0
 static void quirk_amd_8131_ioapic(struct pci_dev *dev)
 { 
-        unsigned char revid, tmp;
+        unsigned char tmp;
         
         if (nr_ioapics == 0) 
                 return;
 
-        pci_read_config_byte(dev, PCI_REVISION_ID, &revid);
-        if (revid == AMD8131_revA0 || revid == AMD8131_revB0) {
+        if (dev->revision == AMD8131_revA0 || dev->revision == AMD8131_revB0) {
                 printk(KERN_INFO "Fixing up AMD8131 IOAPIC mode\n"); 
                 pci_read_config_byte( dev, AMD8131_MISC, &tmp);
                 tmp &= ~(1 << AMD8131_NIOAMODE_BIT);
@@ -627,6 +623,22 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_
 DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_amd_8131_ioapic);
 #endif /* CONFIG_X86_IO_APIC */
 
+/*
+ * Some settings of MMRBC can lead to data corruption so block changes.
+ * See AMD 8131 HyperTransport PCI-X Tunnel Revision Guide
+ */
+static void __init quirk_amd_8131_mmrbc(struct pci_dev *dev)
+{
+        unsigned char revid;
+
+        pci_read_config_byte(dev, PCI_REVISION_ID, &revid);
+        if (dev->subordinate && revid <= 0x12) {
+                printk(KERN_INFO "AMD8131 rev %x detected, disabling PCI-X "
+                                "MMRBC\n", revid);
+                dev->subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MMRBC;
+        }
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE, quirk_amd_8131_mmrbc);
 
 /*
  * FIXME: it is questionable that quirk_via_acpi
@@ -843,10 +855,8 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_CYRIX,	PCI_DEVICE_ID_CYRIX_PCI_MASTER, qu
 static void quirk_disable_pxb(struct pci_dev *pdev)
 {
         u16 config;
-        u8 rev;
         
-        pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
-        if (rev != 0x04)                /* Only C0 requires this */
+        if (pdev->revision != 0x04)             /* Only C0 requires this */
                 return;
         pci_read_config_word(pdev, 0x40, &config);
         if (config & (1<<6)) {
diff --git a/drivers/pci/search.c b/drivers/pci/search.c
index c13232435dc0..9f7090fa8771 100644
--- a/drivers/pci/search.c
+++ b/drivers/pci/search.c
@@ -139,12 +139,14 @@ struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
 }
 
 /**
- * pci_get_bus_and_slot - locate PCI device from a given PCI slot
+ * pci_get_bus_and_slot - locate PCI device from a given PCI bus & slot
  * @bus: number of PCI bus on which desired PCI device resides
  * @devfn: encodes number of PCI slot in which the desired PCI
  * device resides and the logical device number within that slot
  * in case of multi-function devices.
  *
+ * Note: the bus/slot search is limited to PCI domain (segment) 0.
+ *
  * Given a PCI bus and slot/function number, the desired PCI device
  * is located in system global list of PCI devices.  If the device
  * is found, a pointer to its data structure is returned.  If no
@@ -157,7 +159,8 @@ struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn)
         struct pci_dev *dev = NULL;
 
         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
-                if (dev->bus->number == bus && dev->devfn == devfn)
+                if (pci_domain_nr(dev->bus) == 0 &&
+                   (dev->bus->number == bus && dev->devfn == devfn))
                         return dev;
         }
         return NULL;
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 5ec297d7a5b4..5e5191ec8de6 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -34,8 +34,6 @@
 #define DBG(x...)
 #endif
 
-#define ROUND_UP(x, a)          (((x) + (a) - 1) & ~((a) - 1))
-
 static void pbus_assign_resources_sorted(struct pci_bus *bus)
 {
         struct pci_dev *dev;
@@ -310,7 +308,7 @@ static void pbus_size_io(struct pci_bus *bus)
 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
         size = (size & 0xff) + ((size & ~0xffUL) << 2);
 #endif
-        size = ROUND_UP(size + size1, 4096);
+        size = ALIGN(size + size1, 4096);
         if (!size) {
                 b_res->flags = 0;
                 return;
@@ -378,11 +376,11 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask, unsigned long
 
                 if (!align)
                         min_align = align1;
-                else if (ROUND_UP(align + min_align, min_align) < align1)
+                else if (ALIGN(align + min_align, min_align) < align1)
                         min_align = align1 >> 1;
                 align += aligns[order];
         }
-        size = ROUND_UP(size, min_align);
+        size = ALIGN(size, min_align);
         if (!size) {
                 b_res->flags = 0;
                 return 1;
diff --git a/drivers/pci/syscall.c b/drivers/pci/syscall.c
index 9d37fec27f24..2ac050d7f8cf 100644
--- a/drivers/pci/syscall.c
+++ b/drivers/pci/syscall.c
@@ -23,14 +23,14 @@ sys_pciconfig_read(unsigned long bus, unsigned long dfn,
         u8 byte;
         u16 word;
         u32 dword;
-        long err, cfg_ret;
+        long err;
+        long cfg_ret;
 
-        err = -EPERM;
         if (!capable(CAP_SYS_ADMIN))
-                goto error;
+                return -EPERM;
 
         err = -ENODEV;
-        dev = pci_find_slot(bus, dfn);
+        dev = pci_get_bus_and_slot(bus, dfn);
         if (!dev)
                 goto error;
 
@@ -66,7 +66,8 @@ sys_pciconfig_read(unsigned long bus, unsigned long dfn,
         case 4:
                 err = put_user(dword, (unsigned int __user *)buf);
                 break;
-        };
+        }
+        pci_dev_put(dev);
         return err;
 
 error:
@@ -83,7 +84,8 @@ error:
         case 4:
                 put_user(-1, (unsigned int __user *)buf);
                 break;
-        };
+        }
+        pci_dev_put(dev);
         return err;
 }
 
@@ -101,7 +103,7 @@ sys_pciconfig_write(unsigned long bus, unsigned long dfn,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        dev = pci_find_slot(bus, dfn);
+        dev = pci_get_bus_and_slot(bus, dfn);
         if (!dev)
                 return -ENODEV;
 
@@ -137,8 +139,8 @@ sys_pciconfig_write(unsigned long bus, unsigned long dfn,
         default:
                 err = -EINVAL;
                 break;
-        };
+        }
         unlock_kernel();
-
+        pci_dev_put(dev);
         return err;
 }