changes to support:
authorDavid Lide <a0216552@gtudci01.(none)>
Thu, 23 Feb 2012 22:57:26 +0000 (17:57 -0500)
committerDavid Lide <a0216552@gtudci01.(none)>
Thu, 23 Feb 2012 22:57:26 +0000 (17:57 -0500)
  - adding/deleting flows
  - support for routes now when configuring netcp
  - other misc.

19 files changed:
ti/runtime/netapi/netapi.h
ti/runtime/netapi/netapi_err.h
ti/runtime/netapi/netapi_tune.h
ti/runtime/netapi/netcp_cfg.h
ti/runtime/netapi/pktio.h
ti/runtime/netapi/src/netapi.c
ti/runtime/netapi/src/netapi_init.c
ti/runtime/netapi/src/netapi_loc.h
ti/runtime/netapi/src/netapi_sched.c
ti/runtime/netapi/src/netapi_timer.c
ti/runtime/netapi/src/netapi_util.h
ti/runtime/netapi/src/netapi_vm.h
ti/runtime/netapi/src/netcp_cfg.c
ti/runtime/netapi/src/osal.c
ti/runtime/netapi/src/pktio.c
ti/runtime/netapi/src/tim64.c
ti/runtime/netapi/src/timer_loc.h
ti/runtime/netapi/src/timlist.c
ti/runtime/netapi/test/net_test.c

index 0f0f31ee839c20fe75bebc42f9e13095d55db77c..e803e864a3299989696207ad5a2ea06f38325db3 100644 (file)
@@ -222,8 +222,7 @@ int  netapi_getDescRemainder(void);
  *  @pre        @ref netapi_init  \r
  */\r
 static inline NETCP_CFG_FLOW_HANDLE_T netapi_getDefaultFlow(NETAPI_T p) {\r
-NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;\r
-return pp->def_flow;\r
+return NETCP_DEFAULT_FLOW;\r
 }\r
 \r
 /* utility to get default route */\r
@@ -238,8 +237,8 @@ return pp->def_flow;
  *  @pre        @ref netapi_init  \r
  */\r
 static inline NETCP_CFG_ROUTE_HANDLE_T netapi_getDefaultRoute(NETAPI_T p) {\r
-NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;\r
-return pp->def_route;}\r
+return NETCP_DEFAULT_ROUTE;\r
+}\r
 \r
 /* utility to set/get a cookie in the netapi handle */\r
 /**  @ingroup netapi_api_functions */\r
index 6cf7f30ac8fe65f84e953cab260923e81c64bbef..fc301d62960130b574b4893c2a23917f18a87b82 100644 (file)
  */\r
 #define NETAPI_ERR_NOT_IMPLEMENTED -7\r
 /**\r
+*  @ingroup NETAPI_RetValue\r
+ *  @def  NETAPI_ERR_NORES\r
+ *      no free (hw) resources available \r
+ */\r
+#define NETAPI_ERR_NORES -8\r
+/**\r
 *  @ingroup NETAPI_RetValue\r
  *  @def  NETAPI_ERR_ALREADY_CANCELLED\r
  *       timer has already been cancelled\r
index 858e68a6447a02ca649dba8c3048d841d94581de..e96fdbad8660fe83bb718228c618b9699621d9b5 100644 (file)
 \r
 //(16) classifiers\r
 #define TUNE_NETAPI_MAX_CLASSIFIERS 16\r
+\r
+//(17) FLows\r
+#define TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW  4  //!!do not change!!\r
+#define TUNE_NETAPI_MAX_FLOWS  4   //app defined flows\r
 #endif\r
index ce16af86a81e789b39aa919384dce9e798db5cff..49635c0c4895e510170dba1b0512aaf7ddebb885 100644 (file)
@@ -54,30 +54,26 @@ typedef struct NETCP_CFG_FLOW_Tag
        int flowid;\r
 } NETCP_CFG_FLOW_T;\r
 typedef void *  NETCP_CFG_FLOW_HANDLE_T;\r
-\r
+#define NETCP_DEFAULT_FLOW  (NETCP_CFG_FLOW_HANDLE_T*) NULL\r
 \r
 //NETCP ROUTE\r
 typedef struct NETCP_CFG_ROUTE_Tag\r
 {\r
-   NETCP_CFG_FLOW_HANDLE_T p_flow;\r
-   PKTIO_HANDLE_T * p_dest_q;\r
-   int nextAction;\r
+   NETCP_CFG_FLOW_T * p_flow;  //NULL or NETCP_DEFAULT_FLOW for default flow\r
+   PKTIO_HANDLE_T * p_dest_q;       //NULL for default destination queue\r
 } NETCP_CFG_ROUTE_T;\r
-typedef void * NETCP_CFG_ROUTE_HANDLE_T;\r
+typedef void * NETCP_CFG_ROUTE_HANDLE_T;  \r
+#define NETCP_DEFAULT_ROUTE  (NETCP_CFG_ROUTE_HANDLE_T*) NULL\r
+\r
 \r
 /*--------------flow management--------*/\r
 NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T ,\r
                                             int n, \r
                                             Pktlib_HeapHandle handles[],\r
+                                           int sizes[],\r
                                             int * err );\r
 void netcp_cfgDelFlow(NETAPI_T , NETCP_CFG_FLOW_HANDLE_T , int * err);\r
 \r
-/*------------Routes------------------*/\r
-NETCP_CFG_ROUTE_HANDLE_T netcp_cfgAddRoute(NETAPI_T ,int nh, \r
-                                               Pktlib_HeapHandle heaps[],\r
-                                               int *err );\r
-void netcp_cfgDelRoute(NETAPI_T , NETCP_CFG_ROUTE_HANDLE_T, int *err );\r
-\r
 /*-----------Actions----------*/\r
 #define NETCP_CFG_ACTION_DISCARD 0\r
 #define NETCP_CFG_ACTION_CONTINUE 1  //pass packet on to next classifier\r
index f59851b57e4a99fe130a0a28922971deb4f853cb..4ffd90c26eeae322260d2e628256ed7d1e79fcea 100644 (file)
@@ -290,5 +290,5 @@ int pktio_pollAll(NETAPI_T handle, PKTIO_POLL_T * p_poll_cfg, int *err);
 #define pktio_get_netapi_handle(handle) (handle)->back\r
 #define pktio_set_cookie(handle, cookie) (handle)->cookie = cookie\r
 #define pktio_get_cookie(handle) (handle)->cookie\r
-\r
+#define pktio_get_q(handle) (handle)->q\r
 #endif\r
index 89bf6935bd1f6a733020405528ebb13a0a24fd36..dc60bcc9126cb32b6211b75f9a42c3c0919f7eb3 100644 (file)
@@ -148,7 +148,7 @@ void netapi_shutdown(NETAPI_T h)
        NETAPI_HANDLE_T * p = (NETAPI_HANDLE_T *) h;\r
        if (!p) return;\r
 \r
-        printf(">netapi:  shutdown not fully implemented\n");\r
+        printf(">netapi: WARNING shutdown may not be fully implemented\n");\r
        if (p->master)\r
         {\r
            /* close nwal */\r
@@ -163,7 +163,7 @@ void netapi_shutdown(NETAPI_T h)
            {\r
                 if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}\r
            }\r
-           netapi_cleanup_at_start();  //clear 1st 50 queues..\r
+           netapi_cleanup_at_start();  //clear 1st 50 not-specified queues..\r
         } \r
        free(p);\r
         return;\r
@@ -349,7 +349,7 @@ for (i=0;;i+=1 )
                 }\r
                 else {/*printf("netapi qzap in play\n");*/}\r
         }\r
-        if(i) printf(">netapi: @recovery -  %d descriptors cleaned\n",i);\r
+        if(i) printf(">netapi: @recovery -  %d descriptors cleaned from qn %d\n",i, queueNum);\r
 }\r
 \r
 //defensive: clean out stuff hanging around\r
