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