1d1a5b945ab428008ebaa8b31cd1f2a638f6aa97
[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  * Locking rules:
1095  *
1096  * desc->request_mutex  Provides serialization against a concurrent free_irq()
1097  *   chip_bus_lock      Provides serialization for slow bus operations
1098  *     desc->lock       Provides serialization against hard interrupts
1099  *
1100  * chip_bus_lock and desc->lock are sufficient for all other management and
1101  * interrupt related functions. desc->request_mutex solely serializes
1102  * request/free_irq().
1103  */
1104 static int
1105 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
1106 {
1107         struct irqaction *old, **old_ptr;
1108         unsigned long flags, thread_mask = 0;
1109         int ret, nested, shared = 0;
1110
1111         if (!desc)
1112                 return -EINVAL;
1113
1114         if (desc->irq_data.chip == &no_irq_chip)
1115                 return -ENOSYS;
1116         if (!try_module_get(desc->owner))
1117                 return -ENODEV;
1118
1119         new->irq = irq;
1120
1121         /*
1122          * If the trigger type is not specified by the caller,
1123          * then use the default for this interrupt.
1124          */
1125         if (!(new->flags & IRQF_TRIGGER_MASK))
1126                 new->flags |= irqd_get_trigger_type(&desc->irq_data);
1127
1128         /*
1129          * Check whether the interrupt nests into another interrupt
1130          * thread.
1131          */
1132         nested = irq_settings_is_nested_thread(desc);
1133         if (nested) {
1134                 if (!new->thread_fn) {
1135                         ret = -EINVAL;
1136                         goto out_mput;
1137                 }
1138                 /*
1139                  * Replace the primary handler which was provided from
1140                  * the driver for non nested interrupt handling by the
1141                  * dummy function which warns when called.
1142                  */
1143                 new->handler = irq_nested_primary_handler;
1144         } else {
1145                 if (irq_settings_can_thread(desc)) {
1146                         ret = irq_setup_forced_threading(new);
1147                         if (ret)
1148                                 goto out_mput;
1149                 }
1150         }
1151
1152         /*
1153          * Create a handler thread when a thread function is supplied
1154          * and the interrupt does not nest into another interrupt
1155          * thread.
1156          */
1157         if (new->thread_fn && !nested) {
1158                 ret = setup_irq_thread(new, irq, false);
1159                 if (ret)
1160                         goto out_mput;
1161                 if (new->secondary) {
1162                         ret = setup_irq_thread(new->secondary, irq, true);
1163                         if (ret)
1164                                 goto out_thread;
1165                 }
1166         }
1167
1168         /*
1169          * Drivers are often written to work w/o knowledge about the
1170          * underlying irq chip implementation, so a request for a
1171          * threaded irq without a primary hard irq context handler
1172          * requires the ONESHOT flag to be set. Some irq chips like
1173          * MSI based interrupts are per se one shot safe. Check the
1174          * chip flags, so we can avoid the unmask dance at the end of
1175          * the threaded handler for those.
1176          */
1177         if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)
1178                 new->flags &= ~IRQF_ONESHOT;
1179
1180         /*
1181          * Protects against a concurrent __free_irq() call which might wait
1182          * for synchronize_irq() to complete without holding the optional
1183          * chip bus lock and desc->lock.
1184          */
1185         mutex_lock(&desc->request_mutex);
1186
1187         /*
1188          * Acquire bus lock as the irq_request_resources() callback below
1189          * might rely on the serialization or the magic power management
1190          * functions which are abusing the irq_bus_lock() callback,
1191          */
1192         chip_bus_lock(desc);
1193
1194         /* First installed action requests resources. */
1195         if (!desc->action) {
1196                 ret = irq_request_resources(desc);
1197                 if (ret) {
1198                         pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
1199                                new->name, irq, desc->irq_data.chip->name);
1200                         goto out_bus_unlock;
1201                 }
1202         }
1203
1204         /*
1205          * The following block of code has to be executed atomically
1206          * protected against a concurrent interrupt and any of the other
1207          * management calls which are not serialized via
1208          * desc->request_mutex or the optional bus lock.
1209          */
1210         raw_spin_lock_irqsave(&desc->lock, flags);
1211         old_ptr = &desc->action;
1212         old = *old_ptr;
1213         if (old) {
1214                 /*
1215                  * Can't share interrupts unless both agree to and are
1216                  * the same type (level, edge, polarity). So both flag
1217                  * fields must have IRQF_SHARED set and the bits which
1218                  * set the trigger type must match. Also all must
1219                  * agree on ONESHOT.
1220                  */
1221                 unsigned int oldtype = irqd_get_trigger_type(&desc->irq_data);
1222
1223                 if (!((old->flags & new->flags) & IRQF_SHARED) ||
1224                     (oldtype != (new->flags & IRQF_TRIGGER_MASK)) ||
1225                     ((old->flags ^ new->flags) & IRQF_ONESHOT))
1226                         goto mismatch;
1227
1228                 /* All handlers must agree on per-cpuness */
1229                 if ((old->flags & IRQF_PERCPU) !=
1230                     (new->flags & IRQF_PERCPU))
1231                         goto mismatch;
1232
1233                 /* add new interrupt at end of irq queue */
1234                 do {
1235                         /*
1236                          * Or all existing action->thread_mask bits,
1237                          * so we can find the next zero bit for this
1238                          * new action.
1239                          */
1240                         thread_mask |= old->thread_mask;
1241                         old_ptr = &old->next;
1242                         old = *old_ptr;
1243                 } while (old);
1244                 shared = 1;
1245         }
1246
1247         /*
1248          * Setup the thread mask for this irqaction for ONESHOT. For
1249          * !ONESHOT irqs the thread mask is 0 so we can avoid a
1250          * conditional in irq_wake_thread().
1251          */
1252         if (new->flags & IRQF_ONESHOT) {
1253                 /*
1254                  * Unlikely to have 32 resp 64 irqs sharing one line,
1255                  * but who knows.
1256                  */
1257                 if (thread_mask == ~0UL) {
1258                         ret = -EBUSY;
1259                         goto out_unlock;
1260                 }
1261                 /*
1262                  * The thread_mask for the action is or'ed to
1263                  * desc->thread_active to indicate that the
1264                  * IRQF_ONESHOT thread handler has been woken, but not
1265                  * yet finished. The bit is cleared when a thread
1266                  * completes. When all threads of a shared interrupt
1267                  * line have completed desc->threads_active becomes
1268                  * zero and the interrupt line is unmasked. See
1269                  * handle.c:irq_wake_thread() for further information.
1270                  *
1271                  * If no thread is woken by primary (hard irq context)
1272                  * interrupt handlers, then desc->threads_active is
1273                  * also checked for zero to unmask the irq line in the
1274                  * affected hard irq flow handlers
1275                  * (handle_[fasteoi|level]_irq).
1276                  *
1277                  * The new action gets the first zero bit of
1278                  * thread_mask assigned. See the loop above which or's
1279                  * all existing action->thread_mask bits.
1280                  */
1281                 new->thread_mask = 1 << ffz(thread_mask);
1282
1283         } else if (new->handler == irq_default_primary_handler &&
1284                    !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {
1285                 /*
1286                  * The interrupt was requested with handler = NULL, so
1287                  * we use the default primary handler for it. But it
1288                  * does not have the oneshot flag set. In combination
1289                  * with level interrupts this is deadly, because the
1290                  * default primary handler just wakes the thread, then
1291                  * the irq lines is reenabled, but the device still
1292                  * has the level irq asserted. Rinse and repeat....
1293                  *
1294                  * While this works for edge type interrupts, we play
1295                  * it safe and reject unconditionally because we can't
1296                  * say for sure which type this interrupt really
1297                  * has. The type flags are unreliable as the
1298                  * underlying chip implementation can override them.
1299                  */
1300                 pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
1301                        irq);
1302                 ret = -EINVAL;
1303                 goto out_unlock;
1304         }
1305
1306         if (!shared) {
1307                 init_waitqueue_head(&desc->wait_for_threads);
1308
1309                 /* Setup the type (level, edge polarity) if configured: */
1310                 if (new->flags & IRQF_TRIGGER_MASK) {
1311                         ret = __irq_set_trigger(desc,
1312                                                 new->flags & IRQF_TRIGGER_MASK);
1313
1314                         if (ret)
1315                                 goto out_unlock;
1316                 }
1317
1318                 desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
1319                                   IRQS_ONESHOT | IRQS_WAITING);
1320                 irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
1321
1322                 if (new->flags & IRQF_PERCPU) {
1323                         irqd_set(&desc->irq_data, IRQD_PER_CPU);
1324                         irq_settings_set_per_cpu(desc);
1325                 }
1326
1327                 if (new->flags & IRQF_ONESHOT)
1328                         desc->istate |= IRQS_ONESHOT;
1329
1330                 /* Exclude IRQ from balancing if requested */
1331                 if (new->flags & IRQF_NOBALANCING) {
1332                         irq_settings_set_no_balancing(desc);
1333                         irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
1334                 }
1335
1336                 if (irq_settings_can_autoenable(desc)) {
1337                         irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
1338                 } else {
1339                         /*
1340                          * Shared interrupts do not go well with disabling
1341                          * auto enable. The sharing interrupt might request
1342                          * it while it's still disabled and then wait for
1343                          * interrupts forever.
1344                          */
1345                         WARN_ON_ONCE(new->flags & IRQF_SHARED);
1346                         /* Undo nested disables: */
1347                         desc->depth = 1;
1348                 }
1349
1350         } else if (new->flags & IRQF_TRIGGER_MASK) {
1351                 unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
1352                 unsigned int omsk = irqd_get_trigger_type(&desc->irq_data);
1353
1354                 if (nmsk != omsk)
1355                         /* hope the handler works with current  trigger mode */
1356                         pr_warn("irq %d uses trigger mode %u; requested %u\n",
1357                                 irq, omsk, nmsk);
1358         }
1359
1360         *old_ptr = new;
1361
1362         irq_pm_install_action(desc, new);
1363
1364         /* Reset broken irq detection when installing new handler */
1365         desc->irq_count = 0;
1366         desc->irqs_unhandled = 0;
1367
1368         /*
1369          * Check whether we disabled the irq via the spurious handler
1370          * before. Reenable it and give it another chance.
1371          */
1372         if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
1373                 desc->istate &= ~IRQS_SPURIOUS_DISABLED;
1374                 __enable_irq(desc);
1375         }
1376
1377         raw_spin_unlock_irqrestore(&desc->lock, flags);
1378         chip_bus_sync_unlock(desc);
1379         mutex_unlock(&desc->request_mutex);
1380
1381         irq_setup_timings(desc, new);
1382
1383         /*
1384          * Strictly no need to wake it up, but hung_task complains
1385          * when no hard interrupt wakes the thread up.
1386          */
1387         if (new->thread)
1388                 wake_up_process(new->thread);
1389         if (new->secondary)
1390                 wake_up_process(new->secondary->thread);
1391
1392         register_irq_proc(irq, desc);
1393         irq_add_debugfs_entry(irq, desc);
1394         new->dir = NULL;
1395         register_handler_proc(irq, new);
1396         return 0;
1397
1398 mismatch:
1399         if (!(new->flags & IRQF_PROBE_SHARED)) {
1400                 pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",
1401                        irq, new->flags, new->name, old->flags, old->name);
1402 #ifdef CONFIG_DEBUG_SHIRQ
1403                 dump_stack();
1404 #endif
1405         }
1406         ret = -EBUSY;
1407
1408 out_unlock:
1409         raw_spin_unlock_irqrestore(&desc->lock, flags);
1410
1411         if (!desc->action)
1412                 irq_release_resources(desc);
1413 out_bus_unlock:
1414         chip_bus_sync_unlock(desc);
1415         mutex_unlock(&desc->request_mutex);
1416
1417 out_thread:
1418         if (new->thread) {
1419                 struct task_struct *t = new->thread;
1420
1421                 new->thread = NULL;
1422                 kthread_stop(t);
1423                 put_task_struct(t);
1424         }
1425         if (new->secondary && new->secondary->thread) {
1426                 struct task_struct *t = new->secondary->thread;
1427
1428                 new->secondary->thread = NULL;
1429                 kthread_stop(t);
1430                 put_task_struct(t);
1431         }
1432 out_mput:
1433         module_put(desc->owner);
1434         return ret;
1435 }
1436
1437 /**
1438  *      setup_irq - setup an interrupt
1439  *      @irq: Interrupt line to setup
1440  *      @act: irqaction for the interrupt
1441  *
1442  * Used to statically setup interrupts in the early boot process.
1443  */
1444 int setup_irq(unsigned int irq, struct irqaction *act)
1445 {
1446         int retval;
1447         struct irq_desc *desc = irq_to_desc(irq);
1448
1449         if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1450                 return -EINVAL;
1451
1452         retval = irq_chip_pm_get(&desc->irq_data);
1453         if (retval < 0)
1454                 return retval;
1455
1456         retval = __setup_irq(irq, desc, act);
1457
1458         if (retval)
1459                 irq_chip_pm_put(&desc->irq_data);
1460
1461         return retval;
1462 }
1463 EXPORT_SYMBOL_GPL(setup_irq);
1464
1465 /*
1466  * Internal function to unregister an irqaction - used to free
1467  * regular and special interrupts that are part of the architecture.
1468  */
1469 static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
1470 {
1471         struct irq_desc *desc = irq_to_desc(irq);
1472         struct irqaction *action, **action_ptr;
1473         unsigned long flags;
1474
1475         WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1476
1477         if (!desc)
1478                 return NULL;
1479
1480         mutex_lock(&desc->request_mutex);
1481         chip_bus_lock(desc);
1482         raw_spin_lock_irqsave(&desc->lock, flags);
1483
1484         /*
1485          * There can be multiple actions per IRQ descriptor, find the right
1486          * one based on the dev_id:
1487          */
1488         action_ptr = &desc->action;
1489         for (;;) {
1490                 action = *action_ptr;
1491
1492                 if (!action) {
1493                         WARN(1, "Trying to free already-free IRQ %d\n", irq);
1494                         raw_spin_unlock_irqrestore(&desc->lock, flags);
1495                         chip_bus_sync_unlock(desc);
1496                         mutex_unlock(&desc->request_mutex);
1497                         return NULL;
1498                 }
1499
1500                 if (action->dev_id == dev_id)
1501                         break;
1502                 action_ptr = &action->next;
1503         }
1504
1505         /* Found it - now remove it from the list of entries: */
1506         *action_ptr = action->next;
1507
1508         irq_pm_remove_action(desc, action);
1509
1510         /* If this was the last handler, shut down the IRQ line: */
1511         if (!desc->action) {
1512                 irq_settings_clr_disable_unlazy(desc);
1513                 irq_shutdown(desc);
1514         }
1515
1516 #ifdef CONFIG_SMP
1517         /* make sure affinity_hint is cleaned up */
1518         if (WARN_ON_ONCE(desc->affinity_hint))
1519                 desc->affinity_hint = NULL;
1520 #endif
1521
1522         raw_spin_unlock_irqrestore(&desc->lock, flags);
1523         /*
1524          * Drop bus_lock here so the changes which were done in the chip
1525          * callbacks above are synced out to the irq chips which hang
1526          * behind a slow bus (I2C, SPI) before calling synchronize_irq().
1527          *
1528          * Aside of that the bus_lock can also be taken from the threaded
1529          * handler in irq_finalize_oneshot() which results in a deadlock
1530          * because synchronize_irq() would wait forever for the thread to
1531          * complete, which is blocked on the bus lock.
1532          *
1533          * The still held desc->request_mutex() protects against a
1534          * concurrent request_irq() of this irq so the release of resources
1535          * and timing data is properly serialized.
1536          */
1537         chip_bus_sync_unlock(desc);
1538
1539         unregister_handler_proc(irq, action);
1540
1541         /* Make sure it's not being used on another CPU: */
1542         synchronize_irq(irq);
1543
1544 #ifdef CONFIG_DEBUG_SHIRQ
1545         /*
1546          * It's a shared IRQ -- the driver ought to be prepared for an IRQ
1547          * event to happen even now it's being freed, so let's make sure that
1548          * is so by doing an extra call to the handler ....
1549          *
1550          * ( We do this after actually deregistering it, to make sure that a
1551          *   'real' IRQ doesn't run in * parallel with our fake. )
1552          */
1553         if (action->flags & IRQF_SHARED) {
1554                 local_irq_save(flags);
1555                 action->handler(irq, dev_id);
1556                 local_irq_restore(flags);
1557         }
1558 #endif
1559
1560         if (action->thread) {
1561                 kthread_stop(action->thread);
1562                 put_task_struct(action->thread);
1563                 if (action->secondary && action->secondary->thread) {
1564                         kthread_stop(action->secondary->thread);
1565                         put_task_struct(action->secondary->thread);
1566                 }
1567         }
1568
1569         /* Last action releases resources */
1570         if (!desc->action) {
1571                 /*
1572                  * Reaquire bus lock as irq_release_resources() might
1573                  * require it to deallocate resources over the slow bus.
1574                  */
1575                 chip_bus_lock(desc);
1576                 irq_release_resources(desc);
1577                 chip_bus_sync_unlock(desc);
1578                 irq_remove_timings(desc);
1579         }
1580
1581         mutex_unlock(&desc->request_mutex);
1582
1583         irq_chip_pm_put(&desc->irq_data);
1584         module_put(desc->owner);
1585         kfree(action->secondary);
1586         return action;
1587 }
1588
1589 /**
1590  *      remove_irq - free an interrupt
1591  *      @irq: Interrupt line to free
1592  *      @act: irqaction for the interrupt
1593  *
1594  * Used to remove interrupts statically setup by the early boot process.
1595  */
1596 void remove_irq(unsigned int irq, struct irqaction *act)
1597 {
1598         struct irq_desc *desc = irq_to_desc(irq);
1599
1600         if (desc && !WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1601                 __free_irq(irq, act->dev_id);
1602 }
1603 EXPORT_SYMBOL_GPL(remove_irq);
1604
1605 /**
1606  *      free_irq - free an interrupt allocated with request_irq
1607  *      @irq: Interrupt line to free
1608  *      @dev_id: Device identity to free
1609  *
1610  *      Remove an interrupt handler. The handler is removed and if the
1611  *      interrupt line is no longer in use by any driver it is disabled.
1612  *      On a shared IRQ the caller must ensure the interrupt is disabled
1613  *      on the card it drives before calling this function. The function
1614  *      does not return until any executing interrupts for this IRQ
1615  *      have completed.
1616  *
1617  *      This function must not be called from interrupt context.
1618  *
1619  *      Returns the devname argument passed to request_irq.
1620  */
1621 const void *free_irq(unsigned int irq, void *dev_id)
1622 {
1623         struct irq_desc *desc = irq_to_desc(irq);
1624         struct irqaction *action;
1625         const char *devname;
1626
1627         if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1628                 return NULL;
1629
1630 #ifdef CONFIG_SMP
1631         if (WARN_ON(desc->affinity_notify))
1632                 desc->affinity_notify = NULL;
1633 #endif
1634
1635         action = __free_irq(irq, dev_id);
1636         devname = action->name;
1637         kfree(action);
1638         return devname;
1639 }
1640 EXPORT_SYMBOL(free_irq);
1641
1642 /**
1643  *      request_threaded_irq - allocate an interrupt line
1644  *      @irq: Interrupt line to allocate
1645  *      @handler: Function to be called when the IRQ occurs.
1646  *                Primary handler for threaded interrupts
1647  *                If NULL and thread_fn != NULL the default
1648  *                primary handler is installed
1649  *      @thread_fn: Function called from the irq handler thread
1650  *                  If NULL, no irq thread is created
1651  *      @irqflags: Interrupt type flags
1652  *      @devname: An ascii name for the claiming device
1653  *      @dev_id: A cookie passed back to the handler function
1654  *
1655  *      This call allocates interrupt resources and enables the
1656  *      interrupt line and IRQ handling. From the point this
1657  *      call is made your handler function may be invoked. Since
1658  *      your handler function must clear any interrupt the board
1659  *      raises, you must take care both to initialise your hardware
1660  *      and to set up the interrupt handler in the right order.
1661  *
1662  *      If you want to set up a threaded irq handler for your device
1663  *      then you need to supply @handler and @thread_fn. @handler is
1664  *      still called in hard interrupt context and has to check
1665  *      whether the interrupt originates from the device. If yes it
1666  *      needs to disable the interrupt on the device and return
1667  *      IRQ_WAKE_THREAD which will wake up the handler thread and run
1668  *      @thread_fn. This split handler design is necessary to support
1669  *      shared interrupts.
1670  *
1671  *      Dev_id must be globally unique. Normally the address of the
1672  *      device data structure is used as the cookie. Since the handler
1673  *      receives this value it makes sense to use it.
1674  *
1675  *      If your interrupt is shared you must pass a non NULL dev_id
1676  *      as this is required when freeing the interrupt.
1677  *
1678  *      Flags:
1679  *
1680  *      IRQF_SHARED             Interrupt is shared
1681  *      IRQF_TRIGGER_*          Specify active edge(s) or level
1682  *
1683  */
1684 int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1685                          irq_handler_t thread_fn, unsigned long irqflags,
1686                          const char *devname, void *dev_id)
1687 {
1688         struct irqaction *action;
1689         struct irq_desc *desc;
1690         int retval;
1691
1692         if (irq == IRQ_NOTCONNECTED)
1693                 return -ENOTCONN;
1694
1695         /*
1696          * Sanity-check: shared interrupts must pass in a real dev-ID,
1697          * otherwise we'll have trouble later trying to figure out
1698          * which interrupt is which (messes up the interrupt freeing
1699          * logic etc).
1700          *
1701          * Also IRQF_COND_SUSPEND only makes sense for shared interrupts and
1702          * it cannot be set along with IRQF_NO_SUSPEND.
1703          */
1704         if (((irqflags & IRQF_SHARED) && !dev_id) ||
1705             (!(irqflags & IRQF_SHARED) && (irqflags & IRQF_COND_SUSPEND)) ||
1706             ((irqflags & IRQF_NO_SUSPEND) && (irqflags & IRQF_COND_SUSPEND)))
1707                 return -EINVAL;
1708
1709         desc = irq_to_desc(irq);
1710         if (!desc)
1711                 return -EINVAL;
1712
1713         if (!irq_settings_can_request(desc) ||
1714             WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1715                 return -EINVAL;
1716
1717         if (!handler) {
1718                 if (!thread_fn)
1719                         return -EINVAL;
1720                 handler = irq_default_primary_handler;
1721         }
1722
1723         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1724         if (!action)
1725                 return -ENOMEM;
1726
1727         action->handler = handler;
1728         action->thread_fn = thread_fn;
1729         action->flags = irqflags;
1730         action->name = devname;
1731         action->dev_id = dev_id;
1732
1733         retval = irq_chip_pm_get(&desc->irq_data);
1734         if (retval < 0) {
1735                 kfree(action);
1736                 return retval;
1737         }
1738
1739         retval = __setup_irq(irq, desc, action);
1740
1741         if (retval) {
1742                 irq_chip_pm_put(&desc->irq_data);
1743                 kfree(action->secondary);
1744                 kfree(action);
1745         }
1746
1747 #ifdef CONFIG_DEBUG_SHIRQ_FIXME
1748         if (!retval && (irqflags & IRQF_SHARED)) {
1749                 /*
1750                  * It's a shared IRQ -- the driver ought to be prepared for it
1751                  * to happen immediately, so let's make sure....
1752                  * We disable the irq to make sure that a 'real' IRQ doesn't
1753                  * run in parallel with our fake.
1754                  */
1755                 unsigned long flags;
1756
1757                 disable_irq(irq);
1758                 local_irq_save(flags);
1759
1760                 handler(irq, dev_id);
1761
1762                 local_irq_restore(flags);
1763                 enable_irq(irq);
1764         }
1765 #endif
1766         return retval;
1767 }
1768 EXPORT_SYMBOL(request_threaded_irq);
1769
1770 /**
1771  *      request_any_context_irq - allocate an interrupt line
1772  *      @irq: Interrupt line to allocate
1773  *      @handler: Function to be called when the IRQ occurs.
1774  *                Threaded handler for threaded interrupts.
1775  *      @flags: Interrupt type flags
1776  *      @name: An ascii name for the claiming device
1777  *      @dev_id: A cookie passed back to the handler function
1778  *
1779  *      This call allocates interrupt resources and enables the
1780  *      interrupt line and IRQ handling. It selects either a
1781  *      hardirq or threaded handling method depending on the
1782  *      context.
1783  *
1784  *      On failure, it returns a negative value. On success,
1785  *      it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
1786  */
1787 int request_any_context_irq(unsigned int irq, irq_handler_t handler,
1788                             unsigned long flags, const char *name, void *dev_id)
1789 {
1790         struct irq_desc *desc;
1791         int ret;
1792
1793         if (irq == IRQ_NOTCONNECTED)
1794                 return -ENOTCONN;
1795
1796         desc = irq_to_desc(irq);
1797         if (!desc)
1798                 return -EINVAL;
1799
1800         if (irq_settings_is_nested_thread(desc)) {
1801                 ret = request_threaded_irq(irq, NULL, handler,
1802                                            flags, name, dev_id);
1803                 return !ret ? IRQC_IS_NESTED : ret;
1804         }
1805
1806         ret = request_irq(irq, handler, flags, name, dev_id);
1807         return !ret ? IRQC_IS_HARDIRQ : ret;
1808 }
1809 EXPORT_SYMBOL_GPL(request_any_context_irq);
1810
1811 void enable_percpu_irq(unsigned int irq, unsigned int type)
1812 {
1813         unsigned int cpu = smp_processor_id();
1814         unsigned long flags;
1815         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1816
1817         if (!desc)
1818                 return;
1819
1820         /*
1821          * If the trigger type is not specified by the caller, then
1822          * use the default for this interrupt.
1823          */
1824         type &= IRQ_TYPE_SENSE_MASK;
1825         if (type == IRQ_TYPE_NONE)
1826                 type = irqd_get_trigger_type(&desc->irq_data);
1827
1828         if (type != IRQ_TYPE_NONE) {
1829                 int ret;
1830
1831                 ret = __irq_set_trigger(desc, type);
1832
1833                 if (ret) {
1834                         WARN(1, "failed to set type for IRQ%d\n", irq);
1835                         goto out;
1836                 }
1837         }
1838
1839         irq_percpu_enable(desc, cpu);
1840 out:
1841         irq_put_desc_unlock(desc, flags);
1842 }
1843 EXPORT_SYMBOL_GPL(enable_percpu_irq);
1844
1845 /**
1846  * irq_percpu_is_enabled - Check whether the per cpu irq is enabled
1847  * @irq:        Linux irq number to check for
1848  *
1849  * Must be called from a non migratable context. Returns the enable
1850  * state of a per cpu interrupt on the current cpu.
1851  */
1852 bool irq_percpu_is_enabled(unsigned int irq)
1853 {
1854         unsigned int cpu = smp_processor_id();
1855         struct irq_desc *desc;
1856         unsigned long flags;
1857         bool is_enabled;
1858
1859         desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1860         if (!desc)
1861                 return false;
1862
1863         is_enabled = cpumask_test_cpu(cpu, desc->percpu_enabled);
1864         irq_put_desc_unlock(desc, flags);
1865
1866         return is_enabled;
1867 }
1868 EXPORT_SYMBOL_GPL(irq_percpu_is_enabled);
1869
1870 void disable_percpu_irq(unsigned int irq)
1871 {
1872         unsigned int cpu = smp_processor_id();
1873         unsigned long flags;
1874         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1875
1876         if (!desc)
1877                 return;
1878
1879         irq_percpu_disable(desc, cpu);
1880         irq_put_desc_unlock(desc, flags);
1881 }
1882 EXPORT_SYMBOL_GPL(disable_percpu_irq);
1883
1884 /*
1885  * Internal function to unregister a percpu irqaction.
1886  */
1887 static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1888 {
1889         struct irq_desc *desc = irq_to_desc(irq);
1890         struct irqaction *action;
1891         unsigned long flags;
1892
1893         WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1894
1895         if (!desc)
1896                 return NULL;
1897
1898         raw_spin_lock_irqsave(&desc->lock, flags);
1899
1900         action = desc->action;
1901         if (!action || action->percpu_dev_id != dev_id) {
1902                 WARN(1, "Trying to free already-free IRQ %d\n", irq);
1903                 goto bad;
1904         }
1905
1906         if (!cpumask_empty(desc->percpu_enabled)) {
1907                 WARN(1, "percpu IRQ %d still enabled on CPU%d!\n",
1908                      irq, cpumask_first(desc->percpu_enabled));
1909                 goto bad;
1910         }
1911
1912         /* Found it - now remove it from the list of entries: */
1913         desc->action = NULL;
1914
1915         raw_spin_unlock_irqrestore(&desc->lock, flags);
1916
1917         unregister_handler_proc(irq, action);
1918
1919         irq_chip_pm_put(&desc->irq_data);
1920         module_put(desc->owner);
1921         return action;
1922
1923 bad:
1924         raw_spin_unlock_irqrestore(&desc->lock, flags);
1925         return NULL;
1926 }
1927
1928 /**
1929  *      remove_percpu_irq - free a per-cpu interrupt
1930  *      @irq: Interrupt line to free
1931  *      @act: irqaction for the interrupt
1932  *
1933  * Used to remove interrupts statically setup by the early boot process.
1934  */
1935 void remove_percpu_irq(unsigned int irq, struct irqaction *act)
1936 {
1937         struct irq_desc *desc = irq_to_desc(irq);
1938
1939         if (desc && irq_settings_is_per_cpu_devid(desc))
1940             __free_percpu_irq(irq, act->percpu_dev_id);
1941 }
1942
1943 /**
1944  *      free_percpu_irq - free an interrupt allocated with request_percpu_irq
1945  *      @irq: Interrupt line to free
1946  *      @dev_id: Device identity to free
1947  *
1948  *      Remove a percpu interrupt handler. The handler is removed, but
1949  *      the interrupt line is not disabled. This must be done on each
1950  *      CPU before calling this function. The function does not return
1951  *      until any executing interrupts for this IRQ have completed.
1952  *
1953  *      This function must not be called from interrupt context.
1954  */
1955 void free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1956 {
1957         struct irq_desc *desc = irq_to_desc(irq);
1958
1959         if (!desc || !irq_settings_is_per_cpu_devid(desc))
1960                 return;
1961
1962         chip_bus_lock(desc);
1963         kfree(__free_percpu_irq(irq, dev_id));
1964         chip_bus_sync_unlock(desc);
1965 }
1966 EXPORT_SYMBOL_GPL(free_percpu_irq);
1967
1968 /**
1969  *      setup_percpu_irq - setup a per-cpu interrupt
1970  *      @irq: Interrupt line to setup
1971  *      @act: irqaction for the interrupt
1972  *
1973  * Used to statically setup per-cpu interrupts in the early boot process.
1974  */
1975 int setup_percpu_irq(unsigned int irq, struct irqaction *act)
1976 {
1977         struct irq_desc *desc = irq_to_desc(irq);
1978         int retval;
1979
1980         if (!desc || !irq_settings_is_per_cpu_devid(desc))
1981                 return -EINVAL;
1982
1983         retval = irq_chip_pm_get(&desc->irq_data);
1984         if (retval < 0)
1985                 return retval;
1986
1987         retval = __setup_irq(irq, desc, act);
1988
1989         if (retval)
1990                 irq_chip_pm_put(&desc->irq_data);
1991
1992         return retval;
1993 }
1994
1995 /**
1996  *      __request_percpu_irq - allocate a percpu interrupt line
1997  *      @irq: Interrupt line to allocate
1998  *      @handler: Function to be called when the IRQ occurs.
1999  *      @flags: Interrupt type flags (IRQF_TIMER only)
2000  *      @devname: An ascii name for the claiming device
2001  *      @dev_id: A percpu cookie passed back to the handler function
2002  *
2003  *      This call allocates interrupt resources and enables the
2004  *      interrupt on the local CPU. If the interrupt is supposed to be
2005  *      enabled on other CPUs, it has to be done on each CPU using
2006  *      enable_percpu_irq().
2007  *
2008  *      Dev_id must be globally unique. It is a per-cpu variable, and
2009  *      the handler gets called with the interrupted CPU's instance of
2010  *      that variable.
2011  */
2012 int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
2013                          unsigned long flags, const char *devname,
2014                          void __percpu *dev_id)
2015 {
2016         struct irqaction *action;
2017         struct irq_desc *desc;
2018         int retval;
2019
2020         if (!dev_id)
2021                 return -EINVAL;
2022
2023         desc = irq_to_desc(irq);
2024         if (!desc || !irq_settings_can_request(desc) ||
2025             !irq_settings_is_per_cpu_devid(desc))
2026                 return -EINVAL;
2027
2028         if (flags && flags != IRQF_TIMER)
2029                 return -EINVAL;
2030
2031         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
2032         if (!action)
2033                 return -ENOMEM;
2034
2035         action->handler = handler;
2036         action->flags = flags | IRQF_PERCPU | IRQF_NO_SUSPEND;
2037         action->name = devname;
2038         action->percpu_dev_id = dev_id;
2039
2040         retval = irq_chip_pm_get(&desc->irq_data);
2041         if (retval < 0) {
2042                 kfree(action);
2043                 return retval;
2044         }
2045
2046         retval = __setup_irq(irq, desc, action);
2047
2048         if (retval) {
2049                 irq_chip_pm_put(&desc->irq_data);
2050                 kfree(action);
2051         }
2052
2053         return retval;
2054 }
2055 EXPORT_SYMBOL_GPL(__request_percpu_irq);
2056
2057 /**
2058  *      irq_get_irqchip_state - returns the irqchip state of a interrupt.
2059  *      @irq: Interrupt line that is forwarded to a VM
2060  *      @which: One of IRQCHIP_STATE_* the caller wants to know about
2061  *      @state: a pointer to a boolean where the state is to be storeed
2062  *
2063  *      This call snapshots the internal irqchip state of an
2064  *      interrupt, returning into @state the bit corresponding to
2065  *      stage @which
2066  *
2067  *      This function should be called with preemption disabled if the
2068  *      interrupt controller has per-cpu registers.
2069  */
2070 int irq_get_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
2071                           bool *state)
2072 {
2073         struct irq_desc *desc;
2074         struct irq_data *data;
2075         struct irq_chip *chip;
2076         unsigned long flags;
2077         int err = -EINVAL;
2078
2079         desc = irq_get_desc_buslock(irq, &flags, 0);
2080         if (!desc)
2081                 return err;
2082
2083         data = irq_desc_get_irq_data(desc);
2084
2085         do {
2086                 chip = irq_data_get_irq_chip(data);
2087                 if (chip->irq_get_irqchip_state)
2088                         break;
2089 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
2090                 data = data->parent_data;
2091 #else
2092                 data = NULL;
2093 #endif
2094         } while (data);
2095
2096         if (data)
2097                 err = chip->irq_get_irqchip_state(data, which, state);
2098
2099         irq_put_desc_busunlock(desc, flags);
2100         return err;
2101 }
2102 EXPORT_SYMBOL_GPL(irq_get_irqchip_state);
2103
2104 /**
2105  *      irq_set_irqchip_state - set the state of a forwarded interrupt.
2106  *      @irq: Interrupt line that is forwarded to a VM
2107  *      @which: State to be restored (one of IRQCHIP_STATE_*)
2108  *      @val: Value corresponding to @which
2109  *
2110  *      This call sets the internal irqchip state of an interrupt,
2111  *      depending on the value of @which.
2112  *
2113  *      This function should be called with preemption disabled if the
2114  *      interrupt controller has per-cpu registers.
2115  */
2116 int irq_set_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
2117                           bool val)
2118 {
2119         struct irq_desc *desc;
2120         struct irq_data *data;
2121         struct irq_chip *chip;
2122         unsigned long flags;
2123         int err = -EINVAL;
2124
2125         desc = irq_get_desc_buslock(irq, &flags, 0);
2126         if (!desc)
2127                 return err;
2128
2129         data = irq_desc_get_irq_data(desc);
2130
2131         do {
2132                 chip = irq_data_get_irq_chip(data);
2133                 if (chip->irq_set_irqchip_state)
2134                         break;
2135 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
2136                 data = data->parent_data;
2137 #else
2138                 data = NULL;
2139 #endif
2140         } while (data);
2141
2142         if (data)
2143                 err = chip->irq_set_irqchip_state(data, which, val);
2144
2145         irq_put_desc_busunlock(desc, flags);
2146         return err;
2147 }
2148 EXPORT_SYMBOL_GPL(irq_set_irqchip_state);