qcacmn: Replace WMI_LOGD() with wmi_debug()

Replace WMI_LOGD() with wmi_debug().

Change-Id: I9c69cabfd84882fa1daff6e219de5f2643e7d214
CRs-Fixed: 2774563

wmi/src/wmi_unified.c

@@ -1681,7 +1681,7 @@ static uint8_t *wmi_id_to_name(uint32_t wmi_command)
 
 static inline void wmi_log_cmd_id(uint32_t cmd_id, uint32_t tag)
 {
-	WMI_LOGD("Send WMI command:%s command_id:%d htc_tag:%d",
+	wmi_debug("Send WMI command:%s command_id:%d htc_tag:%d",
 		 wmi_id_to_name(cmd_id), cmd_id, tag);
 }
 
@@ -3109,7 +3109,7 @@ static void wmi_htc_log_pkt(void *ctx, HTC_PACKET *htc_pkt)
 	cmd_id = WMI_GET_FIELD(qdf_nbuf_data(wmi_cmd_buf), WMI_CMD_HDR,
 			       COMMANDID);
 
-	WMI_LOGD("WMI command from HTC packet: %s, ID: %d\n",
+	wmi_debug("WMI command from HTC packet: %s, ID: %d",
 		 wmi_id_to_name(cmd_id), cmd_id);
 }
 #else

wmi/src/wmi_unified_apf_tlv.c

@@ -35,7 +35,7 @@ QDF_STATUS wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_bpf_set_vdev_active_mode_cmd_fixed_param *cmd;
 	wmi_buf_t buf;
 
-	WMI_LOGD("Sending WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID(%u, %d, %d)",
+	wmi_debug("Sending WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID(%u, %d, %d)",
 		 vdev_id, ucast_mode, mcast_bcast_mode);
 
 	/* allocate command buffer */

wmi/src/wmi_unified_concurrency_tlv.c

@@ -173,10 +173,8 @@ static QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(
 	uint32_t chan1_freq = adapter_1_chan_freq;
 	uint32_t chan2_freq = adapter_2_chan_freq;
 
-	WMI_LOGD("%s: freq1:%dMHz, Quota1:%dms, "
-		 "freq2:%dMHz, Quota2:%dms", __func__,
-		 chan1_freq, quota_chan1, chan2_freq,
-		 quota_chan2);
+	wmi_debug("freq1:%dMHz, Quota1:%dms, freq2:%dMHz, Quota2:%dms",
+		 chan1_freq, quota_chan1, chan2_freq, quota_chan2);
 
 	/*
 	 * Perform sanity check on time quota values provided.

wmi/src/wmi_unified_cp_stats_tlv.c

@@ -54,8 +54,8 @@ send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
 
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
 
-	WMI_LOGD("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
-				cmd->stats_id, cmd->vdev_id, cmd->pdev_id);
+	wmi_debug("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
+		 cmd->stats_id, cmd->vdev_id, cmd->pdev_id);
 
 	wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send_pm_chk(wmi_handle, buf, len,

wmi/src/wmi_unified_dbr_tlv.c

@@ -65,11 +65,11 @@ static QDF_STATUS send_dbr_cfg_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->num_resp_per_event = cfg->num_resp_per_event;
 	cmd->event_timeout_ms = cfg->event_timeout_ms;
 
-	WMI_LOGD("%s: wmi_dma_ring_cfg_req_fixed_param pdev id %d mod id %d"
+	wmi_debug("wmi_dma_ring_cfg_req_fixed_param pdev id %d mod id %d"
 		  "base paddr lo %x base paddr hi %x head idx paddr lo %x"
 		  "head idx paddr hi %x tail idx paddr lo %x"
 		  "tail idx addr hi %x num elems %d buf size %d num resp %d"
-		  "event timeout %d", __func__, cmd->pdev_id,
+		  "event timeout %d", cmd->pdev_id,
 		  cmd->mod_id, cmd->base_paddr_lo, cmd->base_paddr_hi,
 		  cmd->head_idx_paddr_lo, cmd->head_idx_paddr_hi,
 		  cmd->tail_idx_paddr_lo, cmd->tail_idx_paddr_hi,
@@ -134,7 +134,7 @@ static QDF_STATUS extract_dbr_buf_release_fixed_tlv(wmi_unified_t wmi_handle,
 	param->mod_id = ev->mod_id;
 	param->num_buf_release_entry = ev->num_buf_release_entry;
 	param->num_meta_data_entry = ev->num_meta_data_entry;
-	WMI_LOGD("%s:pdev id %d mod id %d num buf release entry %d", __func__,
+	wmi_debug("pdev id %d mod id %d num buf release entry %d",
 		 param->pdev_id, param->mod_id, param->num_buf_release_entry);
 
 	return QDF_STATUS_SUCCESS;
@@ -157,7 +157,7 @@ static QDF_STATUS extract_dbr_buf_release_entry_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	WMI_LOGD("%s: paddr_lo[%d] = %x", __func__, idx, entry->paddr_lo);
+	wmi_debug("paddr_lo[%d] = %x", idx, entry->paddr_lo);
 
 	param->paddr_lo = entry->paddr_lo;
 	param->paddr_hi = entry->paddr_hi;

wmi/src/wmi_unified_extscan_tlv.c

@@ -101,13 +101,13 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
 			WMITLV_GET_STRUCT_TLVLEN(
 			wmi_passpoint_config_cmd_fixed_param));
 		cmd->id = req->networks[i].id;
-		WMI_LOGD("%s: network id: %u", __func__, cmd->id);
+		wmi_debug("network id: %u", cmd->id);
 		qdf_mem_copy(cmd->realm, req->networks[i].realm,
 			strlen(req->networks[i].realm) + 1);
-		WMI_LOGD("%s: realm: %s", __func__, cmd->realm);
+		wmi_debug("realm: %s", cmd->realm);
 		for (j = 0; j < PASSPOINT_ROAMING_CONSORTIUM_ID_NUM; j++) {
 			bytes = (uint8_t *) &req->networks[i].roaming_consortium_ids[j];
-			WMI_LOGD("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
+			wmi_debug("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
 				j, bytes[0], bytes[1], bytes[2], bytes[3],
 				bytes[4], bytes[5], bytes[6], bytes[7]);
 
@@ -117,8 +117,8 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
 		}
 		qdf_mem_copy(cmd->plmn, req->networks[i].plmn,
 				PASSPOINT_PLMN_ID_LEN);
-		WMI_LOGD("%s: plmn: %02x:%02x:%02x", __func__,
-			cmd->plmn[0], cmd->plmn[1], cmd->plmn[2]);
+		wmi_debug("plmn: %02x:%02x:%02x",
+			 cmd->plmn[0], cmd->plmn[1], cmd->plmn[2]);
 
 		ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 					   WMI_PASSPOINT_LIST_CONFIG_CMDID);
@@ -191,8 +191,8 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
 
 	cmd->no_of_ssids = QDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
-	WMI_LOGD("SSID count: %d flags: %d",
-		cmd->no_of_ssids, cmd->flags);
+	wmi_debug("SSID count: %d flags: %d",
+		 cmd->no_of_ssids, cmd->flags);
 
 	/* Fill nlo_config only when num_networks are non zero */
 	if (cmd->no_of_ssids) {
@@ -214,7 +214,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 			qdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
 				     req->networks[i].ssid.ssid,
 				     nlo_list[i].ssid.ssid.ssid_len);
-			WMI_LOGD("index: %d ssid: %.*s len: %d", i,
+			wmi_debug("index: %d ssid: %.*s len: %d", i,
 				 nlo_list[i].ssid.ssid.ssid_len,
 				 (char *) nlo_list[i].ssid.ssid.ssid,
 				 nlo_list[i].ssid.ssid.ssid_len);
@@ -223,15 +223,15 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 			nlo_list[i].bcast_nw_type.valid = true;
 			nlo_list[i].bcast_nw_type.bcast_nw_type =
 					req->networks[i].flags;
-			WMI_LOGD("PNO flags (%u)",
-				nlo_list[i].bcast_nw_type.bcast_nw_type);
+			wmi_debug("PNO flags: %u",
+				 nlo_list[i].bcast_nw_type.bcast_nw_type);
 
 			/* Copy auth bit field */
 			nlo_list[i].auth_type.valid = true;
 			nlo_list[i].auth_type.auth_type =
 					req->networks[i].auth_bit_field;
-			WMI_LOGD("Auth bit field (%u)",
-					nlo_list[i].auth_type.auth_type);
+			wmi_debug("Auth bit field: %u",
+				 nlo_list[i].auth_type.auth_type);
 		}
 
 		buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters);
@@ -273,7 +273,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("set ePNO list request sent successfully for vdev %d",
+	wmi_debug("set ePNO list request sent successfully for vdev %d",
 		 req->vdev_id);
 
 	return ret;
@@ -498,8 +498,7 @@ static QDF_STATUS wmi_get_buf_extscan_change_monitor_cmd
 		WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
 					   &dest_chglist->bssid);
 
-		WMI_LOGD("%s: min_rssi %d", __func__,
-			 dest_chglist->lower_rssi_limit);
+		wmi_debug("min_rssi: %d", dest_chglist->lower_rssi_limit);
 		dest_chglist++;
 		src_ap++;
 	}
@@ -711,8 +710,8 @@ QDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle,
 		src_bucket++;
 	}
 
-	WMI_LOGD("%s: Total buckets: %d total #of channels is %d",
-		__func__, nbuckets, nchannels);
+	wmi_debug("Total buckets: %d total #of channels is %d",
+		 nbuckets, nchannels);
 	len += nchannels * sizeof(wmi_extscan_bucket_channel);
 	/* Allocate the memory */
 	*buf = wmi_buf_alloc(wmi_handle, len);
@@ -1026,10 +1025,10 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
 		cmd->lost_ap_scan_count = params->lost_ap_sample_size;
 		cmd->first_entry_index = index;
 
-		WMI_LOGD("%s: vdev id:%d total_entries: %d num_entries: %d lost_ap_sample_size: %d",
-			__func__, cmd->vdev_id, cmd->total_entries,
-			cmd->num_entries_in_page,
-			cmd->lost_ap_scan_count);
+		wmi_debug("vdev id:%d total_entries: %d num_entries: %d lost_ap_sample_size: %d",
+			 cmd->vdev_id, cmd->total_entries,
+			 cmd->num_entries_in_page,
+			 cmd->lost_ap_scan_count);
 
 		buf_ptr += sizeof(*cmd);
 		WMITLV_SET_HDR(buf_ptr,
@@ -1051,12 +1050,11 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
 			WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
 						   &dest_hotlist->bssid);
 
-			WMI_LOGD("%s:channel:%d min_rssi %d",
-				 __func__, dest_hotlist->channel,
+			wmi_debug("channel:%d min_rssi %d",
+				 dest_hotlist->channel,
 				 dest_hotlist->min_rssi);
-			WMI_LOGD
-				("%s: bssid mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
-				__func__, dest_hotlist->bssid.mac_addr31to0,
+			wmi_debug("bssid mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
+				dest_hotlist->bssid.mac_addr31to0,
 				dest_hotlist->bssid.mac_addr47to32);
 			dest_hotlist++;
 			src_ap++;

wmi/src/wmi_unified_fwol_tlv.c

@@ -130,7 +130,7 @@ extract_get_elna_bypass_resp_tlv(struct wmi_unified *wmi_handle, void *resp_buf,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("Get elna bypass %d from vdev %d", evt->en_dis, evt->vdev_id);
+	wmi_debug("Get elna bypass %d from vdev %d", evt->en_dis, evt->vdev_id);
 
 	resp->vdev_id = evt->vdev_id;
 	resp->en_dis = evt->en_dis;

wmi/src/wmi_unified_nan_tlv.c

@@ -186,7 +186,7 @@ static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle,
 		       WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param));
 
 	cmd->data_len = nan_data_len;
-	WMI_LOGD("%s: nan data len value is %u", __func__, nan_data_len);
+	wmi_debug("nan data len value is %u", nan_data_len);
 	buf_ptr += sizeof(wmi_nan_cmd_param);
 
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned);
@@ -323,7 +323,7 @@ static QDF_STATUS send_terminate_all_ndps_cmd_tlv(wmi_unified_t wmi_handle,
 	uint32_t len;
 	QDF_STATUS status;
 
-	WMI_LOGD(FL("Enter"));
+	wmi_debug("Enter");
 
 	len = sizeof(*cmd);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -445,16 +445,16 @@ static QDF_STATUS nan_ndp_initiator_req_tlv(wmi_unified_t wmi_handle,
 		qdf_mem_copy(tcp_ip_param->ipv6_intf_addr,
 			     ndp_req->ipv6_addr, WMI_NDP_IPV6_INTF_ADDR_LEN);
 	}
-	WMI_LOGD("IPv6 addr present: %d, addr: %pI6",
+	wmi_debug("IPv6 addr present: %d, addr: %pI6",
 		 ndp_req->is_ipv6_addr_present, ndp_req->ipv6_addr);
 
-	WMI_LOGD("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
+	wmi_debug("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
 		 cmd->vdev_id, cmd->transaction_id, cmd->service_instance_id,
 		 ch_tlv->mhz, cmd->ndp_channel_cfg, cmd->nan_csid,
 		 cmd->peer_discovery_mac_addr.mac_addr31to0,
 		 cmd->peer_discovery_mac_addr.mac_addr47to32);
 
-	WMI_LOGD("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
+	wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
 		 cmd->ndp_cfg_len, cmd->ndp_app_info_len, cmd->nan_pmk_len,
 		 cmd->nan_passphrase_len, cmd->nan_servicename_len);
 
@@ -482,7 +482,7 @@ static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle,
 	uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len;
 
 	vdev_id = wlan_vdev_get_id(req->vdev);
-	WMI_LOGD("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d",
+	wmi_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d",
 		 vdev_id, req->transaction_id,
 		 req->ndp_rsp,
 		 req->ndp_instance_id,
@@ -575,7 +575,7 @@ static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle,
 		tcp_ip_param->transport_protocol = req->protocol;
 	}
 
-	WMI_LOGD("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
+	wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
 		 req->ndp_config.ndp_cfg_len, req->ndp_info.ndp_app_info_len,
 		 cmd->nan_pmk_len, cmd->nan_passphrase_len,
 		 cmd->nan_servicename_len);
@@ -789,7 +789,7 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr,
 				rsp->peer_discovery_mac_addr.bytes);
 
-	WMI_LOGD("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d service_instance %d, ndp_instance %d, role %d, policy %d csid: %d, scid_len: %d, peer_addr: "QDF_MAC_ADDR_FMT", peer_disc_addr: "QDF_MAC_ADDR_FMT" ndp_cfg - %d bytes ndp_app_info - %d bytes",
+	wmi_debug("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d service_instance %d, ndp_instance %d, role %d, policy %d csid: %d, scid_len: %d, peer_addr: "QDF_MAC_ADDR_FMT", peer_disc_addr: "QDF_MAC_ADDR_FMT" ndp_cfg - %d bytes ndp_app_info - %d bytes",
 		 WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id,
 		 fixed_params->service_instance_id,
 		 fixed_params->ndp_instance_id, fixed_params->self_ndp_role,
@@ -834,8 +834,8 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
 				WMI_NDP_IPV6_INTF_ADDR_LEN);
 		}
 	}
-	WMI_LOGD(FL("IPv6 addr present: %d, addr: %pI6"),
-		    rsp->is_ipv6_addr_present, rsp->ipv6_addr);
+	wmi_debug("IPv6 addr present: %d, addr: %pI6",
+		 rsp->is_ipv6_addr_present, rsp->ipv6_addr);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -853,7 +853,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 
 	event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) data;
 	fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param;
