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