rtos.h

Go to the documentation of this file.

#ifndef EVE_RTOS_H_INCLUDED
#define EVE_RTOS_H_INCLUDED
/**********************************************************************/
/*
 * Copyright (c) 2016, Jetro AS
 * 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 AND CONRIBUTORS ``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 EVE platform.
 */

/**
 * \file
 * \brief Header file for the rtos emulation layer.
 *
 * \author DT, Jetro AS
 */ /******************************************************************/

/**
 * \addtogroup rtos RTOS emulation
 * \{
 * RTOS emulation module provides an API layer which can be used to simplify
 * porting of existing RTOS applications to EVE platform.
 * The API mostly resembles FreeRTOS API, but implementation has a lot of deviations.
 *  - All tasks have same priority.
 *  - Preemptive multitasking is not supported.
 *  - Stacks are allocated dynamically from a pool.
 *  - Implementation is thread-safe against soft irqs (EVE work, mwork), but not against
 *    hard irqs (the only exception is xTimerPendFunctionCallFromISR()).\n
 *    Only xTimerPendFunctionCallFromISR() can be called from a hard irq context.
 *    Note that it can be used as a trampolino.
 *  - Timers are implemented as EVE mworks, not as a RTOS task. Timers therefore can preempt tasks.
 *  - There is no idle task in system.
 *  - Task scheduler is initially started.
 *  - Mutexes do not support priority inheritence and work as ordinary semaphores.
 *  - Object handles are typed pointers, not void pointers.
 *  - Most, if not all ...FromISR() functions alias their task-level analogs.
 *  - taskENTER_CRITICAL() disables soft irqs to ensure a thread is not interrupted by a timer.
 *  - taskDISABLE_INTERRUPTS() disables soft and hard irqs.
 *  .
 * The layer is suboptimal and is not intended for creating either energy effective
 * or real-time applications. At the same time it uses much less RAM per task due to
 * stack sharing.
 */

/**
 * \addtogroup common Common FreeRTOS-compatible types
 * @{
 */
#define pdPASS 1                                          /**< pdPASS return code */
#define pdFALSE false                                     /**< pdFALSE return code */
#define pdTRUE true                                       /**< pdTRUE return code */
typedef int32_t BaseType_t;                               /**< BaseType_t type */
typedef uint32_t UBaseType_t;                             /**< UBaseType_t type */
typedef uint32_t TickType_t;                              /**< TickType_t type */

/** @} */

#include <sys/types.h>
#include <net/uip.h>

/* extern */ struct timeval;

/**
 * \addtogroup sock Berkeley sockets emulation
 * @{
 */
#define AF_INET         2                                 /**< INET address family */
#define SOCK_STREAM     1                                 /**< Stream socket type */
#define SOCK_DGRAM      2                                 /**< Datagram socket type */
#define IPPROTO_TCP     6                                 /**< TCP protocol */
#define IPPROTO_UDP     17                                /**< UDP protocol */
#define SOL_SOCKET      1                                 /**< setsockopt() socket options */
#define SO_RCVTIMEO     20                                /**< recv() timeout */
#define SO_SNDTIMEO     21                                /**< send() timeout */
#define TCP_NODELAY     1                                 /**< Disable Nagle's algorithm */
#define FIONBIO         0x5421                            /**< Async. socket IOCTL */


/** @} */

/**
 * \addtogroup task Task emulation
 * @{
 */

struct Task_t;
typedef struct Task_t *TaskHandle_t;                      /**< TaskHandle_t type */
typedef void (*TaskFunction_t)(void * pvParameters);      /**< TaskFunction_t type */

/**
 * portYIELD_FROM_ISR stub.
 * Implementation does not support context switch from an ISR.
 */
#define portYIELD_FROM_ISR(woken) do { } while (0)

/**
 * xTaskCreate emulation.
 * http://www.freertos.org/a00125.html
 * \note
 *  - usStackDepth is ignored, stack is dynamically allocated from a pool
 *  - uxPriority is ignored, all tasks run at same priority level
 */
