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 | */ |
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(msecs: 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(msecs: 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 | */ |
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(lock: &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 | */ |
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(lock: &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 | |