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