cpumask: update irq_desc to use cpumask_var_t
[linux-2.6.git] / kernel / irq / chip.c
1 /*
2  * linux/kernel/irq/chip.c
3  *
4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
6  *
7  * This file contains the core interrupt handling code, for irq-chip
8  * based architectures.
9  *
10  * Detailed information is available in Documentation/DocBook/genericirq
11  */
12
13 #include <linux/irq.h>
14 #include <linux/msi.h>
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel_stat.h>
18
19 #include "internals.h"
20
21 /**
22  *      dynamic_irq_init - initialize a dynamically allocated irq
23  *      @irq:   irq number to initialize
24  */
25 void dynamic_irq_init(unsigned int irq)
26 {
27         struct irq_desc *desc;
28         unsigned long flags;
29
30         desc = irq_to_desc(irq);
31         if (!desc) {
32                 WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
33                 return;
34         }
35
36         /* Ensure we don't have left over values from a previous use of this irq */
37         spin_lock_irqsave(&desc->lock, flags);
38         desc->status = IRQ_DISABLED;
39         desc->chip = &no_irq_chip;
40         desc->handle_irq = handle_bad_irq;
41         desc->depth = 1;
42         desc->msi_desc = NULL;
43         desc->handler_data = NULL;
44         desc->chip_data = NULL;
45         desc->action = NULL;
46         desc->irq_count = 0;
47         desc->irqs_unhandled = 0;
48 #ifdef CONFIG_SMP
49         cpumask_setall(desc->affinity);
50 #ifdef CONFIG_GENERIC_PENDING_IRQ
51         cpumask_clear(desc->pending_mask);
52 #endif
53 #endif
54         spin_unlock_irqrestore(&desc->lock, flags);
55 }
56
57 /**
58  *      dynamic_irq_cleanup - cleanup a dynamically allocated irq
59  *      @irq:   irq number to initialize
60  */
61 void dynamic_irq_cleanup(unsigned int irq)
62 {
63         struct irq_desc *desc = irq_to_desc(irq);
64         unsigned long flags;
65
66         if (!desc) {
67                 WARN(1, KERN_ERR "Trying to cleanup invalid IRQ%d\n", irq);
68                 return;
69         }
70
71         spin_lock_irqsave(&desc->lock, flags);
72         if (desc->action) {
73                 spin_unlock_irqrestore(&desc->lock, flags);
74                 WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
75                         irq);
76                 return;
77         }
78         desc->msi_desc = NULL;
79         desc->handler_data = NULL;
80         desc->chip_data = NULL;
81         desc->handle_irq = handle_bad_irq;
82         desc->chip = &no_irq_chip;
83         desc->name = NULL;
84         spin_unlock_irqrestore(&desc->lock, flags);
85 }
86
87
88 /**
89  *      set_irq_chip - set the irq chip for an irq
90  *      @irq:   irq number
91  *      @chip:  pointer to irq chip description structure
92  */
93 int set_irq_chip(unsigned int irq, struct irq_chip *chip)
94 {
95         struct irq_desc *desc = irq_to_desc(irq);
96         unsigned long flags;
97
98         if (!desc) {
99                 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
100                 return -EINVAL;
101         }
102
103         if (!chip)
104                 chip = &no_irq_chip;
105
106         spin_lock_irqsave(&desc->lock, flags);
107         irq_chip_set_defaults(chip);
108         desc->chip = chip;
109         spin_unlock_irqrestore(&desc->lock, flags);
110
111         return 0;
112 }
113 EXPORT_SYMBOL(set_irq_chip);
114
115 /**
116  *      set_irq_type - set the irq trigger type for an irq
117  *      @irq:   irq number
118  *      @type:  IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
119  */
120 int set_irq_type(unsigned int irq, unsigned int type)
121 {
122         struct irq_desc *desc = irq_to_desc(irq);
123         unsigned long flags;
124         int ret = -ENXIO;
125
126         if (!desc) {
127                 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
128                 return -ENODEV;
129         }
130
131         type &= IRQ_TYPE_SENSE_MASK;
132         if (type == IRQ_TYPE_NONE)
133                 return 0;
134
135         spin_lock_irqsave(&desc->lock, flags);
136         ret = __irq_set_trigger(desc, irq, type);
137         spin_unlock_irqrestore(&desc->lock, flags);
138         return ret;
139 }
140 EXPORT_SYMBOL(set_irq_type);
141
142 /**
143  *      set_irq_data - set irq type data for an irq
144  *      @irq:   Interrupt number
145  *      @data:  Pointer to interrupt specific data
146  *
147  *      Set the hardware irq controller data for an irq
148  */
149 int set_irq_data(unsigned int irq, void *data)
150 {
151         struct irq_desc *desc = irq_to_desc(irq);
152         unsigned long flags;
153
154         if (!desc) {
155                 printk(KERN_ERR
156                        "Trying to install controller data for IRQ%d\n", irq);
157                 return -EINVAL;
158         }
159
160         spin_lock_irqsave(&desc->lock, flags);
161         desc->handler_data = data;
162         spin_unlock_irqrestore(&desc->lock, flags);
163         return 0;
164 }
165 EXPORT_SYMBOL(set_irq_data);
166
167 /**
168  *      set_irq_data - set irq type data for an irq
169  *      @irq:   Interrupt number
170  *      @entry: Pointer to MSI descriptor data
171  *
172  *      Set the hardware irq controller data for an irq
173  */
174 int set_irq_msi(unsigned int irq, struct msi_desc *entry)
175 {
176         struct irq_desc *desc = irq_to_desc(irq);
177         unsigned long flags;
178
179         if (!desc) {
180                 printk(KERN_ERR
181                        "Trying to install msi data for IRQ%d\n", irq);
182                 return -EINVAL;
183         }
184
185         spin_lock_irqsave(&desc->lock, flags);
186         desc->msi_desc = entry;
187         if (entry)
188                 entry->irq = irq;
189         spin_unlock_irqrestore(&desc->lock, flags);
190         return 0;
191 }
192
193 /**
194  *      set_irq_chip_data - set irq chip data for an irq
195  *      @irq:   Interrupt number
196  *      @data:  Pointer to chip specific data
197  *
198  *      Set the hardware irq chip data for an irq
199  */
200 int set_irq_chip_data(unsigned int irq, void *data)
201 {
202         struct irq_desc *desc = irq_to_desc(irq);
203         unsigned long flags;
204
205         if (!desc) {
206                 printk(KERN_ERR
207                        "Trying to install chip data for IRQ%d\n", irq);
208                 return -EINVAL;
209         }
210
211         if (!desc->chip) {
212                 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
213                 return -EINVAL;
214         }
215
216         spin_lock_irqsave(&desc->lock, flags);
217         desc->chip_data = data;
218         spin_unlock_irqrestore(&desc->lock, flags);
219
220         return 0;
221 }
222 EXPORT_SYMBOL(set_irq_chip_data);
223
224 /*
225  * default enable function
226  */
227 static void default_enable(unsigned int irq)
228 {
229         struct irq_desc *desc = irq_to_desc(irq);
230
231         desc->chip->unmask(irq);
232         desc->status &= ~IRQ_MASKED;
233 }
234
235 /*
236  * default disable function
237  */
238 static void default_disable(unsigned int irq)
239 {
240 }
241
242 /*
243  * default startup function
244  */
245 static unsigned int default_startup(unsigned int irq)
246 {
247         struct irq_desc *desc = irq_to_desc(irq);
248
249         desc->chip->enable(irq);
250         return 0;
251 }
252
253 /*
254  * default shutdown function
255  */
256 static void default_shutdown(unsigned int irq)
257 {
258         struct irq_desc *desc = irq_to_desc(irq);
259
260         desc->chip->mask(irq);
261         desc->status |= IRQ_MASKED;
262 }
263
264 /*
265  * Fixup enable/disable function pointers
266  */
267 void irq_chip_set_defaults(struct irq_chip *chip)
268 {
269         if (!chip->enable)
270                 chip->enable = default_enable;
271         if (!chip->disable)
272                 chip->disable = default_disable;
273         if (!chip->startup)
274                 chip->startup = default_startup;
275         /*
276          * We use chip->disable, when the user provided its own. When
277          * we have default_disable set for chip->disable, then we need
278          * to use default_shutdown, otherwise the irq line is not
279          * disabled on free_irq():
280          */
281         if (!chip->shutdown)
282                 chip->shutdown = chip->disable != default_disable ?
283                         chip->disable : default_shutdown;
284         if (!chip->name)
285                 chip->name = chip->typename;
286         if (!chip->end)
287                 chip->end = dummy_irq_chip.end;
288 }
289
290 static inline void mask_ack_irq(struct irq_desc *desc, int irq)
291 {
292         if (desc->chip->mask_ack)
293                 desc->chip->mask_ack(irq);
294         else {
295                 desc->chip->mask(irq);
296                 desc->chip->ack(irq);
297         }
298 }
299
300 /**
301  *      handle_simple_irq - Simple and software-decoded IRQs.
302  *      @irq:   the interrupt number
303  *      @desc:  the interrupt description structure for this irq
304  *
305  *      Simple interrupts are either sent from a demultiplexing interrupt
306  *      handler or come from hardware, where no interrupt hardware control
307  *      is necessary.
308  *
309  *      Note: The caller is expected to handle the ack, clear, mask and
310  *      unmask issues if necessary.
311  */
312 void
313 handle_simple_irq(unsigned int irq, struct irq_desc *desc)
314 {
315         struct irqaction *action;
316         irqreturn_t action_ret;
317
318         spin_lock(&desc->lock);
319
320         if (unlikely(desc->status & IRQ_INPROGRESS))
321                 goto out_unlock;
322         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
323         kstat_incr_irqs_this_cpu(irq, desc);
324
325         action = desc->action;
326         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
327                 goto out_unlock;
328
329         desc->status |= IRQ_INPROGRESS;
330         spin_unlock(&desc->lock);
331
332         action_ret = handle_IRQ_event(irq, action);
333         if (!noirqdebug)
334                 note_interrupt(irq, desc, action_ret);
335
336         spin_lock(&desc->lock);
337         desc->status &= ~IRQ_INPROGRESS;
338 out_unlock:
339         spin_unlock(&desc->lock);
340 }
341
342 /**
343  *      handle_level_irq - Level type irq handler
344  *      @irq:   the interrupt number
345  *      @desc:  the interrupt description structure for this irq
346  *
347  *      Level type interrupts are active as long as the hardware line has
348  *      the active level. This may require to mask the interrupt and unmask
349  *      it after the associated handler has acknowledged the device, so the
350  *      interrupt line is back to inactive.
351  */
352 void
353 handle_level_irq(unsigned int irq, struct irq_desc *desc)
354 {
355         struct irqaction *action;
356         irqreturn_t action_ret;
357
358         spin_lock(&desc->lock);
359         mask_ack_irq(desc, irq);
360         desc = irq_remap_to_desc(irq, desc);
361
362         if (unlikely(desc->status & IRQ_INPROGRESS))
363                 goto out_unlock;
364         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
365         kstat_incr_irqs_this_cpu(irq, desc);
366
367         /*
368          * If its disabled or no action available
369          * keep it masked and get out of here
370          */
371         action = desc->action;
372         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
373                 goto out_unlock;
374
375         desc->status |= IRQ_INPROGRESS;
376         spin_unlock(&desc->lock);
377
378         action_ret = handle_IRQ_event(irq, action);
379         if (!noirqdebug)
380                 note_interrupt(irq, desc, action_ret);
381
382         spin_lock(&desc->lock);
383         desc->status &= ~IRQ_INPROGRESS;
384         if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
385                 desc->chip->unmask(irq);
386 out_unlock:
387         spin_unlock(&desc->lock);
388 }
389
390 /**
391  *      handle_fasteoi_irq - irq handler for transparent controllers
392  *      @irq:   the interrupt number
393  *      @desc:  the interrupt description structure for this irq
394  *
395  *      Only a single callback will be issued to the chip: an ->eoi()
396  *      call when the interrupt has been serviced. This enables support
397  *      for modern forms of interrupt handlers, which handle the flow
398  *      details in hardware, transparently.
399  */
400 void
401 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
402 {
403         struct irqaction *action;
404         irqreturn_t action_ret;
405
406         spin_lock(&desc->lock);
407
408         if (unlikely(desc->status & IRQ_INPROGRESS))
409                 goto out;
410
411         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
412         kstat_incr_irqs_this_cpu(irq, desc);
413
414         /*
415          * If its disabled or no action available
416          * then mask it and get out of here:
417          */
418         action = desc->action;
419         if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
420                 desc->status |= IRQ_PENDING;
421                 if (desc->chip->mask)
422                         desc->chip->mask(irq);
423                 goto out;
424         }
425
426         desc->status |= IRQ_INPROGRESS;
427         desc->status &= ~IRQ_PENDING;
428         spin_unlock(&desc->lock);
429
430         action_ret = handle_IRQ_event(irq, action);
431         if (!noirqdebug)
432                 note_interrupt(irq, desc, action_ret);
433
434         spin_lock(&desc->lock);
435         desc->status &= ~IRQ_INPROGRESS;
436 out:
437         desc->chip->eoi(irq);
438         desc = irq_remap_to_desc(irq, desc);
439
440         spin_unlock(&desc->lock);
441 }
442
443 /**
444  *      handle_edge_irq - edge type IRQ handler
445  *      @irq:   the interrupt number
446  *      @desc:  the interrupt description structure for this irq
447  *
448  *      Interrupt occures on the falling and/or rising edge of a hardware
449  *      signal. The occurence is latched into the irq controller hardware
450  *      and must be acked in order to be reenabled. After the ack another
451  *      interrupt can happen on the same source even before the first one
452  *      is handled by the assosiacted event handler. If this happens it
453  *      might be necessary to disable (mask) the interrupt depending on the
454  *      controller hardware. This requires to reenable the interrupt inside
455  *      of the loop which handles the interrupts which have arrived while
456  *      the handler was running. If all pending interrupts are handled, the
457  *      loop is left.
458  */
459 void
460 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
461 {
462         spin_lock(&desc->lock);
463
464         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
465
466         /*
467          * If we're currently running this IRQ, or its disabled,
468          * we shouldn't process the IRQ. Mark it pending, handle
469          * the necessary masking and go out
470          */
471         if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
472                     !desc->action)) {
473                 desc->status |= (IRQ_PENDING | IRQ_MASKED);
474                 mask_ack_irq(desc, irq);
475                 desc = irq_remap_to_desc(irq, desc);
476                 goto out_unlock;
477         }
478         kstat_incr_irqs_this_cpu(irq, desc);
479
480         /* Start handling the irq */
481         desc->chip->ack(irq);
482         desc = irq_remap_to_desc(irq, desc);
483
484         /* Mark the IRQ currently in progress.*/
485         desc->status |= IRQ_INPROGRESS;
486
487         do {
488                 struct irqaction *action = desc->action;
489                 irqreturn_t action_ret;
490
491                 if (unlikely(!action)) {
492                         desc->chip->mask(irq);
493                         goto out_unlock;
494                 }
495
496                 /*
497                  * When another irq arrived while we were handling
498                  * one, we could have masked the irq.
499                  * Renable it, if it was not disabled in meantime.
500                  */
501                 if (unlikely((desc->status &
502                                (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
503                               (IRQ_PENDING | IRQ_MASKED))) {
504                         desc->chip->unmask(irq);
505                         desc->status &= ~IRQ_MASKED;
506                 }
507
508                 desc->status &= ~IRQ_PENDING;
509                 spin_unlock(&desc->lock);
510                 action_ret = handle_IRQ_event(irq, action);
511                 if (!noirqdebug)
512                         note_interrupt(irq, desc, action_ret);
513                 spin_lock(&desc->lock);
514
515         } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
516
517         desc->status &= ~IRQ_INPROGRESS;
518 out_unlock:
519         spin_unlock(&desc->lock);
520 }
521
522 /**
523  *      handle_percpu_IRQ - Per CPU local irq handler
524  *      @irq:   the interrupt number
525  *      @desc:  the interrupt description structure for this irq
526  *
527  *      Per CPU interrupts on SMP machines without locking requirements
528  */
529 void
530 handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
531 {
532         irqreturn_t action_ret;
533
534         kstat_incr_irqs_this_cpu(irq, desc);
535
536         if (desc->chip->ack)
537                 desc->chip->ack(irq);
538
539         action_ret = handle_IRQ_event(irq, desc->action);
540         if (!noirqdebug)
541                 note_interrupt(irq, desc, action_ret);
542
543         if (desc->chip->eoi) {
544                 desc->chip->eoi(irq);
545                 desc = irq_remap_to_desc(irq, desc);
546         }
547 }
548
549 void
550 __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
551                   const char *name)
552 {
553         struct irq_desc *desc = irq_to_desc(irq);
554         unsigned long flags;
555
556         if (!desc) {
557                 printk(KERN_ERR
558                        "Trying to install type control for IRQ%d\n", irq);
559                 return;
560         }
561
562         if (!handle)
563                 handle = handle_bad_irq;
564         else if (desc->chip == &no_irq_chip) {
565                 printk(KERN_WARNING "Trying to install %sinterrupt handler "
566                        "for IRQ%d\n", is_chained ? "chained " : "", irq);
567                 /*
568                  * Some ARM implementations install a handler for really dumb
569                  * interrupt hardware without setting an irq_chip. This worked
570                  * with the ARM no_irq_chip but the check in setup_irq would
571                  * prevent us to setup the interrupt at all. Switch it to
572                  * dummy_irq_chip for easy transition.
573                  */
574                 desc->chip = &dummy_irq_chip;
575         }
576
577         spin_lock_irqsave(&desc->lock, flags);
578
579         /* Uninstall? */
580         if (handle == handle_bad_irq) {
581                 if (desc->chip != &no_irq_chip) {
582                         mask_ack_irq(desc, irq);
583                         desc = irq_remap_to_desc(irq, desc);
584                 }
585                 desc->status |= IRQ_DISABLED;
586                 desc->depth = 1;
587         }
588         desc->handle_irq = handle;
589         desc->name = name;
590
591         if (handle != handle_bad_irq && is_chained) {
592                 desc->status &= ~IRQ_DISABLED;
593                 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
594                 desc->depth = 0;
595                 desc->chip->startup(irq);
596         }
597         spin_unlock_irqrestore(&desc->lock, flags);
598 }
599
600 void
601 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
602                          irq_flow_handler_t handle)
603 {
604         set_irq_chip(irq, chip);
605         __set_irq_handler(irq, handle, 0, NULL);
606 }
607
608 void
609 set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
610                               irq_flow_handler_t handle, const char *name)
611 {
612         set_irq_chip(irq, chip);
613         __set_irq_handler(irq, handle, 0, name);
614 }
615
616 void __init set_irq_noprobe(unsigned int irq)
617 {
618         struct irq_desc *desc = irq_to_desc(irq);
619         unsigned long flags;
620
621         if (!desc) {
622                 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
623                 return;
624         }
625
626         spin_lock_irqsave(&desc->lock, flags);
627         desc->status |= IRQ_NOPROBE;
628         spin_unlock_irqrestore(&desc->lock, flags);
629 }
630
631 void __init set_irq_probe(unsigned int irq)
632 {
633         struct irq_desc *desc = irq_to_desc(irq);
634         unsigned long flags;
635
636         if (!desc) {
637                 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
638                 return;
639         }
640
641         spin_lock_irqsave(&desc->lock, flags);
642         desc->status &= ~IRQ_NOPROBE;
643         spin_unlock_irqrestore(&desc->lock, flags);
644 }