08a55d107808b580de1b310c6d9fef7c8a9df041
[keystone-rtos/netapi.git] / ti / runtime / netapi / src / pktio.c
1 /*********************************
2  * FILE: pktio.c
3  * PURPOSE: pktio library for NETAPI
4  **************************************************************
5  * FILE:  pktio.c
6  * 
7  * DESCRIPTION:  pktio source file for user space transport
8  *               library
9  * 
10  * REVISION HISTORY:  rev 0.0.1 
11  *
12  *  Copyright (c) Texas Instruments Incorporated 2010-2011
13  * 
14  *  Redistribution and use in source and binary forms, with or without 
15  *  modification, are permitted provided that the following conditions 
16  *  are met:
17  *
18  *    Redistributions of source code must retain the above copyright 
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  *    Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the   
24  *    distribution.
25  *
26  *    Neither the name of Texas Instruments Incorporated nor the names of
27  *    its contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  ********************************/
44 #include <unistd.h>
45 #include "netapi.h"
46 #include "pktio.h"
47 #include <ti/csl/csl_qm_queue.h>
51 /*This defines the maximum number of packets to receive in one pktio poll */
52 #define PKTIO_MAX_RECV  (TUNE_NETAPI_MAX_BURST_RCV)
54 extern NETAPI_SHM_T* pnetapiShm;
57 /* Utilites*/
58 static PKTIO_HANDLE_T * netapip_pktioGetFreeChannelSlot(NETAPI_T n)
59 {
60     NETAPI_HANDLE_T *p_handle;
61     PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
62     int i;
63     p_handle = (NETAPI_HANDLE_T*) n;
64     p_handle->spinLock.lock(&pnetapiShm->netapi_pktio_lock);
65     for(i=0;i<NETAPI_MAX_PKTIO;i++)
66     {
67         if (pp[i]->inuse != PKTIO_INUSE)
68         {
69             pp[i]->inuse = PKTIO_INUSE;
70             p_handle->spinLock.unlock(&pnetapiShm->netapi_pktio_lock);
71             return  pp[i];
72         }
73     }
74     p_handle->spinLock.unlock(&pnetapiShm->netapi_pktio_lock);
75     return NULL;
76 }
79 /*Optimized send functions */
82 /********************************************************************
83  * FUNCTION PURPOSE: Send packet via low level NWAL API's
84  * with updates for L4 checksum,ESP Crypto and outgoing EMAC port 
85  * to NetCP command.
86  ********************************************************************
87  * DESCRIPTION: Send packet via low level NWAL API's
88  * with updates for L4 checksum,ESP Crypto and outgoing EMAC port 
89  * to NetCP command.
90  ********************************************************************/
91 static int netapip_pktioSendL4CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
92                                             Ti_Pkt *pkt,
93                                             PKTIO_METADATA_T *m,
94                                             int * err)
95 {
96     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
97     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
98     Cppi_HostDesc*          pPloadDesc;
99     uint32_t swInfo0, swInfo1;
101     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
102     //printf("netapip_pktioSendL4CkSumCryptPort\n");
103     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
104     {
105         nwal_mCmdSetL4CkSumCrypPort(pkt,
106                                     &p->tx_psCmdInfo,
107                                     pTxPktInfo->l4OffBytes, 
108                                     pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
109                                     pTxPktInfo->pseudoHdrChecksum, 
110                                     pTxPktInfo->saOffBytes, 
111                                     pTxPktInfo->saPayloadLen, 
112                                     swInfo0, 
113                                     swInfo1,
114                                     pTxPktInfo->enetPort);
116         pPloadDesc = Pktlib_getDescFromPacket(pkt);
117         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
118         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
119                                   pPloadDesc,
120                                   NWAL_DESC_SIZE);
121     }
122     else
123     {
124           *err=NETAPI_ERR_BAD_INPUT;
125           return -1;
126     }
128     return 1;
131 /********************************************************************
132  * FUNCTION PURPOSE: Send packet via low level NWAL API's
133  * with updates for ESP Crypto and outgoing EMAC port 
134  * to NetCP command.
135  ********************************************************************
136  * DESCRIPTION: Send packet via low level NWAL API's
137  * with updates for ESP Crypto and outgoing EMAC port 
138  * to NetCP command.
139  ********************************************************************/
140 static int netapip_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
141                                      Ti_Pkt *pkt,
142                                      PKTIO_METADATA_T *m,
143                                      int * err)
145     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
146     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
147     Cppi_HostDesc*          pPloadDesc;
148     uint32_t swInfo0, swInfo1;
150     printf("netapip_pktioSendCryptPort\n");
152     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
154     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
155     {
156         nwal_mCmdSetCrypPort(pkt,
157                              &p->tx_psCmdInfo,
158                               pTxPktInfo->saOffBytes,
159                               pTxPktInfo->saPayloadLen,
160                               swInfo0,
161                               swInfo1,
162                               pTxPktInfo->enetPort);
164         pPloadDesc = Pktlib_getDescFromPacket(pkt);
165         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
166         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
167                                   pPloadDesc,
168                                   NWAL_DESC_SIZE);
169     }
170     else
171     {
172           *err=NETAPI_ERR_BAD_INPUT;
173           return -1;
174     }
176     return 1;
180 /********************************************************************
181  * FUNCTION PURPOSE: Send packet via low level NWAL API's
182  * with updates for L3 checksum, ESP Crypto and outgoing EMAC port
183  * to NetCP command.
184  ********************************************************************
185  * DESCRIPTION: Send packet via low level NWAL API's
186  * with updates for L3 checksum, ESP Crypto and outgoing EMAC port
187  * to NetCP command.
188  ********************************************************************/
189 static int netapip_pktioSendL3CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
190                                      Ti_Pkt *pkt,
191                                      PKTIO_METADATA_T *m,
192                                      int * err)
194     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
195     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
196     Cppi_HostDesc*          pPloadDesc;
197     uint32_t swInfo0, swInfo1;
199     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
201     printf("netapip_pktioSendL3CkSumCryptPort\n");
203     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
204     {
205         nwal_mCmdSetL3CkSumCrypPort(pkt,
206                                     &p->tx_psCmdInfo,
207                                     pTxPktInfo->saOffBytes,
208                                     pTxPktInfo->saPayloadLen,
209                                     swInfo0,
210                                     swInfo1,
211                                     pTxPktInfo->enetPort);
213         pPloadDesc = Pktlib_getDescFromPacket(pkt);
214         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
216         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
217                                   pPloadDesc,
218                                   NWAL_DESC_SIZE);
219     }
220     else
221     {
222           *err=NETAPI_ERR_BAD_INPUT;
223           return -1;
224     }
226     return 1;
234 /********************************************************************
235  * FUNCTION PURPOSE: Send packet via low level NWAL API's
236  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
237  * to NetCP command.
238  *******************************************************************
239  * DESCRIPTION: Send packet via low level NWAL API's
240  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
241  * to NetCP command.
242  ********************************************************************/
243 static int netapip_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
244                                               Ti_Pkt *pkt,
245                                               PKTIO_METADATA_T *m,
246                                               int * err)
248     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
249     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
250     Cppi_HostDesc*          pPloadDesc;
251     uint32_t swInfo0, swInfo1;
253     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
254     printf("netapip_pktioSendL4CkSumAHCryptPort\n");
256     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
257     {
258         nwal_mCmdSetL4CkSumAHCrypPort(pkt,
259                                 &p->tx_psCmdInfo,
260                                 pTxPktInfo->l4OffBytes, 
261                                 pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
262                                 pTxPktInfo->pseudoHdrChecksum, 
263                                 pTxPktInfo->saOffBytes, 
264                                 pTxPktInfo->saPayloadLen, 
265                                 swInfo0, 
266                                 swInfo1,
267                                 pTxPktInfo->saAhIcvOffBytes,
268                                 pTxPktInfo->saAhMacSize,
269                                 pTxPktInfo->enetPort);
271         pPloadDesc = Pktlib_getDescFromPacket(pkt);
272         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
274         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
275                                   pPloadDesc,
276                                   NWAL_DESC_SIZE);
277     }
278     else
279     {
280           *err=NETAPI_ERR_BAD_INPUT;
281           return -1;
282     }
284     return 1;
287 /********************************************************************
288  * FUNCTION PURPOSE: Send packet via low level NWAL API's
289  * with updates for AH Crypto and outgoing EMAC port 
290  * to NetCP command.
291  ********************************************************************
292  * DESCRIPTION: Send packet via low level NWAL API's
293  * with updates for AH Crypto and outgoing EMAC port 
294  * to NetCP command.
295  ********************************************************************/
296 static int netapip_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
297                                        Ti_Pkt *pkt,
298                                        PKTIO_METADATA_T *m,
299                                        int * err)
301     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
302     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
303     Cppi_HostDesc*          pPloadDesc;
304     uint32_t swInfo0, swInfo1;
306     printf("netapip_pktioSendAHCryptPort\n");
308     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
310     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
311     {
312         nwal_mCmdSetAHCrypPort(pkt,
313                                &p->tx_psCmdInfo,
314                                pTxPktInfo->saOffBytes, 
315                                pTxPktInfo->saPayloadLen, 
316                                swInfo0, 
317                                swInfo1,
318                                pTxPktInfo->saAhIcvOffBytes,
319                                pTxPktInfo->saAhMacSize,
320                                pTxPktInfo->enetPort);
321         
322         pPloadDesc = Pktlib_getDescFromPacket(pkt);
323         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
325         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
326                                   pPloadDesc,
327                                   NWAL_DESC_SIZE);
328     }
329     else
330     {
331        *err= NETAPI_ERR_BAD_INPUT;
332        return -1;
333     }
334     return 1;
339 /********************************************************************
340  * FUNCTION PURPOSE: Send packet via low level NWAL API's
341  * with updates for L4 checksum and outgoing EMAC port 
342  * to NetCP command.
343  *******************************************************************
344  * DESCRIPTION: Send packet via low level NWAL API's
345  * with updates for L4 checksum and outgoing EMAC port 
346  * to NetCP command.
347  ********************************************************************/
348 static int netapip_pktioSendL4CkSumPort(struct PKTIO_HANDLE_tag * pp,
349                                       Ti_Pkt *pkt,
350                                       PKTIO_METADATA_T *m,
351                                       int * err)
354     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
355     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
356     Cppi_HostDesc*          pPloadDesc;
358     nwal_mCmdSetL4CkSumPort(pkt,
359                             &p->tx_psCmdInfo,
360                             pTxPktInfo->l4OffBytes,
361                             pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
362                             pTxPktInfo->pseudoHdrChecksum,
363                             pTxPktInfo->enetPort);
365     pPloadDesc = Pktlib_getDescFromPacket(pkt);
366     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
367     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
368                                   pPloadDesc,
369                                   NWAL_DESC_SIZE);
370     return 1;
374 /********************************************************************
375  * FUNCTION PURPOSE: Send packet via low level NWAL API's
376  * with updates for outgoing EMAC port to NetCP command.
377  ********************************************************************
378  * DESCRIPTION: Send packet via low level NWAL API's
379  * with updates for outgoing EMAC port to NetCP command.
380  ********************************************************************/
381 static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
382                                 Ti_Pkt *pkt, 
383                                 PKTIO_METADATA_T *m, 
384                                 int * err)
386     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
387     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
388     Cppi_HostDesc*          pPloadDesc;
389     
390     printf("netapip_pktioSendPort\n");
393     nwal_mCmdSetPort(pkt,
394                      &p->tx_psCmdInfo,
395                      pTxPktInfo->enetPort);
396     pPloadDesc = Pktlib_getDescFromPacket(pkt);
397     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
399     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
400                                   pPloadDesc,
401                                   NWAL_DESC_SIZE);
402     return 1;
405 /********************************************************************
406  * FUNCTION PURPOSE: Send packet via IPC queue
407  ********************************************************************
408  * DESCRIPTION: Send packet via IPC queue
409  ********************************************************************/
410 static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
411                                Ti_Pkt *pkt,
412                                PKTIO_METADATA_T *m,
413                                int * err)
415     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
416     err=0;
417     Qmss_queuePushDesc (p->q, (void*)pkt);
418     return 1;
420 /********************************************************************
421  * FUNCTION PURPOSE: Send packet to NETCP via NWAL
422  ********************************************************************
423  * DESCRIPTION: Send packet to NETCP via NWAL
424  ********************************************************************/
425 static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
426                                 Ti_Pkt *pkt,
427                                 PKTIO_METADATA_T *m,
428                                 int * err)
430     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
431     nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
432     nwal_RetValue res;
433     *err=0;
434     pPktInfo->pPkt = pkt;
435     res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
436     if (res != nwal_OK)
437     {
438         *err = NETAPI_ERR_NWAL_TX_ERR -res;
439         return -1;
440     }
441     return 1;
447 /********************************************************************
448  * FUNCTION PURPOSE: Send packet to SA via NWAL
449  ********************************************************************
450  * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode 
451  * channel via NWAL
452  ********************************************************************/
453 static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
454                               Ti_Pkt *pkt, 
455                               PKTIO_METADATA_T *m, 
456                               int * err)
459     nwal_RetValue nwalRetVal;
460     nwalTxDmPSCmdInfo_t     *dmPSCmdInfo;
461     nwalLocCxtInfo_t    nwalLocCxt;
462     Cppi_HostDesc*          pPloadDesc;
463     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
464     nwalLocCxtInfo_t      info;
465     void* virtAddr = NULL;
466     nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
468     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
470     dmPSCmdInfo = netapip_netcpCfgGetSaSBInfo(&netapi_get_global()->nwal_context, tunnel_id);
471     if (dmPSCmdInfo)
472     {
473         nwalRetVal = nwal_getLocCxtInfo(pktio_mGetNwalInstance(p),&info);
474         if(nwalRetVal == nwal_OK)
475         {
476             dmPSCmdInfo->rxSbSaQ = info.rxSbSaQ;
477         }
478         else
479         {
480             *err=NETAPI_ERR_BAD_INPUT;
481             return -1;
482         }
483         nwal_mCmdDMUpdate(pkt,
484             dmPSCmdInfo,
485             pPktInfoSB->appCtxId,
486             pPktInfoSB->encOffset,
487             pPktInfoSB->encSize,
488             pPktInfoSB->pEncIV,
489             pPktInfoSB->authOffset,
490             pPktInfoSB->authSize,
491             pPktInfoSB->pAuthIV,
492             pPktInfoSB->aadSize,
493             pPktInfoSB->pAad);
494         pPloadDesc = Pktlib_getDescFromPacket(pkt);
496 #if 0
497         printf("netapip_pktioSendSb: dumping descriptor begin\n");
498         PKTIO_dump_buf_32bit(pPloadDesc, 128);
499         printf("netapip_pktioSendSb: dumping descriptor end\n");
500         
501                 virtAddr= hplib_mVMPhyToVirt(pPloadDesc->softwareInfo1);
503                 printf("phy Addr: 0x%x\n", pPloadDesc->softwareInfo1);
504                 printf("virtAddr: 0x%x\n", virtAddr);
506                 printf("netapip_pktioSendSb: dumping security context begin\n");
507                 PKTIO_dump_buf((uint8_t*)virtAddr, 128);
508                 PKTIO_dump_buf((uint8_t*)virtAddr+128, 128);
509                 printf("netapip_pktioSendSb: dumping security context end\n");
510 #endif
513         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
515         Qmss_queuePushDescSizeRaw(dmPSCmdInfo->txQueue,
516                                              pPloadDesc,
517                                              NWAL_DESC_SIZE); 
518     }
519     else
520     {
521           *err=NETAPI_ERR_BAD_INPUT;
522           return -1;
523     }
525     return 1;
528 /********************************************************************
529  * FUNCTION PURPOSE: Send packet via infrastructure DMA channel
530  ********************************************************************
531  * DESCRIPTION: Send packet via infrastructure DMA channel
532  ********************************************************************/
533 static int netapip_pktioSendIfdma(struct PKTIO_HANDLE_tag * pp,
534                                  Ti_Pkt *pkt, 
535                                  PKTIO_METADATA_T *m, 
536                                  int * err)
538         Cppi_DescTag            tag={0};
539         Cppi_HostDesc*          pPloadDesc;
540         PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
541         *err=0;
542         tag.srcTagLo = m->u.tx_ifdma_dest;
543         Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
544         pPloadDesc = Pktlib_getDescFromPacket(pkt);
545         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
547         Qmss_queuePushDescSizeRaw(p->q,
548                                   pPloadDesc,
549                                   NWAL_DESC_SIZE);
550         return 1;
555 /********************************************************************
556  * FUNCTION PURPOSE: Stub function for send, do nothing.
557  ********************************************************************
558  * DESCRIPTION: Stub function for send, do nothing.
559  ********************************************************************/
560 static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
561                                  Ti_Pkt *pkt, 
562                                  PKTIO_METADATA_T *m, 
563                                  int * err)
565     *err =  NETAPI_ERR_BAD_INPUT;
566     return -1;
569 /********************************************************************
570  * FUNCTION PURPOSE: Stub function for poll, do nothing.
571  ********************************************************************
572  * DESCRIPTION: Stub function for send, do nothing.
573  ********************************************************************/
574 static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p, 
575                                  PKTIO_POLL_T * p_poll_cfg,
576                                  int * err)
578     *err= NETAPI_ERR_BAD_INPUT;
579     return 0;
582 /********************************************************************
583  * FUNCTION PURPOSE: Poll IPC queue
584  ********************************************************************
585  * DESCRIPTION: Poll IPC queue
586  ********************************************************************/
587 static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp, 
588                                PKTIO_POLL_T * p_poll_cfg,  
589                                int * err)
591     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
592     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
593     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
594     int r=0;
595     int n;
596     Ti_Pkt * temp;
597     *err=0;
598     n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
599     for(r=0;r<n;r++)
600     {
602         temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
604         if(!temp) break;
605         /* process meta data */
606         pkt_list[r]= temp;
607         meta_s[r].flags1=0x1;
608     }
609     if (r)
610     {
611         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
612     }
613     return r;
616 /********************************************************************
617  * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
618  ********************************************************************
619  * DESCRIPTION: Poll nwal data queues for pkts from netcp
620  ********************************************************************/
621 static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp, 
622                                 PKTIO_POLL_T * p_poll_cfg,  
623                                 int * err)
625     int r=0;
626     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
627     *err=0;
628     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
629         set.  optimizaion maybe? */
630     r=nwal_pollPkt(p->nwalInstanceHandle,
631                    p->poll_flags,
632                    (uint32_t) p,
633                    p->max_n,
634                    QMSS_PARAM_NOT_SPECIFIED,
635                    (void*) NULL);
636     return r;
638 /********************************************************************
639  * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
640  ********************************************************************
641  * DESCRIPTION: Poll nwal sideband queues for pkts from SA
642  ********************************************************************/
643 static int  netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp, 
644                                PKTIO_POLL_T * p_poll_cfg,  
645                                int * err)
647     int r=0;
648     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
649     *err=0;
650     r=nwal_pollDm(p->nwalInstanceHandle,
651                     nwal_POLL_DM_DEF_SB_SA_Q,
652                      (uint32_t) p,
653                      p->max_n,
654                      QMSS_PARAM_NOT_SPECIFIED,
655              (void *) NULL);
656     return r;
659 /********************************************************************
660  * FUNCTION PURPOSE: Poll application provided NETCP RX queue
661  ********************************************************************
662  * DESCRIPTION: Poll application provided NETCP RX queue
663  ********************************************************************/
664 static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp, 
665                                    PKTIO_POLL_T * p_poll_cfg,  
666                                    int * err)
668     int r=0;
669     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
670     *err=0;
671     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
672          set. optimizaion maybe? */
673     r=nwal_pollPkt(p->nwalInstanceHandle,
674                    nwal_POLL_APP_MANAGED_PKT_Q,
675                    (uint32_t) p,
676                    p->max_n,
677                    p->q,
678                    (void *) NULL);
680     return r;
683 /*************************************************************************
684  * FUNCTION PURPOSE: Poll application defined sideband queues for packets
685  *                   from SA
686  ************************************************************************
687  * DESCRIPTION: Poll application defined sideband queues for packets
688  *                   from SA
689  *************************************************************************/
690 static int  netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp, 
691                                   PKTIO_POLL_T * p_poll_cfg,  
692                                   int * err)
694     int r=0;
695     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
696     *err=0;
697     r=nwal_pollDm(p->nwalInstanceHandle,
698                      nwal_POLL_DM_APP_MANAGED_Q,
699                      (uint32_t) p,
700                      p->max_n,
701                      p->q,
702                      (void *)  NULL);
703     return r;
706 /*-----------------------MAIN API----------------------*/
707 /********************************************************************
708  * FUNCTION PURPOSE:  API creates a NETAPI PKTIO channel 
709  ********************************************************************
710  * DESCRIPTION:  API creates a NETAPI PKTIO channel 
711  ********************************************************************/
712 PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
713                                     char * name,
714                                     PKTIO_CB cb, 
715                                     PKTIO_CFG_T * p_cfg, 
716                                     int * err)
718     int r = 0;
719     PKTIO_HANDLE_T *p;
720     uint8_t         isAllocated;
722     *err=0;
723     int q = QMSS_PARAM_NOT_SPECIFIED;
725     int qtype = Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
727     if(p_cfg == NULL)
728     {
729         *err = NETAPI_ERR_BAD_INPUT;
730         return NULL;
731     }
732     /* over-ride only for Qmss_QueueType_GIC400_QUEUE */
733     if (p_cfg->queueType == Qmss_QueueType_GIC400_QUEUE)
734         qtype = p_cfg->queueType;
736     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
737     if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
738     if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
740     /* get a free channel handle */
741     p=netapip_pktioGetFreeChannelSlot(n);
743     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
745     p->back = n;
746     p->cb = cb;
747     p->max_n = p_cfg->max_n;
748     p->_poll=netapip_pktioPollDummy;
749     p->_send=netapip_pktioSendDummy;
750     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
752     if (p_cfg->qnum!=PKTIO_Q_ANY)
753     {
754         q= p_cfg->qnum;
755     }
756     /* special case for infrastructure dma channels */
757     if (p_cfg->flags2 & PKTIO_IFDMA)
758     {
759         qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
760     }
763     /* create a  general queue */
764      p->q  = Qmss_queueOpen(qtype,
765                                 q, 
766                                 &isAllocated);
767     if (p->q < 0)
768     {
769         netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
770         p->inuse=0;
771         *err= NETAPI_ERR_QLLD;  ///queue lld error
772         return NULL;
773     }
775     p->qInfo = Qmss_getQueueNumber(p->q);
777     if (p_cfg->flags2 & PKTIO_PKT)
778     {
779         p->use_nwal = PKTIO_4_ADJ_NWAL;
780         p->_poll=netapip_pktioPollNwalAdj;
781         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
782     }
783     else if (p_cfg->flags2 & PKTIO_SB)
784     {
785         p->use_nwal = PKTIO_4_ADJ_SB;
786         p->_poll=netapip_pktioPollSbAdj;
787         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
788     }
789    else if (p_cfg->flags2 & PKTIO_IFDMA)
790    {
791         p->use_nwal = 0;
792         p->_send = netapip_pktioSendIfdma;
793         p->cfg.flags1=PKTIO_TX;
794         r= netapip_pktioCreateIFDMA(p); //we create the IF DMA channel here
795         if (r<0) 
796         {
797             //trouble -> couldn't set up DMA 
798             //close queue and return failure
799             if (p->q)
800             {
801                 Qmss_queueClose(p->q);
802             }
803             p->inuse=0;
804             *err= NETAPI_ERR_QLLD;  ///queue lld error TODO: fix error code 
805             return NULL;
806         }
807    }
808     else
809     {
810         p->use_nwal=0;
811         if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
812         if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
813     }
815     /* save name */ 
816     strncpy(p->name,name,
817        strlen(name)<PKTIO_MAX_NAME ?
818                strlen(name):PKTIO_MAX_NAME);   
820     /* add name, qnum to global name list */
821     if ((strcmp(name,NETCP_RX)) &&
822         (strcmp(name,NETCP_TX)) &&
823         (strcmp(name,NETCP_SB_RX)) &&
824         (strcmp(name,NETCP_SB_TX)) &&
825         (p_cfg->flags1 & PKTIO_GLOBAL))
826     {
827          //todo: make sure this succeeds..
828         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
829         r=netapip_addGlobalPktio(n, name, &p->qInfo);
830         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
831     }
833   ((NETAPI_HANDLE_T *)n )->n_pktios+=1;
834    return p;
837 /********************************************************************
838  * FUNCTION PURPOSE:  API opens an existing  NETAPI PKTIO channel
839  ********************************************************************
840  * DESCRIPTION:  API opens an existing  NETAPI PKTIO channel
841  ********************************************************************/
842 PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T  n,
843                                   char *name,
844                                   PKTIO_CB cb,
845                                   PKTIO_CFG_T * p_cfg,
846                                   int * err)
848     int r=0;
849     PKTIO_HANDLE_T *p, *p2;
850     uint8_t         isAllocated;
851     *err=0;
852     Qmss_Queue *p_qnum;
853     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
856     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
858     /* get a free channel handle */
860     p=netapip_pktioGetFreeChannelSlot(n);
862     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
863     ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
865     p->inuse= PKTIO_INUSE;
866     p->back = n;
867     p->cb = cb;
868     p->max_n = p_cfg->max_n;
869     p->_poll=netapip_pktioPollDummy;
870     p->_send=netapip_pktioSendDummy;
871     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
873     /* special handling of NETCP_RX, NETCP_TX */
874     if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
875     {
876        /* these have already been opened internally, so don't search in global list */
877         p->use_nwal = PKTIO_DEF_NWAL;
878         p->q = 0;  
879         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
880         if (!strcmp(name,NETCP_RX))
881         {
882             p->_poll=netapip_pktioPollNwal; 
883             p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
884                                     nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
885         }
886         if (!strcmp(name,NETCP_TX))
887         {
888             p->_send=netapip_pktioSendNwal;
889         }
890     }
891     else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
892     {
893        /* these have already been opened internally, so don't search in global list */
894         p->use_nwal =  PKTIO_DEF_SB;
895         p->q = 0;
896         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
897         if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
898         if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
899     }
900     else
901     {
902         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
903         /* Find queue in global list 
904            Note names like "QUEUE:%d" or IFDMA:%d cause general purpose or
905            IFDMA queues of that number to be opened */
906         if (p_cfg->flags2 & PKTIO_IFDMA)
907         {
908             qtype= Qmss_QueueType_INFRASTRUCTURE_QUEUE;
909         }
911         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
912         p_qnum = netapip_findGlobalPktio(n, name);
914         if (!p_qnum ) 
915         {
916             netapi_Log("netapi_pktioOpen: can't find %s\n",name);
917             p->inuse=0;
918             *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
919             return NULL;
920       }
922      /* open a general queue (for now). use qnum that was just found */
923          p->q  = Qmss_queueOpen(qtype,
924                            p_qnum->qNum , &isAllocated);
925         if (p->q == (Qmss_QueueHnd) NULL)
926         {
927             netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
928             p->inuse=0;
929             *err= NETAPI_ERR_QLLD;  ///queue lld error
930             return NULL;
931         }
932         p->qInfo = Qmss_getQueueNumber(p->q);
933         netapi_Log("netapi_pktioOpen: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
934         if (p_cfg->flags2 & PKTIO_PKT)
935         {
936            p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
937            p->_poll = netapip_pktioPollNwalAdj;
938            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n); 
939            netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
940         } 
941         else if (p_cfg->flags2 & PKTIO_SB)
942         {
943            p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
944            p->_poll = netapip_pktioPollSbAdj;
945            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
946         }
947         else if (p_cfg->flags2 & PKTIO_IFDMA)
948         {
949             p->_send= netapip_pktioSendIfdma;
950             p->use_nwal = 0;
951         }
952         else
953         {
954            p->use_nwal=0; //not handled by nwal
955             if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
956             if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
957         }
958     }
960         /* save name */
961         strncpy(p->name,name,
962            strlen(name)<PKTIO_MAX_NAME ?
963                    strlen(name):PKTIO_MAX_NAME);
965         netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
966     return p;
969 /********************************************************************
970  * FUNCTION PURPOSE:  API controls an existing NETAPI PKTIO channel
971  ********************************************************************
972  * DESCRIPTION:  API controls an existing NETAPI PKTIO channel
973  ********************************************************************/
974 void netapi_pktioControl(PKTIO_HANDLE_T * p,
975                          PKTIO_CB cb,
976                          PKTIO_CFG_T * p_cfg,
977                          PKTIO_CONTROL_T * p_control,
978                          int *err)
980     nwal_RetValue       nwalRetVal;
981     if (!p)
982     {
983         *err= NETAPI_ERR_BAD_INPUT; 
984         return;
985     }
986     if (cb) 
987     {
988         p->cb = cb;
989     }
990     if (p_control)
991     {
992         /* todo: check for validity, eg don't allow clear of NETCP TX queues */
993         /* todo: implement divert */
994         switch(p_control->op)
995         {
996             //clear the queue
997             case(PKTIO_SET_POLL_FLAGS):
998                 p->poll_flags=p_control->poll_flags;
999                 break;
1000             case(PKTIO_CLEAR):
1001                 netapip_zapQ(p->q);
1002                 break;
1003             case (PKTIO_UPDATE_FAST_PATH):
1004                 if (p_cfg)
1005                 {
1006                     nwalRetVal = nwal_initPSCmdInfo(p->nwalInstanceHandle, 
1007                                                             p_cfg->fast_path_cfg.txPktInfo,
1008                                                             &p->tx_psCmdInfo);
1009                     if (nwalRetVal == nwal_OK)
1010                     {
1011                         switch (p_cfg->fast_path_cfg.fp_send_option)
1012                         {
1013                             case (PKTIO_FP_ESP_L4CKSUM_PORT):
1014                                 p->_send = netapip_pktioSendL4CkSumCryptPort;
1015                                 break;
1016                             case (PKTIO_FP_AH_L4CKSUM_PORT):
1017                                 p->_send = netapip_pktioSendL4CkSumAHCryptPort;
1018                                 break;
1019                             case (PKTIO_FP_ESP_PORT):
1020                                 p->_send = netapip_pktioSendCryptPort;
1021                                 break;
1022                             case (PKTIO_FP_ESP_L3CKSUM_PORT):
1023                                 p->_send = netapip_pktioSendL3CkSumCryptPort;
1024                                 break;
1025                             case (PKTIO_FP_AH_PORT):
1026                                 p->_send = netapip_pktioSendAHCryptPort;
1027                                 break;
1028                             case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
1029                                 p->_send = netapip_pktioSendPort;
1030                                 break;
1031                             case (PKTIO_FP_L4CKSUM_PORT):
1032                                 p->_send = netapip_pktioSendL4CkSumPort;
1033                                 break;
1034                             default:
1035                                 break;
1036                         }
1037                     }
1038                     else
1039                     {
1040                         *err = NETAPI_ERR_BAD_INPUT;
1041                     }
1042                 }
1043                 else
1044                 {
1045                     *err = NETAPI_ERR_BAD_INPUT;
1046                 }
1047                 break;
1048             case (PKTIO_UPDATE_MAX_PKTS_PER_POLL):
1049                 if (p_cfg)
1050                 {
1051                     p->max_n = p_cfg->max_n;
1052                 }
1053                 else
1054                 {
1055                     *err = NETAPI_ERR_BAD_INPUT;
1056                 }
1057                 break;
1058             case(PKTIO_DIVERT):
1059             default:
1060                 netapi_Log("netapi_pktioControl: pktio_control op %d not implemented\n",p_control->op);
1061                 *err= NETAPI_ERR_NOT_IMPLEMENTED;
1062                 break;
1063         }
1064     }
1066     *err = NETAPI_ERR_OK;
1067     return;
1069 /********************************************************************
1070  * FUNCTION PURPOSE:  API closes a NETAPI PKTIO channel
1071  ********************************************************************
1072  * DESCRIPTION:  API closes a NETAPI PKTIO channel
1073  ********************************************************************/
1074 void netapi_pktioClose(PKTIO_HANDLE_T * p, 
1075                        int * err)
1077     if(!p)
1078     {
1079         *err=1;
1080         return;
1081     }
1082     *err=0;
1083     if (p->q)
1084     {
1085         Qmss_queueClose(p->q);
1086     }
1087     p->q=-1;
1088     p->inuse=0;
1089     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1090     return;
1093 /********************************************************************
1094  * FUNCTION PURPOSE:  API deletes a NETAPI PKTIO channel
1095  ********************************************************************
1096  * DESCRIPTION:  API deletes a NETAPI PKTIO channel
1097  ********************************************************************/
1098 void netapi_pktioDelete(PKTIO_HANDLE_T * p, 
1099                         int * err)
1101     if(!p)
1102     {
1103         *err=1;
1104         return;
1105     }
1106     *err=0;
1107     if (p->cfg.flags2 & PKTIO_IFDMA)
1108     {
1109         netapip_pktioDeleteIFDMA(p);
1110     }
1112         /* remove from name list */
1113     hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
1114         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
1115     hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
1116         if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB)) 
1117     {
1118                 netapip_zapQ(p->q);   //since we are deleting, zap the queue 
1119             Qmss_queueClose(p->q);
1120     }
1121     p->q=-1;
1122     p->inuse=0;
1123     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1124     return ;
1127 /********************************************************************
1128  * FUNCTION PURPOSE:  API sends multiple packets to a NETAPI PKTIO channel
1129  ********************************************************************
1130  * DESCRIPTION:  API sends multiple packets to a NETAPI PKTIO channel
1131  ********************************************************************/
1132 int netapi_pktioSendMulti(PKTIO_HANDLE_T * p, 
1133                           Ti_Pkt * pkt[], 
1134                           PKTIO_METADATA_T * m[], 
1135                           int np, 
1136                           int* err)
1138     int r=0;
1139     for(r=0;r<np;r++)
1140     {
1141         p->_send((struct PKTIO_HANDLE_tag *)p, (Ti_Pkt *)pkt, (PKTIO_METADATA_T *)m, err);
1142     }
1143     return r;
1146 /********************************************************************
1147  * FUNCTION PURPOSE:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1148  * instance for received packets
1149  ********************************************************************
1150  * DESCRIPTION:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1151  * instance for received packets
1152  ********************************************************************/
1153 int netapi_pktioPollAll(NETAPI_T  handle, 
1154                         PKTIO_POLL_T * p_poll_cfg, 
1155                         int *err)
1157     int i=0;
1158     int r=0;
1159     int err2;
1160     int cnt=0;
1161     PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
1162     
1163     *err=0;
1164     for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
1165     {
1166         if (pp[i]->inuse != PKTIO_INUSE) continue;
1167         if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
1168         r+=netapi_pktioPoll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
1169         if (err2) { *err = err2; break;}
1170     }
1171     return r;
1175 /********************************************************************
1176  * FUNCTION PURPOSE:  Internal function to delete a PKTIO infrastructure DMA channel
1177  ********************************************************************
1178  * DESCRIPTION:  Internal function to delete a PKTIO infrastructure DMA channel
1179  ********************************************************************/
1180 int netapip_pktioDeleteIFDMA(PKTIO_HANDLE_T *p)
1182         Cppi_channelDisable (p->txChHnd);
1183         Cppi_channelDisable (p->rxChHnd);
1184         Cppi_channelClose(p->txChHnd);
1185         Cppi_channelClose(p->rxChHnd);
1186         Cppi_close(p->cppiHnd);
1187         return 1;
1190 /********************************************************************
1191  * FUNCTION PURPOSE:  Internal function to create a PKTIO infrastructure DMA channel
1192  ********************************************************************
1193  * DESCRIPTION:  Internal function to create a PKTIO infrastructure DMA channel
1194  *               for infrastructure DMQ queue
1195  ********************************************************************/
1196 int netapip_pktioCreateIFDMA(PKTIO_HANDLE_T * p )
1198    int dmaChan =  p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
1199    unsigned char           isAllocated;
1200    Cppi_TxChInitCfg        txChCfg;
1201    Cppi_RxChInitCfg        rxChCfg;
1202    Cppi_CpDmaInitCfg       cpdmaCfg;
1204     /* Set up QMSS CPDMA configuration */
1205     memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
1206     cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
1208     /* Open QMSS CPDMA */
1209     p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
1210     if (p->cppiHnd == NULL)
1211     {
1212         return -1;
1213     }
1215  /* Set up Tx Channel parameters */
1216     memset ((void *) &txChCfg, 0, sizeof (Cppi_TxChInitCfg));
1217     txChCfg.channelNum = dmaChan;
1218     txChCfg.priority = 0;
1219     txChCfg.filterEPIB = 0;
1220     txChCfg.filterPS = 0;
1221     txChCfg.aifMonoMode = 0;
1222     txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
1224     /* Open Tx Channel */
1225     p->txChHnd = (Cppi_ChHnd) Cppi_txChannelOpen (p->cppiHnd, &txChCfg, &isAllocated);
1226     if (p->txChHnd == NULL)
1227     {
1228         Cppi_close(p->cppiHnd);
1229         return -1;
1230     }
1232      /* Set up Rx Channel parameters */
1233     memset ((void *) &rxChCfg, 0, sizeof (Cppi_RxChInitCfg));
1234     rxChCfg.channelNum = dmaChan;
1235     rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
1237     /* Open Rx Channel */
1238     p->rxChHnd = (Cppi_ChHnd) Cppi_rxChannelOpen (p->cppiHnd, &rxChCfg, &isAllocated);
1239     if (p->rxChHnd == NULL)
1240     {
1241         Cppi_channelClose(p->txChHnd);
1242         Cppi_close(p->cppiHnd);
1243         return -1;
1244     }
1245     if (Cppi_channelEnable (p->txChHnd) != CPPI_SOK)
1246     {
1247         Cppi_channelClose(p->txChHnd);
1248         Cppi_channelClose(p->rxChHnd);
1249         Cppi_close(p->cppiHnd);
1250         return -1;
1251     }
1253     /* Enable receive channel */
1254     if (Cppi_channelEnable (p->rxChHnd) != CPPI_SOK)
1255     {
1256         Cppi_channelDisable (p->txChHnd);
1257         Cppi_channelClose(p->txChHnd);
1258         Cppi_channelClose(p->rxChHnd);
1259         Cppi_close(p->cppiHnd);
1260         return -1;
1261     }
1262     return 1;
1265 /**********************************************************************
1266  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for packet reception
1267  **********************************************************************
1268  * DESCRIPTION:  Callback that gets registered with NWAL for packet reception
1269  * appCookie is the pktio handle 
1270  **********************************************************************/
1271 void netapip_pktioNWALRxPktCallback(uint32_t            appCookie,
1272                               uint16_t             numPkts,
1273                               nwalRxPktInfo_t*    pPktInfo,
1274                               uint64_t            timestamp,
1275                               nwal_Bool_t*        pFreePkt)
1277     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1278     int r=0;
1279     int n;
1280     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1281     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1283     for(r=0;r<numPkts;r++)
1284     {
1285         pkt_list[r] = pPktInfo[r].pPkt;
1286         meta_s[r].flags1 = PKTIO_META_RX;
1287         meta_s[r].u.rx_meta = &pPktInfo[r];
1288     }
1289     if (r)
1290     {
1291         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
1292     }
1296 /**********************************************************************
1297  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for crypto reception
1298  **********************************************************************
1299  * DESCRIPTION:  Callback that gets registered with NWAL for crypto reception,
1300  * appCookie is the pktio handle 
1301  **********************************************************************/
1302 void netapip_pktioNWALSBPktCallback(uint32_t            appCookie,
1303                               uint16_t             numPkts,
1304                               nwalDmRxPayloadInfo_t*  pDmRxPktInfo,
1305                               nwal_Bool_t*        pFreePkt)
1307     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1308     int r=0;
1309     int n;
1310     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1311     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1312     for(r=0;r<numPkts;r++)
1313     {
1314         pkt_list[r] = pDmRxPktInfo[r].pPkt;
1315         meta_s[r].flags1 =  PKTIO_META_SB_RX;
1316         meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
1317     }
1318     if (r)
1319     {
1320         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
1321     }