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