Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit add6cd8d authored by Manikanta Pubbisetty's avatar Manikanta Pubbisetty Committed by Kalle Valo
Browse files

ath10k: add tdls support for 10.4 firmwares 



This patch adds the support of TDLS feature for 10.4 firmware
versions.

A new WMI service is added to advertise the support of TDLS for
10.4 firmwares.

Signed-off-by: default avatarManikanta Pubbisetty <mpubbise@qti.qualcomm.com>
Signed-off-by: default avatarKalle Valo <kvalo@qca.qualcomm.com>
parent 810fe818

drivers/net/wireless/ath/ath10k/core.c

+9 −0
Original line number Diff line number Diff line
@@ -1886,6 +1886,7 @@ static int ath10k_core_init_firmware_features(struct ath10k *ar) 
		ar->fw_stats_req_mask = WMI_10_4_STAT_PEER |

					WMI_10_4_STAT_PEER_EXTD;

		ar->max_spatial_stream = ar->hw_params.max_spatial_stream;

		ar->max_num_tdls_vdevs = TARGET_10_4_NUM_TDLS_VDEVS;



		if (test_bit(ATH10K_FW_FEATURE_PEER_FLOW_CONTROL,

			     fw_file->fw_features))
@@ -2124,6 +2125,14 @@ int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode, 
			     ar->running_fw->fw_file.fw_features))

			val |= WMI_10_4_COEX_GPIO_SUPPORT;



		if (test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY,

			     ar->wmi.svc_map))

			val |= WMI_10_4_TDLS_EXPLICIT_MODE_ONLY;



		if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA,

			     ar->wmi.svc_map))

			val |= WMI_10_4_TDLS_UAPSD_BUFFER_STA;



		status = ath10k_mac_ext_resource_config(ar, val);

		if (status) {

			ath10k_err(ar,

drivers/net/wireless/ath/ath10k/hw.h

+5 −0
Original line number Diff line number Diff line
@@ -720,6 +720,11 @@ ath10k_rx_desc_get_l3_pad_bytes(struct ath10k_hw_params *hw, 
#define TARGET_10_4_IPHDR_PAD_CONFIG		1

#define TARGET_10_4_QWRAP_CONFIG		0



/* TDLS config */

#define TARGET_10_4_NUM_TDLS_VDEVS		1

#define TARGET_10_4_NUM_TDLS_BUFFER_STA		1

#define TARGET_10_4_NUM_TDLS_SLEEP_STA		1



/* Maximum number of Copy Engine's supported */

#define CE_COUNT_MAX 12

drivers/net/wireless/ath/ath10k/mac.c

+4 −1
Original line number Diff line number Diff line
@@ -8197,8 +8197,11 @@ int ath10k_mac_register(struct ath10k *ar) 
			NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;

	}



	if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))

	if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) ||

	    test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) {

		ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;

		ieee80211_hw_set(ar->hw, TDLS_WIDER_BW);

	}



	ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;

	ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;

drivers/net/wireless/ath/ath10k/wmi.c