index dd76161faeeabbce7085858f6094db7b331a1ba6..08be3a95d5badaa7f2d79510d3bc5b43f130e387 100644 (file)
-/************************************************
-*  FILE:  netapi_init.c
-*  Global, local initialization of NETAPI
- *
- * DESCRIPTION: Functions to initialize framework resources for running NETAPI
- *
- * REVISION HISTORY:
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ***********************************************/
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <unistd.h>
-
-#include <ti/drv/nwal/nwal.h>
-#include "netapi.h"
-#include "netapi_vm.h"
-#include "netapi_loc.h"
-#include "ti/drv/nwal/nwal.h"
-
-/* CSL RL includes */
-#include <ti/csl/cslr_device.h>
-#include <ti/csl/cslr_qm_config.h>
-#include <ti/csl/cslr_qm_descriptor_region_config.h>
-#include <ti/csl/cslr_qm_queue_management.h>
-#include <ti/csl/cslr_qm_queue_status_config.h>
-#include <ti/csl/cslr_qm_intd.h>
-#include <ti/csl/cslr_pdsp.h>
-#include <ti/csl/csl_qm_queue.h>
-#include <ti/csl/cslr_cppidma_global_config.h>
-#include <ti/csl/cslr_cppidma_rx_channel_config.h>
-#include <ti/csl/cslr_cppidma_rx_flow_config.h>
-#include <ti/csl/cslr_cppidma_tx_channel_config.h>
-#include <ti/csl/cslr_cppidma_tx_scheduler_config.h>
-#include <ti/csl/csl_cppi.h>
-#include <ti/csl/csl_pscAux.h>
-#include <ti/csl/csl_semAux.h>
-#include <ti/csl/csl_cacheAux.h>
-#include <ti/csl/csl_xmcAux.h>
-#include <ti/csl/csl_cpsw_3gfAux.h>
-#include <ti/csl/csl_cpsw.h>
-#include <ti/csl/csl_cpsgmiiAux.h>
-#include <ti/drv/qmss/qmss_qm.h>
-//pull in device config for qmss, cppi
-#include <ti/drv/qmss/device/qmss_device.c>
-#include <ti/drv/cppi/device/cppi_device.c>
-
-/* TODO verify: */
-#define CACHE_LINESZ    64
-
-#define System_printf   printf
-#define ALIGN(x)    __attribute__((aligned (x)))
-
-/*****************************************************************************
- * Global Resources shared by all Cores
- *****************************************************************************/
-uint8_t *QMemGlobDescRam = 0;
-uint8_t *cppiMemPaSaLinkBuf = 0;
-uint8_t *cppiMemSaPaLinkBuf = 0;
-
-/*****************************************************************************
- * Local Resource allocated at each Core
- *****************************************************************************/
-/* Descriptors in global shared */
-uint8_t *QMemLocDescRam = NULL;
-uint8_t *cppiMemRxPktLinkBuf = NULL;
-uint8_t *cppiMemTxPktLinkBuf = NULL;
-uint8_t *cppiMemRxCtlLinkBuf = NULL;
-uint8_t *cppiMemTxCtlLinkBuf = NULL;
-
-
-//****************************************************
-// initialize CPSW (switch) [per SOC]
-//***************************************************
-int netapi_init_cpsw(void)
-{
-    CSL_CPSW_3GF_ALE_PORTCONTROL        alePortControlCfg;
-
-    CSL_CPSW_3GF_clearAleTable();
-
-    alePortControlCfg.dropUntaggedEnable    =   0;
-    alePortControlCfg.vidIngressCheckEnable =   0;
-
-    alePortControlCfg.mcastLimit            =   0;
-    alePortControlCfg.bcastLimit            =   0;
-
-    /* Disable learning mode for Port 0 */
-    alePortControlCfg.noLearnModeEnable     =   1;
-    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;
-    CSL_CPSW_3GF_setAlePortControlReg (0, &alePortControlCfg);
-
-    /* Enable learning mode for Port 1 */
-    alePortControlCfg.noLearnModeEnable     =   0;
-    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;
-    CSL_CPSW_3GF_setAlePortControlReg (1, &alePortControlCfg);
-
-    /* Enable learning mode for Port 2 */
-    alePortControlCfg.noLearnModeEnable     =   0;
-    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;
-    CSL_CPSW_3GF_setAlePortControlReg (2, &alePortControlCfg);
-
-    return 1;
-}
-
-//****************************************************
-// initialize QM (per SOC)
-//***************************************************
-int netapi_init_qm(void)
-{
-  Qmss_InitCfg     qmssInitConfig;
-  int32_t          result;
-  Qmss_GlobalConfigParams nwalTest_qmssGblCfgParams;
-
-  memset (&qmssInitConfig, 0, sizeof (Qmss_InitCfg));
-
-  /* Use Internal Linking RAM for optimal performance */
-  qmssInitConfig.linkingRAM0Base = 0;
-  qmssInitConfig.linkingRAM0Size = 0;
-  qmssInitConfig.linkingRAM1Base = 0;
-  qmssInitConfig.maxDescNum      = TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM;
-  qmssInitConfig.qmssHwStatus =QMSS_HW_INIT_COMPLETE; //bypass some of the hw init
-  nwalTest_qmssGblCfgParams = qmssGblCfgParams[0];
-
-  nwalTest_qmssGblCfgParams.qmConfigReg = (void *)((uint8_t *)netapi_VM_qmssCfgVaddr +
-      (CSL_QM_SS_CFG_CONFIG_STARVATION_COUNTER_REGS - CSL_QM_SS_CFG_QUE_PEEK_REGS));
-  nwalTest_qmssGblCfgParams.qmDescReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_DESCRIPTION_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmQueMgmtReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_QM_QUEUE_DEQUEUE_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmQueMgmtProxyReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_PROXY_QUEUE_DEQUEUE_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmQueStatReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmQueIntdReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_INTD_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspCmdReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM1_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspCmdReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspCtrlReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_ADSP1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspCtrlReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_ADSP2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspIRamReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_APDSP1_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmPdspIRamReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_APDSP2_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmStatusRAM = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_QM_STATUS_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmLinkingRAMReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_LINKING_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmMcDMAReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_MCDMA_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmTimer16Reg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_TIMER1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmTimer16Reg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-      ((uint32_t)CSL_QM_SS_CFG_TIMER2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
-  nwalTest_qmssGblCfgParams.qmQueMgmtDataReg = (void *)((uint32_t)netapi_VM_qmssDataVaddr);
-  nwalTest_qmssGblCfgParams.qmQueMgmtProxyDataReg = 
-      (void *)((uint32_t)netapi_VM_qmssDataVaddr + ((uint32_t)(0x44040000) - (uint32_t)(0x44020000)));
-
-  result = Qmss_init (&qmssInitConfig, &nwalTest_qmssGblCfgParams);
-  if (result != QMSS_SOK)  {
-    System_printf (">function init_qm: qmss_Init failed with error code %d\n", result);
-    return (nwal_FALSE);
-  }
-
-       return 1;
-}
-
-//****************************************************
-// Set up  QM memory region (per SOC)
-//***************************************************
-int netapi_qm_setup_mem_region(
-                      uint32_t          numDesc,
-                      uint32_t          descSize,
-                      uint32_t*         pDescMemBase,
-                      Qmss_MemRegion    memRegion)
-{
-  Qmss_MemRegInfo   memInfo;
-  Int32             result;
-  Int               n;
-  static int  netapi_qm_region_index=0;
-
-  memset(&memInfo,0,sizeof(Qmss_MemRegInfo));
-  memInfo.descBase       = pDescMemBase;
-  memInfo.descSize       = descSize;
-  memInfo.descNum        = numDesc;
-  memInfo.manageDescFlag = Qmss_ManageDesc_MANAGE_DESCRIPTOR;
-  memInfo.memRegion      = memRegion==NETAPI_GLOBAL_REGION ? Qmss_MemRegion_MEMORY_REGION0 : Qmss_MemRegion_MEMORY_REGION1;
-
-  if(memRegion == NETAPI_GLOBAL_REGION)
-  {
-      memInfo.startIndex = 0;
-      netapi_qm_region_index += numDesc;
-  }else if(memRegion ==NETAPI_LOCAL_REGION)
-  {
-      /* Global shared memory for all descriptors to all cores */
-      memInfo.startIndex     = netapi_qm_region_index;
-  }
-  else
-  {
-      return -1 ;
-  }
-
-  result = Qmss_insertMemoryRegion (&memInfo);
-  if (result < QMSS_SOK)  
-  {
-    printf (">function setup_qm_region: Qmss_insertMemoryRegion returned error code %d\n", result);
-    return (-1);
-  }
-
-  return 1;
-
-}
-
-//****************************************************
-// Start QM (per thread)
-//***************************************************
-int netapi_start_qm(void)
-{
-     int32_t          result;
-     result = Qmss_start();
-     if (result != QMSS_SOK)
-     {
-         System_printf (">start_qm: Qmss_start failed with error code %d\n", result);
-         return (-1);
-     }
-     return 1;
-}
-
-//*************************************************
-//initilaize CPPI (once per soc)
-//*************************************************
-int netapi_init_cppi(void)
-{
-  int32_t result, i;
-  Cppi_GlobalConfigParams nwalTest_cppiGblCfgParams[CPPI_MAX_CPDMA];
-
-  for (i=0; i<CPPI_MAX_CPDMA; i++)
-    nwalTest_cppiGblCfgParams[i] = cppiGblCfgParams[i];
-
-  /* SRIO CPDMA regs */
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs =
-      (void *)((uint32_t)netapi_VM_srioCfgVaddr +
-               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs =
-      (void *)((uint32_t)netapi_VM_srioCfgVaddr +
-               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs =
-      (void *)((uint32_t)netapi_VM_srioCfgVaddr +
-               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs =
-      (void *)((uint32_t)netapi_VM_srioCfgVaddr +
-               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs =
-      (void *)((uint32_t)netapi_VM_srioCfgVaddr +
-               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-
-  /* PASS CPDMA regs */
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs =
-      (void *)((uint32_t)netapi_VM_passCfgVaddr +
-               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs =
-      (void *)((uint32_t)netapi_VM_passCfgVaddr +
-               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs =
-      (void *)((uint32_t)netapi_VM_passCfgVaddr +
-               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs =
-      (void *)((uint32_t)netapi_VM_passCfgVaddr +
-               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs =
-      (void *)((uint32_t)netapi_VM_passCfgVaddr +
-               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- /* QMSS CPDMA regs */
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs =
-      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs =
-      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs =
-      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs =
-      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs =
-      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
-               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-
-  result = Cppi_init (nwalTest_cppiGblCfgParams);
-  if (result != CPPI_SOK)  
-  {
-    printf (">function cppi_init: Cppi_init failed with error code %d\n", result);
-    return (-1);
-  }
-   return 1;
-}
-
-//*************************************************
-//initialize NWAL (one per soc) 
-//*************************************************
-/*** NWAL Memory Buffer Configuration ***/
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE     3400
-uint8_t nwalInstMem[NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE]ALIGN(CACHE_LINESZ);
-
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC                    128
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN      256
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP                     128
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT                   128
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR               128
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT            384
-#define NWAL_CHAN_HANDLE_SIZE    ((NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC * TUNE_NETAPI_MAX_NUM_MAC) + \
-                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) + \
-                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP * TUNE_NETAPI_MAX_NUM_IP) + \
-                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT * TUNE_NETAPI_MAX_NUM_PORTS)+ \
-                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT * TUNE_NETAPI_NUM_CORES) + \
-                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR * TUNE_NETAPI_MAX_NUM_L2_L3_HDRS))
-
-uint8_t nwalHandleMem[NWAL_CHAN_HANDLE_SIZE]ALIGN(CACHE_LINESZ);
-
-/* todo: Check if below size information can be made available from pa interface file */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0      128
-/* PA instance */
-/* Memory used for the PA Instance. Needs to be assigned global uncached memory for chip */
-uint8_t paBuf0[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0]ALIGN(CACHE_LINESZ);
-
-/* Memory used for PA handles */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1    128
-uint8_t paBuf1[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1]ALIGN(CACHE_LINESZ);
-
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2    256
-uint8_t paBuf2[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2]ALIGN(CACHE_LINESZ);
-
-/* Memory used for SA LLD global Handle */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE    384
-uint8_t salldHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE]ALIGN(CACHE_LINESZ);
-
-/* Memory used for SA LLD global Handle */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN             384
-uint8_t saContext[NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS]ALIGN(CACHE_LINESZ);
-
-/* Memory used by SA LLD per Channel */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN          512
-uint8_t salldChanHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS]ALIGN(CACHE_LINESZ);
-
-
-/*******************************************
- * Initialize the nwal subsystem for NETAPI use
- ***********************************************/
-int netapi_init_nwal(
-     int region2use,  
-     Pktlib_HeapIfTable * p_table,
-     NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context )
-{
-    nwalSizeInfo_t  nwalSizeInfo;
-    nwalMemBuf_t    nwalMemBuf[nwal_N_BUFS];
-    nwal_RetValue   nwalRetVal;
-    nwalGlobCfg_t   nwalGlobCfg;
-    uint8_t         count;
-    int             sizes[nwal_N_BUFS];
-    int             aligns[nwal_N_BUFS];
-    void*           bases[nwal_N_BUFS];
-
-    memset(p_nwal_context,0,sizeof( NETAPI_NWAL_GLOBAL_CONTEXT_T) );
-    memset(&nwalGlobCfg,0,sizeof(nwalGlobCfg_t ) );
-
-
-    /* Initialize Buffer Pool for NetCP PA to SA packets */
-    nwalGlobCfg.pa2SaBufPool.numBufPools = 1;
-    nwalGlobCfg.pa2SaBufPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalGlobCfg.pa2SaBufPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
-    nwalGlobCfg.pa2SaBufPool.bufPool[0].heapHandle =
-    Pktlib_createHeap("nwal PA2SA",
-                       region2use,
-                       0,
-                       TUNE_NETAPI_DEFAULT_BUFFER_SIZE,
-                       TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC,
-                       0,
-                       p_table);
-    if(nwalGlobCfg.pa2SaBufPool.bufPool[0].heapHandle == NULL)
-    {
-        printf (">Pktlib_createHeap:Heap Creation Failed for PA to SA Buffer Pool \n");
-        netapi_err_teardown(); 
-        return -1;
-    }
-
- /* Initialize Buffer Pool for NetCP SA to PA packets */
-    nwalGlobCfg.sa2PaBufPool.numBufPools = 1;
-    nwalGlobCfg.sa2PaBufPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalGlobCfg.sa2PaBufPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
-
-    nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle =
-        Pktlib_createHeap("nwal SA2PA",
-                          region2use,
-                          0,
-                          TUNE_NETAPI_DEFAULT_BUFFER_SIZE,
-                          TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC,
-                          0,
-                          p_table);
-    if(nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle == NULL)
-    {
-        printf (">Pktlib_createHeap:Heap Creation Failed for SA to PA Buffer Pool \n");
-        netapi_err_teardown();
-        return -1;
-    }
-
-    nwalGlobCfg.hopLimit = 5;/* Default TTL / Hop Limit */
-    nwalGlobCfg.lpbackPass = TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;
-    nwalGlobCfg.paFwActive = nwal_TRUE;
-    nwalGlobCfg.saFwActive = nwal_TRUE;
-
-    /* Pick Default Physical Address */
-    nwalGlobCfg.paVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr;
-    nwalGlobCfg.saVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr +
-                                 ((uint32_t)CSL_PA_SS_CFG_CP_ACE_CFG_REGS - (uint32_t)CSL_PA_SS_CFG_REGS) ;
-    nwalGlobCfg.rxDefPktQ = QMSS_PARAM_NOT_SPECIFIED;
-
-    /* Get the Buffer Requirement from NWAL */
-    memset(&nwalMemBuf,0,sizeof(nwalMemBuf));
-    memset(&nwalSizeInfo,0,sizeof(nwalSizeInfo));
-    nwalSizeInfo.nMaxMacAddress = TUNE_NETAPI_MAX_NUM_MAC;
-    nwalSizeInfo.nMaxIpAddress = TUNE_NETAPI_MAX_NUM_IP;
-    nwalSizeInfo.nMaxL4Ports = TUNE_NETAPI_MAX_NUM_PORTS;
-    nwalSizeInfo.nMaxIpSecChannels = TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS;
-    nwalSizeInfo.nMaxL2L3Hdr = TUNE_NETAPI_MAX_NUM_L2_L3_HDRS;
-    nwalSizeInfo.nProc = TUNE_NETAPI_NUM_CORES;
-    for(count=0;count < nwal_N_BUFS;count++)
-    {
-        nwalMemBuf[count].cacheLineSize = CACHE_LINESZ;
-    }
-    nwalRetVal = nwal_getBufferReq(&nwalSizeInfo,
-                                   sizes,
-                                   aligns);
-    if(nwalRetVal != nwal_OK)
-    {
-        printf (">netapi: init_nwal - nwal_getBufferReq Failed %d\n", nwalRetVal);
-        return nwal_FALSE;
-    }
-
-/* Check for memory size requirement and update the base */
-    count = 0;
-    bases[nwal_BUF_INDEX_INST] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalInstMem);
-    if(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE < sizes[nwal_BUF_INDEX_INST])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-
-    bases[nwal_BUF_INDEX_INT_HANDLES] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalHandleMem);
-    if(NWAL_CHAN_HANDLE_SIZE  < sizes[nwal_BUF_INDEX_INT_HANDLES])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-     bases[nwal_BUF_INDEX_PA_LLD_BUF0] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf0);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0) < sizes[nwal_BUF_INDEX_PA_LLD_BUF0])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-
-    bases[nwal_BUF_INDEX_PA_LLD_BUF1] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf1);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1) < sizes[nwal_BUF_INDEX_PA_LLD_BUF1])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-
-     bases[nwal_BUF_INDEX_PA_LLD_BUF2] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf2);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2) < sizes[nwal_BUF_INDEX_PA_LLD_BUF2])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-#ifdef NETAPI_ENABLE_SECURITY
-    bases[nwal_BUF_INDEX_SA_LLD_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldHandle);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE) < sizes[nwal_BUF_INDEX_SA_LLD_HANDLE])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-
-    bases[nwal_BUF_INDEX_SA_CONTEXT] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)saContext);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) <
-        sizes[nwal_BUF_INDEX_SA_CONTEXT])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-
-    bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldChanHandle);
-    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) <
-        sizes[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE])
-    {
-        /* Resize Memory */
-        while(1);
-    }
-    count++;
-#else
-    bases[nwal_BUF_INDEX_SA_LLD_HANDLE] = 0;
-    bases[nwal_BUF_INDEX_SA_CONTEXT] = 0;
-    bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = 0;
-    count = count+3;
-#endif
-    if(count != nwal_N_BUFS)
-    {
-        while(1);
-    }
-
-    /* Initialize NWAL module */
-    nwalRetVal = nwal_create(&nwalGlobCfg,
-                             &nwalSizeInfo,
-                             sizes,
-                             bases,
-                             &p_nwal_context->nwalInstHandle);
-    if(nwalRetVal != nwal_OK)
-    {
-        printf (">netapi: init_nwal- nwal_create Failed %d\n",nwalRetVal);
-        while(1);
-    }
-
-    printf(">netapi: init_nwal - Global and Local Network initialization Successful \n");
-    return 1;
-}
-
-//*************************************************
-//* Local (per thread/core) nwal initialization0
-//**************************************************
-int netapi_start_nwal(Pktlib_HeapHandle pkt_heap,
-                    Pktlib_HeapHandle cmd_heap,
-                     NETAPI_NWAL_LOCAL_CONTEXT_T *p,
-                     NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_glob_context  )
-{
-    nwalLocCfg_t    nwalLocCfg;
-    int count;
-    nwal_RetValue       nwalRetVal;
-
-    memset(&nwalLocCfg,0,sizeof(nwalLocCfg));
-
-    /* Common Initialization for all cores */
-    while(count < TUNE_NETAPI_MAX_NUM_TRANS)
-    {
-        p_nwal_glob_context->transInfos[count].transId = count;
-        count++;
-    }
-
- /* Call back registration for the core */
-    nwalLocCfg.pRxPktCallBack = netapi_NWALRxPktCallback;
-    nwalLocCfg.pCmdCallBack = netapi_NWALCmdCallBack;
-    nwalLocCfg.pPaStatsCallBack = netapi_NWALCmdPaStatsReply;
-
-    /* Initialize Buffer Pool for Control packets from NetCP to Host */
-    nwalLocCfg.rxCtlPool.numBufPools = 1;
-    nwalLocCfg.rxCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalLocCfg.rxCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
-    nwalLocCfg.rxCtlPool.bufPool[0].heapHandle = cmd_heap;
-
-    /* Initialize Buffer Pool for Control packets from Host to NetCP */
-    nwalLocCfg.txCtlPool.numBufPools = 1;
-    nwalLocCfg.txCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalLocCfg.txCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
-    nwalLocCfg.txCtlPool.bufPool[0].heapHandle =  cmd_heap;
-
-/* Initialize Buffer Pool for Packets from NetCP to Host */
-    nwalLocCfg.rxPktPool.numBufPools = 1;
-    nwalLocCfg.rxPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalLocCfg.rxPktPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
-    nwalLocCfg.rxPktPool.bufPool[0].heapHandle = pkt_heap;
-
-/* Initialize Buffer Pool for Packets from Host to NetCP */
-    nwalLocCfg.txPktPool.numBufPools = 1;
-    nwalLocCfg.txPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
-    nwalLocCfg.txPktPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
-    nwalLocCfg.txPktPool.bufPool[0].heapHandle = pkt_heap;
-
-    memcpy(&p->nwalLocCfg,&nwalLocCfg,sizeof(nwalLocCfg_t));
-    while(1)
-    {
-        nwalRetVal = nwal_start(p_nwal_glob_context->nwalInstHandle,&nwalLocCfg);
-        if(nwalRetVal == nwal_ERR_INVALID_STATE)
-        {
-            continue;
-        }
-        break;
-    }
-
-    if(nwalRetVal != nwal_OK)
-    {
-        printf (">nwal_start:Failed ->err %d !!!\n", nwalRetVal);
-        return -1;
-    }
-    p->state = NETAPI_NW_CXT_LOC_ACTIVE;
-    return 1;
-
-
-}
-//***************************************************
-// intialize timer
-//***************************************************
-int netapi_init_timer(void)
-{
-        return t64_start();
-}
-
-
+/************************************************\r
+*  FILE:  netapi_init.c\r
+*  Global, local initialization of NETAPI\r
+ *\r
+ * DESCRIPTION: Functions to initialize framework resources for running NETAPI\r
+ *\r
+ * REVISION HISTORY:\r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ ***********************************************/\r
+#include <stdint.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <sys/types.h>\r
+#include <sys/stat.h>\r
+#include <fcntl.h>\r
+#include <sys/mman.h>\r
+#include <errno.h>\r
+#include <unistd.h>\r
+\r
+#include <ti/drv/nwal/nwal.h>\r
+#include "netapi.h"\r
+#include "netapi_vm.h"\r
+#include "netapi_loc.h"\r
+#include "ti/drv/nwal/nwal.h"\r
+\r
+/* CSL RL includes */\r
+#include <ti/csl/cslr_device.h>\r
+#include <ti/csl/cslr_qm_config.h>\r
+#include <ti/csl/cslr_qm_descriptor_region_config.h>\r
+#include <ti/csl/cslr_qm_queue_management.h>\r
+#include <ti/csl/cslr_qm_queue_status_config.h>\r
+#include <ti/csl/cslr_qm_intd.h>\r
+#include <ti/csl/cslr_pdsp.h>\r
+#include <ti/csl/csl_qm_queue.h>\r
+#include <ti/csl/cslr_cppidma_global_config.h>\r
+#include <ti/csl/cslr_cppidma_rx_channel_config.h>\r
+#include <ti/csl/cslr_cppidma_rx_flow_config.h>\r
+#include <ti/csl/cslr_cppidma_tx_channel_config.h>\r
+#include <ti/csl/cslr_cppidma_tx_scheduler_config.h>\r
+#include <ti/csl/csl_cppi.h>\r
+#include <ti/csl/csl_pscAux.h>\r
+#include <ti/csl/csl_semAux.h>\r
+#include <ti/csl/csl_cacheAux.h>\r
+#include <ti/csl/csl_xmcAux.h>\r
+#include <ti/csl/csl_cpsw_3gfAux.h>\r
+#include <ti/csl/csl_cpsw.h>\r
+#include <ti/csl/csl_cpsgmiiAux.h>\r
+#include <ti/drv/qmss/qmss_qm.h>\r
+//pull in device config for qmss, cppi\r
+#include <ti/drv/qmss/device/qmss_device.c>\r
+#include <ti/drv/cppi/device/cppi_device.c>\r
+\r
+/* TODO verify: */\r
+#define CACHE_LINESZ    64\r
+\r
+#define System_printf   printf\r
+#define ALIGN(x)    __attribute__((aligned (x)))\r
+\r
+/*****************************************************************************\r
+ * Global Resources shared by all Cores\r
+ *****************************************************************************/\r
+uint8_t *QMemGlobDescRam = 0;\r
+uint8_t *cppiMemPaSaLinkBuf = 0;\r
+uint8_t *cppiMemSaPaLinkBuf = 0;\r
+\r
+/*****************************************************************************\r
+ * Local Resource allocated at each Core\r
+ *****************************************************************************/\r
+/* Descriptors in global shared */\r
+uint8_t *QMemLocDescRam = NULL;\r
+uint8_t *cppiMemRxPktLinkBuf = NULL;\r
+uint8_t *cppiMemTxPktLinkBuf = NULL;\r
+uint8_t *cppiMemRxCtlLinkBuf = NULL;\r
+uint8_t *cppiMemTxCtlLinkBuf = NULL;\r
+\r
+\r
+//****************************************************\r
+// initialize CPSW (switch) [per SOC]\r
+//***************************************************\r
+int netapi_init_cpsw(void)\r
+{\r
+    CSL_CPSW_3GF_ALE_PORTCONTROL        alePortControlCfg;\r
+\r
+    CSL_CPSW_3GF_clearAleTable();\r
+\r
+    alePortControlCfg.dropUntaggedEnable    =   0;\r
+    alePortControlCfg.vidIngressCheckEnable =   0;\r
+\r
+    alePortControlCfg.mcastLimit            =   0;\r
+    alePortControlCfg.bcastLimit            =   0;\r
+\r
+    /* Disable learning mode for Port 0 */\r
+    alePortControlCfg.noLearnModeEnable     =   1;\r
+    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;\r
+    CSL_CPSW_3GF_setAlePortControlReg (0, &alePortControlCfg);\r
+\r
+    /* Enable learning mode for Port 1 */\r
+    alePortControlCfg.noLearnModeEnable     =   0;\r
+    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;\r
+    CSL_CPSW_3GF_setAlePortControlReg (1, &alePortControlCfg);\r
+\r
+    /* Enable learning mode for Port 2 */\r
+    alePortControlCfg.noLearnModeEnable     =   0;\r
+    alePortControlCfg.portState     =   ALE_PORTSTATE_FORWARD;\r
+    CSL_CPSW_3GF_setAlePortControlReg (2, &alePortControlCfg);\r
+\r
+    return 1;\r
+}\r
+\r
+//****************************************************\r
+// initialize QM (per SOC)\r
+//***************************************************\r
+int netapi_init_qm(void)\r
+{\r
+  Qmss_InitCfg     qmssInitConfig;\r
+  int32_t          result;\r
+  Qmss_GlobalConfigParams nwalTest_qmssGblCfgParams;\r
+\r
+  memset (&qmssInitConfig, 0, sizeof (Qmss_InitCfg));\r
+\r
+  /* Use Internal Linking RAM for optimal performance */\r
+  qmssInitConfig.linkingRAM0Base = 0;\r
+  qmssInitConfig.linkingRAM0Size = 0;\r
+  qmssInitConfig.linkingRAM1Base = 0;\r
+  qmssInitConfig.maxDescNum      = TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM;\r
+  qmssInitConfig.qmssHwStatus =QMSS_HW_INIT_COMPLETE; //bypass some of the hw init\r
+  nwalTest_qmssGblCfgParams = qmssGblCfgParams[0];\r
+\r
+  nwalTest_qmssGblCfgParams.qmConfigReg = (void *)((uint8_t *)netapi_VM_qmssCfgVaddr +\r
+      (CSL_QM_SS_CFG_CONFIG_STARVATION_COUNTER_REGS - CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+  nwalTest_qmssGblCfgParams.qmDescReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_DESCRIPTION_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmQueMgmtReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_QM_QUEUE_DEQUEUE_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmQueMgmtProxyReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_PROXY_QUEUE_DEQUEUE_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmQueStatReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmQueIntdReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_INTD_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspCmdReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM1_REGS)  - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspCmdReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspCtrlReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_ADSP1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspCtrlReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_ADSP2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspIRamReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_APDSP1_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmPdspIRamReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_APDSP2_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmStatusRAM = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_QM_STATUS_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmLinkingRAMReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_LINKING_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmMcDMAReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_MCDMA_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmTimer16Reg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_TIMER1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmTimer16Reg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+      ((uint32_t)CSL_QM_SS_CFG_TIMER2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);\r
+  nwalTest_qmssGblCfgParams.qmQueMgmtDataReg = (void *)((uint32_t)netapi_VM_qmssDataVaddr);\r
+  nwalTest_qmssGblCfgParams.qmQueMgmtProxyDataReg = \r
+      (void *)((uint32_t)netapi_VM_qmssDataVaddr + ((uint32_t)(0x44040000) - (uint32_t)(0x44020000)));\r
+\r
+  result = Qmss_init (&qmssInitConfig, &nwalTest_qmssGblCfgParams);\r
+  if (result != QMSS_SOK)  {\r
+    System_printf (">function init_qm: qmss_Init failed with error code %d\n", result);\r
+    return (nwal_FALSE);\r
+  }\r
+\r
+       return 1;\r
+}\r
+\r
+//****************************************************\r
+// Set up  QM memory region (per SOC)\r
+//***************************************************\r
+int netapi_qm_setup_mem_region(\r
+                      uint32_t          numDesc,\r
+                      uint32_t          descSize,\r
+                      uint32_t*         pDescMemBase,\r
+                      Qmss_MemRegion    memRegion)\r
+{\r
+  Qmss_MemRegInfo   memInfo;\r
+  Int32             result;\r
+  Int               n;\r
+  static int  netapi_qm_region_index=0;\r
+\r
+  memset(&memInfo,0,sizeof(Qmss_MemRegInfo));\r
+  memInfo.descBase       = pDescMemBase;\r
+  memInfo.descSize       = descSize;\r
+  memInfo.descNum        = numDesc;\r
+  memInfo.manageDescFlag = Qmss_ManageDesc_MANAGE_DESCRIPTOR;\r
+  memInfo.memRegion      = memRegion==NETAPI_GLOBAL_REGION ? Qmss_MemRegion_MEMORY_REGION0 : Qmss_MemRegion_MEMORY_REGION1;\r
+\r
+  if(memRegion == NETAPI_GLOBAL_REGION)\r
+  {\r
+      memInfo.startIndex = 0;\r
+      netapi_qm_region_index += numDesc;\r
+  }else if(memRegion ==NETAPI_LOCAL_REGION)\r
+  {\r
+      /* Global shared memory for all descriptors to all cores */\r
+      memInfo.startIndex     = netapi_qm_region_index;\r
+  }\r
+  else\r
+  {\r
+      return -1 ;\r
+  }\r
+\r
+  result = Qmss_insertMemoryRegion (&memInfo);\r
+  if (result < QMSS_SOK)  \r
+  {\r
+    printf (">function setup_qm_region: Qmss_insertMemoryRegion returned error code %d\n", result);\r
+    return (-1);\r
+  }\r
+\r
+  return 1;\r
+\r
+}\r
+\r
+//****************************************************\r
+// Start QM (per thread)\r
+//***************************************************\r
+int netapi_start_qm(void)\r
+{\r
+     int32_t          result;\r
+     result = Qmss_start();\r
+     if (result != QMSS_SOK)\r
+     {\r
+         System_printf (">start_qm: Qmss_start failed with error code %d\n", result);\r
+         return (-1);\r
+     }\r
+     return 1;\r
+}\r
+\r
+//*************************************************\r
+//initilaize CPPI (once per soc)\r
+//*************************************************\r
+int netapi_init_cppi(void)\r
+{\r
+  int32_t result, i;\r
+  Cppi_GlobalConfigParams nwalTest_cppiGblCfgParams[CPPI_MAX_CPDMA];\r
+\r
+  for (i=0; i<CPPI_MAX_CPDMA; i++)\r
+    nwalTest_cppiGblCfgParams[i] = cppiGblCfgParams[i];\r
+\r
+  /* SRIO CPDMA regs */\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs =\r
+      (void *)((uint32_t)netapi_VM_srioCfgVaddr +\r
+               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs =\r
+      (void *)((uint32_t)netapi_VM_srioCfgVaddr +\r
+               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));\r
+\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs =\r
+      (void *)((uint32_t)netapi_VM_srioCfgVaddr +\r
+               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs =\r
+      (void *)((uint32_t)netapi_VM_srioCfgVaddr +\r
+               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));\r
+ nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs =\r
+      (void *)((uint32_t)netapi_VM_srioCfgVaddr +\r
+               (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));\r
+\r
+  /* PASS CPDMA regs */\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs =\r
+      (void *)((uint32_t)netapi_VM_passCfgVaddr +\r
+               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs =\r
+      (void *)((uint32_t)netapi_VM_passCfgVaddr +\r
+               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs =\r
+      (void *)((uint32_t)netapi_VM_passCfgVaddr +\r
+               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs =\r
+      (void *)((uint32_t)netapi_VM_passCfgVaddr +\r
+               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs =\r
+      (void *)((uint32_t)netapi_VM_passCfgVaddr +\r
+               (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));\r
+ /* QMSS CPDMA regs */\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs =\r
+      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs =\r
+      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs =\r
+      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs =\r
+      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+  nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs =\r
+      (void *)((uint32_t)netapi_VM_qmssCfgVaddr +\r
+               (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));\r
+\r
+  result = Cppi_init (nwalTest_cppiGblCfgParams);\r
+  if (result != CPPI_SOK)  \r
+  {\r
+    printf (">function cppi_init: Cppi_init failed with error code %d\n", result);\r
+    return (-1);\r
+  }\r
+   return 1;\r
+}\r
+\r
+//*************************************************\r
+//initialize NWAL (one per soc) \r
+//*************************************************\r
+/*** NWAL Memory Buffer Configuration ***/\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE     3400\r
+uint8_t nwalInstMem[NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE]ALIGN(CACHE_LINESZ);\r
+\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC                    128\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN      256\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP                     128\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT                   128\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR               128\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT            384\r
+#define NWAL_CHAN_HANDLE_SIZE    ((NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC * TUNE_NETAPI_MAX_NUM_MAC) + \\r
+                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) + \\r
+                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP * TUNE_NETAPI_MAX_NUM_IP) + \\r
+                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT * TUNE_NETAPI_MAX_NUM_PORTS)+ \\r
+                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT * TUNE_NETAPI_NUM_CORES) + \\r
+                                  (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR * TUNE_NETAPI_MAX_NUM_L2_L3_HDRS))\r
+\r
+uint8_t nwalHandleMem[NWAL_CHAN_HANDLE_SIZE]ALIGN(CACHE_LINESZ);\r
+\r
+/* todo: Check if below size information can be made available from pa interface file */\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0      128\r
+/* PA instance */\r
+/* Memory used for the PA Instance. Needs to be assigned global uncached memory for chip */\r
+uint8_t paBuf0[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0]ALIGN(CACHE_LINESZ);\r
+\r
+/* Memory used for PA handles */\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1    128\r
+uint8_t paBuf1[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1]ALIGN(CACHE_LINESZ);\r
+\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2    256\r
+uint8_t paBuf2[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2]ALIGN(CACHE_LINESZ);\r
+\r
+/* Memory used for SA LLD global Handle */\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE    384\r
+uint8_t salldHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE]ALIGN(CACHE_LINESZ);\r
+\r
+/* Memory used for SA LLD global Handle */\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN             384\r
+uint8_t saContext[NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS]ALIGN(CACHE_LINESZ);\r
+\r
+/* Memory used by SA LLD per Channel */\r
+#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN          512\r
+uint8_t salldChanHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS]ALIGN(CACHE_LINESZ);\r
+\r
+\r
+/*******************************************\r
+ * Initialize the nwal subsystem for NETAPI use\r
+ ***********************************************/\r
+int netapi_init_nwal(\r
+     int region2use,  \r
+     Pktlib_HeapIfTable * p_table,\r
+     NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context )\r
+{\r
+    nwalSizeInfo_t  nwalSizeInfo;\r
+    nwalMemBuf_t    nwalMemBuf[nwal_N_BUFS];\r
+    nwal_RetValue   nwalRetVal;\r
+    nwalGlobCfg_t   nwalGlobCfg;\r
+    uint8_t         count;\r
+    int             sizes[nwal_N_BUFS];\r
+    int             aligns[nwal_N_BUFS];\r
+    void*           bases[nwal_N_BUFS];\r
+\r
+    memset(p_nwal_context,0,sizeof( NETAPI_NWAL_GLOBAL_CONTEXT_T) );\r
+    memset(&nwalGlobCfg,0,sizeof(nwalGlobCfg_t ) );\r
+\r
+\r
+    /* Initialize Buffer Pool for NetCP PA to SA packets */\r
+    nwalGlobCfg.pa2SaBufPool.numBufPools = 1;\r
+    nwalGlobCfg.pa2SaBufPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalGlobCfg.pa2SaBufPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;\r
+    nwalGlobCfg.pa2SaBufPool.bufPool[0].heapHandle =\r
+    Pktlib_createHeap("nwal PA2SA",\r
+                       region2use,\r
+                       0,\r
+                       TUNE_NETAPI_DEFAULT_BUFFER_SIZE,\r
+                       TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC,\r
+                       0,\r
+                       p_table);\r
+    if(nwalGlobCfg.pa2SaBufPool.bufPool[0].heapHandle == NULL)\r
+    {\r
+        printf (">Pktlib_createHeap:Heap Creation Failed for PA to SA Buffer Pool \n");\r
+        netapi_err_teardown(); \r
+        return -1;\r
+    }\r
+\r
+ /* Initialize Buffer Pool for NetCP SA to PA packets */\r
+    nwalGlobCfg.sa2PaBufPool.numBufPools = 1;\r
+    nwalGlobCfg.sa2PaBufPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalGlobCfg.sa2PaBufPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;\r
+\r
+    nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle =\r
+        Pktlib_createHeap("nwal SA2PA",\r
+                          region2use,\r
+                          0,\r
+                          TUNE_NETAPI_DEFAULT_BUFFER_SIZE,\r
+                          TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC,\r
+                          0,\r
+                          p_table);\r
+    if(nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle == NULL)\r
+    {\r
+        printf (">Pktlib_createHeap:Heap Creation Failed for SA to PA Buffer Pool \n");\r
+        netapi_err_teardown();\r
+        return -1;\r
+    }\r
+\r
+    nwalGlobCfg.hopLimit = 5;/* Default TTL / Hop Limit */\r
+    nwalGlobCfg.lpbackPass = TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;\r
+    nwalGlobCfg.paFwActive = nwal_TRUE;\r
+    nwalGlobCfg.saFwActive = nwal_TRUE;\r
+\r
+    /* Pick Default Physical Address */\r
+    nwalGlobCfg.paVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr;\r
+    nwalGlobCfg.saVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr +\r
+                                 ((uint32_t)CSL_PA_SS_CFG_CP_ACE_CFG_REGS - (uint32_t)CSL_PA_SS_CFG_REGS) ;\r
+    nwalGlobCfg.rxDefPktQ = QMSS_PARAM_NOT_SPECIFIED;\r
+\r
+    /* Get the Buffer Requirement from NWAL */\r
+    memset(&nwalMemBuf,0,sizeof(nwalMemBuf));\r
+    memset(&nwalSizeInfo,0,sizeof(nwalSizeInfo));\r
+    nwalSizeInfo.nMaxMacAddress = TUNE_NETAPI_MAX_NUM_MAC;\r
+    nwalSizeInfo.nMaxIpAddress = TUNE_NETAPI_MAX_NUM_IP;\r
+    nwalSizeInfo.nMaxL4Ports = TUNE_NETAPI_MAX_NUM_PORTS;\r
+    nwalSizeInfo.nMaxIpSecChannels = TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS;\r
+    nwalSizeInfo.nMaxL2L3Hdr = TUNE_NETAPI_MAX_NUM_L2_L3_HDRS;\r
+    nwalSizeInfo.nProc = TUNE_NETAPI_NUM_CORES;\r
+    for(count=0;count < nwal_N_BUFS;count++)\r
+    {\r
+        nwalMemBuf[count].cacheLineSize = CACHE_LINESZ;\r
+    }\r
+    nwalRetVal = nwal_getBufferReq(&nwalSizeInfo,\r
+                                   sizes,\r
+                                   aligns);\r
+    if(nwalRetVal != nwal_OK)\r
+    {\r
+        printf (">netapi: init_nwal - nwal_getBufferReq Failed %d\n", nwalRetVal);\r
+        return nwal_FALSE;\r
+    }\r
+\r
+/* Check for memory size requirement and update the base */\r
+    count = 0;\r
+    bases[nwal_BUF_INDEX_INST] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalInstMem);\r
+    if(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE < sizes[nwal_BUF_INDEX_INST])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+\r
+    bases[nwal_BUF_INDEX_INT_HANDLES] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalHandleMem);\r
+    if(NWAL_CHAN_HANDLE_SIZE  < sizes[nwal_BUF_INDEX_INT_HANDLES])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+     bases[nwal_BUF_INDEX_PA_LLD_BUF0] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf0);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0) < sizes[nwal_BUF_INDEX_PA_LLD_BUF0])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+\r
+    bases[nwal_BUF_INDEX_PA_LLD_BUF1] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf1);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1) < sizes[nwal_BUF_INDEX_PA_LLD_BUF1])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+\r
+     bases[nwal_BUF_INDEX_PA_LLD_BUF2] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf2);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2) < sizes[nwal_BUF_INDEX_PA_LLD_BUF2])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+#ifdef NETAPI_ENABLE_SECURITY\r
+    bases[nwal_BUF_INDEX_SA_LLD_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldHandle);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE) < sizes[nwal_BUF_INDEX_SA_LLD_HANDLE])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+\r
+    bases[nwal_BUF_INDEX_SA_CONTEXT] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)saContext);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) <\r
+        sizes[nwal_BUF_INDEX_SA_CONTEXT])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+\r
+    bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldChanHandle);\r
+    if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS) <\r
+        sizes[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE])\r
+    {\r
+        /* Resize Memory */\r
+        while(1);\r
+    }\r
+    count++;\r
+#else\r
+    bases[nwal_BUF_INDEX_SA_LLD_HANDLE] = 0;\r
+    bases[nwal_BUF_INDEX_SA_CONTEXT] = 0;\r
+    bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = 0;\r
+    count = count+3;\r
+#endif\r
+    if(count != nwal_N_BUFS)\r
+    {\r
+        while(1);\r
+    }\r
+\r
+    /* Initialize NWAL module */\r
+    nwalRetVal = nwal_create(&nwalGlobCfg,\r
+                             &nwalSizeInfo,\r
+                             sizes,\r
+                             bases,\r
+                             &p_nwal_context->nwalInstHandle);\r
+    if(nwalRetVal != nwal_OK)\r
+    {\r
+        printf (">netapi: init_nwal- nwal_create Failed %d\n",nwalRetVal);\r
+        while(1);\r
+    }\r
+\r
+    printf(">netapi: init_nwal - Global and Local Network initialization Successful \n");\r
+    return 1;\r
+}\r
+\r
+//*************************************************\r
+//* Local (per thread/core) nwal initialization0\r
+//**************************************************\r
+int netapi_start_nwal(Pktlib_HeapHandle pkt_heap,\r
+                    Pktlib_HeapHandle cmd_heap,\r
+                     NETAPI_NWAL_LOCAL_CONTEXT_T *p,\r
+                     NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_glob_context  )\r
+{\r
+    nwalLocCfg_t    nwalLocCfg;\r
+    int count;\r
+    nwal_RetValue       nwalRetVal;\r
+\r
+    memset(&nwalLocCfg,0,sizeof(nwalLocCfg));\r
+\r
+    /* Common Initialization for all cores */\r
+    while(count < TUNE_NETAPI_MAX_NUM_TRANS)\r
+    {\r
+        p_nwal_glob_context->transInfos[count].transId = count;\r
+        count++;\r
+    }\r
+\r
+ /* Call back registration for the core */\r
+    nwalLocCfg.pRxPktCallBack = netapi_NWALRxPktCallback;\r
+    nwalLocCfg.pCmdCallBack = netapi_NWALCmdCallBack;\r
+    nwalLocCfg.pPaStatsCallBack = netapi_NWALCmdPaStatsReply;\r
+\r
+    /* Initialize Buffer Pool for Control packets from NetCP to Host */\r
+    nwalLocCfg.rxCtlPool.numBufPools = 1;\r
+    nwalLocCfg.rxCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalLocCfg.rxCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;\r
+    nwalLocCfg.rxCtlPool.bufPool[0].heapHandle = cmd_heap;\r
+\r
+    /* Initialize Buffer Pool for Control packets from Host to NetCP */\r
+    nwalLocCfg.txCtlPool.numBufPools = 1;\r
+    nwalLocCfg.txCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalLocCfg.txCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;\r
+    nwalLocCfg.txCtlPool.bufPool[0].heapHandle =  cmd_heap;\r
+\r
+/* Initialize Buffer Pool for Packets from NetCP to Host */\r
+    nwalLocCfg.rxPktPool.numBufPools = 1;\r
+    nwalLocCfg.rxPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalLocCfg.rxPktPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;\r
+    nwalLocCfg.rxPktPool.bufPool[0].heapHandle = pkt_heap;\r
+\r
+/* Initialize Buffer Pool for Packets from Host to NetCP */\r
+    nwalLocCfg.txPktPool.numBufPools = 1;\r
+    nwalLocCfg.txPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;\r
+    nwalLocCfg.txPktPool.bufPool[0].bufSize =  TUNE_NETAPI_DEFAULT_BUFFER_SIZE;\r
+    nwalLocCfg.txPktPool.bufPool[0].heapHandle = pkt_heap;\r
+\r
+    memcpy(&p->nwalLocCfg,&nwalLocCfg,sizeof(nwalLocCfg_t));\r
+    while(1)\r
+    {\r
+        nwalRetVal = nwal_start(p_nwal_glob_context->nwalInstHandle,&nwalLocCfg);\r
+        if(nwalRetVal == nwal_ERR_INVALID_STATE)\r
+        {\r
+            continue;\r
+        }\r
+        break;\r
+    }\r
+\r
+    if(nwalRetVal != nwal_OK)\r
+    {\r
+        printf (">nwal_start:Failed ->err %d !!!\n", nwalRetVal);\r
+        return -1;\r
+    }\r
+    p->state = NETAPI_NW_CXT_LOC_ACTIVE;\r
+    return 1;\r
+\r
+\r
+}\r
+//***************************************************\r
+// intialize timer\r
+//***************************************************\r
+int netapi_init_timer(void)\r
+{\r
+        return t64_start();\r
+}\r
+\r
+\r
index 290ec7384f438903d84125621a7536769b861707..20584673df45a457025936bbb950dcc3a939de5e 100644 (file)
@@ -34,6 +34,16 @@ typedef struct NETCP_INTERFACE_IP_Tag
         nwalIpOpt_t ip_qualifiers;\r
 } NETCP_INTERFACE_IP_T;\r
 \r
