/**
 * @file
 * lwIP Operating System abstraction
 *
 */

/*
 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 *
 * Author: Adam Dunkels <adam@sics.se>
 *
 */

#include "lwip/opt.h"

#include "lwip/sys.h"

/* Most of the functions defined in sys.h must be implemented in the
 * architecture-dependent file sys_arch.c */


#ifdef WIN32

#include <windows.h>
#include <system/threads/bthread.h>

#else

#include <metalsvm/time.h>
#include <asm/tasks.h>

#define TRUE 1
#define FALSE 0

#endif
/*	sys_now(): retrives tick count to mesure system time
 *
 */
u32_t sys_now(void)
{
#ifdef WIN32
	return GetTickCount();
#else
	return get_clock_tick();
#endif
}

#if !NO_SYS

/**
 * Sleep for some ms. Timeouts are NOT processed while sleeping.
 *
 * @param ms number of milliseconds to sleep
 */
void
sys_msleep(u32_t ms)
{
  if (ms > 0) {
    sys_sem_t delaysem;
    err_t err = sys_sem_new(&delaysem, 0);
    if (err == ERR_OK) {
      sys_arch_sem_wait(&delaysem, ms);
      sys_sem_free(&delaysem);
    }
  }
}

/* sys_thread_new(): Spawns a new thread with given attributes as supportet
 * Note: In MetalSVM this is realized as kernel tasks
 */
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
{
#ifdef WIN32
	bthread_t	tmp;
	bthread_attr_t tattr;
	tattr.creation_flags = NULL;
	tattr.thread_id = NULL;
	tattr.stacksize = stacksize;
	bthread_create(&tmp,NULL,thread,arg);
	return tmp;
#else
	tid_t	tmp;
	create_kernel_task(&tmp,thread,arg);
	return tmp;
#endif
}

/* sys_sem_free(): destroy's given semaphore
 * and releases system resources.
 * This semaphore also gets invalid.
 */
void sys_sem_free(sys_sem_t* sem)
{
	sem->valid = FALSE;
	sem_destroy(&sem->sem);
}
/* sys_sem_valid(): returns if semaphore is valid 
 * at the moment
 */
int sys_sem_valid(sys_sem_t* sem)
{
	return sem->valid;
}

/*	sys_sem_new(): creates a new semaphre with given count.
 *  This semaphore becomes valid
 */
err_t sys_sem_new(sys_sem_t* sem,u8_t count)
{
	sem->valid = TRUE;
	return sem_init(&sem->sem,count);
}
/*	sys_sem_set_invalid(): this semapohore becomes invalid
 *  Note: this does not mean it is destroyed
 */
void sys_sem_set_invalid(sys_sem_t * sem)
{
	sem->valid = FALSE;
}

/* sys_sem_signal(): this semaphore is signaled
 *
 */
void sys_sem_signal(sys_sem_t* sem)
{
	sem_post(&sem->sem);
}
/* sys_arch_sem_wait): wait for the given semaphore for 
 * a given timeout
 * Note: timeout = 0 means wait forever
 */
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
	int err;
	if (!timeout)
		return sem_wait(&sem->sem);
	while (timeout)
	{
		err = sem_trywait(&sem->sem);
#ifdef WIN32
		if (err != 0x00000102L)
			return err;
#else
		if (err != -1)
			return err;
#endif
		timeout--;
	}
	return SYS_ARCH_TIMEOUT;
}

/* sys_mbox_valid() : returns if the given mailbox
 * is valid
 */
int sys_mbox_valid(sys_mbox_t * mbox)
{
	return mbox->valid;
}
/* sys_arch_mbox_fetch(): wait for the given mailbox for a specified
 * amount of time.
 * Note: timeout = 0 means wait forever
 */
u32_t sys_arch_mbox_fetch(sys_mbox_t * mbox, void **msg, u32_t timeout)
{
	int err = 0;

	if (!timeout)
		return mailbox_ptr_fetch(&mbox->mailbox,msg);

	while(timeout)
	{
		if (!mailbox_ptr_tryfetch(&mbox->mailbox,msg))
			return 0;
		timeout--;
	}
	return SYS_ARCH_TIMEOUT;

}
/* sys_mbox_free() : free the given mailbox, release the system resources
 * and set mbox to invalid
 */
void sys_mbox_free(sys_mbox_t* mbox)
{
	mbox->valid = FALSE;
	mailbox_ptr_destroy(&mbox->mailbox);
}

/* sys_arch_mbox_tryfetch(): poll for new data in mailbox
 *
 */
u32_t sys_arch_mbox_tryfetch(sys_mbox_t* mbox, void** msg)
{
	return mailbox_ptr_tryfetch(&mbox->mailbox,msg);
}

/* sys_mbox_new(): create a new mailbox with a minimum size of "size"
 * 
 */
err_t sys_mbox_new(sys_mbox_t* mbox,int size)
{
	mbox->valid = TRUE;
	return mailbox_ptr_init(&mbox->mailbox);
}
/* sys_mbox_set_invalid(): set the given mailbox to invalid
 * Note: system resources are NOT freed
 */
void sys_mbox_set_invalid(sys_mbox_t* mbox)
{
	mbox->valid =FALSE;
}
/* sys_mbox_trypost(): try to post data to the mailbox
 * Note: There is at the moment no try post implemented
 * so we use the normal post instead
 */
int sys_mbox_trypost(sys_mbox_t* mbox,void* msg)
{
	return mailbox_ptr_post(&mbox->mailbox,msg);
}

/* sys_mbox_post(): post new data to the mailbox
 *
 */
void sys_mbox_post(sys_mbox_t* mbox,void* msg)
{
	mailbox_ptr_post(&mbox->mailbox,msg);
}

/* sys_mutex_lock(): lock the given mutex
 * Note: There is no specific mutex in MetalSVM 
 * so we use a semaphore with 1 element
 */
void sys_mutex_lock(sys_mutex_t* mutex)
{
#ifdef WIN32
	bthread_mutex_lock(mutex);
#else
	sem_wait(mutex);
#endif
}

/* sys_mutex_unlock(): unlock the given mutex
 *
 */
void sys_mutex_unlock(sys_mutex_t* mutex)
{
#ifdef WIN32
	bthread_mutex_unlock(mutex);
#else
	sem_post(mutex);
#endif
}

/* sys_mutex_new(): create a new mutex
 *
 */
err_t sys_mutex_new(sys_mutex_t * mutex)
{
#ifdef WIN32
	bthread_mutex_init(mutex);
	return 0;
#else
	sem_init(mutex,1);
	return 0;
#endif
}

/* sys_init(): init needed system resources
 * Note: At the moment there are none
 */
void sys_init()
{
	return NULL;
}

#endif /* !NO_SYS */