BaseType_t xTaskCreate( 
    TaskFunction_t pvTaskCode, 
    const char * const pcName, 
    unsigned short usStackDepth, 
    void *pvParameters, 
    UBaseType_t uxPriority, 
    TaskHandle_t *pvCreatedTask);

/**
 * vTaskDelete emulation.
 * http://www.freertos.org/a00126.html
 */
void vTaskDelete(TaskHandle_t xTask);

/**
 * vTaskDelay emulation.
 * http://www.freertos.org/a00127.html
 */
void vTaskDelay(const TickType_t xTicksToDelay);

/**
 * vTaskDelayUntil emulation.
 * http://www.freertos.org/vtaskdelayuntil.html
 */
void vTaskDelayUntil(
    TickType_t *pxPreviousWakeTime,
    const TickType_t xTimeIncrement);

/**
 * taskYIELD emulation.
 * http://www.freertos.org/a00020.html#taskYIELD
 */
void taskYIELD(void);

/**
 * taskENTER_CRITICAL emulation.
 * http://www.freertos.org/a00020.html#taskENTER_CRITICAL
 */
void taskENTER_CRITICAL(void);

/**
 * taskEXIT_CRITICAL emulation.
 * http://www.freertos.org/a00020.html#taskEXIT_CRITICAL
 */
void taskEXIT_CRITICAL(void);

/**
 * taskDISABLE_INTERRUPTS emulation.
 * http://www.freertos.org/a00020.html#taskDISABLE_INTERRUPTS
 */
void taskDISABLE_INTERRUPTS(void);

/**
 * taskENABLE_INTERRUPTS emulation.
 * http://www.freertos.org/a00020.html#taskENABLE_INTERRUPTS
 */
void taskENABLE_INTERRUPTS(void);

/**
 * uxTaskPriorityGet stub.
 * http://www.freertos.org/a00128.html
 * \note
 *  - Implementation does not support task priorities.
 */
static inline UBaseType_t uxTaskPriorityGet(TaskHandle_t xTask)
{
  return 1;
}

/**
 * vTaskPrioritySet stub.
 * http://www.freertos.org/a00129.html
 * \note
 *  - Implementation does not support task priorities.
 */
static inline void vTaskPrioritySet(
    TaskHandle_t xTask,
    UBaseType_t uxNewPriority)
{
}

/**
 * vTaskSuspend emulation.
 * http://www.freertos.org/a00130.html
 */
void vTaskSuspend(TaskHandle_t xTaskToSuspend);

/**
 * vTaskResume emulation.
 * http://www.freertos.org/a00131.html
 */
void vTaskResume(TaskHandle_t xTaskToResume);

/**
 * xTaskResumeFromISR emulation.
 * http://www.freertos.org/taskresumefromisr.html
 * \note
 *  - Implementation never requests context switch from an ISR
 *  - This function can not be called from a hard irq context.
 */
static inline BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume)
{
  vTaskResume(xTaskToResume);
  return pdFALSE;
}

/**
 * vTaskStartScheduler stub.
 * http://www.freertos.org/a00132.html
 * \note
 *  - Implementation just exits the current thread
 */
void vTaskStartScheduler(void);

/**
 * Cancel any of blocking calls the task is currently waiting in.
 * The blocking call exits with errno set to EINTR
 */
void vTaskCancelBlockingCall(TaskHandle_t xTaskToWakeup);

/** @} */

/**
 * \addtogroup semaphores Semaphore and Mutex emulation
 * @{
 */

/* Dummy */ struct DummySemaphoreQueue_t;
typedef struct DummySemaphoreQueue_t *SemaphoreHandle_t;  /**< SemaphoreHandle_t type */
typedef struct DummySemaphoreQueue_t *QueueHandle_t;      /**< QueueHandle_t type */

/**
 * \def vSemaphoreCreateBinary
 * vSemaphoreCreateBinary emulation
 *
 * http://www.freertos.org/a00121.html
 */
