/*

* FreeRTOS Kernel V10.5.0

* 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

*

*/

#include <stdlib.h>

#include <string.h>

/* 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

#include "Arduino_FreeRTOS.h"

#include "task.h"

#include "queue.h"

/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified

* because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

* for the header files above, but not in this file, in order to generate the

* correct privileged Vs unprivileged linkage and placement. */

#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */

/* Constants used with the cRxLock and cTxLock structure members. */

#define queueUNLOCKED ( ( int8_t ) -1 )

#define queueLOCKED_UNMODIFIED ( ( int8_t ) 0 )

#define queueINT8_MAX ( ( int8_t ) 127 )

/* When the Queue_t structure is used to represent a base queue its pcHead and

* pcTail members are used as pointers into the queue storage area. When the

* Queue_t structure is used to represent a mutex pcHead and pcTail pointers are

* not necessary, and the pcHead pointer is set to NULL to indicate that the

* structure instead holds a pointer to the mutex holder (if any). Map alternative

* names to the pcHead and structure member to ensure the readability of the code

* is maintained. The QueuePointers_t and SemaphoreData_t types are used to form

* a union as their usage is mutually exclusive dependent on what the queue is

* being used for. */

#define uxQueueType pcHead

#define queueQUEUE_IS_MUTEX NULL

typedef struct QueuePointers

{

int8_t * pcTail; /*< Points to the byte at the end of the queue storage area. Once more byte is allocated than necessary to store the queue items, this is used as a marker. */

int8_t * pcReadFrom; /*< Points to the last place that a queued item was read from when the structure is used as a queue. */

} QueuePointers_t;

typedef struct SemaphoreData

{

TaskHandle_t xMutexHolder; /*< The handle of the task that holds the mutex. */

UBaseType_t uxRecursiveCallCount; /*< Maintains a count of the number of times a recursive mutex has been recursively 'taken' when the structure is used as a mutex. */

} SemaphoreData_t;

/* Semaphores do not actually store or copy data, so have an item size of

* zero. */

#define queueSEMAPHORE_QUEUE_ITEM_LENGTH ( ( UBaseType_t ) 0 )

#define queueMUTEX_GIVE_BLOCK_TIME ( ( TickType_t ) 0U )

#if ( configUSE_PREEMPTION == 0 )

/* If the cooperative scheduler is being used then a yield should not be

* performed just because a higher priority task has been woken. */

#define queueYIELD_IF_USING_PREEMPTION()

#else

#define queueYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()

#endif

/*

* Definition of the queue used by the scheduler.

* Items are queued by copy, not reference. See the following link for the

* rationale: https://www.FreeRTOS.org/Embedded-RTOS-Queues.html

*/

typedef struct QueueDef_t

{

int8_t * pcHead; /*< Points to the beginning of the queue storage area. */

int8_t * pcWriteTo; /*< Points to the free next place in the storage area. */

union

{

QueuePointers_t xQueue; /*< Data required exclusively when this structure is used as a queue. */

SemaphoreData_t xSemaphore; /*< Data required exclusively when this structure is used as a semaphore. */

} u;

List_t xTasksWaitingToSend; /*< List of tasks that are blocked waiting to post onto this queue. Stored in priority order. */

List_t xTasksWaitingToReceive; /*< List of tasks that are blocked waiting to read from this queue. Stored in priority order. */

volatile UBaseType_t uxMessagesWaiting; /*< The number of items currently in the queue. */

UBaseType_t uxLength; /*< The length of the queue defined as the number of items it will hold, not the number of bytes. */

UBaseType_t uxItemSize; /*< The size of each items that the queue will hold. */

volatile int8_t cRxLock; /*< Stores the number of items received from the queue (removed from the queue) while the queue was locked. Set to queueUNLOCKED when the queue is not locked. */

volatile int8_t cTxLock; /*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked. Set to queueUNLOCKED when the queue is not locked. */

#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the memory used by the queue was statically allocated to ensure no attempt is made to free the memory. */

#endif

#if ( configUSE_QUEUE_SETS == 1 )

struct QueueDef_t * pxQueueSetContainer;

#endif

#if ( configUSE_TRACE_FACILITY == 1 )

UBaseType_t uxQueueNumber;

uint8_t ucQueueType;

#endif

} Queue_t;

