]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 | 2 | /* |
1da177e4 LT |
3 | * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar |
4 | * | |
5 | * This file contains spurious interrupt handling. | |
6 | */ | |
7 | ||
188fd89d | 8 | #include <linux/jiffies.h> |
1da177e4 LT |
9 | #include <linux/irq.h> |
10 | #include <linux/module.h> | |
1da177e4 | 11 | #include <linux/interrupt.h> |
9e094c17 | 12 | #include <linux/moduleparam.h> |
f84dbb91 | 13 | #include <linux/timer.h> |
1da177e4 | 14 | |
bd151412 TG |
15 | #include "internals.h" |
16 | ||
83d4e6e7 | 17 | static int irqfixup __read_mostly; |
200803df | 18 | |
f84dbb91 | 19 | #define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10) |
24ed960a | 20 | static void poll_spurious_irqs(struct timer_list *unused); |
1d27e3e2 | 21 | static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs); |
d05c65ff TG |
22 | static int irq_poll_cpu; |
23 | static atomic_t irq_poll_active; | |
f84dbb91 | 24 | |
fe200ae4 TG |
25 | /* |
26 | * We wait here for a poller to finish. | |
27 | * | |
28 | * If the poll runs on this CPU, then we yell loudly and return | |
29 | * false. That will leave the interrupt line disabled in the worst | |
30 | * case, but it should never happen. | |
31 | * | |
32 | * We wait until the poller is done and then recheck disabled and | |
33 | * action (about to be disabled). Only if it's still active, we return | |
34 | * true and let the handler run. | |
35 | */ | |
36 | bool irq_wait_for_poll(struct irq_desc *desc) | |
37 | { | |
38 | if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), | |
39 | "irq poll in progress on cpu %d for irq %d\n", | |
40 | smp_processor_id(), desc->irq_data.irq)) | |
41 | return false; | |
42 | ||
43 | #ifdef CONFIG_SMP | |
44 | do { | |
45 | raw_spin_unlock(&desc->lock); | |
32f4125e | 46 | while (irqd_irq_inprogress(&desc->irq_data)) |
fe200ae4 TG |
47 | cpu_relax(); |
48 | raw_spin_lock(&desc->lock); | |
a6aeddd1 | 49 | } while (irqd_irq_inprogress(&desc->irq_data)); |
fe200ae4 | 50 | /* Might have been disabled in meantime */ |
32f4125e | 51 | return !irqd_irq_disabled(&desc->irq_data) && desc->action; |
fe200ae4 TG |
52 | #else |
53 | return false; | |
54 | #endif | |
55 | } | |
56 | ||
0877d662 | 57 | |
200803df AC |
58 | /* |
59 | * Recovery handler for misrouted interrupts. | |
60 | */ | |
c1e5bd8c | 61 | static int try_one_irq(struct irq_desc *desc, bool force) |
200803df | 62 | { |
0877d662 | 63 | irqreturn_t ret = IRQ_NONE; |
f84dbb91 | 64 | struct irqaction *action; |
200803df | 65 | |
239007b8 | 66 | raw_spin_lock(&desc->lock); |
c7259cd7 | 67 | |
b39898cd | 68 | /* |
c5f48c0a | 69 | * PER_CPU, nested thread interrupts and interrupts explicitly |
b39898cd TG |
70 | * marked polled are excluded from polling. |
71 | */ | |
72 | if (irq_settings_is_per_cpu(desc) || | |
73 | irq_settings_is_nested_thread(desc) || | |
74 | irq_settings_is_polled(desc)) | |
c7259cd7 TG |
75 | goto out; |
76 | ||
77 | /* | |
78 | * Do not poll disabled interrupts unless the spurious | |
c5f48c0a | 79 | * disabled poller asks explicitly. |
c7259cd7 | 80 | */ |
32f4125e | 81 | if (irqd_irq_disabled(&desc->irq_data) && !force) |
c7259cd7 TG |
82 | goto out; |
83 | ||
84 | /* | |
85 | * All handlers must agree on IRQF_SHARED, so we test just the | |
e716efde | 86 | * first. |
c7259cd7 TG |
87 | */ |
88 | action = desc->action; | |
89 | if (!action || !(action->flags & IRQF_SHARED) || | |
e716efde | 90 | (action->flags & __IRQF_TIMER)) |
c7259cd7 TG |
91 | goto out; |
92 | ||
f84dbb91 | 93 | /* Already running on another processor */ |
32f4125e | 94 | if (irqd_irq_inprogress(&desc->irq_data)) { |
f84dbb91 EB |
95 | /* |
96 | * Already running: If it is shared get the other | |
97 | * CPU to go looking for our mystery interrupt too | |
98 | */ | |
2a0d6fb3 | 99 | desc->istate |= IRQS_PENDING; |
fa27271b | 100 | goto out; |
c7259cd7 | 101 | } |
fa27271b | 102 | |
0877d662 | 103 | /* Mark it poll in progress */ |
6954b75b | 104 | desc->istate |= IRQS_POLL_INPROGRESS; |
fa27271b | 105 | do { |
0877d662 TG |
106 | if (handle_irq_event(desc) == IRQ_HANDLED) |
107 | ret = IRQ_HANDLED; | |
e716efde | 108 | /* Make sure that there is still a valid action */ |
fa27271b | 109 | action = desc->action; |
2a0d6fb3 | 110 | } while ((desc->istate & IRQS_PENDING) && action); |
6954b75b | 111 | desc->istate &= ~IRQS_POLL_INPROGRESS; |
fa27271b TG |
112 | out: |
113 | raw_spin_unlock(&desc->lock); | |
0877d662 | 114 | return ret == IRQ_HANDLED; |
f84dbb91 EB |
115 | } |
116 | ||
117 | static int misrouted_irq(int irq) | |
118 | { | |
e00585bb | 119 | struct irq_desc *desc; |
d3c60047 | 120 | int i, ok = 0; |
f84dbb91 | 121 | |
c75d720f | 122 | if (atomic_inc_return(&irq_poll_active) != 1) |
d05c65ff TG |
123 | goto out; |
124 | ||
125 | irq_poll_cpu = smp_processor_id(); | |
126 | ||
e00585bb YL |
127 | for_each_irq_desc(i, desc) { |
128 | if (!i) | |
129 | continue; | |
f84dbb91 EB |
130 | |
131 | if (i == irq) /* Already tried */ | |
132 | continue; | |
133 | ||
c1e5bd8c | 134 | if (try_one_irq(desc, false)) |
f84dbb91 | 135 | ok = 1; |
200803df | 136 | } |
d05c65ff TG |
137 | out: |
138 | atomic_dec(&irq_poll_active); | |
200803df AC |
139 | /* So the caller can adjust the irq error counts */ |
140 | return ok; | |
141 | } | |
142 | ||
24ed960a | 143 | static void poll_spurious_irqs(struct timer_list *unused) |
f84dbb91 | 144 | { |
e00585bb | 145 | struct irq_desc *desc; |
d3c60047 | 146 | int i; |
e00585bb | 147 | |
d05c65ff TG |
148 | if (atomic_inc_return(&irq_poll_active) != 1) |
149 | goto out; | |
150 | irq_poll_cpu = smp_processor_id(); | |
151 | ||
e00585bb | 152 | for_each_irq_desc(i, desc) { |
7acdd53e | 153 | unsigned int state; |
f84dbb91 | 154 | |
e00585bb YL |
155 | if (!i) |
156 | continue; | |
157 | ||
f84dbb91 | 158 | /* Racy but it doesn't matter */ |
7acdd53e | 159 | state = desc->istate; |
f84dbb91 | 160 | barrier(); |
7acdd53e | 161 | if (!(state & IRQS_SPURIOUS_DISABLED)) |
f84dbb91 EB |
162 | continue; |
163 | ||
e7e7e0c0 | 164 | local_irq_disable(); |
c1e5bd8c | 165 | try_one_irq(desc, true); |
e7e7e0c0 | 166 | local_irq_enable(); |
f84dbb91 | 167 | } |
d05c65ff TG |
168 | out: |
169 | atomic_dec(&irq_poll_active); | |
d3c60047 TG |
170 | mod_timer(&poll_spurious_irq_timer, |
171 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
f84dbb91 EB |
172 | } |
173 | ||
3a43e05f SAS |
174 | static inline int bad_action_ret(irqreturn_t action_ret) |
175 | { | |
5d4bac9a JK |
176 | unsigned int r = action_ret; |
177 | ||
178 | if (likely(r <= (IRQ_HANDLED | IRQ_WAKE_THREAD))) | |
3a43e05f SAS |
179 | return 0; |
180 | return 1; | |
181 | } | |
182 | ||
1da177e4 LT |
183 | /* |
184 | * If 99,900 of the previous 100,000 interrupts have not been handled | |
185 | * then assume that the IRQ is stuck in some manner. Drop a diagnostic | |
186 | * and try to turn the IRQ off. | |
187 | * | |
188 | * (The other 100-of-100,000 interrupts may have been a correctly | |
189 | * functioning device sharing an IRQ with the failing one) | |
1da177e4 | 190 | */ |
02d00eaa | 191 | static void __report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret) |
1da177e4 | 192 | { |
02d00eaa | 193 | unsigned int irq = irq_desc_get_irq(desc); |
1da177e4 | 194 | struct irqaction *action; |
1082687e | 195 | unsigned long flags; |
1da177e4 | 196 | |
3a43e05f | 197 | if (bad_action_ret(action_ret)) { |
1da177e4 LT |
198 | printk(KERN_ERR "irq event %d: bogus return value %x\n", |
199 | irq, action_ret); | |
200 | } else { | |
200803df AC |
201 | printk(KERN_ERR "irq %d: nobody cared (try booting with " |
202 | "the \"irqpoll\" option)\n", irq); | |
1da177e4 LT |
203 | } |
204 | dump_stack(); | |
205 | printk(KERN_ERR "handlers:\n"); | |
06fcb0c6 | 206 | |
1082687e TG |
207 | /* |
208 | * We need to take desc->lock here. note_interrupt() is called | |
209 | * w/o desc->lock held, but IRQ_PROGRESS set. We might race | |
210 | * with something else removing an action. It's ok to take | |
211 | * desc->lock here. See synchronize_irq(). | |
212 | */ | |
213 | raw_spin_lock_irqsave(&desc->lock, flags); | |
f944b5a7 | 214 | for_each_action_of_desc(desc, action) { |
d75f773c | 215 | printk(KERN_ERR "[<%p>] %ps", action->handler, action->handler); |
ef26f20c | 216 | if (action->thread_fn) |
d75f773c | 217 | printk(KERN_CONT " threaded [<%p>] %ps", |
ef26f20c SAS |
218 | action->thread_fn, action->thread_fn); |
219 | printk(KERN_CONT "\n"); | |
1da177e4 | 220 | } |
1082687e | 221 | raw_spin_unlock_irqrestore(&desc->lock, flags); |
1da177e4 LT |
222 | } |
223 | ||
02d00eaa | 224 | static void report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret) |
1da177e4 LT |
225 | { |
226 | static int count = 100; | |
227 | ||
228 | if (count > 0) { | |
229 | count--; | |
02d00eaa | 230 | __report_bad_irq(desc, action_ret); |
1da177e4 LT |
231 | } |
232 | } | |
233 | ||
d3c60047 TG |
234 | static inline int |
235 | try_misrouted_irq(unsigned int irq, struct irq_desc *desc, | |
236 | irqreturn_t action_ret) | |
92ea7727 LT |
237 | { |
238 | struct irqaction *action; | |
239 | ||
240 | if (!irqfixup) | |
241 | return 0; | |
242 | ||
243 | /* We didn't actually handle the IRQ - see if it was misrouted? */ | |
244 | if (action_ret == IRQ_NONE) | |
245 | return 1; | |
246 | ||
247 | /* | |
248 | * But for 'irqfixup == 2' we also do it for handled interrupts if | |
249 | * they are marked as IRQF_IRQPOLL (or for irq zero, which is the | |
250 | * traditional PC timer interrupt.. Legacy) | |
251 | */ | |
252 | if (irqfixup < 2) | |
253 | return 0; | |
254 | ||
255 | if (!irq) | |
256 | return 1; | |
257 | ||
258 | /* | |
259 | * Since we don't get the descriptor lock, "action" can | |
260 | * change under us. We don't really care, but we don't | |
261 | * want to follow a NULL pointer. So tell the compiler to | |
262 | * just load it once by using a barrier. | |
263 | */ | |
264 | action = desc->action; | |
265 | barrier(); | |
266 | return action && (action->flags & IRQF_IRQPOLL); | |
267 | } | |
268 | ||
1e77d0a1 TG |
269 | #define SPURIOUS_DEFERRED 0x80000000 |
270 | ||
0dcdbc97 | 271 | void note_interrupt(struct irq_desc *desc, irqreturn_t action_ret) |
1da177e4 | 272 | { |
0dcdbc97 JL |
273 | unsigned int irq; |
274 | ||
b39898cd TG |
275 | if (desc->istate & IRQS_POLL_INPROGRESS || |
276 | irq_settings_is_polled(desc)) | |
fe200ae4 TG |
277 | return; |
278 | ||
3a43e05f | 279 | if (bad_action_ret(action_ret)) { |
02d00eaa | 280 | report_bad_irq(desc, action_ret); |
3a43e05f SAS |
281 | return; |
282 | } | |
283 | ||
1e77d0a1 TG |
284 | /* |
285 | * We cannot call note_interrupt from the threaded handler | |
286 | * because we need to look at the compound of all handlers | |
287 | * (primary and threaded). Aside of that in the threaded | |
288 | * shared case we have no serialization against an incoming | |
289 | * hardware interrupt while we are dealing with a threaded | |
290 | * result. | |
291 | * | |
292 | * So in case a thread is woken, we just note the fact and | |
293 | * defer the analysis to the next hardware interrupt. | |
294 | * | |
c5f48c0a | 295 | * The threaded handlers store whether they successfully |
1e77d0a1 TG |
296 | * handled an interrupt and we check whether that number |
297 | * changed versus the last invocation. | |
298 | * | |
299 | * We could handle all interrupts with the delayed by one | |
300 | * mechanism, but for the non forced threaded case we'd just | |
301 | * add pointless overhead to the straight hardirq interrupts | |
302 | * for the sake of a few lines less code. | |
303 | */ | |
304 | if (action_ret & IRQ_WAKE_THREAD) { | |
305 | /* | |
306 | * There is a thread woken. Check whether one of the | |
307 | * shared primary handlers returned IRQ_HANDLED. If | |
308 | * not we defer the spurious detection to the next | |
309 | * interrupt. | |
310 | */ | |
311 | if (action_ret == IRQ_WAKE_THREAD) { | |
312 | int handled; | |
313 | /* | |
314 | * We use bit 31 of thread_handled_last to | |
315 | * denote the deferred spurious detection | |
316 | * active. No locking necessary as | |
317 | * thread_handled_last is only accessed here | |
318 | * and we have the guarantee that hard | |
319 | * interrupts are not reentrant. | |
320 | */ | |
321 | if (!(desc->threads_handled_last & SPURIOUS_DEFERRED)) { | |
322 | desc->threads_handled_last |= SPURIOUS_DEFERRED; | |
323 | return; | |
324 | } | |
325 | /* | |
326 | * Check whether one of the threaded handlers | |
327 | * returned IRQ_HANDLED since the last | |
328 | * interrupt happened. | |
329 | * | |
330 | * For simplicity we just set bit 31, as it is | |
331 | * set in threads_handled_last as well. So we | |
332 | * avoid extra masking. And we really do not | |
333 | * care about the high bits of the handled | |
334 | * count. We just care about the count being | |
335 | * different than the one we saw before. | |
336 | */ | |
337 | handled = atomic_read(&desc->threads_handled); | |
338 | handled |= SPURIOUS_DEFERRED; | |
339 | if (handled != desc->threads_handled_last) { | |
340 | action_ret = IRQ_HANDLED; | |
341 | /* | |
342 | * Note: We keep the SPURIOUS_DEFERRED | |
343 | * bit set. We are handling the | |
344 | * previous invocation right now. | |
345 | * Keep it for the current one, so the | |
346 | * next hardware interrupt will | |
347 | * account for it. | |
348 | */ | |
349 | desc->threads_handled_last = handled; | |
350 | } else { | |
351 | /* | |
352 | * None of the threaded handlers felt | |
353 | * responsible for the last interrupt | |
354 | * | |
355 | * We keep the SPURIOUS_DEFERRED bit | |
356 | * set in threads_handled_last as we | |
357 | * need to account for the current | |
358 | * interrupt as well. | |
359 | */ | |
360 | action_ret = IRQ_NONE; | |
361 | } | |
362 | } else { | |
363 | /* | |
364 | * One of the primary handlers returned | |
365 | * IRQ_HANDLED. So we don't care about the | |
366 | * threaded handlers on the same line. Clear | |
367 | * the deferred detection bit. | |
368 | * | |
369 | * In theory we could/should check whether the | |
370 | * deferred bit is set and take the result of | |
371 | * the previous run into account here as | |
372 | * well. But it's really not worth the | |
373 | * trouble. If every other interrupt is | |
374 | * handled we never trigger the spurious | |
375 | * detector. And if this is just the one out | |
376 | * of 100k unhandled ones which is handled | |
377 | * then we merily delay the spurious detection | |
378 | * by one hard interrupt. Not a real problem. | |
379 | */ | |
380 | desc->threads_handled_last &= ~SPURIOUS_DEFERRED; | |
381 | } | |
382 | } | |
383 | ||
3a43e05f | 384 | if (unlikely(action_ret == IRQ_NONE)) { |
4f27c00b AC |
385 | /* |
386 | * If we are seeing only the odd spurious IRQ caused by | |
387 | * bus asynchronicity then don't eventually trigger an error, | |
fbfecd37 | 388 | * otherwise the counter becomes a doomsday timer for otherwise |
4f27c00b AC |
389 | * working systems |
390 | */ | |
188fd89d | 391 | if (time_after(jiffies, desc->last_unhandled + HZ/10)) |
4f27c00b AC |
392 | desc->irqs_unhandled = 1; |
393 | else | |
394 | desc->irqs_unhandled++; | |
395 | desc->last_unhandled = jiffies; | |
1da177e4 LT |
396 | } |
397 | ||
0dcdbc97 | 398 | irq = irq_desc_get_irq(desc); |
92ea7727 LT |
399 | if (unlikely(try_misrouted_irq(irq, desc, action_ret))) { |
400 | int ok = misrouted_irq(irq); | |
401 | if (action_ret == IRQ_NONE) | |
402 | desc->irqs_unhandled -= ok; | |
200803df AC |
403 | } |
404 | ||
1da177e4 | 405 | desc->irq_count++; |
83d4e6e7 | 406 | if (likely(desc->irq_count < 100000)) |
1da177e4 LT |
407 | return; |
408 | ||
409 | desc->irq_count = 0; | |
83d4e6e7 | 410 | if (unlikely(desc->irqs_unhandled > 99900)) { |
1da177e4 LT |
411 | /* |
412 | * The interrupt is stuck | |
413 | */ | |
02d00eaa | 414 | __report_bad_irq(desc, action_ret); |
1da177e4 LT |
415 | /* |
416 | * Now kill the IRQ | |
417 | */ | |
418 | printk(KERN_EMERG "Disabling IRQ #%d\n", irq); | |
7acdd53e | 419 | desc->istate |= IRQS_SPURIOUS_DISABLED; |
1adb0850 | 420 | desc->depth++; |
87923470 | 421 | irq_disable(desc); |
f84dbb91 | 422 | |
d3c60047 TG |
423 | mod_timer(&poll_spurious_irq_timer, |
424 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
1da177e4 LT |
425 | } |
426 | desc->irqs_unhandled = 0; | |
427 | } | |
428 | ||
2329abfa | 429 | bool noirqdebug __read_mostly; |
1da177e4 | 430 | |
343cde51 | 431 | int noirqdebug_setup(char *str) |
1da177e4 LT |
432 | { |
433 | noirqdebug = 1; | |
434 | printk(KERN_INFO "IRQ lockup detection disabled\n"); | |
06fcb0c6 | 435 | |
1da177e4 LT |
436 | return 1; |
437 | } | |
438 | ||
439 | __setup("noirqdebug", noirqdebug_setup); | |
9e094c17 AK |
440 | module_param(noirqdebug, bool, 0644); |
441 | MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true"); | |
1da177e4 | 442 | |
200803df AC |
443 | static int __init irqfixup_setup(char *str) |
444 | { | |
445 | irqfixup = 1; | |
446 | printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n"); | |
447 | printk(KERN_WARNING "This may impact system performance.\n"); | |
06fcb0c6 | 448 | |
200803df AC |
449 | return 1; |
450 | } | |
451 | ||
452 | __setup("irqfixup", irqfixup_setup); | |
9e094c17 | 453 | module_param(irqfixup, int, 0644); |
200803df AC |
454 | |
455 | static int __init irqpoll_setup(char *str) | |
456 | { | |
457 | irqfixup = 2; | |
458 | printk(KERN_WARNING "Misrouted IRQ fixup and polling support " | |
459 | "enabled\n"); | |
460 | printk(KERN_WARNING "This may significantly impact system " | |
461 | "performance\n"); | |
462 | return 1; | |
463 | } | |
464 | ||
465 | __setup("irqpoll", irqpoll_setup); |