1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/init.h>
4 #include <linux/platform_device.h>
5 #include <linux/delay.h>
6 #include <linux/err.h>
7 #include <linux/skbuff.h>
8
9 #define DHD_STATIC_VERSION_STR "101.10.361.25 (wlan=r892223-20220928-2)"
10 #define STATIC_ERROR_LEVEL BIT(0)
11 #define STATIC_TRACE_LEVEL BIT(1)
12 #define STATIC_MSG_LEVEL BIT(0)
13 uint static_msg_level = STATIC_ERROR_LEVEL | STATIC_MSG_LEVEL;
14
15 #define DHD_STATIC_MSG(x, args...) \
16 do { \
17 if (static_msg_level & STATIC_MSG_LEVEL) { \
18 pr_err("[dhd] STATIC-MSG) %s : " x, __func__, ## args); \
19 } \
20 } while (0)
21 #define DHD_STATIC_ERROR(x, args...) \
22 do { \
23 if (static_msg_level & STATIC_ERROR_LEVEL) { \
24 pr_err("[dhd] STATIC-ERROR) %s : " x, __func__, ## args); \
25 } \
26 } while (0)
27 #define DHD_STATIC_TRACE(x, args...) \
28 do { \
29 if (static_msg_level & STATIC_TRACE_LEVEL) { \
30 pr_err("[dhd] STATIC-TRACE) %s : " x, __func__, ## args); \
31 } \
32 } while (0)
33
34 #define BCMDHD_SDIO
35 #define BCMDHD_PCIE
36 //#define BCMDHD_USB
37 #define CONFIG_BCMDHD_VTS { : = y}
38 #define CONFIG_BCMDHD_DEBUG { : = y}
39 //#define BCMDHD_UNUSE_MEM
40
41 #ifndef MAX_NUM_ADAPTERS
42 #define MAX_NUM_ADAPTERS 1
43 #endif
44
45 enum dhd_prealloc_index {
46 DHD_PREALLOC_PROT = 0,
47 #if defined(BCMDHD_SDIO)
48 DHD_PREALLOC_RXBUF = 1,
49 DHD_PREALLOC_DATABUF = 2,
50 #endif /* BCMDHD_SDIO */
51 DHD_PREALLOC_OSL_BUF = 3,
52 DHD_PREALLOC_SKB_BUF = 4,
53 DHD_PREALLOC_WIPHY_ESCAN0 = 5,
54 DHD_PREALLOC_WIPHY_ESCAN1 = 6,
55 DHD_PREALLOC_DHD_INFO = 7,
56 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
57 DHD_PREALLOC_DHD_WLFC_INFO = 8,
58 #endif /* BCMDHD_SDIO | BCMDHD_USB */
59 #ifdef BCMDHD_PCIE
60 DHD_PREALLOC_IF_FLOW_LKUP = 9,
61 #endif /* BCMDHD_PCIE */
62 DHD_PREALLOC_MEMDUMP_BUF = 10,
63 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
64 DHD_PREALLOC_MEMDUMP_RAM = 11,
65 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
66 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
67 DHD_PREALLOC_DHD_WLFC_HANGER = 12,
68 #endif /* BCMDHD_SDIO | BCMDHD_USB */
69 DHD_PREALLOC_PKTID_MAP = 13,
70 DHD_PREALLOC_PKTID_MAP_IOCTL = 14,
71 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
72 DHD_PREALLOC_DHD_LOG_DUMP_BUF = 15,
73 DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX = 16,
74 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
75 DHD_PREALLOC_DHD_PKTLOG_DUMP_BUF = 17,
76 DHD_PREALLOC_STAT_REPORT_BUF = 18,
77 DHD_PREALLOC_WL_ESCAN = 19,
78 DHD_PREALLOC_FW_VERBOSE_RING = 20,
79 DHD_PREALLOC_FW_EVENT_RING = 21,
80 DHD_PREALLOC_DHD_EVENT_RING = 22,
81 #if defined(BCMDHD_UNUSE_MEM)
82 DHD_PREALLOC_NAN_EVENT_RING = 23,
83 #endif /* BCMDHD_UNUSE_MEM */
84 DHD_PREALLOC_MAX
85 };
86
87 #define STATIC_BUF_MAX_NUM 20
88 #define STATIC_BUF_SIZE (PAGE_SIZE * 2)
89
90 #ifndef CUSTOM_LOG_DUMP_BUFSIZE_MB
91 /* DHD_LOG_DUMP_BUF_SIZE 4 MB static memory in kernel */
92 #define CUSTOM_LOG_DUMP_BUFSIZE_MB 4
93 #endif /* CUSTOM_LOG_DUMP_BUFSIZE_MB */
94
95 #define DHD_PREALLOC_PROT_SIZE (16 * 1024)
96 #define DHD_PREALLOC_RXBUF_SIZE (24 * 1024)
97 #define DHD_PREALLOC_DATABUF_SIZE (64 * 1024)
98 #define DHD_PREALLOC_OSL_BUF_SIZE (STATIC_BUF_MAX_NUM * STATIC_BUF_SIZE)
99 #define DHD_PREALLOC_WIPHY_ESCAN0_SIZE (64 * 1024)
100 #define DHD_PREALLOC_DHD_INFO_SIZE (43 * 1024)
101 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
102 #define DHD_PREALLOC_MEMDUMP_RAM_SIZE (1290 * 1024)
103 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
104 #define DHD_PREALLOC_DHD_WLFC_HANGER_SIZE (73 * 1024)
105 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
106 #define DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE (1024 * 1024 * CUSTOM_LOG_DUMP_BUFSIZE_MB)
107 #define DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE (8 * 1024)
108 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
109 #define DHD_PREALLOC_WL_ESCAN_SIZE (70 * 1024)
110 #ifdef CONFIG_64BIT
111 #define DHD_PREALLOC_IF_FLOW_LKUP_SIZE (20 * 1024 * 2)
112 #else
113 #define DHD_PREALLOC_IF_FLOW_LKUP_SIZE (20 * 1024)
114 #endif
115 #define FW_VERBOSE_RING_SIZE (256 * 1024)
116 #define FW_EVENT_RING_SIZE (64 * 1024)
117 #define DHD_EVENT_RING_SIZE (64 * 1024)
118 #define NAN_EVENT_RING_SIZE (64 * 1024)
119
120 #if defined(CONFIG_64BIT)
121 #define WLAN_DHD_INFO_BUF_SIZE (24 * 1024)
122 #define WLAN_DHD_WLFC_BUF_SIZE (64 * 1024)
123 #define WLAN_DHD_IF_FLOW_LKUP_SIZE (64 * 1024)
124 #else
125 #define WLAN_DHD_INFO_BUF_SIZE (16 * 1024)
126 #define WLAN_DHD_WLFC_BUF_SIZE (64 * 1024)
127 #define WLAN_DHD_IF_FLOW_LKUP_SIZE (20 * 1024)
128 #endif /* CONFIG_64BIT */
129 #define WLAN_DHD_MEMDUMP_SIZE (800 * 1024)
130
131 #define DHD_SKB_1PAGE_BUFSIZE (PAGE_SIZE * 1)
132 #define DHD_SKB_2PAGE_BUFSIZE (PAGE_SIZE * 2)
133 #define DHD_SKB_4PAGE_BUFSIZE (PAGE_SIZE * 4)
134
135 #ifdef BCMDHD_PCIE
136 #define DHD_SKB_1PAGE_BUF_NUM 0
137 #define DHD_SKB_2PAGE_BUF_NUM 192
138 #elif defined(BCMDHD_SDIO)
139 #define DHD_SKB_1PAGE_BUF_NUM 8
140 #define DHD_SKB_2PAGE_BUF_NUM 8
141 #endif /* BCMDHD_PCIE */
142 #define DHD_SKB_4PAGE_BUF_NUM 1
143
144 /* The number is defined in linux_osl.c
145 * WLAN_SKB_1_2PAGE_BUF_NUM => STATIC_PKT_1_2PAGE_NUM
146 * WLAN_SKB_BUF_NUM => STATIC_PKT_MAX_NUM
147 */
148 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
149 #define WLAN_SKB_1_2PAGE_BUF_NUM ((DHD_SKB_1PAGE_BUF_NUM) + \
150 (DHD_SKB_2PAGE_BUF_NUM))
151 #define WLAN_SKB_BUF_NUM ((WLAN_SKB_1_2PAGE_BUF_NUM) + (DHD_SKB_4PAGE_BUF_NUM))
152 #endif
153
154 void *wlan_static_prot[MAX_NUM_ADAPTERS] = {};
155 void *wlan_static_rxbuf[MAX_NUM_ADAPTERS] = {};
156 void *wlan_static_databuf[MAX_NUM_ADAPTERS] = {};
157 void *wlan_static_osl_buf[MAX_NUM_ADAPTERS] = {};
158 void *wlan_static_scan_buf0[MAX_NUM_ADAPTERS] = {};
159 void *wlan_static_scan_buf1[MAX_NUM_ADAPTERS] = {};
160 void *wlan_static_dhd_info_buf[MAX_NUM_ADAPTERS] = {};
161 void *wlan_static_dhd_wlfc_info_buf[MAX_NUM_ADAPTERS] = {};
162 void *wlan_static_if_flow_lkup[MAX_NUM_ADAPTERS] = {};
163 void *wlan_static_dhd_memdump_ram_buf[MAX_NUM_ADAPTERS] = {};
164 void *wlan_static_dhd_wlfc_hanger_buf[MAX_NUM_ADAPTERS] = {};
165 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
166 void *wlan_static_dhd_log_dump_buf[MAX_NUM_ADAPTERS] = {};
167 void *wlan_static_dhd_log_dump_buf_ex[MAX_NUM_ADAPTERS] = {};
168 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
169 void *wlan_static_wl_escan_info_buf[MAX_NUM_ADAPTERS] = {};
170 void *wlan_static_fw_verbose_ring_buf[MAX_NUM_ADAPTERS] = {};
171 void *wlan_static_fw_event_ring_buf[MAX_NUM_ADAPTERS] = {};
172 void *wlan_static_dhd_event_ring_buf[MAX_NUM_ADAPTERS] = {};
173 void *wlan_static_nan_event_ring_buf[MAX_NUM_ADAPTERS] = {};
174
175 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
176 static struct sk_buff *wlan_static_skb[MAX_NUM_ADAPTERS][WLAN_SKB_BUF_NUM] = {};
177 #endif /* BCMDHD_SDIO | BCMDHD_PCIE */
178
179 void *
dhd_wlan_mem_prealloc(uint bus_type,int index,int section,unsigned long size)180 dhd_wlan_mem_prealloc(
181 #if defined(BCMDHD_MDRIVER) && !defined(DHD_STATIC_IN_DRIVER)
182 uint bus_type, int index,
183 #endif
184 int section, unsigned long size)
185 {
186 #if !defined(BCMDHD_MDRIVER) || defined(DHD_STATIC_IN_DRIVER)
187 int index = 0;
188 #endif
189
190 #if defined(BCMDHD_MDRIVER) && !defined(DHD_STATIC_IN_DRIVER)
191 DHD_STATIC_MSG("bus_type %d, index %d, section %d, size %ld\n",
192 bus_type, index, section, size);
193 #else
194 DHD_STATIC_MSG("section %d, size %ld\n", section, size);
195 #endif
196
197 if (section == DHD_PREALLOC_PROT)
198 return wlan_static_prot[index];
199
200 #if defined(BCMDHD_SDIO)
201 if (section == DHD_PREALLOC_RXBUF)
202 return wlan_static_rxbuf[index];
203
204 if (section == DHD_PREALLOC_DATABUF)
205 return wlan_static_databuf[index];
206 #endif /* BCMDHD_SDIO */
207
208 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
209 if (section == DHD_PREALLOC_SKB_BUF)
210 return wlan_static_skb[index];
211 #endif /* BCMDHD_SDIO | BCMDHD_PCIE */
212
213 if (section == DHD_PREALLOC_WIPHY_ESCAN0)
214 return wlan_static_scan_buf0[index];
215
216 if (section == DHD_PREALLOC_WIPHY_ESCAN1)
217 return wlan_static_scan_buf1[index];
218
219 if (section == DHD_PREALLOC_OSL_BUF) {
220 if (size > DHD_PREALLOC_OSL_BUF_SIZE) {
221 DHD_STATIC_ERROR("request OSL_BUF(%lu) > %ld\n",
222 size, DHD_PREALLOC_OSL_BUF_SIZE);
223 return NULL;
224 }
225 return wlan_static_osl_buf[index];
226 }
227
228 if (section == DHD_PREALLOC_DHD_INFO) {
229 if (size > DHD_PREALLOC_DHD_INFO_SIZE) {
230 DHD_STATIC_ERROR("request DHD_INFO(%lu) > %d\n",
231 size, DHD_PREALLOC_DHD_INFO_SIZE);
232 return NULL;
233 }
234 return wlan_static_dhd_info_buf[index];
235 }
236 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
237 if (section == DHD_PREALLOC_DHD_WLFC_INFO) {
238 if (size > WLAN_DHD_WLFC_BUF_SIZE) {
239 DHD_STATIC_ERROR("request DHD_WLFC_INFO(%lu) > %d\n",
240 size, WLAN_DHD_WLFC_BUF_SIZE);
241 return NULL;
242 }
243 return wlan_static_dhd_wlfc_info_buf[index];
244 }
245 #endif /* BCMDHD_SDIO | BCMDHD_USB */
246 #ifdef BCMDHD_PCIE
247 if (section == DHD_PREALLOC_IF_FLOW_LKUP) {
248 if (size > DHD_PREALLOC_IF_FLOW_LKUP_SIZE) {
249 DHD_STATIC_ERROR("request DHD_IF_FLOW_LKUP(%lu) > %d\n",
250 size, DHD_PREALLOC_IF_FLOW_LKUP_SIZE);
251 return NULL;
252 }
253 return wlan_static_if_flow_lkup[index];
254 }
255 #endif /* BCMDHD_PCIE */
256 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
257 if (section == DHD_PREALLOC_MEMDUMP_RAM) {
258 if (size > DHD_PREALLOC_MEMDUMP_RAM_SIZE) {
259 DHD_STATIC_ERROR("request DHD_PREALLOC_MEMDUMP_RAM(%lu) > %d\n",
260 size, DHD_PREALLOC_MEMDUMP_RAM_SIZE);
261 return NULL;
262 }
263 return wlan_static_dhd_memdump_ram_buf[index];
264 }
265 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
266 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
267 if (section == DHD_PREALLOC_DHD_WLFC_HANGER) {
268 if (size > DHD_PREALLOC_DHD_WLFC_HANGER_SIZE) {
269 DHD_STATIC_ERROR("request DHD_WLFC_HANGER(%lu) > %d\n",
270 size, DHD_PREALLOC_DHD_WLFC_HANGER_SIZE);
271 return NULL;
272 }
273 return wlan_static_dhd_wlfc_hanger_buf[index];
274 }
275 #endif /* BCMDHD_SDIO | BCMDHD_USB */
276 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
277 if (section == DHD_PREALLOC_DHD_LOG_DUMP_BUF) {
278 if (size > DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE) {
279 DHD_STATIC_ERROR("request DHD_PREALLOC_DHD_LOG_DUMP_BUF(%lu) > %d\n",
280 size, DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE);
281 return NULL;
282 }
283 return wlan_static_dhd_log_dump_buf[index];
284 }
285 if (section == DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX) {
286 if (size > DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE) {
287 DHD_STATIC_ERROR("request DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX(%lu) > %d\n",
288 size, DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE);
289 return NULL;
290 }
291 return wlan_static_dhd_log_dump_buf_ex[index];
292 }
293 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
294 if (section == DHD_PREALLOC_WL_ESCAN) {
295 if (size > DHD_PREALLOC_WL_ESCAN_SIZE) {
296 DHD_STATIC_ERROR("request DHD_PREALLOC_WL_ESCAN(%lu) > %d\n",
297 size, DHD_PREALLOC_WL_ESCAN_SIZE);
298 return NULL;
299 }
300 return wlan_static_wl_escan_info_buf[index];
301 }
302 if (section == DHD_PREALLOC_FW_VERBOSE_RING) {
303 if (size > FW_VERBOSE_RING_SIZE) {
304 DHD_STATIC_ERROR("request DHD_PREALLOC_FW_VERBOSE_RING(%lu) > %d\n",
305 size, FW_VERBOSE_RING_SIZE);
306 return NULL;
307 }
308 return wlan_static_fw_verbose_ring_buf[index];
309 }
310 if (section == DHD_PREALLOC_FW_EVENT_RING) {
311 if (size > FW_EVENT_RING_SIZE) {
312 DHD_STATIC_ERROR("request DHD_PREALLOC_FW_EVENT_RING(%lu) > %d\n",
313 size, FW_EVENT_RING_SIZE);
314 return NULL;
315 }
316 return wlan_static_fw_event_ring_buf[index];
317 }
318 if (section == DHD_PREALLOC_DHD_EVENT_RING) {
319 if (size > DHD_EVENT_RING_SIZE) {
320 DHD_STATIC_ERROR("request DHD_PREALLOC_DHD_EVENT_RING(%lu) > %d\n",
321 size, DHD_EVENT_RING_SIZE);
322 return NULL;
323 }
324 return wlan_static_dhd_event_ring_buf[index];
325 }
326 #if defined(BCMDHD_UNUSE_MEM)
327 if (section == DHD_PREALLOC_NAN_EVENT_RING) {
328 if (size > NAN_EVENT_RING_SIZE) {
329 DHD_STATIC_ERROR("request DHD_PREALLOC_NAN_EVENT_RING(%lu) > %d\n",
330 size, NAN_EVENT_RING_SIZE);
331 return NULL;
332 }
333 return wlan_static_nan_event_ring_buf[index];
334 }
335 #endif /* BCMDHD_UNUSE_MEM */
336 if ((section < 0) || (section > DHD_PREALLOC_MAX))
337 DHD_STATIC_ERROR("request section id(%d) is out of max index %d\n",
338 section, DHD_PREALLOC_MAX);
339
340 DHD_STATIC_ERROR("failed to alloc section %d, size=%ld\n",
341 section, size);
342
343 return NULL;
344 }
345 #ifndef DHD_STATIC_IN_DRIVER
346 EXPORT_SYMBOL(dhd_wlan_mem_prealloc);
347 #endif
348
349 static void
dhd_deinit_wlan_mem(int index)350 dhd_deinit_wlan_mem(int index)
351 {
352 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
353 int i;
354 #endif /* BCMDHD_SDIO | BCMDHD_PCIE */
355
356 if (wlan_static_prot[index])
357 kfree(wlan_static_prot[index]);
358 #if defined(BCMDHD_SDIO)
359 if (wlan_static_rxbuf[index])
360 kfree(wlan_static_rxbuf[index]);
361 if (wlan_static_databuf[index])
362 kfree(wlan_static_databuf[index]);
363 #endif /* BCMDHD_SDIO */
364 if (wlan_static_osl_buf[index])
365 kfree(wlan_static_osl_buf[index]);
366 if (wlan_static_scan_buf0[index])
367 kfree(wlan_static_scan_buf0[index]);
368 if (wlan_static_scan_buf1[index])
369 kfree(wlan_static_scan_buf1[index]);
370 if (wlan_static_dhd_info_buf[index])
371 kfree(wlan_static_dhd_info_buf[index]);
372 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
373 if (wlan_static_dhd_wlfc_info_buf[index])
374 kfree(wlan_static_dhd_wlfc_info_buf[index]);
375 #endif /* BCMDHD_SDIO | BCMDHD_USB */
376 #ifdef BCMDHD_PCIE
377 if (wlan_static_if_flow_lkup[index])
378 kfree(wlan_static_if_flow_lkup[index]);
379 #endif /* BCMDHD_PCIE */
380 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
381 if (wlan_static_dhd_memdump_ram_buf[index])
382 kfree(wlan_static_dhd_memdump_ram_buf[index]);
383 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
384 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
385 if (wlan_static_dhd_wlfc_hanger_buf[index])
386 kfree(wlan_static_dhd_wlfc_hanger_buf[index]);
387 #endif /* BCMDHD_SDIO | BCMDHD_USB */
388 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
389 if (wlan_static_dhd_log_dump_buf[index])
390 kfree(wlan_static_dhd_log_dump_buf[index]);
391 if (wlan_static_dhd_log_dump_buf_ex[index])
392 kfree(wlan_static_dhd_log_dump_buf_ex[index]);
393 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
394 if (wlan_static_wl_escan_info_buf[index])
395 kfree(wlan_static_wl_escan_info_buf[index]);
396 if (wlan_static_fw_verbose_ring_buf[index])
397 kfree(wlan_static_fw_verbose_ring_buf[index]);
398 if (wlan_static_fw_event_ring_buf[index])
399 kfree(wlan_static_fw_event_ring_buf[index]);
400 if (wlan_static_dhd_event_ring_buf[index])
401 kfree(wlan_static_dhd_event_ring_buf[index]);
402 #if defined(BCMDHD_UNUSE_MEM)
403 if (wlan_static_nan_event_ring_buf[index])
404 kfree(wlan_static_nan_event_ring_buf[index]);
405 #endif /* BCMDHD_UNUSE_MEM */
406
407 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
408 for (i=0; i<WLAN_SKB_BUF_NUM; i++) {
409 if (wlan_static_skb[index][i])
410 dev_kfree_skb(wlan_static_skb[index][i]);
411 }
412 #endif /* BCMDHD_SDIO | BCMDHD_PCIE */
413
414 return;
415 }
416
417 static int
dhd_init_wlan_mem(int index)418 dhd_init_wlan_mem(int index)
419 {
420 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
421 int i;
422 #endif
423 unsigned long size = 0;
424
425 #if defined(BCMDHD_SDIO) || defined(BCMDHD_PCIE)
426 for (i = 0; i < WLAN_SKB_BUF_NUM; i++)
427 wlan_static_skb[index][i] = NULL;
428
429 for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
430 wlan_static_skb[index][i] = dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE);
431 if (!wlan_static_skb[index][i])
432 goto err_mem_alloc;
433 size += DHD_SKB_1PAGE_BUFSIZE;
434 DHD_STATIC_TRACE("section %d skb[%d], size=%ld\n",
435 DHD_PREALLOC_SKB_BUF, i, DHD_SKB_1PAGE_BUFSIZE);
436 }
437
438 for (i = DHD_SKB_1PAGE_BUF_NUM; i < WLAN_SKB_1_2PAGE_BUF_NUM; i++) {
439 wlan_static_skb[index][i] = dev_alloc_skb(DHD_SKB_2PAGE_BUFSIZE);
440 if (!wlan_static_skb[index][i])
441 goto err_mem_alloc;
442 size += DHD_SKB_2PAGE_BUFSIZE;
443 DHD_STATIC_TRACE("section %d skb[%d], size=%ld\n",
444 DHD_PREALLOC_SKB_BUF, i, DHD_SKB_2PAGE_BUFSIZE);
445 }
446 #endif /* BCMDHD_SDIO | BCMDHD_PCIE */
447
448 #if defined(BCMDHD_SDIO)
449 wlan_static_skb[index][i] = dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE);
450 if (!wlan_static_skb[index][i])
451 goto err_mem_alloc;
452 size += DHD_SKB_4PAGE_BUFSIZE;
453 DHD_STATIC_TRACE("section %d skb[%d], size=%ld\n",
454 DHD_PREALLOC_SKB_BUF, i, DHD_SKB_4PAGE_BUFSIZE);
455 #endif /* BCMDHD_SDIO */
456
457 wlan_static_prot[index] = kmalloc(DHD_PREALLOC_PROT_SIZE, GFP_KERNEL);
458 if (!wlan_static_prot[index])
459 goto err_mem_alloc;
460 size += DHD_PREALLOC_PROT_SIZE;
461 DHD_STATIC_TRACE("section %d, size=%d\n",
462 DHD_PREALLOC_PROT, DHD_PREALLOC_PROT_SIZE);
463
464 #if defined(BCMDHD_SDIO)
465 wlan_static_rxbuf[index] = kmalloc(DHD_PREALLOC_RXBUF_SIZE, GFP_KERNEL);
466 if (!wlan_static_rxbuf[index])
467 goto err_mem_alloc;
468 size += DHD_PREALLOC_RXBUF_SIZE;
469 DHD_STATIC_TRACE("section %d, size=%d\n",
470 DHD_PREALLOC_RXBUF, DHD_PREALLOC_RXBUF_SIZE);
471
472 wlan_static_databuf[index] = kmalloc(DHD_PREALLOC_DATABUF_SIZE, GFP_KERNEL);
473 if (!wlan_static_databuf[index])
474 goto err_mem_alloc;
475 size += DHD_PREALLOC_DATABUF_SIZE;
476 DHD_STATIC_TRACE("section %d, size=%d\n",
477 DHD_PREALLOC_DATABUF, DHD_PREALLOC_DATABUF_SIZE);
478 #endif /* BCMDHD_SDIO */
479
480 wlan_static_osl_buf[index] = kmalloc(DHD_PREALLOC_OSL_BUF_SIZE, GFP_KERNEL);
481 if (!wlan_static_osl_buf[index])
482 goto err_mem_alloc;
483 size += DHD_PREALLOC_OSL_BUF_SIZE;
484 DHD_STATIC_TRACE("section %d, size=%ld\n",
485 DHD_PREALLOC_OSL_BUF, DHD_PREALLOC_OSL_BUF_SIZE);
486
487 wlan_static_scan_buf0[index] = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE, GFP_KERNEL);
488 if (!wlan_static_scan_buf0[index])
489 goto err_mem_alloc;
490 size += DHD_PREALLOC_WIPHY_ESCAN0_SIZE;
491 DHD_STATIC_TRACE("section %d, size=%d\n",
492 DHD_PREALLOC_WIPHY_ESCAN0, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
493
494 wlan_static_dhd_info_buf[index] = kmalloc(DHD_PREALLOC_DHD_INFO_SIZE, GFP_KERNEL);
495 if (!wlan_static_dhd_info_buf[index])
496 goto err_mem_alloc;
497 size += DHD_PREALLOC_DHD_INFO_SIZE;
498 DHD_STATIC_TRACE("section %d, size=%d\n",
499 DHD_PREALLOC_DHD_INFO, DHD_PREALLOC_DHD_INFO_SIZE);
500
501 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
502 wlan_static_dhd_wlfc_info_buf[index] = kmalloc(WLAN_DHD_WLFC_BUF_SIZE, GFP_KERNEL);
503 if (!wlan_static_dhd_wlfc_info_buf[index])
504 goto err_mem_alloc;
505 size += WLAN_DHD_WLFC_BUF_SIZE;
506 DHD_STATIC_TRACE("section %d, size=%d\n",
507 DHD_PREALLOC_DHD_WLFC_INFO, WLAN_DHD_WLFC_BUF_SIZE);
508 #endif /* BCMDHD_SDIO | BCMDHD_USB */
509
510 #ifdef BCMDHD_PCIE
511 wlan_static_if_flow_lkup[index] = kmalloc(DHD_PREALLOC_IF_FLOW_LKUP_SIZE, GFP_KERNEL);
512 if (!wlan_static_if_flow_lkup[index])
513 goto err_mem_alloc;
514 size += DHD_PREALLOC_IF_FLOW_LKUP_SIZE;
515 DHD_STATIC_TRACE("section %d, size=%d\n",
516 DHD_PREALLOC_IF_FLOW_LKUP, DHD_PREALLOC_IF_FLOW_LKUP_SIZE);
517 #endif /* BCMDHD_PCIE */
518
519 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
520 wlan_static_dhd_memdump_ram_buf[index] = kmalloc(DHD_PREALLOC_MEMDUMP_RAM_SIZE, GFP_KERNEL);
521 if (!wlan_static_dhd_memdump_ram_buf[index])
522 goto err_mem_alloc;
523 size += DHD_PREALLOC_MEMDUMP_RAM_SIZE;
524 DHD_STATIC_TRACE("section %d, size=%d\n",
525 DHD_PREALLOC_MEMDUMP_RAM, DHD_PREALLOC_MEMDUMP_RAM_SIZE);
526 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
527
528 #if defined(BCMDHD_SDIO) || defined(BCMDHD_USB)
529 wlan_static_dhd_wlfc_hanger_buf[index] = kmalloc(DHD_PREALLOC_DHD_WLFC_HANGER_SIZE, GFP_KERNEL);
530 if (!wlan_static_dhd_wlfc_hanger_buf[index])
531 goto err_mem_alloc;
532 size += DHD_PREALLOC_DHD_WLFC_HANGER_SIZE;
533 DHD_STATIC_TRACE("section %d, size=%d\n",
534 DHD_PREALLOC_DHD_WLFC_HANGER, DHD_PREALLOC_DHD_WLFC_HANGER_SIZE);
535 #endif /* BCMDHD_SDIO | BCMDHD_USB */
536
537 #if defined(CONFIG_BCMDHD_VTS) || defined(CONFIG_BCMDHD_DEBUG)
538 wlan_static_dhd_log_dump_buf[index] = kmalloc(DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE, GFP_KERNEL);
539 if (!wlan_static_dhd_log_dump_buf[index])
540 goto err_mem_alloc;
541 size += DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE;
542 DHD_STATIC_TRACE("section %d, size=%d\n",
543 DHD_PREALLOC_DHD_LOG_DUMP_BUF, DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE);
544
545 wlan_static_dhd_log_dump_buf_ex[index] = kmalloc(DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE, GFP_KERNEL);
546 if (!wlan_static_dhd_log_dump_buf_ex[index])
547 goto err_mem_alloc;
548 size += DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE;
549 DHD_STATIC_TRACE("section %d, size=%d\n",
550 DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX, DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE);
551 #endif /* CONFIG_BCMDHD_VTS | CONFIG_BCMDHD_DEBUG */
552
553 wlan_static_wl_escan_info_buf[index] = kmalloc(DHD_PREALLOC_WL_ESCAN_SIZE, GFP_KERNEL);
554 if (!wlan_static_wl_escan_info_buf[index])
555 goto err_mem_alloc;
556 size += DHD_PREALLOC_WL_ESCAN_SIZE;
557 DHD_STATIC_TRACE("section %d, size=%d\n",
558 DHD_PREALLOC_WL_ESCAN, DHD_PREALLOC_WL_ESCAN_SIZE);
559
560 wlan_static_fw_verbose_ring_buf[index] = kmalloc(FW_VERBOSE_RING_SIZE, GFP_KERNEL);
561 if (!wlan_static_fw_verbose_ring_buf[index])
562 goto err_mem_alloc;
563 size += FW_VERBOSE_RING_SIZE;
564 DHD_STATIC_TRACE("section %d, size=%d\n",
565 DHD_PREALLOC_FW_VERBOSE_RING, FW_VERBOSE_RING_SIZE);
566
567 wlan_static_fw_event_ring_buf[index] = kmalloc(FW_EVENT_RING_SIZE, GFP_KERNEL);
568 if (!wlan_static_fw_event_ring_buf[index])
569 goto err_mem_alloc;
570 size += FW_EVENT_RING_SIZE;
571 DHD_STATIC_TRACE("section %d, size=%d\n",
572 DHD_PREALLOC_FW_EVENT_RING, FW_EVENT_RING_SIZE);
573
574 wlan_static_dhd_event_ring_buf[index] = kmalloc(DHD_EVENT_RING_SIZE, GFP_KERNEL);
575 if (!wlan_static_dhd_event_ring_buf[index])
576 goto err_mem_alloc;
577 size += DHD_EVENT_RING_SIZE;
578 DHD_STATIC_TRACE("section %d, size=%d\n",
579 DHD_PREALLOC_DHD_EVENT_RING, DHD_EVENT_RING_SIZE);
580
581 #if defined(BCMDHD_UNUSE_MEM)
582 wlan_static_nan_event_ring_buf[index] = kmalloc(NAN_EVENT_RING_SIZE, GFP_KERNEL);
583 if (!wlan_static_nan_event_ring_buf[index])
584 goto err_mem_alloc;
585 size += NAN_EVENT_RING_SIZE;
586 DHD_STATIC_TRACE("section %d, size=%d\n",
587 DHD_PREALLOC_NAN_EVENT_RING, NAN_EVENT_RING_SIZE);
588 #endif /* BCMDHD_UNUSE_MEM */
589
590 DHD_STATIC_MSG("prealloc ok for index %d: %ld(%ldK)\n", index, size, size / 1024);
591 return 0;
592
593 err_mem_alloc:
594 DHD_STATIC_ERROR("Failed to allocate memory for index %d\n", index);
595
596 return -ENOMEM;
597 }
598
599 #ifdef DHD_STATIC_IN_DRIVER
600 int
601 #else
602 static int __init
603 #endif
dhd_static_buf_init(void)604 dhd_static_buf_init(void)
605 {
606 int i, ret = 0;
607
608 DHD_STATIC_MSG("%s\n", DHD_STATIC_VERSION_STR);
609
610 for (i=0; i<MAX_NUM_ADAPTERS; i++) {
611 ret = dhd_init_wlan_mem(i);
612 if (ret)
613 break;
614 }
615
616 if (ret) {
617 for (i=0; i<MAX_NUM_ADAPTERS; i++)
618 dhd_deinit_wlan_mem(i);
619 }
620
621 return ret;
622 }
623
624 #ifdef DHD_STATIC_IN_DRIVER
625 void
626 #else
627 static void __exit
628 #endif
dhd_static_buf_exit(void)629 dhd_static_buf_exit(void)
630 {
631 int i;
632
633 DHD_STATIC_MSG("Enter\n");
634
635 for (i=0; i<MAX_NUM_ADAPTERS; i++)
636 dhd_deinit_wlan_mem(i);
637 }
638
639 #ifndef DHD_STATIC_IN_DRIVER
640 module_init(dhd_static_buf_init);
641 module_exit(dhd_static_buf_exit);
642 #endif
643