Patched in Tegra support.

1 files changed, 45 insertions, 38 deletions

diff --git a/lib/atomic64.c b/lib/atomic64.c
index 08a4f068e61..e12ae0dd08a 100644
--- a/lib/atomic64.c
+++ b/lib/atomic64.c
@@ -13,7 +13,7 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/init.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/atomic.h>
 
 /*
@@ -29,15 +29,11 @@
  * Ensure each lock is in a separate cacheline.
  */
 static union {
-        raw_spinlock_t lock;
+        spinlock_t lock;
         char pad[L1_CACHE_BYTES];
-} atomic64_lock[NR_LOCKS] __cacheline_aligned_in_smp = {
-        [0 ... (NR_LOCKS - 1)] = {
-                .lock =  __RAW_SPIN_LOCK_UNLOCKED(atomic64_lock.lock),
-        },
-};
+} atomic64_lock[NR_LOCKS] __cacheline_aligned_in_smp;
 
-static inline raw_spinlock_t *lock_addr(const atomic64_t *v)
+static inline spinlock_t *lock_addr(const atomic64_t *v)
 {
         unsigned long addr = (unsigned long) v;
 
@@ -49,12 +45,12 @@ static inline raw_spinlock_t *lock_addr(const atomic64_t *v)
 long long atomic64_read(const atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_read);
@@ -62,34 +58,34 @@ EXPORT_SYMBOL(atomic64_read);
 void atomic64_set(atomic64_t *v, long long i)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         v->counter = i;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(atomic64_set);
 
 void atomic64_add(long long a, atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         v->counter += a;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(atomic64_add);
 
 long long atomic64_add_return(long long a, atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter += a;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_add_return);
@@ -97,23 +93,23 @@ EXPORT_SYMBOL(atomic64_add_return);
 void atomic64_sub(long long a, atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         v->counter -= a;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(atomic64_sub);
 
 long long atomic64_sub_return(long long a, atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter -= a;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_sub_return);
@@ -121,14 +117,14 @@ EXPORT_SYMBOL(atomic64_sub_return);
 long long atomic64_dec_if_positive(atomic64_t *v)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter - 1;
         if (val >= 0)
                 v->counter = val;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_dec_if_positive);
@@ -136,14 +132,14 @@ EXPORT_SYMBOL(atomic64_dec_if_positive);
 long long atomic64_cmpxchg(atomic64_t *v, long long o, long long n)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter;
         if (val == o)
                 v->counter = n;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_cmpxchg);
@@ -151,13 +147,13 @@ EXPORT_SYMBOL(atomic64_cmpxchg);
 long long atomic64_xchg(atomic64_t *v, long long new)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         long long val;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         val = v->counter;
         v->counter = new;
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return val;
 }
 EXPORT_SYMBOL(atomic64_xchg);
@@ -165,15 +161,26 @@ EXPORT_SYMBOL(atomic64_xchg);
 int atomic64_add_unless(atomic64_t *v, long long a, long long u)
 {
         unsigned long flags;
-        raw_spinlock_t *lock = lock_addr(v);
+        spinlock_t *lock = lock_addr(v);
         int ret = 0;
 
-        raw_spin_lock_irqsave(lock, flags);
+        spin_lock_irqsave(lock, flags);
         if (v->counter != u) {
                 v->counter += a;
                 ret = 1;
         }
-        raw_spin_unlock_irqrestore(lock, flags);
+        spin_unlock_irqrestore(lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(atomic64_add_unless);
+
+static int init_atomic64_lock(void)
+{
+        int i;
+
+        for (i = 0; i < NR_LOCKS; ++i)
+                spin_lock_init(&atomic64_lock[i].lock);
+        return 0;
+}
+
+pure_initcall(init_atomic64_lock);