/*
 * Copyright 2009, Colin Günther, coling@gmx.de.
 * Copyright 2007, Hugo Santos. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */


#include "device.h"

#include <compat/sys/mutex.h>


struct mtx Giant;
struct rw_lock ifnet_rwlock;
struct mtx gIdStoreLock;


void
mtx_init(struct mtx *mutex, const char *name, const char *type,
	int options)
{
	if ((options & MTX_RECURSE) != 0) {
		recursive_lock_init_etc(&mutex->u.recursive, name,
			MUTEX_FLAG_CLONE_NAME);
		mutex->type = MTX_RECURSE;
	} else if ((options & MTX_SPIN) != 0) {
		B_INITIALIZE_SPINLOCK(&mutex->u.spinlock_.lock);
		mutex->type = MTX_SPIN;
	} else {
		mutex_init_etc(&mutex->u.mutex_.lock, name, MUTEX_FLAG_CLONE_NAME);
		mutex->u.mutex_.owner = -1;
		mutex->type = MTX_DEF;
	}
}


void
mtx_sysinit(void *arg)
{
	struct mtx_args *margs = arg;

	mtx_init((struct mtx *)margs->ma_mtx, margs->ma_desc, NULL,
	    margs->ma_opts);
}


void
mtx_destroy(struct mtx *mutex)
{
	if ((mutex->type & MTX_RECURSE) != 0) {
		recursive_lock_destroy(&mutex->u.recursive);
	} else if ((mutex->type & MTX_SPIN) != 0) {
		KASSERT(!B_SPINLOCK_IS_LOCKED(&mutex->u.spinlock_.lock), ("spin mutex is locked"));
	} else {
		mutex_destroy(&mutex->u.mutex_.lock);
	}
}


void
mtx_lock_spin(struct mtx* mutex)
{
	KASSERT(mutex->type == MTX_SPIN, ("not a spin mutex"));

	cpu_status status = disable_interrupts();
	acquire_spinlock(&mutex->u.spinlock_.lock);
	mutex->u.spinlock_.state = status;
}


void
mtx_unlock_spin(struct mtx* mutex)
{
	KASSERT(mutex->type == MTX_SPIN, ("not a spin mutex"));

	cpu_status status = mutex->u.spinlock_.state;
	release_spinlock(&mutex->u.spinlock_.lock);
	restore_interrupts(status);
}


void
_mtx_assert(struct mtx *m, int what, const char *file, int line)
{
	switch (what) {
	case MA_OWNED:
	case MA_OWNED | MA_RECURSED:
	case MA_OWNED | MA_NOTRECURSED:
		if (!mtx_owned(m))
			panic("mutex %p not owned at %s:%d",
				m, file, line);
		if (mtx_recursed(m)) {
			if ((what & MA_NOTRECURSED) != 0)
				panic("mutex %p recursed at %s:%d",
					m, file, line);
		} else if ((what & MA_RECURSED) != 0) {
			panic("mutex %p unrecursed at %s:%d",
				m, file, line);
		}
		break;
	case MA_NOTOWNED:
		if (mtx_owned(m))
			panic("mutex %p owned at %s:%d",
				m, file, line);
		break;
	default:
		panic("unknown mtx_assert at %s:%d", file, line);
	}
}


status_t
init_mutexes()
{
	mtx_init(&Giant, "Banana Giant", NULL, MTX_DEF);
	rw_lock_init(&ifnet_rwlock, "gDevices");
	mtx_init(&gIdStoreLock, "Identity Store", NULL, MTX_DEF);

	return B_OK;
}


void
uninit_mutexes()
{
	mtx_destroy(&Giant);
	rw_lock_destroy(&ifnet_rwlock);
	mtx_destroy(&gIdStoreLock);
}