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