/*-----------------------------------------------------------*/

/*

* The queue registry is just a means for kernel aware debuggers to locate

* queue structures. It has no other purpose so is an optional component.

*/

#if ( configQUEUE_REGISTRY_SIZE > 0 )

/* The type stored within the queue registry array. This allows a name

* to be assigned to each queue making kernel aware debugging a little

* more user friendly. */

typedef struct QUEUE_REGISTRY_ITEM

{

const char * pcQueueName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

QueueHandle_t xHandle;

} xQueueRegistryItem;

/* The old xQueueRegistryItem name is maintained above then typedefed to the

* new xQueueRegistryItem name below to enable the use of older kernel aware

* debuggers. */

typedef xQueueRegistryItem QueueRegistryItem_t;

/* The queue registry is simply an array of QueueRegistryItem_t structures.

* The pcQueueName member of a structure being NULL is indicative of the

* array position being vacant. */

PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];

#endif /* configQUEUE_REGISTRY_SIZE */

/*

* Unlocks a queue locked by a call to prvLockQueue. Locking a queue does not

* prevent an ISR from adding or removing items to the queue, but does prevent

* an ISR from removing tasks from the queue event lists. If an ISR finds a

* queue is locked it will instead increment the appropriate queue lock count

* to indicate that a task may require unblocking. When the queue in unlocked

* these lock counts are inspected, and the appropriate action taken.

*/

static void prvUnlockQueue( Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;

/*

* Uses a critical section to determine if there is any data in a queue.

*

* @return pdTRUE if the queue contains no items, otherwise pdFALSE.

*/

static BaseType_t prvIsQueueEmpty( const Queue_t * pxQueue ) PRIVILEGED_FUNCTION;

/*

* Uses a critical section to determine if there is any space in a queue.

*

* @return pdTRUE if there is no space, otherwise pdFALSE;

*/

static BaseType_t prvIsQueueFull( const Queue_t * pxQueue ) PRIVILEGED_FUNCTION;

/*

* Copies an item into the queue, either at the front of the queue or the

* back of the queue.

*/

static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue,

const void * pvItemToQueue,

const BaseType_t xPosition ) PRIVILEGED_FUNCTION;

/*

* Copies an item out of a queue.

*/

static void prvCopyDataFromQueue( Queue_t * const pxQueue,

void * const pvBuffer ) PRIVILEGED_FUNCTION;

#if ( configUSE_QUEUE_SETS == 1 )

/*

* Checks to see if a queue is a member of a queue set, and if so, notifies

* the queue set that the queue contains data.

*/

static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;

#endif

/*

* Called after a Queue_t structure has been allocated either statically or

* dynamically to fill in the structure's members.

*/

static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength,

const UBaseType_t uxItemSize,

uint8_t * pucQueueStorage,

const uint8_t ucQueueType,

Queue_t * pxNewQueue ) PRIVILEGED_FUNCTION;

/*

* Mutexes are a special type of queue. When a mutex is created, first the

* queue is created, then prvInitialiseMutex() is called to configure the queue

* as a mutex.

*/

#if ( configUSE_MUTEXES == 1 )

static void prvInitialiseMutex( Queue_t * pxNewQueue ) PRIVILEGED_FUNCTION;

#endif

#if ( configUSE_MUTEXES == 1 )

/*

* If a task waiting for a mutex causes the mutex holder to inherit a

* priority, but the waiting task times out, then the holder should

* disinherit the priority - but only down to the highest priority of any

* other tasks that are waiting for the same mutex. This function returns

* that priority.

*/

