add utilities and update TraceX install linkv6.1_rel

1 files changed, 649 insertions, 0 deletions

diff --git a/utility/rtos_compatibility_layers/FreeRTOS/FreeRTOS.h b/utility/rtos_compatibility_layers/FreeRTOS/FreeRTOS.h
new file mode 100644
index 00000000..b5bda820
--- /dev/null
+++ b/utility/rtos_compatibility_layers/FreeRTOS/FreeRTOS.h
@@ -0,0 +1,649 @@
+/**************************************************************************/
+/*                                                                        */
+/*       Copyright (c) Microsoft Corporation. All rights reserved.        */
+/*                                                                        */
+/*       This software is licensed under the Microsoft Software License   */
+/*       Terms for Microsoft Azure RTOS. Full text of the license can be  */
+/*       found in the LICENSE file at https://aka.ms/AzureRTOS_EULA       */
+/*       and in the root directory of this software.                      */
+/*                                                                        */
+/**************************************************************************/
+
+/**************************************************************************/
+/**************************************************************************/
+/**                                                                       */
+/** ThreadX Component                                                     */
+/**                                                                       */
+/**   FreeRTOS compatibility Kit                                          */
+/**                                                                       */
+/**************************************************************************/
+/**************************************************************************/
+/*  RELEASE HISTORY                                                       */
+/*                                                                        */
+/*    DATE              NAME                      DESCRIPTION             */
+/*                                                                        */
+/*  09-30-2020     William E. Lamie         Initial Version 6.1           */
+/*                                                                        */
+/**************************************************************************/
+
+#ifndef FREERTOS_H
+#define FREERTOS_H
+
+#include <stdint.h>
+
+#include <tx_api.h>
+
+#include <FreeRTOSConfig.h>
+
+//// Hard coded configurations and other preprocessor definitions for compatibility.
+#define portCRITICAL_NESTING_IN_TCB 0
+#define portCLEAN_UP_TCB( pxTCB ) ( void ) pxTCB
+#define portPRE_TASK_DELETE_HOOK( pvTaskToDelete, pxYieldPending )
+#define portSETUP_TCB( pxTCB ) ( void ) pxTCB
+#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()
+#define portPRIVILEGE_BIT ((UBaseType_t)0x00)
+#define portYIELD_WITHIN_API portYIELD
+#define portSUPPRESS_TICKS_AND_SLEEP(xExpectedIdleTime)
+#define portTASK_USES_FLOATING_POINT()
+#define portALLOCATE_SECURE_CONTEXT(ulSecureStackSize)
+#define portDONT_DISCARD
+#define portASSERT_IF_INTERRUPT_PRIORITY_INVALID()
+#define mtCOVERAGE_TEST_MARKER()
+#define mtCOVERAGE_TEST_DELAY()
+#define portASSERT_IF_IN_ISR()
+#define portTICK_TYPE_IS_ATOMIC 1
+#define portTICK_TYPE_ENTER_CRITICAL()
+#define portTICK_TYPE_EXIT_CRITICAL()
+#define portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR() 0
+#define portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR(x) (void) x
+
+#if (configENABLE_BACKWARD_COMPATIBILITY == 1)
+    #define eTaskStateGet eTaskGetState
+    #define portTickType TickType_t
+    #define xTaskHandle TaskHandle_t
+    #define xQueueHandle QueueHandle_t
+    #define xSemaphoreHandle SemaphoreHandle_t
+    #define xQueueSetHandle QueueSetHandle_t
+    #define xQueueSetMemberHandle QueueSetMemberHandle_t
+    #define xTimeOutType TimeOut_t
+    #define xMemoryRegion MemoryRegion_t
+    #define xTaskParameters TaskParameters_t
+    #define xTaskStatusType TaskStatus_t
+    #define xTimerHandle TimerHandle_t
+    #define xCoRoutineHandle CoRoutineHandle_t
+    #define pdTASK_HOOK_CODE TaskHookFunction_t
+    #define portTICK_RATE_MS portTICK_PERIOD_MS
+    #define pcTaskGetTaskName pcTaskGetName
+    #define pcTimerGetTimerName pcTimerGetName
+    #define pcQueueGetQueueName pcQueueGetName
+    #define vTaskGetTaskInfo vTaskGetInfo
+    #define tmrTIMER_CALLBACK TimerCallbackFunction_t
+    #define pdTASK_CODE TaskFunction_t
+    #define xListItem ListItem_t
+    #define xList List_t
+    #define pxContainer pvContainer
+#endif // (#if configENABLE_BACKWARD_COMPATIBILITY == 1)
+
+#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE   ( ( ( portUSING_MPU_WRAPPERS == 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) || \
+                                                      ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) )
+
+//// Trace is not supported.
+#define traceSTART()
+#define traceEND()
+
+//// Other
+#define vQueueAddToRegistry(xQueue, pcName)
+#define vQueueUnregisterQueue(xQueue)
+
+// Assertion failure macro invoked on internal errors.
+#ifndef TX_FREERTOS_ASSERT_FAIL
+#define TX_FREERTOS_ASSERT_FAIL()
+#endif
+
+// Assertion check macro used to check for invalid arguments.
+#ifndef configASSERT
+#define configASSERT(x)
+#endif
+
+#ifndef configSTACK_DEPTH_TYPE
+#define configSTACK_DEPTH_TYPE uint16_t
+#endif
+
+typedef LONG BaseType_t;
+typedef ULONG UBaseType_t;
+typedef UINT StackType_t;
+
+#ifndef TX_FREERTOS_AUTO_INIT
+#define TX_FREERTOS_AUTO_INIT 0
+#endif
+
+#ifndef configMINIMAL_STACK_SIZE
+#error "configMINIMAL_STACK_SIZE must be defined in FreeRTOSConfig.h"
+#endif
+
+#ifndef configUSE_16_BIT_TICKS
+#define configUSE_16_BIT_TICKS 0
+#endif
+
+#if (configUSE_16_BIT_TICKS == 1)
+    typedef uint16_t TickType_t;
+    #define portMAX_DELAY (TickType_t) (0xffffU)
+#else
+    typedef uint32_t TickType_t;
+    #define portMAX_DELAY (TickType_t) (0xffffffffUL)
+
+    #define portTICK_TYPE_IS_ATOMIC 1 // TODO - is this needed.
+#endif
+
+typedef void (*TaskFunction_t)(void *);
+
+typedef enum
+{
+    eNoAction = 0,
+    eSetBits,
+    eIncrement,
+    eSetValueWithOverwrite,
+    eSetValueWithoutOverwrite,
+} eNotifyAction;
+
+
+typedef enum
+{
+    eRunning = 0,
+    eReady,
+    eBlocked,
+    eSuspended,
+    eDeleted,
+    eInvalid
+} eTaskState;
+
+#define TXFR_NOTIFYACTION_VALID(x) (((int)x >= (int)eNoAction) && ((int)x <= (int)eSetValueWithoutOverwrite))
+
+typedef struct txfr_queueset txfr_queueset_t;
+
+typedef struct txfr_task txfr_task_t;
+
+// Task related structures and type definitions.
+struct txfr_task {
+    txfr_task_t *p_next;
+    TX_THREAD thread;
+    TaskFunction_t p_task_func;
+    void *p_task_arg;
+    uint32_t task_notify_val;
+    uint32_t task_notify_val_pend;
+    uint32_t *p_notify_val_ret;
+    TX_SEMAPHORE notification_sem;
+    uint8_t notification_pending;
+    uint8_t clear_on_pend;
+    uint32_t clear_mask;
+    uint8_t allocated;
+};
+
+typedef txfr_task_t StaticTask_t;
+typedef txfr_task_t* TaskHandle_t;
+
+
+// Semaphore related structures and type definitions.
+typedef struct txfr_sem {
+    TX_SEMAPHORE sem;
+    TX_MUTEX mutex;
+    UBaseType_t max_count;
+    uint8_t allocated;
+    uint8_t is_mutex;
+    txfr_queueset_t *p_set;
+} txfr_sem_t;
+
+typedef txfr_sem_t *SemaphoreHandle_t;
+typedef txfr_sem_t StaticSemaphore_t;
+
+
+// Queue related structures and type definitions.
+typedef struct txfr_queue {
+    ULONG id;
+    uint8_t allocated;
+    txfr_queueset_t *p_set;
+    uint8_t *p_mem;
+    TX_SEMAPHORE read_sem;
+    TX_SEMAPHORE write_sem;
+    uint8_t *p_write;
+    uint8_t *p_read;
+    UBaseType_t queue_length;
+    UBaseType_t msg_size;
+} txfr_queue_t;
+
+typedef txfr_queue_t *QueueHandle_t;
+typedef txfr_queue_t StaticQueue_t;
+
+
+// Event group related structures and type definitions.
+typedef TickType_t EventBits_t;
+
+typedef struct txfr_event {
+    TX_EVENT_FLAGS_GROUP event;
+    uint8_t allocated;
+} txfr_event_t;
+
+typedef txfr_event_t *EventGroupHandle_t;
+typedef txfr_event_t StaticEventGroup_t;
+
+
+// Timers related structures and type definitions.
+typedef struct txfr_timer txfr_timer_t;
+typedef txfr_timer_t *TimerHandle_t;
+typedef txfr_timer_t StaticTimer_t;
+
+typedef void (*TimerCallbackFunction_t)(TimerHandle_t xTimer);
+
+struct txfr_timer {
+    TX_TIMER timer;
+    uint32_t period;
+    uint8_t one_shot;
+    uint8_t allocated;
+    void *id;
+    TimerCallbackFunction_t callback;
+};
+
+
+// Queue set related structures and type definitions.
+struct txfr_queueset {
+    TX_QUEUE queue;
+};
+
+typedef txfr_queueset_t *QueueSetHandle_t;
+typedef void *QueueSetMemberHandle_t;
+
+// Common definitions.
+#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY   ( -1 )
+#define errQUEUE_BLOCKED                        ( -4 )
+#define errQUEUE_YIELD                          ( -5 )
+
+#define pdFALSE         ((BaseType_t)0)
+#define pdTRUE          ((BaseType_t)1)
+
+#define pdPASS          (pdTRUE)
+#define pdFAIL          (pdFALSE)
+#define errQUEUE_EMPTY  ((BaseType_t)0)
+#define errQUEUE_FULL   ((BaseType_t)0)
+
+
+// Initialize the adaptation layer.
+UINT tx_freertos_init(void);
+
+#define tskIDLE_PRIORITY ((UBaseType_t)0U)
+
+#define taskYIELD() tx_thread_relinquish()
+#define taskYIELD_FROM_ISR()
+
+void *pvPortMalloc(size_t xWantedSize);
+void vPortFree(void *pv);
+void vPortEnterCritical(void);
+void vPortExitCritical(void);
+
+////
+// Task API
+#ifndef taskENTER_CRITICAL_FROM_ISR
+#define taskENTER_CRITICAL_FROM_ISR() __get_interrupt_state(); __disable_interrupt();
+#endif
+
+#ifndef taskEXIT_CRITICAL_FROM_ISR
+#define taskEXIT_CRITICAL_FROM_ISR(x) __set_interrupt_state(x);
+#endif
+
+#ifndef portDISABLE_INTERRUPTS
+#define portDISABLE_INTERRUPTS() __disable_interrupt()
+#endif
+
+#ifndef portENABLE_INTERRUPTS
+#define portENABLE_INTERRUPTS() __enable_interrupt()
+#endif
+
+#define taskENTER_CRITICAL() portENTER_CRITICAL()
+#define taskEXIT_CRITICAL() portEXIT_CRITICAL()
+#define portENTER_CRITICAL() vPortEnterCritical()
+#define portEXIT_CRITICAL() vPortExitCritical()
+
+#define taskDISABLE_INTERRUPTS() portDISABLE_INTERRUPTS()
+#define taskENABLE_INTERRUPTS() portENABLE_INTERRUPTS()
+
+#define taskSCHEDULER_SUSPENDED ((BaseType_t)0)
+#define taskSCHEDULER_NOT_STARTED ((BaseType_t)1)
+#define taskSCHEDULER_RUNNING ((BaseType_t)2)
+
+void vTaskStartScheduler(void);
+
+BaseType_t xTaskGetSchedulerState(void);
+
+void vTaskSuspendAll(void);
+
+BaseType_t xTaskResumeAll(void);
+
+TaskHandle_t xTaskCreateStatic(TaskFunction_t pxTaskCode,
+                               const char *const pcName,
+                               const configSTACK_DEPTH_TYPE ulStackDepth,
+                               void *const pvParameters,
+                               UBaseType_t uxPriority,
+                               StackType_t *const puxStackBuffer,
+                               StaticTask_t *const pxTaskBuffer);
+
+BaseType_t xTaskCreate(TaskFunction_t pvTaskCode,
+                       const char * const pcName,
+                       const configSTACK_DEPTH_TYPE usStackDepth,
+                       void *pvParameters,
+                       UBaseType_t uxPriority,
+                       TaskHandle_t * const pxCreatedTask);
+
+UBaseType_t uxTaskGetNumberOfTasks(void);
+
+void vTaskDelete(TaskHandle_t xTask);
+
+void vTaskDelay(const TickType_t xTicksToDelay);
+
+void vTaskDelayUntil(TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement);
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void);
+
+void vTaskSuspend(TaskHandle_t xTaskToSuspend);
+
+void vTaskResume(TaskHandle_t xTaskToResume);
+
+BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume);
+
+BaseType_t xTaskAbortDelay(TaskHandle_t xTask);
+
+UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask);
+
+UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask);
+
+void vTaskPrioritySet(TaskHandle_t xTask,
+                      UBaseType_t uxNewPriority);
+
+char *pcTaskGetName(TaskHandle_t xTaskToQuery);
+
+eTaskState eTaskGetState(TaskHandle_t xTask);
+
+TickType_t xTaskGetTickCount(void);
+
+TickType_t xTaskGetTickCountFromISR(void);
+
+////
+// Task notification API.
+
+BaseType_t xTaskNotifyGive(TaskHandle_t xTaskToNotify);
+
+void vTaskNotifyGiveFromISR(TaskHandle_t xTaskToNotify,
+                            BaseType_t *pxHigherPriorityTaskWoken);
+
+uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit,
+                          TickType_t xTicksToWait);
+
+BaseType_t xTaskNotifyWait(uint32_t ulBitsToClearOnEntry,
+                           uint32_t ulBitsToClearOnExit,
+                           uint32_t *pulNotificationValue,
+                           TickType_t xTicksToWait );
+
+BaseType_t xTaskNotify(TaskHandle_t xTaskToNotify,
+                        uint32_t ulValue,
+                        eNotifyAction eAction);
+
+BaseType_t xTaskNotifyFromISR(TaskHandle_t xTaskToNotify,
+                              uint32_t ulValue,
+                              eNotifyAction eAction,
+                              BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xTaskNotifyAndQuery(TaskHandle_t xTaskToNotify,
+                               uint32_t ulValue,
+                               eNotifyAction eAction,
+                               uint32_t *pulPreviousNotifyValue);
+
+#define xTaskGenericNotify(a, b, c, d) xTaskNotifyAndQuery(a, b, c, d)
+
+BaseType_t xTaskNotifyAndQueryFromISR(TaskHandle_t xTaskToNotify,
+                                      uint32_t ulValue,
+                                      eNotifyAction eAction,
+                                      uint32_t *pulPreviousNotifyValue,
+                                      BaseType_t *pxHigherPriorityTaskWoken);
+
+#define xTaskGenericNotifyFromISR(a, b, c, d, e) xTaskNotifyAndQueryFromISR(a, b, c, d, e)
+
+BaseType_t xTaskNotifyStateClear(TaskHandle_t xTask);
+
+uint32_t ulTaskNotifyValueClear(TaskHandle_t xTask,
+                                uint32_t ulBitsToClear);
+
+////
+// Semaphore API.
+
+#define semBINARY_SEMAPHORE_QUEUE_LENGTH ((uint8_t)1U)
+#define semSEMAPHORE_QUEUE_ITEM_LENGTH ((uint8_t)0U)
+#define semGIVE_BLOCK_TIME ((TickType_t)0U)
+
+
+SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount,
+                                           UBaseType_t uxInitialCount);
+
+SemaphoreHandle_t xSemaphoreCreateCountingStatic(UBaseType_t uxMaxCount,
+                                                 UBaseType_t uxInitialCount,
+                                                 StaticSemaphore_t *pxSemaphoreBuffer);
+
+SemaphoreHandle_t xSemaphoreCreateBinary(void);
+
+SemaphoreHandle_t xSemaphoreCreateBinaryStatic(StaticSemaphore_t *pxSemaphoreBuffer);
+
+SemaphoreHandle_t xSemaphoreCreateMutex(void);
+
+SemaphoreHandle_t xSemaphoreCreateMutexStatic(StaticSemaphore_t *pxMutexBuffer);
+
+SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void);
+
+SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic(StaticSemaphore_t *pxMutexBuffer);
+
+void vSemaphoreDelete(SemaphoreHandle_t xSemaphore);
+
+BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);
+
+BaseType_t xSemaphoreTakeFromISR(SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t xMutex, TickType_t xTicksToWait);
+
+BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
+
+BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t xMutex);
+
+UBaseType_t uxSemaphoreGetCount(SemaphoreHandle_t xSemaphore);
+
+TaskHandle_t xSemaphoreGetMutexHolder(SemaphoreHandle_t xMutex);
+
+TaskHandle_t xSemaphoreGetMutexHolderFromISR(SemaphoreHandle_t xMutex);
+
+
+////
+// Queue API.
+
+QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength, UBaseType_t uxItemSize);
+
+QueueHandle_t xQueueCreateStatic(UBaseType_t uxQueueLength,
+                                 UBaseType_t uxItemSize,
+                                 uint8_t *pucQueueStorageBuffer,
+                                 StaticQueue_t *pxQueueBuffer );
+
+void vQueueDelete(QueueHandle_t xQueue);
+
+BaseType_t xQueueSend(QueueHandle_t xQueue,
+                      const void * pvItemToQueue,
+                      TickType_t xTicksToWait);
+
+BaseType_t xQueueSendFromISR(QueueHandle_t xQueue,
+                             const void * pvItemToQueue,
+                             BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xQueueSendToBack(QueueHandle_t xQueue,
+                            const void * pvItemToQueue,
+                            TickType_t xTicksToWait);
+
+BaseType_t xQueueSendToBackFromISR(QueueHandle_t xQueue,
+                                   const void * pvItemToQueue,
+                                   BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xQueueSendToFront(QueueHandle_t xQueue,
+                             const void * pvItemToQueue,
+                             TickType_t xTicksToWait);
+
+BaseType_t xQueueSendToFrontFromISR(QueueHandle_t xQueue,
+                                    const void * pvItemToQueue,
+                                    BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xQueueReceive(QueueHandle_t xQueue,
+                         void *pvBuffer,
+                         TickType_t xTicksToWait);
+
+BaseType_t xQueueReceiveFromISR(QueueHandle_t xQueue,
+                                void *pvBuffer,
+                                BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xQueuePeek(QueueHandle_t xQueue,
+                      void *pvBuffer,
+                      TickType_t xTicksToWait);
+
+BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue,
+                             void *pvBuffer);
+
+UBaseType_t uxQueueMessagesWaiting(QueueHandle_t xQueue);
+
+UBaseType_t uxQueueMessagesWaitingFromISR(QueueHandle_t xQueue);
+
+UBaseType_t uxQueueSpacesAvailable(QueueHandle_t xQueue);
+
+BaseType_t xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue);
+
+BaseType_t xQueueIsQueueFullFromISR(const QueueHandle_t xQueue);
+
+BaseType_t xQueueReset(QueueHandle_t xQueue);
+
+BaseType_t xQueueOverwrite(QueueHandle_t xQueue,
+                           const void * pvItemToQueue);
+
+BaseType_t xQueueOverwriteFromISR(QueueHandle_t xQueue,
+                                  const void * pvItemToQueue,
+                                  BaseType_t *pxHigherPriorityTaskWoken);
+
+
+////
+// Event group API.
+
+EventGroupHandle_t xEventGroupCreate(void);
+
+EventGroupHandle_t xEventGroupCreateStatic(StaticEventGroup_t *pxEventGroupBuffer);
+
+void vEventGroupDelete(EventGroupHandle_t xEventGroup);
+
+EventBits_t xEventGroupWaitBits(const EventGroupHandle_t xEventGroup,
+                                const EventBits_t uxBitsToWaitFor,
+                                const BaseType_t xClearOnExit,
+                                const BaseType_t xWaitForAllBits,
+                                TickType_t xTicksToWait);
+
+EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup,
+                               const EventBits_t uxBitsToSet);
+
+BaseType_t xEventGroupSetBitsFromISR(EventGroupHandle_t xEventGroup,
+                                     const EventBits_t uxBitsToSet,
+                                     BaseType_t *pxHigherPriorityTaskWoken);
+
+EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToClear);
+
+BaseType_t xEventGroupClearBitsFromISR(EventGroupHandle_t xEventGroup,
+                                       const EventBits_t uxBitsToClear);
+
+EventBits_t xEventGroupGetBits(EventGroupHandle_t xEventGroup);
+
+EventBits_t xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup);
+
+
+////
+// Software timer API.
+
+#ifndef pdMS_TO_TICKS
+#ifndef configTICK_RATE_HZ
+#error "configTICK_RATE_HZ must be defined in FreeRTOSConfig.h"
+#endif // #ifndef configTICK_RATE_HZ
+    #define pdMS_TO_TICKS(xTimeInMs) ((TickType_t) (((TickType_t) (xTimeInMs) * (TickType_t)configTICK_RATE_HZ) / (TickType_t)1000))
+#endif // #ifndef pdMS_TO_TICKS
+
+TimerHandle_t xTimerCreate(const char * const pcTimerName,
+                           const TickType_t xTimerPeriod,
+                           const UBaseType_t uxAutoReload,
+                           void * const pvTimerID,
+                           TimerCallbackFunction_t pxCallbackFunction);
+
+TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
+                                 const TickType_t xTimerPeriod,
+                                 const UBaseType_t uxAutoReload,
+                                 void * const pvTimerID,
+                                 TimerCallbackFunction_t pxCallbackFunction,
+                                 StaticTimer_t *pxTimerBuffer);
+
+BaseType_t xTimerDelete(TimerHandle_t xTimer, TickType_t xBlockTime);
+
+BaseType_t xTimerIsTimerActive(TimerHandle_t xTimer);
+
+BaseType_t xTimerStart(TimerHandle_t xTimer,
+                       TickType_t xBlockTime);
+
+BaseType_t xTimerStop(TimerHandle_t xTimer,
+                      TickType_t xBlockTime);
+
+BaseType_t xTimerChangePeriod(TimerHandle_t xTimer,
+                              TickType_t xNewPeriod,
+                              TickType_t xBlockTime);
+
+BaseType_t xTimerReset(TimerHandle_t xTimer,
+                       TickType_t xBlockTime);
+
+BaseType_t xTimerStartFromISR(TimerHandle_t xTimer,
+                              BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xTimerStopFromISR(TimerHandle_t xTimer,
+                             BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xTimerChangePeriodFromISR(TimerHandle_t xTimer,
+                                     TickType_t xNewPeriod,
+                                     BaseType_t *pxHigherPriorityTaskWoken);
+
+BaseType_t xTimerResetFromISR(TimerHandle_t xTimer,
+                              BaseType_t *pxHigherPriorityTaskWoken);
+
+void *pvTimerGetTimerID(TimerHandle_t xTimer);
+
+void vTimerSetTimerID(TimerHandle_t xTimer, void *pvNewID);
+
+void vTimerSetReloadMode(TimerHandle_t xTimer,
+                         const UBaseType_t uxAutoReload);
+
+const char * pcTimerGetName(TimerHandle_t xTimer);
+
+TickType_t xTimerGetPeriod(TimerHandle_t xTimer);
+
+TickType_t xTimerGetExpiryTime(TimerHandle_t xTimer);
+
+UBaseType_t uxTimerGetReloadMode(TimerHandle_t xTimer);
+
+////
+// Queue set API.
+
+QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength);
+
+BaseType_t xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore,
+                          QueueSetHandle_t xQueueSet);
+
+BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore,
+                               QueueSetHandle_t xQueueSet);
+
+QueueSetMemberHandle_t xQueueSelectFromSet(QueueSetHandle_t xQueueSet,
+                                           const TickType_t xTicksToWait);
+
+QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet);
+
+#endif /* FREERTOS_H */