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 } }