m68k/irq: Rename {,__}m68k_handle_int()
[linux-3.10.git] / arch / m68k / kernel / ints.c
1 /*
2  * linux/arch/m68k/kernel/ints.c -- Linux/m68k general interrupt handling code
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  * 07/03/96: Timer initialization, and thus mach_sched_init(),
9  *           removed from request_irq() and moved to init_time().
10  *           We should therefore consider renaming our add_isr() and
11  *           remove_isr() to request_irq() and free_irq()
12  *           respectively, so they are compliant with the other
13  *           architectures.                                     /Jes
14  * 11/07/96: Changed all add_/remove_isr() to request_/free_irq() calls.
15  *           Removed irq list support, if any machine needs an irq server
16  *           it must implement this itself (as it's already done), instead
17  *           only default handler are used with mach_default_handler.
18  *           request_irq got some flags different from other architectures:
19  *           - IRQ_FLG_REPLACE : Replace an existing handler (the default one
20  *                               can be replaced without this flag)
21  *           - IRQ_FLG_LOCK : handler can't be replaced
22  *           There are other machine depending flags, see there
23  *           If you want to replace a default handler you should know what
24  *           you're doing, since it might handle different other irq sources
25  *           which must be served                               /Roman Zippel
26  */
27
28 #include <linux/module.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/interrupt.h>
32 #include <linux/kernel_stat.h>
33 #include <linux/errno.h>
34 #include <linux/init.h>
35
36 #include <asm/setup.h>
37 #include <asm/system.h>
38 #include <asm/irq.h>
39 #include <asm/traps.h>
40 #include <asm/page.h>
41 #include <asm/machdep.h>
42 #include <asm/cacheflush.h>
43 #include <asm/irq_regs.h>
44
45 #ifdef CONFIG_Q40
46 #include <asm/q40ints.h>
47 #endif
48
49 extern u32 auto_irqhandler_fixup[];
50 extern u32 user_irqhandler_fixup[];
51 extern u16 user_irqvec_fixup[];
52
53 /* table for system interrupt handlers */
54 static struct irq_data *irq_list[NR_IRQS];
55 static struct irq_chip *irq_chip[NR_IRQS];
56 static int irq_depth[NR_IRQS];
57
58 static inline int irq_set_chip(unsigned int irq, struct irq_chip *chip)
59 {
60         irq_chip[irq] = chip;
61         return 0;
62 }
63
64 static int m68k_first_user_vec;
65
66 static struct irq_chip auto_irq_chip = {
67         .name           = "auto",
68         .irq_startup    = m68k_irq_startup,
69         .irq_shutdown   = m68k_irq_shutdown,
70 };
71
72 static struct irq_chip user_irq_chip = {
73         .name           = "user",
74         .irq_startup    = m68k_irq_startup,
75         .irq_shutdown   = m68k_irq_shutdown,
76 };
77
78 #define NUM_IRQ_NODES 100
79 static struct irq_data nodes[NUM_IRQ_NODES];
80
81 /*
82  * void init_IRQ(void)
83  *
84  * Parameters:  None
85  *
86  * Returns:     Nothing
87  *
88  * This function should be called during kernel startup to initialize
89  * the IRQ handling routines.
90  */
91
92 void __init init_IRQ(void)
93 {
94         int i;
95
96         /* assembly irq entry code relies on this... */
97         if (HARDIRQ_MASK != 0x00ff0000) {
98                 extern void hardirq_mask_is_broken(void);
99                 hardirq_mask_is_broken();
100         }
101
102         for (i = IRQ_AUTO_1; i <= IRQ_AUTO_7; i++)
103                 irq_set_chip(i, &auto_irq_chip);
104
105         mach_init_IRQ();
106 }
107
108 /**
109  * m68k_setup_auto_interrupt
110  * @handler: called from auto vector interrupts
111  *
112  * setup the handler to be called from auto vector interrupts instead of the
113  * standard do_IRQ(), it will be called with irq numbers in the range
114  * from IRQ_AUTO_1 - IRQ_AUTO_7.
115  */
116 void __init m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *))
117 {
118         if (handler)
119                 *auto_irqhandler_fixup = (u32)handler;
120         flush_icache();
121 }
122
123 /**
124  * m68k_setup_user_interrupt
125  * @vec: first user vector interrupt to handle
126  * @cnt: number of active user vector interrupts
127  * @handler: called from user vector interrupts
128  *
129  * setup user vector interrupts, this includes activating the specified range
130  * of interrupts, only then these interrupts can be requested (note: this is
131  * different from auto vector interrupts). An optional handler can be installed
132  * to be called instead of the default do_IRQ(), it will be called
133  * with irq numbers starting from IRQ_USER.
134  */
135 void __init m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
136                                       void (*handler)(unsigned int, struct pt_regs *))
137 {
138         int i;
139
140         BUG_ON(IRQ_USER + cnt > NR_IRQS);
141         m68k_first_user_vec = vec;
142         for (i = 0; i < cnt; i++)
143                 irq_set_chip(IRQ_USER + i, &user_irq_chip);
144         *user_irqvec_fixup = vec - IRQ_USER;
145         if (handler)
146                 *user_irqhandler_fixup = (u32)handler;
147         flush_icache();
148 }
149
150 /**
151  * m68k_setup_irq_chip
152  * @contr: irq controller which controls specified irq
153  * @irq: first irq to be managed by the controller
154  *
155  * Change the controller for the specified range of irq, which will be used to
156  * manage these irq. auto/user irq already have a default controller, which can
157  * be changed as well, but the controller probably should use m68k_irq_startup/
158  * m68k_irq_shutdown.
159  */
160 void m68k_setup_irq_chip(struct irq_chip *contr, unsigned int irq,
161                                unsigned int cnt)
162 {
163         int i;
164
165         for (i = 0; i < cnt; i++)
166                 irq_set_chip(irq + i, contr);
167 }
168
169 struct irq_data *new_irq_node(void)
170 {
171         struct irq_data *node;
172         short i;
173
174         for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--) {
175                 if (!node->handler) {
176                         memset(node, 0, sizeof(*node));
177                         return node;
178                 }
179         }
180
181         printk ("new_irq_node: out of nodes\n");
182         return NULL;
183 }
184
185 static int m68k_setup_irq(unsigned int irq, struct irq_data *node)
186 {
187         struct irq_chip *contr;
188         struct irq_data **prev;
189         unsigned long flags;
190
191         if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
192                 printk("%s: Incorrect IRQ %d from %s\n",
193                        __func__, irq, node->devname);
194                 return -ENXIO;
195         }
196
197         local_irq_save(flags);
198
199         prev = irq_list + irq;
200         if (*prev) {
201                 /* Can't share interrupts unless both agree to */
202                 if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
203                         local_irq_restore(flags);
204                         return -EBUSY;
205                 }
206                 while (*prev)
207                         prev = &(*prev)->next;
208         }
209
210         if (!irq_list[irq]) {
211                 if (contr->irq_startup)
212                         contr->irq_startup(node);
213                 else
214                         contr->irq_enable(node);
215         }
216         node->next = NULL;
217         *prev = node;
218
219         local_irq_restore(flags);
220
221         return 0;
222 }
223
224 int request_irq(unsigned int irq,
225                 irq_handler_t handler,
226                 unsigned long flags, const char *devname, void *dev_id)
227 {
228         struct irq_data *node;
229         int res;
230
231         node = new_irq_node();
232         if (!node)
233                 return -ENOMEM;
234
235         node->irq     = irq;
236         node->handler = handler;
237         node->flags   = flags;
238         node->dev_id  = dev_id;
239         node->devname = devname;
240
241         res = m68k_setup_irq(irq, node);
242         if (res)
243                 node->handler = NULL;
244
245         return res;
246 }
247
248 EXPORT_SYMBOL(request_irq);
249
250 void free_irq(unsigned int irq, void *dev_id)
251 {
252         struct irq_chip *contr;
253         struct irq_data **p, *node;
254         unsigned long flags;
255
256         if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
257                 printk("%s: Incorrect IRQ %d\n", __func__, irq);
258                 return;
259         }
260
261         local_irq_save(flags);
262
263         p = irq_list + irq;
264         while ((node = *p)) {
265                 if (node->dev_id == dev_id)
266                         break;
267                 p = &node->next;
268         }
269
270         if (node) {
271                 *p = node->next;
272                 node->handler = NULL;
273         } else
274                 printk("%s: Removing probably wrong IRQ %d\n",
275                        __func__, irq);
276
277         if (!irq_list[irq]) {
278                 if (contr->irq_shutdown)
279                         contr->irq_shutdown(node);
280                 else
281                         contr->irq_disable(node);
282         }
283
284         local_irq_restore(flags);
285 }
286
287 EXPORT_SYMBOL(free_irq);
288
289 void enable_irq(unsigned int irq)
290 {
291         struct irq_chip *contr;
292         unsigned long flags;
293
294         if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
295                 printk("%s: Incorrect IRQ %d\n",
296                        __func__, irq);
297                 return;
298         }
299
300         local_irq_save(flags);
301         if (irq_depth[irq]) {
302                 if (!--irq_depth[irq]) {
303                         if (contr->irq_enable)
304                                 contr->irq_enable(irq_list[irq]);
305                 }
306         } else
307                 WARN_ON(1);
308         local_irq_restore(flags);
309 }
310
311 EXPORT_SYMBOL(enable_irq);
312
313 void disable_irq(unsigned int irq)
314 {
315         struct irq_chip *contr;
316         unsigned long flags;
317
318         if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
319                 printk("%s: Incorrect IRQ %d\n",
320                        __func__, irq);
321                 return;
322         }
323
324         local_irq_save(flags);
325         if (!irq_depth[irq]++) {
326                 if (contr->irq_disable)
327                         contr->irq_disable(irq_list[irq]);
328         }
329         local_irq_restore(flags);
330 }
331
332 EXPORT_SYMBOL(disable_irq);
333
334 void disable_irq_nosync(unsigned int irq) __attribute__((alias("disable_irq")));
335
336 EXPORT_SYMBOL(disable_irq_nosync);
337
338 unsigned int m68k_irq_startup_irq(unsigned int irq)
339 {
340         if (irq <= IRQ_AUTO_7)
341                 vectors[VEC_SPUR + irq] = auto_inthandler;
342         else
343                 vectors[m68k_first_user_vec + irq - IRQ_USER] = user_inthandler;
344         return 0;
345 }
346
347 unsigned int m68k_irq_startup(struct irq_data *data)
348 {
349         return m68k_irq_startup_irq(data->irq);
350 }
351
352 void m68k_irq_shutdown(struct irq_data *data)
353 {
354         unsigned int irq = data->irq;
355
356         if (irq <= IRQ_AUTO_7)
357                 vectors[VEC_SPUR + irq] = bad_inthandler;
358         else
359                 vectors[m68k_first_user_vec + irq - IRQ_USER] = bad_inthandler;
360 }
361
362
363 /*
364  * Do we need these probe functions on the m68k?
365  *
366  *  ... may be useful with ISA devices
367  */
368 unsigned long probe_irq_on (void)
369 {
370 #ifdef CONFIG_Q40
371         if (MACH_IS_Q40)
372                 return q40_probe_irq_on();
373 #endif
374         return 0;
375 }
376
377 EXPORT_SYMBOL(probe_irq_on);
378
379 int probe_irq_off (unsigned long irqs)
380 {
381 #ifdef CONFIG_Q40
382         if (MACH_IS_Q40)
383                 return q40_probe_irq_off(irqs);
384 #endif
385         return 0;
386 }
387
388 EXPORT_SYMBOL(probe_irq_off);
389
390 unsigned int irq_canonicalize(unsigned int irq)
391 {
392 #ifdef CONFIG_Q40
393         if (MACH_IS_Q40 && irq == 11)
394                 irq = 10;
395 #endif
396         return irq;
397 }
398
399 EXPORT_SYMBOL(irq_canonicalize);
400
401 void generic_handle_irq(unsigned int irq)
402 {
403         struct irq_data *node;
404         kstat_cpu(0).irqs[irq]++;
405         node = irq_list[irq];
406         do {
407                 node->handler(irq, node->dev_id);
408                 node = node->next;
409         } while (node);
410 }
411
412 asmlinkage void do_IRQ(int irq, struct pt_regs *regs)
413 {
414         struct pt_regs *old_regs;
415         old_regs = set_irq_regs(regs);
416         generic_handle_irq(irq);
417         set_irq_regs(old_regs);
418 }
419
420 asmlinkage void handle_badint(struct pt_regs *regs)
421 {
422         kstat_cpu(0).irqs[0]++;
423         printk("unexpected interrupt from %u\n", regs->vector);
424 }
425
426 int show_interrupts(struct seq_file *p, void *v)
427 {
428         struct irq_chip *contr;
429         struct irq_data *node;
430         int i = *(loff_t *) v;
431
432         /* autovector interrupts */
433         if (irq_list[i]) {
434                 contr = irq_chip[i];
435                 node = irq_list[i];
436                 seq_printf(p, "%-8s %3u: %10u %s", contr->name, i, kstat_cpu(0).irqs[i], node->devname);
437                 while ((node = node->next))
438                         seq_printf(p, ", %s", node->devname);
439                 seq_puts(p, "\n");
440         }
441         return 0;
442 }
443
444 #ifdef CONFIG_PROC_FS
445 void init_irq_proc(void)
446 {
447         /* Insert /proc/irq driver here */
448 }
449 #endif