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