Snap for 8512216 from 79464da5e668de737368f899dac7d730fb8aacc5 to tm-frc-scheduling-release
Change-Id: I0b5532d6f389e464c953e0826db1cf5e998d7300
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 @@
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 21f0cef..ecc1abf 100755
--- a/bcmdhd/wifi_hal/common.h
+++ b/bcmdhd/wifi_hal/common.h
@@ -232,7 +232,7 @@
WIFI_SUBCMD_OTA_UPDATE,
WIFI_SUBCMD_USABLE_CHANNEL = ANDROID_NL80211_SUBCMD_USABLE_CHANNEL_START,
WIFI_SUBCMD_TRIGGER_SSR = ANDROID_NL80211_SUBCMD_INIT_DEINIT_RANGE_START,
-
+ WIFI_SUBCMD_GET_RADIO_COMBO_MATRIX,
} WIFI_SUB_COMMAND;
typedef enum {
@@ -306,6 +306,12 @@
bool is_virtual; // mark each iface as virtual or static
} interface_info;
+typedef enum {
+ NAN_STATE_DISABLED = 0,
+ NAN_STATE_AP = 1,
+ NAN_STATE_CHRE = 2,
+} nan_enab_state_t;
+
typedef struct {
struct nl_sock *cmd_sock; // command socket object
@@ -333,6 +339,8 @@
int max_num_interfaces; // max number of interfaces
wifi_subsystem_restart_handler restart_handler; // trigger sub system handler
+ wifi_chre_handler chre_nan_cb; // chre CB for nan status
+ nan_enab_state_t nan_state; // Nan enable state
// add other details
} hal_info;
@@ -448,6 +456,12 @@
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 */
@@ -527,6 +541,36 @@
wifi_error twt_clear_stats(wifi_interface_handle iface, u8 config_id);
wifi_error wifi_trigger_subsystem_restart(wifi_handle handle);
+
+/**@brief nan_chre_enable_request
+ * Request from CHRE to enable NAN
+ * @param transaction id:
+ * @param wifi_interface_handle:
+ * @param NanEnableRequest:
+ * @return Synchronous wifi_error
+ */
+wifi_error nan_chre_enable_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanEnableRequest* msg);
+
+/**@brief nan_chre_disable_request
+ * Request from CHRE to disable NAN
+ * @param transaction id:
+ * @param wifi_interface_handle:
+ * @return Synchronous wifi_error
+ */
+wifi_error nan_chre_disable_request(transaction_id id,
+ wifi_interface_handle iface);
+
+/**@brief nan_chre_register_handler
+ * Register chre handler to handle NAN status
+ * @param wifi_interface_handle:
+ * @param wifi_chre_handler:
+ * @return Synchronous wifi_error
+ */
+wifi_error nan_chre_register_handler(wifi_interface_handle iface,
+ wifi_chre_handler handler);
+
// some common macros
#define min(x, y) ((x) < (y) ? (x) : (y))
diff --git a/bcmdhd/wifi_hal/cpp_bindings.cpp b/bcmdhd/wifi_hal/cpp_bindings.cpp
index 5311e6e..7a634bd 100755
--- a/bcmdhd/wifi_hal/cpp_bindings.cpp
+++ b/bcmdhd/wifi_hal/cpp_bindings.cpp
@@ -647,7 +647,6 @@
}
int WifiCommand::requestResponse(WifiRequest& request) {
- pthread_mutex_lock(&ResponseMutex);
int err = 0;
struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
@@ -674,7 +673,6 @@
}
out:
nl_cb_put(cb);
- pthread_mutex_unlock(&ResponseMutex);
return mapErrorCodes(err);
}
diff --git a/bcmdhd/wifi_hal/nan.cpp b/bcmdhd/wifi_hal/nan.cpp
index 475c697..52f29e3 100755
--- a/bcmdhd/wifi_hal/nan.cpp
+++ b/bcmdhd/wifi_hal/nan.cpp
@@ -290,7 +290,8 @@
NAN_ATTRIBUTE_CHANNEL_INFO = 228,
NAN_ATTRIBUTE_NUM_CHANNELS = 229,
NAN_ATTRIBUTE_INSTANT_MODE_ENABLE = 230,
- NAN_ATTRIBUTE_INSTANT_COMM_CHAN = 231
+ NAN_ATTRIBUTE_INSTANT_COMM_CHAN = 231,
+ NAN_ATTRIBUTE_CHRE_REQUEST = 232,
} NAN_ATTRIBUTE;
typedef enum {
@@ -2543,6 +2544,7 @@
wifi_interface_handle mIface;
NanRequestType mType;
u32 mVersion;
+ u8 mChreNan;
public:
NanMacControl(wifi_interface_handle iface, int id,
@@ -2582,6 +2584,10 @@
mParams = params;
}
+ void setChreNan(u8 chre_nan) {
+ mChreNan = chre_nan;
+ }
+
int createRequest(WifiRequest& request) {
ALOGI("NAN CMD: %s\n", NanCmdToString(mType));
if (mType == NAN_REQUEST_ENABLE) {
@@ -2981,6 +2987,12 @@
ALOGI("%s: instant mode channel = %d\n", __func__, mParams->instant_mode_channel);
}
+ result = request.put_u8(NAN_ATTRIBUTE_CHRE_REQUEST, mChreNan);
+ if (result < 0) {
+ ALOGE("%s: Failing in config chreNan, result = %d\n", __func__, result);
+ return result;
+ }
+
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
@@ -2997,6 +3009,12 @@
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ result = request.put_u8(NAN_ATTRIBUTE_CHRE_REQUEST, mChreNan);
+ if (result < 0) {
+ ALOGE("%s: Failing in config chreNan, result = %d\n", __func__, result);
+ return result;
+ }
+
request.attr_end(data);
NAN_DBG_EXIT();
@@ -3254,13 +3272,15 @@
}
}
- if (mParams->config_instant_mode_channel) {
+ if (mParams->enable_instant_mode && mParams->config_instant_mode_channel
+ && mParams->instant_mode_channel) {
result = request.put_u32(NAN_ATTRIBUTE_INSTANT_COMM_CHAN,
mParams->instant_mode_channel);
if (result < 0) {
ALOGE("%s: Failing in config instant channel, result = %d\n", __func__, result);
return result;
}
+ ALOGI("%s: instant mode channel = %d\n", __func__, mParams->instant_mode_channel);
}
request.attr_end(data);
@@ -3320,6 +3340,10 @@
return NL_SKIP;
}
+ if (mChreNan) {
+ return NL_SKIP;
+ }
+
rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
ALOGI("NanMacControl::handleResponse\n");
if (mType == NAN_VERSION_INFO) {
@@ -3399,6 +3423,10 @@
return NL_SKIP;
}
+ if (mChreNan) {
+ return NL_SKIP;
+ }
+
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
@@ -3868,7 +3896,6 @@
return WIFI_SUCCESS;
}
-#ifdef CONFIG_BRCM
static int dump_NanEnableRequest(NanEnableRequest* msg)
{
ALOGI("%s: Dump NanEnableRequest msg:\n", __func__);
@@ -3974,6 +4001,7 @@
return WIFI_SUCCESS;
}
+#ifdef CONFIG_BRCM
static int dump_NanConfigRequestRequest(NanConfigRequest* msg)
{
ALOGI("%s: Dump NanConfigRequest msg:\n", __func__);
@@ -4272,32 +4300,66 @@
}
///////////////////////////////////////////////////////////////////////////////
-wifi_error nan_enable_request(transaction_id id,
- wifi_interface_handle iface, NanEnableRequest* msg)
+wifi_error nan_cmn_enabe_request(transaction_id id,
+ NanMacControl *cmd, NanEnableRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
- wifi_handle handle = getWifiHandle(iface);
- NanRequestType cmdType = NAN_REQUEST_ENABLE;
-
- ALOGI("Enabling Nan, Handle = %p\n", handle);
-
#ifdef CONFIG_BRCM
// check up nan enable params from Nan manager level
dump_NanEnableRequest(msg);
#endif /* CONFIG_BRCM */
nan_reset_dbg_counters();
- /* XXX: WAR posting async enable response */
- //NanMacControl *cmd = new NanMacControl(iface, id, (void *)msg, cmdType);
- NanMacControl *cmd = (NanMacControl*)(info.nan_mac_control);
- NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
- cmd->setType(cmdType);
+
+ cmd->setType(NAN_REQUEST_ENABLE);
cmd->setId(id);
cmd->setMsg((void *)msg);
+
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
- //cmd->releaseRef();
+
+ return ret;
+}
+
+wifi_error nan_enable_request(transaction_id id,
+ wifi_interface_handle iface, NanEnableRequest* msg)
+{
+ wifi_error ret = WIFI_SUCCESS;
+ hal_info *h_info = getHalInfo(iface);
+
+ ALOGE("nan_enable_request: nan_state = %d\n", h_info->nan_state);
+
+#ifdef CHRE_NAN
+ //check if host NAN is pre-empting CHRE NAN
+ if (h_info->nan_state == NAN_STATE_CHRE) {
+ /* notify pre-empt to chre */
+ if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
+ h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_PREMPTED);
+ }
+ /* first disable NAN for chre */
+ ret = nan_chre_disable_request(1, iface);
+ if (ret != WIFI_SUCCESS) {
+ ALOGE("Failed to disable NAN for CHRE ret %d\n", ret);
+ return ret;
+ }
+ }
+
+ /* notify unavailable status to chre */
+ if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
+ h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_UNAVAILABLE);
+ }
+#endif /* CHRE_NAN */
+
+ NanMacControl *cmd = (NanMacControl*)(info.nan_mac_control);
+ NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+ cmd->setChreNan(0);
+ ret = nan_cmn_enabe_request(id, cmd, msg);
+
+ if (ret == WIFI_SUCCESS) {
+ h_info->nan_state = NAN_STATE_AP;
+ }
+
return ret;
}
@@ -4312,16 +4374,40 @@
ALOGI("Num Transmit Success %d\n", counters.transmit_txs);
}
+wifi_error nan_cmn_disable_request(transaction_id id, NanMacControl *mac)
+{
+ wifi_error ret = WIFI_SUCCESS;
+
+ nan_dump_dbg_counters();
+
+ mac->setType(NAN_REQUEST_DISABLE);
+ ret = (wifi_error)mac->cancel();
+ if (ret != WIFI_SUCCESS) {
+ ALOGE("cancel failed, error = %d\n", ret);
+ } else {
+ ALOGE("Deinitializing Nan Mac Control = %p\n", mac);
+ }
+ mac->releaseRef();
+
+ return ret;
+}
wifi_error nan_disable_request(transaction_id id,
wifi_interface_handle iface)
{
- wifi_handle handle = getWifiHandle(iface);
- NanRequestType cmdType = NAN_REQUEST_DISABLE;
wifi_error ret = WIFI_SUCCESS;
+ hal_info *h_info = getHalInfo(iface);
- ALOGI("Disabling Nan, Handle = %p\n", handle);
- NanMacControl *cmd = new NanMacControl(iface, id, NULL, cmdType);
+ ALOGE("nan_disable_request: nan_state %d\n", h_info->nan_state);
+
+ if (h_info->nan_state == NAN_STATE_CHRE) {
+ ALOGE("nan_disable_request: Not enabled for AP.. return\n");
+ return ret;
+ }
+
NanMacControl *mac_prim = (NanMacControl*)(info.nan_mac_control);
+ NanMacControl *cmd = new NanMacControl(iface, id, NULL, NAN_REQUEST_LAST);
+
+ NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
if (id != NAN_MAC_INVALID_TRANSID) {
ALOGE("Disable NAN MAC transId= %d\n", id);
@@ -4330,17 +4416,15 @@
ALOGE("Invalid transId= %d cur= %d\n", id, mac_prim->getId());
}
- NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
-
- nan_dump_dbg_counters();
-
- ret = (wifi_error)cmd->cancel();
- if (ret != WIFI_SUCCESS) {
- ALOGE("cancel failed, error = %d\n", ret);
- } else {
- ALOGE("Deinitializing Nan Mac Control = %p\n", cmd);
+ cmd->setChreNan(0);
+ ret = nan_cmn_disable_request(id, cmd);
+ if (ret == WIFI_SUCCESS) {
+ h_info->nan_state = NAN_STATE_DISABLED;
+ /* notify pre-empt / unavailable status to chre */
+ if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
+ h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_AVAILABLE);
+ }
}
- cmd->releaseRef();
return ret;
}
@@ -5437,3 +5521,89 @@
NAN_DBG_EXIT();
return ret;
}
+
+wifi_error nan_chre_enable_request(transaction_id id,
+ wifi_interface_handle iface, NanEnableRequest* msg)
+{
+ wifi_error ret = WIFI_SUCCESS;
+ NanEnableRequest def_msg;
+ hal_info *h_info = getHalInfo(iface);
+
+ ALOGI("nan_chre_enable_request: nan_state %d\n", h_info->nan_state);
+
+ if (h_info->nan_state == NAN_STATE_CHRE) {
+ return WIFI_SUCCESS;
+ } else if (h_info->nan_state == NAN_STATE_AP) {
+ ALOGE("nan_chre_enable_request: Nan is enabled for AP. Fail CHRE request\n");
+ return WIFI_ERROR_BUSY;
+ }
+
+ NanMacControl *mac = new NanMacControl(iface, 0, NULL, NAN_REQUEST_LAST);
+ NULL_CHECK_RETURN(mac, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+
+ mac->setChreNan(1);
+ if (msg == NULL) {
+ /* default enable params */
+ ALOGI("Input Enable config is NULL, use default config\n");
+ memset(&def_msg, 0, sizeof(def_msg));
+ def_msg.hop_count_limit_val = 5;
+ def_msg.config_2dot4g_support = 1;
+ def_msg.support_2dot4g_val = 1;
+ def_msg.config_2dot4g_beacons = 1;
+ def_msg.beacon_2dot4g_val = 1;
+ def_msg.config_2dot4g_sdf = 1;
+ def_msg.sdf_2dot4g_val = 1;
+ def_msg.config_disc_mac_addr_randomization = true;
+ def_msg.disc_mac_addr_rand_interval_sec = 0;
+ def_msg.config_ndpe_attr = false;
+ ret = nan_cmn_enabe_request(id, mac, &def_msg);
+ } else {
+ ret = nan_cmn_enabe_request(id, mac, msg);
+ }
+
+ if (ret == WIFI_SUCCESS) {
+ h_info->nan_state = NAN_STATE_CHRE;
+ }
+
+ return ret;
+}
+
+wifi_error nan_chre_disable_request(transaction_id id,
+ wifi_interface_handle iface)
+{
+ wifi_error ret = WIFI_SUCCESS;
+ hal_info *h_info = getHalInfo(iface);
+
+ ALOGI("nan_chre_disable_request: nan_state %d\n", h_info->nan_state);
+
+ if (h_info->nan_state == NAN_STATE_AP) {
+ ALOGE("nan_chre_disable_request: Not enabled for CHRE.. return\n");
+ return ret;
+ }
+
+ NanMacControl *cmd = new NanMacControl(iface, id, NULL, NAN_REQUEST_LAST);
+ NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+
+ cmd->setChreNan(1);
+ ret = nan_cmn_disable_request(id, cmd);
+
+ if (ret == WIFI_SUCCESS) {
+ h_info->nan_state = NAN_STATE_DISABLED;
+ }
+
+ return ret;
+}
+
+wifi_error nan_chre_register_handler(wifi_interface_handle iface,
+ wifi_chre_handler handler)
+{
+ wifi_error ret = WIFI_SUCCESS;
+ hal_info *h_info = getHalInfo(iface);
+
+ if (h_info) {
+ ALOGE("Registering CHRE handler for Nan Status %p\n", handler.on_chre_nan_rtt_change);
+ h_info->chre_nan_cb = handler;
+ }
+
+ return ret;
+}
diff --git a/bcmdhd/wifi_hal/wifi_hal.cpp b/bcmdhd/wifi_hal/wifi_hal.cpp
index 83c65c3..fe679ab 100755
--- a/bcmdhd/wifi_hal/wifi_hal.cpp
+++ b/bcmdhd/wifi_hal/wifi_hal.cpp
@@ -94,6 +94,8 @@
static wifi_error wifi_configure_nd_offload(wifi_interface_handle iface, u8 enable);
static wifi_error wifi_get_usable_channels(wifi_handle handle, u32 band_mask, u32 iface_mode_mask,
u32 filter_mask, u32 max_size, u32* size, wifi_usable_channel* channels);
+static wifi_error wifi_get_supported_radio_combinations_matrix(wifi_handle handle,
+ u32 max_size, u32* size, wifi_radio_combination_matrix *radio_combination_matrix);
static void wifi_cleanup_dynamic_ifaces(wifi_handle handle);
typedef enum wifi_attr {
@@ -116,6 +118,13 @@
ANDR_WIFI_ATTRIBUTE_MAX
} wifi_attr_t;
+enum wifi_radio_combo_attributes {
+ ANDR_WIFI_ATTRIBUTE_RADIO_COMBO_INVALID = 0,
+ ANDR_WIFI_ATTRIBUTE_RADIO_COMBO_MATRIX = 1,
+ // Add more attribute here
+ ANDR_WIFI_ATTRIBUTE_RADIO_COMBO_MAX
+};
+
enum wifi_rssi_monitor_attr {
RSSI_MONITOR_ATTRIBUTE_INVALID = 0,
RSSI_MONITOR_ATTRIBUTE_MAX_RSSI = 1,
@@ -331,6 +340,10 @@
fn->wifi_set_dtim_config = wifi_set_dtim_config;
fn->wifi_get_usable_channels = wifi_get_usable_channels;
fn->wifi_trigger_subsystem_restart = wifi_trigger_subsystem_restart;
+ fn->wifi_get_supported_radio_combinations_matrix = wifi_get_supported_radio_combinations_matrix;
+ fn->wifi_nan_rtt_chre_enable_request = nan_chre_enable_request;
+ fn->wifi_nan_rtt_chre_disable_request = nan_chre_disable_request;
+ fn->wifi_chre_register_handler = nan_chre_register_handler;
return WIFI_SUCCESS;
}
@@ -530,6 +543,7 @@
}
} else {
ALOGI("Not Calling set alert handler as global_iface is NULL");
+ return WIFI_ERROR_UNKNOWN;
}
return WIFI_SUCCESS;
}
@@ -1478,6 +1492,93 @@
}
};
+/////////////////////////////////////////////////////////////////////
+class GetRadioComboCommand : public WifiCommand {
+private:
+ wifi_radio_combination_matrix *rcmatrix;
+ u32* rc_size;
+ u32 set_size_max;
+ int ret = 0;
+
+public:
+ GetRadioComboCommand(wifi_interface_handle handle, u32 max_size, u32* size,
+ wifi_radio_combination_matrix *radio_combination_matrix)
+ : WifiCommand("GetRadioComboCommand", handle, 0), rcmatrix(radio_combination_matrix),
+ rc_size(size), set_size_max(max_size)
+ {
+ }
+
+ virtual int createRequest(WifiRequest& mMsg) {
+ ret = mMsg.create(GOOGLE_OUI, WIFI_SUBCMD_GET_RADIO_COMBO_MATRIX);
+ if (ret < 0) {
+ ALOGE("Can't create message to send to driver - %d", ret);
+ }
+ nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
+ mMsg.attr_end(data);
+
+ return ret;
+ }
+
+ int start() {
+ WifiRequest request(familyId(), ifaceId());
+ ret = createRequest(request);
+ if (ret < 0) {
+ ALOGE("Request failed for radio_combo_matrix, result = %d", ret);
+ return ret;
+ }
+ ret = requestResponse(request);
+ if (ret < 0) {
+ ALOGE("Request Response failed for radio_combo_matrix, result = %d", ret);
+ return ret;
+ }
+ ALOGD("Done! %s", __FUNCTION__);
+ return ret;
+ }
+
+protected:
+ virtual int handleResponse(WifiEvent& reply) {
+ ALOGD("In GetRadioComboCommand::handleResponse");
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ int id = reply.get_vendor_id();
+ int subcmd = reply.get_vendor_subcmd();
+
+ nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = reply.get_vendor_data_len();
+
+ ALOGV("Id = %0x, subcmd = %d, len = %d", id, subcmd, len);
+ if (vendor_data == NULL || len == 0) {
+ ALOGE("no vendor data in GetRadioComboCommand response; ignoring it");
+ return NL_SKIP;
+ }
+
+ for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
+ if (it.get_type() == ANDR_WIFI_ATTRIBUTE_RADIO_COMBO_MATRIX) {
+ void *data = it.get_data();
+ *rc_size = it.get_len();
+ if (!data || !*rc_size) {
+ ALOGE("Buffers pointers not set");
+ return NL_SKIP;
+ }
+ if (set_size_max < *rc_size) {
+ ALOGE("Unexpected buffers size");
+ return NL_SKIP;
+ }
+ memcpy(rcmatrix, data, min(len, *rc_size));
+ } else {
+ ALOGW("Ignoring invalid attribute type = %d, size = %d",
+ it.get_type(), it.get_len());
+ }
+ }
+
+ ALOGD("GetRadioComboCommand::Success");
+ return NL_OK;
+ }
+};
+/////////////////////////////////////////////////////////////////////
class SetLatencyModeCommand : public WifiCommand {
private:
@@ -1759,6 +1860,27 @@
return (wifi_error) command.requestResponse();
}
+wifi_error wifi_get_supported_radio_combinations_matrix(wifi_handle handle,
+ u32 max_size, u32* size, wifi_radio_combination_matrix *radio_combination_matrix)
+{
+ int numIfaceHandles = 0;
+ wifi_interface_handle *ifaceHandles = NULL;
+ wifi_interface_handle wlan0Handle;
+
+ wlan0Handle = wifi_get_wlan_interface((wifi_handle)handle, ifaceHandles, numIfaceHandles);
+ GetRadioComboCommand *cmd = new GetRadioComboCommand(wlan0Handle, max_size,
+ size, radio_combination_matrix);
+ NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
+ wifi_error result = (wifi_error)cmd->start();
+ if (result == WIFI_SUCCESS) {
+ ALOGD("Get radio combo matrix success");
+ } else {
+ ALOGE("Get radio combo matrix failed\n");
+ }
+ cmd->releaseRef();
+ return result;
+}
+
wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui)
{
SetPnoMacAddrOuiCommand command(handle, scan_oui);
diff --git a/bcmdhd/wifi_hal/wifi_logger.cpp b/bcmdhd/wifi_hal/wifi_logger.cpp
index 2a06cfb..1ee9661 100755
--- a/bcmdhd/wifi_hal/wifi_logger.cpp
+++ b/bcmdhd/wifi_hal/wifi_logger.cpp
@@ -72,7 +72,9 @@
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 @@
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 @@
GET_RING_STATUS,
GET_FEATURE,
START_RING_LOG,
+ GET_BUF_RING_MAP,
} GetCmdType;
typedef enum {
@@ -189,6 +194,323 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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_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 @@
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 @@
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,338 @@
}
};
+#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:
+ case DUMP_BUF_ATTR_PKTID_MAP_LOG:
+ case DUMP_BUF_ATTR_PKTID_UNMAP_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:
+ case DUMP_LEN_ATTR_PKTID_MAP_LOG:
+ case DUMP_LEN_ATTR_PKTID_UNMAP_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 +1944,52 @@
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);
