2 * linux/kernel/irq/manage.c
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006 Thomas Gleixner
7 * This file contains driver APIs to the irq subsystem.
10 #include <linux/config.h>
11 #include <linux/irq.h>
12 #include <linux/module.h>
13 #include <linux/random.h>
14 #include <linux/interrupt.h>
16 #include "internals.h"
21 * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
22 * @irq: interrupt number to wait for
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.
28 * This function may be called - with care - from IRQ context.
30 void synchronize_irq(unsigned int irq
)
32 struct irq_desc
*desc
= irq_desc
+ irq
;
37 while (desc
->status
& IRQ_INPROGRESS
)
40 EXPORT_SYMBOL(synchronize_irq
);
45 * disable_irq_nosync - disable an irq without waiting
46 * @irq: Interrupt to disable
48 * Disable the selected interrupt line. Disables and Enables are
50 * Unlike disable_irq(), this function does not ensure existing
51 * instances of the IRQ handler have completed before returning.
53 * This function may be called from IRQ context.
55 void disable_irq_nosync(unsigned int irq
)
57 struct irq_desc
*desc
= irq_desc
+ irq
;
63 spin_lock_irqsave(&desc
->lock
, flags
);
65 desc
->status
|= IRQ_DISABLED
;
66 desc
->chip
->disable(irq
);
68 spin_unlock_irqrestore(&desc
->lock
, flags
);
70 EXPORT_SYMBOL(disable_irq_nosync
);
73 * disable_irq - disable an irq and wait for completion
74 * @irq: Interrupt to disable
76 * Disable the selected interrupt line. Enables and Disables are
78 * This function waits for any pending IRQ handlers for this interrupt
79 * to complete before returning. If you use this function while
80 * holding a resource the IRQ handler may need you will deadlock.
82 * This function may be called - with care - from IRQ context.
84 void disable_irq(unsigned int irq
)
86 struct irq_desc
*desc
= irq_desc
+ irq
;
91 disable_irq_nosync(irq
);
95 EXPORT_SYMBOL(disable_irq
);
98 * enable_irq - enable handling of an irq
99 * @irq: Interrupt to enable
101 * Undoes the effect of one call to disable_irq(). If this
102 * matches the last disable, processing of interrupts on this
103 * IRQ line is re-enabled.
105 * This function may be called from IRQ context.
107 void enable_irq(unsigned int irq
)
109 struct irq_desc
*desc
= irq_desc
+ irq
;
115 spin_lock_irqsave(&desc
->lock
, flags
);
116 switch (desc
->depth
) {
118 printk(KERN_WARNING
"Unablanced enable_irq(%d)\n", irq
);
122 unsigned int status
= desc
->status
& ~IRQ_DISABLED
;
124 /* Prevent probing on this irq: */
125 desc
->status
= status
| IRQ_NOPROBE
;
126 check_irq_resend(desc
, irq
);
132 spin_unlock_irqrestore(&desc
->lock
, flags
);
134 EXPORT_SYMBOL(enable_irq
);
137 * Internal function that tells the architecture code whether a
138 * particular irq has been exclusively allocated or is available
141 int can_request_irq(unsigned int irq
, unsigned long irqflags
)
143 struct irqaction
*action
;
145 if (irq
>= NR_IRQS
|| irq_desc
[irq
].status
& IRQ_NOREQUEST
)
148 action
= irq_desc
[irq
].action
;
150 if (irqflags
& action
->flags
& SA_SHIRQ
)
156 void compat_irq_chip_set_default_handler(struct irq_desc
*desc
)
159 * If the architecture still has not overriden
160 * the flow handler then zap the default. This
161 * should catch incorrect flow-type setting.
163 if (desc
->handle_irq
== &handle_bad_irq
)
164 desc
->handle_irq
= NULL
;
168 * Internal function to register an irqaction - typically used to
169 * allocate special interrupts that are part of the architecture.
171 int setup_irq(unsigned int irq
, struct irqaction
*new)
173 struct irq_desc
*desc
= irq_desc
+ irq
;
174 struct irqaction
*old
, **p
;
181 if (desc
->chip
== &no_irq_type
)
184 * Some drivers like serial.c use request_irq() heavily,
185 * so we have to be careful not to interfere with a
188 if (new->flags
& SA_SAMPLE_RANDOM
) {
190 * This function might sleep, we want to call it first,
191 * outside of the atomic block.
192 * Yes, this might clear the entropy pool if the wrong
193 * driver is attempted to be loaded, without actually
194 * installing a new handler, but is this really a problem,
195 * only the sysadmin is able to do this.
197 rand_initialize_irq(irq
);
201 * The following block of code has to be executed atomically
203 spin_lock_irqsave(&desc
->lock
, flags
);
207 /* Can't share interrupts unless both agree to */
208 if (!(old
->flags
& new->flags
& SA_SHIRQ
))
211 #if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
212 /* All handlers must agree on per-cpuness */
213 if ((old
->flags
& IRQ_PER_CPU
) != (new->flags
& IRQ_PER_CPU
))
217 /* add new interrupt at end of irq queue */
226 #if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
227 if (new->flags
& SA_PERCPU_IRQ
)
228 desc
->status
|= IRQ_PER_CPU
;
231 irq_chip_set_defaults(desc
->chip
);
232 compat_irq_chip_set_default_handler(desc
);
234 desc
->status
&= ~(IRQ_AUTODETECT
| IRQ_WAITING
|
237 if (!(desc
->status
& IRQ_NOAUTOEN
)) {
239 desc
->status
&= ~IRQ_DISABLED
;
240 if (desc
->chip
->startup
)
241 desc
->chip
->startup(irq
);
243 desc
->chip
->enable(irq
);
246 spin_unlock_irqrestore(&desc
->lock
, flags
);
249 register_irq_proc(irq
);
251 register_handler_proc(irq
, new);
256 spin_unlock_irqrestore(&desc
->lock
, flags
);
257 if (!(new->flags
& SA_PROBEIRQ
)) {
258 printk(KERN_ERR
"%s: irq handler mismatch\n", __FUNCTION__
);
265 * free_irq - free an interrupt
266 * @irq: Interrupt line to free
267 * @dev_id: Device identity to free
269 * Remove an interrupt handler. The handler is removed and if the
270 * interrupt line is no longer in use by any driver it is disabled.
271 * On a shared IRQ the caller must ensure the interrupt is disabled
272 * on the card it drives before calling this function. The function
273 * does not return until any executing interrupts for this IRQ
276 * This function must not be called from interrupt context.
278 void free_irq(unsigned int irq
, void *dev_id
)
280 struct irq_desc
*desc
;
281 struct irqaction
**p
;
284 WARN_ON(in_interrupt());
288 desc
= irq_desc
+ irq
;
289 spin_lock_irqsave(&desc
->lock
, flags
);
292 struct irqaction
*action
= *p
;
295 struct irqaction
**pp
= p
;
298 if (action
->dev_id
!= dev_id
)
301 /* Found it - now remove it from the list of entries */
304 /* Currently used only by UML, might disappear one day.*/
305 #ifdef CONFIG_IRQ_RELEASE_METHOD
306 if (desc
->chip
->release
)
307 desc
->chip
->release(irq
, dev_id
);
311 desc
->status
|= IRQ_DISABLED
;
312 if (desc
->chip
->shutdown
)
313 desc
->chip
->shutdown(irq
);
315 desc
->chip
->disable(irq
);
317 spin_unlock_irqrestore(&desc
->lock
, flags
);
318 unregister_handler_proc(irq
, action
);
320 /* Make sure it's not being used on another CPU */
321 synchronize_irq(irq
);
325 printk(KERN_ERR
"Trying to free free IRQ%d\n", irq
);
326 spin_unlock_irqrestore(&desc
->lock
, flags
);
330 EXPORT_SYMBOL(free_irq
);
333 * request_irq - allocate an interrupt line
334 * @irq: Interrupt line to allocate
335 * @handler: Function to be called when the IRQ occurs
336 * @irqflags: Interrupt type flags
337 * @devname: An ascii name for the claiming device
338 * @dev_id: A cookie passed back to the handler function
340 * This call allocates interrupt resources and enables the
341 * interrupt line and IRQ handling. From the point this
342 * call is made your handler function may be invoked. Since
343 * your handler function must clear any interrupt the board
344 * raises, you must take care both to initialise your hardware
345 * and to set up the interrupt handler in the right order.
347 * Dev_id must be globally unique. Normally the address of the
348 * device data structure is used as the cookie. Since the handler
349 * receives this value it makes sense to use it.
351 * If your interrupt is shared you must pass a non NULL dev_id
352 * as this is required when freeing the interrupt.
356 * SA_SHIRQ Interrupt is shared
357 * SA_INTERRUPT Disable local interrupts while processing
358 * SA_SAMPLE_RANDOM The interrupt can be used for entropy
361 int request_irq(unsigned int irq
,
362 irqreturn_t (*handler
)(int, void *, struct pt_regs
*),
363 unsigned long irqflags
, const char *devname
, void *dev_id
)
365 struct irqaction
*action
;
369 * Sanity-check: shared interrupts must pass in a real dev-ID,
370 * otherwise we'll have trouble later trying to figure out
371 * which interrupt is which (messes up the interrupt freeing
374 if ((irqflags
& SA_SHIRQ
) && !dev_id
)
378 if (irq_desc
[irq
].status
& IRQ_NOREQUEST
)
383 action
= kmalloc(sizeof(struct irqaction
), GFP_ATOMIC
);
387 action
->handler
= handler
;
388 action
->flags
= irqflags
;
389 cpus_clear(action
->mask
);
390 action
->name
= devname
;
392 action
->dev_id
= dev_id
;
394 select_smp_affinity(irq
);
396 retval
= setup_irq(irq
, action
);
402 EXPORT_SYMBOL(request_irq
);