1 /*
2 * Platform Dependent file for usage of Preallocted Memory
3 *
4 * Copyright (C) 2020, Broadcom.
5 *
6 * Unless you and Broadcom execute a separate written software license
7 * agreement governing use of this software, this software is licensed to you
8 * under the terms of the GNU General Public License version 2 (the "GPL"),
9 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
10 * following added to such license:
11 *
12 * As a special exception, the copyright holders of this software give you
13 * permission to link this software with independent modules, and to copy and
14 * distribute the resulting executable under terms of your choice, provided that
15 * you also meet, for each linked independent module, the terms and conditions of
16 * the license of that module. An independent module is a module which is not
17 * derived from this software. The special exception does not apply to any
18 * modifications of the software.
19 *
20 *
21 * <<Broadcom-WL-IPTag/Open:>>
22 *
23 * $Id$
24 */
25
26 #include <linux/device.h>
27 #include <linux/slab.h>
28 #include <linux/miscdevice.h>
29 #include <linux/sched.h>
30 #include <linux/module.h>
31 #include <linux/fs.h>
32 #include <linux/list.h>
33 #include <linux/io.h>
34 #include <linux/workqueue.h>
35 #include <linux/unistd.h>
36 #include <linux/bug.h>
37 #include <linux/skbuff.h>
38 #include <linux/init.h>
39
40 #ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM
41
42 #define WLAN_STATIC_SCAN_BUF0 5
43 #define WLAN_STATIC_SCAN_BUF1 6
44 #define WLAN_STATIC_DHD_INFO_BUF 7
45 #define WLAN_STATIC_DHD_WLFC_BUF 8
46 #define WLAN_STATIC_DHD_IF_FLOW_LKUP 9
47 #define WLAN_STATIC_DHD_MEMDUMP_RAM 11
48 #define WLAN_STATIC_DHD_WLFC_HANGER 12
49 #define WLAN_STATIC_DHD_PKTID_MAP 13
50 #define WLAN_STATIC_DHD_PKTID_IOCTL_MAP 14
51 #define WLAN_STATIC_DHD_LOG_DUMP_BUF 15
52 #define WLAN_STATIC_DHD_LOG_DUMP_BUF_EX 16
53 #define WLAN_STATIC_DHD_PKTLOG_DUMP_BUF 17
54
55 #define WLAN_SCAN_BUF_SIZE (64 * 1024)
56
57 #define WLAN_DHD_INFO_BUF_SIZE (64 * 1024)
58 #define WLAN_DHD_WLFC_BUF_SIZE (64 * 1024)
59 #define WLAN_DHD_IF_FLOW_LKUP_SIZE (64 * 1024)
60 /* Have 2MB ramsize to accomodate future chips */
61 #define WLAN_DHD_MEMDUMP_SIZE (3 * 1024 * 1024)
62
63 #define PREALLOC_WLAN_SEC_NUM 4
64 #define PREALLOC_WLAN_BUF_NUM 160
65 #define PREALLOC_WLAN_SECTION_HEADER 24
66
67 #ifdef CONFIG_BCMDHD_PCIE
68 #define DHD_SKB_1PAGE_BUFSIZE (PAGE_SIZE*1)
69 #define DHD_SKB_2PAGE_BUFSIZE (PAGE_SIZE*2)
70 #define DHD_SKB_4PAGE_BUFSIZE (PAGE_SIZE*4)
71
72 #define WLAN_SECTION_SIZE_0 (PREALLOC_WLAN_BUF_NUM * 128)
73 #define WLAN_SECTION_SIZE_1 0
74 #define WLAN_SECTION_SIZE_2 0
75 #define WLAN_SECTION_SIZE_3 (PREALLOC_WLAN_BUF_NUM * 1024)
76
77 #define DHD_SKB_1PAGE_BUF_NUM 0
78 #define DHD_SKB_2PAGE_BUF_NUM 192
79 #define DHD_SKB_4PAGE_BUF_NUM 0
80
81 #else
82 #define DHD_SKB_HDRSIZE 336
83 #define DHD_SKB_1PAGE_BUFSIZE ((PAGE_SIZE*1)-DHD_SKB_HDRSIZE)
84 #define DHD_SKB_2PAGE_BUFSIZE ((PAGE_SIZE*2)-DHD_SKB_HDRSIZE)
85 #define DHD_SKB_4PAGE_BUFSIZE ((PAGE_SIZE*4)-DHD_SKB_HDRSIZE)
86
87 #define WLAN_SECTION_SIZE_0 (PREALLOC_WLAN_BUF_NUM * 128)
88 #define WLAN_SECTION_SIZE_1 (PREALLOC_WLAN_BUF_NUM * 128)
89 #define WLAN_SECTION_SIZE_2 (PREALLOC_WLAN_BUF_NUM * 512)
90 #define WLAN_SECTION_SIZE_3 (PREALLOC_WLAN_BUF_NUM * 1024)
91
92 #define DHD_SKB_1PAGE_BUF_NUM 8
93 #define DHD_SKB_2PAGE_BUF_NUM 8
94 #define DHD_SKB_4PAGE_BUF_NUM 1
95 #endif /* CONFIG_BCMDHD_PCIE */
96
97 #define WLAN_SKB_1_2PAGE_BUF_NUM ((DHD_SKB_1PAGE_BUF_NUM) + \
98 (DHD_SKB_2PAGE_BUF_NUM))
99 #define WLAN_SKB_BUF_NUM ((WLAN_SKB_1_2PAGE_BUF_NUM) + \
100 (DHD_SKB_4PAGE_BUF_NUM))
101
102 #define WLAN_MAX_PKTID_ITEMS (8192)
103 #define WLAN_DHD_PKTID_MAP_HDR_SIZE (20 + 4*(WLAN_MAX_PKTID_ITEMS + 1))
104 #define WLAN_DHD_PKTID_MAP_ITEM_SIZE (32)
105 #define WLAN_DHD_PKTID_MAP_SIZE ((WLAN_DHD_PKTID_MAP_HDR_SIZE) + \
106 ((WLAN_MAX_PKTID_ITEMS+1) * WLAN_DHD_PKTID_MAP_ITEM_SIZE))
107
108 #define WLAN_MAX_PKTID_IOCTL_ITEMS (32)
109 #define WLAN_DHD_PKTID_IOCTL_MAP_HDR_SIZE (20 + 4*(WLAN_MAX_PKTID_IOCTL_ITEMS + 1))
110 #define WLAN_DHD_PKTID_IOCTL_MAP_ITEM_SIZE (32)
111 #define WLAN_DHD_PKTID_IOCTL_MAP_SIZE ((WLAN_DHD_PKTID_IOCTL_MAP_HDR_SIZE) + \
112 ((WLAN_MAX_PKTID_IOCTL_ITEMS+1) * WLAN_DHD_PKTID_IOCTL_MAP_ITEM_SIZE))
113
114 #define DHD_LOG_DUMP_BUF_SIZE (1024 * 1024 * 4)
115 #define DHD_LOG_DUMP_BUF_EX_SIZE (1024 * 1024 * 2)
116
117 #define DHD_PKTLOG_DUMP_BUF_SIZE (64 * 1024)
118
119 #define WLAN_DHD_WLFC_HANGER_MAXITEMS 3072
120 #define WLAN_DHD_WLFC_HANGER_ITEM_SIZE 32
121 #define WLAN_DHD_WLFC_HANGER_SIZE ((WLAN_DHD_WLFC_HANGER_ITEM_SIZE) + \
122 ((WLAN_DHD_WLFC_HANGER_MAXITEMS) * (WLAN_DHD_WLFC_HANGER_ITEM_SIZE)))
123
124 static struct sk_buff *wlan_static_skb[WLAN_SKB_BUF_NUM];
125
126 struct wlan_mem_prealloc {
127 void *mem_ptr;
128 unsigned long size;
129 };
130
131 static struct wlan_mem_prealloc wlan_mem_array[PREALLOC_WLAN_SEC_NUM] = {
132 {NULL, (WLAN_SECTION_SIZE_0 + PREALLOC_WLAN_SECTION_HEADER)},
133 {NULL, (WLAN_SECTION_SIZE_1 + PREALLOC_WLAN_SECTION_HEADER)},
134 {NULL, (WLAN_SECTION_SIZE_2 + PREALLOC_WLAN_SECTION_HEADER)},
135 {NULL, (WLAN_SECTION_SIZE_3 + PREALLOC_WLAN_SECTION_HEADER)}
136 };
137
138 static void *wlan_static_scan_buf0 = NULL;
139 static void *wlan_static_scan_buf1 = NULL;
140 static void *wlan_static_dhd_info_buf = NULL;
141 static void *wlan_static_dhd_wlfc_buf = NULL;
142 static void *wlan_static_if_flow_lkup = NULL;
143 static void *wlan_static_dhd_memdump_ram = NULL;
144 static void *wlan_static_dhd_wlfc_hanger = NULL;
145 static void *wlan_static_dhd_pktid_map = NULL;
146 static void *wlan_static_dhd_pktid_ioctl_map = NULL;
147 static void *wlan_static_dhd_log_dump_buf = NULL;
148 static void *wlan_static_dhd_log_dump_buf_ex = NULL;
149 static void *wlan_static_dhd_pktlog_dump_buf = NULL;
150
151 void dhd_exit_wlan_mem(void);
152
153 void
dhd_wlan_mem_prealloc(int section,unsigned long size)154 *dhd_wlan_mem_prealloc(int section, unsigned long size)
155 {
156 if (section == PREALLOC_WLAN_SEC_NUM) {
157 return wlan_static_skb;
158 }
159
160 if (section == WLAN_STATIC_SCAN_BUF0) {
161 return wlan_static_scan_buf0;
162 }
163
164 if (section == WLAN_STATIC_SCAN_BUF1) {
165 return wlan_static_scan_buf1;
166 }
167
168 if (section == WLAN_STATIC_DHD_INFO_BUF) {
169 if (size > WLAN_DHD_INFO_BUF_SIZE) {
170 pr_err("request DHD_INFO size(%lu) is bigger than"
171 " static size(%d).\n", size,
172 WLAN_DHD_INFO_BUF_SIZE);
173 return NULL;
174 }
175 return wlan_static_dhd_info_buf;
176 }
177
178 if (section == WLAN_STATIC_DHD_WLFC_BUF) {
179 if (size > WLAN_DHD_WLFC_BUF_SIZE) {
180 pr_err("request DHD_WLFC size(%lu) is bigger than"
181 " static size(%d).\n",
182 size, WLAN_DHD_WLFC_BUF_SIZE);
183 return NULL;
184 }
185 return wlan_static_dhd_wlfc_buf;
186 }
187
188 if (section == WLAN_STATIC_DHD_WLFC_HANGER) {
189 if (size > WLAN_DHD_WLFC_HANGER_SIZE) {
190 pr_err("request DHD_WLFC_HANGER size(%lu) is bigger than"
191 " static size(%d).\n",
192 size, WLAN_DHD_WLFC_HANGER_SIZE);
193 return NULL;
194 }
195 return wlan_static_dhd_wlfc_hanger;
196 }
197
198 if (section == WLAN_STATIC_DHD_IF_FLOW_LKUP) {
199 if (size > WLAN_DHD_IF_FLOW_LKUP_SIZE) {
200 pr_err("request DHD_WLFC size(%lu) is bigger than"
201 " static size(%d).\n",
202 size, WLAN_DHD_WLFC_BUF_SIZE);
203 return NULL;
204 }
205 return wlan_static_if_flow_lkup;
206 }
207
208 if (section == WLAN_STATIC_DHD_MEMDUMP_RAM) {
209 if (size > WLAN_DHD_MEMDUMP_SIZE) {
210 pr_err("request DHD_MEMDUMP_RAM size(%lu) is bigger"
211 " than static size(%d).\n",
212 size, WLAN_DHD_MEMDUMP_SIZE);
213 return NULL;
214 }
215 return wlan_static_dhd_memdump_ram;
216 }
217
218 if (section == WLAN_STATIC_DHD_PKTID_MAP) {
219 if (size > WLAN_DHD_PKTID_MAP_SIZE) {
220 pr_err("request DHD_PKTID_MAP size(%lu) is bigger than"
221 " static size(%d).\n",
222 size, WLAN_DHD_PKTID_MAP_SIZE);
223 return NULL;
224 }
225 return wlan_static_dhd_pktid_map;
226 }
227
228 if (section == WLAN_STATIC_DHD_PKTID_IOCTL_MAP) {
229 if (size > WLAN_DHD_PKTID_IOCTL_MAP_SIZE) {
230 pr_err("request DHD_PKTID_IOCTL_MAP size(%lu) is bigger than"
231 " static size(%d).\n",
232 size, WLAN_DHD_PKTID_IOCTL_MAP_SIZE);
233 return NULL;
234 }
235 return wlan_static_dhd_pktid_ioctl_map;
236 }
237
238 if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF) {
239 if (size > DHD_LOG_DUMP_BUF_SIZE) {
240 pr_err("request DHD_LOG_DUMP_BUF size(%lu) is bigger then"
241 " static size(%d).\n",
242 size, DHD_LOG_DUMP_BUF_SIZE);
243 return NULL;
244 }
245 return wlan_static_dhd_log_dump_buf;
246 }
247
248 if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF_EX) {
249 if (size > DHD_LOG_DUMP_BUF_EX_SIZE) {
250 pr_err("request DHD_LOG_DUMP_BUF_EX size(%lu) is bigger then"
251 " static size(%d).\n",
252 size, DHD_LOG_DUMP_BUF_EX_SIZE);
253 return NULL;
254 }
255 return wlan_static_dhd_log_dump_buf_ex;
256 }
257
258 if (section == WLAN_STATIC_DHD_PKTLOG_DUMP_BUF) {
259 if (size > DHD_PKTLOG_DUMP_BUF_SIZE) {
260 pr_err("request DHD_PKTLOG_DUMP_BUF size(%lu) is bigger then"
261 " static size(%d).\n",
262 size, DHD_PKTLOG_DUMP_BUF_SIZE);
263 return NULL;
264 }
265 return wlan_static_dhd_pktlog_dump_buf;
266 }
267
268 if ((section < 0) || (section >= PREALLOC_WLAN_SEC_NUM)) {
269 return NULL;
270 }
271
272 if (wlan_mem_array[section].size < size) {
273 return NULL;
274 }
275
276 return wlan_mem_array[section].mem_ptr;
277 }
278 EXPORT_SYMBOL(dhd_wlan_mem_prealloc);
279
280 int
dhd_init_wlan_mem(void)281 dhd_init_wlan_mem(void)
282 {
283 int i;
284 int j;
285
286 #if !defined(CONFIG_BCMDHD_PCIE)
287 for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
288 wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE, GFP_KERNEL);
289 if (!wlan_static_skb[i]) {
290 pr_err("Failed to alloc 1PAGE SKB BUF\n");
291 goto err_skb_alloc;
292 }
293 }
294 #endif /* !CONFIG_BCMDHD_PCIE */
295
296 for (i = DHD_SKB_1PAGE_BUF_NUM; i < WLAN_SKB_1_2PAGE_BUF_NUM; i++) {
297 wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_2PAGE_BUFSIZE, GFP_KERNEL);
298 if (!wlan_static_skb[i]) {
299 pr_err("Failed to alloc 2PAGE SKB BUF\n");
300 goto err_skb_alloc;
301 }
302 }
303
304 #if !defined(CONFIG_BCMDHD_PCIE)
305 wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE, GFP_KERNEL);
306 if (!wlan_static_skb[i]) {
307 pr_err("Failed to alloc 4PAGE SKB BUF\n");
308 goto err_skb_alloc;
309 }
310 #endif /* !CONFIG_BCMDHD_PCIE */
311
312 for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
313 if (wlan_mem_array[i].size > 0) {
314 wlan_mem_array[i].mem_ptr =
315 kmalloc(wlan_mem_array[i].size, GFP_KERNEL);
316
317 if (!wlan_mem_array[i].mem_ptr) {
318 pr_err("Failed to mem_alloc for WLAN\n");
319 goto err_mem_alloc;
320 }
321 }
322 }
323
324 wlan_static_scan_buf0 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
325 if (!wlan_static_scan_buf0) {
326 pr_err("Failed to alloc wlan_static_scan_buf0\n");
327 goto err_mem_alloc;
328 }
329
330 wlan_static_scan_buf1 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
331 if (!wlan_static_scan_buf1) {
332 pr_err("Failed to alloc wlan_static_scan_buf1\n");
333 goto err_mem_alloc;
334 }
335
336 wlan_static_dhd_log_dump_buf = kmalloc(DHD_LOG_DUMP_BUF_SIZE, GFP_KERNEL);
337 if (!wlan_static_dhd_log_dump_buf) {
338 pr_err("Failed to alloc wlan_static_dhd_log_dump_buf\n");
339 goto err_mem_alloc;
340 }
341
342 wlan_static_dhd_log_dump_buf_ex = kmalloc(DHD_LOG_DUMP_BUF_EX_SIZE, GFP_KERNEL);
343 if (!wlan_static_dhd_log_dump_buf_ex) {
344 pr_err("Failed to alloc wlan_static_dhd_log_dump_buf_ex\n");
345 goto err_mem_alloc;
346 }
347
348 wlan_static_dhd_info_buf = kmalloc(WLAN_DHD_INFO_BUF_SIZE, GFP_KERNEL);
349 if (!wlan_static_dhd_info_buf) {
350 pr_err("Failed to alloc wlan_static_dhd_info_buf\n");
351 goto err_mem_alloc;
352 }
353
354 #ifdef CONFIG_BCMDHD_PCIE
355 wlan_static_if_flow_lkup = kmalloc(WLAN_DHD_IF_FLOW_LKUP_SIZE,
356 GFP_KERNEL);
357 if (!wlan_static_if_flow_lkup) {
358 pr_err("Failed to alloc wlan_static_if_flow_lkup\n");
359 goto err_mem_alloc;
360 }
361
362 #ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
363 wlan_static_dhd_pktid_map = kmalloc(WLAN_DHD_PKTID_MAP_SIZE,
364 GFP_KERNEL);
365 if (!wlan_static_dhd_pktid_map) {
366 pr_err("Failed to alloc wlan_static_dhd_pktid_map\n");
367 goto err_mem_alloc;
368 }
369
370 wlan_static_dhd_pktid_ioctl_map = kmalloc(WLAN_DHD_PKTID_IOCTL_MAP_SIZE,
371 GFP_KERNEL);
372 if (!wlan_static_dhd_pktid_ioctl_map) {
373 pr_err("Failed to alloc wlan_static_dhd_pktid_ioctl_map\n");
374 goto err_mem_alloc;
375 }
376 #endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
377 #else
378 wlan_static_dhd_wlfc_buf = kmalloc(WLAN_DHD_WLFC_BUF_SIZE,
379 GFP_KERNEL);
380 if (!wlan_static_dhd_wlfc_buf) {
381 pr_err("Failed to alloc wlan_static_dhd_wlfc_buf\n");
382 goto err_mem_alloc;
383 }
384
385 wlan_static_dhd_wlfc_hanger = kmalloc(WLAN_DHD_WLFC_HANGER_SIZE,
386 GFP_KERNEL);
387 if (!wlan_static_dhd_wlfc_hanger) {
388 pr_err("Failed to alloc wlan_static_dhd_wlfc_hanger\n");
389 goto err_mem_alloc;
390 }
391 #endif /* CONFIG_BCMDHD_PCIE */
392
393 #ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
394 wlan_static_dhd_memdump_ram = kmalloc(WLAN_DHD_MEMDUMP_SIZE, GFP_KERNEL);
395 if (!wlan_static_dhd_memdump_ram) {
396 pr_err("Failed to alloc wlan_static_dhd_memdump_ram\n");
397 goto err_mem_alloc;
398 }
399 #endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
400
401 wlan_static_dhd_pktlog_dump_buf = kmalloc(DHD_PKTLOG_DUMP_BUF_SIZE, GFP_KERNEL);
402 if (!wlan_static_dhd_pktlog_dump_buf) {
403 pr_err("Failed to alloc wlan_static_dhd_pktlog_dump_buf\n");
404 goto err_mem_alloc;
405 }
406
407 pr_err("%s: WIFI MEM Allocated\n", __FUNCTION__);
408 return 0;
409
410 err_mem_alloc:
411 dhd_exit_wlan_mem();
412 return -ENOMEM;
413
414 err_skb_alloc:
415 /*
416 * When all the skb alloc buf couldn't alloced, free these buf with alloced size
417 * dhd_exit_wlan_mem will free with total size (don't know alloced size)
418 */
419 pr_err("Failed to skb_alloc for WLAN\n");
420 for (j = 0; j < i; j++) {
421 dev_kfree_skb(wlan_static_skb[j]);
422 }
423 return -ENOMEM;
424 }
425
426 EXPORT_SYMBOL(dhd_init_wlan_mem);
427
428 void
dhd_exit_wlan_mem(void)429 dhd_exit_wlan_mem(void)
430 {
431 int i = 0;
432
433 #ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
434 if (wlan_static_dhd_memdump_ram) {
435 kfree(wlan_static_dhd_memdump_ram);
436 }
437
438 #endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
439
440 #ifdef CONFIG_BCMDHD_PCIE
441 if (wlan_static_if_flow_lkup) {
442 kfree(wlan_static_if_flow_lkup);
443 }
444
445 #ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
446 if (wlan_static_dhd_pktid_map) {
447 kfree(wlan_static_dhd_pktid_map);
448 }
449
450 if (wlan_static_dhd_pktid_ioctl_map) {
451 kfree(wlan_static_dhd_pktid_ioctl_map);
452 }
453 #endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
454 #else
455 if (wlan_static_dhd_wlfc_buf) {
456 kfree(wlan_static_dhd_wlfc_buf);
457 }
458
459 if (wlan_static_dhd_wlfc_hanger) {
460 kfree(wlan_static_dhd_wlfc_hanger);
461 }
462 #endif /* CONFIG_BCMDHD_PCIE */
463 if (wlan_static_dhd_info_buf) {
464 kfree(wlan_static_dhd_info_buf);
465 }
466
467 if (wlan_static_dhd_log_dump_buf) {
468 kfree(wlan_static_dhd_log_dump_buf);
469 }
470
471 if (wlan_static_dhd_log_dump_buf_ex) {
472 kfree(wlan_static_dhd_log_dump_buf_ex);
473 }
474
475 if (wlan_static_scan_buf1) {
476 kfree(wlan_static_scan_buf1);
477 }
478
479 if (wlan_static_scan_buf0) {
480 kfree(wlan_static_scan_buf0);
481 }
482
483 if (wlan_static_dhd_pktlog_dump_buf) {
484 kfree(wlan_static_dhd_pktlog_dump_buf);
485 }
486
487 for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
488 if (wlan_mem_array[i].mem_ptr) {
489 kfree(wlan_mem_array[i].mem_ptr);
490 }
491 }
492
493 for (i = 0; i < WLAN_SKB_BUF_NUM; i++) {
494 dev_kfree_skb(wlan_static_skb[i]);
495 }
496
497 return;
498 }
499 EXPORT_SYMBOL(dhd_exit_wlan_mem);
500 #endif /* CONFIG_BROADCOM_WIFI_RESERVED_MEM */
501