diff --git a/bcmdhd/wifi_hal/common.h b/bcmdhd/wifi_hal/common.h
index f1a541f..4c7973b 100755
--- a/bcmdhd/wifi_hal/common.h
+++ b/bcmdhd/wifi_hal/common.h
@@ -460,8 +460,7 @@
 #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);
+wifi_error wifi_stop_ring_dump(wifi_interface_handle iface);
 #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);
diff --git a/bcmdhd/wifi_hal/cpp_bindings.cpp b/bcmdhd/wifi_hal/cpp_bindings.cpp
index 310918c..fa120e7 100755
--- a/bcmdhd/wifi_hal/cpp_bindings.cpp
+++ b/bcmdhd/wifi_hal/cpp_bindings.cpp
@@ -601,6 +601,9 @@
         case -EBUSY:
             ret = WIFI_ERROR_BUSY;
             break;
+        case -ENODEV:
+            ret = WIFI_ERROR_NOT_AVAILABLE;
+            break;
         default:
             ret = WIFI_ERROR_UNKNOWN;
     }
diff --git a/bcmdhd/wifi_hal/nan.cpp b/bcmdhd/wifi_hal/nan.cpp
index b83f10a..bfc33e0 100755
--- a/bcmdhd/wifi_hal/nan.cpp
+++ b/bcmdhd/wifi_hal/nan.cpp
@@ -385,6 +385,7 @@
 static int get_svc_hash(unsigned char *svc_name, u16 svc_name_len,
         u8 *svc_hash, u16 svc_hash_len);
 NanResponseType get_response_type(WIFI_SUB_COMMAND nan_subcmd);
+NanResponseType get_response_type_frm_req_type(NanRequestType cmdType);
 static NanStatusType nan_map_response_status(int vendor_status);
 
 /* Function to separate the common events to NAN1.0 events */
@@ -1570,8 +1571,9 @@
                         pub_term_event.reason = (NanStatusType)it.get_u8();
                         ALOGI("pub termination status %u", pub_term_event.reason);
                     } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                        u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason));
+                        u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason) - 1);
                         memcpy(pub_term_event.nan_reason, it.get_data(), len);
+                        pub_term_event.nan_reason[len] = '\0';
                         ALOGI("pub termination reason: %s, len = %d\n",
                             pub_term_event.nan_reason, len);
                     } else {
@@ -1693,8 +1695,9 @@
                         sub_term_event.reason = (NanStatusType)it.get_u16();
                         ALOGI("sub termination status %u", sub_term_event.reason);
                     } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                        u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason));
+                        u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason) - 1);
                         memcpy(sub_term_event.nan_reason, it.get_data(), len);
+                        sub_term_event.nan_reason[len] = '\0';
                         ALOGI("sub termination nan reason: %s, len = %d\n",
                             sub_term_event.nan_reason, len);
                     } else {
@@ -1745,8 +1748,9 @@
                     } else if (attr_type == NAN_ATTRIBUTE_STATUS) {
                         followup_ind.reason = (NanStatusType)it.get_u8();
                     } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                        u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason));
+                        u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason) - 1);
                         memcpy(followup_ind.nan_reason, it.get_data(), len);
+                        followup_ind.nan_reason[len] = '\0';
                         ALOGI("nan transmit followup ind: reason: %s, len = %d\n",
                             followup_ind.nan_reason, len);
                     }
@@ -1839,40 +1843,69 @@
 
     int createDataPathIfaceRequest(WifiRequest& request, char *iface_name)
     {
-        int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_IFACE_CREATE);
+        ALOGD("add ifname = %s, iface_type = %d", iface_name, NL80211_IFTYPE_STATION);
+        u32 wlan0_id = if_nametoindex("wlan0");
+        if (!wlan0_id) {
+            ALOGE("%s: Error wlan0 not present\n", __FUNCTION__);
+            return WIFI_ERROR_UNKNOWN;
+        }
+
+        /* Do not create interface if already exist. */
+        if (if_nametoindex(iface_name)) {
+            ALOGD("%s: if_nametoindex(%s) = %d already exists, skip create \n",
+                __FUNCTION__, iface_name, if_nametoindex(iface_name));
+            return WIFI_SUCCESS;
+        }
+
+        int result = request.create(NL80211_CMD_NEW_INTERFACE);
         if (result < 0) {
-            ALOGE("%s Failed to create request\n", __func__);
+            ALOGE("failed to create NL80211_CMD_NEW_INTERFACE; result = %d", result);
             return result;
         }
 
