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