qcacmn: Add non-tlv APIs for new WMI commands and support for old commands

Implement following WMI commands and corresponding event extraction
APIs added for WIN release-
WMI_PEER_GID_USERPOS_LIST_CMDID
WMI_PEER_TX_MU_TXMIT_RSTCNT_CMDID
WMI_PEER_TX_MU_TXMIT_COUNT_CMDID
WMI_PDEV_CHECK_CAL_VERSION_CMDID
WMI_BTCOEX_CFG_CMDID

Additions to following existing WMI commands-
WMI_MU_CAL_START_CMDID
WMI_SET_LTEU_CONFIG_CMDID
WMI_PDEV_GET_TPC_CONFIG_CMDID
WMI_START_SCAN_CMDID

Change-Id: Ifd43addf196f2bc3cbff33671ef66202b8b0b487
CRs-Fixed: 1059400

wmi_unified_api.c

@@ -5072,6 +5072,82 @@ wmi_send_set_atf_grouping_cmd(void *wmi_hdl,
 
 }
 
+/**
+ * wmi_send_get_user_position_cmd() - send get user position command to fw
+ * @wmi_handle: wmi handle
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value)
+{
+	wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
+
+	if (wmi_handle->ops->send_get_user_position_cmd)
+		return wmi_handle->ops->send_get_user_position_cmd(wmi_handle,
+								value);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count
+ * 					     command to fw
+ * @wmi_handle: wmi handle
+ * @value: user pos value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->send_get_peer_mumimo_tx_count_cmd)
+		return wmi->ops->send_get_peer_mumimo_tx_count_cmd(wmi, value);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo
+ * 					       tx count to fw
+ * @wmi_handle: wmi handle
+ * @value:	reset tx count value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->send_reset_peer_mumimo_tx_count_cmd)
+		return wmi->ops->send_reset_peer_mumimo_tx_count_cmd(wmi,
+								value);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_send_pdev_caldata_version_check_cmd() - send reset peer mumimo
+ * 					       tx count to fw
+ * @wmi_handle: wmi handle
+ * @value: value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_send_pdev_caldata_version_check_cmd(void *wmi_hdl, uint32_t value)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->send_pdev_caldata_version_check_cmd)
+		return wmi->ops->send_pdev_caldata_version_check_cmd(wmi,
+								value);
+
+	return QDF_STATUS_E_FAILURE;
+}
 
 /* Extract - APIs */
 /**
@@ -5338,6 +5414,90 @@ QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf,
 	return QDF_STATUS_E_FAILURE;
 }
 
+/**
+ * wmi_extract_mu_db_entry() - extract mu db entry from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold mu db entry
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf,
+	uint8_t idx, wmi_host_mu_db_entry *param)
+{
+	wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
+
+	if (wmi_handle->ops->extract_mu_db_entry)
+		return wmi_handle->ops->extract_mu_db_entry(wmi_handle, evt_buf,
+			idx, param);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold mumimo tx count
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf,
+	wmi_host_peer_txmu_cnt_event *param)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->extract_mumimo_tx_count_ev_param)
+		return wmi->ops->extract_mumimo_tx_count_ev_param(wmi,
+			 evt_buf, param);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list
+ * 						  from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold peer gid userposition list
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl,
+	void *evt_buf,
+	wmi_host_peer_gid_userpos_list_event *param)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->extract_peer_gid_userpos_list_ev_param)
+		return wmi->ops->extract_peer_gid_userpos_list_ev_param(wmi,
+			 evt_buf, param);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_extract_pdev_caldata_version_check_ev_param() - extract caldata
+ * 						       from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold caldata version data
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_pdev_caldata_version_check_ev_param(void *wmi_hdl,
+	void *evt_buf,
+	wmi_host_pdev_check_cal_version_event *param)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->extract_pdev_caldata_version_check_ev_param)
+		return wmi->ops->extract_pdev_caldata_version_check_ev_param(
+			wmi, evt_buf, param);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
 /**
  * wmi_extract_pdev_tpc_config_ev_param() - extract pdev tpc configuration
  * param from event
@@ -6084,7 +6244,6 @@ QDF_STATUS wmi_extract_inst_rssi_stats_event(void *wmi_hdl, void *evt_buf,
  * from event
  * @wmi_handle: wmi handle
  * @param evt_buf: pointer to event buffer
- * @param index: Index into chan stats
  * @param ev: Pointer to hold data traffic control
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
@@ -6101,6 +6260,49 @@ QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf,
 	return QDF_STATUS_E_FAILURE;
 }
 
+/**
+ * wmi_extract_atf_peer_stats_ev() - extract atf peer stats
+ * from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param ev: Pointer to hold atf peer stats
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_atf_peer_stats_ev(void *wmi_hdl, void *evt_buf,
+			wmi_host_atf_peer_stats_event *ev)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->extract_atf_peer_stats_ev)
+		return wmi->ops->extract_atf_peer_stats_ev(wmi,
+				evt_buf, ev);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * wmi_extract_atf_token_info_ev() - extract atf token info
+ * from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param idx: Index indicating the peer number
+ * @param ev: Pointer to hold atf token info
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_extract_atf_token_info_ev(void *wmi_hdl, void *evt_buf,
+			uint8_t idx, wmi_host_atf_peer_stats_info *ev)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->extract_atf_token_info_ev)
+		return wmi->ops->extract_atf_token_info_ev(wmi,
+				evt_buf, idx, ev);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
 /**
  * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event
  * @wmi_handle: wmi handle
@@ -6179,6 +6381,26 @@ QDF_STATUS wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl,
 		return wmi_handle->ops->send_encrypt_decrypt_send_cmd(
 						wmi_handle,
 						params);
+	return QDF_STATUS_E_FAILURE;
+}
+
+/*
+ * wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands
+ * @wmi_handle: wmi handle
+ * @value: Priority value
+ *
+ * Send WMI_BTCOEX_CFG_CMDID parameters to fw.
+ *
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
+ */
+QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl,
+				int value)
+{
+	wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
+
+	if (wmi->ops->send_btcoex_wlan_priority_cmd)
+		return wmi->ops->send_btcoex_wlan_priority_cmd(wmi,
+				  value);
 
 	return QDF_STATUS_E_FAILURE;
 }

