Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / arch / powerpc / platforms / 52xx / mpc52xx_pic.c
1 /*
2  *
3  * Programmable Interrupt Controller functions for the Freescale MPC52xx.
4  *
5  * Copyright (C) 2006 bplan GmbH
6  *
7  * Based on the code from the 2.4 kernel by
8  * Dale Farnsworth <dfarnsworth@mvista.com> and Kent Borg.
9  *
10  * Copyright (C) 2004 Sylvain Munaut <tnt@246tNt.com>
11  * Copyright (C) 2003 Montavista Software, Inc
12  *
13  * This file is licensed under the terms of the GNU General Public License
14  * version 2. This program is licensed "as is" without any warranty of any
15  * kind, whether express or implied.
16  *
17  */
18
19 #undef DEBUG
20
21 #include <linux/irq.h>
22 #include <linux/of.h>
23 #include <asm/io.h>
24 #include <asm/prom.h>
25 #include <asm/mpc52xx.h>
26 #include "mpc52xx_pic.h"
27
28 /*
29  *
30 */
31
32 /* MPC5200 device tree match tables */
33 static struct of_device_id mpc52xx_pic_ids[] __initdata = {
34         { .compatible = "fsl,mpc5200-pic", },
35         { .compatible = "mpc5200-pic", },
36         {}
37 };
38 static struct of_device_id mpc52xx_sdma_ids[] __initdata = {
39         { .compatible = "fsl,mpc5200-bestcomm", },
40         { .compatible = "mpc5200-bestcomm", },
41         {}
42 };
43
44 static struct mpc52xx_intr __iomem *intr;
45 static struct mpc52xx_sdma __iomem *sdma;
46 static struct irq_host *mpc52xx_irqhost = NULL;
47
48 static unsigned char mpc52xx_map_senses[4] = {
49         IRQ_TYPE_LEVEL_HIGH,
50         IRQ_TYPE_EDGE_RISING,
51         IRQ_TYPE_EDGE_FALLING,
52         IRQ_TYPE_LEVEL_LOW,
53 };
54
55 /*
56  *
57 */
58
59 static inline void io_be_setbit(u32 __iomem *addr, int bitno)
60 {
61         out_be32(addr, in_be32(addr) | (1 << bitno));
62 }
63
64 static inline void io_be_clrbit(u32 __iomem *addr, int bitno)
65 {
66         out_be32(addr, in_be32(addr) & ~(1 << bitno));
67 }
68
69 /*
70  * IRQ[0-3] interrupt irq_chip
71 */
72
73 static void mpc52xx_extirq_mask(unsigned int virq)
74 {
75         int irq;
76         int l2irq;
77
78         irq = irq_map[virq].hwirq;
79         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
80
81         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
82
83         io_be_clrbit(&intr->ctrl, 11 - l2irq);
84 }
85
86 static void mpc52xx_extirq_unmask(unsigned int virq)
87 {
88         int irq;
89         int l2irq;
90
91         irq = irq_map[virq].hwirq;
92         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
93
94         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
95
96         io_be_setbit(&intr->ctrl, 11 - l2irq);
97 }
98
99 static void mpc52xx_extirq_ack(unsigned int virq)
100 {
101         int irq;
102         int l2irq;
103
104         irq = irq_map[virq].hwirq;
105         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
106
107         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
108
109         io_be_setbit(&intr->ctrl, 27-l2irq);
110 }
111
112 static struct irq_chip mpc52xx_extirq_irqchip = {
113         .typename = " MPC52xx IRQ[0-3] ",
114         .mask = mpc52xx_extirq_mask,
115         .unmask = mpc52xx_extirq_unmask,
116         .ack = mpc52xx_extirq_ack,
117 };
118
119 /*
120  * Main interrupt irq_chip
121 */
122
123 static void mpc52xx_main_mask(unsigned int virq)
124 {
125         int irq;
126         int l2irq;
127
128         irq = irq_map[virq].hwirq;
129         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
130
131         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
132
133         io_be_setbit(&intr->main_mask, 16 - l2irq);
134 }
135
136 static void mpc52xx_main_unmask(unsigned int virq)
137 {
138         int irq;
139         int l2irq;
140
141         irq = irq_map[virq].hwirq;
142         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
143
144         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
145
146         io_be_clrbit(&intr->main_mask, 16 - l2irq);
147 }
148
149 static struct irq_chip mpc52xx_main_irqchip = {
150         .typename = "MPC52xx Main",
151         .mask = mpc52xx_main_mask,
152         .mask_ack = mpc52xx_main_mask,
153         .unmask = mpc52xx_main_unmask,
154 };
155
156 /*
157  * Peripherals interrupt irq_chip
158 */
159
160 static void mpc52xx_periph_mask(unsigned int virq)
161 {
162         int irq;
163         int l2irq;
164
165         irq = irq_map[virq].hwirq;
166         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
167
168         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
169
170         io_be_setbit(&intr->per_mask, 31 - l2irq);
171 }
172
173 static void mpc52xx_periph_unmask(unsigned int virq)
174 {
175         int irq;
176         int l2irq;
177
178         irq = irq_map[virq].hwirq;
179         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
180
181         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
182
183         io_be_clrbit(&intr->per_mask, 31 - l2irq);
184 }
185
186 static struct irq_chip mpc52xx_periph_irqchip = {
187         .typename = "MPC52xx Peripherals",
188         .mask = mpc52xx_periph_mask,
189         .mask_ack = mpc52xx_periph_mask,
190         .unmask = mpc52xx_periph_unmask,
191 };
192
193 /*
194  * SDMA interrupt irq_chip
195 */
196
197 static void mpc52xx_sdma_mask(unsigned int virq)
198 {
199         int irq;
200         int l2irq;
201
202         irq = irq_map[virq].hwirq;
203         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
204
205         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
206
207         io_be_setbit(&sdma->IntMask, l2irq);
208 }
209
210 static void mpc52xx_sdma_unmask(unsigned int virq)
211 {
212         int irq;
213         int l2irq;
214
215         irq = irq_map[virq].hwirq;
216         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
217
218         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
219
220         io_be_clrbit(&sdma->IntMask, l2irq);
221 }
222
223 static void mpc52xx_sdma_ack(unsigned int virq)
224 {
225         int irq;
226         int l2irq;
227
228         irq = irq_map[virq].hwirq;
229         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
230
231         pr_debug("%s: irq=%x. l2=%d\n", __func__, irq, l2irq);
232
233         out_be32(&sdma->IntPend, 1 << l2irq);
234 }
235
236 static struct irq_chip mpc52xx_sdma_irqchip = {
237         .typename = "MPC52xx SDMA",
238         .mask = mpc52xx_sdma_mask,
239         .unmask = mpc52xx_sdma_unmask,
240         .ack = mpc52xx_sdma_ack,
241 };
242
243 /*
244  * irq_host
245 */
246
247 static int mpc52xx_irqhost_xlate(struct irq_host *h, struct device_node *ct,
248                                  u32 * intspec, unsigned int intsize,
249                                  irq_hw_number_t * out_hwirq,
250                                  unsigned int *out_flags)
251 {
252         int intrvect_l1;
253         int intrvect_l2;
254         int intrvect_type;
255         int intrvect_linux;
256
257         if (intsize != 3)
258                 return -1;
259
260         intrvect_l1 = (int)intspec[0];
261         intrvect_l2 = (int)intspec[1];
262         intrvect_type = (int)intspec[2];
263
264         intrvect_linux =
265             (intrvect_l1 << MPC52xx_IRQ_L1_OFFSET) & MPC52xx_IRQ_L1_MASK;
266         intrvect_linux |=
267             (intrvect_l2 << MPC52xx_IRQ_L2_OFFSET) & MPC52xx_IRQ_L2_MASK;
268
269         pr_debug("return %x, l1=%d, l2=%d\n", intrvect_linux, intrvect_l1,
270                  intrvect_l2);
271
272         *out_hwirq = intrvect_linux;
273         *out_flags = mpc52xx_map_senses[intrvect_type];
274
275         return 0;
276 }
277
278 /*
279  * this function retrieves the correct IRQ type out
280  * of the MPC regs
281  * Only externals IRQs needs this
282 */
283 static int mpc52xx_irqx_gettype(int irq)
284 {
285         int type;
286         u32 ctrl_reg;
287
288         ctrl_reg = in_be32(&intr->ctrl);
289         type = (ctrl_reg >> (22 - irq * 2)) & 0x3;
290
291         return mpc52xx_map_senses[type];
292 }
293
294 static int mpc52xx_irqhost_map(struct irq_host *h, unsigned int virq,
295                                irq_hw_number_t irq)
296 {
297         int l1irq;
298         int l2irq;
299         struct irq_chip *good_irqchip;
300         void *good_handle;
301         int type;
302
303         l1irq = (irq & MPC52xx_IRQ_L1_MASK) >> MPC52xx_IRQ_L1_OFFSET;
304         l2irq = (irq & MPC52xx_IRQ_L2_MASK) >> MPC52xx_IRQ_L2_OFFSET;
305
306         /*
307          * Most of ours IRQs will be level low
308          * Only external IRQs on some platform may be others
309          */
310         type = IRQ_TYPE_LEVEL_LOW;
311
312         switch (l1irq) {
313         case MPC52xx_IRQ_L1_CRIT:
314                 pr_debug("%s: Critical. l2=%x\n", __func__, l2irq);
315
316                 BUG_ON(l2irq != 0);
317
318                 type = mpc52xx_irqx_gettype(l2irq);
319                 good_irqchip = &mpc52xx_extirq_irqchip;
320                 break;
321
322         case MPC52xx_IRQ_L1_MAIN:
323                 pr_debug("%s: Main IRQ[1-3] l2=%x\n", __func__, l2irq);
324
325                 if ((l2irq >= 1) && (l2irq <= 3)) {
326                         type = mpc52xx_irqx_gettype(l2irq);
327                         good_irqchip = &mpc52xx_extirq_irqchip;
328                 } else {
329                         good_irqchip = &mpc52xx_main_irqchip;
330                 }
331                 break;
332
333         case MPC52xx_IRQ_L1_PERP:
334                 pr_debug("%s: Peripherals. l2=%x\n", __func__, l2irq);
335                 good_irqchip = &mpc52xx_periph_irqchip;
336                 break;
337
338         case MPC52xx_IRQ_L1_SDMA:
339                 pr_debug("%s: SDMA. l2=%x\n", __func__, l2irq);
340                 good_irqchip = &mpc52xx_sdma_irqchip;
341                 break;
342
343         default:
344                 pr_debug("%s: Error, unknown L1 IRQ (0x%x)\n", __func__, l1irq);
345                 printk(KERN_ERR "Unknow IRQ!\n");
346                 return -EINVAL;
347         }
348
349         switch (type) {
350         case IRQ_TYPE_EDGE_FALLING:
351         case IRQ_TYPE_EDGE_RISING:
352                 good_handle = handle_edge_irq;
353                 break;
354         default:
355                 good_handle = handle_level_irq;
356         }
357
358         set_irq_chip_and_handler(virq, good_irqchip, good_handle);
359
360         pr_debug("%s: virq=%x, hw=%x. type=%x\n", __func__, virq,
361                  (int)irq, type);
362
363         return 0;
364 }
365
366 static struct irq_host_ops mpc52xx_irqhost_ops = {
367         .xlate = mpc52xx_irqhost_xlate,
368         .map = mpc52xx_irqhost_map,
369 };
370
371 /*
372  * init (public)
373 */
374
375 void __init mpc52xx_init_irq(void)
376 {
377         u32 intr_ctrl;
378         struct device_node *picnode;
379         struct device_node *np;
380
381         /* Remap the necessary zones */
382         picnode = of_find_matching_node(NULL, mpc52xx_pic_ids);
383         intr = of_iomap(picnode, 0);
384         if (!intr)
385                 panic(__FILE__  ": find_and_map failed on 'mpc5200-pic'. "
386                                 "Check node !");
387
388         np = of_find_matching_node(NULL, mpc52xx_sdma_ids);
389         sdma = of_iomap(np, 0);
390         of_node_put(np);
391         if (!sdma)
392                 panic(__FILE__  ": find_and_map failed on 'mpc5200-bestcomm'. "
393                                 "Check node !");
394
395         /* Disable all interrupt sources. */
396         out_be32(&sdma->IntPend, 0xffffffff);   /* 1 means clear pending */
397         out_be32(&sdma->IntMask, 0xffffffff);   /* 1 means disabled */
398         out_be32(&intr->per_mask, 0x7ffffc00);  /* 1 means disabled */
399         out_be32(&intr->main_mask, 0x00010fff); /* 1 means disabled */
400         intr_ctrl = in_be32(&intr->ctrl);
401         intr_ctrl &= 0x00ff0000;        /* Keeps IRQ[0-3] config */
402         intr_ctrl |=    0x0f000000 |    /* clear IRQ 0-3 */
403                         0x00001000 |    /* MEE master external enable */
404                         0x00000000 |    /* 0 means disable IRQ 0-3 */
405                         0x00000001;     /* CEb route critical normally */
406         out_be32(&intr->ctrl, intr_ctrl);
407
408         /* Zero a bunch of the priority settings. */
409         out_be32(&intr->per_pri1, 0);
410         out_be32(&intr->per_pri2, 0);
411         out_be32(&intr->per_pri3, 0);
412         out_be32(&intr->main_pri1, 0);
413         out_be32(&intr->main_pri2, 0);
414
415         /*
416          * As last step, add an irq host to translate the real
417          * hw irq information provided by the ofw to linux virq
418          */
419
420         mpc52xx_irqhost = irq_alloc_host(picnode, IRQ_HOST_MAP_LINEAR,
421                                          MPC52xx_IRQ_HIGHTESTHWIRQ,
422                                          &mpc52xx_irqhost_ops, -1);
423
424         if (!mpc52xx_irqhost)
425                 panic(__FILE__ ": Cannot allocate the IRQ host\n");
426
427         printk(KERN_INFO "MPC52xx PIC is up and running!\n");
428 }
429
430 /*
431  * get_irq (public)
432 */
433 unsigned int mpc52xx_get_irq(void)
434 {
435         u32 status;
436         int irq = NO_IRQ_IGNORE;
437
438         status = in_be32(&intr->enc_status);
439         if (status & 0x00000400) {      /* critical */
440                 irq = (status >> 8) & 0x3;
441                 if (irq == 2)   /* high priority peripheral */
442                         goto peripheral;
443                 irq |=  (MPC52xx_IRQ_L1_CRIT << MPC52xx_IRQ_L1_OFFSET) &
444                         MPC52xx_IRQ_L1_MASK;
445         } else if (status & 0x00200000) {       /* main */
446                 irq = (status >> 16) & 0x1f;
447                 if (irq == 4)   /* low priority peripheral */
448                         goto peripheral;
449                 irq |=  (MPC52xx_IRQ_L1_MAIN << MPC52xx_IRQ_L1_OFFSET) &
450                         MPC52xx_IRQ_L1_MASK;
451         } else if (status & 0x20000000) {       /* peripheral */
452               peripheral:
453                 irq = (status >> 24) & 0x1f;
454                 if (irq == 0) { /* bestcomm */
455                         status = in_be32(&sdma->IntPend);
456                         irq = ffs(status) - 1;
457                         irq |=  (MPC52xx_IRQ_L1_SDMA << MPC52xx_IRQ_L1_OFFSET) &
458                                 MPC52xx_IRQ_L1_MASK;
459                 } else {
460                         irq |=  (MPC52xx_IRQ_L1_PERP << MPC52xx_IRQ_L1_OFFSET) &
461                                 MPC52xx_IRQ_L1_MASK;
462                 }
463         }
464
465         pr_debug("%s: irq=%x. virq=%d\n", __func__, irq,
466                  irq_linear_revmap(mpc52xx_irqhost, irq));
467
468         return irq_linear_revmap(mpc52xx_irqhost, irq);
469 }