Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19

Linux/kernel/irq/manage.c

  1 /*
  2  * linux/kernel/irq/manage.c
  3  *
  4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
  5  * Copyright (C) 2005-2006 Thomas Gleixner
  6  *
  7  * This file contains driver APIs to the irq subsystem.
  8  */
  9 
 10 #define pr_fmt(fmt) "genirq: " fmt
 11 
 12 #include <linux/irq.h>
 13 #include <linux/kthread.h>
 14 #include <linux/module.h>
 15 #include <linux/random.h>
 16 #include <linux/interrupt.h>
 17 #include <linux/slab.h>
 18 #include <linux/sched.h>
 19 #include <linux/sched/rt.h>
 20 #include <linux/task_work.h>
 21 
 22 #include "internals.h"
 23 
 24 #ifdef CONFIG_IRQ_FORCED_THREADING
 25 __read_mostly bool force_irqthreads;
 26 
 27 static int __init setup_forced_irqthreads(char *arg)
 28 {
 29         force_irqthreads = true;
 30         return 0;
 31 }
 32 early_param("threadirqs", setup_forced_irqthreads);
 33 #endif
 34 
 35 static void __synchronize_hardirq(struct irq_desc *desc)
 36 {
 37         bool inprogress;
 38 
 39         do {
 40                 unsigned long flags;
 41 
 42                 /*
 43                  * Wait until we're out of the critical section.  This might
 44                  * give the wrong answer due to the lack of memory barriers.
 45                  */
 46                 while (irqd_irq_inprogress(&desc->irq_data))
 47                         cpu_relax();
 48 
 49                 /* Ok, that indicated we're done: double-check carefully. */
 50                 raw_spin_lock_irqsave(&desc->lock, flags);
 51                 inprogress = irqd_irq_inprogress(&desc->irq_data);
 52                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 53 
 54                 /* Oops, that failed? */
 55         } while (inprogress);
 56 }
 57 
 58 /**
 59  *      synchronize_hardirq - wait for pending hard IRQ handlers (on other CPUs)
 60  *      @irq: interrupt number to wait for
 61  *
 62  *      This function waits for any pending hard IRQ handlers for this
 63  *      interrupt to complete before returning. If you use this
 64  *      function while holding a resource the IRQ handler may need you
 65  *      will deadlock. It does not take associated threaded handlers
 66  *      into account.
 67  *
 68  *      Do not use this for shutdown scenarios where you must be sure
 69  *      that all parts (hardirq and threaded handler) have completed.
 70  *
 71  *      This function may be called - with care - from IRQ context.
 72  */
 73 void synchronize_hardirq(unsigned int irq)
 74 {
 75         struct irq_desc *desc = irq_to_desc(irq);
 76 
 77         if (desc)
 78                 __synchronize_hardirq(desc);
 79 }
 80 EXPORT_SYMBOL(synchronize_hardirq);
 81 
 82 /**
 83  *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
 84  *      @irq: interrupt number to wait for
 85  *
 86  *      This function waits for any pending IRQ handlers for this interrupt
 87  *      to complete before returning. If you use this function while
 88  *      holding a resource the IRQ handler may need you will deadlock.
 89  *
 90  *      This function may be called - with care - from IRQ context.
 91  */
 92 void synchronize_irq(unsigned int irq)
 93 {
 94         struct irq_desc *desc = irq_to_desc(irq);
 95 
 96         if (desc) {
 97                 __synchronize_hardirq(desc);
 98                 /*
 99                  * We made sure that no hardirq handler is
100                  * running. Now verify that no threaded handlers are
101                  * active.
102                  */
103                 wait_event(desc->wait_for_threads,
104                            !atomic_read(&desc->threads_active));
105         }
106 }
107 EXPORT_SYMBOL(synchronize_irq);
108 
109 #ifdef CONFIG_SMP
110 cpumask_var_t irq_default_affinity;
111 
112 /**
113  *      irq_can_set_affinity - Check if the affinity of a given irq can be set
114  *      @irq:           Interrupt to check
115  *
116  */
117 int irq_can_set_affinity(unsigned int irq)
118 {
119         struct irq_desc *desc = irq_to_desc(irq);
120 
121         if (!desc || !irqd_can_balance(&desc->irq_data) ||
122             !desc->irq_data.chip || !desc->irq_data.chip->irq_set_affinity)
123                 return 0;
124 
125         return 1;
126 }
127 
128 /**
129  *      irq_set_thread_affinity - Notify irq threads to adjust affinity
130  *      @desc:          irq descriptor which has affitnity changed
131  *
132  *      We just set IRQTF_AFFINITY and delegate the affinity setting
133  *      to the interrupt thread itself. We can not call
134  *      set_cpus_allowed_ptr() here as we hold desc->lock and this
135  *      code can be called from hard interrupt context.
136  */
137 void irq_set_thread_affinity(struct irq_desc *desc)
138 {
139         struct irqaction *action = desc->action;
140 
141         while (action) {
142                 if (action->thread)
143                         set_bit(IRQTF_AFFINITY, &action->thread_flags);
144                 action = action->next;
145         }
146 }
147 
148 #ifdef CONFIG_GENERIC_PENDING_IRQ
149 static inline bool irq_can_move_pcntxt(struct irq_data *data)
150 {
151         return irqd_can_move_in_process_context(data);
152 }
153 static inline bool irq_move_pending(struct irq_data *data)
154 {
155         return irqd_is_setaffinity_pending(data);
156 }
157 static inline void
158 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
159 {
160         cpumask_copy(desc->pending_mask, mask);
161 }
162 static inline void
163 irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
164 {
165         cpumask_copy(mask, desc->pending_mask);
166 }
167 #else
168 static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
169 static inline bool irq_move_pending(struct irq_data *data) { return false; }
170 static inline void
171 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
172 static inline void
173 irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
174 #endif
175 
176 int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask,
177                         bool force)
178 {
179         struct irq_desc *desc = irq_data_to_desc(data);
180         struct irq_chip *chip = irq_data_get_irq_chip(data);
181         int ret;
182 
183         ret = chip->irq_set_affinity(data, mask, force);
184         switch (ret) {
185         case IRQ_SET_MASK_OK:
186         case IRQ_SET_MASK_OK_DONE:
187                 cpumask_copy(data->affinity, mask);
188         case IRQ_SET_MASK_OK_NOCOPY:
189                 irq_set_thread_affinity(desc);
190                 ret = 0;
191         }
192 
193         return ret;
194 }
195 
196 int irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask,
197                             bool force)
198 {
199         struct irq_chip *chip = irq_data_get_irq_chip(data);
200         struct irq_desc *desc = irq_data_to_desc(data);
201         int ret = 0;
202 
203         if (!chip || !chip->irq_set_affinity)
204                 return -EINVAL;
205 
206         if (irq_can_move_pcntxt(data)) {
207                 ret = irq_do_set_affinity(data, mask, force);
208         } else {
209                 irqd_set_move_pending(data);
210                 irq_copy_pending(desc, mask);
211         }
212 
213         if (desc->affinity_notify) {
214                 kref_get(&desc->affinity_notify->kref);
215                 schedule_work(&desc->affinity_notify->work);
216         }
217         irqd_set(data, IRQD_AFFINITY_SET);
218 
219         return ret;
220 }
221 
222 int __irq_set_affinity(unsigned int irq, const struct cpumask *mask, bool force)
223 {
224         struct irq_desc *desc = irq_to_desc(irq);
225         unsigned long flags;
226         int ret;
227 
228         if (!desc)
229                 return -EINVAL;
230 
231         raw_spin_lock_irqsave(&desc->lock, flags);
232         ret = irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask, force);
233         raw_spin_unlock_irqrestore(&desc->lock, flags);
234         return ret;
235 }
236 
237 int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
238 {
239         unsigned long flags;
240         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
241 
242         if (!desc)
243                 return -EINVAL;
244         desc->affinity_hint = m;
245         irq_put_desc_unlock(desc, flags);
246         return 0;
247 }
248 EXPORT_SYMBOL_GPL(irq_set_affinity_hint);
249 
250 static void irq_affinity_notify(struct work_struct *work)
251 {
252         struct irq_affinity_notify *notify =
253                 container_of(work, struct irq_affinity_notify, work);
254         struct irq_desc *desc = irq_to_desc(notify->irq);
255         cpumask_var_t cpumask;
256         unsigned long flags;
257 
258         if (!desc || !alloc_cpumask_var(&cpumask, GFP_KERNEL))
259                 goto out;
260 
261         raw_spin_lock_irqsave(&desc->lock, flags);
262         if (irq_move_pending(&desc->irq_data))
263                 irq_get_pending(cpumask, desc);
264         else
265                 cpumask_copy(cpumask, desc->irq_data.affinity);
266         raw_spin_unlock_irqrestore(&desc->lock, flags);
267 
268         notify->notify(notify, cpumask);
269 
270         free_cpumask_var(cpumask);
271 out:
272         kref_put(&notify->kref, notify->release);
273 }
274 
275 /**
276  *      irq_set_affinity_notifier - control notification of IRQ affinity changes
277  *      @irq:           Interrupt for which to enable/disable notification
278  *      @notify:        Context for notification, or %NULL to disable
279  *                      notification.  Function pointers must be initialised;
280  *                      the other fields will be initialised by this function.
281  *
282  *      Must be called in process context.  Notification may only be enabled
283  *      after the IRQ is allocated and must be disabled before the IRQ is
284  *      freed using free_irq().
285  */
286 int
287 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
288 {
289         struct irq_desc *desc = irq_to_desc(irq);
290         struct irq_affinity_notify *old_notify;
291         unsigned long flags;
292 
293         /* The release function is promised process context */
294         might_sleep();
295 
296         if (!desc)
297                 return -EINVAL;
298 
299         /* Complete initialisation of *notify */
300         if (notify) {
301                 notify->irq = irq;
302                 kref_init(&notify->kref);
303                 INIT_WORK(&notify->work, irq_affinity_notify);
304         }
305 
306         raw_spin_lock_irqsave(&desc->lock, flags);
307         old_notify = desc->affinity_notify;
308         desc->affinity_notify = notify;
309         raw_spin_unlock_irqrestore(&desc->lock, flags);
310 
311         if (old_notify)
312                 kref_put(&old_notify->kref, old_notify->release);
313 
314         return 0;
315 }
316 EXPORT_SYMBOL_GPL(irq_set_affinity_notifier);
317 
318 #ifndef CONFIG_AUTO_IRQ_AFFINITY
319 /*
320  * Generic version of the affinity autoselector.
321  */
322 static int
323 setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
324 {
325         struct cpumask *set = irq_default_affinity;
326         int node = desc->irq_data.node;
327 
328         /* Excludes PER_CPU and NO_BALANCE interrupts */
329         if (!irq_can_set_affinity(irq))
330                 return 0;
331 
332         /*
333          * Preserve an userspace affinity setup, but make sure that
334          * one of the targets is online.
335          */
336         if (irqd_has_set(&desc->irq_data, IRQD_AFFINITY_SET)) {
337                 if (cpumask_intersects(desc->irq_data.affinity,
338                                        cpu_online_mask))
339                         set = desc->irq_data.affinity;
340                 else
341                         irqd_clear(&desc->irq_data, IRQD_AFFINITY_SET);
342         }
343 
344         cpumask_and(mask, cpu_online_mask, set);
345         if (node != NUMA_NO_NODE) {
346                 const struct cpumask *nodemask = cpumask_of_node(node);
347 
348                 /* make sure at least one of the cpus in nodemask is online */
349                 if (cpumask_intersects(mask, nodemask))
350                         cpumask_and(mask, mask, nodemask);
351         }
352         irq_do_set_affinity(&desc->irq_data, mask, false);
353         return 0;
354 }
355 #else
356 static inline int
357 setup_affinity(unsigned int irq, struct irq_desc *d, struct cpumask *mask)
358 {
359         return irq_select_affinity(irq);
360 }
361 #endif
362 
363 /*
364  * Called when affinity is set via /proc/irq
365  */
366 int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask)
367 {
368         struct irq_desc *desc = irq_to_desc(irq);
369         unsigned long flags;
370         int ret;
371 
372         raw_spin_lock_irqsave(&desc->lock, flags);
373         ret = setup_affinity(irq, desc, mask);
374         raw_spin_unlock_irqrestore(&desc->lock, flags);
375         return ret;
376 }
377 
378 #else
379 static inline int
380 setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
381 {
382         return 0;
383 }
384 #endif
385 
386 void __disable_irq(struct irq_desc *desc, unsigned int irq)
387 {
388         if (!desc->depth++)
389                 irq_disable(desc);
390 }
391 
392 static int __disable_irq_nosync(unsigned int irq)
393 {
394         unsigned long flags;
395         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
396 
397         if (!desc)
398                 return -EINVAL;
399         __disable_irq(desc, irq);
400         irq_put_desc_busunlock(desc, flags);
401         return 0;
402 }
403 
404 /**
405  *      disable_irq_nosync - disable an irq without waiting
406  *      @irq: Interrupt to disable
407  *
408  *      Disable the selected interrupt line.  Disables and Enables are
409  *      nested.
410  *      Unlike disable_irq(), this function does not ensure existing
411  *      instances of the IRQ handler have completed before returning.
412  *
413  *      This function may be called from IRQ context.
414  */
415 void disable_irq_nosync(unsigned int irq)
416 {
417         __disable_irq_nosync(irq);
418 }
419 EXPORT_SYMBOL(disable_irq_nosync);
420 
421 /**
422  *      disable_irq - disable an irq and wait for completion
423  *      @irq: Interrupt to disable
424  *
425  *      Disable the selected interrupt line.  Enables and Disables are
426  *      nested.
427  *      This function waits for any pending IRQ handlers for this interrupt
428  *      to complete before returning. If you use this function while
429  *      holding a resource the IRQ handler may need you will deadlock.
430  *
431  *      This function may be called - with care - from IRQ context.
432  */
433 void disable_irq(unsigned int irq)
434 {
435         if (!__disable_irq_nosync(irq))
436                 synchronize_irq(irq);
437 }
438 EXPORT_SYMBOL(disable_irq);
439 
440 void __enable_irq(struct irq_desc *desc, unsigned int irq)
441 {
442         switch (desc->depth) {
443         case 0:
444  err_out:
445                 WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
446                 break;
447         case 1: {
448                 if (desc->istate & IRQS_SUSPENDED)
449                         goto err_out;
450                 /* Prevent probing on this irq: */
451                 irq_settings_set_noprobe(desc);
452                 irq_enable(desc);
453                 check_irq_resend(desc, irq);
454                 /* fall-through */
455         }
456         default:
457                 desc->depth--;
458         }
459 }
460 
461 /**
462  *      enable_irq - enable handling of an irq
463  *      @irq: Interrupt to enable
464  *
465  *      Undoes the effect of one call to disable_irq().  If this
466  *      matches the last disable, processing of interrupts on this
467  *      IRQ line is re-enabled.
468  *
469  *      This function may be called from IRQ context only when
470  *      desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
471  */
472 void enable_irq(unsigned int irq)
473 {
474         unsigned long flags;
475         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
476 
477         if (!desc)
478                 return;
479         if (WARN(!desc->irq_data.chip,
480                  KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq))
481                 goto out;
482 
483         __enable_irq(desc, irq);
484 out:
485         irq_put_desc_busunlock(desc, flags);
486 }
487 EXPORT_SYMBOL(enable_irq);
488 
489 static int set_irq_wake_real(unsigned int irq, unsigned int on)
490 {
491         struct irq_desc *desc = irq_to_desc(irq);
492         int ret = -ENXIO;
493 
494         if (irq_desc_get_chip(desc)->flags &  IRQCHIP_SKIP_SET_WAKE)
495                 return 0;
496 
497         if (desc->irq_data.chip->irq_set_wake)
498                 ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on);
499 
500         return ret;
501 }
502 
503 /**
504  *      irq_set_irq_wake - control irq power management wakeup
505  *      @irq:   interrupt to control
506  *      @on:    enable/disable power management wakeup
507  *
508  *      Enable/disable power management wakeup mode, which is
509  *      disabled by default.  Enables and disables must match,
510  *      just as they match for non-wakeup mode support.
511  *
512  *      Wakeup mode lets this IRQ wake the system from sleep
513  *      states like "suspend to RAM".
514  */
515 int irq_set_irq_wake(unsigned int irq, unsigned int on)
516 {
517         unsigned long flags;
518         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
519         int ret = 0;
520 
521         if (!desc)
522                 return -EINVAL;
523 
524         /* wakeup-capable irqs can be shared between drivers that
525          * don't need to have the same sleep mode behaviors.
526          */
527         if (on) {
528                 if (desc->wake_depth++ == 0) {
529                         ret = set_irq_wake_real(irq, on);
530                         if (ret)
531                                 desc->wake_depth = 0;
532                         else
533                                 irqd_set(&desc->irq_data, IRQD_WAKEUP_STATE);
534                 }
535         } else {
536                 if (desc->wake_depth == 0) {
537                         WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
538                 } else if (--desc->wake_depth == 0) {
539                         ret = set_irq_wake_real(irq, on);
540                         if (ret)
541                                 desc->wake_depth = 1;
542                         else
543                                 irqd_clear(&desc->irq_data, IRQD_WAKEUP_STATE);
544                 }
545         }
546         irq_put_desc_busunlock(desc, flags);
547         return ret;
548 }
549 EXPORT_SYMBOL(irq_set_irq_wake);
550 
551 /*
552  * Internal function that tells the architecture code whether a
553  * particular irq has been exclusively allocated or is available
554  * for driver use.
555  */
556 int can_request_irq(unsigned int irq, unsigned long irqflags)
557 {
558         unsigned long flags;
559         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
560         int canrequest = 0;
561 
562         if (!desc)
563                 return 0;
564 
565         if (irq_settings_can_request(desc)) {
566                 if (!desc->action ||
567                     irqflags & desc->action->flags & IRQF_SHARED)
568                         canrequest = 1;
569         }
570         irq_put_desc_unlock(desc, flags);
571         return canrequest;
572 }
573 
574 int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
575                       unsigned long flags)
576 {
577         struct irq_chip *chip = desc->irq_data.chip;
578         int ret, unmask = 0;
579 
580         if (!chip || !chip->irq_set_type) {
581                 /*
582                  * IRQF_TRIGGER_* but the PIC does not support multiple
583                  * flow-types?
584                  */
585                 pr_debug("No set_type function for IRQ %d (%s)\n", irq,
586                          chip ? (chip->name ? : "unknown") : "unknown");
587                 return 0;
588         }
589 
590         flags &= IRQ_TYPE_SENSE_MASK;
591 
592         if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
593                 if (!irqd_irq_masked(&desc->irq_data))
594                         mask_irq(desc);
595                 if (!irqd_irq_disabled(&desc->irq_data))
596                         unmask = 1;
597         }
598 
599         /* caller masked out all except trigger mode flags */
600         ret = chip->irq_set_type(&desc->irq_data, flags);
601 
602         switch (ret) {
603         case IRQ_SET_MASK_OK:
604         case IRQ_SET_MASK_OK_DONE:
605                 irqd_clear(&desc->irq_data, IRQD_TRIGGER_MASK);
606                 irqd_set(&desc->irq_data, flags);
607 
608         case IRQ_SET_MASK_OK_NOCOPY:
609                 flags = irqd_get_trigger_type(&desc->irq_data);
610                 irq_settings_set_trigger_mask(desc, flags);
611                 irqd_clear(&desc->irq_data, IRQD_LEVEL);
612                 irq_settings_clr_level(desc);
613                 if (flags & IRQ_TYPE_LEVEL_MASK) {
614                         irq_settings_set_level(desc);
615                         irqd_set(&desc->irq_data, IRQD_LEVEL);
616                 }
617 
618                 ret = 0;
619                 break;
620         default:
621                 pr_err("Setting trigger mode %lu for irq %u failed (%pF)\n",
622                        flags, irq, chip->irq_set_type);
623         }
624         if (unmask)
625                 unmask_irq(desc);
626         return ret;
627 }
628 
629 #ifdef CONFIG_HARDIRQS_SW_RESEND
630 int irq_set_parent(int irq, int parent_irq)
631 {
632         unsigned long flags;
633         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
634 
635         if (!desc)
636                 return -EINVAL;
637 
638         desc->parent_irq = parent_irq;
639 
640         irq_put_desc_unlock(desc, flags);
641         return 0;
642 }
643 #endif
644 
645 /*
646  * Default primary interrupt handler for threaded interrupts. Is
647  * assigned as primary handler when request_threaded_irq is called
648  * with handler == NULL. Useful for oneshot interrupts.
649  */
650 static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
651 {
652         return IRQ_WAKE_THREAD;
653 }
654 
655 /*
656  * Primary handler for nested threaded interrupts. Should never be
657  * called.
658  */
659 static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
660 {
661         WARN(1, "Primary handler called for nested irq %d\n", irq);
662         return IRQ_NONE;
663 }
664 
665 static int irq_wait_for_interrupt(struct irqaction *action)
666 {
667         set_current_state(TASK_INTERRUPTIBLE);
668 
669         while (!kthread_should_stop()) {
670 
671                 if (test_and_clear_bit(IRQTF_RUNTHREAD,
672                                        &action->thread_flags)) {
673                         __set_current_state(TASK_RUNNING);
674                         return 0;
675                 }
676                 schedule();
677                 set_current_state(TASK_INTERRUPTIBLE);
678         }
679         __set_current_state(TASK_RUNNING);
680         return -1;
681 }
682 
683 /*
684  * Oneshot interrupts keep the irq line masked until the threaded
685  * handler finished. unmask if the interrupt has not been disabled and
686  * is marked MASKED.
687  */
688 static void irq_finalize_oneshot(struct irq_desc *desc,
689                                  struct irqaction *action)
690 {
691         if (!(desc->istate & IRQS_ONESHOT))
692                 return;
693 again:
694         chip_bus_lock(desc);
695         raw_spin_lock_irq(&desc->lock);
696 
697         /*
698          * Implausible though it may be we need to protect us against
699          * the following scenario:
700          *
701          * The thread is faster done than the hard interrupt handler
702          * on the other CPU. If we unmask the irq line then the
703          * interrupt can come in again and masks the line, leaves due
704          * to IRQS_INPROGRESS and the irq line is masked forever.
705          *
706          * This also serializes the state of shared oneshot handlers
707          * versus "desc->threads_onehsot |= action->thread_mask;" in
708          * irq_wake_thread(). See the comment there which explains the
709          * serialization.
710          */
711         if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
712                 raw_spin_unlock_irq(&desc->lock);
713                 chip_bus_sync_unlock(desc);
714                 cpu_relax();
715                 goto again;
716         }
717 
718         /*
719          * Now check again, whether the thread should run. Otherwise
720          * we would clear the threads_oneshot bit of this thread which
721          * was just set.
722          */
723         if (test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
724                 goto out_unlock;
725 
726         desc->threads_oneshot &= ~action->thread_mask;
727 
728         if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
729             irqd_irq_masked(&desc->irq_data))
730                 unmask_threaded_irq(desc);
731 
732 out_unlock:
733         raw_spin_unlock_irq(&desc->lock);
734         chip_bus_sync_unlock(desc);
735 }
736 
737 #ifdef CONFIG_SMP
738 /*
739  * Check whether we need to change the affinity of the interrupt thread.
740  */
741 static void
742 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
743 {
744         cpumask_var_t mask;
745         bool valid = true;
746 
747         if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
748                 return;
749 
750         /*
751          * In case we are out of memory we set IRQTF_AFFINITY again and
752          * try again next time
753          */
754         if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
755                 set_bit(IRQTF_AFFINITY, &action->thread_flags);
756                 return;
757         }
758 
759         raw_spin_lock_irq(&desc->lock);
760         /*
761          * This code is triggered unconditionally. Check the affinity
762          * mask pointer. For CPU_MASK_OFFSTACK=n this is optimized out.
763          */
764         if (desc->irq_data.affinity)
765                 cpumask_copy(mask, desc->irq_data.affinity);
766         else
767                 valid = false;
768         raw_spin_unlock_irq(&desc->lock);
769 
770         if (valid)
771                 set_cpus_allowed_ptr(current, mask);
772         free_cpumask_var(mask);
773 }
774 #else
775 static inline void
776 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
777 #endif
778 
779 /*
780  * Interrupts which are not explicitely requested as threaded
781  * interrupts rely on the implicit bh/preempt disable of the hard irq
782  * context. So we need to disable bh here to avoid deadlocks and other
783  * side effects.
784  */
785 static irqreturn_t
786 irq_forced_thread_fn(struct irq_desc *desc, struct irqaction *action)
787 {
788         irqreturn_t ret;
789 
790         local_bh_disable();
791         ret = action->thread_fn(action->irq, action->dev_id);
792         irq_finalize_oneshot(desc, action);
793         local_bh_enable();
794         return ret;
795 }
796 
797 /*
798  * Interrupts explicitly requested as threaded interrupts want to be
799  * preemtible - many of them need to sleep and wait for slow busses to
800  * complete.
801  */
802 static irqreturn_t irq_thread_fn(struct irq_desc *desc,
803                 struct irqaction *action)
804 {
805         irqreturn_t ret;
806 
807         ret = action->thread_fn(action->irq, action->dev_id);
808         irq_finalize_oneshot(desc, action);
809         return ret;
810 }
811 
812 static void wake_threads_waitq(struct irq_desc *desc)
813 {
814         if (atomic_dec_and_test(&desc->threads_active))
815                 wake_up(&desc->wait_for_threads);
816 }
817 
818 static void irq_thread_dtor(struct callback_head *unused)
819 {
820         struct task_struct *tsk = current;
821         struct irq_desc *desc;
822         struct irqaction *action;
823 
824         if (WARN_ON_ONCE(!(current->flags & PF_EXITING)))
825                 return;
826 
827         action = kthread_data(tsk);
828 
829         pr_err("exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
830                tsk->comm, tsk->pid, action->irq);
831 
832 
833         desc = irq_to_desc(action->irq);
834         /*
835          * If IRQTF_RUNTHREAD is set, we need to decrement
836          * desc->threads_active and wake possible waiters.
837          */
838         if (test_and_clear_bit(IRQTF_RUNTHREAD, &action->thread_flags))
839                 wake_threads_waitq(desc);
840 
841         /* Prevent a stale desc->threads_oneshot */
842         irq_finalize_oneshot(desc, action);
843 }
844 
845 /*
846  * Interrupt handler thread
847  */
848 static int irq_thread(void *data)
849 {
850         struct callback_head on_exit_work;
851         struct irqaction *action = data;
852         struct irq_desc *desc = irq_to_desc(action->irq);
853         irqreturn_t (*handler_fn)(struct irq_desc *desc,
854                         struct irqaction *action);
855 
856         if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,
857                                         &action->thread_flags))
858                 handler_fn = irq_forced_thread_fn;
859         else
860                 handler_fn = irq_thread_fn;
861 
862         init_task_work(&on_exit_work, irq_thread_dtor);
863         task_work_add(current, &on_exit_work, false);
864 
865         irq_thread_check_affinity(desc, action);
866 
867         while (!irq_wait_for_interrupt(action)) {
868                 irqreturn_t action_ret;
869 
870                 irq_thread_check_affinity(desc, action);
871 
872                 action_ret = handler_fn(desc, action);
873                 if (action_ret == IRQ_HANDLED)
874                         atomic_inc(&desc->threads_handled);
875 
876                 wake_threads_waitq(desc);
877         }
878 
879         /*
880          * This is the regular exit path. __free_irq() is stopping the
881          * thread via kthread_stop() after calling
882          * synchronize_irq(). So neither IRQTF_RUNTHREAD nor the
883          * oneshot mask bit can be set. We cannot verify that as we
884          * cannot touch the oneshot mask at this point anymore as
885          * __setup_irq() might have given out currents thread_mask
886          * again.
887          */
888         task_work_cancel(current, irq_thread_dtor);
889         return 0;
890 }
891 
892 /**
893  *      irq_wake_thread - wake the irq thread for the action identified by dev_id
894  *      @irq:           Interrupt line
895  *      @dev_id:        Device identity for which the thread should be woken
896  *
897  */
898 void irq_wake_thread(unsigned int irq, void *dev_id)
899 {
900         struct irq_desc *desc = irq_to_desc(irq);
901         struct irqaction *action;
902         unsigned long flags;
903 
904         if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
905                 return;
906 
907         raw_spin_lock_irqsave(&desc->lock, flags);
908         for (action = desc->action; action; action = action->next) {
909                 if (action->dev_id == dev_id) {
910                         if (action->thread)
911                                 __irq_wake_thread(desc, action);
912                         break;
913                 }
914         }
915         raw_spin_unlock_irqrestore(&desc->lock, flags);
916 }
917 EXPORT_SYMBOL_GPL(irq_wake_thread);
918 
919 static void irq_setup_forced_threading(struct irqaction *new)
920 {
921         if (!force_irqthreads)
922                 return;
923         if (new->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT))
924                 return;
925 
926         new->flags |= IRQF_ONESHOT;
927 
928         if (!new->thread_fn) {
929                 set_bit(IRQTF_FORCED_THREAD, &new->thread_flags);
930                 new->thread_fn = new->handler;
931                 new->handler = irq_default_primary_handler;
932         }
933 }
934 
935 static int irq_request_resources(struct irq_desc *desc)
936 {
937         struct irq_data *d = &desc->irq_data;
938         struct irq_chip *c = d->chip;
939 
940         return c->irq_request_resources ? c->irq_request_resources(d) : 0;
941 }
942 
943 static void irq_release_resources(struct irq_desc *desc)
944 {
945         struct irq_data *d = &desc->irq_data;
946         struct irq_chip *c = d->chip;
947 
948         if (c->irq_release_resources)
949                 c->irq_release_resources(d);
950 }
951 
952 /*
953  * Internal function to register an irqaction - typically used to
954  * allocate special interrupts that are part of the architecture.
955  */
956 static int
957 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
958 {
959         struct irqaction *old, **old_ptr;
960         unsigned long flags, thread_mask = 0;
961         int ret, nested, shared = 0;
962         cpumask_var_t mask;
963 
964         if (!desc)
965                 return -EINVAL;
966 
967         if (desc->irq_data.chip == &no_irq_chip)
968                 return -ENOSYS;
969         if (!try_module_get(desc->owner))
970                 return -ENODEV;
971 
972         /*
973          * Check whether the interrupt nests into another interrupt
974          * thread.
975          */
976         nested = irq_settings_is_nested_thread(desc);
977         if (nested) {
978                 if (!new->thread_fn) {
979                         ret = -EINVAL;
980                         goto out_mput;
981                 }
982                 /*
983                  * Replace the primary handler which was provided from
984                  * the driver for non nested interrupt handling by the
985                  * dummy function which warns when called.
986                  */
987                 new->handler = irq_nested_primary_handler;
988         } else {
989                 if (irq_settings_can_thread(desc))
990                         irq_setup_forced_threading(new);
991         }
992 
993         /*
994          * Create a handler thread when a thread function is supplied
995          * and the interrupt does not nest into another interrupt
996          * thread.
997          */
998         if (new->thread_fn && !nested) {
999                 struct task_struct *t;
1000                 static const struct sched_param param = {
1001                         .sched_priority = MAX_USER_RT_PRIO/2,
1002                 };
1003 
1004                 t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
1005                                    new->name);
1006                 if (IS_ERR(t)) {
1007                         ret = PTR_ERR(t);
1008                         goto out_mput;
1009                 }
1010 
1011                 sched_setscheduler_nocheck(t, SCHED_FIFO, &param);
1012 
1013                 /*
1014                  * We keep the reference to the task struct even if
1015                  * the thread dies to avoid that the interrupt code
1016                  * references an already freed task_struct.
1017                  */
1018                 get_task_struct(t);
1019                 new->thread = t;
1020                 /*
1021                  * Tell the thread to set its affinity. This is
1022                  * important for shared interrupt handlers as we do
1023                  * not invoke setup_affinity() for the secondary
1024                  * handlers as everything is already set up. Even for
1025                  * interrupts marked with IRQF_NO_BALANCE this is
1026                  * correct as we want the thread to move to the cpu(s)
1027                  * on which the requesting code placed the interrupt.
1028                  */
1029                 set_bit(IRQTF_AFFINITY, &new->thread_flags);
1030         }
1031 
1032         if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
1033                 ret = -ENOMEM;
1034                 goto out_thread;
1035         }
1036 
1037         /*
1038          * Drivers are often written to work w/o knowledge about the
1039          * underlying irq chip implementation, so a request for a
1040          * threaded irq without a primary hard irq context handler
1041          * requires the ONESHOT flag to be set. Some irq chips like
1042          * MSI based interrupts are per se one shot safe. Check the
1043          * chip flags, so we can avoid the unmask dance at the end of
1044          * the threaded handler for those.
1045          */
1046         if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)
1047                 new->flags &= ~IRQF_ONESHOT;
1048 
1049         /*
1050          * The following block of code has to be executed atomically
1051          */
1052         raw_spin_lock_irqsave(&desc->lock, flags);
1053         old_ptr = &desc->action;
1054         old = *old_ptr;
1055         if (old) {
1056                 /*
1057                  * Can't share interrupts unless both agree to and are
1058                  * the same type (level, edge, polarity). So both flag
1059                  * fields must have IRQF_SHARED set and the bits which
1060                  * set the trigger type must match. Also all must
1061                  * agree on ONESHOT.
1062                  */
1063                 if (!((old->flags & new->flags) & IRQF_SHARED) ||
1064                     ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK) ||
1065                     ((old->flags ^ new->flags) & IRQF_ONESHOT))
1066                         goto mismatch;
1067 
1068                 /* All handlers must agree on per-cpuness */
1069                 if ((old->flags & IRQF_PERCPU) !=
1070                     (new->flags & IRQF_PERCPU))
1071                         goto mismatch;
1072 
1073                 /* add new interrupt at end of irq queue */
1074                 do {
1075                         /*
1076                          * Or all existing action->thread_mask bits,
1077                          * so we can find the next zero bit for this
1078                          * new action.
1079                          */
1080                         thread_mask |= old->thread_mask;
1081                         old_ptr = &old->next;
1082                         old = *old_ptr;
1083                 } while (old);
1084                 shared = 1;
1085         }
1086 
1087         /*
1088          * Setup the thread mask for this irqaction for ONESHOT. For
1089          * !ONESHOT irqs the thread mask is 0 so we can avoid a
1090          * conditional in irq_wake_thread().
1091          */
1092         if (new->flags & IRQF_ONESHOT) {
1093                 /*
1094                  * Unlikely to have 32 resp 64 irqs sharing one line,
1095                  * but who knows.
1096                  */
1097                 if (thread_mask == ~0UL) {
1098                         ret = -EBUSY;
1099                         goto out_mask;
1100                 }
1101                 /*
1102                  * The thread_mask for the action is or'ed to
1103                  * desc->thread_active to indicate that the
1104                  * IRQF_ONESHOT thread handler has been woken, but not
1105                  * yet finished. The bit is cleared when a thread
1106                  * completes. When all threads of a shared interrupt
1107                  * line have completed desc->threads_active becomes
1108                  * zero and the interrupt line is unmasked. See
1109                  * handle.c:irq_wake_thread() for further information.
1110                  *
1111                  * If no thread is woken by primary (hard irq context)
1112                  * interrupt handlers, then desc->threads_active is
1113                  * also checked for zero to unmask the irq line in the
1114                  * affected hard irq flow handlers
1115                  * (handle_[fasteoi|level]_irq).
1116                  *
1117                  * The new action gets the first zero bit of
1118                  * thread_mask assigned. See the loop above which or's
1119                  * all existing action->thread_mask bits.
1120                  */
1121                 new->thread_mask = 1 << ffz(thread_mask);
1122 
1123         } else if (new->handler == irq_default_primary_handler &&
1124                    !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {
1125                 /*
1126                  * The interrupt was requested with handler = NULL, so
1127                  * we use the default primary handler for it. But it
1128                  * does not have the oneshot flag set. In combination
1129                  * with level interrupts this is deadly, because the
1130                  * default primary handler just wakes the thread, then
1131                  * the irq lines is reenabled, but the device still
1132                  * has the level irq asserted. Rinse and repeat....
1133                  *
1134                  * While this works for edge type interrupts, we play
1135                  * it safe and reject unconditionally because we can't
1136                  * say for sure which type this interrupt really
1137                  * has. The type flags are unreliable as the
1138                  * underlying chip implementation can override them.
1139                  */
1140                 pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
1141                        irq);
1142                 ret = -EINVAL;
1143                 goto out_mask;
1144         }
1145 
1146         if (!shared) {
1147                 ret = irq_request_resources(desc);
1148                 if (ret) {
1149                         pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
1150                                new->name, irq, desc->irq_data.chip->name);
1151                         goto out_mask;
1152                 }
1153 
1154                 init_waitqueue_head(&desc->wait_for_threads);
1155 
1156                 /* Setup the type (level, edge polarity) if configured: */
1157                 if (new->flags & IRQF_TRIGGER_MASK) {
1158                         ret = __irq_set_trigger(desc, irq,
1159                                         new->flags & IRQF_TRIGGER_MASK);
1160 
1161                         if (ret)
1162                                 goto out_mask;
1163                 }
1164 
1165                 desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
1166                                   IRQS_ONESHOT | IRQS_WAITING);
1167                 irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
1168 
1169                 if (new->flags & IRQF_PERCPU) {
1170                         irqd_set(&desc->irq_data, IRQD_PER_CPU);
1171                         irq_settings_set_per_cpu(desc);
1172                 }
1173 
1174                 if (new->flags & IRQF_ONESHOT)
1175                         desc->istate |= IRQS_ONESHOT;
1176 
1177                 if (irq_settings_can_autoenable(desc))
1178                         irq_startup(desc, true);
1179                 else
1180                         /* Undo nested disables: */
1181                         desc->depth = 1;
1182 
1183                 /* Exclude IRQ from balancing if requested */
1184                 if (new->flags & IRQF_NOBALANCING) {
1185                         irq_settings_set_no_balancing(desc);
1186                         irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
1187                 }
1188 
1189                 /* Set default affinity mask once everything is setup */
1190                 setup_affinity(irq, desc, mask);
1191 
1192         } else if (new->flags & IRQF_TRIGGER_MASK) {
1193                 unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
1194                 unsigned int omsk = irq_settings_get_trigger_mask(desc);
1195 
1196                 if (nmsk != omsk)
1197                         /* hope the handler works with current  trigger mode */
1198                         pr_warning("irq %d uses trigger mode %u; requested %u\n",
1199                                    irq, nmsk, omsk);
1200         }
1201 
1202         new->irq = irq;
1203         *old_ptr = new;
1204 
1205         irq_pm_install_action(desc, new);
1206 
1207         /* Reset broken irq detection when installing new handler */
1208         desc->irq_count = 0;
1209         desc->irqs_unhandled = 0;
1210 
1211         /*
1212          * Check whether we disabled the irq via the spurious handler
1213          * before. Reenable it and give it another chance.
1214          */
1215         if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
1216                 desc->istate &= ~IRQS_SPURIOUS_DISABLED;
1217                 __enable_irq(desc, irq);
1218         }
1219 
1220         raw_spin_unlock_irqrestore(&desc->lock, flags);
1221 
1222         /*
1223          * Strictly no need to wake it up, but hung_task complains
1224          * when no hard interrupt wakes the thread up.
1225          */
1226         if (new->thread)
1227                 wake_up_process(new->thread);
1228 
1229         register_irq_proc(irq, desc);
1230         new->dir = NULL;
1231         register_handler_proc(irq, new);
1232         free_cpumask_var(mask);
1233 
1234         return 0;
1235 
1236 mismatch:
1237         if (!(new->flags & IRQF_PROBE_SHARED)) {
1238                 pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",
1239                        irq, new->flags, new->name, old->flags, old->name);
1240 #ifdef CONFIG_DEBUG_SHIRQ
1241                 dump_stack();
1242 #endif
1243         }
1244         ret = -EBUSY;
1245 
1246 out_mask:
1247         raw_spin_unlock_irqrestore(&desc->lock, flags);
1248         free_cpumask_var(mask);
1249 
1250 out_thread:
1251         if (new->thread) {
1252                 struct task_struct *t = new->thread;
1253 
1254                 new->thread = NULL;
1255                 kthread_stop(t);
1256                 put_task_struct(t);
1257         }
1258 out_mput:
1259         module_put(desc->owner);
1260         return ret;
1261 }
1262 
1263 /**
1264  *      setup_irq - setup an interrupt
1265  *      @irq: Interrupt line to setup
1266  *      @act: irqaction for the interrupt
1267  *
1268  * Used to statically setup interrupts in the early boot process.
1269  */
1270 int setup_irq(unsigned int irq, struct irqaction *act)
1271 {
1272         int retval;
1273         struct irq_desc *desc = irq_to_desc(irq);
1274 
1275         if (WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1276                 return -EINVAL;
1277         chip_bus_lock(desc);
1278         retval = __setup_irq(irq, desc, act);
1279         chip_bus_sync_unlock(desc);
1280 
1281         return retval;
1282 }
1283 EXPORT_SYMBOL_GPL(setup_irq);
1284 
1285 /*
1286  * Internal function to unregister an irqaction - used to free
1287  * regular and special interrupts that are part of the architecture.
1288  */
1289 static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
1290 {
1291         struct irq_desc *desc = irq_to_desc(irq);
1292         struct irqaction *action, **action_ptr;
1293         unsigned long flags;
1294 
1295         WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1296 
1297         if (!desc)
1298                 return NULL;
1299 
1300         raw_spin_lock_irqsave(&desc->lock, flags);
1301 
1302         /*
1303          * There can be multiple actions per IRQ descriptor, find the right
1304          * one based on the dev_id:
1305          */
1306         action_ptr = &desc->action;
1307         for (;;) {
1308                 action = *action_ptr;
1309 
1310                 if (!action) {
1311                         WARN(1, "Trying to free already-free IRQ %d\n", irq);
1312                         raw_spin_unlock_irqrestore(&desc->lock, flags);
1313 
1314                         return NULL;
1315                 }
1316 
1317                 if (action->dev_id == dev_id)
1318                         break;
1319                 action_ptr = &action->next;
1320         }
1321 
1322         /* Found it - now remove it from the list of entries: */
1323         *action_ptr = action->next;
1324 
1325         irq_pm_remove_action(desc, action);
1326 
1327         /* If this was the last handler, shut down the IRQ line: */
1328         if (!desc->action) {
1329                 irq_shutdown(desc);
1330                 irq_release_resources(desc);
1331         }
1332 
1333 #ifdef CONFIG_SMP
1334         /* make sure affinity_hint is cleaned up */
1335         if (WARN_ON_ONCE(desc->affinity_hint))
1336                 desc->affinity_hint = NULL;
1337 #endif
1338 
1339         raw_spin_unlock_irqrestore(&desc->lock, flags);
1340 
1341         unregister_handler_proc(irq, action);
1342 
1343         /* Make sure it's not being used on another CPU: */
1344         synchronize_irq(irq);
1345 
1346 #ifdef CONFIG_DEBUG_SHIRQ
1347         /*
1348          * It's a shared IRQ -- the driver ought to be prepared for an IRQ
1349          * event to happen even now it's being freed, so let's make sure that
1350          * is so by doing an extra call to the handler ....
1351          *
1352          * ( We do this after actually deregistering it, to make sure that a
1353          *   'real' IRQ doesn't run in * parallel with our fake. )
1354          */
1355         if (action->flags & IRQF_SHARED) {
1356                 local_irq_save(flags);
1357                 action->handler(irq, dev_id);
1358                 local_irq_restore(flags);
1359         }
1360 #endif
1361 
1362         if (action->thread) {
1363                 kthread_stop(action->thread);
1364                 put_task_struct(action->thread);
1365         }
1366 
1367         module_put(desc->owner);
1368         return action;
1369 }
1370 
1371 /**
1372  *      remove_irq - free an interrupt
1373  *      @irq: Interrupt line to free
1374  *      @act: irqaction for the interrupt
1375  *
1376  * Used to remove interrupts statically setup by the early boot process.
1377  */
1378 void remove_irq(unsigned int irq, struct irqaction *act)
1379 {
1380         struct irq_desc *desc = irq_to_desc(irq);
1381 
1382         if (desc && !WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1383             __free_irq(irq, act->dev_id);
1384 }
1385 EXPORT_SYMBOL_GPL(remove_irq);
1386 
1387 /**
1388  *      free_irq - free an interrupt allocated with request_irq
1389  *      @irq: Interrupt line to free
1390  *      @dev_id: Device identity to free
1391  *
1392  *      Remove an interrupt handler. The handler is removed and if the
1393  *      interrupt line is no longer in use by any driver it is disabled.
1394  *      On a shared IRQ the caller must ensure the interrupt is disabled
1395  *      on the card it drives before calling this function. The function
1396  *      does not return until any executing interrupts for this IRQ
1397  *      have completed.
1398  *
1399  *      This function must not be called from interrupt context.
1400  */
1401 void free_irq(unsigned int irq, void *dev_id)
1402 {
1403         struct irq_desc *desc = irq_to_desc(irq);
1404 
1405         if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1406                 return;
1407 
1408 #ifdef CONFIG_SMP
1409         if (WARN_ON(desc->affinity_notify))
1410                 desc->affinity_notify = NULL;
1411 #endif
1412 
1413         chip_bus_lock(desc);
1414         kfree(__free_irq(irq, dev_id));
1415         chip_bus_sync_unlock(desc);
1416 }
1417 EXPORT_SYMBOL(free_irq);
1418 
1419 /**
1420  *      request_threaded_irq - allocate an interrupt line
1421  *      @irq: Interrupt line to allocate
1422  *      @handler: Function to be called when the IRQ occurs.
1423  *                Primary handler for threaded interrupts
1424  *                If NULL and thread_fn != NULL the default
1425  *                primary handler is installed
1426  *      @thread_fn: Function called from the irq handler thread
1427  *                  If NULL, no irq thread is created
1428  *      @irqflags: Interrupt type flags
1429  *      @devname: An ascii name for the claiming device
1430  *      @dev_id: A cookie passed back to the handler function
1431  *
1432  *      This call allocates interrupt resources and enables the
1433  *      interrupt line and IRQ handling. From the point this
1434  *      call is made your handler function may be invoked. Since
1435  *      your handler function must clear any interrupt the board
1436  *      raises, you must take care both to initialise your hardware
1437  *      and to set up the interrupt handler in the right order.
1438  *
1439  *      If you want to set up a threaded irq handler for your device
1440  *      then you need to supply @handler and @thread_fn. @handler is
1441  *      still called in hard interrupt context and has to check
1442  *      whether the interrupt originates from the device. If yes it
1443  *      needs to disable the interrupt on the device and return
1444  *      IRQ_WAKE_THREAD which will wake up the handler thread and run
1445  *      @thread_fn. This split handler design is necessary to support
1446  *      shared interrupts.
1447  *
1448  *      Dev_id must be globally unique. Normally the address of the
1449  *      device data structure is used as the cookie. Since the handler
1450  *      receives this value it makes sense to use it.
1451  *
1452  *      If your interrupt is shared you must pass a non NULL dev_id
1453  *      as this is required when freeing the interrupt.
1454  *
1455  *      Flags:
1456  *
1457  *      IRQF_SHARED             Interrupt is shared
1458  *      IRQF_TRIGGER_*          Specify active edge(s) or level
1459  *
1460  */
1461 int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1462                          irq_handler_t thread_fn, unsigned long irqflags,
1463                          const char *devname, void *dev_id)
1464 {
1465         struct irqaction *action;
1466         struct irq_desc *desc;
1467         int retval;
1468 
1469         /*
1470          * Sanity-check: shared interrupts must pass in a real dev-ID,
1471          * otherwise we'll have trouble later trying to figure out
1472          * which interrupt is which (messes up the interrupt freeing
1473          * logic etc).
1474          */
1475         if ((irqflags & IRQF_SHARED) && !dev_id)
1476                 return -EINVAL;
1477 
1478         desc = irq_to_desc(irq);
1479         if (!desc)
1480                 return -EINVAL;
1481 
1482         if (!irq_settings_can_request(desc) ||
1483             WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1484                 return -EINVAL;
1485 
1486         if (!handler) {
1487                 if (!thread_fn)
1488                         return -EINVAL;
1489                 handler = irq_default_primary_handler;
1490         }
1491 
1492         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1493         if (!action)
1494                 return -ENOMEM;
1495 
1496         action->handler = handler;
1497         action->thread_fn = thread_fn;
1498         action->flags = irqflags;
1499         action->name = devname;
1500         action->dev_id = dev_id;
1501 
1502         chip_bus_lock(desc);
1503         retval = __setup_irq(irq, desc, action);
1504         chip_bus_sync_unlock(desc);
1505 
1506         if (retval)
1507                 kfree(action);
1508 
1509 #ifdef CONFIG_DEBUG_SHIRQ_FIXME
1510         if (!retval && (irqflags & IRQF_SHARED)) {
1511                 /*
1512                  * It's a shared IRQ -- the driver ought to be prepared for it
1513                  * to happen immediately, so let's make sure....
1514                  * We disable the irq to make sure that a 'real' IRQ doesn't
1515                  * run in parallel with our fake.
1516                  */
1517                 unsigned long flags;
1518 
1519                 disable_irq(irq);
1520                 local_irq_save(flags);
1521 
1522                 handler(irq, dev_id);
1523 
1524                 local_irq_restore(flags);
1525                 enable_irq(irq);
1526         }
1527 #endif
1528         return retval;
1529 }
1530 EXPORT_SYMBOL(request_threaded_irq);
1531 
1532 /**
1533  *      request_any_context_irq - allocate an interrupt line
1534  *      @irq: Interrupt line to allocate
1535  *      @handler: Function to be called when the IRQ occurs.
1536  *                Threaded handler for threaded interrupts.
1537  *      @flags: Interrupt type flags
1538  *      @name: An ascii name for the claiming device
1539  *      @dev_id: A cookie passed back to the handler function
1540  *
1541  *      This call allocates interrupt resources and enables the
1542  *      interrupt line and IRQ handling. It selects either a
1543  *      hardirq or threaded handling method depending on the
1544  *      context.
1545  *
1546  *      On failure, it returns a negative value. On success,
1547  *      it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
1548  */
1549 int request_any_context_irq(unsigned int irq, irq_handler_t handler,
1550                             unsigned long flags, const char *name, void *dev_id)
1551 {
1552         struct irq_desc *desc = irq_to_desc(irq);
1553         int ret;
1554 
1555         if (!desc)
1556                 return -EINVAL;
1557 
1558         if (irq_settings_is_nested_thread(desc)) {
1559                 ret = request_threaded_irq(irq, NULL, handler,
1560                                            flags, name, dev_id);
1561                 return !ret ? IRQC_IS_NESTED : ret;
1562         }
1563 
1564         ret = request_irq(irq, handler, flags, name, dev_id);
1565         return !ret ? IRQC_IS_HARDIRQ : ret;
1566 }
1567 EXPORT_SYMBOL_GPL(request_any_context_irq);
1568 
1569 void enable_percpu_irq(unsigned int irq, unsigned int type)
1570 {
1571         unsigned int cpu = smp_processor_id();
1572         unsigned long flags;
1573         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1574 
1575         if (!desc)
1576                 return;
1577 
1578         type &= IRQ_TYPE_SENSE_MASK;
1579         if (type != IRQ_TYPE_NONE) {
1580                 int ret;
1581 
1582                 ret = __irq_set_trigger(desc, irq, type);
1583 
1584                 if (ret) {
1585                         WARN(1, "failed to set type for IRQ%d\n", irq);
1586                         goto out;
1587                 }
1588         }
1589 
1590         irq_percpu_enable(desc, cpu);
1591 out:
1592         irq_put_desc_unlock(desc, flags);
1593 }
1594 EXPORT_SYMBOL_GPL(enable_percpu_irq);
1595 
1596 void disable_percpu_irq(unsigned int irq)
1597 {
1598         unsigned int cpu = smp_processor_id();
1599         unsigned long flags;
1600         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1601 
1602         if (!desc)
1603                 return;
1604 
1605         irq_percpu_disable(desc, cpu);
1606         irq_put_desc_unlock(desc, flags);
1607 }
1608 EXPORT_SYMBOL_GPL(disable_percpu_irq);
1609 
1610 /*
1611  * Internal function to unregister a percpu irqaction.
1612  */
1613 static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1614 {
1615         struct irq_desc *desc = irq_to_desc(irq);
1616         struct irqaction *action;
1617         unsigned long flags;
1618 
1619         WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1620 
1621         if (!desc)
1622                 return NULL;
1623 
1624         raw_spin_lock_irqsave(&desc->lock, flags);
1625 
1626         action = desc->action;
1627         if (!action || action->percpu_dev_id != dev_id) {
1628                 WARN(1, "Trying to free already-free IRQ %d\n", irq);
1629                 goto bad;
1630         }
1631 
1632         if (!cpumask_empty(desc->percpu_enabled)) {
1633                 WARN(1, "percpu IRQ %d still enabled on CPU%d!\n",
1634                      irq, cpumask_first(desc->percpu_enabled));
1635                 goto bad;
1636         }
1637 
1638         /* Found it - now remove it from the list of entries: */
1639         desc->action = NULL;
1640 
1641         raw_spin_unlock_irqrestore(&desc->lock, flags);
1642 
1643         unregister_handler_proc(irq, action);
1644 
1645         module_put(desc->owner);
1646         return action;
1647 
1648 bad:
1649         raw_spin_unlock_irqrestore(&desc->lock, flags);
1650         return NULL;
1651 }
1652 
1653 /**
1654  *      remove_percpu_irq - free a per-cpu interrupt
1655  *      @irq: Interrupt line to free
1656  *      @act: irqaction for the interrupt
1657  *
1658  * Used to remove interrupts statically setup by the early boot process.
1659  */
1660 void remove_percpu_irq(unsigned int irq, struct irqaction *act)
1661 {
1662         struct irq_desc *desc = irq_to_desc(irq);
1663 
1664         if (desc && irq_settings_is_per_cpu_devid(desc))
1665             __free_percpu_irq(irq, act->percpu_dev_id);
1666 }
1667 
1668 /**
1669  *      free_percpu_irq - free an interrupt allocated with request_percpu_irq
1670  *      @irq: Interrupt line to free
1671  *      @dev_id: Device identity to free
1672  *
1673  *      Remove a percpu interrupt handler. The handler is removed, but
1674  *      the interrupt line is not disabled. This must be done on each
1675  *      CPU before calling this function. The function does not return
1676  *      until any executing interrupts for this IRQ have completed.
1677  *
1678  *      This function must not be called from interrupt context.
1679  */
1680 void free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1681 {
1682         struct irq_desc *desc = irq_to_desc(irq);
1683 
1684         if (!desc || !irq_settings_is_per_cpu_devid(desc))
1685                 return;
1686 
1687         chip_bus_lock(desc);
1688         kfree(__free_percpu_irq(irq, dev_id));
1689         chip_bus_sync_unlock(desc);
1690 }
1691 
1692 /**
1693  *      setup_percpu_irq - setup a per-cpu interrupt
1694  *      @irq: Interrupt line to setup
1695  *      @act: irqaction for the interrupt
1696  *
1697  * Used to statically setup per-cpu interrupts in the early boot process.
1698  */
1699 int setup_percpu_irq(unsigned int irq, struct irqaction *act)
1700 {
1701         struct irq_desc *desc = irq_to_desc(irq);
1702         int retval;
1703 
1704         if (!desc || !irq_settings_is_per_cpu_devid(desc))
1705                 return -EINVAL;
1706         chip_bus_lock(desc);
1707         retval = __setup_irq(irq, desc, act);
1708         chip_bus_sync_unlock(desc);
1709 
1710         return retval;
1711 }
1712 
1713 /**
1714  *      request_percpu_irq - allocate a percpu interrupt line
1715  *      @irq: Interrupt line to allocate
1716  *      @handler: Function to be called when the IRQ occurs.
1717  *      @devname: An ascii name for the claiming device
1718  *      @dev_id: A percpu cookie passed back to the handler function
1719  *
1720  *      This call allocates interrupt resources, but doesn't
1721  *      automatically enable the interrupt. It has to be done on each
1722  *      CPU using enable_percpu_irq().
1723  *
1724  *      Dev_id must be globally unique. It is a per-cpu variable, and
1725  *      the handler gets called with the interrupted CPU's instance of
1726  *      that variable.
1727  */
1728 int request_percpu_irq(unsigned int irq, irq_handler_t handler,
1729                        const char *devname, void __percpu *dev_id)
1730 {
1731         struct irqaction *action;
1732         struct irq_desc *desc;
1733         int retval;
1734 
1735         if (!dev_id)
1736                 return -EINVAL;
1737 
1738         desc = irq_to_desc(irq);
1739         if (!desc || !irq_settings_can_request(desc) ||
1740             !irq_settings_is_per_cpu_devid(desc))
1741                 return -EINVAL;
1742 
1743         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1744         if (!action)
1745                 return -ENOMEM;
1746 
1747         action->handler = handler;
1748         action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND;
1749         action->name = devname;
1750         action->percpu_dev_id = dev_id;
1751 
1752         chip_bus_lock(desc);
1753         retval = __setup_irq(irq, desc, action);
1754         chip_bus_sync_unlock(desc);
1755 
1756         if (retval)
1757                 kfree(action);
1758 
1759         return retval;
1760 }
1761 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us