-	WMI_LOGD("WMI_NDP_CONFIRM_EVENTID(0x%X) received. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d num_ch: %d",
+	wmi_debug("WMI_NDP_CONFIRM_EVENTID(0x%X) received. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d num_ch: %d",
 		 WMI_NDP_CONFIRM_EVENTID, fixed_params->vdev_id,
 		 fixed_params->ndp_instance_id, fixed_params->rsp_code,
 		 fixed_params->reason_code,
@@ -873,7 +873,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("ndp_cfg - %d bytes, ndp_app_info - %d bytes",
+	wmi_debug("ndp_cfg - %d bytes, ndp_app_info - %d bytes",
 		 fixed_params->ndp_cfg_len, fixed_params->ndp_app_info_len);
 
 	if (fixed_params->ndp_cfg_len >
@@ -942,11 +942,11 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 								     ch_mode);
 		if (ndi_dbs) {
 			rsp->ch[i].mac_id = event->ndp_channel_info[i].mac_id;
-			WMI_LOGD("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
+			wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
 				 rsp->ch[i].freq, rsp->ch[i].ch_width,
 				 rsp->ch[i].nss, rsp->ch[i].mac_id);
 		} else {
-			WMI_LOGD("Freq: %d, ch_mode: %d, nss: %d",
+			wmi_debug("Freq: %d, ch_mode: %d, nss: %d",
 				 rsp->ch[i].freq, rsp->ch[i].ch_width,
 				 rsp->ch[i].nss);
 		}
@@ -973,7 +973,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
 			    event->ndp_transport_ip_param->transport_protocol;
 		}
 	}
-	WMI_LOGD("IPv6 addr present: %d, addr: %pI6 port: %d present: %d protocol: %d present: %d",
+	wmi_debug("IPv6 addr present: %d, addr: %pI6 port: %d present: %d protocol: %d present: %d",
 		 rsp->is_ipv6_addr_present, rsp->ipv6_addr, rsp->port,
 		 rsp->is_port_present, rsp->protocol, rsp->is_protocol_present);
 
@@ -1003,7 +1003,7 @@ static QDF_STATUS extract_ndp_responder_rsp_tlv(wmi_unified_t wmi_handle,
 	rsp->create_peer = fixed_params->create_peer;
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
 				   rsp->peer_mac_addr.bytes);
-	WMI_LOGD("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT",transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d",
+	wmi_debug("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT",transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d",
 		 WMI_NDP_RESPONDER_RSP_EVENTID, fixed_params->vdev_id,
 		 QDF_MAC_ADDR_REF(rsp->peer_mac_addr.bytes),
 		 rsp->transaction_id,
@@ -1020,7 +1020,7 @@ static QDF_STATUS extract_ndp_end_rsp_tlv(wmi_unified_t wmi_handle,
 
 	event = (WMI_NDP_END_RSP_EVENTID_param_tlvs *) data;
 	fixed_params = (wmi_ndp_end_rsp_event_fixed_param *)event->fixed_param;
-	WMI_LOGD("WMI_NDP_END_RSP_EVENTID(0x%X) received. transaction_id: %d, rsp_status: %d, reason_code: %d",
+	wmi_debug("WMI_NDP_END_RSP_EVENTID(0x%X) received. transaction_id: %d, rsp_status: %d, reason_code: %d",
 		 WMI_NDP_END_RSP_EVENTID, fixed_params->transaction_id,
 		 fixed_params->rsp_status, fixed_params->reason_code);
 
@@ -1053,7 +1053,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("number of ndp instances = %d",
+	wmi_debug("number of ndp instances = %d",
 		 event->num_ndp_end_indication_list);
 
 	if (event->num_ndp_end_indication_list > ((UINT_MAX - sizeof(**rsp))/
@@ -1073,7 +1073,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
 	for (i = 0; i < (*rsp)->num_ndp_ids; i++) {
 		WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr,
 					   peer_addr.bytes);
-		WMI_LOGD("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ",
+		wmi_debug("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ",
 			 i, ind[i].type, ind[i].reason_code,
 			 ind[i].ndp_instance_id,
 			 ind[i].num_active_ndps_on_peer);
@@ -1104,7 +1104,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 	event = (WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *)data;
 	fixed_params = event->fixed_param;
 
-	WMI_LOGD(FL("flags: %d, num_ch: %d, num_ndp_instances: %d"),
+	wmi_debug("flags: %d, num_ch: %d, num_ndp_instances: %d",
 		 fixed_params->flags, fixed_params->num_channels,
 		 fixed_params->num_ndp_instances);
 
@@ -1169,18 +1169,18 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
 								     ch_mode);
 		if (ndi_dbs) {
 			ind->ch[i].mac_id = event->ndp_channel_info[i].mac_id;
-			WMI_LOGD(FL("Freq: %d, ch_mode: %d, nss: %d mac_id: %d"),
+			wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
 				 ind->ch[i].freq, ind->ch[i].ch_width,
 				 ind->ch[i].nss, ind->ch[i].mac_id);
 		} else {
-			WMI_LOGD(FL("Freq: %d, ch_mode: %d, nss: %d"),
+			wmi_debug("Freq: %d, ch_mode: %d, nss: %d",
 				 ind->ch[i].freq, ind->ch[i].ch_width,
 				 ind->ch[i].nss);
 		}
 	}
 
 	for (i = 0; i < fixed_params->num_ndp_instances; i++)
-		WMI_LOGD(FL("instance_id[%d]: %d"),
+		wmi_debug("instance_id[%d]: %d",
 			 i, event->ndp_instance_list[i]);
 
 	return QDF_STATUS_SUCCESS;

wmi/src/wmi_unified_p2p_tlv.c

@@ -39,7 +39,6 @@ static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
 	QDF_STATUS status;
 	uint32_t duration;
 
-	WMI_LOGD("%s: Enter", __func__);
 	len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -84,7 +83,6 @@ static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
 	}
 
 end:
-	WMI_LOGD("%s: Exit", __func__);
 	return status;
 }
 
@@ -102,7 +100,6 @@ static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_buf_t buf;
 	QDF_STATUS status;
 
-	WMI_LOGD("%s: Enter", __func__);
 	buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
 	if (!buf) {
 		status = QDF_STATUS_E_FAILURE;
@@ -130,7 +127,6 @@ static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
 	}
 
 end:
-	WMI_LOGD("%s: Exit", __func__);
 	return status;
 }
 
@@ -188,8 +184,7 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("%s:index %u, opps_ps %u, ct_window %u, num_descriptors = %u",
-		 __func__,
+	wmi_debug("index %u, opps_ps %u, ct_window %u, num_descriptors = %u",
 		 param->index, param->opps_ps, param->ct_window,
 		 param->num_desc);
 	for (i = 0; i < param->num_desc; i++) {
@@ -202,8 +197,8 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 			wmi_noa_info->noa_descriptors[i].interval;
 		param->noa_desc[i].start_time =
 			wmi_noa_info->noa_descriptors[i].start_time;
-		WMI_LOGD("%s:NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u",
-			__func__, i, param->noa_desc[i].type_count,
+		wmi_debug("NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u",
+			 i, param->noa_desc[i].type_count,
 			param->noa_desc[i].duration,
 			param->noa_desc[i].interval,
 			param->noa_desc[i].start_time);
@@ -249,7 +244,7 @@ send_set_mac_addr_rx_filter_cmd_tlv(wmi_unified_t wmi_handle,
 		cmd->enable = 1;
 	else
 		cmd->enable = 0;
-	WMI_LOGD("set random mac rx vdev %d freq %d set %d "QDF_MAC_ADDR_FMT,
+	wmi_debug("set random mac rx vdev %d freq %d set %d "QDF_MAC_ADDR_FMT,
 		 param->vdev_id, param->freq, param->set,
 		 QDF_MAC_ADDR_REF(param->mac));
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -312,7 +307,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("%s: vdev_id:%d", __func__, param->vdev_id);
+	wmi_debug("vdev_id: %d", param->vdev_id);
 
 	device_types_len_aligned =
 		qdf_roundup(param->dev_types_len,
@@ -359,7 +354,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_mem_copy(buf_ptr, param->probe_resp_tmplt,
 		     param->probe_resp_len);
 
-	WMI_LOGD("%s: Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d", __func__,
+	wmi_debug("Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d",
 		 cmd->channel, cmd->period, cmd->interval, cmd->count);
 
 	wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_START_CMDID, cmd->vdev_id, 0);
@@ -372,7 +367,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
 		return status;
 	}
 
-	WMI_LOGD("%s: Successfully sent WMI_P2P_LO_START", __func__);
+	wmi_debug("Successfully sent WMI_P2P_LO_START");
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -392,7 +387,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
 	int32_t len;
 	QDF_STATUS status;
 
-	WMI_LOGD("%s: vdev_id:%d", __func__, vdev_id);
+	wmi_debug("vdev_id: %d", vdev_id);
 
 	len = sizeof(*cmd);
 	buf = wmi_buf_alloc(wmi_handle, len);
@@ -407,7 +402,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd->vdev_id = vdev_id;
 
-	WMI_LOGD("%s: Sending WMI_P2P_LO_STOP command", __func__);
+	wmi_debug("Sending WMI_P2P_LO_STOP command");
 
 	wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID, cmd->vdev_id, 0);
 	status = wmi_unified_cmd_send(wmi_handle,
@@ -419,7 +414,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
 		return status;
 	}
 
-	WMI_LOGD("%s: Successfully sent WMI_P2P_LO_STOP", __func__);
+	wmi_debug("Successfully sent WMI_P2P_LO_STOP");
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -455,7 +450,7 @@ static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv(
 	lo_param = param_tlvs->fixed_param;
 	param->vdev_id = lo_param->vdev_id;
 	param->reason_code = lo_param->reason;
-	WMI_LOGD("%s: vdev_id:%d, reason:%d", __func__,
+	wmi_debug("vdev_id:%d, reason:%d",
 		 param->vdev_id, param->reason_code);
 
 	return QDF_STATUS_SUCCESS;

wmi/src/wmi_unified_pmo_tlv.c

@@ -141,7 +141,7 @@ static QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_mem_copy(&(cmd->event_bitmaps[0]), bitmap, sizeof(uint32_t) *
 		     WMI_WOW_MAX_EVENT_BM_LEN);
 
-	WMI_LOGD("Wakeup pattern 0x%x%x%x%x %s in fw", cmd->event_bitmaps[0],
+	wmi_debug("Wakeup pattern 0x%x%x%x%x %s in fw", cmd->event_bitmaps[0],
 		 cmd->event_bitmaps[1], cmd->event_bitmaps[2],
 		 cmd->event_bitmaps[3], enable ? "enabled" : "disabled");
 
@@ -240,15 +240,15 @@ static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
 	bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
 	bitmap_pattern->pattern_id = ptrn_id;
 
-	WMI_LOGD("vdev: %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
+	wmi_debug("vdev: %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
 		 cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
 		 bitmap_pattern->pattern_offset, user);
-	WMI_LOGD("Pattern : ");
+	wmi_debug("Pattern: ");
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
 			   &bitmap_pattern->patternbuf[0],
 			   bitmap_pattern->pattern_len);
 
-	WMI_LOGD("Mask : ");
+	wmi_debug("Mask: ");
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
 			   &bitmap_pattern->bitmaskbuf[0],
 			   bitmap_pattern->pattern_len);
@@ -323,8 +323,8 @@ static void fill_arp_offload_params_tlv(wmi_unified_t wmi_handle,
 			qdf_mem_copy(&arp_tuple->target_ipaddr,
 					offload_req->host_ipv4_addr,
 					WMI_IPV4_ADDR_LEN);
-			WMI_LOGD("ARPOffload IP4 address: %pI4",
-					offload_req->host_ipv4_addr);
+			wmi_debug("ARPOffload IP4 address: %pI4",
+				 offload_req->host_ipv4_addr);
 		}
 		*buf_ptr += sizeof(WMI_ARP_OFFLOAD_TUPLE);
 	}
@@ -375,7 +375,7 @@ static void fill_ns_offload_params_tlv(wmi_unified_t wmi_handle,
 				ns_tuple->flags |=
 					WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
 			}
-			WMI_LOGD("Index %d NS solicitedIp %pI6, targetIp %pI6",
+			wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
 				i, &ns_req->self_ipv6_addr[i],
 				&ns_req->target_ipv6_addr[i]);
 
@@ -444,7 +444,7 @@ static void fill_nsoffload_ext_tlv(wmi_unified_t wmi_handle,
 				ns_tuple->flags |=
 					WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
 			}
-			WMI_LOGD("Index %d NS solicitedIp %pI6, targetIp %pI6",
+			wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
 				i, &ns_req->self_ipv6_addr[i],
 				&ns_req->target_ipv6_addr[i]);
 
@@ -541,7 +541,7 @@ static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->vdev_id = vdev_id;
 	cmd->num_ns_ext_tuples = num_ns_ext_tuples;
 
-	WMI_LOGD("ARP NS Offload vdev_id: %d", cmd->vdev_id);
+	wmi_debug("ARP NS Offload vdev_id: %d", cmd->vdev_id);
 
 	buf_ptr += sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param);
 	fill_ns_offload_params_tlv(wmi_handle, ns_offload_req, &buf_ptr);
@@ -596,7 +596,7 @@ static QDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->vdev_id = vdev_id;
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(multicast_addr.bytes, &cmd->mcastbdcastaddr);
 
-	WMI_LOGD("Action:%d; vdev_id:%d; clearList:%d; MCBC MAC Addr: "QDF_MAC_ADDR_FMT,
+	wmi_debug("Action:%d; vdev_id:%d; clearList:%d; MCBC MAC Addr: "QDF_MAC_ADDR_FMT,
 		 cmd->action, vdev_id, clearList,
 		 QDF_MAC_ADDR_REF(multicast_addr.bytes));
 
@@ -719,7 +719,7 @@ static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
 	else
 		cmd->hw_filter_bitmap = req->mode_bitmap;
 
-	WMI_LOGD("Send %s hw filter mode: 0x%X for vdev id %d",
+	wmi_debug("Send %s hw filter mode: 0x%X for vdev id %d",
 		 req->enable ? "enable" : "disable", req->mode_bitmap,
 		 req->vdev_id);
 
@@ -781,8 +781,6 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
 	WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
-	WMI_LOGD("%s Enter", __func__);
-
 	len = sizeof(*cmd);
 
 	if (params->is_fils_connection)
@@ -819,7 +817,8 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
 	if (params->is_fils_connection)
 		fill_fils_tlv_params(cmd, vdev_id, params);
 
-	WMI_LOGD("VDEVID: %d, GTK_FLAGS: x%x kek len %d", vdev_id, cmd->flags, params->kek_len);
+	wmi_debug("VDEVID: %d, GTK_FLAGS: x%x kek len %d",
+		 vdev_id, cmd->flags, params->kek_len);
 	/* send the wmi command */
 	wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -830,7 +829,6 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
 	}
 
 out:
-	WMI_LOGD("%s Exit", __func__);
 	return status;
 }
 
@@ -920,8 +918,8 @@ QDF_STATUS send_enable_enhance_multicast_offload_tlv(
 	cmd->vdev_id = vdev_id;
 	cmd->enable = ((action == 0) ? ENHANCED_MCAST_FILTER_DISABLED :
 			ENHANCED_MCAST_FILTER_ENABLED);
-	WMI_LOGD("%s: config enhance multicast offload action %d for vdev %d",
-		__func__, action, vdev_id);
+	wmi_debug("config enhance multicast offload action %d for vdev %d",
+		 action, vdev_id);
 	wmi_mtrace(WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID, cmd->vdev_id, 0);
 	status = wmi_unified_cmd_send(wmi_handle, buf,
 			sizeof(*cmd), WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID);
@@ -1053,7 +1051,7 @@ static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
 
 	*((uint32_t *) buf_ptr) = rate_limit_interval;
 
-	WMI_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
+	wmi_debug("send RA rate limit [%d] to fw vdev = %d",
 		 rate_limit_interval, vdev_id);
 
 	wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
@@ -1597,8 +1595,7 @@ QDF_STATUS wmi_unified_cmd_send_chk(struct wmi_unified *wmi_handle,
 				    wmi_buf_t buf,
 				    uint32_t buflen, uint32_t cmd_id)
 {
-	WMI_LOGD("%s: Send WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID over QMI",
-		 __func__);
+	wmi_debug("Send WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID over QMI");
 	return wmi_unified_cmd_send_over_qmi(wmi_handle, buf,
 					     buflen, cmd_id);
 }
@@ -1727,8 +1724,8 @@ static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += WMI_TLV_HDR_SIZE;
 	*((uint32_t *) buf_ptr) = 0;
 
-	WMI_LOGD("%s: send wake timer pattern with time[%d] to fw vdev = %d",
-		__func__, time, vdev_id);
+	wmi_debug("send wake timer pattern with time[%d] to fw vdev = %d",
+		 time, vdev_id);
 
 	wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1775,8 +1772,8 @@ static QDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->type = params->type;
 	cmd->wakeup_pin_num = params->wakeup_pin_num;
 
-	WMI_LOGD("%s: vdev_id %d type %d Wakeup_pin_num %x",
-		 __func__, cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
+	wmi_debug("vdev_id %d type %d Wakeup_pin_num %x",
+		 cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
 
 	wmi_mtrace(WMI_EXTWOW_ENABLE_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1844,14 +1841,14 @@ static QDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_hand
 	cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
 	cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
 
-	WMI_LOGD("%s: vdev_id %d gateway_mac "QDF_MAC_ADDR_FMT" "
+	wmi_debug("vdev_id %d gateway_mac "QDF_MAC_ADDR_FMT" "
 		 "rc4_key %.16s rc4_key_len %u "
 		 "ip_id %x ip_device_ip %x ip_server_ip %x "
 		 "tcp_src_port %u tcp_dst_port %u tcp_seq %u "
 		 "tcp_ack_seq %u keepalive_init %u keepalive_min %u "
 		 "keepalive_max %u keepalive_inc %u "
 		 "tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
-		 __func__, cmd->vdev_id,
+		 cmd->vdev_id,
 		 QDF_MAC_ADDR_REF(appType2Params->gateway_mac.bytes),
 		 cmd->rc4_key, cmd->rc4_key_len,
 		 cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
@@ -1910,10 +1907,10 @@ static QDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_mem_copy(cmd->passwd, app_type1_params->password, 16);
 	cmd->passwd_len = app_type1_params->pass_length;
 
-	WMI_LOGD("%s: vdev_id %d wakee_mac_addr "QDF_MAC_ADDR_FMT" "
+	wmi_debug("vdev_id %d wakee_mac_addr "QDF_MAC_ADDR_FMT" "
 		 "identification_id %.8s id_length %u "
 		 "password %.16s pass_length %u",
-		 __func__, cmd->vdev_id,
+		 cmd->vdev_id,
 		 QDF_MAC_ADDR_REF(app_type1_params->wakee_mac_addr.bytes),
 		 cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);
 

wmi/src/wmi_unified_sta_tlv.c

@@ -61,7 +61,7 @@ static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->sa_query_max_retry_count = max_retries;
 	cmd->sa_query_retry_interval = retry_interval;
 
-	WMI_LOGD(FL("STA sa query: vdev_id:%d interval:%u retry count:%d"),
+	wmi_debug("STA sa query: vdev_id:%d interval:%u retry count:%d",
 		 vdev_id, retry_interval, max_retries);
 
 	wmi_mtrace(WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID, cmd->vdev_id, 0);
@@ -72,7 +72,7 @@ static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	WMI_LOGD(FL("Exit :"));
+	wmi_debug("Exit");
 	return 0;
 }
 
@@ -96,7 +96,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
 	int len;
 	QDF_STATUS ret;
 
-	WMI_LOGD("%s: Enter", __func__);
+	wmi_debug("Enter");
 
 	len = sizeof(*cmd) + sizeof(*arp_rsp);
 	buf = wmi_buf_alloc(wmi_handle, len);
@@ -113,7 +113,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->interval = params->timeperiod;
 	cmd->enable = (params->timeperiod) ? 1 : 0;
 	cmd->vdev_id = params->vdev_id;
-	WMI_LOGD("Keep Alive: vdev_id:%d interval:%u method:%d",
+	wmi_debug("Keep Alive: vdev_id:%d interval:%u method:%d",
 		 params->vdev_id, params->timeperiod, params->method);
 	arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd));
 	WMITLV_SET_HDR(&arp_rsp->tlv_header,
@@ -142,7 +142,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_buf_free(buf);
 	}
 
-	WMI_LOGD("%s: Exit", __func__);
+	wmi_debug("Exit");
 	return ret;
 }
 
@@ -184,7 +184,7 @@ static QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32
 	cmd->gtxTPCMin = gtx_info->gtx_tpcmin;
 	cmd->gtxBWMask = gtx_info->gtx_bwmask;
 
-	WMI_LOGD("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
+	wmi_debug("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
 		 gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \
 		 gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1],
 		 cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin,
@@ -418,7 +418,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
 		break;
 
 	default:
-		WMI_LOGD("%s: invalid profiling command", __func__);
+		wmi_debug("Invalid profiling command: %u", cmd);
 		break;
 	}
 
@@ -438,7 +438,7 @@ static QDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_
 	wmi_buf_t buf;
 	int32_t len = sizeof(*cmd);
 
-	WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
+	wmi_debug("vdev_id: %d", vdev_id);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
 		return QDF_STATUS_E_NOMEM;
@@ -518,7 +518,7 @@ static uint8_t tdls_get_wmi_offchannel_mode(uint8_t tdls_sw_mode)
 		break;
 
 	default:
-		WMI_LOGD(FL("unknown tdls_sw_mode %d"), tdls_sw_mode);
+		wmi_debug("unknown tdls_sw_mode: %d", tdls_sw_mode);
 		off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL;
 	}
 	return off_chan_mode;
@@ -551,7 +551,7 @@ static uint8_t tdls_get_wmi_offchannel_bw(uint16_t tdls_off_ch_bw_offset)
 		off_chan_bw = WMI_TDLS_OFFCHAN_160MHZ;
 		break;
 	default:
-		WMI_LOGD(FL("unknown tdls offchannel bw offset %d"),
+		wmi_debug("unknown tdls offchannel bw offset: %d",
 			 tdls_off_ch_bw_offset);
 		off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ;
 	}
@@ -598,14 +598,13 @@ static QDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle,
 			chan_switch_params->tdls_off_ch_bw_offset);
 	cmd->offchan_oper_class = chan_switch_params->oper_class;
 
-	WMI_LOGD(FL("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x"),
+	wmi_debug("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
 		 cmd->peer_macaddr.mac_addr31to0,
 		 cmd->peer_macaddr.mac_addr47to32);
 
-	WMI_LOGD(FL(
-		 "vdev_id: %d, off channel mode: %d, off channel Num: %d, "
+	wmi_debug("vdev_id: %d, off channel mode: %d, off channel Num: %d, "
 		 "off channel frequency: %u off channel offset: 0x%x, "
-		 " is_peer_responder: %d, operating class: %d"),
+		 "is_peer_responder: %d, operating class: %d",
 		 cmd->vdev_id,
 		 cmd->offchan_mode,
 		 cmd->offchan_num,
@@ -674,7 +673,7 @@ send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->tdls_discovery_wake_timeout =
 		tdls_param->tdls_discovery_wake_timeout;
 
-	WMI_LOGD("%s: vdev %d tdls_state: %d, state: %d, "
+	wmi_debug("vdev %d tdls_state: %d, state: %d, "
 		 "notification_interval_ms: %d, "
 		 "tx_discovery_threshold: %d, "
 		 "tx_teardown_threshold: %d, "
@@ -689,7 +688,7 @@ send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
 		 "teardown_notification_ms: %d, "
 		 "tdls_peer_kickout_threshold: %d, "
 		 "tdls_discovery_wake_timeout: %d",
-		 __func__,tdls_param->vdev_id, tdls_state, cmd->state,
+		 tdls_param->vdev_id, tdls_state, cmd->state,
 		 cmd->notification_interval_ms,
 		 cmd->tx_discovery_threshold,
 		 cmd->tx_teardown_threshold,
@@ -761,10 +760,10 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd->peer_state = peer_state->peer_state;
 
-	WMI_LOGD("%s: vdev_id: %d, peermac: "QDF_MAC_ADDR_FMT", "
+	wmi_debug("vdev_id: %d, peermac: "QDF_MAC_ADDR_FMT", "
 		 "peer_macaddr.mac_addr31to0: 0x%x, "
 		 "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
-		 __func__, cmd->vdev_id,
+		 cmd->vdev_id,
 		 QDF_MAC_ADDR_REF(peer_state->peer_macaddr),
 		 cmd->peer_macaddr.mac_addr31to0,
 		 cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
@@ -799,7 +798,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 	peer_cap->peer_chan_len = in_peer_cap->peer_chanlen;
 	peer_cap->peer_operclass_len = in_peer_cap->peer_oper_classlen;
 
-	WMI_LOGD("peer_operclass_len: %d", peer_cap->peer_operclass_len);
+	wmi_debug("peer_operclass_len: %d", peer_cap->peer_operclass_len);
 	for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
 		peer_cap->peer_operclass[i] = in_peer_cap->peer_oper_class[i];
 	}
@@ -812,12 +811,11 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 	peer_cap->pref_offchan_num = in_peer_cap->pref_off_channum;
 	peer_cap->pref_offchan_bw = in_peer_cap->pref_off_chan_bandwidth;
 
-	WMI_LOGD
-		("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
+	wmi_debug("peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
 		 "peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: "
 		 "%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:"
 		 " %d, pref_offchan_bw: %d, pref_offchan_freq: %u",
-		 __func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
+		 peer_cap->peer_qos, peer_cap->buff_sta_support,
 		 peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
 		 peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
 		 peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
@@ -842,7 +840,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 		chan_info->band_center_freq1 = chan_info->mhz;
 		chan_info->band_center_freq2 = 0;
 
-		WMI_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
+		wmi_debug("chan[%d] = %u", i, chan_info->mhz);
 
 		if (in_chan_info->dfs_set) {
 			WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
@@ -858,7 +856,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
 
 		WMI_SET_CHANNEL_MAX_TX_POWER(chan_info, in_chan_info->pwr);
 		WMI_SET_CHANNEL_REG_POWER(chan_info, in_chan_info->pwr);
-		WMI_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
+		wmi_debug("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
 			 in_chan_info->pwr);
 
 		chan_info++;
@@ -969,8 +967,8 @@ static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	};
 
-	WMI_LOGD("%s: tdls event, peer: "QDF_MAC_ADDR_FMT", type: 0x%x, reason: %d, vdev: %d",
-		 __func__, QDF_MAC_ADDR_REF(param->peermac.bytes),
+	wmi_debug("tdls event, peer: "QDF_MAC_ADDR_FMT", type: 0x%x, reason: %d, vdev: %d",
+		 QDF_MAC_ADDR_REF(param->peermac.bytes),
 		 param->message_type,
 		 param->peer_reason, param->vdev_id);
 
@@ -1034,8 +1032,8 @@ static QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->ie_len = ie_info->length;
 	cmd->band = ie_info->band;
 
-	WMI_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
-		    ie_info->length, ie_info->vdev_id);
+	wmi_debug("IE:%d of size:%d sent for vdev:%d", ie_info->ie_id,
+		 ie_info->length, ie_info->vdev_id);
 
 	buf_ptr += sizeof(*cmd);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
@@ -1172,7 +1170,7 @@ send_reject_ap_list_cmd_tlv(wmi_unified_t wmi_handle,
 	if (!buf)
 		return QDF_STATUS_E_NOMEM;
 
-	WMI_LOGD("num of reject BSSIDs %d", num_of_reject_bssid);
+	wmi_debug("num of reject BSSIDs %d", num_of_reject_bssid);
 
 	buf_ptr = (uint8_t *)wmi_buf_data(buf);
 	chan_list_fp = (wmi_pdev_dsm_filter_fixed_param *)buf_ptr;
@@ -1266,7 +1264,7 @@ static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->commit_limits = sar_limit_params->commit_limits;
 	cmd->num_limit_rows = sar_limit_params->num_limit_rows;
 
-	WMI_LOGD("no of sar rows = %d, len = %d",
+	wmi_debug("no of sar rows = %d, len = %d",
 		 sar_limit_params->num_limit_rows, len);
 	buf_ptr += sizeof(*cmd);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
@@ -1289,7 +1287,7 @@ static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_sar_rows_list->limit_value = sar_rows_list->limit_value;
 		wmi_sar_rows_list->validity_bitmap =
 						sar_rows_list->validity_bitmap;
-		WMI_LOGD("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d",
+		wmi_debug("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d",
 			 i, wmi_sar_rows_list->band_id,
 			 wmi_sar_rows_list->chain_id,
 			 wmi_sar_rows_list->mod_id,
@@ -1319,7 +1317,7 @@ static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
 	uint32_t len;
 	QDF_STATUS status;
 
-	WMI_LOGD(FL("Enter"));
+	wmi_debug("Enter");
 
 	len = sizeof(*cmd);
 	wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -1344,7 +1342,7 @@ static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
 		wmi_buf_free(wmi_buf);
 	}
 
-	WMI_LOGD(FL("Exit"));
+	wmi_debug("Exit");
 
 	return status;
 }
@@ -1451,7 +1449,7 @@ static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
 
 	row_in = param_buf->sar_get_limits;
 	if (!row_in) {
-		WMI_LOGD("sar_get_limits is NULL");
+		wmi_debug("sar_get_limits is NULL");
 	} else {
 		row_out = &event->sar_limit_row[0];
 		for (row = 0; row < event->num_limit_rows; row++) {
@@ -1575,8 +1573,7 @@ static QDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
 	cmd->vdev_id = vdev_id;
 	cmd->ac = ac;
 
-	WMI_LOGD("Delts vdev:%d, ac:%d, %s:%d",
-		 cmd->vdev_id, cmd->ac, __func__, __LINE__);
+	wmi_debug("Delts vdev:%d, ac:%d", cmd->vdev_id, cmd->ac);
 	wmi_mtrace(WMI_VDEV_WMM_DELTS_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_VDEV_WMM_DELTS_CMDID)) {
@@ -1635,8 +1632,8 @@ static QDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle,
 			cmd->medium_time_us =
 				aggr_qos_rsp_msg->tspec[i].mediumTime * 32;
 			cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
-			WMI_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
-				 __func__, __LINE__, cmd->vdev_id, cmd->ac,
+			wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
+				 cmd->vdev_id, cmd->ac,
 				 cmd->medium_time_us, cmd->downgrade_type);
 			wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
 			if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1682,9 +1679,9 @@ static QDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->ac = msg->tspec.tsinfo.traffic.userPrio;
 	cmd->medium_time_us = msg->tspec.mediumTime * 32;
 	cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
-	WMI_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
+	wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d",
 		 cmd->vdev_id, cmd->ac, cmd->medium_time_us,
-		 cmd->downgrade_type, __func__, __LINE__);
+		 cmd->downgrade_type);
 	wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_VDEV_WMM_ADDTS_CMDID)) {
@@ -1747,10 +1744,10 @@ static QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(
 	buf_ptr += WMI_TLV_HDR_SIZE;
 	qdf_mem_copy(buf_ptr, pattern->ucPattern, ptrn_len);
 	for (j = 0; j < pattern->ucPtrnSize; j++)
-		WMI_LOGD("%s: Add Ptrn: %02x", __func__, buf_ptr[j] & 0xff);
+		wmi_debug("Add Ptrn: %02x", buf_ptr[j] & 0xff);
 
-	WMI_LOGD("%s: Add ptrn id: %d vdev_id: %d",
-		 __func__, cmd->pattern_id, cmd->vdev_id);
+	wmi_debug("Add ptrn id: %d vdev_id: %d",
+		 cmd->pattern_id, cmd->vdev_id);
 
 	wmi_mtrace(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
@@ -1795,8 +1792,8 @@ static QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(
 	/* Pass the pattern id to delete for the corresponding vdev id */
 	cmd->vdev_id = vdev_id;
 	cmd->pattern_id = pattern_id;
-	WMI_LOGD("%s: Del ptrn id: %d vdev_id: %d",
-		 __func__, cmd->pattern_id, cmd->vdev_id);
+	wmi_debug("Del ptrn id: %d vdev_id: %d",
+		 cmd->pattern_id, cmd->vdev_id);
 
 	wmi_mtrace(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
@@ -1824,8 +1821,8 @@ static QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd;
 	int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param);
 
-	WMI_LOGD("%s: Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
-		 __func__, timer_val);
+	wmi_debug("Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
+		 timer_val);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -2035,8 +2032,8 @@ QDF_STATUS send_pdev_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle,
 							WMI_HOST_PDEV_ID_SOC);
 	cmd->concurrent_scan_config_bits = msg->scan_config;
 	cmd->fw_mode_config_bits = msg->fw_mode_config;
-	WMI_LOGD("%s: scan_config:%x fw_mode_config:%x",
-		 __func__, msg->scan_config, msg->fw_mode_config);
+	wmi_debug("scan_config:%x fw_mode_config:%x",
+		 msg->scan_config, msg->fw_mode_config);
 
 	wmi_mtrace(WMI_PDEV_SET_MAC_CONFIG_CMDID, NO_SESSION, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2226,7 +2223,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_set_arp->pkt_type = req_buf->pkt_type;
 	wmi_set_arp->ipv4 = req_buf->ip_addr;
 
-	WMI_LOGD("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u",
+	wmi_debug("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u",
 		 wmi_set_arp->vdev_id, wmi_set_arp->set_clr,
 		 wmi_set_arp->pkt_type, wmi_set_arp->ipv4);
 
@@ -2254,7 +2251,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_set_connect_stats->tcp_dst_port = req_buf->tcp_dst_port;
 		wmi_set_connect_stats->icmp_ipv4 = req_buf->icmp_ipv4;
 
-		WMI_LOGD("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u",
+		wmi_debug("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u",
 			 wmi_set_connect_stats->pkt_type_bitmap,
 			 wmi_set_connect_stats->tcp_src_port,
 			 wmi_set_connect_stats->tcp_dst_port,
@@ -2270,7 +2267,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
 		goto error;
 	}
 
-	WMI_LOGD(FL("set arp stats flag=%d, vdev=%d"),
+	wmi_debug("set arp stats flag=%d, vdev=%d",
 		 req_buf->flag, req_buf->vdev_id);
 	return QDF_STATUS_SUCCESS;
 error:
@@ -2386,8 +2383,7 @@ static QDF_STATUS send_peer_unmap_conf_cmd_tlv(wmi_unified_t wmi,
 	for (i = 0; i < peer_id_cnt; i++)
 		peer_ids[i] = peer_id_list[i];
 
-	WMI_LOGD("%s: vdev_id %d peer_id_cnt %d", __func__,
-		 vdev_id, peer_id_cnt);
+	wmi_debug("vdev_id %d peer_id_cnt %d", vdev_id, peer_id_cnt);
 	wmi_mtrace(WMI_PEER_UNMAP_RESPONSE_CMDID, vdev_id, 0);
 	status = wmi_unified_cmd_send(wmi, buf, len,
 				      WMI_PEER_UNMAP_RESPONSE_CMDID);

wmi/src/wmi_unified_tlv.c

@@ -762,17 +762,17 @@ static QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->num_cfg_txrx_streams = num_bands;
 	copy_vdev_create_pdev_id(wmi_handle, cmd, param);
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
-	WMI_LOGD("%s: ID = %d[pdev:%d] VAP Addr = "QDF_MAC_ADDR_FMT,
-		 __func__, param->vdev_id, cmd->pdev_id,
+	wmi_debug("ID = %d[pdev:%d] VAP Addr = "QDF_MAC_ADDR_FMT,
+		 param->vdev_id, cmd->pdev_id,
 		 QDF_MAC_ADDR_REF(macaddr));
 	buf_ptr = (uint8_t *)cmd + sizeof(*cmd);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
 			(num_bands * sizeof(wmi_vdev_txrx_streams)));
 	buf_ptr += WMI_TLV_HDR_SIZE;
 
-	WMI_LOGD("%s: type %d, subtype %d, nss_2g %d, nss_5g %d", __func__,
-			param->type, param->subtype,
-			param->nss_2g, param->nss_5g);
+	wmi_debug("type %d, subtype %d, nss_2g %d, nss_5g %d",
+		 param->type, param->subtype,
+		 param->nss_2g, param->nss_5g);
 	txrx_streams = (wmi_vdev_txrx_streams *)buf_ptr;
 	txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_2G;
 	txrx_streams->supported_tx_streams = param->nss_2g;
@@ -830,7 +830,7 @@ static QDF_STATUS send_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_err("Failed to send WMI_VDEV_DELETE_CMDID");
 		wmi_buf_free(buf);
 	}
-	WMI_LOGD("%s:vdev id = %d", __func__, if_id);
+	wmi_debug("vdev id = %d", if_id);
 
 	return ret;
 }
@@ -886,7 +886,7 @@ send_vdev_nss_chain_params_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_err("Failed to send WMI_VDEV_CHAINMASK_CONFIG_CMDID");
 		wmi_buf_free(buf);
 	}
-	WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
+	wmi_debug("vdev_id %d", vdev_id);
 
 	return ret;
 }
@@ -920,7 +920,7 @@ static QDF_STATUS send_vdev_stop_cmd_tlv(wmi_unified_t wmi,
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("%s:vdev id = %d", __func__, vdev_id);
+	wmi_debug("vdev id = %d", vdev_id);
 
 	return 0;
 }
@@ -953,7 +953,7 @@ static QDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
+	wmi_debug("vdev_id %d", vdev_id);
 
 	return 0;
 }
@@ -1131,8 +1131,8 @@ static QDF_STATUS send_peer_flush_tids_cmd_tlv(wmi_unified_t wmi,
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
 	cmd->peer_tid_bitmap = param->peer_tid_bitmap;
 	cmd->vdev_id = param->vdev_id;
-	WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d and peer bitmap %d",
-		 __func__, QDF_MAC_ADDR_REF(peer_addr), param->vdev_id,
+	wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d and peer bitmap %d",
+		 QDF_MAC_ADDR_REF(peer_addr), param->vdev_id,
 		 param->peer_tid_bitmap);
 	wmi_mtrace(WMI_PEER_FLUSH_TIDS_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) {
@@ -1171,8 +1171,8 @@ static QDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi,
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
 	cmd->vdev_id = vdev_id;
 
-	WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
-		 __func__, QDF_MAC_ADDR_REF(peer_addr), vdev_id);
+	wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
+		 QDF_MAC_ADDR_REF(peer_addr), vdev_id);
 	wmi_mtrace(WMI_PEER_DELETE_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) {
 		wmi_err("Failed to send peer delete command");
@@ -1210,7 +1210,7 @@ static QDF_STATUS send_peer_delete_all_cmd_tlv(
 				(wmi_vdev_delete_all_peer_cmd_fixed_param));
 	cmd->vdev_id = param->vdev_id;
 
-	WMI_LOGD("%s: vdev_id %d", __func__, cmd->vdev_id);
+	wmi_debug("vdev_id %d", cmd->vdev_id);
 	wmi_mtrace(WMI_VDEV_DELETE_ALL_PEER_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi, buf, len,
 				 WMI_VDEV_DELETE_ALL_PEER_CMDID)) {
@@ -1282,8 +1282,8 @@ static QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
 	cmd->param_id = param_id;
 	cmd->param_value = param->param_value;
 
-	WMI_LOGD("%s: vdev_id %d peer_mac: "QDF_MAC_ADDR_FMT" param_id: %u param_value: %x",
-		 __func__, cmd->vdev_id,
+	wmi_debug("vdev_id %d peer_mac: "QDF_MAC_ADDR_FMT" param_id: %u param_value: %x",
+		 cmd->vdev_id,
 		 QDF_MAC_ADDR_REF(peer_addr), param->param_id,
 		 cmd->param_value);
 
@@ -1316,9 +1316,8 @@ static QDF_STATUS send_vdev_up_cmd_tlv(wmi_unified_t wmi,
 	wmi_buf_t buf;
 	int32_t len = sizeof(*cmd);
 
-	WMI_LOGD("%s: VDEV_UP", __func__);
-	WMI_LOGD("%s: vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT,
-		 __func__,
+	wmi_debug("VDEV_UP");
+	wmi_debug("vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT,
 		 params->vdev_id, params->assoc_id, QDF_MAC_ADDR_REF(bssid));
 	buf = wmi_buf_alloc(wmi, len);
 	if (!buf)
@@ -1379,9 +1378,9 @@ static QDF_STATUS send_peer_create_cmd_tlv(wmi_unified_t wmi,
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
-		 __func__, QDF_MAC_ADDR_REF(param->peer_addr),
-		param->vdev_id);
+	wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
+		 QDF_MAC_ADDR_REF(param->peer_addr),
+		 param->vdev_id);
 
 	return 0;
 }
@@ -1428,10 +1427,9 @@ QDF_STATUS send_peer_rx_reorder_queue_setup_cmd_tlv(wmi_unified_t wmi,
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("%s: peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid %d",
-		 __func__,
-		QDF_MAC_ADDR_REF(param->peer_macaddr),
-		param->vdev_id, param->tid);
+	wmi_debug("peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid %d",
+		 QDF_MAC_ADDR_REF(param->peer_macaddr),
+		 param->vdev_id, param->tid);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -1473,10 +1471,9 @@ QDF_STATUS send_peer_rx_reorder_queue_remove_cmd_tlv(wmi_unified_t wmi,
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("%s: peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid_map %d",
-		__func__,
-		QDF_MAC_ADDR_REF(param->peer_macaddr),
-		param->vdev_id, param->peer_tid_bitmap);
+	wmi_debug("peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid_map %d",
+		 QDF_MAC_ADDR_REF(param->peer_macaddr),
+		 param->vdev_id, param->peer_tid_bitmap);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -1497,7 +1494,7 @@ static QDF_STATUS send_green_ap_ps_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_buf_t buf;
 	int32_t len = sizeof(*cmd);
 
-	WMI_LOGD("Set Green AP PS val %d", value);
+	wmi_debug("Set Green AP PS val %d", value);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf)
@@ -1577,13 +1574,13 @@ send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle,
 		segHdrInfo.segmentInfo = segInfo;
 		segHdrInfo.pad = 0;
 
-		WMI_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
+		wmi_debug("segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
 			 " segHdrInfo.segmentInfo = %d",
-			 __func__, segHdrInfo.len, segHdrInfo.msgref,
+			 segHdrInfo.len, segHdrInfo.msgref,
 			 segHdrInfo.segmentInfo);
 
-		WMI_LOGD("%s:total_bytes %d segNumber %d totalSegments %d"
-			 "chunk len %d", __func__, total_bytes, segNumber,
+		wmi_debug("total_bytes %d segNumber %d totalSegments %d"
+			 " chunk len %d", total_bytes, segNumber,
 			 numSegments, chunk_len);
 
 		segNumber++;
@@ -1673,8 +1670,8 @@ send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
 								mac_id);
 	cmd->param_id = pdev_param;
 	cmd->param_value = param->param_value;
-	WMI_LOGD("Setting pdev param = %x, value = %u", param->param_id,
-				param->param_value);
+	wmi_debug("Setting pdev param = %x, value = %u", param->param_id,
+		 param->param_value);
 	wmi_mtrace(WMI_PDEV_SET_PARAM_CMDID, NO_SESSION, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				   WMI_PDEV_SET_PARAM_CMDID);
@@ -1721,7 +1718,7 @@ static QDF_STATUS send_pdev_set_hw_mode_cmd_tlv(wmi_unified_t wmi_handle,
 							wmi_handle,
 							WMI_HOST_PDEV_ID_SOC);
 	cmd->hw_mode_index = hw_mode_index;
-	WMI_LOGD("%s: HW mode index:%d", __func__, cmd->hw_mode_index);
+	wmi_debug("HW mode index:%d", cmd->hw_mode_index);
 
 	wmi_mtrace(WMI_PDEV_SET_HW_MODE_CMDID, NO_SESSION, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2101,7 +2098,7 @@ static QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->vdev_id = param->vdev_id;
 	cmd->param_id = vdev_param;
 	cmd->param_value = param->param_value;
-	WMI_LOGD("Setting vdev %d param = %x, value = %u",
+	wmi_debug("Setting vdev %d param = %x, value = %u",
 		 cmd->vdev_id, cmd->param_id, cmd->param_value);
 	wmi_mtrace(WMI_VDEV_SET_PARAM_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2293,9 +2290,9 @@ static void send_time_stamp_sync_cmd_tlv(wmi_unified_t wmi_handle)
 	 * wont exceed 27 bit
 	 */
 	time_stamp->time_stamp_high = 0;
-	WMI_LOGD(FL("WMA --> DBGLOG_TIME_STAMP_SYNC_CMDID mode %d time_stamp low %d high %d"),
-		time_stamp->mode, time_stamp->time_stamp_low,
-		time_stamp->time_stamp_high);
+	wmi_debug("WMA --> DBGLOG_TIME_STAMP_SYNC_CMDID mode %d time_stamp low %d high %d",
+		 time_stamp->mode, time_stamp->time_stamp_low,
+		 time_stamp->time_stamp_high);
 
 	wmi_mtrace(WMI_DBGLOG_TIME_STAMP_SYNC_CMDID, NO_SESSION, 0);
 	status = wmi_unified_cmd_send(wmi_handle, buf,
@@ -2653,8 +2650,8 @@ static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
 
 		he_mcs->rx_mcs_set = param->peer_he_rx_mcs_set[i];
 		he_mcs->tx_mcs_set = param->peer_he_tx_mcs_set[i];
-		WMI_LOGD("%s:HE idx %d RxMCSmap %x TxMCSmap %x ", __func__,
-			i, he_mcs->rx_mcs_set, he_mcs->tx_mcs_set);
+		wmi_debug("HE idx %d RxMCSmap %x TxMCSmap %x ",
+			 i, he_mcs->rx_mcs_set, he_mcs->tx_mcs_set);
 		buf_ptr += sizeof(wmi_he_rate_set);
 	}
 
@@ -2663,22 +2660,22 @@ static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
 	     == WMI_HOST_HE_INVALID_MCSNSSMAP ||
 	     param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]
 	     == WMI_HOST_HE_INVALID_MCSNSSMAP)) {
-		WMI_LOGD("param->peer_he_tx_mcs_set[160MHz]=%x",
+		wmi_debug("param->peer_he_tx_mcs_set[160MHz]=%x",
 			 param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]);
-		WMI_LOGD("param->peer_he_rx_mcs_set[160MHz]=%x",
+		wmi_debug("param->peer_he_rx_mcs_set[160MHz]=%x",
 			 param->peer_he_rx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]);
-		WMI_LOGD("peer_mac="QDF_MAC_ADDR_FMT,
+		wmi_debug("peer_mac="QDF_MAC_ADDR_FMT,
 			 QDF_MAC_ADDR_REF(param->peer_mac));
 	}
 
-	WMI_LOGD("%s: vdev_id %d associd %d peer_flags %x rate_caps %x "
+	wmi_debug("vdev_id %d associd %d peer_flags %x rate_caps %x "
 		 "peer_caps %x listen_intval %d ht_caps %x max_mpdu %d "
 		 "nss %d phymode %d peer_mpdu_density %d "
 		 "cmd->peer_vht_caps %x "
 		 "HE cap_info %x ops %x "
 		 "HE cap_info_ext %x "
 		 "HE phy %x  %x  %x  "
-		 "peer_bw_rxnss_override %x", __func__,
+		 "peer_bw_rxnss_override %x",
 		 cmd->vdev_id, cmd->peer_associd, cmd->peer_flags,
 		 cmd->peer_rate_caps, cmd->peer_caps,
 		 cmd->peer_listen_intval, cmd->peer_ht_caps,
@@ -3223,7 +3220,7 @@ static QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
 			       WMITLV_GET_STRUCT_TLVLEN
 			       (wmi_scan_chan_list_cmd_fixed_param));
 
-		WMI_LOGD("no of channels = %d, len = %d", num_send_chans, len);
+		wmi_debug("no of channels = %d, len = %d", num_send_chans, len);
 
 		if (num_sends)
 			cmd->flags |= APPEND_TO_EXISTING_CHAN_LIST;
@@ -3653,8 +3650,7 @@ static QDF_STATUS send_modem_power_state_cmd_tlv(wmi_unified_t wmi_handle,
 		       WMITLV_GET_STRUCT_TLVLEN
 			       (wmi_modem_power_state_cmd_param));
 	cmd->modem_power_state = param_value;
-	WMI_LOGD("%s: Setting cmd->modem_power_state = %u", __func__,
-		 param_value);
+	wmi_debug("Setting cmd->modem_power_state = %u", param_value);
 	wmi_mtrace(WMI_MODEM_POWER_STATE_CMDID, NO_SESSION, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
 				     WMI_MODEM_POWER_STATE_CMDID);
@@ -3681,7 +3677,7 @@ static QDF_STATUS send_set_sta_ps_mode_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_buf_t buf;
 	int32_t len = sizeof(*cmd);
 
-	WMI_LOGD("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
+	wmi_debug("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf)
@@ -3735,7 +3731,7 @@ static QDF_STATUS send_idle_roam_monitor_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->idle_trigger_monitor = (val ? WMI_IDLE_TRIGGER_MONITOR_ON :
 					   WMI_IDLE_TRIGGER_MONITOR_OFF);
 
-	WMI_LOGD("val:%d", cmd->idle_trigger_monitor);
+	wmi_debug("val: %d", cmd->idle_trigger_monitor);
 
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_IDLE_TRIGGER_MONITOR_CMDID)) {
@@ -3796,7 +3792,7 @@ static QDF_STATUS send_set_mimops_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	WMI_LOGD("Setting vdev %d value = %u", vdev_id, value);
+	wmi_debug("Setting vdev %d value = %u", vdev_id, value);
 
 	wmi_mtrace(WMI_STA_SMPS_FORCE_MODE_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -3840,7 +3836,7 @@ static QDF_STATUS send_set_smps_params_cmd_tlv(wmi_unified_t wmi_handle, uint8_t
 	cmd->param =
 		(value >> WMI_SMPS_PARAM_VALUE_S) & WMI_SMPS_MASK_UPPER_3BITS;
 
-	WMI_LOGD("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
+	wmi_debug("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
 		 cmd->param);
 
 	wmi_mtrace(WMI_STA_SMPS_PARAM_CMDID, cmd->vdev_id, 0);
@@ -4122,7 +4118,7 @@ static QDF_STATUS send_lro_config_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
 								wmi_handle,
 								pdev_id);
-	WMI_LOGD("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x, pdev_id: %d",
+	wmi_debug("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x, pdev_id: %d",
 		 cmd->lro_enable, cmd->tcp_flag_u32, cmd->pdev_id);
 
 	wmi_mtrace(WMI_LRO_CONFIG_CMDID, NO_SESSION, 0);
@@ -4284,7 +4280,7 @@ static QDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
 	uint8_t *buf_ptr;
 	QDF_STATUS ret;
 
-	WMI_LOGD(FL("Send probe response template for vdev %d"), vdev_id);
+	wmi_debug("Send probe response template for vdev %d", vdev_id);
 
 	tmpl_len = probe_rsp_info->prb_rsp_template_len;
 	tmpl_len_aligned = roundup(tmpl_len, sizeof(uint32_t));
@@ -4502,7 +4498,7 @@ static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
 	buf_ptr += WMI_TLV_HDR_SIZE;
 	qdf_mem_copy(buf_ptr, p2p_ie, ie_len);
 
-	WMI_LOGD("%s: Sending WMI_P2P_GO_SET_BEACON_IE", __func__);
+	wmi_debug("Sending WMI_P2P_GO_SET_BEACON_IE");
 
 	wmi_mtrace(WMI_P2P_GO_SET_BEACON_IE, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle,
@@ -4513,7 +4509,7 @@ static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_buf_free(wmi_buf);
 	}
 
-	WMI_LOGD("%s: Successfully sent WMI_P2P_GO_SET_BEACON_IE", __func__);
+	wmi_debug("Successfully sent WMI_P2P_GO_SET_BEACON_IE");
 	return ret;
 }
 
@@ -4554,8 +4550,7 @@ static QDF_STATUS send_scan_probe_setoui_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_mem_zero(oui_buf, sizeof(cmd->prob_req_oui));
 	*oui_buf = psetoui->oui[0] << 16 | psetoui->oui[1] << 8
 		   | psetoui->oui[2];
-	WMI_LOGD("%s: wmi:oui received from hdd %08x", __func__,
-		 cmd->prob_req_oui);
+	wmi_debug("wmi:oui received from hdd %08x", cmd->prob_req_oui);
 
 	cmd->vdev_id = psetoui->vdev_id;
 	cmd->flags = WMI_SCAN_PROBE_OUI_SPOOFED_MAC_IN_PROBE_REQ;
@@ -4611,7 +4606,7 @@ static QDF_STATUS send_ipa_offload_control_cmd_tlv(wmi_unified_t wmi_handle,
 	if (!wmi_buf)
 		return QDF_STATUS_E_NOMEM;
 
-	WMI_LOGD("%s: offload_type=%d, enable=%d", __func__,
+	wmi_debug("offload_type=%d, enable=%d",
 		ipa_offload->offload_type, ipa_offload->enable);
 
 	buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf);
@@ -4725,11 +4720,11 @@ static void wmi_set_pno_channel_prediction(uint8_t *buf_ptr,
 		pno->channel_prediction_full_scan;
 #endif
 	buf_ptr += sizeof(nlo_channel_prediction_cfg);
-	WMI_LOGD("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d",
-			channel_prediction_cfg->enable,
-			channel_prediction_cfg->top_k_num,
-			channel_prediction_cfg->stationary_threshold,
-			channel_prediction_cfg->full_scan_period_ms);
+	wmi_debug("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d",
+		 channel_prediction_cfg->enable,
+		 channel_prediction_cfg->top_k_num,
+		 channel_prediction_cfg->stationary_threshold,
+		 channel_prediction_cfg->full_scan_period_ms);
 }
 
 /**
@@ -4829,11 +4824,11 @@ static QDF_STATUS send_nlo_mawc_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_nlo_mawc_params->exp_backoff_ratio = params->exp_backoff_ratio;
 	wmi_nlo_mawc_params->init_scan_interval = params->init_scan_interval;
 	wmi_nlo_mawc_params->max_scan_interval = params->max_scan_interval;
-	WMI_LOGD(FL("MAWC NLO en=%d, vdev=%d, ratio=%d, SCAN init=%d, max=%d"),
-		wmi_nlo_mawc_params->enable, wmi_nlo_mawc_params->vdev_id,
-		wmi_nlo_mawc_params->exp_backoff_ratio,
-		wmi_nlo_mawc_params->init_scan_interval,
-		wmi_nlo_mawc_params->max_scan_interval);
+	wmi_debug("MAWC NLO en=%d, vdev=%d, ratio=%d, SCAN init=%d, max=%d",
+		 wmi_nlo_mawc_params->enable, wmi_nlo_mawc_params->vdev_id,
+		 wmi_nlo_mawc_params->exp_backoff_ratio,
+		 wmi_nlo_mawc_params->init_scan_interval,
+		 wmi_nlo_mawc_params->max_scan_interval);
 
 	wmi_mtrace(WMI_NLO_CONFIGURE_MAWC_CMDID, NO_SESSION, 0);
 	status = wmi_unified_cmd_send(wmi_handle, buf,
@@ -5102,11 +5097,11 @@ static QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(clear_req->peer_macaddr.bytes,
 				   &cmd->peer_macaddr);
 
-	WMI_LOGD("LINK_LAYER_STATS - Clear Request Params");
-	WMI_LOGD("StopReq: %d", cmd->stop_stats_collection_req);
-	WMI_LOGD("Vdev Id: %d", cmd->vdev_id);
-	WMI_LOGD("Clear Stat Mask: %d", cmd->stats_clear_req_mask);
-	WMI_LOGD("Peer MAC Addr: "QDF_MAC_ADDR_FMT,
+	wmi_debug("LINK_LAYER_STATS - Clear Request Params");
+	wmi_debug("StopReq: %d Vdev Id: %d Clear Stat Mask: %d"
+		 " Peer MAC Addr: "QDF_MAC_ADDR_FMT,
+		 cmd->stop_stats_collection_req,
+		 cmd->vdev_id, cmd->stats_clear_req_mask,
 		 QDF_MAC_ADDR_REF(clear_req->peer_macaddr.bytes));
 
 	wmi_mtrace(WMI_CLEAR_LINK_STATS_CMDID, cmd->vdev_id, 0);
@@ -5118,7 +5113,7 @@ static QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	WMI_LOGD("Clear Link Layer Stats request sent successfully");
+	wmi_debug("Clear Link Layer Stats request sent successfully");
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -5157,7 +5152,7 @@ static QDF_STATUS send_process_ll_stats_set_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->aggressive_statistics_gathering =
 		set_req->aggressive_statistics_gathering;
 
-	WMI_LOGD("LINK_LAYER_STATS - Start/Set Params MPDU Size Thresh : %d Aggressive Gather: %d",
+	wmi_debug("LINK_LAYER_STATS - Start/Set Params MPDU Size Thresh : %d Aggressive Gather: %d",
 		 cmd->mpdu_size_threshold,
 		 cmd->aggressive_statistics_gathering);
 
@@ -5211,7 +5206,7 @@ static QDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle,
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(get_req->peer_macaddr.bytes,
 				   &cmd->peer_macaddr);
 
-	WMI_LOGD("LINK_LAYER_STATS - Get Request Params Request ID: %u Stats Type: %0x Vdev ID: %d Peer MAC Addr: "QDF_MAC_ADDR_FMT,
+	wmi_debug("LINK_LAYER_STATS - Get Request Params Request ID: %u Stats Type: %0x Vdev ID: %d Peer MAC Addr: "QDF_MAC_ADDR_FMT,
 		 cmd->request_id, cmd->stats_type, cmd->vdev_id,
 		 QDF_MAC_ADDR_REF(get_req->peer_macaddr.bytes));
 
@@ -5257,8 +5252,8 @@ static QDF_STATUS send_congestion_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd->stats_id = WMI_REQUEST_CONGESTION_STAT;
 	cmd->vdev_id = vdev_id;
-	WMI_LOGD("STATS REQ VDEV_ID:%d stats_id %d -->",
-			cmd->vdev_id, cmd->stats_id);
+	wmi_debug("STATS REQ VDEV_ID:%d stats_id %d -->",
+		 cmd->vdev_id, cmd->stats_id);
 
 	wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -5433,7 +5428,7 @@ static QDF_STATUS send_csa_offload_enable_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_buf_t buf;
 	int32_t len = sizeof(*cmd);
 
-	WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
+	wmi_debug("vdev_id %d", vdev_id);
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf)
 		return QDF_STATUS_E_NOMEM;
@@ -5529,7 +5524,7 @@ static QDF_STATUS send_start_11d_scan_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->scan_period_msec = start_11d_scan->scan_period_msec;
 	cmd->start_interval_msec = start_11d_scan->start_interval_msec;
 
-	WMI_LOGD("vdev %d sending 11D scan start req", cmd->vdev_id);
+	wmi_debug("vdev %d sending 11D scan start req", cmd->vdev_id);
 
 	wmi_mtrace(WMI_11D_SCAN_START_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -5574,7 +5569,7 @@ static QDF_STATUS send_stop_11d_scan_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd->vdev_id = stop_11d_scan->vdev_id;
 
-	WMI_LOGD("vdev %d sending 11D scan stop req", cmd->vdev_id);
+	wmi_debug("vdev %d sending 11D scan stop req", cmd->vdev_id);
 
 	wmi_mtrace(WMI_11D_SCAN_STOP_CMDID, cmd->vdev_id, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -5616,8 +5611,7 @@ static QDF_STATUS send_start_oem_data_cmd_tlv(wmi_unified_t wmi_handle,
 	qdf_mem_copy(cmd, data,
 		     data_len);
 
-	WMI_LOGD(FL("Sending OEM Data Request to target, data len %d"),
-		 data_len);
+	wmi_debug("Sending OEM Data Request to target, data len %d", data_len);
 
 	wmi_mtrace(WMI_OEM_REQ_CMDID, NO_SESSION, 0);
 	ret = wmi_unified_cmd_send(wmi_handle, buf,
@@ -5737,8 +5731,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
 
 
 	if (false == dfs_phyerr_filter_offload) {
-		WMI_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
-			 __func__);
+		wmi_debug("Phyerror Filtering offload is Disabled in ini");
 		len = sizeof(*disable_phyerr_offload_cmd);
 		buf = wmi_buf_alloc(wmi_handle, len);
 		if (!buf)
@@ -5767,11 +5760,9 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
 			wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 		}
-		WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success",
-			 __func__);
+		wmi_debug("WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success");
 	} else {
-		WMI_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
-			 __func__);
+		wmi_debug("Phyerror Filtering offload is Enabled in ini");
 
 		len = sizeof(*enable_phyerr_offload_cmd);
 		buf = wmi_buf_alloc(wmi_handle, len);
@@ -5801,8 +5792,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
 			wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 		}
-		WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success",
-			 __func__);
+		wmi_debug("WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success");
 	}
 
 	return QDF_STATUS_SUCCESS;
@@ -5888,7 +5878,7 @@ static QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle,
 		}
 		break;
 	default:
-		WMI_LOGD("%s: invalid PKTLOG command", __func__);
+		wmi_debug("Invalid PKTLOG command: %d", CMD_ID);
 		break;
 	}
 
@@ -5940,8 +5930,8 @@ static QDF_STATUS send_stats_ext_req_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->vdev_id = preq->vdev_id;
 	cmd->data_len = preq->request_data_len;
 
-	WMI_LOGD("%s: The data len value is %u and vdev id set is %u ",
-		 __func__, preq->request_data_len, preq->vdev_id);
+	wmi_debug("The data len value is %u and vdev id set is %u",
+		 preq->request_data_len, preq->vdev_id);
 
 	buf_ptr += sizeof(wmi_req_stats_ext_cmd_fixed_param);
 	WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->data_len);
@@ -5999,8 +5989,7 @@ send_process_dhcpserver_offload_cmd_tlv(wmi_unified_t wmi_handle,
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_FAILURE;
 	}
-	WMI_LOGD("Set dhcp server offload to vdevId %d",
-		 params->vdev_id);
+	wmi_debug("Set dhcp server offload to vdevId %d", params->vdev_id);
 
 	return status;
 }
@@ -6154,13 +6143,13 @@ static QDF_STATUS send_vdev_set_custom_aggr_size_cmd_tlv(
 	cmd->rx_aggr_size = param->rx_aggr_size;
 	copy_custom_aggr_bitmap(param, cmd);
 
-	WMI_LOGD("Set custom aggr: vdev id=0x%X, tx aggr size=0x%X "
-		"rx_aggr_size=0x%X access category=0x%X, agg_type=0x%X "
-		"tx_aggr_size_disable=0x%X, rx_aggr_size_disable=0x%X "
-		"tx_ac_enable=0x%X",
-		param->vdev_id, param->tx_aggr_size, param->rx_aggr_size,
-		param->ac, param->aggr_type, param->tx_aggr_size_disable,
-		param->rx_aggr_size_disable, param->tx_ac_enable);
+	wmi_debug("Set custom aggr: vdev id=0x%X, tx aggr size=0x%X "
+		 "rx_aggr_size=0x%X access category=0x%X, agg_type=0x%X "
+		 "tx_aggr_size_disable=0x%X, rx_aggr_size_disable=0x%X "
+		 "tx_ac_enable=0x%X",
+		 param->vdev_id, param->tx_aggr_size, param->rx_aggr_size,
+		 param->ac, param->aggr_type, param->tx_aggr_size_disable,
+		 param->rx_aggr_size_disable, param->tx_ac_enable);
 
 	wmi_mtrace(WMI_VDEV_SET_CUSTOM_AGGR_SIZE_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -6240,7 +6229,7 @@ static QDF_STATUS send_vdev_set_qdepth_thresh_cmd_tlv(wmi_unified_t wmi_handle,
 				param->update_params[i].msduq_update_mask;
 		cmd_update->qdepth_thresh_value =
 				param->update_params[i].qdepth_thresh_value;
-		WMI_LOGD("Set QDepth Threshold: vdev=0x%X pdev=0x%X, tid=0x%X "
+		wmi_debug("Set QDepth Threshold: vdev=0x%X pdev=0x%X, tid=0x%X "
 			 "mac_addr_upper4=%X, mac_addr_lower2:%X,"
 			 " update mask=0x%X thresh val=0x%X",
 			 cmd->vdev_id, cmd->pdev_id, cmd_update->tid_num,
@@ -6726,7 +6715,7 @@ extract_pdev_sscan_fw_cmd_fixed_param_tlv(
 								ev->pdev_id);
 	param->smode = ev->spectral_scan_mode;
 	param->num_fft_bin_index = param_buf->num_fft_bin_index;
-	WMI_LOGD("%s:pdev id %u scan mode %u num_fft_bin_index %u", __func__,
+	wmi_debug("pdev id %u scan mode %u num_fft_bin_index %u",
 		 param->pdev_id, param->smode, param->num_fft_bin_index);
 
 	return QDF_STATUS_SUCCESS;
@@ -6759,11 +6748,9 @@ extract_pdev_sscan_fft_bin_index_tlv(
 			  param->start_5mhz + 1;
 	param->is_valid = true;
 
-	WMI_LOGD("%s:start_pri80 %u, num_pri80 %u", __func__,
-		 param->start_pri80, param->num_pri80);
-	WMI_LOGD("%s:start_sec80 %u, num_sec80 %u", __func__,
-		 param->start_sec80, param->num_sec80);
-	WMI_LOGD("%s:start_5mhz %u, num_5mhz %u", __func__,
+	wmi_debug("start_pri80: %u num_pri80: %u start_sec80: %u num_sec80: %u start_5mhz: %u, num_5mhz: %u",
+		 param->start_pri80, param->num_pri80,
+		 param->start_sec80, param->num_sec80,
 		 param->start_5mhz, param->num_5mhz);
 
 	return QDF_STATUS_SUCCESS;
@@ -7339,9 +7326,8 @@ static QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle,
 		 * Error: Our host version and the given firmware version
 		 * are incompatible.
 		 **/
-		WMI_LOGD("%s: Error: Incompatible WMI version."
+		wmi_debug("Error: Incompatible WMI version."
 			"Host: %d,%d,0x%x 0x%x 0x%x 0x%x, FW: %d,%d,0x%x 0x%x 0x%x 0x%x",
-				__func__,
 			WMI_VER_GET_MAJOR(wmi_handle->final_abi_vers.
 				abi_version_0),
 			WMI_VER_GET_MINOR(wmi_handle->final_abi_vers.
@@ -7418,8 +7404,7 @@ static QDF_STATUS send_log_supported_evt_cmd_tlv(wmi_unified_t wmi_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	WMI_LOGD("%s: num_of_diag_events_logs=%d",
-			__func__, num_of_diag_events_logs);
+	wmi_debug("num_of_diag_events_logs=%d", num_of_diag_events_logs);
 
 	/* Free any previous allocation */
 	if (wmi_handle->events_logs_list) {
@@ -7522,8 +7507,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
 	count = 0;
 
 	if (!wmi_handle->events_logs_list) {
-		WMI_LOGD("%s: Not received event/log list from FW, yet",
-			 __func__);
+		wmi_debug("Not received event/log list from FW, yet");
 		return QDF_STATUS_E_NOMEM;
 	}
 	/* total_len stores the number of events where BITS 17 and 18 are set.
@@ -7565,7 +7549,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
 	else
 		log_level = 0;
 
-	WMI_LOGD("%s: Length:%d, Log_level:%d", __func__, total_len, log_level);
+	wmi_debug("Length: %d Log_level: %d", total_len, log_level);
 	for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) {
 		uint32_t val = wmi_handle->events_logs_list[i];
 		if ((WMI_DIAG_FREQUENCY_GET(val)) &&
@@ -7577,7 +7561,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
 					WMI_DIAG_TYPE_GET(val));
 			WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[count],
 					log_level);
-			WMI_LOGD("%s: Idx:%d, val:%x", __func__, i, val);
+			wmi_debug("Idx:%d, val:%x", i, val);
 			count++;
 		}
 	}
@@ -7630,7 +7614,7 @@ static QDF_STATUS send_flush_logs_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
 		wmi_buf_free(buf);
 		return QDF_STATUS_E_INVAL;
 	}
-	WMI_LOGD("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW");
+	wmi_debug("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW");
 
 	return ret;
 }
@@ -7761,7 +7745,7 @@ send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle,
 	QDF_STATUS ret;
 	uint32_t len;
 
-	WMI_LOGD(FL("Send encrypt decrypt cmd"));
+	wmi_debug("Send encrypt decrypt cmd");
 
 	len = sizeof(*cmd) +
 			encrypt_decrypt_params->data_len +
@@ -8357,8 +8341,8 @@ QDF_STATUS send_adfs_ch_cfg_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->chan_width = param->chan_width;
 	cmd->min_duration_ms = param->min_duration_ms;
 	cmd->max_duration_ms = param->max_duration_ms;
-	WMI_LOGD("%s:cmd->vdev_id: %d ,cmd->ocac_mode: %d cmd->center_freq: %d",
-		 __func__, cmd->vdev_id, cmd->ocac_mode,
+	wmi_debug("cmd->vdev_id: %d ,cmd->ocac_mode: %d cmd->center_freq: %d",
+		 cmd->vdev_id, cmd->ocac_mode,
 		 cmd->center_freq);
 
 	wmi_mtrace(WMI_VDEV_ADFS_CH_CFG_CMDID, NO_SESSION, 0);
@@ -9190,7 +9174,7 @@ static QDF_STATUS extract_cca_stats_tlv(wmi_unified_t wmi_handle,
 	out_buff->vdev_id = congestion_stats->vdev_id;
 	out_buff->congestion = congestion_stats->congestion;
 
-	WMI_LOGD("%s: cca stats event processed", __func__);
+	wmi_debug("cca stats event processed");
 	return QDF_STATUS_SUCCESS;
 }
 #endif /* QCA_SUPPORT_CP_STATS */
@@ -9298,9 +9282,9 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 			ev->wmi_service_segment_bitmap,
 			(WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t)));
 
-	WMI_LOGD("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x",
-			soc->wmi_ext_service_bitmap[0], soc->wmi_ext_service_bitmap[1],
-			soc->wmi_ext_service_bitmap[2], soc->wmi_ext_service_bitmap[3]);
+	wmi_debug("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x",
+		 soc->wmi_ext_service_bitmap[0], soc->wmi_ext_service_bitmap[1],
+		 soc->wmi_ext_service_bitmap[2], soc->wmi_ext_service_bitmap[3]);
 
 	if (bitmap_buf)
 		qdf_mem_copy(bitmap_buf,
@@ -9308,7 +9292,7 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 			(WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t)));
 
 	if (!param_buf->wmi_service_ext_bitmap) {
-		WMI_LOGD("wmi_service_ext_bitmap not available");
+		wmi_debug("wmi_service_ext_bitmap not available");
 		return QDF_STATUS_SUCCESS;
 	}
 
@@ -9326,7 +9310,7 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 		      sizeof(uint32_t)));
 
 	for (i = 0; i < param_buf->num_wmi_service_ext_bitmap; i++) {
-		WMI_LOGD("wmi_ext2_service_bitmap %u:0x%x",
+		wmi_debug("wmi_ext2_service_bitmap %u:0x%x",
 			 i, soc->wmi_ext2_service_bitmap[i]);
 	}
 
@@ -9419,7 +9403,7 @@ static inline uint32_t convert_wireless_modes_tlv(uint32_t target_wireless_mode)
 
 	uint32_t wireless_modes = 0;
 
-	WMI_LOGD("Target wireless mode: 0x%x", target_wireless_mode);
+	wmi_debug("Target wireless mode: 0x%x", target_wireless_mode);
 
 	if (target_wireless_mode & REGDMN_MODE_11A)
 		wireless_modes |= WMI_HOST_REGDMN_MODE_11A;
@@ -9504,7 +9488,7 @@ static uint32_t convert_phybitmap_tlv(uint32_t target_phybitmap)
 {
 	uint32_t phybitmap = 0;
 
-	WMI_LOGD("Target phybitmap: 0x%x", target_phybitmap);
+	wmi_debug("Target phybitmap: 0x%x", target_phybitmap);
 
 	if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11A)
 		phybitmap |= REGULATORY_PHYMODE_NO11A;
@@ -9532,7 +9516,7 @@ static inline uint32_t convert_wireless_modes_ext_tlv(
 {
 	uint32_t wireless_modes_ext = 0;
 
-	WMI_LOGD("Target wireless mode: 0x%x", target_wireless_modes_ext);
+	wmi_debug("Target wireless mode: 0x%x", target_wireless_modes_ext);
 
 	if (target_wireless_modes_ext & REGDMN_MODE_U32_11AXG_HE20)
 		wireless_modes_ext |= WMI_HOST_REGDMN_MODE_11AXG_HE20;
@@ -10249,7 +10233,7 @@ extract_vdev_prb_fils_stats_tlv(wmi_unified_t wmi_handle,
 			ev->unsolicited_prb_succ_cnt;
 		vdev_stats->unsolicited_prb_fail_cnt =
 			ev->unsolicited_prb_fail_cnt;
-		WMI_LOGD("vdev: %d, fd_s: %d, fd_f: %d, prb_s: %d, prb_f: %d",
+		wmi_debug("vdev: %d, fd_s: %d, fd_f: %d, prb_s: %d, prb_f: %d",
 			 ev->vdev_id, ev->fd_succ_cnt, ev->fd_fail_cnt,
 			 ev->unsolicited_prb_succ_cnt,
 			 ev->unsolicited_prb_fail_cnt);
@@ -11531,7 +11515,7 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
 	wmi_regulatory_rule_struct *wmi_reg_rule;
 	uint32_t num_2g_reg_rules, num_5g_reg_rules;
 
-	WMI_LOGD("processing regulatory channel list");
+	wmi_debug("processing regulatory channel list");
 
 	param_buf = (WMI_REG_CHAN_LIST_CC_EVENTID_param_tlvs *)evt_buf;
 	if (!param_buf) {
@@ -11596,16 +11580,16 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
 	reg_info->min_bw_5g = chan_list_event_hdr->min_bw_5g;
 	reg_info->max_bw_5g = chan_list_event_hdr->max_bw_5g;
 
-	WMI_LOGD(FL("num_phys = %u and phy_id = %u"),
+	wmi_debug("num_phys = %u and phy_id = %u",
 		 reg_info->num_phy, reg_info->phy_id);
 
-	WMI_LOGD("%s:cc %s dfs %d BW: min_2g %d max_2g %d min_5g %d max_5g %d",
-		 __func__, reg_info->alpha2, reg_info->dfs_region,
+	wmi_debug("cc %s dfs %d BW: min_2g %d max_2g %d min_5g %d max_5g %d",
+		 reg_info->alpha2, reg_info->dfs_region,
 		 reg_info->min_bw_2g, reg_info->max_bw_2g,
 		 reg_info->min_bw_5g, reg_info->max_bw_5g);
 
-	WMI_LOGD("%s: num_2g_reg_rules %d num_5g_reg_rules %d", __func__,
-			num_2g_reg_rules, num_5g_reg_rules);
+	wmi_debug("num_2g_reg_rules %d num_5g_reg_rules %d",
+		 num_2g_reg_rules, num_5g_reg_rules);
 	wmi_reg_rule =
 		(wmi_regulatory_rule_struct *)((uint8_t *)chan_list_event_hdr
 			+ sizeof(wmi_reg_chan_list_cc_event_fixed_param)
@@ -11617,7 +11601,7 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
 	reg_info->reg_rules_5g_ptr = create_reg_rules_from_wmi(num_5g_reg_rules,
 			wmi_reg_rule);
 
-	WMI_LOGD("processed regulatory channel list");
+	wmi_debug("processed regulatory channel list");
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -11641,8 +11625,8 @@ static QDF_STATUS extract_reg_11d_new_country_event_tlv(
 			&reg_11d_country_event->new_alpha2, REG_ALPHA2_LEN);
 	reg_11d_country->alpha2[REG_ALPHA2_LEN] = '\0';
 
-	WMI_LOGD("processed 11d country event, new cc %s",
-			reg_11d_country->alpha2);
+	wmi_debug("processed 11d country event, new cc %s",
+		 reg_11d_country->alpha2);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -11680,7 +11664,7 @@ static QDF_STATUS extract_reg_ch_avoid_event_tlv(
 			CH_AVOID_MAX_RANGE) ? CH_AVOID_MAX_RANGE :
 			afr_fixed_param->num_freq_ranges;
 
-	WMI_LOGD("Channel avoid event received with %d ranges",
+	wmi_debug("Channel avoid event received with %d ranges",
 		 num_freq_ranges);
 
 	ch_avoid_ind->ch_avoid_range_cnt = num_freq_ranges;
@@ -11691,9 +11675,9 @@ static QDF_STATUS extract_reg_ch_avoid_event_tlv(
 			afr_desc->start_freq;
 		ch_avoid_ind->avoid_freq_range[freq_range_idx].end_freq =
 			afr_desc->end_freq;
-		WMI_LOGD("range %d tlv id %u, start freq %u, end freq %u",
-				freq_range_idx, afr_desc->tlv_header,
-				afr_desc->start_freq, afr_desc->end_freq);
+		wmi_debug("range %d tlv id %u, start freq %u, end freq %u",
+			 freq_range_idx, afr_desc->tlv_header,
+			 afr_desc->start_freq, afr_desc->end_freq);
 		afr_desc++;
 	}
 
@@ -11726,7 +11710,7 @@ static QDF_STATUS extract_dfs_cac_complete_event_tlv(wmi_unified_t wmi_handle,
 
 	cac_event = param_tlvs->fixed_param;
 	*vdev_id = cac_event->vdev_id;
-	WMI_LOGD("processed cac complete event vdev %d", *vdev_id);
+	wmi_debug("processed cac complete event vdev %d", *vdev_id);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -11766,7 +11750,7 @@ extract_dfs_ocac_complete_event_tlv(wmi_unified_t wmi_handle,
 	param->center_freq2 = ocac_complete_status->center_freq2;
 	param->ocac_status = ocac_complete_status->status;
 	param->chan_width = ocac_complete_status->chan_width;
-	WMI_LOGD("processed ocac complete event vdev %d"
+	wmi_debug("processed ocac complete event vdev %d"
 		 " agile chan %d %d width %d status %d",
 		 param->vdev_id,
 		 param->center_freq1,
@@ -11949,7 +11933,7 @@ static QDF_STATUS send_get_rcpi_cmd_tlv(wmi_unified_t wmi_handle,
 		cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_AVG_MGMT;
 		break;
 	}
-	WMI_LOGD("RCPI REQ VDEV_ID:%d-->", cmd->vdev_id);
+	wmi_debug("RCPI REQ VDEV_ID:%d-->", cmd->vdev_id);
 	wmi_mtrace(WMI_REQUEST_RCPI_CMDID, cmd->vdev_id, 0);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_REQUEST_RCPI_CMDID)) {
@@ -12112,7 +12096,7 @@ static QDF_STATUS send_set_country_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->pdev_id = wmi_handle->ops->convert_host_pdev_id_to_target(
 							wmi_handle,
 							pdev_id);
-	WMI_LOGD("setting current country to  %s and target pdev_id = %u",
+	wmi_debug("setting current country to  %s and target pdev_id = %u",
 		 params->country, cmd->pdev_id);
 
 	qdf_mem_copy((uint8_t *)&cmd->new_alpha2, params->country, 3);
@@ -12313,7 +12297,7 @@ send_roam_scan_stats_cmd_tlv(wmi_unified_t wmi_handle,
 
 	cmd->vdev_id = params->vdev_id;
 
-	WMI_LOGD(FL("Roam Scan Stats Req vdev_id: %u"), cmd->vdev_id);
+	wmi_debug("Roam Scan Stats Req vdev_id: %u", cmd->vdev_id);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_REQUEST_ROAM_SCAN_STATS_CMDID)) {
 		wmi_err("Failed to send WMI_REQUEST_ROAM_SCAN_STATS_CMDID");
@@ -12658,20 +12642,20 @@ static QDF_STATUS extract_comb_phyerr_tlv(wmi_unified_t wmi_handle,
 
 	param_tlvs = (WMI_PHYERR_EVENTID_param_tlvs *)evt_buf;
 	if (!param_tlvs) {
-		WMI_LOGD("%s: Received null data from FW", __func__);
+		wmi_debug("Received null data from FW");
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	pe_hdr = param_tlvs->hdr;
 	if (!pe_hdr) {
-		WMI_LOGD("%s: Received Data PE Header is NULL", __func__);
+		wmi_debug("Received Data PE Header is NULL");
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Ensure it's at least the size of the header */
 	if (datalen < sizeof(*pe_hdr)) {
-		WMI_LOGD("%s: Expected minimum size %zu, received %d",
-			 __func__, sizeof(*pe_hdr), datalen);
+		wmi_debug("Expected minimum size %zu, received %d",
+			 sizeof(*pe_hdr), datalen);
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -12682,7 +12666,7 @@ static QDF_STATUS extract_comb_phyerr_tlv(wmi_unified_t wmi_handle,
 	phyerr->bufp = param_tlvs->bufp;
 
 	if (pe_hdr->buf_len > param_tlvs->num_bufp) {
-		WMI_LOGD("Invalid buf_len %d, num_bufp %d",
+		wmi_debug("Invalid buf_len %d, num_bufp %d",
 			 pe_hdr->buf_len, param_tlvs->num_bufp);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -12718,8 +12702,8 @@ static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle,
 
 	if (n < datalen) {
 		if ((datalen - n) < sizeof(ev->hdr)) {
-			WMI_LOGD("%s: Not enough space. len=%d, n=%d, hdr=%zu",
-				 __func__, datalen, n, sizeof(ev->hdr));
+			wmi_debug("Not enough space. len=%d, n=%d, hdr=%zu",
+				 datalen, n, sizeof(ev->hdr));
 			return QDF_STATUS_E_FAILURE;
 		}
 
@@ -12741,14 +12725,13 @@ static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle,
 		 * If "int" is 64 bits then this becomes a moot point.
 		 */
 		if (ev->hdr.buf_len > PHYERROR_MAX_BUFFER_LENGTH) {
-			WMI_LOGD("%s: buf_len is garbage 0x%x",
-				 __func__, ev->hdr.buf_len);
+			wmi_debug("buf_len is garbage 0x%x", ev->hdr.buf_len);
 			return QDF_STATUS_E_FAILURE;
 		}
 
 		if ((n + ev->hdr.buf_len) > datalen) {
-			WMI_LOGD("%s: len exceeds n=%d, buf_len=%d, datalen=%d",
-				 __func__, n, ev->hdr.buf_len, datalen);
+			wmi_debug("len exceeds n=%d, buf_len=%d, datalen=%d",
+				 n, ev->hdr.buf_len, datalen);
 			return QDF_STATUS_E_FAILURE;
 		}
 
@@ -12899,10 +12882,10 @@ static QDF_STATUS send_obss_color_collision_cfg_cmd_tlv(
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	WMI_LOGD("%s: evt_type: %d vdev id: %d current_bss_color: %d\n"
-		 "detection_period_ms: %d scan_period_ms: %d\n"
+	wmi_debug("evt_type: %d vdev id: %d current_bss_color: %d "
+		 "detection_period_ms: %d scan_period_ms: %d "
 		 "free_slot_expiry_timer_ms: %d",
-		 __func__, cmd->evt_type, cmd->vdev_id, cmd->current_bss_color,
+		 cmd->evt_type, cmd->vdev_id, cmd->current_bss_color,
 		 cmd->detection_period_ms, cmd->scan_period_ms,
 		 cmd->free_slot_expiry_time_ms);
 
@@ -13006,8 +12989,8 @@ send_vdev_fils_enable_cmd_send(struct wmi_unified *wmi_handle,
 	cmd->fd_period = param->fd_period;
 	if (param->send_prb_rsp_frame)
 		cmd->flags |= WMI_FILS_FLAGS_BITMAP_BCAST_PROBE_RSP;
-	WMI_LOGD("%s: vdev id: %d fd_period: %d cmd->Flags %d",
-		 __func__, cmd->vdev_id, cmd->fd_period, cmd->flags);
+	wmi_debug("vdev id: %d fd_period: %d cmd->Flags %d",
+		 cmd->vdev_id, cmd->fd_period, cmd->flags);
 	wmi_mtrace(WMI_ENABLE_FILS_CMDID, cmd->vdev_id, cmd->fd_period);
 	if (wmi_unified_cmd_send(wmi_handle, buf, len,
 				 WMI_ENABLE_FILS_CMDID)) {
@@ -13177,7 +13160,7 @@ static QDF_STATUS send_ani_level_cmd_tlv(wmi_unified_t wmi_handle,
 	chan_list = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE);
 	for (i = 0; i < num_freqs; i++) {
 		chan_list[i] = freqs[i];
-		WMI_LOGD("Requesting ANI for channel[%d]", chan_list[i]);
+		wmi_debug("Requesting ANI for channel[%d]", chan_list[i]);
 	}
 
 	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -13504,7 +13487,7 @@ extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 	if (!param_buf || !param_buf->roam_neighbor_report_info ||
 	    !param_buf->num_roam_neighbor_report_info ||
 	    idx >= param_buf->num_roam_neighbor_report_info) {
-		WMI_LOGD("%s: Invalid 1kv param buf", __func__);
+		wmi_debug("Invalid 1kv param buf");
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -13521,8 +13504,8 @@ extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 		return QDF_STATUS_SUCCESS;
 
 	if (!param_buf->roam_neighbor_report_chan_info) {
-		WMI_LOGD("%s: 11kv channel present, but TLV is NULL num_freq:%d",
-			 __func__, dst->num_freq);
+		wmi_debug("11kv channel present, but TLV is NULL num_freq:%d",
+			 dst->num_freq);
 		dst->num_freq = 0;
 		/* return success as its optional tlv and we can print neighbor
 		 * report received info

wmi/src/wmi_unified_twt_tlv.c

@@ -705,7 +705,7 @@ extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle,
 							ev->pdev_id);
 	params->num_sessions = param_buf->num_twt_sessions;
 
-	WMI_LOGD("pdev_id=%d, num of TWT sessions=%d",
+	wmi_debug("pdev_id=%d, num of TWT sessions=%d",
 		 params->pdev_id, params->num_sessions);
 
 	return QDF_STATUS_SUCCESS;
@@ -760,12 +760,10 @@ extract_twt_session_stats_event_data(wmi_unified_t wmi_handle,
 	session->sp_offset_us = twt_session->sp_offset_us;
 	session->sp_tsf_us_lo = twt_session->sp_tsf_us_lo;
 	session->sp_tsf_us_hi = twt_session->sp_tsf_us_hi;
-	WMI_LOGD("type=%d,id=%d,bcast=%d,trig=%d",
+	wmi_debug("type=%d id=%d bcast=%d trig=%d announ=%d diagid=%d wake_dur=%ul wake_int=%ul offset=%ul",
 		 session->event_type, session->flow_id,
-		 session->bcast, session->trig);
-	WMI_LOGD("announ=%d,diagid=%d,wake_dur=%ul",
-		 session->announ, session->dialog_id, session->wake_dura_us);
-	WMI_LOGD("wake_int=%ul,offset=%ul",
+		 session->bcast, session->trig,
+		 session->announ, session->dialog_id, session->wake_dura_us,
 		 session->wake_intvl_us, session->sp_offset_us);
 
 	return QDF_STATUS_SUCCESS;