+/* to hold a classifier */\r
+typedef struct NETCP_INTERFACE_CLASSIFIER_Tag\r
+{\r
+       int  in_use;\r
+       int  class_type;   //see netcp_cfg.h\r
+       void * nwal_L2_handle;\r
+       void * nwal_L3_handle;\r
+       void * nwal_L4_handle;\r
+} NETCP_INTERFACE_CLASSIFIER_T;\r
+\r
 /* to hold a netcp 'interface' */\r
 typedef struct NETCP_INTERFACE_Tag\r
 {\r
@@ -67,7 +77,18 @@ typedef struct {
     NETAPI_T                netapi_handle; //the thread making the transaction\r
 }  NetapiNwalTransInfo_t;\r
 \r
-/* nwal global context */\r
+/* to hold user defined flows */\r
+typedef struct NETCP_REGISTERED_FLOWS_Tag\r
+{\r
+       int in_use;  //1=> in use\r
+       void * handle; //cppi handle to resource (internal)\r
+        NETCP_CFG_FLOW_T flow;\r
+} NETCP_REGISTERED_FLOWS_T;\r
+\r
+/******************************\r
+ *    nwal global context \r
+ *  (shared over all instances)\r
+ *******************************/\r
 typedef struct\r
 {\r
    int    state;\r
@@ -82,7 +103,8 @@ typedef struct
     int    numBogusTransIds;\r
     NetapiNwalTransInfo_t  transInfos[TUNE_NETAPI_MAX_NUM_TRANS];\r
     NETCP_INTERFACE_T  interfaces[TUNE_NETAPI_MAX_INTERFACES];\r
-\r
+    NETCP_INTERFACE_CLASSIFIER_T classi[TUNE_NETAPI_MAX_CLASSIFIERS];\r
+    NETCP_REGISTERED_FLOWS_T flows[TUNE_NETAPI_MAX_FLOWS];\r
 } NETAPI_NWAL_GLOBAL_CONTEXT_T;\r
 \r
 /* NWAL Local context (per core/thread)  */\r
@@ -154,13 +176,6 @@ NETAPI_NWAL_LOCAL_CONTEXT_T nwal_local;
 \r
 /* timer stuff */\r
 \r
-\r
-/* default flow*/\r
-NETCP_CFG_FLOW_HANDLE_T def_flow;  //uses our heap above\r
-\r
-/* default route */\r
-NETCP_CFG_ROUTE_HANDLE_T def_route; //uses our rx channel above\r
-\r
 /* thread cookie */\r
 void * cookie;  /*set by calling thread */\r
 \r
index 05037f45221f2a9985467e8f61b9dfa9939598c9..5c5f85bb690a071738eb6e90b30e6c603cc9b2e9 100644 (file)
-/****************************************
- * File: netapi_sched.c
- * Purpose:  netapi scheduling module
- * NOTE: This sample right now.
- **************************************************************
- * FILE: netapi_sched.c
- * 
- * DESCRIPTION:  netapi sample scheduler source file for user space transport
- *               library
- * 
- * REVISION HISTORY:  rev 0.0.1 
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- ****************************************/
-
-#include "netapi.h"
-#include "netapi_sched.h"
-
-
-/****************************************/
-/************API************************/
-/**************************************/
-
-/* open a scheduling contex */
-NETAPI_SCHED_HANDLE_T * netapi_schedOpen(NETAPI_T n, NETAPI_SCHED_CONFIG_T * p_config, int *p_err)
-{
-  *p_err=0;
-   NETAPI_SCHED_HANDLE_T * ph = (NETAPI_SCHED_HANDLE_T *) netapi_get_scheduler(n);
-  if(!ph) {*p_err= NETAPI_ERR_NOMEM; return NULL;}
-  if(!p_config) {*p_err=  NETAPI_ERR_BAD_INPUT; return NULL;}
-  memcpy(&ph->config,p_config,sizeof(NETAPI_SCHED_CONFIG_T));
-  ph->start =   netapi_getTimestamp();
-  ph->back = (void *) n;
-  if (ph->config.valid_flags & NETAPI_SCHED_DURATION)
-  {
-    if (ph->config.duration == NETAPI_SCHED_FOREVER) 
-       {
-       ph->shutdown_time=(uint64_t) -1; 
-       }
-    else
-       {
-       ph->shutdown_time = ph->start + ph->config.duration;
-       }
-  }
-  else ph->shutdown_time = (uint64_t) -1;
-  ph->state =NETAPI_SCHED_STATE_ACTIVE; 
-  return(ph);
-
-}
-
-/* re-configure a scheduling context */
-int netapi_schedControl(NETAPI_SCHED_HANDLE_T *s, NETAPI_SCHED_CONFIG_T *p_config, int *p_err)
-{
-  /* not implemented */
-
-  return 0;
-}
-
-
-/* main entry point.  caller gives up control to scheduler */
-int netapi_schedWaitForEvents(NETAPI_SCHED_HANDLE_T *s, int *p_err)
-{
-  int err;
-  *p_err=0;
-  unsigned long long t =  netapi_getTimestamp();
-  int next_house;
-
-  next_house =  s->config.interval;
-  /* loop for duration or until shutdown */
-  for(;t< s->shutdown_time;)
-  {
-    t = netapi_getTimestamp();
-    next_house -=1;
-    //poll all  pktio channels we have open in RX mode 
-     pktio_pollAll((NETAPI_T) s->back, NULL, &err);
-
-    //poll pktlib garbage collections for registered heaps..
-    netapi_pollHeapGarbage((NETAPI_T) s->back);
-    
-    //todo timers (local and global)
-    netapi_TimerGroupPollAll((NETAPI_T) s->back, NETAPI_TIMER_FITLER_ALL, 100000);
-
-    //poll NETCP/PA control channels 
-    netapi_netcpPoll((NETAPI_T) s->back);
-
-    //see if time to do a house keeping callback
-     if ((s->config.valid_flags & NETAPI_SCHED_CBV) && s->config.house_cb)
-        if (next_house<=0)
-        {
-          s->config.house_cb(s);
-           next_house = s->config.interval;
-        }
-    //see if we were closed and/or its time to close
-    if (s->state!= NETAPI_SCHED_STATE_ACTIVE) 
-         { s->state=NETAPI_SCHED_STATE_SHUT; break;}
-  }
-  return 1;
-}
-
-/* shutdown scheduler context */
-int netapi_schedShutdown(NETAPI_SCHED_HANDLE_T * s, NETAPI_SCHED_SHUTDOWN_T * p_close, int * p_err)
-{
-  *p_err=0;
-  s->state=NETAPI_SCHED_STATE_SHUTTING;  //say we are closing
-
-  return 1;
-}
-
-
+/****************************************\r
+ * File: netapi_sched.c\r
+ * Purpose:  netapi scheduling module\r
+ * NOTE: This sample right now.\r
+ **************************************************************\r
+ * FILE: netapi_sched.c\r
+ * \r
+ * DESCRIPTION:  netapi sample scheduler source file for user space transport\r
+ *               library\r
+ * \r
+ * REVISION HISTORY:  rev 0.0.1 \r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+ ****************************************/\r
+\r
+#include "netapi.h"\r
+#include "netapi_sched.h"\r
+\r
+\r
+/****************************************/\r
+/************API************************/\r
+/**************************************/\r
+\r
+/* open a scheduling contex */\r
+NETAPI_SCHED_HANDLE_T * netapi_schedOpen(NETAPI_T n, NETAPI_SCHED_CONFIG_T * p_config, int *p_err)\r
+{\r
+  *p_err=0;\r
+   NETAPI_SCHED_HANDLE_T * ph = (NETAPI_SCHED_HANDLE_T *) netapi_get_scheduler(n);\r
+  if(!ph) {*p_err= NETAPI_ERR_NOMEM; return NULL;}\r
+  if(!p_config) {*p_err=  NETAPI_ERR_BAD_INPUT; return NULL;}\r
+  memcpy(&ph->config,p_config,sizeof(NETAPI_SCHED_CONFIG_T));\r
+  ph->start =   netapi_getTimestamp();\r
+  ph->back = (void *) n;\r
+  if (ph->config.valid_flags & NETAPI_SCHED_DURATION)\r
+  {\r
+    if (ph->config.duration == NETAPI_SCHED_FOREVER) \r
+       {\r
+       ph->shutdown_time=(uint64_t) -1; \r
+       }\r
+    else\r
+       {\r
+       ph->shutdown_time = ph->start + ph->config.duration;\r
+       }\r
+  }\r
+  else ph->shutdown_time = (uint64_t) -1;\r
+  ph->state =NETAPI_SCHED_STATE_ACTIVE; \r
+  return(ph);\r
+\r
+}\r
+\r
+/* re-configure a scheduling context */\r
+int netapi_schedControl(NETAPI_SCHED_HANDLE_T *s, NETAPI_SCHED_CONFIG_T *p_config, int *p_err)\r
+{\r
+  /* not implemented */\r
+\r
+  return 0;\r
+}\r
+\r
+\r
+/* main entry point.  caller gives up control to scheduler */\r
+int netapi_schedWaitForEvents(NETAPI_SCHED_HANDLE_T *s, int *p_err)\r
+{\r
+  int err;\r
+  *p_err=0;\r
+  unsigned long long t =  netapi_getTimestamp();\r
+  int next_house;\r
+\r
+  next_house =  s->config.interval;\r
+  /* loop for duration or until shutdown */\r
+  for(;t< s->shutdown_time;)\r
+  {\r
+    t = netapi_getTimestamp();\r
+    next_house -=1;\r
+    //poll all  pktio channels we have open in RX mode \r
+     pktio_pollAll((NETAPI_T) s->back, NULL, &err);\r
+\r
+    //poll pktlib garbage collections for registered heaps..\r
+    netapi_pollHeapGarbage((NETAPI_T) s->back);\r
+    \r
+    //todo timers (local and global)\r
+    netapi_TimerGroupPollAll((NETAPI_T) s->back, NETAPI_TIMER_FITLER_ALL, 100000);\r
+\r
+    //poll NETCP/PA control channels \r
+    netapi_netcpPoll((NETAPI_T) s->back);\r
+\r
+    //see if time to do a house keeping callback\r
+     if ((s->config.valid_flags & NETAPI_SCHED_CBV) && s->config.house_cb)\r
+        if (next_house<=0)\r
+        {\r
+          s->config.house_cb(s);\r
+           next_house = s->config.interval;\r
+        }\r
+    //see if we were closed and/or its time to close\r
+    if (s->state!= NETAPI_SCHED_STATE_ACTIVE) \r
+         { s->state=NETAPI_SCHED_STATE_SHUT; break;}\r
+  }\r
+  return 1;\r
+}\r
+\r
+/* shutdown scheduler context */\r
+int netapi_schedShutdown(NETAPI_SCHED_HANDLE_T * s, NETAPI_SCHED_SHUTDOWN_T * p_close, int * p_err)\r
+{\r
+  *p_err=0;\r
+  s->state=NETAPI_SCHED_STATE_SHUTTING;  //say we are closing\r
+\r
+  return 1;\r
+}\r
+\r
+\r
index 34b118e95d69055d7a04c2a89d436cc2ac19febd..3cf1abe3e61a778f6edb0c8dcc48cb4eb3f24199 100644 (file)
-/*******************************
- * FILE: netapi_timer.c
- * Purpose:  implementation of user space timers 
- **************************************************************
- * FILE: netapi.c
- * 
- * DESCRIPTION:  user space timers main source file for user space transport
- *               library
- * 
- * REVISION HISTORY:  rev 0.0.1 
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
-*
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ***************************************************************/
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include "netapi.h"
-#include "netapi_timer.h"
-#include "timer_loc.h"
-
-
-/*******************************************************************
- *  hash function:  returns cell to place timer object in
- *   
- ******************************************************************/
-/* static */ int our_hash(
-       unsigned long long ct,
-       int n_cells,
-       unsigned int cell_width)
-{
-int c;
-   //simple hash function
-   c=  (ct/cell_width) % n_cells;
-  return c;
-
-}
-
-//iterator on TIMER_LIST_T
-NETAPI_TIMER_T netapi_TimerGetFirst( NETAPI_TIMER_LIST_T list)
-{ return (NETAPI_TIMER_T) ((TIM_LIST_T *)list)->head; }
-
-NETAPI_TIMER_T netapi_TimerGetNext( NETAPI_TIMER_LIST_T list,NETAPI_TIMER_T prev)
-{return prev ? (NETAPI_TIMER_T) ((TIM_T*) prev)->next:NULL ;}
-
-//return cookie associated with timer object 
-void * netapi_TimerGetCookie(NETAPI_TIMER_T timer)
-{ return ((TIM_T*) timer)->cookie; }
-
-//return timeer value associated with timer object 
-unsigned long long netapi_TimerGetTs(NETAPI_TIMER_T timer)
-{ return ((TIM_T*) timer)->t; }
-
-#if 0
-//timer callback
-typedef void (*NETAPI_TIMER_CB_T) (
-        NETAPI_TIMER_GROUP_HANDLE_T th,
-        int n_fired,     //# timers fired
-        NETAPI_TIMER_LIST_T fired_list,
-        uint64_t currentTime);
-#endif
-
-static TIMER_GROUP_T temp_g; //temp. todo: put inot netHandle
-
-//create a timer group
-NETAPI_TIMER_GROUP_HANDLE_T netapi_TimerGroupCreate(
-        NETAPI_T  netHandle,
-        char * name,
-        NETAPI_TIMER_CB_T cb,
-        int local,    //1 if timers local to thread
-        int exp2cancel,//1 if expect to cancel
-        int cell_width, //in ticks
-       int tol,        //in ticks
-        int maxTimers,
-        int *pErr)
-{
- int ret= tim_group_create(&temp_g, TUNE_NETAPI_NUM_TIMER_CELLS, maxTimers);
- if (!ret) {*pErr = NETAPI_ERR_NOMEM; return NULL;}
- *pErr=0;
- temp_g.cb = cb;
- temp_g.local = local;
- temp_g.exp2cancel= exp2cancel;
- temp_g.cell_width=cell_width;
- temp_g.tol=tol;
- temp_g.h = netHandle;
- temp_g.last_polled=(netapi_getTimestamp()/cell_width) * cell_width + (cell_width-1);
- printf(">timer group %s created. width = %d (ticks)\n", name, cell_width);
- return (NETAPI_TIMER_GROUP_HANDLE_T) &temp_g;
-}
-
-//open a [global] timer group
-NETAPI_TIMER_GROUP_HANDLE_T  netapi_TimerGroupOpen(
-        NETAPI_T netHandle,
-        char * name,
-        NETAPI_TIMER_CB_T cb,
-        int *pErr)
-{
-printf(">timer group open not implemented \n");
-
-}
-
-//start an individual timer
-NETAPI_TIMER_T netapi_TimerGroupStartTimer(
-        NETAPI_TIMER_GROUP_HANDLE_T th,
-        void * cookie,
-        uint64_t offs2fire,  //offset in group ticks 
-        int * pErr)
-{
-TIM_T * timer_obj;
-unsigned long long ct= netapi_getTimestamp() + offs2fire* ((TIMER_GROUP_T*) th)->cell_width;
-int cell;
-*pErr=0;
-
-//find cell where to insert
-cell = our_hash(ct,((TIMER_GROUP_T*) th)->n_cells , ((TIMER_GROUP_T*) th)->cell_width);
-
-//get object and insert into this cell
-timer_obj =tim_set(
-   &((TIMER_GROUP_T*) th)->cells[cell],
-   &((TIMER_GROUP_T*) th)->free , 
-   ct,
-   cookie,
-   pErr);
-if (!timer_obj)  {return NULL;}
-//DEBUGprintf(">timer: setting timer %x for %lld ticks -> hased to cell %d\n",cookie, ct,cell);
-return (NETAPI_TIMER_T) timer_obj;
-}
-
-//Cancel a timer
-void  netapi_TimerGroupCancel(
-        NETAPI_TIMER_GROUP_HANDLE_T th,
-        NETAPI_TIMER_T timerId,
-        int *pErr)
-{
-    tim_cancel((TIM_T *) timerId, pErr);
-}
-
-//close an opened timer group
-void netapi_TimerGroupClose(
-        NETAPI_TIMER_GROUP_HANDLE_T th,
-        int *pErr){}
-
-//delete atimer group
-void netapi_TimerGroupDelete(
-        NETAPI_TIMER_GROUP_HANDLE_T th,
-        int *pErr) {printf(">timer group delete not implemented\n");}
-
-//extract netapi handle from timer group handle
-NETAPI_T netap_TimerGroupGetNH( NETAPI_TIMER_GROUP_HANDLE_T th) { return ((TIMER_GROUP_T*) th)->h; }
-
-
-//-----for timer debuggingi-------
-struct
-{
-//last poll stats
-int n_tot;
-int c_seen;
-
-int max_c_seen;
-int max_n_tot;
-
-} timer_poll_stats;
-void dump_poll_stats(void)
-{
-  printf("debug timer poll> n_tot=%d c_seen=%d mnt=%d mcs=%d\n",
-             timer_poll_stats.n_tot, timer_poll_stats.c_seen,
-             timer_poll_stats.max_n_tot, timer_poll_stats.max_c_seen);
-}
-//-------end timer debugging----
-
-//poll a specific timer group
-int  netapi_TimerGroupPoll(NETAPI_TIMER_GROUP_HANDLE_T th, int maxTimers)
-{
-unsigned long long ct= netapi_getTimestamp(); 
-unsigned long long i;
-int cell;
-TIM_LIST_T res={NULL,NULL};
-int n;
-int n_tot=0;
-int c_seen=0;
-
-   for(i=((TIMER_GROUP_T*) th)->last_polled; (i<= ct) && (n_tot<maxTimers); )
-   {
-      cell =  our_hash(i,((TIMER_GROUP_T*) th)->n_cells , ((TIMER_GROUP_T*) th)->cell_width); 
-      tim_return_fired_list(&((TIMER_GROUP_T*) th)->cells[cell],
-                           &res,
-                            &((TIMER_GROUP_T*) th)->free,
-                            i,  
-                            &n);
-      n_tot+=n;
-      i += ((TIMER_GROUP_T*) th)->cell_width; 
-      c_seen+=1;
-   }
-   if (n_tot)
-      {
-           ((TIMER_GROUP_T*) th)->cb(th, n_tot, (NETAPI_TIMER_LIST_T) &res, ct);
-           tim_return_free(&((TIMER_GROUP_T*) th)->free,&res,n_tot);
-      }
-
-   ((TIMER_GROUP_T*) th)->last_polled = i;
-   if (c_seen) timer_poll_stats.n_tot = n_tot;
-   if (c_seen) timer_poll_stats.c_seen = c_seen;
-   if (n_tot > timer_poll_stats.max_n_tot) timer_poll_stats.max_n_tot = n_tot;
-   if (c_seen > timer_poll_stats.max_c_seen) timer_poll_stats.max_c_seen = c_seen;
-   return n_tot;
-}
-
-//poll all timers
-int  netapi_TimerGroupPollAll(NETAPI_T nh, NETAPI_TIMER_FILTER_T f,  int maxTimers)
-{
- //todo: use filters and poll global, local lists in nh
- if (temp_g.h)
-    netapi_TimerGroupPoll(&temp_g, maxTimers);
- return 0;
-}
-
-
+/*******************************\r
+ * FILE: netapi_timer.c\r
+ * Purpose:  implementation of user space timers \r
+ **************************************************************\r
+ * FILE: netapi.c\r
+ * \r
+ * DESCRIPTION:  user space timers main source file for user space transport\r
+ *               library\r
+ * \r
+ * REVISION HISTORY:  rev 0.0.1 \r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+*\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ ***************************************************************/\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include "netapi.h"\r
+#include "netapi_timer.h"\r
+#include "timer_loc.h"\r
+\r
+\r
+/*******************************************************************\r
+ *  hash function:  returns cell to place timer object in\r
+ *   \r
+ ******************************************************************/\r
+/* static */ int our_hash(\r
+       unsigned long long ct,\r
+       int n_cells,\r
+       unsigned int cell_width)\r
+{\r
+int c;\r
+   //simple hash function\r
+   c=  (ct/cell_width) % n_cells;\r
+  return c;\r
+\r
+}\r
+\r
+//iterator on TIMER_LIST_T\r
+NETAPI_TIMER_T netapi_TimerGetFirst( NETAPI_TIMER_LIST_T list)\r
+{ return (NETAPI_TIMER_T) ((TIM_LIST_T *)list)->head; }\r
+\r
+NETAPI_TIMER_T netapi_TimerGetNext( NETAPI_TIMER_LIST_T list,NETAPI_TIMER_T prev)\r
+{return prev ? (NETAPI_TIMER_T) ((TIM_T*) prev)->next:NULL ;}\r
+\r
+//return cookie associated with timer object \r
+void * netapi_TimerGetCookie(NETAPI_TIMER_T timer)\r
+{ return ((TIM_T*) timer)->cookie; }\r
+\r
+//return timeer value associated with timer object \r
+unsigned long long netapi_TimerGetTs(NETAPI_TIMER_T timer)\r
+{ return ((TIM_T*) timer)->t; }\r
+\r
+#if 0\r
+//timer callback\r
+typedef void (*NETAPI_TIMER_CB_T) (\r
+        NETAPI_TIMER_GROUP_HANDLE_T th,\r
+        int n_fired,     //# timers fired\r
+        NETAPI_TIMER_LIST_T fired_list,\r
+        uint64_t currentTime);\r
+#endif\r
+\r
+static TIMER_GROUP_T temp_g; //temp. todo: put inot netHandle\r
+\r
+//create a timer group\r
+NETAPI_TIMER_GROUP_HANDLE_T netapi_TimerGroupCreate(\r
+        NETAPI_T  netHandle,\r
+        char * name,\r
+        NETAPI_TIMER_CB_T cb,\r
+        int local,    //1 if timers local to thread\r
+        int exp2cancel,//1 if expect to cancel\r
+        int cell_width, //in ticks\r
+       int tol,        //in ticks\r
+        int maxTimers,\r
+        int *pErr)\r
+{\r
+ int ret= tim_group_create(&temp_g, TUNE_NETAPI_NUM_TIMER_CELLS, maxTimers);\r
+ if (!ret) {*pErr = NETAPI_ERR_NOMEM; return NULL;}\r
+ *pErr=0;\r
+ temp_g.cb = cb;\r
+ temp_g.local = local;\r
+ temp_g.exp2cancel= exp2cancel;\r
+ temp_g.cell_width=cell_width;\r
+ temp_g.tol=tol;\r
+ temp_g.h = netHandle;\r
+ temp_g.last_polled=(netapi_getTimestamp()/cell_width) * cell_width + (cell_width-1);\r
+ printf(">timer group %s created. width = %d (ticks)\n", name, cell_width);\r
+ return (NETAPI_TIMER_GROUP_HANDLE_T) &temp_g;\r
+}\r
+\r
+//open a [global] timer group\r
+NETAPI_TIMER_GROUP_HANDLE_T  netapi_TimerGroupOpen(\r
+        NETAPI_T netHandle,\r
+        char * name,\r
+        NETAPI_TIMER_CB_T cb,\r
+        int *pErr)\r
+{\r
+printf(">timer group open not implemented \n");\r
+\r
+}\r
+\r
+//start an individual timer\r
+NETAPI_TIMER_T netapi_TimerGroupStartTimer(\r
+        NETAPI_TIMER_GROUP_HANDLE_T th,\r
+        void * cookie,\r
+        uint64_t offs2fire,  //offset in group ticks \r
+        int * pErr)\r
+{\r
+TIM_T * timer_obj;\r
+unsigned long long ct= netapi_getTimestamp() + offs2fire* ((TIMER_GROUP_T*) th)->cell_width;\r
+int cell;\r
+*pErr=0;\r
+\r
+//find cell where to insert\r
+cell = our_hash(ct,((TIMER_GROUP_T*) th)->n_cells , ((TIMER_GROUP_T*) th)->cell_width);\r
+\r
+//get object and insert into this cell\r
+timer_obj =tim_set(\r
+   &((TIMER_GROUP_T*) th)->cells[cell],\r
+   &((TIMER_GROUP_T*) th)->free , \r
+   ct,\r
+   cookie,\r
+   pErr);\r
+if (!timer_obj)  {return NULL;}\r
+//DEBUGprintf(">timer: setting timer %x for %lld ticks -> hased to cell %d\n",cookie, ct,cell);\r
+return (NETAPI_TIMER_T) timer_obj;\r
+}\r
+\r
+//Cancel a timer\r
+void  netapi_TimerGroupCancel(\r
+        NETAPI_TIMER_GROUP_HANDLE_T th,\r
+        NETAPI_TIMER_T timerId,\r
+        int *pErr)\r
+{\r
+    tim_cancel((TIM_T *) timerId, pErr);\r
+}\r
+\r
+//close an opened timer group\r
+void netapi_TimerGroupClose(\r
+        NETAPI_TIMER_GROUP_HANDLE_T th,\r
+        int *pErr){}\r
+\r
+//delete atimer group\r
+void netapi_TimerGroupDelete(\r
+        NETAPI_TIMER_GROUP_HANDLE_T th,\r
+        int *pErr) {printf(">timer group delete not implemented\n");}\r
+\r
+//extract netapi handle from timer group handle\r
+NETAPI_T netap_TimerGroupGetNH( NETAPI_TIMER_GROUP_HANDLE_T th) { return ((TIMER_GROUP_T*) th)->h; }\r
+\r
+\r
+//-----for timer debuggingi-------\r
+struct\r
+{\r
+//last poll stats\r
+int n_tot;\r
+int c_seen;\r
+\r
+int max_c_seen;\r
+int max_n_tot;\r
+\r
+} timer_poll_stats;\r
+void dump_poll_stats(void)\r
+{\r
+  printf("debug timer poll> n_tot=%d c_seen=%d mnt=%d mcs=%d\n",\r
+             timer_poll_stats.n_tot, timer_poll_stats.c_seen,\r
+             timer_poll_stats.max_n_tot, timer_poll_stats.max_c_seen);\r
+}\r
+//-------end timer debugging----\r
+\r
+//poll a specific timer group\r
+int  netapi_TimerGroupPoll(NETAPI_TIMER_GROUP_HANDLE_T th, int maxTimers)\r
+{\r
+unsigned long long ct= netapi_getTimestamp(); \r
+unsigned long long i;\r
+int cell;\r
+TIM_LIST_T res={NULL,NULL};\r
+int n;\r
+int n_tot=0;\r
+int c_seen=0;\r
+\r
+   for(i=((TIMER_GROUP_T*) th)->last_polled; (i<= ct) && (n_tot<maxTimers); )\r
+   {\r
+      cell =  our_hash(i,((TIMER_GROUP_T*) th)->n_cells , ((TIMER_GROUP_T*) th)->cell_width); \r
+      tim_return_fired_list(&((TIMER_GROUP_T*) th)->cells[cell],\r
+                           &res,\r
+                            &((TIMER_GROUP_T*) th)->free,\r
+                            i,  \r
+                            &n);\r
+      n_tot+=n;\r
+      i += ((TIMER_GROUP_T*) th)->cell_width; \r
+      c_seen+=1;\r
+   }\r
+   if (n_tot)\r
+      {\r
+           ((TIMER_GROUP_T*) th)->cb(th, n_tot, (NETAPI_TIMER_LIST_T) &res, ct);\r
+           tim_return_free(&((TIMER_GROUP_T*) th)->free,&res,n_tot);\r
+      }\r
+\r
+   ((TIMER_GROUP_T*) th)->last_polled = i;\r
+   if (c_seen) timer_poll_stats.n_tot = n_tot;\r
+   if (c_seen) timer_poll_stats.c_seen = c_seen;\r
+   if (n_tot > timer_poll_stats.max_n_tot) timer_poll_stats.max_n_tot = n_tot;\r
+   if (c_seen > timer_poll_stats.max_c_seen) timer_poll_stats.max_c_seen = c_seen;\r
+   return n_tot;\r
+}\r
+\r
+//poll all timers\r
+int  netapi_TimerGroupPollAll(NETAPI_T nh, NETAPI_TIMER_FILTER_T f,  int maxTimers)\r
+{\r
+ //todo: use filters and poll global, local lists in nh\r
+ if (temp_g.h)\r
+    netapi_TimerGroupPoll(&temp_g, maxTimers);\r
+ return 0;\r
+}\r
+\r
+\r
index ce1aa04ed98bfd3b70cb502bf3131121f12cbdd3..dd4b0461da9ea45a59322d577f0934a36cc4a13b 100644 (file)
@@ -1,55 +1,55 @@
-/******************************************************
- *  File: netapi_util.h
- *  Purpose:  misc utilites
- **************************************************************
- * FILE: netapi_util.h
- * 
- * DESCRIPTION:  netapi utility header file for user space transport
- *               library
- * 
- * REVISION HISTORY:  rev 0.0.1 
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- *****************************************************/
-#ifndef __NETAPI_UTIL__H
-#define __NETAPI_UTIL__H
-/* timing */
-static inline unsigned long netapi_timing_start(void)
-{
-        volatile int vval;
-        //read clock
-        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval));
-        return vval;
-}
-#define netapi_timing_stop  netapi_timing_start
-
-#endif
+/******************************************************\r
+ *  File: netapi_util.h\r
+ *  Purpose:  misc utilites\r
+ **************************************************************\r
+ * FILE: netapi_util.h\r
+ * \r
+ * DESCRIPTION:  netapi utility header file for user space transport\r
+ *               library\r
+ * \r
+ * REVISION HISTORY:  rev 0.0.1 \r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+ *****************************************************/\r
+#ifndef __NETAPI_UTIL__H\r
+#define __NETAPI_UTIL__H\r
+/* timing */\r
+static inline unsigned long netapi_timing_start(void)\r
+{\r
+        volatile int vval;\r
+        //read clock\r
+        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval));\r
+        return vval;\r
+}\r
+#define netapi_timing_stop  netapi_timing_start\r
+\r
+#endif\r
index 98d4c8337b211b430db1f8993d83d8f7daf3e5b2..9a0f99decc325da265cf14db280254f9d37a5514 100644 (file)
@@ -1,53 +1,53 @@
-/************************************************
- * FILE: netapi_vm.h
- * PURPOSE: netapi [virtual] memory management
- ************************************************/
-#ifndef __NETAPI_VM_H__
-#define __NETAPI_VM_H__
-#include "netapi_tune.h"
-#include "ti/drv/nwal/nwal.h"
-
-/* Function to initialize memory allocator */
-nwal_Bool_t netapi_VM_memAllocInit
-(
-    uint8_t     *addr, /* Physical address */
-    uint32_t    size   /* Size of block */
-);
-
-/* Function to allocate memory */
-void* netapi_VM_memAlloc
-(
-    uint32_t    size, /* Size of block needed */
-    uint32_t    align /* Alignment of the block needed */
-);
-
-
-/* Function to map the give physical address to virtual memory space */
-void *netapi_VM_memMap
-(
-    void        *addr, /* Physical address */
-    uint32_t    size   /* Size of block */
-);
-
-//todo: put in netapi global region somewhere
-
-/* Global variables to hold virtual address of various hw subsystems */
-extern void *netapi_VM_qmssCfgVaddr;
-extern void *netapi_VM_qmssDataVaddr;
-extern void *netapi_VM_srioCfgVaddr;
-extern void *netapi_VM_passCfgVaddr;
-
-/* Physical address of the [only] memory pool */
-extern uint8_t *netapi_VM_mem_start_phy;
-
-/* virtual address of the [only] memory pool */
-extern uint8_t *netapi_VM_mem_start;
-
-//qm regions: netapi defines two regions, 0,1
-extern unsigned char *netapi_VM_QMemLocalDescRam;
-extern unsigned char *netapi_VM_QMemGlobalDescRam;
-#define NETAPI_GLOBAL_REGION 0 
-#define NETAPI_LOCAL_REGION 1 
-
-#endif
-
+/************************************************\r
+ * FILE: netapi_vm.h\r
+ * PURPOSE: netapi [virtual] memory management\r
+ ************************************************/\r
+#ifndef __NETAPI_VM_H__\r
+#define __NETAPI_VM_H__\r
+#include "netapi_tune.h"\r
+#include "ti/drv/nwal/nwal.h"\r
+\r
+/* Function to initialize memory allocator */\r
+nwal_Bool_t netapi_VM_memAllocInit\r
+(\r
+    uint8_t     *addr, /* Physical address */\r
+    uint32_t    size   /* Size of block */\r
+);\r
+\r
+/* Function to allocate memory */\r
+void* netapi_VM_memAlloc\r
+(\r
+    uint32_t    size, /* Size of block needed */\r
+    uint32_t    align /* Alignment of the block needed */\r
+);\r
+\r
+\r
+/* Function to map the give physical address to virtual memory space */\r
+void *netapi_VM_memMap\r
+(\r
+    void        *addr, /* Physical address */\r
+    uint32_t    size   /* Size of block */\r
+);\r
+\r
+//todo: put in netapi global region somewhere\r
+\r
+/* Global variables to hold virtual address of various hw subsystems */\r
+extern void *netapi_VM_qmssCfgVaddr;\r
+extern void *netapi_VM_qmssDataVaddr;\r
+extern void *netapi_VM_srioCfgVaddr;\r
+extern void *netapi_VM_passCfgVaddr;\r
+\r
+/* Physical address of the [only] memory pool */\r
+extern uint8_t *netapi_VM_mem_start_phy;\r
+\r
+/* virtual address of the [only] memory pool */\r
+extern uint8_t *netapi_VM_mem_start;\r
+\r
+//qm regions: netapi defines two regions, 0,1\r
+extern unsigned char *netapi_VM_QMemLocalDescRam;\r
+extern unsigned char *netapi_VM_QMemGlobalDescRam;\r
+#define NETAPI_GLOBAL_REGION 0 \r
+#define NETAPI_LOCAL_REGION 1 \r
+\r
+#endif\r
+\r
index 4b07528aa5e57082755682f09d530c90ad7018f6..6408e6221765e557e240cd1ac1f50edc6a36e72e 100755 (executable)
@@ -76,6 +76,71 @@ static NetapiNwalTransInfo_t *  netapi_GetFreeTransInfo(NETAPI_GLOBAL_T *p_globa
         return NULL;\r
 \r
 }\r
