include/asm-arm/hardirq.h

   1 #ifndef __ASM_HARDIRQ_H
   2 #define __ASM_HARDIRQ_H
   3
   4 #include <linux/config.h>
   5 #include <linux/cache.h>
   6 #include <linux/threads.h>
   7 #include <asm/irq.h>
   8
   9 typedef struct {
  10         unsigned int __softirq_pending;
  11         unsigned int __local_irq_count;
  12         unsigned int __local_bh_count;
  13         unsigned int __syscall_count;
  14         struct task_struct * __ksoftirqd_task; /* waitqueue is too large */
  15 } ____cacheline_aligned irq_cpustat_t;
  16
  17 #include <linux/irq_cpustat.h>  /* Standard mappings for irq_cpustat_t above */
  18
  19 /*
  20  * We put the hardirq and softirq counter into the preemption
  21  * counter.  The bitmask has the following meaning:
  22  *
  23  * - bits 0-7 are the preemption count (max depth: 256)
  24  * - bits 8-15 are the softirq count (max # of softirqs: 256)
  25  * - bits 16-23 are the hardirq count (max # of hardirqs: 256)
  26  * - bit 26 is the PREEMPT_ACTIVE flag
  27  */
  28 #define PREEMPT_BITS    8
  29 #define SOFTIRQ_BITS    8
  30 #define HARDIRQ_BITS    8
  31
  32 #define PREEMPT_SHIFT   0
  33 #define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
  34 #define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
  35
  36 #define __MASK(x)       ((1UL << (x))-1)
  37
  38 #define PREEMPT_MASK    (__MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
  39 #define HARDIRQ_MASK    (__MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
  40 #define SOFTIRQ_MASK    (__MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
  41
  42 #define hardirq_count() (preempt_count() & HARDIRQ_MASK)
  43 #define softirq_count() (preempt_count() & SOFTIRQ_MASK)
  44 #define irq_count()     (preempt_count() & (HARDIRQ_MASK|SOFTIRQ_MASK))
  45
  46 #define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
  47 #define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
  48 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
  49
  50 /*
  51  * The hardirq mask has to be large enough to have space
  52  * for potentially all IRQ sources in the system nesting
  53  * on a single CPU:
  54  */
  55 #if (1 << HARDIRQ_BITS) < NR_IRQS
  56 # error HARDIRQ_BITS is too low!
  57 #endif
  58
  59 /*
  60  * Are we doing bottom half or hardware interrupt processing?
  61  * Are we in a softirq context? Interrupt context?
  62  */
  63 #define in_irq()                (hardirq_count())
  64 #define in_softirq()            (softirq_count())
  65 #define in_interrupt()          (irq_count())
  66
  67 #define hardirq_trylock()       (!in_interrupt())
  68 #define hardirq_endlock()       do { } while (0)
  69
  70 #define irq_enter()             (preempt_count() += HARDIRQ_OFFSET)
  71
  72 #ifdef CONFIG_PREEMPT
  73 # define in_atomic()    ((preempt_count() & ~PREEMPT_ACTIVE) != kernel_locked())
  74 # define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
  75 #else
  76 # define in_atomic()    (preempt_count() != 0)
  77 # define IRQ_EXIT_OFFSET HARDIRQ_OFFSET
  78 #endif
  79
  80 #ifndef CONFIG_SMP
  81
  82 extern asmlinkage void __do_softirq(void);
  83
  84 #define irq_exit()                                                      \
  85         do {                                                            \
  86                 preempt_count() -= IRQ_EXIT_OFFSET;                     \
  87                 if (!in_interrupt() && local_softirq_pending())         \
  88                         __do_softirq();                                 \
  89                 preempt_enable_no_resched();                            \
  90         } while (0)
  91
  92 #define synchronize_irq(irq)    barrier()
  93 #else
  94 extern void synchronize_irq(unsigned int irq);
  95 #endif
  96
  97 #endif /* __ASM_HARDIRQ_H */