//
// This function is called to "start up" the interface. It may be called
// multiple times, even when the hardware is already running. It will be
// called whenever something "hardware oriented" changes and should leave
// the hardware ready to send/receive packets.
//
static void
s3esk_eth_start(struct eth_drv_sc *sc, unsigned char *enaddr, int flags)
{
/*
struct s3esk_eth_info *qi = (struct s3esk_eth_info *)sc->driver_private;
unsigned short phy_state = 0;
// Enable the device
XEmac_Start(&qi->dev);
phy_state = _eth_phy_state(qi->phy);
diag_printf("s3esk ETH: ");
if ((phy_state & ETH_PHY_STAT_LINK) != 0) {
diag_printf( "Link detected - " );
if ((phy_state & ETH_PHY_STAT_100MB) != 0) {
// Link can handle 100Mb
diag_printf("100Mb");
if ((phy_state & ETH_PHY_STAT_FDX) != 0) {
diag_printf("/Full Duplex");
}
} else {
// Assume 10Mb, half duplex
diag_printf("10Mb");
}
} else
diag_printf("s3esk ETH: Waiting for link to come up\n" );
diag_printf("\n");
*/
struct s3esk_eth_info *qi = (struct s3esk_eth_info *)sc->driver_private;
XEmacLite_EnableInterrupts(&qi->dev);
}
/**
*
* The main entry point for the EmacLite driver in interrupt mode example.
* This function will transmit/receive the frame using internal loop back and
* verify the data in the received frame.
*
* @param DeviceId is device ID of the XEmacLite Device , typically
* XPAR_<EMAC_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS to indicate success, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int EmacLiteIntrLoopbackExample(u16 DeviceId)
{
int Status;
XIntc *IntcInstancePtr;
XEmacLite *EmacLiteInstPtr;
u32 TxLength;
XEmacLite_Config *ConfigPtr;
RecvFrameLength = 0;
IntcInstancePtr = &IntcInstance;
EmacLiteInstPtr =&EmacLiteInstance;
/*
* Initialize the EmacLite device.
*/
ConfigPtr = XEmacLite_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the MAC address.
*/
XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress);
/*
* Set up the interrupt infrastructure.
*/
Status = EmacLiteSetupIntrSystem(IntcInstancePtr, EmacLiteInstPtr,
INTC_EMACLITE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the EmacLite handlers.
*/
XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler)EmacLiteRecvHandler);
XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler)EmacLiteSendHandler);
/*
* Empty any existing receive frames.
*/
XEmacLite_FlushReceive(EmacLiteInstPtr);
/*
* Enable the EmacLite interrupts.
*/
XEmacLite_EnableInterrupts(EmacLiteInstPtr);
/*
* Check if there is a Tx buffer available.
*/
if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) {
return XST_FAILURE;
}
/*
* Enable internal loop back.
*/
XEmacLite_EnableLoopBack(EmacLiteInstPtr);
/*
* Send/Receive frames of varying sizes and verify the data in the
* received frames.
*/
for (TxLength = 1; TxLength <= XEL_MTU_SIZE; ) {
RecvFrameLength = 0;
/*
* Send a frame.
*/
Status = EmacLiteSendFrame(EmacLiteInstPtr, TxLength);
if (Status != XST_SUCCESS) {
/*
* Disable internal loop back.
*/
XEmacLite_DisableLoopBack(EmacLiteInstPtr);
return XST_FAILURE;
}
/*
* Wait for the frame to be transmitted and received back.
* As the core is in loopback the transmit interrupt and the
* receive interrupt occur simulataneously.
*/
while ((RecvFrameLength == 0) && (TransmitComplete == FALSE));
/*
* Check the receive frame.
*/
Status = EmacLiteRecvFrame(TxLength++);
if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) {
/*
* Disable internal loop back.
*/
XEmacLite_DisableLoopBack(EmacLiteInstPtr);
/*
* Disable and disconnect the EmacLite Interrupts.
*/
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr,
INTC_EMACLITE_ID);
return XST_FAILURE;
}
}
/*
* Disable internal loop back.
*/
XEmacLite_DisableLoopBack(EmacLiteInstPtr);
/*
* Disable and disconnect the EmacLite Interrupts.
*/
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr, INTC_EMACLITE_ID);
return XST_SUCCESS;
}
/**
* 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 );
}
static err_t low_level_init(struct netif *netif)
{
struct xemac_s *xemac;
XEmacLite_Config *config;
XEmacLite *xemaclitep;
struct xtopology_t *xtopologyp;
xemacliteif_s *xemacliteif;
unsigned link_speed = 1000;
xemaclitep = mem_malloc(sizeof *xemaclitep);
#ifndef XLWIP_CONFIG_INCLUDE_EMACLITE_ON_ZYNQ
#if XPAR_INTC_0_HAS_FAST == 1
xemaclitep_fast = xemaclitep;
#endif
#endif
if (xemaclitep == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
xemac = mem_malloc(sizeof *xemac);
if (xemac == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
xemacliteif = mem_malloc(sizeof *xemacliteif);
if (xemacliteif == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
/* obtain pointer to topology structure for this emac */
xemac->topology_index = xtopology_find_index((unsigned)(netif->state));
xtopologyp = &xtopology[xemac->topology_index];
/* obtain config of this emaclite */
config = xemaclite_lookup_config((unsigned)(netif->state));
/* maximum transfer unit */
netif->mtu = XEL_MTU_SIZE;
/* broadcast capability */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
/* initialize the mac */
XEmacLite_Initialize(xemaclitep, config->DeviceId);
xemaclitep->NextRxBufferToUse = 0;
#if XLWIP_CONFIG_INCLUDE_EMACLITE_ON_ZYNQ == 1
XScuGic_RegisterHandler(xtopologyp->scugic_baseaddr,
xtopologyp->intc_emac_intr,
(Xil_ExceptionHandler)XEmacLite_InterruptHandler,
xemaclitep);
XScuGic_SetPriTrigTypeByDistAddr(INTC_DIST_BASE_ADDR,
xtopologyp->intc_emac_intr,
EMACLITE_INTR_PRIORITY_SET_IN_GIC,
TRIG_TYPE_RISING_EDGE_SENSITIVE);
XScuGic_EnableIntr(INTC_DIST_BASE_ADDR,
xtopologyp->intc_emac_intr);
#else
#if NO_SYS
#if XPAR_INTC_0_HAS_FAST == 1
XIntc_RegisterFastHandler(xtopologyp->intc_baseaddr,
xtopologyp->intc_emac_intr,
(XFastInterruptHandler)XEmacLite_FastInterruptHandler);
#else
XIntc_RegisterHandler(xtopologyp->intc_baseaddr,
xtopologyp->intc_emac_intr,
(XInterruptHandler)XEmacLite_InterruptHandler,
xemaclitep);
#endif
#else
xPortInstallInterruptHandler( XPAR_INTC_0_EMACLITE_0_VEC_ID, ( XInterruptHandler ) XEmacLite_InterruptWrapper, xemaclitep );
vPortEnableInterrupt( XPAR_INTC_0_EMACLITE_0_VEC_ID );
#endif
#endif
/* set mac address */
XEmacLite_SetMacAddress(xemaclitep, (unsigned char*)(netif->hwaddr));
/* flush any frames already received */
XEmacLite_FlushReceive(xemaclitep);
/* set Rx, Tx interrupt handlers */
XEmacLite_SetRecvHandler(xemaclitep, (void *)(xemac), xemacif_recv_handler);
XEmacLite_SetSendHandler(xemaclitep, (void *)(xemac), xemacif_send_handler);
/* enable Rx, Tx interrupts */
XEmacLite_EnableInterrupts(xemaclitep);
#if !NO_SYS
sys_sem_new(&xemac->sem_rx_data_available, 0);
#endif
/* replace the state in netif (currently the base address of emaclite)
* with the xemacliteif instance pointer.
* this contains a pointer to the config table entry
*/
xemac->type = xemac_type_xps_emaclite;
xemac->state = (void *)xemacliteif;
netif->state = (void *)xemac;
xemacliteif->instance = xemaclitep;
xemacliteif->recv_q = pq_create_queue();
if (!xemacliteif->recv_q)
return ERR_MEM;
xemacliteif->send_q = pq_create_queue();
if (!xemacliteif->send_q)
return ERR_MEM;
/* Initialize PHY */
/* set PHY <--> MAC data clock */
#ifdef CONFIG_LINKSPEED_AUTODETECT
link_speed = get_IEEE_phy_speed_emaclite(xemaclitep);
xil_printf("auto-negotiated link speed: %d\r\n", link_speed);
#elif defined(CONFIG_LINKSPEED1000)
xil_printf("Link speed of 1000 Mbps not possible\r\n");
#elif defined(CONFIG_LINKSPEED100)
link_speed = 100;
configure_IEEE_phy_speed_emaclite(xemaclitep, link_speed);
xil_printf("link speed: %d\r\n", link_speed);
#elif defined(CONFIG_LINKSPEED10)
link_speed = 10;
configure_IEEE_phy_speed_emaclite(xemaclitep, link_speed);
xil_printf("link speed: %d\r\n", link_speed);
#endif
return ERR_OK;
}
/**
*
* The main entry point for the EmacLite driver example in interrupt mode.
* This function will transmit/receive the Ethernet frames and verify the
* data in the received frame (if the MDIO interface is configured in the
* EmacLite core).
* This function simply transmits a frame if the MDIO interface is not
* configured in the EmacLite core.
*
* @param IntcInstancePtr is a pointer to the instance of the Intc.
* @param EmacLiteInstPtr is a pointer to the instance of the EmacLite.
* @param EmacLiteDeviceId is device ID of the XEmacLite Device ,
* typically XPAR_<EMACLITE_instance>_DEVICE_ID value from
* xparameters.h.
* @param EmacLiteIntrId is the interrupt ID and is typically
* XPAR_<INTC_instance>_<EMACLITE_instance>_VEC_ID value from
* xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int EmacLiteIntrExample(INTC *IntcInstancePtr,
XEmacLite *EmacLiteInstPtr,
u16 EmacLiteDeviceId,
u16 EmacLiteIntrId)
{
int Status;
u32 PhyAddress = 0;
XEmacLite_Config *ConfigPtr;
/*
* Initialize the EmacLite device.
*/
ConfigPtr = XEmacLite_LookupConfig(EmacLiteDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XEmacLite_CfgInitialize(EmacLiteInstPtr,
ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the MAC address.
*/
XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress);
/*
* Empty any existing receive frames.
*/
XEmacLite_FlushReceive(EmacLiteInstPtr);
/*
* Check if there is a Tx buffer available, if there isn't it is an
* error.
*/
if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) {
return XST_FAILURE;
}
/*
* Set up the interrupt infrastructure.
*/
Status = EmacLiteSetupIntrSystem(IntcInstancePtr,
EmacLiteInstPtr,
EmacLiteIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the EmacLite handlers.
*/
XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler)EmacLiteRecvHandler);
XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler)EmacLiteSendHandler);
/*
* Enable the interrupts in the EmacLite controller.
*/
XEmacLite_EnableInterrupts(EmacLiteInstPtr);
RecvFrameLength = 0;
/*
* If the MDIO is configured in the device.
*/
if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
/*
* Detect the PHY device and enable the MAC Loop back
* in the PHY.
*/
PhyAddress = EmacLitePhyDetect(EmacLiteInstPtr);
Status = EmacLiteEnablePhyLoopBack(EmacLiteInstPtr,
PhyAddress);
if (Status != XST_SUCCESS) {
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr,
EmacLiteIntrId);
return XST_FAILURE;
}
}
/*
* Transmit an Ethernet frame.
*/
Status = EmacLiteSendFrame(EmacLiteInstPtr,
EMACLITE_TEST_FRAME_SIZE);
if (Status != XST_SUCCESS) {
if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
/*
* Disable the MAC Loop back in the PHY and
* disable/disconnect the EmacLite Interrupts.
*/
EmacLiteDisablePhyLoopBack(EmacLiteInstPtr,
PhyAddress);
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr,
EmacLiteIntrId);
return XST_FAILURE;
}
}
/*
* Wait for the frame to be transmitted.
*/
while (TransmitComplete == FALSE);
/*
* If the MDIO is not configured in the core then return XST_SUCCESS
* as the frame has been transmitted.
*/
if (!XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
/*
* Disable and disconnect the EmacLite Interrupts.
*/
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId);
return XST_SUCCESS;
}
/*
* Wait for the frame to be received.
*/
while (RecvFrameLength == 0);
/*
* Check the received frame.
*/
Status = EmacLiteRecvFrame(EMACLITE_TEST_FRAME_SIZE);
/*
* Diasble the Loop Back.
*/
if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
/*
* Disable the MAC Loop back in the PHY.
*/
Status |= EmacLiteDisablePhyLoopBack(EmacLiteInstPtr,
PhyAddress);
}
/*
* Disable and disconnect the EmacLite Interrupts.
*/
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId);
if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
*
* The main entry point for the EmacLite driver in interrupt mode example.
*
* @param IntcInstancePtr is a pointer to the instance of the Intc.
* @param EmacLiteInstPtr is a pointer to the instance of the EmacLite.
* @param EmacLiteDeviceId is device ID of the XEmacLite Device , typically
* XPAR_<EMACLITE_instance>_DEVICE_ID value from xparameters.h.
* @param EmacLiteIntrId is the interrupt ID and is typically
* XPAR_<INTC_instance>_<EMACLITE_instance>_IP2INTC_IRPT_INTR
* value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
XStatus EmacLiteExample(XIntc *IntcInstancePtr,
XEmacLite *EmacLiteInstPtr,
Xuint16 EmacLiteDeviceId,
Xuint16 EmacLiteIntrId)
{
XStatus Status;
/*
* Initialize the EmacLite device.
*/
Status = XEmacLite_Initialize(EmacLiteInstPtr, EmacLiteDeviceId);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
/*
* Set the MAC address.
*/
XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress);
/*
* Set up the interrupt infrastructure.
*/
Status = EmacLiteSetupIntrSystem(IntcInstancePtr,
EmacLiteInstPtr,
EmacLiteIntrId);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
/*
* Setup the EmacLite handlers.
*/
XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler) EmacLiteRecvHandler);
XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr),
(XEmacLite_Handler) EmacLiteSendHandler);
/*
* Empty any existing receive frames.
*/
XEmacLite_FlushReceive(EmacLiteInstPtr);
/*
* Enable the interrupts in the EmacLite controller.
*/
XEmacLite_EnableInterrupts(EmacLiteInstPtr);
/*
* Check if there is a Tx buffer available, if there isn't it is an error.
*/
if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != XTRUE)
{
return XST_FAILURE;
}
/*
* Transmit a ethernet frame.
*/
Status = EmacLiteSendFrame(EmacLiteInstPtr,
EMACLITE_TEST_FRAME_SIZE,
RemoteAddress);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
/*
* Wait for the frame to be transmitted.
*/
while (TransmitComplete == XFALSE);
/*
* Disable and disconnect the EmacLite Interrupts.
*/
XEmacLite_DisableInterrupts(EmacLiteInstPtr);
EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId);
return XST_SUCCESS;
}
static err_t
low_level_init(struct netif *netif)
{
struct xemac_s *xemac;
XEmacLite_Config *config;
XEmacLite *xemaclitep;
struct xtopology_t *xtopologyp;
xemacliteif_s *xemacliteif;
xemaclitep = mem_malloc(sizeof *xemaclitep);
if (xemaclitep == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
xemac = mem_malloc(sizeof *xemac);
if (xemac == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
xemacliteif = mem_malloc(sizeof *xemacliteif);
if (xemac == NULL) {
LWIP_DEBUGF(NETIF_DEBUG, ("xemacliteif_init: out of memory\r\n"));
return ERR_MEM;
}
/* obtain pointer to topology structure for this emac */
xemac->topology_index = xtopology_find_index((unsigned)(netif->state));
xtopologyp = &xtopology[xemac->topology_index];
/* obtain config of this emaclite */
config = xemaclite_lookup_config((unsigned)(netif->state));
/* maximum transfer unit */
netif->mtu = XEL_MTU_SIZE;
/* broadcast capability */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
/* initialize the mac */
XEmacLite_Initialize(xemaclitep, config->DeviceId);
xemaclitep->NextRxBufferToUse = 0;
#if NO_SYS
XIntc_RegisterHandler(xtopologyp->intc_baseaddr,
xtopologyp->intc_emac_intr,
(XInterruptHandler)XEmacLite_InterruptHandler,
xemaclitep);
#else
#include "xmk.h"
register_int_handler(xtopologyp->intc_emac_intr,
(XInterruptHandler)XEmacLite_InterruptHandler,
xemaclitep);
enable_interrupt(xtopologyp->intc_emac_intr);
#endif
/* set mac address */
XEmacLite_SetMacAddress(xemaclitep, (Xuint8*)(netif->hwaddr));
/* flush any frames already received */
XEmacLite_FlushReceive(xemaclitep);
/* set Rx, Tx interrupt handlers */
XEmacLite_SetRecvHandler(xemaclitep, (void *)(xemac), xemacif_recv_handler);
XEmacLite_SetSendHandler(xemaclitep, (void *)(xemac), xemacif_send_handler);
/* enable Rx, Tx interrupts */
XEmacLite_EnableInterrupts(xemaclitep);
#if !NO_SYS
xemac->sem_rx_data_available = sys_sem_new(0);
#endif
/* replace the state in netif (currently the base address of emaclite)
* with the xemacliteif instance pointer.
* this contains a pointer to the config table entry
*/
xemac->type = xemac_type_xps_emaclite;
xemac->state = (void *)xemacliteif;
netif->state = (void *)xemac;
xemacliteif->instance = xemaclitep;
xemacliteif->recv_q = pq_create_queue();
if (!xemacliteif->recv_q)
return ERR_MEM;
xemacliteif->send_q = pq_create_queue();
if (!xemacliteif->send_q)
return ERR_MEM;
return ERR_OK;
}
//
// This function is called to "start up" the interface. It may be called
// multiple times, even when the hardware is already running. It will be
// called whenever something "hardware oriented" changes and should leave
// the hardware ready to send/receive packets.
//
static void emaclite_start(struct eth_drv_sc *sc, unsigned char *enaddr, int flags)
{
struct emaclite_info *qi = (struct emaclite_info *)sc->driver_private;
XEmacLite_EnableInterrupts(&qi->dev);
}