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