static UBaseType_t prvGetDisinheritPriorityAfterTimeout( const Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;

#endif

/*-----------------------------------------------------------*/

/*

* Macro to mark a queue as locked. Locking a queue prevents an ISR from

* accessing the queue event lists.

*/

#define prvLockQueue( pxQueue ) \

taskENTER_CRITICAL(); \

{ \

if( ( pxQueue )->cRxLock == queueUNLOCKED ) \

{ \

( pxQueue )->cRxLock = queueLOCKED_UNMODIFIED; \

} \

if( ( pxQueue )->cTxLock == queueUNLOCKED ) \

{ \

( pxQueue )->cTxLock = queueLOCKED_UNMODIFIED; \

} \

} \

taskEXIT_CRITICAL()

/*

* Macro to increment cTxLock member of the queue data structure. It is

* capped at the number of tasks in the system as we cannot unblock more

* tasks than the number of tasks in the system.

*/

#define prvIncrementQueueTxLock( pxQueue, cTxLock ) \

{ \

const UBaseType_t uxNumberOfTasks = uxTaskGetNumberOfTasks(); \

if( ( UBaseType_t ) ( cTxLock ) < uxNumberOfTasks ) \

{ \

configASSERT( ( cTxLock ) != queueINT8_MAX ); \

( pxQueue )->cTxLock = ( int8_t ) ( ( cTxLock ) + ( int8_t ) 1 ); \

} \

}

/*

* Macro to increment cRxLock member of the queue data structure. It is

* capped at the number of tasks in the system as we cannot unblock more

* tasks than the number of tasks in the system.

*/

#define prvIncrementQueueRxLock( pxQueue, cRxLock ) \

{ \

const UBaseType_t uxNumberOfTasks = uxTaskGetNumberOfTasks(); \

if( ( UBaseType_t ) ( cRxLock ) < uxNumberOfTasks ) \

{ \

configASSERT( ( cRxLock ) != queueINT8_MAX ); \

( pxQueue )->cRxLock = ( int8_t ) ( ( cRxLock ) + ( int8_t ) 1 ); \

} \

}

/*-----------------------------------------------------------*/

BaseType_t xQueueGenericReset( QueueHandle_t xQueue,

BaseType_t xNewQueue )

{

BaseType_t xReturn = pdPASS;

Queue_t * const pxQueue = xQueue;

configASSERT( pxQueue );

if( ( pxQueue != NULL ) &&

( pxQueue->uxLength >= 1U ) &&

/* Check for multiplication overflow. */

( ( SIZE_MAX / pxQueue->uxLength ) >= pxQueue->uxItemSize ) )

{

taskENTER_CRITICAL();

{

pxQueue->u.xQueue.pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;

pxQueue->pcWriteTo = pxQueue->pcHead;

pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - 1U ) * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

pxQueue->cRxLock = queueUNLOCKED;

pxQueue->cTxLock = queueUNLOCKED;

if( xNewQueue == pdFALSE )

{

/* If there are tasks blocked waiting to read from the queue, then

* the tasks will remain blocked as after this function exits the queue

* will still be empty. If there are tasks blocked waiting to write to

* the queue, then one should be unblocked as after this function exits

* it will be possible to write to it. */

if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

{

if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )

{

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

/* Ensure the event queues start in the correct state. */

vListInitialise( &( pxQueue->xTasksWaitingToSend ) );

vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );

}

}

taskEXIT_CRITICAL();

}

else

{

xReturn = pdFAIL;

}

configASSERT( xReturn != pdFAIL );

/* A value is returned for calling semantic consistency with previous

* versions. */

return xReturn;

}

/*-----------------------------------------------------------*/

#if ( configSUPPORT_STATIC_ALLOCATION == 1 )

QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,

const UBaseType_t uxItemSize,

uint8_t * pucQueueStorage,

StaticQueue_t * pxStaticQueue,

const uint8_t ucQueueType )

