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