+//internal: build route\r
+static void netcp_cfgp_build_route(NETCP_CFG_ROUTE_T * p_route, int16_t * p_flow,  Qmss_QueueHnd * p_q)\r
+{\r
+    if (!p_route) return;\r
+    if (p_route->p_flow)  *p_flow= p_route->p_flow->flowid;\r
+    else *p_flow = CPPI_PARAM_NOT_SPECIFIED;\r
+    if (p_route->p_dest_q) *p_q = pktio_get_q(p_route->p_dest_q);\r
+    else *p_q=QMSS_PARAM_NOT_SPECIFIED;\r
+}\r
+\r
+//internal: find a free slot for a flow \r
+static int netcp_cfgp_find_flow_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p)\r
+{\r
+   int i;\r
+         //find a free entry\r
+   for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)\r
+   {\r
+       if (!p->flows[i].in_use)\r
+       {\r
+           p->flows[i].in_use = 2; //pending\r
+           return i;\r
+       }\r
+   }\r
+   return -1;\r
+}\r
+\r
+//internal: clear flow slot \r
+static void netcp_cfgp_delete_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int slot)\r
+{\r
+   if ((slot >=0 ) && (slot < TUNE_NETAPI_MAX_FLOWS))\r
+   {\r
+        p->flows[slot].in_use = 0;\r
+   }\r
+}\r
+\r
+//internal:  insert a flow into flow slot\r
+ static NETCP_CFG_FLOW_HANDLE_T netcp_cfgp_insert_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
+                          int slot,  //we 'reserved it already'\r
+                          void * handle)  //cppi flow handle. Save this for delete\r
+{\r
+        p->flows[slot].in_use=1;\r
+        p->flows[slot].handle = handle;\r
+       p->flows[slot].flow.flowid  = Cppi_getFlowId(handle);\r
+        return (NETCP_CFG_FLOW_HANDLE_T) &p->flows[slot].flow;\r
+}\r
+\r
+//find entry matching the flowid.  return slot# and the cppi handle\r
+static int netcp_cfgp_find_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
+                          int flowid,  \r
+                          void ** handle) \r
+{\r
+int i;\r
+   *handle=NULL;\r
+   for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)\r
+   {\r
+       if ((p->flows[i].in_use)&&(p->flows[i].flow.flowid == flowid))\r
+       {\r
+           *handle = p->flows[i].handle;\r
+           return i;\r
+       }\r
+   }\r
+   return -1;\r
+}\r
+\r
+\r
 \r
 //internal: find a free slot for IP rule in interface\r
 static int netcp_cfgp_find_ip_slot(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
@@ -238,8 +303,8 @@ static void netcp_cfgp_insert_class(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
         return;\r
 }\r
 \r
-//internal: return nwal_handle for class\r
-static void *netcp_cfgp_get_class_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
+//internal: return L4 nwal_handle for class\r
+static void *netcp_cfgp_get_l4_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
                           int class_slot)\r
 {\r
    if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;\r
@@ -247,6 +312,16 @@ static void *netcp_cfgp_get_class_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
    return p->classi[class_slot].nwal_L4_handle;\r
 }\r
 \r
+//internal: return L3 nwal_handle for class\r
+static void *netcp_cfgp_get_l3_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,\r
+                          int class_slot)\r
+{\r
+   if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;\r
+   if (!p->classi[class_slot].in_use) return NULL;\r
+   return p->classi[class_slot].nwal_L3_handle;\r
+}\r
+\r
+\r
 /***********************************************************************************/\r
 /****************************************API****************************************/\r
 /***********************************************************************************/\r
@@ -264,6 +339,7 @@ nwal_TransID_t     transId;
 if ((!n) || (!cb)) {*err = NETAPI_ERR_BAD_INPUT; return ;}\r
 *err =0;\r
 \r
+\r
 pTransInfo = netapi_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &transId);\r
 if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return ;}\r
 pTransInfo->transType = NETAPI_NWAL_HANDLE_STAT_REQUEST;\r
@@ -324,14 +400,10 @@ nwal_TransID_t     trans_id;
     /* todo: vlan */\r
     MacInfo.ifNum = switch_port;  /* todo: check for 0/1 relative*/\r
 \r
-#if 0  //todo\r
     if (route != NULL)\r
     {\r
-        MacInfo.appRxPktFlowId = ((NETCP_CFG_FLOW_T *)(route.flow))->flowid;\r
-        MacInfo.appRxPktQueue = PKTIO_GET_Q(route->p_dest_q);\r
-        //handle action ??\r
+        netcp_cfgp_build_route(route,&MacInfo.appRxPktFlowId, &MacInfo.appRxPktQueue);\r
     }\r
