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