include/linux/interrupt.h

   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/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 <asm/atomic.h>
  21 #include <asm/ptrace.h>
  22 #include <asm/system.h>
  23 #include <trace/events/irq.h>
  24
  25 /*
  26  * These correspond to the IORESOURCE_IRQ_* defines in
  27  * linux/ioport.h to select the interrupt line behaviour.  When
  28  * requesting an interrupt without specifying a IRQF_TRIGGER, the
  29  * setting should be assumed to be "as already configured", which
  30  * may be as per machine or firmware initialisation.
  31  */
  32 #define IRQF_TRIGGER_NONE       0x00000000
  33 #define IRQF_TRIGGER_RISING     0x00000001
  34 #define IRQF_TRIGGER_FALLING    0x00000002
  35 #define IRQF_TRIGGER_HIGH       0x00000004
  36 #define IRQF_TRIGGER_LOW        0x00000008
  37 #define IRQF_TRIGGER_MASK       (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
  38                                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
  39 #define IRQF_TRIGGER_PROBE      0x00000010
  40
  41 /*
  42  * These flags used only by the kernel as part of the
  43  * irq handling routines.
  44  *
  45  * IRQF_DISABLED - keep irqs disabled when calling the action handler.
  46  *                 DEPRECATED. This flag is a NOOP and scheduled to be removed
  47  * IRQF_SAMPLE_RANDOM - irq is used to feed the random generator
  48  * IRQF_SHARED - allow sharing the irq among several devices
  49  * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur
  50  * IRQF_TIMER - Flag to mark this interrupt as timer interrupt
  51  * IRQF_PERCPU - Interrupt is per cpu
  52  * IRQF_NOBALANCING - Flag to exclude this interrupt from irq balancing
  53  * IRQF_IRQPOLL - Interrupt is used for polling (only the interrupt that is
  54  *                registered first in an shared interrupt is considered for
  55  *                performance reasons)
  56  * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished.
  57  *                Used by threaded interrupts which need to keep the
  58  *                irq line disabled until the threaded handler has been run.
  59  * IRQF_NO_SUSPEND - Do not disable this IRQ during suspend
  60  * IRQF_FORCE_RESUME - Force enable it on resume even if IRQF_NO_SUSPEND is set
  61  */
  62 #define IRQF_DISABLED           0x00000020
  63 #define IRQF_SAMPLE_RANDOM      0x00000040
  64 #define IRQF_SHARED             0x00000080
  65 #define IRQF_PROBE_SHARED       0x00000100
  66 #define __IRQF_TIMER            0x00000200
  67 #define IRQF_PERCPU             0x00000400
  68 #define IRQF_NOBALANCING        0x00000800
  69 #define IRQF_IRQPOLL            0x00001000
  70 #define IRQF_ONESHOT            0x00002000
  71 #define IRQF_NO_SUSPEND         0x00004000
  72 #define IRQF_FORCE_RESUME       0x00008000
  73
  74 #define IRQF_TIMER              (__IRQF_TIMER | IRQF_NO_SUSPEND)
  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  * @flags:      flags (see IRQF_* above)
  94  * @name:       name of the device
  95  * @dev_id:     cookie to identify the device
  96  * @next:       pointer to the next irqaction for shared interrupts
  97  * @irq:        interrupt number
  98  * @dir:        pointer to the proc/irq/NN/name entry
  99  * @thread_fn:  interupt 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  */
 104 struct irqaction {
 105         irq_handler_t handler;
 106         unsigned long flags;
 107         void *dev_id;
 108         struct irqaction *next;
 109         int irq;
 110         irq_handler_t thread_fn;
 111         struct task_struct *thread;
 112         unsigned long thread_flags;
 113         unsigned long thread_mask;
 114         const char *name;
 115         struct proc_dir_entry *dir;
 116 } ____cacheline_internodealigned_in_smp;
 117
 118 extern irqreturn_t no_action(int cpl, void *dev_id);
 119
 120 #ifdef CONFIG_GENERIC_HARDIRQS
 121 extern int __must_check
 122 request_threaded_irq(unsigned int irq, irq_handler_t handler,
 123                      irq_handler_t thread_fn,
 124                      unsigned long flags, const char *name, void *dev);
 125
 126 static inline int __must_check
 127 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 128             const char *name, void *dev)
 129 {
 130         return request_threaded_irq(irq, handler, NULL, flags, name, dev);
 131 }
 132
 133 extern int __must_check
 134 request_any_context_irq(unsigned int irq, irq_handler_t handler,
 135                         unsigned long flags, const char *name, void *dev_id);
 136
 137 extern void exit_irq_thread(void);
 138 #else
 139
 140 extern int __must_check
 141 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 142             const char *name, void *dev);
 143
 144 /*
 145  * Special function to avoid ifdeffery in kernel/irq/devres.c which
 146  * gets magically built by GENERIC_HARDIRQS=n architectures (sparc,
 147  * m68k). I really love these $@%#!* obvious Makefile references:
 148  * ../../../kernel/irq/devres.o
 149  */
 150 static inline int __must_check
 151 request_threaded_irq(unsigned int irq, irq_handler_t handler,
 152                      irq_handler_t thread_fn,
 153                      unsigned long flags, const char *name, void *dev)
 154 {
 155         return request_irq(irq, handler, flags, name, dev);
 156 }
 157
 158 static inline int __must_check
 159 request_any_context_irq(unsigned int irq, irq_handler_t handler,
 160                         unsigned long flags, const char *name, void *dev_id)
 161 {
 162         return request_irq(irq, handler, flags, name, dev_id);
 163 }
 164
 165 static inline void exit_irq_thread(void) { }
 166 #endif
 167
 168 extern void free_irq(unsigned int, void *);
 169
 170 struct device;
 171
 172 extern int __must_check
 173 devm_request_threaded_irq(struct device *dev, unsigned int irq,
 174                           irq_handler_t handler, irq_handler_t thread_fn,
 175                           unsigned long irqflags, const char *devname,
 176                           void *dev_id);
 177
 178 static inline int __must_check
 179 devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
 180                  unsigned long irqflags, const char *devname, void *dev_id)
 181 {
 182         return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
 183                                          devname, dev_id);
 184 }
 185
 186 extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
 187
 188 /*
 189  * On lockdep we dont want to enable hardirqs in hardirq
 190  * context. Use local_irq_enable_in_hardirq() to annotate
 191  * kernel code that has to do this nevertheless (pretty much
 192  * the only valid case is for old/broken hardware that is
 193  * insanely slow).
 194  *
 195  * NOTE: in theory this might break fragile code that relies
 196  * on hardirq delivery - in practice we dont seem to have such
 197  * places left. So the only effect should be slightly increased
 198  * irqs-off latencies.
 199  */
 200 #ifdef CONFIG_LOCKDEP
 201 # define local_irq_enable_in_hardirq()  do { } while (0)
 202 #else
 203 # define local_irq_enable_in_hardirq()  local_irq_enable()
 204 #endif
 205
 206 extern void disable_irq_nosync(unsigned int irq);
 207 extern void disable_irq(unsigned int irq);
 208 extern void enable_irq(unsigned int irq);
 209
 210 /* The following three functions are for the core kernel use only. */
 211 #ifdef CONFIG_GENERIC_HARDIRQS
 212 extern void suspend_device_irqs(void);
 213 extern void resume_device_irqs(void);
 214 #ifdef CONFIG_PM_SLEEP
 215 extern int check_wakeup_irqs(void);
 216 #else
 217 static inline int check_wakeup_irqs(void) { return 0; }
 218 #endif
 219 #else
 220 static inline void suspend_device_irqs(void) { };
 221 static inline void resume_device_irqs(void) { };
 222 static inline int check_wakeup_irqs(void) { return 0; }
 223 #endif
 224
 225 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 226
 227 extern cpumask_var_t irq_default_affinity;
 228
 229 extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
 230 extern int irq_can_set_affinity(unsigned int irq);
 231 extern int irq_select_affinity(unsigned int irq);
 232
 233 extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
 234
 235 /**
 236  * struct irq_affinity_notify - context for notification of IRQ affinity changes
 237  * @irq:                Interrupt to which notification applies
 238  * @kref:               Reference count, for internal use
 239  * @work:               Work item, for internal use
 240  * @notify:             Function to be called on change.  This will be
 241  *                      called in process context.
 242  * @release:            Function to be called on release.  This will be
 243  *                      called in process context.  Once registered, the
 244  *                      structure must only be freed when this function is
 245  *                      called or later.
 246  */
 247 struct irq_affinity_notify {
 248         unsigned int irq;
 249         struct kref kref;
 250         struct work_struct work;
 251         void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask);
 252         void (*release)(struct kref *ref);
 253 };
 254
 255 extern int
 256 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
 257
 258 static inline void irq_run_affinity_notifiers(void)
 259 {
 260         flush_scheduled_work();
 261 }
 262
 263 #else /* CONFIG_SMP */
 264
 265 static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m)
 266 {
 267         return -EINVAL;
 268 }
 269
 270 static inline int irq_can_set_affinity(unsigned int irq)
 271 {
 272         return 0;
 273 }
 274
 275 static inline int irq_select_affinity(unsigned int irq)  { return 0; }
 276
 277 static inline int irq_set_affinity_hint(unsigned int irq,
 278                                         const struct cpumask *m)
 279 {
 280         return -EINVAL;
 281 }
 282 #endif /* CONFIG_SMP && CONFIG_GENERIC_HARDIRQS */
 283
 284 #ifdef CONFIG_GENERIC_HARDIRQS
 285 /*
 286  * Special lockdep variants of irq disabling/enabling.
 287  * These should be used for locking constructs that
 288  * know that a particular irq context which is disabled,
 289  * and which is the only irq-context user of a lock,
 290  * that it's safe to take the lock in the irq-disabled
 291  * section without disabling hardirqs.
 292  *
 293  * On !CONFIG_LOCKDEP they are equivalent to the normal
 294  * irq disable/enable methods.
 295  */
 296 static inline void disable_irq_nosync_lockdep(unsigned int irq)
 297 {
 298         disable_irq_nosync(irq);
 299 #ifdef CONFIG_LOCKDEP
 300         local_irq_disable();
 301 #endif
 302 }
 303
 304 static inline void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
 305 {
 306         disable_irq_nosync(irq);
 307 #ifdef CONFIG_LOCKDEP
 308         local_irq_save(*flags);
 309 #endif
 310 }
 311
 312 static inline void disable_irq_lockdep(unsigned int irq)
 313 {
 314         disable_irq(irq);
 315 #ifdef CONFIG_LOCKDEP
 316         local_irq_disable();
 317 #endif
 318 }
 319
 320 static inline void enable_irq_lockdep(unsigned int irq)
 321 {
 322 #ifdef CONFIG_LOCKDEP
 323         local_irq_enable();
 324 #endif
 325         enable_irq(irq);
 326 }
 327
 328 static inline void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
 329 {
 330 #ifdef CONFIG_LOCKDEP
 331         local_irq_restore(*flags);
 332 #endif
 333         enable_irq(irq);
 334 }
 335
 336 /* IRQ wakeup (PM) control: */
 337 extern int irq_set_irq_wake(unsigned int irq, unsigned int on);
 338
 339 #ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
 340 /* Please do not use: Use the replacement functions instead */
 341 static inline int set_irq_wake(unsigned int irq, unsigned int on)
 342 {
 343         return irq_set_irq_wake(irq, on);
 344 }
 345 #endif
 346
 347 static inline int enable_irq_wake(unsigned int irq)
 348 {
 349         return irq_set_irq_wake(irq, 1);
 350 }
 351
 352 static inline int disable_irq_wake(unsigned int irq)
 353 {
 354         return irq_set_irq_wake(irq, 0);
 355 }
 356
 357 #else /* !CONFIG_GENERIC_HARDIRQS */
 358 /*
 359  * NOTE: non-genirq architectures, if they want to support the lock
 360  * validator need to define the methods below in their asm/irq.h
 361  * files, under an #ifdef CONFIG_LOCKDEP section.
 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
 373 static inline int enable_irq_wake(unsigned int irq)
 374 {
 375         return 0;
 376 }
 377
 378 static inline int disable_irq_wake(unsigned int irq)
 379 {
 380         return 0;
 381 }
 382 #endif /* CONFIG_GENERIC_HARDIRQS */
 383
 384 #ifndef __ARCH_SET_SOFTIRQ_PENDING
 385 #define set_softirq_pending(x) (local_softirq_pending() = (x))
 386 #define or_softirq_pending(x)  (local_softirq_pending() |= (x))
 387 #endif
 388
 389 /* Some architectures might implement lazy enabling/disabling of
 390  * interrupts. In some cases, such as stop_machine, we might want
 391  * to ensure that after a local_irq_disable(), interrupts have
 392  * really been disabled in hardware. Such architectures need to
 393  * implement the following hook.
 394  */
 395 #ifndef hard_irq_disable
 396 #define hard_irq_disable()      do { } while(0)
 397 #endif
 398
 399 /* PLEASE, avoid to allocate new softirqs, if you need not _really_ high
 400    frequency threaded job scheduling. For almost all the purposes
 401    tasklets are more than enough. F.e. all serial device BHs et
 402    al. should be converted to tasklets, not to softirqs.
 403  */
 404
 405 enum
 406 {
 407         HI_SOFTIRQ=0,
 408         TIMER_SOFTIRQ,
 409         NET_TX_SOFTIRQ,
 410         NET_RX_SOFTIRQ,
 411         BLOCK_SOFTIRQ,
 412         BLOCK_IOPOLL_SOFTIRQ,
 413         TASKLET_SOFTIRQ,
 414         SCHED_SOFTIRQ,
 415         HRTIMER_SOFTIRQ,
 416         RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 417
 418         NR_SOFTIRQS
 419 };
 420
 421 /* map softirq index to softirq name. update 'softirq_to_name' in
 422  * kernel/softirq.c when adding a new softirq.
 423  */
 424 extern char *softirq_to_name[NR_SOFTIRQS];
 425
 426 /* softirq mask and active fields moved to irq_cpustat_t in
 427  * asm/hardirq.h to get better cache usage.  KAO
 428  */
 429
 430 struct softirq_action
 431 {
 432         void    (*action)(struct softirq_action *);
 433 };
 434
 435 asmlinkage void do_softirq(void);
 436 asmlinkage void __do_softirq(void);
 437 extern void open_softirq(int nr, void (*action)(struct softirq_action *));
 438 extern void softirq_init(void);
 439 static inline void __raise_softirq_irqoff(unsigned int nr)
 440 {
 441         trace_softirq_raise(nr);
 442         or_softirq_pending(1UL << nr);
 443 }
 444
 445 extern void raise_softirq_irqoff(unsigned int nr);
 446 extern void raise_softirq(unsigned int nr);
 447
 448 /* This is the worklist that queues up per-cpu softirq work.
 449  *
 450  * send_remote_sendirq() adds work to these lists, and
 451  * the softirq handler itself dequeues from them.  The queues
 452  * are protected by disabling local cpu interrupts and they must
 453  * only be accessed by the local cpu that they are for.
 454  */
 455 DECLARE_PER_CPU(struct list_head [NR_SOFTIRQS], softirq_work_list);
 456
 457 /* Try to send a softirq to a remote cpu.  If this cannot be done, the
 458  * work will be queued to the local cpu.
 459  */
 460 extern void send_remote_softirq(struct call_single_data *cp, int cpu, int softirq);
 461
 462 /* Like send_remote_softirq(), but the caller must disable local cpu interrupts
 463  * and compute the current cpu, passed in as 'this_cpu'.
 464  */
 465 extern void __send_remote_softirq(struct call_single_data *cp, int cpu,
 466                                   int this_cpu, int softirq);
 467
 468 /* Tasklets --- multithreaded analogue of BHs.
 469
 470    Main feature differing them of generic softirqs: tasklet
 471    is running only on one CPU simultaneously.
 472
 473    Main feature differing them of BHs: different tasklets
 474    may be run simultaneously on different CPUs.
 475
 476    Properties:
 477    * If tasklet_schedule() is called, then tasklet is guaranteed
 478      to be executed on some cpu at least once after this.
 479    * If the tasklet is already scheduled, but its excecution is still not
 480      started, it will be executed only once.
 481    * If this tasklet is already running on another CPU (or schedule is called
 482      from tasklet itself), it is rescheduled for later.
 483    * Tasklet is strictly serialized wrt itself, but not
 484      wrt another tasklets. If client needs some intertask synchronization,
 485      he makes it with spinlocks.
 486  */
 487
 488 struct 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) \
 498 struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
 499
 500 #define DECLARE_TASKLET_DISABLED(name, func, data) \
 501 struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
 502
 503
 504 enum
 505 {
 506         TASKLET_STATE_SCHED,    /* Tasklet is scheduled for execution */
 507         TASKLET_STATE_RUN       /* Tasklet is running (SMP only) */
 508 };
 509
 510 #ifdef CONFIG_SMP
 511 static inline int tasklet_trylock(struct tasklet_struct *t)
 512 {
 513         return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
 514 }
 515
 516 static inline void tasklet_unlock(struct tasklet_struct *t)
 517 {
 518         smp_mb__before_clear_bit();
 519         clear_bit(TASKLET_STATE_RUN, &(t)->state);
 520 }
 521
 522 static 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
 532 extern void __tasklet_schedule(struct tasklet_struct *t);
 533
 534 static 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
 540 extern void __tasklet_hi_schedule(struct tasklet_struct *t);
 541
 542 static 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
 548 extern void __tasklet_hi_schedule_first(struct tasklet_struct *t);
 549
 550 /*
 551  * This version avoids touching any other tasklets. Needed for kmemcheck
 552  * in order not to take any page faults while enqueueing this tasklet;
 553  * consider VERY carefully whether you really need this or
 554  * tasklet_hi_schedule()...
 555  */
 556 static 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
 563 static inline void tasklet_disable_nosync(struct tasklet_struct *t)
 564 {
 565         atomic_inc(&t->count);
 566         smp_mb__after_atomic_inc();
 567 }
 568
 569 static inline void tasklet_disable(struct tasklet_struct *t)
 570 {
 571         tasklet_disable_nosync(t);
 572         tasklet_unlock_wait(t);
 573         smp_mb();
 574 }
 575
 576 static inline void tasklet_enable(struct tasklet_struct *t)
 577 {
 578         smp_mb__before_atomic_dec();
 579         atomic_dec(&t->count);
 580 }
 581
 582 static inline void tasklet_hi_enable(struct tasklet_struct *t)
 583 {
 584         smp_mb__before_atomic_dec();
 585         atomic_dec(&t->count);
 586 }
 587
 588 extern void tasklet_kill(struct tasklet_struct *t);
 589 extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
 590 extern void tasklet_init(struct tasklet_struct *t,
 591                          void (*func)(unsigned long), unsigned long data);
 592
 593 struct tasklet_hrtimer {
 594         struct hrtimer          timer;
 595         struct tasklet_struct   tasklet;
 596         enum hrtimer_restart    (*function)(struct hrtimer *);
 597 };
 598
 599 extern void
 600 tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
 601                      enum hrtimer_restart (*function)(struct hrtimer *),
 602                      clockid_t which_clock, enum hrtimer_mode mode);
 603
 604 static inline
 605 int tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
 606                           const enum hrtimer_mode mode)
 607 {
 608         return hrtimer_start(&ttimer->timer, time, mode);
 609 }
 610
 611 static inline
 612 void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)
 613 {
 614         hrtimer_cancel(&ttimer->timer);
 615         tasklet_kill(&ttimer->tasklet);
 616 }
 617
 618 /*
 619  * Autoprobing for irqs:
 620  *
 621  * probe_irq_on() and probe_irq_off() provide robust primitives
 622  * for accurate IRQ probing during kernel initialization.  They are
 623  * reasonably simple to use, are not "fooled" by spurious interrupts,
 624  * and, unlike other attempts at IRQ probing, they do not get hung on
 625  * stuck interrupts (such as unused PS2 mouse interfaces on ASUS boards).
 626  *
 627  * For reasonably foolproof probing, use them as follows:
 628  *
 629  * 1. clear and/or mask the device's internal interrupt.
 630  * 2. sti();
 631  * 3. irqs = probe_irq_on();      // "take over" all unassigned idle IRQs
 632  * 4. enable the device and cause it to trigger an interrupt.
 633  * 5. wait for the device to interrupt, using non-intrusive polling or a delay.
 634  * 6. irq = probe_irq_off(irqs);  // get IRQ number, 0=none, negative=multiple
 635  * 7. service the device to clear its pending interrupt.
 636  * 8. loop again if paranoia is required.
 637  *
 638  * probe_irq_on() returns a mask of allocated irq's.
 639  *
 640  * probe_irq_off() takes the mask as a parameter,
 641  * and returns the irq number which occurred,
 642  * or zero if none occurred, or a negative irq number
 643  * if more than one irq occurred.
 644  */
 645
 646 #if defined(CONFIG_GENERIC_HARDIRQS) && !defined(CONFIG_GENERIC_IRQ_PROBE)
 647 static inline unsigned long probe_irq_on(void)
 648 {
 649         return 0;
 650 }
 651 static inline int probe_irq_off(unsigned long val)
 652 {
 653         return 0;
 654 }
 655 static inline unsigned int probe_irq_mask(unsigned long val)
 656 {
 657         return 0;
 658 }
 659 #else
 660 extern unsigned long probe_irq_on(void);        /* returns 0 on failure */
 661 extern int probe_irq_off(unsigned long);        /* returns 0 or negative on failure */
 662 extern unsigned int probe_irq_mask(unsigned long);      /* returns mask of ISA interrupts */
 663 #endif
 664
 665 #ifdef CONFIG_PROC_FS
 666 /* Initialize /proc/irq/ */
 667 extern void init_irq_proc(void);
 668 #else
 669 static inline void init_irq_proc(void)
 670 {
 671 }
 672 #endif
 673
 674 struct seq_file;
 675 int show_interrupts(struct seq_file *p, void *v);
 676 int arch_show_interrupts(struct seq_file *p, int prec);
 677
 678 extern int early_irq_init(void);
 679 extern int arch_probe_nr_irqs(void);
 680 extern int arch_early_irq_init(void);
 681
 682 #endif