index 6358745e5598b350c4210270846160b1aeedb989..cba24bedce4f271f9b0b50edf4317fcd007f2bb0 100755 (executable)
-\r
-/******************************************************************************\r
- * FILE netapi_vm.c\r
- * PURPOSE: Memory allocator for NETAPI and related utilities\r
- * -- using MSMC for descriptors/buffers (current), use CMA (future) \r
- ******************************************************************************\r
- * FILE NAME: netapi_vm.c\r
- *\r
- * DESCRIPTION: Memory allocator for netapi \r
- * This is only a permanent memory allocator.\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
-#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_vm.h"\r
-#include <sys/ioctl.h>\r
-#include "tools/module/netapimod.h"\r
-\r
-\r
-/***********************RAW MEMORY ALLOCATION & TRANSLATION*************************/\r
-/* Macro to align x to y */\r
-#define align(x,y) ((x + y) & (~y))\r
-\r
-#define NETAPI_PERM_MEM_SZ (TUNE_NETAPI_PERM_MEM_SZ) \r
-\r
-/* Physical address map & size for various subsystems */\r
-#define QMSS_CFG_BASE_ADDR CSL_QM_SS_CFG_QUE_PEEK_REGS\r
-#define QMSS_CFG_BLK_SZ (1*1024*1024)\r
-#define QMSS_DATA_BASE_ADDR 0x44020000 \r
-#define QMSS_DATA_BLK_SZ (0x60000)\r
-#define SRIO_CFG_BASE_ADDR CSL_SRIO_CONFIG_REGS\r
-#define SRIO_CFG_BLK_SZ (132*1024)\r
-#define PASS_CFG_BASE_ADDR CSL_PA_SS_CFG_REGS \r
-#define PASS_CFG_BLK_SZ (1*1024*1024)\r
-\r
-#define MSMC_SRAM_BASE_ADDR CSL_MSMC_SRAM_REGS\r
-uint8_t *netapi_VM_mem_start_phy = (uint8_t*)0;\r
-uint8_t *netapi_VM_mem_start = (uint8_t*)0;\r
-uint8_t *netapi_VM_mem_end = (uint8_t*)0;\r
-uint8_t *netapi_VM_mem_end_phy = (uint8_t*)0;\r
-static uint8_t *netapi_VM_mem_alloc_ptr = (uint8_t*)0;\r
-static uint32_t netapi_VM_mem_size = 0;\r
-\r
-\r
-/* File descriptor for /dev/mem */ \r
-static int dev_mem_fd;\r
-static int our_netapi_module_fd;\r
-#define USE_MODULE_MMAP //we will mmap through netapi kernel module, not /dev/mem\r
-#ifndef USE_MODULE_MMAP\r
-static int temp_fd;\r
-#endif\r
-\r
-//inialize the allocate area.\r
-nwal_Bool_t netapi_VM_memAllocInit\r
-(\r
- uint8_t *addr, /* Physical address */\r
- uint32_t size /* Size of block */\r
-)\r
-{\r
- void *map_base; \r
-\r
- //always open dev/mem, since we need for QM, CPPI, etc\r
- if((dev_mem_fd = open("/dev/mem", (O_RDWR | O_SYNC))) == -1)\r
- {\r
- printf(">netapi_VM_memAllocInit: Failed to open \"dev/mem\" err=%s\n",\r
- strerror(errno));\r
- return nwal_FALSE;\r
- }\r
-\r
-#ifdef NETAPI_USE_MSMC\r
- // memory map in addr to addr+size (msmc)\r
- map_base = netapi_VM_memMap ((void *)addr, size); \r
-\r
- if (!map_base)\r
- {\r
- printf(">netapi_VM_memAllocInit: Failed to mmap addr (0x%x)", addr);\r
- return nwal_FALSE;\r
- }\r
-\r
- printf(">netapi_VM_memAllocInit (uncached msmc) Phy Addr %x Memory (%d bytes) mapped at address %p.\n", addr,size, map_base); \r
-#else \r
- //use cached DDR. This requires NETAPI kernel module\r
- our_netapi_module_fd=netapi_utilModInit();\r
-\r
- if (our_netapi_module_fd == -1) {\r
- printf(">netapi_VM_memAllocInit: failed to open /dev/netapi: '%s'\n", strerror(errno));\r
- return nwal_FALSE;\r
- }\r
- addr= ( uint8_t *) netapi_utilGetPhysOfBufferArea(); //get address that was allocated for us by kernela module */\r
- size = netapi_utilGetSizeOfBufferArea(); //get the size that was allocated\r
-#ifdef USE_MODULE_MMAP\r
- map_base = (void *) netapi_utilGetVaOfBufferArea(NETAPIMOD_MMAP_DMA_MEM_OFFSET, size); //mmap into our space, return va\r
-#else\r
- if( (temp_fd = open("/dev/mem", O_RDWR )) == -1) {\r
- printf(">netapi_VM_memAllocInit: failed to open dev/mem again cached err=%d\n",errno);\r
- return nwal_FALSE; \r
- }\r
-\r
- map_base = mmap(0,size , PROT_READ | PROT_WRITE, MAP_SHARED, temp_fd, addr);\r
- if(map_base == (void *) -1) {\r
- printf(">netapi_VM_memAllocInit: failed to mmap CMA area at phy %x err=%d\n",\r
- addr, errno); \r
- return nwal_FALSE;\r
- }\r
-#endif\r
- printf(">netapi_VM_memAllocInit: (cached ddr) Phy Addr %x Memory (%d bytes) mapped at address %p.\n", addr,size, map_base); \r
-#endif\r
-\r
- netapi_VM_mem_alloc_ptr = netapi_VM_mem_start = map_base;\r
- netapi_VM_mem_size = size;\r
- netapi_VM_mem_end = netapi_VM_mem_start + netapi_VM_mem_size;\r
- netapi_VM_mem_start_phy = addr;\r
- netapi_VM_mem_end_phy = netapi_VM_mem_start_phy + netapi_VM_mem_size;\r
- return nwal_TRUE;\r
-}\r
-\r
-//utility to return free amount in buffer/descriptor area\r
-int netapi_getBufMemRemainder(void)\r
-{\r
- return (int) ((unsigned int) netapi_VM_mem_end) - ((unsigned int) netapi_VM_mem_alloc_ptr);\r
-}\r
-\r
-\r
-//------------------------------------------------------------------------\r
-//allocator function for our Buffer/Descriptor/SAcontext area (either MSMC\r
-//or kernel module provided CMA area in DDR\r
-//-----------------------------------------------------------------------\r
-void* netapi_VM_memAlloc\r
-(\r
- uint32_t size,\r
- uint32_t align\r
-)\r
-{\r
- uint32_t key;\r
- uint8_t *alloc_ptr;\r
- void *p_block =NULL;\r
-\r
- Osal_stubCsEnter();\r
- alloc_ptr = (uint8_t*)align((uint32_t)netapi_VM_mem_alloc_ptr, align);\r
- if ((alloc_ptr + size) < netapi_VM_mem_end)\r
- {\r
- p_block =(void *)alloc_ptr;\r
- netapi_VM_mem_alloc_ptr = alloc_ptr + size;\r
- Osal_stubCsExit(key);\r
- memset (p_block, 0, size);\r
- }\r
- else \r
- {\r
- Osal_stubCsExit(key);\r
- }\r
- return p_block;\r
-}\r
-uint32_t xtraLogs=0;\r
-/* Api 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
- void *map_base,*virt_addr,*tmpAddr;\r
- uint32_t page_sz;\r
- long retval;\r
- uint32_t mask = (size-1);\r
- uint32_t offset;\r
-\r
- retval = sysconf(_SC_PAGE_SIZE);\r
- if (retval == -1)\r
- {\r
- printf(">netapi_VM_memMap: Failed to get page size err=%s\n",\r
- strerror(errno));\r
- return (void *)0;\r
- }\r
-\r
- page_sz = (uint32_t)retval;\r
-\r
- if (size%page_sz)\r
- {\r
- printf(">netapi_VM_memMap: error: block size not aligned to page size\n");\r
- return (void *)0;\r
- }\r
-\r
- if ((uint32_t)addr%page_sz)\r
- {\r
- printf(">netapi_VM_memMap: error: addr not aligned to page size\n");\r
- return (void *)0;\r
- }\r
-\r
- map_base = mmap(0, size, (PROT_READ|PROT_WRITE), MAP_SHARED, dev_mem_fd, (off_t)addr & ~mask);\r
- if(map_base == (void *) -1) \r
- {\r
- printf(">netapi_VM_memMap: Failed to mmap \"dev/mem\" err=%s\n",\r
- strerror(errno));\r
- return (void *)0;\r
- }\r
- virt_addr = map_base + ((off_t)addr & mask);\r
- if(xtraLogs)\r
- {\r
- printf(">netapi_VM_memMap:Memory mapped Begin Address 0x%x Read Value: 0x%x.\n", virt_addr,*((unsigned long *)virt_addr));\r
- // offset = size/(sizeof(unsigned long));\r
- // tmpAddr = (unsigned long *)virt_addr + offset-1;\r
- tmpAddr = (uint8_t *)virt_addr + 0x6800c;\r
- printf("netapi_VM_memMap:Memory mapped End Address 0x%x Read Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));\r
- *((unsigned long *)tmpAddr) = 0x1234;\r
- printf("netapi_VM_memMap:Memory mapped End Address 0x%x Write Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));\r
- \r
- }\r
- return(virt_addr);\r
-}\r
-\r
-/***************************************************************/\r
-/*************** Memory Initilaization**************************/\r
-/***************************************************************/\r
-/* for now use msmc */\r
-/* Total Permanent memory required in NWAL test\r
- * for Packet buffers & descriptor buffers\r
- */\r
-/* Global variables to hold virtual address of various subsystems */\r
-void *netapi_VM_qmssCfgVaddr;\r
-void *netapi_VM_qmssDataVaddr;\r
-void *netapi_VM_srioCfgVaddr;\r
-void *netapi_VM_passCfgVaddr;\r
-\r
-/* also for our descriptor area */\r
-unsigned char *netapi_VM_QMemLocalDescRam=NULL;\r
-unsigned char *netapi_VM_QMemGlobalDescRam=NULL;\r
-\r
-/* finaly SA context area */\r
-unsigned char *netapi_VM_SaContextVaddr=NULL;\r
-\r
-/************************************************\r
- * teardown VM memory\r
- ***********************************************/\r
-void netapi_VM_memory_teardown(void)\r
-{\r
- netapi_utilModClose();\r
- close(dev_mem_fd);\r
-#ifndef USE_MODULE_MMAP\r
- close(temp_fd);\r
-#endif\r
-}\r
-/*************************************************\r
- * setup VM memory\r
- ************************************************/\r
-int netapi_VM_memory_setup(void)\r
-{\r
-/* (1) big chunck of memory out of MSMC or DDR via kernel CMA */\r
-#ifdef NETAPI_USE_DDR\r
- if (netapi_VM_memAllocInit( NULL, 0) == nwal_FALSE) {\r
- printf(">netapi ERROR: netapi_V_MmemAllocInit from DDR/CMA failed\n");\r
- return (-1);\r
- }\r
-#else //uncached MSMC \r
- if (netapi_VM_memAllocInit((uint8_t*)MSMC_SRAM_BASE_ADDR,\r
- NETAPI_PERM_MEM_SZ) == nwal_FALSE) {\r
- printf(">netapi ERROR: netapi_V_MmemAllocInit from MSMC failed\n");\r
- return (-1);\r
- }\r
-#endif\r
-\r
- /* (2) Create virtual memory maps for peripherals */\r
- /* (2a) QMSS CFG Regs */\r
- netapi_VM_qmssCfgVaddr = netapi_VM_memMap((void*)QMSS_CFG_BASE_ADDR,\r
- QMSS_CFG_BLK_SZ);\r
- if (!netapi_VM_qmssCfgVaddr)\r
- {\r
- printf(">netapi ERROR: Failed to map QMSS CFG registers\n");\r
- return (-1);\r
- }\r
- printf(">netapi QMSS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_CFG_BASE_ADDR, netapi_VM_qmssCfgVaddr);\r
-\r
- /* (2b) QMSS DATA Regs */\r
-#ifdef USE_MODULE_MMAP\r
- netapi_VM_qmssDataVaddr = (void *) netapi_utilGetVaOfBufferArea(NETAPIMOD_MMAP_QM_DATA_REG_MEM_OFFSET, QMSS_DATA_BLK_SZ);\r
-#else\r
- netapi_VM_qmssDataVaddr = netapi_VM_memMap((void*)QMSS_DATA_BASE_ADDR,\r
- QMSS_DATA_BLK_SZ);\r
-#endif\r
-\r
- if (!netapi_VM_qmssDataVaddr)\r
- {\r
- printf(">netapi ERROR: Failed to map QMSS DATA registers\n");\r
- return (-1);\r
- }\r
- printf(">netapi QMSS_DATA_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_DATA_BASE_ADDR, netapi_VM_qmssDataVaddr);\r
-\r
- /* (2c) SRIO CFG Regs */\r
- netapi_VM_srioCfgVaddr = netapi_VM_memMap((void*)SRIO_CFG_BASE_ADDR,\r
- SRIO_CFG_BLK_SZ);\r
- if (!netapi_VM_srioCfgVaddr)\r
- {\r
- printf(">netapi ERROR: Failed to map SRIO CFG registers\n");\r
- return (-1);\r
- }\r
- printf(">netapi SRIO_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)SRIO_CFG_BASE_ADDR, netapi_VM_srioCfgVaddr);\r
-\r
- /* (2d) PASS CFG Regs */\r
- netapi_VM_passCfgVaddr = netapi_VM_memMap((void*)PASS_CFG_BASE_ADDR,\r
- PASS_CFG_BLK_SZ);\r
- if (!netapi_VM_passCfgVaddr)\r
- {\r
- printf(">netapi ERROR: Failed to map PASS CFG registers\n");\r
- return (-1);\r
- }\r
- printf(">netapi PASS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)PASS_CFG_BASE_ADDR, netapi_VM_passCfgVaddr);\r
-\r
- /* (2e) SA COntext area */\r
-#ifdef NETAPI_ENABLE_SECURITY\r
-#define SEC_CONTEXT_SZ 384 //not tunable\r
-/* allocate 2x number of tunnels since we need one for inflow and one for data mode */\r
- netapi_VM_SaContextVaddr = netapi_VM_memAlloc((TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2 *\r
- SEC_CONTEXT_SZ),\r
- 128);\r
- if (!netapi_VM_SaContextVaddr)\r
- {\r
- printf(">netapi ERROR: Failed to map SA context memory region\n");\r
- return (-1);\r
- }\r
- printf(">netapi VM_SaContext: Memory mapped/allocated at address %p.\n", netapi_VM_SaContextVaddr);\r
-\r
-#else\r
- netapi_VM_SaContextVaddr= (char *) NULL;\r
-#endif\r
-\r
- /* (2f) Timer */\r
- t64_memmap(dev_mem_fd);\r
-\r
- /* (3) Allocate 2 QM regions from continguous chunk above */\r
- netapi_VM_QMemGlobalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *\r
- TUNE_NETAPI_DESC_SIZE),\r
- 128);\r
- netapi_VM_QMemLocalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_LOCAL_DESC *\r
- TUNE_NETAPI_DESC_SIZE),\r
- 128);\r
- printf(">netapi local desc region=%x global desc region=%x\n", netapi_VM_QMemLocalDescRam,netapi_VM_QMemGlobalDescRam);\r
-\r
- return 1;\r
-\r
-}\r
-\r
+
+/******************************************************************************
+ * FILE netapi_vm.c
+ * PURPOSE: Memory allocator for NETAPI and related utilities
+ * -- using MSMC for descriptors/buffers (current), use CMA (future)
+ ******************************************************************************
+ * FILE NAME: netapi_vm.c
+ *
+ * DESCRIPTION: Memory allocator for netapi
+ * This is only a permanent memory allocator.
+ *
+ * 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_vm.h"
+#include <sys/ioctl.h>
+#include "tools/module/netapimod.h"
+
+
+/***********************RAW MEMORY ALLOCATION & TRANSLATION*************************/
+/* Macro to align x to y */
+#define align(x,y) ((x + y) & (~y))
+
+#define NETAPI_PERM_MEM_SZ (TUNE_NETAPI_PERM_MEM_SZ)
+
+/* Physical address map & size for various subsystems */
+#define QMSS_CFG_BASE_ADDR CSL_QM_SS_CFG_QUE_PEEK_REGS
+#define QMSS_CFG_BLK_SZ (1*1024*1024)
+#define QMSS_DATA_BASE_ADDR 0x44020000
+#define QMSS_DATA_BLK_SZ (0x60000)
+#define SRIO_CFG_BASE_ADDR CSL_SRIO_CONFIG_REGS
+#define SRIO_CFG_BLK_SZ (132*1024)
+#define PASS_CFG_BASE_ADDR CSL_PA_SS_CFG_REGS
+#define PASS_CFG_BLK_SZ (1*1024*1024)
+
+#define MSMC_SRAM_BASE_ADDR CSL_MSMC_SRAM_REGS
+uint8_t *netapi_VM_mem_start_phy = (uint8_t*)0;
+uint8_t *netapi_VM_mem_start = (uint8_t*)0;
+uint8_t *netapi_VM_mem_end = (uint8_t*)0;
+uint8_t *netapi_VM_mem_end_phy = (uint8_t*)0;
+static uint8_t *netapi_VM_mem_alloc_ptr = (uint8_t*)0;
+static uint32_t netapi_VM_mem_size = 0;
+
+
+/* File descriptor for /dev/mem */
+static int dev_mem_fd;
+static int our_netapi_module_fd;
+#define USE_MODULE_MMAP //we will mmap through netapi kernel module, not /dev/mem
+#ifndef USE_MODULE_MMAP
+static int temp_fd;
+#endif
+
+//inialize the allocate area.
+nwal_Bool_t netapi_VM_memAllocInit
+(
+ uint8_t *addr, /* Physical address */
+ uint32_t size /* Size of block */
+)
+{
+ void *map_base;
+
+ //always open dev/mem, since we need for QM, CPPI, etc
+ if((dev_mem_fd = open("/dev/mem", (O_RDWR | O_SYNC))) == -1)
+ {
+ printf(">netapi_VM_memAllocInit: Failed to open \"dev/mem\" err=%s\n",
+ strerror(errno));
+ return nwal_FALSE;
+ }
+
+#ifdef NETAPI_USE_MSMC
+ // memory map in addr to addr+size (msmc)
+ map_base = netapi_VM_memMap ((void *)addr, size);
+
+ if (!map_base)
+ {
+ printf(">netapi_VM_memAllocInit: Failed to mmap addr (0x%x)", addr);
+ return nwal_FALSE;
+ }
+
+ printf(">netapi_VM_memAllocInit (uncached msmc) Phy Addr %x Memory (%d bytes) mapped at address %p.\n", addr,size, map_base);
+#else
+ //use cached DDR. This requires NETAPI kernel module
+ our_netapi_module_fd=netapi_utilModInit();
+
+ if (our_netapi_module_fd == -1) {
+ printf(">netapi_VM_memAllocInit: failed to open /dev/netapi: '%s'\n", strerror(errno));
+ return nwal_FALSE;
+ }
+ addr= ( uint8_t *) netapi_utilGetPhysOfBufferArea(); //get address that was allocated for us by kernela module */
+ size = netapi_utilGetSizeOfBufferArea(); //get the size that was allocated
+#ifdef USE_MODULE_MMAP
+ map_base = (void *) netapi_utilGetVaOfBufferArea(NETAPIMOD_MMAP_DMA_MEM_OFFSET, size); //mmap into our space, return va
+#else
+ if( (temp_fd = open("/dev/mem", O_RDWR )) == -1) {
+ printf(">netapi_VM_memAllocInit: failed to open dev/mem again cached err=%d\n",errno);
+ return nwal_FALSE;
+ }
+
+ map_base = mmap(0,size , PROT_READ | PROT_WRITE, MAP_SHARED, temp_fd, addr);
+ if(map_base == (void *) -1) {
+ printf(">netapi_VM_memAllocInit: failed to mmap CMA area at phy %x err=%d\n",
+ addr, errno);
+ return nwal_FALSE;
+ }
+#endif
+ printf(">netapi_VM_memAllocInit: (cached ddr) Phy Addr %x Memory (%d bytes) mapped at address %p.\n", addr,size, map_base);
+#endif
+
+ netapi_VM_mem_alloc_ptr = netapi_VM_mem_start = map_base;
+ netapi_VM_mem_size = size;
+ netapi_VM_mem_end = netapi_VM_mem_start + netapi_VM_mem_size;
+ netapi_VM_mem_start_phy = addr;
+ netapi_VM_mem_end_phy = netapi_VM_mem_start_phy + netapi_VM_mem_size;
+ return nwal_TRUE;
+}
+
+//utility to return free amount in buffer/descriptor area
+int netapi_getBufMemRemainder(void)
+{
+ return (int) ((unsigned int) netapi_VM_mem_end) - ((unsigned int) netapi_VM_mem_alloc_ptr);
+}
+
+
+//------------------------------------------------------------------------
+//allocator function for our Buffer/Descriptor/SAcontext area (either MSMC
+//or kernel module provided CMA area in DDR
+//-----------------------------------------------------------------------
+void* netapi_VM_memAlloc
+(
+ uint32_t size,
+ uint32_t align
+)
+{
+ uint32_t key;
+ uint8_t *alloc_ptr;
+ void *p_block =NULL;
+
+ Osal_stubCsEnter();
+ alloc_ptr = (uint8_t*)align((uint32_t)netapi_VM_mem_alloc_ptr, align);
+ if ((alloc_ptr + size) < netapi_VM_mem_end)
+ {
+ p_block =(void *)alloc_ptr;
+ netapi_VM_mem_alloc_ptr = alloc_ptr + size;
+ Osal_stubCsExit(key);
+ memset (p_block, 0, size);
+ }
+ else
+ {
+ Osal_stubCsExit(key);
+ }
+ return p_block;
+}
+uint32_t xtraLogs=0;
+/* Api to map the give physical address to virtual memory space */
+void *netapi_VM_memMap
+(
+ void *addr, /* Physical address */
+ uint32_t size /* Size of block */
+)
+{
+ void *map_base,*virt_addr,*tmpAddr;
+ uint32_t page_sz;
+ long retval;
+ uint32_t mask = (size-1);
+ uint32_t offset;
+
+ retval = sysconf(_SC_PAGE_SIZE);
+ if (retval == -1)
+ {
+ printf(">netapi_VM_memMap: Failed to get page size err=%s\n",
+ strerror(errno));
+ return (void *)0;
+ }
+
+ page_sz = (uint32_t)retval;
+
+ if (size%page_sz)
+ {
+ printf(">netapi_VM_memMap: error: block size not aligned to page size\n");
+ return (void *)0;
+ }
+
+ if ((uint32_t)addr%page_sz)
+ {
+ printf(">netapi_VM_memMap: error: addr not aligned to page size\n");
+ return (void *)0;
+ }
+
+ map_base = mmap(0, size, (PROT_READ|PROT_WRITE), MAP_SHARED, dev_mem_fd, (off_t)addr & ~mask);
+ if(map_base == (void *) -1)
+ {
+ printf(">netapi_VM_memMap: Failed to mmap \"dev/mem\" err=%s\n",
+ strerror(errno));
+ return (void *)0;
+ }
+ virt_addr = map_base + ((off_t)addr & mask);
+ if(xtraLogs)
+ {
+ printf(">netapi_VM_memMap:Memory mapped Begin Address 0x%x Read Value: 0x%x.\n", virt_addr,*((unsigned long *)virt_addr));
+ // offset = size/(sizeof(unsigned long));
+ // tmpAddr = (unsigned long *)virt_addr + offset-1;
+ tmpAddr = (uint8_t *)virt_addr + 0x6800c;
+ printf("netapi_VM_memMap:Memory mapped End Address 0x%x Read Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));
+ *((unsigned long *)tmpAddr) = 0x1234;
+ printf("netapi_VM_memMap:Memory mapped End Address 0x%x Write Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));
+
+ }
+ return(virt_addr);
+}
+
+/***************************************************************/
+/*************** Memory Initilaization**************************/
+/***************************************************************/
+/* for now use msmc */
+/* Total Permanent memory required in NWAL test
+ * for Packet buffers & descriptor buffers
+ */
+/* Global variables to hold virtual address of various subsystems */
+void *netapi_VM_qmssCfgVaddr;
+void *netapi_VM_qmssDataVaddr;
+void *netapi_VM_srioCfgVaddr;
+void *netapi_VM_passCfgVaddr;
+
+/* also for our descriptor area */
+unsigned char *netapi_VM_QMemLocalDescRam=NULL;
+unsigned char *netapi_VM_QMemGlobalDescRam=NULL;
+
+/* finaly SA context area */
+unsigned char *netapi_VM_SaContextVaddr=NULL;
+
+/************************************************
+ * teardown VM memory
+ ***********************************************/
+void netapi_VM_memory_teardown(void)
+{
+ netapi_utilModClose();
+ close(dev_mem_fd);
+#ifndef USE_MODULE_MMAP
+ close(temp_fd);
+#endif
+}
+/*************************************************
+ * setup VM memory
+ ************************************************/
+int netapi_VM_memory_setup(void)
+{
+/* (1) big chunck of memory out of MSMC or DDR via kernel CMA */
+#ifdef NETAPI_USE_DDR
+ if (netapi_VM_memAllocInit( NULL, 0) == nwal_FALSE) {
+ printf(">netapi ERROR: netapi_V_MmemAllocInit from DDR/CMA failed\n");
+ return (-1);
+ }
+#else //uncached MSMC
+ if (netapi_VM_memAllocInit((uint8_t*)MSMC_SRAM_BASE_ADDR,
+ NETAPI_PERM_MEM_SZ) == nwal_FALSE) {
+ printf(">netapi ERROR: netapi_V_MmemAllocInit from MSMC failed\n");
+ return (-1);
+ }
+#endif
+
+ /* (2) Create virtual memory maps for peripherals */
+ /* (2a) QMSS CFG Regs */
+ netapi_VM_qmssCfgVaddr = netapi_VM_memMap((void*)QMSS_CFG_BASE_ADDR,
+ QMSS_CFG_BLK_SZ);
+ if (!netapi_VM_qmssCfgVaddr)
+ {
+ printf(">netapi ERROR: Failed to map QMSS CFG registers\n");
+ return (-1);
+ }
+ printf(">netapi QMSS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_CFG_BASE_ADDR, netapi_VM_qmssCfgVaddr);
+
+ /* (2b) QMSS DATA Regs */
+#ifdef USE_MODULE_MMAP
+ netapi_VM_qmssDataVaddr = (void *) netapi_utilGetVaOfBufferArea(NETAPIMOD_MMAP_QM_DATA_REG_MEM_OFFSET, QMSS_DATA_BLK_SZ);
+#else
+ netapi_VM_qmssDataVaddr = netapi_VM_memMap((void*)QMSS_DATA_BASE_ADDR,
+ QMSS_DATA_BLK_SZ);
+#endif
+
+ if (!netapi_VM_qmssDataVaddr)
+ {
+ printf(">netapi ERROR: Failed to map QMSS DATA registers\n");
+ return (-1);
+ }
+ printf(">netapi QMSS_DATA_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_DATA_BASE_ADDR, netapi_VM_qmssDataVaddr);
+
+ /* (2c) SRIO CFG Regs */
+ netapi_VM_srioCfgVaddr = netapi_VM_memMap((void*)SRIO_CFG_BASE_ADDR,
+ SRIO_CFG_BLK_SZ);
+ if (!netapi_VM_srioCfgVaddr)
+ {
+ printf(">netapi ERROR: Failed to map SRIO CFG registers\n");
+ return (-1);
+ }
+ printf(">netapi SRIO_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)SRIO_CFG_BASE_ADDR, netapi_VM_srioCfgVaddr);
+
+ /* (2d) PASS CFG Regs */
+ netapi_VM_passCfgVaddr = netapi_VM_memMap((void*)PASS_CFG_BASE_ADDR,
+ PASS_CFG_BLK_SZ);
+ if (!netapi_VM_passCfgVaddr)
+ {
+ printf(">netapi ERROR: Failed to map PASS CFG registers\n");
+ return (-1);
+ }
+ printf(">netapi PASS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)PASS_CFG_BASE_ADDR, netapi_VM_passCfgVaddr);
+
+ /* (2e) SA COntext area */
+#ifdef NETAPI_ENABLE_SECURITY
+#define SEC_CONTEXT_SZ 384 //not tunable
+/* allocate 2x number of tunnels since we need one for inflow and one for data mode */
+ netapi_VM_SaContextVaddr = netapi_VM_memAlloc((TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2 *
+ SEC_CONTEXT_SZ),
+ 128);
+ if (!netapi_VM_SaContextVaddr)
+ {
+ printf(">netapi ERROR: Failed to map SA context memory region\n");
+ return (-1);
+ }
+ printf(">netapi VM_SaContext: Memory mapped/allocated at address %p.\n", netapi_VM_SaContextVaddr);
+
+#else
+ netapi_VM_SaContextVaddr= (char *) NULL;
+#endif
+
+ /* (2f) Timer */
+ t64_memmap(dev_mem_fd);
+
+ /* (3) Allocate 2 QM regions from continguous chunk above */
+ netapi_VM_QMemGlobalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128);
+ netapi_VM_QMemLocalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_LOCAL_DESC *
+ TUNE_NETAPI_DESC_SIZE),
+ 128);
+ printf(">netapi local desc region=%x global desc region=%x\n", netapi_VM_QMemLocalDescRam,netapi_VM_QMemGlobalDescRam);
+
+ return 1;
+
+}
+