int main() {
// Configure ethernet
XEmacLite_Config *etherconfig = XEmacLite_LookupConfig(XPAR_EMACLITE_0_DEVICE_ID);
XEmacLite_CfgInitialize(ðer, etherconfig, etherconfig->BaseAddress);
XEmacLite_SetMacAddress(ðer, mac_address); //Set our sending MAC address
XEmacLite_FlushReceive(ðer); //Clear any received messages
xil_printf("\r\n%s", "Please input the desired world size:");
// receiveWorldInfo(); // Receive the world information from the user via UART
int worldLoop, i;
worldSize = 0;
for(worldLoop = 0; worldLoop < 99999; worldLoop++){
XEmacLite_FlushReceive(ðer); //Clear any received messages
tmit_buffer[14] = 0x01; // Set the type field
tmit_buffer[15] = worldSize; // Add the world size to the transmit buffer
worldID = worldLoop;
for(i = 0; i < 4; i++){ // Add the world ID to the transmit, as it is over several bytes we need to loop through and bit shift
tmit_buffer[16 + i] = worldLoop >> 8*(3-i);
}
sendToEthernet(6); // Send the generated buffer to the server via ethernet
receiveFromEthernet();
receiveFromHardware();
receiveFromEthernet();
}
return 0;
}
/**
*
* Initialize a specific XEmacLite instance/driver. The initialization entails:
* - Initialize fields of the XEmacLite instance structure.
*
* The driver defaults to polled mode operation.
*
* @param InstancePtr is a pointer to the XEmacLite instance.
* @param DeviceId is the unique id of the device controlled by this
* XEmacLite instance. Passing in a device id associates the
* generic XEmacLite instance to a specific device, as chosen by
* the caller or application developer.
*
* @return
* - XST_SUCCESS if initialization was successful.
* - XST_DEVICE_NOT_FOUND/XST_FAILURE if device configuration
* information was not found for a device with the supplied
* device ID.
*
* @note None
*
******************************************************************************/
int XEmacLite_Initialize(XEmacLite *InstancePtr, u16 DeviceId)
{
int Status;
XEmacLite_Config *EmacLiteConfigPtr;/* Pointer to Configuration data. */
/*
* Verify that each of the inputs are valid.
*/
Xil_AssertNonvoid(InstancePtr != NULL);
/*
* Lookup the device configuration in the configuration table. Use this
* configuration info down below when initializing this driver.
*/
EmacLiteConfigPtr = XEmacLite_LookupConfig(DeviceId);
if (EmacLiteConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XEmacLite_CfgInitialize(InstancePtr,
EmacLiteConfigPtr,
EmacLiteConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
*
* The main entry point for the EmacLite driver selftest example.
*
* @param DeviceId is the XPAR_<xemaclite_instance>_DEVICE_ID value from
* xparameters.h
*
* @return XST_SUCCESS to indicate success, else XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int EMACLiteSelfTestExample(u16 DeviceId)
{
int Status;
XEmacLite_Config *ConfigPtr;
XEmacLite *InstancePtr = &EmacLite;
/*
* Initialize the EmacLite device.
*/
ConfigPtr = XEmacLite_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XEmacLite_CfgInitialize(InstancePtr,
ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run the Self Test
*/
Status = XEmacLite_SelfTest(InstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
*
* The entry point for the EmacLite Ping reply example in polled mode.
*
* @param DeviceId is device ID of the XEmacLite Device.
*
* @return XST_FAILURE to indicate failure, otherwise XST_SUCCESS is
* returned.
*
* @note This is in a continuous loop generating a specified number of
* ping replies as defined by MAX_PING_REPLIES.
*
******************************************************************************/
int EmacLitePingReplyExample(u16 DeviceId)
{
int Status;
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
XEmacLite_Config *ConfigPtr;
NumOfPingReplies = 0;
/*
* 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, LocalMacAddr);
/*
* Empty any existing receive frames.
*/
XEmacLite_FlushReceive(EmacLiteInstPtr);
while (1) {
/*
* Wait for a Receive packet.
*/
while (RecvFrameLength == 0) {
RecvFrameLength = XEmacLite_Recv(EmacLiteInstPtr,
(u8 *)RxFrame);
}
/*
* Process the Receive frame.
*/
ProcessRecvFrame(EmacLiteInstPtr);
RecvFrameLength = 0;
/*
* If the number of ping replies sent is equal to that
* specified by the user then exit out of this loop.
*/
if (NumOfPingReplies == MAX_PING_REPLIES) {
return XST_SUCCESS;
}
}
}
int main (void) {
init_platform();
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
XEmacLite_Config *ConfigPtr;
ConfigPtr = XEmacLite_LookupConfig(EMAC_DEVICE_ID);
XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
char s;
int port, dev;
unsigned int value;
#if AEL2005_SR
char port_mode_new[4] = {-1,-1,-1,-1};
char port_mode[4] = {-1,-1,-1,-1};
#endif
goto INIT;
INIT: for(port = 0; port < 4; port ++){
if(port == 0) dev = 2;
if(port == 1) dev = 1;
if(port == 2) dev = 0;
if(port == 3) dev = 3;
//xil_printf("Port %d: ", port);
ael2005_read (EmacLiteInstPtr, dev, 1, 0xa, &value);
/*if(value == 0) {
print("No Signal.\r\n");
continue;
}*/
for(s = 20; s < 36; s++){
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, s, &value);
//xil_printf("%c", value);
}
for(s = 40; s < 56; s++){
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, s, &value);
//xil_printf("%c", value);
}
//print("\r\n");
#if AEL2005_SR
// Check if we have a 10GBASE-SR cable
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, 0x3, &value);
if((value >> 4) == 1) port_mode_new[port] = MODE_SR;
else port_mode_new[port] = MODE_TWINAX;
if(port_mode_new[port] != port_mode[port]){
//xil_printf("Port %d Detected new mode %x\r\n", port, port_mode_new[port]);
test_initialize(EmacLiteInstPtr, dev, port_mode_new[port]);
port_mode[port] = port_mode_new[port];
}
#else
test_initialize(EmacLiteInstPtr, dev, MODE_TWINAX);
#endif
}
/**
*
* The entry point for the EmacLite driver to ping request example in polled
* mode. This function will generate specified number of request packets as
* defined in "NUM_OF_PING_REQ_PKTS.
*
* @param DeviceId is device ID of the XEmacLite Device.
*
* @return XST_FAILURE to indicate failure, otherwise it will return
* XST_SUCCESS.
*
* @note None.
*
******************************************************************************/
static int EmacLitePingReqExample(u16 DeviceId)
{
int Status;
int Index;
int Count;
int EchoReplyStatus;
XEmacLite_Config *ConfigPtr;
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
SeqNum = 0;
RecvFrameLength = 0;
EchoReplyStatus = XST_FAILURE;
NumOfPingReqPkts = NUM_OF_PING_REQ_PKTS;
/*
* 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, LocalMacAddr);
/*
* Empty any existing receive frames.
*/
XEmacLite_FlushReceive(EmacLiteInstPtr);
while (NumOfPingReqPkts--) {
/*
* Introduce delay.
*/
Count = DELAY;
while (Count--) {
}
/*
* Send an ARP or an ICMP packet based on receive packet.
*/
if (SeqNum == 0) {
SendArpReqFrame(EmacLiteInstPtr);
} else {
SendEchoReqFrame(EmacLiteInstPtr);
}
/*
* Check next 10 packets for the correct reply.
*/
Index = NUM_RX_PACK_CHECK_REQ;
while (Index--) {
/*
* Wait for a Receive packet.
*/
Count = NUM_PACK_CHECK_RX_PACK;
while (RecvFrameLength == 0) {
RecvFrameLength = XEmacLite_Recv(
EmacLiteInstPtr,
(u8 *)RxFrame);
/*
* To avoid infinite loop when no packet is
* received.
*/
if (Count-- == 0) {
break;
}
}
/*
* Process the Receive frame.
*/
if (RecvFrameLength != 0) {
EchoReplyStatus = ProcessRecvFrame(
EmacLiteInstPtr);
}
RecvFrameLength = 0;
/*
* Comes out of loop when an echo reply packet is
* received.
*/
if (EchoReplyStatus == XST_SUCCESS) {
break;
}
}
/*
* If no echo reply packet is received, it reports
* request timed out.
*/
if (EchoReplyStatus == XST_FAILURE) {
xil_printf("Packet No: %d",
NUM_OF_PING_REQ_PKTS - NumOfPingReqPkts);
xil_printf(" Seq NO %d Request timed out\r\n",
SeqNum);
}
}
return XST_SUCCESS;
}
/**
*
* The main entry point for the EmacLite driver example in polled 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 DeviceId is device ID of the XEmacLite Device , typically
* XPAR_<EMAC_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS to indicate success, XST_FAILURE otherwise.
*
* @note None.
*
******************************************************************************/
int EmacLitePolledExample(u16 DeviceId)
{
int Status;
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
u32 PhyAddress = 0;
RecvFrameLength = 0;
XEmacLite_Config *ConfigPtr;
/*
* 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);
/*
* 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;
}
/*
* 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) {
return XST_FAILURE;
}
}
/*
* Reset the receive frame length to zero.
*/
RecvFrameLength = 0;
Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE);
if (Status != XST_SUCCESS) {
if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
/*
* Disable the MAC Loop back in the PHY.
*/
EmacLiteDisablePhyLoopBack(EmacLiteInstPtr,
PhyAddress);
return XST_FAILURE;
}
}
/*
* If the MDIO is not configured in the core then return XST_SUCCESS
* as the frame has been transmitted.
*/
if (!XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
return XST_SUCCESS;
}
/*
* Poll for receive packet.
*/
while ((volatile u32)RecvFrameLength == 0) {
RecvFrameLength = XEmacLite_Recv(EmacLiteInstPtr,
(u8 *)RxFrame);
}
/*
* Check the received frame.
*/
Status = EmacLiteRecvFrame(EMACLITE_TEST_FRAME_SIZE);
if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) {
/*
* Disable the MAC Loop back in the PHY.
*/
EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress);
return XST_FAILURE;
}
/*
* Disable the MAC Loop back in the PHY.
*/
EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress);
return XST_SUCCESS;
}
int main()
{
static XIntc intc;
Xil_ICacheEnable();
Xil_DCacheEnable();
xil_printf("Testing UART output.\r\n");
// Camera DMA Configuration
XAxiDma_Config *dmaconf = XAxiDma_LookupConfig(XPAR_AXI_DMA_0_DEVICE_ID);
XAxiDma dma;
XAxiDma_CfgInitialize(&dma, dmaconf);
XAxiDma_Resume(&dma);
XAxiDma_Reset(&dma);
while(!XAxiDma_ResetIsDone(&dma));
// Initialize Video
InitVideo();
// Example camera DMA read
// Note - transfer MUST be 4096B
// Data format is 20-bit pixel number (stored in a 32 bit integer) followed by 16-bit RGB values
// This will not work until you implement camera_stream.v.
// (or at least, until you have it barely working)
//int resdde = XAxiDma_SimpleTransfer(&dma, (u32)((unsigned char*)&camera), 4096, XAXIDMA_DEVICE_TO_DMA);
//while(XAxiDma_Busy(&dma,XAXIDMA_DEVICE_TO_DMA));
int Status;
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
u32 PhyAddress = 0;
RecvFrameLength = 0;
XEmacLite_Config *ConfigPtr;
/*
* Initialize the EmacLite device.
*/
ConfigPtr = XEmacLite_LookupConfig(XPAR_ETHERNET_LITE_DEVICE_ID);
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;
}
/*
* Reset the receive frame length to zero.
*/
RecvFrameLength = 0;
// Example program that sends packets and changes the color of an on-screen box upon receiving a packet.
unsigned char c = 0;
unsigned char r=0xFF, g=0x0, b=0x0;
while(1) {
c++;
if(XEmacLite_IsTxDone(ConfigPtr->BaseAddress)) {
Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE);
if (Status != XST_SUCCESS) {
if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) {
return XST_FAILURE;
}
}
}
else {
RecvFrameLength = XEmacLite_Recv(EmacLiteInstPtr, (u8 *)RxFrame);
if (RecvFrameLength > 0) {
xil_printf("Received a packet!\r\n");
unsigned char oldr = r;
r=g;
g=b;
b=oldr;
}
// Example of writing data to the screen
int x, y;
for (x = 0; x < 20; x++)
for (y = 0; y < 20; y++)
if (t[y*20 + x]) {
fptr[y*640*4 + x*4] = b;
fptr[y*640*4 + x*4 + 1] = g;
fptr[y*640*4 + x*4 + 2] = r;
}
}
}
Xil_DCacheDisable();
Xil_ICacheDisable();
return 0;
}
/**
*
* 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;
}
/**
*
* 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;
}
int main (void) {
init_platform();
XEmacLite *EmacLiteInstPtr = &EmacLiteInstance;
XEmacLite_Config *ConfigPtr;
ConfigPtr = XEmacLite_LookupConfig(EMAC_DEVICE_ID);
XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
// Hold AXI4-Stream Packet Generator/Checker
Xil_Out32(XPAR_NF10_AXIS_GEN_CHECK_0_BASEADDR+0x3, 0x1);
Xil_Out32(XPAR_NF10_AXIS_GEN_CHECK_1_BASEADDR+0x3, 0x1);
char s;
int port, dev;
unsigned int value;
#if AEL2005_SR
char port_mode_new[4] = {-1,-1,-1,-1};
char port_mode[4] = {-1,-1,-1,-1};
#endif
print("hiiiiiiiiiiiiiii");
goto INIT;
while(1){
print("==NetFPGA-10G==\r\n");
print("i : Initialize AEL2005\r\n");
print("s : Dump status\r\n");
print("t : Run AXI4-Stream Gen/Check\r\n");
print("r : Stop AXI4-Stream Gen/Check\r\n");
s = inbyte();
if(s == 'i'){
INIT: for(port = 0; port < 4; port ++){
if(port == 0) dev = 2;
if(port == 1) dev = 1;
if(port == 2) dev = 0;
if(port == 3) dev = 3;
xil_printf("Port %d: ", port);
ael2005_read (EmacLiteInstPtr, dev, 1, 0xa, &value);
/*if(value == 0) {
print("No Signal.\r\n");
continue;
}*/
for(s = 20; s < 36; s++){
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, s, &value);
xil_printf("%c", value);
}
for(s = 40; s < 56; s++){
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, s, &value);
xil_printf("%c", value);
}
print("\r\n");
#if AEL2005_SR
// Check if we have a 10GBASE-SR cable
ael2005_i2c_read (EmacLiteInstPtr, dev, MODULE_DEV_ADDR, 0x3, &value);
if((value >> 4) == 1) port_mode_new[port] = MODE_SR;
else port_mode_new[port] = MODE_TWINAX;
if(port_mode_new[port] != port_mode[port]){
xil_printf("Port %d Detected new mode %x\r\n", port, port_mode_new[port]);
test_initialize(EmacLiteInstPtr, dev, port_mode_new[port]);
port_mode[port] = port_mode_new[port];
}
#else
test_initialize(EmacLiteInstPtr, dev, MODE_TWINAX);
#endif
}
}
