PD#146454 wifi: update dhd_static_buf[1/2]

update dhd_static_buf to fix prealloc mem issue Change-Id: I0f11d174d3b8d688b1ffe37f5dd922244cfae873 Signed-off-by: Rongjun Chen <rongjun.chen@amlogic.com>
2026-06-08 03:40:35 +09:00 · 2017-09-11 15:49:50 +08:00
parent fc4107647e
commit 80a2e62e8b
1 changed files with 345 additions and 97 deletions
--- a/drivers/amlogic/wifi/dhd_static_buf.c
+++ b/drivers/amlogic/wifi/dhd_static_buf.c
@@ -26,93 +26,227 @@
 #include <linux/skbuff.h>
 #include <linux/wlan_plat.h>
 #include <linux/amlogic/dhd_buf.h>
+enum dhd_prealloc_index {
+	DHD_PREALLOC_PROT = 0,
+	DHD_PREALLOC_RXBUF,
+	DHD_PREALLOC_DATABUF,
+	DHD_PREALLOC_OSL_BUF,
+	DHD_PREALLOC_SKB_BUF,
+	DHD_PREALLOC_WIPHY_ESCAN0 = 5,
+	DHD_PREALLOC_WIPHY_ESCAN1 = 6,
+	DHD_PREALLOC_DHD_INFO = 7,
+	DHD_PREALLOC_DHD_WLFC_INFO = 8,
+	DHD_PREALLOC_IF_FLOW_LKUP = 9,
+	DHD_PREALLOC_MEMDUMP_BUF = 10,
+	DHD_PREALLOC_MEMDUMP_RAM = 11,
+	DHD_PREALLOC_DHD_WLFC_HANGER = 12,
+	DHD_PREALLOC_PKTID_MAP = 13,
+	DHD_PREALLOC_PKTID_MAP_IOCTL = 14,
+	DHD_PREALLOC_DHD_LOG_DUMP_BUF = 15,
+	DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX = 16,
+	DHD_PREALLOC_DHD_PKTLOG_DUMP_BUF = 17,
+	DHD_PREALLOC_STAT_REPORT_BUF = 18,
+	DHD_PREALLOC_WL_ESCAN_INFO = 19,
+	DHD_PREALLOC_FW_VERBOSE_RING = 20,
+	DHD_PREALLOC_FW_EVENT_RING = 21,
+	DHD_PREALLOC_DHD_EVENT_RING = 22,
+	DHD_PREALLOC_NAN_EVENT_RING = 23,
+	DHD_PREALLOC_MAX

-#define CONFIG_BROADCOM_WIFI_RESERVED_MEM
+};

-#ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM

-#define WLAN_STATIC_PKT_BUF			4
-#define WLAN_STATIC_SCAN_BUF0		5
-#define WLAN_STATIC_SCAN_BUF1		6
-#define WLAN_STATIC_DHD_INFO		7
-#define WLAN_STATIC_DHD_WLFC_INFO		8
-#define PREALLOC_WLAN_SEC_NUM		6
-#define PREALLOC_WLAN_BUF_NUM		160
-#define PREALLOC_WLAN_SECTION_HEADER	24
+#define STATIC_BUF_MAX_NUM	20
+#define STATIC_BUF_SIZE	(PAGE_SIZE*2)

-#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 WLAN_SECTION_SIZE_7	(PREALLOC_WLAN_BUF_NUM * 128)
-#define WLAN_SECTION_SIZE_8	(PREALLOC_WLAN_BUF_NUM * 512)
+#define DHD_PREALLOC_PROT_SIZE	(16 * 1024)
+#define DHD_PREALLOC_RXBUF_SIZE	(24 * 1024)
+#define DHD_PREALLOC_DATABUF_SIZE	(64 * 1024)
+#define DHD_PREALLOC_OSL_BUF_SIZE	(STATIC_BUF_MAX_NUM * STATIC_BUF_SIZE)
+#define DHD_PREALLOC_WIPHY_ESCAN0_SIZE	(64 * 1024)
+#define DHD_PREALLOC_DHD_INFO_SIZE	(30 * 1024)
+#define DHD_PREALLOC_MEMDUMP_RAM_SIZE      (768 * 1024)
+#define DHD_PREALLOC_DHD_WLFC_HANGER_SIZE	(73 * 1024)
+#define DHD_PREALLOC_WL_ESCAN_INFO_SIZE	(66 * 1024)
+#ifdef CONFIG_64BIT
+#define DHD_PREALLOC_IF_FLOW_LKUP_SIZE	(20 * 1024 * 2)
+#else
+#define DHD_PREALLOC_IF_FLOW_LKUP_SIZE	(20 * 1024)
+#endif

