[linux-2.6-block.git] / arch / mips / kernel / irq.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Code to handle x86 style IRQs plus some generic interrupt stuff.
 *
 * Copyright (C) 1992 Linus Torvalds
 * Copyright (C) 1994 - 2000 Ralf Baechle
 */
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/kallsyms.h>
#include <linux/kgdb.h>
#include <linux/ftrace.h>

#include <asm/atomic.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#ifdef CONFIG_KGDB
int kgdb_early_setup;
#endif

static unsigned long irq_map[NR_IRQS / BITS_PER_LONG];

int allocate_irqno(void)
{
	int irq;

again:
	irq = find_first_zero_bit(irq_map, NR_IRQS);

	if (irq >= NR_IRQS)
		return -ENOSPC;

	if (test_and_set_bit(irq, irq_map))
		goto again;

	return irq;
}

/*
 * Allocate the 16 legacy interrupts for i8259 devices.  This happens early
 * in the kernel initialization so treating allocation failure as BUG() is
 * ok.
 */
void __init alloc_legacy_irqno(void)
{
	int i;

	for (i = 0; i <= 16; i++)
		BUG_ON(test_and_set_bit(i, irq_map));
}

void free_irqno(unsigned int irq)
{
	smp_mb__before_clear_bit();
	clear_bit(irq, irq_map);
	smp_mb__after_clear_bit();
}

/*
 * 'what should we do if we get a hw irq event on an illegal vector'.
 * each architecture has to answer this themselves.
 */
void ack_bad_irq(unsigned int irq)
{
	smtc_im_ack_irq(irq);
	printk("unexpected IRQ # %d\n", irq);
}

atomic_t irq_err_count;

/*
 * Generic, controller-independent functions:
 */

int show_interrupts(struct seq_file *p, void *v)
{
	int i = *(loff_t *) v, j;
	struct irqaction * action;
	unsigned long flags;

	if (i == 0) {
		seq_printf(p, "           ");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%d       ", j);
		seq_putc(p, '\n');
	}

	if (i < NR_IRQS) {
		raw_spin_lock_irqsave(&irq_desc[i].lock, flags);
		action = irq_desc[i].action;
		if (!action)
			goto skip;
		seq_printf(p, "%3d: ", i);
#ifndef CONFIG_SMP
		seq_printf(p, "%10u ", kstat_irqs(i));
#else
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
#endif
		seq_printf(p, " %14s", irq_desc[i].chip->name);
		seq_printf(p, "  %s", action->name);

		for (action=action->next; action; action = action->next)
			seq_printf(p, ", %s", action->name);

		seq_putc(p, '\n');
skip:
		raw_spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	} else if (i == NR_IRQS) {
		seq_putc(p, '\n');
		seq_printf(p, "ERR: %10u\n", atomic_read(&irq_err_count));
	}
	return 0;
}

asmlinkage void spurious_interrupt(void)
{
	atomic_inc(&irq_err_count);
}

void __init init_IRQ(void)
{
	int i;

#ifdef CONFIG_KGDB
	if (kgdb_early_setup)
		return;
#endif

	for (i = 0; i < NR_IRQS; i++)
		set_irq_noprobe(i);

	arch_init_irq();

#ifdef CONFIG_KGDB
	if (!kgdb_early_setup)
		kgdb_early_setup = 1;
#endif
}

/*
 * do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
 */
void __irq_entry do_IRQ(unsigned int irq)
{
	irq_enter();
	__DO_IRQ_SMTC_HOOK(irq);
	generic_handle_irq(irq);
	irq_exit();
}

#ifdef CONFIG_MIPS_MT_SMTC_IRQAFF
/*
 * To avoid inefficient and in some cases pathological re-checking of
 * IRQ affinity, we have this variant that skips the affinity check.
 */

void __irq_entry do_IRQ_no_affinity(unsigned int irq)
{
	irq_enter();
	__NO_AFFINITY_IRQ_SMTC_HOOK(irq);
	generic_handle_irq(irq);
	irq_exit();
}

#endif /* CONFIG_MIPS_MT_SMTC_IRQAFF */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Code to handle x86 style IRQs plus some generic interrupt stuff.
	7	*
	8	* Copyright (C) 1992 Linus Torvalds
	9	* Copyright (C) 1994 - 2000 Ralf Baechle
	10	*/
1da177e4 LT	11	#include <linux/kernel.h>
	12	#include <linux/delay.h>
	13	#include <linux/init.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/kernel_stat.h>
	16	#include <linux/module.h>
	17	#include <linux/proc_fs.h>
	18	#include <linux/slab.h>
	19	#include <linux/mm.h>
	20	#include <linux/random.h>
	21	#include <linux/sched.h>
	22	#include <linux/seq_file.h>
	23	#include <linux/kallsyms.h>
88547001	24	#include <linux/kgdb.h>
8f99a162	25	#include <linux/ftrace.h>
1da177e4 LT	26
	27	#include <asm/atomic.h>
	28	#include <asm/system.h>
	29	#include <asm/uaccess.h>
	30
88547001 JW	31	#ifdef CONFIG_KGDB
	32	int kgdb_early_setup;
	33	#endif
	34
