Linux-2.6.12-rc2
[linux-2.6.git] / arch / m68knommu / platform / 68328 / ints.c
1 /*
2  * linux/arch/m68knommu/platform/68328/ints.c
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file COPYING in the main directory of this archive
6  * for more details.
7  *
8  * Copyright 1996 Roman Zippel
9  * Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
10  */
11
12 #include <linux/module.h>
13 #include <linux/types.h>
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
16 #include <linux/kernel_stat.h>
17 #include <linux/errno.h>
18
19 #include <asm/system.h>
20 #include <asm/irq.h>
21 #include <asm/traps.h>
22 #include <asm/io.h>
23 #include <asm/machdep.h>
24 #include <asm/setup.h>
25
26 #if defined(CONFIG_M68328)
27 #include <asm/MC68328.h>
28 #elif defined(CONFIG_M68EZ328)
29 #include <asm/MC68EZ328.h>
30 #elif defined(CONFIG_M68VZ328)
31 #include <asm/MC68VZ328.h>
32 #endif
33
34 /* assembler routines */
35 asmlinkage void system_call(void);
36 asmlinkage void buserr(void);
37 asmlinkage void trap(void);
38 asmlinkage void trap3(void);
39 asmlinkage void trap4(void);
40 asmlinkage void trap5(void);
41 asmlinkage void trap6(void);
42 asmlinkage void trap7(void);
43 asmlinkage void trap8(void);
44 asmlinkage void trap9(void);
45 asmlinkage void trap10(void);
46 asmlinkage void trap11(void);
47 asmlinkage void trap12(void);
48 asmlinkage void trap13(void);
49 asmlinkage void trap14(void);
50 asmlinkage void trap15(void);
51 asmlinkage void trap33(void);
52 asmlinkage void trap34(void);
53 asmlinkage void trap35(void);
54 asmlinkage void trap36(void);
55 asmlinkage void trap37(void);
56 asmlinkage void trap38(void);
57 asmlinkage void trap39(void);
58 asmlinkage void trap40(void);
59 asmlinkage void trap41(void);
60 asmlinkage void trap42(void);
61 asmlinkage void trap43(void);
62 asmlinkage void trap44(void);
63 asmlinkage void trap45(void);
64 asmlinkage void trap46(void);
65 asmlinkage void trap47(void);
66 asmlinkage irqreturn_t bad_interrupt(int, void *, struct pt_regs *);
67 asmlinkage irqreturn_t inthandler(void);
68 asmlinkage irqreturn_t inthandler1(void);
69 asmlinkage irqreturn_t inthandler2(void);
70 asmlinkage irqreturn_t inthandler3(void);
71 asmlinkage irqreturn_t inthandler4(void);
72 asmlinkage irqreturn_t inthandler5(void);
73 asmlinkage irqreturn_t inthandler6(void);
74 asmlinkage irqreturn_t inthandler7(void);
75
76 extern e_vector *_ramvec;
77
78 /* The number of spurious interrupts */
79 volatile unsigned int num_spurious;
80 unsigned int local_irq_count[NR_CPUS];
81
82 /* irq node variables for the 32 (potential) on chip sources */
83 static irq_node_t int_irq_list[NR_IRQS];
84
85 #if !defined(CONFIG_DRAGEN2)
86 asm (".global _start, __ramend/n/t"
87      ".section .romvec/n"
88      "e_vectors:\n\t"
89      ".long __ramend-4, _start, buserr, trap, trap, trap, trap, trap\n\t"
90      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
91      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
92      ".long trap, trap, trap, trap\n\t"
93      ".long trap, trap, trap, trap\n\t"
94         /*.long inthandler, inthandler, inthandler, inthandler
95         .long inthandler4, inthandler, inthandler, inthandler   */
96         /* TRAP #0-15 */
97      ".long system_call, trap, trap, trap, trap, trap, trap, trap\n\t"
98      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
99      ".long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n\t"
100      ".text\n"
101      "ignore: rte");
102 #endif
103
104 /*
105  * This function should be called during kernel startup to initialize
106  * the IRQ handling routines.
107  */
108 void init_IRQ(void)
109 {
110         int i;
111
112         /* set up the vectors */
113         for (i = 72; i < 256; ++i)
114                 _ramvec[i] = (e_vector) bad_interrupt;
115
116         _ramvec[32] = system_call;
117
118         _ramvec[65] = (e_vector) inthandler1;
119         _ramvec[66] = (e_vector) inthandler2;
120         _ramvec[67] = (e_vector) inthandler3;
121         _ramvec[68] = (e_vector) inthandler4;
122         _ramvec[69] = (e_vector) inthandler5;
123         _ramvec[70] = (e_vector) inthandler6;
124         _ramvec[71] = (e_vector) inthandler7;
125  
126         IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */
127
128         /* initialize handlers */
129         for (i = 0; i < NR_IRQS; i++) {
130                 int_irq_list[i].handler = bad_interrupt;
131                 int_irq_list[i].flags   = IRQ_FLG_STD;
132                 int_irq_list[i].dev_id  = NULL;
133                 int_irq_list[i].devname = NULL;
134         }
135
136         /* turn off all interrupts */
137         IMR = ~0;
138 }
139
140 int request_irq(
141         unsigned int irq,
142         irqreturn_t (*handler)(int, void *, struct pt_regs *),
143         unsigned long flags,
144         const char *devname,
145         void *dev_id)
146 {
147         if (irq >= NR_IRQS) {
148                 printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
149                 return -ENXIO;
150         }
151
152         if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) {
153                 if (int_irq_list[irq].flags & IRQ_FLG_LOCK) {
154                         printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n",
155                                __FUNCTION__, irq, int_irq_list[irq].devname);
156                         return -EBUSY;
157                 }
158                 if (flags & IRQ_FLG_REPLACE) {
159                         printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n",
160                                __FUNCTION__, devname, irq, int_irq_list[irq].devname);
161                         return -EBUSY;
162                 }
163         }
164
165         int_irq_list[irq].handler = handler;
166         int_irq_list[irq].flags   = flags;
167         int_irq_list[irq].dev_id  = dev_id;
168         int_irq_list[irq].devname = devname;
169
170         IMR &= ~(1<<irq);
171
172         return 0;
173 }
174
175 EXPORT_SYMBOL(request_irq);
176
177 void free_irq(unsigned int irq, void *dev_id)
178 {
179         if (irq >= NR_IRQS) {
180                 printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
181                 return;
182         }
183
184         if (int_irq_list[irq].dev_id != dev_id)
185                 printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n",
186                        __FUNCTION__, irq, int_irq_list[irq].devname);
187
188         int_irq_list[irq].handler = bad_interrupt;
189         int_irq_list[irq].flags   = IRQ_FLG_STD;
190         int_irq_list[irq].dev_id  = NULL;
191         int_irq_list[irq].devname = NULL;
192
193         IMR |= 1<<irq;
194 }
195
196 EXPORT_SYMBOL(free_irq);
197
198 int show_interrupts(struct seq_file *p, void *v)
199 {
200         int i = *(loff_t *) v;
201
202         if (i < NR_IRQS) {
203                 if (int_irq_list[i].devname) {
204                         seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]);
205                         if (int_irq_list[i].flags & IRQ_FLG_LOCK)
206                                 seq_printf(p, "L ");
207                         else
208                                 seq_printf(p, "  ");
209                         seq_printf(p, "%s\n", int_irq_list[i].devname);
210                 }
211         }
212         if (i == NR_IRQS)
213                 seq_printf(p, "   : %10u   spurious\n", num_spurious);
214
215         return 0;
216 }
217
218 /* The 68k family did not have a good way to determine the source
219  * of interrupts until later in the family.  The EC000 core does
220  * not provide the vector number on the stack, we vector everything
221  * into one vector and look in the blasted mask register...
222  * This code is designed to be fast, almost constant time, not clean!
223  */
224 void process_int(int vec, struct pt_regs *fp)
225 {
226         int irq;
227         int mask;
228
229         unsigned long pend = ISR;
230
231         while (pend) {
232                 if (pend & 0x0000ffff) {
233                         if (pend & 0x000000ff) {
234                                 if (pend & 0x0000000f) {
235                                         mask = 0x00000001;
236                                         irq = 0;
237                                 } else {
238                                         mask = 0x00000010;
239                                         irq = 4;
240                                 }
241                         } else {
242                                 if (pend & 0x00000f00) {
243                                         mask = 0x00000100;
244                                         irq = 8;
245                                 } else {
246                                         mask = 0x00001000;
247                                         irq = 12;
248                                 }
249                         }
250                 } else {
251                         if (pend & 0x00ff0000) {
252                                 if (pend & 0x000f0000) {
253                                         mask = 0x00010000;
254                                         irq = 16;
255                                 } else {
256                                         mask = 0x00100000;
257                                         irq = 20;
258                                 }
259                         } else {
260                                 if (pend & 0x0f000000) {
261                                         mask = 0x01000000;
262                                         irq = 24;
263                                 } else {
264                                         mask = 0x10000000;
265                                         irq = 28;
266                                 }
267                         }
268                 }
269
270                 while (! (mask & pend)) {
271                         mask <<=1;
272                         irq++;
273                 }
274
275                 kstat_cpu(0).irqs[irq]++;
276
277                 if (int_irq_list[irq].handler) {
278                         int_irq_list[irq].handler(irq, int_irq_list[irq].dev_id, fp);
279                 } else {
280                         printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the IMR...\n", irq);
281                         IMR |= mask;
282                 }
283                 pend &= ~mask;
284         }
285 }