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
49extern u32 auto_irqhandler_fixup[];
50extern u32 user_irqhandler_fixup[];
51extern u16 user_irqvec_fixup[];
52
53/* table for system interrupt handlers */
54static struct irq_node *irq_list[NR_IRQS];
55static struct irq_controller *irq_controller[NR_IRQS];
56static int irq_depth[NR_IRQS];
57
58static int m68k_first_user_vec;
59
60static struct irq_controller auto_irq_controller = {
61	.name		= "auto",
62	.lock		= __SPIN_LOCK_UNLOCKED(auto_irq_controller.lock),
63	.startup	= m68k_irq_startup,
64	.shutdown	= m68k_irq_shutdown,
65};
66
67static struct irq_controller user_irq_controller = {
68	.name		= "user",
69	.lock		= __SPIN_LOCK_UNLOCKED(user_irq_controller.lock),
70	.startup	= m68k_irq_startup,
71	.shutdown	= m68k_irq_shutdown,
72};
73
74#define NUM_IRQ_NODES 100
75static irq_node_t nodes[NUM_IRQ_NODES];
76
77/*
78 * void init_IRQ(void)
79 *
80 * Parameters:	None
81 *
82 * Returns:	Nothing
83 *
84 * This function should be called during kernel startup to initialize
85 * the IRQ handling routines.
86 */
87
88void __init init_IRQ(void)
89{
90	int i;
91
92	/* assembly irq entry code relies on this... */
93	if (HARDIRQ_MASK != 0x00ff0000) {
94		extern void hardirq_mask_is_broken(void);
95		hardirq_mask_is_broken();
96	}
97
98	for (i = IRQ_AUTO_1; i <= IRQ_AUTO_7; i++)
99		irq_controller[i] = &auto_irq_controller;
100
101	mach_init_IRQ();
102}
103
104/**
105 * m68k_setup_auto_interrupt
106 * @handler: called from auto vector interrupts
107 *
108 * setup the handler to be called from auto vector interrupts instead of the
109 * standard __m68k_handle_int(), it will be called with irq numbers in the range
110 * from IRQ_AUTO_1 - IRQ_AUTO_7.
111 */
112void __init m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *))
113{
114	if (handler)
115		*auto_irqhandler_fixup = (u32)handler;
116	flush_icache();
117}
118
119/**
120 * m68k_setup_user_interrupt
121 * @vec: first user vector interrupt to handle
122 * @cnt: number of active user vector interrupts
123 * @handler: called from user vector interrupts
124 *
125 * setup user vector interrupts, this includes activating the specified range
126 * of interrupts, only then these interrupts can be requested (note: this is
127 * different from auto vector interrupts). An optional handler can be installed
128 * to be called instead of the default __m68k_handle_int(), it will be called
129 * with irq numbers starting from IRQ_USER.
130 */
131void __init m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
132				      void (*handler)(unsigned int, struct pt_regs *))
133{
134	int i;
135
136	BUG_ON(IRQ_USER + cnt >= NR_IRQS);
137	m68k_first_user_vec = vec;
138	for (i = 0; i < cnt; i++)
139		irq_controller[IRQ_USER + i] = &user_irq_controller;
140	*user_irqvec_fixup = vec - IRQ_USER;
141	if (handler)
142		*user_irqhandler_fixup = (u32)handler;
143	flush_icache();
144}
145
146/**
147 * m68k_setup_irq_controller
148 * @contr: irq controller which controls specified irq
149 * @irq: first irq to be managed by the controller
150 *
151 * Change the controller for the specified range of irq, which will be used to
152 * manage these irq. auto/user irq already have a default controller, which can
153 * be changed as well, but the controller probably should use m68k_irq_startup/
154 * m68k_irq_shutdown.
155 */
156void m68k_setup_irq_controller(struct irq_controller *contr, unsigned int irq,
157			       unsigned int cnt)
158{
159	int i;
160
161	for (i = 0; i < cnt; i++)
162		irq_controller[irq + i] = contr;
163}
164
165irq_node_t *new_irq_node(void)
166{
167	irq_node_t *node;
168	short i;
169
170	for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--) {
171		if (!node->handler) {
172			memset(node, 0, sizeof(*node));
173			return node;
174		}
175	}
176
177	printk ("new_irq_node: out of nodes\n");
178	return NULL;
179}
180
181int setup_irq(unsigned int irq, struct irq_node *node)
182{
183	struct irq_controller *contr;
184	struct irq_node **prev;
185	unsigned long flags;
186
187	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
188		printk("%s: Incorrect IRQ %d from %s\n",
189		       __FUNCTION__, irq, node->devname);
190		return -ENXIO;
191	}
192
193	spin_lock_irqsave(&contr->lock, flags);
194
195	prev = irq_list + irq;
196	if (*prev) {
197		/* Can't share interrupts unless both agree to */
198		if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
199			spin_unlock_irqrestore(&contr->lock, flags);
200			return -EBUSY;
201		}
202		while (*prev)
203			prev = &(*prev)->next;
204	}
205
206	if (!irq_list[irq]) {
207		if (contr->startup)
208			contr->startup(irq);
209		else
210			contr->enable(irq);
211	}
212	node->next = NULL;
213	*prev = node;
214
215	spin_unlock_irqrestore(&contr->lock, flags);
216
217	return 0;
218}
219
220int request_irq(unsigned int irq,
221		irq_handler_t handler,
222		unsigned long flags, const char *devname, void *dev_id)
223{
224	struct irq_node *node;
225	int res;
226
227	node = new_irq_node();
228	if (!node)
229		return -ENOMEM;
230
231	node->handler = handler;
232	node->flags   = flags;
233	node->dev_id  = dev_id;
234	node->devname = devname;
235
236	res = setup_irq(irq, node);
237	if (res)
238		node->handler = NULL;
239
240	return res;
241}
242
243EXPORT_SYMBOL(request_irq);
244
245void free_irq(unsigned int irq, void *dev_id)
246{
247	struct irq_controller *contr;
248	struct irq_node **p, *node;
249	unsigned long flags;
250
251	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
252		printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
253		return;
254	}
255
256	spin_lock_irqsave(&contr->lock, flags);
257
258	p = irq_list + irq;
259	while ((node = *p)) {
260		if (node->dev_id == dev_id)
261			break;
262		p = &node->next;
263	}
264
265	if (node) {
266		*p = node->next;
267		node->handler = NULL;
268	} else
269		printk("%s: Removing probably wrong IRQ %d\n",
270		       __FUNCTION__, irq);
271
272	if (!irq_list[irq]) {
273		if (contr->shutdown)
274			contr->shutdown(irq);
275		else
276			contr->disable(irq);
277	}
278
279	spin_unlock_irqrestore(&contr->lock, flags);
280}
281
282EXPORT_SYMBOL(free_irq);
283
284void enable_irq(unsigned int irq)
285{
286	struct irq_controller *contr;
287	unsigned long flags;
288
289	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
290		printk("%s: Incorrect IRQ %d\n",
291		       __FUNCTION__, irq);
292		return;
293	}
294
295	spin_lock_irqsave(&contr->lock, flags);
296	if (irq_depth[irq]) {
297		if (!--irq_depth[irq]) {
298			if (contr->enable)
299				contr->enable(irq);
300		}
301	} else
302		WARN_ON(1);
303	spin_unlock_irqrestore(&contr->lock, flags);
304}
305
306EXPORT_SYMBOL(enable_irq);
307
308void disable_irq(unsigned int irq)
309{
310	struct irq_controller *contr;
311	unsigned long flags;
312
313	if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
314		printk("%s: Incorrect IRQ %d\n",
315		       __FUNCTION__, irq);
316		return;
317	}
318
319	spin_lock_irqsave(&contr->lock, flags);
320	if (!irq_depth[irq]++) {
321		if (contr->disable)
322			contr->disable(irq);
323	}
324	spin_unlock_irqrestore(&contr->lock, flags);
325}
326
327EXPORT_SYMBOL(disable_irq);
328
329int m68k_irq_startup(unsigned int irq)
330{
331	if (irq <= IRQ_AUTO_7)
332		vectors[VEC_SPUR + irq] = auto_inthandler;
333	else
334		vectors[m68k_first_user_vec + irq - IRQ_USER] = user_inthandler;
335	return 0;
336}
337
338void m68k_irq_shutdown(unsigned int irq)
339{
340	if (irq <= IRQ_AUTO_7)
341		vectors[VEC_SPUR + irq] = bad_inthandler;
342	else
343		vectors[m68k_first_user_vec + irq - IRQ_USER] = bad_inthandler;
344}
345
346
347/*
348 * Do we need these probe functions on the m68k?
349 *
350 *  ... may be useful with ISA devices
351 */
352unsigned long probe_irq_on (void)
353{
354#ifdef CONFIG_Q40
355	if (MACH_IS_Q40)
356		return q40_probe_irq_on();
357#endif
358	return 0;
359}
360
361EXPORT_SYMBOL(probe_irq_on);
362
363int probe_irq_off (unsigned long irqs)
364{
365#ifdef CONFIG_Q40
366	if (MACH_IS_Q40)
367		return q40_probe_irq_off(irqs);
368#endif
369	return 0;
370}
371
372EXPORT_SYMBOL(probe_irq_off);
373
374unsigned int irq_canonicalize(unsigned int irq)
375{
376#ifdef CONFIG_Q40
377	if (MACH_IS_Q40 && irq == 11)
378		irq = 10;
379#endif
380	return irq;
381}
382
383EXPORT_SYMBOL(irq_canonicalize);
384
385asmlinkage void m68k_handle_int(unsigned int irq)
386{
387	struct irq_node *node;
388	kstat_cpu(0).irqs[irq]++;
389	node = irq_list[irq];
390	do {
391		node->handler(irq, node->dev_id);
392		node = node->next;
393	} while (node);
394}
395
396asmlinkage void __m68k_handle_int(unsigned int irq, struct pt_regs *regs)
397{
398	struct pt_regs *old_regs;
399	old_regs = set_irq_regs(regs);
400	m68k_handle_int(irq);
401	set_irq_regs(old_regs);
402}
403
404asmlinkage void handle_badint(struct pt_regs *regs)
405{
406	kstat_cpu(0).irqs[0]++;
407	printk("unexpected interrupt from %u\n", regs->vector);
408}
409
410int show_interrupts(struct seq_file *p, void *v)
411{
412	struct irq_controller *contr;
413	struct irq_node *node;
414	int i = *(loff_t *) v;
415
416	/* autovector interrupts */
417	if (irq_list[i]) {
418		contr = irq_controller[i];
419		node = irq_list[i];
420		seq_printf(p, "%-8s %3u: %10u %s", contr->name, i, kstat_cpu(0).irqs[i], node->devname);
421		while ((node = node->next))
422			seq_printf(p, ", %s", node->devname);
423		seq_puts(p, "\n");
424	}
425	return 0;
426}
427
428void init_irq_proc(void)
429{
430	/* Insert /proc/irq driver here */
431}
432