/*
 * Copyright (c) 2001-2003 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 OS functionality. */
/* */
/****************************************************************************** */

/* ------------------------ System architecture includes ----------------------------- */
#include "arch/sys_arch.h"
#include "logging.h"

/* ------------------------ lwIP includes --------------------------------- */
#include "lwip/opt.h"

#include "lwip/debug.h"
#include "lwip/def.h"
#include "lwip/sys.h"
#include "lwip/mem.h"
#include "lwip/stats.h"

#if !INCLUDE_xTaskAbortDelay
#error "lwIP FreeRTOS port requires INCLUDE_xTaskAbortDelay"
#endif
#if !INCLUDE_xTaskGetCurrentTaskHandle
#error "lwIP FreeRTOS port requires INCLUDE_xTaskGetCurrentTaskHandle"
#endif

/* Very crude mechanism used to determine if the critical section handling
 * functions are being called from an interrupt context or not.  This relies on
 * the interrupt handler setting this variable manually. */
portBASE_TYPE xInsideISR = pdFALSE;

/*---------------------------------------------------------------------------*
* Routine:  sys_mbox_new
*---------------------------------------------------------------------------*
* Description:
*      Creates a new mailbox
* Inputs:
*      int size                -- Size of elements in the mailbox
* Outputs:
*      sys_mbox_t              -- Handle to new mailbox
*---------------------------------------------------------------------------*/
err_t sys_mbox_new( sys_mbox_t * pxMailBox,
                    int iSize )
{
    err_t xReturn = ERR_MEM;
    sys_mbox_t pxTempMbox;

    pxTempMbox.xMbox = xQueueCreate( iSize, sizeof( void * ) );

    if( pxTempMbox.xMbox != NULL )
    {
        pxTempMbox.xTask = NULL;
        *pxMailBox = pxTempMbox;
        xReturn = ERR_OK;
        SYS_STATS_INC_USED( mbox );
    }

    return xReturn;
}


/*---------------------------------------------------------------------------*
* Routine:  sys_mbox_free
*---------------------------------------------------------------------------*
* Description:
*      Deallocates a mailbox. If there are messages still present in the
*      mailbox when the mailbox is deallocated, it is an indication of a
*      programming error in lwIP and the developer should be notified.
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
* Outputs:
*      sys_mbox_t              -- Handle to new mailbox
*---------------------------------------------------------------------------*/
void sys_mbox_free( sys_mbox_t * pxMailBox )
{
    unsigned long ulMessagesWaiting;
    QueueHandle_t xMbox;
    TaskHandle_t xTask;
    sys_mbox_t volatile * pvxMailBox = pxMailBox;

    if( pvxMailBox != NULL )
    {
        ulMessagesWaiting = uxQueueMessagesWaiting( pvxMailBox->xMbox );
        configASSERT( ( ulMessagesWaiting == 0 ) );

#if SYS_STATS
        {
            if( ulMessagesWaiting != 0UL )
            {
                SYS_STATS_INC( mbox.err );
            }

            SYS_STATS_DEC( mbox.used );
        }
#endif /* SYS_STATS */

        taskENTER_CRITICAL();
        xMbox = pvxMailBox->xMbox;
        xTask = pvxMailBox->xTask;
        pvxMailBox->xMbox = NULL;
        taskEXIT_CRITICAL();

        if( xTask != NULL )
        {
            xTaskAbortDelay( xTask );
        }

        vQueueDelete( xMbox );
    }
}

/*---------------------------------------------------------------------------*
* Routine:  sys_mbox_post
*---------------------------------------------------------------------------*
* Description:
*      Post the "msg" to the mailbox.
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
*      void *data              -- Pointer to data to post
*---------------------------------------------------------------------------*/
void sys_mbox_post( sys_mbox_t * pxMailBox,
                    void * pxMessageToPost )
{
    while( xQueueSendToBack( pxMailBox->xMbox, &pxMessageToPost, portMAX_DELAY ) != pdTRUE )
    {
    }
}