{

Queue_t * pxNewQueue = NULL;

/* The StaticQueue_t structure and the queue storage area must be

* supplied. */

configASSERT( pxStaticQueue );

if( ( uxQueueLength > ( UBaseType_t ) 0 ) &&

( pxStaticQueue != NULL ) &&

/* A queue storage area should be provided if the item size is not 0, and

* should not be provided if the item size is 0. */

( !( ( pucQueueStorage != NULL ) && ( uxItemSize == 0 ) ) ) &&

( !( ( pucQueueStorage == NULL ) && ( uxItemSize != 0 ) ) ) )

{

#if ( configASSERT_DEFINED == 1 )

{

/* Sanity check that the size of the structure used to declare a

* variable of type StaticQueue_t or StaticSemaphore_t equals the size of

* the real queue and semaphore structures. */

volatile size_t xSize = sizeof( StaticQueue_t );

/* This assertion cannot be branch covered in unit tests */

configASSERT( xSize == sizeof( Queue_t ) ); /* LCOV_EXCL_BR_LINE */

( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */

}

#endif /* configASSERT_DEFINED */

/* The address of a statically allocated queue was passed in, use it.

* The address of a statically allocated storage area was also passed in

* but is already set. */

pxNewQueue = ( Queue_t * ) pxStaticQueue; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */

#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

{

/* Queues can be allocated wither statically or dynamically, so

* note this queue was allocated statically in case the queue is

* later deleted. */

pxNewQueue->ucStaticallyAllocated = pdTRUE;

}

#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );

}

else

{

configASSERT( pxNewQueue );

mtCOVERAGE_TEST_MARKER();

}

return pxNewQueue;

}

#endif /* configSUPPORT_STATIC_ALLOCATION */

/*-----------------------------------------------------------*/

#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength,

const UBaseType_t uxItemSize,

const uint8_t ucQueueType )

{

Queue_t * pxNewQueue = NULL;

size_t xQueueSizeInBytes;

uint8_t * pucQueueStorage;

if( ( uxQueueLength > ( UBaseType_t ) 0 ) &&

/* Check for multiplication overflow. */

( ( SIZE_MAX / uxQueueLength ) >= uxItemSize ) &&

/* Check for addition overflow. */

( ( SIZE_MAX - sizeof( Queue_t ) ) >= ( uxQueueLength * uxItemSize ) ) )

{

/* Allocate enough space to hold the maximum number of items that

* can be in the queue at any time. It is valid for uxItemSize to be

* zero in the case the queue is used as a semaphore. */

xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

/* Allocate the queue and storage area. Justification for MISRA

* deviation as follows: pvPortMalloc() always ensures returned memory

* blocks are aligned per the requirements of the MCU stack. In this case

* pvPortMalloc() must return a pointer that is guaranteed to meet the

* alignment requirements of the Queue_t structure - which in this case

* is an int8_t *. Therefore, whenever the stack alignment requirements

* are greater than or equal to the pointer to char requirements the cast

* is safe. In other cases alignment requirements are not strict (one or

* two bytes). */

pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes ); /*lint !e9087 !e9079 see comment above. */

if( pxNewQueue != NULL )

{

/* Jump past the queue structure to find the location of the queue

* storage area. */

pucQueueStorage = ( uint8_t * ) pxNewQueue;

pucQueueStorage += sizeof( Queue_t ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

#if ( configSUPPORT_STATIC_ALLOCATION == 1 )

{

/* Queues can be created either statically or dynamically, so

* note this task was created dynamically in case it is later

* deleted. */

pxNewQueue->ucStaticallyAllocated = pdFALSE;

}

#endif /* configSUPPORT_STATIC_ALLOCATION */

prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );

}

else

{

traceQUEUE_CREATE_FAILED( ucQueueType );

mtCOVERAGE_TEST_MARKER();

}

}

else

{

configASSERT( pxNewQueue );

mtCOVERAGE_TEST_MARKER();

}

return pxNewQueue;

}

#endif /* configSUPPORT_STATIC_ALLOCATION */

/*-----------------------------------------------------------*/

static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength,

const UBaseType_t uxItemSize,

uint8_t * pucQueueStorage,

const uint8_t ucQueueType,

Queue_t * pxNewQueue )

