Incorporated code review comments, source file cleanup, implemented support for GMAC...
authorTinku Mannan <tmannan@ti.com>
Mon, 21 Jan 2013 20:32:09 +0000 (15:32 -0500)
committerTinku Mannan <tmannan@ti.com>
Mon, 21 Jan 2013 21:13:52 +0000 (16:13 -0500)
22 files changed:
ti/runtime/netapi/build/netapi_doxygen.cfg
ti/runtime/netapi/netapi.h
ti/runtime/netapi/netapi_err.h
ti/runtime/netapi/netapi_sched.h
ti/runtime/netapi/netapi_sec.h
ti/runtime/netapi/netapi_ver.h [new file with mode: 0755]
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_sec.c
ti/runtime/netapi/src/netcp_cfg.c
ti/runtime/netapi/src/pdkv2/netapi_navig.c
ti/runtime/netapi/src/pdkv3/netapi_navig.c
ti/runtime/netapi/src/pktio.c
ti/runtime/netapi/test/addsa_test.c
ti/runtime/netapi/test/mt_test.c
ti/runtime/netapi/test/net_test.c
ti/runtime/netapi/test/net_test.h
ti/runtime/netapi/test/net_test_config.txt

index a4fc4412bbcbc1f91901a4b31c6e691301d65070..41e090596a280b4e4bdb132cee386207043f7243 100755 (executable)
@@ -574,7 +574,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = ../netapi.h ../netcp_cfg.h ../netapi_sec.h ../netapi_tune.h ../netapi_sched.h ../pktio.h ../netapi_err.h 
+INPUT                  = ../netapi.h ../netcp_cfg.h ../netapi_sec.h ../netapi_tune.h ../netapi_sched.h ../pktio.h ../netapi_err.h ../netapi_ver.h
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
index 27f49ec3790fecf357a2dccc5d03dd3877b10648..b7a3e6c4ea97403fba92a71a3022f1d26aefc22b 100755 (executable)
  */
 /** @} */
 
-
-extern hplib_virtualAddrInfo_T netapi_VM_VirtAddr[HPLIB_MAX_MEM_POOLS];
-extern unsigned char *netapi_VM_SaContextVaddr;
-
 /** @defgroup netapi_gen_functions NETAPI General Functions
  *  @ingroup netapi
  */
@@ -174,23 +170,6 @@ extern unsigned char *netapi_VM_SaContextVaddr;
  *  @ingroup netapi
  */
 
-
-/**
- * @def NETAPI_VERSION_ID
- *      This is the NETAPI Version. Versions numbers are encoded in the following 
- *      format:
- *              0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
- */
-#define NETAPI_VERSION_ID                   (0x01000004)
-
-/**
- * @def NETAPI_VERSION_STR
- *      This is the version string which describes the NETAPI along with the
- *      date and build information.
- */
-#define NETAPI_VERSION_STR      "NETAPI Revision: 01.00.00.04"
-
-
 /**
  * @ingroup cfg_constants
  * @brief  One per thread, used in most NETAPI function calls.
@@ -200,35 +179,38 @@ typedef void * NETAPI_T;
 
 /**
  * @def NETAPI_SYS_MASTER
- *      This defines master for system
+ *      This defines the master core for the system
  */
 #define NETAPI_SYS_MASTER  2  
 
 /**
  * @def NETAPI_CORE_MASTER
- *      This defines master for core
+ *      This defines the master thread  for a particular core
  */
 #define NETAPI_CORE_MASTER 1  
 
 /**
  * @def  NETAPI_NO_MASTER
- *      This defines no master, data only
+ *      This defines a non master thread which can be running on any core,, specifically for data only
  */
 #define NETAPI_NO_MASTER   0  //data only
 
 #include "netapi_err.h"
 #include "netapi_tune.h"
-#include "ti/runtime/pktlib/pktlib_osal.h"
-#include "ti/runtime/pktlib/pktlib.h"
+//#include "ti/runtime/pktlib/pktlib_osal.h"
+//#include "ti/runtime/pktlib/pktlib.h"
 #include "pktio.h"
-#include "ti/drv/pa/pa.h"
+//#include "ti/drv/pa/pa.h"
 #include "netcp_cfg.h"
 #include "netapi_sec.h"
 #include "netapi_sched.h"
-#include "ti/drv/nwal/nwal.h"
+//#include "ti/drv/nwal/nwal.h"
 #include "src/netapi_loc.h"
 #include "hplib.h"
 
+
+static hplib_spinLock_T netapi_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
+
 /**
  *  @ingroup netapi_gen_functions
  *  @brief netapi_init  API instantiates the NETAPI and allocated global resources.
@@ -284,8 +266,10 @@ Pktlib_HeapIfTable *netapi_getPktlibIfTable(void) ;
  *  @retval     Amount of memory available for heap buffer storage (in bytes)
  *  @pre        @ref netapi_init 
  */
-int  netapi_getBufMemRemainder(void);
-
+static inline int  netapi_getBufMemRemainder(void)
+{
+     return hplib_vmGetMemPoolRemainder(0);
+}
 
 /**
  *  @ingroup netapi_gen_functions
@@ -381,49 +365,63 @@ void netapi_netcpPoll(NETAPI_T  p);
 /**
  *  @ingroup netapi_gen_functions
  *  @brief netapi_registerHeap  API is used to register a heap that is created by application so that
- *                              it's garbage queue can be polled automatically by @ref netapi_poll_heapGarbage().
+ *                              it's garbage queue can be polled automatically by @ref netapi_pollHeapGarbage.
  *
  *  @details This API registers an application-created heap with the netapi instance
  *           so that it can add that heap's garbage queue to the garbage poll function. 
  *           NOTE: netapi internal heap is automatically registered
  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
  *  @param[in]  h   Handle of pklib heap to register
- *  @retval     1 if OK, <0 on error 
+ *  @retval     1 if OK, <0 on error
  *  @pre        @ref netapi_init
  */
 static inline int netapi_registerHeap(NETAPI_T p,  Pktlib_HeapHandle h)
 {
-NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
-int i;
-for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
-{
-       if (!pp->createdHeaps[i]) {pp->createdHeaps[i]=h; return 1;}
-}
-return -1;  //no room
+    NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
+    int i;
+    hplib_mSpinLockLock(&netapi_lock);
+    for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
+    {
+        if (!pp->createdHeaps[i])
+        {
+            pp->createdHeaps[i]=h;
+             hplib_mSpinLockUnlock(&netapi_lock);
+            return 1;
+        }
+    }
+    hplib_mSpinLockUnlock(&netapi_lock);
+    return -1;
 }
 
 /**
  *  @ingroup netapi_gen_functions
  *  @brief netapi_unregisterHeap  API is used to un-register a heap that was created by application 
  *                                and previously registered so that it's garbage queue could  be polled 
- *                                automatically by @ref netapi_poll_heapGarbage()
+ *                                automatically by @ref netapi_pollHeapGarbage
  *
  *  @details This API un-registers an application-created heap with the netapi instance. 
  *           NOTE: netapi internal heap is automatically registered
  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
  *  @param[in]  h   The pklib handle to heap 
  *  @retval     <0 if err, 1 if OK
- *  @pre        @ref netapi_init , @ref netapi_registerHeap()
+ *  @pre        @ref netapi_init
  */
 static inline int netapi_unregisterHeap(NETAPI_T p,  Pktlib_HeapHandle h)
 {
-NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
-int i;
-for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
-{
-        if (pp->createdHeaps[i] == h) {pp->createdHeaps[i]=NULL; return 1;}
-}
-return -1;  //not found
+    NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
+    int i;
+    hplib_mSpinLockLock(&netapi_lock);
+    for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
+    {
+            if (pp->createdHeaps[i] == h)
+            {
+                pp->createdHeaps[i]=NULL;
+                hplib_mSpinLockUnlock(&netapi_lock);
+                return 1;
+            }
+    }
+    hplib_mSpinLockUnlock(&netapi_lock);
+    return -1;
 }
 
 /**
@@ -437,11 +435,18 @@ return -1;  //not found
  *  @retval     <0 if err, 1 if OK
  *  @pre        @ref netapi_init  @ref netapi_registerHeap
  */
-int netapi_closeHeap(NETAPI_T p, Pktlib_HeapHandle h);
-
+static inline int netapi_closeHeap(NETAPI_T p, Pktlib_HeapHandle h)
+{
+    Qmss_QueueHnd q;
+    Pktlib_garbageCollection(p);
+    q = Pktlib_getZeroHeapQueue(p);
+    netapi_zapQ(q);
+    q= Pktlib_getInternalHeapQueue(p);
+    netapi_zapQ(q);
+}
 /**
  *  @ingroup netapi_gen_functions
- *  @brief netapi_poll_heapGarbage  API is used to poll the garbage collection queue for 
+ *  @brief netapi_pollHeapGarbage  API is used to poll the garbage collection queue for 
  *                                  the internal NETAPI heaps and any application created heaps.
  *
  *  @details  This API is used to poll the netapi internal heaps and any 
@@ -452,29 +457,7 @@ int netapi_closeHeap(NETAPI_T p, Pktlib_HeapHandle h);
  *  @retval     none 
  *  @pre        @ref netapi_init
  */
-void netapi_poll_heapGarbage(NETAPI_T p);
+void netapi_pollHeapGarbage(NETAPI_T p);
 
-/**
- *  @ingroup netapi_gen_functions
- *  @brief netapi_get_version  API used to get version of NETAPI 
- *
- *  @details This  API used to get version of netapi
- *  @retval     int version of netapi
- *  @pre        @ref netapi_init
- */
-static inline int netapi_get_version(void)
-{
-return NETAPI_VERSION_ID;
-}
-
-/**
- *  @ingroup netapi_gen_functions
- *  @brief netapi_get_version_string  API used to get version string of NETAPI 
- *
- *  @details This  API used to get version string of netapi
- *  @retval     char version string of netapi
- *  @pre        @ref netapi_init
- */
-static inline char * netapi_get_version_string(void) { return NETAPI_VERSION_STR;}
 
 #endif
index d36ee6cf9b5e166a2b9afe8be658ba08104ea6c0..a7f835849d5f900126a96008266856955a9289fd 100755 (executable)
@@ -97,7 +97,7 @@
 #define NETAPI_ERR_NWAL_ERR0 -6
 
 /**
- *  @def  NETAPI_ERR_NOT_IMLEMENTED_
+ *  @def  NETAPI_ERR_NOT_IMPLEMENTED
  *  @ingroup netapi_errors
  *  @brief   Feature not implemented in this version
  */
index 7f81d67d8fdeb6955b5905a10e20911670b8082d..8b49f6a1f37db826181875fb4d2acc70a15f6fbf 100755 (executable)
@@ -76,18 +76,10 @@ typedef void (*NETAPI_SCHED_CB)(struct NETAPI_SCHED_HANDLE_Tag *h);
  */
 typedef struct NETAPI_SCHED_CONFIG_Tag
 {
-
-/**
- * Valid flag options of scheduler context being configured.
- * <br>
- * The following are flags used to configure the scheduler:
- *      @ref NETAPI_SCHED_DURATION , @ref NETAPI_SCHED_POWER, @ref NETAPI_SCHED_FINE, @ref NETAPI_SCHED_FINE
- */
-    int valid_flags;
-
 /**
  * @def NETAPI_SCHED_DURATION
  * @ingroup sched_constants
+ *      Duration configuration flag for scheduler
  */
 #define NETAPI_SCHED_DURATION 0x1
 
@@ -119,6 +111,17 @@ typedef struct NETAPI_SCHED_CONFIG_Tag
  */
 #define NETAPI_SCHED_FOREVER 0L
 
+/**
+ * Valid flag options of scheduler context being configured.
+ * <br>
+ * The following are flags used to configure the scheduler:
+ *      @ref NETAPI_SCHED_DURATION , @ref NETAPI_SCHED_POWER, @ref NETAPI_SCHED_FINE, @ref NETAPI_SCHED_FINE
+ */
+    int valid_flags;
+
+
+
+
     uint64_t duration;                      /**< Duration scheduler is configured to run, 0 == forever, 
                                               * non-zero value is ticks for scheduler to run
                                               */
@@ -157,6 +160,18 @@ typedef struct NETAPI_SCHED_CONFIG_Tag
     Bool pollGarbageQ;          /**< option to poll the garbage  queue in scheduling loop */
 } NETAPI_SCHED_CONFIG_T;
 
+/**
+ *  @ingroup sched_structures
+ *  @brief NETAPI scheduler statisics.
+ *
+ *  @details  This structure is returned from call to @ref netapi_schedOpen API
+ */
+typedef struct NETAPI_SCHED_STATS_Tag
+{
+    unsigned long long num_pkts;        /**< Number of packets processed in sheduler context */
+    unsigned long long busy_cycles;     /**< Number of CPU cyles scheduler was busy processing packets */
+    unsigned long long cache_cycles;     /**< Number of CPU cyles scheduler was busy in cache operations */
+} NETAPI_SCHED_STATS_T;
 
 
 /**
@@ -167,13 +182,6 @@ typedef struct NETAPI_SCHED_CONFIG_Tag
  */
 typedef struct NETAPI_SCHED_HANDLE_Tag
 {
-/**
- * State of the scheduler
- * <br>
- * The following are valid states of the scheduler, 
- *      @ref NETAPI_SCHED_STATE_CLOSE , @ref NETAPI_SCHED_STATE_CLOSE_IN_PROGRESS, @ref NETAPI_SCHED_STATE_OPEN
- */
-    volatile int state;                /**< 0= shutdown, 1= shutting down, 2=active */
 
 /**
  * @def NETAPI_SCHED_STATE_CLOSE
@@ -196,22 +204,27 @@ typedef struct NETAPI_SCHED_HANDLE_Tag
  */
 #define NETAPI_SCHED_STATE_OPEN 2
 
+/**
+ * State of the scheduler
+ * <br>
+ * The following are valid states of the scheduler, 
+ *      @ref NETAPI_SCHED_STATE_CLOSE , @ref NETAPI_SCHED_STATE_CLOSE_IN_PROGRESS, @ref NETAPI_SCHED_STATE_OPEN
+ */
+    volatile int state;                /**< 0= shutdown, 1= shutting down, 2=active */
+
     void * back;                        /**< Pointer back to NETAPI  handle */
     NETAPI_SCHED_CONFIG_T config;       /**< NETAPI scheduler configuration */
     uint64_t start;                     /**< Start time of NETAPI scheduler context */ 
     volatile int shutdown_reason;       /**< FUTURE-not implemented  */
     volatile uint64_t shutdown_time;    /**< Time till scheduler context will be shutdown/closed */
-unsigned long long num_pkts;
-unsigned long long busy_cycles;
-unsigned long long cache_cycles;
-
+    NETAPI_SCHED_STATS_T stats;         /**< Per scheduler satistics */
 } NETAPI_SCHED_HANDLE_T;
 
 
 
 
 /// @cond FUTURE
-/* return codes for wait_for_events()  currently not used*/
+/* return codes for sched run, ()  currently not used*/
 #define NETAPI_SCHED_RETURN_ERR         0       /**<unknown, err */
 #define NETAPI_SCHED_RETURN_TO          1       /**<returned after timeout */
 #define NETAPI_SCHED_RETURN_SHUTDOWN    2       /**<returned after shutdown */
