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