Subversion Repositories or1k

#ifndef _ALPHA_SEMAPHORE_H

#define _ALPHA_SEMAPHORE_H

/*

 * SMP- and interrupt-safe semaphores..

 *

 * (C) Copyright 1996 Linus Torvalds

 * (C) Copyright 1996, 2000 Richard Henderson

 */

#include <asm/current.h>

#include <asm/system.h>

#include <asm/atomic.h>

#include <linux/compiler.h>

#include <linux/wait.h>

#include <linux/rwsem.h>

struct semaphore {

        /* Careful, inline assembly knows about the position of these two.  */

        atomic_t count __attribute__((aligned(8)));

        atomic_t waking;                /* biased by -1 */

        wait_queue_head_t wait;

#if WAITQUEUE_DEBUG

        long __magic;

#endif

};

#if WAITQUEUE_DEBUG

# define __SEM_DEBUG_INIT(name)         , (long)&(name).__magic

#else

# define __SEM_DEBUG_INIT(name)

#endif

#define __SEMAPHORE_INITIALIZER(name,count)             \

        { ATOMIC_INIT(count), ATOMIC_INIT(-1),          \

          __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \

          __SEM_DEBUG_INIT(name) }

#define __MUTEX_INITIALIZER(name) \

        __SEMAPHORE_INITIALIZER(name,1)

#define __DECLARE_SEMAPHORE_GENERIC(name,count) \

        struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)

#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)

#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)

static inline void sema_init(struct semaphore *sem, int val)

{

        /*

         * Logically,

         *   *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val);

         * except that gcc produces better initializing by parts yet.

         */

        atomic_set(&sem->count, val);

        atomic_set(&sem->waking, -1);

        init_waitqueue_head(&sem->wait);

#if WAITQUEUE_DEBUG

        sem->__magic = (long)&sem->__magic;

#endif

}

static inline void init_MUTEX (struct semaphore *sem)

{

        sema_init(sem, 1);

}

static inline void init_MUTEX_LOCKED (struct semaphore *sem)

{

        sema_init(sem, 0);

}

extern void down(struct semaphore *);

extern void __down_failed(struct semaphore *);

extern int  down_interruptible(struct semaphore *);

extern int  __down_failed_interruptible(struct semaphore *);

extern int  down_trylock(struct semaphore *);

extern void up(struct semaphore *);

extern void __up_wakeup(struct semaphore *);

static inline int sem_getcount(struct semaphore *sem)

{

        return atomic_read(&sem->count);

}

/*

 * Hidden out of line code is fun, but extremely messy.  Rely on newer

 * compilers to do a respectable job with this.  The contention cases

 * are handled out of line in arch/alpha/kernel/semaphore.c.

 */

static inline void __down(struct semaphore *sem)

{

        long count = atomic_dec_return(&sem->count);

        if (unlikely(count < 0))

                __down_failed(sem);

}

static inline int __down_interruptible(struct semaphore *sem)

{

        long count = atomic_dec_return(&sem->count);

        if (unlikely(count < 0))

                return __down_failed_interruptible(sem);

        return 0;

}

/*

 * down_trylock returns 0 on success, 1 if we failed to get the lock.

 *

 * We must manipulate count and waking simultaneously and atomically.

 * Do this by using ll/sc on the pair of 32-bit words.

 */

static inline int __down_trylock(struct semaphore * sem)

{

        long ret, tmp, tmp2, sub;

        /* "Equivalent" C.  Note that we have to do this all without

           (taken) branches in order to be a valid ll/sc sequence.

           do {

                tmp = ldq_l;

                sub = 0x0000000100000000;

                ret = ((int)tmp <= 0);          // count <= 0 ?

                // Note that if count=0, the decrement overflows into

                // waking, so cancel the 1 loaded above.  Also cancel

                // it if the lock was already free.

                if ((int)tmp >= 0) sub = 0;     // count >= 0 ?

                ret &= ((long)tmp < 0);         // waking < 0 ?

                sub += 1;

                if (ret) break;

                tmp -= sub;

                tmp = stq_c = tmp;

           } while (tmp == 0);

        */

        __asm__ __volatile__(

                "1:     ldq_l   %1,%4\n"

                "       lda     %3,1\n"

                "       addl    %1,0,%2\n"

                "       sll     %3,32,%3\n"

                "       cmple   %2,0,%0\n"

                "       cmovge  %2,0,%3\n"

                "       cmplt   %1,0,%2\n"

                "       addq    %3,1,%3\n"

                "       and     %0,%2,%0\n"

                "       bne     %0,2f\n"

                "       subq    %1,%3,%1\n"

                "       stq_c   %1,%4\n"

                "       beq     %1,3f\n"

                "2:     mb\n"

                ".subsection 2\n"

                "3:     br      1b\n"

                ".previous"

                : "=&r"(ret), "=&r"(tmp), "=&r"(tmp2), "=&r"(sub)

                : "m"(*sem)

                : "memory");

        return ret;

}

static inline void __up(struct semaphore *sem)

{

        long ret, tmp, tmp2, tmp3;

        /* We must manipulate count and waking simultaneously and atomically.

           Otherwise we have races between up and __down_failed_interruptible

           waking up on a signal.

           "Equivalent" C.  Note that we have to do this all without

           (taken) branches in order to be a valid ll/sc sequence.

           do {

                tmp = ldq_l;

                ret = (int)tmp + 1;                     // count += 1;

                tmp2 = tmp & 0xffffffff00000000;        // extract waking

                if (ret <= 0)                           // still sleepers?

                        tmp2 += 0x0000000100000000;     // waking += 1;

                tmp = ret & 0x00000000ffffffff;         // insert count

                tmp |= tmp2;                            // insert waking;

               tmp = stq_c = tmp;

           } while (tmp == 0);

        */

        __asm__ __volatile__(

                "       mb\n"

                "1:     ldq_l   %1,%4\n"

                "       addl    %1,1,%0\n"

                "       zapnot  %1,0xf0,%2\n"

                "       addq    %2,%5,%3\n"

                "       cmovle  %0,%3,%2\n"

                "       zapnot  %0,0x0f,%1\n"

                "       bis     %1,%2,%1\n"

                "       stq_c   %1,%4\n"

                "       beq     %1,3f\n"

                "2:\n"

                ".subsection 2\n"

                "3:     br      1b\n"

                ".previous"

                : "=&r"(ret), "=&r"(tmp), "=&r"(tmp2), "=&r"(tmp3)

                : "m"(*sem), "r"(0x0000000100000000)

                : "memory");

        if (unlikely(ret <= 0))

                __up_wakeup(sem);

}

#if !WAITQUEUE_DEBUG && !defined(CONFIG_DEBUG_SEMAPHORE)

extern inline void down(struct semaphore *sem)

{

        __down(sem);

}

extern inline int down_interruptible(struct semaphore *sem)

{

        return __down_interruptible(sem);

}

extern inline int down_trylock(struct semaphore *sem)

{

        return __down_trylock(sem);

}

extern inline void up(struct semaphore *sem)

{

        __up(sem);

}

#endif

#endif