irqdomain: Introduce new interfaces to support hierarchy irqdomains

We plan to use hierarchy irqdomain to suppport CPU vector assignment,
interrupt remapping controller, IO-APIC controller, MSI interrupt
and hypertransport interrupt etc on x86 platforms. So extend irqdomain
interfaces to support hierarchy irqdomain.

There are already many clients of current irqdomain interfaces.
To minimize the changes, we choose to introduce new version 2 interfaces
to support hierarchy instead of extending existing irqdomain interfaces.

According to Thomas's suggestion, the most important design decision is
to build hierarchy struct irq_data to support hierarchy irqdomain, so
hierarchy irqdomain related data could be saved in struct irq_data.
With support of hierarchy irq_data, we could also support stacked
irq_chips. This is most useful in case of set_affinity().

The new hierarchy irqdomain introduces following interfaces:
1) irq_domain_alloc_irqs()/irq_domain_free_irqs(): allocate/release IRQ
   and related resources.
2) __irq_domain_alloc_irqs(): a special version to support legacy IRQs.
3) irq_domain_activate_irq()/irq_domain_deactivate_irq(): program
   interrupt controllers to activate/deactivate interrupt.

There are also several help functions to ease irqdomain implemenations:
1) irq_domain_get_irq_data(): get irq_data associated with a specific
   irqdomain.
2) irq_domain_set_hwirq_and_chip(): save irqdomain specific data into
   irq_data.
3) irq_domain_alloc_irqs_parent()/irq_domain_free_irqs_parent(): invoke
   parent irqdomain's alloc/free callbacks.

We also changed irq_startup()/irq_shutdown() to invoke
irq_domain_activate_irq()/irq_domain_deactivate_irq() to program
interrupt controller when start/stop interrupts.

[ tglx: Folded parts of the later patch series in ]

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Grant Likely <grant.likely@linaro.org>
Cc: Marc Zyngier <marc.zyngier@arm.com>
Cc: Yingjoe Chen <yingjoe.chen@mediatek.com>
Cc: Yijing Wang <wangyijing@huawei.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

3 files changed, 407 insertions, 16 deletions

diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 225086b2652e..4f2eb2b1f23b 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -55,6 +55,11 @@ config GENERIC_IRQ_CHIP
 config IRQ_DOMAIN
         bool
 
+# Support for hierarchical irq domains
+config IRQ_DOMAIN_HIERARCHY
+        bool
+        select IRQ_DOMAIN
+
 config HANDLE_DOMAIN_IRQ
         bool
 
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index e5202f00cabc..72a93086216b 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);
 }
 
diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 6534ff6ce02e..43f3be6fac70 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) {
@@ -480,6 +478,11 @@ unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
                 return 0;
         }
 
+        if (irq_domain_is_hierarchy(domain)) {
+                virq = irq_domain_alloc_irqs(domain, 1, NUMA_NO_NODE, irq_data);
+                return virq <= 0 ? 0 : virq;
+        }
+
         /* If domain has no translation, then we assume interrupt line */
         if (domain->ops->xlate == NULL)
                 hwirq = irq_data->args[0];
@@ -540,8 +543,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 +712,383 @@ 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
+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_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);
+}
+
+/**
+ * __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 = domain->ops->alloc(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);
+        data->domain->ops->free(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_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 */