Set qmQueMgmtProxyDataReg to NULL for k1, k2h
[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 static hplib_spinLock_T netapi_pktio_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
57 /* Utilites*/
58 static PKTIO_HANDLE_T * netapip_pktioGetFreeChannelSlot(NETAPI_T n)
59 {
60     PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
61     int i;
62     hplib_mSpinLockLock(&netapi_pktio_lock);
63     for(i=0;i<NETAPI_MAX_PKTIO;i++)
64     {
65         if (pp[i]->inuse != PKTIO_INUSE)
66         {
67             pp[i]->inuse = PKTIO_INUSE;
68             hplib_mSpinLockUnlock(&netapi_pktio_lock);
69             return  pp[i];
70         }
71     }
72     hplib_mSpinLockUnlock(&netapi_pktio_lock);
73     return NULL;
74 }
77 /*Optimized send functions */
80 /********************************************************************
81  * FUNCTION PURPOSE: Send packet via low level NWAL API's
82  * with updates for L4 checksum,ESP Crypto and outgoing EMAC port 
83  * to NetCP command.
84  ********************************************************************
85  * DESCRIPTION: Send packet via low level NWAL API's
86  * with updates for L4 checksum,ESP Crypto and outgoing EMAC port 
87  * to NetCP command.
88  ********************************************************************/
89 static int netapip_pktioSendL4CkSumCryptPort(struct PKTIO_HANDLE_tag * pp,
90                                             Ti_Pkt *pkt,
91                                             PKTIO_METADATA_T *m,
92                                             int * err)
93 {
94     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
95     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
96     Cppi_HostDesc*          pPloadDesc;
97     uint32_t swInfo0, swInfo1;
99     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
101     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
102     {
103         nwal_mCmdSetL4CkSumCrypPort(pkt,
104                                     &p->tx_psCmdInfo,
105                                     pTxPktInfo->l4OffBytes, 
106                                     pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
107                                     pTxPktInfo->pseudoHdrChecksum, 
108                                     pTxPktInfo->saOffBytes, 
109                                     pTxPktInfo->saPayloadLen, 
110                                     swInfo0, 
111                                     swInfo1,
112                                     0);
114         pPloadDesc = Pktlib_getDescFromPacket(pkt);
115         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
116         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
117                                   pPloadDesc,
118                                   NWAL_DESC_SIZE);
119     }
120     else
121     {
122           *err=NETAPI_ERR_BAD_INPUT;
123           return -1;
124     }
126     return 1;
129 /********************************************************************
130  * FUNCTION PURPOSE: Send packet via low level NWAL API's
131  * with updates for ESP Crypto and outgoing EMAC port 
132  * to NetCP command.
133  ********************************************************************
134  * DESCRIPTION: Send packet via low level NWAL API's
135  * with updates for ESP Crypto and outgoing EMAC port 
136  * to NetCP command.
137  ********************************************************************/
138 static int netapip_pktioSendCryptPort(struct PKTIO_HANDLE_tag * pp,
139                                      Ti_Pkt *pkt,
140                                      PKTIO_METADATA_T *m,
141                                      int * err)
143     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
144     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
145     Cppi_HostDesc*          pPloadDesc;
146     uint32_t swInfo0, swInfo1;
148     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
150     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
151     {
152         nwal_mCmdSetCrypPort(pkt,
153                              &p->tx_psCmdInfo,
154                               pTxPktInfo->saOffBytes, 
155                               pTxPktInfo->saPayloadLen, 
156                               swInfo0, 
157                               swInfo1,
158                               0);
160         pPloadDesc = Pktlib_getDescFromPacket(pkt);
161         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
162         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
163                                   pPloadDesc,
164                                   NWAL_DESC_SIZE);
165     }
166     else
167     {
168           *err=NETAPI_ERR_BAD_INPUT;
169           return -1;
170     }
172     return 1;
175 /********************************************************************
176  * FUNCTION PURPOSE: Send packet via low level NWAL API's
177  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
178  * to NetCP command.
179  *******************************************************************
180  * DESCRIPTION: Send packet via low level NWAL API's
181  * with updates for L4 checksum,AH Crypto and outgoing EMAC port 
182  * to NetCP command.
183  ********************************************************************/
184 static int netapip_pktioSendL4CkSumAHCryptPort(struct PKTIO_HANDLE_tag * pp,
185                                               Ti_Pkt *pkt,
186                                               PKTIO_METADATA_T *m,
187                                               int * err)
189     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
190     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
191     Cppi_HostDesc*          pPloadDesc;
192     uint32_t swInfo0, swInfo1;
194     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
196     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
197     {
198         nwal_mCmdSetL4CkSumAHCrypPort(pkt,
199                                 &p->tx_psCmdInfo,
200                                 pTxPktInfo->l4OffBytes, 
201                                 pTxPktInfo->ploadLen + pTxPktInfo->l4HdrLen, 
202                                 pTxPktInfo->pseudoHdrChecksum, 
203                                 pTxPktInfo->saOffBytes, 
204                                 pTxPktInfo->saPayloadLen, 
205                                 swInfo0, 
206                                 swInfo1,
207                                 pTxPktInfo->saAhIcvOffBytes,
208                                 pTxPktInfo->saAhMacSize,
209                                 pTxPktInfo->enetPort);
211         pPloadDesc = Pktlib_getDescFromPacket(pkt);
212         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
213         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
214                                   pPloadDesc,
215                                   NWAL_DESC_SIZE);
216     }
217     else
218     {
219           *err=NETAPI_ERR_BAD_INPUT;
220           return -1;
221     }
223     return 1;
226 /********************************************************************
227  * FUNCTION PURPOSE: Send packet via low level NWAL API's
228  * with updates for AH Crypto and outgoing EMAC port 
229  * to NetCP command.
230  ********************************************************************
231  * DESCRIPTION: Send packet via low level NWAL API's
232  * with updates for AH Crypto and outgoing EMAC port 
233  * to NetCP command.
234  ********************************************************************/
235 static int netapip_pktioSendAHCryptPort(struct PKTIO_HANDLE_tag * pp,
236                                        Ti_Pkt *pkt,
237                                        PKTIO_METADATA_T *m,
238                                        int * err)
240     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
241     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
242     Cppi_HostDesc*          pPloadDesc;
243     uint32_t swInfo0, swInfo1;
245     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
247     if (netapip_netcpCfgGetSaInflowInfo(&netapi_get_global()->nwal_context, tunnel_id, &swInfo0, &swInfo1))
248     {
249         nwal_mCmdSetAHCrypPort(pkt,
250                                 &p->tx_psCmdInfo,
251                                 pTxPktInfo->saOffBytes, 
252                                 pTxPktInfo->saPayloadLen, 
253                                 swInfo0, 
254                                 swInfo1,
255                                 pTxPktInfo->saAhIcvOffBytes,
256                                 pTxPktInfo->saAhMacSize,
257                                 pTxPktInfo->enetPort);
258         
259         pPloadDesc = Pktlib_getDescFromPacket(pkt);
260         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
261         Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
262                                   pPloadDesc,
263                                   NWAL_DESC_SIZE);
264     }
265     else
266     {
267        *err= NETAPI_ERR_BAD_INPUT;
268        return -1;
269     }
270     return 1;
275 /********************************************************************
276  * FUNCTION PURPOSE: Send packet via low level NWAL API's
277  * with updates for L4 checksum and outgoing EMAC port 
278  * to NetCP command.
279  *******************************************************************
280  * DESCRIPTION: Send packet via low level NWAL API's
281  * with updates for L4 checksum and outgoing EMAC port 
282  * to NetCP command.
283  ********************************************************************/
284 static int netapip_pktioSendL4CkSumPort(struct PKTIO_HANDLE_tag * pp,
285                                       Ti_Pkt *pkt,
286                                       PKTIO_METADATA_T *m,
287                                       int * err)
290     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
291     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
292     Cppi_HostDesc*          pPloadDesc;
293     nwal_mCmdSetL4CkSumPort(pkt,
294                             &p->tx_psCmdInfo,
295                             pTxPktInfo->l4OffBytes,
296                             pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
297                             pTxPktInfo->pseudoHdrChecksum,
298                             pTxPktInfo->enetPort);
300     pPloadDesc = Pktlib_getDescFromPacket(pkt);
301     pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
302     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
303                                   pPloadDesc,
304                                   NWAL_DESC_SIZE);
308 /********************************************************************
309  * FUNCTION PURPOSE: Send packet via low level NWAL API's
310  * with updates for outgoing EMAC port to NetCP command.
311  ********************************************************************
312  * DESCRIPTION: Send packet via low level NWAL API's
313  * with updates for outgoing EMAC port to NetCP command.
314  ********************************************************************/
315 static int netapip_pktioSendPort(struct PKTIO_HANDLE_tag * pp,
316                                 Ti_Pkt *pkt, 
317                                 PKTIO_METADATA_T *m, 
318                                 int * err)
320     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
321     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
322     Cppi_HostDesc*          pPloadDesc;
323     nwal_mCmdSetPort(pkt,
324                                 &p->tx_psCmdInfo,
325                                  pTxPktInfo->enetPort);
326     pPloadDesc = Pktlib_getDescFromPacket(pkt);
327     pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
328     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
329                                   pPloadDesc,
330                                   NWAL_DESC_SIZE);
331     return 1;
334 /********************************************************************
335  * FUNCTION PURPOSE: Send packet via IPC queue
336  ********************************************************************
337  * DESCRIPTION: Send packet via IPC queue
338  ********************************************************************/
339 static int netapip_pktioSendIpc(struct PKTIO_HANDLE_tag * pp,
340                                Ti_Pkt *pkt,
341                                PKTIO_METADATA_T *m,
342                                int * err)
344     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
345     err=0;
346     Qmss_queuePushDesc (p->q, (void*)pkt);
347     return 1;
349 /********************************************************************
350  * FUNCTION PURPOSE: Send packet to NETCP via NWAL
351  ********************************************************************
352  * DESCRIPTION: Send packet to NETCP via NWAL
353  ********************************************************************/
354 static int netapip_pktioSendNwal(struct PKTIO_HANDLE_tag * pp,
355                                 Ti_Pkt *pkt,
356                                 PKTIO_METADATA_T *m,
357                                 int * err)
359     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
360     nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
361     nwal_RetValue res;
362     *err=0;
363     pPktInfo->pPkt = pkt;
364     res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
365     if (res != nwal_OK)
366     {
367         *err = NETAPI_ERR_NWAL_TX_ERR -res;
368         return -1;
369     }
370     return 1;
373 /********************************************************************
374  * FUNCTION PURPOSE: Send packet to SA via NWAL
375  ********************************************************************
376  * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode 
377  * channel via NWAL
378  ********************************************************************/
379 static int netapip_pktioSendSb(struct PKTIO_HANDLE_tag * pp,
380                               Ti_Pkt *pkt, 
381                               PKTIO_METADATA_T *m, 
382                               int * err)
385     nwal_RetValue nwalRetVal;
386     nwalTxDmPSCmdInfo_t     *dmPSCmdInfo;
387     nwalLocCxtInfo_t    nwalLocCxt;
388     Cppi_HostDesc*          pPloadDesc;
389     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
390     nwalLocCxtInfo_t      info;
391     nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
393     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
395     dmPSCmdInfo = netapip_netcpCfgGetSaSBInfo(&netapi_get_global()->nwal_context, tunnel_id);
396     if (dmPSCmdInfo)
397     {
398         nwalRetVal = nwal_getLocCxtInfo(pktio_mGetNwalInstance(p),&info);
399         if(nwalRetVal == nwal_OK)
400         {
401             dmPSCmdInfo->rxSbSaQ = info.rxSbSaQ;
402         }
403         else
404         {
405             *err=NETAPI_ERR_BAD_INPUT;
406             return -1;
407         }
408         nwal_mCmdDMUpdate(pkt,
409             dmPSCmdInfo,
410             pPktInfoSB->appCtxId,
411             pPktInfoSB->encOffset,
412             pPktInfoSB->encSize,
413             pPktInfoSB->pEncIV,
414             pPktInfoSB->authOffset,
415             pPktInfoSB->authSize,
416             pPktInfoSB->pAuthIV,
417             pPktInfoSB->aadSize,
418             pPktInfoSB->pAad);
419         pPloadDesc = Pktlib_getDescFromPacket(pkt);
420         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
421         Qmss_queuePushDescSizeRaw(dmPSCmdInfo->txQueue,
422                                              pPloadDesc,
423                                              NWAL_DESC_SIZE); 
424     }
425     else
426     {
427           *err=NETAPI_ERR_BAD_INPUT;
428           return -1;
429     }
431     return 1;
434 /********************************************************************
435  * FUNCTION PURPOSE: Send packet via infrastructure DMA channel
436  ********************************************************************
437  * DESCRIPTION: Send packet via infrastructure DMA channel
438  ********************************************************************/
439 static int netapip_pktioSendIfdma(struct PKTIO_HANDLE_tag * pp,
440                                  Ti_Pkt *pkt, 
441                                  PKTIO_METADATA_T *m, 
442                                  int * err)
444         Cppi_DescTag            tag={0};
445         Cppi_HostDesc*          pPloadDesc;
446         PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
447         *err=0;
448         tag.srcTagLo = m->u.tx_ifdma_dest;
449         Cppi_setTag (Cppi_DescType_HOST, (Cppi_Desc *)pkt, &tag);
450         pPloadDesc = Pktlib_getDescFromPacket(pkt);
451         pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
452         Qmss_queuePushDescSizeRaw(p->q,
453                                   pPloadDesc,
454                                   NWAL_DESC_SIZE);
455         return 1;
460 /********************************************************************
461  * FUNCTION PURPOSE: Stub function for send, do nothing.
462  ********************************************************************
463  * DESCRIPTION: Stub function for send, do nothing.
464  ********************************************************************/
465 static int netapip_pktioSendDummy(struct PKTIO_HANDLE_tag * p,
466                                  Ti_Pkt *pkt, 
467                                  PKTIO_METADATA_T *m, 
468                                  int * err)
470     *err =  NETAPI_ERR_BAD_INPUT;
471     return -1;
474 /********************************************************************
475  * FUNCTION PURPOSE: Stub function for poll, do nothing.
476  ********************************************************************
477  * DESCRIPTION: Stub function for send, do nothing.
478  ********************************************************************/
479 static int netapip_pktioPollDummy(struct PKTIO_HANDLE_tag * p, 
480                                  PKTIO_POLL_T * p_poll_cfg,
481                                  int * err)
483     *err= NETAPI_ERR_BAD_INPUT;
484     return 0;
487 /********************************************************************
488  * FUNCTION PURPOSE: Poll IPC queue
489  ********************************************************************
490  * DESCRIPTION: Poll IPC queue
491  ********************************************************************/
492 static int netapip_pktioPollIpc(struct PKTIO_HANDLE_tag * pp, 
493                                PKTIO_POLL_T * p_poll_cfg,  
494                                int * err)
496     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
497     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
498     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
499     int r=0;
500     int n;
501     Ti_Pkt * temp;
502     *err=0;
503     n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
504     for(r=0;r<n;r++)
505     {
507         temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
509         if(!temp) break;
510         /* process meta data */
511         pkt_list[r]= temp;
512         meta_s[r].flags1=0x1;
513     }
514     if (r)
515     {
516         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
517     }
518     return r;
521 /********************************************************************
522  * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
523  ********************************************************************
524  * DESCRIPTION: Poll nwal data queues for pkts from netcp
525  ********************************************************************/
526 static int netapip_pktioPollNwal(struct PKTIO_HANDLE_tag * pp, 
527                                 PKTIO_POLL_T * p_poll_cfg,  
528                                 int * err)
530     int r=0;
531     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
532     *err=0;
533     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
534         set.  optimizaion maybe? */
535     r=nwal_pollPkt(p->nwalInstanceHandle,
536                    p->poll_flags,
537                    (uint32_t) p,
538                    p->max_n,
539                    QMSS_PARAM_NOT_SPECIFIED,
540                    (void*) NULL);
541     return r;
543 /********************************************************************
544  * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
545  ********************************************************************
546  * DESCRIPTION: Poll nwal sideband queues for pkts from SA
547  ********************************************************************/
548 static int  netapip_pktioPollSb(struct PKTIO_HANDLE_tag * pp, 
549                                PKTIO_POLL_T * p_poll_cfg,  
550                                int * err)
552     int r=0;
553     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
554     *err=0;
555     r=nwal_pollDm(p->nwalInstanceHandle,
556                     nwal_POLL_DM_DEF_SB_SA_Q,
557                      (uint32_t) p,
558                      p->max_n,
559                      QMSS_PARAM_NOT_SPECIFIED,
560              (void *) NULL);
561     return r;
564 /********************************************************************
565  * FUNCTION PURPOSE: Poll application provided NETCP RX queue
566  ********************************************************************
567  * DESCRIPTION: Poll application provided NETCP RX queue
568  ********************************************************************/
569 static int netapip_pktioPollNwalAdj(struct PKTIO_HANDLE_tag * pp, 
570                                    PKTIO_POLL_T * p_poll_cfg,  
571                                    int * err)
573     int r=0;
574     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
575     *err=0;
576     /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
577          set. optimizaion maybe? */
578     r=nwal_pollPkt(p->nwalInstanceHandle,
579                    nwal_POLL_APP_MANAGED_PKT_Q,
580                    (uint32_t) p,
581                    p->max_n,
582                    p->q,
583                    (void *) NULL);
585     return r;
588 /*************************************************************************
589  * FUNCTION PURPOSE: Poll application defined sideband queues for packets
590  *                   from SA
591  ************************************************************************
592  * DESCRIPTION: Poll application defined sideband queues for packets
593  *                   from SA
594  *************************************************************************/
595 static int  netapip_pktioPollSbAdj(struct PKTIO_HANDLE_tag * pp, 
596                                   PKTIO_POLL_T * p_poll_cfg,  
597                                   int * err)
599     int r=0;
600     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
601     *err=0;
602     r=nwal_pollDm(p->nwalInstanceHandle,
603                      nwal_POLL_DM_APP_MANAGED_Q,
604                      (uint32_t) p,
605                      p->max_n,
606                      p->q,
607                      (void *)  NULL);
608     return r;
611 /*-----------------------MAIN API----------------------*/
612 /********************************************************************
613  * FUNCTION PURPOSE:  API creates a NETAPI PKTIO channel 
614  ********************************************************************
615  * DESCRIPTION:  API creates a NETAPI PKTIO channel 
616  ********************************************************************/
617 PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T n,
618                                     char * name,
619                                     PKTIO_CB cb, 
620                                     PKTIO_CFG_T * p_cfg, 
621                                     int * err)
623     int r = 0;
624     PKTIO_HANDLE_T *p;
625     uint8_t         isAllocated;
627     *err=0;
628     int q= QMSS_PARAM_NOT_SPECIFIED;
629     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
631     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
632     if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
633     if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
635     /* get a free channel handle */
636     p=netapip_pktioGetFreeChannelSlot(n);
638     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
640     p->back = n;
641     p->cb = cb;
642     p->max_n = p_cfg->max_n;
643     p->_poll=netapip_pktioPollDummy;
644     p->_send=netapip_pktioSendDummy;
645     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
647     if (p_cfg->qnum!=PKTIO_Q_ANY)
648     {
649         q= p_cfg->qnum;
650     }
651     /* special case for infrastructure dma channels */
652     if (p_cfg->flags2 & PKTIO_IFDMA)
653     {
654         qtype=Qmss_QueueType_INFRASTRUCTURE_QUEUE;
655     }
658     /* create a  general queue */
659      p->q  = Qmss_queueOpen(qtype,
660                                 q, 
661                                 &isAllocated);
662     if (p->q == (Qmss_QueueHnd) NULL)
663     {
664         netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
665         p->inuse=0;
666         *err= NETAPI_ERR_QLLD;  ///queue lld error
667         return NULL;
668     }
669     p->qInfo = Qmss_getQueueNumber(p->q);
670     if (p_cfg->flags2 & PKTIO_PKT)
671     {
672         p->use_nwal = PKTIO_4_ADJ_NWAL;
673         p->_poll=netapip_pktioPollNwalAdj;
674         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
675     }
676     else if (p_cfg->flags2 & PKTIO_SB)
677     {
678         p->use_nwal = PKTIO_4_ADJ_SB;
679         p->_poll=netapip_pktioPollSbAdj;
680         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
681     }
682    else if (p_cfg->flags2 & PKTIO_IFDMA)
683    {
684         p->use_nwal = 0;
685         p->_send = netapip_pktioSendIfdma;
686         p->cfg.flags1=PKTIO_TX;
687         r= netapip_pktioCreateIFDMA(p); //we create the IF DMA channel here
688         if (r<0) 
689         {
690             //trouble -> couldn't set up DMA 
691             //close queue and return failure
692             if (p->q)
693             {
694                 Qmss_queueClose(p->q);
695             }
696             p->inuse=0;
697             *err= NETAPI_ERR_QLLD;  ///queue lld error TODO: fix error code 
698             return NULL;
699         }
700    }
701     else
702     {
703         p->use_nwal=0;
704         if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
705         if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
706     }
708     /* save name */ 
709     strncpy(p->name,name,
710        strlen(name)<PKTIO_MAX_NAME ?
711                strlen(name):PKTIO_MAX_NAME);   
713     /* add name, qnum to global name list */
714     if ((strcmp(name,NETCP_RX)) &&
715         (strcmp(name,NETCP_TX)) &&
716         (strcmp(name,NETCP_SB_RX)) &&
717         (strcmp(name,NETCP_SB_TX)) &&
718         (p_cfg->flags1 & PKTIO_GLOBAL))
719     {
720          //todo: make sure this succeeds..
721         hplib_mSpinLockLock(&netapi_pktio_lock);
722         r=netapip_addGlobalPktio(n, name, &p->qInfo);
723         hplib_mSpinLockUnlock(&netapi_pktio_lock);
724     }
726   ((NETAPI_HANDLE_T *)n )->n_pktios+=1;
727    return p;
730 /********************************************************************
731  * FUNCTION PURPOSE:  API opens an existing  NETAPI PKTIO channel
732  ********************************************************************
733  * DESCRIPTION:  API opens an existing  NETAPI PKTIO channel
734  ********************************************************************/
735 PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T  n,
736                                   char *name,
737                                   PKTIO_CB cb,
738                                   PKTIO_CFG_T * p_cfg,
739                                   int * err)
741     int r=0;
742     PKTIO_HANDLE_T *p, *p2;
743     uint8_t         isAllocated;
744     *err=0;
745     Qmss_Queue *p_qnum;
746     int qtype=Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
749     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
751     /* get a free channel handle */
753     p=netapip_pktioGetFreeChannelSlot(n);
755     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
756     ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
758     p->inuse= PKTIO_INUSE;
759     p->back = n;
760     p->cb = cb;
761     p->max_n = p_cfg->max_n;
762     p->_poll=netapip_pktioPollDummy;
763     p->_send=netapip_pktioSendDummy;
764     memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
766     /* special handling of NETCP_RX, NETCP_TX */
767     if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
768     {
769        /* these have already been opened internally, so don't search in global list */
770         p->use_nwal = PKTIO_DEF_NWAL;
771         p->q = 0;  
772         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
773         if (!strcmp(name,NETCP_RX))
774         {
775             p->_poll=netapip_pktioPollNwal; 
776             p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
777                                     nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
778         }
779         if (!strcmp(name,NETCP_TX))
780         {
781             p->_send=netapip_pktioSendNwal;
782         }
783     }
784     else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
785     {
786        /* these have already been opened internally, so don't search in global list */
787         p->use_nwal =  PKTIO_DEF_SB;
788         p->q = 0;
789         p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
790         if (!strcmp(name,NETCP_SB_RX)) p->_poll=netapip_pktioPollSb;
791         if (!strcmp(name,NETCP_SB_TX)) p->_send=netapip_pktioSendSb;
792     }
793     else
794     {
795         hplib_mSpinLockLock(&netapi_pktio_lock); 
796         /* Find queue in global list 
797            Note names like "QUEUE:%d" or IFDMA:%d cause general purpose or
798            IFDMA queues of that number to be opened */
799         if (p_cfg->flags2 & PKTIO_IFDMA)
800         {
801             qtype= Qmss_QueueType_INFRASTRUCTURE_QUEUE;
802         }
804         hplib_mSpinLockUnlock(&netapi_pktio_lock);
805         p_qnum = netapip_findGlobalPktio(n, name);
807         if (!p_qnum ) 
808         {
809             netapi_Log("netapi_pktioOpen: can't find %s\n",name);
810             p->inuse=0;
811             *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
812             return NULL;
813       }
815      /* open a general queue (for now). use qnum that was just found */
816          p->q  = Qmss_queueOpen(qtype,
817                            p_qnum->qNum , &isAllocated);
818         if (p->q == (Qmss_QueueHnd) NULL)
819         {
820             netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
821             p->inuse=0;
822             *err= NETAPI_ERR_QLLD;  ///queue lld error
823             return NULL;
824         }
825         p->qInfo = Qmss_getQueueNumber(p->q);
826         netapi_Log("netapi_pktioOpen: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
827         if (p_cfg->flags2 & PKTIO_PKT)
828         {
829            p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
830            p->_poll = netapip_pktioPollNwalAdj;
831            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n); 
832            netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
833         } 
834         else if (p_cfg->flags2 & PKTIO_SB)
835         {
836            p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
837            p->_poll = netapip_pktioPollSbAdj;
838            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
839         }
840         else if (p_cfg->flags2 & PKTIO_IFDMA)
841         {
842             p->_send= netapip_pktioSendIfdma;
843             p->use_nwal = 0;
844         }
845         else
846         {
847            p->use_nwal=0; //not handled by nwal
848             if (p_cfg->flags1& PKTIO_TX) p->_send=netapip_pktioSendIpc;
849             if (p_cfg->flags1& PKTIO_RX) p->_poll=netapip_pktioPollIpc;
850         }
851     }
853         /* save name */
854         strncpy(p->name,name,
855            strlen(name)<PKTIO_MAX_NAME ?
856                    strlen(name):PKTIO_MAX_NAME);
858         netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
859     return p;
862 /********************************************************************
863  * FUNCTION PURPOSE:  API controls an existing NETAPI PKTIO channel
864  ********************************************************************
865  * DESCRIPTION:  API controls an existing NETAPI PKTIO channel
866  ********************************************************************/
867 void netapi_pktioControl(PKTIO_HANDLE_T * p,
868                          PKTIO_CB cb,
869                          PKTIO_CFG_T * p_cfg,
870                          PKTIO_CONTROL_T * p_control,
871                          int *err)
873     nwal_RetValue       nwalRetVal;
874     if (!p)
875     {
876         *err= NETAPI_ERR_BAD_INPUT; 
877         return;
878     }
879     if (cb) 
880     {
881         p->cb = cb;
882     }
883     if (p_control)
884     {
885         /* todo: check for validity, eg don't allow clear of NETCP TX queues */
886         /* todo: implement divert */
887         switch(p_control->op)
888         {
889             //clear the queue
890             case(PKTIO_SET_POLL_FLAGS):
891                 p->poll_flags=p_control->poll_flags;
892                 break;
893             case(PKTIO_CLEAR):
894                 netapip_zapQ(p->q);
895                 break;
896             case (PKTIO_UPDATE_FAST_PATH):
897                 if (p_cfg)
898                 {
899                     nwalRetVal = nwal_initPSCmdInfo(p->nwalInstanceHandle, 
900                                                             p_cfg->fast_path_cfg.txPktInfo,
901                                                             &p->tx_psCmdInfo);
902                     if (nwalRetVal == nwal_OK)
903                     {
904                         switch (p_cfg->fast_path_cfg.fp_send_option)
905                         {
906                             case (PKTIO_FP_ESP_L4CKSUM_PORT):
907                                 p->_send = netapip_pktioSendL4CkSumCryptPort;
908                                 break;
909                             case (PKTIO_FP_AH_L4CKSUM_PORT):
910                                 p->_send = netapip_pktioSendL4CkSumAHCryptPort;
911                                 break;
912                             case (PKTIO_FP_ESP_PORT):
913                                 p->_send = netapip_pktioSendCryptPort;
914                                 break;
915                             case (PKTIO_FP_AH_PORT):
916                                 p->_send = netapip_pktioSendAHCryptPort;
917                                 break;
918                             case (PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT):
919                                 p->_send = netapip_pktioSendPort;
920                                 break;
921                             case (PKTIO_FP_L4CKSUM_PORT):
922                                 p->_send = netapip_pktioSendL4CkSumPort;
923                                 break;
924                             default:
925                                 break;
926                         }
927                     }
928                     else
929                     {
930                         *err = NETAPI_ERR_BAD_INPUT;
931                     }
932                 }
933                 else
934                 {
935                     *err = NETAPI_ERR_BAD_INPUT;
936                 }
937                 break;
938             case (PKTIO_UPDATE_MAX_PKTS_PER_POLL):
939                 if (p_cfg)
940                 {
941                     p->max_n = p_cfg->max_n;
942                 }
943                 else
944                 {
945                     *err = NETAPI_ERR_BAD_INPUT;
946                 }
947                 break;
948             case(PKTIO_DIVERT):
949             default:
950                 netapi_Log("netapi_pktioControl: pktio_control op %d not implemented\n",p_control->op);
951                 *err= NETAPI_ERR_NOT_IMPLEMENTED;
952                 break;
953         }
954     }
956     *err = NETAPI_ERR_OK;
957     return;
959 /********************************************************************
960  * FUNCTION PURPOSE:  API closes a NETAPI PKTIO channel
961  ********************************************************************
962  * DESCRIPTION:  API closes a NETAPI PKTIO channel
963  ********************************************************************/
964 void netapi_pktioClose(PKTIO_HANDLE_T * p, 
965                        int * err)
967     if(!p)
968     {
969         *err=1;
970         return;
971     }
972     *err=0;
973     if (p->q)
974     {
975         Qmss_queueClose(p->q);
976     }
977     p->q=-1;
978     p->inuse=0;
979     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
980     return;
983 /********************************************************************
984  * FUNCTION PURPOSE:  API deletes a NETAPI PKTIO channel
985  ********************************************************************
986  * DESCRIPTION:  API deletes a NETAPI PKTIO channel
987  ********************************************************************/
988 void netapi_pktioDelete(PKTIO_HANDLE_T * p, 
989                         int * err)
991     if(!p)
992     {
993         *err=1;
994         return;
995     }
996     *err=0;
997     if (p->cfg.flags2 & PKTIO_IFDMA)
998     {
999         netapip_pktioDeleteIFDMA(p);
1000     }
1002         /* remove from name list */
1003     hplib_mSpinLockLock(&netapi_pktio_lock);
1004         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
1005     hplib_mSpinLockUnlock(&netapi_pktio_lock);
1006         if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB)) 
1007     {
1008                 netapip_zapQ(p->q);   //since we are deleting, zap the queue 
1009             Qmss_queueClose(p->q);
1010     }
1011     p->q=-1;
1012     p->inuse=0;
1013     ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
1014     return ;
1017 /********************************************************************
1018  * FUNCTION PURPOSE:  API sends multiple packets to a NETAPI PKTIO channel
1019  ********************************************************************
1020  * DESCRIPTION:  API sends multiple packets to a NETAPI PKTIO channel
1021  ********************************************************************/
1022 int netapi_pktioSendMulti(PKTIO_HANDLE_T * p, 
1023                           Ti_Pkt * pkt[], 
1024                           PKTIO_METADATA_T * m[], 
1025                           int np, 
1026                           int* err)
1028     int r=0;
1029     for(r=0;r<np;r++)
1030     {
1031         p->_send((struct PKTIO_HANDLE_tag *)p, (Ti_Pkt *)pkt, (PKTIO_METADATA_T *)m, err);
1032     }
1033     return r;
1036 /********************************************************************
1037  * FUNCTION PURPOSE:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1038  * instance for received packets
1039  ********************************************************************
1040  * DESCRIPTION:  API polls all NETAPI PKTIO channels associated with NETAPI_T
1041  * instance for received packets
1042  ********************************************************************/
1043 int netapi_pktioPollAll(NETAPI_T  handle, 
1044                         PKTIO_POLL_T * p_poll_cfg, 
1045                         int *err)
1047     int i=0;
1048     int r=0;
1049     int err2;
1050     int cnt=0;
1051     PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
1052     
1053     *err=0;
1054     for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
1055     {
1056         if (pp[i]->inuse != PKTIO_INUSE) continue;
1057         if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
1058         r+=netapi_pktioPoll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
1059         if (err2) { *err = err2; break;}
1060     }
1061     return r;
1065 /********************************************************************
1066  * FUNCTION PURPOSE:  Internal function to delete a PKTIO infrastructure DMA channel
1067  ********************************************************************
1068  * DESCRIPTION:  Internal function to delete a PKTIO infrastructure DMA channel
1069  ********************************************************************/
1070 int netapip_pktioDeleteIFDMA(PKTIO_HANDLE_T *p)
1072         Cppi_channelDisable (p->txChHnd);
1073         Cppi_channelDisable (p->rxChHnd);
1074         Cppi_channelClose(p->txChHnd);
1075         Cppi_channelClose(p->rxChHnd);
1076         Cppi_close(p->cppiHnd);
1077         return 1;
1080 /********************************************************************
1081  * FUNCTION PURPOSE:  Internal function to create a PKTIO infrastructure DMA channel
1082  ********************************************************************
1083  * DESCRIPTION:  Internal function to create a PKTIO infrastructure DMA channel
1084  *               for infrastructure DMQ queue
1085  ********************************************************************/
1086 int netapip_pktioCreateIFDMA(PKTIO_HANDLE_T * p )
1088    int dmaChan =  p->qInfo.qNum - QMSS_INFRASTRUCTURE_QUEUE_BASE;
1089    unsigned char           isAllocated;
1090    Cppi_TxChInitCfg        txChCfg;
1091    Cppi_RxChInitCfg        rxChCfg;
1092    Cppi_CpDmaInitCfg       cpdmaCfg;
1094     /* Set up QMSS CPDMA configuration */
1095     memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
1096     cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
1098     /* Open QMSS CPDMA */
1099     p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
1100     if (p->cppiHnd == NULL)
1101     {
1102         return -1;
1103     }
1105  /* Set up Tx Channel parameters */
1106     memset ((void *) &txChCfg, 0, sizeof (Cppi_TxChInitCfg));
1107     txChCfg.channelNum = dmaChan;
1108     txChCfg.priority = 0;
1109     txChCfg.filterEPIB = 0;
1110     txChCfg.filterPS = 0;
1111     txChCfg.aifMonoMode = 0;
1112     txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
1114     /* Open Tx Channel */
1115     p->txChHnd = (Cppi_ChHnd) Cppi_txChannelOpen (p->cppiHnd, &txChCfg, &isAllocated);
1116     if (p->txChHnd == NULL)
1117     {
1118         Cppi_close(p->cppiHnd);
1119         return -1;
1120     }
1122      /* Set up Rx Channel parameters */
1123     memset ((void *) &rxChCfg, 0, sizeof (Cppi_RxChInitCfg));
1124     rxChCfg.channelNum = dmaChan;
1125     rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
1127     /* Open Rx Channel */
1128     p->rxChHnd = (Cppi_ChHnd) Cppi_rxChannelOpen (p->cppiHnd, &rxChCfg, &isAllocated);
1129     if (p->rxChHnd == NULL)
1130     {
1131         Cppi_channelClose(p->txChHnd);
1132         Cppi_close(p->cppiHnd);
1133         return -1;
1134     }
1135     if (Cppi_channelEnable (p->txChHnd) != CPPI_SOK)
1136     {
1137         Cppi_channelClose(p->txChHnd);
1138         Cppi_channelClose(p->rxChHnd);
1139         Cppi_close(p->cppiHnd);
1140         return -1;
1141     }
1143     /* Enable receive channel */
1144     if (Cppi_channelEnable (p->rxChHnd) != CPPI_SOK)
1145     {
1146         Cppi_channelDisable (p->txChHnd);
1147         Cppi_channelClose(p->txChHnd);
1148         Cppi_channelClose(p->rxChHnd);
1149         Cppi_close(p->cppiHnd);
1150         return -1;
1151     }
1152     return 1;
1155 /**********************************************************************
1156  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for packet reception
1157  **********************************************************************
1158  * DESCRIPTION:  Callback that gets registered with NWAL for packet reception
1159  * appCookie is the pktio handle 
1160  **********************************************************************/
1161 void netapip_pktioNWALRxPktCallback(uint32_t            appCookie,
1162                               uint16_t             numPkts,
1163                               nwalRxPktInfo_t*    pPktInfo,
1164                               uint64_t            timestamp,
1165                               nwal_Bool_t*        pFreePkt)
1167     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1168     int r=0;
1169     int n;
1170     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1171     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1173     for(r=0;r<numPkts;r++)
1174     {
1175         pkt_list[r] = pPktInfo[r].pPkt;
1176         meta_s[r].flags1 = PKTIO_META_RX;
1177         meta_s[r].u.rx_meta = &pPktInfo[r];
1178     }
1179     if (r)
1180     {
1181         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
1182     }
1186 /**********************************************************************
1187  * FUNCTION PURPOSE:  Internal Callback that gets registered with NWAL for crypto reception
1188  **********************************************************************
1189  * DESCRIPTION:  Callback that gets registered with NWAL for crypto reception,
1190  * appCookie is the pktio handle 
1191  **********************************************************************/
1192 void netapip_pktioNWALSBPktCallback(uint32_t            appCookie,
1193                               uint16_t             numPkts,
1194                               nwalDmRxPayloadInfo_t*  pDmRxPktInfo,
1195                               nwal_Bool_t*        pFreePkt)
1197     PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
1198     int r=0;
1199     int n;
1200     Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
1201     PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
1202     for(r=0;r<numPkts;r++)
1203     {
1204         pkt_list[r] = pDmRxPktInfo[r].pPkt;
1205         meta_s[r].flags1 =  PKTIO_META_SB_RX;
1206         meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
1207     }
1208     if (r)
1209     {
1210         p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
1211     }