[deliverable/linux.git] / kernel / irq / autoprobe.c

/*
 * linux/kernel/irq/autoprobe.c
 *
 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
 *
 * This file contains the interrupt probing code and driver APIs.
 */

#include <linux/irq.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/delay.h>

/*
 * Autodetection 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.
 */
static DECLARE_MUTEX(probe_sem);

/**
 *	probe_irq_on	- begin an interrupt autodetect
 *
 *	Commence probing for an interrupt. The interrupts are scanned
 *	and a mask of potential interrupt lines is returned.
 *
 */
unsigned long probe_irq_on(void)
{
	unsigned long val;
	irq_desc_t *desc;
	unsigned int i;

	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 (!irq_desc[i].action)
			irq_desc[i].handler->startup(i);
		spin_unlock_irq(&desc->lock);
	}

	/* Wait for longstanding interrupts to trigger. */
	msleep(20);

	/*
	 * 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
	 */
	msleep(100);

	/*
	 * Now filter out any obviously spurious interrupts
	 */
	val = 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) {
			/* 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);

/**
 *	probe_irq_mask - scan a bitmap of interrupt lines
 *	@val:	mask of interrupts to consider
 *
 *	Scan the interrupt lines and return a bitmap of active
 *	autodetect 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 autodetect irq numbers - just so that we reset
 *	them all to a known state.
 */
unsigned int probe_irq_mask(unsigned long val)
{
	unsigned int mask;
	int i;

	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;
}
EXPORT_SYMBOL(probe_irq_mask);

/**
 *	probe_irq_off	- end an interrupt autodetect
 *	@val: mask of potential interrupts (unused)
 *
 *	Scans the unused interrupt lines and returns the line which
 *	appears to have triggered the interrupt. If no interrupt was
 *	found then zero is returned. If more than one interrupt is
 *	found then minus the first candidate is returned to indicate
 *	their is doubt.
 *
 *	The interrupt probe logic state is returned to its previous
 *	value.
 *
 *	BUGS: When used in a module (which arguably shouldn't happen)
 *	nothing prevents two IRQ probe callers from overlapping. The
 *	results of this are non-optimal.
 */
int probe_irq_off(unsigned long val)
{
	int i, irq_found = 0, nr_irqs = 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);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/kernel/irq/autoprobe.c
	3	*
	4	* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
	5	*
	6	* This file contains the interrupt probing code and driver APIs.
	7	*/
	8
	9	#include <linux/irq.h>
	10	#include <linux/module.h>
	11	#include <linux/interrupt.h>
47f176fd	12	#include <linux/delay.h>
1da177e4 LT	13
	14	/*
	15	* Autodetection depends on the fact that any interrupt that
	16	* comes in on to an unassigned handler will get stuck with
	17	* "IRQ_WAITING" cleared and the interrupt disabled.
	18	*/
	19	static DECLARE_MUTEX(probe_sem);
	20
	21	/**
	22	* probe_irq_on - begin an interrupt autodetect
	23	*
	24	* Commence probing for an interrupt. The interrupts are scanned
	25	* and a mask of potential interrupt lines is returned.
	26	*
	27	*/
	28	unsigned long probe_irq_on(void)
	29	{
47f176fd	30	unsigned long val;
1da177e4 LT	31	irq_desc_t *desc;
	32	unsigned int i;
	33
	34	down(&probe_sem);
	35	/*
	36	* something may have generated an irq long ago and we want to
	37	* flush such a longstanding irq before considering it as spurious.
	38	*/
	39	for (i = NR_IRQS-1; i > 0; i--) {
	40	desc = irq_desc + i;
	41
	42	spin_lock_irq(&desc->lock);
	43	if (!irq_desc[i].action)
	44	irq_desc[i].handler->startup(i);
	45	spin_unlock_irq(&desc->lock);
	46	}
	47
	48	/* Wait for longstanding interrupts to trigger. */
47f176fd	49	msleep(20);
1da177e4 LT	50
	51	/*
	52	* enable any unassigned irqs
	53	* (we must startup again here because if a longstanding irq
	54	* happened in the previous stage, it may have masked itself)
	55	*/
	56	for (i = NR_IRQS-1; i > 0; i--) {
	57	desc = irq_desc + i;
	58
	59	spin_lock_irq(&desc->lock);
	60	if (!desc->action) {
	61	desc->status \|= IRQ_AUTODETECT \| IRQ_WAITING;
	62	if (desc->handler->startup(i))
	63	desc->status \|= IRQ_PENDING;
	64	}
	65	spin_unlock_irq(&desc->lock);
	66	}
	67
	68	/*
	69	* Wait for spurious interrupts to trigger
	70	*/
47f176fd	71	msleep(100);
1da177e4 LT	72
	73	/*
	74	* Now filter out any obviously spurious interrupts
	75	*/
	76	val = 0;
	77	for (i = 0; i < NR_IRQS; i++) {
	78	irq_desc_t *desc = irq_desc + i;
	79	unsigned int status;
	80
	81	spin_lock_irq(&desc->lock);
	82	status = desc->status;
	83
	84	if (status & IRQ_AUTODETECT) {
	85	/* It triggered already - consider it spurious. */
	86	if (!(status & IRQ_WAITING)) {
	87	desc->status = status & ~IRQ_AUTODETECT;
	88	desc->handler->shutdown(i);
	89	} else
	90	if (i < 32)
	91	val \|= 1 << i;
	92	}
	93	spin_unlock_irq(&desc->lock);
	94	}
	95
	96	return val;
	97	}
	98
	99	EXPORT_SYMBOL(probe_irq_on);
	100
	101	/**
	102	* probe_irq_mask - scan a bitmap of interrupt lines
	103	* @val: mask of interrupts to consider
	104	*
	105	* Scan the interrupt lines and return a bitmap of active
	106	* autodetect interrupts. The interrupt probe logic state
	107	* is then returned to its previous value.
	108	*
	109	* Note: we need to scan all the irq's even though we will
	110	* only return autodetect irq numbers - just so that we reset
	111	* them all to a known state.
	112	*/
	113	unsigned int probe_irq_mask(unsigned long val)
	114	{
	115	unsigned int mask;
	116	int i;
	117
	118	mask = 0;
	119	for (i = 0; i < NR_IRQS; i++) {
	120	irq_desc_t *desc = irq_desc + i;
	121	unsigned int status;
	122
	123	spin_lock_irq(&desc->lock);
	124	status = desc->status;
	125
	126	if (status & IRQ_AUTODETECT) {
	127	if (i < 16 && !(status & IRQ_WAITING))
	128	mask \|= 1 << i;
	129
	130	desc->status = status & ~IRQ_AUTODETECT;
	131	desc->handler->shutdown(i);
	132	}
	133	spin_unlock_irq(&desc->lock);
	134	}
	135	up(&probe_sem);
136
137	return mask & val;
138	}
139	EXPORT_SYMBOL(probe_irq_mask);
140
141	/**
142	* probe_irq_off - end an interrupt autodetect
143	* @val: mask of potential interrupts (unused)
144	*
145	* Scans the unused interrupt lines and returns the line which
146	* appears to have triggered the interrupt. If no interrupt was
147	* found then zero is returned. If more than one interrupt is
148	* found then minus the first candidate is returned to indicate
149	* their is doubt.
150	*
151	* The interrupt probe logic state is returned to its previous
152	* value.
153	*
154	* BUGS: When used in a module (which arguably shouldn't happen)
155	* nothing prevents two IRQ probe callers from overlapping. The
156	* results of this are non-optimal.
157	*/
158	int probe_irq_off(unsigned long val)
159	{
160	int i, irq_found = 0, nr_irqs = 0;
161
162	for (i = 0; i < NR_IRQS; i++) {
163	irq_desc_t *desc = irq_desc + i;
164	unsigned int status;
165
166	spin_lock_irq(&desc->lock);
167	status = desc->status;
168
169	if (status & IRQ_AUTODETECT) {
170	if (!(status & IRQ_WAITING)) {
171	if (!nr_irqs)
172	irq_found = i;
173	nr_irqs++;
174	}
175	desc->status = status & ~IRQ_AUTODETECT;
176	desc->handler->shutdown(i);
177	}
178	spin_unlock_irq(&desc->lock);
179	}
180	up(&probe_sem);
181
182	if (nr_irqs > 1)
183	irq_found = -irq_found;
184	return irq_found;
185	}
186
187	EXPORT_SYMBOL(probe_irq_off);
188