]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/$(ARCH)/platform/$(PLATFORM)/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 (c) 2000 Michael Leslie <mleslie@lineo.com> | |
9 | * Copyright (c) 1996 Roman Zippel | |
10 | * Copyright (c) 1999 D. Jeff Dionne <jeff@uclinux.org> | |
11 | */ | |
12 | ||
1da177e4 LT |
13 | #include <linux/module.h> |
14 | #include <linux/types.h> | |
15 | #include <linux/kernel.h> | |
16 | #include <linux/sched.h> | |
17 | #include <linux/kernel_stat.h> | |
18 | #include <linux/errno.h> | |
19 | ||
20 | #include <asm/system.h> | |
21 | #include <asm/irq.h> | |
0f7cfcc5 | 22 | #include <asm/irqnode.h> |
1da177e4 LT |
23 | #include <asm/traps.h> |
24 | #include <asm/io.h> | |
25 | #include <asm/machdep.h> | |
26 | #include <asm/setup.h> | |
27 | #include <asm/m68360.h> | |
28 | ||
29 | /* from quicc/commproc.c: */ | |
30 | extern QUICC *pquicc; | |
31 | extern void cpm_interrupt_init(void); | |
32 | ||
33 | #define INTERNAL_IRQS (96) | |
34 | ||
35 | /* assembler routines */ | |
36 | asmlinkage void system_call(void); | |
37 | asmlinkage void buserr(void); | |
38 | asmlinkage void trap(void); | |
39 | asmlinkage irqreturn_t bad_interrupt(void); | |
40 | asmlinkage irqreturn_t inthandler(void); | |
41 | ||
42 | extern void *_ramvec[]; | |
43 | ||
44 | /* The number of spurious interrupts */ | |
45 | volatile unsigned int num_spurious; | |
46 | unsigned int local_irq_count[NR_CPUS]; | |
47 | ||
48 | /* irq node variables for the 32 (potential) on chip sources */ | |
49 | static irq_node_t int_irq_list[INTERNAL_IRQS]; | |
50 | ||
51 | static short int_irq_ablecount[INTERNAL_IRQS]; | |
52 | ||
53 | /* | |
54 | * This function should be called during kernel startup to initialize | |
55 | * IRQ handling routines. | |
56 | */ | |
57 | ||
58 | void init_IRQ(void) | |
59 | { | |
60 | int i; | |
61 | int vba = (CPM_VECTOR_BASE<<4); | |
62 | ||
63 | /* set up the vectors */ | |
64 | _ramvec[2] = buserr; | |
65 | _ramvec[3] = trap; | |
66 | _ramvec[4] = trap; | |
67 | _ramvec[5] = trap; | |
68 | _ramvec[6] = trap; | |
69 | _ramvec[7] = trap; | |
70 | _ramvec[8] = trap; | |
71 | _ramvec[9] = trap; | |
72 | _ramvec[10] = trap; | |
73 | _ramvec[11] = trap; | |
74 | _ramvec[12] = trap; | |
75 | _ramvec[13] = trap; | |
76 | _ramvec[14] = trap; | |
77 | _ramvec[15] = trap; | |
78 | ||
79 | _ramvec[32] = system_call; | |
80 | _ramvec[33] = trap; | |
81 | ||
82 | ||
83 | cpm_interrupt_init(); | |
84 | ||
85 | /* set up CICR for vector base address and irq level */ | |
86 | /* irl = 4, hp = 1f - see MC68360UM p 7-377 */ | |
87 | pquicc->intr_cicr = 0x00e49f00 | vba; | |
88 | ||
89 | /* CPM interrupt vectors: (p 7-376) */ | |
90 | _ramvec[vba+CPMVEC_ERROR] = bad_interrupt; /* Error */ | |
91 | _ramvec[vba+CPMVEC_PIO_PC11] = inthandler; /* pio - pc11 */ | |
92 | _ramvec[vba+CPMVEC_PIO_PC10] = inthandler; /* pio - pc10 */ | |
93 | _ramvec[vba+CPMVEC_SMC2] = inthandler; /* smc2/pip */ | |
94 | _ramvec[vba+CPMVEC_SMC1] = inthandler; /* smc1 */ | |
95 | _ramvec[vba+CPMVEC_SPI] = inthandler; /* spi */ | |
96 | _ramvec[vba+CPMVEC_PIO_PC9] = inthandler; /* pio - pc9 */ | |
97 | _ramvec[vba+CPMVEC_TIMER4] = inthandler; /* timer 4 */ | |
98 | _ramvec[vba+CPMVEC_RESERVED1] = inthandler; /* reserved */ | |
99 | _ramvec[vba+CPMVEC_PIO_PC8] = inthandler; /* pio - pc8 */ | |
100 | _ramvec[vba+CPMVEC_PIO_PC7] = inthandler; /* pio - pc7 */ | |
101 | _ramvec[vba+CPMVEC_PIO_PC6] = inthandler; /* pio - pc6 */ | |
102 | _ramvec[vba+CPMVEC_TIMER3] = inthandler; /* timer 3 */ | |
103 | _ramvec[vba+CPMVEC_RISCTIMER] = inthandler; /* reserved */ | |
104 | _ramvec[vba+CPMVEC_PIO_PC5] = inthandler; /* pio - pc5 */ | |
105 | _ramvec[vba+CPMVEC_PIO_PC4] = inthandler; /* pio - pc4 */ | |
106 | _ramvec[vba+CPMVEC_RESERVED2] = inthandler; /* reserved */ | |
107 | _ramvec[vba+CPMVEC_RISCTIMER] = inthandler; /* timer table */ | |
108 | _ramvec[vba+CPMVEC_TIMER2] = inthandler; /* timer 2 */ | |
109 | _ramvec[vba+CPMVEC_RESERVED3] = inthandler; /* reserved */ | |
110 | _ramvec[vba+CPMVEC_IDMA2] = inthandler; /* idma 2 */ | |
111 | _ramvec[vba+CPMVEC_IDMA1] = inthandler; /* idma 1 */ | |
112 | _ramvec[vba+CPMVEC_SDMA_CB_ERR] = inthandler; /* sdma channel bus error */ | |
113 | _ramvec[vba+CPMVEC_PIO_PC3] = inthandler; /* pio - pc3 */ | |
114 | _ramvec[vba+CPMVEC_PIO_PC2] = inthandler; /* pio - pc2 */ | |
115 | /* _ramvec[vba+CPMVEC_TIMER1] = cpm_isr_timer1; */ /* timer 1 */ | |
116 | _ramvec[vba+CPMVEC_TIMER1] = inthandler; /* timer 1 */ | |
117 | _ramvec[vba+CPMVEC_PIO_PC1] = inthandler; /* pio - pc1 */ | |
118 | _ramvec[vba+CPMVEC_SCC4] = inthandler; /* scc 4 */ | |
119 | _ramvec[vba+CPMVEC_SCC3] = inthandler; /* scc 3 */ | |
120 | _ramvec[vba+CPMVEC_SCC2] = inthandler; /* scc 2 */ | |
121 | _ramvec[vba+CPMVEC_SCC1] = inthandler; /* scc 1 */ | |
122 | _ramvec[vba+CPMVEC_PIO_PC0] = inthandler; /* pio - pc0 */ | |
123 | ||
124 | ||
125 | /* turn off all CPM interrupts */ | |
126 | pquicc->intr_cimr = 0x00000000; | |
127 | ||
128 | /* initialize handlers */ | |
129 | for (i = 0; i < INTERNAL_IRQS; i++) { | |
130 | int_irq_list[i].handler = NULL; | |
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 | ||
137 | #if 0 | |
138 | void M68360_insert_irq(irq_node_t **list, irq_node_t *node) | |
139 | { | |
140 | unsigned long flags; | |
141 | irq_node_t *cur; | |
142 | ||
143 | if (!node->dev_id) | |
144 | printk(KERN_INFO "%s: Warning: dev_id of %s is zero\n", | |
145 | __FUNCTION__, node->devname); | |
146 | ||
147 | local_irq_save(flags); | |
148 | ||
149 | cur = *list; | |
150 | ||
151 | while (cur) { | |
152 | list = &cur->next; | |
153 | cur = cur->next; | |
154 | } | |
155 | ||
156 | node->next = cur; | |
157 | *list = node; | |
158 | ||
159 | local_irq_restore(flags); | |
160 | } | |
161 | ||
162 | void M68360_delete_irq(irq_node_t **list, void *dev_id) | |
163 | { | |
164 | unsigned long flags; | |
165 | irq_node_t *node; | |
166 | ||
167 | local_irq_save(flags); | |
168 | ||
169 | for (node = *list; node; list = &node->next, node = *list) { | |
170 | if (node->dev_id == dev_id) { | |
171 | *list = node->next; | |
172 | /* Mark it as free. */ | |
173 | node->handler = NULL; | |
174 | local_irq_restore(flags); | |
175 | return; | |
176 | } | |
177 | } | |
178 | local_irq_restore(flags); | |
179 | printk (KERN_INFO "%s: tried to remove invalid irq\n", __FUNCTION__); | |
180 | } | |
181 | #endif | |
182 | ||
183 | int request_irq( | |
184 | unsigned int irq, | |
185 | irqreturn_t (*handler)(int, void *, struct pt_regs *), | |
186 | unsigned long flags, | |
187 | const char *devname, | |
188 | void *dev_id) | |
189 | { | |
190 | int mask = (1<<irq); | |
191 | ||
192 | irq += (CPM_VECTOR_BASE<<4); | |
193 | ||
194 | if (irq >= INTERNAL_IRQS) { | |
195 | printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname); | |
196 | return -ENXIO; | |
197 | } | |
198 | ||
199 | if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) { | |
200 | if (int_irq_list[irq].flags & IRQ_FLG_LOCK) { | |
201 | printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n", | |
202 | __FUNCTION__, irq, int_irq_list[irq].devname); | |
203 | return -EBUSY; | |
204 | } | |
205 | if (flags & IRQ_FLG_REPLACE) { | |
206 | printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n", | |
207 | __FUNCTION__, devname, irq, int_irq_list[irq].devname); | |
208 | return -EBUSY; | |
209 | } | |
210 | } | |
211 | int_irq_list[irq].handler = handler; | |
212 | int_irq_list[irq].flags = flags; | |
213 | int_irq_list[irq].dev_id = dev_id; | |
214 | int_irq_list[irq].devname = devname; | |
215 | ||
216 | /* enable in the CIMR */ | |
217 | if (!int_irq_ablecount[irq]) | |
218 | pquicc->intr_cimr |= mask; | |
219 | /* *(volatile unsigned long *)0xfffff304 &= ~(1<<irq); */ | |
220 | ||
221 | return 0; | |
222 | } | |
223 | ||
224 | EXPORT_SYMBOL(request_irq); | |
225 | ||
226 | void free_irq(unsigned int irq, void *dev_id) | |
227 | { | |
228 | if (irq >= INTERNAL_IRQS) { | |
229 | printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq); | |
230 | return; | |
231 | } | |
232 | ||
233 | if (int_irq_list[irq].dev_id != dev_id) | |
234 | printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n", | |
235 | __FUNCTION__, irq, int_irq_list[irq].devname); | |
236 | int_irq_list[irq].handler = NULL; | |
237 | int_irq_list[irq].flags = IRQ_FLG_STD; | |
238 | int_irq_list[irq].dev_id = NULL; | |
239 | int_irq_list[irq].devname = NULL; | |
240 | ||
241 | *(volatile unsigned long *)0xfffff304 |= 1<<irq; | |
242 | } | |
243 | ||
244 | EXPORT_SYMBOL(free_irq); | |
245 | ||
246 | #if 0 | |
247 | /* | |
248 | * Enable/disable a particular machine specific interrupt source. | |
249 | * Note that this may affect other interrupts in case of a shared interrupt. | |
250 | * This function should only be called for a _very_ short time to change some | |
251 | * internal data, that may not be changed by the interrupt at the same time. | |
252 | * int_(enable|disable)_irq calls may also be nested. | |
253 | */ | |
254 | void M68360_enable_irq(unsigned int irq) | |
255 | { | |
256 | if (irq >= INTERNAL_IRQS) { | |
257 | printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq); | |
258 | return; | |
259 | } | |
260 | ||
261 | if (--int_irq_ablecount[irq]) | |
262 | return; | |
263 | ||
264 | /* enable the interrupt */ | |
265 | *(volatile unsigned long *)0xfffff304 &= ~(1<<irq); | |
266 | } | |
267 | ||
268 | void M68360_disable_irq(unsigned int irq) | |
269 | { | |
270 | if (irq >= INTERNAL_IRQS) { | |
271 | printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq); | |
272 | return; | |
273 | } | |
274 | ||
275 | if (int_irq_ablecount[irq]++) | |
276 | return; | |
277 | ||
278 | /* disable the interrupt */ | |
279 | *(volatile unsigned long *)0xfffff304 |= 1<<irq; | |
280 | } | |
281 | #endif | |
282 | ||
283 | int show_interrupts(struct seq_file *p, void *v) | |
284 | { | |
285 | int i = *(loff_t *) v; | |
286 | ||
287 | if (i < NR_IRQS) { | |
288 | if (int_irq_list[i].devname) { | |
289 | seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]); | |
290 | if (int_irq_list[i].flags & IRQ_FLG_LOCK) | |
291 | seq_printf(p, "L "); | |
292 | else | |
293 | seq_printf(p, " "); | |
294 | seq_printf(p, "%s\n", int_irq_list[i].devname); | |
295 | } | |
296 | } | |
297 | if (i == NR_IRQS) | |
298 | seq_printf(p, " : %10u spurious\n", num_spurious); | |
299 | ||
300 | return 0; | |
301 | } | |
302 | ||
303 | /* The 68k family did not have a good way to determine the source | |
304 | * of interrupts until later in the family. The EC000 core does | |
305 | * not provide the vector number on the stack, we vector everything | |
306 | * into one vector and look in the blasted mask register... | |
307 | * This code is designed to be fast, almost constant time, not clean! | |
308 | */ | |
309 | void process_int(int vec, struct pt_regs *fp) | |
310 | { | |
311 | int irq; | |
312 | int mask; | |
313 | ||
314 | /* unsigned long pend = *(volatile unsigned long *)0xfffff30c; */ | |
315 | ||
316 | /* irq = vec + (CPM_VECTOR_BASE<<4); */ | |
317 | irq = vec; | |
318 | ||
319 | /* unsigned long pend = *(volatile unsigned long *)pquicc->intr_cipr; */ | |
320 | ||
321 | /* Bugger all that weirdness. For the moment, I seem to know where I came from; | |
322 | * vec is passed from a specific ISR, so I'll use it. */ | |
323 | ||
324 | if (int_irq_list[irq].handler) { | |
325 | int_irq_list[irq].handler(irq , int_irq_list[irq].dev_id, fp); | |
326 | kstat_cpu(0).irqs[irq]++; | |
327 | pquicc->intr_cisr = (1 << vec); /* indicate that irq has been serviced */ | |
328 | } else { | |
329 | printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the CIMR...\n", irq); | |
330 | /* *(volatile unsigned long *)0xfffff304 |= mask; */ | |
331 | pquicc->intr_cimr &= ~(1 << vec); | |
332 | num_spurious += 1; | |
333 | } | |
334 | return(IRQ_HANDLED); | |
335 | } |