[net-next-2.6.git] / arch / s390 / lib / spinlock.c

/*
 *  arch/s390/lib/spinlock.c
 *    Out of line spinlock code.
 *
 *    Copyright (C) IBM Corp. 2004, 2006
 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/init.h>
#include <asm/io.h>

int spin_retry = 1000;

/**
 * spin_retry= parameter
 */
static int __init spin_retry_setup(char *str)
{
	spin_retry = simple_strtoul(str, &str, 0);
	return 1;
}
__setup("spin_retry=", spin_retry_setup);

static inline void _raw_yield(void)
{
	if (MACHINE_HAS_DIAG44)
		asm volatile("diag 0,0,0x44");
}

static inline void _raw_yield_cpu(int cpu)
{
	if (MACHINE_HAS_DIAG9C)
		asm volatile("diag %0,0,0x9c"
			     : : "d" (__cpu_logical_map[cpu]));
	else
		_raw_yield();
}

void _raw_spin_lock_wait(arch_spinlock_t *lp)
{
	int count = spin_retry;
	unsigned int cpu = ~smp_processor_id();

	while (1) {
		if (count-- <= 0) {
			unsigned int owner = lp->owner_cpu;
			if (owner != 0)
				_raw_yield_cpu(~owner);
			count = spin_retry;
		}
		if (__raw_spin_is_locked(lp))
			continue;
		if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
			return;
	}
}
EXPORT_SYMBOL(_raw_spin_lock_wait);

void _raw_spin_lock_wait_flags(arch_spinlock_t *lp, unsigned long flags)
{
	int count = spin_retry;
	unsigned int cpu = ~smp_processor_id();

	local_irq_restore(flags);
	while (1) {
		if (count-- <= 0) {
			unsigned int owner = lp->owner_cpu;
			if (owner != 0)
				_raw_yield_cpu(~owner);
			count = spin_retry;
		}
		if (__raw_spin_is_locked(lp))
			continue;
		local_irq_disable();
		if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
			return;
		local_irq_restore(flags);
	}
}
EXPORT_SYMBOL(_raw_spin_lock_wait_flags);

int _raw_spin_trylock_retry(arch_spinlock_t *lp)
{
	unsigned int cpu = ~smp_processor_id();
	int count;

	for (count = spin_retry; count > 0; count--) {
		if (__raw_spin_is_locked(lp))
			continue;
		if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
			return 1;
	}
	return 0;
}
EXPORT_SYMBOL(_raw_spin_trylock_retry);

void _raw_spin_relax(arch_spinlock_t *lock)
{
	unsigned int cpu = lock->owner_cpu;
	if (cpu != 0)
		_raw_yield_cpu(~cpu);
}
EXPORT_SYMBOL(_raw_spin_relax);

void _raw_read_lock_wait(raw_rwlock_t *rw)
{
	unsigned int old;
	int count = spin_retry;

	while (1) {
		if (count-- <= 0) {
			_raw_yield();
			count = spin_retry;
		}
		if (!__raw_read_can_lock(rw))
			continue;
		old = rw->lock & 0x7fffffffU;
		if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
			return;
	}
}
EXPORT_SYMBOL(_raw_read_lock_wait);

void _raw_read_lock_wait_flags(raw_rwlock_t *rw, unsigned long flags)
{
	unsigned int old;
	int count = spin_retry;

	local_irq_restore(flags);
	while (1) {
		if (count-- <= 0) {
			_raw_yield();
			count = spin_retry;
		}
		if (!__raw_read_can_lock(rw))
			continue;
		old = rw->lock & 0x7fffffffU;
		local_irq_disable();
		if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
			return;
	}
}
EXPORT_SYMBOL(_raw_read_lock_wait_flags);

int _raw_read_trylock_retry(raw_rwlock_t *rw)
{
	unsigned int old;
	int count = spin_retry;

	while (count-- > 0) {
		if (!__raw_read_can_lock(rw))
			continue;
		old = rw->lock & 0x7fffffffU;
		if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
			return 1;
	}
	return 0;
}
EXPORT_SYMBOL(_raw_read_trylock_retry);

void _raw_write_lock_wait(raw_rwlock_t *rw)
{
	int count = spin_retry;

	while (1) {
		if (count-- <= 0) {
			_raw_yield();
			count = spin_retry;
		}
		if (!__raw_write_can_lock(rw))
			continue;
		if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
			return;
	}
}
EXPORT_SYMBOL(_raw_write_lock_wait);

void _raw_write_lock_wait_flags(raw_rwlock_t *rw, unsigned long flags)
{
	int count = spin_retry;

	local_irq_restore(flags);
	while (1) {
		if (count-- <= 0) {
			_raw_yield();
			count = spin_retry;
		}
		if (!__raw_write_can_lock(rw))
			continue;
		local_irq_disable();
		if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
			return;
	}
}
EXPORT_SYMBOL(_raw_write_lock_wait_flags);

int _raw_write_trylock_retry(raw_rwlock_t *rw)
{
	int count = spin_retry;

	while (count-- > 0) {
		if (!__raw_write_can_lock(rw))
			continue;
		if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
			return 1;
	}
	return 0;
}
EXPORT_SYMBOL(_raw_write_trylock_retry);
Commit	Line	Data
951f22d5 MS	1	/*
	2	* arch/s390/lib/spinlock.c
	3	* Out of line spinlock code.
	4	*
96567161	5	* Copyright (C) IBM Corp. 2004, 2006
951f22d5 MS	6	* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
	7	*/
	8
	9	#include <linux/types.h>
	10	#include <linux/module.h>
	11	#include <linux/spinlock.h>
	12	#include <linux/init.h>
	13	#include <asm/io.h>
	14
951f22d5 MS	15	int spin_retry = 1000;
	16
	17	/**
	18	* spin_retry= parameter
	19	*/
	20	static int __init spin_retry_setup(char *str)
	21	{
	22	spin_retry = simple_strtoul(str, &str, 0);
	23	return 1;
	24	}
	25	__setup("spin_retry=", spin_retry_setup);
	26
3c1fcfe2	27	static inline void _raw_yield(void)
951f22d5	28	{
951f22d5	29	if (MACHINE_HAS_DIAG44)
951f22d5 MS	30	asm volatile("diag 0,0,0x44");
	31	}
	32
3c1fcfe2 MS	33	static inline void _raw_yield_cpu(int cpu)
	34	{
	35	if (MACHINE_HAS_DIAG9C)
	36	asm volatile("diag %0,0,0x9c"
	37	: : "d" (__cpu_logical_map[cpu]));
	38	else
	39	_raw_yield();
	40	}
	41
445c8951	42	void _raw_spin_lock_wait(arch_spinlock_t *lp)
951f22d5 MS	43	{
951f22d5 MS	44	int count = spin_retry;
3c1fcfe2	45	unsigned int cpu = ~smp_processor_id();
951f22d5 MS	46
	47	while (1) {
	48	if (count-- <= 0) {
3c1fcfe2 MS	49	unsigned int owner = lp->owner_cpu;
	50	if (owner != 0)
	51	_raw_yield_cpu(~owner);
951f22d5 MS	52	count = spin_retry;
951f22d5 MS	53	}
96567161 CE	54	if (__raw_spin_is_locked(lp))
96567161 CE	55	continue;
3b4beb31	56	if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
951f22d5 MS	57	return;
	58	}
	59	}
	60	EXPORT_SYMBOL(_raw_spin_lock_wait);
	61
445c8951	62	void _raw_spin_lock_wait_flags(arch_spinlock_t *lp, unsigned long flags)
894cdde2 HH	63	{
	64	int count = spin_retry;
	65	unsigned int cpu = ~smp_processor_id();
	66
	67	local_irq_restore(flags);
	68	while (1) {
	69	if (count-- <= 0) {
	70	unsigned int owner = lp->owner_cpu;
	71	if (owner != 0)
	72	_raw_yield_cpu(~owner);
	73	count = spin_retry;
	74	}
	75	if (__raw_spin_is_locked(lp))
	76	continue;
	77	local_irq_disable();
	78	if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
	79	return;
	80	local_irq_restore(flags);
	81	}
	82	}
	83	EXPORT_SYMBOL(_raw_spin_lock_wait_flags);
	84
