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 | |
83d4e6e7 | 17 | static int irqfixup __read_mostly; |
200803df | 18 | |
f84dbb91 EB |
19 | #define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10) |
20 | static void poll_spurious_irqs(unsigned long dummy); | |
21 | static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs, 0, 0); | |
22 | ||
200803df AC |
23 | /* |
24 | * Recovery handler for misrouted interrupts. | |
25 | */ | |
f84dbb91 | 26 | static int try_one_irq(int irq, struct irq_desc *desc) |
200803df | 27 | { |
f84dbb91 | 28 | struct irqaction *action; |
d3c60047 | 29 | int ok = 0, work = 0; |
200803df | 30 | |
f84dbb91 EB |
31 | spin_lock(&desc->lock); |
32 | /* Already running on another processor */ | |
33 | if (desc->status & IRQ_INPROGRESS) { | |
34 | /* | |
35 | * Already running: If it is shared get the other | |
36 | * CPU to go looking for our mystery interrupt too | |
37 | */ | |
38 | if (desc->action && (desc->action->flags & IRQF_SHARED)) | |
39 | desc->status |= IRQ_PENDING; | |
200803df | 40 | spin_unlock(&desc->lock); |
f84dbb91 EB |
41 | return ok; |
42 | } | |
43 | /* Honour the normal IRQ locking */ | |
44 | desc->status |= IRQ_INPROGRESS; | |
45 | action = desc->action; | |
46 | spin_unlock(&desc->lock); | |
06fcb0c6 | 47 | |
f84dbb91 EB |
48 | while (action) { |
49 | /* Only shared IRQ handlers are safe to call */ | |
50 | if (action->flags & IRQF_SHARED) { | |
51 | if (action->handler(irq, action->dev_id) == | |
52 | IRQ_HANDLED) | |
53 | ok = 1; | |
200803df | 54 | } |
f84dbb91 EB |
55 | action = action->next; |
56 | } | |
57 | local_irq_disable(); | |
58 | /* Now clean up the flags */ | |
59 | spin_lock(&desc->lock); | |
60 | action = desc->action; | |
200803df | 61 | |
f84dbb91 EB |
62 | /* |
63 | * While we were looking for a fixup someone queued a real | |
64 | * IRQ clashing with our walk: | |
65 | */ | |
66 | while ((desc->status & IRQ_PENDING) && action) { | |
200803df | 67 | /* |
f84dbb91 | 68 | * Perform real IRQ processing for the IRQ we deferred |
200803df | 69 | */ |
f84dbb91 | 70 | work = 1; |
200803df | 71 | spin_unlock(&desc->lock); |
f84dbb91 EB |
72 | handle_IRQ_event(irq, action); |
73 | spin_lock(&desc->lock); | |
74 | desc->status &= ~IRQ_PENDING; | |
75 | } | |
76 | desc->status &= ~IRQ_INPROGRESS; | |
77 | /* | |
78 | * If we did actual work for the real IRQ line we must let the | |
79 | * IRQ controller clean up too | |
80 | */ | |
81 | if (work && desc->chip && desc->chip->end) | |
82 | desc->chip->end(irq); | |
83 | spin_unlock(&desc->lock); | |
84 | ||
85 | return ok; | |
86 | } | |
87 | ||
88 | static int misrouted_irq(int irq) | |
89 | { | |
e00585bb | 90 | struct irq_desc *desc; |
d3c60047 | 91 | int i, ok = 0; |
f84dbb91 | 92 | |
e00585bb YL |
93 | for_each_irq_desc(i, desc) { |
94 | if (!i) | |
95 | continue; | |
f84dbb91 EB |
96 | |
97 | if (i == irq) /* Already tried */ | |
98 | continue; | |
99 | ||
100 | if (try_one_irq(i, desc)) | |
101 | ok = 1; | |
200803df AC |
102 | } |
103 | /* So the caller can adjust the irq error counts */ | |
104 | return ok; | |
105 | } | |
106 | ||
74296a8e | 107 | static void poll_all_shared_irqs(void) |
f84dbb91 | 108 | { |
e00585bb | 109 | struct irq_desc *desc; |
d3c60047 | 110 | int i; |
e00585bb YL |
111 | |
112 | for_each_irq_desc(i, desc) { | |
f84dbb91 EB |
113 | unsigned int status; |
114 | ||
e00585bb YL |
115 | if (!i) |
116 | continue; | |
117 | ||
f84dbb91 EB |
118 | /* Racy but it doesn't matter */ |
119 | status = desc->status; | |
120 | barrier(); | |
121 | if (!(status & IRQ_SPURIOUS_DISABLED)) | |
122 | continue; | |
123 | ||
124 | try_one_irq(i, desc); | |
125 | } | |
74296a8e IM |
126 | } |
127 | ||
128 | static void poll_spurious_irqs(unsigned long dummy) | |
129 | { | |
130 | poll_all_shared_irqs(); | |
f84dbb91 | 131 | |
d3c60047 TG |
132 | mod_timer(&poll_spurious_irq_timer, |
133 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
f84dbb91 EB |
134 | } |
135 | ||
74296a8e IM |
136 | #ifdef CONFIG_DEBUG_SHIRQ |
137 | void debug_poll_all_shared_irqs(void) | |
138 | { | |
139 | poll_all_shared_irqs(); | |
140 | } | |
141 | #endif | |
142 | ||
1da177e4 LT |
143 | /* |
144 | * If 99,900 of the previous 100,000 interrupts have not been handled | |
145 | * then assume that the IRQ is stuck in some manner. Drop a diagnostic | |
146 | * and try to turn the IRQ off. | |
147 | * | |
148 | * (The other 100-of-100,000 interrupts may have been a correctly | |
149 | * functioning device sharing an IRQ with the failing one) | |
150 | * | |
151 | * Called under desc->lock | |
152 | */ | |
153 | ||
154 | static void | |
34ffdb72 IM |
155 | __report_bad_irq(unsigned int irq, struct irq_desc *desc, |
156 | irqreturn_t action_ret) | |
1da177e4 LT |
157 | { |
158 | struct irqaction *action; | |
159 | ||
160 | if (action_ret != IRQ_HANDLED && action_ret != IRQ_NONE) { | |
161 | printk(KERN_ERR "irq event %d: bogus return value %x\n", | |
162 | irq, action_ret); | |
163 | } else { | |
200803df AC |
164 | printk(KERN_ERR "irq %d: nobody cared (try booting with " |
165 | "the \"irqpoll\" option)\n", irq); | |
1da177e4 LT |
166 | } |
167 | dump_stack(); | |
168 | printk(KERN_ERR "handlers:\n"); | |
06fcb0c6 | 169 | |
1da177e4 LT |
170 | action = desc->action; |
171 | while (action) { | |
172 | printk(KERN_ERR "[<%p>]", action->handler); | |
173 | print_symbol(" (%s)", | |
174 | (unsigned long)action->handler); | |
175 | printk("\n"); | |
176 | action = action->next; | |
177 | } | |
178 | } | |
179 | ||
06fcb0c6 | 180 | static void |
34ffdb72 | 181 | report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret) |
1da177e4 LT |
182 | { |
183 | static int count = 100; | |
184 | ||
185 | if (count > 0) { | |
186 | count--; | |
187 | __report_bad_irq(irq, desc, action_ret); | |
188 | } | |
189 | } | |
190 | ||
d3c60047 TG |
191 | static inline int |
192 | try_misrouted_irq(unsigned int irq, struct irq_desc *desc, | |
193 | irqreturn_t action_ret) | |
92ea7727 LT |
194 | { |
195 | struct irqaction *action; | |
196 | ||
197 | if (!irqfixup) | |
198 | return 0; | |
199 | ||
200 | /* We didn't actually handle the IRQ - see if it was misrouted? */ | |
201 | if (action_ret == IRQ_NONE) | |
202 | return 1; | |
203 | ||
204 | /* | |
205 | * But for 'irqfixup == 2' we also do it for handled interrupts if | |
206 | * they are marked as IRQF_IRQPOLL (or for irq zero, which is the | |
207 | * traditional PC timer interrupt.. Legacy) | |
208 | */ | |
209 | if (irqfixup < 2) | |
210 | return 0; | |
211 | ||
212 | if (!irq) | |
213 | return 1; | |
214 | ||
215 | /* | |
216 | * Since we don't get the descriptor lock, "action" can | |
217 | * change under us. We don't really care, but we don't | |
218 | * want to follow a NULL pointer. So tell the compiler to | |
219 | * just load it once by using a barrier. | |
220 | */ | |
221 | action = desc->action; | |
222 | barrier(); | |
223 | return action && (action->flags & IRQF_IRQPOLL); | |
224 | } | |
225 | ||
34ffdb72 | 226 | void note_interrupt(unsigned int irq, struct irq_desc *desc, |
7d12e780 | 227 | irqreturn_t action_ret) |
1da177e4 | 228 | { |
83d4e6e7 | 229 | if (unlikely(action_ret != IRQ_HANDLED)) { |
4f27c00b AC |
230 | /* |
231 | * If we are seeing only the odd spurious IRQ caused by | |
232 | * bus asynchronicity then don't eventually trigger an error, | |
233 | * otherwise the couter becomes a doomsday timer for otherwise | |
234 | * working systems | |
235 | */ | |
188fd89d | 236 | if (time_after(jiffies, desc->last_unhandled + HZ/10)) |
4f27c00b AC |
237 | desc->irqs_unhandled = 1; |
238 | else | |
239 | desc->irqs_unhandled++; | |
240 | desc->last_unhandled = jiffies; | |
83d4e6e7 | 241 | if (unlikely(action_ret != IRQ_NONE)) |
1da177e4 LT |
242 | report_bad_irq(irq, desc, action_ret); |
243 | } | |
244 | ||
92ea7727 LT |
245 | if (unlikely(try_misrouted_irq(irq, desc, action_ret))) { |
246 | int ok = misrouted_irq(irq); | |
247 | if (action_ret == IRQ_NONE) | |
248 | desc->irqs_unhandled -= ok; | |
200803df AC |
249 | } |
250 | ||
1da177e4 | 251 | desc->irq_count++; |
83d4e6e7 | 252 | if (likely(desc->irq_count < 100000)) |
1da177e4 LT |
253 | return; |
254 | ||
255 | desc->irq_count = 0; | |
83d4e6e7 | 256 | if (unlikely(desc->irqs_unhandled > 99900)) { |
1da177e4 LT |
257 | /* |
258 | * The interrupt is stuck | |
259 | */ | |
260 | __report_bad_irq(irq, desc, action_ret); | |
261 | /* | |
262 | * Now kill the IRQ | |
263 | */ | |
264 | printk(KERN_EMERG "Disabling IRQ #%d\n", irq); | |
1adb0850 TG |
265 | desc->status |= IRQ_DISABLED | IRQ_SPURIOUS_DISABLED; |
266 | desc->depth++; | |
d1bef4ed | 267 | desc->chip->disable(irq); |
f84dbb91 | 268 | |
d3c60047 TG |
269 | mod_timer(&poll_spurious_irq_timer, |
270 | jiffies + POLL_SPURIOUS_IRQ_INTERVAL); | |
1da177e4 LT |
271 | } |
272 | desc->irqs_unhandled = 0; | |
273 | } | |
274 | ||
83d4e6e7 | 275 | int noirqdebug __read_mostly; |
1da177e4 | 276 | |
343cde51 | 277 | int noirqdebug_setup(char *str) |
1da177e4 LT |
278 | { |
279 | noirqdebug = 1; | |
280 | printk(KERN_INFO "IRQ lockup detection disabled\n"); | |
06fcb0c6 | 281 | |
1da177e4 LT |
282 | return 1; |
283 | } | |
284 | ||
285 | __setup("noirqdebug", noirqdebug_setup); | |
9e094c17 AK |
286 | module_param(noirqdebug, bool, 0644); |
287 | MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true"); | |
1da177e4 | 288 | |
200803df AC |
289 | static int __init irqfixup_setup(char *str) |
290 | { | |
291 | irqfixup = 1; | |
292 | printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n"); | |
293 | printk(KERN_WARNING "This may impact system performance.\n"); | |
06fcb0c6 | 294 | |
200803df AC |
295 | return 1; |
296 | } | |
297 | ||
298 | __setup("irqfixup", irqfixup_setup); | |
9e094c17 | 299 | module_param(irqfixup, int, 0644); |
200803df AC |
300 | |
301 | static int __init irqpoll_setup(char *str) | |
302 | { | |
303 | irqfixup = 2; | |
304 | printk(KERN_WARNING "Misrouted IRQ fixup and polling support " | |
305 | "enabled\n"); | |
306 | printk(KERN_WARNING "This may significantly impact system " | |
307 | "performance\n"); | |
308 | return 1; | |
309 | } | |
310 | ||
311 | __setup("irqpoll", irqpoll_setup); |