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>

diff --cc arch/frv/include/asm/pci.h
Simple merge

diff --cc arch/sh/include/asm/atomic.h
Simple merge

diff --cc arch/x86/include/asm/atomic_32.h
index c83d314,aff9f1f..8cb9c81
--- 1/arch/x86/include/asm/atomic_32.h
--- 2/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()
  
 -#include <asm-generic/atomic.h>
+ /* 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-long.h>
  #endif /* _ASM_X86_ATOMIC_32_H */

diff --cc include/asm-generic/atomic-long.h
index 76e27d6,0000000..b7babf0
mode 100644,000000..100644
--- 1/include/asm-generic/atomic-long.h
--- /dev/null
+++ b/include/asm-generic/atomic-long.h
@@@ -1,258 -1,0 +1,258 @@@
-       (atomic64_xchg((atomic64_t *)(l), (new)))
 +#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 *)(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  */

diff --cc lib/Makefile
Simple merge