2 files changed, 69 insertions, 198 deletions

diff --git a/arch/powerpc/include/asm/irq.h b/arch/powerpc/include/asm/irq.h
index cb06b39f8e61..abdd7ef28cbf 100644
--- a/arch/powerpc/include/asm/irq.h
+++ b/arch/powerpc/include/asm/irq.h
@@ -191,33 +191,6 @@ extern unsigned int irq_linear_revmap(struct irq_domain *host,
                                       irq_hw_number_t hwirq);
 
 
-
-/**
- * irq_alloc_virt - Allocate virtual irq numbers
- * @host: host owning these new virtual irqs
- * @count: number of consecutive numbers to allocate
- * @hint: pass a hint number, the allocator will try to use a 1:1 mapping
- *
- * This is a low level function that is used internally by irq_create_mapping()
- * and that can be used by some irq controllers implementations for things
- * like allocating ranges of numbers for MSIs. The revmaps are left untouched.
- */
-extern unsigned int irq_alloc_virt(struct irq_domain *host,
-                                   unsigned int count,
-                                   unsigned int hint);
-
-/**
- * irq_free_virt - Free virtual irq numbers
- * @virq: virtual irq number of the first interrupt to free
- * @count: number of interrupts to free
- *
- * This function is the opposite of irq_alloc_virt. It will not clear reverse
- * maps, this should be done previously by unmap'ing the interrupt. In fact,
- * all interrupts covered by the range being freed should have been unmapped
- * prior to calling this.
- */
-extern void irq_free_virt(unsigned int virq, unsigned int count);
-
 /**
  * irq_early_init - Init irq remapping subsystem
  */
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 7305f2f65534..03c95f03d792 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -491,38 +491,29 @@ void do_softirq(void)
  * IRQ controller and virtual interrupts
  */
 
-/* The main irq map itself is an array of NR_IRQ entries containing the
- * associate host and irq number. An entry with a host of NULL is free.
- * An entry can be allocated if it's free, the allocator always then sets
- * hwirq first to the host's invalid irq number and then fills ops.
- */
-struct irq_map_entry {
-        irq_hw_number_t hwirq;
-        struct irq_domain       *host;
-};
-
 static LIST_HEAD(irq_domain_list);
-static DEFINE_RAW_SPINLOCK(irq_big_lock);
+static DEFINE_MUTEX(irq_domain_mutex);
 static DEFINE_MUTEX(revmap_trees_mutex);
-static struct irq_map_entry irq_map[NR_IRQS];
 static unsigned int irq_virq_count = NR_IRQS;
 static struct irq_domain *irq_default_host;
 
 irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
 {
-        return irq_map[d->irq].hwirq;
+        return d->hwirq;
 }
 EXPORT_SYMBOL_GPL(irqd_to_hwirq);
 
 irq_hw_number_t virq_to_hw(unsigned int virq)
 {
-        return irq_map[virq].hwirq;
+        struct irq_data *irq_data = irq_get_irq_data(virq);
+        return WARN_ON(!irq_data) ? 0 : irq_data->hwirq;
 }
 EXPORT_SYMBOL_GPL(virq_to_hw);
 
 bool virq_is_host(unsigned int virq, struct irq_domain *host)
 {
-        return irq_map[virq].host == host;
+        struct irq_data *irq_data = irq_get_irq_data(virq);
+        return irq_data ? irq_data->domain == host : false;
 }
 EXPORT_SYMBOL_GPL(virq_is_host);
 
@@ -537,11 +528,10 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node,
                                 struct irq_domain_ops *ops,
                                 irq_hw_number_t inval_irq)
 {
-        struct irq_domain *host;
+        struct irq_domain *host, *h;
         unsigned int size = sizeof(struct irq_domain);
         unsigned int i;
         unsigned int *rmap;
-        unsigned long flags;
 
         /* Allocate structure and revmap table if using linear mapping */
         if (revmap_type == IRQ_DOMAIN_MAP_LINEAR)
@@ -559,23 +549,20 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node,
         if (host->ops->match == NULL)
                 host->ops->match = default_irq_host_match;
 
-        raw_spin_lock_irqsave(&irq_big_lock, flags);
-
-        /* If it's a legacy controller, check for duplicates and
-         * mark it as allocated (we use irq 0 host pointer for that
-         */
+        mutex_lock(&irq_domain_mutex);
+        /* Make sure only one legacy controller can be created */
         if (revmap_type == IRQ_DOMAIN_MAP_LEGACY) {
-                if (irq_map[0].host != NULL) {
-                        raw_spin_unlock_irqrestore(&irq_big_lock, flags);
-                        of_node_put(host->of_node);
-                        kfree(host);
-                        return NULL;
+                list_for_each_entry(h, &irq_domain_list, link) {
+                        if (WARN_ON(h->revmap_type == IRQ_DOMAIN_MAP_LEGACY)) {
+                                mutex_unlock(&irq_domain_mutex);
+                                of_node_put(host->of_node);
+                                kfree(host);
+                                return NULL;
+                        }
                 }
-                irq_map[0].host = host;
         }
-
         list_add(&host->link, &irq_domain_list);
-        raw_spin_unlock_irqrestore(&irq_big_lock, flags);
+        mutex_unlock(&irq_domain_mutex);
 
         /* Additional setups per revmap type */
         switch(revmap_type) {
@@ -584,10 +571,9 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node,
                 host->inval_irq = 0;
                 /* setup us as the host for all legacy interrupts */
                 for (i = 1; i < NUM_ISA_INTERRUPTS; i++) {
-                        irq_map[i].hwirq = i;
-                        smp_wmb();
-                        irq_map[i].host = host;
-                        smp_wmb();
+                        struct irq_data *irq_data = irq_get_irq_data(i);
+                        irq_data->hwirq = i;
+                        irq_data->domain = host;
 
                         /* Legacy flags are left to default at this point,
                          * one can then use irq_create_mapping() to
@@ -604,7 +590,6 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node,
                 for (i = 0; i < revmap_arg; i++)
                         rmap[i] = NO_IRQ;
                 host->revmap_data.linear.size = revmap_arg;
-                smp_wmb();
                 host->revmap_data.linear.revmap = rmap;
                 break;
         case IRQ_DOMAIN_MAP_TREE:
@@ -622,20 +607,19 @@ struct irq_domain *irq_alloc_host(struct device_node *of_node,
 struct irq_domain *irq_find_host(struct device_node *node)
 {
         struct irq_domain *h, *found = NULL;
-        unsigned long flags;
 
         /* We might want to match the legacy controller last since
          * it might potentially be set to match all interrupts in
          * the absence of a device node. This isn't a problem so far
          * yet though...
          */
-        raw_spin_lock_irqsave(&irq_big_lock, flags);
+        mutex_lock(&irq_domain_mutex);
         list_for_each_entry(h, &irq_domain_list, link)