m68k: fix crufty ColdFire intro comments
[muen/linux.git] / arch / m68k / platform / 68000 / ints.c
1 /*
2  * ints.c - Generic interrupt controller support
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/types.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/irq.h>
17 #include <asm/traps.h>
18 #include <asm/io.h>
19 #include <asm/machdep.h>
20
21 #if defined(CONFIG_M68328)
22 #include <asm/MC68328.h>
23 #elif defined(CONFIG_M68EZ328)
24 #include <asm/MC68EZ328.h>
25 #elif defined(CONFIG_M68VZ328)
26 #include <asm/MC68VZ328.h>
27 #endif
28
29 /* assembler routines */
30 asmlinkage void system_call(void);
31 asmlinkage void buserr(void);
32 asmlinkage void trap(void);
33 asmlinkage void trap3(void);
34 asmlinkage void trap4(void);
35 asmlinkage void trap5(void);
36 asmlinkage void trap6(void);
37 asmlinkage void trap7(void);
38 asmlinkage void trap8(void);
39 asmlinkage void trap9(void);
40 asmlinkage void trap10(void);
41 asmlinkage void trap11(void);
42 asmlinkage void trap12(void);
43 asmlinkage void trap13(void);
44 asmlinkage void trap14(void);
45 asmlinkage void trap15(void);
46 asmlinkage void trap33(void);
47 asmlinkage void trap34(void);
48 asmlinkage void trap35(void);
49 asmlinkage void trap36(void);
50 asmlinkage void trap37(void);
51 asmlinkage void trap38(void);
52 asmlinkage void trap39(void);
53 asmlinkage void trap40(void);
54 asmlinkage void trap41(void);
55 asmlinkage void trap42(void);
56 asmlinkage void trap43(void);
57 asmlinkage void trap44(void);
58 asmlinkage void trap45(void);
59 asmlinkage void trap46(void);
60 asmlinkage void trap47(void);
61 asmlinkage irqreturn_t bad_interrupt(int, void *);
62 asmlinkage irqreturn_t inthandler(void);
63 asmlinkage irqreturn_t inthandler1(void);
64 asmlinkage irqreturn_t inthandler2(void);
65 asmlinkage irqreturn_t inthandler3(void);
66 asmlinkage irqreturn_t inthandler4(void);
67 asmlinkage irqreturn_t inthandler5(void);
68 asmlinkage irqreturn_t inthandler6(void);
69 asmlinkage irqreturn_t inthandler7(void);
70
71 /* The 68k family did not have a good way to determine the source
72  * of interrupts until later in the family.  The EC000 core does
73  * not provide the vector number on the stack, we vector everything
74  * into one vector and look in the blasted mask register...
75  * This code is designed to be fast, almost constant time, not clean!
76  */
77 void process_int(int vec, struct pt_regs *fp)
78 {
79         int irq;
80         int mask;
81
82         unsigned long pend = ISR;
83
84         while (pend) {
85                 if (pend & 0x0000ffff) {
86                         if (pend & 0x000000ff) {
87                                 if (pend & 0x0000000f) {
88                                         mask = 0x00000001;
89                                         irq = 0;
90                                 } else {
91                                         mask = 0x00000010;
92                                         irq = 4;
93                                 }
94                         } else {
95                                 if (pend & 0x00000f00) {
96                                         mask = 0x00000100;
97                                         irq = 8;
98                                 } else {
99                                         mask = 0x00001000;
100                                         irq = 12;
101                                 }
102                         }
103                 } else {
104                         if (pend & 0x00ff0000) {
105                                 if (pend & 0x000f0000) {
106                                         mask = 0x00010000;
107                                         irq = 16;
108                                 } else {
109                                         mask = 0x00100000;
110                                         irq = 20;
111                                 }
112                         } else {
113                                 if (pend & 0x0f000000) {
114                                         mask = 0x01000000;
115                                         irq = 24;
116                                 } else {
117                                         mask = 0x10000000;
118                                         irq = 28;
119                                 }
120                         }
121                 }
122
123                 while (! (mask & pend)) {
124                         mask <<=1;
125                         irq++;
126                 }
127
128                 do_IRQ(irq, fp);
129                 pend &= ~mask;
130         }
131 }
132
133 static void intc_irq_unmask(struct irq_data *d)
134 {
135         IMR &= ~(1 << d->irq);
136 }
137
138 static void intc_irq_mask(struct irq_data *d)
139 {
140         IMR |= (1 << d->irq);
141 }
142
143 static struct irq_chip intc_irq_chip = {
144         .name           = "M68K-INTC",
145         .irq_mask       = intc_irq_mask,
146         .irq_unmask     = intc_irq_unmask,
147 };
148
149 /*
150  * This function should be called during kernel startup to initialize
151  * the machine vector table.
152  */
153 void __init trap_init(void)
154 {
155         int i;
156
157         /* set up the vectors */
158         for (i = 72; i < 256; ++i)
159                 _ramvec[i] = (e_vector) bad_interrupt;
160
161         _ramvec[32] = system_call;
162
163         _ramvec[65] = (e_vector) inthandler1;
164         _ramvec[66] = (e_vector) inthandler2;
165         _ramvec[67] = (e_vector) inthandler3;
166         _ramvec[68] = (e_vector) inthandler4;
167         _ramvec[69] = (e_vector) inthandler5;
168         _ramvec[70] = (e_vector) inthandler6;
169         _ramvec[71] = (e_vector) inthandler7;
170 }
171
172 void __init init_IRQ(void)
173 {
174         int i;
175
176         IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */
177
178         /* turn off all interrupts */
179         IMR = ~0;
180
181         for (i = 0; (i < NR_IRQS); i++) {
182                 irq_set_chip(i, &intc_irq_chip);
183                 irq_set_handler(i, handle_level_irq);
184         }
185 }
186