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 #include <ti/csl/csl_qm_queue.h>
  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     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);
 114
 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     }
 126
 127     return 1;
 128 }
 129
 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)
 143 {
 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;
 148
 149
 150     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
 151
 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);
 161
 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     }
 173
 174     return 1;
 175 }
 176
 177
 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)
 191 {
 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;
 196
 197     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
 198
 199
 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);
 209
 210         pPloadDesc = Pktlib_getDescFromPacket(pkt);
 211         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
 212
 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     }
 222
 223     return 1;
 224 }
 225
 226
 227
 228
 229
 230
 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)
 244 {
 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;
 249
 250     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
 251
 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);
 266
 267         pPloadDesc = Pktlib_getDescFromPacket(pkt);
 268         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
 269
 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     }
 279
 280     return 1;
 281 }
 282
 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)
 296 {
 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;
 301
 302
 303     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
 304
 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);
 319
 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;
 330 }
 331
 332
 333
 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)
 347 {
 348
 349     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
 350     nwalTxPktInfo_t *pTxPktInfo = m->u.tx_meta;
 351     Cppi_HostDesc*          pPloadDesc;
 352
 353     nwal_mCmdSetL4CkSumPort(pkt,
 354                             &p->tx_psCmdInfo,
 355                             pTxPktInfo->l4OffBytes,
 356                             pTxPktInfo->l4HdrLen + pTxPktInfo->ploadLen,
 357                             pTxPktInfo->pseudoHdrChecksum,
 358                             pTxPktInfo->enetPort);
 359
 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;
 366 }
 367
 368
 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)
 380 {
 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);
 390
 391     Qmss_queuePushDescSizeRaw(p->tx_psCmdInfo.txQueue,
 392                                   pPloadDesc,
 393                                   NWAL_DESC_SIZE);
 394     return 1;
 395 }
 396
 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)
 406 {
 407     PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
 408     err=0;
 409     Qmss_queuePushDesc (p->q, (void*)pkt);
 410     return 1;
 411 }
 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)
 421 {
 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;
 434 }
 435
 436
 437
 438
 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)
 449 {
 450
 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;
 459
 460     NETCP_CFG_SA_T tunnel_id = (NETCP_CFG_SA_T) m->sa_handle;
 461
 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);
 487
 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);
 494
 495                 printf("phy Addr: 0x%x\n", pPloadDesc->softwareInfo1);
 496                 printf("virtAddr: 0x%x\n", virtAddr);
 497
 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
 503
 504
 505         pPloadDesc = Osal_qmssConvertDescVirtToPhy(0, pPloadDesc);
 506
 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     }
 516
 517     return 1;
 518 }
 519
 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)
 529 {
 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);
 538
 539         Qmss_queuePushDescSizeRaw(p->q,
 540                                   pPloadDesc,
 541                                   NWAL_DESC_SIZE);
 542         return 1;
 543 }
 544
 545
 546
 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)
 556 {
 557     *err =  NETAPI_ERR_BAD_INPUT;
 558     return -1;
 559 }
 560
 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)
 569 {
 570     *err= NETAPI_ERR_BAD_INPUT;
 571     return 0;
 572 }
 573
 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)
 582 {
 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     {
 593
 594         temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
 595
 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;
 606 }
 607
 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)
 616 {
 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;
 629 }
 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)
 638 {
 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;
 649 }
 650
 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)
 659 {
 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);
 671
 672     return r;
 673 }
 674
 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)
 685 {
 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;
 696 }
 697
 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)
 709 {
 710     int r = 0;
 711     PKTIO_HANDLE_T *p;
 712     uint8_t         isAllocated;
 713
 714     *err=0;
 715     int q = QMSS_PARAM_NOT_SPECIFIED;
 716
 717     int qtype = Qmss_QueueType_GENERAL_PURPOSE_QUEUE;
 718
 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;
 727
 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;};
 731
 732     /* get a free channel handle */
 733     p=netapip_pktioGetFreeChannelSlot(n);
 734
 735     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
 736
 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));
 743
 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     }
 753
 754
 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     }
 766
 767     p->qInfo = Qmss_getQueueNumber(p->q);
 768
 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     }
 806
 807     /* save name */
 808     strncpy(p->name,name,
 809        strlen(name)<PKTIO_MAX_NAME ?
 810                strlen(name):PKTIO_MAX_NAME);
 811
 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     }
 824
 825   ((NETAPI_HANDLE_T *)n )->n_pktios+=1;
 826    return p;
 827 }
 828
 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)
 839 {
 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;
 846
 847
 848     if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
 849
 850     /* get a free channel handle */
 851
 852     p=netapip_pktioGetFreeChannelSlot(n);
 853
 854     if (!p) {*err = NETAPI_ERR_NOMEM; return (p); }
 855     ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
 856
 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));
 864
 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         }
 902
 903         hplib_mSpinLockUnlock(&pnetapiShm->netapi_pktio_lock);
 904         p_qnum = netapip_findGlobalPktio(n, name);
 905
 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       }
 913
 914      /* open a general queue (for now). use qnum that was just found */
 915          p->q  = Qmss_queueOpen(qtype,
 916                            p_qnum->qNum , &isAllocated);
 917         if (p->q == (Qmss_QueueHnd) NULL)
 918         {
 919             netapi_Log("netapi_pktioCreate:  queueOpen failed\n");
 920             p->inuse=0;
 921             *err= NETAPI_ERR_QLLD;  ///queue lld error
 922             return NULL;
 923         }
 924         p->qInfo = Qmss_getQueueNumber(p->q);
 925         netapi_Log("netapi_pktioOpen: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
 926         if (p_cfg->flags2 & PKTIO_PKT)
 927         {
 928            p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
 929            p->_poll = netapip_pktioPollNwalAdj;
 930            p->nwalInstanceHandle = netapip_returnNwalInstanceHandle(n);
 931            netapi_Log("netapi_pktioOpen: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
 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     }
 951
 952         /* save name */
 953         strncpy(p->name,name,
 954            strlen(name)<PKTIO_MAX_NAME ?
 955                    strlen(name):PKTIO_MAX_NAME);
 956
 957         netapi_Log("netapi_pktioOpen: returning with sucess for name %s\n", p->name);
 958     return p;
 959 }
 960
 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)
 971 {
 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     }
1057
1058     *err = NETAPI_ERR_OK;
1059     return;
1060 }
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)
1068 {
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;
1083 }
1084
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)
1092 {
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     }
1103
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 ;
1117 }
1118
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)
1129 {
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;
1136 }
1137
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)
1148 {
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;
1164
1165 }
1166
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)
1173 {
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;
1180 }
1181
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 )
1189 {
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;
1195
1196     /* Set up QMSS CPDMA configuration */
1197     memset ((void *) &cpdmaCfg, 0, sizeof (Cppi_CpDmaInitCfg));
1198     cpdmaCfg.dmaNum = Cppi_CpDma_QMSS_CPDMA;
1199
1200     /* Open QMSS CPDMA */
1201     p->cppiHnd = (Cppi_Handle) Cppi_open (&cpdmaCfg);
1202     if (p->cppiHnd == NULL)
1203     {
1204         return -1;
1205     }
1206
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;
1215
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     }
1223
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;
1228
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     }
1244
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;
1255 }
1256
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)
1268 {
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];
1274
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     }
1285 }
1286
1287
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)
1298 {
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     }
1314 }
1315