#define vSemaphoreCreateBinary(xSemaphore) \
  do { \
    (xSemaphore) = xSemaphoreCreateBinary(); \
    xSemaphoreGive(xSemaphore); \
  } while (0)

/**
 * Creates a senaphore / mutex.
 *  \internal
 */
SemaphoreHandle_t xSemaphoreCreateImpl(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, bool xRecursive);

/**
 * xSemaphoreCreateBinary emulation.
 * http://www.freertos.org/xSemaphoreCreateBinary.html
 */
static inline SemaphoreHandle_t xSemaphoreCreateBinary(void)
{
  return xSemaphoreCreateImpl(1, 0, false);
}

/**
 * xSemaphoreCreateCounting emulation.
 * http://www.freertos.org/CreateCounting.html
 */
static inline SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount)
{
  return xSemaphoreCreateImpl(uxMaxCount, uxInitialCount, false);
}

/**
 * xSemaphoreCreateMutex emulation.
 * http://www.freertos.org/CreateMutex.html
 */
static inline SemaphoreHandle_t xSemaphoreCreateMutex(void)
{
  return xSemaphoreCreateImpl(1, 1, false);
}

/**
 * xSemaphoreCreateRecursiveMutex emulation.
 * http://www.freertos.org/xSemaphoreCreateRecursiveMutex.html
 */
static inline SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void)
{
  return xSemaphoreCreateImpl(0xFFFFFFFF, 0, true);
}

/**
 * vSemaphoreDelete emulation.
 * http://www.freertos.org/a00113.html#vSemaphoreDelete
 */
void vSemaphoreDelete(SemaphoreHandle_t xSemaphore);

/**
 * xSemaphoreGetMutexHolder emulation.
 * http://www.freertos.org/xSemaphoreGetMutexHolder.html
 */
TaskHandle_t xSemaphoreGetMutexHolder(SemaphoreHandle_t xSemaphore);

/**
 * xSemaphoreGive emulation.
 * http://www.freertos.org/a00123.html
 */
BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);

/**
 * xSemaphoreGiveFromISR emulation.
 * http://www.freertos.org/a00124.html
 * \note
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xSemaphoreGiveFromISR(
    SemaphoreHandle_t xSemaphore,
    BaseType_t *const pxHigherPriorityTaskWoken)
{
  return xSemaphoreGive(xSemaphore);
}

/**
 * xSemaphoreGiveRecursive emulation.
 * http://www.freertos.org/xSemaphoreGiveRecursive.html
 */
static inline BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t xSemaphore)
{
  return xSemaphoreGive(xSemaphore);
}

/**
 * xSemaphoreTake emulation.
 * http://www.freertos.org/a00123.html
 */
BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);

/**
 * xSemaphoreTakeFromISR emulation.
 * http://www.freertos.org/xSemaphoreTakeFromISR.html
 * \note
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xSemaphoreTakeFromISR(
    SemaphoreHandle_t xSemaphore,
    BaseType_t *const pxHigherPriorityTaskWoken)
{
  return xSemaphoreTake(xSemaphore, 0);
}

/**
 * xSemaphoreTakeRecursive emulation.
 * http://www.freertos.org/a00122.html
 */
static inline BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait)
{
  return xSemaphoreTake(xSemaphore, xTicksToWait);
}

/** @} */

/**
 * \addtogroup timeremu Timer emulation
 * @{
 */

struct Timer_t;
typedef struct Timer_t* TimerHandle_t;                    /**< TimerHandle_t type */
typedef void (*TimerCallbackFunction_t)(TimerHandle_t pxTimer); /**< TimerCallbackFunction_t type */
typedef void (*PendedFunction_t)(void *pvParameter1, uint32_t ulParameter2); /**< PendedFunction_t type */

/**
 * xTimerCreate emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerCreate.html
 */
TimerHandle_t xTimerCreate(
    const char *const pcTimerName,
    const TickType_t xTimerPeriod,
    const UBaseType_t uxAutoReload,
    void *const pvTimerID,
    TimerCallbackFunction_t pxCallbackFunction);

