1
2#ifndef _LINUX_INTERRUPT_H
3#define _LINUX_INTERRUPT_H
4
5#include <linux/kernel.h>
6#include <linux/linkage.h>
7#include <linux/bitops.h>
8#include <linux/preempt.h>
9#include <linux/cpumask.h>
10#include <linux/irqreturn.h>
11#include <linux/irqnr.h>
12#include <linux/hardirq.h>
13#include <linux/irqflags.h>
14#include <linux/hrtimer.h>
15#include <linux/kref.h>
16#include <linux/workqueue.h>
17
18#include <linux/atomic.h>
19#include <asm/ptrace.h>
20#include <asm/irq.h>
21
22
23
24
25
26
27
28
29#define IRQF_TRIGGER_NONE 0x00000000
30#define IRQF_TRIGGER_RISING 0x00000001
31#define IRQF_TRIGGER_FALLING 0x00000002
32#define IRQF_TRIGGER_HIGH 0x00000004
33#define IRQF_TRIGGER_LOW 0x00000008
34#define IRQF_TRIGGER_MASK (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
35 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
36#define IRQF_TRIGGER_PROBE 0x00000010
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65#define IRQF_SHARED 0x00000080
66#define IRQF_PROBE_SHARED 0x00000100
67#define __IRQF_TIMER 0x00000200
68#define IRQF_PERCPU 0x00000400
69#define IRQF_NOBALANCING 0x00000800
70#define IRQF_IRQPOLL 0x00001000
71#define IRQF_ONESHOT 0x00002000
72#define IRQF_NO_SUSPEND 0x00004000
73#define IRQF_FORCE_RESUME 0x00008000
74#define IRQF_NO_THREAD 0x00010000
75#define IRQF_EARLY_RESUME 0x00020000
76#define IRQF_COND_SUSPEND 0x00040000
77
78#define IRQF_TIMER (__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD)
79
80
81
82
83
84
85
86
87enum {
88 IRQC_IS_HARDIRQ = 0,
89 IRQC_IS_NESTED,
90};
91
92typedef irqreturn_t (*irq_handler_t)(int, void *);
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110struct irqaction {
111 irq_handler_t handler;
112 void *dev_id;
113 void __percpu *percpu_dev_id;
114 struct irqaction *next;
115 irq_handler_t thread_fn;
116 struct task_struct *thread;
117 struct irqaction *secondary;
118 unsigned int irq;
119 unsigned int flags;
120 unsigned long thread_flags;
121 unsigned long thread_mask;
122 const char *name;
123 struct proc_dir_entry *dir;
124} ____cacheline_internodealigned_in_smp;
125
126extern irqreturn_t no_action(int cpl, void *dev_id);
127
128
129
130
131
132
133
134
135
136#define IRQ_NOTCONNECTED (1U << 31)
137
138extern int __must_check
139request_threaded_irq(unsigned int irq, irq_handler_t handler,
140 irq_handler_t thread_fn,
141 unsigned long flags, const char *name, void *dev);
142
143static inline int __must_check
144request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
145 const char *name, void *dev)
146{
147 return request_threaded_irq(irq, handler, NULL, flags, name, dev);
148}
149
150extern int __must_check
151request_any_context_irq(unsigned int irq, irq_handler_t handler,
152 unsigned long flags, const char *name, void *dev_id);
153
154extern int __must_check
155request_percpu_irq(unsigned int irq, irq_handler_t handler,
156 const char *devname, void __percpu *percpu_dev_id);
157
158extern void free_irq(unsigned int, void *);
159extern void free_percpu_irq(unsigned int, void __percpu *);
160
161struct device;
162
163extern int __must_check
164devm_request_threaded_irq(struct device *dev, unsigned int irq,
165 irq_handler_t handler, irq_handler_t thread_fn,
166 unsigned long irqflags, const char *devname,
167 void *dev_id);
168
169static inline int __must_check
170devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
171 unsigned long irqflags, const char *devname, void *dev_id)
172{
173 return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
174 devname, dev_id);
175}
176
177extern int __must_check
178devm_request_any_context_irq(struct device *dev, unsigned int irq,
179 irq_handler_t handler, unsigned long irqflags,
180 const char *devname, void *dev_id);
181
182extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
183
184
185
186
187
188
189
190
191
192
193
194
195
196#ifdef CONFIG_LOCKDEP
197# define local_irq_enable_in_hardirq() do { } while (0)
198#else
199# define local_irq_enable_in_hardirq() local_irq_enable()
200#endif
201
202extern void disable_irq_nosync(unsigned int irq);
203extern bool disable_hardirq(unsigned int irq);
204extern void disable_irq(unsigned int irq);
205extern void disable_percpu_irq(unsigned int irq);
206extern void enable_irq(unsigned int irq);
207extern void enable_percpu_irq(unsigned int irq, unsigned int type);
208extern bool irq_percpu_is_enabled(unsigned int irq);
209extern void irq_wake_thread(unsigned int irq, void *dev_id);
210
211
212extern void suspend_device_irqs(void);
213extern void resume_device_irqs(void);
214
215
216
217
218
219
220
221
222
223
224
225
226
227struct irq_affinity_notify {
228 unsigned int irq;
229 struct kref kref;
230 struct work_struct work;
231 void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask);
232 void (*release)(struct kref *ref);
233};
234
235#if defined(CONFIG_SMP)
236
237extern cpumask_var_t irq_default_affinity;
238
239
240extern int __irq_set_affinity(unsigned int irq, const struct cpumask *cpumask,
241 bool force);
242
243
244
245
246
247
248
249
250static inline int
251irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
252{
253 return __irq_set_affinity(irq, cpumask, false);
254}
255
256
257
258
259
260
261
262
263
264
265
266
267static inline int
268irq_force_affinity(unsigned int irq, const struct cpumask *cpumask)
269{
270 return __irq_set_affinity(irq, cpumask, true);
271}
272
273extern int irq_can_set_affinity(unsigned int irq);
274extern int irq_select_affinity(unsigned int irq);
275
276extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
277
278extern int
279irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
280
281#else
282
283static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m)
284{
285 return -EINVAL;
286}
287
288static inline int irq_force_affinity(unsigned int irq, const struct cpumask *cpumask)
289{
290 return 0;
291}
292
293static inline int irq_can_set_affinity(unsigned int irq)
294{
295 return 0;
296}
297
298static inline int irq_select_affinity(unsigned int irq) { return 0; }
299
300static inline int irq_set_affinity_hint(unsigned int irq,
301 const struct cpumask *m)
302{
303 return -EINVAL;
304}
305
306static inline int
307irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
308{
309 return 0;
310}
311#endif
312
313
314
315
316
317
318
319
320
321
322
323
324static inline void disable_irq_nosync_lockdep(unsigned int irq)
325{
326 disable_irq_nosync(irq);
327#ifdef CONFIG_LOCKDEP
328 local_irq_disable();
329#endif
330}
331
332static inline void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
333{
334 disable_irq_nosync(irq);
335#ifdef CONFIG_LOCKDEP
336 local_irq_save(*flags);
337#endif
338}
339
340static inline void disable_irq_lockdep(unsigned int irq)
341{
342 disable_irq(irq);
343#ifdef CONFIG_LOCKDEP
344 local_irq_disable();
345#endif
346}
347
348static inline void enable_irq_lockdep(unsigned int irq)
349{
350#ifdef CONFIG_LOCKDEP
351 local_irq_enable();
352#endif
353 enable_irq(irq);
354}
355
356static inline void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
357{
358#ifdef CONFIG_LOCKDEP
359 local_irq_restore(*flags);
360#endif
361 enable_irq(irq);
362}
363
364
365extern int irq_set_irq_wake(unsigned int irq, unsigned int on);
366
367static inline int enable_irq_wake(unsigned int irq)
368{
369 return irq_set_irq_wake(irq, 1);
370}
371
372static inline int disable_irq_wake(unsigned int irq)
373{
374 return irq_set_irq_wake(irq, 0);
375}
376
377
378
379
380enum irqchip_irq_state {
381 IRQCHIP_STATE_PENDING,
382 IRQCHIP_STATE_ACTIVE,
383 IRQCHIP_STATE_MASKED,
384 IRQCHIP_STATE_LINE_LEVEL,
385};
386
387extern int irq_get_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
388 bool *state);
389extern int irq_set_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
390 bool state);
391
392#ifdef CONFIG_IRQ_FORCED_THREADING
393extern bool force_irqthreads;
394#else
395#define force_irqthreads (0)
396#endif
397
398#ifndef __ARCH_SET_SOFTIRQ_PENDING
399#define set_softirq_pending(x) (local_softirq_pending() = (x))
400#define or_softirq_pending(x) (local_softirq_pending() |= (x))
401#endif
402
403
404
405
406
407
408
409#ifndef hard_irq_disable
410#define hard_irq_disable() do { } while(0)
411#endif
412
413
414
415
416
417
418
419enum
420{
421 HI_SOFTIRQ=0,
422 TIMER_SOFTIRQ,
423 NET_TX_SOFTIRQ,
424 NET_RX_SOFTIRQ,
425 BLOCK_SOFTIRQ,
426 IRQ_POLL_SOFTIRQ,
427 TASKLET_SOFTIRQ,
428 SCHED_SOFTIRQ,
429 HRTIMER_SOFTIRQ,
430
431 RCU_SOFTIRQ,
432
433 NR_SOFTIRQS
434};
435
436#define SOFTIRQ_STOP_IDLE_MASK (~(1 << RCU_SOFTIRQ))
437
438
439
440
441extern const char * const softirq_to_name[NR_SOFTIRQS];
442
443
444
445
446
447struct softirq_action
448{
449 void (*action)(struct softirq_action *);
450};
451
452asmlinkage void do_softirq(void);
453asmlinkage void __do_softirq(void);
454
455#ifdef __ARCH_HAS_DO_SOFTIRQ
456void do_softirq_own_stack(void);
457#else
458static inline void do_softirq_own_stack(void)
459{
460 __do_softirq();
461}
462#endif
463
464extern void open_softirq(int nr, void (*action)(struct softirq_action *));
465extern void softirq_init(void);
466extern void __raise_softirq_irqoff(unsigned int nr);
467
468extern void raise_softirq_irqoff(unsigned int nr);
469extern void raise_softirq(unsigned int nr);
470
471DECLARE_PER_CPU(struct task_struct *, ksoftirqd);
472
473static inline struct task_struct *this_cpu_ksoftirqd(void)
474{
475 return this_cpu_read(ksoftirqd);
476}
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498struct tasklet_struct
499{
500 struct tasklet_struct *next;
501 unsigned long state;
502 atomic_t count;
503 void (*func)(unsigned long);
504 unsigned long data;
505};
506
507#define DECLARE_TASKLET(name, func, data) \
508struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
509
510#define DECLARE_TASKLET_DISABLED(name, func, data) \
511struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
512
513
514enum
515{
516 TASKLET_STATE_SCHED,
517 TASKLET_STATE_RUN
518};
519
520#ifdef CONFIG_SMP
521static inline int tasklet_trylock(struct tasklet_struct *t)
522{
523 return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
524}
525
526static inline void tasklet_unlock(struct tasklet_struct *t)
527{
528 smp_mb__before_atomic();
529 clear_bit(TASKLET_STATE_RUN, &(t)->state);
530}
531
532static inline void tasklet_unlock_wait(struct tasklet_struct *t)
533{
534 while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
535}
536#else
537#define tasklet_trylock(t) 1
538#define tasklet_unlock_wait(t) do { } while (0)
539#define tasklet_unlock(t) do { } while (0)
540#endif
541
542extern void __tasklet_schedule(struct tasklet_struct *t);
543
544static inline void tasklet_schedule(struct tasklet_struct *t)
545{
546 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
547 __tasklet_schedule(t);
548}
549
550extern void __tasklet_hi_schedule(struct tasklet_struct *t);
551
552static inline void tasklet_hi_schedule(struct tasklet_struct *t)
553{
554 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
555 __tasklet_hi_schedule(t);
556}
557
558extern void __tasklet_hi_schedule_first(struct tasklet_struct *t);
559
560
561
562
563
564
565
566static inline void tasklet_hi_schedule_first(struct tasklet_struct *t)
567{
568 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
569 __tasklet_hi_schedule_first(t);
570}
571
572
573static inline void tasklet_disable_nosync(struct tasklet_struct *t)
574{
575 atomic_inc(&t->count);
576 smp_mb__after_atomic();
577}
578
579static inline void tasklet_disable(struct tasklet_struct *t)
580{
581 tasklet_disable_nosync(t);
582 tasklet_unlock_wait(t);
583 smp_mb();
584}
585
586static inline void tasklet_enable(struct tasklet_struct *t)
587{
588 smp_mb__before_atomic();
589 atomic_dec(&t->count);
590}
591
592extern void tasklet_kill(struct tasklet_struct *t);
593extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
594extern void tasklet_init(struct tasklet_struct *t,
595 void (*func)(unsigned long), unsigned long data);
596
597struct tasklet_hrtimer {
598 struct hrtimer timer;
599 struct tasklet_struct tasklet;
600 enum hrtimer_restart (*function)(struct hrtimer *);
601};
602
603extern void
604tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
605 enum hrtimer_restart (*function)(struct hrtimer *),
606 clockid_t which_clock, enum hrtimer_mode mode);
607
608static inline
609void tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
610 const enum hrtimer_mode mode)
611{
612 hrtimer_start(&ttimer->timer, time, mode);
613}
614
615static inline
616void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)
617{
618 hrtimer_cancel(&ttimer->timer);
619 tasklet_kill(&ttimer->tasklet);
620}
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650#if !defined(CONFIG_GENERIC_IRQ_PROBE)
651static inline unsigned long probe_irq_on(void)
652{
653 return 0;
654}
655static inline int probe_irq_off(unsigned long val)
656{
657 return 0;
658}
659static inline unsigned int probe_irq_mask(unsigned long val)
660{
661 return 0;
662}
663#else
664extern unsigned long probe_irq_on(void);
665extern int probe_irq_off(unsigned long);
666extern unsigned int probe_irq_mask(unsigned long);
667#endif
668
669#ifdef CONFIG_PROC_FS
670
671extern void init_irq_proc(void);
672#else
673static inline void init_irq_proc(void)
674{
675}
676#endif
677
678struct seq_file;
679int show_interrupts(struct seq_file *p, void *v);
680int arch_show_interrupts(struct seq_file *p, int prec);
681
682extern int early_irq_init(void);
683extern int arch_probe_nr_irqs(void);
684extern int arch_early_irq_init(void);
685
686#if defined(CONFIG_FUNCTION_GRAPH_TRACER) || defined(CONFIG_KASAN)
687
688
689
690#define __irq_entry __attribute__((__section__(".irqentry.text")))
691#define __softirq_entry \
692 __attribute__((__section__(".softirqentry.text")))
693
694
695extern char __irqentry_text_start[];
696extern char __irqentry_text_end[];
697
698extern char __softirqentry_text_start[];
699extern char __softirqentry_text_end[];
700
701#else
702#define __irq_entry
703#define __softirq_entry
704#endif
705
706#endif
707