Merge branch 'irq-irqdomain-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull irq domain updates from Thomas Gleixner:
 "The real interesting irq updates:

   - Support for hierarchical irq domains:

     For complex interrupt routing scenarios where more than one
     interrupt related chip is involved we had no proper representation
     in the generic interrupt infrastructure so far.  That made people
     implement rather ugly constructs in their nested irq chip
     implementations.  The main offenders are x86 and arm/gic.

     To distangle that mess we have now hierarchical irqdomains which
     seperate the various interrupt chips and connect them via the
     hierarchical domains.  That keeps the domain specific details
     internal to the particular hierarchy level and removes the
     criss/cross referencing of chip internals.  The resulting hierarchy
     for a complex x86 system will look like this:

        vector          mapped: 74
          msi-0         mapped: 2
          dmar-ir-1     mapped: 69
            ioapic-1    mapped: 4
            ioapic-0    mapped: 20
            pci-msi-2   mapped: 45
          dmar-ir-0     mapped: 3
            ioapic-2    mapped: 1
            pci-msi-1   mapped: 2
          htirq         mapped: 0

     Neither ioapic nor pci-msi know about the dmar interrupt remapping
     between themself and the vector domain.  If interrupt remapping is
     disabled ioapic and pci-msi become direct childs of the vector
     domain.

     In hindsight we should have done that years ago, but in hindsight
     we always know better :)

   - Support for generic MSI interrupt domain handling

     We have more and more non PCI related MSI interrupts, so providing
     a generic infrastructure for this is better than having all
     affected architectures implementing their own private hacks.

   - Support for PCI-MSI interrupt domain handling, based on the generic
     MSI support.

     This part carries the pci/msi branch from Bjorn Helgaas pci tree to
     avoid a massive conflict.  The PCI/MSI parts are acked by Bjorn.

  I have two more branches on top of this.  The full conversion of x86
  to hierarchical domains and a partial conversion of arm/gic"

* 'irq-irqdomain-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (41 commits)
  genirq: Move irq_chip_write_msi_msg() helper to core
  PCI/MSI: Allow an msi_controller to be associated to an irq domain
  PCI/MSI: Provide mechanism to alloc/free MSI/MSIX interrupt from irqdomain
  PCI/MSI: Enhance core to support hierarchy irqdomain
  PCI/MSI: Move cached entry functions to irq core
  genirq: Provide default callbacks for msi_domain_ops
  genirq: Introduce msi_domain_alloc/free_irqs()
  asm-generic: Add msi.h
  genirq: Add generic msi irq domain support
  genirq: Introduce callback irq_chip.irq_write_msi_msg
  genirq: Work around __irq_set_handler vs stacked domains ordering issues
  irqdomain: Introduce helper function irq_domain_add_hierarchy()
  irqdomain: Implement a method to automatically call parent domains alloc/free
  genirq: Introduce helper irq_domain_set_info() to reduce duplicated code
  genirq: Split out flow handler typedefs into seperate header file
  genirq: Add IRQ_SET_MASK_OK_DONE to support stacked irqchip
  genirq: Introduce irq_chip.irq_compose_msi_msg() to support stacked irqchip
  genirq: Add more helper functions to support stacked irq_chip
  genirq: Introduce helper functions to support stacked irq_chip
  irqdomain: Do irq_find_mapping and set_type for hierarchy irqdomain in case OF
  ...

6 files changed, 1024 insertions, 21 deletions

diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 225086b2652e..9a76e3beda54 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -55,6 +55,21 @@ config GENERIC_IRQ_CHIP
 config IRQ_DOMAIN
         bool
 
+# Support for hierarchical irq domains
+config IRQ_DOMAIN_HIERARCHY
+        bool
+        select IRQ_DOMAIN
+
+# Generic MSI interrupt support
+config GENERIC_MSI_IRQ
+        bool
+
+# Generic MSI hierarchical interrupt domain support
+config GENERIC_MSI_IRQ_DOMAIN
+        bool
+        select IRQ_DOMAIN_HIERARCHY
+        select GENERIC_MSI_IRQ
+
 config HANDLE_DOMAIN_IRQ
         bool
 
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index fff17381f0af..d12123526e2b 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -6,3 +6,4 @@ obj-$(CONFIG_IRQ_DOMAIN) += irqdomain.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
 obj-$(CONFIG_PM_SLEEP) += pm.o
+obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index e5202f00cabc..6f1c7a566b95 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/kernel_stat.h>
+#include <linux/irqdomain.h>
 
 #include <trace/events/irq.h>
 
@@ -178,6 +179,7 @@ int irq_startup(struct irq_desc *desc, bool resend)
         irq_state_clr_disabled(desc);
         desc->depth = 0;
 
+        irq_domain_activate_irq(&desc->irq_data);
         if (desc->irq_data.chip->irq_startup) {
                 ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
                 irq_state_clr_masked(desc);
@@ -199,6 +201,7 @@ void irq_shutdown(struct irq_desc *desc)
                 desc->irq_data.chip->irq_disable(&desc->irq_data);
         else
                 desc->irq_data.chip->irq_mask(&desc->irq_data);
+        irq_domain_deactivate_irq(&desc->irq_data);
         irq_state_set_masked(desc);
 }
 
