ia64/linux-2.6.18-xen.hg

view kernel/irq/manage.c @ 912:dd42cdb0ab89

[IA64] Build blktap2 driver by default in x86 builds.

add CONFIG_XEN_BLKDEV_TAP2=y to buildconfigs/linux-defconfig_xen_ia64.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Mon Jun 29 12:09:16 2009 +0900 (2009-06-29)
parents 831230e53067
children
line source
1 /*
2 * linux/kernel/irq/manage.c
3 *
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006 Thomas Gleixner
6 *
7 * This file contains driver APIs to the irq subsystem.
8 */
10 #include <linux/irq.h>
11 #include <linux/module.h>
12 #include <linux/random.h>
13 #include <linux/interrupt.h>
15 #include "internals.h"
17 #ifdef CONFIG_SMP
19 /**
20 * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
21 * @irq: interrupt number to wait for
22 *
23 * This function waits for any pending IRQ handlers for this interrupt
24 * to complete before returning. If you use this function while
25 * holding a resource the IRQ handler may need you will deadlock.
26 *
27 * This function may be called - with care - from IRQ context.
28 */
29 void synchronize_irq(unsigned int irq)
30 {
31 struct irq_desc *desc = irq_desc + irq;
33 if (irq >= NR_IRQS)
34 return;
36 while (desc->status & IRQ_INPROGRESS)
37 cpu_relax();
38 }
39 EXPORT_SYMBOL(synchronize_irq);
41 #endif
43 /**
44 * disable_irq_nosync - disable an irq without waiting
45 * @irq: Interrupt to disable
46 *
47 * Disable the selected interrupt line. Disables and Enables are
48 * nested.
49 * Unlike disable_irq(), this function does not ensure existing
50 * instances of the IRQ handler have completed before returning.
51 *
52 * This function may be called from IRQ context.
53 */
54 void disable_irq_nosync(unsigned int irq)
55 {
56 struct irq_desc *desc = irq_desc + irq;
57 unsigned long flags;
59 if (irq >= NR_IRQS)
60 return;
62 spin_lock_irqsave(&desc->lock, flags);
63 if (!desc->depth++) {
64 desc->status |= IRQ_DISABLED;
65 desc->chip->disable(irq);
66 }
67 spin_unlock_irqrestore(&desc->lock, flags);
68 }
69 EXPORT_SYMBOL(disable_irq_nosync);
71 /**
72 * disable_irq - disable an irq and wait for completion
73 * @irq: Interrupt to disable
74 *
75 * Disable the selected interrupt line. Enables and Disables are
76 * nested.
77 * This function waits for any pending IRQ handlers for this interrupt
78 * to complete before returning. If you use this function while
79 * holding a resource the IRQ handler may need you will deadlock.
80 *
81 * This function may be called - with care - from IRQ context.
82 */
83 void disable_irq(unsigned int irq)
84 {
85 struct irq_desc *desc = irq_desc + irq;
87 if (irq >= NR_IRQS)
88 return;
90 disable_irq_nosync(irq);
91 if (desc->action)
92 synchronize_irq(irq);
93 }
94 EXPORT_SYMBOL(disable_irq);
96 /**
97 * enable_irq - enable handling of an irq
98 * @irq: Interrupt to enable
99 *
100 * Undoes the effect of one call to disable_irq(). If this
101 * matches the last disable, processing of interrupts on this
102 * IRQ line is re-enabled.
103 *
104 * This function may be called from IRQ context.
105 */
106 void enable_irq(unsigned int irq)
107 {
108 struct irq_desc *desc = irq_desc + irq;
109 unsigned long flags;
111 if (irq >= NR_IRQS)
112 return;
114 spin_lock_irqsave(&desc->lock, flags);
115 switch (desc->depth) {
116 case 0:
117 printk(KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
118 WARN_ON(1);
119 break;
120 case 1: {
121 unsigned int status = desc->status & ~IRQ_DISABLED;
123 /* Prevent probing on this irq: */
124 desc->status = status | IRQ_NOPROBE;
125 check_irq_resend(desc, irq);
126 /* fall-through */
127 }
128 default:
129 desc->depth--;
130 }
131 spin_unlock_irqrestore(&desc->lock, flags);
132 }
133 EXPORT_SYMBOL(enable_irq);
135 /**
136 * set_irq_wake - control irq power management wakeup
137 * @irq: interrupt to control
138 * @on: enable/disable power management wakeup
139 *
140 * Enable/disable power management wakeup mode, which is
141 * disabled by default. Enables and disables must match,
142 * just as they match for non-wakeup mode support.
143 *
144 * Wakeup mode lets this IRQ wake the system from sleep
145 * states like "suspend to RAM".
146 */
147 int set_irq_wake(unsigned int irq, unsigned int on)
148 {
149 struct irq_desc *desc = irq_desc + irq;
150 unsigned long flags;
151 int ret = -ENXIO;
152 int (*set_wake)(unsigned, unsigned) = desc->chip->set_wake;
154 /* wakeup-capable irqs can be shared between drivers that
155 * don't need to have the same sleep mode behaviors.
156 */
157 spin_lock_irqsave(&desc->lock, flags);
158 if (on) {
159 if (desc->wake_depth++ == 0)
160 desc->status |= IRQ_WAKEUP;
161 else
162 set_wake = NULL;
163 } else {
164 if (desc->wake_depth == 0) {
165 printk(KERN_WARNING "Unbalanced IRQ %d "
166 "wake disable\n", irq);
167 WARN_ON(1);
168 } else if (--desc->wake_depth == 0)
169 desc->status &= ~IRQ_WAKEUP;
170 else
171 set_wake = NULL;
172 }
173 if (set_wake)
174 ret = desc->chip->set_wake(irq, on);
175 spin_unlock_irqrestore(&desc->lock, flags);
176 return ret;
177 }
178 EXPORT_SYMBOL(set_irq_wake);
180 /*
181 * Internal function that tells the architecture code whether a
182 * particular irq has been exclusively allocated or is available
183 * for driver use.
184 */
185 int can_request_irq(unsigned int irq, unsigned long irqflags)
186 {
187 struct irqaction *action;
189 if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST)
190 return 0;
192 action = irq_desc[irq].action;
193 if (action)
194 if (irqflags & action->flags & IRQF_SHARED)
195 action = NULL;
197 return !action;
198 }
200 void compat_irq_chip_set_default_handler(struct irq_desc *desc)
201 {
202 /*
203 * If the architecture still has not overriden
204 * the flow handler then zap the default. This
205 * should catch incorrect flow-type setting.
206 */
207 if (desc->handle_irq == &handle_bad_irq)
208 desc->handle_irq = NULL;
209 }
211 /*
212 * Internal function to register an irqaction - typically used to
213 * allocate special interrupts that are part of the architecture.
214 */
215 int setup_irq(unsigned int irq, struct irqaction *new)
216 {
217 struct irq_desc *desc = irq_desc + irq;
218 struct irqaction *old, **p;
219 unsigned long flags;
220 int shared = 0;
222 if (irq >= NR_IRQS)
223 return -EINVAL;
225 if (desc->chip == &no_irq_chip)
226 return -ENOSYS;
227 /*
228 * Some drivers like serial.c use request_irq() heavily,
229 * so we have to be careful not to interfere with a
230 * running system.
231 */
232 if (new->flags & IRQF_SAMPLE_RANDOM) {
233 /*
234 * This function might sleep, we want to call it first,
235 * outside of the atomic block.
236 * Yes, this might clear the entropy pool if the wrong
237 * driver is attempted to be loaded, without actually
238 * installing a new handler, but is this really a problem,
239 * only the sysadmin is able to do this.
240 */
241 rand_initialize_irq(irq);
242 }
244 /*
245 * The following block of code has to be executed atomically
246 */
247 spin_lock_irqsave(&desc->lock, flags);
248 p = &desc->action;
249 old = *p;
250 if (old) {
251 /*
252 * Can't share interrupts unless both agree to and are
253 * the same type (level, edge, polarity). So both flag
254 * fields must have IRQF_SHARED set and the bits which
255 * set the trigger type must match.
256 */
257 if (!((old->flags & new->flags) & IRQF_SHARED) ||
258 ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK))
259 goto mismatch;
261 #if defined(CONFIG_IRQ_PER_CPU)
262 /* All handlers must agree on per-cpuness */
263 if ((old->flags & IRQF_PERCPU) !=
264 (new->flags & IRQF_PERCPU))
265 goto mismatch;
266 #endif
268 /* add new interrupt at end of irq queue */
269 do {
270 p = &old->next;
271 old = *p;
272 } while (old);
273 shared = 1;
274 }
276 *p = new;
277 #if defined(CONFIG_IRQ_PER_CPU)
278 if (new->flags & IRQF_PERCPU)
279 desc->status |= IRQ_PER_CPU;
280 #endif
281 if (!shared) {
282 irq_chip_set_defaults(desc->chip);
284 /* Setup the type (level, edge polarity) if configured: */
285 if (new->flags & IRQF_TRIGGER_MASK) {
286 if (desc->chip && desc->chip->set_type)
287 desc->chip->set_type(irq,
288 new->flags & IRQF_TRIGGER_MASK);
289 else
290 /*
291 * IRQF_TRIGGER_* but the PIC does not support
292 * multiple flow-types?
293 */
294 printk(KERN_WARNING "No IRQF_TRIGGER set_type "
295 "function for IRQ %d (%s)\n", irq,
296 desc->chip ? desc->chip->name :
297 "unknown");
298 } else
299 compat_irq_chip_set_default_handler(desc);
301 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
302 IRQ_INPROGRESS);
304 if (!(desc->status & IRQ_NOAUTOEN)) {
305 desc->depth = 0;
306 desc->status &= ~IRQ_DISABLED;
307 if (desc->chip->startup)
308 desc->chip->startup(irq);
309 else
310 desc->chip->enable(irq);
311 } else
312 /* Undo nested disables: */
313 desc->depth = 1;
314 }
315 spin_unlock_irqrestore(&desc->lock, flags);
317 new->irq = irq;
318 register_irq_proc(irq);
319 new->dir = NULL;
320 register_handler_proc(irq, new);
322 return 0;
324 mismatch:
325 spin_unlock_irqrestore(&desc->lock, flags);
326 if (!(new->flags & IRQF_PROBE_SHARED)) {
327 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
328 dump_stack();
329 }
330 return -EBUSY;
331 }
333 /**
334 * free_irq - free an interrupt
335 * @irq: Interrupt line to free
336 * @dev_id: Device identity to free
337 *
338 * Remove an interrupt handler. The handler is removed and if the
339 * interrupt line is no longer in use by any driver it is disabled.
340 * On a shared IRQ the caller must ensure the interrupt is disabled
341 * on the card it drives before calling this function. The function
342 * does not return until any executing interrupts for this IRQ
343 * have completed.
344 *
345 * This function must not be called from interrupt context.
346 */
347 void free_irq(unsigned int irq, void *dev_id)
348 {
349 struct irq_desc *desc;
350 struct irqaction **p;
351 unsigned long flags;
353 WARN_ON(in_interrupt());
354 if (irq >= NR_IRQS)
355 return;
357 desc = irq_desc + irq;
358 spin_lock_irqsave(&desc->lock, flags);
359 p = &desc->action;
360 for (;;) {
361 struct irqaction *action = *p;
363 if (action) {
364 struct irqaction **pp = p;
366 p = &action->next;
367 if (action->dev_id != dev_id)
368 continue;
370 /* Found it - now remove it from the list of entries */
371 *pp = action->next;
373 /* Currently used only by UML, might disappear one day.*/
374 #ifdef CONFIG_IRQ_RELEASE_METHOD
375 if (desc->chip->release)
376 desc->chip->release(irq, dev_id);
377 #endif
379 if (!desc->action) {
380 desc->status |= IRQ_DISABLED;
381 if (desc->chip->shutdown)
382 desc->chip->shutdown(irq);
383 else
384 desc->chip->disable(irq);
385 }
386 spin_unlock_irqrestore(&desc->lock, flags);
387 unregister_handler_proc(irq, action);
389 /* Make sure it's not being used on another CPU */
390 synchronize_irq(irq);
391 kfree(action);
392 return;
393 }
394 printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq);
395 spin_unlock_irqrestore(&desc->lock, flags);
396 return;
397 }
398 }
399 EXPORT_SYMBOL(free_irq);
401 /**
402 * request_irq - allocate an interrupt line
403 * @irq: Interrupt line to allocate
404 * @handler: Function to be called when the IRQ occurs
405 * @irqflags: Interrupt type flags
406 * @devname: An ascii name for the claiming device
407 * @dev_id: A cookie passed back to the handler function
408 *
409 * This call allocates interrupt resources and enables the
410 * interrupt line and IRQ handling. From the point this
411 * call is made your handler function may be invoked. Since
412 * your handler function must clear any interrupt the board
413 * raises, you must take care both to initialise your hardware
414 * and to set up the interrupt handler in the right order.
415 *
416 * Dev_id must be globally unique. Normally the address of the
417 * device data structure is used as the cookie. Since the handler
418 * receives this value it makes sense to use it.
419 *
420 * If your interrupt is shared you must pass a non NULL dev_id
421 * as this is required when freeing the interrupt.
422 *
423 * Flags:
424 *
425 * IRQF_SHARED Interrupt is shared
426 * IRQF_DISABLED Disable local interrupts while processing
427 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
428 *
429 */
430 int request_irq(unsigned int irq,
431 irqreturn_t (*handler)(int, void *, struct pt_regs *),
432 unsigned long irqflags, const char *devname, void *dev_id)
433 {
434 struct irqaction *action;
435 int retval;
437 #ifdef CONFIG_LOCKDEP
438 /*
439 * Lockdep wants atomic interrupt handlers:
440 */
441 irqflags |= SA_INTERRUPT;
442 #endif
443 /*
444 * Sanity-check: shared interrupts must pass in a real dev-ID,
445 * otherwise we'll have trouble later trying to figure out
446 * which interrupt is which (messes up the interrupt freeing
447 * logic etc).
448 */
449 if ((irqflags & IRQF_SHARED) && !dev_id)
450 return -EINVAL;
451 if (irq >= NR_IRQS)
452 return -EINVAL;
453 if (irq_desc[irq].status & IRQ_NOREQUEST)
454 return -EINVAL;
455 if (!handler)
456 return -EINVAL;
458 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
459 if (!action)
460 return -ENOMEM;
462 action->handler = handler;
463 action->flags = irqflags;
464 cpus_clear(action->mask);
465 action->name = devname;
466 action->next = NULL;
467 action->dev_id = dev_id;
469 select_smp_affinity(irq);
471 retval = setup_irq(irq, action);
472 if (retval)
473 kfree(action);
475 return retval;
476 }
477 EXPORT_SYMBOL(request_irq);