arch/metag/include/asm/bitops.h

   1 #ifndef __ASM_METAG_BITOPS_H
   2 #define __ASM_METAG_BITOPS_H
   3
   4 #include <linux/compiler.h>
   5 #include <asm/barrier.h>
   6 #include <asm/global_lock.h>
   7
   8 /*
   9  * clear_bit() doesn't provide any barrier for the compiler.
  10  */
  11 #define smp_mb__before_clear_bit()      barrier()
  12 #define smp_mb__after_clear_bit()       barrier()
  13
  14 #ifdef CONFIG_SMP
  15 /*
  16  * These functions are the basis of our bit ops.
  17  */
  18 static inline void set_bit(unsigned int bit, volatile unsigned long *p)
  19 {
  20         unsigned long flags;
  21         unsigned long mask = 1UL << (bit & 31);
  22
  23         p += bit >> 5;
  24
  25         __global_lock1(flags);
  26         fence();
  27         *p |= mask;
  28         __global_unlock1(flags);
  29 }
  30
  31 static inline void clear_bit(unsigned int bit, volatile unsigned long *p)
  32 {
  33         unsigned long flags;
  34         unsigned long mask = 1UL << (bit & 31);
  35
  36         p += bit >> 5;
  37
  38         __global_lock1(flags);
  39         fence();
  40         *p &= ~mask;
  41         __global_unlock1(flags);
  42 }
  43
  44 static inline void change_bit(unsigned int bit, volatile unsigned long *p)
  45 {
  46         unsigned long flags;
  47         unsigned long mask = 1UL << (bit & 31);
  48
  49         p += bit >> 5;
  50
  51         __global_lock1(flags);
  52         fence();
  53         *p ^= mask;
  54         __global_unlock1(flags);
  55 }
  56
  57 static inline int test_and_set_bit(unsigned int bit, volatile unsigned long *p)
  58 {
  59         unsigned long flags;
  60         unsigned long old;
  61         unsigned long mask = 1UL << (bit & 31);
  62
  63         p += bit >> 5;
  64
  65         __global_lock1(flags);
  66         old = *p;
  67         if (!(old & mask)) {
  68                 fence();
  69                 *p = old | mask;
  70         }
  71         __global_unlock1(flags);
  72
  73         return (old & mask) != 0;
  74 }
  75
  76 static inline int test_and_clear_bit(unsigned int bit,
  77                                      volatile unsigned long *p)
  78 {
  79         unsigned long flags;
  80         unsigned long old;
  81         unsigned long mask = 1UL << (bit & 31);
  82
  83         p += bit >> 5;
  84
  85         __global_lock1(flags);
  86         old = *p;
  87         if (old & mask) {
  88                 fence();
  89                 *p = old & ~mask;
  90         }
  91         __global_unlock1(flags);
  92
  93         return (old & mask) != 0;
  94 }
  95
  96 static inline int test_and_change_bit(unsigned int bit,
  97                                       volatile unsigned long *p)
  98 {
  99         unsigned long flags;
 100         unsigned long old;
 101         unsigned long mask = 1UL << (bit & 31);
 102
 103         p += bit >> 5;
 104
 105         __global_lock1(flags);
 106         fence();
 107         old = *p;
 108         *p = old ^ mask;
 109         __global_unlock1(flags);
 110
 111         return (old & mask) != 0;
 112 }
 113
 114 #else
 115 #include <asm-generic/bitops/atomic.h>
 116 #endif /* CONFIG_SMP */
 117
 118 #include <asm-generic/bitops/non-atomic.h>
 119 #include <asm-generic/bitops/find.h>
 120 #include <asm-generic/bitops/ffs.h>
 121 #include <asm-generic/bitops/__ffs.h>
 122 #include <asm-generic/bitops/ffz.h>
 123 #include <asm-generic/bitops/fls.h>
 124 #include <asm-generic/bitops/__fls.h>
 125 #include <asm-generic/bitops/fls64.h>
 126 #include <asm-generic/bitops/hweight.h>
 127 #include <asm-generic/bitops/lock.h>
 128 #include <asm-generic/bitops/sched.h>
 129 #include <asm-generic/bitops/le.h>
 130 #include <asm-generic/bitops/ext2-atomic.h>
 131
 132 #endif /* __ASM_METAG_BITOPS_H */