@@ -728,7 +731,30 @@ __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
         if (!handle) {
                 handle = handle_bad_irq;
         } else {
-                if (WARN_ON(desc->irq_data.chip == &no_irq_chip))
+                struct irq_data *irq_data = &desc->irq_data;
+#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
+                /*
+                 * With hierarchical domains we might run into a
+                 * situation where the outermost chip is not yet set
+                 * up, but the inner chips are there.  Instead of
+                 * bailing we install the handler, but obviously we
+                 * cannot enable/startup the interrupt at this point.
+                 */
+                while (irq_data) {
+                        if (irq_data->chip != &no_irq_chip)
+                                break;
+                        /*
+                         * Bail out if the outer chip is not set up
+                         * and the interrrupt supposed to be started
+                         * right away.
+                         */
+                        if (WARN_ON(is_chained))
+                                goto out;
+                        /* Try the parent */
+                        irq_data = irq_data->parent_data;
+                }
+#endif
+                if (WARN_ON(!irq_data || irq_data->chip == &no_irq_chip))
                         goto out;
         }
 
@@ -847,3 +873,105 @@ void irq_cpu_offline(void)
                 raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 }
+
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+/**
+ * irq_chip_ack_parent - Acknowledge the parent interrupt
+ * @data:       Pointer to interrupt specific data
+ */
+void irq_chip_ack_parent(struct irq_data *data)
+{
+        data = data->parent_data;
+        data->chip->irq_ack(data);
+}
+
+/**
+ * irq_chip_mask_parent - Mask the parent interrupt
+ * @data:       Pointer to interrupt specific data
+ */
+void irq_chip_mask_parent(struct irq_data *data)
+{
+        data = data->parent_data;
+        data->chip->irq_mask(data);
+}
+
+/**
+ * irq_chip_unmask_parent - Unmask the parent interrupt
+ * @data:       Pointer to interrupt specific data
+ */
+void irq_chip_unmask_parent(struct irq_data *data)
+{
+        data = data->parent_data;
+        data->chip->irq_unmask(data);
+}
+
+/**
+ * irq_chip_eoi_parent - Invoke EOI on the parent interrupt
+ * @data:       Pointer to interrupt specific data
+ */
+void irq_chip_eoi_parent(struct irq_data *data)
+{
+        data = data->parent_data;
+        data->chip->irq_eoi(data);
+}
+
+/**
+ * irq_chip_set_affinity_parent - Set affinity on the parent interrupt
+ * @data:       Pointer to interrupt specific data
+ * @dest:       The affinity mask to set
+ * @force:      Flag to enforce setting (disable online checks)
+ *
+ * Conditinal, as the underlying parent chip might not implement it.
+ */
+int irq_chip_set_affinity_parent(struct irq_data *data,
+                                 const struct cpumask *dest, bool force)
+{
+        data = data->parent_data;
+        if (data->chip->irq_set_affinity)
+                return data->chip->irq_set_affinity(data, dest, force);
+
+        return -ENOSYS;
+}
+
+/**
+ * irq_chip_retrigger_hierarchy - Retrigger an interrupt in hardware
+ * @data:       Pointer to interrupt specific data
+ *
+ * Iterate through the domain hierarchy of the interrupt and check
+ * whether a hw retrigger function exists. If yes, invoke it.
+ */
+int irq_chip_retrigger_hierarchy(struct irq_data *data)
+{
+        for (data = data->parent_data; data; data = data->parent_data)
+                if (data->chip && data->chip->irq_retrigger)
+                        return data->chip->irq_retrigger(data);
+
+        return -ENOSYS;
+}
+#endif
+
+/**
+ * irq_chip_compose_msi_msg - Componse msi message for a irq chip
+ * @data:       Pointer to interrupt specific data
+ * @msg:        Pointer to the MSI message
+ *
+ * For hierarchical domains we find the first chip in the hierarchy
+ * which implements the irq_compose_msi_msg callback. For non
+ * hierarchical we use the top level chip.
+ */
+int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg)
+{
+        struct irq_data *pos = NULL;
+
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        for (; data; data = data->parent_data)
+#endif
+                if (data->chip && data->chip->irq_compose_msi_msg)
+                        pos = data;
+        if (!pos)
+                return -ENOSYS;
+
+        pos->chip->irq_compose_msi_msg(pos, msg);
+
+        return 0;
+}
diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 6534ff6ce02e..7fac311057b8 100644
--- a/kernel/irq/irqdomain.c
+++ b/kernel/irq/irqdomain.c
@@ -23,6 +23,10 @@ static DEFINE_MUTEX(irq_domain_mutex);
 static DEFINE_MUTEX(revmap_trees_mutex);
 static struct irq_domain *irq_default_domain;
 
+static int irq_domain_alloc_descs(int virq, unsigned int nr_irqs,
+                                  irq_hw_number_t hwirq, int node);
+static void irq_domain_check_hierarchy(struct irq_domain *domain);
+
 /**
  * __irq_domain_add() - Allocate a new irq_domain data structure
  * @of_node: optional device-tree node of the interrupt controller
@@ -30,7 +34,7 @@ static struct irq_domain *irq_default_domain;
  * @hwirq_max: Maximum number of interrupts supported by controller
  * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
  *              direct mapping
- * @ops: map/unmap domain callbacks
+ * @ops: domain callbacks
  * @host_data: Controller private data pointer
  *
  * Allocates and initialize and irq_domain structure.
@@ -56,6 +60,7 @@ struct irq_domain *__irq_domain_add(struct device_node *of_node, int size,
         domain->hwirq_max = hwirq_max;
         domain->revmap_size = size;
         domain->revmap_direct_max_irq = direct_max;
+        irq_domain_check_hierarchy(domain);
 
         mutex_lock(&irq_domain_mutex);
         list_add(&domain->link, &irq_domain_list);
@@ -109,7 +114,7 @@ EXPORT_SYMBOL_GPL(irq_domain_remove);
  * @first_irq: first number of irq block assigned to the domain,
  *      pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
  *      pre-map all of the irqs in the domain to virqs starting at first_irq.
- * @ops: map/unmap domain callbacks
+ * @ops: domain callbacks
  * @host_data: Controller private data pointer
  *
  * Allocates an irq_domain, and optionally if first_irq is positive then also
@@ -174,10 +179,8 @@ struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
 
         domain = __irq_domain_add(of_node, first_hwirq + size,
                                   first_hwirq + size, 0, ops, host_data);
-        if (!domain)
-                return NULL;
-
-        irq_domain_associate_many(domain, first_irq, first_hwirq, size);
+        if (domain)
+                irq_domain_associate_many(domain, first_irq, first_hwirq, size);
 
         return domain;
 }
@@ -388,7 +391,6 @@ EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
 unsigned int irq_create_mapping(struct irq_domain *domain,
                                 irq_hw_number_t hwirq)
 {
-        unsigned int hint;
         int virq;
 
         pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
@@ -410,12 +412,8 @@ unsigned int irq_create_mapping(struct irq_domain *domain,
         }
 
         /* Allocate a virtual interrupt number */