4a4cf779 RB	35	static unsigned long irq_map[NR_IRQS / BITS_PER_LONG];
4a4cf779 RB	36
f543110d	37	int allocate_irqno(void)
4a4cf779 RB	38	{
	39	int irq;
	40
	41	again:
	42	irq = find_first_zero_bit(irq_map, NR_IRQS);
	43
	44	if (irq >= NR_IRQS)
	45	return -ENOSPC;
	46
	47	if (test_and_set_bit(irq, irq_map))
	48	goto again;
	49
	50	return irq;
	51	}
	52
4a4cf779 RB	53	/*
	54	* Allocate the 16 legacy interrupts for i8259 devices. This happens early
	55	* in the kernel initialization so treating allocation failure as BUG() is
	56	* ok.
	57	*/
	58	void __init alloc_legacy_irqno(void)
	59	{
	60	int i;
	61
	62	for (i = 0; i <= 16; i++)
	63	BUG_ON(test_and_set_bit(i, irq_map));
	64	}
	65
f543110d	66	void free_irqno(unsigned int irq)
4a4cf779 RB	67	{
	68	smp_mb__before_clear_bit();
	69	clear_bit(irq, irq_map);
	70	smp_mb__after_clear_bit();
	71	}
	72
1da177e4 LT	73	/*
	74	* 'what should we do if we get a hw irq event on an illegal vector'.
	75	* each architecture has to answer this themselves.
	76	*/
	77	void ack_bad_irq(unsigned int irq)
	78	{
1146fe30	79	smtc_im_ack_irq(irq);
1da177e4 LT	80	printk("unexpected IRQ # %d\n", irq);
	81	}
	82
	83	atomic_t irq_err_count;
	84
1da177e4 LT	85	/*
	86	* Generic, controller-independent functions:
	87	*/
	88
	89	int show_interrupts(struct seq_file p, void v)
	90	{
	91	int i = (loff_t ) v, j;
	92	struct irqaction * action;
	93	unsigned long flags;
	94
	95	if (i == 0) {
	96	seq_printf(p, " ");
394e3902	97	for_each_online_cpu(j)
21a151d8	98	seq_printf(p, "CPU%d ", j);
1da177e4 LT	99	seq_putc(p, '\n');
	100	}
	101
	102	if (i < NR_IRQS) {
239007b8	103	raw_spin_lock_irqsave(&irq_desc[i].lock, flags);
1da177e4	104	action = irq_desc[i].action;
42a3b4f2	105	if (!action)
1da177e4	106	goto skip;
21a151d8	107	seq_printf(p, "%3d: ", i);
1da177e4 LT	108	#ifndef CONFIG_SMP
	109	seq_printf(p, "%10u ", kstat_irqs(i));
	110	#else
394e3902	111	for_each_online_cpu(j)
0b0f0b1c	112	seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
1da177e4	113	#endif
1ccd1c1c	114	seq_printf(p, " %14s", irq_desc[i].chip->name);
1da177e4 LT	115	seq_printf(p, " %s", action->name);
	116
	117	for (action=action->next; action; action = action->next)
	118	seq_printf(p, ", %s", action->name);
	119
	120	seq_putc(p, '\n');
	121	skip:
239007b8	122	raw_spin_unlock_irqrestore(&irq_desc[i].lock, flags);
1da177e4 LT	123	} else if (i == NR_IRQS) {
	124	seq_putc(p, '\n');
	125	seq_printf(p, "ERR: %10u\n", atomic_read(&irq_err_count));
	126	}
	127	return 0;
	128	}
	129
937a8015	130	asmlinkage void spurious_interrupt(void)
93373ed4 RB	131	{
	132	atomic_inc(&irq_err_count);
	133	}
	134
1da177e4 LT	135	void __init init_IRQ(void)
1da177e4 LT	136	{
24649c00 RB	137	int i;
24649c00 RB	138
88547001 JW	139	#ifdef CONFIG_KGDB
	140	if (kgdb_early_setup)
	141	return;
	142	#endif
	143
24649c00 RB	144	for (i = 0; i < NR_IRQS; i++)
	145	set_irq_noprobe(i);
	146
1da177e4	147	arch_init_irq();
88547001 JW	148
	149	#ifdef CONFIG_KGDB
	150	if (!kgdb_early_setup)
	151	kgdb_early_setup = 1;
	152	#endif
1da177e4	153	}
8f99a162 WZ	154
	155	/*
	156	* do_IRQ handles all normal device IRQ's (the special
	157	* SMP cross-CPU interrupts have their own specific
	158	* handlers).
	159	*/
	160	void __irq_entry do_IRQ(unsigned int irq)
	161	{
	162	irq_enter();
	163	__DO_IRQ_SMTC_HOOK(irq);
	164	generic_handle_irq(irq);
	165	irq_exit();
	166	}
	167
	168	#ifdef CONFIG_MIPS_MT_SMTC_IRQAFF
	169	/*
	170	* To avoid inefficient and in some cases pathological re-checking of
	171	* IRQ affinity, we have this variant that skips the affinity check.
	172	*/
	173
	174	void __irq_entry do_IRQ_no_affinity(unsigned int irq)
	175	{
	176	irq_enter();
	177	__NO_AFFINITY_IRQ_SMTC_HOOK(irq);
	178	generic_handle_irq(irq);
	179	irq_exit();
	180	}
	181
	182	#endif /* CONFIG_MIPS_MT_SMTC_IRQAFF */