blob: 122fef4b0bd30d82ade4af7a84f281d019030280 [file] [log] [blame]
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -07001/*
2 * linux/kernel/irq/chip.c
3 *
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
6 *
7 * This file contains the core interrupt handling code, for irq-chip
8 * based architectures.
9 *
10 * Detailed information is available in Documentation/DocBook/genericirq
11 */
12
13#include <linux/irq.h>
Michael Ellerman7fe37302007-04-18 19:39:21 +100014#include <linux/msi.h>
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -070015#include <linux/module.h>
16#include <linux/interrupt.h>
17#include <linux/kernel_stat.h>
18
19#include "internals.h"
20
21/**
Eric W. Biederman3a16d712006-10-04 02:16:37 -070022 * dynamic_irq_init - initialize a dynamically allocated irq
23 * @irq: irq number to initialize
24 */
25void dynamic_irq_init(unsigned int irq)
26{
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080027 struct irq_desc *desc;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070028 unsigned long flags;
29
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080030 desc = irq_to_desc(irq);
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070031 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -070032 WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070033 return;
34 }
35
36 /* Ensure we don't have left over values from a previous use of this irq */
Eric W. Biederman3a16d712006-10-04 02:16:37 -070037 spin_lock_irqsave(&desc->lock, flags);
38 desc->status = IRQ_DISABLED;
39 desc->chip = &no_irq_chip;
40 desc->handle_irq = handle_bad_irq;
41 desc->depth = 1;
Eric W. Biederman5b912c12007-01-28 12:52:03 -070042 desc->msi_desc = NULL;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070043 desc->handler_data = NULL;
44 desc->chip_data = NULL;
45 desc->action = NULL;
46 desc->irq_count = 0;
47 desc->irqs_unhandled = 0;
48#ifdef CONFIG_SMP
Mike Travis7f7ace02009-01-10 21:58:08 -080049 cpumask_setall(desc->affinity);
50#ifdef CONFIG_GENERIC_PENDING_IRQ
51 cpumask_clear(desc->pending_mask);
52#endif
Eric W. Biederman3a16d712006-10-04 02:16:37 -070053#endif
54 spin_unlock_irqrestore(&desc->lock, flags);
55}
56
57/**
58 * dynamic_irq_cleanup - cleanup a dynamically allocated irq
59 * @irq: irq number to initialize
60 */
61void dynamic_irq_cleanup(unsigned int irq)
62{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +020063 struct irq_desc *desc = irq_to_desc(irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070064 unsigned long flags;
65
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070066 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -070067 WARN(1, KERN_ERR "Trying to cleanup invalid IRQ%d\n", irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070068 return;
69 }
70
Eric W. Biederman3a16d712006-10-04 02:16:37 -070071 spin_lock_irqsave(&desc->lock, flags);
Eric W. Biederman1f800252006-10-04 02:16:56 -070072 if (desc->action) {
73 spin_unlock_irqrestore(&desc->lock, flags);
Arjan van de Ven261c40c2008-07-25 19:45:37 -070074 WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
Eric W. Biederman1f800252006-10-04 02:16:56 -070075 irq);
Eric W. Biederman1f800252006-10-04 02:16:56 -070076 return;
77 }
Eric W. Biederman5b912c12007-01-28 12:52:03 -070078 desc->msi_desc = NULL;
79 desc->handler_data = NULL;
80 desc->chip_data = NULL;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070081 desc->handle_irq = handle_bad_irq;
82 desc->chip = &no_irq_chip;
Dean Nelsonb6f3b782008-10-18 16:06:56 -070083 desc->name = NULL;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070084 spin_unlock_irqrestore(&desc->lock, flags);
85}
86
87
88/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -070089 * set_irq_chip - set the irq chip for an irq
90 * @irq: irq number
91 * @chip: pointer to irq chip description structure
92 */
93int set_irq_chip(unsigned int irq, struct irq_chip *chip)
94{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +020095 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -070096 unsigned long flags;
97
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070098 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -070099 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700100 return -EINVAL;
101 }
102
103 if (!chip)
104 chip = &no_irq_chip;
105
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700106 spin_lock_irqsave(&desc->lock, flags);
107 irq_chip_set_defaults(chip);
108 desc->chip = chip;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700109 spin_unlock_irqrestore(&desc->lock, flags);
110
111 return 0;
112}
113EXPORT_SYMBOL(set_irq_chip);
114
115/**
David Brownell0c5d1eb2008-10-01 14:46:18 -0700116 * set_irq_type - set the irq trigger type for an irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700117 * @irq: irq number
David Brownell0c5d1eb2008-10-01 14:46:18 -0700118 * @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700119 */
120int set_irq_type(unsigned int irq, unsigned int type)
121{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200122 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700123 unsigned long flags;
124 int ret = -ENXIO;
125
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700126 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700127 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
128 return -ENODEV;
129 }
130
David Brownellf2b662d2008-12-01 14:31:38 -0800131 type &= IRQ_TYPE_SENSE_MASK;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700132 if (type == IRQ_TYPE_NONE)
133 return 0;
134
135 spin_lock_irqsave(&desc->lock, flags);
Chris Friesen0b3682ba32008-10-20 12:41:58 -0600136 ret = __irq_set_trigger(desc, irq, type);
David Brownell0c5d1eb2008-10-01 14:46:18 -0700137 spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700138 return ret;
139}
140EXPORT_SYMBOL(set_irq_type);
141
142/**
143 * set_irq_data - set irq type data for an irq
144 * @irq: Interrupt number
145 * @data: Pointer to interrupt specific data
146 *
147 * Set the hardware irq controller data for an irq
148 */
149int set_irq_data(unsigned int irq, void *data)
150{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200151 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700152 unsigned long flags;
153
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700154 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700155 printk(KERN_ERR
156 "Trying to install controller data for IRQ%d\n", irq);
157 return -EINVAL;
158 }
159
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700160 spin_lock_irqsave(&desc->lock, flags);
161 desc->handler_data = data;
162 spin_unlock_irqrestore(&desc->lock, flags);
163 return 0;
164}
165EXPORT_SYMBOL(set_irq_data);
166
167/**
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700168 * set_irq_data - set irq type data for an irq
169 * @irq: Interrupt number
Randy Dunlap472900b2007-02-16 01:28:25 -0800170 * @entry: Pointer to MSI descriptor data
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700171 *
172 * Set the hardware irq controller data for an irq
173 */
174int set_irq_msi(unsigned int irq, struct msi_desc *entry)
175{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200176 struct irq_desc *desc = irq_to_desc(irq);
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700177 unsigned long flags;
178
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700179 if (!desc) {
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700180 printk(KERN_ERR
181 "Trying to install msi data for IRQ%d\n", irq);
182 return -EINVAL;
183 }
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700184
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700185 spin_lock_irqsave(&desc->lock, flags);
186 desc->msi_desc = entry;
Michael Ellerman7fe37302007-04-18 19:39:21 +1000187 if (entry)
188 entry->irq = irq;
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700189 spin_unlock_irqrestore(&desc->lock, flags);
190 return 0;
191}
192
193/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700194 * set_irq_chip_data - set irq chip data for an irq
195 * @irq: Interrupt number
196 * @data: Pointer to chip specific data
197 *
198 * Set the hardware irq chip data for an irq
199 */
200int set_irq_chip_data(unsigned int irq, void *data)
201{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200202 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700203 unsigned long flags;
204
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700205 if (!desc) {
206 printk(KERN_ERR
207 "Trying to install chip data for IRQ%d\n", irq);
208 return -EINVAL;
209 }
210
211 if (!desc->chip) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700212 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
213 return -EINVAL;
214 }
215
216 spin_lock_irqsave(&desc->lock, flags);
217 desc->chip_data = data;
218 spin_unlock_irqrestore(&desc->lock, flags);
219
220 return 0;
221}
222EXPORT_SYMBOL(set_irq_chip_data);
223
224/*
225 * default enable function
226 */
227static void default_enable(unsigned int irq)
228{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200229 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700230
231 desc->chip->unmask(irq);
232 desc->status &= ~IRQ_MASKED;
233}
234
235/*
236 * default disable function
237 */
238static void default_disable(unsigned int irq)
239{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700240}
241
242/*
243 * default startup function
244 */
245static unsigned int default_startup(unsigned int irq)
246{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200247 struct irq_desc *desc = irq_to_desc(irq);
Yinghai Lu08678b02008-08-19 20:50:05 -0700248
Yinghai Lu08678b02008-08-19 20:50:05 -0700249 desc->chip->enable(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700250 return 0;
251}
252
253/*
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100254 * default shutdown function
255 */
256static void default_shutdown(unsigned int irq)
257{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200258 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100259
260 desc->chip->mask(irq);
261 desc->status |= IRQ_MASKED;
262}
263
264/*
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700265 * Fixup enable/disable function pointers
266 */
267void irq_chip_set_defaults(struct irq_chip *chip)
268{
269 if (!chip->enable)
270 chip->enable = default_enable;
271 if (!chip->disable)
272 chip->disable = default_disable;
273 if (!chip->startup)
274 chip->startup = default_startup;
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100275 /*
276 * We use chip->disable, when the user provided its own. When
277 * we have default_disable set for chip->disable, then we need
278 * to use default_shutdown, otherwise the irq line is not
279 * disabled on free_irq():
280 */
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700281 if (!chip->shutdown)
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100282 chip->shutdown = chip->disable != default_disable ?
283 chip->disable : default_shutdown;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700284 if (!chip->name)
285 chip->name = chip->typename;
Zhang, Yanminb86432b2006-11-16 01:19:10 -0800286 if (!chip->end)
287 chip->end = dummy_irq_chip.end;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700288}
289
290static inline void mask_ack_irq(struct irq_desc *desc, int irq)
291{
292 if (desc->chip->mask_ack)
293 desc->chip->mask_ack(irq);
294 else {
295 desc->chip->mask(irq);
296 desc->chip->ack(irq);
297 }
298}
299
300/**
301 * handle_simple_irq - Simple and software-decoded IRQs.
302 * @irq: the interrupt number
303 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700304 *
305 * Simple interrupts are either sent from a demultiplexing interrupt
306 * handler or come from hardware, where no interrupt hardware control
307 * is necessary.
308 *
309 * Note: The caller is expected to handle the ack, clear, mask and
310 * unmask issues if necessary.
311 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800312void
David Howells7d12e782006-10-05 14:55:46 +0100313handle_simple_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700314{
315 struct irqaction *action;
316 irqreturn_t action_ret;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700317
318 spin_lock(&desc->lock);
319
320 if (unlikely(desc->status & IRQ_INPROGRESS))
321 goto out_unlock;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100322 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200323 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700324
325 action = desc->action;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100326 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700327 goto out_unlock;
328
329 desc->status |= IRQ_INPROGRESS;
330 spin_unlock(&desc->lock);
331
David Howells7d12e782006-10-05 14:55:46 +0100332 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700333 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100334 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700335
336 spin_lock(&desc->lock);
337 desc->status &= ~IRQ_INPROGRESS;
338out_unlock:
339 spin_unlock(&desc->lock);
340}
341
342/**
343 * handle_level_irq - Level type irq handler
344 * @irq: the interrupt number
345 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700346 *
347 * Level type interrupts are active as long as the hardware line has
348 * the active level. This may require to mask the interrupt and unmask
349 * it after the associated handler has acknowledged the device, so the
350 * interrupt line is back to inactive.
351 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800352void
David Howells7d12e782006-10-05 14:55:46 +0100353handle_level_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700354{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700355 struct irqaction *action;
356 irqreturn_t action_ret;
357
358 spin_lock(&desc->lock);
359 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800360 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700361
362 if (unlikely(desc->status & IRQ_INPROGRESS))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200363 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700364 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200365 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700366
367 /*
368 * If its disabled or no action available
369 * keep it masked and get out of here
370 */
371 action = desc->action;
Thomas Gleixner49663422007-08-12 15:46:34 +0000372 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200373 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700374
375 desc->status |= IRQ_INPROGRESS;
376 spin_unlock(&desc->lock);
377
David Howells7d12e782006-10-05 14:55:46 +0100378 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700379 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100380 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700381
382 spin_lock(&desc->lock);
383 desc->status &= ~IRQ_INPROGRESS;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700384 if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
385 desc->chip->unmask(irq);
Ingo Molnar86998aa2006-09-19 11:14:34 +0200386out_unlock:
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700387 spin_unlock(&desc->lock);
388}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100389EXPORT_SYMBOL_GPL(handle_level_irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700390
391/**
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700392 * handle_fasteoi_irq - irq handler for transparent controllers
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700393 * @irq: the interrupt number
394 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700395 *
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700396 * Only a single callback will be issued to the chip: an ->eoi()
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700397 * call when the interrupt has been serviced. This enables support
398 * for modern forms of interrupt handlers, which handle the flow
399 * details in hardware, transparently.
400 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800401void
David Howells7d12e782006-10-05 14:55:46 +0100402handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700403{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700404 struct irqaction *action;
405 irqreturn_t action_ret;
406
407 spin_lock(&desc->lock);
408
409 if (unlikely(desc->status & IRQ_INPROGRESS))
410 goto out;
411
412 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200413 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700414
415 /*
416 * If its disabled or no action available
Ingo Molnar76d21602007-02-16 01:28:24 -0800417 * then mask it and get out of here:
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700418 */
419 action = desc->action;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700420 if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
421 desc->status |= IRQ_PENDING;
Ingo Molnar76d21602007-02-16 01:28:24 -0800422 if (desc->chip->mask)
423 desc->chip->mask(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700424 goto out;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700425 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700426
427 desc->status |= IRQ_INPROGRESS;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700428 desc->status &= ~IRQ_PENDING;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700429 spin_unlock(&desc->lock);
430
David Howells7d12e782006-10-05 14:55:46 +0100431 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700432 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100433 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700434
435 spin_lock(&desc->lock);
436 desc->status &= ~IRQ_INPROGRESS;
437out:
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700438 desc->chip->eoi(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800439 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700440
441 spin_unlock(&desc->lock);
442}
443
444/**
445 * handle_edge_irq - edge type IRQ handler
446 * @irq: the interrupt number
447 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700448 *
449 * Interrupt occures on the falling and/or rising edge of a hardware
450 * signal. The occurence is latched into the irq controller hardware
451 * and must be acked in order to be reenabled. After the ack another
452 * interrupt can happen on the same source even before the first one
453 * is handled by the assosiacted event handler. If this happens it
454 * might be necessary to disable (mask) the interrupt depending on the
455 * controller hardware. This requires to reenable the interrupt inside
456 * of the loop which handles the interrupts which have arrived while
457 * the handler was running. If all pending interrupts are handled, the
458 * loop is left.
459 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800460void
David Howells7d12e782006-10-05 14:55:46 +0100461handle_edge_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700462{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700463 spin_lock(&desc->lock);
464
465 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
466
467 /*
468 * If we're currently running this IRQ, or its disabled,
469 * we shouldn't process the IRQ. Mark it pending, handle
470 * the necessary masking and go out
471 */
472 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
473 !desc->action)) {
474 desc->status |= (IRQ_PENDING | IRQ_MASKED);
475 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800476 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700477 goto out_unlock;
478 }
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200479 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700480
481 /* Start handling the irq */
482 desc->chip->ack(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800483 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700484
485 /* Mark the IRQ currently in progress.*/
486 desc->status |= IRQ_INPROGRESS;
487
488 do {
489 struct irqaction *action = desc->action;
490 irqreturn_t action_ret;
491
492 if (unlikely(!action)) {
493 desc->chip->mask(irq);
494 goto out_unlock;
495 }
496
497 /*
498 * When another irq arrived while we were handling
499 * one, we could have masked the irq.
500 * Renable it, if it was not disabled in meantime.
501 */
502 if (unlikely((desc->status &
503 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
504 (IRQ_PENDING | IRQ_MASKED))) {
505 desc->chip->unmask(irq);
506 desc->status &= ~IRQ_MASKED;
507 }
508
509 desc->status &= ~IRQ_PENDING;
510 spin_unlock(&desc->lock);
David Howells7d12e782006-10-05 14:55:46 +0100511 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700512 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100513 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700514 spin_lock(&desc->lock);
515
516 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
517
518 desc->status &= ~IRQ_INPROGRESS;
519out_unlock:
520 spin_unlock(&desc->lock);
521}
522
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700523/**
524 * handle_percpu_IRQ - Per CPU local irq handler
525 * @irq: the interrupt number
526 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700527 *
528 * Per CPU interrupts on SMP machines without locking requirements
529 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800530void
David Howells7d12e782006-10-05 14:55:46 +0100531handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700532{
533 irqreturn_t action_ret;
534
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200535 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700536
537 if (desc->chip->ack)
538 desc->chip->ack(irq);
539
David Howells7d12e782006-10-05 14:55:46 +0100540 action_ret = handle_IRQ_event(irq, desc->action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700541 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100542 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700543
Yinghai Lu48a1b102008-12-11 00:15:01 -0800544 if (desc->chip->eoi) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700545 desc->chip->eoi(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800546 desc = irq_remap_to_desc(irq, desc);
547 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700548}
549
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700550void
Ingo Molnara460e742006-10-17 00:10:03 -0700551__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
552 const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700553{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200554 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700555 unsigned long flags;
556
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700557 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700558 printk(KERN_ERR
559 "Trying to install type control for IRQ%d\n", irq);
560 return;
561 }
562
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700563 if (!handle)
564 handle = handle_bad_irq;
Thomas Gleixner9d7ac8b2006-12-22 01:08:14 -0800565 else if (desc->chip == &no_irq_chip) {
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100566 printk(KERN_WARNING "Trying to install %sinterrupt handler "
Geert Uytterhoevenb039db82006-12-20 15:59:48 +0100567 "for IRQ%d\n", is_chained ? "chained " : "", irq);
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100568 /*
569 * Some ARM implementations install a handler for really dumb
570 * interrupt hardware without setting an irq_chip. This worked
571 * with the ARM no_irq_chip but the check in setup_irq would
572 * prevent us to setup the interrupt at all. Switch it to
573 * dummy_irq_chip for easy transition.
574 */
575 desc->chip = &dummy_irq_chip;
576 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700577
578 spin_lock_irqsave(&desc->lock, flags);
579
580 /* Uninstall? */
581 if (handle == handle_bad_irq) {
Yinghai Lu48a1b102008-12-11 00:15:01 -0800582 if (desc->chip != &no_irq_chip) {
Jan Beulich5575ddf2007-02-16 01:28:26 -0800583 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800584 desc = irq_remap_to_desc(irq, desc);
585 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700586 desc->status |= IRQ_DISABLED;
587 desc->depth = 1;
588 }
589 desc->handle_irq = handle;
Ingo Molnara460e742006-10-17 00:10:03 -0700590 desc->name = name;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700591
592 if (handle != handle_bad_irq && is_chained) {
593 desc->status &= ~IRQ_DISABLED;
594 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
595 desc->depth = 0;
Pawel MOLL7e6e1782008-09-01 10:12:11 +0100596 desc->chip->startup(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700597 }
598 spin_unlock_irqrestore(&desc->lock, flags);
599}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100600EXPORT_SYMBOL_GPL(__set_irq_handler);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700601
602void
603set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
David Howells57a58a92006-10-05 13:06:34 +0100604 irq_flow_handler_t handle)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700605{
606 set_irq_chip(irq, chip);
Ingo Molnara460e742006-10-17 00:10:03 -0700607 __set_irq_handler(irq, handle, 0, NULL);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700608}
609
Ingo Molnara460e742006-10-17 00:10:03 -0700610void
611set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
612 irq_flow_handler_t handle, const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700613{
Ingo Molnara460e742006-10-17 00:10:03 -0700614 set_irq_chip(irq, chip);
615 __set_irq_handler(irq, handle, 0, name);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700616}
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800617
618void __init set_irq_noprobe(unsigned int irq)
619{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200620 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800621 unsigned long flags;
622
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700623 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800624 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800625 return;
626 }
627
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800628 spin_lock_irqsave(&desc->lock, flags);
629 desc->status |= IRQ_NOPROBE;
630 spin_unlock_irqrestore(&desc->lock, flags);
631}
632
633void __init set_irq_probe(unsigned int irq)
634{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200635 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800636 unsigned long flags;
637
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700638 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800639 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800640 return;
641 }
642
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800643 spin_lock_irqsave(&desc->lock, flags);
644 desc->status &= ~IRQ_NOPROBE;
645 spin_unlock_irqrestore(&desc->lock, flags);
646}