index f06293d63b27b444648d9957462b651da6700722..68168e0c0dfce577d449a18c4290c758c7cd97df 100755 (executable)
-/************************************************
+/****************************************************************************
* FILE: netapi_init.c
-* Global, local initialization of NETAPI
+* Global, Private initialization and cleanup routines and defines of NETAPI
*
- * DESCRIPTION: Functions to initialize framework resources for running NETAPI
+ * DESCRIPTION: Functions to initialize and cleanup framework resources
+ * for running NETAPI
*
* REVISION HISTORY:
*
- * Copyright (c) Texas Instruments Incorporated 2010-2011
+ * Copyright (c) Texas Instruments Incorporated 2013
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- ***********************************************/
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
+ ***************************************************************************/
+
+#include "netapi.h"
+#include "netapi_loc.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
-#include <ti/drv/nwal/nwal.h>
-#include "netapi.h"
-#include "netapi_vm.h"
-#include "netapi_loc.h"
#include "ti/drv/nwal/nwal.h"
/* CSL RL includes */
#include <ti/csl/csl_semAux.h>
#include <ti/csl/csl_cacheAux.h>
#include <ti/csl/csl_xmcAux.h>
-#include <ti/csl/csl_cpsw_3gfAux.h>
-#include <ti/csl/csl_cpsw.h>
-#include <ti/csl/csl_cpsgmiiAux.h>
#include <ti/drv/qmss/qmss_qm.h>
-//pull in device config for qmss, cppi
-#include <ti/drv/qmss/device/qmss_device.c>
-#include <ti/drv/cppi/device/cppi_device.c>
+
+
+/* pointer to NWAL local context memory block used by NWAL for local
+ context intance*/
+void* pNwalLocCtxMem = NULL;
+extern void *pRmClientHandle;
+
+nwal_Handle gPNwalInstHandle = NULL;
+
+
+extern NETAPI_SHM_T* pnetapiShm;
+/* Global variablesto hold virtual address of various subsystems */
+extern hplib_virtualAddrInfo_T netapi_VM_VirtAddr[];
+
+/* Global variables which needs to be populated with memory pool attributes
+ which is passed to HPLIB for memory pool initialization*/
+extern hplib_memPoolAttr_T netapi_VM_MempoolAttr[];
+extern unsigned char *netapi_VM_QMemLocalDescRam;
+extern unsigned char *netapi_VM_QMemGlobalDescRam;
+extern unsigned char *netapi_VM_SaContextVaddr;
+
+extern Pktlib_HeapIfTable netapi_pktlib_ifTable;
+extern NETAPI_PROC_GLOBAL_T netapi_proc_global;
+extern NETAPI_HANDLE_T * netapi_proc_master;
+
/* TODO verify: */
#define CACHE_LINESZ 64
-#define System_printf printf
+
#define ALIGN(x) __attribute__((aligned (x)))
/*****************************************************************************
uint8_t *cppiMemPaSaLinkBuf = 0;
uint8_t *cppiMemSaPaLinkBuf = 0;
+
+
+#if 0
/*****************************************************************************
* Local Resource allocated at each Core
*****************************************************************************/
uint8_t *cppiMemRxCtlLinkBuf = NULL;
uint8_t *cppiMemTxCtlLinkBuf = NULL;
+#endif
-//****************************************************
-// initialize CPSW (switch) [per SOC]
-//***************************************************
-int netapi_init_cpsw(void)
-{
- CSL_CPSW_3GF_ALE_PORTCONTROL alePortControlCfg;
-
- CSL_CPSW_3GF_clearAleTable();
-
- alePortControlCfg.dropUntaggedEnable = 0;
- alePortControlCfg.vidIngressCheckEnable = 0;
-
- alePortControlCfg.mcastLimit = 0;
- alePortControlCfg.bcastLimit = 0;
-
- /* Disable learning mode for Port 0 */
- alePortControlCfg.noLearnModeEnable = 1;
- alePortControlCfg.portState = ALE_PORTSTATE_FORWARD;
- CSL_CPSW_3GF_setAlePortControlReg (0, &alePortControlCfg);
- /* Enable learning mode for Port 1 */
- alePortControlCfg.noLearnModeEnable = 0;
- alePortControlCfg.portState = ALE_PORTSTATE_FORWARD;
- CSL_CPSW_3GF_setAlePortControlReg (1, &alePortControlCfg);
- /* Enable learning mode for Port 2 */
- alePortControlCfg.noLearnModeEnable = 0;
- alePortControlCfg.portState = ALE_PORTSTATE_FORWARD;
- CSL_CPSW_3GF_setAlePortControlReg (2, &alePortControlCfg);
+NETCP_CFG_GLOB_DEVICE_PARAMS_T *p_netapi_device_cfg_local;
+Qmss_MemRegInfo memInfo;
- return 1;
-}
-//****************************************************
-// initialize QM (per SOC)
-//***************************************************
-int netapi_init_qm(int max_descriptors)
-{
- Qmss_InitCfg qmssInitConfig;
- int32_t result;
- Qmss_GlobalConfigParams nwalTest_qmssGblCfgParams;
-
- memset (&qmssInitConfig, 0, sizeof (Qmss_InitCfg));
-
- /* Use Internal Linking RAM for optimal performance */
- qmssInitConfig.linkingRAM0Base = 0;
- qmssInitConfig.linkingRAM0Size = 0;
- qmssInitConfig.linkingRAM1Base = 0;
- qmssInitConfig.maxDescNum = max_descriptors;
- qmssInitConfig.qmssHwStatus =QMSS_HW_INIT_COMPLETE; //bypass some of the hw init
- nwalTest_qmssGblCfgParams = qmssGblCfgParams[0];
-
- nwalTest_qmssGblCfgParams.qmConfigReg = (void *)((uint8_t *)netapi_VM_qmssCfgVaddr +
- (CSL_QM_SS_CFG_CONFIG_STARVATION_COUNTER_REGS - CSL_QM_SS_CFG_QUE_PEEK_REGS));
- nwalTest_qmssGblCfgParams.qmDescReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_DESCRIPTION_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmQueMgmtReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_QM_QUEUE_DEQUEUE_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmQueMgmtProxyReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_PROXY_QUEUE_DEQUEUE_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmQueStatReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmQueIntdReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_INTD_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspCmdReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspCmdReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_SCRACH_RAM2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspCtrlReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_ADSP1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspCtrlReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_ADSP2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspIRamReg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_APDSP1_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmPdspIRamReg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_APDSP2_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmStatusRAM = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_QM_STATUS_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmLinkingRAMReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_LINKING_RAM_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmMcDMAReg = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_MCDMA_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmTimer16Reg[0] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_TIMER1_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmTimer16Reg[1] = (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- ((uint32_t)CSL_QM_SS_CFG_TIMER2_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS);
- nwalTest_qmssGblCfgParams.qmQueMgmtDataReg = (void *)((uint32_t)netapi_VM_qmssDataVaddr);
- nwalTest_qmssGblCfgParams.qmQueMgmtProxyDataReg =
- (void *)((uint32_t)netapi_VM_qmssDataVaddr + ((uint32_t)(0x44040000) - (uint32_t)(0x44020000)));
-
- result = Qmss_init (&qmssInitConfig, &nwalTest_qmssGblCfgParams);
- if (result != QMSS_SOK) {
- System_printf (">function init_qm: qmss_Init failed with error code %d\n", result);
- return (nwal_FALSE);
- }
-
- return 1;
-}
-
-//****************************************************
-// Set up QM memory region (per SOC)
-//***************************************************
-int netapi_qm_setup_mem_region(
+/********************************************************************
+ * 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 netapip_qmSetupMemRegion(
uint32_t numDesc,
uint32_t descSize,
uint32_t* pDescMemBase,
- Qmss_MemRegion memRegion)
+ int memRegion,
+ int start_index)
{
- 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;
+ int result;
+
+ memset(&memInfo,0,sizeof(Qmss_MemRegInfo));
+ memInfo.descBase = pDescMemBase;
+ memInfo.descSize = descSize;
+ memInfo.descNum = numDesc;
+ memInfo.manageDescFlag = Qmss_ManageDesc_MANAGE_DESCRIPTOR;
+ if (pRmClientHandle)
+ {
+ memInfo.memRegion = -1;
+ memInfo.startIndex = QMSS_START_INDEX_NOT_SPECIFIED;
+ }
+ else
+ {
+ memInfo.memRegion = memRegion;
+ memInfo.startIndex = start_index;
+ }
+
+ memset (pDescMemBase, 0, (descSize * numDesc));
+
+ result = Qmss_insertMemoryRegion (&memInfo);
+
+ if (result < QMSS_SOK)
+ {
+ return (-1);
+ }
+ netapi_proc_master->memRegion = memInfo.memRegion;
+ return 1;
}
-//****************************************************
-// Start QM (per thread)
-//***************************************************
-int netapi_start_qm(void)
+/********************************************************************
+ * FUNCTION PURPOSE: Internal NETAPI function to start QM
+ ********************************************************************
+ * DESCRIPTION: Internal NETAPI function to start QM
+ * once per thread/core
+ ********************************************************************/
+int netapip_startQm(void* rmClientServiceHandle)
{
int32_t result;
- result = Qmss_start();
+ Qmss_StartCfg startCfg;
+
+ startCfg.rmServiceHandle = rmClientServiceHandle;
+ startCfg.pQmssGblCfgParams = NULL;
+ //result = Qmss_start();
+ result = Qmss_startCfg(&startCfg);
if (result != QMSS_SOK)
{
- System_printf (">start_qm: Qmss_start failed with error code %d\n", result);
return (-1);
}
return 1;
}
-//*************************************************
-//initilaize CPPI (once per soc)
-//*************************************************
-int netapi_init_cppi(void)
-{
- int32_t result, i;
- Cppi_GlobalConfigParams nwalTest_cppiGblCfgParams[CPPI_MAX_CPDMA];
-
- for (i=0; i<CPPI_MAX_CPDMA; i++)
- nwalTest_cppiGblCfgParams[i] = cppiGblCfgParams[i];
-
- /* SRIO CPDMA regs */
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].gblCfgRegs =
- (void *)((uint32_t)netapi_VM_srioCfgVaddr +
- (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txChRegs =
- (void *)((uint32_t)netapi_VM_srioCfgVaddr +
- (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxChRegs =
- (void *)((uint32_t)netapi_VM_srioCfgVaddr +
- (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].txSchedRegs =
- (void *)((uint32_t)netapi_VM_srioCfgVaddr +
- (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_SRIO_CPDMA].rxFlowRegs =
- (void *)((uint32_t)netapi_VM_srioCfgVaddr +
- (((uint32_t)CSL_SRIO_CONFIG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_SRIO_CONFIG_REGS));
-
- /* PASS CPDMA regs */
- nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].gblCfgRegs =
- (void *)((uint32_t)netapi_VM_passCfgVaddr +
- (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txChRegs =
- (void *)((uint32_t)netapi_VM_passCfgVaddr +
- (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxChRegs =
- (void *)((uint32_t)netapi_VM_passCfgVaddr +
- (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].txSchedRegs =
- (void *)((uint32_t)netapi_VM_passCfgVaddr +
- (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_PASS_CPDMA].rxFlowRegs =
- (void *)((uint32_t)netapi_VM_passCfgVaddr +
- (((uint32_t)CSL_PA_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_PA_SS_CFG_REGS));
- /* QMSS CPDMA regs */
- nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].gblCfgRegs =
- (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_GLOBAL_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txChRegs =
- (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxChRegs =
- (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].txSchedRegs =
- (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_TX_SCHEDULER_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
- nwalTest_cppiGblCfgParams[Cppi_CpDma_QMSS_CPDMA].rxFlowRegs =
- (void *)((uint32_t)netapi_VM_qmssCfgVaddr +
- (((uint32_t)CSL_QM_SS_CFG_CPPI_DMA_RX_FLOW_CFG_REGS) - (uint32_t)CSL_QM_SS_CFG_QUE_PEEK_REGS));
-
- result = Cppi_init (nwalTest_cppiGblCfgParams);
- if (result != CPPI_SOK)
- {
- printf (">function cppi_init: Cppi_init failed with error code %d\n", result);
- return (-1);
- }
- return 1;
-}
-//*************************************************
-//initialize NWAL (one per soc)
-//*************************************************
/*** NWAL Memory Buffer Configuration ***/
#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE 3400
-uint8_t nwalInstMem[NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE]ALIGN(CACHE_LINESZ);
+//uint8_t nwalInstMem[NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE]ALIGN(CACHE_LINESZ);
+
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC 128
+#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC 256
#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN 256
#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP 128
#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT 128
#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR 128
-#define NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT 384
#define NWAL_CHAN_HANDLE_SIZE ((NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_MAC * TUNE_NETAPI_MAX_NUM_MAC) + \
(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_IPSEC_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2) + \
(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_IP * TUNE_NETAPI_MAX_NUM_IP) + \
(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_PORT * TUNE_NETAPI_MAX_NUM_PORTS)+ \
- (NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_LOC_CONTEXT * TUNE_NETAPI_NUM_CORES) + \
(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_PER_L2L3_HDR * TUNE_NETAPI_MAX_NUM_L2_L3_HDRS))
-uint8_t nwalHandleMem[NWAL_CHAN_HANDLE_SIZE]ALIGN(CACHE_LINESZ);
+typedef struct NETAPI_NWAL_SHM_Tag
+{
+ uint8_t nwalInstMem[NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE]ALIGN(CACHE_LINESZ);
+ uint8_t nwalHandleMem[NWAL_CHAN_HANDLE_SIZE]ALIGN(CACHE_LINESZ);
+} NETAPI_NWAL_SHM_T;
+
+typedef struct NETAPI_PA_SHM_Tag
+{
/* todo: Check if below size information can be made available from pa interface file */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0 128
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0 256
/* PA instance */
/* Memory used for the PA Instance. Needs to be assigned global uncached memory for chip */
uint8_t paBuf0[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0]ALIGN(CACHE_LINESZ);
/* Memory used for PA handles */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1 128
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1 128 * TUNE_NETAPI_MAX_NUM_MAC
uint8_t paBuf1[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1]ALIGN(CACHE_LINESZ);
-#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2 768
+#define NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2 14592
+
+
uint8_t paBuf2[NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2]ALIGN(CACHE_LINESZ);
+} NETAPI_PA_SHM_T;
+
+typedef struct NETAPI_SA_SHM_Tag
+{
/* Memory used for SA LLD global Handle */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE 384
+#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE 512
uint8_t salldHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE]ALIGN(CACHE_LINESZ);
-#if 0 //need to alloc this since we need phy addr also
-/* Memory used for SA contet Handle */
-#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN 384
-uint8_t saContext[NETAPI_NWAL_CONFIG_BUFSIZE_SA_CONTEXT_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS]ALIGN(CACHE_LINESZ);
-#endif
-
/* Memory used by SA LLD per Channel */
#define NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN 512
uint8_t salldChanHandle[NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2]ALIGN(CACHE_LINESZ);
+} NETAPI_SA_SHM_T;
+
+
+
+
-/*******************************************
- * Initialize the nwal subsystem for NETAPI use
- ***********************************************/
-int netapi_init_nwal(
- int region2use,
- Pktlib_HeapIfTable * p_table,
- NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context,
- NETAPI_CFG_T*p_cfg )
+
+
+/********************************************************************
+* FUNCTION PURPOSE: NETAPI internal function to gracefully cleanup when startup
+* issue occurs.
+ ********************************************************************
+ * DESCRIPTION: NETAPI internal function to gracefully cleanup when startup
+* issue occurs.
+ ********************************************************************/
+void netapipErrTeardown() { netapip_cleanupAtStart(); exit(-99); }
+
+/********************************************************************
+ * FUNCTION PURPOSE: Internal NETAPI function to initialize NWAL subsystem
+ ********************************************************************
+ * DESCRIPTION: Internal NETAPI function to initialize NWAL subsytem
+ ********************************************************************/
+int netapip_initNwal(
+ int region2use,
+ Pktlib_HeapIfTable * p_table,
+ NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_context,
+ NETAPI_CFG_T*p_cfg)
{
nwalSizeInfo_t nwalSizeInfo;
- nwalMemBuf_t nwalMemBuf[nwal_N_BUFS];
nwal_RetValue nwalRetVal;
nwalGlobCfg_t nwalGlobCfg;
+ nwalBaseAddrCfg_t nwalBaseAddrCfg;
uint8_t count;
int sizes[nwal_N_BUFS];
int aligns[nwal_N_BUFS];
void* bases[nwal_N_BUFS];
Pktlib_HeapCfg heapCfg;
- int32_t errCode;
-
+ int32_t errCode = 0;
+ void* pBase = NULL;
+ NETAPI_PA_SHM_T* paEntry = NULL;
+ NETAPI_SA_SHM_T* saEntry = NULL;
+ NETAPI_NWAL_SHM_T* nwalEntry = NULL;
+ uint32_t localCtxSize = 0;
memset(p_nwal_context,0,sizeof( NETAPI_NWAL_GLOBAL_CONTEXT_T) );
memset(&nwalGlobCfg,0,sizeof(nwalGlobCfg_t ) );
-
-
+ memset (&nwalBaseAddrCfg, 0, sizeof(nwalBaseAddrCfg_t));
+ pBase = hplib_shmOpen();
+ if (pBase)
+ {
+ if(hplib_shmAddEntry(pBase, sizeof(NETAPI_PA_SHM_T), PA_ENTRY) == hplib_OK)
+ {
+ paEntry = (NETAPI_PA_SHM_T*)hplib_shmGetEntry(pBase,PA_ENTRY);
+ nwalBaseAddrCfg.pInstPoolPaBaseAddr= (void *)paEntry;
+ }
+ else
+ {
+ return -1;
+ }
+ if(hplib_shmAddEntry(pBase, sizeof(NETAPI_SA_SHM_T), SA_ENTRY) == hplib_OK)
+ {
+ saEntry = (NETAPI_SA_SHM_T*)hplib_shmGetEntry(pBase,SA_ENTRY);
+ nwalBaseAddrCfg.pInstPoolSaBaseAddr= (void*) saEntry;
+ }
+ else
+ {
+ return -1;
+ }
+ if(hplib_shmAddEntry(pBase, sizeof(NETAPI_NWAL_SHM_T), NWAL_ENTRY) == hplib_OK)
+ {
+ nwalEntry = (NETAPI_NWAL_SHM_T*)hplib_shmGetEntry(pBase,NWAL_ENTRY);
+ }
+ else
+ {
+ return -1;
+ }
+
+ }
/* Initialize Buffer Pool for NetCP PA to SA packets */
nwalGlobCfg.pa2SaBufPool.numBufPools = 1;
nwalGlobCfg.pa2SaBufPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
Pktlib_createHeap(&heapCfg, &errCode);
if(nwalGlobCfg.pa2SaBufPool.bufPool[0].heapHandle == NULL)
{
- printf (">Pktlib_createHeap:Heap Creation Failed for PA to SA Buffer Pool , Error Code: %d\n",errCode);
- netapi_err_teardown();
+ netapipErrTeardown();
return -1;
}
heapCfg.name = "nwal SA2PA";
heapCfg.numPkts = TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC;
- nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle = p_nwal_context->sa2pa_heap=
- Pktlib_createHeap(&heapCfg, &errCode);
+ nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle =
+ p_nwal_context->sa2pa_heap = Pktlib_createHeap(&heapCfg, &errCode);
if(nwalGlobCfg.sa2PaBufPool.bufPool[0].heapHandle == NULL)
{
- printf (">Pktlib_createHeap:Heap Creation Failed for SA to PA Buffer Pool , Error Code: %d\n",errCode);
- netapi_err_teardown();
+ netapipErrTeardown();
return -1;
}
nwalGlobCfg.paFwActive = nwal_TRUE;
nwalGlobCfg.saFwActive = nwal_FALSE;
- /* Pick Default Physical Address */
- nwalGlobCfg.paVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr;
- nwalGlobCfg.saVirtBaseAddr = (uint32_t) netapi_VM_passCfgVaddr +
- ((uint32_t)CSL_PA_SS_CFG_CP_ACE_CFG_REGS - (uint32_t)CSL_PA_SS_CFG_REGS) ;
+
+ /* Update nwal cfg with virtual PA and SA addresses */
+
+
+ nwalBaseAddrCfg.paVirtBaseAddr = (uint32_t) netapi_VM_VirtAddr->passCfgVaddr;
+
+
+ nwalBaseAddrCfg.pSaVirtBaseAddr = (uint32_t) netapi_VM_VirtAddr->passCfgVaddr +
+ CSL_NETCP_CFG_SA_CFG_REGS -
+ CSL_NETCP_CFG_REGS;
+ ;
nwalGlobCfg.rxDefPktQ = QMSS_PARAM_NOT_SPECIFIED;
+
/* Get the Buffer Requirement from NWAL */
- memset(&nwalMemBuf,0,sizeof(nwalMemBuf));
memset(&nwalSizeInfo,0,sizeof(nwalSizeInfo));
nwalSizeInfo.nMaxMacAddress = TUNE_NETAPI_MAX_NUM_MAC;
nwalSizeInfo.nMaxIpAddress = TUNE_NETAPI_MAX_NUM_IP;
nwalSizeInfo.nMaxDmSecChannels = TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS;//we allocate 2 per channel
nwalSizeInfo.nMaxL2L3Hdr = TUNE_NETAPI_MAX_NUM_L2_L3_HDRS;
nwalSizeInfo.nProc = TUNE_NETAPI_NUM_CORES;
- for(count=0;count < nwal_N_BUFS;count++)
- {
- nwalMemBuf[count].cacheLineSize = CACHE_LINESZ;
- }
nwalRetVal = nwal_getBufferReq(&nwalSizeInfo,
sizes,
aligns);
if(nwalRetVal != nwal_OK)
{
- printf (">netapi: init_nwal - nwal_getBufferReq Failed %d\n", nwalRetVal);
return nwal_FALSE;
}
/* Check for memory size requirement and update the base */
count = 0;
- bases[nwal_BUF_INDEX_INST] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalInstMem);
+ //bases[nwal_BUF_INDEX_INST] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalInstMem);
+ bases[nwal_BUF_INDEX_INST] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalEntry->nwalInstMem);
+
if(NETAPI_NWAL_CONFIG_BUFSIZE_NWAL_HANDLE < sizes[nwal_BUF_INDEX_INST])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
}
count++;
- bases[nwal_BUF_INDEX_INT_HANDLES] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalHandleMem);
+ //bases[nwal_BUF_INDEX_INT_HANDLES] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)nwalHandleMem);
+ bases[nwal_BUF_INDEX_INT_HANDLES] =
+ (uint32_t *) Osal_nwalLocToGlobAddr((uint32_t)nwalEntry->nwalHandleMem);
+
+
if(NWAL_CHAN_HANDLE_SIZE < sizes[nwal_BUF_INDEX_INT_HANDLES])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
- bases[nwal_BUF_INDEX_PA_LLD_BUF0] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf0);
+ bases[nwal_BUF_INDEX_PA_LLD_BUF0] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paEntry->paBuf0);
if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF0) < sizes[nwal_BUF_INDEX_PA_LLD_BUF0])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
- bases[nwal_BUF_INDEX_PA_LLD_BUF1] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf1);
+ bases[nwal_BUF_INDEX_PA_LLD_BUF1] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paEntry->paBuf1);
if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF1) < sizes[nwal_BUF_INDEX_PA_LLD_BUF1])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
- bases[nwal_BUF_INDEX_PA_LLD_BUF2] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paBuf2);
+ bases[nwal_BUF_INDEX_PA_LLD_BUF2] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)paEntry->paBuf2);
if((NETAPI_NWAL_CONFIG_BUFSIZE_PA_BUF2) < sizes[nwal_BUF_INDEX_PA_LLD_BUF2])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
#ifdef NETAPI_ENABLE_SECURITY
- bases[nwal_BUF_INDEX_SA_LLD_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldHandle);
+ bases[nwal_BUF_INDEX_SA_LLD_HANDLE] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)saEntry->salldHandle);
if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE) < sizes[nwal_BUF_INDEX_SA_LLD_HANDLE])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
bases[nwal_BUF_INDEX_SA_CONTEXT] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)netapi_VM_SaContextVaddr);
+ /* also save this here for easy access to sa_start */
+ nwalBaseAddrCfg.pScPoolBaseAddr= bases[nwal_BUF_INDEX_SA_CONTEXT];
count++;
- bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)salldChanHandle);
+ bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] =
+ (uint32_t *)Osal_nwalLocToGlobAddr((uint32_t)saEntry->salldChanHandle);
if((NETAPI_NWAL_CONFIG_BUFSIZE_SA_LLD_HANDLE_PER_CHAN * TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2) <
sizes[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE])
{
/* Resize Memory */
- while(1);
+ return nwal_FALSE;
+ //while(1);
+
}
count++;
#else
bases[nwal_BUF_INDEX_SA_LLD_CHAN_HANDLE] = 0;
count = count+3;
#endif
- if(count != nwal_N_BUFS)
- {
- while(1);
- }
/* Initialize NWAL module */
+ nwal_getLocContextBufferReq(nwalSizeInfo.nProc, &localCtxSize);
+
+ pNwalLocCtxMem = malloc(localCtxSize);
+ nwal_createProc(bases[nwal_BUF_INDEX_INST],
+ pNwalLocCtxMem,
+ &nwalBaseAddrCfg);
+
+ nwalGlobCfg.pBaseAddrCfg = &nwalBaseAddrCfg;
nwalRetVal = nwal_create(&nwalGlobCfg,
&nwalSizeInfo,
sizes,
bases,
- &p_nwal_context->nwalInstHandle);
+ &gPNwalInstHandle);
if(nwalRetVal != nwal_OK)
{
- printf (">netapi: init_nwal- nwal_create Failed %d\n",nwalRetVal);
- while(1);
+ return nwal_FALSE;
}
- printf(">netapi: init_nwal - Global and Local Network initialization Successful \n");
return 1;
}
-//*************************************************
-//* Local (per thread/core) nwal initialization0
-//**************************************************
-int netapi_start_nwal(Pktlib_HeapHandle pkt_heap,
- Pktlib_HeapHandle cmd_heap,
+/********************************************************************
+ * FUNCTION PURPOSE: Internal NETAPI function to start NWAL
+ ********************************************************************
+ * DESCRIPTION: Internal NETAPI function to start NWAL, per thread/core
+ ********************************************************************/
+int netapip_startNwal(Pktlib_HeapHandle pkt_heap,
+ Pktlib_HeapHandle cmd_rx_heap,
+ Pktlib_HeapHandle cmd_tx_heap,
NETAPI_NWAL_LOCAL_CONTEXT_T *p,
NETAPI_CFG_T *p_cfg,
- NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_glob_context )
+ NETAPI_NWAL_GLOBAL_CONTEXT_T * p_nwal_glob_context,
+ int master)
{
nwalLocCfg_t nwalLocCfg;
- int count;
+ nwalBaseAddrCfg_t nwalBaseAddrCfg;
+ int count=0;
+ static int first_time = 0;
nwal_RetValue nwalRetVal;
+ void* pBase = NULL;
+ NETAPI_NWAL_SHM_T* nwalEntry = NULL;
+ void* pNwalLocCtxMem = NULL;
- memset(&nwalLocCfg,0,sizeof(nwalLocCfg));
+ NETAPI_SA_SHM_T* saEntry = NULL;
+ NETAPI_PA_SHM_T* paEntry = NULL;
- /* Common Initialization for all cores */
- while(count < TUNE_NETAPI_MAX_NUM_TRANS)
- {
- p_nwal_glob_context->transInfos[count].transId = count;
- count++;
- }
+ uint32_t baseAddr;
+ void* instPoolSaBaseAddr;
+ void* pScPoolBaseAddr;
+ void* pInstPoolPaBaseAddr;
+ void* paVirtBaseAddr;
+ uint32_t localCtxSize;
+
+ memset(&nwalLocCfg,0,sizeof(nwalLocCfg));
+ memset(&nwalBaseAddrCfg, 0, sizeof(nwalBaseAddrCfg_t));
/* Update the Start of Packet Offset for the default flows created
* by NWAL
*/
nwalLocCfg.rxSopPktOffset = p_cfg->def_flow_pkt_rx_offset;
+ nwalLocCfg.rxPktTailRoomSz = p_cfg->def_heap_tailroom_size;
/* Call back registration for the core */
- nwalLocCfg.pRxPktCallBack = netapi_NWALRxPktCallback;
- nwalLocCfg.pCmdCallBack = netapi_NWALCmdCallBack;
- nwalLocCfg.pPaStatsCallBack = netapi_NWALCmdPaStatsReply;
- nwalLocCfg.pRxDmCallBack= netapi_NWALSBPktCallback; //sideband mode callback
+ nwalLocCfg.pRxPktCallBack = netapip_pktioNWALRxPktCallback;
+ nwalLocCfg.pCmdCallBack = netapip_netcpCfgNWALCmdCallBack;
+ nwalLocCfg.pPaStatsCallBack = netapip_netcpCfgNWALCmdPaStatsReply;
+
+ nwalLocCfg.pRxDmCallBack= netapip_pktioNWALSBPktCallback; //sideband mode callback
/* Initialize Buffer Pool for Control packets from NetCP to Host */
nwalLocCfg.rxCtlPool.numBufPools = 1;
nwalLocCfg.rxCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
nwalLocCfg.rxCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
- nwalLocCfg.rxCtlPool.bufPool[0].heapHandle = cmd_heap;
+ nwalLocCfg.rxCtlPool.bufPool[0].heapHandle = cmd_rx_heap;
/* Initialize Buffer Pool for Control packets from Host to NetCP */
nwalLocCfg.txCtlPool.numBufPools = 1;
nwalLocCfg.txCtlPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
nwalLocCfg.txCtlPool.bufPool[0].bufSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
- nwalLocCfg.txCtlPool.bufPool[0].heapHandle = cmd_heap;
+ nwalLocCfg.txCtlPool.bufPool[0].heapHandle = cmd_tx_heap;
-/* Initialize Buffer Pool for Packets from NetCP to Host */
+/* Initialize Buffer Pool for L4 Packets from NetCP to Host */
nwalLocCfg.rxPktPool.numBufPools = 1;
nwalLocCfg.rxPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
- nwalLocCfg.rxPktPool.bufPool[0].bufSize = TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
+ nwalLocCfg.rxPktPool.bufPool[0].bufSize = p_cfg->def_heap_buf_size;
nwalLocCfg.rxPktPool.bufPool[0].heapHandle = pkt_heap;
/* Initialize Buffer Pool for Packets from Host to NetCP */
nwalLocCfg.txPktPool.numBufPools = 1;
nwalLocCfg.txPktPool.bufPool[0].descSize = TUNE_NETAPI_DESC_SIZE;
- nwalLocCfg.txPktPool.bufPool[0].bufSize = TUNE_NETAPI_DEFAULT_BUFFER_SIZE;
+ nwalLocCfg.txPktPool.bufPool[0].bufSize = p_cfg->def_heap_buf_size;
nwalLocCfg.txPktPool.bufPool[0].heapHandle = pkt_heap;
+
+
+
memcpy(&p->nwalLocCfg,&nwalLocCfg,sizeof(nwalLocCfg_t));
while(1)
{
- nwalRetVal = nwal_start(p_nwal_glob_context->nwalInstHandle,&nwalLocCfg);
+ if(master == NETAPI_PROC_MASTER)
+ {
+ pBase = hplib_shmOpen();
+ nwalEntry = (NETAPI_NWAL_SHM_T*)hplib_shmGetEntry(pBase,NWAL_ENTRY);
+
+ baseAddr = (void*) netapi_VM_VirtAddr->passCfgVaddr +
+ CSL_NETCP_CFG_SA_CFG_REGS -
+ CSL_NETCP_CFG_REGS;
+ saEntry = (NETAPI_SA_SHM_T*)hplib_shmGetEntry(pBase,SA_ENTRY);
+ instPoolSaBaseAddr = (void*) saEntry;
+
+ pScPoolBaseAddr = Osal_nwalLocToGlobAddr((uint32_t)netapi_VM_SaContextVaddr);
+
+
+ paVirtBaseAddr = (void*) netapi_VM_VirtAddr->passCfgVaddr;
+ paEntry = (NETAPI_PA_SHM_T*)hplib_shmGetEntry(pBase,PA_ENTRY);
+ pInstPoolPaBaseAddr = (void *)paEntry;
+
+ nwal_getLocContextBufferReq(TUNE_NETAPI_NUM_CORES, &localCtxSize);
+ pNwalLocCtxMem = malloc(localCtxSize);
+ if (pNwalLocCtxMem == NULL)
+ {
+ return -1;
+ }
+ nwalBaseAddrCfg.pSaVirtBaseAddr = baseAddr;
+ nwalBaseAddrCfg.pInstPoolSaBaseAddr = instPoolSaBaseAddr;
+ nwalBaseAddrCfg.pScPoolBaseAddr = pScPoolBaseAddr;
+ nwalBaseAddrCfg.paVirtBaseAddr = paVirtBaseAddr;
+ nwalBaseAddrCfg.pInstPoolPaBaseAddr = pInstPoolPaBaseAddr;
+ /* this is 1 time per process */
+ nwal_createProc(nwalEntry,
+ pNwalLocCtxMem,
+ &nwalBaseAddrCfg);
+ }
+ /* this is for every thread including 1st thread of the process */
+ netapi_proc_master->spinLock.lock(&pnetapiShm->netapi_util_lock);
+ nwalRetVal = nwal_start(gPNwalInstHandle,&nwalLocCfg);
+ netapi_proc_master->spinLock.unlock(&pnetapiShm->netapi_util_lock);
if(nwalRetVal == nwal_ERR_INVALID_STATE)
{
continue;
if(nwalRetVal != nwal_OK)
{
- printf (">nwal_start:Failed ->err %d !!!\n", nwalRetVal);
return -1;
}
p->state = NETAPI_NW_CXT_LOC_ACTIVE;
}
-//***************************************************
-// intialize timer
-//***************************************************
-int netapi_init_timer(void)
+/***********************************************************************
+ * 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 netapip_initTimer(void)
{
+#ifdef CORTEX_A8
return t64_start();
+#else
+ return 0;
+#endif
+}
+
+
+
+
+/***************************************************************************
+* FUNCTION PURPOSE: NETAPI internal function for virtual memory allocation.
+ ***************************************************************************
+ * DESCRIPTION: NETAPI internal function for virtual memory allocation.
+ **************************************************************************/
+
+static uint8_t* netapip_sharedMemoryMalloc(uint32_t size)
+{
+ return (uint8_t *)hplib_vmMemAlloc(size +
+ pnetapiShm->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 netapip_sharedMemoryFree(uint8_t* ptr, uint32_t size)
+{
+ /* Do Nothing. */
+ return;
+}
+
+//defensive: clean out stuff hanging around
+//
+// open a bunch of free queues and zap them
+#define NQUEUES2CLEAR 35
+static Qmss_QueueHnd tempQH[NQUEUES2CLEAR];
+void netapip_cleanupAtStart(void)
+{
+ int i;
+ uint8_t isAllocated;
+
+ for(i=0;i<NQUEUES2CLEAR;i++)
+ {
+ tempQH[i] = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE,
+ QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+ netapip_zapQ(tempQH[i]);
+ }
+
+ for(i=0;i<NQUEUES2CLEAR;i++)
+ {
+ Qmss_queueClose(tempQH[i]);
+ }
+}
+
+
+
+/********************************************************************
+* FUNCTION PURPOSE: NETAPI internal function system initialization
+ ********************************************************************
+ * DESCRIPTION: NETAPI internal function system initialization
+ ********************************************************************/
+int netapip_systemInit(NETAPI_HANDLE_T * handle,
+ Bool global_master_process)
+{
+
+ int32_t result;
+ Pktlib_HeapHandle sharedHeapHandle;
+ Pktlib_HeapHandle controlRxHeapHandle,controlTxHeapHandle;
+ Pktlib_HeapCfg heapCfg;
+ int32_t errCode = 0;
+ int count=0;
+
+#ifdef NETAPI_USE_DDR
+ /* Init attributes for DDR */
+ netapi_VM_MempoolAttr[0].attr = HPLIB_ATTR_KM_CACHED0;
+ netapi_VM_MempoolAttr[0].phys_addr = 0;
+ netapi_VM_MempoolAttr[0].size = 0;
+
+#ifdef NETAPI_USE_DDR_AND_MSMC
+ /* Init attributes for un-cached MSMC */
+ netapi_VM_MempoolAttr[1].attr = HPLIB_ATTR_UN_CACHED;
+ netapi_VM_MempoolAttr[1].phys_addr = CSL_MSMC_SRAM_REGS;
+ netapi_VM_MempoolAttr[1].size = TUNE_NETAPI_PERM_MEM_SZ;
+#endif
+#else
+ /* Init attributes for un-cached MSMC */
+ netapi_VM_MempoolAttr[0].attr = HPLIB_ATTR_UN_CACHED;
+ netapi_VM_MempoolAttr[0].phys_addr = CSL_MSMC_SRAM_REGS;
+ netapi_VM_MempoolAttr[0].size = TUNE_NETAPI_PERM_MEM_SZ;
+#ifdef NETAPI_USE_DDR_AND_MSMC
+ netapi_VM_MempoolAttr[1].attr = HPLIB_ATTR_KM_CACHED0;
+ netapi_VM_MempoolAttr[1].phys_addr = 0;
+ netapi_VM_MempoolAttr[1].size = 0;
+#endif
+#endif
+ /* initialize all the memory we are going to use
+ - chunk for buffers, descriptors
+ - memory mapped peripherals we use, such as QMSS, PA, etc */
+#ifdef NETAPI_USE_DDR_AND_MSMC
+ result = hplib_vmInit(&netapi_VM_VirtAddr[0],
+ 2,
+ &netapi_VM_MempoolAttr[0]);
+#else
+ result = hplib_vmInit(&netapi_VM_VirtAddr[0],
+ 1,
+ &netapi_VM_MempoolAttr[0]);
+#endif
+
+ if (result != hplib_OK)
+ {
+ return -1;
+ }
+
+ if (global_master_process == NETAPI_TRUE)
+ {
+ hplib_initMallocArea(0);
+#ifdef NETAPI_USE_DDR_AND_MSMC
+ hplib_initMallocArea(1);
+#endif
+#ifdef NETAPI_ENABLE_SECURITY
+#define SEC_CONTEXT_SZ 384 //not tunable
+ /* 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)
+ {
+ return (-1);
+ }
+#else
+ netapi_VM_SaContextVaddr= (char *) NULL;
+#endif
+
+ /* (3) Allocate 2 QM regions from continguous chunk above */
+ netapi_VM_QMemGlobalDescRam =
+ (void *)hplib_vmMemAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128,
+ 0);
+
+ netapi_VM_QMemLocalDescRam =
+ (void *)hplib_vmMemAlloc((TUNE_NETAPI_NUM_LOCAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128,
+ 0);
+ /* Initialize Queue Manager Sub System */
+ result = netapip_initQm (pnetapiShm->netapi_global.cfg.def_max_descriptors,
+ pRmClientHandle);
+
+ if (result != 1)
+ {
+ return -1;
+ }
+ /* Start the QMSS. */
+ if (netapip_startQm(pRmClientHandle) != 1)
+ {
+ return -1;
+ }
+
+ //clean our old junk in 1st bunch of queues that will be allocated to us
+ netapip_cleanupAtStart();
+ /* Initialize the global descriptor memory region. */
+ result= netapip_qmSetupMemRegion(
+ pnetapiShm->netapi_global.cfg.def_tot_descriptors_for_us,
+ TUNE_NETAPI_DESC_SIZE,
+ (unsigned int *) netapi_VM_QMemGlobalDescRam,
+ pnetapiShm->netapi_global.cfg.memoryRegion,
+ pnetapiShm->netapi_global.cfg.start_index);
+ if(result <0)
+ {
+ return -1;
+ }
+ /* Initialize CPPI CPDMA */
+ result = netapip_initCppi(pRmClientHandle);
+ if (result != 1)
+ {
+ return -1;
+ }
+ /* CPPI and Queue Manager are initialized. */
+
+ /* create main pkt heap */
+ /* Initialize the Shared Heaps. */
+ Pktlib_sharedHeapInit();
+ /* Populate the heap interface table. */
+ netapi_pktlib_ifTable.data_malloc = netapip_sharedMemoryMalloc;
+ netapi_pktlib_ifTable.data_free = netapip_sharedMemoryFree;
+ /* Initialize the heap configuration. */
+ memset ((void *)&heapCfg, 0, sizeof(Pktlib_HeapCfg));
+ /* Populate the heap configuration */
+ heapCfg.name = "netapi";
+ heapCfg.memRegion = memInfo.memRegion;
+ heapCfg.sharedHeap = 1;
+ heapCfg.useStarvationQueue = 0;
+ heapCfg.dataBufferSize = pnetapiShm->netapi_global.cfg.def_heap_buf_size;
+ heapCfg.numPkts = pnetapiShm->netapi_global.cfg.def_heap_n_descriptors;
+ heapCfg.numZeroBufferPackets= pnetapiShm->netapi_global.cfg.def_heap_n_zdescriptors;
+ heapCfg.heapInterfaceTable.data_malloc = netapi_pktlib_ifTable.data_malloc;
+ heapCfg.heapInterfaceTable.data_free = netapi_pktlib_ifTable.data_free;
+ heapCfg.dataBufferPktThreshold = 0;
+ heapCfg.zeroBufferPktThreshold = 0;
+
+ /* Create Shared Heap with specified configuration. */
+ sharedHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ if (!sharedHeapHandle) { return -1;}
+ handle->netcp_heap= sharedHeapHandle;
+ /* Update for Control */
+ heapCfg.name = "netapi_control_rx";
+ heapCfg.sharedHeap = 1;
+ heapCfg.dataBufferSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
+ heapCfg.numPkts = TUNE_NETAPI_CONFIG_NUM_CTL_RX_BUF;
+ heapCfg.numZeroBufferPackets= 0;
+
+ controlRxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ //todo -> cleanup on failure
+ if (!controlRxHeapHandle) { return -1;}
+ handle->netcp_control_rx_heap= controlRxHeapHandle;
+
+
+ heapCfg.name = "netapi_control_tx";
+ heapCfg.numPkts = TUNE_NETAPI_CONFIG_NUM_CTL_TX_BUF;
+
+ controlTxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ //todo -> cleanup on failure
+ if (!controlTxHeapHandle) { return -1;}
+ handle->netcp_control_tx_heap= controlTxHeapHandle;
+ /* now NWAL */
+ result = netapip_initNwal(memInfo.memRegion,
+ &netapi_pktlib_ifTable,
+ &pnetapiShm->netapi_global.nwal_context,
+ &pnetapiShm->netapi_global.cfg);
+ if (result<0) { return -1; }
+ /* Common Initialization for all cores */
+ while(count < TUNE_NETAPI_MAX_NUM_TRANS)
+ {
+ netapi_proc_global.nwal_context.transInfos[count].transId = count;
+ count++;
+ }
+ result = netapip_startNwal(sharedHeapHandle,
+ controlRxHeapHandle,
+ controlTxHeapHandle,
+ &handle->nwal_local,
+ &pnetapiShm->netapi_global.cfg,
+ &pnetapiShm->netapi_global.nwal_context,
+ handle->master);
+ if (result<0) { return -1; }
+ }
+ else
+ {
+ if (hplib_checkMallocArea(0) != hplib_OK)
+ return -1;
+ if (hplib_checkMallocArea(1) != hplib_OK)
+ return -1;
+
+#ifdef NETAPI_ENABLE_SECURITY
+ /* 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)
+ {
+ return (-1);
+ }
+#else
+ netapi_VM_SaContextVaddr= (char *) NULL;
+#endif
+
+
+
+ /* (3) Allocate 2 QM regions from continguous chunk above */
+ netapi_VM_QMemGlobalDescRam =
+ (void *)hplib_vmMemAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128,
+ 0);
+
+ netapi_VM_QMemLocalDescRam =
+ (void *)hplib_vmMemAlloc((TUNE_NETAPI_NUM_LOCAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128,
+ 0);
+
+ /****************************************************
+ * partial initialization. For process, not for SOC
+ ***************************************************/
+ result = netapip_initQm (pnetapiShm->netapi_global.cfg.def_max_descriptors,
+ pRmClientHandle);
+ if (result != 1)
+ {
+ return -1;
+ }
+
+ /* Start the QMSS. */
+ if (netapip_startQm(pRmClientHandle) != 1)
+ {
+ return -1;
+ }
+
+ result= netapip_qmSetupMemRegion(
+ pnetapiShm->netapi_global.cfg.def_tot_descriptors_for_us,
+ TUNE_NETAPI_DESC_SIZE,
+ (unsigned int *) netapi_VM_QMemGlobalDescRam,
+ pnetapiShm->netapi_global.cfg.memoryRegion,
+ pnetapiShm->netapi_global.cfg.start_index);
+ if(result <0)
+ {
+ return -1;
+ }
+ /* Initialize CPPI CPDMA */
+ result = netapip_initCppi(pRmClientHandle);
+ if (result != 1)
+ {
+ return -1;
+ }
+ /* CPPI and Queue Manager are initialized. */
+
+ /* create main pkt heap for this process */
+ /* Initialize the Shared Heaps. */
+ Pktlib_sharedHeapInit();
+ /* Populate the heap interface table. */
+ netapi_pktlib_ifTable.data_malloc = netapip_sharedMemoryMalloc;
+ netapi_pktlib_ifTable.data_free = netapip_sharedMemoryFree;
+ /* Initialize the heap configuration. */
+ memset ((void *)&heapCfg, 0, sizeof(Pktlib_HeapCfg));
+ /* Populate the heap configuration */
+ heapCfg.name = "netapi";
+ //heapCfg.memRegion = TUNE_NETAPI_QM_GLOBAL_REGION;
+ heapCfg.memRegion = memInfo.memRegion;
+ heapCfg.sharedHeap = 1;
+ heapCfg.useStarvationQueue = 0;
+ heapCfg.dataBufferSize = pnetapiShm->netapi_global.cfg.def_heap_buf_size;
+ heapCfg.numPkts = pnetapiShm->netapi_global.cfg.def_heap_n_descriptors;
+ heapCfg.numZeroBufferPackets= pnetapiShm->netapi_global.cfg.def_heap_n_zdescriptors;
+ heapCfg.heapInterfaceTable.data_malloc = netapi_pktlib_ifTable.data_malloc;
+ heapCfg.heapInterfaceTable.data_free = netapi_pktlib_ifTable.data_free;
+ heapCfg.dataBufferPktThreshold = 0;
+ heapCfg.zeroBufferPktThreshold = 0;
+
+ /* Create Shared Heap with specified configuration. */
+ sharedHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ //todo -> cleanup on failure
+ if (!sharedHeapHandle) { return -1;}
+ handle->netcp_heap= sharedHeapHandle;
+
+ //open shared heap handle but create new controlRx & Tx heaps for this
+ //process
+ /* Update for Control */
+ heapCfg.name = "netapi_control_rx";/*todo:add random#*/
+ heapCfg.sharedHeap = 1;
+ heapCfg.dataBufferSize = TUNE_NETAPI_CONFIG_MAX_CTL_RXTX_BUF_SIZE;
+ heapCfg.numPkts = TUNE_NETAPI_CONFIG_NUM_CTL_RX_BUF;
+ heapCfg.numZeroBufferPackets= 0;
+ controlRxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ if (!controlRxHeapHandle) { return -1;}
+
+ handle->netcp_control_rx_heap= controlRxHeapHandle;
+ heapCfg.name = "netapi_control_tx";
+ heapCfg.numPkts = TUNE_NETAPI_CONFIG_NUM_CTL_TX_BUF;
+ controlTxHeapHandle = Pktlib_createHeap(&heapCfg, &errCode);
+ if (!controlTxHeapHandle) { return -1;}
+ handle->netcp_control_tx_heap= controlTxHeapHandle;
+
+ /* Common Initialization for all threads in process */
+ while(count < TUNE_NETAPI_MAX_NUM_TRANS)
+ {
+ netapi_proc_global.nwal_context.transInfos[count].transId = count;
+ count++;
+ }
+ result = netapip_startNwal(sharedHeapHandle,
+ controlRxHeapHandle,
+ controlTxHeapHandle,
+ &handle->nwal_local,
+ &pnetapiShm->netapi_global.cfg,
+ &pnetapiShm->netapi_global.nwal_context,
+ handle->master);
+ if (result<0)
+ {
+ return -1;
+ }
+ }
+
+ //get timer running
+#ifdef CORTEX_A8
+ netapip_initTimer();
+#endif
+
+
+
+ return 0;
}
+/****************************************************************************
+* FUNCTION PURPOSE: NETAPI internal function which performs clean for linux user space
+ ****************************************************************************
+ * DESCRIPTION: NETAPI internal function which performs clean for linux user space
+ ***************************************************************************/
+void netapip_zapQ(int queueNum)
+{
+ int i;
+ if (!queueNum)
+ {
+ return;
+ }
+ for (i=0;;i+=1 )
+ {
+ /* Pop descriptor from source queue */
+ if (pktio_mQmssQueuePopRaw(queueNum) == NULL)
+ {
+ break;
+ }
+ }
+}
+
+
+/****************************************************************************
+* 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,
+ pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
+ printf(" > #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
+ pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
+ pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
+ 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",
+ pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
+ pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
+
+}
+