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
123extern int __must_check
124request_threaded_irq(unsigned int irq, irq_handler_t handler,
125 irq_handler_t thread_fn,
126 unsigned long flags, const char *name, void *dev);
127
128static inline int __must_check
129request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
130 const char *name, void *dev)
131{
132 return request_threaded_irq(irq, handler, NULL, flags, name, dev);
133}
134
135extern int __must_check
136request_any_context_irq(unsigned int irq, irq_handler_t handler,
137 unsigned long flags, const char *name, void *dev_id);
138
139extern int __must_check
140request_percpu_irq(unsigned int irq, irq_handler_t handler,
141 const char *devname, void __percpu *percpu_dev_id);
142
143extern void free_irq(unsigned int, void *);
144extern void free_percpu_irq(unsigned int, void __percpu *);
145
146struct device;
147
148extern int __must_check
149devm_request_threaded_irq(struct device *dev, unsigned int irq,
150 irq_handler_t handler, irq_handler_t thread_fn,
151 unsigned long irqflags, const char *devname,
152 void *dev_id);
153
154static inline int __must_check
155devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
156 unsigned long irqflags, const char *devname, void *dev_id)
157{
158 return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
159 devname, dev_id);
160}
161
162extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
163
164
165
166
167
168
169
170
171
172
173
174
175
176#ifdef CONFIG_LOCKDEP
177# define local_irq_enable_in_hardirq() do { } while (0)
178#else
179# define local_irq_enable_in_hardirq() local_irq_enable()
180#endif
181
182extern void disable_irq_nosync(unsigned int irq);
183extern void disable_irq(unsigned int irq);
184extern void disable_percpu_irq(unsigned int irq);
185extern void enable_irq(unsigned int irq);
186extern void enable_percpu_irq(unsigned int irq, unsigned int type);
187
188
189extern void suspend_device_irqs(void);
190extern void resume_device_irqs(void);
191#ifdef CONFIG_PM_SLEEP
192extern int check_wakeup_irqs(void);
193#else
194static inline int check_wakeup_irqs(void) { return 0; }
195#endif
196
197#if defined(CONFIG_SMP)
198
199extern cpumask_var_t irq_default_affinity;
200
201extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
202extern int irq_can_set_affinity(unsigned int irq);
203extern int irq_select_affinity(unsigned int irq);
204
205extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
206
207
208
209
210
211
212
213
214
215
216
217
218
219struct irq_affinity_notify {
220 unsigned int irq;
221 struct kref kref;
222 struct work_struct work;
223 void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask);
224 void (*release)(struct kref *ref);
225};
226
227extern int
228irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
229
230#else
231
232static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m)
233{
234 return -EINVAL;
235}
236
237static inline int irq_can_set_affinity(unsigned int irq)
238{
239 return 0;
240}
241
242static inline int irq_select_affinity(unsigned int irq) { return 0; }
243
244static inline int irq_set_affinity_hint(unsigned int irq,
245 const struct cpumask *m)
246{
247 return -EINVAL;
248}
249#endif
250
251
252
253
254
255
256
257
258
259
260
261
262static inline void disable_irq_nosync_lockdep(unsigned int irq)
263{
264 disable_irq_nosync(irq);
265#ifdef CONFIG_LOCKDEP
266 local_irq_disable();
267#endif
268}
269
270static inline void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
271{
272 disable_irq_nosync(irq);
273#ifdef CONFIG_LOCKDEP
274 local_irq_save(*flags);
275#endif
276}
277
278static inline void disable_irq_lockdep(unsigned int irq)
279{
280 disable_irq(irq);
281#ifdef CONFIG_LOCKDEP
282 local_irq_disable();
283#endif
284}
285
286static inline void enable_irq_lockdep(unsigned int irq)
287{
288#ifdef CONFIG_LOCKDEP
289 local_irq_enable();
290#endif
291 enable_irq(irq);
292}
293
294static inline void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
295{
296#ifdef CONFIG_LOCKDEP
297 local_irq_restore(*flags);
298#endif
299 enable_irq(irq);
300}
301
302
303extern int irq_set_irq_wake(unsigned int irq, unsigned int on);
304
305static inline int enable_irq_wake(unsigned int irq)
306{
307 return irq_set_irq_wake(irq, 1);
308}
309
310static inline int disable_irq_wake(unsigned int irq)
311{
312 return irq_set_irq_wake(irq, 0);
313}
314
315
316#ifdef CONFIG_IRQ_FORCED_THREADING
317extern bool force_irqthreads;
318#else
319#define force_irqthreads (0)
320#endif
321
322#ifndef __ARCH_SET_SOFTIRQ_PENDING
323#define set_softirq_pending(x) (local_softirq_pending() = (x))
324#define or_softirq_pending(x) (local_softirq_pending() |= (x))
325#endif
326
327
328
329
330
331
332
333#ifndef hard_irq_disable
334#define hard_irq_disable() do { } while(0)
335#endif
336
337
338
339
340
341
342
343enum
344{
345 HI_SOFTIRQ=0,
346 TIMER_SOFTIRQ,
347 NET_TX_SOFTIRQ,
348 NET_RX_SOFTIRQ,
349 BLOCK_SOFTIRQ,
350 BLOCK_IOPOLL_SOFTIRQ,
351 TASKLET_SOFTIRQ,
352 SCHED_SOFTIRQ,
353 HRTIMER_SOFTIRQ,
354 RCU_SOFTIRQ,
355
356 NR_SOFTIRQS
357};
358
359#define SOFTIRQ_STOP_IDLE_MASK (~(1 << RCU_SOFTIRQ))
360
361
362
363
364extern char *softirq_to_name[NR_SOFTIRQS];
365
366
367
368
369
370struct softirq_action
371{
372 void (*action)(struct softirq_action *);
373};
374
375asmlinkage void do_softirq(void);
376asmlinkage void __do_softirq(void);
377extern void open_softirq(int nr, void (*action)(struct softirq_action *));
378extern void softirq_init(void);
379extern void __raise_softirq_irqoff(unsigned int nr);
380
381extern void raise_softirq_irqoff(unsigned int nr);
382extern void raise_softirq(unsigned int nr);
383
384
385
386
387
388
389
390
391DECLARE_PER_CPU(struct list_head [NR_SOFTIRQS], softirq_work_list);
392
393DECLARE_PER_CPU(struct task_struct *, ksoftirqd);
394
395static inline struct task_struct *this_cpu_ksoftirqd(void)
396{
397 return this_cpu_read(ksoftirqd);
398}
399
400
401
402
403extern void send_remote_softirq(struct call_single_data *cp, int cpu, int softirq);
404
405
406
407
408extern void __send_remote_softirq(struct call_single_data *cp, int cpu,
409 int this_cpu, int softirq);
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431struct tasklet_struct
432{
433 struct tasklet_struct *next;
434 unsigned long state;
435 atomic_t count;
436 void (*func)(unsigned long);
437 unsigned long data;
438};
439
440#define DECLARE_TASKLET(name, func, data) \
441struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
442
443#define DECLARE_TASKLET_DISABLED(name, func, data) \
444struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
445
446
447enum
448{
449 TASKLET_STATE_SCHED,
450 TASKLET_STATE_RUN
451};
452
453#ifdef CONFIG_SMP
454static inline int tasklet_trylock(struct tasklet_struct *t)
455{
456 return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
457}
458
459static inline void tasklet_unlock(struct tasklet_struct *t)
460{
461 smp_mb__before_clear_bit();
462 clear_bit(TASKLET_STATE_RUN, &(t)->state);
463}
464
465static inline void tasklet_unlock_wait(struct tasklet_struct *t)
466{
467 while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
468}
469#else
470#define tasklet_trylock(t) 1
471#define tasklet_unlock_wait(t) do { } while (0)
472#define tasklet_unlock(t) do { } while (0)
473#endif
474
475extern void __tasklet_schedule(struct tasklet_struct *t);
476
477static inline void tasklet_schedule(struct tasklet_struct *t)
478{
479 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
480 __tasklet_schedule(t);
481}
482
483extern void __tasklet_hi_schedule(struct tasklet_struct *t);
484
485static inline void tasklet_hi_schedule(struct tasklet_struct *t)
486{
487 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
488 __tasklet_hi_schedule(t);
489}
490
491extern void __tasklet_hi_schedule_first(struct tasklet_struct *t);
492
493
494
495
496
497
498
499static inline void tasklet_hi_schedule_first(struct tasklet_struct *t)
500{
501 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
502 __tasklet_hi_schedule_first(t);
503}
504
505
506static inline void tasklet_disable_nosync(struct tasklet_struct *t)
507{
508 atomic_inc(&t->count);
509 smp_mb__after_atomic_inc();
510}
511
512static inline void tasklet_disable(struct tasklet_struct *t)
513{
514 tasklet_disable_nosync(t);
515 tasklet_unlock_wait(t);
516 smp_mb();
517}
518
519static inline void tasklet_enable(struct tasklet_struct *t)
520{
521 smp_mb__before_atomic_dec();
522 atomic_dec(&t->count);
523}
524
525static inline void tasklet_hi_enable(struct tasklet_struct *t)
526{
527 smp_mb__before_atomic_dec();
528 atomic_dec(&t->count);
529}
530
531extern void tasklet_kill(struct tasklet_struct *t);
532extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
533extern void tasklet_init(struct tasklet_struct *t,
534 void (*func)(unsigned long), unsigned long data);
535
536struct tasklet_hrtimer {
537 struct hrtimer timer;
538 struct tasklet_struct tasklet;
539 enum hrtimer_restart (*function)(struct hrtimer *);
540};
541
542extern void
543tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
544 enum hrtimer_restart (*function)(struct hrtimer *),
545 clockid_t which_clock, enum hrtimer_mode mode);
546
547static inline
548int tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
549 const enum hrtimer_mode mode)
550{
551 return hrtimer_start(&ttimer->timer, time, mode);
552}
553
554static inline
555void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)
556{
557 hrtimer_cancel(&ttimer->timer);
558 tasklet_kill(&ttimer->tasklet);
559}
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589#if !defined(CONFIG_GENERIC_IRQ_PROBE)
590static inline unsigned long probe_irq_on(void)
591{
592 return 0;
593}
594static inline int probe_irq_off(unsigned long val)
595{
596 return 0;
597}
598static inline unsigned int probe_irq_mask(unsigned long val)
599{
600 return 0;
601}
602#else
603extern unsigned long probe_irq_on(void);
604extern int probe_irq_off(unsigned long);
605extern unsigned int probe_irq_mask(unsigned long);
606#endif
607
608#ifdef CONFIG_PROC_FS
609
610extern void init_irq_proc(void);
611#else
612static inline void init_irq_proc(void)
613{
614}
615#endif
616
617struct seq_file;
618int show_interrupts(struct seq_file *p, void *v);
619int arch_show_interrupts(struct seq_file *p, int prec);
620
621extern int early_irq_init(void);
622extern int arch_probe_nr_irqs(void);
623extern int arch_early_irq_init(void);
624
625#endif
626