-#endif\r
     pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_OPEN_PENDING;\r
     retValue = nwal_setMacIface( ((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,\r
                                   trans_id,\r
@@ -493,7 +565,7 @@ NETCP_CFG_IP_T temp;
      nwalIpParam.ipType=ipType;\r
      if(route)\r
      {\r
-          //todo: support app defined routes\r
+        netcp_cfgp_build_route(route,&nwalIpParam.appRxPktFlowId, &nwalIpParam.appRxPktQueue);\r
      } \r
      else{} //use nwal defaults\r
      if (ip_qualifiers)\r
@@ -576,11 +648,13 @@ NETCP_CFG_IP_T  netcp_cfgAddIp(
 /*****************************************************************/\r
 /***************Delete an attached IP*****************************/\r
 /*****************************************************************/\r
-void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,\r
+static void netcp_cfgDelIpInternal(NETAPI_T h, int iface_no,  nwal_IpType ipType,\r
                   nwalIpAddr_t  * ip_addr,\r
                   nwalIpOpt_t * ip_qualifiers, \r
                   NETCP_CFG_IP_T  ip_rule_id,\r
-                  int *err)\r
+                  int *err, \r
+                  void * handle,   /* if flag==0, handle must be valid */\r
+                  int flag)        /* flag==0 => delete IP rule that was part of classifier, not interface */\r
 {\r
     nwal_RetValue ret;\r
     NetapiNwalTransInfo_t *pTransInfo;\r
@@ -590,16 +664,23 @@ void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,
     int ip_slot = (ip_rule_id>>8)&0xff;\r
 \r
     //get the nwal handle assoicated with this ip   \r
-    ifHandle = netcp_cfgp_get_ip_handle(\r
-         &netapi_get_global()->nwal_context, iface_no,\r
-         ip_slot );\r
+    if (flag)\r
+    {\r
+       ifHandle = netcp_cfgp_get_ip_handle(\r
+                 &netapi_get_global()->nwal_context, iface_no,\r
+                 ip_slot );\r
+    }\r
+    else \r
+    {\r
+       ifHandle = handle;\r
+    }\r
     if(!ifHandle)\r
             {*err = NETAPI_ERR_BAD_INPUT; return ;}\r
     *err =0;\r
 \r
     //get a transaction id\r
     pTransInfo = netapi_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);\r
-  if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return ;}\r
+    if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return ;}\r
     pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_IP;\r
     pTransInfo->netapi_handle = h;\r
     //issue request\r
@@ -627,23 +708,44 @@ void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,
             nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);\r
         }\r
     }\r
-    printf (">netcp cfg: IP i/f deleted\n");\r
+    if (flag)\r
+       printf (">netcp cfg: attached IP deleted\n");\r
+    else\r
+       printf (">netcp cfg: Classifier IP rule deleted\n");\r
     pTransInfo->state =  NETAPI_NWAL_HANDLE_STATE_IDLE;\r
     pTransInfo->inUse = nwal_FALSE;\r
+\r
     //zap the entry\r
-    netcp_cfgp_delete_ip(&netapi_get_global()->nwal_context,  \r
+    if (flag)\r
+       netcp_cfgp_delete_ip(&netapi_get_global()->nwal_context,  \r
                          iface_no,\r
                          ip_slot);\r
     return ;\r
 }\r
 \r
+/*****************************************************************/\r
+/***************Delete an attached IP*****************************/\r
+/*****************************************************************/\r
+void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,\r
+                  nwalIpAddr_t  * ip_addr,\r
+                  nwalIpOpt_t * ip_qualifiers,\r
+                  NETCP_CFG_IP_T  ip_rule_id,\r
+                  int *err)\r
+{\r
+       netcp_cfgDelIpInternal( h, iface_no, ipType,\r
+                  ip_addr, ip_qualifiers, ip_rule_id,\r
+                  err, NULL, 1);\r
+       return;\r
+}\r
+\r
+\r
 /**\r
  * @def netcp_cfgAddClass\r
  * @brief  add a classifier rule into NETCP\r
  **/\r
 NETCP_CFG_CLASS_T netcp_cfgAddClass(NETAPI_T h,\r
                                       NETCP_CFG_CLASSIFIER_T *p_class,\r
-                                      NETCP_CFG_ROUTE_HANDLE_T p_route,\r
+                                      NETCP_CFG_ROUTE_HANDLE_T route,\r
                                       int action, int * err)\r
 {\r
 NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;\r
@@ -761,7 +863,11 @@ case(NETCP_CFG_CLASS_TYPE_L4):
        }\r
         \r
         tempCfg.matchAction = (action==NETCP_CFG_ACTION_TO_SW)  ? NWAL_MATCH_ACTION_HOST : NWAL_MATCH_ACTION_DISCARD;\r
-        //todo: flowid and route \r
+       if (route)\r
+        {\r
+               netcp_cfgp_build_route(route,&tempCfg.appRxPktFlowId, &tempCfg.appRxPktQueue);\r
+       }\r
+\r
         //get a transaction id\r
         pTransInfo = netapi_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);\r
         if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return -1 ;}\r
@@ -815,7 +921,8 @@ void netcp_cfgDelClass(NETAPI_T h,
                          int *err)\r
 {\r
 NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;\r
-void * class_handle;  //class handle\r
+void * L4_handle;  //class handle -> L4\r
+void * L3_handle;  //class handle -> L3\r
 nwal_RetValue       retValue;\r
 NetapiNwalTransInfo_t *pTransInfo;\r
 nwal_TransID_t     trans_id;\r
@@ -824,29 +931,34 @@ int class_slot=-1;
 //int ip_slot;\r
 \r
        class_slot = (classId>>8)&0xffff;\r
-        class_handle=netcp_cfgp_get_class_handle(\r
+        L4_handle=netcp_cfgp_get_l4_handle(\r
                        &netapi_get_global()->nwal_context,\r
                        class_slot );\r
-        if(!class_handle)  {*err = NETAPI_ERR_BAD_INPUT; return -1;}\r
+        if(!L4_handle)  {*err = NETAPI_ERR_BAD_INPUT; return ;}\r
+        L3_handle = netcp_cfgp_get_l3_handle(\r
+                        &netapi_get_global()->nwal_context,\r
+                        class_slot );\r
+        /* l3 handle might be NULL,, depending on type of classifier */\r
+\r
        netcp_cfgp_delete_class(\r
                         &netapi_get_global()->nwal_context,\r
                         class_slot );\r
         //get a transaction id\r
         pTransInfo = netapi_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);\r
-        if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return -1 ;}\r
+        if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return  ;}\r
         pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_IP;\r
         pTransInfo->netapi_handle = h;\r
-        //issue request\r
+        //issue request for L4\r
         retValue = nwal_delConn(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,\r
                             trans_id,\r
-                            class_handle);\r
+                            L4_handle);\r
         if(retValue !=  nwal_OK)\r
         {\r
             *err = NETAPI_ERR_NWAL_ERR0;\r
             printf (">netcp cfg - ERROR: nwal_delConn returned Error Code %d\n",\r
                     retValue);\r
             pTransInfo->inUse = nwal_FALSE;\r
-            return -1;\r
+            return ;  /* todo: what about the L3? */\r
         }\r
         //wait here until its done since scheduler isn't running yet most likely..\r
         // todo:  make this handled by scheduler poll later ??\r
@@ -863,10 +975,150 @@ int class_slot=-1;
          printf (">netcp cfg: Classifer deleted\n");\r
          pTransInfo->state =  NETAPI_NWAL_HANDLE_STATE_IDLE;\r
          pTransInfo->inUse = nwal_FALSE;\r
+\r
+         /* delete L3 if we have to */\r
+         if (L3_handle)\r
+         {\r
+             netcp_cfgDelIpInternal( h, 0, 0,\r
+                  NULL, NULL, 0,\r
+                  err, L3_handle,  0);\r
+         }\r
          return ;\r
 }\r
 \r
 \r
+/*--------------flow management--------*/\r
+// ADD A Flow\r
+NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T h,\r
+                                            int n,\r
+                                            Pktlib_HeapHandle handles[],\r
+                                            int sizes[],\r
+                                            int * err )\r
+{\r
+  Cppi_RxFlowCfg  rxFlowCfg;\r
+  Uint8           isAlloc;\r
+  Qmss_QueueHnd   rxBufQ[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];\r
+  Uint32          rxBufSize[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];\r
+  int             i;\r
+  Cppi_FlowHnd FlowHnd;\r
+  int  slot;\r
+  NETCP_CFG_FLOW_HANDLE_T retVal;\r
+\r
+  *err= 0;  /* ok */\r
+  //get a slot to save new flow\r
+  slot = netcp_cfgp_find_flow_slot(&netapi_get_global()->nwal_context);\r
+  if (slot<0) { *err= NETAPI_ERR_NOMEM;  return NULL; }\r
+\r
+  //configure flow\r
+  memset(&rxFlowCfg,0,sizeof(Cppi_RxFlowCfg));\r
+  for (i = 0; i < TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW; i++)\r
+  {\r
+      if (i >= n)\r
+      {\r
+          rxBufQ[i] = 0;\r
+          rxBufSize[i] = 0;\r
+      } else\r
+      {\r
+          rxBufQ[i] =   Pktlib_getInternalHeapQueue(handles[i]);\r
+          //todo: verity sizes< heapsize\r
+         //todo: verify order\r
+          rxBufSize[i]= sizes[i];\r
+      }\r
+      if (i && (rxBufQ[i] <= 0))\r
+      {\r
+          rxBufQ[i] = rxBufQ[i-1];\r
+          rxBufSize[i] = 0;\r
+      }\r
+  }\r
+  /* Configure Rx flow */\r
+  rxFlowCfg.flowIdNum      = CPPI_PARAM_NOT_SPECIFIED;\r
+  rxFlowCfg.rx_dest_qnum   = 100;   //DANGEROUS>  TODO PUT VALID Q HERE\r
+  rxFlowCfg.rx_dest_qmgr   = 0;\r
+  rxFlowCfg.rx_sop_offset  = 0;\r
+  rxFlowCfg.rx_ps_location = Cppi_PSLoc_PS_IN_DESC;\r
+  rxFlowCfg.rx_desc_type   = Cppi_DescType_HOST;\r
+  rxFlowCfg.rx_error_handling = 0;\r
+\r
+  rxFlowCfg.rx_psinfo_present = 1;\r
+  rxFlowCfg.rx_einfo_present  = 1;\r
+\r
+  rxFlowCfg.rx_dest_tag_lo = 0;\r
+  rxFlowCfg.rx_dest_tag_hi = 0;\r
+  rxFlowCfg.rx_src_tag_lo  = 0;\r
+  rxFlowCfg.rx_src_tag_hi  = 0;\r
+\r
+  rxFlowCfg.rx_size_thresh0_en = rxBufSize[1] ? 1 : 0;\r
+  rxFlowCfg.rx_size_thresh1_en = rxBufSize[2] ? 1 : 0;\r
+  rxFlowCfg.rx_size_thresh2_en = rxBufSize[3] ? 1 : 0;\r
+\r
+  rxFlowCfg.rx_dest_tag_lo_sel = 0;\r
+  rxFlowCfg.rx_dest_tag_hi_sel = 0;\r
+  rxFlowCfg.rx_src_tag_lo_sel  = 0;\r
+  rxFlowCfg.rx_src_tag_hi_sel  = 0;\r
+\r
+  rxFlowCfg.rx_fdq1_qnum = rxBufQ[1];\r
+  rxFlowCfg.rx_fdq1_qmgr = 0;\r
+  rxFlowCfg.rx_fdq2_qnum = rxBufQ[2];\r
+\r
+  rxFlowCfg.rx_fdq2_qmgr = 0;\r
+  rxFlowCfg.rx_fdq3_qnum = rxBufQ[3];\r
+\r
+  rxFlowCfg.rx_fdq3_qmgr = 0;\r
+\r
+  rxFlowCfg.rx_size_thresh0 = rxBufSize[1] ? rxBufSize[0] : 0;\r
+  rxFlowCfg.rx_size_thresh1 = rxBufSize[2] ? rxBufSize[1] : 0;\r
+  rxFlowCfg.rx_size_thresh2 = rxBufSize[3] ? rxBufSize[2] : 0;\r
+\r
+  rxFlowCfg.rx_fdq0_sz0_qnum = rxBufQ[0];\r
+  rxFlowCfg.rx_fdq0_sz0_qmgr = 0;\r
+  rxFlowCfg.rx_fdq0_sz1_qnum = rxBufQ[1];\r
+  rxFlowCfg.rx_fdq0_sz1_qmgr = 0;\r
+  rxFlowCfg.rx_fdq0_sz2_qnum = rxBufQ[2];\r
+  rxFlowCfg.rx_fdq0_sz2_qmgr = 0;\r
+  rxFlowCfg.rx_fdq0_sz3_qnum = rxBufQ[3];\r
+  rxFlowCfg.rx_fdq0_sz3_qmgr = 0;\r
+\r
+ {\r
+  //todo: replace this with a nwal call to get global cntx info\r
+  Cppi_CpDmaInitCfg cpdmaCfg;\r
+  memset(&cpdmaCfg,0,sizeof(Cppi_CpDmaInitCfg));\r
+  cpdmaCfg.dmaNum   = Cppi_CpDma_PASS_CPDMA;\r
+  FlowHnd =\r
+      Cppi_configureRxFlow (Cppi_open (&cpdmaCfg), &rxFlowCfg, &isAlloc);\r
+}\r
+  if (FlowHnd == NULL)\r
+  {\r
+      *err= NETAPI_ERR_NORES;\r
+      netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);\r
+      return (NULL);\r
+  }\r
+\r
+  //update slot\r
+  retVal = netcp_cfgp_insert_flow(&netapi_get_global()->nwal_context, slot, (void*) FlowHnd);\r
+  printf(">netcp cfg:  flow %d created\n",  ((NETCP_CFG_FLOW_T *) retVal)->flowid);\r
+  return ( retVal);\r
+\r
+\r
+\r
+}\r
+\r
+//Delete a flow\r
+void netcp_cfgDelFlow(NETAPI_T h , NETCP_CFG_FLOW_HANDLE_T f , int * err)\r
+{\r
+       int slot;\r
+       void * handle;\r
+       *err=0;\r
+        /* find entry */\r
+        slot = netcp_cfgp_find_flow(&netapi_get_global()->nwal_context, ((NETCP_CFG_FLOW_T *) f) ->flowid, &handle);\r
+       if (slot<0) {*err = NETAPI_ERR_BAD_INPUT; return;}\r
+\r
+       Cppi_closeRxFlow( (Cppi_FlowHnd) handle);\r
+        netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);\r
+        printf(">netcp cfg:  flow %d deleted\n",  ((NETCP_CFG_FLOW_T *) f)->flowid);\r
+        return;\r
+}\r
+\r
+\r
 /*************************************************************************/\r
 /*********************************INTERNAL*******************************/\r
 /************************************************************************/\r
