/* SPDX-License-Identifier: GPL-2.0-only *//* * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) */ #ifndef __ASM_SPINLOCK_H#define __ASM_SPINLOCK_H #include <asm/spinlock_types.h>#include <asm/processor.h>#include <asm/barrier.h> #define arch_spin_is_locked(x)	((x)->slock != __ARCH_SPIN_LOCK_UNLOCKED__) #ifdef CONFIG_ARC_HAS_LLSC static inline void arch_spin_lock(arch_spinlock_t *lock){	unsigned int val; 	__asm__ __volatile__(	"1:	llock	%[val], [%[slock]]	\n"	"	breq	%[val], %[LOCKED], 1b	\n"	/* spin while LOCKED */	"	scond	%[LOCKED], [%[slock]]	\n"	/* acquire */	"	bnz	1b			\n"	"					\n"	: [val]		"=&r"	(val)	: [slock]	"r"	(&(lock->slock)),	  [LOCKED]	"r"	(__ARCH_SPIN_LOCK_LOCKED__)	: "memory", "cc"); 	/*	 * ACQUIRE barrier to ensure load/store after taking the lock	 * don't "bleed-up" out of the critical section (leak-in is allowed)	 * http://www.spinics.net/lists/kernel/msg2010409.html	 *	 * ARCv2 only has load-load, store-store and all-all barrier	 * thus need the full all-all barrier	 */	smp_mb();} /* 1 - lock taken successfully */static inline int arch_spin_trylock(arch_spinlock_t *lock){	unsigned int val, got_it = 0; 	__asm__ __volatile__(	"1:	llock	%[val], [%[slock]]	\n"	"	breq	%[val], %[LOCKED], 4f	\n"	/* already LOCKED, just bail */	"	scond	%[LOCKED], [%[slock]]	\n"	/* acquire */	"	bnz	1b			\n"	"	mov	%[got_it], 1		\n"	"4:					\n"	"					\n"	: [val]		"=&r"	(val),	  [got_it]	"+&r"	(got_it)	: [slock]	"r"	(&(lock->slock)),	  [LOCKED]	"r"	(__ARCH_SPIN_LOCK_LOCKED__)	: "memory", "cc"); 	smp_mb(); 	return got_it;} static inline void arch_spin_unlock(arch_spinlock_t *lock){	smp_mb(); 	WRITE_ONCE(lock->slock, __ARCH_SPIN_LOCK_UNLOCKED__);} /* * Read-write spinlocks, allowing multiple readers but only one writer. * Unfair locking as Writers could be starved indefinitely by Reader(s) */ static inline void arch_read_lock(arch_rwlock_t *rw){	unsigned int val; 	/*	 * zero means writer holds the lock exclusively, deny Reader.	 * Otherwise grant lock to first/subseq reader	 *	 * 	if (rw->counter > 0) {	 *		rw->counter--;	 *		ret = 1;	 *	}	 */ 	__asm__ __volatile__(	"1:	llock	%[val], [%[rwlock]]	\n"	"	brls	%[val], %[WR_LOCKED], 1b\n"	/* <= 0: spin while write locked */	"	sub	%[val], %[val], 1	\n"	/* reader lock */	"	scond	%[val], [%[rwlock]]	\n"	"	bnz	1b			\n"	"					\n"	: [val]		"=&r"	(val)	: [rwlock]	"r"	(&(rw->counter)),	  [WR_LOCKED]	"ir"	(0)	: "memory", "cc"); 	smp_mb();} /* 1 - lock taken successfully */static inline int arch_read_trylock(arch_rwlock_t *rw){	unsigned int val, got_it = 0; 	__asm__ __volatile__(	"1:	llock	%[val], [%[rwlock]]	\n"	"	brls	%[val], %[WR_LOCKED], 4f\n"	/* <= 0: already write locked, bail */	"	sub	%[val], %[val], 1	\n"	/* counter-- */	"	scond	%[val], [%[rwlock]]	\n"	"	bnz	1b			\n"	/* retry if collided with someone */	"	mov	%[got_it], 1		\n"	"					\n"	"4: ; --- done ---			\n" 	: [val]		"=&r"	(val),	  [got_it]	"+&r"	(got_it)	: [rwlock]	"r"	(&(rw->counter)),	  [WR_LOCKED]	"ir"	(0)	: "memory", "cc"); 	smp_mb(); 	return got_it;} static inline void arch_write_lock(arch_rwlock_t *rw){	unsigned int val; 	/*	 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),	 * deny writer. Otherwise if unlocked grant to writer	 * Hence the claim that Linux rwlocks are unfair to writers.	 * (can be starved for an indefinite time by readers).	 *	 *	if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) {	 *		rw->counter = 0;	 *		ret = 1;	 *	}	 */ 	__asm__ __volatile__(	"1:	llock	%[val], [%[rwlock]]	\n"	"	brne	%[val], %[UNLOCKED], 1b	\n"	/* while !UNLOCKED spin */	"	mov	%[val], %[WR_LOCKED]	\n"	"	scond	%[val], [%[rwlock]]	\n"	"	bnz	1b			\n"	"					\n"	: [val]		"=&r"	(val)	: [rwlock]	"r"	(&(rw->counter)),	  [UNLOCKED]	"ir"	(__ARCH_RW_LOCK_UNLOCKED__),	  [WR_LOCKED]	"ir"	(0)	: "memory", "cc"); 	smp_mb();} /* 1 - lock taken successfully */static inline int arch_write_trylock(arch_rwlock_t *rw){	unsigned int val, got_it = 0; 	__asm__ __volatile__(	"1:	llock	%[val], [%[rwlock]]	\n"	"	brne	%[val], %[UNLOCKED], 4f	\n"	/* !UNLOCKED, bail */	"	mov	%[val], %[WR_LOCKED]	\n"	"	scond	%[val], [%[rwlock]]	\n"	"	bnz	1b			\n"	/* retry if collided with someone */	"	mov	%[got_it], 1		\n"	"					\n"	"4: ; --- done ---			\n" 	: [val]		"=&r"	(val),	  [got_it]	"+&r"	(got_it)	: [rwlock]	"r"	(&(rw->counter)),	  [UNLOCKED]	"ir"	(__ARCH_RW_LOCK_UNLOCKED__),	  [WR_LOCKED]	"ir"	(0)	: "memory", "cc"); 	smp_mb(); 	return got_it;} static inline void arch_read_unlock(arch_rwlock_t *rw){	unsigned int val; 	smp_mb(); 	/*	 * rw->counter++;	 */	__asm__ __volatile__(	"1:	llock	%[val], [%[rwlock]]	\n"	"	add	%[val], %[val], 1	\n"	"	scond	%[val], [%[rwlock]]	\n"	"	bnz	1b			\n"	"					\n"	: [val]		"=&r"	(val)	: [rwlock]	"r"	(&(rw->counter))	: "memory", "cc");} static inline void arch_write_unlock(arch_rwlock_t *rw){	smp_mb(); 	WRITE_ONCE(rw->counter, __ARCH_RW_LOCK_UNLOCKED__);} #else	/* !CONFIG_ARC_HAS_LLSC */ static inline void arch_spin_lock(arch_spinlock_t *lock){	unsigned int val = __ARCH_SPIN_LOCK_LOCKED__; 	/*	 * Per lkmm, smp_mb() is only required after _lock (and before_unlock)	 * for ACQ and REL semantics respectively. However EX based spinlocks	 * need the extra smp_mb to workaround a hardware quirk.	 */	smp_mb(); 	__asm__ __volatile__(	"1:	ex  %0, [%1]		\n"	"	breq  %0, %2, 1b	\n"	: "+&r" (val)	: "r"(&(lock->slock)), "ir"(__ARCH_SPIN_LOCK_LOCKED__)	: "memory"); 	smp_mb();} /* 1 - lock taken successfully */static inline int arch_spin_trylock(arch_spinlock_t *lock){	unsigned int val = __ARCH_SPIN_LOCK_LOCKED__; 	smp_mb(); 	__asm__ __volatile__(	"1:	ex  %0, [%1]		\n"	: "+r" (val)	: "r"(&(lock->slock))	: "memory"); 	smp_mb(); 	return (val == __ARCH_SPIN_LOCK_UNLOCKED__);} static inline void arch_spin_unlock(arch_spinlock_t *lock){	unsigned int val = __ARCH_SPIN_LOCK_UNLOCKED__; 	/*	 * RELEASE barrier: given the instructions avail on ARCv2, full barrier	 * is the only option	 */	smp_mb(); 	/*	 * EX is not really required here, a simple STore of 0 suffices.	 * However this causes tasklist livelocks in SystemC based SMP virtual	 * platforms where the systemc core scheduler uses EX as a cue for	 * moving to next core. Do a git log of this file for details	 */	__asm__ __volatile__(	"	ex  %0, [%1]		\n"	: "+r" (val)	: "r"(&(lock->slock))	: "memory"); 	/*	 * see pairing version/comment in arch_spin_lock above	 */	smp_mb();} /* * Read-write spinlocks, allowing multiple readers but only one writer. * Unfair locking as Writers could be starved indefinitely by Reader(s) * * The spinlock itself is contained in @counter and access to it is * serialized with @lock_mutex. */ /* 1 - lock taken successfully */static inline int arch_read_trylock(arch_rwlock_t *rw){	int ret = 0;	unsigned long flags; 	local_irq_save(flags);	arch_spin_lock(&(rw->lock_mutex)); 	/*	 * zero means writer holds the lock exclusively, deny Reader.	 * Otherwise grant lock to first/subseq reader	 */	if (rw->counter > 0) {		rw->counter--;		ret = 1;	} 	arch_spin_unlock(&(rw->lock_mutex));	local_irq_restore(flags); 	return ret;} /* 1 - lock taken successfully */static inline int arch_write_trylock(arch_rwlock_t *rw){	int ret = 0;	unsigned long flags; 	local_irq_save(flags);	arch_spin_lock(&(rw->lock_mutex)); 	/*	 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),	 * deny writer. Otherwise if unlocked grant to writer	 * Hence the claim that Linux rwlocks are unfair to writers.	 * (can be starved for an indefinite time by readers).	 */	if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) {		rw->counter = 0;		ret = 1;	}	arch_spin_unlock(&(rw->lock_mutex));	local_irq_restore(flags); 	return ret;} static inline void arch_read_lock(arch_rwlock_t *rw){	while (!arch_read_trylock(rw))		cpu_relax();} static inline void arch_write_lock(arch_rwlock_t *rw){	while (!arch_write_trylock(rw))		cpu_relax();} static inline void arch_read_unlock(arch_rwlock_t *rw){	unsigned long flags; 	local_irq_save(flags);	arch_spin_lock(&(rw->lock_mutex));	rw->counter++;	arch_spin_unlock(&(rw->lock_mutex));	local_irq_restore(flags);} static inline void arch_write_unlock(arch_rwlock_t *rw){	unsigned long flags; 	local_irq_save(flags);	arch_spin_lock(&(rw->lock_mutex));	rw->counter = __ARCH_RW_LOCK_UNLOCKED__;	arch_spin_unlock(&(rw->lock_mutex));	local_irq_restore(flags);} #endif #endif /* __ASM_SPINLOCK_H */