2 * linux/kernel/irq/chip.c
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
7 * This file contains the core interrupt handling code, for irq-chip
10 * Detailed information is available in Documentation/DocBook/genericirq
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>
19 #include "internals.h"
21 static void dynamic_irq_init_x(unsigned int irq
, bool keep_chip_data
)
23 struct irq_desc
*desc
;
26 desc
= irq_to_desc(irq
);
28 WARN(1, KERN_ERR
"Trying to initialize invalid IRQ%d\n", irq
);
32 /* Ensure we don't have left over values from a previous use of this irq */
33 raw_spin_lock_irqsave(&desc
->lock
, flags
);
34 desc
->status
= IRQ_DISABLED
;
35 desc
->irq_data
.chip
= &no_irq_chip
;
36 desc
->handle_irq
= handle_bad_irq
;
38 desc
->irq_data
.msi_desc
= NULL
;
39 desc
->irq_data
.handler_data
= NULL
;
41 desc
->irq_data
.chip_data
= NULL
;
44 desc
->irqs_unhandled
= 0;
46 cpumask_setall(desc
->irq_data
.affinity
);
47 #ifdef CONFIG_GENERIC_PENDING_IRQ
48 cpumask_clear(desc
->pending_mask
);
51 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
55 * dynamic_irq_init - initialize a dynamically allocated irq
56 * @irq: irq number to initialize
58 void dynamic_irq_init(unsigned int irq
)
60 dynamic_irq_init_x(irq
, false);
64 * dynamic_irq_init_keep_chip_data - initialize a dynamically allocated irq
65 * @irq: irq number to initialize
67 * does not set irq_to_desc(irq)->irq_data.chip_data to NULL
69 void dynamic_irq_init_keep_chip_data(unsigned int irq
)
71 dynamic_irq_init_x(irq
, true);
74 static void dynamic_irq_cleanup_x(unsigned int irq
, bool keep_chip_data
)
76 struct irq_desc
*desc
= irq_to_desc(irq
);
80 WARN(1, KERN_ERR
"Trying to cleanup invalid IRQ%d\n", irq
);
84 raw_spin_lock_irqsave(&desc
->lock
, flags
);
86 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
87 WARN(1, KERN_ERR
"Destroying IRQ%d without calling free_irq\n",
91 desc
->irq_data
.msi_desc
= NULL
;
92 desc
->irq_data
.handler_data
= NULL
;
94 desc
->irq_data
.chip_data
= NULL
;
95 desc
->handle_irq
= handle_bad_irq
;
96 desc
->irq_data
.chip
= &no_irq_chip
;
98 clear_kstat_irqs(desc
);
99 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
103 * dynamic_irq_cleanup - cleanup a dynamically allocated irq
104 * @irq: irq number to initialize
106 void dynamic_irq_cleanup(unsigned int irq
)
108 dynamic_irq_cleanup_x(irq
, false);
112 * dynamic_irq_cleanup_keep_chip_data - cleanup a dynamically allocated irq
113 * @irq: irq number to initialize
115 * does not set irq_to_desc(irq)->irq_data.chip_data to NULL
117 void dynamic_irq_cleanup_keep_chip_data(unsigned int irq
)
119 dynamic_irq_cleanup_x(irq
, true);
124 * set_irq_chip - set the irq chip for an irq
126 * @chip: pointer to irq chip description structure
128 int set_irq_chip(unsigned int irq
, struct irq_chip
*chip
)
130 struct irq_desc
*desc
= irq_to_desc(irq
);
134 WARN(1, KERN_ERR
"Trying to install chip for IRQ%d\n", irq
);
141 raw_spin_lock_irqsave(&desc
->lock
, flags
);
142 irq_chip_set_defaults(chip
);
143 desc
->irq_data
.chip
= chip
;
144 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
148 EXPORT_SYMBOL(set_irq_chip
);
151 * set_irq_type - set the irq trigger type for an irq
153 * @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
155 int set_irq_type(unsigned int irq
, unsigned int type
)
157 struct irq_desc
*desc
= irq_to_desc(irq
);
162 printk(KERN_ERR
"Trying to set irq type for IRQ%d\n", irq
);
166 type
&= IRQ_TYPE_SENSE_MASK
;
167 if (type
== IRQ_TYPE_NONE
)
170 raw_spin_lock_irqsave(&desc
->lock
, flags
);
171 ret
= __irq_set_trigger(desc
, irq
, type
);
172 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
175 EXPORT_SYMBOL(set_irq_type
);
178 * set_irq_data - set irq type data for an irq
179 * @irq: Interrupt number
180 * @data: Pointer to interrupt specific data
182 * Set the hardware irq controller data for an irq
184 int set_irq_data(unsigned int irq
, void *data
)
186 struct irq_desc
*desc
= irq_to_desc(irq
);
191 "Trying to install controller data for IRQ%d\n", irq
);
195 raw_spin_lock_irqsave(&desc
->lock
, flags
);
196 desc
->irq_data
.handler_data
= data
;
197 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
200 EXPORT_SYMBOL(set_irq_data
);
203 * set_irq_msi - set MSI descriptor data for an irq
204 * @irq: Interrupt number
205 * @entry: Pointer to MSI descriptor data
207 * Set the MSI descriptor entry for an irq
209 int set_irq_msi(unsigned int irq
, struct msi_desc
*entry
)
211 struct irq_desc
*desc
= irq_to_desc(irq
);
216 "Trying to install msi data for IRQ%d\n", irq
);
220 raw_spin_lock_irqsave(&desc
->lock
, flags
);
221 desc
->irq_data
.msi_desc
= entry
;
224 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
229 * set_irq_chip_data - set irq chip data for an irq
230 * @irq: Interrupt number
231 * @data: Pointer to chip specific data
233 * Set the hardware irq chip data for an irq
235 int set_irq_chip_data(unsigned int irq
, void *data
)
237 struct irq_desc
*desc
= irq_to_desc(irq
);
242 "Trying to install chip data for IRQ%d\n", irq
);
246 if (!desc
->irq_data
.chip
) {
247 printk(KERN_ERR
"BUG: bad set_irq_chip_data(IRQ#%d)\n", irq
);
251 raw_spin_lock_irqsave(&desc
->lock
, flags
);
252 desc
->irq_data
.chip_data
= data
;
253 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
257 EXPORT_SYMBOL(set_irq_chip_data
);
260 * set_irq_nested_thread - Set/Reset the IRQ_NESTED_THREAD flag of an irq
262 * @irq: Interrupt number
263 * @nest: 0 to clear / 1 to set the IRQ_NESTED_THREAD flag
265 * The IRQ_NESTED_THREAD flag indicates that on
266 * request_threaded_irq() no separate interrupt thread should be
267 * created for the irq as the handler are called nested in the
268 * context of a demultiplexing interrupt handler thread.
270 void set_irq_nested_thread(unsigned int irq
, int nest
)
272 struct irq_desc
*desc
= irq_to_desc(irq
);
278 raw_spin_lock_irqsave(&desc
->lock
, flags
);
280 desc
->status
|= IRQ_NESTED_THREAD
;
282 desc
->status
&= ~IRQ_NESTED_THREAD
;
283 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
285 EXPORT_SYMBOL_GPL(set_irq_nested_thread
);
288 * default enable function
290 static void default_enable(struct irq_data
*data
)
292 struct irq_desc
*desc
= irq_data_to_desc(data
);
294 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
295 desc
->status
&= ~IRQ_MASKED
;
299 * default disable function
301 static void default_disable(struct irq_data
*data
)
306 * default startup function
308 static unsigned int default_startup(unsigned int irq
)
310 struct irq_desc
*desc
= irq_to_desc(irq
);
312 desc
->irq_data
.chip
->irq_enable(&desc
->irq_data
);
317 * default shutdown function
319 static void default_shutdown(struct irq_data
*data
)
321 struct irq_desc
*desc
= irq_data_to_desc(data
);
323 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
324 desc
->status
|= IRQ_MASKED
;
327 /* Temporary migration helpers */
328 static void compat_irq_mask(struct irq_data
*data
)
330 data
->chip
->mask(data
->irq
);
333 static void compat_irq_unmask(struct irq_data
*data
)
335 data
->chip
->unmask(data
->irq
);
338 static void compat_irq_ack(struct irq_data
*data
)
340 data
->chip
->ack(data
->irq
);
343 static void compat_irq_mask_ack(struct irq_data
*data
)
345 data
->chip
->mask_ack(data
->irq
);
348 static void compat_irq_eoi(struct irq_data
*data
)
350 data
->chip
->eoi(data
->irq
);
353 static void compat_irq_enable(struct irq_data
*data
)
355 data
->chip
->enable(data
->irq
);
358 static void compat_irq_disable(struct irq_data
*data
)
360 data
->chip
->disable(data
->irq
);
363 static void compat_irq_shutdown(struct irq_data
*data
)
365 data
->chip
->shutdown(data
->irq
);
368 static void compat_bus_lock(struct irq_data
*data
)
370 data
->chip
->bus_lock(data
->irq
);
373 static void compat_bus_sync_unlock(struct irq_data
*data
)
375 data
->chip
->bus_sync_unlock(data
->irq
);
379 * Fixup enable/disable function pointers
381 void irq_chip_set_defaults(struct irq_chip
*chip
)
384 * Compat fixup functions need to be before we set the
385 * defaults for enable/disable/startup/shutdown
388 chip
->irq_enable
= compat_irq_enable
;
390 chip
->irq_disable
= compat_irq_disable
;
392 chip
->irq_shutdown
= compat_irq_shutdown
;
397 if (!chip
->irq_enable
)
398 chip
->irq_enable
= default_enable
;
399 if (!chip
->irq_disable
)
400 chip
->irq_disable
= default_disable
;
402 chip
->startup
= default_startup
;
404 * We use chip->irq_disable, when the user provided its own. When
405 * we have default_disable set for chip->irq_disable, then we need
406 * to use default_shutdown, otherwise the irq line is not
407 * disabled on free_irq():
409 if (!chip
->irq_shutdown
)
410 chip
->irq_shutdown
= chip
->irq_disable
!= default_disable
?
411 chip
->irq_disable
: default_shutdown
;
413 chip
->end
= dummy_irq_chip
.end
;
416 * Now fix up the remaining compat handlers
419 chip
->irq_bus_lock
= compat_bus_lock
;
420 if (chip
->bus_sync_unlock
)
421 chip
->irq_bus_sync_unlock
= compat_bus_sync_unlock
;
423 chip
->irq_mask
= compat_irq_mask
;
425 chip
->irq_unmask
= compat_irq_unmask
;
427 chip
->irq_ack
= compat_irq_ack
;
429 chip
->irq_mask_ack
= compat_irq_mask_ack
;
431 chip
->irq_eoi
= compat_irq_eoi
;
434 static inline void mask_ack_irq(struct irq_desc
*desc
)
436 if (desc
->irq_data
.chip
->irq_mask_ack
)
437 desc
->irq_data
.chip
->irq_mask_ack(&desc
->irq_data
);
439 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
440 if (desc
->irq_data
.chip
->irq_ack
)
441 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
443 desc
->status
|= IRQ_MASKED
;
446 static inline void mask_irq(struct irq_desc
*desc
)
448 if (desc
->irq_data
.chip
->irq_mask
) {
449 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
450 desc
->status
|= IRQ_MASKED
;
454 static inline void unmask_irq(struct irq_desc
*desc
)
456 if (desc
->irq_data
.chip
->irq_unmask
) {
457 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
458 desc
->status
&= ~IRQ_MASKED
;
463 * handle_nested_irq - Handle a nested irq from a irq thread
464 * @irq: the interrupt number
466 * Handle interrupts which are nested into a threaded interrupt
467 * handler. The handler function is called inside the calling
470 void handle_nested_irq(unsigned int irq
)
472 struct irq_desc
*desc
= irq_to_desc(irq
);
473 struct irqaction
*action
;
474 irqreturn_t action_ret
;
478 raw_spin_lock_irq(&desc
->lock
);
480 kstat_incr_irqs_this_cpu(irq
, desc
);
482 action
= desc
->action
;
483 if (unlikely(!action
|| (desc
->status
& IRQ_DISABLED
)))
486 desc
->status
|= IRQ_INPROGRESS
;
487 raw_spin_unlock_irq(&desc
->lock
);
489 action_ret
= action
->thread_fn(action
->irq
, action
->dev_id
);
491 note_interrupt(irq
, desc
, action_ret
);
493 raw_spin_lock_irq(&desc
->lock
);
494 desc
->status
&= ~IRQ_INPROGRESS
;
497 raw_spin_unlock_irq(&desc
->lock
);
499 EXPORT_SYMBOL_GPL(handle_nested_irq
);
502 * handle_simple_irq - Simple and software-decoded IRQs.
503 * @irq: the interrupt number
504 * @desc: the interrupt description structure for this irq
506 * Simple interrupts are either sent from a demultiplexing interrupt
507 * handler or come from hardware, where no interrupt hardware control
510 * Note: The caller is expected to handle the ack, clear, mask and
511 * unmask issues if necessary.
514 handle_simple_irq(unsigned int irq
, struct irq_desc
*desc
)
516 struct irqaction
*action
;
517 irqreturn_t action_ret
;
519 raw_spin_lock(&desc
->lock
);
521 if (unlikely(desc
->status
& IRQ_INPROGRESS
))
523 desc
->status
&= ~(IRQ_REPLAY
| IRQ_WAITING
);
524 kstat_incr_irqs_this_cpu(irq
, desc
);
526 action
= desc
->action
;
527 if (unlikely(!action
|| (desc
->status
& IRQ_DISABLED
)))
530 desc
->status
|= IRQ_INPROGRESS
;
531 raw_spin_unlock(&desc
->lock
);
533 action_ret
= handle_IRQ_event(irq
, action
);
535 note_interrupt(irq
, desc
, action_ret
);
537 raw_spin_lock(&desc
->lock
);
538 desc
->status
&= ~IRQ_INPROGRESS
;
540 raw_spin_unlock(&desc
->lock
);
544 * handle_level_irq - Level type irq handler
545 * @irq: the interrupt number
546 * @desc: the interrupt description structure for this irq
548 * Level type interrupts are active as long as the hardware line has
549 * the active level. This may require to mask the interrupt and unmask
550 * it after the associated handler has acknowledged the device, so the
551 * interrupt line is back to inactive.
554 handle_level_irq(unsigned int irq
, struct irq_desc
*desc
)
556 struct irqaction
*action
;
557 irqreturn_t action_ret
;
559 raw_spin_lock(&desc
->lock
);
562 if (unlikely(desc
->status
& IRQ_INPROGRESS
))
564 desc
->status
&= ~(IRQ_REPLAY
| IRQ_WAITING
);
565 kstat_incr_irqs_this_cpu(irq
, desc
);
568 * If its disabled or no action available
569 * keep it masked and get out of here
571 action
= desc
->action
;
572 if (unlikely(!action
|| (desc
->status
& IRQ_DISABLED
)))
575 desc
->status
|= IRQ_INPROGRESS
;
576 raw_spin_unlock(&desc
->lock
);
578 action_ret
= handle_IRQ_event(irq
, action
);
580 note_interrupt(irq
, desc
, action_ret
);
582 raw_spin_lock(&desc
->lock
);
583 desc
->status
&= ~IRQ_INPROGRESS
;
585 if (!(desc
->status
& (IRQ_DISABLED
| IRQ_ONESHOT
)))
588 raw_spin_unlock(&desc
->lock
);
590 EXPORT_SYMBOL_GPL(handle_level_irq
);
593 * handle_fasteoi_irq - irq handler for transparent controllers
594 * @irq: the interrupt number
595 * @desc: the interrupt description structure for this irq
597 * Only a single callback will be issued to the chip: an ->eoi()
598 * call when the interrupt has been serviced. This enables support
599 * for modern forms of interrupt handlers, which handle the flow
600 * details in hardware, transparently.
603 handle_fasteoi_irq(unsigned int irq
, struct irq_desc
*desc
)
605 struct irqaction
*action
;
606 irqreturn_t action_ret
;
608 raw_spin_lock(&desc
->lock
);
610 if (unlikely(desc
->status
& IRQ_INPROGRESS
))
613 desc
->status
&= ~(IRQ_REPLAY
| IRQ_WAITING
);
614 kstat_incr_irqs_this_cpu(irq
, desc
);
617 * If its disabled or no action available
618 * then mask it and get out of here:
620 action
= desc
->action
;
621 if (unlikely(!action
|| (desc
->status
& IRQ_DISABLED
))) {
622 desc
->status
|= IRQ_PENDING
;
627 desc
->status
|= IRQ_INPROGRESS
;
628 desc
->status
&= ~IRQ_PENDING
;
629 raw_spin_unlock(&desc
->lock
);
631 action_ret
= handle_IRQ_event(irq
, action
);
633 note_interrupt(irq
, desc
, action_ret
);
635 raw_spin_lock(&desc
->lock
);
636 desc
->status
&= ~IRQ_INPROGRESS
;
638 desc
->irq_data
.chip
->irq_eoi(&desc
->irq_data
);
640 raw_spin_unlock(&desc
->lock
);
644 * handle_edge_irq - edge type IRQ handler
645 * @irq: the interrupt number
646 * @desc: the interrupt description structure for this irq
648 * Interrupt occures on the falling and/or rising edge of a hardware
649 * signal. The occurence is latched into the irq controller hardware
650 * and must be acked in order to be reenabled. After the ack another
651 * interrupt can happen on the same source even before the first one
652 * is handled by the associated event handler. If this happens it
653 * might be necessary to disable (mask) the interrupt depending on the
654 * controller hardware. This requires to reenable the interrupt inside
655 * of the loop which handles the interrupts which have arrived while
656 * the handler was running. If all pending interrupts are handled, the
660 handle_edge_irq(unsigned int irq
, struct irq_desc
*desc
)
662 raw_spin_lock(&desc
->lock
);
664 desc
->status
&= ~(IRQ_REPLAY
| IRQ_WAITING
);
667 * If we're currently running this IRQ, or its disabled,
668 * we shouldn't process the IRQ. Mark it pending, handle
669 * the necessary masking and go out
671 if (unlikely((desc
->status
& (IRQ_INPROGRESS
| IRQ_DISABLED
)) ||
673 desc
->status
|= (IRQ_PENDING
| IRQ_MASKED
);
677 kstat_incr_irqs_this_cpu(irq
, desc
);
679 /* Start handling the irq */
680 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
682 /* Mark the IRQ currently in progress.*/
683 desc
->status
|= IRQ_INPROGRESS
;
686 struct irqaction
*action
= desc
->action
;
687 irqreturn_t action_ret
;
689 if (unlikely(!action
)) {
695 * When another irq arrived while we were handling
696 * one, we could have masked the irq.
697 * Renable it, if it was not disabled in meantime.
699 if (unlikely((desc
->status
&
700 (IRQ_PENDING
| IRQ_MASKED
| IRQ_DISABLED
)) ==
701 (IRQ_PENDING
| IRQ_MASKED
))) {
705 desc
->status
&= ~IRQ_PENDING
;
706 raw_spin_unlock(&desc
->lock
);
707 action_ret
= handle_IRQ_event(irq
, action
);
709 note_interrupt(irq
, desc
, action_ret
);
710 raw_spin_lock(&desc
->lock
);
712 } while ((desc
->status
& (IRQ_PENDING
| IRQ_DISABLED
)) == IRQ_PENDING
);
714 desc
->status
&= ~IRQ_INPROGRESS
;
716 raw_spin_unlock(&desc
->lock
);
720 * handle_percpu_irq - Per CPU local irq handler
721 * @irq: the interrupt number
722 * @desc: the interrupt description structure for this irq
724 * Per CPU interrupts on SMP machines without locking requirements
727 handle_percpu_irq(unsigned int irq
, struct irq_desc
*desc
)
729 irqreturn_t action_ret
;
731 kstat_incr_irqs_this_cpu(irq
, desc
);
733 if (desc
->irq_data
.chip
->irq_ack
)
734 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
736 action_ret
= handle_IRQ_event(irq
, desc
->action
);
738 note_interrupt(irq
, desc
, action_ret
);
740 if (desc
->irq_data
.chip
->irq_eoi
)
741 desc
->irq_data
.chip
->irq_eoi(&desc
->irq_data
);
745 __set_irq_handler(unsigned int irq
, irq_flow_handler_t handle
, int is_chained
,
748 struct irq_desc
*desc
= irq_to_desc(irq
);
753 "Trying to install type control for IRQ%d\n", irq
);
758 handle
= handle_bad_irq
;
759 else if (desc
->irq_data
.chip
== &no_irq_chip
) {
760 printk(KERN_WARNING
"Trying to install %sinterrupt handler "
761 "for IRQ%d\n", is_chained
? "chained " : "", irq
);
763 * Some ARM implementations install a handler for really dumb
764 * interrupt hardware without setting an irq_chip. This worked
765 * with the ARM no_irq_chip but the check in setup_irq would
766 * prevent us to setup the interrupt at all. Switch it to
767 * dummy_irq_chip for easy transition.
769 desc
->irq_data
.chip
= &dummy_irq_chip
;
773 raw_spin_lock_irqsave(&desc
->lock
, flags
);
776 if (handle
== handle_bad_irq
) {
777 if (desc
->irq_data
.chip
!= &no_irq_chip
)
779 desc
->status
|= IRQ_DISABLED
;
782 desc
->handle_irq
= handle
;
785 if (handle
!= handle_bad_irq
&& is_chained
) {
786 desc
->status
&= ~IRQ_DISABLED
;
787 desc
->status
|= IRQ_NOREQUEST
| IRQ_NOPROBE
;
789 desc
->irq_data
.chip
->startup(irq
);
791 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
792 chip_bus_sync_unlock(desc
);
794 EXPORT_SYMBOL_GPL(__set_irq_handler
);
797 set_irq_chip_and_handler(unsigned int irq
, struct irq_chip
*chip
,
798 irq_flow_handler_t handle
)
800 set_irq_chip(irq
, chip
);
801 __set_irq_handler(irq
, handle
, 0, NULL
);
805 set_irq_chip_and_handler_name(unsigned int irq
, struct irq_chip
*chip
,
806 irq_flow_handler_t handle
, const char *name
)
808 set_irq_chip(irq
, chip
);
809 __set_irq_handler(irq
, handle
, 0, name
);
812 void set_irq_noprobe(unsigned int irq
)
814 struct irq_desc
*desc
= irq_to_desc(irq
);
818 printk(KERN_ERR
"Trying to mark IRQ%d non-probeable\n", irq
);
822 raw_spin_lock_irqsave(&desc
->lock
, flags
);
823 desc
->status
|= IRQ_NOPROBE
;
824 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
827 void set_irq_probe(unsigned int irq
)
829 struct irq_desc
*desc
= irq_to_desc(irq
);
833 printk(KERN_ERR
"Trying to mark IRQ%d probeable\n", irq
);
837 raw_spin_lock_irqsave(&desc
->lock
, flags
);
838 desc
->status
&= ~IRQ_NOPROBE
;
839 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);