xref: /openbmc/linux/kernel/irq/autoprobe.c (revision 2c684d89)
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  * "IRQS_WAITING" cleared and the interrupt disabled.
21  */
22 static 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  */
31 unsigned long probe_irq_on(void)
32 {
33 	struct irq_desc *desc;
34 	unsigned long mask = 0;
35 	int i;
36 
37 	/*
38 	 * quiesce the kernel, or at least the asynchronous portion
39 	 */
40 	async_synchronize_full();
41 	mutex_lock(&probing_active);
42 	/*
43 	 * something may have generated an irq long ago and we want to
44 	 * flush such a longstanding irq before considering it as spurious.
45 	 */
46 	for_each_irq_desc_reverse(i, desc) {
47 		raw_spin_lock_irq(&desc->lock);
48 		if (!desc->action && irq_settings_can_probe(desc)) {
49 			/*
50 			 * Some chips need to know about probing in
51 			 * progress:
52 			 */
53 			if (desc->irq_data.chip->irq_set_type)
54 				desc->irq_data.chip->irq_set_type(&desc->irq_data,
55 							 IRQ_TYPE_PROBE);
56 			irq_startup(desc, false);
57 		}
58 		raw_spin_unlock_irq(&desc->lock);
59 	}
60 
61 	/* Wait for longstanding interrupts to trigger. */
62 	msleep(20);
63 
64 	/*
65 	 * enable any unassigned irqs
66 	 * (we must startup again here because if a longstanding irq
67 	 * happened in the previous stage, it may have masked itself)
68 	 */
69 	for_each_irq_desc_reverse(i, desc) {
70 		raw_spin_lock_irq(&desc->lock);
71 		if (!desc->action && irq_settings_can_probe(desc)) {
72 			desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
73 			if (irq_startup(desc, false))
74 				desc->istate |= IRQS_PENDING;
75 		}
76 		raw_spin_unlock_irq(&desc->lock);
77 	}
78 
79 	/*
80 	 * Wait for spurious interrupts to trigger
81 	 */
82 	msleep(100);
83 
84 	/*
85 	 * Now filter out any obviously spurious interrupts
86 	 */
87 	for_each_irq_desc(i, desc) {
88 		raw_spin_lock_irq(&desc->lock);
89 
90 		if (desc->istate & IRQS_AUTODETECT) {
91 			/* It triggered already - consider it spurious. */
92 			if (!(desc->istate & IRQS_WAITING)) {
93 				desc->istate &= ~IRQS_AUTODETECT;
94 				irq_shutdown(desc);
95 			} else
96 				if (i < 32)
97 					mask |= 1 << i;
98 		}
99 		raw_spin_unlock_irq(&desc->lock);
100 	}
101 
102 	return mask;
103 }
104 EXPORT_SYMBOL(probe_irq_on);
105 
106 /**
107  *	probe_irq_mask - scan a bitmap of interrupt lines
108  *	@val:	mask of interrupts to consider
109  *
110  *	Scan the interrupt lines and return a bitmap of active
111  *	autodetect interrupts. The interrupt probe logic state
112  *	is then returned to its previous value.
113  *
114  *	Note: we need to scan all the irq's even though we will
115  *	only return autodetect irq numbers - just so that we reset
116  *	them all to a known state.
117  */
118 unsigned int probe_irq_mask(unsigned long val)
119 {
120 	unsigned int mask = 0;
121 	struct irq_desc *desc;
122 	int i;
123 
124 	for_each_irq_desc(i, desc) {
125 		raw_spin_lock_irq(&desc->lock);
126 		if (desc->istate & IRQS_AUTODETECT) {
127 			if (i < 16 && !(desc->istate & IRQS_WAITING))
128 				mask |= 1 << i;
129 
130 			desc->istate &= ~IRQS_AUTODETECT;
131 			irq_shutdown(desc);
132 		}
133 		raw_spin_unlock_irq(&desc->lock);
134 	}
135 	mutex_unlock(&probing_active);
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_of_irqs = 0;
161 	struct irq_desc *desc;
162 
163 	for_each_irq_desc(i, desc) {
164 		raw_spin_lock_irq(&desc->lock);
165 
166 		if (desc->istate & IRQS_AUTODETECT) {
167 			if (!(desc->istate & IRQS_WAITING)) {
168 				if (!nr_of_irqs)
169 					irq_found = i;
170 				nr_of_irqs++;
171 			}
172 			desc->istate &= ~IRQS_AUTODETECT;
173 			irq_shutdown(desc);
174 		}
175 		raw_spin_unlock_irq(&desc->lock);
176 	}
177 	mutex_unlock(&probing_active);
178 
179 	if (nr_of_irqs > 1)
180 		irq_found = -irq_found;
181 
182 	return irq_found;
183 }
184 EXPORT_SYMBOL(probe_irq_off);
185 
186