+161 −2
Original line number Diff line number Diff line
@@ -651,8 +651,6 @@ static struct wmi_cmd_map wmi_10_4_cmd_map = { 
	.gpio_output_cmdid = WMI_10_4_GPIO_OUTPUT_CMDID,

	.pdev_get_temperature_cmdid = WMI_10_4_PDEV_GET_TEMPERATURE_CMDID,

	.vdev_set_wmm_params_cmdid = WMI_CMD_UNSUPPORTED,

	.tdls_set_state_cmdid = WMI_CMD_UNSUPPORTED,

	.tdls_peer_update_cmdid = WMI_CMD_UNSUPPORTED,

	.adaptive_qcs_cmdid = WMI_CMD_UNSUPPORTED,

	.scan_update_request_cmdid = WMI_10_4_SCAN_UPDATE_REQUEST_CMDID,

	.vdev_standby_response_cmdid = WMI_10_4_VDEV_STANDBY_RESPONSE_CMDID,
@@ -711,6 +709,33 @@ static struct wmi_cmd_map wmi_10_4_cmd_map = { 
	.pdev_bss_chan_info_request_cmdid =

			WMI_10_4_PDEV_BSS_CHAN_INFO_REQUEST_CMDID,

	.ext_resource_cfg_cmdid = WMI_10_4_EXT_RESOURCE_CFG_CMDID,

	.vdev_set_ie_cmdid = WMI_10_4_VDEV_SET_IE_CMDID,

	.set_lteu_config_cmdid = WMI_10_4_SET_LTEU_CONFIG_CMDID,

	.atf_ssid_grouping_request_cmdid =

			WMI_10_4_ATF_SSID_GROUPING_REQUEST_CMDID,

	.peer_atf_ext_request_cmdid = WMI_10_4_PEER_ATF_EXT_REQUEST_CMDID,

	.set_periodic_channel_stats_cfg_cmdid =

			WMI_10_4_SET_PERIODIC_CHANNEL_STATS_CONFIG,

	.peer_bwf_request_cmdid = WMI_10_4_PEER_BWF_REQUEST_CMDID,

	.btcoex_cfg_cmdid = WMI_10_4_BTCOEX_CFG_CMDID,

	.peer_tx_mu_txmit_count_cmdid = WMI_10_4_PEER_TX_MU_TXMIT_COUNT_CMDID,

	.peer_tx_mu_txmit_rstcnt_cmdid = WMI_10_4_PEER_TX_MU_TXMIT_RSTCNT_CMDID,

	.peer_gid_userpos_list_cmdid = WMI_10_4_PEER_GID_USERPOS_LIST_CMDID,

	.pdev_check_cal_version_cmdid = WMI_10_4_PDEV_CHECK_CAL_VERSION_CMDID,

	.coex_version_cfg_cmid = WMI_10_4_COEX_VERSION_CFG_CMID,

	.pdev_get_rx_filter_cmdid = WMI_10_4_PDEV_GET_RX_FILTER_CMDID,

	.pdev_extended_nss_cfg_cmdid = WMI_10_4_PDEV_EXTENDED_NSS_CFG_CMDID,

	.vdev_set_scan_nac_rssi_cmdid = WMI_10_4_VDEV_SET_SCAN_NAC_RSSI_CMDID,

	.prog_gpio_band_select_cmdid = WMI_10_4_PROG_GPIO_BAND_SELECT_CMDID,

	.config_smart_logging_cmdid = WMI_10_4_CONFIG_SMART_LOGGING_CMDID,

	.debug_fatal_condition_cmdid = WMI_10_4_DEBUG_FATAL_CONDITION_CMDID,

	.get_tsf_timer_cmdid = WMI_10_4_GET_TSF_TIMER_CMDID,

	.pdev_get_tpc_table_cmdid = WMI_10_4_PDEV_GET_TPC_TABLE_CMDID,

	.vdev_sifs_trigger_time_cmdid = WMI_10_4_VDEV_SIFS_TRIGGER_TIME_CMDID,

	.pdev_wds_entry_list_cmdid = WMI_10_4_PDEV_WDS_ENTRY_LIST_CMDID,

	.tdls_set_state_cmdid = WMI_10_4_TDLS_SET_STATE_CMDID,

	.tdls_peer_update_cmdid = WMI_10_4_TDLS_PEER_UPDATE_CMDID,

	.tdls_set_offchan_mode_cmdid = WMI_10_4_TDLS_SET_OFFCHAN_MODE_CMDID,

};



/* MAIN WMI VDEV param map */
@@ -7803,14 +7828,28 @@ ath10k_wmi_10_4_ext_resource_config(struct ath10k *ar, 
{

	struct wmi_ext_resource_config_10_4_cmd *cmd;

	struct sk_buff *skb;

	u32 num_tdls_sleep_sta = 0;



	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));

	if (!skb)

		return ERR_PTR(-ENOMEM);



	if (test_bit(WMI_SERVICE_TDLS_UAPSD_SLEEP_STA, ar->wmi.svc_map))

		num_tdls_sleep_sta = TARGET_10_4_NUM_TDLS_SLEEP_STA;



	cmd = (struct wmi_ext_resource_config_10_4_cmd *)skb->data;

	cmd->host_platform_config = __cpu_to_le32(type);

	cmd->fw_feature_bitmap = __cpu_to_le32(fw_feature_bitmap);

	cmd->wlan_gpio_priority = __cpu_to_le32(-1);

	cmd->coex_version = __cpu_to_le32(WMI_NO_COEX_VERSION_SUPPORT);

	cmd->coex_gpio_pin1 = __cpu_to_le32(-1);

	cmd->coex_gpio_pin2 = __cpu_to_le32(-1);

	cmd->coex_gpio_pin3 = __cpu_to_le32(-1);

	cmd->num_tdls_vdevs = __cpu_to_le32(TARGET_10_4_NUM_TDLS_VDEVS);

	cmd->num_tdls_conn_table_entries = __cpu_to_le32(20);

	cmd->max_tdls_concurrent_sleep_sta = __cpu_to_le32(num_tdls_sleep_sta);

	cmd->max_tdls_concurrent_buffer_sta =

			__cpu_to_le32(TARGET_10_4_NUM_TDLS_BUFFER_STA);



	ath10k_dbg(ar, ATH10K_DBG_WMI,

		   "wmi ext resource config host type %d firmware feature bitmap %08x\n",
@@ -7818,6 +7857,124 @@ ath10k_wmi_10_4_ext_resource_config(struct ath10k *ar, 
	return skb;

}



static struct sk_buff *

ath10k_wmi_10_4_gen_update_fw_tdls_state(struct ath10k *ar, u32 vdev_id,

					 enum wmi_tdls_state state)

{

	struct wmi_10_4_tdls_set_state_cmd *cmd;

	struct sk_buff *skb;

	u32 options = 0;



	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));

	if (!skb)

		return ERR_PTR(-ENOMEM);



	if (test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map))

		state = WMI_TDLS_ENABLE_PASSIVE;



	if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map))

		options |= WMI_TDLS_BUFFER_STA_EN;



	cmd = (struct wmi_10_4_tdls_set_state_cmd *)skb->data;

	cmd->vdev_id = __cpu_to_le32(vdev_id);

	cmd->state = __cpu_to_le32(state);

	cmd->notification_interval_ms = __cpu_to_le32(5000);

	cmd->tx_discovery_threshold = __cpu_to_le32(100);

	cmd->tx_teardown_threshold = __cpu_to_le32(5);

	cmd->rssi_teardown_threshold = __cpu_to_le32(-75);

	cmd->rssi_delta = __cpu_to_le32(-20);

	cmd->tdls_options = __cpu_to_le32(options);

	cmd->tdls_peer_traffic_ind_window = __cpu_to_le32(2);

	cmd->tdls_peer_traffic_response_timeout_ms = __cpu_to_le32(5000);

	cmd->tdls_puapsd_mask = __cpu_to_le32(0xf);

	cmd->tdls_puapsd_inactivity_time_ms = __cpu_to_le32(0);

	cmd->tdls_puapsd_rx_frame_threshold = __cpu_to_le32(10);

	cmd->teardown_notification_ms = __cpu_to_le32(10);

	cmd->tdls_peer_kickout_threshold = __cpu_to_le32(96);



	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi update fw tdls state %d for vdev %i\n",

		   state, vdev_id);

	return skb;

}