/**
 * xTimerIsTimerActive emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerIsTimerActive.html
 */
BaseType_t xTimerIsTimerActive(TimerHandle_t xTimer);

/**
 * xTimerStart emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerStart.html
 * \note
 *  - xBlockTime is ignored. Timer always starts.
 */
BaseType_t xTimerStart(
    TimerHandle_t xTimer,
    TickType_t xBlockTime);

/**
 * xTimerStop emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerStop.html
 * \note
 *  - xBlockTime is ignored. Timer always stops.
 *  - The function is synchronous, no callbacks will be called after it exits.
 */
BaseType_t xTimerStop(
    TimerHandle_t xTimer,
    TickType_t xBlockTime);

/**
 * xTimerChangePeriod emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerChangePeriod.html
 * \note
 *  - xBlockTime is ignored. Timer always stops.
 */
BaseType_t xTimerChangePeriod(
    TimerHandle_t xTimer,
    TickType_t xNewPeriod,
    TickType_t xBlockTime);

/**
 * xTimerDelete emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerDelete.html
 * \note
 *  - xBlockTime is ignored. Timer always stops.
 */
BaseType_t xTimerDelete(
    TimerHandle_t xTimer,
    TickType_t xBlockTime);

/**
 * xTimerReset emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerReset.html
 * \note
 *  - xBlockTime is ignored. Timer always stops.
 */
static inline BaseType_t xTimerReset(
    TimerHandle_t xTimer,
    TickType_t xBlockTime)
{
  return xTimerStart(xTimer, xBlockTime);
}

/**
 * xTimerStartFromISR emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerStartFromISR.html
 * \note
 *  - Implementation never requests context switch from an ISR
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xTimerStartFromISR(
    TimerHandle_t xTimer,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xTimerStart(xTimer, 0);
}

/**
 * xTimerStopFromISR emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerStopFromISR.html
 * \note
 *  - Implementation never requests context switch from an ISR
 *  - The function is synchronous, no callbacks will be called after it exits.
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xTimerStopFromISR(
    TimerHandle_t xTimer,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xTimerStop(xTimer, 0);
}

/**
 * xTimerChangePeriodFromISR emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerChangePeriodFromISR.html
 * \note
 *  - Implementation never requests context switch from an ISR
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xTimerChangePeriodFromISR(
    TimerHandle_t xTimer,
    TickType_t xNewPeriod,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xTimerChangePeriod(xTimer, xNewPeriod, 0);
}

/**
 * xTimerResetFromISR emulation.
 * http://www.freertos.org/FreeRTOS-timers-xTimerResetFromISR.html
 * \note
 *  - Implementation never requests context switch from an ISR
 *  - This function can not be called from a hard irq context
 */
static inline BaseType_t xTimerResetFromISR(
    TimerHandle_t xTimer,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xTimerReset(xTimer, 0);
}

/**
 * pvTimerGetTimerID emulation.
 * http://www.freertos.org/FreeRTOS-timers-pvTimerGetTimerID.html
 */
void *pvTimerGetTimerID(TimerHandle_t xTimer);

/**
 * vTimerSetTimerID emulation.
 * http://www.freertos.org/FreeRTOS-timers-vTimerSetTimerID.html
 */
void vTimerSetTimerID(TimerHandle_t xTimer, void *pvNewID);

/**
 * pcTimerGetTimerName emulation.
 * http://www.freertos.org/FreeRTOS-Software-Timer-API-Functions.html
 */
const char *pcTimerGetTimerName(TimerHandle_t xTimer);


/**
 * xTimerGetTimerDaemonTaskHandle stub.
 * http://www.freertos.org/FreeRTOS-Software-Timer-API-Functions.html#xTimerGetTimerDaemonTaskHandle
 * \note
 *  - Implementation does not use a timer daemon
 */
#define xTimerGetTimerDaemonTaskHandle() (!!! "Not implemented" !!!)

