c979cb22b528b256972e2db5448ccf1cb6ccad91
[keystone-rtos/netapi.git] / ti / runtime / netapi / src / netapi_vm.c
1 \r
2 /******************************************************************************\r
3  * FILE  netapi_vm.c\r
4  * PURPOSE:  Memory allocator for NETAPI and related utilities\r
5  *   -- using MSMC for descriptors/buffers (current), use CMA (future) \r
6  ******************************************************************************\r
7  * FILE NAME:   netapi_vm.c\r
8  *\r
9  * DESCRIPTION: Memory allocator for netapi \r
10  * This is only a permanent memory allocator.\r
11  *\r
12  * REVISION HISTORY:\r
13  *\r
14  *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
15  * \r
16  *  Redistribution and use in source and binary forms, with or without \r
17  *  modification, are permitted provided that the following conditions \r
18  *  are met:\r
19  *\r
20  *    Redistributions of source code must retain the above copyright \r
21  *    notice, this list of conditions and the following disclaimer.\r
22  *\r
23  *    Redistributions in binary form must reproduce the above copyright\r
24  *    notice, this list of conditions and the following disclaimer in the \r
25  *    documentation and/or other materials provided with the   \r
26  *    distribution.\r
27  *\r
28  *    Neither the name of Texas Instruments Incorporated nor the names of\r
29  *    its contributors may be used to endorse or promote products derived\r
30  *    from this software without specific prior written permission.\r
31  *\r
32  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
33  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
34  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
35  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
36  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
37  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
38  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
39  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
40  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
41  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
42  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
43  *\r
44  */\r
45 \r
46 #include <stdint.h>\r
47 #include <stdio.h>\r
48 #include <string.h>\r
49 #include <sys/types.h>\r
50 #include <sys/stat.h>\r
51 #include <fcntl.h>\r
52 #include <sys/mman.h>\r
53 #include <errno.h>\r
54 #include <unistd.h>\r
55 \r
56 #include <ti/drv/nwal/nwal.h> \r
57 #include "netapi_vm.h"\r
58 \r
59 \r
60 \r
61 /***********************RAW MEMORY ALLOCATION & TRANSLATION*************************/\r
62 /* Macro to align x to y */\r
63 #define align(x,y)   ((x + y) & (~y))\r
64 \r
65 uint8_t *netapi_VM_mem_start_phy = (uint8_t*)0;\r
66 uint8_t *netapi_VM_mem_start = (uint8_t*)0;\r
67 \r
68 static uint8_t *netapi_VM_mem_end = (uint8_t*)0;\r
69 static uint8_t *netapi_VM_mem_alloc_ptr = (uint8_t*)0;\r
70 static uint32_t netapi_VM_mem_size = 0;\r
71 \r
72 \r
73 \r
74 /* File descriptor for /dev/mem */ \r
75 static int dev_mem_fd;\r
76 \r
77 nwal_Bool_t netapi_VM_memAllocInit\r
78 (\r
79     uint8_t     *addr, /* Physical address */\r
80     uint32_t    size   /* Size of block */\r
81 )\r
82 {\r
83     void *map_base; \r
84 \r
85     if((dev_mem_fd = open("/dev/mem", (O_RDWR | O_SYNC))) == -1)\r
86     {\r
87         printf(">netapi_VM_memAllocInit: Failed to open \"dev/mem\" err=%s\n",\r
88                strerror(errno));\r
89         return nwal_FALSE;\r
90     }\r
91 \r
92     map_base = netapi_VM_memMap ((void *)addr, size); \r
93 \r
94     if (!map_base)\r
95     {\r
96         printf(">netapi_VM_memAllocInit: Failed to mmap addr (0x%x)", addr);\r
97         return nwal_FALSE;\r
98     }\r
99 \r
100     printf(">netapi_VM_memAllocInit: Phy Addr %x Memory (%d bytes) mapped at address %p.\n", addr,size,  map_base); \r
101 \r
102     netapi_VM_mem_alloc_ptr = netapi_VM_mem_start = map_base;\r
103     netapi_VM_mem_size = size;\r
104     netapi_VM_mem_end = netapi_VM_mem_start + netapi_VM_mem_size;\r
105     netapi_VM_mem_start_phy = addr;\r
106     return nwal_TRUE;\r
107 }\r
108 \r
109 void* netapi_VM_memAlloc\r
110 (\r
111     uint32_t    size,\r
112     uint32_t    align\r
113 )\r
114 {\r
115     uint32_t key;\r
116     uint8_t *alloc_ptr;\r
117     void *p_block =NULL;\r
118 \r
119     Osal_stubCsEnter();\r
120     alloc_ptr = (uint8_t*)align((uint32_t)netapi_VM_mem_alloc_ptr, align);\r
121     if ((alloc_ptr + size) < netapi_VM_mem_end)\r
122     {\r
123         p_block =(void *)alloc_ptr;\r
124         netapi_VM_mem_alloc_ptr = alloc_ptr + size;\r
125         Osal_stubCsExit(key);\r
126         memset (p_block, 0, size);\r
127     }\r
128     else \r
129     {\r
130         Osal_stubCsExit(key);\r
131     }\r
132     return p_block;\r
133 }\r
134 uint32_t    xtraLogs=0;\r
135 /* Api to map the give physical address to virtual memory space */\r
136 void *netapi_VM_memMap\r
137 (\r
138     void        *addr, /* Physical address */\r
139     uint32_t    size   /* Size of block */\r
140 )\r
141 {\r
142     void            *map_base,*virt_addr,*tmpAddr;\r
143     uint32_t        page_sz;\r
144     long            retval;\r
145     uint32_t        mask = (size-1);\r
146     uint32_t        offset;\r
147 \r
148     retval = sysconf(_SC_PAGE_SIZE);\r
149     if (retval == -1)\r
150     {\r
151         printf(">netapi_VM_memMap: Failed to get page size err=%s\n",\r
152                strerror(errno));\r
153         return (void *)0;\r
154     }\r
155 \r
156     page_sz = (uint32_t)retval;\r
157 \r
158     if (size%page_sz)\r
159     {\r
160         printf(">netapi_VM_memMap: error: block size not aligned to page size\n");\r
161         return (void *)0;\r
162     }\r
163 \r
164     if ((uint32_t)addr%page_sz)\r
165     {\r
166         printf(">netapi_VM_memMap: error: addr not aligned to page size\n");\r
167         return (void *)0;\r
168     }\r
169 \r
170     map_base = mmap(0, size, (PROT_READ|PROT_WRITE), MAP_SHARED, dev_mem_fd, (off_t)addr & ~mask);\r
171     if(map_base == (void *) -1) \r
172     {\r
173         printf(">netapi_VM_memMap: Failed to mmap \"dev/mem\" err=%s\n",\r
174                strerror(errno));\r
175         return (void *)0;\r
176     }\r
177     virt_addr = map_base + ((off_t)addr & mask);\r
178     if(xtraLogs)\r
179     {\r
180         printf(">netapi_VM_memMap:Memory mapped Begin Address 0x%x Read Value: 0x%x.\n", virt_addr,*((unsigned long *)virt_addr));\r
181  //       offset = size/(sizeof(unsigned long));\r
182   //      tmpAddr = (unsigned long *)virt_addr + offset-1;\r
183         tmpAddr = (uint8_t *)virt_addr + 0x6800c;\r
184         printf("netapi_VM_memMap:Memory mapped End Address 0x%x Read Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));\r
185         *((unsigned long *)tmpAddr) = 0x1234;\r
186         printf("netapi_VM_memMap:Memory mapped End Address 0x%x Write Value: 0x%x.\n", (unsigned long *)tmpAddr ,*((unsigned long *)tmpAddr));\r
187         \r
188     }\r
189     return(virt_addr);\r
190 }\r
191 \r
192 /***************************************************************/\r
193 /*************** Memory Initilaization**************************/\r
194 /***************************************************************/\r
195 /* for now use msmc */\r
196 /* Total Permanent memory required in NWAL test\r
197  * for Packet buffers & descriptor buffers\r
198  */\r
199 #define NETAPI_PERM_MEM_SZ  (TUNE_NETAPI_PERM_MEM_SZ) \r
200 \r
201 /* Physical address map & size for various subsystems */\r
202 #define QMSS_CFG_BASE_ADDR  CSL_QM_SS_CFG_QUE_PEEK_REGS\r
203 #define QMSS_CFG_BLK_SZ (1*1024*1024)\r
204 #define QMSS_DATA_BASE_ADDR 0x44020000 \r
205 #define QMSS_DATA_BLK_SZ (0x60000)\r
206 #define SRIO_CFG_BASE_ADDR  CSL_SRIO_CONFIG_REGS\r
207 #define SRIO_CFG_BLK_SZ (132*1024)\r
208 #define PASS_CFG_BASE_ADDR  CSL_PA_SS_CFG_REGS \r
209 #define PASS_CFG_BLK_SZ (1*1024*1024)\r
210 \r
211 #define MSMC_SRAM_BASE_ADDR CSL_MSMC_SRAM_REGS\r
212 \r
213 /* Global variables to hold virtual address of various subsystems */\r
214 void *netapi_VM_qmssCfgVaddr;\r
215 void *netapi_VM_qmssDataVaddr;\r
216 void *netapi_VM_srioCfgVaddr;\r
217 void *netapi_VM_passCfgVaddr;\r
218 \r
219 /* also for our descriptor area */\r
220 unsigned char *netapi_VM_QMemLocalDescRam=NULL;\r
221 unsigned char *netapi_VM_QMemGlobalDescRam=NULL;\r
222 \r
223 /* finaly SA context area */\r
224 unsigned char *netapi_VM_SaContextVaddr=NULL;\r
225 \r
226 /*************************************************\r
227  * setup VM memory\r
228  ************************************************/\r
229 int netapi_VM_memory_setup(void)\r
230 {\r
231     /* (1) big chunck of memory out of MSMC -> todo, get from CMA */\r
232     if (netapi_VM_memAllocInit((uint8_t*)MSMC_SRAM_BASE_ADDR,\r
233                               NETAPI_PERM_MEM_SZ) == nwal_FALSE) {\r
234         printf(">netapi ERROR: netapi_V_MmemAllocInit failed\n");\r
235         return (-1);\r
236     }\r
237 \r
238 \r
239     /* (2) Create virtual memory maps for peripherals */\r
240     /* (2a) QMSS CFG Regs */\r
241     netapi_VM_qmssCfgVaddr = netapi_VM_memMap((void*)QMSS_CFG_BASE_ADDR,\r
242                                             QMSS_CFG_BLK_SZ);\r
243     if (!netapi_VM_qmssCfgVaddr)\r
244     {\r
245         printf(">netapi ERROR: Failed to map QMSS CFG registers\n");\r
246         return (-1);\r
247     }\r
248     printf(">netapi QMSS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_CFG_BASE_ADDR, netapi_VM_qmssCfgVaddr);\r
249 \r
250     /* (2b) QMSS DATA Regs */\r
251     netapi_VM_qmssDataVaddr = netapi_VM_memMap((void*)QMSS_DATA_BASE_ADDR,\r
252                                             QMSS_DATA_BLK_SZ);\r
253     if (!netapi_VM_qmssDataVaddr)\r
254     {\r
255         printf(">netapi ERROR: Failed to map QMSS DATA registers\n");\r
256         return (-1);\r
257     }\r
258     printf(">netapi QMSS_DATA_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)QMSS_DATA_BASE_ADDR, netapi_VM_qmssDataVaddr);\r
259 \r
260     /* (2c)  SRIO CFG Regs */\r
261     netapi_VM_srioCfgVaddr = netapi_VM_memMap((void*)SRIO_CFG_BASE_ADDR,\r
262                                             SRIO_CFG_BLK_SZ);\r
263     if (!netapi_VM_srioCfgVaddr)\r
264     {\r
265         printf(">netapi ERROR: Failed to map SRIO CFG registers\n");\r
266         return (-1);\r
267     }\r
268     printf(">netapi SRIO_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)SRIO_CFG_BASE_ADDR, netapi_VM_srioCfgVaddr);\r
269 \r
270     /* (2d) PASS CFG Regs */\r
271     netapi_VM_passCfgVaddr = netapi_VM_memMap((void*)PASS_CFG_BASE_ADDR,\r
272                                             PASS_CFG_BLK_SZ);\r
273     if (!netapi_VM_passCfgVaddr)\r
274     {\r
275         printf(">netapi ERROR: Failed to map PASS CFG registers\n");\r
276         return (-1);\r
277     }\r
278     printf(">netapi PASS_CFG_BASE_ADDR:0x%x Memory mapped at address %p.\n",(void*)PASS_CFG_BASE_ADDR, netapi_VM_passCfgVaddr);\r
279 \r
280     /* (2e)  SA COntext area */\r
281 #ifdef NETAPI_ENABLE_SECURITY\r
282 #define SEC_CONTEXT_SZ 384  //not tunable\r
283 /* allocate 2x number of tunnels since we need one for inflow and one for data mode */\r
284    netapi_VM_SaContextVaddr = netapi_VM_memAlloc((TUNE_NETAPI_MAX_NUM_IPSEC_CHANNELS*2 *\r
285                                         SEC_CONTEXT_SZ),\r
286                                         128);\r
287    if (!netapi_VM_SaContextVaddr)\r
288     {\r
289         printf(">netapi ERROR: Failed to map SA context memory region\n");\r
290         return (-1);\r
291     }\r
292     printf(">netapi VM_SaContext: Memory mapped/allocated at address %p.\n", netapi_VM_SaContextVaddr);\r
293 \r
294 #else\r
295    netapi_VM_SaContextVaddr= (char *) NULL;\r
296 #endif\r
297 \r
298     /* (2f) Timer */\r
299     t64_memmap(dev_mem_fd);\r
300 \r
301     /* (3) Allocate 2 QM regions from continguous chunk above */\r
302     netapi_VM_QMemGlobalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_GLOBAL_DESC *\r
303                                         TUNE_NETAPI_DESC_SIZE),\r
304                                         128);\r
305     netapi_VM_QMemLocalDescRam = (void *)netapi_VM_memAlloc((TUNE_NETAPI_NUM_LOCAL_DESC *\r
306                                         TUNE_NETAPI_DESC_SIZE),\r
307                                         128);\r
308     printf(">netapi local desc region=%x global desc region=%x\n", netapi_VM_QMemLocalDescRam,netapi_VM_QMemGlobalDescRam);\r
309 \r
310         return 1;\r
311 \r
312 }\r
313 \r