genirq: Expose default irq affinity mask (take 3)
[linux-2.6.git] / kernel / irq / manage.c
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  */
9
10 #include <linux/irq.h>
11 #include <linux/module.h>
12 #include <linux/random.h>
13 #include <linux/interrupt.h>
14 #include <linux/slab.h>
15
16 #include "internals.h"
17
18 #ifdef CONFIG_SMP
19
20 cpumask_t irq_default_affinity = CPU_MASK_ALL;
21
22 /**
23  *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
24  *      @irq: interrupt number to wait for
25  *
26  *      This function waits for any pending IRQ handlers for this interrupt
27  *      to complete before returning. If you use this function while
28  *      holding a resource the IRQ handler may need you will deadlock.
29  *
30  *      This function may be called - with care - from IRQ context.
31  */
32 void synchronize_irq(unsigned int irq)
33 {
34         struct irq_desc *desc = irq_desc + irq;
35         unsigned int status;
36
37         if (irq >= NR_IRQS)
38                 return;
39
40         do {
41                 unsigned long flags;
42
43                 /*
44                  * Wait until we're out of the critical section.  This might
45                  * give the wrong answer due to the lack of memory barriers.
46                  */
47                 while (desc->status & IRQ_INPROGRESS)
48                         cpu_relax();
49
50                 /* Ok, that indicated we're done: double-check carefully. */
51                 spin_lock_irqsave(&desc->lock, flags);
52                 status = desc->status;
53                 spin_unlock_irqrestore(&desc->lock, flags);
54
55                 /* Oops, that failed? */
56         } while (status & IRQ_INPROGRESS);
57 }
58 EXPORT_SYMBOL(synchronize_irq);
59
60 /**
61  *      irq_can_set_affinity - Check if the affinity of a given irq can be set
62  *      @irq:           Interrupt to check
63  *
64  */
65 int irq_can_set_affinity(unsigned int irq)
66 {
67         struct irq_desc *desc = irq_desc + irq;
68
69         if (CHECK_IRQ_PER_CPU(desc->status) || !desc->chip ||
70             !desc->chip->set_affinity)
71                 return 0;
72
73         return 1;
74 }
75
76 /**
77  *      irq_set_affinity - Set the irq affinity of a given irq
78  *      @irq:           Interrupt to set affinity
79  *      @cpumask:       cpumask
80  *
81  */
82 int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
83 {
84         struct irq_desc *desc = irq_desc + irq;
85
86         if (!desc->chip->set_affinity)
87                 return -EINVAL;
88
89         set_balance_irq_affinity(irq, cpumask);
90
91 #ifdef CONFIG_GENERIC_PENDING_IRQ
92         set_pending_irq(irq, cpumask);
93 #else
94         desc->affinity = cpumask;
95         desc->chip->set_affinity(irq, cpumask);
96 #endif
97         return 0;
98 }
99
100 #ifndef CONFIG_AUTO_IRQ_AFFINITY
101 /*
102  * Generic version of the affinity autoselector.
103  */
104 int irq_select_affinity(unsigned int irq)
105 {
106         cpumask_t mask;
107
108         if (!irq_can_set_affinity(irq))
109                 return 0;
110
111         cpus_and(mask, cpu_online_map, irq_default_affinity);
112
113         irq_desc[irq].affinity = mask;
114         irq_desc[irq].chip->set_affinity(irq, mask);
115
116         set_balance_irq_affinity(irq, mask);
117         return 0;
118 }
119 #endif
120
121 #endif
122
123 /**
124  *      disable_irq_nosync - disable an irq without waiting
125  *      @irq: Interrupt to disable
126  *
127  *      Disable the selected interrupt line.  Disables and Enables are
128  *      nested.
129  *      Unlike disable_irq(), this function does not ensure existing
130  *      instances of the IRQ handler have completed before returning.
131  *
132  *      This function may be called from IRQ context.
133  */
134 void disable_irq_nosync(unsigned int irq)
135 {
136         struct irq_desc *desc = irq_desc + irq;
137         unsigned long flags;
138
139         if (irq >= NR_IRQS)
140                 return;
141
142         spin_lock_irqsave(&desc->lock, flags);
143         if (!desc->depth++) {
144                 desc->status |= IRQ_DISABLED;
145                 desc->chip->disable(irq);
146         }
147         spin_unlock_irqrestore(&desc->lock, flags);
148 }
149 EXPORT_SYMBOL(disable_irq_nosync);
150
151 /**
152  *      disable_irq - disable an irq and wait for completion
153  *      @irq: Interrupt to disable
154  *
155  *      Disable the selected interrupt line.  Enables and Disables are
156  *      nested.
157  *      This function waits for any pending IRQ handlers for this interrupt
158  *      to complete before returning. If you use this function while
159  *      holding a resource the IRQ handler may need you will deadlock.
160  *
161  *      This function may be called - with care - from IRQ context.
162  */
163 void disable_irq(unsigned int irq)
164 {
165         struct irq_desc *desc = irq_desc + irq;
166
167         if (irq >= NR_IRQS)
168                 return;
169
170         disable_irq_nosync(irq);
171         if (desc->action)
172                 synchronize_irq(irq);
173 }
174 EXPORT_SYMBOL(disable_irq);
175
176 static void __enable_irq(struct irq_desc *desc, unsigned int irq)
177 {
178         switch (desc->depth) {
179         case 0:
180                 printk(KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
181                 WARN_ON(1);
182                 break;
183         case 1: {
184                 unsigned int status = desc->status & ~IRQ_DISABLED;
185
186                 /* Prevent probing on this irq: */
187                 desc->status = status | IRQ_NOPROBE;
188                 check_irq_resend(desc, irq);
189                 /* fall-through */
190         }
191         default:
192                 desc->depth--;
193         }
194 }
195
196 /**
197  *      enable_irq - enable handling of an irq
198  *      @irq: Interrupt to enable
199  *
200  *      Undoes the effect of one call to disable_irq().  If this
201  *      matches the last disable, processing of interrupts on this
202  *      IRQ line is re-enabled.
203  *
204  *      This function may be called from IRQ context.
205  */
206 void enable_irq(unsigned int irq)
207 {
208         struct irq_desc *desc = irq_desc + irq;
209         unsigned long flags;
210
211         if (irq >= NR_IRQS)
212                 return;
213
214         spin_lock_irqsave(&desc->lock, flags);
215         __enable_irq(desc, irq);
216         spin_unlock_irqrestore(&desc->lock, flags);
217 }
218 EXPORT_SYMBOL(enable_irq);
219
220 /**
221  *      set_irq_wake - control irq power management wakeup
222  *      @irq:   interrupt to control
223  *      @on:    enable/disable power management wakeup
224  *
225  *      Enable/disable power management wakeup mode, which is
226  *      disabled by default.  Enables and disables must match,
227  *      just as they match for non-wakeup mode support.
228  *
229  *      Wakeup mode lets this IRQ wake the system from sleep
230  *      states like "suspend to RAM".
231  */
232 int set_irq_wake(unsigned int irq, unsigned int on)
233 {
234         struct irq_desc *desc = irq_desc + irq;
235         unsigned long flags;
236         int ret = -ENXIO;
237         int (*set_wake)(unsigned, unsigned) = desc->chip->set_wake;
238
239         /* wakeup-capable irqs can be shared between drivers that
240          * don't need to have the same sleep mode behaviors.
241          */
242         spin_lock_irqsave(&desc->lock, flags);
243         if (on) {
244                 if (desc->wake_depth++ == 0)
245                         desc->status |= IRQ_WAKEUP;
246                 else
247                         set_wake = NULL;
248         } else {
249                 if (desc->wake_depth == 0) {
250                         printk(KERN_WARNING "Unbalanced IRQ %d "
251                                         "wake disable\n", irq);
252                         WARN_ON(1);
253                 } else if (--desc->wake_depth == 0)
254                         desc->status &= ~IRQ_WAKEUP;
255                 else
256                         set_wake = NULL;
257         }
258         if (set_wake)
259                 ret = desc->chip->set_wake(irq, on);
260         spin_unlock_irqrestore(&desc->lock, flags);
261         return ret;
262 }
263 EXPORT_SYMBOL(set_irq_wake);
264
265 /*
266  * Internal function that tells the architecture code whether a
267  * particular irq has been exclusively allocated or is available
268  * for driver use.
269  */
270 int can_request_irq(unsigned int irq, unsigned long irqflags)
271 {
272         struct irqaction *action;
273
274         if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST)
275                 return 0;
276
277         action = irq_desc[irq].action;
278         if (action)
279                 if (irqflags & action->flags & IRQF_SHARED)
280                         action = NULL;
281
282         return !action;
283 }
284
285 void compat_irq_chip_set_default_handler(struct irq_desc *desc)
286 {
287         /*
288          * If the architecture still has not overriden
289          * the flow handler then zap the default. This
290          * should catch incorrect flow-type setting.
291          */
292         if (desc->handle_irq == &handle_bad_irq)
293                 desc->handle_irq = NULL;
294 }
295
296 /*
297  * Internal function to register an irqaction - typically used to
298  * allocate special interrupts that are part of the architecture.
299  */
300 int setup_irq(unsigned int irq, struct irqaction *new)
301 {
302         struct irq_desc *desc = irq_desc + irq;
303         struct irqaction *old, **p;
304         const char *old_name = NULL;
305         unsigned long flags;
306         int shared = 0;
307
308         if (irq >= NR_IRQS)
309                 return -EINVAL;
310
311         if (desc->chip == &no_irq_chip)
312                 return -ENOSYS;
313         /*
314          * Some drivers like serial.c use request_irq() heavily,
315          * so we have to be careful not to interfere with a
316          * running system.
317          */
318         if (new->flags & IRQF_SAMPLE_RANDOM) {
319                 /*
320                  * This function might sleep, we want to call it first,
321                  * outside of the atomic block.
322                  * Yes, this might clear the entropy pool if the wrong
323                  * driver is attempted to be loaded, without actually
324                  * installing a new handler, but is this really a problem,
325                  * only the sysadmin is able to do this.
326                  */
327                 rand_initialize_irq(irq);
328         }
329
330         /*
331          * The following block of code has to be executed atomically
332          */
333         spin_lock_irqsave(&desc->lock, flags);
334         p = &desc->action;
335         old = *p;
336         if (old) {
337                 /*
338                  * Can't share interrupts unless both agree to and are
339                  * the same type (level, edge, polarity). So both flag
340                  * fields must have IRQF_SHARED set and the bits which
341                  * set the trigger type must match.
342                  */
343                 if (!((old->flags & new->flags) & IRQF_SHARED) ||
344                     ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) {
345                         old_name = old->name;
346                         goto mismatch;
347                 }
348
349 #if defined(CONFIG_IRQ_PER_CPU)
350                 /* All handlers must agree on per-cpuness */
351                 if ((old->flags & IRQF_PERCPU) !=
352                     (new->flags & IRQF_PERCPU))
353                         goto mismatch;
354 #endif
355
356                 /* add new interrupt at end of irq queue */
357                 do {
358                         p = &old->next;
359                         old = *p;
360                 } while (old);
361                 shared = 1;
362         }
363
364         *p = new;
365
366         /* Exclude IRQ from balancing */
367         if (new->flags & IRQF_NOBALANCING)
368                 desc->status |= IRQ_NO_BALANCING;
369
370         if (!shared) {
371                 irq_chip_set_defaults(desc->chip);
372
373 #if defined(CONFIG_IRQ_PER_CPU)
374                 if (new->flags & IRQF_PERCPU)
375                         desc->status |= IRQ_PER_CPU;
376 #endif
377
378                 /* Setup the type (level, edge polarity) if configured: */
379                 if (new->flags & IRQF_TRIGGER_MASK) {
380                         if (desc->chip && desc->chip->set_type)
381                                 desc->chip->set_type(irq,
382                                                 new->flags & IRQF_TRIGGER_MASK);
383                         else
384                                 /*
385                                  * IRQF_TRIGGER_* but the PIC does not support
386                                  * multiple flow-types?
387                                  */
388                                 printk(KERN_WARNING "No IRQF_TRIGGER set_type "
389                                        "function for IRQ %d (%s)\n", irq,
390                                        desc->chip ? desc->chip->name :
391                                        "unknown");
392                 } else
393                         compat_irq_chip_set_default_handler(desc);
394
395                 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
396                                   IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
397
398                 if (!(desc->status & IRQ_NOAUTOEN)) {
399                         desc->depth = 0;
400                         desc->status &= ~IRQ_DISABLED;
401                         if (desc->chip->startup)
402                                 desc->chip->startup(irq);
403                         else
404                                 desc->chip->enable(irq);
405                 } else
406                         /* Undo nested disables: */
407                         desc->depth = 1;
408
409                 /* Set default affinity mask once everything is setup */
410                 irq_select_affinity(irq);
411         }
412         /* Reset broken irq detection when installing new handler */
413         desc->irq_count = 0;
414         desc->irqs_unhandled = 0;
415
416         /*
417          * Check whether we disabled the irq via the spurious handler
418          * before. Reenable it and give it another chance.
419          */
420         if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
421                 desc->status &= ~IRQ_SPURIOUS_DISABLED;
422                 __enable_irq(desc, irq);
423         }
424
425         spin_unlock_irqrestore(&desc->lock, flags);
426
427         new->irq = irq;
428         register_irq_proc(irq);
429         new->dir = NULL;
430         register_handler_proc(irq, new);
431
432         return 0;
433
434 mismatch:
435 #ifdef CONFIG_DEBUG_SHIRQ
436         if (!(new->flags & IRQF_PROBE_SHARED)) {
437                 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
438                 if (old_name)
439                         printk(KERN_ERR "current handler: %s\n", old_name);
440                 dump_stack();
441         }
442 #endif
443         spin_unlock_irqrestore(&desc->lock, flags);
444         return -EBUSY;
445 }
446
447 /**
448  *      free_irq - free an interrupt
449  *      @irq: Interrupt line to free
450  *      @dev_id: Device identity to free
451  *
452  *      Remove an interrupt handler. The handler is removed and if the
453  *      interrupt line is no longer in use by any driver it is disabled.
454  *      On a shared IRQ the caller must ensure the interrupt is disabled
455  *      on the card it drives before calling this function. The function
456  *      does not return until any executing interrupts for this IRQ
457  *      have completed.
458  *
459  *      This function must not be called from interrupt context.
460  */
461 void free_irq(unsigned int irq, void *dev_id)
462 {
463         struct irq_desc *desc;
464         struct irqaction **p;
465         unsigned long flags;
466
467         WARN_ON(in_interrupt());
468         if (irq >= NR_IRQS)
469                 return;
470
471         desc = irq_desc + irq;
472         spin_lock_irqsave(&desc->lock, flags);
473         p = &desc->action;
474         for (;;) {
475                 struct irqaction *action = *p;
476
477                 if (action) {
478                         struct irqaction **pp = p;
479
480                         p = &action->next;
481                         if (action->dev_id != dev_id)
482                                 continue;
483
484                         /* Found it - now remove it from the list of entries */
485                         *pp = action->next;
486
487                         /* Currently used only by UML, might disappear one day.*/
488 #ifdef CONFIG_IRQ_RELEASE_METHOD
489                         if (desc->chip->release)
490                                 desc->chip->release(irq, dev_id);
491 #endif
492
493                         if (!desc->action) {
494                                 desc->status |= IRQ_DISABLED;
495                                 if (desc->chip->shutdown)
496                                         desc->chip->shutdown(irq);
497                                 else
498                                         desc->chip->disable(irq);
499                         }
500                         spin_unlock_irqrestore(&desc->lock, flags);
501                         unregister_handler_proc(irq, action);
502
503                         /* Make sure it's not being used on another CPU */
504                         synchronize_irq(irq);
505 #ifdef CONFIG_DEBUG_SHIRQ
506                         /*
507                          * It's a shared IRQ -- the driver ought to be
508                          * prepared for it to happen even now it's
509                          * being freed, so let's make sure....  We do
510                          * this after actually deregistering it, to
511                          * make sure that a 'real' IRQ doesn't run in
512                          * parallel with our fake
513                          */
514                         if (action->flags & IRQF_SHARED) {
515                                 local_irq_save(flags);
516                                 action->handler(irq, dev_id);
517                                 local_irq_restore(flags);
518                         }
519 #endif
520                         kfree(action);
521                         return;
522                 }
523                 printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq);
524 #ifdef CONFIG_DEBUG_SHIRQ
525                 dump_stack();
526 #endif
527                 spin_unlock_irqrestore(&desc->lock, flags);
528                 return;
529         }
530 }
531 EXPORT_SYMBOL(free_irq);
532
533 /**
534  *      request_irq - allocate an interrupt line
535  *      @irq: Interrupt line to allocate
536  *      @handler: Function to be called when the IRQ occurs
537  *      @irqflags: Interrupt type flags
538  *      @devname: An ascii name for the claiming device
539  *      @dev_id: A cookie passed back to the handler function
540  *
541  *      This call allocates interrupt resources and enables the
542  *      interrupt line and IRQ handling. From the point this
543  *      call is made your handler function may be invoked. Since
544  *      your handler function must clear any interrupt the board
545  *      raises, you must take care both to initialise your hardware
546  *      and to set up the interrupt handler in the right order.
547  *
548  *      Dev_id must be globally unique. Normally the address of the
549  *      device data structure is used as the cookie. Since the handler
550  *      receives this value it makes sense to use it.
551  *
552  *      If your interrupt is shared you must pass a non NULL dev_id
553  *      as this is required when freeing the interrupt.
554  *
555  *      Flags:
556  *
557  *      IRQF_SHARED             Interrupt is shared
558  *      IRQF_DISABLED   Disable local interrupts while processing
559  *      IRQF_SAMPLE_RANDOM      The interrupt can be used for entropy
560  *
561  */
562 int request_irq(unsigned int irq, irq_handler_t handler,
563                 unsigned long irqflags, const char *devname, void *dev_id)
564 {
565         struct irqaction *action;
566         int retval;
567
568 #ifdef CONFIG_LOCKDEP
569         /*
570          * Lockdep wants atomic interrupt handlers:
571          */
572         irqflags |= IRQF_DISABLED;
573 #endif
574         /*
575          * Sanity-check: shared interrupts must pass in a real dev-ID,
576          * otherwise we'll have trouble later trying to figure out
577          * which interrupt is which (messes up the interrupt freeing
578          * logic etc).
579          */
580         if ((irqflags & IRQF_SHARED) && !dev_id)
581                 return -EINVAL;
582         if (irq >= NR_IRQS)
583                 return -EINVAL;
584         if (irq_desc[irq].status & IRQ_NOREQUEST)
585                 return -EINVAL;
586         if (!handler)
587                 return -EINVAL;
588
589         action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
590         if (!action)
591                 return -ENOMEM;
592
593         action->handler = handler;
594         action->flags = irqflags;
595         cpus_clear(action->mask);
596         action->name = devname;
597         action->next = NULL;
598         action->dev_id = dev_id;
599
600 #ifdef CONFIG_DEBUG_SHIRQ
601         if (irqflags & IRQF_SHARED) {
602                 /*
603                  * It's a shared IRQ -- the driver ought to be prepared for it
604                  * to happen immediately, so let's make sure....
605                  * We do this before actually registering it, to make sure that
606                  * a 'real' IRQ doesn't run in parallel with our fake
607                  */
608                 unsigned long flags;
609
610                 local_irq_save(flags);
611                 handler(irq, dev_id);
612                 local_irq_restore(flags);
613         }
614 #endif
615
616         retval = setup_irq(irq, action);
617         if (retval)
618                 kfree(action);
619
620         return retval;
621 }
622 EXPORT_SYMBOL(request_irq);