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 #ifdef CONFIG_SMP
  19 #error not SMP safe
  20 #endif
  21
  22 /*
  23  * Atomic operations that C can't guarantee us.  Useful for
  24  * resource counting etc..
  25  */
  26
  27 #define ATOMIC_INIT(i)  { (i) }
  28
  29 #ifdef __KERNEL__
  30
  31 /**
  32  * atomic_read - read atomic variable
  33  * @v: pointer of type atomic_t
  34  *
  35  * Atomically reads the value of @v.
  36  */
  37 #define atomic_read(v)  (*(volatile int *)&(v)->counter)
  38
  39 /**
  40  * atomic_set - set atomic variable
  41  * @v: pointer of type atomic_t
  42  * @i: required value
  43  *
  44  * Atomically sets the value of @v to @i.
  45  */
  46 #define atomic_set(v, i) (((v)->counter) = (i))
  47
  48 #include <linux/irqflags.h>
  49 #include <asm/system.h>
  50
  51 /**
  52  * atomic_add_return - add integer to atomic variable
  53  * @i: integer value to add
  54  * @v: pointer of type atomic_t
  55  *
  56  * Atomically adds @i to @v and returns the result
  57  */
  58 static inline int atomic_add_return(int i, atomic_t *v)
  59 {
  60         unsigned long flags;
  61         int temp;
  62
  63         raw_local_irq_save(flags); /* Don't trace it in an irqsoff handler */
  64         temp = v->counter;
  65         temp += i;
  66         v->counter = temp;
  67         raw_local_irq_restore(flags);
  68
  69         return temp;
  70 }
  71
  72 /**
  73  * atomic_sub_return - subtract integer from atomic variable
  74  * @i: integer value to subtract
  75  * @v: pointer of type atomic_t
  76  *
  77  * Atomically subtracts @i from @v and returns the result
  78  */
  79 static inline int atomic_sub_return(int i, atomic_t *v)
  80 {
  81         unsigned long flags;
  82         int temp;
  83
  84         raw_local_irq_save(flags); /* Don't trace it in an irqsoff handler */
  85         temp = v->counter;
  86         temp -= i;
  87         v->counter = temp;
  88         raw_local_irq_restore(flags);
  89
  90         return temp;
  91 }
  92
  93 static inline int atomic_add_negative(int i, atomic_t *v)
  94 {
  95         return atomic_add_return(i, v) < 0;
  96 }
  97
  98 static inline void atomic_add(int i, atomic_t *v)
  99 {
 100         atomic_add_return(i, v);
 101 }
 102
 103 static inline void atomic_sub(int i, atomic_t *v)
 104 {
 105         atomic_sub_return(i, v);
 106 }
 107
 108 static inline void atomic_inc(atomic_t *v)
 109 {
 110         atomic_add_return(1, v);
 111 }
 112
 113 static inline void atomic_dec(atomic_t *v)
 114 {
 115         atomic_sub_return(1, v);
 116 }
 117
 118 #define atomic_dec_return(v)            atomic_sub_return(1, (v))
 119 #define atomic_inc_return(v)            atomic_add_return(1, (v))
 120
 121 #define atomic_sub_and_test(i, v)       (atomic_sub_return((i), (v)) == 0)
 122 #define atomic_dec_and_test(v)          (atomic_dec_return(v) == 0)
 123 #define atomic_inc_and_test(v)          (atomic_inc_return(v) == 0)
 124
 125 #define atomic_xchg(ptr, v)             (xchg(&(ptr)->counter, (v)))
 126 #define atomic_cmpxchg(v, old, new)     (cmpxchg(&((v)->counter), (old), (new)))
 127
 128 #define cmpxchg_local(ptr, o, n)                                               \
 129         ((__typeof__(*(ptr)))__cmpxchg_local_generic((ptr), (unsigned long)(o),\
 130                         (unsigned long)(n), sizeof(*(ptr))))
 131
 132 #define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))
 133
 134 static inline int __atomic_add_unless(atomic_t *v, int a, int u)
 135 {
 136   int c, old;
 137   c = atomic_read(v);
 138   while (c != u && (old = atomic_cmpxchg(v, c, c + a)) != c)
 139     c = old;
 140   return c;
 141 }
 142
 143 /**
 144  * atomic_clear_mask - Atomically clear bits in atomic variable
 145  * @mask: Mask of the bits to be cleared
 146  * @v: pointer of type atomic_t
 147  *
 148  * Atomically clears the bits set in @mask from @v
 149  */
 150 static inline void atomic_clear_mask(unsigned long mask, atomic_t *v)
 151 {
 152         unsigned long flags;
 153
 154         mask = ~mask;
 155         raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
 156         v->counter &= mask;
 157         raw_local_irq_restore(flags);
 158 }
 159
 160 /**
 161  * atomic_set_mask - Atomically set bits in atomic variable
 162  * @mask: Mask of the bits to be set
 163  * @v: pointer of type atomic_t
 164  *
 165  * Atomically sets the bits set in @mask in @v
 166  */
 167 static inline void atomic_set_mask(unsigned int mask, atomic_t *v)
 168 {
 169         unsigned long flags;
 170
 171         raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
 172         v->counter |= mask;
 173         raw_local_irq_restore(flags);
 174 }
 175
 176 /* Assume that atomic operations are already serializing */
 177 #define smp_mb__before_atomic_dec()     barrier()
 178 #define smp_mb__after_atomic_dec()      barrier()
 179 #define smp_mb__before_atomic_inc()     barrier()
 180 #define smp_mb__after_atomic_inc()      barrier()
 181
 182 #endif /* __KERNEL__ */
 183 #endif /* __ASM_GENERIC_ATOMIC_H */