| /* ---------------------------------------------------------------------------- | |
| * SAM Software Package License | |
| * ---------------------------------------------------------------------------- | |
| * Copyright (c) 2011, Atmel Corporation | |
| * | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions are met: | |
| * | |
| * - Redistributions of source code must retain the above copyright notice, | |
| * this list of conditions and the disclaimer below. | |
| * | |
| * Atmel's name may not be used to endorse or promote products derived from | |
| * this software without specific prior written permission. | |
| * | |
| * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR | |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE | |
| * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, | |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, | |
| * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| * ---------------------------------------------------------------------------- | |
| */ | |
| /** \file */ | |
| /*--------------------------------------------------------------------------- | |
| * Headers | |
| *---------------------------------------------------------------------------*/ | |
| #include <board.h> | |
| #include <string.h> | |
| /** \addtogroup EMACD_defines | |
| @{*/ | |
| /*---------------------------------------------------------------------------- | |
| * Definitions | |
| *----------------------------------------------------------------------------*/ | |
| /** Error bits for TX */ | |
| #define EMAC_TX_ERR_BITS \ | |
| (EMAC_TXD_bmERROR | EMAC_TXD_bmUNDERRUN | EMAC_TXD_bmEXHAUSTED) | |
| /*--------------------------------------------------------------------------- | |
| * Circular buffer management | |
| *---------------------------------------------------------------------------*/ | |
| /** Return count in buffer */ | |
| #define CIRC_CNT(head,tail,size) (((head) - (tail)) % (size)) | |
| /** Return space available, 0..size-1. always leave one free char as a completely full buffer | |
| has head == tail, which is the same as empty */ | |
| #define CIRC_SPACE(head,tail,size) CIRC_CNT((tail),((head)+1),(size)) | |
| /** Return count up to the end of the buffer. Carefully avoid accessing head and tail more than once, | |
| so they can change underneath us without returning inconsistent results */ | |
| #define CIRC_CNT_TO_END(head,tail,size) \ | |
| ({int end = (size) - (tail); \ | |
| int n = ((head) + end) % (size); \ | |
| n < end ? n : end;}) | |
| /** Return space available up to the end of the buffer */ | |
| #define CIRC_SPACE_TO_END(head,tail,size) \ | |
| ({int end = (size) - 1 - (head); \ | |
| int n = (end + (tail)) % (size); \ | |
| n <= end ? n : end+1;}) | |
| /** Increment head or tail */ | |
| #define CIRC_INC(headortail,size) \ | |
| headortail++; \ | |
| if(headortail >= size) { \ | |
| headortail = 0; \ | |
| } | |
| /** Circular buffer is empty ? */ | |
| #define CIRC_EMPTY(head, tail) (head == tail) | |
| /** Clear circular buffer */ | |
| #define CIRC_CLEAR(head, tail) (head = tail = 0) | |
| /** @}*/ | |
| /*---------------------------------------------------------------------------- | |
| * Internal variables | |
| *----------------------------------------------------------------------------*/ | |
| /*---------------------------------------------------------------------------- | |
| * Internal functions | |
| *----------------------------------------------------------------------------*/ | |
| /** | |
| * Disable TX & reset registers and descriptor list | |
| * \param pDrv Pointer to EMAC Driver instance. | |
| */ | |
| static void EMACD_ResetTx(sEmacd *pDrv) | |
| { | |
| Emac *pHw = pDrv->pHw; | |
| uint8_t *pTxBuffer = pDrv->pTxBuffer; | |
| sEmacTxDescriptor *pTd = pDrv->pTxD; | |
| uint32_t Index; | |
| uint32_t Address; | |
| /* Disable TX */ | |
| EMAC_TransmitEnable(pHw, 0); | |
| /* Setup the TX descriptors. */ | |
| CIRC_CLEAR(pDrv->wTxHead, pDrv->wTxTail); | |
| for(Index = 0; Index < pDrv->wTxListSize; Index++) | |
| { | |
| Address = (uint32_t)(&(pTxBuffer[Index * EMAC_TX_UNITSIZE])); | |
| pTd[Index].addr = Address; | |
| pTd[Index].status.val = EMAC_TXD_bmUSED; | |
| } | |
| pTd[pDrv->wTxListSize - 1].status.val = EMAC_TXD_bmUSED | EMAC_TXD_bmWRAP; | |
| /* Transmit Buffer Queue Pointer Register */ | |
| EMAC_SetTxQueue(pHw, (uint32_t)pTd); | |
| } | |
| /** | |
| * Disable RX & reset registers and descriptor list | |
| * \param pDrv Pointer to EMAC Driver instance. | |
| */ | |
| static void EMACD_ResetRx(sEmacd *pDrv) | |
| { | |
| Emac *pHw = pDrv->pHw; | |
| uint8_t *pRxBuffer = pDrv->pRxBuffer; | |
| sEmacRxDescriptor *pRd = pDrv->pRxD; | |
| uint32_t Index; | |
| uint32_t Address; | |
| /* Disable RX */ | |
| EMAC_ReceiveEnable(pHw, 0); | |
| /* Setup the RX descriptors. */ | |
| pDrv->wRxI = 0; | |
| for(Index = 0; Index < pDrv->wRxListSize; Index++) | |
| { | |
| Address = (uint32_t)(&(pRxBuffer[Index * EMAC_RX_UNITSIZE])); | |
| /* Remove EMAC_RXD_bmOWNERSHIP and EMAC_RXD_bmWRAP */ | |
| pRd[Index].addr.val = Address & EMAC_RXD_ADDR_MASK; | |
| pRd[Index].status.val = 0; | |
| } | |
| pRd[pDrv->wRxListSize - 1].addr.val |= EMAC_RXD_bmWRAP; | |
| /* Receive Buffer Queue Pointer Register */ | |
| EMAC_SetRxQueue(pHw, (uint32_t) pRd); | |
| } | |
| /*--------------------------------------------------------------------------- | |
| * Exported functions | |
| *---------------------------------------------------------------------------*/ | |
| /** | |
| * EMAC Interrupt handler | |
| */ | |
| void EMACD_Handler( sEmacd *pEmacd ) | |
| { | |
| Emac *pHw = pEmacd->pHw; | |
| uint32_t isr; | |
| uint32_t rsr; | |
| uint32_t tsr; | |
| sEmacTxDescriptor *pTxTd; | |
| fEmacdTransferCallback *pTxCb = NULL; | |
| uint32_t rxStatusFlag; | |
| uint32_t txStatusFlag; | |
| isr = EMAC_GetItStatus(pHw); | |
| rsr = EMAC_GetRxStatus(pHw); | |
| tsr = EMAC_GetTxStatus(pHw); | |
| isr &= ~(EMAC_GetItMask(pHw) | 0xFFC300); | |
| /* RX packet */ | |
| if ((isr & EMAC_ISR_RCOMP) || (rsr & EMAC_RSR_REC)) | |
| { | |
| asm("nop"); | |
| rxStatusFlag = EMAC_RSR_REC; | |
| /* Check OVR */ | |
| if (rsr & EMAC_RSR_OVR) | |
| { | |
| rxStatusFlag |= EMAC_RSR_OVR; | |
| } | |
| /* Check BNA */ | |
| if (rsr & EMAC_RSR_BNA) | |
| { | |
| rxStatusFlag |= EMAC_RSR_BNA; | |
| } | |
| /* Clear status */ | |
| EMAC_ClearRxStatus(pHw, rxStatusFlag); | |
| /* Invoke callbacks */ | |
| if (pEmacd->fRxCb) | |
| { | |
| pEmacd->fRxCb(rxStatusFlag); | |
| } | |
| } | |
| /* TX packet */ | |
| if ((isr & EMAC_ISR_TCOMP) || (tsr & EMAC_TSR_COMP)) { | |
| asm("nop"); | |
| txStatusFlag = EMAC_TSR_COMP; | |
| /* A frame transmitted */ | |
| /* Check RLE */ | |
| if (tsr & EMAC_TSR_RLES) | |
| { | |
| /* Status RLE & Number of discarded buffers */ | |
| txStatusFlag = EMAC_TSR_RLES | |
| | CIRC_CNT(pEmacd->wTxHead, | |
| pEmacd->wTxTail, | |
| pEmacd->wTxListSize) | |
| ; | |
| pTxCb = &pEmacd->fTxCbList[pEmacd->wTxTail]; | |
| EMACD_ResetTx(pEmacd); | |
| TRACE_INFO("Tx RLE!!\n\r"); | |
| EMAC_TransmitEnable(pHw, 1); | |
| } | |
| /* Check COL */ | |
| if (tsr & EMAC_TSR_COL) | |
| { | |
| txStatusFlag |= EMAC_TSR_COL; | |
| } | |
| /* Check BEX */ | |
| if (tsr & EMAC_TSR_BEX) | |
| { | |
| txStatusFlag |= EMAC_TSR_BEX; | |
| } | |
| /* Check UND */ | |
| if (tsr & EMAC_TSR_UND) | |
| { | |
| txStatusFlag |= EMAC_TSR_UND; | |
| } | |
| /* Clear status */ | |
| EMAC_ClearTxStatus(pHw, txStatusFlag); | |
| if (!CIRC_EMPTY(pEmacd->wTxHead, pEmacd->wTxTail)) | |
| { | |
| // Check the buffers | |
| do { | |
| pTxTd = &pEmacd->pTxD[pEmacd->wTxTail]; | |
| pTxCb = &pEmacd->fTxCbList[pEmacd->wTxTail]; | |
| /* Any error? | |
| Exit if buffer has not been sent yet */ | |
| if ((pTxTd->status.val & EMAC_TXD_bmUSED) == 0) | |
| { | |
| break; | |
| } | |
| /* Notify upper layer that a packet has been sent */ | |
| if (*pTxCb) | |
| { | |
| (*pTxCb)(txStatusFlag); | |
| } | |
| CIRC_INC( pEmacd->wTxTail, pEmacd->wTxListSize ); | |
| } while (CIRC_CNT(pEmacd->wTxHead, pEmacd->wTxTail, pEmacd->wTxListSize)); | |
| } | |
| if (tsr & EMAC_TSR_RLES) | |
| { | |
| /* Notify upper layer RLE */ | |
| if (*pTxCb) | |
| { | |
| (*pTxCb)(txStatusFlag); | |
| } | |
| } | |
| /* If a wakeup has been scheduled, notify upper layer that it can | |
| send other packets, send will be successfull. */ | |
| if( (CIRC_SPACE(pEmacd->wTxHead, | |
| pEmacd->wTxTail, | |
| pEmacd->wTxListSize) >= pEmacd->bWakeupThreshold) | |
| && pEmacd->fWakupCb) | |
| { | |
| pEmacd->fWakupCb(); | |
| } | |
| } | |
| /* PAUSE Frame */ | |
| if (isr & EMAC_ISR_PFRE) | |
| { | |
| TRACE_INFO("Pause!\n\r"); | |
| } | |
| if (isr & EMAC_ISR_PTZ) | |
| { | |
| TRACE_INFO("Pause TO!\n\r"); | |
| } | |
| } | |
| /** | |
| * Initialize the EMAC Driver with HW settings. | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param pHw Pointer to HW address for registers. | |
| * \param bID HW ID for power management. | |
| * \param bCAF Enable/Disable CopyAllFrame. | |
| * \param bNBC Enable/Disable NoBroadCast. | |
| */ | |
| void EMACD_Init(sEmacd *pEmacd, | |
| Emac *pHw, uint8_t bID, | |
| uint8_t bCAF, uint8_t bNBC ) | |
| { | |
| TRACE_DEBUG("EMACD_Init\n\r"); | |
| /* Initialize struct */ | |
| pEmacd->pHw = pHw; | |
| pEmacd->bId = bID; | |
| /* Power ON */ | |
| PMC_EnablePeripheral(bID); | |
| /* Disable TX & RX and more */ | |
| EMAC_NetworkControl(pHw, 0); | |
| EMAC_DisableIt(pHw, ~0u); | |
| EMAC_ClearStatistics(pHw); | |
| /* Clear all status bits in the receive status register. */ | |
| EMAC_ClearRxStatus(pHw, EMAC_RSR_OVR | EMAC_RSR_REC | EMAC_RSR_BNA); | |
| /* Clear all status bits in the transmit status register */ | |
| EMAC_ClearTxStatus(pHw, EMAC_TSR_UBR | EMAC_TSR_COL | EMAC_TSR_RLES | |
| | EMAC_TSR_BEX | EMAC_TSR_COMP | EMAC_TSR_UND); | |
| /* Clear interrupts */ | |
| EMAC_GetItStatus(pHw); | |
| /* Enable the copy of data into the buffers | |
| ignore broadcasts, and don't copy FCS. */ | |
| EMAC_Configure(pHw, EMAC_GetConfigure(pHw) | EMAC_NCFGR_DRFCS | EMAC_NCFGR_PAE); | |
| EMAC_CpyAllEnable(pHw, bCAF); | |
| EMAC_BroadcastDisable(pHw, bNBC); | |
| } | |
| /** | |
| * Initialize necessary allocated buffer lists for EMAC Driver to transfer data. | |
| * Must be invoked after EMACD_Init() but before RX/TX start. | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param pRxBuffer Pointer to allocated buffer for RX. The address should | |
| * be 8-byte aligned and the size should be | |
| * EMAC_RX_UNITSIZE * wRxSize. | |
| * \param pRxD Pointer to allocated RX descriptor list. | |
| * \param wRxSize RX size, in number of registered units (RX descriptors). | |
| * \param pTxBuffer Pointer to allocated buffer for TX. The address should | |
| * be 8-byte aligned and the size should be | |
| * EMAC_TX_UNITSIZE * wTxSize. | |
| * \param pTxD Pointer to allocated TX descriptor list. | |
| * \param pTxCb Pointer to allocated TX callback list. | |
| * \param wTxSize TX size, in number of registered units (TX descriptors). | |
| * \return EMACD_OK or EMACD_PARAM. | |
| * \note If input address is not 8-byte aligned the address is automatically | |
| * adjusted and the list size is reduced by one. | |
| */ | |
| extern uint8_t EMACD_InitTransfer( sEmacd *pEmacd, | |
| uint8_t *pRxBuffer, sEmacRxDescriptor *pRxD, | |
| uint16_t wRxSize, | |
| uint8_t *pTxBuffer, sEmacTxDescriptor *pTxD, fEmacdTransferCallback *pTxCb, | |
| uint16_t wTxSize) | |
| { | |
| Emac *pHw = pEmacd->pHw; | |
| if (wRxSize <= 1 || wTxSize <= 1 || pTxCb == NULL) return EMACD_PARAM; | |
| /* Assign RX buffers */ | |
| if ( ((uint32_t)pRxBuffer & 0x7) | |
| || ((uint32_t)pRxD & 0x7) ) | |
| { | |
| wRxSize --; | |
| TRACE_DEBUG("RX list address adjusted\n\r"); | |
| } | |
| pEmacd->pRxBuffer = (uint8_t*)((uint32_t)pRxBuffer & 0xFFFFFFF8); | |
| pEmacd->pRxD = (sEmacRxDescriptor*)((uint32_t)pRxD & 0xFFFFFFF8); | |
| pEmacd->wRxListSize = wRxSize; | |
| /* Assign TX buffers */ | |
| if ( ((uint32_t)pTxBuffer & 0x7) | |
| || ((uint32_t)pTxD & 0x7) ) | |
| { | |
| wTxSize --; | |
| TRACE_DEBUG("TX list address adjusted\n\r"); | |
| } | |
| pEmacd->pTxBuffer = (uint8_t*)((uint32_t)pTxBuffer & 0xFFFFFFF8); | |
| pEmacd->pTxD = (sEmacTxDescriptor*)((uint32_t)pTxD & 0xFFFFFFF8); | |
| pEmacd->wTxListSize = wTxSize; | |
| pEmacd->fTxCbList = pTxCb; | |
| /* Reset TX & RX */ | |
| EMACD_ResetRx(pEmacd); | |
| EMACD_ResetTx(pEmacd); | |
| /* Enable Rx and Tx, plus the stats register. */ | |
| EMAC_TransmitEnable(pHw, 1); | |
| EMAC_ReceiveEnable(pHw, 1); | |
| EMAC_StatisticsWriteEnable(pHw, 1); | |
| /* Setup the interrupts for TX (and errors) */ | |
| EMAC_EnableIt(pHw, EMAC_IER_RXUBR | |
| | EMAC_IER_TUND | |
| | EMAC_IER_RLE | |
| | EMAC_IER_TXERR | |
| | EMAC_IER_TCOMP | |
| | EMAC_IER_ROVR | |
| | EMAC_IER_HRESP | |
| | EMAC_IER_PFR | |
| | EMAC_IER_PTZ); | |
| return EMACD_OK; | |
| } | |
| /** | |
| * Reset TX & RX queue & statistics | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| */ | |
| void EMACD_Reset(sEmacd *pEmacd) | |
| { | |
| Emac *pHw = pEmacd->pHw; | |
| EMACD_ResetRx(pEmacd); | |
| EMACD_ResetTx(pEmacd); | |
| EMAC_NetworkControl(pHw, EMAC_NCR_TE | EMAC_NCR_RE | |
| | EMAC_NCR_WESTAT | EMAC_NCR_CLRSTAT); | |
| } | |
| /** | |
| * Send a packet with EMAC. | |
| * If the packet size is larger than transfer buffer size error returned. | |
| * If packet transfer status is monitored, specify callback for each packet. | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param buffer The buffer to be send | |
| * \param size The size of buffer to be send | |
| * \param fTxCb TX callback. | |
| * \return EMACD_OK, EMACD_PARAM or EMACD_TX_BUSY. | |
| */ | |
| uint8_t EMACD_Send( sEmacd *pEmacd, | |
| void *pBuffer, | |
| uint32_t size, | |
| fEmacdTransferCallback fTxCb ) | |
| { | |
| Emac *pHw = pEmacd->pHw; | |
| volatile sEmacTxDescriptor *pTxTd; | |
| volatile fEmacdTransferCallback *pfTxCb; | |
| TRACE_DEBUG("EMAC_Send\n\r"); | |
| /* Check parameter */ | |
| if (size > EMAC_TX_UNITSIZE) { | |
| TRACE_ERROR("EMAC driver does not split send packets."); | |
| TRACE_ERROR("%d bytes max in one packet (%u bytes requested)\n\r", | |
| EMAC_TX_UNITSIZE, (unsigned int)size); | |
| return EMACD_PARAM; | |
| } | |
| /* Pointers to the current TxTd */ | |
| pTxTd = &pEmacd->pTxD[pEmacd->wTxHead]; | |
| /* If no free TxTd, buffer can't be sent, schedule the wakeup callback */ | |
| if( CIRC_SPACE(pEmacd->wTxHead, pEmacd->wTxTail, pEmacd->wTxListSize) == 0) | |
| { | |
| //if ((pTxTd->status & EMAC_TXD_bmUSED) != 0) | |
| { | |
| //EMAC_ResetTx(); | |
| //TRACE_WARNING("Circ Full but FREE TD found\n\r"); | |
| //AT91C_BASE_EMAC->EMAC_NCR |= AT91C_EMAC_TE; | |
| } | |
| //else | |
| { | |
| return EMACD_TX_BUSY; | |
| } | |
| } | |
| /* Pointers to the current Tx Callback */ | |
| pfTxCb = &pEmacd->fTxCbList[pEmacd->wTxHead]; | |
| /* Setup/Copy data to transmition buffer */ | |
| if (pBuffer && size) | |
| { | |
| /* Driver manage the ring buffer */ | |
| memcpy((void *)pTxTd->addr, pBuffer, size); | |
| } | |
| /* Tx Callback */ | |
| *pfTxCb = fTxCb; | |
| /* Update TD status */ | |
| /* The buffer size defined is length of ethernet frame | |
| so it's always the last buffer of the frame. */ | |
| if (pEmacd->wTxHead == pEmacd->wTxListSize-1) | |
| { | |
| pTxTd->status.val = | |
| (size & EMAC_TXD_LEN_MASK) | EMAC_TXD_bmLAST | EMAC_TXD_bmWRAP; | |
| } | |
| else | |
| { | |
| pTxTd->status.val = (size & EMAC_TXD_LEN_MASK) | EMAC_TXD_bmLAST; | |
| } | |
| CIRC_INC(pEmacd->wTxHead, pEmacd->wTxListSize); | |
| /* Now start to transmit if it is not already done */ | |
| EMAC_TransmissionStart(pHw); | |
| return EMACD_OK; | |
| } | |
| /** | |
| * Return current load of TX. | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| */ | |
| uint32_t EMACD_TxLoad(sEmacd *pEmacd) | |
| { | |
| uint16_t head = pEmacd->wTxHead; | |
| uint16_t tail = pEmacd->wTxTail; | |
| return CIRC_CNT(head, tail, pEmacd->wTxListSize); | |
| } | |
| /** | |
| * Receive a packet with EMAC | |
| * If not enough buffer for the packet, the remaining data is lost but right | |
| * frame length is returned. | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param pFrame Buffer to store the frame | |
| * \param frameSize Size of the frame | |
| * \param pRcvSize Received size | |
| * \return OK, no data, or frame too small | |
| */ | |
| uint8_t EMACD_Poll( sEmacd * pEmacd, | |
| uint8_t *pFrame, | |
| uint32_t frameSize, | |
| uint32_t *pRcvSize) | |
| { | |
| uint16_t bufferLength; | |
| uint32_t tmpFrameSize=0; | |
| uint8_t *pTmpFrame=0; | |
| uint32_t tmpIdx = pEmacd->wRxI; | |
| volatile sEmacRxDescriptor *pRxTd = &pEmacd->pRxD[pEmacd->wRxI]; | |
| char isFrame = 0; | |
| if (pFrame == NULL) return EMACD_PARAM; | |
| /* Set the default return value */ | |
| *pRcvSize = 0; | |
| /* Process received RxTd */ | |
| while ((pRxTd->addr.val & EMAC_RXD_bmOWNERSHIP) == EMAC_RXD_bmOWNERSHIP) | |
| { | |
| /* A start of frame has been received, discard previous fragments */ | |
| if ((pRxTd->status.val & EMAC_RXD_bmSOF) == EMAC_RXD_bmSOF) | |
| { | |
| /* Skip previous fragment */ | |
| while (tmpIdx != pEmacd->wRxI) | |
| { | |
| pRxTd = &pEmacd->pRxD[pEmacd->wRxI]; | |
| pRxTd->addr.val &= ~(EMAC_RXD_bmOWNERSHIP); | |
| CIRC_INC(pEmacd->wRxI, pEmacd->wRxListSize); | |
| } | |
| /* Reset the temporary frame pointer */ | |
| pTmpFrame = pFrame; | |
| tmpFrameSize = 0; | |
| /* Start to gather buffers in a frame */ | |
| isFrame = 1; | |
| } | |
| /* Increment the pointer */ | |
| CIRC_INC(tmpIdx, pEmacd->wRxListSize); | |
| asm("nop"); | |
| /* Copy data in the frame buffer */ | |
| if (isFrame) | |
| { | |
| if (tmpIdx == pEmacd->wRxI) | |
| { | |
| TRACE_INFO("no EOF (Invalid of buffers too small)\n\r"); | |
| do | |
| { | |
| pRxTd = &pEmacd->pRxD[pEmacd->wRxI]; | |
| pRxTd->addr.val &= ~(EMAC_RXD_bmOWNERSHIP); | |
| CIRC_INC(pEmacd->wRxI, pEmacd->wRxListSize); | |
| } while(tmpIdx != pEmacd->wRxI); | |
| return EMACD_RX_NULL; | |
| } | |
| /* Copy the buffer into the application frame */ | |
| bufferLength = EMAC_RX_UNITSIZE; | |
| if ((tmpFrameSize + bufferLength) > frameSize) | |
| { | |
| bufferLength = frameSize - tmpFrameSize; | |
| } | |
| memcpy(pTmpFrame, (void*)(pRxTd->addr.val & EMAC_RXD_ADDR_MASK), bufferLength); | |
| pTmpFrame += bufferLength; | |
| tmpFrameSize += bufferLength; | |
| /* An end of frame has been received, return the data */ | |
| if ((pRxTd->status.val & EMAC_RXD_bmEOF) == EMAC_RXD_bmEOF) | |
| { | |
| /* Frame size from the EMAC */ | |
| *pRcvSize = (pRxTd->status.val & EMAC_RXD_LEN_MASK); | |
| TRACE_INFO("packet %d-%d (%d)\n\r", pEmacd->wRxI, tmpIdx, *pRcvSize); | |
| /* All data have been copied in the application frame buffer => release TD */ | |
| while (pEmacd->wRxI != tmpIdx) | |
| { | |
| pRxTd = &pEmacd->pRxD[pEmacd->wRxI]; | |
| pRxTd->addr.val &= ~(EMAC_RXD_bmOWNERSHIP); | |
| CIRC_INC(pEmacd->wRxI, pEmacd->wRxListSize); | |
| } | |
| /* Application frame buffer is too small all data have not been copied */ | |
| if (tmpFrameSize < *pRcvSize) | |
| { | |
| TRACE_INFO("size req %u size allocated %u\n\r", (unsigned int)(*pRcvSize), (unsigned int)frameSize); | |
| return EMACD_SIZE_TOO_SMALL; | |
| } | |
| return EMACD_OK; | |
| } | |
| } | |
| /* SOF has not been detected, skip the fragment */ | |
| else | |
| { | |
| pRxTd->addr.val &= ~(EMAC_RXD_bmOWNERSHIP); | |
| pEmacd->wRxI = tmpIdx; | |
| } | |
| /* Process the next buffer */ | |
| pRxTd = &pEmacd->pRxD[tmpIdx]; | |
| } | |
| return EMACD_RX_NULL; | |
| } | |
| /** | |
| * Register/Clear RX callback. Callback will be invoked after the next received | |
| * frame. | |
| * | |
| * When EMACD_Poll() returns EMACD_RX_NULL the application task call | |
| * EMACD_SetRxCallback() to register fRxCb() callback and enters suspend state. | |
| * The callback is in charge to resume the task once a new frame has been | |
| * received. The next time EMACD_Poll() is called, it will be successfull. | |
| * | |
| * This function is usually invoked from the RX callback itself with NULL | |
| * callback, to unregister. Once the callback has resumed the application task, | |
| * there is no need to invoke the callback again. | |
| * | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param fRxCb RX callback. | |
| */ | |
| void EMACD_SetRxCallback(sEmacd * pEmacd, fEmacdTransferCallback fRxCb) | |
| { | |
| Emac *pHw = pEmacd->pHw; | |
| if (fRxCb == NULL) | |
| { | |
| EMAC_DisableIt(pHw, EMAC_IDR_RCOMP); | |
| pEmacd->fRxCb = NULL; | |
| } | |
| else | |
| { | |
| pEmacd->fRxCb = fRxCb; | |
| EMAC_EnableIt(pHw, EMAC_IER_RCOMP); | |
| } | |
| } | |
| /** | |
| * Register/Clear TX wakeup callback. | |
| * | |
| * When EMACD_Send() returns EMACD_TX_BUSY (all TD busy) the application | |
| * task calls EMACD_SetTxWakeupCallback() to register fWakeup() callback and | |
| * enters suspend state. The callback is in charge to resume the task once | |
| * several TD have been released. The next time EMACD_Send() will be called, | |
| * it shall be successfull. | |
| * | |
| * This function is usually invoked with NULL callback from the TX wakeup | |
| * callback itself, to unregister. Once the callback has resumed the | |
| * application task, there is no need to invoke the callback again. | |
| * | |
| * \param pEmacd Pointer to EMAC Driver instance. | |
| * \param fWakeup Wakeup callback. | |
| * \param bThreshould Number of free TD before wakeup callback invoked. | |
| * \return EMACD_OK, EMACD_PARAM on parameter error. | |
| */ | |
| uint8_t EMACD_SetTxWakeupCallback(sEmacd * pEmacd, | |
| fEmacdWakeupCallback fWakeup, | |
| uint8_t bThreshold) | |
| { | |
| if (fWakeup == NULL) | |
| { | |
| pEmacd->fWakupCb = NULL; | |
| } | |
| else | |
| { | |
| if (bThreshold <= pEmacd->wTxListSize) | |
| { | |
| pEmacd->fWakupCb = fWakeup; | |
| pEmacd->bWakeupThreshold = bThreshold; | |
| } | |
| else | |
| { | |
| return EMACD_PARAM; | |
| } | |
| } | |
| return EMACD_OK; | |
| } |