1 files changed, 186 insertions, 233 deletions

diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 22da1335445a..9d5da7896892 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -1,6 +1,9 @@
 /*
  * Cell Internal Interrupt Controller
  *
+ * Copyright (C) 2006 Benjamin Herrenschmidt (benh@kernel.crashing.org)
+ *                    IBM, Corp.
+ *
  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
  *
  * Author: Arnd Bergmann <arndb@de.ibm.com>
@@ -25,11 +28,13 @@
 #include <linux/module.h>
 #include <linux/percpu.h>
 #include <linux/types.h>
+#include <linux/ioport.h>
 
 #include <asm/io.h>
 #include <asm/pgtable.h>
 #include <asm/prom.h>
 #include <asm/ptrace.h>
+#include <asm/machdep.h>
 
 #include "interrupt.h"
 #include "cbe_regs.h"
@@ -37,231 +42,65 @@
 struct iic {
         struct cbe_iic_thread_regs __iomem *regs;
         u8 target_id;
+        u8 eoi_stack[16];
+        int eoi_ptr;
+        struct irq_host *host;
 };
 
 static DEFINE_PER_CPU(struct iic, iic);
+#define IIC_NODE_COUNT  2
+static struct irq_host *iic_hosts[IIC_NODE_COUNT];
 
-void iic_local_enable(void)
+/* Convert between "pending" bits and hw irq number */
+static irq_hw_number_t iic_pending_to_hwnum(struct cbe_iic_pending_bits bits)
 {
-        struct iic *iic = &__get_cpu_var(iic);
-        u64 tmp;
-
-        /*
-         * There seems to be a bug that is present in DD2.x CPUs
-         * and still only partially fixed in DD3.1.
-         * This bug causes a value written to the priority register
-         * not to make it there, resulting in a system hang unless we
-         * write it again.
-         * Masking with 0xf0 is done because the Cell BE does not
-         * implement the lower four bits of the interrupt priority,
-         * they always read back as zeroes, although future CPUs
-         * might implement different bits.
-         */
-        do {
-                out_be64(&iic->regs->prio, 0xff);
-                tmp = in_be64(&iic->regs->prio);
-        } while ((tmp & 0xf0) != 0xf0);
-}
-
-void iic_local_disable(void)
-{
-        out_be64(&__get_cpu_var(iic).regs->prio, 0x0);
-}
+        unsigned char unit = bits.source & 0xf;
 
-static unsigned int iic_startup(unsigned int irq)
-{
-        return 0;
+        if (bits.flags & CBE_IIC_IRQ_IPI)
+                return IIC_IRQ_IPI0 | (bits.prio >> 4);
+        else if (bits.class <= 3)
+                return (bits.class << 4) | unit;
+        else
+                return IIC_IRQ_INVALID;
 }
 
-static void iic_enable(unsigned int irq)
+static void iic_mask(unsigned int irq)
 {
-        iic_local_enable();
 }
 
-static void iic_disable(unsigned int irq)
+static void iic_unmask(unsigned int irq)
 {
 }
 
-static void iic_end(unsigned int irq)
+static void iic_eoi(unsigned int irq)
 {
-        iic_local_enable();
+        struct iic *iic = &__get_cpu_var(iic);
+        out_be64(&iic->regs->prio, iic->eoi_stack[--iic->eoi_ptr]);
+        BUG_ON(iic->eoi_ptr < 0);
 }
 
