15 files changed, 119 insertions, 288 deletions

diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index 0a19708074c..0157708d474 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -36,6 +36,7 @@
 #include <linux/tboot.h>
 #include <linux/dmi.h>
 #include <linux/slab.h>
+#include <asm/iommu_table.h>
 
 #define PREFIX "DMAR: "
 
@@ -687,7 +688,7 @@ failed:
         return 0;
 }
 
-void __init detect_intel_iommu(void)
+int __init detect_intel_iommu(void)
 {
         int ret;
 
@@ -723,6 +724,8 @@ void __init detect_intel_iommu(void)
         }
         early_acpi_os_unmap_memory(dmar_tbl, dmar_tbl_size);
         dmar_tbl = NULL;
+
+        return ret ? 1 : -ENODEV;
 }
 
 
@@ -1221,9 +1224,9 @@ const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type)
         }
 }
 
-void dmar_msi_unmask(unsigned int irq)
+void dmar_msi_unmask(struct irq_data *data)
 {
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_data_get_irq_data(data);
         unsigned long flag;
 
         /* unmask it */
@@ -1234,10 +1237,10 @@ void dmar_msi_unmask(unsigned int irq)
         spin_unlock_irqrestore(&iommu->register_lock, flag);
 }
 
-void dmar_msi_mask(unsigned int irq)
+void dmar_msi_mask(struct irq_data *data)
 {
         unsigned long flag;
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_data_get_irq_data(data);
 
         /* mask it */
         spin_lock_irqsave(&iommu->register_lock, flag);
@@ -1455,3 +1458,4 @@ int __init dmar_ir_support(void)
                 return 0;
         return dmar->flags & 0x1;
 }
+IOMMU_INIT_POST(detect_intel_iommu);
diff --git a/drivers/pci/hotplug/cpqphp_sysfs.c b/drivers/pci/hotplug/cpqphp_sysfs.c
index 56215322930..4cb30447a48 100644
--- a/drivers/pci/hotplug/cpqphp_sysfs.c
+++ b/drivers/pci/hotplug/cpqphp_sysfs.c
@@ -34,10 +34,11 @@
 #include <linux/workqueue.h>
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/debugfs.h>
 #include "cpqphp.h"
 
+static DEFINE_MUTEX(cpqphp_mutex);
 static int show_ctrl (struct controller *ctrl, char *buf)
 {
         char *out = buf;
@@ -147,7 +148,7 @@ static int open(struct inode *inode, struct file *file)
         struct ctrl_dbg *dbg;
         int retval = -ENOMEM;
 
-        lock_kernel();
+        mutex_lock(&cpqphp_mutex);
         dbg = kmalloc(sizeof(*dbg), GFP_KERNEL);
         if (!dbg)
                 goto exit;
@@ -160,7 +161,7 @@ static int open(struct inode *inode, struct file *file)
         file->private_data = dbg;
         retval = 0;
 exit:
-        unlock_kernel();
+        mutex_unlock(&cpqphp_mutex);
         return retval;
 }
 
@@ -169,7 +170,7 @@ static loff_t lseek(struct file *file, loff_t off, int whence)
         struct ctrl_dbg *dbg;
         loff_t new = -1;
 
-        lock_kernel();
+        mutex_lock(&cpqphp_mutex);
         dbg = file->private_data;
 
         switch (whence) {
@@ -181,10 +182,10 @@ static loff_t lseek(struct file *file, loff_t off, int whence)
                 break;
         }
         if (new < 0 || new > dbg->size) {
-                unlock_kernel();
+                mutex_unlock(&cpqphp_mutex);
                 return -EINVAL;
         }
-        unlock_kernel();
+        mutex_unlock(&cpqphp_mutex);
         return (file->f_pos = new);
 }
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 73d51398926..838f571027b 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -36,6 +36,7 @@
 #include <linux/sched.h>                /* signal_pending() */
 #include <linux/pcieport_if.h>
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
 
 #define MY_NAME "pciehp"
 
