e3fffdfcc67476e3f8f4a583facd1fd2b61e255d
[linux-2.6.git] / arch / powerpc / platforms / cell / interrupt.c
1 /*
2  * Cell Internal Interrupt Controller
3  *
4  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
5  *
6  * Author: Arnd Bergmann <arndb@de.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include <linux/config.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/module.h>
27 #include <linux/percpu.h>
28 #include <linux/types.h>
29
30 #include <asm/io.h>
31 #include <asm/pgtable.h>
32 #include <asm/prom.h>
33 #include <asm/ptrace.h>
34
35 #include "interrupt.h"
36
37 struct iic_pending_bits {
38         u32 data;
39         u8 flags;
40         u8 class;
41         u8 source;
42         u8 prio;
43 };
44
45 enum iic_pending_flags {
46         IIC_VALID = 0x80,
47         IIC_IPI   = 0x40,
48 };
49
50 struct iic_regs {
51         struct iic_pending_bits pending;
52         struct iic_pending_bits pending_destr;
53         u64 generate;
54         u64 prio;
55 };
56
57 struct iic {
58         struct iic_regs __iomem *regs;
59         u8 target_id;
60 };
61
62 static DEFINE_PER_CPU(struct iic, iic);
63
64 void iic_local_enable(void)
65 {
66         struct iic *iic = &__get_cpu_var(iic);
67         u64 tmp;
68
69         /*
70          * There seems to be a bug that is present in DD2.x CPUs
71          * and still only partially fixed in DD3.1.
72          * This bug causes a value written to the priority register
73          * not to make it there, resulting in a system hang unless we
74          * write it again.
75          * Masking with 0xf0 is done because the Cell BE does not
76          * implement the lower four bits of the interrupt priority,
77          * they always read back as zeroes, although future CPUs
78          * might implement different bits.
79          */
80         do {
81                 out_be64(&iic->regs->prio, 0xff);
82                 tmp = in_be64(&iic->regs->prio);
83         } while ((tmp & 0xf0) != 0xf0);
84 }
85
86 void iic_local_disable(void)
87 {
88         out_be64(&__get_cpu_var(iic).regs->prio, 0x0);
89 }
90
91 static unsigned int iic_startup(unsigned int irq)
92 {
93         return 0;
94 }
95
96 static void iic_enable(unsigned int irq)
97 {
98         iic_local_enable();
99 }
100
101 static void iic_disable(unsigned int irq)
102 {
103 }
104
105 static void iic_end(unsigned int irq)
106 {
107         iic_local_enable();
108 }
109
110 static struct hw_interrupt_type iic_pic = {
111         .typename = " CELL-IIC ",
112         .startup = iic_startup,
113         .enable = iic_enable,
114         .disable = iic_disable,
115         .end = iic_end,
116 };
117
118 static int iic_external_get_irq(struct iic_pending_bits pending)
119 {
120         int irq;
121         unsigned char node, unit;
122
123         node = pending.source >> 4;
124         unit = pending.source & 0xf;
125         irq = -1;
126
127         /*
128          * This mapping is specific to the Cell Broadband
129          * Engine. We might need to get the numbers
130          * from the device tree to support future CPUs.
131          */
132         switch (unit) {
133         case 0x00:
134         case 0x0b:
135                 /*
136                  * One of these units can be connected
137                  * to an external interrupt controller.
138                  */
139                 if (pending.prio > 0x3f ||
140                     pending.class != 2)
141                         break;
142                 irq = IIC_EXT_OFFSET
143                         + spider_get_irq(node)
144                         + node * IIC_NODE_STRIDE;
145                 break;
146         case 0x01 ... 0x04:
147         case 0x07 ... 0x0a:
148                 /*
149                  * These units are connected to the SPEs
150                  */
151                 if (pending.class > 2)
152                         break;
153                 irq = IIC_SPE_OFFSET
154                         + pending.class * IIC_CLASS_STRIDE
155                         + node * IIC_NODE_STRIDE
156                         + unit;
157                 break;
158         }
159         if (irq == -1)
160                 printk(KERN_WARNING "Unexpected interrupt class %02x, "
161                         "source %02x, prio %02x, cpu %02x\n", pending.class,
162                         pending.source, pending.prio, smp_processor_id());
163         return irq;
164 }
165
166 /* Get an IRQ number from the pending state register of the IIC */
167 int iic_get_irq(struct pt_regs *regs)
168 {
169         struct iic *iic;
170         int irq;
171         struct iic_pending_bits pending;
172
173         iic = &__get_cpu_var(iic);
174         *(unsigned long *) &pending = 
175                 in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
176
177         irq = -1;
178         if (pending.flags & IIC_VALID) {
179                 if (pending.flags & IIC_IPI) {
180                         irq = IIC_IPI_OFFSET + (pending.prio >> 4);
181 /*
182                         if (irq > 0x80)
183                                 printk(KERN_WARNING "Unexpected IPI prio %02x"
184                                         "on CPU %02x\n", pending.prio,
185                                                         smp_processor_id());
186 */
187                 } else {
188                         irq = iic_external_get_irq(pending);
189                 }
190         }
191         return irq;
192 }
193
194 /* hardcoded part to be compatible with older firmware */
195
196 static int setup_iic_hardcoded(void)
197 {
198         struct device_node *np;
199         int nodeid, cpu;
200         unsigned long regs;
201         struct iic *iic;
202
203         for_each_cpu(cpu) {
204                 iic = &per_cpu(iic, cpu);
205                 nodeid = cpu/2;
206
207                 for (np = of_find_node_by_type(NULL, "cpu");
208                      np;
209                      np = of_find_node_by_type(np, "cpu")) {
210                         if (nodeid == *(int *)get_property(np, "node-id", NULL))
211                                 break;
212                         }
213
214                 if (!np) {
215                         printk(KERN_WARNING "IIC: CPU %d not found\n", cpu);
216                         iic->regs = NULL;
217                         iic->target_id = 0xff;
218                         return -ENODEV;
219                         }
220
221                 regs = *(long *)get_property(np, "iic", NULL);
222
223                 /* hack until we have decided on the devtree info */
224                 regs += 0x400;
225                 if (cpu & 1)
226                         regs += 0x20;
227
228                 printk(KERN_INFO "IIC for CPU %d at %lx\n", cpu, regs);
229                 iic->regs = __ioremap(regs, sizeof(struct iic_regs),
230                                       _PAGE_NO_CACHE);
231
232                 iic->target_id = (nodeid << 4) + ((cpu & 1) ? 0xf : 0xe);
233         }
234
235         return 0;
236 }
237
238 static int setup_iic(void)
239 {
240         struct device_node *dn;
241         unsigned long *regs;
242         char *compatible;
243         unsigned *np, found = 0;
244         struct iic *iic = NULL;
245
246         for (dn = NULL; (dn = of_find_node_by_name(dn, "interrupt-controller"));) {
247                 compatible = (char *)get_property(dn, "compatible", NULL);
248
249                 if (!compatible) {
250                         printk(KERN_WARNING "no compatible property found !\n");
251                         continue;
252                 }
253
254                 if (strstr(compatible, "IBM,CBEA-Internal-Interrupt-Controller"))
255                         regs = (unsigned long *)get_property(dn,"reg", NULL);
256                 else
257                         continue;
258
259                 if (!regs)
260                         printk(KERN_WARNING "IIC: no reg property\n");
261
262                 np = (unsigned int *)get_property(dn, "ibm,interrupt-server-ranges", NULL);
263
264                 if (!np) {
265                         printk(KERN_WARNING "IIC: CPU association not found\n");
266                         iic->regs = NULL;
267                         iic->target_id = 0xff;
268                         return -ENODEV;
269                 }
270
271                 iic = &per_cpu(iic, np[0]);
272                 iic->regs = __ioremap(regs[0], sizeof(struct iic_regs),
273                                       _PAGE_NO_CACHE);
274                 iic->target_id = ((np[0] & 2) << 3) + ((np[0] & 1) ? 0xf : 0xe);
275                 printk("IIC for CPU %d at %lx mapped to %p\n", np[0], regs[0], iic->regs);
276
277                 iic = &per_cpu(iic, np[1]);
278                 iic->regs = __ioremap(regs[2], sizeof(struct iic_regs),
279                                       _PAGE_NO_CACHE);
280                 iic->target_id = ((np[1] & 2) << 3) + ((np[1] & 1) ? 0xf : 0xe);
281                 printk("IIC for CPU %d at %lx mapped to %p\n", np[1], regs[2], iic->regs);
282
283                 found++;
284         }
285
286         if (found)
287                 return 0;
288         else
289                 return -ENODEV;
290 }
291
292 #ifdef CONFIG_SMP
293
294 /* Use the highest interrupt priorities for IPI */
295 static inline int iic_ipi_to_irq(int ipi)
296 {
297         return IIC_IPI_OFFSET + IIC_NUM_IPIS - 1 - ipi;
298 }
299
300 static inline int iic_irq_to_ipi(int irq)
301 {
302         return IIC_NUM_IPIS - 1 - (irq - IIC_IPI_OFFSET);
303 }
304
305 void iic_setup_cpu(void)
306 {
307         out_be64(&__get_cpu_var(iic).regs->prio, 0xff);
308 }
309
310 void iic_cause_IPI(int cpu, int mesg)
311 {
312         out_be64(&per_cpu(iic, cpu).regs->generate, (IIC_NUM_IPIS - 1 - mesg) << 4);
313 }
314
315 u8 iic_get_target_id(int cpu)
316 {
317         return per_cpu(iic, cpu).target_id;
318 }
319 EXPORT_SYMBOL_GPL(iic_get_target_id);
320
321 static irqreturn_t iic_ipi_action(int irq, void *dev_id, struct pt_regs *regs)
322 {
323         smp_message_recv(iic_irq_to_ipi(irq), regs);
324         return IRQ_HANDLED;
325 }
326
327 static void iic_request_ipi(int ipi, const char *name)
328 {
329         int irq;
330
331         irq = iic_ipi_to_irq(ipi);
332         /* IPIs are marked SA_INTERRUPT as they must run with irqs
333          * disabled */
334         get_irq_desc(irq)->handler = &iic_pic;
335         get_irq_desc(irq)->status |= IRQ_PER_CPU;
336         request_irq(irq, iic_ipi_action, SA_INTERRUPT, name, NULL);
337 }
338
339 void iic_request_IPIs(void)
340 {
341         iic_request_ipi(PPC_MSG_CALL_FUNCTION, "IPI-call");
342         iic_request_ipi(PPC_MSG_RESCHEDULE, "IPI-resched");
343 #ifdef CONFIG_DEBUGGER
344         iic_request_ipi(PPC_MSG_DEBUGGER_BREAK, "IPI-debug");
345 #endif /* CONFIG_DEBUGGER */
346 }
347 #endif /* CONFIG_SMP */
348
349 static void iic_setup_spe_handlers(void)
350 {
351         int be, isrc;
352
353         /* Assume two threads per BE are present */
354         for (be=0; be < num_present_cpus() / 2; be++) {
355                 for (isrc = 0; isrc < IIC_CLASS_STRIDE * 3; isrc++) {
356                         int irq = IIC_NODE_STRIDE * be + IIC_SPE_OFFSET + isrc;
357                         get_irq_desc(irq)->handler = &iic_pic;
358                 }
359         }
360 }
361
362 void iic_init_IRQ(void)
363 {
364         int cpu, irq_offset;
365         struct iic *iic;
366
367         if (setup_iic() < 0)
368                 setup_iic_hardcoded();
369
370         irq_offset = 0;
371         for_each_cpu(cpu) {
372                 iic = &per_cpu(iic, cpu);
373                 if (iic->regs)
374                         out_be64(&iic->regs->prio, 0xff);
375         }
376         iic_setup_spe_handlers();
377 }