b843d069bc1da6880fb768490e093181ac4d41c0
[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;
103     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
104     {
105         nwal_mCmdSetL4CkSumCrypPort(p->nwalInstanceHandle,
106                                     pkt,
107                                     &p->tx_psCmdInfo,
108                                     pTxPktInfo->l4OffBytes, 
109                                     pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
110                                     pTxPktInfo->pseudoHdrChecksum, 
111                                     pTxPktInfo->saOffBytes, 
112                                     pTxPktInfo->saPayloadLen, 
113                                     swInfo0, 
114                                     swInfo1,
115                                     pTxPktInfo->enetPort);
117         pPloadDesc = Pktlib_getDescFromPacket(pkt);
118         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
119         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
120                                   pPloadDesc,
121                                   NWAL_DESC_SIZE);
122     }
123     else
124     {
125           *err=NETAPI_ERR_BAD_INPUT;
126           return -1;
127     }
129     return 1;
132 /********************************************************************
133  * FUNCTION PURPOSE: Send packet via low level NWAL API's
134  * with updates for ESP Crypto and outgoing EMAC port 
135  * to NetCP command.
136  ********************************************************************
137  * DESCRIPTION: Send packet via low level NWAL API's
138  * with updates for ESP Crypto and outgoing EMAC port 
139  * to NetCP command.
140  ********************************************************************/
141 static int netapip_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
142                                      Ti_Pkt *pkt,
143                                      PKTIO_METADATA_T *m,
144                                      int * err)
146     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
147     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
148     Cppi_HostDesc*          pPloadDesc;
149     uint32_t swInfo0, swInfo1;
151     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
153     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
154     {
155         nwal_mCmdSetCrypPort(p->nwalInstanceHandle,
156                              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     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
202     {
203         nwal_mCmdSetL3CkSumCrypPort(p->nwalInstanceHandle,
204                              pkt,
205                              &p->tx_psCmdInfo,
206                               pTxPktInfo->saOffBytes,
207                               pTxPktInfo->saPayloadLen,
208                               swInfo0,
209                               swInfo1,
210                               pTxPktInfo->enetPort);
212         pPloadDesc = Pktlib_getDescFromPacket(pkt);
213         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
215         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
216                                   pPloadDesc,
217                                   NWAL_DESC_SIZE);
218     }
219     else
220     {
221           *err=NETAPI_ERR_BAD_INPUT;
222           return -1;
223     }
225     return 1;
233 /********************************************************************
234  * FUNCTION PURPOSE: Send packet via low level NWAL API's
235  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
236  * to NetCP command.
237  *******************************************************************
238  * DESCRIPTION: Send packet via low level NWAL API's
239  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
240  * to NetCP command.
241  ********************************************************************/
242 static int netapip_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
243                                               Ti_Pkt *pkt,
244                                               PKTIO_METADATA_T *m,
245                                               int * err)
247     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
248     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
249     Cppi_HostDesc*          pPloadDesc;
250     uint32_t swInfo0, swInfo1;
252     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
254     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
255     {
256         nwal_mCmdSetL4CkSumAHCrypPort(p->nwalInstanceHandle,
257                                 pkt,
258                                 &p->tx_psCmdInfo,
259                                 pTxPktInfo->l4OffBytes, 
260                                 pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
261                                 pTxPktInfo->pseudoHdrChecksum, 
262                                 pTxPktInfo->saOffBytes, 
263                                 pTxPktInfo->saPayloadLen, 
264                                 swInfo0, 
265                                 swInfo1,
266                                 pTxPktInfo->saAhIcvOffBytes,
267                                 pTxPktInfo->saAhMacSize,
268                                 pTxPktInfo->enetPort);
270         pPloadDesc = Pktlib_getDescFromPacket(pkt);
271         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
273         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
274                                   pPloadDesc,
275                                   NWAL_DESC_SIZE);
276     }
277     else
278     {
279           *err=NETAPI_ERR_BAD_INPUT;
280           return -1;
281     }
283     return 1;
286 /********************************************************************
287  * FUNCTION PURPOSE: Send packet via low level NWAL API's
288  * with updates for AH Crypto and outgoing EMAC port 
289  * to NetCP command.
290  ********************************************************************
291  * DESCRIPTION: Send packet via low level NWAL API's
292  * with updates for AH Crypto and outgoing EMAC port 
293  * to NetCP command.
294  ********************************************************************/
295 static int netapip_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
296                                        Ti_Pkt *pkt,
297                                        PKTIO_METADATA_T *m,
298                                        int * err)
300     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
301     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
302     Cppi_HostDesc*          pPloadDesc;
303     uint32_t swInfo0, swInfo1;
305     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
307     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
308     {
309         nwal_mCmdSetAHCrypPort(p->nwalInstanceHandle,
310                                pkt,
311                                 &p->tx_psCmdInfo,
312                                 pTxPktInfo->saOffBytes, 
313                                 pTxPktInfo->saPayloadLen, 
314                                 swInfo0, 
315                                 swInfo1,
316                                 pTxPktInfo->saAhIcvOffBytes,
317                                 pTxPktInfo->saAhMacSize,
318                                 pTxPktInfo->enetPort);
319         
320         pPloadDesc = Pktlib_getDescFromPacket(pkt);
321         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
323         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
324                                   pPloadDesc,
325                                   NWAL_DESC_SIZE);
326     }
327     else
328     {
329        *err= NETAPI_ERR_BAD_INPUT;
330        return -1;
331     }
332     return 1;
337 /********************************************************************
338  * FUNCTION PURPOSE: Send packet via low level NWAL API's
339  * with updates for L4 checksum and outgoing EMAC port 
340  * to NetCP command.
341  *******************************************************************
342  * DESCRIPTION: Send packet via low level NWAL API's
343  * with updates for L4 checksum and outgoing EMAC port 
344  * to NetCP command.
345  ********************************************************************/
346 static int netapip_pktioSendL4CkSumPort(struct PKTIO_HANDLE_tag * pp,
347                                       Ti_Pkt *pkt,
348                                       PKTIO_METADATA_T *m,
349                                       int * err)
352     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
353     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
354     Cppi_HostDesc*          pPloadDesc;
355     nwal_mCmdSetL4CkSumPort(p->nwalInstanceHandle,
356                             pkt,
357                             &p->tx_psCmdInfo,
358                             pTxPktInfo->l4OffBytes,
359                             pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
360                             pTxPktInfo->pseudoHdrChecksum,
361                             pTxPktInfo->enetPort);
363     pPloadDesc = Pktlib_getDescFromPacket(pkt);
364     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
365     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
366                                   pPloadDesc,
367                                   NWAL_DESC_SIZE);
371 /********************************************************************
372  * FUNCTION PURPOSE: Send packet via low level NWAL API's
373  * with updates for outgoing EMAC port to NetCP command.
374  ********************************************************************
375  * DESCRIPTION: Send packet via low level NWAL API's
376  * with updates for outgoing EMAC port to NetCP command.
377  ********************************************************************/
378 static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
379                                 Ti_Pkt *pkt, 
380                                 PKTIO_METADATA_T *m, 
381                                 int * err)
383     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
384     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
385     Cppi_HostDesc*          pPloadDesc;
386     nwal_mCmdSetPort(p->nwalInstanceHandle,
387                              pkt,
388                                 &p->tx_psCmdInfo,
389                                  pTxPktInfo->enetPort);
390     pPloadDesc = Pktlib_getDescFromPacket(pkt);
391     pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
393     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
394                                   pPloadDesc,
395                                   NWAL_DESC_SIZE);
396     return 1;
399 /********************************************************************
400  * FUNCTION PURPOSE: Send packet via IPC queue
401  ********************************************************************
402  * DESCRIPTION: Send packet via IPC queue
403  ********************************************************************/
404 static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
405                                Ti_Pkt *pkt,
406                                PKTIO_METADATA_T *m,
407                                int * err)
409     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
410     err=0;
411     Qmss_queuePushDesc (p->q, (void*)pkt);
412     return 1;
414 /********************************************************************
415  * FUNCTION PURPOSE: Send packet to NETCP via NWAL
416  ********************************************************************
417  * DESCRIPTION: Send packet to NETCP via NWAL
418  ********************************************************************/
419 static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
420                                 Ti_Pkt *pkt,
421                                 PKTIO_METADATA_T *m,
422                                 int * err)
424     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
425     nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
426     nwal_RetValue res;
427     *err=0;
428     pPktInfo->pPkt = pkt;
429     res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
430     if (res != nwal_OK)
431     {
432         *err = NETAPI_ERR_NWAL_TX_ERR -res;
433         return -1;
434     }
435     return 1;
438 /********************************************************************
439  * FUNCTION PURPOSE: Send packet to SA via NWAL
440  ********************************************************************
441  * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode 
442  * channel via NWAL
443  ********************************************************************/
444 static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
445                               Ti_Pkt *pkt, 
446                               PKTIO_METADATA_T *m, 
447                               int * err)
450     nwal_RetValue nwalRetVal;
451     nwalTxDmPSCmdInfo_t     *dmPSCmdInfo;
452     nwalLocCxtInfo_t    nwalLocCxt;
453     Cppi_HostDesc*          pPloadDesc;
454     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
455     nwalLocCxtInfo_t      info;
456     nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
458     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
460     dmPSCmdInfo = netapip_netcpCfgGetSaSBInfo(&netapi_get_global()->nwal_context, tunnel_id);
461     if (dmPSCmdInfo)
462     {
463         nwalRetVal = nwal_getLocCxtInfo(pktio_mGetNwalInstance(p),&info);
464         if(nwalRetVal == nwal_OK)
465         {
466             dmPSCmdInfo->rxSbSaQ = info.rxSbSaQ;
467         }
468         else
469         {
470             *err=NETAPI_ERR_BAD_INPUT;
471             return -1;
472         }
473         nwal_mCmdDMUpdate(pkt,
474             dmPSCmdInfo,
475             pPktInfoSB->appCtxId,
476             pPktInfoSB->encOffset,
477             pPktInfoSB->encSize,
478             pPktInfoSB->pEncIV,
479             pPktInfoSB->authOffset,
480             pPktInfoSB->authSize,
481             pPktInfoSB->pAuthIV,
482             pPktInfoSB->aadSize,
483             pPktInfoSB->pAad);
484         pPloadDesc = Pktlib_getDescFromPacket(pkt);
485         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
487         Qmss_queuePushDescSizeRaw(dmPSCmdInfo->txQueue,
488                                              pPloadDesc,
489                                              NWAL_DESC_SIZE); 
490     }
491     else
492     {
493           *err=NETAPI_ERR_BAD_INPUT;
494           return -1;
495     }
497     return 1;
500 /********************************************************************
501  * FUNCTION PURPOSE: Send packet via infrastructure DMA channel
502  ********************************************************************
503  * DESCRIPTION: Send packet via infrastructure DMA channel
504  ********************************************************************/
505 static int netapip_pktioSendIfdma(struct PKTIO_HANDLE_tag * pp,
506                                  Ti_Pkt *pkt, 
507                                  PKTIO_METADATA_T *m, 
508                                  int * err)
510         Cppi_DescTag            tag={0};
511         Cppi_HostDesc*          pPloadDesc;
512         PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
513         *err=0;
514         tag.srcTagLo = m->u.tx_ifdma_dest;
515         Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
516         pPloadDesc = Pktlib_getDescFromPacket(pkt);
517         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
519         Qmss_queuePushDescSizeRaw(p->q,
520                                   pPloadDesc,
521                                   NWAL_DESC_SIZE);
522         return 1;
527 /********************************************************************
528  * FUNCTION PURPOSE: Stub function for send, do nothing.
529  ********************************************************************
530  * DESCRIPTION: Stub function for send, do nothing.
531  ********************************************************************/
532 static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
533                                  Ti_Pkt *pkt, 
534                                  PKTIO_METADATA_T *m, 
535                                  int * err)
537     *err =  NETAPI_ERR_BAD_INPUT;
538     return -1;
541 /********************************************************************
542  * FUNCTION PURPOSE: Stub function for poll, do nothing.
543  ********************************************************************
544  * DESCRIPTION: Stub function for send, do nothing.
545  ********************************************************************/
546 static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p, 
547                                  PKTIO_POLL_T * p_poll_cfg,
548                                  int * err)
550     *err= NETAPI_ERR_BAD_INPUT;
551     return 0;
554 /********************************************************************
555  * FUNCTION PURPOSE: Poll IPC queue
556  ********************************************************************
557  * DESCRIPTION: Poll IPC queue
558  ********************************************************************/
559 static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp, 
560                                PKTIO_POLL_T * p_poll_cfg,  
561                                int * err)
563     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
564     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
565     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
566     int r=0;
567     int n;
568     Ti_Pkt * temp;
569     *err=0;
570     n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
571     for(r=0;r<n;r++)
572     {
574         temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
576         if(!temp) break;
577         /* process meta data */
578         pkt_list[r]= temp;
579         meta_s[r].flags1=0x1;
580     }
581     if (r)
582     {
583         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
584     }
585     return r;
588 /********************************************************************
589  * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
590  ********************************************************************
591  * DESCRIPTION: Poll nwal data queues for pkts from netcp
592  ********************************************************************/
593 static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp, 
594                                 PKTIO_POLL_T * p_poll_cfg,  
595                                 int * err)
597     int r=0;
598     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
599     *err=0;
600     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
601         set.  optimizaion maybe? */
602     r=nwal_pollPkt(p->nwalInstanceHandle,
603                    p->poll_flags,
604                    (uint32_t) p,
605                    p->max_n,
606                    QMSS_PARAM_NOT_SPECIFIED,
607                    (void*) NULL);
608     return r;
610 /********************************************************************
611  * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
612  ********************************************************************
613  * DESCRIPTION: Poll nwal sideband queues for pkts from SA
614  ********************************************************************/
615 static int  netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp, 
616                                PKTIO_POLL_T * p_poll_cfg,  
617                                int * err)
619     int r=0;
620     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
621     *err=0;
622     r=nwal_pollDm(p->nwalInstanceHandle,
623                     nwal_POLL_DM_DEF_SB_SA_Q,
624                      (uint32_t) p,
625                      p->max_n,
626                      QMSS_PARAM_NOT_SPECIFIED,
627              (void *) NULL);
628     return r;
631 /********************************************************************
632  * FUNCTION PURPOSE: Poll application provided NETCP RX queue
633  ********************************************************************
634  * DESCRIPTION: Poll application provided NETCP RX queue
635  ********************************************************************/
636 static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp, 
637                                    PKTIO_POLL_T * p_poll_cfg,  
638                                    int * err)
640     int r=0;
641     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
642     *err=0;
643     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
644          set. optimizaion maybe? */
645     r=nwal_pollPkt(p->nwalInstanceHandle,
646                    nwal_POLL_APP_MANAGED_PKT_Q,
647                    (uint32_t) p,
648                    p->max_n,
649                    p->q,
650                    (void *) NULL);
652     return r;
655 /*************************************************************************
656  * FUNCTION PURPOSE: Poll application defined sideband queues for packets
657  *                   from SA
658  ************************************************************************
659  * DESCRIPTION: Poll application defined sideband queues for packets
660  *                   from SA
661  *************************************************************************/
662 static int  netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp, 
663                                   PKTIO_POLL_T * p_poll_cfg,  
664                                   int * err)
666     int r=0;
667     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
668     *err=0;
669     r=nwal_pollDm(p->nwalInstanceHandle,
670                      nwal_POLL_DM_APP_MANAGED_Q,
671                      (uint32_t) p,
672                      p->max_n,
673                      p->q,
674                      (void *)  NULL);
675     return r;
678 /*-----------------------MAIN API----------------------*/
679 /********************************************************************
680  * FUNCTION PURPOSE:  API creates a NETAPI PKTIO channel 
681  ********************************************************************
682  * DESCRIPTION:  API creates a NETAPI PKTIO channel 
683  ********************************************************************/
684 PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
685                                     char * name,
686                                     PKTIO_CB cb, 
687                                     PKTIO_CFG_T * p_cfg, 
688                                     int * err)
690     int r = 0;
691     PKTIO_HANDLE_T *p;
692     uint8_t         isAllocated;
694     *err=0;
695     int q= QMSS_PARAM_NOT_SPECIFIED;
696     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
698     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
699     if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
700     if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
702     /* get a free channel handle */
703     p=netapip_pktioGetFreeChannelSlot(n);
705     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
707     p->back = n;
708     p->cb = cb;
709     p->max_n = p_cfg->max_n;
710     p->_poll=netapip_pktioPollDummy;
711     p->_send=netapip_pktioSendDummy;
712     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
714     if (p_cfg->qnum!=PKTIO_Q_ANY)
715     {
716         q= p_cfg->qnum;
717     }
718     /* special case for infrastructure dma channels */
719     if (p_cfg->flags2 & PKTIO_IFDMA)
720     {
721         qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
722     }
725     /* create a  general queue */
726      p->q  = Qmss_queueOpen(qtype,
727                                 q, 
728                                 &isAllocated);
729     if (p->q == (Qmss_QueueHnd) NULL)
730     {
731         netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
732         p->inuse=0;
733         *err= NETAPI_ERR_QLLD;  ///queue lld error
734         return NULL;
735     }
736     p->qInfo = Qmss_getQueueNumber(p->q);
737     if (p_cfg->flags2 & PKTIO_PKT)
738     {
739         p->use_nwal = PKTIO_4_ADJ_NWAL;
740         p->_poll=netapip_pktioPollNwalAdj;
741         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
742     }
743     else if (p_cfg->flags2 & PKTIO_SB)
744     {
745         p->use_nwal = PKTIO_4_ADJ_SB;
746         p->_poll=netapip_pktioPollSbAdj;
747         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
748     }
749    else if (p_cfg->flags2 & PKTIO_IFDMA)
750    {
751         p->use_nwal = 0;
752         p->_send = netapip_pktioSendIfdma;
753         p->cfg.flags1=PKTIO_TX;
754         r= netapip_pktioCreateIFDMA(p); //we create the IF DMA channel here
755         if (r<0) 
756         {
757             //trouble -> couldn't set up DMA 
758             //close queue and return failure
759             if (p->q)
760             {
761                 Qmss_queueClose(p->q);
762             }
763             p->inuse=0;
764             *err= NETAPI_ERR_QLLD;  ///queue lld error TODO: fix error code 
765             return NULL;
766         }
767    }
768     else
769     {
770         p->use_nwal=0;
771         if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
772         if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
773     }
775     /* save name */ 
776     strncpy(p->name,name,
777        strlen(name)<PKTIO_MAX_NAME ?
778                strlen(name):PKTIO_MAX_NAME);   
780     /* add name, qnum to global name list */
781     if ((strcmp(name,NETCP_RX)) &&
782         (strcmp(name,NETCP_TX)) &&
783         (strcmp(name,NETCP_SB_RX)) &&
784         (strcmp(name,NETCP_SB_TX)) &&
785         (p_cfg->flags1 & PKTIO_GLOBAL))
786     {
787          //todo: make sure this succeeds..
788         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
789         r=netapip_addGlobalPktio(n, name, &p->qInfo);
790         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
791     }
793   ((NETAPI_HANDLE_T *)n )->n_pktios+=1;
794    return p;
797 /********************************************************************
798  * FUNCTION PURPOSE:  API opens an existing  NETAPI PKTIO channel
799  ********************************************************************
800  * DESCRIPTION:  API opens an existing  NETAPI PKTIO channel
801  ********************************************************************/
802 PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T  n,
803                                   char *name,
804                                   PKTIO_CB cb,
805                                   PKTIO_CFG_T * p_cfg,
806                                   int * err)
808     int r=0;
809     PKTIO_HANDLE_T *p, *p2;
810     uint8_t         isAllocated;
811     *err=0;
812     Qmss_Queue *p_qnum;
813     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
816     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
818     /* get a free channel handle */
820     p=netapip_pktioGetFreeChannelSlot(n);
822     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
823     ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
825     p->inuse= PKTIO_INUSE;
826     p->back = n;
827     p->cb = cb;
828     p->max_n = p_cfg->max_n;
829     p->_poll=netapip_pktioPollDummy;
830     p->_send=netapip_pktioSendDummy;
831     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
833     /* special handling of NETCP_RX, NETCP_TX */
834     if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
835     {
836        /* these have already been opened internally, so don't search in global list */
837         p->use_nwal = PKTIO_DEF_NWAL;
838         p->q = 0;  
839         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
840         if (!strcmp(name,NETCP_RX))
841         {
842             p->_poll=netapip_pktioPollNwal; 
843             p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
844                                     nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
845         }
846         if (!strcmp(name,NETCP_TX))
847         {
848             p->_send=netapip_pktioSendNwal;
849         }
850     }
851     else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
852     {
853        /* these have already been opened internally, so don't search in global list */
854         p->use_nwal =  PKTIO_DEF_SB;
855         p->q = 0;
856         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
857         if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
858         if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
859     }
860     else
861     {
862         hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
863         /* Find queue in global list 
864            Note names like "QUEUE:%d" or IFDMA:%d cause general purpose or
865            IFDMA queues of that number to be opened */
866         if (p_cfg->flags2 & PKTIO_IFDMA)
867         {
868             qtype= Qmss_QueueType_INFRASTRUCTURE_QUEUE;
869         }
871         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
872         p_qnum = netapip_findGlobalPktio(n, name);
874         if (!p_qnum ) 
875         {
876             netapi_Log("netapi_pktioOpen: can't find %s\n",name);
877             p->inuse=0;
878             *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
879             return NULL;
880       }
882      /* open a general queue (for now). use qnum that was just found */
883          p->q  = Qmss_queueOpen(qtype,
884                            p_qnum->qNum , &isAllocated);
885         if (p->q == (Qmss_QueueHnd) NULL)
886         {
887             netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
888             p->inuse=0;
889             *err= NETAPI_ERR_QLLD;  ///queue lld error
890             return NULL;
891         }
892         p->qInfo = Qmss_getQueueNumber(p->q);
893         netapi_Log("netapi_pktioOpen: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
894         if (p_cfg->flags2 & PKTIO_PKT)
895         {
896            p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
897            p->_poll = netapip_pktioPollNwalAdj;
898            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n); 
899            netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
900         } 
901         else if (p_cfg->flags2 & PKTIO_SB)
902         {
903            p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
904            p->_poll = netapip_pktioPollSbAdj;
905            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
906         }
907         else if (p_cfg->flags2 & PKTIO_IFDMA)
908         {
909             p->_send= netapip_pktioSendIfdma;
910             p->use_nwal = 0;
911         }
912         else
913         {
914            p->use_nwal=0; //not handled by nwal
915             if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
916             if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
917         }
918     }
920         /* save name */
921         strncpy(p->name,name,
922            strlen(name)<PKTIO_MAX_NAME ?
923                    strlen(name):PKTIO_MAX_NAME);
925         netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
926     return p;
929 /********************************************************************
930  * FUNCTION PURPOSE:  API controls an existing NETAPI PKTIO channel
931  ********************************************************************
932  * DESCRIPTION:  API controls an existing NETAPI PKTIO channel
933  ********************************************************************/
934 void netapi_pktioControl(PKTIO_HANDLE_T * p,
935                          PKTIO_CB cb,
936                          PKTIO_CFG_T * p_cfg,
937                          PKTIO_CONTROL_T * p_control,
938                          int *err)
940     nwal_RetValue       nwalRetVal;
941     if (!p)
942     {
943         *err= NETAPI_ERR_BAD_INPUT; 
944         return;
945     }
946     if (cb) 
947     {
948         p->cb = cb;
949     }
950     if (p_control)
951     {
952         /* todo: check for validity, eg don't allow clear of NETCP TX queues */
953         /* todo: implement divert */
954         switch(p_control->op)
955         {
956             //clear the queue
957             case(PKTIO_SET_POLL_FLAGS):
958                 p->poll_flags=p_control->poll_flags;
959                 break;
960             case(PKTIO_CLEAR):
961                 netapip_zapQ(p->q);
962                 break;
963             case (PKTIO_UPDATE_FAST_PATH):
964                 if (p_cfg)
965                 {
966                     nwalRetVal = nwal_initPSCmdInfo(p->nwalInstanceHandle, 
967                                                             p_cfg->fast_path_cfg.txPktInfo,
968                                                             &p->tx_psCmdInfo);
969                     if (nwalRetVal == nwal_OK)
970                     {
971                         switch (p_cfg->fast_path_cfg.fp_send_option)
972                         {
973                             case (PKTIO_FP_ESP_L4CKSUM_PORT):
974                                 p->_send = netapip_pktioSendL4CkSumCryptPort;
975                                 break;
976                             case (PKTIO_FP_AH_L4CKSUM_PORT):
977                                 p->_send = netapip_pktioSendL4CkSumAHCryptPort;
978                                 break;
979                             case (PKTIO_FP_ESP_PORT):
980                                 p->_send = netapip_pktioSendCryptPort;
981                                 break;
982                             case (PKTIO_FP_ESP_L3CKSUM_PORT):
983                                 p->_send = netapip_pktioSendL3CkSumCryptPort;
984                                 break;
985                             case (PKTIO_FP_AH_PORT):
986                                 p->_send = netapip_pktioSendAHCryptPort;
987                                 break;
988                             case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
989                                 p->_send = netapip_pktioSendPort;
990                                 break;
991                             case (PKTIO_FP_L4CKSUM_PORT):
992                                 p->_send = netapip_pktioSendL4CkSumPort;
993                                 break;
994                             default:
995                                 break;
996                         }
997                     }
998                     else
999                     {
1000                         *err = NETAPI_ERR_BAD_INPUT;
1001                     }
1002                 }
1003                 else
1004                 {
1005                     *err = NETAPI_ERR_BAD_INPUT;
1006                 }
1007                 break;
1008             case (PKTIO_UPDATE_MAX_PKTS_PER_POLL):
1009                 if (p_cfg)
1010                 {
1011                     p->max_n = p_cfg->max_n;
1012                 }
1013                 else
1014                 {
1015                     *err = NETAPI_ERR_BAD_INPUT;
1016                 }
1017                 break;
1018             case(PKTIO_DIVERT):
1019             default:
1020                 netapi_Log("netapi_pktioControl: pktio_control op %d not implemented\n",p_control->op);
1021                 *err= NETAPI_ERR_NOT_IMPLEMENTED;
1022                 break;
1023         }
1024     }
1026     *err = NETAPI_ERR_OK;
1027     return;
1029 /********************************************************************
1030  * FUNCTION PURPOSE:  API closes a NETAPI PKTIO channel
1031  ********************************************************************
1032  * DESCRIPTION:  API closes a NETAPI PKTIO channel
1033  ********************************************************************/
1034 void netapi_pktioClose(PKTIO_HANDLE_T * p, 
1035                        int * err)
1037     if(!p)
1038     {
1039         *err=1;
1040         return;
1041     }
1042     *err=0;
1043     if (p->q)
1044     {
1045         Qmss_queueClose(p->q);
1046     }
1047     p->q=-1;
1048     p->inuse=0;
1049     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1050     return;
1053 /********************************************************************
1054  * FUNCTION PURPOSE:  API deletes a NETAPI PKTIO channel
1055  ********************************************************************
1056  * DESCRIPTION:  API deletes a NETAPI PKTIO channel
1057  ********************************************************************/
1058 void netapi_pktioDelete(PKTIO_HANDLE_T * p, 
1059                         int * err)
1061     if(!p)
1062     {
1063         *err=1;
1064         return;
1065     }
1066     *err=0;
1067     if (p->cfg.flags2 & PKTIO_IFDMA)
1068     {
1069         netapip_pktioDeleteIFDMA(p);
1070     }
1072         /* remove from name list */
1073     hplib_mSpinLockLock(&pnetapiShm->netapi_pktio_lock);
1074         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
1075     hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
1076         if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB)) 
1077     {
1078                 netapip_zapQ(p->q);   //since we are deleting, zap the queue 
1079             Qmss_queueClose(p->q);
1080     }
1081     p->q=-1;
1082     p->inuse=0;
1083     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1084     return ;
1087 /********************************************************************
1088  * FUNCTION PURPOSE:  API sends multiple packets to a NETAPI PKTIO channel
1089  ********************************************************************
1090  * DESCRIPTION:  API sends multiple packets to a NETAPI PKTIO channel
1091  ********************************************************************/
1092 int netapi_pktioSendMulti(PKTIO_HANDLE_T * p, 
1093                           Ti_Pkt * pkt[], 
1094                           PKTIO_METADATA_T * m[], 
1095                           int np, 
1096                           int* err)
1098     int r=0;
1099     for(r=0;r<np;r++)
1100     {
1101         p->_send((struct PKTIO_HANDLE_tag *)p, (Ti_Pkt *)pkt, (PKTIO_METADATA_T *)m, err);
1102     }
1103     return r;
1106 /********************************************************************
1107  * FUNCTION PURPOSE:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1108  * instance for received packets
1109  ********************************************************************
1110  * DESCRIPTION:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1111  * instance for received packets
1112  ********************************************************************/
1113 int netapi_pktioPollAll(NETAPI_T  handle, 
1114                         PKTIO_POLL_T * p_poll_cfg, 
1115                         int *err)
1117     int i=0;
1118     int r=0;
1119     int err2;
1120     int cnt=0;
1121     PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
1122     
1123     *err=0;
1124     for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
1125     {
1126         if (pp[i]->inuse != PKTIO_INUSE) continue;
1127         if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
1128         r+=netapi_pktioPoll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
1129         if (err2) { *err = err2; break;}
1130     }
1131     return r;
1135 /********************************************************************
1136  * FUNCTION PURPOSE:  Internal function to delete a PKTIO infrastructure DMA channel
1137  ********************************************************************
1138  * DESCRIPTION:  Internal function to delete a PKTIO infrastructure DMA channel
1139  ********************************************************************/
1140 int netapip_pktioDeleteIFDMA(PKTIO_HANDLE_T *p)
1142         Cppi_channelDisable (p->txChHnd);
1143         Cppi_channelDisable (p->rxChHnd);
1144         Cppi_channelClose(p->txChHnd);
1145         Cppi_channelClose(p->rxChHnd);
1146         Cppi_close(p->cppiHnd);
1147         return 1;
1150 /********************************************************************
1151  * FUNCTION PURPOSE:  Internal function to create a PKTIO infrastructure DMA channel
1152  ********************************************************************
1153  * DESCRIPTION:  Internal function to create a PKTIO infrastructure DMA channel
1154  *               for infrastructure DMQ queue
1155  ********************************************************************/
1156 int netapip_pktioCreateIFDMA(PKTIO_HANDLE_T * p )
1158    int dmaChan =  p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
1159    unsigned char           isAllocated;
1160    Cppi_TxChInitCfg        txChCfg;
1161    Cppi_RxChInitCfg        rxChCfg;
1162    Cppi_CpDmaInitCfg       cpdmaCfg;
1164     /* Set up QMSS CPDMA configuration */
1165     memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
1166     cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
1168     /* Open QMSS CPDMA */
1169     p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
1170     if (p->cppiHnd == NULL)
1171     {
1172         return -1;
1173     }
1175  /* Set up Tx Channel parameters */
1176     memset ((void *) &txChCfg, 0, sizeof (Cppi_TxChInitCfg));
1177     txChCfg.channelNum = dmaChan;
1178     txChCfg.priority = 0;
1179     txChCfg.filterEPIB = 0;
1180     txChCfg.filterPS = 0;
1181     txChCfg.aifMonoMode = 0;
1182     txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
1184     /* Open Tx Channel */
1185     p->txChHnd = (Cppi_ChHnd) Cppi_txChannelOpen (p->cppiHnd, &txChCfg, &isAllocated);
1186     if (p->txChHnd == NULL)
1187     {
1188         Cppi_close(p->cppiHnd);
1189         return -1;
1190     }
1192      /* Set up Rx Channel parameters */
1193     memset ((void *) &rxChCfg, 0, sizeof (Cppi_RxChInitCfg));
1194     rxChCfg.channelNum = dmaChan;
1195     rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
1197     /* Open Rx Channel */
1198     p->rxChHnd = (Cppi_ChHnd) Cppi_rxChannelOpen (p->cppiHnd, &rxChCfg, &isAllocated);
1199     if (p->rxChHnd == NULL)
1200     {
1201         Cppi_channelClose(p->txChHnd);
1202         Cppi_close(p->cppiHnd);
1203         return -1;
1204     }
1205     if (Cppi_channelEnable (p->txChHnd) != CPPI_SOK)
1206     {
1207         Cppi_channelClose(p->txChHnd);
1208         Cppi_channelClose(p->rxChHnd);
1209         Cppi_close(p->cppiHnd);
1210         return -1;
1211     }
1213     /* Enable receive channel */
1214     if (Cppi_channelEnable (p->rxChHnd) != CPPI_SOK)
1215     {
1216         Cppi_channelDisable (p->txChHnd);
1217         Cppi_channelClose(p->txChHnd);
1218         Cppi_channelClose(p->rxChHnd);
1219         Cppi_close(p->cppiHnd);
1220         return -1;
1221     }
1222     return 1;
1225 /**********************************************************************
1226  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for packet reception
1227  **********************************************************************
1228  * DESCRIPTION:  Callback that gets registered with NWAL for packet reception
1229  * appCookie is the pktio handle 
1230  **********************************************************************/
1231 void netapip_pktioNWALRxPktCallback(uint32_t            appCookie,
1232                               uint16_t             numPkts,
1233                               nwalRxPktInfo_t*    pPktInfo,
1234                               uint64_t            timestamp,
1235                               nwal_Bool_t*        pFreePkt)
1237     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1238     int r=0;
1239     int n;
1240     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1241     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1243     for(r=0;r<numPkts;r++)
1244     {
1245         pkt_list[r] = pPktInfo[r].pPkt;
1246         meta_s[r].flags1 = PKTIO_META_RX;
1247         meta_s[r].u.rx_meta = &pPktInfo[r];
1248     }
1249     if (r)
1250     {
1251         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
1252     }
1256 /**********************************************************************
1257  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for crypto reception
1258  **********************************************************************
1259  * DESCRIPTION:  Callback that gets registered with NWAL for crypto reception,
1260  * appCookie is the pktio handle 
1261  **********************************************************************/
1262 void netapip_pktioNWALSBPktCallback(uint32_t            appCookie,
1263                               uint16_t             numPkts,
1264                               nwalDmRxPayloadInfo_t*  pDmRxPktInfo,
1265                               nwal_Bool_t*        pFreePkt)
1267     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1268     int r=0;
1269     int n;
1270     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1271     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1272     for(r=0;r<numPkts;r++)
1273     {
1274         pkt_list[r] = pDmRxPktInfo[r].pPkt;
1275         meta_s[r].flags1 =  PKTIO_META_SB_RX;
1276         meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
1277     }
1278     if (r)
1279     {
1280         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
1281     }