/*
 * Copyright 2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ithamar R. Adema, ithamar@upgrade-android.com
 */

#include <KernelExport.h>

#include <kernel.h>
#include <user_atomic.h>

#include <util/AutoLock.h>

#ifdef ATOMIC64_FUNCS_ARE_SYSCALLS

/*
 * NOTE: Unlike their 32-bit counterparts, these functions can use
 * spinlocks safely currently, as no atomic 64-bit operations are
 * done in the spinlock code. If this ever changes, this code will
 * have to change.
 *
 * This code is here for ARMv6, which cannot do proper 64-bit atomic
 * operations. Anything newer is capable, and does therefore not
 * depend on this code.
 */


static spinlock atomic_lock = B_SPINLOCK_INITIALIZER;


void
atomic_set64(int64 *value, int64 newValue)
{
	SpinLocker locker(&atomic_lock);

	*value = newValue;
}


int64
atomic_get_and_set64(int64 *value, int64 newValue)
{
	SpinLocker locker(&atomic_lock);

	int64 oldValue = *value;
	*value = newValue;
	return oldValue;
}


int64
atomic_test_and_set64(int64 *value, int64 newValue, int64 testAgainst)
{
	SpinLocker locker(&atomic_lock);

	int64 oldValue = *value;
	if (oldValue == testAgainst)
		*value = newValue;
	return oldValue;
}


int64
atomic_add64(int64 *value, int64 addValue)
{
	SpinLocker locker(&atomic_lock);

	int64 oldValue = *value;
	*value += addValue;
	return oldValue;
}


int64
atomic_and64(int64 *value, int64 andValue)
{
	SpinLocker locker(&atomic_lock);

	int64 oldValue = *value;
	*value &= andValue;
	return oldValue;
}


int64
atomic_or64(int64 *value, int64 orValue)
{
	SpinLocker locker(&atomic_lock);

	int64 oldValue = *value;
	*value |= orValue;
	return oldValue;
}


int64
atomic_get64(int64 *value)
{
	SpinLocker locker(&atomic_lock);
	return *value;
}


int64
_user_atomic_get_and_set64(int64 *value, int64 newValue)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_get_and_set64(value, newValue);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}


void
_user_atomic_set64(int64 *value, int64 newValue)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		atomic_set64(value, newValue);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return;
	}

access_violation:
	// XXX kill application
	return;
}


int64
_user_atomic_test_and_set64(int64 *value, int64 newValue, int64 testAgainst)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_test_and_set64(value, newValue, testAgainst);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}


int64
_user_atomic_add64(int64 *value, int64 addValue)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_add64(value, addValue);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}


int64
_user_atomic_and64(int64 *value, int64 andValue)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_and64(value, andValue);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}


int64
_user_atomic_or64(int64 *value, int64 orValue)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_or64(value, orValue);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}


int64
_user_atomic_get64(int64 *value)
{
	if (IS_USER_ADDRESS(value)
		&& lock_memory((void *)value, sizeof(int64), B_READ_DEVICE) == B_OK) {
		int64 oldValue = atomic_get64(value);
		unlock_memory((void *)value, sizeof(int64), B_READ_DEVICE);
		return oldValue;
	}

access_violation:
	// XXX kill application
	return -1;
}

#endif /* ATOMIC64_FUNCS_ARE_SYSCALLS */