genirq/irqdomain: Allow partial trimming of irq_data hierarchy

It appears that some HW is ugly enough that not all the interrupts
connected to a particular interrupt controller end up with the same
hierarchy depth (some of them are terminated early). This leaves
the irqchip hacker with only two choices, both equally bad:

- create discrete domain chains, one for each "hierarchy depth",
  which is very hard to maintain

- create fake hierarchy levels for the shallow paths, leading
  to all kind of problems (what are the safe hwirq values for these
  fake levels?)

Implement the ability to cut short a single interrupt hierarchy
from a level marked as being disconnected by using the new
irq_domain_disconnect_hierarchy() helper.

The irqdomain allocation code will then perform the trimming

Signed-off-by: Marc Zyngier <maz@kernel.org>

diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index b37350c4fe3703e53bcb72af5584108d6ed0d46f..a52b095bd4048e248e158e8a41c873da74791f58 100644 (file)
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -509,6 +509,9 @@ extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
                                        unsigned int irq_base,
                                        unsigned int nr_irqs);
 
+extern int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
+                                          unsigned int virq);
+
 static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
 {
        return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;

diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 76cd7ebd1178c15e24437435d420960192d88fc5..cf8b374b892da0ce854e72c8750dfda981315dc8 100644 (file)
--- a/kernel/irq/irqdomain.c
+++ b/kernel/irq/irqdomain.c
@@ -1136,6 +1136,17 @@ static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain,
        return irq_data;
 }
 
+static void __irq_domain_free_hierarchy(struct irq_data *irq_data)
+{
+       struct irq_data *tmp;
+
+       while (irq_data) {
+               tmp = irq_data;
+               irq_data = irq_data->parent_data;
+               kfree(tmp);
+       }
+}
+
 static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
 {
        struct irq_data *irq_data, *tmp;
@@ -1147,12 +1158,83 @@ static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
                irq_data->parent_data = NULL;
                irq_data->domain = NULL;
 
-               while (tmp) {
-                       irq_data = tmp;
-                       tmp = tmp->parent_data;
-                       kfree(irq_data);
+               __irq_domain_free_hierarchy(tmp);
+       }
+}
+
+/**
+ * irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy
+ * @domain:    IRQ domain from which the hierarchy is to be disconnected
+ * @virq:      IRQ number where the hierarchy is to be trimmed
+ *
+ * Marks the @virq level belonging to @domain as disconnected.
+ * Returns -EINVAL if @virq doesn't have a valid irq_data pointing
+ * to @domain.
+ *
+ * Its only use is to be able to trim levels of hierarchy that do not
+ * have any real meaning for this interrupt, and that the driver marks
+ * as such from its .alloc() callback.
+ */
+int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
+                                   unsigned int virq)
+{
+       struct irq_data *irqd;
+
+       irqd = irq_domain_get_irq_data(domain, virq);
+       if (!irqd)
+               return -EINVAL;
+
+       irqd->chip = ERR_PTR(-ENOTCONN);
+       return 0;
+}
+
+static int irq_domain_trim_hierarchy(unsigned int virq)
+{
+       struct irq_data *tail, *irqd, *irq_data;
+
+       irq_data = irq_get_irq_data(virq);
+       tail = NULL;
+
+       /* The first entry must have a valid irqchip */
+       if (!irq_data->chip || IS_ERR(irq_data->chip))
+               return -EINVAL;
+
+       /*
+        * Validate that the irq_data chain is sane in the presence of
+        * a hierarchy trimming marker.
+        */
+       for (irqd = irq_data->parent_data; irqd; irq_data = irqd, irqd = irqd->parent_data) {
+               /* Can't have a valid irqchip after a trim marker */
+               if (irqd->chip && tail)
+                       return -EINVAL;
+
+               /* Can't have an empty irqchip before a trim marker */
+               if (!irqd->chip && !tail)
+                       return -EINVAL;
+
+               if (IS_ERR(irqd->chip)) {
+                       /* Only -ENOTCONN is a valid trim marker */
+                       if (PTR_ERR(irqd->chip) != -ENOTCONN)
+                               return -EINVAL;
+
+                       tail = irq_data;
                }
        }
+
+       /* No trim marker, nothing to do */
+       if (!tail)
+               return 0;
+
+       pr_info("IRQ%d: trimming hierarchy from %s\n",
+               virq, tail->parent_data->domain->name);
+
+       /* Sever the inner part of the hierarchy...  */
+       irqd = tail;
+       tail = tail->parent_data;
+       irqd->parent_data = NULL;
+       __irq_domain_free_hierarchy(tail);
+
+       return 0;
 }
 
 static int irq_domain_alloc_irq_data(struct irq_domain *domain,
@@ -1362,6 +1444,15 @@ int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
                mutex_unlock(&irq_domain_mutex);
                goto out_free_irq_data;
        }
+
+       for (i = 0; i < nr_irqs; i++) {
+               ret = irq_domain_trim_hierarchy(virq + i);
+               if (ret) {
+                       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);