-#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)
+#if defined(CONFIG_64BIT)
+#define WLAN_DHD_INFO_BUF_SIZE	(24 * 1024)
+#define WLAN_DHD_WLFC_BUF_SIZE	(64 * 1024)
+#define WLAN_DHD_IF_FLOW_LKUP_SIZE	(64 * 1024)
+#else
+#define WLAN_DHD_INFO_BUF_SIZE	(16 * 1024)
+#define WLAN_DHD_WLFC_BUF_SIZE	(24 * 1024)
+#define WLAN_DHD_IF_FLOW_LKUP_SIZE	(20 * 1024)
+#endif /* CONFIG_64BIT */
+#define WLAN_DHD_MEMDUMP_SIZE	(800 * 1024)

-#define WLAN_SKB_BUF_NUM	17
+
+#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 DHD_SKB_1PAGE_BUF_NUM	8
+#define DHD_SKB_2PAGE_BUF_NUM	64
+#define DHD_SKB_4PAGE_BUF_NUM	1
+
+
+/* The number is defined in linux_osl.c
+ * WLAN_SKB_1_2PAGE_BUF_NUM => STATIC_PKT_1_2PAGE_NUM
+ * WLAN_SKB_BUF_NUM => STATIC_PKT_MAX_NUM
+ */
+#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))
+
+void *wlan_static_prot;
+void *wlan_static_rxbuf;
+void *wlan_static_databuf;
+void *wlan_static_osl_buf;
+void *wlan_static_scan_buf0;
+void *wlan_static_scan_buf1;
+void *wlan_static_dhd_info_buf;
+void *wlan_static_dhd_wlfc_info_buf;
+void *wlan_static_if_flow_lkup;
+void *wlan_static_dhd_memdump_ram_buf;
+void *wlan_static_wl_escan_info_buf;
+void *wlan_static_dhd_wlfc_hanger_buf;
+void *wlan_static_fw_verbose_ring_buf;
+void *wlan_static_fw_event_ring_buf;
+void *wlan_static_dhd_event_ring_buf;
+void *wlan_static_nan_event_ring_buf;

 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)},
