7160e618b0a96ab64cba71e2eec3fc84b20cff3b
[muen/linux.git] / arch / m68k / platform / 5272 / intc.c
1 /*
2  * intc.c  --  interrupt controller or ColdFire 5272 SoC
3  *
4  * (C) Copyright 2009, Greg Ungerer <gerg@snapgear.com>
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file COPYING in the main directory of this archive
8  * for more details.
9  */
10
11 #include <linux/types.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel_stat.h>
16 #include <linux/irq.h>
17 #include <linux/io.h>
18 #include <asm/coldfire.h>
19 #include <asm/mcfsim.h>
20 #include <asm/traps.h>
21
22 /*
23  * The 5272 ColdFire interrupt controller is nothing like any other
24  * ColdFire interrupt controller - it truly is completely different.
25  * Given its age it is unlikely to be used on any other ColdFire CPU.
26  */
27
28 /*
29  * The masking and priproty setting of interrupts on the 5272 is done
30  * via a set of 4 "Interrupt Controller Registers" (ICR). There is a
31  * loose mapping of vector number to register and internal bits, but
32  * a table is the easiest and quickest way to map them.
33  *
34  * Note that the external interrupts are edge triggered (unlike the
35  * internal interrupt sources which are level triggered). Which means
36  * they also need acknowledging via acknowledge bits.
37  */
38 struct irqmap {
39         unsigned char   icr;
40         unsigned char   index;
41         unsigned char   ack;
42 };
43
44 static struct irqmap intc_irqmap[MCFINT_VECMAX - MCFINT_VECBASE] = {
45         /*MCF_IRQ_SPURIOUS*/    { .icr = 0,           .index = 0,  .ack = 0, },
46         /*MCF_IRQ_EINT1*/       { .icr = MCFSIM_ICR1, .index = 28, .ack = 1, },
47         /*MCF_IRQ_EINT2*/       { .icr = MCFSIM_ICR1, .index = 24, .ack = 1, },
48         /*MCF_IRQ_EINT3*/       { .icr = MCFSIM_ICR1, .index = 20, .ack = 1, },
49         /*MCF_IRQ_EINT4*/       { .icr = MCFSIM_ICR1, .index = 16, .ack = 1, },
50         /*MCF_IRQ_TIMER1*/      { .icr = MCFSIM_ICR1, .index = 12, .ack = 0, },
51         /*MCF_IRQ_TIMER2*/      { .icr = MCFSIM_ICR1, .index = 8,  .ack = 0, },
52         /*MCF_IRQ_TIMER3*/      { .icr = MCFSIM_ICR1, .index = 4,  .ack = 0, },
53         /*MCF_IRQ_TIMER4*/      { .icr = MCFSIM_ICR1, .index = 0,  .ack = 0, },
54         /*MCF_IRQ_UART1*/       { .icr = MCFSIM_ICR2, .index = 28, .ack = 0, },
55         /*MCF_IRQ_UART2*/       { .icr = MCFSIM_ICR2, .index = 24, .ack = 0, },
56         /*MCF_IRQ_PLIP*/        { .icr = MCFSIM_ICR2, .index = 20, .ack = 0, },
57         /*MCF_IRQ_PLIA*/        { .icr = MCFSIM_ICR2, .index = 16, .ack = 0, },
58         /*MCF_IRQ_USB0*/        { .icr = MCFSIM_ICR2, .index = 12, .ack = 0, },
59         /*MCF_IRQ_USB1*/        { .icr = MCFSIM_ICR2, .index = 8,  .ack = 0, },
60         /*MCF_IRQ_USB2*/        { .icr = MCFSIM_ICR2, .index = 4,  .ack = 0, },
61         /*MCF_IRQ_USB3*/        { .icr = MCFSIM_ICR2, .index = 0,  .ack = 0, },
62         /*MCF_IRQ_USB4*/        { .icr = MCFSIM_ICR3, .index = 28, .ack = 0, },
63         /*MCF_IRQ_USB5*/        { .icr = MCFSIM_ICR3, .index = 24, .ack = 0, },
64         /*MCF_IRQ_USB6*/        { .icr = MCFSIM_ICR3, .index = 20, .ack = 0, },
65         /*MCF_IRQ_USB7*/        { .icr = MCFSIM_ICR3, .index = 16, .ack = 0, },
66         /*MCF_IRQ_DMA*/         { .icr = MCFSIM_ICR3, .index = 12, .ack = 0, },
67         /*MCF_IRQ_ERX*/         { .icr = MCFSIM_ICR3, .index = 8,  .ack = 0, },
68         /*MCF_IRQ_ETX*/         { .icr = MCFSIM_ICR3, .index = 4,  .ack = 0, },
69         /*MCF_IRQ_ENTC*/        { .icr = MCFSIM_ICR3, .index = 0,  .ack = 0, },
70         /*MCF_IRQ_QSPI*/        { .icr = MCFSIM_ICR4, .index = 28, .ack = 0, },
71         /*MCF_IRQ_EINT5*/       { .icr = MCFSIM_ICR4, .index = 24, .ack = 1, },
72         /*MCF_IRQ_EINT6*/       { .icr = MCFSIM_ICR4, .index = 20, .ack = 1, },
73         /*MCF_IRQ_SWTO*/        { .icr = MCFSIM_ICR4, .index = 16, .ack = 0, },
74 };
75
76 /*
77  * The act of masking the interrupt also has a side effect of 'ack'ing
78  * an interrupt on this irq (for the external irqs). So this mask function
79  * is also an ack_mask function.
80  */
81 static void intc_irq_mask(struct irq_data *d)
82 {
83         unsigned int irq = d->irq;
84
85         if ((irq >= MCFINT_VECBASE) && (irq <= MCFINT_VECMAX)) {
86                 u32 v;
87                 irq -= MCFINT_VECBASE;
88                 v = 0x8 << intc_irqmap[irq].index;
89                 writel(v, MCF_MBAR + intc_irqmap[irq].icr);
90         }
91 }
92
93 static void intc_irq_unmask(struct irq_data *d)
94 {
95         unsigned int irq = d->irq;
96
97         if ((irq >= MCFINT_VECBASE) && (irq <= MCFINT_VECMAX)) {
98                 u32 v;
99                 irq -= MCFINT_VECBASE;
100                 v = 0xd << intc_irqmap[irq].index;
101                 writel(v, MCF_MBAR + intc_irqmap[irq].icr);
102         }
103 }
104
105 static void intc_irq_ack(struct irq_data *d)
106 {
107         unsigned int irq = d->irq;
108
109         /* Only external interrupts are acked */
110         if ((irq >= MCFINT_VECBASE) && (irq <= MCFINT_VECMAX)) {
111                 irq -= MCFINT_VECBASE;
112                 if (intc_irqmap[irq].ack) {
113                         u32 v;
114                         v = readl(MCF_MBAR + intc_irqmap[irq].icr);
115                         v &= (0x7 << intc_irqmap[irq].index);
116                         v |= (0x8 << intc_irqmap[irq].index);
117                         writel(v, MCF_MBAR + intc_irqmap[irq].icr);
118                 }
119         }
120 }
121
122 static int intc_irq_set_type(struct irq_data *d, unsigned int type)
123 {
124         unsigned int irq = d->irq;
125
126         if ((irq >= MCFINT_VECBASE) && (irq <= MCFINT_VECMAX)) {
127                 irq -= MCFINT_VECBASE;
128                 if (intc_irqmap[irq].ack) {
129                         u32 v;
130                         v = readl(MCF_MBAR + MCFSIM_PITR);
131                         if (type == IRQ_TYPE_EDGE_FALLING)
132                                 v &= ~(0x1 << (32 - irq));
133                         else
134                                 v |= (0x1 << (32 - irq));
135                         writel(v, MCF_MBAR + MCFSIM_PITR);
136                 }
137         }
138         return 0;
139 }
140
141 /*
142  * Simple flow handler to deal with the external edge triggered interrupts.
143  * We need to be careful with the masking/acking due to the side effects
144  * of masking an interrupt.
145  */
146 static void intc_external_irq(unsigned int irq, struct irq_desc *desc)
147 {
148         irq_desc_get_chip(desc)->irq_ack(&desc->irq_data);
149         handle_simple_irq(irq, desc);
150 }
151
152 static struct irq_chip intc_irq_chip = {
153         .name           = "CF-INTC",
154         .irq_mask       = intc_irq_mask,
155         .irq_unmask     = intc_irq_unmask,
156         .irq_mask_ack   = intc_irq_mask,
157         .irq_ack        = intc_irq_ack,
158         .irq_set_type   = intc_irq_set_type,
159 };
160
161 void __init init_IRQ(void)
162 {
163         int irq, edge;
164
165         /* Mask all interrupt sources */
166         writel(0x88888888, MCF_MBAR + MCFSIM_ICR1);
167         writel(0x88888888, MCF_MBAR + MCFSIM_ICR2);
168         writel(0x88888888, MCF_MBAR + MCFSIM_ICR3);
169         writel(0x88888888, MCF_MBAR + MCFSIM_ICR4);
170
171         for (irq = 0; (irq < NR_IRQS); irq++) {
172                 irq_set_chip(irq, &intc_irq_chip);
173                 edge = 0;
174                 if ((irq >= MCFINT_VECBASE) && (irq <= MCFINT_VECMAX))
175                         edge = intc_irqmap[irq - MCFINT_VECBASE].ack;
176                 if (edge) {
177                         irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
178                         irq_set_handler(irq, intc_external_irq);
179                 } else {
180                         irq_set_irq_type(irq, IRQ_TYPE_LEVEL_HIGH);
181                         irq_set_handler(irq, handle_level_irq);
182                 }
183         }
184 }
185