-        nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
-        result = request.put_string(NAN_ATTRIBUTE_IFACE, (char *)iface_name);
+        result = request.put_u32(NL80211_ATTR_IFINDEX, wlan0_id);
         if (result < 0) {
-            ALOGE("%s: Failed to fill iface, result = %d\n", __func__, result);
+            ALOGE("failed to put NL80211_ATTR_IFINDEX; result = %d", result);
             return result;
         }
 
-        request.attr_end(data);
+        result = request.put_string(NL80211_ATTR_IFNAME, iface_name);
+        if (result < 0) {
+            ALOGE("failed to put NL80211_ATTR_IFNAME = %s; result = %d", iface_name, result);
+            return result;
+        }
+
+        result = request.put_u32(NL80211_ATTR_IFTYPE, NL80211_IFTYPE_STATION);
+        if (result < 0) {
+            ALOGE("failed to put NL80211_ATTR_IFTYPE; result = %d", result);
+            return result;
+        }
+
         return WIFI_SUCCESS;
     }
 
     int deleteDataPathIfaceRequest(WifiRequest& request, char *iface_name)
     {
-        int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_IFACE_DELETE);
+        ALOGD("delete ifname = %s\n", iface_name);
+
+        int result = request.create(NL80211_CMD_DEL_INTERFACE);
         if (result < 0) {
-            ALOGE("%s: Failed to create request, result = %d\n", __func__, result);
+            ALOGE("failed to create NL80211_CMD_DEL_INTERFACE; result = %d", result);
             return result;
         }
 
-        nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
-
-        result = request.put_string(NAN_ATTRIBUTE_IFACE, (char *)iface_name);
+        result = request.put_u32(NL80211_ATTR_IFINDEX, if_nametoindex(iface_name));
         if (result < 0) {
-            ALOGE("%s: Failed to fill iface, result = %d\n", __func__, result);
+            ALOGE("failed to put NL80211_ATTR_IFINDEX = %d; result = %d",
+                if_nametoindex(iface_name), result);
             return result;
         }
 
-        request.attr_end(data);
+        result = request.put_string(NL80211_ATTR_IFNAME, iface_name);
+        if (result < 0) {
+            ALOGE("failed to put NL80211_ATTR_IFNAME = %s; result = %d", iface_name, result);
+            return result;
+        }
         return WIFI_SUCCESS;
     }
 
@@ -2296,7 +2329,23 @@
             ALOGE("%s: failed to configure setup; result = %d", __func__, result);
             return result;
         }
-
+        ALOGI("NanDataPathPrmitive::request Response\n");
+        if (mType == NAN_DATA_PATH_IFACE_DELETE) {
+            NanResponseMsg rsp_data;
+            memset(&rsp_data, 0, sizeof(NanResponseMsg));
+            /* Prepare the NanResponseMsg payload */
+            rsp_data.response_type = get_response_type_frm_req_type((NanRequestType)mType);
+            /* Return success even for no dev case also, nothing to do */
+            rsp_data.status = NAN_STATUS_SUCCESS;
+            memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
+                strlen(NanStatusToString(rsp_data.status)));
+            rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
+            rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
+            ALOGI("Mapped hal status = %d\n", rsp_data.status);
+            ALOGI("Received nan_error string %s\n", (u8*)rsp_data.nan_error);
+            GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
+            ALOGE("Notified by cmd ret!!");
+        }
         request.destroy();
         return WIFI_SUCCESS;
     }
@@ -2321,49 +2370,63 @@
     int handleResponse(WifiEvent& reply)
     {
         nan_hal_resp_t *rsp_vndr_data = NULL;
+        NanResponseMsg rsp_data;
+        int32_t result = BCME_OK;
 
-        if (reply.get_cmd() != NL80211_CMD_VENDOR || reply.get_vendor_data() == NULL) {
+        ALOGI("NanDataPathPrmitive::handle Response\n");
+        memset(&rsp_data, 0, sizeof(NanResponseMsg));
+        if (mType == NAN_DATA_PATH_IFACE_CREATE) {
+             /* NDI creation and deletion are done through vendor ops,
+              * driver does not send the cmd response payload,
+              * but for framework,
+              * mimicking the NanResponseMsg for iface create and delete nan cmds
+              */
+             rsp_data.response_type = get_response_type_frm_req_type((NanRequestType)mType);
+             /* Return success even for no dev case also, nothing to do */
+             if (result == WIFI_SUCCESS || result == WIFI_ERROR_NOT_AVAILABLE) {
+                 rsp_data.status = NAN_STATUS_SUCCESS;
+             } else {
+                 rsp_data.status = NAN_STATUS_INTERNAL_FAILURE;
+             }
+         } else if (reply.get_cmd() != NL80211_CMD_VENDOR || reply.get_vendor_data() == NULL) {
             ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
             return NL_SKIP;
+        } else {
+            rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
+            result = rsp_vndr_data->value;
+            rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
+
+            if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
+                /* Follow through */
+            } else if (!valid_dp_response_type(rsp_data.response_type)) {
+               return NL_SKIP;
+            }
+            rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
+
+            if (rsp_data.response_type == NAN_DP_INITIATOR_RESPONSE) {
+                ALOGI("received ndp instance_id %d and ret = %d\n",
+                    rsp_vndr_data->ndp_instance_id, result);
+                rsp_data.body.data_request_response.ndp_instance_id =
+                    rsp_vndr_data->ndp_instance_id;
+                mNdpId = rsp_vndr_data->ndp_instance_id;
+            } else if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
+                memcpy(mPubNmi, rsp_vndr_data->pub_nmi, NAN_MAC_ADDR_LEN);
+                memcpy(mSvcHash, rsp_vndr_data->svc_hash, NAN_SVC_HASH_SIZE);
+                return NL_SKIP;
+            }
         }
 
-        rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
-        ALOGI("NanDataPathPrmitive::handle response\n");
-        int32_t result = rsp_vndr_data->value;
-        NanResponseMsg rsp_data;
-
-        memset(&rsp_data, 0, sizeof(NanResponseMsg));
-        rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
-
-        if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
-            /* Follow through */
-        } else if (!valid_dp_response_type(rsp_data.response_type)) {
-            return NL_SKIP;
-        }
-        rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
-        ALOGE("Mapped hal status = %d\n", rsp_data.status);
-
-        if (rsp_vndr_data->nan_reason[0] == '\0') {
-            memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
-                    strlen(NanStatusToString(rsp_data.status)));
-            rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
-        }
+        memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
+            strlen(NanStatusToString(rsp_data.status)));
+        rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
         rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
-        ALOGI("\n Received nan_error string %s\n", (u8*)rsp_data.nan_error);
 
-        if (rsp_data.response_type == NAN_DP_INITIATOR_RESPONSE) {
-            ALOGI("received ndp instance_id %d and ret = %d\n", rsp_vndr_data->ndp_instance_id, result);
-            rsp_data.body.data_request_response.ndp_instance_id = rsp_vndr_data->ndp_instance_id;
-            mNdpId = rsp_vndr_data->ndp_instance_id;
-        } else if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
-            memcpy(mPubNmi, rsp_vndr_data->pub_nmi, NAN_MAC_ADDR_LEN);
-            memcpy(mSvcHash, rsp_vndr_data->svc_hash, NAN_SVC_HASH_SIZE);
-            return NL_SKIP;
-        }
-
+        ALOGI("Mapped hal status = %d\n", rsp_data.status);
+        ALOGI("Received nan_error string %s\n", (u8*)rsp_data.nan_error);
         ALOGI("NanDataPathPrmitive:Received response for cmd [%s], ret %d\n",
-                NanRspToString(rsp_data.response_type), rsp_data.status);
+            NanRspToString(rsp_data.response_type), rsp_data.status);
         GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
+        ALOGE("Notified by cmd reply!!");
         return NL_SKIP;
     }
 
@@ -3553,8 +3616,9 @@
                         disabled_ind.reason = (NanStatusType)it.get_u8();
                         ALOGI("Nan Disable:status %u", disabled_ind.reason);
                     } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                        u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason));
+                        u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason) - 1);
                         memcpy(disabled_ind.nan_reason, it.get_data(), len);
+                        disabled_ind.nan_reason[len] = '\0';
                         ALOGI("Disabled nan reason: %s, len = %d\n",
                             disabled_ind.nan_reason, len);
                     }
@@ -3864,6 +3928,27 @@
     return response_type;
 }
 
+
+NanResponseType get_response_type_frm_req_type(NanRequestType cmdType) {
+    NanResponseType response_type;
+
+    switch (cmdType) {
+        case NAN_DATA_PATH_IFACE_CREATE:
+            response_type = NAN_DP_INTERFACE_CREATE;
+            break;
+        case NAN_DATA_PATH_IFACE_DELETE:
+            response_type = NAN_DP_INTERFACE_DELETE;
+            break;
+        default:
+            /* unknown response for a request type */
+            response_type = NAN_RESPONSE_ERROR;
+            break;
+    }
+
+    return response_type;
+
+}
+
 static int get_svc_hash(unsigned char *svc_name,
         u16 svc_name_len, u8 *svc_hash, u16 svc_hash_len)
 {
@@ -4845,8 +4930,9 @@
                             disabled_ind.reason = (NanStatusType)it.get_u8();
                             ALOGI("Nan Disable:status %u", disabled_ind.reason);
                         } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                            u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason));
+                            u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason) - 1);
                             memcpy(disabled_ind.nan_reason, it.get_data(), len);
+                            disabled_ind.nan_reason[len] = '\0';
                             ALOGI("nan disabled reason: %s, len = %d\n",
                                 disabled_ind.nan_reason, len);
                         }
@@ -4871,8 +4957,9 @@
                             pub_term_event.reason = (NanStatusType)it.get_u8();
                             ALOGI("pub termination status %u", pub_term_event.reason);
                         } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                            u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason));
+                            u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason) - 1);
                             memcpy(pub_term_event.nan_reason, it.get_data(), len);
+                            pub_term_event.nan_reason[len] = '\0';
                             ALOGI("Pub termination nan reason: %s, len = %d\n",
                                 pub_term_event.nan_reason, len);
                         } else {
@@ -5002,8 +5089,9 @@
                             sub_term_event.reason = (NanStatusType)it.get_u8();
                             ALOGI("sub termination status %u", sub_term_event.reason);
                         } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                            u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason));
+                            u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason) - 1);
                             memcpy(sub_term_event.nan_reason, it.get_data(), len);
+                            sub_term_event.nan_reason[len] = '\0';
                             ALOGI("sub termination nan reason: %s, len = %d\n",
                                 sub_term_event.nan_reason, len);
                         } else {
@@ -5251,8 +5339,9 @@
                         } else if (attr_type == NAN_ATTRIBUTE_STATUS) {
                             followup_ind.reason = (NanStatusType)it.get_u8();
                         } else if (attr_type == NAN_ATTRIBUTE_REASON) {
-                            u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason));
+                            u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason) - 1);
                             memcpy(followup_ind.nan_reason, it.get_data(), len);
+                            followup_ind.nan_reason[len] = '\0';
                             ALOGI("nan transmit followup ind: reason: %s, len = %d\n",
                                followup_ind.nan_reason, len);
                         }
diff --git a/bcmdhd/wifi_hal/rtt.cpp b/bcmdhd/wifi_hal/rtt.cpp
index 9716c0e..603caf3 100644
--- a/bcmdhd/wifi_hal/rtt.cpp
+++ b/bcmdhd/wifi_hal/rtt.cpp
@@ -662,6 +662,7 @@
 	return WIFI_ERROR_INVALID_ARGS;
     }
 
+    ALOGI("Rtt range_request; id = %d", id);
     RttCommand *cmd = new RttCommand(iface, id, num_rtt_config, rtt_config, handler);
     NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
     wifi_error result = wifi_register_cmd(handle, id, cmd);
@@ -695,9 +696,11 @@
 	return WIFI_ERROR_INVALID_ARGS;
     }
 
+    ALOGI("Rtt range_cancel_request; id = %d", id);
     RttCommand *cmd = new RttCommand(iface, id);
     NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
     cmd->cancel_specific(num_devices, addr);
+    wifi_unregister_cmd(handle, id);
     cmd->releaseRef();
     return WIFI_SUCCESS;
 }
diff --git a/bcmdhd/wifi_hal/wifi_logger.cpp b/bcmdhd/wifi_hal/wifi_logger.cpp
index a605b85..dbbcf79 100755
--- a/bcmdhd/wifi_hal/wifi_logger.cpp
+++ b/bcmdhd/wifi_hal/wifi_logger.cpp
@@ -1035,6 +1035,12 @@
     }
 }
 
+typedef struct {
+    u32 magic;
+    int num_entries;
+} __attribute__((packed)) wifi_ring_buffer_entry_pack;
+
+#define WIFI_RING_BUFFER_PACK_MAGIC 0xDBAADBAA
 
 ///////////////////////////////////////////////////////////////////////////////
 class SetLogHandler : public WifiCommand
@@ -1153,11 +1159,46 @@
             if (mHandler.on_ring_buffer_data) {
                 /* Skip msg header. Retrieved log */
                 char *pBuff;
-                wifi_ring_buffer_entry *buffer_entry =
-                            (wifi_ring_buffer_entry *) buffer;
-                pBuff = (char *) (buffer_entry + 1);
-                (*mHandler.on_ring_buffer_data)((char *)status.name, pBuff,
-                    buffer_entry->entry_size, &status);
+                int num_entries;
+                int cur_off = 0;
+                wifi_ring_buffer_entry_pack *pack_hdr =
+                    (wifi_ring_buffer_entry_pack *)buffer;
+                wifi_ring_buffer_entry *entry_hdr =
+                    (wifi_ring_buffer_entry *)(buffer + sizeof(*pack_hdr));
+                cur_off += sizeof(*pack_hdr);
+
+                if (pack_hdr->magic != WIFI_RING_BUFFER_PACK_MAGIC) {
+                    ALOGE("SetLogHandler: magic code is not matched "
+                        "magic:%u ring_name:%s\n", pack_hdr->magic, status.name);
+                    return NL_SKIP;
+                }
+
+                num_entries = pack_hdr->num_entries;
+
+                while (num_entries > 0) {
+                    /* Check for accesses that exceed the total buffer size */
+                    if (cur_off + sizeof(*entry_hdr) + entry_hdr->entry_size > buffer_size) {
+                        ALOGE("SetLogHandler: detected invalid access "
+                            "num_entries:%d cur_num:%d buffer_size:%d cur_off:%d "
+                            "hdrsize:%lu entry_size:%d ring_name:%s\n",
+                            pack_hdr->num_entries, num_entries, buffer_size, cur_off,
+                            sizeof(*entry_hdr), entry_hdr->entry_size, status.name);
+                        return NL_SKIP;
+                    }
+
+                    /* Copy buffer without hdr to the ringbuffer in LegacyHAL */
+                    pBuff = (char *)entry_hdr + sizeof(*entry_hdr);
+                    (*mHandler.on_ring_buffer_data)((char *)status.name, pBuff,
+                        entry_hdr->entry_size, &status);
+
+                    cur_off += sizeof(*entry_hdr) + entry_hdr->entry_size;
+
+                    /* jump to next entry_hdr */
+                    entry_hdr = (wifi_ring_buffer_entry *)((char *)entry_hdr + sizeof(*entry_hdr) + entry_hdr->entry_size);
+
+                    num_entries--;
+                }
+
             }
         } else {
             ALOGE("Unknown Event");
@@ -1198,6 +1239,10 @@
     wifi_handle handle = getWifiHandle(iface);
     ALOGE("Loghandler reset, wifi_request_id = %d, handle = %p", id, handle);
 
+#ifdef RING_DUMP
+    wifi_stop_ring_dump(iface);
+#endif /* RING_DUMP */
+
     if (id == -1) {
         wifi_ring_buffer_data_handler handler;
         memset(&handler, 0, sizeof(handler));
@@ -1207,9 +1252,6 @@
         cmd->cancel();
         cmd->releaseRef();
 
-#ifdef RING_DUMP
-        wifi_stop_ring_dump(iface, handler);
-#endif /* RING_DUMP */
         return WIFI_SUCCESS;
     }
 
@@ -1643,9 +1685,6 @@
                 ring_name[i] = NULL;
             }
         }
-        if (mBuff) {
-            free(mBuff);
-        }
 
         DUMP_INFO(("Stop Ring Dump Successfully Completed, mErrCode = %d\n", mErrCode));
         return WIFI_SUCCESS;
@@ -1984,8 +2023,7 @@
     return result;
 }
 
-wifi_error wifi_stop_ring_dump(wifi_interface_handle iface,
-    wifi_ring_buffer_data_handler ring_handle)
+wifi_error wifi_stop_ring_dump(wifi_interface_handle iface)
 {
     RingDump *cmd = new RingDump(iface, FILE_DUMP_REQUEST_ID);
     NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);