1#ifndef __ARCH_I386_ATOMIC__
2#define __ARCH_I386_ATOMIC__
3
4#include <linux/compiler.h>
5#include <asm/processor.h>
6#include <asm/cmpxchg.h>
7
8/*
9 * Atomic operations that C can't guarantee us.  Useful for
10 * resource counting etc..
11 */
12
13/*
14 * Make sure gcc doesn't try to be clever and move things around
15 * on us. We need to use _exactly_ the address the user gave us,
16 * not some alias that contains the same information.
17 */
18typedef struct { int counter; } atomic_t;
19
20#define ATOMIC_INIT(i)	{ (i) }
21
22/**
23 * atomic_read - read atomic variable
24 * @v: pointer of type atomic_t
25 *
26 * Atomically reads the value of @v.
27 */
28#define atomic_read(v)		((v)->counter)
29
30/**
31 * atomic_set - set atomic variable
32 * @v: pointer of type atomic_t
33 * @i: required value
34 *
35 * Atomically sets the value of @v to @i.
36 */
37#define atomic_set(v,i)		(((v)->counter) = (i))
38
39/**
40 * atomic_add - add integer to atomic variable
41 * @i: integer value to add
42 * @v: pointer of type atomic_t
43 *
44 * Atomically adds @i to @v.
45 */
46static __inline__ void atomic_add(int i, atomic_t *v)
47{
48	__asm__ __volatile__(
49		LOCK_PREFIX "addl %1,%0"
50		:"+m" (v->counter)
51		:"ir" (i));
52}
53
54/**
55 * atomic_sub - subtract integer from atomic variable
56 * @i: integer value to subtract
57 * @v: pointer of type atomic_t
58 *
59 * Atomically subtracts @i from @v.
60 */
61static __inline__ void atomic_sub(int i, atomic_t *v)
62{
63	__asm__ __volatile__(
64		LOCK_PREFIX "subl %1,%0"
65		:"+m" (v->counter)
66		:"ir" (i));
67}
68
69/**
70 * atomic_sub_and_test - subtract value from variable and test result
71 * @i: integer value to subtract
72 * @v: pointer of type atomic_t
73 *
74 * Atomically subtracts @i from @v and returns
75 * true if the result is zero, or false for all
76 * other cases.
77 */
78static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
79{
80	unsigned char c;
81
82	__asm__ __volatile__(
83		LOCK_PREFIX "subl %2,%0; sete %1"
84		:"+m" (v->counter), "=qm" (c)
85		:"ir" (i) : "memory");
86	return c;
87}
88
89/**
90 * atomic_inc - increment atomic variable
91 * @v: pointer of type atomic_t
92 *
93 * Atomically increments @v by 1.
94 */
95static __inline__ void atomic_inc(atomic_t *v)
96{
97	__asm__ __volatile__(
98		LOCK_PREFIX "incl %0"
99		:"+m" (v->counter));
100}
101
102/**
103 * atomic_dec - decrement atomic variable
104 * @v: pointer of type atomic_t
105 *
106 * Atomically decrements @v by 1.
107 */
108static __inline__ void atomic_dec(atomic_t *v)
109{
110	__asm__ __volatile__(
111		LOCK_PREFIX "decl %0"
112		:"+m" (v->counter));
113}
114
115/**
116 * atomic_dec_and_test - decrement and test
117 * @v: pointer of type atomic_t
118 *
119 * Atomically decrements @v by 1 and
120 * returns true if the result is 0, or false for all other
121 * cases.
122 */
123static __inline__ int atomic_dec_and_test(atomic_t *v)
124{
125	unsigned char c;
126
127	__asm__ __volatile__(
128		LOCK_PREFIX "decl %0; sete %1"
129		:"+m" (v->counter), "=qm" (c)
130		: : "memory");
131	return c != 0;
132}
133
134/**
135 * atomic_inc_and_test - increment and test
136 * @v: pointer of type atomic_t
137 *
138 * Atomically increments @v by 1
139 * and returns true if the result is zero, or false for all
140 * other cases.
141 */
142static __inline__ int atomic_inc_and_test(atomic_t *v)
143{
144	unsigned char c;
145
146	__asm__ __volatile__(
147		LOCK_PREFIX "incl %0; sete %1"
148		:"+m" (v->counter), "=qm" (c)
149		: : "memory");
150	return c != 0;
151}
152
153/**
154 * atomic_add_negative - add and test if negative
155 * @v: pointer of type atomic_t
156 * @i: integer value to add
157 *
158 * Atomically adds @i to @v and returns true
159 * if the result is negative, or false when
160 * result is greater than or equal to zero.
161 */
162static __inline__ int atomic_add_negative(int i, atomic_t *v)
163{
164	unsigned char c;
165
166	__asm__ __volatile__(
167		LOCK_PREFIX "addl %2,%0; sets %1"
168		:"+m" (v->counter), "=qm" (c)
169		:"ir" (i) : "memory");
170	return c;
171}
172
173/**
174 * atomic_add_return - add integer and return
175 * @v: pointer of type atomic_t
176 * @i: integer value to add
177 *
178 * Atomically adds @i to @v and returns @i + @v
179 */
180static __inline__ int atomic_add_return(int i, atomic_t *v)
181{
182	int __i;
183#ifdef CONFIG_M386
184	unsigned long flags;
185	if(unlikely(boot_cpu_data.x86 <= 3))
186		goto no_xadd;
187#endif
188	/* Modern 486+ processor */
189	__i = i;
190	__asm__ __volatile__(
191		LOCK_PREFIX "xaddl %0, %1"
192		:"+r" (i), "+m" (v->counter)
193		: : "memory");
194	return i + __i;
195
196#ifdef CONFIG_M386
197no_xadd: /* Legacy 386 processor */
198	local_irq_save(flags);
199	__i = atomic_read(v);
200	atomic_set(v, i + __i);
201	local_irq_restore(flags);
202	return i + __i;
203#endif
204}
205
206/**
207 * atomic_sub_return - subtract integer and return
208 * @v: pointer of type atomic_t
209 * @i: integer value to subtract
210 *
211 * Atomically subtracts @i from @v and returns @v - @i
212 */
213static __inline__ int atomic_sub_return(int i, atomic_t *v)
214{
215	return atomic_add_return(-i,v);
216}
217
218#define atomic_cmpxchg(v, old, new) (cmpxchg(&((v)->counter), (old), (new)))
219#define atomic_xchg(v, new) (xchg(&((v)->counter), (new)))
220
221/**
222 * atomic_add_unless - add unless the number is already a given value
223 * @v: pointer of type atomic_t
224 * @a: the amount to add to v...
225 * @u: ...unless v is equal to u.
226 *
227 * Atomically adds @a to @v, so long as @v was not already @u.
228 * Returns non-zero if @v was not @u, and zero otherwise.
229 */
230static __inline__ int atomic_add_unless(atomic_t *v, int a, int u)
231{
232	int c, old;
233	c = atomic_read(v);
234	for (;;) {
235		if (unlikely(c == (u)))
236			break;
237		old = atomic_cmpxchg((v), c, c + (a));
238		if (likely(old == c))
239			break;
240		c = old;
241	}
242	return c != (u);
243}
244
245#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
246
247#define atomic_inc_return(v)  (atomic_add_return(1,v))
248#define atomic_dec_return(v)  (atomic_sub_return(1,v))
249
250/* These are x86-specific, used by some header files */
251#define atomic_clear_mask(mask, addr) \
252__asm__ __volatile__(LOCK_PREFIX "andl %0,%1" \
253: : "r" (~(mask)),"m" (*addr) : "memory")
254
255#define atomic_set_mask(mask, addr) \
256__asm__ __volatile__(LOCK_PREFIX "orl %0,%1" \
257: : "r" (mask),"m" (*(addr)) : "memory")
258
259/* Atomic operations are already serializing on x86 */
260#define smp_mb__before_atomic_dec()	barrier()
261#define smp_mb__after_atomic_dec()	barrier()
262#define smp_mb__before_atomic_inc()	barrier()
263#define smp_mb__after_atomic_inc()	barrier()
264
265#include <asm-generic/atomic.h>
266#endif
267