2 * linux/kernel/irq/handle.c
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
7 * This file contains the core interrupt handling code.
9 * Detailed information is available in Documentation/DocBook/genericirq
13 #include <linux/irq.h>
14 #include <linux/module.h>
15 #include <linux/random.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel_stat.h>
18 #include <linux/vs_context.h>
20 #include "internals.h"
23 * handle_bad_irq - handle spurious and unhandled irqs
24 * @irq: the interrupt number
25 * @desc: description of the interrupt
26 * @regs: pointer to a register structure
28 * Handles spurious and unhandled IRQ's. It also prints a debugmessage.
31 handle_bad_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
33 print_irq_desc(irq, desc);
34 kstat_this_cpu.irqs[irq]++;
39 * Linux has a controller-independent interrupt architecture.
40 * Every controller has a 'controller-template', that is used
41 * by the main code to do the right thing. Each driver-visible
42 * interrupt source is transparently wired to the appropriate
43 * controller. Thus drivers need not be aware of the
44 * interrupt-controller.
46 * The code is designed to be easily extended with new/different
47 * interrupt controllers, without having to do assembly magic or
48 * having to touch the generic code.
50 * Controller mappings for all interrupt sources:
52 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned = {
54 .status = IRQ_DISABLED,
56 .handle_irq = handle_bad_irq,
58 .lock = SPIN_LOCK_UNLOCKED,
60 .affinity = CPU_MASK_ALL
66 * What should we do if we get a hw irq event on an illegal vector?
67 * Each architecture has to answer this themself.
69 static void ack_bad(unsigned int irq)
71 print_irq_desc(irq, irq_desc + irq);
78 static void noop(unsigned int irq)
82 static unsigned int noop_ret(unsigned int irq)
88 * Generic no controller implementation
90 struct irq_chip no_irq_chip = {
101 * Generic dummy implementation which can be used for
102 * real dumb interrupt sources
104 struct irq_chip dummy_irq_chip = {
117 * Special, empty irq handler:
119 irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs)
125 * handle_IRQ_event - irq action chain handler
126 * @irq: the interrupt number
127 * @regs: pointer to a register structure
128 * @action: the interrupt action chain for this irq
130 * Handles the action chain of an irq event
132 irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
133 struct irqaction *action)
135 irqreturn_t ret, retval = IRQ_NONE;
136 unsigned int status = 0;
138 handle_dynamic_tick(action);
140 if (!(action->flags & IRQF_DISABLED))
141 local_irq_enable_in_hardirq();
144 ret = action->handler(irq, action->dev_id, regs);
145 if (ret == IRQ_HANDLED)
146 status |= action->flags;
148 action = action->next;
151 if (status & IRQF_SAMPLE_RANDOM)
152 add_interrupt_randomness(irq);
159 * __do_IRQ - original all in one highlevel IRQ handler
160 * @irq: the interrupt number
161 * @regs: pointer to a register structure
163 * __do_IRQ handles all normal device IRQ's (the special
164 * SMP cross-CPU interrupts have their own specific
167 * This is the original x86 implementation which is used for every
170 fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
172 struct irq_desc *desc = irq_desc + irq;
173 struct irqaction *action;
174 struct vx_info_save vxis;
177 kstat_this_cpu.irqs[irq]++;
178 if (CHECK_IRQ_PER_CPU(desc->status)) {
179 irqreturn_t action_ret;
182 * No locking required for CPU-local interrupts:
184 __enter_vx_admin(&vxis);
186 desc->chip->ack(irq);
187 action_ret = handle_IRQ_event(irq, regs, desc->action);
188 desc->chip->end(irq);
189 __leave_vx_admin(&vxis);
193 spin_lock(&desc->lock);
194 __enter_vx_admin(&vxis);
196 desc->chip->ack(irq);
198 * REPLAY is when Linux resends an IRQ that was dropped earlier
199 * WAITING is used by probe to mark irqs that are being tested
201 status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
202 status |= IRQ_PENDING; /* we _want_ to handle it */
205 * If the IRQ is disabled for whatever reason, we cannot
206 * use the action we have.
209 if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
210 action = desc->action;
211 status &= ~IRQ_PENDING; /* we commit to handling */
212 status |= IRQ_INPROGRESS; /* we are handling it */
214 desc->status = status;
217 * If there is no IRQ handler or it was disabled, exit early.
218 * Since we set PENDING, if another processor is handling
219 * a different instance of this same irq, the other processor
220 * will take care of it.
222 if (unlikely(!action))
226 * Edge triggered interrupts need to remember
228 * This applies to any hw interrupts that allow a second
229 * instance of the same irq to arrive while we are in do_IRQ
230 * or in the handler. But the code here only handles the _second_
231 * instance of the irq, not the third or fourth. So it is mostly
232 * useful for irq hardware that does not mask cleanly in an
236 irqreturn_t action_ret;
238 spin_unlock(&desc->lock);
240 action_ret = handle_IRQ_event(irq, regs, action);
242 spin_lock(&desc->lock);
244 note_interrupt(irq, desc, action_ret, regs);
245 if (likely(!(desc->status & IRQ_PENDING)))
247 desc->status &= ~IRQ_PENDING;
249 desc->status &= ~IRQ_INPROGRESS;
253 * The ->end() handler has to deal with interrupts which got
254 * disabled while the handler was running.
256 desc->chip->end(irq);
257 __leave_vx_admin(&vxis);
258 spin_unlock(&desc->lock);
263 #ifdef CONFIG_TRACE_IRQFLAGS
266 * lockdep: we want to handle all irq_desc locks as a single lock-class:
268 static struct lock_class_key irq_desc_lock_class;
270 void early_init_irq_lock_class(void)
274 for (i = 0; i < NR_IRQS; i++)
275 lockdep_set_class(&irq_desc[i].lock, &irq_desc_lock_class);