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 - set MSI descriptor data for an irq
94 * @irq: Interrupt number
95 * @entry: Pointer to MSI descriptor data
97 * Set the MSI descriptor entry for an irq
99 int irq_set_msi_desc(unsigned int irq
, struct msi_desc
*entry
)
102 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, IRQ_GET_DESC_CHECK_GLOBAL
);
106 desc
->irq_data
.msi_desc
= entry
;
109 irq_put_desc_unlock(desc
, flags
);
114 * irq_set_chip_data - set irq chip data for an irq
115 * @irq: Interrupt number
116 * @data: Pointer to chip specific data
118 * Set the hardware irq chip data for an irq
120 int irq_set_chip_data(unsigned int irq
, void *data
)
123 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
127 desc
->irq_data
.chip_data
= data
;
128 irq_put_desc_unlock(desc
, flags
);
131 EXPORT_SYMBOL(irq_set_chip_data
);
133 struct irq_data
*irq_get_irq_data(unsigned int irq
)
135 struct irq_desc
*desc
= irq_to_desc(irq
);
137 return desc
? &desc
->irq_data
: NULL
;
139 EXPORT_SYMBOL_GPL(irq_get_irq_data
);
141 static void irq_state_clr_disabled(struct irq_desc
*desc
)
143 irqd_clear(&desc
->irq_data
, IRQD_IRQ_DISABLED
);
146 static void irq_state_set_disabled(struct irq_desc
*desc
)
148 irqd_set(&desc
->irq_data
, IRQD_IRQ_DISABLED
);
151 static void irq_state_clr_masked(struct irq_desc
*desc
)
153 irqd_clear(&desc
->irq_data
, IRQD_IRQ_MASKED
);
156 static void irq_state_set_masked(struct irq_desc
*desc
)
158 irqd_set(&desc
->irq_data
, IRQD_IRQ_MASKED
);
161 int irq_startup(struct irq_desc
*desc
, bool resend
)
165 irq_state_clr_disabled(desc
);
168 if (desc
->irq_data
.chip
->irq_startup
) {
169 ret
= desc
->irq_data
.chip
->irq_startup(&desc
->irq_data
);
170 irq_state_clr_masked(desc
);
175 check_irq_resend(desc
, desc
->irq_data
.irq
);
179 void irq_shutdown(struct irq_desc
*desc
)
181 irq_state_set_disabled(desc
);
183 if (desc
->irq_data
.chip
->irq_shutdown
)
184 desc
->irq_data
.chip
->irq_shutdown(&desc
->irq_data
);
185 else if (desc
->irq_data
.chip
->irq_disable
)
186 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
188 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
189 irq_state_set_masked(desc
);
192 void irq_enable(struct irq_desc
*desc
)
194 irq_state_clr_disabled(desc
);
195 if (desc
->irq_data
.chip
->irq_enable
)
196 desc
->irq_data
.chip
->irq_enable(&desc
->irq_data
);
198 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
199 irq_state_clr_masked(desc
);
202 void irq_disable(struct irq_desc
*desc
)
204 irq_state_set_disabled(desc
);
205 if (desc
->irq_data
.chip
->irq_disable
) {
206 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
207 irq_state_set_masked(desc
);
211 void irq_percpu_enable(struct irq_desc
*desc
, unsigned int cpu
)
213 if (desc
->irq_data
.chip
->irq_enable
)
214 desc
->irq_data
.chip
->irq_enable(&desc
->irq_data
);
216 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
217 cpumask_set_cpu(cpu
, desc
->percpu_enabled
);
220 void irq_percpu_disable(struct irq_desc
*desc
, unsigned int cpu
)
222 if (desc
->irq_data
.chip
->irq_disable
)
223 desc
->irq_data
.chip
->irq_disable(&desc
->irq_data
);
225 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
226 cpumask_clear_cpu(cpu
, desc
->percpu_enabled
);
229 static inline void mask_ack_irq(struct irq_desc
*desc
)
231 if (desc
->irq_data
.chip
->irq_mask_ack
)
232 desc
->irq_data
.chip
->irq_mask_ack(&desc
->irq_data
);
234 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
235 if (desc
->irq_data
.chip
->irq_ack
)
236 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
238 irq_state_set_masked(desc
);
241 void mask_irq(struct irq_desc
*desc
)
243 if (desc
->irq_data
.chip
->irq_mask
) {
244 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
245 irq_state_set_masked(desc
);
249 void unmask_irq(struct irq_desc
*desc
)
251 if (desc
->irq_data
.chip
->irq_unmask
) {
252 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
253 irq_state_clr_masked(desc
);
258 * handle_nested_irq - Handle a nested irq from a irq thread
259 * @irq: the interrupt number
261 * Handle interrupts which are nested into a threaded interrupt
262 * handler. The handler function is called inside the calling
265 void handle_nested_irq(unsigned int irq
)
267 struct irq_desc
*desc
= irq_to_desc(irq
);
268 struct irqaction
*action
;
269 irqreturn_t action_ret
;
273 raw_spin_lock_irq(&desc
->lock
);
275 kstat_incr_irqs_this_cpu(irq
, desc
);
277 action
= desc
->action
;
278 if (unlikely(!action
|| irqd_irq_disabled(&desc
->irq_data
)))
281 irqd_set(&desc
->irq_data
, IRQD_IRQ_INPROGRESS
);
282 raw_spin_unlock_irq(&desc
->lock
);
284 action_ret
= action
->thread_fn(action
->irq
, action
->dev_id
);
286 note_interrupt(irq
, desc
, action_ret
);
288 raw_spin_lock_irq(&desc
->lock
);
289 irqd_clear(&desc
->irq_data
, IRQD_IRQ_INPROGRESS
);
292 raw_spin_unlock_irq(&desc
->lock
);
294 EXPORT_SYMBOL_GPL(handle_nested_irq
);
296 static bool irq_check_poll(struct irq_desc
*desc
)
298 if (!(desc
->istate
& IRQS_POLL_INPROGRESS
))
300 return irq_wait_for_poll(desc
);
304 * handle_simple_irq - Simple and software-decoded IRQs.
305 * @irq: the interrupt number
306 * @desc: the interrupt description structure for this irq
308 * Simple interrupts are either sent from a demultiplexing interrupt
309 * handler or come from hardware, where no interrupt hardware control
312 * Note: The caller is expected to handle the ack, clear, mask and
313 * unmask issues if necessary.
316 handle_simple_irq(unsigned int irq
, struct irq_desc
*desc
)
318 raw_spin_lock(&desc
->lock
);
320 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
321 if (!irq_check_poll(desc
))
324 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
325 kstat_incr_irqs_this_cpu(irq
, desc
);
327 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
)))
330 handle_irq_event(desc
);
333 raw_spin_unlock(&desc
->lock
);
335 EXPORT_SYMBOL_GPL(handle_simple_irq
);
338 * Called unconditionally from handle_level_irq() and only for oneshot
339 * interrupts from handle_fasteoi_irq()
341 static void cond_unmask_irq(struct irq_desc
*desc
)
344 * We need to unmask in the following cases:
345 * - Standard level irq (IRQF_ONESHOT is not set)
346 * - Oneshot irq which did not wake the thread (caused by a
347 * spurious interrupt or a primary handler handling it
350 if (!irqd_irq_disabled(&desc
->irq_data
) &&
351 irqd_irq_masked(&desc
->irq_data
) && !desc
->threads_oneshot
)
356 * handle_level_irq - Level type irq handler
357 * @irq: the interrupt number
358 * @desc: the interrupt description structure for this irq
360 * Level type interrupts are active as long as the hardware line has
361 * the active level. This may require to mask the interrupt and unmask
362 * it after the associated handler has acknowledged the device, so the
363 * interrupt line is back to inactive.
366 handle_level_irq(unsigned int irq
, struct irq_desc
*desc
)
368 raw_spin_lock(&desc
->lock
);
371 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
372 if (!irq_check_poll(desc
))
375 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
376 kstat_incr_irqs_this_cpu(irq
, desc
);
379 * If its disabled or no action available
380 * keep it masked and get out of here
382 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
))) {
383 desc
->istate
|= IRQS_PENDING
;
387 handle_irq_event(desc
);
389 cond_unmask_irq(desc
);
392 raw_spin_unlock(&desc
->lock
);
394 EXPORT_SYMBOL_GPL(handle_level_irq
);
396 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
397 static inline void preflow_handler(struct irq_desc
*desc
)
399 if (desc
->preflow_handler
)
400 desc
->preflow_handler(&desc
->irq_data
);
403 static inline void preflow_handler(struct irq_desc
*desc
) { }
407 * handle_fasteoi_irq - irq handler for transparent controllers
408 * @irq: the interrupt number
409 * @desc: the interrupt description structure for this irq
411 * Only a single callback will be issued to the chip: an ->eoi()
412 * call when the interrupt has been serviced. This enables support
413 * for modern forms of interrupt handlers, which handle the flow
414 * details in hardware, transparently.
417 handle_fasteoi_irq(unsigned int irq
, struct irq_desc
*desc
)
419 raw_spin_lock(&desc
->lock
);
421 if (unlikely(irqd_irq_inprogress(&desc
->irq_data
)))
422 if (!irq_check_poll(desc
))
425 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
426 kstat_incr_irqs_this_cpu(irq
, desc
);
429 * If its disabled or no action available
430 * then mask it and get out of here:
432 if (unlikely(!desc
->action
|| irqd_irq_disabled(&desc
->irq_data
))) {
433 desc
->istate
|= IRQS_PENDING
;
438 if (desc
->istate
& IRQS_ONESHOT
)
441 preflow_handler(desc
);
442 handle_irq_event(desc
);
444 if (desc
->istate
& IRQS_ONESHOT
)
445 cond_unmask_irq(desc
);
448 desc
->irq_data
.chip
->irq_eoi(&desc
->irq_data
);
450 raw_spin_unlock(&desc
->lock
);
453 if (!(desc
->irq_data
.chip
->flags
& IRQCHIP_EOI_IF_HANDLED
))
459 * handle_edge_irq - edge type IRQ handler
460 * @irq: the interrupt number
461 * @desc: the interrupt description structure for this irq
463 * Interrupt occures on the falling and/or rising edge of a hardware
464 * signal. The occurrence is latched into the irq controller hardware
465 * and must be acked in order to be reenabled. After the ack another
466 * interrupt can happen on the same source even before the first one
467 * is handled by the associated event handler. If this happens it
468 * might be necessary to disable (mask) the interrupt depending on the
469 * controller hardware. This requires to reenable the interrupt inside
470 * of the loop which handles the interrupts which have arrived while
471 * the handler was running. If all pending interrupts are handled, the
475 handle_edge_irq(unsigned int irq
, struct irq_desc
*desc
)
477 raw_spin_lock(&desc
->lock
);
479 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
481 * If we're currently running this IRQ, or its disabled,
482 * we shouldn't process the IRQ. Mark it pending, handle
483 * the necessary masking and go out
485 if (unlikely(irqd_irq_disabled(&desc
->irq_data
) ||
486 irqd_irq_inprogress(&desc
->irq_data
) || !desc
->action
)) {
487 if (!irq_check_poll(desc
)) {
488 desc
->istate
|= IRQS_PENDING
;
493 kstat_incr_irqs_this_cpu(irq
, desc
);
495 /* Start handling the irq */
496 desc
->irq_data
.chip
->irq_ack(&desc
->irq_data
);
499 if (unlikely(!desc
->action
)) {
505 * When another irq arrived while we were handling
506 * one, we could have masked the irq.
507 * Renable it, if it was not disabled in meantime.
509 if (unlikely(desc
->istate
& IRQS_PENDING
)) {
510 if (!irqd_irq_disabled(&desc
->irq_data
) &&
511 irqd_irq_masked(&desc
->irq_data
))
515 handle_irq_event(desc
);
517 } while ((desc
->istate
& IRQS_PENDING
) &&
518 !irqd_irq_disabled(&desc
->irq_data
));
521 raw_spin_unlock(&desc
->lock
);
523 EXPORT_SYMBOL(handle_edge_irq
);
525 #ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
527 * handle_edge_eoi_irq - edge eoi type IRQ handler
528 * @irq: the interrupt number
529 * @desc: the interrupt description structure for this irq
531 * Similar as the above handle_edge_irq, but using eoi and w/o the
534 void handle_edge_eoi_irq(unsigned int irq
, struct irq_desc
*desc
)
536 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
538 raw_spin_lock(&desc
->lock
);
540 desc
->istate
&= ~(IRQS_REPLAY
| IRQS_WAITING
);
542 * If we're currently running this IRQ, or its disabled,
543 * we shouldn't process the IRQ. Mark it pending, handle
544 * the necessary masking and go out
546 if (unlikely(irqd_irq_disabled(&desc
->irq_data
) ||
547 irqd_irq_inprogress(&desc
->irq_data
) || !desc
->action
)) {
548 if (!irq_check_poll(desc
)) {
549 desc
->istate
|= IRQS_PENDING
;
553 kstat_incr_irqs_this_cpu(irq
, desc
);
556 if (unlikely(!desc
->action
))
559 handle_irq_event(desc
);
561 } while ((desc
->istate
& IRQS_PENDING
) &&
562 !irqd_irq_disabled(&desc
->irq_data
));
565 chip
->irq_eoi(&desc
->irq_data
);
566 raw_spin_unlock(&desc
->lock
);
571 * handle_percpu_irq - Per CPU local irq handler
572 * @irq: the interrupt number
573 * @desc: the interrupt description structure for this irq
575 * Per CPU interrupts on SMP machines without locking requirements
578 handle_percpu_irq(unsigned int irq
, struct irq_desc
*desc
)
580 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
582 kstat_incr_irqs_this_cpu(irq
, desc
);
585 chip
->irq_ack(&desc
->irq_data
);
587 handle_irq_event_percpu(desc
, desc
->action
);
590 chip
->irq_eoi(&desc
->irq_data
);
594 * handle_percpu_devid_irq - Per CPU local irq handler with per cpu dev ids
595 * @irq: the interrupt number
596 * @desc: the interrupt description structure for this irq
598 * Per CPU interrupts on SMP machines without locking requirements. Same as
599 * handle_percpu_irq() above but with the following extras:
601 * action->percpu_dev_id is a pointer to percpu variables which
602 * contain the real device id for the cpu on which this handler is
605 void handle_percpu_devid_irq(unsigned int irq
, struct irq_desc
*desc
)
607 struct irq_chip
*chip
= irq_desc_get_chip(desc
);
608 struct irqaction
*action
= desc
->action
;
609 void *dev_id
= __this_cpu_ptr(action
->percpu_dev_id
);
612 kstat_incr_irqs_this_cpu(irq
, desc
);
615 chip
->irq_ack(&desc
->irq_data
);
617 trace_irq_handler_entry(irq
, action
);
618 res
= action
->handler(irq
, dev_id
);
619 trace_irq_handler_exit(irq
, action
, res
);
622 chip
->irq_eoi(&desc
->irq_data
);
626 __irq_set_handler(unsigned int irq
, irq_flow_handler_t handle
, int is_chained
,
630 struct irq_desc
*desc
= irq_get_desc_buslock(irq
, &flags
, 0);
636 handle
= handle_bad_irq
;
638 if (WARN_ON(desc
->irq_data
.chip
== &no_irq_chip
))
643 if (handle
== handle_bad_irq
) {
644 if (desc
->irq_data
.chip
!= &no_irq_chip
)
646 irq_state_set_disabled(desc
);
649 desc
->handle_irq
= handle
;
652 if (handle
!= handle_bad_irq
&& is_chained
) {
653 irq_settings_set_noprobe(desc
);
654 irq_settings_set_norequest(desc
);
655 irq_settings_set_nothread(desc
);
656 irq_startup(desc
, true);
659 irq_put_desc_busunlock(desc
, flags
);
661 EXPORT_SYMBOL_GPL(__irq_set_handler
);
664 irq_set_chip_and_handler_name(unsigned int irq
, struct irq_chip
*chip
,
665 irq_flow_handler_t handle
, const char *name
)
667 irq_set_chip(irq
, chip
);
668 __irq_set_handler(irq
, handle
, 0, name
);
671 void irq_modify_status(unsigned int irq
, unsigned long clr
, unsigned long set
)
674 struct irq_desc
*desc
= irq_get_desc_lock(irq
, &flags
, 0);
678 irq_settings_clr_and_set(desc
, clr
, set
);
680 irqd_clear(&desc
->irq_data
, IRQD_NO_BALANCING
| IRQD_PER_CPU
|
681 IRQD_TRIGGER_MASK
| IRQD_LEVEL
| IRQD_MOVE_PCNTXT
);
682 if (irq_settings_has_no_balance_set(desc
))
683 irqd_set(&desc
->irq_data
, IRQD_NO_BALANCING
);
684 if (irq_settings_is_per_cpu(desc
))
685 irqd_set(&desc
->irq_data
, IRQD_PER_CPU
);
686 if (irq_settings_can_move_pcntxt(desc
))
687 irqd_set(&desc
->irq_data
, IRQD_MOVE_PCNTXT
);
688 if (irq_settings_is_level(desc
))
689 irqd_set(&desc
->irq_data
, IRQD_LEVEL
);
691 irqd_set(&desc
->irq_data
, irq_settings_get_trigger_mask(desc
));
693 irq_put_desc_unlock(desc
, flags
);
695 EXPORT_SYMBOL_GPL(irq_modify_status
);
698 * irq_cpu_online - Invoke all irq_cpu_online functions.
700 * Iterate through all irqs and invoke the chip.irq_cpu_online()
703 void irq_cpu_online(void)
705 struct irq_desc
*desc
;
706 struct irq_chip
*chip
;
710 for_each_active_irq(irq
) {
711 desc
= irq_to_desc(irq
);
715 raw_spin_lock_irqsave(&desc
->lock
, flags
);
717 chip
= irq_data_get_irq_chip(&desc
->irq_data
);
718 if (chip
&& chip
->irq_cpu_online
&&
719 (!(chip
->flags
& IRQCHIP_ONOFFLINE_ENABLED
) ||
720 !irqd_irq_disabled(&desc
->irq_data
)))
721 chip
->irq_cpu_online(&desc
->irq_data
);
723 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
728 * irq_cpu_offline - Invoke all irq_cpu_offline functions.
730 * Iterate through all irqs and invoke the chip.irq_cpu_offline()
733 void irq_cpu_offline(void)
735 struct irq_desc
*desc
;
736 struct irq_chip
*chip
;
740 for_each_active_irq(irq
) {
741 desc
= irq_to_desc(irq
);
745 raw_spin_lock_irqsave(&desc
->lock
, flags
);
747 chip
= irq_data_get_irq_chip(&desc
->irq_data
);
748 if (chip
&& chip
->irq_cpu_offline
&&
749 (!(chip
->flags
& IRQCHIP_ONOFFLINE_ENABLED
) ||
750 !irqd_irq_disabled(&desc
->irq_data
)))
751 chip
->irq_cpu_offline(&desc
->irq_data
);
753 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);