2 * linux/kernel/irq/manage.c
4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5 * Copyright (C) 2005-2006 Thomas Gleixner
7 * This file contains driver APIs to the irq subsystem.
10 #include <linux/irq.h>
11 #include <linux/kthread.h>
12 #include <linux/module.h>
13 #include <linux/random.h>
14 #include <linux/interrupt.h>
15 #include <linux/slab.h>
16 #include <linux/sched.h>
18 #include "internals.h"
21 * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
22 * @irq: interrupt number to wait for
24 * This function waits for any pending IRQ handlers for this interrupt
25 * to complete before returning. If you use this function while
26 * holding a resource the IRQ handler may need you will deadlock.
28 * This function may be called - with care - from IRQ context.
30 void synchronize_irq(unsigned int irq)
32 struct irq_desc *desc = irq_to_desc(irq);
42 * Wait until we're out of the critical section. This might
43 * give the wrong answer due to the lack of memory barriers.
45 while (desc->status & IRQ_INPROGRESS)
48 /* Ok, that indicated we're done: double-check carefully. */
49 raw_spin_lock_irqsave(&desc->lock, flags);
50 status = desc->status;
51 raw_spin_unlock_irqrestore(&desc->lock, flags);
53 /* Oops, that failed? */
54 } while (status & IRQ_INPROGRESS);
57 * We made sure that no hardirq handler is running. Now verify
58 * that no threaded handlers are active.
60 wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
62 EXPORT_SYMBOL(synchronize_irq);
65 cpumask_var_t irq_default_affinity;
68 * irq_can_set_affinity - Check if the affinity of a given irq can be set
69 * @irq: Interrupt to check
72 int irq_can_set_affinity(unsigned int irq)
74 struct irq_desc *desc = irq_to_desc(irq);
76 if (CHECK_IRQ_PER_CPU(desc->status) || !desc->irq_data.chip ||
77 !desc->irq_data.chip->irq_set_affinity)
84 * irq_set_thread_affinity - Notify irq threads to adjust affinity
85 * @desc: irq descriptor which has affitnity changed
87 * We just set IRQTF_AFFINITY and delegate the affinity setting
88 * to the interrupt thread itself. We can not call
89 * set_cpus_allowed_ptr() here as we hold desc->lock and this
90 * code can be called from hard interrupt context.
92 void irq_set_thread_affinity(struct irq_desc *desc)
94 struct irqaction *action = desc->action;
98 set_bit(IRQTF_AFFINITY, &action->thread_flags);
99 action = action->next;
104 * irq_set_affinity - Set the irq affinity of a given irq
105 * @irq: Interrupt to set affinity
109 int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
111 struct irq_desc *desc = irq_to_desc(irq);
112 struct irq_chip *chip = desc->irq_data.chip;
115 if (!chip->irq_set_affinity)
118 raw_spin_lock_irqsave(&desc->lock, flags);
120 #ifdef CONFIG_GENERIC_PENDING_IRQ
121 if (desc->status & IRQ_MOVE_PCNTXT) {
122 if (!chip->irq_set_affinity(&desc->irq_data, cpumask, false)) {
123 cpumask_copy(desc->irq_data.affinity, cpumask);
124 irq_set_thread_affinity(desc);
128 desc->status |= IRQ_MOVE_PENDING;
129 cpumask_copy(desc->pending_mask, cpumask);
132 if (!chip->irq_set_affinity(&desc->irq_data, cpumask, false)) {
133 cpumask_copy(desc->irq_data.affinity, cpumask);
134 irq_set_thread_affinity(desc);
137 if (desc->affinity_notify) {
138 kref_get(&desc->affinity_notify->kref);
139 schedule_work(&desc->affinity_notify->work);
141 desc->status |= IRQ_AFFINITY_SET;
142 raw_spin_unlock_irqrestore(&desc->lock, flags);
146 int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
148 struct irq_desc *desc = irq_to_desc(irq);
154 raw_spin_lock_irqsave(&desc->lock, flags);
155 desc->affinity_hint = m;
156 raw_spin_unlock_irqrestore(&desc->lock, flags);
160 EXPORT_SYMBOL_GPL(irq_set_affinity_hint);
162 static void irq_affinity_notify(struct work_struct *work)
164 struct irq_affinity_notify *notify =
165 container_of(work, struct irq_affinity_notify, work);
166 struct irq_desc *desc = irq_to_desc(notify->irq);
167 cpumask_var_t cpumask;
173 if (!alloc_cpumask_var(&cpumask, GFP_KERNEL))
176 raw_spin_lock_irqsave(&desc->lock, flags);
177 #ifdef CONFIG_GENERIC_PENDING_IRQ
178 if (desc->status & IRQ_MOVE_PENDING)
179 cpumask_copy(cpumask, desc->pending_mask);
182 cpumask_copy(cpumask, desc->irq_data.affinity);
183 raw_spin_unlock_irqrestore(&desc->lock, flags);
185 notify->notify(notify, cpumask);
187 free_cpumask_var(cpumask);
189 kref_put(¬ify->kref, notify->release);
193 * irq_set_affinity_notifier - control notification of IRQ affinity changes
194 * @irq: Interrupt for which to enable/disable notification
195 * @notify: Context for notification, or %NULL to disable
196 * notification. Function pointers must be initialised;
197 * the other fields will be initialised by this function.
199 * Must be called in process context. Notification may only be enabled
200 * after the IRQ is allocated and must be disabled before the IRQ is
201 * freed using free_irq().
204 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
206 struct irq_desc *desc = irq_to_desc(irq);
207 struct irq_affinity_notify *old_notify;
210 /* The release function is promised process context */
216 /* Complete initialisation of *notify */
219 kref_init(¬ify->kref);
220 INIT_WORK(¬ify->work, irq_affinity_notify);
223 raw_spin_lock_irqsave(&desc->lock, flags);
224 old_notify = desc->affinity_notify;
225 desc->affinity_notify = notify;
226 raw_spin_unlock_irqrestore(&desc->lock, flags);
229 kref_put(&old_notify->kref, old_notify->release);
233 EXPORT_SYMBOL_GPL(irq_set_affinity_notifier);
235 #ifndef CONFIG_AUTO_IRQ_AFFINITY
237 * Generic version of the affinity autoselector.
239 static int setup_affinity(unsigned int irq, struct irq_desc *desc)
241 if (!irq_can_set_affinity(irq))
245 * Preserve an userspace affinity setup, but make sure that
246 * one of the targets is online.
248 if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
249 if (cpumask_any_and(desc->irq_data.affinity, cpu_online_mask)
253 desc->status &= ~IRQ_AFFINITY_SET;
256 cpumask_and(desc->irq_data.affinity, cpu_online_mask, irq_default_affinity);
258 desc->irq_data.chip->irq_set_affinity(&desc->irq_data, desc->irq_data.affinity, false);
263 static inline int setup_affinity(unsigned int irq, struct irq_desc *d)
265 return irq_select_affinity(irq);
270 * Called when affinity is set via /proc/irq
272 int irq_select_affinity_usr(unsigned int irq)
274 struct irq_desc *desc = irq_to_desc(irq);
278 raw_spin_lock_irqsave(&desc->lock, flags);
279 ret = setup_affinity(irq, desc);
281 irq_set_thread_affinity(desc);
282 raw_spin_unlock_irqrestore(&desc->lock, flags);
288 static inline int setup_affinity(unsigned int irq, struct irq_desc *desc)
294 void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
297 if (!desc->action || (desc->action->flags & IRQF_NO_SUSPEND))
299 desc->status |= IRQ_SUSPENDED;
302 if (!desc->depth++) {
303 desc->status |= IRQ_DISABLED;
304 desc->irq_data.chip->irq_disable(&desc->irq_data);
309 * disable_irq_nosync - disable an irq without waiting
310 * @irq: Interrupt to disable
312 * Disable the selected interrupt line. Disables and Enables are
314 * Unlike disable_irq(), this function does not ensure existing
315 * instances of the IRQ handler have completed before returning.
317 * This function may be called from IRQ context.
319 void disable_irq_nosync(unsigned int irq)
321 struct irq_desc *desc = irq_to_desc(irq);
328 raw_spin_lock_irqsave(&desc->lock, flags);
329 __disable_irq(desc, irq, false);
330 raw_spin_unlock_irqrestore(&desc->lock, flags);
331 chip_bus_sync_unlock(desc);
333 EXPORT_SYMBOL(disable_irq_nosync);
336 * disable_irq - disable an irq and wait for completion
337 * @irq: Interrupt to disable
339 * Disable the selected interrupt line. Enables and Disables are
341 * This function waits for any pending IRQ handlers for this interrupt
342 * to complete before returning. If you use this function while
343 * holding a resource the IRQ handler may need you will deadlock.
345 * This function may be called - with care - from IRQ context.
347 void disable_irq(unsigned int irq)
349 struct irq_desc *desc = irq_to_desc(irq);
354 disable_irq_nosync(irq);
356 synchronize_irq(irq);
358 EXPORT_SYMBOL(disable_irq);
360 void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
363 desc->status &= ~IRQ_SUSPENDED;
365 switch (desc->depth) {
368 WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
371 unsigned int status = desc->status & ~IRQ_DISABLED;
373 if (desc->status & IRQ_SUSPENDED)
375 /* Prevent probing on this irq: */
376 desc->status = status | IRQ_NOPROBE;
377 check_irq_resend(desc, irq);
386 * enable_irq - enable handling of an irq
387 * @irq: Interrupt to enable
389 * Undoes the effect of one call to disable_irq(). If this
390 * matches the last disable, processing of interrupts on this
391 * IRQ line is re-enabled.
393 * This function may be called from IRQ context only when
394 * desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
396 void enable_irq(unsigned int irq)
398 struct irq_desc *desc = irq_to_desc(irq);
404 if (WARN(!desc->irq_data.chip || !desc->irq_data.chip->irq_enable,
405 KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq))
409 raw_spin_lock_irqsave(&desc->lock, flags);
410 __enable_irq(desc, irq, false);
411 raw_spin_unlock_irqrestore(&desc->lock, flags);
412 chip_bus_sync_unlock(desc);
414 EXPORT_SYMBOL(enable_irq);
416 static int set_irq_wake_real(unsigned int irq, unsigned int on)
418 struct irq_desc *desc = irq_to_desc(irq);
421 if (desc->irq_data.chip->irq_set_wake)
422 ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on);
428 * set_irq_wake - control irq power management wakeup
429 * @irq: interrupt to control
430 * @on: enable/disable power management wakeup
432 * Enable/disable power management wakeup mode, which is
433 * disabled by default. Enables and disables must match,
434 * just as they match for non-wakeup mode support.
436 * Wakeup mode lets this IRQ wake the system from sleep
437 * states like "suspend to RAM".
439 int set_irq_wake(unsigned int irq, unsigned int on)
441 struct irq_desc *desc = irq_to_desc(irq);
445 /* wakeup-capable irqs can be shared between drivers that
446 * don't need to have the same sleep mode behaviors.
448 raw_spin_lock_irqsave(&desc->lock, flags);
450 if (desc->wake_depth++ == 0) {
451 ret = set_irq_wake_real(irq, on);
453 desc->wake_depth = 0;
455 desc->status |= IRQ_WAKEUP;
458 if (desc->wake_depth == 0) {
459 WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
460 } else if (--desc->wake_depth == 0) {
461 ret = set_irq_wake_real(irq, on);
463 desc->wake_depth = 1;
465 desc->status &= ~IRQ_WAKEUP;
469 raw_spin_unlock_irqrestore(&desc->lock, flags);
472 EXPORT_SYMBOL(set_irq_wake);
475 * Internal function that tells the architecture code whether a
476 * particular irq has been exclusively allocated or is available
479 int can_request_irq(unsigned int irq, unsigned long irqflags)
481 struct irq_desc *desc = irq_to_desc(irq);
482 struct irqaction *action;
488 if (desc->status & IRQ_NOREQUEST)
491 raw_spin_lock_irqsave(&desc->lock, flags);
492 action = desc->action;
494 if (irqflags & action->flags & IRQF_SHARED)
497 raw_spin_unlock_irqrestore(&desc->lock, flags);
502 void compat_irq_chip_set_default_handler(struct irq_desc *desc)
505 * If the architecture still has not overriden
506 * the flow handler then zap the default. This
507 * should catch incorrect flow-type setting.
509 if (desc->handle_irq == &handle_bad_irq)
510 desc->handle_irq = NULL;
513 int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
517 struct irq_chip *chip = desc->irq_data.chip;
519 if (!chip || !chip->irq_set_type) {
521 * IRQF_TRIGGER_* but the PIC does not support multiple
524 pr_debug("No set_type function for IRQ %d (%s)\n", irq,
525 chip ? (chip->name ? : "unknown") : "unknown");
529 /* caller masked out all except trigger mode flags */
530 ret = chip->irq_set_type(&desc->irq_data, flags);
533 pr_err("setting trigger mode %lu for irq %u failed (%pF)\n",
534 flags, irq, chip->irq_set_type);
536 if (flags & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
538 /* note that IRQF_TRIGGER_MASK == IRQ_TYPE_SENSE_MASK */
539 desc->status &= ~(IRQ_LEVEL | IRQ_TYPE_SENSE_MASK);
540 desc->status |= flags;
542 if (chip != desc->irq_data.chip)
543 irq_chip_set_defaults(desc->irq_data.chip);
550 * Default primary interrupt handler for threaded interrupts. Is
551 * assigned as primary handler when request_threaded_irq is called
552 * with handler == NULL. Useful for oneshot interrupts.
554 static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
556 return IRQ_WAKE_THREAD;
560 * Primary handler for nested threaded interrupts. Should never be
563 static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
565 WARN(1, "Primary handler called for nested irq %d\n", irq);
569 static int irq_wait_for_interrupt(struct irqaction *action)
571 while (!kthread_should_stop()) {
572 set_current_state(TASK_INTERRUPTIBLE);
574 if (test_and_clear_bit(IRQTF_RUNTHREAD,
575 &action->thread_flags)) {
576 __set_current_state(TASK_RUNNING);
585 * Oneshot interrupts keep the irq line masked until the threaded
586 * handler finished. unmask if the interrupt has not been disabled and
589 static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
593 raw_spin_lock_irq(&desc->lock);
596 * Implausible though it may be we need to protect us against
597 * the following scenario:
599 * The thread is faster done than the hard interrupt handler
600 * on the other CPU. If we unmask the irq line then the
601 * interrupt can come in again and masks the line, leaves due
602 * to IRQ_INPROGRESS and the irq line is masked forever.
604 if (unlikely(desc->status & IRQ_INPROGRESS)) {
605 raw_spin_unlock_irq(&desc->lock);
606 chip_bus_sync_unlock(desc);
611 if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
612 desc->status &= ~IRQ_MASKED;
613 desc->irq_data.chip->irq_unmask(&desc->irq_data);
615 raw_spin_unlock_irq(&desc->lock);
616 chip_bus_sync_unlock(desc);
621 * Check whether we need to change the affinity of the interrupt thread.
624 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
628 if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
632 * In case we are out of memory we set IRQTF_AFFINITY again and
633 * try again next time
635 if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
636 set_bit(IRQTF_AFFINITY, &action->thread_flags);
640 raw_spin_lock_irq(&desc->lock);
641 cpumask_copy(mask, desc->irq_data.affinity);
642 raw_spin_unlock_irq(&desc->lock);
644 set_cpus_allowed_ptr(current, mask);
645 free_cpumask_var(mask);
649 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
653 * Interrupt handler thread
655 static int irq_thread(void *data)
657 static const struct sched_param param = {
658 .sched_priority = MAX_USER_RT_PRIO/2,
660 struct irqaction *action = data;
661 struct irq_desc *desc = irq_to_desc(action->irq);
662 int wake, oneshot = desc->status & IRQ_ONESHOT;
664 sched_setscheduler(current, SCHED_FIFO, ¶m);
665 current->irqaction = action;
667 while (!irq_wait_for_interrupt(action)) {
669 irq_thread_check_affinity(desc, action);
671 atomic_inc(&desc->threads_active);
673 raw_spin_lock_irq(&desc->lock);
674 if (unlikely(desc->status & IRQ_DISABLED)) {
676 * CHECKME: We might need a dedicated
677 * IRQ_THREAD_PENDING flag here, which
678 * retriggers the thread in check_irq_resend()
679 * but AFAICT IRQ_PENDING should be fine as it
680 * retriggers the interrupt itself --- tglx
682 desc->status |= IRQ_PENDING;
683 raw_spin_unlock_irq(&desc->lock);
685 raw_spin_unlock_irq(&desc->lock);
687 action->thread_fn(action->irq, action->dev_id);
690 irq_finalize_oneshot(action->irq, desc);
693 wake = atomic_dec_and_test(&desc->threads_active);
695 if (wake && waitqueue_active(&desc->wait_for_threads))
696 wake_up(&desc->wait_for_threads);
700 * Clear irqaction. Otherwise exit_irq_thread() would make
701 * fuzz about an active irq thread going into nirvana.
703 current->irqaction = NULL;
708 * Called from do_exit()
710 void exit_irq_thread(void)
712 struct task_struct *tsk = current;
718 "exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
719 tsk->comm ? tsk->comm : "", tsk->pid, tsk->irqaction->irq);
722 * Set the THREAD DIED flag to prevent further wakeups of the
723 * soon to be gone threaded handler.
725 set_bit(IRQTF_DIED, &tsk->irqaction->flags);
729 * Internal function to register an irqaction - typically used to
730 * allocate special interrupts that are part of the architecture.
733 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
735 struct irqaction *old, **old_ptr;
736 const char *old_name = NULL;
738 int nested, shared = 0;
744 if (desc->irq_data.chip == &no_irq_chip)
747 * Some drivers like serial.c use request_irq() heavily,
748 * so we have to be careful not to interfere with a
751 if (new->flags & IRQF_SAMPLE_RANDOM) {
753 * This function might sleep, we want to call it first,
754 * outside of the atomic block.
755 * Yes, this might clear the entropy pool if the wrong
756 * driver is attempted to be loaded, without actually
757 * installing a new handler, but is this really a problem,
758 * only the sysadmin is able to do this.
760 rand_initialize_irq(irq);
763 /* Oneshot interrupts are not allowed with shared */
764 if ((new->flags & IRQF_ONESHOT) && (new->flags & IRQF_SHARED))
768 * Check whether the interrupt nests into another interrupt
771 nested = desc->status & IRQ_NESTED_THREAD;
776 * Replace the primary handler which was provided from
777 * the driver for non nested interrupt handling by the
778 * dummy function which warns when called.
780 new->handler = irq_nested_primary_handler;
784 * Create a handler thread when a thread function is supplied
785 * and the interrupt does not nest into another interrupt
788 if (new->thread_fn && !nested) {
789 struct task_struct *t;
791 t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
796 * We keep the reference to the task struct even if
797 * the thread dies to avoid that the interrupt code
798 * references an already freed task_struct.
805 * The following block of code has to be executed atomically
807 raw_spin_lock_irqsave(&desc->lock, flags);
808 old_ptr = &desc->action;
812 * Can't share interrupts unless both agree to and are
813 * the same type (level, edge, polarity). So both flag
814 * fields must have IRQF_SHARED set and the bits which
815 * set the trigger type must match.
817 if (!((old->flags & new->flags) & IRQF_SHARED) ||
818 ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) {
819 old_name = old->name;
823 #if defined(CONFIG_IRQ_PER_CPU)
824 /* All handlers must agree on per-cpuness */
825 if ((old->flags & IRQF_PERCPU) !=
826 (new->flags & IRQF_PERCPU))
830 /* add new interrupt at end of irq queue */
832 old_ptr = &old->next;
839 irq_chip_set_defaults(desc->irq_data.chip);
841 init_waitqueue_head(&desc->wait_for_threads);
843 /* Setup the type (level, edge polarity) if configured: */
844 if (new->flags & IRQF_TRIGGER_MASK) {
845 ret = __irq_set_trigger(desc, irq,
846 new->flags & IRQF_TRIGGER_MASK);
851 compat_irq_chip_set_default_handler(desc);
852 #if defined(CONFIG_IRQ_PER_CPU)
853 if (new->flags & IRQF_PERCPU)
854 desc->status |= IRQ_PER_CPU;
857 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | IRQ_ONESHOT |
858 IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
860 if (new->flags & IRQF_ONESHOT)
861 desc->status |= IRQ_ONESHOT;
863 if (!(desc->status & IRQ_NOAUTOEN)) {
865 desc->status &= ~IRQ_DISABLED;
866 desc->irq_data.chip->irq_startup(&desc->irq_data);
868 /* Undo nested disables: */
871 /* Exclude IRQ from balancing if requested */
872 if (new->flags & IRQF_NOBALANCING)
873 desc->status |= IRQ_NO_BALANCING;
875 /* Set default affinity mask once everything is setup */
876 setup_affinity(irq, desc);
878 } else if ((new->flags & IRQF_TRIGGER_MASK)
879 && (new->flags & IRQF_TRIGGER_MASK)
880 != (desc->status & IRQ_TYPE_SENSE_MASK)) {
881 /* hope the handler works with the actual trigger mode... */
882 pr_warning("IRQ %d uses trigger mode %d; requested %d\n",
883 irq, (int)(desc->status & IRQ_TYPE_SENSE_MASK),
884 (int)(new->flags & IRQF_TRIGGER_MASK));
890 /* Reset broken irq detection when installing new handler */
892 desc->irqs_unhandled = 0;
895 * Check whether we disabled the irq via the spurious handler
896 * before. Reenable it and give it another chance.
898 if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
899 desc->status &= ~IRQ_SPURIOUS_DISABLED;
900 __enable_irq(desc, irq, false);
903 raw_spin_unlock_irqrestore(&desc->lock, flags);
906 * Strictly no need to wake it up, but hung_task complains
907 * when no hard interrupt wakes the thread up.
910 wake_up_process(new->thread);
912 register_irq_proc(irq, desc);
914 register_handler_proc(irq, new);
919 #ifdef CONFIG_DEBUG_SHIRQ
920 if (!(new->flags & IRQF_PROBE_SHARED)) {
921 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
923 printk(KERN_ERR "current handler: %s\n", old_name);
930 raw_spin_unlock_irqrestore(&desc->lock, flags);
932 struct task_struct *t = new->thread;
935 if (likely(!test_bit(IRQTF_DIED, &new->thread_flags)))
943 * setup_irq - setup an interrupt
944 * @irq: Interrupt line to setup
945 * @act: irqaction for the interrupt
947 * Used to statically setup interrupts in the early boot process.
949 int setup_irq(unsigned int irq, struct irqaction *act)
951 struct irq_desc *desc = irq_to_desc(irq);
953 return __setup_irq(irq, desc, act);
955 EXPORT_SYMBOL_GPL(setup_irq);
958 * Internal function to unregister an irqaction - used to free
959 * regular and special interrupts that are part of the architecture.
961 static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
963 struct irq_desc *desc = irq_to_desc(irq);
964 struct irqaction *action, **action_ptr;
967 WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
972 raw_spin_lock_irqsave(&desc->lock, flags);
975 * There can be multiple actions per IRQ descriptor, find the right
976 * one based on the dev_id:
978 action_ptr = &desc->action;
980 action = *action_ptr;
983 WARN(1, "Trying to free already-free IRQ %d\n", irq);
984 raw_spin_unlock_irqrestore(&desc->lock, flags);
989 if (action->dev_id == dev_id)
991 action_ptr = &action->next;
994 /* Found it - now remove it from the list of entries: */
995 *action_ptr = action->next;
997 /* Currently used only by UML, might disappear one day: */
998 #ifdef CONFIG_IRQ_RELEASE_METHOD
999 if (desc->irq_data.chip->release)
1000 desc->irq_data.chip->release(irq, dev_id);
1003 /* If this was the last handler, shut down the IRQ line: */
1004 if (!desc->action) {
1005 desc->status |= IRQ_DISABLED;
1006 if (desc->irq_data.chip->irq_shutdown)
1007 desc->irq_data.chip->irq_shutdown(&desc->irq_data);
1009 desc->irq_data.chip->irq_disable(&desc->irq_data);
1013 /* make sure affinity_hint is cleaned up */
1014 if (WARN_ON_ONCE(desc->affinity_hint))
1015 desc->affinity_hint = NULL;
1018 raw_spin_unlock_irqrestore(&desc->lock, flags);
1020 unregister_handler_proc(irq, action);
1022 /* Make sure it's not being used on another CPU: */
1023 synchronize_irq(irq);
1025 #ifdef CONFIG_DEBUG_SHIRQ
1027 * It's a shared IRQ -- the driver ought to be prepared for an IRQ
1028 * event to happen even now it's being freed, so let's make sure that
1029 * is so by doing an extra call to the handler ....
1031 * ( We do this after actually deregistering it, to make sure that a
1032 * 'real' IRQ doesn't run in * parallel with our fake. )
1034 if (action->flags & IRQF_SHARED) {
1035 local_irq_save(flags);
1036 action->handler(irq, dev_id);
1037 local_irq_restore(flags);
1041 if (action->thread) {
1042 if (!test_bit(IRQTF_DIED, &action->thread_flags))
1043 kthread_stop(action->thread);
1044 put_task_struct(action->thread);
1051 * remove_irq - free an interrupt
1052 * @irq: Interrupt line to free
1053 * @act: irqaction for the interrupt
1055 * Used to remove interrupts statically setup by the early boot process.
1057 void remove_irq(unsigned int irq, struct irqaction *act)
1059 __free_irq(irq, act->dev_id);
1061 EXPORT_SYMBOL_GPL(remove_irq);
1064 * free_irq - free an interrupt allocated with request_irq
1065 * @irq: Interrupt line to free
1066 * @dev_id: Device identity to free
1068 * Remove an interrupt handler. The handler is removed and if the
1069 * interrupt line is no longer in use by any driver it is disabled.
1070 * On a shared IRQ the caller must ensure the interrupt is disabled
1071 * on the card it drives before calling this function. The function
1072 * does not return until any executing interrupts for this IRQ
1075 * This function must not be called from interrupt context.
1077 void free_irq(unsigned int irq, void *dev_id)
1079 struct irq_desc *desc = irq_to_desc(irq);
1085 if (WARN_ON(desc->affinity_notify))
1086 desc->affinity_notify = NULL;
1089 chip_bus_lock(desc);
1090 kfree(__free_irq(irq, dev_id));
1091 chip_bus_sync_unlock(desc);
1093 EXPORT_SYMBOL(free_irq);
1096 * request_threaded_irq - allocate an interrupt line
1097 * @irq: Interrupt line to allocate
1098 * @handler: Function to be called when the IRQ occurs.
1099 * Primary handler for threaded interrupts
1100 * If NULL and thread_fn != NULL the default
1101 * primary handler is installed
1102 * @thread_fn: Function called from the irq handler thread
1103 * If NULL, no irq thread is created
1104 * @irqflags: Interrupt type flags
1105 * @devname: An ascii name for the claiming device
1106 * @dev_id: A cookie passed back to the handler function
1108 * This call allocates interrupt resources and enables the
1109 * interrupt line and IRQ handling. From the point this
1110 * call is made your handler function may be invoked. Since
1111 * your handler function must clear any interrupt the board
1112 * raises, you must take care both to initialise your hardware
1113 * and to set up the interrupt handler in the right order.
1115 * If you want to set up a threaded irq handler for your device
1116 * then you need to supply @handler and @thread_fn. @handler ist
1117 * still called in hard interrupt context and has to check
1118 * whether the interrupt originates from the device. If yes it
1119 * needs to disable the interrupt on the device and return
1120 * IRQ_WAKE_THREAD which will wake up the handler thread and run
1121 * @thread_fn. This split handler design is necessary to support
1122 * shared interrupts.
1124 * Dev_id must be globally unique. Normally the address of the
1125 * device data structure is used as the cookie. Since the handler
1126 * receives this value it makes sense to use it.
1128 * If your interrupt is shared you must pass a non NULL dev_id
1129 * as this is required when freeing the interrupt.
1133 * IRQF_SHARED Interrupt is shared
1134 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
1135 * IRQF_TRIGGER_* Specify active edge(s) or level
1138 int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1139 irq_handler_t thread_fn, unsigned long irqflags,
1140 const char *devname, void *dev_id)
1142 struct irqaction *action;
1143 struct irq_desc *desc;
1147 * Sanity-check: shared interrupts must pass in a real dev-ID,
1148 * otherwise we'll have trouble later trying to figure out
1149 * which interrupt is which (messes up the interrupt freeing
1152 if ((irqflags & IRQF_SHARED) && !dev_id)
1155 desc = irq_to_desc(irq);
1159 if (desc->status & IRQ_NOREQUEST)
1165 handler = irq_default_primary_handler;
1168 action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1172 action->handler = handler;
1173 action->thread_fn = thread_fn;
1174 action->flags = irqflags;
1175 action->name = devname;
1176 action->dev_id = dev_id;
1178 chip_bus_lock(desc);
1179 retval = __setup_irq(irq, desc, action);
1180 chip_bus_sync_unlock(desc);
1185 #ifdef CONFIG_DEBUG_SHIRQ_FIXME
1186 if (!retval && (irqflags & IRQF_SHARED)) {
1188 * It's a shared IRQ -- the driver ought to be prepared for it
1189 * to happen immediately, so let's make sure....
1190 * We disable the irq to make sure that a 'real' IRQ doesn't
1191 * run in parallel with our fake.
1193 unsigned long flags;
1196 local_irq_save(flags);
1198 handler(irq, dev_id);
1200 local_irq_restore(flags);
1206 EXPORT_SYMBOL(request_threaded_irq);
1209 * request_any_context_irq - allocate an interrupt line
1210 * @irq: Interrupt line to allocate
1211 * @handler: Function to be called when the IRQ occurs.
1212 * Threaded handler for threaded interrupts.
1213 * @flags: Interrupt type flags
1214 * @name: An ascii name for the claiming device
1215 * @dev_id: A cookie passed back to the handler function
1217 * This call allocates interrupt resources and enables the
1218 * interrupt line and IRQ handling. It selects either a
1219 * hardirq or threaded handling method depending on the
1222 * On failure, it returns a negative value. On success,
1223 * it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
1225 int request_any_context_irq(unsigned int irq, irq_handler_t handler,
1226 unsigned long flags, const char *name, void *dev_id)
1228 struct irq_desc *desc = irq_to_desc(irq);
1234 if (desc->status & IRQ_NESTED_THREAD) {
1235 ret = request_threaded_irq(irq, NULL, handler,
1236 flags, name, dev_id);
1237 return !ret ? IRQC_IS_NESTED : ret;
1240 ret = request_irq(irq, handler, flags, name, dev_id);
1241 return !ret ? IRQC_IS_HARDIRQ : ret;
1243 EXPORT_SYMBOL_GPL(request_any_context_irq);