/**
 * xTimerPendFunctionCall emulation.
 * http://www.freertos.org/xTimerPendFunctionCall.html
 */
BaseType_t xTimerPendFunctionCall(
    PendedFunction_t xFunctionToPend,
    void *pvParameter1,
    uint32_t ulParameter2,
    TickType_t xTicksToWait);

/**
 * xTimerPendFunctionCallFromISR emulation.
 * http://www.freertos.org/xTimerPendFunctionCallFromISR.html
 * \note
 *  - This function can be called from a hard irq context
 *  - The xFunctionToPend will be executed in a soft irq context
 */
static inline BaseType_t xTimerPendFunctionCallFromISR(
    PendedFunction_t xFunctionToPend,
    void *pvParameter1,
    uint32_t ulParameter2,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xTimerPendFunctionCall(xFunctionToPend, pvParameter1, ulParameter2, 0);
}

/** @} */

/**
 * \addtogroup event Event group emulation
 * @{
 */

struct EventGroup_t;
typedef uint32_t EventBits_t;                             /**< EventBits_t type */
typedef struct EventGroup_t *EventGroupHandle_t;          /**< EventGroupHandle_t type */

/**
 * xEventGroupCreate emulation.
 * http://www.freertos.org/xEventGroupCreate.html
 */
EventGroupHandle_t xEventGroupCreate(void);

/**
 * xEventGroupWaitBits emulation.
 * http://www.freertos.org/xEventGroupWaitBits.html
 */
EventBits_t xEventGroupWaitBits(
    const EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToWaitFor,
    const BaseType_t xClearOnExit,
    const BaseType_t xWaitForAllBits,
    TickType_t xTicksToWait);

/**
 * xEventGroupSetBits emulation.
 * http://www.freertos.org/xEventGroupSetBits.html
 */
EventBits_t xEventGroupSetBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToSet);

/**
 * xEventGroupSetBitsFromISR emulation.
 * http://www.freertos.org/xEventGroupSetBitsFromISR.html
 */
static inline BaseType_t xEventGroupSetBitsFromISR(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToSet,
    BaseType_t *pxHigherPriorityTaskWoken)
{
  return xEventGroupSetBits(xEventGroup, uxBitsToSet);
}

/**
 * xEventGroupClearBits emulation.
 * http://www.freertos.org/xEventGroupClearBits.html
 */
EventBits_t xEventGroupClearBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToClear);

/**
 * xEventGroupClearBitsFromISR emulation.
 * http://www.freertos.org/xEventGroupClearBitsFromISR.html
 */
static inline EventBits_t xEventGroupClearBitsFromISR(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToClear)
{
  return xEventGroupClearBits(xEventGroup, uxBitsToClear);
}

/**
 * xEventGroupGetBits emulation.
 * http://www.freertos.org/xEventGroupGetBits.html
 */
EventBits_t xEventGroupGetBits(EventGroupHandle_t xEventGroup);

/**
 * xEventGroupGetBitsFromISR
 * http://www.freertos.org/xEventGroupGetBitsFromISR.html
 */
static inline EventBits_t xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup)
{
  return xEventGroupGetBits(xEventGroup);
}

/**
 * xEventGroupSync emulation
 * http://www.freertos.org/xEventGroupSync.html
 */
EventBits_t xEventGroupSync(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToSet,
    const EventBits_t uxBitsToWaitFor,
    TickType_t xTicksToWait);

/**
 * vEventGroupDelete emulation.
 * http://www.freertos.org/vEventGroupDelete.html
 */
void vEventGroupDelete(EventGroupHandle_t xEventGroup);

/** @} */

/**
 * \addtogroup sock
 * @{
 */

/*extern*/ struct md_heap_t;
extern const struct md_heap_t RtosSocketRxHeap;
extern const struct md_heap_t RtosSocketTxHeap;

enum rtos_socket_swap_direction_t
{
  RTOS_SOCKET_SWAP_IN,
  RTOS_SOCKET_SWAP_OUT,
};

