]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - kernel/irq/spurious.c
[PATCH] irq-flags: XTENSA: Use the new IRQF_ constants
[mirror_ubuntu-artful-kernel.git] / kernel / irq / spurious.c
CommitLineData
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
9#include <linux/irq.h>
10#include <linux/module.h>
11#include <linux/kallsyms.h>
12#include <linux/interrupt.h>
13
83d4e6e7 14static int irqfixup __read_mostly;
200803df
AC
15
16/*
17 * Recovery handler for misrouted interrupts.
18 */
200803df
AC
19static int misrouted_irq(int irq, struct pt_regs *regs)
20{
21 int i;
200803df
AC
22 int ok = 0;
23 int work = 0; /* Did we do work for a real IRQ */
24
06fcb0c6
IM
25 for (i = 1; i < NR_IRQS; i++) {
26 struct irq_desc *desc = irq_desc + i;
200803df
AC
27 struct irqaction *action;
28
29 if (i == irq) /* Already tried */
30 continue;
06fcb0c6 31
200803df 32 spin_lock(&desc->lock);
200803df
AC
33 /* Already running on another processor */
34 if (desc->status & IRQ_INPROGRESS) {
35 /*
36 * Already running: If it is shared get the other
37 * CPU to go looking for our mystery interrupt too
38 */
39 if (desc->action && (desc->action->flags & SA_SHIRQ))
40 desc->status |= IRQ_PENDING;
41 spin_unlock(&desc->lock);
42 continue;
43 }
44 /* Honour the normal IRQ locking */
45 desc->status |= IRQ_INPROGRESS;
06fcb0c6 46 action = desc->action;
200803df 47 spin_unlock(&desc->lock);
06fcb0c6 48
200803df
AC
49 while (action) {
50 /* Only shared IRQ handlers are safe to call */
51 if (action->flags & SA_SHIRQ) {
52 if (action->handler(i, action->dev_id, regs) ==
53 IRQ_HANDLED)
54 ok = 1;
55 }
56 action = action->next;
57 }
58 local_irq_disable();
59 /* Now clean up the flags */
60 spin_lock(&desc->lock);
61 action = desc->action;
62
63 /*
64 * While we were looking for a fixup someone queued a real
06fcb0c6 65 * IRQ clashing with our walk:
200803df 66 */
200803df
AC
67 while ((desc->status & IRQ_PENDING) && action) {
68 /*
69 * Perform real IRQ processing for the IRQ we deferred
70 */
71 work = 1;
72 spin_unlock(&desc->lock);
73 handle_IRQ_event(i, regs, action);
74 spin_lock(&desc->lock);
75 desc->status &= ~IRQ_PENDING;
76 }
77 desc->status &= ~IRQ_INPROGRESS;
78 /*
79 * If we did actual work for the real IRQ line we must let the
80 * IRQ controller clean up too
81 */
dd87eb3a 82 if (work && desc->chip && desc->chip->end)
d1bef4ed 83 desc->chip->end(i);
200803df
AC
84 spin_unlock(&desc->lock);
85 }
86 /* So the caller can adjust the irq error counts */
87 return ok;
88}
89
1da177e4
LT
90/*
91 * If 99,900 of the previous 100,000 interrupts have not been handled
92 * then assume that the IRQ is stuck in some manner. Drop a diagnostic
93 * and try to turn the IRQ off.
94 *
95 * (The other 100-of-100,000 interrupts may have been a correctly
96 * functioning device sharing an IRQ with the failing one)
97 *
98 * Called under desc->lock
99 */
100
101static void
34ffdb72
IM
102__report_bad_irq(unsigned int irq, struct irq_desc *desc,
103 irqreturn_t action_ret)
1da177e4
LT
104{
105 struct irqaction *action;
106
107 if (action_ret != IRQ_HANDLED && action_ret != IRQ_NONE) {
108 printk(KERN_ERR "irq event %d: bogus return value %x\n",
109 irq, action_ret);
110 } else {
200803df
AC
111 printk(KERN_ERR "irq %d: nobody cared (try booting with "
112 "the \"irqpoll\" option)\n", irq);
1da177e4
LT
113 }
114 dump_stack();
115 printk(KERN_ERR "handlers:\n");
06fcb0c6 116
1da177e4
LT
117 action = desc->action;
118 while (action) {
119 printk(KERN_ERR "[<%p>]", action->handler);
120 print_symbol(" (%s)",
121 (unsigned long)action->handler);
122 printk("\n");
123 action = action->next;
124 }
125}
126
06fcb0c6 127static void
34ffdb72 128report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret)
1da177e4
LT
129{
130 static int count = 100;
131
132 if (count > 0) {
133 count--;
134 __report_bad_irq(irq, desc, action_ret);
135 }
136}
137
34ffdb72
IM
138void note_interrupt(unsigned int irq, struct irq_desc *desc,
139 irqreturn_t action_ret, struct pt_regs *regs)
1da177e4 140{
83d4e6e7 141 if (unlikely(action_ret != IRQ_HANDLED)) {
1da177e4 142 desc->irqs_unhandled++;
83d4e6e7 143 if (unlikely(action_ret != IRQ_NONE))
1da177e4
LT
144 report_bad_irq(irq, desc, action_ret);
145 }
146
200803df
AC
147 if (unlikely(irqfixup)) {
148 /* Don't punish working computers */
149 if ((irqfixup == 2 && irq == 0) || action_ret == IRQ_NONE) {
150 int ok = misrouted_irq(irq, regs);
151 if (action_ret == IRQ_NONE)
152 desc->irqs_unhandled -= ok;
153 }
154 }
155
1da177e4 156 desc->irq_count++;
83d4e6e7 157 if (likely(desc->irq_count < 100000))
1da177e4
LT
158 return;
159
160 desc->irq_count = 0;
83d4e6e7 161 if (unlikely(desc->irqs_unhandled > 99900)) {
1da177e4
LT
162 /*
163 * The interrupt is stuck
164 */
165 __report_bad_irq(irq, desc, action_ret);
166 /*
167 * Now kill the IRQ
168 */
169 printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
170 desc->status |= IRQ_DISABLED;
6a6de9ef 171 desc->depth = 1;
d1bef4ed 172 desc->chip->disable(irq);
1da177e4
LT
173 }
174 desc->irqs_unhandled = 0;
175}
176
83d4e6e7 177int noirqdebug __read_mostly;
1da177e4
LT
178
179int __init noirqdebug_setup(char *str)
180{
181 noirqdebug = 1;
182 printk(KERN_INFO "IRQ lockup detection disabled\n");
06fcb0c6 183
1da177e4
LT
184 return 1;
185}
186
187__setup("noirqdebug", noirqdebug_setup);
188
200803df
AC
189static int __init irqfixup_setup(char *str)
190{
191 irqfixup = 1;
192 printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n");
193 printk(KERN_WARNING "This may impact system performance.\n");
06fcb0c6 194
200803df
AC
195 return 1;
196}
197
198__setup("irqfixup", irqfixup_setup);
199
200static int __init irqpoll_setup(char *str)
201{
202 irqfixup = 2;
203 printk(KERN_WARNING "Misrouted IRQ fixup and polling support "
204 "enabled\n");
205 printk(KERN_WARNING "This may significantly impact system "
206 "performance\n");
207 return 1;
208}
209
210__setup("irqpoll", irqpoll_setup);