@@ -44,6 +45,7 @@ extern int pciehp_poll_time;
 extern int pciehp_debug;
 extern int pciehp_force;
 extern struct workqueue_struct *pciehp_wq;
+extern struct workqueue_struct *pciehp_ordered_wq;
 
 #define dbg(format, arg...)                                             \
 do {                                                                    \
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index aa5f3ff629f..7ac8358df8f 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -43,6 +43,7 @@ int pciehp_poll_mode;
 int pciehp_poll_time;
 int pciehp_force;
 struct workqueue_struct *pciehp_wq;
+struct workqueue_struct *pciehp_ordered_wq;
 
 #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>"
@@ -340,18 +341,33 @@ static int __init pcied_init(void)
 {
         int retval = 0;
 
+        pciehp_wq = alloc_workqueue("pciehp", 0, 0);
+        if (!pciehp_wq)
+                return -ENOMEM;
+
+        pciehp_ordered_wq = alloc_ordered_workqueue("pciehp_ordered", 0);
+        if (!pciehp_ordered_wq) {
+                destroy_workqueue(pciehp_wq);
+                return -ENOMEM;
+        }
+
         pciehp_firmware_init();
         retval = pcie_port_service_register(&hpdriver_portdrv);
         dbg("pcie_port_service_register = %d\n", retval);
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
-        if (retval)
+        if (retval) {
+                destroy_workqueue(pciehp_ordered_wq);
+                destroy_workqueue(pciehp_wq);
                 dbg("Failure to register service\n");
+        }
         return retval;
 }
 
 static void __exit pcied_cleanup(void)
 {
         dbg("unload_pciehpd()\n");
+        destroy_workqueue(pciehp_ordered_wq);
+        destroy_workqueue(pciehp_wq);
         pcie_port_service_unregister(&hpdriver_portdrv);
         info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
 }
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 8f58148be04..085dbb5fc16 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -32,7 +32,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/workqueue.h>
 #include "../pci.h"
 #include "pciehp.h"
 
@@ -50,7 +49,7 @@ static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
         info->p_slot = p_slot;
         INIT_WORK(&info->work, interrupt_event_handler);
 
-        schedule_work(&info->work);
+        queue_work(pciehp_wq, &info->work);
 
         return 0;
 }
@@ -345,7 +344,7 @@ void pciehp_queue_pushbutton_work(struct work_struct *work)
                 kfree(info);
                 goto out;
         }
-        queue_work(pciehp_wq, &info->work);
+        queue_work(pciehp_ordered_wq, &info->work);
  out:
         mutex_unlock(&p_slot->lock);
 }
@@ -378,7 +377,7 @@ static void handle_button_press_event(struct slot *p_slot)
                 if (ATTN_LED(ctrl))
                         pciehp_set_attention_status(p_slot, 0);
 
-                schedule_delayed_work(&p_slot->work, 5*HZ);
+                queue_delayed_work(pciehp_wq, &p_slot->work, 5*HZ);
                 break;
         case BLINKINGOFF_STATE:
         case BLINKINGON_STATE:
@@ -440,7 +439,7 @@ static void handle_surprise_event(struct slot *p_slot)
         else
                 p_slot->state = POWERON_STATE;
 
-        queue_work(pciehp_wq, &info->work);
+        queue_work(pciehp_ordered_wq, &info->work);
 }
 
 static void interrupt_event_handler(struct work_struct *work)
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 0cd42047d89..50a23da5d24 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -41,8 +41,6 @@
 #include "../pci.h"
 #include "pciehp.h"
 
