]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - include/asm-powerpc/spinlock.h
1 #ifndef __ASM_SPINLOCK_H
2 #define __ASM_SPINLOCK_H
6 * Simple spin lock operations.
8 * Copyright (C) 2001-2004 Paul Mackerras <paulus@au.ibm.com>, IBM
9 * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
10 * Copyright (C) 2002 Dave Engebretsen <engebret@us.ibm.com>, IBM
11 * Rework to support virtual processors
13 * Type of int is used as a full 64b word is not necessary.
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
20 * (the type definitions are in asm/spinlock_types.h)
24 #include <asm/hvcall.h>
25 #include <asm/iseries/hv_call.h>
27 #include <asm/asm-compat.h>
28 #include <asm/synch.h>
30 #define __raw_spin_is_locked(x) ((x)->slock != 0)
33 /* use 0x800000yy when locked, where yy == CPU number */
34 #define LOCK_TOKEN (*(u32 *)(&get_paca()->lock_token))
40 * This returns the old value in the lock, so we succeeded
41 * in getting the lock if the return value is 0.
43 static __inline__
unsigned long __spin_trylock(raw_spinlock_t
*lock
)
45 unsigned long tmp
, token
;
56 : "r" (token
), "r" (&lock
->slock
)
62 static int __inline__
__raw_spin_trylock(raw_spinlock_t
*lock
)
64 return __spin_trylock(lock
) == 0;
68 * On a system with shared processors (that is, where a physical
69 * processor is multiplexed between several virtual processors),
70 * there is no point spinning on a lock if the holder of the lock
71 * isn't currently scheduled on a physical processor. Instead
72 * we detect this situation and ask the hypervisor to give the
73 * rest of our timeslice to the lock holder.
75 * So that we can tell which virtual processor is holding a lock,
76 * we put 0x80000000 | smp_processor_id() in the lock when it is
77 * held. Conveniently, we have a word in the paca that holds this
81 #if defined(CONFIG_PPC_SPLPAR) || defined(CONFIG_PPC_ISERIES)
82 /* We only yield to the hypervisor if we are in shared processor mode */
83 #define SHARED_PROCESSOR (get_lppaca()->shared_proc)
84 extern void __spin_yield(raw_spinlock_t
*lock
);
85 extern void __rw_yield(raw_rwlock_t
*lock
);
86 #else /* SPLPAR || ISERIES */
87 #define __spin_yield(x) barrier()
88 #define __rw_yield(x) barrier()
89 #define SHARED_PROCESSOR 0
92 static void __inline__
__raw_spin_lock(raw_spinlock_t
*lock
)
95 if (likely(__spin_trylock(lock
) == 0))
101 } while (unlikely(lock
->slock
!= 0));
106 static void __inline__
__raw_spin_lock_flags(raw_spinlock_t
*lock
, unsigned long flags
)
108 unsigned long flags_dis
;
111 if (likely(__spin_trylock(lock
) == 0))
113 local_save_flags(flags_dis
);
114 local_irq_restore(flags
);
117 if (SHARED_PROCESSOR
)
119 } while (unlikely(lock
->slock
!= 0));
121 local_irq_restore(flags_dis
);
125 static __inline__
void __raw_spin_unlock(raw_spinlock_t
*lock
)
127 __asm__
__volatile__("# __raw_spin_unlock\n\t"
128 LWSYNC_ON_SMP
: : :"memory");
133 extern void __raw_spin_unlock_wait(raw_spinlock_t
*lock
);
135 #define __raw_spin_unlock_wait(lock) \
136 do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0)
140 * Read-write spinlocks, allowing multiple readers
141 * but only one writer.
143 * NOTE! it is quite common to have readers in interrupts
144 * but no interrupt writers. For those circumstances we
145 * can "mix" irq-safe locks - any writer needs to get a
146 * irq-safe write-lock, but readers can get non-irqsafe
150 #define __raw_read_can_lock(rw) ((rw)->lock >= 0)
151 #define __raw_write_can_lock(rw) (!(rw)->lock)
154 #define __DO_SIGN_EXTEND "extsw %0,%0\n"
155 #define WRLOCK_TOKEN LOCK_TOKEN /* it's negative */
157 #define __DO_SIGN_EXTEND
158 #define WRLOCK_TOKEN (-1)
162 * This returns the old value in the lock + 1,
163 * so we got a read lock if the return value is > 0.
165 static long __inline__
__read_trylock(raw_rwlock_t
*rw
)
169 __asm__
__volatile__(
180 : "cr0", "xer", "memory");
186 * This returns the old value in the lock,
187 * so we got the write lock if the return value is 0.
189 static __inline__
long __write_trylock(raw_rwlock_t
*rw
)
193 token
= WRLOCK_TOKEN
;
194 __asm__
__volatile__(
203 : "r" (token
), "r" (&rw
->lock
)
209 static void __inline__
__raw_read_lock(raw_rwlock_t
*rw
)
212 if (likely(__read_trylock(rw
) > 0))
216 if (SHARED_PROCESSOR
)
218 } while (unlikely(rw
->lock
< 0));
223 static void __inline__
__raw_write_lock(raw_rwlock_t
*rw
)
226 if (likely(__write_trylock(rw
) == 0))
230 if (SHARED_PROCESSOR
)
232 } while (unlikely(rw
->lock
!= 0));
237 static int __inline__
__raw_read_trylock(raw_rwlock_t
*rw
)
239 return __read_trylock(rw
) > 0;
242 static int __inline__
__raw_write_trylock(raw_rwlock_t
*rw
)
244 return __write_trylock(rw
) == 0;
247 static void __inline__
__raw_read_unlock(raw_rwlock_t
*rw
)
251 __asm__
__volatile__(
264 static __inline__
void __raw_write_unlock(raw_rwlock_t
*rw
)
266 __asm__
__volatile__("# write_unlock\n\t"
267 LWSYNC_ON_SMP
: : :"memory");
271 #endif /* __KERNEL__ */
272 #endif /* __ASM_SPINLOCK_H */