genirq: Convert irq_desc.lock to raw_spinlock
[linux-3.10.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         raw_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         raw_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         raw_spin_lock_irqsave(&desc->lock, flags);
72         if (desc->action) {
73                 raw_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         raw_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         raw_spin_lock_irqsave(&desc->lock, flags);
108         irq_chip_set_defaults(chip);
109         desc->chip = chip;
110         raw_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         raw_spin_lock_irqsave(&desc->lock, flags);
137         ret = __irq_set_trigger(desc, irq, type);
138         raw_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         raw_spin_lock_irqsave(&desc->lock, flags);
162         desc->handler_data = data;
163         raw_spin_unlock_irqrestore(&desc->lock, flags);
164         return 0;
165 }
166 EXPORT_SYMBOL(set_irq_data);
167
168 /**
169  *      set_irq_msi - set MSI descriptor data for an irq
170  *      @irq:   Interrupt number
171  *      @entry: Pointer to MSI descriptor data
172  *
173  *      Set the MSI descriptor entry 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         raw_spin_lock_irqsave(&desc->lock, flags);
187         desc->msi_desc = entry;
188         if (entry)
189                 entry->irq = irq;
190         raw_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         raw_spin_lock_irqsave(&desc->lock, flags);
218         desc->chip_data = data;
219         raw_spin_unlock_irqrestore(&desc->lock, flags);
220
221         return 0;
222 }
223 EXPORT_SYMBOL(set_irq_chip_data);
224
225 /**
226  *      set_irq_nested_thread - Set/Reset the IRQ_NESTED_THREAD flag of an irq
227  *
228  *      @irq:   Interrupt number
229  *      @nest:  0 to clear / 1 to set the IRQ_NESTED_THREAD flag
230  *
231  *      The IRQ_NESTED_THREAD flag indicates that on
232  *      request_threaded_irq() no separate interrupt thread should be
233  *      created for the irq as the handler are called nested in the
234  *      context of a demultiplexing interrupt handler thread.
235  */
236 void set_irq_nested_thread(unsigned int irq, int nest)
237 {
238         struct irq_desc *desc = irq_to_desc(irq);
239         unsigned long flags;
240
241         if (!desc)
242                 return;
243
244         raw_spin_lock_irqsave(&desc->lock, flags);
245         if (nest)
246                 desc->status |= IRQ_NESTED_THREAD;
247         else
248                 desc->status &= ~IRQ_NESTED_THREAD;
249         raw_spin_unlock_irqrestore(&desc->lock, flags);
250 }
251 EXPORT_SYMBOL_GPL(set_irq_nested_thread);
252
253 /*
254  * default enable function
255  */
256 static void default_enable(unsigned int irq)
257 {
258         struct irq_desc *desc = irq_to_desc(irq);
259
260         desc->chip->unmask(irq);
261         desc->status &= ~IRQ_MASKED;
262 }
263
264 /*
265  * default disable function
266  */
267 static void default_disable(unsigned int irq)
268 {
269 }
270
271 /*
272  * default startup function
273  */
274 static unsigned int default_startup(unsigned int irq)
275 {
276         struct irq_desc *desc = irq_to_desc(irq);
277
278         desc->chip->enable(irq);
279         return 0;
280 }
281
282 /*
283  * default shutdown function
284  */
285 static void default_shutdown(unsigned int irq)
286 {
287         struct irq_desc *desc = irq_to_desc(irq);
288
289         desc->chip->mask(irq);
290         desc->status |= IRQ_MASKED;
291 }
292
293 /*
294  * Fixup enable/disable function pointers
295  */
296 void irq_chip_set_defaults(struct irq_chip *chip)
297 {
298         if (!chip->enable)
299                 chip->enable = default_enable;
300         if (!chip->disable)
301                 chip->disable = default_disable;
302         if (!chip->startup)
303                 chip->startup = default_startup;
304         /*
305          * We use chip->disable, when the user provided its own. When
306          * we have default_disable set for chip->disable, then we need
307          * to use default_shutdown, otherwise the irq line is not
308          * disabled on free_irq():
309          */
310         if (!chip->shutdown)
311                 chip->shutdown = chip->disable != default_disable ?
312                         chip->disable : default_shutdown;
313         if (!chip->name)
314                 chip->name = chip->typename;
315         if (!chip->end)
316                 chip->end = dummy_irq_chip.end;
317 }
318
319 static inline void mask_ack_irq(struct irq_desc *desc, int irq)
320 {
321         if (desc->chip->mask_ack)
322                 desc->chip->mask_ack(irq);
323         else {
324                 desc->chip->mask(irq);
325                 if (desc->chip->ack)
326                         desc->chip->ack(irq);
327         }
328 }
329
330 /*
331  *      handle_nested_irq - Handle a nested irq from a irq thread
332  *      @irq:   the interrupt number
333  *
334  *      Handle interrupts which are nested into a threaded interrupt
335  *      handler. The handler function is called inside the calling
336  *      threads context.
337  */
338 void handle_nested_irq(unsigned int irq)
339 {
340         struct irq_desc *desc = irq_to_desc(irq);
341         struct irqaction *action;
342         irqreturn_t action_ret;
343
344         might_sleep();
345
346         raw_spin_lock_irq(&desc->lock);
347
348         kstat_incr_irqs_this_cpu(irq, desc);
349
350         action = desc->action;
351         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
352                 goto out_unlock;
353
354         desc->status |= IRQ_INPROGRESS;
355         raw_spin_unlock_irq(&desc->lock);
356
357         action_ret = action->thread_fn(action->irq, action->dev_id);
358         if (!noirqdebug)
359                 note_interrupt(irq, desc, action_ret);
360
361         raw_spin_lock_irq(&desc->lock);
362         desc->status &= ~IRQ_INPROGRESS;
363
364 out_unlock:
365         raw_spin_unlock_irq(&desc->lock);
366 }
367 EXPORT_SYMBOL_GPL(handle_nested_irq);
368
369 /**
370  *      handle_simple_irq - Simple and software-decoded IRQs.
371  *      @irq:   the interrupt number
372  *      @desc:  the interrupt description structure for this irq
373  *
374  *      Simple interrupts are either sent from a demultiplexing interrupt
375  *      handler or come from hardware, where no interrupt hardware control
376  *      is necessary.
377  *
378  *      Note: The caller is expected to handle the ack, clear, mask and
379  *      unmask issues if necessary.
380  */
381 void
382 handle_simple_irq(unsigned int irq, struct irq_desc *desc)
383 {
384         struct irqaction *action;
385         irqreturn_t action_ret;
386
387         raw_spin_lock(&desc->lock);
388
389         if (unlikely(desc->status & IRQ_INPROGRESS))
390                 goto out_unlock;
391         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
392         kstat_incr_irqs_this_cpu(irq, desc);
393
394         action = desc->action;
395         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
396                 goto out_unlock;
397
398         desc->status |= IRQ_INPROGRESS;
399         raw_spin_unlock(&desc->lock);
400
401         action_ret = handle_IRQ_event(irq, action);
402         if (!noirqdebug)
403                 note_interrupt(irq, desc, action_ret);
404
405         raw_spin_lock(&desc->lock);
406         desc->status &= ~IRQ_INPROGRESS;
407 out_unlock:
408         raw_spin_unlock(&desc->lock);
409 }
410
411 /**
412  *      handle_level_irq - Level type irq handler
413  *      @irq:   the interrupt number
414  *      @desc:  the interrupt description structure for this irq
415  *
416  *      Level type interrupts are active as long as the hardware line has
417  *      the active level. This may require to mask the interrupt and unmask
418  *      it after the associated handler has acknowledged the device, so the
419  *      interrupt line is back to inactive.
420  */
421 void
422 handle_level_irq(unsigned int irq, struct irq_desc *desc)
423 {
424         struct irqaction *action;
425         irqreturn_t action_ret;
426
427         raw_spin_lock(&desc->lock);
428         mask_ack_irq(desc, irq);
429
430         if (unlikely(desc->status & IRQ_INPROGRESS))
431                 goto out_unlock;
432         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
433         kstat_incr_irqs_this_cpu(irq, desc);
434
435         /*
436          * If its disabled or no action available
437          * keep it masked and get out of here
438          */
439         action = desc->action;
440         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
441                 goto out_unlock;
442
443         desc->status |= IRQ_INPROGRESS;
444         raw_spin_unlock(&desc->lock);
445
446         action_ret = handle_IRQ_event(irq, action);
447         if (!noirqdebug)
448                 note_interrupt(irq, desc, action_ret);
449
450         raw_spin_lock(&desc->lock);
451         desc->status &= ~IRQ_INPROGRESS;
452
453         if (unlikely(desc->status & IRQ_ONESHOT))
454                 desc->status |= IRQ_MASKED;
455         else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
456                 desc->chip->unmask(irq);
457 out_unlock:
458         raw_spin_unlock(&desc->lock);
459 }
460 EXPORT_SYMBOL_GPL(handle_level_irq);
461
462 /**
463  *      handle_fasteoi_irq - irq handler for transparent controllers
464  *      @irq:   the interrupt number
465  *      @desc:  the interrupt description structure for this irq
466  *
467  *      Only a single callback will be issued to the chip: an ->eoi()
468  *      call when the interrupt has been serviced. This enables support
469  *      for modern forms of interrupt handlers, which handle the flow
470  *      details in hardware, transparently.
471  */
472 void
473 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
474 {
475         struct irqaction *action;
476         irqreturn_t action_ret;
477
478         raw_spin_lock(&desc->lock);
479
480         if (unlikely(desc->status & IRQ_INPROGRESS))
481                 goto out;
482
483         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
484         kstat_incr_irqs_this_cpu(irq, desc);
485
486         /*
487          * If its disabled or no action available
488          * then mask it and get out of here:
489          */
490         action = desc->action;
491         if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
492                 desc->status |= IRQ_PENDING;
493                 if (desc->chip->mask)
494                         desc->chip->mask(irq);
495                 goto out;
496         }
497
498         desc->status |= IRQ_INPROGRESS;
499         desc->status &= ~IRQ_PENDING;
500         raw_spin_unlock(&desc->lock);
501
502         action_ret = handle_IRQ_event(irq, action);
503         if (!noirqdebug)
504                 note_interrupt(irq, desc, action_ret);
505
506         raw_spin_lock(&desc->lock);
507         desc->status &= ~IRQ_INPROGRESS;
508 out:
509         desc->chip->eoi(irq);
510
511         raw_spin_unlock(&desc->lock);
512 }
513
514 /**
515  *      handle_edge_irq - edge type IRQ handler
516  *      @irq:   the interrupt number
517  *      @desc:  the interrupt description structure for this irq
518  *
519  *      Interrupt occures on the falling and/or rising edge of a hardware
520  *      signal. The occurence is latched into the irq controller hardware
521  *      and must be acked in order to be reenabled. After the ack another
522  *      interrupt can happen on the same source even before the first one
523  *      is handled by the assosiacted event handler. If this happens it
524  *      might be necessary to disable (mask) the interrupt depending on the
525  *      controller hardware. This requires to reenable the interrupt inside
526  *      of the loop which handles the interrupts which have arrived while
527  *      the handler was running. If all pending interrupts are handled, the
528  *      loop is left.
529  */
530 void
531 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
532 {
533         raw_spin_lock(&desc->lock);
534
535         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
536
537         /*
538          * If we're currently running this IRQ, or its disabled,
539          * we shouldn't process the IRQ. Mark it pending, handle
540          * the necessary masking and go out
541          */
542         if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
543                     !desc->action)) {
544                 desc->status |= (IRQ_PENDING | IRQ_MASKED);
545                 mask_ack_irq(desc, irq);
546                 goto out_unlock;
547         }
548         kstat_incr_irqs_this_cpu(irq, desc);
549
550         /* Start handling the irq */
551         if (desc->chip->ack)
552                 desc->chip->ack(irq);
553
554         /* Mark the IRQ currently in progress.*/
555         desc->status |= IRQ_INPROGRESS;
556
557         do {
558                 struct irqaction *action = desc->action;
559                 irqreturn_t action_ret;
560
561                 if (unlikely(!action)) {
562                         desc->chip->mask(irq);
563                         goto out_unlock;
564                 }
565
566                 /*
567                  * When another irq arrived while we were handling
568                  * one, we could have masked the irq.
569                  * Renable it, if it was not disabled in meantime.
570                  */
571                 if (unlikely((desc->status &
572                                (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
573                               (IRQ_PENDING | IRQ_MASKED))) {
574                         desc->chip->unmask(irq);
575                         desc->status &= ~IRQ_MASKED;
576                 }
577
578                 desc->status &= ~IRQ_PENDING;
579                 raw_spin_unlock(&desc->lock);
580                 action_ret = handle_IRQ_event(irq, action);
581                 if (!noirqdebug)
582                         note_interrupt(irq, desc, action_ret);
583                 raw_spin_lock(&desc->lock);
584
585         } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
586
587         desc->status &= ~IRQ_INPROGRESS;
588 out_unlock:
589         raw_spin_unlock(&desc->lock);
590 }
591
592 /**
593  *      handle_percpu_irq - Per CPU local irq handler
594  *      @irq:   the interrupt number
595  *      @desc:  the interrupt description structure for this irq
596  *
597  *      Per CPU interrupts on SMP machines without locking requirements
598  */
599 void
600 handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
601 {
602         irqreturn_t action_ret;
603
604         kstat_incr_irqs_this_cpu(irq, desc);
605
606         if (desc->chip->ack)
607                 desc->chip->ack(irq);
608
609         action_ret = handle_IRQ_event(irq, desc->action);
610         if (!noirqdebug)
611                 note_interrupt(irq, desc, action_ret);
612
613         if (desc->chip->eoi)
614                 desc->chip->eoi(irq);
615 }
616
617 void
618 __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
619                   const char *name)
620 {
621         struct irq_desc *desc = irq_to_desc(irq);
622         unsigned long flags;
623
624         if (!desc) {
625                 printk(KERN_ERR
626                        "Trying to install type control for IRQ%d\n", irq);
627                 return;
628         }
629
630         if (!handle)
631                 handle = handle_bad_irq;
632         else if (desc->chip == &no_irq_chip) {
633                 printk(KERN_WARNING "Trying to install %sinterrupt handler "
634                        "for IRQ%d\n", is_chained ? "chained " : "", irq);
635                 /*
636                  * Some ARM implementations install a handler for really dumb
637                  * interrupt hardware without setting an irq_chip. This worked
638                  * with the ARM no_irq_chip but the check in setup_irq would
639                  * prevent us to setup the interrupt at all. Switch it to
640                  * dummy_irq_chip for easy transition.
641                  */
642                 desc->chip = &dummy_irq_chip;
643         }
644
645         chip_bus_lock(irq, desc);
646         raw_spin_lock_irqsave(&desc->lock, flags);
647
648         /* Uninstall? */
649         if (handle == handle_bad_irq) {
650                 if (desc->chip != &no_irq_chip)
651                         mask_ack_irq(desc, irq);
652                 desc->status |= IRQ_DISABLED;
653                 desc->depth = 1;
654         }
655         desc->handle_irq = handle;
656         desc->name = name;
657
658         if (handle != handle_bad_irq && is_chained) {
659                 desc->status &= ~IRQ_DISABLED;
660                 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
661                 desc->depth = 0;
662                 desc->chip->startup(irq);
663         }
664         raw_spin_unlock_irqrestore(&desc->lock, flags);
665         chip_bus_sync_unlock(irq, desc);
666 }
667 EXPORT_SYMBOL_GPL(__set_irq_handler);
668
669 void
670 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
671                          irq_flow_handler_t handle)
672 {
673         set_irq_chip(irq, chip);
674         __set_irq_handler(irq, handle, 0, NULL);
675 }
676
677 void
678 set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
679                               irq_flow_handler_t handle, const char *name)
680 {
681         set_irq_chip(irq, chip);
682         __set_irq_handler(irq, handle, 0, name);
683 }
684
685 void __init set_irq_noprobe(unsigned int irq)
686 {
687         struct irq_desc *desc = irq_to_desc(irq);
688         unsigned long flags;
689
690         if (!desc) {
691                 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
692                 return;
693         }
694
695         raw_spin_lock_irqsave(&desc->lock, flags);
696         desc->status |= IRQ_NOPROBE;
697         raw_spin_unlock_irqrestore(&desc->lock, flags);
698 }
699
700 void __init set_irq_probe(unsigned int irq)
701 {
702         struct irq_desc *desc = irq_to_desc(irq);
703         unsigned long flags;
704
705         if (!desc) {
706                 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
707                 return;
708         }
709
710         raw_spin_lock_irqsave(&desc->lock, flags);
711         desc->status &= ~IRQ_NOPROBE;
712         raw_spin_unlock_irqrestore(&desc->lock, flags);
713 }