qcacmn: Replace WMI_LOGE() with wmi_err()

Replace WMI_LOGE() with wmi_err().

Change-Id: I4c2e2c278101224a967080c073c46004ea60f5af
CRs-Fixed: 2774563

wmi/src/wmi_filtered_logging.c

@@ -410,7 +410,7 @@ ssize_t debug_filtered_wmi_cmds_write(struct file *file,
 	}
 
 	if (wmi_add_to_record_list(wmi_handle, k, WMI_CMD)) {
-		WMI_LOGE("Add cmd %d to WMI_CMD list failed", k);
+		wmi_err("Add cmd %d to WMI_CMD list failed", k);
 		return 0;
 	}
 
@@ -447,7 +447,7 @@ ssize_t debug_filtered_wmi_evts_write(struct file *file,
 	}
 
 	if (wmi_add_to_record_list(wmi_handle, k, WMI_EVT)) {
-		WMI_LOGE("Add cmd %d to WMI_EVT list failed", k);
+		wmi_err("Add cmd %d to WMI_EVT list failed", k);
 		return 0;
 	}
 
@@ -479,7 +479,7 @@ ssize_t debug_wmi_filtered_command_log_write(struct file *file,
 
 	cmd_log_buf = wmi_handle->log_info.wmi_filtered_command_log;
 	if (wmi_reset_filtered_buffers(wmi_handle, cmd_log_buf))
-		WMI_LOGE("reset WMI CMD filtered_buffers failed");
+		wmi_err("reset WMI CMD filtered_buffers failed");
 	return count;
 }
 
@@ -508,6 +508,6 @@ ssize_t debug_wmi_filtered_event_log_write(struct file *file,
 
 	cmd_log_buf = wmi_handle->log_info.wmi_filtered_event_log;
 	if (wmi_reset_filtered_buffers(wmi_handle, cmd_log_buf))
-		WMI_LOGE("reset WMI EVT filtered_buffers failed");
+		wmi_err("reset WMI EVT filtered_buffers failed");
 	return count;
 }

wmi/src/wmi_unified.c

@@ -995,7 +995,7 @@ static int debug_wmi_log_size_show(struct seq_file *m, void *v)
 									\
 		ret = sscanf(locbuf, "%d", &k);				\
 		if ((ret != 1) || (k != 0)) {                           \
-			WMI_LOGE("Wrong input, echo 0 to clear the wmi buffer");\
+			wmi_err("Wrong input, echo 0 to clear the wmi buffer");\
 			return -EINVAL;					\
 		}							\
 									\
@@ -1165,7 +1165,7 @@ static void wmi_debugfs_create(wmi_unified_t wmi_handle,
 				wmi_handle, wmi_debugfs_infos[i].ops);
 
 		if (!wmi_handle->debugfs_de[i]) {
-			WMI_LOGE("debug Entry creation failed!");
+			wmi_err("debug Entry creation failed!");
 			goto out;
 		}
 	}
@@ -1173,7 +1173,7 @@ static void wmi_debugfs_create(wmi_unified_t wmi_handle,
 	return;
 
 out:
-	WMI_LOGE("debug Entry creation failed!");
+	wmi_err("debug Entry creation failed!");
 	wmi_log_buffer_free(wmi_handle);
 	return;
 }
