include/asm-frv/bitops.h

   1 /* bitops.h: bit operations for the Fujitsu FR-V CPUs
   2  *
   3  * For an explanation of how atomic ops work in this arch, see:
   4  *   Documentation/fujitsu/frv/atomic-ops.txt
   5  *
   6  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
   7  * Written by David Howells (dhowells@redhat.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version
  12  * 2 of the License, or (at your option) any later version.
  13  */
  14 #ifndef _ASM_BITOPS_H
  15 #define _ASM_BITOPS_H
  16
  17 #include <linux/compiler.h>
  18 #include <asm/byteorder.h>
  19 #include <asm/system.h>
  20 #include <asm/atomic.h>
  21
  22 #ifdef __KERNEL__
  23
  24 #include <asm-generic/bitops/ffz.h>
  25
  26 /*
  27  * clear_bit() doesn't provide any barrier for the compiler.
  28  */
  29 #define smp_mb__before_clear_bit()      barrier()
  30 #define smp_mb__after_clear_bit()       barrier()
  31
  32 static inline int test_and_clear_bit(int nr, volatile void *addr)
  33 {
  34         volatile unsigned long *ptr = addr;
  35         unsigned long mask = 1UL << (nr & 31);
  36         ptr += nr >> 5;
  37         return (atomic_test_and_ANDNOT_mask(mask, ptr) & mask) != 0;
  38 }
  39
  40 static inline int test_and_set_bit(int nr, volatile void *addr)
  41 {
  42         volatile unsigned long *ptr = addr;
  43         unsigned long mask = 1UL << (nr & 31);
  44         ptr += nr >> 5;
  45         return (atomic_test_and_OR_mask(mask, ptr) & mask) != 0;
  46 }
  47
  48 static inline int test_and_change_bit(int nr, volatile void *addr)
  49 {
  50         volatile unsigned long *ptr = addr;
  51         unsigned long mask = 1UL << (nr & 31);
  52         ptr += nr >> 5;
  53         return (atomic_test_and_XOR_mask(mask, ptr) & mask) != 0;
  54 }
  55
  56 static inline void clear_bit(int nr, volatile void *addr)
  57 {
  58         test_and_clear_bit(nr, addr);
  59 }
  60
  61 static inline void set_bit(int nr, volatile void *addr)
  62 {
  63         test_and_set_bit(nr, addr);
  64 }
  65
  66 static inline void change_bit(int nr, volatile void * addr)
  67 {
  68         test_and_change_bit(nr, addr);
  69 }
  70
  71 static inline void __clear_bit(int nr, volatile void * addr)
  72 {
  73         volatile unsigned long *a = addr;
  74         int mask;
  75
  76         a += nr >> 5;
  77         mask = 1 << (nr & 31);
  78         *a &= ~mask;
  79 }
  80
  81 static inline void __set_bit(int nr, volatile void * addr)
  82 {
  83         volatile unsigned long *a = addr;
  84         int mask;
  85
  86         a += nr >> 5;
  87         mask = 1 << (nr & 31);
  88         *a |= mask;
  89 }
  90
  91 static inline void __change_bit(int nr, volatile void *addr)
  92 {
  93         volatile unsigned long *a = addr;
  94         int mask;
  95
  96         a += nr >> 5;
  97         mask = 1 << (nr & 31);
  98         *a ^= mask;
  99 }
 100
 101 static inline int __test_and_clear_bit(int nr, volatile void * addr)
 102 {
 103         volatile unsigned long *a = addr;
 104         int mask, retval;
 105
 106         a += nr >> 5;
 107         mask = 1 << (nr & 31);
 108         retval = (mask & *a) != 0;
 109         *a &= ~mask;
 110         return retval;
 111 }
 112
 113 static inline int __test_and_set_bit(int nr, volatile void * addr)
 114 {
 115         volatile unsigned long *a = addr;
 116         int mask, retval;
 117
 118         a += nr >> 5;
 119         mask = 1 << (nr & 31);
 120         retval = (mask & *a) != 0;
 121         *a |= mask;
 122         return retval;
 123 }
 124
 125 static inline int __test_and_change_bit(int nr, volatile void * addr)
 126 {
 127         volatile unsigned long *a = addr;
 128         int mask, retval;
 129
 130         a += nr >> 5;
 131         mask = 1 << (nr & 31);
 132         retval = (mask & *a) != 0;
 133         *a ^= mask;
 134         return retval;
 135 }
 136
 137 /*
 138  * This routine doesn't need to be atomic.
 139  */
 140 static inline int __constant_test_bit(int nr, const volatile void * addr)
 141 {
 142         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
 143 }
 144
 145 static inline int __test_bit(int nr, const volatile void * addr)
 146 {
 147         int     * a = (int *) addr;
 148         int     mask;
 149
 150         a += nr >> 5;
 151         mask = 1 << (nr & 0x1f);
 152         return ((mask & *a) != 0);
 153 }
 154
 155 #define test_bit(nr,addr) \
 156 (__builtin_constant_p(nr) ? \
 157  __constant_test_bit((nr),(addr)) : \
 158  __test_bit((nr),(addr)))
 159
 160 #include <asm-generic/bitops/ffs.h>
 161 #include <asm-generic/bitops/__ffs.h>
 162 #include <asm-generic/bitops/find.h>
 163
 164 /*
 165  * fls: find last bit set.
 166  */
 167 #define fls(x)                                          \
 168 ({                                                      \
 169         int bit;                                        \
 170                                                         \
 171         asm("scan %1,gr0,%0" : "=r"(bit) : "r"(x));     \
 172                                                         \
 173         bit ? 33 - bit : bit;                           \
 174 })
 175
 176 #include <asm-generic/bitops/fls64.h>
 177 #include <asm-generic/bitops/sched.h>
 178 #include <asm-generic/bitops/hweight.h>
 179
 180 #include <asm-generic/bitops/ext2-non-atomic.h>
 181
 182 #define ext2_set_bit_atomic(lock,nr,addr)       test_and_set_bit  ((nr) ^ 0x18, (addr))
 183 #define ext2_clear_bit_atomic(lock,nr,addr)     test_and_clear_bit((nr) ^ 0x18, (addr))
 184
 185 #include <asm-generic/bitops/minix-le.h>
 186
 187 #endif /* __KERNEL__ */
 188
 189 #endif /* _ASM_BITOPS_H */