1 | /* interrupt.h */ |
---|
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/hardirq.h> |
---|
12 | #include <linux/sched.h> |
---|
13 | #include <linux/irqflags.h> |
---|
14 | #include <asm/atomic.h> |
---|
15 | #include <asm/ptrace.h> |
---|
16 | #include <asm/system.h> |
---|
17 | |
---|
18 | /* |
---|
19 | * These correspond to the IORESOURCE_IRQ_* defines in |
---|
20 | * linux/ioport.h to select the interrupt line behaviour. When |
---|
21 | * requesting an interrupt without specifying a IRQF_TRIGGER, the |
---|
22 | * setting should be assumed to be "as already configured", which |
---|
23 | * may be as per machine or firmware initialisation. |
---|
24 | */ |
---|
25 | #define IRQF_TRIGGER_NONE 0x00000000 |
---|
26 | #define IRQF_TRIGGER_RISING 0x00000001 |
---|
27 | #define IRQF_TRIGGER_FALLING 0x00000002 |
---|
28 | #define IRQF_TRIGGER_HIGH 0x00000004 |
---|
29 | #define IRQF_TRIGGER_LOW 0x00000008 |
---|
30 | #define IRQF_TRIGGER_MASK (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \ |
---|
31 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING) |
---|
32 | #define IRQF_TRIGGER_PROBE 0x00000010 |
---|
33 | |
---|
34 | /* |
---|
35 | * These flags used only by the kernel as part of the |
---|
36 | * irq handling routines. |
---|
37 | * |
---|
38 | * IRQF_DISABLED - keep irqs disabled when calling the action handler |
---|
39 | * IRQF_SAMPLE_RANDOM - irq is used to feed the random generator |
---|
40 | * IRQF_SHARED - allow sharing the irq among several devices |
---|
41 | * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur |
---|
42 | * IRQF_TIMER - Flag to mark this interrupt as timer interrupt |
---|
43 | */ |
---|
44 | #define IRQF_DISABLED 0x00000020 |
---|
45 | #define IRQF_SAMPLE_RANDOM 0x00000040 |
---|
46 | #define IRQF_SHARED 0x00000080 |
---|
47 | #define IRQF_PROBE_SHARED 0x00000100 |
---|
48 | #define IRQF_TIMER 0x00000200 |
---|
49 | #define IRQF_PERCPU 0x00000400 |
---|
50 | |
---|
51 | /* |
---|
52 | * Migration helpers. Scheduled for removal in 1/2007 |
---|
53 | * Do not use for new code ! |
---|
54 | */ |
---|
55 | #define SA_INTERRUPT IRQF_DISABLED |
---|
56 | #define SA_SAMPLE_RANDOM IRQF_SAMPLE_RANDOM |
---|
57 | #define SA_SHIRQ IRQF_SHARED |
---|
58 | #define SA_PROBEIRQ IRQF_PROBE_SHARED |
---|
59 | #define SA_PERCPU IRQF_PERCPU |
---|
60 | |
---|
61 | #define SA_TRIGGER_LOW IRQF_TRIGGER_LOW |
---|
62 | #define SA_TRIGGER_HIGH IRQF_TRIGGER_HIGH |
---|
63 | #define SA_TRIGGER_FALLING IRQF_TRIGGER_FALLING |
---|
64 | #define SA_TRIGGER_RISING IRQF_TRIGGER_RISING |
---|
65 | #define SA_TRIGGER_MASK IRQF_TRIGGER_MASK |
---|
66 | |
---|
67 | struct irqaction { |
---|
68 | irqreturn_t (*handler)(int, void *, struct pt_regs *); |
---|
69 | unsigned long flags; |
---|
70 | cpumask_t mask; |
---|
71 | const char *name; |
---|
72 | void *dev_id; |
---|
73 | struct irqaction *next; |
---|
74 | int irq; |
---|
75 | struct proc_dir_entry *dir; |
---|
76 | }; |
---|
77 | |
---|
78 | extern irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs); |
---|
79 | extern int request_irq(unsigned int, |
---|
80 | irqreturn_t (*handler)(int, void *, struct pt_regs *), |
---|
81 | unsigned long, const char *, void *); |
---|
82 | extern void free_irq(unsigned int, void *); |
---|
83 | |
---|
84 | /* |
---|
85 | * On lockdep we dont want to enable hardirqs in hardirq |
---|
86 | * context. Use local_irq_enable_in_hardirq() to annotate |
---|
87 | * kernel code that has to do this nevertheless (pretty much |
---|
88 | * the only valid case is for old/broken hardware that is |
---|
89 | * insanely slow). |
---|
90 | * |
---|
91 | * NOTE: in theory this might break fragile code that relies |
---|
92 | * on hardirq delivery - in practice we dont seem to have such |
---|
93 | * places left. So the only effect should be slightly increased |
---|
94 | * irqs-off latencies. |
---|
95 | */ |
---|
96 | #ifdef CONFIG_LOCKDEP |
---|
97 | # define local_irq_enable_in_hardirq() do { } while (0) |
---|
98 | #else |
---|
99 | # define local_irq_enable_in_hardirq() local_irq_enable() |
---|
100 | #endif |
---|
101 | |
---|
102 | #ifdef CONFIG_GENERIC_HARDIRQS |
---|
103 | extern void disable_irq_nosync(unsigned int irq); |
---|
104 | extern void disable_irq(unsigned int irq); |
---|
105 | extern void enable_irq(unsigned int irq); |
---|
106 | |
---|
107 | /* |
---|
108 | * Special lockdep variants of irq disabling/enabling. |
---|
109 | * These should be used for locking constructs that |
---|
110 | * know that a particular irq context which is disabled, |
---|
111 | * and which is the only irq-context user of a lock, |
---|
112 | * that it's safe to take the lock in the irq-disabled |
---|
113 | * section without disabling hardirqs. |
---|
114 | * |
---|
115 | * On !CONFIG_LOCKDEP they are equivalent to the normal |
---|
116 | * irq disable/enable methods. |
---|
117 | */ |
---|
118 | static inline void disable_irq_nosync_lockdep(unsigned int irq) |
---|
119 | { |
---|
120 | disable_irq_nosync(irq); |
---|
121 | #ifdef CONFIG_LOCKDEP |
---|
122 | local_irq_disable(); |
---|
123 | #endif |
---|
124 | } |
---|
125 | |
---|
126 | static inline void disable_irq_lockdep(unsigned int irq) |
---|
127 | { |
---|
128 | disable_irq(irq); |
---|
129 | #ifdef CONFIG_LOCKDEP |
---|
130 | local_irq_disable(); |
---|
131 | #endif |
---|
132 | } |
---|
133 | |
---|
134 | static inline void enable_irq_lockdep(unsigned int irq) |
---|
135 | { |
---|
136 | #ifdef CONFIG_LOCKDEP |
---|
137 | local_irq_enable(); |
---|
138 | #endif |
---|
139 | enable_irq(irq); |
---|
140 | } |
---|
141 | |
---|
142 | /* IRQ wakeup (PM) control: */ |
---|
143 | extern int set_irq_wake(unsigned int irq, unsigned int on); |
---|
144 | |
---|
145 | static inline int enable_irq_wake(unsigned int irq) |
---|
146 | { |
---|
147 | return set_irq_wake(irq, 1); |
---|
148 | } |
---|
149 | |
---|
150 | static inline int disable_irq_wake(unsigned int irq) |
---|
151 | { |
---|
152 | return set_irq_wake(irq, 0); |
---|
153 | } |
---|
154 | |
---|
155 | #else /* !CONFIG_GENERIC_HARDIRQS */ |
---|
156 | /* |
---|
157 | * NOTE: non-genirq architectures, if they want to support the lock |
---|
158 | * validator need to define the methods below in their asm/irq.h |
---|
159 | * files, under an #ifdef CONFIG_LOCKDEP section. |
---|
160 | */ |
---|
161 | # ifndef CONFIG_LOCKDEP |
---|
162 | # define disable_irq_nosync_lockdep(irq) disable_irq_nosync(irq) |
---|
163 | # define disable_irq_lockdep(irq) disable_irq(irq) |
---|
164 | # define enable_irq_lockdep(irq) enable_irq(irq) |
---|
165 | # endif |
---|
166 | |
---|
167 | #endif /* CONFIG_GENERIC_HARDIRQS */ |
---|
168 | |
---|
169 | #ifdef CONFIG_HAVE_IRQ_IGNORE_UNHANDLED |
---|
170 | int irq_ignore_unhandled(unsigned int irq); |
---|
171 | #else |
---|
172 | #define irq_ignore_unhandled(irq) 0 |
---|
173 | #endif |
---|
174 | |
---|
175 | #ifndef __ARCH_SET_SOFTIRQ_PENDING |
---|
176 | #define set_softirq_pending(x) (local_softirq_pending() = (x)) |
---|
177 | #define or_softirq_pending(x) (local_softirq_pending() |= (x)) |
---|
178 | #endif |
---|
179 | |
---|
180 | /* |
---|
181 | * Temporary defines for UP kernels, until all code gets fixed. |
---|
182 | */ |
---|
183 | #ifndef CONFIG_SMP |
---|
184 | static inline void __deprecated cli(void) |
---|
185 | { |
---|
186 | local_irq_disable(); |
---|
187 | } |
---|
188 | static inline void __deprecated sti(void) |
---|
189 | { |
---|
190 | local_irq_enable(); |
---|
191 | } |
---|
192 | static inline void __deprecated save_flags(unsigned long *x) |
---|
193 | { |
---|
194 | local_save_flags(*x); |
---|
195 | } |
---|
196 | #define save_flags(x) save_flags(&x) |
---|
197 | static inline void __deprecated restore_flags(unsigned long x) |
---|
198 | { |
---|
199 | local_irq_restore(x); |
---|
200 | } |
---|
201 | |
---|
202 | static inline void __deprecated save_and_cli(unsigned long *x) |
---|
203 | { |
---|
204 | local_irq_save(*x); |
---|
205 | } |
---|
206 | #define save_and_cli(x) save_and_cli(&x) |
---|
207 | #endif /* CONFIG_SMP */ |
---|
208 | |
---|
209 | extern void local_bh_disable(void); |
---|
210 | extern void __local_bh_enable(void); |
---|
211 | extern void _local_bh_enable(void); |
---|
212 | extern void local_bh_enable(void); |
---|
213 | extern void local_bh_enable_ip(unsigned long ip); |
---|
214 | |
---|
215 | /* PLEASE, avoid to allocate new softirqs, if you need not _really_ high |
---|
216 | frequency threaded job scheduling. For almost all the purposes |
---|
217 | tasklets are more than enough. F.e. all serial device BHs et |
---|
218 | al. should be converted to tasklets, not to softirqs. |
---|
219 | */ |
---|
220 | |
---|
221 | enum |
---|
222 | { |
---|
223 | HI_SOFTIRQ=0, |
---|
224 | TIMER_SOFTIRQ, |
---|
225 | NET_TX_SOFTIRQ, |
---|
226 | NET_RX_SOFTIRQ, |
---|
227 | BLOCK_SOFTIRQ, |
---|
228 | TASKLET_SOFTIRQ |
---|
229 | }; |
---|
230 | |
---|
231 | /* softirq mask and active fields moved to irq_cpustat_t in |
---|
232 | * asm/hardirq.h to get better cache usage. KAO |
---|
233 | */ |
---|
234 | |
---|
235 | struct softirq_action |
---|
236 | { |
---|
237 | void (*action)(struct softirq_action *); |
---|
238 | void *data; |
---|
239 | }; |
---|
240 | |
---|
241 | asmlinkage void do_softirq(void); |
---|
242 | extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data); |
---|
243 | extern void softirq_init(void); |
---|
244 | #define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0) |
---|
245 | extern void FASTCALL(raise_softirq_irqoff(unsigned int nr)); |
---|
246 | extern void FASTCALL(raise_softirq(unsigned int nr)); |
---|
247 | |
---|
248 | |
---|
249 | /* Tasklets --- multithreaded analogue of BHs. |
---|
250 | |
---|
251 | Main feature differing them of generic softirqs: tasklet |
---|
252 | is running only on one CPU simultaneously. |
---|
253 | |
---|
254 | Main feature differing them of BHs: different tasklets |
---|
255 | may be run simultaneously on different CPUs. |
---|
256 | |
---|
257 | Properties: |
---|
258 | * If tasklet_schedule() is called, then tasklet is guaranteed |
---|
259 | to be executed on some cpu at least once after this. |
---|
260 | * If the tasklet is already scheduled, but its excecution is still not |
---|
261 | started, it will be executed only once. |
---|
262 | * If this tasklet is already running on another CPU (or schedule is called |
---|
263 | from tasklet itself), it is rescheduled for later. |
---|
264 | * Tasklet is strictly serialized wrt itself, but not |
---|
265 | wrt another tasklets. If client needs some intertask synchronization, |
---|
266 | he makes it with spinlocks. |
---|
267 | */ |
---|
268 | |
---|
269 | struct tasklet_struct |
---|
270 | { |
---|
271 | struct tasklet_struct *next; |
---|
272 | unsigned long state; |
---|
273 | atomic_t count; |
---|
274 | void (*func)(unsigned long); |
---|
275 | unsigned long data; |
---|
276 | }; |
---|
277 | |
---|
278 | #define DECLARE_TASKLET(name, func, data) \ |
---|
279 | struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data } |
---|
280 | |
---|
281 | #define DECLARE_TASKLET_DISABLED(name, func, data) \ |
---|
282 | struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data } |
---|
283 | |
---|
284 | |
---|
285 | enum |
---|
286 | { |
---|
287 | TASKLET_STATE_SCHED, /* Tasklet is scheduled for execution */ |
---|
288 | TASKLET_STATE_RUN /* Tasklet is running (SMP only) */ |
---|
289 | }; |
---|
290 | |
---|
291 | #ifdef CONFIG_SMP |
---|
292 | static inline int tasklet_trylock(struct tasklet_struct *t) |
---|
293 | { |
---|
294 | return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state); |
---|
295 | } |
---|
296 | |
---|
297 | static inline void tasklet_unlock(struct tasklet_struct *t) |
---|
298 | { |
---|
299 | smp_mb__before_clear_bit(); |
---|
300 | clear_bit(TASKLET_STATE_RUN, &(t)->state); |
---|
301 | } |
---|
302 | |
---|
303 | static inline void tasklet_unlock_wait(struct tasklet_struct *t) |
---|
304 | { |
---|
305 | while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); } |
---|
306 | } |
---|
307 | #else |
---|
308 | #define tasklet_trylock(t) 1 |
---|
309 | #define tasklet_unlock_wait(t) do { } while (0) |
---|
310 | #define tasklet_unlock(t) do { } while (0) |
---|
311 | #endif |
---|
312 | |
---|
313 | extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t)); |
---|
314 | |
---|
315 | static inline void tasklet_schedule(struct tasklet_struct *t) |
---|
316 | { |
---|
317 | if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) |
---|
318 | __tasklet_schedule(t); |
---|
319 | } |
---|
320 | |
---|
321 | extern void FASTCALL(__tasklet_hi_schedule(struct tasklet_struct *t)); |
---|
322 | |
---|
323 | static inline void tasklet_hi_schedule(struct tasklet_struct *t) |
---|
324 | { |
---|
325 | if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) |
---|
326 | __tasklet_hi_schedule(t); |
---|
327 | } |
---|
328 | |
---|
329 | |
---|
330 | static inline void tasklet_disable_nosync(struct tasklet_struct *t) |
---|
331 | { |
---|
332 | atomic_inc(&t->count); |
---|
333 | smp_mb__after_atomic_inc(); |
---|
334 | } |
---|
335 | |
---|
336 | static inline void tasklet_disable(struct tasklet_struct *t) |
---|
337 | { |
---|
338 | tasklet_disable_nosync(t); |
---|
339 | tasklet_unlock_wait(t); |
---|
340 | smp_mb(); |
---|
341 | } |
---|
342 | |
---|
343 | static inline void tasklet_enable(struct tasklet_struct *t) |
---|
344 | { |
---|
345 | smp_mb__before_atomic_dec(); |
---|
346 | atomic_dec(&t->count); |
---|
347 | } |
---|
348 | |
---|
349 | static inline void tasklet_hi_enable(struct tasklet_struct *t) |
---|
350 | { |
---|
351 | smp_mb__before_atomic_dec(); |
---|
352 | atomic_dec(&t->count); |
---|
353 | } |
---|
354 | |
---|
355 | extern void tasklet_kill(struct tasklet_struct *t); |
---|
356 | extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu); |
---|
357 | extern void tasklet_init(struct tasklet_struct *t, |
---|
358 | void (*func)(unsigned long), unsigned long data); |
---|
359 | |
---|
360 | /* |
---|
361 | * Autoprobing for irqs: |
---|
362 | * |
---|
363 | * probe_irq_on() and probe_irq_off() provide robust primitives |
---|
364 | * for accurate IRQ probing during kernel initialization. They are |
---|
365 | * reasonably simple to use, are not "fooled" by spurious interrupts, |
---|
366 | * and, unlike other attempts at IRQ probing, they do not get hung on |
---|
367 | * stuck interrupts (such as unused PS2 mouse interfaces on ASUS boards). |
---|
368 | * |
---|
369 | * For reasonably foolproof probing, use them as follows: |
---|
370 | * |
---|
371 | * 1. clear and/or mask the device's internal interrupt. |
---|
372 | * 2. sti(); |
---|
373 | * 3. irqs = probe_irq_on(); // "take over" all unassigned idle IRQs |
---|
374 | * 4. enable the device and cause it to trigger an interrupt. |
---|
375 | * 5. wait for the device to interrupt, using non-intrusive polling or a delay. |
---|
376 | * 6. irq = probe_irq_off(irqs); // get IRQ number, 0=none, negative=multiple |
---|
377 | * 7. service the device to clear its pending interrupt. |
---|
378 | * 8. loop again if paranoia is required. |
---|
379 | * |
---|
380 | * probe_irq_on() returns a mask of allocated irq's. |
---|
381 | * |
---|
382 | * probe_irq_off() takes the mask as a parameter, |
---|
383 | * and returns the irq number which occurred, |
---|
384 | * or zero if none occurred, or a negative irq number |
---|
385 | * if more than one irq occurred. |
---|
386 | */ |
---|
387 | |
---|
388 | #if defined(CONFIG_GENERIC_HARDIRQS) && !defined(CONFIG_GENERIC_IRQ_PROBE) |
---|
389 | static inline unsigned long probe_irq_on(void) |
---|
390 | { |
---|
391 | return 0; |
---|
392 | } |
---|
393 | static inline int probe_irq_off(unsigned long val) |
---|
394 | { |
---|
395 | return 0; |
---|
396 | } |
---|
397 | static inline unsigned int probe_irq_mask(unsigned long val) |
---|
398 | { |
---|
399 | return 0; |
---|
400 | } |
---|
401 | #else |
---|
402 | extern unsigned long probe_irq_on(void); /* returns 0 on failure */ |
---|
403 | extern int probe_irq_off(unsigned long); /* returns 0 or negative on failure */ |
---|
404 | extern unsigned int probe_irq_mask(unsigned long); /* returns mask of ISA interrupts */ |
---|
405 | #endif |
---|
406 | |
---|
407 | #endif |
---|