[deliverable/linux.git] / arch / m32r / include / asm / atomic.h

#ifndef _ASM_M32R_ATOMIC_H
#define _ASM_M32R_ATOMIC_H

/*
 *  linux/include/asm-m32r/atomic.h
 *
 *  M32R version:
 *    Copyright (C) 2001, 2002  Hitoshi Yamamoto
 *    Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
 */

#include <linux/types.h>
#include <asm/assembler.h>
#include <asm/cmpxchg.h>
#include <asm/dcache_clear.h>

/*
 * Atomic operations that C can't guarantee us.  Useful for
 * resource counting etc..
 */

#define ATOMIC_INIT(i)	{ (i) }

/**
 * atomic_read - read atomic variable
 * @v: pointer of type atomic_t
 *
 * Atomically reads the value of @v.
 */
#define atomic_read(v)	(*(volatile int *)&(v)->counter)

/**
 * atomic_set - set atomic variable
 * @v: pointer of type atomic_t
 * @i: required value
 *
 * Atomically sets the value of @v to @i.
 */
#define atomic_set(v,i)	(((v)->counter) = (i))

/**
 * atomic_add_return - add integer to atomic variable and return it
 * @i: integer value to add
 * @v: pointer of type atomic_t
 *
 * Atomically adds @i to @v and return (@i + @v).
 */
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
	unsigned long flags;
	int result;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_add_return		\n\t"
		DCACHE_CLEAR("%0", "r4", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"add	%0, %2;			\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (result)
		: "r" (&v->counter), "r" (i)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r4"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);

	return result;
}

/**
 * atomic_sub_return - subtract integer from atomic variable and return it
 * @i: integer value to subtract
 * @v: pointer of type atomic_t
 *
 * Atomically subtracts @i from @v and return (@v - @i).
 */
