From: Arnd Bergmann <arnd@arndb.de>
Date: Fri, 12 Jun 2009 07:53:47 +0000 (+0200)
Subject: asm-generic: merge branch 'master' of torvalds/linux-2.6
X-Git-Url: https://git.stricted.de/?a=commitdiff_plain;h=5b02ee3d219f9e01b6e9146e25613822cfc2e5ce;p=GitHub%2Fmt8127%2Fandroid_kernel_alcatel_ttab.git

asm-generic: merge branch 'master' of torvalds/linux-2.6

Fixes a merge conflict against the x86 tree caused by a fix to
atomic.h which I renamed to atomic_long.h.

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
---

5b02ee3d219f9e01b6e9146e25613822cfc2e5ce
diff --cc arch/x86/include/asm/atomic_32.h
index c83d31486081,aff9f1fcdcd7..8cb9c814e120
--- a/arch/x86/include/asm/atomic_32.h
+++ b/arch/x86/include/asm/atomic_32.h
@@@ -247,5 -247,241 +247,241 @@@ static inline int atomic_add_unless(ato
  #define smp_mb__before_atomic_inc()	barrier()
  #define smp_mb__after_atomic_inc()	barrier()
  
+ /* An 64bit atomic type */
+ 
+ typedef struct {
+ 	unsigned long long counter;
+ } atomic64_t;
+ 
+ #define ATOMIC64_INIT(val)	{ (val) }
+ 
+ /**
+  * atomic64_read - read atomic64 variable
+  * @v: pointer of type atomic64_t
+  *
+  * Atomically reads the value of @v.
+  * Doesn't imply a read memory barrier.
+  */
+ #define __atomic64_read(ptr)		((ptr)->counter)
+ 
+ static inline unsigned long long
+ cmpxchg8b(unsigned long long *ptr, unsigned long long old, unsigned long long new)
+ {
+ 	asm volatile(
+ 
+ 		LOCK_PREFIX "cmpxchg8b (%[ptr])\n"
+ 
+ 		     :		"=A" (old)
+ 
+ 		     : [ptr]	"D" (ptr),
+ 				"A" (old),
+ 				"b" (ll_low(new)),
+ 				"c" (ll_high(new))
+ 
+ 		     : "memory");
+ 
+ 	return old;
+ }
+ 
+ static inline unsigned long long
+ atomic64_cmpxchg(atomic64_t *ptr, unsigned long long old_val,
+ 		 unsigned long long new_val)
+ {
+ 	return cmpxchg8b(&ptr->counter, old_val, new_val);
+ }
+ 
+ /**
+  * atomic64_xchg - xchg atomic64 variable
+  * @ptr:      pointer to type atomic64_t
+  * @new_val:  value to assign
+  * @old_val:  old value that was there
+  *
+  * Atomically xchgs the value of @ptr to @new_val and returns
+  * the old value.
+  */
+ 
+ static inline unsigned long long
+ atomic64_xchg(atomic64_t *ptr, unsigned long long new_val)
+ {
+ 	unsigned long long old_val;
+ 
+ 	do {
+ 		old_val = atomic_read(ptr);
+ 	} while (atomic64_cmpxchg(ptr, old_val, new_val) != old_val);
+ 
+ 	return old_val;
+ }
+ 
+ /**
+  * atomic64_set - set atomic64 variable
+  * @ptr:      pointer to type atomic64_t
+  * @new_val:  value to assign
+  *
+  * Atomically sets the value of @ptr to @new_val.
+  */
+ static inline void atomic64_set(atomic64_t *ptr, unsigned long long new_val)
+ {
+ 	atomic64_xchg(ptr, new_val);
+ }
+ 
+ /**
+  * atomic64_read - read atomic64 variable
+  * @ptr:      pointer to type atomic64_t
+  *
+  * Atomically reads the value of @ptr and returns it.
+  */
+ static inline unsigned long long atomic64_read(atomic64_t *ptr)
+ {
+ 	unsigned long long curr_val;
+ 
+ 	do {
+ 		curr_val = __atomic64_read(ptr);
+ 	} while (atomic64_cmpxchg(ptr, curr_val, curr_val) != curr_val);
+ 
+ 	return curr_val;
+ }
+ 
+ /**
+  * atomic64_add_return - add and return
+  * @delta: integer value to add
+  * @ptr:   pointer to type atomic64_t
+  *
+  * Atomically adds @delta to @ptr and returns @delta + *@ptr
+  */
+ static inline unsigned long long
+ atomic64_add_return(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	unsigned long long old_val, new_val;
+ 
+ 	do {
+ 		old_val = atomic_read(ptr);
+ 		new_val = old_val + delta;
+ 
+ 	} while (atomic64_cmpxchg(ptr, old_val, new_val) != old_val);
+ 
+ 	return new_val;
+ }
+ 
+ static inline long atomic64_sub_return(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	return atomic64_add_return(-delta, ptr);
+ }
+ 
+ static inline long atomic64_inc_return(atomic64_t *ptr)
+ {
+ 	return atomic64_add_return(1, ptr);
+ }
+ 
+ static inline long atomic64_dec_return(atomic64_t *ptr)
+ {
+ 	return atomic64_sub_return(1, ptr);
+ }
+ 
+ /**
+  * atomic64_add - add integer to atomic64 variable
+  * @delta: integer value to add
+  * @ptr:   pointer to type atomic64_t
+  *
+  * Atomically adds @delta to @ptr.
+  */
+ static inline void atomic64_add(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	atomic64_add_return(delta, ptr);
+ }
+ 
+ /**
+  * atomic64_sub - subtract the atomic64 variable
+  * @delta: integer value to subtract
+  * @ptr:   pointer to type atomic64_t
+  *
+  * Atomically subtracts @delta from @ptr.
+  */
+ static inline void atomic64_sub(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	atomic64_add(-delta, ptr);
+ }
+ 
+ /**
+  * atomic64_sub_and_test - subtract value from variable and test result
+  * @delta: integer value to subtract
+  * @ptr:   pointer to type atomic64_t
+  *
+  * Atomically subtracts @delta from @ptr and returns
+  * true if the result is zero, or false for all
+  * other cases.
+  */
+ static inline int
+ atomic64_sub_and_test(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	unsigned long long old_val = atomic64_sub_return(delta, ptr);
+ 
+ 	return old_val == 0;
+ }
+ 
+ /**
+  * atomic64_inc - increment atomic64 variable
+  * @ptr: pointer to type atomic64_t
+  *
+  * Atomically increments @ptr by 1.
+  */
+ static inline void atomic64_inc(atomic64_t *ptr)
+ {
+ 	atomic64_add(1, ptr);
+ }
+ 
+ /**
+  * atomic64_dec - decrement atomic64 variable
+  * @ptr: pointer to type atomic64_t
+  *
+  * Atomically decrements @ptr by 1.
+  */
+ static inline void atomic64_dec(atomic64_t *ptr)
+ {
+ 	atomic64_sub(1, ptr);
+ }
+ 
+ /**
+  * atomic64_dec_and_test - decrement and test
+  * @ptr: pointer to type atomic64_t
+  *
+  * Atomically decrements @ptr by 1 and
+  * returns true if the result is 0, or false for all other
+  * cases.
+  */
+ static inline int atomic64_dec_and_test(atomic64_t *ptr)
+ {
+ 	return atomic64_sub_and_test(1, ptr);
+ }
+ 
+ /**
+  * atomic64_inc_and_test - increment and test
+  * @ptr: pointer to type atomic64_t
+  *
+  * Atomically increments @ptr by 1
+  * and returns true if the result is zero, or false for all
+  * other cases.
+  */
+ static inline int atomic64_inc_and_test(atomic64_t *ptr)
+ {
+ 	return atomic64_sub_and_test(-1, ptr);
+ }
+ 
+ /**
+  * atomic64_add_negative - add and test if negative
+  * @delta: integer value to add
+  * @ptr:   pointer to type atomic64_t
+  *
+  * Atomically adds @delta to @ptr and returns true
+  * if the result is negative, or false when
+  * result is greater than or equal to zero.
+  */
+ static inline int
+ atomic64_add_negative(unsigned long long delta, atomic64_t *ptr)
+ {
+ 	long long old_val = atomic64_add_return(delta, ptr);
+ 
+ 	return old_val < 0;
+ }
+ 
 -#include <asm-generic/atomic.h>
 +#include <asm-generic/atomic-long.h>
  #endif /* _ASM_X86_ATOMIC_32_H */
diff --cc include/asm-generic/atomic-long.h
index 76e27d66c055,000000000000..b7babf0206b8
mode 100644,000000..100644
--- a/include/asm-generic/atomic-long.h
+++ b/include/asm-generic/atomic-long.h
@@@ -1,258 -1,0 +1,258 @@@
 +#ifndef _ASM_GENERIC_ATOMIC_LONG_H
 +#define _ASM_GENERIC_ATOMIC_LONG_H
 +/*
 + * Copyright (C) 2005 Silicon Graphics, Inc.
 + *	Christoph Lameter
 + *
 + * Allows to provide arch independent atomic definitions without the need to
 + * edit all arch specific atomic.h files.
 + */
 +
 +#include <asm/types.h>
 +
 +/*
 + * Suppport for atomic_long_t
 + *
 + * Casts for parameters are avoided for existing atomic functions in order to
 + * avoid issues with cast-as-lval under gcc 4.x and other limitations that the
 + * macros of a platform may have.
 + */
 +
 +#if BITS_PER_LONG == 64
 +
 +typedef atomic64_t atomic_long_t;
 +
 +#define ATOMIC_LONG_INIT(i)	ATOMIC64_INIT(i)
 +
 +static inline long atomic_long_read(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_read(v);
 +}
 +
 +static inline void atomic_long_set(atomic_long_t *l, long i)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	atomic64_set(v, i);
 +}
 +
 +static inline void atomic_long_inc(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	atomic64_inc(v);
 +}
 +
 +static inline void atomic_long_dec(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	atomic64_dec(v);
 +}
 +
 +static inline void atomic_long_add(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	atomic64_add(i, v);
 +}
 +
 +static inline void atomic_long_sub(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	atomic64_sub(i, v);
 +}
 +
 +static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return atomic64_sub_and_test(i, v);
 +}
 +
 +static inline int atomic_long_dec_and_test(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return atomic64_dec_and_test(v);
 +}
 +
 +static inline int atomic_long_inc_and_test(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return atomic64_inc_and_test(v);
 +}
 +
 +static inline int atomic_long_add_negative(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return atomic64_add_negative(i, v);
 +}
 +
 +static inline long atomic_long_add_return(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_add_return(i, v);
 +}
 +
 +static inline long atomic_long_sub_return(long i, atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_sub_return(i, v);
 +}
 +
 +static inline long atomic_long_inc_return(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_inc_return(v);
 +}
 +
 +static inline long atomic_long_dec_return(atomic_long_t *l)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_dec_return(v);
 +}
 +
 +static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
 +{
 +	atomic64_t *v = (atomic64_t *)l;
 +
 +	return (long)atomic64_add_unless(v, a, u);
 +}
 +
 +#define atomic_long_inc_not_zero(l) atomic64_inc_not_zero((atomic64_t *)(l))
 +
 +#define atomic_long_cmpxchg(l, old, new) \
 +	(atomic64_cmpxchg((atomic64_t *)(l), (old), (new)))
 +#define atomic_long_xchg(v, new) \
