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