blob: c687ba4363f2b4a95a5c3988998286a1e8ab699b [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;
Yinghai Lu0f3c2a82009-02-08 16:18:03 -080084 clear_kstat_irqs(desc);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070085 spin_unlock_irqrestore(&desc->lock, flags);
86}
87
88
89/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -070090 * set_irq_chip - set the irq chip for an irq
91 * @irq: irq number
92 * @chip: pointer to irq chip description structure
93 */
94int set_irq_chip(unsigned int irq, struct irq_chip *chip)
95{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +020096 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -070097 unsigned long flags;
98
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070099 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -0700100 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700101 return -EINVAL;
102 }
103
104 if (!chip)
105 chip = &no_irq_chip;
106
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700107 spin_lock_irqsave(&desc->lock, flags);
108 irq_chip_set_defaults(chip);
109 desc->chip = chip;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700110 spin_unlock_irqrestore(&desc->lock, flags);
111
112 return 0;
113}
114EXPORT_SYMBOL(set_irq_chip);
115
116/**
David Brownell0c5d1eb2008-10-01 14:46:18 -0700117 * set_irq_type - set the irq trigger type for an irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700118 * @irq: irq number
David Brownell0c5d1eb2008-10-01 14:46:18 -0700119 * @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700120 */
121int set_irq_type(unsigned int irq, unsigned int type)
122{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200123 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700124 unsigned long flags;
125 int ret = -ENXIO;
126
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700127 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700128 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
129 return -ENODEV;
130 }
131
David Brownellf2b662d2008-12-01 14:31:38 -0800132 type &= IRQ_TYPE_SENSE_MASK;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700133 if (type == IRQ_TYPE_NONE)
134 return 0;
135
136 spin_lock_irqsave(&desc->lock, flags);
Chris Friesen0b3682ba32008-10-20 12:41:58 -0600137 ret = __irq_set_trigger(desc, irq, type);
David Brownell0c5d1eb2008-10-01 14:46:18 -0700138 spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700139 return ret;
140}
141EXPORT_SYMBOL(set_irq_type);
142
143/**
144 * set_irq_data - set irq type data for an irq
145 * @irq: Interrupt number
146 * @data: Pointer to interrupt specific data
147 *
148 * Set the hardware irq controller data for an irq
149 */
150int set_irq_data(unsigned int irq, void *data)
151{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200152 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700153 unsigned long flags;
154
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700155 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700156 printk(KERN_ERR
157 "Trying to install controller data for IRQ%d\n", irq);
158 return -EINVAL;
159 }
160
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700161 spin_lock_irqsave(&desc->lock, flags);
162 desc->handler_data = data;
163 spin_unlock_irqrestore(&desc->lock, flags);
164 return 0;
165}
166EXPORT_SYMBOL(set_irq_data);
167
168/**
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700169 * set_irq_data - set irq type data for an irq
170 * @irq: Interrupt number
Randy Dunlap472900b2007-02-16 01:28:25 -0800171 * @entry: Pointer to MSI descriptor data
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700172 *
173 * Set the hardware irq controller data for an irq
174 */
175int set_irq_msi(unsigned int irq, struct msi_desc *entry)
176{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200177 struct irq_desc *desc = irq_to_desc(irq);
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700178 unsigned long flags;
179
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700180 if (!desc) {
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700181 printk(KERN_ERR
182 "Trying to install msi data for IRQ%d\n", irq);
183 return -EINVAL;
184 }
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700185
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700186 spin_lock_irqsave(&desc->lock, flags);
187 desc->msi_desc = entry;
Michael Ellerman7fe37302007-04-18 19:39:21 +1000188 if (entry)
189 entry->irq = irq;
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700190 spin_unlock_irqrestore(&desc->lock, flags);
191 return 0;
192}
193
194/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700195 * set_irq_chip_data - set irq chip data for an irq
196 * @irq: Interrupt number
197 * @data: Pointer to chip specific data
198 *
199 * Set the hardware irq chip data for an irq
200 */
201int set_irq_chip_data(unsigned int irq, void *data)
202{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200203 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700204 unsigned long flags;
205
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700206 if (!desc) {
207 printk(KERN_ERR
208 "Trying to install chip data for IRQ%d\n", irq);
209 return -EINVAL;
210 }
211
212 if (!desc->chip) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700213 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
214 return -EINVAL;
215 }
216
217 spin_lock_irqsave(&desc->lock, flags);
218 desc->chip_data = data;
219 spin_unlock_irqrestore(&desc->lock, flags);
220
221 return 0;
222}
223EXPORT_SYMBOL(set_irq_chip_data);
224
225/*
226 * default enable function
227 */
228static void default_enable(unsigned int irq)
229{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200230 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700231
232 desc->chip->unmask(irq);
233 desc->status &= ~IRQ_MASKED;
234}
235
236/*
237 * default disable function
238 */
239static void default_disable(unsigned int irq)
240{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700241}
242
243/*
244 * default startup function
245 */
246static unsigned int default_startup(unsigned int irq)
247{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200248 struct irq_desc *desc = irq_to_desc(irq);
Yinghai Lu08678b02008-08-19 20:50:05 -0700249
Yinghai Lu08678b02008-08-19 20:50:05 -0700250 desc->chip->enable(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700251 return 0;
252}
253
254/*
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100255 * default shutdown function
256 */
257static void default_shutdown(unsigned int irq)
258{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200259 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100260
261 desc->chip->mask(irq);
262 desc->status |= IRQ_MASKED;
263}
264
265/*
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700266 * Fixup enable/disable function pointers
267 */
268void irq_chip_set_defaults(struct irq_chip *chip)
269{
270 if (!chip->enable)
271 chip->enable = default_enable;
272 if (!chip->disable)
273 chip->disable = default_disable;
274 if (!chip->startup)
275 chip->startup = default_startup;
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100276 /*
277 * We use chip->disable, when the user provided its own. When
278 * we have default_disable set for chip->disable, then we need
279 * to use default_shutdown, otherwise the irq line is not
280 * disabled on free_irq():
281 */
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700282 if (!chip->shutdown)
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100283 chip->shutdown = chip->disable != default_disable ?
284 chip->disable : default_shutdown;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700285 if (!chip->name)
286 chip->name = chip->typename;
Zhang, Yanminb86432b2006-11-16 01:19:10 -0800287 if (!chip->end)
288 chip->end = dummy_irq_chip.end;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700289}
290
291static inline void mask_ack_irq(struct irq_desc *desc, int irq)
292{
293 if (desc->chip->mask_ack)
294 desc->chip->mask_ack(irq);
295 else {
296 desc->chip->mask(irq);
Wang Chenefdc64f2008-12-29 13:35:11 +0800297 if (desc->chip->ack)
298 desc->chip->ack(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700299 }
300}
301
302/**
303 * handle_simple_irq - Simple and software-decoded IRQs.
304 * @irq: the interrupt number
305 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700306 *
307 * Simple interrupts are either sent from a demultiplexing interrupt
308 * handler or come from hardware, where no interrupt hardware control
309 * is necessary.
310 *
311 * Note: The caller is expected to handle the ack, clear, mask and
312 * unmask issues if necessary.
313 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800314void
David Howells7d12e782006-10-05 14:55:46 +0100315handle_simple_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700316{
317 struct irqaction *action;
318 irqreturn_t action_ret;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700319
320 spin_lock(&desc->lock);
321
322 if (unlikely(desc->status & IRQ_INPROGRESS))
323 goto out_unlock;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100324 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200325 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700326
327 action = desc->action;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100328 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700329 goto out_unlock;
330
331 desc->status |= IRQ_INPROGRESS;
332 spin_unlock(&desc->lock);
333
David Howells7d12e782006-10-05 14:55:46 +0100334 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700335 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100336 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700337
338 spin_lock(&desc->lock);
339 desc->status &= ~IRQ_INPROGRESS;
340out_unlock:
341 spin_unlock(&desc->lock);
342}
343
344/**
345 * handle_level_irq - Level type irq handler
346 * @irq: the interrupt number
347 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700348 *
349 * Level type interrupts are active as long as the hardware line has
350 * the active level. This may require to mask the interrupt and unmask
351 * it after the associated handler has acknowledged the device, so the
352 * interrupt line is back to inactive.
353 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800354void
David Howells7d12e782006-10-05 14:55:46 +0100355handle_level_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700356{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700357 struct irqaction *action;
358 irqreturn_t action_ret;
359
360 spin_lock(&desc->lock);
361 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800362 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700363
364 if (unlikely(desc->status & IRQ_INPROGRESS))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200365 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700366 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200367 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700368
369 /*
370 * If its disabled or no action available
371 * keep it masked and get out of here
372 */
373 action = desc->action;
Thomas Gleixner49663422007-08-12 15:46:34 +0000374 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200375 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700376
377 desc->status |= IRQ_INPROGRESS;
378 spin_unlock(&desc->lock);
379
David Howells7d12e782006-10-05 14:55:46 +0100380 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700381 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100382 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700383
384 spin_lock(&desc->lock);
385 desc->status &= ~IRQ_INPROGRESS;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700386 if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
387 desc->chip->unmask(irq);
Ingo Molnar86998aa2006-09-19 11:14:34 +0200388out_unlock:
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700389 spin_unlock(&desc->lock);
390}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100391EXPORT_SYMBOL_GPL(handle_level_irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700392
393/**
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700394 * handle_fasteoi_irq - irq handler for transparent controllers
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700395 * @irq: the interrupt number
396 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700397 *
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700398 * Only a single callback will be issued to the chip: an ->eoi()
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700399 * call when the interrupt has been serviced. This enables support
400 * for modern forms of interrupt handlers, which handle the flow
401 * details in hardware, transparently.
402 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800403void
David Howells7d12e782006-10-05 14:55:46 +0100404handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700405{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700406 struct irqaction *action;
407 irqreturn_t action_ret;
408
409 spin_lock(&desc->lock);
410
411 if (unlikely(desc->status & IRQ_INPROGRESS))
412 goto out;
413
414 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200415 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700416
417 /*
418 * If its disabled or no action available
Ingo Molnar76d21602007-02-16 01:28:24 -0800419 * then mask it and get out of here:
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700420 */
421 action = desc->action;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700422 if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
423 desc->status |= IRQ_PENDING;
Ingo Molnar76d21602007-02-16 01:28:24 -0800424 if (desc->chip->mask)
425 desc->chip->mask(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700426 goto out;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700427 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700428
429 desc->status |= IRQ_INPROGRESS;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700430 desc->status &= ~IRQ_PENDING;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700431 spin_unlock(&desc->lock);
432
David Howells7d12e782006-10-05 14:55:46 +0100433 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700434 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100435 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700436
437 spin_lock(&desc->lock);
438 desc->status &= ~IRQ_INPROGRESS;
439out:
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700440 desc->chip->eoi(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800441 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700442
443 spin_unlock(&desc->lock);
444}
445
446/**
447 * handle_edge_irq - edge type IRQ handler
448 * @irq: the interrupt number
449 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700450 *
451 * Interrupt occures on the falling and/or rising edge of a hardware
452 * signal. The occurence is latched into the irq controller hardware
453 * and must be acked in order to be reenabled. After the ack another
454 * interrupt can happen on the same source even before the first one
455 * is handled by the assosiacted event handler. If this happens it
456 * might be necessary to disable (mask) the interrupt depending on the
457 * controller hardware. This requires to reenable the interrupt inside
458 * of the loop which handles the interrupts which have arrived while
459 * the handler was running. If all pending interrupts are handled, the
460 * loop is left.
461 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800462void
David Howells7d12e782006-10-05 14:55:46 +0100463handle_edge_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700464{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700465 spin_lock(&desc->lock);
466
467 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
468
469 /*
470 * If we're currently running this IRQ, or its disabled,
471 * we shouldn't process the IRQ. Mark it pending, handle
472 * the necessary masking and go out
473 */
474 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
475 !desc->action)) {
476 desc->status |= (IRQ_PENDING | IRQ_MASKED);
477 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800478 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700479 goto out_unlock;
480 }
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200481 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700482
483 /* Start handling the irq */
Wang Chenefdc64f2008-12-29 13:35:11 +0800484 if (desc->chip->ack)
485 desc->chip->ack(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800486 desc = irq_remap_to_desc(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700487
488 /* Mark the IRQ currently in progress.*/
489 desc->status |= IRQ_INPROGRESS;
490
491 do {
492 struct irqaction *action = desc->action;
493 irqreturn_t action_ret;
494
495 if (unlikely(!action)) {
496 desc->chip->mask(irq);
497 goto out_unlock;
498 }
499
500 /*
501 * When another irq arrived while we were handling
502 * one, we could have masked the irq.
503 * Renable it, if it was not disabled in meantime.
504 */
505 if (unlikely((desc->status &
506 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
507 (IRQ_PENDING | IRQ_MASKED))) {
508 desc->chip->unmask(irq);
509 desc->status &= ~IRQ_MASKED;
510 }
511
512 desc->status &= ~IRQ_PENDING;
513 spin_unlock(&desc->lock);
David Howells7d12e782006-10-05 14:55:46 +0100514 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700515 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100516 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700517 spin_lock(&desc->lock);
518
519 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
520
521 desc->status &= ~IRQ_INPROGRESS;
522out_unlock:
523 spin_unlock(&desc->lock);
524}
525
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700526/**
527 * handle_percpu_IRQ - Per CPU local irq handler
528 * @irq: the interrupt number
529 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700530 *
531 * Per CPU interrupts on SMP machines without locking requirements
532 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800533void
David Howells7d12e782006-10-05 14:55:46 +0100534handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700535{
536 irqreturn_t action_ret;
537
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200538 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700539
540 if (desc->chip->ack)
541 desc->chip->ack(irq);
542
David Howells7d12e782006-10-05 14:55:46 +0100543 action_ret = handle_IRQ_event(irq, desc->action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700544 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100545 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700546
Yinghai Lu48a1b102008-12-11 00:15:01 -0800547 if (desc->chip->eoi) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700548 desc->chip->eoi(irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800549 desc = irq_remap_to_desc(irq, desc);
550 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700551}
552
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700553void
Ingo Molnara460e742006-10-17 00:10:03 -0700554__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
555 const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700556{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200557 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700558 unsigned long flags;
559
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700560 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700561 printk(KERN_ERR
562 "Trying to install type control for IRQ%d\n", irq);
563 return;
564 }
565
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700566 if (!handle)
567 handle = handle_bad_irq;
Thomas Gleixner9d7ac8b2006-12-22 01:08:14 -0800568 else if (desc->chip == &no_irq_chip) {
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100569 printk(KERN_WARNING "Trying to install %sinterrupt handler "
Geert Uytterhoevenb039db82006-12-20 15:59:48 +0100570 "for IRQ%d\n", is_chained ? "chained " : "", irq);
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100571 /*
572 * Some ARM implementations install a handler for really dumb
573 * interrupt hardware without setting an irq_chip. This worked
574 * with the ARM no_irq_chip but the check in setup_irq would
575 * prevent us to setup the interrupt at all. Switch it to
576 * dummy_irq_chip for easy transition.
577 */
578 desc->chip = &dummy_irq_chip;
579 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700580
581 spin_lock_irqsave(&desc->lock, flags);
582
583 /* Uninstall? */
584 if (handle == handle_bad_irq) {
Yinghai Lu48a1b102008-12-11 00:15:01 -0800585 if (desc->chip != &no_irq_chip) {
Jan Beulich5575ddf2007-02-16 01:28:26 -0800586 mask_ack_irq(desc, irq);
Yinghai Lu48a1b102008-12-11 00:15:01 -0800587 desc = irq_remap_to_desc(irq, desc);
588 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700589 desc->status |= IRQ_DISABLED;
590 desc->depth = 1;
591 }
592 desc->handle_irq = handle;
Ingo Molnara460e742006-10-17 00:10:03 -0700593 desc->name = name;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700594
595 if (handle != handle_bad_irq && is_chained) {
596 desc->status &= ~IRQ_DISABLED;
597 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
598 desc->depth = 0;
Pawel MOLL7e6e1782008-09-01 10:12:11 +0100599 desc->chip->startup(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700600 }
601 spin_unlock_irqrestore(&desc->lock, flags);
602}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100603EXPORT_SYMBOL_GPL(__set_irq_handler);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700604
605void
606set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
David Howells57a58a92006-10-05 13:06:34 +0100607 irq_flow_handler_t handle)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700608{
609 set_irq_chip(irq, chip);
Ingo Molnara460e742006-10-17 00:10:03 -0700610 __set_irq_handler(irq, handle, 0, NULL);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700611}
612
Ingo Molnara460e742006-10-17 00:10:03 -0700613void
614set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
615 irq_flow_handler_t handle, const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700616{
Ingo Molnara460e742006-10-17 00:10:03 -0700617 set_irq_chip(irq, chip);
618 __set_irq_handler(irq, handle, 0, name);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700619}
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800620
621void __init set_irq_noprobe(unsigned int irq)
622{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200623 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800624 unsigned long flags;
625
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700626 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800627 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800628 return;
629 }
630
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800631 spin_lock_irqsave(&desc->lock, flags);
632 desc->status |= IRQ_NOPROBE;
633 spin_unlock_irqrestore(&desc->lock, flags);
634}
635
636void __init set_irq_probe(unsigned int irq)
637{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200638 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800639 unsigned long flags;
640
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700641 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800642 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800643 return;
644 }
645
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800646 spin_lock_irqsave(&desc->lock, flags);
647 desc->status &= ~IRQ_NOPROBE;
648 spin_unlock_irqrestore(&desc->lock, flags);
649}