/* | |
* FreeRTOS Kernel V10.3.1 | |
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. | |
* | |
* 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. | |
* | |
* http://www.FreeRTOS.org | |
* http://aws.amazon.com/freertos | |
* | |
* 1 tab == 4 spaces! | |
*/ | |
/* Standard includes. */ | |
#include <stdint.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 | |
/* FreeRTOS includes. */ | |
#include "FreeRTOS.h" | |
#include "task.h" | |
#include "stream_buffer.h" | |
#if( configUSE_TASK_NOTIFICATIONS != 1 ) | |
#error configUSE_TASK_NOTIFICATIONS must be set to 1 to build stream_buffer.c | |
#endif | |
/* Lint e961, e9021 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. */ | |
/* If the user has not provided application specific Rx notification macros, | |
or #defined the notification macros away, them provide default implementations | |
that uses task notifications. */ | |
/*lint -save -e9026 Function like macros allowed and needed here so they can be overidden. */ | |
#ifndef sbRECEIVE_COMPLETED | |
#define sbRECEIVE_COMPLETED( pxStreamBuffer ) \ | |
vTaskSuspendAll(); \ | |
{ \ | |
if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL ) \ | |
{ \ | |
( void ) xTaskNotify( ( pxStreamBuffer )->xTaskWaitingToSend, \ | |
( uint32_t ) 0, \ | |
eNoAction ); \ | |
( pxStreamBuffer )->xTaskWaitingToSend = NULL; \ | |
} \ | |
} \ | |
( void ) xTaskResumeAll(); | |
#endif /* sbRECEIVE_COMPLETED */ | |
#ifndef sbRECEIVE_COMPLETED_FROM_ISR | |
#define sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer, \ | |
pxHigherPriorityTaskWoken ) \ | |
{ \ | |
UBaseType_t uxSavedInterruptStatus; \ | |
\ | |
uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR(); \ | |
{ \ | |
if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL ) \ | |
{ \ | |
( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToSend, \ | |
( uint32_t ) 0, \ | |
eNoAction, \ | |
pxHigherPriorityTaskWoken ); \ | |
( pxStreamBuffer )->xTaskWaitingToSend = NULL; \ | |
} \ | |
} \ | |
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); \ | |
} | |
#endif /* sbRECEIVE_COMPLETED_FROM_ISR */ | |
/* If the user has not provided an application specific Tx notification macro, | |
or #defined the notification macro away, them provide a default implementation | |
that uses task notifications. */ | |
#ifndef sbSEND_COMPLETED | |
#define sbSEND_COMPLETED( pxStreamBuffer ) \ | |
vTaskSuspendAll(); \ | |
{ \ | |
if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL ) \ | |
{ \ | |
( void ) xTaskNotify( ( pxStreamBuffer )->xTaskWaitingToReceive, \ | |
( uint32_t ) 0, \ | |
eNoAction ); \ | |
( pxStreamBuffer )->xTaskWaitingToReceive = NULL; \ | |
} \ | |
} \ | |
( void ) xTaskResumeAll(); | |
#endif /* sbSEND_COMPLETED */ | |
#ifndef sbSEND_COMPLETE_FROM_ISR | |
#define sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken ) \ | |
{ \ | |
UBaseType_t uxSavedInterruptStatus; \ | |
\ | |
uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR(); \ | |
{ \ | |
if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL ) \ | |
{ \ | |
( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToReceive, \ | |
( uint32_t ) 0, \ | |
eNoAction, \ | |
pxHigherPriorityTaskWoken ); \ | |
( pxStreamBuffer )->xTaskWaitingToReceive = NULL; \ | |
} \ | |
} \ | |
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); \ | |
} | |
#endif /* sbSEND_COMPLETE_FROM_ISR */ | |
/*lint -restore (9026) */ | |
/* The number of bytes used to hold the length of a message in the buffer. */ | |
#define sbBYTES_TO_STORE_MESSAGE_LENGTH ( sizeof( configMESSAGE_BUFFER_LENGTH_TYPE ) ) | |
/* Bits stored in the ucFlags field of the stream buffer. */ | |
#define sbFLAGS_IS_MESSAGE_BUFFER ( ( uint8_t ) 1 ) /* Set if the stream buffer was created as a message buffer, in which case it holds discrete messages rather than a stream. */ | |
#define sbFLAGS_IS_STATICALLY_ALLOCATED ( ( uint8_t ) 2 ) /* Set if the stream buffer was created using statically allocated memory. */ | |
/*-----------------------------------------------------------*/ | |
/* Structure that hold state information on the buffer. */ | |
typedef struct StreamBufferDef_t /*lint !e9058 Style convention uses tag. */ | |
{ | |
volatile size_t xTail; /* Index to the next item to read within the buffer. */ | |
volatile size_t xHead; /* Index to the next item to write within the buffer. */ | |
size_t xLength; /* The length of the buffer pointed to by pucBuffer. */ | |
size_t xTriggerLevelBytes; /* The number of bytes that must be in the stream buffer before a task that is waiting for data is unblocked. */ | |
volatile TaskHandle_t xTaskWaitingToReceive; /* Holds the handle of a task waiting for data, or NULL if no tasks are waiting. */ | |
volatile TaskHandle_t xTaskWaitingToSend; /* Holds the handle of a task waiting to send data to a message buffer that is full. */ | |
uint8_t *pucBuffer; /* Points to the buffer itself - that is - the RAM that stores the data passed through the buffer. */ | |
uint8_t ucFlags; | |
#if ( configUSE_TRACE_FACILITY == 1 ) | |
UBaseType_t uxStreamBufferNumber; /* Used for tracing purposes. */ | |
#endif | |
} StreamBuffer_t; | |
/* | |
* The number of bytes available to be read from the buffer. | |
*/ | |
static size_t prvBytesInBuffer( const StreamBuffer_t * const pxStreamBuffer ) PRIVILEGED_FUNCTION; | |
/* | |
* Add xCount bytes from pucData into the pxStreamBuffer message buffer. | |
* Returns the number of bytes written, which will either equal xCount in the | |
* success case, or 0 if there was not enough space in the buffer (in which case | |
* no data is written into the buffer). | |
*/ | |
static size_t prvWriteBytesToBuffer( StreamBuffer_t * const pxStreamBuffer, const uint8_t *pucData, size_t xCount ) PRIVILEGED_FUNCTION; | |
/* | |
* If the stream buffer is being used as a message buffer, then reads an entire | |
* message out of the buffer. If the stream buffer is being used as a stream | |
* buffer then read as many bytes as possible from the buffer. | |
* prvReadBytesFromBuffer() is called to actually extract the bytes from the | |
* buffer's data storage area. | |
*/ | |
static size_t prvReadMessageFromBuffer( StreamBuffer_t *pxStreamBuffer, | |
void *pvRxData, | |
size_t xBufferLengthBytes, | |
size_t xBytesAvailable, | |
size_t xBytesToStoreMessageLength ) PRIVILEGED_FUNCTION; | |
/* | |
* If the stream buffer is being used as a message buffer, then writes an entire | |
* message to the buffer. If the stream buffer is being used as a stream | |
* buffer then write as many bytes as possible to the buffer. | |
* prvWriteBytestoBuffer() is called to actually send the bytes to the buffer's | |
* data storage area. | |
*/ | |
static size_t prvWriteMessageToBuffer( StreamBuffer_t * const pxStreamBuffer, | |
const void * pvTxData, | |
size_t xDataLengthBytes, | |
size_t xSpace, | |
size_t xRequiredSpace ) PRIVILEGED_FUNCTION; | |
/* | |
* Read xMaxCount bytes from the pxStreamBuffer message buffer and write them | |
* to pucData. | |
*/ | |
static size_t prvReadBytesFromBuffer( StreamBuffer_t *pxStreamBuffer, | |
uint8_t *pucData, | |
size_t xMaxCount, | |
size_t xBytesAvailable ) PRIVILEGED_FUNCTION; | |
/* | |
* Called by both pxStreamBufferCreate() and pxStreamBufferCreateStatic() to | |
* initialise the members of the newly created stream buffer structure. | |
*/ | |
static void prvInitialiseNewStreamBuffer( StreamBuffer_t * const pxStreamBuffer, | |
uint8_t * const pucBuffer, | |
size_t xBufferSizeBytes, | |
size_t xTriggerLevelBytes, | |
uint8_t ucFlags ) PRIVILEGED_FUNCTION; | |
/*-----------------------------------------------------------*/ | |
#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) | |
StreamBufferHandle_t xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer ) | |
{ | |
uint8_t *pucAllocatedMemory; | |
uint8_t ucFlags; | |
/* In case the stream buffer is going to be used as a message buffer | |
(that is, it will hold discrete messages with a little meta data that | |
says how big the next message is) check the buffer will be large enough | |
to hold at least one message. */ | |
if( xIsMessageBuffer == pdTRUE ) | |
{ | |
/* Is a message buffer but not statically allocated. */ | |
ucFlags = sbFLAGS_IS_MESSAGE_BUFFER; | |
configASSERT( xBufferSizeBytes > sbBYTES_TO_STORE_MESSAGE_LENGTH ); | |
} | |
else | |
{ | |
/* Not a message buffer and not statically allocated. */ | |
ucFlags = 0; | |
configASSERT( xBufferSizeBytes > 0 ); | |
} | |
configASSERT( xTriggerLevelBytes <= xBufferSizeBytes ); | |
/* A trigger level of 0 would cause a waiting task to unblock even when | |
the buffer was empty. */ | |
if( xTriggerLevelBytes == ( size_t ) 0 ) | |
{ | |
xTriggerLevelBytes = ( size_t ) 1; | |
} | |
/* A stream buffer requires a StreamBuffer_t structure and a buffer. | |
Both are allocated in a single call to pvPortMalloc(). The | |
StreamBuffer_t structure is placed at the start of the allocated memory | |
and the buffer follows immediately after. The requested size is | |
incremented so the free space is returned as the user would expect - | |
this is a quirk of the implementation that means otherwise the free | |
space would be reported as one byte smaller than would be logically | |
expected. */ | |
xBufferSizeBytes++; | |
pucAllocatedMemory = ( uint8_t * ) pvPortMalloc( xBufferSizeBytes + sizeof( StreamBuffer_t ) ); /*lint !e9079 malloc() only returns void*. */ | |
if( pucAllocatedMemory != NULL ) | |
{ | |
prvInitialiseNewStreamBuffer( ( StreamBuffer_t * ) pucAllocatedMemory, /* Structure at the start of the allocated memory. */ /*lint !e9087 Safe cast as allocated memory is aligned. */ /*lint !e826 Area is not too small and alignment is guaranteed provided malloc() behaves as expected and returns aligned buffer. */ | |
pucAllocatedMemory + sizeof( StreamBuffer_t ), /* Storage area follows. */ /*lint !e9016 Indexing past structure valid for uint8_t pointer, also storage area has no alignment requirement. */ | |
xBufferSizeBytes, | |
xTriggerLevelBytes, | |
ucFlags ); | |
traceSTREAM_BUFFER_CREATE( ( ( StreamBuffer_t * ) pucAllocatedMemory ), xIsMessageBuffer ); | |
} | |
else | |
{ | |
traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer ); | |
} | |
return ( StreamBufferHandle_t ) pucAllocatedMemory; /*lint !e9087 !e826 Safe cast as allocated memory is aligned. */ | |
} | |
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */ | |
/*-----------------------------------------------------------*/ | |
#if( configSUPPORT_STATIC_ALLOCATION == 1 ) | |
StreamBufferHandle_t xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, | |
size_t xTriggerLevelBytes, | |
BaseType_t xIsMessageBuffer, | |
uint8_t * const pucStreamBufferStorageArea, | |
StaticStreamBuffer_t * const pxStaticStreamBuffer ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = ( StreamBuffer_t * ) pxStaticStreamBuffer; /*lint !e740 !e9087 Safe cast as StaticStreamBuffer_t is opaque Streambuffer_t. */ | |
StreamBufferHandle_t xReturn; | |
uint8_t ucFlags; | |
configASSERT( pucStreamBufferStorageArea ); | |
configASSERT( pxStaticStreamBuffer ); | |
configASSERT( xTriggerLevelBytes <= xBufferSizeBytes ); | |
/* A trigger level of 0 would cause a waiting task to unblock even when | |
the buffer was empty. */ | |
if( xTriggerLevelBytes == ( size_t ) 0 ) | |
{ | |
xTriggerLevelBytes = ( size_t ) 1; | |
} | |
if( xIsMessageBuffer != pdFALSE ) | |
{ | |
/* Statically allocated message buffer. */ | |
ucFlags = sbFLAGS_IS_MESSAGE_BUFFER | sbFLAGS_IS_STATICALLY_ALLOCATED; | |
} | |
else | |
{ | |
/* Statically allocated stream buffer. */ | |
ucFlags = sbFLAGS_IS_STATICALLY_ALLOCATED; | |
} | |
/* In case the stream buffer is going to be used as a message buffer | |
(that is, it will hold discrete messages with a little meta data that | |
says how big the next message is) check the buffer will be large enough | |
to hold at least one message. */ | |
configASSERT( xBufferSizeBytes > sbBYTES_TO_STORE_MESSAGE_LENGTH ); | |
#if( configASSERT_DEFINED == 1 ) | |
{ | |
/* Sanity check that the size of the structure used to declare a | |
variable of type StaticStreamBuffer_t equals the size of the real | |
message buffer structure. */ | |
volatile size_t xSize = sizeof( StaticStreamBuffer_t ); | |
configASSERT( xSize == sizeof( StreamBuffer_t ) ); | |
} /*lint !e529 xSize is referenced is configASSERT() is defined. */ | |
#endif /* configASSERT_DEFINED */ | |
if( ( pucStreamBufferStorageArea != NULL ) && ( pxStaticStreamBuffer != NULL ) ) | |
{ | |
prvInitialiseNewStreamBuffer( pxStreamBuffer, | |
pucStreamBufferStorageArea, | |
xBufferSizeBytes, | |
xTriggerLevelBytes, | |
ucFlags ); | |
/* Remember this was statically allocated in case it is ever deleted | |
again. */ | |
pxStreamBuffer->ucFlags |= sbFLAGS_IS_STATICALLY_ALLOCATED; | |
traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer ); | |
xReturn = ( StreamBufferHandle_t ) pxStaticStreamBuffer; /*lint !e9087 Data hiding requires cast to opaque type. */ | |
} | |
else | |
{ | |
xReturn = NULL; | |
traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer ); | |
} | |
return xReturn; | |
} | |
#endif /* ( configSUPPORT_STATIC_ALLOCATION == 1 ) */ | |
/*-----------------------------------------------------------*/ | |
void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
StreamBuffer_t * pxStreamBuffer = xStreamBuffer; | |
configASSERT( pxStreamBuffer ); | |
traceSTREAM_BUFFER_DELETE( xStreamBuffer ); | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) pdFALSE ) | |
{ | |
#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) | |
{ | |
/* Both the structure and the buffer were allocated using a single call | |
to pvPortMalloc(), hence only one call to vPortFree() is required. */ | |
vPortFree( ( void * ) pxStreamBuffer ); /*lint !e9087 Standard free() semantics require void *, plus pxStreamBuffer was allocated by pvPortMalloc(). */ | |
} | |
#else | |
{ | |
/* Should not be possible to get here, ucFlags must be corrupt. | |
Force an assert. */ | |
configASSERT( xStreamBuffer == ( StreamBufferHandle_t ) ~0 ); | |
} | |
#endif | |
} | |
else | |
{ | |
/* The structure and buffer were not allocated dynamically and cannot be | |
freed - just scrub the structure so future use will assert. */ | |
( void ) memset( pxStreamBuffer, 0x00, sizeof( StreamBuffer_t ) ); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
BaseType_t xReturn = pdFAIL; | |
#if( configUSE_TRACE_FACILITY == 1 ) | |
UBaseType_t uxStreamBufferNumber; | |
#endif | |
configASSERT( pxStreamBuffer ); | |
#if( configUSE_TRACE_FACILITY == 1 ) | |
{ | |
/* Store the stream buffer number so it can be restored after the | |
reset. */ | |
uxStreamBufferNumber = pxStreamBuffer->uxStreamBufferNumber; | |
} | |
#endif | |
/* Can only reset a message buffer if there are no tasks blocked on it. */ | |
taskENTER_CRITICAL(); | |
{ | |
if( pxStreamBuffer->xTaskWaitingToReceive == NULL ) | |
{ | |
if( pxStreamBuffer->xTaskWaitingToSend == NULL ) | |
{ | |
prvInitialiseNewStreamBuffer( pxStreamBuffer, | |
pxStreamBuffer->pucBuffer, | |
pxStreamBuffer->xLength, | |
pxStreamBuffer->xTriggerLevelBytes, | |
pxStreamBuffer->ucFlags ); | |
xReturn = pdPASS; | |
#if( configUSE_TRACE_FACILITY == 1 ) | |
{ | |
pxStreamBuffer->uxStreamBufferNumber = uxStreamBufferNumber; | |
} | |
#endif | |
traceSTREAM_BUFFER_RESET( xStreamBuffer ); | |
} | |
} | |
} | |
taskEXIT_CRITICAL(); | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
BaseType_t xReturn; | |
configASSERT( pxStreamBuffer ); | |
/* It is not valid for the trigger level to be 0. */ | |
if( xTriggerLevel == ( size_t ) 0 ) | |
{ | |
xTriggerLevel = ( size_t ) 1; | |
} | |
/* The trigger level is the number of bytes that must be in the stream | |
buffer before a task that is waiting for data is unblocked. */ | |
if( xTriggerLevel <= pxStreamBuffer->xLength ) | |
{ | |
pxStreamBuffer->xTriggerLevelBytes = xTriggerLevel; | |
xReturn = pdPASS; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xSpace; | |
configASSERT( pxStreamBuffer ); | |
xSpace = pxStreamBuffer->xLength + pxStreamBuffer->xTail; | |
xSpace -= pxStreamBuffer->xHead; | |
xSpace -= ( size_t ) 1; | |
if( xSpace >= pxStreamBuffer->xLength ) | |
{ | |
xSpace -= pxStreamBuffer->xLength; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
return xSpace; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReturn; | |
configASSERT( pxStreamBuffer ); | |
xReturn = prvBytesInBuffer( pxStreamBuffer ); | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, | |
const void *pvTxData, | |
size_t xDataLengthBytes, | |
TickType_t xTicksToWait ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReturn, xSpace = 0; | |
size_t xRequiredSpace = xDataLengthBytes; | |
TimeOut_t xTimeOut; | |
configASSERT( pvTxData ); | |
configASSERT( pxStreamBuffer ); | |
/* This send function is used to write to both message buffers and stream | |
buffers. If this is a message buffer then the space needed must be | |
increased by the amount of bytes needed to store the length of the | |
message. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xRequiredSpace += sbBYTES_TO_STORE_MESSAGE_LENGTH; | |
/* Overflow? */ | |
configASSERT( xRequiredSpace > xDataLengthBytes ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
if( xTicksToWait != ( TickType_t ) 0 ) | |
{ | |
vTaskSetTimeOutState( &xTimeOut ); | |
do | |
{ | |
/* Wait until the required number of bytes are free in the message | |
buffer. */ | |
taskENTER_CRITICAL(); | |
{ | |
xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer ); | |
if( xSpace < xRequiredSpace ) | |
{ | |
/* Clear notification state as going to wait for space. */ | |
( void ) xTaskNotifyStateClear( NULL ); | |
/* Should only be one writer. */ | |
configASSERT( pxStreamBuffer->xTaskWaitingToSend == NULL ); | |
pxStreamBuffer->xTaskWaitingToSend = xTaskGetCurrentTaskHandle(); | |
} | |
else | |
{ | |
taskEXIT_CRITICAL(); | |
break; | |
} | |
} | |
taskEXIT_CRITICAL(); | |
traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer ); | |
( void ) xTaskNotifyWait( ( uint32_t ) 0, ( uint32_t ) 0, NULL, xTicksToWait ); | |
pxStreamBuffer->xTaskWaitingToSend = NULL; | |
} while( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
if( xSpace == ( size_t ) 0 ) | |
{ | |
xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
xReturn = prvWriteMessageToBuffer( pxStreamBuffer, pvTxData, xDataLengthBytes, xSpace, xRequiredSpace ); | |
if( xReturn > ( size_t ) 0 ) | |
{ | |
traceSTREAM_BUFFER_SEND( xStreamBuffer, xReturn ); | |
/* Was a task waiting for the data? */ | |
if( prvBytesInBuffer( pxStreamBuffer ) >= pxStreamBuffer->xTriggerLevelBytes ) | |
{ | |
sbSEND_COMPLETED( pxStreamBuffer ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer ); | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer, | |
const void *pvTxData, | |
size_t xDataLengthBytes, | |
BaseType_t * const pxHigherPriorityTaskWoken ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReturn, xSpace; | |
size_t xRequiredSpace = xDataLengthBytes; | |
configASSERT( pvTxData ); | |
configASSERT( pxStreamBuffer ); | |
/* This send function is used to write to both message buffers and stream | |
buffers. If this is a message buffer then the space needed must be | |
increased by the amount of bytes needed to store the length of the | |
message. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xRequiredSpace += sbBYTES_TO_STORE_MESSAGE_LENGTH; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer ); | |
xReturn = prvWriteMessageToBuffer( pxStreamBuffer, pvTxData, xDataLengthBytes, xSpace, xRequiredSpace ); | |
if( xReturn > ( size_t ) 0 ) | |
{ | |
/* Was a task waiting for the data? */ | |
if( prvBytesInBuffer( pxStreamBuffer ) >= pxStreamBuffer->xTriggerLevelBytes ) | |
{ | |
sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xReturn ); | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
static size_t prvWriteMessageToBuffer( StreamBuffer_t * const pxStreamBuffer, | |
const void * pvTxData, | |
size_t xDataLengthBytes, | |
size_t xSpace, | |
size_t xRequiredSpace ) | |
{ | |
BaseType_t xShouldWrite; | |
size_t xReturn; | |
if( xSpace == ( size_t ) 0 ) | |
{ | |
/* Doesn't matter if this is a stream buffer or a message buffer, there | |
is no space to write. */ | |
xShouldWrite = pdFALSE; | |
} | |
else if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) == ( uint8_t ) 0 ) | |
{ | |
/* This is a stream buffer, as opposed to a message buffer, so writing a | |
stream of bytes rather than discrete messages. Write as many bytes as | |
possible. */ | |
xShouldWrite = pdTRUE; | |
xDataLengthBytes = configMIN( xDataLengthBytes, xSpace ); | |
} | |
else if( xSpace >= xRequiredSpace ) | |
{ | |
/* This is a message buffer, as opposed to a stream buffer, and there | |
is enough space to write both the message length and the message itself | |
into the buffer. Start by writing the length of the data, the data | |
itself will be written later in this function. */ | |
xShouldWrite = pdTRUE; | |
( void ) prvWriteBytesToBuffer( pxStreamBuffer, ( const uint8_t * ) &( xDataLengthBytes ), sbBYTES_TO_STORE_MESSAGE_LENGTH ); | |
} | |
else | |
{ | |
/* There is space available, but not enough space. */ | |
xShouldWrite = pdFALSE; | |
} | |
if( xShouldWrite != pdFALSE ) | |
{ | |
/* Writes the data itself. */ | |
xReturn = prvWriteBytesToBuffer( pxStreamBuffer, ( const uint8_t * ) pvTxData, xDataLengthBytes ); /*lint !e9079 Storage buffer is implemented as uint8_t for ease of sizing, alighment and access. */ | |
} | |
else | |
{ | |
xReturn = 0; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, | |
void *pvRxData, | |
size_t xBufferLengthBytes, | |
TickType_t xTicksToWait ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReceivedLength = 0, xBytesAvailable, xBytesToStoreMessageLength; | |
configASSERT( pvRxData ); | |
configASSERT( pxStreamBuffer ); | |
/* This receive function is used by both message buffers, which store | |
discrete messages, and stream buffers, which store a continuous stream of | |
bytes. Discrete messages include an additional | |
sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the | |
message. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH; | |
} | |
else | |
{ | |
xBytesToStoreMessageLength = 0; | |
} | |
if( xTicksToWait != ( TickType_t ) 0 ) | |
{ | |
/* Checking if there is data and clearing the notification state must be | |
performed atomically. */ | |
taskENTER_CRITICAL(); | |
{ | |
xBytesAvailable = prvBytesInBuffer( pxStreamBuffer ); | |
/* If this function was invoked by a message buffer read then | |
xBytesToStoreMessageLength holds the number of bytes used to hold | |
the length of the next discrete message. If this function was | |
invoked by a stream buffer read then xBytesToStoreMessageLength will | |
be 0. */ | |
if( xBytesAvailable <= xBytesToStoreMessageLength ) | |
{ | |
/* Clear notification state as going to wait for data. */ | |
( void ) xTaskNotifyStateClear( NULL ); | |
/* Should only be one reader. */ | |
configASSERT( pxStreamBuffer->xTaskWaitingToReceive == NULL ); | |
pxStreamBuffer->xTaskWaitingToReceive = xTaskGetCurrentTaskHandle(); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
taskEXIT_CRITICAL(); | |
if( xBytesAvailable <= xBytesToStoreMessageLength ) | |
{ | |
/* Wait for data to be available. */ | |
traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer ); | |
( void ) xTaskNotifyWait( ( uint32_t ) 0, ( uint32_t ) 0, NULL, xTicksToWait ); | |
pxStreamBuffer->xTaskWaitingToReceive = NULL; | |
/* Recheck the data available after blocking. */ | |
xBytesAvailable = prvBytesInBuffer( pxStreamBuffer ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
xBytesAvailable = prvBytesInBuffer( pxStreamBuffer ); | |
} | |
/* Whether receiving a discrete message (where xBytesToStoreMessageLength | |
holds the number of bytes used to store the message length) or a stream of | |
bytes (where xBytesToStoreMessageLength is zero), the number of bytes | |
available must be greater than xBytesToStoreMessageLength to be able to | |
read bytes from the buffer. */ | |
if( xBytesAvailable > xBytesToStoreMessageLength ) | |
{ | |
xReceivedLength = prvReadMessageFromBuffer( pxStreamBuffer, pvRxData, xBufferLengthBytes, xBytesAvailable, xBytesToStoreMessageLength ); | |
/* Was a task waiting for space in the buffer? */ | |
if( xReceivedLength != ( size_t ) 0 ) | |
{ | |
traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength ); | |
sbRECEIVE_COMPLETED( pxStreamBuffer ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer ); | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
return xReceivedLength; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReturn, xBytesAvailable, xOriginalTail; | |
configMESSAGE_BUFFER_LENGTH_TYPE xTempReturn; | |
configASSERT( pxStreamBuffer ); | |
/* Ensure the stream buffer is being used as a message buffer. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xBytesAvailable = prvBytesInBuffer( pxStreamBuffer ); | |
if( xBytesAvailable > sbBYTES_TO_STORE_MESSAGE_LENGTH ) | |
{ | |
/* The number of bytes available is greater than the number of bytes | |
required to hold the length of the next message, so another message | |
is available. Return its length without removing the length bytes | |
from the buffer. A copy of the tail is stored so the buffer can be | |
returned to its prior state as the message is not actually being | |
removed from the buffer. */ | |
xOriginalTail = pxStreamBuffer->xTail; | |
( void ) prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) &xTempReturn, sbBYTES_TO_STORE_MESSAGE_LENGTH, xBytesAvailable ); | |
xReturn = ( size_t ) xTempReturn; | |
pxStreamBuffer->xTail = xOriginalTail; | |
} | |
else | |
{ | |
/* The minimum amount of bytes in a message buffer is | |
( sbBYTES_TO_STORE_MESSAGE_LENGTH + 1 ), so if xBytesAvailable is | |
less than sbBYTES_TO_STORE_MESSAGE_LENGTH the only other valid | |
value is 0. */ | |
configASSERT( xBytesAvailable == 0 ); | |
xReturn = 0; | |
} | |
} | |
else | |
{ | |
xReturn = 0; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer, | |
void *pvRxData, | |
size_t xBufferLengthBytes, | |
BaseType_t * const pxHigherPriorityTaskWoken ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
size_t xReceivedLength = 0, xBytesAvailable, xBytesToStoreMessageLength; | |
configASSERT( pvRxData ); | |
configASSERT( pxStreamBuffer ); | |
/* This receive function is used by both message buffers, which store | |
discrete messages, and stream buffers, which store a continuous stream of | |
bytes. Discrete messages include an additional | |
sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the | |
message. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH; | |
} | |
else | |
{ | |
xBytesToStoreMessageLength = 0; | |
} | |
xBytesAvailable = prvBytesInBuffer( pxStreamBuffer ); | |
/* Whether receiving a discrete message (where xBytesToStoreMessageLength | |
holds the number of bytes used to store the message length) or a stream of | |
bytes (where xBytesToStoreMessageLength is zero), the number of bytes | |
available must be greater than xBytesToStoreMessageLength to be able to | |
read bytes from the buffer. */ | |
if( xBytesAvailable > xBytesToStoreMessageLength ) | |
{ | |
xReceivedLength = prvReadMessageFromBuffer( pxStreamBuffer, pvRxData, xBufferLengthBytes, xBytesAvailable, xBytesToStoreMessageLength ); | |
/* Was a task waiting for space in the buffer? */ | |
if( xReceivedLength != ( size_t ) 0 ) | |
{ | |
sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken ); | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength ); | |
return xReceivedLength; | |
} | |
/*-----------------------------------------------------------*/ | |
static size_t prvReadMessageFromBuffer( StreamBuffer_t *pxStreamBuffer, | |
void *pvRxData, | |
size_t xBufferLengthBytes, | |
size_t xBytesAvailable, | |
size_t xBytesToStoreMessageLength ) | |
{ | |
size_t xOriginalTail, xReceivedLength, xNextMessageLength; | |
configMESSAGE_BUFFER_LENGTH_TYPE xTempNextMessageLength; | |
if( xBytesToStoreMessageLength != ( size_t ) 0 ) | |
{ | |
/* A discrete message is being received. First receive the length | |
of the message. A copy of the tail is stored so the buffer can be | |
returned to its prior state if the length of the message is too | |
large for the provided buffer. */ | |
xOriginalTail = pxStreamBuffer->xTail; | |
( void ) prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) &xTempNextMessageLength, xBytesToStoreMessageLength, xBytesAvailable ); | |
xNextMessageLength = ( size_t ) xTempNextMessageLength; | |
/* Reduce the number of bytes available by the number of bytes just | |
read out. */ | |
xBytesAvailable -= xBytesToStoreMessageLength; | |
/* Check there is enough space in the buffer provided by the | |
user. */ | |
if( xNextMessageLength > xBufferLengthBytes ) | |
{ | |
/* The user has provided insufficient space to read the message | |
so return the buffer to its previous state (so the length of | |
the message is in the buffer again). */ | |
pxStreamBuffer->xTail = xOriginalTail; | |
xNextMessageLength = 0; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
} | |
else | |
{ | |
/* A stream of bytes is being received (as opposed to a discrete | |
message), so read as many bytes as possible. */ | |
xNextMessageLength = xBufferLengthBytes; | |
} | |
/* Read the actual data. */ | |
xReceivedLength = prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) pvRxData, xNextMessageLength, xBytesAvailable ); /*lint !e9079 Data storage area is implemented as uint8_t array for ease of sizing, indexing and alignment. */ | |
return xReceivedLength; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
BaseType_t xReturn; | |
size_t xTail; | |
configASSERT( pxStreamBuffer ); | |
/* True if no bytes are available. */ | |
xTail = pxStreamBuffer->xTail; | |
if( pxStreamBuffer->xHead == xTail ) | |
{ | |
xReturn = pdTRUE; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
BaseType_t xReturn; | |
size_t xBytesToStoreMessageLength; | |
const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
configASSERT( pxStreamBuffer ); | |
/* This generic version of the receive function is used by both message | |
buffers, which store discrete messages, and stream buffers, which store a | |
continuous stream of bytes. Discrete messages include an additional | |
sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the message. */ | |
if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 ) | |
{ | |
xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH; | |
} | |
else | |
{ | |
xBytesToStoreMessageLength = 0; | |
} | |
/* True if the available space equals zero. */ | |
if( xStreamBufferSpacesAvailable( xStreamBuffer ) <= xBytesToStoreMessageLength ) | |
{ | |
xReturn = pdTRUE; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
BaseType_t xReturn; | |
UBaseType_t uxSavedInterruptStatus; | |
configASSERT( pxStreamBuffer ); | |
uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR(); | |
{ | |
if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL ) | |
{ | |
( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToReceive, | |
( uint32_t ) 0, | |
eNoAction, | |
pxHigherPriorityTaskWoken ); | |
( pxStreamBuffer )->xTaskWaitingToReceive = NULL; | |
xReturn = pdTRUE; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
} | |
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken ) | |
{ | |
StreamBuffer_t * const pxStreamBuffer = xStreamBuffer; | |
BaseType_t xReturn; | |
UBaseType_t uxSavedInterruptStatus; | |
configASSERT( pxStreamBuffer ); | |
uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR(); | |
{ | |
if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL ) | |
{ | |
( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToSend, | |
( uint32_t ) 0, | |
eNoAction, | |
pxHigherPriorityTaskWoken ); | |
( pxStreamBuffer )->xTaskWaitingToSend = NULL; | |
xReturn = pdTRUE; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
} | |
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
static size_t prvWriteBytesToBuffer( StreamBuffer_t * const pxStreamBuffer, const uint8_t *pucData, size_t xCount ) | |
{ | |
size_t xNextHead, xFirstLength; | |
configASSERT( xCount > ( size_t ) 0 ); | |
xNextHead = pxStreamBuffer->xHead; | |
/* Calculate the number of bytes that can be added in the first write - | |
which may be less than the total number of bytes that need to be added if | |
the buffer will wrap back to the beginning. */ | |
xFirstLength = configMIN( pxStreamBuffer->xLength - xNextHead, xCount ); | |
/* Write as many bytes as can be written in the first write. */ | |
configASSERT( ( xNextHead + xFirstLength ) <= pxStreamBuffer->xLength ); | |
( void ) memcpy( ( void* ) ( &( pxStreamBuffer->pucBuffer[ xNextHead ] ) ), ( const void * ) pucData, xFirstLength ); /*lint !e9087 memcpy() requires void *. */ | |
/* If the number of bytes written was less than the number that could be | |
written in the first write... */ | |
if( xCount > xFirstLength ) | |
{ | |
/* ...then write the remaining bytes to the start of the buffer. */ | |
configASSERT( ( xCount - xFirstLength ) <= pxStreamBuffer->xLength ); | |
( void ) memcpy( ( void * ) pxStreamBuffer->pucBuffer, ( const void * ) &( pucData[ xFirstLength ] ), xCount - xFirstLength ); /*lint !e9087 memcpy() requires void *. */ | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
xNextHead += xCount; | |
if( xNextHead >= pxStreamBuffer->xLength ) | |
{ | |
xNextHead -= pxStreamBuffer->xLength; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
pxStreamBuffer->xHead = xNextHead; | |
return xCount; | |
} | |
/*-----------------------------------------------------------*/ | |
static size_t prvReadBytesFromBuffer( StreamBuffer_t *pxStreamBuffer, uint8_t *pucData, size_t xMaxCount, size_t xBytesAvailable ) | |
{ | |
size_t xCount, xFirstLength, xNextTail; | |
/* Use the minimum of the wanted bytes and the available bytes. */ | |
xCount = configMIN( xBytesAvailable, xMaxCount ); | |
if( xCount > ( size_t ) 0 ) | |
{ | |
xNextTail = pxStreamBuffer->xTail; | |
/* Calculate the number of bytes that can be read - which may be | |
less than the number wanted if the data wraps around to the start of | |
the buffer. */ | |
xFirstLength = configMIN( pxStreamBuffer->xLength - xNextTail, xCount ); | |
/* Obtain the number of bytes it is possible to obtain in the first | |
read. Asserts check bounds of read and write. */ | |
configASSERT( xFirstLength <= xMaxCount ); | |
configASSERT( ( xNextTail + xFirstLength ) <= pxStreamBuffer->xLength ); | |
( void ) memcpy( ( void * ) pucData, ( const void * ) &( pxStreamBuffer->pucBuffer[ xNextTail ] ), xFirstLength ); /*lint !e9087 memcpy() requires void *. */ | |
/* If the total number of wanted bytes is greater than the number | |
that could be read in the first read... */ | |
if( xCount > xFirstLength ) | |
{ | |
/*...then read the remaining bytes from the start of the buffer. */ | |
configASSERT( xCount <= xMaxCount ); | |
( void ) memcpy( ( void * ) &( pucData[ xFirstLength ] ), ( void * ) ( pxStreamBuffer->pucBuffer ), xCount - xFirstLength ); /*lint !e9087 memcpy() requires void *. */ | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
/* Move the tail pointer to effectively remove the data read from | |
the buffer. */ | |
xNextTail += xCount; | |
if( xNextTail >= pxStreamBuffer->xLength ) | |
{ | |
xNextTail -= pxStreamBuffer->xLength; | |
} | |
pxStreamBuffer->xTail = xNextTail; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
return xCount; | |
} | |
/*-----------------------------------------------------------*/ | |
static size_t prvBytesInBuffer( const StreamBuffer_t * const pxStreamBuffer ) | |
{ | |
/* Returns the distance between xTail and xHead. */ | |
size_t xCount; | |
xCount = pxStreamBuffer->xLength + pxStreamBuffer->xHead; | |
xCount -= pxStreamBuffer->xTail; | |
if ( xCount >= pxStreamBuffer->xLength ) | |
{ | |
xCount -= pxStreamBuffer->xLength; | |
} | |
else | |
{ | |
mtCOVERAGE_TEST_MARKER(); | |
} | |
return xCount; | |
} | |
/*-----------------------------------------------------------*/ | |
static void prvInitialiseNewStreamBuffer( StreamBuffer_t * const pxStreamBuffer, | |
uint8_t * const pucBuffer, | |
size_t xBufferSizeBytes, | |
size_t xTriggerLevelBytes, | |
uint8_t ucFlags ) | |
{ | |
/* Assert here is deliberately writing to the entire buffer to ensure it can | |
be written to without generating exceptions, and is setting the buffer to a | |
known value to assist in development/debugging. */ | |
#if( configASSERT_DEFINED == 1 ) | |
{ | |
/* The value written just has to be identifiable when looking at the | |
memory. Don't use 0xA5 as that is the stack fill value and could | |
result in confusion as to what is actually being observed. */ | |
const BaseType_t xWriteValue = 0x55; | |
configASSERT( memset( pucBuffer, ( int ) xWriteValue, xBufferSizeBytes ) == pucBuffer ); | |
} /*lint !e529 !e438 xWriteValue is only used if configASSERT() is defined. */ | |
#endif | |
( void ) memset( ( void * ) pxStreamBuffer, 0x00, sizeof( StreamBuffer_t ) ); /*lint !e9087 memset() requires void *. */ | |
pxStreamBuffer->pucBuffer = pucBuffer; | |
pxStreamBuffer->xLength = xBufferSizeBytes; | |
pxStreamBuffer->xTriggerLevelBytes = xTriggerLevelBytes; | |
pxStreamBuffer->ucFlags = ucFlags; | |
} | |
#if ( configUSE_TRACE_FACILITY == 1 ) | |
UBaseType_t uxStreamBufferGetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
return xStreamBuffer->uxStreamBufferNumber; | |
} | |
#endif /* configUSE_TRACE_FACILITY */ | |
/*-----------------------------------------------------------*/ | |
#if ( configUSE_TRACE_FACILITY == 1 ) | |
void vStreamBufferSetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer, UBaseType_t uxStreamBufferNumber ) | |
{ | |
xStreamBuffer->uxStreamBufferNumber = uxStreamBufferNumber; | |
} | |
#endif /* configUSE_TRACE_FACILITY */ | |
/*-----------------------------------------------------------*/ | |
#if ( configUSE_TRACE_FACILITY == 1 ) | |
uint8_t ucStreamBufferGetStreamBufferType( StreamBufferHandle_t xStreamBuffer ) | |
{ | |
return ( xStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ); | |
} | |
#endif /* configUSE_TRACE_FACILITY */ | |
/*-----------------------------------------------------------*/ |