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