Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | /* * SMP- and interrupt-safe semaphores.. * * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. * * (C) Copyright 1996 Linus Torvalds * (C) Copyright 1998, 1999, 2000 Ralf Baechle * (C) Copyright 1999, 2000 Silicon Graphics, Inc. * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. */ #ifndef _ASM_SEMAPHORE_H #define _ASM_SEMAPHORE_H #include <asm/system.h> #include <asm/atomic.h> #include <linux/spinlock.h> #include <linux/wait.h> #include <linux/config.h> #include <linux/rwsem.h> struct semaphore { #ifdef __MIPSEB__ atomic_t count; atomic_t waking; #else atomic_t waking; atomic_t count; #endif wait_queue_head_t wait; #if WAITQUEUE_DEBUG long __magic; #endif } __attribute__((aligned(8))); #if WAITQUEUE_DEBUG # define __SEM_DEBUG_INIT(name) \ , (long)&(name).__magic #else # define __SEM_DEBUG_INIT(name) #endif #ifdef __MIPSEB__ #define __SEMAPHORE_INITIALIZER(name,count) \ { ATOMIC_INIT(count), ATOMIC_INIT(0), __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ __SEM_DEBUG_INIT(name) } #else #define __SEMAPHORE_INITIALIZER(name,count) \ { ATOMIC_INIT(0), ATOMIC_INIT(count), __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \ __SEM_DEBUG_INIT(name) } #endif #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) { atomic_set(&sem->count, val); atomic_set(&sem->waking, 0); 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); } asmlinkage void __down(struct semaphore * sem); asmlinkage int __down_interruptible(struct semaphore * sem); asmlinkage int __down_trylock(struct semaphore * sem); asmlinkage void __up(struct semaphore * sem); static inline void down(struct semaphore * sem) { #if WAITQUEUE_DEBUG CHECK_MAGIC(sem->__magic); #endif if (atomic_dec_return(&sem->count) < 0) __down(sem); } static inline int down_interruptible(struct semaphore * sem) { int ret = 0; #if WAITQUEUE_DEBUG CHECK_MAGIC(sem->__magic); #endif if (atomic_dec_return(&sem->count) < 0) ret = __down_interruptible(sem); return ret; } #if !defined(CONFIG_CPU_HAS_LLSC) || defined(CONFIG_CPU_MIPS32) static inline int down_trylock(struct semaphore * sem) { int ret = 0; if (atomic_dec_return(&sem->count) < 0) ret = __down_trylock(sem); return ret; } #else /* * down_trylock returns 0 on success, 1 if we failed to get the lock. * * We must manipulate count and waking simultaneously and atomically. * Here, we this by using ll/sc on the pair of 32-bit words. This * won't work on MIPS32 platforms, however, and must be rewritten. * * Pseudocode: * * Decrement(sem->count) * If(sem->count >=0) { * Return(SUCCESS) // resource is free * } else { * If(sem->waking <= 0) { // if no wakeup pending * Increment(sem->count) // undo decrement * Return(FAILURE) * } else { * Decrement(sem->waking) // otherwise "steal" wakeup * Return(SUCCESS) * } * } */ static inline int down_trylock(struct semaphore * sem) { long ret, tmp, tmp2, sub; #if WAITQUEUE_DEBUG CHECK_MAGIC(sem->__magic); #endif __asm__ __volatile__( ".set\tmips3\t\t\t# down_trylock\n" "0:\tlld\t%1, %4\n\t" "dli\t%3, 0x0000000100000000\n\t" "dsubu\t%1, %3\n\t" "li\t%0, 0\n\t" "bgez\t%1, 2f\n\t" "sll\t%2, %1, 0\n\t" "blez\t%2, 1f\n\t" "daddiu\t%1, %1, -1\n\t" "b\t2f\n\t" "1:\tdaddu\t%1, %1, %3\n" "li\t%0, 1\n" "2:\tscd\t%1, %4\n\t" "beqz\t%1, 0b\n\t" ".set mips0" : "=&r"(ret), "=&r"(tmp), "=&r"(tmp2), "=&r"(sub) : "m"(*sem) : "memory"); return ret; } #endif /* * Note! This is subtle. We jump to wake people up only if * the semaphore was negative (== somebody was waiting on it). */ static inline void up(struct semaphore * sem) { #if WAITQUEUE_DEBUG CHECK_MAGIC(sem->__magic); #endif if (atomic_inc_return(&sem->count) <= 0) __up(sem); } #endif /* _ASM_SEMAPHORE_H */ |