445c8951	85	int _raw_spin_trylock_retry(arch_spinlock_t *lp)
951f22d5	86	{
3c1fcfe2 MS	87	unsigned int cpu = ~smp_processor_id();
3c1fcfe2 MS	88	int count;
951f22d5	89
3c1fcfe2	90	for (count = spin_retry; count > 0; count--) {
96567161 CE	91	if (__raw_spin_is_locked(lp))
96567161 CE	92	continue;
3b4beb31	93	if (_raw_compare_and_swap(&lp->owner_cpu, 0, cpu) == 0)
951f22d5 MS	94	return 1;
	95	}
	96	return 0;
	97	}
	98	EXPORT_SYMBOL(_raw_spin_trylock_retry);
	99
445c8951	100	void _raw_spin_relax(arch_spinlock_t *lock)
3c1fcfe2 MS	101	{
	102	unsigned int cpu = lock->owner_cpu;
	103	if (cpu != 0)
	104	_raw_yield_cpu(~cpu);
	105	}
	106	EXPORT_SYMBOL(_raw_spin_relax);
	107
	108	void _raw_read_lock_wait(raw_rwlock_t *rw)
951f22d5 MS	109	{
	110	unsigned int old;
	111	int count = spin_retry;
	112
	113	while (1) {
	114	if (count-- <= 0) {
3c1fcfe2	115	_raw_yield();
951f22d5 MS	116	count = spin_retry;
951f22d5 MS	117	}
96567161 CE	118	if (!__raw_read_can_lock(rw))
96567161 CE	119	continue;
951f22d5 MS	120	old = rw->lock & 0x7fffffffU;
	121	if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
	122	return;
	123	}
	124	}
	125	EXPORT_SYMBOL(_raw_read_lock_wait);
	126
ce58ae6f HC	127	void _raw_read_lock_wait_flags(raw_rwlock_t *rw, unsigned long flags)
	128	{
	129	unsigned int old;
	130	int count = spin_retry;
	131
	132	local_irq_restore(flags);
	133	while (1) {
	134	if (count-- <= 0) {
	135	_raw_yield();
	136	count = spin_retry;
	137	}
	138	if (!__raw_read_can_lock(rw))
	139	continue;
	140	old = rw->lock & 0x7fffffffU;
	141	local_irq_disable();
	142	if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
	143	return;
	144	}
	145	}
	146	EXPORT_SYMBOL(_raw_read_lock_wait_flags);
	147
3c1fcfe2	148	int _raw_read_trylock_retry(raw_rwlock_t *rw)
951f22d5 MS	149	{
	150	unsigned int old;
	151	int count = spin_retry;
	152
	153	while (count-- > 0) {
96567161 CE	154	if (!__raw_read_can_lock(rw))
96567161 CE	155	continue;
951f22d5 MS	156	old = rw->lock & 0x7fffffffU;
	157	if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
	158	return 1;
	159	}
	160	return 0;
	161	}
	162	EXPORT_SYMBOL(_raw_read_trylock_retry);
	163
3c1fcfe2	164	void _raw_write_lock_wait(raw_rwlock_t *rw)
951f22d5 MS	165	{
	166	int count = spin_retry;
	167
	168	while (1) {
	169	if (count-- <= 0) {
3c1fcfe2	170	_raw_yield();
951f22d5 MS	171	count = spin_retry;
951f22d5 MS	172	}
96567161 CE	173	if (!__raw_write_can_lock(rw))
96567161 CE	174	continue;
951f22d5 MS	175	if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
	176	return;
	177	}
	178	}
	179	EXPORT_SYMBOL(_raw_write_lock_wait);
	180
ce58ae6f HC	181	void _raw_write_lock_wait_flags(raw_rwlock_t *rw, unsigned long flags)
	182	{
	183	int count = spin_retry;
	184
	185	local_irq_restore(flags);
	186	while (1) {
	187	if (count-- <= 0) {
	188	_raw_yield();
	189	count = spin_retry;
	190	}
	191	if (!__raw_write_can_lock(rw))
	192	continue;
	193	local_irq_disable();
	194	if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
	195	return;
	196	}
	197	}
	198	EXPORT_SYMBOL(_raw_write_lock_wait_flags);
	199
3c1fcfe2	200	int _raw_write_trylock_retry(raw_rwlock_t *rw)
951f22d5 MS	201	{
	202	int count = spin_retry;
	203
	204	while (count-- > 0) {
96567161 CE	205	if (!__raw_write_can_lock(rw))
96567161 CE	206	continue;
951f22d5 MS	207	if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
	208	return 1;
	209	}
	210	return 0;
	211	}
	212	EXPORT_SYMBOL(_raw_write_trylock_retry);