/******************************************************************************* | |
* Network Interface file | |
* | |
* Summary: | |
* Network Interface file for FreeRTOS-Plus-TCP stack | |
* | |
* Description: | |
* - Interfaces PIC32 to the FreeRTOS TCP/IP stack | |
*******************************************************************************/ | |
/******************************************************************************* | |
* File Name: pic32_NetworkInterface.c | |
* Copyright 2017 Microchip Technology Incorporated and its subsidiaries. | |
* | |
* 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 | |
*******************************************************************************/ | |
#include <sys/kmem.h> | |
#include "FreeRTOS.h" | |
#include "semphr.h" | |
#include "event_groups.h" | |
#include "FreeRTOS_IP.h" | |
#include "FreeRTOS_IP_Private.h" | |
#include "NetworkInterface.h" | |
#include "NetworkBufferManagement.h" | |
#include "NetworkInterface.h" | |
#include "NetworkConfig.h" | |
#include "peripheral/eth/plib_eth.h" | |
#include "system_config.h" | |
#include "system/console/sys_console.h" | |
#include "system/debug/sys_debug.h" | |
#include "system/command/sys_command.h" | |
#include "driver/ethmac/drv_ethmac.h" | |
#include "driver/miim/drv_miim.h" | |
#include "tcpip/tcpip.h" | |
#include "tcpip/src/tcpip_private.h" | |
#include "tcpip/src/link_list.h" | |
#ifdef PIC32_USE_ETHERNET | |
/* local definitions and data */ | |
/* debug messages */ | |
#if ( PIC32_MAC_DEBUG_MESSAGES != 0 ) | |
#define PIC32_MAC_DbgPrint( format, ... ) SYS_CONSOLE_PRINT( format, ## __VA_ARGS__ ) | |
#else | |
#define PIC32_MAC_DbgPrint( format, ... ) | |
#endif /* (PIC32_MAC_DEBUG_MESSAGES != 0) */ | |
typedef enum | |
{ | |
PIC32_MAC_EVENT_INIT_NONE = 0x000, /* no event/invalid */ | |
PIC32_MAC_EVENT_INIT_DONE = 0x001, /* initialization done event */ | |
PIC32_MAC_EVENT_TIMEOUT = 0x002, /* periodic timeout event */ | |
PIC32_MAC_EVENT_IF_PENDING = 0x004, /* an interface event signal: RX, TX, errors. etc. */ | |
} PIC32_MAC_EVENT_TYPE; | |
typedef enum | |
{ | |
eMACInit, /* Must initialise MAC. */ | |
eMACPass, /* Initialisation was successful. */ | |
eMACFailed, /* Initialisation failed. */ | |
} eMAC_INIT_STATUS_TYPE; | |
static TCPIP_STACK_HEAP_HANDLE macHeapHandle; | |
static const TCPIP_MAC_OBJECT * macObject; /* the one and only MAC object; */ | |
static SYS_MODULE_OBJ macObjHandle; /* the MAC object instance, obtained at initialization */ | |
static TCPIP_MAC_HANDLE macCliHandle; /* client handle */ | |
static volatile SYS_STATUS macObjStatus; /* current MAC status */ | |
static TaskHandle_t macTaskHandle; | |
static TimerHandle_t macTmrHandle; | |
static bool macLinkStatus; /* true if link is ON */ | |
static eMAC_INIT_STATUS_TYPE xMacInitStatus = eMACInit; | |
/* local prototypes */ | |
static bool StartInitMac( void ); | |
static void StartInitCleanup( void ); | |
static void SetMacCtrl( TCPIP_MAC_MODULE_CTRL * pMacCtrl ); | |
static bool MacSyncFunction( void * synchHandle, | |
TCPIP_MAC_SYNCH_REQUEST req ); | |
/* the PIC32 MAC task function */ | |
static void MacHandlerTask( void * params ); | |
/* MAC interrupt event function */ | |
static void MAC_EventFunction( TCPIP_MAC_EVENT event, | |
const void * eventParam ); | |
/* timer callback for link maintenance, etc; */ | |
static void MacTmrCallback( TimerHandle_t xTimer ); | |
/* MAC RX packets functions */ | |
static void MacRxPackets( void ); | |
static void MacProcessRxPacket( TCPIP_MAC_PACKET * pRxPkt ); | |
/* memory allocation mapping to FreeRTOS */ | |
static void * _malloc( size_t nBytes ) | |
{ | |
return pvPortMalloc( nBytes ); | |
} | |
/*-----------------------------------------------------------*/ | |
static void * _calloc( size_t nElems, | |
size_t elemSize ) | |
{ | |
size_t nBytes = nElems * elemSize; | |
void * ptr = pvPortMalloc( nBytes ); | |
if( ptr != 0 ) | |
{ | |
memset( ptr, 0, nBytes ); | |
} | |
return ptr; | |
} | |
/*-----------------------------------------------------------*/ | |
static void _free( void * pBuff ) | |
{ | |
vPortFree( pBuff ); | |
} | |
/* extern references */ | |
/* */ | |
/* use the configuration data from the system_init.c */ | |
extern const TCPIP_NETWORK_CONFIG TCPIP_HOSTS_CONFIGURATION[]; | |
/* BufferAllocation_2.c:: packet allocation function */ | |
extern TCPIP_MAC_PACKET * PIC32_MacPacketAllocate( uint16_t pktLen, | |
uint16_t segLoadLen, | |
TCPIP_MAC_PACKET_FLAGS flags ); | |
extern void PIC32_MacAssociate( TCPIP_MAC_PACKET * pRxPkt, | |
NetworkBufferDescriptor_t * pxBufferDescriptor, | |
size_t pktLength ); | |
extern void PIC32_MacPacketOrphan( TCPIP_MAC_PACKET * pPkt ); | |
/* cannot use the system_init.c::tcpipHeapConfig because FreeRTOS does not have a calloc function! */ | |
/* we build it here! */ | |
/* make sure we're running with external heap! Redirect to FreeRTOS. */ | |
#if !defined( TCPIP_STACK_USE_EXTERNAL_HEAP ) || defined( TCPIP_STACK_USE_INTERNAL_HEAP ) || defined( TCPIP_STACK_USE_INTERNAL_HEAP_POOL ) | |
#error "TCPIP_STACK_USE_EXTERNAL_HEAP should be defined for this project!" | |
#endif | |
static const TCPIP_STACK_HEAP_EXTERNAL_CONFIG tcpipHeapConfig = | |
{ | |
.heapType = TCPIP_STACK_HEAP_TYPE_EXTERNAL_HEAP, | |
.heapFlags = TCPIP_STACK_HEAP_FLAG_ALLOC_UNCACHED | TCPIP_STACK_HEAP_FLAG_NO_MTHREAD_SYNC, | |
.heapUsage = TCPIP_STACK_HEAP_USE_DEFAULT, | |
.malloc_fnc = _malloc, | |
.calloc_fnc = _calloc, | |
.free_fnc = _free, | |
}; | |
#if ( PIC32_MAC_DEBUG_COMMANDS != 0 ) | |
static int _Command_MacInfo( SYS_CMD_DEVICE_NODE * pCmdIO, | |
int argc, | |
char ** argv ); | |
static int _Command_NetInfo( SYS_CMD_DEVICE_NODE * pCmdIO, | |
int argc, | |
char ** argv ); | |
static int _Command_Version( SYS_CMD_DEVICE_NODE * pCmdIO, | |
int argc, | |
char ** argv ); | |
static const SYS_CMD_DESCRIPTOR macCmdTbl[] = | |
{ | |
{ "macinfo", _Command_MacInfo, ": Check MAC statistics" }, | |
{ "netinfo", _Command_NetInfo, ": Net info" }, | |
{ "version", _Command_Version, ": Version info" }, | |
}; | |
#endif /* (PIC32_MAC_DEBUG_COMMANDS != 0) */ | |
/* FreeRTOS implementation functions */ | |
BaseType_t xNetworkInterfaceInitialise( void ) | |
{ | |
BaseType_t xResult; | |
if( xMacInitStatus == eMACInit ) | |
{ | |
/* This is the first time this function is called. */ | |
if( StartInitMac() != false ) | |
{ | |
/* Indicate that the MAC initialisation succeeded. */ | |
xMacInitStatus = eMACPass; | |
} | |
else | |
{ | |
xMacInitStatus = eMACFailed; | |
} | |
} | |
if( xMacInitStatus == eMACPass ) | |
{ | |
xResult = xGetPhyLinkStatus(); | |
} | |
else | |
{ | |
xResult = pdFAIL; | |
} | |
PIC32_MAC_DbgPrint( "xNetworkInterfaceInitialise: %d %d\r\n", ( int ) xMacInitStatus, ( int ) xResult ); | |
return xResult; | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xNetworkInterfaceOutput( NetworkBufferDescriptor_t * const pxDescriptor, | |
BaseType_t xReleaseAfterSend ) | |
{ | |
TCPIP_MAC_RES macRes; | |
TCPIP_MAC_PACKET * pTxPkt; | |
BaseType_t retRes = pdFALSE; | |
if( ( pxDescriptor != 0 ) && ( pxDescriptor->pucEthernetBuffer != 0 ) && ( pxDescriptor->xDataLength != 0 ) ) | |
{ | |
TCPIP_MAC_PACKET ** ppkt = ( TCPIP_MAC_PACKET ** ) ( pxDescriptor->pucEthernetBuffer - PIC32_BUFFER_PKT_PTR_OSSET ); | |
configASSERT( ( ( uint32_t ) ppkt & ( sizeof( uint32_t ) - 1 ) ) == 0 ); | |
pTxPkt = *ppkt; | |
configASSERT( pTxPkt != 0 ); | |
/* prepare the packet for transmission */ | |
/* set the correct data length: */ | |
configASSERT( pTxPkt->pDSeg->segSize >= pTxPkt->pDSeg->segLen ); | |
pTxPkt->pDSeg->segLen = pxDescriptor->xDataLength; | |
pTxPkt->next = 0; /* unlink it */ | |
macRes = ( macObject->TCPIP_MAC_PacketTx )( macCliHandle, pTxPkt ); | |
if( macRes >= 0 ) | |
{ | |
retRes = pdTRUE; | |
pxDescriptor->pucEthernetBuffer = 0; /* it will be released by the MAC driver once it's transmitted */ | |
iptraceNETWORK_INTERFACE_TRANSMIT(); | |
} | |
/* else same error occurred; this normally should not happen! But the buffer is left in there so it shold be freed! */ | |
/* The buffer has been sent so can be released. */ | |
if( xReleaseAfterSend != pdFALSE ) | |
{ | |
vReleaseNetworkBufferAndDescriptor( pxDescriptor ); | |
} | |
} | |
return retRes; | |
} | |
/************************************* Section: helper functions ************************************************** */ | |
/* */ | |
void PIC32_GetMACAddress( uint8_t macAdd[ 6 ] ) | |
{ | |
#if defined( __PIC32MZ__ ) || defined( __PIC32MX__ ) | |
PLIB_ETH_MACGetAddress( ETH_ID_0, macAdd ); | |
#else | |
#error "MAC Address: not supported architecture!" | |
#endif | |
} | |
/*-----------------------------------------------------------*/ | |
const void * const PIC32_GetMacConfigData( void ) | |
{ | |
#if defined( __PIC32MZ__ ) || defined( __PIC32MX__ ) | |
extern const TCPIP_MODULE_MAC_PIC32INT_CONFIG tcpipMACPIC32INTInitData; | |
return &tcpipMACPIC32INTInitData; | |
#else | |
#error "MAC Address: not supported architecture!" | |
#endif | |
} | |
/************************************* Section: worker code ************************************************** */ | |
/* */ | |
static bool StartInitMac( void ) | |
{ | |
TCPIP_MAC_MODULE_CTRL macCtrl; | |
SYS_MODULE_INIT moduleInit; | |
EventBits_t evBits; | |
/* perform some initialization of all variables so that we can cleanup what failed */ | |
/* if something failed, the routine will be called again and again by FreeRTOS! */ | |
macHeapHandle = 0; | |
macObjHandle = 0; | |
macCliHandle = 0; | |
macTmrHandle = 0; | |
macTaskHandle = 0; | |
macObject = TCPIP_HOSTS_CONFIGURATION[ 0 ].pMacObject; /* the MAC object we use */ | |
macObjStatus = SYS_STATUS_UNINITIALIZED; | |
macLinkStatus = false; | |
int netUpFail = 0; | |
while( true ) | |
{ | |
/* start the allocator */ | |
macHeapHandle = TCPIP_HEAP_Create( ( const TCPIP_STACK_HEAP_CONFIG * ) &tcpipHeapConfig, 0 ); | |
if( macHeapHandle == 0 ) | |
{ | |
netUpFail = 1; | |
break; | |
} | |
if( TCPIP_PKT_Initialize( macHeapHandle, 0, 0 ) == false ) | |
{ | |
netUpFail = 2; | |
break; | |
} | |
moduleInit.sys.powerState = SYS_MODULE_POWER_RUN_FULL; | |
/* Initialize the MAC. MAC address is defined to 0x000000000000 in | |
* FreeRTOSConfig.h and therefore it will be initialized to the | |
* factory programmed MAC address. */ | |
SetMacCtrl( &macCtrl ); | |
/* Set the mac address in the FreeRTOS+TCP stack. */ | |
FreeRTOS_UpdateMACAddress( macCtrl.ifPhyAddress.v ); | |
TCPIP_MAC_INIT macInit = | |
{ | |
.moduleInit = { moduleInit.value }, | |
.macControl = &macCtrl, | |
.moduleData = PIC32_GetMacConfigData(), | |
}; | |
macObjHandle = ( macObject->TCPIP_MAC_Initialize )( TCPIP_MODULE_MAC_PIC32INT, &macInit.moduleInit ); | |
if( macObjHandle == SYS_MODULE_OBJ_INVALID ) | |
{ | |
macObjHandle = 0; | |
netUpFail = 4; | |
break; | |
} | |
/* open the MAC */ | |
macCliHandle = ( macObject->TCPIP_MAC_Open )( TCPIP_MODULE_MAC_PIC32INT, DRV_IO_INTENT_READWRITE ); | |
if( macCliHandle == DRV_HANDLE_INVALID ) | |
{ | |
macCliHandle = 0; | |
netUpFail = 5; | |
break; | |
} | |
if( !( macObject->TCPIP_MAC_EventMaskSet )( macCliHandle, ( TCPIP_MAC_EV_RX_DONE | TCPIP_MAC_EV_TX_DONE | TCPIP_MAC_EV_RXTX_ERRORS ), true ) ) | |
{ | |
netUpFail = 6; | |
break; | |
} | |
/* completed the MAC initialization */ | |
/* continue the initialization */ | |
macTmrHandle = xTimerCreate( PIC32_MAC_TIMER_NAME, PIC32_MAC_TIMER_PERIOD, pdTRUE, 0, MacTmrCallback ); | |
if( ( macTmrHandle == 0 ) || ( xTimerStart( macTmrHandle, 0 ) != pdPASS ) ) | |
{ | |
netUpFail = 8; | |
break; | |
} | |
/* spawn the PIC32 MAC task function */ | |
/* and wait for its event signal */ | |
macObjStatus = SYS_STATUS_BUSY; | |
if( xTaskCreate( MacHandlerTask, PIC32_MAC_TASK_NAME, PIC32_MAC_TASK_STACK_SIZE, xTaskGetCurrentTaskHandle(), PIC32_MAC_TASK_PRI, &macTaskHandle ) != pdPASS ) | |
{ /* failed */ | |
netUpFail = 9; | |
break; | |
} | |
xTaskNotifyWait( PIC32_MAC_EVENT_INIT_DONE, PIC32_MAC_EVENT_INIT_DONE, &evBits, PIC32_MAC_INIT_TIMEOUT ); | |
if( ( evBits & PIC32_MAC_EVENT_INIT_DONE ) == 0 ) | |
{ /* timed out */ | |
netUpFail = 10; | |
break; | |
} | |
if( macObjStatus != SYS_STATUS_READY ) | |
{ /* failed somehow ??? */ | |
netUpFail = 11; | |
break; | |
} | |
netUpFail = 0; | |
break; | |
} | |
if( netUpFail == 0 ) | |
{ | |
PIC32_MAC_DbgPrint( " MAC Init success!\r\n" ); | |
#if ( PIC32_MAC_DEBUG_COMMANDS != 0 ) | |
/* create command group */ | |
if( !SYS_CMD_ADDGRP( macCmdTbl, sizeof( macCmdTbl ) / sizeof( *macCmdTbl ), "mac", ": mac commands" ) ) | |
{ | |
PIC32_MAC_DbgPrint( "Failed to create MAC Commands\r\n" ); | |
} | |
#endif /* (PIC32_MAC_DEBUG_COMMANDS != 0) */ | |
return true; | |
} | |
else | |
{ | |
StartInitCleanup(); | |
PIC32_MAC_DbgPrint( "MAC Init failed: %d!\r\n", netUpFail ); | |
return false; | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static void StartInitCleanup( void ) | |
{ | |
if( macHeapHandle != 0 ) | |
{ | |
TCPIP_HEAP_Delete( macHeapHandle ); | |
macHeapHandle = 0; | |
} | |
if( macObjHandle != 0 ) | |
{ | |
( macObject->TCPIP_MAC_Deinitialize )( macObjHandle ); | |
macObjHandle = 0; | |
} | |
if( macTmrHandle != 0 ) | |
{ | |
xTimerDelete( macTmrHandle, portMAX_DELAY ); | |
macTmrHandle = 0; | |
} | |
if( macTaskHandle != 0 ) | |
{ | |
vTaskDelete( macTaskHandle ); | |
macTaskHandle = 0; | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static void SetMacCtrl( TCPIP_MAC_MODULE_CTRL * pMacCtrl ) | |
{ | |
TCPIP_MAC_ADDR macAdd; | |
uint8_t unsetMACAddr[ 6 ] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; /* not set MAC address */ | |
pMacCtrl->nIfs = 1; | |
pMacCtrl->mallocF = TCPIP_HEAP_MallocOutline; | |
pMacCtrl->callocF = TCPIP_HEAP_CallocOutline; | |
pMacCtrl->freeF = TCPIP_HEAP_FreeOutline; | |
pMacCtrl->memH = macHeapHandle; | |
pMacCtrl->pktAllocF = PIC32_MacPacketAllocate; | |
pMacCtrl->pktFreeF = ( TCPIP_MAC_PKT_FreeF ) _TCPIP_PKT_FREE_FNC; | |
pMacCtrl->pktAckF = ( TCPIP_MAC_PKT_AckF ) _TCPIP_PKT_ACK_FNC; | |
pMacCtrl->synchF = MacSyncFunction; | |
pMacCtrl->eventF = MAC_EventFunction; | |
pMacCtrl->eventParam = 0; | |
pMacCtrl->moduleId = TCPIP_MODULE_MAC_PIC32INT; | |
pMacCtrl->netIx = 0; | |
pMacCtrl->macAction = TCPIP_MAC_ACTION_INIT; | |
pMacCtrl->powerMode = TCPIP_MAC_POWER_FULL; | |
macAdd.v[ 0 ] = configMAC_ADDR0; | |
macAdd.v[ 1 ] = configMAC_ADDR1; | |
macAdd.v[ 2 ] = configMAC_ADDR2; | |
macAdd.v[ 3 ] = configMAC_ADDR3; | |
macAdd.v[ 4 ] = configMAC_ADDR4; | |
macAdd.v[ 5 ] = configMAC_ADDR5; | |
if( memcmp( macAdd.v, unsetMACAddr, sizeof( unsetMACAddr ) ) == 0 ) | |
{ /* if unspecified we use the factory pre-programmed address */ | |
PIC32_GetMACAddress( pMacCtrl->ifPhyAddress.v ); | |
} | |
else | |
{ /* use the config suggested one */ | |
memcpy( pMacCtrl->ifPhyAddress.v, macAdd.v, sizeof( macAdd ) ); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static bool MacSyncFunction( void * synchHandle, | |
TCPIP_MAC_SYNCH_REQUEST req ) | |
{ | |
switch( req ) | |
{ | |
case TCPIP_MAC_SYNCH_REQUEST_OBJ_CREATE: | |
vSemaphoreCreateBinary( *( SemaphoreHandle_t * ) synchHandle ); | |
return ( *( SemaphoreHandle_t * ) synchHandle == NULL ) ? false : true; | |
case TCPIP_MAC_SYNCH_REQUEST_OBJ_DELETE: | |
vSemaphoreDelete( *( SemaphoreHandle_t * ) synchHandle ); | |
*( SemaphoreHandle_t * ) synchHandle = NULL; | |
return true; | |
case TCPIP_MAC_SYNCH_REQUEST_OBJ_LOCK: | |
return ( xSemaphoreTake( *( SemaphoreHandle_t * ) synchHandle, portMAX_DELAY ) == pdTRUE ) ? true : false; | |
case TCPIP_MAC_SYNCH_REQUEST_OBJ_UNLOCK: | |
return ( xSemaphoreGive( *( SemaphoreHandle_t * ) synchHandle ) == pdTRUE ) ? true : false; | |
case TCPIP_MAC_SYNCH_REQUEST_CRIT_ENTER: | |
vTaskSuspendAll(); | |
return true; | |
case TCPIP_MAC_SYNCH_REQUEST_CRIT_LEAVE: | |
xTaskResumeAll(); | |
return true; | |
default: | |
return false; | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static void MacHandlerTask( void * params ) | |
{ | |
EventBits_t evBits; | |
/* perform the MAC initialization */ | |
while( macObjStatus == SYS_STATUS_BUSY ) | |
{ | |
/* process the underlying MAC module tasks */ | |
( macObject->TCPIP_MAC_Tasks )( macObjHandle ); | |
SYS_STATUS macStatus = ( macObject->TCPIP_MAC_Status )( macObjHandle ); | |
if( macStatus == SYS_STATUS_BUSY ) | |
{ /* still pending */ | |
vTaskDelay( PIC32_MAC_TASK_INIT_PENDING_DELAY ); | |
} | |
else | |
{ /* completed ...somehow */ | |
macObjStatus = macStatus; | |
xTaskNotify( ( TaskHandle_t ) params, PIC32_MAC_EVENT_INIT_DONE, eSetBits ); | |
if( macStatus != SYS_STATUS_READY ) | |
{ /* failed miserably */ | |
vTaskDelete( 0 ); | |
} | |
/* done, up and running */ | |
} | |
} | |
while( true ) | |
{ | |
xTaskNotifyWait( PIC32_MAC_EVENT_TIMEOUT | PIC32_MAC_EVENT_IF_PENDING, PIC32_MAC_EVENT_TIMEOUT | PIC32_MAC_EVENT_IF_PENDING, &evBits, portMAX_DELAY ); | |
if( ( evBits & PIC32_MAC_EVENT_TIMEOUT ) != 0 ) | |
{ /* timeout occurred... */ | |
( macObject->TCPIP_MAC_Tasks )( macObjHandle ); | |
bool linkCurr = ( macObject->TCPIP_MAC_LinkCheck )( macCliHandle ); /* check link status */ | |
if( macLinkStatus != linkCurr ) | |
{ /* link status changed; some event could ve fired here if needed */ | |
PIC32_MAC_DbgPrint( " MAC link: %s!\r\n", linkCurr ? "ON" : "OFF" ); | |
macLinkStatus = linkCurr; | |
} | |
} | |
if( ( evBits & PIC32_MAC_EVENT_IF_PENDING ) != 0 ) | |
{ /* IF events signal */ | |
TCPIP_MAC_EVENT activeEvents = ( macObject->TCPIP_MAC_EventPendingGet )( macCliHandle ); | |
if( activeEvents != TCPIP_MAC_EV_NONE ) | |
{ | |
/* acknowledge the events */ | |
( macObject->TCPIP_MAC_EventAcknowledge )( macCliHandle, activeEvents ); | |
/* check for RX */ | |
if( ( activeEvents & ( TCPIP_MAC_EV_RX_DONE | TCPIP_MAC_EV_RX_OVFLOW | TCPIP_MAC_EV_RX_BUFNA ) ) != 0 ) | |
{ /* RX packets available */ | |
MacRxPackets(); | |
} | |
/* call the driver process function; */ | |
/* PIC32 driver requests it through TCPIP_MAC_ParametersGet() which is bypassed here! */ | |
( macObject->TCPIP_MAC_Process )( macCliHandle ); | |
} | |
} | |
/* do what you have to do and then wait for another event... */ | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static void MacTmrCallback( TimerHandle_t xTimer ) | |
{ | |
xTaskNotify( macTaskHandle, PIC32_MAC_EVENT_TIMEOUT, eSetBits ); | |
} | |
/* MAC interrupt event function */ | |
/* MAC signals an event, probably from within ISR */ | |
/* we care just for RX related events */ | |
static void MAC_EventFunction( TCPIP_MAC_EVENT event, | |
const void * eventParam ) | |
{ | |
BaseType_t xHigherPriorityTaskWoken; | |
if( ( event & ( TCPIP_MAC_EV_RX_DONE | TCPIP_MAC_EV_TX_DONE | TCPIP_MAC_EV_RXTX_ERRORS ) ) != 0 ) | |
{ | |
xHigherPriorityTaskWoken = pdFALSE; | |
xTaskNotifyFromISR( macTaskHandle, PIC32_MAC_EVENT_IF_PENDING, eSetBits, &xHigherPriorityTaskWoken ); | |
if( xHigherPriorityTaskWoken ) | |
{ | |
portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); | |
} | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
BaseType_t xGetPhyLinkStatus( void ) | |
{ | |
return macLinkStatus == true ? pdPASS : pdFAIL; | |
} | |
/* receive packets from the MAC driver */ | |
static void MacRxPackets( void ) | |
{ | |
TCPIP_MAC_PACKET * pRxPkt; | |
/* get all the new MAC packets */ | |
while( ( pRxPkt = ( macObject->TCPIP_MAC_PacketRx )( macCliHandle, 0, 0 ) ) != 0 ) | |
{ | |
MacProcessRxPacket( pRxPkt ); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
static void MacProcessRxPacket( TCPIP_MAC_PACKET * pRxPkt ) | |
{ | |
bool pktSuccess, pktLost; | |
size_t pktLength; | |
TCPIP_MAC_DATA_SEGMENT * pSeg; | |
uint8_t * pPktBuff; | |
NetworkBufferDescriptor_t * pxBufferDescriptor; | |
IPStackEvent_t xRxEvent; | |
pxBufferDescriptor = 0; | |
pktSuccess = pktLost = false; | |
while( true ) | |
{ | |
pktLength = 0; | |
int nSegs = 0; | |
pSeg = pRxPkt->pDSeg; | |
pPktBuff = pSeg->segLoad; | |
/* calculate the packet size */ | |
do | |
{ | |
pktLength += pSeg->segLen; | |
pSeg = pSeg->next; | |
nSegs++; | |
} while( pSeg != 0 ); | |
if( nSegs > 1 ) | |
{ /* no support in FreeRTOS for multi segment packets! */ | |
break; | |
} | |
/* sizeof(TCPIP_MAC_ETHERNET_HEADER) is subtracted by the driver */ | |
/* but FreeRTOS needs the whole frame! */ | |
pktLength += sizeof( TCPIP_MAC_ETHERNET_HEADER ); | |
if( eConsiderFrameForProcessing( pPktBuff ) != eProcessBuffer ) | |
{ | |
break; | |
} | |
/* get the network descriptor (no data buffer) to hold this packet */ | |
pxBufferDescriptor = pxGetNetworkBufferWithDescriptor( 0, 0 ); | |
if( pxBufferDescriptor == 0 ) | |
{ | |
pktLost = true; | |
break; | |
} | |
PIC32_MacAssociate( pRxPkt, pxBufferDescriptor, pktLength ); | |
xRxEvent.eEventType = eNetworkRxEvent; | |
xRxEvent.pvData = ( void * ) pxBufferDescriptor; | |
/* Send the data to the TCP/IP stack */ | |
if( xSendEventStructToIPTask( &xRxEvent, 0 ) == pdFALSE ) | |
{ /* failed */ | |
pktLost = true; | |
} | |
else | |
{ /* success */ | |
pktSuccess = true; | |
iptraceNETWORK_INTERFACE_RECEIVE(); | |
} | |
break; | |
} | |
if( !pktSuccess ) | |
{ /* smth went wrong; nothing sent to the */ | |
if( pxBufferDescriptor != 0 ) | |
{ | |
pxBufferDescriptor->pucEthernetBuffer = 0; | |
vReleaseNetworkBufferAndDescriptor( pxBufferDescriptor ); | |
} | |
if( pktLost ) | |
{ | |
iptraceETHERNET_RX_EVENT_LOST(); | |
} | |
/* acknowledge the packet to the MAC driver */ | |
if( pRxPkt->ackFunc ) | |
{ | |
( *pRxPkt->ackFunc )( pRxPkt, pRxPkt->ackParam ); | |
} | |
else | |
{ | |
PIC32_MacPacketOrphan( pRxPkt ); | |
} | |
} | |
} | |
#if ( PIC32_MAC_DEBUG_COMMANDS != 0 ) | |
/* */ | |
static int _Command_MacInfo( SYS_CMD_DEVICE_NODE * pCmdIO, | |
int argc, | |
char ** argv ) | |
{ | |
TCPIP_MAC_RES macRes; | |
TCPIP_MAC_RX_STATISTICS rxStatistics; | |
TCPIP_MAC_TX_STATISTICS txStatistics; | |
TCPIP_MAC_STATISTICS_REG_ENTRY regEntries[ 8 ]; | |
TCPIP_MAC_STATISTICS_REG_ENTRY * pRegEntry; | |
int jx, hwEntries; | |
char entryName[ sizeof( pRegEntry->registerName ) + 1 ]; | |
const void * cmdIoParam = pCmdIO->cmdIoParam; | |
if( argc != 1 ) | |
{ | |
( *pCmdIO->pCmdApi->msg )( cmdIoParam, "Usage: macinfo \r\n" ); | |
( *pCmdIO->pCmdApi->msg )( cmdIoParam, "Ex: macinfo \r\n" ); | |
return false; | |
} | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "Interface: %s driver statistics\r\n", macObject->macName ); | |
macRes = ( macObject->TCPIP_MAC_StatisticsGet )( macCliHandle, &rxStatistics, &txStatistics ); | |
if( macRes == TCPIP_MAC_RES_OK ) | |
{ | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "\tnRxOkPackets: %d, nRxPendBuffers: %d, nRxSchedBuffers: %d, ", | |
rxStatistics.nRxOkPackets, rxStatistics.nRxPendBuffers, rxStatistics.nRxSchedBuffers ); | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "nRxErrorPackets: %d, nRxFragmentErrors: %d\r\n", rxStatistics.nRxErrorPackets, rxStatistics.nRxFragmentErrors ); | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "\tnTxOkPackets: %d, nTxPendBuffers: %d, nTxErrorPackets: %d, nTxQueueFull: %d\r\n", | |
txStatistics.nTxOkPackets, txStatistics.nTxPendBuffers, txStatistics.nTxErrorPackets, txStatistics.nTxQueueFull ); | |
} | |
else | |
{ | |
( *pCmdIO->pCmdApi->msg )( cmdIoParam, "\tnot supported\r\n" ); | |
} | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "Interface: %s hardware statistics\r\n", macObject->macName ); | |
macRes = ( macObject->TCPIP_MAC_RegisterStatisticsGet )( macCliHandle, regEntries, sizeof( regEntries ) / sizeof( *regEntries ), &hwEntries ); | |
if( macRes == TCPIP_MAC_RES_OK ) | |
{ | |
entryName[ sizeof( entryName ) - 1 ] = 0; | |
for( jx = 0, pRegEntry = regEntries; jx < hwEntries && jx < sizeof( regEntries ) / sizeof( *regEntries ); jx++, pRegEntry++ ) | |
{ | |
strncpy( entryName, pRegEntry->registerName, sizeof( entryName ) - 1 ); | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "\t%s: 0x%8x\r\n", entryName, pRegEntry->registerValue ); | |
} | |
} | |
else | |
{ | |
( *pCmdIO->pCmdApi->msg )( cmdIoParam, "\tnot supported\r\n" ); | |
} | |
return true; | |
} | |
/*-----------------------------------------------------------*/ | |
static int _Command_NetInfo( SYS_CMD_DEVICE_NODE * pCmdIO, | |
int argc, | |
char ** argv ) | |
{ | |
const void * cmdIoParam = pCmdIO->cmdIoParam; | |
union | |
{ | |
uint32_t ul; | |
uint8_t b[ 4 ]; | |
} | |
sUl; | |
sUl.ul = FreeRTOS_GetIPAddress(); | |
bool linkUp = FreeRTOS_IsNetworkUp() == pdTRUE; | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "IP address: %d.%d.%d.%d\r\n", sUl.b[ 0 ], sUl.b[ 1 ], sUl.b[ 2 ], sUl.b[ 3 ] ); | |
( *pCmdIO->pCmdApi->print )( cmdIoParam, "Link is: %s\r\n", linkUp ? "Up" : "Down" ); | |
return true; | |
} | |
#include "aws_application_version.h" | |
static int _Command_Version(SYS_CMD_DEVICE_NODE* pCmdIO, int argc, char** argv) | |
{ | |
configPRINTF( ( "App version - maj: %d, min: %d, build: %d\r\n", xAppFirmwareVersion.u.x.ucMajor, xAppFirmwareVersion.u.x.ucMinor, xAppFirmwareVersion.u.x.usBuild) ); | |
return 0; | |
} | |
#endif /* (PIC32_MAC_DEBUG_COMMANDS != 0) */ | |
#endif /* #ifdef PIC32_USE_ETHERNET */ |