- 	(atomic64_xchg((atomic64_t *)(l), (new)))
++	(atomic64_xchg((atomic64_t *)(v), (new)))
 +
 +#else  /*  BITS_PER_LONG == 64  */
 +
 +typedef atomic_t atomic_long_t;
 +
 +#define ATOMIC_LONG_INIT(i)	ATOMIC_INIT(i)
 +static inline long atomic_long_read(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_read(v);
 +}
 +
 +static inline void atomic_long_set(atomic_long_t *l, long i)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	atomic_set(v, i);
 +}
 +
 +static inline void atomic_long_inc(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	atomic_inc(v);
 +}
 +
 +static inline void atomic_long_dec(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	atomic_dec(v);
 +}
 +
 +static inline void atomic_long_add(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	atomic_add(i, v);
 +}
 +
 +static inline void atomic_long_sub(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	atomic_sub(i, v);
 +}
 +
 +static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return atomic_sub_and_test(i, v);
 +}
 +
 +static inline int atomic_long_dec_and_test(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return atomic_dec_and_test(v);
 +}
 +
 +static inline int atomic_long_inc_and_test(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return atomic_inc_and_test(v);
 +}
 +
 +static inline int atomic_long_add_negative(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return atomic_add_negative(i, v);
 +}
 +
 +static inline long atomic_long_add_return(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_add_return(i, v);
 +}
 +
 +static inline long atomic_long_sub_return(long i, atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_sub_return(i, v);
 +}
 +
 +static inline long atomic_long_inc_return(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_inc_return(v);
 +}
 +
 +static inline long atomic_long_dec_return(atomic_long_t *l)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_dec_return(v);
 +}
 +
 +static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
 +{
 +	atomic_t *v = (atomic_t *)l;
 +
 +	return (long)atomic_add_unless(v, a, u);
 +}
 +
 +#define atomic_long_inc_not_zero(l) atomic_inc_not_zero((atomic_t *)(l))
 +
 +#define atomic_long_cmpxchg(l, old, new) \
 +	(atomic_cmpxchg((atomic_t *)(l), (old), (new)))
 +#define atomic_long_xchg(v, new) \
 +	(atomic_xchg((atomic_t *)(v), (new)))
 +
 +#endif  /*  BITS_PER_LONG == 64  */
 +
 +#endif  /*  _ASM_GENERIC_ATOMIC_LONG_H  */