@@ -222,7 +235,7 @@ unsigned long long cache_cycles;
 /**
  *  @ingroup sched_structures
  *  @brief NETAPI scheduler shutdown structure
- *  @details  This structure is passed an an argument for @ref netapi_schedShutdown
+ *  @details  This structure is passed an an argument for @ref netapi_schedClose
  */
 typedef struct NETAPI_SCHED_SHUTDOWN_Tag
 {
@@ -292,7 +305,7 @@ int netapi_schedControl(NETAPI_SCHED_HANDLE_T *s,
 
 /**
  *  @ingroup sched_functions
- *  @brief netapi_schedWaitForEvents: API for main entry point to scheduler.
+ *  @brief netapi_schedRun: API for main entry point to scheduler.
  *
  *  @details API for main entry point to scheduler. User application gives up control to scheduler.
   *  @param[in]  s           The NETAPI scheduling context handle, @ref NETAPI_SCHED_HANDLE_T
@@ -300,33 +313,33 @@ int netapi_schedControl(NETAPI_SCHED_HANDLE_T *s,
  *  @retval     always 1
  *  @pre        @ref netapi_schedOpen 
  */
-int netapi_schedWaitForEvents(NETAPI_SCHED_HANDLE_T *s,
+int netapi_schedRun(NETAPI_SCHED_HANDLE_T *s,
                               int * p_err);
 
 /**
  *  @ingroup sched_functions
- *  @brief netapi_schedShutdown: API to shutdown scheduling context
+ *  @brief netapi_schedClose: API to close a scheduling context
  *
- *  @details API to shutdown scheduling context
+ *  @details API to close a scheduling context
  *  @param[in]  s           The NETAPI scheduling context handle, @ref NETAPI_SCHED_HANDLE_T
  *  @param[in]  p_close  @ref NETAPI_SCHED_SHUTDOWN_T
  *  @param[out] p_err    Pointer to error code.
  *  @retval     NO USED, ALWAYS 1
  *  @pre        @ref netapi_schedOpen 
  */
-int netapi_schedShutdown(NETAPI_SCHED_HANDLE_T * s, 
+int netapi_schedClose(NETAPI_SCHED_HANDLE_T * s, 
                          NETAPI_SCHED_SHUTDOWN_T * p_close,
                          int *p_err);
 
 /**
  *  @ingroup sched_functions
- *  @brief netapi_schedShutdown: API to get the NETAPI handle from scheduling context 
+ *  @brief netapi_schedGetHandle: API to get the NETAPI handle from scheduling context 
  *
  *  @details API to get the NETAPI handle from scheduling context 
  *  @param[in]  s           The NETAPI scheduling context handle, @ref NETAPI_SCHED_HANDLE_T
  *  @retval     Handle to NETAPI instance
  */
-static NETAPI_T netapi_schedGetNetapiHandle(NETAPI_SCHED_HANDLE_T *s)
+static NETAPI_T netapi_schedGetHandle(NETAPI_SCHED_HANDLE_T *s)
 {
     return (NETAPI_T)s->back;
 }
@@ -336,16 +349,16 @@ static NETAPI_T netapi_schedGetNetapiHandle(NETAPI_SCHED_HANDLE_T *s)
 
 /**
  *  @ingroup sched_functions
- *  @brief netapi_sched_get_stats: API to get NETAP scheduling context statistics
+ *  @brief netapi_schedGetStats: API to get scheduling context statistics
  *
- *  @details   API to tget NETAP scheduling context statistics
+ *  @details   API to tget scheduling context statistics
  *  @param[in]  s           The NETAPI scheduling context handle, @ref NETAPI_SCHED_HANDLE_T
  *  @param[in]  p_pkts  total number of packets processed by scheduler poll loop
  *  @param[in]  p_cycles total number cycles taken by scheduler poll loop
  *  @param[in]  p_ccycles  total number of cache control cycles taken by scheduler poll loop
  *  @retval     none
  */
-void netapi_sched_get_stats(NETAPI_SCHED_HANDLE_T *s,
+void netapi_schedGetStats(NETAPI_SCHED_HANDLE_T *s,
                                                         unsigned long long * p_pkts, 
                                                         unsigned long long * p_cycles,
                                                         unsigned long long * p_ccycles);
index 525b89e09986fde0e9c2957bdaf8f36991306470..74d1e82d2718b408deb1ef56c0a406d2b770cb86 100755 (executable)
@@ -130,9 +130,9 @@ typedef struct NETAPI_SEC_SA_INFO_tag
 
 /**
  *  @ingroup cfg_security_functions
- *  @brief netapi_secAddSA  API to configure an IPSEC SA.
+ *  @brief netapi_secAddSA  API to add an IPSEC SA.
  *
- *  @details API to configure an IPSec SA. SAs are IPSec security contexts and define a uni-directional
+ *  @details API to add an IPSec SA. SAs are IPSec security contexts and define a uni-directional
  *           secure path (tunnel or transport). SAs are attached to MAC interfaces that have already
  *           been created. API allows SA to be configured as either inflow or sideband mode. This API is used for both receive and transmit SAs.
  *  @param[in]  h            The NETAPI handle, @ref NETAPI_T
diff --git a/ti/runtime/netapi/netapi_ver.h b/ti/runtime/netapi/netapi_ver.h
new file mode 100755 (executable)
index 0000000..da9596f
--- /dev/null
@@ -0,0 +1,83 @@
+/*******************************
+ * file: netapi_ver.h
+ * purpose: netapi version information
+ **************************************************************
+ * @file netapi.h
+ * 
+ * @brief DESCRIPTION:  netapi version information 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_ERR__
+#define __NETAPI_ERR__
+/**
+ * @def NETAPI_VERSION_ID
+ *      This is the NETAPI Version. Versions numbers are encoded in the following 
+ *      format:
+ *              0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
+ */
+#define NETAPI_VERSION_ID                   (0x01000004)
+
+/**
+ * @def NETAPI_VERSION_STR
+ *      This is the version string which describes the NETAPI along with the
+ *      date and build information.
+ */
+#define NETAPI_VERSION_STR      "NETAPI Revision: 01.00.00.04"
+
+/**
+ *  @ingroup netapi_gen_functions
+ *  @brief netapi_mGetVersion  API used to get version of NETAPI 
+ *
+ *  @details This  API used to get version of netapi
+ *  @retval     int version of netapi
+ *  @pre        @ref netapi_init
+ */
+static inline int netapi_getVersion(void)
+{
+return NETAPI_VERSION_ID;
+}
+
+/**
+ *  @ingroup netapi_gen_functions
+ *  @brief netapi_mGetVersionString  API used to get version string of NETAPI 
+ *
+ *  @details This  API used to get version string of netapi
+ *  @retval     char version string of netapi
+ *  @pre        @ref netapi_init
+ */
+static inline char * netapi_getVersionString(void) { return NETAPI_VERSION_STR;}
+#endif
index b89e3c6f96a7b9495dbd59f54e790af200bce5c3..f75e2473816197da0a957e78272c511c240f610d 100755 (executable)
@@ -58,7 +58,7 @@
 /**
  *  @ingroup cfg_structures
  *  @brief CPPI flow ID for default case, use NETCP_DEFAULT_FLOW
- *  @details A flow defines a set of free queues (@pktlib heap) for h/w to use to get free packet descriptor(s) and buffer(s) to use when receiving a packet
+ *  @details A flow defines a set of free queues (pktlib heap) for h/w to use to get free packet descriptor(s) and buffer(s) to use when receiving a packet
  */
 typedef struct NETCP_CFG_FLOW_Tag
 {
@@ -109,8 +109,6 @@ Cppi_HostDesc->origBuffPtr
                         ^
                         |
                      Cppi_HostDesc->buffPtr
-
-
 */
 
 
@@ -123,23 +121,26 @@ typedef void *  NETCP_CFG_FLOW_HANDLE_T;
 /**
  * @ingroup cfg_constants
  * @def NETCP_DEFAULT_FLOW
- * @brief This defines the default FLOW for NETCP to use. The default flow uses the default @pktlib heap created by netapi_init; i.e. NETCP will allocate descriptors and buffers for received packets from this heap.
+ * @brief This defines the default FLOW for NETCP to use. 
+ * The default flow uses the default pktlib heap created by netapi_init; i.e. NETCP will allocate descriptors and buffers for received packets from this heap.
  */
 #define NETCP_DEFAULT_FLOW  (NETCP_CFG_FLOW_HANDLE_T*) NULL
 
 
 /**
  * @ingroup cfg_constants
- * @brief  Handle to a  NETCP route.
- * @details Application to use this handle to identify a  NETCP route.  A NETCP route defines the pktio channel for packets received by NETCP and the flow to use
+ * @brief  Handle to a NETCP route.
+ * @details Application to use this handle to identify a NETCP route.  A NETCP route defines the pktio channel for packets received by NETCP
+ *    and the flow to use.
  */
 typedef void * NETCP_CFG_ROUTE_HANDLE_T;
 
 /**
  * @def NETCP_DEFAULT_ROUTE
- *      This defines the NETCP default route.  This route has NETCP send received packets to the default NETCP pktio channel using descriptors and buffers from the default flow. The default route is created by @netapi_init
+ * This defines the NETCP default route.  This route has NETCP send received packets to the default NETCP 
+ * pktio channel using descriptors and buffers from the default flow. The default route is created by netapi_init
  */
-#define NETCP_DEFAULT_ROUTE  (NETCP_CFG_ROUTE_HANDLE_T*) NULL
+#define NETCP_DEFAULT_ROUTE (NETCP_CFG_ROUTE_HANDLE_T*) NULL
 
 
 /**
@@ -173,14 +174,12 @@ typedef struct NETCP_CFG_ROUTE_Tag
  */
 #define NETCP_CFG_ACTION_TO_SW    2
 
-
-
 /**
  * @ingroup cfg_constants
- * @def NETCP_CTRL_CFG_ALL_EXCEPTIONS
+ * @def NETCP_CFG_ALL_EXCEPTIONS
  *      This defines NETCP configuration for all Exepction Packets.
  */
-#define NETCP_CFG_ALL_EXCEPTIONS -0xff
+#define NETCP_CFG_ALL_EXCEPTIONS 0xff
 
 
 
@@ -188,7 +187,7 @@ typedef struct NETCP_CFG_ROUTE_Tag
 /**
  * @ingroup cfg_constants
  * @brief  Handle to NETCP VLAN configuration (FUTURE).
- * @details Application to use this handle to identify a VLAN configutation.
+ * @details Application to use this handle to identify a VLAN configuration.
  */
 typedef void * NETCP_CFG_VLAN_T;
 
@@ -204,8 +203,6 @@ typedef uint32_t NETCP_CFG_MACIF_T;
  */
 typedef uint32_t NETCP_CFG_IP_T;
 
-
-
 /**
  * @ingroup cfg_constants
  * @brief This define is used to identify the application id associated with a created SA (IPSEC security association) rule
@@ -229,8 +226,7 @@ typedef uint32_t NETCP_CFG_EXCEPTION_PKT_T;
 
 /**
  * @ingroup cfg_constants
- * @def NETCP_CFG_NO_INTERFACE
- *      This define is to be used in AddIp, AddClassifier, addSA, etc. to indicate that the rule can be bound to any MAC address.
+ *@brief This define is to be used in AddIp, AddClassifier, addSA, etc. to indicate that the rule can be bound to any MAC address.
  */
 #define NETCP_CFG_NO_INTERFACE 0xff
 
@@ -338,7 +334,7 @@ NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T h,
  *  @ingroup cfg_functions
  *  @brief netcp_cfgDelFlow   API to delete a flow
  * 
- *  @details This api is used to delete a flow previousy added.
+ *  @details This api is used to delete a flow.
  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
  *  @param[in]  p    handle to NETCP  flow
  *  @param[out] err     pointer to error return
@@ -557,13 +553,14 @@ typedef struct NETCP_CFG_CLASSIFIER_Tag
 
 /**
  *  @ingroup cfg_functions
- *  @brief netcp_cfgAddClass   API can be used to attach a classifier rule to NETCP.  This can be used to route a particular packet flow to a specific PKTIO channel
+ *  @brief netcp_cfgAddClass   API to attach a classifier rule to NETCP.
+ *      This can be used to route a particular packet flow to a specific PKTIO channel
  * 
  *  @details This api can be used to route a particular packet flow to a particular PktIO channel, using a specific 
  *  pktLib heap, and/or have NetCP attach a tag (classifier id) to the incoming packet.
  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
  *  @param[in]  p_class definition of the classifier
- *  @param[in]  p_route, @ref NETCP_CFG_ROUTE_HANDLE_T
+ *  @param[in]  p_route handle to NETCP route.
  *  @param[in]  action       what to do with packet: one of NETCP_CFG_ACTION_TO_SW, DISCARD or CONTINUE
  *  @param[out] err     pointer to error return
  *  @retval     returned AppID for attached rule. This is returned in RX meta data for packets matching this rule and no other, @ref NETCP_CFG_IP_T
@@ -578,7 +575,7 @@ typedef struct NETCP_CFG_CLASSIFIER_Tag
 
 /**
  *  @ingroup cfg_functions
- *  @brief netcp_cfgDelClass   API can be used to delete a preconfigured classifier
+ *  @brief netcp_cfgDelClass   API to delete a preconfigured classifier
  * 
  *  @details This API can be used to delete a preconfigured classifier
  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
@@ -634,10 +631,9 @@ void netcp_cfgReqStats(NETAPI_T  h,
  *
  *  @details This api is used to configure NETCP with global rules of how to handle exception packets specified by exception_id.
  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
- *  @param[in]  exception_id-id of the exception packet, refer to pa.h,.pa_EROUTE_XXX for list of exception packet id's
- *  @param[in]  p_route, @ref NETCP_CFG_ROUTE_HANDLE_T
+ *  @param[in]  exception_id id of the exception packet, refer to pa.h,.pa_EROUTE_XXX for list of exception packet id's
+ *  @param[in]  p_route handle to NETCP route.
  *  @param[in]  action, action for NETCP to take upon classifying packet as type exception, refer to nwal. nwal_matchAction_t
- *  @param[out] err     pointer to error return
  *  @retval returns app_id, @ref NETCP_CFG_EXCEPTION_PKT_T
  *  @pre       @ref netapi_init 
  */
index feab0752cf2058bcd37307c98a792b83099d5cba..fe0c64be894132758beb87471ef5b08738841577 100755 (executable)
@@ -186,14 +186,6 @@ typedef struct PKTIO_POLL_Tag
 /* future */
 } PKTIO_POLL_T;
 
-/**
- * @def PKTIO_MAX_RECV
- * @ingroup pktio_constants
- *      This defines the maximum number of packets to receive in one pktio poll, @ref TUNE_NETAPI_MAX_BURST_RCV
- */
-#define PKTIO_MAX_RECV  (TUNE_NETAPI_MAX_BURST_RCV)
-
-
 /**
  *  @ingroup netapi_cb_functions
  *  @brief PKTIO_CB   Callback function to be issued on packet receive
@@ -260,43 +252,33 @@ typedef int (*PKTIO_POLL)(struct PKTIO_HANDLE_tag * channel,
 typedef struct PKTIO_CFG_Tag
 {
 /**
- * Flags for PKTIO channel configuration
- * <br>
- * The following are flags used to configure the pktio channel:
- *      @ref PKTIO_R , @ref PKTIO_W, @ref PKTIO_RW
- */
-    int flags1; 
-
-/**
- * @def PKTIO_R
+ * @def PKTIO_RX
  * @ingroup pktio_constants
  *      This defines the pktio channel as type read, i.e., for ingress
  */
-#define PKTIO_R 0x1
+#define PKTIO_RX 0x1
 
 /**
- * @def PKTIO_W
+ * @def PKTIO_TX
  * @ingroup pktio_constants
  *      This defines the pktio channel as type write, i.e. for egress
  */
-#define PKTIO_W 0x2
+#define PKTIO_TX 0x2
 
 /**
- * @def PKTIO_RW
+ * @def PKTIO_RX_TX
  * @ingroup pktio_constants
  *      This defines the pktio channel as type read/write 
  */
-#define PKTIO_RW (PKTIO_R | PKTIO_W)
-
-
+#define PKTIO_RX_TX (PKTIO_RX | PKTIO_TX)
 
 /**
- * Additional flags  for PKTIO channel configuration
+ * Flags for PKTIO channel configuration
  * <br>
  * The following are flags used to configure the pktio channel:
- *      @ref PKTIO_LOCAL , @ref PKTIO_GLOBAL, @ref PKTIO_RW
+ *      @ref PKTIO_RX , @ref PKTIO_TX, @ref PKTIO_RX_TX
  */
-int flags2; /**< Flags for PKTIO channel configuration */
+    int flags1; 
 
 /**
  * @def PKTIO_GLOBAL
@@ -326,6 +308,17 @@ int flags2; /**< Flags for PKTIO channel configuration */
  */
 #define PKTIO_SB     0x8
 
+
+
+/**
+ * Additional flags  for PKTIO channel configuration
+ * <br>
+ * The following are flags used to configure the pktio channel:
+ *      @ref PKTIO_LOCAL , @ref PKTIO_GLOBAL, @ref PKTIO_PKT, @ref PKTIO_SB
+ */
+int flags2; /**< Flags for PKTIO channel configuration */
+
+
 /**
  * @def PKTIO_Q_ANY
  * @ingroup pktio_constants
@@ -343,7 +336,25 @@ struct NETAPI_tag;
 
 /* a pktio channel .. */
 
-
+/**
+ *  @ingroup pktio_structures
+ *  @brief Per PKTIO channel statistics
+ *
+ *  @details Per PKTIO channel statistics
+ */
+typedef struct PKTIO_CHAN_STATS_Tag
+{
+    /* for benchmarking .. need to be defined somewhere */
+    unsigned int vv7p;
+    unsigned int vv8p;
+    unsigned int vv9p;
+    unsigned int vv10p;
+    unsigned int vv11p;
+    unsigned int vv12p;
+    unsigned int vv13p;  //rcv path
+    unsigned int vv14p;
+    unsigned int vv15p;
+} PKTIO_CHAN_STATS_T;
 
 /**
  *  @ingroup pktio_structures
@@ -415,19 +426,11 @@ typedef struct PKTIO_HANDLE_Tag
     void * cookie;                  /**<app specific */
     PKTIO_SEND _send;               /**<pktio type specific send function */
     PKTIO_POLL _poll;               /**<pktio type specific POLL function */
-    int poll_flags;
+    int poll_flags;                 /**< pktio flags to control polling options */
     char name[PKTIO_MAX_NAME+1];    /**< Name of pktio channel */
 #ifdef PKTIO_GET_BENCHMARK
+    PKTIO_CHAN_STATS_T stats;       /**<Per PKTIO channel stats, @ref PKTIO_CHAN_STATS_T */
     /* for benchmarking .. need to be defined somewhere */
-    unsigned int vv7p;
-    unsigned int vv8p;
-    unsigned int vv9p;
-    unsigned int vv10p;
-    unsigned int vv11p;
-    unsigned int vv12p;
-    unsigned int vv13p;  //rcv path
-    unsigned int vv14p;
-    unsigned int vv15p;
 #endif
 }  PKTIO_HANDLE_T;
 
@@ -442,19 +445,25 @@ typedef struct PKTIO_CONTROL_Tag
 {
 /**
  * @def PKTIO_CLEAR
- *      This defines is used to clear out the PKTIO channel
+ *      This defines is used to clear out the pktio channel
  */
 #define PKTIO_CLEAR 0x1
 
 /**
  * @def PKTIO_DIVERT
- *      This defines is used to divert to dest channel 
+ *      This define is used to divert to a dest pktio channel 
  */
 #define PKTIO_DIVERT 0x2
+
+/**
+ * @def PKTIO_SET_POLL_FLAGS
+ *      This define is used to set poll flags for a pktio channel
+ */
 #define PKTIO_SET_POLL_FLAGS 0x4 //control poll flags (netcp_rx only)
-    int op;                 /**< control operation (CLEAR, DIVERT, ..) */
+
+    int op;                 /**< Control operation (CLEAR, DIVERT, ..) */
     PKTIO_HANDLE_T *dest;   /**< Handle to PKTIO channel (for DIVERT) */
-    int poll_flags;
+    int poll_flags;         /**< Flags to indicate polling options */
 } PKTIO_CONTROL_T;
 
 
@@ -531,7 +540,7 @@ void pktio_control(PKTIO_HANDLE_T * handle,
 
 /**
  *  @ingroup pktio_functions
- *  @brief API closes a PKTIO channel
+ *  @brief API closes a NETAPI PKTIO channel
  *
  *  @details This closes a PKTIO channel
  *
@@ -545,7 +554,7 @@ void pktio_close(PKTIO_HANDLE_T * handle,
 
 /**
  *  @ingroup pktio_functions
- *  @brief API deletes a PKTIO channel
+ *  @brief API deletes a NETAPI PKTIO channel
  *
  *  @details This deletes a PKTIO channel
  *
@@ -559,7 +568,7 @@ void pktio_delete(PKTIO_HANDLE_T * handle,
 
 /**
  *  @ingroup pktio_functions
- *  @brief  API sends data to a NETAPI PKTIO channel 
+ *  @brief  API sends a packet to a NETAPI PKTIO channel 
  *
  *  @details This sends a Ti_Pkt and associated meta data, 
  *  @ref PKTIO_METADATA_T to a channel. The channel
@@ -583,7 +592,7 @@ static inline int  pktio_send(PKTIO_HANDLE_T * handle,
 
 /**
  *  @ingroup pktio_functions
- *  @brief API sends data to a NETAPI PKTIO channel
+ *  @brief API sends multiple packets to a NETAPI PKTIO channel
  *
  *  @details This sends an array of Ti_Pkt and associated meta data,
  *  @ref PKTIO_METADATA_T to a channel. The channel
@@ -629,7 +638,7 @@ static inline int pktio_poll(PKTIO_HANDLE_T * handle,
 
 /**
  *  @ingroup pktio_functions
- *  @brief API polls all NETAPI PKTIO channels associarted with @ref NETAPI_T instance
+ *  @brief API polls all NETAPI PKTIO channels associated with @ref NETAPI_T instance
  *         for received packets
  *
  *  @details This api polls all pktio channels attached to an instance.
@@ -691,7 +700,7 @@ int pktio_pollAll(NETAPI_T handle,
  *  @brief  API returns default packet queue to poll for netcp RX
  *  @note: these are expensive calls, so call once and save
  */
-static inline Qmss_QueueHnd PKTIO_GET_DEFAULT_NETCP_Q(PKTIO_HANDLE_T *h)
+static inline Qmss_QueueHnd pktio_mGetDefaultNetCpQ(PKTIO_HANDLE_T *h)
 {
     nwalGlobCxtInfo_t Info;
     nwal_getGlobCxtInfo(h->nwalInstanceHandle,&Info);
@@ -704,11 +713,11 @@ static inline Qmss_QueueHnd PKTIO_GET_DEFAULT_NETCP_Q(PKTIO_HANDLE_T *h)
  *  @brief  API returns L4Queue to poll for netcp RX (L4 classifier queue).
  *  @note: these are expensive calls, so call once and save
  */
-static inline Qmss_QueueHnd PKTIO_GET_DEFAULT_NETCP_L4Q(PKTIO_HANDLE_T *h)
+static inline Qmss_QueueHnd pktio_mGetDefaultNetCPL4Q(PKTIO_HANDLE_T *h)
 {
-nwalLocCxtInfo_t Info;
-nwal_getLocCxtInfo(h->nwalInstanceHandle,&Info);
-return Info.rxL4PktQ;
+    nwalLocCxtInfo_t Info;
+    nwal_getLocCxtInfo(h->nwalInstanceHandle,&Info);
+    return Info.rxL4PktQ;
 }
 
 
@@ -716,7 +725,7 @@ return Info.rxL4PktQ;
  *  @ingroup pktio_functions
  *  @brief  API to perform descriptor push to QMSS Queue
  */
-static inline void PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW(Qmss_QueueHnd hnd,
+static inline void pktio_mQmssQueuePushDescSizeRaw(Qmss_QueueHnd hnd,
                                                        void *descAddr,
                                                        uint32_t descSize)
 {
@@ -727,7 +736,7 @@ static inline void PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW(Qmss_QueueHnd hnd,
  *  @ingroup pktio_functions
  *  @brief  API to perform descriptor pop from QMSS Queue
  */
-static inline void* PKTIO_QMSS_QUEUE_POP_RAW(Qmss_QueueHnd hnd)
+static inline void* pktio_mQmssQueuePopRaw(Qmss_QueueHnd hnd)
 {
     return(Qmss_queuePopRaw(hnd));
 }
@@ -736,9 +745,9 @@ static inline void* PKTIO_QMSS_QUEUE_POP_RAW(Qmss_QueueHnd hnd)
  *  @ingroup pktio_functions
  *  @brief  API to retrieve NWAL global instance handle.
  */
-static inline nwal_Inst PKTIO_GET_NWAL_INSTANCE(PKTIO_HANDLE_T *h)
+static inline nwal_Inst pktio_mGetNwalInstance(PKTIO_HANDLE_T *h)
 {
-return h->nwalInstanceHandle;
+    return h->nwalInstanceHandle;
 }
 
 
index 9388f4aff77bb7455a3f9f570d7a13af7751c97c..40eb7b81d419cea0b84077a1172f9a829934f334 100755 (executable)
 #include <unistd.h>
 #include <string.h>
 #include "netapi.h"
+#include "src/netapi_loc.h"
 
 
-typedef struct PRESET_Tag
-{
-#define KMAXQ 10
-       int kqinuse[KMAXQ];
-        //more..
-} PRESET_T;
-
 /*------------internal prototypes---------------*/
 static uint8_t* netapiSharedMemoryMalloc(uint32_t size);
 static void netapiSharedMemoryFree(uint8_t* ptr, uint32_t size);
 static int system_init(NETAPI_HANDLE_T *);
-static void get_presets(PRESET_T * p_preset);
 static void netapi_cleanup_at_start(void);
 
 
@@ -100,10 +93,14 @@ NETAPI_GLOBAL_T * netapi_get_global(){ return &netapi_global;}
 Pktlib_HeapIfTable *netapi_getPktlibIfTable(void) {return &netapi_pktlib_ifTable;}
 
 //zap a queue
-void netapi_zapQ(int queueNum);
-/*-------------------------------------
- *  initialize NETAPI instance 
- *-------------------------------------*/
+void netapi_zapQ(int queueNum);\
+
+
+/********************************************************************
+* FUNCTION PURPOSE:  API instantiates the NETAPI and allocated global resources.
+ ********************************************************************
+ * DESCRIPTION:  API instantiates the NETAPI and allocated global resources.
+ ********************************************************************/
 NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
 {
     int i;
@@ -115,7 +112,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
     p->master = master;
 
     /* create space for our local pktios */
-    for(i=0;i<NETAPI_MAX_PKTIO; i++)
+    for(i=0;i<TUNE_NETAPI_MAX_PKTIO; i++)
     {
         p->pktios[i] = calloc(1,sizeof(PKTIO_HANDLE_T));
         if (!p->pktios[i])
@@ -141,7 +138,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
         {
             memcpy(&netapi_global.cfg,&netapi_default_cfg, sizeof(NETAPI_CFG_T));
         }
-        for(i=0;i<NETAPI_MAX_PKTIO;i++) 
+        for(i=0;i<TUNE_NETAPI_MAX_PKTIO;i++) 
         {
             netapi_global.pktios[i].qn.qNum=-1;
             netapi_global.pktios[i].name[0]='\0';
@@ -177,7 +174,7 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
     {
         //dalmt ->simple trial.  Just copy master's packetio list for now
         p->n_pktios = p_master->n_pktios;
-        memcpy(&p->pktios[0],&p_master->pktios[0],NETAPI_MAX_PKTIO*sizeof(PKTIO_HANDLE_T));
+        memcpy(&p->pktios[0],&p_master->pktios[0],TUNE_NETAPI_MAX_PKTIO*sizeof(PKTIO_HANDLE_T));
         p->nwal_local=p_master->nwal_local;
     }
     /* this is the NETAPI_CORE_MASTER case */
@@ -201,53 +198,75 @@ NETAPI_T netapi_init(int master, NETAPI_CFG_T * p_cfg)
         printf("netapi_init: no master specified\n");
         return -1;
     }
-//#endif
+
     return (NETAPI_T) p;
 }
 
-/*-------------------------------
- * Shut down netapi instance
- *-------------------------------*/
+/********************************************************************
+* FUNCTION PURPOSE:  API de-allocates all global resources allocated as part 
+*                                   of ref netapi_init
+ ********************************************************************
+ * DESCRIPTION:   API de-allocates all global resources allocated as part 
+*                                   of ref netapi_init
+ ********************************************************************/
 void netapi_shutdown(NETAPI_T h)
 {
-       int i;
-       NETAPI_HANDLE_T * p = (NETAPI_HANDLE_T *) h;
-       if (!p) return;
+    int i;
+    NETAPI_HANDLE_T * p = (NETAPI_HANDLE_T *) h;
+    if (!p) return;
 
-        printf(">netapi: WARNING shutdown may not be fully implemented\n");
-       if (p->master ==NETAPI_SYS_MASTER)
+    printf(">netapi: WARNING shutdown may not be fully implemented\n");
+    if (p->master ==NETAPI_SYS_MASTER)
+    {
+        /* close nwal */
+        nwal_delete(netapi_global.nwal_context.nwalInstHandle);
+
+        /* close heaps */
+        netapi_closeHeap(h, p->netcp_heap);
+        netapi_closeHeap(h, p->netcp_control_rx_heap);
+        netapi_closeHeap(h, p->netcp_control_tx_heap);
+        netapi_closeHeap(h, netapi_get_global()->nwal_context.pa2sa_heap); 
+        netapi_closeHeap(h, netapi_get_global()->nwal_context.sa2pa_heap); 
+
+        //loop over registered heaps
+        for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
         {
-           /* close nwal */
-           nwal_delete(netapi_global.nwal_context.nwalInstHandle);
-
-           /* close heaps */
-           netapi_closeHeap(h, p->netcp_heap);
-           netapi_closeHeap(h, p->netcp_control_rx_heap);
-           netapi_closeHeap(h, p->netcp_control_tx_heap);
-           netapi_closeHeap(h, netapi_get_global()->nwal_context.pa2sa_heap); 
-           netapi_closeHeap(h, netapi_get_global()->nwal_context.sa2pa_heap); 
-           //loop over registered heaps
-           for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
-           {
-                if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}
-           }
-           netapi_cleanup_at_start();  //clear 1st 50 not-specified queues..
-           hplib_vmTeardown();
-        } 
-       free(p);
-        return;
+            if (p->createdHeaps[i])  {netapi_closeHeap(h,p->createdHeaps[i]);p->createdHeaps[i]=NULL;}
+        }
+        netapi_cleanup_at_start();  //clear 1st 50 not-specified queues..
+        hplib_vmTeardown();
+    }
+    free(p);
+    return;
 }
 
-//exception crash
+
+/********************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function to gracefully cleanup when startup
+*                                  issue occurs.
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function to gracefully cleanup when startup
+*                                  issue occurs.
+ ********************************************************************/
 void netapi_err_teardown() { netapi_cleanup_at_start(); exit(-99); }
 
-/*-------------------utilities-------------------*/
+
+/***************************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function for virtual memory allocation.
+ ***************************************************************************
+ * DESCRIPTION:  NETAPI internal function for virtual memory allocation.
+ **************************************************************************/
+
 static uint8_t* netapiSharedMemoryMalloc(uint32_t size)
 {
 return  (uint8_t *)hplib_vmMemAlloc(size +netapi_global.cfg.def_heap_extra_size , 128, 0); 
 }
 
+/********************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function for virtual memory free.
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function for virtual memory free.
+ ********************************************************************/
 static void netapiSharedMemoryFree(uint8_t* ptr, uint32_t size)
 {
     /* Do Nothing. */
@@ -255,7 +274,11 @@ static void netapiSharedMemoryFree(uint8_t* ptr, uint32_t size)
     return;
 }
 
-// initialization
+/********************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function system initialization
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function system initialization
+ ********************************************************************/
 static int system_init(NETAPI_HANDLE_T * handle) 
 {
     int32_t             result;
@@ -291,7 +314,7 @@ static int system_init(NETAPI_HANDLE_T * handle)
     result = hplib_vmInit(&netapi_VM_VirtAddr[0], 2, &netapi_VM_MempoolAttr[0]);
     /* TODO: at this point, we need to create the QM regions which need to moved out of the above 
     netapi_VM_memory_setup() call, also need to move out the SA context stuff */
-       
+
     if (result == hplib_OK) printf(">netapi: system init - memory set  up OK\n");
     else {printf(">netap: system init - memory set up failed\n"); return -1;}
 
@@ -301,15 +324,12 @@ static int system_init(NETAPI_HANDLE_T * handle)
 /* allocate 2x number of tunnels since we need one for inflow and one for data mode */
     netapi_VM_SaContextVaddr = hplib_vmMemAlloc((TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2 *
                                         SEC_CONTEXT_SZ), 128, 0);
-   if (!netapi_VM_SaContextVaddr)
+    if (!netapi_VM_SaContextVaddr)
     {
         printf(">netapi ERROR: Failed to map SA context memory region\n");
         return (-1);
     }
     printf(">hplib VM_SaContext: Memory mapped/allocated at address %p.\n", netapi_VM_SaContextVaddr);
-//    *netapi_VM_SaContextVaddr = 'x';
-//    printf(" system Init: value being read  %c\n", netapi_VM_SaContextVaddr);
-//    *netapi_VM_SaContextVaddr = 0;
 
 #else
    netapi_VM_SaContextVaddr= (char *) NULL;
@@ -464,67 +484,74 @@ printf(">system_init: returned from netapi_qm_setup_mem_region\n");
                                &netapi_global.nwal_context);
     if (result<0) {printf("netapi start_nwal() failed\n"); return -1; }
     printf("system_init: returned from netapi_start_nwal\n");
-    //** success **
-
-
     return 0;
-
-}
-
-
-/*---------------
- * get presets()
- *---------------*/
-static void get_presets(PRESET_T * p_preset)
-{
- /* read from kernel or overall config area */
- /* for now hard code what kernel did */
 }
 
-
 /*************************************************************
  ******************MISC INTERNAL******************************
 **************************************************************/
-/* poll the garbage queues of all registered heaps */
+
+/***********************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function to poll the internal heaps
+*                                   and any application created heaps that have been registered
+*                                   with NETAPI instance.
+************************************************************************
+* DESCRIPTION:    The poll function checks the garbage collection queue associated 
+*                 with the heap and returnsdescriptors and buffers when appropriate 
+*                 to the main free queue.
+***********************************************************************/
 void netapi_pollHeapGarbage(NETAPI_T h)
 {
-int i;
-       NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
-        Pktlib_garbageCollection(n->netcp_heap);
-        //no need to do garbage collection on other internal heaps
-       for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
-       {
-               if (n->createdHeaps[i]) Pktlib_garbageCollection(n->createdHeaps[i]);
-       }
+    int i;
+    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
+    Pktlib_garbageCollection(n->netcp_heap);
+    //no need to do garbage collection on other internal heaps
+    for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
+    {
+        if (n->createdHeaps[i])
+        {
+            Pktlib_garbageCollection(n->createdHeaps[i]);
+        }
+    }
 }
 
-/* poll NETCP control queue for responses */
+/****************************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function which poll NETCP control queue
+*                    for responses
+****************************************************************************
+* DESCRIPTION:  NETAPI internal function which poll NETCP control queue 
+*                    for responses
+***************************************************************************/
 void netapi_netcpPoll(NETAPI_T  p)
 {
-       NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) p;
-        nwal_pollCtl( ((NETAPI_GLOBAL_T *) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
+    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) p;
+    nwal_pollCtl( ((NETAPI_GLOBAL_T *) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
 }
 
 /****************************************************************
  *****************Cleanup Functions******************************
 *****************************************************************/
 
-//clean up function for linux user space
+/****************************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function which performs clean for linux user space
+ ****************************************************************************
+ * DESCRIPTION:  NETAPI internal function which performs clean for linux user space
+ ***************************************************************************/
 void netapi_zapQ(int queueNum)
 {
-char * descPtr;
-int i;
-if (!queueNum) return;
-for (i=0;;i+=1 )
+    char * descPtr;
+    int i;
+    if (!queueNum) return;
+    for (i=0;;i+=1 )
+    {
+        /* Pop descriptor from source queue */
+        if ((descPtr = (char *)pktio_mQmssQueuePopRaw(queueNum)) == NULL)
         {
-                /* Pop descriptor from source queue */
-                if ((descPtr = (char *)PKTIO_QMSS_QUEUE_POP_RAW  (queueNum)) == NULL)
-                {
-                        break;
-                }
-                else {/*printf("netapi qzap in play\n");*/}
+        break;
         }
-        if(i) printf(">netapi: @recovery -  %d descriptors cleaned from qn %d\n",i, queueNum);
+        else {/*printf("netapi qzap in play\n");*/}
+    }
+    if(i) printf(">netapi: @recovery -  %d descriptors cleaned from qn %d\n",i, queueNum);
 }
 
 //defensive: clean out stuff hanging around
@@ -551,37 +578,18 @@ for(i=0;i<NQUEUES2CLEAR;i++)
 
 }
 
-/********************************
- *  clean up a  pktlib heap
- ***********************************/
-int netapi_closeHeap(NETAPI_T h, Pktlib_HeapHandle p)
-{
-Qmss_QueueHnd q;
-Pktlib_garbageCollection(p);  
-q = Pktlib_getZeroHeapQueue(p);
-netapi_zapQ(q);
-q= Pktlib_getInternalHeapQueue(p);
-netapi_zapQ(q);
-}
-
-
-
-
-
-netapi_getBufMemRemainder(void)
-{
-    hplib_vmGetMemPoolRemainder(0);
-}
-
-
-
+/****************************************************************************
+* FUNCTION PURPOSE:  NETAPI internal function to display internal heap stats.
+ ****************************************************************************
+ * DESCRIPTION:  NETAPI internal function to display internal heap stats.
+ ***************************************************************************/
 void netapi_dump_internal_heap_stats(void)
 {
-Pktlib_HeapStats    pktLibHeapStats;
-Pktlib_getHeapStats(netapi_get_global()->nwal_context.pa2sa_heap,&pktLibHeapStats);
-printf("PA2SA(ingress) stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
+    Pktlib_HeapStats    pktLibHeapStats;
+    Pktlib_getHeapStats(netapi_get_global()->nwal_context.pa2sa_heap,&pktLibHeapStats);
+    printf("PA2SA(ingress) stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
-printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
+    printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
 #if 0
@@ -592,10 +600,10 @@ printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufT
                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
 #endif
-Pktlib_getHeapStats(netapi_get_global()->nwal_context.sa2pa_heap,&pktLibHeapStats);
-printf("SA2PA stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
+    Pktlib_getHeapStats(netapi_get_global()->nwal_context.sa2pa_heap,&pktLibHeapStats);
+    printf("SA2PA stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
-printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
+    printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
 
index b59ea2abe17272997118b8578f202705e20636a3..fbd50791313cf4ce37bce21cc5930844bb0775ac 100755 (executable)
@@ -97,57 +97,63 @@ uint8_t *cppiMemRxCtlLinkBuf = NULL;
 uint8_t *cppiMemTxCtlLinkBuf = NULL;
 
 
-//****************************************************
-// Set up  QM memory region (per SOC)
-//***************************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI function to setup the QM memory region
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAPI function to setup the QM memory region,
+ *               once 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;
-
-  if(memRegion == NETAPI_GLOBAL_REGION)
-  {
-      memInfo.startIndex = TUNE_NETAPI_QM_START_INDEX;  //was 0
-      netapi_qm_region_index += numDesc;
-  }else if(memRegion ==NETAPI_LOCAL_REGION)
-  {
-      /* 2nd region for descriptors (perhaps private?) */
-      memInfo.startIndex     = netapi_qm_region_index;
-  }
-  else
-  {
-      return -1 ;
-  }
-
-  memset (pDescMemBase, 0, (descSize * numDesc));
-
-  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;
+    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;
+
+    if(memRegion == NETAPI_GLOBAL_REGION)
+    {
+        memInfo.startIndex = TUNE_NETAPI_QM_START_INDEX;  //was 0
+        netapi_qm_region_index += numDesc;
+    }else if(memRegion ==NETAPI_LOCAL_REGION)
+    {
+        /* 2nd region for descriptors (perhaps private?) */
+        memInfo.startIndex     = netapi_qm_region_index;
+    }
+    else
+    {
+        return -1 ;
+    }
+
+    memset (pDescMemBase, 0, (descSize * numDesc));
+
+    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)
-//***************************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI function to start QM
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAPI function to start QM
+ *               once per thread/core
+ ********************************************************************/
 int netapi_start_qm(void)
 {
      int32_t          result;
@@ -160,9 +166,7 @@ int netapi_start_qm(void)
      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);
@@ -213,15 +217,16 @@ uint8_t saContext[NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_M
 #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*2]ALIGN(CACHE_LINESZ);
 
-
-/*******************************************
- * Initialize the nwal subsystem for NETAPI use
- ***********************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI function to initialize NWAL subsystem
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAPI function to initialize NWAL subsytem
+ ********************************************************************/
 int netapi_init_nwal(
-     int region2use,  
-     Pktlib_HeapIfTable * p_table,
-     NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context, 
-     NETAPI_CFG_T*p_cfg )
+    int region2use,
+    Pktlib_HeapIfTable * p_table,
+    NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context, 
+    NETAPI_CFG_T*p_cfg )
 {
     nwalSizeInfo_t  nwalSizeInfo;
     nwal_RetValue   nwalRetVal;
@@ -411,9 +416,11 @@ int netapi_init_nwal(
     return 1;
 }
 
-//*************************************************
-//* Local (per thread/core) nwal initialization0
-//**************************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI function to start  NWAL 
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAPI function to start NWAL, per thread/core
+ ********************************************************************/
 int netapi_start_nwal(Pktlib_HeapHandle pkt_heap,
                       Pktlib_HeapHandle cmd_rx_heap,
                       Pktlib_HeapHandle cmd_tx_heap,
@@ -485,9 +492,11 @@ int netapi_start_nwal(Pktlib_HeapHandle pkt_heap,
 
 
 }
-//***************************************************
-// intialize timer
-//***************************************************
+/***********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI function to initialize the 64 bit timer.
+ ***********************************************************************
+ * DESCRIPTION:  Internal NETAPI function to initialize the 64 bit timer. for tci6614 ONLY
+ **********************************************************************/
 int netapi_init_timer(void)
 {
 #ifdef CORTEX_A8
index 1f1ed605de47a2e48d3a8a551df77911e96e1f6f..c728b5515aca3f68d225c39b30aaaaa74f907346 100755 (executable)
@@ -5,10 +5,12 @@
 
 #ifndef __NETAPI_LOC__H
 #define __NETAPI_LOC__H
-/***************************************
-* INTERNAL HANDLE STRUCTURE DEFINITION
-****************************************/
 
+#include "ti/runtime/netapi/netapi.h"
+
+
+extern hplib_virtualAddrInfo_T netapi_VM_VirtAddr[HPLIB_MAX_MEM_POOLS];
+extern unsigned char *netapi_VM_SaContextVaddr;
 /***********************************************
  *  GLOBAL AREA
  *   short term:  this is global to process
@@ -177,6 +179,7 @@ NETAPI_T p_master;  //DALMT save p'masters handle
 } NETAPI_GLOBAL_T;
 
 
+#if 1
 /************************************
  * this is a per thread structure.
  * It contains stuff local to thread
@@ -213,6 +216,7 @@ typedef struct NETAPI_HANDLE_Tag
     void * cookie;  /*set by calling thread */
 } NETAPI_HANDLE_T;
 
+#endif
 
 //internal initialization routines */
 int netapi_init_qm(int max_descriptors);
@@ -359,6 +363,8 @@ NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
 return ((NETAPI_GLOBAL_T *)(pp->global))->nwal_context.nwalInstHandle;
 }
 
+
+
 //utility to clear out a queue
 void netapi_zapQ(int queueNum);
 void netcp_cfgp_build_route(NETCP_CFG_ROUTE_T * p_route, int16_t * p_flow,  Qmss_QueueHnd * p_q);
index cc5c657f8fc432f0fda7065a9f5018effbefec63..db993fb676bfd924450257b6c60a676e8fe1f9da 100755 (executable)
 #define NO_TIMER  //turn off timer related scheduling
 #define NO_GARBAGE  //turn off garbage collection
 
-void netapi_sched_get_stats(NETAPI_SCHED_HANDLE_T *s, 
+
+/********************************************************************
+ * FUNCTION PURPOSE:  API to get  scheduling context statistics
+ ********************************************************************
+ * DESCRIPTION:  API to get  scheduling context statistics
+ ********************************************************************/
+void netapi_schedGetStats(NETAPI_SCHED_HANDLE_T *s, 
     unsigned long long * p_pkts, 
     unsigned long long * p_cycles,
     unsigned long long * p_cache_cycles)
 {
-   *p_pkts= s->num_pkts;
-   *p_cycles= s->busy_cycles;
-   *p_cache_cycles= s->cache_cycles;
+   *p_pkts= s->stats.num_pkts;
+   *p_cycles= s->stats.busy_cycles;
+   *p_cache_cycles= s->stats.cache_cycles;
    return;
 }
 /****************************************/
 /************API************************/
 /**************************************/
 
-/* open a scheduling contex */
+/********************************************************************
+ * FUNCTION PURPOSE:  API to open a scheduling context
+ ********************************************************************
+ * DESCRIPTION:  API to open a scheduling context
+ ********************************************************************/
 NETAPI_SCHED_HANDLE_T * netapi_schedOpen(NETAPI_T n, NETAPI_SCHED_CONFIG_T * p_config, int *p_err)
 {
   *p_err=0;
@@ -89,89 +99,103 @@ NETAPI_SCHED_HANDLE_T * netapi_schedOpen(NETAPI_T n, NETAPI_SCHED_CONFIG_T * p_c
 
 }
 
+/********************************************************************
+ * FUNCTION PURPOSE:  API to re-configure a scheduling context, FUTURE, 
+ *                                  not implemented
+ ********************************************************************
+ * DESCRIPTION:  API to re-configure a scheduling context, FUTURE, 
+ *                                  not implemented
+ ********************************************************************/
 /* 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;
+    /* not implemented */
+    return 0;
 }
 
-
+/********************************************************************
+ * FUNCTION PURPOSE:  API for main entry point to scheduler
+ ********************************************************************
+ * DESCRIPTION:  API to get NETAPI scheduling context statistics
+ ********************************************************************/
 /* main entry point.  caller gives up control to scheduler */
-int netapi_schedWaitForEvents(NETAPI_SCHED_HANDLE_T *s, int *p_err)
+int netapi_schedRun(NETAPI_SCHED_HANDLE_T *s, int *p_err)
 {
-  int err;
-  *p_err=0;
-  unsigned long long t =  hplib_mUtilGetTimestamp();
-  int next_house;
-  volatile int pkts;
-  volatile unsigned long t1;
-  volatile unsigned long t2;
-  volatile unsigned long long cache_op_b2;
-  volatile unsigned long long n_c_ops;
-
-  next_house =  s->config.interval;
-  /* loop for duration or until shutdown */
-  for(;t< s->shutdown_time;)
-  {
+    int err;
+    *p_err=0;
+    unsigned long long t =  hplib_mUtilGetTimestamp();
+    int next_house;
+    volatile int pkts;
+    volatile unsigned long t1;
+    volatile unsigned long t2;
+    volatile unsigned long long cache_op_b2;
+    volatile unsigned long long n_c_ops;
+
+    next_house =  s->config.interval;
+    /* loop for duration or until shutdown */
+    for(;t< s->shutdown_time;)
+    {
 #ifndef NO_TIMER
-    t = hplib_mUtilGetTimestamp();
+        t = hplib_mUtilGetTimestamp();
 #endif
-    next_house -=1;
-    //poll all  pktio channels we have open in RX mode 
-     //Osal_cache_op_measure_reset();
-     cache_op_b2= Osal_cache_op_measure(&n_c_ops);
-     t1=hplib_mUtilGetPmuCCNT();
-     pkts=pktio_pollAll((NETAPI_T) s->back, NULL, &err);
-     if (!pkts  && (s->config.yield == TRUE))
-     {
-        sched_yield();
-     }
-     t2=hplib_mUtilGetPmuCCNT();
-     if (pkts)
-     {
-        s->num_pkts+= (unsigned long long) pkts;
-        s->busy_cycles += (unsigned long long) (t2-t1);
-        cache_op_b2=  Osal_cache_op_measure(&n_c_ops)- cache_op_b2;
-        s->cache_cycles += (unsigned long long) cache_op_b2;
-     }
+        next_house -=1;
+        //poll all  pktio channels we have open in RX mode 
+        //Osal_cache_op_measure_reset();
+         cache_op_b2= Osal_cache_op_measure(&n_c_ops);
+         t1=hplib_mUtilGetPmuCCNT();
+         pkts=pktio_pollAll((NETAPI_T) s->back, NULL, &err);
+         if (!pkts  && (s->config.yield == TRUE))
+         {
+            sched_yield();
+         }
+         t2=hplib_mUtilGetPmuCCNT();
+         if (pkts)
+         {
+            s->stats.num_pkts+= (unsigned long long) pkts;
+            s->stats.busy_cycles += (unsigned long long) (t2-t1);
+            cache_op_b2=  Osal_cache_op_measure(&n_c_ops)- cache_op_b2;
+            s->stats.cache_cycles += (unsigned long long) cache_op_b2;
+         }
 
 #ifndef NO_GARBAGE
-    //poll pktlib garbage collections for registered heaps..
-    if (TRUE== s->config.pollGarbageQ)
-    {
-        netapi_pollHeapGarbage((NETAPI_T) s->back);
-     }
+        //poll pktlib garbage collections for registered heaps..
+        if (TRUE== s->config.pollGarbageQ)
+        {
+            netapi_pollHeapGarbage((NETAPI_T) s->back);
+        }
 #endif    
 
-#ifndef NO_TIMER
-    //todo timers (local and global)
-    hplib_TimerPollAllGroups((NETAPI_T) s->back, HPLIB_TIMER_FITLER_ALL, 100000);
-#endif
-    //poll NETCP/PA control channels 
-    if (TRUE== s->config.pollGarbageQ)
-    {
-        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)
+        //poll NETCP/PA control channels 
+        if (TRUE== s->config.pollGarbageQ)
+        {
+            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;
+            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_OPEN) 
+        {
+            s->state=NETAPI_SCHED_STATE_CLOSE;
+            break;
         }
-    //see if we were closed and/or its time to close
-    if (s->state!= NETAPI_SCHED_STATE_OPEN) 
-         { s->state=NETAPI_SCHED_STATE_CLOSE; break;}
-   
-  }
-  return 1;
-}
 
+    }
+    return 1;
+}
+/********************************************************************
+ * FUNCTION PURPOSE:  API to close a scheduling context
+ ********************************************************************
+ * DESCRIPTION:  API to close a scheduling context
+ ********************************************************************/
 /* shutdown scheduler context */
-int netapi_schedShutdown(NETAPI_SCHED_HANDLE_T * s, NETAPI_SCHED_SHUTDOWN_T * p_close, int * p_err)
+int netapi_schedClose(NETAPI_SCHED_HANDLE_T * s, NETAPI_SCHED_SHUTDOWN_T * p_close, int * p_err)
 {
   *p_err=0;
   s->state=NETAPI_SCHED_STATE_CLOSE_IN_PROGRESS;  //say we are closing
index c43d68584bc2ab7821a0dd75c7d7b96c7ea6fe36..a04db91a100513d36dae6fcd7779260ec9b66ff6 100755 (executable)
 #include "netapi_loc.h"
 
 
-//add a RX Security Association 
+/********************************************************************
+ * FUNCTION PURPOSE:  API to add an IPSEC SA
+ ********************************************************************
+ * DESCRIPTION:  API to add an IPSEC SA
+ ********************************************************************/
 NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
                                 int iface_no, //inteface to attach to
                                 NETAPI_SEC_SA_INFO_T *sa_info   ,//info on the SA
@@ -92,7 +96,7 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
         /* nwalSaIpSecKeyParams_t */
         {0}
     };
-   void * mac_handle = netcp_cfgp_get_mac_handle(&netapi_get_global()->nwal_context,iface_no);
+    void * mac_handle = netcp_cfgp_get_mac_handle(&netapi_get_global()->nwal_context,iface_no);
     int  coreid = Osal_nwalGetProcId();
     *perr =0;
     if ((!n) || (!sa_info)  ||  (!p_data_mode_handle) ) {*perr = NETAPI_ERR_BAD_INPUT; return -1;}
@@ -137,7 +141,9 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
         createParam.saIpSecParam.cipherMode = sa_info->cipherMode;
         createParam.saIpSecParam.esnLo = sa_info->esnLo;
         createParam.saIpSecParam.esnHi = sa_info->esnHi;
-        if ((sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
+        if ((sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
+            (sa_info->cipherMode == NWAL_SA_EALG_AES_CCM) ||
+            (sa_info->authMode == NWAL_SA_AALG_GMAC))
         {
             createParam.saIpSecParam.macSize = 16;
         }
@@ -155,7 +161,7 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
             netcp_cfgp_build_route(route,&createParam.saIpSecParam.appRxPktFlowId, 
                                          &createParam.saIpSecParam.appRxPktQueue);
         }
-        
+
         //fire off config message
         retValue = nwal_setSecAssoc (((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
                                         trans_id,
@@ -165,7 +171,7 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
                                         &pTransInfo->handle);
         if(retValue == nwal_TRANS_COMPLETE)
         {
-           have_to_wait=0;
+            have_to_wait=0;
         }
         else if(retValue !=  nwal_OK)
         {
@@ -177,13 +183,11 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
             return -1;
         }
 
-
         //wait here until its done since scheduler isn't running yet most likely..
         // todo:  make this handled by scheduler poll later ??
         if((trans_id != NWAL_TRANSID_SPIN_WAIT)&&(have_to_wait))
         {
             n->nwal_local.numPendingCfg++;
-            
             while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
                     (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_OPEN))
             {
@@ -198,7 +202,6 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
                 *perr = NETAPI_ERR_PA_FW;
                 printf (">netapi_sec - ERROR returned by NETCP PA firmware %d\n",
                         *perr);
-                
                 netcp_cfgp_delete_sa(&netapi_get_global()->nwal_context,tunnelId);
                 return -1;
             }
@@ -222,7 +225,9 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
         dmSaParam.dmSaParam.macSize=12;        /**todo: pass in or deduce */
         dmSaParam.dmSaParam.aadSize=0;        /**todo: pass in or deduce */
         dmSaParam.dmSaParam.enc1st =  (sa_info->dir ==NWAL_SA_DIR_OUTBOUND) ? nwal_TRUE : nwal_FALSE;  //encypt 1st for outbound
-        if ((sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
+        if ((sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
+            (sa_info->cipherMode == NWAL_SA_EALG_AES_CCM) ||
+            (sa_info->authMode == NWAL_SA_AALG_GMAC))
         {
             dmSaParam.dmSaParam.macSize = 16;
             dmSaParam.dmSaParam.aadSize=8;
@@ -256,7 +261,6 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
         printf("netapi_secAddSA: Creating sideband mode SA for %d ( mac %d)\n", tunnelId, iface_no); 
         *p_data_mode_handle = dm_handle;
     }
-    //save stuff
 
     netcp_cfgp_insert_sa(&netapi_get_global()->nwal_context,
                            tunnelId,
@@ -268,15 +272,24 @@ NETCP_CFG_SA_T netapi_secAddSA(NETAPI_T h, //the  netapi handle
     return  (appId);
 }
 
-//enable or disable inflow mode
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal function  to dynamically switch between inflow
+ *                                  and sideband mode
+ ********************************************************************
+ * DESCRIPTION:  Internal function  to dynamically switch between inflow
+ *                                  and sideband mode
+ ********************************************************************/
 void netapi_secInflowMode(int iface, NETCP_CFG_SA_T sa,  int on)
 {
   /*todo */   /* FUTURE */
   printf(">netapi_sec:  dynamic switch between inflow and sideband is not functional yet\n");
 }
 
-//delete the SA
-//(internal version)
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal function  to delete an IPSEC SA
+ ********************************************************************
+ * DESCRIPTION:  Internal function to delete an IPSEC SA
+ ********************************************************************/
 static void netapi_secDelSA_internal(NETAPI_T h,int iface_no, NETCP_CFG_SA_T  sa_app_id, int flags, int *perr)
 {
     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
@@ -369,15 +382,22 @@ static void netapi_secDelSA_internal(NETAPI_T h,int iface_no, NETCP_CFG_SA_T  sa
         netcp_cfgp_delete_sa(&netapi_get_global()->nwal_context, tunnelId);
 }
 
+/********************************************************************
+ * FUNCTION PURPOSE:  API to delete an IPSEC SA
+ ********************************************************************
+ * DESCRIPTION:  API to delete an IPSEC SA
+ ********************************************************************/
 void netapi_secDelSA(NETAPI_T h,int iface_no, NETCP_CFG_SA_T  sa_app_id,  int *perr)
 {
     netapi_secDelSA_internal( h, iface_no,  sa_app_id, 0x00, perr);
 }
 
 
-//******************************************
-// Add Policy
-//******************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  API to add a recieve security policy
+ ********************************************************************
+ * DESCRIPTION:  API to add a recieve security policy
+ ********************************************************************/
 NETCP_CFG_IPSEC_POLICY_T netapi_secAddRxPolicy(NETAPI_T h, //the  netapi handle
                                 NETCP_CFG_SA_T sa,  //tunnel to attach to
                                nwal_IpType ipType,     //V4 or V6
@@ -455,7 +475,6 @@ NETCP_CFG_IPSEC_POLICY_T netapi_secAddRxPolicy(NETAPI_T h, //the  netapi handle
 
     //fire off config message
 
-
     retValue = nwal_setSecPolicy (((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
                                   trans_id,
                                   (nwal_AppId) appId,
@@ -506,9 +525,11 @@ NETCP_CFG_IPSEC_POLICY_T netapi_secAddRxPolicy(NETAPI_T h, //the  netapi handle
     return  (appId);
 }
 
-//************************
-//Delete Policy  (internal)
-//***********************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal function to delete a recieve security policy
+ ********************************************************************
+ * DESCRIPTION:  Internal function to delete a recieve security policy
+ ********************************************************************/
 static void netapi_secDelRxPolicy_internal(NETAPI_T h, NETCP_CFG_IPSEC_POLICY_T policy_app_id, int flags, int *perr)
 {
     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
@@ -579,16 +600,21 @@ static void netapi_secDelRxPolicy_internal(NETAPI_T h, NETCP_CFG_IPSEC_POLICY_T
     if (!flags) netcp_cfgp_delete_policy(&netapi_get_global()->nwal_context, policyId);
 }
 
-//************************
-//Delete Policy  
-//***********************
+/********************************************************************
+ * FUNCTION PURPOSE:  API to delete a recieve security policy
+ ********************************************************************
+ * DESCRIPTION:  API to delete a recieve security policy
+ ********************************************************************/
 void netapi_secDelRxPolicy(NETAPI_T h, NETCP_CFG_IPSEC_POLICY_T policy_app_id, int *perr)
 {
     netapi_secDelRxPolicy_internal(h,  policy_app_id, 0, perr);
 }
 
-
-
+/********************************************************************
+ * FUNCTION PURPOSE:  API to retrieve SA statistics via NWAL
+ ********************************************************************
+ * DESCRIPTION:  API to retrieve SA statistics via NWAL
+ ********************************************************************/
 void  netapi_getSaStats (NETAPI_T               h, 
                          NETCP_CFG_SA_T         handle,
                          NETAPI_SA_STATS_T*     pSaStats)
@@ -603,17 +629,15 @@ void  netapi_getSaStats (NETAPI_T               h,
                                           tunnelId, &handle_sideband);
     if(handle_inflow)
     {
-        //printf("netapi_getSaStats(): handle inflow valid\n");
         nwal_getSecAssocStats(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle, 
                                                 handle_inflow, &(pSaStats->saIpsecStats));
         pSaStats->validParams |= NETAPI_IPSEC_STAT_VALID;
     }
     if(handle_sideband)
     {
-        //printf("netapi_getSaStats(): handle sideband valid\n");
         nwal_getDataModeStats(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle, 
                                                 handle_sideband, &(pSaStats->dataModeStats));
-         pSaStats->validParams |= NETAPI_SIDEBAND_DATA_MODE_STAT_VALID;
+        pSaStats->validParams |= NETAPI_SIDEBAND_DATA_MODE_STAT_VALID;
     }
     
 }
index 6029673bd6b8c195f9773e6fe8d1e15c7da30100..df531c4e36dc9dd63c489a00937e7bc6cd71f4ea 100755 (executable)
 #include "netapi_loc.h"
 
 /******************************************************************
- ********************Utility*************************************
+ ********************Netapi internal*************************************
 *******************************************************************/
 static hplib_spinLock_T netcp_cfg_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
 
-//get a free transaction id
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to get a free transaction id
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to get a free transaction id.
+ ********************************************************************/
 NetapiNwalTransInfo_t *  netapip_GetFreeTransInfo(NETAPI_GLOBAL_T *p_global, nwal_TransID_t *pTransId)
 {
-         uint16_t    count=0;
+    uint16_t    count=0;
 
-       count=0;
-            hplib_mSpinLockLock(&netcp_cfg_lock);
-        while(count < TUNE_NETAPI_MAX_NUM_TRANS)
+    count=0;
+    hplib_mSpinLockLock(&netcp_cfg_lock);
+    while(count < TUNE_NETAPI_MAX_NUM_TRANS)
+    {
+        if((p_global->nwal_context.transInfos[count].inUse) != nwal_TRUE)
         {
-            if((p_global->nwal_context.transInfos[count].inUse) != nwal_TRUE)
-            {
-                p_global->nwal_context.transInfos[count].inUse = nwal_TRUE;
-                *pTransId = count;
-                        hplib_mSpinLockUnlock(&netcp_cfg_lock);
-                return(&p_global->nwal_context.transInfos[count]);
-            }
-            count++;
+            p_global->nwal_context.transInfos[count].inUse = nwal_TRUE;
+            *pTransId = count;
+            hplib_mSpinLockUnlock(&netcp_cfg_lock);
+            return(&p_global->nwal_context.transInfos[count]);
         }
-         hplib_mSpinLockUnlock(&netcp_cfg_lock);
-        /* trouble.  need to wait for one to free up*/
-        /* to do: handle this by forcing a poll of cntrl queue*/
-        printf(">netcp_cfg: trying to get free transaction slot but all full!!\n");
-                
-        return NULL;
+        count++;
+    }
+    hplib_mSpinLockUnlock(&netcp_cfg_lock);
+    /* trouble.  need to wait for one to free up*/
+    /* to do: handle this by forcing a poll of cntrl queue*/
+    printf(">netcp_cfg: trying to get free transaction slot but all full!!\n");
+    return NULL;
 
 }
 
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to free a transaction id
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to free a transaction id
+ ********************************************************************/
 void netapip_FreeTransInfo(NetapiNwalTransInfo_t *pTransInfo)
 {
     pTransInfo->inUse = nwal_FALSE;
     pTransInfo->state = NETAPI_NWAL_HANDLE_STATE_IDLE;
     pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_NONE;
 }
-//internal: build route
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to build a route
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to build a route
+ ********************************************************************/
 void netcp_cfgp_build_route(NETCP_CFG_ROUTE_T * p_route, int16_t * p_flow,  Qmss_QueueHnd * p_q)
 {
     if (!p_route) return;
@@ -95,69 +107,93 @@ void netcp_cfgp_build_route(NETCP_CFG_ROUTE_T * p_route, int16_t * p_flow,  Qmss
     if (p_route->p_dest_q) *p_q = pktio_get_q(p_route->p_dest_q);
     else *p_q=QMSS_PARAM_NOT_SPECIFIED;
 }
-/*-----------------------------------------------------------*/
-/*----------------database management stuff-------------------*/
-/*-----------------------------------------------------------*/
 
-/*=====================Policies=============================*/
-//internal: find a free slot for an SA 
+
+/******************************************************/
+/*----------------database management stuff           */
+/******************************************************/
+
+/*=====================POLICIES=============================*/
+
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a free slot for an SA
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to find a free slot for an SA
+ ********************************************************************/
 int netcp_cfgp_find_policy_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p, int tunnel)
 {
-   int i;
-   if ((tunnel <0 ) || (tunnel >=TUNE_NETAPI_MAX_SA)) return -1;
+    int i;
+    if ((tunnel <0 ) || (tunnel >=TUNE_NETAPI_MAX_SA))
+        return -1;
 
-        hplib_mSpinLockLock(&netcp_cfg_lock);
-         //find a free entry
-   for(i=0;i<TUNE_NETAPI_MAX_POLICY;i++)
-   {
-       if (!p->policy[i].in_use)
-       {
-           p->policy[i].in_use = 2; //pending
-           p->policy[i].tunnel= tunnel; //save tunnel this is linked to 
+    hplib_mSpinLockLock(&netcp_cfg_lock);
+    //find a free entry
+    for(i=0;i<TUNE_NETAPI_MAX_POLICY;i++)
+    {
+        if (!p->policy[i].in_use)
+        {
+            p->policy[i].in_use = 2; //pending
+            p->policy[i].tunnel= tunnel; //save tunnel this is linked to 
             hplib_mSpinLockUnlock(&netcp_cfg_lock);
-           return i;
-       }
-   }
-           hplib_mSpinLockUnlock(&netcp_cfg_lock);
-   return -1;
+            return i;
+        }
+    }
+    hplib_mSpinLockUnlock(&netcp_cfg_lock);
+    return -1;
 }
 
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to delete a policy from policy list
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to delete a policy from policy list
+ ********************************************************************/
 //internal: delete a policy from list 
 void netcp_cfgp_delete_policy(
          NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
          int policy_slot )
 {
-   if ((policy_slot <0 ) || (policy_slot >= TUNE_NETAPI_MAX_POLICY))
-   {
+    if ((policy_slot <0 ) || (policy_slot >= TUNE_NETAPI_MAX_POLICY))
+    {
         return ;
-   }
-   p->policy[policy_slot].in_use=0;
-   return;
+    }
+    p->policy[policy_slot].in_use=0;
+    return;
 }
 
-//internal:  insert an policy into the list  
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to insert a policy to the policy list
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to insert a policy to the policy list
+ ********************************************************************/
 void netcp_cfgp_insert_policy(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int policy_slot,  //we 'reserved it already'
                           void * handle)
 {
-        p->policy[policy_slot].in_use=1;
-        p->policy[policy_slot].nwal_handle = handle;
-        return;
+    p->policy[policy_slot].in_use=1;
+    p->policy[policy_slot].nwal_handle = handle;
+    return;
 }
 
-//internal: return nwal_handle for policy 
+/************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function which returns NWAL handle for a policy
+ ************************************************************************
+ * DESCRIPTION:  Netapi internal function which returns NWAL handle for a policy
+ ************************************************************************/
 void *netcp_cfgp_get_policy( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int policy_slot)
 {
-   if ((policy_slot <0 ) || (policy_slot >= TUNE_NETAPI_MAX_POLICY)) return NULL;
-   if (!p->policy[policy_slot].in_use) return NULL;
-   return p->policy[policy_slot].nwal_handle;
+    if ((policy_slot <0 ) || (policy_slot >= TUNE_NETAPI_MAX_POLICY))
+        return NULL;
+    if (!p->policy[policy_slot].in_use)
+        return NULL;
+    return p->policy[policy_slot].nwal_handle;
 }
 
-
-
-/*======================SAs==================================*/
-//internal: find a free slot for an SA 
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a free slot in SA list for a SA
+ ********************************************************************
+ * DESCRIPTION:  Netapi internal function to find a free slot in SA list for an SA
+ ********************************************************************/
 int netcp_cfgp_find_sa_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p, int iface)
 {                                    
    int i;
@@ -180,20 +216,29 @@ int netcp_cfgp_find_sa_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p, int iface)
    hplib_mSpinLockUnlock(&netcp_cfg_lock);
    return -1;
 }
- //internal: delete an SAr from list 
+
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to delete an SA from SA list
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to delete an SA from SA list 
+ ********************************************************************/
 void netcp_cfgp_delete_sa(
          NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
          int sa_slot )
 {
-   if ((sa_slot <0 ) || (sa_slot >= TUNE_NETAPI_MAX_SA))
-   {
+    if ((sa_slot <0 ) || (sa_slot >= TUNE_NETAPI_MAX_SA))
+    {
         return ;
-   }
-   p->tunnel[sa_slot].in_use=0;
-   return;
+    }
+    p->tunnel[sa_slot].in_use=0;
+    return;
 }
 
-//internal:  insert an SA into the list  
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to insert an SA to the SA list
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to insert an SA to the SA list 
+ ********************************************************************/
 void netcp_cfgp_insert_sa(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int sa_slot,  //we 'reserved it already'
                           int dir,
@@ -211,104 +256,137 @@ void netcp_cfgp_insert_sa(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
         return;
 }
 
-//internal: return nwal_handles for SA   
-void *netcp_cfgp_get_sa_handles( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to return NWAL handles for an SA
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to return NWAL handles for an SA
+ ********************************************************************/
+ void *netcp_cfgp_get_sa_handles( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int sa_slot, void ** p_sideband)
 {
-   if ((sa_slot <0 ) || (sa_slot >= TUNE_NETAPI_MAX_SA)) return NULL;
-   if (!p->tunnel[sa_slot].in_use) return NULL;
-   *p_sideband = p->tunnel[sa_slot].sa_handle_sideband;
-   return p->tunnel[sa_slot].sa_handle_inflow;
+    if ((sa_slot <0 ) || (sa_slot >= TUNE_NETAPI_MAX_SA))
+        return NULL;
+    if (!p->tunnel[sa_slot].in_use)
+        return NULL;
+    *p_sideband = p->tunnel[sa_slot].sa_handle_sideband;
+    return p->tunnel[sa_slot].sa_handle_inflow;
 }
 
 
-/*==============================fLOWS=============================*/
-//internal: find a free slot for a flow 
+/*==============================FLOWS=============================*/
+
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a free slot for a flow
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to find a free slot for a flow
+ ********************************************************************/
 static int netcp_cfgp_find_flow_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p)
 {
-   int i;
-         //find a free entry
-     hplib_mSpinLockLock(&netcp_cfg_lock);
-   for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)
-   {
-       if (!p->flows[i].in_use)
-       {
-           p->flows[i].in_use = 2; //pending
-           hplib_mSpinLockUnlock(&netcp_cfg_lock);
-           return i;
-       }
-   }
-   hplib_mSpinLockUnlock(&netcp_cfg_lock);
-   return -1;
+    int i;
+    //find a free entry
+    hplib_mSpinLockLock(&netcp_cfg_lock);
+    for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)
+    {
+        if (!p->flows[i].in_use)
+        {
+            p->flows[i].in_use = 2; //pending
+            hplib_mSpinLockUnlock(&netcp_cfg_lock);
+            return i;
+        }
+    }
+    hplib_mSpinLockUnlock(&netcp_cfg_lock);
+    return -1;
 }
 
-//internal: clear flow slot 
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find delete a flow from flow list
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to find delete a flow from flow list
+ ********************************************************************/
 static void netcp_cfgp_delete_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int slot)
 {
-   if ((slot >=0 ) && (slot < TUNE_NETAPI_MAX_FLOWS))
-   {
+    if ((slot >=0 ) && (slot < TUNE_NETAPI_MAX_FLOWS))
+    {
         p->flows[slot].in_use = 0;
-   }
+    }
 }
 
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to  insert a flow to the  flow list
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to  delete a flow from flow list
+ ********************************************************************/
 //internal:  insert a flow into flow slot
 static NETCP_CFG_FLOW_HANDLE_T netcp_cfgp_insert_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int slot,  //we 'reserved it already'
                           void * handle)  //cppi flow handle. Save this for delete
 {
-        p->flows[slot].in_use=1;
-        p->flows[slot].handle = handle;
-       p->flows[slot].flow.flowid  = Cppi_getFlowId(handle);
+    p->flows[slot].in_use=1;
+    p->flows[slot].handle = handle;
+    p->flows[slot].flow.flowid  = Cppi_getFlowId(handle);
         return (NETCP_CFG_FLOW_HANDLE_T) &p->flows[slot].flow;
 }
 
-//find entry matching the flowid.  return slot# and the cppi handle
+/********************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find entry matching the flowid
+ ********************************************************************
+ * DESCRIPTION: Netapi internal function to find entry matching the flowid. Returns
+ * the slot number and the cPPI handle.
+ ********************************************************************/
 static int netcp_cfgp_find_flow(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int flowid,  
                           void ** handle) 
 {
-int i;
-   *handle=NULL;
-     hplib_mSpinLockLock(&netcp_cfg_lock);
-   for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)
-   {
-       if ((p->flows[i].in_use)&&(p->flows[i].flow.flowid == flowid))
-       {
-           *handle = p->flows[i].handle;
-             hplib_mSpinLockUnlock(&netcp_cfg_lock);
-           return i;
-       }
-   }
+    int i;
+    *handle=NULL;
+    hplib_mSpinLockLock(&netcp_cfg_lock);
+    for(i=0;i<TUNE_NETAPI_MAX_FLOWS;i++)
+    {
+        if ((p->flows[i].in_use)&&(p->flows[i].flow.flowid == flowid))
+        {
+            *handle = p->flows[i].handle;
+            hplib_mSpinLockUnlock(&netcp_cfg_lock);
+            return i;
+        }
+    }
     hplib_mSpinLockUnlock(&netcp_cfg_lock);
    return -1;
 }
 
 
+
 /*============================IP ADDRESSES==========================*/
 
-//internal: find a free slot for IP rule 
+/***************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a free slot for IP rule in IP slot list 
+ ***************************************************************************
+ * DESCRIPTION: NNetapi internal function to find a free slot for IP rule in IP slot list
+ ***************************************************************************/
 static int netcp_cfgp_find_ip_slot(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int iface_no)
 {
-   int i;
+    int i;
 
-   //find a free entry
+    //find a free entry
     hplib_mSpinLockLock(&netcp_cfg_lock);
-   for(i=0;i<TUNE_NETAPI_MAX_NUM_IP;i++)
-   {
-       if (!p->ips[i].in_use)
-       {
-           p->ips[i].in_use = 2; //pending
+    for(i=0;i<TUNE_NETAPI_MAX_NUM_IP;i++)
+    {
+        if (!p->ips[i].in_use)
+        {
+            p->ips[i].in_use = 2; //pending
             hplib_mSpinLockUnlock(&netcp_cfg_lock);
-           return i;
-       }
-   }
+            return i;
+        }
+    }
     hplib_mSpinLockUnlock(&netcp_cfg_lock);
-   return -1;
+    return -1;
 }
 
-
-//internal:  insert an IP address into iface
+/***************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to insert an IP address into interface
+ ***************************************************************************
+ * DESCRIPTION: Netapi internal function to insert an IP address into interface
+ ***************************************************************************/
 static void netcp_cfgp_insert_ip(NETAPI_NWAL_GLOBAL_CONTEXT_T *p, 
                           nwal_IpType ipType,
                           nwalIpAddr_t *ip_addr, 
@@ -317,48 +395,63 @@ static void netcp_cfgp_insert_ip(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int ip_slot,  //we 'reserved it already'
                           void * handle)
 {
-        p->ips[ip_slot].in_use=1;
-        memcpy(&p->ips[ip_slot].ip_addr, ip_addr, sizeof(nwalIpAddr_t));
-        if(ip_qualifiers)
+     p->ips[ip_slot].in_use=1;
+    memcpy(&p->ips[ip_slot].ip_addr, ip_addr, sizeof(nwalIpAddr_t));
+    if(ip_qualifiers)
         memcpy(&p->ips[ip_slot].ip_qualifiers, ip_qualifiers, sizeof(nwalIpOpt_t));
-        else
+    else
         memset(&p->ips[ip_slot].ip_qualifiers, 0, sizeof(nwalIpOpt_t));
-        p->ips[ip_slot].ip_type = ipType;
-        p->ips[ip_slot].nwal_handle = handle;
-        return;
+    p->ips[ip_slot].ip_type = ipType;
+    p->ips[ip_slot].nwal_handle = handle;
 }
 
-
-//internal: free IP slot associated with ip address 
+/***************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to free IP slot associated with IP address
+ ***************************************************************************
+ * DESCRIPTION: Netapi internal function to free IP slot associated with IP address
+ ***************************************************************************/
 static void netcp_cfgp_delete_ip(
          NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
          int iface_no,
          int ip_slot )
 {
-   if ((ip_slot <0)||(ip_slot>TUNE_NETAPI_MAX_NUM_IP)) return ;
-   p->ips[ip_slot].in_use=0;
-   return;
+    if ((ip_slot >=0) &&(ip_slot <=TUNE_NETAPI_MAX_NUM_IP))
+    {
+        p->ips[ip_slot].in_use=0;
+    }
 }
 
-
-//internal: get IP handle associated with ip address 
+/***************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to get IP handle associated with IP address
+ ***************************************************************************
+ * DESCRIPTION: Netapi internal function to get IP handle associated with IP address
+ ***************************************************************************/
 static void *netcp_cfgp_get_ip_handle(
          NETAPI_NWAL_GLOBAL_CONTEXT_T *p, 
          int iface_no,
          int ip_slot )
 {
-   if ((ip_slot <0)||(ip_slot>=TUNE_NETAPI_MAX_NUM_IP)) return NULL;
-   if (!p->ips[ip_slot].in_use) return NULL;
-   return (void *) p->ips[ip_slot].nwal_handle;
+    if ((ip_slot <0)||(ip_slot>=TUNE_NETAPI_MAX_NUM_IP))
+        return NULL;
+    if (!p->ips[ip_slot].in_use)
+        return NULL;
+    return (void *) p->ips[ip_slot].nwal_handle;
 }
 
 /*==========================MAC INTERFACES======================*/
-//internal: insert interface info into global context
+
+
+
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to insert an interface to the interface list
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to insert an interface to the interface list
+ *******************************************************************************/
 static void netcp_cfgp_insert_mac(NETAPI_NWAL_GLOBAL_CONTEXT_T *p, unsigned char * p_mac,
                            int iface_no, int state, NETCP_CFG_VLAN_T vlan, void * handle)
 {
-   if ((iface_no >=0 ) && (iface_no < TUNE_NETAPI_MAX_NUM_MAC))
-   {
+    if ((iface_no >=0 ) && (iface_no < TUNE_NETAPI_MAX_NUM_MAC))
+    {
         memset(&p->interfaces[iface_no],0,sizeof(NETCP_INTERFACE_T));
         p->interfaces[iface_no].in_use = 1;
         memcpy(&p->interfaces[iface_no].mac[0], p_mac,6);
@@ -366,12 +459,17 @@ static void netcp_cfgp_insert_mac(NETAPI_NWAL_GLOBAL_CONTEXT_T *p, unsigned char
         //todo p->interfaces[iface_no].vlan = vlan;
         p->interfaces[iface_no].nwal_handle = handle; //save handle assoicated with this rule
         printf("netcp_cfgp_insert_mac, global context 0x%x\n", p);
-   }
-   else printf(">netcp_cfg insert interface # out of range %d\n",iface_no);
+    }
+    else 
+        printf(">netcp_cfg insert interface # out of range %d\n",iface_no);
 
 }
 
-//internal: get handle associated with interface
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to get handle associated with interface
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to get handle associated with interface
+ *******************************************************************************/
 void* netcp_cfgp_get_mac_handle(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int iface_no)
 {
    if (iface_no == NETCP_CFG_NO_INTERFACE) return NULL;
@@ -386,18 +484,27 @@ void* netcp_cfgp_get_mac_handle(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int iface_no)
    //no valid entry in slot
    return NULL;
 }
-//internal: clear inteface entry
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to delete interface from interface list
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to delete interface from interface list
+ *******************************************************************************/
 static void netcp_cfgp_delete_mac(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,int iface_no)
 {
-   if ((iface_no >=0 ) && (iface_no < TUNE_NETAPI_MAX_NUM_MAC))
-   {
+    if ((iface_no >=0 ) && (iface_no < TUNE_NETAPI_MAX_NUM_MAC))
+    {
         p->interfaces[iface_no].in_use = 0;
-   }
+    }
 }
 
 
 /*========================CLASSIFIERS==========================*/
-//internal: find a free slot for classifier rule
+
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a free slot for classifier rule
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to find a free slot for classifier rule
+ *******************************************************************************/
 static int netcp_cfgp_find_class_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p)
 {
    int i;
@@ -415,52 +522,65 @@ static int netcp_cfgp_find_class_slot( NETAPI_NWAL_GLOBAL_CONTEXT_T *p)
     hplib_mSpinLockUnlock(&netcp_cfg_lock);
    return -1;
 }
-
- //internal: delete a classifer from list 
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a delete a classifer from classifer list
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to find a delete a classifer from classifer list
+ *******************************************************************************/
 static void netcp_cfgp_delete_class(
          NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
          int class_slot )
 {
-   if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS))
-   {
+    if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS))
+    {
         return ;
-   }
-   p->classi[class_slot].in_use=0;
-   return;
+    }
+    p->classi[class_slot].in_use=0;
 }
 
-//internal:  insert a classifier into list 
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to find a insert a classifer to classifer list
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to find a insert a classifer to classifer list
+ *******************************************************************************/
 static void netcp_cfgp_insert_class(NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
-                          int class_slot,  //we 'reserved it already'
-                         int class_type,
-                          void * L2_handle,
-                          void * L3_handle,
-                          void * L4_handle)
+                            int class_slot,  //we 'reserved it already'
+                            int class_type,
+                            void * L2_handle,
+                            void * L3_handle,
+                            void * L4_handle)
 {
-        p->classi[class_slot].in_use=1;
-        p->classi[class_slot].nwal_L2_handle = L2_handle;
-        p->classi[class_slot].nwal_L3_handle = L3_handle;
-        p->classi[class_slot].nwal_L4_handle = L4_handle;
-       p->classi[class_slot].class_type = class_type;
-        return;
+    p->classi[class_slot].in_use=1;
+    p->classi[class_slot].nwal_L2_handle = L2_handle;
+    p->classi[class_slot].nwal_L3_handle = L3_handle;
+    p->classi[class_slot].nwal_L4_handle = L4_handle;
+    p->classi[class_slot].class_type = class_type;
 }
 
-//internal: return L4 nwal_handle for class
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to get L4 nwal handle for classifier
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to get L4 nwal handle for classifier
+ *******************************************************************************/
 static void *netcp_cfgp_get_l4_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int class_slot)
 {
-   if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;
-   if (!p->classi[class_slot].in_use) return NULL;
-   return p->classi[class_slot].nwal_L4_handle;
+    if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;
+    if (!p->classi[class_slot].in_use) return NULL;
+    return p->classi[class_slot].nwal_L4_handle;
 }
 
-//internal: return L3 nwal_handle for class
+/*******************************************************************************
+ * FUNCTION PURPOSE:  Netapi internal function to get L3 nwal handle for classifier
+ *******************************************************************************
+ * DESCRIPTION:  Netapi internal function to get L3 nwal handle for classifier
+ *******************************************************************************/
 static void *netcp_cfgp_get_l3_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
                           int class_slot)
 {
-   if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;
-   if (!p->classi[class_slot].in_use) return NULL;
-   return p->classi[class_slot].nwal_L3_handle;
+    if ((class_slot <0 ) || (class_slot >= TUNE_NETAPI_MAX_CLASSIFIERS)) return NULL;
+    if (!p->classi[class_slot].in_use) return NULL;
+    return p->classi[class_slot].nwal_L3_handle;
 }
 
 
@@ -469,19 +589,24 @@ static void *netcp_cfgp_get_l3_handle( NETAPI_NWAL_GLOBAL_CONTEXT_T *p,
 /***********************************************************************************/
 
 
-/*****************************************************************
- *  Queury Stats
- ****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API to request statistics from NETCP
+ ********************************************************************
+ * DESCRIPTION:  API to request statistics from NETCP
+ ********************************************************************/
 void netcp_cfgReqStats(NETAPI_T  h, NETCP_CFG_STATS_CB cb, int doClear, int *err) 
 {
     nwal_RetValue ret;
     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
     NetapiNwalTransInfo_t *pTransInfo;
     nwal_TransID_t     transId;
-    if ((!n) || (!cb)) {*err = NETAPI_ERR_BAD_INPUT; return ;}
+    if ((!n) || (!cb))
+    {
+        *err = NETAPI_ERR_BAD_INPUT;
+        return ;
+    }
     *err =0;
 
-
     pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &transId);
     if (!pTransInfo) { *err =  NETAPI_ERR_BUSY; return ;}
     pTransInfo->transType = NETAPI_NWAL_HANDLE_STAT_REQUEST;
@@ -493,25 +618,27 @@ void netcp_cfgReqStats(NETAPI_T  h, NETCP_CFG_STATS_CB cb, int doClear, int *err
                               doClear);
     if(ret !=  nwal_OK)
     {
-       pTransInfo->inUse = nwal_FALSE;
-       *err = NETAPI_ERR_BUSY;  //no resources??
-       printf("> netcp_cfg reqStats failed, err=%d\n",ret);
+        pTransInfo->inUse = nwal_FALSE;
+        *err = NETAPI_ERR_BUSY;  //no resources??
+        printf("> netcp_cfg reqStats failed, err=%d\n",ret);
     }
 
 }
-/*****************************************************************
- *  CREATE A MAC INTERFACE
- ****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API to create a MAC interface
+ ********************************************************************
+ * DESCRIPTION:  API to create a MAC interface
+ ********************************************************************/
 NETCP_CFG_MACIF_T  netcp_cfgCreateMacInterface(
-                  NETAPI_T  h,
-                  uint8_t *p_mac,
-                 int  iface_no, 
-                  int switch_port, 
-                  NETCP_CFG_ROUTE_HANDLE_T  route,
-                  NETCP_CFG_VLAN_T  vlan,  //future
-                  int state,  //0=down, 1=up  //ignored
-                  int * err
-                  )
+                    NETAPI_T  h,
+                    uint8_t *p_mac,
+                    int  iface_no, 
+                    int switch_port, 
+                    NETCP_CFG_ROUTE_HANDLE_T  route,
+                    NETCP_CFG_VLAN_T  vlan,  //future
+                    int state,  //0=down, 1=up  //ignored
+                    int * err
+)
 {
     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
     nwalMacParam_t   MacInfo=
@@ -597,10 +724,11 @@ NETCP_CFG_MACIF_T  netcp_cfgCreateMacInterface(
     return  (NETAPI_NETCP_MATCH_GENERIC_MAC | iface_no);
 }
 
-
-/*****************************************************************/
-/***************Delete a mac interface****************************/
-/*****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API to delete MAC  interface
+ ********************************************************************
+ * DESCRIPTION:  API to delete MAC  interface
+ ********************************************************************/
 void netcp_cfgDelMac(NETAPI_T h,int iface_no,  int *err)
 {
     nwal_RetValue ret;
@@ -614,7 +742,7 @@ void netcp_cfgDelMac(NETAPI_T h,int iface_no,  int *err)
     if(!ifHandle) 
             {*err = NETAPI_ERR_BAD_INPUT; return ;}
     *err =0;
-    
+
     //get a transaction id
     pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
     if (!pTransInfo)
@@ -658,8 +786,8 @@ void netcp_cfgDelMac(NETAPI_T h,int iface_no,  int *err)
             *err = NETAPI_ERR_PA_FW;
             printf (">netcp_cfgCreateMacInterface - ERROR returned by NETCP PA firmware %d\n",
                     *err);
-              netcp_cfgp_delete_mac(&netapi_get_global()->nwal_context,  iface_no);
-            return -1;
+            netcp_cfgp_delete_mac(&netapi_get_global()->nwal_context,  iface_no);
+            return;
         }
     }
     printf (">netcp cfg: MAC i/f %d deleted\n",iface_no);
@@ -670,9 +798,11 @@ void netcp_cfgDelMac(NETAPI_T h,int iface_no,  int *err)
 }
 
 
-/*****************************************************************/
-/***************Add IP to MAC interface (internal)****************/
-/*****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  NETAPi internal function to Add IP to MAC interface
+ ********************************************************************
+ * DESCRIPTION:  NETAPi internal function to Add IP to MAC interface
+ ********************************************************************/
 static NETCP_CFG_IP_T  netcp_cfgAddIpInternal(
                   NETAPI_T  h,
                   int  iface_no,
@@ -683,9 +813,9 @@ static NETCP_CFG_IP_T  netcp_cfgAddIpInternal(
                   int * err,
                   int  flag) //TRUE: add IP to iface.  False: add IP as part of classifier
 {
-NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
-void * n_handle=NULL;
-nwalIpParam_t    nwalIpParam= {
+    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
+    void * n_handle=NULL;
+    nwalIpParam_t    nwalIpParam= {
     pa_IPV4,      /* IP Type */
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Dest IP */
     { 0x0,0,0,0},/* IP Options */
@@ -694,46 +824,46 @@ nwalIpParam_t    nwalIpParam= {
     CPPI_PARAM_NOT_SPECIFIED,                    /* Use default flow configured to NWAL  if packet is routed to host */
     QMSS_PARAM_NOT_SPECIFIED                     /* Use default queue configured to NWAL if packet is routed to host */
 };
-nwal_RetValue       retValue;
-NetapiNwalTransInfo_t *pTransInfo;
-nwal_TransID_t     trans_id;
-int ip_slot=-1;
-NETCP_CFG_IP_T ip_rule_id;
-NETCP_CFG_IP_T temp;
-
-     //verify that iface has been configured 
-     if (iface_no != NETCP_CFG_NO_INTERFACE)
-     {
-     if ((iface_no<0) || (iface_no>= TUNE_NETAPI_MAX_NUM_MAC)) {*err = NETAPI_ERR_BAD_INPUT; return -1;}
-     }
-
-     if (iface_no != NETCP_CFG_NO_INTERFACE)
-     {
+    nwal_RetValue       retValue;
+    NetapiNwalTransInfo_t *pTransInfo;
+    nwal_TransID_t     trans_id;
+    int ip_slot=-1;
+    NETCP_CFG_IP_T ip_rule_id;
+    NETCP_CFG_IP_T temp;
+
+    //verify that iface has been configured 
+    if (iface_no != NETCP_CFG_NO_INTERFACE)
+    {
+        if ((iface_no<0) || (iface_no>= TUNE_NETAPI_MAX_NUM_MAC)) {*err = NETAPI_ERR_BAD_INPUT; return -1;}
+    }
+
+    if (iface_no != NETCP_CFG_NO_INTERFACE)
+    {
         printf("netcp_cfgAddIpInternal, in_use %d\n", netapi_get_global()->nwal_context.interfaces[iface_no].in_use);
         printf("netcp-cfgAddIpInternal, p 0x%x\n", &netapi_get_global()->nwal_context);
-     if(netapi_get_global()->nwal_context.interfaces[iface_no].in_use)
-     {
-        n_handle =  netapi_get_global()->nwal_context.interfaces[iface_no].nwal_handle;
-     }
-     else
-     {
-       *err = NETAPI_ERR_BAD_INPUT;
-       return -1;
-     }
-     }
-     if (flag) //if adding IP to MAC then reserve a slot to save info
-     {
-         //find free slot for IP & reserve
-         ip_slot= netcp_cfgp_find_ip_slot(&netapi_get_global()->nwal_context, 
+        if(netapi_get_global()->nwal_context.interfaces[iface_no].in_use)
+        {
+            n_handle =  netapi_get_global()->nwal_context.interfaces[iface_no].nwal_handle;
+        }
+        else
+        {
+            *err = NETAPI_ERR_BAD_INPUT;
+            return -1;
+        }
+    }
+    if (flag) //if adding IP to MAC then reserve a slot to save info
+    {
+        //find free slot for IP & reserve
+         ip_slot= netcp_cfgp_find_ip_slot(&netapi_get_global()->nwal_context, 
                                    iface_no);
-         if (ip_slot <0) 
-         {
-               *err= NETAPI_ERR_NOMEM;  //no room 
-                return -1;
-          }
-     }
+        if (ip_slot <0) 
+        {
+            *err= NETAPI_ERR_NOMEM;  //no room 
+            return -1;
+        }
+    }
 
-     //get a transaction object for config action
+    //get a transaction object for config action
     pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
     if (!pTransInfo)
     {
@@ -751,28 +881,27 @@ NETCP_CFG_IP_T temp;
     pTransInfo->inUse = nwal_TRUE;
     pTransInfo->netapi_handle = h;
 
-     //build nwalIpParam
-     memcpy(&nwalIpParam.locIpAddr,ip_addr, sizeof(nwalIpAddr_t));
-     nwalIpParam.ipType=ipType;
-     if(route)
-     {
+    //build nwalIpParam
+    memcpy(&nwalIpParam.locIpAddr,ip_addr, sizeof(nwalIpAddr_t));
+    nwalIpParam.ipType=ipType;
+    if(route)
+    {
         netcp_cfgp_build_route(route,&nwalIpParam.appRxPktFlowId, &nwalIpParam.appRxPktQueue);
-     } 
-     else{} //use nwal defaults
-     if (ip_qualifiers)
-       memcpy(&nwalIpParam.ipOpt,ip_qualifiers, sizeof(nwalIpOpt_t)); 
-     else
+    }
+    else{} //use nwal defaults
+
+    if (ip_qualifiers)
+        memcpy(&nwalIpParam.ipOpt,ip_qualifiers, sizeof(nwalIpOpt_t)); 
+    else
         memset(&nwalIpParam.ipOpt,0, sizeof(nwalIpOpt_t));
 
-     //build the rule id that will be returned when a packet matches 
-     if (flag)
-       ip_rule_id = NETAPI_NETCP_MATCH_GENERIC_IP | iface_no | ((ip_slot&&0xff)<<8);
-     else
+    //build the rule id that will be returned when a packet matches 
+    if (flag)
+        ip_rule_id = NETAPI_NETCP_MATCH_GENERIC_IP | iface_no | ((ip_slot&&0xff)<<8);
+    else
         ip_rule_id = (NETAPI_NETCP_MATCH_CLASS_L3 | iface_no);
 
-     //perform config action
-
-     retValue = nwal_setIPAddr(   netapi_get_global()->nwal_context.nwalInstHandle,
+    retValue = nwal_setIPAddr(   netapi_get_global()->nwal_context.nwalInstHandle,
                                   trans_id,
                                   (nwal_AppId) (ip_rule_id),
                                   n_handle,
@@ -798,21 +927,21 @@ NETCP_CFG_IP_T temp;
     // todo:  make this handled by scheduler poll later ??
     if(trans_id != NWAL_TRANSID_SPIN_WAIT)
     {
-            n->nwal_local.numPendingCfg++;
-            while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
-                (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_OPEN))
-            {
-                // if response is there, then this poll squirts out in the CTl poll callback, 
-                // which handles the rest (including decrmenting #pending!!
-                nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
-            }
-            if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
-            {
-                netapip_FreeTransInfo(pTransInfo);
-                *err = NETAPI_ERR_PA_FW;
-                printf (">netcp_cfgAddIpInternal - ERROR returned by NETCP PA firmware %d\n", *err);
-                return -1;
-            }
+        n->nwal_local.numPendingCfg++;
+        while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
+        (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_OPEN))
+        {
+            // if response is there, then this poll squirts out in the CTl poll callback, 
+            // which handles the rest (including decrmenting #pending!!
+            nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
+        }
+        if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
+        {
+            netapip_FreeTransInfo(pTransInfo);
+            *err = NETAPI_ERR_PA_FW;
+            printf (">netcp_cfgAddIpInternal - ERROR returned by NETCP PA firmware %d\n", *err);
+            return -1;
+        }
     }
     if (flag)
     {
@@ -826,9 +955,12 @@ NETCP_CFG_IP_T temp;
     netapip_FreeTransInfo(pTransInfo);
     return  (flag ? ip_rule_id:  temp);
 }
-/*****************************************************************/
-/***************Add IP to MAC interface **************************/
-/*****************************************************************/
+
+/********************************************************************
+ * FUNCTION PURPOSE:  API to Add IP to MAC interface
+ ********************************************************************
+ * DESCRIPTION:  API to Add IP to MAC interface
+ ********************************************************************/
 NETCP_CFG_IP_T  netcp_cfgAddIp(
                   NETAPI_T  h,
                   int  iface_no,
@@ -839,14 +971,15 @@ NETCP_CFG_IP_T  netcp_cfgAddIp(
                   int * err
                   )
 {
-       return netcp_cfgAddIpInternal(
-               h, iface_no, ipType, ip_addr, ip_qualifiers, route, err, 
-                1);
+    return netcp_cfgAddIpInternal(h, iface_no, ipType, ip_addr, 
+                                                        ip_qualifiers, route, err, 1);
 }
 
-/*****************************************************************/
-/***************Delete an attached IP*****************************/
-/*****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  NETAPI internal function to detach IP from MAC interface
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function to detach IP from MAC interface
+ ********************************************************************/
 static void netcp_cfgDelIpInternal(NETAPI_T h, int iface_no,  nwal_IpType ipType,
                   nwalIpAddr_t  * ip_addr,
                   nwalIpOpt_t * ip_qualifiers, 
@@ -865,24 +998,27 @@ static void netcp_cfgDelIpInternal(NETAPI_T h, int iface_no,  nwal_IpType ipType
     //get the nwal handle assoicated with this ip   
     if (flag)
     {
-       ifHandle = netcp_cfgp_get_ip_handle(
-                 &netapi_get_global()->nwal_context, iface_no,
-                 ip_slot );
+        ifHandle = netcp_cfgp_get_ip_handle(
+                                        &netapi_get_global()->nwal_context, iface_no,
+                                        ip_slot );
     }
     else 
     {
-       ifHandle = handle;
+        ifHandle = handle;
     }
     if(!ifHandle)
-            {*err = NETAPI_ERR_BAD_INPUT; return ;}
+    {
+        *err = NETAPI_ERR_BAD_INPUT;
+        return ;
+    }
     *err =0;
 
     //get a transaction id
     pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
     if (!pTransInfo)
     {
-        *err =  NETAPI_ERR_BUSY; 
-        return -1;
+        *err =  NETAPI_ERR_BUSY;
+        return;
     }
     pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_IP;
     pTransInfo->state = NETAPI_NWAL_HANDLE_STATE_CLOSE_PENDING;
@@ -908,21 +1044,21 @@ static void netcp_cfgDelIpInternal(NETAPI_T h, int iface_no,  nwal_IpType ipType
         n->nwal_local.numPendingCfg++;
         while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
                 (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_IDLE))
-            {
-                // if response is there, then this poll squirts out in the CTl poll callback, 
-                // which handles the rest (including decrmenting #pending!!
-                nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
-            }
-            if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
-            {
-                netapip_FreeTransInfo(pTransInfo);
-                *err = NETAPI_ERR_PA_FW;
-                printf (">netcp_cfgDelIpInternal - ERROR returned by NETCP PA firmware %d\n", *err);
-                return -1;
-            }
+        {
+            // if response is there, then this poll squirts out in the CTl poll callback, 
+            // which handles the rest (including decrmenting #pending!!
+            nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
+        }
+        if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
+        {
+            netapip_FreeTransInfo(pTransInfo);
+            *err = NETAPI_ERR_PA_FW;
+            printf (">netcp_cfgDelIpInternal - ERROR returned by NETCP PA firmware %d\n", *err);
+            return;
+        }
     }
     if (flag)
-       printf (">netcp cfg: attached IP deleted\n");
+        printf (">netcp cfg: attached IP deleted\n");
     else
         printf (">netcp cfg: Classifier IP rule deleted\n");
 
@@ -930,225 +1066,241 @@ static void netcp_cfgDelIpInternal(NETAPI_T h, int iface_no,  nwal_IpType ipType
 
     //zap the entry
     if (flag)
-       netcp_cfgp_delete_ip(&netapi_get_global()->nwal_context,  
+        netcp_cfgp_delete_ip(&netapi_get_global()->nwal_context,  
                          iface_no,
                          ip_slot);
     return ;
 }
 
-/*****************************************************************/
-/***************Delete an attached IP*****************************/
-/*****************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API to detach IP from MAC interface
+ ********************************************************************
+ * DESCRIPTION:  API  to detach IP from MAC interface
+ ********************************************************************/
 void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,
                   nwalIpAddr_t  * ip_addr,
                   nwalIpOpt_t * ip_qualifiers,
                   NETCP_CFG_IP_T  ip_rule_id,
                   int *err)
 {
-       netcp_cfgDelIpInternal( h, iface_no, ipType,
+    netcp_cfgDelIpInternal( h, iface_no, ipType,
                   ip_addr, ip_qualifiers, ip_rule_id,
                   err, NULL, 1);
-       return;
+    return;
 }
 
 
-/**
- * @def netcp_cfgAddClass
- * @brief  add a classifier rule into NETCP
- **/
+/********************************************************************
+ * FUNCTION PURPOSE:  API to attach a classifier rule to NETCP
+ ********************************************************************
+ * DESCRIPTION:  API to attach a classifier rule to NETCP
+ ********************************************************************/
 NETCP_CFG_CLASS_T netcp_cfgAddClass(NETAPI_T h,
                                       NETCP_CFG_CLASSIFIER_T *p_class,
                                       NETCP_CFG_ROUTE_HANDLE_T route,
                                       int action, int * err)
 {
-NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
-void * l3_handle=NULL;  //ip handle
-nwal_RetValue       retValue;
-NetapiNwalTransInfo_t *pTransInfo;
-nwal_TransID_t     trans_id;
-int class_slot=-1;
-int iface_no;
-int ip_slot=-1;
-NETCP_CFG_CLASS_T  classHandle;  //returned by us
-nwal_appProtoType_t proto;
-nwalRxConnCfg_t tempCfg={
-0,  //nwal_handle: to be filled in
-{0}, // l4 ports: to be filled in
-0,  //core id (NA)
-0, //action
-CPPI_PARAM_NOT_SPECIFIED, //flow id
-QMSS_PARAM_NOT_SPECIFIED, //dest queue
-};
-
-if(!p_class) { *err=NETAPI_ERR_BAD_INPUT; return -1;}
-switch(p_class->classType)
-{
-default:
-       printf(">netcp_cfg : classifier type %d not supported\n",p_class->classType);
-       break;
-case(NETCP_CFG_CLASS_TYPE_L3_L4):
-case(NETCP_CFG_CLASS_TYPE_L4):
-       //assume just type l4 only (L2, L3 defined by iface, l3 id )
-        iface_no = p_class->u.c_l4.iface;
-        if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
-        { 
-               ip_slot = (p_class->u.c_l4.ip>>8)&0xff;
-       }
-
-         //verify that iface has been configured 
-        if (iface_no != NETCP_CFG_NO_INTERFACE)
-        {
-        if(!netapi_get_global()->nwal_context.interfaces[iface_no].in_use)
-       {
-               *err = NETAPI_ERR_BAD_INPUT;
-               return -1;
-       }
-        }
-
-        if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
-        {
-                    //verify that ip has been configured and get its handle
-             l3_handle = netcp_cfgp_get_ip_handle(
-                          &netapi_get_global()->nwal_context, iface_no,
-                          ip_slot );
-        }
-        else
-        {
-            nwalIpParam_t tempParam={
-    pa_IPV4,      /* IP Type */
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Dest IP */
-    { 0x0,0,0,0},/* IP Options */
-    NWAL_MATCH_ACTION_CONTINUE_NEXT_ROUTE,       /* Continue parsing to next route for match */
-    NWAL_NEXT_ROUTE_FAIL_ACTION_HOST,            /* For next route fail action by default is route to host */
-    CPPI_PARAM_NOT_SPECIFIED,                    /* Use default flow configured to NWAL  if packet is routed to host */
-    QMSS_PARAM_NOT_SPECIFIED                     /* Use default queue configured to NWAL if packet is routed to host */
-       };
-               //build nwalIpParam
-               memcpy(&tempParam.locIpAddr,p_class->u.c_l3_l4.ip_addr, sizeof(nwalIpAddr_t));
-               tempParam.ipType=p_class->u.c_l3_l4.ipType;
-            //use nwal defauls for route
-           if (p_class->u.c_l3_l4.ip_qualifiers)
-                       memcpy(&tempParam.ipOpt,p_class->u.c_l3_l4.ip_qualifiers, sizeof(nwalIpOpt_t));
-            else
-                       memset(&tempParam.ipOpt,0, sizeof(nwalIpOpt_t));
-
-
-            //find if we have a matching L3 handle for IP classifier; if not create it
-             retValue =  nwal_getIPAddr (((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
-                                &tempParam,
-                                netcp_cfgp_get_mac_handle(&netapi_get_global()->nwal_context, iface_no ),
-                                &l3_handle); 
-             if (retValue != nwal_TRUE) 
-             {
-                int ret;
-                //**NEW IP RULE  
-               //need to attach this IP RULE to the MAC
-               l3_handle= (void *) netcp_cfgAddIpInternal(
-                  h, iface_no, 
-                  p_class->u.c_l3_l4.ipType,
-                  p_class->u.c_l3_l4.ip_addr,
-                  p_class->u.c_l3_l4.ip_qualifiers,
-                 p_class->u.c_l3_l4.p_fail_route,
-                 &ret,
-                  FALSE);
-                if(!ret)
-                 {
-                       l3_handle=NULL;
-                 }
-             }
-        }         
-        if(!l3_handle)
-            {*err = NETAPI_ERR_BAD_INPUT; return -1 ;}
-
-
-        //find free slot for CLASS & reserve
-        class_slot= netcp_cfgp_find_class_slot(&netapi_get_global()->nwal_context);
-        if(class_slot<0) {*err = NETAPI_ERR_NOMEM; return -1;}
-        classHandle = NETAPI_NETCP_MATCH_CLASS | (class_slot<<8) | (iface_no&0xff);
-        //build request from template
-        tempCfg.inHandle=l3_handle;
-        if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
-        { 
-               memcpy(&tempCfg.appProto,&p_class->u.c_l4.appProto,sizeof(nwalAppProto_t));
-               proto = p_class->u.c_l4.proto;
-        }
-        else
-       {
-               memcpy(&tempCfg.appProto,&p_class->u.c_l3_l4.appProto,sizeof(nwalAppProto_t));
-               proto = p_class->u.c_l3_l4.proto;
-       }
-        
-        tempCfg.matchAction = (action==NETCP_CFG_ACTION_TO_SW)  ? NWAL_MATCH_ACTION_HOST : NWAL_MATCH_ACTION_DISCARD;
-       if (route)
-        {
-               netcp_cfgp_build_route(route,&tempCfg.appRxPktFlowId, &tempCfg.appRxPktQueue);
-       }
-
+    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
+    void * l3_handle=NULL;  //ip handle
+    nwal_RetValue       retValue;
+    NetapiNwalTransInfo_t *pTransInfo;
+    nwal_TransID_t     trans_id;
+    int class_slot=-1;
+    int iface_no;
+    int ip_slot=-1;
+    NETCP_CFG_CLASS_T  classHandle;  //returned by us
+    nwal_appProtoType_t proto;
+    nwalRxConnCfg_t tempCfg=
+    {
+        0,  //nwal_handle: to be filled in
+        {0}, // l4 ports: to be filled in
+        0,  //core id (NA)
+        0, //action
+        CPPI_PARAM_NOT_SPECIFIED, //flow id
+        QMSS_PARAM_NOT_SPECIFIED, //dest queue
+    };
 
-    //get a transaction id
-    pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
-    if (!pTransInfo)
+    if(!p_class)
     {
-        *err =  NETAPI_ERR_BUSY; 
+        *err=NETAPI_ERR_BAD_INPUT;
         return -1;
     }
-    pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_PORT;
-    pTransInfo->state = NETAPI_NWAL_HANDLE_STATE_OPEN_PENDING;
-    pTransInfo->inUse = nwal_TRUE;
-    pTransInfo->netapi_handle = h;
-        //issue request
-        retValue = nwal_addConn(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
+    switch(p_class->classType)
+    {
+        default:
+            printf(">netcp_cfg : classifier type %d not supported\n",p_class->classType);
+            break;
+        case(NETCP_CFG_CLASS_TYPE_L3_L4):
+        case(NETCP_CFG_CLASS_TYPE_L4):
+            //assume just type l4 only (L2, L3 defined by iface, l3 id )
+            iface_no = p_class->u.c_l4.iface;
+            if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
+            {
+                ip_slot = (p_class->u.c_l4.ip>>8)&0xff;
+            }
+
+            //verify that iface has been configured 
+            if (iface_no != NETCP_CFG_NO_INTERFACE)
+            {
+                if(!netapi_get_global()->nwal_context.interfaces[iface_no].in_use)
+                {
+                    *err = NETAPI_ERR_BAD_INPUT;
+                    return -1;
+                }
+            }
+
+            if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
+            {
+                //verify that ip has been configured and get its handle
+                l3_handle = netcp_cfgp_get_ip_handle(
+                      &netapi_get_global()->nwal_context, iface_no,
+                      ip_slot );
+            }
+            else
+            {
+                nwalIpParam_t tempParam=
+                {
+                    pa_IPV4,      /* IP Type */
+                    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Dest IP */
+                    { 0x0,0,0,0},/* IP Options */
+                    NWAL_MATCH_ACTION_CONTINUE_NEXT_ROUTE,       /* Continue parsing to next route for match */
+                    NWAL_NEXT_ROUTE_FAIL_ACTION_HOST,            /* For next route fail action by default is route to host */
+                    CPPI_PARAM_NOT_SPECIFIED,                    /* Use default flow configured to NWAL  if packet is routed to host */
+                    QMSS_PARAM_NOT_SPECIFIED                     /* Use default queue configured to NWAL if packet is routed to host */
+                };
+                //build nwalIpParam
+                memcpy(&tempParam.locIpAddr,p_class->u.c_l3_l4.ip_addr, sizeof(nwalIpAddr_t));
+                tempParam.ipType=p_class->u.c_l3_l4.ipType;
+                //use nwal defauls for route
+                if (p_class->u.c_l3_l4.ip_qualifiers)
+                    memcpy(&tempParam.ipOpt,p_class->u.c_l3_l4.ip_qualifiers, sizeof(nwalIpOpt_t));
+                else
+                    memset(&tempParam.ipOpt,0, sizeof(nwalIpOpt_t));
+
+                //find if we have a matching L3 handle for IP classifier; if not create it
+                retValue =  nwal_getIPAddr (((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
+                            &tempParam,
+                            netcp_cfgp_get_mac_handle(&netapi_get_global()->nwal_context, iface_no ),
+                            &l3_handle); 
+                if (retValue != nwal_TRUE) 
+                {
+                    int ret;
+                    //**NEW IP RULE  
+                    //need to attach this IP RULE to the MAC
+                    l3_handle= (void *) netcp_cfgAddIpInternal(
+                                      h, iface_no, 
+                                      p_class->u.c_l3_l4.ipType,
+                                      p_class->u.c_l3_l4.ip_addr,
+                                      p_class->u.c_l3_l4.ip_qualifiers,
+                                      p_class->u.c_l3_l4.p_fail_route,
+                                      &ret,
+                                      FALSE);
+                    if(!ret)
+                    {
+                        l3_handle=NULL;
+                    }
+                }
+            }
+            if(!l3_handle)
+            {
+                *err = NETAPI_ERR_BAD_INPUT; 
+                return -1 ;
+            }
+
+
+            //find free slot for CLASS & reserve
+            class_slot= netcp_cfgp_find_class_slot(&netapi_get_global()->nwal_context);
+            if(class_slot<0) {*err = NETAPI_ERR_NOMEM; return -1;}
+            classHandle = NETAPI_NETCP_MATCH_CLASS | (class_slot<<8) | (iface_no&0xff);
+            //build request from template
+            tempCfg.inHandle=l3_handle;
+            if (p_class->classType== NETCP_CFG_CLASS_TYPE_L4)
+            {
+                memcpy(&tempCfg.appProto,&p_class->u.c_l4.appProto,sizeof(nwalAppProto_t));
+                proto = p_class->u.c_l4.proto;
+            }
+            else
+            {
+                memcpy(&tempCfg.appProto,&p_class->u.c_l3_l4.appProto,sizeof(nwalAppProto_t));
+                proto = p_class->u.c_l3_l4.proto;
+            }
+
+            tempCfg.matchAction = (action==NETCP_CFG_ACTION_TO_SW)  ? NWAL_MATCH_ACTION_HOST : NWAL_MATCH_ACTION_DISCARD;
+            if (route)
+            {
+                netcp_cfgp_build_route(route,&tempCfg.appRxPktFlowId, &tempCfg.appRxPktQueue);
+            }
+
+
+            //get a transaction id
+            pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
+            if (!pTransInfo)
+            {
+                *err =  NETAPI_ERR_BUSY; 
+                return -1;
+            }
+            pTransInfo->transType = NETAPI_NWAL_HANDLE_TRANS_PORT;
+            pTransInfo->state = NETAPI_NWAL_HANDLE_STATE_OPEN_PENDING;
+            pTransInfo->inUse = nwal_TRUE;
+            pTransInfo->netapi_handle = h;
+                //issue request
+            retValue = nwal_addConn(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
                             trans_id,
-                           (nwal_AppId) classHandle,
+                            (nwal_AppId) classHandle,
                             proto,
                             &tempCfg,
                             NULL,
                             &pTransInfo->handle);
-        if(retValue !=  nwal_OK)
-        {
-            *err = NETAPI_ERR_NWAL_ERR0;
-            printf (">netcp cfg - ERROR: nwal_delMacIface returned Error Code %d\n",
-                    retValue);
-            netapip_FreeTransInfo(pTransInfo);
-            netcp_cfgp_delete_class(&netapi_get_global()->nwal_context, class_slot);
-            return -1;
-        }
-        //wait here until its done since scheduler isn't running yet most likely..
-        // todo:  make this handled by scheduler poll later ??
-        if(trans_id != NWAL_TRANSID_SPIN_WAIT)
-        {
-            n->nwal_local.numPendingCfg++;
-            while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
-                (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_OPEN))
-             {
-                // if response is there, then this poll squirts out in the CTl poll callback, 
-                // which handles the rest (including decrmenting #pending!!
-                nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
-             }
-            if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
+            if(retValue !=  nwal_OK)
             {
+                *err = NETAPI_ERR_NWAL_ERR0;
+                printf (">netcp cfg - ERROR: nwal_delMacIface returned Error Code %d\n",
+                        retValue);
                 netapip_FreeTransInfo(pTransInfo);
-                *err = NETAPI_ERR_PA_FW;
-                 netcp_cfgp_delete_class(&netapi_get_global()->nwal_context, class_slot);
-                printf (">netcp_cfgAddClass - ERROR returned by NETCP PA firmware %d\n", *err);
+                netcp_cfgp_delete_class(&netapi_get_global()->nwal_context, class_slot);
                 return -1;
             }
-         }
-         printf (">netcp cfg: L4 Classifer added to interface %d ip %d (slot%d)\n", iface_no, ip_slot, class_slot);
-         netcp_cfgp_insert_class(&netapi_get_global()->nwal_context, 
+            //wait here until its done since scheduler isn't running yet most likely..
+           // todo:  make this handled by scheduler poll later ??
+            if(trans_id != NWAL_TRANSID_SPIN_WAIT)
+            {
+                n->nwal_local.numPendingCfg++;
+                while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
+                    (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_OPEN))
+                {
+                    // if response is there, then this poll squirts out in the CTl poll callback, 
+                    // which handles the rest (including decrmenting #pending!!
+                    nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
+                }
+                if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
+                {
+                    netapip_FreeTransInfo(pTransInfo);
+                    *err = NETAPI_ERR_PA_FW;
+                    netcp_cfgp_delete_class(&netapi_get_global()->nwal_context, class_slot);
+                    printf (">netcp_cfgAddClass - ERROR returned by NETCP PA firmware %d\n", *err);
+                    return -1;
+                }
+            }
+            printf (">netcp cfg: L4 Classifer added to interface %d ip %d (slot%d)\n", iface_no, ip_slot, class_slot);
+            netcp_cfgp_insert_class(&netapi_get_global()->nwal_context, 
                                    class_slot,
                                  p_class->classType, 
                                 NULL,  //L2 we have
                                 (p_class->classType== NETCP_CFG_CLASS_TYPE_L3_L4? l3_handle : NULL),
                                   pTransInfo->handle);
 
-    netapip_FreeTransInfo(pTransInfo);
-    return classHandle;
-} //end switch
+            netapip_FreeTransInfo(pTransInfo);
+            return classHandle;
+    } //end switch
+
 return -1;
 }
 
-//delete classifier
+/********************************************************************
+ * FUNCTION PURPOSE:  API to delete a preconfigured classifier
+ ********************************************************************
+ * DESCRIPTION:  API to delete a preconfigured classifier
+ ********************************************************************/
 void netcp_cfgDelClass(NETAPI_T h,
                          NETCP_CFG_CLASS_T classId,
                          int *err)
@@ -1160,23 +1312,21 @@ void netcp_cfgDelClass(NETAPI_T h,
     NetapiNwalTransInfo_t *pTransInfo;
     nwal_TransID_t     trans_id;
     int class_slot=-1;
-    //int iface;
-    //int ip_slot;
-
-       class_slot = (classId>>8)&0xffff;
-        L4_handle=netcp_cfgp_get_l4_handle(
-                       &netapi_get_global()->nwal_context,
-                       class_slot );
-        if(!L4_handle)  {*err = NETAPI_ERR_BAD_INPUT; return ;}
-        L3_handle = netcp_cfgp_get_l3_handle(
-                        &netapi_get_global()->nwal_context,
-                        class_slot );
-        /* l3 handle might be NULL,, depending on type of classifier */
 
-       netcp_cfgp_delete_class(
+    class_slot = (classId>>8)&0xffff;
+    L4_handle=netcp_cfgp_get_l4_handle(&netapi_get_global()->nwal_context, class_slot);
+    if(!L4_handle)
+    {
+        *err = NETAPI_ERR_BAD_INPUT; 
+        return ;
+    }
+    L3_handle = netcp_cfgp_get_l3_handle( &netapi_get_global()->nwal_context, class_slot );
+    /* l3 handle might be NULL,, depending on type of classifier */
+
+    netcp_cfgp_delete_class(
                         &netapi_get_global()->nwal_context,
                         class_slot );
-        //get a transaction id
+    //get a transaction id
     pTransInfo = netapip_GetFreeTransInfo((NETAPI_GLOBAL_T *) n->global, &trans_id);
     if (!pTransInfo)
     {
@@ -1187,54 +1337,57 @@ void netcp_cfgDelClass(NETAPI_T h,
     pTransInfo->state = NETAPI_NWAL_HANDLE_STATE_CLOSE_PENDING;
     pTransInfo->inUse = nwal_TRUE;
     pTransInfo->netapi_handle = h;
-        //issue request for L4
-        retValue = nwal_delConn(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
-                            trans_id,
-                            L4_handle);
-        if(retValue !=  nwal_OK)
-        {
-            *err = NETAPI_ERR_NWAL_ERR0;
-            printf (">netcp cfg - ERROR: nwal_delMacIface returned Error Code %d\n",
-                    retValue);
-            netapip_FreeTransInfo(pTransInfo);
-            return ;  /* todo: what about the L3? */
-        }
-        //wait here until its done since scheduler isn't running yet most likely..
-        // todo:  make this handled by scheduler poll later ??
-        if(trans_id != NWAL_TRANSID_SPIN_WAIT)
-        {
-             n->nwal_local.numPendingCfg++;
+    //issue request for L4
+    retValue = nwal_delConn(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,
+                                                  trans_id,
+                                                L4_handle);
+    if(retValue !=  nwal_OK)
+    {
+        *err = NETAPI_ERR_NWAL_ERR0;
+         printf (">netcp cfg - ERROR: nwal_delMacIface returned Error Code %d\n", retValue);
+         netapip_FreeTransInfo(pTransInfo);
+         return ;  /* todo: what about the L3? */
+    }
+    //wait here until its done since scheduler isn't running yet most likely..
+    // todo:  make this handled by scheduler poll later ??
+    if(trans_id != NWAL_TRANSID_SPIN_WAIT)
+    {
+        n->nwal_local.numPendingCfg++;
         while ((pTransInfo->state  !=NETAPI_NWAL_HANDLE_STATE_ERR) &&
                 (pTransInfo->state !=NETAPI_NWAL_HANDLE_STATE_IDLE))
-             {
-                // if response is there, then this poll squirts out in the CTl poll callback, 
-                // which handles the rest (including decrmenting #pending!!
-                nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
-             }
-         }
-        if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
         {
-            netapip_FreeTransInfo(pTransInfo);
-            *err = NETAPI_ERR_PA_FW;
-             printf (">netcp_cfgDelClass - ERROR returned by NETCP PA firmware %d\n", *err);
-             return -1;
-            }
-         printf (">netcp cfg: Classifer deleted\n");
-         pTransInfo->state =  NETAPI_NWAL_HANDLE_STATE_IDLE;
-         pTransInfo->inUse = nwal_FALSE;
-
-         /* delete L3 if we have to */
-         if (L3_handle)
-         {
-             netcp_cfgDelIpInternal( h, 0, 0,
-                  NULL, NULL, 0,
-                  err, L3_handle,  0);
+            // if response is there, then this poll squirts out in the CTl poll callback, 
+            // which handles the rest (including decrmenting #pending!!
+            nwal_pollCtl(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle,NULL,NULL);
         }
+    }
+    if (pTransInfo->state == NETAPI_NWAL_HANDLE_STATE_ERR)
+    {
         netapip_FreeTransInfo(pTransInfo);
+        *err = NETAPI_ERR_PA_FW;
+         printf (">netcp_cfgDelClass - ERROR returned by NETCP PA firmware %d\n", *err);
+         return -1;
+    }
+    printf (">netcp cfg: Classifer deleted\n");
+    pTransInfo->state =  NETAPI_NWAL_HANDLE_STATE_IDLE;
+    pTransInfo->inUse = nwal_FALSE;
+
+    /* delete L3 if we have to */
+    if (L3_handle)
+    {
+        netcp_cfgDelIpInternal( h, 0, 0,
+                  NULL, NULL, 0,
+                  err, L3_handle,  0);
+    }
+    netapip_FreeTransInfo(pTransInfo);
     return ;
 }
 
-
+/********************************************************************
+ * FUNCTION PURPOSE:  API to add a flow
+ ********************************************************************
+ * DESCRIPTION:  API to add a flow
+ ********************************************************************/
 /*--------------flow management--------*/
 // ADD A Flow
 NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T h,
@@ -1244,137 +1397,188 @@ NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T h,
                                             int byte_offset,
                                             int * err )
 {
-  Cppi_RxFlowCfg  rxFlowCfg;
-  Uint8           isAlloc;
-  Qmss_QueueHnd   rxBufQ[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];
-  Uint32          rxBufSize[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];
-  int             i;
-  Cppi_FlowHnd FlowHnd;
-  int  slot;
-  NETCP_CFG_FLOW_HANDLE_T retVal;
-
-  *err= 0;  /* ok */
-  //get a slot to save new flow
-  slot = netcp_cfgp_find_flow_slot(&netapi_get_global()->nwal_context);
-  if (slot<0) { *err= NETAPI_ERR_NOMEM;  return NULL; }
-
-  //configure flow
-  memset(&rxFlowCfg,0,sizeof(Cppi_RxFlowCfg));
-  for (i = 0; i < TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW; i++)
-  {
-      if (i >= n)
-      {
-          rxBufQ[i] = 0;
-          rxBufSize[i] = 0;
-      } else
-      {
-          rxBufQ[i] =   Pktlib_getInternalHeapQueue(handles[i]);
-          //todo: verity sizes< heapsize
-         //todo: verify order
-          rxBufSize[i]= sizes[i];
-      }
-      if (i && (rxBufQ[i] <= 0))
-      {
-          rxBufQ[i] = rxBufQ[i-1];
-          rxBufSize[i] = 0;
-      }
-  }
-  /* Configure Rx flow */
-  rxFlowCfg.flowIdNum      = CPPI_PARAM_NOT_SPECIFIED;
-  rxFlowCfg.rx_dest_qnum   = 100;   //DANGEROUS>  TODO PUT VALID Q HERE
-  rxFlowCfg.rx_dest_qmgr   = 0;
-  rxFlowCfg.rx_sop_offset  = byte_offset;
-  rxFlowCfg.rx_ps_location = Cppi_PSLoc_PS_IN_DESC;
-  rxFlowCfg.rx_desc_type   = Cppi_DescType_HOST;
-  rxFlowCfg.rx_error_handling = 0;
-
-  rxFlowCfg.rx_psinfo_present = 1;
-  rxFlowCfg.rx_einfo_present  = 1;
-
-  rxFlowCfg.rx_dest_tag_lo = 0;
-  rxFlowCfg.rx_dest_tag_hi = 0;
-  rxFlowCfg.rx_src_tag_lo  = 0;
-  rxFlowCfg.rx_src_tag_hi  = 0;
-
-  rxFlowCfg.rx_size_thresh0_en = rxBufSize[1] ? 1 : 0;
-  rxFlowCfg.rx_size_thresh1_en = rxBufSize[2] ? 1 : 0;
-  rxFlowCfg.rx_size_thresh2_en = rxBufSize[3] ? 1 : 0;
-
-  rxFlowCfg.rx_dest_tag_lo_sel = 0;
-  rxFlowCfg.rx_dest_tag_hi_sel = 0;
-  rxFlowCfg.rx_src_tag_lo_sel  = 0;
-  rxFlowCfg.rx_src_tag_hi_sel  = 0;
-
-  rxFlowCfg.rx_fdq1_qnum = rxBufQ[1];
-  rxFlowCfg.rx_fdq1_qmgr = 0;
-  rxFlowCfg.rx_fdq2_qnum = rxBufQ[2];
-
-  rxFlowCfg.rx_fdq2_qmgr = 0;
-  rxFlowCfg.rx_fdq3_qnum = rxBufQ[3];
-
-  rxFlowCfg.rx_fdq3_qmgr = 0;
-
-  rxFlowCfg.rx_size_thresh0 = rxBufSize[1] ? rxBufSize[0] : 0;
-  rxFlowCfg.rx_size_thresh1 = rxBufSize[2] ? rxBufSize[1] : 0;
-  rxFlowCfg.rx_size_thresh2 = rxBufSize[3] ? rxBufSize[2] : 0;
-
-  rxFlowCfg.rx_fdq0_sz0_qnum = rxBufQ[0];
-  rxFlowCfg.rx_fdq0_sz0_qmgr = 0;
-  rxFlowCfg.rx_fdq0_sz1_qnum = rxBufQ[1];
-  rxFlowCfg.rx_fdq0_sz1_qmgr = 0;
-  rxFlowCfg.rx_fdq0_sz2_qnum = rxBufQ[2];
-  rxFlowCfg.rx_fdq0_sz2_qmgr = 0;
-  rxFlowCfg.rx_fdq0_sz3_qnum = rxBufQ[3];
-  rxFlowCfg.rx_fdq0_sz3_qmgr = 0;
-
- {
-  //todo: replace this with a nwal call to get global cntx info
-  Cppi_CpDmaInitCfg cpdmaCfg;
-  memset(&cpdmaCfg,0,sizeof(Cppi_CpDmaInitCfg));
-  cpdmaCfg.dmaNum   = Cppi_CpDma_PASS_CPDMA;
-  FlowHnd =
-      Cppi_configureRxFlow (Cppi_open (&cpdmaCfg), &rxFlowCfg, &isAlloc);
-}
-  if (FlowHnd == NULL)
-  {
-      *err= NETAPI_ERR_NORES;
-      netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);
-      return (NULL);
-  }
-
-  //update slot
-  retVal = netcp_cfgp_insert_flow(&netapi_get_global()->nwal_context, slot, (void*) FlowHnd);
-  printf(">netcp cfg:  flow %d created\n",  ((NETCP_CFG_FLOW_T *) retVal)->flowid);
-  return ( retVal);
+    Cppi_RxFlowCfg  rxFlowCfg;
+    Uint8           isAlloc;
+    Qmss_QueueHnd   rxBufQ[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];
+    Uint32          rxBufSize[TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW];
+    int             i;
+    Cppi_FlowHnd FlowHnd;
+    int  slot;
+    NETCP_CFG_FLOW_HANDLE_T retVal;
+
+    *err= 0;  /* ok */
+    //get a slot to save new flow
+    slot = netcp_cfgp_find_flow_slot(&netapi_get_global()->nwal_context);
+    if (slot<0) { *err= NETAPI_ERR_NOMEM;  return NULL; }
+
+    //configure flow
+    memset(&rxFlowCfg,0,sizeof(Cppi_RxFlowCfg));
+    for (i = 0; i < TUNE_NETAPI_MAX_BUF_POOLS_IN_FLOW; i++)
+    {
+        if (i >= n)
+        {
+            rxBufQ[i] = 0;
+            rxBufSize[i] = 0;
+        }
+        else
+        {
+            rxBufQ[i] =   Pktlib_getInternalHeapQueue(handles[i]);
+            //todo: verity sizes< heapsize
+            //todo: verify order
+            rxBufSize[i]= sizes[i];
+        }
+       if (i && (rxBufQ[i] <= 0))
+       {
+            rxBufQ[i] = rxBufQ[i-1];
+            rxBufSize[i] = 0;
+       }
+    }
 
+    /* Configure Rx flow */
+    rxFlowCfg.flowIdNum      = CPPI_PARAM_NOT_SPECIFIED;
+    rxFlowCfg.rx_dest_qnum   = 100;   //DANGEROUS>  TODO PUT VALID Q HERE
+    rxFlowCfg.rx_dest_qmgr   = 0;
+    rxFlowCfg.rx_sop_offset  = byte_offset;
+    rxFlowCfg.rx_ps_location = Cppi_PSLoc_PS_IN_DESC;
+    rxFlowCfg.rx_desc_type   = Cppi_DescType_HOST;
+    rxFlowCfg.rx_error_handling = 0;
+
+    rxFlowCfg.rx_psinfo_present = 1;
+    rxFlowCfg.rx_einfo_present  = 1;
+
+    rxFlowCfg.rx_dest_tag_lo = 0;
+    rxFlowCfg.rx_dest_tag_hi = 0;
+    rxFlowCfg.rx_src_tag_lo  = 0;
+    rxFlowCfg.rx_src_tag_hi  = 0;
+
+    rxFlowCfg.rx_size_thresh0_en = rxBufSize[1] ? 1 : 0;
+    rxFlowCfg.rx_size_thresh1_en = rxBufSize[2] ? 1 : 0;
+    rxFlowCfg.rx_size_thresh2_en = rxBufSize[3] ? 1 : 0;
+
+    rxFlowCfg.rx_dest_tag_lo_sel = 0;
+    rxFlowCfg.rx_dest_tag_hi_sel = 0;
+    rxFlowCfg.rx_src_tag_lo_sel  = 0;
+    rxFlowCfg.rx_src_tag_hi_sel  = 0;
+
+    rxFlowCfg.rx_fdq1_qnum = rxBufQ[1];
+    rxFlowCfg.rx_fdq1_qmgr = 0;
+    rxFlowCfg.rx_fdq2_qnum = rxBufQ[2];
+
+    rxFlowCfg.rx_fdq2_qmgr = 0;
+    rxFlowCfg.rx_fdq3_qnum = rxBufQ[3];
+
+    rxFlowCfg.rx_fdq3_qmgr = 0;
+
+    rxFlowCfg.rx_size_thresh0 = rxBufSize[1] ? rxBufSize[0] : 0;
+    rxFlowCfg.rx_size_thresh1 = rxBufSize[2] ? rxBufSize[1] : 0;
+    rxFlowCfg.rx_size_thresh2 = rxBufSize[3] ? rxBufSize[2] : 0;
+
+    rxFlowCfg.rx_fdq0_sz0_qnum = rxBufQ[0];
+    rxFlowCfg.rx_fdq0_sz0_qmgr = 0;
+    rxFlowCfg.rx_fdq0_sz1_qnum = rxBufQ[1];
+    rxFlowCfg.rx_fdq0_sz1_qmgr = 0;
+    rxFlowCfg.rx_fdq0_sz2_qnum = rxBufQ[2];
+    rxFlowCfg.rx_fdq0_sz2_qmgr = 0;
+    rxFlowCfg.rx_fdq0_sz3_qnum = rxBufQ[3];
+    rxFlowCfg.rx_fdq0_sz3_qmgr = 0;
 
+    {
+        //todo: replace this with a nwal call to get global cntx info
+        Cppi_CpDmaInitCfg cpdmaCfg;
+        memset(&cpdmaCfg,0,sizeof(Cppi_CpDmaInitCfg));
+        cpdmaCfg.dmaNum   = Cppi_CpDma_PASS_CPDMA;
+        FlowHnd = Cppi_configureRxFlow (Cppi_open (&cpdmaCfg), &rxFlowCfg, &isAlloc);
+    }
+    if (FlowHnd == NULL)
+    {
+        *err= NETAPI_ERR_NORES;
+        netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);
+        return (NULL);
+    }
 
+    //update slot
+    retVal = netcp_cfgp_insert_flow(&netapi_get_global()->nwal_context, slot, (void*) FlowHnd);
+    printf(">netcp cfg:  flow %d created\n",  ((NETCP_CFG_FLOW_T *) retVal)->flowid);
+    return ( retVal);
 }
 
-//Delete a flow
+/********************************************************************
+ * FUNCTION PURPOSE:  API to delete a flow
+ ********************************************************************
+ * DESCRIPTION:  API to delete a flow
+ ********************************************************************/
 void netcp_cfgDelFlow(NETAPI_T h , NETCP_CFG_FLOW_HANDLE_T f , int * err)
 {
-       int slot;
-       void * handle;
-       *err=0;
-        /* find entry */
-        slot = netcp_cfgp_find_flow(&netapi_get_global()->nwal_context, ((NETCP_CFG_FLOW_T *) f) ->flowid, &handle);
-       if (slot<0) {*err = NETAPI_ERR_BAD_INPUT; return;}
-
-       Cppi_closeRxFlow( (Cppi_FlowHnd) handle);
-        netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);
-        printf(">netcp cfg:  flow %d deleted\n",  ((NETCP_CFG_FLOW_T *) f)->flowid);
+    int slot;
+    void * handle;
+    *err=0;
+    /* find entry */
+    slot = netcp_cfgp_find_flow(&netapi_get_global()->nwal_context, ((NETCP_CFG_FLOW_T *) f) ->flowid, &handle);
+    if (slot<0)
+    {
+        *err = NETAPI_ERR_BAD_INPUT; 
         return;
+    }
+
+    Cppi_closeRxFlow( (Cppi_FlowHnd) handle);
+    netcp_cfgp_delete_flow(&netapi_get_global()->nwal_context, slot);
+    printf(">netcp cfg:  flow %d deleted\n",  ((NETCP_CFG_FLOW_T *) f)->flowid);
+    return;
 }
 
+/******************************************************************************
+ * FUNCTION PURPOSE:  API to configure NETCP with global rules for exception packet handling
+ ******************************************************************************
+ * DESCRIPTION:  API to configure NETCP with global rules for exception packet handling
+ *****************************************************************************/
+NETCP_CFG_EXCEPTION_PKT_T netcp_cfgExceptions(NETAPI_T h,
+                                    int exception_id ,
+                                    nwal_matchAction_t action,
+                                    NETCP_CFG_ROUTE_HANDLE_T p_route)
+{
+    nwalCtlInfo_t   ctrl;
+    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
+    nwal_RetValue retVal = 0;
+    memset(&ctrl, 0, sizeof(nwalCtlInfo_t));
+
+    if (p_route != NULL)
+    {
+        netcp_cfgp_build_route(p_route, &ctrl.appRxPktFlowId,& ctrl.appRxPktQueue);
+    }
+    else
+    {
+        ctrl.appRxPktFlowId = NWAL_FLOW_NOT_SPECIFIED;
+        ctrl.appRxPktQueue = NWAL_QUEUE_NOT_SPECIFIED;
+    }
+
+    ctrl.appId =NETCP_CFG_MATCH_EXCEPTION | exception_id;
+
+    ctrl.matchAction = action;
+
+    if (exception_id == NETCP_CFG_ALL_EXCEPTIONS)
+    {
+        ctrl.pktCtl = NWAL_CTRL_CFG_ALL_EXCEPTIONS;
+    }
+    else
+    {
+            ctrl.pa_EROUTE_Id = exception_id;
+            ctrl.pktCtl = NWAL_CTRL_CFG_SINGLE_EXCEPTION;
+    }
+
+    retVal = nwal_control(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle, &ctrl);
+
+    return (NETCP_CFG_EXCEPTION_PKT_T) ctrl.appId;
+}
 
 /*************************************************************************/
 /*********************************INTERNAL*******************************/
 /************************************************************************/
 
-/***************************************************************
- ********************NETCP CMD Reply Callback******************
- ***************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  NETAPI internal function, NETCP command reply callback
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function, NETCP command reply callback
+ ********************************************************************/
 void netapi_NWALCmdCallBack (nwal_AppId        appHandle,
                           uint16_t            trans_id,
                           nwal_RetValue     ret)
@@ -1396,13 +1600,13 @@ void netapi_NWALCmdCallBack (nwal_AppId        appHandle,
         printf (">netcp cfg : netapi_NWALCmdCallBack returned Error Code %d for trans_id %d\n",
                     ret, trans_id);
         // update error code that is fialed  in p_trans */
-       //todo: atomic inc
-       p_trans->state = NETAPI_NWAL_HANDLE_STATE_ERR;
+        //todo: atomic inc
+        p_trans->state = NETAPI_NWAL_HANDLE_STATE_ERR;
         netapi_get_global()->nwal_context.numCmdFail++;
     }
     else
     {
-       //todo: atomic inc
+        //todo: atomic inc
         netapi_get_global()->nwal_context.numCmdPass++;
         switch(p_trans->transType)
         {
@@ -1454,7 +1658,7 @@ void netapi_NWALCmdCallBack (nwal_AppId        appHandle,
                 }
                 break;
             }
-           case NETAPI_NWAL_HANDLE_TRANS_SA_POLICY:
+            case NETAPI_NWAL_HANDLE_TRANS_SA_POLICY:
             {
                 if(p_trans->state == NETAPI_NWAL_HANDLE_STATE_OPEN_PENDING)
                 {
@@ -1481,20 +1685,21 @@ void netapi_NWALCmdCallBack (nwal_AppId        appHandle,
     {
         p_trans->inUse = nwal_FALSE;
     }
-
 }
 
 
-/*******************************************************/
-/**************stats reply callback**********************/
-/*******************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  NETAPI internal function, PA stats reply callback
+ ********************************************************************
+ * DESCRIPTION:  NETAPI internal function, PA stats reply callback
+ ********************************************************************/
 void netapi_NWALCmdPaStatsReply (nwal_AppId        appHandle,
                               nwal_TransID_t    trans_id,
                               paSysStats_t      *stats)
 {
     NetapiNwalTransInfo_t * p_trans;
     NETAPI_NWAL_LOCAL_CONTEXT_T *p_local=NULL;
-  
+
     if(trans_id == NWAL_TRANSID_SPIN_WAIT)
     {
         netapi_get_global()->nwal_context.numBogusTransIds++;
@@ -1508,52 +1713,11 @@ void netapi_NWALCmdPaStatsReply (nwal_AppId        appHandle,
     //save a local copy  of some stuff*/
     p_local->numL2PktsRecvd=stats->classify1.nPackets;
     p_local->numL3PktsRecvd=stats->classify1.nIpv4Packets;
-#if 0
-    p_local->numL4PktsRecvd=stats->;
-    p_local->numL4PktsSent=stats->;
-    p_local->TxErrDrop=stats->;
-#endif
-    //callout result to application !!
-    if (p_local->stats_cb) (*p_local->stats_cb)(p_trans->netapi_handle,stats);
-    
-} 
 
-// Configure global rules at NETCP for exception packet handling
-NETCP_CFG_EXCEPTION_PKT_T netcp_cfgExceptions(NETAPI_T h,
-                                    int exception_id ,
-                                    nwal_matchAction_t action,
-                                    NETCP_CFG_ROUTE_HANDLE_T p_route)
-{
-    nwalCtlInfo_t   ctrl;
-    NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) h;
-    nwal_RetValue retVal = 0;
-    memset(&ctrl, 0, sizeof(nwalCtlInfo_t));
-
-    if (p_route != NULL)
-    {
-        netcp_cfgp_build_route(p_route, &ctrl.appRxPktFlowId,& ctrl.appRxPktQueue);
-    }
-    else
-    {
-        ctrl.appRxPktFlowId = NWAL_FLOW_NOT_SPECIFIED;
-        ctrl.appRxPktQueue = NWAL_QUEUE_NOT_SPECIFIED;
-    }
-
-    ctrl.appId =NETCP_CFG_MATCH_EXCEPTION | exception_id;
-
-    ctrl.matchAction = action;
-
-    if (exception_id == NETCP_CFG_ALL_EXCEPTIONS)
+    //callout result to application !!
+    if (p_local->stats_cb)
     {
-        ctrl.pktCtl = NWAL_CTRL_CFG_ALL_EXCEPTIONS;
+        (*p_local->stats_cb)(p_trans->netapi_handle,stats);
     }
-    else
-    {
-            ctrl.pa_EROUTE_Id = exception_id;
-            ctrl.pktCtl = NWAL_CTRL_CFG_SINGLE_EXCEPTION;
-    }
-
-    retVal = nwal_control(((NETAPI_GLOBAL_T*) (n->global))->nwal_context.nwalInstHandle, &ctrl);
-
-    return (NETCP_CFG_EXCEPTION_PKT_T) ctrl.appId;
 }
+
index b14f0c1820e81c27d67abdd52a7840b35e0a2a32..83e2b7d9eb2ecd16ab6ef17380da0e4bdee3b0fd 100755 (executable)
 #include "qmss_device.c"
 #include "cppi_device.c"
 
-/******************************************************************************
-* Macro to convert to IP Register Virtual Address from a mapped base Virtual
-* Address
-* Input: virtBaseAddr: Virtual base address mapped using mmap for IP
-*        phyBaseAddr: Physical base address for the IP
-*        phyRegAddr:  Physical register address
-******************************************************************************/
+
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI macro to convert to IP Register
+ *                    Virtual Address from a mapped base Virtual
+ *                    Address.
+ ********************************************************************
+ * DESCRIPTION:  Arguments:
+ *      virtBaseAddr: Virtual base address mapped using mmap for IP
+ *       phyBaseAddr: Physical base address for the IP
+ *       phyRegAddr:  Physical register address
+ ********************************************************************/
+
+
 static inline void* NETAPI_GET_REG_VADDR (void *    virtBaseAddr,
                                           uint32_t  phyBaseAddr,
                                           uint32_t  phyRegAddr)
@@ -72,220 +78,224 @@ static inline void* NETAPI_GET_REG_VADDR (void *    virtBaseAddr,
 }
 
 
-//*************************************************
-//initilaize CPPI (once per soc)
-//*************************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAI function ti initialize CPPI. 
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAI function ti initialize CPPI
+ ********************************************************************/
 int netapi_init_cppi(void)
 {
-  int32_t result, i;
-  Cppi_GlobalConfigParams     netapi_cppiGblCfgParams[CPPI_MAX_CPDMA];
+    int32_t result, i;
+    Cppi_GlobalConfigParams     netapi_cppiGblCfgParams[CPPI_MAX_CPDMA];
 
-  for (i=0; i<CPPI_MAX_CPDMA; i++)
-    netapi_cppiGblCfgParams[i] = cppiGblCfgParams[i];
+    for (i=0; i<CPPI_MAX_CPDMA; i++)
+        netapi_cppiGblCfgParams[i] = cppiGblCfgParams[i];
 
-  /* SRIO CPDMA regs */
-  netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs =
-   NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
+    /* SRIO CPDMA regs */
+    netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs =
+     NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
                         CSL_SRIO_CONFIG_REGS,
                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs);
 
-  netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs =
-   NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
-                        CSL_SRIO_CONFIG_REGS,
-                        (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs =
-   NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
-                        CSL_SRIO_CONFIG_REGS,
-                        (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs =
-   NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
-                        CSL_SRIO_CONFIG_REGS,
-                        (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs);
-
- netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs =
-   NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
-                        CSL_SRIO_CONFIG_REGS,
-                        (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs);
-
-  /* PASS CPDMA regs */
-  netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
-                         CSL_PA_SS_CFG_REGS,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
-                         CSL_PA_SS_CFG_REGS,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
-                         CSL_PA_SS_CFG_REGS,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
-                         CSL_PA_SS_CFG_REGS,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
-                         CSL_PA_SS_CFG_REGS,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs);
-
- /* QMSS CPDMA regs */
-  netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs);
-
-  netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs);
-
-  result = Cppi_init (netapi_cppiGblCfgParams);
-  if (result != CPPI_SOK)
-  {
-    printf (">function cppi_init: Cppi_init failed with error code %d\n", result);
-    return (-1);
-  }
-   return 1;
+    netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs =
+     NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
+                          CSL_SRIO_CONFIG_REGS,
+                          (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs =
+     NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
+                          CSL_SRIO_CONFIG_REGS,
+                          (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs =
+     NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
+                          CSL_SRIO_CONFIG_REGS,
+                          (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs);
+
  netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs =
+     NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->srioCfgVaddr,
+                          CSL_SRIO_CONFIG_REGS,
+                          (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs);
+
+    /* PASS CPDMA regs */
+    netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
+                           CSL_PA_SS_CFG_REGS,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
+                           CSL_PA_SS_CFG_REGS,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
+                           CSL_PA_SS_CFG_REGS,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
+                           CSL_PA_SS_CFG_REGS,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->passCfgVaddr,
+                           CSL_PA_SS_CFG_REGS,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs);
+
  /* QMSS CPDMA regs */
+    netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs);
+
+    netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs);
+
+    result = Cppi_init (netapi_cppiGblCfgParams);
+    if (result != CPPI_SOK)
+    {
+      printf (">function cppi_init: Cppi_init failed with error code %d\n", result);
+      return (-1);
+    }
+     return 1;
 }
 
-//****************************************************
-// initialize QM (per SOC)
-//***************************************************
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAI function ti initialize QM. 
+ ********************************************************************
+ * DESCRIPTION:  Internal NETAI function ti initialize QM (once per SOC)
+ ********************************************************************/
 int netapi_init_qm(int max_descriptors)
 {
-  Qmss_InitCfg     qmssInitConfig;
-  int32_t          result;
-  Qmss_GlobalConfigParams netapi_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      = max_descriptors;
-  qmssInitConfig.qmssHwStatus =QMSS_HW_INIT_COMPLETE; //bypass some of the hw init
-  netapi_qmssGblCfgParams = qmssGblCfgParams[0];
-
-  netapi_qmssGblCfgParams.qmConfigReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmConfigReg);
-
-  netapi_qmssGblCfgParams.qmDescReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmDescReg);
-
-  netapi_qmssGblCfgParams.qmQueMgmtReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmQueMgmtReg);
-
-  netapi_qmssGblCfgParams.qmQueMgmtProxyReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmQueMgmtProxyReg);
-
-  netapi_qmssGblCfgParams.qmQueStatReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmQueStatReg);
-
-  netapi_qmssGblCfgParams.qmQueIntdReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmQueIntdReg);
-
-  netapi_qmssGblCfgParams.qmPdspCmdReg[0] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspCmdReg[0]);
-
-  netapi_qmssGblCfgParams.qmPdspCmdReg[1] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspCmdReg[1]);
-
-  netapi_qmssGblCfgParams.qmPdspCtrlReg[0] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspCtrlReg[0]);
-
-  netapi_qmssGblCfgParams.qmPdspCtrlReg[1] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspCtrlReg[1]);
-
-  netapi_qmssGblCfgParams.qmPdspIRamReg[0] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspIRamReg[0]);
-
-  netapi_qmssGblCfgParams.qmPdspIRamReg[1] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmPdspIRamReg[1]);
-
-  netapi_qmssGblCfgParams.qmStatusRAM =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmStatusRAM);
-  netapi_qmssGblCfgParams.qmLinkingRAMReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmLinkingRAMReg);
-  netapi_qmssGblCfgParams.qmMcDMAReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmMcDMAReg);
-
-  netapi_qmssGblCfgParams.qmTimer16Reg[0] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmTimer16Reg[0]);
-
-  netapi_qmssGblCfgParams.qmTimer16Reg[1] =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
-                         QMSS_CFG_BASE_ADDR,
-                         (uint32_t)netapi_qmssGblCfgParams.qmTimer16Reg[1]);
-
-
-  netapi_qmssGblCfgParams.qmQueMgmtDataReg = 
-                                                    (void *)((uint32_t)netapi_VM_VirtAddr->qmssDataVaddr);
-  
-  netapi_qmssGblCfgParams.qmQueMgmtProxyDataReg =
-    NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssDataVaddr,
-                         QMSS_DATA_BASE_ADDR,
-                         QMSS_DATA_ARM_PROXY_QUEUE_DEQUEUE_REGS);
-
-  result = Qmss_init (&qmssInitConfig, &netapi_qmssGblCfgParams);
-  if (result != QMSS_SOK)  {
-    printf (">function init_qm: qmss_Init failed with error code %d\n", result);
-    return (nwal_FALSE);
-  }
-
+    Qmss_InitCfg     qmssInitConfig;
+    int32_t          result;
+    Qmss_GlobalConfigParams netapi_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      = max_descriptors;
+    qmssInitConfig.qmssHwStatus =QMSS_HW_INIT_COMPLETE; //bypass some of the hw init
+    netapi_qmssGblCfgParams = qmssGblCfgParams[0];
+
+    netapi_qmssGblCfgParams.qmConfigReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmConfigReg);
+
+    netapi_qmssGblCfgParams.qmDescReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmDescReg);
+
+    netapi_qmssGblCfgParams.qmQueMgmtReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmQueMgmtReg);
+
+    netapi_qmssGblCfgParams.qmQueMgmtProxyReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmQueMgmtProxyReg);
+
+    netapi_qmssGblCfgParams.qmQueStatReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmQueStatReg);
+
+    netapi_qmssGblCfgParams.qmQueIntdReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmQueIntdReg);
+
+    netapi_qmssGblCfgParams.qmPdspCmdReg[0] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspCmdReg[0]);
+
+    netapi_qmssGblCfgParams.qmPdspCmdReg[1] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspCmdReg[1]);
+
+    netapi_qmssGblCfgParams.qmPdspCtrlReg[0] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspCtrlReg[0]);
+
+    netapi_qmssGblCfgParams.qmPdspCtrlReg[1] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspCtrlReg[1]);
+
+    netapi_qmssGblCfgParams.qmPdspIRamReg[0] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspIRamReg[0]);
+
+    netapi_qmssGblCfgParams.qmPdspIRamReg[1] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmPdspIRamReg[1]);
+
+    netapi_qmssGblCfgParams.qmStatusRAM =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmStatusRAM);
+
+    netapi_qmssGblCfgParams.qmLinkingRAMReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmLinkingRAMReg);
+
+    netapi_qmssGblCfgParams.qmMcDMAReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmMcDMAReg);
+
+    netapi_qmssGblCfgParams.qmTimer16Reg[0] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmTimer16Reg[0]);
+
+    netapi_qmssGblCfgParams.qmTimer16Reg[1] =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssCfgVaddr,
+                           QMSS_CFG_BASE_ADDR,
+                           (uint32_t)netapi_qmssGblCfgParams.qmTimer16Reg[1]);
+
+    netapi_qmssGblCfgParams.qmQueMgmtDataReg = 
+                                                      (void *)((uint32_t)netapi_VM_VirtAddr->qmssDataVaddr);
+
+    netapi_qmssGblCfgParams.qmQueMgmtProxyDataReg =
+      NETAPI_GET_REG_VADDR(netapi_VM_VirtAddr->qmssDataVaddr,
+                           QMSS_DATA_BASE_ADDR,
+                           QMSS_DATA_ARM_PROXY_QUEUE_DEQUEUE_REGS);
+
+    result = Qmss_init (&qmssInitConfig, &netapi_qmssGblCfgParams);
+    if (result != QMSS_SOK)  {
+        printf (">function init_qm: qmss_Init failed with error code %d\n", result);
+        return (nwal_FALSE);
+    }
     return 1;
 }