-static struct hw_interrupt_type iic_pic = {
+static struct irq_chip iic_chip = {
         .typename = " CELL-IIC ",
-        .startup = iic_startup,
-        .enable = iic_enable,
-        .disable = iic_disable,
-        .end = iic_end,
+        .mask = iic_mask,
+        .unmask = iic_unmask,
+        .eoi = iic_eoi,
 };
 
-static int iic_external_get_irq(struct cbe_iic_pending_bits pending)
-{
-        int irq;
-        unsigned char node, unit;
-
-        node = pending.source >> 4;
-        unit = pending.source & 0xf;
-        irq = -1;
-
-        /*
-         * This mapping is specific to the Cell Broadband
-         * Engine. We might need to get the numbers
-         * from the device tree to support future CPUs.
-         */
-        switch (unit) {
-        case 0x00:
-        case 0x0b:
-                /*
-                 * One of these units can be connected
-                 * to an external interrupt controller.
-                 */
-                if (pending.class != 2)
-                        break;
-                irq = IIC_EXT_OFFSET
-                        + spider_get_irq(node)
-                        + node * IIC_NODE_STRIDE;
-                break;
-        case 0x01 ... 0x04:
-        case 0x07 ... 0x0a:
-                /*
-                 * These units are connected to the SPEs
-                 */
-                if (pending.class > 2)
-                        break;
-                irq = IIC_SPE_OFFSET
-                        + pending.class * IIC_CLASS_STRIDE
-                        + node * IIC_NODE_STRIDE
-                        + unit;
-                break;
-        }
-        if (irq == -1)
-                printk(KERN_WARNING "Unexpected interrupt class %02x, "
-                        "source %02x, prio %02x, cpu %02x\n", pending.class,
-                        pending.source, pending.prio, smp_processor_id());
-        return irq;
-}
-
 /* Get an IRQ number from the pending state register of the IIC */
-int iic_get_irq(struct pt_regs *regs)
+static unsigned int iic_get_irq(struct pt_regs *regs)
 {
-        struct iic *iic;
-        int irq;
-        struct cbe_iic_pending_bits pending;
-
-        iic = &__get_cpu_var(iic);
-        *(unsigned long *) &pending = 
-                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
-
-        irq = -1;
-        if (pending.flags & CBE_IIC_IRQ_VALID) {
-                if (pending.flags & CBE_IIC_IRQ_IPI) {
-                        irq = IIC_IPI_OFFSET + (pending.prio >> 4);
-/*
-                        if (irq > 0x80)
-                                printk(KERN_WARNING "Unexpected IPI prio %02x"
-                                        "on CPU %02x\n", pending.prio,
-                                                        smp_processor_id());
-*/
-                } else {
-                        irq = iic_external_get_irq(pending);
-                }
-        }
-        return irq;
-}
-
-/* hardcoded part to be compatible with older firmware */
-
-static int setup_iic_hardcoded(void)
-{
-        struct device_node *np;
-        int nodeid, cpu;
-        unsigned long regs;
-        struct iic *iic;
-
-        for_each_possible_cpu(cpu) {
-                iic = &per_cpu(iic, cpu);
-                nodeid = cpu/2;
-
-                for (np = of_find_node_by_type(NULL, "cpu");
-                     np;
-                     np = of_find_node_by_type(np, "cpu")) {
-                        if (nodeid == *(int *)get_property(np, "node-id", NULL))
-                                break;
-                        }
-
-                if (!np) {
-                        printk(KERN_WARNING "IIC: CPU %d not found\n", cpu);
-                        iic->regs = NULL;
-                        iic->target_id = 0xff;
-                        return -ENODEV;
-                        }
-
-                regs = *(long *)get_property(np, "iic", NULL);
-
-                /* hack until we have decided on the devtree info */
-                regs += 0x400;
-                if (cpu & 1)
-                        regs += 0x20;
-
-                printk(KERN_INFO "IIC for CPU %d at %lx\n", cpu, regs);
-                iic->regs = ioremap(regs, sizeof(struct cbe_iic_thread_regs));
-                iic->target_id = (nodeid << 4) + ((cpu & 1) ? 0xf : 0xe);
-        }
-
-        return 0;
-}
-
-static int setup_iic(void)
-{
-        struct device_node *dn;
-        unsigned long *regs;
-        char *compatible;
-        unsigned *np, found = 0;
-        struct iic *iic = NULL;
-
-        for (dn = NULL; (dn = of_find_node_by_name(dn, "interrupt-controller"));) {
-                compatible = (char *)get_property(dn, "compatible", NULL);
-
-                if (!compatible) {
-                        printk(KERN_WARNING "no compatible property found !\n");
-                        continue;
-                }
-
-                if (strstr(compatible, "IBM,CBEA-Internal-Interrupt-Controller"))
-                        regs = (unsigned long *)get_property(dn,"reg", NULL);
-                else
-                        continue;
-
-                if (!regs)
-                        printk(KERN_WARNING "IIC: no reg property\n");
-
-                np = (unsigned int *)get_property(dn, "ibm,interrupt-server-ranges", NULL);
-
-                if (!np) {
-                        printk(KERN_WARNING "IIC: CPU association not found\n");
-                        iic->regs = NULL;
-                        iic->target_id = 0xff;
-                        return -ENODEV;
-                }
-
-                iic = &per_cpu(iic, np[0]);
-                iic->regs = ioremap(regs[0], sizeof(struct cbe_iic_thread_regs));
-                iic->target_id = ((np[0] & 2) << 3) + ((np[0] & 1) ? 0xf : 0xe);
-                printk("IIC for CPU %d at %lx mapped to %p\n", np[0], regs[0], iic->regs);
-
-                iic = &per_cpu(iic, np[1]);
-                iic->regs = ioremap(regs[2], sizeof(struct cbe_iic_thread_regs));
-                iic->target_id = ((np[1] & 2) << 3) + ((np[1] & 1) ? 0xf : 0xe);
-                printk("IIC for CPU %d at %lx mapped to %p\n", np[1], regs[2], iic->regs);
-
-                found++;
-        }
-
-        if (found)
-                return 0;
-        else
-                return -ENODEV;
+        struct cbe_iic_pending_bits pending;
+        struct iic *iic;
+
+        iic = &__get_cpu_var(iic);
+        *(unsigned long *) &pending =
+                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
+        iic->eoi_stack[++iic->eoi_ptr] = pending.prio;
+        BUG_ON(iic->eoi_ptr > 15);
+        if (pending.flags & CBE_IIC_IRQ_VALID)
+                return irq_linear_revmap(iic->host,
+                                         iic_pending_to_hwnum(pending));
+        return NO_IRQ;
 }
 
 #ifdef CONFIG_SMP
@@ -269,12 +108,12 @@ static int setup_iic(void)
 /* Use the highest interrupt priorities for IPI */
 static inline int iic_ipi_to_irq(int ipi)
 {
-        return IIC_IPI_OFFSET + IIC_NUM_IPIS - 1 - ipi;
+        return IIC_IRQ_IPI0 + IIC_NUM_IPIS - 1 - ipi;
 }
 
 static inline int iic_irq_to_ipi(int irq)
 {
-        return IIC_NUM_IPIS - 1 - (irq - IIC_IPI_OFFSET);
+        return IIC_NUM_IPIS - 1 - (irq - IIC_IRQ_IPI0);
 }
 
 void iic_setup_cpu(void)
@@ -293,22 +132,51 @@ u8 iic_get_target_id(int cpu)
 }
 EXPORT_SYMBOL_GPL(iic_get_target_id);
 