enum rtos_socket_swap_target_t
{
  RTOS_SOCKET_SWAP_RX,
  RTOS_SOCKET_SWAP_TX,
};

struct rtos_socket_swap_params_t
{
  enum rtos_socket_swap_direction_t Dir;
  enum rtos_socket_swap_target_t Target;
  void *Data;
  uint32_t Pos;
  uint32_t Size;
};

extern bool RtosSocketSwapCallback(const struct rtos_socket_swap_params_t *Params);

bool RtosSocketRxHeapSwapOut(const struct md_heap_t *RxHeap, uint32_t Pos, const uint8_t **DataPtr, uint32_t Size);
bool RtosSocketRxHeapSwapIn(const struct md_heap_t *RxHeap, uint8_t **DataPtr, uint32_t Pos, uint32_t Size);
bool RtosSocketTxHeapSwapOut(const struct md_heap_t *TxHeap, uint32_t Pos, const uint8_t **DataPtr, uint32_t Size);
bool RtosSocketTxHeapSwapIn(const struct md_heap_t *TxHeap, uint8_t **DataPtr, uint32_t Pos, uint32_t Size);

#define RTOS_SOCKET_HEAP_NUM_ENTRIES(NumSockets) \
  ((NumSockets) + 4)

#define RTOS_SOCKET_HEAP_RAM_BUFFER_SIZE(NumSockets) \
  ((NumSockets) * (1500 + 4) + 4)

#define RTOS_SOCKET_HEAP_TINY_RAM_BUFFER_SIZE(NumSockets) \
  ((NumSockets) * 4 + 1500 + 4)

#define RTOS_SOCKET_HEAP_EXT_RAM_SIZE(NumSockets) \
  ((NumSockets) * 1500)

