/**
* @fn void ixEthAccCodeletRxSinkRxCB()
*
* Recieve callback for Rx sink
*
* @return void
*/
PRIVATE void
ixEthAccCodeletRxSinkRxCB(UINT32 cbTag, IX_OSAL_MBUF** mBufPtr)
{
while (NULL != *mBufPtr)
{
ixEthAccCodeletStats[cbTag].rxCount++;
#ifdef IX_ETHACC_CODELET_TXGENRXSINK_VERIFY
IX_ETHACC_CODELET_DATA_VERIFY(IX_OSAL_MBUF_MDATA(*mBufPtr), compData);
/* After reading the payload, invalidate it before replenish */
IX_OSAL_CACHE_INVALIDATE(IX_OSAL_MBUF_MDATA(*mBufPtr),
IX_OSAL_MBUF_MLEN(*mBufPtr));
#endif
ixEthAccCodeletMbufChainSizeSet(*mBufPtr);
/* Return mBuf to free queue on same port */
if(ixEthAccPortRxFreeReplenish(cbTag, *mBufPtr) != IX_SUCCESS)
{
ixOsalLog(IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDOUT,
"Error replenishing RX free q in TxGen-RxSink\n",
0, 0, 0, 0, 0, 0);
}
/* move to next buffer received */
mBufPtr++;
}
}
PRIVATE IX_OSAL_MBUF *
ixOsalBuffPoolMbufInit (UINT32 mbufSizeAligned,
UINT32 dataSizeAligned,
IX_OSAL_MBUF_POOL *poolPtr)
{
UINT8 *dataPtr;
IX_OSAL_MBUF *realMbufPtr;
/* Allocate cache-aligned memory for mbuf header */
realMbufPtr = (IX_OSAL_MBUF *) IX_OSAL_CACHE_DMA_MALLOC (mbufSizeAligned);
IX_OSAL_ASSERT (realMbufPtr != NULL);
memset (realMbufPtr, 0, mbufSizeAligned);
/* Allocate cache-aligned memory for mbuf data */
dataPtr = (UINT8 *) IX_OSAL_CACHE_DMA_MALLOC (dataSizeAligned);
IX_OSAL_ASSERT (dataPtr != NULL);
memset (dataPtr, 0, dataSizeAligned);
/* Fill in mbuf header fields */
IX_OSAL_MBUF_MDATA (realMbufPtr) = dataPtr;
IX_OSAL_MBUF_ALLOCATED_BUFF_DATA (realMbufPtr) = (UINT32)dataPtr;
IX_OSAL_MBUF_MLEN (realMbufPtr) = dataSizeAligned;
IX_OSAL_MBUF_ALLOCATED_BUFF_LEN (realMbufPtr) = dataSizeAligned;
IX_OSAL_MBUF_NET_POOL (realMbufPtr) = (IX_OSAL_MBUF_POOL *) poolPtr;
IX_OSAL_MBUF_SYS_SIGNATURE_INIT(realMbufPtr);
/* update some statistical information */
poolPtr->mbufMemSize += mbufSizeAligned;
poolPtr->dataMemSize += dataSizeAligned;
return realMbufPtr;
}
/* ---------------------------------------------------
*/
PRIVATE void
ixOamRxInvalidate(IX_OSAL_MBUF * mbufPtr)
{
while (mbufPtr != NULL)
{
IX_OSAL_CACHE_INVALIDATE(IX_OSAL_MBUF_MDATA(mbufPtr), IX_OSAL_MBUF_MLEN(mbufPtr));
mbufPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr);
}
return;
}
/* ---------------------------------------------------
*/
PRIVATE void
ixOamTxFlush(IX_OSAL_MBUF * mbufPtr)
{
while (mbufPtr != NULL)
{
IX_OSAL_CACHE_FLUSH(IX_OSAL_MBUF_MDATA(mbufPtr), IX_OSAL_MBUF_MLEN(mbufPtr));
mbufPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr);
}
return;
}
PRIVATE void
ixOamRxFreeLowReplenishCallback (IxAtmdAccUserId userId)
{
IX_OSAL_MBUF *mBuf;
UINT32 numFreeEntries;
UINT32 cnt;
IX_STATUS retval;
IX_OSAL_ASSERT(userId == oamRxUserId);
retval = ixAtmdAccRxVcFreeEntriesQuery (oamRxConnId, &numFreeEntries);
if (retval != IX_SUCCESS)
{
IX_OAM_CODELET_IRQ_SAFE_LOG_ERROR("Failed to query depth of Oam Rx Free Q");
return;
}
/* Replenish Rx buffers */
for (cnt=0; cnt<numFreeEntries; cnt++)
{
ixAtmUtilsMbufGet(IX_ATM_OAM_CELL_SIZE_NO_HEC, &mBuf);
if (mBuf == NULL)
{
IX_OAM_CODELET_IRQ_SAFE_LOG_ERROR("Failed to get rx free buffer");
return;
}
/*
* Set the number of bytes of data in this MBUF to 1 OAM cell
*/
IX_OSAL_MBUF_MLEN(mBuf) = IX_ATM_OAM_CELL_SIZE_NO_HEC;
/* invalidate cache */
ixOamRxInvalidate( mBuf );
/* Send free buffers to NPE */
retval = ixAtmdAccRxVcFreeReplenish (oamRxConnId, mBuf);
if (retval != IX_SUCCESS)
{
/* Free the allocated buffer */
ixAtmUtilsMbufFree(mBuf);
IX_OAM_CODELET_IRQ_SAFE_LOG_ERROR("Failed to pass Oam Rx free buffers to Atmd");
return;
}
}
replenishCallbackCount++;
}
/**
* @ingroup IxTimeSyncAccCodelet
*
* @fn ixTimeSyncAccCodeletMbufAllocate ()
*
* @brief Allocate memory for mBuf and its associated data buffer
*
* @return
* @li IX_OSAL_MBUF * - successfully allocated memory for mBuf
* @li NULL - fail
*/
PRIVATE IX_OSAL_MBUF
*ixTimeSyncAccCodeletMbufAllocate ()
{
IX_OSAL_MBUF *mBufPtr;
UINT8 *dataPtr;
/* Allocate cache-aligned memory for mbuf header */
mBufPtr = (IX_OSAL_MBUF *) IX_OSAL_CACHE_DMA_MALLOC (sizeof (IX_OSAL_MBUF));
if (NULL == mBufPtr)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDERR, "ixTimeSyncAccCodeletMbufAllocate: failed to allocate memory for mBuf\n",
0, 0, 0, 0, 0, 0);
return NULL;
}
/* initialize mBuf */
ixOsalMemSet (mBufPtr, 0, sizeof (IX_OSAL_MBUF));
/* Allocate cache-aligned memory for mbuf data */
dataPtr = (UINT8 *) IX_OSAL_CACHE_DMA_MALLOC (IX_TIMESYNCACC_CODELET_UDP_FRAME_LEN);
if (NULL == dataPtr)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDERR, "ixTimeSyncAccCodeletMbufAllocate: failed to allocate memory for mBuf's data buffer\n",
0, 0, 0, 0, 0, 0);
return NULL;
}
/* initialize mBuf's data buffer */
ixOsalMemSet (dataPtr, 0, IX_TIMESYNCACC_CODELET_UDP_FRAME_LEN);
/* Fill in mbuf header fields */
IX_OSAL_MBUF_MDATA (mBufPtr) = dataPtr;
IX_OSAL_MBUF_ALLOCATED_BUFF_DATA (mBufPtr) = (UINT32)dataPtr;
IX_OSAL_MBUF_MLEN (mBufPtr) = IX_TIMESYNCACC_CODELET_UDP_FRAME_LEN;
IX_OSAL_MBUF_ALLOCATED_BUFF_LEN (mBufPtr) = IX_TIMESYNCACC_CODELET_UDP_FRAME_LEN;
IX_OSAL_MBUF_PKT_LEN (mBufPtr) = IX_TIMESYNCACC_CODELET_UDP_FRAME_LEN;
return mBufPtr;
} /* end of ixTimeSyncAccCodeletMbufAllocate function */
void
ixAtmUtilsMbufGet (UINT32 bufSize, IX_OSAL_MBUF **buf)
{
IX_OSAL_MBUF_POOL *poolPtr = NULL;
unsigned i,numPools;
numPools = NUMELEMS (poolInfo);
for (i = 0; i < numPools; i++)
{
if (poolInfo[i].bufSize >= bufSize)
{
poolPtr = poolInfo[i].poolPtr;
break;
}
}
if (poolPtr == NULL)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,IX_OSAL_LOG_DEV_STDERR, "ixAtmUtilsMbufGet - Invalid bufSize specified\n", 0, 0, 0, 0, 0, 0);
*buf = NULL;
return;
}
*buf = IX_OSAL_MBUF_POOL_GET (poolPtr);
if (*buf)
{
IX_OSAL_MBUF_MLEN(*buf) = bufSize;
}
else
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,IX_OSAL_LOG_DEV_STDERR, "ixAtmUtilsMbufGet returning a NULL buffer\n", 0, 0, 0, 0, 0, 0);
ixAtmUtilsMbufShow ();
}
}
/*
*
* Transmit loopback parent cell
*/
PRIVATE IX_STATUS
ixOamParentLbCellTx (IxAtmLogicalPort port, UINT32 vpi, UINT32 vci, UINT32 pti)
{
IxOamITU610Cell *txCell;
IxOamITU610LbPayload *lbPayload;
IX_OSAL_MBUF *txMbuf;
IX_STATUS retval = IX_FAIL;
UINT32 lockKey;
UINT32 oamHdr = 0x0;
/* Get a Tx mbuf */
ixAtmUtilsMbufGet(IX_ATM_OAM_CELL_SIZE_NO_HEC, &txMbuf);
if (txMbuf != NULL)
{
/* set the packet header len */
IX_OSAL_MBUF_PKT_LEN(txMbuf) = IX_OSAL_MBUF_MLEN(txMbuf);
txCell = (IxOamITU610Cell *)(IX_OSAL_MBUF_MDATA(txMbuf));
/* Setup shortcut pointers */
lbPayload = &(txCell->payload.lbPayload);
/* Set the OAM function type to LB */
IX_OAM_TYPE_AND_FUNC_SET(lbPayload, IX_OAM_ITU610_TYPE_FAULT_MAN_LB);
/* Setup the loopback indication */
IX_OAM_LOOPBACK_INDICATION_SET(lbPayload, IX_OAM_ITU610_LB_INDICATION_PARENT);
/* Increment the correlation tag and write this into the cell */
lbCorrelationTag++;
ixOamMemCpy(lbPayload->correlationTag, (UCHAR *)(&lbCorrelationTag), IX_OAM_ITU610_LB_CORRELATION_TAG_LEN);
/* Set Loopback Location Id */
ixOamMemCpy(lbPayload->llid, allOnesLocId, IX_OAM_ITU610_LOCATION_ID_LEN);
/* Store the source Id as the CPID */
ixOamMemCpy(lbPayload->sourceId, oamCpid, IX_OAM_ITU610_LOCATION_ID_LEN);
/* Set the reserved fields to 0x6a */
ixOamMemSet(lbPayload->reserved,
IX_OAM_ITU610_RESERVED_BYTE_VALUE,
IX_OAM_ITU610_LB_RESERVED_BYTES_LEN);
/* Set the transmit VPI */
IX_OAM_VPI_SET(oamHdr, vpi);
/* Set the transmit VCI TX Vci */
IX_OAM_VCI_SET(oamHdr, vci);
/* Set the PTI */
IX_OAM_PTI_SET(oamHdr, pti);
/* Set the header in buffer */
IX_OAM_HEADER_SET(txCell, oamHdr);
/* flush the mbuf frm cache */
ixOamTxFlush( txMbuf );
/* Transmit the cell, not reentrant on a VC basis so protect */
lockKey = ixOsalIrqLock();
retval = ixOamTxAndRetry (oamTxConnId[port],
txMbuf,
0, /* CLP 0 */
1); /* Cells per packet */
ixOsalIrqUnlock (lockKey);
if (retval == IX_SUCCESS)
{
/* Increment the loopback out counter */
parentLbCellTxCount[port]++;
}
else
{
/* Release the MBUF */
ixAtmUtilsMbufFree (txMbuf);
}
}
else
{
IX_OAM_CODELET_IRQ_SAFE_LOG_ERROR("ixOamParentLbCellTx: Failed to get a buffer for transmit");
}
return retval;
}
/*
*Function :ixHssAccPktRxFreeReplenish
*/
IX_STATUS
ixHssAccPktRxFreeReplenish (IxHssAccHssPort hssPortId,
IxHssAccHdlcPort hdlcPortId,
IX_OSAL_MBUF *buffer)
{
/* This function may be called from within an ISR */
IX_STATUS status = IX_SUCCESS;
UINT32 qEntry = 0;
IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
"ixHssAccPktRxFreeReplenish \n");
/* Check that the client is connected */
if (ixHssAccPCMCheckReplenishOk (hssPortId, hdlcPortId))
{
/* Set up the NPE shared region of the IX_OSAL_BUF buffer */
IX_HSSACC_IX_NE_SHARED_STATUS(buffer) = (UINT8) IX_HSSACC_PKT_OK;
IX_HSSACC_IX_NE_SHARED_PKT_LEN(buffer) = (UINT16) 0;
IX_HSSACC_IX_NE_SHARED_DATA(buffer) = (UINT8 *)IX_HSSACC_PKT_MMU_VIRT_TO_PHY(IX_OSAL_MBUF_MDATA(buffer));
IX_HSSACC_IX_NE_SHARED_LEN(buffer) = (UINT16) IX_OSAL_MBUF_MLEN(buffer);
IX_HSSACC_IX_NE_SHARED_NEXT(buffer) = (UINT32 *) NULL;
IX_HSSACC_IX_NE_SHARED_ERR_CNT(buffer) = (UINT8) 0;
/* Endian conversion is performed on the NPE shared region of the buffer */
IX_HSSACC_IX_NE_ENDIAN_SWAP(buffer);
/* The cache is flushed for the NPE shared region of the buffer */
IX_HSSACC_IX_NE_SHARED_CACHE_FLUSH(buffer);
/* Form the Q entry and Write it to the appropriate RxFree Q*/
qEntry = (UINT32) IX_HSSACC_PKT_MMU_VIRT_TO_PHY (IX_HSSACC_IX_NE_SHARED(buffer));
qEntry |= (hdlcPortId & IX_HSSACC_QM_Q_CHAN_NUM_MASK);
status = ixQMgrQWrite (ixHssAccPCMRxFreeQIdGet (hssPortId, hdlcPortId),
&qEntry);
if (status != IX_SUCCESS)
{
if (status == IX_FAIL)
{
IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxFreeReplenish:"
"Writing a queue entry to the RXFREE"
" Queue failed\n");
ixHssAccPktRxStats.rxFreeQWriteFails++;
}
else if (status == IX_QMGR_Q_OVERFLOW)
{
ixHssAccPktRxStats.rxQWriteOverflows++;
status = IX_HSSACC_Q_WRITE_OVERFLOW;
}
return status;
} /* end of if (status != IX_SUCCESS)*/
/* Increment the number of buffers in use count for the client by one*/
ixHssAccPCMnoBuffersInUseCountInc (hssPortId, hdlcPortId, 1);
ixHssAccPktRxStats.rxFreeReplenishs++;
}
else
{
IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxFreeReplenish:"
"Called ixHssAccPktRxInternalFreeBufReplenish "
"on a port that is not connected\n");
return IX_FAIL;
}
IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
"ixHssAccPktRxFreeReplenish \n");
return status;
}
PRIVATE IX_STATUS
ixEthAccCodeletTxGenRxSinkStart(IxEthAccPortId portId)
{
IX_OSAL_MBUF *mBufPtr;
UINT32 numBufs;
IxEthDBStatus status;
/* port transmits as fast as possible and drops rx traffic */
if (ixEthAccCodeletPortConfigure(portId,
NULL,
ixEthAccCodeletRxSinkRxCB,
ixEthAccCodeletTxGenTxCB,
portId)
!= IX_ETH_ACC_SUCCESS)
{
printf("Loopbacks: Failed to start the Tx-Gen Rx-Sink Operation port %u\n",
(UINT32)portId);
return IX_FAIL;
}
/* Disable MAC learning and filtering at the port that sinks the frame.
With learning enabled at both ports, TxGenRxSink will report buffer underrun and overruns
as this mode generates a heavy load of MAC address migrations in the learning/filtering
database.
*/
status = ixEthDBFeatureEnable (portId, IX_ETH_DB_FILTERING, FALSE);
if (IX_ETH_DB_SUCCESS == status)
{
status = ixEthDBFeatureEnable (portId, IX_ETH_DB_LEARNING, FALSE);
}
if (IX_ETH_DB_SUCCESS == status)
{
printf("\nMAC learning & filtering are disabled at port %d\n", portId);
printf("This is to prohibit the MAC address from being migrated back and forth\n");
printf("between two connected ports in the learning/filtering database.\n\n");
}
else
{
printf("\nFailed to disable MAC learning & filtering at port %d.\n", portId);
printf("TxGenRxSink will report buffer underrun and overruns as this mode generates \n");
printf("a heavy load of MAC address migrations in the learning/filtering database. \n");
printf("With learning enabled at both ports, buffer underrun and overruns are expected.\n");
}
/* Generate our random data for the payload */
IX_ETHACC_CODELET_DATAGEN(compData);
/* Now start the loopback by transmitting the first few frames */
for (numBufs=0; numBufs<IX_ETHACC_CODELET_TXGEN_PCKS; numBufs++)
{
IX_ETHACC_CODELET_REMOVE_MBUF_FROM_Q_HEAD(ixEthAccCodeletFreeBufQ,
mBufPtr);
if (mBufPtr == NULL)
{
printf("Loopbacks: Buffer queue empty. Not enough free buffers to transmit in TxGen-RxSink Loopback!\n");
return (IX_FAIL);
}
IX_OSAL_MBUF_MLEN(mBufPtr) = IX_ETHACC_CODELET_TXGEN_PCK_LEN;
IX_OSAL_MBUF_PKT_LEN(mBufPtr) = IX_ETHACC_CODELET_TXGEN_PCK_LEN;
memcpy(IX_OSAL_MBUF_MDATA(mBufPtr),
&compData[0],
IX_ETHACC_CODELET_TXGEN_PCK_LEN);
IX_OSAL_CACHE_FLUSH(IX_OSAL_MBUF_MDATA(mBufPtr),
IX_OSAL_MBUF_MLEN(mBufPtr));
if(ixEthAccPortTxFrameSubmit(portId,
mBufPtr,
IX_ETH_ACC_TX_DEFAULT_PRIORITY)
!= IX_ETH_ACC_SUCCESS)
{
printf("Loopbacks: Error Submitting frame for transmission on port %u\n",
portId);
return (IX_FAIL);
}
}
printf("Port %d Tx pool has %d buffers\n", portId, numBufs);
/* enable traffic */
if(ixEthAccPortEnable(portId)
!= IX_ETH_ACC_SUCCESS)
{
printf("Loopbacks: Error Enabling port %u\n",
(UINT32)portId);
return (IX_FAIL);
}
return (IX_SUCCESS);
}
PUBLIC IX_OSAL_MBUF_POOL *
ixOsalNoAllocPoolInit (void *poolBufPtr,
void *poolDataPtr, UINT32 count, UINT32 size, const char *name)
{
UINT32 i, mbufSizeAligned, sizeAligned;
IX_OSAL_MBUF *currentMbufPtr = NULL;
IX_OSAL_MBUF *nextMbufPtr = NULL;
IX_OSAL_MBUF_POOL *poolPtr = NULL;
/*
* check parameters
*/
if (poolBufPtr == NULL)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
IX_OSAL_LOG_DEV_STDOUT,
"ixOsalNoAllocPoolInit(): "
"ERROR - NULL poolBufPtr \n", 0, 0, 0, 0, 0, 0);
return NULL;
}
if (count <= 0)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
IX_OSAL_LOG_DEV_STDOUT,
"ixOsalNoAllocPoolInit(): "
"ERROR - count must > 0 \n", 0, 0, 0, 0, 0, 0);
return NULL;
}
if (name == NULL)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
IX_OSAL_LOG_DEV_STDOUT,
"ixOsalNoAllocPoolInit(): "
"ERROR - NULL name ptr \n", 0, 0, 0, 0, 0, 0);
return NULL;
}
if (strlen (name) > IX_OSAL_MBUF_POOL_NAME_LEN)
{
ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
IX_OSAL_LOG_DEV_STDOUT,
"ixOsalNoAllocPoolInit(): "
"ERROR - name length should be no greater than %d \n",
IX_OSAL_MBUF_POOL_NAME_LEN, 0, 0, 0, 0, 0);
return NULL;
}
poolPtr = ixOsalPoolAlloc ();
if (poolPtr == NULL)
{
return NULL;
}
/*
* Adjust sizes to ensure alignment on cache line boundaries
*/
mbufSizeAligned =
IX_OSAL_MBUF_POOL_SIZE_ALIGN (sizeof (IX_OSAL_MBUF));
/*
* clear the mbuf memory area
*/
memset (poolBufPtr, 0, mbufSizeAligned * count);
if (poolDataPtr != NULL)
{
/*
* Adjust sizes to ensure alignment on cache line boundaries
*/
sizeAligned = IX_OSAL_MBUF_POOL_SIZE_ALIGN (size);
/*
* clear the data memory area
*/
memset (poolDataPtr, 0, sizeAligned * count);
}
else
{
sizeAligned = 0;
}
/*
* initialise pool fields
*/
strcpy ((poolPtr)->name, name);
poolPtr->dataMemPtr = poolDataPtr;
poolPtr->mbufMemPtr = poolBufPtr;
poolPtr->bufDataSize = sizeAligned;
poolPtr->totalBufsInPool = count;
poolPtr->mbufMemSize = mbufSizeAligned * count;
poolPtr->dataMemSize = sizeAligned * count;
currentMbufPtr = (IX_OSAL_MBUF *) poolBufPtr;
poolPtr->nextFreeBuf = currentMbufPtr;
for (i = 0; i < count; i++)
{
if (i < (count - 1))
{
nextMbufPtr =
(IX_OSAL_MBUF *) ((unsigned) currentMbufPtr +
mbufSizeAligned);
}
else
{ /* last mbuf in chain */
nextMbufPtr = NULL;
}
IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (currentMbufPtr) = nextMbufPtr;
IX_OSAL_MBUF_NET_POOL (currentMbufPtr) = poolPtr;
IX_OSAL_MBUF_SYS_SIGNATURE_INIT(currentMbufPtr);
if (poolDataPtr != NULL)
{
IX_OSAL_MBUF_MDATA (currentMbufPtr) = poolDataPtr;
IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(currentMbufPtr) = (UINT32) poolDataPtr;
IX_OSAL_MBUF_MLEN (currentMbufPtr) = sizeAligned;
IX_OSAL_MBUF_ALLOCATED_BUFF_LEN(currentMbufPtr) = sizeAligned;
poolDataPtr = (void *) ((unsigned) poolDataPtr + sizeAligned);
}
currentMbufPtr = nextMbufPtr;
}
/*
* update the number of free buffers in the pool
*/
poolPtr->freeBufsInPool = count;
poolPtr->poolAllocType = IX_OSAL_MBUF_POOL_TYPE_USER_ALLOC;
return poolPtr;
}
