/* | |
* FreeRTOS+TCP Labs Build 160919 (C) 2016 Real Time Engineers ltd. | |
* Authors include Hein Tibosch and Richard Barry | |
* | |
******************************************************************************* | |
***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE *** | |
*** *** | |
*** *** | |
*** FREERTOS+TCP IS STILL IN THE LAB (mainly because the FTP and HTTP *** | |
*** demos have a dependency on FreeRTOS+FAT, which is only in the Labs *** | |
*** download): *** | |
*** *** | |
*** FreeRTOS+TCP is functional and has been used in commercial products *** | |
*** for some time. Be aware however that we are still refining its *** | |
*** design, the source code does not yet quite conform to the strict *** | |
*** coding and style standards mandated by Real Time Engineers ltd., and *** | |
*** the documentation and testing is not necessarily complete. *** | |
*** *** | |
*** PLEASE REPORT EXPERIENCES USING THE SUPPORT RESOURCES FOUND ON THE *** | |
*** URL: http://www.FreeRTOS.org/contact Active early adopters may, at *** | |
*** the sole discretion of Real Time Engineers Ltd., be offered versions *** | |
*** under a license other than that described below. *** | |
*** *** | |
*** *** | |
***** NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE ******* NOTE *** | |
******************************************************************************* | |
* | |
* FreeRTOS+TCP can be used under two different free open source licenses. The | |
* license that applies is dependent on the processor on which FreeRTOS+TCP is | |
* executed, as follows: | |
* | |
* If FreeRTOS+TCP is executed on one of the processors listed under the Special | |
* License Arrangements heading of the FreeRTOS+TCP license information web | |
* page, then it can be used under the terms of the FreeRTOS Open Source | |
* License. If FreeRTOS+TCP is used on any other processor, then it can be used | |
* under the terms of the GNU General Public License V2. Links to the relevant | |
* licenses follow: | |
* | |
* The FreeRTOS+TCP License Information Page: http://www.FreeRTOS.org/tcp_license | |
* The FreeRTOS Open Source License: http://www.FreeRTOS.org/license | |
* The GNU General Public License Version 2: http://www.FreeRTOS.org/gpl-2.0.txt | |
* | |
* FreeRTOS+TCP is distributed in the hope that it will be useful. You cannot | |
* use FreeRTOS+TCP unless you agree that you use the software 'as is'. | |
* FreeRTOS+TCP is provided WITHOUT ANY WARRANTY; without even the implied | |
* warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR | |
* PURPOSE. Real Time Engineers Ltd. disclaims all conditions and terms, be they | |
* implied, expressed, or statutory. | |
* | |
* 1 tab == 4 spaces! | |
* | |
* http://www.FreeRTOS.org | |
* http://www.FreeRTOS.org/plus | |
* http://www.FreeRTOS.org/labs | |
* | |
*/ | |
/****************************************************************************** | |
* | |
* See the following web page for essential buffer allocation scheme usage and | |
* configuration details: | |
* http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/Embedded_Ethernet_Buffer_Management.html | |
* | |
******************************************************************************/ | |
/* THIS FILE SHOULD NOT BE USED IF THE PROJECT INCLUDES A MEMORY ALLOCATOR | |
* THAT WILL FRAGMENT THE HEAP MEMORY. For example, heap_2 must not be used, | |
* heap_4 can be used. */ | |
/* Standard includes. */ | |
#include <stdint.h> | |
/* FreeRTOS includes. */ | |
#include "FreeRTOS.h" | |
#include "task.h" | |
#include "semphr.h" | |
/* FreeRTOS+TCP includes. */ | |
#include "FreeRTOS_IP.h" | |
#include "FreeRTOS_UDP_IP.h" | |
#include "FreeRTOS_IP_Private.h" | |
#include "NetworkInterface.h" | |
#include "NetworkBufferManagement.h" | |
#include "tcpip/tcpip.h" | |
#include "tcpip/src/tcpip_private.h" | |
#include "NetworkConfig.h" | |
/* The obtained network buffer must be large enough to hold a packet that might | |
* replace the packet that was requested to be sent. */ | |
#if ipconfigUSE_TCP == 1 | |
#define baMINIMAL_BUFFER_SIZE sizeof( TCPPacket_t ) | |
#else | |
#define baMINIMAL_BUFFER_SIZE sizeof( ARPPacket_t ) | |
#endif /* ipconfigUSE_TCP == 1 */ | |
/*_RB_ This is too complex not to have an explanation. */ | |
#if defined( ipconfigETHERNET_MINIMUM_PACKET_BYTES ) | |
#define ASSERT_CONCAT_( a, b ) a ## b | |
#define ASSERT_CONCAT( a, b ) ASSERT_CONCAT_( a, b ) | |
#define STATIC_ASSERT( e ) \ | |
; enum { ASSERT_CONCAT( assert_line_, __LINE__ ) = 1 / ( !!( e ) ) } | |
STATIC_ASSERT( ipconfigETHERNET_MINIMUM_PACKET_BYTES <= baMINIMAL_BUFFER_SIZE ); | |
#endif | |
/* A list of free (available) NetworkBufferDescriptor_t structures. */ | |
static List_t xFreeBuffersList; | |
/* Some statistics about the use of buffers. */ | |
static size_t uxMinimumFreeNetworkBuffers; | |
/* Declares the pool of NetworkBufferDescriptor_t structures that are available | |
* to the system. All the network buffers referenced from xFreeBuffersList exist | |
* in this array. The array is not accessed directly except during initialisation, | |
* when the xFreeBuffersList is filled (as all the buffers are free when the system | |
* is booted). */ | |
static NetworkBufferDescriptor_t xNetworkBufferDescriptors[ ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS ]; | |
/* This constant is defined as false to let FreeRTOS_TCP_IP.c know that the | |
* network buffers have a variable size: resizing may be necessary */ | |
const BaseType_t xBufferAllocFixedSize = pdFALSE; | |
/* The semaphore used to obtain network buffers. */ | |
static SemaphoreHandle_t xNetworkBufferSemaphore = NULL; | |
/*-----------------------------------------------------------*/ | |
#ifdef PIC32_USE_ETHERNET | |
/* PIC32 specific stuff */ | |
/* */ | |
/* MAC packet acknowledgment, once MAC is done with it */ | |
static bool PIC32_MacPacketAcknowledge( TCPIP_MAC_PACKET * pPkt, | |
const void * param ); | |
/* allocates a MAC packet that holds a data buffer that can be used by both: */ | |
/* - the FreeRTOSIP (NetworkBufferDescriptor_t->pucEthernetBuffer) */ | |
/* - the Harmony MAC driver: TCPIP_MAC_PACKET->pDSeg->segLoad */ | |
/* from the beginning of the buffer: */ | |
/* - 4 bytes pointer to the network descriptor (FreeRTOS) */ | |
/* - 4 bytes pointer to the MAC packet (pic32_NetworkInterface.c) */ | |
/* - 2 bytes offset from the MAC packet (Harmony MAC driver: segLoadOffset) */ | |
/* */ | |
/* NOTE: segLoadLen should NOT include: */ | |
/* - the TCPIP_MAC_FRAME_OFFSET (== ipBUFFER_PADDING which should be == 10!) */ | |
/* - the sizeof(TCPIP_MAC_ETHERNET_HEADER) */ | |
/* These are added by the MAC packet allocation! */ | |
/* */ | |
static uint8_t * PIC32_PktAlloc( uint16_t pktLen, | |
uint16_t segLoadLen, | |
TCPIP_MAC_PACKET_ACK_FUNC ackF, | |
TCPIP_MAC_PACKET ** pPtrPkt ) | |
{ | |
uint8_t * pBuff = 0; | |
/* allocate standard packet */ | |
TCPIP_MAC_PACKET * pPkt = TCPIP_PKT_PacketAlloc( pktLen, segLoadLen, 0 ); | |
/* set the MAC packet pointer in the packet */ | |
if( pPkt != 0 ) | |
{ | |
pBuff = pPkt->pDSeg->segLoad; | |
TCPIP_MAC_PACKET ** ppkt = ( TCPIP_MAC_PACKET ** ) ( pBuff - PIC32_BUFFER_PKT_PTR_OSSET ); | |
configASSERT( ( ( uint32_t ) ppkt & ( sizeof( uint32_t ) - 1 ) ) == 0 ); | |
*ppkt = pPkt; /* store the packet it comes from */ | |
pPkt->ackFunc = ackF; | |
pPkt->ackParam = 0; | |
} | |
if( pPtrPkt != 0 ) | |
{ | |
*pPtrPkt = pPkt; | |
} | |
return pBuff; | |
} | |
/* standard PIC32 MAC allocation function for a MAC packet */ | |
/* this packet saves room for the FreeRTOS network descriptor */ | |
/* at the beginning of the data buffer */ | |
/* see NetworkBufferAllocate */ | |
/* Note: flags parameter is ignored since that's used in the Harmony stack only */ | |
TCPIP_MAC_PACKET * PIC32_MacPacketAllocate( uint16_t pktLen, | |
uint16_t segLoadLen, | |
TCPIP_MAC_PACKET_FLAGS flags ) | |
{ | |
TCPIP_MAC_PACKET * pPkt; | |
PIC32_PktAlloc( pktLen, segLoadLen, 0, &pPkt ); | |
return pPkt; | |
} | |
/* standard PIC32 MAC packet acknowledgment */ | |
/* function called once MAC is done with it */ | |
static bool PIC32_MacPacketAcknowledge( TCPIP_MAC_PACKET * pPkt, | |
const void * param ) | |
{ | |
configASSERT( ( pPkt != 0 ) ); | |
TCPIP_PKT_PacketFree( pPkt ); | |
return false; | |
} | |
/* associates the current MAC packet with a network descriptor */ | |
/* mainly for RX packet */ | |
void PIC32_MacAssociate( TCPIP_MAC_PACKET * pRxPkt, | |
NetworkBufferDescriptor_t * pxBufferDescriptor, | |
size_t pktLength ) | |
{ | |
uint8_t * pPktBuff = pRxPkt->pDSeg->segLoad; | |
pxBufferDescriptor->pucEthernetBuffer = pPktBuff; | |
pxBufferDescriptor->xDataLength = pktLength; | |
/* make sure this is a properly allocated packet */ | |
TCPIP_MAC_PACKET ** ppkt = ( TCPIP_MAC_PACKET ** ) ( pPktBuff - PIC32_BUFFER_PKT_PTR_OSSET ); | |
configASSERT( ( ( uint32_t ) ppkt & ( sizeof( uint32_t ) - 1 ) ) == 0 ); | |
if( *ppkt != pRxPkt ) | |
{ | |
configASSERT( false ); | |
} | |
/* set the proper descriptor info */ | |
NetworkBufferDescriptor_t ** ppDcpt = ( NetworkBufferDescriptor_t ** ) ( pPktBuff - ipBUFFER_PADDING ); | |
configASSERT( ( ( uint32_t ) ppDcpt & ( sizeof( uint32_t ) - 1 ) ) == 0 ); | |
*ppDcpt = pxBufferDescriptor; | |
} | |
/* debug functionality */ | |
void PIC32_MacPacketOrphan( TCPIP_MAC_PACKET * pPkt ) | |
{ | |
TCPIP_PKT_PacketFree( pPkt ); | |
configASSERT( false ); | |
} | |
/* FreeRTOS allocation functions */ | |
/* allocates a buffer that can be used by both: */ | |
/* - the FreeRTOSIP (NetworkBufferDescriptor_t->pucEthernetBuffer) */ | |
/* - the Harmony MAC driver: TCPIP_MAC_PACKET */ | |
/* See PIC32_PktAlloc for details */ | |
/* */ | |
/* NOTE: reqLength should NOT include the ipBUFFER_PADDING (which should be == 10!) */ | |
/* or the sizeof(TCPIP_MAC_ETHERNET_HEADER) */ | |
/* These are added by the MAC packet allocation! */ | |
/* */ | |
uint8_t * NetworkBufferAllocate( size_t reqLength ) | |
{ | |
return PIC32_PktAlloc( sizeof( TCPIP_MAC_PACKET ), reqLength, PIC32_MacPacketAcknowledge, 0 ); | |
} | |
/* deallocates a network buffer previously allocated */ | |
/* with NetworkBufferAllocate */ | |
void NetworkBufferFree( uint8_t * pNetworkBuffer ) | |
{ | |
if( pNetworkBuffer != 0 ) | |
{ | |
TCPIP_MAC_PACKET ** ppkt = ( TCPIP_MAC_PACKET ** ) ( pNetworkBuffer - PIC32_BUFFER_PKT_PTR_OSSET ); | |
configASSERT( ( ( uint32_t ) ppkt & ( sizeof( uint32_t ) - 1 ) ) == 0 ); | |
TCPIP_MAC_PACKET * pPkt = *ppkt; | |
configASSERT( ( pPkt != 0 ) ); | |
if( pPkt->ackFunc != 0 ) | |
{ | |
( *pPkt->ackFunc )( pPkt, pPkt->ackParam ); | |
} | |
else | |
{ /* ??? */ | |
PIC32_MacPacketOrphan( pPkt ); | |
} | |
} | |
} | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
/*-----------------------------------------------------------*/ | |
BaseType_t xNetworkBuffersInitialise( void ) | |
{ | |
BaseType_t xReturn, x; | |
/* Only initialise the buffers and their associated kernel objects if they | |
* have not been initialised before. */ | |
if( xNetworkBufferSemaphore == NULL ) | |
{ | |
xNetworkBufferSemaphore = xSemaphoreCreateCounting( ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS, ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS ); | |
configASSERT( xNetworkBufferSemaphore ); | |
if( xNetworkBufferSemaphore != NULL ) | |
{ | |
#if ( configQUEUE_REGISTRY_SIZE > 0 ) | |
{ | |
vQueueAddToRegistry( xNetworkBufferSemaphore, "NetBufSem" ); | |
} | |
#endif /* configQUEUE_REGISTRY_SIZE */ | |
/* If the trace recorder code is included name the semaphore for viewing | |
* in FreeRTOS+Trace. */ | |
#if ( ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS == 1 ) | |
{ | |
extern QueueHandle_t xNetworkEventQueue; | |
vTraceSetQueueName( xNetworkEventQueue, "IPStackEvent" ); | |
vTraceSetQueueName( xNetworkBufferSemaphore, "NetworkBufferCount" ); | |
} | |
#endif /* ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS == 1 */ | |
vListInitialise( &xFreeBuffersList ); | |
/* Initialise all the network buffers. No storage is allocated to | |
* the buffers yet. */ | |
for( x = 0; x < ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS; x++ ) | |
{ | |
/* Initialise and set the owner of the buffer list items. */ | |
xNetworkBufferDescriptors[ x ].pucEthernetBuffer = NULL; | |
vListInitialiseItem( &( xNetworkBufferDescriptors[ x ].xBufferListItem ) ); | |
listSET_LIST_ITEM_OWNER( &( xNetworkBufferDescriptors[ x ].xBufferListItem ), &xNetworkBufferDescriptors[ x ] ); | |
/* Currently, all buffers are available for use. */ | |
vListInsert( &xFreeBuffersList, &( xNetworkBufferDescriptors[ x ].xBufferListItem ) ); | |
} | |
uxMinimumFreeNetworkBuffers = ipconfigNUM_NETWORK_BUFFER_DESCRIPTORS; | |
} | |
} | |
if( xNetworkBufferSemaphore == NULL ) | |
{ | |
xReturn = pdFAIL; | |
} | |
else | |
{ | |
xReturn = pdPASS; | |
} | |
return xReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
uint8_t * pucGetNetworkBuffer( size_t * pxRequestedSizeBytes ) | |
{ | |
uint8_t * pucEthernetBuffer; | |
size_t xSize = *pxRequestedSizeBytes; | |
if( xSize < baMINIMAL_BUFFER_SIZE ) | |
{ | |
/* Buffers must be at least large enough to hold a TCP-packet with | |
* headers, or an ARP packet, in case TCP is not included. */ | |
xSize = baMINIMAL_BUFFER_SIZE; | |
} | |
/* Round up xSize to the nearest multiple of N bytes, | |
* where N equals 'sizeof( size_t )'. */ | |
if( ( xSize & ( sizeof( size_t ) - 1u ) ) != 0u ) | |
{ | |
xSize = ( xSize | ( sizeof( size_t ) - 1u ) ) + 1u; | |
} | |
*pxRequestedSizeBytes = xSize; | |
/* Allocate a buffer large enough to store the requested Ethernet frame size | |
* and a pointer to a network buffer structure (hence the addition of | |
* ipBUFFER_PADDING bytes). */ | |
#ifdef PIC32_USE_ETHERNET | |
pucEthernetBuffer = NetworkBufferAllocate( xSize - sizeof( TCPIP_MAC_ETHERNET_HEADER ) ); | |
#else | |
pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xSize + ipBUFFER_PADDING ); | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
configASSERT( pucEthernetBuffer ); | |
if( pucEthernetBuffer != NULL ) | |
{ | |
/* Enough space is left at the start of the buffer to place a pointer to | |
* the network buffer structure that references this Ethernet buffer. | |
* Return a pointer to the start of the Ethernet buffer itself. */ | |
#ifndef PIC32_USE_ETHERNET | |
pucEthernetBuffer += ipBUFFER_PADDING; | |
#endif /* #ifndef PIC32_USE_ETHERNET */ | |
} | |
return pucEthernetBuffer; | |
} | |
/*-----------------------------------------------------------*/ | |
void vReleaseNetworkBuffer( uint8_t * pucEthernetBuffer ) | |
{ | |
/* There is space before the Ethernet buffer in which a pointer to the | |
* network buffer that references this Ethernet buffer is stored. Remove the | |
* space before freeing the buffer. */ | |
#ifdef PIC32_USE_ETHERNET | |
NetworkBufferFree( pucEthernetBuffer ); | |
#else | |
if( pucEthernetBuffer != NULL ) | |
{ | |
pucEthernetBuffer -= ipBUFFER_PADDING; | |
vPortFree( ( void * ) pucEthernetBuffer ); | |
} | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
} | |
/*-----------------------------------------------------------*/ | |
NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedSizeBytes, | |
TickType_t xBlockTimeTicks ) | |
{ | |
NetworkBufferDescriptor_t * pxReturn = NULL; | |
size_t uxCount; | |
if( ( xRequestedSizeBytes != 0u ) && ( xRequestedSizeBytes < ( size_t ) baMINIMAL_BUFFER_SIZE ) ) | |
{ | |
/* ARP packets can replace application packets, so the storage must be | |
* at least large enough to hold an ARP. */ | |
xRequestedSizeBytes = baMINIMAL_BUFFER_SIZE; | |
} | |
#ifdef PIC32_USE_ETHERNET | |
if( xRequestedSizeBytes != 0u ) | |
{ | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
xRequestedSizeBytes += 2u; | |
if( ( xRequestedSizeBytes & ( sizeof( size_t ) - 1u ) ) != 0u ) | |
{ | |
xRequestedSizeBytes = ( xRequestedSizeBytes | ( sizeof( size_t ) - 1u ) ) + 1u; | |
} | |
#ifdef PIC32_USE_ETHERNET | |
} | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
/* If there is a semaphore available, there is a network buffer available. */ | |
if( xSemaphoreTake( xNetworkBufferSemaphore, xBlockTimeTicks ) == pdPASS ) | |
{ | |
/* Protect the structure as it is accessed from tasks and interrupts. */ | |
taskENTER_CRITICAL(); | |
{ | |
pxReturn = ( NetworkBufferDescriptor_t * ) listGET_OWNER_OF_HEAD_ENTRY( &xFreeBuffersList ); | |
uxListRemove( &( pxReturn->xBufferListItem ) ); | |
} | |
taskEXIT_CRITICAL(); | |
/* Reading UBaseType_t, no critical section needed. */ | |
uxCount = listCURRENT_LIST_LENGTH( &xFreeBuffersList ); | |
if( uxMinimumFreeNetworkBuffers > uxCount ) | |
{ | |
uxMinimumFreeNetworkBuffers = uxCount; | |
} | |
/* Allocate storage of exactly the requested size to the buffer. */ | |
configASSERT( pxReturn->pucEthernetBuffer == NULL ); | |
if( xRequestedSizeBytes > 0 ) | |
{ | |
/* Extra space is obtained so a pointer to the network buffer can | |
* be stored at the beginning of the buffer. */ | |
#ifdef PIC32_USE_ETHERNET | |
pxReturn->pucEthernetBuffer = NetworkBufferAllocate( xRequestedSizeBytes - sizeof( TCPIP_MAC_ETHERNET_HEADER ) ); | |
#else | |
pxReturn->pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xRequestedSizeBytes + ipBUFFER_PADDING ); | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
if( pxReturn->pucEthernetBuffer == NULL ) | |
{ | |
/* The attempt to allocate storage for the buffer payload failed, | |
* so the network buffer structure cannot be used and must be | |
* released. */ | |
vReleaseNetworkBufferAndDescriptor( pxReturn ); | |
pxReturn = NULL; | |
} | |
else | |
{ | |
/* Store a pointer to the network buffer structure in the | |
* buffer storage area, then move the buffer pointer on past the | |
* stored pointer so the pointer value is not overwritten by the | |
* application when the buffer is used. */ | |
#ifdef PIC32_USE_ETHERNET | |
*( ( NetworkBufferDescriptor_t ** ) ( pxReturn->pucEthernetBuffer - ipBUFFER_PADDING ) ) = pxReturn; | |
#else | |
*( ( NetworkBufferDescriptor_t ** ) ( pxReturn->pucEthernetBuffer ) ) = pxReturn; | |
pxReturn->pucEthernetBuffer += ipBUFFER_PADDING; | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
/* Store the actual size of the allocated buffer, which may be | |
* greater than the original requested size. */ | |
pxReturn->xDataLength = xRequestedSizeBytes; | |
#if ( ipconfigUSE_LINKED_RX_MESSAGES != 0 ) | |
{ | |
/* make sure the buffer is not linked */ | |
pxReturn->pxNextBuffer = NULL; | |
} | |
#endif /* ipconfigUSE_LINKED_RX_MESSAGES */ | |
} | |
} | |
else | |
{ | |
/* A descriptor is being returned without an associated buffer being | |
* allocated. */ | |
} | |
} | |
if( pxReturn == NULL ) | |
{ | |
iptraceFAILED_TO_OBTAIN_NETWORK_BUFFER(); | |
} | |
else | |
{ | |
iptraceNETWORK_BUFFER_OBTAINED( pxReturn ); | |
} | |
return pxReturn; | |
} | |
/*-----------------------------------------------------------*/ | |
void vReleaseNetworkBufferAndDescriptor( NetworkBufferDescriptor_t * const pxNetworkBuffer ) | |
{ | |
BaseType_t xListItemAlreadyInFreeList; | |
/* Ensure the buffer is returned to the list of free buffers before the | |
* counting semaphore is 'given' to say a buffer is available. Release the | |
* storage allocated to the buffer payload. THIS FILE SHOULD NOT BE USED | |
* IF THE PROJECT INCLUDES A MEMORY ALLOCATOR THAT WILL FRAGMENT THE HEAP | |
* MEMORY. For example, heap_2 must not be used, heap_4 can be used. */ | |
vReleaseNetworkBuffer( pxNetworkBuffer->pucEthernetBuffer ); | |
pxNetworkBuffer->pucEthernetBuffer = NULL; | |
taskENTER_CRITICAL(); | |
{ | |
xListItemAlreadyInFreeList = listIS_CONTAINED_WITHIN( &xFreeBuffersList, &( pxNetworkBuffer->xBufferListItem ) ); | |
if( xListItemAlreadyInFreeList == pdFALSE ) | |
{ | |
vListInsertEnd( &xFreeBuffersList, &( pxNetworkBuffer->xBufferListItem ) ); | |
} | |
} | |
taskEXIT_CRITICAL(); | |
/* | |
* Update the network state machine, unless the program fails to release its 'xNetworkBufferSemaphore'. | |
* The program should only try to release its semaphore if 'xListItemAlreadyInFreeList' is false. | |
*/ | |
if( xListItemAlreadyInFreeList == pdFALSE ) | |
{ | |
if ( xSemaphoreGive( xNetworkBufferSemaphore ) == pdTRUE ) | |
{ | |
iptraceNETWORK_BUFFER_RELEASED( pxNetworkBuffer ); | |
} | |
} | |
else | |
{ | |
iptraceNETWORK_BUFFER_RELEASED( pxNetworkBuffer ); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
/* | |
* Returns the number of free network buffers | |
*/ | |
UBaseType_t uxGetNumberOfFreeNetworkBuffers( void ) | |
{ | |
return listCURRENT_LIST_LENGTH( &xFreeBuffersList ); | |
} | |
/*-----------------------------------------------------------*/ | |
UBaseType_t uxGetMinimumFreeNetworkBuffers( void ) | |
{ | |
return uxMinimumFreeNetworkBuffers; | |
} | |
/*-----------------------------------------------------------*/ | |
NetworkBufferDescriptor_t * pxResizeNetworkBufferWithDescriptor( NetworkBufferDescriptor_t * pxNetworkBuffer, | |
size_t xNewSizeBytes ) | |
{ | |
size_t xOriginalLength; | |
uint8_t * pucBuffer; | |
#ifdef PIC32_USE_ETHERNET | |
xOriginalLength = pxNetworkBuffer->xDataLength; | |
#else | |
xOriginalLength = pxNetworkBuffer->xDataLength + ipBUFFER_PADDING; | |
xNewSizeBytes = xNewSizeBytes + ipBUFFER_PADDING; | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
pucBuffer = pucGetNetworkBuffer( &( xNewSizeBytes ) ); | |
if( pucBuffer == NULL ) | |
{ | |
/* In case the allocation fails, return NULL. */ | |
pxNetworkBuffer = NULL; | |
} | |
else | |
{ | |
pxNetworkBuffer->xDataLength = xNewSizeBytes; | |
if( xNewSizeBytes > xOriginalLength ) | |
{ | |
xNewSizeBytes = xOriginalLength; | |
} | |
#ifdef PIC32_USE_ETHERNET | |
memcpy( pucBuffer, pxNetworkBuffer->pucEthernetBuffer, xNewSizeBytes ); | |
*( ( NetworkBufferDescriptor_t ** ) ( pucBuffer - ipBUFFER_PADDING ) ) = pxNetworkBuffer; | |
#else | |
memcpy( pucBuffer - ipBUFFER_PADDING, pxNetworkBuffer->pucEthernetBuffer - ipBUFFER_PADDING, xNewSizeBytes ); | |
#endif /* #ifdef PIC32_USE_ETHERNET */ | |
vReleaseNetworkBuffer( pxNetworkBuffer->pucEthernetBuffer ); | |
pxNetworkBuffer->pucEthernetBuffer = pucBuffer; | |
} | |
return pxNetworkBuffer; | |
} |