Branch data Line data Source code
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/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 : : * These correspond to the IORESOURCE_IRQ_* defines in
24 : : * linux/ioport.h to select the interrupt line behaviour. When
25 : : * requesting an interrupt without specifying a IRQF_TRIGGER, the
26 : : * setting should be assumed to be "as already configured", which
27 : : * may be as per machine or firmware initialisation.
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 : : * These flags used only by the kernel as part of the
40 : : * irq handling routines.
41 : : *
42 : : * IRQF_DISABLED - keep irqs disabled when calling the action handler.
43 : : * DEPRECATED. This flag is a NOOP and scheduled to be removed
44 : : * IRQF_SHARED - allow sharing the irq among several devices
45 : : * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur
46 : : * IRQF_TIMER - Flag to mark this interrupt as timer interrupt
47 : : * IRQF_PERCPU - Interrupt is per cpu
48 : : * IRQF_NOBALANCING - Flag to exclude this interrupt from irq balancing
49 : : * IRQF_IRQPOLL - Interrupt is used for polling (only the interrupt that is
50 : : * registered first in an shared interrupt is considered for
51 : : * performance reasons)
52 : : * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished.
53 : : * Used by threaded interrupts which need to keep the
54 : : * irq line disabled until the threaded handler has been run.
55 : : * IRQF_NO_SUSPEND - Do not disable this IRQ during suspend
56 : : * IRQF_FORCE_RESUME - Force enable it on resume even if IRQF_NO_SUSPEND is set
57 : : * IRQF_NO_THREAD - Interrupt cannot be threaded
58 : : * IRQF_EARLY_RESUME - Resume IRQ early during syscore instead of at device
59 : : * resume time.
60 : : */
61 : : #define IRQF_DISABLED 0x00000020
62 : : #define IRQF_SHARED 0x00000080
63 : : #define IRQF_PROBE_SHARED 0x00000100
64 : : #define __IRQF_TIMER 0x00000200
65 : : #define IRQF_PERCPU 0x00000400
66 : : #define IRQF_NOBALANCING 0x00000800
67 : : #define IRQF_IRQPOLL 0x00001000
68 : : #define IRQF_ONESHOT 0x00002000
69 : : #define IRQF_NO_SUSPEND 0x00004000
70 : : #define IRQF_FORCE_RESUME 0x00008000
71 : : #define IRQF_NO_THREAD 0x00010000
72 : : #define IRQF_EARLY_RESUME 0x00020000
73 : :
74 : : #define IRQF_TIMER (__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD)
75 : :
76 : : /*
77 : : * These values can be returned by request_any_context_irq() and
78 : : * describe the context the interrupt will be run in.
79 : : *
80 : : * IRQC_IS_HARDIRQ - interrupt runs in hardirq context
81 : : * IRQC_IS_NESTED - interrupt runs in a nested threaded context
82 : : */
83 : : enum {
84 : : IRQC_IS_HARDIRQ = 0,
85 : : IRQC_IS_NESTED,
86 : : };
87 : :
88 : : typedef irqreturn_t (*irq_handler_t)(int, void *);
89 : :
90 : : /**
91 : : * struct irqaction - per interrupt action descriptor
92 : : * @handler: interrupt handler function
93 : : * @name: name of the device
94 : : * @dev_id: cookie to identify the device
95 : : * @percpu_dev_id: cookie to identify the device
96 : : * @next: pointer to the next irqaction for shared interrupts
97 : : * @irq: interrupt number
98 : : * @flags: flags (see IRQF_* above)
99 : : * @thread_fn: interrupt handler function for threaded interrupts
100 : : * @thread: thread pointer for threaded interrupts
101 : : * @thread_flags: flags related to @thread
102 : : * @thread_mask: bitmask for keeping track of @thread activity
103 : : * @dir: pointer to the proc/irq/NN/name entry
104 : : */
105 : : struct irqaction {
106 : : irq_handler_t handler;
107 : : void *dev_id;
108 : : void __percpu *percpu_dev_id;
109 : : struct irqaction *next;
110 : : irq_handler_t thread_fn;
111 : : struct task_struct *thread;
112 : : unsigned int irq;
113 : : unsigned int flags;
114 : : unsigned long thread_flags;
115 : : unsigned long thread_mask;
116 : : const char *name;
117 : : struct proc_dir_entry *dir;
118 : : } ____cacheline_internodealigned_in_smp;
119 : :
120 : : extern irqreturn_t no_action(int cpl, void *dev_id);
121 : :
122 : : extern int __must_check
123 : : request_threaded_irq(unsigned int irq, irq_handler_t handler,
124 : : irq_handler_t thread_fn,
125 : : unsigned long flags, const char *name, void *dev);
126 : :
127 : : static inline int __must_check
128 : : request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
129 : : const char *name, void *dev)
130 : : {
131 : 0 : return request_threaded_irq(irq, handler, NULL, flags, name, dev);
132 : : }
133 : :
134 : : extern int __must_check
135 : : request_any_context_irq(unsigned int irq, irq_handler_t handler,
136 : : unsigned long flags, const char *name, void *dev_id);
137 : :
138 : : extern int __must_check
139 : : request_percpu_irq(unsigned int irq, irq_handler_t handler,
140 : : const char *devname, void __percpu *percpu_dev_id);
141 : :
142 : : extern void free_irq(unsigned int, void *);
143 : : extern void free_percpu_irq(unsigned int, void __percpu *);
144 : :
145 : : struct device;
146 : :
147 : : extern int __must_check
148 : : devm_request_threaded_irq(struct device *dev, unsigned int irq,
149 : : irq_handler_t handler, irq_handler_t thread_fn,
150 : : unsigned long irqflags, const char *devname,
151 : : void *dev_id);
152 : :
153 : : static inline int __must_check
154 : : devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
155 : : unsigned long irqflags, const char *devname, void *dev_id)
156 : : {
157 : : return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
158 : : devname, dev_id);
159 : : }
160 : :
161 : : extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
162 : :
163 : : /*
164 : : * On lockdep we dont want to enable hardirqs in hardirq
165 : : * context. Use local_irq_enable_in_hardirq() to annotate
166 : : * kernel code that has to do this nevertheless (pretty much
167 : : * the only valid case is for old/broken hardware that is
168 : : * insanely slow).
169 : : *
170 : : * NOTE: in theory this might break fragile code that relies
171 : : * on hardirq delivery - in practice we dont seem to have such
172 : : * places left. So the only effect should be slightly increased
173 : : * irqs-off latencies.
174 : : */
175 : : #ifdef CONFIG_LOCKDEP
176 : : # define local_irq_enable_in_hardirq() do { } while (0)
177 : : #else
178 : : # define local_irq_enable_in_hardirq() local_irq_enable()
179 : : #endif
180 : :
181 : : extern void disable_irq_nosync(unsigned int irq);
182 : : extern void disable_irq(unsigned int irq);
183 : : extern void disable_percpu_irq(unsigned int irq);
184 : : extern void enable_irq(unsigned int irq);
185 : : extern void enable_percpu_irq(unsigned int irq, unsigned int type);
186 : :
187 : : /* The following three functions are for the core kernel use only. */
188 : : extern void suspend_device_irqs(void);
189 : : extern void resume_device_irqs(void);
190 : : #ifdef CONFIG_PM_SLEEP
191 : : extern int check_wakeup_irqs(void);
192 : : #else
193 : : static inline int check_wakeup_irqs(void) { return 0; }
194 : : #endif
195 : :
196 : : #if defined(CONFIG_SMP)
197 : :
198 : : extern cpumask_var_t irq_default_affinity;
199 : :
200 : : extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
201 : : extern int irq_can_set_affinity(unsigned int irq);
202 : : extern int irq_select_affinity(unsigned int irq);
203 : :
204 : : extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
205 : :
206 : : /**
207 : : * struct irq_affinity_notify - context for notification of IRQ affinity changes
208 : : * @irq: Interrupt to which notification applies
209 : : * @kref: Reference count, for internal use
210 : : * @work: Work item, for internal use
211 : : * @notify: Function to be called on change. This will be
212 : : * called in process context.
213 : : * @release: Function to be called on release. This will be
214 : : * called in process context. Once registered, the
215 : : * structure must only be freed when this function is
216 : : * called or later.
217 : : */
218 : : struct irq_affinity_notify {
219 : : unsigned int irq;
220 : : struct kref kref;
221 : : struct work_struct work;
222 : : void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask);
223 : : void (*release)(struct kref *ref);
224 : : };
225 : :
226 : : extern int
227 : : irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
228 : :
229 : : #else /* CONFIG_SMP */
230 : :
231 : : static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m)
232 : : {
233 : : return -EINVAL;
234 : : }
235 : :
236 : : static inline int irq_can_set_affinity(unsigned int irq)
237 : : {
238 : : return 0;
239 : : }
240 : :
241 : : static inline int irq_select_affinity(unsigned int irq) { return 0; }
242 : :
243 : : static inline int irq_set_affinity_hint(unsigned int irq,
244 : : const struct cpumask *m)
245 : : {
246 : : return -EINVAL;
247 : : }
248 : : #endif /* CONFIG_SMP */
249 : :
250 : : /*
251 : : * Special lockdep variants of irq disabling/enabling.
252 : : * These should be used for locking constructs that
253 : : * know that a particular irq context which is disabled,
254 : : * and which is the only irq-context user of a lock,
255 : : * that it's safe to take the lock in the irq-disabled
256 : : * section without disabling hardirqs.
257 : : *
258 : : * On !CONFIG_LOCKDEP they are equivalent to the normal
259 : : * irq disable/enable methods.
260 : : */
261 : : static inline void disable_irq_nosync_lockdep(unsigned int irq)
262 : : {
263 : : disable_irq_nosync(irq);
264 : : #ifdef CONFIG_LOCKDEP
265 : : local_irq_disable();
266 : : #endif
267 : : }
268 : :
269 : : static inline void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
270 : : {
271 : : disable_irq_nosync(irq);
272 : : #ifdef CONFIG_LOCKDEP
273 : : local_irq_save(*flags);
274 : : #endif
275 : : }
276 : :
277 : : static inline void disable_irq_lockdep(unsigned int irq)
278 : : {
279 : : disable_irq(irq);
280 : : #ifdef CONFIG_LOCKDEP
281 : : local_irq_disable();
282 : : #endif
283 : : }
284 : :
285 : : static inline void enable_irq_lockdep(unsigned int irq)
286 : : {
287 : : #ifdef CONFIG_LOCKDEP
288 : : local_irq_enable();
289 : : #endif
290 : : enable_irq(irq);
291 : : }
292 : :
293 : : static inline void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
294 : : {
295 : : #ifdef CONFIG_LOCKDEP
296 : : local_irq_restore(*flags);
297 : : #endif
298 : : enable_irq(irq);
299 : : }
300 : :
301 : : /* IRQ wakeup (PM) control: */
302 : : extern int irq_set_irq_wake(unsigned int irq, unsigned int on);
303 : :
304 : : static inline int enable_irq_wake(unsigned int irq)
305 : : {
306 : 0 : return irq_set_irq_wake(irq, 1);
307 : : }
308 : :
309 : : static inline int disable_irq_wake(unsigned int irq)
310 : : {
311 : 0 : return irq_set_irq_wake(irq, 0);
312 : : }
313 : :
314 : :
315 : : #ifdef CONFIG_IRQ_FORCED_THREADING
316 : : extern bool force_irqthreads;
317 : : #else
318 : : #define force_irqthreads (0)
319 : : #endif
320 : :
321 : : #ifndef __ARCH_SET_SOFTIRQ_PENDING
322 : : #define set_softirq_pending(x) (local_softirq_pending() = (x))
323 : : #define or_softirq_pending(x) (local_softirq_pending() |= (x))
324 : : #endif
325 : :
326 : : /* Some architectures might implement lazy enabling/disabling of
327 : : * interrupts. In some cases, such as stop_machine, we might want
328 : : * to ensure that after a local_irq_disable(), interrupts have
329 : : * really been disabled in hardware. Such architectures need to
330 : : * implement the following hook.
331 : : */
332 : : #ifndef hard_irq_disable
333 : : #define hard_irq_disable() do { } while(0)
334 : : #endif
335 : :
336 : : /* PLEASE, avoid to allocate new softirqs, if you need not _really_ high
337 : : frequency threaded job scheduling. For almost all the purposes
338 : : tasklets are more than enough. F.e. all serial device BHs et
339 : : al. should be converted to tasklets, not to softirqs.
340 : : */
341 : :
342 : : enum
343 : : {
344 : : HI_SOFTIRQ=0,
345 : : TIMER_SOFTIRQ,
346 : : NET_TX_SOFTIRQ,
347 : : NET_RX_SOFTIRQ,
348 : : BLOCK_SOFTIRQ,
349 : : BLOCK_IOPOLL_SOFTIRQ,
350 : : TASKLET_SOFTIRQ,
351 : : SCHED_SOFTIRQ,
352 : : HRTIMER_SOFTIRQ,
353 : : RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */
354 : :
355 : : NR_SOFTIRQS
356 : : };
357 : :
358 : : #define SOFTIRQ_STOP_IDLE_MASK (~(1 << RCU_SOFTIRQ))
359 : :
360 : : /* map softirq index to softirq name. update 'softirq_to_name' in
361 : : * kernel/softirq.c when adding a new softirq.
362 : : */
363 : : extern char *softirq_to_name[NR_SOFTIRQS];
364 : :
365 : : /* softirq mask and active fields moved to irq_cpustat_t in
366 : : * asm/hardirq.h to get better cache usage. KAO
367 : : */
368 : :
369 : : struct softirq_action
370 : : {
371 : : void (*action)(struct softirq_action *);
372 : : };
373 : :
374 : : asmlinkage void do_softirq(void);
375 : : asmlinkage void __do_softirq(void);
376 : :
377 : : #ifdef __ARCH_HAS_DO_SOFTIRQ
378 : : void do_softirq_own_stack(void);
379 : : #else
380 : : static inline void do_softirq_own_stack(void)
381 : : {
382 : 7923614 : __do_softirq();
383 : : }
384 : : #endif
385 : :
386 : : extern void open_softirq(int nr, void (*action)(struct softirq_action *));
387 : : extern void softirq_init(void);
388 : : extern void __raise_softirq_irqoff(unsigned int nr);
389 : :
390 : : extern void raise_softirq_irqoff(unsigned int nr);
391 : : extern void raise_softirq(unsigned int nr);
392 : :
393 : : DECLARE_PER_CPU(struct task_struct *, ksoftirqd);
394 : :
395 : : static inline struct task_struct *this_cpu_ksoftirqd(void)
396 : : {
397 : : return this_cpu_read(ksoftirqd);
398 : : }
399 : :
400 : : /* Tasklets --- multithreaded analogue of BHs.
401 : :
402 : : Main feature differing them of generic softirqs: tasklet
403 : : is running only on one CPU simultaneously.
404 : :
405 : : Main feature differing them of BHs: different tasklets
406 : : may be run simultaneously on different CPUs.
407 : :
408 : : Properties:
409 : : * If tasklet_schedule() is called, then tasklet is guaranteed
410 : : to be executed on some cpu at least once after this.
411 : : * If the tasklet is already scheduled, but its execution is still not
412 : : started, it will be executed only once.
413 : : * If this tasklet is already running on another CPU (or schedule is called
414 : : from tasklet itself), it is rescheduled for later.
415 : : * Tasklet is strictly serialized wrt itself, but not
416 : : wrt another tasklets. If client needs some intertask synchronization,
417 : : he makes it with spinlocks.
418 : : */
419 : :
420 : : struct tasklet_struct
421 : : {
422 : : struct tasklet_struct *next;
423 : : unsigned long state;
424 : : atomic_t count;
425 : : void (*func)(unsigned long);
426 : : unsigned long data;
427 : : };
428 : :
429 : : #define DECLARE_TASKLET(name, func, data) \
430 : : struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
431 : :
432 : : #define DECLARE_TASKLET_DISABLED(name, func, data) \
433 : : struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
434 : :
435 : :
436 : : enum
437 : : {
438 : : TASKLET_STATE_SCHED, /* Tasklet is scheduled for execution */
439 : : TASKLET_STATE_RUN /* Tasklet is running (SMP only) */
440 : : };
441 : :
442 : : #ifdef CONFIG_SMP
443 : : static inline int tasklet_trylock(struct tasklet_struct *t)
444 : : {
445 : 0 : return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
446 : : }
447 : :
448 : : static inline void tasklet_unlock(struct tasklet_struct *t)
449 : : {
450 : 0 : smp_mb__before_clear_bit();
451 : 0 : clear_bit(TASKLET_STATE_RUN, &(t)->state);
452 : : }
453 : :
454 : : static inline void tasklet_unlock_wait(struct tasklet_struct *t)
455 : : {
456 [ # # ]: 0 : while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
457 : : }
458 : : #else
459 : : #define tasklet_trylock(t) 1
460 : : #define tasklet_unlock_wait(t) do { } while (0)
461 : : #define tasklet_unlock(t) do { } while (0)
462 : : #endif
463 : :
464 : : extern void __tasklet_schedule(struct tasklet_struct *t);
465 : :
466 : : static inline void tasklet_schedule(struct tasklet_struct *t)
467 : : {
468 [ # # ][ # # : 0 : if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
# # # # #
# # # ]
[ # # ]
469 : 0 : __tasklet_schedule(t);
470 : : }
471 : :
472 : : extern void __tasklet_hi_schedule(struct tasklet_struct *t);
473 : :
474 : : static inline void tasklet_hi_schedule(struct tasklet_struct *t)
475 : : {
476 [ # # ]: 0 : if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
477 : 0 : __tasklet_hi_schedule(t);
478 : : }
479 : :
480 : : extern void __tasklet_hi_schedule_first(struct tasklet_struct *t);
481 : :
482 : : /*
483 : : * This version avoids touching any other tasklets. Needed for kmemcheck
484 : : * in order not to take any page faults while enqueueing this tasklet;
485 : : * consider VERY carefully whether you really need this or
486 : : * tasklet_hi_schedule()...
487 : : */
488 : : static inline void tasklet_hi_schedule_first(struct tasklet_struct *t)
489 : : {
490 : : if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
491 : : __tasklet_hi_schedule_first(t);
492 : : }
493 : :
494 : :
495 : : static inline void tasklet_disable_nosync(struct tasklet_struct *t)
496 : : {
497 : : atomic_inc(&t->count);
498 : 0 : smp_mb__after_atomic_inc();
499 : : }
500 : :
501 : : static inline void tasklet_disable(struct tasklet_struct *t)
502 : : {
503 : : tasklet_disable_nosync(t);
504 : : tasklet_unlock_wait(t);
505 : 0 : smp_mb();
506 : : }
507 : :
508 : : static inline void tasklet_enable(struct tasklet_struct *t)
509 : : {
510 : 0 : smp_mb__before_atomic_dec();
511 : : atomic_dec(&t->count);
512 : : }
513 : :
514 : : static inline void tasklet_hi_enable(struct tasklet_struct *t)
515 : : {
516 : : smp_mb__before_atomic_dec();
517 : : atomic_dec(&t->count);
518 : : }
519 : :
520 : : extern void tasklet_kill(struct tasklet_struct *t);
521 : : extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
522 : : extern void tasklet_init(struct tasklet_struct *t,
523 : : void (*func)(unsigned long), unsigned long data);
524 : :
525 : : struct tasklet_hrtimer {
526 : : struct hrtimer timer;
527 : : struct tasklet_struct tasklet;
528 : : enum hrtimer_restart (*function)(struct hrtimer *);
529 : : };
530 : :
531 : : extern void
532 : : tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
533 : : enum hrtimer_restart (*function)(struct hrtimer *),
534 : : clockid_t which_clock, enum hrtimer_mode mode);
535 : :
536 : : static inline
537 : : int tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
538 : : const enum hrtimer_mode mode)
539 : : {
540 : : return hrtimer_start(&ttimer->timer, time, mode);
541 : : }
542 : :
543 : : static inline
544 : : void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)
545 : : {
546 : : hrtimer_cancel(&ttimer->timer);
547 : : tasklet_kill(&ttimer->tasklet);
548 : : }
549 : :
550 : : /*
551 : : * Autoprobing for irqs:
552 : : *
553 : : * probe_irq_on() and probe_irq_off() provide robust primitives
554 : : * for accurate IRQ probing during kernel initialization. They are
555 : : * reasonably simple to use, are not "fooled" by spurious interrupts,
556 : : * and, unlike other attempts at IRQ probing, they do not get hung on
557 : : * stuck interrupts (such as unused PS2 mouse interfaces on ASUS boards).
558 : : *
559 : : * For reasonably foolproof probing, use them as follows:
560 : : *
561 : : * 1. clear and/or mask the device's internal interrupt.
562 : : * 2. sti();
563 : : * 3. irqs = probe_irq_on(); // "take over" all unassigned idle IRQs
564 : : * 4. enable the device and cause it to trigger an interrupt.
565 : : * 5. wait for the device to interrupt, using non-intrusive polling or a delay.
566 : : * 6. irq = probe_irq_off(irqs); // get IRQ number, 0=none, negative=multiple
567 : : * 7. service the device to clear its pending interrupt.
568 : : * 8. loop again if paranoia is required.
569 : : *
570 : : * probe_irq_on() returns a mask of allocated irq's.
571 : : *
572 : : * probe_irq_off() takes the mask as a parameter,
573 : : * and returns the irq number which occurred,
574 : : * or zero if none occurred, or a negative irq number
575 : : * if more than one irq occurred.
576 : : */
577 : :
578 : : #if !defined(CONFIG_GENERIC_IRQ_PROBE)
579 : : static inline unsigned long probe_irq_on(void)
580 : : {
581 : : return 0;
582 : : }
583 : : static inline int probe_irq_off(unsigned long val)
584 : : {
585 : : return 0;
586 : : }
587 : : static inline unsigned int probe_irq_mask(unsigned long val)
588 : : {
589 : : return 0;
590 : : }
591 : : #else
592 : : extern unsigned long probe_irq_on(void); /* returns 0 on failure */
593 : : extern int probe_irq_off(unsigned long); /* returns 0 or negative on failure */
594 : : extern unsigned int probe_irq_mask(unsigned long); /* returns mask of ISA interrupts */
595 : : #endif
596 : :
597 : : #ifdef CONFIG_PROC_FS
598 : : /* Initialize /proc/irq/ */
599 : : extern void init_irq_proc(void);
600 : : #else
601 : : static inline void init_irq_proc(void)
602 : : {
603 : : }
604 : : #endif
605 : :
606 : : struct seq_file;
607 : : int show_interrupts(struct seq_file *p, void *v);
608 : : int arch_show_interrupts(struct seq_file *p, int prec);
609 : :
610 : : extern int early_irq_init(void);
611 : : extern int arch_probe_nr_irqs(void);
612 : : extern int arch_early_irq_init(void);
613 : :
614 : : #endif
|