index 017f194ae5805892378538512bca187dd9284021..3888ba7929168c9c17e0a2db7585d7838b520d8a 100755 (executable)
 #include "qmss_device.c"
 #include "cppi_device.c"
 
-/******************************************************************************
-* Macro to convert to IP Register Virtual Address from a mapped base Virtual
-* Address
-* Input: virtBaseAddr: Virtual base address mapped using mmap for IP
-*        phyBaseAddr: Physical base address for the IP
-*        phyRegAddr:  Physical register address
-******************************************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  Internal NETAPI macro to convert to IP Register
+ *                    Virtual Address from a mapped base Virtual
+ *                    Address.
+ ********************************************************************
+ * DESCRIPTION:  Arguments:
+ *      virtBaseAddr: Virtual base address mapped using mmap for IP
+ *       phyBaseAddr: Physical base address for the IP
+ *       phyRegAddr:  Physical register address
+ ********************************************************************/
 static inline void* NETAPI_GET_REG_VADDR (void *    virtBaseAddr,
                                           uint32_t  phyBaseAddr,
                                           uint32_t  phyRegAddr)
index e6bc81c21d51fd3648db5476dbc0d543594932e4..6dc7568e4ae7854dfcc9d4583e9f3fd2968e85f4 100755 (executable)
@@ -50,6 +50,8 @@
 
 
 