#define RTOS_SOCKET_HEAP_IMPL(NumSockets, Direction) \
  static struct md_descriptor_t RtosSocket ## Direction ## HeapEntries[RTOS_SOCKET_HEAP_NUM_ENTRIES(NumSockets)];   \
  static uint8_t RtosSocket ## Direction ## HeapRamBuffer[RTOS_SOCKET_HEAP_RAM_BUFFER_SIZE(NumSockets)];            \
  static struct md_state_t RtosSocket ## Direction ## HeapState;                                                    \
  const struct md_heap_t RtosSocket ## Direction ## Heap;                                                           \
  static void RtosSocket ## Direction ## HeapCtor(void) __attribute__((constructor));                               \
  static void RtosSocket ## Direction ## HeapCtor(void)                                                             \
  {                                                                                                                 \
    MemInit(&RtosSocket ## Direction ## Heap);                                                                      \
  }                                                                                                                 \
  const struct md_heap_t RtosSocket ## Direction ## Heap =                                                          \
  {                                                                                                                 \
    .Entries = RtosSocket ## Direction ## HeapEntries,                                                              \
    .NumEntries = RTOS_SOCKET_HEAP_NUM_ENTRIES(NumSockets),                                                         \
    .RamBuffer = RtosSocket ## Direction ## HeapRamBuffer,                                                          \
    .RamBufferSize = RTOS_SOCKET_HEAP_RAM_BUFFER_SIZE(NumSockets),                                                  \
    .State = &RtosSocket ## Direction ## HeapState,                                                                 \
    .ExtRamSize = 0,                                                                                                \
    .SwapOut = NULL,                                                                                                \
    .SwapIn = NULL,                                                                                                 \
  }
#define RTOS_SOCKET_HEAP(NumSockets)            \
    RTOS_SOCKET_HEAP_IMPL(NumSockets, Rx);      \
    RTOS_SOCKET_HEAP_IMPL(NumSockets, Tx)

#define RTOS_SOCKET_TINY_HEAP_IMPL(NumSockets, Direction) \
  static struct md_descriptor_t RtosSocket ## Direction ## HeapEntries[RTOS_SOCKET_HEAP_NUM_ENTRIES(NumSockets)];   \
  static uint8_t RtosSocket ## Direction ## HeapRamBuffer[RTOS_SOCKET_HEAP_TINY_RAM_BUFFER_SIZE(NumSockets)];       \
  static struct md_state_t RtosSocket ## Direction ## HeapState;                                                    \
  const struct md_heap_t RtosSocket ## Direction ## Heap;                                                           \
  static void RtosSocket ## Direction ## HeapCtor(void) __attribute__((constructor));                               \
  static void RtosSocket ## Direction ## HeapCtor(void)                                                             \
  {                                                                                                                 \
    MemInit(&RtosSocket ## Direction ## Heap);                                                                      \
  }                                                                                                                 \
  const struct md_heap_t RtosSocket ## Direction ## Heap =                                                          \
  {                                                                                                                 \
    .Entries = RtosSocket ## Direction ## HeapEntries,                                                              \
    .NumEntries = RTOS_SOCKET_HEAP_NUM_ENTRIES(NumSockets),                                                         \
    .RamBuffer = RtosSocket ## Direction ## HeapRamBuffer,                                                          \
    .RamBufferSize = RTOS_SOCKET_HEAP_TINY_RAM_BUFFER_SIZE(NumSockets),                                             \
    .State = &RtosSocket ## Direction ## HeapState,                                                                 \
    .ExtRamSize = RTOS_SOCKET_HEAP_EXT_RAM_SIZE(NumSockets),                                                        \
    .SwapOut = RtosSocket ## Direction ## HeapSwapOut,                                                              \
    .SwapIn = RtosSocket ## Direction ## HeapSwapIn,                                                                \
  }
#define RTOS_SOCKET_TINY_HEAP(NumSockets)       \
    RTOS_SOCKET_TINY_HEAP_IMPL(NumSockets, Rx); \
    RTOS_SOCKET_TINY_HEAP_IMPL(NumSockets, Tx)


typedef uint16_t sa_family_t;                             /**< Socket address family type */
typedef uint32_t socklen_t;                               /**< Socket address length type */

/**
 * Abstract socket address.
 */
struct sockaddr
{
  sa_family_t sa_family;                                  /**< Socket address family */
  char sa_data[14];                                       /**< Abstract data */
};

/**
 * IP address.
 */
struct in_addr
{
  uint32_t s_addr;                                        /**< Address */
};

/**
 * Internet socket address.
 */
struct sockaddr_in
{
  sa_family_t sin_family;                                 /**< Socket address family (AF_INET) */
  uint16_t sin_port;                                      /**< Socket port, big endian */
  struct in_addr sin_addr;                                /**< IP address */
  unsigned char pad[sizeof(struct sockaddr) - sizeof(sa_family_t) - sizeof(uint16_t) - sizeof(struct in_addr)];
};

/**
 * Host to network order
 *
 * \param hostshort Host-order short value
 * \return          Network-order short value
 */
#define HTONS(hostshort) UIP_HTONS(hostshort)

/**
 * Host to network order
 *
 * \param hostshort Host-order short value
 * \return          Network-order short value
 */
static inline uint16_t htons(uint16_t hostshort)
{
  return UIP_HTONS(hostshort);
}

/**
 * Creates an endpoint for communication and returns a descriptor for the socket.
 *
 * \param domain   The protocol family of the created socket.
 * \param type     SOCK_STREAM or SOCK_DGRAM
 * \param protocol The actual transport protocol to use. 0 or IPPROTO_xxx
 * \return  -1 if an error occurred. Otherwise, it returns an integer representing the newly assigned descriptor.
 */
int socket(int domain, int type, int protocol);

/**
 * Assigns a socket to an address.
 *
 * \param sockfd A descriptor representing the socket to perform the bind on.
 * \param addr A pointer to a sockaddr structure representing the address to bind to.
 * \param addrlen The size of the sockaddr structure, pointed by addr.
 * \return 0 on success or -1 if an error occurs.
 */
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

/**
 * Prepares a socket for incoming connections.
 *
 * \param sockfd A socket descriptor.
 * \param backlog The number of pending connections that can be queued up at any one time (ignored by the current implementation).
 * \return 0 on success or -1 if an error occurs.
 */
int listen(int sockfd, int backlog);

/**
 * Creates a new socket for an incoming connection.
 *
 * \param sockfd A descriptor representing the listening socket.
 * \param addr A pointer to a sockaddr structure to receive the client's address information.
 * \param addrlen A pointer to a variable, containing size of the sockaddr structure. Updated by the call.
 */
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

/**
 * Establishes a communication link towards a remote host.
 *
 * \param sockfd A local socket descriptor
 * \param addr A pointer to a sockaddr structure representing the address of the remote host.
 * \param addrlen The size of the sockaddr structure, pointed by addr.
 * \return 0 on success or -1 if an error occurs.
 */
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

/**
 * Closes a socket desctiptor.
 *
 * \param sockfd A socket descriptor
 * \return 0 on success or -1 if an error occurs.
 */
int closesocket(int sockfd);

/**
 * Receives data from a socket
 *
 * \param sockfd A socket descriptor.
 * \param buf The buffer to be filled by data
 * \param len Length of the buffer.
 * \param flags Ignored in the current implementation
 * \return Amount of bytes received or -1 if an error occurs.
 */
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

/**
 * Waits for a socket becomes available for data reading
 *
 * If this function returns 0 for a socket, then a consequent recv() call
 * will not block and will not return EWOULDBLOCK.
 *
 * \param sockfd A socket descriptor.
 * \param timeout Timeout in system ticks.
 * \return 0 if the socket becomes available, or -1 if not.
 */
int poll_recv(int sockfd, uint32_t timeout);

/**
 * Sends data into a socket
 *
 * \param sockfd A socket descriptor.
 * \param buf The buffer to be sent
 * \param len Length of the buffer.
 * \param flags Ignored in the current implementation
 * \return Amount of bytes sent or -1 if an error occurs.
 */
ssize_t send(int sockfd, const void *buf, size_t len, int flags);

/**
 * Waits for a socket becomes available for data sending
 *
 * If thiss function returns 0 for a socket, then a consequent send() call
 * will not block and will not return EWOULDBLOCK.
 *
 * \param sockfd A socket descriptor.
 * \param timeout Timeout in system ticks.
 * \return 0 if the socket becomes available, or -1 if not.
 */
int poll_send(int sockfd, uint32_t timeout);

/**
 * Synchronous I/O multiplexing
 *
 * \param nfds The highest-numbered socket descriptor plus 1.
 * \param readfds set of sockets, watched for read, updated on return.
 * \param writefds set of sockets, watched for write, updated on return.
 * \param exceptfds set of sockets, watched for exception, updated on return.
 * \param timeout timeout. Infinite if NULL.
 * \return the total number of bits set in the readfds, writefds, exceptfds.
 */
int select(int nfds, fd_set *readfds, fd_set *writefds,
    fd_set *exceptfds, struct timeval *timeout);

/**
 * Controls socket options (IOCTL ones).
 *
 * \param sockfd A socket descriptor.
 * \param request IOCTL request (so far FIONBIO is the only supported)
 * \param opt The option value
 * \return 0
 *
 * \code
int opt = 1;
ioctlsocket(fd, FIONBIO, &opt);
 * \endcode
 */
int ioctlsocket(int sockfd, int request, const void *opt);

/**
 * Controls socket options (setsockopt ones).
 *
 * \param sockfd A socket descriptor.
 * \param level Option level (SOL_SOCKET, IPPROTO_TCP)
 * \param request The option name (SO_RCVTIMEO, SO_SNDTIMEO, TCP_NODELAY)
 * \param opt The option value
 * \param length Length of the option
 * \return 0
 *
 * \code
struct timeval tv;
tv.tv_sec = 30;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

int flag = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
 * \endcode
 */
int setsockopt(int sockfd, int level, int request, const void *opt, socklen_t length);

/** \} */ /* sock */

/** \} */ /* rtos */

#endif