1 files changed, 120 insertions, 213 deletions

diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 4a65386995d7..5b428e308666 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -66,7 +66,6 @@
 #include <asm/ptrace.h>
 #include <asm/machdep.h>
 #include <asm/udbg.h>
-#include <asm/dbell.h>
 #include <asm/smp.h>
 
 #ifdef CONFIG_PPC64
@@ -116,7 +115,7 @@ static inline notrace void set_soft_enabled(unsigned long enable)
         : : "r" (enable), "i" (offsetof(struct paca_struct, soft_enabled)));
 }
 
-notrace void raw_local_irq_restore(unsigned long en)
+notrace void arch_local_irq_restore(unsigned long en)
 {
         /*
          * get_paca()->soft_enabled = en;
@@ -160,7 +159,8 @@ notrace void raw_local_irq_restore(unsigned long en)
 
 #if defined(CONFIG_BOOKE) && defined(CONFIG_SMP)
         /* Check for pending doorbell interrupts and resend to ourself */
-        doorbell_check_self();
+        if (cpu_has_feature(CPU_FTR_DBELL))
+                smp_muxed_ipi_resend();
 #endif
 
         /*
@@ -192,10 +192,10 @@ notrace void raw_local_irq_restore(unsigned long en)
 
         __hard_irq_enable();
 }
-EXPORT_SYMBOL(raw_local_irq_restore);
+EXPORT_SYMBOL(arch_local_irq_restore);
 #endif /* CONFIG_PPC64 */
 
-static int show_other_interrupts(struct seq_file *p, int prec)
+int arch_show_interrupts(struct seq_file *p, int prec)
 {
         int j;
 
@@ -231,63 +231,6 @@ static int show_other_interrupts(struct seq_file *p, int prec)
         return 0;
 }
 
-int show_interrupts(struct seq_file *p, void *v)
-{
-        unsigned long flags, any_count = 0;
-        int i = *(loff_t *) v, j, prec;
-        struct irqaction *action;
-        struct irq_desc *desc;
-
-        if (i > nr_irqs)
-                return 0;
-
-        for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
-                j *= 10;
-
-        if (i == nr_irqs)
-                return show_other_interrupts(p, prec);
-
-        /* print header */
-        if (i == 0) {
-                seq_printf(p, "%*s", prec + 8, "");
-                for_each_online_cpu(j)
-                        seq_printf(p, "CPU%-8d", j);
-                seq_putc(p, '\n');
-        }
-
-        desc = irq_to_desc(i);
-        if (!desc)
-                return 0;
-
-        raw_spin_lock_irqsave(&desc->lock, flags);
-        for_each_online_cpu(j)
-                any_count |= kstat_irqs_cpu(i, j);
-        action = desc->action;
-        if (!action && !any_count)
-                goto out;
-
-        seq_printf(p, "%*d: ", prec, i);
-        for_each_online_cpu(j)
-                seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
-
-        if (desc->chip)
-                seq_printf(p, "  %-16s", desc->chip->name);
-        else
-                seq_printf(p, "  %-16s", "None");
-        seq_printf(p, " %-8s", (desc->status & IRQ_LEVEL) ? "Level" : "Edge");
-
-        if (action) {
-                seq_printf(p, "     %s", action->name);
-                while ((action = action->next) != NULL)
-                        seq_printf(p, ", %s", action->name);
-        }
-
-        seq_putc(p, '\n');
-out:
-        raw_spin_unlock_irqrestore(&desc->lock, flags);
-        return 0;
-}
-
 /*
  * /proc/stat helpers
  */
@@ -303,30 +246,37 @@ u64 arch_irq_stat_cpu(unsigned int cpu)
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
-void fixup_irqs(const struct cpumask *map)
+void migrate_irqs(void)
 {
         struct irq_desc *desc;
         unsigned int irq;
         static int warned;
         cpumask_var_t mask;
+        const struct cpumask *map = cpu_online_mask;
 
         alloc_cpumask_var(&mask, GFP_KERNEL);
 
         for_each_irq(irq) {
+                struct irq_data *data;
+                struct irq_chip *chip;
+
                 desc = irq_to_desc(irq);
                 if (!desc)
                         continue;
 
-                if (desc->status & IRQ_PER_CPU)
+                data = irq_desc_get_irq_data(desc);
+                if (irqd_is_per_cpu(data))
                         continue;
 
-                cpumask_and(mask, desc->affinity, map);
+                chip = irq_data_get_irq_chip(data);
+
+                cpumask_and(mask, data->affinity, map);
                 if (cpumask_any(mask) >= nr_cpu_ids) {
                         printk("Breaking affinity for irq %i\n", irq);
                         cpumask_copy(mask, map);
                 }
-                if (desc->chip->set_affinity)
-                        desc->chip->set_affinity(irq, mask);
+                if (chip->irq_set_affinity)
+                        chip->irq_set_affinity(data, mask, true);
                 else if (desc->action && !(warned++))
                         printk("Cannot set affinity for irq %i\n", irq);
         }
@@ -345,17 +295,20 @@ static inline void handle_one_irq(unsigned int irq)
         unsigned long saved_sp_limit;
         struct irq_desc *desc;
 
+        desc = irq_to_desc(irq);
+        if (!desc)
+                return;
+
         /* Switch to the irq stack to handle this */
         curtp = current_thread_info();
         irqtp = hardirq_ctx[smp_processor_id()];
 
         if (curtp == irqtp) {
                 /* We're already on the irq stack, just handle it */
-                generic_handle_irq(irq);
+                desc->handle_irq(irq, desc);
                 return;
         }
 
-        desc = irq_to_desc(irq);
         saved_sp_limit = current->thread.ksp_limit;
 
         irqtp->task = curtp->task;
@@ -447,24 +400,28 @@ struct thread_info *mcheckirq_ctx[NR_CPUS] __read_mostly;
 void exc_lvl_ctx_init(void)
 {
         struct thread_info *tp;
-        int i, hw_cpu;
+        int i, cpu_nr;
 
         for_each_possible_cpu(i) {
-                hw_cpu = get_hard_smp_processor_id(i);
-                memset((void *)critirq_ctx[hw_cpu], 0, THREAD_SIZE);
-                tp = critirq_ctx[hw_cpu];
-                tp->cpu = i;
+#ifdef CONFIG_PPC64
+                cpu_nr = i;
+#else
+                cpu_nr = get_hard_smp_processor_id(i);
+#endif
+                memset((void *)critirq_ctx[cpu_nr], 0, THREAD_SIZE);
+                tp = critirq_ctx[cpu_nr];
+                tp->cpu = cpu_nr;
                 tp->preempt_count = 0;
 
 #ifdef CONFIG_BOOKE
-                memset((void *)dbgirq_ctx[hw_cpu], 0, THREAD_SIZE);
-                tp = dbgirq_ctx[hw_cpu];
-                tp->cpu = i;
+                memset((void *)dbgirq_ctx[cpu_nr], 0, THREAD_SIZE);
+                tp = dbgirq_ctx[cpu_nr];
+                tp->cpu = cpu_nr;
                 tp->preempt_count = 0;
 
-                memset((void *)mcheckirq_ctx[hw_cpu], 0, THREAD_SIZE);
-                tp = mcheckirq_ctx[hw_cpu];
-                tp->cpu = i;
+                memset((void *)mcheckirq_ctx[cpu_nr], 0, THREAD_SIZE);
+                tp = mcheckirq_ctx[cpu_nr];
+                tp->cpu = cpu_nr;
                 tp->preempt_count = HARDIRQ_OFFSET;
 #endif
         }
@@ -527,20 +484,41 @@ 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_host *host;
+};
+
 static LIST_HEAD(irq_hosts);
 static DEFINE_RAW_SPINLOCK(irq_big_lock);
-static unsigned int revmap_trees_allocated;
 static DEFINE_MUTEX(revmap_trees_mutex);
-struct irq_map_entry irq_map[NR_IRQS];
+static struct irq_map_entry irq_map[NR_IRQS];
 static unsigned int irq_virq_count = NR_IRQS;
 static struct irq_host *irq_default_host;
 
+irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
+{
+        return irq_map[d->irq].hwirq;
+}
+EXPORT_SYMBOL_GPL(irqd_to_hwirq);
+
 irq_hw_number_t virq_to_hw(unsigned int virq)
 {
         return irq_map[virq].hwirq;
 }
 EXPORT_SYMBOL_GPL(virq_to_hw);
 
+bool virq_is_host(unsigned int virq, struct irq_host *host)
+{
+        return irq_map[virq].host == host;
+}
+EXPORT_SYMBOL_GPL(virq_is_host);
+
 static int default_irq_host_match(struct irq_host *h, struct device_node *np)
 {
         return h->of_node != NULL && h->of_node == np;
@@ -561,7 +539,7 @@ struct irq_host *irq_alloc_host(struct device_node *of_node,
         /* Allocate structure and revmap table if using linear mapping */
         if (revmap_type == IRQ_HOST_MAP_LINEAR)
                 size += revmap_arg * sizeof(unsigned int);
-        host = zalloc_maybe_bootmem(size, GFP_KERNEL);
+        host = kzalloc(size, GFP_KERNEL);
         if (host == NULL)
                 return NULL;
 
@@ -582,13 +560,8 @@ struct irq_host *irq_alloc_host(struct device_node *of_node,
         if (revmap_type == IRQ_HOST_MAP_LEGACY) {
                 if (irq_map[0].host != NULL) {
                         raw_spin_unlock_irqrestore(&irq_big_lock, flags);
-                        /* If we are early boot, we can't free the structure,
-                         * too bad...
-                         * this will be fixed once slab is made available early
-                         * instead of the current cruft
-                         */
-                        if (mem_init_done)
-                                kfree(host);
+                        of_node_put(host->of_node);
+                        kfree(host);
                         return NULL;
                 }
                 irq_map[0].host = host;
@@ -609,14 +582,14 @@ struct irq_host *irq_alloc_host(struct device_node *of_node,
                         irq_map[i].host = host;
                         smp_wmb();
 
-                        /* Clear norequest flags */
-                        irq_to_desc(i)->status &= ~IRQ_NOREQUEST;
-
                         /* Legacy flags are left to default at this point,
                          * one can then use irq_create_mapping() to
                          * explicitly change them
                          */
                         ops->map(host, i, i);
+
+                        /* Clear norequest flags */
+                        irq_clear_status_flags(i, IRQ_NOREQUEST);
                 }
                 break;
         case IRQ_HOST_MAP_LINEAR:
@@ -627,6 +600,9 @@ struct irq_host *irq_alloc_host(struct device_node *of_node,
                 smp_wmb();
                 host->revmap_data.linear.revmap = rmap;
                 break;
+        case IRQ_HOST_MAP_TREE:
+                INIT_RADIX_TREE(&host->revmap_data.tree, GFP_KERNEL);
+                break;
         default:
                 break;
         }
@@ -676,17 +652,14 @@ void irq_set_virq_count(unsigned int count)
 static int irq_setup_virq(struct irq_host *host, unsigned int virq,
                             irq_hw_number_t hwirq)
 {
-        struct irq_desc *desc;
+        int res;
 
-        desc = irq_to_desc_alloc_node(virq, 0);
-        if (!desc) {
+        res = irq_alloc_desc_at(virq, 0);
+        if (res != virq) {
                 pr_debug("irq: -> allocating desc failed\n");
                 goto error;
         }
 
-        /* Clear IRQ_NOREQUEST flag */
-        desc->status &= ~IRQ_NOREQUEST;
-
         /* map it */
         smp_wmb();
         irq_map[virq].hwirq = hwirq;
@@ -694,11 +667,15 @@ static int irq_setup_virq(struct irq_host *host, unsigned int virq,
 
         if (host->ops->map(host, virq, hwirq)) {
                 pr_debug("irq: -> mapping failed, freeing\n");
-                goto error;
+                goto errdesc;
         }
 
+        irq_clear_status_flags(virq, IRQ_NOREQUEST);
+
         return 0;
 
+errdesc:
+        irq_free_descs(virq, 1);
 error:
         irq_free_virt(virq, 1);
         return -1;
@@ -746,13 +723,9 @@ unsigned int irq_create_mapping(struct irq_host *host,
         }
         pr_debug("irq: -> using host @%p\n", host);
 
-        /* Check if mapping already exist, if it does, call
-         * host->ops->map() to update the flags
-         */
+        /* Check if mapping already exists */
         virq = irq_find_mapping(host, hwirq);
         if (virq != NO_IRQ) {
-                if (host->ops->remap)
-                        host->ops->remap(host, virq, hwirq);
                 pr_debug("irq: -> existing mapping on virq %d\n", virq);
                 return virq;
         }
@@ -818,8 +791,8 @@ unsigned int irq_create_of_mapping(struct device_node *controller,
 
         /* Set type if specified and different than the current one */
         if (type != IRQ_TYPE_NONE &&
-            type != (irq_to_desc(virq)->status & IRQF_TRIGGER_MASK))
-                set_irq_type(virq, type);
+            type != (irqd_get_trigger_type(irq_get_irq_data(virq))))
+                irq_set_irq_type(virq, type);
         return virq;
 }
 EXPORT_SYMBOL_GPL(irq_create_of_mapping);
@@ -833,16 +806,17 @@ void irq_dispose_mapping(unsigned int virq)
                 return;
 
         host = irq_map[virq].host;
-        WARN_ON (host == NULL);
-        if (host == NULL)
+        if (WARN_ON(host == NULL))
                 return;
 
         /* Never unmap legacy interrupts */
         if (host->revmap_type == IRQ_HOST_MAP_LEGACY)
                 return;
 
+        irq_set_status_flags(virq, IRQ_NOREQUEST);
+
         /* remove chip and handler */
-        set_irq_chip_and_handler(virq, NULL, NULL);
+        irq_set_chip_and_handler(virq, NULL, NULL);
 
         /* Make sure it's completed */
         synchronize_irq(virq);
@@ -860,13 +834,6 @@ void irq_dispose_mapping(unsigned int virq)
                         host->revmap_data.linear.revmap[hwirq] = NO_IRQ;
                 break;
         case IRQ_HOST_MAP_TREE:
-                /*
-                 * Check if radix tree allocated yet, if not then nothing to
-                 * remove.
-                 */
-                smp_rmb();
-                if (revmap_trees_allocated < 1)
-                        break;
                 mutex_lock(&revmap_trees_mutex);
                 radix_tree_delete(&host->revmap_data.tree, hwirq);
                 mutex_unlock(&revmap_trees_mutex);
@@ -877,9 +844,7 @@ void irq_dispose_mapping(unsigned int virq)
         smp_mb();
         irq_map[virq].hwirq = host->inval_irq;
 
-        /* Set some flags */
-        irq_to_desc(virq)->status |= IRQ_NOREQUEST;
-
+        irq_free_descs(virq, 1);
         /* Free it */
         irq_free_virt(virq, 1);
 }
@@ -924,21 +889,17 @@ unsigned int irq_radix_revmap_lookup(struct irq_host *host,
         struct irq_map_entry *ptr;
         unsigned int virq;
 
-        WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE);
-
-        /*
-         * Check if the radix tree exists and has bee initialized.
-         * If not, we fallback to slow mode
-         */
-        if (revmap_trees_allocated < 2)
+        if (WARN_ON_ONCE(host->revmap_type != IRQ_HOST_MAP_TREE))
                 return irq_find_mapping(host, hwirq);
 
-        /* Now try to resolve */
         /*
-         * No rcu_read_lock(ing) needed, the ptr returned can't go under us
-         * as it's referencing an entry in the static irq_map table.
+         * The ptr returned references the static global irq_map.
+         * but freeing an irq can delete nodes along the path to
+         * do the lookup via call_rcu.
          */
+        rcu_read_lock();
         ptr = radix_tree_lookup(&host->revmap_data.tree, hwirq);
+        rcu_read_unlock();
 
         /*
          * If found in radix tree, then fine.
@@ -956,16 +917,7 @@ unsigned int irq_radix_revmap_lookup(struct irq_host *host,
 void irq_radix_revmap_insert(struct irq_host *host, unsigned int virq,
                              irq_hw_number_t hwirq)
 {
-
-        WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE);
-
-        /*
-         * Check if the radix tree exists yet.
-         * If not, then the irq will be inserted into the tree when it gets
-         * initialized.
-         */
-        smp_rmb();
-        if (revmap_trees_allocated < 1)
+        if (WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE))
                 return;
 
         if (virq != NO_IRQ) {
@@ -981,7 +933,8 @@ unsigned int irq_linear_revmap(struct irq_host *host,
 {
         unsigned int *revmap;
 
-        WARN_ON(host->revmap_type != IRQ_HOST_MAP_LINEAR);
+        if (WARN_ON_ONCE(host->revmap_type != IRQ_HOST_MAP_LINEAR))
+                return irq_find_mapping(host, hwirq);
 
         /* Check revmap bounds */
         if (unlikely(hwirq >= host->revmap_data.linear.size))
@@ -1054,14 +1007,23 @@ void irq_free_virt(unsigned int virq, unsigned int count)
         WARN_ON (virq < NUM_ISA_INTERRUPTS);
         WARN_ON (count == 0 || (virq + count) > irq_virq_count);
 
+        if (virq < NUM_ISA_INTERRUPTS) {
+                if (virq + count < NUM_ISA_INTERRUPTS)
+                        return;
+                count  =- NUM_ISA_INTERRUPTS - virq;
+                virq = NUM_ISA_INTERRUPTS;
+        }
+
+        if (count > irq_virq_count || virq > irq_virq_count - count) {
+                if (virq > irq_virq_count)
+                        return;
+                count = irq_virq_count - virq;
+        }
+
         raw_spin_lock_irqsave(&irq_big_lock, flags);
         for (i = virq; i < (virq + count); i++) {
                 struct irq_host *host;
 
-                if (i < NUM_ISA_INTERRUPTS ||
-                    (virq + count) > irq_virq_count)
-                        continue;
-
                 host = irq_map[i].host;
                 irq_map[i].hwirq = host->inval_irq;
                 smp_wmb();
@@ -1072,82 +1034,21 @@ void irq_free_virt(unsigned int virq, unsigned int count)
 
 int arch_early_irq_init(void)
 {
-        struct irq_desc *desc;
-        int i;
-
-        for (i = 0; i < NR_IRQS; i++) {
-                desc = irq_to_desc(i);
-                if (desc)
-                        desc->status |= IRQ_NOREQUEST;
-        }
-
-        return 0;
-}
-
-int arch_init_chip_data(struct irq_desc *desc, int node)
-{
-        desc->status |= IRQ_NOREQUEST;
         return 0;
 }
 
-/* We need to create the radix trees late */
-static int irq_late_init(void)
-{
-        struct irq_host *h;
-        unsigned int i;
-
-        /*
-         * No mutual exclusion with respect to accessors of the tree is needed
-         * here as the synchronization is done via the state variable
-         * revmap_trees_allocated.
-         */
-        list_for_each_entry(h, &irq_hosts, link) {
-                if (h->revmap_type == IRQ_HOST_MAP_TREE)
-                        INIT_RADIX_TREE(&h->revmap_data.tree, GFP_KERNEL);
-        }
-
-        /*
-         * Make sure the radix trees inits are visible before setting
-         * the flag
-         */
-        smp_wmb();
-        revmap_trees_allocated = 1;
-
-        /*
-         * Insert the reverse mapping for those interrupts already present
-         * in irq_map[].
-         */
-        mutex_lock(&revmap_trees_mutex);
-        for (i = 0; i < irq_virq_count; i++) {
-                if (irq_map[i].host &&
-                    (irq_map[i].host->revmap_type == IRQ_HOST_MAP_TREE))
-                        radix_tree_insert(&irq_map[i].host->revmap_data.tree,
-                                          irq_map[i].hwirq, &irq_map[i]);
-        }
-        mutex_unlock(&revmap_trees_mutex);
-
-        /*
-         * Make sure the radix trees insertions are visible before setting
-         * the flag
-         */
-        smp_wmb();
-        revmap_trees_allocated = 2;
-
-        return 0;
-}
-arch_initcall(irq_late_init);
-
 #ifdef CONFIG_VIRQ_DEBUG
 static int virq_debug_show(struct seq_file *m, void *private)
 {
         unsigned long flags;
         struct irq_desc *desc;
         const char *p;
-        char none[] = "none";
+        static const char none[] = "none";
+        void *data;
         int i;
 
-        seq_printf(m, "%-5s  %-7s  %-15s  %s\n", "virq", "hwirq",
-                      "chip name", "host name");
+        seq_printf(m, "%-5s  %-7s  %-15s  %-18s  %s\n", "virq", "hwirq",
+                      "chip name", "chip data", "host name");
 
         for (i = 1; i < nr_irqs; i++) {
                 desc = irq_to_desc(i);
@@ -1157,15 +1058,21 @@ static int virq_debug_show(struct seq_file *m, void *private)
                 raw_spin_lock_irqsave(&desc->lock, flags);
 
                 if (desc->action && desc->action->handler) {
+                        struct irq_chip *chip;
+
                         seq_printf(m, "%5d  ", i);
-                        seq_printf(m, "0x%05lx  ", virq_to_hw(i));
+                        seq_printf(m, "0x%05lx  ", irq_map[i].hwirq);
 
-                        if (desc->chip && desc->chip->name)
-                                p = desc->chip->name;
+                        chip = irq_desc_get_chip(desc);
+                        if (chip && chip->name)
+                                p = chip->name;
                         else
                                 p = none;
                         seq_printf(m, "%-15s  ", p);
 
+                        data = irq_desc_get_chip_data(desc);
+                        seq_printf(m, "0x%16p  ", data);
+
                         if (irq_map[i].host && irq_map[i].host->of_node)
                                 p = irq_map[i].host->of_node->full_name;
                         else