blob: 8775dd39ab3d348bd275b43f23a9736034323527 [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
Brandon Phiilpsced5b692010-02-10 01:20:06 -080021static void dynamic_irq_init_x(unsigned int irq, bool keep_chip_data)
Eric W. Biederman3a16d712006-10-04 02:16:37 -070022{
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080023 struct irq_desc *desc;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070024 unsigned long flags;
25
Yinghai Lu0b8f1ef2008-12-05 18:58:31 -080026 desc = irq_to_desc(irq);
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070027 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -070028 WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070029 return;
30 }
31
32 /* Ensure we don't have left over values from a previous use of this irq */
Thomas Gleixner239007b2009-11-17 16:46:45 +010033 raw_spin_lock_irqsave(&desc->lock, flags);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070034 desc->status = IRQ_DISABLED;
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020035 desc->irq_data.chip = &no_irq_chip;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070036 desc->handle_irq = handle_bad_irq;
37 desc->depth = 1;
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020038 desc->irq_data.msi_desc = NULL;
39 desc->irq_data.handler_data = NULL;
Brandon Phiilpsced5b692010-02-10 01:20:06 -080040 if (!keep_chip_data)
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020041 desc->irq_data.chip_data = NULL;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070042 desc->action = NULL;
43 desc->irq_count = 0;
44 desc->irqs_unhandled = 0;
45#ifdef CONFIG_SMP
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020046 cpumask_setall(desc->irq_data.affinity);
Mike Travis7f7ace02009-01-10 21:58:08 -080047#ifdef CONFIG_GENERIC_PENDING_IRQ
48 cpumask_clear(desc->pending_mask);
49#endif
Eric W. Biederman3a16d712006-10-04 02:16:37 -070050#endif
Thomas Gleixner239007b2009-11-17 16:46:45 +010051 raw_spin_unlock_irqrestore(&desc->lock, flags);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070052}
53
54/**
Brandon Phiilpsced5b692010-02-10 01:20:06 -080055 * dynamic_irq_init - initialize a dynamically allocated irq
Eric W. Biederman3a16d712006-10-04 02:16:37 -070056 * @irq: irq number to initialize
57 */
Brandon Phiilpsced5b692010-02-10 01:20:06 -080058void dynamic_irq_init(unsigned int irq)
59{
60 dynamic_irq_init_x(irq, false);
61}
62
63/**
64 * dynamic_irq_init_keep_chip_data - initialize a dynamically allocated irq
65 * @irq: irq number to initialize
66 *
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020067 * does not set irq_to_desc(irq)->irq_data.chip_data to NULL
Brandon Phiilpsced5b692010-02-10 01:20:06 -080068 */
69void dynamic_irq_init_keep_chip_data(unsigned int irq)
70{
71 dynamic_irq_init_x(irq, true);
72}
73
74static void dynamic_irq_cleanup_x(unsigned int irq, bool keep_chip_data)
Eric W. Biederman3a16d712006-10-04 02:16:37 -070075{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +020076 struct irq_desc *desc = irq_to_desc(irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070077 unsigned long flags;
78
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070079 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -070080 WARN(1, KERN_ERR "Trying to cleanup invalid IRQ%d\n", irq);
Eric W. Biederman3a16d712006-10-04 02:16:37 -070081 return;
82 }
83
Thomas Gleixner239007b2009-11-17 16:46:45 +010084 raw_spin_lock_irqsave(&desc->lock, flags);
Eric W. Biederman1f800252006-10-04 02:16:56 -070085 if (desc->action) {
Thomas Gleixner239007b2009-11-17 16:46:45 +010086 raw_spin_unlock_irqrestore(&desc->lock, flags);
Arjan van de Ven261c40c2008-07-25 19:45:37 -070087 WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
Eric W. Biederman1f800252006-10-04 02:16:56 -070088 irq);
Eric W. Biederman1f800252006-10-04 02:16:56 -070089 return;
90 }
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020091 desc->irq_data.msi_desc = NULL;
92 desc->irq_data.handler_data = NULL;
Brandon Phiilpsced5b692010-02-10 01:20:06 -080093 if (!keep_chip_data)
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020094 desc->irq_data.chip_data = NULL;
Eric W. Biederman3a16d712006-10-04 02:16:37 -070095 desc->handle_irq = handle_bad_irq;
Thomas Gleixner6b8ff312010-10-01 12:58:38 +020096 desc->irq_data.chip = &no_irq_chip;
Dean Nelsonb6f3b782008-10-18 16:06:56 -070097 desc->name = NULL;
Yinghai Lu0f3c2a82009-02-08 16:18:03 -080098 clear_kstat_irqs(desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +010099 raw_spin_unlock_irqrestore(&desc->lock, flags);
Eric W. Biederman3a16d712006-10-04 02:16:37 -0700100}
101
Brandon Phiilpsced5b692010-02-10 01:20:06 -0800102/**
103 * dynamic_irq_cleanup - cleanup a dynamically allocated irq
104 * @irq: irq number to initialize
105 */
106void dynamic_irq_cleanup(unsigned int irq)
107{
108 dynamic_irq_cleanup_x(irq, false);
109}
110
111/**
112 * dynamic_irq_cleanup_keep_chip_data - cleanup a dynamically allocated irq
113 * @irq: irq number to initialize
114 *
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200115 * does not set irq_to_desc(irq)->irq_data.chip_data to NULL
Brandon Phiilpsced5b692010-02-10 01:20:06 -0800116 */
117void dynamic_irq_cleanup_keep_chip_data(unsigned int irq)
118{
119 dynamic_irq_cleanup_x(irq, true);
120}
121
Eric W. Biederman3a16d712006-10-04 02:16:37 -0700122
123/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700124 * set_irq_chip - set the irq chip for an irq
125 * @irq: irq number
126 * @chip: pointer to irq chip description structure
127 */
128int set_irq_chip(unsigned int irq, struct irq_chip *chip)
129{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200130 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700131 unsigned long flags;
132
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700133 if (!desc) {
Arjan van de Ven261c40c2008-07-25 19:45:37 -0700134 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700135 return -EINVAL;
136 }
137
138 if (!chip)
139 chip = &no_irq_chip;
140
Thomas Gleixner239007b2009-11-17 16:46:45 +0100141 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700142 irq_chip_set_defaults(chip);
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200143 desc->irq_data.chip = chip;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100144 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700145
146 return 0;
147}
148EXPORT_SYMBOL(set_irq_chip);
149
150/**
David Brownell0c5d1eb2008-10-01 14:46:18 -0700151 * set_irq_type - set the irq trigger type for an irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700152 * @irq: irq number
David Brownell0c5d1eb2008-10-01 14:46:18 -0700153 * @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700154 */
155int set_irq_type(unsigned int irq, unsigned int type)
156{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200157 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700158 unsigned long flags;
159 int ret = -ENXIO;
160
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700161 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700162 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
163 return -ENODEV;
164 }
165
David Brownellf2b662d2008-12-01 14:31:38 -0800166 type &= IRQ_TYPE_SENSE_MASK;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700167 if (type == IRQ_TYPE_NONE)
168 return 0;
169
Thomas Gleixner239007b2009-11-17 16:46:45 +0100170 raw_spin_lock_irqsave(&desc->lock, flags);
Chris Friesen0b3682ba32008-10-20 12:41:58 -0600171 ret = __irq_set_trigger(desc, irq, type);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100172 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700173 return ret;
174}
175EXPORT_SYMBOL(set_irq_type);
176
177/**
178 * set_irq_data - set irq type data for an irq
179 * @irq: Interrupt number
180 * @data: Pointer to interrupt specific data
181 *
182 * Set the hardware irq controller data for an irq
183 */
184int set_irq_data(unsigned int irq, void *data)
185{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200186 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700187 unsigned long flags;
188
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700189 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700190 printk(KERN_ERR
191 "Trying to install controller data for IRQ%d\n", irq);
192 return -EINVAL;
193 }
194
Thomas Gleixner239007b2009-11-17 16:46:45 +0100195 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200196 desc->irq_data.handler_data = data;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100197 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700198 return 0;
199}
200EXPORT_SYMBOL(set_irq_data);
201
202/**
Liuweni24b26d42009-11-04 20:11:05 +0800203 * set_irq_msi - set MSI descriptor data for an irq
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700204 * @irq: Interrupt number
Randy Dunlap472900b2007-02-16 01:28:25 -0800205 * @entry: Pointer to MSI descriptor data
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700206 *
Liuweni24b26d42009-11-04 20:11:05 +0800207 * Set the MSI descriptor entry for an irq
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700208 */
209int set_irq_msi(unsigned int irq, struct msi_desc *entry)
210{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200211 struct irq_desc *desc = irq_to_desc(irq);
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700212 unsigned long flags;
213
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700214 if (!desc) {
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700215 printk(KERN_ERR
216 "Trying to install msi data for IRQ%d\n", irq);
217 return -EINVAL;
218 }
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700219
Thomas Gleixner239007b2009-11-17 16:46:45 +0100220 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200221 desc->irq_data.msi_desc = entry;
Michael Ellerman7fe37302007-04-18 19:39:21 +1000222 if (entry)
223 entry->irq = irq;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100224 raw_spin_unlock_irqrestore(&desc->lock, flags);
Eric W. Biederman5b912c12007-01-28 12:52:03 -0700225 return 0;
226}
227
228/**
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700229 * set_irq_chip_data - set irq chip data for an irq
230 * @irq: Interrupt number
231 * @data: Pointer to chip specific data
232 *
233 * Set the hardware irq chip data for an irq
234 */
235int set_irq_chip_data(unsigned int irq, void *data)
236{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200237 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700238 unsigned long flags;
239
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700240 if (!desc) {
241 printk(KERN_ERR
242 "Trying to install chip data for IRQ%d\n", irq);
243 return -EINVAL;
244 }
245
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200246 if (!desc->irq_data.chip) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700247 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
248 return -EINVAL;
249 }
250
Thomas Gleixner239007b2009-11-17 16:46:45 +0100251 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200252 desc->irq_data.chip_data = data;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100253 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700254
255 return 0;
256}
257EXPORT_SYMBOL(set_irq_chip_data);
258
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200259/**
260 * set_irq_nested_thread - Set/Reset the IRQ_NESTED_THREAD flag of an irq
261 *
262 * @irq: Interrupt number
263 * @nest: 0 to clear / 1 to set the IRQ_NESTED_THREAD flag
264 *
265 * The IRQ_NESTED_THREAD flag indicates that on
266 * request_threaded_irq() no separate interrupt thread should be
267 * created for the irq as the handler are called nested in the
268 * context of a demultiplexing interrupt handler thread.
269 */
270void set_irq_nested_thread(unsigned int irq, int nest)
271{
272 struct irq_desc *desc = irq_to_desc(irq);
273 unsigned long flags;
274
275 if (!desc)
276 return;
277
Thomas Gleixner239007b2009-11-17 16:46:45 +0100278 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200279 if (nest)
280 desc->status |= IRQ_NESTED_THREAD;
281 else
282 desc->status &= ~IRQ_NESTED_THREAD;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100283 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200284}
285EXPORT_SYMBOL_GPL(set_irq_nested_thread);
286
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700287/*
288 * default enable function
289 */
Thomas Gleixnerc5f75632010-09-27 12:44:56 +0000290static void default_enable(struct irq_data *data)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700291{
Thomas Gleixnerc5f75632010-09-27 12:44:56 +0000292 struct irq_desc *desc = irq_data_to_desc(data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700293
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000294 desc->irq_data.chip->irq_unmask(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700295 desc->status &= ~IRQ_MASKED;
296}
297
298/*
299 * default disable function
300 */
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000301static void default_disable(struct irq_data *data)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700302{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700303}
304
305/*
306 * default startup function
307 */
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000308static unsigned int default_startup(struct irq_data *data)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700309{
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000310 struct irq_desc *desc = irq_data_to_desc(data);
Yinghai Lu08678b02008-08-19 20:50:05 -0700311
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000312 desc->irq_data.chip->irq_enable(data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700313 return 0;
314}
315
316/*
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100317 * default shutdown function
318 */
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000319static void default_shutdown(struct irq_data *data)
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100320{
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000321 struct irq_desc *desc = irq_data_to_desc(data);
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100322
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000323 desc->irq_data.chip->irq_mask(&desc->irq_data);
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100324 desc->status |= IRQ_MASKED;
325}
326
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000327/* Temporary migration helpers */
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000328static void compat_irq_mask(struct irq_data *data)
329{
330 data->chip->mask(data->irq);
331}
332
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000333static void compat_irq_unmask(struct irq_data *data)
334{
335 data->chip->unmask(data->irq);
336}
337
Thomas Gleixner22a49162010-09-27 12:44:47 +0000338static void compat_irq_ack(struct irq_data *data)
339{
340 data->chip->ack(data->irq);
341}
342
Thomas Gleixner9205e312010-09-27 12:44:50 +0000343static void compat_irq_mask_ack(struct irq_data *data)
344{
345 data->chip->mask_ack(data->irq);
346}
347
Thomas Gleixner0c5c1552010-09-27 12:44:53 +0000348static void compat_irq_eoi(struct irq_data *data)
349{
350 data->chip->eoi(data->irq);
351}
352
Thomas Gleixnerc5f75632010-09-27 12:44:56 +0000353static void compat_irq_enable(struct irq_data *data)
354{
355 data->chip->enable(data->irq);
356}
357
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000358static void compat_irq_disable(struct irq_data *data)
359{
360 data->chip->disable(data->irq);
361}
362
363static void compat_irq_shutdown(struct irq_data *data)
364{
365 data->chip->shutdown(data->irq);
366}
367
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000368static unsigned int compat_irq_startup(struct irq_data *data)
369{
370 return data->chip->startup(data->irq);
371}
372
Thomas Gleixnerc96b3b32010-09-27 12:45:41 +0000373static int compat_irq_set_affinity(struct irq_data *data,
374 const struct cpumask *dest, bool force)
375{
376 return data->chip->set_affinity(data->irq, dest);
377}
378
Thomas Gleixnerb2ba2c32010-09-27 12:45:47 +0000379static int compat_irq_set_type(struct irq_data *data, unsigned int type)
380{
381 return data->chip->set_type(data->irq, type);
382}
383
Thomas Gleixner2f7e99b2010-09-27 12:45:50 +0000384static int compat_irq_set_wake(struct irq_data *data, unsigned int on)
385{
386 return data->chip->set_wake(data->irq, on);
387}
388
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000389static void compat_bus_lock(struct irq_data *data)
390{
391 data->chip->bus_lock(data->irq);
392}
393
394static void compat_bus_sync_unlock(struct irq_data *data)
395{
396 data->chip->bus_sync_unlock(data->irq);
397}
398
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100399/*
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700400 * Fixup enable/disable function pointers
401 */
402void irq_chip_set_defaults(struct irq_chip *chip)
403{
Thomas Gleixnerc5f75632010-09-27 12:44:56 +0000404 /*
405 * Compat fixup functions need to be before we set the
406 * defaults for enable/disable/startup/shutdown
407 */
408 if (chip->enable)
409 chip->irq_enable = compat_irq_enable;
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000410 if (chip->disable)
411 chip->irq_disable = compat_irq_disable;
412 if (chip->shutdown)
413 chip->irq_shutdown = compat_irq_shutdown;
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000414 if (chip->startup)
415 chip->irq_startup = compat_irq_startup;
Thomas Gleixnerc5f75632010-09-27 12:44:56 +0000416
417 /*
418 * The real defaults
419 */
420 if (!chip->irq_enable)
421 chip->irq_enable = default_enable;
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000422 if (!chip->irq_disable)
423 chip->irq_disable = default_disable;
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000424 if (!chip->irq_startup)
425 chip->irq_startup = default_startup;
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100426 /*
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000427 * We use chip->irq_disable, when the user provided its own. When
428 * we have default_disable set for chip->irq_disable, then we need
Thomas Gleixner89d694b2008-02-18 18:25:17 +0100429 * to use default_shutdown, otherwise the irq line is not
430 * disabled on free_irq():
431 */
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000432 if (!chip->irq_shutdown)
433 chip->irq_shutdown = chip->irq_disable != default_disable ?
434 chip->irq_disable : default_shutdown;
Zhang, Yanminb86432b2006-11-16 01:19:10 -0800435 if (!chip->end)
436 chip->end = dummy_irq_chip.end;
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000437
Thomas Gleixnerbc310dd2010-09-27 12:45:02 +0000438 /*
439 * Now fix up the remaining compat handlers
440 */
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000441 if (chip->bus_lock)
442 chip->irq_bus_lock = compat_bus_lock;
443 if (chip->bus_sync_unlock)
444 chip->irq_bus_sync_unlock = compat_bus_sync_unlock;
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000445 if (chip->mask)
446 chip->irq_mask = compat_irq_mask;
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000447 if (chip->unmask)
448 chip->irq_unmask = compat_irq_unmask;
Thomas Gleixner22a49162010-09-27 12:44:47 +0000449 if (chip->ack)
450 chip->irq_ack = compat_irq_ack;
Thomas Gleixner9205e312010-09-27 12:44:50 +0000451 if (chip->mask_ack)
452 chip->irq_mask_ack = compat_irq_mask_ack;
Thomas Gleixner0c5c1552010-09-27 12:44:53 +0000453 if (chip->eoi)
454 chip->irq_eoi = compat_irq_eoi;
Thomas Gleixnerc96b3b32010-09-27 12:45:41 +0000455 if (chip->set_affinity)
456 chip->irq_set_affinity = compat_irq_set_affinity;
Thomas Gleixnerb2ba2c32010-09-27 12:45:47 +0000457 if (chip->set_type)
458 chip->irq_set_type = compat_irq_set_type;
Thomas Gleixner2f7e99b2010-09-27 12:45:50 +0000459 if (chip->set_wake)
460 chip->irq_set_wake = compat_irq_set_wake;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700461}
462
Thomas Gleixner9205e312010-09-27 12:44:50 +0000463static inline void mask_ack_irq(struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700464{
Thomas Gleixner9205e312010-09-27 12:44:50 +0000465 if (desc->irq_data.chip->irq_mask_ack)
466 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700467 else {
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000468 desc->irq_data.chip->irq_mask(&desc->irq_data);
Thomas Gleixner22a49162010-09-27 12:44:47 +0000469 if (desc->irq_data.chip->irq_ack)
470 desc->irq_data.chip->irq_ack(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700471 }
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100472 desc->status |= IRQ_MASKED;
473}
474
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000475static inline void mask_irq(struct irq_desc *desc)
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100476{
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000477 if (desc->irq_data.chip->irq_mask) {
478 desc->irq_data.chip->irq_mask(&desc->irq_data);
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100479 desc->status |= IRQ_MASKED;
480 }
481}
482
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000483static inline void unmask_irq(struct irq_desc *desc)
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100484{
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000485 if (desc->irq_data.chip->irq_unmask) {
486 desc->irq_data.chip->irq_unmask(&desc->irq_data);
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100487 desc->status &= ~IRQ_MASKED;
488 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700489}
490
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200491/*
492 * handle_nested_irq - Handle a nested irq from a irq thread
493 * @irq: the interrupt number
494 *
495 * Handle interrupts which are nested into a threaded interrupt
496 * handler. The handler function is called inside the calling
497 * threads context.
498 */
499void handle_nested_irq(unsigned int irq)
500{
501 struct irq_desc *desc = irq_to_desc(irq);
502 struct irqaction *action;
503 irqreturn_t action_ret;
504
505 might_sleep();
506
Thomas Gleixner239007b2009-11-17 16:46:45 +0100507 raw_spin_lock_irq(&desc->lock);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200508
509 kstat_incr_irqs_this_cpu(irq, desc);
510
511 action = desc->action;
512 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
513 goto out_unlock;
514
515 desc->status |= IRQ_INPROGRESS;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100516 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200517
518 action_ret = action->thread_fn(action->irq, action->dev_id);
519 if (!noirqdebug)
520 note_interrupt(irq, desc, action_ret);
521
Thomas Gleixner239007b2009-11-17 16:46:45 +0100522 raw_spin_lock_irq(&desc->lock);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200523 desc->status &= ~IRQ_INPROGRESS;
524
525out_unlock:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100526 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200527}
528EXPORT_SYMBOL_GPL(handle_nested_irq);
529
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700530/**
531 * handle_simple_irq - Simple and software-decoded IRQs.
532 * @irq: the interrupt number
533 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700534 *
535 * Simple interrupts are either sent from a demultiplexing interrupt
536 * handler or come from hardware, where no interrupt hardware control
537 * is necessary.
538 *
539 * Note: The caller is expected to handle the ack, clear, mask and
540 * unmask issues if necessary.
541 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800542void
David Howells7d12e782006-10-05 14:55:46 +0100543handle_simple_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700544{
545 struct irqaction *action;
546 irqreturn_t action_ret;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700547
Thomas Gleixner239007b2009-11-17 16:46:45 +0100548 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700549
550 if (unlikely(desc->status & IRQ_INPROGRESS))
551 goto out_unlock;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100552 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200553 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700554
555 action = desc->action;
Steven Rostedt971e5b35f2007-12-18 18:05:58 +0100556 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700557 goto out_unlock;
558
559 desc->status |= IRQ_INPROGRESS;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100560 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700561
David Howells7d12e782006-10-05 14:55:46 +0100562 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700563 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100564 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700565
Thomas Gleixner239007b2009-11-17 16:46:45 +0100566 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700567 desc->status &= ~IRQ_INPROGRESS;
568out_unlock:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100569 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700570}
571
572/**
573 * handle_level_irq - Level type irq handler
574 * @irq: the interrupt number
575 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700576 *
577 * Level type interrupts are active as long as the hardware line has
578 * the active level. This may require to mask the interrupt and unmask
579 * it after the associated handler has acknowledged the device, so the
580 * interrupt line is back to inactive.
581 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800582void
David Howells7d12e782006-10-05 14:55:46 +0100583handle_level_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700584{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700585 struct irqaction *action;
586 irqreturn_t action_ret;
587
Thomas Gleixner239007b2009-11-17 16:46:45 +0100588 raw_spin_lock(&desc->lock);
Thomas Gleixner9205e312010-09-27 12:44:50 +0000589 mask_ack_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700590
591 if (unlikely(desc->status & IRQ_INPROGRESS))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200592 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700593 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200594 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700595
596 /*
597 * If its disabled or no action available
598 * keep it masked and get out of here
599 */
600 action = desc->action;
Thomas Gleixner49663422007-08-12 15:46:34 +0000601 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
Ingo Molnar86998aa2006-09-19 11:14:34 +0200602 goto out_unlock;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700603
604 desc->status |= IRQ_INPROGRESS;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100605 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700606
David Howells7d12e782006-10-05 14:55:46 +0100607 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700608 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100609 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700610
Thomas Gleixner239007b2009-11-17 16:46:45 +0100611 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700612 desc->status &= ~IRQ_INPROGRESS;
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200613
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100614 if (!(desc->status & (IRQ_DISABLED | IRQ_ONESHOT)))
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000615 unmask_irq(desc);
Ingo Molnar86998aa2006-09-19 11:14:34 +0200616out_unlock:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100617 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700618}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100619EXPORT_SYMBOL_GPL(handle_level_irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700620
621/**
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700622 * handle_fasteoi_irq - irq handler for transparent controllers
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700623 * @irq: the interrupt number
624 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700625 *
Ingo Molnar47c2a3a2006-06-29 02:25:03 -0700626 * Only a single callback will be issued to the chip: an ->eoi()
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700627 * call when the interrupt has been serviced. This enables support
628 * for modern forms of interrupt handlers, which handle the flow
629 * details in hardware, transparently.
630 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800631void
David Howells7d12e782006-10-05 14:55:46 +0100632handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700633{
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700634 struct irqaction *action;
635 irqreturn_t action_ret;
636
Thomas Gleixner239007b2009-11-17 16:46:45 +0100637 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700638
639 if (unlikely(desc->status & IRQ_INPROGRESS))
640 goto out;
641
642 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200643 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700644
645 /*
646 * If its disabled or no action available
Ingo Molnar76d21602007-02-16 01:28:24 -0800647 * then mask it and get out of here:
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700648 */
649 action = desc->action;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700650 if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
651 desc->status |= IRQ_PENDING;
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000652 mask_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700653 goto out;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700654 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700655
656 desc->status |= IRQ_INPROGRESS;
Benjamin Herrenschmidt98bb2442006-06-29 02:25:01 -0700657 desc->status &= ~IRQ_PENDING;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100658 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700659
David Howells7d12e782006-10-05 14:55:46 +0100660 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700661 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100662 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700663
Thomas Gleixner239007b2009-11-17 16:46:45 +0100664 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700665 desc->status &= ~IRQ_INPROGRESS;
666out:
Thomas Gleixner0c5c1552010-09-27 12:44:53 +0000667 desc->irq_data.chip->irq_eoi(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700668
Thomas Gleixner239007b2009-11-17 16:46:45 +0100669 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700670}
671
672/**
673 * handle_edge_irq - edge type IRQ handler
674 * @irq: the interrupt number
675 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700676 *
677 * Interrupt occures on the falling and/or rising edge of a hardware
678 * signal. The occurence is latched into the irq controller hardware
679 * and must be acked in order to be reenabled. After the ack another
680 * interrupt can happen on the same source even before the first one
Uwe Kleine-Königdfff0612010-02-12 21:58:11 +0100681 * is handled by the associated event handler. If this happens it
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700682 * might be necessary to disable (mask) the interrupt depending on the
683 * controller hardware. This requires to reenable the interrupt inside
684 * of the loop which handles the interrupts which have arrived while
685 * the handler was running. If all pending interrupts are handled, the
686 * loop is left.
687 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800688void
David Howells7d12e782006-10-05 14:55:46 +0100689handle_edge_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700690{
Thomas Gleixner239007b2009-11-17 16:46:45 +0100691 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700692
693 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
694
695 /*
696 * If we're currently running this IRQ, or its disabled,
697 * we shouldn't process the IRQ. Mark it pending, handle
698 * the necessary masking and go out
699 */
700 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
701 !desc->action)) {
702 desc->status |= (IRQ_PENDING | IRQ_MASKED);
Thomas Gleixner9205e312010-09-27 12:44:50 +0000703 mask_ack_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700704 goto out_unlock;
705 }
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200706 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700707
708 /* Start handling the irq */
Thomas Gleixner22a49162010-09-27 12:44:47 +0000709 desc->irq_data.chip->irq_ack(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700710
711 /* Mark the IRQ currently in progress.*/
712 desc->status |= IRQ_INPROGRESS;
713
714 do {
715 struct irqaction *action = desc->action;
716 irqreturn_t action_ret;
717
718 if (unlikely(!action)) {
Thomas Gleixnere2c0f8f2010-09-27 12:44:42 +0000719 mask_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700720 goto out_unlock;
721 }
722
723 /*
724 * When another irq arrived while we were handling
725 * one, we could have masked the irq.
726 * Renable it, if it was not disabled in meantime.
727 */
728 if (unlikely((desc->status &
729 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
730 (IRQ_PENDING | IRQ_MASKED))) {
Thomas Gleixner0eda58b2010-09-27 12:44:44 +0000731 unmask_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700732 }
733
734 desc->status &= ~IRQ_PENDING;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100735 raw_spin_unlock(&desc->lock);
David Howells7d12e782006-10-05 14:55:46 +0100736 action_ret = handle_IRQ_event(irq, action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700737 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100738 note_interrupt(irq, desc, action_ret);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100739 raw_spin_lock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700740
741 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
742
743 desc->status &= ~IRQ_INPROGRESS;
744out_unlock:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100745 raw_spin_unlock(&desc->lock);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700746}
747
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700748/**
Liuweni24b26d42009-11-04 20:11:05 +0800749 * handle_percpu_irq - Per CPU local irq handler
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700750 * @irq: the interrupt number
751 * @desc: the interrupt description structure for this irq
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700752 *
753 * Per CPU interrupts on SMP machines without locking requirements
754 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800755void
David Howells7d12e782006-10-05 14:55:46 +0100756handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700757{
758 irqreturn_t action_ret;
759
Thomas Gleixnerd6c88a52008-10-15 15:27:23 +0200760 kstat_incr_irqs_this_cpu(irq, desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700761
Thomas Gleixner22a49162010-09-27 12:44:47 +0000762 if (desc->irq_data.chip->irq_ack)
763 desc->irq_data.chip->irq_ack(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700764
David Howells7d12e782006-10-05 14:55:46 +0100765 action_ret = handle_IRQ_event(irq, desc->action);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700766 if (!noirqdebug)
David Howells7d12e782006-10-05 14:55:46 +0100767 note_interrupt(irq, desc, action_ret);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700768
Thomas Gleixner0c5c1552010-09-27 12:44:53 +0000769 if (desc->irq_data.chip->irq_eoi)
770 desc->irq_data.chip->irq_eoi(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700771}
772
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700773void
Ingo Molnara460e742006-10-17 00:10:03 -0700774__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
775 const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700776{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200777 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700778 unsigned long flags;
779
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700780 if (!desc) {
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700781 printk(KERN_ERR
782 "Trying to install type control for IRQ%d\n", irq);
783 return;
784 }
785
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700786 if (!handle)
787 handle = handle_bad_irq;
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200788 else if (desc->irq_data.chip == &no_irq_chip) {
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100789 printk(KERN_WARNING "Trying to install %sinterrupt handler "
Geert Uytterhoevenb039db82006-12-20 15:59:48 +0100790 "for IRQ%d\n", is_chained ? "chained " : "", irq);
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100791 /*
792 * Some ARM implementations install a handler for really dumb
793 * interrupt hardware without setting an irq_chip. This worked
794 * with the ARM no_irq_chip but the check in setup_irq would
795 * prevent us to setup the interrupt at all. Switch it to
796 * dummy_irq_chip for easy transition.
797 */
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200798 desc->irq_data.chip = &dummy_irq_chip;
Thomas Gleixnerf8b54732006-07-01 22:30:08 +0100799 }
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700800
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000801 chip_bus_lock(desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100802 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700803
804 /* Uninstall? */
805 if (handle == handle_bad_irq) {
Thomas Gleixner6b8ff312010-10-01 12:58:38 +0200806 if (desc->irq_data.chip != &no_irq_chip)
Thomas Gleixner9205e312010-09-27 12:44:50 +0000807 mask_ack_irq(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700808 desc->status |= IRQ_DISABLED;
809 desc->depth = 1;
810 }
811 desc->handle_irq = handle;
Ingo Molnara460e742006-10-17 00:10:03 -0700812 desc->name = name;
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700813
814 if (handle != handle_bad_irq && is_chained) {
815 desc->status &= ~IRQ_DISABLED;
816 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
817 desc->depth = 0;
Thomas Gleixner37e12df2010-09-27 12:45:38 +0000818 desc->irq_data.chip->irq_startup(&desc->irq_data);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700819 }
Thomas Gleixner239007b2009-11-17 16:46:45 +0100820 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner3876ec92010-09-27 12:44:35 +0000821 chip_bus_sync_unlock(desc);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700822}
Ingo Molnar14819ea2009-01-14 12:34:21 +0100823EXPORT_SYMBOL_GPL(__set_irq_handler);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700824
825void
826set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
David Howells57a58a92006-10-05 13:06:34 +0100827 irq_flow_handler_t handle)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700828{
829 set_irq_chip(irq, chip);
Ingo Molnara460e742006-10-17 00:10:03 -0700830 __set_irq_handler(irq, handle, 0, NULL);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700831}
832
Ingo Molnara460e742006-10-17 00:10:03 -0700833void
834set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
835 irq_flow_handler_t handle, const char *name)
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700836{
Ingo Molnara460e742006-10-17 00:10:03 -0700837 set_irq_chip(irq, chip);
838 __set_irq_handler(irq, handle, 0, name);
Thomas Gleixnerdd87eb32006-06-29 02:24:53 -0700839}
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800840
Henrik Kretzschmar860652b2010-03-24 12:59:20 +0100841void set_irq_noprobe(unsigned int irq)
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800842{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200843 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800844 unsigned long flags;
845
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700846 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800847 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800848 return;
849 }
850
Thomas Gleixner239007b2009-11-17 16:46:45 +0100851 raw_spin_lock_irqsave(&desc->lock, flags);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800852 desc->status |= IRQ_NOPROBE;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100853 raw_spin_unlock_irqrestore(&desc->lock, flags);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800854}
855
Henrik Kretzschmar860652b2010-03-24 12:59:20 +0100856void set_irq_probe(unsigned int irq)
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800857{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200858 struct irq_desc *desc = irq_to_desc(irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800859 unsigned long flags;
860
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700861 if (!desc) {
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800862 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800863 return;
864 }
865
Thomas Gleixner239007b2009-11-17 16:46:45 +0100866 raw_spin_lock_irqsave(&desc->lock, flags);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800867 desc->status &= ~IRQ_NOPROBE;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100868 raw_spin_unlock_irqrestore(&desc->lock, flags);
Ralf Baechle46f4f8f2008-02-08 04:22:01 -0800869}