/*---------------------------------------------------------------------------*
* Routine:  sys_mbox_trypost
*---------------------------------------------------------------------------*
* Description:
*      Try to post the "msg" to the mailbox.  Returns immediately with
*      error if cannot.
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
*      void *msg               -- Pointer to data to post
* Outputs:
*      err_t                   -- ERR_OK if message posted, else ERR_MEM
*                                  if not.
*---------------------------------------------------------------------------*/
err_t sys_mbox_trypost( sys_mbox_t * pxMailBox,
                        void * pxMessageToPost )
{
    err_t xReturn;
    portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

    if( xInsideISR != pdFALSE )
    {
        xReturn = xQueueSendFromISR( pxMailBox->xMbox, &pxMessageToPost, &xHigherPriorityTaskWoken );
    }
    else
    {
        xReturn = xQueueSend( pxMailBox->xMbox, &pxMessageToPost, ( TickType_t ) 0 );
    }

    if( xReturn == pdPASS )
    {
        xReturn = ERR_OK;
    }
    else
    {
        /* The queue was already full. */
        xReturn = ERR_MEM;
        SYS_STATS_INC( mbox.err );
    }

    return xReturn;
}

err_t sys_mbox_trypost_fromisr( sys_mbox_t * pxMailBox,
                                void * pxMessageToPost )
{
    err_t xReturn;

    xInsideISR = pdTRUE;
    xReturn = sys_mbox_trypost( pxMailBox, pxMessageToPost );
    xInsideISR = pdFALSE;

    return xReturn;
}

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_mbox_fetch
*---------------------------------------------------------------------------*
* Description:
*      Blocks the thread until a message arrives in the mailbox, but does
*      not block the thread longer than "timeout" milliseconds (similar to
*      the sys_arch_sem_wait() function). The "msg" argument is a result
*      parameter that is set by the function (i.e., by doing "*msg =
*      ptr"). The "msg" parameter maybe NULL to indicate that the message
*      should be dropped.
*
*      The return values are the same as for the sys_arch_sem_wait() function:
*      Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
*      timeout.
*
*      Note that a function with a similar name, sys_mbox_fetch(), is
*      implemented by lwIP.
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
*      void **msg              -- Pointer to pointer to msg received
*      u32_t timeout           -- Number of milliseconds until timeout
* Outputs:
*      u32_t                   -- SYS_ARCH_TIMEOUT if timeout, else 1
*---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_fetch( sys_mbox_t * pxMailBox,
                           void ** ppvBuffer,
                           u32_t ulTimeOut )
{
    void * pvDummy;
    unsigned long ulReturn = SYS_ARCH_TIMEOUT;
    QueueHandle_t xMbox;
    TaskHandle_t xTask;
    BaseType_t xResult;
    sys_mbox_t volatile * pvxMailBox = pxMailBox;

    if( pvxMailBox == NULL )
    {
        goto exit;
    }

    taskENTER_CRITICAL();
    xMbox = pvxMailBox->xMbox;
    xTask = xTaskGetCurrentTaskHandle();

    if( ( xMbox != NULL ) && ( xTask != NULL ) && ( pvxMailBox->xTask == NULL ) )
    {
        pvxMailBox->xTask = xTask;
    }
    else
    {
        xMbox = NULL;
    }

    taskEXIT_CRITICAL();

    if( xMbox == NULL )
    {
        goto exit;
    }

    if( NULL == ppvBuffer )
    {
        ppvBuffer = &pvDummy;
    }

    if( ulTimeOut != 0UL )
    {
        configASSERT( xInsideISR == ( portBASE_TYPE ) 0 );

        if( pdTRUE == xQueueReceive( xMbox, &( *ppvBuffer ), ulTimeOut / portTICK_PERIOD_MS ) )
        {
            ulReturn = 1UL;
        }
        else
        {
            /* Timed out. */
            *ppvBuffer = NULL;
        }
    }
    else
    {
        for( xResult = pdFALSE; ( xMbox != NULL ) && ( xResult != pdTRUE ); )
        {
            xResult = xQueueReceive( xMbox, &( *ppvBuffer ), portMAX_DELAY );
            xMbox = pvxMailBox->xMbox;
        }

        if( xResult == pdTRUE )
        {
            ulReturn = 1UL;
        }
    }

    pvxMailBox->xTask = NULL;

exit:
    return ulReturn;
}

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_mbox_tryfetch
*---------------------------------------------------------------------------*
* Description:
*      Similar to sys_arch_mbox_fetch, but if message is not ready
*      immediately, we'll return with SYS_MBOX_EMPTY.  On success, 0 is
*      returned.
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
*      void **msg              -- Pointer to pointer to msg received
* Outputs:
*      u32_t                   -- SYS_MBOX_EMPTY if no messages.  Otherwise,
*                                  return ERR_OK.
*---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_tryfetch( sys_mbox_t * pxMailBox,
                              void ** ppvBuffer )
{
    void * pvDummy;
    unsigned long ulReturn;
    long lResult;
    portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

    if( ppvBuffer == NULL )
    {
        ppvBuffer = &pvDummy;
    }

    if( xInsideISR != pdFALSE )
    {
        lResult = xQueueReceiveFromISR( pxMailBox->xMbox, &( *ppvBuffer ), &xHigherPriorityTaskWoken );
    }
    else
    {
        lResult = xQueueReceive( pxMailBox->xMbox, &( *ppvBuffer ), 0UL );
    }

    if( lResult == pdPASS )
    {
        ulReturn = ERR_OK;
    }
    else
    {
        ulReturn = SYS_MBOX_EMPTY;
    }

    return ulReturn;
}

/*---------------------------------------------------------------------------*
* Routine:  sys_sem_new
*---------------------------------------------------------------------------*
* Description:
*      Creates and returns a new semaphore. The "ucCount" argument specifies
*      the initial state of the semaphore.
*      NOTE: Currently this routine only creates counts of 1 or 0
* Inputs:
*      sys_mbox_t mbox         -- Handle of mailbox
*      u8_t ucCount              -- Initial ucCount of semaphore (1 or 0)
* Outputs:
*      sys_sem_t               -- Created semaphore or 0 if could not create.
*---------------------------------------------------------------------------*/
err_t sys_sem_new( sys_sem_t * pxSemaphore,
                   u8_t ucCount )
{
    err_t xReturn = ERR_MEM;

    vSemaphoreCreateBinary( ( *pxSemaphore ) );

    if( *pxSemaphore != NULL )
    {
        if( ucCount == 0U )
        {
            xSemaphoreTake( *pxSemaphore, 1UL );
        }

        xReturn = ERR_OK;
        SYS_STATS_INC_USED( sem );
    }
    else
    {
        SYS_STATS_INC( sem.err );
    }

    return xReturn;
}

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_sem_wait
*---------------------------------------------------------------------------*
* Description:
*      Blocks the thread while waiting for the semaphore to be
*      signaled. If the "timeout" argument is non-zero, the thread should
*      only be blocked for the specified time (measured in
*      milliseconds).
*
*      If the timeout argument is non-zero, the return value is the number of
*      milliseconds spent waiting for the semaphore to be signaled. If the
*      semaphore wasn't signaled within the specified time, the return value is
*      SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
*      (i.e., it was already signaled), the function may return zero.
*
*      Notice that lwIP implements a function with a similar name,
*      sys_sem_wait(), that uses the sys_arch_sem_wait() function.
* Inputs:
*      sys_sem_t sem           -- Semaphore to wait on
*      u32_t timeout           -- Number of milliseconds until timeout
* Outputs:
*      u32_t                   -- Time elapsed or SYS_ARCH_TIMEOUT.
*---------------------------------------------------------------------------*/
u32_t sys_arch_sem_wait( sys_sem_t * pxSemaphore,
                         u32_t ulTimeout )
{
    TickType_t xStartTime, xEndTime, xElapsed;
    unsigned long ulReturn;

    xStartTime = xTaskGetTickCount();

    if( ulTimeout != 0UL )
    {
        if( xSemaphoreTake( *pxSemaphore, ulTimeout / portTICK_PERIOD_MS ) == pdTRUE )
        {
            xEndTime = xTaskGetTickCount();
            xElapsed = ( xEndTime - xStartTime ) * portTICK_PERIOD_MS;
            ulReturn = xElapsed;
        }
        else
        {
            ulReturn = SYS_ARCH_TIMEOUT;
        }
    }
    else
    {
        while( xSemaphoreTake( *pxSemaphore, portMAX_DELAY ) != pdTRUE )
        {
        }

        xEndTime = xTaskGetTickCount();
        xElapsed = ( xEndTime - xStartTime ) * portTICK_PERIOD_MS;

        if( xElapsed == 0UL )
        {
            xElapsed = 1UL;
        }

        ulReturn = xElapsed;
    }

    return ulReturn;
}

/** Create a new mutex
 * @param mutex pointer to the mutex to create
 * @return a new mutex */
err_t sys_mutex_new( sys_mutex_t * pxMutex )
{
    err_t xReturn = ERR_MEM;

    *pxMutex = xSemaphoreCreateMutex();

    if( *pxMutex != NULL )
    {
        xReturn = ERR_OK;
        SYS_STATS_INC_USED( mutex );
    }
    else
    {
        SYS_STATS_INC( mutex.err );
    }

    return xReturn;
}

/** Lock a mutex
 * @param mutex the mutex to lock */
void sys_mutex_lock( sys_mutex_t * pxMutex )
{
    while( xSemaphoreTake( *pxMutex, portMAX_DELAY ) != pdPASS )
    {
    }
}

/** Unlock a mutex
 * @param mutex the mutex to unlock */
void sys_mutex_unlock( sys_mutex_t * pxMutex )
{
    xSemaphoreGive( *pxMutex );
}


/** Delete a semaphore
 * @param mutex the mutex to delete */
void sys_mutex_free( sys_mutex_t * pxMutex )
{
    SYS_STATS_DEC( mutex.used );
    vQueueDelete( *pxMutex );
}


/*---------------------------------------------------------------------------*
* Routine:  sys_sem_signal
*---------------------------------------------------------------------------*
* Description:
*      Signals (releases) a semaphore
* Inputs:
*      sys_sem_t sem           -- Semaphore to signal
*---------------------------------------------------------------------------*/
void sys_sem_signal( sys_sem_t * pxSemaphore )
{
    portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

    if( xInsideISR != pdFALSE )
    {
        xSemaphoreGiveFromISR( *pxSemaphore, &xHigherPriorityTaskWoken );
    }
    else
    {
        xSemaphoreGive( *pxSemaphore );
    }
}

/*---------------------------------------------------------------------------*
* Routine:  sys_sem_free
*---------------------------------------------------------------------------*
* Description:
*      Deallocates a semaphore
* Inputs:
*      sys_sem_t sem           -- Semaphore to free
*---------------------------------------------------------------------------*/
void sys_sem_free( sys_sem_t * pxSemaphore )
{
    SYS_STATS_DEC( sem.used );
    vQueueDelete( *pxSemaphore );
}

/*---------------------------------------------------------------------------*
* Routine:  sys_init
*---------------------------------------------------------------------------*
* Description:
*      Initialize sys arch
*---------------------------------------------------------------------------*/
void sys_init( void )
{
/*    srand( rand() ); */
}

u32_t sys_now( void )
{
    return xTaskGetTickCount();
}

/*---------------------------------------------------------------------------*
* Routine:  sys_thread_new
*---------------------------------------------------------------------------*
* Description:
*      Starts a new thread with priority "prio" that will begin its
*      execution in the function "thread()". The "arg" argument will be
*      passed as an argument to the thread() function. The id of the new
*      thread is returned. Both the id and the priority are system
*      dependent.
* Inputs:
*      char *name              -- Name of thread
*      void (* thread)(void *arg) -- Pointer to function to run.
*      void *arg               -- Argument passed into function
*      int stacksize           -- Required stack amount in bytes
*      int prio                -- Thread priority
* Outputs:
*      sys_thread_t            -- Pointer to per-thread timeouts.
*---------------------------------------------------------------------------*/
sys_thread_t sys_thread_new( const char * pcName,
                             void ( * pxThread )( void * pvParameters ),
                             void * pvArg,
                             int iStackSize,
                             int iPriority )
{
    TaskHandle_t xCreatedTask;
    portBASE_TYPE xResult;
    sys_thread_t xReturn;

    xResult = xTaskCreate( pxThread, pcName, iStackSize, pvArg, iPriority, &xCreatedTask );

    if( xResult == pdPASS )
    {
        xReturn = xCreatedTask;
    }
    else
    {
        xReturn = NULL;
    }

    return xReturn;
}

#if LWIP_NETCONN_SEM_PER_THREAD
#if configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_netconn_sem_get
*---------------------------------------------------------------------------*
* Description:
*      Lookup the task-specific semaphore; create one if necessary.
*      The semaphore pointer lives in the 0th slot of the
*      TCB local storage array.  Once allocated, it is never released.
*---------------------------------------------------------------------------*/
sys_sem_t * sys_arch_netconn_sem_get( void )
{
    void * ret;
    TaskHandle_t task = xTaskGetCurrentTaskHandle();

    configASSERT( task != NULL );

    ret = pvTaskGetThreadLocalStoragePointer( task, 0 );

    if( ret == NULL )
    {
        sys_sem_t * sem;
        err_t err;
        /* allocate memory for this semaphore */
        sem = mem_malloc( sizeof( sys_sem_t ) );
        configASSERT( sem != NULL );
        err = sys_sem_new( sem, 0 );
        configASSERT( err == ERR_OK );
        configASSERT( sys_sem_valid( sem ) );
        vTaskSetThreadLocalStoragePointer( task, 0, sem );
        ret = sem;
    }

    return ret;
}
#else /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */
#error LWIP_NETCONN_SEM_PER_THREAD needs configNUM_THREAD_LOCAL_STORAGE_POINTERS
#endif /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */

#endif /* LWIP_NETCONN_SEM_PER_THREAD */

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_protect
*---------------------------------------------------------------------------*
* Description:
*      This optional function does a "fast" critical region protection and
*      returns the previous protection level. This function is only called
*      during very short critical regions. An embedded system which supports
*      ISR-based drivers might want to implement this function by disabling
*      interrupts. Task-based systems might want to implement this by using
*      a mutex or disabling tasking. This function should support recursive
*      calls from the same task or interrupt. In other words,
*      sys_arch_protect() could be called while already protected. In
*      that case the return value indicates that it is already protected.
*
*      sys_arch_protect() is only required if your port is supporting an
*      operating system.
* Outputs:
*      sys_prot_t              -- Previous protection level (not used here)
*---------------------------------------------------------------------------*/
sys_prot_t sys_arch_protect( void )
{
    if( xInsideISR == pdFALSE )
    {
        taskENTER_CRITICAL();
    }

    return ( sys_prot_t ) 1;
}

/*---------------------------------------------------------------------------*
* Routine:  sys_arch_unprotect
*---------------------------------------------------------------------------*
* Description:
*      This optional function does a "fast" set of critical region
*      protection to the value specified by pval. See the documentation for
*      sys_arch_protect() for more information. This function is only
*      required if your port is supporting an operating system.
* Inputs:
*      sys_prot_t              -- Previous protection level (not used here)
*---------------------------------------------------------------------------*/
void sys_arch_unprotect( sys_prot_t xValue )
{
    ( void ) xValue;

    if( xInsideISR == pdFALSE )
    {
        taskEXIT_CRITICAL();
    }
}

/*-------------------------------------------------------------------------*
* End of File:  sys_arch.c
*-------------------------------------------------------------------------*/