index 0fae54d31f693e6a25186cb159f02fe46bcb7ee1..818621b4f2b47ebbdaba0bac82255a70ca216f48 100644 (file)
-/******************************************************************************
- * FILE PURPOSE:  Functions to OSAL related routines for running NWAL, PA, QMSS,etc
- ******************************************************************************
- * FILE NAME:   osal.c
- *
- * DESCRIPTION: Functions to initialize framework resources for running NWAL
- *
- * REVISION HISTORY:
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-/* CSL RL includes */
-#include <ti/csl/cslr_device.h>
-#include <ti/csl/csl_pscAux.h>
-#include <ti/csl/csl_semAux.h>
-#include <ti/csl/csl_cacheAux.h>
-#include <ti/csl/csl_xmcAux.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "netapi_vm.h"
-#include "netapi_timer.h"
-#define System_printf   printf
-
-uint32_t              Osal_qmss_MallocCounter =0;
-uint32_t              Osal_qmss_FreeCounter =0;
-uint32_t              Osal_cppi_MallocCounter =0;
-uint32_t              Osal_cppi_FreeCounter =0;
-
-
-
-/* TODO: */
-#define DNUM    0
-
-#if 0
-uint32_t globalCritkey;
-
-/* Lock to be used for critical section */
-pthread_mutex_t mutex_lock;
-
-void nwalTest_osalInit() 
-{
-    pthread_mutex_init(&mutex_lock, NULL);
-    return;
-}
-
-void nwalTest_osalshutdown() 
-{
-    pthread_mutex_destroy(&mutex_lock);
-    return;
-}
-
-static inline void nwalTest_osalEnterCS()
-{
-#if 0
-    pthread_mutex_lock(&mutex_lock);
-#endif 
-    return;
-}
-
-static inline void nwalTest_osalLeaveCS()
-{
-
-#if 0
-    pthread_mutex_unlock(&mutex_lock);
-#endif
-    return;
-}
-
-#endif
-
-/*****************************************************************************
- * FUNCTION PURPOSE: Cache Invalidation Routine
- ***************************************************************************** 
- * DESCRIPTION: Cache Invalidation Routine
- *****************************************************************************/
-void Osal_invalidateCache (void *blockPtr, uint32_t size) 
-{
-    /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */
-    return;
-}
-
-/*****************************************************************************
- * FUNCTION PURPOSE: Cache Writeback Routine
- ***************************************************************************** 
- * DESCRIPTION: Cache Invalidation Routine
- *****************************************************************************/
-void Osal_writeBackCache (void *blockPtr, uint32_t size) 
-{
-    /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */
-    return;
-}
-
-
-void *  Osal_qmssMtCsEnter()
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return NULL;
-}
-
-
-void Osal_qmssMtCsExit(void *key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-void Osal_nwalCsEnter(uint32_t *key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-void Osal_nwalCsExit(uint32_t key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-
-void Osal_qmssLog ( String fmt, ... )
-{
-}
-
-
-void Osal_cppiCsEnter (uint32_t *key)
-{ 
-
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-void Osal_cppiCsExit (uint32_t key)
-{
-
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-void Osal_cppiLog ( String fmt, ... )
-{
-}
-
-void Osal_paBeginMemAccess (Ptr addr, uint32_t size)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-
-}
-
-void Osal_paEndMemAccess (Ptr addr, uint32_t size)
-{      
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-}
-
-void*  Osal_qmssCsEnter ()
-{
-    
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return(NULL);
-}
-
-void Osal_qmssCsExit (void *  key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */
-    return;
-}
-
-Ptr Osal_qmssMalloc (uint32_t num_bytes)
-{
-    Ptr ret;
-   
-    Osal_qmss_MallocCounter++;
-    ret = malloc (num_bytes);    
-    if(ret==NULL)
-    {
-      System_printf("\nERROR! QMSS Malloc failed!\n");
-    }    
-    
-    return ret;
-}
-
-void Osal_qmssFree (Ptr ptr, uint32_t size)
-{
-    /* Increment the free counter. */
-    Osal_qmss_FreeCounter++;   
-    free(ptr);
-}
-
-Ptr Osal_cppiMalloc (uint32_t num_bytes)
-{
-    Ptr ret;
-    
-    Osal_cppi_MallocCounter++;
-    num_bytes += (CACHE_L2_LINESIZE-1);
-    ret = malloc (num_bytes);
-
-    if(ret==NULL)
-    {
-      System_printf("\nERROR! CPPI Malloc failed!\n");
-    }   
-    
-    return ret;
-}
-
-void Osal_cppiFree (Ptr ptr, uint32_t size)
-{
-    /* Increment the free counter. */
-    Osal_cppi_FreeCounter++;   
-    free(ptr);    
-}
-
-void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_invalidateCache(blockPtr,size);
-    return;
-}
-
-void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_writeBackCache(blockPtr,size);
-    return;
-}
-
-void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_invalidateCache(blockPtr,size);
-    return;
-}
-
-void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_writeBackCache(blockPtr,size);
-    return;
-}
-
-void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)
-{
-    Osal_invalidateCache(blockPtr,size);
-    return;
-}
-
-void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)
-{
-    Osal_writeBackCache(blockPtr,size);
-    return;
-}
-
-uint32_t Osal_nwalGetCacheLineSize (void )
-{
-    /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */
-    return (CACHE_L2_LINESIZE);
-}
-
-/********************************************************************
- * FUNCTION PURPOSE: Convert local address to global
- ********************************************************************
- * DESCRIPTION: Returns global address
- ********************************************************************/
-
-unsigned int Osal_nwalLocToGlobAddr(unsigned int x)
-{
-    return x;
-}
-
-uint16_t Osal_nwalGetProcId (void )
-{
-    return DNUM;
-}
-uint64_t Osal_nwalGetTimeStamp(void)
-{
-    /* Stub function to return timestamp
-     */
-    return netapi_getTimestamp();
-}
-#ifdef NWAL_ENABLE_SA 
-void Osal_saCsEnter (uint32_t *key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */ 
-    ((CSL_semAcquireDirect (SA_HW_SEM)) == 0); 
-    return;
-}
-
-void Osal_saCsExit (uint32_t key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */ 
-    return;
-}
-
-
-void Osal_saMtCsEnter (uint32_t *key)
-{
-   /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */ 
-    return;
-}
-
-void Osal_saMtCsExit (uint32_t key)
-{
-    /* Stub Function. TBD: Would need to handle when for multi proc access 
-     * To be handled once infrastructure is available from Kernel
-     */ 
-    return;
-}
-
-void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_invalidateCache(blockPtr,size);
-    return;
-}
-
-void Osal_saEndMemAccess (void *blockPtr, uint32_t size)
-{
-    Osal_writeBackCache(blockPtr,size);
-    return;
-}
-
-
-
-void Osal_saBeginScAccess (void* addr, uint32_t size)
-{
-   Osal_invalidateCache(addr,size);  
-        
-}
-void Osal_saEndScAccess   (void* addr, uint32_t size)
-{
-    Osal_writeBackCache(addr,size);
-    
-}
-
-#endif
-
-void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)
-{
-    Osal_invalidateCache(ptr,size);
-}
-
-
-void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)
-{
-    Osal_writeBackCache(ptr,size);
-}
-
-
-void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
-{
-    /* TODO: We should use the 'heapHandle' and compare it with what we got from the
-     * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
-     * Just for testing we are always invalidating the cache here. */
-
-     Osal_invalidateCache(ptrPkt,size);
-}
-
-
-void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)
-{
-    /* TODO: We should use the 'heapHandle' and compare it with what we got from the
-     * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
-     * Just for testing we are always writing back the cache here. */
-
-    /* Writeback the contents of the cache. */
-    Osal_writeBackCache(ptrPkt,size);
-}
-
-
-void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)
-{
-    /* TODO: We should use the 'heapHandle' and compare it with what we got from the
-     * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
-     * Implementations here could range from a MULTI-THREAD protection if the packets in 
-     * the heap are being accessed across multiple threads or MULTI-CORE if the packets
-     * are being accessed across multiple cores and features: split and clone are used.
-     * For NWAL layer no protection required.
-     *
-     * For testing we are not doing any of this so we are simply setting it to NOOP */
-    return NULL;
-}
-
-
-void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)
-{
-    /* TODO: We should use the 'heapHandle' and compare it with what we got from the
-     * 'create/find' HEAP API & depending upon the comparison take appropriate action. 
-     * Implementations here could range from a MULTI-THREAD protection if the packets in 
-     * the heap are being accessed across multiple threads or MULTI-CORE if the packets
-     * are being accessed across multiple cores and features: split and clone are used.
-     * For NWAL layer no protection required.. 
-     *
-     * For testing we are not doing any of this so we are simply setting it to NOOP */
-    return;        
-}
-
-void* Osal_qmssVirtToPhy (void *ptr)
-{
-    return (void *)(netapi_VM_mem_start_phy + ((uint8_t*)ptr - netapi_VM_mem_start));
-}
-
-void* Osal_qmssPhyToVirt (void *ptr)
-{
-    if (!ptr) return (void *) 0;
-    //todo, see if out of range of mem_start_phy and size!! (like mmu would do)
-    return (void *)(netapi_VM_mem_start + ((uint8_t*)ptr - netapi_VM_mem_start_phy));
-}
-
-/******************************************************************************
-* Function to traverse a CPPI descriptor and convert all address references
-* from virtual to physical.
-******************************************************************************/
-void* Osal_qmssConvertDescVirtToPhy(void *descAddr)
-{
-    if (!descAddr) return (void *)0;
-
-    if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
-    {
-        Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
-        Cppi_HostDesc *prevBDPtr = 0;
-        while (nextBDPtr)
-        {
-            void *buffPtr;
-            if (nextBDPtr->buffPtr)
-            {
-                buffPtr = (void *)nextBDPtr->buffPtr;
-                nextBDPtr->buffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->buffPtr));
-                if (!(nextBDPtr->buffPtr)) return (void *)0;
-            }
-
-            if (nextBDPtr->origBuffPtr)
-            {
-                nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->origBuffPtr));
-                if (!(nextBDPtr->origBuffPtr)) return (void *)0;
-            }
-
-            prevBDPtr = nextBDPtr;
-            nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
-            if (prevBDPtr->nextBDPtr)
-            {
-                prevBDPtr->nextBDPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(prevBDPtr->nextBDPtr));
-                if (!(prevBDPtr->nextBDPtr)) return (void *)0;
-            }
-
-            Qmss_osalEndMemAccess(buffPtr, prevBDPtr->buffLen);
-            Qmss_osalEndMemAccess(prevBDPtr, sizeof(Cppi_HostDesc));
-        }
-        descAddr = Osal_qmssVirtToPhy(descAddr);
-        if (!descAddr) return (void *)0;
-    }
-    else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
-    {
-        descAddr = Osal_qmssVirtToPhy(descAddr);
-        if (!descAddr) return (void *)0;
-    }
-    return descAddr;
-
-}
-
-
-/******************************************************************************
-* Function to traverse a CPPI descriptor and convert all address references
-* from physical to virtual.
-******************************************************************************/
-void* Osal_qmssConvertDescPhyToVirt(void *descAddr)
-{
-    if (!descAddr) return (void *)0;
-    descAddr = Osal_qmssPhyToVirt(descAddr);
-
-    if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)
-    {
-        Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);
-        while (nextBDPtr)
-        {
-            Qmss_osalBeginMemAccess(nextBDPtr, sizeof(Cppi_HostDesc));
-            if (nextBDPtr->buffPtr)
-            {
-                nextBDPtr->buffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->buffPtr));
-                if (!(nextBDPtr->buffPtr)) return (void *)0;
-            }
-
-            if (nextBDPtr->origBuffPtr)
-            {
-                nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->origBuffPtr));
-                if (!(nextBDPtr->origBuffPtr)) return (void *)0;
-            }
-
-            if (nextBDPtr->nextBDPtr)
-            {
-                nextBDPtr->nextBDPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->nextBDPtr));
-                if (!(nextBDPtr->nextBDPtr)) return (void *)0;
-            }
-
-            Qmss_osalBeginMemAccess((void *)(nextBDPtr->buffPtr), nextBDPtr->buffLen);
-            nextBDPtr = (void *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));
-        }
-    }
-    else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)
-    {
-        descAddr = Osal_qmssPhyToVirt(descAddr);
-        if (!descAddr) return (void *)0;
-    }
-    return descAddr;
-}
-
-void* Osal_stubCsEnter (void)
-{
-
-
-}
-void Osal_stubCsExit (void *CsHandle)
-{
-    /* Release Semaphore using handle */
-
-
-    return;
-}
-
+/******************************************************************************\r
+ * FILE PURPOSE:  Functions to OSAL related routines for running NWAL, PA, QMSS,etc\r
+ ******************************************************************************\r
+ * FILE NAME:   osal.c\r
+ *\r
+ * DESCRIPTION: Functions to initialize framework resources for running NWAL\r
+ *\r
+ * REVISION HISTORY:\r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ */\r
+\r
+/* CSL RL includes */\r
+#include <ti/csl/cslr_device.h>\r
+#include <ti/csl/csl_pscAux.h>\r
+#include <ti/csl/csl_semAux.h>\r
+#include <ti/csl/csl_cacheAux.h>\r
+#include <ti/csl/csl_xmcAux.h>\r
+\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+\r
+#include "netapi_vm.h"\r
+#include "netapi_timer.h"\r
+#define System_printf   printf\r
+\r
+uint32_t              Osal_qmss_MallocCounter =0;\r
+uint32_t              Osal_qmss_FreeCounter =0;\r
+uint32_t              Osal_cppi_MallocCounter =0;\r
+uint32_t              Osal_cppi_FreeCounter =0;\r
+\r
+\r
+\r
+/* TODO: */\r
+#define DNUM    0\r
+\r
+#if 0\r
+uint32_t globalCritkey;\r
+\r
+/* Lock to be used for critical section */\r
+pthread_mutex_t mutex_lock;\r
+\r
+void nwalTest_osalInit() \r
+{\r
+    pthread_mutex_init(&mutex_lock, NULL);\r
+    return;\r
+}\r
+\r
+void nwalTest_osalshutdown() \r
+{\r
+    pthread_mutex_destroy(&mutex_lock);\r
+    return;\r
+}\r
+\r
+static inline void nwalTest_osalEnterCS()\r
+{\r
+#if 0\r
+    pthread_mutex_lock(&mutex_lock);\r
+#endif \r
+    return;\r
+}\r
+\r
+static inline void nwalTest_osalLeaveCS()\r
+{\r
+\r
+#if 0\r
+    pthread_mutex_unlock(&mutex_lock);\r
+#endif\r
+    return;\r
+}\r
+\r
+#endif\r
+\r
+/*****************************************************************************\r
+ * FUNCTION PURPOSE: Cache Invalidation Routine\r
+ ***************************************************************************** \r
+ * DESCRIPTION: Cache Invalidation Routine\r
+ *****************************************************************************/\r
+void Osal_invalidateCache (void *blockPtr, uint32_t size) \r
+{\r
+    /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */\r
+    return;\r
+}\r
+\r
+/*****************************************************************************\r
+ * FUNCTION PURPOSE: Cache Writeback Routine\r
+ ***************************************************************************** \r
+ * DESCRIPTION: Cache Invalidation Routine\r
+ *****************************************************************************/\r
+void Osal_writeBackCache (void *blockPtr, uint32_t size) \r
+{\r
+    /* Stub Function. TBD: Would need to handle when cache is enabled for ARM */\r
+    return;\r
+}\r
+\r
+\r
+void *  Osal_qmssMtCsEnter()\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return NULL;\r
+}\r
+\r
+\r
+void Osal_qmssMtCsExit(void *key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+void Osal_nwalCsEnter(uint32_t *key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+void Osal_nwalCsExit(uint32_t key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+\r
+void Osal_qmssLog ( String fmt, ... )\r
+{\r
+}\r
+\r
+\r
+void Osal_cppiCsEnter (uint32_t *key)\r
+{ \r
+\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+void Osal_cppiCsExit (uint32_t key)\r
+{\r
+\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+void Osal_cppiLog ( String fmt, ... )\r
+{\r
+}\r
+\r
+void Osal_paBeginMemAccess (Ptr addr, uint32_t size)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+\r
+}\r
+\r
+void Osal_paEndMemAccess (Ptr addr, uint32_t size)\r
+{      \r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+}\r
+\r
+void*  Osal_qmssCsEnter ()\r
+{\r
+    \r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return(NULL);\r
+}\r
+\r
+void Osal_qmssCsExit (void *  key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */\r
+    return;\r
+}\r
+\r
+Ptr Osal_qmssMalloc (uint32_t num_bytes)\r
+{\r
+    Ptr ret;\r
+   \r
+    Osal_qmss_MallocCounter++;\r
+    ret = malloc (num_bytes);    \r
+    if(ret==NULL)\r
+    {\r
+      System_printf("\nERROR! QMSS Malloc failed!\n");\r
+    }    \r
+    \r
+    return ret;\r
+}\r
+\r
+void Osal_qmssFree (Ptr ptr, uint32_t size)\r
+{\r
+    /* Increment the free counter. */\r
+    Osal_qmss_FreeCounter++;   \r
+    free(ptr);\r
+}\r
+\r
+Ptr Osal_cppiMalloc (uint32_t num_bytes)\r
+{\r
+    Ptr ret;\r
+    \r
+    Osal_cppi_MallocCounter++;\r
+    num_bytes += (CACHE_L2_LINESIZE-1);\r
+    ret = malloc (num_bytes);\r
+\r
+    if(ret==NULL)\r
+    {\r
+      System_printf("\nERROR! CPPI Malloc failed!\n");\r
+    }   \r
+    \r
+    return ret;\r
+}\r
+\r
+void Osal_cppiFree (Ptr ptr, uint32_t size)\r
+{\r
+    /* Increment the free counter. */\r
+    Osal_cppi_FreeCounter++;   \r
+    free(ptr);    \r
+}\r
+\r
+void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_invalidateCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void  Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_invalidateCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void Osal_nwalInvalidateCache (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_invalidateCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void Osal_nwalWriteBackCache (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+uint32_t Osal_nwalGetCacheLineSize (void )\r
+{\r
+    /* By default assumes L2 cache line is enabled. If not return CACHE_L1D_LINESIZE */\r
+    return (CACHE_L2_LINESIZE);\r
+}\r
+\r
+/********************************************************************\r
+ * FUNCTION PURPOSE: Convert local address to global\r
+ ********************************************************************\r
+ * DESCRIPTION: Returns global address\r
+ ********************************************************************/\r
+\r
+unsigned int Osal_nwalLocToGlobAddr(unsigned int x)\r
+{\r
+    return x;\r
+}\r
+\r
+uint16_t Osal_nwalGetProcId (void )\r
+{\r
+    return DNUM;\r
+}\r
+uint64_t Osal_nwalGetTimeStamp(void)\r
+{\r
+    /* Stub function to return timestamp\r
+     */\r
+    return netapi_getTimestamp();\r
+}\r
+#ifdef NWAL_ENABLE_SA \r
+void Osal_saCsEnter (uint32_t *key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */ \r
+    ((CSL_semAcquireDirect (SA_HW_SEM)) == 0); \r
+    return;\r
+}\r
+\r
+void Osal_saCsExit (uint32_t key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */ \r
+    return;\r
+}\r
+\r
+\r
+void Osal_saMtCsEnter (uint32_t *key)\r
+{\r
+   /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */ \r
+    return;\r
+}\r
+\r
+void Osal_saMtCsExit (uint32_t key)\r
+{\r
+    /* Stub Function. TBD: Would need to handle when for multi proc access \r
+     * To be handled once infrastructure is available from Kernel\r
+     */ \r
+    return;\r
+}\r
+\r
+void Osal_saBeginMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_invalidateCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+void Osal_saEndMemAccess (void *blockPtr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(blockPtr,size);\r
+    return;\r
+}\r
+\r
+\r
+\r
+void Osal_saBeginScAccess (void* addr, uint32_t size)\r
+{\r
+   Osal_invalidateCache(addr,size);  \r
+        \r
+}\r
\r
+void Osal_saEndScAccess   (void* addr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(addr,size);\r
+    \r
+}\r
+\r
+#endif\r
+\r
+void Osal_pktLibBeginMemAccess(void* ptr, uint32_t size)\r
+{\r
+    Osal_invalidateCache(ptr,size);\r
+}\r
+\r
+\r
+void Osal_pktLibEndMemAccess(void* ptr, uint32_t size)\r
+{\r
+    Osal_writeBackCache(ptr,size);\r
+}\r
+\r
+\r
+void Osal_pktLibBeginPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)\r
+{\r
+    /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
+     * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
+     * Just for testing we are always invalidating the cache here. */\r
+\r
+     Osal_invalidateCache(ptrPkt,size);\r
+}\r
+\r
+\r
+void Osal_pktLibEndPktAccess(Pktlib_HeapHandle heapHandle, Ti_Pkt* ptrPkt, uint32_t size)\r
+{\r
+    /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
+     * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
+     * Just for testing we are always writing back the cache here. */\r
+\r
+    /* Writeback the contents of the cache. */\r
+    Osal_writeBackCache(ptrPkt,size);\r
+}\r
+\r
+\r
+void* Osal_pktLibEnterCriticalSection(Pktlib_HeapHandle heapHandle)\r
+{\r
+    /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
+     * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
+     * Implementations here could range from a MULTI-THREAD protection if the packets in \r
+     * the heap are being accessed across multiple threads or MULTI-CORE if the packets\r
+     * are being accessed across multiple cores and features: split and clone are used.\r
+     * For NWAL layer no protection required.\r
+     *\r
+     * For testing we are not doing any of this so we are simply setting it to NOOP */\r
+    return NULL;\r
+}\r
+\r
+\r
+void  Osal_pktLibExitCriticalSection(Pktlib_HeapHandle heapHandle, void* csHandle)\r
+{\r
+    /* TODO: We should use the 'heapHandle' and compare it with what we got from the\r
+     * 'create/find' HEAP API & depending upon the comparison take appropriate action. \r
+     * Implementations here could range from a MULTI-THREAD protection if the packets in \r
+     * the heap are being accessed across multiple threads or MULTI-CORE if the packets\r
+     * are being accessed across multiple cores and features: split and clone are used.\r
+     * For NWAL layer no protection required.. \r
+     *\r
+     * For testing we are not doing any of this so we are simply setting it to NOOP */\r
+    return;        \r
+}\r
+\r
+void* Osal_qmssVirtToPhy (void *ptr)\r
+{\r
+    return (void *)(netapi_VM_mem_start_phy + ((uint8_t*)ptr - netapi_VM_mem_start));\r
+}\r
+\r
+void* Osal_qmssPhyToVirt (void *ptr)\r
+{\r
+    if (!ptr) return (void *) 0;\r
+    //todo, see if out of range of mem_start_phy and size!! (like mmu would do)\r
+    return (void *)(netapi_VM_mem_start + ((uint8_t*)ptr - netapi_VM_mem_start_phy));\r
+}\r
+\r
+/******************************************************************************\r
+* Function to traverse a CPPI descriptor and convert all address references\r
+* from virtual to physical.\r
+******************************************************************************/\r
+void* Osal_qmssConvertDescVirtToPhy(void *descAddr)\r
+{\r
+    if (!descAddr) return (void *)0;\r
+\r
+    if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)\r
+    {\r
+        Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);\r
+        Cppi_HostDesc *prevBDPtr = 0;\r
+        while (nextBDPtr)\r
+        {\r
+            void *buffPtr;\r
+            if (nextBDPtr->buffPtr)\r
+            {\r
+                buffPtr = (void *)nextBDPtr->buffPtr;\r
+                nextBDPtr->buffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->buffPtr));\r
+                if (!(nextBDPtr->buffPtr)) return (void *)0;\r
+            }\r
+\r
+            if (nextBDPtr->origBuffPtr)\r
+            {\r
+                nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(nextBDPtr->origBuffPtr));\r
+                if (!(nextBDPtr->origBuffPtr)) return (void *)0;\r
+            }\r
+\r
+            prevBDPtr = nextBDPtr;\r
+            nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));\r
+            if (prevBDPtr->nextBDPtr)\r
+            {\r
+                prevBDPtr->nextBDPtr = (uint32_t)Osal_qmssVirtToPhy((void *)(prevBDPtr->nextBDPtr));\r
+                if (!(prevBDPtr->nextBDPtr)) return (void *)0;\r
+            }\r
+\r
+            Qmss_osalEndMemAccess(buffPtr, prevBDPtr->buffLen);\r
+            Qmss_osalEndMemAccess(prevBDPtr, sizeof(Cppi_HostDesc));\r
+        }\r
+        descAddr = Osal_qmssVirtToPhy(descAddr);\r
+        if (!descAddr) return (void *)0;\r
+    }\r
+    else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)\r
+    {\r
+        descAddr = Osal_qmssVirtToPhy(descAddr);\r
+        if (!descAddr) return (void *)0;\r
+    }\r
+    return descAddr;\r
+\r
+}\r
+\r
+\r
+/******************************************************************************\r
+* Function to traverse a CPPI descriptor and convert all address references\r
+* from physical to virtual.\r
+******************************************************************************/\r
+void* Osal_qmssConvertDescPhyToVirt(void *descAddr)\r
+{\r
+    if (!descAddr) return (void *)0;\r
+    descAddr = Osal_qmssPhyToVirt(descAddr);\r
+\r
+    if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_HOST)\r
+    {\r
+        Cppi_HostDesc *nextBDPtr = (Cppi_HostDesc *)QMSS_DESC_PTR(descAddr);\r
+        while (nextBDPtr)\r
+        {\r
+            Qmss_osalBeginMemAccess(nextBDPtr, sizeof(Cppi_HostDesc));\r
+            if (nextBDPtr->buffPtr)\r
+            {\r
+                nextBDPtr->buffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->buffPtr));\r
+                if (!(nextBDPtr->buffPtr)) return (void *)0;\r
+            }\r
+\r
+            if (nextBDPtr->origBuffPtr)\r
+            {\r
+                nextBDPtr->origBuffPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->origBuffPtr));\r
+                if (!(nextBDPtr->origBuffPtr)) return (void *)0;\r
+            }\r
+\r
+            if (nextBDPtr->nextBDPtr)\r
+            {\r
+                nextBDPtr->nextBDPtr = (uint32_t)Osal_qmssPhyToVirt((void *)(nextBDPtr->nextBDPtr));\r
+                if (!(nextBDPtr->nextBDPtr)) return (void *)0;\r
+            }\r
+\r
+            Qmss_osalBeginMemAccess((void *)(nextBDPtr->buffPtr), nextBDPtr->buffLen);\r
+            nextBDPtr = (void *)QMSS_DESC_PTR((nextBDPtr->nextBDPtr));\r
+        }\r
+    }\r
+    else if (Cppi_getDescType((Cppi_Desc *)QMSS_DESC_PTR(descAddr)) == Cppi_DescType_MONOLITHIC)\r
+    {\r
+        descAddr = Osal_qmssPhyToVirt(descAddr);\r
+        if (!descAddr) return (void *)0;\r
+    }\r
+    return descAddr;\r
+}\r
+\r
+void* Osal_stubCsEnter (void)\r
+{\r
+\r
+\r
+}\r
+void Osal_stubCsExit (void *CsHandle)\r
+{\r
+    /* Release Semaphore using handle */\r
+\r
+\r
+    return;\r
+}\r
+\r
index f947b374dfb50fd3281e2ccb972e35b8484e509e..8aba3c06c3e37c3a68f67281c97de29dc03861f8 100644 (file)
@@ -257,6 +257,7 @@ void pktio_delete(PKTIO_HANDLE_T * p, int * err)
         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);\r
         if(p->use_nwal !=2)\r
        {\r
+                netapi_zapQ(p->q);   //since we are deleting, zap the queue \r
                Qmss_queueClose(p->q);\r
        }\r
         p->q=-1;\r
