index b5c41d20e7f343282569ccf4c4ce49a3ba23f210..f3d1841a60f84ee57d861cc05a8c6ec9672a45a9 100755 (executable)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************/
-#include <stdio.h>
-#include <stdlib.h>
+
#include <unistd.h>
-#include <string.h>
#include "netapi.h"
+#include "pktio.h"
+#include <ti/csl/csl_qm_queue.h>
+
-#ifdef PKTIO_GET_BENCHMARK
-/* for benchmarking .. need to be defined somewhere */
-unsigned int vv7p;
-unsigned int vv8p;
-unsigned int vv9p;
-unsigned int vv10p;
-unsigned int vv11p;
-unsigned int vv12p;
-unsigned int vv13p; //rcv path
-unsigned int vv14p;
-unsigned int vv15p;
-#endif
-/*--------------------Utilites-----------------*/
+/*This defines the maximum number of packets to receive in one pktio poll */
+#define PKTIO_MAX_RECV (TUNE_NETAPI_MAX_BURST_RCV)
+extern NETAPI_SHM_T* pnetapiShm;
-static PKTIO_HANDLE_T * pktiop_get_free_channel_slot(NETAPI_T n)
+
+/* Utilites*/
+static PKTIO_HANDLE_T * netapip_pktioGetFreeChannelSlot(NETAPI_T n)
{
- PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
- int i;
- for(i=0;i<NETAPI_MAX_PKTIO;i++)
- {
- if (pp[i]->inuse != PKTIO_INUSE)
- {
- return pp[i];
- }
- }
- return NULL;
+ NETAPI_HANDLE_T *p_handle;
+ PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
+ int i;
+ p_handle = (NETAPI_HANDLE_T*) n;
+ p_handle->spinLock.lock(&pnetapiShm->netapi_pktio_lock);
+ for(i=0;i<NETAPI_MAX_PKTIO;i++)
+ {
+ if (pp[i]->inuse != PKTIO_INUSE)
+ {
+ pp[i]->inuse = PKTIO_INUSE;
+ p_handle->spinLock.unlock(&pnetapiShm->netapi_pktio_lock);
+ return pp[i];
+ }
+ }
+ p_handle->spinLock.unlock(&pnetapiShm->netapi_pktio_lock);
+ return NULL;
}
-/*-----------------------------------------------------*/
-/* optimized send/rcv functions */
-/*----------------------------------------------------*/
+/*Optimized send functions */
+
-//********************************************
-//send pkt via ipc queue
-//********************************************
-static int pktio_send_ipc(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for L4 checksum,ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for L4 checksum,ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendL4CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
{
- PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
- *err=0;
-#ifdef PKTIO_GET_BENCHMARK
- vv8p=netapi_timing_stop();
-#endif
- Qmss_queuePushDesc (p->q, (void*)pkt);
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+ uint32_t swInfo0, swInfo1;
-#ifdef PKTIO_GET_BENCHMARK
- vv9p=netapi_timing_stop();
-#endif
- return 1;
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+ if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
+ {
+ nwal_mCmdSetL4CkSumCrypPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->l4OffBytes,
+ pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen,
+ pTxPktInfo->pseudoHdrChecksum,
+ pTxPktInfo->saOffBytes,
+ pTxPktInfo->saPayloadLen,
+ swInfo0,
+ swInfo1,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
+ return 1;
}
-//********************************************
-//send pkt to NETCP via NWAL
-//********************************************
-static int pktio_send_nwal(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
{
- PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
- nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
- nwal_RetValue res;
- *err=0;
- pPktInfo->pPkt = pkt;
-#ifdef PKTIO_GET_BENCHMARK
- vv11p=netapi_timing_stop();
-#endif
- res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
-#ifdef PKTIO_GET_BENCHMARK
- vv12p=netapi_timing_stop();
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+ uint32_t swInfo0, swInfo1;
+
+
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+
+ if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
+ {
+ nwal_mCmdSetCrypPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->saOffBytes,
+ pTxPktInfo->saPayloadLen,
+ swInfo0,
+ swInfo1,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
+ return 1;
+}
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for L3 checksum, ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for L3 checksum, ESP Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendL3CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+ uint32_t swInfo0, swInfo1;
+
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+
+
+ if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
+ {
+ nwal_mCmdSetL3CkSumCrypPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->saOffBytes,
+ pTxPktInfo->saPayloadLen,
+ swInfo0,
+ swInfo1,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
+ return 1;
+}
+
+
+
+
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for L4 checksum,AH Crypto and outgoing EMAC port
+ * to NetCP command.
+ *******************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for L4 checksum,AH Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+ uint32_t swInfo0, swInfo1;
+
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+
+ if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
+ {
+ nwal_mCmdSetL4CkSumAHCrypPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->l4OffBytes,
+ pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen,
+ pTxPktInfo->pseudoHdrChecksum,
+ pTxPktInfo->saOffBytes,
+ pTxPktInfo->saPayloadLen,
+ swInfo0,
+ swInfo1,
+ pTxPktInfo->saAhIcvOffBytes,
+ pTxPktInfo->saAhMacSize,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
+ return 1;
+}
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for AH Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for AH Crypto and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+ uint32_t swInfo0, swInfo1;
+
+
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+
+ if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
+ {
+ nwal_mCmdSetAHCrypPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->saOffBytes,
+ pTxPktInfo->saPayloadLen,
+ swInfo0,
+ swInfo1,
+ pTxPktInfo->saAhIcvOffBytes,
+ pTxPktInfo->saAhMacSize,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err= NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+ return 1;
+}
+
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for L4 checksum and outgoing EMAC port
+ * to NetCP command.
+ *******************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for L4 checksum and outgoing EMAC port
+ * to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendL4CkSumPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+
+ nwal_mCmdSetL4CkSumPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->l4OffBytes,
+ pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
+ pTxPktInfo->pseudoHdrChecksum,
+ pTxPktInfo->enetPort);
+
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ return 1;
+}
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via low level NWAL API's
+ * with updates for outgoing EMAC port to NetCP command.
+ ********************************************************************
+ * DESCRIPTION: Send packet via low level NWAL API's
+ * with updates for outgoing EMAC port to NetCP command.
+ ********************************************************************/
+static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
+ Cppi_HostDesc* pPloadDesc;
+
+ nwal_mCmdSetPort(pkt,
+ &p->tx_psCmdInfo,
+ pTxPktInfo->enetPort);
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ return 1;
+}
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via IPC queue
+ ********************************************************************
+ * DESCRIPTION: Send packet via IPC queue
+ ********************************************************************/
+static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ err=0;
+ Qmss_queuePushDesc (p->q, (void*)pkt);
+ return 1;
+}
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet to NETCP via NWAL
+ ********************************************************************
+ * DESCRIPTION: Send packet to NETCP via NWAL
+ ********************************************************************/
+static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
+ nwal_RetValue res;
+ *err=0;
+ pPktInfo->pPkt = pkt;
+ res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
+ if (res != nwal_OK)
+ {
+ *err = NETAPI_ERR_NWAL_TX_ERR -res;
+ return -1;
+ }
+ return 1;
+}
+
+
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet to SA via NWAL
+ ********************************************************************
+ * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode
+ * channel via NWAL
+ ********************************************************************/
+static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
+{
+
+ nwal_RetValue nwalRetVal;
+ nwalTxDmPSCmdInfo_t *dmPSCmdInfo;
+ nwalLocCxtInfo_t nwalLocCxt;
+ Cppi_HostDesc* pPloadDesc;
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ nwalLocCxtInfo_t info;
+ void* virtAddr = NULL;
+ nwalDmTxPayloadInfo_t *pPktInfoSB = m->u.tx_sb_meta;
+
+ NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
+
+ dmPSCmdInfo = netapip_netcpCfgGetSaSBInfo(&netapi_get_global()->nwal_context, tunnel_id);
+ if (dmPSCmdInfo)
+ {
+ nwalRetVal = nwal_getLocCxtInfo(pktio_mGetNwalInstance(p),&info);
+ if(nwalRetVal == nwal_OK)
+ {
+ dmPSCmdInfo->rxSbSaQ = info.rxSbSaQ;
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+ nwal_mCmdDMUpdate(pkt,
+ dmPSCmdInfo,
+ pPktInfoSB->appCtxId,
+ pPktInfoSB->encOffset,
+ pPktInfoSB->encSize,
+ pPktInfoSB->pEncIV,
+ pPktInfoSB->authOffset,
+ pPktInfoSB->authSize,
+ pPktInfoSB->pAuthIV,
+ pPktInfoSB->aadSize,
+ pPktInfoSB->pAad);
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+
+#if 0
+ printf("netapip_pktioSendSb: dumping descriptor begin\n");
+ PKTIO_dump_buf_32bit(pPloadDesc, 128);
+ printf("netapip_pktioSendSb: dumping descriptor end\n");
+
+ virtAddr= hplib_mVMPhyToVirt(pPloadDesc->softwareInfo1);
+
+ printf("phy Addr: 0x%x\n", pPloadDesc->softwareInfo1);
+ printf("virtAddr: 0x%x\n", virtAddr);
+
+ printf("netapip_pktioSendSb: dumping security context begin\n");
+ PKTIO_dump_buf((uint8_t*)virtAddr, 128);
+ PKTIO_dump_buf((uint8_t*)virtAddr+128, 128);
+ printf("netapip_pktioSendSb: dumping security context end\n");
#endif
- if (res != nwal_OK) { *err = NETAPI_ERR_NWAL_TX_ERR -res;}
- return 1;
+
+
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(dmPSCmdInfo->txQueue,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ }
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
+ return 1;
}
-//********************************************
-//send to SA via SB queue
-//********************************************
-static int pktio_send_sb(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via infrastructure DMA channel
+ ********************************************************************
+ * DESCRIPTION: Send packet via infrastructure DMA channel
+ ********************************************************************/
+static int netapip_pktioSendIfdma(struct PKTIO_HANDLE_tag * pp,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
{
+ Cppi_DescTag tag={0};
+ Cppi_HostDesc* pPloadDesc;
PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
- nwalDmTxPayloadInfo_t *pPktInfoSB = m->u.tx_sb_meta;
- nwal_RetValue res;
- *err=0;
- pPktInfoSB->pPkt = pkt;
- res=nwal_sendDM(p->nwalInstanceHandle, m->sa_handle,pPktInfoSB);
- if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
+ *err=0;
+ tag.srcTagLo = m->u.tx_ifdma_dest;
+ Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
+
+ Qmss_queuePushDescSizeRaw(p->q,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
return 1;
}
-//********************************************
-//dummy. return err
-//********************************************
-static int pktio_send_dummy(struct PKTIO_HANDLE_tag * p, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
-{
- *err = NETAPI_ERR_BAD_INPUT;
- return -1;
-}
-//*******************************************
-//dummy poll
-//*******************************************
-static int pktio_poll_dummy(struct PKTIO_HANDLE_tag * p, PKTIO_POLL_T * p_poll_cfg, int * err)
+
+
+
+/********************************************************************
+ * FUNCTION PURPOSE: Stub function for send, do nothing.
+ ********************************************************************
+ * DESCRIPTION: Stub function for send, do nothing.
+ ********************************************************************/
+static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
+ Ti_Pkt *pkt,
+ PKTIO_METADATA_T *m,
+ int * err)
{
- *err= NETAPI_ERR_BAD_INPUT;
- return 0;
+ *err = NETAPI_ERR_BAD_INPUT;
+ return -1;
}
-//********************************************
-//poll IPC queue
-//********************************************
-static int pktio_poll_ipc(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg, int * err)
+
+/********************************************************************
+ * FUNCTION PURPOSE: Stub function for poll, do nothing.
+ ********************************************************************
+ * DESCRIPTION: Stub function for send, do nothing.
+ ********************************************************************/
+static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-int r=0;
-int n;
-Ti_Pkt * temp;
-*err=0;
-n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
-for(r=0;r<n;r++)
+ *err= NETAPI_ERR_BAD_INPUT;
+ return 0;
+}
+
+/********************************************************************
+ * FUNCTION PURPOSE: Poll IPC queue
+ ********************************************************************
+ * DESCRIPTION: Poll IPC queue
+ ********************************************************************/
+static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-#ifdef PKTIO_GET_BENCHMARK
- if (r==0) vv7p=netapi_timing_stop();
-#endif
- temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
+ Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+ PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ int r=0;
+ int n;
+ Ti_Pkt * temp;
+ *err=0;
+ n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
+ for(r=0;r<n;r++)
+ {
-#ifdef PKTIO_GET_BENCHMARK
- if (r==0) vv10p=netapi_timing_stop();
-#endif
- if(!temp) break;
- /* process meta data */
- pkt_list[r]= temp;
- meta_s[r].flags1=0x1;
- }
- if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
- return r;
+ temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
+
+ if(!temp) break;
+ /* process meta data */
+ pkt_list[r]= temp;
+ meta_s[r].flags1=0x1;
+ }
+ if (r)
+ {
+ p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
+ }
+ return r;
}
-//********************************************
-//poll nwal data queues for pkts from netcp
-//********************************************
-static int pktio_poll_nwal(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg, int * err)
+
+/********************************************************************
+ * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
+ ********************************************************************
+ * DESCRIPTION: Poll nwal data queues for pkts from netcp
+ ********************************************************************/
+static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
- /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
- set.. optimizaion maybe? */
-#ifdef PKTIO_GET_BENCHMARK
- vv13p=netapi_timing_stop();
-#endif
- r=nwal_pollPkt(p->nwalInstanceHandle,
- nwal_POLL_DEFAULT_GLOB_PKT_Q| nwal_POLL_DEFAULT_PER_PROC_PKT_Q,
+ int r=0;
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ *err=0;
+ /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
+ set. optimizaion maybe? */
+ r=nwal_pollPkt(p->nwalInstanceHandle,
+ p->poll_flags,
(uint32_t) p,
p->max_n,
QMSS_PARAM_NOT_SPECIFIED,
(void*) NULL);
- return r;
+ return r;
}
-//********************************************
-//poll nwal sideband queues for pkts from SA
-//********************************************
-static int pktio_poll_sb(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
+ ********************************************************************
+ * DESCRIPTION: Poll nwal sideband queues for pkts from SA
+ ********************************************************************/
+static int netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
- r=nwal_pollDm(p->nwalInstanceHandle,
- nwal_POLL_DM_DEF_GLOB_ENCRYPT_Q,
- (uint32_t) p,
- p->max_n,
- QMSS_PARAM_NOT_SPECIFIED,
- (void *) NULL);
- r+=nwal_pollDm(p->nwalInstanceHandle,
- nwal_POLL_DM_DEF_GLOB_DECRYPT_Q,
+ int r=0;
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ *err=0;
+ r=nwal_pollDm(p->nwalInstanceHandle,
+ nwal_POLL_DM_DEF_SB_SA_Q,
(uint32_t) p,
p->max_n,
QMSS_PARAM_NOT_SPECIFIED,
- (void *) NULL);
- return r;
+ (void *) NULL);
+ return r;
}
-//********************************************
-//poll app-provided netcp rx queue
-//********************************************
-static int pktio_poll_nwal_adj(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: Poll application provided NETCP RX queue
+ ********************************************************************
+ * DESCRIPTION: Poll application provided NETCP RX queue
+ ********************************************************************/
+static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
- /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
- set.. optimizaion maybe? */
-#ifdef PKTIO_GET_BENCHMARK
- vv14p=netapi_timing_stop();
-#endif
- r=nwal_pollPkt(p->nwalInstanceHandle,
- nwal_POLL_APP_MANAGED_PKT_Q,
- (uint32_t) p,
- p->max_n,
- p->q,
- (void *) NULL);
- return r;
+ int r=0;
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ *err=0;
+ /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
+ set. optimizaion maybe? */
+ r=nwal_pollPkt(p->nwalInstanceHandle,
+ nwal_POLL_APP_MANAGED_PKT_Q,
+ (uint32_t) p,
+ p->max_n,
+ p->q,
+ (void *) NULL);
+
+ return r;
}
-//********************************************
-//poll app-defined sideband queues for pkts from SA
-//********************************************
-static int pktio_poll_sb_adj(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg, int * err)
+/*************************************************************************
+ * FUNCTION PURPOSE: Poll application defined sideband queues for packets
+ * from SA
+ ************************************************************************
+ * DESCRIPTION: Poll application defined sideband queues for packets
+ * from SA
+ *************************************************************************/
+static int netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp,
+ PKTIO_POLL_T * p_poll_cfg,
+ int * err)
{
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
- r=nwal_pollDm(p->nwalInstanceHandle,
+ int r=0;
+ PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+ *err=0;
+ r=nwal_pollDm(p->nwalInstanceHandle,
nwal_POLL_DM_APP_MANAGED_Q,
(uint32_t) p,
p->max_n,
p->q,
(void *) NULL);
- return r;
+ return r;
}
/*-----------------------MAIN API----------------------*/
-/* create a channel */
-PKTIO_HANDLE_T * pktio_create(NETAPI_T n, char * name,
- PKTIO_CB cb, PKTIO_CFG_T * p_cfg, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: API creates a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API creates a NETAPI PKTIO channel
+ ********************************************************************/
+PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
+ char * name,
+ PKTIO_CB cb,
+ PKTIO_CFG_T * p_cfg,
+ int * err)
{
-int r = 0;
-PKTIO_HANDLE_T *p;
-uint8_t isAllocated;
-
-*err=0;
-
-if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
-if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_W)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
-if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_W)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
-
-/* get a free channel handle */
-p=pktiop_get_free_channel_slot(n);
-if (!p) {*err = PKTIO_NOMEM; return (p); }
-
-p->inuse= PKTIO_INUSE;
-p->back = n;
-p->cb = cb;
-p->max_n = p_cfg->max_n;
-p->_poll=pktio_poll_dummy;
-p->_send=pktio_send_dummy;
-memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
-
- /* create a general queue (for now). todo: allow qnum to be passed in */
- p->q = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
- QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
- if (p->q == (Qmss_QueueHnd) NULL)
- {
- printf(">pktio_create: queueOpen failed\n");
+ int r = 0;
+ PKTIO_HANDLE_T *p;
+ uint8_t isAllocated;
+
+ *err=0;
+ int q = QMSS_PARAM_NOT_SPECIFIED;
+
+ int qtype = Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
+
+ if(p_cfg == NULL)
+ {
+ *err = NETAPI_ERR_BAD_INPUT;
+ return NULL;
+ }
+ /* over-ride only for Qmss_QueueType_GIC400_QUEUE */
+ if (p_cfg->queueType == Qmss_QueueType_GIC400_QUEUE)
+ qtype = p_cfg->queueType;
+
+ if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
+ if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
+ if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
+
+ /* get a free channel handle */
+ p=netapip_pktioGetFreeChannelSlot(n);
+
+ if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
+
+ p->back = n;
+ p->cb = cb;
+ p->max_n = p_cfg->max_n;
+ p->_poll=netapip_pktioPollDummy;
+ p->_send=netapip_pktioSendDummy;
+ memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
+
+ if (p_cfg->qnum!=PKTIO_Q_ANY)
+ {
+ q= p_cfg->qnum;
+ }
+ /* special case for infrastructure dma channels */
+ if (p_cfg->flags2 & PKTIO_IFDMA)
+ {
+ qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
+ }
+
+
+ /* create a general queue */
+ p->q = Qmss_queueOpen(qtype,
+ q,
+ &isAllocated);
+ if (p->q < 0)
+ {
+ netapi_Log("netapi_pktioCreate: queueOpen failed\n");
p->inuse=0;
*err= NETAPI_ERR_QLLD; ///queue lld error
return NULL;
}
+
p->qInfo = Qmss_getQueueNumber(p->q);
+
if (p_cfg->flags2 & PKTIO_PKT)
{
- p->use_nwal = PKTIO_4_ADJ_NWAL;
- p->_poll=pktio_poll_nwal_adj;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
+ p->use_nwal = PKTIO_4_ADJ_NWAL;
+ p->_poll=netapip_pktioPollNwalAdj;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
}
else if (p_cfg->flags2 & PKTIO_SB)
{
- p->use_nwal = PKTIO_4_ADJ_SB;
- p->_poll=pktio_poll_sb_adj;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
+ p->use_nwal = PKTIO_4_ADJ_SB;
+ p->_poll=netapip_pktioPollSbAdj;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
}
+ else if (p_cfg->flags2 & PKTIO_IFDMA)
+ {
+ p->use_nwal = 0;
+ p->_send = netapip_pktioSendIfdma;
+ p->cfg.flags1=PKTIO_TX;
+ r= netapip_pktioCreateIFDMA(p); //we create the IF DMA channel here
+ if (r<0)
+ {
+ //trouble -> couldn't set up DMA
+ //close queue and return failure
+ if (p->q)
+ {
+ Qmss_queueClose(p->q);
+ }
+ p->inuse=0;
+ *err= NETAPI_ERR_QLLD; ///queue lld error TODO: fix error code
+ return NULL;
+ }
+ }
else
{
p->use_nwal=0;
- if (p_cfg->flags1& PKTIO_W) p->_send=pktio_send_ipc;
- if (p_cfg->flags1& PKTIO_R) p->_poll=pktio_poll_ipc;
+ if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
+ if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
}
/* save name */
strlen(name):PKTIO_MAX_NAME);
/* add name, qnum to global name list */
- if ((strcmp(name,NETCP_RX)) && (strcmp(name,NETCP_TX)) &&
- (strcmp(name,NETCP_SB_RX)) &&
- (strcmp(name,NETCP_SB_TX)) &&
- (p_cfg->flags1 & PKTIO_GLOBAL) )
- {
- //todo: make sure this succeeds..
- r=netapi_add_global_pktio(n, name, &p->qInfo);
- }
+ if ((strcmp(name,NETCP_RX)) &&
+ (strcmp(name,NETCP_TX)) &&
+ (strcmp(name,NETCP_SB_RX)) &&
+ (strcmp(name,NETCP_SB_TX)) &&
+ (p_cfg->flags1 & PKTIO_GLOBAL))
+ {
+ //todo: make sure this succeeds..
+ hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
+ r=netapip_addGlobalPktio(n, name, &p->qInfo);
+ hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
+ }
+
((NETAPI_HANDLE_T *)n )->n_pktios+=1;
return p;
}
-
-/***********************************************************/
-/************** open an existing channel. *****************/
-/***********************************************************/
-PKTIO_HANDLE_T * pktio_open(NETAPI_T n, char *name,
- PKTIO_CB cb, PKTIO_CFG_T * p_cfg, int * err)
-{
-int r=0;
-PKTIO_HANDLE_T *p, *p2;
-uint8_t isAllocated;
-*err=0;
-Qmss_Queue *p_qnum;
-
-if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
-
-/* get a free channel handle */
-p=pktiop_get_free_channel_slot(n);
-if (!p) {*err = PKTIO_NOMEM; return (p); }
-((NETAPI_HANDLE_T *)n)->n_pktios+=1;
-
-p->inuse= PKTIO_INUSE;
-p->back = n;
-p->cb = cb;
-p->max_n = p_cfg->max_n;
-p->_poll=pktio_poll_dummy;
-p->_send=pktio_send_dummy;
-memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
-
-/* special handling of NETCP_RX, NETCP_TX */
-if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
-{
- /* these have already been opened internally, so don't search in global list */
- p->use_nwal = PKTIO_DEF_NWAL;
- p->q = 0;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
- if (!strcmp(name,NETCP_RX)) p->_poll=pktio_poll_nwal;
- if (!strcmp(name,NETCP_TX)) p->_send=pktio_send_nwal;
-}
-else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
-{
- /* these have already been opened internally, so don't search in global list */
- p->use_nwal = PKTIO_DEF_SB;
- p->q = 0;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
- if (!strcmp(name,NETCP_SB_RX)) p->_poll=pktio_poll_sb;
- if (!strcmp(name,NETCP_SB_TX)) p->_send=pktio_send_sb;
-}
-else
+/********************************************************************
+ * FUNCTION PURPOSE: API opens an existing NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API opens an existing NETAPI PKTIO channel
+ ********************************************************************/
+PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T n,
+ char *name,
+ PKTIO_CB cb,
+ PKTIO_CFG_T * p_cfg,
+ int * err)
{
- /* find queue in global list */
- p_qnum = netapi_find_global_pktio(n, name);
- if (!p_qnum )
- {
- printf(">pktio_open: can't find %s\n",name);
- p->inuse=0;
- *err= NETAPI_ERR_NOTFOUND; ///queue lld error
- return NULL;
- }
+ int r=0;
+ PKTIO_HANDLE_T *p, *p2;
+ uint8_t isAllocated;
+ *err=0;
+ Qmss_Queue *p_qnum;
+ int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
+
+
+ if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
+
+ /* get a free channel handle */
- /* open a general queue (for now). use qnum that was just found */
- p->q = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
- p_qnum->qNum , &isAllocated);
- if (p->q == (Qmss_QueueHnd) NULL)
+ p=netapip_pktioGetFreeChannelSlot(n);
+
+ if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
+ ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
+
+ p->inuse= PKTIO_INUSE;
+ p->back = n;
+ p->cb = cb;
+ p->max_n = p_cfg->max_n;
+ p->_poll=netapip_pktioPollDummy;
+ p->_send=netapip_pktioSendDummy;
+ memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
+
+ /* special handling of NETCP_RX, NETCP_TX */
+ if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
{
- printf(">pktio_create: queueOpen failed\n");
- p->inuse=0;
- *err= NETAPI_ERR_QLLD; ///queue lld error
- return NULL;
+ /* these have already been opened internally, so don't search in global list */
+ p->use_nwal = PKTIO_DEF_NWAL;
+ p->q = 0;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
+ if (!strcmp(name,NETCP_RX))
+ {
+ p->_poll=netapip_pktioPollNwal;
+ p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
+ nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
+ }
+ if (!strcmp(name,NETCP_TX))
+ {
+ p->_send=netapip_pktioSendNwal;
+ }
}
- p->qInfo = Qmss_getQueueNumber(p->q);
- if (p_cfg->flags2 & PKTIO_PKT)
- {
- p->use_nwal = PKTIO_4_ADJ_NWAL; //additonal RX q for nwal
- p->_poll = pktio_poll_nwal_adj;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
- }
- else if (p_cfg->flags2 & PKTIO_SB)
+ else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
{
- p->use_nwal = PKTIO_4_ADJ_SB; //additional RX q for sideband with NWAL
- p->_poll = pktio_poll_sb_adj;
- p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
- }
- else
- {
- p->use_nwal=0; //not handled by nwal
- if (p_cfg->flags1& PKTIO_W) p->_send=pktio_send_ipc;
- if (p_cfg->flags1& PKTIO_R) p->_poll=pktio_poll_ipc;
+ /* these have already been opened internally, so don't search in global list */
+ p->use_nwal = PKTIO_DEF_SB;
+ p->q = 0;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
+ if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
+ if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
}
-}
+ else
+ {
+ hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
+ /* Find queue in global list
+ Note names like "QUEUE:%d" or IFDMA:%d cause general purpose or
+ IFDMA queues of that number to be opened */
+ if (p_cfg->flags2 & PKTIO_IFDMA)
+ {
+ qtype= Qmss_QueueType_INFRASTRUCTURE_QUEUE;
+ }
- /* save name */
- strncpy(p->name,name,
- strlen(name)<PKTIO_MAX_NAME ?
- strlen(name):PKTIO_MAX_NAME);
+ hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
+ p_qnum = netapip_findGlobalPktio(n, name);
+ if (!p_qnum )
+ {
+ netapi_Log("netapi_pktioOpen: can't find %s\n",name);
+ p->inuse=0;
+ *err= NETAPI_ERR_NOTFOUND; ///queue lld error
+ return NULL;
+ }
+
+ /* open a general queue (for now). use qnum that was just found */
+ p->q = Qmss_queueOpen(qtype,
+ p_qnum->qNum , &isAllocated);
+ if (p->q == (Qmss_QueueHnd) NULL)
+ {
+ netapi_Log("netapi_pktioCreate: queueOpen failed\n");
+ p->inuse=0;
+ *err= NETAPI_ERR_QLLD; ///queue lld error
+ return NULL;
+ }
+ p->qInfo = Qmss_getQueueNumber(p->q);
+ netapi_Log("netapi_pktioOpen: queueMgr %d, queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
+ if (p_cfg->flags2 & PKTIO_PKT)
+ {
+ p->use_nwal = PKTIO_4_ADJ_NWAL; //additonal RX q for nwal
+ p->_poll = netapip_pktioPollNwalAdj;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
+ netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
+ }
+ else if (p_cfg->flags2 & PKTIO_SB)
+ {
+ p->use_nwal = PKTIO_4_ADJ_SB; //additional RX q for sideband with NWAL
+ p->_poll = netapip_pktioPollSbAdj;
+ p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
+ }
+ else if (p_cfg->flags2 & PKTIO_IFDMA)
+ {
+ p->_send= netapip_pktioSendIfdma;
+ p->use_nwal = 0;
+ }
+ else
+ {
+ p->use_nwal=0; //not handled by nwal
+ if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
+ if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
+ }
+ }
+ /* save name */
+ strncpy(p->name,name,
+ strlen(name)<PKTIO_MAX_NAME ?
+ strlen(name):PKTIO_MAX_NAME);
-return p;
+ netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
+ return p;
}
-/***********************************************************/
-/************** control the channel ****************/
-/***********************************************************/
-void pktio_control(PKTIO_HANDLE_T * p,
- PKTIO_CB cb,
- PKTIO_CFG_T * p_cfg,
- PKTIO_CONTROL_T * p_control,
- int *err)
+/********************************************************************
+ * FUNCTION PURPOSE: API controls an existing NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API controls an existing NETAPI PKTIO channel
+ ********************************************************************/
+void netapi_pktioControl(PKTIO_HANDLE_T * p,
+ PKTIO_CB cb,
+ PKTIO_CFG_T * p_cfg,
+ PKTIO_CONTROL_T * p_control,
+ int *err)
{
- if (!p) { *err=1; return;}
- if (cb)
- {
- p->cb = cb;
- }
- if (p_control)
+ nwal_RetValue nwalRetVal;
+ if (!p)
+ {
+ *err= NETAPI_ERR_BAD_INPUT;
+ return;
+ }
+ if (cb)
+ {
+ p->cb = cb;
+ }
+ if (p_control)
+ {
+ /* todo: check for validity, eg don't allow clear of NETCP TX queues */
+ /* todo: implement divert */
+ switch(p_control->op)
{
- /* todo: check for validity, eg don't allow clear of NETCP TX queues */
- /* todo: implement divert */
- switch(p_control->op)
- {
- //clear the queue
- case(PKTIO_CLEAR):
- netapi_zapQ(p->q);
- break;
- case(PKTIO_DIVERT):
- default:
- printf(">pktio_control: pktio_control op %d not implemented\n",p_control->op);
- *err= NETAPI_ERR_NOT_IMPLEMENTED;
- break;
- }
+ //clear the queue
+ case(PKTIO_SET_POLL_FLAGS):
+ p->poll_flags=p_control->poll_flags;
+ break;
+ case(PKTIO_CLEAR):
+ netapip_zapQ(p->q);
+ break;
+ case (PKTIO_UPDATE_FAST_PATH):
+ if (p_cfg)
+ {
+ nwalRetVal = nwal_initPSCmdInfo(p->nwalInstanceHandle,
+ p_cfg->fast_path_cfg.txPktInfo,
+ &p->tx_psCmdInfo);
+ if (nwalRetVal == nwal_OK)
+ {
+ switch (p_cfg->fast_path_cfg.fp_send_option)
+ {
+ case (PKTIO_FP_ESP_L4CKSUM_PORT):
+ p->_send = netapip_pktioSendL4CkSumCryptPort;
+ break;
+ case (PKTIO_FP_AH_L4CKSUM_PORT):
+ p->_send = netapip_pktioSendL4CkSumAHCryptPort;
+ break;
+ case (PKTIO_FP_ESP_PORT):
+ p->_send = netapip_pktioSendCryptPort;
+ break;
+ case (PKTIO_FP_ESP_L3CKSUM_PORT):
+ p->_send = netapip_pktioSendL3CkSumCryptPort;
+ break;
+ case (PKTIO_FP_AH_PORT):
+ p->_send = netapip_pktioSendAHCryptPort;
+ break;
+ case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
+ p->_send = netapip_pktioSendPort;
+ break;
+ case (PKTIO_FP_L4CKSUM_PORT):
+ p->_send = netapip_pktioSendL4CkSumPort;
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ *err = NETAPI_ERR_BAD_INPUT;
+ }
+ }
+ else
+ {
+ *err = NETAPI_ERR_BAD_INPUT;
+ }
+ break;
+ case (PKTIO_UPDATE_MAX_PKTS_PER_POLL):
+ if (p_cfg)
+ {
+ p->max_n = p_cfg->max_n;
+ }
+ else
+ {
+ *err = NETAPI_ERR_BAD_INPUT;
+ }
+ break;
+ case(PKTIO_DIVERT):
+ default:
+ netapi_Log("netapi_pktioControl: pktio_control op %d not implemented\n",p_control->op);
+ *err= NETAPI_ERR_NOT_IMPLEMENTED;
+ break;
}
- //all we configure is max_n. Can't change type of queue, rx/tx, etc
- if (p_cfg)
- {
- p->max_n = p_cfg->max_n;
- }
- *err=0;
- return;
-}
+ }
-/***********************************************************/
-/*****************close ***************************/
-/***********************************************************/
-void pktio_close(PKTIO_HANDLE_T * p, int * err)
+ *err = NETAPI_ERR_OK;
+ return;
+}
+/********************************************************************
+ * FUNCTION PURPOSE: API closes a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API closes a NETAPI PKTIO channel
+ ********************************************************************/
+void netapi_pktioClose(PKTIO_HANDLE_T * p,
+ int * err)
{
- if(!p) { *err=1; return;}
- *err=0;
- Qmss_queueClose(p->q); //LLD keeps reference count
- p->q=-1;
- p->inuse=0;
- ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
- return;
+ if(!p)
+ {
+ *err=1;
+ return;
+ }
+ *err=0;
+ if (p->q)
+ {
+ Qmss_queueClose(p->q);
+ }
+ p->q=-1;
+ p->inuse=0;
+ ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
+ return;
}
-/***********************************************************/
-/*****************Delete***************************/
-/***********************************************************/
-void pktio_delete(PKTIO_HANDLE_T * p, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: API deletes a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API deletes a NETAPI PKTIO channel
+ ********************************************************************/
+void netapi_pktioDelete(PKTIO_HANDLE_T * p,
+ int * err)
{
- if(!p) { *err=1; return;}
- *err=0;
+ if(!p)
+ {
+ *err=1;
+ return;
+ }
+ *err=0;
+ if (p->cfg.flags2 & PKTIO_IFDMA)
+ {
+ netapip_pktioDeleteIFDMA(p);
+ }
+
/* remove from name list */
+ hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
+ hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB))
- {
- netapi_zapQ(p->q); //since we are deleting, zap the queue
- Qmss_queueClose(p->q);
- }
- p->q=-1;
- p->inuse=0;
- ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
- return ;
+ {
+ netapip_zapQ(p->q); //since we are deleting, zap the queue
+ Qmss_queueClose(p->q);
+ }
+ p->q=-1;
+ p->inuse=0;
+ ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
+ return ;
}
+/********************************************************************
+ * FUNCTION PURPOSE: API sends multiple packets to a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION: API sends multiple packets to a NETAPI PKTIO channel
+ ********************************************************************/
+int netapi_pktioSendMulti(PKTIO_HANDLE_T * p,
+ Ti_Pkt * pkt[],
+ PKTIO_METADATA_T * m[],
+ int np,
+ int* err)
+{
+ int r=0;
+ for(r=0;r<np;r++)
+ {
+ p->_send((struct PKTIO_HANDLE_tag *)p, (Ti_Pkt *)pkt, (PKTIO_METADATA_T *)m, err);
+ }
+ return r;
+}
-/***********************************************************/
-/*****************send *************************/
-/***********************************************************/
-int pktio_send_genric(PKTIO_HANDLE_T * p, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: API polls all NETAPI PKTIO channels associated with NETAPI_T
+ * instance for received packets
+ ********************************************************************
+ * DESCRIPTION: API polls all NETAPI PKTIO channels associated with NETAPI_T
+ * instance for received packets
+ ********************************************************************/
+int netapi_pktioPollAll(NETAPI_T handle,
+ PKTIO_POLL_T * p_poll_cfg,
+ int *err)
{
- nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
- nwal_RetValue res;
+ int i=0;
+ int r=0;
+ int err2;
+ int cnt=0;
+ PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **) netapi_get_pktio_list(handle);
+
*err=0;
- if(! (p->cfg.flags1&PKTIO_W)) return 0;
- if ((p->use_nwal== PKTIO_DEF_NWAL) )
+ for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
{
- pPktInfo->pPkt = pkt;
-#ifdef PKTIO_GET_BENCHMARK
- vv11p=netapi_timing_stop();
-#endif
- res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
-#ifdef PKTIO_GET_BENCHMARK
- vv12p=netapi_timing_stop();
-#endif
- if (res != nwal_OK) { printf("nwal send err= %d (%x)\n", res, res); *err = NETAPI_ERR_NWAL_TX_ERR -res;}
+ if (pp[i]->inuse != PKTIO_INUSE) continue;
+ if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
+ r+=netapi_pktioPoll(pp[i], p_poll_cfg, &err2); cnt+=1;
+ if (err2) { *err = err2; break;}
}
- else if ((p->use_nwal== PKTIO_DEF_SB) )
- {
- nwalDmTxPayloadInfo_t *pPktInfoSB = m->u.tx_sb_meta;
- pPktInfoSB->pPkt = pkt;
- res=nwal_sendDM(p->nwalInstanceHandle, m->sa_handle,pPktInfoSB);
- if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
- }
- else
- {
- /* tod: meta data for non netcp xfers */
- /* process meta data */
-#ifdef PKTIO_GET_BENCHMARK
- vv8p=netapi_timing_stop();
-#endif
- Qmss_queuePushDesc (p->q, (void*)pkt);
+ return r;
-#ifdef PKTIO_GET_BENCHMARK
- vv9p=netapi_timing_stop();
-#endif
- }
- return 1;
}
-/***********************************************************/
-/*******************send multiple**************************/
-/***********************************************************/
-int pktio_sendMulti(PKTIO_HANDLE_T * p, Ti_Pkt * pkt[], PKTIO_METADATA_T * m[], int np, int* err)
+/********************************************************************
+ * FUNCTION PURPOSE: Internal function to delete a PKTIO infrastructure DMA channel
+ ********************************************************************
+ * DESCRIPTION: Internal function to delete a PKTIO infrastructure DMA channel
+ ********************************************************************/
+int netapip_pktioDeleteIFDMA(PKTIO_HANDLE_T *p)
{
- nwal_RetValue res;
- int r=0;
- *err=0;
- if(! p->cfg.flags1&PKTIO_W) return 0;
- if ((p->use_nwal== PKTIO_DEF_NWAL) )
- {
- for(r=0;r<np;r++)
- {
- nwalTxPktInfo_t *pPktInfo= m[r]->u.tx_meta;
- pPktInfo->pPkt = pkt[r];
- res=nwal_send(p->nwalInstanceHandle,m[r]->sa_handle,pPktInfo);
- if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
- }
- }
- else if ((p->use_nwal== PKTIO_DEF_SB) )
- {
- for(r=0;r<np;r++)
- {
- nwalDmTxPayloadInfo_t *pPktInfoSB =m[r]->u.tx_sb_meta;
- pPktInfoSB->pPkt = pkt[r];
- res=nwal_sendDM(p->nwalInstanceHandle, m[r]->sa_handle,pPktInfoSB);
- if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
- }
- }
- else
- {
- for(r=0;r<np;r++)
- {
- /* process meta data */
- Qmss_queuePushDesc(p->q, (void*) pkt[r]);
- }
- }
- return r;
+ Cppi_channelDisable (p->txChHnd);
+ Cppi_channelDisable (p->rxChHnd);
+ Cppi_channelClose(p->txChHnd);
+ Cppi_channelClose(p->rxChHnd);
+ Cppi_close(p->cppiHnd);
+ return 1;
}
-/***********************************************************/
-/******************* polling **********************/
-/***********************************************************/
-
-/* poll a particular channel */
-int pktio_poll_generic(PKTIO_HANDLE_T * p, PKTIO_POLL_T * p_poll_cfg, int * err)
+/********************************************************************
+ * FUNCTION PURPOSE: Internal function to create a PKTIO infrastructure DMA channel
+ ********************************************************************
+ * DESCRIPTION: Internal function to create a PKTIO infrastructure DMA channel
+ * for infrastructure DMQ queue
+ ********************************************************************/
+int netapip_pktioCreateIFDMA(PKTIO_HANDLE_T * p )
{
-int r=0;
-int n;
-Ti_Pkt * temp;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
-//uint64_t ts= netapi_getTimestamp(); //get_ts
-uint64_t ts=0LL;
-
- if(! p->cfg.flags1&PKTIO_R) return 0;
-
- /** poll the netcp default RX queue we squirt out below */
- if (p->use_nwal==PKTIO_DEF_NWAL)
- {
- /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
- set.. optimizaion maybe? */
-#ifdef PKTIO_GET_BENCHMARK
- vv13p=netapi_timing_stop();
-#endif
- r=nwal_pollPkt(p->nwalInstanceHandle,
- nwal_POLL_DEFAULT_GLOB_PKT_Q| nwal_POLL_DEFAULT_PER_PROC_PKT_Q,
- (uint32_t) p,
- p->max_n,
- QMSS_PARAM_NOT_SPECIFIED,
- (void*) NULL);
- }
- /** poll a netcp RX queue. we squirt out below */
- else if (p->use_nwal==PKTIO_4_ADJ_NWAL)
- {
- /* Poll an additional NETCP RX queue */
-#ifdef PKTIO_GET_BENCHMARK
- vv14p=netapi_timing_stop();
-#endif
- r=nwal_pollPkt(p->nwalInstanceHandle,
- nwal_POLL_APP_MANAGED_PKT_Q,
- (uint32_t) p,
- p->max_n,
- p->q,
- (void *) NULL);
- }
- /** poll the NETCP default SideBand (data mode -dm) return queue **/
- else if(p->use_nwal==PKTIO_DEF_SB)
- {
- r=nwal_pollDm(p->nwalInstanceHandle,
- nwal_POLL_DM_DEF_GLOB_ENCRYPT_Q,
- (uint32_t) p,
- p->max_n,
- QMSS_PARAM_NOT_SPECIFIED,
- (void *) NULL);
- r+=nwal_pollDm(p->nwalInstanceHandle,
- nwal_POLL_DM_DEF_GLOB_DECRYPT_Q,
- (uint32_t) p,
- p->max_n,
- QMSS_PARAM_NOT_SPECIFIED,
- (void *) NULL);
+ int dmaChan = p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
+ unsigned char isAllocated;
+ Cppi_TxChInitCfg txChCfg;
+ Cppi_RxChInitCfg rxChCfg;
+ Cppi_CpDmaInitCfg cpdmaCfg;
- }
- /** poll an app define SideBand (data mode -dm) return queue **/
- else if (p->use_nwal==PKTIO_4_ADJ_SB)
- {
- r=nwal_pollDm(p->nwalInstanceHandle,
- nwal_POLL_DM_APP_MANAGED_Q,
- (uint32_t) p,
- p->max_n,
- p->q,
- (void *) NULL);
- }
+ /* Set up QMSS CPDMA configuration */
+ memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
+ cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
- /* poll an IPC queue */
- else
- {
- *err=0;
- n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
- for(r=0;r<n;r++)
- {
-#ifdef PKTIO_GET_BENCHMARK
- if (r==0) vv7p=netapi_timing_stop();
-#endif
- temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
+ /* Open QMSS CPDMA */
+ p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
+ if (p->cppiHnd == NULL)
+ {
+ return -1;
+ }
-#ifdef PKTIO_GET_BENCHMARK
- if (r==0) vv10p=netapi_timing_stop();
-#endif
- if(!temp) break;
- /* process meta data */
- pkt_list[r]= temp;
- meta_s[r].flags1=0x1;
- }
- if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, ts);
- }
- return r;
-}
+ /* Set up Tx Channel parameters */
+ memset ((void *) &txChCfg, 0, sizeof (Cppi_TxChInitCfg));
+ txChCfg.channelNum = dmaChan;
+ txChCfg.priority = 0;
+ txChCfg.filterEPIB = 0;
+ txChCfg.filterPS = 0;
+ txChCfg.aifMonoMode = 0;
+ txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
-/***********************************************************/
-/** poll all channels attached to this handle */
-/***********************************************************/
-int pktio_pollAll(NETAPI_T handle, PKTIO_POLL_T * p_poll_cfg, int *err)
-{
-int i=0;
-int r=0;
-int err2;
-int cnt=0;
-PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **) netapi_get_pktio_list(handle);
-
-*err=0;
-for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
-{
- if (pp[i]->inuse != PKTIO_INUSE) continue;
- if(!(pp[i]->cfg.flags1&PKTIO_R)) continue;
- r+=pktio_poll(pp[i], p_poll_cfg, &err2); cnt+=1;
- if (err2) { *err = err2; break;}
-}
-return r;
+ /* Open Tx Channel */
+ p->txChHnd = (Cppi_ChHnd) Cppi_txChannelOpen (p->cppiHnd, &txChCfg, &isAllocated);
+ if (p->txChHnd == NULL)
+ {
+ Cppi_close(p->cppiHnd);
+ return -1;
+ }
+ /* Set up Rx Channel parameters */
+ memset ((void *) &rxChCfg, 0, sizeof (Cppi_RxChInitCfg));
+ rxChCfg.channelNum = dmaChan;
+ rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
+
+ /* Open Rx Channel */
+ p->rxChHnd = (Cppi_ChHnd) Cppi_rxChannelOpen (p->cppiHnd, &rxChCfg, &isAllocated);
+ if (p->rxChHnd == NULL)
+ {
+ Cppi_channelClose(p->txChHnd);
+ Cppi_close(p->cppiHnd);
+ return -1;
+ }
+ if (Cppi_channelEnable (p->txChHnd) != CPPI_SOK)
+ {
+ Cppi_channelClose(p->txChHnd);
+ Cppi_channelClose(p->rxChHnd);
+ Cppi_close(p->cppiHnd);
+ return -1;
+ }
+
+ /* Enable receive channel */
+ if (Cppi_channelEnable (p->rxChHnd) != CPPI_SOK)
+ {
+ Cppi_channelDisable (p->txChHnd);
+ Cppi_channelClose(p->txChHnd);
+ Cppi_channelClose(p->rxChHnd);
+ Cppi_close(p->cppiHnd);
+ return -1;
+ }
+ return 1;
}
-/***** this is the callback we registered with NWAL for pkt reception *****/
-/* appcookie -> pktio handle */
-void netapi_NWALRxPktCallback (uint32_t appCookie,
- uint16_t numPkts,
- nwalRxPktInfo_t* pPktInfo,
- uint64_t timestamp,
- nwal_Bool_t* pFreePkt)
+/**********************************************************************
+ * FUNCTION PURPOSE: Internal Callback that gets registered with NWAL for packet reception
+ **********************************************************************
+ * DESCRIPTION: Callback that gets registered with NWAL for packet reception
+ * appCookie is the pktio handle
+ **********************************************************************/
+void netapip_pktioNWALRxPktCallback(uint32_t appCookie,
+ uint16_t numPkts,
+ nwalRxPktInfo_t* pPktInfo,
+ uint64_t timestamp,
+ nwal_Bool_t* pFreePkt)
{
-PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
-int r=0;
-int n;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
-
-#ifdef PKTIO_GET_BENCHMARK
- vv15p=netapi_timing_stop();
-#endif
+ PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
+ int r=0;
+ int n;
+ Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+ PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+
for(r=0;r<numPkts;r++)
{
- pkt_list[r] = pPktInfo[r].pPkt;
- meta_s[r].flags1 = PKTIO_META_RX;
- meta_s[r].u.rx_meta = &pPktInfo[r];
+ pkt_list[r] = pPktInfo[r].pPkt;
+ meta_s[r].flags1 = PKTIO_META_RX;
+ meta_s[r].u.rx_meta = &pPktInfo[r];
+ }
+ if (r)
+ {
+ p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
}
- if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
-
}
-/***** this is the callback we registered with NWAL for crypto callbcak *****/
-/* appcookie -> pktio handle */
-void netapi_NWALSBPktCallback (uint32_t appCookie,
- uint16_t numPkts,
- nwalDmRxPayloadInfo_t* pDmRxPktInfo,
- nwal_Bool_t* pFreePkt)
+
+/**********************************************************************
+ * FUNCTION PURPOSE: Internal Callback that gets registered with NWAL for crypto reception
+ **********************************************************************
+ * DESCRIPTION: Callback that gets registered with NWAL for crypto reception,
+ * appCookie is the pktio handle
+ **********************************************************************/
+void netapip_pktioNWALSBPktCallback(uint32_t appCookie,
+ uint16_t numPkts,
+ nwalDmRxPayloadInfo_t* pDmRxPktInfo,
+ nwal_Bool_t* pFreePkt)
{
-PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
-int r=0;
-int n;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+ PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
+ int r=0;
+ int n;
+ Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+ PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
for(r=0;r<numPkts;r++)
{
- pkt_list[r] = pDmRxPktInfo[r].pPkt;
- meta_s[r].flags1 = PKTIO_META_SB_RX;
- meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
+ pkt_list[r] = pDmRxPktInfo[r].pPkt;
+ meta_s[r].flags1 = PKTIO_META_SB_RX;
+ meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
+ }
+ if (r)
+ {
+ p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
}
- if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
-
}
-
-