+struct irq_host *iic_get_irq_host(int node)
+{
+        if (node < 0 || node >= IIC_NODE_COUNT)
+                return NULL;
+        return iic_hosts[node];
+}
+EXPORT_SYMBOL_GPL(iic_get_irq_host);
+
+
 static irqreturn_t iic_ipi_action(int irq, void *dev_id, struct pt_regs *regs)
 {
-        smp_message_recv(iic_irq_to_ipi(irq), regs);
+        int ipi = (int)(long)dev_id;
+
+        smp_message_recv(ipi, regs);
+
         return IRQ_HANDLED;
 }
 
 static void iic_request_ipi(int ipi, const char *name)
 {
-        int irq;
-
-        irq = iic_ipi_to_irq(ipi);
-        /* IPIs are marked IRQF_DISABLED as they must run with irqs
-         * disabled */
-        get_irq_desc(irq)->chip = &iic_pic;
-        get_irq_desc(irq)->status |= IRQ_PER_CPU;
-        request_irq(irq, iic_ipi_action, IRQF_DISABLED, name, NULL);
+        int node, virq;
+
+        for (node = 0; node < IIC_NODE_COUNT; node++) {
+                char *rname;
+                if (iic_hosts[node] == NULL)
+                        continue;
+                virq = irq_create_mapping(iic_hosts[node],
+                                          iic_ipi_to_irq(ipi), 0);
+                if (virq == NO_IRQ) {
+                        printk(KERN_ERR
+                               "iic: failed to map IPI %s on node %d\n",
+                               name, node);
+                        continue;
+                }
+                rname = kzalloc(strlen(name) + 16, GFP_KERNEL);
+                if (rname)
+                        sprintf(rname, "%s node %d", name, node);
+                else
+                        rname = (char *)name;
+                if (request_irq(virq, iic_ipi_action, IRQF_DISABLED,
+                                rname, (void *)(long)ipi))
+                        printk(KERN_ERR
+                               "iic: failed to request IPI %s on node %d\n",
+                               name, node);
+        }
 }
 
 void iic_request_IPIs(void)
@@ -319,34 +187,119 @@ void iic_request_IPIs(void)
         iic_request_ipi(PPC_MSG_DEBUGGER_BREAK, "IPI-debug");
 #endif /* CONFIG_DEBUGGER */
 }
+
 #endif /* CONFIG_SMP */
 