@@ -339,9 +340,10 @@ uint64_t ts= netapi_getTimestamp();  //get_ts
        /** poll the netcp default RX queue we squirt out below */\r
        if (p->use_nwal==2)\r
        {\r
-               /* Poll for common L2/L3 packets */\r
-               nwal_pollPkt(p->nwalInstanceHandle,\r
-                     nwal_POLL_DEFAULT_GLOB_PKT_Q,\r
+               /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are\r
+                   set.. optimizaion maybe? */\r
+               r=nwal_pollPkt(p->nwalInstanceHandle,\r
+                     nwal_POLL_DEFAULT_GLOB_PKT_Q|  nwal_POLL_DEFAULT_PER_PROC_PKT_Q,\r
                      (uint32_t) p,\r
                      p->max_n,\r
                      QMSS_PARAM_NOT_SPECIFIED,\r
@@ -351,7 +353,7 @@ uint64_t ts= netapi_getTimestamp();  //get_ts
        else if (p->use_nwal==1)\r
        {\r
                /* Poll an additional NETCP RX queue */\r
-               nwal_pollPkt(p->nwalInstanceHandle,\r
+               r=nwal_pollPkt(p->nwalInstanceHandle,\r
                      nwal_POLL_APP_MANAGED_PKT_Q,\r
                      (uint32_t) p,\r
                      p->max_n,\r
@@ -385,14 +387,14 @@ int i=0;
 int r=0;\r
 int err2;\r
 int cnt=0;\r
-PKTIO_HANDLE_T *pp =( PKTIO_HANDLE_T *)  netapi_get_pktio_list(handle);\r
+PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);\r
  \r
 *err=0;\r
-for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++,pp+=1)\r
+for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)\r
 {\r
-    if (pp->inuse != PKTIO_INUSE) continue;\r
-    if(!(pp->cfg.flags1&PKTIO_R)) continue;\r
-    r+=pktio_poll(pp,  p_poll_cfg,  &err2); cnt+=1;\r
+    if (pp[i]->inuse != PKTIO_INUSE) continue;\r
+    if(!(pp[i]->cfg.flags1&PKTIO_R)) continue;\r
+    r+=pktio_poll(pp[i],  p_poll_cfg,  &err2); cnt+=1;\r
     if (err2) { *err = err2; break;}\r
 }\r
 return r;\r
index ccf23e69b38408756341929bfe8240ba76a13cad..ad17c5a8f29a796c46f330fc7a04cd98532ee542 100644 (file)
-/*
- * tim64.c  : enable use of timer64 from user space
- *  (using 64 bit mode)
- *   TIMER 6
- **************************************************************
- * FILE: tim64.c  
- * 
- * DESCRIPTION:  tim64 peripheral driver for user space transport
- *               library
- * 
- * REVISION HISTORY:  rev 0.0.1 
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <termios.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include "netapi_timer.h"
-
-/* timing */
-static inline unsigned long timing_start(void)
-{
-        volatile int vval;
-        //read clock
-        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval));
-        return vval;
-}
-static inline unsigned long timing_stop(void)
-{
-        volatile int vval2;
-        //read clock
-        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval2));
-        return vval2;
-}
-
-
-  
-#define MAP_SIZE 4096UL
-#define MAP_MASK (MAP_SIZE - 1)
-//this is for timer 6
-#define T64BASE_6  (void *)0x02260000
-volatile unsigned long * t64_virt_addr;
-static unsigned long tv_lo;
-static unsigned long tv_hi;
-
-//read
-static unsigned long long read_t64(void)
-{
- volatile unsigned long long t1;
- volatile unsigned long long t2;
- unsigned long long val;
- t1 = t64_virt_addr[0x10/4]; //lo
- t2 = t64_virt_addr[0x14/4]; //hi
- val = ((unsigned long long) t2) <<32 | t1;
- return val;
-
-}
-
-//claibrate
-static unsigned int t64_cpu_cycle_per_tick=0;
-unsigned int cpu_cycles_sec=983040000;
-unsigned long t64_ticks_sec(void)
-{
-   if (t64_cpu_cycle_per_tick)
-      return ( cpu_cycles_sec/t64_cpu_cycle_per_tick); //ticks per/sec
-   else return 166666666;
-
-}
-static int t64_calibrate(int n)
-{
-volatile unsigned long t1;
-volatile unsigned long t2;
-volatile unsigned long long t164;
-volatile unsigned long long t264;
-int i;
-volatile int s;
-t1=timing_start();
-t164=read_t64();
-
-sleep(1);
-#if 0
-for(i=0;i<n;i++)
-{
- s+=t164*20; s=s*(2+i);
-}
-#endif
-t264=read_t64();
-t2=timing_stop();
-t64_cpu_cycle_per_tick = (unsigned long) ((t2-t1)/(t264-t164));
-printf(">netapi:  tim64 calibration - n=%d t2-t1=%lu t264-t164=%llu ccpt=%ld tps=%ld\n",
-       n, t2-t1, t264-t164, t64_cpu_cycle_per_tick,  t64_ticks_sec());
-
-}
-
-
-/*********************************
- * memory map t64 into user space
- *   input: pass in fd for /dev/mem
- **********************************/
-int t64_memmap(int fd)
-{
-     off_t t64_base= (off_t) T64BASE_6;
-     void * map_base;
-     int op;
-     volatile unsigned long t1;
-     volatile unsigned long t2;
-     unsigned long long blah;
-
-
-    /* Map one page */
-    map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, t64_base & ~MAP_MASK);
-    if(map_base == (void *) -1) exit(-99);
-    fflush(stdout);
-
-    t64_virt_addr = (long *) map_base + (t64_base & MAP_MASK);
-    printf(">netapi timer64:  T64 Memory mapped at address %p.\n", t64_virt_addr);
-    fflush(stdout);
-    return 1;
-}
-
-
- /*********************************
- *  start the timer64
- ***********************************/
-int t64_start(void)
-{
-      t64_virt_addr[0x24/4]= 0x00;
-      t64_virt_addr[0x10/4]= 0x00;
-      t64_virt_addr[0x14/4]= 0x00;
-      t64_virt_addr[0x18/4]= 0xffffffff;
-      t64_virt_addr[0x1c/4]= 0xffffffff;
-      t64_virt_addr[0x20/4]= 0x80;
-      t64_virt_addr[0x24/4]= 0x03; //go
-      t64_calibrate(100000);
-      return 1;
-}
-
-
-#ifdef TEST_DRIVER
-int main(int argc, char **argv) {
-    int fd;
-     off_t t64_base= (off_t) T64BASE_6; 
-    void * map_base;
-    int op;
-volatile unsigned long t1;
-volatile unsigned long t2;
-unsigned long long blah;
-       
-       if(argc < 2) {
-               fprintf(stderr, "Usage: tim64 start|stop|read  \n"
-                       );
-               exit(1);
-       }
-        if (!strcmp(argv[1],"start")) op=0;
-        else if (!strcmp(argv[1],"stop")) op =1;
-        else if (!strcmp(argv[1],"read")) op =2;
-        else {  fprintf(stderr, "Usage: tim64 start|stop|read  \n"
-                        );
-                exit(1);
-             }
-
-
-    if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) exit(-99);
-    printf("/dev/mem opened.\n"); 
-    fflush(stdout);
-    
-    /* Map one page */
-    map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, t64_base & ~MAP_MASK);
-    if(map_base == (void *) -1) exit(-99);
-    printf("mapbase=Memory mapped at address %p.\n", map_base); 
-    fflush(stdout);
-    
-    t64_virt_addr = (long *) map_base + (t64_base & MAP_MASK);
-    printf("t64_virt_ddr: Memory mapped at address %p.\n", t64_virt_addr); 
-    fflush(stdout);
-
-    switch(op)
-    {
-    case(0):
-    default:
-      //start
-      t64_virt_addr[0x24/4]= 0x00;
-      t64_virt_addr[0x10/4]= 0x00;
-      t64_virt_addr[0x14/4]= 0x00;
-      t64_virt_addr[0x18/4]= 0xffffffff;
-      t64_virt_addr[0x1c/4]= 0xffffffff;
-      t64_virt_addr[0x20/4]= 0x80;
-      t64_virt_addr[0x24/4]= 0x03; //go
-      t64_calibrate(100000);
-      break;
-    case(1):
-     //stop
-      t64_virt_addr[0x24/4]= 0x00;
-      break;
-    case(2):
-      //read
-      tv_lo= t64_virt_addr[0x10/4];
-      tv_hi= t64_virt_addr[0x14/4];
-t1=timing_start();
-blah = read_t64();
-t2=timing_stop();
-
-      printf("t64 = %x%x   %llx (read_t64 takes %d ticks)\n",tv_hi,tv_lo,blah, t2-t1);
-      break;
-    } 
-    if(munmap(map_base, MAP_SIZE) == -1) exit(-99);
-    close(fd);
-    return 0;
-}
-#endif
+/*\r
+ * tim64.c  : enable use of timer64 from user space\r
+ *  (using 64 bit mode)\r
+ *   TIMER 6\r
+ **************************************************************\r
+ * FILE: tim64.c  \r
+ * \r
+ * DESCRIPTION:  tim64 peripheral driver for user space transport\r
+ *               library\r
+ * \r
+ * REVISION HISTORY:  rev 0.0.1 \r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#include <signal.h>\r
+#include <fcntl.h>\r
+#include <ctype.h>\r
+#include <termios.h>\r
+#include <sys/types.h>\r
+#include <sys/mman.h>\r
+#include "netapi_timer.h"\r
+\r
+/* timing */\r
+static inline unsigned long timing_start(void)\r
+{\r
+        volatile int vval;\r
+        //read clock\r
+        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval));\r
+        return vval;\r
+}\r
+static inline unsigned long timing_stop(void)\r
+{\r
+        volatile int vval2;\r
+        //read clock\r
+        asm volatile("mrc p15, 0, %0, c9, c13, 0" :  "=r"(vval2));\r
+        return vval2;\r
+}\r
+\r
+\r
+  \r
+#define MAP_SIZE 4096UL\r
+#define MAP_MASK (MAP_SIZE - 1)\r
+//this is for timer 6\r
+#define T64BASE_6  (void *)0x02260000\r
+volatile unsigned long * t64_virt_addr;\r
+static unsigned long tv_lo;\r
+static unsigned long tv_hi;\r
+\r
+//read\r
+static unsigned long long read_t64(void)\r
+{\r
+ volatile unsigned long long t1;\r
+ volatile unsigned long long t2;\r
+ unsigned long long val;\r
+ t1 = t64_virt_addr[0x10/4]; //lo\r
+ t2 = t64_virt_addr[0x14/4]; //hi\r
\r
+ val = ((unsigned long long) t2) <<32 | t1;\r
+ return val;\r
+\r
+}\r
+\r
+//claibrate\r
+static unsigned int t64_cpu_cycle_per_tick=0;\r
+unsigned int cpu_cycles_sec=983040000;\r
+unsigned long t64_ticks_sec(void)\r
+{\r
+   if (t64_cpu_cycle_per_tick)\r
+      return ( cpu_cycles_sec/t64_cpu_cycle_per_tick); //ticks per/sec\r
+   else return 166666666;\r
+\r
+}\r
+static int t64_calibrate(int n)\r
+{\r
+volatile unsigned long t1;\r
+volatile unsigned long t2;\r
+volatile unsigned long long t164;\r
+volatile unsigned long long t264;\r
+int i;\r
+volatile int s;\r
+t1=timing_start();\r
+t164=read_t64();\r
+\r
+sleep(1);\r
+#if 0\r
+for(i=0;i<n;i++)\r
+{\r
+ s+=t164*20; s=s*(2+i);\r
+}\r
+#endif\r
+t264=read_t64();\r
+t2=timing_stop();\r
+t64_cpu_cycle_per_tick = (unsigned long) ((t2-t1)/(t264-t164));\r
+printf(">netapi:  tim64 calibration - n=%d t2-t1=%lu t264-t164=%llu ccpt=%ld tps=%ld\n",\r
+       n, t2-t1, t264-t164, t64_cpu_cycle_per_tick,  t64_ticks_sec());\r
+\r
+}\r
+\r
+\r
+/*********************************\r
+ * memory map t64 into user space\r
+ *   input: pass in fd for /dev/mem\r
+ **********************************/\r
+int t64_memmap(int fd)\r
+{\r
+     off_t t64_base= (off_t) T64BASE_6;\r
+     void * map_base;\r
+     int op;\r
+     volatile unsigned long t1;\r
+     volatile unsigned long t2;\r
+     unsigned long long blah;\r
+\r
+\r
+    /* Map one page */\r
+    map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, t64_base & ~MAP_MASK);\r
+    if(map_base == (void *) -1) exit(-99);\r
+    fflush(stdout);\r
+\r
+    t64_virt_addr = (long *) map_base + (t64_base & MAP_MASK);\r
+    printf(">netapi timer64:  T64 Memory mapped at address %p.\n", t64_virt_addr);\r
+    fflush(stdout);\r
+    return 1;\r
+}\r
+\r
+\r
+ /*********************************\r
+ *  start the timer64\r
+ ***********************************/\r
+int t64_start(void)\r
+{\r
+      t64_virt_addr[0x24/4]= 0x00;\r
+      t64_virt_addr[0x10/4]= 0x00;\r
+      t64_virt_addr[0x14/4]= 0x00;\r
+      t64_virt_addr[0x18/4]= 0xffffffff;\r
+      t64_virt_addr[0x1c/4]= 0xffffffff;\r
+      t64_virt_addr[0x20/4]= 0x80;\r
+      t64_virt_addr[0x24/4]= 0x03; //go\r
+      t64_calibrate(100000);\r
+      return 1;\r
+}\r
+\r
+\r
+#ifdef TEST_DRIVER\r
+int main(int argc, char **argv) {\r
+    int fd;\r
+     off_t t64_base= (off_t) T64BASE_6; \r
+    void * map_base;\r
+    int op;\r
+volatile unsigned long t1;\r
+volatile unsigned long t2;\r
+unsigned long long blah;\r
+       \r
+       if(argc < 2) {\r
+               fprintf(stderr, "Usage: tim64 start|stop|read  \n"\r
+                       );\r
+               exit(1);\r
+       }\r
+        if (!strcmp(argv[1],"start")) op=0;\r
+        else if (!strcmp(argv[1],"stop")) op =1;\r
+        else if (!strcmp(argv[1],"read")) op =2;\r
+        else {  fprintf(stderr, "Usage: tim64 start|stop|read  \n"\r
+                        );\r
+                exit(1);\r
+             }\r
+\r
+\r
+    if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) exit(-99);\r
+    printf("/dev/mem opened.\n"); \r
+    fflush(stdout);\r
+    \r
+    /* Map one page */\r
+    map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, t64_base & ~MAP_MASK);\r
+    if(map_base == (void *) -1) exit(-99);\r
+    printf("mapbase=Memory mapped at address %p.\n", map_base); \r
+    fflush(stdout);\r
+    \r
+    t64_virt_addr = (long *) map_base + (t64_base & MAP_MASK);\r
+    printf("t64_virt_ddr: Memory mapped at address %p.\n", t64_virt_addr); \r
+    fflush(stdout);\r
+\r
+    switch(op)\r
+    {\r
+    case(0):\r
+    default:\r
+      //start\r
+      t64_virt_addr[0x24/4]= 0x00;\r
+      t64_virt_addr[0x10/4]= 0x00;\r
+      t64_virt_addr[0x14/4]= 0x00;\r
+      t64_virt_addr[0x18/4]= 0xffffffff;\r
+      t64_virt_addr[0x1c/4]= 0xffffffff;\r
+      t64_virt_addr[0x20/4]= 0x80;\r
+      t64_virt_addr[0x24/4]= 0x03; //go\r
+      t64_calibrate(100000);\r
+      break;\r
+    case(1):\r
+     //stop\r
+      t64_virt_addr[0x24/4]= 0x00;\r
+      break;\r
+    case(2):\r
+      //read\r
+      tv_lo= t64_virt_addr[0x10/4];\r
+      tv_hi= t64_virt_addr[0x14/4];\r
+t1=timing_start();\r
+blah = read_t64();\r
+t2=timing_stop();\r
+\r
+      printf("t64 = %x%x   %llx (read_t64 takes %d ticks)\n",tv_hi,tv_lo,blah, t2-t1);\r
+      break;\r
+    } \r
+    if(munmap(map_base, MAP_SIZE) == -1) exit(-99);\r
+    close(fd);\r
+    return 0;\r
+}\r
+#endif\r
index a0535aa8dad0323b3fe07312f7e485d62d6e9dc3..67098bfb40450a11349af69601a034918516b730 100644 (file)
@@ -1,81 +1,81 @@
-/********************************************************
-  * File: timer_loc.h
-  * Purpose: local definitions for timer module
-  ******************************************************/
-
-#ifndef __TIMER_LOC__H
-#define __TIMER_LOC__H
-
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-
-/**********************************
- * A timer object
- *  active timrs have non zero cookie
- **********************************/
-struct TIM_tag;
-typedef struct TIM_tag
-{
-struct TIM_tag * next;
-void * cookie;
-unsigned long long t;
-} TIM_T;
-
-//a list of timers 
-typedef struct TIM_LIST_tAG
-{
-   TIM_T * head;
-   TIM_T * tail;
-} TIM_LIST_T;
-
-
-//the timer group context
-typedef struct TIMER_GROUP_Tag
-{
-  NETAPI_T  h;       //back pointer
-  int n_cells;       //#of cells (hash entries)
-  int n_timers;      //# of timer objects
-  int cell_width;    //size of each cell in ticks
-  TIM_LIST_T free;   //free list of timer objects
-  TIM_LIST_T * cells;//active timers hash table
-  unsigned long long last_polled;  //in ticks
-  NETAPI_TIMER_CB_T cb; //timer callback
-  int local;   //1 => local timer, 0 =>global timer
-  int exp2cancel; //1=> expect to cancel, 0=> expect to fire
-  int tol;     //in ticks  [FUTURE]
-} TIMER_GROUP_T;
-
-/**********************INTERNAL API*******************/
-//create a timer group
-int tim_group_create(TIMER_GROUP_T *g, int n_cells, int n_timers);
-
-//return a list of timer objects to free list
-void tim_return_free(TIM_LIST_T *ftl,  TIM_LIST_T *p, int n);  
-
-//get a free timer oblject
-TIM_T * tim_get_free(TIM_LIST_T *ftl, void *cookie, unsigned long long t);
-
-//return a list of timers that have fired
-void tim_return_fired_list(TIM_LIST_T *tl, TIM_LIST_T * pr, TIM_LIST_T * ftl, unsigned long long t,  int * p_nf);
-
-
-//cancel a timer
-void tim_cancel(TIM_T * p, int *pErr);
-
-//insert an active timer into hash cell
-TIM_T *tim_set(TIM_LIST_T *tl, TIM_LIST_T *free_tl, unsigned long long t, void *cookie, int *pErr);
-
-/********************************************************/
-/********************internal control of hw*************/
-/******************************************************/
-//memmap t64 registers. fd is open(/dev/mem)
-int t64_memmap(int fd);
-
-//start the timer 
-int t64_start(void);
-
-
-#endif
+/********************************************************\r
+  * File: timer_loc.h\r
+  * Purpose: local definitions for timer module\r
+  ******************************************************/\r
+\r
+#ifndef __TIMER_LOC__H\r
+#define __TIMER_LOC__H\r
+\r
+\r
+#ifndef NULL\r
+#define NULL 0\r
+#endif\r
+\r
+\r
+/**********************************\r
+ * A timer object\r
+ *  active timrs have non zero cookie\r
+ **********************************/\r
+struct TIM_tag;\r
+typedef struct TIM_tag\r
+{\r
+struct TIM_tag * next;\r
+void * cookie;\r
+unsigned long long t;\r
+} TIM_T;\r
+\r
+//a list of timers \r
+typedef struct TIM_LIST_tAG\r
+{\r
+   TIM_T * head;\r
+   TIM_T * tail;\r
+} TIM_LIST_T;\r
+\r
+\r
+//the timer group context\r
+typedef struct TIMER_GROUP_Tag\r
+{\r
+  NETAPI_T  h;       //back pointer\r
+  int n_cells;       //#of cells (hash entries)\r
+  int n_timers;      //# of timer objects\r
+  int cell_width;    //size of each cell in ticks\r
+  TIM_LIST_T free;   //free list of timer objects\r
+  TIM_LIST_T * cells;//active timers hash table\r
+  unsigned long long last_polled;  //in ticks\r
+  NETAPI_TIMER_CB_T cb; //timer callback\r
+  int local;   //1 => local timer, 0 =>global timer\r
+  int exp2cancel; //1=> expect to cancel, 0=> expect to fire\r
+  int tol;     //in ticks  [FUTURE]\r
+} TIMER_GROUP_T;\r
+\r
+/**********************INTERNAL API*******************/\r
+//create a timer group\r
+int tim_group_create(TIMER_GROUP_T *g, int n_cells, int n_timers);\r
+\r
+//return a list of timer objects to free list\r
+void tim_return_free(TIM_LIST_T *ftl,  TIM_LIST_T *p, int n);  \r
+\r
+//get a free timer oblject\r
+TIM_T * tim_get_free(TIM_LIST_T *ftl, void *cookie, unsigned long long t);\r
+\r
+//return a list of timers that have fired\r
+void tim_return_fired_list(TIM_LIST_T *tl, TIM_LIST_T * pr, TIM_LIST_T * ftl, unsigned long long t,  int * p_nf);\r
+\r
+\r
+//cancel a timer\r
+void tim_cancel(TIM_T * p, int *pErr);\r
+\r
+//insert an active timer into hash cell\r
+TIM_T *tim_set(TIM_LIST_T *tl, TIM_LIST_T *free_tl, unsigned long long t, void *cookie, int *pErr);\r
+\r
+/********************************************************/\r
+/********************internal control of hw*************/\r
+/******************************************************/\r
+//memmap t64 registers. fd is open(/dev/mem)\r
+int t64_memmap(int fd);\r
+\r
+//start the timer \r
+int t64_start(void);\r
+\r
+\r
+#endif\r
index 9eb69d6ea667254dff2167c90b9a65abfb0b3109..b5fe712bfb699d0475b3990575ecefef8f3927cd 100644 (file)
-/******************************************
- * FILE:timlist.c 
- * Purpose:  timer low level primitives
- ***********************************************
-* FILE:timlist.c
- * 
- * DESCRIPTION:  netapi timer library source file for user space transport
- *               library
- * 
- * REVISION HISTORY:  rev 0.0.1 
- *
- *  Copyright (c) Texas Instruments Incorporated 2010-2011
- * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright 
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
- ***************************************/
-//#define TEST_DRIVER
-#ifdef TEST_DRIVER
-typedef void * NETAPI_T;
-typedef void * NETAPI_TIMER_CB_T;
-#else
-#include "../netapi_timer.h"
-#endif
-#include "timer_loc.h"
-#include "../netapi_err.h"
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-
-//create a timer group
-int tim_group_create(TIMER_GROUP_T *g, int n_cells, int n_timers)
-{
-char * mem= (char *) malloc(n_timers * sizeof (TIM_T));
-if (!mem) return -1;
-g->n_cells = n_cells;
-tim_build_free(&g->free, mem, sizeof(TIM_T) * n_timers);
-g->cells=(TIM_LIST_T *) malloc(n_cells * sizeof(TIM_LIST_T));
-if (!g->cells) {free(mem);  return -1;}
-g->n_timers=n_timers;
-g->last_polled=0;
-return 1;
-}
-
-//return as single timer to end of free list, zero cookie, etc
-void tim_return_single_free(TIM_LIST_T *ftl,  TIM_T *p)
-{
-TIM_T * pt;
-int i;
-pt = ftl->tail;
-if (!pt)
-{
-ftl->head=p;
-ftl->tail=p;
-}
-else
-{
-pt->next=p;
-ftl->tail = p;
-}
-  p->t=0LL;
-  p->cookie=NULL;
-  p->next=NULL;
-}
-
-
-//return a list of N timers to  end of [free] list.  zero cookie, etc 
-void tim_return_free(TIM_LIST_T *ftl,  TIM_LIST_T *p, int n)
-{
-TIM_T * pt;
-int i;
-pt = ftl->tail;
-if (!pt) 
-{
-ftl->head=p->head;
-ftl->tail=p->tail;
-}
-else 
-{
-pt->next=p->head;
-ftl->tail = p->tail;
-}
-
-pt= p->head;
-for(i=0;i<n;i++)
-{
-  pt->t=0LL;
-  pt->cookie=NULL;
-  pt= pt->next;
-}
-ftl->tail->next=NULL;
-}
-
-//get a [free] entry from front of a list 
-TIM_T * tim_get_free(TIM_LIST_T *tl, void *cookie, unsigned long long t)
-{
-TIM_T *p = tl->head;
-if  (p)
-{
-   tl->head=p->next;
-   p->next=NULL;
-   p->cookie = cookie;
-   p->t = t;
-   if (!tl->head) tl->tail=NULL;
-}
-return p;
-}
-
-//build a timer list from chunk of memory
-int tim_build_free(TIM_LIST_T *tl, char *p_mem, int mem_size)
-{
-TIM_T * p = (TIM_T*) p_mem;
-TIM_T * p_old = (TIM_T*) p_mem;
-int i=0;
-tl->head = p;
-while(mem_size)
-{
-   p_old = p;
-   p->cookie=NULL;
-   p->t = 0LL;
-   mem_size -= sizeof(TIM_T);
-   p+=1;
-   i+=1;
-   p_old->next=p;
-}
-p_old->next = NULL;
-tl->tail = p_old;
-return i;
-}
-
-//return a list of timers that have fired
-void tim_return_fired_list(TIM_LIST_T *tl, TIM_LIST_T * pr, TIM_LIST_T * ftl, unsigned long long t,  int * p_nf)
-{
-int i=0;
-int got_start=0;
-int found_end=0;
-TIM_T * p_last, *p, *temp_p_next;
-TIM_LIST_T p_free={NULL,NULL};
-if (! tl->head) { *p_nf=0; return ;}
-
-p =  tl->head;
-p_last= NULL; 
-
-for(i=0;p;)
-{
-  if(p->t <= t) 
-  {
-    if(!got_start)
-    {
-       if(p->cookie)
-       {
-       //start results chain
-         got_start=1;
-         if(pr->tail)  {pr->tail->next = p; pr->tail=p;}
-         else {pr->head=pr->tail = p;}
-         i+=1;
-         p_last=p;
-         p=p->next;
-         continue;
-       }
-       else //skip over cancelled timer..
-       {
-         //skip & free. make sure we adjust head or tail if necessary
-         if (p_last){
-             p_last->next=p->next; 
-         }
-         else {
-            tl->head = p->next; /* we are freeing old head..*/
-         }
-         if (tl->tail ==p)  tl->tail=p_last; /* we are freeing old tail */
-         temp_p_next=p->next;
-         tim_return_single_free(ftl,p);
-         p=temp_p_next; 
-         /*keep p_last the same! */
-         continue;     
-       }
-    } 
-    else
-    {
-      if(!p->cookie)
-      {
-         //skip & free
-         if (p_last){ 
-             p_last->next=p->next; 
-         }
-         else {
-            tl->head = p->next;
-         }
-         if (tl->tail ==p)  tl->tail=p_last; /* we are freeing old tail */
-         temp_p_next=p->next;
-         tim_return_single_free(ftl,p);
-         p=temp_p_next;      
-         /*keep p_last the same! */
-         continue;
-      }  
-      else { //valid entry for list.
-        p_last=p; 
-        p=p->next;
-        i+=1;
-        continue;
-      }  
-    }
-  }
-  else  /* p->t > t */
-  {
-    if(got_start)
-    {
-       found_end =1; //found end of chain to return.  All is good
-       pr->tail = p_last;
-       p_last->next=NULL;
-       tl->head=p;
-    }
-    // done
-    break;
-  }
-}
-
-*p_nf=i;
-if ((got_start) && (!found_end)) 
-{
-  //cleared the list
-  //DEBUGprintf("clearingthelist\n");
-  tl->head = tl->tail=NULL;
-}
-return;
-}
-
-//cancel a timer
-void tim_cancel(TIM_T * p, int *pErr)
-{
- *pErr =0;
- if (!p) {*pErr = NETAPI_ERR_BAD_INPUT; return; }
- if (!p->cookie) {*pErr= NETAPI_ERR_ALREADY_CANCELLED; return;}
- p->cookie = NULL;
- return;
-}
-
-//set a timer 
-TIM_T *tim_set(TIM_LIST_T *tl, TIM_LIST_T *free_tl, unsigned long long t, void *cookie, int *pErr)
-{
-TIM_T *pt = tl->head;
-TIM_T *p = tim_get_free(free_tl, cookie, t);
-TIM_T *pt_last= NULL;
-int i;
-*pErr=0;
-if (!p ) { *pErr=NETAPI_ERR_NOMEM; return NULL;}  
-
-if (!pt) //first one
-{
-  tl->head = p;
-  tl->tail =p;
-  return p;  
-}
-
-//see if we can place at front of list
-if (pt->t >=t)
-{
-  tl->head=p;
-  p->next=pt;
-  return p;
-}
-
- //timer has hashed into this chain.  find out where
-for(;pt;)
-{
-   if (pt->t >= t)       
-   {
-      if (pt_last) {
-        pt_last->next = p;
-        p->next=pt;
-        return p;
-      }
-      else
-      {
-        tl->head=p;
-        p->next=pt;
-        return p;
-      }
-   }
-   else {pt_last=pt;pt=pt->next;}
-}
-//last one
-pt_last->next=p;
-p->next=NULL;
-tl->tail=p;
-return p;
-}
-
-#ifdef TEST_DRIVER
-TIM_LIST_T the_base={NULL,NULL};
-TIM_LIST_T cell_base={NULL,NULL};
-char *mem;
-TIM_T * timers[10];
-TIM_LIST_T res;
-main()
-{
- int err;
- mem= malloc(100*sizeof(TIM_T));
- TIM_T *p;
- int n;
- int i;
- tim_build_free(&the_base, mem , 100*sizeof(TIM_T));
-
- timers[0]=tim_set(&cell_base, &the_base, 100LL, (void *) 1, &err);
- timers[1]=tim_set(&cell_base, &the_base, 101LL, (void *) 2, &err);
- timers[2]=tim_set(&cell_base, &the_base, 105LL, (void *) 3, &err);
- timers[3]=tim_set(&cell_base, &the_base,  95LL, (void *) 4, &err);
- timers[4]=tim_set(&cell_base, &the_base,  95LL, (void *) 5, &err);
- timers[5]=tim_set(&cell_base, &the_base,  95LL, (void *) 6, &err);
- timers[6]=tim_set(&cell_base, &the_base,  104LL, (void *) 7, &err);
- timers[7]=tim_set(&cell_base, &the_base,  104LL, (void *) 8, &err);
- timers[8]=tim_set(&cell_base, &the_base,  104LL, (void *) 9, &err);
-
- tim_cancel(timers[6], &err);
-
-
- res.head=res.tail=NULL;
-for(i=90;i<106;i++)
- {
-tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) i,  &n);
- printf("at %d got %d\n", i, n);
- if (n) {tim_return_free(&the_base,&res,n); res.head=res.tail=NULL;
-
- }
-
-//special cases..
- res.head=res.tail=NULL;
- timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);
- tim_cancel(timers[0],&err);
- tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);
- res.head=res.tail=NULL;
- timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);
- timers[1]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);
- tim_cancel(timers[0],&err);
- tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);
-
- res.head=res.tail=NULL;
- timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);
- timers[1]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);
- tim_cancel(timers[0],&err);
- tim_cancel(timers[1],&err);
- tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);
-}
-#endif
+/******************************************\r
+ * FILE:timlist.c \r
+ * Purpose:  timer low level primitives\r
+ ***********************************************\r
+* FILE:timlist.c\r
+ * \r
+ * DESCRIPTION:  netapi timer library source file for user space transport\r
+ *               library\r
+ * \r
+ * REVISION HISTORY:  rev 0.0.1 \r
+ *\r
+ *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
+ * \r
+ *  Redistribution and use in source and binary forms, with or without \r
+ *  modification, are permitted provided that the following conditions \r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright \r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the \r
+ *    documentation and/or other materials provided with the   \r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+ ***************************************/\r
+//#define TEST_DRIVER\r
+#ifdef TEST_DRIVER\r
+typedef void * NETAPI_T;\r
+typedef void * NETAPI_TIMER_CB_T;\r
+#else\r
+#include "../netapi_timer.h"\r
+#endif\r
+#include "timer_loc.h"\r
+#include "../netapi_err.h"\r
+\r
+#ifndef NULL\r
+#define NULL 0\r
+#endif\r
+\r
+\r
+//create a timer group\r
+int tim_group_create(TIMER_GROUP_T *g, int n_cells, int n_timers)\r
+{\r
+char * mem= (char *) malloc(n_timers * sizeof (TIM_T));\r
+if (!mem) return -1;\r
+g->n_cells = n_cells;\r
+tim_build_free(&g->free, mem, sizeof(TIM_T) * n_timers);\r
+g->cells=(TIM_LIST_T *) malloc(n_cells * sizeof(TIM_LIST_T));\r
+if (!g->cells) {free(mem);  return -1;}\r
+g->n_timers=n_timers;\r
+g->last_polled=0;\r
+return 1;\r
+}\r
+\r
+//return as single timer to end of free list, zero cookie, etc\r
+void tim_return_single_free(TIM_LIST_T *ftl,  TIM_T *p)\r
+{\r
+TIM_T * pt;\r
+int i;\r
+pt = ftl->tail;\r
+if (!pt)\r
+{\r
+ftl->head=p;\r
+ftl->tail=p;\r
+}\r
+else\r
+{\r
+pt->next=p;\r
+ftl->tail = p;\r
+}\r
+  p->t=0LL;\r
+  p->cookie=NULL;\r
+  p->next=NULL;\r
+}\r
+\r
+\r
+//return a list of N timers to  end of [free] list.  zero cookie, etc \r
+void tim_return_free(TIM_LIST_T *ftl,  TIM_LIST_T *p, int n)\r
+{\r
+TIM_T * pt;\r
+int i;\r
+pt = ftl->tail;\r
+if (!pt) \r
+{\r
+ftl->head=p->head;\r
+ftl->tail=p->tail;\r
+}\r
+else \r
+{\r
+pt->next=p->head;\r
+ftl->tail = p->tail;\r
+}\r
+\r
+pt= p->head;\r
+for(i=0;i<n;i++)\r
+{\r
+  pt->t=0LL;\r
+  pt->cookie=NULL;\r
+  pt= pt->next;\r
+}\r
+ftl->tail->next=NULL;\r
+}\r
+\r
+//get a [free] entry from front of a list \r
+TIM_T * tim_get_free(TIM_LIST_T *tl, void *cookie, unsigned long long t)\r
+{\r
+TIM_T *p = tl->head;\r
+if  (p)\r
+{\r
+   tl->head=p->next;\r
+   p->next=NULL;\r
+   p->cookie = cookie;\r
+   p->t = t;\r
+   if (!tl->head) tl->tail=NULL;\r
+}\r
+return p;\r
+}\r
+\r
+//build a timer list from chunk of memory\r
+int tim_build_free(TIM_LIST_T *tl, char *p_mem, int mem_size)\r
+{\r
+TIM_T * p = (TIM_T*) p_mem;\r
+TIM_T * p_old = (TIM_T*) p_mem;\r
+int i=0;\r
+tl->head = p;\r
+while(mem_size)\r
+{\r
+   p_old = p;\r
+   p->cookie=NULL;\r
+   p->t = 0LL;\r
+   mem_size -= sizeof(TIM_T);\r
+   p+=1;\r
+   i+=1;\r
+   p_old->next=p;\r
+}\r
+p_old->next = NULL;\r
+tl->tail = p_old;\r
+return i;\r
+}\r
+\r
+//return a list of timers that have fired\r
+void tim_return_fired_list(TIM_LIST_T *tl, TIM_LIST_T * pr, TIM_LIST_T * ftl, unsigned long long t,  int * p_nf)\r
+{\r
+int i=0;\r
+int got_start=0;\r
+int found_end=0;\r
+TIM_T * p_last, *p, *temp_p_next;\r
+TIM_LIST_T p_free={NULL,NULL};\r
+if (! tl->head) { *p_nf=0; return ;}\r
+\r
+p =  tl->head;\r
+p_last= NULL; \r
+\r
+for(i=0;p;)\r
+{\r
+  if(p->t <= t) \r
+  {\r
+    if(!got_start)\r
+    {\r
+       if(p->cookie)\r
+       {\r
+       //start results chain\r
+         got_start=1;\r
+         if(pr->tail)  {pr->tail->next = p; pr->tail=p;}\r
+         else {pr->head=pr->tail = p;}\r
+         i+=1;\r
+         p_last=p;\r
+         p=p->next;\r
+         continue;\r
+       }\r
+       else //skip over cancelled timer..\r
+       {\r
+         //skip & free. make sure we adjust head or tail if necessary\r
+         if (p_last){\r
+             p_last->next=p->next; \r
+         }\r
+         else {\r
+            tl->head = p->next; /* we are freeing old head..*/\r
+         }\r
+         if (tl->tail ==p)  tl->tail=p_last; /* we are freeing old tail */\r
+         temp_p_next=p->next;\r
+         tim_return_single_free(ftl,p);\r
+         p=temp_p_next; \r
+         /*keep p_last the same! */\r
+         continue;     \r
+       }\r
+    } \r
+    else\r
+    {\r
+      if(!p->cookie)\r
+      {\r
+         //skip & free\r
+         if (p_last){ \r
+             p_last->next=p->next; \r
+         }\r
+         else {\r
+            tl->head = p->next;\r
+         }\r
+         if (tl->tail ==p)  tl->tail=p_last; /* we are freeing old tail */\r
+         temp_p_next=p->next;\r
+         tim_return_single_free(ftl,p);\r
+         p=temp_p_next;      \r
+         /*keep p_last the same! */\r
+         continue;\r
+      }  \r
+      else { //valid entry for list.\r
+        p_last=p; \r
+        p=p->next;\r
+        i+=1;\r
+        continue;\r
+      }  \r
+    }\r
+  }\r
+  else  /* p->t > t */\r
+  {\r
+    if(got_start)\r
+    {\r
+       found_end =1; //found end of chain to return.  All is good\r
+       pr->tail = p_last;\r
+       p_last->next=NULL;\r
+       tl->head=p;\r
+    }\r
+    // done\r
+    break;\r
+  }\r
+}\r
+\r
+*p_nf=i;\r
+if ((got_start) && (!found_end)) \r
+{\r
+  //cleared the list\r
+  //DEBUGprintf("clearingthelist\n");\r
+  tl->head = tl->tail=NULL;\r
+}\r
+return;\r
+}\r
+\r
+//cancel a timer\r
+void tim_cancel(TIM_T * p, int *pErr)\r
+{\r
+ *pErr =0;\r
+ if (!p) {*pErr = NETAPI_ERR_BAD_INPUT; return; }\r
+ if (!p->cookie) {*pErr= NETAPI_ERR_ALREADY_CANCELLED; return;}\r
+ p->cookie = NULL;\r
+ return;\r
+}\r
+\r
+//set a timer \r
+TIM_T *tim_set(TIM_LIST_T *tl, TIM_LIST_T *free_tl, unsigned long long t, void *cookie, int *pErr)\r
+{\r
+TIM_T *pt = tl->head;\r
+TIM_T *p = tim_get_free(free_tl, cookie, t);\r
+TIM_T *pt_last= NULL;\r
+int i;\r
+*pErr=0;\r
+if (!p ) { *pErr=NETAPI_ERR_NOMEM; return NULL;}  \r
+\r
+if (!pt) //first one\r
+{\r
+  tl->head = p;\r
+  tl->tail =p;\r
+  return p;  \r
+}\r
+\r
+//see if we can place at front of list\r
+if (pt->t >=t)\r
+{\r
+  tl->head=p;\r
+  p->next=pt;\r
+  return p;\r
+}\r
+\r
+ //timer has hashed into this chain.  find out where\r
+for(;pt;)\r
+{\r
+   if (pt->t >= t)       \r
+   {\r
+      if (pt_last) {\r
+        pt_last->next = p;\r
+        p->next=pt;\r
+        return p;\r
+      }\r
+      else\r
+      {\r
+        tl->head=p;\r
+        p->next=pt;\r
+        return p;\r
+      }\r
+   }\r
+   else {pt_last=pt;pt=pt->next;}\r
+}\r
+//last one\r
+pt_last->next=p;\r
+p->next=NULL;\r
+tl->tail=p;\r
+return p;\r
+}\r
+\r
+#ifdef TEST_DRIVER\r
+TIM_LIST_T the_base={NULL,NULL};\r
+TIM_LIST_T cell_base={NULL,NULL};\r
+char *mem;\r
+TIM_T * timers[10];\r
+TIM_LIST_T res;\r
+main()\r
+{\r
+ int err;\r
+ mem= malloc(100*sizeof(TIM_T));\r
+ TIM_T *p;\r
+ int n;\r
+ int i;\r
\r
+ tim_build_free(&the_base, mem , 100*sizeof(TIM_T));\r
+\r
+ timers[0]=tim_set(&cell_base, &the_base, 100LL, (void *) 1, &err);\r
+ timers[1]=tim_set(&cell_base, &the_base, 101LL, (void *) 2, &err);\r
+ timers[2]=tim_set(&cell_base, &the_base, 105LL, (void *) 3, &err);\r
+ timers[3]=tim_set(&cell_base, &the_base,  95LL, (void *) 4, &err);\r
+ timers[4]=tim_set(&cell_base, &the_base,  95LL, (void *) 5, &err);\r
+ timers[5]=tim_set(&cell_base, &the_base,  95LL, (void *) 6, &err);\r
+ timers[6]=tim_set(&cell_base, &the_base,  104LL, (void *) 7, &err);\r
+ timers[7]=tim_set(&cell_base, &the_base,  104LL, (void *) 8, &err);\r
+ timers[8]=tim_set(&cell_base, &the_base,  104LL, (void *) 9, &err);\r
+\r
+ tim_cancel(timers[6], &err);\r
+\r
+\r
+ res.head=res.tail=NULL;\r
+for(i=90;i<106;i++)\r
+ {\r
+tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) i,  &n);\r
+ printf("at %d got %d\n", i, n);\r
+ if (n) {tim_return_free(&the_base,&res,n); res.head=res.tail=NULL;\r
+\r
+ }\r
+\r
+//special cases..\r
+ res.head=res.tail=NULL;\r
+ timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);\r
+ tim_cancel(timers[0],&err);\r
+ tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);\r
\r
+ res.head=res.tail=NULL;\r
+ timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);\r
+ timers[1]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);\r
+ tim_cancel(timers[0],&err);\r
+ tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);\r
+\r
+ res.head=res.tail=NULL;\r
+ timers[0]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);\r
+ timers[1]=tim_set(&cell_base, &the_base, 106LL, (void *)10, &err);\r
+ tim_cancel(timers[0],&err);\r
+ tim_cancel(timers[1],&err);\r
+ tim_return_fired_list(&cell_base, &res, &the_base, (unsigned long long) 106,  &n);\r
\r
+}\r
+#endif\r
index 7d933b74e36af0f62bed8db98bbeb32ac2c20717..393db4f76117f6536c81d74a355ef75aa1ef5171 100755 (executable)
@@ -246,11 +246,16 @@ int perslow= PERSLOW;
  *************NETAPI OBJECTS***************\r
  *****************************************/\r
 Pktlib_HeapHandle OurHeap;\r
