HAL: Add RING_DUMP feature to avoid overrun socket buffer

When dhd_mem_dump() ocrrus, DHD sends bulky data to HAL through netlink socket for debugging.
This sometimes overruns the socket buffer and drops important events.
To avoid this, replace socket event-based communication with memcpy-based(copy_to_user) for vulky data

BUG: 205673231
Test: sanity test passed
Signed-off-by: Dennis Jeon <dennis.jeon@broadcom.corp-partner.google.com>
Change-Id: I3e324ae528752069943cbfaca08c98cf90edddf7

3 files changed, 783 insertions, 3 deletions

diff --git a/bcmdhd/wifi_hal/Android.mk b/bcmdhd/wifi_hal/Android.mk
index 580a730..471c312 100755
--- a/bcmdhd/wifi_hal/Android.mk
+++ b/bcmdhd/wifi_hal/Android.mk
@@ -45,6 +45,8 @@ ifneq ($(wildcard vendor/google/libraries/GoogleWifiConfigLib),)
 LOCAL_SHARED_LIBRARIES += \
 	google_wifi_firmware_config_version_c_wrapper
 LOCAL_CFLAGS += -DGOOGLE_WIFI_FW_CONFIG_VERSION_C_WRAPPER
+#only for pixel feature
+LOCAL_CFLAGS += -DRING_DUMP
 endif
 
 LOCAL_SRC_FILES := \
diff --git a/bcmdhd/wifi_hal/common.h b/bcmdhd/wifi_hal/common.h
index debb279..3cfa78f 100755
--- a/bcmdhd/wifi_hal/common.h
+++ b/bcmdhd/wifi_hal/common.h
@@ -448,6 +448,12 @@ wifi_error wifi_start_hal(wifi_interface_handle iface);
 wifi_error wifi_stop_hal(wifi_interface_handle iface);
 wifi_interface_handle wifi_get_wlan_interface(wifi_handle info,
 	    wifi_interface_handle *ifaceHandles, int numIfaceHandles);
+#ifdef RING_DUMP
+wifi_error wifi_start_ring_dump(wifi_interface_handle iface,
+            wifi_ring_buffer_data_handler ring_handle);
+wifi_error wifi_stop_ring_dump(wifi_interface_handle iface,
+            wifi_ring_buffer_data_handler ring_handle);
+#endif /* RING_DUMP */
 wifi_error wifi_hal_ota_update(wifi_interface_handle iface, uint32_t ota_version);
 wifi_error wifi_hal_preInit(wifi_interface_handle iface);
 /* API to get wake reason statistics */
diff --git a/bcmdhd/wifi_hal/wifi_logger.cpp b/bcmdhd/wifi_hal/wifi_logger.cpp
index 2a06cfb..9ff65bc 100755
--- a/bcmdhd/wifi_hal/wifi_logger.cpp
+++ b/bcmdhd/wifi_hal/wifi_logger.cpp
@@ -72,7 +72,9 @@ typedef enum {
     LOGGER_FILE_DUMP_DONE_IND,
     LOGGER_SET_HAL_START,
     LOGGER_HAL_STOP,
-    LOGGER_SET_HAL_PID
+    LOGGER_SET_HAL_PID,
+    LOGGER_SET_TPUT_DEBUG_DUMP_CMD,
+    LOGGER_GET_BUF_RING_MAP
 } DEBUG_SUB_COMMAND;
 
 #define MAX_NV_FILE 4
@@ -118,6 +120,8 @@ typedef enum {
     LOGGER_ATTRIBUTE_PKT_FATE_NUM		= 17,
     LOGGER_ATTRIBUTE_PKT_FATE_DATA		= 18,
     LOGGER_ATTRIBUTE_HANG_REASON		= 19,
+    LOGGER_ATTRIBUTE_BUF_RING_NUM		= 20,
+    LOGGER_ATTRIBUTE_BUF_RING_MAP		= 21,
     /* Add new attributes just above this */
     LOGGER_ATTRIBUTE_MAX
 } LOGGER_ATTRIBUTE;
@@ -137,6 +141,7 @@ typedef enum {
     GET_RING_STATUS,
     GET_FEATURE,
     START_RING_LOG,
+    GET_BUF_RING_MAP,
 } GetCmdType;
 
 typedef enum {
@@ -189,6 +194,323 @@ typedef enum {
 #define HAL_START_REQUEST_ID 2
 #define HAL_RESTART_ID 3
 #define FILE_NAME_LEN 256
+#define RING_NAME_LEN 32
+#if defined(RING_DUMP)
+/* Loglevel */
+#define DUMP_DEBUG(x)
+#define DUMP_INFO(x) ALOGI x
+#define FILE_DUMP_REQUEST_ID 2
+#define C2S(x)  case x: return #x;
+static const char *EWP_EventAttrToString(int len_attr);
+static const char *EWP_CmdAttrToString(int data_attr);
+
+typedef struct buf_data {
+    u32 ver; /* version of struct */
+    u32 len; /* Total len */
+    /* size of each buffer in case of split buffers (0 - single buffer). */
+    u32 buf_threshold;
+    const void *data_buf[1]; /* array of user space buffer pointers.*/
+} buf_data_t;
+
+/* Attributes associated with GOOGLE_FILE_DUMP_EVENT */
+typedef enum {
+    DUMP_LEN_ATTR_INVALID                       = 0,
+    DUMP_LEN_ATTR_MEMDUMP                       = 1,
+    DUMP_LEN_ATTR_SSSR_C0_BEFORE                = 2,
+    DUMP_LEN_ATTR_SSSR_C0_AFTER                 = 3,
+    DUMP_LEN_ATTR_SSSR_C1_BEFORE                = 4,
+    DUMP_LEN_ATTR_SSSR_C1_AFTER                 = 5,
+    DUMP_LEN_ATTR_SSSR_C2_BEFORE                = 6,
+    DUMP_LEN_ATTR_SSSR_C2_AFTER                 = 7,
+    DUMP_LEN_ATTR_SSSR_DIG_BEFORE               = 8,
+    DUMP_LEN_ATTR_SSSR_DIG_AFTER                = 9,
+    DUMP_LEN_ATTR_TIMESTAMP                     = 10,
+    DUMP_LEN_ATTR_GENERAL_LOG                   = 11,
+    DUMP_LEN_ATTR_ECNTRS                        = 12,
+    DUMP_LEN_ATTR_SPECIAL_LOG                   = 13,
+    DUMP_LEN_ATTR_DHD_DUMP                      = 14,
+    DUMP_LEN_ATTR_EXT_TRAP                      = 15,
+    DUMP_LEN_ATTR_HEALTH_CHK                    = 16,
+    DUMP_LEN_ATTR_PRESERVE_LOG                  = 17,
+    DUMP_LEN_ATTR_COOKIE                        = 18,
+    DUMP_LEN_ATTR_FLOWRING_DUMP                 = 19,
+    DUMP_LEN_ATTR_PKTLOG                        = 20,
+    DUMP_LEN_ATTR_PKTLOG_DEBUG                  = 21,
+    DUMP_FILENAME_ATTR_DEBUG_DUMP               = 22,
+    DUMP_FILENAME_ATTR_MEM_DUMP                 = 23,
+    DUMP_FILENAME_ATTR_SSSR_CORE_0_BEFORE_DUMP  = 24,
+    DUMP_FILENAME_ATTR_SSSR_CORE_0_AFTER_DUMP   = 25,
+    DUMP_FILENAME_ATTR_SSSR_CORE_1_BEFORE_DUMP  = 26,
+    DUMP_FILENAME_ATTR_SSSR_CORE_1_AFTER_DUMP   = 27,
+    DUMP_FILENAME_ATTR_SSSR_CORE_2_BEFORE_DUMP  = 28,
+    DUMP_FILENAME_ATTR_SSSR_CORE_2_AFTER_DUMP   = 29,
+    DUMP_FILENAME_ATTR_SSSR_DIG_BEFORE_DUMP     = 30,
+    DUMP_FILENAME_ATTR_SSSR_DIG_AFTER_DUMP      = 31,
+    DUMP_FILENAME_ATTR_PKTLOG_DUMP              = 32,
+    DUMP_FILENAME_ATTR_PKTLOG_DEBUG_DUMP        = 33,
+    DUMP_LEN_ATTR_STATUS_LOG                    = 34,
+    DUMP_LEN_ATTR_AXI_ERROR                     = 35,
+    DUMP_FILENAME_ATTR_AXI_ERROR_DUMP           = 36,
+    DUMP_LEN_ATTR_RTT_LOG                       = 37,
+    DUMP_LEN_ATTR_SDTC_ETB_DUMP                 = 38,
+    DUMP_FILENAME_ATTR_SDTC_ETB_DUMP            = 39,
+    DUMP_LEN_ATTR_PKTID_MAP_LOG                 = 40,
+    DUMP_LEN_ATTR_PKTID_UNMAP_LOG               = 41,
+    DUMP_LEN_ATTR_EWP_HW_INIT_LOG               = 42,
+    DUMP_LEN_ATTR_EWP_HW_MOD_DUMP               = 43,
+    DUMP_LEN_ATTR_EWP_HW_REG_DUMP               = 44,
+    /*  Please add new attributes from here to sync up old DHD */
+    DUMP_EVENT_ATTR_MAX                         = 45,
+} EWP_DUMP_EVENT_ATTRIBUTE;
+
+/* Attributes associated with DEBUG_GET_DUMP_BUF */
+typedef enum {
+    DUMP_BUF_ATTR_INVALID               = 0,
+    DUMP_BUF_ATTR_MEMDUMP               = 1,
+    DUMP_BUF_ATTR_SSSR_C0_BEFORE        = 2,
+    DUMP_BUF_ATTR_SSSR_C0_AFTER         = 3,
+    DUMP_BUF_ATTR_SSSR_C1_BEFORE        = 4,
+    DUMP_BUF_ATTR_SSSR_C1_AFTER         = 5,
+    DUMP_BUF_ATTR_SSSR_C2_BEFORE        = 6,
+    DUMP_BUF_ATTR_SSSR_C2_AFTER         = 7,
+    DUMP_BUF_ATTR_SSSR_DIG_BEFORE       = 8,
+    DUMP_BUF_ATTR_SSSR_DIG_AFTER        = 9,
+    DUMP_BUF_ATTR_TIMESTAMP             = 10,
+    DUMP_BUF_ATTR_GENERAL_LOG           = 11,
+    DUMP_BUF_ATTR_ECNTRS                = 12,
+    DUMP_BUF_ATTR_SPECIAL_LOG           = 13,
+    DUMP_BUF_ATTR_DHD_DUMP              = 14,
+    DUMP_BUF_ATTR_EXT_TRAP              = 15,
+    DUMP_BUF_ATTR_HEALTH_CHK            = 16,
+    DUMP_BUF_ATTR_PRESERVE_LOG          = 17,
+    DUMP_BUF_ATTR_COOKIE                = 18,
+    DUMP_BUF_ATTR_FLOWRING_DUMP         = 19,
+    DUMP_BUF_ATTR_PKTLOG                = 20,
+    DUMP_BUF_ATTR_PKTLOG_DEBUG          = 21,
+    DUMP_BUF_ATTR_STATUS_LOG            = 22,
+    DUMP_BUF_ATTR_AXI_ERROR             = 23,
+    DUMP_BUF_ATTR_RTT_LOG               = 24,
+    DUMP_BUF_ATTR_SDTC_ETB_DUMP         = 25,
+    DUMP_BUF_ATTR_PKTID_MAP_LOG         = 26,
+    DUMP_BUF_ATTR_PKTID_UNMAP_LOG       = 27,
+    DUMP_BUF_ATTR_EWP_HW_INIT_LOG       = 28,
+    DUMP_BUF_ATTR_EWP_HW_MOD_DUMP       = 29,
+    DUMP_BUF_ATTR_EWP_HW_REG_DUMP       = 30,
+    /*  Please add new attributes from here to sync up old DHD */
+    DUMP_BUF_ATTR_MAX		        = 31,
+} EWP_DUMP_CMD_ATTRIBUTE;
+
+typedef enum {
+    DUMP_TYPE_MEM_DUMP                  = 0,
+    DUMP_TYPE_DEBUG_DUMP                = 1,
+    DUMP_TYPE_SSSR_CORE0_BEF_DUMP       = 2,
+    DUMP_TYPE_SSSR_CORE0_AFT_DUMP       = 3,
+    DUMP_TYPE_SSSR_CORE1_BEF_DUMP       = 4,
+    DUMP_TYPE_SSSR_CORE1_AFT_DUMP       = 5,
+    DUMP_TYPE_SSSR_CORE2_BEF_DUMP       = 6,
+    DUMP_TYPE_SSSR_CORE2_AFT_DUMP       = 7,
+    DUMP_TYPE_SSSR_DIG_BEF_DUMP         = 8,
+    DUMP_TYPE_SSSR_DIG_AFT_DUMP         = 9,
+    DUMP_TYPE_PKTLOG_DUMP               = 10,
+    DUMP_TYPE_PKTLOG_DEBUG_DUMP         = 11,
+    DUMP_TYPE_AXI_ERROR_DUMP            = 12,
+    DUMP_TYPE_D2H_MINI_DUMP             = 13,
+    DUMP_TYPE_SDTC_ETB_DUMP             = 14,
+    /*  Please add new attributes from here to sync up old DHD */
+    DUMP_TYPE_MAX                       = 15,
+} EWP_DUMP_TYPE;
+
+/* Struct for table which has len_attr, data_attr and dump file type attr */
+typedef struct logger_attr_entry {
+    u8 attr_type; /* Type of attribute */
+    u8 buf_attr; /* Buffer associated with the attribute */
+    u8 dump_type; /* Each attribute will be linked to a dump type */
+} logger_attr_entry_t;
+
+logger_attr_entry_t attr_lookup_tbl[] = {
+    /* Mem Dump Block */
+    {DUMP_FILENAME_ATTR_MEM_DUMP, 0, DUMP_TYPE_MEM_DUMP},
+    {DUMP_LEN_ATTR_MEMDUMP, DUMP_BUF_ATTR_MEMDUMP, DUMP_TYPE_MEM_DUMP},
+    /* SSSR Dump Block */
+    {DUMP_FILENAME_ATTR_SSSR_CORE_0_BEFORE_DUMP, 0, DUMP_TYPE_SSSR_CORE0_BEF_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C0_BEFORE, DUMP_BUF_ATTR_SSSR_C0_BEFORE, DUMP_TYPE_SSSR_CORE0_BEF_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_CORE_0_AFTER_DUMP, 0, DUMP_TYPE_SSSR_CORE0_AFT_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C0_AFTER, DUMP_BUF_ATTR_SSSR_C0_AFTER, DUMP_TYPE_SSSR_CORE0_AFT_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_CORE_1_BEFORE_DUMP, 0, DUMP_TYPE_SSSR_CORE1_BEF_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C1_BEFORE, DUMP_BUF_ATTR_SSSR_C1_BEFORE, DUMP_TYPE_SSSR_CORE1_BEF_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_CORE_1_AFTER_DUMP, 0, DUMP_TYPE_SSSR_CORE1_AFT_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C1_AFTER, DUMP_BUF_ATTR_SSSR_C1_AFTER, DUMP_TYPE_SSSR_CORE1_AFT_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_CORE_2_BEFORE_DUMP, 0, DUMP_TYPE_SSSR_CORE2_BEF_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C2_BEFORE, DUMP_BUF_ATTR_SSSR_C2_BEFORE, DUMP_TYPE_SSSR_CORE2_BEF_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_CORE_2_AFTER_DUMP, 0, DUMP_TYPE_SSSR_CORE2_AFT_DUMP},
+    {DUMP_LEN_ATTR_SSSR_C2_AFTER, DUMP_BUF_ATTR_SSSR_C2_AFTER, DUMP_TYPE_SSSR_CORE2_AFT_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_DIG_BEFORE_DUMP, 0, DUMP_TYPE_SSSR_DIG_BEF_DUMP},
+    {DUMP_LEN_ATTR_SSSR_DIG_BEFORE, DUMP_BUF_ATTR_SSSR_DIG_BEFORE, DUMP_TYPE_SSSR_DIG_BEF_DUMP},
+
+    {DUMP_FILENAME_ATTR_SSSR_DIG_AFTER_DUMP, 0, DUMP_TYPE_SSSR_DIG_AFT_DUMP},
+    {DUMP_LEN_ATTR_SSSR_DIG_AFTER, DUMP_BUF_ATTR_SSSR_DIG_AFTER, DUMP_TYPE_SSSR_DIG_AFT_DUMP},
+
+    /* Debug Dump Block */
+    {DUMP_FILENAME_ATTR_DEBUG_DUMP, 0, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_TIMESTAMP, DUMP_BUF_ATTR_TIMESTAMP, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_GENERAL_LOG, DUMP_BUF_ATTR_GENERAL_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_ECNTRS, DUMP_BUF_ATTR_ECNTRS, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_SPECIAL_LOG, DUMP_BUF_ATTR_SPECIAL_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_DHD_DUMP, DUMP_BUF_ATTR_DHD_DUMP, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_EXT_TRAP, DUMP_BUF_ATTR_EXT_TRAP, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_HEALTH_CHK, DUMP_BUF_ATTR_HEALTH_CHK, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_PRESERVE_LOG, DUMP_BUF_ATTR_PRESERVE_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_COOKIE, DUMP_BUF_ATTR_COOKIE, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_FLOWRING_DUMP, DUMP_BUF_ATTR_FLOWRING_DUMP, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_STATUS_LOG, DUMP_BUF_ATTR_STATUS_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_RTT_LOG, DUMP_BUF_ATTR_RTT_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_PKTID_MAP_LOG, DUMP_BUF_ATTR_PKTID_MAP_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_PKTID_UNMAP_LOG, DUMP_BUF_ATTR_PKTID_UNMAP_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_EWP_HW_INIT_LOG, DUMP_BUF_ATTR_EWP_HW_INIT_LOG, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_EWP_HW_MOD_DUMP, DUMP_BUF_ATTR_EWP_HW_MOD_DUMP, DUMP_TYPE_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_EWP_HW_REG_DUMP, DUMP_BUF_ATTR_EWP_HW_REG_DUMP, DUMP_TYPE_DEBUG_DUMP},
+
+    /* PKT log dump block */
+    {DUMP_FILENAME_ATTR_PKTLOG_DUMP, 0, DUMP_TYPE_PKTLOG_DUMP},
+    {DUMP_LEN_ATTR_PKTLOG, DUMP_BUF_ATTR_PKTLOG, DUMP_TYPE_PKTLOG_DUMP},
+    {DUMP_FILENAME_ATTR_PKTLOG_DEBUG_DUMP, 0, DUMP_TYPE_PKTLOG_DEBUG_DUMP},
+    {DUMP_LEN_ATTR_PKTLOG_DEBUG, DUMP_BUF_ATTR_PKTLOG_DEBUG, DUMP_TYPE_PKTLOG_DEBUG_DUMP},
+    /* AXI error log dump block */
+    {DUMP_FILENAME_ATTR_AXI_ERROR_DUMP, 0, DUMP_TYPE_AXI_ERROR_DUMP},
+    {DUMP_LEN_ATTR_AXI_ERROR, DUMP_BUF_ATTR_AXI_ERROR, DUMP_TYPE_AXI_ERROR_DUMP},
+    /* SDTC etb log dump block */
+    {DUMP_FILENAME_ATTR_SDTC_ETB_DUMP, 0, DUMP_TYPE_SDTC_ETB_DUMP},
+    {DUMP_LEN_ATTR_SDTC_ETB_DUMP, DUMP_BUF_ATTR_SDTC_ETB_DUMP, DUMP_TYPE_SDTC_ETB_DUMP},
+    {DUMP_EVENT_ATTR_MAX, 0, 0},
+};
+
+static const char *EWP_EventAttrToString(int len_attr)
+{
+    switch (len_attr) {
+        C2S(DUMP_LEN_ATTR_MEMDUMP)
+        C2S(DUMP_LEN_ATTR_SSSR_C0_BEFORE)
+        C2S(DUMP_LEN_ATTR_SSSR_C0_AFTER)
+        C2S(DUMP_LEN_ATTR_SSSR_C1_BEFORE)
+        C2S(DUMP_LEN_ATTR_SSSR_C1_AFTER)
+        C2S(DUMP_LEN_ATTR_SSSR_C2_BEFORE)
+        C2S(DUMP_LEN_ATTR_SSSR_C2_AFTER)
+        C2S(DUMP_LEN_ATTR_SSSR_DIG_BEFORE)
+        C2S(DUMP_LEN_ATTR_SSSR_DIG_AFTER)
+        C2S(DUMP_LEN_ATTR_TIMESTAMP)
+        C2S(DUMP_LEN_ATTR_GENERAL_LOG)
+        C2S(DUMP_LEN_ATTR_ECNTRS)
+        C2S(DUMP_LEN_ATTR_SPECIAL_LOG)
+        C2S(DUMP_LEN_ATTR_DHD_DUMP)
+        C2S(DUMP_LEN_ATTR_EXT_TRAP)
+        C2S(DUMP_LEN_ATTR_HEALTH_CHK)
+        C2S(DUMP_LEN_ATTR_PRESERVE_LOG)
+        C2S(DUMP_LEN_ATTR_COOKIE)
+        C2S(DUMP_LEN_ATTR_FLOWRING_DUMP)
+        C2S(DUMP_LEN_ATTR_PKTLOG)
+        C2S(DUMP_LEN_ATTR_PKTLOG_DEBUG)
+        C2S(DUMP_LEN_ATTR_STATUS_LOG)
+        C2S(DUMP_FILENAME_ATTR_DEBUG_DUMP)
+        C2S(DUMP_FILENAME_ATTR_MEM_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_0_BEFORE_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_0_AFTER_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_1_BEFORE_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_1_AFTER_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_2_BEFORE_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_CORE_2_AFTER_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_DIG_BEFORE_DUMP)
+        C2S(DUMP_FILENAME_ATTR_SSSR_DIG_AFTER_DUMP)
+        C2S(DUMP_FILENAME_ATTR_PKTLOG_DUMP)
+        C2S(DUMP_FILENAME_ATTR_PKTLOG_DEBUG_DUMP)
+        C2S(DUMP_LEN_ATTR_AXI_ERROR)
+        C2S(DUMP_FILENAME_ATTR_AXI_ERROR_DUMP)
+        C2S(DUMP_LEN_ATTR_RTT_LOG)
+        C2S(DUMP_FILENAME_ATTR_SDTC_ETB_DUMP)
+        C2S(DUMP_LEN_ATTR_SDTC_ETB_DUMP)
+        C2S(DUMP_LEN_ATTR_PKTID_MAP_LOG)
+        C2S(DUMP_LEN_ATTR_PKTID_UNMAP_LOG)
+        C2S(DUMP_LEN_ATTR_EWP_HW_INIT_LOG)
+        C2S(DUMP_LEN_ATTR_EWP_HW_MOD_DUMP)
+        C2S(DUMP_LEN_ATTR_EWP_HW_REG_DUMP)
+        default:
+            return "DUMP_LEN_ATTR_INVALID";
+    }
+}
+
+static const char *EWP_CmdAttrToString(int attr)
+{
+    switch (attr) {
+        C2S(DUMP_BUF_ATTR_MEMDUMP)
+        C2S(DUMP_BUF_ATTR_SSSR_C0_BEFORE)
+        C2S(DUMP_BUF_ATTR_SSSR_C0_AFTER)
+        C2S(DUMP_BUF_ATTR_SSSR_C1_BEFORE)
+        C2S(DUMP_BUF_ATTR_SSSR_C1_AFTER)
+        C2S(DUMP_BUF_ATTR_SSSR_C2_BEFORE)
+        C2S(DUMP_BUF_ATTR_SSSR_C2_AFTER)
+        C2S(DUMP_BUF_ATTR_SSSR_DIG_BEFORE)
+        C2S(DUMP_BUF_ATTR_SSSR_DIG_AFTER)
+        C2S(DUMP_BUF_ATTR_TIMESTAMP)
+        C2S(DUMP_BUF_ATTR_GENERAL_LOG)
+        C2S(DUMP_BUF_ATTR_ECNTRS)
+        C2S(DUMP_BUF_ATTR_SPECIAL_LOG)
+        C2S(DUMP_BUF_ATTR_DHD_DUMP)
+        C2S(DUMP_BUF_ATTR_EXT_TRAP)
+        C2S(DUMP_BUF_ATTR_HEALTH_CHK)
+        C2S(DUMP_BUF_ATTR_PRESERVE_LOG)
+        C2S(DUMP_BUF_ATTR_COOKIE)
+        C2S(DUMP_BUF_ATTR_FLOWRING_DUMP)
+        C2S(DUMP_BUF_ATTR_PKTLOG)
+        C2S(DUMP_BUF_ATTR_PKTLOG_DEBUG)
+        C2S(DUMP_BUF_ATTR_STATUS_LOG)
+        C2S(DUMP_BUF_ATTR_AXI_ERROR)
+        C2S(DUMP_BUF_ATTR_RTT_LOG)
+        C2S(DUMP_BUF_ATTR_SDTC_ETB_DUMP)
+        C2S(DUMP_BUF_ATTR_PKTID_MAP_LOG)
+        C2S(DUMP_BUF_ATTR_PKTID_UNMAP_LOG)
+        C2S(DUMP_BUF_ATTR_EWP_HW_INIT_LOG)
+        C2S(DUMP_BUF_ATTR_EWP_HW_MOD_DUMP)
+        C2S(DUMP_BUF_ATTR_EWP_HW_REG_DUMP)
+        default:
+            return "DUMP_BUF_ATTR_INVALID";
+    }
+}
+
+/* Return index for matching buffer attribute */
+static int logger_attr_buffer_lookup(u8 attr) {
+    for (u8 i = 0; i < ARRAYSIZE(attr_lookup_tbl); i++) {
+        if (attr == attr_lookup_tbl[i].buf_attr) {
+            return i;
+        }
+    }
+    ALOGE("Lookup for buf attr = %s failed\n",
+    EWP_CmdAttrToString(attr));
+    return -1;
+}
+
+/* Return index matching the length attribute */
+static int logger_attr_lookup(u8 attr) {
+    for (u8 i = 0; i < ARRAYSIZE(attr_lookup_tbl); i++) {
+        if (attr == attr_lookup_tbl[i].attr_type) {
+            return i;
+        }
+    }
+    ALOGE("Lookup for len attr = %s failed\n",
+        EWP_EventAttrToString(attr));
+    return -1;
+}
+#endif /* RING_DUMP */
+
+#define DBGRING_NAME_MAX 32  //Copy from legacy hal
+typedef struct wifi_buf_ring_map_entry {
+    uint32_t type;
+    uint32_t ring_id;
+    char ring_name[DBGRING_NAME_MAX];
+} wifi_buf_ring_map_entry_t;
 
 typedef struct {
     char hw_id[PROPERTY_VALUE_MAX];
@@ -217,6 +539,8 @@ class DebugCommand : public WifiCommand
     int *mBuffSize;
     u32 *mNumRings;
     wifi_ring_buffer_status *mStatus;
+    u32 *mNumMaps;
+    wifi_buf_ring_map_entry_t *mMaps;
     unsigned int *mSupport;
     u32 mVerboseLevel;
     u32 mFlags;
@@ -290,6 +614,14 @@ public:
         mRingName = NULL;
     }
 
+    // constructor for buf ring map
+    DebugCommand(wifi_interface_handle iface, u32 *num_maps,
+            wifi_buf_ring_map_entry_t *map, GetCmdType cmdType)
+        : WifiCommand("DebugCommand", iface, 0), mNumMaps(num_maps), mMaps(map), mType(cmdType)
+    {
+        memset(mMaps, 0, sizeof(wifi_buf_ring_map_entry_t) * (*mNumMaps));
+    }
+
     // constructor for ring params
     DebugCommand(wifi_interface_handle iface, u32 verbose_level, u32 flags,
             u32 max_interval_sec, u32 min_data_size, char *ring_name, GetCmdType cmdType)
@@ -428,6 +760,16 @@ public:
                 break;
             }
 
+            case GET_BUF_RING_MAP:
+            {
+                result = request.create(GOOGLE_OUI, LOGGER_GET_BUF_RING_MAP);
+                if (result != WIFI_SUCCESS) {
+                    ALOGE("Failed to create get ring status request; result = %d", result);
+                    return result;
+                }
+                break;
+            }
+
             case START_RING_LOG:
                 result = createRingRequest(request);
                 break;
@@ -538,6 +880,52 @@ public:
                 break;
             }
 
