blob: 17c71bb565c6ed287901aaef1c201a3c70f79aef [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/irq/handle.c
3 *
Ingo Molnara34db9b2006-06-29 02:24:50 -07004 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This file contains the core interrupt handling code.
Ingo Molnara34db9b2006-06-29 02:24:50 -07008 *
9 * Detailed information is available in Documentation/DocBook/genericirq
10 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13#include <linux/irq.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040014#include <linux/sched.h>
Paul Mundt948cd522009-05-22 10:40:09 +090015#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/random.h>
18#include <linux/interrupt.h>
19#include <linux/kernel_stat.h>
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080020#include <linux/rculist.h>
21#include <linux/hash.h>
Mike Travis0fa0ebb2009-01-10 22:24:06 -080022#include <linux/bootmem.h>
Steven Rostedtad8d75f2009-04-14 19:39:12 -040023#include <trace/events/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include "internals.h"
26
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080027/*
28 * lockdep: we want to handle all irq_desc locks as a single lock-class:
29 */
Yinghai Lu48a1b102008-12-11 00:15:01 -080030struct lock_class_key irq_desc_lock_class;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080031
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -070032/**
33 * handle_bad_irq - handle spurious and unhandled irqs
Henrik Kretzschmar43a1dd52006-08-31 21:27:44 -070034 * @irq: the interrupt number
35 * @desc: description of the interrupt
Henrik Kretzschmar43a1dd52006-08-31 21:27:44 -070036 *
37 * Handles spurious and unhandled IRQ's. It also prints a debugmessage.
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -070038 */
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +020039void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -070040{
Ingo Molnar43f77752006-06-29 02:24:58 -070041 print_irq_desc(irq, desc);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +020042 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -070043 ack_bad_irq(irq);
44}
45
David Daney97179fd2009-01-27 09:53:22 -080046#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
47static void __init init_irq_default_affinity(void)
48{
Yinghai Lu28be2252009-06-12 11:33:02 +030049 alloc_cpumask_var(&irq_default_affinity, GFP_NOWAIT);
David Daney97179fd2009-01-27 09:53:22 -080050 cpumask_setall(irq_default_affinity);
51}
52#else
53static void __init init_irq_default_affinity(void)
54{
55}
56#endif
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058/*
59 * Linux has a controller-independent interrupt architecture.
60 * Every controller has a 'controller-template', that is used
61 * by the main code to do the right thing. Each driver-visible
Ingo Molnar06fcb0c2006-06-29 02:24:40 -070062 * interrupt source is transparently wired to the appropriate
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * controller. Thus drivers need not be aware of the
64 * interrupt-controller.
65 *
66 * The code is designed to be easily extended with new/different
67 * interrupt controllers, without having to do assembly magic or
68 * having to touch the generic code.
69 *
70 * Controller mappings for all interrupt sources:
71 */
Yinghai Lu85c0f902008-08-19 20:49:47 -070072int nr_irqs = NR_IRQS;
Ingo Molnarfa42d102008-08-19 20:50:30 -070073EXPORT_SYMBOL_GPL(nr_irqs);
Yinghai Lud60458b2008-08-19 20:50:00 -070074
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080075#ifdef CONFIG_SPARSE_IRQ
Mike Travis92296c62009-01-11 09:22:58 -080076
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080077static struct irq_desc irq_desc_init = {
78 .irq = -1,
79 .status = IRQ_DISABLED,
80 .chip = &no_irq_chip,
81 .handle_irq = handle_bad_irq,
82 .depth = 1,
83 .lock = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080084};
85
Paul Mundt948cd522009-05-22 10:40:09 +090086void __ref init_kstat_irqs(struct irq_desc *desc, int node, int nr)
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080087{
Yinghai Lu005bf0e62009-02-08 16:18:03 -080088 void *ptr;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080089
Paul Mundt948cd522009-05-22 10:40:09 +090090 if (slab_is_available())
91 ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs),
92 GFP_ATOMIC, node);
93 else
94 ptr = alloc_bootmem_node(NODE_DATA(node),
95 nr * sizeof(*desc->kstat_irqs));
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080096
Yinghai Lu005bf0e62009-02-08 16:18:03 -080097 /*
98 * don't overwite if can not get new one
99 * init_copy_kstat_irqs() could still use old one
100 */
101 if (ptr) {
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700102 printk(KERN_DEBUG " alloc kstat_irqs on node %d\n", node);
Yinghai Lu005bf0e62009-02-08 16:18:03 -0800103 desc->kstat_irqs = ptr;
104 }
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800105}
106
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700107static void init_one_irq_desc(int irq, struct irq_desc *desc, int node)
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800108{
109 memcpy(desc, &irq_desc_init, sizeof(struct irq_desc));
Ingo Molnar793f7b12008-12-26 19:02:20 +0100110
111 spin_lock_init(&desc->lock);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800112 desc->irq = irq;
113#ifdef CONFIG_SMP
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700114 desc->node = node;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800115#endif
116 lockdep_set_class(&desc->lock, &irq_desc_lock_class);
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700117 init_kstat_irqs(desc, node, nr_cpu_ids);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800118 if (!desc->kstat_irqs) {
119 printk(KERN_ERR "can not alloc kstat_irqs\n");
120 BUG_ON(1);
121 }
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700122 if (!alloc_desc_masks(desc, node, false)) {
Mike Travis7f7ace02009-01-10 21:58:08 -0800123 printk(KERN_ERR "can not alloc irq_desc cpumasks\n");
124 BUG_ON(1);
125 }
Yinghai Lu9ec4fa22009-04-27 17:57:18 -0700126 init_desc_masks(desc);
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700127 arch_init_chip_data(desc, node);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800128}
129
130/*
131 * Protect the sparse_irqs:
132 */
Yinghai Lu48a1b102008-12-11 00:15:01 -0800133DEFINE_SPINLOCK(sparse_irq_lock);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800134
Mike Travis0fa0ebb2009-01-10 22:24:06 -0800135struct irq_desc **irq_desc_ptrs __read_mostly;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800136
Yinghai Lu99d093d2008-12-05 18:58:32 -0800137static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_smp = {
138 [0 ... NR_IRQS_LEGACY-1] = {
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800139 .irq = -1,
140 .status = IRQ_DISABLED,
141 .chip = &no_irq_chip,
142 .handle_irq = handle_bad_irq,
143 .depth = 1,
144 .lock = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800145 }
146};
147
Mike Travis542d8652009-01-10 22:24:07 -0800148static unsigned int *kstat_irqs_legacy;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800149
Yinghai Lu13a0c3c2008-12-26 02:05:47 -0800150int __init early_irq_init(void)
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800151{
152 struct irq_desc *desc;
153 int legacy_count;
Yinghai Ludad213a2009-05-28 18:14:40 -0700154 int node;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800155 int i;
156
David Daney97179fd2009-01-27 09:53:22 -0800157 init_irq_default_affinity();
158
Yinghai Lu4a046d12009-01-12 17:39:24 -0800159 /* initialize nr_irqs based on nr_cpu_ids */
160 arch_probe_nr_irqs();
Mike Travis95949492009-01-10 22:24:06 -0800161 printk(KERN_INFO "NR_IRQS:%d nr_irqs:%d\n", NR_IRQS, nr_irqs);
162
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800163 desc = irq_desc_legacy;
164 legacy_count = ARRAY_SIZE(irq_desc_legacy);
Yinghai Lu372e24b2009-08-26 16:20:13 -0700165 node = first_online_node;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800166
Mike Travis0fa0ebb2009-01-10 22:24:06 -0800167 /* allocate irq_desc_ptrs array based on nr_irqs */
Pekka Enberg22fb4e72009-06-11 14:46:49 +0300168 irq_desc_ptrs = kcalloc(nr_irqs, sizeof(void *), GFP_NOWAIT);
Mike Travis0fa0ebb2009-01-10 22:24:06 -0800169
Mike Travis542d8652009-01-10 22:24:07 -0800170 /* allocate based on nr_cpu_ids */
Yinghai Ludad213a2009-05-28 18:14:40 -0700171 kstat_irqs_legacy = kzalloc_node(NR_IRQS_LEGACY * nr_cpu_ids *
172 sizeof(int), GFP_NOWAIT, node);
Mike Travis542d8652009-01-10 22:24:07 -0800173
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800174 for (i = 0; i < legacy_count; i++) {
175 desc[i].irq = i;
Yinghai Lu372e24b2009-08-26 16:20:13 -0700176#ifdef CONFIG_SMP
177 desc[i].node = node;
178#endif
Mike Travis542d8652009-01-10 22:24:07 -0800179 desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
Yinghai Lufa6beb32008-12-22 20:24:09 -0800180 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
Yinghai Ludad213a2009-05-28 18:14:40 -0700181 alloc_desc_masks(&desc[i], node, true);
Yinghai Lu9ec4fa22009-04-27 17:57:18 -0700182 init_desc_masks(&desc[i]);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800183 irq_desc_ptrs[i] = desc + i;
184 }
185
Mike Travis95949492009-01-10 22:24:06 -0800186 for (i = legacy_count; i < nr_irqs; i++)
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800187 irq_desc_ptrs[i] = NULL;
188
Yinghai Lu13a0c3c2008-12-26 02:05:47 -0800189 return arch_early_irq_init();
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800190}
191
192struct irq_desc *irq_to_desc(unsigned int irq)
193{
Mike Travis0fa0ebb2009-01-10 22:24:06 -0800194 if (irq_desc_ptrs && irq < nr_irqs)
195 return irq_desc_ptrs[irq];
196
197 return NULL;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800198}
199
Paul Mundt948cd522009-05-22 10:40:09 +0900200struct irq_desc * __ref irq_to_desc_alloc_node(unsigned int irq, int node)
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800201{
202 struct irq_desc *desc;
203 unsigned long flags;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800204
Mike Travis95949492009-01-10 22:24:06 -0800205 if (irq >= nr_irqs) {
Mike Travise2f4d062009-01-10 22:24:06 -0800206 WARN(1, "irq (%d) >= nr_irqs (%d) in irq_to_desc_alloc\n",
207 irq, nr_irqs);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800208 return NULL;
209 }
210
211 desc = irq_desc_ptrs[irq];
212 if (desc)
213 return desc;
214
215 spin_lock_irqsave(&sparse_irq_lock, flags);
216
217 /* We have to check it to avoid races with another CPU */
218 desc = irq_desc_ptrs[irq];
219 if (desc)
220 goto out_unlock;
221
Paul Mundt948cd522009-05-22 10:40:09 +0900222 if (slab_is_available())
223 desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
224 else
225 desc = alloc_bootmem_node(NODE_DATA(node), sizeof(*desc));
226
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700227 printk(KERN_DEBUG " alloc irq_desc for %d on node %d\n", irq, node);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800228 if (!desc) {
229 printk(KERN_ERR "can not alloc irq_desc\n");
230 BUG_ON(1);
231 }
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700232 init_one_irq_desc(irq, desc, node);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800233
234 irq_desc_ptrs[irq] = desc;
235
236out_unlock:
237 spin_unlock_irqrestore(&sparse_irq_lock, flags);
238
239 return desc;
240}
241
KOSAKI Motohirof9af0e72008-12-26 12:24:24 +0900242#else /* !CONFIG_SPARSE_IRQ */
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800243
Ravikiran G Thirumalaie729aa12007-05-08 00:29:13 -0700244struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 [0 ... NR_IRQS-1] = {
Zhang, Yanmin4f167fb2005-05-16 21:53:43 -0700246 .status = IRQ_DISABLED,
Ingo Molnarf1c26622006-06-29 02:24:57 -0700247 .chip = &no_irq_chip,
Ingo Molnar7a557132006-06-29 02:24:54 -0700248 .handle_irq = handle_bad_irq,
Thomas Gleixner94d39e12006-06-29 02:24:50 -0700249 .depth = 1,
Yinghai Luaac3f2b2008-09-24 19:04:35 -0700250 .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252};
Yinghai Lu08678b02008-08-19 20:50:05 -0700253
Yinghai Lud7e51e62009-01-07 15:03:13 -0800254static unsigned int kstat_irqs_all[NR_IRQS][NR_CPUS];
Yinghai Lu12026ea2008-12-26 22:38:15 -0800255int __init early_irq_init(void)
256{
257 struct irq_desc *desc;
258 int count;
259 int i;
260
David Daney97179fd2009-01-27 09:53:22 -0800261 init_irq_default_affinity();
262
Mike Travis95949492009-01-10 22:24:06 -0800263 printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);
264
Yinghai Lu12026ea2008-12-26 22:38:15 -0800265 desc = irq_desc;
266 count = ARRAY_SIZE(irq_desc);
267
Yinghai Lud7e51e62009-01-07 15:03:13 -0800268 for (i = 0; i < count; i++) {
Yinghai Lu12026ea2008-12-26 22:38:15 -0800269 desc[i].irq = i;
Yinghai Lu9ec4fa22009-04-27 17:57:18 -0700270 alloc_desc_masks(&desc[i], 0, true);
271 init_desc_masks(&desc[i]);
Yinghai Lud7e51e62009-01-07 15:03:13 -0800272 desc[i].kstat_irqs = kstat_irqs_all[i];
273 }
Yinghai Lu12026ea2008-12-26 22:38:15 -0800274 return arch_early_irq_init();
275}
276
KOSAKI Motohirof9af0e72008-12-26 12:24:24 +0900277struct irq_desc *irq_to_desc(unsigned int irq)
278{
279 return (irq < NR_IRQS) ? irq_desc + irq : NULL;
280}
281
Yinghai Lu85ac16d2009-04-27 18:00:38 -0700282struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node)
KOSAKI Motohirof9af0e72008-12-26 12:24:24 +0900283{
284 return irq_to_desc(irq);
285}
286#endif /* !CONFIG_SPARSE_IRQ */
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800287
Yinghai Lu0f3c2a82009-02-08 16:18:03 -0800288void clear_kstat_irqs(struct irq_desc *desc)
289{
290 memset(desc->kstat_irqs, 0, nr_cpu_ids * sizeof(*(desc->kstat_irqs)));
291}
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293/*
Ingo Molnar77a5afe2006-06-29 02:24:46 -0700294 * What should we do if we get a hw irq event on an illegal vector?
295 * Each architecture has to answer this themself.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 */
Ingo Molnar77a5afe2006-06-29 02:24:46 -0700297static void ack_bad(unsigned int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200299 struct irq_desc *desc = irq_to_desc(irq);
Yinghai Lu08678b02008-08-19 20:50:05 -0700300
Yinghai Lu08678b02008-08-19 20:50:05 -0700301 print_irq_desc(irq, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 ack_bad_irq(irq);
303}
304
Ingo Molnar77a5afe2006-06-29 02:24:46 -0700305/*
306 * NOP functions
307 */
308static void noop(unsigned int irq)
309{
310}
311
312static unsigned int noop_ret(unsigned int irq)
313{
314 return 0;
315}
316
317/*
318 * Generic no controller implementation
319 */
Ingo Molnarf1c26622006-06-29 02:24:57 -0700320struct irq_chip no_irq_chip = {
321 .name = "none",
Ingo Molnar77a5afe2006-06-29 02:24:46 -0700322 .startup = noop_ret,
323 .shutdown = noop,
324 .enable = noop,
325 .disable = noop,
326 .ack = ack_bad,
327 .end = noop,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328};
329
330/*
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100331 * Generic dummy implementation which can be used for
332 * real dumb interrupt sources
333 */
334struct irq_chip dummy_irq_chip = {
335 .name = "dummy",
336 .startup = noop_ret,
337 .shutdown = noop,
338 .enable = noop,
339 .disable = noop,
340 .ack = noop,
341 .mask = noop,
342 .unmask = noop,
343 .end = noop,
344};
345
346/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 * Special, empty irq handler:
348 */
David Howells7d12e782006-10-05 14:55:46 +0100349irqreturn_t no_action(int cpl, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350{
351 return IRQ_NONE;
352}
353
Thomas Gleixnerf48fe812009-03-24 11:46:22 +0100354static void warn_no_thread(unsigned int irq, struct irqaction *action)
355{
356 if (test_and_set_bit(IRQTF_WARNED, &action->thread_flags))
357 return;
358
359 printk(KERN_WARNING "IRQ %d device %s returned IRQ_WAKE_THREAD "
360 "but no thread function available.", irq, action->name);
361}
362
Ingo Molnar8d28bc72006-06-29 02:24:46 -0700363/**
364 * handle_IRQ_event - irq action chain handler
365 * @irq: the interrupt number
Ingo Molnar8d28bc72006-06-29 02:24:46 -0700366 * @action: the interrupt action chain for this irq
367 *
368 * Handles the action chain of an irq event
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 */
David Howells7d12e782006-10-05 14:55:46 +0100370irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Jan Beulich908dcec2006-06-23 02:06:00 -0700372 irqreturn_t ret, retval = IRQ_NONE;
373 unsigned int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700375 if (!(action->flags & IRQF_DISABLED))
Ingo Molnar366c7f52006-07-03 00:25:25 -0700376 local_irq_enable_in_hardirq();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378 do {
Jason Baronaf392412009-02-26 10:11:05 -0500379 trace_irq_handler_entry(irq, action);
David Howells7d12e782006-10-05 14:55:46 +0100380 ret = action->handler(irq, action->dev_id);
Jason Baronaf392412009-02-26 10:11:05 -0500381 trace_irq_handler_exit(irq, action, ret);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100382
383 switch (ret) {
384 case IRQ_WAKE_THREAD:
385 /*
Thomas Gleixnerf48fe812009-03-24 11:46:22 +0100386 * Set result to handled so the spurious check
387 * does not trigger.
388 */
389 ret = IRQ_HANDLED;
390
391 /*
392 * Catch drivers which return WAKE_THREAD but
393 * did not set up a thread function
394 */
395 if (unlikely(!action->thread_fn)) {
396 warn_no_thread(irq, action);
397 break;
398 }
399
400 /*
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100401 * Wake up the handler thread for this
402 * action. In case the thread crashed and was
403 * killed we just pretend that we handled the
404 * interrupt. The hardirq handler above has
405 * disabled the device interrupt, so no irq
406 * storm is lurking.
407 */
408 if (likely(!test_bit(IRQTF_DIED,
409 &action->thread_flags))) {
410 set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
411 wake_up_process(action->thread);
412 }
413
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100414 /* Fall through to add to randomness */
415 case IRQ_HANDLED:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 status |= action->flags;
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100417 break;
418
419 default:
420 break;
421 }
422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 retval |= ret;
424 action = action->next;
425 } while (action);
426
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700427 if (status & IRQF_SAMPLE_RANDOM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 add_interrupt_randomness(irq);
429 local_irq_disable();
430
431 return retval;
432}
433
David Howellsaf8c65b2006-09-25 23:32:07 -0700434#ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
Thomas Gleixner0e57aa12009-03-13 14:34:05 +0100435
436#ifdef CONFIG_ENABLE_WARN_DEPRECATED
437# warning __do_IRQ is deprecated. Please convert to proper flow handlers
438#endif
439
Ingo Molnar8d28bc72006-06-29 02:24:46 -0700440/**
441 * __do_IRQ - original all in one highlevel IRQ handler
442 * @irq: the interrupt number
Ingo Molnar8d28bc72006-06-29 02:24:46 -0700443 *
444 * __do_IRQ handles all normal device IRQ's (the special
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 * SMP cross-CPU interrupts have their own specific
446 * handlers).
Ingo Molnar8d28bc72006-06-29 02:24:46 -0700447 *
448 * This is the original x86 implementation which is used for every
449 * interrupt type.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800451unsigned int __do_IRQ(unsigned int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
Yinghai Lu08678b02008-08-19 20:50:05 -0700453 struct irq_desc *desc = irq_to_desc(irq);
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700454 struct irqaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 unsigned int status;
456
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200457 kstat_incr_irqs_this_cpu(irq, desc);
458
Karsten Wiesef26fdd52005-09-06 15:17:25 -0700459 if (CHECK_IRQ_PER_CPU(desc->status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 irqreturn_t action_ret;
461
462 /*
463 * No locking required for CPU-local interrupts:
464 */
Yinghai Lufcef5912009-04-27 17:58:23 -0700465 if (desc->chip->ack)
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700466 desc->chip->ack(irq);
Russ Andersonc642b832007-11-14 17:00:15 -0800467 if (likely(!(desc->status & IRQ_DISABLED))) {
468 action_ret = handle_IRQ_event(irq, desc->action);
469 if (!noirqdebug)
470 note_interrupt(irq, desc, action_ret);
471 }
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700472 desc->chip->end(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return 1;
474 }
475
476 spin_lock(&desc->lock);
Yinghai Lufcef5912009-04-27 17:58:23 -0700477 if (desc->chip->ack)
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700478 desc->chip->ack(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /*
480 * REPLAY is when Linux resends an IRQ that was dropped earlier
481 * WAITING is used by probe to mark irqs that are being tested
482 */
483 status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
484 status |= IRQ_PENDING; /* we _want_ to handle it */
485
486 /*
487 * If the IRQ is disabled for whatever reason, we cannot
488 * use the action we have.
489 */
490 action = NULL;
491 if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
492 action = desc->action;
493 status &= ~IRQ_PENDING; /* we commit to handling */
494 status |= IRQ_INPROGRESS; /* we are handling it */
495 }
496 desc->status = status;
497
498 /*
499 * If there is no IRQ handler or it was disabled, exit early.
500 * Since we set PENDING, if another processor is handling
501 * a different instance of this same irq, the other processor
502 * will take care of it.
503 */
504 if (unlikely(!action))
505 goto out;
506
507 /*
508 * Edge triggered interrupts need to remember
509 * pending events.
510 * This applies to any hw interrupts that allow a second
511 * instance of the same irq to arrive while we are in do_IRQ
512 * or in the handler. But the code here only handles the _second_
513 * instance of the irq, not the third or fourth. So it is mostly
514 * useful for irq hardware that does not mask cleanly in an
515 * SMP environment.
516 */
517 for (;;) {
518 irqreturn_t action_ret;
519
520 spin_unlock(&desc->lock);
521
David Howells7d12e782006-10-05 14:55:46 +0100522 action_ret = handle_IRQ_event(irq, action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100524 note_interrupt(irq, desc, action_ret);
Linus Torvaldsb42172f2006-11-22 09:32:06 -0800525
526 spin_lock(&desc->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 if (likely(!(desc->status & IRQ_PENDING)))
528 break;
529 desc->status &= ~IRQ_PENDING;
530 }
531 desc->status &= ~IRQ_INPROGRESS;
532
533out:
534 /*
535 * The ->end() handler has to deal with interrupts which got
536 * disabled while the handler was running.
537 */
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700538 desc->chip->end(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 spin_unlock(&desc->lock);
540
541 return 1;
542}
David Howellsaf8c65b2006-09-25 23:32:07 -0700543#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Ingo Molnar243c7622006-07-03 00:25:06 -0700545void early_init_irq_lock_class(void)
546{
Thomas Gleixner10e58082008-10-16 14:19:04 +0200547 struct irq_desc *desc;
Ingo Molnar243c7622006-07-03 00:25:06 -0700548 int i;
549
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800550 for_each_irq_desc(i, desc) {
Thomas Gleixner10e58082008-10-16 14:19:04 +0200551 lockdep_set_class(&desc->lock, &irq_desc_lock_class);
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800552 }
Yinghai Lu08678b02008-08-19 20:50:05 -0700553}
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800554
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800555unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
556{
557 struct irq_desc *desc = irq_to_desc(irq);
KOSAKI Motohiro26ddd8d2008-12-26 14:24:10 +0900558 return desc ? desc->kstat_irqs[cpu] : 0;
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800559}
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -0800560EXPORT_SYMBOL(kstat_irqs_cpu);
561