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