Integration changes with latest NWAL
[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"
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         printf("netapip_pktioSendL4CkSumPort\n");
359     nwal_mCmdSetL4CkSumPort(pkt,
360                             &p->tx_psCmdInfo,
361                             pTxPktInfo->l4OffBytes,
362                             pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
363                             pTxPktInfo->pseudoHdrChecksum,
364                             pTxPktInfo->enetPort);
366     pPloadDesc = Pktlib_getDescFromPacket(pkt);
367     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
368     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
369                                   pPloadDesc,
370                                   NWAL_DESC_SIZE);
371     printf("netapip_pktioSendL4CkSumPort: txQueue: %d\n",
372         p->tx_psCmdInfo.txQueue);
376 /********************************************************************
377  * FUNCTION PURPOSE: Send packet via low level NWAL API's
378  * with updates for outgoing EMAC port to NetCP command.
379  ********************************************************************
380  * DESCRIPTION: Send packet via low level NWAL API's
381  * with updates for outgoing EMAC port to NetCP command.
382  ********************************************************************/
383 static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
384                                 Ti_Pkt *pkt, 
385                                 PKTIO_METADATA_T *m, 
386                                 int * err)
388     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
389     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
390     Cppi_HostDesc*          pPloadDesc;
391     
392     printf("netapip_pktioSendPort\n");
395     nwal_mCmdSetPort(pkt,
396                      &p->tx_psCmdInfo,
397                      pTxPktInfo->enetPort);
398     pPloadDesc = Pktlib_getDescFromPacket(pkt);
399     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
401     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
402                                   pPloadDesc,
403                                   NWAL_DESC_SIZE);
404     return 1;
407 /********************************************************************
408  * FUNCTION PURPOSE: Send packet via IPC queue
409  ********************************************************************
410  * DESCRIPTION: Send packet via IPC queue
411  ********************************************************************/
412 static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
413                                Ti_Pkt *pkt,
414                                PKTIO_METADATA_T *m,
415                                int * err)
417     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
418     err=0;
419     Qmss_queuePushDesc (p->q, (void*)pkt);
420     return 1;
422 /********************************************************************
423  * FUNCTION PURPOSE: Send packet to NETCP via NWAL
424  ********************************************************************
425  * DESCRIPTION: Send packet to NETCP via NWAL
426  ********************************************************************/
427 static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
428                                 Ti_Pkt *pkt,
429                                 PKTIO_METADATA_T *m,
430                                 int * err)
432     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
433     nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
434     nwal_RetValue res;
435     *err=0;
436     pPktInfo->pPkt = pkt;
437     res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
438     if (res != nwal_OK)
439     {
440         *err = NETAPI_ERR_NWAL_TX_ERR -res;
441         return -1;
442     }
443     return 1;
447 static void  PKTIO_dump_buf_32bit
449     uint8_t*                      buf,
450     uint32_t                      buf_length
453     uint8_t                       count = 0;
454     uint16_t                      dump_size;
455     uint32_t*                     tmp_buf;
456     uint8_t                       row_count;
458     dump_size = buf_length/4 ;
460     tmp_buf = (uint32_t *)(buf);
462     printf("pktio *:  - 32 bit word hex Length: %d Start \n",buf_length);
463     do
464     {
465         row_count = (dump_size - count);
467         if(row_count == 0)
468         {
469             break;
470         }
472         if(row_count > 4)
473         {
474             row_count = 4;
475         }
477         switch (row_count)
478         {
479             case 4:
480             {
481                 printf("pktio *:%02d : %08x    %08x    %08x    %08x \n",
482                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2],tmp_buf[3]);
483                 break;
484             }
485             case 3:
486             {
487                 printf("pktio *: %02d : %08x    %08x    %08x \n",
488                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2]);
489                 break;
490             }
492             case 2:
493             {
494                 printf("pktio *: %02d : %08x    %08x \n",
495                       count,tmp_buf[0],tmp_buf[1]);
496                 break;
497             }
499             case 1:
500             {
501                 printf("pktio *: %02d : %08x \n",
502                       count,tmp_buf[0]);
503                 break;
504             }
506             default:
507             {
508                 /* Should never reach here */
509                 printf("pktio *: Internal Error in nwal_dump_buf_32bit().Row Count: %d \n",
510                     row_count);
511                 return;
512             }
513         }
515         tmp_buf = tmp_buf + row_count;
516         count = count +  row_count;
518     }while(count < dump_size);
520     printf("NWAL *:  - Byte hex Dump End \n");
525 static void  PKTIO_dump_buf
527     uint8_t*                      buf,
528     uint32_t                      buf_length
531     uint8_t                       count = 0;
532     uint16_t                      dump_size;
533     uint8_t*                     tmp_buf;
534     uint8_t                       row_count;
537     dump_size = buf_length ;
539     tmp_buf = (uint8_t *)(buf);
541     printf("PKTIO *:  - 8 bit word hex Length: %d Start \n",buf_length);
542     do
543     {
544         row_count = (dump_size - count);
546         if(row_count == 0)
547         {
548             break;
549         }
551         if(row_count > 4)
552         {
553             row_count = 4;
554         }
556         switch (row_count)
557         {
558             case 4:
559             {
560                 printf("PKTIO *:%02d : %02x    %02x    %02x    %02x \n",
561                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2],tmp_buf[3]);
562                 break;
563             }
564             case 3:
565             {
566                 printf("PKTIO *: %02d : %02x    %02x    %02x \n",
567                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2]);
568                 break;
569             }
571             case 2:
572             {
573                 printf("PKTIO *: %02d : %02x    %02x \n",
574                       count,tmp_buf[0],tmp_buf[1]);
575                 break;
576             }
578             case 1:
579             {
580                 printf("PKTIO *: %02d : %02x \n",
581                       count,tmp_buf[0]);
582                 break;
583             }
585             default:
586             {
587                 /* Should never reach here */
588                 printf("PKTIO *: Internal Error in PKTIO_dump_buf().Row Count: %d \n",
589                     row_count);
590                 return;
591             }
592         }
594         tmp_buf = tmp_buf + row_count;
595         count = count +  row_count;
597     }while(count < dump_size);
599     printf("PKTIO *:  - Byte hex Dump End \n");
603 /********************************************************************
604  * FUNCTION PURPOSE: Send packet to SA via NWAL
605  ********************************************************************
606  * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode 
607  * channel via NWAL
608  ********************************************************************/
609 static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
610                               Ti_Pkt *pkt, 
611                               PKTIO_METADATA_T *m, 
612                               int * err)
615     nwal_RetValue nwalRetVal;
616     nwalTxDmPSCmdInfo_t     *dmPSCmdInfo;
617     nwalLocCxtInfo_t    nwalLocCxt;
618     Cppi_HostDesc*          pPloadDesc;
619     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
620     nwalLocCxtInfo_t      info;
621     void* virtAddr = NULL;
622     nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
624     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
626     dmPSCmdInfo = netapip_netcpCfgGetSaSBInfo(&netapi_get_global()->nwal_context, tunnel_id);
627     if (dmPSCmdInfo)
628     {
629         nwalRetVal = nwal_getLocCxtInfo(pktio_mGetNwalInstance(p),&info);
630         if(nwalRetVal == nwal_OK)
631         {
632             dmPSCmdInfo->rxSbSaQ = info.rxSbSaQ;
633         }
634         else
635         {
636             *err=NETAPI_ERR_BAD_INPUT;
637             return -1;
638         }
639         nwal_mCmdDMUpdate(pkt,
640             dmPSCmdInfo,
641             pPktInfoSB->appCtxId,
642             pPktInfoSB->encOffset,
643             pPktInfoSB->encSize,
644             pPktInfoSB->pEncIV,
645             pPktInfoSB->authOffset,
646             pPktInfoSB->authSize,
647             pPktInfoSB->pAuthIV,
648             pPktInfoSB->aadSize,
649             pPktInfoSB->pAad);
650         pPloadDesc = Pktlib_getDescFromPacket(pkt);
652 #if 0
653         printf("netapip_pktioSendSb: dumping descriptor begin\n");
654         PKTIO_dump_buf_32bit(pPloadDesc, 128);
655         printf("netapip_pktioSendSb: dumping descriptor end\n");
656         
657                 virtAddr= hplib_mVMPhyToVirt(pPloadDesc->softwareInfo1);
659                 printf("phy Addr: 0x%x\n", pPloadDesc->softwareInfo1);
660                 printf("virtAddr: 0x%x\n", virtAddr);
662                 printf("netapip_pktioSendSb: dumping security context begin\n");
663                 PKTIO_dump_buf((uint8_t*)virtAddr, 128);
664                 PKTIO_dump_buf((uint8_t*)virtAddr+128, 128);
665                 printf("netapip_pktioSendSb: dumping security context end\n");
666 #endif
669         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
671         Qmss_queuePushDescSizeRaw(dmPSCmdInfo->txQueue,
672                                              pPloadDesc,
673                                              NWAL_DESC_SIZE); 
674     }
675     else
676     {
677           *err=NETAPI_ERR_BAD_INPUT;
678           return -1;
679     }
681     return 1;
684 /********************************************************************
685  * FUNCTION PURPOSE: Send packet via infrastructure DMA channel
686  ********************************************************************
687  * DESCRIPTION: Send packet via infrastructure DMA channel
688  ********************************************************************/
689 static int netapip_pktioSendIfdma(struct PKTIO_HANDLE_tag * pp,
690                                  Ti_Pkt *pkt, 
691                                  PKTIO_METADATA_T *m, 
692                                  int * err)
694         Cppi_DescTag            tag={0};
695         Cppi_HostDesc*          pPloadDesc;
696         PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
697         *err=0;
698         tag.srcTagLo = m->u.tx_ifdma_dest;
699         Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
700         pPloadDesc = Pktlib_getDescFromPacket(pkt);
701         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
703         Qmss_queuePushDescSizeRaw(p->q,
704                                   pPloadDesc,
705                                   NWAL_DESC_SIZE);
706         return 1;
711 /********************************************************************
712  * FUNCTION PURPOSE: Stub function for send, do nothing.
713  ********************************************************************
714  * DESCRIPTION: Stub function for send, do nothing.
715  ********************************************************************/
716 static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
717                                  Ti_Pkt *pkt, 
718                                  PKTIO_METADATA_T *m, 
719                                  int * err)
721     *err =  NETAPI_ERR_BAD_INPUT;
722     return -1;
725 /********************************************************************
726  * FUNCTION PURPOSE: Stub function for poll, do nothing.
727  ********************************************************************
728  * DESCRIPTION: Stub function for send, do nothing.
729  ********************************************************************/
730 static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p, 
731                                  PKTIO_POLL_T * p_poll_cfg,
732                                  int * err)
734     *err= NETAPI_ERR_BAD_INPUT;
735     return 0;
738 /********************************************************************
739  * FUNCTION PURPOSE: Poll IPC queue
740  ********************************************************************
741  * DESCRIPTION: Poll IPC queue
742  ********************************************************************/
743 static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp, 
744                                PKTIO_POLL_T * p_poll_cfg,  
745                                int * err)
747     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
748     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
749     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
750     int r=0;
751     int n;
752     Ti_Pkt * temp;
753     *err=0;
754     n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
755     for(r=0;r<n;r++)
756     {
758         temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
760         if(!temp) break;
761         /* process meta data */
762         pkt_list[r]= temp;
763         meta_s[r].flags1=0x1;
764     }
765     if (r)
766     {
767         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
768     }
769     return r;
772 /********************************************************************
773  * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
774  ********************************************************************
775  * DESCRIPTION: Poll nwal data queues for pkts from netcp
776  ********************************************************************/
777 static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp, 
778                                 PKTIO_POLL_T * p_poll_cfg,  
779                                 int * err)
781     int r=0;
782     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
783     *err=0;
784     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
785         set.  optimizaion maybe? */
786     r=nwal_pollPkt(p->nwalInstanceHandle,
787                    p->poll_flags,
788                    (uint32_t) p,
789                    p->max_n,
790                    QMSS_PARAM_NOT_SPECIFIED,
791                    (void*) NULL);
792     return r;
794 /********************************************************************
795  * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
796  ********************************************************************
797  * DESCRIPTION: Poll nwal sideband queues for pkts from SA
798  ********************************************************************/
799 static int  netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp, 
800                                PKTIO_POLL_T * p_poll_cfg,  
801                                int * err)
803     int r=0;
804     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
805     *err=0;
806     r=nwal_pollDm(p->nwalInstanceHandle,
807                     nwal_POLL_DM_DEF_SB_SA_Q,
808                      (uint32_t) p,
809                      p->max_n,
810                      QMSS_PARAM_NOT_SPECIFIED,
811              (void *) NULL);
812     return r;
815 /********************************************************************
816  * FUNCTION PURPOSE: Poll application provided NETCP RX queue
817  ********************************************************************
818  * DESCRIPTION: Poll application provided NETCP RX queue
819  ********************************************************************/
820 static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp, 
821                                    PKTIO_POLL_T * p_poll_cfg,  
822                                    int * err)
824     int r=0;
825     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
826     *err=0;
827     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
828          set. optimizaion maybe? */
829     r=nwal_pollPkt(p->nwalInstanceHandle,
830                    nwal_POLL_APP_MANAGED_PKT_Q,
831                    (uint32_t) p,
832                    p->max_n,
833                    p->q,
834                    (void *) NULL);
836     return r;
839 /*************************************************************************
840  * FUNCTION PURPOSE: Poll application defined sideband queues for packets
841  *                   from SA
842  ************************************************************************
843  * DESCRIPTION: Poll application defined sideband queues for packets
844  *                   from SA
845  *************************************************************************/
846 static int  netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp, 
847                                   PKTIO_POLL_T * p_poll_cfg,  
848                                   int * err)
850     int r=0;
851     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
852     *err=0;
853     r=nwal_pollDm(p->nwalInstanceHandle,
854                      nwal_POLL_DM_APP_MANAGED_Q,
855                      (uint32_t) p,
856                      p->max_n,
857                      p->q,
858                      (void *)  NULL);
859     return r;
862 /*-----------------------MAIN API----------------------*/
863 /********************************************************************
864  * FUNCTION PURPOSE:  API creates a NETAPI PKTIO channel 
865  ********************************************************************
866  * DESCRIPTION:  API creates a NETAPI PKTIO channel 
867  ********************************************************************/
868 PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
869                                     char * name,
870                                     PKTIO_CB cb, 
871                                     PKTIO_CFG_T * p_cfg, 
872                                     int * err)
874     int r = 0;
875     PKTIO_HANDLE_T *p;
876     uint8_t         isAllocated;
878     *err=0;
879     int q= QMSS_PARAM_NOT_SPECIFIED;
880     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
882     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
883     if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
884     if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
886     /* get a free channel handle */
887     p=netapip_pktioGetFreeChannelSlot(n);
889     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
891     p->back = n;
892     p->cb = cb;
893     p->max_n = p_cfg->max_n;
894     p->_poll=netapip_pktioPollDummy;
895     p->_send=netapip_pktioSendDummy;
896     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
898     if (p_cfg->qnum!=PKTIO_Q_ANY)
899     {
900         q= p_cfg->qnum;
901     }
902     /* special case for infrastructure dma channels */
903     if (p_cfg->flags2 & PKTIO_IFDMA)
904     {
905         qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
906     }
909     /* create a  general queue */
910      p->q  = Qmss_queueOpen(qtype,
911                                 q, 
912                                 &isAllocated);
913     if (p->q == (Qmss_QueueHnd) NULL)
914     {
915         netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
916         p->inuse=0;
917         *err= NETAPI_ERR_QLLD;  ///queue lld error
918         return NULL;
919     }
920     p->qInfo = Qmss_getQueueNumber(p->q);
921     if (p_cfg->flags2 & PKTIO_PKT)
922     {
923         p->use_nwal = PKTIO_4_ADJ_NWAL;
924         p->_poll=netapip_pktioPollNwalAdj;
925         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
926     }
927     else if (p_cfg->flags2 & PKTIO_SB)
928     {
929         p->use_nwal = PKTIO_4_ADJ_SB;
930         p->_poll=netapip_pktioPollSbAdj;
931         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
932     }
933    else if (p_cfg->flags2 & PKTIO_IFDMA)
934    {
935         p->use_nwal = 0;
936         p->_send = netapip_pktioSendIfdma;
937         p->cfg.flags1=PKTIO_TX;
938         r= netapip_pktioCreateIFDMA(p); //we create the IF DMA channel here
939         if (r<0) 
940         {
941             //trouble -> couldn't set up DMA 
942             //close queue and return failure
943             if (p->q)
944             {
945                 Qmss_queueClose(p->q);
946             }
947             p->inuse=0;
948             *err= NETAPI_ERR_QLLD;  ///queue lld error TODO: fix error code 
949             return NULL;
950         }
951    }
952     else
953     {
954         p->use_nwal=0;
955         if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
956         if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
957     }
959     /* save name */ 
960     strncpy(p->name,name,
961        strlen(name)<PKTIO_MAX_NAME ?
962                strlen(name):PKTIO_MAX_NAME);   
964     /* add name, qnum to global name list */
965     if ((strcmp(name,NETCP_RX)) &&
966         (strcmp(name,NETCP_TX)) &&
967         (strcmp(name,NETCP_SB_RX)) &&
968         (strcmp(name,NETCP_SB_TX)) &&
969         (p_cfg->flags1 & PKTIO_GLOBAL))
970     {
971          //todo: make sure this succeeds..
972         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
973         r=netapip_addGlobalPktio(n, name, &p->qInfo);
974         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
975     }
977   ((NETAPI_HANDLE_T *)n )->n_pktios+=1;
978    return p;
981 /********************************************************************
982  * FUNCTION PURPOSE:  API opens an existing  NETAPI PKTIO channel
983  ********************************************************************
984  * DESCRIPTION:  API opens an existing  NETAPI PKTIO channel
985  ********************************************************************/
986 PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T  n,
987                                   char *name,
988                                   PKTIO_CB cb,
989                                   PKTIO_CFG_T * p_cfg,
990                                   int * err)
992     int r=0;
993     PKTIO_HANDLE_T *p, *p2;
994     uint8_t         isAllocated;
995     *err=0;
996     Qmss_Queue *p_qnum;
997     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
1000     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
1002     /* get a free channel handle */
1004     p=netapip_pktioGetFreeChannelSlot(n);
1006     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
1007     ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
1009     p->inuse= PKTIO_INUSE;
1010     p->back = n;
1011     p->cb = cb;
1012     p->max_n = p_cfg->max_n;
1013     p->_poll=netapip_pktioPollDummy;
1014     p->_send=netapip_pktioSendDummy;
1015     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
1017     /* special handling of NETCP_RX, NETCP_TX */
1018     if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
1019     {
1020        /* these have already been opened internally, so don't search in global list */
1021         p->use_nwal = PKTIO_DEF_NWAL;
1022         p->q = 0;  
1023         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
1024         if (!strcmp(name,NETCP_RX))
1025         {
1026             p->_poll=netapip_pktioPollNwal; 
1027             p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
1028                                     nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
1029         }
1030         if (!strcmp(name,NETCP_TX))
1031         {
1032             p->_send=netapip_pktioSendNwal;
1033         }
1034     }
1035     else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
1036     {
1037        /* these have already been opened internally, so don't search in global list */
1038         p->use_nwal =  PKTIO_DEF_SB;
1039         p->q = 0;
1040         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
1041         if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
1042         if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
1043     }
1044     else
1045     {
1046         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
1047         /* Find queue in global list 
1048            Note names like "QUEUE:%d" or IFDMA:%d cause general purpose or
1049            IFDMA queues of that number to be opened */
1050         if (p_cfg->flags2 & PKTIO_IFDMA)
1051         {
1052             qtype= Qmss_QueueType_INFRASTRUCTURE_QUEUE;
1053         }
1055         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
1056         p_qnum = netapip_findGlobalPktio(n, name);
1058         if (!p_qnum ) 
1059         {
1060             netapi_Log("netapi_pktioOpen: can't find %s\n",name);
1061             p->inuse=0;
1062             *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
1063             return NULL;
1064       }
1066      /* open a general queue (for now). use qnum that was just found */
1067          p->q  = Qmss_queueOpen(qtype,
1068                            p_qnum->qNum , &isAllocated);
1069         if (p->q == (Qmss_QueueHnd) NULL)
1070         {
1071             netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
1072             p->inuse=0;
1073             *err= NETAPI_ERR_QLLD;  ///queue lld error
1074             return NULL;
1075         }
1076         p->qInfo = Qmss_getQueueNumber(p->q);
1077         netapi_Log("netapi_pktioOpen: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
1078         if (p_cfg->flags2 & PKTIO_PKT)
1079         {
1080            p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
1081            p->_poll = netapip_pktioPollNwalAdj;
1082            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n); 
1083            netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
1084         } 
1085         else if (p_cfg->flags2 & PKTIO_SB)
1086         {
1087            p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
1088            p->_poll = netapip_pktioPollSbAdj;
1089            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
1090         }
1091         else if (p_cfg->flags2 & PKTIO_IFDMA)
1092         {
1093             p->_send= netapip_pktioSendIfdma;
1094             p->use_nwal = 0;
1095         }
1096         else
1097         {
1098            p->use_nwal=0; //not handled by nwal
1099             if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
1100             if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
1101         }
1102     }
1104         /* save name */
1105         strncpy(p->name,name,
1106            strlen(name)<PKTIO_MAX_NAME ?
1107                    strlen(name):PKTIO_MAX_NAME);
1109         netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
1110     return p;
1113 /********************************************************************
1114  * FUNCTION PURPOSE:  API controls an existing NETAPI PKTIO channel
1115  ********************************************************************
1116  * DESCRIPTION:  API controls an existing NETAPI PKTIO channel
1117  ********************************************************************/
1118 void netapi_pktioControl(PKTIO_HANDLE_T * p,
1119                          PKTIO_CB cb,
1120                          PKTIO_CFG_T * p_cfg,
1121                          PKTIO_CONTROL_T * p_control,
1122                          int *err)
1124     nwal_RetValue       nwalRetVal;
1125     if (!p)
1126     {
1127         *err= NETAPI_ERR_BAD_INPUT; 
1128         return;
1129     }
1130     if (cb) 
1131     {
1132         p->cb = cb;
1133     }
1134     if (p_control)
1135     {
1136         /* todo: check for validity, eg don't allow clear of NETCP TX queues */
1137         /* todo: implement divert */
1138         switch(p_control->op)
1139         {
1140             //clear the queue
1141             case(PKTIO_SET_POLL_FLAGS):
1142                 p->poll_flags=p_control->poll_flags;
1143                 break;
1144             case(PKTIO_CLEAR):
1145                 netapip_zapQ(p->q);
1146                 break;
1147             case (PKTIO_UPDATE_FAST_PATH):
1148                 if (p_cfg)
1149                 {
1150                     nwalRetVal = nwal_initPSCmdInfo(p->nwalInstanceHandle, 
1151                                                             p_cfg->fast_path_cfg.txPktInfo,
1152                                                             &p->tx_psCmdInfo);
1153                     if (nwalRetVal == nwal_OK)
1154                     {
1155                         switch (p_cfg->fast_path_cfg.fp_send_option)
1156                         {
1157                             case (PKTIO_FP_ESP_L4CKSUM_PORT):
1158                                 p->_send = netapip_pktioSendL4CkSumCryptPort;
1159                                 break;
1160                             case (PKTIO_FP_AH_L4CKSUM_PORT):
1161                                 p->_send = netapip_pktioSendL4CkSumAHCryptPort;
1162                                 break;
1163                             case (PKTIO_FP_ESP_PORT):
1164                                 p->_send = netapip_pktioSendCryptPort;
1165                                 break;
1166                             case (PKTIO_FP_ESP_L3CKSUM_PORT):
1167                                 p->_send = netapip_pktioSendL3CkSumCryptPort;
1168                                 break;
1169                             case (PKTIO_FP_AH_PORT):
1170                                 p->_send = netapip_pktioSendAHCryptPort;
1171                                 break;
1172                             case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
1173                                 p->_send = netapip_pktioSendPort;
1174                                 break;
1175                             case (PKTIO_FP_L4CKSUM_PORT):
1176                                 p->_send = netapip_pktioSendL4CkSumPort;
1177                                 break;
1178                             default:
1179                                 break;
1180                         }
1181                     }
1182                     else
1183                     {
1184                         *err = NETAPI_ERR_BAD_INPUT;
1185                     }
1186                 }
1187                 else
1188                 {
1189                     *err = NETAPI_ERR_BAD_INPUT;
1190                 }
1191                 break;
1192             case (PKTIO_UPDATE_MAX_PKTS_PER_POLL):
1193                 if (p_cfg)
1194                 {
1195                     p->max_n = p_cfg->max_n;
1196                 }
1197                 else
1198                 {
1199                     *err = NETAPI_ERR_BAD_INPUT;
1200                 }
1201                 break;
1202             case(PKTIO_DIVERT):
1203             default:
1204                 netapi_Log("netapi_pktioControl: pktio_control op %d not implemented\n",p_control->op);
1205                 *err= NETAPI_ERR_NOT_IMPLEMENTED;
1206                 break;
1207         }
1208     }
1210     *err = NETAPI_ERR_OK;
1211     return;
1213 /********************************************************************
1214  * FUNCTION PURPOSE:  API closes a NETAPI PKTIO channel
1215  ********************************************************************
1216  * DESCRIPTION:  API closes a NETAPI PKTIO channel
1217  ********************************************************************/
1218 void netapi_pktioClose(PKTIO_HANDLE_T * p, 
1219                        int * err)
1221     if(!p)
1222     {
1223         *err=1;
1224         return;
1225     }
1226     *err=0;
1227     if (p->q)
1228     {
1229         Qmss_queueClose(p->q);
1230     }
1231     p->q=-1;
1232     p->inuse=0;
1233     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1234     return;
1237 /********************************************************************
1238  * FUNCTION PURPOSE:  API deletes a NETAPI PKTIO channel
1239  ********************************************************************
1240  * DESCRIPTION:  API deletes a NETAPI PKTIO channel
1241  ********************************************************************/
1242 void netapi_pktioDelete(PKTIO_HANDLE_T * p, 
1243                         int * err)
1245     if(!p)
1246     {
1247         *err=1;
1248         return;
1249     }
1250     *err=0;
1251     if (p->cfg.flags2 & PKTIO_IFDMA)
1252     {
1253         netapip_pktioDeleteIFDMA(p);
1254     }
1256         /* remove from name list */
1257     hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
1258         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
1259     hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
1260         if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB)) 
1261     {
1262                 netapip_zapQ(p->q);   //since we are deleting, zap the queue 
1263             Qmss_queueClose(p->q);
1264     }
1265     p->q=-1;
1266     p->inuse=0;
1267     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1268     return ;
1271 /********************************************************************
1272  * FUNCTION PURPOSE:  API sends multiple packets to a NETAPI PKTIO channel
1273  ********************************************************************
1274  * DESCRIPTION:  API sends multiple packets to a NETAPI PKTIO channel
1275  ********************************************************************/
1276 int netapi_pktioSendMulti(PKTIO_HANDLE_T * p, 
1277                           Ti_Pkt * pkt[], 
1278                           PKTIO_METADATA_T * m[], 
1279                           int np, 
1280                           int* err)
1282     int r=0;
1283     for(r=0;r<np;r++)
1284     {
1285         p->_send((struct PKTIO_HANDLE_tag *)p, (Ti_Pkt *)pkt, (PKTIO_METADATA_T *)m, err);
1286     }
1287     return r;
1290 /********************************************************************
1291  * FUNCTION PURPOSE:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1292  * instance for received packets
1293  ********************************************************************
1294  * DESCRIPTION:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1295  * instance for received packets
1296  ********************************************************************/
1297 int netapi_pktioPollAll(NETAPI_T  handle, 
1298                         PKTIO_POLL_T * p_poll_cfg, 
1299                         int *err)
1301     int i=0;
1302     int r=0;
1303     int err2;
1304     int cnt=0;
1305     PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
1306     
1307     *err=0;
1308     for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
1309     {
1310         if (pp[i]->inuse != PKTIO_INUSE) continue;
1311         if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
1312         r+=netapi_pktioPoll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
1313         if (err2) { *err = err2; break;}
1314     }
1315     return r;
1319 /********************************************************************
1320  * FUNCTION PURPOSE:  Internal function to delete a PKTIO infrastructure DMA channel
1321  ********************************************************************
1322  * DESCRIPTION:  Internal function to delete a PKTIO infrastructure DMA channel
1323  ********************************************************************/
1324 int netapip_pktioDeleteIFDMA(PKTIO_HANDLE_T *p)
1326         Cppi_channelDisable (p->txChHnd);
1327         Cppi_channelDisable (p->rxChHnd);
1328         Cppi_channelClose(p->txChHnd);
1329         Cppi_channelClose(p->rxChHnd);
1330         Cppi_close(p->cppiHnd);
1331         return 1;
1334 /********************************************************************
1335  * FUNCTION PURPOSE:  Internal function to create a PKTIO infrastructure DMA channel
1336  ********************************************************************
1337  * DESCRIPTION:  Internal function to create a PKTIO infrastructure DMA channel
1338  *               for infrastructure DMQ queue
1339  ********************************************************************/
1340 int netapip_pktioCreateIFDMA(PKTIO_HANDLE_T * p )
1342    int dmaChan =  p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
1343    unsigned char           isAllocated;
1344    Cppi_TxChInitCfg        txChCfg;
1345    Cppi_RxChInitCfg        rxChCfg;
1346    Cppi_CpDmaInitCfg       cpdmaCfg;
1348     /* Set up QMSS CPDMA configuration */
1349     memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
1350     cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
1352     /* Open QMSS CPDMA */
1353     p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
1354     if (p->cppiHnd == NULL)
1355     {
1356         return -1;
1357     }
1359  /* Set up Tx Channel parameters */
1360     memset ((void *) &txChCfg, 0, sizeof (Cppi_TxChInitCfg));
1361     txChCfg.channelNum = dmaChan;
1362     txChCfg.priority = 0;
1363     txChCfg.filterEPIB = 0;
1364     txChCfg.filterPS = 0;
1365     txChCfg.aifMonoMode = 0;
1366     txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
1368     /* Open Tx Channel */
1369     p->txChHnd = (Cppi_ChHnd) Cppi_txChannelOpen (p->cppiHnd, &txChCfg, &isAllocated);
1370     if (p->txChHnd == NULL)
1371     {
1372         Cppi_close(p->cppiHnd);
1373         return -1;
1374     }
1376      /* Set up Rx Channel parameters */
1377     memset ((void *) &rxChCfg, 0, sizeof (Cppi_RxChInitCfg));
1378     rxChCfg.channelNum = dmaChan;
1379     rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
1381     /* Open Rx Channel */
1382     p->rxChHnd = (Cppi_ChHnd) Cppi_rxChannelOpen (p->cppiHnd, &rxChCfg, &isAllocated);
1383     if (p->rxChHnd == NULL)
1384     {
1385         Cppi_channelClose(p->txChHnd);
1386         Cppi_close(p->cppiHnd);
1387         return -1;
1388     }
1389     if (Cppi_channelEnable (p->txChHnd) != CPPI_SOK)
1390     {
1391         Cppi_channelClose(p->txChHnd);
1392         Cppi_channelClose(p->rxChHnd);
1393         Cppi_close(p->cppiHnd);
1394         return -1;
1395     }
1397     /* Enable receive channel */
1398     if (Cppi_channelEnable (p->rxChHnd) != CPPI_SOK)
1399     {
1400         Cppi_channelDisable (p->txChHnd);
1401         Cppi_channelClose(p->txChHnd);
1402         Cppi_channelClose(p->rxChHnd);
1403         Cppi_close(p->cppiHnd);
1404         return -1;
1405     }
1406     return 1;
1409 /**********************************************************************
1410  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for packet reception
1411  **********************************************************************
1412  * DESCRIPTION:  Callback that gets registered with NWAL for packet reception
1413  * appCookie is the pktio handle 
1414  **********************************************************************/
1415 void netapip_pktioNWALRxPktCallback(uint32_t            appCookie,
1416                               uint16_t             numPkts,
1417                               nwalRxPktInfo_t*    pPktInfo,
1418                               uint64_t            timestamp,
1419                               nwal_Bool_t*        pFreePkt)
1421     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1422     int r=0;
1423     int n;
1424     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1425     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1427     for(r=0;r<numPkts;r++)
1428     {
1429         pkt_list[r] = pPktInfo[r].pPkt;
1430         meta_s[r].flags1 = PKTIO_META_RX;
1431         meta_s[r].u.rx_meta = &pPktInfo[r];
1432     }
1433     if (r)
1434     {
1435         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
1436     }
1440 /**********************************************************************
1441  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for crypto reception
1442  **********************************************************************
1443  * DESCRIPTION:  Callback that gets registered with NWAL for crypto reception,
1444  * appCookie is the pktio handle 
1445  **********************************************************************/
1446 void netapip_pktioNWALSBPktCallback(uint32_t            appCookie,
1447                               uint16_t             numPkts,
1448                               nwalDmRxPayloadInfo_t*  pDmRxPktInfo,
1449                               nwal_Bool_t*        pFreePkt)
1451     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1452     int r=0;
1453     int n;
1454     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1455     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1456     for(r=0;r<numPkts;r++)
1457     {
1458         pkt_list[r] = pDmRxPktInfo[r].pPkt;
1459         meta_s[r].flags1 =  PKTIO_META_SB_RX;
1460         meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
1461     }
1462     if (r)
1463     {
1464         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
1465     }