-static void iic_setup_spe_handlers(void)
+
+static int iic_host_match(struct irq_host *h, struct device_node *node)
+{
+        return h->host_data != NULL && node == h->host_data;
+}
+
+static int iic_host_map(struct irq_host *h, unsigned int virq,
+                        irq_hw_number_t hw, unsigned int flags)
+{
+        if (hw < IIC_IRQ_IPI0)
+                set_irq_chip_and_handler(virq, &iic_chip, handle_fasteoi_irq);
+        else
+                set_irq_chip_and_handler(virq, &iic_chip, handle_percpu_irq);
+        return 0;
+}
+
+static int iic_host_xlate(struct irq_host *h, struct device_node *ct,
+                           u32 *intspec, unsigned int intsize,
+                           irq_hw_number_t *out_hwirq, unsigned int *out_flags)
+
+{
+        /* Currently, we don't translate anything. That needs to be fixed as
+         * we get better defined device-trees. iic interrupts have to be
+         * explicitely mapped by whoever needs them
+         */
+        return -ENODEV;
+}
+
+static struct irq_host_ops iic_host_ops = {
+        .match = iic_host_match,
+        .map = iic_host_map,
+        .xlate = iic_host_xlate,
+};
+
+static void __init init_one_iic(unsigned int hw_cpu, unsigned long addr,
+                                struct irq_host *host)
 {
-        int be, isrc;
+        /* XXX FIXME: should locate the linux CPU number from the HW cpu
+         * number properly. We are lucky for now
+         */
+        struct iic *iic = &per_cpu(iic, hw_cpu);
+
+        iic->regs = ioremap(addr, sizeof(struct cbe_iic_thread_regs));
+        BUG_ON(iic->regs == NULL);
 
-        /* Assume two threads per BE are present */
-        for (be=0; be < num_present_cpus() / 2; be++) {
-                for (isrc = 0; isrc < IIC_CLASS_STRIDE * 3; isrc++) {
-                        int irq = IIC_NODE_STRIDE * be + IIC_SPE_OFFSET + isrc;
-                        get_irq_desc(irq)->chip = &iic_pic;
+        iic->target_id = ((hw_cpu & 2) << 3) | ((hw_cpu & 1) ? 0xf : 0xe);
+        iic->eoi_stack[0] = 0xff;
+        iic->host = host;
+        out_be64(&iic->regs->prio, 0);
+
+        printk(KERN_INFO "IIC for CPU %d at %lx mapped to %p, target id 0x%x\n",
+               hw_cpu, addr, iic->regs, iic->target_id);
+}
+
+static int __init setup_iic(void)
+{
+        struct device_node *dn;
+        struct resource r0, r1;
+        struct irq_host *host;
+        int found = 0;
+        u32 *np;
+
+        for (dn = NULL;
+             (dn = of_find_node_by_name(dn,"interrupt-controller")) != NULL;) {
+                if (!device_is_compatible(dn,
+                                     "IBM,CBEA-Internal-Interrupt-Controller"))
+                        continue;
+                np = (u32 *)get_property(dn, "ibm,interrupt-server-ranges",
+                                         NULL);
+                if (np == NULL) {
+                        printk(KERN_WARNING "IIC: CPU association not found\n");
+                        of_node_put(dn);
+                        return -ENODEV;
+                }
+                if (of_address_to_resource(dn, 0, &r0) ||
+                    of_address_to_resource(dn, 1, &r1)) {
+                        printk(KERN_WARNING "IIC: Can't resolve addresses\n");
+                        of_node_put(dn);
+                        return -ENODEV;
                 }
+                host = NULL;
+                if (found < IIC_NODE_COUNT) {
+                        host = irq_alloc_host(IRQ_HOST_MAP_LINEAR,
+                                              IIC_SOURCE_COUNT,
+                                              &iic_host_ops,
+                                              IIC_IRQ_INVALID);
+                        iic_hosts[found] = host;
+                        BUG_ON(iic_hosts[found] == NULL);
+                        iic_hosts[found]->host_data = of_node_get(dn);
+                        found++;
+                }
+                init_one_iic(np[0], r0.start, host);
+                init_one_iic(np[1], r1.start, host);
         }
+
+        if (found)
+                return 0;
+        else
+                return -ENODEV;
 }
 
-void iic_init_IRQ(void)
+void __init iic_init_IRQ(void)
 {
-        int cpu, irq_offset;
-        struct iic *iic;
-
+        /* Discover and initialize iics */
         if (setup_iic() < 0)
-                setup_iic_hardcoded();
+                panic("IIC: Failed to initialize !\n");
 
-        irq_offset = 0;
-        for_each_possible_cpu(cpu) {
-                iic = &per_cpu(iic, cpu);
-                if (iic->regs)
-                        out_be64(&iic->regs->prio, 0xff);
-        }
-        iic_setup_spe_handlers();
+        /* Set master interrupt handling function */
+        ppc_md.get_irq = iic_get_irq;
+
+        /* Enable on current CPU */
+        iic_setup_cpu();
 }