]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - include/asm-generic/atomic.h
asm-generic/atomic.h: simplify inc/dec test helpers
[~shefty/rdma-dev.git] / 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 static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr)
144 {
145         unsigned long flags;
146
147         mask = ~mask;
148         raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
149         *addr &= mask;
150         raw_local_irq_restore(flags);
151 }
152
153 /* Assume that atomic operations are already serializing */
154 #define smp_mb__before_atomic_dec()     barrier()
155 #define smp_mb__after_atomic_dec()      barrier()
156 #define smp_mb__before_atomic_inc()     barrier()
157 #define smp_mb__after_atomic_inc()      barrier()
158
159 #endif /* __KERNEL__ */
160 #endif /* __ASM_GENERIC_ATOMIC_H */