/* 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 */