index 5cfd2dc7fa08eff6b210fb67bc1e62f017ab5d66..a99adab3a1720e5ac13accd2ae704007610b121c 100755 (executable)
/*This defines the maximum number of packets to receive in one pktio poll */
#define PKTIO_MAX_RECV (TUNE_NETAPI_MAX_BURST_RCV)
-static hplib_spinLock_T pktio_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
+static hplib_spinLock_T netapi_pktio_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
/* Utilites*/
-static PKTIO_HANDLE_T * pktiop_get_free_channel_slot(NETAPI_T n)
+static PKTIO_HANDLE_T * netapip_pktioGetFreeChannelSlot(NETAPI_T n)
{
PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
int i;
- hplib_mSpinLockLock(&pktio_lock);
+ hplib_mSpinLockLock(&netapi_pktio_lock);
for(i=0;i<NETAPI_MAX_PKTIO;i++)
{
if (pp[i]->inuse != PKTIO_INUSE)
{
pp[i]->inuse = PKTIO_INUSE;
- hplib_mSpinLockUnlock(&pktio_lock);
+ hplib_mSpinLockUnlock(&netapi_pktio_lock);
return pp[i];
}
}
- hplib_mSpinLockUnlock(&pktio_lock);
+ hplib_mSpinLockUnlock(&netapi_pktio_lock);
return NULL;
}
* with updates for L4 checksum,ESP Crypto and outgoing EMAC port
* to NetCP command.
********************************************************************/
-static int netapi_pktioSendL4CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendL4CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
- netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1);
-
if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
{
nwal_mCmdSetL4CkSumCrypPort(pkt,
swInfo1,
0);
- netapi_Log("netapi_pktioSendL4CkSumCryptPort: swinfo0 0x%x, swinfo1: 0x%x\n",swInfo0,swInfo1);
pPloadDesc = Pktlib_getDescFromPacket(pkt);
pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
pPloadDesc,
NWAL_DESC_SIZE);
}
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
return 1;
}
* with updates for ESP Crypto and outgoing EMAC port
* to NetCP command.
********************************************************************/
-static int netapi_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
- netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1);
-
if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
{
nwal_mCmdSetCrypPort(pkt,
swInfo0,
swInfo1,
0);
- netapi_Log("netapi_pktioSendCryptPort: swinfo0 0x%x, swinfo1: 0x%x\n",swInfo0,swInfo1);
+
pPloadDesc = Pktlib_getDescFromPacket(pkt);
pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
pPloadDesc,
NWAL_DESC_SIZE);
}
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
return 1;
}
* with updates for L4 checksum,AH Crypto and outgoing EMAC port
* to NetCP command.
********************************************************************/
-static int netapi_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
pTxPktInfo->saAhMacSize,
pTxPktInfo->enetPort);
- netapi_Log("netapi_pktioSendL4CkSumAHCryptPort: swinfo0 0x%x, swinfo1: 0x%x\n",swInfo0,swInfo1);
pPloadDesc = Pktlib_getDescFromPacket(pkt);
pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
pPloadDesc,
NWAL_DESC_SIZE);
}
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+
return 1;
}
* with updates for AH Crypto and outgoing EMAC port
* to NetCP command.
********************************************************************/
-static int netapi_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
pPloadDesc,
NWAL_DESC_SIZE);
}
+ else
+ {
+ *err= NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
return 1;
}
* with updates for L4 checksum and outgoing EMAC port
* to NetCP command.
********************************************************************/
-static int netapi_pktioSendL4CkSumPort(struct PKTIO_HANDLE_tag * pp,
+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;
- netapi_Log("netapi_pktioSendL4CkSumPort: non-ipsec packet sent with L4 chksum\n");
- netapi_Log("netapi_pktioSendL4CkSumPort: l4offbytes: %d, l4HdrLen: %d, enetPort %d\n",
- pTxPktInfo->l4OffBytes,
- pTxPktInfo->l4HdrLen,
- pTxPktInfo->enetPort);
nwal_mCmdSetL4CkSumPort(pkt,
&p->tx_psCmdInfo,
pTxPktInfo->l4OffBytes,
* DESCRIPTION: Send packet via low level NWAL API's
* with updates for outgoing EMAC port to NetCP command.
********************************************************************/
-static int netapi_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
********************************************************************
* DESCRIPTION: Send packet via IPC queue
********************************************************************/
-static int netapi_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
********************************************************************
* DESCRIPTION: Send packet to NETCP via NWAL
********************************************************************/
-static int netapi_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
if (res != nwal_OK)
{
*err = NETAPI_ERR_NWAL_TX_ERR -res;
+ return -1;
}
return 1;
}
* DESCRIPTION: Send packet to NETCP via NWAL for side band data mode
* channel via NWAL
********************************************************************/
-static int netapi_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
{
dmPSCmdInfo->rxSbSaQ = rxQ;
}
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
nwal_mCmdDMUpdate(pkt,
dmPSCmdInfo,
pPktInfoSB->appCtxId,
pPloadDesc,
NWAL_DESC_SIZE);
}
+ else
+ {
+ *err=NETAPI_ERR_BAD_INPUT;
+ return -1;
+ }
+ return 1;
}
+/********************************************************************
+ * 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;
+ *err=0;
+ tag.srcTagLo = m->u.tx_ifdma_dest;
+ Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
+ pPloadDesc = Pktlib_getDescFromPacket(pkt);
+ pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
+ Qmss_queuePushDescSizeRaw(p->q,
+ pPloadDesc,
+ NWAL_DESC_SIZE);
+ return 1;
+}
+
+
+
/********************************************************************
* FUNCTION PURPOSE: Stub function for send, do nothing.
********************************************************************
* DESCRIPTION: Stub function for send, do nothing.
********************************************************************/
-static int netapi_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
+static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
Ti_Pkt *pkt,
PKTIO_METADATA_T *m,
int * err)
********************************************************************
* DESCRIPTION: Stub function for send, do nothing.
********************************************************************/
-static int netapi_pktioPollDummy(struct PKTIO_HANDLE_tag * p,
+static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
********************************************************************
* DESCRIPTION: Poll IPC queue
********************************************************************/
-static int netapi_pktioPollIpc(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
********************************************************************
* DESCRIPTION: Poll nwal data queues for pkts from netcp
********************************************************************/
-static int netapi_pktioPollNwal(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
********************************************************************
* DESCRIPTION: Poll nwal sideband queues for pkts from SA
********************************************************************/
-static int netapi_pktioPollSb(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
********************************************************************
* DESCRIPTION: Poll application provided NETCP RX queue
********************************************************************/
-static int netapi_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
* DESCRIPTION: Poll application defined sideband queues for packets
* from SA
*************************************************************************/
-static int netapi_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp,
+static int netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp,
PKTIO_POLL_T * p_poll_cfg,
int * err)
{
uint8_t isAllocated;
*err=0;
+ int q= QMSS_PARAM_NOT_SPECIFIED;
+ int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
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=pktiop_get_free_channel_slot(n);
+ 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=netapi_pktioPollDummy;
- p->_send=netapi_pktioSendDummy;
+ p->_poll=netapip_pktioPollDummy;
+ p->_send=netapip_pktioSendDummy;
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);
+
+ /* special case for infrastructure dma channels */
+ if (p_cfg->flags2 & PKTIO_IFDMA)
+ {
+ if (p_cfg->qnum!=PKTIO_Q_ANY)
+ {
+ q= p_cfg->qnum;
+ }
+ qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
+ }
+
+
+ /* create a general queue */
+ p->q = Qmss_queueOpen(qtype,
+ q,
+ &isAllocated);
if (p->q == (Qmss_QueueHnd) NULL)
{
netapi_Log("netapi_pktioCreate: queueOpen failed\n");
p->qInfo = Qmss_getQueueNumber(p->q);
if (p_cfg->flags2 & PKTIO_PKT)
{
- p->use_nwal = PKTIO_4_ADJ_NWAL;
- p->_poll=netapi_pktioPollNwalAdj;
- p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(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=netapi_pktioPollSbAdj;
- p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(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_TX) p->_send=netapi_pktioSendIpc;
- if (p_cfg->flags1& PKTIO_RX) p->_poll=netapi_pktioPollIpc;
+ 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) )
+ 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(&pktio_lock);
- r=netapi_add_global_pktio(n, name, &p->qInfo);
- hplib_mSpinLockUnlock(&pktio_lock);
+ hplib_mSpinLockLock(&netapi_pktio_lock);
+ r=netapip_addGlobalPktio(n, name, &p->qInfo);
+ hplib_mSpinLockUnlock(&netapi_pktio_lock);
}
((NETAPI_HANDLE_T *)n )->n_pktios+=1;
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 */
- p=pktiop_get_free_channel_slot(n);
+ p=netapip_pktioGetFreeChannelSlot(n);
if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
((NETAPI_HANDLE_T *)n)->n_pktios+=1;
p->back = n;
p->cb = cb;
p->max_n = p_cfg->max_n;
- p->_poll=netapi_pktioPollDummy;
- p->_send=netapi_pktioSendDummy;
+ 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 */
p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
if (!strcmp(name,NETCP_RX))
{
- p->_poll=netapi_pktioPollNwal;
+ 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=netapi_pktioSendNwal;
+ p->_send=netapip_pktioSendNwal;
}
}
else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
p->use_nwal = PKTIO_DEF_SB;
p->q = 0;
p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
- if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapi_pktioPollSb;
- if (!strcmp(name,NETCP_SB_TX)) p->_send=netapi_pktioSendSb;
+ if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
+ if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
}
else
{
- hplib_mSpinLockLock(&pktio_lock);
- /* find queue in global list */
- p_qnum = netapi_find_global_pktio(n, name);
+ hplib_mSpinLockLock(&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;
+ }
+
+ hplib_mSpinLockUnlock(&netapi_pktio_lock);
+ p_qnum = netapip_findGlobalPktio(n, name);
- hplib_mSpinLockUnlock(&pktio_lock);
if (!p_qnum )
{
netapi_Log("netapi_pktioOpen: can't find %s\n",name);
return NULL;
}
- /* open a general queue (for now). use qnum that was just found */
- p->q = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
+ /* 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)
{
if (p_cfg->flags2 & PKTIO_PKT)
{
p->use_nwal = PKTIO_4_ADJ_NWAL; //additonal RX q for nwal
- p->_poll = netapi_pktioPollNwalAdj;
+ 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 = netapi_pktioPollSbAdj;
+ p->_poll = netapip_pktioPollSbAdj;
p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
- }
- else
+ }
+ 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=netapi_pktioSendIpc;
- if (p_cfg->flags1& PKTIO_RX) p->_poll=netapi_pktioPollIpc;
+ if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
+ if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
}
}
switch (p_cfg->fast_path_cfg.fp_send_option)
{
case (PKTIO_FP_ESP_L4CKSUM_PORT):
- p->_send = netapi_pktioSendL4CkSumCryptPort;
+ p->_send = netapip_pktioSendL4CkSumCryptPort;
break;
case (PKTIO_FP_AH_L4CKSUM_PORT):
- p->_send = netapi_pktioSendL4CkSumAHCryptPort;
+ p->_send = netapip_pktioSendL4CkSumAHCryptPort;
break;
case (PKTIO_FP_ESP_PORT):
- p->_send = netapi_pktioSendCryptPort;
+ p->_send = netapip_pktioSendCryptPort;
break;
case (PKTIO_FP_AH_PORT):
- p->_send = netapi_pktioSendAHCryptPort;
+ p->_send = netapip_pktioSendAHCryptPort;
break;
case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
- p->_send = netapi_pktioSendPort;
+ p->_send = netapip_pktioSendPort;
break;
case (PKTIO_FP_L4CKSUM_PORT):
- p->_send = netapi_pktioSendL4CkSumPort;
+ p->_send = netapip_pktioSendL4CkSumPort;
break;
default:
break;
void netapi_pktioClose(PKTIO_HANDLE_T * p,
int * err)
{
- if(!p) { *err=1; return;}
+ if(!p)
+ {
+ *err=1;
+ return;
+ }
*err=0;
- if (p->q) Qmss_queueClose(p->q); //LLD keeps reference count
+ if (p->q)
+ {
+ Qmss_queueClose(p->q);
+ }
p->q=-1;
p->inuse=0;
((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
void netapi_pktioDelete(PKTIO_HANDLE_T * p,
int * err)
{
- if(!p) { *err=1; return;}
+ if(!p)
+ {
+ *err=1;
+ return;
+ }
*err=0;
+ if (p->cfg.flags2 & PKTIO_IFDMA)
+ {
+ netapip_pktioDeleteIFDMA(p);
+ }
+
/* remove from name list */
- hplib_mSpinLockLock(&pktio_lock);
+ hplib_mSpinLockLock(&netapi_pktio_lock);
netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
- hplib_mSpinLockUnlock(&pktio_lock);
+ hplib_mSpinLockUnlock(&netapi_pktio_lock);
if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB))
{
netapip_zapQ(p->q); //since we are deleting, zap the queue
}
+/********************************************************************
+ * 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)
+{
+ Cppi_channelDisable (p->txChHnd);
+ Cppi_channelDisable (p->rxChHnd);
+ Cppi_channelClose(p->txChHnd);
+ Cppi_channelClose(p->rxChHnd);
+ Cppi_close(p->cppiHnd);
+ return 1;
+}
+
+/********************************************************************
+ * 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 dmaChan = p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
+ unsigned char isAllocated;
+ Cppi_TxChInitCfg txChCfg;
+ Cppi_RxChInitCfg rxChCfg;
+ Cppi_CpDmaInitCfg cpdmaCfg;
+
+ /* Set up QMSS CPDMA configuration */
+ memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
+ cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
+
+ /* Open QMSS CPDMA */
+ p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
+ if (p->cppiHnd == NULL)
+ {
+ return -1;
+ }
+
+ /* 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;
+
+ /* 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;
+}
/**********************************************************************
- * FUNCTION PURPOSE: Callback that gets registered with NWAL for packet reception
+ * 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 netapi_NWALRxPktCallback(uint32_t appCookie,
+void netapip_pktioNWALRxPktCallback(uint32_t appCookie,
uint16_t numPkts,
nwalRxPktInfo_t* pPktInfo,
uint64_t timestamp,
/**********************************************************************
- * FUNCTION PURPOSE: Callback that gets registered with NWAL for crypto reception
+ * 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 netapi_NWALSBPktCallback(uint32_t appCookie,
+void netapip_pktioNWALSBPktCallback(uint32_t appCookie,
uint16_t numPkts,
nwalDmRxPayloadInfo_t* pDmRxPktInfo,
nwal_Bool_t* pFreePkt)