wmi_unified_non_tlv.c

@@ -1922,7 +1922,7 @@ QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 				 WMI_SCAN_EVENT_FOREIGN_CHANNEL |
 				 WMI_SCAN_EVENT_DEQUEUED
 #if QCA_LTEU_SUPPORT
-				 | WMI_SCAN_EVENT_INVALID
+				 | WMI_SCAN_EVENT_GPIO_TIMEOUT;
 #endif
 							;
 
@@ -1945,8 +1945,15 @@ QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
 	if (param->is_phy_error)
 		cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
 
+	if (param->half_rate)
+		cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
+
+	if (param->quarter_rate)
+		cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
+
 	/** send multiple braodcast probe req with this delay in between */
 	cmd->repeat_probe_time = param->repeat_probe_time;
+	cmd->probe_spacing_time = param->probe_spacing_time;
 	/** delay between channel change and first probe request */
 	cmd->probe_delay = param->probe_delay;
 	/** idle time on channel for which if no traffic is seen
@@ -3157,6 +3164,11 @@ send_mu_scan_cmd_non_tlv(wmi_unified_t wmi_handle,
 	cmd->mu_duration = param->duration;
 	cmd->mu_type = param->type;
 	cmd->lteu_tx_power = param->lteu_tx_power;
+	cmd->rssi_thr_bssid = param->rssi_thr_bssid;
+	cmd->rssi_thr_sta = param->rssi_thr_sta;
+	cmd->rssi_thr_sc = param->rssi_thr_sc;
+	cmd->plmn_id = param->plmn_id;
+	cmd->alpha_num_bssid = param->alpha_num_bssid;
 	return wmi_unified_cmd_send(wmi_handle, buf,
 				sizeof(wmi_mu_start_cmd),
 				WMI_MU_CAL_START_CMDID);
@@ -3193,6 +3205,7 @@ send_lteu_config_cmd_non_tlv(wmi_unified_t wmi_handle,
 	cmd->alpha_num_bssid = param->alpha_num_bssid;
 	cmd->use_actual_nf = param->use_actual_nf;
 	cmd->wifi_tx_power = param->wifi_tx_power;
+	cmd->allow_err_packets = param->allow_err_packets;
 	return wmi_unified_cmd_send(wmi_handle, buf,
 				sizeof(wmi_set_lteu_config),
 				WMI_SET_LTEU_CONFIG_CMDID);
@@ -4337,7 +4350,8 @@ send_pdev_set_chan_cmd_non_tlv(wmi_unified_t wmi_handle,
 	if (param->quarter_rate)
 		WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_QUARTER);
 
-	if (param->phy_mode == MODE_11AC_VHT80_80) {
+	if ((param->phy_mode == MODE_11AC_VHT80_80) ||
+			(param->phy_mode == MODE_11AC_VHT160)) {
 		qdf_print(
 		"WMI channel freq=%d, mode=%x band_center_freq1=%d band_center_freq2=%d\n",
 		cmd->chan.mhz,
@@ -5066,6 +5080,162 @@ send_start_oem_data_cmd_non_tlv(wmi_unified_t wmi_handle,
 	return QDF_STATUS_SUCCESS;
 }
 
+/**
+ * send_get_user_position_cmd_non_tlv() - send cmd get user position from fw
+ * @wmi_handle: wmi handle
+ * @value: user pos value
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS
+send_get_user_position_cmd_non_tlv(wmi_unified_t wmi_handle, uint32_t value)
+{
+	wmi_buf_t buf;
+	wmi_peer_gid_userpos_list_cmd *cmd;
+
+	buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_gid_userpos_list_cmd));
+	if (!buf) {
+		qdf_print("No WMI resource!");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_nbuf_put_tail(buf, sizeof(wmi_peer_gid_userpos_list_cmd));
+	cmd = (wmi_peer_gid_userpos_list_cmd *)(wmi_buf_data(buf));
+	cmd->aid = value;
+
+	if (wmi_unified_cmd_send(wmi_handle, buf,
+		sizeof(wmi_peer_gid_userpos_list_cmd),
+		WMI_PEER_GID_USERPOS_LIST_CMDID)) {
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * send_reset_peer_mumimo_tx_count_cmd_non_tlv() - send mumimo reset tx count fw
+ * @wmi_handle: wmi handle
+ * @value:	reset tx count
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS
+send_reset_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
+						uint32_t value)
+{
+	wmi_buf_t buf;
+	wmi_peer_txmu_rstcnt_cmd *cmd;
+
+	buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_rstcnt_cmd));
+	if (!buf) {
+		qdf_print("No WMI resource!");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_rstcnt_cmd));
+	cmd = (wmi_peer_txmu_rstcnt_cmd *)(wmi_buf_data(buf));
+	cmd->aid = value;
+
+	if (wmi_unified_cmd_send(wmi_handle, buf,
+		sizeof(wmi_peer_txmu_rstcnt_cmd),
+		WMI_PEER_TX_MU_TXMIT_RSTCNT_CMDID)) {
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * send_get_peer_mumimo_tx_count_cmd_non_tlv() - send cmd to get mumimo tx count from fw
+ * @wmi_handle: wmi handle
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS
+send_get_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
+						uint32_t value)
+{
+	wmi_buf_t buf;
+	wmi_peer_txmu_cnt_cmd *cmd;
+
+	buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_cnt_cmd));
+	if (!buf) {
+		qdf_print("No WMI resource!");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_cnt_cmd));
+	cmd = (wmi_peer_txmu_cnt_cmd *)(wmi_buf_data(buf));
+	cmd->aid = value;
+
+	if (wmi_unified_cmd_send(wmi_handle, buf,
+		sizeof(wmi_peer_txmu_cnt_cmd),
+		WMI_PEER_TX_MU_TXMIT_COUNT_CMDID)) {
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * send_pdev_caldata_version_check_cmd_non_tlv() - send caldata check cmd to fw
+ * @wmi_handle: wmi handle
+ * @param:	reserved param
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS
+send_pdev_caldata_version_check_cmd_non_tlv(wmi_unified_t wmi_handle,
+						uint32_t param)
+{
+	wmi_pdev_check_cal_version_cmd *cmd;
+	wmi_buf_t buf;
+	int32_t len = sizeof(wmi_pdev_check_cal_version_cmd);
+
+	buf = wmi_buf_alloc(wmi_handle, len);
+	if (!buf) {
+		qdf_print("%s:wmi_buf_alloc failed\n", __func__);
+		return QDF_STATUS_E_FAILURE;
+	}
+	cmd = (wmi_pdev_check_cal_version_cmd *)wmi_buf_data(buf);
+	cmd->reserved = param; /* set to 0x0 as expected from FW */
+	if (wmi_unified_cmd_send(wmi_handle, buf, len,
+			WMI_PDEV_CHECK_CAL_VERSION_CMDID)) {
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * send_btcoex_wlan_priority_cmd_non_tlv() - send btcoex wlan priority fw
+ * @wmi_handle: wmi handle
+ * @value:	priority value
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS
+send_btcoex_wlan_priority_cmd_non_tlv(wmi_unified_t wmi_handle, int value)
+{
+	wmi_buf_t buf;
+	wmi_btcoex_cfg_cmd *cmd;
+	int len = sizeof(wmi_btcoex_cfg_cmd);
+
+	buf = wmi_buf_alloc(wmi_handle, len);
+	if (!buf) {
+		qdf_print("%s:wmi_buf_alloc failed\n", __func__);
+		return QDF_STATUS_E_FAILURE;
+	}
+	cmd = (wmi_btcoex_cfg_cmd *) wmi_buf_data(buf);
+	cmd->btcoex_wlan_priority_bitmap = value;
+	if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_BTCOEX_CFG_CMDID)) {
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
 /**
  * wmi_copy_resource_config_non_tlv() - copy resource configuration function
  * @param resource_cfg: pointer to resource configuration
@@ -5849,6 +6019,99 @@ QDF_STATUS extract_mu_ev_param_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
 	param->status_reason = event->status_reason;
 	qdf_mem_copy(param->total_mu, event->total_mu, sizeof(param->total_mu));
 	param->num_active_bssid = event->num_active_bssid;
+	qdf_mem_copy(param->hidden_node_mu, event->hidden_node_mu,
+				sizeof(param->hidden_node_mu));
+	param->num_TA_entries = event->num_TA_entries;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * extract_mu_db_entry_non_tlv() - extract mu db entry from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param profile_data: Pointer to hold mu_db_entry
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS extract_mu_db_entry_non_tlv(wmi_unified_t wmi_handle,
+		void *evt_buf, uint8_t idx,
+		wmi_host_mu_db_entry *db_entry)
+{
+	wmi_mu_report_event *event = (wmi_mu_report_event *)evt_buf;
+
+	if (idx > event->num_TA_entries)
+		return QDF_STATUS_E_INVAL;
+
+	qdf_mem_copy(db_entry, &event->mu_entry[idx],
+		sizeof(wmi_host_mu_db_entry));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+
+/**
+ * extract_mumimo_tx_count_ev_param_non_tlv() - extract mumimo tx count from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold mu report
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS extract_mumimo_tx_count_ev_param_non_tlv(wmi_unified_t wmi_handle,
+			void *evt_buf, wmi_host_peer_txmu_cnt_event *param)
+{
+	wmi_peer_txmu_cnt_event *event = (wmi_peer_txmu_cnt_event *)evt_buf;
+
+	param->tx_mu_transmitted = event->tx_mu_transmitted;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * extract_peer_gid_userpos_list_ev_param_non_tlv() - extract gid user position
+ * 						      from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold peer user position list
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS extract_peer_gid_userpos_list_ev_param_non_tlv(
+			wmi_unified_t wmi_handle,
+			void *evt_buf,
+			wmi_host_peer_gid_userpos_list_event *param)
+{
+	wmi_peer_gid_userpos_list_event *event =
+			(wmi_peer_gid_userpos_list_event *)evt_buf;
+
+	qdf_mem_copy(param->usr_list, event->usr_list, sizeof(param->usr_list));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * extract_pdev_caldata_version_check_ev_param_non_tlv() - extract caldata from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param param: Pointer to hold peer caldata version data
+ *
+ * Return: 0 for success or error code
+ */
+QDF_STATUS extract_pdev_caldata_version_check_ev_param_non_tlv(
+			wmi_unified_t wmi_handle,
+			void *evt_buf,
+			wmi_host_pdev_check_cal_version_event *param)
+{
+	wmi_pdev_check_cal_version_event *event =
+			(wmi_pdev_check_cal_version_event *)evt_buf;
+
+	param->software_cal_version = event->software_cal_version;
+	param->board_cal_version = event->board_cal_version;
+	param->cal_ok = event->cal_ok;
+
+	qdf_mem_copy(param->board_mcn_detail, event->board_mcn_detail,
+				sizeof(param->board_mcn_detail));
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -7397,7 +7660,6 @@ static QDF_STATUS extract_inst_rssi_stats_event_non_tlv(
  * from event
  * @wmi_handle: wmi handle
  * @param evt_buf: pointer to event buffer
- * @param index: Index into chan stats
  * @param ev: Pointer to hold data traffic control
  *
  * Return: 0 for success or error code
@@ -7416,6 +7678,57 @@ static QDF_STATUS extract_tx_data_traffic_ctrl_ev_non_tlv(
 	return QDF_STATUS_SUCCESS;
 }
 
+/**
+ * extract_atf_peer_stats_ev_non_tlv() - extract atf peer stats
+ * from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @param ev: Pointer to hold atf stats event data
+ *
+ * Return: 0 for success or error code
+ */
+static QDF_STATUS extract_atf_peer_stats_ev_non_tlv(
+	wmi_unified_t wmi_handle, void *evt_buf,
+	wmi_host_atf_peer_stats_event *ev)
+{
+	wmi_atf_peer_stats_event *evt =
+		(wmi_atf_peer_stats_event *)evt_buf;
+
+	ev->num_atf_peers = evt->num_atf_peers;
+	ev->comp_usable_airtime = evt->comp_usable_airtime;
+	qdf_mem_copy(&ev->reserved[0], &evt->reserved[0],
+				sizeof(evt->reserved));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * extract_atf_token_info_ev_non_tlv() - extract atf token info
+ * from event
+ * @wmi_handle: wmi handle
+ * @param evt_buf: pointer to event buffer
+ * @idx: Index indicating the peer number
+ * @param atf_token_info: Pointer to hold atf token info
+ *
+ * Return: 0 for success or error code
+ */
+static QDF_STATUS extract_atf_token_info_ev_non_tlv(
+	wmi_unified_t wmi_handle, void *evt_buf,
+	uint8_t idx, wmi_host_atf_peer_stats_info *atf_token_info)
+{
+	wmi_atf_peer_stats_event *evt =
+		(wmi_atf_peer_stats_event *)evt_buf;
+
+	if (idx > evt->num_atf_peers)
+		return QDF_STATUS_E_INVAL;
+
+	atf_token_info->field1 = evt->token_info_list[idx].field1;
+	atf_token_info->field2 = evt->token_info_list[idx].field2;
+	atf_token_info->field3 = evt->token_info_list[idx].field3;
+
+	return QDF_STATUS_SUCCESS;
+}
+
 #ifdef WMI_INTERFACE_EVENT_LOGGING
 static bool is_management_record_non_tlv(uint32_t cmd_id)
 {
@@ -7555,6 +7868,14 @@ struct wmi_ops non_tlv_ops =  {
 	.send_rtt_keepalive_req_cmd = send_rtt_keepalive_req_cmd_non_tlv,
 	.send_periodic_chan_stats_config_cmd =
 			send_periodic_chan_stats_config_cmd_non_tlv,
+	.send_get_user_position_cmd = send_get_user_position_cmd_non_tlv,
+	.send_reset_peer_mumimo_tx_count_cmd =
+			send_reset_peer_mumimo_tx_count_cmd_non_tlv,
+	.send_get_peer_mumimo_tx_count_cmd =
+			send_get_peer_mumimo_tx_count_cmd_non_tlv,
+	.send_pdev_caldata_version_check_cmd =
+			send_pdev_caldata_version_check_cmd_non_tlv,
+	.send_btcoex_wlan_priority_cmd = send_btcoex_wlan_priority_cmd_non_tlv,
 
 	.get_target_cap_from_service_ready = extract_service_ready_non_tlv,
 	.extract_fw_version = extract_fw_version_non_tlv,
@@ -7625,6 +7946,16 @@ struct wmi_ops non_tlv_ops =  {
 	.extract_fips_event_data = extract_fips_event_data_non_tlv,
 	.extract_fips_event_error_status =
 				extract_fips_event_error_status_non_tlv,
+	.extract_mumimo_tx_count_ev_param =
+				extract_mumimo_tx_count_ev_param_non_tlv,
+	.extract_peer_gid_userpos_list_ev_param =
+				extract_peer_gid_userpos_list_ev_param_non_tlv,
+	.extract_pdev_caldata_version_check_ev_param =
+			extract_pdev_caldata_version_check_ev_param_non_tlv,
+	.extract_mu_db_entry = extract_mu_db_entry_non_tlv,
+	.extract_atf_peer_stats_ev = extract_atf_peer_stats_ev_non_tlv,
+	.extract_atf_token_info_ev = extract_atf_token_info_ev_non_tlv,
+
 };
 
 /**
@@ -7703,6 +8034,8 @@ static void populate_non_tlv_service(uint32_t *wmi_service)
 	wmi_service[wmi_service_tx_mode_push_pull] =
 				WMI_SERVICE_TX_MODE_PUSH_PULL;
 	wmi_service[wmi_service_tx_mode_dynamic] = WMI_SERVICE_TX_MODE_DYNAMIC;
+	wmi_service[wmi_service_check_cal_version] =
+				WMI_SERVICE_CHECK_CAL_VERSION;
 
 	wmi_service[wmi_service_roam_scan_offload] = WMI_SERVICE_UNAVAILABLE;
 	wmi_service[wmi_service_arpns_offload] = WMI_SERVICE_UNAVAILABLE;
@@ -7851,6 +8184,14 @@ static void populate_non_tlv_events_id(uint32_t *event_ids)
 	event_ids[wmi_tx_data_traffic_ctrl_event_id] =
 					WMI_TX_DATA_TRAFFIC_CTRL_EVENTID;
 	event_ids[wmi_pdev_utf_event_id] = WMI_PDEV_UTF_EVENTID;
+	event_ids[wmi_peer_tx_mu_txmit_count_event_id] =
+					WMI_PEER_TX_MU_TXMIT_COUNT_EVENTID;
+	event_ids[wmi_peer_gid_userpos_list_event_id] =
+					WMI_PEER_GID_USERPOS_LIST_EVENTID;
+	event_ids[wmi_pdev_check_cal_version_event_id] =
+					WMI_PDEV_CHECK_CAL_VERSION_EVENTID;
+	event_ids[wmi_atf_peer_stats_event_id] =
+					WMI_ATF_PEER_STATS_EVENTID;
 }
 
 /**
@@ -8034,6 +8375,10 @@ static void populate_pdev_param_non_tlv(uint32_t *pdev_param)
 		WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE;
 	pdev_param[wmi_pdev_param_atf_ssid_group_policy] =
 		WMI_PDEV_PARAM_ATF_SSID_GROUP_POLICY;
+	pdev_param[wmi_pdev_param_enable_btcoex] =
+		WMI_PDEV_PARAM_ENABLE_BTCOEX;
+	pdev_param[wmi_pdev_param_atf_peer_stats] =
+		WMI_PDEV_PARAM_ATF_PEER_STATS;
 	pdev_param[wmi_pdev_param_rfkill_enable] = WMI_UNAVAILABLE_PARAM;
 	pdev_param[wmi_pdev_param_hw_rfkill_config] = WMI_UNAVAILABLE_PARAM;
 	pdev_param[wmi_pdev_param_low_power_rf_enable] = WMI_UNAVAILABLE_PARAM;
@@ -8195,6 +8540,11 @@ static void populate_vdev_param_non_tlv(uint32_t *vdev_param)
 	vdev_param[wmi_vdev_param_sta_kickout] = WMI_VDEV_PARAM_STA_KICKOUT;
 	vdev_param[wmi_vdev_param_capabilities] =
 		WMI_VDEV_PARAM_CAPABILITIES;
+	vdev_param[wmi_vdev_param_mgmt_tx_power] = WMI_VDEV_PARAM_MGMT_TX_POWER;
+	vdev_param[wmi_vdev_param_atf_ssid_sched_policy] =
+		WMI_VDEV_PARAM_ATF_SSID_SCHED_POLICY;
+	vdev_param[wmi_vdev_param_disable_dyn_bw_rts] =
+		WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS;
 }
 #endif