-static atomic_t pciehp_num_controllers = ATOMIC_INIT(0);
-
 static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
 {
         struct pci_dev *dev = ctrl->pcie->port;
@@ -805,8 +803,8 @@ static void pcie_cleanup_slot(struct controller *ctrl)
 {
         struct slot *slot = ctrl->slot;
         cancel_delayed_work(&slot->work);
-        flush_scheduled_work();
         flush_workqueue(pciehp_wq);
+        flush_workqueue(pciehp_ordered_wq);
         kfree(slot);
 }
 
@@ -912,16 +910,6 @@ struct controller *pcie_init(struct pcie_device *dev)
         /* Disable sotfware notification */
         pcie_disable_notification(ctrl);
 
-        /*
-         * If this is the first controller to be initialized,
-         * initialize the pciehp work queue
-         */
-        if (atomic_add_return(1, &pciehp_num_controllers) == 1) {
-                pciehp_wq = create_singlethread_workqueue("pciehpd");
-                if (!pciehp_wq)
-                        goto abort_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);
@@ -941,11 +929,5 @@ void pciehp_release_ctrl(struct controller *ctrl)
 {
         pcie_shutdown_notification(ctrl);
         pcie_cleanup_slot(ctrl);
-        /*
-         * If this is the last controller to be released, destroy the
-         * pciehp work queue
-         */
-        if (atomic_dec_and_test(&pciehp_num_controllers))
-                destroy_workqueue(pciehp_wq);
         kfree(ctrl);
 }
diff --git a/drivers/pci/hotplug/shpchp.h b/drivers/pci/hotplug/shpchp.h
index d2627e1c3ac..e0c90e643b5 100644
--- a/drivers/pci/hotplug/shpchp.h
+++ b/drivers/pci/hotplug/shpchp.h
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/sched.h>        /* signal_pending(), struct timer_list */
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
 
 #if !defined(MODULE)
         #define MY_NAME "shpchp"
@@ -46,6 +47,7 @@ extern int shpchp_poll_mode;
 extern int shpchp_poll_time;
 extern int shpchp_debug;
 extern struct workqueue_struct *shpchp_wq;
+extern struct workqueue_struct *shpchp_ordered_wq;
 
 #define dbg(format, arg...)                                             \
 do {                                                                    \
diff --git a/drivers/pci/hotplug/shpchp_core.c b/drivers/pci/hotplug/shpchp_core.c
index a7bd5048396..aca972bbfb4 100644
--- a/drivers/pci/hotplug/shpchp_core.c
+++ b/drivers/pci/hotplug/shpchp_core.c
@@ -33,7 +33,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/workqueue.h>
 #include "shpchp.h"
 
 /* Global variables */
@@ -41,6 +40,7 @@ int shpchp_debug;
 int shpchp_poll_mode;
 int shpchp_poll_time;
 struct workqueue_struct *shpchp_wq;
+struct workqueue_struct *shpchp_ordered_wq;
 
 #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>"
@@ -174,8 +174,8 @@ void cleanup_slots(struct controller *ctrl)
                 slot = list_entry(tmp, struct slot, slot_list);
                 list_del(&slot->slot_list);
                 cancel_delayed_work(&slot->work);
-                flush_scheduled_work();
                 flush_workqueue(shpchp_wq);
+                flush_workqueue(shpchp_ordered_wq);
                 pci_hp_deregister(slot->hotplug_slot);
         }
 }
@@ -360,9 +360,23 @@ static int __init shpcd_init(void)
 {
         int retval = 0;
 
+        shpchp_wq = alloc_ordered_workqueue("shpchp", 0);
+        if (!shpchp_wq)
+                return -ENOMEM;
+
+        shpchp_ordered_wq = alloc_ordered_workqueue("shpchp_ordered", 0);
+        if (!shpchp_ordered_wq) {
+                destroy_workqueue(shpchp_wq);
+                return -ENOMEM;
+        }
+
         retval = pci_register_driver(&shpc_driver);
         dbg("%s: pci_register_driver = %d\n", __func__, retval);
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
+        if (retval) {
+                destroy_workqueue(shpchp_ordered_wq);
+                destroy_workqueue(shpchp_wq);
+        }
         return retval;
 }
 
