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 <trace/events/irq.h>
21 #include "internals.h"
24 * irq_set_chip - set the irq chip for an irq
26 * @chip: pointer to irq chip description structure
28 int irq_set_chip(unsigned int irq
, struct irq_chip
*chip
)
31 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
39 desc
->irq_data
.chip
= chip
;
40 irq_put_desc_unlock(desc
, flags
);
42 * For !CONFIG_SPARSE_IRQ make the irq show up in
43 * allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
44 * already marked, and this call is harmless.
49 EXPORT_SYMBOL(irq_set_chip
);
52 * irq_set_type - set the irq trigger type for an irq
54 * @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
56 int irq_set_irq_type(unsigned int irq
, unsigned int type
)
59 struct irq_desc
*desc
= irq_get_desc_buslock(irq
, &flags
, IRQ_GET_DESC_CHECK_GLOBAL
);
65 type
&= IRQ_TYPE_SENSE_MASK
;
66 ret
= __irq_set_trigger(desc
, irq
, type
);
67 irq_put_desc_busunlock(desc
, flags
);
70 EXPORT_SYMBOL(irq_set_irq_type
);
73 * irq_set_handler_data - set irq handler data for an irq
74 * @irq: Interrupt number
75 * @data: Pointer to interrupt specific data
77 * Set the hardware irq controller data for an irq
79 int irq_set_handler_data(unsigned int irq
, void *data
)
82 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
86 desc
->irq_data
.handler_data
= data
;
87 irq_put_desc_unlock(desc
, flags
);
90 EXPORT_SYMBOL(irq_set_handler_data
);
93 * irq_set_msi_desc_off - set MSI descriptor data for an irq at offset
94 * @irq_base: Interrupt number base
95 * @irq_offset: Interrupt number offset
96 * @entry: Pointer to MSI descriptor data
98 * Set the MSI descriptor entry for an irq at offset
100 int irq_set_msi_desc_off(unsigned int irq_base
, unsigned int irq_offset
,
101 struct msi_desc
*entry
)
104 struct irq_desc
*desc
= irq_get_desc_lock(irq_base
+ irq_offset
, &flags
, IRQ_GET_DESC_CHECK_GLOBAL
);
108 desc
->irq_data
.msi_desc
= entry
;
109 if (entry
&& !irq_offset
)
110 entry
->irq
= irq_base
;
111 irq_put_desc_unlock(desc
, flags
);
116 * irq_set_msi_desc - set MSI descriptor data for an irq
117 * @irq: Interrupt number
118 * @entry: Pointer to MSI descriptor data
120 * Set the MSI descriptor entry for an irq
122 int irq_set_msi_desc(unsigned int irq
, struct msi_desc
*entry
)
124 return irq_set_msi_desc_off(irq
, 0, entry
);
128 * irq_set_chip_data - set irq chip data for an irq
129 * @irq: Interrupt number
130 * @data: Pointer to chip specific data
132 * Set the hardware irq chip data for an irq
134 int irq_set_chip_data(unsigned int irq
, void *data
)
137 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
141 desc
->irq_data
.chip_data
= data
;
142 irq_put_desc_unlock(desc
, flags
);
145 EXPORT_SYMBOL(irq_set_chip_data
);
147 struct irq_data
*irq_get_irq_data(unsigned int irq
)
149 struct irq_desc
*desc
= irq_to_desc(irq
);
151 return desc
? &desc
->irq_data
: NULL
;
153 EXPORT_SYMBOL_GPL(irq_get_irq_data
);
155 static void irq_state_clr_disabled(struct irq_desc
*desc
)
157 irqd_clear(&desc
->irq_data
, IRQD_IRQ_DISABLED
);
160 static void irq_state_set_disabled(struct irq_desc
*desc
)
162 irqd_set(&desc
->irq_data
, IRQD_IRQ_DISABLED
);
165 static void irq_state_clr_masked(struct irq_desc
*desc
)
167 irqd_clear(&desc
->irq_data
, IRQD_IRQ_MASKED
);
170 static void irq_state_set_masked(struct irq_desc
*desc
)
172 irqd_set(&desc
->irq_data
, IRQD_IRQ_MASKED
);
175 int irq_startup(struct irq_desc
*desc
, bool resend
)
179 irq_state_clr_disabled(desc
);
182 if (desc
->irq_data
.chip
->irq_startup
) {
183 ret
= desc
->irq_data
.chip
->irq_startup(&desc
->irq_data
);
184 irq_state_clr_masked(desc
);
189 check_irq_resend(desc
, desc
->irq_data
.irq
);
193 void irq_shutdown(struct irq_desc
*desc
)
195 irq_state_set_disabled(desc
);
197 if (desc
->irq_data
.chip
->irq_shutdown
)
198 desc
->irq_data
.chip
->irq_shutdown(&desc
->irq_data
);
199 else if (desc
->irq_data
.chip
->irq_disable
)
200 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
202 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
203 irq_state_set_masked(desc
);
206 void irq_enable(struct irq_desc
*desc
)
208 irq_state_clr_disabled(desc
);
209 if (desc
->irq_data
.chip
->irq_enable
)
210 desc
->irq_data
.chip
->irq_enable(&desc
->irq_data
);
212 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
213 irq_state_clr_masked(desc
);
216 void irq_disable(struct irq_desc
*desc
)
218 irq_state_set_disabled(desc
);
219 if (desc
->irq_data
.chip
->irq_disable
) {
220 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
221 irq_state_set_masked(desc
);
225 void irq_percpu_enable(struct irq_desc
*desc
, unsigned int cpu
)
227 if (desc
->irq_data
.chip
->irq_enable
)
228 desc
->irq_data
.chip
->irq_enable(&desc
->irq_data
);
230 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
231 cpumask_set_cpu(cpu
, desc
->percpu_enabled
);
234 void irq_percpu_disable(struct irq_desc
*desc
, unsigned int cpu
)
236 if (desc
->irq_data
.chip
->irq_disable
)
237 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
239 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
240 cpumask_clear_cpu(cpu
, desc
->percpu_enabled
);
243 static inline void mask_ack_irq(struct irq_desc
*desc
)
245 if (desc
->irq_data
.chip
->irq_mask_ack
)
246 desc
->irq_data
.chip
->irq_mask_ack(&desc
->irq_data
);
248 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
249 if (desc
->irq_data
.chip
->irq_ack
)
250 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
252 irq_state_set_masked(desc
);
255 void mask_irq(struct irq_desc
*desc
)
257 if (desc
->irq_data
.chip
->irq_mask
) {
258 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
259 irq_state_set_masked(desc
);
263 void unmask_irq(struct irq_desc
*desc
)
265 if (desc
->irq_data
.chip
->irq_unmask
) {
266 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
267 irq_state_clr_masked(desc
);
272 * handle_nested_irq - Handle a nested irq from a irq thread
273 * @irq: the interrupt number
275 * Handle interrupts which are nested into a threaded interrupt
276 * handler. The handler function is called inside the calling
279 void handle_nested_irq(unsigned int irq
)
281 struct irq_desc
*desc
= irq_to_desc(irq
);
282 struct irqaction
*action
;
283 irqreturn_t action_ret
;
287 raw_spin_lock_irq(&desc
->lock
);
289 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
290 kstat_incr_irqs_this_cpu(irq
, desc
);
292 action
= desc
->action
;
293 if (unlikely(!action
|| irqd_irq_disabled(&desc
->irq_data
))) {
294 desc
->istate
|= IRQS_PENDING
;
298 irqd_set(&desc
->irq_data
, IRQD_IRQ_INPROGRESS
);
299 raw_spin_unlock_irq(&desc
->lock
);
301 action_ret
= action
->thread_fn(action
->irq
, action
->dev_id
);
303 note_interrupt(irq
, desc
, action_ret
);
305 raw_spin_lock_irq(&desc
->lock
);
306 irqd_clear(&desc
->irq_data
, IRQD_IRQ_INPROGRESS
);
309 raw_spin_unlock_irq(&desc
->lock
);
311 EXPORT_SYMBOL_GPL(handle_nested_irq
);
313 static bool irq_check_poll(struct irq_desc
*desc
)
315 if (!(desc
->istate
& IRQS_POLL_INPROGRESS
))
317 return irq_wait_for_poll(desc
);
321 * handle_simple_irq - Simple and software-decoded IRQs.
322 * @irq: the interrupt number
323 * @desc: the interrupt description structure for this irq
325 * Simple interrupts are either sent from a demultiplexing interrupt
326 * handler or come from hardware, where no interrupt hardware control
329 * Note: The caller is expected to handle the ack, clear, mask and
330 * unmask issues if necessary.
333 handle_simple_irq(unsigned int irq
, struct irq_desc
*desc
)
335 raw_spin_lock(&desc
->lock
);
337 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
338 if (!irq_check_poll(desc
))
341 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
342 kstat_incr_irqs_this_cpu(irq
, desc
);
344 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
))) {
345 desc
->istate
|= IRQS_PENDING
;
349 handle_irq_event(desc
);
352 raw_spin_unlock(&desc
->lock
);
354 EXPORT_SYMBOL_GPL(handle_simple_irq
);
357 * Called unconditionally from handle_level_irq() and only for oneshot
358 * interrupts from handle_fasteoi_irq()
360 static void cond_unmask_irq(struct irq_desc
*desc
)
363 * We need to unmask in the following cases:
364 * - Standard level irq (IRQF_ONESHOT is not set)
365 * - Oneshot irq which did not wake the thread (caused by a
366 * spurious interrupt or a primary handler handling it
369 if (!irqd_irq_disabled(&desc
->irq_data
) &&
370 irqd_irq_masked(&desc
->irq_data
) && !desc
->threads_oneshot
)
375 * handle_level_irq - Level type irq handler
376 * @irq: the interrupt number
377 * @desc: the interrupt description structure for this irq
379 * Level type interrupts are active as long as the hardware line has
380 * the active level. This may require to mask the interrupt and unmask
381 * it after the associated handler has acknowledged the device, so the
382 * interrupt line is back to inactive.
385 handle_level_irq(unsigned int irq
, struct irq_desc
*desc
)
387 raw_spin_lock(&desc
->lock
);
390 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
391 if (!irq_check_poll(desc
))
394 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
395 kstat_incr_irqs_this_cpu(irq
, desc
);
398 * If its disabled or no action available
399 * keep it masked and get out of here
401 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
))) {
402 desc
->istate
|= IRQS_PENDING
;
406 handle_irq_event(desc
);
408 cond_unmask_irq(desc
);
411 raw_spin_unlock(&desc
->lock
);
413 EXPORT_SYMBOL_GPL(handle_level_irq
);
415 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
416 static inline void preflow_handler(struct irq_desc
*desc
)
418 if (desc
->preflow_handler
)
419 desc
->preflow_handler(&desc
->irq_data
);
422 static inline void preflow_handler(struct irq_desc
*desc
) { }
426 * handle_fasteoi_irq - irq handler for transparent controllers
427 * @irq: the interrupt number
428 * @desc: the interrupt description structure for this irq
430 * Only a single callback will be issued to the chip: an ->eoi()
431 * call when the interrupt has been serviced. This enables support
432 * for modern forms of interrupt handlers, which handle the flow
433 * details in hardware, transparently.
436 handle_fasteoi_irq(unsigned int irq
, struct irq_desc
*desc
)
438 raw_spin_lock(&desc
->lock
);
440 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
441 if (!irq_check_poll(desc
))
444 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
445 kstat_incr_irqs_this_cpu(irq
, desc
);
448 * If its disabled or no action available
449 * then mask it and get out of here:
451 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
))) {
452 desc
->istate
|= IRQS_PENDING
;
457 if (desc
->istate
& IRQS_ONESHOT
)
460 preflow_handler(desc
);
461 handle_irq_event(desc
);
463 if (desc
->istate
& IRQS_ONESHOT
)
464 cond_unmask_irq(desc
);
467 desc
->irq_data
.chip
->irq_eoi(&desc
->irq_data
);
469 raw_spin_unlock(&desc
->lock
);
472 if (!(desc
->irq_data
.chip
->flags
& IRQCHIP_EOI_IF_HANDLED
))
478 * handle_edge_irq - edge type IRQ handler
479 * @irq: the interrupt number
480 * @desc: the interrupt description structure for this irq
482 * Interrupt occures on the falling and/or rising edge of a hardware
483 * signal. The occurrence is latched into the irq controller hardware
484 * and must be acked in order to be reenabled. After the ack another
485 * interrupt can happen on the same source even before the first one
486 * is handled by the associated event handler. If this happens it
487 * might be necessary to disable (mask) the interrupt depending on the
488 * controller hardware. This requires to reenable the interrupt inside
489 * of the loop which handles the interrupts which have arrived while
490 * the handler was running. If all pending interrupts are handled, the
494 handle_edge_irq(unsigned int irq
, struct irq_desc
*desc
)
496 raw_spin_lock(&desc
->lock
);
498 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
500 * If we're currently running this IRQ, or its disabled,
501 * we shouldn't process the IRQ. Mark it pending, handle
502 * the necessary masking and go out
504 if (unlikely(irqd_irq_disabled(&desc
->irq_data
) ||
505 irqd_irq_inprogress(&desc
->irq_data
) || !desc
->action
)) {
506 if (!irq_check_poll(desc
)) {
507 desc
->istate
|= IRQS_PENDING
;
512 kstat_incr_irqs_this_cpu(irq
, desc
);
514 /* Start handling the irq */
515 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
518 if (unlikely(!desc
->action
)) {
524 * When another irq arrived while we were handling
525 * one, we could have masked the irq.
526 * Renable it, if it was not disabled in meantime.
528 if (unlikely(desc
->istate
& IRQS_PENDING
)) {
529 if (!irqd_irq_disabled(&desc
->irq_data
) &&
530 irqd_irq_masked(&desc
->irq_data
))
534 handle_irq_event(desc
);
536 } while ((desc
->istate
& IRQS_PENDING
) &&
537 !irqd_irq_disabled(&desc
->irq_data
));
540 raw_spin_unlock(&desc
->lock
);
542 EXPORT_SYMBOL(handle_edge_irq
);
544 #ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
546 * handle_edge_eoi_irq - edge eoi type IRQ handler
547 * @irq: the interrupt number
548 * @desc: the interrupt description structure for this irq
550 * Similar as the above handle_edge_irq, but using eoi and w/o the
553 void handle_edge_eoi_irq(unsigned int irq
, struct irq_desc
*desc
)
555 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
557 raw_spin_lock(&desc
->lock
);
559 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
561 * If we're currently running this IRQ, or its disabled,
562 * we shouldn't process the IRQ. Mark it pending, handle
563 * the necessary masking and go out
565 if (unlikely(irqd_irq_disabled(&desc
->irq_data
) ||
566 irqd_irq_inprogress(&desc
->irq_data
) || !desc
->action
)) {
567 if (!irq_check_poll(desc
)) {
568 desc
->istate
|= IRQS_PENDING
;
572 kstat_incr_irqs_this_cpu(irq
, desc
);
575 if (unlikely(!desc
->action
))
578 handle_irq_event(desc
);
580 } while ((desc
->istate
& IRQS_PENDING
) &&
581 !irqd_irq_disabled(&desc
->irq_data
));
584 chip
->irq_eoi(&desc
->irq_data
);
585 raw_spin_unlock(&desc
->lock
);
590 * handle_percpu_irq - Per CPU local irq handler
591 * @irq: the interrupt number
592 * @desc: the interrupt description structure for this irq
594 * Per CPU interrupts on SMP machines without locking requirements
597 handle_percpu_irq(unsigned int irq
, struct irq_desc
*desc
)
599 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
601 kstat_incr_irqs_this_cpu(irq
, desc
);
604 chip
->irq_ack(&desc
->irq_data
);
606 handle_irq_event_percpu(desc
, desc
->action
);
609 chip
->irq_eoi(&desc
->irq_data
);
613 * handle_percpu_devid_irq - Per CPU local irq handler with per cpu dev ids
614 * @irq: the interrupt number
615 * @desc: the interrupt description structure for this irq
617 * Per CPU interrupts on SMP machines without locking requirements. Same as
618 * handle_percpu_irq() above but with the following extras:
620 * action->percpu_dev_id is a pointer to percpu variables which
621 * contain the real device id for the cpu on which this handler is
624 void handle_percpu_devid_irq(unsigned int irq
, struct irq_desc
*desc
)
626 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
627 struct irqaction
*action
= desc
->action
;
628 void *dev_id
= __this_cpu_ptr(action
->percpu_dev_id
);
631 kstat_incr_irqs_this_cpu(irq
, desc
);
634 chip
->irq_ack(&desc
->irq_data
);
636 trace_irq_handler_entry(irq
, action
);
637 res
= action
->handler(irq
, dev_id
);
638 trace_irq_handler_exit(irq
, action
, res
);
641 chip
->irq_eoi(&desc
->irq_data
);
645 __irq_set_handler(unsigned int irq
, irq_flow_handler_t handle
, int is_chained
,
649 struct irq_desc
*desc
= irq_get_desc_buslock(irq
, &flags
, 0);
655 handle
= handle_bad_irq
;
657 if (WARN_ON(desc
->irq_data
.chip
== &no_irq_chip
))
662 if (handle
== handle_bad_irq
) {
663 if (desc
->irq_data
.chip
!= &no_irq_chip
)
665 irq_state_set_disabled(desc
);
668 desc
->handle_irq
= handle
;
671 if (handle
!= handle_bad_irq
&& is_chained
) {
672 irq_settings_set_noprobe(desc
);
673 irq_settings_set_norequest(desc
);
674 irq_settings_set_nothread(desc
);
675 irq_startup(desc
, true);
678 irq_put_desc_busunlock(desc
, flags
);
680 EXPORT_SYMBOL_GPL(__irq_set_handler
);
683 irq_set_chip_and_handler_name(unsigned int irq
, struct irq_chip
*chip
,
684 irq_flow_handler_t handle
, const char *name
)
686 irq_set_chip(irq
, chip
);
687 __irq_set_handler(irq
, handle
, 0, name
);
689 EXPORT_SYMBOL_GPL(irq_set_chip_and_handler_name
);
691 void irq_modify_status(unsigned int irq
, unsigned long clr
, unsigned long set
)
694 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
698 irq_settings_clr_and_set(desc
, clr
, set
);
700 irqd_clear(&desc
->irq_data
, IRQD_NO_BALANCING
| IRQD_PER_CPU
|
701 IRQD_TRIGGER_MASK
| IRQD_LEVEL
| IRQD_MOVE_PCNTXT
);
702 if (irq_settings_has_no_balance_set(desc
))
703 irqd_set(&desc
->irq_data
, IRQD_NO_BALANCING
);
704 if (irq_settings_is_per_cpu(desc
))
705 irqd_set(&desc
->irq_data
, IRQD_PER_CPU
);
706 if (irq_settings_can_move_pcntxt(desc
))
707 irqd_set(&desc
->irq_data
, IRQD_MOVE_PCNTXT
);
708 if (irq_settings_is_level(desc
))
709 irqd_set(&desc
->irq_data
, IRQD_LEVEL
);
711 irqd_set(&desc
->irq_data
, irq_settings_get_trigger_mask(desc
));
713 irq_put_desc_unlock(desc
, flags
);
715 EXPORT_SYMBOL_GPL(irq_modify_status
);
718 * irq_cpu_online - Invoke all irq_cpu_online functions.
720 * Iterate through all irqs and invoke the chip.irq_cpu_online()
723 void irq_cpu_online(void)
725 struct irq_desc
*desc
;
726 struct irq_chip
*chip
;
730 for_each_active_irq(irq
) {
731 desc
= irq_to_desc(irq
);
735 raw_spin_lock_irqsave(&desc
->lock
, flags
);
737 chip
= irq_data_get_irq_chip(&desc
->irq_data
);
738 if (chip
&& chip
->irq_cpu_online
&&
739 (!(chip
->flags
& IRQCHIP_ONOFFLINE_ENABLED
) ||
740 !irqd_irq_disabled(&desc
->irq_data
)))
741 chip
->irq_cpu_online(&desc
->irq_data
);
743 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
748 * irq_cpu_offline - Invoke all irq_cpu_offline functions.
750 * Iterate through all irqs and invoke the chip.irq_cpu_offline()
753 void irq_cpu_offline(void)
755 struct irq_desc
*desc
;
756 struct irq_chip
*chip
;
760 for_each_active_irq(irq
) {
761 desc
= irq_to_desc(irq
);
765 raw_spin_lock_irqsave(&desc
->lock
, flags
);
767 chip
= irq_data_get_irq_chip(&desc
->irq_data
);
768 if (chip
&& chip
->irq_cpu_offline
&&
769 (!(chip
->flags
& IRQCHIP_ONOFFLINE_ENABLED
) ||
770 !irqd_irq_disabled(&desc
->irq_data
)))
771 chip
->irq_cpu_offline(&desc
->irq_data
);
773 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);