qcacmn: Add WMI fixes made for TLV bringup on WIN

These fixes are made during qca8074 VP control path bringup.
Add fixes in tlv.c and enable TLV helper routines for WIN.
Fixed some inconsistencies in wmi API params by adding compiler flags.
This needs to be cleaned up so that API and params have common interface
between WIN and MCL.

Change-Id: I0821daa58df86ad0b394a7846a982a9e3577cd14
CRs-Fixed: 1063252

wmi/inc/wmi_unified_api.h

@@ -349,7 +349,7 @@ QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl,
 				struct wow_cmd_params *param,
 				uint8_t mac_id);
 
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl,
 				WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT);
 #else
@@ -471,7 +471,7 @@ QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd(
 		   void *wmi_hdl, uint32_t mcc_adaptive_scheduler,
 		   uint32_t pdev_id);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_bcn_buf_ll_cmd(void *wmi_hdl,
 			wmi_bcn_send_from_host_cmd_fixed_param *param);
 #endif
@@ -487,7 +487,7 @@ QDF_STATUS wmi_unified_set_sta_keep_alive_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_vdev_set_gtx_cfg_cmd(void *wmi_hdl, uint32_t if_id,
 				  struct wmi_gtx_config *gtx_info);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl,
 		     uint8_t vdev_id,
 		     wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC]);
@@ -521,7 +521,7 @@ QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(void *wmi_hdl,
 					struct wifi_passpoint_req_param *req);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(void *wmi_hdl,
 				wmi_start_scan_cmd_fixed_param *scan_cmd_fp,
 				struct roam_offload_scan_params *roam_req);
@@ -603,7 +603,7 @@ QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id);
 QDF_STATUS wmi_unified_link_status_req_cmd(void *wmi_hdl,
 				 struct link_status_params *link_status);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_lphb_config_hbenable_cmd(void *wmi_hdl,
 				wmi_hb_set_enable_cmd_fixed_param *params);
 
@@ -647,7 +647,7 @@ QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl,
 			bool dfs_phyerr_filter_offload);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl,
 				   WMI_PKTLOG_EVENT pktlog_event,
 				   uint32_t cmd_id,
@@ -821,7 +821,7 @@ QDF_STATUS wmi_unified_roam_invoke_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_roam_scan_offload_cmd(void *wmi_hdl,
 					 uint32_t command, uint32_t vdev_id);
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd(void *wmi_hdl,
 					    wmi_ap_profile *ap_profile_p,
 					    uint32_t vdev_id);

wmi/inc/wmi_unified_param.h