@@ -370,6 +384,8 @@ static void __exit shpcd_cleanup(void)
 {
         dbg("unload_shpchpd()\n");
         pci_unregister_driver(&shpc_driver);
+        destroy_workqueue(shpchp_ordered_wq);
+        destroy_workqueue(shpchp_wq);
         info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
 }
 
diff --git a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c
index 3387fbfb0c5..b00b09bdd38 100644
--- a/drivers/pci/hotplug/shpchp_ctrl.c
+++ b/drivers/pci/hotplug/shpchp_ctrl.c
@@ -32,7 +32,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/workqueue.h>
 #include "../pci.h"
 #include "shpchp.h"
 
@@ -52,7 +51,7 @@ static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
         info->p_slot = p_slot;
         INIT_WORK(&info->work, interrupt_event_handler);
 
-        schedule_work(&info->work);
+        queue_work(shpchp_wq, &info->work);
 
         return 0;
 }
@@ -457,7 +456,7 @@ void shpchp_queue_pushbutton_work(struct work_struct *work)
                 kfree(info);
                 goto out;
         }
-        queue_work(shpchp_wq, &info->work);
+        queue_work(shpchp_ordered_wq, &info->work);
  out:
         mutex_unlock(&p_slot->lock);
 }
@@ -505,7 +504,7 @@ static void handle_button_press_event(struct slot *p_slot)
                 p_slot->hpc_ops->green_led_blink(p_slot);
                 p_slot->hpc_ops->set_attention_status(p_slot, 0);
 
-                schedule_delayed_work(&p_slot->work, 5*HZ);
+                queue_delayed_work(shpchp_wq, &p_slot->work, 5*HZ);
                 break;
         case BLINKINGOFF_STATE:
         case BLINKINGON_STATE:
diff --git a/drivers/pci/hotplug/shpchp_hpc.c b/drivers/pci/hotplug/shpchp_hpc.c
index d3985e7deab..36547f0ce30 100644
--- a/drivers/pci/hotplug/shpchp_hpc.c
+++ b/drivers/pci/hotplug/shpchp_hpc.c
@@ -179,8 +179,6 @@
 #define SLOT_EVENT_LATCH        0x2
 #define SLOT_SERR_INT_MASK      0x3
 
-static atomic_t shpchp_num_controllers = ATOMIC_INIT(0);
-
 static irqreturn_t shpc_isr(int irq, void *dev_id);
 static void start_int_poll_timer(struct controller *ctrl, int sec);
 static int hpc_check_cmd_status(struct controller *ctrl);
@@ -614,13 +612,6 @@ static void hpc_release_ctlr(struct controller *ctrl)
 
         iounmap(ctrl->creg);
         release_mem_region(ctrl->mmio_base, ctrl->mmio_size);
-
-        /*
-         * If this is the last controller to be released, destroy the
-         * shpchpd work queue
-         */
-        if (atomic_dec_and_test(&shpchp_num_controllers))
-                destroy_workqueue(shpchp_wq);
 }
 
 static int hpc_power_on_slot(struct slot * slot)
@@ -1077,9 +1068,8 @@ int shpc_init(struct controller *ctrl, struct pci_dev *pdev)
 
                 rc = request_irq(ctrl->pci_dev->irq, shpc_isr, IRQF_SHARED,
                                  MY_NAME, (void *)ctrl);
