From 80a2e62e8b880439fc9df24df50b4ad41f6e2801 Mon Sep 17 00:00:00 2001 From: Rongjun Chen Date: Mon, 11 Sep 2017 15:49:50 +0800 Subject: [PATCH] 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 --- drivers/amlogic/wifi/dhd_static_buf.c | 434 ++++++++++++++++++++++++++-------- 1 file changed, 341 insertions(+), 93 deletions(-) diff --git a/drivers/amlogic/wifi/dhd_static_buf.c b/drivers/amlogic/wifi/dhd_static_buf.c index 96b3141..2781201 100644 --- a/drivers/amlogic/wifi/dhd_static_buf.c +++ b/drivers/amlogic/wifi/dhd_static_buf.c @@ -26,93 +26,227 @@ #include #include #include +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 -static struct sk_buff *wlan_static_skb[WLAN_SKB_BUF_NUM]; +#define DHD_SKB_1PAGE_BUFSIZE (PAGE_SIZE*1) +#define DHD_SKB_2PAGE_BUFSIZE (PAGE_SIZE*2) +#define DHD_SKB_4PAGE_BUFSIZE (PAGE_SIZE*4) -struct wlan_mem_prealloc { - void *mem_ptr; - unsigned long size; -}; +#define DHD_SKB_1PAGE_BUF_NUM 8 +#define DHD_SKB_2PAGE_BUF_NUM 64 +#define DHD_SKB_4PAGE_BUF_NUM 1 -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)} -}; +/* 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]; + 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 == 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 (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 == 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; } - 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 == 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 < 0) || (section > PREALLOC_WLAN_SEC_NUM)) { - pr_info("5 %s: out of section %d\n", __func__, section); - return NULL; + 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_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; + } - 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; + return wlan_static_dhd_memdump_ram_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_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_mem_array[section].mem_ptr; + 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_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_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_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"); -- 2.7.4