474 lines
14 KiB
C
474 lines
14 KiB
C
|
/*
|
||
|
|
* FreeRTOS V202212.00
|
||
|
|
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||
|
|
*
|
||
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||
|
|
* this software and associated documentation files (the "Software"), to deal in
|
||
|
|
* the Software without restriction, including without limitation the rights to
|
||
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||
|
|
* subject to the following conditions:
|
||
|
|
*
|
||
|
|
* The above copyright notice and this permission notice shall be included in all
|
||
|
|
* copies or substantial portions of the Software.
|
||
|
|
*
|
||
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
|
*
|
||
|
|
* https://www.FreeRTOS.org
|
||
|
|
* https://github.com/FreeRTOS
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* FreeRTOS includes. */
|
||
|
|
#include "FreeRTOS.h"
|
||
|
|
#include "task.h"
|
||
|
|
#include "queue.h"
|
||
|
|
|
||
|
|
/* BSP includes. */
|
||
|
|
#include "xemaclite.h"
|
||
|
|
#include "xintc_l.h"
|
||
|
|
|
||
|
|
/* lwIP includes. */
|
||
|
|
#include "lwip/opt.h"
|
||
|
|
#include "lwip/def.h"
|
||
|
|
#include "lwip/mem.h"
|
||
|
|
#include "lwip/pbuf.h"
|
||
|
|
#include "lwip/sys.h"
|
||
|
|
#include <lwip/stats.h>
|
||
|
|
#include <lwip/snmp.h>
|
||
|
|
#include "netif/etharp.h"
|
||
|
|
|
||
|
|
/* Define those to better describe your network interface. */
|
||
|
|
#define IFNAME0 'e'
|
||
|
|
#define IFNAME1 'l'
|
||
|
|
|
||
|
|
/* When a packet is ready to be sent, if it cannot be sent immediately then
|
||
|
|
* the task performing the transmit will block for netifTX_BUFFER_FREE_WAIT
|
||
|
|
* milliseconds. It will do this a maximum of netifMAX_TX_ATTEMPTS before
|
||
|
|
* giving up.
|
||
|
|
*/
|
||
|
|
#define netifTX_BUFFER_FREE_WAIT ( ( TickType_t ) 2UL / portTICK_PERIOD_MS )
|
||
|
|
#define netifMAX_TX_ATTEMPTS ( 5 )
|
||
|
|
|
||
|
|
#define netifMAX_MTU 1500
|
||
|
|
|
||
|
|
struct xEthernetIf
|
||
|
|
{
|
||
|
|
struct eth_addr *ethaddr;
|
||
|
|
/* Add whatever per-interface state that is needed here. */
|
||
|
|
};
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Copy the received data into a pbuf.
|
||
|
|
*/
|
||
|
|
static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, unsigned short usDataLength );
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Send data from a pbuf to the hardware.
|
||
|
|
*/
|
||
|
|
static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p );
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Perform any hardware and/or driver initialisation necessary.
|
||
|
|
*/
|
||
|
|
static void prvLowLevelInit( struct netif *pxNetIf );
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Functions that get registered as the Rx and Tx interrupt handers
|
||
|
|
* respectively.
|
||
|
|
*/
|
||
|
|
static void prvRxHandler( void *pvNetIf );
|
||
|
|
static void prvTxHandler( void *pvUnused );
|
||
|
|
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------*/
|
||
|
|
|
||
|
|
/* The instance of the xEmacLite IP being used in this driver. */
|
||
|
|
static XEmacLite xEMACInstance;
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* In this function, the hardware should be initialized.
|
||
|
|
* Called from ethernetif_init().
|
||
|
|
*
|
||
|
|
* @param pxNetIf the already initialized lwip network interface structure
|
||
|
|
* for this etherpxNetIf
|
||
|
|
*/
|
||
|
|
static void prvLowLevelInit( struct netif *pxNetIf )
|
||
|
|
{
|
||
|
|
portBASE_TYPE xStatus;
|
||
|
|
extern void vInitialisePHY( XEmacLite *xemaclitep );
|
||
|
|
unsigned portBASE_TYPE uxOriginalPriority;
|
||
|
|
|
||
|
|
/* Hardware initialisation can take some time, so temporarily lower the
|
||
|
|
task priority to ensure other functionality is not adversely effected.
|
||
|
|
The priority will get raised again before this function exits. */
|
||
|
|
uxOriginalPriority = uxTaskPriorityGet( NULL );
|
||
|
|
vTaskPrioritySet( NULL, tskIDLE_PRIORITY );
|
||
|
|
|
||
|
|
/* set MAC hardware address length */
|
||
|
|
pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;
|
||
|
|
|
||
|
|
/* set MAC hardware address */
|
||
|
|
pxNetIf->hwaddr[ 0 ] = configMAC_ADDR0;
|
||
|
|
pxNetIf->hwaddr[ 1 ] = configMAC_ADDR1;
|
||
|
|
pxNetIf->hwaddr[ 2 ] = configMAC_ADDR2;
|
||
|
|
pxNetIf->hwaddr[ 3 ] = configMAC_ADDR3;
|
||
|
|
pxNetIf->hwaddr[ 4 ] = configMAC_ADDR4;
|
||
|
|
pxNetIf->hwaddr[ 5 ] = configMAC_ADDR5;
|
||
|
|
|
||
|
|
/* device capabilities */
|
||
|
|
pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
|
||
|
|
|
||
|
|
/* maximum transfer unit */
|
||
|
|
pxNetIf->mtu = netifMAX_MTU;
|
||
|
|
|
||
|
|
/* Broadcast capability */
|
||
|
|
pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
|
||
|
|
|
||
|
|
/* Initialize the mac */
|
||
|
|
xStatus = XEmacLite_Initialize( &xEMACInstance, XPAR_EMACLITE_0_DEVICE_ID );
|
||
|
|
|
||
|
|
if( xStatus == XST_SUCCESS )
|
||
|
|
{
|
||
|
|
/* Set mac address */
|
||
|
|
XEmacLite_SetMacAddress( &xEMACInstance, ( Xuint8* )( pxNetIf->hwaddr ) );
|
||
|
|
|
||
|
|
/* Flush any frames already received */
|
||
|
|
XEmacLite_FlushReceive( &xEMACInstance );
|
||
|
|
|
||
|
|
/* Set Rx, Tx interrupt handlers */
|
||
|
|
XEmacLite_SetRecvHandler( &xEMACInstance, ( void * ) pxNetIf, prvRxHandler );
|
||
|
|
XEmacLite_SetSendHandler( &xEMACInstance, NULL, prvTxHandler );
|
||
|
|
|
||
|
|
/* Enable Rx, Tx interrupts */
|
||
|
|
XEmacLite_EnableInterrupts( &xEMACInstance );
|
||
|
|
|
||
|
|
/* Install the standard Xilinx library interrupt handler itself.
|
||
|
|
*NOTE* The xPortInstallInterruptHandler() API function must be used
|
||
|
|
for this purpose. */
|
||
|
|
xStatus = xPortInstallInterruptHandler( XPAR_INTC_0_EMACLITE_0_VEC_ID, ( XInterruptHandler ) XEmacLite_InterruptHandler, &xEMACInstance );
|
||
|
|
|
||
|
|
vInitialisePHY( &xEMACInstance );
|
||
|
|
|
||
|
|
/* Enable the interrupt in the interrupt controller.
|
||
|
|
*NOTE* The vPortEnableInterrupt() API function must be used for this
|
||
|
|
purpose. */
|
||
|
|
vPortEnableInterrupt( XPAR_INTC_0_EMACLITE_0_VEC_ID );
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Reset the task priority back to its original value. */
|
||
|
|
vTaskPrioritySet( NULL, uxOriginalPriority );
|
||
|
|
|
||
|
|
configASSERT( xStatus == pdPASS );
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This function should do the actual transmission of the packet. The packet is
|
||
|
|
* contained in the pbuf that is passed to the function. This pbuf
|
||
|
|
* might be chained.
|
||
|
|
*
|
||
|
|
* @param pxNetIf the lwip network interface structure for this etherpxNetIf
|
||
|
|
* @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
|
||
|
|
* @return ERR_OK if the packet could be sent
|
||
|
|
* an err_t value if the packet couldn't be sent
|
||
|
|
*
|
||
|
|
* @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
|
||
|
|
* strange results. You might consider waiting for space in the DMA queue
|
||
|
|
* to become available since the stack doesn't retry to send a packet
|
||
|
|
* dropped because of memory failure (except for the TCP timers).
|
||
|
|
*/
|
||
|
|
|
||
|
|
static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p )
|
||
|
|
{
|
||
|
|
|
||
|
|
/* This is taken from lwIP example code and therefore does not conform
|
||
|
|
to the FreeRTOS coding standard. */
|
||
|
|
|
||
|
|
struct pbuf *q;
|
||
|
|
static unsigned char ucBuffer[ 1520 ] __attribute__((aligned(32)));
|
||
|
|
unsigned char *pucBuffer = ucBuffer;
|
||
|
|
unsigned char *pucChar;
|
||
|
|
struct eth_hdr *pxHeader;
|
||
|
|
u16_t usTotalLength = p->tot_len - ETH_PAD_SIZE;
|
||
|
|
err_t xReturn = ERR_OK;
|
||
|
|
long x;
|
||
|
|
|
||
|
|
( void ) pxNetIf;
|
||
|
|
|
||
|
|
#if defined(LWIP_DEBUG) && LWIP_NETIF_TX_SINGLE_PBUF
|
||
|
|
LWIP_ASSERT("p->next == NULL && p->len == p->tot_len", p->next == NULL && p->len == p->tot_len);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* Initiate transfer. */
|
||
|
|
if( p->len == p->tot_len )
|
||
|
|
{
|
||
|
|
/* No pbuf chain, don't have to copy -> faster. */
|
||
|
|
pucBuffer = &( ( unsigned char * ) p->payload )[ ETH_PAD_SIZE ];
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* pbuf chain, copy into contiguous ucBuffer. */
|
||
|
|
if( p->tot_len >= sizeof( ucBuffer ) )
|
||
|
|
{
|
||
|
|
LINK_STATS_INC( link.lenerr );
|
||
|
|
LINK_STATS_INC( link.drop );
|
||
|
|
snmp_inc_ifoutdiscards( pxNetIf );
|
||
|
|
xReturn = ERR_BUF;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pucChar = ucBuffer;
|
||
|
|
|
||
|
|
for( q = p; q != NULL; q = q->next )
|
||
|
|
{
|
||
|
|
/* Send the data from the pbuf to the interface, one pbuf at a
|
||
|
|
time. The size of the data in each pbuf is kept in the ->len
|
||
|
|
variable. */
|
||
|
|
/* send data from(q->payload, q->len); */
|
||
|
|
LWIP_DEBUGF( NETIF_DEBUG, ( "NETIF: send pucChar %p q->payload %p q->len %i q->next %p\n", pucChar, q->payload, ( int ) q->len, ( void* ) q->next ) );
|
||
|
|
if( q == p )
|
||
|
|
{
|
||
|
|
memcpy( pucChar, &( ( char * ) q->payload )[ ETH_PAD_SIZE ], q->len - ETH_PAD_SIZE );
|
||
|
|
pucChar += q->len - ETH_PAD_SIZE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
memcpy( pucChar, q->payload, q->len );
|
||
|
|
pucChar += q->len;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( xReturn == ERR_OK )
|
||
|
|
{
|
||
|
|
for( x = 0; x < netifMAX_TX_ATTEMPTS; x++ )
|
||
|
|
{
|
||
|
|
xReturn = XEmacLite_Send( &xEMACInstance, pucBuffer, ( int ) usTotalLength );
|
||
|
|
if( xReturn == XST_SUCCESS )
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
vTaskDelay( netifTX_BUFFER_FREE_WAIT );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( xReturn != XST_SUCCESS )
|
||
|
|
{
|
||
|
|
LINK_STATS_INC( link.memerr );
|
||
|
|
LINK_STATS_INC( link.drop );
|
||
|
|
snmp_inc_ifoutdiscards( pxNetIf );
|
||
|
|
xReturn = ERR_BUF;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LINK_STATS_INC( link.xmit );
|
||
|
|
snmp_add_ifoutoctets( pxNetIf, usTotalLength );
|
||
|
|
pxHeader = ( struct eth_hdr * )p->payload;
|
||
|
|
|
||
|
|
if( ( pxHeader->dest.addr[ 0 ] & 1 ) != 0 )
|
||
|
|
{
|
||
|
|
/* broadcast or multicast packet*/
|
||
|
|
snmp_inc_ifoutnucastpkts( pxNetIf );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* unicast packet */
|
||
|
|
snmp_inc_ifoutucastpkts( pxNetIf );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return xReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Should allocate a pbuf and transfer the bytes of the incoming
|
||
|
|
* packet from the interface into the pbuf.
|
||
|
|
*
|
||
|
|
* @param pxNetIf the lwip network interface structure for this etherpxNetIf
|
||
|
|
* @return a pbuf filled with the received packet (including MAC header)
|
||
|
|
* NULL on memory error
|
||
|
|
*/
|
||
|
|
static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, unsigned short usDataLength )
|
||
|
|
{
|
||
|
|
struct pbuf *p = NULL, *q;
|
||
|
|
|
||
|
|
if( usDataLength > 0U )
|
||
|
|
{
|
||
|
|
#if ETH_PAD_SIZE
|
||
|
|
len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* We allocate a pbuf chain of pbufs from the pool. */
|
||
|
|
p = pbuf_alloc( PBUF_RAW, usDataLength, PBUF_POOL );
|
||
|
|
|
||
|
|
if( p != NULL )
|
||
|
|
{
|
||
|
|
#if ETH_PAD_SIZE
|
||
|
|
pbuf_header( p, -ETH_PAD_SIZE ); /* drop the padding word */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* We iterate over the pbuf chain until we have read the entire
|
||
|
|
* packet into the pbuf. */
|
||
|
|
usDataLength = 0U;
|
||
|
|
for( q = p; q != NULL; q = q->next )
|
||
|
|
{
|
||
|
|
/* Read enough bytes to fill this pbuf in the chain. The
|
||
|
|
* available data in the pbuf is given by the q->len
|
||
|
|
* variable.
|
||
|
|
* This does not necessarily have to be a memcpy, you can also preallocate
|
||
|
|
* pbufs for a DMA-enabled MAC and after receiving truncate it to the
|
||
|
|
* actually received size. In this case, ensure the usTotalLength member of the
|
||
|
|
* pbuf is the sum of the chained pbuf len members.
|
||
|
|
*/
|
||
|
|
memcpy( q->payload, &( pucInputData[ usDataLength ] ), q->len );
|
||
|
|
usDataLength += q->len;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if ETH_PAD_SIZE
|
||
|
|
pbuf_header( p, ETH_PAD_SIZE ); /* reclaim the padding word */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
LINK_STATS_INC(link.recv);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Should be called at the beginning of the program to set up the
|
||
|
|
* network interface. It calls the function prvLowLevelInit() to do the
|
||
|
|
* actual setup of the hardware.
|
||
|
|
*
|
||
|
|
* This function should be passed as a parameter to pxNetIf_add().
|
||
|
|
*
|
||
|
|
* @param pxNetIf the lwip network interface structure for this etherpxNetIf
|
||
|
|
* @return ERR_OK if the loopif is initialized
|
||
|
|
* ERR_MEM if private data couldn't be allocated
|
||
|
|
* any other err_t on error
|
||
|
|
*/
|
||
|
|
err_t ethernetif_init( struct netif *pxNetIf )
|
||
|
|
{
|
||
|
|
err_t xReturn = ERR_OK;
|
||
|
|
|
||
|
|
/* This is taken from lwIP example code and therefore does not conform
|
||
|
|
to the FreeRTOS coding standard. */
|
||
|
|
|
||
|
|
struct xEthernetIf *pxEthernetIf;
|
||
|
|
|
||
|
|
LWIP_ASSERT( "pxNetIf != NULL", ( pxNetIf != NULL ) );
|
||
|
|
|
||
|
|
pxEthernetIf = mem_malloc( sizeof( struct xEthernetIf ) );
|
||
|
|
if( pxEthernetIf == NULL )
|
||
|
|
{
|
||
|
|
LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_init: out of memory\n" ) );
|
||
|
|
xReturn = ERR_MEM;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#if LWIP_NETIF_HOSTNAME
|
||
|
|
{
|
||
|
|
/* Initialize interface hostname */
|
||
|
|
pxNetIf->hostname = "lwip";
|
||
|
|
}
|
||
|
|
#endif /* LWIP_NETIF_HOSTNAME */
|
||
|
|
|
||
|
|
pxNetIf->state = pxEthernetIf;
|
||
|
|
pxNetIf->name[ 0 ] = IFNAME0;
|
||
|
|
pxNetIf->name[ 1 ] = IFNAME1;
|
||
|
|
|
||
|
|
/* We directly use etharp_output() here to save a function call.
|
||
|
|
* You can instead declare your own function an call etharp_output()
|
||
|
|
* from it if you have to do some checks before sending (e.g. if link
|
||
|
|
* is available...) */
|
||
|
|
pxNetIf->output = etharp_output;
|
||
|
|
pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
|
||
|
|
pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;
|
||
|
|
pxNetIf->mtu = netifMAX_MTU;
|
||
|
|
pxNetIf->linkoutput = prvLowLevelOutput;
|
||
|
|
|
||
|
|
pxEthernetIf->ethaddr = ( struct eth_addr * ) &( pxNetIf->hwaddr[ 0 ] );
|
||
|
|
|
||
|
|
/* initialize the hardware */
|
||
|
|
prvLowLevelInit( pxNetIf );
|
||
|
|
}
|
||
|
|
|
||
|
|
return xReturn;
|
||
|
|
}
|
||
|
|
/*-----------------------------------------------------------*/
|
||
|
|
|
||
|
|
static void prvRxHandler( void *pvNetIf )
|
||
|
|
{
|
||
|
|
/* This is taken from lwIP example code and therefore does not conform
|
||
|
|
to the FreeRTOS coding standard. */
|
||
|
|
|
||
|
|
struct eth_hdr *pxHeader;
|
||
|
|
struct pbuf *p;
|
||
|
|
unsigned short usInputLength;
|
||
|
|
static unsigned char ucBuffer[ 1520 ] __attribute__((aligned(32)));
|
||
|
|
extern portBASE_TYPE xInsideISR;
|
||
|
|
struct netif *pxNetIf = ( struct netif * ) pvNetIf;
|
||
|
|
|
||
|
|
XIntc_AckIntr( XPAR_ETHERNET_LITE_BASEADDR, XPAR_ETHERNET_LITE_IP2INTC_IRPT_MASK );
|
||
|
|
|
||
|
|
/* Ensure the pbuf handling functions don't attempt to use critical
|
||
|
|
sections. */
|
||
|
|
xInsideISR++;
|
||
|
|
|
||
|
|
usInputLength = ( long ) XEmacLite_Recv( &xEMACInstance, ucBuffer );
|
||
|
|
|
||
|
|
/* move received packet into a new pbuf */
|
||
|
|
p = prvLowLevelInput( ucBuffer, usInputLength );
|
||
|
|
|
||
|
|
/* no packet could be read, silently ignore this */
|
||
|
|
if( p != NULL )
|
||
|
|
{
|
||
|
|
/* points to packet payload, which starts with an Ethernet header */
|
||
|
|
pxHeader = p->payload;
|
||
|
|
|
||
|
|
switch( htons( pxHeader->type ) )
|
||
|
|
{
|
||
|
|
/* IP or ARP packet? */
|
||
|
|
case ETHTYPE_IP:
|
||
|
|
case ETHTYPE_ARP:
|
||
|
|
/* full packet send to tcpip_thread to process */
|
||
|
|
if( pxNetIf->input( p, pxNetIf ) != ERR_OK )
|
||
|
|
{
|
||
|
|
LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_input: IP input error\n" ) );
|
||
|
|
pbuf_free(p);
|
||
|
|
p = NULL;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
pbuf_free( p );
|
||
|
|
p = NULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
xInsideISR--;
|
||
|
|
}
|
||
|
|
/*-----------------------------------------------------------*/
|
||
|
|
|
||
|
|
static void prvTxHandler( void *pvUnused )
|
||
|
|
{
|
||
|
|
( void ) pvUnused;
|
||
|
|
XIntc_AckIntr( XPAR_ETHERNET_LITE_BASEADDR, XPAR_ETHERNET_LITE_IP2INTC_IRPT_MASK );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|