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