-                ctrl_dbg(ctrl, "request_irq %d for hpc%d (returns %d)\n",
-                         ctrl->pci_dev->irq,
-                    atomic_read(&shpchp_num_controllers), rc);
+                ctrl_dbg(ctrl, "request_irq %d (returns %d)\n",
+                         ctrl->pci_dev->irq, rc);
                 if (rc) {
                         ctrl_err(ctrl, "Can't get irq %d for the hotplug "
                                  "controller\n", ctrl->pci_dev->irq);
@@ -1092,18 +1082,6 @@ int shpc_init(struct controller *ctrl, struct pci_dev *pdev)
         shpc_get_cur_bus_speed(ctrl);
 
         /*
-         * If this is the first controller to be initialized,
-         * initialize the shpchpd work queue
-         */
-        if (atomic_add_return(1, &shpchp_num_controllers) == 1) {
-                shpchp_wq = create_singlethread_workqueue("shpchpd");
-                if (!shpchp_wq) {
-                        rc = -ENOMEM;
-                        goto abort_iounmap;
-                }
-        }
-
-        /*
          * Unmask all event interrupts of all slots
          */
         for (hp_slot = 0; hp_slot < ctrl->num_slots; hp_slot++) {
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
index 98abf8b9129..834842aa5bb 100644
--- a/drivers/pci/htirq.c
+++ b/drivers/pci/htirq.c
@@ -57,28 +57,22 @@ void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
         *msg = cfg->msg;
 }
 
-void mask_ht_irq(unsigned int irq)
+void mask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg;
-        struct ht_irq_msg msg;
-
-        cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_msg msg = cfg->msg;
 
-        msg = cfg->msg;
         msg.address_lo |= 1;
-        write_ht_irq_msg(irq, &msg);
+        write_ht_irq_msg(data->irq, &msg);
 }
 
-void unmask_ht_irq(unsigned int irq)
+void unmask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg;
-        struct ht_irq_msg msg;
-
-        cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_msg msg = cfg->msg;
 
-        msg = cfg->msg;
         msg.address_lo &= ~1;
-        write_ht_irq_msg(irq, &msg);
+        write_ht_irq_msg(data->irq, &msg);
 }
 
 /**
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index fd1d2867cdc..ec87cd66f3e 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -46,109 +46,24 @@ static __init int setup_intremap(char *str)
 }
 early_param("intremap", setup_intremap);
 
-struct irq_2_iommu {
-        struct intel_iommu *iommu;
-        u16 irte_index;
-        u16 sub_handle;
-        u8  irte_mask;
-};
-
-#ifdef CONFIG_GENERIC_HARDIRQS
-static struct irq_2_iommu *get_one_free_irq_2_iommu(int node)
-{
-        struct irq_2_iommu *iommu;
-
-        iommu = kzalloc_node(sizeof(*iommu), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "alloc irq_2_iommu on node %d\n", node);
-
-        return iommu;
-}
-
-static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-
-        if (WARN_ON_ONCE(!desc))
-                return NULL;
-
-        return desc->irq_2_iommu;
-}
-
-static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
-{
-        struct irq_desc *desc;
-        struct irq_2_iommu *irq_iommu;
-
-        desc = irq_to_desc(irq);
-        if (!desc) {
-                printk(KERN_INFO "can not get irq_desc for %d\n", irq);
-                return NULL;
-        }
-
-        irq_iommu = desc->irq_2_iommu;
-
-        if (!irq_iommu)
-                desc->irq_2_iommu = get_one_free_irq_2_iommu(irq_node(irq));
-
-        return desc->irq_2_iommu;
-}
-
-#else /* !CONFIG_SPARSE_IRQ */
-
-static struct irq_2_iommu irq_2_iommuX[NR_IRQS];
-
-static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
-{
-        if (irq < nr_irqs)
-                return &irq_2_iommuX[irq];
-
-        return NULL;
-}
-static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
-{
-        return irq_2_iommu(irq);
-}
-#endif
-
 static DEFINE_SPINLOCK(irq_2_ir_lock);
 