+            case GET_BUF_RING_MAP:
+            {
+                nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+                int len = reply.get_vendor_data_len();
+                wifi_buf_ring_map_entry_t *map(mMaps);
+
+                if (vendor_data == NULL || len == 0) {
+                    ALOGE("No Debug data found");
+                    return NL_SKIP;
+                }
+
+                nl_iterator it(vendor_data);
+                if (it.get_type() == LOGGER_ATTRIBUTE_BUF_RING_NUM) {
+                    unsigned int num_maps = it.get_u32();
+                    if (*mNumMaps < num_maps) {
+                        ALOGE("Not enough status buffers provided, available: %d required: %d",
+                            *mNumMaps, num_maps);
+                    } else {
+                        *mNumMaps = num_maps;
+                    }
+                } else {
+                    ALOGE("Unknown attribute: %d expecting %d",
+                        it.get_type(), LOGGER_ATTRIBUTE_BUF_RING_NUM);
+                    return NL_SKIP;
+                }
+
+                it.next();
+                for (unsigned int i = 0; it.has_next() && i < *mNumMaps; it.next()) {
+                    if (it.get_type() == LOGGER_ATTRIBUTE_BUF_RING_MAP) {
+                        if (it.get_len() > sizeof(wifi_buf_ring_map_entry_t)) {
+                            ALOGE("GET_BUF_RING_MAP: unexpected len = %d, dest len = %lu",
+                                it.get_len(), sizeof(wifi_buf_ring_map_entry_t));
+                            return NL_SKIP;
+                        } else {
+                            memcpy(map, it.get_data(), sizeof(wifi_buf_ring_map_entry_t));
+                        }
+                        i++;
+                        map++;
+                    } else {
+                        ALOGW("Ignoring invalid attribute type = %d, size = %d",
+                            it.get_type(), it.get_len());
+                    }
+                }
+                break;
+            }
+
             default:
                 ALOGW("Unknown Debug command");
         }
@@ -627,6 +1015,8 @@ wifi_error wifi_start_logging(wifi_interface_handle iface, u32 verbose_level,
         u32 flags, u32 max_interval_sec, u32 min_data_size, char *ring_name)
 {
     if (ring_name) {
+        ALOGE("Ring name: level:%d sec:%d ring_name:%s",
+                verbose_level, max_interval_sec, ring_name);
         DebugCommand *cmd = new DebugCommand(iface, verbose_level, flags, max_interval_sec,
                     min_data_size, ring_name, START_RING_LOG);
         NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
@@ -775,7 +1165,7 @@ wifi_error wifi_set_log_handler(wifi_request_id id, wifi_interface_handle iface,
         wifi_ring_buffer_data_handler handler)
 {
     wifi_handle handle = getWifiHandle(iface);
-    ALOGV("Loghandler start, handle = %p", handle);
+    ALOGE("Loghandler start, handle = %p", handle);
 
     SetLogHandler *cmd = new SetLogHandler(iface, id, handler);
     NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
@@ -790,13 +1180,17 @@ wifi_error wifi_set_log_handler(wifi_request_id id, wifi_interface_handle iface,
         cmd->releaseRef();
         return result;
     }
+
+#ifdef RING_DUMP
+    wifi_start_ring_dump(iface, handler);
+#endif /* RING_DUMP */
     return result;
 }
 
 wifi_error wifi_reset_log_handler(wifi_request_id id, wifi_interface_handle iface)
 {
     wifi_handle handle = getWifiHandle(iface);
-    ALOGV("Loghandler reset, wifi_request_id = %d, handle = %p", id, handle);
+    ALOGE("Loghandler reset, wifi_request_id = %d, handle = %p", id, handle);
 
     if (id == -1) {
         wifi_ring_buffer_data_handler handler;
@@ -806,6 +1200,10 @@ wifi_error wifi_reset_log_handler(wifi_request_id id, wifi_interface_handle ifac
         NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
         cmd->cancel();
         cmd->releaseRef();
+
+#ifdef RING_DUMP
+        wifi_stop_ring_dump(iface, handler);
+#endif /* RING_DUMP */
         return WIFI_SUCCESS;
     }
 
@@ -1171,6 +1569,334 @@ class HalInit : public WifiCommand
     }
 };
 
+#ifdef RING_DUMP
+///////////////////////////////////////////////////////////////////////////////
+class RingDump : public WifiCommand
+{
+    int mLargestBuffSize;
+    char *mBuff;
+    int mErrCode;
+    int mNumMaps;
+    wifi_buf_ring_map_entry_t *mMap;
+    int attr_type_len[DUMP_EVENT_ATTR_MAX];
+    char *ring_name[DUMP_BUF_ATTR_MAX];
+    wifi_ring_buffer_data_handler mHandle;
+
+public:
+    RingDump(wifi_interface_handle iface, int id, int num_maps, wifi_buf_ring_map_entry_t *map,
+        wifi_ring_buffer_data_handler ring_handle)
+        : WifiCommand("RingDump", iface, id), mLargestBuffSize(0), mBuff(NULL),
+        mErrCode(0), mNumMaps(num_maps), mMap(map), mHandle(ring_handle)
+    {
+        memset(attr_type_len, 0, sizeof(attr_type_len));
+        for (int i = 0; i < DUMP_BUF_ATTR_MAX; i++) {
+            ring_name[i] = NULL;
+        }
+    }
+    RingDump(wifi_interface_handle iface, int id)
+        : WifiCommand("RingDump", iface, id), mLargestBuffSize(0), mBuff(NULL),
+        mErrCode(0)
+    {
+    }
+
+    int start() {
+        DUMP_INFO(("Start Ring Dump Map_cnt:%d\n", mNumMaps));
+        registerVendorHandler(GOOGLE_OUI, GOOGLE_FILE_DUMP_EVENT);
+
+        //Set ringname to buf hashmap
+        for (int i = 0; i < mNumMaps; i++) {
+            int type = mMap[i].type;
+            ring_name[type] = (char *)malloc(DBGRING_NAME_MAX);
+            memset(ring_name[type], 0, DBGRING_NAME_MAX);
+            memcpy(ring_name[type], mMap[i].ring_name, strlen(mMap[i].ring_name));
+            DUMP_DEBUG(("Set ringname Buf:%s Ringname:%s len:%lu",
+                EWP_CmdAttrToString(type), ring_name[type], strlen(mMap[i].ring_name)));
+        }
+        return WIFI_SUCCESS;
+    }
+
+    virtual int freeup() {
+        DUMP_DEBUG(("freeup:Enter\n"));
+        if (mBuff) {
+            free(mBuff);
+            mBuff = NULL;
+            DUMP_INFO(("freed allocated memory\n"));
+        }
+        return WIFI_SUCCESS;
+    }
+
+    virtual int cancel() {
+        /* unregister file dump handler */
+        unregisterVendorHandler(GOOGLE_OUI, GOOGLE_FILE_DUMP_EVENT);
+        wifi_unregister_cmd(wifiHandle(), id());
+
+        /* Free up the ring names allocated */
+        for (u8 i = 0; i < DUMP_BUF_ATTR_MAX; i++) {
+            if (ring_name[i]) {
+                free(ring_name[i]);
+                ring_name[i] = NULL;
+            }
+        }
+        if (mBuff) {
+            free(mBuff);
+        }
+
+        DUMP_INFO(("Stop Ring Dump Successfully Completed, mErrCode = %d\n", mErrCode));
+        return WIFI_SUCCESS;
+    }
+
+    virtual int handleResponse(WifiEvent& reply) {
+        DUMP_DEBUG(("RingDump::handleResponse\n"));
+        int buf_attr = DUMP_BUF_ATTR_INVALID;
+        int len_attr = DUMP_LEN_ATTR_INVALID;
+        int index = -1;
+
+        if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+            ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+            return NL_SKIP;
+        }
+
+        nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+        int len = reply.get_vendor_data_len();
+
+        if (vendor_data == NULL || len == 0) {
+            ALOGE("no vendor data in memory dump response; ignoring it");
+            return NL_SKIP;
+        }
+
+        for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
+            buf_attr = it.get_type();
+            switch (buf_attr) {
+                case DUMP_BUF_ATTR_MEMDUMP:
+                case DUMP_BUF_ATTR_TIMESTAMP:
+                case DUMP_BUF_ATTR_ECNTRS:
+                case DUMP_BUF_ATTR_DHD_DUMP:
+                case DUMP_BUF_ATTR_EXT_TRAP:
+                case DUMP_BUF_ATTR_HEALTH_CHK:
+                case DUMP_BUF_ATTR_COOKIE:
+                case DUMP_BUF_ATTR_FLOWRING_DUMP:
+                case DUMP_BUF_ATTR_STATUS_LOG:
+                case DUMP_BUF_ATTR_RTT_LOG: {
+                    if (it.get_u32()) {
+                        ALOGE("Copying data to userspace failed, status = %d\n", it.get_u32());
+                        return WIFI_ERROR_UNKNOWN;
+                    }
+                    index = logger_attr_buffer_lookup(buf_attr);
+                    if (index == -1) {
+                        ALOGE("Invalid index. buf attr = %s\n", EWP_CmdAttrToString(buf_attr));
+                        return WIFI_ERROR_UNKNOWN;
+                    }
+                    len_attr = attr_lookup_tbl[index].attr_type;
+                    if (len_attr == DUMP_EVENT_ATTR_MAX) {
+                        ALOGE("Invalid len attr = %s\n", EWP_EventAttrToString(len_attr));
+                        return WIFI_ERROR_UNKNOWN;
+                    }
+                    if (!mBuff || attr_type_len[len_attr] <= 0) {
+                        return WIFI_ERROR_UNKNOWN;
+                    }
+
+                    if (!ring_name[buf_attr]) {
+                        ALOGE("Not allocated buf attr = %s\n", EWP_CmdAttrToString(buf_attr));
+                        return WIFI_ERROR_UNKNOWN;
+                    }
+                    DUMP_INFO(("RingDump:: buf_attr:%s size = %d ring_name:%s\n",
+                        EWP_CmdAttrToString(buf_attr), attr_type_len[len_attr],
+                        ring_name[buf_attr]));
+                    if (mHandle.on_ring_buffer_data) {
+                        /* on_ring_buffer_data callback requires status memory
+                         * so should pass status memory */
+                        wifi_ring_buffer_status status;
+                        memset(&status, 0, sizeof(status));
+                        /* Skip msg header. Retrieved log */
+                        (*mHandle.on_ring_buffer_data)(ring_name[buf_attr], mBuff,
+                            attr_type_len[len_attr], &status);
+                    }
+                    if (mBuff) {
+                        memset(mBuff, 0, mLargestBuffSize);
+                    }
+                    break;
+                }
+                default: {
+                    DUMP_DEBUG(("Ignoring invalid attribute buf_attr = %d, size = %d",
+                        buf_attr, it.get_len()));
+                    break;
+                }
+            }
+        }
+        return NL_OK;
+    }
+
+    virtual int request_logger_dump(WifiRequest& request,
+            buf_data_t *buf, int len_attr) {
+
+        int result = 0;
+        int buf_attr = DUMP_BUF_ATTR_INVALID;
+        int index = -1;
+        nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+
+        index = logger_attr_lookup(len_attr);
+        if (index == -1) {
+            ALOGE("Invalid index\n");
+            return WIFI_ERROR_UNKNOWN;
+        }
+        buf_attr = attr_lookup_tbl[index].buf_attr;
+
+        if (buf_attr != DUMP_BUF_ATTR_INVALID) {
+            result = request.put(buf_attr, buf, sizeof(buf_data_t));
+            if (result != WIFI_SUCCESS) {
+                ALOGE("Failed to put get memory dump request; result = %d", result);
+                return result;
+            }
+        } else {
+            ALOGE("Invalid buf attr = %s, index = %d\n",
+                EWP_CmdAttrToString(buf_attr), index);
+            return WIFI_ERROR_UNKNOWN;
+        }
+        DUMP_INFO(("Trigger get dump for buf attr = %s\n",
+                EWP_CmdAttrToString(buf_attr)));
+
+        request.attr_end(data);
+        return result;
+    }
+
+    virtual int handleEvent(WifiEvent& event) {
+        mLargestBuffSize = 0;
+        mBuff = NULL;
+        memset(attr_type_len, 0, sizeof(attr_type_len));
+        u8 i = 0;
+        int result = 0;
+        int mActualBuffSize = 0;
+        int index = -1;
+
+        nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
+        int len = event.get_vendor_data_len();
+        int event_id = event.get_vendor_subcmd();
+        int req_attr_cnt = 0;
+        int req_attr[DUMP_EVENT_ATTR_MAX];
+        int buf_attr = DUMP_BUF_ATTR_INVALID;
+
+        if (vendor_data == NULL || len == 0) {
+            ALOGE("No Debug data found");
+            return NL_SKIP;
+        }
+        DUMP_INFO(("Ring Dump handler. Got event: %d", event_id));
+
+        buf_data_t buf;
+
+        memset(&buf, 0, sizeof(buf_data_t));
+        buf.ver = 0;
+        buf.buf_threshold = 0;
+
+        if (event_id == GOOGLE_FILE_DUMP_EVENT) {
+            for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
+                int attr = it.get_type();
+                switch (attr) {
+                    case DUMP_LEN_ATTR_MEMDUMP:
+                    case DUMP_LEN_ATTR_TIMESTAMP:
+                    case DUMP_LEN_ATTR_ECNTRS:
+                    case DUMP_LEN_ATTR_DHD_DUMP:
+                    case DUMP_LEN_ATTR_EXT_TRAP:
+                    case DUMP_LEN_ATTR_HEALTH_CHK:
+                    case DUMP_LEN_ATTR_COOKIE:
+                    case DUMP_LEN_ATTR_FLOWRING_DUMP:
+                    case DUMP_LEN_ATTR_STATUS_LOG:
+                    case DUMP_LEN_ATTR_RTT_LOG: {
+                        mActualBuffSize = it.get_u32();
+                        DUMP_DEBUG(("len attr %s, len %d\n",
+                            EWP_EventAttrToString(attr), mActualBuffSize));
+                        if (mActualBuffSize > mLargestBuffSize)
+                            mLargestBuffSize = mActualBuffSize;
+                            attr_type_len[attr] = mActualBuffSize;
+
+                            /* Store the order in which attributes are received
+                             * so that file dump can be done in the same order
+                             */
+                            req_attr[req_attr_cnt++] = attr;
+                            break;
+                    }
+                    default: {
+                        ALOGE("Ignoring invalid attribute type = %d, size = %d",
+                            attr, it.get_len());
+                            break;
+                        }
+                }
+            }
+            /* Allocation for the largest buffer size to use it recursively for other buf attr. */
+            if (mLargestBuffSize) {
+                DUMP_INFO(("Max dump size: %d", mLargestBuffSize));
+                mBuff = (char *)malloc(mLargestBuffSize);
+                if (!mBuff) {
+                    ALOGE("Buffer allocation failed");
+                    return NL_SKIP;
+                }
+                memset(mBuff, 0, mLargestBuffSize);
+            }
+
+            WifiRequest request(familyId(), ifaceId());
+            result = request.create(GOOGLE_OUI, LOGGER_DEBUG_GET_DUMP);
+            if (result != WIFI_SUCCESS) {
+                ALOGE("Failed to create get memory dump request; result = %d", result);
+                freeup();
+                goto exit;
+            }
+
+            /* Requesting logger dump for each received attr */
+            for (i = 0; i < req_attr_cnt; i++) {
+                int attr = req_attr[i];
+
+                if (attr_type_len[attr] == 0) {
+                    continue;
+                }
+
+                index = logger_attr_lookup(attr);
+                buf_attr = attr_lookup_tbl[index].buf_attr;
+                if (!ring_name[buf_attr]) {
+                    ALOGE("Failed to find ringname index:%d buf_attr:%d", index, buf_attr);
+                    continue;
+                }
+
+                buf.len = attr_type_len[attr];
+                buf.data_buf[0] = mBuff;
+                DUMP_DEBUG(("buf len = %d, buf ptr= %p for attr = %s\n",
+                    buf.len, buf.data_buf[0], EWP_EventAttrToString(attr)));
+                result = request_logger_dump(request, &buf, attr);
+                if (result != WIFI_SUCCESS) {
+                    /* Proceeding further for other attributes */
+                    ALOGE("Failed to request the logger dump for attr = %s; result = %d",
+                        EWP_EventAttrToString(attr), result);
+                    continue;
+                }
+                result = requestResponse(request);
+                if (result != WIFI_SUCCESS) {
+                    ALOGE("Failed to register get memory dump response for attr = %s; result = %d",
+                        EWP_EventAttrToString(attr), result);
+                        /* Proceeding further for other attributes */
+                        continue;
+                }
+            }
+
+            WifiRequest request2(familyId(), ifaceId());
+            result = request2.create(GOOGLE_OUI, LOGGER_FILE_DUMP_DONE_IND);
+            if (result != WIFI_SUCCESS) {
+                ALOGE("Failed to trigger dev close; result = %d", result);
+                freeup();
+                goto exit;
+            }
+            requestResponse(request2);
+            freeup();
+        } else {
+            ALOGE("dump event missing dump length attribute");
+            return NL_SKIP;
+        }
+    exit:
+        if (result != WIFI_SUCCESS) {
+            return NL_SKIP;
+        }
+        return NL_OK;
+    }
+};
+///////////////////////////////////////////////////////////////////////////////
+#endif /* RING_DUMP */
 
 wifi_error wifi_start_hal(wifi_interface_handle iface)
 {
@@ -1214,6 +1940,52 @@ wifi_error wifi_hal_preInit(wifi_interface_handle iface)
     return result;
 }
 
+#ifdef RING_DUMP
+wifi_error wifi_start_ring_dump(wifi_interface_handle iface,
+    wifi_ring_buffer_data_handler ring_handle)
+{
+    wifi_handle handle = getWifiHandle(iface);
+    DUMP_INFO(("start ring dump, handle = %p", handle));
+    wifi_buf_ring_map_entry_t map[DUMP_BUF_ATTR_MAX];
+    unsigned int num_maps = DUMP_BUF_ATTR_MAX;
+    wifi_error result;
+
+    /* Get mapping table from driver */
+    DebugCommand *debug_cmd = new DebugCommand(iface, &num_maps, map, GET_BUF_RING_MAP);
+    NULL_CHECK_RETURN(debug_cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+    result = (wifi_error)debug_cmd->start();
+    debug_cmd->releaseRef();
+
+    /* Set ringname to corresponding buf attr */
+    RingDump *cmd = new RingDump(iface, FILE_DUMP_REQUEST_ID, num_maps, map, ring_handle);
+    NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+    result = wifi_register_cmd(handle, FILE_DUMP_REQUEST_ID, cmd);
+    if (result != WIFI_SUCCESS) {
+        cmd->releaseRef();
+        return result;
+    }
+
+    result = (wifi_error)cmd->start();
+    if (result != WIFI_SUCCESS) {
+        wifi_unregister_cmd(handle, FILE_DUMP_REQUEST_ID);
+        cmd->releaseRef();
+        return result;
+    }
+    return result;
+}
+
+wifi_error wifi_stop_ring_dump(wifi_interface_handle iface,
+    wifi_ring_buffer_data_handler ring_handle)
+{
+    RingDump *cmd = new RingDump(iface, FILE_DUMP_REQUEST_ID);
+    NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+    DUMP_INFO(("stop ring dump"));
+    cmd->cancel();
+    cmd->releaseRef();
+    return WIFI_SUCCESS;
+}
+#endif /* RING_DUMP */
+
 wifi_error wifi_stop_hal(wifi_interface_handle iface)
 {
     HalInit *cmd = new HalInit(iface, HAL_START_REQUEST_ID);