[linux-2.6-block.git] / arch / arc / include / asm / spinlock.h

/*
 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#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__)
#define arch_spin_lock_flags(lock, flags)	arch_spin_lock(lock)
#define arch_spin_unlock_wait(x) \
	do { while (arch_spin_is_locked(x)) cpu_relax(); } while (0)

static inline void arch_spin_lock(arch_spinlock_t *lock)
{
	unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__;

	__asm__ __volatile__(
	"1:	ex  %0, [%1]		\n"
	"	breq  %0, %2, 1b	\n"
	: "+&r" (tmp)
	: "r"(&(lock->slock)), "ir"(__ARCH_SPIN_LOCK_LOCKED__)
	: "memory");
}

static inline int arch_spin_trylock(arch_spinlock_t *lock)
{
	unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__;

	__asm__ __volatile__(
	"1:	ex  %0, [%1]		\n"
	: "+r" (tmp)
	: "r"(&(lock->slock))
	: "memory");

	return (tmp == __ARCH_SPIN_LOCK_UNLOCKED__);
}

static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
	lock->slock = __ARCH_SPIN_LOCK_UNLOCKED__;
	smp_mb();
}

/*
 * Read-write spinlocks, allowing multiple readers but only one writer.
 *
 * The spinlock itself is contained in @counter and access to it is
 * serialized with @lock_mutex.
 *
 * Unfair locking as Writers could be starved indefinitely by Reader(s)
 */

/* Would read_trylock() succeed? */
#define arch_read_can_lock(x)	((x)->counter > 0)

/* Would write_trylock() succeed? */
#define arch_write_can_lock(x)	((x)->counter == __ARCH_RW_LOCK_UNLOCKED__)

/* 1 - lock taken successfully */
static inline int arch_read_trylock(arch_rwlock_t *rw)
{
	int ret = 0;

	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));

	smp_mb();
	return ret;
}

/* 1 - lock taken successfully */
static inline int arch_write_trylock(arch_rwlock_t *rw)
{
	int ret = 0;

	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));

	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)
{
	arch_spin_lock(&(rw->lock_mutex));
	rw->counter++;
	arch_spin_unlock(&(rw->lock_mutex));
}

static inline void arch_write_unlock(arch_rwlock_t *rw)
{
	arch_spin_lock(&(rw->lock_mutex));
	rw->counter = __ARCH_RW_LOCK_UNLOCKED__;
	arch_spin_unlock(&(rw->lock_mutex));
}

#define arch_read_lock_flags(lock, flags)	arch_read_lock(lock)
#define arch_write_lock_flags(lock, flags)	arch_write_lock(lock)

#define arch_spin_relax(lock)	cpu_relax()
#define arch_read_relax(lock)	cpu_relax()
#define arch_write_relax(lock)	cpu_relax()

#endif /* __ASM_SPINLOCK_H */
Commit	Line	Data
6e35fa2d VG	1	/*
	2	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*/
	8
	9	#ifndef __ASM_SPINLOCK_H
	10	#define __ASM_SPINLOCK_H
	11
	12	#include <asm/spinlock_types.h>
	13	#include <asm/processor.h>
	14	#include <asm/barrier.h>
	15
	16	#define arch_spin_is_locked(x) ((x)->slock != __ARCH_SPIN_LOCK_UNLOCKED__)
	17	#define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock)
	18	#define arch_spin_unlock_wait(x) \
	19	do { while (arch_spin_is_locked(x)) cpu_relax(); } while (0)
	20
	21	static inline void arch_spin_lock(arch_spinlock_t *lock)
	22	{
	23	unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__;
	24
	25	__asm__ __volatile__(
	26	"1: ex %0, [%1] \n"
	27	" breq %0, %2, 1b \n"
	28	: "+&r" (tmp)
	29	: "r"(&(lock->slock)), "ir"(__ARCH_SPIN_LOCK_LOCKED__)
	30	: "memory");
	31	}
	32
	33	static inline int arch_spin_trylock(arch_spinlock_t *lock)
	34	{
	35	unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__;
	36
	37	__asm__ __volatile__(
	38	"1: ex %0, [%1] \n"
	39	: "+r" (tmp)
	40	: "r"(&(lock->slock))
	41	: "memory");
	42
	43	return (tmp == __ARCH_SPIN_LOCK_UNLOCKED__);
	44	}
	45
	46	static inline void arch_spin_unlock(arch_spinlock_t *lock)
	47	{
	48	lock->slock = __ARCH_SPIN_LOCK_UNLOCKED__;
	49	smp_mb();
	50	}
	51
	52	/*
	53	* Read-write spinlocks, allowing multiple readers but only one writer.
	54	*
	55	* The spinlock itself is contained in @counter and access to it is
	56	* serialized with @lock_mutex.
	57	*
	58	* Unfair locking as Writers could be starved indefinitely by Reader(s)
	59	*/
	60
	61	/* Would read_trylock() succeed? */
	62	#define arch_read_can_lock(x) ((x)->counter > 0)
	63
	64	/* Would write_trylock() succeed? */
65	#define arch_write_can_lock(x) ((x)->counter == __ARCH_RW_LOCK_UNLOCKED__)
66
67	/* 1 - lock taken successfully */
68	static inline int arch_read_trylock(arch_rwlock_t *rw)
69	{
70	int ret = 0;
71
72	arch_spin_lock(&(rw->lock_mutex));
73
74	/*
75	* zero means writer holds the lock exclusively, deny Reader.
76	* Otherwise grant lock to first/subseq reader
77	*/
78	if (rw->counter > 0) {
79	rw->counter--;
80	ret = 1;
81	}
82
83	arch_spin_unlock(&(rw->lock_mutex));
84
85	smp_mb();
86	return ret;
87	}
88
89	/* 1 - lock taken successfully */
90	static inline int arch_write_trylock(arch_rwlock_t *rw)
91	{
92	int ret = 0;
93
94	arch_spin_lock(&(rw->lock_mutex));
95
96	/*
97	* If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),
98	* deny writer. Otherwise if unlocked grant to writer
99	* Hence the claim that Linux rwlocks are unfair to writers.
100	* (can be starved for an indefinite time by readers).
101	*/
102	if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) {
103	rw->counter = 0;
104	ret = 1;
105	}
106	arch_spin_unlock(&(rw->lock_mutex));
107
108	return ret;
109	}
110
111	static inline void arch_read_lock(arch_rwlock_t *rw)
112	{
113	while (!arch_read_trylock(rw))
114	cpu_relax();
115	}
116
117	static inline void arch_write_lock(arch_rwlock_t *rw)
118	{
119	while (!arch_write_trylock(rw))
120	cpu_relax();
121	}
122
123	static inline void arch_read_unlock(arch_rwlock_t *rw)
124	{
125	arch_spin_lock(&(rw->lock_mutex));
126	rw->counter++;
127	arch_spin_unlock(&(rw->lock_mutex));
128	}
129
130	static inline void arch_write_unlock(arch_rwlock_t *rw)
131	{
132	arch_spin_lock(&(rw->lock_mutex));
133	rw->counter = __ARCH_RW_LOCK_UNLOCKED__;
134	arch_spin_unlock(&(rw->lock_mutex));
135	}
136
137	#define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
138	#define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
139
140	#define arch_spin_relax(lock) cpu_relax()
141	#define arch_read_relax(lock) cpu_relax()
142	#define arch_write_relax(lock) cpu_relax()
143
144	#endif /* __ASM_SPINLOCK_H */