-        hint = hwirq % nr_irqs;
-        if (hint == 0)
-                hint++;
-        virq = irq_alloc_desc_from(hint, of_node_to_nid(domain->of_node));
-        if (virq <= 0)
-                virq = irq_alloc_desc_from(1, of_node_to_nid(domain->of_node));
+        virq = irq_domain_alloc_descs(-1, 1, hwirq,
+                                      of_node_to_nid(domain->of_node));
         if (virq <= 0) {
                 pr_debug("-> virq allocation failed\n");
                 return 0;
@@ -471,7 +469,7 @@ unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
         struct irq_domain *domain;
         irq_hw_number_t hwirq;
         unsigned int type = IRQ_TYPE_NONE;
-        unsigned int virq;
+        int virq;
 
         domain = irq_data->np ? irq_find_host(irq_data->np) : irq_default_domain;
         if (!domain) {
@@ -489,10 +487,24 @@ unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
                         return 0;
         }
 
-        /* Create mapping */
-        virq = irq_create_mapping(domain, hwirq);
-        if (!virq)
-                return virq;
+        if (irq_domain_is_hierarchy(domain)) {
+                /*
+                 * If we've already configured this interrupt,
+                 * don't do it again, or hell will break loose.
+                 */
+                virq = irq_find_mapping(domain, hwirq);
+                if (virq)
+                        return virq;
+
+                virq = irq_domain_alloc_irqs(domain, 1, NUMA_NO_NODE, irq_data);
+                if (virq <= 0)
+                        return 0;
+        } else {
+                /* Create mapping */
+                virq = irq_create_mapping(domain, hwirq);
+                if (!virq)
+                        return virq;
+        }
 
         /* Set type if specified and different than the current one */
         if (type != IRQ_TYPE_NONE &&
@@ -540,8 +552,8 @@ unsigned int irq_find_mapping(struct irq_domain *domain,
                 return 0;
 
         if (hwirq < domain->revmap_direct_max_irq) {
-                data = irq_get_irq_data(hwirq);
-                if (data && (data->domain == domain) && (data->hwirq == hwirq))
+                data = irq_domain_get_irq_data(domain, hwirq);
+                if (data && data->hwirq == hwirq)
                         return hwirq;
         }
 
@@ -709,3 +721,518 @@ const struct irq_domain_ops irq_domain_simple_ops = {
         .xlate = irq_domain_xlate_onetwocell,
 };
 EXPORT_SYMBOL_GPL(irq_domain_simple_ops);
+
+static int irq_domain_alloc_descs(int virq, unsigned int cnt,
+                                  irq_hw_number_t hwirq, int node)
+{
+        unsigned int hint;
+
+        if (virq >= 0) {
+                virq = irq_alloc_descs(virq, virq, cnt, node);
+        } else {
+                hint = hwirq % nr_irqs;
+                if (hint == 0)
+                        hint++;
+                virq = irq_alloc_descs_from(hint, cnt, node);
+                if (virq <= 0 && hint > 1)
+                        virq = irq_alloc_descs_from(1, cnt, node);
+        }
+
+        return virq;
+}
+
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+/**
+ * irq_domain_add_hierarchy - Add a irqdomain into the hierarchy
+ * @parent:     Parent irq domain to associate with the new domain
+ * @flags:      Irq domain flags associated to the domain
+ * @size:       Size of the domain. See below
+ * @node:       Optional device-tree node of the interrupt controller
+ * @ops:        Pointer to the interrupt domain callbacks
+ * @host_data:  Controller private data pointer
+ *
+ * If @size is 0 a tree domain is created, otherwise a linear domain.
+ *
+ * If successful the parent is associated to the new domain and the
+ * domain flags are set.
+ * Returns pointer to IRQ domain, or NULL on failure.
+ */
+struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
+                                            unsigned int flags,
+                                            unsigned int size,
+                                            struct device_node *node,
+                                            const struct irq_domain_ops *ops,
+                                            void *host_data)
+{
+        struct irq_domain *domain;
+
+        if (size)
+                domain = irq_domain_add_linear(node, size, ops, host_data);
+        else
+                domain = irq_domain_add_tree(node, ops, host_data);
+        if (domain) {
+                domain->parent = parent;
+                domain->flags |= flags;
+        }
+
+        return domain;
+}
+
+static void irq_domain_insert_irq(int virq)
+{
+        struct irq_data *data;
+
+        for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
+                struct irq_domain *domain = data->domain;
+                irq_hw_number_t hwirq = data->hwirq;
+
+                if (hwirq < domain->revmap_size) {
+                        domain->linear_revmap[hwirq] = virq;
+                } else {
+                        mutex_lock(&revmap_trees_mutex);
+                        radix_tree_insert(&domain->revmap_tree, hwirq, data);
+                        mutex_unlock(&revmap_trees_mutex);
+                }
+
+                /* If not already assigned, give the domain the chip's name */
+                if (!domain->name && data->chip)
+                        domain->name = data->chip->name;
+        }
+
+        irq_clear_status_flags(virq, IRQ_NOREQUEST);
+}
+
+static void irq_domain_remove_irq(int virq)
+{
+        struct irq_data *data;
+
+        irq_set_status_flags(virq, IRQ_NOREQUEST);
+        irq_set_chip_and_handler(virq, NULL, NULL);
+        synchronize_irq(virq);
+        smp_mb();
+
+        for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
+                struct irq_domain *domain = data->domain;
+                irq_hw_number_t hwirq = data->hwirq;
+
+                if (hwirq < domain->revmap_size) {
+                        domain->linear_revmap[hwirq] = 0;
+                } else {
+                        mutex_lock(&revmap_trees_mutex);
+                        radix_tree_delete(&domain->revmap_tree, hwirq);
+                        mutex_unlock(&revmap_trees_mutex);
+                }
+        }
+}
+
+static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain,
+                                                   struct irq_data *child)
+{
+        struct irq_data *irq_data;
+
+        irq_data = kzalloc_node(sizeof(*irq_data), GFP_KERNEL, child->node);
+        if (irq_data) {
+                child->parent_data = irq_data;
+                irq_data->irq = child->irq;
+                irq_data->node = child->node;
+                irq_data->domain = domain;
+        }
+
+        return irq_data;
+}
+
+static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
+{
+        struct irq_data *irq_data, *tmp;
+        int i;
+
+        for (i = 0; i < nr_irqs; i++) {
+                irq_data = irq_get_irq_data(virq + i);
+                tmp = irq_data->parent_data;
+                irq_data->parent_data = NULL;
+                irq_data->domain = NULL;
+
+                while (tmp) {
+                        irq_data = tmp;
+                        tmp = tmp->parent_data;
+                        kfree(irq_data);
+                }
+        }
+}
+
+static int irq_domain_alloc_irq_data(struct irq_domain *domain,
+                                     unsigned int virq, unsigned int nr_irqs)
+{
+        struct irq_data *irq_data;
+        struct irq_domain *parent;
+        int i;
+
+        /* The outermost irq_data is embedded in struct irq_desc */
+        for (i = 0; i < nr_irqs; i++) {
+                irq_data = irq_get_irq_data(virq + i);
+                irq_data->domain = domain;
+
+                for (parent = domain->parent; parent; parent = parent->parent) {
+                        irq_data = irq_domain_insert_irq_data(parent, irq_data);
+                        if (!irq_data) {
+                                irq_domain_free_irq_data(virq, i + 1);
+                                return -ENOMEM;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
+ * @domain:     domain to match
+ * @virq:       IRQ number to get irq_data
+ */
+struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
+                                         unsigned int virq)
+{
+        struct irq_data *irq_data;
+
+        for (irq_data = irq_get_irq_data(virq); irq_data;
+             irq_data = irq_data->parent_data)
+                if (irq_data->domain == domain)
+                        return irq_data;
+
+        return NULL;
+}
+
+/**
+ * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
+ * @domain:     Interrupt domain to match
+ * @virq:       IRQ number
+ * @hwirq:      The hwirq number
+ * @chip:       The associated interrupt chip
+ * @chip_data:  The associated chip data
+ */
+int irq_domain_set_hwirq_and_chip(struct irq_domain *domain, unsigned int virq,
+                                  irq_hw_number_t hwirq, struct irq_chip *chip,
+                                  void *chip_data)
+{
+        struct irq_data *irq_data = irq_domain_get_irq_data(domain, virq);
+
+        if (!irq_data)
+                return -ENOENT;
+
+        irq_data->hwirq = hwirq;
+        irq_data->chip = chip ? chip : &no_irq_chip;
+        irq_data->chip_data = chip_data;
+
+        return 0;
+}
+
+/**
+ * irq_domain_set_info - Set the complete data for a @virq in @domain
+ * @domain:             Interrupt domain to match
+ * @virq:               IRQ number
+ * @hwirq:              The hardware interrupt number
+ * @chip:               The associated interrupt chip
+ * @chip_data:          The associated interrupt chip data
+ * @handler:            The interrupt flow handler
+ * @handler_data:       The interrupt flow handler data
+ * @handler_name:       The interrupt handler name
+ */
+void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
+                         irq_hw_number_t hwirq, struct irq_chip *chip,
+                         void *chip_data, irq_flow_handler_t handler,
+                         void *handler_data, const char *handler_name)
+{
+        irq_domain_set_hwirq_and_chip(domain, virq, hwirq, chip, chip_data);
+        __irq_set_handler(virq, handler, 0, handler_name);
+        irq_set_handler_data(virq, handler_data);
+}
+
+/**
+ * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
+ * @irq_data:   The pointer to irq_data
+ */
+void irq_domain_reset_irq_data(struct irq_data *irq_data)
+{
+        irq_data->hwirq = 0;
+        irq_data->chip = &no_irq_chip;
+        irq_data->chip_data = NULL;
+}
+
+/**
+ * irq_domain_free_irqs_common - Clear irq_data and free the parent
+ * @domain:     Interrupt domain to match
+ * @virq:       IRQ number to start with
+ * @nr_irqs:    The number of irqs to free
+ */
+void irq_domain_free_irqs_common(struct irq_domain *domain, unsigned int virq,
+                                 unsigned int nr_irqs)
+{
+        struct irq_data *irq_data;
+        int i;
+
+        for (i = 0; i < nr_irqs; i++) {
+                irq_data = irq_domain_get_irq_data(domain, virq + i);
+                if (irq_data)
+                        irq_domain_reset_irq_data(irq_data);
+        }
+        irq_domain_free_irqs_parent(domain, virq, nr_irqs);
+}
+
+/**
+ * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
+ * @domain:     Interrupt domain to match
+ * @virq:       IRQ number to start with
+ * @nr_irqs:    The number of irqs to free
+ */
+void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
+                              unsigned int nr_irqs)
+{
+        int i;
+
+        for (i = 0; i < nr_irqs; i++) {
+                irq_set_handler_data(virq + i, NULL);
+                irq_set_handler(virq + i, NULL);
+        }
+        irq_domain_free_irqs_common(domain, virq, nr_irqs);
+}
+
+static bool irq_domain_is_auto_recursive(struct irq_domain *domain)
+{
+        return domain->flags & IRQ_DOMAIN_FLAG_AUTO_RECURSIVE;
+}
+
+static void irq_domain_free_irqs_recursive(struct irq_domain *domain,
+                                           unsigned int irq_base,
+                                           unsigned int nr_irqs)
+{
+        domain->ops->free(domain, irq_base, nr_irqs);
+        if (irq_domain_is_auto_recursive(domain)) {
+                BUG_ON(!domain->parent);
+                irq_domain_free_irqs_recursive(domain->parent, irq_base,
+                                               nr_irqs);
+        }
+}
+
+static int irq_domain_alloc_irqs_recursive(struct irq_domain *domain,
+                                           unsigned int irq_base,
+                                           unsigned int nr_irqs, void *arg)
+{
+        int ret = 0;
+        struct irq_domain *parent = domain->parent;
+        bool recursive = irq_domain_is_auto_recursive(domain);
+
+        BUG_ON(recursive && !parent);
+        if (recursive)
+                ret = irq_domain_alloc_irqs_recursive(parent, irq_base,
+                                                      nr_irqs, arg);
+        if (ret >= 0)
+                ret = domain->ops->alloc(domain, irq_base, nr_irqs, arg);
+        if (ret < 0 && recursive)
+                irq_domain_free_irqs_recursive(parent, irq_base, nr_irqs);
+
+        return ret;
+}
+
+/**
+ * __irq_domain_alloc_irqs - Allocate IRQs from domain
+ * @domain:     domain to allocate from
+ * @irq_base:   allocate specified IRQ nubmer if irq_base >= 0
+ * @nr_irqs:    number of IRQs to allocate
+ * @node:       NUMA node id for memory allocation
+ * @arg:        domain specific argument
+ * @realloc:    IRQ descriptors have already been allocated if true
+ *
+ * Allocate IRQ numbers and initialized all data structures to support
+ * hierarchy IRQ domains.
+ * Parameter @realloc is mainly to support legacy IRQs.
+ * Returns error code or allocated IRQ number
+ *
+ * The whole process to setup an IRQ has been split into two steps.
+ * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
+ * descriptor and required hardware resources. The second step,
+ * irq_domain_activate_irq(), is to program hardwares with preallocated
+ * resources. In this way, it's easier to rollback when failing to
+ * allocate resources.
+ */
+int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
+                            unsigned int nr_irqs, int node, void *arg,
+                            bool realloc)
+{
+        int i, ret, virq;
+
+        if (domain == NULL) {
+                domain = irq_default_domain;
+                if (WARN(!domain, "domain is NULL; cannot allocate IRQ\n"))
+                        return -EINVAL;
+        }
+
+        if (!domain->ops->alloc) {
+                pr_debug("domain->ops->alloc() is NULL\n");
+                return -ENOSYS;
+        }
+
+        if (realloc && irq_base >= 0) {
+                virq = irq_base;
+        } else {
+                virq = irq_domain_alloc_descs(irq_base, nr_irqs, 0, node);
+                if (virq < 0) {
+                        pr_debug("cannot allocate IRQ(base %d, count %d)\n",
+                                 irq_base, nr_irqs);
+                        return virq;
+                }
+        }
+
+        if (irq_domain_alloc_irq_data(domain, virq, nr_irqs)) {
+                pr_debug("cannot allocate memory for IRQ%d\n", virq);
+                ret = -ENOMEM;
+                goto out_free_desc;
+        }
+
+        mutex_lock(&irq_domain_mutex);
+        ret = irq_domain_alloc_irqs_recursive(domain, virq, nr_irqs, arg);
+        if (ret < 0) {
+                mutex_unlock(&irq_domain_mutex);
+                goto out_free_irq_data;
+        }
+        for (i = 0; i < nr_irqs; i++)
+                irq_domain_insert_irq(virq + i);
+        mutex_unlock(&irq_domain_mutex);
+
+        return virq;
+
+out_free_irq_data:
+        irq_domain_free_irq_data(virq, nr_irqs);
+out_free_desc:
+        irq_free_descs(virq, nr_irqs);
+        return ret;
+}
+
+/**
+ * irq_domain_free_irqs - Free IRQ number and associated data structures
+ * @virq:       base IRQ number
+ * @nr_irqs:    number of IRQs to free
+ */
+void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
+{
+        struct irq_data *data = irq_get_irq_data(virq);
+        int i;
+
+        if (WARN(!data || !data->domain || !data->domain->ops->free,
+                 "NULL pointer, cannot free irq\n"))
+                return;
+
+        mutex_lock(&irq_domain_mutex);
+        for (i = 0; i < nr_irqs; i++)
+                irq_domain_remove_irq(virq + i);
+        irq_domain_free_irqs_recursive(data->domain, virq, nr_irqs);
+        mutex_unlock(&irq_domain_mutex);
+
+        irq_domain_free_irq_data(virq, nr_irqs);
+        irq_free_descs(virq, nr_irqs);
+}
+
+/**
+ * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
+ * @irq_base:   Base IRQ number
+ * @nr_irqs:    Number of IRQs to allocate
+ * @arg:        Allocation data (arch/domain specific)
+ *
+ * Check whether the domain has been setup recursive. If not allocate
+ * through the parent domain.
+ */
+int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
+                                 unsigned int irq_base, unsigned int nr_irqs,
+                                 void *arg)
+{
+        /* irq_domain_alloc_irqs_recursive() has called parent's alloc() */
+        if (irq_domain_is_auto_recursive(domain))
+                return 0;
+
+        domain = domain->parent;
+        if (domain)
+                return irq_domain_alloc_irqs_recursive(domain, irq_base,
+                                                       nr_irqs, arg);
+        return -ENOSYS;
+}
+
+/**
+ * irq_domain_free_irqs_parent - Free interrupts from parent domain
+ * @irq_base:   Base IRQ number
+ * @nr_irqs:    Number of IRQs to free
+ *
+ * Check whether the domain has been setup recursive. If not free
+ * through the parent domain.
+ */
+void irq_domain_free_irqs_parent(struct irq_domain *domain,
+                                 unsigned int irq_base, unsigned int nr_irqs)
+{
+        /* irq_domain_free_irqs_recursive() will call parent's free */
+        if (!irq_domain_is_auto_recursive(domain) && domain->parent)
+                irq_domain_free_irqs_recursive(domain->parent, irq_base,
+                                               nr_irqs);
+}
+
+/**
+ * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
+ *                           interrupt
+ * @irq_data:   outermost irq_data associated with interrupt
+ *
+ * This is the second step to call domain_ops->activate to program interrupt
+ * controllers, so the interrupt could actually get delivered.
+ */
+void irq_domain_activate_irq(struct irq_data *irq_data)
+{
+        if (irq_data && irq_data->domain) {
+                struct irq_domain *domain = irq_data->domain;
+
+                if (irq_data->parent_data)
+                        irq_domain_activate_irq(irq_data->parent_data);
+                if (domain->ops->activate)
+                        domain->ops->activate(domain, irq_data);
+        }
+}
+
+/**
+ * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
+ *                             deactivate interrupt
+ * @irq_data: outermost irq_data associated with interrupt
+ *
+ * It calls domain_ops->deactivate to program interrupt controllers to disable
+ * interrupt delivery.
+ */
+void irq_domain_deactivate_irq(struct irq_data *irq_data)
+{
+        if (irq_data && irq_data->domain) {
+                struct irq_domain *domain = irq_data->domain;
+
+                if (domain->ops->deactivate)
+                        domain->ops->deactivate(domain, irq_data);
+                if (irq_data->parent_data)
+                        irq_domain_deactivate_irq(irq_data->parent_data);
+        }
+}
+
+static void irq_domain_check_hierarchy(struct irq_domain *domain)
+{
+        /* Hierarchy irq_domains must implement callback alloc() */
+        if (domain->ops->alloc)
+                domain->flags |= IRQ_DOMAIN_FLAG_HIERARCHY;
+}
+#else   /* CONFIG_IRQ_DOMAIN_HIERARCHY */
+/**
+ * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
+ * @domain:     domain to match
+ * @virq:       IRQ number to get irq_data
+ */
+struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
+                                         unsigned int virq)
+{
+        struct irq_data *irq_data = irq_get_irq_data(virq);
+
+        return (irq_data && irq_data->domain == domain) ? irq_data : NULL;
+}
+
+static void irq_domain_check_hierarchy(struct irq_domain *domain)
+{
+}
+#endif  /* CONFIG_IRQ_DOMAIN_HIERARCHY */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 0a9104b4608b..80692373abd6 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -183,6 +183,7 @@ int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask,
         ret = chip->irq_set_affinity(data, mask, force);
         switch (ret) {
         case IRQ_SET_MASK_OK:
+        case IRQ_SET_MASK_OK_DONE:
                 cpumask_copy(data->affinity, mask);
         case IRQ_SET_MASK_OK_NOCOPY:
                 irq_set_thread_affinity(desc);
@@ -600,6 +601,7 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
 
         switch (ret) {
         case IRQ_SET_MASK_OK:
+        case IRQ_SET_MASK_OK_DONE:
                 irqd_clear(&desc->irq_data, IRQD_TRIGGER_MASK);
                 irqd_set(&desc->irq_data, flags);
 
diff --git a/kernel/irq/msi.c b/kernel/irq/msi.c
new file mode 100644
index 000000000000..3e18163f336f
--- /dev/null
+++ b/kernel/irq/msi.c
@@ -0,0 +1,330 @@
+/*
+ * linux/kernel/irq/msi.c
+ *
+ * Copyright (C) 2014 Intel Corp.
+ * Author: Jiang Liu <jiang.liu@linux.intel.com>
+ *
+ * This file is licensed under GPLv2.
+ *
+ * This file contains common code to support Message Signalled Interrupt for
+ * PCI compatible and non PCI compatible devices.
+ */
+#include <linux/types.h>
+#include <linux/device.h>
+#include <linux/irq.h>
+#include <linux/irqdomain.h>
+#include <linux/msi.h>
+
+/* Temparory solution for building, will be removed later */
+#include <linux/pci.h>
+
+void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
+{
+        *msg = entry->msg;
+}
+
+void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
+{
+        struct msi_desc *entry = irq_get_msi_desc(irq);
+
+        __get_cached_msi_msg(entry, msg);
+}
+EXPORT_SYMBOL_GPL(get_cached_msi_msg);
+
+#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
+static inline void irq_chip_write_msi_msg(struct irq_data *data,
+                                          struct msi_msg *msg)
+{
+        data->chip->irq_write_msi_msg(data, msg);
+}
+
+/**
+ * msi_domain_set_affinity - Generic affinity setter function for MSI domains
+ * @irq_data:   The irq data associated to the interrupt
+ * @mask:       The affinity mask to set
+ * @force:      Flag to enforce setting (disable online checks)
+ *
+ * Intended to be used by MSI interrupt controllers which are
+ * implemented with hierarchical domains.
+ */
+int msi_domain_set_affinity(struct irq_data *irq_data,
+                            const struct cpumask *mask, bool force)
+{
+        struct irq_data *parent = irq_data->parent_data;
+        struct msi_msg msg;
+        int ret;
+
+        ret = parent->chip->irq_set_affinity(parent, mask, force);
+        if (ret >= 0 && ret != IRQ_SET_MASK_OK_DONE) {
+                BUG_ON(irq_chip_compose_msi_msg(irq_data, &msg));
+                irq_chip_write_msi_msg(irq_data, &msg);
+        }
+
+        return ret;
+}
+
+static void msi_domain_activate(struct irq_domain *domain,
+                                struct irq_data *irq_data)
+{
+        struct msi_msg msg;
+
+        BUG_ON(irq_chip_compose_msi_msg(irq_data, &msg));
+        irq_chip_write_msi_msg(irq_data, &msg);
+}
+
+static void msi_domain_deactivate(struct irq_domain *domain,
+                                  struct irq_data *irq_data)
+{
+        struct msi_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        irq_chip_write_msi_msg(irq_data, &msg);
+}
+
+static int msi_domain_alloc(struct irq_domain *domain, unsigned int virq,
+                            unsigned int nr_irqs, void *arg)
+{
+        struct msi_domain_info *info = domain->host_data;
+        struct msi_domain_ops *ops = info->ops;
+        irq_hw_number_t hwirq = ops->get_hwirq(info, arg);
+        int i, ret;
+
+        if (irq_find_mapping(domain, hwirq) > 0)
+                return -EEXIST;
+
+        ret = irq_domain_alloc_irqs_parent(domain, virq, nr_irqs, arg);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < nr_irqs; i++) {
+                ret = ops->msi_init(domain, info, virq + i, hwirq + i, arg);
+                if (ret < 0) {
+                        if (ops->msi_free) {
+                                for (i--; i > 0; i--)
+                                        ops->msi_free(domain, info, virq + i);
+                        }
+                        irq_domain_free_irqs_top(domain, virq, nr_irqs);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static void msi_domain_free(struct irq_domain *domain, unsigned int virq,
+                            unsigned int nr_irqs)
+{
+        struct msi_domain_info *info = domain->host_data;
+        int i;
+
+        if (info->ops->msi_free) {
+                for (i = 0; i < nr_irqs; i++)
+                        info->ops->msi_free(domain, info, virq + i);
+        }
+        irq_domain_free_irqs_top(domain, virq, nr_irqs);
+}
+
+static struct irq_domain_ops msi_domain_ops = {
+        .alloc          = msi_domain_alloc,
+        .free           = msi_domain_free,
+        .activate       = msi_domain_activate,
+        .deactivate     = msi_domain_deactivate,
+};
+
+#ifdef GENERIC_MSI_DOMAIN_OPS
+static irq_hw_number_t msi_domain_ops_get_hwirq(struct msi_domain_info *info,
+                                                msi_alloc_info_t *arg)
+{
+        return arg->hwirq;
+}
+
+static int msi_domain_ops_prepare(struct irq_domain *domain, struct device *dev,
+                                  int nvec, msi_alloc_info_t *arg)
+{
+        memset(arg, 0, sizeof(*arg));
+        return 0;
+}
+
+static void msi_domain_ops_set_desc(msi_alloc_info_t *arg,
+                                    struct msi_desc *desc)
+{
+        arg->desc = desc;
+}
+#else
+#define msi_domain_ops_get_hwirq        NULL
+#define msi_domain_ops_prepare          NULL
+#define msi_domain_ops_set_desc         NULL
+#endif /* !GENERIC_MSI_DOMAIN_OPS */
+
+static int msi_domain_ops_init(struct irq_domain *domain,
+                               struct msi_domain_info *info,
+                               unsigned int virq, irq_hw_number_t hwirq,
+                               msi_alloc_info_t *arg)
+{
+        irq_domain_set_hwirq_and_chip(domain, virq, hwirq, info->chip,
+                                      info->chip_data);
+        if (info->handler && info->handler_name) {
+                __irq_set_handler(virq, info->handler, 0, info->handler_name);
+                if (info->handler_data)
+                        irq_set_handler_data(virq, info->handler_data);
+        }
+        return 0;
+}
+
+static int msi_domain_ops_check(struct irq_domain *domain,
+                                struct msi_domain_info *info,
+                                struct device *dev)
+{
+        return 0;
+}
+
+static struct msi_domain_ops msi_domain_ops_default = {
+        .get_hwirq      = msi_domain_ops_get_hwirq,
+        .msi_init       = msi_domain_ops_init,
+        .msi_check      = msi_domain_ops_check,
+        .msi_prepare    = msi_domain_ops_prepare,
+        .set_desc       = msi_domain_ops_set_desc,
+};
+
+static void msi_domain_update_dom_ops(struct msi_domain_info *info)
+{
+        struct msi_domain_ops *ops = info->ops;
+
+        if (ops == NULL) {
+                info->ops = &msi_domain_ops_default;
+                return;
+        }
+
+        if (ops->get_hwirq == NULL)
+                ops->get_hwirq = msi_domain_ops_default.get_hwirq;
+        if (ops->msi_init == NULL)
+                ops->msi_init = msi_domain_ops_default.msi_init;
+        if (ops->msi_check == NULL)
+                ops->msi_check = msi_domain_ops_default.msi_check;
+        if (ops->msi_prepare == NULL)
+                ops->msi_prepare = msi_domain_ops_default.msi_prepare;
+        if (ops->set_desc == NULL)
+                ops->set_desc = msi_domain_ops_default.set_desc;
+}
+
+static void msi_domain_update_chip_ops(struct msi_domain_info *info)
+{
+        struct irq_chip *chip = info->chip;
+
+        BUG_ON(!chip);
+        if (!chip->irq_mask)
+                chip->irq_mask = pci_msi_mask_irq;
+        if (!chip->irq_unmask)
+                chip->irq_unmask = pci_msi_unmask_irq;
+        if (!chip->irq_set_affinity)
+                chip->irq_set_affinity = msi_domain_set_affinity;
+}
+
+/**
+ * msi_create_irq_domain - Create a MSI interrupt domain
+ * @of_node:    Optional device-tree node of the interrupt controller
+ * @info:       MSI domain info
+ * @parent:     Parent irq domain
+ */
+struct irq_domain *msi_create_irq_domain(struct device_node *node,
+                                         struct msi_domain_info *info,
+                                         struct irq_domain *parent)
+{
+        if (info->flags & MSI_FLAG_USE_DEF_DOM_OPS)
+                msi_domain_update_dom_ops(info);
+        if (info->flags & MSI_FLAG_USE_DEF_CHIP_OPS)
+                msi_domain_update_chip_ops(info);
+
+        return irq_domain_add_hierarchy(parent, 0, 0, node, &msi_domain_ops,
+                                        info);
+}
+
+/**
+ * msi_domain_alloc_irqs - Allocate interrupts from a MSI interrupt domain
+ * @domain:     The domain to allocate from
+ * @dev:        Pointer to device struct of the device for which the interrupts
+ *              are allocated
+ * @nvec:       The number of interrupts to allocate
+ *
+ * Returns 0 on success or an error code.
+ */
+int msi_domain_alloc_irqs(struct irq_domain *domain, struct device *dev,
+                          int nvec)
+{
+        struct msi_domain_info *info = domain->host_data;
+        struct msi_domain_ops *ops = info->ops;
+        msi_alloc_info_t arg;
+        struct msi_desc *desc;
+        int i, ret, virq = -1;
+
+        ret = ops->msi_check(domain, info, dev);
+        if (ret == 0)
+                ret = ops->msi_prepare(domain, dev, nvec, &arg);
+        if (ret)
+                return ret;
+
+        for_each_msi_entry(desc, dev) {
+                ops->set_desc(&arg, desc);
+                if (info->flags & MSI_FLAG_IDENTITY_MAP)
+                        virq = (int)ops->get_hwirq(info, &arg);
+                else
+                        virq = -1;
+
+                virq = __irq_domain_alloc_irqs(domain, virq, desc->nvec_used,
+                                               dev_to_node(dev), &arg, false);
+                if (virq < 0) {
+                        ret = -ENOSPC;
+                        if (ops->handle_error)
+                                ret = ops->handle_error(domain, desc, ret);
+                        if (ops->msi_finish)
+                                ops->msi_finish(&arg, ret);
+                        return ret;
+                }
+
+                for (i = 0; i < desc->nvec_used; i++)
+                        irq_set_msi_desc_off(virq, i, desc);
+        }
+
+        if (ops->msi_finish)
+                ops->msi_finish(&arg, 0);
+
+        for_each_msi_entry(desc, dev) {
+                if (desc->nvec_used == 1)
+                        dev_dbg(dev, "irq %d for MSI\n", virq);
+                else
+                        dev_dbg(dev, "irq [%d-%d] for MSI\n",
+                                virq, virq + desc->nvec_used - 1);
+        }
+
+        return 0;
+}
+
+/**
+ * msi_domain_free_irqs - Free interrupts from a MSI interrupt @domain associated tp @dev
+ * @domain:     The domain to managing the interrupts
+ * @dev:        Pointer to device struct of the device for which the interrupts
+ *              are free
+ */
+void msi_domain_free_irqs(struct irq_domain *domain, struct device *dev)
+{
+        struct msi_desc *desc;
+
+        for_each_msi_entry(desc, dev) {
+                irq_domain_free_irqs(desc->irq, desc->nvec_used);
+                desc->irq = 0;
+        }
+}
+
+/**
+ * msi_get_domain_info - Get the MSI interrupt domain info for @domain
+ * @domain:     The interrupt domain to retrieve data from
+ *
+ * Returns the pointer to the msi_domain_info stored in
+ * @domain->host_data.
+ */
+struct msi_domain_info *msi_get_domain_info(struct irq_domain *domain)
+{
+        return (struct msi_domain_info *)domain->host_data;
+}
+
+#endif /* CONFIG_GENERIC_MSI_IRQ_DOMAIN */