arch/sh/kernel/irq.c - third_party/linux - Git at Google

 /* $Id: irq.c,v 1.20 2004/01/13 05:52:11 kkojima Exp $
  *
  * linux/arch/sh/kernel/irq.c
  *
  *	Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
  *
  *
  * SuperH version:  Copyright (C) 1999  Niibe Yutaka
  */

 /*
  * IRQs are in fact implemented a bit like signal handlers for the kernel.
  * Naturally it's not a 1:1 relation, but there are similarities.
  */

 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/ptrace.h>
 #include <linux/errno.h>
 #include <linux/kernel_stat.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/interrupt.h>
 #include <linux/timex.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/random.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/seq_file.h>
 #include <linux/kallsyms.h>
 #include <linux/bitops.h>

 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/pgalloc.h>
 #include <asm/delay.h>
 #include <asm/irq.h>
 #include <linux/irq.h>

 /*
  * Controller mappings for all interrupt sources:
  */
 irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned = {
 	[0 ... NR_IRQS-1] = {
 		.handler = &no_irq_type,
 		.lock = SPIN_LOCK_UNLOCKED
 	}
 };

 /*
  * Special irq handlers.
  */

 irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs)
 { return IRQ_NONE; }

 /*
  * Generic no controller code
  */

 static void enable_none(unsigned int irq) { }
 static unsigned int startup_none(unsigned int irq) { return 0; }
 static void disable_none(unsigned int irq) { }
 static void ack_none(unsigned int irq)
 {
 /*
  * 'what should we do if we get a hw irq event on an illegal vector'.
  * each architecture has to answer this themselves, it doesn't deserve
  * a generic callback i think.
  */
 	printk("unexpected IRQ trap at vector %02x\n", irq);
 }

 /* startup is the same as "enable", shutdown is same as "disable" */
 #define shutdown_none	disable_none
 #define end_none	enable_none

 struct hw_interrupt_type no_irq_type = {
 	"none",
 	startup_none,
 	shutdown_none,
 	enable_none,
 	disable_none,
 	ack_none,
 	end_none
 };

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

 #if defined(CONFIG_PROC_FS)
 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_puts(p, "           ");
 		for (j=0; j<NR_CPUS; j++)
 			if (cpu_online(j))
 				seq_printf(p, "CPU%d       ",j);
 		seq_putc(p, '\n');
 	}

 	if (i < ACTUAL_NR_IRQS) {
 		spin_lock_irqsave(&irq_desc[i].lock, flags);
 		action = irq_desc[i].action;
 		if (!action)
 			goto unlock;
 		seq_printf(p, "%3d: ",i);
 		seq_printf(p, "%10u ", kstat_irqs(i));
 		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');
 unlock:
 		spin_unlock_irqrestore(&irq_desc[i].lock, flags);
 	}
 	return 0;
 }
 #endif

 /*
  * This should really return information about whether
  * we should do bottom half handling etc. Right now we
  * end up _always_ checking the bottom half, which is a
  * waste of time and is not what some drivers would
  * prefer.
  */
 int handle_IRQ_event(unsigned int irq, struct pt_regs * regs, struct irqaction * action)
 {
 	int status = 1;	/* Force the "do bottom halves" bit */
 	int ret, retval = 0;

 	if (!(action->flags & SA_INTERRUPT))
 		local_irq_enable();

 	do {
 		ret = action->handler(irq, action->dev_id, regs);
 		if (ret == IRQ_HANDLED)
 			status |= action->flags;
 		retval |= ret;
 		action = action->next;
 	} while (action);

 	if (status & SA_SAMPLE_RANDOM)
 		add_interrupt_randomness(irq);

 	local_irq_disable();
 	return retval;
 }

 static void __report_bad_irq(int irq, irq_desc_t *desc, irqreturn_t action_ret)
 {
 	struct irqaction *action;

 	if (action_ret != IRQ_HANDLED && action_ret != IRQ_NONE) {
 		printk(KERN_ERR "irq event %d: bogus return value %x\n",
 				irq, action_ret);
 	} else {
 		printk(KERN_ERR "irq %d: nobody cared!\n", irq);
 	}
 	dump_stack();
 	printk(KERN_ERR "handlers:\n");
 	action = desc->action;
 	do {
 		printk(KERN_ERR "[<%p>]", action->handler);
 		print_symbol(" (%s)",
 			(unsigned long)action->handler);
 		printk("\n");
 		action = action->next;
 	} while (action);
 }

 static void report_bad_irq(int irq, irq_desc_t *desc, irqreturn_t action_ret)
 {
 	static int count = 100;

 	if (count) {
 		count--;
 		__report_bad_irq(irq, desc, action_ret);
 	}
 }

 static int noirqdebug;

 static int __init noirqdebug_setup(char *str)
 {
 	noirqdebug = 1;
 	printk("IRQ lockup detection disabled\n");
 	return 1;
 }

 __setup("noirqdebug", noirqdebug_setup);

 /*
  * If 99,900 of the previous 100,000 interrupts have not been handled then
  * assume that the IRQ is stuck in some manner.  Drop a diagnostic and try to
  * turn the IRQ off.
  *
  * (The other 100-of-100,000 interrupts may have been a correctly-functioning
  *  device sharing an IRQ with the failing one)
  *
  * Called under desc->lock
  */
 static void note_interrupt(int irq, irq_desc_t *desc, irqreturn_t action_ret)
 {
 	if (action_ret != IRQ_HANDLED) {
 		desc->irqs_unhandled++;
 		if (action_ret != IRQ_NONE)
 			report_bad_irq(irq, desc, action_ret);
 	}

 	desc->irq_count++;
 	if (desc->irq_count < 100000)
 		return;

 	desc->irq_count = 0;
 	if (desc->irqs_unhandled > 99900) {
 		/*
 		 * The interrupt is stuck
 		 */
 		__report_bad_irq(irq, desc, action_ret);
 		/*
 		 * Now kill the IRQ
 		 */
 		printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
 		desc->status |= IRQ_DISABLED;
 		desc->handler->disable(irq);
 	}
 	desc->irqs_unhandled = 0;
 }

 /*
  * Generic enable/disable code: this just calls
  * down into the PIC-specific version for the actual
  * hardware disable after having gotten the irq
  * controller lock.
  */
 inline void disable_irq_nosync(unsigned int irq)
 {
 	irq_desc_t *desc = irq_desc + irq;
 	unsigned long flags;

 	spin_lock_irqsave(&desc->lock, flags);
 	if (!desc->depth++) {
 		desc->status |= IRQ_DISABLED;
 		desc->handler->disable(irq);
 	}
 	spin_unlock_irqrestore(&desc->lock, flags);
 }

 /*
  * Synchronous version of the above, making sure the IRQ is
  * no longer running on any other IRQ..
  */
 void disable_irq(unsigned int irq)
 {
 	irq_desc_t *desc = irq_desc + irq;
 	disable_irq_nosync(irq);
 	if (desc->action)
 		synchronize_irq(irq);
 }

 void enable_irq(unsigned int irq)
 {
 	irq_desc_t *desc = irq_desc + irq;
 	unsigned long flags;

 	spin_lock_irqsave(&desc->lock, flags);
 	switch (desc->depth) {
 	case 1: {
 		unsigned int status = desc->status & ~(IRQ_DISABLED | IRQ_INPROGRESS);
 		desc->status = status;
 		if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
 			desc->status = status | IRQ_REPLAY;
 			hw_resend_irq(desc->handler,irq);
 		}
 		desc->handler->enable(irq);
 		/* fall-through */
 	}
 	default:
 		desc->depth--;
 		break;
 	case 0:
 		printk("enable_irq() unbalanced from %p\n",
 		       __builtin_return_address(0));
 	}
 	spin_unlock_irqrestore(&desc->lock, flags);
 }

 /*
  * do_IRQ handles all normal device IRQ's.
  */
 asmlinkage int do_IRQ(unsigned long r4, unsigned long r5,
 		      unsigned long r6, unsigned long r7,
 		      struct pt_regs regs)
 {
 	/*
 	 * We ack quickly, we don't want the irq controller
 	 * thinking we're snobs just because some other CPU has
 	 * disabled global interrupts (we have already done the
 	 * INT_ACK cycles, it's too late to try to pretend to the
 	 * controller that we aren't taking the interrupt).
 	 *
 	 * 0 return value means that this irq is already being
 	 * handled by some other CPU. (or is disabled)
 	 */
 	int irq;
 	irq_desc_t *desc;
 	struct irqaction * action;
 	unsigned int status;

 	irq_enter();

 #ifdef CONFIG_PREEMPT
 	/*
 	 * At this point we're now about to actually call handlers,
 	 * and interrupts might get reenabled during them... bump
 	 * preempt_count to prevent any preemption while the handler
 	 * called here is pending...
 	 */
 	preempt_disable();
 #endif

 	/* Get IRQ number */
 	asm volatile("stc	r2_bank, %0\n\t"
 		     "shlr2	%0\n\t"
 		     "shlr2	%0\n\t"
 		     "shlr	%0\n\t"
 		     "add	#-16, %0\n\t"
 		     :"=z" (irq));
 	irq = irq_demux(irq);

 	kstat_this_cpu.irqs[irq]++;
 	desc = irq_desc + irq;
 	spin_lock(&desc->lock);
 	desc->handler->ack(irq);
 	/*
 	   REPLAY is when Linux resends an IRQ that was dropped earlier
 	   WAITING is used by probe to mark irqs that are being tested
 	   */
 	status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
 	status |= IRQ_PENDING; /* we _want_ to handle it */

 	/*
 	 * If the IRQ is disabled for whatever reason, we cannot
 	 * use the action we have.
 	 */
 	action = NULL;
 	if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
 		action = desc->action;
 		status &= ~IRQ_PENDING; /* we commit to handling */
 		status |= IRQ_INPROGRESS; /* we are handling it */
 	}
 	desc->status = status;

 	/*
 	 * If there is no IRQ handler or it was disabled, exit early.
 	   Since we set PENDING, if another processor is handling
 	   a different instance of this same irq, the other processor
 	   will take care of it.
 	 */
 	if (unlikely(!action))
 		goto out;

 	/*
 	 * Edge triggered interrupts need to remember
 	 * pending events.
 	 * This applies to any hw interrupts that allow a second
 	 * instance of the same irq to arrive while we are in do_IRQ
 	 * or in the handler. But the code here only handles the _second_
 	 * instance of the irq, not the third or fourth. So it is mostly
 	 * useful for irq hardware that does not mask cleanly in an
 	 * SMP environment.
 	 */
 	for (;;) {
 		irqreturn_t action_ret;

 		spin_unlock(&desc->lock);
 		action_ret = handle_IRQ_event(irq, &regs, action);
 		spin_lock(&desc->lock);
 		if (!noirqdebug)
 			note_interrupt(irq, desc, action_ret);
 		if (likely(!(desc->status & IRQ_PENDING)))
 			break;
 		desc->status &= ~IRQ_PENDING;
 	}
 	desc->status &= ~IRQ_INPROGRESS;

 out:
 	/*
 	 * The ->end() handler has to deal with interrupts which got
 	 * disabled while the handler was running.
 	 */
 	desc->handler->end(irq);
 	spin_unlock(&desc->lock);

 	irq_exit();

 #ifdef CONFIG_PREEMPT
 	/*
 	 * We're done with the handlers, interrupts should be
 	 * currently disabled; decrement preempt_count now so
 	 * as we return preemption may be allowed...
 	 */
 	preempt_enable_no_resched();
 #endif

 	return 1;
 }

 int request_irq(unsigned int irq,
 		irqreturn_t (*handler)(int, void *, struct pt_regs *),
 		unsigned long irqflags,
 		const char * devname,
 		void *dev_id)
 {
 	int retval;
 	struct irqaction * action;

 	if (irq >= ACTUAL_NR_IRQS)
 		return -EINVAL;
 	if (!handler)
 		return -EINVAL;

 	action = (struct irqaction *)
 			kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
 	if (!action)
 		return -ENOMEM;

 	action->handler = handler;
 	action->flags = irqflags;
 	cpus_clear(action->mask);
 	action->name = devname;
 	action->next = NULL;
 	action->dev_id = dev_id;

 	retval = setup_irq(irq, action);
 	if (retval)
 		kfree(action);
 	return retval;
 }

 EXPORT_SYMBOL(request_irq);

 void free_irq(unsigned int irq, void *dev_id)
 {
 	irq_desc_t *desc;
 	struct irqaction **p;
 	unsigned long flags;

 	if (irq >= ACTUAL_NR_IRQS)
 		return;

 	desc = irq_desc + irq;
 	spin_lock_irqsave(&desc->lock,flags);
 	p = &desc->action;
 	for (;;) {
 		struct irqaction * action = *p;
 		if (action) {
 			struct irqaction **pp = p;
 			p = &action->next;
 			if (action->dev_id != dev_id)
 				continue;

 			/* Found it - now remove it from the list of entries */
 			*pp = action->next;
 			if (!desc->action) {
 				desc->status |= IRQ_DISABLED;
 				desc->handler->shutdown(irq);
 			}
 			spin_unlock_irqrestore(&desc->lock,flags);
 			synchronize_irq(irq);
 			kfree(action);
 			return;
 		}
 		printk("Trying to free free IRQ%d\n",irq);
 		spin_unlock_irqrestore(&desc->lock,flags);
 		return;
 	}
 }

 EXPORT_SYMBOL(free_irq);

 static DECLARE_MUTEX(probe_sem);

 /*
  * IRQ autodetection code..
  *
  * This depends on the fact that any interrupt that
  * comes in on to an unassigned handler will get stuck
  * with "IRQ_WAITING" cleared and the interrupt
  * disabled.
  */
 unsigned long probe_irq_on(void)
 {
 	unsigned int i;
 	irq_desc_t *desc;
 	unsigned long val;
 	unsigned long delay;

 	down(&probe_sem);
 	/*
 	 * something may have generated an irq long ago and we want to
 	 * flush such a longstanding irq before considering it as spurious.
 	 */
 	for (i = NR_IRQS-1; i > 0; i--) {
 		desc = irq_desc + i;

 		spin_lock_irq(&desc->lock);
 		if (!desc->action)
 			desc->handler->startup(i);
 		spin_unlock_irq(&desc->lock);
 	}

 	/* Wait for longstanding interrupts to trigger. */
 	for (delay = jiffies + HZ/50; time_after(delay, jiffies); )
 		/* about 20ms delay */ barrier();

 	/*
 	 * enable any unassigned irqs
 	 * (we must startup again here because if a longstanding irq
 	 * happened in the previous stage, it may have masked itself)
 	 */
 	for (i = NR_IRQS-1; i > 0; i--) {
 		desc = irq_desc + i;

 		spin_lock_irq(&desc->lock);
 		if (!desc->action) {
 			desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
 			if (desc->handler->startup(i))
 				desc->status |= IRQ_PENDING;
 		}
 		spin_unlock_irq(&desc->lock);
 	}

 	/*
 	 * Wait for spurious interrupts to trigger
 	 */
 	for (delay = jiffies + HZ/10; time_after(delay, jiffies); )
 		/* about 100ms delay */ barrier();

 	/*
 	 * Now filter out any obviously spurious interrupts
 	 */
 	val = 0;
 	for (i=0; i<NR_IRQS; i++) {
 		unsigned int status;

 		desc = irq_desc + i;

 		spin_lock_irq(&desc->lock);
 		status = desc->status;

 		if (status & IRQ_AUTODETECT) {
 			/* It triggered already - consider it spurious. */
 			if (!(status & IRQ_WAITING)) {
 				desc->status = status & ~IRQ_AUTODETECT;
 				desc->handler->shutdown(i);
 			} else
 				if (i < 32)
 					val |= 1 << i;
 		}
 		spin_unlock_irq(&desc->lock);
 	}

 	return val;
 }

 EXPORT_SYMBOL(probe_irq_on);

 /* Return a mask of triggered interrupts (this
  * can handle only legacy ISA interrupts).
  */

 /*
  *	probe_irq_mask - scan a bitmap of interrupt lines
  *	@val:	mask of interrupts to consider
  *
  *	Scan the ISA bus interrupt lines and return a bitmap of
  *	active interrupts. The interrupt probe logic state is then
  *	returned to its previous value.
  *
  *	Note: we need to scan all the irq's even though we will
  *	only return ISA irq numbers - just so that we reset them
  *	all to a known state.
  */
 unsigned int probe_irq_mask(unsigned long val)
 {
 	int i;
 	unsigned int mask;

 	mask = 0;
 	for (i = 0; i < NR_IRQS; i++) {
 		irq_desc_t *desc = irq_desc + i;
 		unsigned int status;

 		spin_lock_irq(&desc->lock);
 		status = desc->status;

 		if (status & IRQ_AUTODETECT) {
 			if (i < 16 && !(status & IRQ_WAITING))
 				mask |= 1 << i;

 			desc->status = status & ~IRQ_AUTODETECT;
 			desc->handler->shutdown(i);
 		}
 		spin_unlock_irq(&desc->lock);
 	}
 	up(&probe_sem);

 	return mask & val;
 }

 int probe_irq_off(unsigned long val)
 {
 	int i, irq_found, nr_irqs;

 	nr_irqs = 0;
 	irq_found = 0;
 	for (i=0; i<NR_IRQS; i++) {
 		irq_desc_t *desc = irq_desc + i;
 		unsigned int status;

 		spin_lock_irq(&desc->lock);
 		status = desc->status;

 		if (status & IRQ_AUTODETECT) {
 			if (!(status & IRQ_WAITING)) {
 				if (!nr_irqs)
 					irq_found = i;
 				nr_irqs++;
 			}
 			desc->status = status & ~IRQ_AUTODETECT;
 			desc->handler->shutdown(i);
 		}
 		spin_unlock_irq(&desc->lock);
 	}
 	up(&probe_sem);

 	if (nr_irqs > 1)
 		irq_found = -irq_found;
 	return irq_found;
 }

 EXPORT_SYMBOL(probe_irq_off);

 int setup_irq(unsigned int irq, struct irqaction * new)
 {
 	int shared = 0;
 	struct irqaction *old, **p;
 	unsigned long flags;
 	irq_desc_t *desc = irq_desc + irq;

 	if (desc->handler == &no_irq_type)
 		return -ENOSYS;
  	/*
 	 * Some drivers like serial.c use request_irq() heavily,
 	 * so we have to be careful not to interfere with a
 	 * running system.
 	 */
 	if (new->flags & SA_SAMPLE_RANDOM) {
 		/*
 		 * This function might sleep, we want to call it first,
 		 * outside of the atomic block.
 		 * Yes, this might clear the entropy pool if the wrong
 		 * driver is attempted to be loaded, without actually
 		 * installing a new handler, but is this really a problem,
 		 * only the sysadmin is able to do this.
 		 */
 		rand_initialize_irq(irq);
 	}

 	/*
 	 * The following block of code has to be executed atomically
 	 */
 	spin_lock_irqsave(&desc->lock,flags);
 	p = &desc->action;
 	if ((old = *p) != NULL) {
 		/* Can't share interrupts unless both agree to */
 		if (!(old->flags & new->flags & SA_SHIRQ)) {
 			spin_unlock_irqrestore(&desc->lock,flags);
 			return -EBUSY;
 		}

 		/* add new interrupt at end of irq queue */
 		do {
 			p = &old->next;
 			old = *p;
 		} while (old);
 		shared = 1;
 	}

 	*p = new;

 	if (!shared) {
 		desc->depth = 0;
 		desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING | IRQ_INPROGRESS);
 		desc->handler->startup(irq);
 	}
 	spin_unlock_irqrestore(&desc->lock,flags);
 	return 0;
 }

 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)

 void init_irq_proc(void)
 {
 }
 #endif

 /* Taken from the 2.5 alpha port */
 #ifdef CONFIG_SMP
 void synchronize_irq(unsigned int irq)
 {
 	/* is there anything to synchronize with? */
 	if (!irq_desc[irq].action)
 		return;

 	while (irq_desc[irq].status & IRQ_INPROGRESS)
 		barrier();
 }
 #endif
	/* $Id: irq.c,v 1.20 2004/01/13 05:52:11 kkojima Exp $
	*
	* linux/arch/sh/kernel/irq.c
	*
	* Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
	*
	*
	* SuperH version: Copyright (C) 1999 Niibe Yutaka
	*/

	/*
	* IRQs are in fact implemented a bit like signal handlers for the kernel.
	* Naturally it's not a 1:1 relation, but there are similarities.
	*/

	#include <linux/config.h>
	#include <linux/module.h>
	#include <linux/ptrace.h>
	#include <linux/errno.h>
	#include <linux/kernel_stat.h>
	#include <linux/signal.h>
	#include <linux/sched.h>
	#include <linux/ioport.h>
	#include <linux/interrupt.h>
	#include <linux/timex.h>
	#include <linux/mm.h>
	#include <linux/slab.h>
	#include <linux/random.h>
	#include <linux/smp.h>
	#include <linux/smp_lock.h>
	#include <linux/init.h>
	#include <linux/seq_file.h>
	#include <linux/kallsyms.h>
	#include <linux/bitops.h>

	#include <asm/system.h>
	#include <asm/io.h>
	#include <asm/pgalloc.h>
	#include <asm/delay.h>
	#include <asm/irq.h>
	#include <linux/irq.h>

	/*
	* Controller mappings for all interrupt sources:
	*/
	irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned = {
	[0 ... NR_IRQS-1] = {
	.handler = &no_irq_type,
	.lock = SPIN_LOCK_UNLOCKED
	}
	};

	/*
	* Special irq handlers.
	*/

	irqreturn_t no_action(int cpl, void dev_id, struct pt_regs regs)
	{ return IRQ_NONE; }

	/*
	* Generic no controller code
	*/

	static void enable_none(unsigned int irq) { }
	static unsigned int startup_none(unsigned int irq) { return 0; }
	static void disable_none(unsigned int irq) { }
	static void ack_none(unsigned int irq)
	{
	/*
	* 'what should we do if we get a hw irq event on an illegal vector'.
	* each architecture has to answer this themselves, it doesn't deserve
	* a generic callback i think.
	*/
	printk("unexpected IRQ trap at vector %02x\n", irq);
	}

	/* startup is the same as "enable", shutdown is same as "disable" */
	#define shutdown_none disable_none
	#define end_none enable_none

	struct hw_interrupt_type no_irq_type = {
	"none",
	startup_none,
	shutdown_none,
	enable_none,
	disable_none,
	ack_none,
	end_none
	};

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

	#if defined(CONFIG_PROC_FS)
	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_puts(p, " ");
	for (j=0; j<NR_CPUS; j++)
	if (cpu_online(j))
	seq_printf(p, "CPU%d ",j);
	seq_putc(p, '\n');
	}

	if (i < ACTUAL_NR_IRQS) {
	spin_lock_irqsave(&irq_desc[i].lock, flags);
	action = irq_desc[i].action;
	if (!action)
	goto unlock;
	seq_printf(p, "%3d: ",i);
	seq_printf(p, "%10u ", kstat_irqs(i));
	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');
	unlock:
	spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	}
	return 0;
	}
	#endif

	/*
	* This should really return information about whether
	* we should do bottom half handling etc. Right now we
	* end up _always_ checking the bottom half, which is a
	* waste of time and is not what some drivers would
	* prefer.
	*/
	int handle_IRQ_event(unsigned int irq, struct pt_regs * regs, struct irqaction * action)
	{
	int status = 1; /* Force the "do bottom halves" bit */
	int ret, retval = 0;

	if (!(action->flags & SA_INTERRUPT))
	local_irq_enable();

	do {
	ret = action->handler(irq, action->dev_id, regs);
	if (ret == IRQ_HANDLED)
	status \|= action->flags;
	retval \|= ret;
	action = action->next;
	} while (action);

	if (status & SA_SAMPLE_RANDOM)
	add_interrupt_randomness(irq);

	local_irq_disable();
	return retval;
	}

	static void __report_bad_irq(int irq, irq_desc_t *desc, irqreturn_t action_ret)
	{
	struct irqaction *action;

	if (action_ret != IRQ_HANDLED && action_ret != IRQ_NONE) {
	printk(KERN_ERR "irq event %d: bogus return value %x\n",
	irq, action_ret);
	} else {
	printk(KERN_ERR "irq %d: nobody cared!\n", irq);
	}
	dump_stack();
	printk(KERN_ERR "handlers:\n");
	action = desc->action;
	do {
	printk(KERN_ERR "[<%p>]", action->handler);
	print_symbol(" (%s)",
	(unsigned long)action->handler);
	printk("\n");
	action = action->next;
	} while (action);
	}

	static void report_bad_irq(int irq, irq_desc_t *desc, irqreturn_t action_ret)
	{
	static int count = 100;

	if (count) {
	count--;
	__report_bad_irq(irq, desc, action_ret);
	}
	}

	static int noirqdebug;

	static int __init noirqdebug_setup(char *str)
	{
	noirqdebug = 1;
	printk("IRQ lockup detection disabled\n");
	return 1;
	}

	__setup("noirqdebug", noirqdebug_setup);

	/*
	* If 99,900 of the previous 100,000 interrupts have not been handled then
	* assume that the IRQ is stuck in some manner. Drop a diagnostic and try to
	* turn the IRQ off.
	*
	* (The other 100-of-100,000 interrupts may have been a correctly-functioning
	* device sharing an IRQ with the failing one)
	*
	* Called under desc->lock
	*/
	static void note_interrupt(int irq, irq_desc_t *desc, irqreturn_t action_ret)
	{
	if (action_ret != IRQ_HANDLED) {
	desc->irqs_unhandled++;
	if (action_ret != IRQ_NONE)
	report_bad_irq(irq, desc, action_ret);
	}

	desc->irq_count++;
	if (desc->irq_count < 100000)
	return;

	desc->irq_count = 0;
	if (desc->irqs_unhandled > 99900) {
	/*
	* The interrupt is stuck
	*/
	__report_bad_irq(irq, desc, action_ret);
	/*
	* Now kill the IRQ
	*/
	printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
	desc->status \|= IRQ_DISABLED;
	desc->handler->disable(irq);
	}
	desc->irqs_unhandled = 0;
	}

	/*
	* Generic enable/disable code: this just calls
	* down into the PIC-specific version for the actual
	* hardware disable after having gotten the irq
	* controller lock.
	*/
	inline void disable_irq_nosync(unsigned int irq)
	{
	irq_desc_t *desc = irq_desc + irq;
	unsigned long flags;

	spin_lock_irqsave(&desc->lock, flags);
	if (!desc->depth++) {
	desc->status \|= IRQ_DISABLED;
	desc->handler->disable(irq);
	}
	spin_unlock_irqrestore(&desc->lock, flags);
	}

	/*
	* Synchronous version of the above, making sure the IRQ is
	* no longer running on any other IRQ..
	*/
	void disable_irq(unsigned int irq)
	{
	irq_desc_t *desc = irq_desc + irq;
	disable_irq_nosync(irq);
	if (desc->action)
	synchronize_irq(irq);
	}

	void enable_irq(unsigned int irq)
	{
	irq_desc_t *desc = irq_desc + irq;
	unsigned long flags;

	spin_lock_irqsave(&desc->lock, flags);
	switch (desc->depth) {
	case 1: {
	unsigned int status = desc->status & ~(IRQ_DISABLED \| IRQ_INPROGRESS);
	desc->status = status;
	if ((status & (IRQ_PENDING \| IRQ_REPLAY)) == IRQ_PENDING) {
	desc->status = status \| IRQ_REPLAY;
	hw_resend_irq(desc->handler,irq);
	}
	desc->handler->enable(irq);
	/* fall-through */
	}
	default:
	desc->depth--;
	break;
	case 0:
	printk("enable_irq() unbalanced from %p\n",
	__builtin_return_address(0));
	}
	spin_unlock_irqrestore(&desc->lock, flags);
	}

	/*
	* do_IRQ handles all normal device IRQ's.
	*/
	asmlinkage int do_IRQ(unsigned long r4, unsigned long r5,
	unsigned long r6, unsigned long r7,
	struct pt_regs regs)
	{
	/*
	* We ack quickly, we don't want the irq controller
	* thinking we're snobs just because some other CPU has
	* disabled global interrupts (we have already done the
	* INT_ACK cycles, it's too late to try to pretend to the
	* controller that we aren't taking the interrupt).
	*
	* 0 return value means that this irq is already being
	* handled by some other CPU. (or is disabled)
	*/
	int irq;
	irq_desc_t *desc;
	struct irqaction * action;
	unsigned int status;

	irq_enter();

	#ifdef CONFIG_PREEMPT
	/*
	* At this point we're now about to actually call handlers,
	* and interrupts might get reenabled during them... bump
	* preempt_count to prevent any preemption while the handler
	* called here is pending...
	*/
	preempt_disable();
	#endif

	/* Get IRQ number */
	asm volatile("stc r2_bank, %0\n\t"
	"shlr2 %0\n\t"
	"shlr2 %0\n\t"
	"shlr %0\n\t"
	"add #-16, %0\n\t"
	:"=z" (irq));
	irq = irq_demux(irq);

	kstat_this_cpu.irqs[irq]++;
	desc = irq_desc + irq;
	spin_lock(&desc->lock);
	desc->handler->ack(irq);
	/*
	REPLAY is when Linux resends an IRQ that was dropped earlier
	WAITING is used by probe to mark irqs that are being tested
	*/
	status = desc->status & ~(IRQ_REPLAY \| IRQ_WAITING);
	status \|= IRQ_PENDING; /* we _want_ to handle it */

	/*
	* If the IRQ is disabled for whatever reason, we cannot
	* use the action we have.
	*/
	action = NULL;
	if (likely(!(status & (IRQ_DISABLED \| IRQ_INPROGRESS)))) {
	action = desc->action;
	status &= ~IRQ_PENDING; /* we commit to handling */
	status \|= IRQ_INPROGRESS; /* we are handling it */
	}
	desc->status = status;

	/*
	* If there is no IRQ handler or it was disabled, exit early.
	Since we set PENDING, if another processor is handling
	a different instance of this same irq, the other processor
	will take care of it.
	*/
	if (unlikely(!action))
	goto out;

	/*
	* Edge triggered interrupts need to remember
	* pending events.
	* This applies to any hw interrupts that allow a second
	* instance of the same irq to arrive while we are in do_IRQ
	* or in the handler. But the code here only handles the _second_
	* instance of the irq, not the third or fourth. So it is mostly
	* useful for irq hardware that does not mask cleanly in an
	* SMP environment.
	*/
	for (;;) {
	irqreturn_t action_ret;

	spin_unlock(&desc->lock);
	action_ret = handle_IRQ_event(irq, &regs, action);
	spin_lock(&desc->lock);
	if (!noirqdebug)
	note_interrupt(irq, desc, action_ret);
	if (likely(!(desc->status & IRQ_PENDING)))
	break;
	desc->status &= ~IRQ_PENDING;
	}
	desc->status &= ~IRQ_INPROGRESS;

	out:
	/*
	* The ->end() handler has to deal with interrupts which got
	* disabled while the handler was running.
	*/
	desc->handler->end(irq);
	spin_unlock(&desc->lock);

	irq_exit();

	#ifdef CONFIG_PREEMPT
	/*
	* We're done with the handlers, interrupts should be
	* currently disabled; decrement preempt_count now so
	* as we return preemption may be allowed...
	*/
	preempt_enable_no_resched();
	#endif

	return 1;
	}

	int request_irq(unsigned int irq,
	irqreturn_t (handler)(int, void , struct pt_regs *),
	unsigned long irqflags,
	const char * devname,
	void *dev_id)
	{
	int retval;
	struct irqaction * action;

	if (irq >= ACTUAL_NR_IRQS)
	return -EINVAL;
	if (!handler)
	return -EINVAL;

	action = (struct irqaction *)
	kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
	if (!action)
	return -ENOMEM;

	action->handler = handler;
	action->flags = irqflags;
	cpus_clear(action->mask);
	action->name = devname;
	action->next = NULL;
	action->dev_id = dev_id;

	retval = setup_irq(irq, action);
	if (retval)
	kfree(action);
	return retval;
	}

	EXPORT_SYMBOL(request_irq);

	void free_irq(unsigned int irq, void *dev_id)
	{
	irq_desc_t *desc;
	struct irqaction **p;
	unsigned long flags;

	if (irq >= ACTUAL_NR_IRQS)
	return;

	desc = irq_desc + irq;
	spin_lock_irqsave(&desc->lock,flags);
	p = &desc->action;
	for (;;) {
	struct irqaction * action = *p;
	if (action) {
	struct irqaction **pp = p;
	p = &action->next;
	if (action->dev_id != dev_id)
	continue;

	/* Found it - now remove it from the list of entries */
	*pp = action->next;
	if (!desc->action) {
	desc->status \|= IRQ_DISABLED;
	desc->handler->shutdown(irq);
	}
	spin_unlock_irqrestore(&desc->lock,flags);
	synchronize_irq(irq);
	kfree(action);
	return;
	}
	printk("Trying to free free IRQ%d\n",irq);
	spin_unlock_irqrestore(&desc->lock,flags);
	return;
	}
	}

	EXPORT_SYMBOL(free_irq);

	static DECLARE_MUTEX(probe_sem);

	/*
	* IRQ autodetection code..
	*
	* This depends on the fact that any interrupt that
	* comes in on to an unassigned handler will get stuck
	* with "IRQ_WAITING" cleared and the interrupt
	* disabled.
	*/
	unsigned long probe_irq_on(void)
	{
	unsigned int i;
	irq_desc_t *desc;
	unsigned long val;
	unsigned long delay;

	down(&probe_sem);
	/*
	* something may have generated an irq long ago and we want to
	* flush such a longstanding irq before considering it as spurious.
	*/
	for (i = NR_IRQS-1; i > 0; i--) {
	desc = irq_desc + i;

	spin_lock_irq(&desc->lock);
	if (!desc->action)
	desc->handler->startup(i);
	spin_unlock_irq(&desc->lock);
	}

	/* Wait for longstanding interrupts to trigger. */
	for (delay = jiffies + HZ/50; time_after(delay, jiffies); )
	/* about 20ms delay */ barrier();

	/*
	* enable any unassigned irqs
	* (we must startup again here because if a longstanding irq
	* happened in the previous stage, it may have masked itself)
	*/
	for (i = NR_IRQS-1; i > 0; i--) {
	desc = irq_desc + i;

	spin_lock_irq(&desc->lock);
	if (!desc->action) {
	desc->status \|= IRQ_AUTODETECT \| IRQ_WAITING;
	if (desc->handler->startup(i))
	desc->status \|= IRQ_PENDING;
	}
	spin_unlock_irq(&desc->lock);
	}

	/*
	* Wait for spurious interrupts to trigger
	*/
	for (delay = jiffies + HZ/10; time_after(delay, jiffies); )
	/* about 100ms delay */ barrier();

	/*
	* Now filter out any obviously spurious interrupts
	*/
	val = 0;
	for (i=0; i<NR_IRQS; i++) {
	unsigned int status;

	desc = irq_desc + i;

	spin_lock_irq(&desc->lock);
	status = desc->status;

	if (status & IRQ_AUTODETECT) {
	/* It triggered already - consider it spurious. */
	if (!(status & IRQ_WAITING)) {
	desc->status = status & ~IRQ_AUTODETECT;
	desc->handler->shutdown(i);
	} else
	if (i < 32)
	val \|= 1 << i;
	}
	spin_unlock_irq(&desc->lock);
	}

	return val;
	}

	EXPORT_SYMBOL(probe_irq_on);

	/* Return a mask of triggered interrupts (this
	* can handle only legacy ISA interrupts).
	*/

	/*
	* probe_irq_mask - scan a bitmap of interrupt lines
	* @val: mask of interrupts to consider
	*
	* Scan the ISA bus interrupt lines and return a bitmap of
	* active interrupts. The interrupt probe logic state is then
	* returned to its previous value.
	*
	* Note: we need to scan all the irq's even though we will
	* only return ISA irq numbers - just so that we reset them
	* all to a known state.
	*/
	unsigned int probe_irq_mask(unsigned long val)
	{
	int i;
	unsigned int mask;

	mask = 0;
	for (i = 0; i < NR_IRQS; i++) {
	irq_desc_t *desc = irq_desc + i;
	unsigned int status;

	spin_lock_irq(&desc->lock);
	status = desc->status;

	if (status & IRQ_AUTODETECT) {
	if (i < 16 && !(status & IRQ_WAITING))
	mask \|= 1 << i;

	desc->status = status & ~IRQ_AUTODETECT;
	desc->handler->shutdown(i);
	}
	spin_unlock_irq(&desc->lock);
	}
	up(&probe_sem);

	return mask & val;
	}

	int probe_irq_off(unsigned long val)
	{
	int i, irq_found, nr_irqs;

	nr_irqs = 0;
	irq_found = 0;
	for (i=0; i<NR_IRQS; i++) {
	irq_desc_t *desc = irq_desc + i;
	unsigned int status;

	spin_lock_irq(&desc->lock);
	status = desc->status;

	if (status & IRQ_AUTODETECT) {
	if (!(status & IRQ_WAITING)) {
	if (!nr_irqs)
	irq_found = i;
	nr_irqs++;
	}
	desc->status = status & ~IRQ_AUTODETECT;
	desc->handler->shutdown(i);
	}
	spin_unlock_irq(&desc->lock);
	}
	up(&probe_sem);

	if (nr_irqs > 1)
	irq_found = -irq_found;
	return irq_found;
	}

	EXPORT_SYMBOL(probe_irq_off);

	int setup_irq(unsigned int irq, struct irqaction * new)
	{
	int shared = 0;
	struct irqaction old, *p;
	unsigned long flags;
	irq_desc_t *desc = irq_desc + irq;

	if (desc->handler == &no_irq_type)
	return -ENOSYS;
	/*
	* Some drivers like serial.c use request_irq() heavily,
	* so we have to be careful not to interfere with a
	* running system.
	*/
	if (new->flags & SA_SAMPLE_RANDOM) {
	/*
	* This function might sleep, we want to call it first,
	* outside of the atomic block.
	* Yes, this might clear the entropy pool if the wrong
	* driver is attempted to be loaded, without actually
	* installing a new handler, but is this really a problem,
	* only the sysadmin is able to do this.
	*/
	rand_initialize_irq(irq);
	}

	/*
	* The following block of code has to be executed atomically
	*/
	spin_lock_irqsave(&desc->lock,flags);
	p = &desc->action;
	if ((old = *p) != NULL) {
	/* Can't share interrupts unless both agree to */
	if (!(old->flags & new->flags & SA_SHIRQ)) {
	spin_unlock_irqrestore(&desc->lock,flags);
	return -EBUSY;
	}

	/* add new interrupt at end of irq queue */
	do {
	p = &old->next;
	old = *p;
	} while (old);
	shared = 1;
	}

	*p = new;

	if (!shared) {
	desc->depth = 0;
	desc->status &= ~(IRQ_DISABLED \| IRQ_AUTODETECT \| IRQ_WAITING \| IRQ_INPROGRESS);
	desc->handler->startup(irq);
	}
	spin_unlock_irqrestore(&desc->lock,flags);
	return 0;
	}

	#if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)

	void init_irq_proc(void)
	{
	}
	#endif

	/* Taken from the 2.5 alpha port */
	#ifdef CONFIG_SMP
	void synchronize_irq(unsigned int irq)
	{
	/* is there anything to synchronize with? */
	if (!irq_desc[irq].action)
	return;

	while (irq_desc[irq].status & IRQ_INPROGRESS)
	barrier();
	}
	#endif