@@ -457,7 +457,7 @@ struct vdev_start_params {
 	uint32_t num_noa_descriptors;
 	uint32_t preferred_rx_streams;
 	uint32_t preferred_tx_streams;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	uint8_t oper_mode;
 	int32_t dfs_pri_multiplier;
 	uint8_t dot11_mode;
@@ -634,7 +634,7 @@ typedef struct {
 struct stats_request_params {
 	uint32_t stats_id;
 	uint32_t vdev_id;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	wmi_host_inst_rssi_args rssi_args;
 #endif
 };
@@ -893,7 +893,7 @@ struct peer_assoc_params {
 	uint32_t tx_max_rate;
 	uint32_t tx_mcs_set;
 	uint8_t vht_capable;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	uint32_t tx_max_mcs_nss;
 	uint32_t peer_bw_rxnss_override;
 	bool is_pmf_enabled;
@@ -1019,7 +1019,7 @@ struct scan_start_params {
 	uint8_t  *ie_base;
 	uint16_t uie_fieldOffset;
 	uint8_t  mac_add_bytes[IEEE80211_ADDR_LEN];
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	bool is_strict_pscan_en;
 	bool is_promiscous_mode;
 	bool is_phy_error;
@@ -1051,7 +1051,7 @@ struct scan_stop_params {
 	uint32_t scan_id;
 	uint32_t req_type;
 	uint32_t vdev_id;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	bool all_scans;
 	bool vap_scans;
 	bool specific_scan;
@@ -1096,7 +1096,6 @@ struct scan_chan_list_params {
  * @ch_param: pointer to channel_paramw
  */
 struct scan_chan_list_params {
-	uint8_t num_chan;
 	uint16_t nallchans;
 	struct channel_param ch_param[1];
 };
@@ -1121,7 +1120,7 @@ struct fw_hang_params {
 struct pdev_utf_params {
 	uint8_t *utf_payload;
 	uint32_t len;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	bool is_ar900b;
 #endif
 };
@@ -1161,7 +1160,7 @@ struct dbglog_params {
 	uint32_t val;
 	uint32_t *module_id_bitmap;
 	uint32_t bitmap_len;
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	uint32_t cfgvalid[2];
 #endif
 };
@@ -1720,7 +1719,7 @@ struct roam_offload_scan_params {
 #endif
 	bool is_ese_assoc;
 	struct mobility_domain_info mdid;
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 	/* THis is not available in non tlv target.
 	* please remove this and replace with a host based
 	* structure */
@@ -5770,6 +5769,15 @@ typedef enum {
 	/* set group membership status */
 	WMI_HOST_PEER_MEMBERSHIP = 0xb,
 	WMI_HOST_PEER_USERPOS = 0xc,
+	WMI_HOST_PEER_CRIT_PROTO_HINT_ENABLED = 0xd,
+	WMI_HOST_PEER_TX_FAIL_CNT_THR = 0xe,
+	WMI_HOST_PEER_SET_HW_RETRY_CTS2S = 0xf,
+	WMI_HOST_PEER_IBSS_ATIM_WINDOW_LENGTH = 0x10,
+	WMI_HOST_PEER_PHYMODE = 0x11,
+	WMI_HOST_PEER_SET_MAC_TX_RATE = 0x12,
+	/* Set default Rx routing */
+	WMI_HOST_PEER_SET_DEFAULT_ROUTING = 0x13,
+	WMI_HOST_PEER_SET_MIN_TX_RATE = 0x14,
 } PEER_PARAM_ENUM;
 #define WMI_HOST_PEER_MIMO_PS_NONE	0x0
 #define WMI_HOST_PEER_MIMO_PS_STATIC	0x1

wmi/inc/wmi_unified_priv.h

@@ -1169,7 +1169,7 @@ struct wmi_unified {
 	qdf_nbuf_queue_t event_queue;
 	struct work_struct rx_event_work;
 	int wmi_stop_in_progress;
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 	struct _wmi_abi_version fw_abi_version;
 	struct _wmi_abi_version final_abi_vers;
 #endif
@@ -1198,7 +1198,7 @@ struct wmi_unified {
 	bool use_cookie;
 	bool wmi_stopinprogress;
 	qdf_spinlock_t ctx_lock;
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	/* WMI service bitmap recieved from target */
 	uint32_t wmi_service_bitmap[wmi_services_max];
 	uint32_t wmi_events[wmi_events_max];

wmi/src/wmi_unified.c

@@ -1056,7 +1056,7 @@ uint16_t wmi_get_max_msg_len(wmi_unified_t wmi_handle)
 	return wmi_handle->max_msg_len - WMI_MIN_HEAD_ROOM;
 }
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 static uint8_t *wmi_id_to_name(uint32_t wmi_command)
 {
 	switch (wmi_command) {
@@ -1663,7 +1663,7 @@ static uint8_t *wmi_id_to_name(uint32_t wmi_command)
  *
  * Return: true if the command is part of the suspend resume sequence.
  */
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 static bool wmi_is_runtime_pm_cmd(uint32_t cmd_id)
 {
 	switch (cmd_id) {
@@ -1742,8 +1742,8 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 		return -EINVAL;
 	}
 
-	/* Do sanity check on the TLV parameter structure */
 #ifndef WMI_NON_TLV_SUPPORT
+	/* Do sanity check on the TLV parameter structure */
 	if (wmi_handle->target_type == WMI_TLV_TARGET) {
 		void *buf_ptr = (void *)qdf_nbuf_data(buf);
 
@@ -1794,7 +1794,7 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 			       wmi_handle->wmi_endpoint_id, htc_tag);
 
 	SET_HTC_PACKET_NET_BUF_CONTEXT(pkt, buf);
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 	wma_log_cmd_id(cmd_id);
 #endif
 
@@ -1864,7 +1864,7 @@ int wmi_unified_register_event_handler(wmi_unified_t wmi_handle,
 	uint32_t idx = 0;
 	uint32_t evt_id;
 
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	if (event_id >= wmi_events_max ||
 		wmi_handle->wmi_events[event_id] == WMI_EVENT_ID_INVALID) {
 		qdf_print("%s: Event id %d is unavailable\n",
@@ -1909,7 +1909,7 @@ int wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle,
 	uint32_t idx = 0;
 	uint32_t evt_id;
 
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	if (event_id >= wmi_events_max ||
 		wmi_handle->wmi_events[event_id] == WMI_EVENT_ID_INVALID) {
 		qdf_print("%s: Event id %d is unavailable\n",
@@ -1955,7 +1955,7 @@ static void wmi_process_fw_event_default_ctx(struct wmi_unified *wmi_handle,
 	wmi_buf_t evt_buf;
 	evt_buf = (wmi_buf_t) htc_packet->pPktContext;
 
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 	wmi_handle->rx_ops.wma_process_fw_event_handler_cbk
 		(wmi_handle->scn_handle, evt_buf, exec_ctx);
 #else
@@ -2137,6 +2137,7 @@ end:
 	if (wmi_handle->target_type == WMI_TLV_TARGET)
 		wmitlv_free_allocated_event_tlvs(id, &wmi_cmd_struct_ptr);
 #endif
+
 	qdf_nbuf_free(evt_buf);
 
 }
@@ -2216,7 +2217,7 @@ void *wmi_unified_attach(void *scn_handle,
 {
 	struct wmi_unified *wmi_handle;
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 	wmi_handle =
 		(struct wmi_unified *)os_malloc(NULL,
 				sizeof(struct wmi_unified),
@@ -2462,7 +2463,7 @@ void wmi_set_target_suspend(wmi_unified_t wmi_handle, A_BOOL val)
 	qdf_atomic_set(&wmi_handle->is_target_suspended, val);
 }
 
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 /**
  * API to flush all the previous packets  associated with the wmi endpoint
  *

wmi/src/wmi_unified_api.c

@@ -578,7 +578,7 @@ QDF_STATUS wmi_unified_stats_request_send(void *wmi_hdl,
 	return QDF_STATUS_E_FAILURE;
 }
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 /**
  *  wmi_unified_packet_log_enable_send() - WMI request stats function
  *  @param wmi_handle      : handle to WMI.
@@ -1205,7 +1205,7 @@ QDF_STATUS wmi_unified_lro_config_cmd(void *wmi_hdl,
 	return QDF_STATUS_E_FAILURE;
 }
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 /**
  * wmi_unified_peer_rate_report_cmd() - process the peer rate report command
  * @wmi_hdl: Pointer to wmi handle
@@ -1323,7 +1323,7 @@ QDF_STATUS wmi_unified_vdev_set_gtx_cfg_cmd(void *wmi_hdl, uint32_t if_id,
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl,
 				uint8_t vdev_id,
 				wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC])
@@ -1533,7 +1533,7 @@ QDF_STATUS wmi_unified_set_epno_network_list_cmd(void *wmi_hdl,
 	return QDF_STATUS_E_FAILURE;
 }
 
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 /**
  * wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters
  * @wmi_hdl: wmi handle
@@ -2123,7 +2123,7 @@ QDF_STATUS wmi_unified_lphb_config_udp_pkt_filter_cmd(void *wmi_hdl,
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_process_dhcp_ind(void *wmi_hdl,
 				wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
 {
@@ -2309,7 +2309,7 @@ wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl,
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl,
 				   WMI_PKTLOG_EVENT pktlog_event,
 				   uint32_t cmd_id,
@@ -3319,7 +3319,7 @@ QDF_STATUS wmi_unified_roam_scan_offload_cmd(void *wmi_hdl,
 
 	return QDF_STATUS_E_FAILURE;
 }
-#ifndef WMI_NON_TLV_SUPPORT
+#ifdef CONFIG_MCL
 /**
  * wmi_unified_send_roam_scan_offload_ap_cmd() - set roam ap profile in fw
  * @wmi_hdl: wmi handle
@@ -4606,7 +4606,7 @@ QDF_STATUS wmi_check_and_update_fw_version(void *wmi_hdl, void *evt_buf)
  *
  * Return: 1 enabled, 0 disabled
  */
-#ifdef WMI_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 bool wmi_service_enabled(void *wmi_hdl, uint32_t service_id)
 {
 	wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;

wmi/src/wmi_unified_non_tlv.c

@@ -35,7 +35,7 @@
 #include "wmi_unified_api.h"
 #include "wmi_unified_priv.h"
 
-#ifdef WMI_NON_TLV_SUPPORT
+#if defined(WMI_NON_TLV_SUPPORT) || defined(WMI_TLV_AND_NON_TLV_SUPPORT)
 #include "legacy/wmi.h"
 #include "legacy/wmi_unified.h"
 /**
@@ -510,6 +510,56 @@ QDF_STATUS send_peer_delete_cmd_non_tlv(wmi_unified_t wmi_handle,
 			WMI_PEER_DELETE_CMDID);
 }
 
+/**
+ * convert_host_peer_id_to_target_id_non_tlv - convert host peer param_id
+ * to target id.
+ * @targ_paramid: Target parameter id to hold the result.
+ * @peer_param_id: host param id.
+ *
+ * Return: QDF_STATUS_SUCCESS for success
+ *         QDF_STATUS_E_NOSUPPORT when the param_id in not supported in tareget
+ */
+static QDF_STATUS convert_host_peer_id_to_target_id_non_tlv(
+		uint32_t *targ_paramid,
+		uint32_t peer_param_id)
+{
+	switch (peer_param_id) {
+	case WMI_HOST_PEER_MIMO_PS_STATE:
+		*targ_paramid = WMI_PEER_MIMO_PS_STATE;
+		break;
+	case WMI_HOST_PEER_AMPDU:
+		*targ_paramid = WMI_PEER_AMPDU;
+		break;
+	case WMI_HOST_PEER_AUTHORIZE:
+		*targ_paramid = WMI_PEER_AUTHORIZE;
+		break;
+	case WMI_HOST_PEER_CHWIDTH:
+		*targ_paramid = WMI_PEER_CHWIDTH;
+		break;
+	case WMI_HOST_PEER_NSS:
+		*targ_paramid = WMI_PEER_NSS;
+		break;
+	case WMI_HOST_PEER_USE_4ADDR:
+		*targ_paramid = WMI_PEER_USE_4ADDR;
+		break;
+	case WMI_HOST_PEER_USE_FIXED_PWR:
+		*targ_paramid = WMI_PEER_USE_FIXED_PWR;
+		break;
+	case WMI_HOST_PEER_PARAM_FIXED_RATE:
+		*targ_paramid = WMI_PEER_PARAM_FIXED_RATE;
+		break;
+	case WMI_HOST_PEER_SET_MU_WHITELIST:
+		*targ_paramid = WMI_PEER_SET_MU_WHITELIST;
+		break;
+	case WMI_HOST_PEER_EXT_STATS_ENABLE:
+		*targ_paramid = WMI_PEER_EXT_STATS_ENABLE;
+		break;
+	default:
+		return QDF_STATUS_E_NOSUPPORT;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
 /**
  * send_peer_param_cmd_non_tlv() - set peer parameter in fw
  * @wmi_handle: wmi handle
@@ -525,6 +575,11 @@ QDF_STATUS send_peer_param_cmd_non_tlv(wmi_unified_t wmi_handle,
 	wmi_peer_set_param_cmd *cmd;
 	wmi_buf_t buf;
 	int len = sizeof(wmi_peer_set_param_cmd);
+	uint32_t param_id;
+
+	if (convert_host_peer_id_to_target_id_non_tlv(&param_id,
+					param->param_id) != QDF_STATUS_SUCCESS)
+		return QDF_STATUS_E_NOSUPPORT;
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -533,7 +588,7 @@ QDF_STATUS send_peer_param_cmd_non_tlv(wmi_unified_t wmi_handle,
 	}
 	cmd = (wmi_peer_set_param_cmd *)wmi_buf_data(buf);
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
-	cmd->param_id = param->param_id;
+	cmd->param_id = param_id;
 	cmd->param_value = param->param_value;
 	cmd->vdev_id = param->vdev_id;
 	return wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -7989,7 +8044,7 @@ static void populate_vdev_param_non_tlv(uint32_t *vdev_param)
  */
 void wmi_non_tlv_attach(struct wmi_unified *wmi_handle)
 {
-#ifdef WMI_NON_TLV_SUPPORT
+#if defined(WMI_NON_TLV_SUPPORT) || defined(WMI_TLV_AND_NON_TLV_SUPPORT)
 	wmi_handle->ops = &non_tlv_ops;
 	populate_non_tlv_service(wmi_handle->services);
 	populate_non_tlv_events_id(wmi_handle->wmi_events);

wmi/src/wmi_unified_tlv.c

@@ -209,6 +209,62 @@ QDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
 	return 0;
 }
 
+#ifdef CONFIG_MCL
+static inline void copy_channel_info(
+		wmi_vdev_start_request_cmd_fixed_param * cmd,
+		wmi_channel *chan,
+		struct vdev_start_params *req)
+{
+	chan->mhz = req->chan_freq;
+
+	WMI_SET_CHANNEL_MODE(chan, req->chan_mode);
+
+	chan->band_center_freq1 = req->band_center_freq1;
+	chan->band_center_freq2 = req->band_center_freq2;
+
+	if (req->is_half_rate)
+		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
+	else if (req->is_quarter_rate)
+		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
+
+	if (req->is_dfs) {
+		WMI_SET_CHANNEL_FLAG(chan, req->flag_dfs);
+		cmd->disable_hw_ack = req->dis_hw_ack;
+	}
+
+	WMI_SET_CHANNEL_REG_POWER(chan, req->max_txpow);
+	WMI_SET_CHANNEL_MAX_TX_POWER(chan, req->max_txpow);
+
+}
+#else
+static inline void copy_channel_info(
+		wmi_vdev_start_request_cmd_fixed_param * cmd,
+		wmi_channel *chan,
+		struct vdev_start_params *req)
+{
+	chan->mhz = req->channel.mhz;
+
+	WMI_SET_CHANNEL_MODE(chan, req->channel.phy_mode);
+
+	chan->band_center_freq1 = req->channel.cfreq1;
+	chan->band_center_freq2 = req->channel.cfreq2;
+
+	if (req->channel.half_rate)
+		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
+	else if (req->channel.quarter_rate)
+		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
+
+	if (req->channel.dfs_set) {
+		WMI_SET_CHANNEL_FLAG(chan, req->flag_dfs);
+		cmd->disable_hw_ack = req->disable_hw_ack;
+	}
+
+	/* FIXME: Find out min, max and regulatory power levels */
+	WMI_SET_CHANNEL_REG_POWER(chan, req->channel.maxregpower);
+	WMI_SET_CHANNEL_MAX_TX_POWER(chan, req->channel.maxpower);
+
+}
+#endif
 /**
  * send_vdev_start_cmd_tlv() - send vdev start request to fw
  * @wmi_handle: wmi handle
@@ -243,28 +299,10 @@ QDF_STATUS send_vdev_start_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->vdev_id = req->vdev_id;
 
 	/* Fill channel info */
-	chan->mhz = req->chan_freq;
-
-	WMI_SET_CHANNEL_MODE(chan, req->chan_mode);
-
-	chan->band_center_freq1 = req->band_center_freq1;
-	chan->band_center_freq2 = req->band_center_freq2;
-
-	if (req->is_half_rate)
-		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
-	else if (req->is_quarter_rate)
-		WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
-
-	if (req->is_dfs) {
-		WMI_SET_CHANNEL_FLAG(chan, req->flag_dfs);
-		cmd->disable_hw_ack = req->dis_hw_ack;
-	}
+	copy_channel_info(cmd, chan, req);
 
 	cmd->beacon_interval = req->beacon_intval;
 	cmd->dtim_period = req->dtim_period;
-	/* FIXME: Find out min, max and regulatory power levels */
-	WMI_SET_CHANNEL_REG_POWER(chan, req->max_txpow);
-	WMI_SET_CHANNEL_MAX_TX_POWER(chan, req->max_txpow);
 
 	if (!req->is_restart) {
 		cmd->beacon_interval = req->beacon_intval;
@@ -471,6 +509,90 @@ QDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi,
 	return 0;
 }
 
+/**
+ * convert_host_peer_id_to_target_id_tlv - convert host peer param_id
+ * to target id.
+ * @targ_paramid: Target parameter id to hold the result.
+ * @peer_param_id: host param id.
+ *
+ * Return: QDF_STATUS_SUCCESS for success
+ *         QDF_STATUS_E_NOSUPPORT when the param_id in not supported in tareget
+ */
+#ifdef CONFIG_MCL
+static QDF_STATUS convert_host_peer_id_to_target_id_tlv(
+		uint32_t *targ_paramid,
+		uint32_t peer_param_id)
+{
+	*targ_paramid = peer_param_id;
+	return QDF_STATUS_SUCCESS;
+}
+#else
+static QDF_STATUS convert_host_peer_id_to_target_id_tlv(
+		uint32_t *targ_paramid,
+		uint32_t peer_param_id)
+{
+	switch (peer_param_id) {
+	case WMI_HOST_PEER_MIMO_PS_STATE:
+		*targ_paramid = WMI_PEER_MIMO_PS_STATE;
+		break;
+	case WMI_HOST_PEER_AMPDU:
+		*targ_paramid = WMI_PEER_AMPDU;
+		break;
+	case WMI_HOST_PEER_AUTHORIZE:
+		*targ_paramid = WMI_PEER_AUTHORIZE;
+		break;
+	case WMI_HOST_PEER_CHWIDTH:
+		*targ_paramid = WMI_PEER_CHWIDTH;
+		break;
+	case WMI_HOST_PEER_NSS:
+		*targ_paramid = WMI_PEER_NSS;
+		break;
+	case WMI_HOST_PEER_USE_4ADDR:
+		*targ_paramid = WMI_PEER_USE_4ADDR;
+		break;
+	case WMI_HOST_PEER_MEMBERSHIP:
+		*targ_paramid = WMI_PEER_MEMBERSHIP;
+		break;
+	case WMI_HOST_PEER_USERPOS:
+		*targ_paramid = WMI_PEER_USERPOS;
+		break;
+	case WMI_HOST_PEER_CRIT_PROTO_HINT_ENABLED:
+		*targ_paramid = WMI_PEER_CRIT_PROTO_HINT_ENABLED;
+		break;
+	case WMI_HOST_PEER_TX_FAIL_CNT_THR:
+		*targ_paramid = WMI_PEER_TX_FAIL_CNT_THR;
+		break;
+	case WMI_HOST_PEER_SET_HW_RETRY_CTS2S:
+		*targ_paramid = WMI_PEER_SET_HW_RETRY_CTS2S;
+		break;
+	case WMI_HOST_PEER_IBSS_ATIM_WINDOW_LENGTH:
+		*targ_paramid = WMI_PEER_IBSS_ATIM_WINDOW_LENGTH;
+		break;
+	case WMI_HOST_PEER_PHYMODE:
+		*targ_paramid = WMI_PEER_PHYMODE;
+		break;
+	case WMI_HOST_PEER_USE_FIXED_PWR:
+		*targ_paramid = WMI_PEER_USE_FIXED_PWR;
+		break;
+	case WMI_HOST_PEER_PARAM_FIXED_RATE:
+		*targ_paramid = WMI_PEER_PARAM_FIXED_RATE;
+		break;
+	case WMI_HOST_PEER_SET_MU_WHITELIST:
+		*targ_paramid = WMI_PEER_SET_MU_WHITELIST;
+		break;
+	case WMI_HOST_PEER_SET_MAC_TX_RATE:
+		*targ_paramid = WMI_PEER_SET_MAX_TX_RATE;
+		break;
+	case WMI_HOST_PEER_SET_MIN_TX_RATE:
+		*targ_paramid = WMI_PEER_SET_MIN_TX_RATE;
+		break;
+	default:
+		return QDF_STATUS_E_NOSUPPORT;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif
 /**
  * send_peer_param_cmd_tlv() - set peer parameter in fw
  * @wmi: wmi handle
@@ -486,6 +608,11 @@ QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
 	wmi_peer_set_param_cmd_fixed_param *cmd;
 	wmi_buf_t buf;
 	int32_t err;
+	uint32_t param_id;
+
+	if (convert_host_peer_id_to_target_id_tlv(&param_id,
+				param->param_id) != QDF_STATUS_SUCCESS)
+		return QDF_STATUS_E_NOSUPPORT;
 
 	buf = wmi_buf_alloc(wmi, sizeof(*cmd));
 	if (!buf) {
@@ -499,7 +626,7 @@ QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
 				(wmi_peer_set_param_cmd_fixed_param));
 	cmd->vdev_id = param->vdev_id;
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
-	cmd->param_id = param->param_id;
+	cmd->param_id = param_id;
 	cmd->param_value = param->param_value;
 	err = wmi_unified_cmd_send(wmi, buf,
 				   sizeof(wmi_peer_set_param_cmd_fixed_param),
@@ -724,7 +851,22 @@ send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle,
 
 	return ret;
 }
+#ifdef CONFIG_MCL
+static inline uint32_t convert_host_pdev_param_tlv(wmi_unified_t wmi_handle,
+				uint32_t host_param)
+{
+	return host_param;
+}
+#else
+static inline uint32_t convert_host_pdev_param_tlv(wmi_unified_t wmi_handle,
+				uint32_t host_param)
+{
+	if (host_param < wmi_pdev_param_max)
+		return wmi_handle->pdev_param[host_param];
 
+	return WMI_UNAVAILABLE_PARAM;
+}
+#endif
 /**
  * send_pdev_param_cmd_tlv() - set pdev parameters
  * @wmi_handle: wmi handle
@@ -742,6 +884,14 @@ send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_pdev_set_param_cmd_fixed_param *cmd;
 	wmi_buf_t buf;
 	uint16_t len = sizeof(*cmd);
+	uint32_t pdev_param;
+
+	pdev_param = convert_host_pdev_param_tlv(wmi_handle, param->param_id);
+	if (pdev_param == WMI_UNAVAILABLE_PARAM) {
+		WMI_LOGW("%s: Unavailable param %d\n",
+				__func__, param->param_id);
+		return QDF_STATUS_E_INVAL;
+	}
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -754,7 +904,7 @@ send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
 		       WMITLV_GET_STRUCT_TLVLEN
 			       (wmi_pdev_set_param_cmd_fixed_param));
 	cmd->pdev_id = 0;
-	cmd->param_id = param->param_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);
@@ -1076,6 +1226,22 @@ send_dbglog_cmd_tlv(wmi_unified_t wmi_handle,
 	return status;
 }
 
+#ifdef CONFIG_MCL
+static inline uint32_t convert_host_vdev_param_tlv(wmi_unified_t wmi_handle,
+				uint32_t host_param)
+{
+	return host_param;
+}
+#else
+static inline uint32_t convert_host_vdev_param_tlv(wmi_unified_t wmi_handle,
+				uint32_t host_param)
+{
+	if (host_param < wmi_vdev_param_max)
+		return wmi_handle->vdev_param[host_param];
+
+	return WMI_UNAVAILABLE_PARAM;
+}
+#endif
 /**
  *  send_vdev_set_param_cmd_tlv() - WMI vdev set parameter function
  *  @param wmi_handle      : handle to WMI.
@@ -1091,6 +1257,15 @@ QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
 	wmi_vdev_set_param_cmd_fixed_param *cmd;
 	wmi_buf_t buf;
 	uint16_t len = sizeof(*cmd);
+	uint32_t vdev_param;
+
+	vdev_param = convert_host_vdev_param_tlv(wmi_handle, param->param_id);
+	if (vdev_param == WMI_UNAVAILABLE_PARAM) {
+		WMI_LOGW("%s:Vdev param %d not available", __func__,
+				param->param_id);
+		return QDF_STATUS_E_INVAL;
+
+	}
 
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
@@ -1103,7 +1278,7 @@ QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
 		       WMITLV_GET_STRUCT_TLVLEN
 			       (wmi_vdev_set_param_cmd_fixed_param));
 	cmd->vdev_id = param->if_id;
-	cmd->param_id = param->param_id;
+	cmd->param_id = vdev_param;
 	cmd->param_value = param->param_value;
 	WMI_LOGD("Setting vdev %d param = %x, value = %u",
 		 param->if_id, param->param_id, param->param_value);
@@ -1308,6 +1483,94 @@ QDF_STATUS send_beacon_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
 }
 #endif
 
+#ifdef CONFIG_MCL
+static inline void copy_peer_flags_tlv(
+			wmi_peer_assoc_complete_cmd_fixed_param * cmd,
+			struct peer_assoc_params *param)
+{
+	cmd->peer_flags = param->peer_flags;
+}
+#else
+static inline void copy_peer_flags_tlv(
+			wmi_peer_assoc_complete_cmd_fixed_param * cmd,
+			struct peer_assoc_params *param)
+{
+	/*
+	 * The target only needs a subset of the flags maintained in the host.
+	 * Just populate those flags and send it down
+	 */
+	cmd->peer_flags = 0;
+
+	/*
+	 * Do not enable HT/VHT if WMM/wme is disabled for vap.
+	 */
+	if (param->is_wme_set) {
+
+		if (param->qos_flag)
+			cmd->peer_flags |= WMI_PEER_QOS;
+		if (param->apsd_flag)
+			cmd->peer_flags |= WMI_PEER_APSD;
+		if (param->ht_flag)
+			cmd->peer_flags |= WMI_PEER_HT;
+		if (param->bw_40)
+			cmd->peer_flags |= WMI_PEER_40MHZ;
+		if (param->bw_80)
+			cmd->peer_flags |= WMI_PEER_80MHZ;
+		if (param->bw_160)
+			cmd->peer_flags |= WMI_PEER_160MHZ;
+
+		/* Typically if STBC is enabled for VHT it should be enabled
+		 * for HT as well
+		 **/
+		if (param->stbc_flag)
+			cmd->peer_flags |= WMI_PEER_STBC;
+
+		/* Typically if LDPC is enabled for VHT it should be enabled
+		 * for HT as well
+		 **/
+		if (param->ldpc_flag)
+			cmd->peer_flags |= WMI_PEER_LDPC;
+
+		if (param->static_mimops_flag)
+			cmd->peer_flags |= WMI_PEER_STATIC_MIMOPS;
+		if (param->dynamic_mimops_flag)
+			cmd->peer_flags |= WMI_PEER_DYN_MIMOPS;
+		if (param->spatial_mux_flag)
+			cmd->peer_flags |= WMI_PEER_SPATIAL_MUX;
+		if (param->vht_flag)
+			cmd->peer_flags |= WMI_PEER_VHT;
+	}
+	/*
+	 * Suppress authorization for all AUTH modes that need 4-way handshake
+	 * (during re-association).
+	 * Authorization will be done for these modes on key installation.
+	 */
+	if (param->auth_flag)
+		cmd->peer_flags |= WMI_PEER_AUTH;
+	if (param->need_ptk_4_way)
+		cmd->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
+	else
+		cmd->peer_flags &= ~WMI_PEER_NEED_PTK_4_WAY;
+	if (param->need_gtk_2_way)
+		cmd->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
+	/* safe mode bypass the 4-way handshake */
+	if (param->safe_mode_enabled)
+		cmd->peer_flags &=
+		    ~(WMI_PEER_NEED_PTK_4_WAY | WMI_PEER_NEED_GTK_2_WAY);
+	/* Disable AMSDU for station transmit, if user configures it */
+	/* Disable AMSDU for AP transmit to 11n Stations, if user configures
+	 * it
+	 * if (param->amsdu_disable) Add after FW support
+	 **/
+
+	/* Target asserts if node is marked HT and all MCS is set to 0.
+	 * Mark the node as non-HT if all the mcs rates are disabled through
+	 * iwpriv
+	 **/
+	if (param->peer_ht_rates.num_rates == 0)
+		cmd->peer_flags &= ~WMI_PEER_HT;
+}
+#endif
 /**
  *  send_peer_assoc_cmd_tlv() - WMI peer assoc function
  *  @param wmi_handle      : handle to WMI.
@@ -1355,7 +1618,7 @@ QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
 				 sizeof(param->peer_macaddr));
 	cmd->peer_new_assoc = param->peer_new_assoc;
 	cmd->peer_associd = param->peer_associd;
-	cmd->peer_flags = param->peer_flags;
+	copy_peer_flags_tlv(cmd, param);
 	cmd->peer_rate_caps = param->peer_rate_caps;
 	cmd->peer_caps = param->peer_caps;
 	cmd->peer_listen_intval = param->peer_listen_intval;
@@ -1419,6 +1682,34 @@ QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
 	return ret;
 }
 
+/* copy_scan_notify_events() - Helper routine to copy scan notify events
+ */
+#ifdef CONFIG_MCL
+static inline void copy_scan_notify_ev_flags(
+		wmi_start_scan_cmd_fixed_param * cmd,
+		struct scan_start_params *params)
+{
+	cmd->notify_scan_events = params->notify_scan_events;
+	cmd->scan_ctrl_flags = params->scan_ctrl_flags;
+}
+#else
+static inline void copy_scan_notify_ev_flags(
+		wmi_start_scan_cmd_fixed_param * cmd,
+		struct scan_start_params *params)
+{
+	cmd->notify_scan_events = WMI_SCAN_EVENT_STARTED |
+		WMI_SCAN_EVENT_COMPLETED |
+		WMI_SCAN_EVENT_BSS_CHANNEL |
+		WMI_SCAN_EVENT_FOREIGN_CHANNEL |
+		WMI_SCAN_EVENT_DEQUEUED
+		;
+	cmd->scan_ctrl_flags = params->scan_ctrl_flags;
+	cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ;
+
+	if (params->is_phy_error)
+		cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
+}
+#endif
 /**
  *  send_scan_start_cmd_tlv() - WMI scan start function
  *  @param wmi_handle      : handle to WMI.
@@ -1477,7 +1768,7 @@ QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->scan_req_id = params->scan_req_id;
 	cmd->vdev_id = params->vdev_id;
 	cmd->scan_priority = params->scan_priority;
-	cmd->notify_scan_events = params->notify_scan_events;
+	copy_scan_notify_ev_flags(cmd, params);
 	cmd->dwell_time_active = params->dwell_time_active;
 	cmd->dwell_time_passive = params->dwell_time_passive;
 	cmd->min_rest_time = params->min_rest_time;
@@ -1487,7 +1778,6 @@ QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->idle_time = params->idle_time;
 	cmd->max_scan_time = params->max_scan_time;
 	cmd->probe_delay = params->probe_delay;
-	cmd->scan_ctrl_flags = params->scan_ctrl_flags;
 	cmd->burst_duration = params->burst_duration;
 	cmd->num_chan = params->num_chan;
 	cmd->num_bssid = params->num_bssid;
@@ -1681,7 +1971,7 @@ QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
 	struct channel_param *tchan_info;
 	uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
 
-	len += sizeof(wmi_channel) * chan_list->num_chan;
+	len += sizeof(wmi_channel) * chan_list->nallchans;
 	buf = wmi_buf_alloc(wmi_handle, len);
 	if (!buf) {
 		WMI_LOGE("Failed to allocate memory");
@@ -1696,16 +1986,16 @@ 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", chan_list->num_chan, len);
+	WMI_LOGD("no of channels = %d, len = %d", chan_list->nallchans, len);
 
-	cmd->num_scan_chans = chan_list->num_chan;
+	cmd->num_scan_chans = chan_list->nallchans;
 	WMITLV_SET_HDR((buf_ptr + sizeof(wmi_scan_chan_list_cmd_fixed_param)),
 		       WMITLV_TAG_ARRAY_STRUC,
-		       sizeof(wmi_channel) * chan_list->num_chan);
+		       sizeof(wmi_channel) * chan_list->nallchans);
 	chan_info = (wmi_channel *) (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE);
 	tchan_info = &(chan_list->ch_param[0]);
 
-	for (i = 0; i < chan_list->num_chan; ++i) {
+	for (i = 0; i < chan_list->nallchans; ++i) {
 		WMITLV_SET_HDR(&chan_info->tlv_header,
 			       WMITLV_TAG_STRUC_wmi_channel,
 			       WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
@@ -1715,11 +2005,37 @@ QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
 		chan_info->band_center_freq2 =
 				tchan_info->cfreq2;
 
+		if (tchan_info->is_chan_passive)
+			WMI_SET_CHANNEL_FLAG(chan_info,
+					WMI_CHAN_FLAG_PASSIVE);
+
+		if (tchan_info->allow_vht)
+			WMI_SET_CHANNEL_FLAG(chan_info,
+					WMI_CHAN_FLAG_ALLOW_VHT);
+		else  if (tchan_info->allow_ht)
+			WMI_SET_CHANNEL_FLAG(chan_info,
+					WMI_CHAN_FLAG_ALLOW_HT);
+		WMI_SET_CHANNEL_MODE(chan_info,
+				tchan_info->phy_mode);
+
+		/* Add tchan_info->half_rate and tchan_info->quarter_rate later
+		 * after FW support
+		 */
+
+		/* also fill in power information */
+		WMI_SET_CHANNEL_MIN_POWER(chan_info,
+				tchan_info->minpower);
+		WMI_SET_CHANNEL_MAX_POWER(chan_info,
+				tchan_info->maxpower);
+		WMI_SET_CHANNEL_REG_POWER(chan_info,
+				tchan_info->maxregpower);
+		WMI_SET_CHANNEL_ANTENNA_MAX(chan_info,
+				tchan_info->antennamax);
+		WMI_SET_CHANNEL_REG_CLASSID(chan_info,
+				tchan_info->reg_class_id);
+
 		WMI_LOGD("chan[%d] = %u", i, chan_info->mhz);
 
-		/*TODO: Set WMI_SET_CHANNEL_MIN_POWER */
-		/*TODO: Set WMI_SET_CHANNEL_ANTENNA_MAX */
-		/*TODO: WMI_SET_CHANNEL_REG_CLASSID */
 		tchan_info++;
 		chan_info++;
 	}
@@ -9249,8 +9565,6 @@ QDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf)
 		return QDF_STATUS_E_FAILURE;
 
 #ifdef CONFIG_MCL
-	/* TODO:This needs to be enabled for WIN Lithium after removing dependen
-	 * on wmi_unified.h from priv.h for using wmi_abi_version type */
 	/*Save fw version from service ready message */
 	/*This will be used while sending INIT message */
 	qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers,
@@ -9280,8 +9594,6 @@ QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle,
 	param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf;
 	ev = param_buf->fixed_param;
 #ifdef CONFIG_MCL
-	/* TODO:This needs to be enabled for WIN Lithium after removing dependen
-	 * on wmi_unified.h from priv.h for using wmi_abi_version type */
 	if (!wmi_versions_are_compatible(&wmi_handle->final_abi_vers,
 				&ev->fw_abi_vers)) {
 		/*
@@ -10918,7 +11230,7 @@ static QDF_STATUS init_cmd_send_tlv(wmi_unified_t wmi_handle,
  *
  * Return: None
  */
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 void save_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf)
 {
 	WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf;
@@ -10943,7 +11255,7 @@ void save_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf)
  *
  * Return: 1 enabled, 0 disabled
  */
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 static bool is_service_enabled_tlv(wmi_unified_t wmi_handle,
 		uint32_t service_id)
 {
@@ -12160,7 +12472,7 @@ struct wmi_ops tlv_ops =  {
 	.send_fw_test_cmd = send_fw_test_cmd_tlv,
 };
 
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 /**
  * populate_tlv_service() - populates wmi services
  *
@@ -12835,7 +13147,7 @@ static void populate_vdev_param_tlv(uint32_t *vdev_param)
  *
  * Return: None
  */
-#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+#ifndef CONFIG_MCL
 void wmi_tlv_attach(wmi_unified_t wmi_handle)
 {
 	wmi_handle->ops = &tlv_ops;