+/*This defines the maximum number of packets to receive in one pktio poll */
+#define PKTIO_MAX_RECV  (TUNE_NETAPI_MAX_BURST_RCV)
 
 static hplib_spinLock_T pktio_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
 
@@ -58,17 +60,20 @@ static hplib_spinLock_T pktio_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
 
 static PKTIO_HANDLE_T * pktiop_get_free_channel_slot(NETAPI_T n)
 {
-       PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
-       int i;
-       for(i=0;i<NETAPI_MAX_PKTIO;i++)
-       {
-               if (pp[i]->inuse != PKTIO_INUSE)
-               {
-                       pp[i]->inuse = PKTIO_INUSE;
-                    return  pp[i];
-               }
-       }
-       return NULL;
+    PKTIO_HANDLE_T ** pp = (PKTIO_HANDLE_T **) netapi_get_pktio_list(n);
+    int i;
+    hplib_mSpinLockLock(&pktio_lock);
+    for(i=0;i<NETAPI_MAX_PKTIO;i++)
+    {
+        if (pp[i]->inuse != PKTIO_INUSE)
+        {
+            pp[i]->inuse = PKTIO_INUSE;
+            hplib_mSpinLockUnlock(&pktio_lock);
+            return  pp[i];
+        }
+    }
+    hplib_mSpinLockUnlock(&pktio_lock);
+    return NULL;
 }
 
 
