[PATCH] ppc: Fix m82xx_pci build
[linux-2.6] / arch / ppc / syslib / mpc52xx_pic.c
1 /*
2  * arch/ppc/syslib/mpc52xx_pic.c
3  *
4  * Programmable Interrupt Controller functions for the Freescale MPC52xx 
5  * embedded CPU.
6  *
7  * 
8  * Maintainer : Sylvain Munaut <tnt@246tNt.com>
9  *
10  * Based on (well, mostly copied from) the code from the 2.4 kernel by
11  * Dale Farnsworth <dfarnsworth@mvista.com> and Kent Borg.
12  * 
13  * Copyright (C) 2004 Sylvain Munaut <tnt@246tNt.com>
14  * Copyright (C) 2003 Montavista Software, Inc
15  * 
16  * This file is licensed under the terms of the GNU General Public License
17  * version 2. This program is licensed "as is" without any warranty of any
18  * kind, whether express or implied.
19  */
20
21 #include <linux/stddef.h>
22 #include <linux/init.h>
23 #include <linux/sched.h>
24 #include <linux/signal.h>
25 #include <linux/stddef.h>
26 #include <linux/delay.h>
27 #include <linux/irq.h>
28
29 #include <asm/io.h>
30 #include <asm/processor.h>
31 #include <asm/system.h>
32 #include <asm/irq.h>
33 #include <asm/mpc52xx.h>
34
35
36 static struct mpc52xx_intr __iomem *intr;
37 static struct mpc52xx_sdma __iomem *sdma;
38
39 static void
40 mpc52xx_ic_disable(unsigned int irq)
41 {
42         u32 val;
43
44         if (irq == MPC52xx_IRQ0) {
45                 val = in_be32(&intr->ctrl);
46                 val &= ~(1 << 11);
47                 out_be32(&intr->ctrl, val);
48         }
49         else if (irq < MPC52xx_IRQ1) {
50                 BUG();
51         }
52         else if (irq <= MPC52xx_IRQ3) {
53                 val = in_be32(&intr->ctrl);
54                 val &= ~(1 << (10 - (irq - MPC52xx_IRQ1)));
55                 out_be32(&intr->ctrl, val);
56         }
57         else if (irq < MPC52xx_SDMA_IRQ_BASE) {
58                 val = in_be32(&intr->main_mask);
59                 val |= 1 << (16 - (irq - MPC52xx_MAIN_IRQ_BASE));
60                 out_be32(&intr->main_mask, val);
61         }
62         else if (irq < MPC52xx_PERP_IRQ_BASE) {
63                 val = in_be32(&sdma->IntMask);
64                 val |= 1 << (irq - MPC52xx_SDMA_IRQ_BASE);
65                 out_be32(&sdma->IntMask, val);
66         }
67         else {
68                 val = in_be32(&intr->per_mask);
69                 val |= 1 << (31 - (irq - MPC52xx_PERP_IRQ_BASE));
70                 out_be32(&intr->per_mask, val);
71         }
72 }
73
74 static void
75 mpc52xx_ic_enable(unsigned int irq)
76 {
77         u32 val;
78
79         if (irq == MPC52xx_IRQ0) {
80                 val = in_be32(&intr->ctrl);
81                 val |= 1 << 11;
82                 out_be32(&intr->ctrl, val);
83         }
84         else if (irq < MPC52xx_IRQ1) {
85                 BUG();
86         }
87         else if (irq <= MPC52xx_IRQ3) {
88                 val = in_be32(&intr->ctrl);
89                 val |= 1 << (10 - (irq - MPC52xx_IRQ1));
90                 out_be32(&intr->ctrl, val);
91         }
92         else if (irq < MPC52xx_SDMA_IRQ_BASE) {
93                 val = in_be32(&intr->main_mask);
94                 val &= ~(1 << (16 - (irq - MPC52xx_MAIN_IRQ_BASE)));
95                 out_be32(&intr->main_mask, val);
96         }
97         else if (irq < MPC52xx_PERP_IRQ_BASE) {
98                 val = in_be32(&sdma->IntMask);
99                 val &= ~(1 << (irq - MPC52xx_SDMA_IRQ_BASE));
100                 out_be32(&sdma->IntMask, val);
101         }
102         else {
103                 val = in_be32(&intr->per_mask);
104                 val &= ~(1 << (31 - (irq - MPC52xx_PERP_IRQ_BASE)));
105                 out_be32(&intr->per_mask, val);
106         }
107 }
108
109 static void
110 mpc52xx_ic_ack(unsigned int irq)
111 {
112         u32 val;
113
114         /*
115          * Only some irqs are reset here, others in interrupting hardware.
116          */
117
118         switch (irq) {
119         case MPC52xx_IRQ0:
120                 val = in_be32(&intr->ctrl);
121                 val |= 0x08000000;
122                 out_be32(&intr->ctrl, val);
123                 break;
124         case MPC52xx_CCS_IRQ:
125                 val = in_be32(&intr->enc_status);
126                 val |= 0x00000400;
127                 out_be32(&intr->enc_status, val);
128                 break;
129         case MPC52xx_IRQ1:
130                 val = in_be32(&intr->ctrl);
131                 val |= 0x04000000;
132                 out_be32(&intr->ctrl, val);
133                 break;
134         case MPC52xx_IRQ2:
135                 val = in_be32(&intr->ctrl);
136                 val |= 0x02000000;
137                 out_be32(&intr->ctrl, val);
138                 break;
139         case MPC52xx_IRQ3:
140                 val = in_be32(&intr->ctrl);
141                 val |= 0x01000000;
142                 out_be32(&intr->ctrl, val);
143                 break;
144         default:
145                 if (irq >= MPC52xx_SDMA_IRQ_BASE
146                     && irq < (MPC52xx_SDMA_IRQ_BASE + MPC52xx_SDMA_IRQ_NUM)) {
147                         out_be32(&sdma->IntPend,
148                                  1 << (irq - MPC52xx_SDMA_IRQ_BASE));
149                 }
150                 break;
151         }
152 }
153
154 static void
155 mpc52xx_ic_disable_and_ack(unsigned int irq)
156 {
157         mpc52xx_ic_disable(irq);
158         mpc52xx_ic_ack(irq);
159 }
160
161 static void
162 mpc52xx_ic_end(unsigned int irq)
163 {
164         if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
165                 mpc52xx_ic_enable(irq);
166 }
167
168 static struct hw_interrupt_type mpc52xx_ic = {
169         .typename       = " MPC52xx  ",
170         .enable         = mpc52xx_ic_enable,
171         .disable        = mpc52xx_ic_disable,
172         .ack            = mpc52xx_ic_disable_and_ack,
173         .end            = mpc52xx_ic_end,
174 };
175
176 void __init
177 mpc52xx_init_irq(void)
178 {
179         int i;
180         u32 intr_ctrl;
181
182         /* Remap the necessary zones */
183         intr = ioremap(MPC52xx_PA(MPC52xx_INTR_OFFSET), MPC52xx_INTR_SIZE);
184         sdma = ioremap(MPC52xx_PA(MPC52xx_SDMA_OFFSET), MPC52xx_SDMA_SIZE);
185
186         if ((intr==NULL) || (sdma==NULL))
187                 panic("Can't ioremap PIC/SDMA register for init_irq !");
188
189         /* Disable all interrupt sources. */
190         out_be32(&sdma->IntPend, 0xffffffff);   /* 1 means clear pending */
191         out_be32(&sdma->IntMask, 0xffffffff);   /* 1 means disabled */
192         out_be32(&intr->per_mask, 0x7ffffc00);  /* 1 means disabled */
193         out_be32(&intr->main_mask, 0x00010fff); /* 1 means disabled */
194         intr_ctrl = in_be32(&intr->ctrl);
195         intr_ctrl &=    0x00ff0000;     /* Keeps IRQ[0-3] config */
196         intr_ctrl |=    0x0f000000 |    /* clear IRQ 0-3 */
197                         0x00001000 |    /* MEE master external enable */
198                         0x00000000 |    /* 0 means disable IRQ 0-3 */
199                         0x00000001;     /* CEb route critical normally */
200         out_be32(&intr->ctrl, intr_ctrl);
201
202         /* Zero a bunch of the priority settings.  */
203         out_be32(&intr->per_pri1, 0);
204         out_be32(&intr->per_pri2, 0);
205         out_be32(&intr->per_pri3, 0);
206         out_be32(&intr->main_pri1, 0);
207         out_be32(&intr->main_pri2, 0);
208
209         /* Initialize irq_desc[i].handler's with mpc52xx_ic. */
210         for (i = 0; i < NR_IRQS; i++) {
211                 irq_desc[i].handler = &mpc52xx_ic;
212                 irq_desc[i].status = IRQ_LEVEL;
213         }
214
215         #define IRQn_MODE(intr_ctrl,irq) (((intr_ctrl) >> (22-(i<<1))) & 0x03)
216         for (i=0 ; i<4 ; i++) {
217                 int mode;
218                 mode = IRQn_MODE(intr_ctrl,i);
219                 if ((mode == 0x1) || (mode == 0x2))
220                         irq_desc[i?MPC52xx_IRQ1+i-1:MPC52xx_IRQ0].status = 0;
221         }
222 }
223
224 int
225 mpc52xx_get_irq(struct pt_regs *regs)
226 {
227         u32 status;
228         int irq = -1;
229
230         status = in_be32(&intr->enc_status);
231
232         if (status & 0x00000400) {              /* critical */
233                 irq = (status >> 8) & 0x3;
234                 if (irq == 2)                   /* high priority peripheral */
235                         goto peripheral;
236                 irq += MPC52xx_CRIT_IRQ_BASE;
237         }
238         else if (status & 0x00200000) {         /* main */
239                 irq = (status >> 16) & 0x1f;
240                 if (irq == 4)                   /* low priority peripheral */
241                         goto peripheral;
242                 irq += MPC52xx_MAIN_IRQ_BASE;
243         }
244         else if (status & 0x20000000) {         /* peripheral */
245 peripheral:
246                 irq = (status >> 24) & 0x1f;
247                 if (irq == 0) {                 /* bestcomm */
248                         status = in_be32(&sdma->IntPend);
249                         irq = ffs(status) + MPC52xx_SDMA_IRQ_BASE-1;
250                 }
251                 else
252                         irq += MPC52xx_PERP_IRQ_BASE;
253         }
254
255         return irq;
256 }
257