2
* linux/kernel/irq/spurious.c
4
* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
6
* This file contains spurious interrupt handling.
9
#include <linux/jiffies.h>
10
#include <linux/irq.h>
11
#include <linux/module.h>
12
#include <linux/kallsyms.h>
13
#include <linux/interrupt.h>
14
#include <linux/moduleparam.h>
15
#include <linux/timer.h>
17
#include "internals.h"
19
static int irqfixup __read_mostly;
21
#define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10)
22
static void poll_spurious_irqs(unsigned long dummy);
23
static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs, 0, 0);
24
static int irq_poll_cpu;
25
static atomic_t irq_poll_active;
28
* We wait here for a poller to finish.
30
* If the poll runs on this CPU, then we yell loudly and return
31
* false. That will leave the interrupt line disabled in the worst
32
* case, but it should never happen.
34
* We wait until the poller is done and then recheck disabled and
35
* action (about to be disabled). Only if it's still active, we return
36
* true and let the handler run.
38
bool irq_wait_for_poll(struct irq_desc *desc)
40
if (WARN_ONCE(irq_poll_cpu == smp_processor_id(),
41
"irq poll in progress on cpu %d for irq %d\n",
42
smp_processor_id(), desc->irq_data.irq))
47
raw_spin_unlock(&desc->lock);
48
while (irqd_irq_inprogress(&desc->irq_data))
50
raw_spin_lock(&desc->lock);
51
} while (irqd_irq_inprogress(&desc->irq_data));
52
/* Might have been disabled in meantime */
53
return !irqd_irq_disabled(&desc->irq_data) && desc->action;
61
* Recovery handler for misrouted interrupts.
63
static int try_one_irq(int irq, struct irq_desc *desc, bool force)
65
irqreturn_t ret = IRQ_NONE;
66
struct irqaction *action;
68
raw_spin_lock(&desc->lock);
70
/* PER_CPU and nested thread interrupts are never polled */
71
if (irq_settings_is_per_cpu(desc) || irq_settings_is_nested_thread(desc))
75
* Do not poll disabled interrupts unless the spurious
76
* disabled poller asks explicitely.
78
if (irqd_irq_disabled(&desc->irq_data) && !force)
82
* All handlers must agree on IRQF_SHARED, so we test just the
83
* first. Check for action->next as well.
85
action = desc->action;
86
if (!action || !(action->flags & IRQF_SHARED) ||
87
(action->flags & __IRQF_TIMER) ||
88
(action->handler(irq, action->dev_id) == IRQ_HANDLED) ||
92
/* Already running on another processor */
93
if (irqd_irq_inprogress(&desc->irq_data)) {
95
* Already running: If it is shared get the other
96
* CPU to go looking for our mystery interrupt too
98
desc->istate |= IRQS_PENDING;
102
/* Mark it poll in progress */
103
desc->istate |= IRQS_POLL_INPROGRESS;
105
if (handle_irq_event(desc) == IRQ_HANDLED)
107
action = desc->action;
108
} while ((desc->istate & IRQS_PENDING) && action);
109
desc->istate &= ~IRQS_POLL_INPROGRESS;
111
raw_spin_unlock(&desc->lock);
112
return ret == IRQ_HANDLED;
115
static int misrouted_irq(int irq)
117
struct irq_desc *desc;
120
if (atomic_inc_return(&irq_poll_active) != 1)
123
irq_poll_cpu = smp_processor_id();
125
for_each_irq_desc(i, desc) {
129
if (i == irq) /* Already tried */
132
if (try_one_irq(i, desc, false))
136
atomic_dec(&irq_poll_active);
137
/* So the caller can adjust the irq error counts */
141
static void poll_spurious_irqs(unsigned long dummy)
143
struct irq_desc *desc;
146
if (atomic_inc_return(&irq_poll_active) != 1)
148
irq_poll_cpu = smp_processor_id();
150
for_each_irq_desc(i, desc) {
156
/* Racy but it doesn't matter */
157
state = desc->istate;
159
if (!(state & IRQS_SPURIOUS_DISABLED))
163
try_one_irq(i, desc, true);
167
atomic_dec(&irq_poll_active);
168
mod_timer(&poll_spurious_irq_timer,
169
jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
172
static inline int bad_action_ret(irqreturn_t action_ret)
174
if (likely(action_ret <= (IRQ_HANDLED | IRQ_WAKE_THREAD)))
180
* If 99,900 of the previous 100,000 interrupts have not been handled
181
* then assume that the IRQ is stuck in some manner. Drop a diagnostic
182
* and try to turn the IRQ off.
184
* (The other 100-of-100,000 interrupts may have been a correctly
185
* functioning device sharing an IRQ with the failing one)
188
__report_bad_irq(unsigned int irq, struct irq_desc *desc,
189
irqreturn_t action_ret)
191
struct irqaction *action;
194
if (bad_action_ret(action_ret)) {
195
printk(KERN_ERR "irq event %d: bogus return value %x\n",
198
printk(KERN_ERR "irq %d: nobody cared (try booting with "
199
"the \"irqpoll\" option)\n", irq);
202
printk(KERN_ERR "handlers:\n");
205
* We need to take desc->lock here. note_interrupt() is called
206
* w/o desc->lock held, but IRQ_PROGRESS set. We might race
207
* with something else removing an action. It's ok to take
208
* desc->lock here. See synchronize_irq().
210
raw_spin_lock_irqsave(&desc->lock, flags);
211
action = desc->action;
213
printk(KERN_ERR "[<%p>] %pf", action->handler, action->handler);
214
if (action->thread_fn)
215
printk(KERN_CONT " threaded [<%p>] %pf",
216
action->thread_fn, action->thread_fn);
217
printk(KERN_CONT "\n");
218
action = action->next;
220
raw_spin_unlock_irqrestore(&desc->lock, flags);
224
report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret)
226
static int count = 100;
230
__report_bad_irq(irq, desc, action_ret);
235
try_misrouted_irq(unsigned int irq, struct irq_desc *desc,
236
irqreturn_t action_ret)
238
struct irqaction *action;
243
/* We didn't actually handle the IRQ - see if it was misrouted? */
244
if (action_ret == IRQ_NONE)
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)
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.
264
action = desc->action;
266
return action && (action->flags & IRQF_IRQPOLL);
269
void note_interrupt(unsigned int irq, struct irq_desc *desc,
270
irqreturn_t action_ret)
272
if (desc->istate & IRQS_POLL_INPROGRESS)
275
/* we get here again via the threaded handler */
276
if (action_ret == IRQ_WAKE_THREAD)
279
if (bad_action_ret(action_ret)) {
280
report_bad_irq(irq, desc, action_ret);
284
if (unlikely(action_ret == IRQ_NONE)) {
286
* If we are seeing only the odd spurious IRQ caused by
287
* bus asynchronicity then don't eventually trigger an error,
288
* otherwise the counter becomes a doomsday timer for otherwise
291
if (time_after(jiffies, desc->last_unhandled + HZ/10))
292
desc->irqs_unhandled = 1;
294
desc->irqs_unhandled++;
295
desc->last_unhandled = jiffies;
298
if (unlikely(try_misrouted_irq(irq, desc, action_ret))) {
299
int ok = misrouted_irq(irq);
300
if (action_ret == IRQ_NONE)
301
desc->irqs_unhandled -= ok;
305
if (likely(desc->irq_count < 100000))
309
if (unlikely(desc->irqs_unhandled > 99900)) {
311
* The interrupt is stuck
313
__report_bad_irq(irq, desc, action_ret);
317
printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
318
desc->istate |= IRQS_SPURIOUS_DISABLED;
322
mod_timer(&poll_spurious_irq_timer,
323
jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
325
desc->irqs_unhandled = 0;
328
int noirqdebug __read_mostly;
330
int noirqdebug_setup(char *str)
333
printk(KERN_INFO "IRQ lockup detection disabled\n");
338
__setup("noirqdebug", noirqdebug_setup);
339
module_param(noirqdebug, bool, 0644);
340
MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true");
342
static int __init irqfixup_setup(char *str)
345
printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n");
346
printk(KERN_WARNING "This may impact system performance.\n");
351
__setup("irqfixup", irqfixup_setup);
352
module_param(irqfixup, int, 0644);
354
static int __init irqpoll_setup(char *str)
357
printk(KERN_WARNING "Misrouted IRQ fixup and polling support "
359
printk(KERN_WARNING "This may significantly impact system "
364
__setup("irqpoll", irqpoll_setup);