{

/* Remove compiler warnings about unused parameters should

* configUSE_TRACE_FACILITY not be set to 1. */

( void ) ucQueueType;

if( uxItemSize == ( UBaseType_t ) 0 )

{

/* No RAM was allocated for the queue storage area, but PC head cannot

* be set to NULL because NULL is used as a key to say the queue is used as

* a mutex. Therefore just set pcHead to point to the queue as a benign

* value that is known to be within the memory map. */

pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;

}

else

{

/* Set the head to the start of the queue storage area. */

pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;

}

/* Initialise the queue members as described where the queue type is

* defined. */

pxNewQueue->uxLength = uxQueueLength;

pxNewQueue->uxItemSize = uxItemSize;

( void ) xQueueGenericReset( pxNewQueue, pdTRUE );

#if ( configUSE_TRACE_FACILITY == 1 )

{

pxNewQueue->ucQueueType = ucQueueType;

}

#endif /* configUSE_TRACE_FACILITY */

#if ( configUSE_QUEUE_SETS == 1 )

{

pxNewQueue->pxQueueSetContainer = NULL;

}

#endif /* configUSE_QUEUE_SETS */

traceQUEUE_CREATE( pxNewQueue );

}

/*-----------------------------------------------------------*/

#if ( configUSE_MUTEXES == 1 )

static void prvInitialiseMutex( Queue_t * pxNewQueue )

{

if( pxNewQueue != NULL )

{

/* The queue create function will set all the queue structure members

* correctly for a generic queue, but this function is creating a

* mutex. Overwrite those members that need to be set differently -

* in particular the information required for priority inheritance. */

pxNewQueue->u.xSemaphore.xMutexHolder = NULL;

pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;

/* In case this is a recursive mutex. */

pxNewQueue->u.xSemaphore.uxRecursiveCallCount = 0;

traceCREATE_MUTEX( pxNewQueue );

/* Start with the semaphore in the expected state. */

( void ) xQueueGenericSend( pxNewQueue, NULL, ( TickType_t ) 0U, queueSEND_TO_BACK );

}

else

{

traceCREATE_MUTEX_FAILED();

}

}

#endif /* configUSE_MUTEXES */

/*-----------------------------------------------------------*/

#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )

{

QueueHandle_t xNewQueue;

const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;

xNewQueue = xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );

prvInitialiseMutex( ( Queue_t * ) xNewQueue );

return xNewQueue;

}

#endif /* configUSE_MUTEXES */

/*-----------------------------------------------------------*/

#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType,

StaticQueue_t * pxStaticQueue )

{

QueueHandle_t xNewQueue;

const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;

/* Prevent compiler warnings about unused parameters if

* configUSE_TRACE_FACILITY does not equal 1. */

( void ) ucQueueType;

xNewQueue = xQueueGenericCreateStatic( uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType );

prvInitialiseMutex( ( Queue_t * ) xNewQueue );

return xNewQueue;

}

#endif /* configUSE_MUTEXES */

/*-----------------------------------------------------------*/

#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )

TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore )

{

TaskHandle_t pxReturn;

Queue_t * const pxSemaphore = ( Queue_t * ) xSemaphore;

configASSERT( xSemaphore );

/* This function is called by xSemaphoreGetMutexHolder(), and should not

* be called directly. Note: This is a good way of determining if the

* calling task is the mutex holder, but not a good way of determining the

* identity of the mutex holder, as the holder may change between the

* following critical section exiting and the function returning. */

taskENTER_CRITICAL();

{

if( pxSemaphore->uxQueueType == queueQUEUE_IS_MUTEX )

{

pxReturn = pxSemaphore->u.xSemaphore.xMutexHolder;

}

else

{

pxReturn = NULL;

}

}

taskEXIT_CRITICAL();

return pxReturn;

} /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */

#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */

/*-----------------------------------------------------------*/

#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )

TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore )

{

TaskHandle_t pxReturn;

configASSERT( xSemaphore );

/* Mutexes cannot be used in interrupt service routines, so the mutex

* holder should not change in an ISR, and therefore a critical section is

* not required here. */

if( ( ( Queue_t * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )

{

pxReturn = ( ( Queue_t * ) xSemaphore )->u.xSemaphore.xMutexHolder;

}

else

{

pxReturn = NULL;

}

return pxReturn;

} /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */

#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */

/*-----------------------------------------------------------*/

#if ( configUSE_RECURSIVE_MUTEXES == 1 )

BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex )

{

BaseType_t xReturn;

Queue_t * const pxMutex = ( Queue_t * ) xMutex;

configASSERT( pxMutex );

/* If this is the task that holds the mutex then xMutexHolder will not

* change outside of this task. If this task does not hold the mutex then

* pxMutexHolder can never coincidentally equal the tasks handle, and as

* this is the only condition we are interested in it does not matter if

* pxMutexHolder is accessed simultaneously by another task. Therefore no

* mutual exclusion is required to test the pxMutexHolder variable. */

if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )

{

traceGIVE_MUTEX_RECURSIVE( pxMutex );

/* uxRecursiveCallCount cannot be zero if xMutexHolder is equal to

* the task handle, therefore no underflow check is required. Also,

* uxRecursiveCallCount is only modified by the mutex holder, and as

* there can only be one, no mutual exclusion is required to modify the

* uxRecursiveCallCount member. */

( pxMutex->u.xSemaphore.uxRecursiveCallCount )--;

/* Has the recursive call count unwound to 0? */

if( pxMutex->u.xSemaphore.uxRecursiveCallCount == ( UBaseType_t ) 0 )

{

/* Return the mutex. This will automatically unblock any other

* task that might be waiting to access the mutex. */

( void ) xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );

}

else

{

mtCOVERAGE_TEST_MARKER();

}

xReturn = pdPASS;

}

else

{

/* The mutex cannot be given because the calling task is not the

* holder. */

xReturn = pdFAIL;

traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex );

}

return xReturn;

}

#endif /* configUSE_RECURSIVE_MUTEXES */

/*-----------------------------------------------------------*/

#if ( configUSE_RECURSIVE_MUTEXES == 1 )

BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex,

TickType_t xTicksToWait )

{

BaseType_t xReturn;

Queue_t * const pxMutex = ( Queue_t * ) xMutex;

configASSERT( pxMutex );

/* Comments regarding mutual exclusion as per those within

* xQueueGiveMutexRecursive(). */

traceTAKE_MUTEX_RECURSIVE( pxMutex );

if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )

{

( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;

xReturn = pdPASS;

}

else

{

xReturn = xQueueSemaphoreTake( pxMutex, xTicksToWait );

/* pdPASS will only be returned if the mutex was successfully

* obtained. The calling task may have entered the Blocked state

* before reaching here. */

if( xReturn != pdFAIL )

{

( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;

}

else

{

traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex );

}

}

return xReturn;

}

#endif /* configUSE_RECURSIVE_MUTEXES */

/*-----------------------------------------------------------*/

#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,

const UBaseType_t uxInitialCount,

StaticQueue_t * pxStaticQueue )

{

QueueHandle_t xHandle = NULL;

if( ( uxMaxCount != 0 ) &&

( uxInitialCount <= uxMaxCount ) )

{

xHandle = xQueueGenericCreateStatic( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticQueue, queueQUEUE_TYPE_COUNTING_SEMAPHORE );

if( xHandle != NULL )

{

( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;

traceCREATE_COUNTING_SEMAPHORE();

}

else

{

traceCREATE_COUNTING_SEMAPHORE_FAILED();

}

}

else

{

configASSERT( xHandle );

mtCOVERAGE_TEST_MARKER();

}

return xHandle;

}

#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */

/*-----------------------------------------------------------*/

#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,

const UBaseType_t uxInitialCount )

