[deliverable/linux.git] / arch / x86_64 / kernel / irq.c

/*
 *	linux/arch/x86_64/kernel/irq.c
 *
 *	Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
 *
 * This file contains the lowest level x86_64-specific interrupt
 * entry and irq statistics code. All the remaining irq logic is
 * done by the generic kernel/irq/ code and in the
 * x86_64-specific irq controller code. (e.g. i8259.c and
 * io_apic.c.)
 */

#include <linux/kernel_stat.h>
#include <linux/interrupt.h>
#include <linux/seq_file.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/io_apic.h>
#include <asm/idle.h>

atomic_t irq_err_count;
#ifdef CONFIG_X86_IO_APIC
#ifdef APIC_MISMATCH_DEBUG
atomic_t irq_mis_count;
#endif
#endif

/*
 * 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%-8d",j);
		seq_putc(p, '\n');
	}

	if (i < NR_IRQS) {
		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_cpu(j).irqs[i]);
#endif
		seq_printf(p, " %14s", irq_desc[i].handler->typename);

		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:
		spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	} else if (i == NR_IRQS) {
		seq_printf(p, "NMI: ");
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", cpu_pda(j)->__nmi_count);
		seq_putc(p, '\n');
#ifdef CONFIG_X86_LOCAL_APIC
		seq_printf(p, "LOC: ");
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", cpu_pda(j)->apic_timer_irqs);
		seq_putc(p, '\n');
#endif
		seq_printf(p, "ERR: %10u\n", atomic_read(&irq_err_count));
#ifdef CONFIG_X86_IO_APIC
#ifdef APIC_MISMATCH_DEBUG
		seq_printf(p, "MIS: %10u\n", atomic_read(&irq_mis_count));
#endif
#endif
	}
	return 0;
}

/*
 * do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
 */
asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
{	
	/* high bits used in ret_from_ code  */
	unsigned irq = regs->orig_rax & 0xff;

	exit_idle();
	irq_enter();

	__do_IRQ(irq, regs);
	irq_exit();

	return 1;
}

#ifdef CONFIG_HOTPLUG_CPU
void fixup_irqs(cpumask_t map)
{
	unsigned int irq;
	static int warned;

	for (irq = 0; irq < NR_IRQS; irq++) {
		cpumask_t mask;
		if (irq == 2)
			continue;

		cpus_and(mask, irq_affinity[irq], map);
		if (any_online_cpu(mask) == NR_CPUS) {
			printk("Breaking affinity for irq %i\n", irq);
			mask = map;
		}
		if (irq_desc[irq].handler->set_affinity)
			irq_desc[irq].handler->set_affinity(irq, mask);
		else if (irq_desc[irq].action && !(warned++))
			printk("Cannot set affinity for irq %i\n", irq);
	}

	/* That doesn't seem sufficient.  Give it 1ms. */
	local_irq_enable();
	mdelay(1);
	local_irq_disable();
}
#endif

extern void call_softirq(void);

asmlinkage void do_softirq(void)
{
 	__u32 pending;
 	unsigned long flags;

 	if (in_interrupt())
 		return;

 	local_irq_save(flags);
 	pending = local_softirq_pending();
 	/* Switch to interrupt stack */
 	if (pending)
		call_softirq();
 	local_irq_restore(flags);
}
EXPORT_SYMBOL(do_softirq);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/x86_64/kernel/irq.c
	3	*
	4	* Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
	5	*
	6	* This file contains the lowest level x86_64-specific interrupt
	7	* entry and irq statistics code. All the remaining irq logic is
	8	* done by the generic kernel/irq/ code and in the
	9	* x86_64-specific irq controller code. (e.g. i8259.c and
	10	* io_apic.c.)
	11	*/
	12
	13	#include <linux/kernel_stat.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/seq_file.h>
	16	#include <linux/module.h>
76e4f660	17	#include <linux/delay.h>
1da177e4 LT	18	#include <asm/uaccess.h>
1da177e4 LT	19	#include <asm/io_apic.h>
95833c83	20	#include <asm/idle.h>
1da177e4 LT	21
	22	atomic_t irq_err_count;
	23	#ifdef CONFIG_X86_IO_APIC
	24	#ifdef APIC_MISMATCH_DEBUG
	25	atomic_t irq_mis_count;
	26	#endif
	27	#endif
	28
	29	/*
	30	* Generic, controller-independent functions:
	31	*/
	32
	33	int show_interrupts(struct seq_file p, void v)
	34	{
	35	int i = (loff_t ) v, j;
	36	struct irqaction * action;
	37	unsigned long flags;
	38
	39	if (i == 0) {
	40	seq_printf(p, " ");
394e3902	41	for_each_online_cpu(j)
bdbdaa79	42	seq_printf(p, "CPU%-8d",j);
1da177e4 LT	43	seq_putc(p, '\n');
	44	}
	45
	46	if (i < NR_IRQS) {
	47	spin_lock_irqsave(&irq_desc[i].lock, flags);
	48	action = irq_desc[i].action;
	49	if (!action)
	50	goto skip;
	51	seq_printf(p, "%3d: ",i);
	52	#ifndef CONFIG_SMP
	53	seq_printf(p, "%10u ", kstat_irqs(i));
	54	#else
394e3902 AM	55	for_each_online_cpu(j)
394e3902 AM	56	seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
1da177e4 LT	57	#endif
	58	seq_printf(p, " %14s", irq_desc[i].handler->typename);
	59
	60	seq_printf(p, " %s", action->name);
	61	for (action=action->next; action; action = action->next)
	62	seq_printf(p, ", %s", action->name);
	63	seq_putc(p, '\n');
	64	skip:
	65	spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	66	} else if (i == NR_IRQS) {
	67	seq_printf(p, "NMI: ");
394e3902 AM	68	for_each_online_cpu(j)
394e3902 AM	69	seq_printf(p, "%10u ", cpu_pda(j)->__nmi_count);
1da177e4 LT	70	seq_putc(p, '\n');
	71	#ifdef CONFIG_X86_LOCAL_APIC
	72	seq_printf(p, "LOC: ");
394e3902 AM	73	for_each_online_cpu(j)
394e3902 AM	74	seq_printf(p, "%10u ", cpu_pda(j)->apic_timer_irqs);
1da177e4 LT	75	seq_putc(p, '\n');
	76	#endif
	77	seq_printf(p, "ERR: %10u\n", atomic_read(&irq_err_count));
	78	#ifdef CONFIG_X86_IO_APIC
	79	#ifdef APIC_MISMATCH_DEBUG
	80	seq_printf(p, "MIS: %10u\n", atomic_read(&irq_mis_count));
	81	#endif
	82	#endif
	83	}
	84	return 0;
	85	}
	86
	87	/*
	88	* do_IRQ handles all normal device IRQ's (the special
	89	* SMP cross-CPU interrupts have their own specific
	90	* handlers).
	91	*/
	92	asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
	93	{
	94	/* high bits used in ret_from_ code */
	95	unsigned irq = regs->orig_rax & 0xff;
	96
95833c83	97	exit_idle();
1da177e4	98	irq_enter();
1da177e4 LT	99
	100	__do_IRQ(irq, regs);
	101	irq_exit();
	102
	103	return 1;
	104	}
	105
76e4f660 AR	106	#ifdef CONFIG_HOTPLUG_CPU
	107	void fixup_irqs(cpumask_t map)
	108	{
	109	unsigned int irq;
	110	static int warned;
	111
	112	for (irq = 0; irq < NR_IRQS; irq++) {
	113	cpumask_t mask;
	114	if (irq == 2)
	115	continue;
	116
	117	cpus_and(mask, irq_affinity[irq], map);
	118	if (any_online_cpu(mask) == NR_CPUS) {
	119	printk("Breaking affinity for irq %i\n", irq);
	120	mask = map;
	121	}
	122	if (irq_desc[irq].handler->set_affinity)
	123	irq_desc[irq].handler->set_affinity(irq, mask);
	124	else if (irq_desc[irq].action && !(warned++))
	125	printk("Cannot set affinity for irq %i\n", irq);
	126	}
	127
	128	/* That doesn't seem sufficient. Give it 1ms. */
	129	local_irq_enable();
	130	mdelay(1);
	131	local_irq_disable();
	132	}
	133	#endif
ed6b676c AK	134
	135	extern void call_softirq(void);
	136
	137	asmlinkage void do_softirq(void)
	138	{
	139	__u32 pending;
	140	unsigned long flags;
	141
	142	if (in_interrupt())
	143	return;
	144
	145	local_irq_save(flags);
	146	pending = local_softirq_pending();
	147	/* Switch to interrupt stack */
	148	if (pending)
	149	call_softirq();
	150	local_irq_restore(flags);
	151	}
	152	EXPORT_SYMBOL(do_softirq);