irqdomain: Implement a method to automatically call parent domains alloc/free

Add a flags to irq_domain.flags to control whether the irqdomain core
should automatically call parent irqdomain's alloc/free callbacks. It
help to reduce hierarchy irqdomains users' code size.

Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: linux-arm-kernel@lists.infradead.org
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Grant Likely <grant.likely@linaro.org>
Cc: Marc Zyngier <marc.zyngier@arm.com>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Yingjoe Chen <yingjoe.chen@mediatek.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Matthias Brugger <matthias.bgg@gmail.com>
Link: http://lkml.kernel.org/r/1416061447-9472-4-git-send-email-jiang.liu@linux.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index 7aca1adb68a17dcba44d83d856e685d0b3d3eaf9..dd2709bdad567d33b32c1eca0802712803b11bd4 100644 (file)
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -134,6 +134,9 @@ enum {
        /* Irq domain is hierarchical */
        IRQ_DOMAIN_FLAG_HIERARCHY       = (1 << 0),
 
+       /* Core calls alloc/free recursive through the domain hierarchy. */
+       IRQ_DOMAIN_FLAG_AUTO_RECURSIVE  = (1 << 1),
+
        /*
         * Flags starting from IRQ_DOMAIN_FLAG_NONCORE are reserved
         * for implementation specific purposes and ignored by the
@@ -285,22 +288,13 @@ extern void irq_domain_free_irqs_common(struct irq_domain *domain,
 extern void irq_domain_free_irqs_top(struct irq_domain *domain,
                                     unsigned int virq, unsigned int nr_irqs);
 
-static inline int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
-                                              unsigned int irq_base,
-                                              unsigned int nr_irqs, void *arg)
-{
-       if (domain->parent && domain->parent->ops->alloc)
-               return domain->parent->ops->alloc(domain->parent, irq_base,
-                                                 nr_irqs, arg);
-       return -ENOSYS;
-}
+extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
+                                       unsigned int irq_base,
+                                       unsigned int nr_irqs, void *arg);
 
-static inline void irq_domain_free_irqs_parent(struct irq_domain *domain,
-                               unsigned int irq_base, unsigned int nr_irqs)
-{
-       if (domain->parent && domain->parent->ops->free)
-               domain->parent->ops->free(domain->parent, irq_base, nr_irqs);
-}
+extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
+                                       unsigned int irq_base,
+                                       unsigned int nr_irqs);
 
 static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
 {

diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 4e62832ace82946a7b840ca3cff6f9a9d957c71a..9c88db7056d4a33f608672ec0b96e4b6d9ec0823 100644 (file)
--- a/kernel/irq/irqdomain.c
+++ b/kernel/irq/irqdomain.c
@@ -960,6 +960,43 @@ void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
        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
@@ -1016,7 +1053,7 @@ int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
        }
 
        mutex_lock(&irq_domain_mutex);
-       ret = domain->ops->alloc(domain, virq, nr_irqs, arg);
+       ret = irq_domain_alloc_irqs_recursive(domain, virq, nr_irqs, arg);
        if (ret < 0) {
                mutex_unlock(&irq_domain_mutex);
                goto out_free_irq_data;
@@ -1051,13 +1088,54 @@ void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
        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);
+       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