bcmdhd.100.10.315.x/dhd_static_buf.c

   1 /*
   2  * drivers/amlogic/wifi/dhd_static_buf.c
   3  *
   4  * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  */
  17
  18 #define pr_fmt(fmt)     "Wifi: %s: " fmt, __func__
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/init.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/delay.h>
  25 #include <linux/err.h>
  26 #include <linux/skbuff.h>
  27 #include <linux/wlan_plat.h>
  28 #include <linux/amlogic/dhd_buf.h>
  29
  30 #define DHD_STATIC_VERSION_STR          "100.10.545.3"
  31
  32 #define BCMDHD_SDIO
  33 #define BCMDHD_PCIE
  34
  35 enum dhd_prealloc_index {
  36         DHD_PREALLOC_PROT = 0,
  37 #if defined(BCMDHD_SDIO)
  38         DHD_PREALLOC_RXBUF = 1,
  39         DHD_PREALLOC_DATABUF = 2,
  40 #endif
  41         DHD_PREALLOC_OSL_BUF = 3,
  42         DHD_PREALLOC_SKB_BUF = 4,
  43         DHD_PREALLOC_WIPHY_ESCAN0 = 5,
  44         DHD_PREALLOC_WIPHY_ESCAN1 = 6,
  45         DHD_PREALLOC_DHD_INFO = 7,
  46         DHD_PREALLOC_DHD_WLFC_INFO = 8,
  47 #ifdef BCMDHD_PCIE
  48         DHD_PREALLOC_IF_FLOW_LKUP = 9,
  49 #endif
  50         DHD_PREALLOC_MEMDUMP_BUF = 10,
  51         DHD_PREALLOC_MEMDUMP_RAM = 11,
  52         DHD_PREALLOC_DHD_WLFC_HANGER = 12,
  53         DHD_PREALLOC_PKTID_MAP = 13,
  54         DHD_PREALLOC_PKTID_MAP_IOCTL = 14,
  55         DHD_PREALLOC_DHD_LOG_DUMP_BUF = 15,
  56         DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX = 16,
  57         DHD_PREALLOC_DHD_PKTLOG_DUMP_BUF = 17,
  58         DHD_PREALLOC_STAT_REPORT_BUF = 18,
  59         DHD_PREALLOC_WL_WEXT_INFO = 19,
  60         DHD_PREALLOC_FW_VERBOSE_RING = 20,
  61         DHD_PREALLOC_FW_EVENT_RING = 21,
  62         DHD_PREALLOC_DHD_EVENT_RING = 22,
  63         DHD_PREALLOC_NAN_EVENT_RING = 23,
  64         DHD_PREALLOC_MAX
  65 };
  66
  67 #define STATIC_BUF_MAX_NUM      20
  68 #define STATIC_BUF_SIZE (PAGE_SIZE*2)
  69
  70 #define DHD_PREALLOC_PROT_SIZE  (16 * 1024)
  71 #define DHD_PREALLOC_RXBUF_SIZE (24 * 1024)
  72 #define DHD_PREALLOC_DATABUF_SIZE       (64 * 1024)
  73 #define DHD_PREALLOC_OSL_BUF_SIZE       (STATIC_BUF_MAX_NUM * STATIC_BUF_SIZE)
  74 #define DHD_PREALLOC_WIPHY_ESCAN0_SIZE  (64 * 1024)
  75 #define DHD_PREALLOC_DHD_INFO_SIZE      (32 * 1024)
  76 #define DHD_PREALLOC_MEMDUMP_RAM_SIZE   (1290 * 1024)
  77 #define DHD_PREALLOC_DHD_WLFC_HANGER_SIZE       (73 * 1024)
  78 #define DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE (1024 * 1024 * CUSTOM_LOG_DUMP_BUFSIZE_MB)
  79 #define DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE (8 * 1024)
  80 #define DHD_PREALLOC_WL_WEXT_INFO_SIZE  (70 * 1024)
  81 #ifdef CONFIG_64BIT
  82 #define DHD_PREALLOC_IF_FLOW_LKUP_SIZE  (20 * 1024 * 2)
  83 #else
  84 #define DHD_PREALLOC_IF_FLOW_LKUP_SIZE  (20 * 1024)
  85 #endif
  86 #define FW_VERBOSE_RING_SIZE            (256 * 1024)
  87 #define FW_EVENT_RING_SIZE              (64 * 1024)
  88 #define DHD_EVENT_RING_SIZE             (64 * 1024)
  89 #define NAN_EVENT_RING_SIZE             (64 * 1024)
  90
  91 #if defined(CONFIG_64BIT)
  92 #define WLAN_DHD_INFO_BUF_SIZE  (24 * 1024)
  93 #define WLAN_DHD_WLFC_BUF_SIZE  (64 * 1024)
  94 #define WLAN_DHD_IF_FLOW_LKUP_SIZE      (64 * 1024)
  95 #else
  96 #define WLAN_DHD_INFO_BUF_SIZE  (16 * 1024)
  97 #define WLAN_DHD_WLFC_BUF_SIZE  (64 * 1024)
  98 #define WLAN_DHD_IF_FLOW_LKUP_SIZE      (20 * 1024)
  99 #endif /* CONFIG_64BIT */
 100 #define WLAN_DHD_MEMDUMP_SIZE   (800 * 1024)
 101
 102 #define DHD_SKB_1PAGE_BUFSIZE   (PAGE_SIZE*1)
 103 #define DHD_SKB_2PAGE_BUFSIZE   (PAGE_SIZE*2)
 104 #define DHD_SKB_4PAGE_BUFSIZE   (PAGE_SIZE*4)
 105
 106 #define DHD_SKB_1PAGE_BUF_NUM   8
 107 #define DHD_SKB_2PAGE_BUF_NUM   64
 108 #define DHD_SKB_4PAGE_BUF_NUM   1
 109
 110 /* The number is defined in linux_osl.c
 111  * WLAN_SKB_1_2PAGE_BUF_NUM => STATIC_PKT_1_2PAGE_NUM
 112  * WLAN_SKB_BUF_NUM => STATIC_PKT_MAX_NUM
 113  */
 114 #define WLAN_SKB_1_2PAGE_BUF_NUM ((DHD_SKB_1PAGE_BUF_NUM) + \
 115                 (DHD_SKB_2PAGE_BUF_NUM))
 116 #define WLAN_SKB_BUF_NUM ((WLAN_SKB_1_2PAGE_BUF_NUM) + (DHD_SKB_4PAGE_BUF_NUM))
 117
 118 void *wlan_static_prot;
 119 void *wlan_static_rxbuf;
 120 void *wlan_static_databuf;
 121 void *wlan_static_osl_buf;
 122 void *wlan_static_scan_buf0;
 123 void *wlan_static_scan_buf1;
 124 void *wlan_static_dhd_info_buf;
 125 void *wlan_static_dhd_wlfc_info_buf;
 126 void *wlan_static_if_flow_lkup;
 127 void *wlan_static_dhd_memdump_ram_buf;
 128 void *wlan_static_dhd_wlfc_hanger_buf;
 129 void *wlan_static_dhd_log_dump_buf;
 130 void *wlan_static_dhd_log_dump_buf_ex;
 131 void *wlan_static_wl_escan_info_buf;
 132 void *wlan_static_fw_verbose_ring_buf;
 133 void *wlan_static_fw_event_ring_buf;
 134 void *wlan_static_dhd_event_ring_buf;
 135 void *wlan_static_nan_event_ring_buf;
 136
 137 static struct sk_buff *wlan_static_skb[WLAN_SKB_BUF_NUM];
 138
 139 void *bcmdhd_mem_prealloc(int section, unsigned long size)
 140 {
 141         pr_info("sectoin %d, size %ld\n", section, size);
 142         if (section == DHD_PREALLOC_PROT)
 143                 return wlan_static_prot;
 144
 145 #if defined(BCMDHD_SDIO)
 146         if (section == DHD_PREALLOC_RXBUF)
 147                 return wlan_static_rxbuf;
 148
 149         if (section == DHD_PREALLOC_DATABUF)
 150                 return wlan_static_databuf;
 151 #endif /* BCMDHD_SDIO */
 152
 153         if (section == DHD_PREALLOC_SKB_BUF)
 154                 return wlan_static_skb;
 155
 156         if (section == DHD_PREALLOC_WIPHY_ESCAN0)
 157                 return wlan_static_scan_buf0;
 158
 159         if (section == DHD_PREALLOC_WIPHY_ESCAN1)
 160                 return wlan_static_scan_buf1;
 161
 162         if (section == DHD_PREALLOC_OSL_BUF) {
 163                 if (size > DHD_PREALLOC_OSL_BUF_SIZE) {
 164                         pr_err("request OSL_BUF(%lu) > %ld\n",
 165                                 size, DHD_PREALLOC_OSL_BUF_SIZE);
 166                         return NULL;
 167                 }
 168                 return wlan_static_osl_buf;
 169         }
 170
 171         if (section == DHD_PREALLOC_DHD_INFO) {
 172                 if (size > DHD_PREALLOC_DHD_INFO_SIZE) {
 173                         pr_err("request DHD_INFO size(%lu) > %d\n",
 174                                 size, DHD_PREALLOC_DHD_INFO_SIZE);
 175                         return NULL;
 176                 }
 177                 return wlan_static_dhd_info_buf;
 178         }
 179         if (section == DHD_PREALLOC_DHD_WLFC_INFO) {
 180                 if (size > WLAN_DHD_WLFC_BUF_SIZE) {
 181                         pr_err("request DHD_WLFC_INFO size(%lu) > %d\n",
 182                                 size, WLAN_DHD_WLFC_BUF_SIZE);
 183                         return NULL;
 184                 }
 185                 return wlan_static_dhd_wlfc_info_buf;
 186         }
 187 #ifdef BCMDHD_PCIE
 188         if (section == DHD_PREALLOC_IF_FLOW_LKUP)  {
 189                 if (size > DHD_PREALLOC_IF_FLOW_LKUP_SIZE) {
 190                         pr_err("request DHD_IF_FLOW_LKUP size(%lu) > %d\n",
 191                                 size, DHD_PREALLOC_IF_FLOW_LKUP_SIZE);
 192                         return NULL;
 193                 }
 194
 195                 return wlan_static_if_flow_lkup;
 196         }
 197 #endif /* BCMDHD_PCIE */
 198         if (section == DHD_PREALLOC_MEMDUMP_RAM) {
 199                 if (size > DHD_PREALLOC_MEMDUMP_RAM_SIZE) {
 200                         pr_err("request DHD_PREALLOC_MEMDUMP_RAM_SIZE(%lu) > %d\n",
 201                                 size, DHD_PREALLOC_MEMDUMP_RAM_SIZE);
 202                         return NULL;
 203                 }
 204
 205                 return wlan_static_dhd_memdump_ram_buf;
 206         }
 207         if (section == DHD_PREALLOC_DHD_WLFC_HANGER) {
 208                 if (size > DHD_PREALLOC_DHD_WLFC_HANGER_SIZE) {
 209                         pr_err("request DHD_WLFC_HANGER size(%lu) > %d\n",
 210                                 size, DHD_PREALLOC_DHD_WLFC_HANGER_SIZE);
 211                         return NULL;
 212                 }
 213                 return wlan_static_dhd_wlfc_hanger_buf;
 214         }
 215         if (section == DHD_PREALLOC_DHD_LOG_DUMP_BUF) {
 216                 if (size > DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE) {
 217                         pr_err("request DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE(%lu) > %d\n",
 218                                 size, DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE);
 219                         return NULL;
 220                 }
 221
 222                 return wlan_static_dhd_log_dump_buf;
 223         }
 224         if (section == DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX) {
 225                 if (size > DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE) {
 226                         pr_err("request DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE(%lu) > %d\n",
 227                                 size, DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE);
 228                         return NULL;
 229                 }
 230
 231                 return wlan_static_dhd_log_dump_buf_ex;
 232         }
 233         if (section == DHD_PREALLOC_WL_WEXT_INFO) {
 234                 if (size > DHD_PREALLOC_WL_WEXT_INFO_SIZE) {
 235                         pr_err("request DHD_PREALLOC_WL_WEXT_INFO_SIZE(%lu) > %d\n",
 236                                 size, DHD_PREALLOC_WL_WEXT_INFO_SIZE);
 237                         return NULL;
 238                 }
 239
 240                 return wlan_static_wl_escan_info_buf;
 241         }
 242         if (section == DHD_PREALLOC_FW_VERBOSE_RING) {
 243                 if (size > FW_VERBOSE_RING_SIZE) {
 244                         pr_err("request DHD_PREALLOC_FW_VERBOSE_RING(%lu) > %d\n",
 245                                 size, FW_VERBOSE_RING_SIZE);
 246                         return NULL;
 247                 }
 248
 249                 return wlan_static_fw_verbose_ring_buf;
 250         }
 251         if (section == DHD_PREALLOC_FW_EVENT_RING) {
 252                 if (size > FW_EVENT_RING_SIZE) {
 253                         pr_err("request DHD_PREALLOC_FW_EVENT_RING(%lu) > %d\n",
 254                                 size, FW_EVENT_RING_SIZE);
 255                         return NULL;
 256                 }
 257
 258                 return wlan_static_fw_event_ring_buf;
 259         }
 260         if (section == DHD_PREALLOC_DHD_EVENT_RING) {
 261                 if (size > DHD_EVENT_RING_SIZE) {
 262                         pr_err("request DHD_PREALLOC_DHD_EVENT_RING(%lu) > %d\n",
 263                                 size, DHD_EVENT_RING_SIZE);
 264                         return NULL;
 265                 }
 266
 267                 return wlan_static_dhd_event_ring_buf;
 268         }
 269         if (section == DHD_PREALLOC_NAN_EVENT_RING) {
 270                 if (size > NAN_EVENT_RING_SIZE) {
 271                         pr_err("request DHD_PREALLOC_NAN_EVENT_RING(%lu) > %d\n",
 272                                 size, NAN_EVENT_RING_SIZE);
 273                         return NULL;
 274                 }
 275
 276                 return wlan_static_nan_event_ring_buf;
 277         }
 278         if ((section < 0) || (section > DHD_PREALLOC_MAX))
 279                 pr_err("request section id(%d) is out of max index %d\n",
 280                                 section, DHD_PREALLOC_MAX);
 281
 282         pr_err("%s: failed to alloc section %d, size=%ld\n",
 283                 __func__, section, size);
 284
 285         return NULL;
 286 }
 287 EXPORT_SYMBOL(bcmdhd_mem_prealloc);
 288
 289 int bcmdhd_init_wlan_mem(void)
 290 {
 291         int i;
 292         int j;
 293         pr_info("%s(): %s\n", __func__, DHD_STATIC_VERSION_STR);
 294
 295         for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
 296                 wlan_static_skb[i] = dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE);
 297                 if (!wlan_static_skb[i])
 298                         goto err_skb_alloc;
 299         }
 300
 301         for (i = DHD_SKB_1PAGE_BUF_NUM; i < WLAN_SKB_1_2PAGE_BUF_NUM; i++) {
 302                 wlan_static_skb[i] = dev_alloc_skb(DHD_SKB_2PAGE_BUFSIZE);
 303                 if (!wlan_static_skb[i])
 304                         goto err_skb_alloc;
 305         }
 306
 307 #if defined(BCMDHD_SDIO)
 308         wlan_static_skb[i] = dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE);
 309         if (!wlan_static_skb[i])
 310                 goto err_skb_alloc;
 311 #endif /* BCMDHD_SDIO */
 312
 313         wlan_static_prot = kmalloc(DHD_PREALLOC_PROT_SIZE, GFP_KERNEL);
 314         if (!wlan_static_prot)
 315                 goto err_mem_alloc;
 316
 317 #if defined(BCMDHD_SDIO)
 318         wlan_static_rxbuf = kmalloc(DHD_PREALLOC_RXBUF_SIZE, GFP_KERNEL);
 319         if (!wlan_static_rxbuf)
 320                 goto err_mem_alloc;
 321
 322         wlan_static_databuf = kmalloc(DHD_PREALLOC_DATABUF_SIZE, GFP_KERNEL);
 323         if (!wlan_static_databuf)
 324                 goto err_mem_alloc;
 325 #endif /* BCMDHD_SDIO */
 326
 327         wlan_static_osl_buf = kmalloc(DHD_PREALLOC_OSL_BUF_SIZE, GFP_KERNEL);
 328         if (!wlan_static_osl_buf)
 329                 goto err_mem_alloc;
 330
 331         wlan_static_scan_buf0 = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE, GFP_KERNEL);
 332         if (!wlan_static_scan_buf0)
 333                 goto err_mem_alloc;
 334
 335         wlan_static_dhd_info_buf = kmalloc(DHD_PREALLOC_DHD_INFO_SIZE, GFP_KERNEL);
 336         if (!wlan_static_dhd_info_buf)
 337                 goto err_mem_alloc;
 338
 339         wlan_static_dhd_wlfc_info_buf = kmalloc(WLAN_DHD_WLFC_BUF_SIZE, GFP_KERNEL);
 340         if (!wlan_static_dhd_wlfc_info_buf)
 341                 goto err_mem_alloc;
 342
 343 #ifdef BCMDHD_PCIE
 344         wlan_static_if_flow_lkup = kmalloc(DHD_PREALLOC_IF_FLOW_LKUP_SIZE, GFP_KERNEL);
 345         if (!wlan_static_if_flow_lkup)
 346                 goto err_mem_alloc;
 347 #endif /* BCMDHD_PCIE */
 348
 349         wlan_static_dhd_memdump_ram_buf = kmalloc(DHD_PREALLOC_MEMDUMP_RAM_SIZE, GFP_KERNEL);
 350         if (!wlan_static_dhd_memdump_ram_buf)
 351                 goto err_mem_alloc;
 352
 353         wlan_static_dhd_wlfc_hanger_buf = kmalloc(DHD_PREALLOC_DHD_WLFC_HANGER_SIZE, GFP_KERNEL);
 354         if (!wlan_static_dhd_wlfc_hanger_buf)
 355                 goto err_mem_alloc;
 356
 357         wlan_static_dhd_log_dump_buf = kmalloc(DHD_PREALLOC_DHD_LOG_DUMP_BUF_SIZE, GFP_KERNEL);
 358         if (!wlan_static_dhd_log_dump_buf)
 359                 goto err_mem_alloc;
 360
 361         wlan_static_dhd_log_dump_buf_ex = kmalloc(DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX_SIZE, GFP_KERNEL);
 362         if (!wlan_static_dhd_log_dump_buf_ex)
 363                 goto err_mem_alloc;
 364
 365         wlan_static_wl_escan_info_buf = kmalloc(DHD_PREALLOC_WL_WEXT_INFO_SIZE, GFP_KERNEL);
 366         if (!wlan_static_wl_escan_info_buf)
 367                 goto err_mem_alloc;
 368
 369         wlan_static_fw_verbose_ring_buf = kmalloc(FW_VERBOSE_RING_SIZE, GFP_KERNEL);
 370         if (!wlan_static_fw_verbose_ring_buf)
 371                 goto err_mem_alloc;
 372
 373         wlan_static_fw_event_ring_buf = kmalloc(FW_EVENT_RING_SIZE, GFP_KERNEL);
 374         if (!wlan_static_fw_event_ring_buf)
 375                 goto err_mem_alloc;
 376
 377         wlan_static_dhd_event_ring_buf = kmalloc(DHD_EVENT_RING_SIZE, GFP_KERNEL);
 378         if (!wlan_static_dhd_event_ring_buf)
 379                 goto err_mem_alloc;
 380
 381         wlan_static_nan_event_ring_buf = kmalloc(NAN_EVENT_RING_SIZE, GFP_KERNEL);
 382         if (!wlan_static_nan_event_ring_buf)
 383                 goto err_mem_alloc;
 384
 385         pr_info("bcmdhd_init_wlan_mem prealloc ok\n");
 386         return 0;
 387
 388 err_mem_alloc:
 389
 390         if (wlan_static_prot)
 391                 kfree(wlan_static_prot);
 392
 393 #if defined(BCMDHD_SDIO)
 394         if (wlan_static_rxbuf)
 395                 kfree(wlan_static_rxbuf);
 396
 397         if (wlan_static_databuf)
 398                 kfree(wlan_static_databuf);
 399 #endif /* BCMDHD_SDIO */
 400
 401         if (wlan_static_osl_buf)
 402                 kfree(wlan_static_osl_buf);
 403
 404         if (wlan_static_scan_buf0)
 405                 kfree(wlan_static_scan_buf0);
 406
 407         if (wlan_static_scan_buf1)
 408                 kfree(wlan_static_scan_buf1);
 409
 410         if (wlan_static_dhd_info_buf)
 411                 kfree(wlan_static_dhd_info_buf);
 412
 413         if (wlan_static_dhd_wlfc_info_buf)
 414                 kfree(wlan_static_dhd_wlfc_info_buf);
 415
 416 #ifdef BCMDHD_PCIE
 417         if (wlan_static_if_flow_lkup)
 418                 kfree(wlan_static_if_flow_lkup);
 419 #endif /* BCMDHD_PCIE */
 420
 421         if (wlan_static_dhd_memdump_ram_buf)
 422                 kfree(wlan_static_dhd_memdump_ram_buf);
 423
 424         if (wlan_static_dhd_wlfc_hanger_buf)
 425                 kfree(wlan_static_dhd_wlfc_hanger_buf);
 426
 427         if (wlan_static_dhd_log_dump_buf)
 428                 kfree(wlan_static_dhd_log_dump_buf);
 429
 430         if (wlan_static_dhd_log_dump_buf_ex)
 431                 kfree(wlan_static_dhd_log_dump_buf_ex);
 432
 433         if (wlan_static_wl_escan_info_buf)
 434                 kfree(wlan_static_wl_escan_info_buf);
 435
 436 #ifdef BCMDHD_PCIE
 437         if (wlan_static_fw_verbose_ring_buf)
 438                 kfree(wlan_static_fw_verbose_ring_buf);
 439
 440         if (wlan_static_fw_event_ring_buf)
 441                 kfree(wlan_static_fw_event_ring_buf);
 442
 443         if (wlan_static_dhd_event_ring_buf)
 444                 kfree(wlan_static_dhd_event_ring_buf);
 445
 446         if (wlan_static_nan_event_ring_buf)
 447                 kfree(wlan_static_nan_event_ring_buf);
 448 #endif /* BCMDHD_PCIE */
 449
 450         pr_err("%s: Failed to mem_alloc for WLAN\n", __func__);
 451
 452         i = WLAN_SKB_BUF_NUM;
 453
 454 err_skb_alloc:
 455         pr_err("%s: Failed to skb_alloc for WLAN\n", __func__);
 456         for (j = 0; j < i; j++)
 457                 dev_kfree_skb(wlan_static_skb[j]);
 458
 459         return -ENOMEM;
 460 }
 461 EXPORT_SYMBOL(bcmdhd_init_wlan_mem);
 462 MODULE_LICENSE("GPL");
 463 MODULE_AUTHOR("AMLOGIC");
 464 MODULE_DESCRIPTION("wifi device tree driver");