/* * this function is always called with interrupts off * this function also assumes that there are available BD's */ static err_t _unbuffered_low_level_output(xlltemacif_s *xlltemacif, struct pbuf *p) { XStatus status = 0; #if ETH_PAD_SIZE pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */ #endif if (XLlTemac_IsDma(&xlltemacif->lltemac)) status = lldma_sgsend(xlltemacif, p); else status = xllfifo_send(xlltemacif, p); if (status != XST_SUCCESS) { #if LINK_STATS lwip_stats.link.drop++; #endif } #if ETH_PAD_SIZE pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */ #endif #if LINK_STATS lwip_stats.link.xmit++; #endif /* LINK_STATS */ return ERR_OK; }
int is_tx_space_available(xlltemacif_s *emac) { if (XLlTemac_IsDma(&emac->lltemac)) { XLlDma_BdRing *txring = &XLlDma_GetTxRing(&emac->lldma); /* tx space is available as long as there are valid BD's */ return XLlDma_BdRingGetFreeCnt(txring); } else { return ((XLlFifo_TxVacancy(&emac->llfifo) * 4) > XTE_MAX_FRAME_SIZE); } }
/** * * This function demonstrates the usage usage of the TEMAC by sending by sending * and receiving frames in interrupt driven SGDMA mode. * * * @param IntcInstancePtr is a pointer to the instance of the Intc component. * @param TemacInstancePtr is a pointer to the instance of the Temac * component. * @param TemacDeviceId is Device ID of the Temac Device , typically * XPAR_<TEMAC_instance>_DEVICE_ID value from xparameters.h. * @param TemacIntrId is the Interrupt ID and is typically * XPAR_<INTC_instance>_<TEMAC_instance>_IP2INTC_IRPT_INTR * value from xparameters.h. * * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ int TemacSgDmaIntrExample(XIntc * IntcInstancePtr, XLlTemac * TemacInstancePtr, XLlDma * DmaInstancePtr, u16 TemacDeviceId, u16 TemacIntrId, u16 DmaRxIntrId, u16 DmaTxIntrId) { int Status; u32 Rdy; int dma_mode; XLlTemac_Config *MacCfgPtr; XLlDma_BdRing *RxRingPtr = &XLlDma_GetRxRing(DmaInstancePtr); XLlDma_BdRing *TxRingPtr = &XLlDma_GetTxRing(DmaInstancePtr); XLlDma_Bd BdTemplate; /*************************************/ /* Setup device for first-time usage */ /*************************************/ /* * Initialize instance. Should be configured for SGDMA */ MacCfgPtr = XLlTemac_LookupConfig(TemacDeviceId); Status = XLlTemac_CfgInitialize(TemacInstancePtr, MacCfgPtr, MacCfgPtr->BaseAddress); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error in initialize"); return XST_FAILURE; } XLlDma_Initialize(DmaInstancePtr, TemacInstancePtr->Config.LLDevBaseAddress); /* * Check whether the IPIF interface is correct for this example */ dma_mode = XLlTemac_IsDma(TemacInstancePtr); if (! dma_mode) { TemacUtilErrorTrap ("Device HW not configured for SGDMA mode\r\n"); return XST_FAILURE; } /* * Set the MAC address */ Status = XLlTemac_SetMacAddress(TemacInstancePtr, TemacMAC); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error setting MAC address"); 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. */ XLlDma_BdClear(&BdTemplate); /* * Create the RxBD ring */ Status = XLlDma_BdRingCreate(RxRingPtr, (u32) &RxBdSpace, (u32) &RxBdSpace, BD_ALIGNMENT, RXBD_CNT); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error setting up RxBD space"); return XST_FAILURE; } Status = XLlDma_BdRingClone(RxRingPtr, &BdTemplate); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error initializing RxBD space"); return XST_FAILURE; } /* * Setup TxBD space. * * Like RxBD space, we have already defined a properly aligned area of * memory to use. */ /* * Create the TxBD ring */ Status = XLlDma_BdRingCreate(TxRingPtr, (u32) &TxBdSpace, (u32) &TxBdSpace, BD_ALIGNMENT, TXBD_CNT); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error setting up TxBD space"); return XST_FAILURE; } /* * We reuse the bd template, as the same one will work for both rx and tx. */ Status = XLlDma_BdRingClone(TxRingPtr, &BdTemplate); if (Status != XST_SUCCESS) { TemacUtilErrorTrap("Error initializing TxBD space"); return XST_FAILURE; } /* Make sure the hard temac is ready */ Rdy = XLlTemac_ReadReg(TemacInstancePtr->Config.BaseAddress, XTE_RDY_OFFSET); while ((Rdy & XTE_RDY_HARD_ACS_RDY_MASK) == 0) { Rdy = XLlTemac_ReadReg(TemacInstancePtr->Config.BaseAddress, XTE_RDY_OFFSET); } #if !SIM /* * Set PHY to loopback */ TemacUtilEnterLoopback(TemacInstancePtr, TEMAC_LOOPBACK_SPEED); /* * Set PHY<-->MAC data clock */ XLlTemac_SetOperatingSpeed(TemacInstancePtr, TEMAC_LOOPBACK_SPEED); /* * Setting the operating speed of the MAC needs a delay. There * doesn't seem to be register to poll, so please consider this * during your application design. */ TemacUtilPhyDelay(2); #endif /* * Connect to the interrupt controller and enable interrupts */ Status = TemacSetupIntrSystem(IntcInstancePtr, TemacInstancePtr, DmaInstancePtr, TemacIntrId, DmaRxIntrId, DmaTxIntrId); /****************************/ /* Run through the examples */ /****************************/ /* * Run the Temac SGDMA Single Frame Interrupt example */ Status = TemacSgDmaIntrSingleFrameExample(TemacInstancePtr, DmaInstancePtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Disable the interrupts for the Temac device */ TemacDisableIntrSystem(IntcInstancePtr, TemacIntrId, DmaRxIntrId, DmaTxIntrId); /* * Stop the device */ XLlTemac_Stop(TemacInstancePtr); return XST_SUCCESS; }
static err_t low_level_init(struct netif *netif) { unsigned mac_address = (unsigned)(netif->state); struct xemac_s *xemac; xlltemacif_s *xlltemacif; xlltemacif = mem_malloc(sizeof *xlltemacif); if (xlltemacif == NULL) { LWIP_DEBUGF(NETIF_DEBUG, ("xlltemacif_init: out of memory\r\n")); return ERR_MEM; } xemac = mem_malloc(sizeof *xemac); if (xemac == NULL) { LWIP_DEBUGF(NETIF_DEBUG, ("xlltemacif_init: out of memory\r\n")); return ERR_MEM; } xemac->state = (void *)xlltemacif; xemac->topology_index = xtopology_find_index(mac_address); xemac->type = xemac_type_xps_ll_temac; xlltemacif->send_q = NULL; xlltemacif->recv_q = pq_create_queue(); if (!xlltemacif->recv_q) return ERR_MEM; /* maximum transfer unit */ #ifdef USE_JUMBO_FRAMES netif->mtu = XTE_JUMBO_MTU - XTE_HDR_SIZE; #else netif->mtu = XTE_MTU - XTE_HDR_SIZE; #endif #if LWIP_IGMP netif->igmp_mac_filter = xlltemacif_mac_filter_update; #endif /* broadcast capability */ netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP; #if LWIP_IGMP netif->flags |= NETIF_FLAG_IGMP; #endif #if !NO_SYS sys_sem_new(&xemac->sem_rx_data_available, 0); #endif /* initialize the mac */ init_lltemac(xlltemacif, netif); /* figure out if the system has DMA */ if (XLlTemac_IsDma(&xlltemacif->lltemac)) { /* initialize the DMA engine */ init_sdma(xemac); } else if (XLlTemac_IsFifo(&xlltemacif->lltemac)) { /* initialize the locallink FIFOs */ init_ll_fifo(xemac); } else { /* should not occur */ LWIP_DEBUGF(NETIF_DEBUG, ("xlltemacif_init: lltemac is not configured with DMA or FIFO\r\n")); return ERR_IF; } /* replace the state in netif (currently the emac baseaddress) * with the xlltemac instance pointer. */ netif->state = (void *)xemac; return ERR_OK; }