--- /dev/null
+/*
+ * Platform Dependent file for usage of Preallocted Memory
+ *
+ * Copyright (C) 2020, Broadcom.
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2 (the "GPL"),
+ * available at http://www.broadcom.com/licenses/GPLv2.php, with the
+ * following added to such license:
+ *
+ * As a special exception, the copyright holders of this software give you
+ * permission to link this software with independent modules, and to copy and
+ * distribute the resulting executable under terms of your choice, provided that
+ * you also meet, for each linked independent module, the terms and conditions of
+ * the license of that module. An independent module is a module which is not
+ * derived from this software. The special exception does not apply to any
+ * modifications of the software.
+ *
+ *
+ * <<Broadcom-WL-IPTag/Open:>>
+ *
+ * $Id$
+ */
+
+#include <linux/device.h>
+#include <linux/slab.h>
+#include <linux/miscdevice.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/io.h>
+#include <linux/workqueue.h>
+#include <linux/unistd.h>
+#include <linux/bug.h>
+#include <linux/skbuff.h>
+#include <linux/init.h>
+
+#ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM
+
+#define WLAN_STATIC_SCAN_BUF0 5
+#define WLAN_STATIC_SCAN_BUF1 6
+#define WLAN_STATIC_DHD_INFO_BUF 7
+#define WLAN_STATIC_DHD_WLFC_BUF 8
+#define WLAN_STATIC_DHD_IF_FLOW_LKUP 9
+#define WLAN_STATIC_DHD_MEMDUMP_RAM 11
+#define WLAN_STATIC_DHD_WLFC_HANGER 12
+#define WLAN_STATIC_DHD_PKTID_MAP 13
+#define WLAN_STATIC_DHD_PKTID_IOCTL_MAP 14
+#define WLAN_STATIC_DHD_LOG_DUMP_BUF 15
+#define WLAN_STATIC_DHD_LOG_DUMP_BUF_EX 16
+#define WLAN_STATIC_DHD_PKTLOG_DUMP_BUF 17
+
+#define WLAN_SCAN_BUF_SIZE (64 * 1024)
+
+#define WLAN_DHD_INFO_BUF_SIZE (32 * 1024)
+#define WLAN_DHD_WLFC_BUF_SIZE (64 * 1024)
+#define WLAN_DHD_IF_FLOW_LKUP_SIZE (64 * 1024)
+/* Have 2MB ramsize to accomodate future chips */
+#define WLAN_DHD_MEMDUMP_SIZE (3 * 1024 * 1024)
+
+#define PREALLOC_WLAN_SEC_NUM 4
+#define PREALLOC_WLAN_BUF_NUM 160
+#define PREALLOC_WLAN_SECTION_HEADER 24
+
+#ifdef CONFIG_BCMDHD_PCIE
+#define DHD_SKB_1PAGE_BUFSIZE (PAGE_SIZE*1)
+#define DHD_SKB_2PAGE_BUFSIZE (PAGE_SIZE*2)
+#define DHD_SKB_4PAGE_BUFSIZE (PAGE_SIZE*4)
+
+#define WLAN_SECTION_SIZE_0 (PREALLOC_WLAN_BUF_NUM * 128)
+#define WLAN_SECTION_SIZE_1 0
+#define WLAN_SECTION_SIZE_2 0
+#define WLAN_SECTION_SIZE_3 (PREALLOC_WLAN_BUF_NUM * 1024)
+
+#define DHD_SKB_1PAGE_BUF_NUM 0
+#define DHD_SKB_2PAGE_BUF_NUM 128
+#define DHD_SKB_4PAGE_BUF_NUM 0
+
+#else
+#define DHD_SKB_HDRSIZE 336
+#define DHD_SKB_1PAGE_BUFSIZE ((PAGE_SIZE*1)-DHD_SKB_HDRSIZE)
+#define DHD_SKB_2PAGE_BUFSIZE ((PAGE_SIZE*2)-DHD_SKB_HDRSIZE)
+#define DHD_SKB_4PAGE_BUFSIZE ((PAGE_SIZE*4)-DHD_SKB_HDRSIZE)
+
+#define WLAN_SECTION_SIZE_0 (PREALLOC_WLAN_BUF_NUM * 128)
+#define WLAN_SECTION_SIZE_1 (PREALLOC_WLAN_BUF_NUM * 128)
+#define WLAN_SECTION_SIZE_2 (PREALLOC_WLAN_BUF_NUM * 512)
+#define WLAN_SECTION_SIZE_3 (PREALLOC_WLAN_BUF_NUM * 1024)
+
+#define DHD_SKB_1PAGE_BUF_NUM 8
+#define DHD_SKB_2PAGE_BUF_NUM 8
+#define DHD_SKB_4PAGE_BUF_NUM 1
+#endif /* CONFIG_BCMDHD_PCIE */
+
+#define WLAN_SKB_1_2PAGE_BUF_NUM ((DHD_SKB_1PAGE_BUF_NUM) + \
+ (DHD_SKB_2PAGE_BUF_NUM))
+#define WLAN_SKB_BUF_NUM ((WLAN_SKB_1_2PAGE_BUF_NUM) + \
+ (DHD_SKB_4PAGE_BUF_NUM))
+
+#define WLAN_MAX_PKTID_ITEMS (8192)
+#define WLAN_DHD_PKTID_MAP_HDR_SIZE (20 + 4*(WLAN_MAX_PKTID_ITEMS + 1))
+#define WLAN_DHD_PKTID_MAP_ITEM_SIZE (32)
+#define WLAN_DHD_PKTID_MAP_SIZE ((WLAN_DHD_PKTID_MAP_HDR_SIZE) + \
+ ((WLAN_MAX_PKTID_ITEMS+1) * WLAN_DHD_PKTID_MAP_ITEM_SIZE))
+
+#define WLAN_MAX_PKTID_IOCTL_ITEMS (32)
+#define WLAN_DHD_PKTID_IOCTL_MAP_HDR_SIZE (20 + 4*(WLAN_MAX_PKTID_IOCTL_ITEMS + 1))
+#define WLAN_DHD_PKTID_IOCTL_MAP_ITEM_SIZE (32)
+#define WLAN_DHD_PKTID_IOCTL_MAP_SIZE ((WLAN_DHD_PKTID_IOCTL_MAP_HDR_SIZE) + \
+ ((WLAN_MAX_PKTID_IOCTL_ITEMS+1) * WLAN_DHD_PKTID_IOCTL_MAP_ITEM_SIZE))
+
+#define DHD_LOG_DUMP_BUF_SIZE (1024 * 1024 * 4)
+#define DHD_LOG_DUMP_BUF_EX_SIZE (1024 * 1024 * 2)
+
+#define DHD_PKTLOG_DUMP_BUF_SIZE (64 * 1024)
+
+#define WLAN_DHD_WLFC_HANGER_MAXITEMS 3072
+#define WLAN_DHD_WLFC_HANGER_ITEM_SIZE 32
+#define WLAN_DHD_WLFC_HANGER_SIZE ((WLAN_DHD_WLFC_HANGER_ITEM_SIZE) + \
+ ((WLAN_DHD_WLFC_HANGER_MAXITEMS) * (WLAN_DHD_WLFC_HANGER_ITEM_SIZE)))
+
+static struct sk_buff *wlan_static_skb[WLAN_SKB_BUF_NUM];
+
+struct wlan_mem_prealloc {
+ void *mem_ptr;
+ unsigned long size;
+};
+
+static struct wlan_mem_prealloc wlan_mem_array[PREALLOC_WLAN_SEC_NUM] = {
+ {NULL, (WLAN_SECTION_SIZE_0 + PREALLOC_WLAN_SECTION_HEADER)},
+ {NULL, (WLAN_SECTION_SIZE_1 + PREALLOC_WLAN_SECTION_HEADER)},
+ {NULL, (WLAN_SECTION_SIZE_2 + PREALLOC_WLAN_SECTION_HEADER)},
+ {NULL, (WLAN_SECTION_SIZE_3 + PREALLOC_WLAN_SECTION_HEADER)}
+};
+
+static void *wlan_static_scan_buf0 = NULL;
+static void *wlan_static_scan_buf1 = NULL;
+static void *wlan_static_dhd_info_buf = NULL;
+static void *wlan_static_dhd_wlfc_buf = NULL;
+static void *wlan_static_if_flow_lkup = NULL;
+static void *wlan_static_dhd_memdump_ram = NULL;
+static void *wlan_static_dhd_wlfc_hanger = NULL;
+static void *wlan_static_dhd_pktid_map = NULL;
+static void *wlan_static_dhd_pktid_ioctl_map = NULL;
+static void *wlan_static_dhd_log_dump_buf = NULL;
+static void *wlan_static_dhd_log_dump_buf_ex = NULL;
+static void *wlan_static_dhd_pktlog_dump_buf = NULL;
+
+void
+*dhd_wlan_mem_prealloc(int section, unsigned long size)
+{
+ if (section == PREALLOC_WLAN_SEC_NUM) {
+ return wlan_static_skb;
+ }
+
+ if (section == WLAN_STATIC_SCAN_BUF0) {
+ return wlan_static_scan_buf0;
+ }
+
+ if (section == WLAN_STATIC_SCAN_BUF1) {
+ return wlan_static_scan_buf1;
+ }
+
+ if (section == WLAN_STATIC_DHD_INFO_BUF) {
+ if (size > WLAN_DHD_INFO_BUF_SIZE) {
+ pr_err("request DHD_INFO size(%lu) is bigger than"
+ " static size(%d).\n", size,
+ WLAN_DHD_INFO_BUF_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_info_buf;
+ }
+
+ if (section == WLAN_STATIC_DHD_WLFC_BUF) {
+ if (size > WLAN_DHD_WLFC_BUF_SIZE) {
+ pr_err("request DHD_WLFC size(%lu) is bigger than"
+ " static size(%d).\n",
+ size, WLAN_DHD_WLFC_BUF_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_wlfc_buf;
+ }
+
+ if (section == WLAN_STATIC_DHD_WLFC_HANGER) {
+ if (size > WLAN_DHD_WLFC_HANGER_SIZE) {
+ pr_err("request DHD_WLFC_HANGER size(%lu) is bigger than"
+ " static size(%d).\n",
+ size, WLAN_DHD_WLFC_HANGER_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_wlfc_hanger;
+ }
+
+ if (section == WLAN_STATIC_DHD_IF_FLOW_LKUP) {
+ if (size > WLAN_DHD_IF_FLOW_LKUP_SIZE) {
+ pr_err("request DHD_WLFC size(%lu) is bigger than"
+ " static size(%d).\n",
+ size, WLAN_DHD_WLFC_BUF_SIZE);
+ return NULL;
+ }
+ return wlan_static_if_flow_lkup;
+ }
+
+ if (section == WLAN_STATIC_DHD_MEMDUMP_RAM) {
+ if (size > WLAN_DHD_MEMDUMP_SIZE) {
+ pr_err("request DHD_MEMDUMP_RAM size(%lu) is bigger"
+ " than static size(%d).\n",
+ size, WLAN_DHD_MEMDUMP_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_memdump_ram;
+ }
+
+ if (section == WLAN_STATIC_DHD_PKTID_MAP) {
+ if (size > WLAN_DHD_PKTID_MAP_SIZE) {
+ pr_err("request DHD_PKTID_MAP size(%lu) is bigger than"
+ " static size(%d).\n",
+ size, WLAN_DHD_PKTID_MAP_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_pktid_map;
+ }
+
+ if (section == WLAN_STATIC_DHD_PKTID_IOCTL_MAP) {
+ if (size > WLAN_DHD_PKTID_IOCTL_MAP_SIZE) {
+ pr_err("request DHD_PKTID_IOCTL_MAP size(%lu) is bigger than"
+ " static size(%d).\n",
+ size, WLAN_DHD_PKTID_IOCTL_MAP_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_pktid_ioctl_map;
+ }
+
+ if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF) {
+ if (size > DHD_LOG_DUMP_BUF_SIZE) {
+ pr_err("request DHD_LOG_DUMP_BUF size(%lu) is bigger then"
+ " static size(%d).\n",
+ size, DHD_LOG_DUMP_BUF_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_log_dump_buf;
+ }
+
+ if (section == WLAN_STATIC_DHD_LOG_DUMP_BUF_EX) {
+ if (size > DHD_LOG_DUMP_BUF_EX_SIZE) {
+ pr_err("request DHD_LOG_DUMP_BUF_EX size(%lu) is bigger then"
+ " static size(%d).\n",
+ size, DHD_LOG_DUMP_BUF_EX_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_log_dump_buf_ex;
+ }
+
+ if (section == WLAN_STATIC_DHD_PKTLOG_DUMP_BUF) {
+ if (size > DHD_PKTLOG_DUMP_BUF_SIZE) {
+ pr_err("request DHD_PKTLOG_DUMP_BUF size(%lu) is bigger then"
+ " static size(%d).\n",
+ size, DHD_PKTLOG_DUMP_BUF_SIZE);
+ return NULL;
+ }
+ return wlan_static_dhd_pktlog_dump_buf;
+ }
+
+ if ((section < 0) || (section >= PREALLOC_WLAN_SEC_NUM)) {
+ return NULL;
+ }
+
+ if (wlan_mem_array[section].size < size) {
+ return NULL;
+ }
+
+ return wlan_mem_array[section].mem_ptr;
+}
+EXPORT_SYMBOL(dhd_wlan_mem_prealloc);
+
+int
+dhd_init_wlan_mem(void)
+{
+ int i;
+ int j;
+
+#if !defined(CONFIG_BCMDHD_PCIE)
+ for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
+ wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE, GFP_KERNEL);
+ if (!wlan_static_skb[i]) {
+ goto err_skb_alloc;
+ }
+ }
+#endif /* !CONFIG_BCMDHD_PCIE */
+
+ for (i = DHD_SKB_1PAGE_BUF_NUM; i < WLAN_SKB_1_2PAGE_BUF_NUM; i++) {
+ wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_2PAGE_BUFSIZE, GFP_KERNEL);
+ if (!wlan_static_skb[i]) {
+ goto err_skb_alloc;
+ }
+ }
+
+#if !defined(CONFIG_BCMDHD_PCIE)
+ wlan_static_skb[i] = __dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE, GFP_KERNEL);
+ if (!wlan_static_skb[i]) {
+ goto err_skb_alloc;
+ }
+#endif /* !CONFIG_BCMDHD_PCIE */
+
+ for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
+ if (wlan_mem_array[i].size > 0) {
+ wlan_mem_array[i].mem_ptr =
+ kmalloc(wlan_mem_array[i].size, GFP_KERNEL);
+
+ if (!wlan_mem_array[i].mem_ptr) {
+ goto err_mem_alloc;
+ }
+ }
+ }
+
+ wlan_static_scan_buf0 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
+ if (!wlan_static_scan_buf0) {
+ pr_err("Failed to alloc wlan_static_scan_buf0\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_scan_buf1 = kmalloc(WLAN_SCAN_BUF_SIZE, GFP_KERNEL);
+ if (!wlan_static_scan_buf1) {
+ pr_err("Failed to alloc wlan_static_scan_buf1\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_dhd_log_dump_buf = kmalloc(DHD_LOG_DUMP_BUF_SIZE, GFP_KERNEL);
+ if (!wlan_static_dhd_log_dump_buf) {
+ pr_err("Failed to alloc wlan_static_dhd_log_dump_buf\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_dhd_log_dump_buf_ex = kmalloc(DHD_LOG_DUMP_BUF_EX_SIZE, GFP_KERNEL);
+ if (!wlan_static_dhd_log_dump_buf_ex) {
+ pr_err("Failed to alloc wlan_static_dhd_log_dump_buf_ex\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_dhd_info_buf = kmalloc(WLAN_DHD_INFO_BUF_SIZE, GFP_KERNEL);
+ if (!wlan_static_dhd_info_buf) {
+ pr_err("Failed to alloc wlan_static_dhd_info_buf\n");
+ goto err_mem_alloc;
+ }
+
+#ifdef CONFIG_BCMDHD_PCIE
+ wlan_static_if_flow_lkup = kmalloc(WLAN_DHD_IF_FLOW_LKUP_SIZE,
+ GFP_KERNEL);
+ if (!wlan_static_if_flow_lkup) {
+ pr_err("Failed to alloc wlan_static_if_flow_lkup\n");
+ goto err_mem_alloc;
+ }
+
+#ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
+ wlan_static_dhd_pktid_map = kmalloc(WLAN_DHD_PKTID_MAP_SIZE,
+ GFP_KERNEL);
+ if (!wlan_static_dhd_pktid_map) {
+ pr_err("Failed to alloc wlan_static_dhd_pktid_map\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_dhd_pktid_ioctl_map = kmalloc(WLAN_DHD_PKTID_IOCTL_MAP_SIZE,
+ GFP_KERNEL);
+ if (!wlan_static_dhd_pktid_ioctl_map) {
+ pr_err("Failed to alloc wlan_static_dhd_pktid_ioctl_map\n");
+ goto err_mem_alloc;
+ }
+#endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
+#else
+ wlan_static_dhd_wlfc_buf = kmalloc(WLAN_DHD_WLFC_BUF_SIZE,
+ GFP_KERNEL);
+ if (!wlan_static_dhd_wlfc_buf) {
+ pr_err("Failed to alloc wlan_static_dhd_wlfc_buf\n");
+ goto err_mem_alloc;
+ }
+
+ wlan_static_dhd_wlfc_hanger = kmalloc(WLAN_DHD_WLFC_HANGER_SIZE,
+ GFP_KERNEL);
+ if (!wlan_static_dhd_wlfc_hanger) {
+ pr_err("Failed to alloc wlan_static_dhd_wlfc_hanger\n");
+ goto err_mem_alloc;
+ }
+#endif /* CONFIG_BCMDHD_PCIE */
+
+#ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
+ wlan_static_dhd_memdump_ram = kmalloc(WLAN_DHD_MEMDUMP_SIZE, GFP_KERNEL);
+ if (!wlan_static_dhd_memdump_ram) {
+ pr_err("Failed to alloc wlan_static_dhd_memdump_ram\n");
+ goto err_mem_alloc;
+ }
+#endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
+
+ wlan_static_dhd_pktlog_dump_buf = kmalloc(DHD_PKTLOG_DUMP_BUF_SIZE, GFP_KERNEL);
+ if (!wlan_static_dhd_pktlog_dump_buf) {
+ pr_err("Failed to alloc wlan_static_dhd_pktlog_dump_buf\n");
+ goto err_mem_alloc;
+ }
+
+ pr_err("%s: WIFI MEM Allocated\n", __FUNCTION__);
+ return 0;
+
+err_mem_alloc:
+#ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
+ if (wlan_static_dhd_memdump_ram) {
+ kfree(wlan_static_dhd_memdump_ram);
+ }
+
+#endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
+
+#ifdef CONFIG_BCMDHD_PCIE
+ if (wlan_static_if_flow_lkup) {
+ kfree(wlan_static_if_flow_lkup);
+ }
+
+#ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
+ if (wlan_static_dhd_pktid_map) {
+ kfree(wlan_static_dhd_pktid_map);
+ }
+
+ if (wlan_static_dhd_pktid_ioctl_map) {
+ kfree(wlan_static_dhd_pktid_ioctl_map);
+ }
+#endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
+#else
+ if (wlan_static_dhd_wlfc_buf) {
+ kfree(wlan_static_dhd_wlfc_buf);
+ }
+
+ if (wlan_static_dhd_wlfc_hanger) {
+ kfree(wlan_static_dhd_wlfc_hanger);
+ }
+#endif /* CONFIG_BCMDHD_PCIE */
+ if (wlan_static_dhd_info_buf) {
+ kfree(wlan_static_dhd_info_buf);
+ }
+
+ if (wlan_static_dhd_log_dump_buf) {
+ kfree(wlan_static_dhd_log_dump_buf);
+ }
+
+ if (wlan_static_dhd_log_dump_buf_ex) {
+ kfree(wlan_static_dhd_log_dump_buf_ex);
+ }
+
+ if (wlan_static_scan_buf1) {
+ kfree(wlan_static_scan_buf1);
+ }
+
+ if (wlan_static_scan_buf0) {
+ kfree(wlan_static_scan_buf0);
+ }
+
+ if (wlan_static_dhd_pktlog_dump_buf) {
+ kfree(wlan_static_dhd_pktlog_dump_buf);
+ }
+
+ pr_err("Failed to mem_alloc for WLAN\n");
+
+ for (j = 0; j < i; j++) {
+ kfree(wlan_mem_array[j].mem_ptr);
+ }
+
+ i = WLAN_SKB_BUF_NUM;
+
+err_skb_alloc:
+ pr_err("Failed to skb_alloc for WLAN\n");
+ for (j = 0; j < i; j++) {
+ dev_kfree_skb(wlan_static_skb[j]);
+ }
+
+ return -ENOMEM;
+}
+EXPORT_SYMBOL(dhd_init_wlan_mem);
+
+void
+dhd_exit_wlan_mem(void)
+{
+ int i = 0;
+
+#ifdef CONFIG_BCMDHD_PREALLOC_MEMDUMP
+ if (wlan_static_dhd_memdump_ram) {
+ kfree(wlan_static_dhd_memdump_ram);
+ }
+
+#endif /* CONFIG_BCMDHD_PREALLOC_MEMDUMP */
+
+#ifdef CONFIG_BCMDHD_PCIE
+ if (wlan_static_if_flow_lkup) {
+ kfree(wlan_static_if_flow_lkup);
+ }
+
+#ifdef CONFIG_BCMDHD_PREALLOC_PKTIDMAP
+ if (wlan_static_dhd_pktid_map) {
+ kfree(wlan_static_dhd_pktid_map);
+ }
+
+ if (wlan_static_dhd_pktid_ioctl_map) {
+ kfree(wlan_static_dhd_pktid_ioctl_map);
+ }
+#endif /* CONFIG_BCMDHD_PREALLOC_PKTIDMAP */
+#else
+ if (wlan_static_dhd_wlfc_buf) {
+ kfree(wlan_static_dhd_wlfc_buf);
+ }
+
+ if (wlan_static_dhd_wlfc_hanger) {
+ kfree(wlan_static_dhd_wlfc_hanger);
+ }
+#endif /* CONFIG_BCMDHD_PCIE */
+ if (wlan_static_dhd_info_buf) {
+ kfree(wlan_static_dhd_info_buf);
+ }
+
+ if (wlan_static_dhd_log_dump_buf) {
+ kfree(wlan_static_dhd_log_dump_buf);
+ }
+
+ if (wlan_static_dhd_log_dump_buf_ex) {
+ kfree(wlan_static_dhd_log_dump_buf_ex);
+ }
+
+ if (wlan_static_scan_buf1) {
+ kfree(wlan_static_scan_buf1);
+ }
+
+ if (wlan_static_scan_buf0) {
+ kfree(wlan_static_scan_buf0);
+ }
+
+ if (wlan_static_dhd_pktlog_dump_buf) {
+ kfree(wlan_static_dhd_pktlog_dump_buf);
+ }
+
+ pr_err("Failed to mem_alloc for WLAN\n");
+
+ for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
+ if (wlan_mem_array[i].mem_ptr) {
+ kfree(wlan_mem_array[i].mem_ptr);
+ }
+ }
+
+ pr_err("Failed to skb_alloc for WLAN\n");
+ for (i = 0; i < WLAN_SKB_BUF_NUM; i++) {
+ dev_kfree_skb(wlan_static_skb[i]);
+ }
+
+ return;
+}
+EXPORT_SYMBOL(dhd_exit_wlan_mem);
+#endif /* CONFIG_BROADCOM_WIFI_RESERVED_MEM */
projects / GitHub / LineageOS / G12 / android_hardware_amlogic_kernel-modules_dhd-driver.git / blobdiff