/******************************************************************************* * 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 #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; 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 */ /* 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 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 ) { if( StartInitMac() ) { return pdPASS; } return pdFAIL; } /*-----------------------------------------------------------*/ 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 */