void setup_isr( xemacpsif_s *xemacpsif ) { /* * Setup callbacks */ XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_DMASEND, (void *) emacps_send_handler, (void *) xemacpsif); XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_DMARECV, (void *) emacps_recv_handler, (void *) xemacpsif); XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_ERROR, (void *) emacps_error_handler, (void *) xemacpsif); }
void setup_isr (struct xemac_s *xemac) { xemacpsif_s *xemacpsif; xemacpsif = (xemacpsif_s *)(xemac->state); /* * Setup callbacks */ XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_DMASEND, (void *) emacps_send_handler, (void *) xemac); XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_DMARECV, (void *) emacps_recv_handler, (void *) xemac); XEmacPs_SetHandler(&xemacpsif->emacps, XEMACPS_HANDLER_ERROR, (void *) emacps_error_handler, (void *) xemac); }
/** * This function resets the device but preserves the options set by the user. * * The descriptor list could be reinitialized with the same calls to * XEmacPs_BdRingClone() as used in main(). Doing this is a matter of * preference. * In many cases, an OS may have resources tied up in the descriptors. * Reinitializing in this case may bad for the OS since its resources may be * permamently lost. * * @param EmacPsInstancePtr is a pointer to the instance of the EmacPs * driver. * * @return XST_SUCCESS if successful, else XST_FAILURE. * * @note None. * *****************************************************************************/ static int EmacPsResetDevice(XEmacPs * EmacPsInstancePtr) { int Status = 0; u8 MacSave[6]; u32 Options; XEmacPs_Bd BdTemplate; /* * Stop device */ XEmacPs_Stop(EmacPsInstancePtr); /* * Save the device state */ XEmacPs_GetMacAddress(EmacPsInstancePtr, &MacSave, 1); Options = XEmacPs_GetOptions(EmacPsInstancePtr); /* * Stop and reset the device */ XEmacPs_Reset(EmacPsInstancePtr); /* * Restore the state */ XEmacPs_SetMacAddress(EmacPsInstancePtr, &MacSave, 1); Status |= XEmacPs_SetOptions(EmacPsInstancePtr, Options); Status |= XEmacPs_ClearOptions(EmacPsInstancePtr, ~Options); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap("Error restoring state after reset"); return XST_FAILURE; } /* * Setup callbacks */ Status = XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_DMASEND, (void *) XEmacPsSendHandler, EmacPsInstancePtr); Status |= XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_DMARECV, (void *) XEmacPsRecvHandler, EmacPsInstancePtr); Status |= XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_ERROR, (void *) XEmacPsErrorHandler, EmacPsInstancePtr); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap("Error assigning handlers"); return XST_FAILURE; } /* * Setup RxBD space. * * We have already defined a properly aligned area of memory to store * RxBDs at the beginning of this source code file so just pass its * address into the function. No MMU is being used so the physical and * virtual addresses are the same. * * Setup a BD template for the Rx channel. This template will be copied * to every RxBD. We will not have to explicitly set these again. */ XEmacPs_BdClear(&BdTemplate); /* * Create the RxBD ring */ Status = XEmacPs_BdRingCreate(&(XEmacPs_GetRxRing (EmacPsInstancePtr)), RX_BD_LIST_START_ADDRESS, RX_BD_LIST_START_ADDRESS, XEMACPS_BD_ALIGNMENT, RXBD_CNT); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up RxBD space, BdRingCreate"); return XST_FAILURE; } Status = XEmacPs_BdRingClone(& (XEmacPs_GetRxRing(EmacPsInstancePtr)), &BdTemplate, XEMACPS_RECV); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up RxBD space, BdRingClone"); return XST_FAILURE; } /* * Setup TxBD space. * * Like RxBD space, we have already defined a properly aligned area of * memory to use. * * Also like the RxBD space, we create a template. Notice we don't set * the "last" attribute. The examples will be overriding this * attribute so it does no good to set it up here. */ XEmacPs_BdClear(&BdTemplate); XEmacPs_BdSetStatus(&BdTemplate, XEMACPS_TXBUF_USED_MASK); /* * Create the TxBD ring */ Status = XEmacPs_BdRingCreate(&(XEmacPs_GetTxRing (EmacPsInstancePtr)), TX_BD_LIST_START_ADDRESS, TX_BD_LIST_START_ADDRESS, XEMACPS_BD_ALIGNMENT, TXBD_CNT); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up TxBD space, BdRingCreate"); return XST_FAILURE; } Status = XEmacPs_BdRingClone(& (XEmacPs_GetTxRing(EmacPsInstancePtr)), &BdTemplate, XEMACPS_SEND); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up TxBD space, BdRingClone"); return XST_FAILURE; } /* * Restart the device */ XEmacPs_Start(EmacPsInstancePtr); return XST_SUCCESS; }
/** * * This function demonstrates the usage of the EmacPs driver by sending by * sending and receiving frames in interrupt driven DMA mode. * * * @param IntcInstancePtr is a pointer to the instance of the Intc driver. * @param EmacPsInstancePtr is a pointer to the instance of the EmacPs * driver. * @param EmacPsDeviceId is Device ID of the EmacPs Device , typically * XPAR_<EMACPS_instance>_DEVICE_ID value from xparameters.h. * @param EmacPsIntrId is the Interrupt ID and is typically * XPAR_<EMACPS_instance>_INTR value from xparameters.h. * * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE. * * @note None. * *****************************************************************************/ int EmacPsDmaIntrExample(XScuGic * IntcInstancePtr, XEmacPs * EmacPsInstancePtr, u16 EmacPsDeviceId, u16 EmacPsIntrId) { int Status; XEmacPs_Config *Config; XEmacPs_Bd BdTemplate; #ifndef PEEP u32 SlcrTxClkCntrl; #endif /*************************************/ /* Setup device for first-time usage */ /*************************************/ /* SLCR unlock */ *(volatile unsigned int *)(SLCR_UNLOCK_ADDR) = SLCR_UNLOCK_KEY_VALUE; #ifdef PEEP *(volatile unsigned int *)(SLCR_GEM0_CLK_CTRL_ADDR) = SLCR_GEM_1G_CLK_CTRL_VALUE; *(volatile unsigned int *)(SLCR_GEM1_CLK_CTRL_ADDR) = SLCR_GEM_1G_CLK_CTRL_VALUE; #else if (EmacPsIntrId == XPS_GEM0_INT_ID) { #ifdef XPAR_PS7_ETHERNET_0_ENET_SLCR_1000MBPS_DIV0 /* GEM0 1G clock configuration*/ SlcrTxClkCntrl = *(volatile unsigned int *)(SLCR_GEM0_CLK_CTRL_ADDR); SlcrTxClkCntrl &= EMACPS_SLCR_DIV_MASK; SlcrTxClkCntrl |= (XPAR_PS7_ETHERNET_0_ENET_SLCR_1000MBPS_DIV1 << 20); SlcrTxClkCntrl |= (XPAR_PS7_ETHERNET_0_ENET_SLCR_1000MBPS_DIV0 << 8); *(volatile unsigned int *)(SLCR_GEM0_CLK_CTRL_ADDR) = SlcrTxClkCntrl; #endif } else if (EmacPsIntrId == XPS_GEM1_INT_ID) { #ifdef XPAR_PS7_ETHERNET_1_ENET_SLCR_1000MBPS_DIV1 /* GEM1 1G clock configuration*/ SlcrTxClkCntrl = *(volatile unsigned int *)(SLCR_GEM1_CLK_CTRL_ADDR); SlcrTxClkCntrl &= EMACPS_SLCR_DIV_MASK; SlcrTxClkCntrl |= (XPAR_PS7_ETHERNET_1_ENET_SLCR_1000MBPS_DIV1 << 20); SlcrTxClkCntrl |= (XPAR_PS7_ETHERNET_1_ENET_SLCR_1000MBPS_DIV0 << 8); *(volatile unsigned int *)(SLCR_GEM1_CLK_CTRL_ADDR) = SlcrTxClkCntrl; #endif } #endif /* SLCR lock */ *(unsigned int *)(SLCR_LOCK_ADDR) = SLCR_LOCK_KEY_VALUE; sleep(1); /* * Initialize instance. Should be configured for DMA * This example calls _CfgInitialize instead of _Initialize due to * retiring _Initialize. So in _CfgInitialize we use * XPAR_(IP)_BASEADDRESS to make sure it is not virtual address. */ Config = XEmacPs_LookupConfig(EmacPsDeviceId); Status = XEmacPs_CfgInitialize(EmacPsInstancePtr, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap("Error in initialize"); return XST_FAILURE; } /* * Set the MAC address */ Status = XEmacPs_SetMacAddress(EmacPsInstancePtr, EmacPsMAC, 1); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap("Error setting MAC address"); return XST_FAILURE; } /* * Setup callbacks */ Status = XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_DMASEND, (void *) XEmacPsSendHandler, EmacPsInstancePtr); Status |= XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_DMARECV, (void *) XEmacPsRecvHandler, EmacPsInstancePtr); Status |= XEmacPs_SetHandler(EmacPsInstancePtr, XEMACPS_HANDLER_ERROR, (void *) XEmacPsErrorHandler, EmacPsInstancePtr); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap("Error assigning handlers"); return XST_FAILURE; } /* * The BDs need to be allocated in uncached memory. Hence the 1 MB * address range that starts at address 0xFF00000 is made uncached. */ Xil_SetTlbAttributes(0x0FF00000, 0xc02); /* * Setup RxBD space. * * We have already defined a properly aligned area of memory to store * RxBDs at the beginning of this source code file so just pass its * address into the function. No MMU is being used so the physical * and virtual addresses are the same. * * Setup a BD template for the Rx channel. This template will be * copied to every RxBD. We will not have to explicitly set these * again. */ XEmacPs_BdClear(&BdTemplate); /* * Create the RxBD ring */ Status = XEmacPs_BdRingCreate(&(XEmacPs_GetRxRing (EmacPsInstancePtr)), RX_BD_LIST_START_ADDRESS, RX_BD_LIST_START_ADDRESS, XEMACPS_BD_ALIGNMENT, RXBD_CNT); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up RxBD space, BdRingCreate"); return XST_FAILURE; } Status = XEmacPs_BdRingClone(&(XEmacPs_GetRxRing(EmacPsInstancePtr)), &BdTemplate, XEMACPS_RECV); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up RxBD space, BdRingClone"); return XST_FAILURE; } /* * Setup TxBD space. * * Like RxBD space, we have already defined a properly aligned area * of memory to use. * * Also like the RxBD space, we create a template. Notice we don't * set the "last" attribute. The example will be overriding this * attribute so it does no good to set it up here. */ XEmacPs_BdClear(&BdTemplate); XEmacPs_BdSetStatus(&BdTemplate, XEMACPS_TXBUF_USED_MASK); /* * Create the TxBD ring */ Status = XEmacPs_BdRingCreate(&(XEmacPs_GetTxRing (EmacPsInstancePtr)), TX_BD_LIST_START_ADDRESS, TX_BD_LIST_START_ADDRESS, XEMACPS_BD_ALIGNMENT, TXBD_CNT); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up TxBD space, BdRingCreate"); return XST_FAILURE; } Status = XEmacPs_BdRingClone(&(XEmacPs_GetTxRing(EmacPsInstancePtr)), &BdTemplate, XEMACPS_SEND); if (Status != XST_SUCCESS) { EmacPsUtilErrorTrap ("Error setting up TxBD space, BdRingClone"); return XST_FAILURE; } /* * Set emacps to phy loopback */ #ifndef PEEP /* For Zynq board */ XEmacPs_SetMdioDivisor(EmacPsInstancePtr, MDC_DIV_224); sleep(1); #endif EmacPsUtilEnterLoopback(EmacPsInstancePtr, EMACPS_LOOPBACK_SPEED_1G); XEmacPs_SetOperatingSpeed(EmacPsInstancePtr, EMACPS_LOOPBACK_SPEED_1G); /* * Setup the interrupt controller and enable interrupts */ Status = EmacPsSetupIntrSystem(IntcInstancePtr, EmacPsInstancePtr, EmacPsIntrId); /* * Run the EmacPs DMA Single Frame Interrupt example */ Status = EmacPsDmaSingleFrameIntrExample(EmacPsInstancePtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Disable the interrupts for the EmacPs device */ EmacPsDisableIntrSystem(IntcInstancePtr, EmacPsIntrId); /* * Stop the device */ XEmacPs_Stop(EmacPsInstancePtr); return XST_SUCCESS; }