+Pktlib_HeapHandle specialSmall;\r
+Pktlib_HeapHandle specialLarge;\r
+\r
 PKTIO_HANDLE_T *our_chan;\r
 PKTIO_HANDLE_T *netcp_rx_chan;\r
+PKTIO_HANDLE_T *netcp_rx_chan2;\r
 PKTIO_HANDLE_T *netcp_tx_chan;\r
 PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};\r
 PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};\r
+PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};\r
 PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};\r
 \r
 void house(NETAPI_SCHED_HANDLE_T *s);\r
@@ -275,6 +280,7 @@ NETCP_CFG_IP_T ip_rule1;
 NETCP_CFG_CLASS_T class_0;\r
 NETCP_CFG_CLASS_T class_1;\r
 NETCP_CFG_CLASS_T class_2;\r
+NETCP_CFG_FLOW_HANDLE_T specialFlow;\r
 \r
 NETCP_CFG_CLASSIFIER_T class_0_cfg=\r
 {\r
@@ -292,6 +298,10 @@ NETCP_CFG_CLASSIFIER_T class_1_cfg=
    }\r
 };\r
 \r
+NETCP_CFG_ROUTE_T  class2_route=\r
+{\r
+NULL, NULL  //* to be filled in\r
+};\r
 NETCP_CFG_CLASSIFIER_T class_2_cfg=\r
 {\r
    NETCP_CFG_CLASS_TYPE_L3_L4,\r
@@ -634,9 +644,10 @@ uint32_t numFreeDataPackets;
 uint32_t numZeroBufferPackets;\r
 uint32_t numPacketsinGarbage;\r
 \r
-printf("stats @ %lld\n", netapi_getTimestamp());\r
-printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);\r
-printf("itx=%d rx=%d tx=%d bad=%d slow=%d rx_class0=%d rx_class1=%d n_t1=%d n_t2=%d n_t3=%d\n",stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new,stats.n_class0_rx, stats.n_class1_rx, stats.n_t1, stats.n_t2,stats.n_t3);\r
+printf(">*****stats @ %lld\n", netapi_getTimestamp());\r
+//printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);\r
+printf(">itx=%d rx=%d tx=%d bad=%d slow=%d \n>rx_class0=%d rx_class1=%d rx_class2=%d n_t1=%d n_t2=%d n_t3=%d\n",stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new,stats.n_class0_rx, stats.n_class1_rx,\r
+  stats.n_class2_rx, stats.n_t1, stats.n_t2,stats.n_t3);\r
 \r
 if(pPaStats)\r
 {\r
@@ -662,8 +673,17 @@ if(pPaStats)
 }\r
 Pktlib_getHeapStats(OurHeap, &numFreeDataPackets,\r
                              &numZeroBufferPackets, &numPacketsinGarbage);\r
-printf("heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
+printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
+                                numZeroBufferPackets, numPacketsinGarbage);\r
+Pktlib_getHeapStats(specialSmall, &numFreeDataPackets,\r
+                             &numZeroBufferPackets, &numPacketsinGarbage);\r
+printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
                                 numZeroBufferPackets, numPacketsinGarbage);\r
+Pktlib_getHeapStats(specialLarge, &numFreeDataPackets,\r
+                             &numZeroBufferPackets, &numPacketsinGarbage);\r
+printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
+                                numZeroBufferPackets, numPacketsinGarbage);\r
+\r
 //debug = dump timer polling stats\r
 dump_poll_stats();\r
 \r
@@ -788,6 +808,23 @@ netapi_handle = netapi_init(NETAPI_SYS_MASTER);
 OurHeap = Pktlib_findHeapByName("netapi");\r
 if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}\r
 \r
+/* create two secondary heaps */\r
+specialSmall = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
+                                                1,\r
+                                                256, //bytes\r
+                                                64,  //num buffs\r
+                                                0,\r
+                                                netapi_getPktlibIfTable());\r
+specialLarge = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
+                                                1,\r
+                                                1600, //bytes\r
+                                                64,  //num buffs\r
+                                                0,\r
+                                                netapi_getPktlibIfTable());\r
+netapi_registerHeap(netapi_handle, specialSmall);\r
+netapi_registerHeap(netapi_handle, specialLarge);\r
+\r
+\r
 /* create a pktio channel */\r
 our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb, &our_chan_cfg,&err);\r
 if (!our_chan) {printf("pktio create failed err=%d\n",err); exit(1);}\r
@@ -798,6 +835,10 @@ if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);\r
 if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}\r
 \r
+/* create a pktio channel for specially classified pkts */\r
+netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);\r
+if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}\r
+\r
 \r
 /* create scheduler instance */\r
 our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);\r
@@ -867,10 +908,30 @@ class_1 =  netcp_cfgAddClass(netapi_handle,
 if (err) {printf("addclass1 failed %d\n",err); exit(1);}\r
 \r
 \r
+//3rd classifier has a different IP and route\r
 class_2_cfg.u.c_l3_l4.ip_addr = &OurIp2;\r
+\r
+//create specialFlow for this classifier\r
+{\r
+Pktlib_HeapHandle heaps[2];\r
+int sizes[2];\r
+heaps[0]= specialSmall;\r
+heaps[1]= specialLarge;\r
+sizes[0]=256;\r
+sizes[1]=1600;\r
+specialFlow = netcp_cfgAddFlow( netapi_handle,\r
+                               2,\r
+                                heaps,\r
+                                sizes,\r
+                                &err);\r
+if (err) {printf("add flow failed\n", err); exit(1);}\r
+}\r
+//special route for this classifier:  different flow + destination q\r
+class2_route.p_dest_q = netcp_rx_chan2;\r
+class2_route.p_flow = specialFlow;\r
 class_2 = netcp_cfgAddClass(netapi_handle,\r
                             &class_2_cfg,\r
-                            NULL,\r
+                            (void*) &class2_route,\r
                             NETCP_CFG_ACTION_TO_SW,\r
                             &err);\r
 if (err) {printf("addclass2 failed %d\n",err); exit(1);}\r
@@ -908,6 +969,8 @@ t3 = netapi_TimerGroupStartTimer(
         &err);\r
 if (err) {printf("timerstart failed %d\n");}\r
 \r
+netcp_cfgReqStats(netapi_handle, our_stats_cb, 1,&err);\r
+if (err!=0) {printf("stats req failed\n");}\r
 \r
 /*********************************************/\r
 /*****************end NETAPI STARTUP**********/\r
@@ -947,11 +1010,18 @@ netapi_schedWaitForEvents(our_sched, &err);
 printf("done: itx=%d rx=%d tx=%d bad=%d slow=%d\n",stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new);\r
 our_stats_cb(netapi_handle, NULL);\r
 \r
+/*************************************************\r
+ ************CLEAN UP****************************\r
+ ************************************************/\r
+\r
 //delete Classifiers\r
 netcp_cfgDelClass(netapi_handle, class_0, &err); \r
 netcp_cfgDelClass(netapi_handle, class_1, &err); \r
 netcp_cfgDelClass(netapi_handle, class_2, &err); \r
 \r
+//delete flow \r
+netcp_cfgDelFlow(netapi_handle, specialFlow, &err);\r
+\r
 //delete IPs and MAC Interfacess\r
 netcp_cfgDelIp(netapi_handle, 0, 0, NULL, NULL, ip_rule0, &err);\r
 netcp_cfgDelIp(netapi_handle, 1, 0, NULL, NULL, ip_rule1, &err);\r
@@ -964,8 +1034,11 @@ pktio_close(netcp_rx_chan ,&err);
 \r
 //clear pktio channel we created\r
 pktio_control(our_chan, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
+pktio_control(netcp_rx_chan2, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
+\r
 //delete pktio channels we created\r
 pktio_delete(our_chan, &err);\r
+pktio_delete(netcp_rx_chan2,&err);\r
 \r
 netapi_shutdown(netapi_handle);\r
 \r