blob: 3ed7aee848651c1924db31da8ba53deb9301b3fc [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
Paolo 'Blaisorblade' Giarrussob77d6ad2005-06-21 17:16:24 -070010#include <linux/config.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/irq.h>
12#include <linux/module.h>
13#include <linux/random.h>
14#include <linux/interrupt.h>
15
16#include "internals.h"
17
18#ifdef CONFIG_SMP
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{
32 struct irq_desc *desc = irq_desc + irq;
33
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -070034 if (irq >= NR_IRQS)
35 return;
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 while (desc->status & IRQ_INPROGRESS)
38 cpu_relax();
39}
Linus Torvalds1da177e2005-04-16 15:20:36 -070040EXPORT_SYMBOL(synchronize_irq);
41
42#endif
43
44/**
45 * disable_irq_nosync - disable an irq without waiting
46 * @irq: Interrupt to disable
47 *
48 * Disable the selected interrupt line. Disables and Enables are
49 * nested.
50 * Unlike disable_irq(), this function does not ensure existing
51 * instances of the IRQ handler have completed before returning.
52 *
53 * This function may be called from IRQ context.
54 */
55void disable_irq_nosync(unsigned int irq)
56{
Ingo Molnar34ffdb72006-06-29 02:24:40 -070057 struct irq_desc *desc = irq_desc + irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 unsigned long flags;
59
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -070060 if (irq >= NR_IRQS)
61 return;
62
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 spin_lock_irqsave(&desc->lock, flags);
64 if (!desc->depth++) {
65 desc->status |= IRQ_DISABLED;
Ingo Molnard1bef4e2006-06-29 02:24:36 -070066 desc->chip->disable(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 }
68 spin_unlock_irqrestore(&desc->lock, flags);
69}
Linus Torvalds1da177e2005-04-16 15:20:36 -070070EXPORT_SYMBOL(disable_irq_nosync);
71
72/**
73 * disable_irq - disable an irq and wait for completion
74 * @irq: Interrupt to disable
75 *
76 * Disable the selected interrupt line. Enables and Disables are
77 * nested.
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.
81 *
82 * This function may be called - with care - from IRQ context.
83 */
84void disable_irq(unsigned int irq)
85{
Ingo Molnar34ffdb72006-06-29 02:24:40 -070086 struct irq_desc *desc = irq_desc + irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -070088 if (irq >= NR_IRQS)
89 return;
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 disable_irq_nosync(irq);
92 if (desc->action)
93 synchronize_irq(irq);
94}
Linus Torvalds1da177e2005-04-16 15:20:36 -070095EXPORT_SYMBOL(disable_irq);
96
97/**
98 * enable_irq - enable handling of an irq
99 * @irq: Interrupt to enable
100 *
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.
104 *
105 * This function may be called from IRQ context.
106 */
107void enable_irq(unsigned int irq)
108{
Ingo Molnar34ffdb72006-06-29 02:24:40 -0700109 struct irq_desc *desc = irq_desc + irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 unsigned long flags;
111
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700112 if (irq >= NR_IRQS)
113 return;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 spin_lock_irqsave(&desc->lock, flags);
116 switch (desc->depth) {
117 case 0:
Thomas Gleixner096c8132006-06-29 02:24:44 -0700118 printk(KERN_WARNING "Unablanced enable_irq(%d)\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 WARN_ON(1);
120 break;
121 case 1: {
Thomas Gleixner3418d722006-06-29 02:24:49 -0700122 unsigned int status = desc->status & ~IRQ_DISABLED;
123
124 /* Prevent probing on this irq: */
125 desc->status = status | IRQ_NOPROBE;
Thomas Gleixnera4633adc2006-06-29 02:24:48 -0700126 check_irq_resend(desc, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 /* fall-through */
128 }
129 default:
130 desc->depth--;
131 }
132 spin_unlock_irqrestore(&desc->lock, flags);
133}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134EXPORT_SYMBOL(enable_irq);
135
Thomas Gleixnerba9a2332006-06-29 02:24:55 -0700136/**
137 * set_irq_wake - control irq power management wakeup
138 * @irq: interrupt to control
139 * @on: enable/disable power management wakeup
140 *
141 * Enable/disable power management wakeup mode
142 */
143int set_irq_wake(unsigned int irq, unsigned int on)
144{
145 struct irq_desc *desc = irq_desc + irq;
146 unsigned long flags;
147 int ret = -ENXIO;
148
149 spin_lock_irqsave(&desc->lock, flags);
150 if (desc->chip->set_wake)
151 ret = desc->chip->set_wake(irq, on);
152 spin_unlock_irqrestore(&desc->lock, flags);
153 return ret;
154}
155EXPORT_SYMBOL(set_irq_wake);
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157/*
158 * Internal function that tells the architecture code whether a
159 * particular irq has been exclusively allocated or is available
160 * for driver use.
161 */
162int can_request_irq(unsigned int irq, unsigned long irqflags)
163{
164 struct irqaction *action;
165
Thomas Gleixner6550c772006-06-29 02:24:49 -0700166 if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return 0;
168
169 action = irq_desc[irq].action;
170 if (action)
171 if (irqflags & action->flags & SA_SHIRQ)
172 action = NULL;
173
174 return !action;
175}
176
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -0700177void compat_irq_chip_set_default_handler(struct irq_desc *desc)
178{
179 /*
180 * If the architecture still has not overriden
181 * the flow handler then zap the default. This
182 * should catch incorrect flow-type setting.
183 */
184 if (desc->handle_irq == &handle_bad_irq)
185 desc->handle_irq = NULL;
186}
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/*
189 * Internal function to register an irqaction - typically used to
190 * allocate special interrupts that are part of the architecture.
191 */
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700192int setup_irq(unsigned int irq, struct irqaction *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 struct irq_desc *desc = irq_desc + irq;
195 struct irqaction *old, **p;
196 unsigned long flags;
197 int shared = 0;
198
Matthew Wilcoxc2b5a252005-11-03 07:51:18 -0700199 if (irq >= NR_IRQS)
200 return -EINVAL;
201
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700202 if (desc->chip == &no_irq_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return -ENOSYS;
204 /*
205 * Some drivers like serial.c use request_irq() heavily,
206 * so we have to be careful not to interfere with a
207 * running system.
208 */
209 if (new->flags & SA_SAMPLE_RANDOM) {
210 /*
211 * This function might sleep, we want to call it first,
212 * outside of the atomic block.
213 * Yes, this might clear the entropy pool if the wrong
214 * driver is attempted to be loaded, without actually
215 * installing a new handler, but is this really a problem,
216 * only the sysadmin is able to do this.
217 */
218 rand_initialize_irq(irq);
219 }
220
221 /*
222 * The following block of code has to be executed atomically
223 */
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700224 spin_lock_irqsave(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 p = &desc->action;
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700226 old = *p;
227 if (old) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 /* Can't share interrupts unless both agree to */
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800229 if (!(old->flags & new->flags & SA_SHIRQ))
230 goto mismatch;
231
Ingo Molnar0d7012a2006-06-29 02:24:43 -0700232#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800233 /* All handlers must agree on per-cpuness */
234 if ((old->flags & IRQ_PER_CPU) != (new->flags & IRQ_PER_CPU))
235 goto mismatch;
236#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 /* add new interrupt at end of irq queue */
239 do {
240 p = &old->next;
241 old = *p;
242 } while (old);
243 shared = 1;
244 }
245
246 *p = new;
Ingo Molnar0d7012a2006-06-29 02:24:43 -0700247#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800248 if (new->flags & SA_PERCPU_IRQ)
249 desc->status |= IRQ_PER_CPU;
250#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (!shared) {
Thomas Gleixner6a6de9e2006-06-29 02:24:51 -0700252 irq_chip_set_defaults(desc->chip);
253 compat_irq_chip_set_default_handler(desc);
254
Thomas Gleixner94d39e12006-06-29 02:24:50 -0700255 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
256 IRQ_INPROGRESS);
257
258 if (!(desc->status & IRQ_NOAUTOEN)) {
259 desc->depth = 0;
260 desc->status &= ~IRQ_DISABLED;
261 if (desc->chip->startup)
262 desc->chip->startup(irq);
263 else
264 desc->chip->enable(irq);
265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 }
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700267 spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 new->irq = irq;
270 register_irq_proc(irq);
271 new->dir = NULL;
272 register_handler_proc(irq, new);
273
274 return 0;
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800275
276mismatch:
277 spin_unlock_irqrestore(&desc->lock, flags);
Andrew Morton13e87ec2006-04-27 18:39:18 -0700278 if (!(new->flags & SA_PROBEIRQ)) {
279 printk(KERN_ERR "%s: irq handler mismatch\n", __FUNCTION__);
280 dump_stack();
281 }
Dimitri Sivanichf5163422006-03-25 03:08:23 -0800282 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
285/**
286 * free_irq - free an interrupt
287 * @irq: Interrupt line to free
288 * @dev_id: Device identity to free
289 *
290 * Remove an interrupt handler. The handler is removed and if the
291 * interrupt line is no longer in use by any driver it is disabled.
292 * On a shared IRQ the caller must ensure the interrupt is disabled
293 * on the card it drives before calling this function. The function
294 * does not return until any executing interrupts for this IRQ
295 * have completed.
296 *
297 * This function must not be called from interrupt context.
298 */
299void free_irq(unsigned int irq, void *dev_id)
300{
301 struct irq_desc *desc;
302 struct irqaction **p;
303 unsigned long flags;
304
Ingo Molnarcd7b24b2006-03-26 01:36:54 -0800305 WARN_ON(in_interrupt());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (irq >= NR_IRQS)
307 return;
308
309 desc = irq_desc + irq;
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700310 spin_lock_irqsave(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 p = &desc->action;
312 for (;;) {
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700313 struct irqaction *action = *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 if (action) {
316 struct irqaction **pp = p;
317
318 p = &action->next;
319 if (action->dev_id != dev_id)
320 continue;
321
322 /* Found it - now remove it from the list of entries */
323 *pp = action->next;
Paolo 'Blaisorblade' Giarrussodbce7062005-06-21 17:16:19 -0700324
Paolo 'Blaisorblade' Giarrussob77d6ad2005-06-21 17:16:24 -0700325 /* Currently used only by UML, might disappear one day.*/
326#ifdef CONFIG_IRQ_RELEASE_METHOD
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700327 if (desc->chip->release)
328 desc->chip->release(irq, dev_id);
Paolo 'Blaisorblade' Giarrussob77d6ad2005-06-21 17:16:24 -0700329#endif
Paolo 'Blaisorblade' Giarrussodbce7062005-06-21 17:16:19 -0700330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 if (!desc->action) {
332 desc->status |= IRQ_DISABLED;
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700333 if (desc->chip->shutdown)
334 desc->chip->shutdown(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 else
Ingo Molnard1bef4e2006-06-29 02:24:36 -0700336 desc->chip->disable(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700338 spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 unregister_handler_proc(irq, action);
340
341 /* Make sure it's not being used on another CPU */
342 synchronize_irq(irq);
343 kfree(action);
344 return;
345 }
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700346 printk(KERN_ERR "Trying to free free IRQ%d\n", irq);
347 spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return;
349 }
350}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351EXPORT_SYMBOL(free_irq);
352
353/**
354 * request_irq - allocate an interrupt line
355 * @irq: Interrupt line to allocate
356 * @handler: Function to be called when the IRQ occurs
357 * @irqflags: Interrupt type flags
358 * @devname: An ascii name for the claiming device
359 * @dev_id: A cookie passed back to the handler function
360 *
361 * This call allocates interrupt resources and enables the
362 * interrupt line and IRQ handling. From the point this
363 * call is made your handler function may be invoked. Since
364 * your handler function must clear any interrupt the board
365 * raises, you must take care both to initialise your hardware
366 * and to set up the interrupt handler in the right order.
367 *
368 * Dev_id must be globally unique. Normally the address of the
369 * device data structure is used as the cookie. Since the handler
370 * receives this value it makes sense to use it.
371 *
372 * If your interrupt is shared you must pass a non NULL dev_id
373 * as this is required when freeing the interrupt.
374 *
375 * Flags:
376 *
377 * SA_SHIRQ Interrupt is shared
378 * SA_INTERRUPT Disable local interrupts while processing
379 * SA_SAMPLE_RANDOM The interrupt can be used for entropy
380 *
381 */
382int request_irq(unsigned int irq,
383 irqreturn_t (*handler)(int, void *, struct pt_regs *),
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700384 unsigned long irqflags, const char *devname, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
Ingo Molnar06fcb0c2006-06-29 02:24:40 -0700386 struct irqaction *action;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 int retval;
388
389 /*
390 * Sanity-check: shared interrupts must pass in a real dev-ID,
391 * otherwise we'll have trouble later trying to figure out
392 * which interrupt is which (messes up the interrupt freeing
393 * logic etc).
394 */
395 if ((irqflags & SA_SHIRQ) && !dev_id)
396 return -EINVAL;
397 if (irq >= NR_IRQS)
398 return -EINVAL;
Thomas Gleixner6550c772006-06-29 02:24:49 -0700399 if (irq_desc[irq].status & IRQ_NOREQUEST)
400 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (!handler)
402 return -EINVAL;
403
404 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
405 if (!action)
406 return -ENOMEM;
407
408 action->handler = handler;
409 action->flags = irqflags;
410 cpus_clear(action->mask);
411 action->name = devname;
412 action->next = NULL;
413 action->dev_id = dev_id;
414
Ivan Kokshayskyeee45262006-01-06 00:12:21 -0800415 select_smp_affinity(irq);
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 retval = setup_irq(irq, action);
418 if (retval)
419 kfree(action);
420
421 return retval;
422}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423EXPORT_SYMBOL(request_irq);
424