static u32 ath10k_wmi_prepare_peer_qos(u8 uapsd_queues, u8 sp)

{

	u32 peer_qos = 0;



	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)

		peer_qos |= WMI_TDLS_PEER_QOS_AC_VO;

	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)

		peer_qos |= WMI_TDLS_PEER_QOS_AC_VI;

	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)

		peer_qos |= WMI_TDLS_PEER_QOS_AC_BK;

	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)

		peer_qos |= WMI_TDLS_PEER_QOS_AC_BE;



	peer_qos |= SM(sp, WMI_TDLS_PEER_SP);



	return peer_qos;

}



static struct sk_buff *

ath10k_wmi_10_4_gen_tdls_peer_update(struct ath10k *ar,

				     const struct wmi_tdls_peer_update_cmd_arg *arg,

				     const struct wmi_tdls_peer_capab_arg *cap,

				     const struct wmi_channel_arg *chan_arg)

{

	struct wmi_10_4_tdls_peer_update_cmd *cmd;

	struct wmi_tdls_peer_capabilities *peer_cap;

	struct wmi_channel *chan;

	struct sk_buff *skb;

	u32 peer_qos;

	int len, chan_len;

	int i;



	/* tdls peer update cmd has place holder for one channel*/

	chan_len = cap->peer_chan_len ? (cap->peer_chan_len - 1) : 0;



	len = sizeof(*cmd) + chan_len * sizeof(*chan);



	skb = ath10k_wmi_alloc_skb(ar, len);

	if (!skb)

		return ERR_PTR(-ENOMEM);



	memset(skb->data, 0, sizeof(*cmd));



	cmd = (struct wmi_10_4_tdls_peer_update_cmd *)skb->data;

	cmd->vdev_id = __cpu_to_le32(arg->vdev_id);

	ether_addr_copy(cmd->peer_macaddr.addr, arg->addr);

	cmd->peer_state = __cpu_to_le32(arg->peer_state);



	peer_qos = ath10k_wmi_prepare_peer_qos(cap->peer_uapsd_queues,

					       cap->peer_max_sp);



	peer_cap = &cmd->peer_capab;

	peer_cap->peer_qos = __cpu_to_le32(peer_qos);

	peer_cap->buff_sta_support = __cpu_to_le32(cap->buff_sta_support);

	peer_cap->off_chan_support = __cpu_to_le32(cap->off_chan_support);

	peer_cap->peer_curr_operclass = __cpu_to_le32(cap->peer_curr_operclass);

	peer_cap->self_curr_operclass = __cpu_to_le32(cap->self_curr_operclass);

	peer_cap->peer_chan_len = __cpu_to_le32(cap->peer_chan_len);

	peer_cap->peer_operclass_len = __cpu_to_le32(cap->peer_operclass_len);



	for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++)

		peer_cap->peer_operclass[i] = cap->peer_operclass[i];



	peer_cap->is_peer_responder = __cpu_to_le32(cap->is_peer_responder);

	peer_cap->pref_offchan_num = __cpu_to_le32(cap->pref_offchan_num);

	peer_cap->pref_offchan_bw = __cpu_to_le32(cap->pref_offchan_bw);



	for (i = 0; i < cap->peer_chan_len; i++) {

		chan = (struct wmi_channel *)&peer_cap->peer_chan_list[i];

		ath10k_wmi_put_wmi_channel(chan, &chan_arg[i]);

	}



	ath10k_dbg(ar, ATH10K_DBG_WMI,

		   "wmi tdls peer update vdev %i state %d n_chans %u\n",

		   arg->vdev_id, arg->peer_state, cap->peer_chan_len);

	return skb;

}



static struct sk_buff *

ath10k_wmi_op_gen_echo(struct ath10k *ar, u32 value)

{
@@ -8197,6 +8354,8 @@ static const struct wmi_ops wmi_10_4_ops = { 
	.gen_delba_send = ath10k_wmi_op_gen_delba_send,

	.fw_stats_fill = ath10k_wmi_10_4_op_fw_stats_fill,

	.ext_resource_config = ath10k_wmi_10_4_ext_resource_config,

	.gen_update_fw_tdls_state = ath10k_wmi_10_4_gen_update_fw_tdls_state,

	.gen_tdls_peer_update = ath10k_wmi_10_4_gen_tdls_peer_update,



	/* shared with 10.2 */

	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,

drivers/net/wireless/ath/ath10k/wmi.h

+257 −0
Original line number Diff line number Diff line
@@ -184,6 +184,17 @@ enum wmi_service { 
	WMI_SERVICE_TX_MODE_PUSH_ONLY,

	WMI_SERVICE_TX_MODE_PUSH_PULL,

	WMI_SERVICE_TX_MODE_DYNAMIC,

	WMI_SERVICE_VDEV_RX_FILTER,

	WMI_SERVICE_BTCOEX,

	WMI_SERVICE_CHECK_CAL_VERSION,

	WMI_SERVICE_DBGLOG_WARN2,

	WMI_SERVICE_BTCOEX_DUTY_CYCLE,

	WMI_SERVICE_4_WIRE_COEX_SUPPORT,

	WMI_SERVICE_EXTENDED_NSS_SUPPORT,

	WMI_SERVICE_PROG_GPIO_BAND_SELECT,

	WMI_SERVICE_SMART_LOGGING_SUPPORT,

	WMI_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE,

	WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY,



	/* keep last */

	WMI_SERVICE_MAX,
@@ -310,6 +321,21 @@ enum wmi_10_4_service { 
	WMI_10_4_SERVICE_TX_MODE_PUSH_ONLY,

	WMI_10_4_SERVICE_TX_MODE_PUSH_PULL,

	WMI_10_4_SERVICE_TX_MODE_DYNAMIC,

	WMI_10_4_SERVICE_VDEV_RX_FILTER,

	WMI_10_4_SERVICE_BTCOEX,

	WMI_10_4_SERVICE_CHECK_CAL_VERSION,

	WMI_10_4_SERVICE_DBGLOG_WARN2,

	WMI_10_4_SERVICE_BTCOEX_DUTY_CYCLE,

	WMI_10_4_SERVICE_4_WIRE_COEX_SUPPORT,

	WMI_10_4_SERVICE_EXTENDED_NSS_SUPPORT,

	WMI_10_4_SERVICE_PROG_GPIO_BAND_SELECT,

	WMI_10_4_SERVICE_SMART_LOGGING_SUPPORT,

	WMI_10_4_SERVICE_TDLS,

	WMI_10_4_SERVICE_TDLS_OFFCHAN,

	WMI_10_4_SERVICE_TDLS_UAPSD_BUFFER_STA,

	WMI_10_4_SERVICE_TDLS_UAPSD_SLEEP_STA,

	WMI_10_4_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE,

	WMI_10_4_SERVICE_TDLS_EXPLICIT_MODE_ONLY,

};



static inline char *wmi_service_name(int service_id)
@@ -408,6 +434,16 @@ static inline char *wmi_service_name(int service_id) 
	SVCSTR(WMI_SERVICE_TX_MODE_PUSH_ONLY);

	SVCSTR(WMI_SERVICE_TX_MODE_PUSH_PULL);

	SVCSTR(WMI_SERVICE_TX_MODE_DYNAMIC);

	SVCSTR(WMI_SERVICE_VDEV_RX_FILTER);

	SVCSTR(WMI_SERVICE_CHECK_CAL_VERSION);

	SVCSTR(WMI_SERVICE_DBGLOG_WARN2);

	SVCSTR(WMI_SERVICE_BTCOEX_DUTY_CYCLE);

	SVCSTR(WMI_SERVICE_4_WIRE_COEX_SUPPORT);

	SVCSTR(WMI_SERVICE_EXTENDED_NSS_SUPPORT);

	SVCSTR(WMI_SERVICE_PROG_GPIO_BAND_SELECT);

	SVCSTR(WMI_SERVICE_SMART_LOGGING_SUPPORT);

	SVCSTR(WMI_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE);

	SVCSTR(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY);

	default:

		return NULL;

	}
@@ -674,6 +710,36 @@ static inline void wmi_10_4_svc_map(const __le32 *in, unsigned long *out, 
	       WMI_SERVICE_TX_MODE_PUSH_PULL, len);

	SVCMAP(WMI_10_4_SERVICE_TX_MODE_DYNAMIC,

	       WMI_SERVICE_TX_MODE_DYNAMIC, len);

	SVCMAP(WMI_10_4_SERVICE_VDEV_RX_FILTER,

	       WMI_SERVICE_VDEV_RX_FILTER, len);

	SVCMAP(WMI_10_4_SERVICE_BTCOEX,

	       WMI_SERVICE_BTCOEX, len);

	SVCMAP(WMI_10_4_SERVICE_CHECK_CAL_VERSION,

	       WMI_SERVICE_CHECK_CAL_VERSION, len);

	SVCMAP(WMI_10_4_SERVICE_DBGLOG_WARN2,

	       WMI_SERVICE_DBGLOG_WARN2, len);

	SVCMAP(WMI_10_4_SERVICE_BTCOEX_DUTY_CYCLE,

	       WMI_SERVICE_BTCOEX_DUTY_CYCLE, len);

	SVCMAP(WMI_10_4_SERVICE_4_WIRE_COEX_SUPPORT,

	       WMI_SERVICE_4_WIRE_COEX_SUPPORT, len);

	SVCMAP(WMI_10_4_SERVICE_EXTENDED_NSS_SUPPORT,

	       WMI_SERVICE_EXTENDED_NSS_SUPPORT, len);

	SVCMAP(WMI_10_4_SERVICE_PROG_GPIO_BAND_SELECT,

	       WMI_SERVICE_PROG_GPIO_BAND_SELECT, len);

	SVCMAP(WMI_10_4_SERVICE_SMART_LOGGING_SUPPORT,

	       WMI_SERVICE_SMART_LOGGING_SUPPORT, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS,

	       WMI_SERVICE_TDLS, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS_OFFCHAN,

	       WMI_SERVICE_TDLS_OFFCHAN, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS_UAPSD_BUFFER_STA,

	       WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS_UAPSD_SLEEP_STA,

	       WMI_SERVICE_TDLS_UAPSD_SLEEP_STA, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE,

	       WMI_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE, len);

	SVCMAP(WMI_10_4_SERVICE_TDLS_EXPLICIT_MODE_ONLY,

	       WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, len);

}



#undef SVCMAP
@@ -848,6 +914,29 @@ struct wmi_cmd_map { 
	u32 pdev_bss_chan_info_request_cmdid;

	u32 pdev_enable_adaptive_cca_cmdid;

	u32 ext_resource_cfg_cmdid;

	u32 vdev_set_ie_cmdid;

	u32 set_lteu_config_cmdid;

	u32 atf_ssid_grouping_request_cmdid;

	u32 peer_atf_ext_request_cmdid;

	u32 set_periodic_channel_stats_cfg_cmdid;

	u32 peer_bwf_request_cmdid;

	u32 btcoex_cfg_cmdid;

	u32 peer_tx_mu_txmit_count_cmdid;

	u32 peer_tx_mu_txmit_rstcnt_cmdid;

	u32 peer_gid_userpos_list_cmdid;

	u32 pdev_check_cal_version_cmdid;

	u32 coex_version_cfg_cmid;

	u32 pdev_get_rx_filter_cmdid;

	u32 pdev_extended_nss_cfg_cmdid;

	u32 vdev_set_scan_nac_rssi_cmdid;

	u32 prog_gpio_band_select_cmdid;

	u32 config_smart_logging_cmdid;

	u32 debug_fatal_condition_cmdid;

	u32 get_tsf_timer_cmdid;

	u32 pdev_get_tpc_table_cmdid;

	u32 vdev_sifs_trigger_time_cmdid;

	u32 pdev_wds_entry_list_cmdid;

	u32 tdls_set_offchan_mode_cmdid;

};



/*
@@ -1658,6 +1747,29 @@ enum wmi_10_4_cmd_id { 
	WMI_10_4_EXT_RESOURCE_CFG_CMDID,

	WMI_10_4_VDEV_SET_IE_CMDID,

	WMI_10_4_SET_LTEU_CONFIG_CMDID,

	WMI_10_4_ATF_SSID_GROUPING_REQUEST_CMDID,

	WMI_10_4_PEER_ATF_EXT_REQUEST_CMDID,

	WMI_10_4_SET_PERIODIC_CHANNEL_STATS_CONFIG,

	WMI_10_4_PEER_BWF_REQUEST_CMDID,

	WMI_10_4_BTCOEX_CFG_CMDID,

	WMI_10_4_PEER_TX_MU_TXMIT_COUNT_CMDID,

	WMI_10_4_PEER_TX_MU_TXMIT_RSTCNT_CMDID,

	WMI_10_4_PEER_GID_USERPOS_LIST_CMDID,

	WMI_10_4_PDEV_CHECK_CAL_VERSION_CMDID,

	WMI_10_4_COEX_VERSION_CFG_CMID,

	WMI_10_4_PDEV_GET_RX_FILTER_CMDID,

	WMI_10_4_PDEV_EXTENDED_NSS_CFG_CMDID,

	WMI_10_4_VDEV_SET_SCAN_NAC_RSSI_CMDID,

	WMI_10_4_PROG_GPIO_BAND_SELECT_CMDID,

	WMI_10_4_CONFIG_SMART_LOGGING_CMDID,

	WMI_10_4_DEBUG_FATAL_CONDITION_CMDID,

	WMI_10_4_GET_TSF_TIMER_CMDID,

	WMI_10_4_PDEV_GET_TPC_TABLE_CMDID,

	WMI_10_4_VDEV_SIFS_TRIGGER_TIME_CMDID,

	WMI_10_4_PDEV_WDS_ENTRY_LIST_CMDID,

	WMI_10_4_TDLS_SET_STATE_CMDID,

	WMI_10_4_TDLS_PEER_UPDATE_CMDID,

	WMI_10_4_TDLS_SET_OFFCHAN_MODE_CMDID,

	WMI_10_4_PDEV_UTF_CMDID = WMI_10_4_END_CMDID - 1,

};
@@ -1721,6 +1833,18 @@ enum wmi_10_4_event_id { 
	WMI_10_4_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID,

	WMI_10_4_PDEV_BSS_CHAN_INFO_EVENTID,

	WMI_10_4_MU_REPORT_EVENTID,

	WMI_10_4_TX_DATA_TRAFFIC_CTRL_EVENTID,

	WMI_10_4_PEER_TX_MU_TXMIT_COUNT_EVENTID,

	WMI_10_4_PEER_GID_USERPOS_LIST_EVENTID,

	WMI_10_4_PDEV_CHECK_CAL_VERSION_EVENTID,

	WMI_10_4_ATF_PEER_STATS_EVENTID,

	WMI_10_4_PDEV_GET_RX_FILTER_EVENTID,

	WMI_10_4_NAC_RSSI_EVENTID,

	WMI_10_4_DEBUG_FATAL_CONDITION_EVENTID,

	WMI_10_4_GET_TSF_TIMER_RESP_EVENTID,

	WMI_10_4_PDEV_TPC_TABLE_EVENTID,

	WMI_10_4_PDEV_WDS_ENTRY_LIST_EVENTID,

	WMI_10_4_TDLS_PEER_EVENTID,

	WMI_10_4_PDEV_UTF_EVENTID = WMI_10_4_END_EVENTID - 1,

};
@@ -2729,6 +2853,18 @@ struct wmi_resource_config_10_4 { 
	__le32 qwrap_config;

} __packed;



enum wmi_coex_version {

	WMI_NO_COEX_VERSION_SUPPORT	= 0,

	/* 3 wire coex support*/

	WMI_COEX_VERSION_1		= 1,

	/* 2.5 wire coex support*/

	WMI_COEX_VERSION_2		= 2,

	/* 2.5 wire coex with duty cycle support */

	WMI_COEX_VERSION_3		= 3,

	/* 4 wire coex support*/

	WMI_COEX_VERSION_4		= 4,

};



/**

 * enum wmi_10_4_feature_mask - WMI 10.4 feature enable/disable flags

 * @WMI_10_4_LTEU_SUPPORT: LTEU config
@@ -2737,6 +2873,14 @@ struct wmi_resource_config_10_4 { 
 * @WMI_10_4_AUX_RADIO_CHAN_LOAD_INTF: AUX Radio Enhancement for chan load scan

 * @WMI_10_4_BSS_CHANNEL_INFO_64: BSS channel info stats

 * @WMI_10_4_PEER_STATS: Per station stats

 * @WMI_10_4_VDEV_STATS: Per vdev stats

 * @WMI_10_4_TDLS: Implicit TDLS support in firmware enable/disable

 * @WMI_10_4_TDLS_OFFCHAN: TDLS offchannel support enable/disable

 * @WMI_10_4_TDLS_UAPSD_BUFFER_STA: TDLS buffer sta support enable/disable

 * @WMI_10_4_TDLS_UAPSD_SLEEP_STA: TDLS sleep sta support enable/disable

 * @WMI_10_4_TDLS_CONN_TRACKER_IN_HOST_MODE: TDLS connection tracker in host

 *	enable/disable

 * @WMI_10_4_TDLS_EXPLICIT_MODE_ONLY:Explicit TDLS mode enable/disable

 */

enum wmi_10_4_feature_mask {

	WMI_10_4_LTEU_SUPPORT			= BIT(0),
@@ -2745,6 +2889,14 @@ enum wmi_10_4_feature_mask { 
	WMI_10_4_AUX_RADIO_CHAN_LOAD_INTF	= BIT(3),

	WMI_10_4_BSS_CHANNEL_INFO_64		= BIT(4),

	WMI_10_4_PEER_STATS			= BIT(5),

	WMI_10_4_VDEV_STATS			= BIT(6),

	WMI_10_4_TDLS				= BIT(7),

	WMI_10_4_TDLS_OFFCHAN			= BIT(8),

	WMI_10_4_TDLS_UAPSD_BUFFER_STA		= BIT(9),

	WMI_10_4_TDLS_UAPSD_SLEEP_STA		= BIT(10),

	WMI_10_4_TDLS_CONN_TRACKER_IN_HOST_MODE = BIT(11),

	WMI_10_4_TDLS_EXPLICIT_MODE_ONLY	= BIT(12),



};



struct wmi_ext_resource_config_10_4_cmd {
@@ -2752,6 +2904,22 @@ struct wmi_ext_resource_config_10_4_cmd { 
	__le32 host_platform_config;

	/* see enum wmi_10_4_feature_mask */

	__le32 fw_feature_bitmap;

	/* WLAN priority GPIO number */

	__le32 wlan_gpio_priority;

	/* see enum wmi_coex_version */

	__le32 coex_version;

	/* COEX GPIO config */

	__le32 coex_gpio_pin1;

	__le32 coex_gpio_pin2;

	__le32 coex_gpio_pin3;

	/* number of vdevs allowed to perform tdls */

	__le32 num_tdls_vdevs;

	/* number of peers to track per TDLS vdev */

	__le32 num_tdls_conn_table_entries;

	/* number of tdls sleep sta supported */

	__le32 max_tdls_concurrent_sleep_sta;

	/* number of tdls buffer sta supported */

	__le32 max_tdls_concurrent_buffer_sta;

};



/* strucutre describing host memory chunk. */
@@ -6567,6 +6735,22 @@ struct wmi_tdls_peer_update_cmd_arg { 


#define WMI_TDLS_MAX_SUPP_OPER_CLASSES 32



#define WMI_TDLS_PEER_SP_MASK	0x60

#define WMI_TDLS_PEER_SP_LSB	5



enum wmi_tdls_options {

	WMI_TDLS_OFFCHAN_EN = BIT(0),

	WMI_TDLS_BUFFER_STA_EN = BIT(1),

	WMI_TDLS_SLEEP_STA_EN = BIT(2),

};



enum {

	WMI_TDLS_PEER_QOS_AC_VO = BIT(0),

	WMI_TDLS_PEER_QOS_AC_VI = BIT(1),

	WMI_TDLS_PEER_QOS_AC_BK = BIT(2),

	WMI_TDLS_PEER_QOS_AC_BE = BIT(3),

};



struct wmi_tdls_peer_capab_arg {

	u8 peer_uapsd_queues;

	u8 peer_max_sp;
@@ -6582,6 +6766,79 @@ struct wmi_tdls_peer_capab_arg { 
	u32 pref_offchan_bw;

};



struct wmi_10_4_tdls_set_state_cmd {

	__le32 vdev_id;

	__le32 state;

	__le32 notification_interval_ms;

	__le32 tx_discovery_threshold;

	__le32 tx_teardown_threshold;

	__le32 rssi_teardown_threshold;

	__le32 rssi_delta;

	__le32 tdls_options;

	__le32 tdls_peer_traffic_ind_window;

	__le32 tdls_peer_traffic_response_timeout_ms;

	__le32 tdls_puapsd_mask;

	__le32 tdls_puapsd_inactivity_time_ms;

	__le32 tdls_puapsd_rx_frame_threshold;

	__le32 teardown_notification_ms;

	__le32 tdls_peer_kickout_threshold;

} __packed;



struct wmi_tdls_peer_capabilities {

	__le32 peer_qos;

	__le32 buff_sta_support;

	__le32 off_chan_support;

	__le32 peer_curr_operclass;

	__le32 self_curr_operclass;

	__le32 peer_chan_len;

	__le32 peer_operclass_len;

	u8 peer_operclass[WMI_TDLS_MAX_SUPP_OPER_CLASSES];

	__le32 is_peer_responder;

	__le32 pref_offchan_num;

	__le32 pref_offchan_bw;

	struct wmi_channel peer_chan_list[1];

} __packed;



struct wmi_10_4_tdls_peer_update_cmd {

	__le32 vdev_id;

	struct wmi_mac_addr peer_macaddr;

	__le32 peer_state;

	__le32 reserved[4];

	struct wmi_tdls_peer_capabilities peer_capab;

} __packed;



enum wmi_tdls_peer_reason {

	WMI_TDLS_TEARDOWN_REASON_TX,

	WMI_TDLS_TEARDOWN_REASON_RSSI,

	WMI_TDLS_TEARDOWN_REASON_SCAN,

	WMI_TDLS_DISCONNECTED_REASON_PEER_DELETE,

	WMI_TDLS_TEARDOWN_REASON_PTR_TIMEOUT,

	WMI_TDLS_TEARDOWN_REASON_BAD_PTR,

	WMI_TDLS_TEARDOWN_REASON_NO_RESPONSE,

	WMI_TDLS_ENTER_BUF_STA,

	WMI_TDLS_EXIT_BUF_STA,

	WMI_TDLS_ENTER_BT_BUSY_MODE,

	WMI_TDLS_EXIT_BT_BUSY_MODE,

	WMI_TDLS_SCAN_STARTED_EVENT,

	WMI_TDLS_SCAN_COMPLETED_EVENT,

};



enum wmi_tdls_peer_notification {

	WMI_TDLS_SHOULD_DISCOVER,

	WMI_TDLS_SHOULD_TEARDOWN,

	WMI_TDLS_PEER_DISCONNECTED,

	WMI_TDLS_CONNECTION_TRACKER_NOTIFICATION,

};



struct wmi_tdls_peer_event {

	struct wmi_mac_addr peer_macaddr;

	/* see enum wmi_tdls_peer_notification*/

	__le32 peer_status;

	/* see enum wmi_tdls_peer_reason */

	__le32 peer_reason;

	__le32 vdev_id;

} __packed;



enum wmi_txbf_conf {

	WMI_TXBF_CONF_UNSUPPORTED,

	WMI_TXBF_CONF_BEFORE_ASSOC,