bcmdhd.101.10.240.x/dhd_custom_memprealloc.c

   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          (32 * 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   128
  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
 152 *dhd_wlan_mem_prealloc(int section, unsigned long size)
 153 {
 154         if (section == PREALLOC_WLAN_SEC_NUM) {
 155                 return wlan_static_skb;
 156         }
 157
 158         if (section == WLAN_STATIC_SCAN_BUF0) {
 159                 return wlan_static_scan_buf0;
 160         }
 161
 162         if (section == WLAN_STATIC_SCAN_BUF1) {
 163                 return wlan_static_scan_buf1;
 164         }
 165
 166         if (section == WLAN_STATIC_DHD_INFO_BUF) {
 167                 if (size > WLAN_DHD_INFO_BUF_SIZE) {
 168                         pr_err("request DHD_INFO size(%lu) is bigger than"
 169                                 " static size(%d).\n", size,
 170                                 WLAN_DHD_INFO_BUF_SIZE);
 171                         return NULL;
 172                 }
 173                 return wlan_static_dhd_info_buf;
 174         }
 175
 176         if (section == WLAN_STATIC_DHD_WLFC_BUF)  {
 177                 if (size > WLAN_DHD_WLFC_BUF_SIZE) {
 178                         pr_err("request DHD_WLFC size(%lu) is bigger than"
 179                                 " static size(%d).\n",
 180                                 size, WLAN_DHD_WLFC_BUF_SIZE);
 181                         return NULL;
 182                 }
 183                 return wlan_static_dhd_wlfc_buf;
 184         }
 185
 186         if (section == WLAN_STATIC_DHD_WLFC_HANGER) {
 187                 if (size > WLAN_DHD_WLFC_HANGER_SIZE) {
 188                         pr_err("request DHD_WLFC_HANGER size(%lu) is bigger than"
 189                                 " static size(%d).\n",
 190                                 size, WLAN_DHD_WLFC_HANGER_SIZE);
 191                         return NULL;
 192                 }
 193                 return wlan_static_dhd_wlfc_hanger;
 194         }
 195
 196         if (section == WLAN_STATIC_DHD_IF_FLOW_LKUP)  {
 197                 if (size > WLAN_DHD_IF_FLOW_LKUP_SIZE) {
 198                         pr_err("request DHD_WLFC size(%lu) is bigger than"
 199                                 " static size(%d).\n",
 200                                 size, WLAN_DHD_WLFC_BUF_SIZE);
 201                         return NULL;
 202                 }
 203                 return wlan_static_if_flow_lkup;
 204         }
 205
 206         if (section == WLAN_STATIC_DHD_MEMDUMP_RAM) {
 207                 if (size > WLAN_DHD_MEMDUMP_SIZE) {
 208                         pr_err("request DHD_MEMDUMP_RAM size(%lu) is bigger"
 209                                 " than static size(%d).\n",
 210                                 size, WLAN_DHD_MEMDUMP_SIZE);
 211                         return NULL;
 212                 }
 213                 return wlan_static_dhd_memdump_ram;
 214         }
 215
 216         if (section == WLAN_STATIC_DHD_PKTID_MAP)  {
 217                 if (size > WLAN_DHD_PKTID_MAP_SIZE) {
 218                         pr_err("request DHD_PKTID_MAP size(%lu) is bigger than"
 219                                 " static size(%d).\n",
 220                                 size, WLAN_DHD_PKTID_MAP_SIZE);
 221                         return NULL;
 222                 }
 223                 return wlan_static_dhd_pktid_map;
 224         }
 225
 226         if (section == WLAN_STATIC_DHD_PKTID_IOCTL_MAP)  {
 227                 if (size > WLAN_DHD_PKTID_IOCTL_MAP_SIZE) {
 228                         pr_err("request DHD_PKTID_IOCTL_MAP size(%lu) is bigger than"
 229                                 " static size(%d).\n",
 230                                 size, WLAN_DHD_PKTID_IOCTL_MAP_SIZE);
 231                         return NULL;
 232                 }
 233                 return wlan_static_dhd_pktid_ioctl_map;
 234         }
 235
 236         if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF) {
 237                 if (size > DHD_LOG_DUMP_BUF_SIZE) {
 238                         pr_err("request DHD_LOG_DUMP_BUF size(%lu) is bigger then"
 239                                 " static size(%d).\n",
 240                                 size, DHD_LOG_DUMP_BUF_SIZE);
 241                         return NULL;
 242                 }
 243                 return wlan_static_dhd_log_dump_buf;
 244         }
 245
 246         if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF_EX) {
 247                 if (size > DHD_LOG_DUMP_BUF_EX_SIZE) {
 248                         pr_err("request DHD_LOG_DUMP_BUF_EX size(%lu) is bigger then"
 249                                 " static size(%d).\n",
 250                                 size, DHD_LOG_DUMP_BUF_EX_SIZE);
 251                         return NULL;
 252                 }
 253                 return wlan_static_dhd_log_dump_buf_ex;
 254         }
 255
 256         if (section == WLAN_STATIC_DHD_PKTLOG_DUMP_BUF) {
 257                 if (size > DHD_PKTLOG_DUMP_BUF_SIZE) {
 258                         pr_err("request DHD_PKTLOG_DUMP_BUF size(%lu) is bigger then"
 259                                         " static size(%d).\n",
 260                                         size, DHD_PKTLOG_DUMP_BUF_SIZE);
 261                         return NULL;
 262                 }
 263                 return wlan_static_dhd_pktlog_dump_buf;
 264         }
 265
 266         if ((section < 0) || (section >= PREALLOC_WLAN_SEC_NUM)) {
 267                 return NULL;
 268         }
 269
 270         if (wlan_mem_array[section].size < size) {
 271                 return NULL;
 272         }
 273
 274         return wlan_mem_array[section].mem_ptr;
 275 }
 276 EXPORT_SYMBOL(dhd_wlan_mem_prealloc);
 277
 278 int
 279 dhd_init_wlan_mem(void)
 280 {
 281         int i;
 282         int j;
 283
 284 #if !defined(CONFIG_BCMDHD_PCIE)
 285         for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
 286                 wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE, GFP_KERNEL);
 287                 if (!wlan_static_skb[i]) {
 288                         goto err_skb_alloc;
 289                 }
 290         }
 291 #endif /* !CONFIG_BCMDHD_PCIE */
 292
 293         for (i = DHD_SKB_1PAGE_BUF_NUM; i < WLAN_SKB_1_2PAGE_BUF_NUM; i++) {
 294                 wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_2PAGE_BUFSIZE, GFP_KERNEL);
 295                 if (!wlan_static_skb[i]) {
 296                         goto err_skb_alloc;
 297                 }
 298         }
 299
 300 #if !defined(CONFIG_BCMDHD_PCIE)
 301         wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE, GFP_KERNEL);
 302         if (!wlan_static_skb[i]) {
 303                 goto err_skb_alloc;
 304         }
 305 #endif /* !CONFIG_BCMDHD_PCIE */
 306
 307         for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
 308                 if (wlan_mem_array[i].size > 0) {
 309                         wlan_mem_array[i].mem_ptr =
 310                                 kmalloc(wlan_mem_array[i].size, GFP_KERNEL);
 311
 312                         if (!wlan_mem_array[i].mem_ptr) {
 313                                 goto err_mem_alloc;
 314                         }
 315                 }
 316         }
 317
 318         wlan_static_scan_buf0 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
 319         if (!wlan_static_scan_buf0) {
 320                 pr_err("Failed to alloc wlan_static_scan_buf0\n");
 321                 goto err_mem_alloc;
 322         }
 323
 324         wlan_static_scan_buf1 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
 325         if (!wlan_static_scan_buf1) {
 326                 pr_err("Failed to alloc wlan_static_scan_buf1\n");
 327                 goto err_mem_alloc;
 328         }
 329
 330         wlan_static_dhd_log_dump_buf = kmalloc(DHD_LOG_DUMP_BUF_SIZE, GFP_KERNEL);
 331         if (!wlan_static_dhd_log_dump_buf) {
 332                 pr_err("Failed to alloc wlan_static_dhd_log_dump_buf\n");
 333                 goto err_mem_alloc;
 334         }
 335
 336         wlan_static_dhd_log_dump_buf_ex = kmalloc(DHD_LOG_DUMP_BUF_EX_SIZE, GFP_KERNEL);
 337         if (!wlan_static_dhd_log_dump_buf_ex) {
 338                 pr_err("Failed to alloc wlan_static_dhd_log_dump_buf_ex\n");
 339                 goto err_mem_alloc;
 340         }
 341
 342         wlan_static_dhd_info_buf = kmalloc(WLAN_DHD_INFO_BUF_SIZE, GFP_KERNEL);
 343         if (!wlan_static_dhd_info_buf) {
 344                 pr_err("Failed to alloc wlan_static_dhd_info_buf\n");
 345                 goto err_mem_alloc;
 346         }
 347
 348 #ifdef CONFIG_BCMDHD_PCIE
 349         wlan_static_if_flow_lkup = kmalloc(WLAN_DHD_IF_FLOW_LKUP_SIZE,
 350                 GFP_KERNEL);
 351         if (!wlan_static_if_flow_lkup) {
 352                 pr_err("Failed to alloc wlan_static_if_flow_lkup\n");
 353                 goto err_mem_alloc;
 354         }
 355
 356 #ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
 357         wlan_static_dhd_pktid_map = kmalloc(WLAN_DHD_PKTID_MAP_SIZE,
 358                 GFP_KERNEL);
 359         if (!wlan_static_dhd_pktid_map) {
 360                 pr_err("Failed to alloc wlan_static_dhd_pktid_map\n");
 361                 goto err_mem_alloc;
 362         }
 363
 364         wlan_static_dhd_pktid_ioctl_map = kmalloc(WLAN_DHD_PKTID_IOCTL_MAP_SIZE,
 365                 GFP_KERNEL);
 366         if (!wlan_static_dhd_pktid_ioctl_map) {
 367                 pr_err("Failed to alloc wlan_static_dhd_pktid_ioctl_map\n");
 368                 goto err_mem_alloc;
 369         }
 370 #endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
 371 #else
 372         wlan_static_dhd_wlfc_buf = kmalloc(WLAN_DHD_WLFC_BUF_SIZE,
 373                 GFP_KERNEL);
 374         if (!wlan_static_dhd_wlfc_buf) {
 375                 pr_err("Failed to alloc wlan_static_dhd_wlfc_buf\n");
 376                 goto err_mem_alloc;
 377         }
 378
 379         wlan_static_dhd_wlfc_hanger = kmalloc(WLAN_DHD_WLFC_HANGER_SIZE,
 380                 GFP_KERNEL);
 381         if (!wlan_static_dhd_wlfc_hanger) {
 382                 pr_err("Failed to alloc wlan_static_dhd_wlfc_hanger\n");
 383                 goto err_mem_alloc;
 384         }
 385 #endif /* CONFIG_BCMDHD_PCIE */
 386
 387 #ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
 388         wlan_static_dhd_memdump_ram = kmalloc(WLAN_DHD_MEMDUMP_SIZE, GFP_KERNEL);
 389         if (!wlan_static_dhd_memdump_ram) {
 390                 pr_err("Failed to alloc wlan_static_dhd_memdump_ram\n");
 391                 goto err_mem_alloc;
 392         }
 393 #endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
 394
 395         wlan_static_dhd_pktlog_dump_buf = kmalloc(DHD_PKTLOG_DUMP_BUF_SIZE, GFP_KERNEL);
 396         if (!wlan_static_dhd_pktlog_dump_buf) {
 397                 pr_err("Failed to alloc wlan_static_dhd_pktlog_dump_buf\n");
 398                 goto err_mem_alloc;
 399         }
 400
 401         pr_err("%s: WIFI MEM Allocated\n", __FUNCTION__);
 402         return 0;
 403
 404 err_mem_alloc:
 405 #ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
 406         if (wlan_static_dhd_memdump_ram) {
 407                 kfree(wlan_static_dhd_memdump_ram);
 408         }
 409
 410 #endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
 411
 412 #ifdef CONFIG_BCMDHD_PCIE
 413         if (wlan_static_if_flow_lkup) {
 414                 kfree(wlan_static_if_flow_lkup);
 415         }
 416
 417 #ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
 418         if (wlan_static_dhd_pktid_map) {
 419                 kfree(wlan_static_dhd_pktid_map);
 420         }
 421
 422         if (wlan_static_dhd_pktid_ioctl_map) {
 423                 kfree(wlan_static_dhd_pktid_ioctl_map);
 424         }
 425 #endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
 426 #else
 427         if (wlan_static_dhd_wlfc_buf) {
 428                 kfree(wlan_static_dhd_wlfc_buf);
 429         }
 430
 431         if (wlan_static_dhd_wlfc_hanger) {
 432                 kfree(wlan_static_dhd_wlfc_hanger);
 433         }
 434 #endif /* CONFIG_BCMDHD_PCIE */
 435         if (wlan_static_dhd_info_buf) {
 436                 kfree(wlan_static_dhd_info_buf);
 437         }
 438
 439         if (wlan_static_dhd_log_dump_buf) {
 440                 kfree(wlan_static_dhd_log_dump_buf);
 441         }
 442
 443         if (wlan_static_dhd_log_dump_buf_ex) {
 444                 kfree(wlan_static_dhd_log_dump_buf_ex);
 445         }
 446
 447         if (wlan_static_scan_buf1) {
 448                 kfree(wlan_static_scan_buf1);
 449         }
 450
 451         if (wlan_static_scan_buf0) {
 452                 kfree(wlan_static_scan_buf0);
 453         }
 454
 455         if (wlan_static_dhd_pktlog_dump_buf) {
 456                 kfree(wlan_static_dhd_pktlog_dump_buf);
 457         }
 458
 459         pr_err("Failed to mem_alloc for WLAN\n");
 460
 461         for (j = 0; j < i; j++) {
 462                 kfree(wlan_mem_array[j].mem_ptr);
 463         }
 464
 465         i = WLAN_SKB_BUF_NUM;
 466
 467 err_skb_alloc:
 468         pr_err("Failed to skb_alloc for WLAN\n");
 469         for (j = 0; j < i; j++) {
 470                 dev_kfree_skb(wlan_static_skb[j]);
 471         }
 472
 473         return -ENOMEM;
 474 }
 475 EXPORT_SYMBOL(dhd_init_wlan_mem);
 476
 477 void
 478 dhd_exit_wlan_mem(void)
 479 {
 480         int i = 0;
 481
 482 #ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
 483         if (wlan_static_dhd_memdump_ram) {
 484                 kfree(wlan_static_dhd_memdump_ram);
 485         }
 486
 487 #endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
 488
 489 #ifdef CONFIG_BCMDHD_PCIE
 490         if (wlan_static_if_flow_lkup) {
 491                 kfree(wlan_static_if_flow_lkup);
 492         }
 493
 494 #ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
 495         if (wlan_static_dhd_pktid_map) {
 496                 kfree(wlan_static_dhd_pktid_map);
 497         }
 498
 499         if (wlan_static_dhd_pktid_ioctl_map) {
 500                 kfree(wlan_static_dhd_pktid_ioctl_map);
 501         }
 502 #endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
 503 #else
 504         if (wlan_static_dhd_wlfc_buf) {
 505                 kfree(wlan_static_dhd_wlfc_buf);
 506         }
 507
 508         if (wlan_static_dhd_wlfc_hanger) {
 509                 kfree(wlan_static_dhd_wlfc_hanger);
 510         }
 511 #endif /* CONFIG_BCMDHD_PCIE */
 512         if (wlan_static_dhd_info_buf) {
 513                 kfree(wlan_static_dhd_info_buf);
 514         }
 515
 516         if (wlan_static_dhd_log_dump_buf) {
 517                 kfree(wlan_static_dhd_log_dump_buf);
 518         }
 519
 520         if (wlan_static_dhd_log_dump_buf_ex) {
 521                 kfree(wlan_static_dhd_log_dump_buf_ex);
 522         }
 523
 524         if (wlan_static_scan_buf1) {
 525                 kfree(wlan_static_scan_buf1);
 526         }
 527
 528         if (wlan_static_scan_buf0) {
 529                 kfree(wlan_static_scan_buf0);
 530         }
 531
 532         if (wlan_static_dhd_pktlog_dump_buf) {
 533                 kfree(wlan_static_dhd_pktlog_dump_buf);
 534         }
 535
 536         pr_err("Failed to mem_alloc for WLAN\n");
 537
 538         for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
 539                 if (wlan_mem_array[i].mem_ptr) {
 540                         kfree(wlan_mem_array[i].mem_ptr);
 541                 }
 542         }
 543
 544         pr_err("Failed to skb_alloc for WLAN\n");
 545         for (i = 0; i < WLAN_SKB_BUF_NUM; i++) {
 546                 dev_kfree_skb(wlan_static_skb[i]);
 547         }
 548
 549         return;
 550 }
 551 EXPORT_SYMBOL(dhd_exit_wlan_mem);
 552 #endif /* CONFIG_BROADCOM_WIFI_RESERVED_MEM */