-static struct irq_2_iommu *valid_irq_2_iommu(unsigned int irq)
-{
-        struct irq_2_iommu *irq_iommu;
-
-        irq_iommu = irq_2_iommu(irq);
-
-        if (!irq_iommu)
-                return NULL;
-
-        if (!irq_iommu->iommu)
-                return NULL;
-
-        return irq_iommu;
-}
-
-int irq_remapped(int irq)
+static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
 {
-        return valid_irq_2_iommu(irq) != NULL;
+        struct irq_cfg *cfg = get_irq_chip_data(irq);
+        return cfg ? &cfg->irq_2_iommu : NULL;
 }
 
 int get_irte(int irq, struct irte *entry)
 {
-        int index;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int index;
 
-        if (!entry)
+        if (!entry || !irq_iommu)
                 return -1;
 
         spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
 
         index = irq_iommu->irte_index + irq_iommu->sub_handle;
         *entry = *(irq_iommu->iommu->ir_table->base + index);
@@ -160,20 +75,14 @@ int get_irte(int irq, struct irte *entry)
 int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
 {
         struct ir_table *table = iommu->ir_table;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         u16 index, start_index;
         unsigned int mask = 0;
         unsigned long flags;
         int i;
 
-        if (!count)
-                return -1;
-
-#ifndef CONFIG_SPARSE_IRQ
-        /* protect irq_2_iommu_alloc later */
-        if (irq >= nr_irqs)
+        if (!count || !irq_iommu)
                 return -1;
-#endif
 
         /*
          * start the IRTE search from index 0.
@@ -214,13 +123,6 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         for (i = index; i < index + count; i++)
                 table->base[i].present = 1;
 
-        irq_iommu = irq_2_iommu_alloc(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                printk(KERN_ERR "can't allocate irq_2_iommu\n");
-                return -1;
-        }
-
         irq_iommu->iommu = iommu;
         irq_iommu->irte_index =  index;
         irq_iommu->sub_handle = 0;
@@ -244,17 +146,14 @@ static int qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
 
 int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 {
-        int index;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int index;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
 
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
         *sub_handle = irq_iommu->sub_handle;
         index = irq_iommu->irte_index;
         spin_unlock_irqrestore(&irq_2_ir_lock, flags);
@@ -263,18 +162,13 @@ int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 
 int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 {
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-
-        irq_iommu = irq_2_iommu_alloc(irq);
-
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                printk(KERN_ERR "can't allocate irq_2_iommu\n");
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         irq_iommu->iommu = iommu;
         irq_iommu->irte_index = index;
@@ -286,43 +180,18 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
         return 0;
 }
 
-int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index)
-{
-        struct irq_2_iommu *irq_iommu;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
-
-        irq_iommu->iommu = NULL;
-        irq_iommu->irte_index = 0;
-        irq_iommu->sub_handle = 0;
-        irq_2_iommu(irq)->irte_mask = 0;
-
-        spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-
-        return 0;
-}
-
 int modify_irte(int irq, struct irte *irte_modified)
 {
-        int rc;
-        int index;
-        struct irte *irte;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         struct intel_iommu *iommu;
-        struct irq_2_iommu *irq_iommu;
         unsigned long flags;
+        struct irte *irte;
+        int rc, index;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         iommu = irq_iommu->iommu;
 
@@ -339,31 +208,6 @@ int modify_irte(int irq, struct irte *irte_modified)
         return rc;
 }
 
-int flush_irte(int irq)
-{
-        int rc;
-        int index;
-        struct intel_iommu *iommu;
-        struct irq_2_iommu *irq_iommu;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
-
-        iommu = irq_iommu->iommu;
-
-        index = irq_iommu->irte_index + irq_iommu->sub_handle;
-
-        rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask);
-        spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-
-        return rc;
-}
-
 struct intel_iommu *map_hpet_to_ir(u8 hpet_id)
 {
         int i;
@@ -420,16 +264,14 @@ static int clear_entries(struct irq_2_iommu *irq_iommu)
 
 int free_irte(int irq)
 {
-        int rc = 0;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int rc;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         rc = clear_entries(irq_iommu);
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 69b7be33b3a..5fcf5aec680 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -170,33 +170,31 @@ static void msix_mask_irq(struct msi_desc *desc, u32 flag)
         desc->masked = __msix_mask_irq(desc, flag);
 }
 
-static void msi_set_mask_bit(unsigned irq, u32 flag)
+static void msi_set_mask_bit(struct irq_data *data, u32 flag)
 {
-        struct msi_desc *desc = get_irq_msi(irq);
+        struct msi_desc *desc = irq_data_get_msi(data);
 
         if (desc->msi_attrib.is_msix) {
                 msix_mask_irq(desc, flag);
                 readl(desc->mask_base);         /* Flush write to device */
         } else {
-                unsigned offset = irq - desc->dev->irq;
+                unsigned offset = data->irq - desc->dev->irq;
                 msi_mask_irq(desc, 1 << offset, flag << offset);
         }
 }
 
