include/asm-cris/atomic.h

   1 /* $Id: atomic.h,v 1.3 2001/07/25 16:15:19 bjornw Exp $ */
   2
   3 #ifndef __ASM_CRIS_ATOMIC__
   4 #define __ASM_CRIS_ATOMIC__
   5
   6 #include <asm/system.h>
   7 #include <asm/arch/atomic.h>
   8 #include <linux/compiler.h>
   9
  10 /*
  11  * Atomic operations that C can't guarantee us.  Useful for
  12  * resource counting etc..
  13  */
  14
  15 typedef struct { volatile int counter; } atomic_t;
  16
  17 #define ATOMIC_INIT(i)  { (i) }
  18
  19 #define atomic_read(v) ((v)->counter)
  20 #define atomic_set(v,i) (((v)->counter) = (i))
  21
  22 /* These should be written in asm but we do it in C for now. */
  23
  24 static inline void atomic_add(int i, volatile atomic_t *v)
  25 {
  26         unsigned long flags;
  27         cris_atomic_save(v, flags);
  28         v->counter += i;
  29         cris_atomic_restore(v, flags);
  30 }
  31
  32 static inline void atomic_sub(int i, volatile atomic_t *v)
  33 {
  34         unsigned long flags;
  35         cris_atomic_save(v, flags);
  36         v->counter -= i;
  37         cris_atomic_restore(v, flags);
  38 }
  39
  40 static inline int atomic_add_return(int i, volatile atomic_t *v)
  41 {
  42         unsigned long flags;
  43         int retval;
  44         cris_atomic_save(v, flags);
  45         retval = (v->counter += i);
  46         cris_atomic_restore(v, flags);
  47         return retval;
  48 }
  49
  50 #define atomic_add_negative(a, v)       (atomic_add_return((a), (v)) < 0)
  51
  52 static inline int atomic_sub_return(int i, volatile atomic_t *v)
  53 {
  54         unsigned long flags;
  55         int retval;
  56         cris_atomic_save(v, flags);
  57         retval = (v->counter -= i);
  58         cris_atomic_restore(v, flags);
  59         return retval;
  60 }
  61
  62 static inline int atomic_sub_and_test(int i, volatile atomic_t *v)
  63 {
  64         int retval;
  65         unsigned long flags;
  66         cris_atomic_save(v, flags);
  67         retval = (v->counter -= i) == 0;
  68         cris_atomic_restore(v, flags);
  69         return retval;
  70 }
  71
  72 static inline void atomic_inc(volatile atomic_t *v)
  73 {
  74         unsigned long flags;
  75         cris_atomic_save(v, flags);
  76         (v->counter)++;
  77         cris_atomic_restore(v, flags);
  78 }
  79
  80 static inline void atomic_dec(volatile atomic_t *v)
  81 {
  82         unsigned long flags;
  83         cris_atomic_save(v, flags);
  84         (v->counter)--;
  85         cris_atomic_restore(v, flags);
  86 }
  87
  88 static inline int atomic_inc_return(volatile atomic_t *v)
  89 {
  90         unsigned long flags;
  91         int retval;
  92         cris_atomic_save(v, flags);
  93         retval = (v->counter)++;
  94         cris_atomic_restore(v, flags);
  95         return retval;
  96 }
  97
  98 static inline int atomic_dec_return(volatile atomic_t *v)
  99 {
 100         unsigned long flags;
 101         int retval;
 102         cris_atomic_save(v, flags);
 103         retval = (v->counter)--;
 104         cris_atomic_restore(v, flags);
 105         return retval;
 106 }
 107 static inline int atomic_dec_and_test(volatile atomic_t *v)
 108 {
 109         int retval;
 110         unsigned long flags;
 111         cris_atomic_save(v, flags);
 112         retval = --(v->counter) == 0;
 113         cris_atomic_restore(v, flags);
 114         return retval;
 115 }
 116
 117 static inline int atomic_inc_and_test(volatile atomic_t *v)
 118 {
 119         int retval;
 120         unsigned long flags;
 121         cris_atomic_save(v, flags);
 122         retval = ++(v->counter) == 0;
 123         cris_atomic_restore(v, flags);
 124         return retval;
 125 }
 126
 127 static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
 128 {
 129         int ret;
 130         unsigned long flags;
 131
 132         cris_atomic_save(v, flags);
 133         ret = v->counter;
 134         if (likely(ret == old))
 135                 v->counter = new;
 136         cris_atomic_restore(v, flags);
 137         return ret;
 138 }
 139
 140 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
 141
 142 static inline int atomic_add_unless(atomic_t *v, int a, int u)
 143 {
 144         int ret;
 145         unsigned long flags;
 146
 147         cris_atomic_save(v, flags);
 148         ret = v->counter;
 149         if (ret != u)
 150                 v->counter += a;
 151         cris_atomic_restore(v, flags);
 152         return ret != u;
 153 }
 154 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
 155
 156 /* Atomic operations are already serializing */
 157 #define smp_mb__before_atomic_dec()    barrier()
 158 #define smp_mb__after_atomic_dec()     barrier()
 159 #define smp_mb__before_atomic_inc()    barrier()
 160 #define smp_mb__after_atomic_inc()     barrier()
 161
 162 #include <asm-generic/atomic.h>
 163 #endif