include/asm-generic/atomic.h

   1 /*
   2  * Generic C implementation of atomic counter operations. Usable on
   3  * UP systems only. Do not include in machine independent code.
   4  *
   5  * Originally implemented for MN10300.
   6  *
   7  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   8  * Written by David Howells (dhowells@redhat.com)
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public Licence
  12  * as published by the Free Software Foundation; either version
  13  * 2 of the Licence, or (at your option) any later version.
  14  */
  15 #ifndef __ASM_GENERIC_ATOMIC_H
  16 #define __ASM_GENERIC_ATOMIC_H
  17
  18 #include <asm/cmpxchg.h>
  19
  20 #ifdef CONFIG_SMP
  21 /* Force people to define core atomics */
  22 # if !defined(atomic_add_return) || !defined(atomic_sub_return) || \
  23      !defined(atomic_clear_mask) || !defined(atomic_set_mask)
  24 #  error "SMP requires a little arch-specific magic"
  25 # endif
  26 #endif
  27
  28 /*
  29  * Atomic operations that C can't guarantee us.  Useful for
  30  * resource counting etc..
  31  */
  32
  33 #define ATOMIC_INIT(i)  { (i) }
  34
  35 #ifdef __KERNEL__
  36
  37 /**
  38  * atomic_read - read atomic variable
  39  * @v: pointer of type atomic_t
  40  *
  41  * Atomically reads the value of @v.
  42  */
  43 #ifndef atomic_read
  44 #define atomic_read(v)  (*(volatile int *)&(v)->counter)
  45 #endif
  46
  47 /**
  48  * atomic_set - set atomic variable
  49  * @v: pointer of type atomic_t
  50  * @i: required value
  51  *
  52  * Atomically sets the value of @v to @i.
  53  */
  54 #define atomic_set(v, i) (((v)->counter) = (i))
  55
  56 #include <linux/irqflags.h>
  57 #include <asm/system.h>
  58
  59 /**
  60  * atomic_add_return - add integer to atomic variable
  61  * @i: integer value to add
  62  * @v: pointer of type atomic_t
  63  *
  64  * Atomically adds @i to @v and returns the result
  65  */
  66 #ifndef atomic_add_return
  67 static inline int atomic_add_return(int i, atomic_t *v)
  68 {
  69         unsigned long flags;
  70         int temp;
  71
  72         raw_local_irq_save(flags); /* Don't trace it in an irqsoff handler */
  73         temp = v->counter;
  74         temp += i;
  75         v->counter = temp;
  76         raw_local_irq_restore(flags);
  77
  78         return temp;
  79 }
  80 #endif
  81
  82 /**
  83  * atomic_sub_return - subtract integer from atomic variable
  84  * @i: integer value to subtract
  85  * @v: pointer of type atomic_t
  86  *
  87  * Atomically subtracts @i from @v and returns the result
  88  */
  89 #ifndef atomic_sub_return
  90 static inline int atomic_sub_return(int i, atomic_t *v)
  91 {
  92         unsigned long flags;
  93         int temp;
  94
  95         raw_local_irq_save(flags); /* Don't trace it in an irqsoff handler */
  96         temp = v->counter;
  97         temp -= i;
  98         v->counter = temp;
  99         raw_local_irq_restore(flags);
 100
 101         return temp;
 102 }
 103 #endif
 104
 105 static inline int atomic_add_negative(int i, atomic_t *v)
 106 {
 107         return atomic_add_return(i, v) < 0;
 108 }
 109
 110 static inline void atomic_add(int i, atomic_t *v)
 111 {
 112         atomic_add_return(i, v);
 113 }
 114
 115 static inline void atomic_sub(int i, atomic_t *v)
 116 {
 117         atomic_sub_return(i, v);
 118 }
 119
 120 static inline void atomic_inc(atomic_t *v)
 121 {
 122         atomic_add_return(1, v);
 123 }
 124
 125 static inline void atomic_dec(atomic_t *v)
 126 {
 127         atomic_sub_return(1, v);
 128 }
 129
 130 #define atomic_dec_return(v)            atomic_sub_return(1, (v))
 131 #define atomic_inc_return(v)            atomic_add_return(1, (v))
 132
 133 #define atomic_sub_and_test(i, v)       (atomic_sub_return((i), (v)) == 0)
 134 #define atomic_dec_and_test(v)          (atomic_dec_return(v) == 0)
 135 #define atomic_inc_and_test(v)          (atomic_inc_return(v) == 0)
 136
 137 #define atomic_xchg(ptr, v)             (xchg(&(ptr)->counter, (v)))
 138 #define atomic_cmpxchg(v, old, new)     (cmpxchg(&((v)->counter), (old), (new)))
 139
 140 #define cmpxchg_local(ptr, o, n)                                               \
 141         ((__typeof__(*(ptr)))__cmpxchg_local_generic((ptr), (unsigned long)(o),\
 142                         (unsigned long)(n), sizeof(*(ptr))))
 143
 144 #define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))
 145
 146 static inline int __atomic_add_unless(atomic_t *v, int a, int u)
 147 {
 148   int c, old;
 149   c = atomic_read(v);
 150   while (c != u && (old = atomic_cmpxchg(v, c, c + a)) != c)
 151     c = old;
 152   return c;
 153 }
 154
 155 /**
 156  * atomic_clear_mask - Atomically clear bits in atomic variable
 157  * @mask: Mask of the bits to be cleared
 158  * @v: pointer of type atomic_t
 159  *
 160  * Atomically clears the bits set in @mask from @v
 161  */
 162 #ifndef atomic_clear_mask
 163 static inline void atomic_clear_mask(unsigned long mask, atomic_t *v)
 164 {
 165         unsigned long flags;
 166
 167         mask = ~mask;
 168         raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
 169         v->counter &= mask;
 170         raw_local_irq_restore(flags);
 171 }
 172 #endif
 173
 174 /**
 175  * atomic_set_mask - Atomically set bits in atomic variable
 176  * @mask: Mask of the bits to be set
 177  * @v: pointer of type atomic_t
 178  *
 179  * Atomically sets the bits set in @mask in @v
 180  */
 181 #ifndef atomic_set_mask
 182 static inline void atomic_set_mask(unsigned int mask, atomic_t *v)
 183 {
 184         unsigned long flags;
 185
 186         raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
 187         v->counter |= mask;
 188         raw_local_irq_restore(flags);
 189 }
 190 #endif
 191
 192 /* Assume that atomic operations are already serializing */
 193 #define smp_mb__before_atomic_dec()     barrier()
 194 #define smp_mb__after_atomic_dec()      barrier()
 195 #define smp_mb__before_atomic_inc()     barrier()
 196 #define smp_mb__after_atomic_inc()      barrier()
 197
 198 #endif /* __KERNEL__ */
 199 #endif /* __ASM_GENERIC_ATOMIC_H */