blob: 398fda155f6e26dd72dd1fa00805b1383c156a5d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/irq/manage.c
3 *
Ingo Molnara34db9b2006-06-29 02:24:50 -07004 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006 Thomas Gleixner
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This file contains driver APIs to the irq subsystem.
8 */
9
10#include <linux/irq.h>
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010011#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/module.h>
13#include <linux/random.h>
14#include <linux/interrupt.h>
Robert P. J. Day1aeb2722008-04-29 00:59:25 -070015#include <linux/slab.h>
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010016#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18#include "internals.h"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020/**
21 * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
Randy Dunlap1e5d5332005-11-07 01:01:06 -080022 * @irq: interrupt number to wait for
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 *
24 * This function waits for any pending IRQ handlers for this interrupt
25 * to complete before returning. If you use this function while
26 * holding a resource the IRQ handler may need you will deadlock.
27 *
28 * This function may be called - with care - from IRQ context.
29 */
30void synchronize_irq(unsigned int irq)
31{
Yinghai Lucb5bc832008-08-19 20:50:17 -070032 struct irq_desc *desc = irq_to_desc(irq);
Herbert Xua98ce5c2007-10-23 11:26:25 +080033 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Yinghai Lu7d94f7c2008-08-19 20:50:14 -070035 if (!desc)
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -070036 return;
37
Herbert Xua98ce5c2007-10-23 11:26:25 +080038 do {
39 unsigned long flags;
40
41 /*
42 * Wait until we're out of the critical section. This might
43 * give the wrong answer due to the lack of memory barriers.
44 */
45 while (desc->status & IRQ_INPROGRESS)
46 cpu_relax();
47
48 /* Ok, that indicated we're done: double-check carefully. */
Thomas Gleixner239007b2009-11-17 16:46:45 +010049 raw_spin_lock_irqsave(&desc->lock, flags);
Herbert Xua98ce5c2007-10-23 11:26:25 +080050 status = desc->status;
Thomas Gleixner239007b2009-11-17 16:46:45 +010051 raw_spin_unlock_irqrestore(&desc->lock, flags);
Herbert Xua98ce5c2007-10-23 11:26:25 +080052
53 /* Oops, that failed? */
54 } while (status & IRQ_INPROGRESS);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010055
56 /*
57 * We made sure that no hardirq handler is running. Now verify
58 * that no threaded handlers are active.
59 */
60 wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
Linus Torvalds1da177e2005-04-16 15:20:36 -070061}
Linus Torvalds1da177e2005-04-16 15:20:36 -070062EXPORT_SYMBOL(synchronize_irq);
63
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010064#ifdef CONFIG_SMP
65cpumask_var_t irq_default_affinity;
66
Thomas Gleixner771ee3b2007-02-16 01:27:25 -080067/**
68 * irq_can_set_affinity - Check if the affinity of a given irq can be set
69 * @irq: Interrupt to check
70 *
71 */
72int irq_can_set_affinity(unsigned int irq)
73{
Yinghai Lu08678b02008-08-19 20:50:05 -070074 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixner771ee3b2007-02-16 01:27:25 -080075
76 if (CHECK_IRQ_PER_CPU(desc->status) || !desc->chip ||
77 !desc->chip->set_affinity)
78 return 0;
79
80 return 1;
81}
82
Thomas Gleixner591d2fb2009-07-21 11:09:39 +020083/**
84 * irq_set_thread_affinity - Notify irq threads to adjust affinity
85 * @desc: irq descriptor which has affitnity changed
86 *
87 * We just set IRQTF_AFFINITY and delegate the affinity setting
88 * to the interrupt thread itself. We can not call
89 * set_cpus_allowed_ptr() here as we hold desc->lock and this
90 * code can be called from hard interrupt context.
91 */
92void irq_set_thread_affinity(struct irq_desc *desc)
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010093{
94 struct irqaction *action = desc->action;
95
96 while (action) {
97 if (action->thread)
Thomas Gleixner591d2fb2009-07-21 11:09:39 +020098 set_bit(IRQTF_AFFINITY, &action->thread_flags);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +010099 action = action->next;
100 }
101}
102
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800103/**
104 * irq_set_affinity - Set the irq affinity of a given irq
105 * @irq: Interrupt to set affinity
106 * @cpumask: cpumask
107 *
108 */
Rusty Russell0de26522008-12-13 21:20:26 +1030109int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800110{
Yinghai Lu08678b02008-08-19 20:50:05 -0700111 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100112 unsigned long flags;
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800113
114 if (!desc->chip->set_affinity)
115 return -EINVAL;
116
Thomas Gleixner239007b2009-11-17 16:46:45 +0100117 raw_spin_lock_irqsave(&desc->lock, flags);
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100118
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800119#ifdef CONFIG_GENERIC_PENDING_IRQ
Yinghai Lu57b150c2009-04-27 17:59:53 -0700120 if (desc->status & IRQ_MOVE_PCNTXT) {
121 if (!desc->chip->set_affinity(irq, cpumask)) {
122 cpumask_copy(desc->affinity, cpumask);
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200123 irq_set_thread_affinity(desc);
Yinghai Lu57b150c2009-04-27 17:59:53 -0700124 }
125 }
Pallipadi, Venkatesh6ec3cfe2009-04-13 15:20:58 -0700126 else {
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100127 desc->status |= IRQ_MOVE_PENDING;
Mike Travis7f7ace02009-01-10 21:58:08 -0800128 cpumask_copy(desc->pending_mask, cpumask);
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100129 }
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800130#else
Yinghai Lu57b150c2009-04-27 17:59:53 -0700131 if (!desc->chip->set_affinity(irq, cpumask)) {
132 cpumask_copy(desc->affinity, cpumask);
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200133 irq_set_thread_affinity(desc);
Yinghai Lu57b150c2009-04-27 17:59:53 -0700134 }
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800135#endif
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100136 desc->status |= IRQ_AFFINITY_SET;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100137 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner771ee3b2007-02-16 01:27:25 -0800138 return 0;
139}
140
Max Krasnyansky18404752008-05-29 11:02:52 -0700141#ifndef CONFIG_AUTO_IRQ_AFFINITY
142/*
143 * Generic version of the affinity autoselector.
144 */
Hannes Eder548c8932009-02-08 20:24:47 +0100145static int setup_affinity(unsigned int irq, struct irq_desc *desc)
Max Krasnyansky18404752008-05-29 11:02:52 -0700146{
Max Krasnyansky18404752008-05-29 11:02:52 -0700147 if (!irq_can_set_affinity(irq))
148 return 0;
149
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100150 /*
151 * Preserve an userspace affinity setup, but make sure that
152 * one of the targets is online.
153 */
Thomas Gleixner612e3682008-11-07 13:58:46 +0100154 if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
Mike Travis7f7ace02009-01-10 21:58:08 -0800155 if (cpumask_any_and(desc->affinity, cpu_online_mask)
Rusty Russell0de26522008-12-13 21:20:26 +1030156 < nr_cpu_ids)
157 goto set_affinity;
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100158 else
159 desc->status &= ~IRQ_AFFINITY_SET;
160 }
161
Mike Travis7f7ace02009-01-10 21:58:08 -0800162 cpumask_and(desc->affinity, cpu_online_mask, irq_default_affinity);
Rusty Russell0de26522008-12-13 21:20:26 +1030163set_affinity:
Mike Travis7f7ace02009-01-10 21:58:08 -0800164 desc->chip->set_affinity(irq, desc->affinity);
Max Krasnyansky18404752008-05-29 11:02:52 -0700165
Max Krasnyansky18404752008-05-29 11:02:52 -0700166 return 0;
167}
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100168#else
Hannes Eder548c8932009-02-08 20:24:47 +0100169static inline int setup_affinity(unsigned int irq, struct irq_desc *d)
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100170{
171 return irq_select_affinity(irq);
172}
Max Krasnyansky18404752008-05-29 11:02:52 -0700173#endif
174
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100175/*
176 * Called when affinity is set via /proc/irq
177 */
178int irq_select_affinity_usr(unsigned int irq)
179{
180 struct irq_desc *desc = irq_to_desc(irq);
181 unsigned long flags;
182 int ret;
183
Thomas Gleixner239007b2009-11-17 16:46:45 +0100184 raw_spin_lock_irqsave(&desc->lock, flags);
Hannes Eder548c8932009-02-08 20:24:47 +0100185 ret = setup_affinity(irq, desc);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100186 if (!ret)
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200187 irq_set_thread_affinity(desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100188 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100189
190 return ret;
191}
192
193#else
Hannes Eder548c8932009-02-08 20:24:47 +0100194static inline int setup_affinity(unsigned int irq, struct irq_desc *desc)
Thomas Gleixnerf6d87f42008-11-07 13:18:30 +0100195{
196 return 0;
197}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#endif
199
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100200void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
201{
202 if (suspend) {
203 if (!desc->action || (desc->action->flags & IRQF_TIMER))
204 return;
205 desc->status |= IRQ_SUSPENDED;
206 }
207
208 if (!desc->depth++) {
209 desc->status |= IRQ_DISABLED;
210 desc->chip->disable(irq);
211 }
212}
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214/**
215 * disable_irq_nosync - disable an irq without waiting
216 * @irq: Interrupt to disable
217 *
218 * Disable the selected interrupt line. Disables and Enables are
219 * nested.
220 * Unlike disable_irq(), this function does not ensure existing
221 * instances of the IRQ handler have completed before returning.
222 *
223 * This function may be called from IRQ context.
224 */
225void disable_irq_nosync(unsigned int irq)
226{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200227 struct irq_desc *desc = irq_to_desc(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 unsigned long flags;
229
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700230 if (!desc)
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700231 return;
232
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200233 chip_bus_lock(irq, desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100234 raw_spin_lock_irqsave(&desc->lock, flags);
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100235 __disable_irq(desc, irq, false);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100236 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200237 chip_bus_sync_unlock(irq, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239EXPORT_SYMBOL(disable_irq_nosync);
240
241/**
242 * disable_irq - disable an irq and wait for completion
243 * @irq: Interrupt to disable
244 *
245 * Disable the selected interrupt line. Enables and Disables are
246 * nested.
247 * This function waits for any pending IRQ handlers for this interrupt
248 * to complete before returning. If you use this function while
249 * holding a resource the IRQ handler may need you will deadlock.
250 *
251 * This function may be called - with care - from IRQ context.
252 */
253void disable_irq(unsigned int irq)
254{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200255 struct irq_desc *desc = irq_to_desc(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700257 if (!desc)
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700258 return;
259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 disable_irq_nosync(irq);
261 if (desc->action)
262 synchronize_irq(irq);
263}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264EXPORT_SYMBOL(disable_irq);
265
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100266void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200267{
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100268 if (resume)
269 desc->status &= ~IRQ_SUSPENDED;
270
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200271 switch (desc->depth) {
272 case 0:
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100273 err_out:
Arjan van de Venb8c512f2008-07-25 19:45:36 -0700274 WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200275 break;
276 case 1: {
277 unsigned int status = desc->status & ~IRQ_DISABLED;
278
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100279 if (desc->status & IRQ_SUSPENDED)
280 goto err_out;
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200281 /* Prevent probing on this irq: */
282 desc->status = status | IRQ_NOPROBE;
283 check_irq_resend(desc, irq);
284 /* fall-through */
285 }
286 default:
287 desc->depth--;
288 }
289}
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291/**
292 * enable_irq - enable handling of an irq
293 * @irq: Interrupt to enable
294 *
295 * Undoes the effect of one call to disable_irq(). If this
296 * matches the last disable, processing of interrupts on this
297 * IRQ line is re-enabled.
298 *
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200299 * This function may be called from IRQ context only when
300 * desc->chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 */
302void enable_irq(unsigned int irq)
303{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200304 struct irq_desc *desc = irq_to_desc(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 unsigned long flags;
306
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700307 if (!desc)
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700308 return;
309
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200310 chip_bus_lock(irq, desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100311 raw_spin_lock_irqsave(&desc->lock, flags);
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100312 __enable_irq(desc, irq, false);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100313 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200314 chip_bus_sync_unlock(irq, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316EXPORT_SYMBOL(enable_irq);
317
David Brownell0c5d1eb2008-10-01 14:46:18 -0700318static int set_irq_wake_real(unsigned int irq, unsigned int on)
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200319{
Yinghai Lu08678b02008-08-19 20:50:05 -0700320 struct irq_desc *desc = irq_to_desc(irq);
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200321 int ret = -ENXIO;
322
323 if (desc->chip->set_wake)
324 ret = desc->chip->set_wake(irq, on);
325
326 return ret;
327}
328
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700329/**
330 * set_irq_wake - control irq power management wakeup
331 * @irq: interrupt to control
332 * @on: enable/disable power management wakeup
333 *
David Brownell15a647e2006-07-30 03:03:08 -0700334 * Enable/disable power management wakeup mode, which is
335 * disabled by default. Enables and disables must match,
336 * just as they match for non-wakeup mode support.
337 *
338 * Wakeup mode lets this IRQ wake the system from sleep
339 * states like "suspend to RAM".
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700340 */
341int set_irq_wake(unsigned int irq, unsigned int on)
342{
Yinghai Lu08678b02008-08-19 20:50:05 -0700343 struct irq_desc *desc = irq_to_desc(irq);
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700344 unsigned long flags;
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200345 int ret = 0;
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700346
David Brownell15a647e2006-07-30 03:03:08 -0700347 /* wakeup-capable irqs can be shared between drivers that
348 * don't need to have the same sleep mode behaviors.
349 */
Thomas Gleixner239007b2009-11-17 16:46:45 +0100350 raw_spin_lock_irqsave(&desc->lock, flags);
David Brownell15a647e2006-07-30 03:03:08 -0700351 if (on) {
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200352 if (desc->wake_depth++ == 0) {
353 ret = set_irq_wake_real(irq, on);
354 if (ret)
355 desc->wake_depth = 0;
356 else
357 desc->status |= IRQ_WAKEUP;
358 }
David Brownell15a647e2006-07-30 03:03:08 -0700359 } else {
360 if (desc->wake_depth == 0) {
Arjan van de Ven7a2c4772008-07-25 01:45:54 -0700361 WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200362 } else if (--desc->wake_depth == 0) {
363 ret = set_irq_wake_real(irq, on);
364 if (ret)
365 desc->wake_depth = 1;
366 else
367 desc->status &= ~IRQ_WAKEUP;
368 }
David Brownell15a647e2006-07-30 03:03:08 -0700369 }
Uwe Kleine-König2db87322008-07-23 14:42:25 +0200370
Thomas Gleixner239007b2009-11-17 16:46:45 +0100371 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700372 return ret;
373}
374EXPORT_SYMBOL(set_irq_wake);
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376/*
377 * Internal function that tells the architecture code whether a
378 * particular irq has been exclusively allocated or is available
379 * for driver use.
380 */
381int can_request_irq(unsigned int irq, unsigned long irqflags)
382{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200383 struct irq_desc *desc = irq_to_desc(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct irqaction *action;
Thomas Gleixnercc8c3b72010-03-23 22:40:53 +0100385 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700387 if (!desc)
388 return 0;
389
390 if (desc->status & IRQ_NOREQUEST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 return 0;
392
Thomas Gleixnercc8c3b72010-03-23 22:40:53 +0100393 raw_spin_lock_irqsave(&desc->lock, flags);
Yinghai Lu08678b02008-08-19 20:50:05 -0700394 action = desc->action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (action)
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700396 if (irqflags & action->flags & IRQF_SHARED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 action = NULL;
398
Thomas Gleixnercc8c3b72010-03-23 22:40:53 +0100399 raw_spin_unlock_irqrestore(&desc->lock, flags);
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return !action;
402}
403
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -0700404void compat_irq_chip_set_default_handler(struct irq_desc *desc)
405{
406 /*
407 * If the architecture still has not overriden
408 * the flow handler then zap the default. This
409 * should catch incorrect flow-type setting.
410 */
411 if (desc->handle_irq == &handle_bad_irq)
412 desc->handle_irq = NULL;
413}
414
David Brownell0c5d1eb2008-10-01 14:46:18 -0700415int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700416 unsigned long flags)
417{
418 int ret;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700419 struct irq_chip *chip = desc->chip;
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700420
421 if (!chip || !chip->set_type) {
422 /*
423 * IRQF_TRIGGER_* but the PIC does not support multiple
424 * flow-types?
425 */
Mark Nelson3ff68a62008-11-13 21:37:41 +1100426 pr_debug("No set_type function for IRQ %d (%s)\n", irq,
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700427 chip ? (chip->name ? : "unknown") : "unknown");
428 return 0;
429 }
430
David Brownellf2b662d2008-12-01 14:31:38 -0800431 /* caller masked out all except trigger mode flags */
432 ret = chip->set_type(irq, flags);
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700433
434 if (ret)
David Brownellc69ad712008-08-05 13:01:14 -0700435 pr_err("setting trigger mode %d for irq %u failed (%pF)\n",
David Brownellf2b662d2008-12-01 14:31:38 -0800436 (int)flags, irq, chip->set_type);
David Brownell0c5d1eb2008-10-01 14:46:18 -0700437 else {
David Brownellf2b662d2008-12-01 14:31:38 -0800438 if (flags & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
439 flags |= IRQ_LEVEL;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700440 /* note that IRQF_TRIGGER_MASK == IRQ_TYPE_SENSE_MASK */
David Brownellf2b662d2008-12-01 14:31:38 -0800441 desc->status &= ~(IRQ_LEVEL | IRQ_TYPE_SENSE_MASK);
442 desc->status |= flags;
David Brownell0c5d1eb2008-10-01 14:46:18 -0700443 }
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700444
445 return ret;
446}
447
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200448/*
449 * Default primary interrupt handler for threaded interrupts. Is
450 * assigned as primary handler when request_threaded_irq is called
451 * with handler == NULL. Useful for oneshot interrupts.
452 */
453static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
454{
455 return IRQ_WAKE_THREAD;
456}
457
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200458/*
459 * Primary handler for nested threaded interrupts. Should never be
460 * called.
461 */
462static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
463{
464 WARN(1, "Primary handler called for nested irq %d\n", irq);
465 return IRQ_NONE;
466}
467
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100468static int irq_wait_for_interrupt(struct irqaction *action)
469{
470 while (!kthread_should_stop()) {
471 set_current_state(TASK_INTERRUPTIBLE);
Thomas Gleixnerf48fe812009-03-24 11:46:22 +0100472
473 if (test_and_clear_bit(IRQTF_RUNTHREAD,
474 &action->thread_flags)) {
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100475 __set_current_state(TASK_RUNNING);
476 return 0;
Thomas Gleixnerf48fe812009-03-24 11:46:22 +0100477 }
478 schedule();
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100479 }
480 return -1;
481}
482
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200483/*
484 * Oneshot interrupts keep the irq line masked until the threaded
485 * handler finished. unmask if the interrupt has not been disabled and
486 * is marked MASKED.
487 */
488static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
489{
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100490again:
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200491 chip_bus_lock(irq, desc);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100492 raw_spin_lock_irq(&desc->lock);
Thomas Gleixner0b1adaa2010-03-09 19:45:54 +0100493
494 /*
495 * Implausible though it may be we need to protect us against
496 * the following scenario:
497 *
498 * The thread is faster done than the hard interrupt handler
499 * on the other CPU. If we unmask the irq line then the
500 * interrupt can come in again and masks the line, leaves due
501 * to IRQ_INPROGRESS and the irq line is masked forever.
502 */
503 if (unlikely(desc->status & IRQ_INPROGRESS)) {
504 raw_spin_unlock_irq(&desc->lock);
505 chip_bus_sync_unlock(irq, desc);
506 cpu_relax();
507 goto again;
508 }
509
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200510 if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
511 desc->status &= ~IRQ_MASKED;
512 desc->chip->unmask(irq);
513 }
Thomas Gleixner239007b2009-11-17 16:46:45 +0100514 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200515 chip_bus_sync_unlock(irq, desc);
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200516}
517
Bruno Premont61f38262009-07-22 22:22:32 +0200518#ifdef CONFIG_SMP
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100519/*
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200520 * Check whether we need to change the affinity of the interrupt thread.
521 */
522static void
523irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
524{
525 cpumask_var_t mask;
526
527 if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
528 return;
529
530 /*
531 * In case we are out of memory we set IRQTF_AFFINITY again and
532 * try again next time
533 */
534 if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
535 set_bit(IRQTF_AFFINITY, &action->thread_flags);
536 return;
537 }
538
Thomas Gleixner239007b2009-11-17 16:46:45 +0100539 raw_spin_lock_irq(&desc->lock);
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200540 cpumask_copy(mask, desc->affinity);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100541 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200542
543 set_cpus_allowed_ptr(current, mask);
544 free_cpumask_var(mask);
545}
Bruno Premont61f38262009-07-22 22:22:32 +0200546#else
547static inline void
548irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
549#endif
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200550
551/*
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100552 * Interrupt handler thread
553 */
554static int irq_thread(void *data)
555{
556 struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2, };
557 struct irqaction *action = data;
558 struct irq_desc *desc = irq_to_desc(action->irq);
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200559 int wake, oneshot = desc->status & IRQ_ONESHOT;
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100560
561 sched_setscheduler(current, SCHED_FIFO, &param);
562 current->irqaction = action;
563
564 while (!irq_wait_for_interrupt(action)) {
565
Thomas Gleixner591d2fb2009-07-21 11:09:39 +0200566 irq_thread_check_affinity(desc, action);
567
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100568 atomic_inc(&desc->threads_active);
569
Thomas Gleixner239007b2009-11-17 16:46:45 +0100570 raw_spin_lock_irq(&desc->lock);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100571 if (unlikely(desc->status & IRQ_DISABLED)) {
572 /*
573 * CHECKME: We might need a dedicated
574 * IRQ_THREAD_PENDING flag here, which
575 * retriggers the thread in check_irq_resend()
576 * but AFAICT IRQ_PENDING should be fine as it
577 * retriggers the interrupt itself --- tglx
578 */
579 desc->status |= IRQ_PENDING;
Thomas Gleixner239007b2009-11-17 16:46:45 +0100580 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100581 } else {
Thomas Gleixner239007b2009-11-17 16:46:45 +0100582 raw_spin_unlock_irq(&desc->lock);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100583
584 action->thread_fn(action->irq, action->dev_id);
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200585
586 if (oneshot)
587 irq_finalize_oneshot(action->irq, desc);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100588 }
589
590 wake = atomic_dec_and_test(&desc->threads_active);
591
592 if (wake && waitqueue_active(&desc->wait_for_threads))
593 wake_up(&desc->wait_for_threads);
594 }
595
596 /*
597 * Clear irqaction. Otherwise exit_irq_thread() would make
598 * fuzz about an active irq thread going into nirvana.
599 */
600 current->irqaction = NULL;
601 return 0;
602}
603
604/*
605 * Called from do_exit()
606 */
607void exit_irq_thread(void)
608{
609 struct task_struct *tsk = current;
610
611 if (!tsk->irqaction)
612 return;
613
614 printk(KERN_ERR
615 "exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
616 tsk->comm ? tsk->comm : "", tsk->pid, tsk->irqaction->irq);
617
618 /*
619 * Set the THREAD DIED flag to prevent further wakeups of the
620 * soon to be gone threaded handler.
621 */
622 set_bit(IRQTF_DIED, &tsk->irqaction->flags);
623}
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625/*
626 * Internal function to register an irqaction - typically used to
627 * allocate special interrupts that are part of the architecture.
628 */
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200629static int
Ingo Molnar327ec562009-02-15 11:21:37 +0100630__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Ingo Molnarf17c7542009-02-17 20:43:37 +0100632 struct irqaction *old, **old_ptr;
Andrew Morton8b126b72006-11-14 02:03:23 -0800633 const char *old_name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 unsigned long flags;
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200635 int nested, shared = 0;
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700636 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700638 if (!desc)
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700639 return -EINVAL;
640
Ingo Molnarf1c26622006-06-29 02:24:57 -0700641 if (desc->chip == &no_irq_chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return -ENOSYS;
643 /*
644 * Some drivers like serial.c use request_irq() heavily,
645 * so we have to be careful not to interfere with a
646 * running system.
647 */
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700648 if (new->flags & IRQF_SAMPLE_RANDOM) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /*
650 * This function might sleep, we want to call it first,
651 * outside of the atomic block.
652 * Yes, this might clear the entropy pool if the wrong
653 * driver is attempted to be loaded, without actually
654 * installing a new handler, but is this really a problem,
655 * only the sysadmin is able to do this.
656 */
657 rand_initialize_irq(irq);
658 }
659
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200660 /* Oneshot interrupts are not allowed with shared */
661 if ((new->flags & IRQF_ONESHOT) && (new->flags & IRQF_SHARED))
662 return -EINVAL;
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 /*
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200665 * Check whether the interrupt nests into another interrupt
666 * thread.
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100667 */
Thomas Gleixner399b5da2009-08-13 13:21:38 +0200668 nested = desc->status & IRQ_NESTED_THREAD;
669 if (nested) {
670 if (!new->thread_fn)
671 return -EINVAL;
672 /*
673 * Replace the primary handler which was provided from
674 * the driver for non nested interrupt handling by the
675 * dummy function which warns when called.
676 */
677 new->handler = irq_nested_primary_handler;
678 }
679
680 /*
681 * Create a handler thread when a thread function is supplied
682 * and the interrupt does not nest into another interrupt
683 * thread.
684 */
685 if (new->thread_fn && !nested) {
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100686 struct task_struct *t;
687
688 t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
689 new->name);
690 if (IS_ERR(t))
691 return PTR_ERR(t);
692 /*
693 * We keep the reference to the task struct even if
694 * the thread dies to avoid that the interrupt code
695 * references an already freed task_struct.
696 */
697 get_task_struct(t);
698 new->thread = t;
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100699 }
700
701 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 * The following block of code has to be executed atomically
703 */
Thomas Gleixner239007b2009-11-17 16:46:45 +0100704 raw_spin_lock_irqsave(&desc->lock, flags);
Ingo Molnarf17c7542009-02-17 20:43:37 +0100705 old_ptr = &desc->action;
706 old = *old_ptr;
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700707 if (old) {
Thomas Gleixnere76de9f2006-06-29 02:24:56 -0700708 /*
709 * Can't share interrupts unless both agree to and are
710 * the same type (level, edge, polarity). So both flag
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700711 * fields must have IRQF_SHARED set and the bits which
Thomas Gleixnere76de9f2006-06-29 02:24:56 -0700712 * set the trigger type must match.
713 */
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700714 if (!((old->flags & new->flags) & IRQF_SHARED) ||
Andrew Morton8b126b72006-11-14 02:03:23 -0800715 ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) {
716 old_name = old->name;
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800717 goto mismatch;
Andrew Morton8b126b72006-11-14 02:03:23 -0800718 }
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800719
Thomas Gleixner284c6682006-07-03 02:20:32 +0200720#if defined(CONFIG_IRQ_PER_CPU)
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800721 /* All handlers must agree on per-cpuness */
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700722 if ((old->flags & IRQF_PERCPU) !=
723 (new->flags & IRQF_PERCPU))
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800724 goto mismatch;
725#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727 /* add new interrupt at end of irq queue */
728 do {
Ingo Molnarf17c7542009-02-17 20:43:37 +0100729 old_ptr = &old->next;
730 old = *old_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 } while (old);
732 shared = 1;
733 }
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (!shared) {
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -0700736 irq_chip_set_defaults(desc->chip);
Thomas Gleixnere76de9f2006-06-29 02:24:56 -0700737
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100738 init_waitqueue_head(&desc->wait_for_threads);
739
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700740 /* Setup the type (level, edge polarity) if configured: */
741 if (new->flags & IRQF_TRIGGER_MASK) {
David Brownellf2b662d2008-12-01 14:31:38 -0800742 ret = __irq_set_trigger(desc, irq,
743 new->flags & IRQF_TRIGGER_MASK);
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700744
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100745 if (ret)
746 goto out_thread;
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700747 } else
748 compat_irq_chip_set_default_handler(desc);
Ahmed S. Darwishf75d2222007-05-08 00:27:55 -0700749#if defined(CONFIG_IRQ_PER_CPU)
750 if (new->flags & IRQF_PERCPU)
751 desc->status |= IRQ_PER_CPU;
752#endif
753
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200754 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | IRQ_ONESHOT |
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200755 IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
Thomas Gleixner94d39e12006-06-29 02:24:50 -0700756
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200757 if (new->flags & IRQF_ONESHOT)
758 desc->status |= IRQ_ONESHOT;
759
Thomas Gleixner94d39e12006-06-29 02:24:50 -0700760 if (!(desc->status & IRQ_NOAUTOEN)) {
761 desc->depth = 0;
762 desc->status &= ~IRQ_DISABLED;
Pawel MOLL7e6e1782008-09-01 10:12:11 +0100763 desc->chip->startup(irq);
Thomas Gleixnere76de9f2006-06-29 02:24:56 -0700764 } else
765 /* Undo nested disables: */
766 desc->depth = 1;
Max Krasnyansky18404752008-05-29 11:02:52 -0700767
Thomas Gleixner612e3682008-11-07 13:58:46 +0100768 /* Exclude IRQ from balancing if requested */
769 if (new->flags & IRQF_NOBALANCING)
770 desc->status |= IRQ_NO_BALANCING;
771
Max Krasnyansky18404752008-05-29 11:02:52 -0700772 /* Set default affinity mask once everything is setup */
Hannes Eder548c8932009-02-08 20:24:47 +0100773 setup_affinity(irq, desc);
David Brownell0c5d1eb2008-10-01 14:46:18 -0700774
775 } else if ((new->flags & IRQF_TRIGGER_MASK)
776 && (new->flags & IRQF_TRIGGER_MASK)
777 != (desc->status & IRQ_TYPE_SENSE_MASK)) {
778 /* hope the handler works with the actual trigger mode... */
779 pr_warning("IRQ %d uses trigger mode %d; requested %d\n",
780 irq, (int)(desc->status & IRQ_TYPE_SENSE_MASK),
781 (int)(new->flags & IRQF_TRIGGER_MASK));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700783
Thomas Gleixner69ab8492009-08-17 14:07:16 +0200784 new->irq = irq;
Ingo Molnarf17c7542009-02-17 20:43:37 +0100785 *old_ptr = new;
Uwe Kleine-König82736f42008-07-23 21:28:54 -0700786
Linus Torvalds8528b0f2007-01-23 14:16:31 -0800787 /* Reset broken irq detection when installing new handler */
788 desc->irq_count = 0;
789 desc->irqs_unhandled = 0;
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200790
791 /*
792 * Check whether we disabled the irq via the spurious handler
793 * before. Reenable it and give it another chance.
794 */
795 if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
796 desc->status &= ~IRQ_SPURIOUS_DISABLED;
Rafael J. Wysocki0a0c5162009-03-16 22:33:49 +0100797 __enable_irq(desc, irq, false);
Thomas Gleixner1adb0852008-04-28 17:01:56 +0200798 }
799
Thomas Gleixner239007b2009-11-17 16:46:45 +0100800 raw_spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Thomas Gleixner69ab8492009-08-17 14:07:16 +0200802 /*
803 * Strictly no need to wake it up, but hung_task complains
804 * when no hard interrupt wakes the thread up.
805 */
806 if (new->thread)
807 wake_up_process(new->thread);
808
Yinghai Lu2c6927a2008-08-19 20:50:11 -0700809 register_irq_proc(irq, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 new->dir = NULL;
811 register_handler_proc(irq, new);
812
813 return 0;
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800814
815mismatch:
Alan Cox3f050442007-02-12 00:52:04 -0800816#ifdef CONFIG_DEBUG_SHIRQ
Thomas Gleixner3cca53b2006-07-01 19:29:31 -0700817 if (!(new->flags & IRQF_PROBE_SHARED)) {
Bjorn Helgaase8c4b9d2006-07-01 04:35:45 -0700818 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
Andrew Morton8b126b72006-11-14 02:03:23 -0800819 if (old_name)
820 printk(KERN_ERR "current handler: %s\n", old_name);
Andrew Morton13e87ec2006-04-27 18:39:18 -0700821 dump_stack();
822 }
Alan Cox3f050442007-02-12 00:52:04 -0800823#endif
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100824 ret = -EBUSY;
825
826out_thread:
Thomas Gleixner239007b2009-11-17 16:46:45 +0100827 raw_spin_unlock_irqrestore(&desc->lock, flags);
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100828 if (new->thread) {
829 struct task_struct *t = new->thread;
830
831 new->thread = NULL;
832 if (likely(!test_bit(IRQTF_DIED, &new->thread_flags)))
833 kthread_stop(t);
834 put_task_struct(t);
835 }
836 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837}
838
839/**
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200840 * setup_irq - setup an interrupt
841 * @irq: Interrupt line to setup
842 * @act: irqaction for the interrupt
843 *
844 * Used to statically setup interrupts in the early boot process.
845 */
846int setup_irq(unsigned int irq, struct irqaction *act)
847{
848 struct irq_desc *desc = irq_to_desc(irq);
849
850 return __setup_irq(irq, desc, act);
851}
Magnus Dammeb53b4e2009-03-12 21:05:59 +0900852EXPORT_SYMBOL_GPL(setup_irq);
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200853
Magnus Dammcbf94f02009-03-12 21:05:51 +0900854 /*
855 * Internal function to unregister an irqaction - used to free
856 * regular and special interrupts that are part of the architecture.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 */
Magnus Dammcbf94f02009-03-12 21:05:51 +0900858static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Thomas Gleixnerd3c60042008-10-16 09:55:00 +0200860 struct irq_desc *desc = irq_to_desc(irq);
Ingo Molnarf17c7542009-02-17 20:43:37 +0100861 struct irqaction *action, **action_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 unsigned long flags;
863
Ingo Molnarae88a232009-02-15 11:29:50 +0100864 WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700865
Yinghai Lu7d94f7c2008-08-19 20:50:14 -0700866 if (!desc)
Magnus Dammf21cfb22009-03-12 21:05:42 +0900867 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Thomas Gleixner239007b2009-11-17 16:46:45 +0100869 raw_spin_lock_irqsave(&desc->lock, flags);
Ingo Molnarae88a232009-02-15 11:29:50 +0100870
871 /*
872 * There can be multiple actions per IRQ descriptor, find the right
873 * one based on the dev_id:
874 */
Ingo Molnarf17c7542009-02-17 20:43:37 +0100875 action_ptr = &desc->action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 for (;;) {
Ingo Molnarf17c7542009-02-17 20:43:37 +0100877 action = *action_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
Ingo Molnarae88a232009-02-15 11:29:50 +0100879 if (!action) {
880 WARN(1, "Trying to free already-free IRQ %d\n", irq);
Thomas Gleixner239007b2009-11-17 16:46:45 +0100881 raw_spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Magnus Dammf21cfb22009-03-12 21:05:42 +0900883 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
Ingo Molnarae88a232009-02-15 11:29:50 +0100885
Ingo Molnar8316e382009-02-17 20:28:29 +0100886 if (action->dev_id == dev_id)
887 break;
Ingo Molnarf17c7542009-02-17 20:43:37 +0100888 action_ptr = &action->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 }
Ingo Molnarae88a232009-02-15 11:29:50 +0100890
891 /* Found it - now remove it from the list of entries: */
Ingo Molnarf17c7542009-02-17 20:43:37 +0100892 *action_ptr = action->next;
Ingo Molnarae88a232009-02-15 11:29:50 +0100893
894 /* Currently used only by UML, might disappear one day: */
895#ifdef CONFIG_IRQ_RELEASE_METHOD
896 if (desc->chip->release)
897 desc->chip->release(irq, dev_id);
898#endif
899
900 /* If this was the last handler, shut down the IRQ line: */
901 if (!desc->action) {
902 desc->status |= IRQ_DISABLED;
903 if (desc->chip->shutdown)
904 desc->chip->shutdown(irq);
905 else
906 desc->chip->disable(irq);
907 }
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100908
Thomas Gleixner239007b2009-11-17 16:46:45 +0100909 raw_spin_unlock_irqrestore(&desc->lock, flags);
Ingo Molnarae88a232009-02-15 11:29:50 +0100910
911 unregister_handler_proc(irq, action);
912
913 /* Make sure it's not being used on another CPU: */
914 synchronize_irq(irq);
915
916#ifdef CONFIG_DEBUG_SHIRQ
917 /*
918 * It's a shared IRQ -- the driver ought to be prepared for an IRQ
919 * event to happen even now it's being freed, so let's make sure that
920 * is so by doing an extra call to the handler ....
921 *
922 * ( We do this after actually deregistering it, to make sure that a
923 * 'real' IRQ doesn't run in * parallel with our fake. )
924 */
925 if (action->flags & IRQF_SHARED) {
926 local_irq_save(flags);
927 action->handler(irq, dev_id);
928 local_irq_restore(flags);
929 }
930#endif
Linus Torvalds2d860ad2009-08-13 13:05:10 -0700931
932 if (action->thread) {
933 if (!test_bit(IRQTF_DIED, &action->thread_flags))
934 kthread_stop(action->thread);
935 put_task_struct(action->thread);
936 }
937
Magnus Dammf21cfb22009-03-12 21:05:42 +0900938 return action;
939}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941/**
Magnus Dammcbf94f02009-03-12 21:05:51 +0900942 * remove_irq - free an interrupt
943 * @irq: Interrupt line to free
944 * @act: irqaction for the interrupt
945 *
946 * Used to remove interrupts statically setup by the early boot process.
947 */
948void remove_irq(unsigned int irq, struct irqaction *act)
949{
950 __free_irq(irq, act->dev_id);
951}
Magnus Dammeb53b4e2009-03-12 21:05:59 +0900952EXPORT_SYMBOL_GPL(remove_irq);
Magnus Dammcbf94f02009-03-12 21:05:51 +0900953
954/**
Magnus Dammf21cfb22009-03-12 21:05:42 +0900955 * free_irq - free an interrupt allocated with request_irq
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 * @irq: Interrupt line to free
957 * @dev_id: Device identity to free
958 *
959 * Remove an interrupt handler. The handler is removed and if the
960 * interrupt line is no longer in use by any driver it is disabled.
961 * On a shared IRQ the caller must ensure the interrupt is disabled
962 * on the card it drives before calling this function. The function
963 * does not return until any executing interrupts for this IRQ
964 * have completed.
965 *
966 * This function must not be called from interrupt context.
967 */
968void free_irq(unsigned int irq, void *dev_id)
969{
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200970 struct irq_desc *desc = irq_to_desc(irq);
971
972 if (!desc)
973 return;
974
975 chip_bus_lock(irq, desc);
Magnus Dammcbf94f02009-03-12 21:05:51 +0900976 kfree(__free_irq(irq, dev_id));
Thomas Gleixner70aedd22009-08-13 12:17:48 +0200977 chip_bus_sync_unlock(irq, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979EXPORT_SYMBOL(free_irq);
980
981/**
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100982 * request_threaded_irq - allocate an interrupt line
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 * @irq: Interrupt line to allocate
Thomas Gleixner3aa551c2009-03-23 18:28:15 +0100984 * @handler: Function to be called when the IRQ occurs.
985 * Primary handler for threaded interrupts
Thomas Gleixnerb25c3402009-08-13 12:17:22 +0200986 * If NULL and thread_fn != NULL the default
987 * primary handler is installed
Thomas Gleixnerf48fe812009-03-24 11:46:22 +0100988 * @thread_fn: Function called from the irq handler thread
989 * If NULL, no irq thread is created
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 * @irqflags: Interrupt type flags
991 * @devname: An ascii name for the claiming device
992 * @dev_id: A cookie passed back to the handler function
993 *
994 * This call allocates interrupt resources and enables the
995 * interrupt line and IRQ handling. From the point this
996 * call is made your handler function may be invoked. Since
997 * your handler function must clear any interrupt the board
998 * raises, you must take care both to initialise your hardware
999 * and to set up the interrupt handler in the right order.
1000 *
Thomas Gleixner3aa551c2009-03-23 18:28:15 +01001001 * If you want to set up a threaded irq handler for your device
1002 * then you need to supply @handler and @thread_fn. @handler ist
1003 * still called in hard interrupt context and has to check
1004 * whether the interrupt originates from the device. If yes it
1005 * needs to disable the interrupt on the device and return
Steven Rostedt39a2edd2009-05-12 14:35:54 -04001006 * IRQ_WAKE_THREAD which will wake up the handler thread and run
Thomas Gleixner3aa551c2009-03-23 18:28:15 +01001007 * @thread_fn. This split handler design is necessary to support
1008 * shared interrupts.
1009 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 * Dev_id must be globally unique. Normally the address of the
1011 * device data structure is used as the cookie. Since the handler
1012 * receives this value it makes sense to use it.
1013 *
1014 * If your interrupt is shared you must pass a non NULL dev_id
1015 * as this is required when freeing the interrupt.
1016 *
1017 * Flags:
1018 *
Thomas Gleixner3cca53b2006-07-01 19:29:31 -07001019 * IRQF_SHARED Interrupt is shared
1020 * IRQF_DISABLED Disable local interrupts while processing
1021 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
David Brownell0c5d1eb2008-10-01 14:46:18 -07001022 * IRQF_TRIGGER_* Specify active edge(s) or level
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 *
1024 */
Thomas Gleixner3aa551c2009-03-23 18:28:15 +01001025int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1026 irq_handler_t thread_fn, unsigned long irqflags,
1027 const char *devname, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028{
Ingo Molnar06fcb0c2006-06-29 02:24:40 -07001029 struct irqaction *action;
Yinghai Lu08678b02008-08-19 20:50:05 -07001030 struct irq_desc *desc;
Thomas Gleixnerd3c60042008-10-16 09:55:00 +02001031 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
David Brownell470c6622008-12-01 14:31:37 -08001033 /*
1034 * handle_IRQ_event() always ignores IRQF_DISABLED except for
1035 * the _first_ irqaction (sigh). That can cause oopsing, but
1036 * the behavior is classified as "will not fix" so we need to
1037 * start nudging drivers away from using that idiom.
1038 */
Ingo Molnar327ec562009-02-15 11:21:37 +01001039 if ((irqflags & (IRQF_SHARED|IRQF_DISABLED)) ==
1040 (IRQF_SHARED|IRQF_DISABLED)) {
1041 pr_warning(
1042 "IRQ %d/%s: IRQF_DISABLED is not guaranteed on shared IRQs\n",
1043 irq, devname);
1044 }
David Brownell470c6622008-12-01 14:31:37 -08001045
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001046#ifdef CONFIG_LOCKDEP
1047 /*
1048 * Lockdep wants atomic interrupt handlers:
1049 */
Thomas Gleixner38515e92007-02-14 00:33:16 -08001050 irqflags |= IRQF_DISABLED;
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001051#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 /*
1053 * Sanity-check: shared interrupts must pass in a real dev-ID,
1054 * otherwise we'll have trouble later trying to figure out
1055 * which interrupt is which (messes up the interrupt freeing
1056 * logic etc).
1057 */
Thomas Gleixner3cca53b2006-07-01 19:29:31 -07001058 if ((irqflags & IRQF_SHARED) && !dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return -EINVAL;
Yinghai Lu7d94f7c2008-08-19 20:50:14 -07001060
Yinghai Lucb5bc832008-08-19 20:50:17 -07001061 desc = irq_to_desc(irq);
Yinghai Lu7d94f7c2008-08-19 20:50:14 -07001062 if (!desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 return -EINVAL;
Yinghai Lu7d94f7c2008-08-19 20:50:14 -07001064
Yinghai Lu08678b02008-08-19 20:50:05 -07001065 if (desc->status & IRQ_NOREQUEST)
Thomas Gleixner6550c772006-06-29 02:24:49 -07001066 return -EINVAL;
Thomas Gleixnerb25c3402009-08-13 12:17:22 +02001067
1068 if (!handler) {
1069 if (!thread_fn)
1070 return -EINVAL;
1071 handler = irq_default_primary_handler;
1072 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Thomas Gleixner45535732009-02-22 23:00:32 +01001074 action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (!action)
1076 return -ENOMEM;
1077
1078 action->handler = handler;
Thomas Gleixner3aa551c2009-03-23 18:28:15 +01001079 action->thread_fn = thread_fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 action->flags = irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 action->name = devname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 action->dev_id = dev_id;
1083
Thomas Gleixner70aedd22009-08-13 12:17:48 +02001084 chip_bus_lock(irq, desc);
Thomas Gleixnerd3c60042008-10-16 09:55:00 +02001085 retval = __setup_irq(irq, desc, action);
Thomas Gleixner70aedd22009-08-13 12:17:48 +02001086 chip_bus_sync_unlock(irq, desc);
1087
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001088 if (retval)
1089 kfree(action);
1090
David Woodhousea304e1b2007-02-12 00:52:00 -08001091#ifdef CONFIG_DEBUG_SHIRQ
Luis Henriques6ce51c42009-04-01 18:06:35 +01001092 if (!retval && (irqflags & IRQF_SHARED)) {
David Woodhousea304e1b2007-02-12 00:52:00 -08001093 /*
1094 * It's a shared IRQ -- the driver ought to be prepared for it
1095 * to happen immediately, so let's make sure....
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001096 * We disable the irq to make sure that a 'real' IRQ doesn't
1097 * run in parallel with our fake.
David Woodhousea304e1b2007-02-12 00:52:00 -08001098 */
Jarek Poplawski59845b12007-08-30 23:56:34 -07001099 unsigned long flags;
David Woodhousea304e1b2007-02-12 00:52:00 -08001100
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001101 disable_irq(irq);
Jarek Poplawski59845b12007-08-30 23:56:34 -07001102 local_irq_save(flags);
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001103
Jarek Poplawski59845b12007-08-30 23:56:34 -07001104 handler(irq, dev_id);
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001105
Jarek Poplawski59845b12007-08-30 23:56:34 -07001106 local_irq_restore(flags);
Anton Vorontsov377bf1e2008-08-21 22:58:28 +04001107 enable_irq(irq);
David Woodhousea304e1b2007-02-12 00:52:00 -08001108 }
1109#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return retval;
1111}
Thomas Gleixner3aa551c2009-03-23 18:28:15 +01001112EXPORT_SYMBOL(request_threaded_irq);