static __inline__ int atomic_sub_return(int i, atomic_t *v)
{
	unsigned long flags;
	int result;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_sub_return		\n\t"
		DCACHE_CLEAR("%0", "r4", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"sub	%0, %2;			\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (result)
		: "r" (&v->counter), "r" (i)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r4"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);

	return result;
}

/**
 * atomic_add - add integer to atomic variable
 * @i: integer value to add
 * @v: pointer of type atomic_t
 *
 * Atomically adds @i to @v.
 */
#define atomic_add(i,v) ((void) atomic_add_return((i), (v)))

/**
 * atomic_sub - subtract the atomic variable
 * @i: integer value to subtract
 * @v: pointer of type atomic_t
 *
 * Atomically subtracts @i from @v.
 */
#define atomic_sub(i,v) ((void) atomic_sub_return((i), (v)))

/**
 * atomic_sub_and_test - subtract value from variable and test result
 * @i: integer value to subtract
 * @v: pointer of type atomic_t
 *
 * Atomically subtracts @i from @v and returns
 * true if the result is zero, or false for all
 * other cases.
 */
#define atomic_sub_and_test(i,v) (atomic_sub_return((i), (v)) == 0)

/**
 * atomic_inc_return - increment atomic variable and return it
 * @v: pointer of type atomic_t
 *
 * Atomically increments @v by 1 and returns the result.
 */
static __inline__ int atomic_inc_return(atomic_t *v)
{
	unsigned long flags;
	int result;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_inc_return		\n\t"
		DCACHE_CLEAR("%0", "r4", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"addi	%0, #1;			\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (result)
		: "r" (&v->counter)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r4"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);

	return result;
}

/**
 * atomic_dec_return - decrement atomic variable and return it
 * @v: pointer of type atomic_t
 *
 * Atomically decrements @v by 1 and returns the result.
 */
static __inline__ int atomic_dec_return(atomic_t *v)
{
	unsigned long flags;
	int result;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_dec_return		\n\t"
		DCACHE_CLEAR("%0", "r4", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"addi	%0, #-1;		\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (result)
		: "r" (&v->counter)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r4"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);

	return result;
}

/**
 * atomic_inc - increment atomic variable
 * @v: pointer of type atomic_t
 *
 * Atomically increments @v by 1.
 */
#define atomic_inc(v) ((void)atomic_inc_return(v))

/**
 * atomic_dec - decrement atomic variable
 * @v: pointer of type atomic_t
 *
 * Atomically decrements @v by 1.
 */
#define atomic_dec(v) ((void)atomic_dec_return(v))

/**
 * atomic_inc_and_test - increment and test
 * @v: pointer of type atomic_t
 *
 * Atomically increments @v by 1
 * and returns true if the result is zero, or false for all
 * other cases.
 */
#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0)

/**
 * atomic_dec_and_test - decrement and test
 * @v: pointer of type atomic_t
 *
 * Atomically decrements @v by 1 and
 * returns true if the result is 0, or false for all
 * other cases.
 */
#define atomic_dec_and_test(v) (atomic_dec_return(v) == 0)

/**
 * atomic_add_negative - add and test if negative
 * @v: pointer of type atomic_t
 * @i: integer value to add
 *
 * Atomically adds @i to @v and returns true
 * if the result is negative, or false when
 * result is greater than or equal to zero.
 */
#define atomic_add_negative(i,v) (atomic_add_return((i), (v)) < 0)

#define atomic_cmpxchg(v, o, n) ((int)cmpxchg(&((v)->counter), (o), (n)))
#define atomic_xchg(v, new) (xchg(&((v)->counter), new))

/**
 * __atomic_add_unless - add unless the number is a given value
 * @v: pointer of type atomic_t
 * @a: the amount to add to v...
 * @u: ...unless v is equal to u.
 *
 * Atomically adds @a to @v, so long as it was not @u.
 * Returns the old value of @v.
 */
static __inline__ int __atomic_add_unless(atomic_t *v, int a, int u)
{
	int c, old;
	c = atomic_read(v);
	for (;;) {
		if (unlikely(c == (u)))
			break;
		old = atomic_cmpxchg((v), c, c + (a));
		if (likely(old == c))
			break;
		c = old;
	}
	return c;
}


static __inline__ void atomic_clear_mask(unsigned long  mask, atomic_t *addr)
{
	unsigned long flags;
	unsigned long tmp;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_clear_mask		\n\t"
		DCACHE_CLEAR("%0", "r5", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"and	%0, %2;			\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (tmp)
		: "r" (addr), "r" (~mask)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r5"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);
}

static __inline__ void atomic_set_mask(unsigned long  mask, atomic_t *addr)
{
	unsigned long flags;
	unsigned long tmp;

	local_irq_save(flags);
	__asm__ __volatile__ (
		"# atomic_set_mask		\n\t"
		DCACHE_CLEAR("%0", "r5", "%1")
		M32R_LOCK" %0, @%1;		\n\t"
		"or	%0, %2;			\n\t"
		M32R_UNLOCK" %0, @%1;		\n\t"
		: "=&r" (tmp)
		: "r" (addr), "r" (mask)
		: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
		, "r5"
#endif	/* CONFIG_CHIP_M32700_TS1 */
	);
	local_irq_restore(flags);
}

/* Atomic operations are already serializing on m32r */
#define smp_mb__before_atomic_dec()	barrier()
#define smp_mb__after_atomic_dec()	barrier()
#define smp_mb__before_atomic_inc()	barrier()
#define smp_mb__after_atomic_inc()	barrier()

#endif	/* _ASM_M32R_ATOMIC_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _ASM_M32R_ATOMIC_H
	2	#define _ASM_M32R_ATOMIC_H
	3
	4	/*
	5	* linux/include/asm-m32r/atomic.h
	6	*
	7	* M32R version:
	8	* Copyright (C) 2001, 2002 Hitoshi Yamamoto
	9	* Copyright (C) 2004 Hirokazu Takata <takata at linux-m32r.org>
	10	*/
	11
ea435467	12	#include <linux/types.h>
1da177e4	13	#include <asm/assembler.h>
c9034c3a DH	14	#include <asm/cmpxchg.h>
c9034c3a DH	15	#include <asm/dcache_clear.h>
1da177e4 LT	16
	17	/*
	18	* Atomic operations that C can't guarantee us. Useful for
	19	* resource counting etc..
	20	*/
	21
1da177e4 LT	22	#define ATOMIC_INIT(i) { (i) }
	23
	24	/**
	25	* atomic_read - read atomic variable
	26	* @v: pointer of type atomic_t
	27	*
	28	* Atomically reads the value of @v.
	29	*/
f3d46f9d	30	#define atomic_read(v) ((volatile int )&(v)->counter)
1da177e4 LT	31
	32	/**
	33	* atomic_set - set atomic variable
	34	* @v: pointer of type atomic_t
	35	* @i: required value
	36	*
	37	* Atomically sets the value of @v to @i.
	38	*/
	39	#define atomic_set(v,i) (((v)->counter) = (i))
	40
	41	/**
	42	* atomic_add_return - add integer to atomic variable and return it
	43	* @i: integer value to add
	44	* @v: pointer of type atomic_t
	45	*
	46	* Atomically adds @i to @v and return (@i + @v).
	47	*/
	48	static __inline__ int atomic_add_return(int i, atomic_t *v)
	49	{
	50	unsigned long flags;
	51	int result;
	52
	53	local_irq_save(flags);
	54	__asm__ __volatile__ (
	55	"# atomic_add_return \n\t"
	56	DCACHE_CLEAR("%0", "r4", "%1")
	57	M32R_LOCK" %0, @%1; \n\t"
	58	"add %0, %2; \n\t"
	59	M32R_UNLOCK" %0, @%1; \n\t"
	60	: "=&r" (result)
	61	: "r" (&v->counter), "r" (i)
	62	: "memory"
	63	#ifdef CONFIG_CHIP_M32700_TS1
	64	, "r4"
	65	#endif /* CONFIG_CHIP_M32700_TS1 */
	66	);
	67	local_irq_restore(flags);
	68
	69	return result;
	70	}
	71
	72	/**
	73	* atomic_sub_return - subtract integer from atomic variable and return it
	74	* @i: integer value to subtract
	75	* @v: pointer of type atomic_t
	76	*
	77	* Atomically subtracts @i from @v and return (@v - @i).
	78	*/
	79	static __inline__ int atomic_sub_return(int i, atomic_t *v)
	80	{
	81	unsigned long flags;
	82	int result;
	83
	84	local_irq_save(flags);
	85	__asm__ __volatile__ (
	86	"# atomic_sub_return \n\t"
	87	DCACHE_CLEAR("%0", "r4", "%1")
	88	M32R_LOCK" %0, @%1; \n\t"
	89	"sub %0, %2; \n\t"
	90	M32R_UNLOCK" %0, @%1; \n\t"
	91	: "=&r" (result)
	92	: "r" (&v->counter), "r" (i)
	93	: "memory"
	94	#ifdef CONFIG_CHIP_M32700_TS1
95	, "r4"
96	#endif /* CONFIG_CHIP_M32700_TS1 */
97	);
98	local_irq_restore(flags);
99
100	return result;
101	}
102
103	/**
104	* atomic_add - add integer to atomic variable
105	* @i: integer value to add
106	* @v: pointer of type atomic_t
107	*
108	* Atomically adds @i to @v.
109	*/
110	#define atomic_add(i,v) ((void) atomic_add_return((i), (v)))
111
112	/**
113	* atomic_sub - subtract the atomic variable
114	* @i: integer value to subtract
115	* @v: pointer of type atomic_t
116	*
117	* Atomically subtracts @i from @v.
118	*/
119	#define atomic_sub(i,v) ((void) atomic_sub_return((i), (v)))
120
121	/**
122	* atomic_sub_and_test - subtract value from variable and test result
123	* @i: integer value to subtract
124	* @v: pointer of type atomic_t
125	*
126	* Atomically subtracts @i from @v and returns
127	* true if the result is zero, or false for all
128	* other cases.
129	*/
130	#define atomic_sub_and_test(i,v) (atomic_sub_return((i), (v)) == 0)
131
132	/**
133	* atomic_inc_return - increment atomic variable and return it
134	* @v: pointer of type atomic_t
135	*
136	* Atomically increments @v by 1 and returns the result.
137	*/
138	static __inline__ int atomic_inc_return(atomic_t *v)
139	{
140	unsigned long flags;
141	int result;
142
143	local_irq_save(flags);
144	__asm__ __volatile__ (
145	"# atomic_inc_return \n\t"
146	DCACHE_CLEAR("%0", "r4", "%1")
147	M32R_LOCK" %0, @%1; \n\t"
148	"addi %0, #1; \n\t"
149	M32R_UNLOCK" %0, @%1; \n\t"
150	: "=&r" (result)
151	: "r" (&v->counter)
152	: "memory"
153	#ifdef CONFIG_CHIP_M32700_TS1
154	, "r4"
155	#endif /* CONFIG_CHIP_M32700_TS1 */
156	);
157	local_irq_restore(flags);
158
159	return result;
160	}
161
162	/**
163	* atomic_dec_return - decrement atomic variable and return it
164	* @v: pointer of type atomic_t
165	*
166	* Atomically decrements @v by 1 and returns the result.
167	*/
168	static __inline__ int atomic_dec_return(atomic_t *v)
169	{
170	unsigned long flags;
171	int result;
172
173	local_irq_save(flags);
174	__asm__ __volatile__ (
175	"# atomic_dec_return \n\t"
176	DCACHE_CLEAR("%0", "r4", "%1")
177	M32R_LOCK" %0, @%1; \n\t"
178	"addi %0, #-1; \n\t"
179	M32R_UNLOCK" %0, @%1; \n\t"
180	: "=&r" (result)
181	: "r" (&v->counter)
182	: "memory"
183	#ifdef CONFIG_CHIP_M32700_TS1
184	, "r4"
185	#endif /* CONFIG_CHIP_M32700_TS1 */
186	);
187	local_irq_restore(flags);
188
189	return result;
190	}
191
192	/**
193	* atomic_inc - increment atomic variable
194	* @v: pointer of type atomic_t
195	*
196	* Atomically increments @v by 1.
197	*/
198	#define atomic_inc(v) ((void)atomic_inc_return(v))
199
200	/**
201	* atomic_dec - decrement atomic variable
202	* @v: pointer of type atomic_t
203	*
204	* Atomically decrements @v by 1.
205	*/
206	#define atomic_dec(v) ((void)atomic_dec_return(v))
207
208	/**
209	* atomic_inc_and_test - increment and test
210	* @v: pointer of type atomic_t
211	*
212	* Atomically increments @v by 1
213	* and returns true if the result is zero, or false for all
214	* other cases.
215	*/
216	#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0)
217
218	/**
219	* atomic_dec_and_test - decrement and test
220	* @v: pointer of type atomic_t
221	*
222	* Atomically decrements @v by 1 and
223	* returns true if the result is 0, or false for all
224	* other cases.
225	*/
226	#define atomic_dec_and_test(v) (atomic_dec_return(v) == 0)
227
228	/**
229	* atomic_add_negative - add and test if negative
230	* @v: pointer of type atomic_t
231	* @i: integer value to add
232	*
233	* Atomically adds @i to @v and returns true
234	* if the result is negative, or false when
235	* result is greater than or equal to zero.
236	*/
237	#define atomic_add_negative(i,v) (atomic_add_return((i), (v)) < 0)
238
0332db5a	239	#define atomic_cmpxchg(v, o, n) ((int)cmpxchg(&((v)->counter), (o), (n)))
ffbf670f	240	#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
0332db5a HT	241
0332db5a HT	242	/**
f24219b4	243	* __atomic_add_unless - add unless the number is a given value
0332db5a HT	244	* @v: pointer of type atomic_t
	245	* @a: the amount to add to v...
	246	* @u: ...unless v is equal to u.
	247	*
	248	* Atomically adds @a to @v, so long as it was not @u.
f24219b4	249	* Returns the old value of @v.
0332db5a	250	*/
f24219b4	251	static __inline__ int __atomic_add_unless(atomic_t *v, int a, int u)
2856f5e3 MD	252	{
	253	int c, old;
	254	c = atomic_read(v);
	255	for (;;) {
	256	if (unlikely(c == (u)))
	257	break;
	258	old = atomic_cmpxchg((v), c, c + (a));
	259	if (likely(old == c))
	260	break;
	261	c = old;
	262	}
f24219b4	263	return c;
2856f5e3 MD	264	}
2856f5e3 MD	265
0332db5a	266
1da177e4 LT	267	static __inline__ void atomic_clear_mask(unsigned long mask, atomic_t *addr)
	268	{
	269	unsigned long flags;
	270	unsigned long tmp;
	271
	272	local_irq_save(flags);
	273	__asm__ __volatile__ (
	274	"# atomic_clear_mask \n\t"
	275	DCACHE_CLEAR("%0", "r5", "%1")
	276	M32R_LOCK" %0, @%1; \n\t"
	277	"and %0, %2; \n\t"
	278	M32R_UNLOCK" %0, @%1; \n\t"
	279	: "=&r" (tmp)
	280	: "r" (addr), "r" (~mask)
	281	: "memory"
	282	#ifdef CONFIG_CHIP_M32700_TS1
	283	, "r5"
	284	#endif /* CONFIG_CHIP_M32700_TS1 */
	285	);
	286	local_irq_restore(flags);
	287	}
	288
	289	static __inline__ void atomic_set_mask(unsigned long mask, atomic_t *addr)
	290	{
	291	unsigned long flags;
	292	unsigned long tmp;
	293
	294	local_irq_save(flags);
	295	__asm__ __volatile__ (
	296	"# atomic_set_mask \n\t"
	297	DCACHE_CLEAR("%0", "r5", "%1")
	298	M32R_LOCK" %0, @%1; \n\t"
	299	"or %0, %2; \n\t"
	300	M32R_UNLOCK" %0, @%1; \n\t"
	301	: "=&r" (tmp)
	302	: "r" (addr), "r" (mask)
	303	: "memory"
	304	#ifdef CONFIG_CHIP_M32700_TS1
	305	, "r5"
	306	#endif /* CONFIG_CHIP_M32700_TS1 */
	307	);
	308	local_irq_restore(flags);
	309	}
	310
	311	/* Atomic operations are already serializing on m32r */
	312	#define smp_mb__before_atomic_dec() barrier()
	313	#define smp_mb__after_atomic_dec() barrier()
	314	#define smp_mb__before_atomic_inc() barrier()
	315	#define smp_mb__after_atomic_inc() barrier()
	316
	317	#endif /* _ASM_M32R_ATOMIC_H */