arch/x86/include/asm/atomic64_32.h

   1 #ifndef _ASM_X86_ATOMIC64_32_H
   2 #define _ASM_X86_ATOMIC64_32_H
   3
   4 #include <linux/compiler.h>
   5 #include <linux/types.h>
   6 #include <asm/processor.h>
   7 //#include <asm/cmpxchg.h>
   8
   9 /* An 64bit atomic type */
  10
  11 typedef struct {
  12         u64 __aligned(8) counter;
  13 } atomic64_t;
  14
  15 #define ATOMIC64_INIT(val)      { (val) }
  16
  17 #ifdef CONFIG_X86_CMPXCHG64
  18 #define ATOMIC64_ALTERNATIVE_(f, g) "call atomic64_" #g "_cx8"
  19 #else
  20 #define ATOMIC64_ALTERNATIVE_(f, g) ALTERNATIVE("call atomic64_" #f "_386", "call atomic64_" #g "_cx8", X86_FEATURE_CX8)
  21 #endif
  22
  23 #define ATOMIC64_ALTERNATIVE(f) ATOMIC64_ALTERNATIVE_(f, f)
  24
  25 /**
  26  * atomic64_cmpxchg - cmpxchg atomic64 variable
  27  * @p: pointer to type atomic64_t
  28  * @o: expected value
  29  * @n: new value
  30  *
  31  * Atomically sets @v to @n if it was equal to @o and returns
  32  * the old value.
  33  */
  34
  35 static inline long long atomic64_cmpxchg(atomic64_t *v, long long o, long long n)
  36 {
  37         return cmpxchg64(&v->counter, o, n);
  38 }
  39
  40 /**
  41  * atomic64_xchg - xchg atomic64 variable
  42  * @v: pointer to type atomic64_t
  43  * @n: value to assign
  44  *
  45  * Atomically xchgs the value of @v to @n and returns
  46  * the old value.
  47  */
  48 static inline long long atomic64_xchg(atomic64_t *v, long long n)
  49 {
  50         long long o;
  51         unsigned high = (unsigned)(n >> 32);
  52         unsigned low = (unsigned)n;
  53         asm volatile(ATOMIC64_ALTERNATIVE(xchg)
  54                      : "=A" (o), "+b" (low), "+c" (high)
  55                      : "S" (v)
  56                      : "memory"
  57                      );
  58         return o;
  59 }
  60
  61 /**
  62  * atomic64_set - set atomic64 variable
  63  * @v: pointer to type atomic64_t
  64  * @n: value to assign
  65  *
  66  * Atomically sets the value of @v to @n.
  67  */
  68 static inline void atomic64_set(atomic64_t *v, long long i)
  69 {
  70         unsigned high = (unsigned)(i >> 32);
  71         unsigned low = (unsigned)i;
  72         asm volatile(ATOMIC64_ALTERNATIVE(set)
  73                      : "+b" (low), "+c" (high)
  74                      : "S" (v)
  75                      : "eax", "edx", "memory"
  76                      );
  77 }
  78
  79 /**
  80  * atomic64_read - read atomic64 variable
  81  * @v: pointer to type atomic64_t
  82  *
  83  * Atomically reads the value of @v and returns it.
  84  */
  85 static inline long long atomic64_read(const atomic64_t *v)
  86 {
  87         long long r;
  88         asm volatile(ATOMIC64_ALTERNATIVE(read)
  89                      : "=A" (r), "+c" (v)
  90                      : : "memory"
  91                      );
  92         return r;
  93  }
  94
  95 /**
  96  * atomic64_add_return - add and return
  97  * @i: integer value to add
  98  * @v: pointer to type atomic64_t
  99  *
 100  * Atomically adds @i to @v and returns @i + *@v
 101  */
 102 static inline long long atomic64_add_return(long long i, atomic64_t *v)
 103 {
 104         asm volatile(ATOMIC64_ALTERNATIVE(add_return)
 105                      : "+A" (i), "+c" (v)
 106                      : : "memory"
 107                      );
 108         return i;
 109 }
 110
 111 /*
 112  * Other variants with different arithmetic operators:
 113  */
 114 static inline long long atomic64_sub_return(long long i, atomic64_t *v)
 115 {
 116         asm volatile(ATOMIC64_ALTERNATIVE(sub_return)
 117                      : "+A" (i), "+c" (v)
 118                      : : "memory"
 119                      );
 120         return i;
 121 }
 122
 123 static inline long long atomic64_inc_return(atomic64_t *v)
 124 {
 125         long long a;
 126         asm volatile(ATOMIC64_ALTERNATIVE(inc_return)
 127                      : "=A" (a)
 128                      : "S" (v)
 129                      : "memory", "ecx"
 130                      );
 131         return a;
 132 }
 133
 134 static inline long long atomic64_dec_return(atomic64_t *v)
 135 {
 136         long long a;
 137         asm volatile(ATOMIC64_ALTERNATIVE(dec_return)
 138                      : "=A" (a)
 139                      : "S" (v)
 140                      : "memory", "ecx"
 141                      );
 142         return a;
 143 }
 144
 145 /**
 146  * atomic64_add - add integer to atomic64 variable
 147  * @i: integer value to add
 148  * @v: pointer to type atomic64_t
 149  *
 150  * Atomically adds @i to @v.
 151  */
 152 static inline long long atomic64_add(long long i, atomic64_t *v)
 153 {
 154         asm volatile(ATOMIC64_ALTERNATIVE_(add, add_return)
 155                      : "+A" (i), "+c" (v)
 156                      : : "memory"
 157                      );
 158         return i;
 159 }
 160
 161 /**
 162  * atomic64_sub - subtract the atomic64 variable
 163  * @i: integer value to subtract
 164  * @v: pointer to type atomic64_t
 165  *
 166  * Atomically subtracts @i from @v.
 167  */
 168 static inline long long atomic64_sub(long long i, atomic64_t *v)
 169 {
 170         asm volatile(ATOMIC64_ALTERNATIVE_(sub, sub_return)
 171                      : "+A" (i), "+c" (v)
 172                      : : "memory"
 173                      );
 174         return i;
 175 }
 176
 177 /**
 178  * atomic64_sub_and_test - subtract value from variable and test result
 179  * @i: integer value to subtract
 180  * @v: pointer to type atomic64_t
 181   *
 182  * Atomically subtracts @i from @v and returns
 183  * true if the result is zero, or false for all
 184  * other cases.
 185  */
 186 static inline int atomic64_sub_and_test(long long i, atomic64_t *v)
 187 {
 188         return atomic64_sub_return(i, v) == 0;
 189 }
 190
 191 /**
 192  * atomic64_inc - increment atomic64 variable
 193  * @v: pointer to type atomic64_t
 194  *
 195  * Atomically increments @v by 1.
 196  */
 197 static inline void atomic64_inc(atomic64_t *v)
 198 {
 199         asm volatile(ATOMIC64_ALTERNATIVE_(inc, inc_return)
 200                      : : "S" (v)
 201                      : "memory", "eax", "ecx", "edx"
 202                      );
 203 }
 204
 205 /**
 206  * atomic64_dec - decrement atomic64 variable
 207  * @ptr: pointer to type atomic64_t
 208  *
 209  * Atomically decrements @ptr by 1.
 210  */
 211 static inline void atomic64_dec(atomic64_t *v)
 212 {
 213         asm volatile(ATOMIC64_ALTERNATIVE_(dec, dec_return)
 214                      : : "S" (v)
 215                      : "memory", "eax", "ecx", "edx"
 216                      );
 217 }
 218
 219 /**
 220  * atomic64_dec_and_test - decrement and test
 221  * @v: pointer to type atomic64_t
 222  *
 223  * Atomically decrements @v by 1 and
 224  * returns true if the result is 0, or false for all other
 225  * cases.
 226  */
 227 static inline int atomic64_dec_and_test(atomic64_t *v)
 228 {
 229         return atomic64_dec_return(v) == 0;
 230 }
 231
 232 /**
 233  * atomic64_inc_and_test - increment and test
 234  * @v: pointer to type atomic64_t
 235  *
 236  * Atomically increments @v by 1
 237  * and returns true if the result is zero, or false for all
 238  * other cases.
 239  */
 240 static inline int atomic64_inc_and_test(atomic64_t *v)
 241 {
 242         return atomic64_inc_return(v) == 0;
 243 }
 244
 245 /**
 246  * atomic64_add_negative - add and test if negative
 247  * @i: integer value to add
 248  * @v: pointer to type atomic64_t
 249  *
 250  * Atomically adds @i to @v and returns true
 251  * if the result is negative, or false when
 252  * result is greater than or equal to zero.
 253  */
 254 static inline int atomic64_add_negative(long long i, atomic64_t *v)
 255 {
 256         return atomic64_add_return(i, v) < 0;
 257 }
 258
 259 /**
 260  * atomic64_add_unless - add unless the number is a given value
 261  * @v: pointer of type atomic64_t
 262  * @a: the amount to add to v...
 263  * @u: ...unless v is equal to u.
 264  *
 265  * Atomically adds @a to @v, so long as it was not @u.
 266  * Returns the old value of @v.
 267  */
 268 static inline int atomic64_add_unless(atomic64_t *v, long long a, long long u)
 269 {
 270         unsigned low = (unsigned)u;
 271         unsigned high = (unsigned)(u >> 32);
 272         asm volatile(ATOMIC64_ALTERNATIVE(add_unless) "\n\t"
 273                      : "+A" (a), "+c" (v), "+S" (low), "+D" (high)
 274                      : : "memory");
 275         return (int)a;
 276 }
 277
 278
 279 static inline int atomic64_inc_not_zero(atomic64_t *v)
 280 {
 281         int r;
 282         asm volatile(ATOMIC64_ALTERNATIVE(inc_not_zero)
 283                      : "=a" (r)
 284                      : "S" (v)
 285                      : "ecx", "edx", "memory"
 286                      );
 287         return r;
 288 }
 289
 290 static inline long long atomic64_dec_if_positive(atomic64_t *v)
 291 {
 292         long long r;
 293         asm volatile(ATOMIC64_ALTERNATIVE(dec_if_positive)
 294                      : "=A" (r)
 295                      : "S" (v)
 296                      : "ecx", "memory"
 297                      );
 298         return r;
 299 }
 300
 301 #undef ATOMIC64_ALTERNATIVE
 302 #undef ATOMIC64_ALTERNATIVE_
 303
 304 #endif /* _ASM_X86_ATOMIC64_32_H */