Made c99 compatibility changes
[akaros.git] / kern / arch / sparc / atomic.h
index 73d370f..84a5f57 100644 (file)
@@ -1,16 +1,21 @@
 #ifndef ROS_INCLUDE_ATOMIC_H
 #define ROS_INCLUDE_ATOMIC_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #define mb() {rmb(); wmb();}
 #define rmb()
-#define wmb() ({ asm volatile("stbar"); })
+#define wmb() ({ __asm__ __volatile__ ("stbar"); })
 /* Force a wmb, used in cases where an IPI could beat a write, even though
  * write-orderings are respected.  (Used by x86) */
 #define wmb_f() wmb()
 
-typedef volatile uint32_t spinlock_t;
+typedef struct
+{
+       volatile uint32_t rlock;
+} spinlock_t;
+
+#define SPINLOCK_INITIALIZER {0}
 
 // atomic_t is void*, so we can't accidentally dereference it
 typedef void* atomic_t;
@@ -21,7 +26,9 @@ static inline void atomic_set(atomic_t* number, int32_t val);
 static inline void atomic_add(atomic_t* number, int32_t inc);
 static inline void atomic_inc(atomic_t* number);
 static inline void atomic_dec(atomic_t* number);
+static inline uint32_t atomic_swap(uint32_t* addr, uint32_t val);
 static inline uint32_t spin_trylock(spinlock_t*SAFE lock);
+static inline uint32_t spin_locked(spinlock_t*SAFE lock);
 static inline void spin_lock(spinlock_t*SAFE lock);
 static inline void spin_unlock(spinlock_t*SAFE lock);
 
@@ -30,13 +37,13 @@ static inline void spin_unlock(spinlock_t*SAFE lock);
 static inline void atomic_init(atomic_t* number, int32_t val)
 {
        val <<= 8;
-       asm volatile ("st %0,[%1]" : : "r"(val), "r"(number) : "memory");
+       __asm__ __volatile__ ("st %0,[%1]" : : "r"(val), "r"(number) : "memory");
 }
 
 static inline int32_t atomic_read(atomic_t* number)
 {
        int32_t val;
-       asm volatile ("ld [%1],%0" : "=r"(val) : "r"(number));
+       __asm__ __volatile__ ("ld [%1],%0" : "=r"(val) : "r"(number));
        return val >> 8;
 }
 
@@ -53,7 +60,7 @@ static inline void atomic_add(atomic_t* number, int32_t inc)
        atomic_init(number,inc);
 }
 
-static inline void atomic_set(atomic_t* number, uint32_t val)
+static inline void atomic_set(atomic_t* number, int32_t val)
 {
        // this works basically the same as atomic_add... but without the add
        spin_lock((spinlock_t*)number);
@@ -70,17 +77,23 @@ static inline void atomic_dec(atomic_t* number)
        atomic_add(number,-1);
 }
 
+static inline uint32_t atomic_swap(uint32_t* addr, uint32_t val)
+{
+       __asm__ __volatile__ ("swap [%2],%0" : "=r"(val) : "0"(val),"r"(addr) : "memory");
+       return val;
+}
+
 static inline uint32_t spin_trylock(spinlock_t*SAFE lock)
 {
        uint32_t reg;
-       asm volatile("ldstub [%1+3],%0" : "=r"(reg) : "r"(lock) : "memory");
+       __asm__ __volatile__ ("ldstub [%1+3],%0" : "=r"(reg) : "r"(&lock->rlock) : "memory");
        return reg;
 }
 
 static inline uint32_t spin_locked(spinlock_t*SAFE lock)
 {
        uint32_t reg;
-       asm volatile("ldub [%1+3],%0" : "=r"(reg) : "r"(lock));
+       __asm__ __volatile__ ("ldub [%1+3],%0" : "=r"(reg) : "r"(&lock->rlock));
        return reg;
 }
 
@@ -93,7 +106,16 @@ static inline void spin_lock(spinlock_t*SAFE lock)
 static inline void spin_unlock(spinlock_t*SAFE lock)
 {
        wmb();
-       asm volatile("stub %%g0,[%0+3]" : : "r"(lock) : "memory");
+       __asm__ __volatile__ ("stub %%g0,[%0+3]" : : "r"(&lock->rlock) : "memory");
+}
+
+static inline void spinlock_init(spinlock_t* lock)
+{
+       lock->rlock = 0;
+}
+
+static inline void spinlock_debug(spinlock_t* lock)
+{
 }
 
 #endif /* !ROS_INCLUDE_ATOMIC_H */