]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/kernel/irq/spurious.c | |
3 | * | |
4 | * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar | |
5 | * | |
6 | * This file contains spurious interrupt handling. | |
7 | */ | |
8 | ||
188fd89d | 9 | #include <linux/jiffies.h> |
1da177e4 LT |
10 | #include <linux/irq.h> |
11 | #include <linux/module.h> | |
12 | #include <linux/kallsyms.h> | |
13 | #include <linux/interrupt.h> | |
9e094c17 | 14 | #include <linux/moduleparam.h> |
f84dbb91 | 15 | #include <linux/timer.h> |
1da177e4 | 16 | |
bd151412 TG |
17 | #include "internals.h" |
18 | ||
83d4e6e7 | 19 | static int irqfixup __read_mostly; |
200803df | 20 | |
f84dbb91 EB |
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); | |
d05c65ff TG |
24 | static int irq_poll_cpu; |
25 | static atomic_t irq_poll_active; | |
f84dbb91 | 26 | |
fe200ae4 TG |
27 | /* |
28 | * We wait here for a poller to finish. | |
29 | * | |
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. | |
33 | * | |
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. | |
37 | */ | |
38 | bool irq_wait_for_poll(struct irq_desc *desc) | |
39 | { | |
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)) | |
43 | return false; | |
44 | ||
45 | #ifdef CONFIG_SMP | |
46 | do { | |
47 | raw_spin_unlock(&desc->lock); | |
009b4c3b | 48 | while (desc->istate & IRQS_INPROGRESS) |
fe200ae4 TG |
49 | cpu_relax(); |
50 | raw_spin_lock(&desc->lock); | |
009b4c3b | 51 | } while (desc->istate & IRQS_INPROGRESS); |
fe200ae4 | 52 | /* Might have been disabled in meantime */ |
c1594b77 | 53 | return !(desc->istate & IRQS_DISABLED) && desc->action; |
fe200ae4 TG |
54 | #else |
55 | return false; | |
56 | #endif | |
57 | } | |
58 | ||
0877d662 | 59 | |
200803df AC |
60 | /* |
61 | * Recovery handler for misrouted interrupts. | |
62 | */ | |
c7259cd7 | 63 | static int try_one_irq(int irq, struct irq_desc *desc, bool force) |
200803df | 64 | { |
0877d662 | 65 | irqreturn_t ret = IRQ_NONE; |
f84dbb91 | 66 | struct irqaction *action; |
200803df | 67 | |
239007b8 | 68 | raw_spin_lock(&desc->lock); |
c7259cd7 TG |
69 | |
70 | /* PER_CPU and nested thread interrupts are never polled */ | |
1ccb4e61 | 71 | if (irq_settings_is_per_cpu(desc) || irq_settings_is_nested_thread(desc)) |
c7259cd7 TG |
72 | goto out; |
73 | ||
74 | /* | |
75 | * Do not poll disabled interrupts unless the spurious | |
76 | * disabled poller asks explicitely. | |
77 | */ | |
c1594b77 | 78 | if ((desc->istate & IRQS_DISABLED) && !force) |
c7259cd7 TG |
79 | goto out; |
80 | ||
81 | /* | |
82 | * All handlers must agree on IRQF_SHARED, so we test just the | |
83 | * first. Check for action->next as well. | |
84 | */ | |
85 | action = desc->action; | |
86 | if (!action || !(action->flags & IRQF_SHARED) || | |
87 | (action->flags & __IRQF_TIMER) || !action->next) | |
88 | goto out; | |
89 | ||
f84dbb91 | 90 | /* Already running on another processor */ |
009b4c3b | 91 | if (desc->istate & IRQS_INPROGRESS) { |
f84dbb91 EB |
92 | /* |
93 | * Already running: If it is shared get the other | |
94 | * CPU to go looking for our mystery interrupt too | |
95 | */ | |
2a0d6fb3 TG |
96 | irq_compat_set_pending(desc); |
97 | desc->istate |= IRQS_PENDING; | |
fa27271b | 98 | goto out; |
c7259cd7 | 99 | } |
fa27271b | 100 | |
0877d662 | 101 | /* Mark it poll in progress */ |
6954b75b | 102 | desc->istate |= IRQS_POLL_INPROGRESS; |
fa27271b | 103 | do { |
0877d662 TG |
104 | if (handle_irq_event(desc) == IRQ_HANDLED) |
105 | ret = IRQ_HANDLED; | |
fa27271b | 106 | action = desc->action; |
2a0d6fb3 | 107 | } while ((desc->istate & IRQS_PENDING) && action); |
6954b75b | 108 | desc->istate &= ~IRQS_POLL_INPROGRESS; |
fa27271b TG |
109 | out: |
110 | raw_spin_unlock(&desc->lock); | |
0877d662 | 111 | return ret == IRQ_HANDLED; |
f84dbb91 EB |
112 | } |
113 | ||
114 | static int misrouted_irq(int irq) | |
115 | { | |
e00585bb | 116 | struct irq_desc *desc; |
d3c60047 | 117 | int i, ok = 0; |
f84dbb91 | 118 | |
d05c65ff TG |
119 | if (atomic_inc_return(&irq_poll_active) == 1) |
120 | goto out; | |
121 | ||
122 | irq_poll_cpu = smp_processor_id(); | |
123 | ||
e00585bb YL |
124 | for_each_irq_desc(i, desc) { |
125 | if (!i) | |
126 | continue; | |
f84dbb91 EB |
127 | |
128 | if (i == irq) /* Already tried */ | |
129 | continue; | |
130 | ||
c7259cd7 | 131 | if (try_one_irq(i, desc, false)) |
f84dbb91 | 132 | ok = 1; |
200803df | 133 | } |
d05c65ff TG |
134 | out: |
135 | atomic_dec(&irq_poll_active); | |
200803df AC |
136 | /* So the caller can adjust the irq error counts */ |
137 | return ok; | |
138 | } | |
139 | ||
663e6959 | 140 | static void poll_spurious_irqs(unsigned long dummy) |
f84dbb91 | 141 | { |
e00585bb | 142 | struct irq_desc *desc; |
d3c60047 | 143 | int i; |
e00585bb | 144 | |
d05c65ff TG |
145 | if (atomic_inc_return(&irq_poll_active) != 1) |
146 | goto out; | |
147 | irq_poll_cpu = smp_processor_id(); | |
148 | ||
e00585bb | 149 | for_each_irq_desc(i, desc) { |
7acdd53e | 150 | unsigned int state; |
f84dbb91 | 151 | |
e00585bb YL |
152 | if (!i) |
153 | continue; | |
154 | ||
f84dbb91 | 155 | /* Racy but it doesn't matter */ |
7acdd53e | 156 | state = desc->istate; |
f84dbb91 | 157 | barrier(); |
7acdd53e | 158 | if (!(state & IRQS_SPURIOUS_DISABLED)) |
f84dbb91 EB |
159 | continue; |
160 | ||
e7e7e0c0 | 161 | local_irq_disable(); |
c7259cd7 | 162 | try_one_irq(i, desc, true); |
e7e7e0c0 | 163 | local_irq_enable(); |
f84dbb91 | 164 | } |
d05c65ff TG |
165 | out: |
166 | atomic_dec(&irq_poll_active); | |
d3c60047 TG |
167 | mod_timer(&poll_spurious_irq_timer, |
168 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
f84dbb91 EB |
169 | } |
170 | ||
1da177e4 LT |
171 | /* |
172 | * If 99,900 of the previous 100,000 interrupts have not been handled | |
173 | * then assume that the IRQ is stuck in some manner. Drop a diagnostic | |
174 | * and try to turn the IRQ off. | |
175 | * | |
176 | * (The other 100-of-100,000 interrupts may have been a correctly | |
177 | * functioning device sharing an IRQ with the failing one) | |
1da177e4 | 178 | */ |
1da177e4 | 179 | static void |
34ffdb72 IM |
180 | __report_bad_irq(unsigned int irq, struct irq_desc *desc, |
181 | irqreturn_t action_ret) | |
1da177e4 LT |
182 | { |
183 | struct irqaction *action; | |
1082687e | 184 | unsigned long flags; |
1da177e4 LT |
185 | |
186 | if (action_ret != IRQ_HANDLED && action_ret != IRQ_NONE) { | |
187 | printk(KERN_ERR "irq event %d: bogus return value %x\n", | |
188 | irq, action_ret); | |
189 | } else { | |
200803df AC |
190 | printk(KERN_ERR "irq %d: nobody cared (try booting with " |
191 | "the \"irqpoll\" option)\n", irq); | |
1da177e4 LT |
192 | } |
193 | dump_stack(); | |
194 | printk(KERN_ERR "handlers:\n"); | |
06fcb0c6 | 195 | |
1082687e TG |
196 | /* |
197 | * We need to take desc->lock here. note_interrupt() is called | |
198 | * w/o desc->lock held, but IRQ_PROGRESS set. We might race | |
199 | * with something else removing an action. It's ok to take | |
200 | * desc->lock here. See synchronize_irq(). | |
201 | */ | |
202 | raw_spin_lock_irqsave(&desc->lock, flags); | |
1da177e4 LT |
203 | action = desc->action; |
204 | while (action) { | |
205 | printk(KERN_ERR "[<%p>]", action->handler); | |
206 | print_symbol(" (%s)", | |
207 | (unsigned long)action->handler); | |
208 | printk("\n"); | |
209 | action = action->next; | |
210 | } | |
1082687e | 211 | raw_spin_unlock_irqrestore(&desc->lock, flags); |
1da177e4 LT |
212 | } |
213 | ||
06fcb0c6 | 214 | static void |
34ffdb72 | 215 | report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret) |
1da177e4 LT |
216 | { |
217 | static int count = 100; | |
218 | ||
219 | if (count > 0) { | |
220 | count--; | |
221 | __report_bad_irq(irq, desc, action_ret); | |
222 | } | |
223 | } | |
224 | ||
d3c60047 TG |
225 | static inline int |
226 | try_misrouted_irq(unsigned int irq, struct irq_desc *desc, | |
227 | irqreturn_t action_ret) | |
92ea7727 LT |
228 | { |
229 | struct irqaction *action; | |
230 | ||
231 | if (!irqfixup) | |
232 | return 0; | |
233 | ||
234 | /* We didn't actually handle the IRQ - see if it was misrouted? */ | |
235 | if (action_ret == IRQ_NONE) | |
236 | return 1; | |
237 | ||
238 | /* | |
239 | * But for 'irqfixup == 2' we also do it for handled interrupts if | |
240 | * they are marked as IRQF_IRQPOLL (or for irq zero, which is the | |
241 | * traditional PC timer interrupt.. Legacy) | |
242 | */ | |
243 | if (irqfixup < 2) | |
244 | return 0; | |
245 | ||
246 | if (!irq) | |
247 | return 1; | |
248 | ||
249 | /* | |
250 | * Since we don't get the descriptor lock, "action" can | |
251 | * change under us. We don't really care, but we don't | |
252 | * want to follow a NULL pointer. So tell the compiler to | |
253 | * just load it once by using a barrier. | |
254 | */ | |
255 | action = desc->action; | |
256 | barrier(); | |
257 | return action && (action->flags & IRQF_IRQPOLL); | |
258 | } | |
259 | ||
34ffdb72 | 260 | void note_interrupt(unsigned int irq, struct irq_desc *desc, |
7d12e780 | 261 | irqreturn_t action_ret) |
1da177e4 | 262 | { |
6954b75b | 263 | if (desc->istate & IRQS_POLL_INPROGRESS) |
fe200ae4 TG |
264 | return; |
265 | ||
83d4e6e7 | 266 | if (unlikely(action_ret != IRQ_HANDLED)) { |
4f27c00b AC |
267 | /* |
268 | * If we are seeing only the odd spurious IRQ caused by | |
269 | * bus asynchronicity then don't eventually trigger an error, | |
fbfecd37 | 270 | * otherwise the counter becomes a doomsday timer for otherwise |
4f27c00b AC |
271 | * working systems |
272 | */ | |
188fd89d | 273 | if (time_after(jiffies, desc->last_unhandled + HZ/10)) |
4f27c00b AC |
274 | desc->irqs_unhandled = 1; |
275 | else | |
276 | desc->irqs_unhandled++; | |
277 | desc->last_unhandled = jiffies; | |
83d4e6e7 | 278 | if (unlikely(action_ret != IRQ_NONE)) |
1da177e4 LT |
279 | report_bad_irq(irq, desc, action_ret); |
280 | } | |
281 | ||
92ea7727 LT |
282 | if (unlikely(try_misrouted_irq(irq, desc, action_ret))) { |
283 | int ok = misrouted_irq(irq); | |
284 | if (action_ret == IRQ_NONE) | |
285 | desc->irqs_unhandled -= ok; | |
200803df AC |
286 | } |
287 | ||
1da177e4 | 288 | desc->irq_count++; |
83d4e6e7 | 289 | if (likely(desc->irq_count < 100000)) |
1da177e4 LT |
290 | return; |
291 | ||
292 | desc->irq_count = 0; | |
83d4e6e7 | 293 | if (unlikely(desc->irqs_unhandled > 99900)) { |
1da177e4 LT |
294 | /* |
295 | * The interrupt is stuck | |
296 | */ | |
297 | __report_bad_irq(irq, desc, action_ret); | |
298 | /* | |
299 | * Now kill the IRQ | |
300 | */ | |
301 | printk(KERN_EMERG "Disabling IRQ #%d\n", irq); | |
7acdd53e | 302 | desc->istate |= IRQS_SPURIOUS_DISABLED; |
1adb0850 | 303 | desc->depth++; |
87923470 | 304 | irq_disable(desc); |
f84dbb91 | 305 | |
d3c60047 TG |
306 | mod_timer(&poll_spurious_irq_timer, |
307 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
1da177e4 LT |
308 | } |
309 | desc->irqs_unhandled = 0; | |
310 | } | |
311 | ||
83d4e6e7 | 312 | int noirqdebug __read_mostly; |
1da177e4 | 313 | |
343cde51 | 314 | int noirqdebug_setup(char *str) |
1da177e4 LT |
315 | { |
316 | noirqdebug = 1; | |
317 | printk(KERN_INFO "IRQ lockup detection disabled\n"); | |
06fcb0c6 | 318 | |
1da177e4 LT |
319 | return 1; |
320 | } | |
321 | ||
322 | __setup("noirqdebug", noirqdebug_setup); | |
9e094c17 AK |
323 | module_param(noirqdebug, bool, 0644); |
324 | MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true"); | |
1da177e4 | 325 | |
200803df AC |
326 | static int __init irqfixup_setup(char *str) |
327 | { | |
328 | irqfixup = 1; | |
329 | printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n"); | |
330 | printk(KERN_WARNING "This may impact system performance.\n"); | |
06fcb0c6 | 331 | |
200803df AC |
332 | return 1; |
333 | } | |
334 | ||
335 | __setup("irqfixup", irqfixup_setup); | |
9e094c17 | 336 | module_param(irqfixup, int, 0644); |
200803df AC |
337 | |
338 | static int __init irqpoll_setup(char *str) | |
339 | { | |
340 | irqfixup = 2; | |
341 | printk(KERN_WARNING "Misrouted IRQ fixup and polling support " | |
342 | "enabled\n"); | |
343 | printk(KERN_WARNING "This may significantly impact system " | |
344 | "performance\n"); | |
345 | return 1; | |
346 | } | |
347 | ||
348 | __setup("irqpoll", irqpoll_setup); |