-void mask_msi_irq(unsigned int irq)
+void mask_msi_irq(struct irq_data *data)
 {
-        msi_set_mask_bit(irq, 1);
+        msi_set_mask_bit(data, 1);
 }
 
-void unmask_msi_irq(unsigned int irq)
+void unmask_msi_irq(struct irq_data *data)
 {
-        msi_set_mask_bit(irq, 0);
+        msi_set_mask_bit(data, 0);
 }
 
-void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         BUG_ON(entry->dev->current_state != PCI_D0);
 
         if (entry->msi_attrib.is_msix) {
@@ -227,15 +225,13 @@ void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void read_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        read_msi_msg_desc(desc, msg);
+        __read_msi_msg(entry, msg);
 }
 
-void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         /* Assert that the cache is valid, assuming that
          * valid messages are not all-zeroes. */
         BUG_ON(!(entry->msg.address_hi | entry->msg.address_lo |
@@ -246,15 +242,13 @@ void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        get_cached_msi_msg_desc(desc, msg);
+        __get_cached_msi_msg(entry, msg);
 }
 
-void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         if (entry->dev->current_state != PCI_D0) {
                 /* Don't touch the hardware now */
         } else if (entry->msi_attrib.is_msix) {
@@ -292,9 +286,9 @@ void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void write_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        write_msi_msg_desc(desc, msg);
+        __write_msi_msg(entry, msg);
 }
 
 static void free_msi_irqs(struct pci_dev *dev)
diff --git a/drivers/pci/pcie/aer/aer_inject.c b/drivers/pci/pcie/aer/aer_inject.c
index 909924692b8..b3cf6223f63 100644
--- a/drivers/pci/pcie/aer/aer_inject.c
+++ b/drivers/pci/pcie/aer/aer_inject.c
@@ -472,6 +472,7 @@ static ssize_t aer_inject_write(struct file *filp, const char __user *ubuf,
 static const struct file_operations aer_inject_fops = {
         .write = aer_inject_write,
         .owner = THIS_MODULE,
+        .llseek = noop_llseek,
 };
 
 static struct miscdevice aer_inject_device = {
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 034430690a5..f5c63fe9db5 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -226,6 +226,7 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 	PCI_DEVICE_ID_INTEL_82439TX, 	quir
  *      VIA Apollo KT133 needs PCI latency patch
  *      Made according to a windows driver based patch by George E. Breese
  *      see PCI Latency Adjust on http://www.viahardware.com/download/viatweak.shtm
+ *      and http://www.georgebreese.com/net/software/#PCI
  *      Also see http://www.au-ja.org/review-kt133a-1-en.phtml for
  *      the info on which Mr Breese based his work.
  *
@@ -1016,7 +1017,7 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TOSHIBA,	0x605,	quirk_transparent_bridge)
 /*
  * Common misconfiguration of the MediaGX/Geode PCI master that will
  * reduce PCI bandwidth from 70MB/s to 25MB/s.  See the GXM/GXLV/GX1
- * datasheets found at http://www.national.com/ds/GX for info on what
+ * datasheets found at http://www.national.com/analog for info on what
  * these bits do.  <christer@weinigel.se>
  */
 static void quirk_mediagx_master(struct pci_dev *dev)