-	{NULL, (WLAN_SECTION_SIZE_7 + PREALLOC_WLAN_SECTION_HEADER)},
-	{NULL, (WLAN_SECTION_SIZE_8 + PREALLOC_WLAN_SECTION_HEADER)}
-};
-
-void *wlan_static_scan_buf0;
-void *wlan_static_scan_buf1;
 void *bcmdhd_mem_prealloc(int section, unsigned long size)
 {
-	if (section == WLAN_STATIC_PKT_BUF) {
-		pr_info("1 %s: section=%d, wlan_static_skb=%p\n",
-			__func__, section, wlan_static_skb);
+	pr_err("%s: sectoin %d, %ld\n", __func__, section, size);
+	if (section == DHD_PREALLOC_PROT)
+		return wlan_static_prot;
+
+	if (section == DHD_PREALLOC_RXBUF)
+		return wlan_static_rxbuf;
+
+	if (section == DHD_PREALLOC_DATABUF)
+		return wlan_static_databuf;
+
+	if (section == DHD_PREALLOC_SKB_BUF)
 		return wlan_static_skb;
-	}
-	if (section == WLAN_STATIC_SCAN_BUF0) {
-		pr_info("2 %s: section=%d, wlan_static_scan_buf0=%p\n",
-			__func__, section, wlan_static_scan_buf0);
+
+	if (section == DHD_PREALLOC_WIPHY_ESCAN0)
 		return wlan_static_scan_buf0;
-	}
-	if (section == WLAN_STATIC_SCAN_BUF1) {
-		pr_info("3 %s: section=%d, wlan_static_scan_buf1=%p\n",
-			__func__, section, wlan_static_scan_buf1);
+
+	if (section == DHD_PREALLOC_WIPHY_ESCAN1)
 		return wlan_static_scan_buf1;
-	}
-	if (section == WLAN_STATIC_DHD_INFO) {
-		pr_info("4 %s: section=%d, wlan_mem_array[4]=%p\n",
-			__func__, section, wlan_mem_array[4].mem_ptr);
-		return wlan_mem_array[4].mem_ptr;
-	}
-	if (section == WLAN_STATIC_DHD_WLFC_INFO) {
-		pr_info("5 %s: section=%d, wlan_mem_array[5]=%p\n",
-			__func__, section, wlan_mem_array[5].mem_ptr);
-		return wlan_mem_array[5].mem_ptr;
-	}
-	if ((section < 0) || (section > PREALLOC_WLAN_SEC_NUM)) {
-		pr_info("5 %s: out of section %d\n", __func__, section);
-		return NULL;
+
+	if (section == DHD_PREALLOC_OSL_BUF) {
+		if (size > DHD_PREALLOC_OSL_BUF_SIZE) {
+			pr_err("request OSL_BUF(%lu) is bigger than static size(%ld).\n",
+				size, DHD_PREALLOC_OSL_BUF_SIZE);
+			return NULL;
+		}
+		return wlan_static_osl_buf;
 	}

-	if (wlan_mem_array[section].size < size) {
-		pr_info("6 %s: wlan_mem_array[section].size=%lu, size=%lu\n",
-			__func__, wlan_mem_array[section].size, size);
-		return NULL;
+	if (section == DHD_PREALLOC_DHD_INFO) {
+		if (size > DHD_PREALLOC_DHD_INFO_SIZE) {
+			pr_err("request DHD_INFO size(%lu) is bigger than static size(%d).\n",
+				size, DHD_PREALLOC_DHD_INFO_SIZE);
+			return NULL;
+		}
+		return wlan_static_dhd_info_buf;
 	}
-	pr_info("7 %s: wlan_mem_array[section].mem_ptr=%p, size=%lu\n",
-		__func__, &wlan_mem_array[section], size);
+	if (section == DHD_PREALLOC_DHD_WLFC_INFO) {
+		if (size > WLAN_DHD_WLFC_BUF_SIZE) {
+			pr_err("request DHD_WLFC_INFO size(%lu) is bigger than static size(%d).\n",
+				size, WLAN_DHD_WLFC_BUF_SIZE);
+			return NULL;
+		}
+		return wlan_static_dhd_wlfc_info_buf;
+	}
+	if (section == DHD_PREALLOC_IF_FLOW_LKUP)  {
+		if (size > DHD_PREALLOC_IF_FLOW_LKUP_SIZE) {
+			pr_err("request DHD_IF_FLOW_LKUP size(%lu) is bigger than static size(%d).\n",
+				size, DHD_PREALLOC_IF_FLOW_LKUP_SIZE);
+			return NULL;
+		}

-	return wlan_mem_array[section].mem_ptr;
+		return wlan_static_if_flow_lkup;
+	}
+	if (section == DHD_PREALLOC_MEMDUMP_RAM) {
+		if (size > DHD_PREALLOC_MEMDUMP_RAM_SIZE) {
+			pr_err("request DHD_PREALLOC_MEMDUMP_RAM_SIZE(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_MEMDUMP_RAM_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_dhd_memdump_ram_buf;
+	}
+	if (section == DHD_PREALLOC_WL_ESCAN_INFO) {
+		if (size > DHD_PREALLOC_WL_ESCAN_INFO_SIZE) {
+			pr_err("request DHD_PREALLOC_WL_ESCAN_INFO_SIZE(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_wl_escan_info_buf;
+	}
+	if (section == DHD_PREALLOC_FW_VERBOSE_RING) {
+		if (size > DHD_PREALLOC_WIPHY_ESCAN0_SIZE) {
+			pr_err("request DHD_PREALLOC_FW_VERBOSE_RING(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_fw_verbose_ring_buf;
+	}
+	if (section == DHD_PREALLOC_FW_EVENT_RING) {
+		if (size > DHD_PREALLOC_WIPHY_ESCAN0_SIZE) {
+			pr_err("request DHD_PREALLOC_FW_EVENT_RING(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_fw_event_ring_buf;
+	}
+	if (section == DHD_PREALLOC_DHD_EVENT_RING) {
+		if (size > DHD_PREALLOC_WIPHY_ESCAN0_SIZE) {
+			pr_err("request DHD_PREALLOC_DHD_EVENT_RING(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_dhd_event_ring_buf;
+	}
+	if (section == DHD_PREALLOC_NAN_EVENT_RING) {
+		if (size > DHD_PREALLOC_WIPHY_ESCAN0_SIZE) {
+			pr_err("request DHD_PREALLOC_NAN_EVENT_RING(%lu) is bigger than static size(%d).\n",
+					size, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
+			return NULL;
+		}
+
+		return wlan_static_nan_event_ring_buf;
+	}
+	if (section == DHD_PREALLOC_DHD_WLFC_HANGER) {
+		if (size > DHD_PREALLOC_DHD_WLFC_HANGER_SIZE) {
+			pr_err("request DHD_WLFC_HANGER size(%lu) is bigger than static size(%d).\n",
+				size, DHD_PREALLOC_DHD_WLFC_HANGER_SIZE);
+			return NULL;
+		}
+		return wlan_static_dhd_wlfc_hanger_buf;
+	}
+	if ((section < 0) || (section > DHD_PREALLOC_MAX))
+		pr_err("request section id(%d) is out of max index %d\n",
+				section, DHD_PREALLOC_MAX);
+
+	pr_err("%s: failed to alloc section %d, size=%ld\n",
+			 __func__, section, size);
+
+	return NULL;
 }
 EXPORT_SYMBOL(bcmdhd_mem_prealloc);

@@ -121,58 +255,172 @@ int bcmdhd_init_wlan_mem(void)
 	int i;
 	int j;

-	for (i = 0; i < 8; i++) {
+	for (i = 0; i < DHD_SKB_1PAGE_BUF_NUM; i++) {
 		wlan_static_skb[i] = dev_alloc_skb(DHD_SKB_1PAGE_BUFSIZE);
 		if (!wlan_static_skb[i])
 			goto err_skb_alloc;
-		pr_debug("1 %s: wlan_static_skb[%d]=%p, size=%lu\n",
-			__func__, i, wlan_static_skb[i], DHD_SKB_1PAGE_BUFSIZE);
+
+		pr_err("%s: sectoin %d skb[%d], size=%ld\n", __func__,
+			 DHD_PREALLOC_SKB_BUF, i, DHD_SKB_1PAGE_BUFSIZE);
 	}

-	for (; i < 16; i++) {
+	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);
 		if (!wlan_static_skb[i])
 			goto err_skb_alloc;
-		pr_debug("2 %s: wlan_static_skb[%d]=%p, size=%lu\n",
-			__func__, i, wlan_static_skb[i], DHD_SKB_2PAGE_BUFSIZE);
+
+		pr_err("%s: sectoin %d skb[%d], size=%ld\n", __func__,
+			 DHD_PREALLOC_SKB_BUF, i, DHD_SKB_2PAGE_BUFSIZE);
 	}

+
 	wlan_static_skb[i] = dev_alloc_skb(DHD_SKB_4PAGE_BUFSIZE);
 	if (!wlan_static_skb[i])
 		goto err_skb_alloc;
-	pr_debug("3 %s: wlan_static_skb[%d]=%p, size=%lu\n",
-		__func__, i, wlan_static_skb[i], DHD_SKB_4PAGE_BUFSIZE);

-	for (i = 0; i < PREALLOC_WLAN_SEC_NUM; i++) {
-		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;
-		pr_debug("4 %s: wlan_mem_array[%d]=%p, size=%lu\n",
-			__func__, i, wlan_static_skb[i],
-			wlan_mem_array[i].size);
-	}

-	wlan_static_scan_buf0 = kmalloc(65536, GFP_KERNEL);
+	wlan_static_prot = kmalloc(DHD_PREALLOC_PROT_SIZE, GFP_KERNEL);
+	if (!wlan_static_prot)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_PROT, DHD_PREALLOC_PROT_SIZE);
+
+
+	wlan_static_rxbuf = kmalloc(DHD_PREALLOC_RXBUF_SIZE, GFP_KERNEL);
+	if (!wlan_static_rxbuf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_RXBUF, DHD_PREALLOC_RXBUF_SIZE);
+
+	wlan_static_databuf = kmalloc(DHD_PREALLOC_DATABUF_SIZE, GFP_KERNEL);
+	if (!wlan_static_databuf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_DATABUF, DHD_PREALLOC_DATABUF_SIZE);
+
+
+	wlan_static_osl_buf = kmalloc(DHD_PREALLOC_OSL_BUF_SIZE, GFP_KERNEL);
+	if (!wlan_static_osl_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%ld\n", __func__,
+		 DHD_PREALLOC_OSL_BUF, DHD_PREALLOC_OSL_BUF_SIZE);
+
+	wlan_static_scan_buf0 = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE,
+					 GFP_KERNEL);
 	if (!wlan_static_scan_buf0)
 		goto err_mem_alloc;
-	pr_debug("5 %s: wlan_static_scan_buf0=%p, size=%d\n",
-		__func__, wlan_static_scan_buf0, 65536);

-	wlan_static_scan_buf1 = kmalloc(65536, GFP_KERNEL);
-	if (!wlan_static_scan_buf1)
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_WIPHY_ESCAN0, DHD_PREALLOC_WIPHY_ESCAN0_SIZE);
+
+	wlan_static_dhd_info_buf = kmalloc(DHD_PREALLOC_DHD_INFO_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_dhd_info_buf)
 		goto err_mem_alloc;
-	pr_debug("6 %s: wlan_static_scan_buf1=%p, size=%d\n",
-		__func__, wlan_static_scan_buf1, 65536);

-	pr_info("%s: WIFI MEM Allocated\n", __func__);
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_DHD_INFO, DHD_PREALLOC_DHD_INFO_SIZE);
+
+	wlan_static_dhd_wlfc_info_buf = kmalloc(WLAN_DHD_WLFC_BUF_SIZE,
+						 GFP_KERNEL);
+	if (!wlan_static_dhd_wlfc_info_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		 DHD_PREALLOC_DHD_WLFC_INFO, WLAN_DHD_WLFC_BUF_SIZE);
+
+	wlan_static_dhd_memdump_ram_buf = kmalloc(DHD_PREALLOC_MEMDUMP_RAM_SIZE,
+						 GFP_KERNEL);
+	if (!wlan_static_dhd_memdump_ram_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_MEMDUMP_RAM, DHD_PREALLOC_MEMDUMP_RAM_SIZE);
+
+	wlan_static_wl_escan_info_buf = kmalloc(DHD_PREALLOC_WL_ESCAN_INFO_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_wl_escan_info_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_WL_ESCAN_INFO, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+
+	wlan_static_fw_verbose_ring_buf = kmalloc(
+						DHD_PREALLOC_WIPHY_ESCAN0_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_fw_verbose_ring_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_FW_VERBOSE_RING, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+
+	wlan_static_fw_event_ring_buf = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_fw_event_ring_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_FW_EVENT_RING, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+
+	wlan_static_dhd_event_ring_buf = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_dhd_event_ring_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_DHD_EVENT_RING, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+
+	wlan_static_nan_event_ring_buf = kmalloc(DHD_PREALLOC_WIPHY_ESCAN0_SIZE,
+						GFP_KERNEL);
+	if (!wlan_static_nan_event_ring_buf)
+		goto err_mem_alloc;
+
+	pr_err("%s: sectoin %d, size=%d\n", __func__,
+		DHD_PREALLOC_NAN_EVENT_RING, DHD_PREALLOC_WL_ESCAN_INFO_SIZE);
+
+	wlan_static_dhd_wlfc_hanger_buf = kmalloc(
+				DHD_PREALLOC_DHD_WLFC_HANGER_SIZE,
+				GFP_KERNEL);
+	if (!wlan_static_dhd_wlfc_hanger_buf)
+		goto err_mem_alloc;
+
+	pr_err("sectoin %d, size=%d\n", DHD_PREALLOC_DHD_WLFC_HANGER,
+				DHD_PREALLOC_DHD_WLFC_HANGER_SIZE);
+
+
+	wlan_static_if_flow_lkup = kmalloc(DHD_PREALLOC_IF_FLOW_LKUP_SIZE,
+						 GFP_KERNEL);
+	if (!wlan_static_if_flow_lkup)
+		goto err_mem_alloc;
+
+
+
 	return 0;

 err_mem_alloc:
+
+	kfree(wlan_static_prot);
+	kfree(wlan_static_rxbuf);
+	kfree(wlan_static_databuf);
+	kfree(wlan_static_dhd_info_buf);
+	kfree(wlan_static_dhd_wlfc_info_buf);
+	kfree(wlan_static_dhd_wlfc_hanger_buf);
+	kfree(wlan_static_dhd_memdump_ram_buf);
+	kfree(wlan_static_wl_escan_info_buf);
+	kfree(wlan_static_fw_verbose_ring_buf);
+	kfree(wlan_static_fw_event_ring_buf);
+	kfree(wlan_static_dhd_event_ring_buf);
+	kfree(wlan_static_nan_event_ring_buf);
+	kfree(wlan_static_scan_buf1);
+	kfree(wlan_static_scan_buf0);
+	kfree(wlan_static_osl_buf);
+	kfree(wlan_static_if_flow_lkup);
 	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;

@@ -181,10 +429,10 @@ err_skb_alloc:
 	for (j = 0; j < i; j++)
 		dev_kfree_skb(wlan_static_skb[j]);

+
 	return -ENOMEM;
 }
 EXPORT_SYMBOL(bcmdhd_init_wlan_mem);
-#endif /* CONFIG_BROADCOM_WIFI_RESERVED_MEM */
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("AMLOGIC");
 MODULE_DESCRIPTION("wifi device tree driver");