{

QueueHandle_t xHandle = NULL;

if( ( uxMaxCount != 0 ) &&

( uxInitialCount <= uxMaxCount ) )

{

xHandle = xQueueGenericCreate( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );

if( xHandle != NULL )

{

( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;

traceCREATE_COUNTING_SEMAPHORE();

}

else

{

traceCREATE_COUNTING_SEMAPHORE_FAILED();

}

}

else

{

configASSERT( xHandle );

mtCOVERAGE_TEST_MARKER();

}

return xHandle;

}

#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */

/*-----------------------------------------------------------*/

BaseType_t xQueueGenericSend( QueueHandle_t xQueue,

const void * const pvItemToQueue,

TickType_t xTicksToWait,

const BaseType_t xCopyPosition )

{

BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;

TimeOut_t xTimeOut;

Queue_t * const pxQueue = xQueue;

configASSERT( pxQueue );

configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );

#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )

{

configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );

}

#endif

/*lint -save -e904 This function relaxes the coding standard somewhat to

* allow return statements within the function itself. This is done in the

* interest of execution time efficiency. */

for( ; ; )

{

taskENTER_CRITICAL();

{

/* Is there room on the queue now? The running task must be the

* highest priority task wanting to access the queue. If the head item

* in the queue is to be overwritten then it does not matter if the

* queue is full. */

if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )

{

traceQUEUE_SEND( pxQueue );

#if ( configUSE_QUEUE_SETS == 1 )

{

const UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;

xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

if( pxQueue->pxQueueSetContainer != NULL )

{

if( ( xCopyPosition == queueOVERWRITE ) && ( uxPreviousMessagesWaiting != ( UBaseType_t ) 0 ) )

{

/* Do not notify the queue set as an existing item

* was overwritten in the queue so the number of items

* in the queue has not changed. */

mtCOVERAGE_TEST_MARKER();

}

else if( prvNotifyQueueSetContainer( pxQueue ) != pdFALSE )

{

/* The queue is a member of a queue set, and posting

* to the queue set caused a higher priority task to

* unblock. A context switch is required. */

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

/* If there was a task waiting for data to arrive on the

* queue then unblock it now. */

if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

{

if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

{

/* The unblocked task has a priority higher than

* our own so yield immediately. Yes it is ok to

* do this from within the critical section - the

* kernel takes care of that. */

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else if( xYieldRequired != pdFALSE )

{

/* This path is a special case that will only get

* executed if the task was holding multiple mutexes

* and the mutexes were given back in an order that is

* different to that in which they were taken. */

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

}

#else /* configUSE_QUEUE_SETS */

{

xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

/* If there was a task waiting for data to arrive on the

* queue then unblock it now. */

if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

{

if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

{

/* The unblocked task has a priority higher than

* our own so yield immediately. Yes it is ok to do

* this from within the critical section - the kernel

* takes care of that. */

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else if( xYieldRequired != pdFALSE )

{

/* This path is a special case that will only get

* executed if the task was holding multiple mutexes and

* the mutexes were given back in an order that is

* different to that in which they were taken. */

queueYIELD_IF_USING_PREEMPTION();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

#endif /* configUSE_QUEUE_SETS */

taskEXIT_CRITICAL();

return pdPASS;

}

else

{

if( xTicksToWait == ( TickType_t ) 0 )

{

/* The queue was full and no block time is specified (or

* the block time has expired) so leave now. */

taskEXIT_CRITICAL();

/* Return to the original privilege level before exiting

* the function. */

traceQUEUE_SEND_FAILED( pxQueue );

return errQUEUE_FULL;

}

else if( xEntryTimeSet == pdFALSE )

{

/* The queue was full and a block time was specified so

* configure the timeout structure. */

vTaskInternalSetTimeOutState( &xTimeOut );

xEntryTimeSet = pdTRUE;

}

else

{

/* Entry time was already set. */

mtCOVERAGE_TEST_MARKER();

}

}

}

taskEXIT_CRITICAL();

/* Interrupts and other tasks can send to and receive from the queue

* now the critical section has been exited. */

vTaskSuspendAll();

prvLockQueue( pxQueue );

/* Update the timeout state to see if it has expired yet. */

if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

{

if( prvIsQueueFull( pxQueue ) != pdFALSE )

{

traceBLOCKING_ON_QUEUE_SEND( pxQueue );

vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );