xref: /linux/kernel/irq/autoprobe.c (revision 0898782247ae533d1f4e47a06bc5d4870931b284)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
4  *
5  * This file contains the interrupt probing code and driver APIs.
6  */
7 
8 #include <linux/irq.h>
9 #include <linux/module.h>
10 #include <linux/interrupt.h>
11 #include <linux/delay.h>
12 #include <linux/async.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  * "IRQS_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  */
probe_irq_on(void)30 unsigned long probe_irq_on(void)
31 {
32 	struct irq_desc *desc;
33 	unsigned long mask = 0;
34 	int i;
35 
36 	/*
37 	 * quiesce the kernel, or at least the asynchronous portion
38 	 */
39 	async_synchronize_full();
40 	mutex_lock(&probing_active);
41 	/*
42 	 * something may have generated an irq long ago and we want to
43 	 * flush such a longstanding irq before considering it as spurious.
44 	 */
45 	for_each_irq_desc_reverse(i, desc) {
46 		raw_spin_lock_irq(&desc->lock);
47 		if (!desc->action && irq_settings_can_probe(desc)) {
48 			/*
49 			 * Some chips need to know about probing in
50 			 * progress:
51 			 */
52 			if (desc->irq_data.chip->irq_set_type)
53 				desc->irq_data.chip->irq_set_type(&desc->irq_data,
54 							 IRQ_TYPE_PROBE);
55 			irq_activate_and_startup(desc, IRQ_NORESEND);
56 		}
57 		raw_spin_unlock_irq(&desc->lock);
58 	}
59 
60 	/* Wait for longstanding interrupts to trigger. */
61 	msleep(20);
62 
63 	/*
64 	 * enable any unassigned irqs
65 	 * (we must startup again here because if a longstanding irq
66 	 * happened in the previous stage, it may have masked itself)
67 	 */
68 	for_each_irq_desc_reverse(i, desc) {
69 		raw_spin_lock_irq(&desc->lock);
70 		if (!desc->action && irq_settings_can_probe(desc)) {
71 			desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
72 			if (irq_activate_and_startup(desc, IRQ_NORESEND))
73 				desc->istate |= IRQS_PENDING;
74 		}
75 		raw_spin_unlock_irq(&desc->lock);
76 	}
77 
78 	/*
79 	 * Wait for spurious interrupts to trigger
80 	 */
81 	msleep(100);
82 
83 	/*
84 	 * Now filter out any obviously spurious interrupts
85 	 */
86 	for_each_irq_desc(i, desc) {
87 		raw_spin_lock_irq(&desc->lock);
88 
89 		if (desc->istate & IRQS_AUTODETECT) {
90 			/* It triggered already - consider it spurious. */
91 			if (!(desc->istate & IRQS_WAITING)) {
92 				desc->istate &= ~IRQS_AUTODETECT;
93 				irq_shutdown_and_deactivate(desc);
94 			} else
95 				if (i < 32)
96 					mask |= 1 << i;
97 		}
98 		raw_spin_unlock_irq(&desc->lock);
99 	}
100 
101 	return mask;
102 }
103 EXPORT_SYMBOL(probe_irq_on);
104 
105 /**
106  *	probe_irq_mask - scan a bitmap of interrupt lines
107  *	@val:	mask of interrupts to consider
108  *
109  *	Scan the interrupt lines and return a bitmap of active
110  *	autodetect interrupts. The interrupt probe logic state
111  *	is then returned to its previous value.
112  *
113  *	Note: we need to scan all the irq's even though we will
114  *	only return autodetect irq numbers - just so that we reset
115  *	them all to a known state.
116  */
probe_irq_mask(unsigned long val)117 unsigned int probe_irq_mask(unsigned long val)
118 {
119 	unsigned int mask = 0;
120 	struct irq_desc *desc;
121 	int i;
122 
123 	for_each_irq_desc(i, desc) {
124 		raw_spin_lock_irq(&desc->lock);
125 		if (desc->istate & IRQS_AUTODETECT) {
126 			if (i < 16 && !(desc->istate & IRQS_WAITING))
127 				mask |= 1 << i;
128 
129 			desc->istate &= ~IRQS_AUTODETECT;
130 			irq_shutdown_and_deactivate(desc);
131 		}
132 		raw_spin_unlock_irq(&desc->lock);
133 	}
134 	mutex_unlock(&probing_active);
135 
136 	return mask & val;
137 }
138 EXPORT_SYMBOL(probe_irq_mask);
139 
140 /**
141  *	probe_irq_off	- end an interrupt autodetect
142  *	@val: mask of potential interrupts (unused)
143  *
144  *	Scans the unused interrupt lines and returns the line which
145  *	appears to have triggered the interrupt. If no interrupt was
146  *	found then zero is returned. If more than one interrupt is
147  *	found then minus the first candidate is returned to indicate
148  *	their is doubt.
149  *
150  *	The interrupt probe logic state is returned to its previous
151  *	value.
152  *
153  *	BUGS: When used in a module (which arguably shouldn't happen)
154  *	nothing prevents two IRQ probe callers from overlapping. The
155  *	results of this are non-optimal.
156  */
probe_irq_off(unsigned long val)157 int probe_irq_off(unsigned long val)
158 {
159 	int i, irq_found = 0, nr_of_irqs = 0;
160 	struct irq_desc *desc;
161 
162 	for_each_irq_desc(i, desc) {
163 		raw_spin_lock_irq(&desc->lock);
164 
165 		if (desc->istate & IRQS_AUTODETECT) {
166 			if (!(desc->istate & IRQS_WAITING)) {
167 				if (!nr_of_irqs)
168 					irq_found = i;
169 				nr_of_irqs++;
170 			}
171 			desc->istate &= ~IRQS_AUTODETECT;
172 			irq_shutdown_and_deactivate(desc);
173 		}
174 		raw_spin_unlock_irq(&desc->lock);
175 	}
176 	mutex_unlock(&probing_active);
177 
178 	if (nr_of_irqs > 1)
179 		irq_found = -irq_found;
180 
181 	return irq_found;
182 }
183 EXPORT_SYMBOL(probe_irq_off);
184 
185