/*
 * 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.
 *
 * Copyright (C) 2006 by Ralf Baechle (ralf@linux-mips.org)
 */
#ifndef __ASM_BARRIER_H
#define __ASM_BARRIER_H

#include <asm/addrspace.h>
#include <asm/sync.h>

static inline void __sync(void)
{
        asm volatile(__SYNC(full, always) ::: "memory");
}

static inline void rmb(void)
{
        asm volatile(__SYNC(rmb, always) ::: "memory");
}
#define rmb rmb

static inline void wmb(void)
{
        asm volatile(__SYNC(wmb, always) ::: "memory");
}
#define wmb wmb

#define fast_mb()       __sync()

#define __fast_iob()                            \
        __asm__ __volatile__(                   \
                ".set   push\n\t"               \
                ".set   noreorder\n\t"          \
                "lw     $0,%0\n\t"              \
                "nop\n\t"                       \
                ".set   pop"                    \
                : /* no output */               \
                : "m" (*(int *)CKSEG1)          \
                : "memory")
#ifdef CONFIG_CPU_CAVIUM_OCTEON
# define fast_iob()     do { } while (0)
#else /* ! CONFIG_CPU_CAVIUM_OCTEON */
# ifdef CONFIG_SGI_IP28
#  define fast_iob()                            \
        __asm__ __volatile__(                   \
                ".set   push\n\t"               \
                ".set   noreorder\n\t"          \
                "lw     $0,%0\n\t"              \
                "sync\n\t"                      \
                "lw     $0,%0\n\t"              \
                ".set   pop"                    \
                : /* no output */               \
                : "m" (*(int *)CKSEG1ADDR(0x1fa00004)) \
                : "memory")
# else
#  define fast_iob()                            \
        do {                                    \
                __sync();                       \
                __fast_iob();                   \
        } while (0)
# endif
#endif /* CONFIG_CPU_CAVIUM_OCTEON */

#ifdef CONFIG_CPU_HAS_WB

#include <asm/wbflush.h>

#define mb()            wbflush()
#define iob()           wbflush()

#else /* !CONFIG_CPU_HAS_WB */

#define mb()            fast_mb()
#define iob()           fast_iob()

#endif /* !CONFIG_CPU_HAS_WB */

#if defined(CONFIG_WEAK_ORDERING)
# define __smp_mb()     __sync()
# define __smp_rmb()    rmb()
# define __smp_wmb()    wmb()
#else
# define __smp_mb()     barrier()
# define __smp_rmb()    barrier()
# define __smp_wmb()    barrier()
#endif

/*
 * When LL/SC does imply order, it must also be a compiler barrier to avoid the
 * compiler from reordering where the CPU will not. When it does not imply
 * order, the compiler is also free to reorder across the LL/SC loop and
 * ordering will be done by smp_llsc_mb() and friends.
 */
#if defined(CONFIG_WEAK_REORDERING_BEYOND_LLSC) && defined(CONFIG_SMP)
# define __WEAK_LLSC_MB         sync
# define smp_llsc_mb() \
        __asm__ __volatile__(__stringify(__WEAK_LLSC_MB) : : :"memory")
# define __LLSC_CLOBBER
#else
# define __WEAK_LLSC_MB
# define smp_llsc_mb()          do { } while (0)
# define __LLSC_CLOBBER         "memory"
#endif

#ifdef CONFIG_CPU_CAVIUM_OCTEON
#define smp_mb__before_llsc() smp_wmb()
#define __smp_mb__before_llsc() __smp_wmb()
/* Cause previous writes to become visible on all CPUs as soon as possible */
#define nudge_writes() __asm__ __volatile__(".set push\n\t"             \
                                            ".set arch=octeon\n\t"      \
                                            "syncw\n\t"                 \
                                            ".set pop" : : : "memory")
#else
#define smp_mb__before_llsc() smp_llsc_mb()
#define __smp_mb__before_llsc() smp_llsc_mb()
#define nudge_writes() mb()
#endif

/*
 * In the Loongson3 LL/SC workaround case, all of our LL/SC loops already have
 * a completion barrier immediately preceding the LL instruction. Therefore we
 * can skip emitting a barrier from __smp_mb__before_atomic().
 */
#ifdef CONFIG_CPU_LOONGSON3_WORKAROUNDS
# define __smp_mb__before_atomic()
#else
# define __smp_mb__before_atomic()      __smp_mb__before_llsc()
#endif

#define __smp_mb__after_atomic()        smp_llsc_mb()

static inline void sync_ginv(void)
{
        asm volatile(__SYNC(ginv, always));
}

#include <asm-generic/barrier.h>

#endif /* __ASM_BARRIER_H */