arch/parisc/include/asm/bitops.h

   1 #ifndef _PARISC_BITOPS_H
   2 #define _PARISC_BITOPS_H
   3
   4 #ifndef _LINUX_BITOPS_H
   5 #error only <linux/bitops.h> can be included directly
   6 #endif
   7
   8 #include <linux/compiler.h>
   9 #include <asm/types.h>
  10 #include <asm/byteorder.h>
  11 #include <asm/barrier.h>
  12 #include <linux/atomic.h>
  13
  14 /*
  15  * HP-PARISC specific bit operations
  16  * for a detailed description of the functions please refer
  17  * to include/asm-i386/bitops.h or kerneldoc
  18  */
  19
  20 #if __BITS_PER_LONG == 64
  21 #define SHIFT_PER_LONG 6
  22 #else
  23 #define SHIFT_PER_LONG 5
  24 #endif
  25
  26 #define CHOP_SHIFTCOUNT(x) (((unsigned long) (x)) & (BITS_PER_LONG - 1))
  27
  28
  29 /* See http://marc.theaimsgroup.com/?t=108826637900003 for discussion
  30  * on use of volatile and __*_bit() (set/clear/change):
  31  *      *_bit() want use of volatile.
  32  *      __*_bit() are "relaxed" and don't use spinlock or volatile.
  33  */
  34
  35 static __inline__ void set_bit(int nr, volatile unsigned long * addr)
  36 {
  37         unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
  38         unsigned long flags;
  39
  40         addr += (nr >> SHIFT_PER_LONG);
  41         _atomic_spin_lock_irqsave(addr, flags);
  42         *addr |= mask;
  43         _atomic_spin_unlock_irqrestore(addr, flags);
  44 }
  45
  46 static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
  47 {
  48         unsigned long mask = ~(1UL << CHOP_SHIFTCOUNT(nr));
  49         unsigned long flags;
  50
  51         addr += (nr >> SHIFT_PER_LONG);
  52         _atomic_spin_lock_irqsave(addr, flags);
  53         *addr &= mask;
  54         _atomic_spin_unlock_irqrestore(addr, flags);
  55 }
  56
  57 static __inline__ void change_bit(int nr, volatile unsigned long * addr)
  58 {
  59         unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
  60         unsigned long flags;
  61
  62         addr += (nr >> SHIFT_PER_LONG);
  63         _atomic_spin_lock_irqsave(addr, flags);
  64         *addr ^= mask;
  65         _atomic_spin_unlock_irqrestore(addr, flags);
  66 }
  67
  68 static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
  69 {
  70         unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
  71         unsigned long old;
  72         unsigned long flags;
  73         int set;
  74
  75         addr += (nr >> SHIFT_PER_LONG);
  76         _atomic_spin_lock_irqsave(addr, flags);
  77         old = *addr;
  78         set = (old & mask) ? 1 : 0;
  79         if (!set)
  80                 *addr = old | mask;
  81         _atomic_spin_unlock_irqrestore(addr, flags);
  82
  83         return set;
  84 }
  85
  86 static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
  87 {
  88         unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
  89         unsigned long old;
  90         unsigned long flags;
  91         int set;
  92
  93         addr += (nr >> SHIFT_PER_LONG);
  94         _atomic_spin_lock_irqsave(addr, flags);
  95         old = *addr;
  96         set = (old & mask) ? 1 : 0;
  97         if (set)
  98                 *addr = old & ~mask;
  99         _atomic_spin_unlock_irqrestore(addr, flags);
 100
 101         return set;
 102 }
 103
 104 static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
 105 {
 106         unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
 107         unsigned long oldbit;
 108         unsigned long flags;
 109
 110         addr += (nr >> SHIFT_PER_LONG);
 111         _atomic_spin_lock_irqsave(addr, flags);
 112         oldbit = *addr;
 113         *addr = oldbit ^ mask;
 114         _atomic_spin_unlock_irqrestore(addr, flags);
 115
 116         return (oldbit & mask) ? 1 : 0;
 117 }
 118
 119 #include <asm-generic/bitops/non-atomic.h>
 120
 121 #ifdef __KERNEL__
 122
 123 /**
 124  * __ffs - find first bit in word. returns 0 to "BITS_PER_LONG-1".
 125  * @word: The word to search
 126  *
 127  * __ffs() return is undefined if no bit is set.
 128  *
 129  * 32-bit fast __ffs by LaMont Jones "lamont At hp com".
 130  * 64-bit enhancement by Grant Grundler "grundler At parisc-linux org".
 131  * (with help from willy/jejb to get the semantics right)
 132  *
 133  * This algorithm avoids branches by making use of nullification.
 134  * One side effect of "extr" instructions is it sets PSW[N] bit.
 135  * How PSW[N] (nullify next insn) gets set is determined by the
 136  * "condition" field (eg "<>" or "TR" below) in the extr* insn.
 137  * Only the 1st and one of either the 2cd or 3rd insn will get executed.
 138  * Each set of 3 insn will get executed in 2 cycles on PA8x00 vs 16 or so
 139  * cycles for each mispredicted branch.
 140  */
 141
 142 static __inline__ unsigned long __ffs(unsigned long x)
 143 {
 144         unsigned long ret;
 145
 146         __asm__(
 147 #ifdef CONFIG_64BIT
 148                 " ldi       63,%1\n"
 149                 " extrd,u,*<>  %0,63,32,%%r0\n"
 150                 " extrd,u,*TR  %0,31,32,%0\n"   /* move top 32-bits down */
 151                 " addi    -32,%1,%1\n"
 152 #else
 153                 " ldi       31,%1\n"
 154 #endif
 155                 " extru,<>  %0,31,16,%%r0\n"
 156                 " extru,TR  %0,15,16,%0\n"      /* xxxx0000 -> 0000xxxx */
 157                 " addi    -16,%1,%1\n"
 158                 " extru,<>  %0,31,8,%%r0\n"
 159                 " extru,TR  %0,23,8,%0\n"       /* 0000xx00 -> 000000xx */
 160                 " addi    -8,%1,%1\n"
 161                 " extru,<>  %0,31,4,%%r0\n"
 162                 " extru,TR  %0,27,4,%0\n"       /* 000000x0 -> 0000000x */
 163                 " addi    -4,%1,%1\n"
 164                 " extru,<>  %0,31,2,%%r0\n"
 165                 " extru,TR  %0,29,2,%0\n"       /* 0000000y, 1100b -> 0011b */
 166                 " addi    -2,%1,%1\n"
 167                 " extru,=  %0,31,1,%%r0\n"      /* check last bit */
 168                 " addi    -1,%1,%1\n"
 169                         : "+r" (x), "=r" (ret) );
 170         return ret;
 171 }
 172
 173 #include <asm-generic/bitops/ffz.h>
 174
 175 /*
 176  * ffs: find first bit set. returns 1 to BITS_PER_LONG or 0 (if none set)
 177  * This is defined the same way as the libc and compiler builtin
 178  * ffs routines, therefore differs in spirit from the above ffz (man ffs).
 179  */
 180 static __inline__ int ffs(int x)
 181 {
 182         return x ? (__ffs((unsigned long)x) + 1) : 0;
 183 }
 184
 185 /*
 186  * fls: find last (most significant) bit set.
 187  * fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
 188  */
 189
 190 static __inline__ int fls(int x)
 191 {
 192         int ret;
 193         if (!x)
 194                 return 0;
 195
 196         __asm__(
 197         "       ldi             1,%1\n"
 198         "       extru,<>        %0,15,16,%%r0\n"
 199         "       zdep,TR         %0,15,16,%0\n"          /* xxxx0000 */
 200         "       addi            16,%1,%1\n"
 201         "       extru,<>        %0,7,8,%%r0\n"
 202         "       zdep,TR         %0,23,24,%0\n"          /* xx000000 */
 203         "       addi            8,%1,%1\n"
 204         "       extru,<>        %0,3,4,%%r0\n"
 205         "       zdep,TR         %0,27,28,%0\n"          /* x0000000 */
 206         "       addi            4,%1,%1\n"
 207         "       extru,<>        %0,1,2,%%r0\n"
 208         "       zdep,TR         %0,29,30,%0\n"          /* y0000000 (y&3 = 0) */
 209         "       addi            2,%1,%1\n"
 210         "       extru,=         %0,0,1,%%r0\n"
 211         "       addi            1,%1,%1\n"              /* if y & 8, add 1 */
 212                 : "+r" (x), "=r" (ret) );
 213
 214         return ret;
 215 }
 216
 217 #include <asm-generic/bitops/__fls.h>
 218 #include <asm-generic/bitops/fls64.h>
 219 #include <asm-generic/bitops/hweight.h>
 220 #include <asm-generic/bitops/lock.h>
 221 #include <asm-generic/bitops/sched.h>
 222
 223 #endif /* __KERNEL__ */
 224
 225 #include <asm-generic/bitops/find.h>
 226
 227 #ifdef __KERNEL__
 228
 229 #include <asm-generic/bitops/le.h>
 230 #include <asm-generic/bitops/ext2-atomic-setbit.h>
 231
 232 #endif  /* __KERNEL__ */
 233
 234 #endif /* _PARISC_BITOPS_H */