1 /***********************license start*************** 2 * Author: Cavium Networks 3 * 4 * Contact: support@caviumnetworks.com 5 * This file is part of the OCTEON SDK 6 * 7 * Copyright (c) 2003-2008 Cavium Networks 8 * 9 * This file is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License, Version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This file is distributed in the hope that it will be useful, but 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 16 * NONINFRINGEMENT. See the GNU General Public License for more 17 * details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this file; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * or visit http://www.gnu.org/licenses/. 23 * 24 * This file may also be available under a different license from Cavium. 25 * Contact Cavium Networks for more information 26 ***********************license end**************************************/ 27 28 /** 29 * Implementation of spinlocks for Octeon CVMX. Although similar in 30 * function to Linux kernel spinlocks, they are not compatible. 31 * Octeon CVMX spinlocks are only used to synchronize with the boot 32 * monitor and other non-Linux programs running in the system. 33 */ 34 35 #ifndef __CVMX_SPINLOCK_H__ 36 #define __CVMX_SPINLOCK_H__ 37 38 #include <asm/octeon/cvmx-asm.h> 39 40 /* Spinlocks for Octeon */ 41 42 /* define these to enable recursive spinlock debugging */ 43 /*#define CVMX_SPINLOCK_DEBUG */ 44 45 /** 46 * Spinlocks for Octeon CVMX 47 */ 48 typedef struct { 49 volatile uint32_t value; 50 } cvmx_spinlock_t; 51 52 /* note - macros not expanded in inline ASM, so values hardcoded */ 53 #define CVMX_SPINLOCK_UNLOCKED_VAL 0 54 #define CVMX_SPINLOCK_LOCKED_VAL 1 55 56 #define CVMX_SPINLOCK_UNLOCKED_INITIALIZER {CVMX_SPINLOCK_UNLOCKED_VAL} 57 58 /** 59 * Initialize a spinlock 60 * 61 * @lock: Lock to initialize 62 */ cvmx_spinlock_init(cvmx_spinlock_t * lock)63 static inline void cvmx_spinlock_init(cvmx_spinlock_t *lock) 64 { 65 lock->value = CVMX_SPINLOCK_UNLOCKED_VAL; 66 } 67 68 /** 69 * Return non-zero if the spinlock is currently locked 70 * 71 * @lock: Lock to check 72 * Returns Non-zero if locked 73 */ cvmx_spinlock_locked(cvmx_spinlock_t * lock)74 static inline int cvmx_spinlock_locked(cvmx_spinlock_t *lock) 75 { 76 return lock->value != CVMX_SPINLOCK_UNLOCKED_VAL; 77 } 78 79 /** 80 * Releases lock 81 * 82 * @lock: pointer to lock structure 83 */ cvmx_spinlock_unlock(cvmx_spinlock_t * lock)84 static inline void cvmx_spinlock_unlock(cvmx_spinlock_t *lock) 85 { 86 CVMX_SYNCWS; 87 lock->value = 0; 88 CVMX_SYNCWS; 89 } 90 91 /** 92 * Attempts to take the lock, but does not spin if lock is not available. 93 * May take some time to acquire the lock even if it is available 94 * due to the ll/sc not succeeding. 95 * 96 * @lock: pointer to lock structure 97 * 98 * Returns 0: lock successfully taken 99 * 1: lock not taken, held by someone else 100 * These return values match the Linux semantics. 101 */ 102 cvmx_spinlock_trylock(cvmx_spinlock_t * lock)103 static inline unsigned int cvmx_spinlock_trylock(cvmx_spinlock_t *lock) 104 { 105 unsigned int tmp; 106 107 __asm__ __volatile__(".set noreorder \n" 108 "1: ll %[tmp], %[val] \n" 109 /* if lock held, fail immediately */ 110 " bnez %[tmp], 2f \n" 111 " li %[tmp], 1 \n" 112 " sc %[tmp], %[val] \n" 113 " beqz %[tmp], 1b \n" 114 " li %[tmp], 0 \n" 115 "2: \n" 116 ".set reorder \n" : 117 [val] "+m"(lock->value), [tmp] "=&r"(tmp) 118 : : "memory"); 119 120 return tmp != 0; /* normalize to 0 or 1 */ 121 } 122 123 /** 124 * Gets lock, spins until lock is taken 125 * 126 * @lock: pointer to lock structure 127 */ cvmx_spinlock_lock(cvmx_spinlock_t * lock)128 static inline void cvmx_spinlock_lock(cvmx_spinlock_t *lock) 129 { 130 unsigned int tmp; 131 132 __asm__ __volatile__(".set noreorder \n" 133 "1: ll %[tmp], %[val] \n" 134 " bnez %[tmp], 1b \n" 135 " li %[tmp], 1 \n" 136 " sc %[tmp], %[val] \n" 137 " beqz %[tmp], 1b \n" 138 " nop \n" 139 ".set reorder \n" : 140 [val] "+m"(lock->value), [tmp] "=&r"(tmp) 141 : : "memory"); 142 143 } 144 145 /** ******************************************************************** 146 * Bit spinlocks 147 * These spinlocks use a single bit (bit 31) of a 32 bit word for locking. 148 * The rest of the bits in the word are left undisturbed. This enables more 149 * compact data structures as only 1 bit is consumed for the lock. 150 * 151 */ 152 153 /** 154 * Gets lock, spins until lock is taken 155 * Preserves the low 31 bits of the 32 bit 156 * word used for the lock. 157 * 158 * 159 * @word: word to lock bit 31 of 160 */ cvmx_spinlock_bit_lock(uint32_t * word)161 static inline void cvmx_spinlock_bit_lock(uint32_t *word) 162 { 163 unsigned int tmp; 164 unsigned int sav; 165 166 __asm__ __volatile__(".set noreorder \n" 167 ".set noat \n" 168 "1: ll %[tmp], %[val] \n" 169 " bbit1 %[tmp], 31, 1b \n" 170 " li $at, 1 \n" 171 " ins %[tmp], $at, 31, 1 \n" 172 " sc %[tmp], %[val] \n" 173 " beqz %[tmp], 1b \n" 174 " nop \n" 175 ".set at \n" 176 ".set reorder \n" : 177 [val] "+m"(*word), [tmp] "=&r"(tmp), [sav] "=&r"(sav) 178 : : "memory"); 179 180 } 181 182 /** 183 * Attempts to get lock, returns immediately with success/failure 184 * Preserves the low 31 bits of the 32 bit 185 * word used for the lock. 186 * 187 * 188 * @word: word to lock bit 31 of 189 * Returns 0: lock successfully taken 190 * 1: lock not taken, held by someone else 191 * These return values match the Linux semantics. 192 */ cvmx_spinlock_bit_trylock(uint32_t * word)193 static inline unsigned int cvmx_spinlock_bit_trylock(uint32_t *word) 194 { 195 unsigned int tmp; 196 197 __asm__ __volatile__(".set noreorder\n\t" 198 ".set noat\n" 199 "1: ll %[tmp], %[val] \n" 200 /* if lock held, fail immediately */ 201 " bbit1 %[tmp], 31, 2f \n" 202 " li $at, 1 \n" 203 " ins %[tmp], $at, 31, 1 \n" 204 " sc %[tmp], %[val] \n" 205 " beqz %[tmp], 1b \n" 206 " li %[tmp], 0 \n" 207 "2: \n" 208 ".set at \n" 209 ".set reorder \n" : 210 [val] "+m"(*word), [tmp] "=&r"(tmp) 211 : : "memory"); 212 213 return tmp != 0; /* normalize to 0 or 1 */ 214 } 215 216 /** 217 * Releases bit lock 218 * 219 * Unconditionally clears bit 31 of the lock word. Note that this is 220 * done non-atomically, as this implementation assumes that the rest 221 * of the bits in the word are protected by the lock. 222 * 223 * @word: word to unlock bit 31 in 224 */ cvmx_spinlock_bit_unlock(uint32_t * word)225 static inline void cvmx_spinlock_bit_unlock(uint32_t *word) 226 { 227 CVMX_SYNCWS; 228 *word &= ~(1UL << 31); 229 CVMX_SYNCWS; 230 } 231 232 #endif /* __CVMX_SPINLOCK_H__ */ 233