@@ -76,208 +81,249 @@ static PKTIO_HANDLE_T * pktiop_get_free_channel_slot(NETAPI_T n)
 /*          optimized send/rcv functions              */
 /*----------------------------------------------------*/
 
-//********************************************
-//send pkt via ipc queue 
-//********************************************
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet via IPC queue
+ ********************************************************************
+ * DESCRIPTION: Send packet via IPC queue
+ ********************************************************************/
 static int pktio_send_ipc(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
 {
-        PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-        *err=0;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    err=0;
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv8p=netapi_timing_stop();
+    p->stats.vv8p=hplib_mUtilGetPmuCCNT();
 #endif
-        Qmss_queuePushDesc (p->q, (void*)pkt);
+    Qmss_queuePushDesc (p->q, (void*)pkt);
 
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv9p=netapi_timing_stop();
+    p->stats.vv9p=hplib_mUtilGetPmuCCNT();
 #endif
-       return 1;
+    return 1;
 }
-//********************************************
-//send pkt to NETCP via NWAL
-//********************************************
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet to NETCP via NWAL
+ ********************************************************************
+ * DESCRIPTION: Send packet to NETCP via NWAL
+ ********************************************************************/
 static int pktio_send_nwal(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
 {
-        PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-        nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
-        nwal_RetValue res;
-       *err=0;
-       pPktInfo->pPkt = pkt;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
+    nwal_RetValue res;
+    *err=0;
+    pPktInfo->pPkt = pkt;
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv11p=netapi_timing_stop();
+    p->stats.vv11p=hplib_mUtilGetPmuCCNT();
 #endif
-        res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
+    res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv12p=netapi_timing_stop();
+    p->stats.vv12p=hplib_mUtilGetPmuCCNT();
 #endif
-        if (res != nwal_OK) {  *err = NETAPI_ERR_NWAL_TX_ERR -res;}
-        return 1;
+    if (res != nwal_OK)
+    {
+        *err = NETAPI_ERR_NWAL_TX_ERR -res;
+    }
+    return 1;
 }
-//********************************************
-//send to SA via SB queue
-//********************************************
+
+/********************************************************************
+ * FUNCTION PURPOSE: Send packet to SA via NWAL
+ ********************************************************************
+ * DESCRIPTION: Send packet to NETCP via NWAL for side band data mode channel 
+ * via NWAL
+ ********************************************************************/
 static int pktio_send_sb(struct PKTIO_HANDLE_tag * pp, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
 {
-        PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-        nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
-        nwal_RetValue res;
-       *err=0;
-        pPktInfoSB->pPkt = pkt;
-        res=nwal_sendDM(p->nwalInstanceHandle, m->sa_handle,pPktInfoSB);
-        if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
-        return 1;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
+    nwal_RetValue res;
+    *err=0;
+    pPktInfoSB->pPkt = pkt;
+    res=nwal_sendDM(p->nwalInstanceHandle, m->sa_handle,pPktInfoSB);
+    if (res != nwal_OK) 
+    {
+        *err = NETAPI_ERR_NWAL_TX_ERR -res;
+    }
+    return 1;
 }
-//********************************************
-//dummy.  return err
-//********************************************
+
+/********************************************************************
+ * FUNCTION PURPOSE: Stub function for send, do nothing.
+ ********************************************************************
+ * DESCRIPTION: Stub function for send, do nothing.
+ ********************************************************************/
 static int pktio_send_dummy(struct PKTIO_HANDLE_tag * p, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
 {
-       *err =  NETAPI_ERR_BAD_INPUT;
-       return -1;
-} 
-//*******************************************
-//dummy poll
-//*******************************************
+    *err =  NETAPI_ERR_BAD_INPUT;
+    return -1;
+}
+
+/********************************************************************
+ * FUNCTION PURPOSE: Stub function for poll, do nothing.
+ ********************************************************************
+ * DESCRIPTION: Stub function for send, do nothing.
+ ********************************************************************/
 static int pktio_poll_dummy(struct PKTIO_HANDLE_tag * p, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-       *err= NETAPI_ERR_BAD_INPUT;
-       return 0;
+    *err= NETAPI_ERR_BAD_INPUT;
+    return 0;
 }
-//********************************************
-//poll IPC queue
-//********************************************
+
+/********************************************************************
+ * FUNCTION PURPOSE: Poll IPC queue
+ ********************************************************************
+ * DESCRIPTION: Poll IPC queue
+ ********************************************************************/
 static int pktio_poll_ipc(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-int r=0;
-int n;
-Ti_Pkt * temp;
-*err=0;
-n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
-for(r=0;r<n;r++)
-{
+    Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+    PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    int r=0;
+    int n;
+    Ti_Pkt * temp;
+    *err=0;
+    n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
+    for(r=0;r<n;r++)
+    {
 #ifdef PKTIO_GET_BENCHMARK
-      if (r==0) p->vv7p=netapi_timing_stop();
+        if (r==0) p->stats.vv7p=hplib_mUtilGetPmuCCNT();
 #endif
-      temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
+        temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
 
 #ifdef PKTIO_GET_BENCHMARK
-      if (r==0) p->vv10p=netapi_timing_stop();
+        if (r==0) p->stats.vv10p=hplib_mUtilGetPmuCCNT();
 #endif
-      if(!temp) break;
-         /* process meta data */
-         pkt_list[r]= temp;
-         meta_s[r].flags1=0x1;
-      }
-      if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
-      return r;
+        if(!temp) break;
+        /* process meta data */
+        pkt_list[r]= temp;
+        meta_s[r].flags1=0x1;
+    }
+    if (r)
+    {
+        p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
+    }
+    return r;
 }
-//********************************************
-//poll nwal data queues for pkts from netcp
-//********************************************
+
+/********************************************************************
+ * FUNCTION PURPOSE: Poll nwal data queues for pkts from netcp
+ ********************************************************************
+ * DESCRIPTION: Poll nwal data queues for pkts from netcp
+ ********************************************************************/
 static int pktio_poll_nwal(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
-        /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
-         set.. optimizaion maybe? */
+    int r=0;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    *err=0;
+    /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
+        set.  optimizaion maybe? */
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv13p=netapi_timing_stop();
+    p->stats.vv13p=hplib_mUtilGetPmuCCNT();
 #endif
-        r=nwal_pollPkt(p->nwalInstanceHandle,
+    r=nwal_pollPkt(p->nwalInstanceHandle,
                    p->poll_flags,
                    (uint32_t) p,
                    p->max_n,
                    QMSS_PARAM_NOT_SPECIFIED,
                    (void*) NULL);
-        return r;
+    return r;
 }
-//********************************************
-//poll nwal sideband queues for pkts from SA
-//********************************************
+/********************************************************************
+ * FUNCTION PURPOSE: Poll nwal sideband queues for pkts from SA
+ ********************************************************************
+ * DESCRIPTION: Poll nwal sideband queues for pkts from SA
+ ********************************************************************/
 static int  pktio_poll_sb(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
-      r=nwal_pollDm(p->nwalInstanceHandle,
+    int r=0;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    *err=0;
+    r=nwal_pollDm(p->nwalInstanceHandle,
                     nwal_POLL_DM_DEF_SB_SA_Q,
                      (uint32_t) p,
                      p->max_n,
                      QMSS_PARAM_NOT_SPECIFIED,
-                    (void *) NULL);
-      return r;
+             (void *) NULL);
+    return r;
 }
 
-//********************************************
-//poll app-provided netcp rx queue
-//********************************************
+/********************************************************************
+ * FUNCTION PURPOSE: Poll application provided NETCP RX queue
+ ********************************************************************
+ * DESCRIPTION: Poll application provided NETCP RX queue
+ ********************************************************************/
 static int pktio_poll_nwal_adj(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
-        /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
-         set.. optimizaion maybe? */
+    int r=0;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    *err=0;
+    /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
+         set. optimizaion maybe? */
 #ifdef PKTIO_GET_BENCHMARK
-        p->vv14p=netapi_timing_stop();
+    p->stats.vv14p=hplib_mUtilGetPmuCCNT();
 #endif
-        r=nwal_pollPkt(p->nwalInstanceHandle,
+    r=nwal_pollPkt(p->nwalInstanceHandle,
                      nwal_POLL_APP_MANAGED_PKT_Q,
                      (uint32_t) p,
                      p->max_n,
                      p->q,
                      (void *)  NULL);
-        return r;
+    return r;
 }
 
-//********************************************
-//poll app-defined sideband queues for pkts from SA
-//********************************************
+/*************************************************************************
+ * FUNCTION PURPOSE: Poll application defined sideband queues for packets
+ *                   from SA
+ ************************************************************************
+ * DESCRIPTION: Poll application defined sideband queues for packets
+ *                   from SA
+ *************************************************************************/
 static int  pktio_poll_sb_adj(struct PKTIO_HANDLE_tag * pp, PKTIO_POLL_T * p_poll_cfg,  int * err)
 {
-int r=0;
-PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
-*err=0;
-      r=nwal_pollDm(p->nwalInstanceHandle,
+    int r=0;
+    PKTIO_HANDLE_T *p=(PKTIO_HANDLE_T*) pp;
+    *err=0;
+    r=nwal_pollDm(p->nwalInstanceHandle,
                      nwal_POLL_DM_APP_MANAGED_Q,
                      (uint32_t) p,
                      p->max_n,
                      p->q,
                      (void *)  NULL);
-      return r;
+    return r;
 }
 
 /*-----------------------MAIN API----------------------*/
-/* create a channel */
+/********************************************************************
+ * FUNCTION PURPOSE:  API creates a NETAPI PKTIO channel 
+ ********************************************************************
+ * DESCRIPTION:  API creates a NETAPI PKTIO channel 
+ ********************************************************************/
 PKTIO_HANDLE_T * pktio_create(NETAPI_T n, char * name,
                               PKTIO_CB cb, PKTIO_CFG_T * p_cfg, int * err)
 {
-int r = 0;
-PKTIO_HANDLE_T *p;
-uint8_t         isAllocated;
+    int r = 0;
+    PKTIO_HANDLE_T *p;
+    uint8_t         isAllocated;
 
-*err=0;
+    *err=0;
 
-if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
-if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_W)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
-if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_W)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
+    if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
+    if ((p_cfg->flags2 & PKTIO_PKT) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
+    if ((p_cfg->flags2 & PKTIO_SB) &&(p_cfg->flags1& PKTIO_TX)) { *err=NETAPI_ERR_BAD_INPUT; return NULL;};
 
-/* get a free channel handle */
-p=pktiop_get_free_channel_slot(n);
+    /* get a free channel handle */
+    p=pktiop_get_free_channel_slot(n);
 
-if (!p) {*err = PKTIO_NOMEM; return (p); }
+    if (!p) {*err = PKTIO_NOMEM; return (p); }
 
-/* p->inuse= PKTIO_INUSE;   moved to pktiop_get_free_channel_slot */
-p->back = n;
-p->cb = cb;
-p->max_n = p_cfg->max_n;
-p->_poll=pktio_poll_dummy;
-p->_send=pktio_send_dummy;
-memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
+    p->back = n;
+    p->cb = cb;
+    p->max_n = p_cfg->max_n;
+    p->_poll=pktio_poll_dummy;
+    p->_send=pktio_send_dummy;
+    memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
 
     /* create a  general queue (for now). todo: allow qnum to be passed in */
      p->q  = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
@@ -305,8 +351,8 @@ memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
     else
     {
         p->use_nwal=0;
-        if (p_cfg->flags1& PKTIO_W) p->_send=pktio_send_ipc;
-        if (p_cfg->flags1& PKTIO_R) p->_poll=pktio_poll_ipc;
+        if (p_cfg->flags1& PKTIO_TX) p->_send=pktio_send_ipc;
+        if (p_cfg->flags1& PKTIO_RX) p->_poll=pktio_poll_ipc;
     }
 
     /* save name */ 
@@ -315,11 +361,11 @@ memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
                strlen(name):PKTIO_MAX_NAME);   
 
     /* add name, qnum to global name list */
-   if ((strcmp(name,NETCP_RX)) && (strcmp(name,NETCP_TX)) && 
+    if ((strcmp(name,NETCP_RX)) && (strcmp(name,NETCP_TX)) && 
        (strcmp(name,NETCP_SB_RX)) &&
        (strcmp(name,NETCP_SB_TX)) &&
        (p_cfg->flags1 & PKTIO_GLOBAL) )
-   {
+    {
          //todo: make sure this succeeds..
         hplib_mSpinLockLock(&pktio_lock);
         r=netapi_add_global_pktio(n, name, &p->qInfo);
@@ -330,448 +376,311 @@ memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
    return p;
 }
 
-
-/***********************************************************/
-/************** open an existing channel.  *****************/
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API opens an existing  NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION:  API opens an existing  NETAPI PKTIO channel
+ ********************************************************************/
 PKTIO_HANDLE_T * pktio_open(NETAPI_T  n, char *name,
                             PKTIO_CB cb,  PKTIO_CFG_T * p_cfg, int * err)
 {
-int r=0;
-PKTIO_HANDLE_T *p, *p2;
-uint8_t         isAllocated;
-*err=0;
-Qmss_Queue *p_qnum;
+    int r=0;
+    PKTIO_HANDLE_T *p, *p2;
+    uint8_t         isAllocated;
+    *err=0;
+    Qmss_Queue *p_qnum;
 
-if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
+    if ((!p_cfg)||(!name)) {*err=NETAPI_ERR_BAD_INPUT; return NULL;}
 
-/* get a free channel handle */
+    /* get a free channel handle */
 
-p=pktiop_get_free_channel_slot(n);
+    p=pktiop_get_free_channel_slot(n);
 
-if (!p) {*err = PKTIO_NOMEM; return (p); }
-((NETAPI_HANDLE_T *)n)->n_pktios+=1;
+    if (!p) {*err = PKTIO_NOMEM; return (p); }
+    ((NETAPI_HANDLE_T *)n)->n_pktios+=1;
 
-p->inuse= PKTIO_INUSE;
-p->back = n;
-p->cb = cb;
-p->max_n = p_cfg->max_n;
-p->_poll=pktio_poll_dummy;
-p->_send=pktio_send_dummy;
-memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
+    p->inuse= PKTIO_INUSE;
+    p->back = n;
+    p->cb = cb;
+    p->max_n = p_cfg->max_n;
+    p->_poll=pktio_poll_dummy;
+    p->_send=pktio_send_dummy;
+    memcpy((char *)&p->cfg, (char*) p_cfg, sizeof(PKTIO_CFG_T));
 
-/* special handling of NETCP_RX, NETCP_TX */
-if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
-{
-    printf("pktio_open: trace 1\n");
-   /* these have already been opened internally, so don't search in global list */
-    p->use_nwal = PKTIO_DEF_NWAL;
-    p->q = 0;  
-    p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
-    printf("pktio_open1: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
-    if (!strcmp(name,NETCP_RX)) 
+    /* special handling of NETCP_RX, NETCP_TX */
+    if( (!strcmp(name, NETCP_RX)) || (!strcmp(name,NETCP_TX)) )
     {
-       p->_poll=pktio_poll_nwal; 
-       p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|  nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
+       /* these have already been opened internally, so don't search in global list */
+        p->use_nwal = PKTIO_DEF_NWAL;
+        p->q = 0;  
+        p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
+        if (!strcmp(name,NETCP_RX))
+        {
+            p->_poll=pktio_poll_nwal; 
+            p->poll_flags= nwal_POLL_DEFAULT_GLOB_PKT_Q|
+                                    nwal_POLL_DEFAULT_PER_PROC_PKT_Q;
+        }
+        if (!strcmp(name,NETCP_TX))
+        {
+            p->_send=pktio_send_nwal;
+        }
     }
-    if (!strcmp(name,NETCP_TX)) p->_send=pktio_send_nwal;
-}
-else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
-{
-   /* these have already been opened internally, so don't search in global list */
-    p->use_nwal =  PKTIO_DEF_SB;
-    p->q = 0;
-    p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
-    if (!strcmp(name,NETCP_SB_RX)) p->_poll=pktio_poll_sb;
-    if (!strcmp(name,NETCP_SB_TX)) p->_send=pktio_send_sb;
-}
-else
-{
-    hplib_mSpinLockLock(&pktio_lock); 
-    /* find queue in global list */
-    p_qnum = netapi_find_global_pktio(n, name);
-     printf("pktio_open: trace 2\n");
-    
-    hplib_mSpinLockUnlock(&pktio_lock);
- if (!p_qnum ) 
-  {
-        printf(">pktio_open: can't find %s\n",name);
-        p->inuse=0;
-       *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
-        return NULL;
-  }
-
- /* open a  general queue (for now). use qnum that was just found */
-     p->q  = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
-                       p_qnum->qNum , &isAllocated);
-    if (p->q == (Qmss_QueueHnd) NULL)
+    else if( (!strcmp(name, NETCP_SB_RX)) || (!strcmp(name,NETCP_SB_TX)) )
     {
-        printf(">pktio_create:  queueOpen failed\n");
-        p->inuse=0;
-        *err= NETAPI_ERR_QLLD;  ///queue lld error
-        return NULL;
+       /* these have already been opened internally, so don't search in global list */
+        p->use_nwal =  PKTIO_DEF_SB;
+        p->q = 0;
+        p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
+        if (!strcmp(name,NETCP_SB_RX)) p->_poll=pktio_poll_sb;
+        if (!strcmp(name,NETCP_SB_TX)) p->_send=pktio_send_sb;
     }
-    p->qInfo = Qmss_getQueueNumber(p->q);
-    printf("pktio_open: queueMgr %d\,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
-    if (p_cfg->flags2 & PKTIO_PKT)
-    {
-       p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
-       p->_poll = pktio_poll_nwal_adj;
-       p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n); 
-       printf("pktio_open: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
-    } 
-    else if (p_cfg->flags2 & PKTIO_SB)
-    {
-       p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
-       p->_poll = pktio_poll_sb_adj;
-       p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
-    } 
-    else 
+    else
     {
-       p->use_nwal=0; //not handled by nwal
-        if (p_cfg->flags1& PKTIO_W) p->_send=pktio_send_ipc;
-        if (p_cfg->flags1& PKTIO_R) p->_poll=pktio_poll_ipc;
-    }
-}
+        hplib_mSpinLockLock(&pktio_lock); 
+        /* find queue in global list */
+        p_qnum = netapi_find_global_pktio(n, name);
 
-    /* save name */
-    strncpy(p->name,name,
-       strlen(name)<PKTIO_MAX_NAME ?
-               strlen(name):PKTIO_MAX_NAME);
+        hplib_mSpinLockUnlock(&pktio_lock);
+        if (!p_qnum ) 
+        {
+            printf(">pktio_open: can't find %s\n",name);
+            p->inuse=0;
+            *err= NETAPI_ERR_NOTFOUND;  ///queue lld error
+            return NULL;
+      }
+
+     /* open a  general queue (for now). use qnum that was just found */
+         p->q  = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
+                           p_qnum->qNum , &isAllocated);
+        if (p->q == (Qmss_QueueHnd) NULL)
+        {
+            printf(">pktio_create:  queueOpen failed\n");
+            p->inuse=0;
+            *err= NETAPI_ERR_QLLD;  ///queue lld error
+            return NULL;
+        }
+        p->qInfo = Qmss_getQueueNumber(p->q);
+        printf("pktio_open: queueMgr %d,  queueNum; %d\n", p->qInfo.qMgr, p->qInfo.qNum);
+        if (p_cfg->flags2 & PKTIO_PKT)
+        {
+           p->use_nwal = PKTIO_4_ADJ_NWAL;  //additonal RX q for nwal
+           p->_poll = pktio_poll_nwal_adj;
+           p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n); 
+           printf("pktio_open: nwalInstanceHandle 0x%x\n", p->nwalInstanceHandle);
+        } 
+        else if (p_cfg->flags2 & PKTIO_SB)
+        {
+           p->use_nwal = PKTIO_4_ADJ_SB;  //additional RX q for sideband with NWAL
+           p->_poll = pktio_poll_sb_adj;
+           p->nwalInstanceHandle = netapi_return_nwal_instance_handle(n);
+        } 
+        else 
+        {
+           p->use_nwal=0; //not handled by nwal
+            if (p_cfg->flags1& PKTIO_TX) p->_send=pktio_send_ipc;
+            if (p_cfg->flags1& PKTIO_RX) p->_poll=pktio_poll_ipc;
+        }
+    }
 
+        /* save name */
+        strncpy(p->name,name,
+           strlen(name)<PKTIO_MAX_NAME ?
+                   strlen(name):PKTIO_MAX_NAME);
 
-    printf("pktio_open: returning with sucess for name %s\n", p->name);
-return p;
+        printf("pktio_open: returning with sucess for name %s\n", p->name);
+    return p;
 }
 
-/***********************************************************/
-/************** control the channel ****************/
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API controls an existing NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION:  API controls an existing NETAPI PKTIO channel
+ ********************************************************************/
 void pktio_control(PKTIO_HANDLE_T * p,
                    PKTIO_CB cb,
                    PKTIO_CFG_T * p_cfg,
-                  PKTIO_CONTROL_T * p_control,
+           PKTIO_CONTROL_T * p_control,
                    int *err)
 {
-       if (!p) { *err=1; return;}
-       if (cb) 
-        {
-               p->cb = cb;
-       }
-       if (p_control)
+    if (!p)
+    {
+        *err=1; 
+        return;
+    }
+    if (cb) 
+    {
+        p->cb = cb;
+    }
+    if (p_control)
+    {
+        /* todo: check for validity, eg don't allow clear of NETCP TX queues */
+        /* todo: implement divert */
+        switch(p_control->op)
         {
-                /* todo: check for validity, eg don't allow clear of NETCP TX queues */
-               /* todo: implement divert */
-               switch(p_control->op)
-               {
-                       //clear the queue
-                        case(PKTIO_SET_POLL_FLAGS):
-                               p->poll_flags=p_control->poll_flags;
-                               break;
-                       case(PKTIO_CLEAR):
-                               netapi_zapQ(p->q);
-                               break;
-                       case(PKTIO_DIVERT):
-                       default:
-                               printf(">pktio_control: pktio_control op %d not implemented\n",p_control->op);
-                               *err= NETAPI_ERR_NOT_IMPLEMENTED;
-                               break;
-               }
+            //clear the queue
+            case(PKTIO_SET_POLL_FLAGS):
+                p->poll_flags=p_control->poll_flags;
+                break;
+            case(PKTIO_CLEAR):
+                netapi_zapQ(p->q);
+                break;
+            case(PKTIO_DIVERT):
+            default:
+                printf(">pktio_control: pktio_control op %d not implemented\n",p_control->op);
+                *err= NETAPI_ERR_NOT_IMPLEMENTED;
+                break;
         }
-        //all we configure is max_n.  Can't change type of queue, rx/tx, etc
-       if (p_cfg)
-       {
-                       p->max_n = p_cfg->max_n;
-       }
-       *err=0;
-       return;
+    }
+    //all we configure is max_n.  Can't change type of queue, rx/tx, etc
+    if (p_cfg)
+    {
+        p->max_n = p_cfg->max_n;
+    }
+    *err=0;
+    return;
 }
-
-/***********************************************************/
-/*****************close ***************************/
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API closes a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION:  API closes a NETAPI PKTIO channel
+ ********************************************************************/
 void pktio_close(PKTIO_HANDLE_T * p, int * err)
 {
-       if(!p) { *err=1; return;}
-       *err=0;
-       if (p->q) Qmss_queueClose(p->q); //LLD keeps reference count
-        p->q=-1;
-       p->inuse=0;
-        ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
-       return;
+    if(!p) { *err=1; return;}
+    *err=0;
+    if (p->q) Qmss_queueClose(p->q); //LLD keeps reference count
+    p->q=-1;
+    p->inuse=0;
+    ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
+    return;
 }
 
-/***********************************************************/
-/*****************Delete***************************/
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API deletes a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION:  API deletes a NETAPI PKTIO channel
+ ********************************************************************/
 void pktio_delete(PKTIO_HANDLE_T * p, int * err)
 {
-       if(!p) { *err=1; return;}
-       *err=0;
+    if(!p) { *err=1; return;}
+    *err=0;
         /* remove from name list */
     hplib_mSpinLockLock(&pktio_lock);
         netapi_del_global_pktio((NETAPI_HANDLE_T *)p->back, p->name);
     hplib_mSpinLockUnlock(&pktio_lock);
         if((p->use_nwal != PKTIO_DEF_NWAL) && (p->use_nwal != PKTIO_DEF_SB)) 
-       {
-                netapi_zapQ(p->q);   //since we are deleting, zap the queue 
-               Qmss_queueClose(p->q);
-       }
-        p->q=-1;
-        p->inuse=0;
-        ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
-       return ;
-}
-
-
-/***********************************************************/
-/*****************send *************************/
-/***********************************************************/
-int pktio_send_genric(PKTIO_HANDLE_T * p, Ti_Pkt *pkt, PKTIO_METADATA_T *m, int * err)
-{
-    nwalTxPktInfo_t * pPktInfo=m->u.tx_meta;
-    nwal_RetValue res;
-    *err=0;
-    if(! (p->cfg.flags1&PKTIO_W)) return 0;
-    if ((p->use_nwal== PKTIO_DEF_NWAL) )
-    {
-        pPktInfo->pPkt = pkt;
-#ifdef PKTIO_GET_BENCHMARK
-        p->vv11p=netapi_timing_stop();
-#endif
-        res=nwal_send(p->nwalInstanceHandle, m->sa_handle,pPktInfo);
-#ifdef PKTIO_GET_BENCHMARK
-        p->vv12p=netapi_timing_stop();
-#endif
-        if (res != nwal_OK) { printf("nwal send err= %d (%x)\n", res, res);  *err = NETAPI_ERR_NWAL_TX_ERR -res;}
-    }
-        else if ((p->use_nwal== PKTIO_DEF_SB) )
-        {
-                nwalDmTxPayloadInfo_t *pPktInfoSB =  m->u.tx_sb_meta;
-                pPktInfoSB->pPkt = pkt;
-                res=nwal_sendDM(p->nwalInstanceHandle, m->sa_handle,pPktInfoSB);
-                if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
-        }
-    else
     {
-                /* tod: meta data for non netcp xfers */
-            /* process meta data */
-#ifdef PKTIO_GET_BENCHMARK
-        p->vv8p=netapi_timing_stop();
-#endif
-        Qmss_queuePushDesc (p->q, (void*)pkt);
-
-#ifdef PKTIO_GET_BENCHMARK
-        p->vv9p=netapi_timing_stop();
-#endif
+                netapi_zapQ(p->q);   //since we are deleting, zap the queue 
+            Qmss_queueClose(p->q);
     }
-    return 1;
+    p->q=-1;
+    p->inuse=0;
+    ((NETAPI_HANDLE_T *)p->back)->n_pktios-=1;
+    return ;
 }
 
-/***********************************************************/
-/*******************send multiple**************************/
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API sends multiple packets to a NETAPI PKTIO channel
+ ********************************************************************
+ * DESCRIPTION:  API sends multiple packets to a NETAPI PKTIO channel
+ ********************************************************************/
 int pktio_sendMulti(PKTIO_HANDLE_T * p, Ti_Pkt * pkt[], PKTIO_METADATA_T * m[], int np, int* err)
 {
-        nwal_RetValue res;
-       int r=0;
-       *err=0;
-       if(! p->cfg.flags1&PKTIO_W) return 0;
-        if ((p->use_nwal== PKTIO_DEF_NWAL) )
-        {
-               for(r=0;r<np;r++)
-                {
-                        nwalTxPktInfo_t  *pPktInfo= m[r]->u.tx_meta;
-                        pPktInfo->pPkt = pkt[r];
-                        res=nwal_send(p->nwalInstanceHandle,m[r]->sa_handle,pPktInfo);
-                        if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
-                }
-        }
-        else if ((p->use_nwal== PKTIO_DEF_SB) )
-        {
-               for(r=0;r<np;r++)
-                {
-                        nwalDmTxPayloadInfo_t *pPktInfoSB  =m[r]->u.tx_sb_meta;
-                       pPktInfoSB->pPkt = pkt[r];
-                        res=nwal_sendDM(p->nwalInstanceHandle, m[r]->sa_handle,pPktInfoSB);
-                        if (res != nwal_OK) *err = NETAPI_ERR_NWAL_TX_ERR -res;
-                }
-        }
-       else
-       {
-               for(r=0;r<np;r++)
-                {
-                        /* process meta data */
-                        Qmss_queuePushDesc(p->q, (void*) pkt[r]);
-                }
-       }       
-       return r;
-}
-
-/***********************************************************/
-/******************* polling **********************/
-/***********************************************************/
-
-/* poll a particular channel */
-int pktio_poll_generic(PKTIO_HANDLE_T * p, PKTIO_POLL_T * p_poll_cfg,  int * err)
-{
-int r=0;
-int n;
-Ti_Pkt * temp;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
-//uint64_t ts= netapi_getTimestamp();  //get_ts
-uint64_t ts=0LL;
-
-        if(! p->cfg.flags1&PKTIO_R) return 0;
-
-       /** poll the netcp default RX queue we squirt out below */
-       if (p->use_nwal==PKTIO_DEF_NWAL)
-       {
-               /* Poll for common L2/L3 packets and L4 class pkts (todo-> only do L4 if classifiers are
-                   set.. optimizaion maybe? */
-#ifdef PKTIO_GET_BENCHMARK
-            p->vv13p=netapi_timing_stop();
-#endif
-               r=nwal_pollPkt(p->nwalInstanceHandle,
-                     p->poll_flags,
-                     (uint32_t) p,
-                     p->max_n,
-                     QMSS_PARAM_NOT_SPECIFIED,
-                     (void*) NULL);
-       }
-       /** poll a netcp RX queue. we squirt out below */
-       else if (p->use_nwal==PKTIO_4_ADJ_NWAL)
-       {
-               /* Poll an additional NETCP RX queue */
-#ifdef PKTIO_GET_BENCHMARK
-               p->vv14p=netapi_timing_stop();
-#endif
-               r=nwal_pollPkt(p->nwalInstanceHandle,
-                     nwal_POLL_APP_MANAGED_PKT_Q,
-                     (uint32_t) p,
-                     p->max_n,
-                     p->q,
-                     (void *)  NULL);
-       }
-        /** poll the NETCP default SideBand (data mode -dm) return queue **/
-        else if(p->use_nwal==PKTIO_DEF_SB)
-        {
-                r=nwal_pollDm(p->nwalInstanceHandle,
-                     nwal_POLL_DM_DEF_SB_SA_Q,
-                     (uint32_t) p,
-                     p->max_n,
-                     QMSS_PARAM_NOT_SPECIFIED,
-                     (void *)  NULL);
-
-        }
-        /** poll an app define SideBand (data mode -dm) return queue **/
-       else if (p->use_nwal==PKTIO_4_ADJ_SB)
-        {            
-                 r=nwal_pollDm(p->nwalInstanceHandle,
-                     nwal_POLL_DM_APP_MANAGED_Q,
-                     (uint32_t) p,
-                     p->max_n,
-                     p->q,
-                     (void *)  NULL);
-        }
-
-       /* poll an IPC queue */
-       else 
-       {
-               *err=0;
-               n= (p->max_n< PKTIO_MAX_RECV) ? p->max_n : PKTIO_MAX_RECV;
-               for(r=0;r<n;r++)
-               {
-#ifdef PKTIO_GET_BENCHMARK
-            if (r==0) p->vv7p=netapi_timing_stop();
-#endif
-                       temp=(Ti_Pkt*)(Cppi_HostDesc*)QMSS_DESC_PTR(Qmss_queuePop(p->q));
-
-#ifdef PKTIO_GET_BENCHMARK
-            if (r==0) p->vv10p=netapi_timing_stop();
-#endif
-                       if(!temp) break;
-                                /* process meta data */
-                       pkt_list[r]= temp;
-                       meta_s[r].flags1=0x1;
-               }       
-               if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, ts);
-       }
-       return r;
+    int r=0;
+    for(r=0;r<np;r++)
+    {
+        p->_send((struct PKTIO_HANDLE_tag *)p, pkt, m, err);
+    }
+    return r;
 }
 
-/***********************************************************/
-/** poll all channels attached to this handle */
-/***********************************************************/
+/********************************************************************
+ * FUNCTION PURPOSE:  API polls all NETAPI PKTIO channels associated with NETAPI_T
+ * instance for received packets
+ ********************************************************************
+ * DESCRIPTION:  API polls all NETAPI PKTIO channels associated with NETAPI_T
+ * instance for received packets
+ ********************************************************************/
 int pktio_pollAll(NETAPI_T  handle, PKTIO_POLL_T * p_poll_cfg, int *err)
 {
-int i=0;
-int r=0;
-int err2;
-int cnt=0;
-PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
-*err=0;
-for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
-{
-    if (pp[i]->inuse != PKTIO_INUSE) continue;
-    if(!(pp[i]->cfg.flags1&PKTIO_R)) continue;
-    r+=pktio_poll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
-    if (err2) { *err = err2; break;}
-}
-return r;
+    int i=0;
+    int r=0;
+    int err2;
+    int cnt=0;
+    PKTIO_HANDLE_T **pp =( PKTIO_HANDLE_T **)  netapi_get_pktio_list(handle);
+    
+    *err=0;
+    for(i=0;i<NETAPI_MAX_PKTIO && cnt < ((NETAPI_HANDLE_T *)handle)->n_pktios;i++)
+    {
+        if (pp[i]->inuse != PKTIO_INUSE) continue;
+        if(!(pp[i]->cfg.flags1&PKTIO_RX)) continue;
+        r+=pktio_poll(pp[i],  p_poll_cfg,  &err2); cnt+=1;
+        if (err2) { *err = err2; break;}
+    }
+    return r;
 
 }
 
-/***** this is the callback we registered with NWAL for pkt reception *****/
-/* appcookie -> pktio handle */
+
+/**********************************************************************
+ * FUNCTION PURPOSE:  Callback that gets registered with NWAL for packet reception
+ **********************************************************************
+ * DESCRIPTION:  Callback that gets registered with NWAL for packet reception
+ * appCookie is the pktio handle 
+ **********************************************************************/
 void netapi_NWALRxPktCallback     (uint32_t            appCookie,
                                 uint16_t             numPkts,
                                 nwalRxPktInfo_t*    pPktInfo,
                                 uint64_t            timestamp,
                                 nwal_Bool_t*        pFreePkt)
 {
-PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
-int r=0;
-int n;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+    PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
+    int r=0;
+    int n;
+    Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+    PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
 
 #ifdef PKTIO_GET_BENCHMARK
-    p->vv15p=netapi_timing_stop();
+    p->stats.vv15p=hplib_mUtilGetPmuCCNT();
 #endif
     for(r=0;r<numPkts;r++)
     {
-         pkt_list[r] = pPktInfo[r].pPkt;
-        meta_s[r].flags1 = PKTIO_META_RX;
-        meta_s[r].u.rx_meta = &pPktInfo[r];
+        pkt_list[r] = pPktInfo[r].pPkt;
+        meta_s[r].flags1 = PKTIO_META_RX;
+        meta_s[r].u.rx_meta = &pPktInfo[r];
+    }
+    if (r)
+    {
+        p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
     }
-    if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, timestamp);
-
 }
 
-/***** this is the callback we registered with NWAL for crypto callbcak *****/
-/* appcookie -> pktio handle */
+
+/**********************************************************************
+ * FUNCTION PURPOSE:  Callback that gets registered with NWAL for crypto reception
+ **********************************************************************
+ * DESCRIPTION:  Callback that gets registered with NWAL for crypto reception,
+ * appCookie is the pktio handle 
+ **********************************************************************/
 void netapi_NWALSBPktCallback     (uint32_t            appCookie,
                                 uint16_t             numPkts,
                                 nwalDmRxPayloadInfo_t*  pDmRxPktInfo,
                                 nwal_Bool_t*        pFreePkt)
 {
-PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
-int r=0;
-int n;
-Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
-PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
+    PKTIO_HANDLE_T * p = (PKTIO_HANDLE_T *) appCookie;
+    int r=0;
+    int n;
+    Ti_Pkt * pkt_list[PKTIO_MAX_RECV];
+    PKTIO_METADATA_T meta_s[PKTIO_MAX_RECV];
     for(r=0;r<numPkts;r++)
     {
-         pkt_list[r] = pDmRxPktInfo[r].pPkt;
-         meta_s[r].flags1 =  PKTIO_META_SB_RX;
-         meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
+        pkt_list[r] = pDmRxPktInfo[r].pPkt;
+        meta_s[r].flags1 =  PKTIO_META_SB_RX;
+        meta_s[r].u.rx_sb_meta = &pDmRxPktInfo[r];
+    }
+    if (r)
+    {
+        p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
     }
-    if (r) p->cb((struct PKTIO_HANDLE_tag *)p, pkt_list, &meta_s[0], r, 0LL);
-
 }
 
-                                                  
-
index d5ef58af5a2d1c6326c342f9256ed8ebeea63f7e..e0db4daf4d015951bac357301ae840e4aa2e1ef6 100755 (executable)
@@ -193,12 +193,12 @@ PKTIO_HANDLE_T *netcp_rx_chan2;
 PKTIO_HANDLE_T *netcp_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_rx_chan;
-PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T our_chan_cfg={PKTIO_RX_TX, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
 
 void house(NETAPI_SCHED_HANDLE_T *s);
 NETAPI_T netapi_handle;
index 6a550d27524c4105ff1891e34ecdfcd5815194c4..2f2e0f89f46d9f679f8846292d93ccc21c2218ac 100755 (executable)
@@ -208,12 +208,12 @@ PKTIO_HANDLE_T *netcp_rx_chan2;
 PKTIO_HANDLE_T *netcp_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_rx_chan;
-PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T our_chan_cfg={PKTIO_RX_TX, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
 
 void house(NETAPI_SCHED_HANDLE_T *s);
 NETAPI_T netapi_handle;
@@ -909,7 +909,7 @@ static int done_burst=0;
 void house(NETAPI_SCHED_HANDLE_T * s)
 {
     int err;
-    if (QUIT) {netapi_schedShutdown(s,NULL,&err); return;}
+    if (QUIT) {netapi_schedClose(s,NULL,&err); return;}
 }
 
 void  build_sa_db(int i)
@@ -1417,7 +1417,7 @@ count = 0;
 #endif
 
             
-    netapi_schedWaitForEvents(scheduler[coreid], &err);
+    netapi_schedRun(scheduler[coreid], &err);
             
     printf(">net_test: core %d worker thread done\n",coreid);
     pktio_close(tx_chan, &err);
@@ -1606,7 +1606,7 @@ sleep(1);
         }
 #endif
 
-    netapi_schedWaitForEvents(scheduler[coreid], &err);
+    netapi_schedRun(scheduler[coreid], &err);
     printf(">net_test: core %d worker thread done\n",coreid);
     pktio_close(tx_chan, &err);
     pktio_close(rx_chan, &err);
@@ -1784,7 +1784,7 @@ int main(int argc, char **argv)
     /*********************************************/
     /**************Entry point into scheduler ****/
     /*********************************************/
-    netapi_schedWaitForEvents(our_sched, &err);
+    netapi_schedRun(our_sched, &err);
 
 #endif
 
index a4f33f8b58e84d9b916439a0f3cadc6bf6d9136c..9b98f8ecb52c59e6cf704685f634730edbbfd55e 100755 (executable)
@@ -259,7 +259,7 @@ static uint8_t testPkt[] = {
 };
 
 char    input_file_name[] = "net_test_config.txt";
-#define MAX_LINE_LENGTH 40
+#define MAX_LINE_LENGTH 256
 
 #define TEST_PAYLOAD_LEN            80
 
@@ -362,7 +362,13 @@ netTestConfig_t config =
     {192,168 , 1, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
     IPSEC_MODE_RX_SIDEBAND,
     IPSEC_MODE_TX_SIDEBAND,
-    0
+    0,
+    {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
+         0x20, 0x21, 0x22, 0x23 },
+    {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+         0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+         0x30, 0x31, 0x32, 0x33 }
 };
 
 #if 1  //goes with real tx (to laptop) 
@@ -417,12 +423,12 @@ PKTIO_HANDLE_T *netcp_rx_chan2;
 PKTIO_HANDLE_T *netcp_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_tx_chan;
 PKTIO_HANDLE_T *netcp_sb_rx_chan;
-PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
-PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
-PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T our_chan_cfg={PKTIO_RX_TX, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
+PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
+PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
 
 void house(NETAPI_SCHED_HANDLE_T *s);
 NETAPI_T netapi_handle;
@@ -488,7 +494,7 @@ NETCP_CFG_CLASSIFIER_T class_2_cfg=
 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
 
 /* security objects. (for loopback mode) */
-netTestSA_t sa_info[7];
+netTestSA_t sa_info[8];
 int netapi_algorithm_set = 0;
 int netapi_sec_sa_mode = 2;
 
@@ -496,7 +502,7 @@ NETCP_CFG_IPSEC_POLICY_T rx_policy[7];
 
 
 
-NETAPI_SEC_SA_INFO_T rx_sa [7] = {
+NETAPI_SEC_SA_INFO_T rx_sa [8] = {
 {
     NWAL_SA_DIR_INBOUND,
     0x11111111,  //spi
@@ -587,11 +593,24 @@ NETAPI_SEC_SA_INFO_T rx_sa [7] = {
     NWAL_SA_AALG_AES_XCBC,
     NWAL_SA_EALG_NULL,
     0,0  //na
+},
+{
+    NWAL_SA_DIR_INBOUND,
+    0x88888888,  //spi
+    nwal_IpSecProtoESP, //ESP mode
+    nwal_SA_MODE_TUNNEL,  //tunnel mode
+    nwal_IPV4, //v4
+    { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
+    { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
+    64,/* replayWindow */
+    NWAL_SA_AALG_GMAC,
+    NWAL_SA_EALG_NULL,
+    0,0  //na
 }
 };
 
 /*tx */
-NETAPI_SEC_SA_INFO_T tx_sa[7]= {
+NETAPI_SEC_SA_INFO_T tx_sa[8]= {
 {
     NWAL_SA_DIR_OUTBOUND,
     0x11111111,  //spi
@@ -681,11 +700,24 @@ NETAPI_SEC_SA_INFO_T tx_sa[7]= {
     NWAL_SA_AALG_AES_XCBC,
     NWAL_SA_EALG_NULL,
     0,0  //na
+},
+{
+    NWAL_SA_DIR_OUTBOUND,
+    0x88888888,  //spi
+    nwal_IpSecProtoESP, //ESP mode
+    nwal_SA_MODE_TUNNEL,  //tunnel mode
+    nwal_IPV4, //v4
+    { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
+    { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
+    64,/* replayWindow */
+    NWAL_SA_AALG_GMAC,
+    NWAL_SA_EALG_NULL,
+    0,0  //na
 }
 };
 
 
-static nwalSecKeyParams_t ourTXKeyParams[7] ={
+static nwalSecKeyParams_t ourTXKeyParams[8] ={
 {
     32, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
@@ -727,11 +759,17 @@ static nwalSecKeyParams_t ourTXKeyParams[7] ={
     16, /* macKeySize 0*/
     NULL, //set below
     NULL, //set below
+},
+{
+    0, /* encKeySize: GMAC  16 bytes Encryption Key and4  bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
+    20, /* macKeySize 0*/
+    NULL, //set below
+    NULL, //set below
 }
 };
 
 /* these keys are for aes-ctr and hmac sha2_256 */
-static nwalSecKeyParams_t ourRXKeyParams[7] ={
+static nwalSecKeyParams_t ourRXKeyParams[8] ={
 {
     32, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
@@ -773,10 +811,17 @@ static nwalSecKeyParams_t ourRXKeyParams[7] ={
     16, /* macKeySize 0*/
     NULL, //set below
     NULL, //set below
+},
+{
+    0, /* encKeySize: GMAC 16 bytes Encryption Key and 3 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
+    20, /* macKeySize 0*/
+    NULL, //set below
+    NULL, //set below
 }
 };
 
 
+#if 0
 static uint8_t ourAuthKey[36] =
         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
@@ -787,7 +832,7 @@ static uint8_t ourEncrKey[36] =
         {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
          0x30, 0x31, 0x32, 0x33 }; 
-
+#endif
 
 /*************************END NETAPI OBJECTS***********************/
 
@@ -1036,10 +1081,10 @@ for(i=0;i<ntrials;i++)
    timings[8]+=(vv11-vv6);
 
 #ifdef PKTIO_GET_BENCHMARK
-   timings[2]+=(our_chan->vv7p-vv4);
-   timings[4]+=(our_chan->vv8p-vv3);
-   timings[6]+=(our_chan->vv9p-our_chan->vv8p);
-   timings[7]+=(our_chan->vv10p-our_chan->vv7p);
+   timings[2]+=(our_chan->stats.vv7p-vv4);
+   timings[4]+=(our_chan->stats.vv8p-vv3);
+   timings[6]+=(our_chan->stats.vv9p-our_chan->stats.vv8p);
+   timings[7]+=(our_chan->stats.vv10p-our_chan->stats.vv7p);
 #endif
 }
 
@@ -1268,7 +1313,8 @@ int coreid=0;
             meta_tx.pAad=NULL;
             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
             {
-                memcpy(&p_iv[0], &ourEncrKey[16], 4);
+                //memcpy(&p_iv[0], &ourEncrKey[16], 4);
+                memcpy(&p_iv[0], &config.encr_key[16], 4);
                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
                 p_iv[12] = 0;
                 p_iv[13] = 0;
@@ -1278,13 +1324,21 @@ int coreid=0;
             }
             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
                 (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
-                {
-                        memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
-                        meta_tx.pEncIV = &p_iv[0];
-                        memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
-                        meta_tx.pAad= &p_add[0];
-                        meta_tx.aadSize = 8;
-                }
+            {
+                memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
+                meta_tx.pEncIV = &p_iv[0];
+                memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
+                meta_tx.pAad= &p_add[0];
+                meta_tx.aadSize = 8;
+            }
+            else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
+            {
+                memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
+                meta_tx.pAuthIV= &p_iv[0];
+                memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
+                meta_tx.pAad= &p_add[0];
+                meta_tx.aadSize = 8;
+            }
             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
             {
                 meta_tx.pEncIV = NULL;
@@ -1308,7 +1362,7 @@ int coreid=0;
             * SA
             */
             nwalRetVal =  
-            nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
+            nwal_getLocCxtInfo(pktio_mGetNwalInstance(netcp_sb_tx_chan),
                                                       &nwalLocCxt);
             if(nwalRetVal == nwal_OK)
             {
@@ -1680,7 +1734,6 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
     p_head=&temp_head;
 
 
-    printf("recv_cb: entered with n_pkts %d\n", n_pkts);
     /* loop over received pkts */
     for(i=0;i<n_pkts;i++)
     {
@@ -1693,8 +1746,7 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
         Pktlib_setPacketLen(tip,len);
-        //printf("recv_cb() packet len %d\n", len);
-        printf("recv_cb:flags: 0x%x, appid 0x%x\n", (unsigned int)meta[i].u.rx_meta->rxFlag1, (unsigned int)meta[i].u.rx_meta->appId);
+
         if(((unsigned int)meta[i].u.rx_meta->appId) == expPkt_appid)
         {
             printf("recv_cb: received exception packet\n");
@@ -1794,7 +1846,8 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
 
                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
                 {
-                    memcpy(&p_iv[0], &ourEncrKey[16], 4);
+                    //memcpy(&p_iv[0], &ourEncrKey[16], 4);
+                     memcpy(&p_iv[0], &config.encr_key[16], 4);
                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
                     p_iv[12] = 0;
                     p_iv[13] = 0;
@@ -1803,7 +1856,7 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
                     meta_tx.pEncIV = &p_iv[0];
                  
                 }
-                else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM)  ||
+                else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
                 {
                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
@@ -1813,6 +1866,15 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
                         meta_tx.pAad= &p_add[0];
                         meta_tx.aadSize = 8;
                 }
+                else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
+                {
+                    memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
+                        meta_tx.pAuthIV= &p_iv[0];
+                        /* aad is the ESP header which is 8 bytes */
+                        memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
+                        meta_tx.pAad= &p_add[0];
+                        meta_tx.aadSize = 8;
+                }
                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
                 {
                     meta_tx.pEncIV = NULL;
@@ -1838,7 +1900,7 @@ void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
             * SA
             */
             nwalRetVal =  
-            nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
+            nwal_getLocCxtInfo(pktio_mGetNwalInstance(netcp_sb_tx_chan),
                                                       &nwalLocCxt);
             if(nwalRetVal == nwal_OK)
             {
@@ -2087,13 +2149,13 @@ NETAPI_SA_STATS_T netapi_sa_stats;
     }
 
 #ifdef MULTI_THREAD
-    netapi_sched_get_stats(scheduler[0],&tmp_npL[0],&tmp_cyclesL[0],&tmp_ccyclesL[0]);
-    netapi_sched_get_stats(scheduler[1],&tmp_npL[1],&tmp_cyclesL[1],&tmp_ccyclesL[1]);
+    netapi_schedGetStats(scheduler[0],&tmp_npL[0],&tmp_cyclesL[0],&tmp_ccyclesL[0]);
+    netapi_schedGetStats(scheduler[1],&tmp_npL[1],&tmp_cyclesL[1],&tmp_ccyclesL[1]);
 npL = tmp_npL[0]+tmp_npL[1];
 cyclesL = tmp_cyclesL[0]+tmp_cyclesL[1];
 ccyclesL = tmp_ccyclesL[0]+tmp_ccyclesL[1];
 #else
-netapi_sched_get_stats(our_sched, &npL,&cyclesL,&ccyclesL);
+netapi_schedGetStats(our_sched, &npL,&cyclesL,&ccyclesL);
 #endif
 
 if(pPaStats)
@@ -2251,10 +2313,10 @@ Cppi_HostDesc*      pPktDesc;
 
 int coreid = 0;  //who we are
 #ifdef MULTI_THREAD
-NETAPI_T nh= netapi_schedGetNetapiHandle(s);
+NETAPI_T nh= netapi_schedGetHandle(s);
 coreid=(int) netapi_getCookie(nh);
 
-if (QUIT) {netapi_schedShutdown(s,NULL,&err); return;}
+if (QUIT) {netapi_schedClose(s,NULL,&err); return;}
 
 if (coreid==0) //slave
 {
@@ -2269,7 +2331,7 @@ if(done_burst)
   if (err!=0) {printf("stats req failed\n");}
   if (house_pkts_gened >= np2process+ 100)
   {
-     netapi_schedShutdown(s,NULL,&err);
+     netapi_schedClose(s,NULL,&err);
   }
   return;
 }
@@ -2289,7 +2351,7 @@ if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
   if (house_pkts_gened >= np2process+ 100)
   {
      //shutdown
-     netapi_schedShutdown(s,NULL,&err);
+     netapi_schedClose(s,NULL,&err);
      continue;
   }
 
@@ -2347,7 +2409,7 @@ if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
    {
        first++;
        nwal_flow_vv1= hplib_mUtilGetPmuCCNT();
-       if(nwal_initPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan),
+       if(nwal_initPSCmdInfo(pktio_mGetNwalInstance(netcp_tx_chan),
                              &meta_tx,
                              &flowPSCmdInfo) != nwal_OK)
        {
@@ -2768,6 +2830,58 @@ void  build_sa_db(int i)
         tmp_spi = htonl((long)(tx_sa[i].spi));
          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
     }
+    else if ((tx_sa[i].authMode == NWAL_SA_AALG_GMAC) && (rx_sa[i].cipherMode == NWAL_SA_EALG_NULL))
+    {
+        /* static configuration, will not change */
+        sa_info[i].tx_payload_info.aadSize = 0;
+        sa_info[i].tx_payload_info.pAad = NULL;
+        sa_info[i].tx_payload_info.pAuthIV = NULL;
+        sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
+
+
+        sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
+                                                                     netTest_IP_HEADER_LEN +
+                                                                    netTest_ESP_HEADER_LEN +
+                                                                    netTest_AES_GMAC_IV_LEN;
+#ifdef EXPERIMENTAL
+        sa_info[i].iv_len=0;
+        sa_info[i].bl=4;
+        sa_info[i].spi = tx_sa[i].spi;
+        sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
+        sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
+#endif
+
+
+        /* dynamic configuration, will  be calculated on the fly */
+        sa_info[i].tx_payload_info.authSize = 0;
+        sa_info[i].tx_payload_info.encSize = 0;
+        //sa_info[i].tx_payload_info.ploadLen = 0;
+        sa_info[i].tx_payload_info.pEncIV = 0;
+         sa_info[i].tx_payload_info.pAuthIV = 0;
+        sa_info[i].tx_payload_info.pPkt = 0;
+
+        sa_info[i].cipherMode = NWAL_SA_EALG_NULL;
+        sa_info[i].authMode = NWAL_SA_AALG_GMAC;
+        sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
+        sa_info[i].auth_tag_size = netTest_AES_GMAC_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM , GMAC*/
+
+        sa_info[i].tx_pkt_info.enetPort = 0;
+        sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
+        sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
+        sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
+        sa_info[i].tx_pkt_info.startOffset = 0;
+        sa_info[i].tx_pkt_info.lpbackPass = 0;
+        sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
+        sa_info[i].tx_pkt_info.pPkt = NULL;
+        sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
+        sa_info[i].tx_pkt_info.saPayloadLen = 0;
+        sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
+       
+        sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
+        
+        tmp_spi = htonl((long)(tx_sa[i].spi));
+         trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
+    }
     else
         printf("build_sa_db(): invalid encryption/authentication combination selected\n");
 
@@ -2821,6 +2935,36 @@ void parse_one_mac(char * p_mac_str, unsigned char *p_mac)
          printf("************mac0[%d]: 0x%x\n",i,  p_mac[i]);
 }
 
+
+void parse_one_key(char *p_key_str, unsigned char *p_key)
+{
+    int index = 0;
+    int i;
+     char * pch = strtok (&p_key_str[0],",");
+
+    while (pch != NULL)
+    {
+         printf ("%s\n",pch);
+         p_key[index] = hex2dec(pch);
+         index++;
+         pch = strtok (NULL,",");
+    }
+     printf("index value for parse-auth_key: %d\n", index);
+    for (i=0; i<36;i++)
+         printf("************mac0[%d]: 0x%x\n",i, p_key[i]);
+}
+
+void parse_key(netTestConfigFile_t *pConfig)
+{
+     if (strlen(&pConfig->auth_key[0]))
+        parse_one_key(&pConfig->auth_key[0],&config.auth_key[0]);
+    if (strlen(&pConfig->mac1[0]))
+        parse_one_key(&pConfig->encr_key[0],&config.encr_key[0]); 
+}
+
+
+
+
 void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
 {
     int index = 0;
@@ -2837,8 +2981,6 @@ void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
     printf("index value : %d\n", index);
     for (i=0; i<4;i++)
         printf("************ip[%d]: 0x%x\n",i, p_ip[i]);
-
-
 }
 
 void parse_mac_address(netTestConfigFile_t *pConfig)
@@ -2982,6 +3124,9 @@ static void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_RX,&(pConfig->ipsec_mode_rx[0]));
          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_TX,&(pConfig->ipsec_mode_tx[0]));
          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_IF_NO,&(pConfig->ipsec_if_no[0]));
+         CHECK_SET_PARAM(INIT_CONFIG_AUTH_KEY,&(pConfig->auth_key[0]));
+         CHECK_SET_PARAM(INIT_CONFIG_ENCR_KEY,&(pConfig->encr_key[0]));
+         
 #ifdef EXPERIMENTAL
     for(i=0;i<MAX_ROUTES;i++)
     {
@@ -3001,6 +3146,9 @@ static void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
     parse_ip_address(pConfig);
 
     parse_ipsec_mode(pConfig);
+
+    parse_key(pConfig);
+    
 #ifdef EXPERIMENTAL
      if (strlen(&pConfig->ipsec_if_no[0]))
         config.ipsec_if_no = atoi(&pConfig->ipsec_if_no[0]);
@@ -3073,7 +3221,7 @@ void slow_path_thread(int coreid)
             /*********************************************/
     /**************Entry point into scheduler ****/
     /*********************************************/
-    netapi_schedWaitForEvents(scheduler[coreid], &err);
+    netapi_schedRun(scheduler[coreid], &err);
     printf(">net_test: core %d worker thread done\n",coreid);
     pktio_close(tx_chan, &err);
     pktio_close(rx_chan, &err);
@@ -3138,7 +3286,7 @@ void fast_path_thread(int coreid)
      scheduler[coreid]->config.pollGarbageQ = FALSE;
      scheduler[coreid]->config.pollCtrlQ = FALSE;
      //sleep(100000);
-    netapi_schedWaitForEvents(scheduler[coreid], &err);
+    netapi_schedRun(scheduler[coreid], &err);
     printf(">net_test: core %d worker thread done\n",coreid);
     pktio_close(tx_chan, &err);
     pktio_close(rx_chan, &err);
@@ -3444,8 +3592,8 @@ if (err) {printf("addclass2 failed %d\n",err); exit(1);}
 
     for (i=0; i < MAX_SEC_INDEX;i++)
     {
-        ourRXKeyParams[i].pEncKey = &ourEncrKey[0];
-        ourRXKeyParams[i].pAuthKey = &ourAuthKey[0];
+        ourRXKeyParams[i].pEncKey = &config.encr_key[0];
+        ourRXKeyParams[i].pAuthKey = &config.auth_key[0];
         memcpy(&(rx_sa[i].src), &config.remote_ipsec_ip,4);
         memcpy(&(rx_sa[i].dst), &config.local_ipsec_ip,4);
 
@@ -3488,7 +3636,7 @@ if (err) {printf("addclass2 failed %d\n",err); exit(1);}
     if(config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
     {
             nwalRetVal =  
-            nwal_initDMPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_rx_chan),
+            nwal_initDMPSCmdInfo(pktio_mGetNwalInstance(netcp_sb_rx_chan),
                                  sa_info[i].rx_data_mode_handle,
                                  &sa_info[i].rx_dmPSCmdInfo);
     }
@@ -3500,11 +3648,12 @@ if (err) {printf("addclass2 failed %d\n",err); exit(1);}
 //security stuff 
      for (i=0; i < MAX_SEC_INDEX;i++)
     {
-    ourTXKeyParams[i].pEncKey = &ourEncrKey[0];
-    ourTXKeyParams[i].pAuthKey = &ourAuthKey[0];
-    memcpy(&(tx_sa[i].src), &config.local_ipsec_ip,4);
-    memcpy(&(tx_sa[i].dst), &config.remote_ipsec_ip,4);
-    sa_info[i].tx_tunnel = netapi_secAddSA( netapi_handle,
+        ourTXKeyParams[i].pEncKey = &config.encr_key[0];
+        ourTXKeyParams[i].pAuthKey = &config.auth_key[0];
+
+        memcpy(&(tx_sa[i].src), &config.local_ipsec_ip,4);
+        memcpy(&(tx_sa[i].dst), &config.remote_ipsec_ip,4);
+        sa_info[i].tx_tunnel = netapi_secAddSA( netapi_handle,
                  0, //iface #0 
                 &(tx_sa[i]),
                 &ourTXKeyParams[i],
@@ -3513,7 +3662,7 @@ if (err) {printf("addclass2 failed %d\n",err); exit(1);}
                 &(sa_info[i].tx_data_mode_handle),
                 &(sa_info[i].tx_inflow_mode_handle),
                 &err);
-if (err) {printf("addTxSa failed %d\n",err); exit(1);}
+    if (err) {printf("addTxSa failed %d\n",err); exit(1);}
 
 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
 
@@ -3524,7 +3673,7 @@ if (err) {printf("addTxSa failed %d\n",err); exit(1);}
     if(config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
     {
             nwalRetVal =  
-            nwal_initDMPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
+            nwal_initDMPSCmdInfo(pktio_mGetNwalInstance(netcp_sb_tx_chan),
                                  sa_info[i].tx_data_mode_handle,
                                  &sa_info[i].tx_dmPSCmdInfo);
     }
@@ -3539,13 +3688,13 @@ if (err) {printf("addTxSa failed %d\n",err); exit(1);}
         memcpy(&(nwalSaIpSecId.dst), &config.remote_ipsec_ip,sizeof( nwalIpAddr_t));
         nwalSaIpSecId.proto= tx_sa[i].proto;
 
-        nwalRetVal = nwal_initPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan), 
+        nwalRetVal = nwal_initPSCmdInfo(pktio_mGetNwalInstance(netcp_tx_chan), 
                                                             &sa_info[i].tx_pkt_info,
                                                             &sa_info[i].tx_psCmdInfo);
 
         if (nwalRetVal == nwal_OK)
         {
-             if (nwal_getSecAssoc(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan),
+             if (nwal_getSecAssoc(pktio_mGetNwalInstance(netcp_tx_chan),
                                 &nwalSaIpSecId, 
                                 NWAL_SA_DIR_OUTBOUND,
                                 &(sa_info[i].tx_inflow_mode_handle),
@@ -3685,7 +3834,7 @@ srand((unsigned) np2process);
     /*********************************************/
     /**************Entry point into scheduler ****/
     /*********************************************/
-    netapi_schedWaitForEvents(our_sched, &err);
+    netapi_schedRun(our_sched, &err);
 
 #endif
 
@@ -3786,13 +3935,13 @@ for(i=0;i<n_trials;i++)
 {
     //raw pop
     t1= hplib_mUtilGetPmuCCNT();
-    pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
+    pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));
     for(j=1;j<NTOPOP;j++)
     {
        tempVA  =  hplib_mVMPhyToVirt(pHd[j-1]);
        netapi_pld(tempVA);
         //__builtin_prefetch(tempVA);
-       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
+       pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (freeQ));
        sumf+= (int) (   ((Cppi_HostDesc *) tempVA)->origBuffPtr -
                   ((Cppi_HostDesc *) tempVA)->buffPtr);
     }
@@ -3813,7 +3962,7 @@ for(i=0;i<n_trials;i++)
     t1=hplib_mUtilGetPmuCCNT();
     for(j=0;j<NTOPOP;j++)
     {
-        PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
+        pktio_mQmssQueuePushDescSizeRaw (freeQ,
                                              (void *) pHd[j],
                                              128);
     }
@@ -3848,13 +3997,13 @@ unsigned long totlen=0;
 int max_batch=0;
 
 //this should  be done once and saved
-Qmss_QueueHnd rxQ= PKTIO_GET_DEFAULT_NETCP_Q(p_pktio);
+Qmss_QueueHnd rxQ= pktio_mGetDefaultNetCpQ(p_pktio);
 Qmss_QueueHnd freeQ;
 //loop forever
 for(;max_pkts>0;)
 {
     t1= hplib_mUtilGetPmuCCNT();
-    pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
+    pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (rxQ));
     if (!pHd[0]) continue;
     //got pkt
     for(i=1;(i<n) && (pHd[i-1]);i++)
@@ -3867,7 +4016,7 @@ for(;max_pkts>0;)
         //netapi_pld(tempVA);
 
         //read next descriptor from queue 
-        pHd[i] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
+        pHd[i] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (rxQ));
 #if 1   
         /* extract some meta data */
         Cppi_getData (Cppi_DescType_HOST, (Cppi_Desc*)tempVA, &buf[jj], &len[jj]);
@@ -3938,7 +4087,7 @@ for(;max_pkts>0;)
         // descriptor chain 
         t11= hplib_mUtilGetPmuCCNT();
        // Pktlib_freePacket(tempVA);
-        PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
+        pktio_mQmssQueuePushDescSizeRaw (freeQ,
                                              (void *) pHd[k],
                                              128);
 
@@ -3966,12 +4115,12 @@ for(;max_pkts>0;)
     //cleanup any remaining buffers
     for(;;)
     {
-        pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
+        pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(pktio_mQmssQueuePopRaw (rxQ));
         if(!pHd[0]) break;
        tempVA  =  Osal_qmssPhyToVirt(pHd[0]);
         freeQ=Qmss_getQueueHandle(Cppi_getReturnQueue (Cppi_DescType_HOST, (Cppi_Desc *)tempVA));
         hplib_cacheWbInv(tempVA,128);
-        PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
+        pktio_mQmssQueuePushDescSizeRaw (freeQ,
                                              (void *) pHd[0],
                                              128);
     }
index 9a28052bf9d08573cf167d1e97ee45b99e6c0bed..4adb72c1ba7ee84309529fda2a57d246bf78d9c0 100755 (executable)
@@ -86,9 +86,9 @@
 #define INIT_CONFIG_IPSEC_MODE_RX   "ipsec_mode_rx"
 #define INIT_CONFIG_IPSEC_MODE_TX   "ipsec_mode_tx"
 #define INIT_CONFIG_IPSEC_IF_NO     "ipsec_if"
-
-
-#define CONFIG_STRING_LEN 25
+#define INIT_CONFIG_AUTH_KEY  "authkey"
+#define INIT_CONFIG_ENCR_KEY  "encrkey"
+#define CONFIG_STRING_LEN 128
 
 
 
@@ -145,6 +145,9 @@ typedef struct{
     char dst_ips[MAX_ROUTES][CONFIG_STRING_LEN];
     char paths[MAX_ROUTES][CONFIG_STRING_LEN];
     char ipsec_if_no[CONFIG_STRING_LEN];
+    char auth_key[CONFIG_STRING_LEN];
+    char encr_key[CONFIG_STRING_LEN];
+    
 } netTestConfigFile_t;
 
 
@@ -161,7 +164,8 @@ nwalIpAddr_t remote_ipsec_ip;
 uint8_t ipsec_mode_rx;
 uint8_t ipsec_mode_tx;
 int ipsec_if_no;  /* 0 if mac0, 1 if mac 1 */
-
+uint8_t auth_key[36];
+uint8_t encr_key[36];
 } netTestConfig_t;
 
 
index 8dbd7a69142ddac5dffd43cf61cdd5752144a005..60885c4826244525afc67394e0d0847410bccddb 100644 (file)
@@ -7,11 +7,11 @@ local_ipsec_ip = 192.168.1.100
 remote_ipsec_ip = 192.168.1.10
 ipsec_if = 0
 #ipsec_mode_rx = SIDEBAND
-#ipsec_mode_rx = SIDEBAND
+#ipsec_mode_tx = SIDEBAND
 ipsec_mode_rx = INFLOW
 ipsec_mode_tx = INFLOW
-
-
+authkey = 00,01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,20,21,22,23
+encrkey = 00,11,22,33,44,55,66,77,88,99,AA,BB,CC,DD,EE,FF,00,11,22,33,44,55,66,77,88,99,AA,BB,CC,DD,EE,FF,30,31,32,33
 route0 =  MAC00-23-24-08-67-46  1
 route1 =  MAC00-22-33-44-55-56  2