@@ -1221,7 +1221,7 @@ static QDF_STATUS wmi_debugfs_init(wmi_unified_t wmi_handle, uint32_t pdev_idx)
 		debugfs_create_dir(buf, NULL);
 
 	if (!wmi_handle->log_info.wmi_log_debugfs_dir) {
-		WMI_LOGE("error while creating debugfs dir for %s", buf);
+		wmi_err("error while creating debugfs dir for %s", buf);
 		return QDF_STATUS_E_FAILURE;
 	}
 	wmi_debugfs_create(wmi_handle,
@@ -1498,7 +1498,7 @@ static QDF_STATUS wmi_ext_dbgfs_init(struct wmi_unified *wmi_handle,
 	}
 
 	if (!dentry) {
-		WMI_LOGE("error while creating extended wmi debugfs dir");
+		wmi_err("error while creating extended wmi debugfs dir");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -1508,7 +1508,7 @@ static QDF_STATUS wmi_ext_dbgfs_init(struct wmi_unified *wmi_handle,
 	if (!qdf_debugfs_create_file(WMI_EXT_DBG_FILE, WMI_EXT_DBG_FILE_PERM,
 				     dentry, &wmi_ext_dbgfs_ops[pdev_idx])) {
 		qdf_debugfs_remove_dir(dentry);
-		WMI_LOGE("error while creating extended wmi debugfs file");
+		wmi_err("Error while creating extended wmi debugfs file");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -1993,7 +1993,7 @@ wmi_register_event_handler_with_ctx(wmi_unified_t wmi_handle,
 	struct wmi_soc *soc;
 
 	if (!wmi_handle) {
-		WMI_LOGE("WMI handle is NULL");
+		wmi_err("WMI handle is NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -2013,7 +2013,7 @@ wmi_register_event_handler_with_ctx(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (soc->max_event_idx == WMI_UNIFIED_MAX_EVENT) {
-		WMI_LOGE("no more event handlers 0x%x",
+		wmi_err("no more event handlers 0x%x",
 			 evt_id);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -2110,7 +2110,7 @@ QDF_STATUS wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle,
 	struct wmi_soc *soc;
 
 	if (!wmi_handle) {
-		WMI_LOGE("WMI handle is NULL");
+		wmi_err("WMI handle is NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -2363,7 +2363,7 @@ static void wmi_process_control_rx(struct wmi_unified *wmi_handle,
 	} else if (exec_ctx == WMI_RX_SERIALIZER_CTX) {
 		wmi_process_fw_event_sched_thread_ctx(wmi_handle, evt_buf);
 	} else {
-		WMI_LOGE("Invalid event context %d", exec_ctx);
+		wmi_err("Invalid event context %d", exec_ctx);
 		qdf_nbuf_free(evt_buf);
 	}
 
@@ -2386,9 +2386,8 @@ static void wmi_control_rx(void *ctx, HTC_PACKET *htc_packet)
 
 	wmi_handle = wmi_get_pdev_ep(soc, htc_packet->Endpoint);
 	if (!wmi_handle) {
-		WMI_LOGE
-		("unable to get wmi_handle to Endpoint %d\n",
-		 htc_packet->Endpoint);
+		wmi_err("unable to get wmi_handle to Endpoint %d",
+			htc_packet->Endpoint);
 		qdf_nbuf_free(evt_buf);
 		return;
 	}
@@ -2750,7 +2749,7 @@ void *wmi_unified_get_pdev_handle(struct wmi_soc *soc, uint32_t pdev_idx)
 		wmi_handle->wmi_rx_work_queue =
 			qdf_alloc_unbound_workqueue("wmi_rx_event_work_queue");
 		if (!wmi_handle->wmi_rx_work_queue) {
-			WMI_LOGE("failed to create wmi_rx_event_work_queue");
+			wmi_err("failed to create wmi_rx_event_work_queue");
 			goto error;
 		}
 		wmi_handle->wmi_events = soc->wmi_events;
@@ -2769,7 +2768,7 @@ void *wmi_unified_get_pdev_handle(struct wmi_soc *soc, uint32_t pdev_idx)
 		wmi_interface_sequence_init(wmi_handle);
 		if (wmi_ext_dbgfs_init(wmi_handle, pdev_idx) !=
 		    QDF_STATUS_SUCCESS)
-			WMI_LOGE("failed to initialize wmi extended debugfs");
+			wmi_err("Failed to initialize wmi extended debugfs");
 
 		soc->wmi_pdev[pdev_idx] = wmi_handle;
 	} else
@@ -2890,7 +2889,7 @@ void *wmi_unified_attach(void *scn_handle,
 	wmi_handle->wmi_rx_work_queue =
 		qdf_alloc_unbound_workqueue("wmi_rx_event_work_queue");
 	if (!wmi_handle->wmi_rx_work_queue) {
-		WMI_LOGE("failed to create wmi_rx_event_work_queue");
+		wmi_err("failed to create wmi_rx_event_work_queue");
 		goto error;
 	}
 	wmi_interface_logging_init(wmi_handle, WMI_HOST_PDEV_ID_0);
@@ -2903,7 +2902,7 @@ void *wmi_unified_attach(void *scn_handle,
 	if (wmi_attach_register[param->target_type]) {
 		wmi_attach_register[param->target_type](wmi_handle);
 	} else {
-		WMI_LOGE("wmi attach is not registered");
+		wmi_err("wmi attach is not registered");
 		goto error;
 	}
 	wmi_interface_sequence_init(wmi_handle);
@@ -2919,7 +2918,7 @@ void *wmi_unified_attach(void *scn_handle,
 	soc->ops = wmi_handle->ops;
 	soc->wmi_pdev[0] = wmi_handle;
 	if (wmi_ext_dbgfs_init(wmi_handle, 0) != QDF_STATUS_SUCCESS)
-		WMI_LOGE("failed to initialize wmi extended debugfs");
+		wmi_err("Failed to initialize wmi extended debugfs");
 
 	wmi_wbuff_register(wmi_handle);
 
@@ -3054,7 +3053,7 @@ static void wmi_htc_tx_complete(void *ctx, HTC_PACKET *htc_pkt)
 	ASSERT(wmi_cmd_buf);
 	wmi_handle = wmi_get_pdev_ep(soc, htc_pkt->Endpoint);
 	if (!wmi_handle) {
-		WMI_LOGE("%s: Unable to get wmi handle\n", __func__);
+		wmi_err("Unable to get wmi handle");
 		QDF_ASSERT(0);
 		return;
 	}
@@ -3156,7 +3155,7 @@ static QDF_STATUS wmi_connect_pdev_htc_service(struct wmi_soc *soc,
 	status = htc_connect_service(soc->htc_handle, &connect, &response);
 
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to connect to WMI CONTROL service status:%d\n",
+		wmi_err("Failed to connect to WMI CONTROL service status:%d",
 			 status);
 		return status;
 	}

wmi/src/wmi_unified_action_oui_tlv.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2018, 2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -17,6 +17,7 @@
  */
 
 #include "wmi_unified_action_oui_tlv.h"
+#include "wmi_unified_priv.h"
 
 bool wmi_get_action_oui_id(enum action_oui_id action_id,
 			   wmi_vendor_oui_action_id *id)
@@ -126,7 +127,7 @@ wmi_fill_oui_extensions_buffer(struct action_oui_extension *extension,
 
 	for (i = 0; i < (uint8_t)no_oui_extns; i++) {
 		if ((rem_var_buf_len - cmd_ext->buf_data_length) < 0) {
-			WMI_LOGE(FL("Invalid action oui command length"));
+			wmi_err("Invalid action oui command length");
 			return QDF_STATUS_E_INVAL;
 		}
 
@@ -197,7 +198,7 @@ send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
 	QDF_STATUS status;
 
 	if (!req) {
-		WMI_LOGE(FL("action oui is empty"));
+		wmi_err("action oui is empty");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -211,13 +212,13 @@ send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
 	    no_oui_extns > WMI_MAX_VENDOR_OUI_ACTION_SUPPORTED_PER_ACTION ||
 	    (total_no_oui_extns > WMI_VENDOR_OUI_ACTION_MAX_ACTION_ID *
 	     WMI_MAX_VENDOR_OUI_ACTION_SUPPORTED_PER_ACTION)) {
-		WMI_LOGE(FL("Invalid number of action oui extensions"));
+		wmi_err("Invalid number of action oui extensions");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	valid = wmi_get_action_oui_id(req->action_id, &action_id);
 	if (!valid) {
-		WMI_LOGE(FL("Invalid action id"));
+		wmi_err("Invalid action id");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -242,7 +243,7 @@ send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
 
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE(FL("Failed to allocate wmi buffer"));
+		wmi_err("Failed to allocate wmi buffer");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -281,7 +282,7 @@ send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_PDEV_CONFIG_VENDOR_OUI_ACTION_CMDID)) {
-		WMI_LOGE(FL("WMI_PDEV_CONFIG_VENDOR_OUI_ACTION send fail"));
+		wmi_err("WMI_PDEV_CONFIG_VENDOR_OUI_ACTION send fail");
 		wmi_buf_free(wmi_buf);
 		wmi_buf = NULL;
 		return QDF_STATUS_E_FAILURE;

wmi/src/wmi_unified_apf_tlv.c

@@ -41,7 +41,7 @@ QDF_STATUS wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
 	/* allocate command buffer */
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -58,7 +58,7 @@ QDF_STATUS wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				      WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID:%d",
+		wmi_err("Failed to send WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID:%d",
 			 status);
 		wmi_buf_free(buf);
 		return status;
@@ -90,8 +90,7 @@ QDF_STATUS wmi_send_apf_enable_cmd_tlv(wmi_unified_t wmi_handle,
 
 	if (wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				 WMI_BPF_SET_VDEV_ENABLE_CMDID)) {
-		WMI_LOGE("%s: Failed to enable/disable APF interpreter",
-			 __func__);
+		wmi_err("Failed to enable/disable APF interpreter");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -148,7 +147,7 @@ wmi_send_apf_write_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
 
 	if (wmi_unified_cmd_send(wmi_handle, buf, wmi_buf_len,
 				 WMI_BPF_SET_VDEV_WORK_MEMORY_CMDID)) {
-		WMI_LOGE("%s: Failed to write APF work memory", __func__);
+		wmi_err("Failed to write APF work memory");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -183,7 +182,7 @@ wmi_send_apf_read_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
 
 	if (wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				 WMI_BPF_GET_VDEV_WORK_MEMORY_CMDID)) {
-		WMI_LOGE("%s: Failed to get APF work memory", __func__);
+		wmi_err("Failed to get APF work memory");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -202,7 +201,7 @@ wmi_extract_apf_read_memory_resp_event_tlv(wmi_unified_t wmi_handle,
 
 	param_buf = evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("encrypt decrypt resp evt_buf is NULL");
+		wmi_err("encrypt decrypt resp evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -213,7 +212,7 @@ wmi_extract_apf_read_memory_resp_event_tlv(wmi_unified_t wmi_handle,
 	resp->more_data = data_event->fragment;
 
 	if (data_event->length > param_buf->num_data) {
-		WMI_LOGE("FW msg data_len %d more than TLV hdr %d",
+		wmi_err("FW msg data_len %d more than TLV hdr %d",
 			 data_event->length,
 			 param_buf->num_data);
 		return QDF_STATUS_E_INVAL;

wmi/src/wmi_unified_bcn_tlv.c

@@ -1,6 +1,5 @@
-
 /*
- * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -56,7 +55,7 @@ static QDF_STATUS send_bcn_buf_ll_cmd_tlv(
 				   WMI_PDEV_SEND_BCN_CMDID);
 
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to send WMI_PDEV_SEND_BCN_CMDID command");
+		wmi_err("Failed to send WMI_PDEV_SEND_BCN_CMDID command");
 		wmi_buf_free(wmi_buf);
 	}
 

wmi/src/wmi_unified_cfr_tlv.c

@@ -32,13 +32,13 @@ extract_cfr_peer_tx_event_param_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 
 	param_buf = (WMI_PEER_CFR_CAPTURE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid cfr capture buffer");
+		wmi_err("Invalid cfr capture buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	peer_tx_event_ev = param_buf->fixed_param;
 	if (!peer_tx_event_ev) {
-		WMI_LOGE("peer cfr capture buffer is null");
+		wmi_err("peer cfr capture buffer is null");
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
@@ -144,7 +144,7 @@ static QDF_STATUS send_cfr_rcc_cmd_tlv(wmi_unified_t wmi_handle,
 	buf = wmi_buf_alloc(wmi_handle, len);
 
 	if (!buf) {
-		WMI_LOGE("%s:wmi_buf_alloc failed\n", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -245,7 +245,7 @@ static QDF_STATUS send_peer_cfr_capture_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_PEER_CFR_CAPTURE_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to send WMI_PEER_CFR_CAPTURE_CMDID");
+		wmi_err("Failed to send WMI_PEER_CFR_CAPTURE_CMDID");
 		wmi_buf_free(buf);
 	}
 

wmi/src/wmi_unified_concurrency_tlv.c

@@ -102,9 +102,9 @@ static QDF_STATUS send_set_mcc_channel_time_latency_cmd_tlv(
 	 */
 	if ((latency_chan1 > 0) &&
 	    (latency_chan1 < WMI_MCC_MIN_NON_ZERO_CHANNEL_LATENCY)) {
-		WMI_LOGE("%s: Invalid time latency for Channel #1 = %dms "
+		wmi_err("Invalid time latency for Channel #1 = %dms "
 			 "Minimum is 30ms (or 0 to use default value by "
-			 "firmware)", __func__, latency_chan1);
+			 "firmware)", latency_chan1);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -136,8 +136,7 @@ static QDF_STATUS send_set_mcc_channel_time_latency_cmd_tlv(
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_RESMGR_SET_CHAN_LATENCY_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("%s: Failed to send MCC Channel Time Latency command",
-			 __func__);
+		wmi_err("Failed to send MCC Channel Time Latency command");
 		wmi_buf_free(buf);
 		QDF_ASSERT(0);
 	}
@@ -184,8 +183,8 @@ static QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(
 	 */
 	if (quota_chan1 < WMI_MCC_MIN_CHANNEL_QUOTA ||
 	    quota_chan1 > WMI_MCC_MAX_CHANNEL_QUOTA) {
-		WMI_LOGE("%s: Invalid time quota for Channel #1=%dms. Minimum "
-			 "is 20ms & maximum is 80ms", __func__, quota_chan1);
+		wmi_err("Invalid time quota for Channel #1=%dms. Minimum "
+			 "is 20ms & maximum is 80ms", quota_chan1);
 		return QDF_STATUS_E_INVAL;
 	}
 	/* Set WMI CMD for channel time quota here */
@@ -223,7 +222,7 @@ static QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to send MCC Channel Time Quota command");
+		wmi_err("Failed to send MCC Channel Time Quota command");
 		wmi_buf_free(buf);
 		QDF_ASSERT(0);
 	}

wmi/src/wmi_unified_cp_stats_tlv.c

@@ -62,7 +62,7 @@ send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
 					  WMI_REQUEST_STATS_CMDID);
 
 	if (ret) {
-		WMI_LOGE("Failed to send status request to fw =%d", ret);
+		wmi_err("Failed to send status request to fw =%d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -92,12 +92,12 @@ extract_all_stats_counts_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 	ev = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
 	rssi_event = param_buf->chain_stats;
 	if (!ev) {
-		WMI_LOGE("%s: event fixed param NULL", __func__);
+		wmi_err("event fixed param NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (param_buf->num_data > WMI_SVC_MSG_MAX_SIZE - sizeof(*ev)) {
-		WMI_LOGE("num_data : %u is invalid", param_buf->num_data);
+		wmi_err("num_data : %u is invalid", param_buf->num_data);
 		return QDF_STATUS_E_FAULT;
 	}
 
@@ -169,7 +169,7 @@ extract_all_stats_counts_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 		(((uint64_t)ev->num_mib_extd_stats) *
 		 sizeof(wmi_mib_extd_stats));
 	if (param_buf->num_data != min_data_len) {
-		WMI_LOGE("data len: %u isn't same as calculated: %llu",
+		wmi_err("data len: %u isn't same as calculated: %llu",
 			 param_buf->num_data, min_data_len);
 		return QDF_STATUS_E_FAULT;
 	}
@@ -203,7 +203,7 @@ extract_all_stats_counts_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 
 	if (rssi_event->num_per_chain_rssi_stats >=
 	    WMITLV_GET_TLVLEN(rssi_event->tlv_header)) {
-		WMI_LOGE("num_per_chain_rssi_stats:%u is out of bounds",
+		wmi_err("num_per_chain_rssi_stats:%u is out of bounds",
 			 rssi_event->num_per_chain_rssi_stats);
 		return QDF_STATUS_E_INVAL;
 	}

wmi/src/wmi_unified_dbr_tlv.c

@@ -40,7 +40,7 @@ static QDF_STATUS send_dbr_cfg_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE(FL("wmi_buf_alloc failed"));
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -79,7 +79,7 @@ static QDF_STATUS send_dbr_cfg_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_PDEV_DMA_RING_CFG_REQ_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL(":wmi cmd send failed"));
+		wmi_err(":wmi cmd send failed");
 		wmi_buf_free(buf);
 	}
 
@@ -153,7 +153,7 @@ static QDF_STATUS extract_dbr_buf_release_entry_tlv(wmi_unified_t wmi_handle,
 	entry = &param_buf->entries[idx];
 
 	if (!entry) {
-		WMI_LOGE("%s: Entry is NULL", __func__);
+		wmi_err("Entry is NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -179,7 +179,7 @@ static QDF_STATUS extract_dbr_buf_metadata_tlv(
 	entry = &param_buf->meta_data[idx];
 
 	if (!entry) {
-		WMI_LOGE("%s: Entry is NULL", __func__);
+		wmi_err("Entry is NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 

wmi/src/wmi_unified_dcs_tlv.c

@@ -35,12 +35,12 @@ static QDF_STATUS extract_dcs_interference_type_tlv(
 
 	param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid dcs interference event buffer");
+		wmi_err("Invalid dcs interference event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (!param_buf->fixed_param) {
-		WMI_LOGE("Invalid fixed param");
+		wmi_err("Invalid fixed param");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -71,13 +71,13 @@ static QDF_STATUS extract_dcs_im_tgt_stats_tlv(
 
 	param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid dcs interference event buffer");
+		wmi_err("Invalid dcs interference event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	ev = param_buf->wlan_stat;
 	if (!ev) {
-		WMI_LOGE("Invalid wlan stat");
+		wmi_err("Invalid wlan stat");
 		return QDF_STATUS_E_INVAL;
 	}
 

wmi/src/wmi_unified_extscan_tlv.c

@@ -42,7 +42,7 @@ static QDF_STATUS send_reset_passpoint_network_list_cmd_tlv
 	len = sizeof(*cmd);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
+		wmi_err("Failed allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -57,8 +57,7 @@ static QDF_STATUS send_reset_passpoint_network_list_cmd_tlv
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_PASSPOINT_LIST_CONFIG_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to send reset passpoint network list wmi cmd",
-			 __func__);
+		wmi_err("Failed to send reset passpoint network list wmi cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -90,7 +89,7 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
 	for (i = 0; i < req->num_networks; i++) {
 		buf = wmi_buf_alloc(wmi_handle, len);
 		if (!buf) {
-			WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
+			wmi_err("Failed allocate wmi buffer");
 			return QDF_STATUS_E_NOMEM;
 		}
 
@@ -124,8 +123,7 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 					   WMI_PASSPOINT_LIST_CONFIG_CMDID);
 		if (ret) {
-			WMI_LOGE("%s: Failed to send set passpoint network list wmi cmd",
-				 __func__);
+			wmi_err("Failed to send set passpoint network list wmi cmd");
 			wmi_buf_free(buf);
 			return QDF_STATUS_E_FAILURE;
 		}
@@ -173,7 +171,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
+		wmi_err("Failed allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -270,7 +268,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 			WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__);
+		wmi_err("Failed to send nlo wmi cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -301,7 +299,7 @@ static QDF_STATUS send_extscan_get_capabilities_cmd_tlv(wmi_unified_t wmi_handle
 	len = sizeof(*cmd);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 	buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
@@ -316,7 +314,7 @@ static QDF_STATUS send_extscan_get_capabilities_cmd_tlv(wmi_unified_t wmi_handle
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_EXTSCAN_GET_CAPABILITIES_CMDID)) {
-		WMI_LOGE("%s: failed to  command", __func__);
+		wmi_err("Failed to send extscan get capabilities cmd");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -343,7 +341,7 @@ static QDF_STATUS send_extscan_get_cached_results_cmd_tlv(wmi_unified_t wmi_hand
 	len = sizeof(*cmd);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 	buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
@@ -360,7 +358,7 @@ static QDF_STATUS send_extscan_get_cached_results_cmd_tlv(wmi_unified_t wmi_hand
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID)) {
-		WMI_LOGE("%s: failed to  command", __func__);
+		wmi_err("failed to  command", __func__);
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -393,7 +391,7 @@ static QDF_STATUS send_extscan_stop_change_monitor_cmd_tlv
 	len += change_list * sizeof(wmi_extscan_wlan_change_bssid_param);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 	buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
@@ -420,7 +418,7 @@ static QDF_STATUS send_extscan_stop_change_monitor_cmd_tlv
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 			 WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
-		WMI_LOGE("%s: failed to  command", __func__);
+		wmi_err("Failed to send extscan change monitor cmd");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -452,7 +450,7 @@ static QDF_STATUS wmi_get_buf_extscan_change_monitor_cmd
 	struct ap_threshold_params *src_ap = psigchange->ap;
 
 	if (!numap || (numap > WMI_WLAN_EXTSCAN_MAX_SIGNIFICANT_CHANGE_APS)) {
-		WMI_LOGE("%s: Invalid number of bssid's", __func__);
+		wmi_err("Invalid number of bssid's");
 		return QDF_STATUS_E_INVAL;
 	}
 	len += WMI_TLV_HDR_SIZE;
@@ -534,17 +532,16 @@ static QDF_STATUS send_extscan_start_change_monitor_cmd_tlv
 			     psigchange, &buf,
 			     &len);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: Failed to get buffer for change monitor cmd",
-			 __func__);
+		wmi_err("Failed to get buffer for change monitor cmd");
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (!buf) {
-		WMI_LOGE("%s: Failed to get buffer", __func__);
+		wmi_err("Failed to get buffer");
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 		 WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
-		WMI_LOGE("%s: failed to send command", __func__);
+		wmi_err("Failed to send command");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -578,7 +575,7 @@ static QDF_STATUS send_extscan_stop_hotlist_monitor_cmd_tlv
 
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -603,7 +600,7 @@ static QDF_STATUS send_extscan_stop_hotlist_monitor_cmd_tlv
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID)) {
-		WMI_LOGE("%s: failed to  command", __func__);
+		wmi_err("Failed to send extscan cfg hotlist cmd");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -630,7 +627,7 @@ static QDF_STATUS send_stop_extscan_cmd_tlv(wmi_unified_t wmi_handle,
 	len = sizeof(*cmd);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
 	if (!wmi_buf) {
-		WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 	buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
@@ -645,7 +642,7 @@ static QDF_STATUS send_stop_extscan_cmd_tlv(wmi_unified_t wmi_handle,
 
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_EXTSCAN_STOP_CMDID)) {
-		WMI_LOGE("%s: failed to  command", __func__);
+		wmi_err("Failed to send extscan stop cmd");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -915,17 +912,16 @@ static QDF_STATUS send_start_extscan_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_status = wmi_get_buf_extscan_start_cmd(wmi_handle,
 			     pstart, &buf, &len);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: Failed to get buffer for ext scan cmd", __func__);
+		wmi_err("Failed to get buffer for ext scan cmd");
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (!buf) {
-		WMI_LOGE("%s:Failed to get buffer for current extscan info",
-			__func__);
+		wmi_err("Failed to get buffer for current extscan info");
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (wmi_unified_cmd_send(wmi_handle, buf,
 				 len, WMI_EXTSCAN_START_CMDID)) {
-		WMI_LOGE("%s: failed to send command", __func__);
+		wmi_err("Failed to send extscan start cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -996,7 +992,7 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
 	 * to be non zero value
 	 */
 	if (!numap || (numap > WMI_WLAN_EXTSCAN_MAX_HOTLIST_APS)) {
-		WMI_LOGE("Invalid number of APs: %d", numap);
+		wmi_err("Invalid number of APs: %d", numap);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1070,7 +1066,7 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
 
 		if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID)) {
-			WMI_LOGE("%s: failed to send command", __func__);
+			wmi_err("Failed to send extscan cfg hotlist monitor cmd");
 			wmi_buf_free(buf);
 			return QDF_STATUS_E_FAILURE;
 		}

wmi/src/wmi_unified_fwol_tlv.c

@@ -43,7 +43,7 @@ send_set_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s: Failed to allocate wmi buffer", __func__);
+		wmi_err("Failed to allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -58,7 +58,7 @@ send_set_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_SET_ELNA_BYPASS_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to send set param command ret = %d", ret);
+		wmi_err("Failed to send set param command ret = %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -85,7 +85,7 @@ send_get_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s: Failed to allocate wmi buffer", __func__);
+		wmi_err("Failed to allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -99,7 +99,7 @@ send_get_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_GET_ELNA_BYPASS_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to send set param command ret = %d", ret);
+		wmi_err("Failed to send set param command ret = %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -126,7 +126,7 @@ extract_get_elna_bypass_resp_tlv(struct wmi_unified *wmi_handle, void *resp_buf,
 	param_buf = resp_buf;
 	evt = param_buf->fixed_param;
 	if (!evt) {
-		WMI_LOGE("Invalid get elna bypass event");
+		wmi_err("Invalid get elna bypass event");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -173,7 +173,7 @@ send_dscp_tid_map_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s: Failed to allocate wmi buffer", __func__);
+		wmi_err("Failed to allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -190,7 +190,7 @@ send_dscp_tid_map_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_PDEV_SET_DSCP_TID_MAP_CMDID);
 	if (status) {
-		WMI_LOGE("Failed to send dscp_up_map_to_fw %d", status);
+		wmi_err("Failed to send dscp_up_map_to_fw %d", status);
 		wmi_buf_free(buf);
 	}
 

wmi/src/wmi_unified_nan_tlv.c

@@ -58,8 +58,8 @@ extract_nan_event_rsp_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 
 	/* Actual data may include some padding, so data_len <= num_data */
 	if (nan_rsp_event_hdr->data_len > event->num_data) {
-		WMI_LOGE("%s: Provided NAN event length(%d) exceeding actual length(%d)!",
-			 __func__, nan_rsp_event_hdr->data_len,
+		wmi_err("Provided NAN event length(%d) exceeding actual length(%d)!",
+			 nan_rsp_event_hdr->data_len,
 			 event->num_data);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -69,7 +69,7 @@ extract_nan_event_rsp_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 	if (nan_rsp_event_hdr->data_len < sizeof(nan_msg_header_t) ||
 	    nan_rsp_event_hdr->data_len > (WMI_SVC_MSG_MAX_SIZE -
 							    WMI_TLV_HDR_SIZE)) {
-		WMI_LOGE("%s: Invalid NAN event data length(%d)!",  __func__,
+		wmi_err("Invalid NAN event data length(%d)!",
 			 nan_rsp_event_hdr->data_len);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -85,7 +85,7 @@ extract_nan_event_rsp_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 	case NAN_MSG_ID_ENABLE_RSP:
 		nan_evt_info = event->event_info;
 		if (!nan_evt_info) {
-			WMI_LOGE(FL("Fail: NAN enable rsp event info Null"));
+			wmi_err("Fail: NAN enable rsp event info Null");
 			return QDF_STATUS_E_INVAL;
 		}
 		evt_params->evt_type = nan_event_id_enable_rsp;
@@ -153,7 +153,7 @@ static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle,
 	 */
 
 	if (!nan_msg) {
-		WMI_LOGE("%s:nan req is not valid", __func__);
+		wmi_err("nan req is not valid");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -162,15 +162,13 @@ static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle,
 	if (nan_data_len) {
 		nan_data_len_aligned = roundup(nan_data_len, sizeof(uint32_t));
 		if (nan_data_len_aligned < nan_data_len) {
-			WMI_LOGE("%s: Int overflow while rounding up data_len",
-				 __func__);
+			wmi_err("Int overflow while rounding up data_len");
 			return QDF_STATUS_E_FAILURE;
 		}
 
 		if (nan_data_len_aligned > WMI_SVC_MSG_MAX_SIZE
 							- WMI_TLV_HDR_SIZE) {
-			WMI_LOGE("%s: nan_data_len exceeding wmi_max_msg_size",
-				 __func__);
+			wmi_err("nan_data_len exceeding wmi_max_msg_size");
 			return QDF_STATUS_E_FAILURE;
 		}
 
@@ -215,8 +213,7 @@ static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_NAN_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("%s Failed to send set param command ret = %d",
-			 __func__, ret);
+		wmi_err("Failed to send set param command ret = %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -253,21 +250,19 @@ static QDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle,
 	 *    +-----------------------+------------------------------------+
 	 */
 	if (!nan_msg) {
-		WMI_LOGE("%s:nan req is not valid", __func__);
+		wmi_err("nan req is not valid");
 		return QDF_STATUS_E_FAILURE;
 	}
 	nan_data_len = nan_msg->request_data_len;
 	nan_data_len_aligned = roundup(nan_msg->request_data_len,
 				       sizeof(uint32_t));
 	if (nan_data_len_aligned < nan_msg->request_data_len) {
-		WMI_LOGE("%s: integer overflow while rounding up data_len",
-			 __func__);
+		wmi_err("integer overflow while rounding up data_len");
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (nan_data_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) {
-		WMI_LOGE("%s: wmi_max_msg_size overflow for given datalen",
-			 __func__);
+		wmi_err("wmi_max_msg_size overflow for given datalen");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -305,8 +300,7 @@ static QDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_NAN_CMDID, NO_SESSION, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_NAN_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("%s Failed to send NAN req command ret = %d",
-			 __func__, ret);
+		wmi_err("Failed to send NAN req command ret = %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -347,7 +341,7 @@ static QDF_STATUS send_terminate_all_ndps_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_NDP_CMDID, NO_SESSION, 0);
 	status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len, WMI_NDP_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send NDP Terminate cmd: %d", status);
+		wmi_err("Failed to send NDP Terminate cmd: %d", status);
 		wmi_buf_free(wmi_buf);
 	}
 
@@ -468,7 +462,7 @@ static QDF_STATUS nan_ndp_initiator_req_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_NDP_INITIATOR_REQ_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("WMI_NDP_INITIATOR_REQ_CMDID failed, ret: %d", status);
+		wmi_err("WMI_NDP_INITIATOR_REQ_CMDID failed, ret: %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -590,7 +584,7 @@ static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_NDP_RESPONDER_REQ_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d", status);
+		wmi_err("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d", status);
 		wmi_buf_free(buf);
 	}
 	return status;
@@ -640,7 +634,7 @@ static QDF_STATUS nan_ndp_end_req_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_NDP_END_REQ_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("WMI_NDP_END_REQ_CMDID failed, ret: %d", status);
+		wmi_err("WMI_NDP_END_REQ_CMDID failed, ret: %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -662,7 +656,7 @@ extract_ndp_host_event_tlv(wmi_unified_t wmi_handle, uint8_t *data,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!evt->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -686,7 +680,7 @@ static QDF_STATUS extract_ndp_initiator_rsp_tlv(wmi_unified_t wmi_handle,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!rsp->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -733,20 +727,20 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 		(wmi_ndp_indication_event_fixed_param *)event->fixed_param;
 
 	if (fixed_params->ndp_cfg_len > event->num_ndp_cfg) {
-		WMI_LOGE("FW message ndp cfg length %d larger than TLV hdr %d",
+		wmi_err("FW message ndp cfg length %d larger than TLV hdr %d",
 			 fixed_params->ndp_cfg_len, event->num_ndp_cfg);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (fixed_params->ndp_app_info_len > event->num_ndp_app_info) {
-		WMI_LOGE("FW message ndp app info length %d more than TLV hdr %d",
+		wmi_err("FW message ndp app info length %d more than TLV hdr %d",
 			 fixed_params->ndp_app_info_len,
 			 event->num_ndp_app_info);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (fixed_params->nan_scid_len > event->num_ndp_scid) {
-		WMI_LOGE("FW msg ndp scid info len %d more than TLV hdr %d",
+		wmi_err("FW msg ndp scid info len %d more than TLV hdr %d",
 			 fixed_params->nan_scid_len,
 			 event->num_ndp_scid);
 		return QDF_STATUS_E_INVAL;
@@ -754,8 +748,8 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 
 	if (fixed_params->ndp_cfg_len >
 		(WMI_SVC_MSG_MAX_SIZE - sizeof(*fixed_params))) {
-		WMI_LOGE("%s: excess wmi buffer: ndp_cfg_len %d",
-			 __func__, fixed_params->ndp_cfg_len);
+		wmi_err("excess wmi buffer: ndp_cfg_len %d",
+			fixed_params->ndp_cfg_len);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -764,16 +758,16 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 
 	if (fixed_params->ndp_app_info_len >
 		(WMI_SVC_MSG_MAX_SIZE - total_array_len)) {
-		WMI_LOGE("%s: excess wmi buffer: ndp_cfg_len %d",
-			 __func__, fixed_params->ndp_app_info_len);
+		wmi_err("excess wmi buffer: ndp_cfg_len %d",
+			fixed_params->ndp_app_info_len);
 		return QDF_STATUS_E_INVAL;
 	}
 	total_array_len += fixed_params->ndp_app_info_len;
 
 	if (fixed_params->nan_scid_len >
 		(WMI_SVC_MSG_MAX_SIZE - total_array_len)) {
-		WMI_LOGE("%s: excess wmi buffer: ndp_cfg_len %d",
-			 __func__, fixed_params->nan_scid_len);
+		wmi_err("excess wmi buffer: ndp_cfg_len %d",
+			fixed_params->nan_scid_len);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -782,7 +776,7 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!rsp->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 	rsp->service_instance_id = fixed_params->service_instance_id;
@@ -867,13 +861,13 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 		 fixed_params->num_ndp_channels);
 
 	if (fixed_params->ndp_cfg_len > event->num_ndp_cfg) {
-		WMI_LOGE("FW message ndp cfg length %d larger than TLV hdr %d",
+		wmi_err("FW message ndp cfg length %d larger than TLV hdr %d",
 			 fixed_params->ndp_cfg_len, event->num_ndp_cfg);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (fixed_params->ndp_app_info_len > event->num_ndp_app_info) {
-		WMI_LOGE("FW message ndp app info length %d more than TLV hdr %d",
+		wmi_err("FW message ndp app info length %d more than TLV hdr %d",
 			 fixed_params->ndp_app_info_len,
 			 event->num_ndp_app_info);
 		return QDF_STATUS_E_INVAL;
@@ -884,8 +878,8 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 
 	if (fixed_params->ndp_cfg_len >
 			(WMI_SVC_MSG_MAX_SIZE - sizeof(*fixed_params))) {
-		WMI_LOGE("%s: excess wmi buffer: ndp_cfg_len %d",
-			 __func__, fixed_params->ndp_cfg_len);
+		wmi_err("excess wmi buffer: ndp_cfg_len %d",
+			fixed_params->ndp_cfg_len);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -894,14 +888,14 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 
 	if (fixed_params->ndp_app_info_len >
 		(WMI_SVC_MSG_MAX_SIZE - total_array_len)) {
-		WMI_LOGE("%s: excess wmi buffer: ndp_cfg_len %d",
-			 __func__, fixed_params->ndp_app_info_len);
+		wmi_err("excess wmi buffer: ndp_cfg_len %d",
+			fixed_params->ndp_app_info_len);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (fixed_params->num_ndp_channels > event->num_ndp_channel_list ||
 	    fixed_params->num_ndp_channels > event->num_nss_list) {
-		WMI_LOGE(FL("NDP Ch count %d greater than NDP Ch TLV len(%d) or NSS TLV len(%d)"),
+		wmi_err("NDP Ch count %d greater than NDP Ch TLV len(%d) or NSS TLV len(%d)",
 			 fixed_params->num_ndp_channels,
 			 event->num_ndp_channel_list,
 			 event->num_nss_list);
@@ -910,7 +904,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 
 	if (ndi_dbs &&
 	    fixed_params->num_ndp_channels > event->num_ndp_channel_info) {
-		WMI_LOGE(FL("NDP Ch count %d greater than NDP Ch info(%d)"),
+		wmi_err("NDP Ch count %d greater than NDP Ch info(%d)",
 			 fixed_params->num_ndp_channels,
 			 event->num_ndp_channel_info);
 		return QDF_STATUS_E_INVAL;
@@ -921,7 +915,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!rsp->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 	rsp->ndp_instance_id = fixed_params->ndp_instance_id;
@@ -936,7 +930,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 		     rsp->ndp_info.ndp_app_info_len);
 
 	if (rsp->num_channels > NAN_CH_INFO_MAX_CHANNELS) {
-		WMI_LOGE(FL("too many channels"));
+		wmi_err("too many channels");
 		rsp->num_channels = NAN_CH_INFO_MAX_CHANNELS;
 	}
 
@@ -1000,7 +994,7 @@ static QDF_STATUS extract_ndp_responder_rsp_tlv(wmi_unified_t wmi_handle,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!rsp->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 	rsp->transaction_id = fixed_params->transaction_id;
@@ -1033,7 +1027,7 @@ static QDF_STATUS extract_ndp_end_rsp_tlv(wmi_unified_t wmi_handle,
 	rsp->vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(
 			wmi_handle->soc->wmi_psoc, QDF_NDI_MODE, WLAN_NAN_ID);
 	if (!rsp->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 	rsp->transaction_id = fixed_params->transaction_id;
@@ -1055,7 +1049,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
 	ind = event->ndp_end_indication_list;
 
 	if (event->num_ndp_end_indication_list == 0) {
-		WMI_LOGE("Error: Event ignored, 0 ndp instances");
+		wmi_err("Error: Event ignored, 0 ndp instances");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1064,7 +1058,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
 
 	if (event->num_ndp_end_indication_list > ((UINT_MAX - sizeof(**rsp))/
 						sizeof((*rsp)->ndp_map[0]))) {
-		WMI_LOGE("num_ndp_end_ind_list %d too large",
+		wmi_err("num_ndp_end_ind_list %d too large",
 			 event->num_ndp_end_indication_list);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -1116,7 +1110,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 
 	if (fixed_params->num_channels > event->num_ndl_channel_list ||
 	    fixed_params->num_channels > event->num_nss_list) {
-		WMI_LOGE(FL("Channel count %d greater than NDP Ch list TLV len(%d) or NSS list TLV len(%d)"),
+		wmi_err("Channel count %d greater than NDP Ch list TLV len(%d) or NSS list TLV len(%d)",
 			 fixed_params->num_channels,
 			 event->num_ndl_channel_list,
 			 event->num_nss_list);
@@ -1125,14 +1119,14 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 
 	if (ndi_dbs &&
 	    fixed_params->num_channels > event->num_ndp_channel_info) {
-		WMI_LOGE(FL("Channel count %d greater than NDP Ch info(%d)"),
+		wmi_err("Channel count %d greater than NDP Ch info(%d)",
 			 fixed_params->num_channels,
 			 event->num_ndp_channel_info);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (fixed_params->num_ndp_instances > event->num_ndp_instance_list) {
-		WMI_LOGE(FL("NDP Instance count %d greater than NDP Instancei TLV len %d"),
+		wmi_err("NDP Instance count %d greater than NDP Instancei TLV len %d",
 			 fixed_params->num_ndp_instances,
 			 event->num_ndp_instance_list);
 		return QDF_STATUS_E_INVAL;
@@ -1143,7 +1137,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 						     fixed_params->vdev_id,
 						     WLAN_NAN_ID);
 	if (!ind->vdev) {
-		WMI_LOGE("vdev is null");
+		wmi_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1154,7 +1148,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 				   ind->peer_addr.bytes);
 
 	if (ind->num_ndp_instances > NDP_NUM_INSTANCE_ID) {
-		WMI_LOGE(FL("uint32 overflow"));
+		wmi_err("uint32 overflow");
 		wlan_objmgr_vdev_release_ref(ind->vdev, WLAN_NAN_ID);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -1163,7 +1157,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 		     sizeof(uint32_t) * ind->num_ndp_instances);
 
 	if (ind->num_channels > NAN_CH_INFO_MAX_CHANNELS) {
-		WMI_LOGE(FL("too many channels"));
+		wmi_err("too many channels");
 		ind->num_channels = NAN_CH_INFO_MAX_CHANNELS;
 	}
 

wmi/src/wmi_unified_ocb_tlv.c

@@ -61,7 +61,7 @@ static QDF_STATUS send_ocb_set_utc_time_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_OCB_SET_UTC_TIME_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to set OCB UTC time"));
+		wmi_err("Failed to set OCB UTC time");
 		wmi_buf_free(buf);
 	}
 
@@ -124,7 +124,7 @@ static QDF_STATUS send_ocb_start_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_OCB_START_TIMING_ADVERT_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to start OCB timing advert"));
+		wmi_err("Failed to start OCB timing advert");
 		wmi_buf_free(buf);
 	}
 
@@ -167,7 +167,7 @@ static QDF_STATUS send_ocb_stop_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_OCB_STOP_TIMING_ADVERT_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to stop OCB timing advert"));
+		wmi_err("Failed to stop OCB timing advert");
 		wmi_buf_free(buf);
 	}
 
@@ -211,7 +211,7 @@ static QDF_STATUS send_ocb_get_tsf_timer_cmd_tlv(wmi_unified_t wmi_handle,
 				   WMI_OCB_GET_TSF_TIMER_CMDID);
 	/* If there is an error, set the completion event */
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to send WMI message: %d"), ret);
+		wmi_err("Failed to send WMI message: %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -239,7 +239,7 @@ static QDF_STATUS send_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
 	/* Validate the input */
 	if (get_stats_param->request_array_len !=
 	    get_stats_param->channel_count * sizeof(*channel_stats_array)) {
-		WMI_LOGE(FL("Invalid parameter"));
+		wmi_err("Invalid parameter");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -285,7 +285,7 @@ static QDF_STATUS send_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
 				   WMI_DCC_GET_STATS_CMDID);
 
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to send WMI message: %d"), ret);
+		wmi_err("Failed to send WMI message: %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -335,7 +335,7 @@ static QDF_STATUS send_dcc_clear_stats_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_DCC_CLEAR_STATS_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to send the WMI command"));
+		wmi_err("Failed to send the WMI command");
 		wmi_buf_free(buf);
 	}
 
@@ -365,7 +365,7 @@ static QDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
 	/* validate the input */
 	if (update_ndl_param->dcc_ndl_chan_list_len !=
 	    update_ndl_param->channel_count * sizeof(*ndl_chan_array)) {
-		WMI_LOGE(FL("Invalid parameter"));
+		wmi_err("Invalid parameter");
 		return QDF_STATUS_E_INVAL;
 	}
 	active_state_count = 0;
@@ -375,7 +375,7 @@ static QDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
 			WMI_NDL_NUM_ACTIVE_STATE_GET(&ndl_chan_array[i]);
 	if (update_ndl_param->dcc_ndl_active_state_list_len !=
 	    active_state_count * sizeof(*ndl_active_state_array)) {
-		WMI_LOGE(FL("Invalid parameter"));
+		wmi_err("Invalid parameter");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -440,7 +440,7 @@ static QDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
 					  WMI_DCC_UPDATE_NDL_CMDID);
 	/* If there is an error, set the completion event */
 	if (QDF_IS_STATUS_ERROR(qdf_status)) {
-		WMI_LOGE(FL("Failed to send WMI message: %d"), qdf_status);
+		wmi_err("Failed to send WMI message: %d", qdf_status);
 		wmi_buf_free(buf);
 	}
 
@@ -479,7 +479,7 @@ static QDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
 		if (!config->dcc_ndl_chan_list ||
 			config->dcc_ndl_chan_list_len !=
 			config->channel_count * sizeof(wmi_dcc_ndl_chan)) {
-			WMI_LOGE(FL("NDL channel is invalid. List len: %d"),
+			wmi_err("NDL channel is invalid. List len: %d",
 				 config->dcc_ndl_chan_list_len);
 			return QDF_STATUS_E_INVAL;
 		}
@@ -494,7 +494,7 @@ static QDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
 				config->dcc_ndl_active_state_list_len !=
 				active_state_count *
 				sizeof(wmi_dcc_ndl_active_state_config)) {
-				WMI_LOGE(FL("NDL active state is invalid."));
+				wmi_err("NDL active state is invalid");
 				return QDF_STATUS_E_INVAL;
 			}
 		}
@@ -646,7 +646,7 @@ static QDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_OCB_SET_CONFIG_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to set OCB config");
+		wmi_err("Failed to set OCB config");
 		wmi_buf_free(buf);
 	}
 

wmi/src/wmi_unified_p2p_api.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -47,7 +47,7 @@ QDF_STATUS wmi_extract_p2p_noa_ev_param(wmi_unified_t wmi_handle,
 					struct p2p_noa_info *param)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -63,7 +63,7 @@ wmi_send_set_mac_addr_rx_filter_cmd(wmi_unified_t wmi_handle,
 				    struct p2p_set_mac_filter *param)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -80,7 +80,7 @@ wmi_extract_mac_addr_rx_filter_evt_param(wmi_unified_t wmi_handle,
 					 struct p2p_set_mac_filter_evt *param)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -96,7 +96,7 @@ QDF_STATUS wmi_unified_p2p_lo_start_cmd(wmi_unified_t wmi_handle,
 					struct p2p_lo_start *param)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -111,7 +111,7 @@ QDF_STATUS wmi_unified_p2p_lo_stop_cmd(wmi_unified_t wmi_handle,
 				       uint8_t vdev_id)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -127,7 +127,7 @@ QDF_STATUS wmi_extract_p2p_lo_stop_ev_param(wmi_unified_t wmi_handle,
 					    struct p2p_lo_event *param)
 {
 	if (!wmi_handle) {
-		WMI_LOGE("wmi handle is null");
+		wmi_err("wmi handle is null");
 		return QDF_STATUS_E_INVAL;
 	}
 

wmi/src/wmi_unified_p2p_tlv.c

@@ -79,7 +79,7 @@ static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID");
+		wmi_err("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -125,7 +125,7 @@ static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				      WMI_P2P_SET_OPPPS_PARAM_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID");
+		wmi_err("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -155,12 +155,12 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 
 	param_tlvs = (WMI_P2P_NOA_EVENTID_param_tlvs *)evt_buf;
 	if (!param_tlvs) {
-		WMI_LOGE("%s: Invalid P2P NoA event buffer", __func__);
+		wmi_err("Invalid P2P NoA event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (!param) {
-		WMI_LOGE("noa information param is null");
+		wmi_err("noa information param is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -170,7 +170,7 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 	wmi_noa_info = (wmi_p2p_noa_info *) (buf_ptr);
 
 	if (!WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(wmi_noa_info)) {
-		WMI_LOGE("%s: noa attr is not modified", __func__);
+		wmi_err("noa attr is not modified");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -184,8 +184,7 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 	descriptors = WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(wmi_noa_info);
 	param->num_desc = (uint8_t)descriptors;
 	if (param->num_desc > WMI_P2P_MAX_NOA_DESCRIPTORS) {
-		WMI_LOGE("%s: invalid num desc:%d", __func__,
-			 param->num_desc);
+		wmi_err("Invalid num desc: %d", param->num_desc);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -223,14 +222,14 @@ send_set_mac_addr_rx_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	int ret;
 
 	if (!wmi_handle) {
-		WMI_LOGE("WMA context is invald!");
+		wmi_err("WMA context is invald!");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	len = sizeof(*cmd);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("Failed allocate wmi buffer");
+		wmi_err("Failed allocate wmi buffer");
 		return QDF_STATUS_E_NOMEM;
 	}
 
@@ -256,7 +255,7 @@ send_set_mac_addr_rx_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_CMDID);
 	if (ret) {
-		WMI_LOGE("Failed to send action frame random mac cmd");
+		wmi_err("Failed to send action frame random mac cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -275,12 +274,12 @@ static QDF_STATUS extract_mac_addr_rx_filter_evt_param_tlv(
 		(WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID_param_tlvs *)
 		evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid action frame filter mac event");
+		wmi_err("Invalid action frame filter mac event");
 		return QDF_STATUS_E_INVAL;
 	}
 	event = param_buf->fixed_param;
 	if (!event) {
-		WMI_LOGE("Invalid fixed param");
+		wmi_err("Invalid fixed param");
 		return QDF_STATUS_E_INVAL;
 	}
 	param->vdev_id = event->vdev_id;
@@ -309,7 +308,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 	int probe_resp_len_aligned;
 
 	if (!param) {
-		WMI_LOGE("lo start param is null");
+		wmi_err("lo start param is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -368,8 +367,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 				      buf, len,
 				      WMI_P2P_LISTEN_OFFLOAD_START_CMDID);
 	if (status != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: Failed to send p2p lo start: %d",
-			 __func__, status);
+		wmi_err("Failed to send p2p lo start: %d", status);
 		wmi_buf_free(buf);
 		return status;
 	}
@@ -416,8 +414,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
 				      buf, len,
 				      WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID);
 	if (status != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: Failed to send p2p lo stop: %d",
-			 __func__, status);
+		wmi_err("Failed to send p2p lo stop: %d", status);
 		wmi_buf_free(buf);
 		return status;
 	}
@@ -446,12 +443,12 @@ static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv(
 	param_tlvs = (WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *)
 					evt_buf;
 	if (!param_tlvs) {
-		WMI_LOGE("%s: Invalid P2P lo stop event buffer", __func__);
+		wmi_err("Invalid P2P lo stop event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (!param) {
-		WMI_LOGE("lo stop event param is null");
+		wmi_err("lo stop event param is null");
 		return QDF_STATUS_E_INVAL;
 	}
 

wmi/src/wmi_unified_pmo_tlv.c

@@ -149,7 +149,7 @@ static QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
 	if (ret) {
-		WMI_LOGE("Failed to config wow wakeup event");
+		wmi_err("Failed to config wow wakeup event");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -280,7 +280,7 @@ static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_WOW_ADD_WAKE_PATTERN_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to send wow ptrn to fw", __func__);
+		wmi_err("Failed to send wow ptrn to fw");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -553,7 +553,7 @@ static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
 	res = wmi_unified_cmd_send(wmi_handle, buf, len,
 				     WMI_SET_ARP_NS_OFFLOAD_CMDID);
 	if (res) {
-		WMI_LOGE("Failed to enable ARP NDP/NSffload");
+		wmi_err("Failed to enable ARP NDP/NSffload");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -605,7 +605,7 @@ static QDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
 				   sizeof(*cmd),
 				   WMI_SET_MCASTBCAST_FILTER_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send set_param cmd");
+		wmi_err("Failed to send set_param cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -682,7 +682,7 @@ send_cmd:
 				   len,
 				   WMI_SET_MULTIPLE_MCAST_FILTER_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send set_param cmd");
+		wmi_err("Failed to send set_param cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -698,7 +698,7 @@ static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
 	wmi_buf_t wmi_buf;
 
 	if (!req) {
-		WMI_LOGE("req is null");
+		wmi_err("req is null");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -727,7 +727,7 @@ static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
 	status = wmi_unified_cmd_send(wmi, wmi_buf, sizeof(*cmd),
 				      WMI_HW_DATA_FILTER_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to configure hw filter");
+		wmi_err("Failed to configure hw filter");
 		wmi_buf_free(wmi_buf);
 	}
 
@@ -824,7 +824,7 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
 	wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_GTK_OFFLOAD_CMDID)) {
-		WMI_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID");
+		wmi_err("Failed to send WMI_GTK_OFFLOAD_CMDID");
 		wmi_buf_free(buf);
 		status = QDF_STATUS_E_FAILURE;
 	}
@@ -874,7 +874,7 @@ static QDF_STATUS send_process_gtk_offload_getinfo_cmd_tlv(
 	wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_GTK_OFFLOAD_CMDID)) {
-		WMI_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID for req info");
+		wmi_err("Failed to send WMI_GTK_OFFLOAD_CMDID for req info");
 		wmi_buf_free(buf);
 		status = QDF_STATUS_E_FAILURE;
 	}
@@ -927,8 +927,7 @@ QDF_STATUS send_enable_enhance_multicast_offload_tlv(
 			sizeof(*cmd), WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID);
 	if (status != QDF_STATUS_SUCCESS) {
 		wmi_buf_free(buf);
-		WMI_LOGE("%s:Failed to send ENHANCED_MCAST_FILTER_CMDID",
-			__func__);
+		wmi_err("Failed to send ENHANCED_MCAST_FILTER_CMDID");
 	}
 
 	return status;
@@ -951,12 +950,12 @@ static QDF_STATUS extract_gtk_rsp_event_tlv(wmi_unified_t wmi_handle,
 
 	param_buf = (WMI_GTK_OFFLOAD_STATUS_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("gtk param_buf is NULL");
+		wmi_err("gtk param_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (len < sizeof(WMI_GTK_OFFLOAD_STATUS_EVENT_fixed_param)) {
-		WMI_LOGE("Invalid length for GTK status");
+		wmi_err("Invalid length for GTK status");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1061,7 +1060,7 @@ static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_WOW_ADD_WAKE_PATTERN_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to send RA rate limit to fw", __func__);
+		wmi_err("Failed to send RA rate limit to fw");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1126,7 +1125,7 @@ static QDF_STATUS send_action_frame_patterns_cmd_tlv(wmi_unified_t wmi_handle,
 	err = wmi_unified_cmd_send(wmi_handle, buf,
 				   len, WMI_WOW_SET_ACTION_WAKE_UP_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send ap_ps_egap cmd");
+		wmi_err("Failed to send ap_ps_egap cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1173,7 +1172,7 @@ static QDF_STATUS send_lphb_config_hbenable_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HB_SET_ENABLE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("cmd_send WMI_HB_SET_ENABLE returned Error %d",
+		wmi_err("cmd_send WMI_HB_SET_ENABLE returned Error %d",
 			 status);
 		wmi_buf_free(buf);
 	}
@@ -1227,7 +1226,7 @@ static QDF_STATUS send_lphb_config_tcp_params_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HB_SET_TCP_PARAMS_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
+		wmi_err("cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
 			 status);
 		wmi_buf_free(buf);
 	}
@@ -1278,7 +1277,7 @@ QDF_STATUS send_lphb_config_tcp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HB_SET_TCP_PKT_FILTER_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
+		wmi_err("cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
 			 status);
 		wmi_buf_free(buf);
 	}
@@ -1331,7 +1330,7 @@ static QDF_STATUS send_lphb_config_udp_params_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HB_SET_UDP_PARAMS_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
+		wmi_err("cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
 			 status);
 		wmi_buf_free(buf);
 	}
@@ -1382,7 +1381,7 @@ QDF_STATUS send_lphb_config_udp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HB_SET_UDP_PKT_FILTER_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
+		wmi_err("cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
 			 status);
 		wmi_buf_free(buf);
 	}
@@ -1443,14 +1442,13 @@ static QDF_STATUS send_enable_disable_packet_filter_cmd_tlv(
 	else
 		cmd->enable = PACKET_FILTER_SET_DISABLE;
 
-	WMI_LOGE("%s: Packet filter enable %d for vdev_id %d",
-		 __func__, cmd->enable, vdev_id);
+	wmi_err("Packet filter enable %d for vdev_id %d", cmd->enable, vdev_id);
 
 	wmi_mtrace(WMI_PACKET_FILTER_ENABLE_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_PACKET_FILTER_ENABLE_CMDID);
 	if (ret) {
-		WMI_LOGE("Failed to send packet filter wmi cmd to fw");
+		wmi_err("Failed to send packet filter wmi cmd to fw");
 		wmi_buf_free(buf);
 	}
 
@@ -1521,14 +1519,14 @@ static QDF_STATUS send_config_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
 		}
 	}
 
-	WMI_LOGE("Packet filter action %d filter with id: %d, num_params=%d",
+	wmi_err("Packet filter action %d filter with id: %d, num_params=%d",
 		 cmd->filter_action, cmd->filter_id, cmd->num_params);
 	/* send the command along with data */
 	wmi_mtrace(WMI_PACKET_FILTER_CONFIG_CMDID, cmd->vdev_id, 0);
 	err = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_PACKET_FILTER_CONFIG_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send pkt_filter cmd");
+		wmi_err("Failed to send pkt_filter cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1585,7 +1583,7 @@ static QDF_STATUS send_wow_delete_pattern_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_WOW_DEL_WAKE_PATTERN_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to delete wow ptrn from fw", __func__);
+		wmi_err("Failed to delete wow ptrn from fw");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1650,7 +1648,7 @@ static QDF_STATUS send_host_wakeup_ind_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
 	ret = wmi_unified_cmd_send_chk(wmi_handle, buf, len,
 				       WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
 	if (ret) {
-		WMI_LOGE("Failed to send host wakeup indication to fw");
+		wmi_err("Failed to send host wakeup indication to fw");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1736,8 +1734,7 @@ static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_WOW_ADD_WAKE_PATTERN_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to send wake timer pattern to fw",
-			__func__);
+		wmi_err("Failed to send wake timer pattern to fw");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1785,7 +1782,7 @@ static QDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_EXTWOW_ENABLE_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to set EXTWOW Enable", __func__);
+		wmi_err("Failed to set EXTWOW Enable");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1867,7 +1864,7 @@ static QDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_hand
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to set APP TYPE2 PARAMS", __func__);
+		wmi_err("Failed to set APP TYPE2 PARAMS");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1924,7 +1921,7 @@ static QDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
 	if (ret) {
-		WMI_LOGE("%s: Failed to set APP TYPE1 PARAMS", __func__);
+		wmi_err("Failed to set APP TYPE1 PARAMS");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}

wmi/src/wmi_unified_sta_tlv.c

@@ -67,7 +67,7 @@ static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID)) {
-		WMI_LOGE(FL("Failed to offload STA SA Query"));
+		wmi_err("Failed to offload STA SA Query");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -138,7 +138,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_STA_KEEPALIVE_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to set KeepAlive");
+		wmi_err("Failed to set KeepAlive");
 		wmi_buf_free(buf);
 	}
 
@@ -194,7 +194,7 @@ static QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_VDEV_SET_GTX_PARAMS_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE("Failed to set GTX PARAMS");
+		wmi_err("Failed to set GTX PARAMS");
 		wmi_buf_free(buf);
 	}
 	return ret;
@@ -240,8 +240,8 @@ static QDF_STATUS send_process_dhcp_ind_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_PEER_SET_PARAM_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
-			 " returned Error %d", __func__, status);
+		wmi_err("wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
+			 " returned Error %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -284,7 +284,7 @@ static QDF_STATUS send_get_link_speed_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) {
-		WMI_LOGE("%s: failed to send link speed command", __func__);
+		wmi_err("Failed to send link speed command");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -330,7 +330,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 					   WMI_WLAN_PROFILE_TRIGGER_CMDID);
 		if (ret) {
-			WMI_LOGE("PROFILE_TRIGGER cmd Failed with value %d",
+			wmi_err("PROFILE_TRIGGER cmd Failed with value %d",
 				 value1);
 			wmi_buf_free(buf);
 			return ret;
@@ -355,7 +355,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID);
 		if (ret) {
-			WMI_LOGE("PROFILE_DATA cmd Failed for id %d value %d",
+			wmi_err("PROFILE_DATA cmd Failed for id %d value %d",
 				 value1, value2);
 			wmi_buf_free(buf);
 			return ret;
@@ -382,7 +382,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID);
 		if (ret) {
-			WMI_LOGE("HIST_INTVL cmd Failed for id %d value %d",
+			wmi_err("HIST_INTVL cmd Failed for id %d value %d",
 				 value1, value2);
 			wmi_buf_free(buf);
 			return ret;
@@ -410,7 +410,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
 		if (ret) {
-			WMI_LOGE("enable cmd Failed for id %d value %d",
+			wmi_err("enable cmd Failed for id %d value %d",
 				 value1, value2);
 			wmi_buf_free(buf);
 			return ret;
@@ -487,8 +487,7 @@ static QDF_STATUS send_wlm_latency_level_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_WLM_CONFIG_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_WLM_CONFIG_CMDID)) {
-		WMI_LOGE("%s: Failed to send setting latency config command",
-			 __func__);
+		wmi_err("Failed to send setting latency config command");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -869,8 +868,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_TDLS_PEER_UPDATE_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_TDLS_PEER_UPDATE_CMDID)) {
-		WMI_LOGE("%s: failed to send tdls peer update state command",
-			 __func__);
+		wmi_err("Failed to send tdls peer update state command");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -894,7 +892,7 @@ static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
 
 	param_buf = (WMI_TDLS_PEER_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: NULL param_buf", __func__);
+		wmi_err("NULL param_buf");
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
@@ -919,8 +917,8 @@ static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
 		param->message_type = TDLS_CONNECTION_TRACKER_NOTIFY;
 		break;
 	default:
-		WMI_LOGE("%s: Discarding unknown tdls event %d from target",
-			 __func__, evt->peer_status);
+		wmi_err("Discarding unknown tdls event %d from target",
+			evt->peer_status);
 		return QDF_STATUS_E_INVAL;
 	};
 
@@ -966,8 +964,8 @@ static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
 		break;
 
 	default:
-		WMI_LOGE("%s: unknown reason %d in tdls event %d from target",
-			 __func__, evt->peer_reason, evt->peer_status);
+		wmi_err("Unknown reason %d in tdls event %d from target",
+			evt->peer_reason, evt->peer_status);
 		return QDF_STATUS_E_INVAL;
 	};
 
@@ -1049,7 +1047,7 @@ static QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_VDEV_SET_IE_CMDID);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMI_LOGE(FL("Failed to send set IE command ret = %d"), ret);
+		wmi_err("Failed to send set IE command ret = %d", ret);
 		wmi_buf_free(buf);
 	}
 
@@ -1091,7 +1089,7 @@ static QDF_STATUS send_set_base_macaddr_indicate_cmd_tlv(wmi_unified_t wmi_handl
 				   sizeof(*cmd),
 				   WMI_PDEV_SET_BASE_MACADDR_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send set_base_macaddr cmd");
+		wmi_err("Failed to send set_base_macaddr cmd");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1213,7 +1211,7 @@ send_reject_ap_list_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_PDEV_DSM_FILTER_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("wmi_unified_cmd_send WMI_PDEV_DSM_FILTER_CMDID returned Error %d",
+		wmi_err("wmi_unified_cmd_send WMI_PDEV_DSM_FILTER_CMDID returned Error %d",
 			 status);
 		goto error;
 	}
@@ -1306,7 +1304,7 @@ send_sar_limits:
 					  WMI_SAR_LIMITS_CMDID);
 
 	if (QDF_IS_STATUS_ERROR(qdf_status)) {
-		WMI_LOGE("Failed to send WMI_SAR_LIMITS_CMDID");
+		wmi_err("Failed to send WMI_SAR_LIMITS_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -1342,7 +1340,7 @@ static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
 	status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				      WMI_SAR_GET_LIMITS_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE(FL("Failed to send get SAR limit cmd: %d"), status);
+		wmi_err("Failed to send get SAR limit cmd: %d", status);
 		wmi_buf_free(wmi_buf);
 	}
 
@@ -1418,11 +1416,11 @@ static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
 	uint32_t row;
 
 	if (!evt_buf) {
-		WMI_LOGE(FL("input event is NULL"));
+		wmi_err("input event is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 	if (!event) {
-		WMI_LOGE(FL("output event is NULL"));
+		wmi_err("output event is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1430,7 +1428,7 @@ static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
 
 	fixed_param = param_buf->fixed_param;
 	if (!fixed_param) {
-		WMI_LOGE(FL("Invalid fixed param"));
+		wmi_err("Invalid fixed param");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -1438,14 +1436,14 @@ static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
 	event->num_limit_rows = fixed_param->num_limit_rows;
 
 	if (event->num_limit_rows > param_buf->num_sar_get_limits) {
-		WMI_LOGE(FL("Num rows %d exceeds sar_get_limits rows len %d"),
+		wmi_err("Num rows %d exceeds sar_get_limits rows len %d",
 			 event->num_limit_rows, param_buf->num_sar_get_limits);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (event->num_limit_rows > MAX_SAR_LIMIT_ROWS_SUPPORTED) {
 		QDF_ASSERT(0);
-		WMI_LOGE(FL("Num rows %d exceeds max of %d"),
+		wmi_err("Num rows %d exceeds max of %d",
 			 event->num_limit_rows,
 			 MAX_SAR_LIMIT_ROWS_SUPPORTED);
 		event->num_limit_rows = MAX_SAR_LIMIT_ROWS_SUPPORTED;
@@ -1543,8 +1541,8 @@ send_cmd:
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_PDEV_UPDATE_PMK_CACHE_CMDID);
 	if (status != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: failed to send set del pmkid cache command %d",
-			 __func__, status);
+		wmi_err("Failed to send set del pmkid cache command %d",
+			status);
 		wmi_buf_free(buf);
 	}
 
@@ -1757,8 +1755,7 @@ static QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(
 	wmi_mtrace(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
-		WMI_LOGE("%s: failed to add pattern set state command",
-			 __func__);
+		wmi_err("Failed to add pattern set state command");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1804,7 +1801,7 @@ static QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(
 	wmi_mtrace(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
 				 WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
-		WMI_LOGE("%s: failed to send del pattern command", __func__);
+		wmi_err("Failed to send del pattern command");
 		wmi_buf_free(wmi_buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1849,8 +1846,7 @@ static QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("%s: WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d",
-			 __func__, status);
+		wmi_err("WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -1891,8 +1887,8 @@ static QDF_STATUS send_set_led_flashing_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, len,
 				      WMI_PDEV_SET_LED_FLASHING_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
-			 " returned Error %d", __func__, status);
+		wmi_err("wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
+			 " returned Error %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -1930,9 +1926,9 @@ static QDF_STATUS send_process_ch_avoid_update_cmd_tlv(wmi_unified_t wmi_handle)
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_CHAN_AVOID_UPDATE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("wmi_unified_cmd_send"
-			 " WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE"
-			 " returned Error %d", status);
+		wmi_err("wmi_unified_cmd_send"
+			" WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE"
+			" returned Error %d", status);
 		wmi_buf_free(buf);
 	}
 
@@ -1996,7 +1992,7 @@ static QDF_STATUS send_pdev_set_pcl_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_PDEV_SET_PCL_CMDID, NO_SESSION, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_PDEV_SET_PCL_CMDID)) {
-		WMI_LOGE("%s: Failed to send WMI_PDEV_SET_PCL_CMDID", __func__);
+		wmi_err("Failed to send WMI_PDEV_SET_PCL_CMDID");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -2045,8 +2041,7 @@ QDF_STATUS send_pdev_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_mtrace(WMI_PDEV_SET_MAC_CONFIG_CMDID, NO_SESSION, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_PDEV_SET_MAC_CONFIG_CMDID)) {
-		WMI_LOGE("%s: Failed to send WMI_PDEV_SET_MAC_CONFIG_CMDID",
-			 __func__);
+		wmi_err("Failed to send WMI_PDEV_SET_MAC_CONFIG_CMDID");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -2116,7 +2111,7 @@ QDF_STATUS send_adapt_dwelltime_params_cmd_tlv(wmi_unified_t wmi_handle,
 	err = wmi_unified_cmd_send(wmi_handle, buf,
 				   len, WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID);
 	if (err) {
-		WMI_LOGE("Failed to send adapt dwelltime cmd err=%d", err);
+		wmi_err("Failed to send adapt dwelltime cmd err=%d", err);
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -2182,7 +2177,7 @@ static QDF_STATUS send_dbs_scan_sel_params_cmd_tlv(wmi_unified_t wmi_handle,
 	err = wmi_unified_cmd_send(wmi_handle, buf,
 				   len, WMI_SET_SCAN_DBS_DUTY_CYCLE_CMDID);
 	if (QDF_IS_STATUS_ERROR(err)) {
-		WMI_LOGE("Failed to send dbs scan selection cmd err=%d", err);
+		wmi_err("Failed to send dbs scan selection cmd err=%d", err);
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -2271,8 +2266,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_VDEV_SET_ARP_STAT_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("WMI_SET_ARP_STATS_CMDID failed, Error %d",
-			 status);
+		wmi_err("WMI_SET_ARP_STATS_CMDID failed, Error %d", status);
 		goto error;
 	}
 
@@ -2324,8 +2318,7 @@ static QDF_STATUS send_get_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 				      len, WMI_VDEV_GET_ARP_STAT_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("WMI_GET_ARP_STATS_CMDID failed, Error %d",
-			 status);
+		wmi_err("WMI_GET_ARP_STATS_CMDID failed, Error %d", status);
 		goto error;
 	}
 
@@ -2399,8 +2392,8 @@ static QDF_STATUS send_peer_unmap_conf_cmd_tlv(wmi_unified_t wmi,
 	status = wmi_unified_cmd_send(wmi, buf, len,
 				      WMI_PEER_UNMAP_RESPONSE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("%s: Failed to send peer unmap conf command: Err[%d]",
-			 __func__, status);
+		wmi_err("Failed to send peer unmap conf command: Err[%d]",
+			 status);
 		wmi_buf_free(buf);
 		return status;
 	}
@@ -2442,7 +2435,7 @@ send_ocl_cmd_tlv(wmi_unified_t wmi_handle, struct ocl_cmd_params *param)
 				   WMI_SET_OCL_CMDID);
 
 	if (ret != 0) {
-		WMI_LOGE("Sending OCL CMD failed");
+		wmi_err("Sending OCL CMD failed");
 		wmi_buf_free(buf);
 	}
 

wmi/src/wmi_unified_twt_tlv.c

@@ -31,7 +31,7 @@ static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -67,7 +67,7 @@ static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 			WMI_TWT_ENABLE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_ENABLE_CMDID");
+		wmi_err("Failed to send WMI_TWT_ENABLE_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -84,7 +84,7 @@ static QDF_STATUS send_twt_disable_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -102,7 +102,7 @@ static QDF_STATUS send_twt_disable_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 			WMI_TWT_DISABLE_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_DISABLE_CMDID");
+		wmi_err("Failed to send WMI_TWT_DISABLE_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -139,7 +139,7 @@ send_twt_add_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -167,7 +167,7 @@ send_twt_add_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				      WMI_TWT_ADD_DIALOG_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_ADD_DIALOG_CMDID");
+		wmi_err("Failed to send WMI_TWT_ADD_DIALOG_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -201,7 +201,7 @@ send_twt_del_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -220,7 +220,7 @@ send_twt_del_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				      WMI_TWT_DEL_DIALOG_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_DEL_DIALOG_CMDID");
+		wmi_err("Failed to send WMI_TWT_DEL_DIALOG_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -237,7 +237,7 @@ send_twt_pause_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -254,7 +254,7 @@ send_twt_pause_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 				      WMI_TWT_PAUSE_DIALOG_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_PAUSE_DIALOG_CMDID");
+		wmi_err("Failed to send WMI_TWT_PAUSE_DIALOG_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -270,7 +270,7 @@ static QDF_STATUS send_twt_resume_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -289,7 +289,7 @@ static QDF_STATUS send_twt_resume_dialog_cmd_tlv(wmi_unified_t wmi_handle,
 	status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
 						WMI_TWT_RESUME_DIALOG_CMDID);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		WMI_LOGE("Failed to send WMI_TWT_RESUME_DIALOG_CMDID");
+		wmi_err("Failed to send WMI_TWT_RESUME_DIALOG_CMDID");
 		wmi_buf_free(buf);
 	}
 
@@ -308,7 +308,7 @@ send_twt_btwt_invite_sta_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -342,7 +342,7 @@ send_twt_btwt_remove_sta_cmd_tlv(wmi_unified_t wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
-		WMI_LOGE("Failed to allocate memory");
+		wmi_err("Failed to allocate memory");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -375,7 +375,7 @@ static QDF_STATUS extract_twt_enable_comp_event_tlv(wmi_unified_t wmi_handle,
 
 	param_buf = (WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -398,7 +398,7 @@ static QDF_STATUS extract_twt_disable_comp_event_tlv(wmi_unified_t wmi_handle,
 
 	param_buf = (WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -432,7 +432,7 @@ static QDF_STATUS extract_twt_add_dialog_comp_event_tlv(
 
 	param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -472,7 +472,7 @@ static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters
 
 	param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -484,18 +484,18 @@ static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters
 	 */
 	if (ev->status != WMI_HOST_ADD_TWT_STATUS_OK &&
 	    ev->status != WMI_HOST_ADD_TWT_STATUS_DENIED) {
-		WMI_LOGE("Status of add dialog complete is not success");
+		wmi_err("Status of add dialog complete is not success");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (idx >= param_buf->num_twt_params) {
-		WMI_LOGE("Invalid idx %d while num_twt_params = %d",
+		wmi_err("Invalid idx %d while num_twt_params = %d",
 			 idx, param_buf->num_twt_params);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (!param_buf->twt_params) {
-		WMI_LOGE("Unable to extract additional twt parameters");
+		wmi_err("Unable to extract additional twt parameters");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -504,7 +504,7 @@ static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters
 			sizeof(wmi_twt_add_dialog_additional_params)));
 
 	if (evt_buf_len != expected_len) {
-		WMI_LOGE("Got invalid len data from FW %d expected %d",
+		wmi_err("Got invalid len data from FW %d expected %d",
 			 evt_buf_len, expected_len);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -541,7 +541,7 @@ static QDF_STATUS extract_twt_del_dialog_comp_event_tlv(
 
 	param_buf = (WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -565,7 +565,7 @@ static QDF_STATUS extract_twt_pause_dialog_comp_event_tlv(
 
 	param_buf = (WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -590,7 +590,7 @@ static QDF_STATUS extract_twt_resume_dialog_comp_event_tlv(
 	param_buf =
 		(WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -619,7 +619,7 @@ extract_twt_btwt_invite_sta_comp_event_tlv(
 	param_buf =
 		(WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -647,7 +647,7 @@ extract_twt_btwt_remove_sta_comp_event_tlv(
 	param_buf =
 		(WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -695,7 +695,7 @@ extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle,
 	param_buf =
 		(WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -729,12 +729,12 @@ extract_twt_session_stats_event_data(wmi_unified_t wmi_handle,
 	param_buf =
 		(WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("evt_buf is NULL");
+		wmi_err("evt_buf is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (idx >= param_buf->num_twt_sessions) {
-		WMI_LOGE("wrong idx, idx=%d, num_sessions=%d",
+		wmi_err("wrong idx, idx=%d, num_sessions=%d",
 			 idx, param_buf->num_twt_sessions);
 		return QDF_STATUS_E_INVAL;
 	}

wmi/src/wmi_unified_vdev_tlv.c

@@ -33,7 +33,7 @@ send_vdev_config_ratemask_cmd_tlv(struct wmi_unified *wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_FAILURE;
 	}
 	cmd = (wmi_vdev_config_ratemask_cmd_fixed_param *)wmi_buf_data(buf);
@@ -51,7 +51,7 @@ send_vdev_config_ratemask_cmd_tlv(struct wmi_unified *wmi_handle,
 	wmi_mtrace(WMI_VDEV_RATEMASK_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_VDEV_RATEMASK_CMDID)) {
-		WMI_LOGE("Seting vdev ratemask failed");
+		wmi_err("Setting vdev ratemask failed");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -71,7 +71,7 @@ send_beacon_send_cmd_tlv(struct wmi_unified *wmi_handle,
 
 	wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!wmi_buf) {
-		WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_NOMEM;
 	}
 	if (param->is_dtim_count_zero) {
@@ -102,7 +102,7 @@ send_beacon_send_cmd_tlv(struct wmi_unified *wmi_handle,
 	ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
 				   WMI_PDEV_SEND_BCN_CMDID);
 	if (ret != QDF_STATUS_SUCCESS) {
-		WMI_LOGE("%s: Failed to send bcn: %d", __func__, ret);
+		wmi_err("Failed to send bcn: %d", ret);
 		wmi_buf_free(wmi_buf);
 	}
 
@@ -119,7 +119,7 @@ extract_tbttoffset_num_vdevs_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
 
 	param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: Invalid tbtt update ext event buffer", __func__);
+		wmi_err("Invalid tbtt update ext event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 	tbtt_offset_event = param_buf->fixed_param;
@@ -140,7 +140,7 @@ send_vdev_set_neighbour_rx_cmd_tlv(struct wmi_unified *wmi_handle,
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
-		WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
+		wmi_err("wmi_buf_alloc failed");
 		return QDF_STATUS_E_FAILURE;
 	}
 	cmd = (wmi_vdev_filter_nrp_config_cmd_fixed_param *)wmi_buf_data(buf);
@@ -158,7 +158,7 @@ send_vdev_set_neighbour_rx_cmd_tlv(struct wmi_unified *wmi_handle,
 	wmi_mtrace(WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID)) {
-		WMI_LOGE("Failed to set neighbour rx param");
+		wmi_err("Failed to set neighbour rx param");
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -175,13 +175,13 @@ extract_vdev_start_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
 
 	param_buf = (WMI_VDEV_START_RESP_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: Invalid start response event buffer", __func__);
+		wmi_err("Invalid start response event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	ev = param_buf->fixed_param;
 	if (!ev) {
-		WMI_LOGE("%s: Invalid start response event buffer", __func__);
+		wmi_err("Invalid start response event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -197,7 +197,7 @@ extract_vdev_start_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
 		vdev_rsp->resp_type = WMI_HOST_VDEV_RESTART_RESP_EVENT;
 		break;
 	default:
-		WMI_LOGE("Invalid start response event buffer");
+		wmi_err("Invalid start response event buffer");
 		break;
 	};
 	vdev_rsp->status = ev->status;
@@ -220,13 +220,13 @@ extract_vdev_delete_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
 
 	param_buf = (WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid vdev delete response event buffer");
+		wmi_err("Invalid vdev delete response event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
 	ev = param_buf->fixed_param;
 	if (!ev) {
-		WMI_LOGE("Invalid vdev delete response event");
+		wmi_err("Invalid vdev delete response event");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -249,7 +249,7 @@ static QDF_STATUS extract_vdev_peer_delete_all_response_event_tlv(
 	ev = (wmi_vdev_delete_all_peer_resp_event_fixed_param *)
 							param_buf->fixed_param;
 	if (!ev) {
-		WMI_LOGE("%s: Invalid peer_delete all response", __func__);
+		wmi_err("Invalid peer_delete all response");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -268,7 +268,7 @@ extract_vdev_stopped_param_tlv(struct wmi_unified *wmi_handle,
 
 	param_buf = (WMI_VDEV_STOPPED_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("Invalid event buffer");
+		wmi_err("Invalid event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 	resp_event = param_buf->fixed_param;
@@ -287,7 +287,7 @@ static QDF_STATUS extract_ext_tbttoffset_num_vdevs_tlv(
 
 	param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s Invalid tbtt update ext event buffer", __func__);
+		wmi_err("Invalid tbtt update ext event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 	tbtt_offset_ext_event = param_buf->fixed_param;
@@ -308,7 +308,7 @@ static QDF_STATUS extract_tbttoffset_update_params_tlv(
 
 	param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: Invalid tbtt update event buffer", __func__);
+		wmi_err("Invalid tbtt update event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -339,7 +339,7 @@ static QDF_STATUS extract_ext_tbttoffset_update_params_tlv(
 
 	param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: Invalid tbtt update event buffer", __func__);
+		wmi_err("Invalid tbtt update event buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 	tbtt_offset_info = &param_buf->tbtt_offset_info[idx];
@@ -362,7 +362,7 @@ static QDF_STATUS extract_muedca_params_tlv(wmi_unified_t wmi_hdl,
 
 	param_buf = (WMI_MUEDCA_PARAMS_CONFIG_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
-		WMI_LOGE("%s: Invalid muedca evt buffer", __func__);
+		wmi_err("Invalid muedca evt buffer");
 		return QDF_STATUS_E_INVAL;
 	}
 	muedca_param = param_buf->fixed_param;