epagris/FreeRTOS-Kernel
1
0
Fork 1
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-11-04 11:09:01 +01:00
Code Issues Packages Projects Releases Wiki Activity
FreeRTOS-Kernel/portable/Common/mpu_wrappers_v2.c
Caleb Perkinson f69b1db45c
Add Stream Batching Buffer (#916) 
The difference between a stream buffer and a stream batching buffer is when
a task performs read on a non-empty buffer:
- The task reading from a non-empty stream buffer returns immediately
   regardless of the amount of data in the buffer.
- The task reading from a non-empty steam batching buffer blocks until the
   amount of data in the buffer exceeds the trigger level or the block time
   expires.
2024-04-17 20:24:00 +05:30

5268 lines
217 KiB
C
Raw Blame History

/*
* FreeRTOS Kernel <DEVELOPMENT BRANCH>
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* https://www.FreeRTOS.org
* https://github.com/FreeRTOS
*
*/
/*
* Implementation of the wrapper functions used to raise the processor privilege
* before calling a standard FreeRTOS API function.
*/
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
* all the API functions to use the MPU wrappers. That should only be done when
* task.h is included from an application file. */
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"
#include "event_groups.h"
#include "stream_buffer.h"
#include "mpu_prototypes.h"
#include "mpu_syscall_numbers.h"
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
/*-----------------------------------------------------------*/
#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
#ifndef configPROTECTED_KERNEL_OBJECT_POOL_SIZE
#error configPROTECTED_KERNEL_OBJECT_POOL_SIZE must be defined to maximum number of kernel objects in the application.
#endif
/**
* @brief Offset added to the index before returning to the user.
*
* If the actual handle is stored at index i, ( i + INDEX_OFFSET )
* is returned to the user.
*/
#define INDEX_OFFSET 1
/**
* @brief Opaque type for a kernel object.
*/
struct OpaqueObject;
typedef struct OpaqueObject * OpaqueObjectHandle_t;
/**
* @brief Defines kernel object in the kernel object pool.
*/
typedef struct KernelObject
{
OpaqueObjectHandle_t xInternalObjectHandle;
uint32_t ulKernelObjectType;
void * pvKernelObjectData;
} KernelObject_t;
/**
* @brief Kernel object types.
*/
#define KERNEL_OBJECT_TYPE_INVALID ( 0UL )
#define KERNEL_OBJECT_TYPE_QUEUE ( 1UL )
#define KERNEL_OBJECT_TYPE_TASK ( 2UL )
#define KERNEL_OBJECT_TYPE_STREAM_BUFFER ( 3UL )
#define KERNEL_OBJECT_TYPE_EVENT_GROUP ( 4UL )
#define KERNEL_OBJECT_TYPE_TIMER ( 5UL )
/**
* @brief Checks whether an external index is valid or not.
*/
#define IS_EXTERNAL_INDEX_VALID( lIndex ) \
( ( ( ( lIndex ) >= INDEX_OFFSET ) && \
( ( lIndex ) < ( configPROTECTED_KERNEL_OBJECT_POOL_SIZE + INDEX_OFFSET ) ) ) ? pdTRUE : pdFALSE )
/**
* @brief Checks whether an internal index is valid or not.
*/
#define IS_INTERNAL_INDEX_VALID( lIndex ) \
( ( ( ( lIndex ) >= 0 ) && \
( ( lIndex ) < ( configPROTECTED_KERNEL_OBJECT_POOL_SIZE ) ) ) ? pdTRUE : pdFALSE )
/**
* @brief Converts an internal index into external.
*/
#define CONVERT_TO_EXTERNAL_INDEX( lIndex ) ( ( lIndex ) + INDEX_OFFSET )
/**
* @brief Converts an external index into internal.
*/
#define CONVERT_TO_INTERNAL_INDEX( lIndex ) ( ( lIndex ) - INDEX_OFFSET )
/**
* @brief Max value that fits in a uint32_t type.
*/
#define mpuUINT32_MAX ( ~( ( uint32_t ) 0 ) )
/**
* @brief Check if multiplying a and b will result in overflow.
*/
#define mpuMULTIPLY_UINT32_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( mpuUINT32_MAX / ( a ) ) ) )
/**
* @brief Get the index of a free slot in the kernel object pool.
*
* If a free slot is found, this function marks the slot as
* "not free".
*
* @return Index of a free slot is returned, if a free slot is
* found. Otherwise -1 is returned.
*/
static int32_t MPU_GetFreeIndexInKernelObjectPool( void ) PRIVILEGED_FUNCTION;
/**
* @brief Set the given index as free in the kernel object pool.
*
* @param lIndex The index to set as free.
*/
static void MPU_SetIndexFreeInKernelObjectPool( int32_t lIndex ) PRIVILEGED_FUNCTION;
/**
* @brief Get the index at which a given kernel object is stored.
*
* @param xHandle The given kernel object handle.
* @param ulKernelObjectType The kernel object type.
*
* @return Index at which the kernel object is stored if it is a valid
* handle, -1 otherwise.
*/
static int32_t MPU_GetIndexForHandle( OpaqueObjectHandle_t xHandle,
uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
/**
* @brief Store the given kernel object handle at the given index in
* the kernel object pool.
*
* @param lIndex Index to store the given handle at.
* @param xHandle Kernel object handle to store.
* @param pvKernelObjectData The data associated with the kernel object.
* Currently, only used for timer objects to store timer callback.
* @param ulKernelObjectType The kernel object type.
*/
static void MPU_StoreHandleAndDataAtIndex( int32_t lIndex,
OpaqueObjectHandle_t xHandle,
void * pvKernelObjectData,
uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
/**
* @brief Get the kernel object handle at the given index from
* the kernel object pool.
*
* @param lIndex Index at which to get the kernel object handle.
* @param ulKernelObjectType The kernel object type.
*
* @return The kernel object handle at the index.
*/
static OpaqueObjectHandle_t MPU_GetHandleAtIndex( int32_t lIndex,
uint32_t ulKernelObjectType ) PRIVILEGED_FUNCTION;
#if ( configUSE_TIMERS == 1 )
/**
* @brief The function registered as callback for all the timers.
*
* We intercept all the timer callbacks so that we can call application
* callbacks with opaque handle.
*
* @param xInternalHandle The internal timer handle.
*/
static void MPU_TimerCallback( TimerHandle_t xInternalHandle ) PRIVILEGED_FUNCTION;
#endif /* #if ( configUSE_TIMERS == 1 ) */
/*
* Wrappers to keep all the casting in one place.
*/
#define MPU_StoreQueueHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), NULL, KERNEL_OBJECT_TYPE_QUEUE )
#define MPU_GetQueueHandleAtIndex( lIndex ) ( QueueHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_QUEUE )
#if ( configUSE_QUEUE_SETS == 1 )
#define MPU_StoreQueueSetHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), NULL, KERNEL_OBJECT_TYPE_QUEUE )
#define MPU_GetQueueSetHandleAtIndex( lIndex ) ( QueueSetHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_QUEUE )
#define MPU_StoreQueueSetMemberHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), NULL, KERNEL_OBJECT_TYPE_QUEUE )
#define MPU_GetQueueSetMemberHandleAtIndex( lIndex ) ( QueueSetMemberHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_QUEUE )
#define MPU_GetIndexForQueueSetMemberHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) ( xHandle ), KERNEL_OBJECT_TYPE_QUEUE )
#endif
/*
* Wrappers to keep all the casting in one place for Task APIs.
*/
#define MPU_StoreTaskHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), NULL, KERNEL_OBJECT_TYPE_TASK )
#define MPU_GetTaskHandleAtIndex( lIndex ) ( TaskHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_TASK )
#define MPU_GetIndexForTaskHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) ( xHandle ), KERNEL_OBJECT_TYPE_TASK )
#if ( configUSE_EVENT_GROUPS == 1 )
/*
* Wrappers to keep all the casting in one place for Event Group APIs.
*/
#define MPU_StoreEventGroupHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), NULL, KERNEL_OBJECT_TYPE_EVENT_GROUP )
#define MPU_GetEventGroupHandleAtIndex( lIndex ) ( EventGroupHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_EVENT_GROUP )
#define MPU_GetIndexForEventGroupHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) ( xHandle ), KERNEL_OBJECT_TYPE_EVENT_GROUP )
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
#if ( configUSE_STREAM_BUFFERS == 1 )
/*
* Wrappers to keep all the casting in one place for Stream Buffer APIs.
*/
#define MPU_StoreStreamBufferHandleAtIndex( lIndex, xHandle ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle), NULL, KERNEL_OBJECT_TYPE_STREAM_BUFFER )
#define MPU_GetStreamBufferHandleAtIndex( lIndex ) ( StreamBufferHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_STREAM_BUFFER )
#define MPU_GetIndexForStreamBufferHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) ( xHandle ), KERNEL_OBJECT_TYPE_STREAM_BUFFER )
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
#if ( configUSE_TIMERS == 1 )
/*
* Wrappers to keep all the casting in one place for Timer APIs.
*/
#define MPU_StoreTimerHandleAtIndex( lIndex, xHandle, pxApplicationCallback ) MPU_StoreHandleAndDataAtIndex( ( lIndex ), ( OpaqueObjectHandle_t ) ( xHandle ), ( void * ) ( pxApplicationCallback ), KERNEL_OBJECT_TYPE_TIMER )
#define MPU_GetTimerHandleAtIndex( lIndex ) ( TimerHandle_t ) MPU_GetHandleAtIndex( ( lIndex ), KERNEL_OBJECT_TYPE_TIMER )
#define MPU_GetIndexForTimerHandle( xHandle ) MPU_GetIndexForHandle( ( OpaqueObjectHandle_t ) ( xHandle ), KERNEL_OBJECT_TYPE_TIMER )
#endif /* #if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
/**
* @brief Kernel object pool.
*/
PRIVILEGED_DATA static KernelObject_t xKernelObjectPool[ configPROTECTED_KERNEL_OBJECT_POOL_SIZE ] = { 0 };
/*-----------------------------------------------------------*/
static int32_t MPU_GetFreeIndexInKernelObjectPool( void ) /* PRIVILEGED_FUNCTION */
{
int32_t i, lFreeIndex = -1;
/* This function is called only from resource create APIs
* which are not supposed to be called from ISRs. Therefore,
* we only need to suspend the scheduler and do not require
* critical section. */
vTaskSuspendAll();
{
for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
{
if( xKernelObjectPool[ i ].xInternalObjectHandle == NULL )
{
/* Mark this index as not free. */
xKernelObjectPool[ i ].xInternalObjectHandle = ( OpaqueObjectHandle_t ) ( ~0U );
lFreeIndex = i;
break;
}
}
}
( void ) xTaskResumeAll();
return lFreeIndex;
}
/*-----------------------------------------------------------*/
static void MPU_SetIndexFreeInKernelObjectPool( int32_t lIndex ) /* PRIVILEGED_FUNCTION */
{
configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
taskENTER_CRITICAL();
{
xKernelObjectPool[ lIndex ].xInternalObjectHandle = NULL;
xKernelObjectPool[ lIndex ].ulKernelObjectType = KERNEL_OBJECT_TYPE_INVALID;
xKernelObjectPool[ lIndex ].pvKernelObjectData = NULL;
}
taskEXIT_CRITICAL();
}
/*-----------------------------------------------------------*/
static int32_t MPU_GetIndexForHandle( OpaqueObjectHandle_t xHandle,
uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
{
int32_t i, lIndex = -1;
configASSERT( xHandle != NULL );
for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
{
if( ( xKernelObjectPool[ i ].xInternalObjectHandle == xHandle ) &&
( xKernelObjectPool[ i ].ulKernelObjectType == ulKernelObjectType ) )
{
lIndex = i;
break;
}
}
return lIndex;
}
/*-----------------------------------------------------------*/
static void MPU_StoreHandleAndDataAtIndex( int32_t lIndex,
OpaqueObjectHandle_t xHandle,
void * pvKernelObjectData,
uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
{
configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
xKernelObjectPool[ lIndex ].xInternalObjectHandle = xHandle;
xKernelObjectPool[ lIndex ].ulKernelObjectType = ulKernelObjectType;
xKernelObjectPool[ lIndex ].pvKernelObjectData = pvKernelObjectData;
}
/*-----------------------------------------------------------*/
static OpaqueObjectHandle_t MPU_GetHandleAtIndex( int32_t lIndex,
uint32_t ulKernelObjectType ) /* PRIVILEGED_FUNCTION */
{
OpaqueObjectHandle_t xObjectHandle = NULL;
configASSERT( IS_INTERNAL_INDEX_VALID( lIndex ) != pdFALSE );
if( xKernelObjectPool[ lIndex ].ulKernelObjectType == ulKernelObjectType )
{
xObjectHandle = xKernelObjectPool[ lIndex ].xInternalObjectHandle;
}
return xObjectHandle;
}
/*-----------------------------------------------------------*/
#if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
void vGrantAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
int32_t lExternalKernelObjectHandle ) /* PRIVILEGED_FUNCTION */
{
int32_t lExternalTaskIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( IS_EXTERNAL_INDEX_VALID( lExternalKernelObjectHandle ) != pdFALSE )
{
if( xExternalTaskHandle == NULL )
{
vPortGrantAccessToKernelObject( xExternalTaskHandle, CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
}
else
{
lExternalTaskIndex = ( int32_t ) xExternalTaskHandle;
if( IS_EXTERNAL_INDEX_VALID( lExternalTaskIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lExternalTaskIndex ) );
if( xInternalTaskHandle != NULL )
{
vPortGrantAccessToKernelObject( xInternalTaskHandle,
CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
}
}
}
}
}
#endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
/*-----------------------------------------------------------*/
#if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
void vRevokeAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
int32_t lExternalKernelObjectHandle ) /* PRIVILEGED_FUNCTION */
{
int32_t lExternalTaskIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( IS_EXTERNAL_INDEX_VALID( lExternalKernelObjectHandle ) != pdFALSE )
{
if( xExternalTaskHandle == NULL )
{
vPortRevokeAccessToKernelObject( xExternalTaskHandle, CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
}
else
{
lExternalTaskIndex = ( int32_t ) xExternalTaskHandle;
if( IS_EXTERNAL_INDEX_VALID( lExternalTaskIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lExternalTaskIndex ) );
if( xInternalTaskHandle != NULL )
{
vPortRevokeAccessToKernelObject( xInternalTaskHandle,
CONVERT_TO_INTERNAL_INDEX( lExternalKernelObjectHandle ) );
}
}
}
}
}
#endif /* #if ( configENABLE_ACCESS_CONTROL_LIST == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
static void MPU_TimerCallback( TimerHandle_t xInternalHandle ) /* PRIVILEGED_FUNCTION */
{
int32_t i, lIndex = -1;
TimerHandle_t xExternalHandle = NULL;
TimerCallbackFunction_t pxApplicationCallBack = NULL;
/* Coming from the timer task and therefore, should be valid. */
configASSERT( xInternalHandle != NULL );
for( i = 0; i < configPROTECTED_KERNEL_OBJECT_POOL_SIZE; i++ )
{
if( ( ( TimerHandle_t ) xKernelObjectPool[ i ].xInternalObjectHandle == xInternalHandle ) &&
( xKernelObjectPool[ i ].ulKernelObjectType == KERNEL_OBJECT_TYPE_TIMER ) )
{
lIndex = i;
break;
}
}
configASSERT( lIndex != -1 );
xExternalHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
pxApplicationCallBack = ( TimerCallbackFunction_t ) xKernelObjectPool[ lIndex ].pvKernelObjectData;
pxApplicationCallBack( xExternalHandle );
}
#endif /* #if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
/*-----------------------------------------------------------*/
/* MPU wrappers for tasks APIs. */
/*-----------------------------------------------------------*/
#if ( INCLUDE_xTaskDelayUntil == 1 )
BaseType_t MPU_xTaskDelayUntilImpl( TickType_t * const pxPreviousWakeTime,
TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskDelayUntilImpl( TickType_t * const pxPreviousWakeTime,
TickType_t xTimeIncrement ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
BaseType_t xIsPreviousWakeTimeAccessible = pdFALSE;
if( ( pxPreviousWakeTime != NULL ) && ( xTimeIncrement > 0U ) )
{
xIsPreviousWakeTimeAccessible = xPortIsAuthorizedToAccessBuffer( pxPreviousWakeTime,
sizeof( TickType_t ),
( tskMPU_WRITE_PERMISSION | tskMPU_READ_PERMISSION ) );
if( xIsPreviousWakeTimeAccessible == pdTRUE )
{
xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
}
}
return xReturn;
}
#endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_xTaskAbortDelay == 1 )
BaseType_t MPU_xTaskAbortDelayImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskAbortDelayImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskAbortDelay( xInternalTaskHandle );
}
}
}
return xReturn;
}
#endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_vTaskDelay == 1 )
void MPU_vTaskDelayImpl( TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
void MPU_vTaskDelayImpl( TickType_t xTicksToDelay ) /* PRIVILEGED_FUNCTION */
{
vTaskDelay( xTicksToDelay );
}
#endif /* if ( INCLUDE_vTaskDelay == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_uxTaskPriorityGet == 1 )
UBaseType_t MPU_uxTaskPriorityGetImpl( const TaskHandle_t pxTask ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxTaskPriorityGetImpl( const TaskHandle_t pxTask ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = configMAX_PRIORITIES;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( pxTask == NULL )
{
uxReturn = uxTaskPriorityGet( pxTask );
}
else
{
lIndex = ( int32_t ) pxTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskPriorityGet( xInternalTaskHandle );
}
}
}
}
return uxReturn;
}
#endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_eTaskGetState == 1 )
eTaskState MPU_eTaskGetStateImpl( TaskHandle_t pxTask ) PRIVILEGED_FUNCTION;
eTaskState MPU_eTaskGetStateImpl( TaskHandle_t pxTask ) /* PRIVILEGED_FUNCTION */
{
eTaskState eReturn = eInvalid;
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
lIndex = ( int32_t ) pxTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
eReturn = eTaskGetState( xInternalTaskHandle );
}
}
}
return eReturn;
}
#endif /* if ( INCLUDE_eTaskGetState == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TRACE_FACILITY == 1 )
void MPU_vTaskGetInfoImpl( TaskHandle_t xTask,
TaskStatus_t * pxTaskStatus,
BaseType_t xGetFreeStackSpace,
eTaskState eState ) PRIVILEGED_FUNCTION;
void MPU_vTaskGetInfoImpl( TaskHandle_t xTask,
TaskStatus_t * pxTaskStatus,
BaseType_t xGetFreeStackSpace,
eTaskState eState ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xIsTaskStatusWriteable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
xIsTaskStatusWriteable = xPortIsAuthorizedToAccessBuffer( pxTaskStatus,
sizeof( TaskStatus_t ),
tskMPU_WRITE_PERMISSION );
if( xIsTaskStatusWriteable == pdTRUE )
{
if( xTask == NULL )
{
vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskGetInfo( xInternalTaskHandle, pxTaskStatus, xGetFreeStackSpace, eState );
}
}
}
}
}
}
#endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
TaskHandle_t MPU_xTaskGetIdleTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
TaskHandle_t MPU_xTaskGetIdleTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xIdleTaskHandle = NULL;
xIdleTaskHandle = xTaskGetIdleTaskHandle();
return xIdleTaskHandle;
}
#endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_vTaskSuspend == 1 )
void MPU_vTaskSuspendImpl( TaskHandle_t pxTaskToSuspend ) PRIVILEGED_FUNCTION;
void MPU_vTaskSuspendImpl( TaskHandle_t pxTaskToSuspend ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( pxTaskToSuspend == NULL )
{
vTaskSuspend( pxTaskToSuspend );
}
else
{
/* After the scheduler starts, only privileged tasks are allowed
* to suspend other tasks. */
#if ( INCLUDE_xTaskGetSchedulerState == 1 )
if( ( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED ) || ( portIS_TASK_PRIVILEGED() == pdTRUE ) )
#else
if( portIS_TASK_PRIVILEGED() == pdTRUE )
#endif
{
lIndex = ( int32_t ) pxTaskToSuspend;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskSuspend( xInternalTaskHandle );
}
}
}
}
}
}
#endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_vTaskSuspend == 1 )
void MPU_vTaskResumeImpl( TaskHandle_t pxTaskToResume ) PRIVILEGED_FUNCTION;
void MPU_vTaskResumeImpl( TaskHandle_t pxTaskToResume ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
lIndex = ( int32_t ) pxTaskToResume;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskResume( xInternalTaskHandle );
}
}
}
}
#endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
/*-----------------------------------------------------------*/
TickType_t MPU_xTaskGetTickCountImpl( void ) PRIVILEGED_FUNCTION;
TickType_t MPU_xTaskGetTickCountImpl( void ) /* PRIVILEGED_FUNCTION */
{
TickType_t xReturn;
xReturn = xTaskGetTickCount();
return xReturn;
}
/*-----------------------------------------------------------*/
UBaseType_t MPU_uxTaskGetNumberOfTasksImpl( void ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxTaskGetNumberOfTasksImpl( void ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn;
uxReturn = uxTaskGetNumberOfTasks();
return uxReturn;
}
/*-----------------------------------------------------------*/
#if ( configGENERATE_RUN_TIME_STATS == 1 )
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounterImpl( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounterImpl( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
configRUN_TIME_COUNTER_TYPE xReturn = 0;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
xReturn = ulTaskGetRunTimeCounter( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = ulTaskGetRunTimeCounter( xInternalTaskHandle );
}
}
}
}
return xReturn;
}
#endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configGENERATE_RUN_TIME_STATS == 1 )
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercentImpl( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercentImpl( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
configRUN_TIME_COUNTER_TYPE xReturn = 0;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
xReturn = ulTaskGetRunTimePercent( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = ulTaskGetRunTimePercent( xInternalTaskHandle );
}
}
}
}
return xReturn;
}
#endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercentImpl( void ) PRIVILEGED_FUNCTION;
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercentImpl( void ) /* PRIVILEGED_FUNCTION */
{
configRUN_TIME_COUNTER_TYPE xReturn;
xReturn = ulTaskGetIdleRunTimePercent();
return xReturn;
}
#endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounterImpl( void ) PRIVILEGED_FUNCTION;
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounterImpl( void ) /* PRIVILEGED_FUNCTION */
{
configRUN_TIME_COUNTER_TYPE xReturn;
xReturn = ulTaskGetIdleRunTimeCounter();
return xReturn;
}
#endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_APPLICATION_TASK_TAG == 1 )
void MPU_vTaskSetApplicationTaskTagImpl( TaskHandle_t xTask,
TaskHookFunction_t pxTagValue ) PRIVILEGED_FUNCTION;
void MPU_vTaskSetApplicationTaskTagImpl( TaskHandle_t xTask,
TaskHookFunction_t pxTagValue ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
vTaskSetApplicationTaskTag( xTask, pxTagValue );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskSetApplicationTaskTag( xInternalTaskHandle, pxTagValue );
}
}
}
}
}
#endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_APPLICATION_TASK_TAG == 1 )
TaskHookFunction_t MPU_xTaskGetApplicationTaskTagImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
TaskHookFunction_t MPU_xTaskGetApplicationTaskTagImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
TaskHookFunction_t xReturn = NULL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
xReturn = xTaskGetApplicationTaskTag( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGetApplicationTaskTag( xInternalTaskHandle );
}
}
}
}
return xReturn;
}
#endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
/*-----------------------------------------------------------*/
#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
void MPU_vTaskSetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToSet,
BaseType_t xIndex,
void * pvValue ) PRIVILEGED_FUNCTION;
void MPU_vTaskSetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToSet,
BaseType_t xIndex,
void * pvValue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTaskToSet == NULL )
{
vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
}
else
{
lIndex = ( int32_t ) xTaskToSet;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskSetThreadLocalStoragePointer( xInternalTaskHandle, xIndex, pvValue );
}
}
}
}
}
#endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
/*-----------------------------------------------------------*/
#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
void * MPU_pvTaskGetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToQuery,
BaseType_t xIndex ) PRIVILEGED_FUNCTION;
void * MPU_pvTaskGetThreadLocalStoragePointerImpl( TaskHandle_t xTaskToQuery,
BaseType_t xIndex ) /* PRIVILEGED_FUNCTION */
{
void * pvReturn = NULL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTaskToQuery == NULL )
{
pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
}
else
{
lIndex = ( int32_t ) xTaskToQuery;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
pvReturn = pvTaskGetThreadLocalStoragePointer( xInternalTaskHandle, xIndex );
}
}
}
}
return pvReturn;
}
#endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TRACE_FACILITY == 1 )
UBaseType_t MPU_uxTaskGetSystemStateImpl( TaskStatus_t * pxTaskStatusArray,
UBaseType_t uxArraySize,
configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxTaskGetSystemStateImpl( TaskStatus_t * pxTaskStatusArray,
UBaseType_t uxArraySize,
configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = 0;
UBaseType_t xIsTaskStatusArrayWriteable = pdFALSE;
UBaseType_t xIsTotalRunTimeWriteable = pdFALSE;
uint32_t ulArraySize = ( uint32_t ) uxArraySize;
uint32_t ulTaskStatusSize = ( uint32_t ) sizeof( TaskStatus_t );
if( mpuMULTIPLY_UINT32_WILL_OVERFLOW( ulTaskStatusSize, ulArraySize ) == 0 )
{
xIsTaskStatusArrayWriteable = xPortIsAuthorizedToAccessBuffer( pxTaskStatusArray,
ulTaskStatusSize * ulArraySize,
tskMPU_WRITE_PERMISSION );
if( pulTotalRunTime != NULL )
{
xIsTotalRunTimeWriteable = xPortIsAuthorizedToAccessBuffer( pulTotalRunTime,
sizeof( configRUN_TIME_COUNTER_TYPE ),
tskMPU_WRITE_PERMISSION );
}
if( ( xIsTaskStatusArrayWriteable == pdTRUE ) &&
( ( pulTotalRunTime == NULL ) || ( xIsTotalRunTimeWriteable == pdTRUE ) ) )
{
uxReturn = uxTaskGetSystemState( pxTaskStatusArray, ( UBaseType_t ) ulArraySize, pulTotalRunTime );
}
}
return uxReturn;
}
#endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
UBaseType_t MPU_uxTaskGetStackHighWaterMarkImpl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxTaskGetStackHighWaterMarkImpl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = 0;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
uxReturn = uxTaskGetStackHighWaterMark( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskGetStackHighWaterMark( xInternalTaskHandle );
}
}
}
}
return uxReturn;
}
#endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2Impl( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2Impl( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
configSTACK_DEPTH_TYPE uxReturn = 0;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( xTask == NULL )
{
uxReturn = uxTaskGetStackHighWaterMark2( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskGetStackHighWaterMark2( xInternalTaskHandle );
}
}
}
}
return uxReturn;
}
#endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
TaskHandle_t MPU_xTaskGetCurrentTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
TaskHandle_t MPU_xTaskGetCurrentTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
TaskHandle_t xExternalTaskHandle = NULL;
int32_t lIndex;
xInternalTaskHandle = xTaskGetCurrentTaskHandle();
if( xInternalTaskHandle != NULL )
{
lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
if( lIndex != -1 )
{
xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
}
return xExternalTaskHandle;
}
#endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_xTaskGetSchedulerState == 1 )
BaseType_t MPU_xTaskGetSchedulerStateImpl( void ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskGetSchedulerStateImpl( void ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = taskSCHEDULER_NOT_STARTED;
xReturn = xTaskGetSchedulerState();
return xReturn;
}
#endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
/*-----------------------------------------------------------*/
void MPU_vTaskSetTimeOutStateImpl( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
void MPU_vTaskSetTimeOutStateImpl( TimeOut_t * const pxTimeOut ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xIsTimeOutWriteable = pdFALSE;
if( pxTimeOut != NULL )
{
xIsTimeOutWriteable = xPortIsAuthorizedToAccessBuffer( pxTimeOut,
sizeof( TimeOut_t ),
tskMPU_WRITE_PERMISSION );
if( xIsTimeOutWriteable == pdTRUE )
{
vTaskSetTimeOutState( pxTimeOut );
}
}
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xTaskCheckForTimeOutImpl( TimeOut_t * const pxTimeOut,
TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskCheckForTimeOutImpl( TimeOut_t * const pxTimeOut,
TickType_t * const pxTicksToWait ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
BaseType_t xIsTimeOutWriteable = pdFALSE;
BaseType_t xIsTicksToWaitWriteable = pdFALSE;
if( ( pxTimeOut != NULL ) && ( pxTicksToWait != NULL ) )
{
xIsTimeOutWriteable = xPortIsAuthorizedToAccessBuffer( pxTimeOut,
sizeof( TimeOut_t ),
tskMPU_WRITE_PERMISSION );
xIsTicksToWaitWriteable = xPortIsAuthorizedToAccessBuffer( pxTicksToWait,
sizeof( TickType_t ),
tskMPU_WRITE_PERMISSION );
if( ( xIsTimeOutWriteable == pdTRUE ) && ( xIsTicksToWaitWriteable == pdTRUE ) )
{
xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
UBaseType_t uxIndexToNotify,
uint32_t ulValue,
eNotifyAction eAction,
uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
{
BaseType_t xReturn = pdFAIL;
xTaskGenericNotifyParams_t xParams;
xParams.xTaskToNotify = xTaskToNotify;
xParams.uxIndexToNotify = uxIndexToNotify;
xParams.ulValue = ulValue;
xParams.eAction = eAction;
xParams.pulPreviousNotificationValue = pulPreviousNotificationValue;
xReturn = MPU_xTaskGenericNotifyEntry( &( xParams ) );
return xReturn;
}
BaseType_t MPU_xTaskGenericNotifyImpl( const xTaskGenericNotifyParams_t * pxParams ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskGenericNotifyImpl( const xTaskGenericNotifyParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xIsPreviousNotificationValueWriteable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
BaseType_t xAreParamsReadable = pdFALSE;
if( pxParams != NULL )
{
xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
sizeof( xTaskGenericNotifyParams_t ),
tskMPU_READ_PERMISSION );
}
if( xAreParamsReadable == pdTRUE )
{
if( ( pxParams->uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES ) &&
( ( pxParams->eAction == eNoAction ) ||
( pxParams->eAction == eSetBits ) ||
( pxParams->eAction == eIncrement ) ||
( pxParams->eAction == eSetValueWithOverwrite ) ||
( pxParams->eAction == eSetValueWithoutOverwrite ) ) )
{
if( pxParams->pulPreviousNotificationValue != NULL )
{
xIsPreviousNotificationValueWriteable = xPortIsAuthorizedToAccessBuffer( pxParams->pulPreviousNotificationValue,
sizeof( uint32_t ),
tskMPU_WRITE_PERMISSION );
}
if( ( pxParams->pulPreviousNotificationValue == NULL ) ||
( xIsPreviousNotificationValueWriteable == pdTRUE ) )
{
lIndex = ( int32_t ) ( pxParams->xTaskToNotify );
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGenericNotify( xInternalTaskHandle,
pxParams->uxIndexToNotify,
pxParams->ulValue,
pxParams->eAction,
pxParams->pulPreviousNotificationValue );
}
}
}
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
uint32_t ulBitsToClearOnEntry,
uint32_t ulBitsToClearOnExit,
uint32_t * pulNotificationValue,
TickType_t xTicksToWait )
{
BaseType_t xReturn = pdFAIL;
xTaskGenericNotifyWaitParams_t xParams;
xParams.uxIndexToWaitOn = uxIndexToWaitOn;
xParams.ulBitsToClearOnEntry = ulBitsToClearOnEntry;
xParams.ulBitsToClearOnExit = ulBitsToClearOnExit;
xParams.pulNotificationValue = pulNotificationValue;
xParams.xTicksToWait = xTicksToWait;
xReturn = MPU_xTaskGenericNotifyWaitEntry( &( xParams ) );
return xReturn;
}
BaseType_t MPU_xTaskGenericNotifyWaitImpl( const xTaskGenericNotifyWaitParams_t * pxParams ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskGenericNotifyWaitImpl( const xTaskGenericNotifyWaitParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
BaseType_t xIsNotificationValueWritable = pdFALSE;
BaseType_t xAreParamsReadable = pdFALSE;
if( pxParams != NULL )
{
xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
sizeof( xTaskGenericNotifyWaitParams_t ),
tskMPU_READ_PERMISSION );
}
if( xAreParamsReadable == pdTRUE )
{
if( pxParams->uxIndexToWaitOn < configTASK_NOTIFICATION_ARRAY_ENTRIES )
{
if( pxParams->pulNotificationValue != NULL )
{
xIsNotificationValueWritable = xPortIsAuthorizedToAccessBuffer( pxParams->pulNotificationValue,
sizeof( uint32_t ),
tskMPU_WRITE_PERMISSION );
}
if( ( pxParams->pulNotificationValue == NULL ) ||
( xIsNotificationValueWritable == pdTRUE ) )
{
xReturn = xTaskGenericNotifyWait( pxParams->uxIndexToWaitOn,
pxParams->ulBitsToClearOnEntry,
pxParams->ulBitsToClearOnExit,
pxParams->pulNotificationValue,
pxParams->xTicksToWait );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
uint32_t MPU_ulTaskGenericNotifyTakeImpl( UBaseType_t uxIndexToWaitOn,
BaseType_t xClearCountOnExit,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
uint32_t MPU_ulTaskGenericNotifyTakeImpl( UBaseType_t uxIndexToWaitOn,
BaseType_t xClearCountOnExit,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
uint32_t ulReturn = 0;
if( uxIndexToWaitOn < configTASK_NOTIFICATION_ARRAY_ENTRIES )
{
ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
}
return ulReturn;
}
#endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t MPU_xTaskGenericNotifyStateClearImpl( TaskHandle_t xTask,
UBaseType_t uxIndexToClear ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTaskGenericNotifyStateClearImpl( TaskHandle_t xTask,
UBaseType_t uxIndexToClear ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( uxIndexToClear < configTASK_NOTIFICATION_ARRAY_ENTRIES )
{
if( xTask == NULL )
{
xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGenericNotifyStateClear( xInternalTaskHandle, uxIndexToClear );
}
}
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
uint32_t MPU_ulTaskGenericNotifyValueClearImpl( TaskHandle_t xTask,
UBaseType_t uxIndexToClear,
uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
uint32_t MPU_ulTaskGenericNotifyValueClearImpl( TaskHandle_t xTask,
UBaseType_t uxIndexToClear,
uint32_t ulBitsToClear ) /* PRIVILEGED_FUNCTION */
{
uint32_t ulReturn = 0;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessTask = pdFALSE;
if( uxIndexToClear < configTASK_NOTIFICATION_ARRAY_ENTRIES )
{
if( xTask == NULL )
{
ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTask = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTask == pdTRUE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
ulReturn = ulTaskGenericNotifyValueClear( xInternalTaskHandle, uxIndexToClear, ulBitsToClear );
}
}
}
}
}
return ulReturn;
}
#endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*-----------------------------------------------------------*/
/* Privileged only wrappers for Task APIs. These are needed so that
* the application can use opaque handles maintained in mpu_wrappers.c
* with all the APIs. */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,
const char * const pcName,
const configSTACK_DEPTH_TYPE uxStackDepth,
void * pvParameters,
UBaseType_t uxPriority,
TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
/* xTaskCreate() can only be used to create privileged tasks in MPU port. */
if( ( uxPriority & portPRIVILEGE_BIT ) != 0 )
{
xReturn = xTaskCreate( pvTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, &( xInternalTaskHandle ) );
if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
{
MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
if( pxCreatedTask != NULL )
{
*pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
}
return xReturn;
}
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
const char * const pcName,
const configSTACK_DEPTH_TYPE uxStackDepth,
void * const pvParameters,
UBaseType_t uxPriority,
StackType_t * const puxStackBuffer,
StaticTask_t * const pxTaskBuffer ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xExternalTaskHandle = NULL;
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalTaskHandle = xTaskCreateStatic( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
if( xInternalTaskHandle != NULL )
{
MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
#if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
{
/* By default, an unprivileged task has access to itself. */
if( ( uxPriority & portPRIVILEGE_BIT ) == 0 )
{
vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
}
}
#endif
xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalTaskHandle;
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
/*-----------------------------------------------------------*/
#if ( INCLUDE_vTaskDelete == 1 )
void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
if( pxTaskToDelete == NULL )
{
xInternalTaskHandle = xTaskGetCurrentTaskHandle();
lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
if( lIndex != -1 )
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
vTaskDelete( xInternalTaskHandle );
}
else
{
lIndex = ( int32_t ) pxTaskToDelete;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
vTaskDelete( xInternalTaskHandle );
}
}
}
}
#endif /* #if ( INCLUDE_vTaskDelete == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_vTaskPrioritySet == 1 )
void MPU_vTaskPrioritySet( TaskHandle_t pxTask,
UBaseType_t uxNewPriority ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
if( pxTask == NULL )
{
vTaskPrioritySet( pxTask, uxNewPriority );
}
else
{
lIndex = ( int32_t ) pxTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskPrioritySet( xInternalTaskHandle, uxNewPriority );
}
}
}
}
#endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */
/*-----------------------------------------------------------*/
#if ( INCLUDE_xTaskGetHandle == 1 )
TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
TaskHandle_t xExternalTaskHandle = NULL;
int32_t lIndex;
xInternalTaskHandle = xTaskGetHandle( pcNameToQuery );
if( xInternalTaskHandle != NULL )
{
lIndex = MPU_GetIndexForTaskHandle( xInternalTaskHandle );
if( lIndex != -1 )
{
xExternalTaskHandle = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
}
return xExternalTaskHandle;
}
#endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_APPLICATION_TASK_TAG == 1 )
BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
void * pvParameter ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTask == NULL )
{
xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskCallApplicationTaskHook( xInternalTaskHandle, pvParameter );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xReturn = xTaskCreateRestricted( pxTaskDefinition, &( xInternalTaskHandle ) );
if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
{
MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
#if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
{
/* By default, an unprivileged task has access to itself. */
if( ( pxTaskDefinition->uxPriority & portPRIVILEGE_BIT ) == 0 )
{
vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
}
}
#endif
if( pxCreatedTask != NULL )
{
*pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xReturn;
}
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
TaskHandle_t * pxCreatedTask ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xReturn = xTaskCreateRestrictedStatic( pxTaskDefinition, &( xInternalTaskHandle ) );
if( ( xReturn == pdPASS ) && ( xInternalTaskHandle != NULL ) )
{
MPU_StoreTaskHandleAtIndex( lIndex, xInternalTaskHandle );
#if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
{
/* By default, an unprivileged task has access to itself. */
if( ( pxTaskDefinition->uxPriority & portPRIVILEGE_BIT ) == 0 )
{
vPortGrantAccessToKernelObject( xInternalTaskHandle, lIndex );
}
}
#endif
if( pxCreatedTask != NULL )
{
*pxCreatedTask = ( TaskHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xReturn;
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
/*-----------------------------------------------------------*/
void MPU_vTaskAllocateMPURegions( TaskHandle_t xTaskToModify,
const MemoryRegion_t * const xRegions ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
if( xTaskToModify == NULL )
{
vTaskAllocateMPURegions( xTaskToModify, xRegions );
}
else
{
lIndex = ( int32_t ) xTaskToModify;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskAllocateMPURegions( xInternalTaskHandle, xRegions );
}
}
}
}
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
BaseType_t MPU_xTaskGetStaticBuffers( TaskHandle_t xTask,
StackType_t ** ppuxStackBuffer,
StaticTask_t ** ppxTaskBuffer ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xInternalTaskHandle = NULL;
int32_t lIndex;
BaseType_t xReturn = pdFALSE;
if( xTask == NULL )
{
xInternalTaskHandle = xTaskGetCurrentTaskHandle();
xReturn = xTaskGetStaticBuffers( xInternalTaskHandle, ppuxStackBuffer, ppxTaskBuffer );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGetStaticBuffers( xInternalTaskHandle, ppuxStackBuffer, ppxTaskBuffer );
}
}
}
return xReturn;
}
#endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
/*-----------------------------------------------------------*/
char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* PRIVILEGED_FUNCTION */
{
char * pcReturn = NULL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTaskToQuery == NULL )
{
pcReturn = pcTaskGetName( xTaskToQuery );
}
else
{
lIndex = ( int32_t ) xTaskToQuery;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
pcReturn = pcTaskGetName( xInternalTaskHandle );
}
}
}
return pcReturn;
}
/*-----------------------------------------------------------*/
#if ( INCLUDE_uxTaskPriorityGet == 1 )
UBaseType_t MPU_uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = configMAX_PRIORITIES;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTask == NULL )
{
uxReturn = uxTaskPriorityGetFromISR( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskPriorityGetFromISR( xInternalTaskHandle );
}
}
}
return uxReturn;
}
#endif /* #if ( INCLUDE_uxTaskPriorityGet == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( INCLUDE_uxTaskPriorityGet == 1 ) && ( configUSE_MUTEXES == 1 ) )
UBaseType_t MPU_uxTaskBasePriorityGet( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = configMAX_PRIORITIES;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTask == NULL )
{
uxReturn = uxTaskBasePriorityGet( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskBasePriorityGet( xInternalTaskHandle );
}
}
}
return uxReturn;
}
#endif /* #if ( ( INCLUDE_uxTaskPriorityGet == 1 ) && ( configUSE_MUTEXES == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( INCLUDE_uxTaskPriorityGet == 1 ) && ( configUSE_MUTEXES == 1 ) )
UBaseType_t MPU_uxTaskBasePriorityGetFromISR( const TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = configMAX_PRIORITIES;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTask == NULL )
{
uxReturn = uxTaskBasePriorityGetFromISR( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
uxReturn = uxTaskBasePriorityGetFromISR( xInternalTaskHandle );
}
}
}
return uxReturn;
}
#endif /* #if ( ( INCLUDE_uxTaskPriorityGet == 1 ) && ( configUSE_MUTEXES == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
BaseType_t MPU_xTaskResumeFromISR( TaskHandle_t xTaskToResume ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = ( int32_t ) xTaskToResume;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskResumeFromISR( xInternalTaskHandle );
}
}
return xReturn;
}
#endif /* #if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )*/
/*---------------------------------------------------------------------------------------*/
#if ( configUSE_APPLICATION_TASK_TAG == 1 )
TaskHookFunction_t MPU_xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) /* PRIVILEGED_FUNCTION */
{
TaskHookFunction_t xReturn = NULL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
if( xTask == NULL )
{
xReturn = xTaskGetApplicationTaskTagFromISR( xTask );
}
else
{
lIndex = ( int32_t ) xTask;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGetApplicationTaskTagFromISR( xInternalTaskHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
/*---------------------------------------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t MPU_xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
UBaseType_t uxIndexToNotify,
uint32_t ulValue,
eNotifyAction eAction,
uint32_t * pulPreviousNotificationValue,
BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = ( int32_t ) xTaskToNotify;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
xReturn = xTaskGenericNotifyFromISR( xInternalTaskHandle, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
/*---------------------------------------------------------------------------------------*/
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
void MPU_vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
UBaseType_t uxIndexToNotify,
BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
TaskHandle_t xInternalTaskHandle = NULL;
lIndex = ( int32_t ) xTaskToNotify;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTaskHandle = MPU_GetTaskHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTaskHandle != NULL )
{
vTaskGenericNotifyGiveFromISR( xInternalTaskHandle, uxIndexToNotify, pxHigherPriorityTaskWoken );
}
}
}
#endif /*#if ( configUSE_TASK_NOTIFICATIONS == 1 )*/
/*-----------------------------------------------------------*/
/*-----------------------------------------------------------*/
/* MPU wrappers for queue APIs. */
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueGenericSendImpl( QueueHandle_t xQueue,
const void * const pvItemToQueue,
TickType_t xTicksToWait,
BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueGenericSendImpl( QueueHandle_t xQueue,
const void * const pvItemToQueue,
TickType_t xTicksToWait,
BaseType_t xCopyPosition ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFAIL;
BaseType_t xIsItemToQueueReadable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
UBaseType_t uxQueueItemSize, uxQueueLength;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
uxQueueLength = uxQueueGetQueueLength( xInternalQueueHandle );
if( ( !( ( pvItemToQueue == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) ) &&
( !( ( xCopyPosition == queueOVERWRITE ) && ( uxQueueLength != ( UBaseType_t ) 1U ) ) )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0U ) ) )
#endif
)
{
if( pvItemToQueue != NULL )
{
xIsItemToQueueReadable = xPortIsAuthorizedToAccessBuffer( pvItemToQueue,
uxQueueItemSize,
tskMPU_READ_PERMISSION );
}
if( ( pvItemToQueue == NULL ) || ( xIsItemToQueueReadable == pdTRUE ) )
{
xReturn = xQueueGenericSend( xInternalQueueHandle, pvItemToQueue, xTicksToWait, xCopyPosition );
}
}
}
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
UBaseType_t MPU_uxQueueMessagesWaitingImpl( const QueueHandle_t pxQueue ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxQueueMessagesWaitingImpl( const QueueHandle_t pxQueue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
UBaseType_t uxReturn = 0;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) pxQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxReturn = uxQueueMessagesWaiting( xInternalQueueHandle );
}
}
}
return uxReturn;
}
/*-----------------------------------------------------------*/
UBaseType_t MPU_uxQueueSpacesAvailableImpl( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxQueueSpacesAvailableImpl( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
UBaseType_t uxReturn = 0;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxReturn = uxQueueSpacesAvailable( xInternalQueueHandle );
}
}
}
return uxReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueReceiveImpl( QueueHandle_t pxQueue,
void * const pvBuffer,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueReceiveImpl( QueueHandle_t pxQueue,
void * const pvBuffer,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFAIL;
BaseType_t xIsReceiveBufferWritable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
UBaseType_t uxQueueItemSize;
lIndex = ( int32_t ) pxQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
if( ( !( ( ( pvBuffer ) == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0U ) ) )
#endif
)
{
xIsReceiveBufferWritable = xPortIsAuthorizedToAccessBuffer( pvBuffer,
uxQueueItemSize,
tskMPU_WRITE_PERMISSION );
if( xIsReceiveBufferWritable == pdTRUE )
{
xReturn = xQueueReceive( xInternalQueueHandle, pvBuffer, xTicksToWait );
}
}
}
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueuePeekImpl( QueueHandle_t xQueue,
void * const pvBuffer,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueuePeekImpl( QueueHandle_t xQueue,
void * const pvBuffer,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFAIL;
BaseType_t xIsReceiveBufferWritable = pdFALSE;
UBaseType_t uxQueueItemSize;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
if( ( !( ( ( pvBuffer ) == NULL ) && ( uxQueueItemSize != ( UBaseType_t ) 0U ) ) )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0U ) ) )
#endif
)
{
xIsReceiveBufferWritable = xPortIsAuthorizedToAccessBuffer( pvBuffer,
uxQueueItemSize,
tskMPU_WRITE_PERMISSION );
if( xIsReceiveBufferWritable == pdTRUE )
{
xReturn = xQueuePeek( xInternalQueueHandle, pvBuffer, xTicksToWait );
}
}
}
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueSemaphoreTakeImpl( QueueHandle_t xQueue,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueSemaphoreTakeImpl( QueueHandle_t xQueue,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFAIL;
UBaseType_t uxQueueItemSize;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
if( ( uxQueueItemSize == 0U )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0U ) ) )
#endif
)
{
xReturn = xQueueSemaphoreTake( xInternalQueueHandle, xTicksToWait );
}
}
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
TaskHandle_t MPU_xQueueGetMutexHolderImpl( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
TaskHandle_t MPU_xQueueGetMutexHolderImpl( QueueHandle_t xSemaphore ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xMutexHolderTaskInternalHandle = NULL;
TaskHandle_t xMutexHolderTaskExternalHandle = NULL;
int32_t lIndex, lMutexHolderTaskIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xSemaphore;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xMutexHolderTaskInternalHandle = xQueueGetMutexHolder( xInternalQueueHandle );
if( xMutexHolderTaskInternalHandle != NULL )
{
lMutexHolderTaskIndex = MPU_GetIndexForTaskHandle( xMutexHolderTaskInternalHandle );
if( lMutexHolderTaskIndex != -1 )
{
xMutexHolderTaskExternalHandle = ( TaskHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lMutexHolderTaskIndex ) );
}
}
}
}
}
return xMutexHolderTaskExternalHandle;
}
#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_RECURSIVE_MUTEXES == 1 )
BaseType_t MPU_xQueueTakeMutexRecursiveImpl( QueueHandle_t xMutex,
TickType_t xBlockTime ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueTakeMutexRecursiveImpl( QueueHandle_t xMutex,
TickType_t xBlockTime ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
UBaseType_t uxQueueItemSize;
lIndex = ( int32_t ) xMutex;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxQueueItemSize = uxQueueGetQueueItemSize( xInternalQueueHandle );
if( uxQueueItemSize == 0 )
{
xReturn = xQueueTakeMutexRecursive( xInternalQueueHandle, xBlockTime );
}
}
}
}
return xReturn;
}
#endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_RECURSIVE_MUTEXES == 1 )
BaseType_t MPU_xQueueGiveMutexRecursiveImpl( QueueHandle_t xMutex ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueGiveMutexRecursiveImpl( QueueHandle_t xMutex ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xMutex;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueGiveMutexRecursive( xInternalQueueHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_QUEUE_SETS == 1 )
QueueSetMemberHandle_t MPU_xQueueSelectFromSetImpl( QueueSetHandle_t xQueueSet,
TickType_t xBlockTimeTicks ) PRIVILEGED_FUNCTION;
QueueSetMemberHandle_t MPU_xQueueSelectFromSetImpl( QueueSetHandle_t xQueueSet,
TickType_t xBlockTimeTicks ) /* PRIVILEGED_FUNCTION */
{
QueueSetHandle_t xInternalQueueSetHandle = NULL;
QueueSetMemberHandle_t xSelectedMemberInternal = NULL;
QueueSetMemberHandle_t xSelectedMemberExternal = NULL;
int32_t lIndexQueueSet, lIndexSelectedMember;
BaseType_t xCallingTaskIsAuthorizedToAccessQueueSet = pdFALSE;
lIndexQueueSet = ( int32_t ) xQueueSet;
if( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueueSet = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
if( xCallingTaskIsAuthorizedToAccessQueueSet == pdTRUE )
{
xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
if( xInternalQueueSetHandle != NULL )
{
xSelectedMemberInternal = xQueueSelectFromSet( xInternalQueueSetHandle, xBlockTimeTicks );
if( xSelectedMemberInternal != NULL )
{
lIndexSelectedMember = MPU_GetIndexForQueueSetMemberHandle( xSelectedMemberInternal );
if( lIndexSelectedMember != -1 )
{
xSelectedMemberExternal = ( QueueSetMemberHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lIndexSelectedMember ) );
}
}
}
}
}
return xSelectedMemberExternal;
}
#endif /* if ( configUSE_QUEUE_SETS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_QUEUE_SETS == 1 )
BaseType_t MPU_xQueueAddToSetImpl( QueueSetMemberHandle_t xQueueOrSemaphore,
QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xQueueAddToSetImpl( QueueSetMemberHandle_t xQueueOrSemaphore,
QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
QueueSetMemberHandle_t xInternalQueueSetMemberHandle = NULL;
QueueSetHandle_t xInternalQueueSetHandle = NULL;
int32_t lIndexQueueSet, lIndexQueueSetMember;
BaseType_t xCallingTaskIsAuthorizedToAccessQueueSet = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessQueueSetMember = pdFALSE;
lIndexQueueSet = ( int32_t ) xQueueSet;
lIndexQueueSetMember = ( int32_t ) xQueueOrSemaphore;
if( ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE ) &&
( IS_EXTERNAL_INDEX_VALID( lIndexQueueSetMember ) != pdFALSE ) )
{
xCallingTaskIsAuthorizedToAccessQueueSet = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
xCallingTaskIsAuthorizedToAccessQueueSetMember = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
if( ( xCallingTaskIsAuthorizedToAccessQueueSet == pdTRUE ) && ( xCallingTaskIsAuthorizedToAccessQueueSetMember == pdTRUE ) )
{
xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
xInternalQueueSetMemberHandle = MPU_GetQueueSetMemberHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
if( ( xInternalQueueSetHandle != NULL ) && ( xInternalQueueSetMemberHandle != NULL ) )
{
xReturn = xQueueAddToSet( xInternalQueueSetMemberHandle, xInternalQueueSetHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_QUEUE_SETS == 1 ) */
/*-----------------------------------------------------------*/
#if configQUEUE_REGISTRY_SIZE > 0
void MPU_vQueueAddToRegistryImpl( QueueHandle_t xQueue,
const char * pcName ) PRIVILEGED_FUNCTION;
void MPU_vQueueAddToRegistryImpl( QueueHandle_t xQueue,
const char * pcName ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
vQueueAddToRegistry( xInternalQueueHandle, pcName );
}
}
}
}
#endif /* if configQUEUE_REGISTRY_SIZE > 0 */
/*-----------------------------------------------------------*/
#if configQUEUE_REGISTRY_SIZE > 0
void MPU_vQueueUnregisterQueueImpl( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
void MPU_vQueueUnregisterQueueImpl( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
vQueueUnregisterQueue( xInternalQueueHandle );
}
}
}
}
#endif /* if configQUEUE_REGISTRY_SIZE > 0 */
/*-----------------------------------------------------------*/
#if configQUEUE_REGISTRY_SIZE > 0
const char * MPU_pcQueueGetNameImpl( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
const char * MPU_pcQueueGetNameImpl( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
const char * pcReturn = NULL;
QueueHandle_t xInternalQueueHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessQueue = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessQueue = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessQueue == pdTRUE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
pcReturn = pcQueueGetName( xInternalQueueHandle );
}
}
}
return pcReturn;
}
#endif /* if configQUEUE_REGISTRY_SIZE > 0 */
/*-----------------------------------------------------------*/
/* Privileged only wrappers for Queue APIs. These are needed so that
* the application can use opaque handles maintained in mpu_wrappers.c
* with all the APIs. */
/*-----------------------------------------------------------*/
void MPU_vQueueDelete( QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
vQueueDelete( xInternalQueueHandle );
MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
}
}
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueCreateMutex( ucQueueType );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
StaticQueue_t * pxStaticQueue ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,
UBaseType_t uxInitialCount ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
const UBaseType_t uxInitialCount,
StaticQueue_t * pxStaticQueue ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,
UBaseType_t uxItemSize,
uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
const UBaseType_t uxItemSize,
uint8_t * pucQueueStorage,
StaticQueue_t * pxStaticQueue,
const uint8_t ucQueueType ) /* PRIVILEGED_FUNCTION */
{
QueueHandle_t xInternalQueueHandle = NULL;
QueueHandle_t xExternalQueueHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueHandle = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
if( xInternalQueueHandle != NULL )
{
MPU_StoreQueueHandleAtIndex( lIndex, xInternalQueueHandle );
xExternalQueueHandle = ( QueueHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueHandle;
}
#endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
BaseType_t xNewQueue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFAIL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueGenericReset( xInternalQueueHandle, xNewQueue );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* PRIVILEGED_FUNCTION */
{
QueueSetHandle_t xInternalQueueSetHandle = NULL;
QueueSetHandle_t xExternalQueueSetHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalQueueSetHandle = xQueueCreateSet( uxEventQueueLength );
if( xInternalQueueSetHandle != NULL )
{
MPU_StoreQueueSetHandleAtIndex( lIndex, xInternalQueueSetHandle );
xExternalQueueSetHandle = ( QueueSetHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalQueueSetHandle;
}
#endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_QUEUE_SETS == 1 )
BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
QueueSetMemberHandle_t xInternalQueueSetMemberHandle = NULL;
QueueSetHandle_t xInternalQueueSetHandle = NULL;
int32_t lIndexQueueSet, lIndexQueueSetMember;
lIndexQueueSet = ( int32_t ) xQueueSet;
lIndexQueueSetMember = ( int32_t ) xQueueOrSemaphore;
if( ( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE ) &&
( IS_EXTERNAL_INDEX_VALID( lIndexQueueSetMember ) != pdFALSE ) )
{
xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
xInternalQueueSetMemberHandle = MPU_GetQueueSetMemberHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSetMember ) );
if( ( xInternalQueueSetHandle != NULL ) && ( xInternalQueueSetMemberHandle != NULL ) )
{
xReturn = xQueueRemoveFromSet( xInternalQueueSetMemberHandle, xInternalQueueSetHandle );
}
}
return xReturn;
}
#endif /* if ( configUSE_QUEUE_SETS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
BaseType_t MPU_xQueueGenericGetStaticBuffers( QueueHandle_t xQueue,
uint8_t ** ppucQueueStorage,
StaticQueue_t ** ppxStaticQueue ) /* PRIVILEGED_FUNCTION */
{
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
BaseType_t xReturn = pdFALSE;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueGenericGetStaticBuffers( xInternalQueueHandle, ppucQueueStorage, ppxStaticQueue );
}
}
return xReturn;
}
#endif /*if ( configSUPPORT_STATIC_ALLOCATION == 1 )*/
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueGenericSendFromISR( QueueHandle_t xQueue,
const void * const pvItemToQueue,
BaseType_t * const pxHigherPriorityTaskWoken,
const BaseType_t xCopyPosition ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueGenericSendFromISR( xInternalQueueHandle, pvItemToQueue, pxHigherPriorityTaskWoken, xCopyPosition );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueGiveFromISR( QueueHandle_t xQueue,
BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueGiveFromISR( xInternalQueueHandle, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t xQueue,
void * const pvBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueuePeekFromISR( xInternalQueueHandle, pvBuffer );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueReceiveFromISR( QueueHandle_t xQueue,
void * const pvBuffer,
BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueReceiveFromISR( xInternalQueueHandle, pvBuffer, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueIsQueueEmptyFromISR( xInternalQueueHandle );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
BaseType_t MPU_xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
xReturn = xQueueIsQueueFullFromISR( xInternalQueueHandle );
}
}
return xReturn;
}
/*-----------------------------------------------------------*/
UBaseType_t MPU_uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = 0;
int32_t lIndex;
QueueHandle_t xInternalQueueHandle = NULL;
lIndex = ( int32_t ) xQueue;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalQueueHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalQueueHandle != NULL )
{
uxReturn = uxQueueMessagesWaitingFromISR( xInternalQueueHandle );
}
}
return uxReturn;
}
/*-----------------------------------------------------------*/
#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
TaskHandle_t MPU_xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xMutexHolderTaskInternalHandle = NULL;
TaskHandle_t xMutexHolderTaskExternalHandle = NULL;
int32_t lIndex, lMutexHolderTaskIndex;
QueueHandle_t xInternalSemaphoreHandle = NULL;
lIndex = ( int32_t ) xSemaphore;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalSemaphoreHandle = MPU_GetQueueHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalSemaphoreHandle != NULL )
{
xMutexHolderTaskInternalHandle = xQueueGetMutexHolder( xInternalSemaphoreHandle );
if( xMutexHolderTaskInternalHandle != NULL )
{
lMutexHolderTaskIndex = MPU_GetIndexForTaskHandle( xMutexHolderTaskInternalHandle );
if( lMutexHolderTaskIndex != -1 )
{
xMutexHolderTaskExternalHandle = ( TaskHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lMutexHolderTaskIndex ) );
}
}
}
}
return xMutexHolderTaskExternalHandle;
}
#endif /* #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_QUEUE_SETS == 1 )
QueueSetMemberHandle_t MPU_xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) /* PRIVILEGED_FUNCTION */
{
QueueSetHandle_t xInternalQueueSetHandle = NULL;
QueueSetMemberHandle_t xSelectedMemberInternal = NULL;
QueueSetMemberHandle_t xSelectedMemberExternal = NULL;
int32_t lIndexQueueSet, lIndexSelectedMember;
lIndexQueueSet = ( int32_t ) xQueueSet;
if( IS_EXTERNAL_INDEX_VALID( lIndexQueueSet ) != pdFALSE )
{
xInternalQueueSetHandle = MPU_GetQueueSetHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndexQueueSet ) );
if( xInternalQueueSetHandle != NULL )
{
xSelectedMemberInternal = xQueueSelectFromSetFromISR( xInternalQueueSetHandle );
if( xSelectedMemberInternal != NULL )
{
lIndexSelectedMember = MPU_GetIndexForQueueSetMemberHandle( xSelectedMemberInternal );
if( lIndexSelectedMember != -1 )
{
xSelectedMemberExternal = ( QueueSetMemberHandle_t ) ( CONVERT_TO_EXTERNAL_INDEX( lIndexSelectedMember ) );
}
}
}
}
return xSelectedMemberExternal;
}
#endif /* if ( configUSE_QUEUE_SETS == 1 ) */
/*-----------------------------------------------------------*/
/*-----------------------------------------------------------*/
/* MPU wrappers for timers APIs. */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
void * MPU_pvTimerGetTimerIDImpl( const TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
void * MPU_pvTimerGetTimerIDImpl( const TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
void * pvReturn = NULL;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
pvReturn = pvTimerGetTimerID( xInternalTimerHandle );
}
}
}
return pvReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
void MPU_vTimerSetTimerIDImpl( TimerHandle_t xTimer,
void * pvNewID ) PRIVILEGED_FUNCTION;
void MPU_vTimerSetTimerIDImpl( TimerHandle_t xTimer,
void * pvNewID ) /* PRIVILEGED_FUNCTION */
{
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
vTimerSetTimerID( xInternalTimerHandle, pvNewID );
}
}
}
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
BaseType_t MPU_xTimerIsTimerActiveImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTimerIsTimerActiveImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerIsTimerActive( xInternalTimerHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandleImpl( void ) PRIVILEGED_FUNCTION;
TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandleImpl( void ) /* PRIVILEGED_FUNCTION */
{
TaskHandle_t xReturn;
xReturn = xTimerGetTimerDaemonTaskHandle();
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
const BaseType_t xCommandID,
const TickType_t xOptionalValue,
BaseType_t * const pxHigherPriorityTaskWoken,
const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
{
BaseType_t xReturn = pdFALSE;
xTimerGenericCommandFromTaskParams_t xParams;
xParams.xTimer = xTimer;
xParams.xCommandID = xCommandID;
xParams.xOptionalValue = xOptionalValue;
xParams.pxHigherPriorityTaskWoken = pxHigherPriorityTaskWoken;
xParams.xTicksToWait = xTicksToWait;
xReturn = MPU_xTimerGenericCommandFromTaskEntry( &( xParams ) );
return xReturn;
}
BaseType_t MPU_xTimerGenericCommandFromTaskImpl( const xTimerGenericCommandFromTaskParams_t * pxParams ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTimerGenericCommandFromTaskImpl( const xTimerGenericCommandFromTaskParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xIsHigherPriorityTaskWokenWriteable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
BaseType_t xAreParamsReadable = pdFALSE;
if( pxParams != NULL )
{
xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
sizeof( xTimerGenericCommandFromTaskParams_t ),
tskMPU_READ_PERMISSION );
}
if( xAreParamsReadable == pdTRUE )
{
if( pxParams->xCommandID < tmrFIRST_FROM_ISR_COMMAND )
{
if( pxParams->pxHigherPriorityTaskWoken != NULL )
{
xIsHigherPriorityTaskWokenWriteable = xPortIsAuthorizedToAccessBuffer( pxParams->pxHigherPriorityTaskWoken,
sizeof( BaseType_t ),
tskMPU_WRITE_PERMISSION );
}
if( ( pxParams->pxHigherPriorityTaskWoken == NULL ) ||
( xIsHigherPriorityTaskWokenWriteable == pdTRUE ) )
{
lIndex = ( int32_t ) ( pxParams->xTimer );
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGenericCommandFromTask( xInternalTimerHandle,
pxParams->xCommandID,
pxParams->xOptionalValue,
pxParams->pxHigherPriorityTaskWoken,
pxParams->xTicksToWait );
}
}
}
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
const char * MPU_pcTimerGetNameImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
const char * MPU_pcTimerGetNameImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
const char * pcReturn = NULL;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
pcReturn = pcTimerGetName( xInternalTimerHandle );
}
}
}
return pcReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
void MPU_vTimerSetReloadModeImpl( TimerHandle_t xTimer,
const UBaseType_t uxAutoReload ) PRIVILEGED_FUNCTION;
void MPU_vTimerSetReloadModeImpl( TimerHandle_t xTimer,
const UBaseType_t uxAutoReload ) /* PRIVILEGED_FUNCTION */
{
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
vTimerSetReloadMode( xInternalTimerHandle, uxAutoReload );
}
}
}
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
BaseType_t MPU_xTimerGetReloadModeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xTimerGetReloadModeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGetReloadMode( xInternalTimerHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
UBaseType_t MPU_uxTimerGetReloadModeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxTimerGetReloadModeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t uxReturn = 0;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
uxReturn = uxTimerGetReloadMode( xInternalTimerHandle );
}
}
}
return uxReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
TickType_t MPU_xTimerGetPeriodImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
TickType_t MPU_xTimerGetPeriodImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
TickType_t xReturn = 0;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGetPeriod( xInternalTimerHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
TickType_t MPU_xTimerGetExpiryTimeImpl( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
TickType_t MPU_xTimerGetExpiryTimeImpl( TimerHandle_t xTimer ) /* PRIVILEGED_FUNCTION */
{
TickType_t xReturn = 0;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessTimer = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessTimer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessTimer == pdTRUE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGetExpiryTime( xInternalTimerHandle );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
/* Privileged only wrappers for Timer APIs. These are needed so that
* the application can use opaque handles maintained in mpu_wrappers.c
* with all the APIs. */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,
const TickType_t xTimerPeriodInTicks,
const UBaseType_t uxAutoReload,
void * const pvTimerID,
TimerCallbackFunction_t pxCallbackFunction ) /* PRIVILEGED_FUNCTION */
{
TimerHandle_t xInternalTimerHandle = NULL;
TimerHandle_t xExternalTimerHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalTimerHandle = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, MPU_TimerCallback );
if( xInternalTimerHandle != NULL )
{
MPU_StoreTimerHandleAtIndex( lIndex, xInternalTimerHandle, pxCallbackFunction );
xExternalTimerHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalTimerHandle;
}
#endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,
const TickType_t xTimerPeriodInTicks,
const UBaseType_t uxAutoReload,
void * const pvTimerID,
TimerCallbackFunction_t pxCallbackFunction,
StaticTimer_t * pxTimerBuffer ) /* PRIVILEGED_FUNCTION */
{
TimerHandle_t xInternalTimerHandle = NULL;
TimerHandle_t xExternalTimerHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalTimerHandle = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, MPU_TimerCallback, pxTimerBuffer );
if( xInternalTimerHandle != NULL )
{
MPU_StoreTimerHandleAtIndex( lIndex, xInternalTimerHandle, pxCallbackFunction );
xExternalTimerHandle = ( TimerHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalTimerHandle;
}
#endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 )
BaseType_t MPU_xTimerGetStaticBuffer( TimerHandle_t xTimer,
StaticTimer_t ** ppxTimerBuffer ) /* PRIVILEGED_FUNCTION */
{
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xReturn = pdFALSE;
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGetStaticBuffer( xInternalTimerHandle, ppxTimerBuffer );
}
}
return xReturn;
}
#endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_TIMERS == 1 )
BaseType_t MPU_xTimerGenericCommandFromISR( TimerHandle_t xTimer,
const BaseType_t xCommandID,
const TickType_t xOptionalValue,
BaseType_t * const pxHigherPriorityTaskWoken,
const TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
TimerHandle_t xInternalTimerHandle = NULL;
int32_t lIndex;
BaseType_t xIsHigherPriorityTaskWokenWriteable = pdFALSE;
if( pxHigherPriorityTaskWoken != NULL )
{
xIsHigherPriorityTaskWokenWriteable = xPortIsAuthorizedToAccessBuffer( pxHigherPriorityTaskWoken,
sizeof( BaseType_t ),
tskMPU_WRITE_PERMISSION );
}
if( ( pxHigherPriorityTaskWoken == NULL ) || ( xIsHigherPriorityTaskWokenWriteable == pdTRUE ) )
{
lIndex = ( int32_t ) xTimer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalTimerHandle = MPU_GetTimerHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalTimerHandle != NULL )
{
xReturn = xTimerGenericCommandFromISR( xInternalTimerHandle, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
}
}
}
return xReturn;
}
#endif /* if ( configUSE_TIMERS == 1 ) */
/*-----------------------------------------------------------*/
/*-----------------------------------------------------------*/
/* MPU wrappers for event group APIs. */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToWaitFor,
const BaseType_t xClearOnExit,
const BaseType_t xWaitForAllBits,
TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
{
EventBits_t xReturn = 0;
xEventGroupWaitBitsParams_t xParams;
xParams.xEventGroup = xEventGroup;
xParams.uxBitsToWaitFor = uxBitsToWaitFor;
xParams.xClearOnExit = xClearOnExit;
xParams.xWaitForAllBits = xWaitForAllBits;
xParams.xTicksToWait = xTicksToWait;
xReturn = MPU_xEventGroupWaitBitsEntry( &( xParams ) );
return xReturn;
}
EventBits_t MPU_xEventGroupWaitBitsImpl( const xEventGroupWaitBitsParams_t * pxParams ) PRIVILEGED_FUNCTION;
EventBits_t MPU_xEventGroupWaitBitsImpl( const xEventGroupWaitBitsParams_t * pxParams ) /* PRIVILEGED_FUNCTION */
{
EventBits_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
BaseType_t xAreParamsReadable = pdFALSE;
if( pxParams != NULL )
{
xAreParamsReadable = xPortIsAuthorizedToAccessBuffer( pxParams,
sizeof( xEventGroupWaitBitsParams_t ),
tskMPU_READ_PERMISSION );
}
if( xAreParamsReadable == pdTRUE )
{
if( ( ( pxParams->uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0U ) &&
( pxParams->uxBitsToWaitFor != 0U )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( pxParams->xTicksToWait != 0U ) ) )
#endif
)
{
lIndex = ( int32_t ) ( pxParams->xEventGroup );
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupWaitBits( xInternalEventGroupHandle,
pxParams->uxBitsToWaitFor,
pxParams->xClearOnExit,
pxParams->xWaitForAllBits,
pxParams->xTicksToWait );
}
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
EventBits_t MPU_xEventGroupClearBitsImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
EventBits_t MPU_xEventGroupClearBitsImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToClear ) /* PRIVILEGED_FUNCTION */
{
EventBits_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
if( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0U )
{
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupClearBits( xInternalEventGroupHandle, uxBitsToClear );
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
EventBits_t MPU_xEventGroupSetBitsImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
EventBits_t MPU_xEventGroupSetBitsImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet ) /* PRIVILEGED_FUNCTION */
{
EventBits_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
if( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0U )
{
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupSetBits( xInternalEventGroupHandle, uxBitsToSet );
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
EventBits_t MPU_xEventGroupSyncImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet,
const EventBits_t uxBitsToWaitFor,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
EventBits_t MPU_xEventGroupSyncImpl( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet,
const EventBits_t uxBitsToWaitFor,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
EventBits_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
if( ( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0U ) &&
( uxBitsToWaitFor != 0U )
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
&& ( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0U ) ) )
#endif
)
{
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupSync( xInternalEventGroupHandle, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) )
UBaseType_t MPU_uxEventGroupGetNumberImpl( void * xEventGroup ) PRIVILEGED_FUNCTION;
UBaseType_t MPU_uxEventGroupGetNumberImpl( void * xEventGroup ) /* PRIVILEGED_FUNCTION */
{
UBaseType_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = uxEventGroupGetNumber( xInternalEventGroupHandle );
}
}
}
return xReturn;
}
#endif /* #if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) )
void MPU_vEventGroupSetNumberImpl( void * xEventGroup,
UBaseType_t uxEventGroupNumber ) PRIVILEGED_FUNCTION;
void MPU_vEventGroupSetNumberImpl( void * xEventGroup,
UBaseType_t uxEventGroupNumber ) /* PRIVILEGED_FUNCTION */
{
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessEventGroup = pdFALSE;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessEventGroup = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessEventGroup == pdTRUE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
vEventGroupSetNumber( xInternalEventGroupHandle, uxEventGroupNumber );
}
}
}
}
#endif /* #if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) ) */
/*-----------------------------------------------------------*/
/* Privileged only wrappers for Event Group APIs. These are needed so that
* the application can use opaque handles maintained in mpu_wrappers.c
* with all the APIs. */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
EventGroupHandle_t MPU_xEventGroupCreate( void ) /* PRIVILEGED_FUNCTION */
{
EventGroupHandle_t xInternalEventGroupHandle = NULL;
EventGroupHandle_t xExternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalEventGroupHandle = xEventGroupCreate();
if( xInternalEventGroupHandle != NULL )
{
MPU_StoreEventGroupHandleAtIndex( lIndex, xInternalEventGroupHandle );
xExternalEventGroupHandle = ( EventGroupHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalEventGroupHandle;
}
#endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* PRIVILEGED_FUNCTION */
{
EventGroupHandle_t xInternalEventGroupHandle = NULL;
EventGroupHandle_t xExternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalEventGroupHandle = xEventGroupCreateStatic( pxEventGroupBuffer );
if( xInternalEventGroupHandle != NULL )
{
MPU_StoreEventGroupHandleAtIndex( lIndex, xInternalEventGroupHandle );
xExternalEventGroupHandle = ( EventGroupHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
return xExternalEventGroupHandle;
}
#endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* PRIVILEGED_FUNCTION */
{
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
vEventGroupDelete( xInternalEventGroupHandle );
MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
}
}
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
BaseType_t MPU_xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
StaticEventGroup_t ** ppxEventGroupBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupGetStaticBuffer( xInternalEventGroupHandle, ppxEventGroupBuffer );
}
}
return xReturn;
}
#endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
BaseType_t MPU_xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToClear ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupClearBitsFromISR( xInternalEventGroupHandle, uxBitsToClear );
}
}
return xReturn;
}
#endif /* #if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
BaseType_t MPU_xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet,
BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupSetBitsFromISR( xInternalEventGroupHandle, uxBitsToSet, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( ( configUSE_EVENT_GROUPS == 1 ) && ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_EVENT_GROUPS == 1 )
EventBits_t MPU_xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) /* PRIVILEGED_FUNCTION */
{
EventBits_t xReturn = 0;
EventGroupHandle_t xInternalEventGroupHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xEventGroup;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalEventGroupHandle = MPU_GetEventGroupHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalEventGroupHandle != NULL )
{
xReturn = xEventGroupGetBitsFromISR( xInternalEventGroupHandle );
}
}
return xReturn;
}
#endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
/*-----------------------------------------------------------*/
/*-----------------------------------------------------------*/
/* MPU wrappers for stream buffer APIs. */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferSendImpl( StreamBufferHandle_t xStreamBuffer,
const void * pvTxData,
size_t xDataLengthBytes,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
size_t MPU_xStreamBufferSendImpl( StreamBufferHandle_t xStreamBuffer,
const void * pvTxData,
size_t xDataLengthBytes,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xIsTxDataBufferReadable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
if( pvTxData != NULL )
{
xIsTxDataBufferReadable = xPortIsAuthorizedToAccessBuffer( pvTxData,
xDataLengthBytes,
tskMPU_READ_PERMISSION );
if( xIsTxDataBufferReadable == pdTRUE )
{
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferSend( xInternalStreamBufferHandle, pvTxData, xDataLengthBytes, xTicksToWait );
}
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferReceiveImpl( StreamBufferHandle_t xStreamBuffer,
void * pvRxData,
size_t xBufferLengthBytes,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
size_t MPU_xStreamBufferReceiveImpl( StreamBufferHandle_t xStreamBuffer,
void * pvRxData,
size_t xBufferLengthBytes,
TickType_t xTicksToWait ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xIsRxDataBufferWriteable = pdFALSE;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
if( pvRxData != NULL )
{
xIsRxDataBufferWriteable = xPortIsAuthorizedToAccessBuffer( pvRxData,
xBufferLengthBytes,
tskMPU_WRITE_PERMISSION );
if( xIsRxDataBufferWriteable == pdTRUE )
{
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferReceive( xInternalStreamBufferHandle, pvRxData, xBufferLengthBytes, xTicksToWait );
}
}
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferIsFullImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xStreamBufferIsFullImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferIsFull( xInternalStreamBufferHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferIsEmptyImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xStreamBufferIsEmptyImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferIsEmpty( xInternalStreamBufferHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferSpacesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
size_t MPU_xStreamBufferSpacesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferSpacesAvailable( xInternalStreamBufferHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferBytesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
size_t MPU_xStreamBufferBytesAvailableImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferBytesAvailable( xInternalStreamBufferHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferSetTriggerLevelImpl( StreamBufferHandle_t xStreamBuffer,
size_t xTriggerLevel ) PRIVILEGED_FUNCTION;
BaseType_t MPU_xStreamBufferSetTriggerLevelImpl( StreamBufferHandle_t xStreamBuffer,
size_t xTriggerLevel ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferSetTriggerLevel( xInternalStreamBufferHandle, xTriggerLevel );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferNextMessageLengthBytesImpl( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
size_t MPU_xStreamBufferNextMessageLengthBytesImpl( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
BaseType_t xCallingTaskIsAuthorizedToAccessStreamBuffer = pdFALSE;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xCallingTaskIsAuthorizedToAccessStreamBuffer = xPortIsAuthorizedToAccessKernelObject( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xCallingTaskIsAuthorizedToAccessStreamBuffer == pdTRUE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferNextMessageLengthBytes( xInternalStreamBufferHandle );
}
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
* the application can use opaque handles maintained in mpu_wrappers.c
* with all the APIs. */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
size_t xTriggerLevelBytes,
BaseType_t xStreamBufferType,
StreamBufferCallbackFunction_t pxSendCompletedCallback,
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* PRIVILEGED_FUNCTION */
{
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
StreamBufferHandle_t xExternalStreamBufferHandle = NULL;
int32_t lIndex;
/**
* Stream buffer application level callback functionality is disabled for MPU
* enabled ports.
*/
configASSERT( ( pxSendCompletedCallback == NULL ) &&
( pxReceiveCompletedCallback == NULL ) );
if( ( pxSendCompletedCallback == NULL ) &&
( pxReceiveCompletedCallback == NULL ) )
{
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalStreamBufferHandle = xStreamBufferGenericCreate( xBufferSizeBytes,
xTriggerLevelBytes,
xStreamBufferType,
NULL,
NULL );
if( xInternalStreamBufferHandle != NULL )
{
MPU_StoreStreamBufferHandleAtIndex( lIndex, xInternalStreamBufferHandle );
xExternalStreamBufferHandle = ( StreamBufferHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
}
else
{
traceSTREAM_BUFFER_CREATE_FAILED( xStreamBufferType );
xExternalStreamBufferHandle = NULL;
}
return xExternalStreamBufferHandle;
}
#endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
size_t xTriggerLevelBytes,
BaseType_t xStreamBufferType,
uint8_t * const pucStreamBufferStorageArea,
StaticStreamBuffer_t * const pxStaticStreamBuffer,
StreamBufferCallbackFunction_t pxSendCompletedCallback,
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* PRIVILEGED_FUNCTION */
{
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
StreamBufferHandle_t xExternalStreamBufferHandle = NULL;
int32_t lIndex;
/**
* Stream buffer application level callback functionality is disabled for MPU
* enabled ports.
*/
configASSERT( ( pxSendCompletedCallback == NULL ) &&
( pxReceiveCompletedCallback == NULL ) );
if( ( pxSendCompletedCallback == NULL ) &&
( pxReceiveCompletedCallback == NULL ) )
{
lIndex = MPU_GetFreeIndexInKernelObjectPool();
if( lIndex != -1 )
{
xInternalStreamBufferHandle = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
xTriggerLevelBytes,
xStreamBufferType,
pucStreamBufferStorageArea,
pxStaticStreamBuffer,
NULL,
NULL );
if( xInternalStreamBufferHandle != NULL )
{
MPU_StoreStreamBufferHandleAtIndex( lIndex, xInternalStreamBufferHandle );
xExternalStreamBufferHandle = ( StreamBufferHandle_t ) CONVERT_TO_EXTERNAL_INDEX( lIndex );
}
else
{
MPU_SetIndexFreeInKernelObjectPool( lIndex );
}
}
}
else
{
traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xStreamBufferType );
xExternalStreamBufferHandle = NULL;
}
return xExternalStreamBufferHandle;
}
#endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
vStreamBufferDelete( xInternalStreamBufferHandle );
}
MPU_SetIndexFreeInKernelObjectPool( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
}
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferReset( xInternalStreamBufferHandle );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
BaseType_t MPU_xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffers,
uint8_t * ppucStreamBufferStorageArea,
StaticStreamBuffer_t * ppxStaticStreamBuffer ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffers;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = MPU_xStreamBufferGetStaticBuffers( xInternalStreamBufferHandle, ppucStreamBufferStorageArea, ppxStaticStreamBuffer );
}
}
return xReturn;
}
#endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
const void * pvTxData,
size_t xDataLengthBytes,
BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferSendFromISR( xInternalStreamBufferHandle, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
size_t MPU_xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
void * pvRxData,
size_t xBufferLengthBytes,
BaseType_t * const pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
size_t xReturn = 0;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferReceiveFromISR( xInternalStreamBufferHandle, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
BaseType_t * pxHigherPriorityTaskWoken ) /* PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferSendCompletedFromISR( xInternalStreamBufferHandle, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
BaseType_t * pxHigherPriorityTaskWoken ) /*PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFALSE;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferReceiveCompletedFromISR( xInternalStreamBufferHandle, pxHigherPriorityTaskWoken );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
#if ( configUSE_STREAM_BUFFERS == 1 )
BaseType_t MPU_xStreamBufferResetFromISR( StreamBufferHandle_t xStreamBuffer ) /*PRIVILEGED_FUNCTION */
{
BaseType_t xReturn = pdFAIL;
StreamBufferHandle_t xInternalStreamBufferHandle = NULL;
int32_t lIndex;
lIndex = ( int32_t ) xStreamBuffer;
if( IS_EXTERNAL_INDEX_VALID( lIndex ) != pdFALSE )
{
xInternalStreamBufferHandle = MPU_GetStreamBufferHandleAtIndex( CONVERT_TO_INTERNAL_INDEX( lIndex ) );
if( xInternalStreamBufferHandle != NULL )
{
xReturn = xStreamBufferResetFromISR( xInternalStreamBufferHandle );
}
}
return xReturn;
}
#endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
/*-----------------------------------------------------------*/
/* Functions that the application writer wants to execute in privileged mode
* can be defined in application_defined_privileged_functions.h. */
#if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
#include "application_defined_privileged_functions.h"
#endif
/*-----------------------------------------------------------*/
/**
* @brief Array of system call implementation functions.
*
* The index in the array MUST match the corresponding system call number
* defined in mpu_wrappers.h.
*/
PRIVILEGED_DATA UBaseType_t uxSystemCallImplementations[ NUM_SYSTEM_CALLS ] =
{
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
( UBaseType_t ) MPU_xTaskGenericNotifyImpl, /* SYSTEM_CALL_xTaskGenericNotify. */
( UBaseType_t ) MPU_xTaskGenericNotifyWaitImpl, /* SYSTEM_CALL_xTaskGenericNotifyWait. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotify. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotifyWait. */
#endif
#if ( configUSE_TIMERS == 1 )
( UBaseType_t ) MPU_xTimerGenericCommandFromTaskImpl, /* SYSTEM_CALL_xTimerGenericCommandFromTask. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGenericCommandFromTask. */
#endif
#if ( configUSE_EVENT_GROUPS == 1 )
( UBaseType_t ) MPU_xEventGroupWaitBitsImpl, /* SYSTEM_CALL_xEventGroupWaitBits. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xEventGroupWaitBits. */
#endif
/* The system calls above this line take 5 parameters. */
#if ( INCLUDE_xTaskDelayUntil == 1 )
( UBaseType_t ) MPU_xTaskDelayUntilImpl, /* SYSTEM_CALL_xTaskDelayUntil. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskDelayUntil. */
#endif
#if ( INCLUDE_xTaskAbortDelay == 1 )
( UBaseType_t ) MPU_xTaskAbortDelayImpl, /* SYSTEM_CALL_xTaskAbortDelay. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskAbortDelay. */
#endif
#if ( INCLUDE_vTaskDelay == 1 )
( UBaseType_t ) MPU_vTaskDelayImpl, /* SYSTEM_CALL_vTaskDelay. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskDelay. */
#endif
#if ( INCLUDE_uxTaskPriorityGet == 1 )
( UBaseType_t ) MPU_uxTaskPriorityGetImpl, /* SYSTEM_CALL_uxTaskPriorityGet. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskPriorityGet. */
#endif
#if ( INCLUDE_eTaskGetState == 1 )
( UBaseType_t ) MPU_eTaskGetStateImpl, /* SYSTEM_CALL_eTaskGetState. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_eTaskGetState. */
#endif
#if ( configUSE_TRACE_FACILITY == 1 )
( UBaseType_t ) MPU_vTaskGetInfoImpl, /* SYSTEM_CALL_vTaskGetInfo. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskGetInfo. */
#endif
#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
( UBaseType_t ) MPU_xTaskGetIdleTaskHandleImpl, /* SYSTEM_CALL_xTaskGetIdleTaskHandle. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetIdleTaskHandle. */
#endif
#if ( INCLUDE_vTaskSuspend == 1 )
( UBaseType_t ) MPU_vTaskSuspendImpl, /* SYSTEM_CALL_vTaskSuspend. */
( UBaseType_t ) MPU_vTaskResumeImpl, /* SYSTEM_CALL_vTaskResume. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSuspend. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskResume. */
#endif
( UBaseType_t ) MPU_xTaskGetTickCountImpl, /* SYSTEM_CALL_xTaskGetTickCount. */
( UBaseType_t ) MPU_uxTaskGetNumberOfTasksImpl, /* SYSTEM_CALL_uxTaskGetNumberOfTasks. */
#if ( configGENERATE_RUN_TIME_STATS == 1 )
( UBaseType_t ) MPU_ulTaskGetRunTimeCounterImpl, /* SYSTEM_CALL_ulTaskGetRunTimeCounter. */
( UBaseType_t ) MPU_ulTaskGetRunTimePercentImpl, /* SYSTEM_CALL_ulTaskGetRunTimePercent. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetRunTimeCounter. */
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetRunTimePercent. */
#endif
#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
( UBaseType_t ) MPU_ulTaskGetIdleRunTimePercentImpl, /* SYSTEM_CALL_ulTaskGetIdleRunTimePercent. */
( UBaseType_t ) MPU_ulTaskGetIdleRunTimeCounterImpl, /* SYSTEM_CALL_ulTaskGetIdleRunTimeCounter. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetIdleRunTimePercent. */
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGetIdleRunTimeCounter. */
#endif
#if ( configUSE_APPLICATION_TASK_TAG == 1 )
( UBaseType_t ) MPU_vTaskSetApplicationTaskTagImpl, /* SYSTEM_CALL_vTaskSetApplicationTaskTag. */
( UBaseType_t ) MPU_xTaskGetApplicationTaskTagImpl, /* SYSTEM_CALL_xTaskGetApplicationTaskTag. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSetApplicationTaskTag. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetApplicationTaskTag. */
#endif
#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
( UBaseType_t ) MPU_vTaskSetThreadLocalStoragePointerImpl, /* SYSTEM_CALL_vTaskSetThreadLocalStoragePointer. */
( UBaseType_t ) MPU_pvTaskGetThreadLocalStoragePointerImpl, /* SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vTaskSetThreadLocalStoragePointer. */
( UBaseType_t ) 0, /* SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer. */
#endif
#if ( configUSE_TRACE_FACILITY == 1 )
( UBaseType_t ) MPU_uxTaskGetSystemStateImpl, /* SYSTEM_CALL_uxTaskGetSystemState. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetSystemState. */
#endif
#if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
( UBaseType_t ) MPU_uxTaskGetStackHighWaterMarkImpl, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark. */
#endif
#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
( UBaseType_t ) MPU_uxTaskGetStackHighWaterMark2Impl, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark2. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_uxTaskGetStackHighWaterMark2. */
#endif
#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
( UBaseType_t ) MPU_xTaskGetCurrentTaskHandleImpl, /* SYSTEM_CALL_xTaskGetCurrentTaskHandle. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetCurrentTaskHandle. */
#endif
#if ( INCLUDE_xTaskGetSchedulerState == 1 )
( UBaseType_t ) MPU_xTaskGetSchedulerStateImpl, /* SYSTEM_CALL_xTaskGetSchedulerState. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGetSchedulerState. */
#endif
( UBaseType_t ) MPU_vTaskSetTimeOutStateImpl, /* SYSTEM_CALL_vTaskSetTimeOutState. */
( UBaseType_t ) MPU_xTaskCheckForTimeOutImpl, /* SYSTEM_CALL_xTaskCheckForTimeOut. */
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
( UBaseType_t ) MPU_ulTaskGenericNotifyTakeImpl, /* SYSTEM_CALL_ulTaskGenericNotifyTake. */
( UBaseType_t ) MPU_xTaskGenericNotifyStateClearImpl, /* SYSTEM_CALL_xTaskGenericNotifyStateClear. */
( UBaseType_t ) MPU_ulTaskGenericNotifyValueClearImpl, /* SYSTEM_CALL_ulTaskGenericNotifyValueClear. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGenericNotifyTake. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTaskGenericNotifyStateClear. */
( UBaseType_t ) 0, /* SYSTEM_CALL_ulTaskGenericNotifyValueClear. */
#endif
( UBaseType_t ) MPU_xQueueGenericSendImpl, /* SYSTEM_CALL_xQueueGenericSend. */
( UBaseType_t ) MPU_uxQueueMessagesWaitingImpl, /* SYSTEM_CALL_uxQueueMessagesWaiting. */
( UBaseType_t ) MPU_uxQueueSpacesAvailableImpl, /* SYSTEM_CALL_uxQueueSpacesAvailable. */
( UBaseType_t ) MPU_xQueueReceiveImpl, /* SYSTEM_CALL_xQueueReceive. */
( UBaseType_t ) MPU_xQueuePeekImpl, /* SYSTEM_CALL_xQueuePeek. */
( UBaseType_t ) MPU_xQueueSemaphoreTakeImpl, /* SYSTEM_CALL_xQueueSemaphoreTake. */
#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
( UBaseType_t ) MPU_xQueueGetMutexHolderImpl, /* SYSTEM_CALL_xQueueGetMutexHolder. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueGetMutexHolder. */
#endif
#if ( configUSE_RECURSIVE_MUTEXES == 1 )
( UBaseType_t ) MPU_xQueueTakeMutexRecursiveImpl, /* SYSTEM_CALL_xQueueTakeMutexRecursive. */
( UBaseType_t ) MPU_xQueueGiveMutexRecursiveImpl, /* SYSTEM_CALL_xQueueGiveMutexRecursive. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueTakeMutexRecursive. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueGiveMutexRecursive. */
#endif
#if ( configUSE_QUEUE_SETS == 1 )
( UBaseType_t ) MPU_xQueueSelectFromSetImpl, /* SYSTEM_CALL_xQueueSelectFromSet. */
( UBaseType_t ) MPU_xQueueAddToSetImpl, /* SYSTEM_CALL_xQueueAddToSet. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueSelectFromSet. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xQueueAddToSet. */
#endif
#if configQUEUE_REGISTRY_SIZE > 0
( UBaseType_t ) MPU_vQueueAddToRegistryImpl, /* SYSTEM_CALL_vQueueAddToRegistry. */
( UBaseType_t ) MPU_vQueueUnregisterQueueImpl, /* SYSTEM_CALL_vQueueUnregisterQueue. */
( UBaseType_t ) MPU_pcQueueGetNameImpl, /* SYSTEM_CALL_pcQueueGetName. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_vQueueAddToRegistry. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vQueueUnregisterQueue. */
( UBaseType_t ) 0, /* SYSTEM_CALL_pcQueueGetName. */
#endif
#if ( configUSE_TIMERS == 1 )
( UBaseType_t ) MPU_pvTimerGetTimerIDImpl, /* SYSTEM_CALL_pvTimerGetTimerID. */
( UBaseType_t ) MPU_vTimerSetTimerIDImpl, /* SYSTEM_CALL_vTimerSetTimerID. */
( UBaseType_t ) MPU_xTimerIsTimerActiveImpl, /* SYSTEM_CALL_xTimerIsTimerActive. */
( UBaseType_t ) MPU_xTimerGetTimerDaemonTaskHandleImpl, /* SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle. */
( UBaseType_t ) MPU_pcTimerGetNameImpl, /* SYSTEM_CALL_pcTimerGetName. */
( UBaseType_t ) MPU_vTimerSetReloadModeImpl, /* SYSTEM_CALL_vTimerSetReloadMode. */
( UBaseType_t ) MPU_xTimerGetReloadModeImpl, /* SYSTEM_CALL_xTimerGetReloadMode. */
( UBaseType_t ) MPU_uxTimerGetReloadModeImpl, /* SYSTEM_CALL_uxTimerGetReloadMode. */
( UBaseType_t ) MPU_xTimerGetPeriodImpl, /* SYSTEM_CALL_xTimerGetPeriod. */
( UBaseType_t ) MPU_xTimerGetExpiryTimeImpl, /* SYSTEM_CALL_xTimerGetExpiryTime. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_pvTimerGetTimerID. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vTimerSetTimerID. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerIsTimerActive. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle. */
( UBaseType_t ) 0, /* SYSTEM_CALL_pcTimerGetName. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vTimerSetReloadMode. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetReloadMode. */
( UBaseType_t ) 0, /* SYSTEM_CALL_uxTimerGetReloadMode. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetPeriod. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xTimerGetExpiryTime. */
#endif
#if ( configUSE_EVENT_GROUPS == 1 )
( UBaseType_t ) MPU_xEventGroupClearBitsImpl, /* SYSTEM_CALL_xEventGroupClearBits. */
( UBaseType_t ) MPU_xEventGroupSetBitsImpl, /* SYSTEM_CALL_xEventGroupSetBits. */
( UBaseType_t ) MPU_xEventGroupSyncImpl, /* SYSTEM_CALL_xEventGroupSync. */
#if ( configUSE_TRACE_FACILITY == 1 )
( UBaseType_t ) MPU_uxEventGroupGetNumberImpl, /* SYSTEM_CALL_uxEventGroupGetNumber. */
( UBaseType_t ) MPU_vEventGroupSetNumberImpl, /* SYSTEM_CALL_vEventGroupSetNumber. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_uxEventGroupGetNumber. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vEventGroupSetNumber. */
#endif
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xEventGroupClearBits. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xEventGroupSetBits. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xEventGroupSync. */
( UBaseType_t ) 0, /* SYSTEM_CALL_uxEventGroupGetNumber. */
( UBaseType_t ) 0, /* SYSTEM_CALL_vEventGroupSetNumber. */
#endif
#if ( configUSE_STREAM_BUFFERS == 1 )
( UBaseType_t ) MPU_xStreamBufferSendImpl, /* SYSTEM_CALL_xStreamBufferSend. */
( UBaseType_t ) MPU_xStreamBufferReceiveImpl, /* SYSTEM_CALL_xStreamBufferReceive. */
( UBaseType_t ) MPU_xStreamBufferIsFullImpl, /* SYSTEM_CALL_xStreamBufferIsFull. */
( UBaseType_t ) MPU_xStreamBufferIsEmptyImpl, /* SYSTEM_CALL_xStreamBufferIsEmpty. */
( UBaseType_t ) MPU_xStreamBufferSpacesAvailableImpl, /* SYSTEM_CALL_xStreamBufferSpacesAvailable. */
( UBaseType_t ) MPU_xStreamBufferBytesAvailableImpl, /* SYSTEM_CALL_xStreamBufferBytesAvailable. */
( UBaseType_t ) MPU_xStreamBufferSetTriggerLevelImpl, /* SYSTEM_CALL_xStreamBufferSetTriggerLevel. */
( UBaseType_t ) MPU_xStreamBufferNextMessageLengthBytesImpl /* SYSTEM_CALL_xStreamBufferNextMessageLengthBytes. */
#else
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferSend. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferReceive. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferIsFull. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferIsEmpty. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferSpacesAvailable. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferBytesAvailable. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferSetTriggerLevel. */
( UBaseType_t ) 0, /* SYSTEM_CALL_xStreamBufferNextMessageLengthBytes. */
#endif
};
/*-----------------------------------------------------------*/
#endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) ) */
/*-----------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink