1// SPDX-License-Identifier: ISC
   2/*
   3 * Copyright (c) 2005-2011 Atheros Communications Inc.
   4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
   5 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
   6 */
   7
   8#include <linux/skbuff.h>
   9#include <linux/ctype.h>
  10
  11#include "core.h"
  12#include "htc.h"
  13#include "debug.h"
  14#include "wmi.h"
  15#include "wmi-tlv.h"
  16#include "mac.h"
  17#include "testmode.h"
  18#include "wmi-ops.h"
  19#include "p2p.h"
  20#include "hw.h"
  21#include "hif.h"
  22#include "txrx.h"
  23
  24#define ATH10K_WMI_BARRIER_ECHO_ID 0xBA991E9
  25#define ATH10K_WMI_BARRIER_TIMEOUT_HZ (3 * HZ)
  26#define ATH10K_WMI_DFS_CONF_TIMEOUT_HZ (HZ / 6)
  27
  28/* MAIN WMI cmd track */
  29static struct wmi_cmd_map wmi_cmd_map = {
  30	.init_cmdid = WMI_INIT_CMDID,
  31	.start_scan_cmdid = WMI_START_SCAN_CMDID,
  32	.stop_scan_cmdid = WMI_STOP_SCAN_CMDID,
  33	.scan_chan_list_cmdid = WMI_SCAN_CHAN_LIST_CMDID,
  34	.scan_sch_prio_tbl_cmdid = WMI_SCAN_SCH_PRIO_TBL_CMDID,
  35	.scan_prob_req_oui_cmdid = WMI_CMD_UNSUPPORTED,
  36	.pdev_set_regdomain_cmdid = WMI_PDEV_SET_REGDOMAIN_CMDID,
  37	.pdev_set_channel_cmdid = WMI_PDEV_SET_CHANNEL_CMDID,
  38	.pdev_set_param_cmdid = WMI_PDEV_SET_PARAM_CMDID,
  39	.pdev_pktlog_enable_cmdid = WMI_PDEV_PKTLOG_ENABLE_CMDID,
  40	.pdev_pktlog_disable_cmdid = WMI_PDEV_PKTLOG_DISABLE_CMDID,
  41	.pdev_set_wmm_params_cmdid = WMI_PDEV_SET_WMM_PARAMS_CMDID,
  42	.pdev_set_ht_cap_ie_cmdid = WMI_PDEV_SET_HT_CAP_IE_CMDID,
  43	.pdev_set_vht_cap_ie_cmdid = WMI_PDEV_SET_VHT_CAP_IE_CMDID,
  44	.pdev_set_dscp_tid_map_cmdid = WMI_PDEV_SET_DSCP_TID_MAP_CMDID,
  45	.pdev_set_quiet_mode_cmdid = WMI_PDEV_SET_QUIET_MODE_CMDID,
  46	.pdev_green_ap_ps_enable_cmdid = WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID,
  47	.pdev_get_tpc_config_cmdid = WMI_PDEV_GET_TPC_CONFIG_CMDID,
  48	.pdev_set_base_macaddr_cmdid = WMI_PDEV_SET_BASE_MACADDR_CMDID,
  49	.vdev_create_cmdid = WMI_VDEV_CREATE_CMDID,
  50	.vdev_delete_cmdid = WMI_VDEV_DELETE_CMDID,
  51	.vdev_start_request_cmdid = WMI_VDEV_START_REQUEST_CMDID,
  52	.vdev_restart_request_cmdid = WMI_VDEV_RESTART_REQUEST_CMDID,
  53	.vdev_up_cmdid = WMI_VDEV_UP_CMDID,
  54	.vdev_stop_cmdid = WMI_VDEV_STOP_CMDID,
  55	.vdev_down_cmdid = WMI_VDEV_DOWN_CMDID,
  56	.vdev_set_param_cmdid = WMI_VDEV_SET_PARAM_CMDID,
  57	.vdev_install_key_cmdid = WMI_VDEV_INSTALL_KEY_CMDID,
  58	.peer_create_cmdid = WMI_PEER_CREATE_CMDID,
  59	.peer_delete_cmdid = WMI_PEER_DELETE_CMDID,
  60	.peer_flush_tids_cmdid = WMI_PEER_FLUSH_TIDS_CMDID,
  61	.peer_set_param_cmdid = WMI_PEER_SET_PARAM_CMDID,
  62	.peer_assoc_cmdid = WMI_PEER_ASSOC_CMDID,
  63	.peer_add_wds_entry_cmdid = WMI_PEER_ADD_WDS_ENTRY_CMDID,
  64	.peer_remove_wds_entry_cmdid = WMI_PEER_REMOVE_WDS_ENTRY_CMDID,
  65	.peer_mcast_group_cmdid = WMI_PEER_MCAST_GROUP_CMDID,
  66	.bcn_tx_cmdid = WMI_BCN_TX_CMDID,
  67	.pdev_send_bcn_cmdid = WMI_PDEV_SEND_BCN_CMDID,
  68	.bcn_tmpl_cmdid = WMI_BCN_TMPL_CMDID,
  69	.bcn_filter_rx_cmdid = WMI_BCN_FILTER_RX_CMDID,
  70	.prb_req_filter_rx_cmdid = WMI_PRB_REQ_FILTER_RX_CMDID,
  71	.mgmt_tx_cmdid = WMI_MGMT_TX_CMDID,
  72	.prb_tmpl_cmdid = WMI_PRB_TMPL_CMDID,
  73	.addba_clear_resp_cmdid = WMI_ADDBA_CLEAR_RESP_CMDID,
  74	.addba_send_cmdid = WMI_ADDBA_SEND_CMDID,
  75	.addba_status_cmdid = WMI_ADDBA_STATUS_CMDID,
  76	.delba_send_cmdid = WMI_DELBA_SEND_CMDID,
  77	.addba_set_resp_cmdid = WMI_ADDBA_SET_RESP_CMDID,
  78	.send_singleamsdu_cmdid = WMI_SEND_SINGLEAMSDU_CMDID,
  79	.sta_powersave_mode_cmdid = WMI_STA_POWERSAVE_MODE_CMDID,
  80	.sta_powersave_param_cmdid = WMI_STA_POWERSAVE_PARAM_CMDID,
  81	.sta_mimo_ps_mode_cmdid = WMI_STA_MIMO_PS_MODE_CMDID,
  82	.pdev_dfs_enable_cmdid = WMI_PDEV_DFS_ENABLE_CMDID,
  83	.pdev_dfs_disable_cmdid = WMI_PDEV_DFS_DISABLE_CMDID,
  84	.roam_scan_mode = WMI_ROAM_SCAN_MODE,
  85	.roam_scan_rssi_threshold = WMI_ROAM_SCAN_RSSI_THRESHOLD,
  86	.roam_scan_period = WMI_ROAM_SCAN_PERIOD,
  87	.roam_scan_rssi_change_threshold = WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD,
  88	.roam_ap_profile = WMI_ROAM_AP_PROFILE,
  89	.ofl_scan_add_ap_profile = WMI_ROAM_AP_PROFILE,
  90	.ofl_scan_remove_ap_profile = WMI_OFL_SCAN_REMOVE_AP_PROFILE,
  91	.ofl_scan_period = WMI_OFL_SCAN_PERIOD,
  92	.p2p_dev_set_device_info = WMI_P2P_DEV_SET_DEVICE_INFO,
  93	.p2p_dev_set_discoverability = WMI_P2P_DEV_SET_DISCOVERABILITY,
  94	.p2p_go_set_beacon_ie = WMI_P2P_GO_SET_BEACON_IE,
  95	.p2p_go_set_probe_resp_ie = WMI_P2P_GO_SET_PROBE_RESP_IE,
  96	.p2p_set_vendor_ie_data_cmdid = WMI_P2P_SET_VENDOR_IE_DATA_CMDID,
  97	.ap_ps_peer_param_cmdid = WMI_AP_PS_PEER_PARAM_CMDID,
  98	.ap_ps_peer_uapsd_coex_cmdid = WMI_AP_PS_PEER_UAPSD_COEX_CMDID,
  99	.peer_rate_retry_sched_cmdid = WMI_PEER_RATE_RETRY_SCHED_CMDID,
 100	.wlan_profile_trigger_cmdid = WMI_WLAN_PROFILE_TRIGGER_CMDID,
 101	.wlan_profile_set_hist_intvl_cmdid =
 102				WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
 103	.wlan_profile_get_profile_data_cmdid =
 104				WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
 105	.wlan_profile_enable_profile_id_cmdid =
 106				WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
 107	.wlan_profile_list_profile_id_cmdid =
 108				WMI_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
 109	.pdev_suspend_cmdid = WMI_PDEV_SUSPEND_CMDID,
 110	.pdev_resume_cmdid = WMI_PDEV_RESUME_CMDID,
 111	.add_bcn_filter_cmdid = WMI_ADD_BCN_FILTER_CMDID,
 112	.rmv_bcn_filter_cmdid = WMI_RMV_BCN_FILTER_CMDID,
 113	.wow_add_wake_pattern_cmdid = WMI_WOW_ADD_WAKE_PATTERN_CMDID,
 114	.wow_del_wake_pattern_cmdid = WMI_WOW_DEL_WAKE_PATTERN_CMDID,
 115	.wow_enable_disable_wake_event_cmdid =
 116				WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID,
 117	.wow_enable_cmdid = WMI_WOW_ENABLE_CMDID,
 118	.wow_hostwakeup_from_sleep_cmdid = WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID,
 119	.rtt_measreq_cmdid = WMI_RTT_MEASREQ_CMDID,
 120	.rtt_tsf_cmdid = WMI_RTT_TSF_CMDID,
 121	.vdev_spectral_scan_configure_cmdid =
 122				WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID,
 123	.vdev_spectral_scan_enable_cmdid = WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID,
 124	.request_stats_cmdid = WMI_REQUEST_STATS_CMDID,
 125	.set_arp_ns_offload_cmdid = WMI_SET_ARP_NS_OFFLOAD_CMDID,
 126	.network_list_offload_config_cmdid =
 127				WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID,
 128	.gtk_offload_cmdid = WMI_GTK_OFFLOAD_CMDID,
 129	.csa_offload_enable_cmdid = WMI_CSA_OFFLOAD_ENABLE_CMDID,
 130	.csa_offload_chanswitch_cmdid = WMI_CSA_OFFLOAD_CHANSWITCH_CMDID,
 131	.chatter_set_mode_cmdid = WMI_CHATTER_SET_MODE_CMDID,
 132	.peer_tid_addba_cmdid = WMI_PEER_TID_ADDBA_CMDID,
 133	.peer_tid_delba_cmdid = WMI_PEER_TID_DELBA_CMDID,
 134	.sta_dtim_ps_method_cmdid = WMI_STA_DTIM_PS_METHOD_CMDID,
 135	.sta_uapsd_auto_trig_cmdid = WMI_STA_UAPSD_AUTO_TRIG_CMDID,
 136	.sta_keepalive_cmd = WMI_STA_KEEPALIVE_CMD,
 137	.echo_cmdid = WMI_ECHO_CMDID,
 138	.pdev_utf_cmdid = WMI_PDEV_UTF_CMDID,
 139	.dbglog_cfg_cmdid = WMI_DBGLOG_CFG_CMDID,
 140	.pdev_qvit_cmdid = WMI_PDEV_QVIT_CMDID,
 141	.pdev_ftm_intg_cmdid = WMI_PDEV_FTM_INTG_CMDID,
 142	.vdev_set_keepalive_cmdid = WMI_VDEV_SET_KEEPALIVE_CMDID,
 143	.vdev_get_keepalive_cmdid = WMI_VDEV_GET_KEEPALIVE_CMDID,
 144	.force_fw_hang_cmdid = WMI_FORCE_FW_HANG_CMDID,
 145	.gpio_config_cmdid = WMI_GPIO_CONFIG_CMDID,
 146	.gpio_output_cmdid = WMI_GPIO_OUTPUT_CMDID,
 147	.pdev_get_temperature_cmdid = WMI_CMD_UNSUPPORTED,
 148	.pdev_enable_adaptive_cca_cmdid = WMI_CMD_UNSUPPORTED,
 149	.scan_update_request_cmdid = WMI_CMD_UNSUPPORTED,
 150	.vdev_standby_response_cmdid = WMI_CMD_UNSUPPORTED,
 151	.vdev_resume_response_cmdid = WMI_CMD_UNSUPPORTED,
 152	.wlan_peer_caching_add_peer_cmdid = WMI_CMD_UNSUPPORTED,
 153	.wlan_peer_caching_evict_peer_cmdid = WMI_CMD_UNSUPPORTED,
 154	.wlan_peer_caching_restore_peer_cmdid = WMI_CMD_UNSUPPORTED,
 155	.wlan_peer_caching_print_all_peers_info_cmdid = WMI_CMD_UNSUPPORTED,
 156	.peer_update_wds_entry_cmdid = WMI_CMD_UNSUPPORTED,
 157	.peer_add_proxy_sta_entry_cmdid = WMI_CMD_UNSUPPORTED,
 158	.rtt_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 159	.oem_req_cmdid = WMI_CMD_UNSUPPORTED,
 160	.nan_cmdid = WMI_CMD_UNSUPPORTED,
 161	.vdev_ratemask_cmdid = WMI_CMD_UNSUPPORTED,
 162	.qboost_cfg_cmdid = WMI_CMD_UNSUPPORTED,
 163	.pdev_smart_ant_enable_cmdid = WMI_CMD_UNSUPPORTED,
 164	.pdev_smart_ant_set_rx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 165	.peer_smart_ant_set_tx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 166	.peer_smart_ant_set_train_info_cmdid = WMI_CMD_UNSUPPORTED,
 167	.peer_smart_ant_set_node_config_ops_cmdid = WMI_CMD_UNSUPPORTED,
 168	.pdev_set_antenna_switch_table_cmdid = WMI_CMD_UNSUPPORTED,
 169	.pdev_set_ctl_table_cmdid = WMI_CMD_UNSUPPORTED,
 170	.pdev_set_mimogain_table_cmdid = WMI_CMD_UNSUPPORTED,
 171	.pdev_ratepwr_table_cmdid = WMI_CMD_UNSUPPORTED,
 172	.pdev_ratepwr_chainmsk_table_cmdid = WMI_CMD_UNSUPPORTED,
 173	.pdev_fips_cmdid = WMI_CMD_UNSUPPORTED,
 174	.tt_set_conf_cmdid = WMI_CMD_UNSUPPORTED,
 175	.fwtest_cmdid = WMI_CMD_UNSUPPORTED,
 176	.vdev_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 177	.peer_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 178	.pdev_get_ani_cck_config_cmdid = WMI_CMD_UNSUPPORTED,
 179	.pdev_get_ani_ofdm_config_cmdid = WMI_CMD_UNSUPPORTED,
 180	.pdev_reserve_ast_entry_cmdid = WMI_CMD_UNSUPPORTED,
 181	.pdev_get_nfcal_power_cmdid = WMI_CMD_UNSUPPORTED,
 182	.pdev_get_tpc_cmdid = WMI_CMD_UNSUPPORTED,
 183	.pdev_get_ast_info_cmdid = WMI_CMD_UNSUPPORTED,
 184	.vdev_set_dscp_tid_map_cmdid = WMI_CMD_UNSUPPORTED,
 185	.pdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 186	.vdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 187	.vdev_filter_neighbor_rx_packets_cmdid = WMI_CMD_UNSUPPORTED,
 188	.mu_cal_start_cmdid = WMI_CMD_UNSUPPORTED,
 189	.set_cca_params_cmdid = WMI_CMD_UNSUPPORTED,
 190	.pdev_bss_chan_info_request_cmdid = WMI_CMD_UNSUPPORTED,
 191	.pdev_get_tpc_table_cmdid = WMI_CMD_UNSUPPORTED,
 192	.radar_found_cmdid = WMI_CMD_UNSUPPORTED,
 193};
 194
 195/* 10.X WMI cmd track */
 196static struct wmi_cmd_map wmi_10x_cmd_map = {
 197	.init_cmdid = WMI_10X_INIT_CMDID,
 198	.start_scan_cmdid = WMI_10X_START_SCAN_CMDID,
 199	.stop_scan_cmdid = WMI_10X_STOP_SCAN_CMDID,
 200	.scan_chan_list_cmdid = WMI_10X_SCAN_CHAN_LIST_CMDID,
 201	.scan_sch_prio_tbl_cmdid = WMI_CMD_UNSUPPORTED,
 202	.scan_prob_req_oui_cmdid = WMI_CMD_UNSUPPORTED,
 203	.pdev_set_regdomain_cmdid = WMI_10X_PDEV_SET_REGDOMAIN_CMDID,
 204	.pdev_set_channel_cmdid = WMI_10X_PDEV_SET_CHANNEL_CMDID,
 205	.pdev_set_param_cmdid = WMI_10X_PDEV_SET_PARAM_CMDID,
 206	.pdev_pktlog_enable_cmdid = WMI_10X_PDEV_PKTLOG_ENABLE_CMDID,
 207	.pdev_pktlog_disable_cmdid = WMI_10X_PDEV_PKTLOG_DISABLE_CMDID,
 208	.pdev_set_wmm_params_cmdid = WMI_10X_PDEV_SET_WMM_PARAMS_CMDID,
 209	.pdev_set_ht_cap_ie_cmdid = WMI_10X_PDEV_SET_HT_CAP_IE_CMDID,
 210	.pdev_set_vht_cap_ie_cmdid = WMI_10X_PDEV_SET_VHT_CAP_IE_CMDID,
 211	.pdev_set_dscp_tid_map_cmdid = WMI_10X_PDEV_SET_DSCP_TID_MAP_CMDID,
 212	.pdev_set_quiet_mode_cmdid = WMI_10X_PDEV_SET_QUIET_MODE_CMDID,
 213	.pdev_green_ap_ps_enable_cmdid = WMI_10X_PDEV_GREEN_AP_PS_ENABLE_CMDID,
 214	.pdev_get_tpc_config_cmdid = WMI_10X_PDEV_GET_TPC_CONFIG_CMDID,
 215	.pdev_set_base_macaddr_cmdid = WMI_10X_PDEV_SET_BASE_MACADDR_CMDID,
 216	.vdev_create_cmdid = WMI_10X_VDEV_CREATE_CMDID,
 217	.vdev_delete_cmdid = WMI_10X_VDEV_DELETE_CMDID,
 218	.vdev_start_request_cmdid = WMI_10X_VDEV_START_REQUEST_CMDID,
 219	.vdev_restart_request_cmdid = WMI_10X_VDEV_RESTART_REQUEST_CMDID,
 220	.vdev_up_cmdid = WMI_10X_VDEV_UP_CMDID,
 221	.vdev_stop_cmdid = WMI_10X_VDEV_STOP_CMDID,
 222	.vdev_down_cmdid = WMI_10X_VDEV_DOWN_CMDID,
 223	.vdev_set_param_cmdid = WMI_10X_VDEV_SET_PARAM_CMDID,
 224	.vdev_install_key_cmdid = WMI_10X_VDEV_INSTALL_KEY_CMDID,
 225	.peer_create_cmdid = WMI_10X_PEER_CREATE_CMDID,
 226	.peer_delete_cmdid = WMI_10X_PEER_DELETE_CMDID,
 227	.peer_flush_tids_cmdid = WMI_10X_PEER_FLUSH_TIDS_CMDID,
 228	.peer_set_param_cmdid = WMI_10X_PEER_SET_PARAM_CMDID,
 229	.peer_assoc_cmdid = WMI_10X_PEER_ASSOC_CMDID,
 230	.peer_add_wds_entry_cmdid = WMI_10X_PEER_ADD_WDS_ENTRY_CMDID,
 231	.peer_remove_wds_entry_cmdid = WMI_10X_PEER_REMOVE_WDS_ENTRY_CMDID,
 232	.peer_mcast_group_cmdid = WMI_10X_PEER_MCAST_GROUP_CMDID,
 233	.bcn_tx_cmdid = WMI_10X_BCN_TX_CMDID,
 234	.pdev_send_bcn_cmdid = WMI_10X_PDEV_SEND_BCN_CMDID,
 235	.bcn_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
 236	.bcn_filter_rx_cmdid = WMI_10X_BCN_FILTER_RX_CMDID,
 237	.prb_req_filter_rx_cmdid = WMI_10X_PRB_REQ_FILTER_RX_CMDID,
 238	.mgmt_tx_cmdid = WMI_10X_MGMT_TX_CMDID,
 239	.prb_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
 240	.addba_clear_resp_cmdid = WMI_10X_ADDBA_CLEAR_RESP_CMDID,
 241	.addba_send_cmdid = WMI_10X_ADDBA_SEND_CMDID,
 242	.addba_status_cmdid = WMI_10X_ADDBA_STATUS_CMDID,
 243	.delba_send_cmdid = WMI_10X_DELBA_SEND_CMDID,
 244	.addba_set_resp_cmdid = WMI_10X_ADDBA_SET_RESP_CMDID,
 245	.send_singleamsdu_cmdid = WMI_10X_SEND_SINGLEAMSDU_CMDID,
 246	.sta_powersave_mode_cmdid = WMI_10X_STA_POWERSAVE_MODE_CMDID,
 247	.sta_powersave_param_cmdid = WMI_10X_STA_POWERSAVE_PARAM_CMDID,
 248	.sta_mimo_ps_mode_cmdid = WMI_10X_STA_MIMO_PS_MODE_CMDID,
 249	.pdev_dfs_enable_cmdid = WMI_10X_PDEV_DFS_ENABLE_CMDID,
 250	.pdev_dfs_disable_cmdid = WMI_10X_PDEV_DFS_DISABLE_CMDID,
 251	.roam_scan_mode = WMI_10X_ROAM_SCAN_MODE,
 252	.roam_scan_rssi_threshold = WMI_10X_ROAM_SCAN_RSSI_THRESHOLD,
 253	.roam_scan_period = WMI_10X_ROAM_SCAN_PERIOD,
 254	.roam_scan_rssi_change_threshold =
 255				WMI_10X_ROAM_SCAN_RSSI_CHANGE_THRESHOLD,
 256	.roam_ap_profile = WMI_10X_ROAM_AP_PROFILE,
 257	.ofl_scan_add_ap_profile = WMI_10X_OFL_SCAN_ADD_AP_PROFILE,
 258	.ofl_scan_remove_ap_profile = WMI_10X_OFL_SCAN_REMOVE_AP_PROFILE,
 259	.ofl_scan_period = WMI_10X_OFL_SCAN_PERIOD,
 260	.p2p_dev_set_device_info = WMI_10X_P2P_DEV_SET_DEVICE_INFO,
 261	.p2p_dev_set_discoverability = WMI_10X_P2P_DEV_SET_DISCOVERABILITY,
 262	.p2p_go_set_beacon_ie = WMI_10X_P2P_GO_SET_BEACON_IE,
 263	.p2p_go_set_probe_resp_ie = WMI_10X_P2P_GO_SET_PROBE_RESP_IE,
 264	.p2p_set_vendor_ie_data_cmdid = WMI_CMD_UNSUPPORTED,
 265	.ap_ps_peer_param_cmdid = WMI_10X_AP_PS_PEER_PARAM_CMDID,
 266	.ap_ps_peer_uapsd_coex_cmdid = WMI_CMD_UNSUPPORTED,
 267	.peer_rate_retry_sched_cmdid = WMI_10X_PEER_RATE_RETRY_SCHED_CMDID,
 268	.wlan_profile_trigger_cmdid = WMI_10X_WLAN_PROFILE_TRIGGER_CMDID,
 269	.wlan_profile_set_hist_intvl_cmdid =
 270				WMI_10X_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
 271	.wlan_profile_get_profile_data_cmdid =
 272				WMI_10X_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
 273	.wlan_profile_enable_profile_id_cmdid =
 274				WMI_10X_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
 275	.wlan_profile_list_profile_id_cmdid =
 276				WMI_10X_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
 277	.pdev_suspend_cmdid = WMI_10X_PDEV_SUSPEND_CMDID,
 278	.pdev_resume_cmdid = WMI_10X_PDEV_RESUME_CMDID,
 279	.add_bcn_filter_cmdid = WMI_10X_ADD_BCN_FILTER_CMDID,
 280	.rmv_bcn_filter_cmdid = WMI_10X_RMV_BCN_FILTER_CMDID,
 281	.wow_add_wake_pattern_cmdid = WMI_10X_WOW_ADD_WAKE_PATTERN_CMDID,
 282	.wow_del_wake_pattern_cmdid = WMI_10X_WOW_DEL_WAKE_PATTERN_CMDID,
 283	.wow_enable_disable_wake_event_cmdid =
 284				WMI_10X_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID,
 285	.wow_enable_cmdid = WMI_10X_WOW_ENABLE_CMDID,
 286	.wow_hostwakeup_from_sleep_cmdid =
 287				WMI_10X_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID,
 288	.rtt_measreq_cmdid = WMI_10X_RTT_MEASREQ_CMDID,
 289	.rtt_tsf_cmdid = WMI_10X_RTT_TSF_CMDID,
 290	.vdev_spectral_scan_configure_cmdid =
 291				WMI_10X_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID,
 292	.vdev_spectral_scan_enable_cmdid =
 293				WMI_10X_VDEV_SPECTRAL_SCAN_ENABLE_CMDID,
 294	.request_stats_cmdid = WMI_10X_REQUEST_STATS_CMDID,
 295	.set_arp_ns_offload_cmdid = WMI_CMD_UNSUPPORTED,
 296	.network_list_offload_config_cmdid = WMI_CMD_UNSUPPORTED,
 297	.gtk_offload_cmdid = WMI_CMD_UNSUPPORTED,
 298	.csa_offload_enable_cmdid = WMI_CMD_UNSUPPORTED,
 299	.csa_offload_chanswitch_cmdid = WMI_CMD_UNSUPPORTED,
 300	.chatter_set_mode_cmdid = WMI_CMD_UNSUPPORTED,
 301	.peer_tid_addba_cmdid = WMI_CMD_UNSUPPORTED,
 302	.peer_tid_delba_cmdid = WMI_CMD_UNSUPPORTED,
 303	.sta_dtim_ps_method_cmdid = WMI_CMD_UNSUPPORTED,
 304	.sta_uapsd_auto_trig_cmdid = WMI_CMD_UNSUPPORTED,
 305	.sta_keepalive_cmd = WMI_CMD_UNSUPPORTED,
 306	.echo_cmdid = WMI_10X_ECHO_CMDID,
 307	.pdev_utf_cmdid = WMI_10X_PDEV_UTF_CMDID,
 308	.dbglog_cfg_cmdid = WMI_10X_DBGLOG_CFG_CMDID,
 309	.pdev_qvit_cmdid = WMI_10X_PDEV_QVIT_CMDID,
 310	.pdev_ftm_intg_cmdid = WMI_CMD_UNSUPPORTED,
 311	.vdev_set_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 312	.vdev_get_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 313	.force_fw_hang_cmdid = WMI_CMD_UNSUPPORTED,
 314	.gpio_config_cmdid = WMI_10X_GPIO_CONFIG_CMDID,
 315	.gpio_output_cmdid = WMI_10X_GPIO_OUTPUT_CMDID,
 316	.pdev_get_temperature_cmdid = WMI_CMD_UNSUPPORTED,
 317	.pdev_enable_adaptive_cca_cmdid = WMI_CMD_UNSUPPORTED,
 318	.scan_update_request_cmdid = WMI_CMD_UNSUPPORTED,
 319	.vdev_standby_response_cmdid = WMI_CMD_UNSUPPORTED,
 320	.vdev_resume_response_cmdid = WMI_CMD_UNSUPPORTED,
 321	.wlan_peer_caching_add_peer_cmdid = WMI_CMD_UNSUPPORTED,
 322	.wlan_peer_caching_evict_peer_cmdid = WMI_CMD_UNSUPPORTED,
 323	.wlan_peer_caching_restore_peer_cmdid = WMI_CMD_UNSUPPORTED,
 324	.wlan_peer_caching_print_all_peers_info_cmdid = WMI_CMD_UNSUPPORTED,
 325	.peer_update_wds_entry_cmdid = WMI_CMD_UNSUPPORTED,
 326	.peer_add_proxy_sta_entry_cmdid = WMI_CMD_UNSUPPORTED,
 327	.rtt_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 328	.oem_req_cmdid = WMI_CMD_UNSUPPORTED,
 329	.nan_cmdid = WMI_CMD_UNSUPPORTED,
 330	.vdev_ratemask_cmdid = WMI_CMD_UNSUPPORTED,
 331	.qboost_cfg_cmdid = WMI_CMD_UNSUPPORTED,
 332	.pdev_smart_ant_enable_cmdid = WMI_CMD_UNSUPPORTED,
 333	.pdev_smart_ant_set_rx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 334	.peer_smart_ant_set_tx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 335	.peer_smart_ant_set_train_info_cmdid = WMI_CMD_UNSUPPORTED,
 336	.peer_smart_ant_set_node_config_ops_cmdid = WMI_CMD_UNSUPPORTED,
 337	.pdev_set_antenna_switch_table_cmdid = WMI_CMD_UNSUPPORTED,
 338	.pdev_set_ctl_table_cmdid = WMI_CMD_UNSUPPORTED,
 339	.pdev_set_mimogain_table_cmdid = WMI_CMD_UNSUPPORTED,
 340	.pdev_ratepwr_table_cmdid = WMI_CMD_UNSUPPORTED,
 341	.pdev_ratepwr_chainmsk_table_cmdid = WMI_CMD_UNSUPPORTED,
 342	.pdev_fips_cmdid = WMI_CMD_UNSUPPORTED,
 343	.tt_set_conf_cmdid = WMI_CMD_UNSUPPORTED,
 344	.fwtest_cmdid = WMI_CMD_UNSUPPORTED,
 345	.vdev_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 346	.peer_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 347	.pdev_get_ani_cck_config_cmdid = WMI_CMD_UNSUPPORTED,
 348	.pdev_get_ani_ofdm_config_cmdid = WMI_CMD_UNSUPPORTED,
 349	.pdev_reserve_ast_entry_cmdid = WMI_CMD_UNSUPPORTED,
 350	.pdev_get_nfcal_power_cmdid = WMI_CMD_UNSUPPORTED,
 351	.pdev_get_tpc_cmdid = WMI_CMD_UNSUPPORTED,
 352	.pdev_get_ast_info_cmdid = WMI_CMD_UNSUPPORTED,
 353	.vdev_set_dscp_tid_map_cmdid = WMI_CMD_UNSUPPORTED,
 354	.pdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 355	.vdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 356	.vdev_filter_neighbor_rx_packets_cmdid = WMI_CMD_UNSUPPORTED,
 357	.mu_cal_start_cmdid = WMI_CMD_UNSUPPORTED,
 358	.set_cca_params_cmdid = WMI_CMD_UNSUPPORTED,
 359	.pdev_bss_chan_info_request_cmdid = WMI_CMD_UNSUPPORTED,
 360	.pdev_get_tpc_table_cmdid = WMI_CMD_UNSUPPORTED,
 361	.radar_found_cmdid = WMI_CMD_UNSUPPORTED,
 362};
 363
 364/* 10.2.4 WMI cmd track */
 365static struct wmi_cmd_map wmi_10_2_4_cmd_map = {
 366	.init_cmdid = WMI_10_2_INIT_CMDID,
 367	.start_scan_cmdid = WMI_10_2_START_SCAN_CMDID,
 368	.stop_scan_cmdid = WMI_10_2_STOP_SCAN_CMDID,
 369	.scan_chan_list_cmdid = WMI_10_2_SCAN_CHAN_LIST_CMDID,
 370	.scan_sch_prio_tbl_cmdid = WMI_CMD_UNSUPPORTED,
 371	.scan_prob_req_oui_cmdid = WMI_CMD_UNSUPPORTED,
 372	.pdev_set_regdomain_cmdid = WMI_10_2_PDEV_SET_REGDOMAIN_CMDID,
 373	.pdev_set_channel_cmdid = WMI_10_2_PDEV_SET_CHANNEL_CMDID,
 374	.pdev_set_param_cmdid = WMI_10_2_PDEV_SET_PARAM_CMDID,
 375	.pdev_pktlog_enable_cmdid = WMI_10_2_PDEV_PKTLOG_ENABLE_CMDID,
 376	.pdev_pktlog_disable_cmdid = WMI_10_2_PDEV_PKTLOG_DISABLE_CMDID,
 377	.pdev_set_wmm_params_cmdid = WMI_10_2_PDEV_SET_WMM_PARAMS_CMDID,
 378	.pdev_set_ht_cap_ie_cmdid = WMI_10_2_PDEV_SET_HT_CAP_IE_CMDID,
 379	.pdev_set_vht_cap_ie_cmdid = WMI_10_2_PDEV_SET_VHT_CAP_IE_CMDID,
 380	.pdev_set_quiet_mode_cmdid = WMI_10_2_PDEV_SET_QUIET_MODE_CMDID,
 381	.pdev_green_ap_ps_enable_cmdid = WMI_10_2_PDEV_GREEN_AP_PS_ENABLE_CMDID,
 382	.pdev_get_tpc_config_cmdid = WMI_10_2_PDEV_GET_TPC_CONFIG_CMDID,
 383	.pdev_set_base_macaddr_cmdid = WMI_10_2_PDEV_SET_BASE_MACADDR_CMDID,
 384	.vdev_create_cmdid = WMI_10_2_VDEV_CREATE_CMDID,
 385	.vdev_delete_cmdid = WMI_10_2_VDEV_DELETE_CMDID,
 386	.vdev_start_request_cmdid = WMI_10_2_VDEV_START_REQUEST_CMDID,
 387	.vdev_restart_request_cmdid = WMI_10_2_VDEV_RESTART_REQUEST_CMDID,
 388	.vdev_up_cmdid = WMI_10_2_VDEV_UP_CMDID,
 389	.vdev_stop_cmdid = WMI_10_2_VDEV_STOP_CMDID,
 390	.vdev_down_cmdid = WMI_10_2_VDEV_DOWN_CMDID,
 391	.vdev_set_param_cmdid = WMI_10_2_VDEV_SET_PARAM_CMDID,
 392	.vdev_install_key_cmdid = WMI_10_2_VDEV_INSTALL_KEY_CMDID,
 393	.peer_create_cmdid = WMI_10_2_PEER_CREATE_CMDID,
 394	.peer_delete_cmdid = WMI_10_2_PEER_DELETE_CMDID,
 395	.peer_flush_tids_cmdid = WMI_10_2_PEER_FLUSH_TIDS_CMDID,
 396	.peer_set_param_cmdid = WMI_10_2_PEER_SET_PARAM_CMDID,
 397	.peer_assoc_cmdid = WMI_10_2_PEER_ASSOC_CMDID,
 398	.peer_add_wds_entry_cmdid = WMI_10_2_PEER_ADD_WDS_ENTRY_CMDID,
 399	.peer_remove_wds_entry_cmdid = WMI_10_2_PEER_REMOVE_WDS_ENTRY_CMDID,
 400	.peer_mcast_group_cmdid = WMI_10_2_PEER_MCAST_GROUP_CMDID,
 401	.bcn_tx_cmdid = WMI_10_2_BCN_TX_CMDID,
 402	.pdev_send_bcn_cmdid = WMI_10_2_PDEV_SEND_BCN_CMDID,
 403	.bcn_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
 404	.bcn_filter_rx_cmdid = WMI_10_2_BCN_FILTER_RX_CMDID,
 405	.prb_req_filter_rx_cmdid = WMI_10_2_PRB_REQ_FILTER_RX_CMDID,
 406	.mgmt_tx_cmdid = WMI_10_2_MGMT_TX_CMDID,
 407	.prb_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
 408	.addba_clear_resp_cmdid = WMI_10_2_ADDBA_CLEAR_RESP_CMDID,
 409	.addba_send_cmdid = WMI_10_2_ADDBA_SEND_CMDID,
 410	.addba_status_cmdid = WMI_10_2_ADDBA_STATUS_CMDID,
 411	.delba_send_cmdid = WMI_10_2_DELBA_SEND_CMDID,
 412	.addba_set_resp_cmdid = WMI_10_2_ADDBA_SET_RESP_CMDID,
 413	.send_singleamsdu_cmdid = WMI_10_2_SEND_SINGLEAMSDU_CMDID,
 414	.sta_powersave_mode_cmdid = WMI_10_2_STA_POWERSAVE_MODE_CMDID,
 415	.sta_powersave_param_cmdid = WMI_10_2_STA_POWERSAVE_PARAM_CMDID,
 416	.sta_mimo_ps_mode_cmdid = WMI_10_2_STA_MIMO_PS_MODE_CMDID,
 417	.pdev_dfs_enable_cmdid = WMI_10_2_PDEV_DFS_ENABLE_CMDID,
 418	.pdev_dfs_disable_cmdid = WMI_10_2_PDEV_DFS_DISABLE_CMDID,
 419	.roam_scan_mode = WMI_10_2_ROAM_SCAN_MODE,
 420	.roam_scan_rssi_threshold = WMI_10_2_ROAM_SCAN_RSSI_THRESHOLD,
 421	.roam_scan_period = WMI_10_2_ROAM_SCAN_PERIOD,
 422	.roam_scan_rssi_change_threshold =
 423				WMI_10_2_ROAM_SCAN_RSSI_CHANGE_THRESHOLD,
 424	.roam_ap_profile = WMI_10_2_ROAM_AP_PROFILE,
 425	.ofl_scan_add_ap_profile = WMI_10_2_OFL_SCAN_ADD_AP_PROFILE,
 426	.ofl_scan_remove_ap_profile = WMI_10_2_OFL_SCAN_REMOVE_AP_PROFILE,
 427	.ofl_scan_period = WMI_10_2_OFL_SCAN_PERIOD,
 428	.p2p_dev_set_device_info = WMI_10_2_P2P_DEV_SET_DEVICE_INFO,
 429	.p2p_dev_set_discoverability = WMI_10_2_P2P_DEV_SET_DISCOVERABILITY,
 430	.p2p_go_set_beacon_ie = WMI_10_2_P2P_GO_SET_BEACON_IE,
 431	.p2p_go_set_probe_resp_ie = WMI_10_2_P2P_GO_SET_PROBE_RESP_IE,
 432	.p2p_set_vendor_ie_data_cmdid = WMI_CMD_UNSUPPORTED,
 433	.ap_ps_peer_param_cmdid = WMI_10_2_AP_PS_PEER_PARAM_CMDID,
 434	.ap_ps_peer_uapsd_coex_cmdid = WMI_CMD_UNSUPPORTED,
 435	.peer_rate_retry_sched_cmdid = WMI_10_2_PEER_RATE_RETRY_SCHED_CMDID,
 436	.wlan_profile_trigger_cmdid = WMI_10_2_WLAN_PROFILE_TRIGGER_CMDID,
 437	.wlan_profile_set_hist_intvl_cmdid =
 438				WMI_10_2_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
 439	.wlan_profile_get_profile_data_cmdid =
 440				WMI_10_2_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
 441	.wlan_profile_enable_profile_id_cmdid =
 442				WMI_10_2_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
 443	.wlan_profile_list_profile_id_cmdid =
 444				WMI_10_2_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
 445	.pdev_suspend_cmdid = WMI_10_2_PDEV_SUSPEND_CMDID,
 446	.pdev_resume_cmdid = WMI_10_2_PDEV_RESUME_CMDID,
 447	.add_bcn_filter_cmdid = WMI_10_2_ADD_BCN_FILTER_CMDID,
 448	.rmv_bcn_filter_cmdid = WMI_10_2_RMV_BCN_FILTER_CMDID,
 449	.wow_add_wake_pattern_cmdid = WMI_10_2_WOW_ADD_WAKE_PATTERN_CMDID,
 450	.wow_del_wake_pattern_cmdid = WMI_10_2_WOW_DEL_WAKE_PATTERN_CMDID,
 451	.wow_enable_disable_wake_event_cmdid =
 452				WMI_10_2_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID,
 453	.wow_enable_cmdid = WMI_10_2_WOW_ENABLE_CMDID,
 454	.wow_hostwakeup_from_sleep_cmdid =
 455				WMI_10_2_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID,
 456	.rtt_measreq_cmdid = WMI_10_2_RTT_MEASREQ_CMDID,
 457	.rtt_tsf_cmdid = WMI_10_2_RTT_TSF_CMDID,
 458	.vdev_spectral_scan_configure_cmdid =
 459				WMI_10_2_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID,
 460	.vdev_spectral_scan_enable_cmdid =
 461				WMI_10_2_VDEV_SPECTRAL_SCAN_ENABLE_CMDID,
 462	.request_stats_cmdid = WMI_10_2_REQUEST_STATS_CMDID,
 463	.set_arp_ns_offload_cmdid = WMI_CMD_UNSUPPORTED,
 464	.network_list_offload_config_cmdid = WMI_CMD_UNSUPPORTED,
 465	.gtk_offload_cmdid = WMI_CMD_UNSUPPORTED,
 466	.csa_offload_enable_cmdid = WMI_CMD_UNSUPPORTED,
 467	.csa_offload_chanswitch_cmdid = WMI_CMD_UNSUPPORTED,
 468	.chatter_set_mode_cmdid = WMI_CMD_UNSUPPORTED,
 469	.peer_tid_addba_cmdid = WMI_CMD_UNSUPPORTED,
 470	.peer_tid_delba_cmdid = WMI_CMD_UNSUPPORTED,
 471	.sta_dtim_ps_method_cmdid = WMI_CMD_UNSUPPORTED,
 472	.sta_uapsd_auto_trig_cmdid = WMI_CMD_UNSUPPORTED,
 473	.sta_keepalive_cmd = WMI_CMD_UNSUPPORTED,
 474	.echo_cmdid = WMI_10_2_ECHO_CMDID,
 475	.pdev_utf_cmdid = WMI_10_2_PDEV_UTF_CMDID,
 476	.dbglog_cfg_cmdid = WMI_10_2_DBGLOG_CFG_CMDID,
 477	.pdev_qvit_cmdid = WMI_10_2_PDEV_QVIT_CMDID,
 478	.pdev_ftm_intg_cmdid = WMI_CMD_UNSUPPORTED,
 479	.vdev_set_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 480	.vdev_get_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 481	.force_fw_hang_cmdid = WMI_CMD_UNSUPPORTED,
 482	.gpio_config_cmdid = WMI_10_2_GPIO_CONFIG_CMDID,
 483	.gpio_output_cmdid = WMI_10_2_GPIO_OUTPUT_CMDID,
 484	.pdev_get_temperature_cmdid = WMI_10_2_PDEV_GET_TEMPERATURE_CMDID,
 485	.pdev_enable_adaptive_cca_cmdid = WMI_10_2_SET_CCA_PARAMS,
 486	.scan_update_request_cmdid = WMI_CMD_UNSUPPORTED,
 487	.vdev_standby_response_cmdid = WMI_CMD_UNSUPPORTED,
 488	.vdev_resume_response_cmdid = WMI_CMD_UNSUPPORTED,
 489	.wlan_peer_caching_add_peer_cmdid = WMI_CMD_UNSUPPORTED,
 490	.wlan_peer_caching_evict_peer_cmdid = WMI_CMD_UNSUPPORTED,
 491	.wlan_peer_caching_restore_peer_cmdid = WMI_CMD_UNSUPPORTED,
 492	.wlan_peer_caching_print_all_peers_info_cmdid = WMI_CMD_UNSUPPORTED,
 493	.peer_update_wds_entry_cmdid = WMI_CMD_UNSUPPORTED,
 494	.peer_add_proxy_sta_entry_cmdid = WMI_CMD_UNSUPPORTED,
 495	.rtt_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
 496	.oem_req_cmdid = WMI_CMD_UNSUPPORTED,
 497	.nan_cmdid = WMI_CMD_UNSUPPORTED,
 498	.vdev_ratemask_cmdid = WMI_CMD_UNSUPPORTED,
 499	.qboost_cfg_cmdid = WMI_CMD_UNSUPPORTED,
 500	.pdev_smart_ant_enable_cmdid = WMI_CMD_UNSUPPORTED,
 501	.pdev_smart_ant_set_rx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 502	.peer_smart_ant_set_tx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
 503	.peer_smart_ant_set_train_info_cmdid = WMI_CMD_UNSUPPORTED,
 504	.peer_smart_ant_set_node_config_ops_cmdid = WMI_CMD_UNSUPPORTED,
 505	.pdev_set_antenna_switch_table_cmdid = WMI_CMD_UNSUPPORTED,
 506	.pdev_set_ctl_table_cmdid = WMI_CMD_UNSUPPORTED,
 507	.pdev_set_mimogain_table_cmdid = WMI_CMD_UNSUPPORTED,
 508	.pdev_ratepwr_table_cmdid = WMI_CMD_UNSUPPORTED,
 509	.pdev_ratepwr_chainmsk_table_cmdid = WMI_CMD_UNSUPPORTED,
 510	.pdev_fips_cmdid = WMI_CMD_UNSUPPORTED,
 511	.tt_set_conf_cmdid = WMI_CMD_UNSUPPORTED,
 512	.fwtest_cmdid = WMI_CMD_UNSUPPORTED,
 513	.vdev_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 514	.peer_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
 515	.pdev_get_ani_cck_config_cmdid = WMI_CMD_UNSUPPORTED,
 516	.pdev_get_ani_ofdm_config_cmdid = WMI_CMD_UNSUPPORTED,
 517	.pdev_reserve_ast_entry_cmdid = WMI_CMD_UNSUPPORTED,
 518	.pdev_get_nfcal_power_cmdid = WMI_CMD_UNSUPPORTED,
 519	.pdev_get_tpc_cmdid = WMI_CMD_UNSUPPORTED,
 520	.pdev_get_ast_info_cmdid = WMI_CMD_UNSUPPORTED,
 521	.vdev_set_dscp_tid_map_cmdid = WMI_CMD_UNSUPPORTED,
 522	.pdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 523	.vdev_get_info_cmdid = WMI_CMD_UNSUPPORTED,
 524	.vdev_filter_neighbor_rx_packets_cmdid = WMI_CMD_UNSUPPORTED,
 525	.mu_cal_start_cmdid = WMI_CMD_UNSUPPORTED,
 526	.set_cca_params_cmdid = WMI_CMD_UNSUPPORTED,
 527	.pdev_bss_chan_info_request_cmdid =
 528		WMI_10_2_PDEV_BSS_CHAN_INFO_REQUEST_CMDID,
 529	.pdev_get_tpc_table_cmdid = WMI_CMD_UNSUPPORTED,
 530	.radar_found_cmdid = WMI_CMD_UNSUPPORTED,
 531	.set_bb_timing_cmdid = WMI_10_2_PDEV_SET_BB_TIMING_CONFIG_CMDID,
 532};
 533
 534/* 10.4 WMI cmd track */
 535static struct wmi_cmd_map wmi_10_4_cmd_map = {
 536	.init_cmdid = WMI_10_4_INIT_CMDID,
 537	.start_scan_cmdid = WMI_10_4_START_SCAN_CMDID,
 538	.stop_scan_cmdid = WMI_10_4_STOP_SCAN_CMDID,
 539	.scan_chan_list_cmdid = WMI_10_4_SCAN_CHAN_LIST_CMDID,
 540	.scan_sch_prio_tbl_cmdid = WMI_10_4_SCAN_SCH_PRIO_TBL_CMDID,
 541	.scan_prob_req_oui_cmdid = WMI_CMD_UNSUPPORTED,
 542	.pdev_set_regdomain_cmdid = WMI_10_4_PDEV_SET_REGDOMAIN_CMDID,
 543	.pdev_set_channel_cmdid = WMI_10_4_PDEV_SET_CHANNEL_CMDID,
 544	.pdev_set_param_cmdid = WMI_10_4_PDEV_SET_PARAM_CMDID,
 545	.pdev_pktlog_enable_cmdid = WMI_10_4_PDEV_PKTLOG_ENABLE_CMDID,
 546	.pdev_pktlog_disable_cmdid = WMI_10_4_PDEV_PKTLOG_DISABLE_CMDID,
 547	.pdev_set_wmm_params_cmdid = WMI_10_4_PDEV_SET_WMM_PARAMS_CMDID,
 548	.pdev_set_ht_cap_ie_cmdid = WMI_10_4_PDEV_SET_HT_CAP_IE_CMDID,
 549	.pdev_set_vht_cap_ie_cmdid = WMI_10_4_PDEV_SET_VHT_CAP_IE_CMDID,
 550	.pdev_set_dscp_tid_map_cmdid = WMI_10_4_PDEV_SET_DSCP_TID_MAP_CMDID,
 551	.pdev_set_quiet_mode_cmdid = WMI_10_4_PDEV_SET_QUIET_MODE_CMDID,
 552	.pdev_green_ap_ps_enable_cmdid = WMI_10_4_PDEV_GREEN_AP_PS_ENABLE_CMDID,
 553	.pdev_get_tpc_config_cmdid = WMI_10_4_PDEV_GET_TPC_CONFIG_CMDID,
 554	.pdev_set_base_macaddr_cmdid = WMI_10_4_PDEV_SET_BASE_MACADDR_CMDID,
 555	.vdev_create_cmdid = WMI_10_4_VDEV_CREATE_CMDID,
 556	.vdev_delete_cmdid = WMI_10_4_VDEV_DELETE_CMDID,
 557	.vdev_start_request_cmdid = WMI_10_4_VDEV_START_REQUEST_CMDID,
 558	.vdev_restart_request_cmdid = WMI_10_4_VDEV_RESTART_REQUEST_CMDID,
 559	.vdev_up_cmdid = WMI_10_4_VDEV_UP_CMDID,
 560	.vdev_stop_cmdid = WMI_10_4_VDEV_STOP_CMDID,
 561	.vdev_down_cmdid = WMI_10_4_VDEV_DOWN_CMDID,
 562	.vdev_set_param_cmdid = WMI_10_4_VDEV_SET_PARAM_CMDID,
 563	.vdev_install_key_cmdid = WMI_10_4_VDEV_INSTALL_KEY_CMDID,
 564	.peer_create_cmdid = WMI_10_4_PEER_CREATE_CMDID,
 565	.peer_delete_cmdid = WMI_10_4_PEER_DELETE_CMDID,
 566	.peer_flush_tids_cmdid = WMI_10_4_PEER_FLUSH_TIDS_CMDID,
 567	.peer_set_param_cmdid = WMI_10_4_PEER_SET_PARAM_CMDID,
 568	.peer_assoc_cmdid = WMI_10_4_PEER_ASSOC_CMDID,
 569	.peer_add_wds_entry_cmdid = WMI_10_4_PEER_ADD_WDS_ENTRY_CMDID,
 570	.peer_remove_wds_entry_cmdid = WMI_10_4_PEER_REMOVE_WDS_ENTRY_CMDID,
 571	.peer_mcast_group_cmdid = WMI_10_4_PEER_MCAST_GROUP_CMDID,
 572	.bcn_tx_cmdid = WMI_10_4_BCN_TX_CMDID,
 573	.pdev_send_bcn_cmdid = WMI_10_4_PDEV_SEND_BCN_CMDID,
 574	.bcn_tmpl_cmdid = WMI_10_4_BCN_PRB_TMPL_CMDID,
 575	.bcn_filter_rx_cmdid = WMI_10_4_BCN_FILTER_RX_CMDID,
 576	.prb_req_filter_rx_cmdid = WMI_10_4_PRB_REQ_FILTER_RX_CMDID,
 577	.mgmt_tx_cmdid = WMI_10_4_MGMT_TX_CMDID,
 578	.prb_tmpl_cmdid = WMI_10_4_PRB_TMPL_CMDID,
 579	.addba_clear_resp_cmdid = WMI_10_4_ADDBA_CLEAR_RESP_CMDID,
 580	.addba_send_cmdid = WMI_10_4_ADDBA_SEND_CMDID,
 581	.addba_status_cmdid = WMI_10_4_ADDBA_STATUS_CMDID,
 582	.delba_send_cmdid = WMI_10_4_DELBA_SEND_CMDID,
 583	.addba_set_resp_cmdid = WMI_10_4_ADDBA_SET_RESP_CMDID,
 584	.send_singleamsdu_cmdid = WMI_10_4_SEND_SINGLEAMSDU_CMDID,
 585	.sta_powersave_mode_cmdid = WMI_10_4_STA_POWERSAVE_MODE_CMDID,
 586	.sta_powersave_param_cmdid = WMI_10_4_STA_POWERSAVE_PARAM_CMDID,
 587	.sta_mimo_ps_mode_cmdid = WMI_10_4_STA_MIMO_PS_MODE_CMDID,
 588	.pdev_dfs_enable_cmdid = WMI_10_4_PDEV_DFS_ENABLE_CMDID,
 589	.pdev_dfs_disable_cmdid = WMI_10_4_PDEV_DFS_DISABLE_CMDID,
 590	.roam_scan_mode = WMI_10_4_ROAM_SCAN_MODE,
 591	.roam_scan_rssi_threshold = WMI_10_4_ROAM_SCAN_RSSI_THRESHOLD,
 592	.roam_scan_period = WMI_10_4_ROAM_SCAN_PERIOD,
 593	.roam_scan_rssi_change_threshold =
 594				WMI_10_4_ROAM_SCAN_RSSI_CHANGE_THRESHOLD,
 595	.roam_ap_profile = WMI_10_4_ROAM_AP_PROFILE,
 596	.ofl_scan_add_ap_profile = WMI_10_4_OFL_SCAN_ADD_AP_PROFILE,
 597	.ofl_scan_remove_ap_profile = WMI_10_4_OFL_SCAN_REMOVE_AP_PROFILE,
 598	.ofl_scan_period = WMI_10_4_OFL_SCAN_PERIOD,
 599	.p2p_dev_set_device_info = WMI_10_4_P2P_DEV_SET_DEVICE_INFO,
 600	.p2p_dev_set_discoverability = WMI_10_4_P2P_DEV_SET_DISCOVERABILITY,
 601	.p2p_go_set_beacon_ie = WMI_10_4_P2P_GO_SET_BEACON_IE,
 602	.p2p_go_set_probe_resp_ie = WMI_10_4_P2P_GO_SET_PROBE_RESP_IE,
 603	.p2p_set_vendor_ie_data_cmdid = WMI_10_4_P2P_SET_VENDOR_IE_DATA_CMDID,
 604	.ap_ps_peer_param_cmdid = WMI_10_4_AP_PS_PEER_PARAM_CMDID,
 605	.ap_ps_peer_uapsd_coex_cmdid = WMI_10_4_AP_PS_PEER_UAPSD_COEX_CMDID,
 606	.peer_rate_retry_sched_cmdid = WMI_10_4_PEER_RATE_RETRY_SCHED_CMDID,
 607	.wlan_profile_trigger_cmdid = WMI_10_4_WLAN_PROFILE_TRIGGER_CMDID,
 608	.wlan_profile_set_hist_intvl_cmdid =
 609				WMI_10_4_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
 610	.wlan_profile_get_profile_data_cmdid =
 611				WMI_10_4_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
 612	.wlan_profile_enable_profile_id_cmdid =
 613				WMI_10_4_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
 614	.wlan_profile_list_profile_id_cmdid =
 615				WMI_10_4_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
 616	.pdev_suspend_cmdid = WMI_10_4_PDEV_SUSPEND_CMDID,
 617	.pdev_resume_cmdid = WMI_10_4_PDEV_RESUME_CMDID,
 618	.add_bcn_filter_cmdid = WMI_10_4_ADD_BCN_FILTER_CMDID,
 619	.rmv_bcn_filter_cmdid = WMI_10_4_RMV_BCN_FILTER_CMDID,
 620	.wow_add_wake_pattern_cmdid = WMI_10_4_WOW_ADD_WAKE_PATTERN_CMDID,
 621	.wow_del_wake_pattern_cmdid = WMI_10_4_WOW_DEL_WAKE_PATTERN_CMDID,
 622	.wow_enable_disable_wake_event_cmdid =
 623				WMI_10_4_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID,
 624	.wow_enable_cmdid = WMI_10_4_WOW_ENABLE_CMDID,
 625	.wow_hostwakeup_from_sleep_cmdid =
 626				WMI_10_4_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID,
 627	.rtt_measreq_cmdid = WMI_10_4_RTT_MEASREQ_CMDID,
 628	.rtt_tsf_cmdid = WMI_10_4_RTT_TSF_CMDID,
 629	.vdev_spectral_scan_configure_cmdid =
 630				WMI_10_4_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID,
 631	.vdev_spectral_scan_enable_cmdid =
 632				WMI_10_4_VDEV_SPECTRAL_SCAN_ENABLE_CMDID,
 633	.request_stats_cmdid = WMI_10_4_REQUEST_STATS_CMDID,
 634	.set_arp_ns_offload_cmdid = WMI_CMD_UNSUPPORTED,
 635	.network_list_offload_config_cmdid = WMI_CMD_UNSUPPORTED,
 636	.gtk_offload_cmdid = WMI_10_4_GTK_OFFLOAD_CMDID,
 637	.csa_offload_enable_cmdid = WMI_10_4_CSA_OFFLOAD_ENABLE_CMDID,
 638	.csa_offload_chanswitch_cmdid = WMI_10_4_CSA_OFFLOAD_CHANSWITCH_CMDID,
 639	.chatter_set_mode_cmdid = WMI_CMD_UNSUPPORTED,
 640	.peer_tid_addba_cmdid = WMI_CMD_UNSUPPORTED,
 641	.peer_tid_delba_cmdid = WMI_CMD_UNSUPPORTED,
 642	.sta_dtim_ps_method_cmdid = WMI_CMD_UNSUPPORTED,
 643	.sta_uapsd_auto_trig_cmdid = WMI_CMD_UNSUPPORTED,
 644	.sta_keepalive_cmd = WMI_CMD_UNSUPPORTED,
 645	.echo_cmdid = WMI_10_4_ECHO_CMDID,
 646	.pdev_utf_cmdid = WMI_10_4_PDEV_UTF_CMDID,
 647	.dbglog_cfg_cmdid = WMI_10_4_DBGLOG_CFG_CMDID,
 648	.pdev_qvit_cmdid = WMI_10_4_PDEV_QVIT_CMDID,
 649	.pdev_ftm_intg_cmdid = WMI_CMD_UNSUPPORTED,
 650	.vdev_set_keepalive_cmdid = WMI_10_4_VDEV_SET_KEEPALIVE_CMDID,
 651	.vdev_get_keepalive_cmdid = WMI_10_4_VDEV_GET_KEEPALIVE_CMDID,
 652	.force_fw_hang_cmdid = WMI_10_4_FORCE_FW_HANG_CMDID,
 653	.gpio_config_cmdid = WMI_10_4_GPIO_CONFIG_CMDID,
 654	.gpio_output_cmdid = WMI_10_4_GPIO_OUTPUT_CMDID,
 655	.pdev_get_temperature_cmdid = WMI_10_4_PDEV_GET_TEMPERATURE_CMDID,
 656	.vdev_set_wmm_params_cmdid = WMI_CMD_UNSUPPORTED,
 657	.adaptive_qcs_cmdid = WMI_CMD_UNSUPPORTED,
 658	.scan_update_request_cmdid = WMI_10_4_SCAN_UPDATE_REQUEST_CMDID,
 659	.vdev_standby_response_cmdid = WMI_10_4_VDEV_STANDBY_RESPONSE_CMDID,
 660	.vdev_resume_response_cmdid = WMI_10_4_VDEV_RESUME_RESPONSE_CMDID,
 661	.wlan_peer_caching_add_peer_cmdid =
 662			WMI_10_4_WLAN_PEER_CACHING_ADD_PEER_CMDID,
 663	.wlan_peer_caching_evict_peer_cmdid =
 664			WMI_10_4_WLAN_PEER_CACHING_EVICT_PEER_CMDID,
 665	.wlan_peer_caching_restore_peer_cmdid =
 666			WMI_10_4_WLAN_PEER_CACHING_RESTORE_PEER_CMDID,
 667	.wlan_peer_caching_print_all_peers_info_cmdid =
 668			WMI_10_4_WLAN_PEER_CACHING_PRINT_ALL_PEERS_INFO_CMDID,
 669	.peer_update_wds_entry_cmdid = WMI_10_4_PEER_UPDATE_WDS_ENTRY_CMDID,
 670	.peer_add_proxy_sta_entry_cmdid =
 671			WMI_10_4_PEER_ADD_PROXY_STA_ENTRY_CMDID,
 672	.rtt_keepalive_cmdid = WMI_10_4_RTT_KEEPALIVE_CMDID,
 673	.oem_req_cmdid = WMI_10_4_OEM_REQ_CMDID,
 674	.nan_cmdid = WMI_10_4_NAN_CMDID,
 675	.vdev_ratemask_cmdid = WMI_10_4_VDEV_RATEMASK_CMDID,
 676	.qboost_cfg_cmdid = WMI_10_4_QBOOST_CFG_CMDID,
 677	.pdev_smart_ant_enable_cmdid = WMI_10_4_PDEV_SMART_ANT_ENABLE_CMDID,
 678	.pdev_smart_ant_set_rx_antenna_cmdid =
 679			WMI_10_4_PDEV_SMART_ANT_SET_RX_ANTENNA_CMDID,
 680	.peer_smart_ant_set_tx_antenna_cmdid =
 681			WMI_10_4_PEER_SMART_ANT_SET_TX_ANTENNA_CMDID,
 682	.peer_smart_ant_set_train_info_cmdid =
 683			WMI_10_4_PEER_SMART_ANT_SET_TRAIN_INFO_CMDID,
 684	.peer_smart_ant_set_node_config_ops_cmdid =
 685			WMI_10_4_PEER_SMART_ANT_SET_NODE_CONFIG_OPS_CMDID,
 686	.pdev_set_antenna_switch_table_cmdid =
 687			WMI_10_4_PDEV_SET_ANTENNA_SWITCH_TABLE_CMDID,
 688	.pdev_set_ctl_table_cmdid = WMI_10_4_PDEV_SET_CTL_TABLE_CMDID,
 689	.pdev_set_mimogain_table_cmdid = WMI_10_4_PDEV_SET_MIMOGAIN_TABLE_CMDID,
 690	.pdev_ratepwr_table_cmdid = WMI_10_4_PDEV_RATEPWR_TABLE_CMDID,
 691	.pdev_ratepwr_chainmsk_table_cmdid =
 692			WMI_10_4_PDEV_RATEPWR_CHAINMSK_TABLE_CMDID,
 693	.pdev_fips_cmdid = WMI_10_4_PDEV_FIPS_CMDID,
 694	.tt_set_conf_cmdid = WMI_10_4_TT_SET_CONF_CMDID,
 695	.fwtest_cmdid = WMI_10_4_FWTEST_CMDID,
 696	.vdev_atf_request_cmdid = WMI_10_4_VDEV_ATF_REQUEST_CMDID,
 697	.peer_atf_request_cmdid = WMI_10_4_PEER_ATF_REQUEST_CMDID,
 698	.pdev_get_ani_cck_config_cmdid = WMI_10_4_PDEV_GET_ANI_CCK_CONFIG_CMDID,
 699	.pdev_get_ani_ofdm_config_cmdid =
 700			WMI_10_4_PDEV_GET_ANI_OFDM_CONFIG_CMDID,
 701	.pdev_reserve_ast_entry_cmdid = WMI_10_4_PDEV_RESERVE_AST_ENTRY_CMDID,
 702	.pdev_get_nfcal_power_cmdid = WMI_10_4_PDEV_GET_NFCAL_POWER_CMDID,
 703	.pdev_get_tpc_cmdid = WMI_10_4_PDEV_GET_TPC_CMDID,
 704	.pdev_get_ast_info_cmdid = WMI_10_4_PDEV_GET_AST_INFO_CMDID,
 705	.vdev_set_dscp_tid_map_cmdid = WMI_10_4_VDEV_SET_DSCP_TID_MAP_CMDID,
 706	.pdev_get_info_cmdid = WMI_10_4_PDEV_GET_INFO_CMDID,
 707	.vdev_get_info_cmdid = WMI_10_4_VDEV_GET_INFO_CMDID,
 708	.vdev_filter_neighbor_rx_packets_cmdid =
 709			WMI_10_4_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID,
 710	.mu_cal_start_cmdid = WMI_10_4_MU_CAL_START_CMDID,
 711	.set_cca_params_cmdid = WMI_10_4_SET_CCA_PARAMS_CMDID,
 712	.pdev_bss_chan_info_request_cmdid =
 713			WMI_10_4_PDEV_BSS_CHAN_INFO_REQUEST_CMDID,
 714	.ext_resource_cfg_cmdid = WMI_10_4_EXT_RESOURCE_CFG_CMDID,
 715	.vdev_set_ie_cmdid = WMI_10_4_VDEV_SET_IE_CMDID,
 716	.set_lteu_config_cmdid = WMI_10_4_SET_LTEU_CONFIG_CMDID,
 717	.atf_ssid_grouping_request_cmdid =
 718			WMI_10_4_ATF_SSID_GROUPING_REQUEST_CMDID,
 719	.peer_atf_ext_request_cmdid = WMI_10_4_PEER_ATF_EXT_REQUEST_CMDID,
 720	.set_periodic_channel_stats_cfg_cmdid =
 721			WMI_10_4_SET_PERIODIC_CHANNEL_STATS_CONFIG,
 722	.peer_bwf_request_cmdid = WMI_10_4_PEER_BWF_REQUEST_CMDID,
 723	.btcoex_cfg_cmdid = WMI_10_4_BTCOEX_CFG_CMDID,
 724	.peer_tx_mu_txmit_count_cmdid = WMI_10_4_PEER_TX_MU_TXMIT_COUNT_CMDID,
 725	.peer_tx_mu_txmit_rstcnt_cmdid = WMI_10_4_PEER_TX_MU_TXMIT_RSTCNT_CMDID,
 726	.peer_gid_userpos_list_cmdid = WMI_10_4_PEER_GID_USERPOS_LIST_CMDID,
 727	.pdev_check_cal_version_cmdid = WMI_10_4_PDEV_CHECK_CAL_VERSION_CMDID,
 728	.coex_version_cfg_cmid = WMI_10_4_COEX_VERSION_CFG_CMID,
 729	.pdev_get_rx_filter_cmdid = WMI_10_4_PDEV_GET_RX_FILTER_CMDID,
 730	.pdev_extended_nss_cfg_cmdid = WMI_10_4_PDEV_EXTENDED_NSS_CFG_CMDID,
 731	.vdev_set_scan_nac_rssi_cmdid = WMI_10_4_VDEV_SET_SCAN_NAC_RSSI_CMDID,
 732	.prog_gpio_band_select_cmdid = WMI_10_4_PROG_GPIO_BAND_SELECT_CMDID,
 733	.config_smart_logging_cmdid = WMI_10_4_CONFIG_SMART_LOGGING_CMDID,
 734	.debug_fatal_condition_cmdid = WMI_10_4_DEBUG_FATAL_CONDITION_CMDID,
 735	.get_tsf_timer_cmdid = WMI_10_4_GET_TSF_TIMER_CMDID,
 736	.pdev_get_tpc_table_cmdid = WMI_10_4_PDEV_GET_TPC_TABLE_CMDID,
 737	.vdev_sifs_trigger_time_cmdid = WMI_10_4_VDEV_SIFS_TRIGGER_TIME_CMDID,
 738	.pdev_wds_entry_list_cmdid = WMI_10_4_PDEV_WDS_ENTRY_LIST_CMDID,
 739	.tdls_set_state_cmdid = WMI_10_4_TDLS_SET_STATE_CMDID,
 740	.tdls_peer_update_cmdid = WMI_10_4_TDLS_PEER_UPDATE_CMDID,
 741	.tdls_set_offchan_mode_cmdid = WMI_10_4_TDLS_SET_OFFCHAN_MODE_CMDID,
 742	.radar_found_cmdid = WMI_10_4_RADAR_FOUND_CMDID,
 743	.per_peer_per_tid_config_cmdid = WMI_10_4_PER_PEER_PER_TID_CONFIG_CMDID,
 744};
 745
 746static struct wmi_peer_param_map wmi_peer_param_map = {
 747	.smps_state = WMI_PEER_SMPS_STATE,
 748	.ampdu = WMI_PEER_AMPDU,
 749	.authorize = WMI_PEER_AUTHORIZE,
 750	.chan_width = WMI_PEER_CHAN_WIDTH,
 751	.nss = WMI_PEER_NSS,
 752	.use_4addr = WMI_PEER_USE_4ADDR,
 753	.use_fixed_power = WMI_PEER_USE_FIXED_PWR,
 754	.debug = WMI_PEER_DEBUG,
 755	.phymode = WMI_PEER_PHYMODE,
 756	.dummy_var = WMI_PEER_DUMMY_VAR,
 757};
 758
 759/* MAIN WMI VDEV param map */
 760static struct wmi_vdev_param_map wmi_vdev_param_map = {
 761	.rts_threshold = WMI_VDEV_PARAM_RTS_THRESHOLD,
 762	.fragmentation_threshold = WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
 763	.beacon_interval = WMI_VDEV_PARAM_BEACON_INTERVAL,
 764	.listen_interval = WMI_VDEV_PARAM_LISTEN_INTERVAL,
 765	.multicast_rate = WMI_VDEV_PARAM_MULTICAST_RATE,
 766	.mgmt_tx_rate = WMI_VDEV_PARAM_MGMT_TX_RATE,
 767	.slot_time = WMI_VDEV_PARAM_SLOT_TIME,
 768	.preamble = WMI_VDEV_PARAM_PREAMBLE,
 769	.swba_time = WMI_VDEV_PARAM_SWBA_TIME,
 770	.wmi_vdev_stats_update_period = WMI_VDEV_STATS_UPDATE_PERIOD,
 771	.wmi_vdev_pwrsave_ageout_time = WMI_VDEV_PWRSAVE_AGEOUT_TIME,
 772	.wmi_vdev_host_swba_interval = WMI_VDEV_HOST_SWBA_INTERVAL,
 773	.dtim_period = WMI_VDEV_PARAM_DTIM_PERIOD,
 774	.wmi_vdev_oc_scheduler_air_time_limit =
 775					WMI_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT,
 776	.wds = WMI_VDEV_PARAM_WDS,
 777	.atim_window = WMI_VDEV_PARAM_ATIM_WINDOW,
 778	.bmiss_count_max = WMI_VDEV_PARAM_BMISS_COUNT_MAX,
 779	.bmiss_first_bcnt = WMI_VDEV_PARAM_BMISS_FIRST_BCNT,
 780	.bmiss_final_bcnt = WMI_VDEV_PARAM_BMISS_FINAL_BCNT,
 781	.feature_wmm = WMI_VDEV_PARAM_FEATURE_WMM,
 782	.chwidth = WMI_VDEV_PARAM_CHWIDTH,
 783	.chextoffset = WMI_VDEV_PARAM_CHEXTOFFSET,
 784	.disable_htprotection =	WMI_VDEV_PARAM_DISABLE_HTPROTECTION,
 785	.sta_quickkickout = WMI_VDEV_PARAM_STA_QUICKKICKOUT,
 786	.mgmt_rate = WMI_VDEV_PARAM_MGMT_RATE,
 787	.protection_mode = WMI_VDEV_PARAM_PROTECTION_MODE,
 788	.fixed_rate = WMI_VDEV_PARAM_FIXED_RATE,
 789	.sgi = WMI_VDEV_PARAM_SGI,
 790	.ldpc = WMI_VDEV_PARAM_LDPC,
 791	.tx_stbc = WMI_VDEV_PARAM_TX_STBC,
 792	.rx_stbc = WMI_VDEV_PARAM_RX_STBC,
 793	.intra_bss_fwd = WMI_VDEV_PARAM_INTRA_BSS_FWD,
 794	.def_keyid = WMI_VDEV_PARAM_DEF_KEYID,
 795	.nss = WMI_VDEV_PARAM_NSS,
 796	.bcast_data_rate = WMI_VDEV_PARAM_BCAST_DATA_RATE,
 797	.mcast_data_rate = WMI_VDEV_PARAM_MCAST_DATA_RATE,
 798	.mcast_indicate = WMI_VDEV_PARAM_MCAST_INDICATE,
 799	.dhcp_indicate = WMI_VDEV_PARAM_DHCP_INDICATE,
 800	.unknown_dest_indicate = WMI_VDEV_PARAM_UNKNOWN_DEST_INDICATE,
 801	.ap_keepalive_min_idle_inactive_time_secs =
 802			WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
 803	.ap_keepalive_max_idle_inactive_time_secs =
 804			WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
 805	.ap_keepalive_max_unresponsive_time_secs =
 806			WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
 807	.ap_enable_nawds = WMI_VDEV_PARAM_AP_ENABLE_NAWDS,
 808	.mcast2ucast_set = WMI_VDEV_PARAM_UNSUPPORTED,
 809	.enable_rtscts = WMI_VDEV_PARAM_ENABLE_RTSCTS,
 810	.txbf = WMI_VDEV_PARAM_TXBF,
 811	.packet_powersave = WMI_VDEV_PARAM_PACKET_POWERSAVE,
 812	.drop_unencry = WMI_VDEV_PARAM_DROP_UNENCRY,
 813	.tx_encap_type = WMI_VDEV_PARAM_TX_ENCAP_TYPE,
 814	.ap_detect_out_of_sync_sleeping_sta_time_secs =
 815					WMI_VDEV_PARAM_UNSUPPORTED,
 816	.rc_num_retries = WMI_VDEV_PARAM_UNSUPPORTED,
 817	.cabq_maxdur = WMI_VDEV_PARAM_UNSUPPORTED,
 818	.mfptest_set = WMI_VDEV_PARAM_UNSUPPORTED,
 819	.rts_fixed_rate = WMI_VDEV_PARAM_UNSUPPORTED,
 820	.vht_sgimask = WMI_VDEV_PARAM_UNSUPPORTED,
 821	.vht80_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 822	.early_rx_adjust_enable = WMI_VDEV_PARAM_UNSUPPORTED,
 823	.early_rx_tgt_bmiss_num = WMI_VDEV_PARAM_UNSUPPORTED,
 824	.early_rx_bmiss_sample_cycle = WMI_VDEV_PARAM_UNSUPPORTED,
 825	.early_rx_slop_step = WMI_VDEV_PARAM_UNSUPPORTED,
 826	.early_rx_init_slop = WMI_VDEV_PARAM_UNSUPPORTED,
 827	.early_rx_adjust_pause = WMI_VDEV_PARAM_UNSUPPORTED,
 828	.proxy_sta = WMI_VDEV_PARAM_UNSUPPORTED,
 829	.meru_vc = WMI_VDEV_PARAM_UNSUPPORTED,
 830	.rx_decap_type = WMI_VDEV_PARAM_UNSUPPORTED,
 831	.bw_nss_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 832	.disable_4addr_src_lrn = WMI_VDEV_PARAM_UNSUPPORTED,
 833	.rtt_responder_role = WMI_VDEV_PARAM_UNSUPPORTED,
 834};
 835
 836/* 10.X WMI VDEV param map */
 837static struct wmi_vdev_param_map wmi_10x_vdev_param_map = {
 838	.rts_threshold = WMI_10X_VDEV_PARAM_RTS_THRESHOLD,
 839	.fragmentation_threshold = WMI_10X_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
 840	.beacon_interval = WMI_10X_VDEV_PARAM_BEACON_INTERVAL,
 841	.listen_interval = WMI_10X_VDEV_PARAM_LISTEN_INTERVAL,
 842	.multicast_rate = WMI_10X_VDEV_PARAM_MULTICAST_RATE,
 843	.mgmt_tx_rate = WMI_10X_VDEV_PARAM_MGMT_TX_RATE,
 844	.slot_time = WMI_10X_VDEV_PARAM_SLOT_TIME,
 845	.preamble = WMI_10X_VDEV_PARAM_PREAMBLE,
 846	.swba_time = WMI_10X_VDEV_PARAM_SWBA_TIME,
 847	.wmi_vdev_stats_update_period = WMI_10X_VDEV_STATS_UPDATE_PERIOD,
 848	.wmi_vdev_pwrsave_ageout_time = WMI_10X_VDEV_PWRSAVE_AGEOUT_TIME,
 849	.wmi_vdev_host_swba_interval = WMI_10X_VDEV_HOST_SWBA_INTERVAL,
 850	.dtim_period = WMI_10X_VDEV_PARAM_DTIM_PERIOD,
 851	.wmi_vdev_oc_scheduler_air_time_limit =
 852				WMI_10X_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT,
 853	.wds = WMI_10X_VDEV_PARAM_WDS,
 854	.atim_window = WMI_10X_VDEV_PARAM_ATIM_WINDOW,
 855	.bmiss_count_max = WMI_10X_VDEV_PARAM_BMISS_COUNT_MAX,
 856	.bmiss_first_bcnt = WMI_VDEV_PARAM_UNSUPPORTED,
 857	.bmiss_final_bcnt = WMI_VDEV_PARAM_UNSUPPORTED,
 858	.feature_wmm = WMI_10X_VDEV_PARAM_FEATURE_WMM,
 859	.chwidth = WMI_10X_VDEV_PARAM_CHWIDTH,
 860	.chextoffset = WMI_10X_VDEV_PARAM_CHEXTOFFSET,
 861	.disable_htprotection = WMI_10X_VDEV_PARAM_DISABLE_HTPROTECTION,
 862	.sta_quickkickout = WMI_10X_VDEV_PARAM_STA_QUICKKICKOUT,
 863	.mgmt_rate = WMI_10X_VDEV_PARAM_MGMT_RATE,
 864	.protection_mode = WMI_10X_VDEV_PARAM_PROTECTION_MODE,
 865	.fixed_rate = WMI_10X_VDEV_PARAM_FIXED_RATE,
 866	.sgi = WMI_10X_VDEV_PARAM_SGI,
 867	.ldpc = WMI_10X_VDEV_PARAM_LDPC,
 868	.tx_stbc = WMI_10X_VDEV_PARAM_TX_STBC,
 869	.rx_stbc = WMI_10X_VDEV_PARAM_RX_STBC,
 870	.intra_bss_fwd = WMI_10X_VDEV_PARAM_INTRA_BSS_FWD,
 871	.def_keyid = WMI_10X_VDEV_PARAM_DEF_KEYID,
 872	.nss = WMI_10X_VDEV_PARAM_NSS,
 873	.bcast_data_rate = WMI_10X_VDEV_PARAM_BCAST_DATA_RATE,
 874	.mcast_data_rate = WMI_10X_VDEV_PARAM_MCAST_DATA_RATE,
 875	.mcast_indicate = WMI_10X_VDEV_PARAM_MCAST_INDICATE,
 876	.dhcp_indicate = WMI_10X_VDEV_PARAM_DHCP_INDICATE,
 877	.unknown_dest_indicate = WMI_10X_VDEV_PARAM_UNKNOWN_DEST_INDICATE,
 878	.ap_keepalive_min_idle_inactive_time_secs =
 879		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
 880	.ap_keepalive_max_idle_inactive_time_secs =
 881		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
 882	.ap_keepalive_max_unresponsive_time_secs =
 883		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
 884	.ap_enable_nawds = WMI_10X_VDEV_PARAM_AP_ENABLE_NAWDS,
 885	.mcast2ucast_set = WMI_10X_VDEV_PARAM_MCAST2UCAST_SET,
 886	.enable_rtscts = WMI_10X_VDEV_PARAM_ENABLE_RTSCTS,
 887	.txbf = WMI_VDEV_PARAM_UNSUPPORTED,
 888	.packet_powersave = WMI_VDEV_PARAM_UNSUPPORTED,
 889	.drop_unencry = WMI_VDEV_PARAM_UNSUPPORTED,
 890	.tx_encap_type = WMI_VDEV_PARAM_UNSUPPORTED,
 891	.ap_detect_out_of_sync_sleeping_sta_time_secs =
 892		WMI_10X_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS,
 893	.rc_num_retries = WMI_VDEV_PARAM_UNSUPPORTED,
 894	.cabq_maxdur = WMI_VDEV_PARAM_UNSUPPORTED,
 895	.mfptest_set = WMI_VDEV_PARAM_UNSUPPORTED,
 896	.rts_fixed_rate = WMI_VDEV_PARAM_UNSUPPORTED,
 897	.vht_sgimask = WMI_VDEV_PARAM_UNSUPPORTED,
 898	.vht80_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 899	.early_rx_adjust_enable = WMI_VDEV_PARAM_UNSUPPORTED,
 900	.early_rx_tgt_bmiss_num = WMI_VDEV_PARAM_UNSUPPORTED,
 901	.early_rx_bmiss_sample_cycle = WMI_VDEV_PARAM_UNSUPPORTED,
 902	.early_rx_slop_step = WMI_VDEV_PARAM_UNSUPPORTED,
 903	.early_rx_init_slop = WMI_VDEV_PARAM_UNSUPPORTED,
 904	.early_rx_adjust_pause = WMI_VDEV_PARAM_UNSUPPORTED,
 905	.proxy_sta = WMI_VDEV_PARAM_UNSUPPORTED,
 906	.meru_vc = WMI_VDEV_PARAM_UNSUPPORTED,
 907	.rx_decap_type = WMI_VDEV_PARAM_UNSUPPORTED,
 908	.bw_nss_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 909	.disable_4addr_src_lrn = WMI_VDEV_PARAM_UNSUPPORTED,
 910	.rtt_responder_role = WMI_VDEV_PARAM_UNSUPPORTED,
 911};
 912
 913static struct wmi_vdev_param_map wmi_10_2_4_vdev_param_map = {
 914	.rts_threshold = WMI_10X_VDEV_PARAM_RTS_THRESHOLD,
 915	.fragmentation_threshold = WMI_10X_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
 916	.beacon_interval = WMI_10X_VDEV_PARAM_BEACON_INTERVAL,
 917	.listen_interval = WMI_10X_VDEV_PARAM_LISTEN_INTERVAL,
 918	.multicast_rate = WMI_10X_VDEV_PARAM_MULTICAST_RATE,
 919	.mgmt_tx_rate = WMI_10X_VDEV_PARAM_MGMT_TX_RATE,
 920	.slot_time = WMI_10X_VDEV_PARAM_SLOT_TIME,
 921	.preamble = WMI_10X_VDEV_PARAM_PREAMBLE,
 922	.swba_time = WMI_10X_VDEV_PARAM_SWBA_TIME,
 923	.wmi_vdev_stats_update_period = WMI_10X_VDEV_STATS_UPDATE_PERIOD,
 924	.wmi_vdev_pwrsave_ageout_time = WMI_10X_VDEV_PWRSAVE_AGEOUT_TIME,
 925	.wmi_vdev_host_swba_interval = WMI_10X_VDEV_HOST_SWBA_INTERVAL,
 926	.dtim_period = WMI_10X_VDEV_PARAM_DTIM_PERIOD,
 927	.wmi_vdev_oc_scheduler_air_time_limit =
 928				WMI_10X_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT,
 929	.wds = WMI_10X_VDEV_PARAM_WDS,
 930	.atim_window = WMI_10X_VDEV_PARAM_ATIM_WINDOW,
 931	.bmiss_count_max = WMI_10X_VDEV_PARAM_BMISS_COUNT_MAX,
 932	.bmiss_first_bcnt = WMI_VDEV_PARAM_UNSUPPORTED,
 933	.bmiss_final_bcnt = WMI_VDEV_PARAM_UNSUPPORTED,
 934	.feature_wmm = WMI_10X_VDEV_PARAM_FEATURE_WMM,
 935	.chwidth = WMI_10X_VDEV_PARAM_CHWIDTH,
 936	.chextoffset = WMI_10X_VDEV_PARAM_CHEXTOFFSET,
 937	.disable_htprotection = WMI_10X_VDEV_PARAM_DISABLE_HTPROTECTION,
 938	.sta_quickkickout = WMI_10X_VDEV_PARAM_STA_QUICKKICKOUT,
 939	.mgmt_rate = WMI_10X_VDEV_PARAM_MGMT_RATE,
 940	.protection_mode = WMI_10X_VDEV_PARAM_PROTECTION_MODE,
 941	.fixed_rate = WMI_10X_VDEV_PARAM_FIXED_RATE,
 942	.sgi = WMI_10X_VDEV_PARAM_SGI,
 943	.ldpc = WMI_10X_VDEV_PARAM_LDPC,
 944	.tx_stbc = WMI_10X_VDEV_PARAM_TX_STBC,
 945	.rx_stbc = WMI_10X_VDEV_PARAM_RX_STBC,
 946	.intra_bss_fwd = WMI_10X_VDEV_PARAM_INTRA_BSS_FWD,
 947	.def_keyid = WMI_10X_VDEV_PARAM_DEF_KEYID,
 948	.nss = WMI_10X_VDEV_PARAM_NSS,
 949	.bcast_data_rate = WMI_10X_VDEV_PARAM_BCAST_DATA_RATE,
 950	.mcast_data_rate = WMI_10X_VDEV_PARAM_MCAST_DATA_RATE,
 951	.mcast_indicate = WMI_10X_VDEV_PARAM_MCAST_INDICATE,
 952	.dhcp_indicate = WMI_10X_VDEV_PARAM_DHCP_INDICATE,
 953	.unknown_dest_indicate = WMI_10X_VDEV_PARAM_UNKNOWN_DEST_INDICATE,
 954	.ap_keepalive_min_idle_inactive_time_secs =
 955		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
 956	.ap_keepalive_max_idle_inactive_time_secs =
 957		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
 958	.ap_keepalive_max_unresponsive_time_secs =
 959		WMI_10X_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
 960	.ap_enable_nawds = WMI_10X_VDEV_PARAM_AP_ENABLE_NAWDS,
 961	.mcast2ucast_set = WMI_10X_VDEV_PARAM_MCAST2UCAST_SET,
 962	.enable_rtscts = WMI_10X_VDEV_PARAM_ENABLE_RTSCTS,
 963	.txbf = WMI_VDEV_PARAM_UNSUPPORTED,
 964	.packet_powersave = WMI_VDEV_PARAM_UNSUPPORTED,
 965	.drop_unencry = WMI_VDEV_PARAM_UNSUPPORTED,
 966	.tx_encap_type = WMI_VDEV_PARAM_UNSUPPORTED,
 967	.ap_detect_out_of_sync_sleeping_sta_time_secs =
 968		WMI_10X_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS,
 969	.rc_num_retries = WMI_VDEV_PARAM_UNSUPPORTED,
 970	.cabq_maxdur = WMI_VDEV_PARAM_UNSUPPORTED,
 971	.mfptest_set = WMI_VDEV_PARAM_UNSUPPORTED,
 972	.rts_fixed_rate = WMI_VDEV_PARAM_UNSUPPORTED,
 973	.vht_sgimask = WMI_VDEV_PARAM_UNSUPPORTED,
 974	.vht80_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 975	.early_rx_adjust_enable = WMI_VDEV_PARAM_UNSUPPORTED,
 976	.early_rx_tgt_bmiss_num = WMI_VDEV_PARAM_UNSUPPORTED,
 977	.early_rx_bmiss_sample_cycle = WMI_VDEV_PARAM_UNSUPPORTED,
 978	.early_rx_slop_step = WMI_VDEV_PARAM_UNSUPPORTED,
 979	.early_rx_init_slop = WMI_VDEV_PARAM_UNSUPPORTED,
 980	.early_rx_adjust_pause = WMI_VDEV_PARAM_UNSUPPORTED,
 981	.proxy_sta = WMI_VDEV_PARAM_UNSUPPORTED,
 982	.meru_vc = WMI_VDEV_PARAM_UNSUPPORTED,
 983	.rx_decap_type = WMI_VDEV_PARAM_UNSUPPORTED,
 984	.bw_nss_ratemask = WMI_VDEV_PARAM_UNSUPPORTED,
 985	.disable_4addr_src_lrn = WMI_VDEV_PARAM_UNSUPPORTED,
 986	.rtt_responder_role = WMI_VDEV_PARAM_UNSUPPORTED,
 987};
 988
 989static struct wmi_vdev_param_map wmi_10_4_vdev_param_map = {
 990	.rts_threshold = WMI_10_4_VDEV_PARAM_RTS_THRESHOLD,
 991	.fragmentation_threshold = WMI_10_4_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
 992	.beacon_interval = WMI_10_4_VDEV_PARAM_BEACON_INTERVAL,
 993	.listen_interval = WMI_10_4_VDEV_PARAM_LISTEN_INTERVAL,
 994	.multicast_rate = WMI_10_4_VDEV_PARAM_MULTICAST_RATE,
 995	.mgmt_tx_rate = WMI_10_4_VDEV_PARAM_MGMT_TX_RATE,
 996	.slot_time = WMI_10_4_VDEV_PARAM_SLOT_TIME,
 997	.preamble = WMI_10_4_VDEV_PARAM_PREAMBLE,
 998	.swba_time = WMI_10_4_VDEV_PARAM_SWBA_TIME,
 999	.wmi_vdev_stats_update_period = WMI_10_4_VDEV_STATS_UPDATE_PERIOD,
1000	.wmi_vdev_pwrsave_ageout_time = WMI_10_4_VDEV_PWRSAVE_AGEOUT_TIME,
1001	.wmi_vdev_host_swba_interval = WMI_10_4_VDEV_HOST_SWBA_INTERVAL,
1002	.dtim_period = WMI_10_4_VDEV_PARAM_DTIM_PERIOD,
1003	.wmi_vdev_oc_scheduler_air_time_limit =
1004	       WMI_10_4_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT,
1005	.wds = WMI_10_4_VDEV_PARAM_WDS,
1006	.atim_window = WMI_10_4_VDEV_PARAM_ATIM_WINDOW,
1007	.bmiss_count_max = WMI_10_4_VDEV_PARAM_BMISS_COUNT_MAX,
1008	.bmiss_first_bcnt = WMI_10_4_VDEV_PARAM_BMISS_FIRST_BCNT,
1009	.bmiss_final_bcnt = WMI_10_4_VDEV_PARAM_BMISS_FINAL_BCNT,
1010	.feature_wmm = WMI_10_4_VDEV_PARAM_FEATURE_WMM,
1011	.chwidth = WMI_10_4_VDEV_PARAM_CHWIDTH,
1012	.chextoffset = WMI_10_4_VDEV_PARAM_CHEXTOFFSET,
1013	.disable_htprotection = WMI_10_4_VDEV_PARAM_DISABLE_HTPROTECTION,
1014	.sta_quickkickout = WMI_10_4_VDEV_PARAM_STA_QUICKKICKOUT,
1015	.mgmt_rate = WMI_10_4_VDEV_PARAM_MGMT_RATE,
1016	.protection_mode = WMI_10_4_VDEV_PARAM_PROTECTION_MODE,
1017	.fixed_rate = WMI_10_4_VDEV_PARAM_FIXED_RATE,
1018	.sgi = WMI_10_4_VDEV_PARAM_SGI,
1019	.ldpc = WMI_10_4_VDEV_PARAM_LDPC,
1020	.tx_stbc = WMI_10_4_VDEV_PARAM_TX_STBC,
1021	.rx_stbc = WMI_10_4_VDEV_PARAM_RX_STBC,
1022	.intra_bss_fwd = WMI_10_4_VDEV_PARAM_INTRA_BSS_FWD,
1023	.def_keyid = WMI_10_4_VDEV_PARAM_DEF_KEYID,
1024	.nss = WMI_10_4_VDEV_PARAM_NSS,
1025	.bcast_data_rate = WMI_10_4_VDEV_PARAM_BCAST_DATA_RATE,
1026	.mcast_data_rate = WMI_10_4_VDEV_PARAM_MCAST_DATA_RATE,
1027	.mcast_indicate = WMI_10_4_VDEV_PARAM_MCAST_INDICATE,
1028	.dhcp_indicate = WMI_10_4_VDEV_PARAM_DHCP_INDICATE,
1029	.unknown_dest_indicate = WMI_10_4_VDEV_PARAM_UNKNOWN_DEST_INDICATE,
1030	.ap_keepalive_min_idle_inactive_time_secs =
1031	       WMI_10_4_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
1032	.ap_keepalive_max_idle_inactive_time_secs =
1033	       WMI_10_4_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
1034	.ap_keepalive_max_unresponsive_time_secs =
1035	       WMI_10_4_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
1036	.ap_enable_nawds = WMI_10_4_VDEV_PARAM_AP_ENABLE_NAWDS,
1037	.mcast2ucast_set = WMI_10_4_VDEV_PARAM_MCAST2UCAST_SET,
1038	.enable_rtscts = WMI_10_4_VDEV_PARAM_ENABLE_RTSCTS,
1039	.txbf = WMI_10_4_VDEV_PARAM_TXBF,
1040	.packet_powersave = WMI_10_4_VDEV_PARAM_PACKET_POWERSAVE,
1041	.drop_unencry = WMI_10_4_VDEV_PARAM_DROP_UNENCRY,
1042	.tx_encap_type = WMI_10_4_VDEV_PARAM_TX_ENCAP_TYPE,
1043	.ap_detect_out_of_sync_sleeping_sta_time_secs =
1044	       WMI_10_4_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS,
1045	.rc_num_retries = WMI_10_4_VDEV_PARAM_RC_NUM_RETRIES,
1046	.cabq_maxdur = WMI_10_4_VDEV_PARAM_CABQ_MAXDUR,
1047	.mfptest_set = WMI_10_4_VDEV_PARAM_MFPTEST_SET,
1048	.rts_fixed_rate = WMI_10_4_VDEV_PARAM_RTS_FIXED_RATE,
1049	.vht_sgimask = WMI_10_4_VDEV_PARAM_VHT_SGIMASK,
1050	.vht80_ratemask = WMI_10_4_VDEV_PARAM_VHT80_RATEMASK,
1051	.early_rx_adjust_enable = WMI_10_4_VDEV_PARAM_EARLY_RX_ADJUST_ENABLE,
1052	.early_rx_tgt_bmiss_num = WMI_10_4_VDEV_PARAM_EARLY_RX_TGT_BMISS_NUM,
1053	.early_rx_bmiss_sample_cycle =
1054	       WMI_10_4_VDEV_PARAM_EARLY_RX_BMISS_SAMPLE_CYCLE,
1055	.early_rx_slop_step = WMI_10_4_VDEV_PARAM_EARLY_RX_SLOP_STEP,
1056	.early_rx_init_slop = WMI_10_4_VDEV_PARAM_EARLY_RX_INIT_SLOP,
1057	.early_rx_adjust_pause = WMI_10_4_VDEV_PARAM_EARLY_RX_ADJUST_PAUSE,
1058	.proxy_sta = WMI_10_4_VDEV_PARAM_PROXY_STA,
1059	.meru_vc = WMI_10_4_VDEV_PARAM_MERU_VC,
1060	.rx_decap_type = WMI_10_4_VDEV_PARAM_RX_DECAP_TYPE,
1061	.bw_nss_ratemask = WMI_10_4_VDEV_PARAM_BW_NSS_RATEMASK,
1062	.inc_tsf = WMI_10_4_VDEV_PARAM_TSF_INCREMENT,
1063	.dec_tsf = WMI_10_4_VDEV_PARAM_TSF_DECREMENT,
1064	.disable_4addr_src_lrn = WMI_10_4_VDEV_PARAM_DISABLE_4_ADDR_SRC_LRN,
1065	.rtt_responder_role = WMI_10_4_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE,
1066};
1067
1068static struct wmi_pdev_param_map wmi_pdev_param_map = {
1069	.tx_chain_mask = WMI_PDEV_PARAM_TX_CHAIN_MASK,
1070	.rx_chain_mask = WMI_PDEV_PARAM_RX_CHAIN_MASK,
1071	.txpower_limit2g = WMI_PDEV_PARAM_TXPOWER_LIMIT2G,
1072	.txpower_limit5g = WMI_PDEV_PARAM_TXPOWER_LIMIT5G,
1073	.txpower_scale = WMI_PDEV_PARAM_TXPOWER_SCALE,
1074	.beacon_gen_mode = WMI_PDEV_PARAM_BEACON_GEN_MODE,
1075	.beacon_tx_mode = WMI_PDEV_PARAM_BEACON_TX_MODE,
1076	.resmgr_offchan_mode = WMI_PDEV_PARAM_RESMGR_OFFCHAN_MODE,
1077	.protection_mode = WMI_PDEV_PARAM_PROTECTION_MODE,
1078	.dynamic_bw = WMI_PDEV_PARAM_DYNAMIC_BW,
1079	.non_agg_sw_retry_th = WMI_PDEV_PARAM_NON_AGG_SW_RETRY_TH,
1080	.agg_sw_retry_th = WMI_PDEV_PARAM_AGG_SW_RETRY_TH,
1081	.sta_kickout_th = WMI_PDEV_PARAM_STA_KICKOUT_TH,
1082	.ac_aggrsize_scaling = WMI_PDEV_PARAM_AC_AGGRSIZE_SCALING,
1083	.ltr_enable = WMI_PDEV_PARAM_LTR_ENABLE,
1084	.ltr_ac_latency_be = WMI_PDEV_PARAM_LTR_AC_LATENCY_BE,
1085	.ltr_ac_latency_bk = WMI_PDEV_PARAM_LTR_AC_LATENCY_BK,
1086	.ltr_ac_latency_vi = WMI_PDEV_PARAM_LTR_AC_LATENCY_VI,
1087	.ltr_ac_latency_vo = WMI_PDEV_PARAM_LTR_AC_LATENCY_VO,
1088	.ltr_ac_latency_timeout = WMI_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT,
1089	.ltr_sleep_override = WMI_PDEV_PARAM_LTR_SLEEP_OVERRIDE,
1090	.ltr_rx_override = WMI_PDEV_PARAM_LTR_RX_OVERRIDE,
1091	.ltr_tx_activity_timeout = WMI_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT,
1092	.l1ss_enable = WMI_PDEV_PARAM_L1SS_ENABLE,
1093	.dsleep_enable = WMI_PDEV_PARAM_DSLEEP_ENABLE,
1094	.pcielp_txbuf_flush = WMI_PDEV_PARAM_PCIELP_TXBUF_FLUSH,
1095	.pcielp_txbuf_watermark = WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_EN,
1096	.pcielp_txbuf_tmo_en = WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_EN,
1097	.pcielp_txbuf_tmo_value = WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_VALUE,
1098	.pdev_stats_update_period = WMI_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD,
1099	.vdev_stats_update_period = WMI_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD,
1100	.peer_stats_update_period = WMI_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD,
1101	.bcnflt_stats_update_period = WMI_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD,
1102	.pmf_qos = WMI_PDEV_PARAM_PMF_QOS,
1103	.arp_ac_override = WMI_PDEV_PARAM_ARP_AC_OVERRIDE,
1104	.dcs = WMI_PDEV_PARAM_DCS,
1105	.ani_enable = WMI_PDEV_PARAM_ANI_ENABLE,
1106	.ani_poll_period = WMI_PDEV_PARAM_ANI_POLL_PERIOD,
1107	.ani_listen_period = WMI_PDEV_PARAM_ANI_LISTEN_PERIOD,
1108	.ani_ofdm_level = WMI_PDEV_PARAM_ANI_OFDM_LEVEL,
1109	.ani_cck_level = WMI_PDEV_PARAM_ANI_CCK_LEVEL,
1110	.dyntxchain = WMI_PDEV_PARAM_DYNTXCHAIN,
1111	.proxy_sta = WMI_PDEV_PARAM_PROXY_STA,
1112	.idle_ps_config = WMI_PDEV_PARAM_IDLE_PS_CONFIG,
1113	.power_gating_sleep = WMI_PDEV_PARAM_POWER_GATING_SLEEP,
1114	.fast_channel_reset = WMI_PDEV_PARAM_UNSUPPORTED,
1115	.burst_dur = WMI_PDEV_PARAM_UNSUPPORTED,
1116	.burst_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1117	.cal_period = WMI_PDEV_PARAM_UNSUPPORTED,
1118	.aggr_burst = WMI_PDEV_PARAM_UNSUPPORTED,
1119	.rx_decap_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1120	.smart_antenna_default_antenna = WMI_PDEV_PARAM_UNSUPPORTED,
1121	.igmpmld_override = WMI_PDEV_PARAM_UNSUPPORTED,
1122	.igmpmld_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1123	.antenna_gain = WMI_PDEV_PARAM_UNSUPPORTED,
1124	.rx_filter = WMI_PDEV_PARAM_UNSUPPORTED,
1125	.set_mcast_to_ucast_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1126	.proxy_sta_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1127	.set_mcast2ucast_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1128	.set_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1129	.remove_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1130	.peer_sta_ps_statechg_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1131	.igmpmld_ac_override = WMI_PDEV_PARAM_UNSUPPORTED,
1132	.block_interbss = WMI_PDEV_PARAM_UNSUPPORTED,
1133	.set_disable_reset_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1134	.set_msdu_ttl_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1135	.set_ppdu_duration_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1136	.txbf_sound_period_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1137	.set_promisc_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1138	.set_burst_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1139	.en_stats = WMI_PDEV_PARAM_UNSUPPORTED,
1140	.mu_group_policy = WMI_PDEV_PARAM_UNSUPPORTED,
1141	.noise_detection = WMI_PDEV_PARAM_UNSUPPORTED,
1142	.noise_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1143	.dpd_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1144	.set_mcast_bcast_echo = WMI_PDEV_PARAM_UNSUPPORTED,
1145	.atf_strict_sch = WMI_PDEV_PARAM_UNSUPPORTED,
1146	.atf_sched_duration = WMI_PDEV_PARAM_UNSUPPORTED,
1147	.ant_plzn = WMI_PDEV_PARAM_UNSUPPORTED,
1148	.mgmt_retry_limit = WMI_PDEV_PARAM_UNSUPPORTED,
1149	.sensitivity_level = WMI_PDEV_PARAM_UNSUPPORTED,
1150	.signed_txpower_2g = WMI_PDEV_PARAM_UNSUPPORTED,
1151	.signed_txpower_5g = WMI_PDEV_PARAM_UNSUPPORTED,
1152	.enable_per_tid_amsdu = WMI_PDEV_PARAM_UNSUPPORTED,
1153	.enable_per_tid_ampdu = WMI_PDEV_PARAM_UNSUPPORTED,
1154	.cca_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1155	.rts_fixed_rate = WMI_PDEV_PARAM_UNSUPPORTED,
1156	.pdev_reset = WMI_PDEV_PARAM_UNSUPPORTED,
1157	.wapi_mbssid_offset = WMI_PDEV_PARAM_UNSUPPORTED,
1158	.arp_srcaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1159	.arp_dstaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1160	.enable_btcoex = WMI_PDEV_PARAM_UNSUPPORTED,
1161};
1162
1163static struct wmi_pdev_param_map wmi_10x_pdev_param_map = {
1164	.tx_chain_mask = WMI_10X_PDEV_PARAM_TX_CHAIN_MASK,
1165	.rx_chain_mask = WMI_10X_PDEV_PARAM_RX_CHAIN_MASK,
1166	.txpower_limit2g = WMI_10X_PDEV_PARAM_TXPOWER_LIMIT2G,
1167	.txpower_limit5g = WMI_10X_PDEV_PARAM_TXPOWER_LIMIT5G,
1168	.txpower_scale = WMI_10X_PDEV_PARAM_TXPOWER_SCALE,
1169	.beacon_gen_mode = WMI_10X_PDEV_PARAM_BEACON_GEN_MODE,
1170	.beacon_tx_mode = WMI_10X_PDEV_PARAM_BEACON_TX_MODE,
1171	.resmgr_offchan_mode = WMI_10X_PDEV_PARAM_RESMGR_OFFCHAN_MODE,
1172	.protection_mode = WMI_10X_PDEV_PARAM_PROTECTION_MODE,
1173	.dynamic_bw = WMI_10X_PDEV_PARAM_DYNAMIC_BW,
1174	.non_agg_sw_retry_th = WMI_10X_PDEV_PARAM_NON_AGG_SW_RETRY_TH,
1175	.agg_sw_retry_th = WMI_10X_PDEV_PARAM_AGG_SW_RETRY_TH,
1176	.sta_kickout_th = WMI_10X_PDEV_PARAM_STA_KICKOUT_TH,
1177	.ac_aggrsize_scaling = WMI_10X_PDEV_PARAM_AC_AGGRSIZE_SCALING,
1178	.ltr_enable = WMI_10X_PDEV_PARAM_LTR_ENABLE,
1179	.ltr_ac_latency_be = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_BE,
1180	.ltr_ac_latency_bk = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_BK,
1181	.ltr_ac_latency_vi = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_VI,
1182	.ltr_ac_latency_vo = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_VO,
1183	.ltr_ac_latency_timeout = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT,
1184	.ltr_sleep_override = WMI_10X_PDEV_PARAM_LTR_SLEEP_OVERRIDE,
1185	.ltr_rx_override = WMI_10X_PDEV_PARAM_LTR_RX_OVERRIDE,
1186	.ltr_tx_activity_timeout = WMI_10X_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT,
1187	.l1ss_enable = WMI_10X_PDEV_PARAM_L1SS_ENABLE,
1188	.dsleep_enable = WMI_10X_PDEV_PARAM_DSLEEP_ENABLE,
1189	.pcielp_txbuf_flush = WMI_PDEV_PARAM_UNSUPPORTED,
1190	.pcielp_txbuf_watermark = WMI_PDEV_PARAM_UNSUPPORTED,
1191	.pcielp_txbuf_tmo_en = WMI_PDEV_PARAM_UNSUPPORTED,
1192	.pcielp_txbuf_tmo_value = WMI_PDEV_PARAM_UNSUPPORTED,
1193	.pdev_stats_update_period = WMI_10X_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD,
1194	.vdev_stats_update_period = WMI_10X_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD,
1195	.peer_stats_update_period = WMI_10X_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD,
1196	.bcnflt_stats_update_period =
1197				WMI_10X_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD,
1198	.pmf_qos = WMI_10X_PDEV_PARAM_PMF_QOS,
1199	.arp_ac_override = WMI_10X_PDEV_PARAM_ARPDHCP_AC_OVERRIDE,
1200	.dcs = WMI_10X_PDEV_PARAM_DCS,
1201	.ani_enable = WMI_10X_PDEV_PARAM_ANI_ENABLE,
1202	.ani_poll_period = WMI_10X_PDEV_PARAM_ANI_POLL_PERIOD,
1203	.ani_listen_period = WMI_10X_PDEV_PARAM_ANI_LISTEN_PERIOD,
1204	.ani_ofdm_level = WMI_10X_PDEV_PARAM_ANI_OFDM_LEVEL,
1205	.ani_cck_level = WMI_10X_PDEV_PARAM_ANI_CCK_LEVEL,
1206	.dyntxchain = WMI_10X_PDEV_PARAM_DYNTXCHAIN,
1207	.proxy_sta = WMI_PDEV_PARAM_UNSUPPORTED,
1208	.idle_ps_config = WMI_PDEV_PARAM_UNSUPPORTED,
1209	.power_gating_sleep = WMI_PDEV_PARAM_UNSUPPORTED,
1210	.fast_channel_reset = WMI_10X_PDEV_PARAM_FAST_CHANNEL_RESET,
1211	.burst_dur = WMI_10X_PDEV_PARAM_BURST_DUR,
1212	.burst_enable = WMI_10X_PDEV_PARAM_BURST_ENABLE,
1213	.cal_period = WMI_10X_PDEV_PARAM_CAL_PERIOD,
1214	.aggr_burst = WMI_PDEV_PARAM_UNSUPPORTED,
1215	.rx_decap_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1216	.smart_antenna_default_antenna = WMI_PDEV_PARAM_UNSUPPORTED,
1217	.igmpmld_override = WMI_PDEV_PARAM_UNSUPPORTED,
1218	.igmpmld_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1219	.antenna_gain = WMI_PDEV_PARAM_UNSUPPORTED,
1220	.rx_filter = WMI_PDEV_PARAM_UNSUPPORTED,
1221	.set_mcast_to_ucast_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1222	.proxy_sta_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1223	.set_mcast2ucast_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1224	.set_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1225	.remove_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1226	.peer_sta_ps_statechg_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1227	.igmpmld_ac_override = WMI_PDEV_PARAM_UNSUPPORTED,
1228	.block_interbss = WMI_PDEV_PARAM_UNSUPPORTED,
1229	.set_disable_reset_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1230	.set_msdu_ttl_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1231	.set_ppdu_duration_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1232	.txbf_sound_period_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1233	.set_promisc_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1234	.set_burst_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1235	.en_stats = WMI_PDEV_PARAM_UNSUPPORTED,
1236	.mu_group_policy = WMI_PDEV_PARAM_UNSUPPORTED,
1237	.noise_detection = WMI_PDEV_PARAM_UNSUPPORTED,
1238	.noise_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1239	.dpd_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1240	.set_mcast_bcast_echo = WMI_PDEV_PARAM_UNSUPPORTED,
1241	.atf_strict_sch = WMI_PDEV_PARAM_UNSUPPORTED,
1242	.atf_sched_duration = WMI_PDEV_PARAM_UNSUPPORTED,
1243	.ant_plzn = WMI_PDEV_PARAM_UNSUPPORTED,
1244	.mgmt_retry_limit = WMI_PDEV_PARAM_UNSUPPORTED,
1245	.sensitivity_level = WMI_PDEV_PARAM_UNSUPPORTED,
1246	.signed_txpower_2g = WMI_PDEV_PARAM_UNSUPPORTED,
1247	.signed_txpower_5g = WMI_PDEV_PARAM_UNSUPPORTED,
1248	.enable_per_tid_amsdu = WMI_PDEV_PARAM_UNSUPPORTED,
1249	.enable_per_tid_ampdu = WMI_PDEV_PARAM_UNSUPPORTED,
1250	.cca_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1251	.rts_fixed_rate = WMI_PDEV_PARAM_UNSUPPORTED,
1252	.pdev_reset = WMI_PDEV_PARAM_UNSUPPORTED,
1253	.wapi_mbssid_offset = WMI_PDEV_PARAM_UNSUPPORTED,
1254	.arp_srcaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1255	.arp_dstaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1256	.enable_btcoex = WMI_PDEV_PARAM_UNSUPPORTED,
1257};
1258
1259static struct wmi_pdev_param_map wmi_10_2_4_pdev_param_map = {
1260	.tx_chain_mask = WMI_10X_PDEV_PARAM_TX_CHAIN_MASK,
1261	.rx_chain_mask = WMI_10X_PDEV_PARAM_RX_CHAIN_MASK,
1262	.txpower_limit2g = WMI_10X_PDEV_PARAM_TXPOWER_LIMIT2G,
1263	.txpower_limit5g = WMI_10X_PDEV_PARAM_TXPOWER_LIMIT5G,
1264	.txpower_scale = WMI_10X_PDEV_PARAM_TXPOWER_SCALE,
1265	.beacon_gen_mode = WMI_10X_PDEV_PARAM_BEACON_GEN_MODE,
1266	.beacon_tx_mode = WMI_10X_PDEV_PARAM_BEACON_TX_MODE,
1267	.resmgr_offchan_mode = WMI_10X_PDEV_PARAM_RESMGR_OFFCHAN_MODE,
1268	.protection_mode = WMI_10X_PDEV_PARAM_PROTECTION_MODE,
1269	.dynamic_bw = WMI_10X_PDEV_PARAM_DYNAMIC_BW,
1270	.non_agg_sw_retry_th = WMI_10X_PDEV_PARAM_NON_AGG_SW_RETRY_TH,
1271	.agg_sw_retry_th = WMI_10X_PDEV_PARAM_AGG_SW_RETRY_TH,
1272	.sta_kickout_th = WMI_10X_PDEV_PARAM_STA_KICKOUT_TH,
1273	.ac_aggrsize_scaling = WMI_10X_PDEV_PARAM_AC_AGGRSIZE_SCALING,
1274	.ltr_enable = WMI_10X_PDEV_PARAM_LTR_ENABLE,
1275	.ltr_ac_latency_be = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_BE,
1276	.ltr_ac_latency_bk = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_BK,
1277	.ltr_ac_latency_vi = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_VI,
1278	.ltr_ac_latency_vo = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_VO,
1279	.ltr_ac_latency_timeout = WMI_10X_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT,
1280	.ltr_sleep_override = WMI_10X_PDEV_PARAM_LTR_SLEEP_OVERRIDE,
1281	.ltr_rx_override = WMI_10X_PDEV_PARAM_LTR_RX_OVERRIDE,
1282	.ltr_tx_activity_timeout = WMI_10X_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT,
1283	.l1ss_enable = WMI_10X_PDEV_PARAM_L1SS_ENABLE,
1284	.dsleep_enable = WMI_10X_PDEV_PARAM_DSLEEP_ENABLE,
1285	.pcielp_txbuf_flush = WMI_PDEV_PARAM_UNSUPPORTED,
1286	.pcielp_txbuf_watermark = WMI_PDEV_PARAM_UNSUPPORTED,
1287	.pcielp_txbuf_tmo_en = WMI_PDEV_PARAM_UNSUPPORTED,
1288	.pcielp_txbuf_tmo_value = WMI_PDEV_PARAM_UNSUPPORTED,
1289	.pdev_stats_update_period = WMI_10X_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD,
1290	.vdev_stats_update_period = WMI_10X_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD,
1291	.peer_stats_update_period = WMI_10X_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD,
1292	.bcnflt_stats_update_period =
1293				WMI_10X_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD,
1294	.pmf_qos = WMI_10X_PDEV_PARAM_PMF_QOS,
1295	.arp_ac_override = WMI_10X_PDEV_PARAM_ARPDHCP_AC_OVERRIDE,
1296	.dcs = WMI_10X_PDEV_PARAM_DCS,
1297	.ani_enable = WMI_10X_PDEV_PARAM_ANI_ENABLE,
1298	.ani_poll_period = WMI_10X_PDEV_PARAM_ANI_POLL_PERIOD,
1299	.ani_listen_period = WMI_10X_PDEV_PARAM_ANI_LISTEN_PERIOD,
1300	.ani_ofdm_level = WMI_10X_PDEV_PARAM_ANI_OFDM_LEVEL,
1301	.ani_cck_level = WMI_10X_PDEV_PARAM_ANI_CCK_LEVEL,
1302	.dyntxchain = WMI_10X_PDEV_PARAM_DYNTXCHAIN,
1303	.proxy_sta = WMI_PDEV_PARAM_UNSUPPORTED,
1304	.idle_ps_config = WMI_PDEV_PARAM_UNSUPPORTED,
1305	.power_gating_sleep = WMI_PDEV_PARAM_UNSUPPORTED,
1306	.fast_channel_reset = WMI_10X_PDEV_PARAM_FAST_CHANNEL_RESET,
1307	.burst_dur = WMI_10X_PDEV_PARAM_BURST_DUR,
1308	.burst_enable = WMI_10X_PDEV_PARAM_BURST_ENABLE,
1309	.cal_period = WMI_10X_PDEV_PARAM_CAL_PERIOD,
1310	.aggr_burst = WMI_PDEV_PARAM_UNSUPPORTED,
1311	.rx_decap_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1312	.smart_antenna_default_antenna = WMI_PDEV_PARAM_UNSUPPORTED,
1313	.igmpmld_override = WMI_PDEV_PARAM_UNSUPPORTED,
1314	.igmpmld_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1315	.antenna_gain = WMI_PDEV_PARAM_UNSUPPORTED,
1316	.rx_filter = WMI_PDEV_PARAM_UNSUPPORTED,
1317	.set_mcast_to_ucast_tid = WMI_PDEV_PARAM_UNSUPPORTED,
1318	.proxy_sta_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1319	.set_mcast2ucast_mode = WMI_PDEV_PARAM_UNSUPPORTED,
1320	.set_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1321	.remove_mcast2ucast_buffer = WMI_PDEV_PARAM_UNSUPPORTED,
1322	.peer_sta_ps_statechg_enable =
1323				WMI_10X_PDEV_PARAM_PEER_STA_PS_STATECHG_ENABLE,
1324	.igmpmld_ac_override = WMI_PDEV_PARAM_UNSUPPORTED,
1325	.block_interbss = WMI_PDEV_PARAM_UNSUPPORTED,
1326	.set_disable_reset_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1327	.set_msdu_ttl_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1328	.set_ppdu_duration_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1329	.txbf_sound_period_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1330	.set_promisc_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1331	.set_burst_mode_cmdid = WMI_PDEV_PARAM_UNSUPPORTED,
1332	.en_stats = WMI_PDEV_PARAM_UNSUPPORTED,
1333	.mu_group_policy = WMI_PDEV_PARAM_UNSUPPORTED,
1334	.noise_detection = WMI_PDEV_PARAM_UNSUPPORTED,
1335	.noise_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1336	.dpd_enable = WMI_PDEV_PARAM_UNSUPPORTED,
1337	.set_mcast_bcast_echo = WMI_PDEV_PARAM_UNSUPPORTED,
1338	.atf_strict_sch = WMI_PDEV_PARAM_UNSUPPORTED,
1339	.atf_sched_duration = WMI_PDEV_PARAM_UNSUPPORTED,
1340	.ant_plzn = WMI_PDEV_PARAM_UNSUPPORTED,
1341	.mgmt_retry_limit = WMI_PDEV_PARAM_UNSUPPORTED,
1342	.sensitivity_level = WMI_PDEV_PARAM_UNSUPPORTED,
1343	.signed_txpower_2g = WMI_PDEV_PARAM_UNSUPPORTED,
1344	.signed_txpower_5g = WMI_PDEV_PARAM_UNSUPPORTED,
1345	.enable_per_tid_amsdu = WMI_PDEV_PARAM_UNSUPPORTED,
1346	.enable_per_tid_ampdu = WMI_PDEV_PARAM_UNSUPPORTED,
1347	.cca_threshold = WMI_PDEV_PARAM_UNSUPPORTED,
1348	.rts_fixed_rate = WMI_PDEV_PARAM_UNSUPPORTED,
1349	.pdev_reset = WMI_10X_PDEV_PARAM_PDEV_RESET,
1350	.wapi_mbssid_offset = WMI_PDEV_PARAM_UNSUPPORTED,
1351	.arp_srcaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1352	.arp_dstaddr = WMI_PDEV_PARAM_UNSUPPORTED,
1353	.enable_btcoex = WMI_PDEV_PARAM_UNSUPPORTED,
1354};
1355
1356/* firmware 10.2 specific mappings */
1357static struct wmi_cmd_map wmi_10_2_cmd_map = {
1358	.init_cmdid = WMI_10_2_INIT_CMDID,
1359	.start_scan_cmdid = WMI_10_2_START_SCAN_CMDID,
1360	.stop_scan_cmdid = WMI_10_2_STOP_SCAN_CMDID,
1361	.scan_chan_list_cmdid = WMI_10_2_SCAN_CHAN_LIST_CMDID,
1362	.scan_sch_prio_tbl_cmdid = WMI_CMD_UNSUPPORTED,
1363	.scan_prob_req_oui_cmdid = WMI_CMD_UNSUPPORTED,
1364	.pdev_set_regdomain_cmdid = WMI_10_2_PDEV_SET_REGDOMAIN_CMDID,
1365	.pdev_set_channel_cmdid = WMI_10_2_PDEV_SET_CHANNEL_CMDID,
1366	.pdev_set_param_cmdid = WMI_10_2_PDEV_SET_PARAM_CMDID,
1367	.pdev_pktlog_enable_cmdid = WMI_10_2_PDEV_PKTLOG_ENABLE_CMDID,
1368	.pdev_pktlog_disable_cmdid = WMI_10_2_PDEV_PKTLOG_DISABLE_CMDID,
1369	.pdev_set_wmm_params_cmdid = WMI_10_2_PDEV_SET_WMM_PARAMS_CMDID,
1370	.pdev_set_ht_cap_ie_cmdid = WMI_10_2_PDEV_SET_HT_CAP_IE_CMDID,
1371	.pdev_set_vht_cap_ie_cmdid = WMI_10_2_PDEV_SET_VHT_CAP_IE_CMDID,
1372	.pdev_set_quiet_mode_cmdid = WMI_10_2_PDEV_SET_QUIET_MODE_CMDID,
1373	.pdev_green_ap_ps_enable_cmdid = WMI_10_2_PDEV_GREEN_AP_PS_ENABLE_CMDID,
1374	.pdev_get_tpc_config_cmdid = WMI_10_2_PDEV_GET_TPC_CONFIG_CMDID,
1375	.pdev_set_base_macaddr_cmdid = WMI_10_2_PDEV_SET_BASE_MACADDR_CMDID,
1376	.vdev_create_cmdid = WMI_10_2_VDEV_CREATE_CMDID,
1377	.vdev_delete_cmdid = WMI_10_2_VDEV_DELETE_CMDID,
1378	.vdev_start_request_cmdid = WMI_10_2_VDEV_START_REQUEST_CMDID,
1379	.vdev_restart_request_cmdid = WMI_10_2_VDEV_RESTART_REQUEST_CMDID,
1380	.vdev_up_cmdid = WMI_10_2_VDEV_UP_CMDID,
1381	.vdev_stop_cmdid = WMI_10_2_VDEV_STOP_CMDID,
1382	.vdev_down_cmdid = WMI_10_2_VDEV_DOWN_CMDID,
1383	.vdev_set_param_cmdid = WMI_10_2_VDEV_SET_PARAM_CMDID,
1384	.vdev_install_key_cmdid = WMI_10_2_VDEV_INSTALL_KEY_CMDID,
1385	.peer_create_cmdid = WMI_10_2_PEER_CREATE_CMDID,
1386	.peer_delete_cmdid = WMI_10_2_PEER_DELETE_CMDID,
1387	.peer_flush_tids_cmdid = WMI_10_2_PEER_FLUSH_TIDS_CMDID,
1388	.peer_set_param_cmdid = WMI_10_2_PEER_SET_PARAM_CMDID,
1389	.peer_assoc_cmdid = WMI_10_2_PEER_ASSOC_CMDID,
1390	.peer_add_wds_entry_cmdid = WMI_10_2_PEER_ADD_WDS_ENTRY_CMDID,
1391	.peer_remove_wds_entry_cmdid = WMI_10_2_PEER_REMOVE_WDS_ENTRY_CMDID,
1392	.peer_mcast_group_cmdid = WMI_10_2_PEER_MCAST_GROUP_CMDID,
1393	.bcn_tx_cmdid = WMI_10_2_BCN_TX_CMDID,
1394	.pdev_send_bcn_cmdid = WMI_10_2_PDEV_SEND_BCN_CMDID,
1395	.bcn_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
1396	.bcn_filter_rx_cmdid = WMI_10_2_BCN_FILTER_RX_CMDID,
1397	.prb_req_filter_rx_cmdid = WMI_10_2_PRB_REQ_FILTER_RX_CMDID,
1398	.mgmt_tx_cmdid = WMI_10_2_MGMT_TX_CMDID,
1399	.prb_tmpl_cmdid = WMI_CMD_UNSUPPORTED,
1400	.addba_clear_resp_cmdid = WMI_10_2_ADDBA_CLEAR_RESP_CMDID,
1401	.addba_send_cmdid = WMI_10_2_ADDBA_SEND_CMDID,
1402	.addba_status_cmdid = WMI_10_2_ADDBA_STATUS_CMDID,
1403	.delba_send_cmdid = WMI_10_2_DELBA_SEND_CMDID,
1404	.addba_set_resp_cmdid = WMI_10_2_ADDBA_SET_RESP_CMDID,
1405	.send_singleamsdu_cmdid = WMI_10_2_SEND_SINGLEAMSDU_CMDID,
1406	.sta_powersave_mode_cmdid = WMI_10_2_STA_POWERSAVE_MODE_CMDID,
1407	.sta_powersave_param_cmdid = WMI_10_2_STA_POWERSAVE_PARAM_CMDID,
1408	.sta_mimo_ps_mode_cmdid = WMI_10_2_STA_MIMO_PS_MODE_CMDID,
1409	.pdev_dfs_enable_cmdid = WMI_10_2_PDEV_DFS_ENABLE_CMDID,
1410	.pdev_dfs_disable_cmdid = WMI_10_2_PDEV_DFS_DISABLE_CMDID,
1411	.roam_scan_mode = WMI_10_2_ROAM_SCAN_MODE,
1412	.roam_scan_rssi_threshold = WMI_10_2_ROAM_SCAN_RSSI_THRESHOLD,
1413	.roam_scan_period = WMI_10_2_ROAM_SCAN_PERIOD,
1414	.roam_scan_rssi_change_threshold =
1415				WMI_10_2_ROAM_SCAN_RSSI_CHANGE_THRESHOLD,
1416	.roam_ap_profile = WMI_10_2_ROAM_AP_PROFILE,
1417	.ofl_scan_add_ap_profile = WMI_10_2_OFL_SCAN_ADD_AP_PROFILE,
1418	.ofl_scan_remove_ap_profile = WMI_10_2_OFL_SCAN_REMOVE_AP_PROFILE,
1419	.ofl_scan_period = WMI_10_2_OFL_SCAN_PERIOD,
1420	.p2p_dev_set_device_info = WMI_10_2_P2P_DEV_SET_DEVICE_INFO,
1421	.p2p_dev_set_discoverability = WMI_10_2_P2P_DEV_SET_DISCOVERABILITY,
1422	.p2p_go_set_beacon_ie = WMI_10_2_P2P_GO_SET_BEACON_IE,
1423	.p2p_go_set_probe_resp_ie = WMI_10_2_P2P_GO_SET_PROBE_RESP_IE,
1424	.p2p_set_vendor_ie_data_cmdid = WMI_CMD_UNSUPPORTED,
1425	.ap_ps_peer_param_cmdid = WMI_10_2_AP_PS_PEER_PARAM_CMDID,
1426	.ap_ps_peer_uapsd_coex_cmdid = WMI_CMD_UNSUPPORTED,
1427	.peer_rate_retry_sched_cmdid = WMI_10_2_PEER_RATE_RETRY_SCHED_CMDID,
1428	.wlan_profile_trigger_cmdid = WMI_10_2_WLAN_PROFILE_TRIGGER_CMDID,
1429	.wlan_profile_set_hist_intvl_cmdid =
1430				WMI_10_2_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
1431	.wlan_profile_get_profile_data_cmdid =
1432				WMI_10_2_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
1433	.wlan_profile_enable_profile_id_cmdid =
1434				WMI_10_2_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
1435	.wlan_profile_list_profile_id_cmdid =
1436				WMI_10_2_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
1437	.pdev_suspend_cmdid = WMI_10_2_PDEV_SUSPEND_CMDID,
1438	.pdev_resume_cmdid = WMI_10_2_PDEV_RESUME_CMDID,
1439	.add_bcn_filter_cmdid = WMI_10_2_ADD_BCN_FILTER_CMDID,
1440	.rmv_bcn_filter_cmdid = WMI_10_2_RMV_BCN_FILTER_CMDID,
1441	.wow_add_wake_pattern_cmdid = WMI_10_2_WOW_ADD_WAKE_PATTERN_CMDID,
1442	.wow_del_wake_pattern_cmdid = WMI_10_2_WOW_DEL_WAKE_PATTERN_CMDID,
1443	.wow_enable_disable_wake_event_cmdid =
1444				WMI_10_2_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID,
1445	.wow_enable_cmdid = WMI_10_2_WOW_ENABLE_CMDID,
1446	.wow_hostwakeup_from_sleep_cmdid =
1447				WMI_10_2_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID,
1448	.rtt_measreq_cmdid = WMI_10_2_RTT_MEASREQ_CMDID,
1449	.rtt_tsf_cmdid = WMI_10_2_RTT_TSF_CMDID,
1450	.vdev_spectral_scan_configure_cmdid =
1451				WMI_10_2_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID,
1452	.vdev_spectral_scan_enable_cmdid =
1453				WMI_10_2_VDEV_SPECTRAL_SCAN_ENABLE_CMDID,
1454	.request_stats_cmdid = WMI_10_2_REQUEST_STATS_CMDID,
1455	.set_arp_ns_offload_cmdid = WMI_CMD_UNSUPPORTED,
1456	.network_list_offload_config_cmdid = WMI_CMD_UNSUPPORTED,
1457	.gtk_offload_cmdid = WMI_CMD_UNSUPPORTED,
1458	.csa_offload_enable_cmdid = WMI_CMD_UNSUPPORTED,
1459	.csa_offload_chanswitch_cmdid = WMI_CMD_UNSUPPORTED,
1460	.chatter_set_mode_cmdid = WMI_CMD_UNSUPPORTED,
1461	.peer_tid_addba_cmdid = WMI_CMD_UNSUPPORTED,
1462	.peer_tid_delba_cmdid = WMI_CMD_UNSUPPORTED,
1463	.sta_dtim_ps_method_cmdid = WMI_CMD_UNSUPPORTED,
1464	.sta_uapsd_auto_trig_cmdid = WMI_CMD_UNSUPPORTED,
1465	.sta_keepalive_cmd = WMI_CMD_UNSUPPORTED,
1466	.echo_cmdid = WMI_10_2_ECHO_CMDID,
1467	.pdev_utf_cmdid = WMI_10_2_PDEV_UTF_CMDID,
1468	.dbglog_cfg_cmdid = WMI_10_2_DBGLOG_CFG_CMDID,
1469	.pdev_qvit_cmdid = WMI_10_2_PDEV_QVIT_CMDID,
1470	.pdev_ftm_intg_cmdid = WMI_CMD_UNSUPPORTED,
1471	.vdev_set_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
1472	.vdev_get_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
1473	.force_fw_hang_cmdid = WMI_CMD_UNSUPPORTED,
1474	.gpio_config_cmdid = WMI_10_2_GPIO_CONFIG_CMDID,
1475	.gpio_output_cmdid = WMI_10_2_GPIO_OUTPUT_CMDID,
1476	.pdev_get_temperature_cmdid = WMI_CMD_UNSUPPORTED,
1477	.pdev_enable_adaptive_cca_cmdid = WMI_CMD_UNSUPPORTED,
1478	.scan_update_request_cmdid = WMI_CMD_UNSUPPORTED,
1479	.vdev_standby_response_cmdid = WMI_CMD_UNSUPPORTED,
1480	.vdev_resume_response_cmdid = WMI_CMD_UNSUPPORTED,
1481	.wlan_peer_caching_add_peer_cmdid = WMI_CMD_UNSUPPORTED,
1482	.wlan_peer_caching_evict_peer_cmdid = WMI_CMD_UNSUPPORTED,
1483	.wlan_peer_caching_restore_peer_cmdid = WMI_CMD_UNSUPPORTED,
1484	.wlan_peer_caching_print_all_peers_info_cmdid = WMI_CMD_UNSUPPORTED,
1485	.peer_update_wds_entry_cmdid = WMI_CMD_UNSUPPORTED,
1486	.peer_add_proxy_sta_entry_cmdid = WMI_CMD_UNSUPPORTED,
1487	.rtt_keepalive_cmdid = WMI_CMD_UNSUPPORTED,
1488	.oem_req_cmdid = WMI_CMD_UNSUPPORTED,
1489	.nan_cmdid = WMI_CMD_UNSUPPORTED,
1490	.vdev_ratemask_cmdid = WMI_CMD_UNSUPPORTED,
1491	.qboost_cfg_cmdid = WMI_CMD_UNSUPPORTED,
1492	.pdev_smart_ant_enable_cmdid = WMI_CMD_UNSUPPORTED,
1493	.pdev_smart_ant_set_rx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
1494	.peer_smart_ant_set_tx_antenna_cmdid = WMI_CMD_UNSUPPORTED,
1495	.peer_smart_ant_set_train_info_cmdid = WMI_CMD_UNSUPPORTED,
1496	.peer_smart_ant_set_node_config_ops_cmdid = WMI_CMD_UNSUPPORTED,
1497	.pdev_set_antenna_switch_table_cmdid = WMI_CMD_UNSUPPORTED,
1498	.pdev_set_ctl_table_cmdid = WMI_CMD_UNSUPPORTED,
1499	.pdev_set_mimogain_table_cmdid = WMI_CMD_UNSUPPORTED,
1500	.pdev_ratepwr_table_cmdid = WMI_CMD_UNSUPPORTED,
1501	.pdev_ratepwr_chainmsk_table_cmdid = WMI_CMD_UNSUPPORTED,
1502	.pdev_fips_cmdid = WMI_CMD_UNSUPPORTED,
1503	.tt_set_conf_cmdid = WMI_CMD_UNSUPPORTED,
1504	.fwtest_cmdid = WMI_CMD_UNSUPPORTED,
1505	.vdev_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
1506	.peer_atf_request_cmdid = WMI_CMD_UNSUPPORTED,
1507	.pdev_get_ani_cck_config_cmdid = WMI_CMD_UNSUPPORTED,
1508	.pdev_get_ani_ofdm_config_cmdid = WMI_CMD_UNSUPPORTED,
1509	.pdev_reserve_ast_entry_cmdid = WMI_CMD_UNSUPPORTED,
1510	.pdev_get_tpc_table_cmdid = WMI_CMD_UNSUPPORTED,
1511	.radar_found_cmdid = WMI_CMD_UNSUPPORTED,
1512};
1513
1514static struct wmi_pdev_param_map wmi_10_4_pdev_param_map = {
1515	.tx_chain_mask = WMI_10_4_PDEV_PARAM_TX_CHAIN_MASK,
1516	.rx_chain_mask = WMI_10_4_PDEV_PARAM_RX_CHAIN_MASK,
1517	.txpower_limit2g = WMI_10_4_PDEV_PARAM_TXPOWER_LIMIT2G,
1518	.txpower_limit5g = WMI_10_4_PDEV_PARAM_TXPOWER_LIMIT5G,
1519	.txpower_scale = WMI_10_4_PDEV_PARAM_TXPOWER_SCALE,
1520	.beacon_gen_mode = WMI_10_4_PDEV_PARAM_BEACON_GEN_MODE,
1521	.beacon_tx_mode = WMI_10_4_PDEV_PARAM_BEACON_TX_MODE,
1522	.resmgr_offchan_mode = WMI_10_4_PDEV_PARAM_RESMGR_OFFCHAN_MODE,
1523	.protection_mode = WMI_10_4_PDEV_PARAM_PROTECTION_MODE,
1524	.dynamic_bw = WMI_10_4_PDEV_PARAM_DYNAMIC_BW,
1525	.non_agg_sw_retry_th = WMI_10_4_PDEV_PARAM_NON_AGG_SW_RETRY_TH,
1526	.agg_sw_retry_th = WMI_10_4_PDEV_PARAM_AGG_SW_RETRY_TH,
1527	.sta_kickout_th = WMI_10_4_PDEV_PARAM_STA_KICKOUT_TH,
1528	.ac_aggrsize_scaling = WMI_10_4_PDEV_PARAM_AC_AGGRSIZE_SCALING,
1529	.ltr_enable = WMI_10_4_PDEV_PARAM_LTR_ENABLE,
1530	.ltr_ac_latency_be = WMI_10_4_PDEV_PARAM_LTR_AC_LATENCY_BE,
1531	.ltr_ac_latency_bk = WMI_10_4_PDEV_PARAM_LTR_AC_LATENCY_BK,
1532	.ltr_ac_latency_vi = WMI_10_4_PDEV_PARAM_LTR_AC_LATENCY_VI,
1533	.ltr_ac_latency_vo = WMI_10_4_PDEV_PARAM_LTR_AC_LATENCY_VO,
1534	.ltr_ac_latency_timeout = WMI_10_4_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT,
1535	.ltr_sleep_override = WMI_10_4_PDEV_PARAM_LTR_SLEEP_OVERRIDE,
1536	.ltr_rx_override = WMI_10_4_PDEV_PARAM_LTR_RX_OVERRIDE,
1537	.ltr_tx_activity_timeout = WMI_10_4_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT,
1538	.l1ss_enable = WMI_10_4_PDEV_PARAM_L1SS_ENABLE,
1539	.dsleep_enable = WMI_10_4_PDEV_PARAM_DSLEEP_ENABLE,
1540	.pcielp_txbuf_flush = WMI_10_4_PDEV_PARAM_PCIELP_TXBUF_FLUSH,
1541	.pcielp_txbuf_watermark = WMI_10_4_PDEV_PARAM_PCIELP_TXBUF_WATERMARK,
1542	.pcielp_txbuf_tmo_en = WMI_10_4_PDEV_PARAM_PCIELP_TXBUF_TMO_EN,
1543	.pcielp_txbuf_tmo_value = WMI_10_4_PDEV_PARAM_PCIELP_TXBUF_TMO_VALUE,
1544	.pdev_stats_update_period =
1545			WMI_10_4_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD,
1546	.vdev_stats_update_period =
1547			WMI_10_4_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD,
1548	.peer_stats_update_period =
1549			WMI_10_4_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD,
1550	.bcnflt_stats_update_period =
1551			WMI_10_4_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD,
1552	.pmf_qos = WMI_10_4_PDEV_PARAM_PMF_QOS,
1553	.arp_ac_override = WMI_10_4_PDEV_PARAM_ARP_AC_OVERRIDE,
1554	.dcs = WMI_10_4_PDEV_PARAM_DCS,
1555	.ani_enable = WMI_10_4_PDEV_PARAM_ANI_ENABLE,
1556	.ani_poll_period = WMI_10_4_PDEV_PARAM_ANI_POLL_PERIOD,
1557	.ani_listen_period = WMI_10_4_PDEV_PARAM_ANI_LISTEN_PERIOD,
1558	.ani_ofdm_level = WMI_10_4_PDEV_PARAM_ANI_OFDM_LEVEL,
1559	.ani_cck_level = WMI_10_4_PDEV_PARAM_ANI_CCK_LEVEL,
1560	.dyntxchain = WMI_10_4_PDEV_PARAM_DYNTXCHAIN,
1561	.proxy_sta = WMI_10_4_PDEV_PARAM_PROXY_STA,
1562	.idle_ps_config = WMI_10_4_PDEV_PARAM_IDLE_PS_CONFIG,
1563	.power_gating_sleep = WMI_10_4_PDEV_PARAM_POWER_GATING_SLEEP,
1564	.fast_channel_reset = WMI_10_4_PDEV_PARAM_FAST_CHANNEL_RESET,
1565	.burst_dur = WMI_10_4_PDEV_PARAM_BURST_DUR,
1566	.burst_enable = WMI_10_4_PDEV_PARAM_BURST_ENABLE,
1567	.cal_period = WMI_10_4_PDEV_PARAM_CAL_PERIOD,
1568	.aggr_burst = WMI_10_4_PDEV_PARAM_AGGR_BURST,
1569	.rx_decap_mode = WMI_10_4_PDEV_PARAM_RX_DECAP_MODE,
1570	.smart_antenna_default_antenna =
1571			WMI_10_4_PDEV_PARAM_SMART_ANTENNA_DEFAULT_ANTENNA,
1572	.igmpmld_override = WMI_10_4_PDEV_PARAM_IGMPMLD_OVERRIDE,
1573	.igmpmld_tid = WMI_10_4_PDEV_PARAM_IGMPMLD_TID,
1574	.antenna_gain = WMI_10_4_PDEV_PARAM_ANTENNA_GAIN,
1575	.rx_filter = WMI_10_4_PDEV_PARAM_RX_FILTER,
1576	.set_mcast_to_ucast_tid = WMI_10_4_PDEV_SET_MCAST_TO_UCAST_TID,
1577	.proxy_sta_mode = WMI_10_4_PDEV_PARAM_PROXY_STA_MODE,
1578	.set_mcast2ucast_mode = WMI_10_4_PDEV_PARAM_SET_MCAST2UCAST_MODE,
1579	.set_mcast2ucast_buffer = WMI_10_4_PDEV_PARAM_SET_MCAST2UCAST_BUFFER,
1580	.remove_mcast2ucast_buffer =
1581			WMI_10_4_PDEV_PARAM_REMOVE_MCAST2UCAST_BUFFER,
1582	.peer_sta_ps_statechg_enable =
1583			WMI_10_4_PDEV_PEER_STA_PS_STATECHG_ENABLE,
1584	.igmpmld_ac_override = WMI_10_4_PDEV_PARAM_IGMPMLD_AC_OVERRIDE,
1585	.block_interbss = WMI_10_4_PDEV_PARAM_BLOCK_INTERBSS,
1586	.set_disable_reset_cmdid = WMI_10_4_PDEV_PARAM_SET_DISABLE_RESET_CMDID,
1587	.set_msdu_ttl_cmdid = WMI_10_4_PDEV_PARAM_SET_MSDU_TTL_CMDID,
1588	.set_ppdu_duration_cmdid = WMI_10_4_PDEV_PARAM_SET_PPDU_DURATION_CMDID,
1589	.txbf_sound_period_cmdid = WMI_10_4_PDEV_PARAM_TXBF_SOUND_PERIOD_CMDID,
1590	.set_promisc_mode_cmdid = WMI_10_4_PDEV_PARAM_SET_PROMISC_MODE_CMDID,
1591	.set_burst_mode_cmdid = WMI_10_4_PDEV_PARAM_SET_BURST_MODE_CMDID,
1592	.en_stats = WMI_10_4_PDEV_PARAM_EN_STATS,
1593	.mu_group_policy = WMI_10_4_PDEV_PARAM_MU_GROUP_POLICY,
1594	.noise_detection = WMI_10_4_PDEV_PARAM_NOISE_DETECTION,
1595	.noise_threshold = WMI_10_4_PDEV_PARAM_NOISE_THRESHOLD,
1596	.dpd_enable = WMI_10_4_PDEV_PARAM_DPD_ENABLE,
1597	.set_mcast_bcast_echo = WMI_10_4_PDEV_PARAM_SET_MCAST_BCAST_ECHO,
1598	.atf_strict_sch = WMI_10_4_PDEV_PARAM_ATF_STRICT_SCH,
1599	.atf_sched_duration = WMI_10_4_PDEV_PARAM_ATF_SCHED_DURATION,
1600	.ant_plzn = WMI_10_4_PDEV_PARAM_ANT_PLZN,
1601	.mgmt_retry_limit = WMI_10_4_PDEV_PARAM_MGMT_RETRY_LIMIT,
1602	.sensitivity_level = WMI_10_4_PDEV_PARAM_SENSITIVITY_LEVEL,
1603	.signed_txpower_2g = WMI_10_4_PDEV_PARAM_SIGNED_TXPOWER_2G,
1604	.signed_txpower_5g = WMI_10_4_PDEV_PARAM_SIGNED_TXPOWER_5G,
1605	.enable_per_tid_amsdu = WMI_10_4_PDEV_PARAM_ENABLE_PER_TID_AMSDU,
1606	.enable_per_tid_ampdu = WMI_10_4_PDEV_PARAM_ENABLE_PER_TID_AMPDU,
1607	.cca_threshold = WMI_10_4_PDEV_PARAM_CCA_THRESHOLD,
1608	.rts_fixed_rate = WMI_10_4_PDEV_PARAM_RTS_FIXED_RATE,
1609	.pdev_reset = WMI_10_4_PDEV_PARAM_PDEV_RESET,
1610	.wapi_mbssid_offset = WMI_10_4_PDEV_PARAM_WAPI_MBSSID_OFFSET,
1611	.arp_srcaddr = WMI_10_4_PDEV_PARAM_ARP_SRCADDR,
1612	.arp_dstaddr = WMI_10_4_PDEV_PARAM_ARP_DSTADDR,
1613	.enable_btcoex = WMI_10_4_PDEV_PARAM_ENABLE_BTCOEX,
1614};
1615
1616static const u8 wmi_key_cipher_suites[] = {
1617	[WMI_CIPHER_NONE] = WMI_CIPHER_NONE,
1618	[WMI_CIPHER_WEP] = WMI_CIPHER_WEP,
1619	[WMI_CIPHER_TKIP] = WMI_CIPHER_TKIP,
1620	[WMI_CIPHER_AES_OCB] = WMI_CIPHER_AES_OCB,
1621	[WMI_CIPHER_AES_CCM] = WMI_CIPHER_AES_CCM,
1622	[WMI_CIPHER_WAPI] = WMI_CIPHER_WAPI,
1623	[WMI_CIPHER_CKIP] = WMI_CIPHER_CKIP,
1624	[WMI_CIPHER_AES_CMAC] = WMI_CIPHER_AES_CMAC,
1625	[WMI_CIPHER_AES_GCM] = WMI_CIPHER_AES_GCM,
1626};
1627
1628static const u8 wmi_tlv_key_cipher_suites[] = {
1629	[WMI_CIPHER_NONE] = WMI_TLV_CIPHER_NONE,
1630	[WMI_CIPHER_WEP] = WMI_TLV_CIPHER_WEP,
1631	[WMI_CIPHER_TKIP] = WMI_TLV_CIPHER_TKIP,
1632	[WMI_CIPHER_AES_OCB] = WMI_TLV_CIPHER_AES_OCB,
1633	[WMI_CIPHER_AES_CCM] = WMI_TLV_CIPHER_AES_CCM,
1634	[WMI_CIPHER_WAPI] = WMI_TLV_CIPHER_WAPI,
1635	[WMI_CIPHER_CKIP] = WMI_TLV_CIPHER_CKIP,
1636	[WMI_CIPHER_AES_CMAC] = WMI_TLV_CIPHER_AES_CMAC,
1637	[WMI_CIPHER_AES_GCM] = WMI_TLV_CIPHER_AES_GCM,
1638};
1639
1640static const struct wmi_peer_flags_map wmi_peer_flags_map = {
1641	.auth = WMI_PEER_AUTH,
1642	.qos = WMI_PEER_QOS,
1643	.need_ptk_4_way = WMI_PEER_NEED_PTK_4_WAY,
1644	.need_gtk_2_way = WMI_PEER_NEED_GTK_2_WAY,
1645	.apsd = WMI_PEER_APSD,
1646	.ht = WMI_PEER_HT,
1647	.bw40 = WMI_PEER_40MHZ,
1648	.stbc = WMI_PEER_STBC,
1649	.ldbc = WMI_PEER_LDPC,
1650	.dyn_mimops = WMI_PEER_DYN_MIMOPS,
1651	.static_mimops = WMI_PEER_STATIC_MIMOPS,
1652	.spatial_mux = WMI_PEER_SPATIAL_MUX,
1653	.vht = WMI_PEER_VHT,
1654	.bw80 = WMI_PEER_80MHZ,
1655	.vht_2g = WMI_PEER_VHT_2G,
1656	.pmf = WMI_PEER_PMF,
1657	.bw160 = WMI_PEER_160MHZ,
1658};
1659
1660static const struct wmi_peer_flags_map wmi_10x_peer_flags_map = {
1661	.auth = WMI_10X_PEER_AUTH,
1662	.qos = WMI_10X_PEER_QOS,
1663	.need_ptk_4_way = WMI_10X_PEER_NEED_PTK_4_WAY,
1664	.need_gtk_2_way = WMI_10X_PEER_NEED_GTK_2_WAY,
1665	.apsd = WMI_10X_PEER_APSD,
1666	.ht = WMI_10X_PEER_HT,
1667	.bw40 = WMI_10X_PEER_40MHZ,
1668	.stbc = WMI_10X_PEER_STBC,
1669	.ldbc = WMI_10X_PEER_LDPC,
1670	.dyn_mimops = WMI_10X_PEER_DYN_MIMOPS,
1671	.static_mimops = WMI_10X_PEER_STATIC_MIMOPS,
1672	.spatial_mux = WMI_10X_PEER_SPATIAL_MUX,
1673	.vht = WMI_10X_PEER_VHT,
1674	.bw80 = WMI_10X_PEER_80MHZ,
1675	.bw160 = WMI_10X_PEER_160MHZ,
1676};
1677
1678static const struct wmi_peer_flags_map wmi_10_2_peer_flags_map = {
1679	.auth = WMI_10_2_PEER_AUTH,
1680	.qos = WMI_10_2_PEER_QOS,
1681	.need_ptk_4_way = WMI_10_2_PEER_NEED_PTK_4_WAY,
1682	.need_gtk_2_way = WMI_10_2_PEER_NEED_GTK_2_WAY,
1683	.apsd = WMI_10_2_PEER_APSD,
1684	.ht = WMI_10_2_PEER_HT,
1685	.bw40 = WMI_10_2_PEER_40MHZ,
1686	.stbc = WMI_10_2_PEER_STBC,
1687	.ldbc = WMI_10_2_PEER_LDPC,
1688	.dyn_mimops = WMI_10_2_PEER_DYN_MIMOPS,
1689	.static_mimops = WMI_10_2_PEER_STATIC_MIMOPS,
1690	.spatial_mux = WMI_10_2_PEER_SPATIAL_MUX,
1691	.vht = WMI_10_2_PEER_VHT,
1692	.bw80 = WMI_10_2_PEER_80MHZ,
1693	.vht_2g = WMI_10_2_PEER_VHT_2G,
1694	.pmf = WMI_10_2_PEER_PMF,
1695	.bw160 = WMI_10_2_PEER_160MHZ,
1696};
1697
1698void ath10k_wmi_put_wmi_channel(struct ath10k *ar, struct wmi_channel *ch,
1699				const struct wmi_channel_arg *arg)
1700{
1701	u32 flags = 0;
1702	struct ieee80211_channel *chan = NULL;
1703
1704	memset(ch, 0, sizeof(*ch));
1705
1706	if (arg->passive)
1707		flags |= WMI_CHAN_FLAG_PASSIVE;
1708	if (arg->allow_ibss)
1709		flags |= WMI_CHAN_FLAG_ADHOC_ALLOWED;
1710	if (arg->allow_ht)
1711		flags |= WMI_CHAN_FLAG_ALLOW_HT;
1712	if (arg->allow_vht)
1713		flags |= WMI_CHAN_FLAG_ALLOW_VHT;
1714	if (arg->ht40plus)
1715		flags |= WMI_CHAN_FLAG_HT40_PLUS;
1716	if (arg->chan_radar)
1717		flags |= WMI_CHAN_FLAG_DFS;
1718
1719	ch->band_center_freq2 = 0;
1720	ch->mhz = __cpu_to_le32(arg->freq);
1721	ch->band_center_freq1 = __cpu_to_le32(arg->band_center_freq1);
1722	if (arg->mode == MODE_11AC_VHT80_80) {
1723		ch->band_center_freq2 = __cpu_to_le32(arg->band_center_freq2);
1724		chan = ieee80211_get_channel(ar->hw->wiphy,
1725					     arg->band_center_freq2 - 10);
1726	}
1727
1728	if (arg->mode == MODE_11AC_VHT160) {
1729		u32 band_center_freq1;
1730		u32 band_center_freq2;
1731
1732		if (arg->freq > arg->band_center_freq1) {
1733			band_center_freq1 = arg->band_center_freq1 + 40;
1734			band_center_freq2 = arg->band_center_freq1 - 40;
1735		} else {
1736			band_center_freq1 = arg->band_center_freq1 - 40;
1737			band_center_freq2 = arg->band_center_freq1 + 40;
1738		}
1739
1740		ch->band_center_freq1 =
1741					__cpu_to_le32(band_center_freq1);
1742		/* Minus 10 to get a defined 5G channel frequency*/
1743		chan = ieee80211_get_channel(ar->hw->wiphy,
1744					     band_center_freq2 - 10);
1745		/* The center frequency of the entire VHT160 */
1746		ch->band_center_freq2 = __cpu_to_le32(arg->band_center_freq1);
1747	}
1748
1749	if (chan && chan->flags & IEEE80211_CHAN_RADAR)
1750		flags |= WMI_CHAN_FLAG_DFS_CFREQ2;
1751
1752	ch->min_power = arg->min_power;
1753	ch->max_power = arg->max_power;
1754	ch->reg_power = arg->max_reg_power;
1755	ch->antenna_max = arg->max_antenna_gain;
1756	ch->max_tx_power = arg->max_power;
1757
1758	/* mode & flags share storage */
1759	ch->mode = arg->mode;
1760	ch->flags |= __cpu_to_le32(flags);
1761}
1762
1763int ath10k_wmi_wait_for_service_ready(struct ath10k *ar)
1764{
1765	unsigned long time_left;
1766
1767	time_left = wait_for_completion_timeout(&ar->wmi.service_ready,
1768						WMI_SERVICE_READY_TIMEOUT_HZ);
1769	if (!time_left)
1770		return -ETIMEDOUT;
1771	return 0;
1772}
1773
1774int ath10k_wmi_wait_for_unified_ready(struct ath10k *ar)
1775{
1776	unsigned long time_left;
1777
1778	time_left = wait_for_completion_timeout(&ar->wmi.unified_ready,
1779						WMI_UNIFIED_READY_TIMEOUT_HZ);
1780	if (!time_left)
1781		return -ETIMEDOUT;
1782	return 0;
1783}
1784
1785struct sk_buff *ath10k_wmi_alloc_skb(struct ath10k *ar, u32 len)
1786{
1787	struct sk_buff *skb;
1788	u32 round_len = roundup(len, 4);
1789
1790	skb = ath10k_htc_alloc_skb(ar, WMI_SKB_HEADROOM + round_len);
1791	if (!skb)
1792		return NULL;
1793
1794	skb_reserve(skb, WMI_SKB_HEADROOM);
1795	if (!IS_ALIGNED((unsigned long)skb->data, 4))
1796		ath10k_warn(ar, "Unaligned WMI skb\n");
1797
1798	skb_put(skb, round_len);
1799	memset(skb->data, 0, round_len);
1800
1801	return skb;
1802}
1803
1804static void ath10k_wmi_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb)
1805{
1806	dev_kfree_skb(skb);
1807}
1808
1809int ath10k_wmi_cmd_send_nowait(struct ath10k *ar, struct sk_buff *skb,
1810			       u32 cmd_id)
1811{
1812	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
1813	struct wmi_cmd_hdr *cmd_hdr;
1814	int ret;
1815	u32 cmd = 0;
1816
1817	if (skb_push(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
1818		return -ENOMEM;
1819
1820	cmd |= SM(cmd_id, WMI_CMD_HDR_CMD_ID);
1821
1822	cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
1823	cmd_hdr->cmd_id = __cpu_to_le32(cmd);
1824
1825	memset(skb_cb, 0, sizeof(*skb_cb));
1826	trace_ath10k_wmi_cmd(ar, cmd_id, skb->data, skb->len);
1827	ret = ath10k_htc_send(&ar->htc, ar->wmi.eid, skb);
1828
1829	if (ret)
1830		goto err_pull;
1831
1832	return 0;
1833
1834err_pull:
1835	skb_pull(skb, sizeof(struct wmi_cmd_hdr));
1836	return ret;
1837}
1838
1839static void ath10k_wmi_tx_beacon_nowait(struct ath10k_vif *arvif)
1840{
1841	struct ath10k *ar = arvif->ar;
1842	struct ath10k_skb_cb *cb;
1843	struct sk_buff *bcn;
1844	bool dtim_zero;
1845	bool deliver_cab;
1846	int ret;
1847
1848	spin_lock_bh(&ar->data_lock);
1849
1850	bcn = arvif->beacon;
1851
1852	if (!bcn)
1853		goto unlock;
1854
1855	cb = ATH10K_SKB_CB(bcn);
1856
1857	switch (arvif->beacon_state) {
1858	case ATH10K_BEACON_SENDING:
1859	case ATH10K_BEACON_SENT:
1860		break;
1861	case ATH10K_BEACON_SCHEDULED:
1862		arvif->beacon_state = ATH10K_BEACON_SENDING;
1863		spin_unlock_bh(&ar->data_lock);
1864
1865		dtim_zero = !!(cb->flags & ATH10K_SKB_F_DTIM_ZERO);
1866		deliver_cab = !!(cb->flags & ATH10K_SKB_F_DELIVER_CAB);
1867		ret = ath10k_wmi_beacon_send_ref_nowait(arvif->ar,
1868							arvif->vdev_id,
1869							bcn->data, bcn->len,
1870							cb->paddr,
1871							dtim_zero,
1872							deliver_cab);
1873
1874		spin_lock_bh(&ar->data_lock);
1875
1876		if (ret == 0)
1877			arvif->beacon_state = ATH10K_BEACON_SENT;
1878		else
1879			arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
1880	}
1881
1882unlock:
1883	spin_unlock_bh(&ar->data_lock);
1884}
1885
1886static void ath10k_wmi_tx_beacons_iter(void *data, u8 *mac,
1887				       struct ieee80211_vif *vif)
1888{
1889	struct ath10k_vif *arvif = (void *)vif->drv_priv;
1890
1891	ath10k_wmi_tx_beacon_nowait(arvif);
1892}
1893
1894static void ath10k_wmi_tx_beacons_nowait(struct ath10k *ar)
1895{
1896	ieee80211_iterate_active_interfaces_atomic(ar->hw,
1897						   ATH10K_ITER_NORMAL_FLAGS,
1898						   ath10k_wmi_tx_beacons_iter,
1899						   NULL);
1900}
1901
1902static void ath10k_wmi_op_ep_tx_credits(struct ath10k *ar)
1903{
1904	/* try to send pending beacons first. they take priority */
1905	ath10k_wmi_tx_beacons_nowait(ar);
1906
1907	wake_up(&ar->wmi.tx_credits_wq);
1908}
1909
1910int ath10k_wmi_cmd_send(struct ath10k *ar, struct sk_buff *skb, u32 cmd_id)
1911{
1912	int ret = -EOPNOTSUPP;
1913
1914	might_sleep();
1915
1916	if (cmd_id == WMI_CMD_UNSUPPORTED) {
1917		ath10k_warn(ar, "wmi command %d is not supported by firmware\n",
1918			    cmd_id);
1919		return ret;
1920	}
1921
1922	wait_event_timeout(ar->wmi.tx_credits_wq, ({
1923		/* try to send pending beacons first. they take priority */
1924		ath10k_wmi_tx_beacons_nowait(ar);
1925
1926		ret = ath10k_wmi_cmd_send_nowait(ar, skb, cmd_id);
1927
1928		if (ret && test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
1929			ret = -ESHUTDOWN;
1930
1931		(ret != -EAGAIN);
1932	}), 3 * HZ);
1933
1934	if (ret)
1935		dev_kfree_skb_any(skb);
1936
1937	if (ret == -EAGAIN) {
1938		ath10k_warn(ar, "wmi command %d timeout, restarting hardware\n",
1939			    cmd_id);
1940		ath10k_core_start_recovery(ar);
1941	}
1942
1943	return ret;
1944}
1945
1946static struct sk_buff *
1947ath10k_wmi_op_gen_mgmt_tx(struct ath10k *ar, struct sk_buff *msdu)
1948{
1949	struct ath10k_skb_cb *cb = ATH10K_SKB_CB(msdu);
1950	struct ath10k_vif *arvif;
1951	struct wmi_mgmt_tx_cmd *cmd;
1952	struct ieee80211_hdr *hdr;
1953	struct sk_buff *skb;
1954	int len;
1955	u32 vdev_id;
1956	u32 buf_len = msdu->len;
1957	u16 fc;
1958	const u8 *peer_addr;
1959
1960	hdr = (struct ieee80211_hdr *)msdu->data;
1961	fc = le16_to_cpu(hdr->frame_control);
1962
1963	if (cb->vif) {
1964		arvif = (void *)cb->vif->drv_priv;
1965		vdev_id = arvif->vdev_id;
1966	} else {
1967		vdev_id = 0;
1968	}
1969
1970	if (WARN_ON_ONCE(!ieee80211_is_mgmt(hdr->frame_control)))
1971		return ERR_PTR(-EINVAL);
1972
1973	len = sizeof(cmd->hdr) + msdu->len;
1974
1975	if ((ieee80211_is_action(hdr->frame_control) ||
1976	     ieee80211_is_deauth(hdr->frame_control) ||
1977	     ieee80211_is_disassoc(hdr->frame_control)) &&
1978	     ieee80211_has_protected(hdr->frame_control)) {
1979		peer_addr = hdr->addr1;
1980		if (is_multicast_ether_addr(peer_addr)) {
1981			len += sizeof(struct ieee80211_mmie_16);
1982			buf_len += sizeof(struct ieee80211_mmie_16);
1983		} else {
1984			if (cb->ucast_cipher == WLAN_CIPHER_SUITE_GCMP ||
1985			    cb->ucast_cipher == WLAN_CIPHER_SUITE_GCMP_256) {
1986				len += IEEE80211_GCMP_MIC_LEN;
1987				buf_len += IEEE80211_GCMP_MIC_LEN;
1988			} else {
1989				len += IEEE80211_CCMP_MIC_LEN;
1990				buf_len += IEEE80211_CCMP_MIC_LEN;
1991			}
1992		}
1993	}
1994
1995	len = round_up(len, 4);
1996
1997	skb = ath10k_wmi_alloc_skb(ar, len);
1998	if (!skb)
1999		return ERR_PTR(-ENOMEM);
2000
2001	cmd = (struct wmi_mgmt_tx_cmd *)skb->data;
2002
2003	cmd->hdr.vdev_id = __cpu_to_le32(vdev_id);
2004	cmd->hdr.tx_rate = 0;
2005	cmd->hdr.tx_power = 0;
2006	cmd->hdr.buf_len = __cpu_to_le32(buf_len);
2007
2008	ether_addr_copy(cmd->hdr.peer_macaddr.addr, ieee80211_get_DA(hdr));
2009	memcpy(cmd->buf, msdu->data, msdu->len);
2010
2011	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi mgmt tx skb %pK len %d ftype %02x stype %02x\n",
2012		   msdu, skb->len, fc & IEEE80211_FCTL_FTYPE,
2013		   fc & IEEE80211_FCTL_STYPE);
2014	trace_ath10k_tx_hdr(ar, skb->data, skb->len);
2015	trace_ath10k_tx_payload(ar, skb->data, skb->len);
2016
2017	return skb;
2018}
2019
2020static void ath10k_wmi_event_scan_started(struct ath10k *ar)
2021{
2022	lockdep_assert_held(&ar->data_lock);
2023
2024	switch (ar->scan.state) {
2025	case ATH10K_SCAN_IDLE:
2026	case ATH10K_SCAN_RUNNING:
2027	case ATH10K_SCAN_ABORTING:
2028		ath10k_warn(ar, "received scan started event in an invalid scan state: %s (%d)\n",
2029			    ath10k_scan_state_str(ar->scan.state),
2030			    ar->scan.state);
2031		break;
2032	case ATH10K_SCAN_STARTING:
2033		ar->scan.state = ATH10K_SCAN_RUNNING;
2034
2035		if (ar->scan.is_roc)
2036			ieee80211_ready_on_channel(ar->hw);
2037
2038		complete(&ar->scan.started);
2039		break;
2040	}
2041}
2042
2043static void ath10k_wmi_event_scan_start_failed(struct ath10k *ar)
2044{
2045	lockdep_assert_held(&ar->data_lock);
2046
2047	switch (ar->scan.state) {
2048	case ATH10K_SCAN_IDLE:
2049	case ATH10K_SCAN_RUNNING:
2050	case ATH10K_SCAN_ABORTING:
2051		ath10k_warn(ar, "received scan start failed event in an invalid scan state: %s (%d)\n",
2052			    ath10k_scan_state_str(ar->scan.state),
2053			    ar->scan.state);
2054		break;
2055	case ATH10K_SCAN_STARTING:
2056		complete(&ar->scan.started);
2057		__ath10k_scan_finish(ar);
2058		break;
2059	}
2060}
2061
2062static void ath10k_wmi_event_scan_completed(struct ath10k *ar)
2063{
2064	lockdep_assert_held(&ar->data_lock);
2065
2066	switch (ar->scan.state) {
2067	case ATH10K_SCAN_IDLE:
2068	case ATH10K_SCAN_STARTING:
2069		/* One suspected reason scan can be completed while starting is
2070		 * if firmware fails to deliver all scan events to the host,
2071		 * e.g. when transport pipe is full. This has been observed
2072		 * with spectral scan phyerr events starving wmi transport
2073		 * pipe. In such case the "scan completed" event should be (and
2074		 * is) ignored by the host as it may be just firmware's scan
2075		 * state machine recovering.
2076		 */
2077		ath10k_warn(ar, "received scan completed event in an invalid scan state: %s (%d)\n",
2078			    ath10k_scan_state_str(ar->scan.state),
2079			    ar->scan.state);
2080		break;
2081	case ATH10K_SCAN_RUNNING:
2082	case ATH10K_SCAN_ABORTING:
2083		__ath10k_scan_finish(ar);
2084		break;
2085	}
2086}
2087
2088static void ath10k_wmi_event_scan_bss_chan(struct ath10k *ar)
2089{
2090	lockdep_assert_held(&ar->data_lock);
2091
2092	switch (ar->scan.state) {
2093	case ATH10K_SCAN_IDLE:
2094	case ATH10K_SCAN_STARTING:
2095		ath10k_warn(ar, "received scan bss chan event in an invalid scan state: %s (%d)\n",
2096			    ath10k_scan_state_str(ar->scan.state),
2097			    ar->scan.state);
2098		break;
2099	case ATH10K_SCAN_RUNNING:
2100	case ATH10K_SCAN_ABORTING:
2101		ar->scan_channel = NULL;
2102		break;
2103	}
2104}
2105
2106static void ath10k_wmi_event_scan_foreign_chan(struct ath10k *ar, u32 freq)
2107{
2108	lockdep_assert_held(&ar->data_lock);
2109
2110	switch (ar->scan.state) {
2111	case ATH10K_SCAN_IDLE:
2112	case ATH10K_SCAN_STARTING:
2113		ath10k_warn(ar, "received scan foreign chan event in an invalid scan state: %s (%d)\n",
2114			    ath10k_scan_state_str(ar->scan.state),
2115			    ar->scan.state);
2116		break;
2117	case ATH10K_SCAN_RUNNING:
2118	case ATH10K_SCAN_ABORTING:
2119		ar->scan_channel = ieee80211_get_channel(ar->hw->wiphy, freq);
2120
2121		if (ar->scan.is_roc && ar->scan.roc_freq == freq)
2122			complete(&ar->scan.on_channel);
2123		break;
2124	}
2125}
2126
2127static const char *
2128ath10k_wmi_event_scan_type_str(enum wmi_scan_event_type type,
2129			       enum wmi_scan_completion_reason reason)
2130{
2131	switch (type) {
2132	case WMI_SCAN_EVENT_STARTED:
2133		return "started";
2134	case WMI_SCAN_EVENT_COMPLETED:
2135		switch (reason) {
2136		case WMI_SCAN_REASON_COMPLETED:
2137			return "completed";
2138		case WMI_SCAN_REASON_CANCELLED:
2139			return "completed [cancelled]";
2140		case WMI_SCAN_REASON_PREEMPTED:
2141			return "completed [preempted]";
2142		case WMI_SCAN_REASON_TIMEDOUT:
2143			return "completed [timedout]";
2144		case WMI_SCAN_REASON_INTERNAL_FAILURE:
2145			return "completed [internal err]";
2146		case WMI_SCAN_REASON_MAX:
2147			break;
2148		}
2149		return "completed [unknown]";
2150	case WMI_SCAN_EVENT_BSS_CHANNEL:
2151		return "bss channel";
2152	case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
2153		return "foreign channel";
2154	case WMI_SCAN_EVENT_DEQUEUED:
2155		return "dequeued";
2156	case WMI_SCAN_EVENT_PREEMPTED:
2157		return "preempted";
2158	case WMI_SCAN_EVENT_START_FAILED:
2159		return "start failed";
2160	case WMI_SCAN_EVENT_RESTARTED:
2161		return "restarted";
2162	case WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT:
2163		return "foreign channel exit";
2164	default:
2165		return "unknown";
2166	}
2167}
2168
2169static int ath10k_wmi_op_pull_scan_ev(struct ath10k *ar, struct sk_buff *skb,
2170				      struct wmi_scan_ev_arg *arg)
2171{
2172	struct wmi_scan_event *ev = (void *)skb->data;
2173
2174	if (skb->len < sizeof(*ev))
2175		return -EPROTO;
2176
2177	skb_pull(skb, sizeof(*ev));
2178	arg->event_type = ev->event_type;
2179	arg->reason = ev->reason;
2180	arg->channel_freq = ev->channel_freq;
2181	arg->scan_req_id = ev->scan_req_id;
2182	arg->scan_id = ev->scan_id;
2183	arg->vdev_id = ev->vdev_id;
2184
2185	return 0;
2186}
2187
2188int ath10k_wmi_event_scan(struct ath10k *ar, struct sk_buff *skb)
2189{
2190	struct wmi_scan_ev_arg arg = {};
2191	enum wmi_scan_event_type event_type;
2192	enum wmi_scan_completion_reason reason;
2193	u32 freq;
2194	u32 req_id;
2195	u32 scan_id;
2196	u32 vdev_id;
2197	int ret;
2198
2199	ret = ath10k_wmi_pull_scan(ar, skb, &arg);
2200	if (ret) {
2201		ath10k_warn(ar, "failed to parse scan event: %d\n", ret);
2202		return ret;
2203	}
2204
2205	event_type = __le32_to_cpu(arg.event_type);
2206	reason = __le32_to_cpu(arg.reason);
2207	freq = __le32_to_cpu(arg.channel_freq);
2208	req_id = __le32_to_cpu(arg.scan_req_id);
2209	scan_id = __le32_to_cpu(arg.scan_id);
2210	vdev_id = __le32_to_cpu(arg.vdev_id);
2211
2212	spin_lock_bh(&ar->data_lock);
2213
2214	ath10k_dbg(ar, ATH10K_DBG_WMI,
2215		   "scan event %s type %d reason %d freq %d req_id %d scan_id %d vdev_id %d state %s (%d)\n",
2216		   ath10k_wmi_event_scan_type_str(event_type, reason),
2217		   event_type, reason, freq, req_id, scan_id, vdev_id,
2218		   ath10k_scan_state_str(ar->scan.state), ar->scan.state);
2219
2220	switch (event_type) {
2221	case WMI_SCAN_EVENT_STARTED:
2222		ath10k_wmi_event_scan_started(ar);
2223		break;
2224	case WMI_SCAN_EVENT_COMPLETED:
2225		ath10k_wmi_event_scan_completed(ar);
2226		break;
2227	case WMI_SCAN_EVENT_BSS_CHANNEL:
2228		ath10k_wmi_event_scan_bss_chan(ar);
2229		break;
2230	case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
2231		ath10k_wmi_event_scan_foreign_chan(ar, freq);
2232		break;
2233	case WMI_SCAN_EVENT_START_FAILED:
2234		ath10k_warn(ar, "received scan start failure event\n");
2235		ath10k_wmi_event_scan_start_failed(ar);
2236		break;
2237	case WMI_SCAN_EVENT_DEQUEUED:
2238	case WMI_SCAN_EVENT_PREEMPTED:
2239	case WMI_SCAN_EVENT_RESTARTED:
2240	case WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT:
2241	default:
2242		break;
2243	}
2244
2245	spin_unlock_bh(&ar->data_lock);
2246	return 0;
2247}
2248
2249/* If keys are configured, HW decrypts all frames
2250 * with protected bit set. Mark such frames as decrypted.
2251 */
2252static void ath10k_wmi_handle_wep_reauth(struct ath10k *ar,
2253					 struct sk_buff *skb,
2254					 struct ieee80211_rx_status *status)
2255{
2256	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2257	unsigned int hdrlen;
2258	bool peer_key;
2259	u8 *addr, keyidx;
2260
2261	if (!ieee80211_is_auth(hdr->frame_control) ||
2262	    !ieee80211_has_protected(hdr->frame_control))
2263		return;
2264
2265	hdrlen = ieee80211_hdrlen(hdr->frame_control);
2266	if (skb->len < (hdrlen + IEEE80211_WEP_IV_LEN))
2267		return;
2268
2269	keyidx = skb->data[hdrlen + (IEEE80211_WEP_IV_LEN - 1)] >> WEP_KEYID_SHIFT;
2270	addr = ieee80211_get_SA(hdr);
2271
2272	spin_lock_bh(&ar->data_lock);
2273	peer_key = ath10k_mac_is_peer_wep_key_set(ar, addr, keyidx);
2274	spin_unlock_bh(&ar->data_lock);
2275
2276	if (peer_key) {
2277		ath10k_dbg(ar, ATH10K_DBG_MAC,
2278			   "mac wep key present for peer %pM\n", addr);
2279		status->flag |= RX_FLAG_DECRYPTED;
2280	}
2281}
2282
2283static int ath10k_wmi_op_pull_mgmt_rx_ev(struct ath10k *ar, struct sk_buff *skb,
2284					 struct wmi_mgmt_rx_ev_arg *arg)
2285{
2286	struct wmi_mgmt_rx_event_v1 *ev_v1;
2287	struct wmi_mgmt_rx_event_v2 *ev_v2;
2288	struct wmi_mgmt_rx_hdr_v1 *ev_hdr;
2289	struct wmi_mgmt_rx_ext_info *ext_info;
2290	size_t pull_len;
2291	u32 msdu_len;
2292	u32 len;
2293
2294	if (test_bit(ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX,
2295		     ar->running_fw->fw_file.fw_features)) {
2296		ev_v2 = (struct wmi_mgmt_rx_event_v2 *)skb->data;
2297		ev_hdr = &ev_v2->hdr.v1;
2298		pull_len = sizeof(*ev_v2);
2299	} else {
2300		ev_v1 = (struct wmi_mgmt_rx_event_v1 *)skb->data;
2301		ev_hdr = &ev_v1->hdr;
2302		pull_len = sizeof(*ev_v1);
2303	}
2304
2305	if (skb->len < pull_len)
2306		return -EPROTO;
2307
2308	skb_pull(skb, pull_len);
2309	arg->channel = ev_hdr->channel;
2310	arg->buf_len = ev_hdr->buf_len;
2311	arg->status = ev_hdr->status;
2312	arg->snr = ev_hdr->snr;
2313	arg->phy_mode = ev_hdr->phy_mode;
2314	arg->rate = ev_hdr->rate;
2315
2316	msdu_len = __le32_to_cpu(arg->buf_len);
2317	if (skb->len < msdu_len)
2318		return -EPROTO;
2319
2320	if (le32_to_cpu(arg->status) & WMI_RX_STATUS_EXT_INFO) {
2321		len = ALIGN(le32_to_cpu(arg->buf_len), 4);
2322		ext_info = (struct wmi_mgmt_rx_ext_info *)(skb->data + len);
2323		memcpy(&arg->ext_info, ext_info,
2324		       sizeof(struct wmi_mgmt_rx_ext_info));
2325	}
2326	/* the WMI buffer might've ended up being padded to 4 bytes due to HTC
2327	 * trailer with credit update. Trim the excess garbage.
2328	 */
2329	skb_trim(skb, msdu_len);
2330
2331	return 0;
2332}
2333
2334static int ath10k_wmi_10_4_op_pull_mgmt_rx_ev(struct ath10k *ar,
2335					      struct sk_buff *skb,
2336					      struct wmi_mgmt_rx_ev_arg *arg)
2337{
2338	struct wmi_10_4_mgmt_rx_event *ev;
2339	struct wmi_10_4_mgmt_rx_hdr *ev_hdr;
2340	size_t pull_len;
2341	u32 msdu_len;
2342	struct wmi_mgmt_rx_ext_info *ext_info;
2343	u32 len;
2344
2345	ev = (struct wmi_10_4_mgmt_rx_event *)skb->data;
2346	ev_hdr = &ev->hdr;
2347	pull_len = sizeof(*ev);
2348
2349	if (skb->len < pull_len)
2350		return -EPROTO;
2351
2352	skb_pull(skb, pull_len);
2353	arg->channel = ev_hdr->channel;
2354	arg->buf_len = ev_hdr->buf_len;
2355	arg->status = ev_hdr->status;
2356	arg->snr = ev_hdr->snr;
2357	arg->phy_mode = ev_hdr->phy_mode;
2358	arg->rate = ev_hdr->rate;
2359
2360	msdu_len = __le32_to_cpu(arg->buf_len);
2361	if (skb->len < msdu_len)
2362		return -EPROTO;
2363
2364	if (le32_to_cpu(arg->status) & WMI_RX_STATUS_EXT_INFO) {
2365		len = ALIGN(le32_to_cpu(arg->buf_len), 4);
2366		ext_info = (struct wmi_mgmt_rx_ext_info *)(skb->data + len);
2367		memcpy(&arg->ext_info, ext_info,
2368		       sizeof(struct wmi_mgmt_rx_ext_info));
2369	}
2370
2371	/* Make sure bytes added for padding are removed. */
2372	skb_trim(skb, msdu_len);
2373
2374	return 0;
2375}
2376
2377static bool ath10k_wmi_rx_is_decrypted(struct ath10k *ar,
2378				       struct ieee80211_hdr *hdr)
2379{
2380	if (!ieee80211_has_protected(hdr->frame_control))
2381		return false;
2382
2383	/* FW delivers WEP Shared Auth frame with Protected Bit set and
2384	 * encrypted payload. However in case of PMF it delivers decrypted
2385	 * frames with Protected Bit set.
2386	 */
2387	if (ieee80211_is_auth(hdr->frame_control))
2388		return false;
2389
2390	/* qca99x0 based FW delivers broadcast or multicast management frames
2391	 * (ex: group privacy action frames in mesh) as encrypted payload.
2392	 */
2393	if (is_multicast_ether_addr(ieee80211_get_DA(hdr)) &&
2394	    ar->hw_params.sw_decrypt_mcast_mgmt)
2395		return false;
2396
2397	return true;
2398}
2399
2400static int
2401wmi_process_mgmt_tx_comp(struct ath10k *ar, struct mgmt_tx_compl_params *param)
2402{
2403	struct ath10k_mgmt_tx_pkt_addr *pkt_addr;
2404	struct ath10k_wmi *wmi = &ar->wmi;
2405	struct ieee80211_tx_info *info;
2406	struct sk_buff *msdu;
2407	int ret;
2408
2409	spin_lock_bh(&ar->data_lock);
2410
2411	pkt_addr = idr_find(&wmi->mgmt_pending_tx, param->desc_id);
2412	if (!pkt_addr) {
2413		ath10k_warn(ar, "received mgmt tx completion for invalid msdu_id: %d\n",
2414			    param->desc_id);
2415		ret = -ENOENT;
2416		goto out;
2417	}
2418
2419	msdu = pkt_addr->vaddr;
2420	dma_unmap_single(ar->dev, pkt_addr->paddr,
2421			 msdu->len, DMA_TO_DEVICE);
2422	info = IEEE80211_SKB_CB(msdu);
2423
2424	if (param->status) {
2425		info->flags &= ~IEEE80211_TX_STAT_ACK;
2426	} else {
2427		info->flags |= IEEE80211_TX_STAT_ACK;
2428		info->status.ack_signal = ATH10K_DEFAULT_NOISE_FLOOR +
2429					  param->ack_rssi;
2430		info->status.flags |= IEEE80211_TX_STATUS_ACK_SIGNAL_VALID;
2431	}
2432
2433	ieee80211_tx_status_irqsafe(ar->hw, msdu);
2434
2435	ret = 0;
2436
2437out:
2438	idr_remove(&wmi->mgmt_pending_tx, param->desc_id);
2439	spin_unlock_bh(&ar->data_lock);
2440	return ret;
2441}
2442
2443int ath10k_wmi_event_mgmt_tx_compl(struct ath10k *ar, struct sk_buff *skb)
2444{
2445	struct wmi_tlv_mgmt_tx_compl_ev_arg arg;
2446	struct mgmt_tx_compl_params param;
2447	int ret;
2448
2449	ret = ath10k_wmi_pull_mgmt_tx_compl(ar, skb, &arg);
2450	if (ret) {
2451		ath10k_warn(ar, "failed to parse mgmt comp event: %d\n", ret);
2452		return ret;
2453	}
2454
2455	memset(&param, 0, sizeof(struct mgmt_tx_compl_params));
2456	param.desc_id = __le32_to_cpu(arg.desc_id);
2457	param.status = __le32_to_cpu(arg.status);
2458
2459	if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map))
2460		param.ack_rssi = __le32_to_cpu(arg.ack_rssi);
2461
2462	wmi_process_mgmt_tx_comp(ar, &param);
2463
2464	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi tlv evnt mgmt tx completion\n");
2465
2466	return 0;
2467}
2468
2469int ath10k_wmi_event_mgmt_tx_bundle_compl(struct ath10k *ar, struct sk_buff *skb)
2470{
2471	struct wmi_tlv_mgmt_tx_bundle_compl_ev_arg arg;
2472	struct mgmt_tx_compl_params param;
2473	u32 num_reports;
2474	int i, ret;
2475
2476	ret = ath10k_wmi_pull_mgmt_tx_bundle_compl(ar, skb, &arg);
2477	if (ret) {
2478		ath10k_warn(ar, "failed to parse bundle mgmt compl event: %d\n", ret);
2479		return ret;
2480	}
2481
2482	num_reports = __le32_to_cpu(arg.num_reports);
2483
2484	for (i = 0; i < num_reports; i++) {
2485		memset(&param, 0, sizeof(struct mgmt_tx_compl_params));
2486		param.desc_id = __le32_to_cpu(arg.desc_ids[i]);
2487		param.status = __le32_to_cpu(arg.desc_ids[i]);
2488
2489		if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map))
2490			param.ack_rssi = __le32_to_cpu(arg.ack_rssi[i]);
2491		wmi_process_mgmt_tx_comp(ar, &param);
2492	}
2493
2494	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi tlv event bundle mgmt tx completion\n");
2495
2496	return 0;
2497}
2498
2499int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
2500{
2501	struct wmi_mgmt_rx_ev_arg arg = {};
2502	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
2503	struct ieee80211_hdr *hdr;
2504	struct ieee80211_supported_band *sband;
2505	u32 rx_status;
2506	u32 channel;
2507	u32 phy_mode;
2508	u32 snr, rssi;
2509	u32 rate;
2510	u16 fc;
2511	int ret, i;
2512
2513	ret = ath10k_wmi_pull_mgmt_rx(ar, skb, &arg);
2514	if (ret) {
2515		ath10k_warn(ar, "failed to parse mgmt rx event: %d\n", ret);
2516		dev_kfree_skb(skb);
2517		return ret;
2518	}
2519
2520	channel = __le32_to_cpu(arg.channel);
2521	rx_status = __le32_to_cpu(arg.status);
2522	snr = __le32_to_cpu(arg.snr);
2523	phy_mode = __le32_to_cpu(arg.phy_mode);
2524	rate = __le32_to_cpu(arg.rate);
2525
2526	memset(status, 0, sizeof(*status));
2527
2528	ath10k_dbg(ar, ATH10K_DBG_MGMT,
2529		   "event mgmt rx status %08x\n", rx_status);
2530
2531	if ((test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags)) ||
2532	    (rx_status & (WMI_RX_STATUS_ERR_DECRYPT |
2533	    WMI_RX_STATUS_ERR_KEY_CACHE_MISS | WMI_RX_STATUS_ERR_CRC))) {
2534		dev_kfree_skb(skb);
2535		return 0;
2536	}
2537
2538	if (rx_status & WMI_RX_STATUS_ERR_MIC)
2539		status->flag |= RX_FLAG_MMIC_ERROR;
2540
2541	if (rx_status & WMI_RX_STATUS_EXT_INFO) {
2542		status->mactime =
2543			__le64_to_cpu(arg.ext_info.rx_mac_timestamp);
2544		status->flag |= RX_FLAG_MACTIME_END;
2545	}
2546	/* Hardware can Rx CCK rates on 5GHz. In that case phy_mode is set to
2547	 * MODE_11B. This means phy_mode is not a reliable source for the band
2548	 * of mgmt rx.
2549	 */
2550	if (channel >= 1 && channel <= 14) {
2551		status->band = NL80211_BAND_2GHZ;
2552	} else if (channel >= 36 && channel <= ATH10K_MAX_5G_CHAN) {
2553		status->band = NL80211_BAND_5GHZ;
2554	} else {
2555		/* Shouldn't happen unless list of advertised channels to
2556		 * mac80211 has been changed.
2557		 */
2558		WARN_ON_ONCE(1);
2559		dev_kfree_skb(skb);
2560		return 0;
2561	}
2562
2563	if (phy_mode == MODE_11B && status->band == NL80211_BAND_5GHZ)
2564		ath10k_dbg(ar, ATH10K_DBG_MGMT, "wmi mgmt rx 11b (CCK) on 5GHz\n");
2565
2566	sband = &ar->mac.sbands[status->band];
2567
2568	status->freq = ieee80211_channel_to_frequency(channel, status->band);
2569	status->signal = snr + ATH10K_DEFAULT_NOISE_FLOOR;
2570
2571	BUILD_BUG_ON(ARRAY_SIZE(status->chain_signal) != ARRAY_SIZE(arg.rssi));
2572
2573	for (i = 0; i < ARRAY_SIZE(status->chain_signal); i++) {
2574		status->chains &= ~BIT(i);
2575		rssi = __le32_to_cpu(arg.rssi[i]);
2576		ath10k_dbg(ar, ATH10K_DBG_MGMT, "mgmt rssi[%d]:%d\n", i, arg.rssi[i]);
2577
2578		if (rssi != ATH10K_INVALID_RSSI && rssi != 0) {
2579			status->chain_signal[i] = ATH10K_DEFAULT_NOISE_FLOOR + rssi;
2580			status->chains |= BIT(i);
2581		}
2582	}
2583
2584	status->rate_idx = ath10k_mac_bitrate_to_idx(sband, rate / 100);
2585
2586	hdr = (struct ieee80211_hdr *)skb->data;
2587	fc = le16_to_cpu(hdr->frame_control);
2588
2589	/* Firmware is guaranteed to report all essential management frames via
2590	 * WMI while it can deliver some extra via HTT. Since there can be
2591	 * duplicates split the reporting wrt monitor/sniffing.
2592	 */
2593	status->flag |= RX_FLAG_SKIP_MONITOR;
2594
2595	ath10k_wmi_handle_wep_reauth(ar, skb, status);
2596
2597	if (ath10k_wmi_rx_is_decrypted(ar, hdr)) {
2598		status->flag |= RX_FLAG_DECRYPTED;
2599
2600		if (!ieee80211_is_action(hdr->frame_control) &&
2601		    !ieee80211_is_deauth(hdr->frame_control) &&
2602		    !ieee80211_is_disassoc(hdr->frame_control)) {
2603			status->flag |= RX_FLAG_IV_STRIPPED |
2604					RX_FLAG_MMIC_STRIPPED;
2605			hdr->frame_control = __cpu_to_le16(fc &
2606					~IEEE80211_FCTL_PROTECTED);
2607		}
2608	}
2609
2610	if (ieee80211_is_beacon(hdr->frame_control))
2611		ath10k_mac_handle_beacon(ar, skb);
2612
2613	if (ieee80211_is_beacon(hdr->frame_control) ||
2614	    ieee80211_is_probe_resp(hdr->frame_control))
2615		status->boottime_ns = ktime_get_boottime_ns();
2616
2617	ath10k_dbg(ar, ATH10K_DBG_MGMT,
2618		   "event mgmt rx skb %pK len %d ftype %02x stype %02x\n",
2619		   skb, skb->len,
2620		   fc & IEEE80211_FCTL_FTYPE, fc & IEEE80211_FCTL_STYPE);
2621
2622	ath10k_dbg(ar, ATH10K_DBG_MGMT,
2623		   "event mgmt rx freq %d band %d snr %d, rate_idx %d\n",
2624		   status->freq, status->band, status->signal,
2625		   status->rate_idx);
2626
2627	ieee80211_rx_ni(ar->hw, skb);
2628
2629	return 0;
2630}
2631
2632static int freq_to_idx(struct ath10k *ar, int freq)
2633{
2634	struct ieee80211_supported_band *sband;
2635	int band, ch, idx = 0;
2636
2637	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2638		sband = ar->hw->wiphy->bands[band];
2639		if (!sband)
2640			continue;
2641
2642		for (ch = 0; ch < sband->n_channels; ch++, idx++)
2643			if (sband->channels[ch].center_freq == freq)
2644				goto exit;
2645	}
2646
2647exit:
2648	return idx;
2649}
2650
2651static int ath10k_wmi_op_pull_ch_info_ev(struct ath10k *ar, struct sk_buff *skb,
2652					 struct wmi_ch_info_ev_arg *arg)
2653{
2654	struct wmi_chan_info_event *ev = (void *)skb->data;
2655
2656	if (skb->len < sizeof(*ev))
2657		return -EPROTO;
2658
2659	skb_pull(skb, sizeof(*ev));
2660	arg->err_code = ev->err_code;
2661	arg->freq = ev->freq;
2662	arg->cmd_flags = ev->cmd_flags;
2663	arg->noise_floor = ev->noise_floor;
2664	arg->rx_clear_count = ev->rx_clear_count;
2665	arg->cycle_count = ev->cycle_count;
2666
2667	return 0;
2668}
2669
2670static int ath10k_wmi_10_4_op_pull_ch_info_ev(struct ath10k *ar,
2671					      struct sk_buff *skb,
2672					      struct wmi_ch_info_ev_arg *arg)
2673{
2674	struct wmi_10_4_chan_info_event *ev = (void *)skb->data;
2675
2676	if (skb->len < sizeof(*ev))
2677		return -EPROTO;
2678
2679	skb_pull(skb, sizeof(*ev));
2680	arg->err_code = ev->err_code;
2681	arg->freq = ev->freq;
2682	arg->cmd_flags = ev->cmd_flags;
2683	arg->noise_floor = ev->noise_floor;
2684	arg->rx_clear_count = ev->rx_clear_count;
2685	arg->cycle_count = ev->cycle_count;
2686	arg->chan_tx_pwr_range = ev->chan_tx_pwr_range;
2687	arg->chan_tx_pwr_tp = ev->chan_tx_pwr_tp;
2688	arg->rx_frame_count = ev->rx_frame_count;
2689
2690	return 0;
2691}
2692
2693/*
2694 * Handle the channel info event for firmware which only sends one
2695 * chan_info event per scanned channel.
2696 */
2697static void ath10k_wmi_event_chan_info_unpaired(struct ath10k *ar,
2698						struct chan_info_params *params)
2699{
2700	struct survey_info *survey;
2701	int idx;
2702
2703	if (params->cmd_flags & WMI_CHAN_INFO_FLAG_COMPLETE) {
2704		ath10k_dbg(ar, ATH10K_DBG_WMI, "chan info report completed\n");
2705		return;
2706	}
2707
2708	idx = freq_to_idx(ar, params->freq);
2709	if (idx >= ARRAY_SIZE(ar->survey)) {
2710		ath10k_warn(ar, "chan info: invalid frequency %d (idx %d out of bounds)\n",
2711			    params->freq, idx);
2712		return;
2713	}
2714
2715	survey = &ar->survey[idx];
2716
2717	if (!params->mac_clk_mhz)
2718		return;
2719
2720	memset(survey, 0, sizeof(*survey));
2721
2722	survey->noise = params->noise_floor;
2723	survey->time = (params->cycle_count / params->mac_clk_mhz) / 1000;
2724	survey->time_busy = (params->rx_clear_count / params->mac_clk_mhz) / 1000;
2725	survey->filled |= SURVEY_INFO_NOISE_DBM | SURVEY_INFO_TIME |
2726			  SURVEY_INFO_TIME_BUSY;
2727}
2728
2729/*
2730 * Handle the channel info event for firmware which sends chan_info
2731 * event in pairs(start and stop events) for every scanned channel.
2732 */
2733static void ath10k_wmi_event_chan_info_paired(struct ath10k *ar,
2734					      struct chan_info_params *params)
2735{
2736	struct survey_info *survey;
2737	int idx;
2738
2739	idx = freq_to_idx(ar, params->freq);
2740	if (idx >= ARRAY_SIZE(ar->survey)) {
2741		ath10k_warn(ar, "chan info: invalid frequency %d (idx %d out of bounds)\n",
2742			    params->freq, idx);
2743		return;
2744	}
2745
2746	if (params->cmd_flags & WMI_CHAN_INFO_FLAG_COMPLETE) {
2747		if (ar->ch_info_can_report_survey) {
2748			survey = &ar->survey[idx];
2749			survey->noise = params->noise_floor;
2750			survey->filled = SURVEY_INFO_NOISE_DBM;
2751
2752			ath10k_hw_fill_survey_time(ar,
2753						   survey,
2754						   params->cycle_count,
2755						   params->rx_clear_count,
2756						   ar->survey_last_cycle_count,
2757						   ar->survey_last_rx_clear_count);
2758		}
2759
2760		ar->ch_info_can_report_survey = false;
2761	} else {
2762		ar->ch_info_can_report_survey = true;
2763	}
2764
2765	if (!(params->cmd_flags & WMI_CHAN_INFO_FLAG_PRE_COMPLETE)) {
2766		ar->survey_last_rx_clear_count = params->rx_clear_count;
2767		ar->survey_last_cycle_count = params->cycle_count;
2768	}
2769}
2770
2771void ath10k_wmi_event_chan_info(struct ath10k *ar, struct sk_buff *skb)
2772{
2773	struct chan_info_params ch_info_param;
2774	struct wmi_ch_info_ev_arg arg = {};
2775	int ret;
2776
2777	ret = ath10k_wmi_pull_ch_info(ar, skb, &arg);
2778	if (ret) {
2779		ath10k_warn(ar, "failed to parse chan info event: %d\n", ret);
2780		return;
2781	}
2782
2783	ch_info_param.err_code = __le32_to_cpu(arg.err_code);
2784	ch_info_param.freq = __le32_to_cpu(arg.freq);
2785	ch_info_param.cmd_flags = __le32_to_cpu(arg.cmd_flags);
2786	ch_info_param.noise_floor = __le32_to_cpu(arg.noise_floor);
2787	ch_info_param.rx_clear_count = __le32_to_cpu(arg.rx_clear_count);
2788	ch_info_param.cycle_count = __le32_to_cpu(arg.cycle_count);
2789	ch_info_param.mac_clk_mhz = __le32_to_cpu(arg.mac_clk_mhz);
2790
2791	ath10k_dbg(ar, ATH10K_DBG_WMI,
2792		   "chan info err_code %d freq %d cmd_flags %d noise_floor %d rx_clear_count %d cycle_count %d\n",
2793		   ch_info_param.err_code, ch_info_param.freq, ch_info_param.cmd_flags,
2794		   ch_info_param.noise_floor, ch_info_param.rx_clear_count,
2795		   ch_info_param.cycle_count);
2796
2797	spin_lock_bh(&ar->data_lock);
2798
2799	switch (ar->scan.state) {
2800	case ATH10K_SCAN_IDLE:
2801	case ATH10K_SCAN_STARTING:
2802		ath10k_dbg(ar, ATH10K_DBG_WMI, "received chan info event without a scan request, ignoring\n");
2803		goto exit;
2804	case ATH10K_SCAN_RUNNING:
2805	case ATH10K_SCAN_ABORTING:
2806		break;
2807	}
2808
2809	if (test_bit(ATH10K_FW_FEATURE_SINGLE_CHAN_INFO_PER_CHANNEL,
2810		     ar->running_fw->fw_file.fw_features))
2811		ath10k_wmi_event_chan_info_unpaired(ar, &ch_info_param);
2812	else
2813		ath10k_wmi_event_chan_info_paired(ar, &ch_info_param);
2814
2815exit:
2816	spin_unlock_bh(&ar->data_lock);
2817}
2818
2819void ath10k_wmi_event_echo(struct ath10k *ar, struct sk_buff *skb)
2820{
2821	struct wmi_echo_ev_arg arg = {};
2822	int ret;
2823
2824	ret = ath10k_wmi_pull_echo_ev(ar, skb, &arg);
2825	if (ret) {
2826		ath10k_warn(ar, "failed to parse echo: %d\n", ret);
2827		return;
2828	}
2829
2830	ath10k_dbg(ar, ATH10K_DBG_WMI,
2831		   "wmi event echo value 0x%08x\n",
2832		   le32_to_cpu(arg.value));
2833
2834	if (le32_to_cpu(arg.value) == ATH10K_WMI_BARRIER_ECHO_ID)
2835		complete(&ar->wmi.barrier);
2836}
2837
2838int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb)
2839{
2840	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi event debug mesg len %d\n",
2841		   skb->len);
2842
2843	trace_ath10k_wmi_dbglog(ar, skb->data, skb->len);
2844
2845	return 0;
2846}
2847
2848void ath10k_wmi_pull_pdev_stats_base(const struct wmi_pdev_stats_base *src,
2849				     struct ath10k_fw_stats_pdev *dst)
2850{
2851	dst->ch_noise_floor = __le32_to_cpu(src->chan_nf);
2852	dst->tx_frame_count = __le32_to_cpu(src->tx_frame_count);
2853	dst->rx_frame_count = __le32_to_cpu(src->rx_frame_count);
2854	dst->rx_clear_count = __le32_to_cpu(src->rx_clear_count);
2855	dst->cycle_count = __le32_to_cpu(src->cycle_count);
2856	dst->phy_err_count = __le32_to_cpu(src->phy_err_count);
2857	dst->chan_tx_power = __le32_to_cpu(src->chan_tx_pwr);
2858}
2859
2860void ath10k_wmi_pull_pdev_stats_tx(const struct wmi_pdev_stats_tx *src,
2861				   struct ath10k_fw_stats_pdev *dst)
2862{
2863	dst->comp_queued = __le32_to_cpu(src->comp_queued);
2864	dst->comp_delivered = __le32_to_cpu(src->comp_delivered);
2865	dst->msdu_enqued = __le32_to_cpu(src->msdu_enqued);
2866	dst->mpdu_enqued = __le32_to_cpu(src->mpdu_enqued);
2867	dst->wmm_drop = __le32_to_cpu(src->wmm_drop);
2868	dst->local_enqued = __le32_to_cpu(src->local_enqued);
2869	dst->local_freed = __le32_to_cpu(src->local_freed);
2870	dst->hw_queued = __le32_to_cpu(src->hw_queued);
2871	dst->hw_reaped = __le32_to_cpu(src->hw_reaped);
2872	dst->underrun = __le32_to_cpu(src->underrun);
2873	dst->tx_abort = __le32_to_cpu(src->tx_abort);
2874	dst->mpdus_requeued = __le32_to_cpu(src->mpdus_requeued);
2875	dst->tx_ko = __le32_to_cpu(src->tx_ko);
2876	dst->data_rc = __le32_to_cpu(src->data_rc);
2877	dst->self_triggers = __le32_to_cpu(src->self_triggers);
2878	dst->sw_retry_failure = __le32_to_cpu(src->sw_retry_failure);
2879	dst->illgl_rate_phy_err = __le32_to_cpu(src->illgl_rate_phy_err);
2880	dst->pdev_cont_xretry = __le32_to_cpu(src->pdev_cont_xretry);
2881	dst->pdev_tx_timeout = __le32_to_cpu(src->pdev_tx_timeout);
2882	dst->pdev_resets = __le32_to_cpu(src->pdev_resets);
2883	dst->phy_underrun = __le32_to_cpu(src->phy_underrun);
2884	dst->txop_ovf = __le32_to_cpu(src->txop_ovf);
2885}
2886
2887static void
2888ath10k_wmi_10_4_pull_pdev_stats_tx(const struct wmi_10_4_pdev_stats_tx *src,
2889				   struct ath10k_fw_stats_pdev *dst)
2890{
2891	dst->comp_queued = __le32_to_cpu(src->comp_queued);
2892	dst->comp_delivered = __le32_to_cpu(src->comp_delivered);
2893	dst->msdu_enqued = __le32_to_cpu(src->msdu_enqued);
2894	dst->mpdu_enqued = __le32_to_cpu(src->mpdu_enqued);
2895	dst->wmm_drop = __le32_to_cpu(src->wmm_drop);
2896	dst->local_enqued = __le32_to_cpu(src->local_enqued);
2897	dst->local_freed = __le32_to_cpu(src->local_freed);
2898	dst->hw_queued = __le32_to_cpu(src->hw_queued);
2899	dst->hw_reaped = __le32_to_cpu(src->hw_reaped);
2900	dst->underrun = __le32_to_cpu(src->underrun);
2901	dst->tx_abort = __le32_to_cpu(src->tx_abort);
2902	dst->mpdus_requeued = __le32_to_cpu(src->mpdus_requeued);
2903	dst->tx_ko = __le32_to_cpu(src->tx_ko);
2904	dst->data_rc = __le32_to_cpu(src->data_rc);
2905	dst->self_triggers = __le32_to_cpu(src->self_triggers);
2906	dst->sw_retry_failure = __le32_to_cpu(src->sw_retry_failure);
2907	dst->illgl_rate_phy_err = __le32_to_cpu(src->illgl_rate_phy_err);
2908	dst->pdev_cont_xretry = __le32_to_cpu(src->pdev_cont_xretry);
2909	dst->pdev_tx_timeout = __le32_to_cpu(src->pdev_tx_timeout);
2910	dst->pdev_resets = __le32_to_cpu(src->pdev_resets);
2911	dst->phy_underrun = __le32_to_cpu(src->phy_underrun);
2912	dst->txop_ovf = __le32_to_cpu(src->txop_ovf);
2913	dst->hw_paused = __le32_to_cpu(src->hw_paused);
2914	dst->seq_posted = __le32_to_cpu(src->seq_posted);
2915	dst->seq_failed_queueing =
2916		__le32_to_cpu(src->seq_failed_queueing);
2917	dst->seq_completed = __le32_to_cpu(src->seq_completed);
2918	dst->seq_restarted = __le32_to_cpu(src->seq_restarted);
2919	dst->mu_seq_posted = __le32_to_cpu(src->mu_seq_posted);
2920	dst->mpdus_sw_flush = __le32_to_cpu(src->mpdus_sw_flush);
2921	dst->mpdus_hw_filter = __le32_to_cpu(src->mpdus_hw_filter);
2922	dst->mpdus_truncated = __le32_to_cpu(src->mpdus_truncated);
2923	dst->mpdus_ack_failed = __le32_to_cpu(src->mpdus_ack_failed);
2924	dst->mpdus_hw_filter = __le32_to_cpu(src->mpdus_hw_filter);
2925	dst->mpdus_expired = __le32_to_cpu(src->mpdus_expired);
2926}
2927
2928void ath10k_wmi_pull_pdev_stats_rx(const struct wmi_pdev_stats_rx *src,
2929				   struct ath10k_fw_stats_pdev *dst)
2930{
2931	dst->mid_ppdu_route_change = __le32_to_cpu(src->mid_ppdu_route_change);
2932	dst->status_rcvd = __le32_to_cpu(src->status_rcvd);
2933	dst->r0_frags = __le32_to_cpu(src->r0_frags);
2934	dst->r1_frags = __le32_to_cpu(src->r1_frags);
2935	dst->r2_frags = __le32_to_cpu(src->r2_frags);
2936	dst->r3_frags = __le32_to_cpu(src->r3_frags);
2937	dst->htt_msdus = __le32_to_cpu(src->htt_msdus);
2938	dst->htt_mpdus = __le32_to_cpu(src->htt_mpdus);
2939	dst->loc_msdus = __le32_to_cpu(src->loc_msdus);
2940	dst->loc_mpdus = __le32_to_cpu(src->loc_mpdus);
2941	dst->oversize_amsdu = __le32_to_cpu(src->oversize_amsdu);
2942	dst->phy_errs = __le32_to_cpu(src->phy_errs);
2943	dst->phy_err_drop = __le32_to_cpu(src->phy_err_drop);
2944	dst->mpdu_errs = __le32_to_cpu(src->mpdu_errs);
2945}
2946
2947void ath10k_wmi_pull_pdev_stats_extra(const struct wmi_pdev_stats_extra *src,
2948				      struct ath10k_fw_stats_pdev *dst)
2949{
2950	dst->ack_rx_bad = __le32_to_cpu(src->ack_rx_bad);
2951	dst->rts_bad = __le32_to_cpu(src->rts_bad);
2952	dst->rts_good = __le32_to_cpu(src->rts_good);
2953	dst->fcs_bad = __le32_to_cpu(src->fcs_bad);
2954	dst->no_beacons = __le32_to_cpu(src->no_beacons);
2955	dst->mib_int_count = __le32_to_cpu(src->mib_int_count);
2956}
2957
2958void ath10k_wmi_pull_peer_stats(const struct wmi_peer_stats *src,
2959				struct ath10k_fw_stats_peer *dst)
2960{
2961	ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);
2962	dst->peer_rssi = __le32_to_cpu(src->peer_rssi);
2963	dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);
2964}
2965
2966static void
2967ath10k_wmi_10_4_pull_peer_stats(const struct wmi_10_4_peer_stats *src,
2968				struct ath10k_fw_stats_peer *dst)
2969{
2970	ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);
2971	dst->peer_rssi = __le32_to_cpu(src->peer_rssi);
2972	dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);
2973	dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);
2974}
2975
2976static void
2977ath10k_wmi_10_4_pull_vdev_stats(const struct wmi_vdev_stats_extd *src,
2978				struct ath10k_fw_stats_vdev_extd *dst)
2979{
2980	dst->vdev_id = __le32_to_cpu(src->vdev_id);
2981	dst->ppdu_aggr_cnt = __le32_to_cpu(src->ppdu_aggr_cnt);
2982	dst->ppdu_noack = __le32_to_cpu(src->ppdu_noack);
2983	dst->mpdu_queued = __le32_to_cpu(src->mpdu_queued);
2984	dst->ppdu_nonaggr_cnt = __le32_to_cpu(src->ppdu_nonaggr_cnt);
2985	dst->mpdu_sw_requeued = __le32_to_cpu(src->mpdu_sw_requeued);
2986	dst->mpdu_suc_retry = __le32_to_cpu(src->mpdu_suc_retry);
2987	dst->mpdu_suc_multitry = __le32_to_cpu(src->mpdu_suc_multitry);
2988	dst->mpdu_fail_retry = __le32_to_cpu(src->mpdu_fail_retry);
2989	dst->tx_ftm_suc = __le32_to_cpu(src->tx_ftm_suc);
2990	dst->tx_ftm_suc_retry = __le32_to_cpu(src->tx_ftm_suc_retry);
2991	dst->tx_ftm_fail = __le32_to_cpu(src->tx_ftm_fail);
2992	dst->rx_ftmr_cnt = __le32_to_cpu(src->rx_ftmr_cnt);
2993	dst->rx_ftmr_dup_cnt = __le32_to_cpu(src->rx_ftmr_dup_cnt);
2994	dst->rx_iftmr_cnt = __le32_to_cpu(src->rx_iftmr_cnt);
2995	dst->rx_iftmr_dup_cnt = __le32_to_cpu(src->rx_iftmr_dup_cnt);
2996}
2997
2998static int ath10k_wmi_main_op_pull_fw_stats(struct ath10k *ar,
2999					    struct sk_buff *skb,
3000					    struct ath10k_fw_stats *stats)
3001{
3002	const struct wmi_stats_event *ev = (void *)skb->data;
3003	u32 num_pdev_stats, num_peer_stats;
3004	int i;
3005
3006	if (!skb_pull(skb, sizeof(*ev)))
3007		return -EPROTO;
3008
3009	num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats);
3010	num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
3011
3012	for (i = 0; i < num_pdev_stats; i++) {
3013		const struct wmi_pdev_stats *src;
3014		struct ath10k_fw_stats_pdev *dst;
3015
3016		src = (void *)skb->data;
3017		if (!skb_pull(skb, sizeof(*src)))
3018			return -EPROTO;
3019
3020		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3021		if (!dst)
3022			continue;
3023
3024		ath10k_wmi_pull_pdev_stats_base(&src->base, dst);
3025		ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);
3026		ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);
3027
3028		list_add_tail(&dst->list, &stats->pdevs);
3029	}
3030
3031	/* fw doesn't implement vdev stats */
3032
3033	for (i = 0; i < num_peer_stats; i++) {
3034		const struct wmi_peer_stats *src;
3035		struct ath10k_fw_stats_peer *dst;
3036
3037		src = (void *)skb->data;
3038		if (!skb_pull(skb, sizeof(*src)))
3039			return -EPROTO;
3040
3041		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3042		if (!dst)
3043			continue;
3044
3045		ath10k_wmi_pull_peer_stats(src, dst);
3046		list_add_tail(&dst->list, &stats->peers);
3047	}
3048
3049	return 0;
3050}
3051
3052static int ath10k_wmi_10x_op_pull_fw_stats(struct ath10k *ar,
3053					   struct sk_buff *skb,
3054					   struct ath10k_fw_stats *stats)
3055{
3056	const struct wmi_stats_event *ev = (void *)skb->data;
3057	u32 num_pdev_stats, num_peer_stats;
3058	int i;
3059
3060	if (!skb_pull(skb, sizeof(*ev)))
3061		return -EPROTO;
3062
3063	num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats);
3064	num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
3065
3066	for (i = 0; i < num_pdev_stats; i++) {
3067		const struct wmi_10x_pdev_stats *src;
3068		struct ath10k_fw_stats_pdev *dst;
3069
3070		src = (void *)skb->data;
3071		if (!skb_pull(skb, sizeof(*src)))
3072			return -EPROTO;
3073
3074		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3075		if (!dst)
3076			continue;
3077
3078		ath10k_wmi_pull_pdev_stats_base(&src->base, dst);
3079		ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);
3080		ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);
3081		ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);
3082
3083		list_add_tail(&dst->list, &stats->pdevs);
3084	}
3085
3086	/* fw doesn't implement vdev stats */
3087
3088	for (i = 0; i < num_peer_stats; i++) {
3089		const struct wmi_10x_peer_stats *src;
3090		struct ath10k_fw_stats_peer *dst;
3091
3092		src = (void *)skb->data;
3093		if (!skb_pull(skb, sizeof(*src)))
3094			return -EPROTO;
3095
3096		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3097		if (!dst)
3098			continue;
3099
3100		ath10k_wmi_pull_peer_stats(&src->old, dst);
3101
3102		dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);
3103
3104		list_add_tail(&dst->list, &stats->peers);
3105	}
3106
3107	return 0;
3108}
3109
3110static int ath10k_wmi_10_2_op_pull_fw_stats(struct ath10k *ar,
3111					    struct sk_buff *skb,
3112					    struct ath10k_fw_stats *stats)
3113{
3114	const struct wmi_10_2_stats_event *ev = (void *)skb->data;
3115	u32 num_pdev_stats;
3116	u32 num_pdev_ext_stats;
3117	u32 num_peer_stats;
3118	int i;
3119
3120	if (!skb_pull(skb, sizeof(*ev)))
3121		return -EPROTO;
3122
3123	num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats);
3124	num_pdev_ext_stats = __le32_to_cpu(ev->num_pdev_ext_stats);
3125	num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
3126
3127	for (i = 0; i < num_pdev_stats; i++) {
3128		const struct wmi_10_2_pdev_stats *src;
3129		struct ath10k_fw_stats_pdev *dst;
3130
3131		src = (void *)skb->data;
3132		if (!skb_pull(skb, sizeof(*src)))
3133			return -EPROTO;
3134
3135		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3136		if (!dst)
3137			continue;
3138
3139		ath10k_wmi_pull_pdev_stats_base(&src->base, dst);
3140		ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);
3141		ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);
3142		ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);
3143		/* FIXME: expose 10.2 specific values */
3144
3145		list_add_tail(&dst->list, &stats->pdevs);
3146	}
3147
3148	for (i = 0; i < num_pdev_ext_stats; i++) {
3149		const struct wmi_10_2_pdev_ext_stats *src;
3150
3151		src = (void *)skb->data;
3152		if (!skb_pull(skb, sizeof(*src)))
3153			return -EPROTO;
3154
3155		/* FIXME: expose values to userspace
3156		 *
3157		 * Note: Even though this loop seems to do nothing it is
3158		 * required to parse following sub-structures properly.
3159		 */
3160	}
3161
3162	/* fw doesn't implement vdev stats */
3163
3164	for (i = 0; i < num_peer_stats; i++) {
3165		const struct wmi_10_2_peer_stats *src;
3166		struct ath10k_fw_stats_peer *dst;
3167
3168		src = (void *)skb->data;
3169		if (!skb_pull(skb, sizeof(*src)))
3170			return -EPROTO;
3171
3172		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3173		if (!dst)
3174			continue;
3175
3176		ath10k_wmi_pull_peer_stats(&src->old, dst);
3177
3178		dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);
3179		/* FIXME: expose 10.2 specific values */
3180
3181		list_add_tail(&dst->list, &stats->peers);
3182	}
3183
3184	return 0;
3185}
3186
3187static int ath10k_wmi_10_2_4_op_pull_fw_stats(struct ath10k *ar,
3188					      struct sk_buff *skb,
3189					      struct ath10k_fw_stats *stats)
3190{
3191	const struct wmi_10_2_stats_event *ev = (void *)skb->data;
3192	u32 num_pdev_stats;
3193	u32 num_pdev_ext_stats;
3194	u32 num_peer_stats;
3195	int i;
3196
3197	if (!skb_pull(skb, sizeof(*ev)))
3198		return -EPROTO;
3199
3200	num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats);
3201	num_pdev_ext_stats = __le32_to_cpu(ev->num_pdev_ext_stats);
3202	num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
3203
3204	for (i = 0; i < num_pdev_stats; i++) {
3205		const struct wmi_10_2_pdev_stats *src;
3206		struct ath10k_fw_stats_pdev *dst;
3207
3208		src = (void *)skb->data;
3209		if (!skb_pull(skb, sizeof(*src)))
3210			return -EPROTO;
3211
3212		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3213		if (!dst)
3214			continue;
3215
3216		ath10k_wmi_pull_pdev_stats_base(&src->base, dst);
3217		ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);
3218		ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);
3219		ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);
3220		/* FIXME: expose 10.2 specific values */
3221
3222		list_add_tail(&dst->list, &stats->pdevs);
3223	}
3224
3225	for (i = 0; i < num_pdev_ext_stats; i++) {
3226		const struct wmi_10_2_pdev_ext_stats *src;
3227
3228		src = (void *)skb->data;
3229		if (!skb_pull(skb, sizeof(*src)))
3230			return -EPROTO;
3231
3232		/* FIXME: expose values to userspace
3233		 *
3234		 * Note: Even though this loop seems to do nothing it is
3235		 * required to parse following sub-structures properly.
3236		 */
3237	}
3238
3239	/* fw doesn't implement vdev stats */
3240
3241	for (i = 0; i < num_peer_stats; i++) {
3242		const struct wmi_10_2_4_ext_peer_stats *src;
3243		struct ath10k_fw_stats_peer *dst;
3244		int stats_len;
3245
3246		if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
3247			stats_len = sizeof(struct wmi_10_2_4_ext_peer_stats);
3248		else
3249			stats_len = sizeof(struct wmi_10_2_4_peer_stats);
3250
3251		src = (void *)skb->data;
3252		if (!skb_pull(skb, stats_len))
3253			return -EPROTO;
3254
3255		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3256		if (!dst)
3257			continue;
3258
3259		ath10k_wmi_pull_peer_stats(&src->common.old, dst);
3260
3261		dst->peer_rx_rate = __le32_to_cpu(src->common.peer_rx_rate);
3262
3263		if (ath10k_peer_stats_enabled(ar))
3264			dst->rx_duration = __le32_to_cpu(src->rx_duration);
3265		/* FIXME: expose 10.2 specific values */
3266
3267		list_add_tail(&dst->list, &stats->peers);
3268	}
3269
3270	return 0;
3271}
3272
3273static int ath10k_wmi_10_4_op_pull_fw_stats(struct ath10k *ar,
3274					    struct sk_buff *skb,
3275					    struct ath10k_fw_stats *stats)
3276{
3277	const struct wmi_10_2_stats_event *ev = (void *)skb->data;
3278	u32 num_pdev_stats;
3279	u32 num_pdev_ext_stats;
3280	u32 num_vdev_stats;
3281	u32 num_peer_stats;
3282	u32 num_bcnflt_stats;
3283	u32 stats_id;
3284	int i;
3285
3286	if (!skb_pull(skb, sizeof(*ev)))
3287		return -EPROTO;
3288
3289	num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats);
3290	num_pdev_ext_stats = __le32_to_cpu(ev->num_pdev_ext_stats);
3291	num_vdev_stats = __le32_to_cpu(ev->num_vdev_stats);
3292	num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
3293	num_bcnflt_stats = __le32_to_cpu(ev->num_bcnflt_stats);
3294	stats_id = __le32_to_cpu(ev->stats_id);
3295
3296	for (i = 0; i < num_pdev_stats; i++) {
3297		const struct wmi_10_4_pdev_stats *src;
3298		struct ath10k_fw_stats_pdev *dst;
3299
3300		src = (void *)skb->data;
3301		if (!skb_pull(skb, sizeof(*src)))
3302			return -EPROTO;
3303
3304		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3305		if (!dst)
3306			continue;
3307
3308		ath10k_wmi_pull_pdev_stats_base(&src->base, dst);
3309		ath10k_wmi_10_4_pull_pdev_stats_tx(&src->tx, dst);
3310		ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);
3311		dst->rx_ovfl_errs = __le32_to_cpu(src->rx_ovfl_errs);
3312		ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);
3313
3314		list_add_tail(&dst->list, &stats->pdevs);
3315	}
3316
3317	for (i = 0; i < num_pdev_ext_stats; i++) {
3318		const struct wmi_10_2_pdev_ext_stats *src;
3319
3320		src = (void *)skb->data;
3321		if (!skb_pull(skb, sizeof(*src)))
3322			return -EPROTO;
3323
3324		/* FIXME: expose values to userspace
3325		 *
3326		 * Note: Even though this loop seems to do nothing it is
3327		 * required to parse following sub-structures properly.
3328		 */
3329	}
3330
3331	for (i = 0; i < num_vdev_stats; i++) {
3332		const struct wmi_vdev_stats *src;
3333
3334		/* Ignore vdev stats here as it has only vdev id. Actual vdev
3335		 * stats will be retrieved from vdev extended stats.
3336		 */
3337		src = (void *)skb->data;
3338		if (!skb_pull(skb, sizeof(*src)))
3339			return -EPROTO;
3340	}
3341
3342	for (i = 0; i < num_peer_stats; i++) {
3343		const struct wmi_10_4_peer_stats *src;
3344		struct ath10k_fw_stats_peer *dst;
3345
3346		src = (void *)skb->data;
3347		if (!skb_pull(skb, sizeof(*src)))
3348			return -EPROTO;
3349
3350		dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3351		if (!dst)
3352			continue;
3353
3354		ath10k_wmi_10_4_pull_peer_stats(src, dst);
3355		list_add_tail(&dst->list, &stats->peers);
3356	}
3357
3358	for (i = 0; i < num_bcnflt_stats; i++) {
3359		const struct wmi_10_4_bss_bcn_filter_stats *src;
3360
3361		src = (void *)skb->data;
3362		if (!skb_pull(skb, sizeof(*src)))
3363			return -EPROTO;
3364
3365		/* FIXME: expose values to userspace
3366		 *
3367		 * Note: Even though this loop seems to do nothing it is
3368		 * required to parse following sub-structures properly.
3369		 */
3370	}
3371
3372	if (stats_id & WMI_10_4_STAT_PEER_EXTD) {
3373		stats->extended = true;
3374
3375		for (i = 0; i < num_peer_stats; i++) {
3376			const struct wmi_10_4_peer_extd_stats *src;
3377			struct ath10k_fw_extd_stats_peer *dst;
3378
3379			src = (void *)skb->data;
3380			if (!skb_pull(skb, sizeof(*src)))
3381				return -EPROTO;
3382
3383			dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3384			if (!dst)
3385				continue;
3386
3387			ether_addr_copy(dst->peer_macaddr,
3388					src->peer_macaddr.addr);
3389			dst->rx_duration = __le32_to_cpu(src->rx_duration);
3390			list_add_tail(&dst->list, &stats->peers_extd);
3391		}
3392	}
3393
3394	if (stats_id & WMI_10_4_STAT_VDEV_EXTD) {
3395		for (i = 0; i < num_vdev_stats; i++) {
3396			const struct wmi_vdev_stats_extd *src;
3397			struct ath10k_fw_stats_vdev_extd *dst;
3398
3399			src = (void *)skb->data;
3400			if (!skb_pull(skb, sizeof(*src)))
3401				return -EPROTO;
3402
3403			dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
3404			if (!dst)
3405				continue;
3406			ath10k_wmi_10_4_pull_vdev_stats(src, dst);
3407			list_add_tail(&dst->list, &stats->vdevs);
3408		}
3409	}
3410
3411	return 0;
3412}
3413
3414void ath10k_wmi_event_update_stats(struct ath10k *ar, struct sk_buff *skb)
3415{
3416	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_UPDATE_STATS_EVENTID\n");
3417	ath10k_debug_fw_stats_process(ar, skb);
3418}
3419
3420static int
3421ath10k_wmi_op_pull_vdev_start_ev(struct ath10k *ar, struct sk_buff *skb,
3422				 struct wmi_vdev_start_ev_arg *arg)
3423{
3424	struct wmi_vdev_start_response_event *ev = (void *)skb->data;
3425
3426	if (skb->len < sizeof(*ev))
3427		return -EPROTO;
3428
3429	skb_pull(skb, sizeof(*ev));
3430	arg->vdev_id = ev->vdev_id;
3431	arg->req_id = ev->req_id;
3432	arg->resp_type = ev->resp_type;
3433	arg->status = ev->status;
3434
3435	return 0;
3436}
3437
3438void ath10k_wmi_event_vdev_start_resp(struct ath10k *ar, struct sk_buff *skb)
3439{
3440	struct wmi_vdev_start_ev_arg arg = {};
3441	int ret;
3442	u32 status;
3443
3444	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_VDEV_START_RESP_EVENTID\n");
3445
3446	ar->last_wmi_vdev_start_status = 0;
3447
3448	ret = ath10k_wmi_pull_vdev_start(ar, skb, &arg);
3449	if (ret) {
3450		ath10k_warn(ar, "failed to parse vdev start event: %d\n", ret);
3451		ar->last_wmi_vdev_start_status = ret;
3452		goto out;
3453	}
3454
3455	status = __le32_to_cpu(arg.status);
3456	if (WARN_ON_ONCE(status)) {
3457		ath10k_warn(ar, "vdev-start-response reports status error: %d (%s)\n",
3458			    status, (status == WMI_VDEV_START_CHAN_INVALID) ?
3459			    "chan-invalid" : "unknown");
3460		/* Setup is done one way or another though, so we should still
3461		 * do the completion, so don't return here.
3462		 */
3463		ar->last_wmi_vdev_start_status = -EINVAL;
3464	}
3465
3466out:
3467	complete(&ar->vdev_setup_done);
3468}
3469
3470void ath10k_wmi_event_vdev_stopped(struct ath10k *ar, struct sk_buff *skb)
3471{
3472	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_VDEV_STOPPED_EVENTID\n");
3473	complete(&ar->vdev_setup_done);
3474}
3475
3476static int
3477ath10k_wmi_op_pull_peer_kick_ev(struct ath10k *ar, struct sk_buff *skb,
3478				struct wmi_peer_kick_ev_arg *arg)
3479{
3480	struct wmi_peer_sta_kickout_event *ev = (void *)skb->data;
3481
3482	if (skb->len < sizeof(*ev))
3483		return -EPROTO;
3484
3485	skb_pull(skb, sizeof(*ev));
3486	arg->mac_addr = ev->peer_macaddr.addr;
3487
3488	return 0;
3489}
3490
3491void ath10k_wmi_event_peer_sta_kickout(struct ath10k *ar, struct sk_buff *skb)
3492{
3493	struct wmi_peer_kick_ev_arg arg = {};
3494	struct ieee80211_sta *sta;
3495	int ret;
3496
3497	ret = ath10k_wmi_pull_peer_kick(ar, skb, &arg);
3498	if (ret) {
3499		ath10k_warn(ar, "failed to parse peer kickout event: %d\n",
3500			    ret);
3501		return;
3502	}
3503
3504	ath10k_dbg(ar, ATH10K_DBG_STA, "wmi event peer sta kickout %pM\n",
3505		   arg.mac_addr);
3506
3507	rcu_read_lock();
3508
3509	sta = ieee80211_find_sta_by_ifaddr(ar->hw, arg.mac_addr, NULL);
3510	if (!sta) {
3511		ath10k_warn(ar, "Spurious quick kickout for STA %pM\n",
3512			    arg.mac_addr);
3513		goto exit;
3514	}
3515
3516	ieee80211_report_low_ack(sta, 10);
3517
3518exit:
3519	rcu_read_unlock();
3520}
3521
3522/*
3523 * FIXME
3524 *
3525 * We don't report to mac80211 sleep state of connected
3526 * stations. Due to this mac80211 can't fill in TIM IE
3527 * correctly.
3528 *
3529 * I know of no way of getting nullfunc frames that contain
3530 * sleep transition from connected stations - these do not
3531 * seem to be sent from the target to the host. There also
3532 * doesn't seem to be a dedicated event for that. So the
3533 * only way left to do this would be to read tim_bitmap
3534 * during SWBA.
3535 *
3536 * We could probably try using tim_bitmap from SWBA to tell
3537 * mac80211 which stations are asleep and which are not. The
3538 * problem here is calling mac80211 functions so many times
3539 * could take too long and make us miss the time to submit
3540 * the beacon to the target.
3541 *
3542 * So as a workaround we try to extend the TIM IE if there
3543 * is unicast buffered for stations with aid > 7 and fill it
3544 * in ourselves.
3545 */
3546static void ath10k_wmi_update_tim(struct ath10k *ar,
3547				  struct ath10k_vif *arvif,
3548				  struct sk_buff *bcn,
3549				  const struct wmi_tim_info_arg *tim_info)
3550{
3551	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)bcn->data;
3552	struct ieee80211_tim_ie *tim;
3553	u8 *ies, *ie;
3554	u8 ie_len, pvm_len;
3555	__le32 t;
3556	u32 v, tim_len;
3557
3558	/* When FW reports 0 in tim_len, ensure at least first byte
3559	 * in tim_bitmap is considered for pvm calculation.
3560	 */
3561	tim_len = tim_info->tim_len ? __le32_to_cpu(tim_info->tim_len) : 1;
3562
3563	/* if next SWBA has no tim_changed the tim_bitmap is garbage.
3564	 * we must copy the bitmap upon change and reuse it later
3565	 */
3566	if (__le32_to_cpu(tim_info->tim_changed)) {
3567		int i;
3568
3569		if (sizeof(arvif->u.ap.tim_bitmap) < tim_len) {
3570			ath10k_warn(ar, "SWBA TIM field is too big (%u), truncated it to %zu",
3571				    tim_len, sizeof(arvif->u.ap.tim_bitmap));
3572			tim_len = sizeof(arvif->u.ap.tim_bitmap);
3573		}
3574
3575		for (i = 0; i < tim_len; i++) {
3576			t = tim_info->tim_bitmap[i / 4];
3577			v = __le32_to_cpu(t);
3578			arvif->u.ap.tim_bitmap[i] = (v >> ((i % 4) * 8)) & 0xFF;
3579		}
3580
3581		/* FW reports either length 0 or length based on max supported
3582		 * station. so we calculate this on our own
3583		 */
3584		arvif->u.ap.tim_len = 0;
3585		for (i = 0; i < tim_len; i++)
3586			if (arvif->u.ap.tim_bitmap[i])
3587				arvif->u.ap.tim_len = i;
3588
3589		arvif->u.ap.tim_len++;
3590	}
3591
3592	ies = bcn->data;
3593	ies += ieee80211_hdrlen(hdr->frame_control);
3594	ies += 12; /* fixed parameters */
3595
3596	ie = (u8 *)cfg80211_find_ie(WLAN_EID_TIM, ies,
3597				    (u8 *)skb_tail_pointer(bcn) - ies);
3598	if (!ie) {
3599		if (arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
3600			ath10k_warn(ar, "no tim ie found;\n");
3601		return;
3602	}
3603
3604	tim = (void *)ie + 2;
3605	ie_len = ie[1];
3606	pvm_len = ie_len - 3; /* exclude dtim count, dtim period, bmap ctl */
3607
3608	if (pvm_len < arvif->u.ap.tim_len) {
3609		int expand_size = tim_len - pvm_len;
3610		int move_size = skb_tail_pointer(bcn) - (ie + 2 + ie_len);
3611		void *next_ie = ie + 2 + ie_len;
3612
3613		if (skb_put(bcn, expand_size)) {
3614			memmove(next_ie + expand_size, next_ie, move_size);
3615
3616			ie[1] += expand_size;
3617			ie_len += expand_size;
3618			pvm_len += expand_size;
3619		} else {
3620			ath10k_warn(ar, "tim expansion failed\n");
3621		}
3622	}
3623
3624	if (pvm_len > tim_len) {
3625		ath10k_warn(ar, "tim pvm length is too great (%d)\n", pvm_len);
3626		return;
3627	}
3628
3629	tim->bitmap_ctrl = !!__le32_to_cpu(tim_info->tim_mcast);
3630	memcpy(tim->virtual_map, arvif->u.ap.tim_bitmap, pvm_len);
3631
3632	if (tim->dtim_count == 0) {
3633		ATH10K_SKB_CB(bcn)->flags |= ATH10K_SKB_F_DTIM_ZERO;
3634
3635		if (__le32_to_cpu(tim_info->tim_mcast) == 1)
3636			ATH10K_SKB_CB(bcn)->flags |= ATH10K_SKB_F_DELIVER_CAB;
3637	}
3638
3639	ath10k_dbg(ar, ATH10K_DBG_MGMT, "dtim %d/%d mcast %d pvmlen %d\n",
3640		   tim->dtim_count, tim->dtim_period,
3641		   tim->bitmap_ctrl, pvm_len);
3642}
3643
3644static void ath10k_wmi_update_noa(struct ath10k *ar, struct ath10k_vif *arvif,
3645				  struct sk_buff *bcn,
3646				  const struct wmi_p2p_noa_info *noa)
3647{
3648	if (!arvif->vif->p2p)
3649		return;
3650
3651	ath10k_dbg(ar, ATH10K_DBG_MGMT, "noa changed: %d\n", noa->changed);
3652
3653	if (noa->changed & WMI_P2P_NOA_CHANGED_BIT)
3654		ath10k_p2p_noa_update(arvif, noa);
3655
3656	if (arvif->u.ap.noa_data)
3657		if (!pskb_expand_head(bcn, 0, arvif->u.ap.noa_len, GFP_ATOMIC))
3658			skb_put_data(bcn, arvif->u.ap.noa_data,
3659				     arvif->u.ap.noa_len);
3660}
3661
3662static int ath10k_wmi_op_pull_swba_ev(struct ath10k *ar, struct sk_buff *skb,
3663				      struct wmi_swba_ev_arg *arg)
3664{
3665	struct wmi_host_swba_event *ev = (void *)skb->data;
3666	u32 map;
3667	size_t i;
3668
3669	if (skb->len < sizeof(*ev))
3670		return -EPROTO;
3671
3672	skb_pull(skb, sizeof(*ev));
3673	arg->vdev_map = ev->vdev_map;
3674
3675	for (i = 0, map = __le32_to_cpu(ev->vdev_map); map; map >>= 1) {
3676		if (!(map & BIT(0)))
3677			continue;
3678
3679		/* If this happens there were some changes in firmware and
3680		 * ath10k should update the max size of tim_info array.
3681		 */
3682		if (WARN_ON_ONCE(i == ARRAY_SIZE(arg->tim_info)))
3683			break;
3684
3685		if (__le32_to_cpu(ev->bcn_info[i].tim_info.tim_len) >
3686		     sizeof(ev->bcn_info[i].tim_info.tim_bitmap)) {
3687			ath10k_warn(ar, "refusing to parse invalid swba structure\n");
3688			return -EPROTO;
3689		}
3690
3691		arg->tim_info[i].tim_len = ev->bcn_info[i].tim_info.tim_len;
3692		arg->tim_info[i].tim_mcast = ev->bcn_info[i].tim_info.tim_mcast;
3693		arg->tim_info[i].tim_bitmap =
3694				ev->bcn_info[i].tim_info.tim_bitmap;
3695		arg->tim_info[i].tim_changed =
3696				ev->bcn_info[i].tim_info.tim_changed;
3697		arg->tim_info[i].tim_num_ps_pending =
3698				ev->bcn_info[i].tim_info.tim_num_ps_pending;
3699
3700		arg->noa_info[i] = &ev->bcn_info[i].p2p_noa_info;
3701		i++;
3702	}
3703
3704	return 0;
3705}
3706
3707static int ath10k_wmi_10_2_4_op_pull_swba_ev(struct ath10k *ar,
3708					     struct sk_buff *skb,
3709					     struct wmi_swba_ev_arg *arg)
3710{
3711	struct wmi_10_2_4_host_swba_event *ev = (void *)skb->data;
3712	u32 map;
3713	size_t i;
3714
3715	if (skb->len < sizeof(*ev))
3716		return -EPROTO;
3717
3718	skb_pull(skb, sizeof(*ev));
3719	arg->vdev_map = ev->vdev_map;
3720
3721	for (i = 0, map = __le32_to_cpu(ev->vdev_map); map; map >>= 1) {
3722		if (!(map & BIT(0)))
3723			continue;
3724
3725		/* If this happens there were some changes in firmware and
3726		 * ath10k should update the max size of tim_info array.
3727		 */
3728		if (WARN_ON_ONCE(i == ARRAY_SIZE(arg->tim_info)))
3729			break;
3730
3731		if (__le32_to_cpu(ev->bcn_info[i].tim_info.tim_len) >
3732		     sizeof(ev->bcn_info[i].tim_info.tim_bitmap)) {
3733			ath10k_warn(ar, "refusing to parse invalid swba structure\n");
3734			return -EPROTO;
3735		}
3736
3737		arg->tim_info[i].tim_len = ev->bcn_info[i].tim_info.tim_len;
3738		arg->tim_info[i].tim_mcast = ev->bcn_info[i].tim_info.tim_mcast;
3739		arg->tim_info[i].tim_bitmap =
3740				ev->bcn_info[i].tim_info.tim_bitmap;
3741		arg->tim_info[i].tim_changed =
3742				ev->bcn_info[i].tim_info.tim_changed;
3743		arg->tim_info[i].tim_num_ps_pending =
3744				ev->bcn_info[i].tim_info.tim_num_ps_pending;
3745		i++;
3746	}
3747
3748	return 0;
3749}
3750
3751static int ath10k_wmi_10_4_op_pull_swba_ev(struct ath10k *ar,
3752					   struct sk_buff *skb,
3753					   struct wmi_swba_ev_arg *arg)
3754{
3755	struct wmi_10_4_host_swba_event *ev = (void *)skb->data;
3756	u32 map, tim_len;
3757	size_t i;
3758
3759	if (skb->len < sizeof(*ev))
3760		return -EPROTO;
3761
3762	skb_pull(skb, sizeof(*ev));
3763	arg->vdev_map = ev->vdev_map;
3764
3765	for (i = 0, map = __le32_to_cpu(ev->vdev_map); map; map >>= 1) {
3766		if (!(map & BIT(0)))
3767			continue;
3768
3769		/* If this happens there were some changes in firmware and
3770		 * ath10k should update the max size of tim_info array.
3771		 */
3772		if (WARN_ON_ONCE(i == ARRAY_SIZE(arg->tim_info)))
3773			break;
3774
3775		if (__le32_to_cpu(ev->bcn_info[i].tim_info.tim_len) >
3776		      sizeof(ev->bcn_info[i].tim_info.tim_bitmap)) {
3777			ath10k_warn(ar, "refusing to parse invalid swba structure\n");
3778			return -EPROTO;
3779		}
3780
3781		tim_len = __le32_to_cpu(ev->bcn_info[i].tim_info.tim_len);
3782		if (tim_len) {
3783			/* Exclude 4 byte guard length */
3784			tim_len -= 4;
3785			arg->tim_info[i].tim_len = __cpu_to_le32(tim_len);
3786		} else {
3787			arg->tim_info[i].tim_len = 0;
3788		}
3789
3790		arg->tim_info[i].tim_mcast = ev->bcn_info[i].tim_info.tim_mcast;
3791		arg->tim_info[i].tim_bitmap =
3792				ev->bcn_info[i].tim_info.tim_bitmap;
3793		arg->tim_info[i].tim_changed =
3794				ev->bcn_info[i].tim_info.tim_changed;
3795		arg->tim_info[i].tim_num_ps_pending =
3796				ev->bcn_info[i].tim_info.tim_num_ps_pending;
3797
3798		/* 10.4 firmware doesn't have p2p support. notice of absence
3799		 * info can be ignored for now.
3800		 */
3801
3802		i++;
3803	}
3804
3805	return 0;
3806}
3807
3808static enum wmi_txbf_conf ath10k_wmi_10_4_txbf_conf_scheme(struct ath10k *ar)
3809{
3810	return WMI_TXBF_CONF_BEFORE_ASSOC;
3811}
3812
3813void ath10k_wmi_event_host_swba(struct ath10k *ar, struct sk_buff *skb)
3814{
3815	struct wmi_swba_ev_arg arg = {};
3816	u32 map;
3817	int i = -1;
3818	const struct wmi_tim_info_arg *tim_info;
3819	const struct wmi_p2p_noa_info *noa_info;
3820	struct ath10k_vif *arvif;
3821	struct sk_buff *bcn;
3822	dma_addr_t paddr;
3823	int ret, vdev_id = 0;
3824
3825	ret = ath10k_wmi_pull_swba(ar, skb, &arg);
3826	if (ret) {
3827		ath10k_warn(ar, "failed to parse swba event: %d\n", ret);
3828		return;
3829	}
3830
3831	map = __le32_to_cpu(arg.vdev_map);
3832
3833	ath10k_dbg(ar, ATH10K_DBG_MGMT, "mgmt swba vdev_map 0x%x\n",
3834		   map);
3835
3836	for (; map; map >>= 1, vdev_id++) {
3837		if (!(map & 0x1))
3838			continue;
3839
3840		i++;
3841
3842		if (i >= WMI_MAX_AP_VDEV) {
3843			ath10k_warn(ar, "swba has corrupted vdev map\n");
3844			break;
3845		}
3846
3847		tim_info = &arg.tim_info[i];
3848		noa_info = arg.noa_info[i];
3849
3850		ath10k_dbg(ar, ATH10K_DBG_MGMT,
3851			   "mgmt event bcn_info %d tim_len %d mcast %d changed %d num_ps_pending %d bitmap 0x%08x%08x%08x%08x\n",
3852			   i,
3853			   __le32_to_cpu(tim_info->tim_len),
3854			   __le32_to_cpu(tim_info->tim_mcast),
3855			   __le32_to_cpu(tim_info->tim_changed),
3856			   __le32_to_cpu(tim_info->tim_num_ps_pending),
3857			   __le32_to_cpu(tim_info->tim_bitmap[3]),
3858			   __le32_to_cpu(tim_info->tim_bitmap[2]),
3859			   __le32_to_cpu(tim_info->tim_bitmap[1]),
3860			   __le32_to_cpu(tim_info->tim_bitmap[0]));
3861
3862		/* TODO: Only first 4 word from tim_bitmap is dumped.
3863		 * Extend debug code to dump full tim_bitmap.
3864		 */
3865
3866		arvif = ath10k_get_arvif(ar, vdev_id);
3867		if (arvif == NULL) {
3868			ath10k_warn(ar, "no vif for vdev_id %d found\n",
3869				    vdev_id);
3870			continue;
3871		}
3872
3873		/* mac80211 would have already asked us to stop beaconing and
3874		 * bring the vdev down, so continue in that case
3875		 */
3876		if (!arvif->is_up)
3877			continue;
3878
3879		/* There are no completions for beacons so wait for next SWBA
3880		 * before telling mac80211 to decrement CSA counter
3881		 *
3882		 * Once CSA counter is completed stop sending beacons until
3883		 * actual channel switch is done
3884		 */
3885		if (arvif->vif->bss_conf.csa_active &&
3886		    ieee80211_beacon_cntdwn_is_complete(arvif->vif)) {
3887			ieee80211_csa_finish(arvif->vif);
3888			continue;
3889		}
3890
3891		bcn = ieee80211_beacon_get(ar->hw, arvif->vif, 0);
3892		if (!bcn) {
3893			ath10k_warn(ar, "could not get mac80211 beacon\n");
3894			continue;
3895		}
3896
3897		ath10k_tx_h_seq_no(arvif->vif, bcn);
3898		ath10k_wmi_update_tim(ar, arvif, bcn, tim_info);
3899		ath10k_wmi_update_noa(ar, arvif, bcn, noa_info);
3900
3901		spin_lock_bh(&ar->data_lock);
3902
3903		if (arvif->beacon) {
3904			switch (arvif->beacon_state) {
3905			case ATH10K_BEACON_SENT:
3906				break;
3907			case ATH10K_BEACON_SCHEDULED:
3908				ath10k_warn(ar, "SWBA overrun on vdev %d, skipped old beacon\n",
3909					    arvif->vdev_id);
3910				break;
3911			case ATH10K_BEACON_SENDING:
3912				ath10k_warn(ar, "SWBA overrun on vdev %d, skipped new beacon\n",
3913					    arvif->vdev_id);
3914				dev_kfree_skb(bcn);
3915				goto skip;
3916			}
3917
3918			ath10k_mac_vif_beacon_free(arvif);
3919		}
3920
3921		if (!arvif->beacon_buf) {
3922			paddr = dma_map_single(arvif->ar->dev, bcn->data,
3923					       bcn->len, DMA_TO_DEVICE);
3924			ret = dma_mapping_error(arvif->ar->dev, paddr);
3925			if (ret) {
3926				ath10k_warn(ar, "failed to map beacon: %d\n",
3927					    ret);
3928				dev_kfree_skb_any(bcn);
3929				goto skip;
3930			}
3931
3932			ATH10K_SKB_CB(bcn)->paddr = paddr;
3933		} else {
3934			if (bcn->len > IEEE80211_MAX_FRAME_LEN) {
3935				ath10k_warn(ar, "trimming beacon %d -> %d bytes!\n",
3936					    bcn->len, IEEE80211_MAX_FRAME_LEN);
3937				skb_trim(bcn, IEEE80211_MAX_FRAME_LEN);
3938			}
3939			memcpy(arvif->beacon_buf, bcn->data, bcn->len);
3940			ATH10K_SKB_CB(bcn)->paddr = arvif->beacon_paddr;
3941		}
3942
3943		arvif->beacon = bcn;
3944		arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
3945
3946		trace_ath10k_tx_hdr(ar, bcn->data, bcn->len);
3947		trace_ath10k_tx_payload(ar, bcn->data, bcn->len);
3948
3949skip:
3950		spin_unlock_bh(&ar->data_lock);
3951	}
3952
3953	ath10k_wmi_tx_beacons_nowait(ar);
3954}
3955
3956void ath10k_wmi_event_tbttoffset_update(struct ath10k *ar, struct sk_buff *skb)
3957{
3958	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_TBTTOFFSET_UPDATE_EVENTID\n");
3959}
3960
3961static void ath10k_radar_detected(struct ath10k *ar)
3962{
3963	ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs radar detected\n");
3964	ATH10K_DFS_STAT_INC(ar, radar_detected);
3965
3966	/* Control radar events reporting in debugfs file
3967	 * dfs_block_radar_events
3968	 */
3969	if (ar->dfs_block_radar_events)
3970		ath10k_info(ar, "DFS Radar detected, but ignored as requested\n");
3971	else
3972		ieee80211_radar_detected(ar->hw);
3973}
3974
3975static void ath10k_radar_confirmation_work(struct work_struct *work)
3976{
3977	struct ath10k *ar = container_of(work, struct ath10k,
3978					 radar_confirmation_work);
3979	struct ath10k_radar_found_info radar_info;
3980	int ret, time_left;
3981
3982	reinit_completion(&ar->wmi.radar_confirm);
3983
3984	spin_lock_bh(&ar->data_lock);
3985	memcpy(&radar_info, &ar->last_radar_info, sizeof(radar_info));
3986	spin_unlock_bh(&ar->data_lock);
3987
3988	ret = ath10k_wmi_report_radar_found(ar, &radar_info);
3989	if (ret) {
3990		ath10k_warn(ar, "failed to send radar found %d\n", ret);
3991		goto wait_complete;
3992	}
3993
3994	time_left = wait_for_completion_timeout(&ar->wmi.radar_confirm,
3995						ATH10K_WMI_DFS_CONF_TIMEOUT_HZ);
3996	if (time_left) {
3997		/* DFS Confirmation status event received and
3998		 * necessary action completed.
3999		 */
4000		goto wait_complete;
4001	} else {
4002		/* DFS Confirmation event not received from FW.Considering this
4003		 * as real radar.
4004		 */
4005		ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4006			   "dfs confirmation not received from fw, considering as radar\n");
4007		goto radar_detected;
4008	}
4009
4010radar_detected:
4011	ath10k_radar_detected(ar);
4012
4013	/* Reset state to allow sending confirmation on consecutive radar
4014	 * detections, unless radar confirmation is disabled/stopped.
4015	 */
4016wait_complete:
4017	spin_lock_bh(&ar->data_lock);
4018	if (ar->radar_conf_state != ATH10K_RADAR_CONFIRMATION_STOPPED)
4019		ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE;
4020	spin_unlock_bh(&ar->data_lock);
4021}
4022
4023static void ath10k_dfs_radar_report(struct ath10k *ar,
4024				    struct wmi_phyerr_ev_arg *phyerr,
4025				    const struct phyerr_radar_report *rr,
4026				    u64 tsf)
4027{
4028	u32 reg0, reg1, tsf32l;
4029	struct ieee80211_channel *ch;
4030	struct pulse_event pe;
4031	struct radar_detector_specs rs;
4032	u64 tsf64;
4033	u8 rssi, width;
4034	struct ath10k_radar_found_info *radar_info;
4035
4036	reg0 = __le32_to_cpu(rr->reg0);
4037	reg1 = __le32_to_cpu(rr->reg1);
4038
4039	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4040		   "wmi phyerr radar report chirp %d max_width %d agc_total_gain %d pulse_delta_diff %d\n",
4041		   MS(reg0, RADAR_REPORT_REG0_PULSE_IS_CHIRP),
4042		   MS(reg0, RADAR_REPORT_REG0_PULSE_IS_MAX_WIDTH),
4043		   MS(reg0, RADAR_REPORT_REG0_AGC_TOTAL_GAIN),
4044		   MS(reg0, RADAR_REPORT_REG0_PULSE_DELTA_DIFF));
4045	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4046		   "wmi phyerr radar report pulse_delta_pean %d pulse_sidx %d fft_valid %d agc_mb_gain %d subchan_mask %d\n",
4047		   MS(reg0, RADAR_REPORT_REG0_PULSE_DELTA_PEAK),
4048		   MS(reg0, RADAR_REPORT_REG0_PULSE_SIDX),
4049		   MS(reg1, RADAR_REPORT_REG1_PULSE_SRCH_FFT_VALID),
4050		   MS(reg1, RADAR_REPORT_REG1_PULSE_AGC_MB_GAIN),
4051		   MS(reg1, RADAR_REPORT_REG1_PULSE_SUBCHAN_MASK));
4052	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4053		   "wmi phyerr radar report pulse_tsf_offset 0x%X pulse_dur: %d\n",
4054		   MS(reg1, RADAR_REPORT_REG1_PULSE_TSF_OFFSET),
4055		   MS(reg1, RADAR_REPORT_REG1_PULSE_DUR));
4056
4057	if (!ar->dfs_detector)
4058		return;
4059
4060	spin_lock_bh(&ar->data_lock);
4061	ch = ar->rx_channel;
4062
4063	/* fetch target operating channel during channel change */
4064	if (!ch)
4065		ch = ar->tgt_oper_chan;
4066
4067	spin_unlock_bh(&ar->data_lock);
4068
4069	if (!ch) {
4070		ath10k_warn(ar, "failed to derive channel for radar pulse, treating as radar\n");
4071		goto radar_detected;
4072	}
4073
4074	/* report event to DFS pattern detector */
4075	tsf32l = phyerr->tsf_timestamp;
4076	tsf64 = tsf & (~0xFFFFFFFFULL);
4077	tsf64 |= tsf32l;
4078
4079	width = MS(reg1, RADAR_REPORT_REG1_PULSE_DUR);
4080	rssi = phyerr->rssi_combined;
4081
4082	/* hardware store this as 8 bit signed value,
4083	 * set to zero if negative number
4084	 */
4085	if (rssi & 0x80)
4086		rssi = 0;
4087
4088	pe.ts = tsf64;
4089	pe.freq = ch->center_freq;
4090	pe.width = width;
4091	pe.rssi = rssi;
4092	pe.chirp = (MS(reg0, RADAR_REPORT_REG0_PULSE_IS_CHIRP) != 0);
4093	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4094		   "dfs add pulse freq: %d, width: %d, rssi %d, tsf: %llX\n",
4095		   pe.freq, pe.width, pe.rssi, pe.ts);
4096
4097	ATH10K_DFS_STAT_INC(ar, pulses_detected);
4098
4099	if (!ar->dfs_detector->add_pulse(ar->dfs_detector, &pe, &rs)) {
4100		ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4101			   "dfs no pulse pattern detected, yet\n");
4102		return;
4103	}
4104
4105	if ((test_bit(WMI_SERVICE_HOST_DFS_CHECK_SUPPORT, ar->wmi.svc_map)) &&
4106	    ar->dfs_detector->region == NL80211_DFS_FCC) {
4107		/* Consecutive radar indications need not be
4108		 * sent to the firmware until we get confirmation
4109		 * for the previous detected radar.
4110		 */
4111		spin_lock_bh(&ar->data_lock);
4112		if (ar->radar_conf_state != ATH10K_RADAR_CONFIRMATION_IDLE) {
4113			spin_unlock_bh(&ar->data_lock);
4114			return;
4115		}
4116		ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_INPROGRESS;
4117		radar_info = &ar->last_radar_info;
4118
4119		radar_info->pri_min = rs.pri_min;
4120		radar_info->pri_max = rs.pri_max;
4121		radar_info->width_min = rs.width_min;
4122		radar_info->width_max = rs.width_max;
4123		/*TODO Find sidx_min and sidx_max */
4124		radar_info->sidx_min = MS(reg0, RADAR_REPORT_REG0_PULSE_SIDX);
4125		radar_info->sidx_max = MS(reg0, RADAR_REPORT_REG0_PULSE_SIDX);
4126
4127		ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4128			   "sending wmi radar found cmd pri_min %d pri_max %d width_min %d width_max %d sidx_min %d sidx_max %d\n",
4129			   radar_info->pri_min, radar_info->pri_max,
4130			   radar_info->width_min, radar_info->width_max,
4131			   radar_info->sidx_min, radar_info->sidx_max);
4132		ieee80211_queue_work(ar->hw, &ar->radar_confirmation_work);
4133		spin_unlock_bh(&ar->data_lock);
4134		return;
4135	}
4136
4137radar_detected:
4138	ath10k_radar_detected(ar);
4139}
4140
4141static int ath10k_dfs_fft_report(struct ath10k *ar,
4142				 struct wmi_phyerr_ev_arg *phyerr,
4143				 const struct phyerr_fft_report *fftr,
4144				 u64 tsf)
4145{
4146	u32 reg0, reg1;
4147	u8 rssi, peak_mag;
4148
4149	reg0 = __le32_to_cpu(fftr->reg0);
4150	reg1 = __le32_to_cpu(fftr->reg1);
4151	rssi = phyerr->rssi_combined;
4152
4153	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4154		   "wmi phyerr fft report total_gain_db %d base_pwr_db %d fft_chn_idx %d peak_sidx %d\n",
4155		   MS(reg0, SEARCH_FFT_REPORT_REG0_TOTAL_GAIN_DB),
4156		   MS(reg0, SEARCH_FFT_REPORT_REG0_BASE_PWR_DB),
4157		   MS(reg0, SEARCH_FFT_REPORT_REG0_FFT_CHN_IDX),
4158		   MS(reg0, SEARCH_FFT_REPORT_REG0_PEAK_SIDX));
4159	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4160		   "wmi phyerr fft report rel_pwr_db %d avgpwr_db %d peak_mag %d num_store_bin %d\n",
4161		   MS(reg1, SEARCH_FFT_REPORT_REG1_RELPWR_DB),
4162		   MS(reg1, SEARCH_FFT_REPORT_REG1_AVGPWR_DB),
4163		   MS(reg1, SEARCH_FFT_REPORT_REG1_PEAK_MAG),
4164		   MS(reg1, SEARCH_FFT_REPORT_REG1_NUM_STR_BINS_IB));
4165
4166	peak_mag = MS(reg1, SEARCH_FFT_REPORT_REG1_PEAK_MAG);
4167
4168	/* false event detection */
4169	if (rssi == DFS_RSSI_POSSIBLY_FALSE &&
4170	    peak_mag < 2 * DFS_PEAK_MAG_THOLD_POSSIBLY_FALSE) {
4171		ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs false pulse detected\n");
4172		ATH10K_DFS_STAT_INC(ar, pulses_discarded);
4173		return -EINVAL;
4174	}
4175
4176	return 0;
4177}
4178
4179void ath10k_wmi_event_dfs(struct ath10k *ar,
4180			  struct wmi_phyerr_ev_arg *phyerr,
4181			  u64 tsf)
4182{
4183	int buf_len, tlv_len, res, i = 0;
4184	const struct phyerr_tlv *tlv;
4185	const struct phyerr_radar_report *rr;
4186	const struct phyerr_fft_report *fftr;
4187	const u8 *tlv_buf;
4188
4189	buf_len = phyerr->buf_len;
4190	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4191		   "wmi event dfs err_code %d rssi %d tsfl 0x%X tsf64 0x%llX len %d\n",
4192		   phyerr->phy_err_code, phyerr->rssi_combined,
4193		   phyerr->tsf_timestamp, tsf, buf_len);
4194
4195	/* Skip event if DFS disabled */
4196	if (!IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED))
4197		return;
4198
4199	ATH10K_DFS_STAT_INC(ar, pulses_total);
4200
4201	while (i < buf_len) {
4202		if (i + sizeof(*tlv) > buf_len) {
4203			ath10k_warn(ar, "too short buf for tlv header (%d)\n",
4204				    i);
4205			return;
4206		}
4207
4208		tlv = (struct phyerr_tlv *)&phyerr->buf[i];
4209		tlv_len = __le16_to_cpu(tlv->len);
4210		tlv_buf = &phyerr->buf[i + sizeof(*tlv)];
4211		ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4212			   "wmi event dfs tlv_len %d tlv_tag 0x%02X tlv_sig 0x%02X\n",
4213			   tlv_len, tlv->tag, tlv->sig);
4214
4215		switch (tlv->tag) {
4216		case PHYERR_TLV_TAG_RADAR_PULSE_SUMMARY:
4217			if (i + sizeof(*tlv) + sizeof(*rr) > buf_len) {
4218				ath10k_warn(ar, "too short radar pulse summary (%d)\n",
4219					    i);
4220				return;
4221			}
4222
4223			rr = (struct phyerr_radar_report *)tlv_buf;
4224			ath10k_dfs_radar_report(ar, phyerr, rr, tsf);
4225			break;
4226		case PHYERR_TLV_TAG_SEARCH_FFT_REPORT:
4227			if (i + sizeof(*tlv) + sizeof(*fftr) > buf_len) {
4228				ath10k_warn(ar, "too short fft report (%d)\n",
4229					    i);
4230				return;
4231			}
4232
4233			fftr = (struct phyerr_fft_report *)tlv_buf;
4234			res = ath10k_dfs_fft_report(ar, phyerr, fftr, tsf);
4235			if (res)
4236				return;
4237			break;
4238		}
4239
4240		i += sizeof(*tlv) + tlv_len;
4241	}
4242}
4243
4244void ath10k_wmi_event_spectral_scan(struct ath10k *ar,
4245				    struct wmi_phyerr_ev_arg *phyerr,
4246				    u64 tsf)
4247{
4248	int buf_len, tlv_len, res, i = 0;
4249	struct phyerr_tlv *tlv;
4250	const void *tlv_buf;
4251	const struct phyerr_fft_report *fftr;
4252	size_t fftr_len;
4253
4254	buf_len = phyerr->buf_len;
4255
4256	while (i < buf_len) {
4257		if (i + sizeof(*tlv) > buf_len) {
4258			ath10k_warn(ar, "failed to parse phyerr tlv header at byte %d\n",
4259				    i);
4260			return;
4261		}
4262
4263		tlv = (struct phyerr_tlv *)&phyerr->buf[i];
4264		tlv_len = __le16_to_cpu(tlv->len);
4265		tlv_buf = &phyerr->buf[i + sizeof(*tlv)];
4266
4267		if (i + sizeof(*tlv) + tlv_len > buf_len) {
4268			ath10k_warn(ar, "failed to parse phyerr tlv payload at byte %d\n",
4269				    i);
4270			return;
4271		}
4272
4273		switch (tlv->tag) {
4274		case PHYERR_TLV_TAG_SEARCH_FFT_REPORT:
4275			if (sizeof(*fftr) > tlv_len) {
4276				ath10k_warn(ar, "failed to parse fft report at byte %d\n",
4277					    i);
4278				return;
4279			}
4280
4281			fftr_len = tlv_len - sizeof(*fftr);
4282			fftr = tlv_buf;
4283			res = ath10k_spectral_process_fft(ar, phyerr,
4284							  fftr, fftr_len,
4285							  tsf);
4286			if (res < 0) {
4287				ath10k_dbg(ar, ATH10K_DBG_WMI, "failed to process fft report: %d\n",
4288					   res);
4289				return;
4290			}
4291			break;
4292		}
4293
4294		i += sizeof(*tlv) + tlv_len;
4295	}
4296}
4297
4298static int ath10k_wmi_op_pull_phyerr_ev_hdr(struct ath10k *ar,
4299					    struct sk_buff *skb,
4300					    struct wmi_phyerr_hdr_arg *arg)
4301{
4302	struct wmi_phyerr_event *ev = (void *)skb->data;
4303
4304	if (skb->len < sizeof(*ev))
4305		return -EPROTO;
4306
4307	arg->num_phyerrs = __le32_to_cpu(ev->num_phyerrs);
4308	arg->tsf_l32 = __le32_to_cpu(ev->tsf_l32);
4309	arg->tsf_u32 = __le32_to_cpu(ev->tsf_u32);
4310	arg->buf_len = skb->len - sizeof(*ev);
4311	arg->phyerrs = ev->phyerrs;
4312
4313	return 0;
4314}
4315
4316static int ath10k_wmi_10_4_op_pull_phyerr_ev_hdr(struct ath10k *ar,
4317						 struct sk_buff *skb,
4318						 struct wmi_phyerr_hdr_arg *arg)
4319{
4320	struct wmi_10_4_phyerr_event *ev = (void *)skb->data;
4321
4322	if (skb->len < sizeof(*ev))
4323		return -EPROTO;
4324
4325	/* 10.4 firmware always reports only one phyerr */
4326	arg->num_phyerrs = 1;
4327
4328	arg->tsf_l32 = __le32_to_cpu(ev->tsf_l32);
4329	arg->tsf_u32 = __le32_to_cpu(ev->tsf_u32);
4330	arg->buf_len = skb->len;
4331	arg->phyerrs = skb->data;
4332
4333	return 0;
4334}
4335
4336int ath10k_wmi_op_pull_phyerr_ev(struct ath10k *ar,
4337				 const void *phyerr_buf,
4338				 int left_len,
4339				 struct wmi_phyerr_ev_arg *arg)
4340{
4341	const struct wmi_phyerr *phyerr = phyerr_buf;
4342	int i;
4343
4344	if (left_len < sizeof(*phyerr)) {
4345		ath10k_warn(ar, "wrong phyerr event head len %d (need: >=%zd)\n",
4346			    left_len, sizeof(*phyerr));
4347		return -EINVAL;
4348	}
4349
4350	arg->tsf_timestamp = __le32_to_cpu(phyerr->tsf_timestamp);
4351	arg->freq1 = __le16_to_cpu(phyerr->freq1);
4352	arg->freq2 = __le16_to_cpu(phyerr->freq2);
4353	arg->rssi_combined = phyerr->rssi_combined;
4354	arg->chan_width_mhz = phyerr->chan_width_mhz;
4355	arg->buf_len = __le32_to_cpu(phyerr->buf_len);
4356	arg->buf = phyerr->buf;
4357	arg->hdr_len = sizeof(*phyerr);
4358
4359	for (i = 0; i < 4; i++)
4360		arg->nf_chains[i] = __le16_to_cpu(phyerr->nf_chains[i]);
4361
4362	switch (phyerr->phy_err_code) {
4363	case PHY_ERROR_GEN_SPECTRAL_SCAN:
4364		arg->phy_err_code = PHY_ERROR_SPECTRAL_SCAN;
4365		break;
4366	case PHY_ERROR_GEN_FALSE_RADAR_EXT:
4367		arg->phy_err_code = PHY_ERROR_FALSE_RADAR_EXT;
4368		break;
4369	case PHY_ERROR_GEN_RADAR:
4370		arg->phy_err_code = PHY_ERROR_RADAR;
4371		break;
4372	default:
4373		arg->phy_err_code = PHY_ERROR_UNKNOWN;
4374		break;
4375	}
4376
4377	return 0;
4378}
4379
4380static int ath10k_wmi_10_4_op_pull_phyerr_ev(struct ath10k *ar,
4381					     const void *phyerr_buf,
4382					     int left_len,
4383					     struct wmi_phyerr_ev_arg *arg)
4384{
4385	const struct wmi_10_4_phyerr_event *phyerr = phyerr_buf;
4386	u32 phy_err_mask;
4387	int i;
4388
4389	if (left_len < sizeof(*phyerr)) {
4390		ath10k_warn(ar, "wrong phyerr event head len %d (need: >=%zd)\n",
4391			    left_len, sizeof(*phyerr));
4392		return -EINVAL;
4393	}
4394
4395	arg->tsf_timestamp = __le32_to_cpu(phyerr->tsf_timestamp);
4396	arg->freq1 = __le16_to_cpu(phyerr->freq1);
4397	arg->freq2 = __le16_to_cpu(phyerr->freq2);
4398	arg->rssi_combined = phyerr->rssi_combined;
4399	arg->chan_width_mhz = phyerr->chan_width_mhz;
4400	arg->buf_len = __le32_to_cpu(phyerr->buf_len);
4401	arg->buf = phyerr->buf;
4402	arg->hdr_len = sizeof(*phyerr);
4403
4404	for (i = 0; i < 4; i++)
4405		arg->nf_chains[i] = __le16_to_cpu(phyerr->nf_chains[i]);
4406
4407	phy_err_mask = __le32_to_cpu(phyerr->phy_err_mask[0]);
4408
4409	if (phy_err_mask & PHY_ERROR_10_4_SPECTRAL_SCAN_MASK)
4410		arg->phy_err_code = PHY_ERROR_SPECTRAL_SCAN;
4411	else if (phy_err_mask & PHY_ERROR_10_4_RADAR_MASK)
4412		arg->phy_err_code = PHY_ERROR_RADAR;
4413	else
4414		arg->phy_err_code = PHY_ERROR_UNKNOWN;
4415
4416	return 0;
4417}
4418
4419void ath10k_wmi_event_phyerr(struct ath10k *ar, struct sk_buff *skb)
4420{
4421	struct wmi_phyerr_hdr_arg hdr_arg = {};
4422	struct wmi_phyerr_ev_arg phyerr_arg = {};
4423	const void *phyerr;
4424	u32 count, i, buf_len, phy_err_code;
4425	u64 tsf;
4426	int left_len, ret;
4427
4428	ATH10K_DFS_STAT_INC(ar, phy_errors);
4429
4430	ret = ath10k_wmi_pull_phyerr_hdr(ar, skb, &hdr_arg);
4431	if (ret) {
4432		ath10k_warn(ar, "failed to parse phyerr event hdr: %d\n", ret);
4433		return;
4434	}
4435
4436	/* Check number of included events */
4437	count = hdr_arg.num_phyerrs;
4438
4439	left_len = hdr_arg.buf_len;
4440
4441	tsf = hdr_arg.tsf_u32;
4442	tsf <<= 32;
4443	tsf |= hdr_arg.tsf_l32;
4444
4445	ath10k_dbg(ar, ATH10K_DBG_WMI,
4446		   "wmi event phyerr count %d tsf64 0x%llX\n",
4447		   count, tsf);
4448
4449	phyerr = hdr_arg.phyerrs;
4450	for (i = 0; i < count; i++) {
4451		ret = ath10k_wmi_pull_phyerr(ar, phyerr, left_len, &phyerr_arg);
4452		if (ret) {
4453			ath10k_warn(ar, "failed to parse phyerr event (%d)\n",
4454				    i);
4455			return;
4456		}
4457
4458		left_len -= phyerr_arg.hdr_len;
4459		buf_len = phyerr_arg.buf_len;
4460		phy_err_code = phyerr_arg.phy_err_code;
4461
4462		if (left_len < buf_len) {
4463			ath10k_warn(ar, "single event (%d) wrong buf len\n", i);
4464			return;
4465		}
4466
4467		left_len -= buf_len;
4468
4469		switch (phy_err_code) {
4470		case PHY_ERROR_RADAR:
4471			ath10k_wmi_event_dfs(ar, &phyerr_arg, tsf);
4472			break;
4473		case PHY_ERROR_SPECTRAL_SCAN:
4474			ath10k_wmi_event_spectral_scan(ar, &phyerr_arg, tsf);
4475			break;
4476		case PHY_ERROR_FALSE_RADAR_EXT:
4477			ath10k_wmi_event_dfs(ar, &phyerr_arg, tsf);
4478			ath10k_wmi_event_spectral_scan(ar, &phyerr_arg, tsf);
4479			break;
4480		default:
4481			break;
4482		}
4483
4484		phyerr = phyerr + phyerr_arg.hdr_len + buf_len;
4485	}
4486}
4487
4488static int
4489ath10k_wmi_10_4_op_pull_dfs_status_ev(struct ath10k *ar, struct sk_buff *skb,
4490				      struct wmi_dfs_status_ev_arg *arg)
4491{
4492	struct wmi_dfs_status_ev_arg *ev = (void *)skb->data;
4493
4494	if (skb->len < sizeof(*ev))
4495		return -EPROTO;
4496
4497	arg->status = ev->status;
4498
4499	return 0;
4500}
4501
4502static void
4503ath10k_wmi_event_dfs_status_check(struct ath10k *ar, struct sk_buff *skb)
4504{
4505	struct wmi_dfs_status_ev_arg status_arg = {};
4506	int ret;
4507
4508	ret = ath10k_wmi_pull_dfs_status(ar, skb, &status_arg);
4509
4510	if (ret) {
4511		ath10k_warn(ar, "failed to parse dfs status event: %d\n", ret);
4512		return;
4513	}
4514
4515	ath10k_dbg(ar, ATH10K_DBG_REGULATORY,
4516		   "dfs status event received from fw: %d\n",
4517		   status_arg.status);
4518
4519	/* Even in case of radar detection failure we follow the same
4520	 * behaviour as if radar is detected i.e to switch to a different
4521	 * channel.
4522	 */
4523	if (status_arg.status == WMI_HW_RADAR_DETECTED ||
4524	    status_arg.status == WMI_RADAR_DETECTION_FAIL)
4525		ath10k_radar_detected(ar);
4526	complete(&ar->wmi.radar_confirm);
4527}
4528
4529void ath10k_wmi_event_roam(struct ath10k *ar, struct sk_buff *skb)
4530{
4531	struct wmi_roam_ev_arg arg = {};
4532	int ret;
4533	u32 vdev_id;
4534	u32 reason;
4535	s32 rssi;
4536
4537	ret = ath10k_wmi_pull_roam_ev(ar, skb, &arg);
4538	if (ret) {
4539		ath10k_warn(ar, "failed to parse roam event: %d\n", ret);
4540		return;
4541	}
4542
4543	vdev_id = __le32_to_cpu(arg.vdev_id);
4544	reason = __le32_to_cpu(arg.reason);
4545	rssi = __le32_to_cpu(arg.rssi);
4546	rssi += WMI_SPECTRAL_NOISE_FLOOR_REF_DEFAULT;
4547
4548	ath10k_dbg(ar, ATH10K_DBG_WMI,
4549		   "wmi roam event vdev %u reason 0x%08x rssi %d\n",
4550		   vdev_id, reason, rssi);
4551
4552	if (reason >= WMI_ROAM_REASON_MAX)
4553		ath10k_warn(ar, "ignoring unknown roam event reason %d on vdev %i\n",
4554			    reason, vdev_id);
4555
4556	switch (reason) {
4557	case WMI_ROAM_REASON_BEACON_MISS:
4558		ath10k_mac_handle_beacon_miss(ar, vdev_id);
4559		break;
4560	case WMI_ROAM_REASON_BETTER_AP:
4561	case WMI_ROAM_REASON_LOW_RSSI:
4562	case WMI_ROAM_REASON_SUITABLE_AP_FOUND:
4563	case WMI_ROAM_REASON_HO_FAILED:
4564		ath10k_warn(ar, "ignoring not implemented roam event reason %d on vdev %i\n",
4565			    reason, vdev_id);
4566		break;
4567	}
4568}
4569
4570void ath10k_wmi_event_profile_match(struct ath10k *ar, struct sk_buff *skb)
4571{
4572	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_PROFILE_MATCH\n");
4573}
4574
4575void ath10k_wmi_event_debug_print(struct ath10k *ar, struct sk_buff *skb)
4576{
4577	char buf[101], c;
4578	int i;
4579
4580	for (i = 0; i < sizeof(buf) - 1; i++) {
4581		if (i >= skb->len)
4582			break;
4583
4584		c = skb->data[i];
4585
4586		if (c == '\0')
4587			break;
4588
4589		if (isascii(c) && isprint(c))
4590			buf[i] = c;
4591		else
4592			buf[i] = '.';
4593	}
4594
4595	if (i == sizeof(buf) - 1)
4596		ath10k_warn(ar, "wmi debug print truncated: %d\n", skb->len);
4597
4598	/* for some reason the debug prints end with \n, remove that */
4599	if (skb->data[i - 1] == '\n')
4600		i--;
4601
4602	/* the last byte is always reserved for the null character */
4603	buf[i] = '\0';
4604
4605	ath10k_dbg(ar, ATH10K_DBG_WMI_PRINT, "wmi print '%s'\n", buf);
4606}
4607
4608void ath10k_wmi_event_pdev_qvit(struct ath10k *ar, struct sk_buff *skb)
4609{
4610	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_PDEV_QVIT_EVENTID\n");
4611}
4612
4613void ath10k_wmi_event_wlan_profile_data(struct ath10k *ar, struct sk_buff *skb)
4614{
4615	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_WLAN_PROFILE_DATA_EVENTID\n");
4616}
4617
4618void ath10k_wmi_event_rtt_measurement_report(struct ath10k *ar,
4619					     struct sk_buff *skb)
4620{
4621	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_RTT_MEASUREMENT_REPORT_EVENTID\n");
4622}
4623
4624void ath10k_wmi_event_tsf_measurement_report(struct ath10k *ar,
4625					     struct sk_buff *skb)
4626{
4627	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_TSF_MEASUREMENT_REPORT_EVENTID\n");
4628}
4629
4630void ath10k_wmi_event_rtt_error_report(struct ath10k *ar, struct sk_buff *skb)
4631{
4632	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_RTT_ERROR_REPORT_EVENTID\n");
4633}
4634
4635void ath10k_wmi_event_wow_wakeup_host(struct ath10k *ar, struct sk_buff *skb)
4636{
4637	struct wmi_wow_ev_arg ev = {};
4638	int ret;
4639
4640	complete(&ar->wow.wakeup_completed);
4641
4642	ret = ath10k_wmi_pull_wow_event(ar, skb, &ev);
4643	if (ret) {
4644		ath10k_warn(ar, "failed to parse wow wakeup event: %d\n", ret);
4645		return;
4646	}
4647
4648	ath10k_dbg(ar, ATH10K_DBG_WMI, "wow wakeup host reason %s\n",
4649		   wow_reason(ev.wake_reason));
4650}
4651
4652void ath10k_wmi_event_dcs_interference(struct ath10k *ar, struct sk_buff *skb)
4653{
4654	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_DCS_INTERFERENCE_EVENTID\n");
4655}
4656
4657static u8 ath10k_tpc_config_get_rate(struct ath10k *ar,
4658				     struct wmi_pdev_tpc_config_event *ev,
4659				     u32 rate_idx, u32 num_chains,
4660				     u32 rate_code, u8 type)
4661{
4662	u8 tpc, num_streams, preamble, ch, stm_idx;
4663
4664	num_streams = ATH10K_HW_NSS(rate_code);
4665	preamble = ATH10K_HW_PREAMBLE(rate_code);
4666	ch = num_chains - 1;
4667
4668	tpc = min_t(u8, ev->rates_array[rate_idx], ev->max_reg_allow_pow[ch]);
4669
4670	if (__le32_to_cpu(ev->num_tx_chain) <= 1)
4671		goto out;
4672
4673	if (preamble == WMI_RATE_PREAMBLE_CCK)
4674		goto out;
4675
4676	stm_idx = num_streams - 1;
4677	if (num_chains <= num_streams)
4678		goto out;
4679
4680	switch (type) {
4681	case WMI_TPC_TABLE_TYPE_STBC:
4682		tpc = min_t(u8, tpc,
4683			    ev->max_reg_allow_pow_agstbc[ch - 1][stm_idx]);
4684		break;
4685	case WMI_TPC_TABLE_TYPE_TXBF:
4686		tpc = min_t(u8, tpc,
4687			    ev->max_reg_allow_pow_agtxbf[ch - 1][stm_idx]);
4688		break;
4689	case WMI_TPC_TABLE_TYPE_CDD:
4690		tpc = min_t(u8, tpc,
4691			    ev->max_reg_allow_pow_agcdd[ch - 1][stm_idx]);
4692		break;
4693	default:
4694		ath10k_warn(ar, "unknown wmi tpc table type: %d\n", type);
4695		tpc = 0;
4696		break;
4697	}
4698
4699out:
4700	return tpc;
4701}
4702
4703static void ath10k_tpc_config_disp_tables(struct ath10k *ar,
4704					  struct wmi_pdev_tpc_config_event *ev,
4705					  struct ath10k_tpc_stats *tpc_stats,
4706					  u8 *rate_code, u16 *pream_table, u8 type)
4707{
4708	u32 i, j, pream_idx, flags;
4709	u8 tpc[WMI_TPC_TX_N_CHAIN];
4710	char tpc_value[WMI_TPC_TX_N_CHAIN * WMI_TPC_BUF_SIZE];
4711	char buff[WMI_TPC_BUF_SIZE];
4712
4713	flags = __le32_to_cpu(ev->flags);
4714
4715	switch (type) {
4716	case WMI_TPC_TABLE_TYPE_CDD:
4717		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_CDD)) {
4718			ath10k_dbg(ar, ATH10K_DBG_WMI, "CDD not supported\n");
4719			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
4720			return;
4721		}
4722		break;
4723	case WMI_TPC_TABLE_TYPE_STBC:
4724		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_STBC)) {
4725			ath10k_dbg(ar, ATH10K_DBG_WMI, "STBC not supported\n");
4726			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
4727			return;
4728		}
4729		break;
4730	case WMI_TPC_TABLE_TYPE_TXBF:
4731		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_TXBF)) {
4732			ath10k_dbg(ar, ATH10K_DBG_WMI, "TXBF not supported\n");
4733			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
4734			return;
4735		}
4736		break;
4737	default:
4738		ath10k_dbg(ar, ATH10K_DBG_WMI,
4739			   "invalid table type in wmi tpc event: %d\n", type);
4740		return;
4741	}
4742
4743	pream_idx = 0;
4744	for (i = 0; i < tpc_stats->rate_max; i++) {
4745		memset(tpc_value, 0, sizeof(tpc_value));
4746		memset(buff, 0, sizeof(buff));
4747		if (i == pream_table[pream_idx])
4748			pream_idx++;
4749
4750		for (j = 0; j < tpc_stats->num_tx_chain; j++) {
4751			tpc[j] = ath10k_tpc_config_get_rate(ar, ev, i, j + 1,
4752							    rate_code[i],
4753							    type);
4754			snprintf(buff, sizeof(buff), "%8d ", tpc[j]);
4755			strlcat(tpc_value, buff, sizeof(tpc_value));
4756		}
4757		tpc_stats->tpc_table[type].pream_idx[i] = pream_idx;
4758		tpc_stats->tpc_table[type].rate_code[i] = rate_code[i];
4759		memcpy(tpc_stats->tpc_table[type].tpc_value[i],
4760		       tpc_value, sizeof(tpc_value));
4761	}
4762}
4763
4764void ath10k_wmi_tpc_config_get_rate_code(u8 *rate_code, u16 *pream_table,
4765					 u32 num_tx_chain)
4766{
4767	u32 i, j, pream_idx;
4768	u8 rate_idx;
4769
4770	/* Create the rate code table based on the chains supported */
4771	rate_idx = 0;
4772	pream_idx = 0;
4773
4774	/* Fill CCK rate code */
4775	for (i = 0; i < 4; i++) {
4776		rate_code[rate_idx] =
4777			ATH10K_HW_RATECODE(i, 0, WMI_RATE_PREAMBLE_CCK);
4778		rate_idx++;
4779	}
4780	pream_table[pream_idx] = rate_idx;
4781	pream_idx++;
4782
4783	/* Fill OFDM rate code */
4784	for (i = 0; i < 8; i++) {
4785		rate_code[rate_idx] =
4786			ATH10K_HW_RATECODE(i, 0, WMI_RATE_PREAMBLE_OFDM);
4787		rate_idx++;
4788	}
4789	pream_table[pream_idx] = rate_idx;
4790	pream_idx++;
4791
4792	/* Fill HT20 rate code */
4793	for (i = 0; i < num_tx_chain; i++) {
4794		for (j = 0; j < 8; j++) {
4795			rate_code[rate_idx] =
4796			ATH10K_HW_RATECODE(j, i, WMI_RATE_PREAMBLE_HT);
4797			rate_idx++;
4798		}
4799	}
4800	pream_table[pream_idx] = rate_idx;
4801	pream_idx++;
4802
4803	/* Fill HT40 rate code */
4804	for (i = 0; i < num_tx_chain; i++) {
4805		for (j = 0; j < 8; j++) {
4806			rate_code[rate_idx] =
4807			ATH10K_HW_RATECODE(j, i, WMI_RATE_PREAMBLE_HT);
4808			rate_idx++;
4809		}
4810	}
4811	pream_table[pream_idx] = rate_idx;
4812	pream_idx++;
4813
4814	/* Fill VHT20 rate code */
4815	for (i = 0; i < num_tx_chain; i++) {
4816		for (j = 0; j < 10; j++) {
4817			rate_code[rate_idx] =
4818			ATH10K_HW_RATECODE(j, i, WMI_RATE_PREAMBLE_VHT);
4819			rate_idx++;
4820		}
4821	}
4822	pream_table[pream_idx] = rate_idx;
4823	pream_idx++;
4824
4825	/* Fill VHT40 rate code */
4826	for (i = 0; i < num_tx_chain; i++) {
4827		for (j = 0; j < 10; j++) {
4828			rate_code[rate_idx] =
4829			ATH10K_HW_RATECODE(j, i, WMI_RATE_PREAMBLE_VHT);
4830			rate_idx++;
4831		}
4832	}
4833	pream_table[pream_idx] = rate_idx;
4834	pream_idx++;
4835
4836	/* Fill VHT80 rate code */
4837	for (i = 0; i < num_tx_chain; i++) {
4838		for (j = 0; j < 10; j++) {
4839			rate_code[rate_idx] =
4840			ATH10K_HW_RATECODE(j, i, WMI_RATE_PREAMBLE_VHT);
4841			rate_idx++;
4842		}
4843	}
4844	pream_table[pream_idx] = rate_idx;
4845	pream_idx++;
4846
4847	rate_code[rate_idx++] =
4848		ATH10K_HW_RATECODE(0, 0, WMI_RATE_PREAMBLE_CCK);
4849	rate_code[rate_idx++] =
4850		ATH10K_HW_RATECODE(0, 0, WMI_RATE_PREAMBLE_OFDM);
4851	rate_code[rate_idx++] =
4852		ATH10K_HW_RATECODE(0, 0, WMI_RATE_PREAMBLE_CCK);
4853	rate_code[rate_idx++] =
4854		ATH10K_HW_RATECODE(0, 0, WMI_RATE_PREAMBLE_OFDM);
4855	rate_code[rate_idx++] =
4856		ATH10K_HW_RATECODE(0, 0, WMI_RATE_PREAMBLE_OFDM);
4857
4858	pream_table[pream_idx] = ATH10K_TPC_PREAM_TABLE_END;
4859}
4860
4861void ath10k_wmi_event_pdev_tpc_config(struct ath10k *ar, struct sk_buff *skb)
4862{
4863	u32 num_tx_chain, rate_max;
4864	u8 rate_code[WMI_TPC_RATE_MAX];
4865	u16 pream_table[WMI_TPC_PREAM_TABLE_MAX];
4866	struct wmi_pdev_tpc_config_event *ev;
4867	struct ath10k_tpc_stats *tpc_stats;
4868
4869	ev = (struct wmi_pdev_tpc_config_event *)skb->data;
4870
4871	num_tx_chain = __le32_to_cpu(ev->num_tx_chain);
4872
4873	if (num_tx_chain > WMI_TPC_TX_N_CHAIN) {
4874		ath10k_warn(ar, "number of tx chain is %d greater than TPC configured tx chain %d\n",
4875			    num_tx_chain, WMI_TPC_TX_N_CHAIN);
4876		return;
4877	}
4878
4879	rate_max = __le32_to_cpu(ev->rate_max);
4880	if (rate_max > WMI_TPC_RATE_MAX) {
4881		ath10k_warn(ar, "number of rate is %d greater than TPC configured rate %d\n",
4882			    rate_max, WMI_TPC_RATE_MAX);
4883		rate_max = WMI_TPC_RATE_MAX;
4884	}
4885
4886	tpc_stats = kzalloc(sizeof(*tpc_stats), GFP_ATOMIC);
4887	if (!tpc_stats)
4888		return;
4889
4890	ath10k_wmi_tpc_config_get_rate_code(rate_code, pream_table,
4891					    num_tx_chain);
4892
4893	tpc_stats->chan_freq = __le32_to_cpu(ev->chan_freq);
4894	tpc_stats->phy_mode = __le32_to_cpu(ev->phy_mode);
4895	tpc_stats->ctl = __le32_to_cpu(ev->ctl);
4896	tpc_stats->reg_domain = __le32_to_cpu(ev->reg_domain);
4897	tpc_stats->twice_antenna_gain = a_sle32_to_cpu(ev->twice_antenna_gain);
4898	tpc_stats->twice_antenna_reduction =
4899		__le32_to_cpu(ev->twice_antenna_reduction);
4900	tpc_stats->power_limit = __le32_to_cpu(ev->power_limit);
4901	tpc_stats->twice_max_rd_power = __le32_to_cpu(ev->twice_max_rd_power);
4902	tpc_stats->num_tx_chain = num_tx_chain;
4903	tpc_stats->rate_max = rate_max;
4904
4905	ath10k_tpc_config_disp_tables(ar, ev, tpc_stats,
4906				      rate_code, pream_table,
4907				      WMI_TPC_TABLE_TYPE_CDD);
4908	ath10k_tpc_config_disp_tables(ar, ev,  tpc_stats,
4909				      rate_code, pream_table,
4910				      WMI_TPC_TABLE_TYPE_STBC);
4911	ath10k_tpc_config_disp_tables(ar, ev, tpc_stats,
4912				      rate_code, pream_table,
4913				      WMI_TPC_TABLE_TYPE_TXBF);
4914
4915	ath10k_debug_tpc_stats_process(ar, tpc_stats);
4916
4917	ath10k_dbg(ar, ATH10K_DBG_WMI,
4918		   "wmi event tpc config channel %d mode %d ctl %d regd %d gain %d %d limit %d max_power %d tx_chanins %d rates %d\n",
4919		   __le32_to_cpu(ev->chan_freq),
4920		   __le32_to_cpu(ev->phy_mode),
4921		   __le32_to_cpu(ev->ctl),
4922		   __le32_to_cpu(ev->reg_domain),
4923		   a_sle32_to_cpu(ev->twice_antenna_gain),
4924		   __le32_to_cpu(ev->twice_antenna_reduction),
4925		   __le32_to_cpu(ev->power_limit),
4926		   __le32_to_cpu(ev->twice_max_rd_power) / 2,
4927		   __le32_to_cpu(ev->num_tx_chain),
4928		   __le32_to_cpu(ev->rate_max));
4929}
4930
4931static u8
4932ath10k_wmi_tpc_final_get_rate(struct ath10k *ar,
4933			      struct wmi_pdev_tpc_final_table_event *ev,
4934			      u32 rate_idx, u32 num_chains,
4935			      u32 rate_code, u8 type, u32 pream_idx)
4936{
4937	u8 tpc, num_streams, preamble, ch, stm_idx;
4938	s8 pow_agcdd, pow_agstbc, pow_agtxbf;
4939	int pream;
4940
4941	num_streams = ATH10K_HW_NSS(rate_code);
4942	preamble = ATH10K_HW_PREAMBLE(rate_code);
4943	ch = num_chains - 1;
4944	stm_idx = num_streams - 1;
4945	pream = -1;
4946
4947	if (__le32_to_cpu(ev->chan_freq) <= 2483) {
4948		switch (pream_idx) {
4949		case WMI_TPC_PREAM_2GHZ_CCK:
4950			pream = 0;
4951			break;
4952		case WMI_TPC_PREAM_2GHZ_OFDM:
4953			pream = 1;
4954			break;
4955		case WMI_TPC_PREAM_2GHZ_HT20:
4956		case WMI_TPC_PREAM_2GHZ_VHT20:
4957			pream = 2;
4958			break;
4959		case WMI_TPC_PREAM_2GHZ_HT40:
4960		case WMI_TPC_PREAM_2GHZ_VHT40:
4961			pream = 3;
4962			break;
4963		case WMI_TPC_PREAM_2GHZ_VHT80:
4964			pream = 4;
4965			break;
4966		default:
4967			pream = -1;
4968			break;
4969		}
4970	}
4971
4972	if (__le32_to_cpu(ev->chan_freq) >= 5180) {
4973		switch (pream_idx) {
4974		case WMI_TPC_PREAM_5GHZ_OFDM:
4975			pream = 0;
4976			break;
4977		case WMI_TPC_PREAM_5GHZ_HT20:
4978		case WMI_TPC_PREAM_5GHZ_VHT20:
4979			pream = 1;
4980			break;
4981		case WMI_TPC_PREAM_5GHZ_HT40:
4982		case WMI_TPC_PREAM_5GHZ_VHT40:
4983			pream = 2;
4984			break;
4985		case WMI_TPC_PREAM_5GHZ_VHT80:
4986			pream = 3;
4987			break;
4988		case WMI_TPC_PREAM_5GHZ_HTCUP:
4989			pream = 4;
4990			break;
4991		default:
4992			pream = -1;
4993			break;
4994		}
4995	}
4996
4997	if (pream == -1) {
4998		ath10k_warn(ar, "unknown wmi tpc final index and frequency: %u, %u\n",
4999			    pream_idx, __le32_to_cpu(ev->chan_freq));
5000		tpc = 0;
5001		goto out;
5002	}
5003
5004	if (pream == 4)
5005		tpc = min_t(u8, ev->rates_array[rate_idx],
5006			    ev->max_reg_allow_pow[ch]);
5007	else
5008		tpc = min_t(u8, min_t(u8, ev->rates_array[rate_idx],
5009				      ev->max_reg_allow_pow[ch]),
5010			    ev->ctl_power_table[0][pream][stm_idx]);
5011
5012	if (__le32_to_cpu(ev->num_tx_chain) <= 1)
5013		goto out;
5014
5015	if (preamble == WMI_RATE_PREAMBLE_CCK)
5016		goto out;
5017
5018	if (num_chains <= num_streams)
5019		goto out;
5020
5021	switch (type) {
5022	case WMI_TPC_TABLE_TYPE_STBC:
5023		pow_agstbc = ev->max_reg_allow_pow_agstbc[ch - 1][stm_idx];
5024		if (pream == 4)
5025			tpc = min_t(u8, tpc, pow_agstbc);
5026		else
5027			tpc = min_t(u8, min_t(u8, tpc, pow_agstbc),
5028				    ev->ctl_power_table[0][pream][stm_idx]);
5029		break;
5030	case WMI_TPC_TABLE_TYPE_TXBF:
5031		pow_agtxbf = ev->max_reg_allow_pow_agtxbf[ch - 1][stm_idx];
5032		if (pream == 4)
5033			tpc = min_t(u8, tpc, pow_agtxbf);
5034		else
5035			tpc = min_t(u8, min_t(u8, tpc, pow_agtxbf),
5036				    ev->ctl_power_table[1][pream][stm_idx]);
5037		break;
5038	case WMI_TPC_TABLE_TYPE_CDD:
5039		pow_agcdd = ev->max_reg_allow_pow_agcdd[ch - 1][stm_idx];
5040		if (pream == 4)
5041			tpc = min_t(u8, tpc, pow_agcdd);
5042		else
5043			tpc = min_t(u8, min_t(u8, tpc, pow_agcdd),
5044				    ev->ctl_power_table[0][pream][stm_idx]);
5045		break;
5046	default:
5047		ath10k_warn(ar, "unknown wmi tpc final table type: %d\n", type);
5048		tpc = 0;
5049		break;
5050	}
5051
5052out:
5053	return tpc;
5054}
5055
5056static void
5057ath10k_wmi_tpc_stats_final_disp_tables(struct ath10k *ar,
5058				       struct wmi_pdev_tpc_final_table_event *ev,
5059				       struct ath10k_tpc_stats_final *tpc_stats,
5060				       u8 *rate_code, u16 *pream_table, u8 type)
5061{
5062	u32 i, j, pream_idx, flags;
5063	u8 tpc[WMI_TPC_TX_N_CHAIN];
5064	char tpc_value[WMI_TPC_TX_N_CHAIN * WMI_TPC_BUF_SIZE];
5065	char buff[WMI_TPC_BUF_SIZE];
5066
5067	flags = __le32_to_cpu(ev->flags);
5068
5069	switch (type) {
5070	case WMI_TPC_TABLE_TYPE_CDD:
5071		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_CDD)) {
5072			ath10k_dbg(ar, ATH10K_DBG_WMI, "CDD not supported\n");
5073			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
5074			return;
5075		}
5076		break;
5077	case WMI_TPC_TABLE_TYPE_STBC:
5078		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_STBC)) {
5079			ath10k_dbg(ar, ATH10K_DBG_WMI, "STBC not supported\n");
5080			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
5081			return;
5082		}
5083		break;
5084	case WMI_TPC_TABLE_TYPE_TXBF:
5085		if (!(flags & WMI_TPC_CONFIG_EVENT_FLAG_TABLE_TXBF)) {
5086			ath10k_dbg(ar, ATH10K_DBG_WMI, "TXBF not supported\n");
5087			tpc_stats->flag[type] = ATH10K_TPC_TABLE_TYPE_FLAG;
5088			return;
5089		}
5090		break;
5091	default:
5092		ath10k_dbg(ar, ATH10K_DBG_WMI,
5093			   "invalid table type in wmi tpc event: %d\n", type);
5094		return;
5095	}
5096
5097	pream_idx = 0;
5098	for (i = 0; i < tpc_stats->rate_max; i++) {
5099		memset(tpc_value, 0, sizeof(tpc_value));
5100		memset(buff, 0, sizeof(buff));
5101		if (i == pream_table[pream_idx])
5102			pream_idx++;
5103
5104		for (j = 0; j < tpc_stats->num_tx_chain; j++) {
5105			tpc[j] = ath10k_wmi_tpc_final_get_rate(ar, ev, i, j + 1,
5106							       rate_code[i],
5107							       type, pream_idx);
5108			snprintf(buff, sizeof(buff), "%8d ", tpc[j]);
5109			strlcat(tpc_value, buff, sizeof(tpc_value));
5110		}
5111		tpc_stats->tpc_table_final[type].pream_idx[i] = pream_idx;
5112		tpc_stats->tpc_table_final[type].rate_code[i] = rate_code[i];
5113		memcpy(tpc_stats->tpc_table_final[type].tpc_value[i],
5114		       tpc_value, sizeof(tpc_value));
5115	}
5116}
5117
5118void ath10k_wmi_event_tpc_final_table(struct ath10k *ar, struct sk_buff *skb)
5119{
5120	u32 num_tx_chain, rate_max;
5121	u8 rate_code[WMI_TPC_FINAL_RATE_MAX];
5122	u16 pream_table[WMI_TPC_PREAM_TABLE_MAX];
5123	struct wmi_pdev_tpc_final_table_event *ev;
5124	struct ath10k_tpc_stats_final *tpc_stats;
5125
5126	ev = (struct wmi_pdev_tpc_final_table_event *)skb->data;
5127
5128	num_tx_chain = __le32_to_cpu(ev->num_tx_chain);
5129	if (num_tx_chain > WMI_TPC_TX_N_CHAIN) {
5130		ath10k_warn(ar, "number of tx chain is %d greater than TPC final configured tx chain %d\n",
5131			    num_tx_chain, WMI_TPC_TX_N_CHAIN);
5132		return;
5133	}
5134
5135	rate_max = __le32_to_cpu(ev->rate_max);
5136	if (rate_max > WMI_TPC_FINAL_RATE_MAX) {
5137		ath10k_warn(ar, "number of rate is %d greater than TPC final configured rate %d\n",
5138			    rate_max, WMI_TPC_FINAL_RATE_MAX);
5139		rate_max = WMI_TPC_FINAL_RATE_MAX;
5140	}
5141
5142	tpc_stats = kzalloc(sizeof(*tpc_stats), GFP_ATOMIC);
5143	if (!tpc_stats)
5144		return;
5145
5146	ath10k_wmi_tpc_config_get_rate_code(rate_code, pream_table,
5147					    num_tx_chain);
5148
5149	tpc_stats->chan_freq = __le32_to_cpu(ev->chan_freq);
5150	tpc_stats->phy_mode = __le32_to_cpu(ev->phy_mode);
5151	tpc_stats->ctl = __le32_to_cpu(ev->ctl);
5152	tpc_stats->reg_domain = __le32_to_cpu(ev->reg_domain);
5153	tpc_stats->twice_antenna_gain = a_sle32_to_cpu(ev->twice_antenna_gain);
5154	tpc_stats->twice_antenna_reduction =
5155		__le32_to_cpu(ev->twice_antenna_reduction);
5156	tpc_stats->power_limit = __le32_to_cpu(ev->power_limit);
5157	tpc_stats->twice_max_rd_power = __le32_to_cpu(ev->twice_max_rd_power);
5158	tpc_stats->num_tx_chain = num_tx_chain;
5159	tpc_stats->rate_max = rate_max;
5160
5161	ath10k_wmi_tpc_stats_final_disp_tables(ar, ev, tpc_stats,
5162					       rate_code, pream_table,
5163					       WMI_TPC_TABLE_TYPE_CDD);
5164	ath10k_wmi_tpc_stats_final_disp_tables(ar, ev,  tpc_stats,
5165					       rate_code, pream_table,
5166					       WMI_TPC_TABLE_TYPE_STBC);
5167	ath10k_wmi_tpc_stats_final_disp_tables(ar, ev, tpc_stats,
5168					       rate_code, pream_table,
5169					       WMI_TPC_TABLE_TYPE_TXBF);
5170
5171	ath10k_debug_tpc_stats_final_process(ar, tpc_stats);
5172
5173	ath10k_dbg(ar, ATH10K_DBG_WMI,
5174		   "wmi event tpc final table channel %d mode %d ctl %d regd %d gain %d %d limit %d max_power %d tx_chanins %d rates %d\n",
5175		   __le32_to_cpu(ev->chan_freq),
5176		   __le32_to_cpu(ev->phy_mode),
5177		   __le32_to_cpu(ev->ctl),
5178		   __le32_to_cpu(ev->reg_domain),
5179		   a_sle32_to_cpu(ev->twice_antenna_gain),
5180		   __le32_to_cpu(ev->twice_antenna_reduction),
5181		   __le32_to_cpu(ev->power_limit),
5182		   __le32_to_cpu(ev->twice_max_rd_power) / 2,
5183		   __le32_to_cpu(ev->num_tx_chain),
5184		   __le32_to_cpu(ev->rate_max));
5185}
5186
5187static void
5188ath10k_wmi_handle_tdls_peer_event(struct ath10k *ar, struct sk_buff *skb)
5189{
5190	struct wmi_tdls_peer_event *ev;
5191	struct ath10k_peer *peer;
5192	struct ath10k_vif *arvif;
5193	int vdev_id;
5194	int peer_status;
5195	int peer_reason;
5196	u8 reason;
5197
5198	if (skb->len < sizeof(*ev)) {
5199		ath10k_err(ar, "received tdls peer event with invalid size (%d bytes)\n",
5200			   skb->len);
5201		return;
5202	}
5203
5204	ev = (struct wmi_tdls_peer_event *)skb->data;
5205	vdev_id = __le32_to_cpu(ev->vdev_id);
5206	peer_status = __le32_to_cpu(ev->peer_status);
5207	peer_reason = __le32_to_cpu(ev->peer_reason);
5208
5209	spin_lock_bh(&ar->data_lock);
5210	peer = ath10k_peer_find(ar, vdev_id, ev->peer_macaddr.addr);
5211	spin_unlock_bh(&ar->data_lock);
5212
5213	if (!peer) {
5214		ath10k_warn(ar, "failed to find peer entry for %pM\n",
5215			    ev->peer_macaddr.addr);
5216		return;
5217	}
5218
5219	switch (peer_status) {
5220	case WMI_TDLS_SHOULD_TEARDOWN:
5221		switch (peer_reason) {
5222		case WMI_TDLS_TEARDOWN_REASON_PTR_TIMEOUT:
5223		case WMI_TDLS_TEARDOWN_REASON_NO_RESPONSE:
5224		case WMI_TDLS_TEARDOWN_REASON_RSSI:
5225			reason = WLAN_REASON_TDLS_TEARDOWN_UNREACHABLE;
5226			break;
5227		default:
5228			reason = WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED;
5229			break;
5230		}
5231
5232		arvif = ath10k_get_arvif(ar, vdev_id);
5233		if (!arvif) {
5234			ath10k_warn(ar, "received tdls peer event for invalid vdev id %u\n",
5235				    vdev_id);
5236			return;
5237		}
5238
5239		ieee80211_tdls_oper_request(arvif->vif, ev->peer_macaddr.addr,
5240					    NL80211_TDLS_TEARDOWN, reason,
5241					    GFP_ATOMIC);
5242
5243		ath10k_dbg(ar, ATH10K_DBG_WMI,
5244			   "received tdls teardown event for peer %pM reason %u\n",
5245			   ev->peer_macaddr.addr, peer_reason);
5246		break;
5247	default:
5248		ath10k_dbg(ar, ATH10K_DBG_WMI,
5249			   "received unknown tdls peer event %u\n",
5250			   peer_status);
5251		break;
5252	}
5253}
5254
5255static void
5256ath10k_wmi_event_peer_sta_ps_state_chg(struct ath10k *ar, struct sk_buff *skb)
5257{
5258	struct wmi_peer_sta_ps_state_chg_event *ev;
5259	struct ieee80211_sta *sta;
5260	struct ath10k_sta *arsta;
5261	u8 peer_addr[ETH_ALEN];
5262
5263	lockdep_assert_held(&ar->data_lock);
5264
5265	ev = (struct wmi_peer_sta_ps_state_chg_event *)skb->data;
5266	ether_addr_copy(peer_addr, ev->peer_macaddr.addr);
5267
5268	rcu_read_lock();
5269
5270	sta = ieee80211_find_sta_by_ifaddr(ar->hw, peer_addr, NULL);
5271
5272	if (!sta) {
5273		ath10k_warn(ar, "failed to find station entry %pM\n",
5274			    peer_addr);
5275		goto exit;
5276	}
5277
5278	arsta = (struct ath10k_sta *)sta->drv_priv;
5279	arsta->peer_ps_state = __le32_to_cpu(ev->peer_ps_state);
5280
5281exit:
5282	rcu_read_unlock();
5283}
5284
5285void ath10k_wmi_event_pdev_ftm_intg(struct ath10k *ar, struct sk_buff *skb)
5286{
5287	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_PDEV_FTM_INTG_EVENTID\n");
5288}
5289
5290void ath10k_wmi_event_gtk_offload_status(struct ath10k *ar, struct sk_buff *skb)
5291{
5292	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_GTK_OFFLOAD_STATUS_EVENTID\n");
5293}
5294
5295void ath10k_wmi_event_gtk_rekey_fail(struct ath10k *ar, struct sk_buff *skb)
5296{
5297	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_GTK_REKEY_FAIL_EVENTID\n");
5298}
5299
5300void ath10k_wmi_event_delba_complete(struct ath10k *ar, struct sk_buff *skb)
5301{
5302	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_TX_DELBA_COMPLETE_EVENTID\n");
5303}
5304
5305void ath10k_wmi_event_addba_complete(struct ath10k *ar, struct sk_buff *skb)
5306{
5307	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_TX_ADDBA_COMPLETE_EVENTID\n");
5308}
5309
5310void ath10k_wmi_event_vdev_install_key_complete(struct ath10k *ar,
5311						struct sk_buff *skb)
5312{
5313	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID\n");
5314}
5315
5316void ath10k_wmi_event_inst_rssi_stats(struct ath10k *ar, struct sk_buff *skb)
5317{
5318	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_INST_RSSI_STATS_EVENTID\n");
5319}
5320
5321void ath10k_wmi_event_vdev_standby_req(struct ath10k *ar, struct sk_buff *skb)
5322{
5323	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_VDEV_STANDBY_REQ_EVENTID\n");
5324}
5325
5326void ath10k_wmi_event_vdev_resume_req(struct ath10k *ar, struct sk_buff *skb)
5327{
5328	ath10k_dbg(ar, ATH10K_DBG_WMI, "WMI_VDEV_RESUME_REQ_EVENTID\n");
5329}
5330
5331static int ath10k_wmi_alloc_chunk(struct ath10k *ar, u32 req_id,
5332				  u32 num_units, u32 unit_len)
5333{
5334	dma_addr_t paddr;
5335	u32 pool_size;
5336	int idx = ar->wmi.num_mem_chunks;
5337	void *vaddr;
5338
5339	pool_size = num_units * round_up(unit_len, 4);
5340	vaddr = dma_alloc_coherent(ar->dev, pool_size, &paddr, GFP_KERNEL);
5341
5342	if (!vaddr)
5343		return -ENOMEM;
5344
5345	ar->wmi.mem_chunks[idx].vaddr = vaddr;
5346	ar->wmi.mem_chunks[idx].paddr = paddr;
5347	ar->wmi.mem_chunks[idx].len = pool_size;
5348	ar->wmi.mem_chunks[idx].req_id = req_id;
5349	ar->wmi.num_mem_chunks++;
5350
5351	return num_units;
5352}
5353
5354static int ath10k_wmi_alloc_host_mem(struct ath10k *ar, u32 req_id,
5355				     u32 num_units, u32 unit_len)
5356{
5357	int ret;
5358
5359	while (num_units) {
5360		ret = ath10k_wmi_alloc_chunk(ar, req_id, num_units, unit_len);
5361		if (ret < 0)
5362			return ret;
5363
5364		num_units -= ret;
5365	}
5366
5367	return 0;
5368}
5369
5370static bool
5371ath10k_wmi_is_host_mem_allocated(struct ath10k *ar,
5372				 const struct wlan_host_mem_req **mem_reqs,
5373				 u32 num_mem_reqs)
5374{
5375	u32 req_id, num_units, unit_size, num_unit_info;
5376	u32 pool_size;
5377	int i, j;
5378	bool found;
5379
5380	if (ar->wmi.num_mem_chunks != num_mem_reqs)
5381		return false;
5382
5383	for (i = 0; i < num_mem_reqs; ++i) {
5384		req_id = __le32_to_cpu(mem_reqs[i]->req_id);
5385		num_units = __le32_to_cpu(mem_reqs[i]->num_units);
5386		unit_size = __le32_to_cpu(mem_reqs[i]->unit_size);
5387		num_unit_info = __le32_to_cpu(mem_reqs[i]->num_unit_info);
5388
5389		if (num_unit_info & NUM_UNITS_IS_NUM_ACTIVE_PEERS) {
5390			if (ar->num_active_peers)
5391				num_units = ar->num_active_peers + 1;
5392			else
5393				num_units = ar->max_num_peers + 1;
5394		} else if (num_unit_info & NUM_UNITS_IS_NUM_PEERS) {
5395			num_units = ar->max_num_peers + 1;
5396		} else if (num_unit_info & NUM_UNITS_IS_NUM_VDEVS) {
5397			num_units = ar->max_num_vdevs + 1;
5398		}
5399
5400		found = false;
5401		for (j = 0; j < ar->wmi.num_mem_chunks; j++) {
5402			if (ar->wmi.mem_chunks[j].req_id == req_id) {
5403				pool_size = num_units * round_up(unit_size, 4);
5404				if (ar->wmi.mem_chunks[j].len == pool_size) {
5405					found = true;
5406					break;
5407				}
5408			}
5409		}
5410		if (!found)
5411			return false;
5412	}
5413
5414	return true;
5415}
5416
5417static int
5418ath10k_wmi_main_op_pull_svc_rdy_ev(struct ath10k *ar, struct sk_buff *skb,
5419				   struct wmi_svc_rdy_ev_arg *arg)
5420{
5421	struct wmi_service_ready_event *ev;
5422	size_t i, n;
5423
5424	if (skb->len < sizeof(*ev))
5425		return -EPROTO;
5426
5427	ev = (void *)skb->data;
5428	skb_pull(skb, sizeof(*ev));
5429	arg->min_tx_power = ev->hw_min_tx_power;
5430	arg->max_tx_power = ev->hw_max_tx_power;
5431	arg->ht_cap = ev->ht_cap_info;
5432	arg->vht_cap = ev->vht_cap_info;
5433	arg->vht_supp_mcs = ev->vht_supp_mcs;
5434	arg->sw_ver0 = ev->sw_version;
5435	arg->sw_ver1 = ev->sw_version_1;
5436	arg->phy_capab = ev->phy_capability;
5437	arg->num_rf_chains = ev->num_rf_chains;
5438	arg->eeprom_rd = ev->hal_reg_capabilities.eeprom_rd;
5439	arg->low_2ghz_chan = ev->hal_reg_capabilities.low_2ghz_chan;
5440	arg->high_2ghz_chan = ev->hal_reg_capabilities.high_2ghz_chan;
5441	arg->low_5ghz_chan = ev->hal_reg_capabilities.low_5ghz_chan;
5442	arg->high_5ghz_chan = ev->hal_reg_capabilities.high_5ghz_chan;
5443	arg->num_mem_reqs = ev->num_mem_reqs;
5444	arg->service_map = ev->wmi_service_bitmap;
5445	arg->service_map_len = sizeof(ev->wmi_service_bitmap);
5446
5447	n = min_t(size_t, __le32_to_cpu(arg->num_mem_reqs),
5448		  ARRAY_SIZE(arg->mem_reqs));
5449	for (i = 0; i < n; i++)
5450		arg->mem_reqs[i] = &ev->mem_reqs[i];
5451
5452	if (skb->len <
5453	    __le32_to_cpu(arg->num_mem_reqs) * sizeof(arg->mem_reqs[0]))
5454		return -EPROTO;
5455
5456	return 0;
5457}
5458
5459static int
5460ath10k_wmi_10x_op_pull_svc_rdy_ev(struct ath10k *ar, struct sk_buff *skb,
5461				  struct wmi_svc_rdy_ev_arg *arg)
5462{
5463	struct wmi_10x_service_ready_event *ev;
5464	int i, n;
5465
5466	if (skb->len < sizeof(*ev))
5467		return -EPROTO;
5468
5469	ev = (void *)skb->data;
5470	skb_pull(skb, sizeof(*ev));
5471	arg->min_tx_power = ev->hw_min_tx_power;
5472	arg->max_tx_power = ev->hw_max_tx_power;
5473	arg->ht_cap = ev->ht_cap_info;
5474	arg->vht_cap = ev->vht_cap_info;
5475	arg->vht_supp_mcs = ev->vht_supp_mcs;
5476	arg->sw_ver0 = ev->sw_version;
5477	arg->phy_capab = ev->phy_capability;
5478	arg->num_rf_chains = ev->num_rf_chains;
5479	arg->eeprom_rd = ev->hal_reg_capabilities.eeprom_rd;
5480	arg->low_2ghz_chan = ev->hal_reg_capabilities.low_2ghz_chan;
5481	arg->high_2ghz_chan = ev->hal_reg_capabilities.high_2ghz_chan;
5482	arg->low_5ghz_chan = ev->hal_reg_capabilities.low_5ghz_chan;
5483	arg->high_5ghz_chan = ev->hal_reg_capabilities.high_5ghz_chan;
5484	arg->num_mem_reqs = ev->num_mem_reqs;
5485	arg->service_map = ev->wmi_service_bitmap;
5486	arg->service_map_len = sizeof(ev->wmi_service_bitmap);
5487
5488	/* Deliberately skipping ev->sys_cap_info as WMI and WMI-TLV have
5489	 * different values. We would need a translation to handle that,
5490	 * but as we don't currently need anything from sys_cap_info from
5491	 * WMI interface (only from WMI-TLV) safest it to skip it.
5492	 */
5493
5494	n = min_t(size_t, __le32_to_cpu(arg->num_mem_reqs),
5495		  ARRAY_SIZE(arg->mem_reqs));
5496	for (i = 0; i < n; i++)
5497		arg->mem_reqs[i] = &ev->mem_reqs[i];
5498
5499	if (skb->len <
5500	    __le32_to_cpu(arg->num_mem_reqs) * sizeof(arg->mem_reqs[0]))
5501		return -EPROTO;
5502
5503	return 0;
5504}
5505
5506static void ath10k_wmi_event_service_ready_work(struct work_struct *work)
5507{
5508	struct ath10k *ar = container_of(work, struct ath10k, svc_rdy_work);
5509	struct sk_buff *skb = ar->svc_rdy_skb;
5510	struct wmi_svc_rdy_ev_arg arg = {};
5511	u32 num_units, req_id, unit_size, num_mem_reqs, num_unit_info, i;
5512	int ret;
5513	bool allocated;
5514
5515	if (!skb) {
5516		ath10k_warn(ar, "invalid service ready event skb\n");
5517		return;
5518	}
5519
5520	ret = ath10k_wmi_pull_svc_rdy(ar, skb, &arg);
5521	if (ret) {
5522		ath10k_warn(ar, "failed to parse service ready: %d\n", ret);
5523		return;
5524	}
5525
5526	ath10k_wmi_map_svc(ar, arg.service_map, ar->wmi.svc_map,
5527			   arg.service_map_len);
5528
5529	ar->hw_min_tx_power = __le32_to_cpu(arg.min_tx_power);
5530	ar->hw_max_tx_power = __le32_to_cpu(arg.max_tx_power);
5531	ar->ht_cap_info = __le32_to_cpu(arg.ht_cap);
5532	ar->vht_cap_info = __le32_to_cpu(arg.vht_cap);
5533	ar->vht_supp_mcs = __le32_to_cpu(arg.vht_supp_mcs);
5534	ar->fw_version_major =
5535		(__le32_to_cpu(arg.sw_ver0) & 0xff000000) >> 24;
5536	ar->fw_version_minor = (__le32_to_cpu(arg.sw_ver0) & 0x00ffffff);
5537	ar->fw_version_release =
5538		(__le32_to_cpu(arg.sw_ver1) & 0xffff0000) >> 16;
5539	ar->fw_version_build = (__le32_to_cpu(arg.sw_ver1) & 0x0000ffff);
5540	ar->phy_capability = __le32_to_cpu(arg.phy_capab);
5541	ar->num_rf_chains = __le32_to_cpu(arg.num_rf_chains);
5542	ar->hw_eeprom_rd = __le32_to_cpu(arg.eeprom_rd);
5543	ar->low_2ghz_chan = __le32_to_cpu(arg.low_2ghz_chan);
5544	ar->high_2ghz_chan = __le32_to_cpu(arg.high_2ghz_chan);
5545	ar->low_5ghz_chan = __le32_to_cpu(arg.low_5ghz_chan);
5546	ar->high_5ghz_chan = __le32_to_cpu(arg.high_5ghz_chan);
5547	ar->sys_cap_info = __le32_to_cpu(arg.sys_cap_info);
5548
5549	ath10k_dbg_dump(ar, ATH10K_DBG_WMI, NULL, "wmi svc: ",
5550			arg.service_map, arg.service_map_len);
5551	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi sys_cap_info 0x%x\n",
5552		   ar->sys_cap_info);
5553
5554	if (ar->num_rf_chains > ar->max_spatial_stream) {
5555		ath10k_warn(ar, "hardware advertises support for more spatial streams than it should (%d > %d)\n",
5556			    ar->num_rf_chains, ar->max_spatial_stream);
5557		ar->num_rf_chains = ar->max_spatial_stream;
5558	}
5559
5560	if (!ar->cfg_tx_chainmask) {
5561		ar->cfg_tx_chainmask = (1 << ar->num_rf_chains) - 1;
5562		ar->cfg_rx_chainmask = (1 << ar->num_rf_chains) - 1;
5563	}
5564
5565	if (strlen(ar->hw->wiphy->fw_version) == 0) {
5566		snprintf(ar->hw->wiphy->fw_version,
5567			 sizeof(ar->hw->wiphy->fw_version),
5568			 "%u.%u.%u.%u",
5569			 ar->fw_version_major,
5570			 ar->fw_version_minor,
5571			 ar->fw_version_release,
5572			 ar->fw_version_build);
5573	}
5574
5575	num_mem_reqs = __le32_to_cpu(arg.num_mem_reqs);
5576	if (num_mem_reqs > WMI_MAX_MEM_REQS) {
5577		ath10k_warn(ar, "requested memory chunks number (%d) exceeds the limit\n",
5578			    num_mem_reqs);
5579		return;
5580	}
5581
5582	if (test_bit(WMI_SERVICE_PEER_CACHING, ar->wmi.svc_map)) {
5583		if (test_bit(ATH10K_FW_FEATURE_PEER_FLOW_CONTROL,
5584			     ar->running_fw->fw_file.fw_features))
5585			ar->num_active_peers = TARGET_10_4_QCACHE_ACTIVE_PEERS_PFC +
5586					       ar->max_num_vdevs;
5587		else
5588			ar->num_active_peers = TARGET_10_4_QCACHE_ACTIVE_PEERS +
5589					       ar->max_num_vdevs;
5590
5591		ar->max_num_peers = TARGET_10_4_NUM_QCACHE_PEERS_MAX +
5592				    ar->max_num_vdevs;
5593		ar->num_tids = ar->num_active_peers * 2;
5594		ar->max_num_stations = TARGET_10_4_NUM_QCACHE_PEERS_MAX;
5595	}
5596
5597	/* TODO: Adjust max peer count for cases like WMI_SERVICE_RATECTRL_CACHE
5598	 * and WMI_SERVICE_IRAM_TIDS, etc.
5599	 */
5600
5601	allocated = ath10k_wmi_is_host_mem_allocated(ar, arg.mem_reqs,
5602						     num_mem_reqs);
5603	if (allocated)
5604		goto skip_mem_alloc;
5605
5606	/* Either this event is received during boot time or there is a change
5607	 * in memory requirement from firmware when compared to last request.
5608	 * Free any old memory and do a fresh allocation based on the current
5609	 * memory requirement.
5610	 */
5611	ath10k_wmi_free_host_mem(ar);
5612
5613	for (i = 0; i < num_mem_reqs; ++i) {
5614		req_id = __le32_to_cpu(arg.mem_reqs[i]->req_id);
5615		num_units = __le32_to_cpu(arg.mem_reqs[i]->num_units);
5616		unit_size = __le32_to_cpu(arg.mem_reqs[i]->unit_size);
5617		num_unit_info = __le32_to_cpu(arg.mem_reqs[i]->num_unit_info);
5618
5619		if (num_unit_info & NUM_UNITS_IS_NUM_ACTIVE_PEERS) {
5620			if (ar->num_active_peers)
5621				num_units = ar->num_active_peers + 1;
5622			else
5623				num_units = ar->max_num_peers + 1;
5624		} else if (num_unit_info & NUM_UNITS_IS_NUM_PEERS) {
5625			/* number of units to allocate is number of
5626			 * peers, 1 extra for self peer on target
5627			 * this needs to be tied, host and target
5628			 * can get out of sync
5629			 */
5630			num_units = ar->max_num_peers + 1;
5631		} else if (num_unit_info & NUM_UNITS_IS_NUM_VDEVS) {
5632			num_units = ar->max_num_vdevs + 1;
5633		}
5634
5635		ath10k_dbg(ar, ATH10K_DBG_WMI,
5636			   "wmi mem_req_id %d num_units %d num_unit_info %d unit size %d actual units %d\n",
5637			   req_id,
5638			   __le32_to_cpu(arg.mem_reqs[i]->num_units),
5639			   num_unit_info,
5640			   unit_size,
5641			   num_units);
5642
5643		ret = ath10k_wmi_alloc_host_mem(ar, req_id, num_units,
5644						unit_size);
5645		if (ret)
5646			return;
5647	}
5648
5649skip_mem_alloc:
5650	ath10k_dbg(ar, ATH10K_DBG_WMI,
5651		   "wmi event service ready min_tx_power 0x%08x max_tx_power 0x%08x ht_cap 0x%08x vht_cap 0x%08x vht_supp_mcs 0x%08x sw_ver0 0x%08x sw_ver1 0x%08x fw_build 0x%08x phy_capab 0x%08x num_rf_chains 0x%08x eeprom_rd 0x%08x low_2ghz_chan %d high_2ghz_chan %d low_5ghz_chan %d high_5ghz_chan %d num_mem_reqs 0x%08x\n",
5652		   __le32_to_cpu(arg.min_tx_power),
5653		   __le32_to_cpu(arg.max_tx_power),
5654		   __le32_to_cpu(arg.ht_cap),
5655		   __le32_to_cpu(arg.vht_cap),
5656		   __le32_to_cpu(arg.vht_supp_mcs),
5657		   __le32_to_cpu(arg.sw_ver0),
5658		   __le32_to_cpu(arg.sw_ver1),
5659		   __le32_to_cpu(arg.fw_build),
5660		   __le32_to_cpu(arg.phy_capab),
5661		   __le32_to_cpu(arg.num_rf_chains),
5662		   __le32_to_cpu(arg.eeprom_rd),
5663		   __le32_to_cpu(arg.low_2ghz_chan),
5664		   __le32_to_cpu(arg.high_2ghz_chan),
5665		   __le32_to_cpu(arg.low_5ghz_chan),
5666		   __le32_to_cpu(arg.high_5ghz_chan),
5667		   __le32_to_cpu(arg.num_mem_reqs));
5668
5669	dev_kfree_skb(skb);
5670	ar->svc_rdy_skb = NULL;
5671	complete(&ar->wmi.service_ready);
5672}
5673
5674void ath10k_wmi_event_service_ready(struct ath10k *ar, struct sk_buff *skb)
5675{
5676	ar->svc_rdy_skb = skb;
5677	queue_work(ar->workqueue_aux, &ar->svc_rdy_work);
5678}
5679
5680static int ath10k_wmi_op_pull_rdy_ev(struct ath10k *ar, struct sk_buff *skb,
5681				     struct wmi_rdy_ev_arg *arg)
5682{
5683	struct wmi_ready_event *ev = (void *)skb->data;
5684
5685	if (skb->len < sizeof(*ev))
5686		return -EPROTO;
5687
5688	skb_pull(skb, sizeof(*ev));
5689	arg->sw_version = ev->sw_version;
5690	arg->abi_version = ev->abi_version;
5691	arg->status = ev->status;
5692	arg->mac_addr = ev->mac_addr.addr;
5693
5694	return 0;
5695}
5696
5697static int ath10k_wmi_op_pull_roam_ev(struct ath10k *ar, struct sk_buff *skb,
5698				      struct wmi_roam_ev_arg *arg)
5699{
5700	struct wmi_roam_ev *ev = (void *)skb->data;
5701
5702	if (skb->len < sizeof(*ev))
5703		return -EPROTO;
5704
5705	skb_pull(skb, sizeof(*ev));
5706	arg->vdev_id = ev->vdev_id;
5707	arg->reason = ev->reason;
5708
5709	return 0;
5710}
5711
5712static int ath10k_wmi_op_pull_echo_ev(struct ath10k *ar,
5713				      struct sk_buff *skb,
5714				      struct wmi_echo_ev_arg *arg)
5715{
5716	struct wmi_echo_event *ev = (void *)skb->data;
5717
5718	arg->value = ev->value;
5719
5720	return 0;
5721}
5722
5723int ath10k_wmi_event_ready(struct ath10k *ar, struct sk_buff *skb)
5724{
5725	struct wmi_rdy_ev_arg arg = {};
5726	int ret;
5727
5728	ret = ath10k_wmi_pull_rdy(ar, skb, &arg);
5729	if (ret) {
5730		ath10k_warn(ar, "failed to parse ready event: %d\n", ret);
5731		return ret;
5732	}
5733
5734	ath10k_dbg(ar, ATH10K_DBG_WMI,
5735		   "wmi event ready sw_version 0x%08x abi_version %u mac_addr %pM status %d\n",
5736		   __le32_to_cpu(arg.sw_version),
5737		   __le32_to_cpu(arg.abi_version),
5738		   arg.mac_addr,
5739		   __le32_to_cpu(arg.status));
5740
5741	if (is_zero_ether_addr(ar->mac_addr))
5742		ether_addr_copy(ar->mac_addr, arg.mac_addr);
5743	complete(&ar->wmi.unified_ready);
5744	return 0;
5745}
5746
5747void ath10k_wmi_event_service_available(struct ath10k *ar, struct sk_buff *skb)
5748{
5749	int ret;
5750	struct wmi_svc_avail_ev_arg arg = {};
5751
5752	ret = ath10k_wmi_pull_svc_avail(ar, skb, &arg);
5753	if (ret) {
5754		ath10k_warn(ar, "failed to parse service available event: %d\n",
5755			    ret);
5756	}
5757
5758	/*
5759	 * Initialization of "arg.service_map_ext_valid" to ZERO is necessary
5760	 * for the below logic to work.
5761	 */
5762	if (arg.service_map_ext_valid)
5763		ath10k_wmi_map_svc_ext(ar, arg.service_map_ext, ar->wmi.svc_map,
5764				       __le32_to_cpu(arg.service_map_ext_len));
5765}
5766
5767static int ath10k_wmi_event_temperature(struct ath10k *ar, struct sk_buff *skb)
5768{
5769	const struct wmi_pdev_temperature_event *ev;
5770
5771	ev = (struct wmi_pdev_temperature_event *)skb->data;
5772	if (WARN_ON(skb->len < sizeof(*ev)))
5773		return -EPROTO;
5774
5775	ath10k_thermal_event_temperature(ar, __le32_to_cpu(ev->temperature));
5776	return 0;
5777}
5778
5779static int ath10k_wmi_event_pdev_bss_chan_info(struct ath10k *ar,
5780					       struct sk_buff *skb)
5781{
5782	struct wmi_pdev_bss_chan_info_event *ev;
5783	struct survey_info *survey;
5784	u64 busy, total, tx, rx, rx_bss;
5785	u32 freq, noise_floor;
5786	u32 cc_freq_hz = ar->hw_params.channel_counters_freq_hz;
5787	int idx;
5788
5789	ev = (struct wmi_pdev_bss_chan_info_event *)skb->data;
5790	if (WARN_ON(skb->len < sizeof(*ev)))
5791		return -EPROTO;
5792
5793	freq        = __le32_to_cpu(ev->freq);
5794	noise_floor = __le32_to_cpu(ev->noise_floor);
5795	busy        = __le64_to_cpu(ev->cycle_busy);
5796	total       = __le64_to_cpu(ev->cycle_total);
5797	tx          = __le64_to_cpu(ev->cycle_tx);
5798	rx          = __le64_to_cpu(ev->cycle_rx);
5799	rx_bss      = __le64_to_cpu(ev->cycle_rx_bss);
5800
5801	ath10k_dbg(ar, ATH10K_DBG_WMI,
5802		   "wmi event pdev bss chan info:\n freq: %d noise: %d cycle: busy %llu total %llu tx %llu rx %llu rx_bss %llu\n",
5803		   freq, noise_floor, busy, total, tx, rx, rx_bss);
5804
5805	spin_lock_bh(&ar->data_lock);
5806	idx = freq_to_idx(ar, freq);
5807	if (idx >= ARRAY_SIZE(ar->survey)) {
5808		ath10k_warn(ar, "bss chan info: invalid frequency %d (idx %d out of bounds)\n",
5809			    freq, idx);
5810		goto exit;
5811	}
5812
5813	survey = &ar->survey[idx];
5814
5815	survey->noise     = noise_floor;
5816	survey->time      = div_u64(total, cc_freq_hz);
5817	survey->time_busy = div_u64(busy, cc_freq_hz);
5818	survey->time_rx   = div_u64(rx_bss, cc_freq_hz);
5819	survey->time_tx   = div_u64(tx, cc_freq_hz);
5820	survey->filled   |= (SURVEY_INFO_NOISE_DBM |
5821			     SURVEY_INFO_TIME |
5822			     SURVEY_INFO_TIME_BUSY |
5823			     SURVEY_INFO_TIME_RX |
5824			     SURVEY_INFO_TIME_TX);
5825exit:
5826	spin_unlock_bh(&ar->data_lock);
5827	complete(&ar->bss_survey_done);
5828	return 0;
5829}
5830
5831static inline void ath10k_wmi_queue_set_coverage_class_work(struct ath10k *ar)
5832{
5833	if (ar->hw_params.hw_ops->set_coverage_class) {
5834		spin_lock_bh(&ar->data_lock);
5835
5836		/* This call only ensures that the modified coverage class
5837		 * persists in case the firmware sets the registers back to
5838		 * their default value. So calling it is only necessary if the
5839		 * coverage class has a non-zero value.
5840		 */
5841		if (ar->fw_coverage.coverage_class)
5842			queue_work(ar->workqueue, &ar->set_coverage_class_work);
5843
5844		spin_unlock_bh(&ar->data_lock);
5845	}
5846}
5847
5848static void ath10k_wmi_op_rx(struct ath10k *ar, struct sk_buff *skb)
5849{
5850	struct wmi_cmd_hdr *cmd_hdr;
5851	enum wmi_event_id id;
5852
5853	cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
5854	id = MS(__le32_to_cpu(cmd_hdr->cmd_id), WMI_CMD_HDR_CMD_ID);
5855
5856	if (skb_pull(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
5857		goto out;
5858
5859	trace_ath10k_wmi_event(ar, id, skb->data, skb->len);
5860
5861	switch (id) {
5862	case WMI_MGMT_RX_EVENTID:
5863		ath10k_wmi_event_mgmt_rx(ar, skb);
5864		/* mgmt_rx() owns the skb now! */
5865		return;
5866	case WMI_SCAN_EVENTID:
5867		ath10k_wmi_event_scan(ar, skb);
5868		ath10k_wmi_queue_set_coverage_class_work(ar);
5869		break;
5870	case WMI_CHAN_INFO_EVENTID:
5871		ath10k_wmi_event_chan_info(ar, skb);
5872		break;
5873	case WMI_ECHO_EVENTID:
5874		ath10k_wmi_event_echo(ar, skb);
5875		break;
5876	case WMI_DEBUG_MESG_EVENTID:
5877		ath10k_wmi_event_debug_mesg(ar, skb);
5878		ath10k_wmi_queue_set_coverage_class_work(ar);
5879		break;
5880	case WMI_UPDATE_STATS_EVENTID:
5881		ath10k_wmi_event_update_stats(ar, skb);
5882		break;
5883	case WMI_VDEV_START_RESP_EVENTID:
5884		ath10k_wmi_event_vdev_start_resp(ar, skb);
5885		ath10k_wmi_queue_set_coverage_class_work(ar);
5886		break;
5887	case WMI_VDEV_STOPPED_EVENTID:
5888		ath10k_wmi_event_vdev_stopped(ar, skb);
5889		ath10k_wmi_queue_set_coverage_class_work(ar);
5890		break;
5891	case WMI_PEER_STA_KICKOUT_EVENTID:
5892		ath10k_wmi_event_peer_sta_kickout(ar, skb);
5893		break;
5894	case WMI_HOST_SWBA_EVENTID:
5895		ath10k_wmi_event_host_swba(ar, skb);
5896		break;
5897	case WMI_TBTTOFFSET_UPDATE_EVENTID:
5898		ath10k_wmi_event_tbttoffset_update(ar, skb);
5899		break;
5900	case WMI_PHYERR_EVENTID:
5901		ath10k_wmi_event_phyerr(ar, skb);
5902		break;
5903	case WMI_ROAM_EVENTID:
5904		ath10k_wmi_event_roam(ar, skb);
5905		ath10k_wmi_queue_set_coverage_class_work(ar);
5906		break;
5907	case WMI_PROFILE_MATCH:
5908		ath10k_wmi_event_profile_match(ar, skb);
5909		break;
5910	case WMI_DEBUG_PRINT_EVENTID:
5911		ath10k_wmi_event_debug_print(ar, skb);
5912		ath10k_wmi_queue_set_coverage_class_work(ar);
5913		break;
5914	case WMI_PDEV_QVIT_EVENTID:
5915		ath10k_wmi_event_pdev_qvit(ar, skb);
5916		break;
5917	case WMI_WLAN_PROFILE_DATA_EVENTID:
5918		ath10k_wmi_event_wlan_profile_data(ar, skb);
5919		break;
5920	case WMI_RTT_MEASUREMENT_REPORT_EVENTID:
5921		ath10k_wmi_event_rtt_measurement_report(ar, skb);
5922		break;
5923	case WMI_TSF_MEASUREMENT_REPORT_EVENTID:
5924		ath10k_wmi_event_tsf_measurement_report(ar, skb);
5925		break;
5926	case WMI_RTT_ERROR_REPORT_EVENTID:
5927		ath10k_wmi_event_rtt_error_report(ar, skb);
5928		break;
5929	case WMI_WOW_WAKEUP_HOST_EVENTID:
5930		ath10k_wmi_event_wow_wakeup_host(ar, skb);
5931		break;
5932	case WMI_DCS_INTERFERENCE_EVENTID:
5933		ath10k_wmi_event_dcs_interference(ar, skb);
5934		break;
5935	case WMI_PDEV_TPC_CONFIG_EVENTID:
5936		ath10k_wmi_event_pdev_tpc_config(ar, skb);
5937		break;
5938	case WMI_PDEV_FTM_INTG_EVENTID:
5939		ath10k_wmi_event_pdev_ftm_intg(ar, skb);
5940		break;
5941	case WMI_GTK_OFFLOAD_STATUS_EVENTID:
5942		ath10k_wmi_event_gtk_offload_status(ar, skb);
5943		break;
5944	case WMI_GTK_REKEY_FAIL_EVENTID:
5945		ath10k_wmi_event_gtk_rekey_fail(ar, skb);
5946		break;
5947	case WMI_TX_DELBA_COMPLETE_EVENTID:
5948		ath10k_wmi_event_delba_complete(ar, skb);
5949		break;
5950	case WMI_TX_ADDBA_COMPLETE_EVENTID:
5951		ath10k_wmi_event_addba_complete(ar, skb);
5952		break;
5953	case WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID:
5954		ath10k_wmi_event_vdev_install_key_complete(ar, skb);
5955		break;
5956	case WMI_SERVICE_READY_EVENTID:
5957		ath10k_wmi_event_service_ready(ar, skb);
5958		return;
5959	case WMI_READY_EVENTID:
5960		ath10k_wmi_event_ready(ar, skb);
5961		ath10k_wmi_queue_set_coverage_class_work(ar);
5962		break;
5963	case WMI_SERVICE_AVAILABLE_EVENTID:
5964		ath10k_wmi_event_service_available(ar, skb);
5965		break;
5966	default:
5967		ath10k_warn(ar, "Unknown eventid: %d\n", id);
5968		break;
5969	}
5970
5971out:
5972	dev_kfree_skb(skb);
5973}
5974
5975static void ath10k_wmi_10_1_op_rx(struct ath10k *ar, struct sk_buff *skb)
5976{
5977	struct wmi_cmd_hdr *cmd_hdr;
5978	enum wmi_10x_event_id id;
5979	bool consumed;
5980
5981	cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
5982	id = MS(__le32_to_cpu(cmd_hdr->cmd_id), WMI_CMD_HDR_CMD_ID);
5983
5984	if (skb_pull(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
5985		goto out;
5986
5987	trace_ath10k_wmi_event(ar, id, skb->data, skb->len);
5988
5989	consumed = ath10k_tm_event_wmi(ar, id, skb);
5990
5991	/* Ready event must be handled normally also in UTF mode so that we
5992	 * know the UTF firmware has booted, others we are just bypass WMI
5993	 * events to testmode.
5994	 */
5995	if (consumed && id != WMI_10X_READY_EVENTID) {
5996		ath10k_dbg(ar, ATH10K_DBG_WMI,
5997			   "wmi testmode consumed 0x%x\n", id);
5998		goto out;
5999	}
6000
6001	switch (id) {
6002	case WMI_10X_MGMT_RX_EVENTID:
6003		ath10k_wmi_event_mgmt_rx(ar, skb);
6004		/* mgmt_rx() owns the skb now! */
6005		return;
6006	case WMI_10X_SCAN_EVENTID:
6007		ath10k_wmi_event_scan(ar, skb);
6008		ath10k_wmi_queue_set_coverage_class_work(ar);
6009		break;
6010	case WMI_10X_CHAN_INFO_EVENTID:
6011		ath10k_wmi_event_chan_info(ar, skb);
6012		break;
6013	case WMI_10X_ECHO_EVENTID:
6014		ath10k_wmi_event_echo(ar, skb);
6015		break;
6016	case WMI_10X_DEBUG_MESG_EVENTID:
6017		ath10k_wmi_event_debug_mesg(ar, skb);
6018		ath10k_wmi_queue_set_coverage_class_work(ar);
6019		break;
6020	case WMI_10X_UPDATE_STATS_EVENTID:
6021		ath10k_wmi_event_update_stats(ar, skb);
6022		break;
6023	case WMI_10X_VDEV_START_RESP_EVENTID:
6024		ath10k_wmi_event_vdev_start_resp(ar, skb);
6025		ath10k_wmi_queue_set_coverage_class_work(ar);
6026		break;
6027	case WMI_10X_VDEV_STOPPED_EVENTID:
6028		ath10k_wmi_event_vdev_stopped(ar, skb);
6029		ath10k_wmi_queue_set_coverage_class_work(ar);
6030		break;
6031	case WMI_10X_PEER_STA_KICKOUT_EVENTID:
6032		ath10k_wmi_event_peer_sta_kickout(ar, skb);
6033		break;
6034	case WMI_10X_HOST_SWBA_EVENTID:
6035		ath10k_wmi_event_host_swba(ar, skb);
6036		break;
6037	case WMI_10X_TBTTOFFSET_UPDATE_EVENTID:
6038		ath10k_wmi_event_tbttoffset_update(ar, skb);
6039		break;
6040	case WMI_10X_PHYERR_EVENTID:
6041		ath10k_wmi_event_phyerr(ar, skb);
6042		break;
6043	case WMI_10X_ROAM_EVENTID:
6044		ath10k_wmi_event_roam(ar, skb);
6045		ath10k_wmi_queue_set_coverage_class_work(ar);
6046		break;
6047	case WMI_10X_PROFILE_MATCH:
6048		ath10k_wmi_event_profile_match(ar, skb);
6049		break;
6050	case WMI_10X_DEBUG_PRINT_EVENTID:
6051		ath10k_wmi_event_debug_print(ar, skb);
6052		ath10k_wmi_queue_set_coverage_class_work(ar);
6053		break;
6054	case WMI_10X_PDEV_QVIT_EVENTID:
6055		ath10k_wmi_event_pdev_qvit(ar, skb);
6056		break;
6057	case WMI_10X_WLAN_PROFILE_DATA_EVENTID:
6058		ath10k_wmi_event_wlan_profile_data(ar, skb);
6059		break;
6060	case WMI_10X_RTT_MEASUREMENT_REPORT_EVENTID:
6061		ath10k_wmi_event_rtt_measurement_report(ar, skb);
6062		break;
6063	case WMI_10X_TSF_MEASUREMENT_REPORT_EVENTID:
6064		ath10k_wmi_event_tsf_measurement_report(ar, skb);
6065		break;
6066	case WMI_10X_RTT_ERROR_REPORT_EVENTID:
6067		ath10k_wmi_event_rtt_error_report(ar, skb);
6068		break;
6069	case WMI_10X_WOW_WAKEUP_HOST_EVENTID:
6070		ath10k_wmi_event_wow_wakeup_host(ar, skb);
6071		break;
6072	case WMI_10X_DCS_INTERFERENCE_EVENTID:
6073		ath10k_wmi_event_dcs_interference(ar, skb);
6074		break;
6075	case WMI_10X_PDEV_TPC_CONFIG_EVENTID:
6076		ath10k_wmi_event_pdev_tpc_config(ar, skb);
6077		break;
6078	case WMI_10X_INST_RSSI_STATS_EVENTID:
6079		ath10k_wmi_event_inst_rssi_stats(ar, skb);
6080		break;
6081	case WMI_10X_VDEV_STANDBY_REQ_EVENTID:
6082		ath10k_wmi_event_vdev_standby_req(ar, skb);
6083		break;
6084	case WMI_10X_VDEV_RESUME_REQ_EVENTID:
6085		ath10k_wmi_event_vdev_resume_req(ar, skb);
6086		break;
6087	case WMI_10X_SERVICE_READY_EVENTID:
6088		ath10k_wmi_event_service_ready(ar, skb);
6089		return;
6090	case WMI_10X_READY_EVENTID:
6091		ath10k_wmi_event_ready(ar, skb);
6092		ath10k_wmi_queue_set_coverage_class_work(ar);
6093		break;
6094	case WMI_10X_PDEV_UTF_EVENTID:
6095		/* ignore utf events */
6096		break;
6097	default:
6098		ath10k_warn(ar, "Unknown eventid: %d\n", id);
6099		break;
6100	}
6101
6102out:
6103	dev_kfree_skb(skb);
6104}
6105
6106static void ath10k_wmi_10_2_op_rx(struct ath10k *ar, struct sk_buff *skb)
6107{
6108	struct wmi_cmd_hdr *cmd_hdr;
6109	enum wmi_10_2_event_id id;
6110	bool consumed;
6111
6112	cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
6113	id = MS(__le32_to_cpu(cmd_hdr->cmd_id), WMI_CMD_HDR_CMD_ID);
6114
6115	if (skb_pull(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
6116		goto out;
6117
6118	trace_ath10k_wmi_event(ar, id, skb->data, skb->len);
6119
6120	consumed = ath10k_tm_event_wmi(ar, id, skb);
6121
6122	/* Ready event must be handled normally also in UTF mode so that we
6123	 * know the UTF firmware has booted, others we are just bypass WMI
6124	 * events to testmode.
6125	 */
6126	if (consumed && id != WMI_10_2_READY_EVENTID) {
6127		ath10k_dbg(ar, ATH10K_DBG_WMI,
6128			   "wmi testmode consumed 0x%x\n", id);
6129		goto out;
6130	}
6131
6132	switch (id) {
6133	case WMI_10_2_MGMT_RX_EVENTID:
6134		ath10k_wmi_event_mgmt_rx(ar, skb);
6135		/* mgmt_rx() owns the skb now! */
6136		return;
6137	case WMI_10_2_SCAN_EVENTID:
6138		ath10k_wmi_event_scan(ar, skb);
6139		ath10k_wmi_queue_set_coverage_class_work(ar);
6140		break;
6141	case WMI_10_2_CHAN_INFO_EVENTID:
6142		ath10k_wmi_event_chan_info(ar, skb);
6143		break;
6144	case WMI_10_2_ECHO_EVENTID:
6145		ath10k_wmi_event_echo(ar, skb);
6146		break;
6147	case WMI_10_2_DEBUG_MESG_EVENTID:
6148		ath10k_wmi_event_debug_mesg(ar, skb);
6149		ath10k_wmi_queue_set_coverage_class_work(ar);
6150		break;
6151	case WMI_10_2_UPDATE_STATS_EVENTID:
6152		ath10k_wmi_event_update_stats(ar, skb);
6153		break;
6154	case WMI_10_2_VDEV_START_RESP_EVENTID:
6155		ath10k_wmi_event_vdev_start_resp(ar, skb);
6156		ath10k_wmi_queue_set_coverage_class_work(ar);
6157		break;
6158	case WMI_10_2_VDEV_STOPPED_EVENTID:
6159		ath10k_wmi_event_vdev_stopped(ar, skb);
6160		ath10k_wmi_queue_set_coverage_class_work(ar);
6161		break;
6162	case WMI_10_2_PEER_STA_KICKOUT_EVENTID:
6163		ath10k_wmi_event_peer_sta_kickout(ar, skb);
6164		break;
6165	case WMI_10_2_HOST_SWBA_EVENTID:
6166		ath10k_wmi_event_host_swba(ar, skb);
6167		break;
6168	case WMI_10_2_TBTTOFFSET_UPDATE_EVENTID:
6169		ath10k_wmi_event_tbttoffset_update(ar, skb);
6170		break;
6171	case WMI_10_2_PHYERR_EVENTID:
6172		ath10k_wmi_event_phyerr(ar, skb);
6173		break;
6174	case WMI_10_2_ROAM_EVENTID:
6175		ath10k_wmi_event_roam(ar, skb);
6176		ath10k_wmi_queue_set_coverage_class_work(ar);
6177		break;
6178	case WMI_10_2_PROFILE_MATCH:
6179		ath10k_wmi_event_profile_match(ar, skb);
6180		break;
6181	case WMI_10_2_DEBUG_PRINT_EVENTID:
6182		ath10k_wmi_event_debug_print(ar, skb);
6183		ath10k_wmi_queue_set_coverage_class_work(ar);
6184		break;
6185	case WMI_10_2_PDEV_QVIT_EVENTID:
6186		ath10k_wmi_event_pdev_qvit(ar, skb);
6187		break;
6188	case WMI_10_2_WLAN_PROFILE_DATA_EVENTID:
6189		ath10k_wmi_event_wlan_profile_data(ar, skb);
6190		break;
6191	case WMI_10_2_RTT_MEASUREMENT_REPORT_EVENTID:
6192		ath10k_wmi_event_rtt_measurement_report(ar, skb);
6193		break;
6194	case WMI_10_2_TSF_MEASUREMENT_REPORT_EVENTID:
6195		ath10k_wmi_event_tsf_measurement_report(ar, skb);
6196		break;
6197	case WMI_10_2_RTT_ERROR_REPORT_EVENTID:
6198		ath10k_wmi_event_rtt_error_report(ar, skb);
6199		break;
6200	case WMI_10_2_WOW_WAKEUP_HOST_EVENTID:
6201		ath10k_wmi_event_wow_wakeup_host(ar, skb);
6202		break;
6203	case WMI_10_2_DCS_INTERFERENCE_EVENTID:
6204		ath10k_wmi_event_dcs_interference(ar, skb);
6205		break;
6206	case WMI_10_2_PDEV_TPC_CONFIG_EVENTID:
6207		ath10k_wmi_event_pdev_tpc_config(ar, skb);
6208		break;
6209	case WMI_10_2_INST_RSSI_STATS_EVENTID:
6210		ath10k_wmi_event_inst_rssi_stats(ar, skb);
6211		break;
6212	case WMI_10_2_VDEV_STANDBY_REQ_EVENTID:
6213		ath10k_wmi_event_vdev_standby_req(ar, skb);
6214		ath10k_wmi_queue_set_coverage_class_work(ar);
6215		break;
6216	case WMI_10_2_VDEV_RESUME_REQ_EVENTID:
6217		ath10k_wmi_event_vdev_resume_req(ar, skb);
6218		ath10k_wmi_queue_set_coverage_class_work(ar);
6219		break;
6220	case WMI_10_2_SERVICE_READY_EVENTID:
6221		ath10k_wmi_event_service_ready(ar, skb);
6222		return;
6223	case WMI_10_2_READY_EVENTID:
6224		ath10k_wmi_event_ready(ar, skb);
6225		ath10k_wmi_queue_set_coverage_class_work(ar);
6226		break;
6227	case WMI_10_2_PDEV_TEMPERATURE_EVENTID:
6228		ath10k_wmi_event_temperature(ar, skb);
6229		break;
6230	case WMI_10_2_PDEV_BSS_CHAN_INFO_EVENTID:
6231		ath10k_wmi_event_pdev_bss_chan_info(ar, skb);
6232		break;
6233	case WMI_10_2_RTT_KEEPALIVE_EVENTID:
6234	case WMI_10_2_GPIO_INPUT_EVENTID:
6235	case WMI_10_2_PEER_RATECODE_LIST_EVENTID:
6236	case WMI_10_2_GENERIC_BUFFER_EVENTID:
6237	case WMI_10_2_MCAST_BUF_RELEASE_EVENTID:
6238	case WMI_10_2_MCAST_LIST_AGEOUT_EVENTID:
6239	case WMI_10_2_WDS_PEER_EVENTID:
6240		ath10k_dbg(ar, ATH10K_DBG_WMI,
6241			   "received event id %d not implemented\n", id);
6242		break;
6243	case WMI_10_2_PEER_STA_PS_STATECHG_EVENTID:
6244		ath10k_wmi_event_peer_sta_ps_state_chg(ar, skb);
6245		break;
6246	default:
6247		ath10k_warn(ar, "Unknown eventid: %d\n", id);
6248		break;
6249	}
6250
6251out:
6252	dev_kfree_skb(skb);
6253}
6254
6255static void ath10k_wmi_10_4_op_rx(struct ath10k *ar, struct sk_buff *skb)
6256{
6257	struct wmi_cmd_hdr *cmd_hdr;
6258	enum wmi_10_4_event_id id;
6259	bool consumed;
6260
6261	cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
6262	id = MS(__le32_to_cpu(cmd_hdr->cmd_id), WMI_CMD_HDR_CMD_ID);
6263
6264	if (!skb_pull(skb, sizeof(struct wmi_cmd_hdr)))
6265		goto out;
6266
6267	trace_ath10k_wmi_event(ar, id, skb->data, skb->len);
6268
6269	consumed = ath10k_tm_event_wmi(ar, id, skb);
6270
6271	/* Ready event must be handled normally also in UTF mode so that we
6272	 * know the UTF firmware has booted, others we are just bypass WMI
6273	 * events to testmode.
6274	 */
6275	if (consumed && id != WMI_10_4_READY_EVENTID) {
6276		ath10k_dbg(ar, ATH10K_DBG_WMI,
6277			   "wmi testmode consumed 0x%x\n", id);
6278		goto out;
6279	}
6280
6281	switch (id) {
6282	case WMI_10_4_MGMT_RX_EVENTID:
6283		ath10k_wmi_event_mgmt_rx(ar, skb);
6284		/* mgmt_rx() owns the skb now! */
6285		return;
6286	case WMI_10_4_ECHO_EVENTID:
6287		ath10k_wmi_event_echo(ar, skb);
6288		break;
6289	case WMI_10_4_DEBUG_MESG_EVENTID:
6290		ath10k_wmi_event_debug_mesg(ar, skb);
6291		ath10k_wmi_queue_set_coverage_class_work(ar);
6292		break;
6293	case WMI_10_4_SERVICE_READY_EVENTID:
6294		ath10k_wmi_event_service_ready(ar, skb);
6295		return;
6296	case WMI_10_4_SCAN_EVENTID:
6297		ath10k_wmi_event_scan(ar, skb);
6298		ath10k_wmi_queue_set_coverage_class_work(ar);
6299		break;
6300	case WMI_10_4_CHAN_INFO_EVENTID:
6301		ath10k_wmi_event_chan_info(ar, skb);
6302		break;
6303	case WMI_10_4_PHYERR_EVENTID:
6304		ath10k_wmi_event_phyerr(ar, skb);
6305		break;
6306	case WMI_10_4_READY_EVENTID:
6307		ath10k_wmi_event_ready(ar, skb);
6308		ath10k_wmi_queue_set_coverage_class_work(ar);
6309		break;
6310	case WMI_10_4_PEER_STA_KICKOUT_EVENTID:
6311		ath10k_wmi_event_peer_sta_kickout(ar, skb);
6312		break;
6313	case WMI_10_4_ROAM_EVENTID:
6314		ath10k_wmi_event_roam(ar, skb);
6315		ath10k_wmi_queue_set_coverage_class_work(ar);
6316		break;
6317	case WMI_10_4_HOST_SWBA_EVENTID:
6318		ath10k_wmi_event_host_swba(ar, skb);
6319		break;
6320	case WMI_10_4_TBTTOFFSET_UPDATE_EVENTID:
6321		ath10k_wmi_event_tbttoffset_update(ar, skb);
6322		break;
6323	case WMI_10_4_DEBUG_PRINT_EVENTID:
6324		ath10k_wmi_event_debug_print(ar, skb);
6325		ath10k_wmi_queue_set_coverage_class_work(ar);
6326		break;
6327	case WMI_10_4_VDEV_START_RESP_EVENTID:
6328		ath10k_wmi_event_vdev_start_resp(ar, skb);
6329		ath10k_wmi_queue_set_coverage_class_work(ar);
6330		break;
6331	case WMI_10_4_VDEV_STOPPED_EVENTID:
6332		ath10k_wmi_event_vdev_stopped(ar, skb);
6333		ath10k_wmi_queue_set_coverage_class_work(ar);
6334		break;
6335	case WMI_10_4_WOW_WAKEUP_HOST_EVENTID:
6336	case WMI_10_4_PEER_RATECODE_LIST_EVENTID:
6337	case WMI_10_4_WDS_PEER_EVENTID:
6338	case WMI_10_4_DEBUG_FATAL_CONDITION_EVENTID:
6339		ath10k_dbg(ar, ATH10K_DBG_WMI,
6340			   "received event id %d not implemented\n", id);
6341		break;
6342	case WMI_10_4_UPDATE_STATS_EVENTID:
6343		ath10k_wmi_event_update_stats(ar, skb);
6344		break;
6345	case WMI_10_4_PDEV_TEMPERATURE_EVENTID:
6346		ath10k_wmi_event_temperature(ar, skb);
6347		break;
6348	case WMI_10_4_PDEV_BSS_CHAN_INFO_EVENTID:
6349		ath10k_wmi_event_pdev_bss_chan_info(ar, skb);
6350		break;
6351	case WMI_10_4_PDEV_TPC_CONFIG_EVENTID:
6352		ath10k_wmi_event_pdev_tpc_config(ar, skb);
6353		break;
6354	case WMI_10_4_TDLS_PEER_EVENTID:
6355		ath10k_wmi_handle_tdls_peer_event(ar, skb);
6356		break;
6357	case WMI_10_4_PDEV_TPC_TABLE_EVENTID:
6358		ath10k_wmi_event_tpc_final_table(ar, skb);
6359		break;
6360	case WMI_10_4_DFS_STATUS_CHECK_EVENTID:
6361		ath10k_wmi_event_dfs_status_check(ar, skb);
6362		break;
6363	case WMI_10_4_PEER_STA_PS_STATECHG_EVENTID:
6364		ath10k_wmi_event_peer_sta_ps_state_chg(ar, skb);
6365		break;
6366	default:
6367		ath10k_warn(ar, "Unknown eventid: %d\n", id);
6368		break;
6369	}
6370
6371out:
6372	dev_kfree_skb(skb);
6373}
6374
6375static void ath10k_wmi_process_rx(struct ath10k *ar, struct sk_buff *skb)
6376{
6377	int ret;
6378
6379	ret = ath10k_wmi_rx(ar, skb);
6380	if (ret)
6381		ath10k_warn(ar, "failed to process wmi rx: %d\n", ret);
6382}
6383
6384int ath10k_wmi_connect(struct ath10k *ar)
6385{
6386	int status;
6387	struct ath10k_htc_svc_conn_req conn_req;
6388	struct ath10k_htc_svc_conn_resp conn_resp;
6389
6390	memset(&ar->wmi.svc_map, 0, sizeof(ar->wmi.svc_map));
6391
6392	memset(&conn_req, 0, sizeof(conn_req));
6393	memset(&conn_resp, 0, sizeof(conn_resp));
6394
6395	/* these fields are the same for all service endpoints */
6396	conn_req.ep_ops.ep_tx_complete = ath10k_wmi_htc_tx_complete;
6397	conn_req.ep_ops.ep_rx_complete = ath10k_wmi_process_rx;
6398	conn_req.ep_ops.ep_tx_credits = ath10k_wmi_op_ep_tx_credits;
6399
6400	/* connect to control service */
6401	conn_req.service_id = ATH10K_HTC_SVC_ID_WMI_CONTROL;
6402
6403	status = ath10k_htc_connect_service(&ar->htc, &conn_req, &conn_resp);
6404	if (status) {
6405		ath10k_warn(ar, "failed to connect to WMI CONTROL service status: %d\n",
6406			    status);
6407		return status;
6408	}
6409
6410	ar->wmi.eid = conn_resp.eid;
6411	return 0;
6412}
6413
6414static struct sk_buff *
6415ath10k_wmi_op_gen_pdev_set_base_macaddr(struct ath10k *ar,
6416					const u8 macaddr[ETH_ALEN])
6417{
6418	struct wmi_pdev_set_base_macaddr_cmd *cmd;
6419	struct sk_buff *skb;
6420
6421	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
6422	if (!skb)
6423		return ERR_PTR(-ENOMEM);
6424
6425	cmd = (struct wmi_pdev_set_base_macaddr_cmd *)skb->data;
6426	ether_addr_copy(cmd->mac_addr.addr, macaddr);
6427
6428	ath10k_dbg(ar, ATH10K_DBG_WMI,
6429		   "wmi pdev basemac %pM\n", macaddr);
6430	return skb;
6431}
6432
6433static struct sk_buff *
6434ath10k_wmi_op_gen_pdev_set_rd(struct ath10k *ar, u16 rd, u16 rd2g, u16 rd5g,
6435			      u16 ctl2g, u16 ctl5g,
6436			      enum wmi_dfs_region dfs_reg)
6437{
6438	struct wmi_pdev_set_regdomain_cmd *cmd;
6439	struct sk_buff *skb;
6440
6441	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
6442	if (!skb)
6443		return ERR_PTR(-ENOMEM);
6444
6445	cmd = (struct wmi_pdev_set_regdomain_cmd *)skb->data;
6446	cmd->reg_domain = __cpu_to_le32(rd);
6447	cmd->reg_domain_2G = __cpu_to_le32(rd2g);
6448	cmd->reg_domain_5G = __cpu_to_le32(rd5g);
6449	cmd->conformance_test_limit_2G = __cpu_to_le32(ctl2g);
6450	cmd->conformance_test_limit_5G = __cpu_to_le32(ctl5g);
6451
6452	ath10k_dbg(ar, ATH10K_DBG_WMI,
6453		   "wmi pdev regdomain rd %x rd2g %x rd5g %x ctl2g %x ctl5g %x\n",
6454		   rd, rd2g, rd5g, ctl2g, ctl5g);
6455	return skb;
6456}
6457
6458static struct sk_buff *
6459ath10k_wmi_10x_op_gen_pdev_set_rd(struct ath10k *ar, u16 rd, u16 rd2g, u16
6460				  rd5g, u16 ctl2g, u16 ctl5g,
6461				  enum wmi_dfs_region dfs_reg)
6462{
6463	struct wmi_pdev_set_regdomain_cmd_10x *cmd;
6464	struct sk_buff *skb;
6465
6466	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
6467	if (!skb)
6468		return ERR_PTR(-ENOMEM);
6469
6470	cmd = (struct wmi_pdev_set_regdomain_cmd_10x *)skb->data;
6471	cmd->reg_domain = __cpu_to_le32(rd);
6472	cmd->reg_domain_2G = __cpu_to_le32(rd2g);
6473	cmd->reg_domain_5G = __cpu_to_le32(rd5g);
6474	cmd->conformance_test_limit_2G = __cpu_to_le32(ctl2g);
6475	cmd->conformance_test_limit_5G = __cpu_to_le32(ctl5g);
6476	cmd->dfs_domain = __cpu_to_le32(dfs_reg);
6477
6478	ath10k_dbg(ar, ATH10K_DBG_WMI,
6479		   "wmi pdev regdomain rd %x rd2g %x rd5g %x ctl2g %x ctl5g %x dfs_region %x\n",
6480		   rd, rd2g, rd5g, ctl2g, ctl5g, dfs_reg);
6481	return skb;
6482}
6483
6484static struct sk_buff *
6485ath10k_wmi_op_gen_pdev_suspend(struct ath10k *ar, u32 suspend_opt)
6486{
6487	struct wmi_pdev_suspend_cmd *cmd;
6488	struct sk_buff *skb;
6489
6490	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
6491	if (!skb)
6492		return ERR_PTR(-ENOMEM);
6493
6494	cmd = (struct wmi_pdev_suspend_cmd *)skb->data;
6495	cmd->suspend_opt = __cpu_to_le32(suspend_opt);
6496
6497	return skb;
6498}
6499
6500static struct sk_buff *
6501ath10k_wmi_op_gen_pdev_resume(struct ath10k *ar)
6502{
6503	struct sk_buff *skb;
6504
6505	skb = ath10k_wmi_alloc_skb(ar, 0);
6506	if (!skb)
6507		return ERR_PTR(-ENOMEM);
6508
6509	return skb;
6510}
6511
6512static struct sk_buff *
6513ath10k_wmi_op_gen_pdev_set_param(struct ath10k *ar, u32 id, u32 value)
6514{
6515	struct wmi_pdev_set_param_cmd *cmd;
6516	struct sk_buff *skb;
6517
6518	if (id == WMI_PDEV_PARAM_UNSUPPORTED) {
6519		ath10k_warn(ar, "pdev param %d not supported by firmware\n",
6520			    id);
6521		return ERR_PTR(-EOPNOTSUPP);
6522	}
6523
6524	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
6525	if (!skb)
6526		return ERR_PTR(-ENOMEM);
6527
6528	cmd = (struct wmi_pdev_set_param_cmd *)skb->data;
6529	cmd->param_id    = __cpu_to_le32(id);
6530	cmd->param_value = __cpu_to_le32(value);
6531
6532	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi pdev set param %d value %d\n",
6533		   id, value);
6534	return skb;
6535}
6536
6537void ath10k_wmi_put_host_mem_chunks(struct ath10k *ar,
6538				    struct wmi_host_mem_chunks *chunks)
6539{
6540	struct host_memory_chunk *chunk;
6541	int i;
6542
6543	chunks->count = __cpu_to_le32(ar->wmi.num_mem_chunks);
6544
6545	for (i = 0; i < ar->wmi.num_mem_chunks; i++) {
6546		chunk = &chunks->items[i];
6547		chunk->ptr = __cpu_to_le32(ar->wmi.mem_chunks[i].paddr);
6548		chunk->size = __cpu_to_le32(ar->wmi.mem_chunks[i].len);
6549		chunk->req_id = __cpu_to_le32(ar->wmi.mem_chunks[i].req_id);
6550
6551		ath10k_dbg(ar, ATH10K_DBG_WMI,
6552			   "wmi chunk %d len %d requested, addr 0x%llx\n",
6553			   i,
6554			   ar->wmi.mem_chunks[i].len,
6555			   (unsigned long long)ar->wmi.mem_chunks[i].paddr);
6556	}
6557}
6558
6559static struct sk_buff *ath10k_wmi_op_gen_init(struct ath10k *ar)
6560{
6561	struct wmi_init_cmd *cmd;
6562	struct sk_buff *buf;
6563	struct wmi_resource_config config = {};
6564	u32 val;
6565
6566	config.num_vdevs = __cpu_to_le32(TARGET_NUM_VDEVS);
6567	config.num_peers = __cpu_to_le32(TARGET_NUM_PEERS);
6568	config.num_offload_peers = __cpu_to_le32(TARGET_NUM_OFFLOAD_PEERS);
6569
6570	config.num_offload_reorder_bufs =
6571		__cpu_to_le32(TARGET_NUM_OFFLOAD_REORDER_BUFS);
6572
6573	config.num_peer_keys = __cpu_to_le32(TARGET_NUM_PEER_KEYS);
6574	config.num_tids = __cpu_to_le32(TARGET_NUM_TIDS);
6575	config.ast_skid_limit = __cpu_to_le32(TARGET_AST_SKID_LIMIT);
6576	config.tx_chain_mask = __cpu_to_le32(TARGET_TX_CHAIN_MASK);
6577	config.rx_chain_mask = __cpu_to_le32(TARGET_RX_CHAIN_MASK);
6578	config.rx_timeout_pri_vo = __cpu_to_le32(TARGET_RX_TIMEOUT_LO_PRI);
6579	config.rx_timeout_pri_vi = __cpu_to_le32(TARGET_RX_TIMEOUT_LO_PRI);
6580	config.rx_timeout_pri_be = __cpu_to_le32(TARGET_RX_TIMEOUT_LO_PRI);
6581	config.rx_timeout_pri_bk = __cpu_to_le32(TARGET_RX_TIMEOUT_HI_PRI);
6582	config.rx_decap_mode = __cpu_to_le32(ar->wmi.rx_decap_mode);
6583	config.scan_max_pending_reqs =
6584		__cpu_to_le32(TARGET_SCAN_MAX_PENDING_REQS);
6585
6586	config.bmiss_offload_max_vdev =
6587		__cpu_to_le32(TARGET_BMISS_OFFLOAD_MAX_VDEV);
6588
6589	config.roam_offload_max_vdev =
6590		__cpu_to_le32(TARGET_ROAM_OFFLOAD_MAX_VDEV);
6591
6592	config.roam_offload_max_ap_profiles =
6593		__cpu_to_le32(TARGET_ROAM_OFFLOAD_MAX_AP_PROFILES);
6594
6595	config.num_mcast_groups = __cpu_to_le32(TARGET_NUM_MCAST_GROUPS);
6596	config.num_mcast_table_elems =
6597		__cpu_to_le32(TARGET_NUM_MCAST_TABLE_ELEMS);
6598
6599	config.mcast2ucast_mode = __cpu_to_le32(TARGET_MCAST2UCAST_MODE);
6600	config.tx_dbg_log_size = __cpu_to_le32(TARGET_TX_DBG_LOG_SIZE);
6601	config.num_wds_entries = __cpu_to_le32(TARGET_NUM_WDS_ENTRIES);
6602	config.dma_burst_size = __cpu_to_le32(TARGET_DMA_BURST_SIZE);
6603	config.mac_aggr_delim = __cpu_to_le32(TARGET_MAC_AGGR_DELIM);
6604
6605	val = TARGET_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK;
6606	config.rx_skip_defrag_timeout_dup_detection_check = __cpu_to_le32(val);
6607
6608	config.vow_config = __cpu_to_le32(TARGET_VOW_CONFIG);
6609
6610	config.gtk_offload_max_vdev =
6611		__cpu_to_le32(TARGET_GTK_OFFLOAD_MAX_VDEV);
6612
6613	config.num_msdu_desc = __cpu_to_le32(TARGET_NUM_MSDU_DESC);
6614	config.max_frag_entries = __cpu_to_le32(TARGET_MAX_FRAG_ENTRIES);
6615
6616	buf = ath10k_wmi_alloc_skb(ar, struct_size(cmd, mem_chunks.items,
6617						   ar->wmi.num_mem_chunks));
6618	if (!buf)
6619		return ERR_PTR(-ENOMEM);
6620
6621	cmd = (struct wmi_init_cmd *)buf->data;
6622
6623	memcpy(&cmd->resource_config, &config, sizeof(config));
6624	ath10k_wmi_put_host_mem_chunks(ar, &cmd->mem_chunks);
6625
6626	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi init\n");
6627	return buf;
6628}
6629
6630static struct sk_buff *ath10k_wmi_10_1_op_gen_init(struct ath10k *ar)
6631{
6632	struct wmi_init_cmd_10x *cmd;
6633	struct sk_buff *buf;
6634	struct wmi_resource_config_10x config = {};
6635	u32 val;
6636
6637	config.num_vdevs = __cpu_to_le32(TARGET_10X_NUM_VDEVS);
6638	config.num_peers = __cpu_to_le32(TARGET_10X_NUM_PEERS);
6639	config.num_peer_keys = __cpu_to_le32(TARGET_10X_NUM_PEER_KEYS);
6640	config.num_tids = __cpu_to_le32(TARGET_10X_NUM_TIDS);
6641	config.ast_skid_limit = __cpu_to_le32(TARGET_10X_AST_SKID_LIMIT);
6642	config.tx_chain_mask = __cpu_to_le32(TARGET_10X_TX_CHAIN_MASK);
6643	config.rx_chain_mask = __cpu_to_le32(TARGET_10X_RX_CHAIN_MASK);
6644	config.rx_timeout_pri_vo = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6645	config.rx_timeout_pri_vi = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6646	config.rx_timeout_pri_be = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6647	config.rx_timeout_pri_bk = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_HI_PRI);
6648	config.rx_decap_mode = __cpu_to_le32(ar->wmi.rx_decap_mode);
6649	config.scan_max_pending_reqs =
6650		__cpu_to_le32(TARGET_10X_SCAN_MAX_PENDING_REQS);
6651
6652	config.bmiss_offload_max_vdev =
6653		__cpu_to_le32(TARGET_10X_BMISS_OFFLOAD_MAX_VDEV);
6654
6655	config.roam_offload_max_vdev =
6656		__cpu_to_le32(TARGET_10X_ROAM_OFFLOAD_MAX_VDEV);
6657
6658	config.roam_offload_max_ap_profiles =
6659		__cpu_to_le32(TARGET_10X_ROAM_OFFLOAD_MAX_AP_PROFILES);
6660
6661	config.num_mcast_groups = __cpu_to_le32(TARGET_10X_NUM_MCAST_GROUPS);
6662	config.num_mcast_table_elems =
6663		__cpu_to_le32(TARGET_10X_NUM_MCAST_TABLE_ELEMS);
6664
6665	config.mcast2ucast_mode = __cpu_to_le32(TARGET_10X_MCAST2UCAST_MODE);
6666	config.tx_dbg_log_size = __cpu_to_le32(TARGET_10X_TX_DBG_LOG_SIZE);
6667	config.num_wds_entries = __cpu_to_le32(TARGET_10X_NUM_WDS_ENTRIES);
6668	config.dma_burst_size = __cpu_to_le32(TARGET_10X_DMA_BURST_SIZE);
6669	config.mac_aggr_delim = __cpu_to_le32(TARGET_10X_MAC_AGGR_DELIM);
6670
6671	val = TARGET_10X_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK;
6672	config.rx_skip_defrag_timeout_dup_detection_check = __cpu_to_le32(val);
6673
6674	config.vow_config = __cpu_to_le32(TARGET_10X_VOW_CONFIG);
6675
6676	config.num_msdu_desc = __cpu_to_le32(TARGET_10X_NUM_MSDU_DESC);
6677	config.max_frag_entries = __cpu_to_le32(TARGET_10X_MAX_FRAG_ENTRIES);
6678
6679	buf = ath10k_wmi_alloc_skb(ar, struct_size(cmd, mem_chunks.items,
6680						   ar->wmi.num_mem_chunks));
6681	if (!buf)
6682		return ERR_PTR(-ENOMEM);
6683
6684	cmd = (struct wmi_init_cmd_10x *)buf->data;
6685
6686	memcpy(&cmd->resource_config, &config, sizeof(config));
6687	ath10k_wmi_put_host_mem_chunks(ar, &cmd->mem_chunks);
6688
6689	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi init 10x\n");
6690	return buf;
6691}
6692
6693static struct sk_buff *ath10k_wmi_10_2_op_gen_init(struct ath10k *ar)
6694{
6695	struct wmi_init_cmd_10_2 *cmd;
6696	struct sk_buff *buf;
6697	struct wmi_resource_config_10x config = {};
6698	u32 val, features;
6699
6700	config.num_vdevs = __cpu_to_le32(TARGET_10X_NUM_VDEVS);
6701	config.num_peer_keys = __cpu_to_le32(TARGET_10X_NUM_PEER_KEYS);
6702
6703	if (ath10k_peer_stats_enabled(ar)) {
6704		config.num_peers = __cpu_to_le32(TARGET_10X_TX_STATS_NUM_PEERS);
6705		config.num_tids = __cpu_to_le32(TARGET_10X_TX_STATS_NUM_TIDS);
6706	} else {
6707		config.num_peers = __cpu_to_le32(TARGET_10X_NUM_PEERS);
6708		config.num_tids = __cpu_to_le32(TARGET_10X_NUM_TIDS);
6709	}
6710
6711	config.ast_skid_limit = __cpu_to_le32(TARGET_10X_AST_SKID_LIMIT);
6712	config.tx_chain_mask = __cpu_to_le32(TARGET_10X_TX_CHAIN_MASK);
6713	config.rx_chain_mask = __cpu_to_le32(TARGET_10X_RX_CHAIN_MASK);
6714	config.rx_timeout_pri_vo = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6715	config.rx_timeout_pri_vi = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6716	config.rx_timeout_pri_be = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_LO_PRI);
6717	config.rx_timeout_pri_bk = __cpu_to_le32(TARGET_10X_RX_TIMEOUT_HI_PRI);
6718	config.rx_decap_mode = __cpu_to_le32(ar->wmi.rx_decap_mode);
6719
6720	config.scan_max_pending_reqs =
6721		__cpu_to_le32(TARGET_10X_SCAN_MAX_PENDING_REQS);
6722
6723	config.bmiss_offload_max_vdev =
6724		__cpu_to_le32(TARGET_10X_BMISS_OFFLOAD_MAX_VDEV);
6725
6726	config.roam_offload_max_vdev =
6727		__cpu_to_le32(TARGET_10X_ROAM_OFFLOAD_MAX_VDEV);
6728
6729	config.roam_offload_max_ap_profiles =
6730		__cpu_to_le32(TARGET_10X_ROAM_OFFLOAD_MAX_AP_PROFILES);
6731
6732	config.num_mcast_groups = __cpu_to_le32(TARGET_10X_NUM_MCAST_GROUPS);
6733	config.num_mcast_table_elems =
6734		__cpu_to_le32(TARGET_10X_NUM_MCAST_TABLE_ELEMS);
6735
6736	config.mcast2ucast_mode = __cpu_to_le32(TARGET_10X_MCAST2UCAST_MODE);
6737	config.tx_dbg_log_size = __cpu_to_le32(TARGET_10X_TX_DBG_LOG_SIZE);
6738	config.num_wds_entries = __cpu_to_le32(TARGET_10X_NUM_WDS_ENTRIES);
6739	config.dma_burst_size = __cpu_to_le32(TARGET_10_2_DMA_BURST_SIZE);
6740	config.mac_aggr_delim = __cpu_to_le32(TARGET_10X_MAC_AGGR_DELIM);
6741
6742	val = TARGET_10X_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK;
6743	config.rx_skip_defrag_timeout_dup_detection_check = __cpu_to_le32(val);
6744
6745	config.vow_config = __cpu_to_le32(TARGET_10X_VOW_CONFIG);
6746
6747	config.num_msdu_desc = __cpu_to_le32(TARGET_10X_NUM_MSDU_DESC);
6748	config.max_frag_entries = __cpu_to_le32(TARGET_10X_MAX_FRAG_ENTRIES);
6749
6750	buf = ath10k_wmi_alloc_skb(ar, struct_size(cmd, mem_chunks.items,
6751						   ar->wmi.num_mem_chunks));
6752	if (!buf)
6753		return ERR_PTR(-ENOMEM);
6754
6755	cmd = (struct wmi_init_cmd_10_2 *)buf->data;
6756
6757	features = WMI_10_2_RX_BATCH_MODE;
6758
6759	if (test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) &&
6760	    test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
6761		features |= WMI_10_2_COEX_GPIO;
6762
6763	if (ath10k_peer_stats_enabled(ar))
6764		features |= WMI_10_2_PEER_STATS;
6765
6766	if (test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map))
6767		features |= WMI_10_2_BSS_CHAN_INFO;
6768
6769	cmd->resource_config.feature_mask = __cpu_to_le32(features);
6770
6771	memcpy(&cmd->resource_config.common, &config, sizeof(config));
6772	ath10k_wmi_put_host_mem_chunks(ar, &cmd->mem_chunks);
6773
6774	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi init 10.2\n");
6775	return buf;
6776}
6777
6778static struct sk_buff *ath10k_wmi_10_4_op_gen_init(struct ath10k *ar)
6779{
6780	struct wmi_init_cmd_10_4 *cmd;
6781	struct sk_buff *buf;
6782	struct wmi_resource_config_10_4 config = {};
6783
6784	config.num_vdevs = __cpu_to_le32(ar->max_num_vdevs);
6785	config.num_peers = __cpu_to_le32(ar->max_num_peers);
6786	config.num_active_peers = __cpu_to_le32(ar->num_active_peers);
6787	config.num_tids = __cpu_to_le32(ar->num_tids);
6788
6789	config.num_offload_peers = __cpu_to_le32(TARGET_10_4_NUM_OFFLOAD_PEERS);
6790	config.num_offload_reorder_buffs =
6791			__cpu_to_le32(TARGET_10_4_NUM_OFFLOAD_REORDER_BUFFS);
6792	config.num_peer_keys  = __cpu_to_le32(TARGET_10_4_NUM_PEER_KEYS);
6793	config.ast_skid_limit = __cpu_to_le32(TARGET_10_4_AST_SKID_LIMIT);
6794	config.tx_chain_mask  = __cpu_to_le32(ar->hw_params.tx_chain_mask);
6795	config.rx_chain_mask  = __cpu_to_le32(ar->hw_params.rx_chain_mask);
6796
6797	config.rx_timeout_pri[0] = __cpu_to_le32(TARGET_10_4_RX_TIMEOUT_LO_PRI);
6798	config.rx_timeout_pri[1] = __cpu_to_le32(TARGET_10_4_RX_TIMEOUT_LO_PRI);
6799	config.rx_timeout_pri[2] = __cpu_to_le32(TARGET_10_4_RX_TIMEOUT_LO_PRI);
6800	config.rx_timeout_pri[3] = __cpu_to_le32(TARGET_10_4_RX_TIMEOUT_HI_PRI);
6801
6802	config.rx_decap_mode	    = __cpu_to_le32(ar->wmi.rx_decap_mode);
6803	config.scan_max_pending_req = __cpu_to_le32(TARGET_10_4_SCAN_MAX_REQS);
6804	config.bmiss_offload_max_vdev =
6805			__cpu_to_le32(TARGET_10_4_BMISS_OFFLOAD_MAX_VDEV);
6806	config.roam_offload_max_vdev  =
6807			__cpu_to_le32(TARGET_10_4_ROAM_OFFLOAD_MAX_VDEV);
6808	config.roam_offload_max_ap_profiles =
6809			__cpu_to_le32(TARGET_10_4_ROAM_OFFLOAD_MAX_PROFILES);
6810	config.num_mcast_groups = __cpu_to_le32(TARGET_10_4_NUM_MCAST_GROUPS);
6811	config.num_mcast_table_elems =
6812			__cpu_to_le32(TARGET_10_4_NUM_MCAST_TABLE_ELEMS);
6813
6814	config.mcast2ucast_mode = __cpu_to_le32(TARGET_10_4_MCAST2UCAST_MODE);
6815	config.tx_dbg_log_size  = __cpu_to_le32(TARGET_10_4_TX_DBG_LOG_SIZE);
6816	config.num_wds_entries  = __cpu_to_le32(TARGET_10_4_NUM_WDS_ENTRIES);
6817	config.dma_burst_size   = __cpu_to_le32(TARGET_10_4_DMA_BURST_SIZE);
6818	config.mac_aggr_delim   = __cpu_to_le32(TARGET_10_4_MAC_AGGR_DELIM);
6819
6820	config.rx_skip_defrag_timeout_dup_detection_check =
6821	  __cpu_to_le32(TARGET_10_4_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK);
6822
6823	config.vow_config = __cpu_to_le32(TARGET_10_4_VOW_CONFIG);
6824	config.gtk_offload_max_vdev =
6825			__cpu_to_le32(TARGET_10_4_GTK_OFFLOAD_MAX_VDEV);
6826	config.num_msdu_desc = __cpu_to_le32(ar->htt.max_num_pending_tx);
6827	config.max_frag_entries = __cpu_to_le32(TARGET_10_4_11AC_TX_MAX_FRAGS);
6828	config.max_peer_ext_stats =
6829			__cpu_to_le32(TARGET_10_4_MAX_PEER_EXT_STATS);
6830	config.smart_ant_cap = __cpu_to_le32(TARGET_10_4_SMART_ANT_CAP);
6831
6832	config.bk_minfree = __cpu_to_le32(TARGET_10_4_BK_MIN_FREE);
6833	config.be_minfree = __cpu_to_le32(TARGET_10_4_BE_MIN_FREE);
6834	config.vi_minfree = __cpu_to_le32(TARGET_10_4_VI_MIN_FREE);
6835	config.vo_minfree = __cpu_to_le32(TARGET_10_4_VO_MIN_FREE);
6836
6837	config.rx_batchmode = __cpu_to_le32(TARGET_10_4_RX_BATCH_MODE);
6838	config.tt_support =
6839			__cpu_to_le32(TARGET_10_4_THERMAL_THROTTLING_CONFIG);
6840	config.atf_config = __cpu_to_le32(TARGET_10_4_ATF_CONFIG);
6841	config.iphdr_pad_config = __cpu_to_le32(TARGET_10_4_IPHDR_PAD_CONFIG);
6842	config.qwrap_config = __cpu_to_le32(TARGET_10_4_QWRAP_CONFIG);
6843
6844	buf = ath10k_wmi_alloc_skb(ar, struct_size(cmd, mem_chunks.items,
6845						   ar->wmi.num_mem_chunks));
6846	if (!buf)
6847		return ERR_PTR(-ENOMEM);
6848
6849	cmd = (struct wmi_init_cmd_10_4 *)buf->data;
6850	memcpy(&cmd->resource_config, &config, sizeof(config));
6851	ath10k_wmi_put_host_mem_chunks(ar, &cmd->mem_chunks);
6852
6853	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi init 10.4\n");
6854	return buf;
6855}
6856
6857int ath10k_wmi_start_scan_verify(const struct wmi_start_scan_arg *arg)
6858{
6859	if (arg->ie_len > WLAN_SCAN_PARAMS_MAX_IE_LEN)
6860		return -EINVAL;
6861	if (arg->n_channels > ARRAY_SIZE(arg->channels))
6862		return -EINVAL;
6863	if (arg->n_ssids > WLAN_SCAN_PARAMS_MAX_SSID)
6864		return -EINVAL;
6865	if (arg->n_bssids > WLAN_SCAN_PARAMS_MAX_BSSID)
6866		return -EINVAL;
6867
6868	return 0;
6869}
6870
6871static size_t
6872ath10k_wmi_start_scan_tlvs_len(const struct wmi_start_scan_arg *arg)
6873{
6874	int len = 0;
6875
6876	if (arg->ie_len) {
6877		len += sizeof(struct wmi_ie_data);
6878		len += roundup(arg->ie_len, 4);
6879	}
6880
6881	if (arg->n_channels) {
6882		len += sizeof(struct wmi_chan_list);
6883		len += sizeof(__le32) * arg->n_channels;
6884	}
6885
6886	if (arg->n_ssids) {
6887		len += sizeof(struct wmi_ssid_list);
6888		len += sizeof(struct wmi_ssid) * arg->n_ssids;
6889	}
6890
6891	if (arg->n_bssids) {
6892		len += sizeof(struct wmi_bssid_list);
6893		len += sizeof(struct wmi_mac_addr) * arg->n_bssids;
6894	}
6895
6896	return len;
6897}
6898
6899void ath10k_wmi_put_start_scan_common(struct wmi_start_scan_common *cmn,
6900				      const struct wmi_start_scan_arg *arg)
6901{
6902	u32 scan_id;
6903	u32 scan_req_id;
6904
6905	scan_id  = WMI_HOST_SCAN_REQ_ID_PREFIX;
6906	scan_id |= arg->scan_id;
6907
6908	scan_req_id  = WMI_HOST_SCAN_REQUESTOR_ID_PREFIX;
6909	scan_req_id |= arg->scan_req_id;
6910
6911	cmn->scan_id            = __cpu_to_le32(scan_id);
6912	cmn->scan_req_id        = __cpu_to_le32(scan_req_id);
6913	cmn->vdev_id            = __cpu_to_le32(arg->vdev_id);
6914	cmn->scan_priority      = __cpu_to_le32(arg->scan_priority);
6915	cmn->notify_scan_events = __cpu_to_le32(arg->notify_scan_events);
6916	cmn->dwell_time_active  = __cpu_to_le32(arg->dwell_time_active);
6917	cmn->dwell_time_passive = __cpu_to_le32(arg->dwell_time_passive);
6918	cmn->min_rest_time      = __cpu_to_le32(arg->min_rest_time);
6919	cmn->max_rest_time      = __cpu_to_le32(arg->max_rest_time);
6920	cmn->repeat_probe_time  = __cpu_to_le32(arg->repeat_probe_time);
6921	cmn->probe_spacing_time = __cpu_to_le32(arg->probe_spacing_time);
6922	cmn->idle_time          = __cpu_to_le32(arg->idle_time);
6923	cmn->max_scan_time      = __cpu_to_le32(arg->max_scan_time);
6924	cmn->probe_delay        = __cpu_to_le32(arg->probe_delay);
6925	cmn->scan_ctrl_flags    = __cpu_to_le32(arg->scan_ctrl_flags);
6926}
6927
6928static void
6929ath10k_wmi_put_start_scan_tlvs(struct wmi_start_scan_tlvs *tlvs,
6930			       const struct wmi_start_scan_arg *arg)
6931{
6932	struct wmi_ie_data *ie;
6933	struct wmi_chan_list *channels;
6934	struct wmi_ssid_list *ssids;
6935	struct wmi_bssid_list *bssids;
6936	void *ptr = tlvs->tlvs;
6937	int i;
6938
6939	if (arg->n_channels) {
6940		channels = ptr;
6941		channels->tag = __cpu_to_le32(WMI_CHAN_LIST_TAG);
6942		channels->num_chan = __cpu_to_le32(arg->n_channels);
6943
6944		for (i = 0; i < arg->n_channels; i++)
6945			channels->channel_list[i].freq =
6946				__cpu_to_le16(arg->channels[i]);
6947
6948		ptr += sizeof(*channels);
6949		ptr += sizeof(__le32) * arg->n_channels;
6950	}
6951
6952	if (arg->n_ssids) {
6953		ssids = ptr;
6954		ssids->tag = __cpu_to_le32(WMI_SSID_LIST_TAG);
6955		ssids->num_ssids = __cpu_to_le32(arg->n_ssids);
6956
6957		for (i = 0; i < arg->n_ssids; i++) {
6958			ssids->ssids[i].ssid_len =
6959				__cpu_to_le32(arg->ssids[i].len);
6960			memcpy(&ssids->ssids[i].ssid,
6961			       arg->ssids[i].ssid,
6962			       arg->ssids[i].len);
6963		}
6964
6965		ptr += sizeof(*ssids);
6966		ptr += sizeof(struct wmi_ssid) * arg->n_ssids;
6967	}
6968
6969	if (arg->n_bssids) {
6970		bssids = ptr;
6971		bssids->tag = __cpu_to_le32(WMI_BSSID_LIST_TAG);
6972		bssids->num_bssid = __cpu_to_le32(arg->n_bssids);
6973
6974		for (i = 0; i < arg->n_bssids; i++)
6975			ether_addr_copy(bssids->bssid_list[i].addr,
6976					arg->bssids[i].bssid);
6977
6978		ptr += sizeof(*bssids);
6979		ptr += sizeof(struct wmi_mac_addr) * arg->n_bssids;
6980	}
6981
6982	if (arg->ie_len) {
6983		ie = ptr;
6984		ie->tag = __cpu_to_le32(WMI_IE_TAG);
6985		ie->ie_len = __cpu_to_le32(arg->ie_len);
6986		memcpy(ie->ie_data, arg->ie, arg->ie_len);
6987
6988		ptr += sizeof(*ie);
6989		ptr += roundup(arg->ie_len, 4);
6990	}
6991}
6992
6993static struct sk_buff *
6994ath10k_wmi_op_gen_start_scan(struct ath10k *ar,
6995			     const struct wmi_start_scan_arg *arg)
6996{
6997	struct wmi_start_scan_cmd *cmd;
6998	struct sk_buff *skb;
6999	size_t len;
7000	int ret;
7001
7002	ret = ath10k_wmi_start_scan_verify(arg);
7003	if (ret)
7004		return ERR_PTR(ret);
7005
7006	len = sizeof(*cmd) + ath10k_wmi_start_scan_tlvs_len(arg);
7007	skb = ath10k_wmi_alloc_skb(ar, len);
7008	if (!skb)
7009		return ERR_PTR(-ENOMEM);
7010
7011	cmd = (struct wmi_start_scan_cmd *)skb->data;
7012
7013	ath10k_wmi_put_start_scan_common(&cmd->common, arg);
7014	ath10k_wmi_put_start_scan_tlvs(&cmd->tlvs, arg);
7015
7016	cmd->burst_duration_ms = __cpu_to_le32(0);
7017
7018	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi start scan\n");
7019	return skb;
7020}
7021
7022static struct sk_buff *
7023ath10k_wmi_10x_op_gen_start_scan(struct ath10k *ar,
7024				 const struct wmi_start_scan_arg *arg)
7025{
7026	struct wmi_10x_start_scan_cmd *cmd;
7027	struct sk_buff *skb;
7028	size_t len;
7029	int ret;
7030
7031	ret = ath10k_wmi_start_scan_verify(arg);
7032	if (ret)
7033		return ERR_PTR(ret);
7034
7035	len = sizeof(*cmd) + ath10k_wmi_start_scan_tlvs_len(arg);
7036	skb = ath10k_wmi_alloc_skb(ar, len);
7037	if (!skb)
7038		return ERR_PTR(-ENOMEM);
7039
7040	cmd = (struct wmi_10x_start_scan_cmd *)skb->data;
7041
7042	ath10k_wmi_put_start_scan_common(&cmd->common, arg);
7043	ath10k_wmi_put_start_scan_tlvs(&cmd->tlvs, arg);
7044
7045	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi 10x start scan\n");
7046	return skb;
7047}
7048
7049void ath10k_wmi_start_scan_init(struct ath10k *ar,
7050				struct wmi_start_scan_arg *arg)
7051{
7052	/* setup commonly used values */
7053	arg->scan_req_id = 1;
7054	arg->scan_priority = WMI_SCAN_PRIORITY_LOW;
7055	arg->dwell_time_active = 50;
7056	arg->dwell_time_passive = 150;
7057	arg->min_rest_time = 50;
7058	arg->max_rest_time = 500;
7059	arg->repeat_probe_time = 0;
7060	arg->probe_spacing_time = 0;
7061	arg->idle_time = 0;
7062	arg->max_scan_time = 20000;
7063	arg->probe_delay = 5;
7064	arg->notify_scan_events = WMI_SCAN_EVENT_STARTED
7065		| WMI_SCAN_EVENT_COMPLETED
7066		| WMI_SCAN_EVENT_BSS_CHANNEL
7067		| WMI_SCAN_EVENT_FOREIGN_CHANNEL
7068		| WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT
7069		| WMI_SCAN_EVENT_DEQUEUED;
7070	arg->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT;
7071	arg->n_bssids = 1;
7072	arg->bssids[0].bssid = "\xFF\xFF\xFF\xFF\xFF\xFF";
7073}
7074
7075static struct sk_buff *
7076ath10k_wmi_op_gen_stop_scan(struct ath10k *ar,
7077			    const struct wmi_stop_scan_arg *arg)
7078{
7079	struct wmi_stop_scan_cmd *cmd;
7080	struct sk_buff *skb;
7081	u32 scan_id;
7082	u32 req_id;
7083
7084	if (arg->req_id > 0xFFF)
7085		return ERR_PTR(-EINVAL);
7086	if (arg->req_type == WMI_SCAN_STOP_ONE && arg->u.scan_id > 0xFFF)
7087		return ERR_PTR(-EINVAL);
7088
7089	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7090	if (!skb)
7091		return ERR_PTR(-ENOMEM);
7092
7093	scan_id = arg->u.scan_id;
7094	scan_id |= WMI_HOST_SCAN_REQ_ID_PREFIX;
7095
7096	req_id = arg->req_id;
7097	req_id |= WMI_HOST_SCAN_REQUESTOR_ID_PREFIX;
7098
7099	cmd = (struct wmi_stop_scan_cmd *)skb->data;
7100	cmd->req_type    = __cpu_to_le32(arg->req_type);
7101	cmd->vdev_id     = __cpu_to_le32(arg->u.vdev_id);
7102	cmd->scan_id     = __cpu_to_le32(scan_id);
7103	cmd->scan_req_id = __cpu_to_le32(req_id);
7104
7105	ath10k_dbg(ar, ATH10K_DBG_WMI,
7106		   "wmi stop scan reqid %d req_type %d vdev/scan_id %d\n",
7107		   arg->req_id, arg->req_type, arg->u.scan_id);
7108	return skb;
7109}
7110
7111static struct sk_buff *
7112ath10k_wmi_op_gen_vdev_create(struct ath10k *ar, u32 vdev_id,
7113			      enum wmi_vdev_type type,
7114			      enum wmi_vdev_subtype subtype,
7115			      const u8 macaddr[ETH_ALEN])
7116{
7117	struct wmi_vdev_create_cmd *cmd;
7118	struct sk_buff *skb;
7119
7120	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7121	if (!skb)
7122		return ERR_PTR(-ENOMEM);
7123
7124	cmd = (struct wmi_vdev_create_cmd *)skb->data;
7125	cmd->vdev_id      = __cpu_to_le32(vdev_id);
7126	cmd->vdev_type    = __cpu_to_le32(type);
7127	cmd->vdev_subtype = __cpu_to_le32(subtype);
7128	ether_addr_copy(cmd->vdev_macaddr.addr, macaddr);
7129
7130	ath10k_dbg(ar, ATH10K_DBG_WMI,
7131		   "WMI vdev create: id %d type %d subtype %d macaddr %pM\n",
7132		   vdev_id, type, subtype, macaddr);
7133	return skb;
7134}
7135
7136static struct sk_buff *
7137ath10k_wmi_op_gen_vdev_delete(struct ath10k *ar, u32 vdev_id)
7138{
7139	struct wmi_vdev_delete_cmd *cmd;
7140	struct sk_buff *skb;
7141
7142	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7143	if (!skb)
7144		return ERR_PTR(-ENOMEM);
7145
7146	cmd = (struct wmi_vdev_delete_cmd *)skb->data;
7147	cmd->vdev_id = __cpu_to_le32(vdev_id);
7148
7149	ath10k_dbg(ar, ATH10K_DBG_WMI,
7150		   "WMI vdev delete id %d\n", vdev_id);
7151	return skb;
7152}
7153
7154static struct sk_buff *
7155ath10k_wmi_op_gen_vdev_start(struct ath10k *ar,
7156			     const struct wmi_vdev_start_request_arg *arg,
7157			     bool restart)
7158{
7159	struct wmi_vdev_start_request_cmd *cmd;
7160	struct sk_buff *skb;
7161	const char *cmdname;
7162	u32 flags = 0;
7163
7164	if (WARN_ON(arg->hidden_ssid && !arg->ssid))
7165		return ERR_PTR(-EINVAL);
7166	if (WARN_ON(arg->ssid_len > sizeof(cmd->ssid.ssid)))
7167		return ERR_PTR(-EINVAL);
7168
7169	if (restart)
7170		cmdname = "restart";
7171	else
7172		cmdname = "start";
7173
7174	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7175	if (!skb)
7176		return ERR_PTR(-ENOMEM);
7177
7178	if (arg->hidden_ssid)
7179		flags |= WMI_VDEV_START_HIDDEN_SSID;
7180	if (arg->pmf_enabled)
7181		flags |= WMI_VDEV_START_PMF_ENABLED;
7182
7183	cmd = (struct wmi_vdev_start_request_cmd *)skb->data;
7184	cmd->vdev_id         = __cpu_to_le32(arg->vdev_id);
7185	cmd->disable_hw_ack  = __cpu_to_le32(arg->disable_hw_ack);
7186	cmd->beacon_interval = __cpu_to_le32(arg->bcn_intval);
7187	cmd->dtim_period     = __cpu_to_le32(arg->dtim_period);
7188	cmd->flags           = __cpu_to_le32(flags);
7189	cmd->bcn_tx_rate     = __cpu_to_le32(arg->bcn_tx_rate);
7190	cmd->bcn_tx_power    = __cpu_to_le32(arg->bcn_tx_power);
7191
7192	if (arg->ssid) {
7193		cmd->ssid.ssid_len = __cpu_to_le32(arg->ssid_len);
7194		memcpy(cmd->ssid.ssid, arg->ssid, arg->ssid_len);
7195	}
7196
7197	ath10k_wmi_put_wmi_channel(ar, &cmd->chan, &arg->channel);
7198
7199	ath10k_dbg(ar, ATH10K_DBG_WMI,
7200		   "wmi vdev %s id 0x%x flags: 0x%0X, freq %d, mode %d, ch_flags: 0x%0X, max_power: %d\n",
7201		   cmdname, arg->vdev_id,
7202		   flags, arg->channel.freq, arg->channel.mode,
7203		   cmd->chan.flags, arg->channel.max_power);
7204
7205	return skb;
7206}
7207
7208static struct sk_buff *
7209ath10k_wmi_op_gen_vdev_stop(struct ath10k *ar, u32 vdev_id)
7210{
7211	struct wmi_vdev_stop_cmd *cmd;
7212	struct sk_buff *skb;
7213
7214	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7215	if (!skb)
7216		return ERR_PTR(-ENOMEM);
7217
7218	cmd = (struct wmi_vdev_stop_cmd *)skb->data;
7219	cmd->vdev_id = __cpu_to_le32(vdev_id);
7220
7221	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi vdev stop id 0x%x\n", vdev_id);
7222	return skb;
7223}
7224
7225static struct sk_buff *
7226ath10k_wmi_op_gen_vdev_up(struct ath10k *ar, u32 vdev_id, u32 aid,
7227			  const u8 *bssid)
7228{
7229	struct wmi_vdev_up_cmd *cmd;
7230	struct sk_buff *skb;
7231
7232	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7233	if (!skb)
7234		return ERR_PTR(-ENOMEM);
7235
7236	cmd = (struct wmi_vdev_up_cmd *)skb->data;
7237	cmd->vdev_id       = __cpu_to_le32(vdev_id);
7238	cmd->vdev_assoc_id = __cpu_to_le32(aid);
7239	ether_addr_copy(cmd->vdev_bssid.addr, bssid);
7240
7241	ath10k_dbg(ar, ATH10K_DBG_WMI,
7242		   "wmi mgmt vdev up id 0x%x assoc id %d bssid %pM\n",
7243		   vdev_id, aid, bssid);
7244	return skb;
7245}
7246
7247static struct sk_buff *
7248ath10k_wmi_op_gen_vdev_down(struct ath10k *ar, u32 vdev_id)
7249{
7250	struct wmi_vdev_down_cmd *cmd;
7251	struct sk_buff *skb;
7252
7253	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7254	if (!skb)
7255		return ERR_PTR(-ENOMEM);
7256
7257	cmd = (struct wmi_vdev_down_cmd *)skb->data;
7258	cmd->vdev_id = __cpu_to_le32(vdev_id);
7259
7260	ath10k_dbg(ar, ATH10K_DBG_WMI,
7261		   "wmi mgmt vdev down id 0x%x\n", vdev_id);
7262	return skb;
7263}
7264
7265static struct sk_buff *
7266ath10k_wmi_op_gen_vdev_set_param(struct ath10k *ar, u32 vdev_id,
7267				 u32 param_id, u32 param_value)
7268{
7269	struct wmi_vdev_set_param_cmd *cmd;
7270	struct sk_buff *skb;
7271
7272	if (param_id == WMI_VDEV_PARAM_UNSUPPORTED) {
7273		ath10k_dbg(ar, ATH10K_DBG_WMI,
7274			   "vdev param %d not supported by firmware\n",
7275			    param_id);
7276		return ERR_PTR(-EOPNOTSUPP);
7277	}
7278
7279	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7280	if (!skb)
7281		return ERR_PTR(-ENOMEM);
7282
7283	cmd = (struct wmi_vdev_set_param_cmd *)skb->data;
7284	cmd->vdev_id     = __cpu_to_le32(vdev_id);
7285	cmd->param_id    = __cpu_to_le32(param_id);
7286	cmd->param_value = __cpu_to_le32(param_value);
7287
7288	ath10k_dbg(ar, ATH10K_DBG_WMI,
7289		   "wmi vdev id 0x%x set param %d value %d\n",
7290		   vdev_id, param_id, param_value);
7291	return skb;
7292}
7293
7294static struct sk_buff *
7295ath10k_wmi_op_gen_vdev_install_key(struct ath10k *ar,
7296				   const struct wmi_vdev_install_key_arg *arg)
7297{
7298	struct wmi_vdev_install_key_cmd *cmd;
7299	struct sk_buff *skb;
7300
7301	if (arg->key_cipher == WMI_CIPHER_NONE && arg->key_data != NULL)
7302		return ERR_PTR(-EINVAL);
7303	if (arg->key_cipher != WMI_CIPHER_NONE && arg->key_data == NULL)
7304		return ERR_PTR(-EINVAL);
7305
7306	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + arg->key_len);
7307	if (!skb)
7308		return ERR_PTR(-ENOMEM);
7309
7310	cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
7311	cmd->vdev_id       = __cpu_to_le32(arg->vdev_id);
7312	cmd->key_idx       = __cpu_to_le32(arg->key_idx);
7313	cmd->key_flags     = __cpu_to_le32(arg->key_flags);
7314	cmd->key_cipher    = __cpu_to_le32(arg->key_cipher);
7315	cmd->key_len       = __cpu_to_le32(arg->key_len);
7316	cmd->key_txmic_len = __cpu_to_le32(arg->key_txmic_len);
7317	cmd->key_rxmic_len = __cpu_to_le32(arg->key_rxmic_len);
7318
7319	if (arg->macaddr)
7320		ether_addr_copy(cmd->peer_macaddr.addr, arg->macaddr);
7321	if (arg->key_data)
7322		memcpy(cmd->key_data, arg->key_data, arg->key_len);
7323
7324	ath10k_dbg(ar, ATH10K_DBG_WMI,
7325		   "wmi vdev install key idx %d cipher %d len %d\n",
7326		   arg->key_idx, arg->key_cipher, arg->key_len);
7327	return skb;
7328}
7329
7330static struct sk_buff *
7331ath10k_wmi_op_gen_vdev_spectral_conf(struct ath10k *ar,
7332				     const struct wmi_vdev_spectral_conf_arg *arg)
7333{
7334	struct wmi_vdev_spectral_conf_cmd *cmd;
7335	struct sk_buff *skb;
7336
7337	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7338	if (!skb)
7339		return ERR_PTR(-ENOMEM);
7340
7341	cmd = (struct wmi_vdev_spectral_conf_cmd *)skb->data;
7342	cmd->vdev_id = __cpu_to_le32(arg->vdev_id);
7343	cmd->scan_count = __cpu_to_le32(arg->scan_count);
7344	cmd->scan_period = __cpu_to_le32(arg->scan_period);
7345	cmd->scan_priority = __cpu_to_le32(arg->scan_priority);
7346	cmd->scan_fft_size = __cpu_to_le32(arg->scan_fft_size);
7347	cmd->scan_gc_ena = __cpu_to_le32(arg->scan_gc_ena);
7348	cmd->scan_restart_ena = __cpu_to_le32(arg->scan_restart_ena);
7349	cmd->scan_noise_floor_ref = __cpu_to_le32(arg->scan_noise_floor_ref);
7350	cmd->scan_init_delay = __cpu_to_le32(arg->scan_init_delay);
7351	cmd->scan_nb_tone_thr = __cpu_to_le32(arg->scan_nb_tone_thr);
7352	cmd->scan_str_bin_thr = __cpu_to_le32(arg->scan_str_bin_thr);
7353	cmd->scan_wb_rpt_mode = __cpu_to_le32(arg->scan_wb_rpt_mode);
7354	cmd->scan_rssi_rpt_mode = __cpu_to_le32(arg->scan_rssi_rpt_mode);
7355	cmd->scan_rssi_thr = __cpu_to_le32(arg->scan_rssi_thr);
7356	cmd->scan_pwr_format = __cpu_to_le32(arg->scan_pwr_format);
7357	cmd->scan_rpt_mode = __cpu_to_le32(arg->scan_rpt_mode);
7358	cmd->scan_bin_scale = __cpu_to_le32(arg->scan_bin_scale);
7359	cmd->scan_dbm_adj = __cpu_to_le32(arg->scan_dbm_adj);
7360	cmd->scan_chn_mask = __cpu_to_le32(arg->scan_chn_mask);
7361
7362	return skb;
7363}
7364
7365static struct sk_buff *
7366ath10k_wmi_op_gen_vdev_spectral_enable(struct ath10k *ar, u32 vdev_id,
7367				       u32 trigger, u32 enable)
7368{
7369	struct wmi_vdev_spectral_enable_cmd *cmd;
7370	struct sk_buff *skb;
7371
7372	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7373	if (!skb)
7374		return ERR_PTR(-ENOMEM);
7375
7376	cmd = (struct wmi_vdev_spectral_enable_cmd *)skb->data;
7377	cmd->vdev_id = __cpu_to_le32(vdev_id);
7378	cmd->trigger_cmd = __cpu_to_le32(trigger);
7379	cmd->enable_cmd = __cpu_to_le32(enable);
7380
7381	return skb;
7382}
7383
7384static struct sk_buff *
7385ath10k_wmi_op_gen_peer_create(struct ath10k *ar, u32 vdev_id,
7386			      const u8 peer_addr[ETH_ALEN],
7387			      enum wmi_peer_type peer_type)
7388{
7389	struct wmi_peer_create_cmd *cmd;
7390	struct sk_buff *skb;
7391
7392	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7393	if (!skb)
7394		return ERR_PTR(-ENOMEM);
7395
7396	cmd = (struct wmi_peer_create_cmd *)skb->data;
7397	cmd->vdev_id = __cpu_to_le32(vdev_id);
7398	ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
7399	cmd->peer_type = __cpu_to_le32(peer_type);
7400
7401	ath10k_dbg(ar, ATH10K_DBG_WMI,
7402		   "wmi peer create vdev_id %d peer_addr %pM\n",
7403		   vdev_id, peer_addr);
7404	return skb;
7405}
7406
7407static struct sk_buff *
7408ath10k_wmi_op_gen_peer_delete(struct ath10k *ar, u32 vdev_id,
7409			      const u8 peer_addr[ETH_ALEN])
7410{
7411	struct wmi_peer_delete_cmd *cmd;
7412	struct sk_buff *skb;
7413
7414	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7415	if (!skb)
7416		return ERR_PTR(-ENOMEM);
7417
7418	cmd = (struct wmi_peer_delete_cmd *)skb->data;
7419	cmd->vdev_id = __cpu_to_le32(vdev_id);
7420	ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
7421
7422	ath10k_dbg(ar, ATH10K_DBG_WMI,
7423		   "wmi peer delete vdev_id %d peer_addr %pM\n",
7424		   vdev_id, peer_addr);
7425	return skb;
7426}
7427
7428static struct sk_buff *
7429ath10k_wmi_op_gen_peer_flush(struct ath10k *ar, u32 vdev_id,
7430			     const u8 peer_addr[ETH_ALEN], u32 tid_bitmap)
7431{
7432	struct wmi_peer_flush_tids_cmd *cmd;
7433	struct sk_buff *skb;
7434
7435	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7436	if (!skb)
7437		return ERR_PTR(-ENOMEM);
7438
7439	cmd = (struct wmi_peer_flush_tids_cmd *)skb->data;
7440	cmd->vdev_id         = __cpu_to_le32(vdev_id);
7441	cmd->peer_tid_bitmap = __cpu_to_le32(tid_bitmap);
7442	ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
7443
7444	ath10k_dbg(ar, ATH10K_DBG_WMI,
7445		   "wmi peer flush vdev_id %d peer_addr %pM tids %08x\n",
7446		   vdev_id, peer_addr, tid_bitmap);
7447	return skb;
7448}
7449
7450static struct sk_buff *
7451ath10k_wmi_op_gen_peer_set_param(struct ath10k *ar, u32 vdev_id,
7452				 const u8 *peer_addr,
7453				 enum wmi_peer_param param_id,
7454				 u32 param_value)
7455{
7456	struct wmi_peer_set_param_cmd *cmd;
7457	struct sk_buff *skb;
7458
7459	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7460	if (!skb)
7461		return ERR_PTR(-ENOMEM);
7462
7463	cmd = (struct wmi_peer_set_param_cmd *)skb->data;
7464	cmd->vdev_id     = __cpu_to_le32(vdev_id);
7465	cmd->param_id    = __cpu_to_le32(param_id);
7466	cmd->param_value = __cpu_to_le32(param_value);
7467	ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
7468
7469	ath10k_dbg(ar, ATH10K_DBG_WMI,
7470		   "wmi vdev %d peer 0x%pM set param %d value %d\n",
7471		   vdev_id, peer_addr, param_id, param_value);
7472	return skb;
7473}
7474
7475static struct sk_buff *
7476ath10k_wmi_op_gen_set_psmode(struct ath10k *ar, u32 vdev_id,
7477			     enum wmi_sta_ps_mode psmode)
7478{
7479	struct wmi_sta_powersave_mode_cmd *cmd;
7480	struct sk_buff *skb;
7481
7482	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7483	if (!skb)
7484		return ERR_PTR(-ENOMEM);
7485
7486	cmd = (struct wmi_sta_powersave_mode_cmd *)skb->data;
7487	cmd->vdev_id     = __cpu_to_le32(vdev_id);
7488	cmd->sta_ps_mode = __cpu_to_le32(psmode);
7489
7490	ath10k_dbg(ar, ATH10K_DBG_WMI,
7491		   "wmi set powersave id 0x%x mode %d\n",
7492		   vdev_id, psmode);
7493	return skb;
7494}
7495
7496static struct sk_buff *
7497ath10k_wmi_op_gen_set_sta_ps(struct ath10k *ar, u32 vdev_id,
7498			     enum wmi_sta_powersave_param param_id,
7499			     u32 value)
7500{
7501	struct wmi_sta_powersave_param_cmd *cmd;
7502	struct sk_buff *skb;
7503
7504	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7505	if (!skb)
7506		return ERR_PTR(-ENOMEM);
7507
7508	cmd = (struct wmi_sta_powersave_param_cmd *)skb->data;
7509	cmd->vdev_id     = __cpu_to_le32(vdev_id);
7510	cmd->param_id    = __cpu_to_le32(param_id);
7511	cmd->param_value = __cpu_to_le32(value);
7512
7513	ath10k_dbg(ar, ATH10K_DBG_STA,
7514		   "wmi sta ps param vdev_id 0x%x param %d value %d\n",
7515		   vdev_id, param_id, value);
7516	return skb;
7517}
7518
7519static struct sk_buff *
7520ath10k_wmi_op_gen_set_ap_ps(struct ath10k *ar, u32 vdev_id, const u8 *mac,
7521			    enum wmi_ap_ps_peer_param param_id, u32 value)
7522{
7523	struct wmi_ap_ps_peer_cmd *cmd;
7524	struct sk_buff *skb;
7525
7526	if (!mac)
7527		return ERR_PTR(-EINVAL);
7528
7529	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7530	if (!skb)
7531		return ERR_PTR(-ENOMEM);
7532
7533	cmd = (struct wmi_ap_ps_peer_cmd *)skb->data;
7534	cmd->vdev_id = __cpu_to_le32(vdev_id);
7535	cmd->param_id = __cpu_to_le32(param_id);
7536	cmd->param_value = __cpu_to_le32(value);
7537	ether_addr_copy(cmd->peer_macaddr.addr, mac);
7538
7539	ath10k_dbg(ar, ATH10K_DBG_WMI,
7540		   "wmi ap ps param vdev_id 0x%X param %d value %d mac_addr %pM\n",
7541		   vdev_id, param_id, value, mac);
7542	return skb;
7543}
7544
7545static struct sk_buff *
7546ath10k_wmi_op_gen_scan_chan_list(struct ath10k *ar,
7547				 const struct wmi_scan_chan_list_arg *arg)
7548{
7549	struct wmi_scan_chan_list_cmd *cmd;
7550	struct sk_buff *skb;
7551	struct wmi_channel_arg *ch;
7552	struct wmi_channel *ci;
7553	int i;
7554
7555	skb = ath10k_wmi_alloc_skb(ar, struct_size(cmd, chan_info, arg->n_channels));
7556	if (!skb)
7557		return ERR_PTR(-EINVAL);
7558
7559	cmd = (struct wmi_scan_chan_list_cmd *)skb->data;
7560	cmd->num_scan_chans = __cpu_to_le32(arg->n_channels);
7561
7562	for (i = 0; i < arg->n_channels; i++) {
7563		ch = &arg->channels[i];
7564		ci = &cmd->chan_info[i];
7565
7566		ath10k_wmi_put_wmi_channel(ar, ci, ch);
7567	}
7568
7569	return skb;
7570}
7571
7572static void
7573ath10k_wmi_peer_assoc_fill(struct ath10k *ar, void *buf,
7574			   const struct wmi_peer_assoc_complete_arg *arg)
7575{
7576	struct wmi_common_peer_assoc_complete_cmd *cmd = buf;
7577
7578	cmd->vdev_id            = __cpu_to_le32(arg->vdev_id);
7579	cmd->peer_new_assoc     = __cpu_to_le32(arg->peer_reassoc ? 0 : 1);
7580	cmd->peer_associd       = __cpu_to_le32(arg->peer_aid);
7581	cmd->peer_flags         = __cpu_to_le32(arg->peer_flags);
7582	cmd->peer_caps          = __cpu_to_le32(arg->peer_caps);
7583	cmd->peer_listen_intval = __cpu_to_le32(arg->peer_listen_intval);
7584	cmd->peer_ht_caps       = __cpu_to_le32(arg->peer_ht_caps);
7585	cmd->peer_max_mpdu      = __cpu_to_le32(arg->peer_max_mpdu);
7586	cmd->peer_mpdu_density  = __cpu_to_le32(arg->peer_mpdu_density);
7587	cmd->peer_rate_caps     = __cpu_to_le32(arg->peer_rate_caps);
7588	cmd->peer_nss           = __cpu_to_le32(arg->peer_num_spatial_streams);
7589	cmd->peer_vht_caps      = __cpu_to_le32(arg->peer_vht_caps);
7590	cmd->peer_phymode       = __cpu_to_le32(arg->peer_phymode);
7591
7592	ether_addr_copy(cmd->peer_macaddr.addr, arg->addr);
7593
7594	cmd->peer_legacy_rates.num_rates =
7595		__cpu_to_le32(arg->peer_legacy_rates.num_rates);
7596	memcpy(cmd->peer_legacy_rates.rates, arg->peer_legacy_rates.rates,
7597	       arg->peer_legacy_rates.num_rates);
7598
7599	cmd->peer_ht_rates.num_rates =
7600		__cpu_to_le32(arg->peer_ht_rates.num_rates);
7601	memcpy(cmd->peer_ht_rates.rates, arg->peer_ht_rates.rates,
7602	       arg->peer_ht_rates.num_rates);
7603
7604	cmd->peer_vht_rates.rx_max_rate =
7605		__cpu_to_le32(arg->peer_vht_rates.rx_max_rate);
7606	cmd->peer_vht_rates.rx_mcs_set =
7607		__cpu_to_le32(arg->peer_vht_rates.rx_mcs_set);
7608	cmd->peer_vht_rates.tx_max_rate =
7609		__cpu_to_le32(arg->peer_vht_rates.tx_max_rate);
7610	cmd->peer_vht_rates.tx_mcs_set =
7611		__cpu_to_le32(arg->peer_vht_rates.tx_mcs_set);
7612}
7613
7614static void
7615ath10k_wmi_peer_assoc_fill_main(struct ath10k *ar, void *buf,
7616				const struct wmi_peer_assoc_complete_arg *arg)
7617{
7618	struct wmi_main_peer_assoc_complete_cmd *cmd = buf;
7619
7620	ath10k_wmi_peer_assoc_fill(ar, buf, arg);
7621	memset(cmd->peer_ht_info, 0, sizeof(cmd->peer_ht_info));
7622}
7623
7624static void
7625ath10k_wmi_peer_assoc_fill_10_1(struct ath10k *ar, void *buf,
7626				const struct wmi_peer_assoc_complete_arg *arg)
7627{
7628	ath10k_wmi_peer_assoc_fill(ar, buf, arg);
7629}
7630
7631static void
7632ath10k_wmi_peer_assoc_fill_10_2(struct ath10k *ar, void *buf,
7633				const struct wmi_peer_assoc_complete_arg *arg)
7634{
7635	struct wmi_10_2_peer_assoc_complete_cmd *cmd = buf;
7636	int max_mcs, max_nss;
7637	u32 info0;
7638
7639	/* TODO: Is using max values okay with firmware? */
7640	max_mcs = 0xf;
7641	max_nss = 0xf;
7642
7643	info0 = SM(max_mcs, WMI_PEER_ASSOC_INFO0_MAX_MCS_IDX) |
7644		SM(max_nss, WMI_PEER_ASSOC_INFO0_MAX_NSS);
7645
7646	ath10k_wmi_peer_assoc_fill(ar, buf, arg);
7647	cmd->info0 = __cpu_to_le32(info0);
7648}
7649
7650static void
7651ath10k_wmi_peer_assoc_fill_10_4(struct ath10k *ar, void *buf,
7652				const struct wmi_peer_assoc_complete_arg *arg)
7653{
7654	struct wmi_10_4_peer_assoc_complete_cmd *cmd = buf;
7655
7656	ath10k_wmi_peer_assoc_fill_10_2(ar, buf, arg);
7657	cmd->peer_bw_rxnss_override =
7658		__cpu_to_le32(arg->peer_bw_rxnss_override);
7659}
7660
7661static int
7662ath10k_wmi_peer_assoc_check_arg(const struct wmi_peer_assoc_complete_arg *arg)
7663{
7664	if (arg->peer_mpdu_density > 16)
7665		return -EINVAL;
7666	if (arg->peer_legacy_rates.num_rates > MAX_SUPPORTED_RATES)
7667		return -EINVAL;
7668	if (arg->peer_ht_rates.num_rates > MAX_SUPPORTED_RATES)
7669		return -EINVAL;
7670
7671	return 0;
7672}
7673
7674static struct sk_buff *
7675ath10k_wmi_op_gen_peer_assoc(struct ath10k *ar,
7676			     const struct wmi_peer_assoc_complete_arg *arg)
7677{
7678	size_t len = sizeof(struct wmi_main_peer_assoc_complete_cmd);
7679	struct sk_buff *skb;
7680	int ret;
7681
7682	ret = ath10k_wmi_peer_assoc_check_arg(arg);
7683	if (ret)
7684		return ERR_PTR(ret);
7685
7686	skb = ath10k_wmi_alloc_skb(ar, len);
7687	if (!skb)
7688		return ERR_PTR(-ENOMEM);
7689
7690	ath10k_wmi_peer_assoc_fill_main(ar, skb->data, arg);
7691
7692	ath10k_dbg(ar, ATH10K_DBG_WMI,
7693		   "wmi peer assoc vdev %d addr %pM (%s)\n",
7694		   arg->vdev_id, arg->addr,
7695		   arg->peer_reassoc ? "reassociate" : "new");
7696	return skb;
7697}
7698
7699static struct sk_buff *
7700ath10k_wmi_10_1_op_gen_peer_assoc(struct ath10k *ar,
7701				  const struct wmi_peer_assoc_complete_arg *arg)
7702{
7703	size_t len = sizeof(struct wmi_10_1_peer_assoc_complete_cmd);
7704	struct sk_buff *skb;
7705	int ret;
7706
7707	ret = ath10k_wmi_peer_assoc_check_arg(arg);
7708	if (ret)
7709		return ERR_PTR(ret);
7710
7711	skb = ath10k_wmi_alloc_skb(ar, len);
7712	if (!skb)
7713		return ERR_PTR(-ENOMEM);
7714
7715	ath10k_wmi_peer_assoc_fill_10_1(ar, skb->data, arg);
7716
7717	ath10k_dbg(ar, ATH10K_DBG_WMI,
7718		   "wmi peer assoc vdev %d addr %pM (%s)\n",
7719		   arg->vdev_id, arg->addr,
7720		   arg->peer_reassoc ? "reassociate" : "new");
7721	return skb;
7722}
7723
7724static struct sk_buff *
7725ath10k_wmi_10_2_op_gen_peer_assoc(struct ath10k *ar,
7726				  const struct wmi_peer_assoc_complete_arg *arg)
7727{
7728	size_t len = sizeof(struct wmi_10_2_peer_assoc_complete_cmd);
7729	struct sk_buff *skb;
7730	int ret;
7731
7732	ret = ath10k_wmi_peer_assoc_check_arg(arg);
7733	if (ret)
7734		return ERR_PTR(ret);
7735
7736	skb = ath10k_wmi_alloc_skb(ar, len);
7737	if (!skb)
7738		return ERR_PTR(-ENOMEM);
7739
7740	ath10k_wmi_peer_assoc_fill_10_2(ar, skb->data, arg);
7741
7742	ath10k_dbg(ar, ATH10K_DBG_WMI,
7743		   "wmi peer assoc vdev %d addr %pM (%s)\n",
7744		   arg->vdev_id, arg->addr,
7745		   arg->peer_reassoc ? "reassociate" : "new");
7746	return skb;
7747}
7748
7749static struct sk_buff *
7750ath10k_wmi_10_4_op_gen_peer_assoc(struct ath10k *ar,
7751				  const struct wmi_peer_assoc_complete_arg *arg)
7752{
7753	size_t len = sizeof(struct wmi_10_4_peer_assoc_complete_cmd);
7754	struct sk_buff *skb;
7755	int ret;
7756
7757	ret = ath10k_wmi_peer_assoc_check_arg(arg);
7758	if (ret)
7759		return ERR_PTR(ret);
7760
7761	skb = ath10k_wmi_alloc_skb(ar, len);
7762	if (!skb)
7763		return ERR_PTR(-ENOMEM);
7764
7765	ath10k_wmi_peer_assoc_fill_10_4(ar, skb->data, arg);
7766
7767	ath10k_dbg(ar, ATH10K_DBG_WMI,
7768		   "wmi peer assoc vdev %d addr %pM (%s)\n",
7769		   arg->vdev_id, arg->addr,
7770		   arg->peer_reassoc ? "reassociate" : "new");
7771	return skb;
7772}
7773
7774static struct sk_buff *
7775ath10k_wmi_10_2_op_gen_pdev_get_temperature(struct ath10k *ar)
7776{
7777	struct sk_buff *skb;
7778
7779	skb = ath10k_wmi_alloc_skb(ar, 0);
7780	if (!skb)
7781		return ERR_PTR(-ENOMEM);
7782
7783	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi pdev get temperature\n");
7784	return skb;
7785}
7786
7787static struct sk_buff *
7788ath10k_wmi_10_2_op_gen_pdev_bss_chan_info(struct ath10k *ar,
7789					  enum wmi_bss_survey_req_type type)
7790{
7791	struct wmi_pdev_chan_info_req_cmd *cmd;
7792	struct sk_buff *skb;
7793
7794	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7795	if (!skb)
7796		return ERR_PTR(-ENOMEM);
7797
7798	cmd = (struct wmi_pdev_chan_info_req_cmd *)skb->data;
7799	cmd->type = __cpu_to_le32(type);
7800
7801	ath10k_dbg(ar, ATH10K_DBG_WMI,
7802		   "wmi pdev bss info request type %d\n", type);
7803
7804	return skb;
7805}
7806
7807/* This function assumes the beacon is already DMA mapped */
7808static struct sk_buff *
7809ath10k_wmi_op_gen_beacon_dma(struct ath10k *ar, u32 vdev_id, const void *bcn,
7810			     size_t bcn_len, u32 bcn_paddr, bool dtim_zero,
7811			     bool deliver_cab)
7812{
7813	struct wmi_bcn_tx_ref_cmd *cmd;
7814	struct sk_buff *skb;
7815	struct ieee80211_hdr *hdr;
7816	u16 fc;
7817
7818	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7819	if (!skb)
7820		return ERR_PTR(-ENOMEM);
7821
7822	hdr = (struct ieee80211_hdr *)bcn;
7823	fc = le16_to_cpu(hdr->frame_control);
7824
7825	cmd = (struct wmi_bcn_tx_ref_cmd *)skb->data;
7826	cmd->vdev_id = __cpu_to_le32(vdev_id);
7827	cmd->data_len = __cpu_to_le32(bcn_len);
7828	cmd->data_ptr = __cpu_to_le32(bcn_paddr);
7829	cmd->msdu_id = 0;
7830	cmd->frame_control = __cpu_to_le32(fc);
7831	cmd->flags = 0;
7832	cmd->antenna_mask = __cpu_to_le32(WMI_BCN_TX_REF_DEF_ANTENNA);
7833
7834	if (dtim_zero)
7835		cmd->flags |= __cpu_to_le32(WMI_BCN_TX_REF_FLAG_DTIM_ZERO);
7836
7837	if (deliver_cab)
7838		cmd->flags |= __cpu_to_le32(WMI_BCN_TX_REF_FLAG_DELIVER_CAB);
7839
7840	return skb;
7841}
7842
7843void ath10k_wmi_set_wmm_param(struct wmi_wmm_params *params,
7844			      const struct wmi_wmm_params_arg *arg)
7845{
7846	params->cwmin  = __cpu_to_le32(arg->cwmin);
7847	params->cwmax  = __cpu_to_le32(arg->cwmax);
7848	params->aifs   = __cpu_to_le32(arg->aifs);
7849	params->txop   = __cpu_to_le32(arg->txop);
7850	params->acm    = __cpu_to_le32(arg->acm);
7851	params->no_ack = __cpu_to_le32(arg->no_ack);
7852}
7853
7854static struct sk_buff *
7855ath10k_wmi_op_gen_pdev_set_wmm(struct ath10k *ar,
7856			       const struct wmi_wmm_params_all_arg *arg)
7857{
7858	struct wmi_pdev_set_wmm_params *cmd;
7859	struct sk_buff *skb;
7860
7861	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7862	if (!skb)
7863		return ERR_PTR(-ENOMEM);
7864
7865	cmd = (struct wmi_pdev_set_wmm_params *)skb->data;
7866	ath10k_wmi_set_wmm_param(&cmd->ac_be, &arg->ac_be);
7867	ath10k_wmi_set_wmm_param(&cmd->ac_bk, &arg->ac_bk);
7868	ath10k_wmi_set_wmm_param(&cmd->ac_vi, &arg->ac_vi);
7869	ath10k_wmi_set_wmm_param(&cmd->ac_vo, &arg->ac_vo);
7870
7871	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi pdev set wmm params\n");
7872	return skb;
7873}
7874
7875static struct sk_buff *
7876ath10k_wmi_op_gen_request_stats(struct ath10k *ar, u32 stats_mask)
7877{
7878	struct wmi_request_stats_cmd *cmd;
7879	struct sk_buff *skb;
7880
7881	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7882	if (!skb)
7883		return ERR_PTR(-ENOMEM);
7884
7885	cmd = (struct wmi_request_stats_cmd *)skb->data;
7886	cmd->stats_id = __cpu_to_le32(stats_mask);
7887
7888	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi request stats 0x%08x\n",
7889		   stats_mask);
7890	return skb;
7891}
7892
7893static struct sk_buff *
7894ath10k_wmi_op_gen_force_fw_hang(struct ath10k *ar,
7895				enum wmi_force_fw_hang_type type, u32 delay_ms)
7896{
7897	struct wmi_force_fw_hang_cmd *cmd;
7898	struct sk_buff *skb;
7899
7900	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7901	if (!skb)
7902		return ERR_PTR(-ENOMEM);
7903
7904	cmd = (struct wmi_force_fw_hang_cmd *)skb->data;
7905	cmd->type = __cpu_to_le32(type);
7906	cmd->delay_ms = __cpu_to_le32(delay_ms);
7907
7908	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi force fw hang %d delay %d\n",
7909		   type, delay_ms);
7910	return skb;
7911}
7912
7913static struct sk_buff *
7914ath10k_wmi_op_gen_dbglog_cfg(struct ath10k *ar, u64 module_enable,
7915			     u32 log_level)
7916{
7917	struct wmi_dbglog_cfg_cmd *cmd;
7918	struct sk_buff *skb;
7919	u32 cfg;
7920
7921	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7922	if (!skb)
7923		return ERR_PTR(-ENOMEM);
7924
7925	cmd = (struct wmi_dbglog_cfg_cmd *)skb->data;
7926
7927	if (module_enable) {
7928		cfg = SM(log_level,
7929			 ATH10K_DBGLOG_CFG_LOG_LVL);
7930	} else {
7931		/* set back defaults, all modules with WARN level */
7932		cfg = SM(ATH10K_DBGLOG_LEVEL_WARN,
7933			 ATH10K_DBGLOG_CFG_LOG_LVL);
7934		module_enable = ~0;
7935	}
7936
7937	cmd->module_enable = __cpu_to_le32(module_enable);
7938	cmd->module_valid = __cpu_to_le32(~0);
7939	cmd->config_enable = __cpu_to_le32(cfg);
7940	cmd->config_valid = __cpu_to_le32(ATH10K_DBGLOG_CFG_LOG_LVL_MASK);
7941
7942	ath10k_dbg(ar, ATH10K_DBG_WMI,
7943		   "wmi dbglog cfg modules %08x %08x config %08x %08x\n",
7944		   __le32_to_cpu(cmd->module_enable),
7945		   __le32_to_cpu(cmd->module_valid),
7946		   __le32_to_cpu(cmd->config_enable),
7947		   __le32_to_cpu(cmd->config_valid));
7948	return skb;
7949}
7950
7951static struct sk_buff *
7952ath10k_wmi_10_4_op_gen_dbglog_cfg(struct ath10k *ar, u64 module_enable,
7953				  u32 log_level)
7954{
7955	struct wmi_10_4_dbglog_cfg_cmd *cmd;
7956	struct sk_buff *skb;
7957	u32 cfg;
7958
7959	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7960	if (!skb)
7961		return ERR_PTR(-ENOMEM);
7962
7963	cmd = (struct wmi_10_4_dbglog_cfg_cmd *)skb->data;
7964
7965	if (module_enable) {
7966		cfg = SM(log_level,
7967			 ATH10K_DBGLOG_CFG_LOG_LVL);
7968	} else {
7969		/* set back defaults, all modules with WARN level */
7970		cfg = SM(ATH10K_DBGLOG_LEVEL_WARN,
7971			 ATH10K_DBGLOG_CFG_LOG_LVL);
7972		module_enable = ~0;
7973	}
7974
7975	cmd->module_enable = __cpu_to_le64(module_enable);
7976	cmd->module_valid = __cpu_to_le64(~0);
7977	cmd->config_enable = __cpu_to_le32(cfg);
7978	cmd->config_valid = __cpu_to_le32(ATH10K_DBGLOG_CFG_LOG_LVL_MASK);
7979
7980	ath10k_dbg(ar, ATH10K_DBG_WMI,
7981		   "wmi dbglog cfg modules 0x%016llx 0x%016llx config %08x %08x\n",
7982		   __le64_to_cpu(cmd->module_enable),
7983		   __le64_to_cpu(cmd->module_valid),
7984		   __le32_to_cpu(cmd->config_enable),
7985		   __le32_to_cpu(cmd->config_valid));
7986	return skb;
7987}
7988
7989static struct sk_buff *
7990ath10k_wmi_op_gen_pktlog_enable(struct ath10k *ar, u32 ev_bitmap)
7991{
7992	struct wmi_pdev_pktlog_enable_cmd *cmd;
7993	struct sk_buff *skb;
7994
7995	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
7996	if (!skb)
7997		return ERR_PTR(-ENOMEM);
7998
7999	ev_bitmap &= ATH10K_PKTLOG_ANY;
8000
8001	cmd = (struct wmi_pdev_pktlog_enable_cmd *)skb->data;
8002	cmd->ev_bitmap = __cpu_to_le32(ev_bitmap);
8003
8004	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi enable pktlog filter 0x%08x\n",
8005		   ev_bitmap);
8006	return skb;
8007}
8008
8009static struct sk_buff *
8010ath10k_wmi_op_gen_pktlog_disable(struct ath10k *ar)
8011{
8012	struct sk_buff *skb;
8013
8014	skb = ath10k_wmi_alloc_skb(ar, 0);
8015	if (!skb)
8016		return ERR_PTR(-ENOMEM);
8017
8018	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi disable pktlog\n");
8019	return skb;
8020}
8021
8022static struct sk_buff *
8023ath10k_wmi_op_gen_pdev_set_quiet_mode(struct ath10k *ar, u32 period,
8024				      u32 duration, u32 next_offset,
8025				      u32 enabled)
8026{
8027	struct wmi_pdev_set_quiet_cmd *cmd;
8028	struct sk_buff *skb;
8029
8030	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8031	if (!skb)
8032		return ERR_PTR(-ENOMEM);
8033
8034	cmd = (struct wmi_pdev_set_quiet_cmd *)skb->data;
8035	cmd->period = __cpu_to_le32(period);
8036	cmd->duration = __cpu_to_le32(duration);
8037	cmd->next_start = __cpu_to_le32(next_offset);
8038	cmd->enabled = __cpu_to_le32(enabled);
8039
8040	ath10k_dbg(ar, ATH10K_DBG_WMI,
8041		   "wmi quiet param: period %u duration %u enabled %d\n",
8042		   period, duration, enabled);
8043	return skb;
8044}
8045
8046static struct sk_buff *
8047ath10k_wmi_op_gen_addba_clear_resp(struct ath10k *ar, u32 vdev_id,
8048				   const u8 *mac)
8049{
8050	struct wmi_addba_clear_resp_cmd *cmd;
8051	struct sk_buff *skb;
8052
8053	if (!mac)
8054		return ERR_PTR(-EINVAL);
8055
8056	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8057	if (!skb)
8058		return ERR_PTR(-ENOMEM);
8059
8060	cmd = (struct wmi_addba_clear_resp_cmd *)skb->data;
8061	cmd->vdev_id = __cpu_to_le32(vdev_id);
8062	ether_addr_copy(cmd->peer_macaddr.addr, mac);
8063
8064	ath10k_dbg(ar, ATH10K_DBG_WMI,
8065		   "wmi addba clear resp vdev_id 0x%X mac_addr %pM\n",
8066		   vdev_id, mac);
8067	return skb;
8068}
8069
8070static struct sk_buff *
8071ath10k_wmi_op_gen_addba_send(struct ath10k *ar, u32 vdev_id, const u8 *mac,
8072			     u32 tid, u32 buf_size)
8073{
8074	struct wmi_addba_send_cmd *cmd;
8075	struct sk_buff *skb;
8076
8077	if (!mac)
8078		return ERR_PTR(-EINVAL);
8079
8080	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8081	if (!skb)
8082		return ERR_PTR(-ENOMEM);
8083
8084	cmd = (struct wmi_addba_send_cmd *)skb->data;
8085	cmd->vdev_id = __cpu_to_le32(vdev_id);
8086	ether_addr_copy(cmd->peer_macaddr.addr, mac);
8087	cmd->tid = __cpu_to_le32(tid);
8088	cmd->buffersize = __cpu_to_le32(buf_size);
8089
8090	ath10k_dbg(ar, ATH10K_DBG_WMI,
8091		   "wmi addba send vdev_id 0x%X mac_addr %pM tid %u bufsize %u\n",
8092		   vdev_id, mac, tid, buf_size);
8093	return skb;
8094}
8095
8096static struct sk_buff *
8097ath10k_wmi_op_gen_addba_set_resp(struct ath10k *ar, u32 vdev_id, const u8 *mac,
8098				 u32 tid, u32 status)
8099{
8100	struct wmi_addba_setresponse_cmd *cmd;
8101	struct sk_buff *skb;
8102
8103	if (!mac)
8104		return ERR_PTR(-EINVAL);
8105
8106	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8107	if (!skb)
8108		return ERR_PTR(-ENOMEM);
8109
8110	cmd = (struct wmi_addba_setresponse_cmd *)skb->data;
8111	cmd->vdev_id = __cpu_to_le32(vdev_id);
8112	ether_addr_copy(cmd->peer_macaddr.addr, mac);
8113	cmd->tid = __cpu_to_le32(tid);
8114	cmd->statuscode = __cpu_to_le32(status);
8115
8116	ath10k_dbg(ar, ATH10K_DBG_WMI,
8117		   "wmi addba set resp vdev_id 0x%X mac_addr %pM tid %u status %u\n",
8118		   vdev_id, mac, tid, status);
8119	return skb;
8120}
8121
8122static struct sk_buff *
8123ath10k_wmi_op_gen_delba_send(struct ath10k *ar, u32 vdev_id, const u8 *mac,
8124			     u32 tid, u32 initiator, u32 reason)
8125{
8126	struct wmi_delba_send_cmd *cmd;
8127	struct sk_buff *skb;
8128
8129	if (!mac)
8130		return ERR_PTR(-EINVAL);
8131
8132	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8133	if (!skb)
8134		return ERR_PTR(-ENOMEM);
8135
8136	cmd = (struct wmi_delba_send_cmd *)skb->data;
8137	cmd->vdev_id = __cpu_to_le32(vdev_id);
8138	ether_addr_copy(cmd->peer_macaddr.addr, mac);
8139	cmd->tid = __cpu_to_le32(tid);
8140	cmd->initiator = __cpu_to_le32(initiator);
8141	cmd->reasoncode = __cpu_to_le32(reason);
8142
8143	ath10k_dbg(ar, ATH10K_DBG_WMI,
8144		   "wmi delba send vdev_id 0x%X mac_addr %pM tid %u initiator %u reason %u\n",
8145		   vdev_id, mac, tid, initiator, reason);
8146	return skb;
8147}
8148
8149static struct sk_buff *
8150ath10k_wmi_10_2_4_op_gen_pdev_get_tpc_config(struct ath10k *ar, u32 param)
8151{
8152	struct wmi_pdev_get_tpc_config_cmd *cmd;
8153	struct sk_buff *skb;
8154
8155	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8156	if (!skb)
8157		return ERR_PTR(-ENOMEM);
8158
8159	cmd = (struct wmi_pdev_get_tpc_config_cmd *)skb->data;
8160	cmd->param = __cpu_to_le32(param);
8161
8162	ath10k_dbg(ar, ATH10K_DBG_WMI,
8163		   "wmi pdev get tpc config param %d\n", param);
8164	return skb;
8165}
8166
8167size_t ath10k_wmi_fw_stats_num_peers(struct list_head *head)
8168{
8169	struct ath10k_fw_stats_peer *i;
8170	size_t num = 0;
8171
8172	list_for_each_entry(i, head, list)
8173		++num;
8174
8175	return num;
8176}
8177
8178size_t ath10k_wmi_fw_stats_num_vdevs(struct list_head *head)
8179{
8180	struct ath10k_fw_stats_vdev *i;
8181	size_t num = 0;
8182
8183	list_for_each_entry(i, head, list)
8184		++num;
8185
8186	return num;
8187}
8188
8189static void
8190ath10k_wmi_fw_pdev_base_stats_fill(const struct ath10k_fw_stats_pdev *pdev,
8191				   char *buf, u32 *length)
8192{
8193	u32 len = *length;
8194	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8195
8196	len += scnprintf(buf + len, buf_len - len, "\n");
8197	len += scnprintf(buf + len, buf_len - len, "%30s\n",
8198			"ath10k PDEV stats");
8199	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8200			"=================");
8201
8202	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8203			"Channel noise floor", pdev->ch_noise_floor);
8204	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8205			"Channel TX power", pdev->chan_tx_power);
8206	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8207			"TX frame count", pdev->tx_frame_count);
8208	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8209			"RX frame count", pdev->rx_frame_count);
8210	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8211			"RX clear count", pdev->rx_clear_count);
8212	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8213			"Cycle count", pdev->cycle_count);
8214	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8215			"PHY error count", pdev->phy_err_count);
8216
8217	*length = len;
8218}
8219
8220static void
8221ath10k_wmi_fw_pdev_extra_stats_fill(const struct ath10k_fw_stats_pdev *pdev,
8222				    char *buf, u32 *length)
8223{
8224	u32 len = *length;
8225	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8226
8227	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8228			"RTS bad count", pdev->rts_bad);
8229	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8230			"RTS good count", pdev->rts_good);
8231	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8232			"FCS bad count", pdev->fcs_bad);
8233	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8234			"No beacon count", pdev->no_beacons);
8235	len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
8236			"MIB int count", pdev->mib_int_count);
8237
8238	len += scnprintf(buf + len, buf_len - len, "\n");
8239	*length = len;
8240}
8241
8242static void
8243ath10k_wmi_fw_pdev_tx_stats_fill(const struct ath10k_fw_stats_pdev *pdev,
8244				 char *buf, u32 *length)
8245{
8246	u32 len = *length;
8247	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8248
8249	len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
8250			 "ath10k PDEV TX stats");
8251	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8252				 "=================");
8253
8254	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8255			 "HTT cookies queued", pdev->comp_queued);
8256	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8257			 "HTT cookies disp.", pdev->comp_delivered);
8258	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8259			 "MSDU queued", pdev->msdu_enqued);
8260	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8261			 "MPDU queued", pdev->mpdu_enqued);
8262	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8263			 "MSDUs dropped", pdev->wmm_drop);
8264	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8265			 "Local enqued", pdev->local_enqued);
8266	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8267			 "Local freed", pdev->local_freed);
8268	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8269			 "HW queued", pdev->hw_queued);
8270	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8271			 "PPDUs reaped", pdev->hw_reaped);
8272	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8273			 "Num underruns", pdev->underrun);
8274	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8275			 "PPDUs cleaned", pdev->tx_abort);
8276	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8277			 "MPDUs requeued", pdev->mpdus_requeued);
8278	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8279			 "Excessive retries", pdev->tx_ko);
8280	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8281			 "HW rate", pdev->data_rc);
8282	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8283			 "Sched self triggers", pdev->self_triggers);
8284	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8285			 "Dropped due to SW retries",
8286			 pdev->sw_retry_failure);
8287	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8288			 "Illegal rate phy errors",
8289			 pdev->illgl_rate_phy_err);
8290	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8291			 "Pdev continuous xretry", pdev->pdev_cont_xretry);
8292	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8293			 "TX timeout", pdev->pdev_tx_timeout);
8294	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8295			 "PDEV resets", pdev->pdev_resets);
8296	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8297			 "PHY underrun", pdev->phy_underrun);
8298	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8299			 "MPDU is more than txop limit", pdev->txop_ovf);
8300	*length = len;
8301}
8302
8303static void
8304ath10k_wmi_fw_pdev_rx_stats_fill(const struct ath10k_fw_stats_pdev *pdev,
8305				 char *buf, u32 *length)
8306{
8307	u32 len = *length;
8308	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8309
8310	len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
8311			 "ath10k PDEV RX stats");
8312	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8313				 "=================");
8314
8315	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8316			 "Mid PPDU route change",
8317			 pdev->mid_ppdu_route_change);
8318	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8319			 "Tot. number of statuses", pdev->status_rcvd);
8320	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8321			 "Extra frags on rings 0", pdev->r0_frags);
8322	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8323			 "Extra frags on rings 1", pdev->r1_frags);
8324	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8325			 "Extra frags on rings 2", pdev->r2_frags);
8326	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8327			 "Extra frags on rings 3", pdev->r3_frags);
8328	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8329			 "MSDUs delivered to HTT", pdev->htt_msdus);
8330	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8331			 "MPDUs delivered to HTT", pdev->htt_mpdus);
8332	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8333			 "MSDUs delivered to stack", pdev->loc_msdus);
8334	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8335			 "MPDUs delivered to stack", pdev->loc_mpdus);
8336	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8337			 "Oversized AMSDUs", pdev->oversize_amsdu);
8338	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8339			 "PHY errors", pdev->phy_errs);
8340	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8341			 "PHY errors drops", pdev->phy_err_drop);
8342	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8343			 "MPDU errors (FCS, MIC, ENC)", pdev->mpdu_errs);
8344	*length = len;
8345}
8346
8347static void
8348ath10k_wmi_fw_vdev_stats_fill(const struct ath10k_fw_stats_vdev *vdev,
8349			      char *buf, u32 *length)
8350{
8351	u32 len = *length;
8352	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8353	int i;
8354
8355	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8356			"vdev id", vdev->vdev_id);
8357	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8358			"beacon snr", vdev->beacon_snr);
8359	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8360			"data snr", vdev->data_snr);
8361	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8362			"num rx frames", vdev->num_rx_frames);
8363	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8364			"num rts fail", vdev->num_rts_fail);
8365	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8366			"num rts success", vdev->num_rts_success);
8367	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8368			"num rx err", vdev->num_rx_err);
8369	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8370			"num rx discard", vdev->num_rx_discard);
8371	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8372			"num tx not acked", vdev->num_tx_not_acked);
8373
8374	for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames); i++)
8375		len += scnprintf(buf + len, buf_len - len,
8376				"%25s [%02d] %u\n",
8377				"num tx frames", i,
8378				vdev->num_tx_frames[i]);
8379
8380	for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_retries); i++)
8381		len += scnprintf(buf + len, buf_len - len,
8382				"%25s [%02d] %u\n",
8383				"num tx frames retries", i,
8384				vdev->num_tx_frames_retries[i]);
8385
8386	for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_failures); i++)
8387		len += scnprintf(buf + len, buf_len - len,
8388				"%25s [%02d] %u\n",
8389				"num tx frames failures", i,
8390				vdev->num_tx_frames_failures[i]);
8391
8392	for (i = 0 ; i < ARRAY_SIZE(vdev->tx_rate_history); i++)
8393		len += scnprintf(buf + len, buf_len - len,
8394				"%25s [%02d] 0x%08x\n",
8395				"tx rate history", i,
8396				vdev->tx_rate_history[i]);
8397
8398	for (i = 0 ; i < ARRAY_SIZE(vdev->beacon_rssi_history); i++)
8399		len += scnprintf(buf + len, buf_len - len,
8400				"%25s [%02d] %u\n",
8401				"beacon rssi history", i,
8402				vdev->beacon_rssi_history[i]);
8403
8404	len += scnprintf(buf + len, buf_len - len, "\n");
8405	*length = len;
8406}
8407
8408static void
8409ath10k_wmi_fw_peer_stats_fill(const struct ath10k_fw_stats_peer *peer,
8410			      char *buf, u32 *length, bool extended_peer)
8411{
8412	u32 len = *length;
8413	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8414
8415	len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
8416			"Peer MAC address", peer->peer_macaddr);
8417	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8418			"Peer RSSI", peer->peer_rssi);
8419	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8420			"Peer TX rate", peer->peer_tx_rate);
8421	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8422			"Peer RX rate", peer->peer_rx_rate);
8423	if (!extended_peer)
8424		len += scnprintf(buf + len, buf_len - len, "%30s %llu\n",
8425				"Peer RX duration", peer->rx_duration);
8426
8427	len += scnprintf(buf + len, buf_len - len, "\n");
8428	*length = len;
8429}
8430
8431static void
8432ath10k_wmi_fw_extd_peer_stats_fill(const struct ath10k_fw_extd_stats_peer *peer,
8433				   char *buf, u32 *length)
8434{
8435	u32 len = *length;
8436	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8437
8438	len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
8439			"Peer MAC address", peer->peer_macaddr);
8440	len += scnprintf(buf + len, buf_len - len, "%30s %llu\n",
8441			"Peer RX duration", peer->rx_duration);
8442}
8443
8444void ath10k_wmi_main_op_fw_stats_fill(struct ath10k *ar,
8445				      struct ath10k_fw_stats *fw_stats,
8446				      char *buf)
8447{
8448	u32 len = 0;
8449	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8450	const struct ath10k_fw_stats_pdev *pdev;
8451	const struct ath10k_fw_stats_vdev *vdev;
8452	const struct ath10k_fw_stats_peer *peer;
8453	size_t num_peers;
8454	size_t num_vdevs;
8455
8456	spin_lock_bh(&ar->data_lock);
8457
8458	pdev = list_first_entry_or_null(&fw_stats->pdevs,
8459					struct ath10k_fw_stats_pdev, list);
8460	if (!pdev) {
8461		ath10k_warn(ar, "failed to get pdev stats\n");
8462		goto unlock;
8463	}
8464
8465	num_peers = ath10k_wmi_fw_stats_num_peers(&fw_stats->peers);
8466	num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&fw_stats->vdevs);
8467
8468	ath10k_wmi_fw_pdev_base_stats_fill(pdev, buf, &len);
8469	ath10k_wmi_fw_pdev_tx_stats_fill(pdev, buf, &len);
8470	ath10k_wmi_fw_pdev_rx_stats_fill(pdev, buf, &len);
8471
8472	len += scnprintf(buf + len, buf_len - len, "\n");
8473	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8474			 "ath10k VDEV stats", num_vdevs);
8475	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8476				 "=================");
8477
8478	list_for_each_entry(vdev, &fw_stats->vdevs, list) {
8479		ath10k_wmi_fw_vdev_stats_fill(vdev, buf, &len);
8480	}
8481
8482	len += scnprintf(buf + len, buf_len - len, "\n");
8483	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8484			 "ath10k PEER stats", num_peers);
8485	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8486				 "=================");
8487
8488	list_for_each_entry(peer, &fw_stats->peers, list) {
8489		ath10k_wmi_fw_peer_stats_fill(peer, buf, &len,
8490					      fw_stats->extended);
8491	}
8492
8493unlock:
8494	spin_unlock_bh(&ar->data_lock);
8495
8496	if (len >= buf_len)
8497		buf[len - 1] = 0;
8498	else
8499		buf[len] = 0;
8500}
8501
8502void ath10k_wmi_10x_op_fw_stats_fill(struct ath10k *ar,
8503				     struct ath10k_fw_stats *fw_stats,
8504				     char *buf)
8505{
8506	unsigned int len = 0;
8507	unsigned int buf_len = ATH10K_FW_STATS_BUF_SIZE;
8508	const struct ath10k_fw_stats_pdev *pdev;
8509	const struct ath10k_fw_stats_vdev *vdev;
8510	const struct ath10k_fw_stats_peer *peer;
8511	size_t num_peers;
8512	size_t num_vdevs;
8513
8514	spin_lock_bh(&ar->data_lock);
8515
8516	pdev = list_first_entry_or_null(&fw_stats->pdevs,
8517					struct ath10k_fw_stats_pdev, list);
8518	if (!pdev) {
8519		ath10k_warn(ar, "failed to get pdev stats\n");
8520		goto unlock;
8521	}
8522
8523	num_peers = ath10k_wmi_fw_stats_num_peers(&fw_stats->peers);
8524	num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&fw_stats->vdevs);
8525
8526	ath10k_wmi_fw_pdev_base_stats_fill(pdev, buf, &len);
8527	ath10k_wmi_fw_pdev_extra_stats_fill(pdev, buf, &len);
8528	ath10k_wmi_fw_pdev_tx_stats_fill(pdev, buf, &len);
8529	ath10k_wmi_fw_pdev_rx_stats_fill(pdev, buf, &len);
8530
8531	len += scnprintf(buf + len, buf_len - len, "\n");
8532	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8533			 "ath10k VDEV stats", num_vdevs);
8534	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8535				 "=================");
8536
8537	list_for_each_entry(vdev, &fw_stats->vdevs, list) {
8538		ath10k_wmi_fw_vdev_stats_fill(vdev, buf, &len);
8539	}
8540
8541	len += scnprintf(buf + len, buf_len - len, "\n");
8542	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8543			 "ath10k PEER stats", num_peers);
8544	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8545				 "=================");
8546
8547	list_for_each_entry(peer, &fw_stats->peers, list) {
8548		ath10k_wmi_fw_peer_stats_fill(peer, buf, &len,
8549					      fw_stats->extended);
8550	}
8551
8552unlock:
8553	spin_unlock_bh(&ar->data_lock);
8554
8555	if (len >= buf_len)
8556		buf[len - 1] = 0;
8557	else
8558		buf[len] = 0;
8559}
8560
8561static struct sk_buff *
8562ath10k_wmi_op_gen_pdev_enable_adaptive_cca(struct ath10k *ar, u8 enable,
8563					   u32 detect_level, u32 detect_margin)
8564{
8565	struct wmi_pdev_set_adaptive_cca_params *cmd;
8566	struct sk_buff *skb;
8567
8568	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8569	if (!skb)
8570		return ERR_PTR(-ENOMEM);
8571
8572	cmd = (struct wmi_pdev_set_adaptive_cca_params *)skb->data;
8573	cmd->enable = __cpu_to_le32(enable);
8574	cmd->cca_detect_level = __cpu_to_le32(detect_level);
8575	cmd->cca_detect_margin = __cpu_to_le32(detect_margin);
8576
8577	ath10k_dbg(ar, ATH10K_DBG_WMI,
8578		   "wmi pdev set adaptive cca params enable:%d detection level:%d detection margin:%d\n",
8579		   enable, detect_level, detect_margin);
8580	return skb;
8581}
8582
8583static void
8584ath10k_wmi_fw_vdev_stats_extd_fill(const struct ath10k_fw_stats_vdev_extd *vdev,
8585				   char *buf, u32 *length)
8586{
8587	u32 len = *length;
8588	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8589	u32 val;
8590
8591	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8592			 "vdev id", vdev->vdev_id);
8593	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8594			 "ppdu aggr count", vdev->ppdu_aggr_cnt);
8595	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8596			 "ppdu noack", vdev->ppdu_noack);
8597	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8598			 "mpdu queued", vdev->mpdu_queued);
8599	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8600			 "ppdu nonaggr count", vdev->ppdu_nonaggr_cnt);
8601	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8602			 "mpdu sw requeued", vdev->mpdu_sw_requeued);
8603	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8604			 "mpdu success retry", vdev->mpdu_suc_retry);
8605	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8606			 "mpdu success multitry", vdev->mpdu_suc_multitry);
8607	len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8608			 "mpdu fail retry", vdev->mpdu_fail_retry);
8609	val = vdev->tx_ftm_suc;
8610	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8611		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8612				 "tx ftm success",
8613				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8614	val = vdev->tx_ftm_suc_retry;
8615	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8616		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8617				 "tx ftm success retry",
8618				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8619	val = vdev->tx_ftm_fail;
8620	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8621		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8622				 "tx ftm fail",
8623				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8624	val = vdev->rx_ftmr_cnt;
8625	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8626		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8627				 "rx ftm request count",
8628				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8629	val = vdev->rx_ftmr_dup_cnt;
8630	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8631		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8632				 "rx ftm request dup count",
8633				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8634	val = vdev->rx_iftmr_cnt;
8635	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8636		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8637				 "rx initial ftm req count",
8638				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8639	val = vdev->rx_iftmr_dup_cnt;
8640	if (val & WMI_VDEV_STATS_FTM_COUNT_VALID)
8641		len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
8642				 "rx initial ftm req dup cnt",
8643				 MS(val, WMI_VDEV_STATS_FTM_COUNT));
8644	len += scnprintf(buf + len, buf_len - len, "\n");
8645
8646	*length = len;
8647}
8648
8649void ath10k_wmi_10_4_op_fw_stats_fill(struct ath10k *ar,
8650				      struct ath10k_fw_stats *fw_stats,
8651				      char *buf)
8652{
8653	u32 len = 0;
8654	u32 buf_len = ATH10K_FW_STATS_BUF_SIZE;
8655	const struct ath10k_fw_stats_pdev *pdev;
8656	const struct ath10k_fw_stats_vdev_extd *vdev;
8657	const struct ath10k_fw_stats_peer *peer;
8658	const struct ath10k_fw_extd_stats_peer *extd_peer;
8659	size_t num_peers;
8660	size_t num_vdevs;
8661
8662	spin_lock_bh(&ar->data_lock);
8663
8664	pdev = list_first_entry_or_null(&fw_stats->pdevs,
8665					struct ath10k_fw_stats_pdev, list);
8666	if (!pdev) {
8667		ath10k_warn(ar, "failed to get pdev stats\n");
8668		goto unlock;
8669	}
8670
8671	num_peers = ath10k_wmi_fw_stats_num_peers(&fw_stats->peers);
8672	num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&fw_stats->vdevs);
8673
8674	ath10k_wmi_fw_pdev_base_stats_fill(pdev, buf, &len);
8675	ath10k_wmi_fw_pdev_extra_stats_fill(pdev, buf, &len);
8676	ath10k_wmi_fw_pdev_tx_stats_fill(pdev, buf, &len);
8677
8678	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8679			"HW paused", pdev->hw_paused);
8680	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8681			"Seqs posted", pdev->seq_posted);
8682	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8683			"Seqs failed queueing", pdev->seq_failed_queueing);
8684	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8685			"Seqs completed", pdev->seq_completed);
8686	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8687			"Seqs restarted", pdev->seq_restarted);
8688	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8689			"MU Seqs posted", pdev->mu_seq_posted);
8690	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8691			"MPDUs SW flushed", pdev->mpdus_sw_flush);
8692	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8693			"MPDUs HW filtered", pdev->mpdus_hw_filter);
8694	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8695			"MPDUs truncated", pdev->mpdus_truncated);
8696	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8697			"MPDUs receive no ACK", pdev->mpdus_ack_failed);
8698	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8699			"MPDUs expired", pdev->mpdus_expired);
8700
8701	ath10k_wmi_fw_pdev_rx_stats_fill(pdev, buf, &len);
8702	len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
8703			"Num Rx Overflow errors", pdev->rx_ovfl_errs);
8704
8705	len += scnprintf(buf + len, buf_len - len, "\n");
8706	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8707			"ath10k VDEV stats", num_vdevs);
8708	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8709				"=================");
8710	list_for_each_entry(vdev, &fw_stats->vdevs, list) {
8711		ath10k_wmi_fw_vdev_stats_extd_fill(vdev, buf, &len);
8712	}
8713
8714	len += scnprintf(buf + len, buf_len - len, "\n");
8715	len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
8716			"ath10k PEER stats", num_peers);
8717	len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
8718				"=================");
8719
8720	list_for_each_entry(peer, &fw_stats->peers, list) {
8721		ath10k_wmi_fw_peer_stats_fill(peer, buf, &len,
8722					      fw_stats->extended);
8723	}
8724
8725	if (fw_stats->extended) {
8726		list_for_each_entry(extd_peer, &fw_stats->peers_extd, list) {
8727			ath10k_wmi_fw_extd_peer_stats_fill(extd_peer, buf,
8728							   &len);
8729		}
8730	}
8731
8732unlock:
8733	spin_unlock_bh(&ar->data_lock);
8734
8735	if (len >= buf_len)
8736		buf[len - 1] = 0;
8737	else
8738		buf[len] = 0;
8739}
8740
8741int ath10k_wmi_op_get_vdev_subtype(struct ath10k *ar,
8742				   enum wmi_vdev_subtype subtype)
8743{
8744	switch (subtype) {
8745	case WMI_VDEV_SUBTYPE_NONE:
8746		return WMI_VDEV_SUBTYPE_LEGACY_NONE;
8747	case WMI_VDEV_SUBTYPE_P2P_DEVICE:
8748		return WMI_VDEV_SUBTYPE_LEGACY_P2P_DEV;
8749	case WMI_VDEV_SUBTYPE_P2P_CLIENT:
8750		return WMI_VDEV_SUBTYPE_LEGACY_P2P_CLI;
8751	case WMI_VDEV_SUBTYPE_P2P_GO:
8752		return WMI_VDEV_SUBTYPE_LEGACY_P2P_GO;
8753	case WMI_VDEV_SUBTYPE_PROXY_STA:
8754		return WMI_VDEV_SUBTYPE_LEGACY_PROXY_STA;
8755	case WMI_VDEV_SUBTYPE_MESH_11S:
8756	case WMI_VDEV_SUBTYPE_MESH_NON_11S:
8757		return -ENOTSUPP;
8758	}
8759	return -ENOTSUPP;
8760}
8761
8762static int ath10k_wmi_10_2_4_op_get_vdev_subtype(struct ath10k *ar,
8763						 enum wmi_vdev_subtype subtype)
8764{
8765	switch (subtype) {
8766	case WMI_VDEV_SUBTYPE_NONE:
8767		return WMI_VDEV_SUBTYPE_10_2_4_NONE;
8768	case WMI_VDEV_SUBTYPE_P2P_DEVICE:
8769		return WMI_VDEV_SUBTYPE_10_2_4_P2P_DEV;
8770	case WMI_VDEV_SUBTYPE_P2P_CLIENT:
8771		return WMI_VDEV_SUBTYPE_10_2_4_P2P_CLI;
8772	case WMI_VDEV_SUBTYPE_P2P_GO:
8773		return WMI_VDEV_SUBTYPE_10_2_4_P2P_GO;
8774	case WMI_VDEV_SUBTYPE_PROXY_STA:
8775		return WMI_VDEV_SUBTYPE_10_2_4_PROXY_STA;
8776	case WMI_VDEV_SUBTYPE_MESH_11S:
8777		return WMI_VDEV_SUBTYPE_10_2_4_MESH_11S;
8778	case WMI_VDEV_SUBTYPE_MESH_NON_11S:
8779		return -ENOTSUPP;
8780	}
8781	return -ENOTSUPP;
8782}
8783
8784static int ath10k_wmi_10_4_op_get_vdev_subtype(struct ath10k *ar,
8785					       enum wmi_vdev_subtype subtype)
8786{
8787	switch (subtype) {
8788	case WMI_VDEV_SUBTYPE_NONE:
8789		return WMI_VDEV_SUBTYPE_10_4_NONE;
8790	case WMI_VDEV_SUBTYPE_P2P_DEVICE:
8791		return WMI_VDEV_SUBTYPE_10_4_P2P_DEV;
8792	case WMI_VDEV_SUBTYPE_P2P_CLIENT:
8793		return WMI_VDEV_SUBTYPE_10_4_P2P_CLI;
8794	case WMI_VDEV_SUBTYPE_P2P_GO:
8795		return WMI_VDEV_SUBTYPE_10_4_P2P_GO;
8796	case WMI_VDEV_SUBTYPE_PROXY_STA:
8797		return WMI_VDEV_SUBTYPE_10_4_PROXY_STA;
8798	case WMI_VDEV_SUBTYPE_MESH_11S:
8799		return WMI_VDEV_SUBTYPE_10_4_MESH_11S;
8800	case WMI_VDEV_SUBTYPE_MESH_NON_11S:
8801		return WMI_VDEV_SUBTYPE_10_4_MESH_NON_11S;
8802	}
8803	return -ENOTSUPP;
8804}
8805
8806static struct sk_buff *
8807ath10k_wmi_10_4_ext_resource_config(struct ath10k *ar,
8808				    enum wmi_host_platform_type type,
8809				    u32 fw_feature_bitmap)
8810{
8811	struct wmi_ext_resource_config_10_4_cmd *cmd;
8812	struct sk_buff *skb;
8813	u32 num_tdls_sleep_sta = 0;
8814
8815	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8816	if (!skb)
8817		return ERR_PTR(-ENOMEM);
8818
8819	if (test_bit(WMI_SERVICE_TDLS_UAPSD_SLEEP_STA, ar->wmi.svc_map))
8820		num_tdls_sleep_sta = TARGET_10_4_NUM_TDLS_SLEEP_STA;
8821
8822	cmd = (struct wmi_ext_resource_config_10_4_cmd *)skb->data;
8823	cmd->host_platform_config = __cpu_to_le32(type);
8824	cmd->fw_feature_bitmap = __cpu_to_le32(fw_feature_bitmap);
8825	cmd->wlan_gpio_priority = __cpu_to_le32(ar->coex_gpio_pin);
8826	cmd->coex_version = __cpu_to_le32(WMI_NO_COEX_VERSION_SUPPORT);
8827	cmd->coex_gpio_pin1 = __cpu_to_le32(-1);
8828	cmd->coex_gpio_pin2 = __cpu_to_le32(-1);
8829	cmd->coex_gpio_pin3 = __cpu_to_le32(-1);
8830	cmd->num_tdls_vdevs = __cpu_to_le32(TARGET_10_4_NUM_TDLS_VDEVS);
8831	cmd->num_tdls_conn_table_entries = __cpu_to_le32(20);
8832	cmd->max_tdls_concurrent_sleep_sta = __cpu_to_le32(num_tdls_sleep_sta);
8833	cmd->max_tdls_concurrent_buffer_sta =
8834			__cpu_to_le32(TARGET_10_4_NUM_TDLS_BUFFER_STA);
8835
8836	ath10k_dbg(ar, ATH10K_DBG_WMI,
8837		   "wmi ext resource config host type %d firmware feature bitmap %08x\n",
8838		   type, fw_feature_bitmap);
8839	return skb;
8840}
8841
8842static struct sk_buff *
8843ath10k_wmi_10_4_gen_update_fw_tdls_state(struct ath10k *ar, u32 vdev_id,
8844					 enum wmi_tdls_state state)
8845{
8846	struct wmi_10_4_tdls_set_state_cmd *cmd;
8847	struct sk_buff *skb;
8848	u32 options = 0;
8849
8850	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8851	if (!skb)
8852		return ERR_PTR(-ENOMEM);
8853
8854	if (test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map) &&
8855	    state == WMI_TDLS_ENABLE_ACTIVE)
8856		state = WMI_TDLS_ENABLE_PASSIVE;
8857
8858	if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map))
8859		options |= WMI_TDLS_BUFFER_STA_EN;
8860
8861	cmd = (struct wmi_10_4_tdls_set_state_cmd *)skb->data;
8862	cmd->vdev_id = __cpu_to_le32(vdev_id);
8863	cmd->state = __cpu_to_le32(state);
8864	cmd->notification_interval_ms = __cpu_to_le32(5000);
8865	cmd->tx_discovery_threshold = __cpu_to_le32(100);
8866	cmd->tx_teardown_threshold = __cpu_to_le32(5);
8867	cmd->rssi_teardown_threshold = __cpu_to_le32(-75);
8868	cmd->rssi_delta = __cpu_to_le32(-20);
8869	cmd->tdls_options = __cpu_to_le32(options);
8870	cmd->tdls_peer_traffic_ind_window = __cpu_to_le32(2);
8871	cmd->tdls_peer_traffic_response_timeout_ms = __cpu_to_le32(5000);
8872	cmd->tdls_puapsd_mask = __cpu_to_le32(0xf);
8873	cmd->tdls_puapsd_inactivity_time_ms = __cpu_to_le32(0);
8874	cmd->tdls_puapsd_rx_frame_threshold = __cpu_to_le32(10);
8875	cmd->teardown_notification_ms = __cpu_to_le32(10);
8876	cmd->tdls_peer_kickout_threshold = __cpu_to_le32(96);
8877
8878	ath10k_dbg(ar, ATH10K_DBG_WMI, "wmi update fw tdls state %d for vdev %i\n",
8879		   state, vdev_id);
8880	return skb;
8881}
8882
8883static u32 ath10k_wmi_prepare_peer_qos(u8 uapsd_queues, u8 sp)
8884{
8885	u32 peer_qos = 0;
8886
8887	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
8888		peer_qos |= WMI_TDLS_PEER_QOS_AC_VO;
8889	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
8890		peer_qos |= WMI_TDLS_PEER_QOS_AC_VI;
8891	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
8892		peer_qos |= WMI_TDLS_PEER_QOS_AC_BK;
8893	if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
8894		peer_qos |= WMI_TDLS_PEER_QOS_AC_BE;
8895
8896	peer_qos |= SM(sp, WMI_TDLS_PEER_SP);
8897
8898	return peer_qos;
8899}
8900
8901static struct sk_buff *
8902ath10k_wmi_10_4_op_gen_pdev_get_tpc_table_cmdid(struct ath10k *ar, u32 param)
8903{
8904	struct wmi_pdev_get_tpc_table_cmd *cmd;
8905	struct sk_buff *skb;
8906
8907	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8908	if (!skb)
8909		return ERR_PTR(-ENOMEM);
8910
8911	cmd = (struct wmi_pdev_get_tpc_table_cmd *)skb->data;
8912	cmd->param = __cpu_to_le32(param);
8913
8914	ath10k_dbg(ar, ATH10K_DBG_WMI,
8915		   "wmi pdev get tpc table param:%d\n", param);
8916	return skb;
8917}
8918
8919static struct sk_buff *
8920ath10k_wmi_10_4_gen_tdls_peer_update(struct ath10k *ar,
8921				     const struct wmi_tdls_peer_update_cmd_arg *arg,
8922				     const struct wmi_tdls_peer_capab_arg *cap,
8923				     const struct wmi_channel_arg *chan_arg)
8924{
8925	struct wmi_10_4_tdls_peer_update_cmd *cmd;
8926	struct wmi_tdls_peer_capabilities *peer_cap;
8927	struct wmi_channel *chan;
8928	struct sk_buff *skb;
8929	u32 peer_qos;
8930	int len, chan_len;
8931	int i;
8932
8933	/* tdls peer update cmd has place holder for one channel*/
8934	chan_len = cap->peer_chan_len ? (cap->peer_chan_len - 1) : 0;
8935
8936	len = sizeof(*cmd) + chan_len * sizeof(*chan);
8937
8938	skb = ath10k_wmi_alloc_skb(ar, len);
8939	if (!skb)
8940		return ERR_PTR(-ENOMEM);
8941
8942	memset(skb->data, 0, sizeof(*cmd));
8943
8944	cmd = (struct wmi_10_4_tdls_peer_update_cmd *)skb->data;
8945	cmd->vdev_id = __cpu_to_le32(arg->vdev_id);
8946	ether_addr_copy(cmd->peer_macaddr.addr, arg->addr);
8947	cmd->peer_state = __cpu_to_le32(arg->peer_state);
8948
8949	peer_qos = ath10k_wmi_prepare_peer_qos(cap->peer_uapsd_queues,
8950					       cap->peer_max_sp);
8951
8952	peer_cap = &cmd->peer_capab;
8953	peer_cap->peer_qos = __cpu_to_le32(peer_qos);
8954	peer_cap->buff_sta_support = __cpu_to_le32(cap->buff_sta_support);
8955	peer_cap->off_chan_support = __cpu_to_le32(cap->off_chan_support);
8956	peer_cap->peer_curr_operclass = __cpu_to_le32(cap->peer_curr_operclass);
8957	peer_cap->self_curr_operclass = __cpu_to_le32(cap->self_curr_operclass);
8958	peer_cap->peer_chan_len = __cpu_to_le32(cap->peer_chan_len);
8959	peer_cap->peer_operclass_len = __cpu_to_le32(cap->peer_operclass_len);
8960
8961	for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++)
8962		peer_cap->peer_operclass[i] = cap->peer_operclass[i];
8963
8964	peer_cap->is_peer_responder = __cpu_to_le32(cap->is_peer_responder);
8965	peer_cap->pref_offchan_num = __cpu_to_le32(cap->pref_offchan_num);
8966	peer_cap->pref_offchan_bw = __cpu_to_le32(cap->pref_offchan_bw);
8967
8968	for (i = 0; i < cap->peer_chan_len; i++) {
8969		chan = (struct wmi_channel *)&peer_cap->peer_chan_list[i];
8970		ath10k_wmi_put_wmi_channel(ar, chan, &chan_arg[i]);
8971	}
8972
8973	ath10k_dbg(ar, ATH10K_DBG_WMI,
8974		   "wmi tdls peer update vdev %i state %d n_chans %u\n",
8975		   arg->vdev_id, arg->peer_state, cap->peer_chan_len);
8976	return skb;
8977}
8978
8979static struct sk_buff *
8980ath10k_wmi_10_4_gen_radar_found(struct ath10k *ar,
8981				const struct ath10k_radar_found_info *arg)
8982{
8983	struct wmi_radar_found_info *cmd;
8984	struct sk_buff *skb;
8985
8986	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
8987	if (!skb)
8988		return ERR_PTR(-ENOMEM);
8989
8990	cmd = (struct wmi_radar_found_info *)skb->data;
8991	cmd->pri_min   = __cpu_to_le32(arg->pri_min);
8992	cmd->pri_max   = __cpu_to_le32(arg->pri_max);
8993	cmd->width_min = __cpu_to_le32(arg->width_min);
8994	cmd->width_max = __cpu_to_le32(arg->width_max);
8995	cmd->sidx_min  = __cpu_to_le32(arg->sidx_min);
8996	cmd->sidx_max  = __cpu_to_le32(arg->sidx_max);
8997
8998	ath10k_dbg(ar, ATH10K_DBG_WMI,
8999		   "wmi radar found pri_min %d pri_max %d width_min %d width_max %d sidx_min %d sidx_max %d\n",
9000		   arg->pri_min, arg->pri_max, arg->width_min,
9001		   arg->width_max, arg->sidx_min, arg->sidx_max);
9002	return skb;
9003}
9004
9005static struct sk_buff *
9006ath10k_wmi_10_4_gen_per_peer_per_tid_cfg(struct ath10k *ar,
9007					 const struct wmi_per_peer_per_tid_cfg_arg *arg)
9008{
9009	struct wmi_peer_per_tid_cfg_cmd *cmd;
9010	struct sk_buff *skb;
9011
9012	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
9013	if (!skb)
9014		return ERR_PTR(-ENOMEM);
9015
9016	memset(skb->data, 0, sizeof(*cmd));
9017
9018	cmd = (struct wmi_peer_per_tid_cfg_cmd *)skb->data;
9019	cmd->vdev_id = cpu_to_le32(arg->vdev_id);
9020	ether_addr_copy(cmd->peer_macaddr.addr, arg->peer_macaddr.addr);
9021	cmd->tid = cpu_to_le32(arg->tid);
9022	cmd->ack_policy = cpu_to_le32(arg->ack_policy);
9023	cmd->aggr_control = cpu_to_le32(arg->aggr_control);
9024	cmd->rate_control = cpu_to_le32(arg->rate_ctrl);
9025	cmd->retry_count = cpu_to_le32(arg->retry_count);
9026	cmd->rcode_flags = cpu_to_le32(arg->rcode_flags);
9027	cmd->ext_tid_cfg_bitmap = cpu_to_le32(arg->ext_tid_cfg_bitmap);
9028	cmd->rtscts_ctrl = cpu_to_le32(arg->rtscts_ctrl);
9029
9030	ath10k_dbg(ar, ATH10K_DBG_WMI,
9031		   "wmi noack tid %d vdev id %d ack_policy %d aggr %u rate_ctrl %u rcflag %u retry_count %d rtscts %d ext_tid_cfg_bitmap %d mac_addr %pM\n",
9032		   arg->tid, arg->vdev_id, arg->ack_policy, arg->aggr_control,
9033		   arg->rate_ctrl, arg->rcode_flags, arg->retry_count,
9034		   arg->rtscts_ctrl, arg->ext_tid_cfg_bitmap, arg->peer_macaddr.addr);
9035	return skb;
9036}
9037
9038static struct sk_buff *
9039ath10k_wmi_op_gen_echo(struct ath10k *ar, u32 value)
9040{
9041	struct wmi_echo_cmd *cmd;
9042	struct sk_buff *skb;
9043
9044	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
9045	if (!skb)
9046		return ERR_PTR(-ENOMEM);
9047
9048	cmd = (struct wmi_echo_cmd *)skb->data;
9049	cmd->value = cpu_to_le32(value);
9050
9051	ath10k_dbg(ar, ATH10K_DBG_WMI,
9052		   "wmi echo value 0x%08x\n", value);
9053	return skb;
9054}
9055
9056int
9057ath10k_wmi_barrier(struct ath10k *ar)
9058{
9059	int ret;
9060	int time_left;
9061
9062	spin_lock_bh(&ar->data_lock);
9063	reinit_completion(&ar->wmi.barrier);
9064	spin_unlock_bh(&ar->data_lock);
9065
9066	ret = ath10k_wmi_echo(ar, ATH10K_WMI_BARRIER_ECHO_ID);
9067	if (ret) {
9068		ath10k_warn(ar, "failed to submit wmi echo: %d\n", ret);
9069		return ret;
9070	}
9071
9072	time_left = wait_for_completion_timeout(&ar->wmi.barrier,
9073						ATH10K_WMI_BARRIER_TIMEOUT_HZ);
9074	if (!time_left)
9075		return -ETIMEDOUT;
9076
9077	return 0;
9078}
9079
9080static struct sk_buff *
9081ath10k_wmi_10_2_4_op_gen_bb_timing(struct ath10k *ar,
9082				   const struct wmi_bb_timing_cfg_arg *arg)
9083{
9084	struct wmi_pdev_bb_timing_cfg_cmd *cmd;
9085	struct sk_buff *skb;
9086
9087	skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
9088	if (!skb)
9089		return ERR_PTR(-ENOMEM);
9090
9091	cmd = (struct wmi_pdev_bb_timing_cfg_cmd *)skb->data;
9092	cmd->bb_tx_timing = __cpu_to_le32(arg->bb_tx_timing);
9093	cmd->bb_xpa_timing = __cpu_to_le32(arg->bb_xpa_timing);
9094
9095	ath10k_dbg(ar, ATH10K_DBG_WMI,
9096		   "wmi pdev bb_tx_timing 0x%x bb_xpa_timing 0x%x\n",
9097		   arg->bb_tx_timing, arg->bb_xpa_timing);
9098	return skb;
9099}
9100
9101static const struct wmi_ops wmi_ops = {
9102	.rx = ath10k_wmi_op_rx,
9103	.map_svc = wmi_main_svc_map,
9104
9105	.pull_scan = ath10k_wmi_op_pull_scan_ev,
9106	.pull_mgmt_rx = ath10k_wmi_op_pull_mgmt_rx_ev,
9107	.pull_ch_info = ath10k_wmi_op_pull_ch_info_ev,
9108	.pull_vdev_start = ath10k_wmi_op_pull_vdev_start_ev,
9109	.pull_peer_kick = ath10k_wmi_op_pull_peer_kick_ev,
9110	.pull_swba = ath10k_wmi_op_pull_swba_ev,
9111	.pull_phyerr_hdr = ath10k_wmi_op_pull_phyerr_ev_hdr,
9112	.pull_phyerr = ath10k_wmi_op_pull_phyerr_ev,
9113	.pull_svc_rdy = ath10k_wmi_main_op_pull_svc_rdy_ev,
9114	.pull_rdy = ath10k_wmi_op_pull_rdy_ev,
9115	.pull_fw_stats = ath10k_wmi_main_op_pull_fw_stats,
9116	.pull_roam_ev = ath10k_wmi_op_pull_roam_ev,
9117	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,
9118
9119	.gen_pdev_suspend = ath10k_wmi_op_gen_pdev_suspend,
9120	.gen_pdev_resume = ath10k_wmi_op_gen_pdev_resume,
9121	.gen_pdev_set_rd = ath10k_wmi_op_gen_pdev_set_rd,
9122	.gen_pdev_set_param = ath10k_wmi_op_gen_pdev_set_param,
9123	.gen_init = ath10k_wmi_op_gen_init,
9124	.gen_start_scan = ath10k_wmi_op_gen_start_scan,
9125	.gen_stop_scan = ath10k_wmi_op_gen_stop_scan,
9126	.gen_vdev_create = ath10k_wmi_op_gen_vdev_create,
9127	.gen_vdev_delete = ath10k_wmi_op_gen_vdev_delete,
9128	.gen_vdev_start = ath10k_wmi_op_gen_vdev_start,
9129	.gen_vdev_stop = ath10k_wmi_op_gen_vdev_stop,
9130	.gen_vdev_up = ath10k_wmi_op_gen_vdev_up,
9131	.gen_vdev_down = ath10k_wmi_op_gen_vdev_down,
9132	.gen_vdev_set_param = ath10k_wmi_op_gen_vdev_set_param,
9133	.gen_vdev_install_key = ath10k_wmi_op_gen_vdev_install_key,
9134	.gen_vdev_spectral_conf = ath10k_wmi_op_gen_vdev_spectral_conf,
9135	.gen_vdev_spectral_enable = ath10k_wmi_op_gen_vdev_spectral_enable,
9136	/* .gen_vdev_wmm_conf not implemented */
9137	.gen_peer_create = ath10k_wmi_op_gen_peer_create,
9138	.gen_peer_delete = ath10k_wmi_op_gen_peer_delete,
9139	.gen_peer_flush = ath10k_wmi_op_gen_peer_flush,
9140	.gen_peer_set_param = ath10k_wmi_op_gen_peer_set_param,
9141	.gen_peer_assoc = ath10k_wmi_op_gen_peer_assoc,
9142	.gen_set_psmode = ath10k_wmi_op_gen_set_psmode,
9143	.gen_set_sta_ps = ath10k_wmi_op_gen_set_sta_ps,
9144	.gen_set_ap_ps = ath10k_wmi_op_gen_set_ap_ps,
9145	.gen_scan_chan_list = ath10k_wmi_op_gen_scan_chan_list,
9146	.gen_beacon_dma = ath10k_wmi_op_gen_beacon_dma,
9147	.gen_pdev_set_wmm = ath10k_wmi_op_gen_pdev_set_wmm,
9148	.gen_request_stats = ath10k_wmi_op_gen_request_stats,
9149	.gen_force_fw_hang = ath10k_wmi_op_gen_force_fw_hang,
9150	.gen_mgmt_tx = ath10k_wmi_op_gen_mgmt_tx,
9151	.gen_dbglog_cfg = ath10k_wmi_op_gen_dbglog_cfg,
9152	.gen_pktlog_enable = ath10k_wmi_op_gen_pktlog_enable,
9153	.gen_pktlog_disable = ath10k_wmi_op_gen_pktlog_disable,
9154	.gen_pdev_set_quiet_mode = ath10k_wmi_op_gen_pdev_set_quiet_mode,
9155	/* .gen_pdev_get_temperature not implemented */
9156	.gen_addba_clear_resp = ath10k_wmi_op_gen_addba_clear_resp,
9157	.gen_addba_send = ath10k_wmi_op_gen_addba_send,
9158	.gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
9159	.gen_delba_send = ath10k_wmi_op_gen_delba_send,
9160	.fw_stats_fill = ath10k_wmi_main_op_fw_stats_fill,
9161	.get_vdev_subtype = ath10k_wmi_op_get_vdev_subtype,
9162	.gen_echo = ath10k_wmi_op_gen_echo,
9163	/* .gen_bcn_tmpl not implemented */
9164	/* .gen_prb_tmpl not implemented */
9165	/* .gen_p2p_go_bcn_ie not implemented */
9166	/* .gen_adaptive_qcs not implemented */
9167	/* .gen_pdev_enable_adaptive_cca not implemented */
9168};
9169
9170static const struct wmi_ops wmi_10_1_ops = {
9171	.rx = ath10k_wmi_10_1_op_rx,
9172	.map_svc = wmi_10x_svc_map,
9173	.pull_svc_rdy = ath10k_wmi_10x_op_pull_svc_rdy_ev,
9174	.pull_fw_stats = ath10k_wmi_10x_op_pull_fw_stats,
9175	.gen_init = ath10k_wmi_10_1_op_gen_init,
9176	.gen_pdev_set_rd = ath10k_wmi_10x_op_gen_pdev_set_rd,
9177	.gen_start_scan = ath10k_wmi_10x_op_gen_start_scan,
9178	.gen_peer_assoc = ath10k_wmi_10_1_op_gen_peer_assoc,
9179	/* .gen_pdev_get_temperature not implemented */
9180
9181	/* shared with main branch */
9182	.pull_scan = ath10k_wmi_op_pull_scan_ev,
9183	.pull_mgmt_rx = ath10k_wmi_op_pull_mgmt_rx_ev,
9184	.pull_ch_info = ath10k_wmi_op_pull_ch_info_ev,
9185	.pull_vdev_start = ath10k_wmi_op_pull_vdev_start_ev,
9186	.pull_peer_kick = ath10k_wmi_op_pull_peer_kick_ev,
9187	.pull_swba = ath10k_wmi_op_pull_swba_ev,
9188	.pull_phyerr_hdr = ath10k_wmi_op_pull_phyerr_ev_hdr,
9189	.pull_phyerr = ath10k_wmi_op_pull_phyerr_ev,
9190	.pull_rdy = ath10k_wmi_op_pull_rdy_ev,
9191	.pull_roam_ev = ath10k_wmi_op_pull_roam_ev,
9192	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,
9193
9194	.gen_pdev_suspend = ath10k_wmi_op_gen_pdev_suspend,
9195	.gen_pdev_resume = ath10k_wmi_op_gen_pdev_resume,
9196	.gen_pdev_set_param = ath10k_wmi_op_gen_pdev_set_param,
9197	.gen_stop_scan = ath10k_wmi_op_gen_stop_scan,
9198	.gen_vdev_create = ath10k_wmi_op_gen_vdev_create,
9199	.gen_vdev_delete = ath10k_wmi_op_gen_vdev_delete,
9200	.gen_vdev_start = ath10k_wmi_op_gen_vdev_start,
9201	.gen_vdev_stop = ath10k_wmi_op_gen_vdev_stop,
9202	.gen_vdev_up = ath10k_wmi_op_gen_vdev_up,
9203	.gen_vdev_down = ath10k_wmi_op_gen_vdev_down,
9204	.gen_vdev_set_param = ath10k_wmi_op_gen_vdev_set_param,
9205	.gen_vdev_install_key = ath10k_wmi_op_gen_vdev_install_key,
9206	.gen_vdev_spectral_conf = ath10k_wmi_op_gen_vdev_spectral_conf,
9207	.gen_vdev_spectral_enable = ath10k_wmi_op_gen_vdev_spectral_enable,
9208	/* .gen_vdev_wmm_conf not implemented */
9209	.gen_peer_create = ath10k_wmi_op_gen_peer_create,
9210	.gen_peer_delete = ath10k_wmi_op_gen_peer_delete,
9211	.gen_peer_flush = ath10k_wmi_op_gen_peer_flush,
9212	.gen_peer_set_param = ath10k_wmi_op_gen_peer_set_param,
9213	.gen_set_psmode = ath10k_wmi_op_gen_set_psmode,
9214	.gen_set_sta_ps = ath10k_wmi_op_gen_set_sta_ps,
9215	.gen_set_ap_ps = ath10k_wmi_op_gen_set_ap_ps,
9216	.gen_scan_chan_list = ath10k_wmi_op_gen_scan_chan_list,
9217	.gen_beacon_dma = ath10k_wmi_op_gen_beacon_dma,
9218	.gen_pdev_set_wmm = ath10k_wmi_op_gen_pdev_set_wmm,
9219	.gen_request_stats = ath10k_wmi_op_gen_request_stats,
9220	.gen_force_fw_hang = ath10k_wmi_op_gen_force_fw_hang,
9221	.gen_mgmt_tx = ath10k_wmi_op_gen_mgmt_tx,
9222	.gen_dbglog_cfg = ath10k_wmi_op_gen_dbglog_cfg,
9223	.gen_pktlog_enable = ath10k_wmi_op_gen_pktlog_enable,
9224	.gen_pktlog_disable = ath10k_wmi_op_gen_pktlog_disable,
9225	.gen_pdev_set_quiet_mode = ath10k_wmi_op_gen_pdev_set_quiet_mode,
9226	.gen_addba_clear_resp = ath10k_wmi_op_gen_addba_clear_resp,
9227	.gen_addba_send = ath10k_wmi_op_gen_addba_send,
9228	.gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
9229	.gen_delba_send = ath10k_wmi_op_gen_delba_send,
9230	.fw_stats_fill = ath10k_wmi_10x_op_fw_stats_fill,
9231	.get_vdev_subtype = ath10k_wmi_op_get_vdev_subtype,
9232	.gen_echo = ath10k_wmi_op_gen_echo,
9233	/* .gen_bcn_tmpl not implemented */
9234	/* .gen_prb_tmpl not implemented */
9235	/* .gen_p2p_go_bcn_ie not implemented */
9236	/* .gen_adaptive_qcs not implemented */
9237	/* .gen_pdev_enable_adaptive_cca not implemented */
9238};
9239
9240static const struct wmi_ops wmi_10_2_ops = {
9241	.rx = ath10k_wmi_10_2_op_rx,
9242	.pull_fw_stats = ath10k_wmi_10_2_op_pull_fw_stats,
9243	.gen_init = ath10k_wmi_10_2_op_gen_init,
9244	.gen_peer_assoc = ath10k_wmi_10_2_op_gen_peer_assoc,
9245	/* .gen_pdev_get_temperature not implemented */
9246
9247	/* shared with 10.1 */
9248	.map_svc = wmi_10x_svc_map,
9249	.pull_svc_rdy = ath10k_wmi_10x_op_pull_svc_rdy_ev,
9250	.gen_pdev_set_rd = ath10k_wmi_10x_op_gen_pdev_set_rd,
9251	.gen_start_scan = ath10k_wmi_10x_op_gen_start_scan,
9252	.gen_echo = ath10k_wmi_op_gen_echo,
9253
9254	.pull_scan = ath10k_wmi_op_pull_scan_ev,
9255	.pull_mgmt_rx = ath10k_wmi_op_pull_mgmt_rx_ev,
9256	.pull_ch_info = ath10k_wmi_op_pull_ch_info_ev,
9257	.pull_vdev_start = ath10k_wmi_op_pull_vdev_start_ev,
9258	.pull_peer_kick = ath10k_wmi_op_pull_peer_kick_ev,
9259	.pull_swba = ath10k_wmi_op_pull_swba_ev,
9260	.pull_phyerr_hdr = ath10k_wmi_op_pull_phyerr_ev_hdr,
9261	.pull_phyerr = ath10k_wmi_op_pull_phyerr_ev,
9262	.pull_rdy = ath10k_wmi_op_pull_rdy_ev,
9263	.pull_roam_ev = ath10k_wmi_op_pull_roam_ev,
9264	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,
9265
9266	.gen_pdev_suspend = ath10k_wmi_op_gen_pdev_suspend,
9267	.gen_pdev_resume = ath10k_wmi_op_gen_pdev_resume,
9268	.gen_pdev_set_param = ath10k_wmi_op_gen_pdev_set_param,
9269	.gen_stop_scan = ath10k_wmi_op_gen_stop_scan,
9270	.gen_vdev_create = ath10k_wmi_op_gen_vdev_create,
9271	.gen_vdev_delete = ath10k_wmi_op_gen_vdev_delete,
9272	.gen_vdev_start = ath10k_wmi_op_gen_vdev_start,
9273	.gen_vdev_stop = ath10k_wmi_op_gen_vdev_stop,
9274	.gen_vdev_up = ath10k_wmi_op_gen_vdev_up,
9275	.gen_vdev_down = ath10k_wmi_op_gen_vdev_down,
9276	.gen_vdev_set_param = ath10k_wmi_op_gen_vdev_set_param,
9277	.gen_vdev_install_key = ath10k_wmi_op_gen_vdev_install_key,
9278	.gen_vdev_spectral_conf = ath10k_wmi_op_gen_vdev_spectral_conf,
9279	.gen_vdev_spectral_enable = ath10k_wmi_op_gen_vdev_spectral_enable,
9280	/* .gen_vdev_wmm_conf not implemented */
9281	.gen_peer_create = ath10k_wmi_op_gen_peer_create,
9282	.gen_peer_delete = ath10k_wmi_op_gen_peer_delete,
9283	.gen_peer_flush = ath10k_wmi_op_gen_peer_flush,
9284	.gen_pdev_set_base_macaddr = ath10k_wmi_op_gen_pdev_set_base_macaddr,
9285	.gen_peer_set_param = ath10k_wmi_op_gen_peer_set_param,
9286	.gen_set_psmode = ath10k_wmi_op_gen_set_psmode,
9287	.gen_set_sta_ps = ath10k_wmi_op_gen_set_sta_ps,
9288	.gen_set_ap_ps = ath10k_wmi_op_gen_set_ap_ps,
9289	.gen_scan_chan_list = ath10k_wmi_op_gen_scan_chan_list,
9290	.gen_beacon_dma = ath10k_wmi_op_gen_beacon_dma,
9291	.gen_pdev_set_wmm = ath10k_wmi_op_gen_pdev_set_wmm,
9292	.gen_request_stats = ath10k_wmi_op_gen_request_stats,
9293	.gen_force_fw_hang = ath10k_wmi_op_gen_force_fw_hang,
9294	.gen_mgmt_tx = ath10k_wmi_op_gen_mgmt_tx,
9295	.gen_dbglog_cfg = ath10k_wmi_op_gen_dbglog_cfg,
9296	.gen_pktlog_enable = ath10k_wmi_op_gen_pktlog_enable,
9297	.gen_pktlog_disable = ath10k_wmi_op_gen_pktlog_disable,
9298	.gen_pdev_set_quiet_mode = ath10k_wmi_op_gen_pdev_set_quiet_mode,
9299	.gen_addba_clear_resp = ath10k_wmi_op_gen_addba_clear_resp,
9300	.gen_addba_send = ath10k_wmi_op_gen_addba_send,
9301	.gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
9302	.gen_delba_send = ath10k_wmi_op_gen_delba_send,
9303	.fw_stats_fill = ath10k_wmi_10x_op_fw_stats_fill,
9304	.get_vdev_subtype = ath10k_wmi_op_get_vdev_subtype,
9305	/* .gen_pdev_enable_adaptive_cca not implemented */
9306};
9307
9308static const struct wmi_ops wmi_10_2_4_ops = {
9309	.rx = ath10k_wmi_10_2_op_rx,
9310	.pull_fw_stats = ath10k_wmi_10_2_4_op_pull_fw_stats,
9311	.gen_init = ath10k_wmi_10_2_op_gen_init,
9312	.gen_peer_assoc = ath10k_wmi_10_2_op_gen_peer_assoc,
9313	.gen_pdev_get_temperature = ath10k_wmi_10_2_op_gen_pdev_get_temperature,
9314	.gen_pdev_bss_chan_info_req = ath10k_wmi_10_2_op_gen_pdev_bss_chan_info,
9315
9316	/* shared with 10.1 */
9317	.map_svc = wmi_10x_svc_map,
9318	.pull_svc_rdy = ath10k_wmi_10x_op_pull_svc_rdy_ev,
9319	.gen_pdev_set_rd = ath10k_wmi_10x_op_gen_pdev_set_rd,
9320	.gen_start_scan = ath10k_wmi_10x_op_gen_start_scan,
9321	.gen_echo = ath10k_wmi_op_gen_echo,
9322
9323	.pull_scan = ath10k_wmi_op_pull_scan_ev,
9324	.pull_mgmt_rx = ath10k_wmi_op_pull_mgmt_rx_ev,
9325	.pull_ch_info = ath10k_wmi_op_pull_ch_info_ev,
9326	.pull_vdev_start = ath10k_wmi_op_pull_vdev_start_ev,
9327	.pull_peer_kick = ath10k_wmi_op_pull_peer_kick_ev,
9328	.pull_swba = ath10k_wmi_10_2_4_op_pull_swba_ev,
9329	.pull_phyerr_hdr = ath10k_wmi_op_pull_phyerr_ev_hdr,
9330	.pull_phyerr = ath10k_wmi_op_pull_phyerr_ev,
9331	.pull_rdy = ath10k_wmi_op_pull_rdy_ev,
9332	.pull_roam_ev = ath10k_wmi_op_pull_roam_ev,
9333	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,
9334
9335	.gen_pdev_suspend = ath10k_wmi_op_gen_pdev_suspend,
9336	.gen_pdev_resume = ath10k_wmi_op_gen_pdev_resume,
9337	.gen_pdev_set_param = ath10k_wmi_op_gen_pdev_set_param,
9338	.gen_stop_scan = ath10k_wmi_op_gen_stop_scan,
9339	.gen_vdev_create = ath10k_wmi_op_gen_vdev_create,
9340	.gen_vdev_delete = ath10k_wmi_op_gen_vdev_delete,
9341	.gen_vdev_start = ath10k_wmi_op_gen_vdev_start,
9342	.gen_vdev_stop = ath10k_wmi_op_gen_vdev_stop,
9343	.gen_vdev_up = ath10k_wmi_op_gen_vdev_up,
9344	.gen_vdev_down = ath10k_wmi_op_gen_vdev_down,
9345	.gen_vdev_set_param = ath10k_wmi_op_gen_vdev_set_param,
9346	.gen_vdev_install_key = ath10k_wmi_op_gen_vdev_install_key,
9347	.gen_vdev_spectral_conf = ath10k_wmi_op_gen_vdev_spectral_conf,
9348	.gen_vdev_spectral_enable = ath10k_wmi_op_gen_vdev_spectral_enable,
9349	.gen_peer_create = ath10k_wmi_op_gen_peer_create,
9350	.gen_peer_delete = ath10k_wmi_op_gen_peer_delete,
9351	.gen_peer_flush = ath10k_wmi_op_gen_peer_flush,
9352	.gen_peer_set_param = ath10k_wmi_op_gen_peer_set_param,
9353	.gen_set_psmode = ath10k_wmi_op_gen_set_psmode,
9354	.gen_set_sta_ps = ath10k_wmi_op_gen_set_sta_ps,
9355	.gen_set_ap_ps = ath10k_wmi_op_gen_set_ap_ps,
9356	.gen_scan_chan_list = ath10k_wmi_op_gen_scan_chan_list,
9357	.gen_beacon_dma = ath10k_wmi_op_gen_beacon_dma,
9358	.gen_pdev_set_wmm = ath10k_wmi_op_gen_pdev_set_wmm,
9359	.gen_request_stats = ath10k_wmi_op_gen_request_stats,
9360	.gen_force_fw_hang = ath10k_wmi_op_gen_force_fw_hang,
9361	.gen_mgmt_tx = ath10k_wmi_op_gen_mgmt_tx,
9362	.gen_dbglog_cfg = ath10k_wmi_op_gen_dbglog_cfg,
9363	.gen_pktlog_enable = ath10k_wmi_op_gen_pktlog_enable,
9364	.gen_pktlog_disable = ath10k_wmi_op_gen_pktlog_disable,
9365	.gen_pdev_set_quiet_mode = ath10k_wmi_op_gen_pdev_set_quiet_mode,
9366	.gen_addba_clear_resp = ath10k_wmi_op_gen_addba_clear_resp,
9367	.gen_addba_send = ath10k_wmi_op_gen_addba_send,
9368	.gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
9369	.gen_delba_send = ath10k_wmi_op_gen_delba_send,
9370	.gen_pdev_get_tpc_config = ath10k_wmi_10_2_4_op_gen_pdev_get_tpc_config,
9371	.fw_stats_fill = ath10k_wmi_10x_op_fw_stats_fill,
9372	.gen_pdev_enable_adaptive_cca =
9373		ath10k_wmi_op_gen_pdev_enable_adaptive_cca,
9374	.get_vdev_subtype = ath10k_wmi_10_2_4_op_get_vdev_subtype,
9375	.gen_bb_timing = ath10k_wmi_10_2_4_op_gen_bb_timing,
9376	/* .gen_bcn_tmpl not implemented */
9377	/* .gen_prb_tmpl not implemented */
9378	/* .gen_p2p_go_bcn_ie not implemented */
9379	/* .gen_adaptive_qcs not implemented */
9380};
9381
9382static const struct wmi_ops wmi_10_4_ops = {
9383	.rx = ath10k_wmi_10_4_op_rx,
9384	.map_svc = wmi_10_4_svc_map,
9385
9386	.pull_fw_stats = ath10k_wmi_10_4_op_pull_fw_stats,
9387	.pull_scan = ath10k_wmi_op_pull_scan_ev,
9388	.pull_mgmt_rx = ath10k_wmi_10_4_op_pull_mgmt_rx_ev,
9389	.pull_ch_info = ath10k_wmi_10_4_op_pull_ch_info_ev,
9390	.pull_vdev_start = ath10k_wmi_op_pull_vdev_start_ev,
9391	.pull_peer_kick = ath10k_wmi_op_pull_peer_kick_ev,
9392	.pull_swba = ath10k_wmi_10_4_op_pull_swba_ev,
9393	.pull_phyerr_hdr = ath10k_wmi_10_4_op_pull_phyerr_ev_hdr,
9394	.pull_phyerr = ath10k_wmi_10_4_op_pull_phyerr_ev,
9395	.pull_svc_rdy = ath10k_wmi_main_op_pull_svc_rdy_ev,
9396	.pull_rdy = ath10k_wmi_op_pull_rdy_ev,
9397	.pull_roam_ev = ath10k_wmi_op_pull_roam_ev,
9398	.pull_dfs_status_ev = ath10k_wmi_10_4_op_pull_dfs_status_ev,
9399	.get_txbf_conf_scheme = ath10k_wmi_10_4_txbf_conf_scheme,
9400
9401	.gen_pdev_suspend = ath10k_wmi_op_gen_pdev_suspend,
9402	.gen_pdev_resume = ath10k_wmi_op_gen_pdev_resume,
9403	.gen_pdev_set_base_macaddr = ath10k_wmi_op_gen_pdev_set_base_macaddr,
9404	.gen_pdev_set_rd = ath10k_wmi_10x_op_gen_pdev_set_rd,
9405	.gen_pdev_set_param = ath10k_wmi_op_gen_pdev_set_param,
9406	.gen_init = ath10k_wmi_10_4_op_gen_init,
9407	.gen_start_scan = ath10k_wmi_op_gen_start_scan,
9408	.gen_stop_scan = ath10k_wmi_op_gen_stop_scan,
9409	.gen_vdev_create = ath10k_wmi_op_gen_vdev_create,
9410	.gen_vdev_delete = ath10k_wmi_op_gen_vdev_delete,
9411	.gen_vdev_start = ath10k_wmi_op_gen_vdev_start,
9412	.gen_vdev_stop = ath10k_wmi_op_gen_vdev_stop,
9413	.gen_vdev_up = ath10k_wmi_op_gen_vdev_up,
9414	.gen_vdev_down = ath10k_wmi_op_gen_vdev_down,
9415	.gen_vdev_set_param = ath10k_wmi_op_gen_vdev_set_param,
9416	.gen_vdev_install_key = ath10k_wmi_op_gen_vdev_install_key,
9417	.gen_vdev_spectral_conf = ath10k_wmi_op_gen_vdev_spectral_conf,
9418	.gen_vdev_spectral_enable = ath10k_wmi_op_gen_vdev_spectral_enable,
9419	.gen_peer_create = ath10k_wmi_op_gen_peer_create,
9420	.gen_peer_delete = ath10k_wmi_op_gen_peer_delete,
9421	.gen_peer_flush = ath10k_wmi_op_gen_peer_flush,
9422	.gen_peer_set_param = ath10k_wmi_op_gen_peer_set_param,
9423	.gen_peer_assoc = ath10k_wmi_10_4_op_gen_peer_assoc,
9424	.gen_set_psmode = ath10k_wmi_op_gen_set_psmode,
9425	.gen_set_sta_ps = ath10k_wmi_op_gen_set_sta_ps,
9426	.gen_set_ap_ps = ath10k_wmi_op_gen_set_ap_ps,
9427	.gen_scan_chan_list = ath10k_wmi_op_gen_scan_chan_list,
9428	.gen_beacon_dma = ath10k_wmi_op_gen_beacon_dma,
9429	.gen_pdev_set_wmm = ath10k_wmi_op_gen_pdev_set_wmm,
9430	.gen_force_fw_hang = ath10k_wmi_op_gen_force_fw_hang,
9431	.gen_mgmt_tx = ath10k_wmi_op_gen_mgmt_tx,
9432	.gen_dbglog_cfg = ath10k_wmi_10_4_op_gen_dbglog_cfg,
9433	.gen_pktlog_enable = ath10k_wmi_op_gen_pktlog_enable,
9434	.gen_pktlog_disable = ath10k_wmi_op_gen_pktlog_disable,
9435	.gen_pdev_set_quiet_mode = ath10k_wmi_op_gen_pdev_set_quiet_mode,
9436	.gen_addba_clear_resp = ath10k_wmi_op_gen_addba_clear_resp,
9437	.gen_addba_send = ath10k_wmi_op_gen_addba_send,
9438	.gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
9439	.gen_delba_send = ath10k_wmi_op_gen_delba_send,
9440	.fw_stats_fill = ath10k_wmi_10_4_op_fw_stats_fill,
9441	.ext_resource_config = ath10k_wmi_10_4_ext_resource_config,
9442	.gen_update_fw_tdls_state = ath10k_wmi_10_4_gen_update_fw_tdls_state,
9443	.gen_tdls_peer_update = ath10k_wmi_10_4_gen_tdls_peer_update,
9444	.gen_pdev_get_tpc_table_cmdid =
9445			ath10k_wmi_10_4_op_gen_pdev_get_tpc_table_cmdid,
9446	.gen_radar_found = ath10k_wmi_10_4_gen_radar_found,
9447	.gen_per_peer_per_tid_cfg = ath10k_wmi_10_4_gen_per_peer_per_tid_cfg,
9448
9449	/* shared with 10.2 */
9450	.pull_echo_ev = ath10k_wmi_op_pull_echo_ev,
9451	.gen_request_stats = ath10k_wmi_op_gen_request_stats,
9452	.gen_pdev_get_temperature = ath10k_wmi_10_2_op_gen_pdev_get_temperature,
9453	.get_vdev_subtype = ath10k_wmi_10_4_op_get_vdev_subtype,
9454	.gen_pdev_bss_chan_info_req = ath10k_wmi_10_2_op_gen_pdev_bss_chan_info,
9455	.gen_echo = ath10k_wmi_op_gen_echo,
9456	.gen_pdev_get_tpc_config = ath10k_wmi_10_2_4_op_gen_pdev_get_tpc_config,
9457};
9458
9459int ath10k_wmi_attach(struct ath10k *ar)
9460{
9461	switch (ar->running_fw->fw_file.wmi_op_version) {
9462	case ATH10K_FW_WMI_OP_VERSION_10_4:
9463		ar->wmi.ops = &wmi_10_4_ops;
9464		ar->wmi.cmd = &wmi_10_4_cmd_map;
9465		ar->wmi.vdev_param = &wmi_10_4_vdev_param_map;
9466		ar->wmi.pdev_param = &wmi_10_4_pdev_param_map;
9467		ar->wmi.peer_param = &wmi_peer_param_map;
9468		ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
9469		ar->wmi_key_cipher = wmi_key_cipher_suites;
9470		break;
9471	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
9472		ar->wmi.cmd = &wmi_10_2_4_cmd_map;
9473		ar->wmi.ops = &wmi_10_2_4_ops;
9474		ar->wmi.vdev_param = &wmi_10_2_4_vdev_param_map;
9475		ar->wmi.pdev_param = &wmi_10_2_4_pdev_param_map;
9476		ar->wmi.peer_param = &wmi_peer_param_map;
9477		ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
9478		ar->wmi_key_cipher = wmi_key_cipher_suites;
9479		break;
9480	case ATH10K_FW_WMI_OP_VERSION_10_2:
9481		ar->wmi.cmd = &wmi_10_2_cmd_map;
9482		ar->wmi.ops = &wmi_10_2_ops;
9483		ar->wmi.vdev_param = &wmi_10x_vdev_param_map;
9484		ar->wmi.pdev_param = &wmi_10x_pdev_param_map;
9485		ar->wmi.peer_param = &wmi_peer_param_map;
9486		ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
9487		ar->wmi_key_cipher = wmi_key_cipher_suites;
9488		break;
9489	case ATH10K_FW_WMI_OP_VERSION_10_1:
9490		ar->wmi.cmd = &wmi_10x_cmd_map;
9491		ar->wmi.ops = &wmi_10_1_ops;
9492		ar->wmi.vdev_param = &wmi_10x_vdev_param_map;
9493		ar->wmi.pdev_param = &wmi_10x_pdev_param_map;
9494		ar->wmi.peer_param = &wmi_peer_param_map;
9495		ar->wmi.peer_flags = &wmi_10x_peer_flags_map;
9496		ar->wmi_key_cipher = wmi_key_cipher_suites;
9497		break;
9498	case ATH10K_FW_WMI_OP_VERSION_MAIN:
9499		ar->wmi.cmd = &wmi_cmd_map;
9500		ar->wmi.ops = &wmi_ops;
9501		ar->wmi.vdev_param = &wmi_vdev_param_map;
9502		ar->wmi.pdev_param = &wmi_pdev_param_map;
9503		ar->wmi.peer_param = &wmi_peer_param_map;
9504		ar->wmi.peer_flags = &wmi_peer_flags_map;
9505		ar->wmi_key_cipher = wmi_key_cipher_suites;
9506		break;
9507	case ATH10K_FW_WMI_OP_VERSION_TLV:
9508		ath10k_wmi_tlv_attach(ar);
9509		ar->wmi_key_cipher = wmi_tlv_key_cipher_suites;
9510		break;
9511	case ATH10K_FW_WMI_OP_VERSION_UNSET:
9512	case ATH10K_FW_WMI_OP_VERSION_MAX:
9513		ath10k_err(ar, "unsupported WMI op version: %d\n",
9514			   ar->running_fw->fw_file.wmi_op_version);
9515		return -EINVAL;
9516	}
9517
9518	init_completion(&ar->wmi.service_ready);
9519	init_completion(&ar->wmi.unified_ready);
9520	init_completion(&ar->wmi.barrier);
9521	init_completion(&ar->wmi.radar_confirm);
9522
9523	INIT_WORK(&ar->svc_rdy_work, ath10k_wmi_event_service_ready_work);
9524	INIT_WORK(&ar->radar_confirmation_work,
9525		  ath10k_radar_confirmation_work);
9526
9527	if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF,
9528		     ar->running_fw->fw_file.fw_features)) {
9529		idr_init(&ar->wmi.mgmt_pending_tx);
9530	}
9531
9532	return 0;
9533}
9534
9535void ath10k_wmi_free_host_mem(struct ath10k *ar)
9536{
9537	int i;
9538
9539	/* free the host memory chunks requested by firmware */
9540	for (i = 0; i < ar->wmi.num_mem_chunks; i++) {
9541		dma_free_coherent(ar->dev,
9542				  ar->wmi.mem_chunks[i].len,
9543				  ar->wmi.mem_chunks[i].vaddr,
9544				  ar->wmi.mem_chunks[i].paddr);
9545	}
9546
9547	ar->wmi.num_mem_chunks = 0;
9548}
9549
9550static int ath10k_wmi_mgmt_tx_clean_up_pending(int msdu_id, void *ptr,
9551					       void *ctx)
9552{
9553	struct ath10k_mgmt_tx_pkt_addr *pkt_addr = ptr;
9554	struct ath10k *ar = ctx;
9555	struct sk_buff *msdu;
9556
9557	ath10k_dbg(ar, ATH10K_DBG_WMI,
9558		   "force cleanup mgmt msdu_id %u\n", msdu_id);
9559
9560	msdu = pkt_addr->vaddr;
9561	dma_unmap_single(ar->dev, pkt_addr->paddr,
9562			 msdu->len, DMA_TO_DEVICE);
9563	ieee80211_free_txskb(ar->hw, msdu);
9564
9565	return 0;
9566}
9567
9568void ath10k_wmi_detach(struct ath10k *ar)
9569{
9570	if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF,
9571		     ar->running_fw->fw_file.fw_features)) {
9572		spin_lock_bh(&ar->data_lock);
9573		idr_for_each(&ar->wmi.mgmt_pending_tx,
9574			     ath10k_wmi_mgmt_tx_clean_up_pending, ar);
9575		idr_destroy(&ar->wmi.mgmt_pending_tx);
9576		spin_unlock_bh(&ar->data_lock);
9577	}
9578
9579	cancel_work_sync(&ar->svc_rdy_work);
9580	dev_kfree_skb(ar->svc_rdy_skb);
9581}