1 /* 2 * Copyright (c) 2016-2020 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include "wmi_unified_api.h" 20 #include "wmi.h" 21 #include "wmi_version.h" 22 #include "wmi_unified_priv.h" 23 #include "wmi_version_whitelist.h" 24 #include <qdf_module.h> 25 #include <wlan_defs.h> 26 #include <wlan_cmn.h> 27 #include <htc_services.h> 28 #ifdef FEATURE_WLAN_APF 29 #include "wmi_unified_apf_tlv.h" 30 #endif 31 #ifdef WLAN_FEATURE_ACTION_OUI 32 #include "wmi_unified_action_oui_tlv.h" 33 #endif 34 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 35 #include "wlan_pmo_hw_filter_public_struct.h" 36 #endif 37 #include <wlan_utility.h> 38 #ifdef WLAN_SUPPORT_GREEN_AP 39 #include "wlan_green_ap_api.h" 40 #endif 41 42 #include "wmi_unified_twt_api.h" 43 44 #ifdef WLAN_POLICY_MGR_ENABLE 45 #include "wlan_policy_mgr_public_struct.h" 46 #endif 47 48 #ifdef WMI_SMART_ANT_SUPPORT 49 #include "wmi_unified_smart_ant_api.h" 50 #endif 51 52 #ifdef WMI_DBR_SUPPORT 53 #include "wmi_unified_dbr_api.h" 54 #endif 55 56 #ifdef WMI_ATF_SUPPORT 57 #include "wmi_unified_atf_api.h" 58 #endif 59 60 #ifdef WMI_AP_SUPPORT 61 #include "wmi_unified_ap_api.h" 62 #endif 63 64 #include <wmi_unified_vdev_api.h> 65 #include <wmi_unified_vdev_tlv.h> 66 67 /* HTC service ids for WMI for multi-radio */ 68 static const uint32_t multi_svc_ids[] = {WMI_CONTROL_SVC, 69 WMI_CONTROL_SVC_WMAC1, 70 WMI_CONTROL_SVC_WMAC2}; 71 72 #ifdef ENABLE_HOST_TO_TARGET_CONVERSION 73 /*Populate peer_param array whose index as host id and 74 *value as target id 75 */ 76 static const uint32_t peer_param_tlv[] = { 77 [WMI_HOST_PEER_MIMO_PS_STATE] = WMI_PEER_MIMO_PS_STATE, 78 [WMI_HOST_PEER_AMPDU] = WMI_PEER_AMPDU, 79 [WMI_HOST_PEER_AUTHORIZE] = WMI_PEER_AUTHORIZE, 80 [WMI_HOST_PEER_CHWIDTH] = WMI_PEER_CHWIDTH, 81 [WMI_HOST_PEER_NSS] = WMI_PEER_NSS, 82 [WMI_HOST_PEER_USE_4ADDR] = WMI_PEER_USE_4ADDR, 83 [WMI_HOST_PEER_MEMBERSHIP] = WMI_PEER_MEMBERSHIP, 84 [WMI_HOST_PEER_USERPOS] = WMI_PEER_USERPOS, 85 [WMI_HOST_PEER_CRIT_PROTO_HINT_ENABLED] = 86 WMI_PEER_CRIT_PROTO_HINT_ENABLED, 87 [WMI_HOST_PEER_TX_FAIL_CNT_THR] = WMI_PEER_TX_FAIL_CNT_THR, 88 [WMI_HOST_PEER_SET_HW_RETRY_CTS2S] = WMI_PEER_SET_HW_RETRY_CTS2S, 89 [WMI_HOST_PEER_IBSS_ATIM_WINDOW_LENGTH] = 90 WMI_PEER_IBSS_ATIM_WINDOW_LENGTH, 91 [WMI_HOST_PEER_PHYMODE] = WMI_PEER_PHYMODE, 92 [WMI_HOST_PEER_USE_FIXED_PWR] = WMI_PEER_USE_FIXED_PWR, 93 [WMI_HOST_PEER_PARAM_FIXED_RATE] = WMI_PEER_PARAM_FIXED_RATE, 94 [WMI_HOST_PEER_SET_MU_WHITELIST] = WMI_PEER_SET_MU_WHITELIST, 95 [WMI_HOST_PEER_SET_MAC_TX_RATE] = WMI_PEER_SET_MAX_TX_RATE, 96 [WMI_HOST_PEER_SET_MIN_TX_RATE] = WMI_PEER_SET_MIN_TX_RATE, 97 [WMI_HOST_PEER_SET_DEFAULT_ROUTING] = WMI_PEER_SET_DEFAULT_ROUTING, 98 [WMI_HOST_PEER_NSS_VHT160] = WMI_PEER_NSS_VHT160, 99 [WMI_HOST_PEER_NSS_VHT80_80] = WMI_PEER_NSS_VHT80_80, 100 [WMI_HOST_PEER_PARAM_SU_TXBF_SOUNDING_INTERVAL] = 101 WMI_PEER_PARAM_SU_TXBF_SOUNDING_INTERVAL, 102 [WMI_HOST_PEER_PARAM_MU_TXBF_SOUNDING_INTERVAL] = 103 WMI_PEER_PARAM_MU_TXBF_SOUNDING_INTERVAL, 104 [WMI_HOST_PEER_PARAM_TXBF_SOUNDING_ENABLE] = 105 WMI_PEER_PARAM_TXBF_SOUNDING_ENABLE, 106 [WMI_HOST_PEER_PARAM_MU_ENABLE] = WMI_PEER_PARAM_MU_ENABLE, 107 [WMI_HOST_PEER_PARAM_OFDMA_ENABLE] = WMI_PEER_PARAM_OFDMA_ENABLE, 108 [WMI_HOST_PEER_PARAM_ENABLE_FT] = WMI_PEER_PARAM_ENABLE_FT, 109 }; 110 111 /** 112 * Populate pdev_param_value whose index is host param and value is target 113 * param 114 */ 115 static const uint32_t pdev_param_tlv[] = { 116 [wmi_pdev_param_tx_chain_mask] = WMI_PDEV_PARAM_TX_CHAIN_MASK, 117 [wmi_pdev_param_rx_chain_mask] = WMI_PDEV_PARAM_RX_CHAIN_MASK, 118 [wmi_pdev_param_txpower_limit2g] = WMI_PDEV_PARAM_TXPOWER_LIMIT2G, 119 [wmi_pdev_param_txpower_limit5g] = WMI_PDEV_PARAM_TXPOWER_LIMIT5G, 120 [wmi_pdev_param_txpower_scale] = WMI_PDEV_PARAM_TXPOWER_SCALE, 121 [wmi_pdev_param_beacon_gen_mode] = WMI_PDEV_PARAM_BEACON_GEN_MODE, 122 [wmi_pdev_param_beacon_tx_mode] = WMI_PDEV_PARAM_BEACON_TX_MODE, 123 [wmi_pdev_param_resmgr_offchan_mode] = 124 WMI_PDEV_PARAM_RESMGR_OFFCHAN_MODE, 125 [wmi_pdev_param_protection_mode] = WMI_PDEV_PARAM_PROTECTION_MODE, 126 [wmi_pdev_param_dynamic_bw] = WMI_PDEV_PARAM_DYNAMIC_BW, 127 [wmi_pdev_param_non_agg_sw_retry_th] = 128 WMI_PDEV_PARAM_NON_AGG_SW_RETRY_TH, 129 [wmi_pdev_param_agg_sw_retry_th] = WMI_PDEV_PARAM_AGG_SW_RETRY_TH, 130 [wmi_pdev_param_sta_kickout_th] = WMI_PDEV_PARAM_STA_KICKOUT_TH, 131 [wmi_pdev_param_ac_aggrsize_scaling] = 132 WMI_PDEV_PARAM_AC_AGGRSIZE_SCALING, 133 [wmi_pdev_param_ltr_enable] = WMI_PDEV_PARAM_LTR_ENABLE, 134 [wmi_pdev_param_ltr_ac_latency_be] = 135 WMI_PDEV_PARAM_LTR_AC_LATENCY_BE, 136 [wmi_pdev_param_ltr_ac_latency_bk] = WMI_PDEV_PARAM_LTR_AC_LATENCY_BK, 137 [wmi_pdev_param_ltr_ac_latency_vi] = WMI_PDEV_PARAM_LTR_AC_LATENCY_VI, 138 [wmi_pdev_param_ltr_ac_latency_vo] = WMI_PDEV_PARAM_LTR_AC_LATENCY_VO, 139 [wmi_pdev_param_ltr_ac_latency_timeout] = 140 WMI_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT, 141 [wmi_pdev_param_ltr_sleep_override] = WMI_PDEV_PARAM_LTR_SLEEP_OVERRIDE, 142 [wmi_pdev_param_ltr_rx_override] = WMI_PDEV_PARAM_LTR_RX_OVERRIDE, 143 [wmi_pdev_param_ltr_tx_activity_timeout] = 144 WMI_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT, 145 [wmi_pdev_param_l1ss_enable] = WMI_PDEV_PARAM_L1SS_ENABLE, 146 [wmi_pdev_param_dsleep_enable] = WMI_PDEV_PARAM_DSLEEP_ENABLE, 147 [wmi_pdev_param_pcielp_txbuf_flush] = WMI_PDEV_PARAM_PCIELP_TXBUF_FLUSH, 148 [wmi_pdev_param_pcielp_txbuf_watermark] = 149 WMI_PDEV_PARAM_PCIELP_TXBUF_WATERMARK, 150 [wmi_pdev_param_pcielp_txbuf_tmo_en] = 151 WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_EN, 152 [wmi_pdev_param_pcielp_txbuf_tmo_value] = 153 WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_VALUE, 154 [wmi_pdev_param_pdev_stats_update_period] = 155 WMI_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD, 156 [wmi_pdev_param_vdev_stats_update_period] = 157 WMI_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD, 158 [wmi_pdev_param_peer_stats_update_period] = 159 WMI_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD, 160 [wmi_pdev_param_bcnflt_stats_update_period] = 161 WMI_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD, 162 [wmi_pdev_param_pmf_qos] = WMI_PDEV_PARAM_PMF_QOS, 163 [wmi_pdev_param_arp_ac_override] = WMI_PDEV_PARAM_ARP_AC_OVERRIDE, 164 [wmi_pdev_param_dcs] = WMI_PDEV_PARAM_DCS, 165 [wmi_pdev_param_ani_enable] = WMI_PDEV_PARAM_ANI_ENABLE, 166 [wmi_pdev_param_ani_poll_period] = WMI_PDEV_PARAM_ANI_POLL_PERIOD, 167 [wmi_pdev_param_ani_listen_period] = WMI_PDEV_PARAM_ANI_LISTEN_PERIOD, 168 [wmi_pdev_param_ani_ofdm_level] = WMI_PDEV_PARAM_ANI_OFDM_LEVEL, 169 [wmi_pdev_param_ani_cck_level] = WMI_PDEV_PARAM_ANI_CCK_LEVEL, 170 [wmi_pdev_param_dyntxchain] = WMI_PDEV_PARAM_DYNTXCHAIN, 171 [wmi_pdev_param_proxy_sta] = WMI_PDEV_PARAM_PROXY_STA, 172 [wmi_pdev_param_idle_ps_config] = WMI_PDEV_PARAM_IDLE_PS_CONFIG, 173 [wmi_pdev_param_power_gating_sleep] = WMI_PDEV_PARAM_POWER_GATING_SLEEP, 174 [wmi_pdev_param_rfkill_enable] = WMI_PDEV_PARAM_RFKILL_ENABLE, 175 [wmi_pdev_param_burst_dur] = WMI_PDEV_PARAM_BURST_DUR, 176 [wmi_pdev_param_burst_enable] = WMI_PDEV_PARAM_BURST_ENABLE, 177 [wmi_pdev_param_hw_rfkill_config] = WMI_PDEV_PARAM_HW_RFKILL_CONFIG, 178 [wmi_pdev_param_low_power_rf_enable] = 179 WMI_PDEV_PARAM_LOW_POWER_RF_ENABLE, 180 [wmi_pdev_param_l1ss_track] = WMI_PDEV_PARAM_L1SS_TRACK, 181 [wmi_pdev_param_hyst_en] = WMI_PDEV_PARAM_HYST_EN, 182 [wmi_pdev_param_power_collapse_enable] = 183 WMI_PDEV_PARAM_POWER_COLLAPSE_ENABLE, 184 [wmi_pdev_param_led_sys_state] = WMI_PDEV_PARAM_LED_SYS_STATE, 185 [wmi_pdev_param_led_enable] = WMI_PDEV_PARAM_LED_ENABLE, 186 [wmi_pdev_param_audio_over_wlan_latency] = 187 WMI_PDEV_PARAM_AUDIO_OVER_WLAN_LATENCY, 188 [wmi_pdev_param_audio_over_wlan_enable] = 189 WMI_PDEV_PARAM_AUDIO_OVER_WLAN_ENABLE, 190 [wmi_pdev_param_whal_mib_stats_update_enable] = 191 WMI_PDEV_PARAM_WHAL_MIB_STATS_UPDATE_ENABLE, 192 [wmi_pdev_param_vdev_rate_stats_update_period] = 193 WMI_PDEV_PARAM_VDEV_RATE_STATS_UPDATE_PERIOD, 194 [wmi_pdev_param_cts_cbw] = WMI_PDEV_PARAM_CTS_CBW, 195 [wmi_pdev_param_wnts_config] = WMI_PDEV_PARAM_WNTS_CONFIG, 196 [wmi_pdev_param_adaptive_early_rx_enable] = 197 WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_ENABLE, 198 [wmi_pdev_param_adaptive_early_rx_min_sleep_slop] = 199 WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_MIN_SLEEP_SLOP, 200 [wmi_pdev_param_adaptive_early_rx_inc_dec_step] = 201 WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_INC_DEC_STEP, 202 [wmi_pdev_param_early_rx_fix_sleep_slop] = 203 WMI_PDEV_PARAM_EARLY_RX_FIX_SLEEP_SLOP, 204 [wmi_pdev_param_bmiss_based_adaptive_bto_enable] = 205 WMI_PDEV_PARAM_BMISS_BASED_ADAPTIVE_BTO_ENABLE, 206 [wmi_pdev_param_bmiss_bto_min_bcn_timeout] = 207 WMI_PDEV_PARAM_BMISS_BTO_MIN_BCN_TIMEOUT, 208 [wmi_pdev_param_bmiss_bto_inc_dec_step] = 209 WMI_PDEV_PARAM_BMISS_BTO_INC_DEC_STEP, 210 [wmi_pdev_param_bto_fix_bcn_timeout] = 211 WMI_PDEV_PARAM_BTO_FIX_BCN_TIMEOUT, 212 [wmi_pdev_param_ce_based_adaptive_bto_enable] = 213 WMI_PDEV_PARAM_CE_BASED_ADAPTIVE_BTO_ENABLE, 214 [wmi_pdev_param_ce_bto_combo_ce_value] = 215 WMI_PDEV_PARAM_CE_BTO_COMBO_CE_VALUE, 216 [wmi_pdev_param_tx_chain_mask_2g] = WMI_PDEV_PARAM_TX_CHAIN_MASK_2G, 217 [wmi_pdev_param_rx_chain_mask_2g] = WMI_PDEV_PARAM_RX_CHAIN_MASK_2G, 218 [wmi_pdev_param_tx_chain_mask_5g] = WMI_PDEV_PARAM_TX_CHAIN_MASK_5G, 219 [wmi_pdev_param_rx_chain_mask_5g] = WMI_PDEV_PARAM_RX_CHAIN_MASK_5G, 220 [wmi_pdev_param_tx_chain_mask_cck] = WMI_PDEV_PARAM_TX_CHAIN_MASK_CCK, 221 [wmi_pdev_param_tx_chain_mask_1ss] = WMI_PDEV_PARAM_TX_CHAIN_MASK_1SS, 222 [wmi_pdev_param_rx_filter] = WMI_PDEV_PARAM_RX_FILTER, 223 [wmi_pdev_set_mcast_to_ucast_tid] = WMI_PDEV_SET_MCAST_TO_UCAST_TID, 224 [wmi_pdev_param_mgmt_retry_limit] = WMI_PDEV_PARAM_MGMT_RETRY_LIMIT, 225 [wmi_pdev_param_aggr_burst] = WMI_PDEV_PARAM_AGGR_BURST, 226 [wmi_pdev_peer_sta_ps_statechg_enable] = 227 WMI_PDEV_PEER_STA_PS_STATECHG_ENABLE, 228 [wmi_pdev_param_proxy_sta_mode] = WMI_PDEV_PARAM_PROXY_STA_MODE, 229 [wmi_pdev_param_mu_group_policy] = WMI_PDEV_PARAM_MU_GROUP_POLICY, 230 [wmi_pdev_param_noise_detection] = WMI_PDEV_PARAM_NOISE_DETECTION, 231 [wmi_pdev_param_noise_threshold] = WMI_PDEV_PARAM_NOISE_THRESHOLD, 232 [wmi_pdev_param_dpd_enable] = WMI_PDEV_PARAM_DPD_ENABLE, 233 [wmi_pdev_param_set_mcast_bcast_echo] = 234 WMI_PDEV_PARAM_SET_MCAST_BCAST_ECHO, 235 [wmi_pdev_param_atf_strict_sch] = WMI_PDEV_PARAM_ATF_STRICT_SCH, 236 [wmi_pdev_param_atf_sched_duration] = WMI_PDEV_PARAM_ATF_SCHED_DURATION, 237 [wmi_pdev_param_ant_plzn] = WMI_PDEV_PARAM_ANT_PLZN, 238 [wmi_pdev_param_sensitivity_level] = WMI_PDEV_PARAM_SENSITIVITY_LEVEL, 239 [wmi_pdev_param_signed_txpower_2g] = WMI_PDEV_PARAM_SIGNED_TXPOWER_2G, 240 [wmi_pdev_param_signed_txpower_5g] = WMI_PDEV_PARAM_SIGNED_TXPOWER_5G, 241 [wmi_pdev_param_enable_per_tid_amsdu] = 242 WMI_PDEV_PARAM_ENABLE_PER_TID_AMSDU, 243 [wmi_pdev_param_enable_per_tid_ampdu] = 244 WMI_PDEV_PARAM_ENABLE_PER_TID_AMPDU, 245 [wmi_pdev_param_cca_threshold] = WMI_PDEV_PARAM_CCA_THRESHOLD, 246 [wmi_pdev_param_rts_fixed_rate] = WMI_PDEV_PARAM_RTS_FIXED_RATE, 247 [wmi_pdev_param_cal_period] = WMI_UNAVAILABLE_PARAM, 248 [wmi_pdev_param_pdev_reset] = WMI_PDEV_PARAM_PDEV_RESET, 249 [wmi_pdev_param_wapi_mbssid_offset] = WMI_PDEV_PARAM_WAPI_MBSSID_OFFSET, 250 [wmi_pdev_param_arp_srcaddr] = WMI_PDEV_PARAM_ARP_DBG_SRCADDR, 251 [wmi_pdev_param_arp_dstaddr] = WMI_PDEV_PARAM_ARP_DBG_DSTADDR, 252 [wmi_pdev_param_txpower_decr_db] = WMI_PDEV_PARAM_TXPOWER_DECR_DB, 253 [wmi_pdev_param_rx_batchmode] = WMI_UNAVAILABLE_PARAM, 254 [wmi_pdev_param_packet_aggr_delay] = WMI_UNAVAILABLE_PARAM, 255 [wmi_pdev_param_atf_obss_noise_sch] = 256 WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCH, 257 [wmi_pdev_param_atf_obss_noise_scaling_factor] = 258 WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCALING_FACTOR, 259 [wmi_pdev_param_cust_txpower_scale] = WMI_PDEV_PARAM_CUST_TXPOWER_SCALE, 260 [wmi_pdev_param_atf_dynamic_enable] = WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE, 261 [wmi_pdev_param_atf_ssid_group_policy] = WMI_UNAVAILABLE_PARAM, 262 [wmi_pdev_param_igmpmld_override] = WMI_PDEV_PARAM_IGMPMLD_AC_OVERRIDE, 263 [wmi_pdev_param_igmpmld_tid] = WMI_PDEV_PARAM_IGMPMLD_AC_OVERRIDE, 264 [wmi_pdev_param_antenna_gain] = WMI_PDEV_PARAM_ANTENNA_GAIN, 265 [wmi_pdev_param_block_interbss] = WMI_PDEV_PARAM_BLOCK_INTERBSS, 266 [wmi_pdev_param_set_disable_reset_cmdid] = 267 WMI_PDEV_PARAM_SET_DISABLE_RESET_CMDID, 268 [wmi_pdev_param_set_msdu_ttl_cmdid] = WMI_PDEV_PARAM_SET_MSDU_TTL_CMDID, 269 [wmi_pdev_param_txbf_sound_period_cmdid] = 270 WMI_PDEV_PARAM_TXBF_SOUND_PERIOD_CMDID, 271 [wmi_pdev_param_set_burst_mode_cmdid] = 272 WMI_PDEV_PARAM_SET_BURST_MODE_CMDID, 273 [wmi_pdev_param_en_stats] = WMI_PDEV_PARAM_EN_STATS, 274 [wmi_pdev_param_mesh_mcast_enable] = WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 275 [wmi_pdev_param_set_promisc_mode_cmdid] = 276 WMI_PDEV_PARAM_SET_PROMISC_MODE_CMDID, 277 [wmi_pdev_param_set_ppdu_duration_cmdid] = 278 WMI_PDEV_PARAM_SET_PPDU_DURATION_CMDID, 279 [wmi_pdev_param_remove_mcast2ucast_buffer] = 280 WMI_PDEV_PARAM_REMOVE_MCAST2UCAST_BUFFER, 281 [wmi_pdev_param_set_mcast2ucast_buffer] = 282 WMI_PDEV_PARAM_SET_MCAST2UCAST_BUFFER, 283 [wmi_pdev_param_set_mcast2ucast_mode] = 284 WMI_PDEV_PARAM_SET_MCAST2UCAST_MODE, 285 [wmi_pdev_param_smart_antenna_default_antenna] = 286 WMI_PDEV_PARAM_SMART_ANTENNA_DEFAULT_ANTENNA, 287 [wmi_pdev_param_fast_channel_reset] = 288 WMI_PDEV_PARAM_FAST_CHANNEL_RESET, 289 [wmi_pdev_param_rx_decap_mode] = WMI_PDEV_PARAM_RX_DECAP_MODE, 290 [wmi_pdev_param_tx_ack_timeout] = WMI_PDEV_PARAM_ACK_TIMEOUT, 291 [wmi_pdev_param_cck_tx_enable] = WMI_PDEV_PARAM_CCK_TX_ENABLE, 292 [wmi_pdev_param_antenna_gain_half_db] = 293 WMI_PDEV_PARAM_ANTENNA_GAIN_HALF_DB, 294 [wmi_pdev_param_esp_indication_period] = 295 WMI_PDEV_PARAM_ESP_INDICATION_PERIOD, 296 [wmi_pdev_param_esp_ba_window] = WMI_PDEV_PARAM_ESP_BA_WINDOW, 297 [wmi_pdev_param_esp_airtime_fraction] = 298 WMI_PDEV_PARAM_ESP_AIRTIME_FRACTION, 299 [wmi_pdev_param_esp_ppdu_duration] = WMI_PDEV_PARAM_ESP_PPDU_DURATION, 300 [wmi_pdev_param_ru26_allowed] = WMI_PDEV_PARAM_UL_RU26_ALLOWED, 301 [wmi_pdev_param_use_nol] = WMI_PDEV_PARAM_USE_NOL, 302 /* Trigger interval for all trigger types. */ 303 [wmi_pdev_param_ul_trig_int] = WMI_PDEV_PARAM_SET_UL_BSR_TRIG_INTERVAL, 304 [wmi_pdev_param_sub_channel_marking] = 305 WMI_PDEV_PARAM_SUB_CHANNEL_MARKING, 306 [wmi_pdev_param_ul_ppdu_duration] = WMI_PDEV_PARAM_SET_UL_PPDU_DURATION, 307 [wmi_pdev_param_equal_ru_allocation_enable] = 308 WMI_PDEV_PARAM_EQUAL_RU_ALLOCATION_ENABLE, 309 [wmi_pdev_param_per_peer_prd_cfr_enable] = 310 WMI_PDEV_PARAM_PER_PEER_PERIODIC_CFR_ENABLE, 311 [wmi_pdev_param_nav_override_config] = 312 WMI_PDEV_PARAM_NAV_OVERRIDE_CONFIG, 313 [wmi_pdev_param_set_mgmt_ttl] = WMI_PDEV_PARAM_SET_MGMT_TTL, 314 [wmi_pdev_param_set_prb_rsp_ttl] = 315 WMI_PDEV_PARAM_SET_PROBE_RESP_TTL, 316 [wmi_pdev_param_set_mu_ppdu_duration] = 317 WMI_PDEV_PARAM_SET_MU_PPDU_DURATION, 318 [wmi_pdev_param_set_tbtt_ctrl] = 319 WMI_PDEV_PARAM_SET_TBTT_CTRL, 320 [wmi_pdev_param_set_cmd_obss_pd_threshold] = 321 WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD, 322 [wmi_pdev_param_set_cmd_obss_pd_per_ac] = 323 WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC, 324 [wmi_pdev_param_set_cong_ctrl_max_msdus] = 325 WMI_PDEV_PARAM_SET_CONG_CTRL_MAX_MSDUS, 326 [wmi_pdev_param_enable_fw_dynamic_he_edca] = 327 WMI_PDEV_PARAM_ENABLE_FW_DYNAMIC_HE_EDCA, 328 [wmi_pdev_param_enable_srp] = WMI_PDEV_PARAM_ENABLE_SRP, 329 [wmi_pdev_param_enable_sr_prohibit] = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT, 330 }; 331 332 /** 333 * Populate vdev_param_value_tlv array whose index is host param 334 * and value is target param 335 */ 336 static const uint32_t vdev_param_tlv[] = { 337 [wmi_vdev_param_rts_threshold] = WMI_VDEV_PARAM_RTS_THRESHOLD, 338 [wmi_vdev_param_fragmentation_threshold] = 339 WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD, 340 [wmi_vdev_param_beacon_interval] = WMI_VDEV_PARAM_BEACON_INTERVAL, 341 [wmi_vdev_param_listen_interval] = WMI_VDEV_PARAM_LISTEN_INTERVAL, 342 [wmi_vdev_param_multicast_rate] = WMI_VDEV_PARAM_MULTICAST_RATE, 343 [wmi_vdev_param_mgmt_tx_rate] = WMI_VDEV_PARAM_MGMT_TX_RATE, 344 [wmi_vdev_param_slot_time] = WMI_VDEV_PARAM_SLOT_TIME, 345 [wmi_vdev_param_preamble] = WMI_VDEV_PARAM_PREAMBLE, 346 [wmi_vdev_param_swba_time] = WMI_VDEV_PARAM_SWBA_TIME, 347 [wmi_vdev_stats_update_period] = WMI_VDEV_STATS_UPDATE_PERIOD, 348 [wmi_vdev_pwrsave_ageout_time] = WMI_VDEV_PWRSAVE_AGEOUT_TIME, 349 [wmi_vdev_host_swba_interval] = WMI_VDEV_HOST_SWBA_INTERVAL, 350 [wmi_vdev_param_dtim_period] = WMI_VDEV_PARAM_DTIM_PERIOD, 351 [wmi_vdev_oc_scheduler_air_time_limit] = 352 WMI_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT, 353 [wmi_vdev_param_wds] = WMI_VDEV_PARAM_WDS, 354 [wmi_vdev_param_atim_window] = WMI_VDEV_PARAM_ATIM_WINDOW, 355 [wmi_vdev_param_bmiss_count_max] = WMI_VDEV_PARAM_BMISS_COUNT_MAX, 356 [wmi_vdev_param_bmiss_first_bcnt] = WMI_VDEV_PARAM_BMISS_FIRST_BCNT, 357 [wmi_vdev_param_bmiss_final_bcnt] = WMI_VDEV_PARAM_BMISS_FINAL_BCNT, 358 [wmi_vdev_param_feature_wmm] = WMI_VDEV_PARAM_FEATURE_WMM, 359 [wmi_vdev_param_chwidth] = WMI_VDEV_PARAM_CHWIDTH, 360 [wmi_vdev_param_chextoffset] = WMI_VDEV_PARAM_CHEXTOFFSET, 361 [wmi_vdev_param_disable_htprotection] = 362 WMI_VDEV_PARAM_DISABLE_HTPROTECTION, 363 [wmi_vdev_param_sta_quickkickout] = WMI_VDEV_PARAM_STA_QUICKKICKOUT, 364 [wmi_vdev_param_mgmt_rate] = WMI_VDEV_PARAM_MGMT_RATE, 365 [wmi_vdev_param_protection_mode] = WMI_VDEV_PARAM_PROTECTION_MODE, 366 [wmi_vdev_param_fixed_rate] = WMI_VDEV_PARAM_FIXED_RATE, 367 [wmi_vdev_param_sgi] = WMI_VDEV_PARAM_SGI, 368 [wmi_vdev_param_ldpc] = WMI_VDEV_PARAM_LDPC, 369 [wmi_vdev_param_tx_stbc] = WMI_VDEV_PARAM_TX_STBC, 370 [wmi_vdev_param_rx_stbc] = WMI_VDEV_PARAM_RX_STBC, 371 [wmi_vdev_param_intra_bss_fwd] = WMI_VDEV_PARAM_INTRA_BSS_FWD, 372 [wmi_vdev_param_def_keyid] = WMI_VDEV_PARAM_DEF_KEYID, 373 [wmi_vdev_param_nss] = WMI_VDEV_PARAM_NSS, 374 [wmi_vdev_param_bcast_data_rate] = WMI_VDEV_PARAM_BCAST_DATA_RATE, 375 [wmi_vdev_param_mcast_data_rate] = WMI_VDEV_PARAM_MCAST_DATA_RATE, 376 [wmi_vdev_param_mcast_indicate] = WMI_VDEV_PARAM_MCAST_INDICATE, 377 [wmi_vdev_param_dhcp_indicate] = WMI_VDEV_PARAM_DHCP_INDICATE, 378 [wmi_vdev_param_unknown_dest_indicate] = 379 WMI_VDEV_PARAM_UNKNOWN_DEST_INDICATE, 380 [wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs] = 381 WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS, 382 [wmi_vdev_param_ap_keepalive_max_idle_inactive_time_secs] = 383 WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS, 384 [wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs] = 385 WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS, 386 [wmi_vdev_param_ap_enable_nawds] = WMI_VDEV_PARAM_AP_ENABLE_NAWDS, 387 [wmi_vdev_param_enable_rtscts] = WMI_VDEV_PARAM_ENABLE_RTSCTS, 388 [wmi_vdev_param_txbf] = WMI_VDEV_PARAM_TXBF, 389 [wmi_vdev_param_packet_powersave] = WMI_VDEV_PARAM_PACKET_POWERSAVE, 390 [wmi_vdev_param_drop_unencry] = WMI_VDEV_PARAM_DROP_UNENCRY, 391 [wmi_vdev_param_tx_encap_type] = WMI_VDEV_PARAM_TX_ENCAP_TYPE, 392 [wmi_vdev_param_ap_detect_out_of_sync_sleeping_sta_time_secs] = 393 WMI_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS, 394 [wmi_vdev_param_early_rx_adjust_enable] = 395 WMI_VDEV_PARAM_EARLY_RX_ADJUST_ENABLE, 396 [wmi_vdev_param_early_rx_tgt_bmiss_num] = 397 WMI_VDEV_PARAM_EARLY_RX_TGT_BMISS_NUM, 398 [wmi_vdev_param_early_rx_bmiss_sample_cycle] = 399 WMI_VDEV_PARAM_EARLY_RX_BMISS_SAMPLE_CYCLE, 400 [wmi_vdev_param_early_rx_slop_step] = WMI_VDEV_PARAM_EARLY_RX_SLOP_STEP, 401 [wmi_vdev_param_early_rx_init_slop] = WMI_VDEV_PARAM_EARLY_RX_INIT_SLOP, 402 [wmi_vdev_param_early_rx_adjust_pause] = 403 WMI_VDEV_PARAM_EARLY_RX_ADJUST_PAUSE, 404 [wmi_vdev_param_tx_pwrlimit] = WMI_VDEV_PARAM_TX_PWRLIMIT, 405 [wmi_vdev_param_snr_num_for_cal] = WMI_VDEV_PARAM_SNR_NUM_FOR_CAL, 406 [wmi_vdev_param_roam_fw_offload] = WMI_VDEV_PARAM_ROAM_FW_OFFLOAD, 407 [wmi_vdev_param_enable_rmc] = WMI_VDEV_PARAM_ENABLE_RMC, 408 [wmi_vdev_param_ibss_max_bcn_lost_ms] = 409 WMI_VDEV_PARAM_IBSS_MAX_BCN_LOST_MS, 410 [wmi_vdev_param_max_rate] = WMI_VDEV_PARAM_MAX_RATE, 411 [wmi_vdev_param_early_rx_drift_sample] = 412 WMI_VDEV_PARAM_EARLY_RX_DRIFT_SAMPLE, 413 [wmi_vdev_param_set_ibss_tx_fail_cnt_thr] = 414 WMI_VDEV_PARAM_SET_IBSS_TX_FAIL_CNT_THR, 415 [wmi_vdev_param_ebt_resync_timeout] = 416 WMI_VDEV_PARAM_EBT_RESYNC_TIMEOUT, 417 [wmi_vdev_param_aggr_trig_event_enable] = 418 WMI_VDEV_PARAM_AGGR_TRIG_EVENT_ENABLE, 419 [wmi_vdev_param_is_ibss_power_save_allowed] = 420 WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED, 421 [wmi_vdev_param_is_power_collapse_allowed] = 422 WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED, 423 [wmi_vdev_param_is_awake_on_txrx_enabled] = 424 WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED, 425 [wmi_vdev_param_inactivity_cnt] = WMI_VDEV_PARAM_INACTIVITY_CNT, 426 [wmi_vdev_param_txsp_end_inactivity_time_ms] = 427 WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS, 428 [wmi_vdev_param_dtim_policy] = WMI_VDEV_PARAM_DTIM_POLICY, 429 [wmi_vdev_param_ibss_ps_warmup_time_secs] = 430 WMI_VDEV_PARAM_IBSS_PS_WARMUP_TIME_SECS, 431 [wmi_vdev_param_ibss_ps_1rx_chain_in_atim_window_enable] = 432 WMI_VDEV_PARAM_IBSS_PS_1RX_CHAIN_IN_ATIM_WINDOW_ENABLE, 433 [wmi_vdev_param_rx_leak_window] = WMI_VDEV_PARAM_RX_LEAK_WINDOW, 434 [wmi_vdev_param_stats_avg_factor] = 435 WMI_VDEV_PARAM_STATS_AVG_FACTOR, 436 [wmi_vdev_param_disconnect_th] = WMI_VDEV_PARAM_DISCONNECT_TH, 437 [wmi_vdev_param_rtscts_rate] = WMI_VDEV_PARAM_RTSCTS_RATE, 438 [wmi_vdev_param_mcc_rtscts_protection_enable] = 439 WMI_VDEV_PARAM_MCC_RTSCTS_PROTECTION_ENABLE, 440 [wmi_vdev_param_mcc_broadcast_probe_enable] = 441 WMI_VDEV_PARAM_MCC_BROADCAST_PROBE_ENABLE, 442 [wmi_vdev_param_mgmt_tx_power] = WMI_VDEV_PARAM_MGMT_TX_POWER, 443 [wmi_vdev_param_beacon_rate] = WMI_VDEV_PARAM_BEACON_RATE, 444 [wmi_vdev_param_rx_decap_type] = WMI_VDEV_PARAM_RX_DECAP_TYPE, 445 [wmi_vdev_param_he_dcm_enable] = WMI_VDEV_PARAM_HE_DCM, 446 [wmi_vdev_param_he_range_ext_enable] = WMI_VDEV_PARAM_HE_RANGE_EXT, 447 [wmi_vdev_param_he_bss_color] = WMI_VDEV_PARAM_BSS_COLOR, 448 [wmi_vdev_param_set_hemu_mode] = WMI_VDEV_PARAM_SET_HEMU_MODE, 449 [wmi_vdev_param_set_he_sounding_mode] = 450 WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE, 451 [wmi_vdev_param_set_heop] = WMI_VDEV_PARAM_HEOPS_0_31, 452 [wmi_vdev_param_sensor_ap] = WMI_VDEV_PARAM_SENSOR_AP, 453 [wmi_vdev_param_dtim_enable_cts] = WMI_VDEV_PARAM_DTIM_ENABLE_CTS, 454 [wmi_vdev_param_atf_ssid_sched_policy] = 455 WMI_VDEV_PARAM_ATF_SSID_SCHED_POLICY, 456 [wmi_vdev_param_disable_dyn_bw_rts] = WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS, 457 [wmi_vdev_param_mcast2ucast_set] = WMI_VDEV_PARAM_MCAST2UCAST_SET, 458 [wmi_vdev_param_rc_num_retries] = WMI_VDEV_PARAM_RC_NUM_RETRIES, 459 [wmi_vdev_param_cabq_maxdur] = WMI_VDEV_PARAM_CABQ_MAXDUR, 460 [wmi_vdev_param_mfptest_set] = WMI_VDEV_PARAM_MFPTEST_SET, 461 [wmi_vdev_param_rts_fixed_rate] = WMI_VDEV_PARAM_RTS_FIXED_RATE, 462 [wmi_vdev_param_vht_sgimask] = WMI_VDEV_PARAM_VHT_SGIMASK, 463 [wmi_vdev_param_vht80_ratemask] = WMI_VDEV_PARAM_VHT80_RATEMASK, 464 [wmi_vdev_param_proxy_sta] = WMI_VDEV_PARAM_PROXY_STA, 465 [wmi_vdev_param_bw_nss_ratemask] = WMI_VDEV_PARAM_BW_NSS_RATEMASK, 466 [wmi_vdev_param_set_he_ltf] = WMI_VDEV_PARAM_HE_LTF, 467 [wmi_vdev_param_disable_cabq] = WMI_VDEV_PARAM_DISABLE_CABQ, 468 [wmi_vdev_param_rate_dropdown_bmap] = WMI_VDEV_PARAM_RATE_DROPDOWN_BMAP, 469 [wmi_vdev_param_set_ba_mode] = WMI_VDEV_PARAM_BA_MODE, 470 [wmi_vdev_param_capabilities] = WMI_VDEV_PARAM_CAPABILITIES, 471 [wmi_vdev_param_autorate_misc_cfg] = WMI_VDEV_PARAM_AUTORATE_MISC_CFG, 472 [wmi_vdev_param_ul_shortgi] = WMI_VDEV_PARAM_UL_GI, 473 [wmi_vdev_param_ul_he_ltf] = WMI_VDEV_PARAM_UL_HE_LTF, 474 [wmi_vdev_param_ul_nss] = WMI_VDEV_PARAM_UL_NSS, 475 [wmi_vdev_param_ul_ppdu_bw] = WMI_VDEV_PARAM_UL_PPDU_BW, 476 [wmi_vdev_param_ul_ldpc] = WMI_VDEV_PARAM_UL_LDPC, 477 [wmi_vdev_param_ul_stbc] = WMI_VDEV_PARAM_UL_STBC, 478 [wmi_vdev_param_ul_fixed_rate] = WMI_VDEV_PARAM_UL_FIXED_RATE, 479 [wmi_vdev_param_rawmode_open_war] = WMI_VDEV_PARAM_RAW_IS_ENCRYPTED, 480 [wmi_vdev_param_max_mtu_size] = WMI_VDEV_PARAM_MAX_MTU_SIZE, 481 [wmi_vdev_param_mcast_rc_stale_period] = 482 WMI_VDEV_PARAM_MCAST_RC_STALE_PERIOD, 483 [wmi_vdev_param_enable_multi_group_key] = 484 WMI_VDEV_PARAM_ENABLE_MULTI_GROUP_KEY, 485 [wmi_vdev_param_max_group_keys] = WMI_VDEV_PARAM_NUM_GROUP_KEYS, 486 [wmi_vdev_param_enable_mcast_rc] = WMI_VDEV_PARAM_ENABLE_MCAST_RC, 487 [wmi_vdev_param_6ghz_params] = WMI_VDEV_PARAM_6GHZ_PARAMS, 488 [wmi_vdev_param_enable_disable_roam_reason_vsie] = 489 WMI_VDEV_PARAM_ENABLE_DISABLE_ROAM_REASON_VSIE, 490 [wmi_vdev_param_set_cmd_obss_pd_threshold] = 491 WMI_VDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD, 492 [wmi_vdev_param_set_cmd_obss_pd_per_ac] = 493 WMI_VDEV_PARAM_SET_CMD_OBSS_PD_PER_AC, 494 [wmi_vdev_param_enable_srp] = WMI_VDEV_PARAM_ENABLE_SRP, 495 }; 496 #endif 497 498 /** 499 * Populate the pktlog event tlv array, where 500 * the values are the FW WMI events, which host 501 * uses to communicate with FW for pktlog 502 */ 503 504 static const uint32_t pktlog_event_tlv[] = { 505 [WMI_HOST_PKTLOG_EVENT_RX_BIT] = WMI_PKTLOG_EVENT_RX, 506 [WMI_HOST_PKTLOG_EVENT_TX_BIT] = WMI_PKTLOG_EVENT_TX, 507 [WMI_HOST_PKTLOG_EVENT_RCF_BIT] = WMI_PKTLOG_EVENT_RCF, 508 [WMI_HOST_PKTLOG_EVENT_RCU_BIT] = WMI_PKTLOG_EVENT_RCU, 509 [WMI_HOST_PKTLOG_EVENT_DBG_PRINT_BIT] = 0, 510 [WMI_HOST_PKTLOG_EVENT_SMART_ANTENNA_BIT] = 511 WMI_PKTLOG_EVENT_SMART_ANTENNA, 512 [WMI_HOST_PKTLOG_EVENT_H_INFO_BIT] = 0, 513 [WMI_HOST_PKTLOG_EVENT_STEERING_BIT] = 0, 514 [WMI_HOST_PKTLOG_EVENT_TX_DATA_CAPTURE_BIT] = 0, 515 [WMI_HOST_PKTLOG_EVENT_PHY_LOGGING_BIT] = WMI_PKTLOG_EVENT_PHY, 516 }; 517 518 /** 519 * convert_host_pdev_id_to_target_pdev_id() - Convert pdev_id from 520 * host to target defines. 521 * @wmi_handle: pointer to wmi_handle 522 * @param pdev_id: host pdev_id to be converted. 523 * Return: target pdev_id after conversion. 524 */ 525 static uint32_t convert_host_pdev_id_to_target_pdev_id(wmi_unified_t wmi_handle, 526 uint32_t pdev_id) 527 { 528 if (pdev_id <= WMI_HOST_PDEV_ID_2 && pdev_id >= WMI_HOST_PDEV_ID_0) { 529 if (!wmi_handle->soc->is_pdev_is_map_enable) { 530 switch (pdev_id) { 531 case WMI_HOST_PDEV_ID_0: 532 return WMI_PDEV_ID_1ST; 533 case WMI_HOST_PDEV_ID_1: 534 return WMI_PDEV_ID_2ND; 535 case WMI_HOST_PDEV_ID_2: 536 return WMI_PDEV_ID_3RD; 537 } 538 } else { 539 return wmi_handle->cmd_pdev_id_map[pdev_id]; 540 } 541 } else { 542 return WMI_PDEV_ID_SOC; 543 } 544 545 QDF_ASSERT(0); 546 547 return WMI_PDEV_ID_SOC; 548 } 549 550 /** 551 * convert_target_pdev_id_to_host_pdev_id() - Convert pdev_id from 552 * target to host defines. 553 * @wmi_handle: pointer to wmi_handle 554 * @param pdev_id: target pdev_id to be converted. 555 * Return: host pdev_id after conversion. 556 */ 557 static uint32_t convert_target_pdev_id_to_host_pdev_id(wmi_unified_t wmi_handle, 558 uint32_t pdev_id) 559 { 560 561 if (pdev_id <= WMI_PDEV_ID_3RD && pdev_id >= WMI_PDEV_ID_1ST) { 562 if (!wmi_handle->soc->is_pdev_is_map_enable) { 563 switch (pdev_id) { 564 case WMI_PDEV_ID_1ST: 565 return WMI_HOST_PDEV_ID_0; 566 case WMI_PDEV_ID_2ND: 567 return WMI_HOST_PDEV_ID_1; 568 case WMI_PDEV_ID_3RD: 569 return WMI_HOST_PDEV_ID_2; 570 } 571 } else { 572 return wmi_handle->evt_pdev_id_map[pdev_id - 1]; 573 } 574 } else if (pdev_id == WMI_PDEV_ID_SOC) { 575 return WMI_HOST_PDEV_ID_SOC; 576 } else { 577 WMI_LOGE("Invalid pdev_id"); 578 } 579 580 return WMI_HOST_PDEV_ID_INVALID; 581 } 582 583 /** 584 * convert_host_phy_id_to_target_phy_id() - Convert phy_id from 585 * host to target defines. 586 * @wmi_handle: pointer to wmi_handle 587 * @param phy_id: host pdev_id to be converted. 588 * Return: target phy_id after conversion. 589 */ 590 static uint32_t convert_host_phy_id_to_target_phy_id(wmi_unified_t wmi_handle, 591 uint32_t phy_id) 592 { 593 if (!wmi_handle->soc->is_phy_id_map_enable || 594 phy_id >= WMI_MAX_RADIOS) { 595 return phy_id; 596 } 597 598 return wmi_handle->cmd_phy_id_map[phy_id]; 599 } 600 601 /** 602 * convert_target_phy_id_to_host_phy_id() - Convert phy_id from 603 * target to host defines. 604 * @wmi_handle: pointer to wmi_handle 605 * @param phy_id: target phy_id to be converted. 606 * Return: host phy_id after conversion. 607 */ 608 static uint32_t convert_target_phy_id_to_host_phy_id(wmi_unified_t wmi_handle, 609 uint32_t phy_id) 610 { 611 if (!wmi_handle->soc->is_phy_id_map_enable || 612 phy_id >= WMI_MAX_RADIOS) { 613 return phy_id; 614 } 615 616 return wmi_handle->evt_phy_id_map[phy_id]; 617 } 618 619 /** 620 * wmi_tlv_pdev_id_conversion_enable() - Enable pdev_id conversion 621 * 622 * Return None. 623 */ 624 static void wmi_tlv_pdev_id_conversion_enable(wmi_unified_t wmi_handle, 625 uint32_t *pdev_id_map, 626 uint8_t size) 627 { 628 int i = 0; 629 630 if (pdev_id_map && (size <= WMI_MAX_RADIOS)) { 631 for (i = 0; i < size; i++) { 632 wmi_handle->cmd_pdev_id_map[i] = pdev_id_map[i]; 633 wmi_handle->evt_pdev_id_map[i] = 634 WMI_HOST_PDEV_ID_INVALID; 635 wmi_handle->cmd_phy_id_map[i] = pdev_id_map[i] - 1; 636 wmi_handle->evt_phy_id_map[i] = 637 WMI_HOST_PDEV_ID_INVALID; 638 } 639 640 for (i = 0; i < size; i++) { 641 if (wmi_handle->cmd_pdev_id_map[i] != 642 WMI_HOST_PDEV_ID_INVALID) { 643 wmi_handle->evt_pdev_id_map 644 [wmi_handle->cmd_pdev_id_map[i] - 1] = i; 645 } 646 if (wmi_handle->cmd_phy_id_map[i] != 647 WMI_HOST_PDEV_ID_INVALID) { 648 wmi_handle->evt_phy_id_map 649 [wmi_handle->cmd_phy_id_map[i]] = i; 650 } 651 } 652 wmi_handle->soc->is_pdev_is_map_enable = true; 653 wmi_handle->soc->is_phy_id_map_enable = true; 654 } else { 655 wmi_handle->soc->is_pdev_is_map_enable = false; 656 wmi_handle->soc->is_phy_id_map_enable = false; 657 } 658 659 wmi_handle->ops->convert_pdev_id_host_to_target = 660 convert_host_pdev_id_to_target_pdev_id; 661 wmi_handle->ops->convert_pdev_id_target_to_host = 662 convert_target_pdev_id_to_host_pdev_id; 663 664 /* phy_id convert function assignments */ 665 wmi_handle->ops->convert_phy_id_host_to_target = 666 convert_host_phy_id_to_target_phy_id; 667 wmi_handle->ops->convert_phy_id_target_to_host = 668 convert_target_phy_id_to_host_phy_id; 669 } 670 671 /* copy_vdev_create_pdev_id() - copy pdev from host params to target command 672 * buffer. 673 * @wmi_handle: pointer to wmi_handle 674 * @cmd: pointer target vdev create command buffer 675 * @param: pointer host params for vdev create 676 * 677 * Return: None 678 */ 679 static inline void copy_vdev_create_pdev_id( 680 struct wmi_unified *wmi_handle, 681 wmi_vdev_create_cmd_fixed_param * cmd, 682 struct vdev_create_params *param) 683 { 684 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 685 wmi_handle, 686 param->pdev_id); 687 } 688 689 void wmi_mtrace(uint32_t message_id, uint16_t vdev_id, uint32_t data) 690 { 691 uint16_t mtrace_message_id; 692 693 mtrace_message_id = QDF_WMI_MTRACE_CMD_ID(message_id) | 694 (QDF_WMI_MTRACE_GRP_ID(message_id) << 695 QDF_WMI_MTRACE_CMD_NUM_BITS); 696 qdf_mtrace(QDF_MODULE_ID_WMI, QDF_MODULE_ID_TARGET, 697 mtrace_message_id, vdev_id, data); 698 } 699 qdf_export_symbol(wmi_mtrace); 700 701 #ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI 702 static QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle, 703 wmi_buf_t buf, 704 uint32_t buflen, uint32_t cmd_id) 705 { 706 if (wmi_is_target_suspended(wmi_handle)) { 707 if (QDF_IS_STATUS_SUCCESS( 708 wmi_unified_cmd_send_over_qmi(wmi_handle, buf, 709 buflen, cmd_id))) 710 return QDF_STATUS_SUCCESS; 711 } 712 713 qdf_atomic_set(&wmi_handle->num_stats_over_qmi, 0); 714 715 return wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id); 716 } 717 #else 718 static inline 719 QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle, 720 wmi_buf_t buf, 721 uint32_t buflen, uint32_t cmd_id) 722 { 723 return wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id); 724 } 725 #endif 726 727 /** 728 * send_vdev_create_cmd_tlv() - send VDEV create command to fw 729 * @wmi_handle: wmi handle 730 * @param: pointer to hold vdev create parameter 731 * @macaddr: vdev mac address 732 * 733 * Return: QDF_STATUS_SUCCESS for success or error code 734 */ 735 static QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle, 736 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 737 struct vdev_create_params *param) 738 { 739 wmi_vdev_create_cmd_fixed_param *cmd; 740 wmi_buf_t buf; 741 int32_t len = sizeof(*cmd); 742 QDF_STATUS ret; 743 int num_bands = 2; 744 uint8_t *buf_ptr; 745 wmi_vdev_txrx_streams *txrx_streams; 746 747 len += (num_bands * sizeof(*txrx_streams) + WMI_TLV_HDR_SIZE); 748 buf = wmi_buf_alloc(wmi_handle, len); 749 if (!buf) 750 return QDF_STATUS_E_NOMEM; 751 752 cmd = (wmi_vdev_create_cmd_fixed_param *) wmi_buf_data(buf); 753 WMITLV_SET_HDR(&cmd->tlv_header, 754 WMITLV_TAG_STRUC_wmi_vdev_create_cmd_fixed_param, 755 WMITLV_GET_STRUCT_TLVLEN 756 (wmi_vdev_create_cmd_fixed_param)); 757 cmd->vdev_id = param->vdev_id; 758 cmd->vdev_type = param->type; 759 cmd->vdev_subtype = param->subtype; 760 cmd->flags = param->mbssid_flags; 761 cmd->vdevid_trans = param->vdevid_trans; 762 cmd->num_cfg_txrx_streams = num_bands; 763 copy_vdev_create_pdev_id(wmi_handle, cmd, param); 764 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr); 765 WMI_LOGD("%s: ID = %d[pdev:%d] VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x", 766 __func__, param->vdev_id, cmd->pdev_id, 767 macaddr[0], macaddr[1], macaddr[2], 768 macaddr[3], macaddr[4], macaddr[5]); 769 buf_ptr = (uint8_t *)cmd + sizeof(*cmd); 770 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 771 (num_bands * sizeof(wmi_vdev_txrx_streams))); 772 buf_ptr += WMI_TLV_HDR_SIZE; 773 774 WMI_LOGD("%s: type %d, subtype %d, nss_2g %d, nss_5g %d", __func__, 775 param->type, param->subtype, 776 param->nss_2g, param->nss_5g); 777 txrx_streams = (wmi_vdev_txrx_streams *)buf_ptr; 778 txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_2G; 779 txrx_streams->supported_tx_streams = param->nss_2g; 780 txrx_streams->supported_rx_streams = param->nss_2g; 781 WMITLV_SET_HDR(&txrx_streams->tlv_header, 782 WMITLV_TAG_STRUC_wmi_vdev_txrx_streams, 783 WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_txrx_streams)); 784 785 txrx_streams++; 786 txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_5G; 787 txrx_streams->supported_tx_streams = param->nss_5g; 788 txrx_streams->supported_rx_streams = param->nss_5g; 789 WMITLV_SET_HDR(&txrx_streams->tlv_header, 790 WMITLV_TAG_STRUC_wmi_vdev_txrx_streams, 791 WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_txrx_streams)); 792 wmi_mtrace(WMI_VDEV_CREATE_CMDID, cmd->vdev_id, 0); 793 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_CREATE_CMDID); 794 if (QDF_IS_STATUS_ERROR(ret)) { 795 WMI_LOGE("Failed to send WMI_VDEV_CREATE_CMDID"); 796 wmi_buf_free(buf); 797 } 798 799 return ret; 800 } 801 802 /** 803 * send_vdev_delete_cmd_tlv() - send VDEV delete command to fw 804 * @wmi_handle: wmi handle 805 * @if_id: vdev id 806 * 807 * Return: QDF_STATUS_SUCCESS for success or error code 808 */ 809 static QDF_STATUS send_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle, 810 uint8_t if_id) 811 { 812 wmi_vdev_delete_cmd_fixed_param *cmd; 813 wmi_buf_t buf; 814 QDF_STATUS ret; 815 816 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 817 if (!buf) 818 return QDF_STATUS_E_NOMEM; 819 820 cmd = (wmi_vdev_delete_cmd_fixed_param *) wmi_buf_data(buf); 821 WMITLV_SET_HDR(&cmd->tlv_header, 822 WMITLV_TAG_STRUC_wmi_vdev_delete_cmd_fixed_param, 823 WMITLV_GET_STRUCT_TLVLEN 824 (wmi_vdev_delete_cmd_fixed_param)); 825 cmd->vdev_id = if_id; 826 wmi_mtrace(WMI_VDEV_DELETE_CMDID, cmd->vdev_id, 0); 827 ret = wmi_unified_cmd_send(wmi_handle, buf, 828 sizeof(wmi_vdev_delete_cmd_fixed_param), 829 WMI_VDEV_DELETE_CMDID); 830 if (QDF_IS_STATUS_ERROR(ret)) { 831 WMI_LOGE("Failed to send WMI_VDEV_DELETE_CMDID"); 832 wmi_buf_free(buf); 833 } 834 WMI_LOGD("%s:vdev id = %d", __func__, if_id); 835 836 return ret; 837 } 838 839 /** 840 * send_vdev_nss_chain_params_cmd_tlv() - send VDEV nss chain params to fw 841 * @wmi_handle: wmi handle 842 * @vdev_id: vdev id 843 * @nss_chains_user_cfg: user configured nss chain params 844 * 845 * Return: QDF_STATUS_SUCCESS for success or error code 846 */ 847 static QDF_STATUS 848 send_vdev_nss_chain_params_cmd_tlv(wmi_unified_t wmi_handle, 849 uint8_t vdev_id, 850 struct vdev_nss_chains *user_cfg) 851 { 852 wmi_vdev_chainmask_config_cmd_fixed_param *cmd; 853 wmi_buf_t buf; 854 QDF_STATUS ret; 855 856 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 857 if (!buf) 858 return QDF_STATUS_E_NOMEM; 859 860 cmd = (wmi_vdev_chainmask_config_cmd_fixed_param *)wmi_buf_data(buf); 861 WMITLV_SET_HDR(&cmd->tlv_header, 862 WMITLV_TAG_STRUC_wmi_vdev_chainmask_config_cmd_fixed_param, 863 WMITLV_GET_STRUCT_TLVLEN 864 (wmi_vdev_chainmask_config_cmd_fixed_param)); 865 cmd->vdev_id = vdev_id; 866 cmd->disable_rx_mrc_2g = user_cfg->disable_rx_mrc[NSS_CHAINS_BAND_2GHZ]; 867 cmd->disable_tx_mrc_2g = user_cfg->disable_tx_mrc[NSS_CHAINS_BAND_2GHZ]; 868 cmd->disable_rx_mrc_5g = user_cfg->disable_rx_mrc[NSS_CHAINS_BAND_5GHZ]; 869 cmd->disable_tx_mrc_5g = user_cfg->disable_tx_mrc[NSS_CHAINS_BAND_5GHZ]; 870 cmd->num_rx_chains_2g = user_cfg->num_rx_chains[NSS_CHAINS_BAND_2GHZ]; 871 cmd->num_tx_chains_2g = user_cfg->num_tx_chains[NSS_CHAINS_BAND_2GHZ]; 872 cmd->num_rx_chains_5g = user_cfg->num_rx_chains[NSS_CHAINS_BAND_5GHZ]; 873 cmd->num_tx_chains_5g = user_cfg->num_tx_chains[NSS_CHAINS_BAND_5GHZ]; 874 cmd->rx_nss_2g = user_cfg->rx_nss[NSS_CHAINS_BAND_2GHZ]; 875 cmd->tx_nss_2g = user_cfg->tx_nss[NSS_CHAINS_BAND_2GHZ]; 876 cmd->rx_nss_5g = user_cfg->rx_nss[NSS_CHAINS_BAND_5GHZ]; 877 cmd->tx_nss_5g = user_cfg->tx_nss[NSS_CHAINS_BAND_5GHZ]; 878 cmd->num_tx_chains_a = user_cfg->num_tx_chains_11a; 879 cmd->num_tx_chains_b = user_cfg->num_tx_chains_11b; 880 cmd->num_tx_chains_g = user_cfg->num_tx_chains_11g; 881 882 wmi_mtrace(WMI_VDEV_CHAINMASK_CONFIG_CMDID, cmd->vdev_id, 0); 883 ret = wmi_unified_cmd_send(wmi_handle, buf, 884 sizeof(wmi_vdev_chainmask_config_cmd_fixed_param), 885 WMI_VDEV_CHAINMASK_CONFIG_CMDID); 886 if (QDF_IS_STATUS_ERROR(ret)) { 887 WMI_LOGE("Failed to send WMI_VDEV_CHAINMASK_CONFIG_CMDID"); 888 wmi_buf_free(buf); 889 } 890 WMI_LOGD("%s: vdev_id %d", __func__, vdev_id); 891 892 return ret; 893 } 894 895 /** 896 * send_vdev_stop_cmd_tlv() - send vdev stop command to fw 897 * @wmi: wmi handle 898 * @vdev_id: vdev id 899 * 900 * Return: QDF_STATUS_SUCCESS for success or erro code 901 */ 902 static QDF_STATUS send_vdev_stop_cmd_tlv(wmi_unified_t wmi, 903 uint8_t vdev_id) 904 { 905 wmi_vdev_stop_cmd_fixed_param *cmd; 906 wmi_buf_t buf; 907 int32_t len = sizeof(*cmd); 908 909 buf = wmi_buf_alloc(wmi, len); 910 if (!buf) 911 return QDF_STATUS_E_NOMEM; 912 913 cmd = (wmi_vdev_stop_cmd_fixed_param *) wmi_buf_data(buf); 914 WMITLV_SET_HDR(&cmd->tlv_header, 915 WMITLV_TAG_STRUC_wmi_vdev_stop_cmd_fixed_param, 916 WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_stop_cmd_fixed_param)); 917 cmd->vdev_id = vdev_id; 918 wmi_mtrace(WMI_VDEV_STOP_CMDID, cmd->vdev_id, 0); 919 if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_STOP_CMDID)) { 920 WMI_LOGP("%s: Failed to send vdev stop command", __func__); 921 wmi_buf_free(buf); 922 return QDF_STATUS_E_FAILURE; 923 } 924 WMI_LOGD("%s:vdev id = %d", __func__, vdev_id); 925 926 return 0; 927 } 928 929 /** 930 * send_vdev_down_cmd_tlv() - send vdev down command to fw 931 * @wmi: wmi handle 932 * @vdev_id: vdev id 933 * 934 * Return: QDF_STATUS_SUCCESS for success or error code 935 */ 936 static QDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id) 937 { 938 wmi_vdev_down_cmd_fixed_param *cmd; 939 wmi_buf_t buf; 940 int32_t len = sizeof(*cmd); 941 942 buf = wmi_buf_alloc(wmi, len); 943 if (!buf) 944 return QDF_STATUS_E_NOMEM; 945 946 cmd = (wmi_vdev_down_cmd_fixed_param *) wmi_buf_data(buf); 947 WMITLV_SET_HDR(&cmd->tlv_header, 948 WMITLV_TAG_STRUC_wmi_vdev_down_cmd_fixed_param, 949 WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_down_cmd_fixed_param)); 950 cmd->vdev_id = vdev_id; 951 wmi_mtrace(WMI_VDEV_DOWN_CMDID, cmd->vdev_id, 0); 952 if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_DOWN_CMDID)) { 953 WMI_LOGP("%s: Failed to send vdev down", __func__); 954 wmi_buf_free(buf); 955 return QDF_STATUS_E_FAILURE; 956 } 957 WMI_LOGD("%s: vdev_id %d", __func__, vdev_id); 958 959 return 0; 960 } 961 962 static inline void copy_channel_info( 963 wmi_vdev_start_request_cmd_fixed_param * cmd, 964 wmi_channel *chan, 965 struct vdev_start_params *req) 966 { 967 chan->mhz = req->channel.mhz; 968 969 WMI_SET_CHANNEL_MODE(chan, req->channel.phy_mode); 970 971 chan->band_center_freq1 = req->channel.cfreq1; 972 chan->band_center_freq2 = req->channel.cfreq2; 973 974 if (req->channel.half_rate) 975 WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE); 976 else if (req->channel.quarter_rate) 977 WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE); 978 979 if (req->channel.dfs_set) { 980 WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_DFS); 981 cmd->disable_hw_ack = req->disable_hw_ack; 982 } 983 984 if (req->channel.dfs_set_cfreq2) 985 WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_DFS_CFREQ2); 986 987 /* According to firmware both reg power and max tx power 988 * on set channel power is used and set it to max reg 989 * power from regulatory. 990 */ 991 WMI_SET_CHANNEL_MIN_POWER(chan, req->channel.minpower); 992 WMI_SET_CHANNEL_MAX_POWER(chan, req->channel.maxpower); 993 WMI_SET_CHANNEL_REG_POWER(chan, req->channel.maxregpower); 994 WMI_SET_CHANNEL_ANTENNA_MAX(chan, req->channel.antennamax); 995 WMI_SET_CHANNEL_REG_CLASSID(chan, req->channel.reg_class_id); 996 WMI_SET_CHANNEL_MAX_TX_POWER(chan, req->channel.maxregpower); 997 998 } 999 1000 /** 1001 * send_vdev_start_cmd_tlv() - send vdev start request to fw 1002 * @wmi_handle: wmi handle 1003 * @req: vdev start params 1004 * 1005 * Return: QDF status 1006 */ 1007 static QDF_STATUS send_vdev_start_cmd_tlv(wmi_unified_t wmi_handle, 1008 struct vdev_start_params *req) 1009 { 1010 wmi_vdev_start_request_cmd_fixed_param *cmd; 1011 wmi_buf_t buf; 1012 wmi_channel *chan; 1013 int32_t len, ret; 1014 uint8_t *buf_ptr; 1015 1016 len = sizeof(*cmd) + sizeof(wmi_channel) + WMI_TLV_HDR_SIZE; 1017 buf = wmi_buf_alloc(wmi_handle, len); 1018 if (!buf) 1019 return QDF_STATUS_E_NOMEM; 1020 1021 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1022 cmd = (wmi_vdev_start_request_cmd_fixed_param *) buf_ptr; 1023 chan = (wmi_channel *) (buf_ptr + sizeof(*cmd)); 1024 WMITLV_SET_HDR(&cmd->tlv_header, 1025 WMITLV_TAG_STRUC_wmi_vdev_start_request_cmd_fixed_param, 1026 WMITLV_GET_STRUCT_TLVLEN 1027 (wmi_vdev_start_request_cmd_fixed_param)); 1028 WMITLV_SET_HDR(&chan->tlv_header, WMITLV_TAG_STRUC_wmi_channel, 1029 WMITLV_GET_STRUCT_TLVLEN(wmi_channel)); 1030 cmd->vdev_id = req->vdev_id; 1031 1032 /* Fill channel info */ 1033 copy_channel_info(cmd, chan, req); 1034 cmd->beacon_interval = req->beacon_interval; 1035 cmd->dtim_period = req->dtim_period; 1036 1037 cmd->bcn_tx_rate = req->bcn_tx_rate_code; 1038 if (req->bcn_tx_rate_code) 1039 wmi_enable_bcn_ratecode(&cmd->flags); 1040 1041 if (!req->is_restart) { 1042 if (req->pmf_enabled) 1043 cmd->flags |= WMI_UNIFIED_VDEV_START_PMF_ENABLED; 1044 } 1045 1046 /* Copy the SSID */ 1047 if (req->ssid.length) { 1048 if (req->ssid.length < sizeof(cmd->ssid.ssid)) 1049 cmd->ssid.ssid_len = req->ssid.length; 1050 else 1051 cmd->ssid.ssid_len = sizeof(cmd->ssid.ssid); 1052 qdf_mem_copy(cmd->ssid.ssid, req->ssid.mac_ssid, 1053 cmd->ssid.ssid_len); 1054 } 1055 1056 if (req->hidden_ssid) 1057 cmd->flags |= WMI_UNIFIED_VDEV_START_HIDDEN_SSID; 1058 1059 cmd->flags |= WMI_UNIFIED_VDEV_START_LDPC_RX_ENABLED; 1060 cmd->num_noa_descriptors = req->num_noa_descriptors; 1061 cmd->preferred_rx_streams = req->preferred_rx_streams; 1062 cmd->preferred_tx_streams = req->preferred_tx_streams; 1063 cmd->cac_duration_ms = req->cac_duration_ms; 1064 cmd->regdomain = req->regdomain; 1065 cmd->he_ops = req->he_ops; 1066 1067 buf_ptr = (uint8_t *) (((uintptr_t) cmd) + sizeof(*cmd) + 1068 sizeof(wmi_channel)); 1069 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 1070 cmd->num_noa_descriptors * 1071 sizeof(wmi_p2p_noa_descriptor)); 1072 WMI_LOGI("%s: vdev_id %d freq %d chanmode %d ch_info: 0x%x is_dfs %d " 1073 "beacon interval %d dtim %d center_chan %d center_freq2 %d " 1074 "reg_info_1: 0x%x reg_info_2: 0x%x, req->max_txpow: 0x%x " 1075 "Tx SS %d, Rx SS %d, ldpc_rx: %d, cac %d, regd %d, HE ops: %d" 1076 "req->dis_hw_ack: %d ", __func__, req->vdev_id, 1077 chan->mhz, req->channel.phy_mode, chan->info, 1078 req->channel.dfs_set, req->beacon_interval, cmd->dtim_period, 1079 chan->band_center_freq1, chan->band_center_freq2, 1080 chan->reg_info_1, chan->reg_info_2, req->channel.maxregpower, 1081 req->preferred_tx_streams, req->preferred_rx_streams, 1082 req->ldpc_rx_enabled, req->cac_duration_ms, 1083 req->regdomain, req->he_ops, 1084 req->disable_hw_ack); 1085 1086 if (req->is_restart) { 1087 wmi_mtrace(WMI_VDEV_RESTART_REQUEST_CMDID, cmd->vdev_id, 0); 1088 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1089 WMI_VDEV_RESTART_REQUEST_CMDID); 1090 } else { 1091 wmi_mtrace(WMI_VDEV_START_REQUEST_CMDID, cmd->vdev_id, 0); 1092 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1093 WMI_VDEV_START_REQUEST_CMDID); 1094 } 1095 if (ret) { 1096 WMI_LOGP("%s: Failed to send vdev start command", __func__); 1097 wmi_buf_free(buf); 1098 return QDF_STATUS_E_FAILURE; 1099 } 1100 1101 return QDF_STATUS_SUCCESS; 1102 } 1103 1104 /** 1105 * send_peer_flush_tids_cmd_tlv() - flush peer tids packets in fw 1106 * @wmi: wmi handle 1107 * @peer_addr: peer mac address 1108 * @param: pointer to hold peer flush tid parameter 1109 * 1110 * Return: 0 for success or error code 1111 */ 1112 static QDF_STATUS send_peer_flush_tids_cmd_tlv(wmi_unified_t wmi, 1113 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1114 struct peer_flush_params *param) 1115 { 1116 wmi_peer_flush_tids_cmd_fixed_param *cmd; 1117 wmi_buf_t buf; 1118 int32_t len = sizeof(*cmd); 1119 1120 buf = wmi_buf_alloc(wmi, len); 1121 if (!buf) 1122 return QDF_STATUS_E_NOMEM; 1123 1124 cmd = (wmi_peer_flush_tids_cmd_fixed_param *) wmi_buf_data(buf); 1125 WMITLV_SET_HDR(&cmd->tlv_header, 1126 WMITLV_TAG_STRUC_wmi_peer_flush_tids_cmd_fixed_param, 1127 WMITLV_GET_STRUCT_TLVLEN 1128 (wmi_peer_flush_tids_cmd_fixed_param)); 1129 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr); 1130 cmd->peer_tid_bitmap = param->peer_tid_bitmap; 1131 cmd->vdev_id = param->vdev_id; 1132 WMI_LOGD("%s: peer_addr %pM vdev_id %d and peer bitmap %d", __func__, 1133 peer_addr, param->vdev_id, 1134 param->peer_tid_bitmap); 1135 wmi_mtrace(WMI_PEER_FLUSH_TIDS_CMDID, cmd->vdev_id, 0); 1136 if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) { 1137 WMI_LOGP("%s: Failed to send flush tid command", __func__); 1138 wmi_buf_free(buf); 1139 return QDF_STATUS_E_FAILURE; 1140 } 1141 1142 return 0; 1143 } 1144 1145 /** 1146 * send_peer_delete_cmd_tlv() - send PEER delete command to fw 1147 * @wmi: wmi handle 1148 * @peer_addr: peer mac addr 1149 * @vdev_id: vdev id 1150 * 1151 * Return: QDF_STATUS_SUCCESS for success or error code 1152 */ 1153 static QDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi, 1154 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1155 uint8_t vdev_id) 1156 { 1157 wmi_peer_delete_cmd_fixed_param *cmd; 1158 wmi_buf_t buf; 1159 int32_t len = sizeof(*cmd); 1160 buf = wmi_buf_alloc(wmi, len); 1161 if (!buf) 1162 return QDF_STATUS_E_NOMEM; 1163 1164 cmd = (wmi_peer_delete_cmd_fixed_param *) wmi_buf_data(buf); 1165 WMITLV_SET_HDR(&cmd->tlv_header, 1166 WMITLV_TAG_STRUC_wmi_peer_delete_cmd_fixed_param, 1167 WMITLV_GET_STRUCT_TLVLEN 1168 (wmi_peer_delete_cmd_fixed_param)); 1169 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr); 1170 cmd->vdev_id = vdev_id; 1171 1172 WMI_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id); 1173 wmi_mtrace(WMI_PEER_DELETE_CMDID, cmd->vdev_id, 0); 1174 if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) { 1175 WMI_LOGP("%s: Failed to send peer delete command", __func__); 1176 wmi_buf_free(buf); 1177 return QDF_STATUS_E_FAILURE; 1178 } 1179 1180 return 0; 1181 } 1182 1183 /** 1184 * send_peer_delete_all_cmd_tlv() - send PEER delete all command to fw 1185 * @wmi: wmi handle 1186 * @param: pointer to hold peer delete all parameter 1187 * 1188 * Return: QDF_STATUS_SUCCESS for success or error code 1189 */ 1190 static QDF_STATUS send_peer_delete_all_cmd_tlv( 1191 wmi_unified_t wmi, 1192 struct peer_delete_all_params *param) 1193 { 1194 wmi_vdev_delete_all_peer_cmd_fixed_param *cmd; 1195 wmi_buf_t buf; 1196 int32_t len = sizeof(*cmd); 1197 1198 buf = wmi_buf_alloc(wmi, len); 1199 if (!buf) 1200 return QDF_STATUS_E_NOMEM; 1201 1202 cmd = (wmi_vdev_delete_all_peer_cmd_fixed_param *)wmi_buf_data(buf); 1203 WMITLV_SET_HDR( 1204 &cmd->tlv_header, 1205 WMITLV_TAG_STRUC_wmi_vdev_delete_all_peer_cmd_fixed_param, 1206 WMITLV_GET_STRUCT_TLVLEN 1207 (wmi_vdev_delete_all_peer_cmd_fixed_param)); 1208 cmd->vdev_id = param->vdev_id; 1209 1210 WMI_LOGD("%s: vdev_id %d", __func__, cmd->vdev_id); 1211 wmi_mtrace(WMI_VDEV_DELETE_ALL_PEER_CMDID, cmd->vdev_id, 0); 1212 if (wmi_unified_cmd_send(wmi, buf, len, 1213 WMI_VDEV_DELETE_ALL_PEER_CMDID)) { 1214 WMI_LOGP("%s: Failed to send peer del all command", __func__); 1215 wmi_buf_free(buf); 1216 return QDF_STATUS_E_FAILURE; 1217 } 1218 1219 return QDF_STATUS_SUCCESS; 1220 } 1221 1222 /** 1223 * convert_host_peer_param_id_to_target_id_tlv - convert host peer param_id 1224 * to target id. 1225 * @peer_param_id: host param id. 1226 * 1227 * Return: Target param id. 1228 */ 1229 #ifdef ENABLE_HOST_TO_TARGET_CONVERSION 1230 static inline uint32_t convert_host_peer_param_id_to_target_id_tlv( 1231 uint32_t peer_param_id) 1232 { 1233 if (peer_param_id < QDF_ARRAY_SIZE(peer_param_tlv)) 1234 return peer_param_tlv[peer_param_id]; 1235 return WMI_UNAVAILABLE_PARAM; 1236 } 1237 #else 1238 static inline uint32_t convert_host_peer_param_id_to_target_id_tlv( 1239 uint32_t peer_param_id) 1240 { 1241 return peer_param_id; 1242 } 1243 #endif 1244 1245 /** 1246 * send_peer_param_cmd_tlv() - set peer parameter in fw 1247 * @wmi: wmi handle 1248 * @peer_addr: peer mac address 1249 * @param : pointer to hold peer set parameter 1250 * 1251 * Return: QDF_STATUS_SUCCESS for success or error code 1252 */ 1253 static QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi, 1254 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1255 struct peer_set_params *param) 1256 { 1257 wmi_peer_set_param_cmd_fixed_param *cmd; 1258 wmi_buf_t buf; 1259 int32_t err; 1260 uint32_t param_id; 1261 1262 param_id = convert_host_peer_param_id_to_target_id_tlv(param->param_id); 1263 if (param_id == WMI_UNAVAILABLE_PARAM) { 1264 WMI_LOGW("%s: Unavailable param %d", __func__, param->param_id); 1265 return QDF_STATUS_E_NOSUPPORT; 1266 } 1267 1268 buf = wmi_buf_alloc(wmi, sizeof(*cmd)); 1269 if (!buf) 1270 return QDF_STATUS_E_NOMEM; 1271 1272 cmd = (wmi_peer_set_param_cmd_fixed_param *) wmi_buf_data(buf); 1273 WMITLV_SET_HDR(&cmd->tlv_header, 1274 WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param, 1275 WMITLV_GET_STRUCT_TLVLEN 1276 (wmi_peer_set_param_cmd_fixed_param)); 1277 cmd->vdev_id = param->vdev_id; 1278 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr); 1279 cmd->param_id = param_id; 1280 cmd->param_value = param->param_value; 1281 wmi_mtrace(WMI_PEER_SET_PARAM_CMDID, cmd->vdev_id, 0); 1282 err = wmi_unified_cmd_send(wmi, buf, 1283 sizeof(wmi_peer_set_param_cmd_fixed_param), 1284 WMI_PEER_SET_PARAM_CMDID); 1285 if (err) { 1286 WMI_LOGE("Failed to send set_param cmd"); 1287 wmi_buf_free(buf); 1288 return QDF_STATUS_E_FAILURE; 1289 } 1290 1291 return 0; 1292 } 1293 1294 /** 1295 * send_vdev_up_cmd_tlv() - send vdev up command in fw 1296 * @wmi: wmi handle 1297 * @bssid: bssid 1298 * @vdev_up_params: pointer to hold vdev up parameter 1299 * 1300 * Return: QDF_STATUS_SUCCESS for success or error code 1301 */ 1302 static QDF_STATUS send_vdev_up_cmd_tlv(wmi_unified_t wmi, 1303 uint8_t bssid[QDF_MAC_ADDR_SIZE], 1304 struct vdev_up_params *params) 1305 { 1306 wmi_vdev_up_cmd_fixed_param *cmd; 1307 wmi_buf_t buf; 1308 int32_t len = sizeof(*cmd); 1309 1310 WMI_LOGD("%s: VDEV_UP", __func__); 1311 WMI_LOGD("%s: vdev_id %d aid %d bssid %pM", __func__, 1312 params->vdev_id, params->assoc_id, bssid); 1313 buf = wmi_buf_alloc(wmi, len); 1314 if (!buf) 1315 return QDF_STATUS_E_NOMEM; 1316 1317 cmd = (wmi_vdev_up_cmd_fixed_param *) wmi_buf_data(buf); 1318 WMITLV_SET_HDR(&cmd->tlv_header, 1319 WMITLV_TAG_STRUC_wmi_vdev_up_cmd_fixed_param, 1320 WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_up_cmd_fixed_param)); 1321 cmd->vdev_id = params->vdev_id; 1322 cmd->vdev_assoc_id = params->assoc_id; 1323 cmd->profile_idx = params->profile_idx; 1324 cmd->profile_num = params->profile_num; 1325 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->trans_bssid, &cmd->trans_bssid); 1326 WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid, &cmd->vdev_bssid); 1327 wmi_mtrace(WMI_VDEV_UP_CMDID, cmd->vdev_id, 0); 1328 if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_UP_CMDID)) { 1329 WMI_LOGP("%s: Failed to send vdev up command", __func__); 1330 wmi_buf_free(buf); 1331 return QDF_STATUS_E_FAILURE; 1332 } 1333 1334 return 0; 1335 } 1336 1337 /** 1338 * send_peer_create_cmd_tlv() - send peer create command to fw 1339 * @wmi: wmi handle 1340 * @peer_addr: peer mac address 1341 * @peer_type: peer type 1342 * @vdev_id: vdev id 1343 * 1344 * Return: QDF_STATUS_SUCCESS for success or error code 1345 */ 1346 static QDF_STATUS send_peer_create_cmd_tlv(wmi_unified_t wmi, 1347 struct peer_create_params *param) 1348 { 1349 wmi_peer_create_cmd_fixed_param *cmd; 1350 wmi_buf_t buf; 1351 int32_t len = sizeof(*cmd); 1352 1353 buf = wmi_buf_alloc(wmi, len); 1354 if (!buf) 1355 return QDF_STATUS_E_NOMEM; 1356 1357 cmd = (wmi_peer_create_cmd_fixed_param *) wmi_buf_data(buf); 1358 WMITLV_SET_HDR(&cmd->tlv_header, 1359 WMITLV_TAG_STRUC_wmi_peer_create_cmd_fixed_param, 1360 WMITLV_GET_STRUCT_TLVLEN 1361 (wmi_peer_create_cmd_fixed_param)); 1362 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr); 1363 cmd->peer_type = param->peer_type; 1364 cmd->vdev_id = param->vdev_id; 1365 1366 wmi_mtrace(WMI_PEER_CREATE_CMDID, cmd->vdev_id, 0); 1367 if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CREATE_CMDID)) { 1368 WMI_LOGP("%s: failed to send WMI_PEER_CREATE_CMDID", __func__); 1369 wmi_buf_free(buf); 1370 return QDF_STATUS_E_FAILURE; 1371 } 1372 WMI_LOGD("%s: peer_addr %pM vdev_id %d", __func__, param->peer_addr, 1373 param->vdev_id); 1374 1375 return 0; 1376 } 1377 1378 /** 1379 * send_peer_rx_reorder_queue_setup_cmd_tlv() - send rx reorder setup 1380 * command to fw 1381 * @wmi: wmi handle 1382 * @rx_reorder_queue_setup_params: Rx reorder queue setup parameters 1383 * 1384 * Return: 0 for success or error code 1385 */ 1386 static 1387 QDF_STATUS send_peer_rx_reorder_queue_setup_cmd_tlv(wmi_unified_t wmi, 1388 struct rx_reorder_queue_setup_params *param) 1389 { 1390 wmi_peer_reorder_queue_setup_cmd_fixed_param *cmd; 1391 wmi_buf_t buf; 1392 int32_t len = sizeof(*cmd); 1393 1394 buf = wmi_buf_alloc(wmi, len); 1395 if (!buf) 1396 return QDF_STATUS_E_NOMEM; 1397 1398 cmd = (wmi_peer_reorder_queue_setup_cmd_fixed_param *)wmi_buf_data(buf); 1399 WMITLV_SET_HDR(&cmd->tlv_header, 1400 WMITLV_TAG_STRUC_wmi_peer_reorder_queue_setup_cmd_fixed_param, 1401 WMITLV_GET_STRUCT_TLVLEN 1402 (wmi_peer_reorder_queue_setup_cmd_fixed_param)); 1403 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_macaddr, &cmd->peer_macaddr); 1404 cmd->vdev_id = param->vdev_id; 1405 cmd->tid = param->tid; 1406 cmd->queue_ptr_lo = param->hw_qdesc_paddr_lo; 1407 cmd->queue_ptr_hi = param->hw_qdesc_paddr_hi; 1408 cmd->queue_no = param->queue_no; 1409 cmd->ba_window_size_valid = param->ba_window_size_valid; 1410 cmd->ba_window_size = param->ba_window_size; 1411 1412 1413 wmi_mtrace(WMI_PEER_REORDER_QUEUE_SETUP_CMDID, cmd->vdev_id, 0); 1414 if (wmi_unified_cmd_send(wmi, buf, len, 1415 WMI_PEER_REORDER_QUEUE_SETUP_CMDID)) { 1416 WMI_LOGP("%s: fail to send WMI_PEER_REORDER_QUEUE_SETUP_CMDID", 1417 __func__); 1418 wmi_buf_free(buf); 1419 return QDF_STATUS_E_FAILURE; 1420 } 1421 WMI_LOGD("%s: peer_macaddr %pM vdev_id %d, tid %d", __func__, 1422 param->peer_macaddr, param->vdev_id, param->tid); 1423 1424 return QDF_STATUS_SUCCESS; 1425 } 1426 1427 /** 1428 * send_peer_rx_reorder_queue_remove_cmd_tlv() - send rx reorder remove 1429 * command to fw 1430 * @wmi: wmi handle 1431 * @rx_reorder_queue_remove_params: Rx reorder queue remove parameters 1432 * 1433 * Return: 0 for success or error code 1434 */ 1435 static 1436 QDF_STATUS send_peer_rx_reorder_queue_remove_cmd_tlv(wmi_unified_t wmi, 1437 struct rx_reorder_queue_remove_params *param) 1438 { 1439 wmi_peer_reorder_queue_remove_cmd_fixed_param *cmd; 1440 wmi_buf_t buf; 1441 int32_t len = sizeof(*cmd); 1442 1443 buf = wmi_buf_alloc(wmi, len); 1444 if (!buf) 1445 return QDF_STATUS_E_NOMEM; 1446 1447 cmd = (wmi_peer_reorder_queue_remove_cmd_fixed_param *) 1448 wmi_buf_data(buf); 1449 WMITLV_SET_HDR(&cmd->tlv_header, 1450 WMITLV_TAG_STRUC_wmi_peer_reorder_queue_remove_cmd_fixed_param, 1451 WMITLV_GET_STRUCT_TLVLEN 1452 (wmi_peer_reorder_queue_remove_cmd_fixed_param)); 1453 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_macaddr, &cmd->peer_macaddr); 1454 cmd->vdev_id = param->vdev_id; 1455 cmd->tid_mask = param->peer_tid_bitmap; 1456 1457 wmi_mtrace(WMI_PEER_REORDER_QUEUE_REMOVE_CMDID, cmd->vdev_id, 0); 1458 if (wmi_unified_cmd_send(wmi, buf, len, 1459 WMI_PEER_REORDER_QUEUE_REMOVE_CMDID)) { 1460 WMI_LOGP("%s: fail to send WMI_PEER_REORDER_QUEUE_REMOVE_CMDID", 1461 __func__); 1462 wmi_buf_free(buf); 1463 return QDF_STATUS_E_FAILURE; 1464 } 1465 WMI_LOGD("%s: peer_macaddr %pM vdev_id %d, tid_map %d", __func__, 1466 param->peer_macaddr, param->vdev_id, param->peer_tid_bitmap); 1467 1468 return QDF_STATUS_SUCCESS; 1469 } 1470 1471 #ifdef WLAN_SUPPORT_GREEN_AP 1472 /** 1473 * send_green_ap_ps_cmd_tlv() - enable green ap powersave command 1474 * @wmi_handle: wmi handle 1475 * @value: value 1476 * @pdev_id: pdev id to have radio context 1477 * 1478 * Return: QDF_STATUS_SUCCESS for success or error code 1479 */ 1480 static QDF_STATUS send_green_ap_ps_cmd_tlv(wmi_unified_t wmi_handle, 1481 uint32_t value, uint8_t pdev_id) 1482 { 1483 wmi_pdev_green_ap_ps_enable_cmd_fixed_param *cmd; 1484 wmi_buf_t buf; 1485 int32_t len = sizeof(*cmd); 1486 1487 WMI_LOGD("Set Green AP PS val %d", value); 1488 1489 buf = wmi_buf_alloc(wmi_handle, len); 1490 if (!buf) 1491 return QDF_STATUS_E_NOMEM; 1492 1493 cmd = (wmi_pdev_green_ap_ps_enable_cmd_fixed_param *) wmi_buf_data(buf); 1494 WMITLV_SET_HDR(&cmd->tlv_header, 1495 WMITLV_TAG_STRUC_wmi_pdev_green_ap_ps_enable_cmd_fixed_param, 1496 WMITLV_GET_STRUCT_TLVLEN 1497 (wmi_pdev_green_ap_ps_enable_cmd_fixed_param)); 1498 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1499 wmi_handle, 1500 pdev_id); 1501 cmd->enable = value; 1502 1503 wmi_mtrace(WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID, NO_SESSION, 0); 1504 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1505 WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID)) { 1506 WMI_LOGE("Set Green AP PS param Failed val %d", value); 1507 wmi_buf_free(buf); 1508 return QDF_STATUS_E_FAILURE; 1509 } 1510 1511 return 0; 1512 } 1513 #endif 1514 1515 /** 1516 * send_pdev_utf_cmd_tlv() - send utf command to fw 1517 * @wmi_handle: wmi handle 1518 * @param: pointer to pdev_utf_params 1519 * @mac_id: mac id to have radio context 1520 * 1521 * Return: QDF_STATUS_SUCCESS for success or error code 1522 */ 1523 static QDF_STATUS 1524 send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle, 1525 struct pdev_utf_params *param, 1526 uint8_t mac_id) 1527 { 1528 wmi_buf_t buf; 1529 uint8_t *cmd; 1530 /* if param->len is 0 no data is sent, return error */ 1531 QDF_STATUS ret = QDF_STATUS_E_INVAL; 1532 static uint8_t msgref = 1; 1533 uint8_t segNumber = 0, segInfo, numSegments; 1534 uint16_t chunk_len, total_bytes; 1535 uint8_t *bufpos; 1536 struct seg_hdr_info segHdrInfo; 1537 1538 bufpos = param->utf_payload; 1539 total_bytes = param->len; 1540 ASSERT(total_bytes / MAX_WMI_UTF_LEN == 1541 (uint8_t) (total_bytes / MAX_WMI_UTF_LEN)); 1542 numSegments = (uint8_t) (total_bytes / MAX_WMI_UTF_LEN); 1543 1544 if (param->len - (numSegments * MAX_WMI_UTF_LEN)) 1545 numSegments++; 1546 1547 while (param->len) { 1548 if (param->len > MAX_WMI_UTF_LEN) 1549 chunk_len = MAX_WMI_UTF_LEN; /* MAX message */ 1550 else 1551 chunk_len = param->len; 1552 1553 buf = wmi_buf_alloc(wmi_handle, 1554 (chunk_len + sizeof(segHdrInfo) + 1555 WMI_TLV_HDR_SIZE)); 1556 if (!buf) 1557 return QDF_STATUS_E_NOMEM; 1558 1559 cmd = (uint8_t *) wmi_buf_data(buf); 1560 1561 segHdrInfo.len = total_bytes; 1562 segHdrInfo.msgref = msgref; 1563 segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF); 1564 segHdrInfo.segmentInfo = segInfo; 1565 segHdrInfo.pad = 0; 1566 1567 WMI_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d," 1568 " segHdrInfo.segmentInfo = %d", 1569 __func__, segHdrInfo.len, segHdrInfo.msgref, 1570 segHdrInfo.segmentInfo); 1571 1572 WMI_LOGD("%s:total_bytes %d segNumber %d totalSegments %d" 1573 "chunk len %d", __func__, total_bytes, segNumber, 1574 numSegments, chunk_len); 1575 1576 segNumber++; 1577 1578 WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE, 1579 (chunk_len + sizeof(segHdrInfo))); 1580 cmd += WMI_TLV_HDR_SIZE; 1581 memcpy(cmd, &segHdrInfo, sizeof(segHdrInfo)); /* 4 bytes */ 1582 memcpy(&cmd[sizeof(segHdrInfo)], bufpos, chunk_len); 1583 1584 wmi_mtrace(WMI_PDEV_UTF_CMDID, NO_SESSION, 0); 1585 ret = wmi_unified_cmd_send(wmi_handle, buf, 1586 (chunk_len + sizeof(segHdrInfo) + 1587 WMI_TLV_HDR_SIZE), 1588 WMI_PDEV_UTF_CMDID); 1589 1590 if (QDF_IS_STATUS_ERROR(ret)) { 1591 WMI_LOGE("Failed to send WMI_PDEV_UTF_CMDID command"); 1592 wmi_buf_free(buf); 1593 break; 1594 } 1595 1596 param->len -= chunk_len; 1597 bufpos += chunk_len; 1598 } 1599 1600 msgref++; 1601 1602 return ret; 1603 } 1604 1605 #ifdef ENABLE_HOST_TO_TARGET_CONVERSION 1606 static inline uint32_t convert_host_pdev_param_tlv(uint32_t host_param) 1607 { 1608 if (host_param < QDF_ARRAY_SIZE(pdev_param_tlv)) 1609 return pdev_param_tlv[host_param]; 1610 return WMI_UNAVAILABLE_PARAM; 1611 } 1612 #else 1613 static inline uint32_t convert_host_pdev_param_tlv(uint32_t host_param) 1614 { 1615 return host_param; 1616 } 1617 #endif 1618 1619 /** 1620 * send_pdev_param_cmd_tlv() - set pdev parameters 1621 * @wmi_handle: wmi handle 1622 * @param: pointer to pdev parameter 1623 * @mac_id: radio context 1624 * 1625 * Return: 0 on success, errno on failure 1626 */ 1627 static QDF_STATUS 1628 send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle, 1629 struct pdev_params *param, 1630 uint8_t mac_id) 1631 { 1632 QDF_STATUS ret; 1633 wmi_pdev_set_param_cmd_fixed_param *cmd; 1634 wmi_buf_t buf; 1635 uint16_t len = sizeof(*cmd); 1636 uint32_t pdev_param; 1637 1638 pdev_param = convert_host_pdev_param_tlv(param->param_id); 1639 if (pdev_param == WMI_UNAVAILABLE_PARAM) { 1640 WMI_LOGW("%s: Unavailable param %d", 1641 __func__, param->param_id); 1642 return QDF_STATUS_E_INVAL; 1643 } 1644 1645 buf = wmi_buf_alloc(wmi_handle, len); 1646 if (!buf) 1647 return QDF_STATUS_E_NOMEM; 1648 1649 cmd = (wmi_pdev_set_param_cmd_fixed_param *) wmi_buf_data(buf); 1650 WMITLV_SET_HDR(&cmd->tlv_header, 1651 WMITLV_TAG_STRUC_wmi_pdev_set_param_cmd_fixed_param, 1652 WMITLV_GET_STRUCT_TLVLEN 1653 (wmi_pdev_set_param_cmd_fixed_param)); 1654 if (param->is_host_pdev_id) 1655 cmd->pdev_id = wmi_handle->ops->convert_host_pdev_id_to_target( 1656 wmi_handle, 1657 mac_id); 1658 else 1659 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1660 wmi_handle, 1661 mac_id); 1662 cmd->param_id = pdev_param; 1663 cmd->param_value = param->param_value; 1664 WMI_LOGD("Setting pdev param = %x, value = %u", param->param_id, 1665 param->param_value); 1666 wmi_mtrace(WMI_PDEV_SET_PARAM_CMDID, NO_SESSION, 0); 1667 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1668 WMI_PDEV_SET_PARAM_CMDID); 1669 if (QDF_IS_STATUS_ERROR(ret)) { 1670 WMI_LOGE("Failed to send set param command ret = %d", ret); 1671 wmi_buf_free(buf); 1672 } 1673 return ret; 1674 } 1675 1676 /** 1677 * send_pdev_set_hw_mode_cmd_tlv() - Send WMI_PDEV_SET_HW_MODE_CMDID to FW 1678 * @wmi_handle: wmi handle 1679 * @msg: Structure containing the following parameters 1680 * @hw_mode_index: The HW_Mode field is a enumerated type that is selected 1681 * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID. 1682 * 1683 * Provides notification to the WLAN firmware that host driver is requesting a 1684 * HardWare (HW) Mode change. This command is needed to support iHelium in the 1685 * configurations that include the Dual Band Simultaneous (DBS) feature. 1686 * 1687 * Return: Success if the cmd is sent successfully to the firmware 1688 */ 1689 static QDF_STATUS send_pdev_set_hw_mode_cmd_tlv(wmi_unified_t wmi_handle, 1690 uint32_t hw_mode_index) 1691 { 1692 wmi_pdev_set_hw_mode_cmd_fixed_param *cmd; 1693 wmi_buf_t buf; 1694 uint32_t len; 1695 1696 len = sizeof(*cmd); 1697 1698 buf = wmi_buf_alloc(wmi_handle, len); 1699 if (!buf) 1700 return QDF_STATUS_E_NOMEM; 1701 1702 cmd = (wmi_pdev_set_hw_mode_cmd_fixed_param *)wmi_buf_data(buf); 1703 WMITLV_SET_HDR(&cmd->tlv_header, 1704 WMITLV_TAG_STRUC_wmi_pdev_set_hw_mode_cmd_fixed_param, 1705 WMITLV_GET_STRUCT_TLVLEN( 1706 wmi_pdev_set_hw_mode_cmd_fixed_param)); 1707 1708 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1709 wmi_handle, 1710 WMI_HOST_PDEV_ID_SOC); 1711 cmd->hw_mode_index = hw_mode_index; 1712 WMI_LOGD("%s: HW mode index:%d", __func__, cmd->hw_mode_index); 1713 1714 wmi_mtrace(WMI_PDEV_SET_HW_MODE_CMDID, NO_SESSION, 0); 1715 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1716 WMI_PDEV_SET_HW_MODE_CMDID)) { 1717 WMI_LOGE("%s: Failed to send WMI_PDEV_SET_HW_MODE_CMDID", 1718 __func__); 1719 wmi_buf_free(buf); 1720 return QDF_STATUS_E_FAILURE; 1721 } 1722 1723 return QDF_STATUS_SUCCESS; 1724 } 1725 1726 /** 1727 * send_suspend_cmd_tlv() - WMI suspend function 1728 * @param wmi_handle : handle to WMI. 1729 * @param param : pointer to hold suspend parameter 1730 * @mac_id: radio context 1731 * 1732 * Return 0 on success and -ve on failure. 1733 */ 1734 static QDF_STATUS send_suspend_cmd_tlv(wmi_unified_t wmi_handle, 1735 struct suspend_params *param, 1736 uint8_t mac_id) 1737 { 1738 wmi_pdev_suspend_cmd_fixed_param *cmd; 1739 wmi_buf_t wmibuf; 1740 uint32_t len = sizeof(*cmd); 1741 int32_t ret; 1742 1743 /* 1744 * send the command to Target to ignore the 1745 * PCIE reset so as to ensure that Host and target 1746 * states are in sync 1747 */ 1748 wmibuf = wmi_buf_alloc(wmi_handle, len); 1749 if (!wmibuf) 1750 return QDF_STATUS_E_NOMEM; 1751 1752 cmd = (wmi_pdev_suspend_cmd_fixed_param *) wmi_buf_data(wmibuf); 1753 WMITLV_SET_HDR(&cmd->tlv_header, 1754 WMITLV_TAG_STRUC_wmi_pdev_suspend_cmd_fixed_param, 1755 WMITLV_GET_STRUCT_TLVLEN 1756 (wmi_pdev_suspend_cmd_fixed_param)); 1757 if (param->disable_target_intr) 1758 cmd->suspend_opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR; 1759 else 1760 cmd->suspend_opt = WMI_PDEV_SUSPEND; 1761 1762 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1763 wmi_handle, 1764 mac_id); 1765 1766 wmi_mtrace(WMI_PDEV_SUSPEND_CMDID, NO_SESSION, 0); 1767 ret = wmi_unified_cmd_send(wmi_handle, wmibuf, len, 1768 WMI_PDEV_SUSPEND_CMDID); 1769 if (ret) { 1770 wmi_buf_free(wmibuf); 1771 WMI_LOGE("Failed to send WMI_PDEV_SUSPEND_CMDID command"); 1772 } 1773 1774 return ret; 1775 } 1776 1777 /** 1778 * send_resume_cmd_tlv() - WMI resume function 1779 * @param wmi_handle : handle to WMI. 1780 * @mac_id: radio context 1781 * 1782 * Return: 0 on success and -ve on failure. 1783 */ 1784 static QDF_STATUS send_resume_cmd_tlv(wmi_unified_t wmi_handle, 1785 uint8_t mac_id) 1786 { 1787 wmi_buf_t wmibuf; 1788 wmi_pdev_resume_cmd_fixed_param *cmd; 1789 QDF_STATUS ret; 1790 1791 wmibuf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1792 if (!wmibuf) 1793 return QDF_STATUS_E_NOMEM; 1794 cmd = (wmi_pdev_resume_cmd_fixed_param *) wmi_buf_data(wmibuf); 1795 WMITLV_SET_HDR(&cmd->tlv_header, 1796 WMITLV_TAG_STRUC_wmi_pdev_resume_cmd_fixed_param, 1797 WMITLV_GET_STRUCT_TLVLEN 1798 (wmi_pdev_resume_cmd_fixed_param)); 1799 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1800 wmi_handle, 1801 mac_id); 1802 wmi_mtrace(WMI_PDEV_RESUME_CMDID, NO_SESSION, 0); 1803 ret = wmi_unified_cmd_send(wmi_handle, wmibuf, sizeof(*cmd), 1804 WMI_PDEV_RESUME_CMDID); 1805 if (QDF_IS_STATUS_ERROR(ret)) { 1806 WMI_LOGE("Failed to send WMI_PDEV_RESUME_CMDID command"); 1807 wmi_buf_free(wmibuf); 1808 } 1809 1810 return ret; 1811 } 1812 1813 /** 1814 * send_wow_enable_cmd_tlv() - WMI wow enable function 1815 * @param wmi_handle : handle to WMI. 1816 * @param param : pointer to hold wow enable parameter 1817 * @mac_id: radio context 1818 * 1819 * Return: 0 on success and -ve on failure. 1820 */ 1821 static QDF_STATUS send_wow_enable_cmd_tlv(wmi_unified_t wmi_handle, 1822 struct wow_cmd_params *param, 1823 uint8_t mac_id) 1824 { 1825 wmi_wow_enable_cmd_fixed_param *cmd; 1826 wmi_buf_t buf; 1827 int32_t len; 1828 int32_t ret; 1829 1830 len = sizeof(wmi_wow_enable_cmd_fixed_param); 1831 1832 buf = wmi_buf_alloc(wmi_handle, len); 1833 if (!buf) 1834 return QDF_STATUS_E_NOMEM; 1835 1836 cmd = (wmi_wow_enable_cmd_fixed_param *) wmi_buf_data(buf); 1837 WMITLV_SET_HDR(&cmd->tlv_header, 1838 WMITLV_TAG_STRUC_wmi_wow_enable_cmd_fixed_param, 1839 WMITLV_GET_STRUCT_TLVLEN 1840 (wmi_wow_enable_cmd_fixed_param)); 1841 cmd->enable = param->enable; 1842 if (param->can_suspend_link) 1843 cmd->pause_iface_config = WOW_IFACE_PAUSE_ENABLED; 1844 else 1845 cmd->pause_iface_config = WOW_IFACE_PAUSE_DISABLED; 1846 cmd->flags = param->flags; 1847 1848 WMI_LOGI("suspend type: %s", 1849 cmd->pause_iface_config == WOW_IFACE_PAUSE_ENABLED ? 1850 "WOW_IFACE_PAUSE_ENABLED" : "WOW_IFACE_PAUSE_DISABLED"); 1851 1852 wmi_mtrace(WMI_WOW_ENABLE_CMDID, NO_SESSION, 0); 1853 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1854 WMI_WOW_ENABLE_CMDID); 1855 if (ret) 1856 wmi_buf_free(buf); 1857 1858 return ret; 1859 } 1860 1861 /** 1862 * send_set_ap_ps_param_cmd_tlv() - set ap powersave parameters 1863 * @wmi_handle: wmi handle 1864 * @peer_addr: peer mac address 1865 * @param: pointer to ap_ps parameter structure 1866 * 1867 * Return: QDF_STATUS_SUCCESS for success or error code 1868 */ 1869 static QDF_STATUS send_set_ap_ps_param_cmd_tlv(wmi_unified_t wmi_handle, 1870 uint8_t *peer_addr, 1871 struct ap_ps_params *param) 1872 { 1873 wmi_ap_ps_peer_cmd_fixed_param *cmd; 1874 wmi_buf_t buf; 1875 int32_t err; 1876 1877 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1878 if (!buf) 1879 return QDF_STATUS_E_NOMEM; 1880 1881 cmd = (wmi_ap_ps_peer_cmd_fixed_param *) wmi_buf_data(buf); 1882 WMITLV_SET_HDR(&cmd->tlv_header, 1883 WMITLV_TAG_STRUC_wmi_ap_ps_peer_cmd_fixed_param, 1884 WMITLV_GET_STRUCT_TLVLEN 1885 (wmi_ap_ps_peer_cmd_fixed_param)); 1886 cmd->vdev_id = param->vdev_id; 1887 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr); 1888 cmd->param = param->param; 1889 cmd->value = param->value; 1890 wmi_mtrace(WMI_AP_PS_PEER_PARAM_CMDID, cmd->vdev_id, 0); 1891 err = wmi_unified_cmd_send(wmi_handle, buf, 1892 sizeof(*cmd), WMI_AP_PS_PEER_PARAM_CMDID); 1893 if (err) { 1894 WMI_LOGE("Failed to send set_ap_ps_param cmd"); 1895 wmi_buf_free(buf); 1896 return QDF_STATUS_E_FAILURE; 1897 } 1898 1899 return 0; 1900 } 1901 1902 /** 1903 * send_set_sta_ps_param_cmd_tlv() - set sta powersave parameters 1904 * @wmi_handle: wmi handle 1905 * @peer_addr: peer mac address 1906 * @param: pointer to sta_ps parameter structure 1907 * 1908 * Return: QDF_STATUS_SUCCESS for success or error code 1909 */ 1910 static QDF_STATUS send_set_sta_ps_param_cmd_tlv(wmi_unified_t wmi_handle, 1911 struct sta_ps_params *param) 1912 { 1913 wmi_sta_powersave_param_cmd_fixed_param *cmd; 1914 wmi_buf_t buf; 1915 int32_t len = sizeof(*cmd); 1916 1917 buf = wmi_buf_alloc(wmi_handle, len); 1918 if (!buf) 1919 return QDF_STATUS_E_NOMEM; 1920 1921 cmd = (wmi_sta_powersave_param_cmd_fixed_param *) wmi_buf_data(buf); 1922 WMITLV_SET_HDR(&cmd->tlv_header, 1923 WMITLV_TAG_STRUC_wmi_sta_powersave_param_cmd_fixed_param, 1924 WMITLV_GET_STRUCT_TLVLEN 1925 (wmi_sta_powersave_param_cmd_fixed_param)); 1926 cmd->vdev_id = param->vdev_id; 1927 cmd->param = param->param_id; 1928 cmd->value = param->value; 1929 1930 wmi_mtrace(WMI_STA_POWERSAVE_PARAM_CMDID, cmd->vdev_id, 0); 1931 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1932 WMI_STA_POWERSAVE_PARAM_CMDID)) { 1933 WMI_LOGE("Set Sta Ps param Failed vdevId %d Param %d val %d", 1934 param->vdev_id, param->param_id, param->value); 1935 wmi_buf_free(buf); 1936 return QDF_STATUS_E_FAILURE; 1937 } 1938 1939 return 0; 1940 } 1941 1942 /** 1943 * send_crash_inject_cmd_tlv() - inject fw crash 1944 * @wmi_handle: wmi handle 1945 * @param: ponirt to crash inject parameter structure 1946 * 1947 * Return: QDF_STATUS_SUCCESS for success or return error 1948 */ 1949 static QDF_STATUS send_crash_inject_cmd_tlv(wmi_unified_t wmi_handle, 1950 struct crash_inject *param) 1951 { 1952 int32_t ret = 0; 1953 WMI_FORCE_FW_HANG_CMD_fixed_param *cmd; 1954 uint16_t len = sizeof(*cmd); 1955 wmi_buf_t buf; 1956 1957 buf = wmi_buf_alloc(wmi_handle, len); 1958 if (!buf) 1959 return QDF_STATUS_E_NOMEM; 1960 1961 cmd = (WMI_FORCE_FW_HANG_CMD_fixed_param *) wmi_buf_data(buf); 1962 WMITLV_SET_HDR(&cmd->tlv_header, 1963 WMITLV_TAG_STRUC_WMI_FORCE_FW_HANG_CMD_fixed_param, 1964 WMITLV_GET_STRUCT_TLVLEN 1965 (WMI_FORCE_FW_HANG_CMD_fixed_param)); 1966 cmd->type = param->type; 1967 cmd->delay_time_ms = param->delay_time_ms; 1968 1969 wmi_mtrace(WMI_FORCE_FW_HANG_CMDID, NO_SESSION, 0); 1970 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1971 WMI_FORCE_FW_HANG_CMDID); 1972 if (ret) { 1973 WMI_LOGE("%s: Failed to send set param command, ret = %d", 1974 __func__, ret); 1975 wmi_buf_free(buf); 1976 } 1977 1978 return ret; 1979 } 1980 1981 #ifdef FEATURE_FW_LOG_PARSING 1982 /** 1983 * send_dbglog_cmd_tlv() - set debug log level 1984 * @param wmi_handle : handle to WMI. 1985 * @param param : pointer to hold dbglog level parameter 1986 * 1987 * Return: 0 on success and -ve on failure. 1988 */ 1989 static QDF_STATUS 1990 send_dbglog_cmd_tlv(wmi_unified_t wmi_handle, 1991 struct dbglog_params *dbglog_param) 1992 { 1993 wmi_buf_t buf; 1994 wmi_debug_log_config_cmd_fixed_param *configmsg; 1995 QDF_STATUS status; 1996 int32_t i; 1997 int32_t len; 1998 int8_t *buf_ptr; 1999 int32_t *module_id_bitmap_array; /* Used to fomr the second tlv */ 2000 2001 ASSERT(dbglog_param->bitmap_len < MAX_MODULE_ID_BITMAP_WORDS); 2002 2003 /* Allocate size for 2 tlvs - including tlv hdr space for second tlv */ 2004 len = sizeof(wmi_debug_log_config_cmd_fixed_param) + WMI_TLV_HDR_SIZE + 2005 (sizeof(int32_t) * MAX_MODULE_ID_BITMAP_WORDS); 2006 buf = wmi_buf_alloc(wmi_handle, len); 2007 if (!buf) 2008 return QDF_STATUS_E_NOMEM; 2009 2010 configmsg = 2011 (wmi_debug_log_config_cmd_fixed_param *) (wmi_buf_data(buf)); 2012 buf_ptr = (int8_t *) configmsg; 2013 WMITLV_SET_HDR(&configmsg->tlv_header, 2014 WMITLV_TAG_STRUC_wmi_debug_log_config_cmd_fixed_param, 2015 WMITLV_GET_STRUCT_TLVLEN 2016 (wmi_debug_log_config_cmd_fixed_param)); 2017 configmsg->dbg_log_param = dbglog_param->param; 2018 configmsg->value = dbglog_param->val; 2019 /* Filling in the data part of second tlv -- should 2020 * follow first tlv _ WMI_TLV_HDR_SIZE */ 2021 module_id_bitmap_array = (uint32_t *) (buf_ptr + 2022 sizeof 2023 (wmi_debug_log_config_cmd_fixed_param) 2024 + WMI_TLV_HDR_SIZE); 2025 WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param), 2026 WMITLV_TAG_ARRAY_UINT32, 2027 sizeof(uint32_t) * MAX_MODULE_ID_BITMAP_WORDS); 2028 if (dbglog_param->module_id_bitmap) { 2029 for (i = 0; i < dbglog_param->bitmap_len; ++i) { 2030 module_id_bitmap_array[i] = 2031 dbglog_param->module_id_bitmap[i]; 2032 } 2033 } 2034 2035 wmi_mtrace(WMI_DBGLOG_CFG_CMDID, NO_SESSION, 0); 2036 status = wmi_unified_cmd_send(wmi_handle, buf, 2037 len, WMI_DBGLOG_CFG_CMDID); 2038 2039 if (status != QDF_STATUS_SUCCESS) 2040 wmi_buf_free(buf); 2041 2042 return status; 2043 } 2044 #endif 2045 2046 #ifdef ENABLE_HOST_TO_TARGET_CONVERSION 2047 static inline uint32_t convert_host_vdev_param_tlv(uint32_t host_param) 2048 { 2049 if (host_param < QDF_ARRAY_SIZE(vdev_param_tlv)) 2050 return vdev_param_tlv[host_param]; 2051 return WMI_UNAVAILABLE_PARAM; 2052 } 2053 #else 2054 static inline uint32_t convert_host_vdev_param_tlv(uint32_t host_param) 2055 { 2056 return host_param; 2057 } 2058 #endif 2059 2060 /** 2061 * send_vdev_set_param_cmd_tlv() - WMI vdev set parameter function 2062 * @param wmi_handle : handle to WMI. 2063 * @param macaddr : MAC address 2064 * @param param : pointer to hold vdev set parameter 2065 * 2066 * Return: 0 on success and -ve on failure. 2067 */ 2068 static QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle, 2069 struct vdev_set_params *param) 2070 { 2071 QDF_STATUS ret; 2072 wmi_vdev_set_param_cmd_fixed_param *cmd; 2073 wmi_buf_t buf; 2074 uint16_t len = sizeof(*cmd); 2075 uint32_t vdev_param; 2076 2077 vdev_param = convert_host_vdev_param_tlv(param->param_id); 2078 if (vdev_param == WMI_UNAVAILABLE_PARAM) { 2079 WMI_LOGW("%s:Vdev param %d not available", __func__, 2080 param->param_id); 2081 return QDF_STATUS_E_INVAL; 2082 2083 } 2084 2085 buf = wmi_buf_alloc(wmi_handle, len); 2086 if (!buf) 2087 return QDF_STATUS_E_NOMEM; 2088 2089 cmd = (wmi_vdev_set_param_cmd_fixed_param *) wmi_buf_data(buf); 2090 WMITLV_SET_HDR(&cmd->tlv_header, 2091 WMITLV_TAG_STRUC_wmi_vdev_set_param_cmd_fixed_param, 2092 WMITLV_GET_STRUCT_TLVLEN 2093 (wmi_vdev_set_param_cmd_fixed_param)); 2094 cmd->vdev_id = param->vdev_id; 2095 cmd->param_id = vdev_param; 2096 cmd->param_value = param->param_value; 2097 WMI_LOGD("Setting vdev %d param = %x, value = %u", 2098 cmd->vdev_id, cmd->param_id, cmd->param_value); 2099 wmi_mtrace(WMI_VDEV_SET_PARAM_CMDID, cmd->vdev_id, 0); 2100 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 2101 WMI_VDEV_SET_PARAM_CMDID); 2102 if (QDF_IS_STATUS_ERROR(ret)) { 2103 WMI_LOGE("Failed to send set param command ret = %d", ret); 2104 wmi_buf_free(buf); 2105 } 2106 2107 return ret; 2108 } 2109 2110 /** 2111 * send_stats_request_cmd_tlv() - WMI request stats function 2112 * @param wmi_handle : handle to WMI. 2113 * @param macaddr : MAC address 2114 * @param param : pointer to hold stats request parameter 2115 * 2116 * Return: 0 on success and -ve on failure. 2117 */ 2118 static QDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle, 2119 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2120 struct stats_request_params *param) 2121 { 2122 int32_t ret; 2123 wmi_request_stats_cmd_fixed_param *cmd; 2124 wmi_buf_t buf; 2125 uint16_t len = sizeof(wmi_request_stats_cmd_fixed_param); 2126 2127 buf = wmi_buf_alloc(wmi_handle, len); 2128 if (!buf) 2129 return -QDF_STATUS_E_NOMEM; 2130 2131 cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf); 2132 WMITLV_SET_HDR(&cmd->tlv_header, 2133 WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param, 2134 WMITLV_GET_STRUCT_TLVLEN 2135 (wmi_request_stats_cmd_fixed_param)); 2136 cmd->stats_id = param->stats_id; 2137 cmd->vdev_id = param->vdev_id; 2138 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 2139 wmi_handle, 2140 param->pdev_id); 2141 2142 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr); 2143 2144 WMI_LOGD("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->", 2145 cmd->stats_id, cmd->vdev_id, cmd->pdev_id); 2146 2147 wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0); 2148 ret = wmi_unified_cmd_send_pm_chk(wmi_handle, buf, len, 2149 WMI_REQUEST_STATS_CMDID); 2150 2151 if (ret) { 2152 WMI_LOGE("Failed to send status request to fw =%d", ret); 2153 wmi_buf_free(buf); 2154 } 2155 2156 return ret; 2157 } 2158 2159 /** 2160 * send_peer_based_pktlog_cmd() - Send WMI command to enable packet-log 2161 * @wmi_handle: handle to WMI. 2162 * @macaddr: Peer mac address to be filter 2163 * @mac_id: mac id to have radio context 2164 * @enb_dsb: Enable MAC based filtering or Disable 2165 * 2166 * Return: QDF_STATUS 2167 */ 2168 static QDF_STATUS send_peer_based_pktlog_cmd(wmi_unified_t wmi_handle, 2169 uint8_t *macaddr, 2170 uint8_t mac_id, 2171 uint8_t enb_dsb) 2172 { 2173 int32_t ret; 2174 wmi_pdev_pktlog_filter_cmd_fixed_param *cmd; 2175 wmi_pdev_pktlog_filter_info *mac_info; 2176 wmi_buf_t buf; 2177 uint8_t *buf_ptr; 2178 uint16_t len = sizeof(wmi_pdev_pktlog_filter_cmd_fixed_param) + 2179 sizeof(wmi_pdev_pktlog_filter_info) + WMI_TLV_HDR_SIZE; 2180 2181 buf = wmi_buf_alloc(wmi_handle, len); 2182 if (!buf) 2183 return QDF_STATUS_E_NOMEM; 2184 2185 buf_ptr = (uint8_t *)wmi_buf_data(buf); 2186 cmd = (wmi_pdev_pktlog_filter_cmd_fixed_param *)buf_ptr; 2187 WMITLV_SET_HDR(&cmd->tlv_header, 2188 WMITLV_TAG_STRUC_wmi_pdev_pktlog_filter_cmd_fixed_param, 2189 WMITLV_GET_STRUCT_TLVLEN 2190 (wmi_pdev_pktlog_filter_cmd_fixed_param)); 2191 cmd->pdev_id = mac_id; 2192 cmd->enable = enb_dsb; 2193 cmd->num_of_mac_addresses = 1; 2194 wmi_mtrace(WMI_PDEV_PKTLOG_FILTER_CMDID, cmd->pdev_id, 0); 2195 2196 buf_ptr += sizeof(*cmd); 2197 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 2198 sizeof(wmi_pdev_pktlog_filter_info)); 2199 buf_ptr += WMI_TLV_HDR_SIZE; 2200 2201 mac_info = (wmi_pdev_pktlog_filter_info *)(buf_ptr); 2202 2203 WMITLV_SET_HDR(&mac_info->tlv_header, 2204 WMITLV_TAG_STRUC_wmi_pdev_pktlog_filter_info, 2205 WMITLV_GET_STRUCT_TLVLEN 2206 (wmi_pdev_pktlog_filter_info)); 2207 2208 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &mac_info->peer_mac_address); 2209 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 2210 WMI_PDEV_PKTLOG_FILTER_CMDID); 2211 if (ret) { 2212 WMI_LOGE("Failed to send peer based pktlog command to FW =%d" 2213 , ret); 2214 wmi_buf_free(buf); 2215 } 2216 2217 return ret; 2218 } 2219 2220 /** 2221 * send_packet_log_enable_cmd_tlv() - Send WMI command to enable packet-log 2222 * @param wmi_handle : handle to WMI. 2223 * @param PKTLOG_EVENT : packet log event 2224 * @mac_id: mac id to have radio context 2225 * 2226 * Return: 0 on success and -ve on failure. 2227 */ 2228 static QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle, 2229 WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id) 2230 { 2231 int32_t ret, idx, max_idx; 2232 wmi_pdev_pktlog_enable_cmd_fixed_param *cmd; 2233 wmi_buf_t buf; 2234 uint16_t len = sizeof(wmi_pdev_pktlog_enable_cmd_fixed_param); 2235 2236 buf = wmi_buf_alloc(wmi_handle, len); 2237 if (!buf) 2238 return -QDF_STATUS_E_NOMEM; 2239 2240 cmd = (wmi_pdev_pktlog_enable_cmd_fixed_param *) wmi_buf_data(buf); 2241 WMITLV_SET_HDR(&cmd->tlv_header, 2242 WMITLV_TAG_STRUC_wmi_pdev_pktlog_enable_cmd_fixed_param, 2243 WMITLV_GET_STRUCT_TLVLEN 2244 (wmi_pdev_pktlog_enable_cmd_fixed_param)); 2245 max_idx = sizeof(pktlog_event_tlv) / (sizeof(pktlog_event_tlv[0])); 2246 cmd->evlist = 0; 2247 for (idx = 0; idx < max_idx; idx++) { 2248 if (PKTLOG_EVENT & (1 << idx)) 2249 cmd->evlist |= pktlog_event_tlv[idx]; 2250 } 2251 cmd->pdev_id = mac_id; 2252 wmi_mtrace(WMI_PDEV_PKTLOG_ENABLE_CMDID, cmd->pdev_id, 0); 2253 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 2254 WMI_PDEV_PKTLOG_ENABLE_CMDID); 2255 if (ret) { 2256 WMI_LOGE("Failed to send pktlog enable cmd to FW =%d", ret); 2257 wmi_buf_free(buf); 2258 } 2259 2260 return ret; 2261 } 2262 2263 /** 2264 * send_packet_log_disable_cmd_tlv() - Send WMI command to disable packet-log 2265 * @param wmi_handle : handle to WMI. 2266 * @mac_id: mac id to have radio context 2267 * 2268 * Return: 0 on success and -ve on failure. 2269 */ 2270 static QDF_STATUS send_packet_log_disable_cmd_tlv(wmi_unified_t wmi_handle, 2271 uint8_t mac_id) 2272 { 2273 int32_t ret; 2274 wmi_pdev_pktlog_disable_cmd_fixed_param *cmd; 2275 wmi_buf_t buf; 2276 uint16_t len = sizeof(wmi_pdev_pktlog_disable_cmd_fixed_param); 2277 2278 buf = wmi_buf_alloc(wmi_handle, len); 2279 if (!buf) 2280 return -QDF_STATUS_E_NOMEM; 2281 2282 cmd = (wmi_pdev_pktlog_disable_cmd_fixed_param *) wmi_buf_data(buf); 2283 WMITLV_SET_HDR(&cmd->tlv_header, 2284 WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param, 2285 WMITLV_GET_STRUCT_TLVLEN 2286 (wmi_pdev_pktlog_disable_cmd_fixed_param)); 2287 cmd->pdev_id = mac_id; 2288 wmi_mtrace(WMI_PDEV_PKTLOG_DISABLE_CMDID, cmd->pdev_id, 0); 2289 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 2290 WMI_PDEV_PKTLOG_DISABLE_CMDID); 2291 if (ret) { 2292 WMI_LOGE("Failed to send pktlog disable cmd to FW =%d", ret); 2293 wmi_buf_free(buf); 2294 } 2295 2296 return ret; 2297 } 2298 2299 #define WMI_FW_TIME_STAMP_LOW_MASK 0xffffffff 2300 /** 2301 * send_time_stamp_sync_cmd_tlv() - Send WMI command to 2302 * sync time between bwtween host and firmware 2303 * @param wmi_handle : handle to WMI. 2304 * 2305 * Return: None 2306 */ 2307 static void send_time_stamp_sync_cmd_tlv(wmi_unified_t wmi_handle) 2308 { 2309 wmi_buf_t buf; 2310 QDF_STATUS status = QDF_STATUS_SUCCESS; 2311 WMI_DBGLOG_TIME_STAMP_SYNC_CMD_fixed_param *time_stamp; 2312 int32_t len; 2313 qdf_time_t time_ms; 2314 2315 len = sizeof(*time_stamp); 2316 buf = wmi_buf_alloc(wmi_handle, len); 2317 2318 if (!buf) 2319 return; 2320 2321 time_stamp = 2322 (WMI_DBGLOG_TIME_STAMP_SYNC_CMD_fixed_param *) 2323 (wmi_buf_data(buf)); 2324 WMITLV_SET_HDR(&time_stamp->tlv_header, 2325 WMITLV_TAG_STRUC_wmi_dbglog_time_stamp_sync_cmd_fixed_param, 2326 WMITLV_GET_STRUCT_TLVLEN( 2327 WMI_DBGLOG_TIME_STAMP_SYNC_CMD_fixed_param)); 2328 2329 time_ms = qdf_get_time_of_the_day_ms(); 2330 time_stamp->mode = WMI_TIME_STAMP_SYNC_MODE_MS; 2331 time_stamp->time_stamp_low = time_ms & 2332 WMI_FW_TIME_STAMP_LOW_MASK; 2333 /* 2334 * Send time_stamp_high 0 as the time converted from HR:MIN:SEC:MS to ms 2335 * wont exceed 27 bit 2336 */ 2337 time_stamp->time_stamp_high = 0; 2338 WMI_LOGD(FL("WMA --> DBGLOG_TIME_STAMP_SYNC_CMDID mode %d time_stamp low %d high %d"), 2339 time_stamp->mode, time_stamp->time_stamp_low, 2340 time_stamp->time_stamp_high); 2341 2342 wmi_mtrace(WMI_DBGLOG_TIME_STAMP_SYNC_CMDID, NO_SESSION, 0); 2343 status = wmi_unified_cmd_send(wmi_handle, buf, 2344 len, WMI_DBGLOG_TIME_STAMP_SYNC_CMDID); 2345 if (status) { 2346 WMI_LOGE("Failed to send WMI_DBGLOG_TIME_STAMP_SYNC_CMDID command"); 2347 wmi_buf_free(buf); 2348 } 2349 2350 } 2351 2352 /** 2353 * send_fd_tmpl_cmd_tlv() - WMI FILS Discovery send function 2354 * @param wmi_handle : handle to WMI. 2355 * @param param : pointer to hold FILS Discovery send cmd parameter 2356 * 2357 * Return: 0 on success and -ve on failure. 2358 */ 2359 static QDF_STATUS send_fd_tmpl_cmd_tlv(wmi_unified_t wmi_handle, 2360 struct fils_discovery_tmpl_params *param) 2361 { 2362 int32_t ret; 2363 wmi_fd_tmpl_cmd_fixed_param *cmd; 2364 wmi_buf_t wmi_buf; 2365 uint8_t *buf_ptr; 2366 uint32_t wmi_buf_len; 2367 2368 wmi_buf_len = sizeof(wmi_fd_tmpl_cmd_fixed_param) + 2369 WMI_TLV_HDR_SIZE + param->tmpl_len_aligned; 2370 wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); 2371 if (!wmi_buf) 2372 return QDF_STATUS_E_NOMEM; 2373 2374 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 2375 cmd = (wmi_fd_tmpl_cmd_fixed_param *) buf_ptr; 2376 WMITLV_SET_HDR(&cmd->tlv_header, 2377 WMITLV_TAG_STRUC_wmi_fd_tmpl_cmd_fixed_param, 2378 WMITLV_GET_STRUCT_TLVLEN(wmi_fd_tmpl_cmd_fixed_param)); 2379 cmd->vdev_id = param->vdev_id; 2380 cmd->buf_len = param->tmpl_len; 2381 buf_ptr += sizeof(wmi_fd_tmpl_cmd_fixed_param); 2382 2383 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->tmpl_len_aligned); 2384 buf_ptr += WMI_TLV_HDR_SIZE; 2385 qdf_mem_copy(buf_ptr, param->frm, param->tmpl_len); 2386 2387 wmi_mtrace(WMI_FD_TMPL_CMDID, cmd->vdev_id, 0); 2388 ret = wmi_unified_cmd_send(wmi_handle, 2389 wmi_buf, wmi_buf_len, WMI_FD_TMPL_CMDID); 2390 2391 if (ret) { 2392 WMI_LOGE("%s: Failed to send fd tmpl: %d", __func__, ret); 2393 wmi_buf_free(wmi_buf); 2394 return ret; 2395 } 2396 2397 return 0; 2398 } 2399 2400 /** 2401 * send_beacon_send_tmpl_cmd_tlv() - WMI beacon send function 2402 * @param wmi_handle : handle to WMI. 2403 * @param param : pointer to hold beacon send cmd parameter 2404 * 2405 * Return: 0 on success and -ve on failure. 2406 */ 2407 static QDF_STATUS send_beacon_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle, 2408 struct beacon_tmpl_params *param) 2409 { 2410 int32_t ret; 2411 wmi_bcn_tmpl_cmd_fixed_param *cmd; 2412 wmi_bcn_prb_info *bcn_prb_info; 2413 wmi_buf_t wmi_buf; 2414 uint8_t *buf_ptr; 2415 uint32_t wmi_buf_len; 2416 2417 wmi_buf_len = sizeof(wmi_bcn_tmpl_cmd_fixed_param) + 2418 sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE + 2419 param->tmpl_len_aligned; 2420 wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); 2421 if (!wmi_buf) 2422 return QDF_STATUS_E_NOMEM; 2423 2424 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 2425 cmd = (wmi_bcn_tmpl_cmd_fixed_param *) buf_ptr; 2426 WMITLV_SET_HDR(&cmd->tlv_header, 2427 WMITLV_TAG_STRUC_wmi_bcn_tmpl_cmd_fixed_param, 2428 WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_tmpl_cmd_fixed_param)); 2429 cmd->vdev_id = param->vdev_id; 2430 cmd->tim_ie_offset = param->tim_ie_offset; 2431 cmd->mbssid_ie_offset = param->mbssid_ie_offset; 2432 cmd->csa_switch_count_offset = param->csa_switch_count_offset; 2433 cmd->ext_csa_switch_count_offset = param->ext_csa_switch_count_offset; 2434 cmd->esp_ie_offset = param->esp_ie_offset; 2435 cmd->mu_edca_ie_offset = param->mu_edca_ie_offset; 2436 cmd->ema_params = param->ema_params; 2437 cmd->buf_len = param->tmpl_len; 2438 2439 WMI_BEACON_PROTECTION_EN_SET(cmd->feature_enable_bitmap, 2440 param->enable_bigtk); 2441 buf_ptr += sizeof(wmi_bcn_tmpl_cmd_fixed_param); 2442 2443 bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr; 2444 WMITLV_SET_HDR(&bcn_prb_info->tlv_header, 2445 WMITLV_TAG_STRUC_wmi_bcn_prb_info, 2446 WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info)); 2447 bcn_prb_info->caps = 0; 2448 bcn_prb_info->erp = 0; 2449 buf_ptr += sizeof(wmi_bcn_prb_info); 2450 2451 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->tmpl_len_aligned); 2452 buf_ptr += WMI_TLV_HDR_SIZE; 2453 qdf_mem_copy(buf_ptr, param->frm, param->tmpl_len); 2454 2455 wmi_mtrace(WMI_BCN_TMPL_CMDID, cmd->vdev_id, 0); 2456 ret = wmi_unified_cmd_send(wmi_handle, 2457 wmi_buf, wmi_buf_len, WMI_BCN_TMPL_CMDID); 2458 if (ret) { 2459 WMI_LOGE("%s: Failed to send bcn tmpl: %d", __func__, ret); 2460 wmi_buf_free(wmi_buf); 2461 } 2462 2463 return 0; 2464 } 2465 2466 static inline void copy_peer_flags_tlv( 2467 wmi_peer_assoc_complete_cmd_fixed_param * cmd, 2468 struct peer_assoc_params *param) 2469 { 2470 /* 2471 * The target only needs a subset of the flags maintained in the host. 2472 * Just populate those flags and send it down 2473 */ 2474 cmd->peer_flags = 0; 2475 2476 /* 2477 * Do not enable HT/VHT if WMM/wme is disabled for vap. 2478 */ 2479 if (param->is_wme_set) { 2480 2481 if (param->qos_flag) 2482 cmd->peer_flags |= WMI_PEER_QOS; 2483 if (param->apsd_flag) 2484 cmd->peer_flags |= WMI_PEER_APSD; 2485 if (param->ht_flag) 2486 cmd->peer_flags |= WMI_PEER_HT; 2487 if (param->bw_40) 2488 cmd->peer_flags |= WMI_PEER_40MHZ; 2489 if (param->bw_80) 2490 cmd->peer_flags |= WMI_PEER_80MHZ; 2491 if (param->bw_160) 2492 cmd->peer_flags |= WMI_PEER_160MHZ; 2493 2494 /* Typically if STBC is enabled for VHT it should be enabled 2495 * for HT as well 2496 **/ 2497 if (param->stbc_flag) 2498 cmd->peer_flags |= WMI_PEER_STBC; 2499 2500 /* Typically if LDPC is enabled for VHT it should be enabled 2501 * for HT as well 2502 **/ 2503 if (param->ldpc_flag) 2504 cmd->peer_flags |= WMI_PEER_LDPC; 2505 2506 if (param->static_mimops_flag) 2507 cmd->peer_flags |= WMI_PEER_STATIC_MIMOPS; 2508 if (param->dynamic_mimops_flag) 2509 cmd->peer_flags |= WMI_PEER_DYN_MIMOPS; 2510 if (param->spatial_mux_flag) 2511 cmd->peer_flags |= WMI_PEER_SPATIAL_MUX; 2512 if (param->vht_flag) 2513 cmd->peer_flags |= WMI_PEER_VHT; 2514 if (param->he_flag) 2515 cmd->peer_flags |= WMI_PEER_HE; 2516 if (param->p2p_capable_sta) 2517 cmd->peer_flags |= WMI_PEER_IS_P2P_CAPABLE; 2518 } 2519 2520 if (param->is_pmf_enabled) 2521 cmd->peer_flags |= WMI_PEER_PMF; 2522 /* 2523 * Suppress authorization for all AUTH modes that need 4-way handshake 2524 * (during re-association). 2525 * Authorization will be done for these modes on key installation. 2526 */ 2527 if (param->auth_flag) 2528 cmd->peer_flags |= WMI_PEER_AUTH; 2529 if (param->need_ptk_4_way) 2530 cmd->peer_flags |= WMI_PEER_NEED_PTK_4_WAY; 2531 else 2532 cmd->peer_flags &= ~WMI_PEER_NEED_PTK_4_WAY; 2533 if (param->need_gtk_2_way) 2534 cmd->peer_flags |= WMI_PEER_NEED_GTK_2_WAY; 2535 /* safe mode bypass the 4-way handshake */ 2536 if (param->safe_mode_enabled) 2537 cmd->peer_flags &= 2538 ~(WMI_PEER_NEED_PTK_4_WAY | WMI_PEER_NEED_GTK_2_WAY); 2539 /* inter BSS peer */ 2540 if (param->inter_bss_peer) 2541 cmd->peer_flags |= WMI_PEER_INTER_BSS_PEER; 2542 /* Disable AMSDU for station transmit, if user configures it */ 2543 /* Disable AMSDU for AP transmit to 11n Stations, if user configures 2544 * it 2545 * if (param->amsdu_disable) Add after FW support 2546 **/ 2547 2548 /* Target asserts if node is marked HT and all MCS is set to 0. 2549 * Mark the node as non-HT if all the mcs rates are disabled through 2550 * iwpriv 2551 **/ 2552 if (param->peer_ht_rates.num_rates == 0) 2553 cmd->peer_flags &= ~WMI_PEER_HT; 2554 2555 if (param->twt_requester) 2556 cmd->peer_flags |= WMI_PEER_TWT_REQ; 2557 2558 if (param->twt_responder) 2559 cmd->peer_flags |= WMI_PEER_TWT_RESP; 2560 } 2561 2562 static inline void copy_peer_mac_addr_tlv( 2563 wmi_peer_assoc_complete_cmd_fixed_param * cmd, 2564 struct peer_assoc_params *param) 2565 { 2566 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_mac, &cmd->peer_macaddr); 2567 } 2568 2569 /** 2570 * send_peer_assoc_cmd_tlv() - WMI peer assoc function 2571 * @param wmi_handle : handle to WMI. 2572 * @param param : pointer to peer assoc parameter 2573 * 2574 * Return: 0 on success and -ve on failure. 2575 */ 2576 static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle, 2577 struct peer_assoc_params *param) 2578 { 2579 wmi_peer_assoc_complete_cmd_fixed_param *cmd; 2580 wmi_vht_rate_set *mcs; 2581 wmi_he_rate_set *he_mcs; 2582 wmi_buf_t buf; 2583 int32_t len; 2584 uint8_t *buf_ptr; 2585 QDF_STATUS ret; 2586 uint32_t peer_legacy_rates_align; 2587 uint32_t peer_ht_rates_align; 2588 int32_t i; 2589 2590 2591 peer_legacy_rates_align = wmi_align(param->peer_legacy_rates.num_rates); 2592 peer_ht_rates_align = wmi_align(param->peer_ht_rates.num_rates); 2593 2594 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + 2595 (peer_legacy_rates_align * sizeof(uint8_t)) + 2596 WMI_TLV_HDR_SIZE + 2597 (peer_ht_rates_align * sizeof(uint8_t)) + 2598 sizeof(wmi_vht_rate_set) + 2599 (sizeof(wmi_he_rate_set) * param->peer_he_mcs_count 2600 + WMI_TLV_HDR_SIZE); 2601 2602 buf = wmi_buf_alloc(wmi_handle, len); 2603 if (!buf) 2604 return QDF_STATUS_E_NOMEM; 2605 2606 buf_ptr = (uint8_t *) wmi_buf_data(buf); 2607 cmd = (wmi_peer_assoc_complete_cmd_fixed_param *) buf_ptr; 2608 WMITLV_SET_HDR(&cmd->tlv_header, 2609 WMITLV_TAG_STRUC_wmi_peer_assoc_complete_cmd_fixed_param, 2610 WMITLV_GET_STRUCT_TLVLEN 2611 (wmi_peer_assoc_complete_cmd_fixed_param)); 2612 2613 cmd->vdev_id = param->vdev_id; 2614 2615 cmd->peer_new_assoc = param->peer_new_assoc; 2616 cmd->peer_associd = param->peer_associd; 2617 2618 copy_peer_flags_tlv(cmd, param); 2619 copy_peer_mac_addr_tlv(cmd, param); 2620 2621 cmd->peer_rate_caps = param->peer_rate_caps; 2622 cmd->peer_caps = param->peer_caps; 2623 cmd->peer_listen_intval = param->peer_listen_intval; 2624 cmd->peer_ht_caps = param->peer_ht_caps; 2625 cmd->peer_max_mpdu = param->peer_max_mpdu; 2626 cmd->peer_mpdu_density = param->peer_mpdu_density; 2627 cmd->peer_vht_caps = param->peer_vht_caps; 2628 cmd->peer_phymode = param->peer_phymode; 2629 2630 /* Update 11ax capabilities */ 2631 cmd->peer_he_cap_info = 2632 param->peer_he_cap_macinfo[WMI_HOST_HECAP_MAC_WORD1]; 2633 cmd->peer_he_cap_info_ext = 2634 param->peer_he_cap_macinfo[WMI_HOST_HECAP_MAC_WORD2]; 2635 cmd->peer_he_cap_info_internal = param->peer_he_cap_info_internal; 2636 cmd->peer_he_ops = param->peer_he_ops; 2637 qdf_mem_copy(&cmd->peer_he_cap_phy, ¶m->peer_he_cap_phyinfo, 2638 sizeof(param->peer_he_cap_phyinfo)); 2639 qdf_mem_copy(&cmd->peer_ppet, ¶m->peer_ppet, 2640 sizeof(param->peer_ppet)); 2641 cmd->peer_he_caps_6ghz = param->peer_he_caps_6ghz; 2642 2643 /* Update peer legacy rate information */ 2644 buf_ptr += sizeof(*cmd); 2645 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 2646 peer_legacy_rates_align); 2647 buf_ptr += WMI_TLV_HDR_SIZE; 2648 cmd->num_peer_legacy_rates = param->peer_legacy_rates.num_rates; 2649 qdf_mem_copy(buf_ptr, param->peer_legacy_rates.rates, 2650 param->peer_legacy_rates.num_rates); 2651 2652 /* Update peer HT rate information */ 2653 buf_ptr += peer_legacy_rates_align; 2654 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 2655 peer_ht_rates_align); 2656 buf_ptr += WMI_TLV_HDR_SIZE; 2657 cmd->num_peer_ht_rates = param->peer_ht_rates.num_rates; 2658 qdf_mem_copy(buf_ptr, param->peer_ht_rates.rates, 2659 param->peer_ht_rates.num_rates); 2660 2661 /* VHT Rates */ 2662 buf_ptr += peer_ht_rates_align; 2663 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_wmi_vht_rate_set, 2664 WMITLV_GET_STRUCT_TLVLEN(wmi_vht_rate_set)); 2665 2666 cmd->peer_nss = param->peer_nss; 2667 2668 /* Update bandwidth-NSS mapping */ 2669 cmd->peer_bw_rxnss_override = 0; 2670 cmd->peer_bw_rxnss_override |= param->peer_bw_rxnss_override; 2671 2672 mcs = (wmi_vht_rate_set *) buf_ptr; 2673 if (param->vht_capable) { 2674 mcs->rx_max_rate = param->rx_max_rate; 2675 mcs->rx_mcs_set = param->rx_mcs_set; 2676 mcs->tx_max_rate = param->tx_max_rate; 2677 mcs->tx_mcs_set = param->tx_mcs_set; 2678 } 2679 2680 /* HE Rates */ 2681 cmd->min_data_rate = param->min_data_rate; 2682 cmd->peer_he_mcs = param->peer_he_mcs_count; 2683 buf_ptr += sizeof(wmi_vht_rate_set); 2684 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 2685 (param->peer_he_mcs_count * sizeof(wmi_he_rate_set))); 2686 buf_ptr += WMI_TLV_HDR_SIZE; 2687 2688 /* Loop through the HE rate set */ 2689 for (i = 0; i < param->peer_he_mcs_count; i++) { 2690 he_mcs = (wmi_he_rate_set *) buf_ptr; 2691 WMITLV_SET_HDR(he_mcs, WMITLV_TAG_STRUC_wmi_he_rate_set, 2692 WMITLV_GET_STRUCT_TLVLEN(wmi_he_rate_set)); 2693 2694 he_mcs->rx_mcs_set = param->peer_he_rx_mcs_set[i]; 2695 he_mcs->tx_mcs_set = param->peer_he_tx_mcs_set[i]; 2696 WMI_LOGD("%s:HE idx %d RxMCSmap %x TxMCSmap %x ", __func__, 2697 i, he_mcs->rx_mcs_set, he_mcs->tx_mcs_set); 2698 buf_ptr += sizeof(wmi_he_rate_set); 2699 } 2700 2701 if ((param->he_flag) && (param->peer_he_mcs_count > 1) && 2702 (param->peer_he_rx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160] 2703 == WMI_HOST_HE_INVALID_MCSNSSMAP || 2704 param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160] 2705 == WMI_HOST_HE_INVALID_MCSNSSMAP)) { 2706 WMI_LOGD("param->peer_he_tx_mcs_set[160MHz]=%x", 2707 param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]); 2708 WMI_LOGD("param->peer_he_rx_mcs_set[160MHz]=%x", 2709 param->peer_he_rx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]); 2710 WMI_LOGD("peer_mac=%02x:%02x:%02x:%02x:%02x:%02x", 2711 param->peer_mac[0], param->peer_mac[1], 2712 param->peer_mac[2], param->peer_mac[3], 2713 param->peer_mac[4], param->peer_mac[5]); 2714 } 2715 2716 WMI_LOGD("%s: vdev_id %d associd %d peer_flags %x rate_caps %x " 2717 "peer_caps %x listen_intval %d ht_caps %x max_mpdu %d " 2718 "nss %d phymode %d peer_mpdu_density %d " 2719 "cmd->peer_vht_caps %x " 2720 "HE cap_info %x ops %x " 2721 "HE cap_info_ext %x " 2722 "HE phy %x %x %x " 2723 "peer_bw_rxnss_override %x", __func__, 2724 cmd->vdev_id, cmd->peer_associd, cmd->peer_flags, 2725 cmd->peer_rate_caps, cmd->peer_caps, 2726 cmd->peer_listen_intval, cmd->peer_ht_caps, 2727 cmd->peer_max_mpdu, cmd->peer_nss, cmd->peer_phymode, 2728 cmd->peer_mpdu_density, 2729 cmd->peer_vht_caps, cmd->peer_he_cap_info, 2730 cmd->peer_he_ops, cmd->peer_he_cap_info_ext, 2731 cmd->peer_he_cap_phy[0], cmd->peer_he_cap_phy[1], 2732 cmd->peer_he_cap_phy[2], 2733 cmd->peer_bw_rxnss_override); 2734 2735 wmi_mtrace(WMI_PEER_ASSOC_CMDID, cmd->vdev_id, 0); 2736 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 2737 WMI_PEER_ASSOC_CMDID); 2738 if (QDF_IS_STATUS_ERROR(ret)) { 2739 WMI_LOGP("%s: Failed to send peer assoc command ret = %d", 2740 __func__, ret); 2741 wmi_buf_free(buf); 2742 } 2743 2744 return ret; 2745 } 2746 2747 /* copy_scan_notify_events() - Helper routine to copy scan notify events 2748 */ 2749 static inline void copy_scan_event_cntrl_flags( 2750 wmi_start_scan_cmd_fixed_param * cmd, 2751 struct scan_req_params *param) 2752 { 2753 2754 /* Scan events subscription */ 2755 if (param->scan_ev_started) 2756 cmd->notify_scan_events |= WMI_SCAN_EVENT_STARTED; 2757 if (param->scan_ev_completed) 2758 cmd->notify_scan_events |= WMI_SCAN_EVENT_COMPLETED; 2759 if (param->scan_ev_bss_chan) 2760 cmd->notify_scan_events |= WMI_SCAN_EVENT_BSS_CHANNEL; 2761 if (param->scan_ev_foreign_chan) 2762 cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL; 2763 if (param->scan_ev_dequeued) 2764 cmd->notify_scan_events |= WMI_SCAN_EVENT_DEQUEUED; 2765 if (param->scan_ev_preempted) 2766 cmd->notify_scan_events |= WMI_SCAN_EVENT_PREEMPTED; 2767 if (param->scan_ev_start_failed) 2768 cmd->notify_scan_events |= WMI_SCAN_EVENT_START_FAILED; 2769 if (param->scan_ev_restarted) 2770 cmd->notify_scan_events |= WMI_SCAN_EVENT_RESTARTED; 2771 if (param->scan_ev_foreign_chn_exit) 2772 cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT; 2773 if (param->scan_ev_suspended) 2774 cmd->notify_scan_events |= WMI_SCAN_EVENT_SUSPENDED; 2775 if (param->scan_ev_resumed) 2776 cmd->notify_scan_events |= WMI_SCAN_EVENT_RESUMED; 2777 2778 /** Set scan control flags */ 2779 cmd->scan_ctrl_flags = 0; 2780 if (param->scan_f_passive) 2781 cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 2782 if (param->scan_f_strict_passive_pch) 2783 cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN; 2784 if (param->scan_f_promisc_mode) 2785 cmd->scan_ctrl_flags |= WMI_SCAN_FILTER_PROMISCOUS; 2786 if (param->scan_f_capture_phy_err) 2787 cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR; 2788 if (param->scan_f_half_rate) 2789 cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT; 2790 if (param->scan_f_quarter_rate) 2791 cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT; 2792 if (param->scan_f_cck_rates) 2793 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES; 2794 if (param->scan_f_ofdm_rates) 2795 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES; 2796 if (param->scan_f_chan_stat_evnt) 2797 cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT; 2798 if (param->scan_f_filter_prb_req) 2799 cmd->scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 2800 if (param->scan_f_bcast_probe) 2801 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ; 2802 if (param->scan_f_offchan_mgmt_tx) 2803 cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX; 2804 if (param->scan_f_offchan_data_tx) 2805 cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX; 2806 if (param->scan_f_force_active_dfs_chn) 2807 cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS; 2808 if (param->scan_f_add_tpc_ie_in_probe) 2809 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ; 2810 if (param->scan_f_add_ds_ie_in_probe) 2811 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ; 2812 if (param->scan_f_add_spoofed_mac_in_probe) 2813 cmd->scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ; 2814 if (param->scan_f_add_rand_seq_in_probe) 2815 cmd->scan_ctrl_flags |= WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ; 2816 if (param->scan_f_en_ie_whitelist_in_probe) 2817 cmd->scan_ctrl_flags |= 2818 WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ; 2819 2820 /* for adaptive scan mode using 3 bits (21 - 23 bits) */ 2821 WMI_SCAN_SET_DWELL_MODE(cmd->scan_ctrl_flags, 2822 param->adaptive_dwell_time_mode); 2823 } 2824 2825 /* scan_copy_ie_buffer() - Copy scan ie_data */ 2826 static inline void scan_copy_ie_buffer(uint8_t *buf_ptr, 2827 struct scan_req_params *params) 2828 { 2829 qdf_mem_copy(buf_ptr, params->extraie.ptr, params->extraie.len); 2830 } 2831 2832 /** 2833 * wmi_copy_scan_random_mac() - To copy scan randomization attrs to wmi buffer 2834 * @mac: random mac addr 2835 * @mask: random mac mask 2836 * @mac_addr: wmi random mac 2837 * @mac_mask: wmi random mac mask 2838 * 2839 * Return None. 2840 */ 2841 static inline 2842 void wmi_copy_scan_random_mac(uint8_t *mac, uint8_t *mask, 2843 wmi_mac_addr *mac_addr, wmi_mac_addr *mac_mask) 2844 { 2845 WMI_CHAR_ARRAY_TO_MAC_ADDR(mac, mac_addr); 2846 WMI_CHAR_ARRAY_TO_MAC_ADDR(mask, mac_mask); 2847 } 2848 2849 /* 2850 * wmi_fill_vendor_oui() - fill vendor OUIs 2851 * @buf_ptr: pointer to wmi tlv buffer 2852 * @num_vendor_oui: number of vendor OUIs to be filled 2853 * @param_voui: pointer to OUI buffer 2854 * 2855 * This function populates the wmi tlv buffer when vendor specific OUIs are 2856 * present. 2857 * 2858 * Return: None 2859 */ 2860 static inline 2861 void wmi_fill_vendor_oui(uint8_t *buf_ptr, uint32_t num_vendor_oui, 2862 uint32_t *pvoui) 2863 { 2864 wmi_vendor_oui *voui = NULL; 2865 uint32_t i; 2866 2867 voui = (wmi_vendor_oui *)buf_ptr; 2868 2869 for (i = 0; i < num_vendor_oui; i++) { 2870 WMITLV_SET_HDR(&voui[i].tlv_header, 2871 WMITLV_TAG_STRUC_wmi_vendor_oui, 2872 WMITLV_GET_STRUCT_TLVLEN(wmi_vendor_oui)); 2873 voui[i].oui_type_subtype = pvoui[i]; 2874 } 2875 } 2876 2877 /* 2878 * wmi_fill_ie_whitelist_attrs() - fill IE whitelist attrs 2879 * @ie_bitmap: output pointer to ie bit map in cmd 2880 * @num_vendor_oui: output pointer to num vendor OUIs 2881 * @ie_whitelist: input parameter 2882 * 2883 * This function populates the IE whitelist attrs of scan, pno and 2884 * scan oui commands for ie_whitelist parameter. 2885 * 2886 * Return: None 2887 */ 2888 static inline 2889 void wmi_fill_ie_whitelist_attrs(uint32_t *ie_bitmap, 2890 uint32_t *num_vendor_oui, 2891 struct probe_req_whitelist_attr *ie_whitelist) 2892 { 2893 uint32_t i = 0; 2894 2895 for (i = 0; i < PROBE_REQ_BITMAP_LEN; i++) 2896 ie_bitmap[i] = ie_whitelist->ie_bitmap[i]; 2897 2898 *num_vendor_oui = ie_whitelist->num_vendor_oui; 2899 } 2900 2901 /** 2902 * send_scan_start_cmd_tlv() - WMI scan start function 2903 * @param wmi_handle : handle to WMI. 2904 * @param param : pointer to hold scan start cmd parameter 2905 * 2906 * Return: 0 on success and -ve on failure. 2907 */ 2908 static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle, 2909 struct scan_req_params *params) 2910 { 2911 int32_t ret = 0; 2912 int32_t i; 2913 wmi_buf_t wmi_buf; 2914 wmi_start_scan_cmd_fixed_param *cmd; 2915 uint8_t *buf_ptr; 2916 uint32_t *tmp_ptr; 2917 wmi_ssid *ssid = NULL; 2918 wmi_mac_addr *bssid; 2919 size_t len = sizeof(*cmd); 2920 uint16_t extraie_len_with_pad = 0; 2921 uint8_t phymode_roundup = 0; 2922 struct probe_req_whitelist_attr *ie_whitelist = ¶ms->ie_whitelist; 2923 wmi_hint_freq_short_ssid *s_ssid = NULL; 2924 wmi_hint_freq_bssid *hint_bssid = NULL; 2925 2926 /* Length TLV placeholder for array of uint32_t */ 2927 len += WMI_TLV_HDR_SIZE; 2928 /* calculate the length of buffer required */ 2929 if (params->chan_list.num_chan) 2930 len += params->chan_list.num_chan * sizeof(uint32_t); 2931 2932 /* Length TLV placeholder for array of wmi_ssid structures */ 2933 len += WMI_TLV_HDR_SIZE; 2934 if (params->num_ssids) 2935 len += params->num_ssids * sizeof(wmi_ssid); 2936 2937 /* Length TLV placeholder for array of wmi_mac_addr structures */ 2938 len += WMI_TLV_HDR_SIZE; 2939 if (params->num_bssid) 2940 len += sizeof(wmi_mac_addr) * params->num_bssid; 2941 2942 /* Length TLV placeholder for array of bytes */ 2943 len += WMI_TLV_HDR_SIZE; 2944 if (params->extraie.len) 2945 extraie_len_with_pad = 2946 roundup(params->extraie.len, sizeof(uint32_t)); 2947 len += extraie_len_with_pad; 2948 2949 len += WMI_TLV_HDR_SIZE; /* Length of TLV for array of wmi_vendor_oui */ 2950 if (ie_whitelist->num_vendor_oui) 2951 len += ie_whitelist->num_vendor_oui * sizeof(wmi_vendor_oui); 2952 2953 len += WMI_TLV_HDR_SIZE; /* Length of TLV for array of scan phymode */ 2954 if (params->scan_f_wide_band) 2955 phymode_roundup = 2956 qdf_roundup(params->chan_list.num_chan * sizeof(uint8_t), 2957 sizeof(uint32_t)); 2958 len += phymode_roundup; 2959 2960 len += WMI_TLV_HDR_SIZE; 2961 if (params->num_hint_bssid) 2962 len += params->num_hint_bssid * sizeof(wmi_hint_freq_bssid); 2963 2964 len += WMI_TLV_HDR_SIZE; 2965 if (params->num_hint_s_ssid) 2966 len += params->num_hint_s_ssid * sizeof(wmi_hint_freq_short_ssid); 2967 2968 /* Allocate the memory */ 2969 wmi_buf = wmi_buf_alloc(wmi_handle, len); 2970 if (!wmi_buf) 2971 return QDF_STATUS_E_FAILURE; 2972 2973 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 2974 cmd = (wmi_start_scan_cmd_fixed_param *) buf_ptr; 2975 WMITLV_SET_HDR(&cmd->tlv_header, 2976 WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param, 2977 WMITLV_GET_STRUCT_TLVLEN 2978 (wmi_start_scan_cmd_fixed_param)); 2979 2980 cmd->scan_id = params->scan_id; 2981 cmd->scan_req_id = params->scan_req_id; 2982 cmd->vdev_id = params->vdev_id; 2983 cmd->scan_priority = params->scan_priority; 2984 2985 copy_scan_event_cntrl_flags(cmd, params); 2986 2987 cmd->dwell_time_active = params->dwell_time_active; 2988 cmd->dwell_time_active_2g = params->dwell_time_active_2g; 2989 cmd->dwell_time_passive = params->dwell_time_passive; 2990 cmd->dwell_time_active_6ghz = params->dwell_time_active_6g; 2991 cmd->dwell_time_passive_6ghz = params->dwell_time_passive_6g; 2992 cmd->scan_start_offset = params->scan_offset_time; 2993 cmd->min_rest_time = params->min_rest_time; 2994 cmd->max_rest_time = params->max_rest_time; 2995 cmd->repeat_probe_time = params->repeat_probe_time; 2996 cmd->probe_spacing_time = params->probe_spacing_time; 2997 cmd->idle_time = params->idle_time; 2998 cmd->max_scan_time = params->max_scan_time; 2999 cmd->probe_delay = params->probe_delay; 3000 cmd->burst_duration = params->burst_duration; 3001 cmd->num_chan = params->chan_list.num_chan; 3002 cmd->num_bssid = params->num_bssid; 3003 cmd->num_ssids = params->num_ssids; 3004 cmd->ie_len = params->extraie.len; 3005 cmd->n_probes = params->n_probes; 3006 cmd->scan_ctrl_flags_ext = params->scan_ctrl_flags_ext; 3007 3008 if (params->scan_random.randomize) 3009 wmi_copy_scan_random_mac(params->scan_random.mac_addr, 3010 params->scan_random.mac_mask, 3011 &cmd->mac_addr, 3012 &cmd->mac_mask); 3013 3014 if (ie_whitelist->white_list) 3015 wmi_fill_ie_whitelist_attrs(cmd->ie_bitmap, 3016 &cmd->num_vendor_oui, 3017 ie_whitelist); 3018 3019 buf_ptr += sizeof(*cmd); 3020 tmp_ptr = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 3021 for (i = 0; i < params->chan_list.num_chan; ++i) 3022 tmp_ptr[i] = params->chan_list.chan[i].freq; 3023 3024 WMITLV_SET_HDR(buf_ptr, 3025 WMITLV_TAG_ARRAY_UINT32, 3026 (params->chan_list.num_chan * sizeof(uint32_t))); 3027 buf_ptr += WMI_TLV_HDR_SIZE + 3028 (params->chan_list.num_chan * sizeof(uint32_t)); 3029 3030 if (params->num_ssids > WLAN_SCAN_MAX_NUM_SSID) { 3031 WMI_LOGE("Invalid value for num_ssids %d", params->num_ssids); 3032 goto error; 3033 } 3034 3035 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC, 3036 (params->num_ssids * sizeof(wmi_ssid))); 3037 3038 if (params->num_ssids) { 3039 ssid = (wmi_ssid *) (buf_ptr + WMI_TLV_HDR_SIZE); 3040 for (i = 0; i < params->num_ssids; ++i) { 3041 ssid->ssid_len = params->ssid[i].length; 3042 qdf_mem_copy(ssid->ssid, params->ssid[i].ssid, 3043 params->ssid[i].length); 3044 ssid++; 3045 } 3046 } 3047 buf_ptr += WMI_TLV_HDR_SIZE + (params->num_ssids * sizeof(wmi_ssid)); 3048 3049 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC, 3050 (params->num_bssid * sizeof(wmi_mac_addr))); 3051 bssid = (wmi_mac_addr *) (buf_ptr + WMI_TLV_HDR_SIZE); 3052 3053 if (params->num_bssid) { 3054 for (i = 0; i < params->num_bssid; ++i) { 3055 WMI_CHAR_ARRAY_TO_MAC_ADDR( 3056 ¶ms->bssid_list[i].bytes[0], bssid); 3057 bssid++; 3058 } 3059 } 3060 3061 buf_ptr += WMI_TLV_HDR_SIZE + 3062 (params->num_bssid * sizeof(wmi_mac_addr)); 3063 3064 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, extraie_len_with_pad); 3065 if (params->extraie.len) 3066 scan_copy_ie_buffer(buf_ptr + WMI_TLV_HDR_SIZE, 3067 params); 3068 3069 buf_ptr += WMI_TLV_HDR_SIZE + extraie_len_with_pad; 3070 3071 /* probe req ie whitelisting */ 3072 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 3073 ie_whitelist->num_vendor_oui * sizeof(wmi_vendor_oui)); 3074 3075 buf_ptr += WMI_TLV_HDR_SIZE; 3076 3077 if (cmd->num_vendor_oui) { 3078 wmi_fill_vendor_oui(buf_ptr, cmd->num_vendor_oui, 3079 ie_whitelist->voui); 3080 buf_ptr += cmd->num_vendor_oui * sizeof(wmi_vendor_oui); 3081 } 3082 3083 /* Add phy mode TLV if it's a wide band scan */ 3084 if (params->scan_f_wide_band) { 3085 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, phymode_roundup); 3086 buf_ptr = (uint8_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 3087 for (i = 0; i < params->chan_list.num_chan; ++i) 3088 buf_ptr[i] = 3089 WMI_SCAN_CHAN_SET_MODE(params->chan_list.chan[i].phymode); 3090 buf_ptr += phymode_roundup; 3091 } else { 3092 /* Add ZERO legth phy mode TLV */ 3093 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 0); 3094 buf_ptr += WMI_TLV_HDR_SIZE; 3095 } 3096 3097 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC, 3098 (params->num_hint_s_ssid * sizeof(wmi_hint_freq_short_ssid))); 3099 if (params->num_hint_s_ssid) { 3100 s_ssid = (wmi_hint_freq_short_ssid *)(buf_ptr + WMI_TLV_HDR_SIZE); 3101 for (i = 0; i < params->num_hint_s_ssid; ++i) { 3102 s_ssid->freq_flags = params->hint_s_ssid[i].freq_flags; 3103 s_ssid->short_ssid = params->hint_s_ssid[i].short_ssid; 3104 s_ssid++; 3105 } 3106 } 3107 buf_ptr += WMI_TLV_HDR_SIZE + 3108 (params->num_hint_s_ssid * sizeof(wmi_hint_freq_short_ssid)); 3109 3110 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC, 3111 (params->num_hint_bssid * sizeof(wmi_hint_freq_bssid))); 3112 if (params->num_hint_bssid) { 3113 hint_bssid = (wmi_hint_freq_bssid *)(buf_ptr + WMI_TLV_HDR_SIZE); 3114 for (i = 0; i < params->num_hint_bssid; ++i) { 3115 hint_bssid->freq_flags = 3116 params->hint_bssid[i].freq_flags; 3117 WMI_CHAR_ARRAY_TO_MAC_ADDR(¶ms->hint_bssid[i].bssid.bytes[0], 3118 &hint_bssid->bssid); 3119 hint_bssid++; 3120 } 3121 } 3122 3123 wmi_mtrace(WMI_START_SCAN_CMDID, cmd->vdev_id, 0); 3124 ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, 3125 len, WMI_START_SCAN_CMDID); 3126 if (ret) { 3127 WMI_LOGE("%s: Failed to start scan: %d", __func__, ret); 3128 wmi_buf_free(wmi_buf); 3129 } 3130 return ret; 3131 error: 3132 wmi_buf_free(wmi_buf); 3133 return QDF_STATUS_E_FAILURE; 3134 } 3135 3136 /** 3137 * send_scan_stop_cmd_tlv() - WMI scan start function 3138 * @param wmi_handle : handle to WMI. 3139 * @param param : pointer to hold scan cancel cmd parameter 3140 * 3141 * Return: 0 on success and -ve on failure. 3142 */ 3143 static QDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle, 3144 struct scan_cancel_param *param) 3145 { 3146 wmi_stop_scan_cmd_fixed_param *cmd; 3147 int ret; 3148 int len = sizeof(*cmd); 3149 wmi_buf_t wmi_buf; 3150 3151 /* Allocate the memory */ 3152 wmi_buf = wmi_buf_alloc(wmi_handle, len); 3153 if (!wmi_buf) { 3154 ret = QDF_STATUS_E_NOMEM; 3155 goto error; 3156 } 3157 3158 cmd = (wmi_stop_scan_cmd_fixed_param *) wmi_buf_data(wmi_buf); 3159 WMITLV_SET_HDR(&cmd->tlv_header, 3160 WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param, 3161 WMITLV_GET_STRUCT_TLVLEN(wmi_stop_scan_cmd_fixed_param)); 3162 cmd->vdev_id = param->vdev_id; 3163 cmd->requestor = param->requester; 3164 cmd->scan_id = param->scan_id; 3165 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 3166 wmi_handle, 3167 param->pdev_id); 3168 /* stop the scan with the corresponding scan_id */ 3169 if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) { 3170 /* Cancelling all scans */ 3171 cmd->req_type = WMI_SCAN_STOP_ALL; 3172 } else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) { 3173 /* Cancelling VAP scans */ 3174 cmd->req_type = WMI_SCN_STOP_VAP_ALL; 3175 } else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) { 3176 /* Cancelling specific scan */ 3177 cmd->req_type = WMI_SCAN_STOP_ONE; 3178 } else if (param->req_type == WLAN_SCAN_CANCEL_HOST_VDEV_ALL) { 3179 cmd->req_type = WMI_SCN_STOP_HOST_VAP_ALL; 3180 } else { 3181 WMI_LOGE("%s: Invalid Command : ", __func__); 3182 wmi_buf_free(wmi_buf); 3183 return QDF_STATUS_E_INVAL; 3184 } 3185 3186 wmi_mtrace(WMI_STOP_SCAN_CMDID, cmd->vdev_id, 0); 3187 ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, 3188 len, WMI_STOP_SCAN_CMDID); 3189 if (ret) { 3190 WMI_LOGE("%s: Failed to send stop scan: %d", __func__, ret); 3191 wmi_buf_free(wmi_buf); 3192 } 3193 3194 error: 3195 return ret; 3196 } 3197 3198 #define WMI_MAX_CHAN_INFO_LOG 192 3199 3200 /** 3201 * wmi_scan_chanlist_dump() - Dump scan channel list info 3202 * @scan_chan_list: scan channel list 3203 * 3204 * Return: void 3205 */ 3206 static void wmi_scan_chanlist_dump(struct scan_chan_list_params *scan_chan_list) 3207 { 3208 uint32_t i; 3209 uint8_t info[WMI_MAX_CHAN_INFO_LOG]; 3210 uint32_t len = 0; 3211 struct channel_param *chan; 3212 int ret; 3213 3214 wmi_debug("Total chan %d", scan_chan_list->nallchans); 3215 for (i = 0; i < scan_chan_list->nallchans; i++) { 3216 chan = &scan_chan_list->ch_param[i]; 3217 ret = qdf_scnprintf(info + len, sizeof(info) - len, 3218 " %d[%d][%d]", chan->mhz, chan->maxregpower, 3219 chan->dfs_set); 3220 if (ret <= 0) 3221 break; 3222 len += ret; 3223 if (len >= (sizeof(info) - 20)) { 3224 wmi_nofl_debug("Chan[TXPwr][DFS]:%s", info); 3225 len = 0; 3226 } 3227 } 3228 if (len) 3229 wmi_nofl_debug("Chan[TXPwr][DFS]:%s", info); 3230 } 3231 3232 static QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle, 3233 struct scan_chan_list_params *chan_list) 3234 { 3235 wmi_buf_t buf; 3236 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS; 3237 wmi_scan_chan_list_cmd_fixed_param *cmd; 3238 int i; 3239 uint8_t *buf_ptr; 3240 wmi_channel *chan_info; 3241 struct channel_param *tchan_info; 3242 uint16_t len; 3243 uint16_t num_send_chans, num_sends = 0; 3244 3245 wmi_scan_chanlist_dump(chan_list); 3246 tchan_info = &chan_list->ch_param[0]; 3247 while (chan_list->nallchans) { 3248 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE; 3249 if (chan_list->nallchans > MAX_NUM_CHAN_PER_WMI_CMD) 3250 num_send_chans = MAX_NUM_CHAN_PER_WMI_CMD; 3251 else 3252 num_send_chans = chan_list->nallchans; 3253 3254 chan_list->nallchans -= num_send_chans; 3255 len += sizeof(wmi_channel) * num_send_chans; 3256 buf = wmi_buf_alloc(wmi_handle, len); 3257 if (!buf) { 3258 qdf_status = QDF_STATUS_E_NOMEM; 3259 goto end; 3260 } 3261 3262 buf_ptr = (uint8_t *)wmi_buf_data(buf); 3263 cmd = (wmi_scan_chan_list_cmd_fixed_param *)buf_ptr; 3264 WMITLV_SET_HDR(&cmd->tlv_header, 3265 WMITLV_TAG_STRUC_wmi_scan_chan_list_cmd_fixed_param, 3266 WMITLV_GET_STRUCT_TLVLEN 3267 (wmi_scan_chan_list_cmd_fixed_param)); 3268 3269 WMI_LOGD("no of channels = %d, len = %d", num_send_chans, len); 3270 3271 if (num_sends) 3272 cmd->flags |= APPEND_TO_EXISTING_CHAN_LIST; 3273 3274 if (chan_list->max_bw_support_present) 3275 cmd->flags |= CHANNEL_MAX_BANDWIDTH_VALID; 3276 3277 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 3278 wmi_handle, 3279 chan_list->pdev_id); 3280 3281 wmi_mtrace(WMI_SCAN_CHAN_LIST_CMDID, cmd->pdev_id, 0); 3282 3283 cmd->num_scan_chans = num_send_chans; 3284 WMITLV_SET_HDR((buf_ptr + 3285 sizeof(wmi_scan_chan_list_cmd_fixed_param)), 3286 WMITLV_TAG_ARRAY_STRUC, 3287 sizeof(wmi_channel) * num_send_chans); 3288 chan_info = (wmi_channel *)(buf_ptr + sizeof(*cmd) + 3289 WMI_TLV_HDR_SIZE); 3290 3291 for (i = 0; i < num_send_chans; ++i) { 3292 WMITLV_SET_HDR(&chan_info->tlv_header, 3293 WMITLV_TAG_STRUC_wmi_channel, 3294 WMITLV_GET_STRUCT_TLVLEN(wmi_channel)); 3295 chan_info->mhz = tchan_info->mhz; 3296 chan_info->band_center_freq1 = 3297 tchan_info->cfreq1; 3298 chan_info->band_center_freq2 = 3299 tchan_info->cfreq2; 3300 3301 if (tchan_info->is_chan_passive) 3302 WMI_SET_CHANNEL_FLAG(chan_info, 3303 WMI_CHAN_FLAG_PASSIVE); 3304 if (tchan_info->dfs_set) 3305 WMI_SET_CHANNEL_FLAG(chan_info, 3306 WMI_CHAN_FLAG_DFS); 3307 3308 if (tchan_info->dfs_set_cfreq2) 3309 WMI_SET_CHANNEL_FLAG(chan_info, 3310 WMI_CHAN_FLAG_DFS_CFREQ2); 3311 3312 if (tchan_info->allow_he) 3313 WMI_SET_CHANNEL_FLAG(chan_info, 3314 WMI_CHAN_FLAG_ALLOW_HE); 3315 3316 if (tchan_info->allow_vht) 3317 WMI_SET_CHANNEL_FLAG(chan_info, 3318 WMI_CHAN_FLAG_ALLOW_VHT); 3319 3320 if (tchan_info->allow_ht) 3321 WMI_SET_CHANNEL_FLAG(chan_info, 3322 WMI_CHAN_FLAG_ALLOW_HT); 3323 WMI_SET_CHANNEL_MODE(chan_info, 3324 tchan_info->phy_mode); 3325 3326 if (tchan_info->half_rate) 3327 WMI_SET_CHANNEL_FLAG(chan_info, 3328 WMI_CHAN_FLAG_HALF_RATE); 3329 3330 if (tchan_info->quarter_rate) 3331 WMI_SET_CHANNEL_FLAG(chan_info, 3332 WMI_CHAN_FLAG_QUARTER_RATE); 3333 3334 if (tchan_info->psc_channel) 3335 WMI_SET_CHANNEL_FLAG(chan_info, 3336 WMI_CHAN_FLAG_PSC); 3337 3338 /* also fill in power information */ 3339 WMI_SET_CHANNEL_MIN_POWER(chan_info, 3340 tchan_info->minpower); 3341 WMI_SET_CHANNEL_MAX_POWER(chan_info, 3342 tchan_info->maxpower); 3343 WMI_SET_CHANNEL_REG_POWER(chan_info, 3344 tchan_info->maxregpower); 3345 WMI_SET_CHANNEL_ANTENNA_MAX(chan_info, 3346 tchan_info->antennamax); 3347 WMI_SET_CHANNEL_REG_CLASSID(chan_info, 3348 tchan_info->reg_class_id); 3349 WMI_SET_CHANNEL_MAX_TX_POWER(chan_info, 3350 tchan_info->maxregpower); 3351 WMI_SET_CHANNEL_MAX_BANDWIDTH(chan_info, 3352 tchan_info->max_bw_supported); 3353 3354 tchan_info++; 3355 chan_info++; 3356 } 3357 3358 qdf_status = wmi_unified_cmd_send( 3359 wmi_handle, 3360 buf, len, WMI_SCAN_CHAN_LIST_CMDID); 3361 3362 if (QDF_IS_STATUS_ERROR(qdf_status)) { 3363 WMI_LOGE("Failed to send WMI_SCAN_CHAN_LIST_CMDID"); 3364 wmi_buf_free(buf); 3365 goto end; 3366 } 3367 num_sends++; 3368 } 3369 3370 end: 3371 return qdf_status; 3372 } 3373 3374 /** 3375 * populate_tx_send_params - Populate TX param TLV for mgmt and offchan tx 3376 * 3377 * @bufp: Pointer to buffer 3378 * @param: Pointer to tx param 3379 * 3380 * Return: QDF_STATUS_SUCCESS for success and QDF_STATUS_E_FAILURE for failure 3381 */ 3382 static inline QDF_STATUS populate_tx_send_params(uint8_t *bufp, 3383 struct tx_send_params param) 3384 { 3385 wmi_tx_send_params *tx_param; 3386 QDF_STATUS status = QDF_STATUS_SUCCESS; 3387 3388 if (!bufp) { 3389 status = QDF_STATUS_E_FAILURE; 3390 return status; 3391 } 3392 tx_param = (wmi_tx_send_params *)bufp; 3393 WMITLV_SET_HDR(&tx_param->tlv_header, 3394 WMITLV_TAG_STRUC_wmi_tx_send_params, 3395 WMITLV_GET_STRUCT_TLVLEN(wmi_tx_send_params)); 3396 WMI_TX_SEND_PARAM_PWR_SET(tx_param->tx_param_dword0, param.pwr); 3397 WMI_TX_SEND_PARAM_MCS_MASK_SET(tx_param->tx_param_dword0, 3398 param.mcs_mask); 3399 WMI_TX_SEND_PARAM_NSS_MASK_SET(tx_param->tx_param_dword0, 3400 param.nss_mask); 3401 WMI_TX_SEND_PARAM_RETRY_LIMIT_SET(tx_param->tx_param_dword0, 3402 param.retry_limit); 3403 WMI_TX_SEND_PARAM_CHAIN_MASK_SET(tx_param->tx_param_dword1, 3404 param.chain_mask); 3405 WMI_TX_SEND_PARAM_BW_MASK_SET(tx_param->tx_param_dword1, 3406 param.bw_mask); 3407 WMI_TX_SEND_PARAM_PREAMBLE_SET(tx_param->tx_param_dword1, 3408 param.preamble_type); 3409 WMI_TX_SEND_PARAM_FRAME_TYPE_SET(tx_param->tx_param_dword1, 3410 param.frame_type); 3411 WMI_TX_SEND_PARAM_CFR_CAPTURE_SET(tx_param->tx_param_dword1, 3412 param.cfr_enable); 3413 3414 return status; 3415 } 3416 3417 #ifdef CONFIG_HL_SUPPORT 3418 /** 3419 * send_mgmt_cmd_tlv() - WMI scan start function 3420 * @wmi_handle : handle to WMI. 3421 * @param : pointer to hold mgmt cmd parameter 3422 * 3423 * Return: 0 on success and -ve on failure. 3424 */ 3425 static QDF_STATUS send_mgmt_cmd_tlv(wmi_unified_t wmi_handle, 3426 struct wmi_mgmt_params *param) 3427 { 3428 wmi_buf_t buf; 3429 uint8_t *bufp; 3430 int32_t cmd_len; 3431 wmi_mgmt_tx_send_cmd_fixed_param *cmd; 3432 int32_t bufp_len = (param->frm_len < mgmt_tx_dl_frm_len) ? param->frm_len : 3433 mgmt_tx_dl_frm_len; 3434 3435 if (param->frm_len > mgmt_tx_dl_frm_len) { 3436 WMI_LOGE("%s:mgmt frame len %u exceeds %u", 3437 __func__, param->frm_len, mgmt_tx_dl_frm_len); 3438 return QDF_STATUS_E_INVAL; 3439 } 3440 3441 cmd_len = sizeof(wmi_mgmt_tx_send_cmd_fixed_param) + 3442 WMI_TLV_HDR_SIZE + 3443 roundup(bufp_len, sizeof(uint32_t)); 3444 3445 buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_tx_send_params) + cmd_len); 3446 if (!buf) 3447 return QDF_STATUS_E_NOMEM; 3448 3449 cmd = (wmi_mgmt_tx_send_cmd_fixed_param *)wmi_buf_data(buf); 3450 bufp = (uint8_t *) cmd; 3451 WMITLV_SET_HDR(&cmd->tlv_header, 3452 WMITLV_TAG_STRUC_wmi_mgmt_tx_send_cmd_fixed_param, 3453 WMITLV_GET_STRUCT_TLVLEN 3454 (wmi_mgmt_tx_send_cmd_fixed_param)); 3455 3456 cmd->vdev_id = param->vdev_id; 3457 3458 cmd->desc_id = param->desc_id; 3459 cmd->chanfreq = param->chanfreq; 3460 bufp += sizeof(wmi_mgmt_tx_send_cmd_fixed_param); 3461 WMITLV_SET_HDR(bufp, WMITLV_TAG_ARRAY_BYTE, roundup(bufp_len, 3462 sizeof(uint32_t))); 3463 bufp += WMI_TLV_HDR_SIZE; 3464 qdf_mem_copy(bufp, param->pdata, bufp_len); 3465 3466 cmd->frame_len = param->frm_len; 3467 cmd->buf_len = bufp_len; 3468 cmd->tx_params_valid = param->tx_params_valid; 3469 3470 wmi_mgmt_cmd_record(wmi_handle, WMI_MGMT_TX_SEND_CMDID, 3471 bufp, cmd->vdev_id, cmd->chanfreq); 3472 3473 bufp += roundup(bufp_len, sizeof(uint32_t)); 3474 if (param->tx_params_valid) { 3475 if (populate_tx_send_params(bufp, param->tx_param) != 3476 QDF_STATUS_SUCCESS) { 3477 WMI_LOGE("%s: Populate TX send params failed", 3478 __func__); 3479 goto free_buf; 3480 } 3481 cmd_len += sizeof(wmi_tx_send_params); 3482 } 3483 3484 wmi_mtrace(WMI_MGMT_TX_SEND_CMDID, cmd->vdev_id, 0); 3485 if (wmi_unified_cmd_send(wmi_handle, buf, cmd_len, 3486 WMI_MGMT_TX_SEND_CMDID)) { 3487 WMI_LOGE("%s: Failed to send mgmt Tx", __func__); 3488 goto free_buf; 3489 } 3490 return QDF_STATUS_SUCCESS; 3491 3492 free_buf: 3493 wmi_buf_free(buf); 3494 return QDF_STATUS_E_FAILURE; 3495 } 3496 #else 3497 /** 3498 * send_mgmt_cmd_tlv() - WMI scan start function 3499 * @wmi_handle : handle to WMI. 3500 * @param : pointer to hold mgmt cmd parameter 3501 * 3502 * Return: 0 on success and -ve on failure. 3503 */ 3504 static QDF_STATUS send_mgmt_cmd_tlv(wmi_unified_t wmi_handle, 3505 struct wmi_mgmt_params *param) 3506 { 3507 wmi_buf_t buf; 3508 wmi_mgmt_tx_send_cmd_fixed_param *cmd; 3509 int32_t cmd_len; 3510 uint64_t dma_addr; 3511 void *qdf_ctx = param->qdf_ctx; 3512 uint8_t *bufp; 3513 QDF_STATUS status = QDF_STATUS_SUCCESS; 3514 int32_t bufp_len = (param->frm_len < mgmt_tx_dl_frm_len) ? param->frm_len : 3515 mgmt_tx_dl_frm_len; 3516 3517 cmd_len = sizeof(wmi_mgmt_tx_send_cmd_fixed_param) + 3518 WMI_TLV_HDR_SIZE + 3519 roundup(bufp_len, sizeof(uint32_t)); 3520 3521 buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_tx_send_params) + cmd_len); 3522 if (!buf) 3523 return QDF_STATUS_E_NOMEM; 3524 3525 cmd = (wmi_mgmt_tx_send_cmd_fixed_param *)wmi_buf_data(buf); 3526 bufp = (uint8_t *) cmd; 3527 WMITLV_SET_HDR(&cmd->tlv_header, 3528 WMITLV_TAG_STRUC_wmi_mgmt_tx_send_cmd_fixed_param, 3529 WMITLV_GET_STRUCT_TLVLEN 3530 (wmi_mgmt_tx_send_cmd_fixed_param)); 3531 3532 cmd->vdev_id = param->vdev_id; 3533 3534 cmd->desc_id = param->desc_id; 3535 cmd->chanfreq = param->chanfreq; 3536 bufp += sizeof(wmi_mgmt_tx_send_cmd_fixed_param); 3537 WMITLV_SET_HDR(bufp, WMITLV_TAG_ARRAY_BYTE, roundup(bufp_len, 3538 sizeof(uint32_t))); 3539 bufp += WMI_TLV_HDR_SIZE; 3540 qdf_mem_copy(bufp, param->pdata, bufp_len); 3541 3542 status = qdf_nbuf_map_single(qdf_ctx, param->tx_frame, 3543 QDF_DMA_TO_DEVICE); 3544 if (status != QDF_STATUS_SUCCESS) { 3545 WMI_LOGE("%s: wmi buf map failed", __func__); 3546 goto free_buf; 3547 } 3548 3549 dma_addr = qdf_nbuf_get_frag_paddr(param->tx_frame, 0); 3550 cmd->paddr_lo = (uint32_t)(dma_addr & 0xffffffff); 3551 #if defined(HTT_PADDR64) 3552 cmd->paddr_hi = (uint32_t)((dma_addr >> 32) & 0x1F); 3553 #endif 3554 cmd->frame_len = param->frm_len; 3555 cmd->buf_len = bufp_len; 3556 cmd->tx_params_valid = param->tx_params_valid; 3557 3558 wmi_mgmt_cmd_record(wmi_handle, WMI_MGMT_TX_SEND_CMDID, 3559 bufp, cmd->vdev_id, cmd->chanfreq); 3560 3561 bufp += roundup(bufp_len, sizeof(uint32_t)); 3562 if (param->tx_params_valid) { 3563 status = populate_tx_send_params(bufp, param->tx_param); 3564 if (status != QDF_STATUS_SUCCESS) { 3565 WMI_LOGE("%s: Populate TX send params failed", 3566 __func__); 3567 goto unmap_tx_frame; 3568 } 3569 cmd_len += sizeof(wmi_tx_send_params); 3570 } 3571 3572 wmi_mtrace(WMI_MGMT_TX_SEND_CMDID, cmd->vdev_id, 0); 3573 if (wmi_unified_cmd_send(wmi_handle, buf, cmd_len, 3574 WMI_MGMT_TX_SEND_CMDID)) { 3575 WMI_LOGE("%s: Failed to send mgmt Tx", __func__); 3576 goto unmap_tx_frame; 3577 } 3578 return QDF_STATUS_SUCCESS; 3579 3580 unmap_tx_frame: 3581 qdf_nbuf_unmap_single(qdf_ctx, param->tx_frame, 3582 QDF_DMA_TO_DEVICE); 3583 free_buf: 3584 wmi_buf_free(buf); 3585 return QDF_STATUS_E_FAILURE; 3586 } 3587 #endif /* CONFIG_HL_SUPPORT */ 3588 3589 /** 3590 * send_offchan_data_tx_send_cmd_tlv() - Send off-chan tx data 3591 * @wmi_handle : handle to WMI. 3592 * @param : pointer to offchan data tx cmd parameter 3593 * 3594 * Return: QDF_STATUS_SUCCESS on success and error on failure. 3595 */ 3596 static QDF_STATUS send_offchan_data_tx_cmd_tlv(wmi_unified_t wmi_handle, 3597 struct wmi_offchan_data_tx_params *param) 3598 { 3599 wmi_buf_t buf; 3600 wmi_offchan_data_tx_send_cmd_fixed_param *cmd; 3601 int32_t cmd_len; 3602 uint64_t dma_addr; 3603 void *qdf_ctx = param->qdf_ctx; 3604 uint8_t *bufp; 3605 int32_t bufp_len = (param->frm_len < mgmt_tx_dl_frm_len) ? 3606 param->frm_len : mgmt_tx_dl_frm_len; 3607 QDF_STATUS status = QDF_STATUS_SUCCESS; 3608 3609 cmd_len = sizeof(wmi_offchan_data_tx_send_cmd_fixed_param) + 3610 WMI_TLV_HDR_SIZE + 3611 roundup(bufp_len, sizeof(uint32_t)); 3612 3613 buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_tx_send_params) + cmd_len); 3614 if (!buf) 3615 return QDF_STATUS_E_NOMEM; 3616 3617 cmd = (wmi_offchan_data_tx_send_cmd_fixed_param *) wmi_buf_data(buf); 3618 bufp = (uint8_t *) cmd; 3619 WMITLV_SET_HDR(&cmd->tlv_header, 3620 WMITLV_TAG_STRUC_wmi_offchan_data_tx_send_cmd_fixed_param, 3621 WMITLV_GET_STRUCT_TLVLEN 3622 (wmi_offchan_data_tx_send_cmd_fixed_param)); 3623 3624 cmd->vdev_id = param->vdev_id; 3625 3626 cmd->desc_id = param->desc_id; 3627 cmd->chanfreq = param->chanfreq; 3628 bufp += sizeof(wmi_offchan_data_tx_send_cmd_fixed_param); 3629 WMITLV_SET_HDR(bufp, WMITLV_TAG_ARRAY_BYTE, roundup(bufp_len, 3630 sizeof(uint32_t))); 3631 bufp += WMI_TLV_HDR_SIZE; 3632 qdf_mem_copy(bufp, param->pdata, bufp_len); 3633 qdf_nbuf_map_single(qdf_ctx, param->tx_frame, QDF_DMA_TO_DEVICE); 3634 dma_addr = qdf_nbuf_get_frag_paddr(param->tx_frame, 0); 3635 cmd->paddr_lo = (uint32_t)(dma_addr & 0xffffffff); 3636 #if defined(HTT_PADDR64) 3637 cmd->paddr_hi = (uint32_t)((dma_addr >> 32) & 0x1F); 3638 #endif 3639 cmd->frame_len = param->frm_len; 3640 cmd->buf_len = bufp_len; 3641 cmd->tx_params_valid = param->tx_params_valid; 3642 3643 wmi_mgmt_cmd_record(wmi_handle, WMI_OFFCHAN_DATA_TX_SEND_CMDID, 3644 bufp, cmd->vdev_id, cmd->chanfreq); 3645 3646 bufp += roundup(bufp_len, sizeof(uint32_t)); 3647 if (param->tx_params_valid) { 3648 status = populate_tx_send_params(bufp, param->tx_param); 3649 if (status != QDF_STATUS_SUCCESS) { 3650 WMI_LOGE("%s: Populate TX send params failed", 3651 __func__); 3652 goto err1; 3653 } 3654 cmd_len += sizeof(wmi_tx_send_params); 3655 } 3656 3657 wmi_mtrace(WMI_OFFCHAN_DATA_TX_SEND_CMDID, cmd->vdev_id, 0); 3658 if (wmi_unified_cmd_send(wmi_handle, buf, cmd_len, 3659 WMI_OFFCHAN_DATA_TX_SEND_CMDID)) { 3660 WMI_LOGE("%s: Failed to offchan data Tx", __func__); 3661 goto err1; 3662 } 3663 3664 return QDF_STATUS_SUCCESS; 3665 3666 err1: 3667 wmi_buf_free(buf); 3668 return QDF_STATUS_E_FAILURE; 3669 } 3670 3671 /** 3672 * send_modem_power_state_cmd_tlv() - set modem power state to fw 3673 * @wmi_handle: wmi handle 3674 * @param_value: parameter value 3675 * 3676 * Return: QDF_STATUS_SUCCESS for success or error code 3677 */ 3678 static QDF_STATUS send_modem_power_state_cmd_tlv(wmi_unified_t wmi_handle, 3679 uint32_t param_value) 3680 { 3681 QDF_STATUS ret; 3682 wmi_modem_power_state_cmd_param *cmd; 3683 wmi_buf_t buf; 3684 uint16_t len = sizeof(*cmd); 3685 3686 buf = wmi_buf_alloc(wmi_handle, len); 3687 if (!buf) 3688 return QDF_STATUS_E_NOMEM; 3689 3690 cmd = (wmi_modem_power_state_cmd_param *) wmi_buf_data(buf); 3691 WMITLV_SET_HDR(&cmd->tlv_header, 3692 WMITLV_TAG_STRUC_wmi_modem_power_state_cmd_param, 3693 WMITLV_GET_STRUCT_TLVLEN 3694 (wmi_modem_power_state_cmd_param)); 3695 cmd->modem_power_state = param_value; 3696 WMI_LOGD("%s: Setting cmd->modem_power_state = %u", __func__, 3697 param_value); 3698 wmi_mtrace(WMI_MODEM_POWER_STATE_CMDID, NO_SESSION, 0); 3699 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 3700 WMI_MODEM_POWER_STATE_CMDID); 3701 if (QDF_IS_STATUS_ERROR(ret)) { 3702 WMI_LOGE("Failed to send notify cmd ret = %d", ret); 3703 wmi_buf_free(buf); 3704 } 3705 3706 return ret; 3707 } 3708 3709 /** 3710 * send_set_sta_ps_mode_cmd_tlv() - set sta powersave mode in fw 3711 * @wmi_handle: wmi handle 3712 * @vdev_id: vdev id 3713 * @val: value 3714 * 3715 * Return: QDF_STATUS_SUCCESS for success or error code. 3716 */ 3717 static QDF_STATUS send_set_sta_ps_mode_cmd_tlv(wmi_unified_t wmi_handle, 3718 uint32_t vdev_id, uint8_t val) 3719 { 3720 wmi_sta_powersave_mode_cmd_fixed_param *cmd; 3721 wmi_buf_t buf; 3722 int32_t len = sizeof(*cmd); 3723 3724 WMI_LOGD("Set Sta Mode Ps vdevId %d val %d", vdev_id, val); 3725 3726 buf = wmi_buf_alloc(wmi_handle, len); 3727 if (!buf) 3728 return QDF_STATUS_E_NOMEM; 3729 3730 cmd = (wmi_sta_powersave_mode_cmd_fixed_param *) wmi_buf_data(buf); 3731 WMITLV_SET_HDR(&cmd->tlv_header, 3732 WMITLV_TAG_STRUC_wmi_sta_powersave_mode_cmd_fixed_param, 3733 WMITLV_GET_STRUCT_TLVLEN 3734 (wmi_sta_powersave_mode_cmd_fixed_param)); 3735 cmd->vdev_id = vdev_id; 3736 if (val) 3737 cmd->sta_ps_mode = WMI_STA_PS_MODE_ENABLED; 3738 else 3739 cmd->sta_ps_mode = WMI_STA_PS_MODE_DISABLED; 3740 3741 wmi_mtrace(WMI_STA_POWERSAVE_MODE_CMDID, cmd->vdev_id, 0); 3742 if (wmi_unified_cmd_send(wmi_handle, buf, len, 3743 WMI_STA_POWERSAVE_MODE_CMDID)) { 3744 WMI_LOGE("Set Sta Mode Ps Failed vdevId %d val %d", 3745 vdev_id, val); 3746 wmi_buf_free(buf); 3747 return QDF_STATUS_E_FAILURE; 3748 } 3749 return QDF_STATUS_SUCCESS; 3750 } 3751 3752 /** 3753 * send_idle_roam_monitor_cmd_tlv() - send idle monitor command to fw 3754 * @wmi_handle: wmi handle 3755 * @vdev_id: vdev id 3756 * 3757 * Return: QDF_STATUS_SUCCESS for success or error code. 3758 */ 3759 static QDF_STATUS send_idle_roam_monitor_cmd_tlv(wmi_unified_t wmi_handle, 3760 uint8_t val) 3761 { 3762 wmi_idle_trigger_monitor_cmd_fixed_param *cmd; 3763 wmi_buf_t buf; 3764 size_t len = sizeof(*cmd); 3765 3766 buf = wmi_buf_alloc(wmi_handle, len); 3767 if (!buf) 3768 return QDF_STATUS_E_NOMEM; 3769 3770 cmd = (wmi_idle_trigger_monitor_cmd_fixed_param *)wmi_buf_data(buf); 3771 WMITLV_SET_HDR(&cmd->tlv_header, 3772 WMITLV_TAG_STRUC_wmi_idle_trigger_monitor_cmd_fixed_param, 3773 WMITLV_GET_STRUCT_TLVLEN(wmi_idle_trigger_monitor_cmd_fixed_param)); 3774 3775 cmd->idle_trigger_monitor = (val ? WMI_IDLE_TRIGGER_MONITOR_ON : 3776 WMI_IDLE_TRIGGER_MONITOR_OFF); 3777 3778 WMI_LOGD("val:%d", cmd->idle_trigger_monitor); 3779 3780 if (wmi_unified_cmd_send(wmi_handle, buf, len, 3781 WMI_IDLE_TRIGGER_MONITOR_CMDID)) { 3782 wmi_buf_free(buf); 3783 return QDF_STATUS_E_FAILURE; 3784 } 3785 return QDF_STATUS_SUCCESS; 3786 } 3787 3788 /** 3789 * send_set_mimops_cmd_tlv() - set MIMO powersave 3790 * @wmi_handle: wmi handle 3791 * @vdev_id: vdev id 3792 * @value: value 3793 * 3794 * Return: QDF_STATUS_SUCCESS for success or error code. 3795 */ 3796 static QDF_STATUS send_set_mimops_cmd_tlv(wmi_unified_t wmi_handle, 3797 uint8_t vdev_id, int value) 3798 { 3799 QDF_STATUS ret; 3800 wmi_sta_smps_force_mode_cmd_fixed_param *cmd; 3801 wmi_buf_t buf; 3802 uint16_t len = sizeof(*cmd); 3803 3804 buf = wmi_buf_alloc(wmi_handle, len); 3805 if (!buf) 3806 return QDF_STATUS_E_NOMEM; 3807 3808 cmd = (wmi_sta_smps_force_mode_cmd_fixed_param *) wmi_buf_data(buf); 3809 WMITLV_SET_HDR(&cmd->tlv_header, 3810 WMITLV_TAG_STRUC_wmi_sta_smps_force_mode_cmd_fixed_param, 3811 WMITLV_GET_STRUCT_TLVLEN 3812 (wmi_sta_smps_force_mode_cmd_fixed_param)); 3813 3814 cmd->vdev_id = vdev_id; 3815 3816 /* WMI_SMPS_FORCED_MODE values do not directly map 3817 * to SM power save values defined in the specification. 3818 * Make sure to send the right mapping. 3819 */ 3820 switch (value) { 3821 case 0: 3822 cmd->forced_mode = WMI_SMPS_FORCED_MODE_NONE; 3823 break; 3824 case 1: 3825 cmd->forced_mode = WMI_SMPS_FORCED_MODE_DISABLED; 3826 break; 3827 case 2: 3828 cmd->forced_mode = WMI_SMPS_FORCED_MODE_STATIC; 3829 break; 3830 case 3: 3831 cmd->forced_mode = WMI_SMPS_FORCED_MODE_DYNAMIC; 3832 break; 3833 default: 3834 WMI_LOGE("%s:INVALID Mimo PS CONFIG", __func__); 3835 wmi_buf_free(buf); 3836 return QDF_STATUS_E_FAILURE; 3837 } 3838 3839 WMI_LOGD("Setting vdev %d value = %u", vdev_id, value); 3840 3841 wmi_mtrace(WMI_STA_SMPS_FORCE_MODE_CMDID, cmd->vdev_id, 0); 3842 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 3843 WMI_STA_SMPS_FORCE_MODE_CMDID); 3844 if (QDF_IS_STATUS_ERROR(ret)) { 3845 WMI_LOGE("Failed to send set Mimo PS ret = %d", ret); 3846 wmi_buf_free(buf); 3847 } 3848 3849 return ret; 3850 } 3851 3852 /** 3853 * send_set_smps_params_cmd_tlv() - set smps params 3854 * @wmi_handle: wmi handle 3855 * @vdev_id: vdev id 3856 * @value: value 3857 * 3858 * Return: QDF_STATUS_SUCCESS for success or error code. 3859 */ 3860 static QDF_STATUS send_set_smps_params_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id, 3861 int value) 3862 { 3863 QDF_STATUS ret; 3864 wmi_sta_smps_param_cmd_fixed_param *cmd; 3865 wmi_buf_t buf; 3866 uint16_t len = sizeof(*cmd); 3867 3868 buf = wmi_buf_alloc(wmi_handle, len); 3869 if (!buf) 3870 return QDF_STATUS_E_NOMEM; 3871 3872 cmd = (wmi_sta_smps_param_cmd_fixed_param *) wmi_buf_data(buf); 3873 WMITLV_SET_HDR(&cmd->tlv_header, 3874 WMITLV_TAG_STRUC_wmi_sta_smps_param_cmd_fixed_param, 3875 WMITLV_GET_STRUCT_TLVLEN 3876 (wmi_sta_smps_param_cmd_fixed_param)); 3877 3878 cmd->vdev_id = vdev_id; 3879 cmd->value = value & WMI_SMPS_MASK_LOWER_16BITS; 3880 cmd->param = 3881 (value >> WMI_SMPS_PARAM_VALUE_S) & WMI_SMPS_MASK_UPPER_3BITS; 3882 3883 WMI_LOGD("Setting vdev %d value = %x param %x", vdev_id, cmd->value, 3884 cmd->param); 3885 3886 wmi_mtrace(WMI_STA_SMPS_PARAM_CMDID, cmd->vdev_id, 0); 3887 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 3888 WMI_STA_SMPS_PARAM_CMDID); 3889 if (QDF_IS_STATUS_ERROR(ret)) { 3890 WMI_LOGE("Failed to send set Mimo PS ret = %d", ret); 3891 wmi_buf_free(buf); 3892 } 3893 3894 return ret; 3895 } 3896 3897 /** 3898 * send_get_temperature_cmd_tlv() - get pdev temperature req 3899 * @wmi_handle: wmi handle 3900 * 3901 * Return: QDF_STATUS_SUCCESS for success or error code. 3902 */ 3903 static QDF_STATUS send_get_temperature_cmd_tlv(wmi_unified_t wmi_handle) 3904 { 3905 wmi_pdev_get_temperature_cmd_fixed_param *cmd; 3906 wmi_buf_t wmi_buf; 3907 uint32_t len = sizeof(wmi_pdev_get_temperature_cmd_fixed_param); 3908 uint8_t *buf_ptr; 3909 3910 if (!wmi_handle) { 3911 WMI_LOGE(FL("WMI is closed, can not issue cmd")); 3912 return QDF_STATUS_E_INVAL; 3913 } 3914 3915 wmi_buf = wmi_buf_alloc(wmi_handle, len); 3916 if (!wmi_buf) 3917 return QDF_STATUS_E_NOMEM; 3918 3919 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 3920 3921 cmd = (wmi_pdev_get_temperature_cmd_fixed_param *) buf_ptr; 3922 WMITLV_SET_HDR(&cmd->tlv_header, 3923 WMITLV_TAG_STRUC_wmi_pdev_get_temperature_cmd_fixed_param, 3924 WMITLV_GET_STRUCT_TLVLEN 3925 (wmi_pdev_get_temperature_cmd_fixed_param)); 3926 3927 wmi_mtrace(WMI_PDEV_GET_TEMPERATURE_CMDID, NO_SESSION, 0); 3928 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 3929 WMI_PDEV_GET_TEMPERATURE_CMDID)) { 3930 WMI_LOGE(FL("failed to send get temperature command")); 3931 wmi_buf_free(wmi_buf); 3932 return QDF_STATUS_E_FAILURE; 3933 } 3934 3935 return QDF_STATUS_SUCCESS; 3936 } 3937 3938 /** 3939 * send_set_sta_uapsd_auto_trig_cmd_tlv() - set uapsd auto trigger command 3940 * @wmi_handle: wmi handle 3941 * @vdevid: vdev id 3942 * @peer_addr: peer mac address 3943 * @auto_triggerparam: auto trigger parameters 3944 * @num_ac: number of access category 3945 * 3946 * This function sets the trigger 3947 * uapsd params such as service interval, delay interval 3948 * and suspend interval which will be used by the firmware 3949 * to send trigger frames periodically when there is no 3950 * traffic on the transmit side. 3951 * 3952 * Return: QDF_STATUS_SUCCESS for success or error code. 3953 */ 3954 static QDF_STATUS send_set_sta_uapsd_auto_trig_cmd_tlv(wmi_unified_t wmi_handle, 3955 struct sta_uapsd_trig_params *param) 3956 { 3957 wmi_sta_uapsd_auto_trig_cmd_fixed_param *cmd; 3958 QDF_STATUS ret; 3959 uint32_t param_len = param->num_ac * sizeof(wmi_sta_uapsd_auto_trig_param); 3960 uint32_t cmd_len = sizeof(*cmd) + param_len + WMI_TLV_HDR_SIZE; 3961 uint32_t i; 3962 wmi_buf_t buf; 3963 uint8_t *buf_ptr; 3964 struct sta_uapsd_params *uapsd_param; 3965 wmi_sta_uapsd_auto_trig_param *trig_param; 3966 3967 buf = wmi_buf_alloc(wmi_handle, cmd_len); 3968 if (!buf) 3969 return QDF_STATUS_E_NOMEM; 3970 3971 buf_ptr = (uint8_t *) wmi_buf_data(buf); 3972 cmd = (wmi_sta_uapsd_auto_trig_cmd_fixed_param *) buf_ptr; 3973 WMITLV_SET_HDR(&cmd->tlv_header, 3974 WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_cmd_fixed_param, 3975 WMITLV_GET_STRUCT_TLVLEN 3976 (wmi_sta_uapsd_auto_trig_cmd_fixed_param)); 3977 cmd->vdev_id = param->vdevid; 3978 cmd->num_ac = param->num_ac; 3979 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr); 3980 3981 /* TLV indicating array of structures to follow */ 3982 buf_ptr += sizeof(*cmd); 3983 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, param_len); 3984 3985 buf_ptr += WMI_TLV_HDR_SIZE; 3986 3987 /* 3988 * Update tag and length for uapsd auto trigger params (this will take 3989 * care of updating tag and length if it is not pre-filled by caller). 3990 */ 3991 uapsd_param = (struct sta_uapsd_params *)param->auto_triggerparam; 3992 trig_param = (wmi_sta_uapsd_auto_trig_param *)buf_ptr; 3993 for (i = 0; i < param->num_ac; i++) { 3994 WMITLV_SET_HDR((buf_ptr + 3995 (i * sizeof(wmi_sta_uapsd_auto_trig_param))), 3996 WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_param, 3997 WMITLV_GET_STRUCT_TLVLEN 3998 (wmi_sta_uapsd_auto_trig_param)); 3999 trig_param->wmm_ac = uapsd_param->wmm_ac; 4000 trig_param->user_priority = uapsd_param->user_priority; 4001 trig_param->service_interval = uapsd_param->service_interval; 4002 trig_param->suspend_interval = uapsd_param->suspend_interval; 4003 trig_param->delay_interval = uapsd_param->delay_interval; 4004 trig_param++; 4005 uapsd_param++; 4006 } 4007 4008 wmi_mtrace(WMI_STA_UAPSD_AUTO_TRIG_CMDID, cmd->vdev_id, 0); 4009 ret = wmi_unified_cmd_send(wmi_handle, buf, cmd_len, 4010 WMI_STA_UAPSD_AUTO_TRIG_CMDID); 4011 if (QDF_IS_STATUS_ERROR(ret)) { 4012 WMI_LOGE("Failed to send set uapsd param ret = %d", ret); 4013 wmi_buf_free(buf); 4014 } 4015 4016 return ret; 4017 } 4018 4019 /** 4020 * send_set_thermal_mgmt_cmd_tlv() - set thermal mgmt command to fw 4021 * @wmi_handle: Pointer to wmi handle 4022 * @thermal_info: Thermal command information 4023 * 4024 * This function sends the thermal management command 4025 * to the firmware 4026 * 4027 * Return: QDF_STATUS_SUCCESS for success otherwise failure 4028 */ 4029 static QDF_STATUS send_set_thermal_mgmt_cmd_tlv(wmi_unified_t wmi_handle, 4030 struct thermal_cmd_params *thermal_info) 4031 { 4032 wmi_thermal_mgmt_cmd_fixed_param *cmd = NULL; 4033 wmi_buf_t buf = NULL; 4034 QDF_STATUS status; 4035 uint32_t len = 0; 4036 4037 len = sizeof(*cmd); 4038 4039 buf = wmi_buf_alloc(wmi_handle, len); 4040 if (!buf) 4041 return QDF_STATUS_E_FAILURE; 4042 4043 cmd = (wmi_thermal_mgmt_cmd_fixed_param *) wmi_buf_data(buf); 4044 4045 WMITLV_SET_HDR(&cmd->tlv_header, 4046 WMITLV_TAG_STRUC_wmi_thermal_mgmt_cmd_fixed_param, 4047 WMITLV_GET_STRUCT_TLVLEN 4048 (wmi_thermal_mgmt_cmd_fixed_param)); 4049 4050 cmd->lower_thresh_degreeC = thermal_info->min_temp; 4051 cmd->upper_thresh_degreeC = thermal_info->max_temp; 4052 cmd->enable = thermal_info->thermal_enable; 4053 4054 WMI_LOGE("TM Sending thermal mgmt cmd: low temp %d, upper temp %d, enabled %d", 4055 cmd->lower_thresh_degreeC, cmd->upper_thresh_degreeC, cmd->enable); 4056 4057 wmi_mtrace(WMI_THERMAL_MGMT_CMDID, NO_SESSION, 0); 4058 status = wmi_unified_cmd_send(wmi_handle, buf, len, 4059 WMI_THERMAL_MGMT_CMDID); 4060 if (QDF_IS_STATUS_ERROR(status)) { 4061 wmi_buf_free(buf); 4062 WMI_LOGE("%s:Failed to send thermal mgmt command", __func__); 4063 } 4064 4065 return status; 4066 } 4067 4068 /** 4069 * send_lro_config_cmd_tlv() - process the LRO config command 4070 * @wmi_handle: Pointer to WMI handle 4071 * @wmi_lro_cmd: Pointer to LRO configuration parameters 4072 * 4073 * This function sends down the LRO configuration parameters to 4074 * the firmware to enable LRO, sets the TCP flags and sets the 4075 * seed values for the toeplitz hash generation 4076 * 4077 * Return: QDF_STATUS_SUCCESS for success otherwise failure 4078 */ 4079 static QDF_STATUS send_lro_config_cmd_tlv(wmi_unified_t wmi_handle, 4080 struct wmi_lro_config_cmd_t *wmi_lro_cmd) 4081 { 4082 wmi_lro_info_cmd_fixed_param *cmd; 4083 wmi_buf_t buf; 4084 QDF_STATUS status; 4085 uint8_t pdev_id = wmi_lro_cmd->pdev_id; 4086 4087 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 4088 if (!buf) 4089 return QDF_STATUS_E_FAILURE; 4090 4091 cmd = (wmi_lro_info_cmd_fixed_param *) wmi_buf_data(buf); 4092 4093 WMITLV_SET_HDR(&cmd->tlv_header, 4094 WMITLV_TAG_STRUC_wmi_lro_info_cmd_fixed_param, 4095 WMITLV_GET_STRUCT_TLVLEN(wmi_lro_info_cmd_fixed_param)); 4096 4097 cmd->lro_enable = wmi_lro_cmd->lro_enable; 4098 WMI_LRO_INFO_TCP_FLAG_VALS_SET(cmd->tcp_flag_u32, 4099 wmi_lro_cmd->tcp_flag); 4100 WMI_LRO_INFO_TCP_FLAGS_MASK_SET(cmd->tcp_flag_u32, 4101 wmi_lro_cmd->tcp_flag_mask); 4102 cmd->toeplitz_hash_ipv4_0_3 = 4103 wmi_lro_cmd->toeplitz_hash_ipv4[0]; 4104 cmd->toeplitz_hash_ipv4_4_7 = 4105 wmi_lro_cmd->toeplitz_hash_ipv4[1]; 4106 cmd->toeplitz_hash_ipv4_8_11 = 4107 wmi_lro_cmd->toeplitz_hash_ipv4[2]; 4108 cmd->toeplitz_hash_ipv4_12_15 = 4109 wmi_lro_cmd->toeplitz_hash_ipv4[3]; 4110 cmd->toeplitz_hash_ipv4_16 = 4111 wmi_lro_cmd->toeplitz_hash_ipv4[4]; 4112 4113 cmd->toeplitz_hash_ipv6_0_3 = 4114 wmi_lro_cmd->toeplitz_hash_ipv6[0]; 4115 cmd->toeplitz_hash_ipv6_4_7 = 4116 wmi_lro_cmd->toeplitz_hash_ipv6[1]; 4117 cmd->toeplitz_hash_ipv6_8_11 = 4118 wmi_lro_cmd->toeplitz_hash_ipv6[2]; 4119 cmd->toeplitz_hash_ipv6_12_15 = 4120 wmi_lro_cmd->toeplitz_hash_ipv6[3]; 4121 cmd->toeplitz_hash_ipv6_16_19 = 4122 wmi_lro_cmd->toeplitz_hash_ipv6[4]; 4123 cmd->toeplitz_hash_ipv6_20_23 = 4124 wmi_lro_cmd->toeplitz_hash_ipv6[5]; 4125 cmd->toeplitz_hash_ipv6_24_27 = 4126 wmi_lro_cmd->toeplitz_hash_ipv6[6]; 4127 cmd->toeplitz_hash_ipv6_28_31 = 4128 wmi_lro_cmd->toeplitz_hash_ipv6[7]; 4129 cmd->toeplitz_hash_ipv6_32_35 = 4130 wmi_lro_cmd->toeplitz_hash_ipv6[8]; 4131 cmd->toeplitz_hash_ipv6_36_39 = 4132 wmi_lro_cmd->toeplitz_hash_ipv6[9]; 4133 cmd->toeplitz_hash_ipv6_40 = 4134 wmi_lro_cmd->toeplitz_hash_ipv6[10]; 4135 4136 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 4137 wmi_handle, 4138 pdev_id); 4139 WMI_LOGD("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x, pdev_id: %d", 4140 cmd->lro_enable, cmd->tcp_flag_u32, cmd->pdev_id); 4141 4142 wmi_mtrace(WMI_LRO_CONFIG_CMDID, NO_SESSION, 0); 4143 status = wmi_unified_cmd_send(wmi_handle, buf, 4144 sizeof(*cmd), WMI_LRO_CONFIG_CMDID); 4145 if (QDF_IS_STATUS_ERROR(status)) { 4146 wmi_buf_free(buf); 4147 WMI_LOGE("%s:Failed to send WMI_LRO_CONFIG_CMDID", __func__); 4148 } 4149 4150 return status; 4151 } 4152 4153 /** 4154 * send_peer_rate_report_cmd_tlv() - process the peer rate report command 4155 * @wmi_handle: Pointer to wmi handle 4156 * @rate_report_params: Pointer to peer rate report parameters 4157 * 4158 * 4159 * Return: QDF_STATUS_SUCCESS for success otherwise failure 4160 */ 4161 static QDF_STATUS send_peer_rate_report_cmd_tlv(wmi_unified_t wmi_handle, 4162 struct wmi_peer_rate_report_params *rate_report_params) 4163 { 4164 wmi_peer_set_rate_report_condition_fixed_param *cmd = NULL; 4165 wmi_buf_t buf = NULL; 4166 QDF_STATUS status = 0; 4167 uint32_t len = 0; 4168 uint32_t i, j; 4169 4170 len = sizeof(*cmd); 4171 4172 buf = wmi_buf_alloc(wmi_handle, len); 4173 if (!buf) 4174 return QDF_STATUS_E_FAILURE; 4175 4176 cmd = (wmi_peer_set_rate_report_condition_fixed_param *) 4177 wmi_buf_data(buf); 4178 4179 WMITLV_SET_HDR( 4180 &cmd->tlv_header, 4181 WMITLV_TAG_STRUC_wmi_peer_set_rate_report_condition_fixed_param, 4182 WMITLV_GET_STRUCT_TLVLEN( 4183 wmi_peer_set_rate_report_condition_fixed_param)); 4184 4185 cmd->enable_rate_report = rate_report_params->rate_report_enable; 4186 cmd->report_backoff_time = rate_report_params->backoff_time; 4187 cmd->report_timer_period = rate_report_params->timer_period; 4188 for (i = 0; i < PEER_RATE_REPORT_COND_MAX_NUM; i++) { 4189 cmd->cond_per_phy[i].val_cond_flags = 4190 rate_report_params->report_per_phy[i].cond_flags; 4191 cmd->cond_per_phy[i].rate_delta.min_delta = 4192 rate_report_params->report_per_phy[i].delta.delta_min; 4193 cmd->cond_per_phy[i].rate_delta.percentage = 4194 rate_report_params->report_per_phy[i].delta.percent; 4195 for (j = 0; j < MAX_NUM_OF_RATE_THRESH; j++) { 4196 cmd->cond_per_phy[i].rate_threshold[j] = 4197 rate_report_params->report_per_phy[i]. 4198 report_rate_threshold[j]; 4199 } 4200 } 4201 4202 WMI_LOGE("%s enable %d backoff_time %d period %d", __func__, 4203 cmd->enable_rate_report, 4204 cmd->report_backoff_time, cmd->report_timer_period); 4205 4206 wmi_mtrace(WMI_PEER_SET_RATE_REPORT_CONDITION_CMDID, NO_SESSION, 0); 4207 status = wmi_unified_cmd_send(wmi_handle, buf, len, 4208 WMI_PEER_SET_RATE_REPORT_CONDITION_CMDID); 4209 if (QDF_IS_STATUS_ERROR(status)) { 4210 wmi_buf_free(buf); 4211 WMI_LOGE("%s:Failed to send peer_set_report_cond command", 4212 __func__); 4213 } 4214 return status; 4215 } 4216 4217 /** 4218 * send_process_update_edca_param_cmd_tlv() - update EDCA params 4219 * @wmi_handle: wmi handle 4220 * @vdev_id: vdev id. 4221 * @wmm_vparams: edca parameters 4222 * 4223 * This function updates EDCA parameters to the target 4224 * 4225 * Return: CDF Status 4226 */ 4227 static QDF_STATUS send_process_update_edca_param_cmd_tlv(wmi_unified_t wmi_handle, 4228 uint8_t vdev_id, bool mu_edca_param, 4229 struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]) 4230 { 4231 uint8_t *buf_ptr; 4232 wmi_buf_t buf; 4233 wmi_vdev_set_wmm_params_cmd_fixed_param *cmd; 4234 wmi_wmm_vparams *wmm_param; 4235 struct wmi_host_wme_vparams *twmm_param; 4236 int len = sizeof(*cmd); 4237 int ac; 4238 4239 buf = wmi_buf_alloc(wmi_handle, len); 4240 4241 if (!buf) 4242 return QDF_STATUS_E_NOMEM; 4243 4244 buf_ptr = (uint8_t *) wmi_buf_data(buf); 4245 cmd = (wmi_vdev_set_wmm_params_cmd_fixed_param *) buf_ptr; 4246 WMITLV_SET_HDR(&cmd->tlv_header, 4247 WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param, 4248 WMITLV_GET_STRUCT_TLVLEN 4249 (wmi_vdev_set_wmm_params_cmd_fixed_param)); 4250 cmd->vdev_id = vdev_id; 4251 cmd->wmm_param_type = mu_edca_param; 4252 4253 for (ac = 0; ac < WMI_MAX_NUM_AC; ac++) { 4254 wmm_param = (wmi_wmm_vparams *) (&cmd->wmm_params[ac]); 4255 twmm_param = (struct wmi_host_wme_vparams *) (&wmm_vparams[ac]); 4256 WMITLV_SET_HDR(&wmm_param->tlv_header, 4257 WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param, 4258 WMITLV_GET_STRUCT_TLVLEN(wmi_wmm_vparams)); 4259 wmm_param->cwmin = twmm_param->cwmin; 4260 wmm_param->cwmax = twmm_param->cwmax; 4261 wmm_param->aifs = twmm_param->aifs; 4262 if (mu_edca_param) 4263 wmm_param->mu_edca_timer = twmm_param->mu_edca_timer; 4264 else 4265 wmm_param->txoplimit = twmm_param->txoplimit; 4266 wmm_param->acm = twmm_param->acm; 4267 wmm_param->no_ack = twmm_param->noackpolicy; 4268 } 4269 4270 wmi_mtrace(WMI_VDEV_SET_WMM_PARAMS_CMDID, cmd->vdev_id, 0); 4271 if (wmi_unified_cmd_send(wmi_handle, buf, len, 4272 WMI_VDEV_SET_WMM_PARAMS_CMDID)) 4273 goto fail; 4274 4275 return QDF_STATUS_SUCCESS; 4276 4277 fail: 4278 wmi_buf_free(buf); 4279 WMI_LOGE("%s: Failed to set WMM Paremeters", __func__); 4280 return QDF_STATUS_E_FAILURE; 4281 } 4282 4283 /** 4284 * send_probe_rsp_tmpl_send_cmd_tlv() - send probe response template to fw 4285 * @wmi_handle: wmi handle 4286 * @vdev_id: vdev id 4287 * @probe_rsp_info: probe response info 4288 * 4289 * Return: QDF_STATUS_SUCCESS for success or error code 4290 */ 4291 static QDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle, 4292 uint8_t vdev_id, 4293 struct wmi_probe_resp_params *probe_rsp_info) 4294 { 4295 wmi_prb_tmpl_cmd_fixed_param *cmd; 4296 wmi_bcn_prb_info *bcn_prb_info; 4297 wmi_buf_t wmi_buf; 4298 uint32_t tmpl_len, tmpl_len_aligned, wmi_buf_len; 4299 uint8_t *buf_ptr; 4300 QDF_STATUS ret; 4301 4302 WMI_LOGD(FL("Send probe response template for vdev %d"), vdev_id); 4303 4304 tmpl_len = probe_rsp_info->prb_rsp_template_len; 4305 tmpl_len_aligned = roundup(tmpl_len, sizeof(uint32_t)); 4306 4307 wmi_buf_len = sizeof(wmi_prb_tmpl_cmd_fixed_param) + 4308 sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE + 4309 tmpl_len_aligned; 4310 4311 if (wmi_buf_len > WMI_BEACON_TX_BUFFER_SIZE) { 4312 WMI_LOGE(FL("wmi_buf_len: %d > %d. Can't send wmi cmd"), 4313 wmi_buf_len, WMI_BEACON_TX_BUFFER_SIZE); 4314 return QDF_STATUS_E_INVAL; 4315 } 4316 4317 wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); 4318 if (!wmi_buf) 4319 return QDF_STATUS_E_NOMEM; 4320 4321 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 4322 4323 cmd = (wmi_prb_tmpl_cmd_fixed_param *) buf_ptr; 4324 WMITLV_SET_HDR(&cmd->tlv_header, 4325 WMITLV_TAG_STRUC_wmi_prb_tmpl_cmd_fixed_param, 4326 WMITLV_GET_STRUCT_TLVLEN(wmi_prb_tmpl_cmd_fixed_param)); 4327 cmd->vdev_id = vdev_id; 4328 cmd->buf_len = tmpl_len; 4329 buf_ptr += sizeof(wmi_prb_tmpl_cmd_fixed_param); 4330 4331 bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr; 4332 WMITLV_SET_HDR(&bcn_prb_info->tlv_header, 4333 WMITLV_TAG_STRUC_wmi_bcn_prb_info, 4334 WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info)); 4335 bcn_prb_info->caps = 0; 4336 bcn_prb_info->erp = 0; 4337 buf_ptr += sizeof(wmi_bcn_prb_info); 4338 4339 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, tmpl_len_aligned); 4340 buf_ptr += WMI_TLV_HDR_SIZE; 4341 qdf_mem_copy(buf_ptr, probe_rsp_info->prb_rsp_template_frm, tmpl_len); 4342 4343 wmi_mtrace(WMI_PRB_TMPL_CMDID, cmd->vdev_id, 0); 4344 ret = wmi_unified_cmd_send(wmi_handle, 4345 wmi_buf, wmi_buf_len, WMI_PRB_TMPL_CMDID); 4346 if (QDF_IS_STATUS_ERROR(ret)) { 4347 WMI_LOGE(FL("Failed to send PRB RSP tmpl: %d"), ret); 4348 wmi_buf_free(wmi_buf); 4349 } 4350 4351 return ret; 4352 } 4353 4354 #if defined(ATH_SUPPORT_WAPI) || defined(FEATURE_WLAN_WAPI) 4355 #define WPI_IV_LEN 16 4356 4357 /** 4358 * wmi_update_wpi_key_counter() - update WAPI tsc and rsc key counters 4359 * 4360 * @dest_tx: destination address of tsc key counter 4361 * @src_tx: source address of tsc key counter 4362 * @dest_rx: destination address of rsc key counter 4363 * @src_rx: source address of rsc key counter 4364 * 4365 * This function copies WAPI tsc and rsc key counters in the wmi buffer. 4366 * 4367 * Return: None 4368 * 4369 */ 4370 static void wmi_update_wpi_key_counter(uint8_t *dest_tx, uint8_t *src_tx, 4371 uint8_t *dest_rx, uint8_t *src_rx) 4372 { 4373 qdf_mem_copy(dest_tx, src_tx, WPI_IV_LEN); 4374 qdf_mem_copy(dest_rx, src_rx, WPI_IV_LEN); 4375 } 4376 #else 4377 static void wmi_update_wpi_key_counter(uint8_t *dest_tx, uint8_t *src_tx, 4378 uint8_t *dest_rx, uint8_t *src_rx) 4379 { 4380 return; 4381 } 4382 #endif 4383 4384 /** 4385 * send_setup_install_key_cmd_tlv() - set key parameters 4386 * @wmi_handle: wmi handle 4387 * @key_params: key parameters 4388 * 4389 * This function fills structure from information 4390 * passed in key_params. 4391 * 4392 * Return: QDF_STATUS_SUCCESS - success 4393 * QDF_STATUS_E_FAILURE - failure 4394 * QDF_STATUS_E_NOMEM - not able to allocate buffer 4395 */ 4396 static QDF_STATUS send_setup_install_key_cmd_tlv(wmi_unified_t wmi_handle, 4397 struct set_key_params *key_params) 4398 { 4399 wmi_vdev_install_key_cmd_fixed_param *cmd; 4400 wmi_buf_t buf; 4401 uint8_t *buf_ptr; 4402 uint32_t len; 4403 uint8_t *key_data; 4404 QDF_STATUS status; 4405 4406 len = sizeof(*cmd) + roundup(key_params->key_len, sizeof(uint32_t)) + 4407 WMI_TLV_HDR_SIZE; 4408 4409 buf = wmi_buf_alloc(wmi_handle, len); 4410 if (!buf) 4411 return QDF_STATUS_E_NOMEM; 4412 4413 buf_ptr = (uint8_t *) wmi_buf_data(buf); 4414 cmd = (wmi_vdev_install_key_cmd_fixed_param *) buf_ptr; 4415 WMITLV_SET_HDR(&cmd->tlv_header, 4416 WMITLV_TAG_STRUC_wmi_vdev_install_key_cmd_fixed_param, 4417 WMITLV_GET_STRUCT_TLVLEN 4418 (wmi_vdev_install_key_cmd_fixed_param)); 4419 cmd->vdev_id = key_params->vdev_id; 4420 cmd->key_ix = key_params->key_idx; 4421 if (key_params->group_key_idx) { 4422 cmd->is_group_key_ix_valid = 1; 4423 cmd->group_key_ix = key_params->group_key_idx; 4424 } 4425 4426 4427 WMI_CHAR_ARRAY_TO_MAC_ADDR(key_params->peer_mac, &cmd->peer_macaddr); 4428 cmd->key_flags |= key_params->key_flags; 4429 cmd->key_cipher = key_params->key_cipher; 4430 if ((key_params->key_txmic_len) && 4431 (key_params->key_rxmic_len)) { 4432 cmd->key_txmic_len = key_params->key_txmic_len; 4433 cmd->key_rxmic_len = key_params->key_rxmic_len; 4434 } 4435 #if defined(ATH_SUPPORT_WAPI) || defined(FEATURE_WLAN_WAPI) 4436 wmi_update_wpi_key_counter(cmd->wpi_key_tsc_counter, 4437 key_params->tx_iv, 4438 cmd->wpi_key_rsc_counter, 4439 key_params->rx_iv); 4440 #endif 4441 buf_ptr += sizeof(wmi_vdev_install_key_cmd_fixed_param); 4442 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 4443 roundup(key_params->key_len, sizeof(uint32_t))); 4444 key_data = (uint8_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 4445 qdf_mem_copy((void *)key_data, 4446 (const void *)key_params->key_data, key_params->key_len); 4447 qdf_mem_copy(&cmd->key_rsc_counter, &key_params->key_rsc_ctr, 4448 sizeof(wmi_key_seq_counter)); 4449 cmd->key_len = key_params->key_len; 4450 4451 qdf_mem_copy(&cmd->key_tsc_counter, &key_params->key_tsc_counter, 4452 sizeof(wmi_key_seq_counter)); 4453 wmi_mtrace(WMI_VDEV_INSTALL_KEY_CMDID, cmd->vdev_id, 0); 4454 status = wmi_unified_cmd_send(wmi_handle, buf, len, 4455 WMI_VDEV_INSTALL_KEY_CMDID); 4456 if (QDF_IS_STATUS_ERROR(status)) { 4457 qdf_mem_zero(wmi_buf_data(buf), len); 4458 wmi_buf_free(buf); 4459 } 4460 return status; 4461 } 4462 4463 /** 4464 * send_p2p_go_set_beacon_ie_cmd_tlv() - set beacon IE for p2p go 4465 * @wmi_handle: wmi handle 4466 * @vdev_id: vdev id 4467 * @p2p_ie: p2p IE 4468 * 4469 * Return: QDF_STATUS_SUCCESS for success or error code 4470 */ 4471 static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle, 4472 uint32_t vdev_id, uint8_t *p2p_ie) 4473 { 4474 QDF_STATUS ret; 4475 wmi_p2p_go_set_beacon_ie_fixed_param *cmd; 4476 wmi_buf_t wmi_buf; 4477 uint32_t ie_len, ie_len_aligned, wmi_buf_len; 4478 uint8_t *buf_ptr; 4479 4480 ie_len = (uint32_t) (p2p_ie[1] + 2); 4481 4482 /* More than one P2P IE may be included in a single frame. 4483 If multiple P2P IEs are present, the complete P2P attribute 4484 data consists of the concatenation of the P2P Attribute 4485 fields of the P2P IEs. The P2P Attributes field of each 4486 P2P IE may be any length up to the maximum (251 octets). 4487 In this case host sends one P2P IE to firmware so the length 4488 should not exceed more than 251 bytes 4489 */ 4490 if (ie_len > 251) { 4491 WMI_LOGE("%s : invalid p2p ie length %u", __func__, ie_len); 4492 return QDF_STATUS_E_INVAL; 4493 } 4494 4495 ie_len_aligned = roundup(ie_len, sizeof(uint32_t)); 4496 4497 wmi_buf_len = 4498 sizeof(wmi_p2p_go_set_beacon_ie_fixed_param) + ie_len_aligned + 4499 WMI_TLV_HDR_SIZE; 4500 4501 wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); 4502 if (!wmi_buf) 4503 return QDF_STATUS_E_NOMEM; 4504 4505 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 4506 4507 cmd = (wmi_p2p_go_set_beacon_ie_fixed_param *) buf_ptr; 4508 WMITLV_SET_HDR(&cmd->tlv_header, 4509 WMITLV_TAG_STRUC_wmi_p2p_go_set_beacon_ie_fixed_param, 4510 WMITLV_GET_STRUCT_TLVLEN 4511 (wmi_p2p_go_set_beacon_ie_fixed_param)); 4512 cmd->vdev_id = vdev_id; 4513 cmd->ie_buf_len = ie_len; 4514 4515 buf_ptr += sizeof(wmi_p2p_go_set_beacon_ie_fixed_param); 4516 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned); 4517 buf_ptr += WMI_TLV_HDR_SIZE; 4518 qdf_mem_copy(buf_ptr, p2p_ie, ie_len); 4519 4520 WMI_LOGD("%s: Sending WMI_P2P_GO_SET_BEACON_IE", __func__); 4521 4522 wmi_mtrace(WMI_P2P_GO_SET_BEACON_IE, cmd->vdev_id, 0); 4523 ret = wmi_unified_cmd_send(wmi_handle, 4524 wmi_buf, wmi_buf_len, 4525 WMI_P2P_GO_SET_BEACON_IE); 4526 if (QDF_IS_STATUS_ERROR(ret)) { 4527 WMI_LOGE("Failed to send bcn tmpl: %d", ret); 4528 wmi_buf_free(wmi_buf); 4529 } 4530 4531 WMI_LOGD("%s: Successfully sent WMI_P2P_GO_SET_BEACON_IE", __func__); 4532 return ret; 4533 } 4534 4535 /** 4536 * send_scan_probe_setoui_cmd_tlv() - set scan probe OUI 4537 * @wmi_handle: wmi handle 4538 * @psetoui: OUI parameters 4539 * 4540 * set scan probe OUI parameters in firmware 4541 * 4542 * Return: CDF status 4543 */ 4544 static QDF_STATUS send_scan_probe_setoui_cmd_tlv(wmi_unified_t wmi_handle, 4545 struct scan_mac_oui *psetoui) 4546 { 4547 wmi_scan_prob_req_oui_cmd_fixed_param *cmd; 4548 wmi_buf_t wmi_buf; 4549 uint32_t len; 4550 uint8_t *buf_ptr; 4551 uint32_t *oui_buf; 4552 struct probe_req_whitelist_attr *ie_whitelist = &psetoui->ie_whitelist; 4553 4554 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + 4555 ie_whitelist->num_vendor_oui * sizeof(wmi_vendor_oui); 4556 4557 wmi_buf = wmi_buf_alloc(wmi_handle, len); 4558 if (!wmi_buf) 4559 return QDF_STATUS_E_NOMEM; 4560 4561 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 4562 cmd = (wmi_scan_prob_req_oui_cmd_fixed_param *) buf_ptr; 4563 WMITLV_SET_HDR(&cmd->tlv_header, 4564 WMITLV_TAG_STRUC_wmi_scan_prob_req_oui_cmd_fixed_param, 4565 WMITLV_GET_STRUCT_TLVLEN 4566 (wmi_scan_prob_req_oui_cmd_fixed_param)); 4567 4568 oui_buf = &cmd->prob_req_oui; 4569 qdf_mem_zero(oui_buf, sizeof(cmd->prob_req_oui)); 4570 *oui_buf = psetoui->oui[0] << 16 | psetoui->oui[1] << 8 4571 | psetoui->oui[2]; 4572 WMI_LOGD("%s: wmi:oui received from hdd %08x", __func__, 4573 cmd->prob_req_oui); 4574 4575 cmd->vdev_id = psetoui->vdev_id; 4576 cmd->flags = WMI_SCAN_PROBE_OUI_SPOOFED_MAC_IN_PROBE_REQ; 4577 if (psetoui->enb_probe_req_sno_randomization) 4578 cmd->flags |= WMI_SCAN_PROBE_OUI_RANDOM_SEQ_NO_IN_PROBE_REQ; 4579 4580 if (ie_whitelist->white_list) { 4581 wmi_fill_ie_whitelist_attrs(cmd->ie_bitmap, 4582 &cmd->num_vendor_oui, 4583 ie_whitelist); 4584 cmd->flags |= 4585 WMI_SCAN_PROBE_OUI_ENABLE_IE_WHITELIST_IN_PROBE_REQ; 4586 } 4587 4588 buf_ptr += sizeof(*cmd); 4589 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 4590 ie_whitelist->num_vendor_oui * sizeof(wmi_vendor_oui)); 4591 buf_ptr += WMI_TLV_HDR_SIZE; 4592 4593 if (cmd->num_vendor_oui != 0) { 4594 wmi_fill_vendor_oui(buf_ptr, cmd->num_vendor_oui, 4595 ie_whitelist->voui); 4596 buf_ptr += cmd->num_vendor_oui * sizeof(wmi_vendor_oui); 4597 } 4598 4599 wmi_mtrace(WMI_SCAN_PROB_REQ_OUI_CMDID, cmd->vdev_id, 0); 4600 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 4601 WMI_SCAN_PROB_REQ_OUI_CMDID)) { 4602 WMI_LOGE("%s: failed to send command", __func__); 4603 wmi_buf_free(wmi_buf); 4604 return QDF_STATUS_E_FAILURE; 4605 } 4606 return QDF_STATUS_SUCCESS; 4607 } 4608 4609 #ifdef IPA_OFFLOAD 4610 /** send_ipa_offload_control_cmd_tlv() - ipa offload control parameter 4611 * @wmi_handle: wmi handle 4612 * @ipa_offload: ipa offload control parameter 4613 * 4614 * Returns: 0 on success, error number otherwise 4615 */ 4616 static QDF_STATUS send_ipa_offload_control_cmd_tlv(wmi_unified_t wmi_handle, 4617 struct ipa_uc_offload_control_params *ipa_offload) 4618 { 4619 wmi_ipa_offload_enable_disable_cmd_fixed_param *cmd; 4620 wmi_buf_t wmi_buf; 4621 uint32_t len; 4622 u_int8_t *buf_ptr; 4623 4624 len = sizeof(*cmd); 4625 wmi_buf = wmi_buf_alloc(wmi_handle, len); 4626 if (!wmi_buf) 4627 return QDF_STATUS_E_NOMEM; 4628 4629 WMI_LOGD("%s: offload_type=%d, enable=%d", __func__, 4630 ipa_offload->offload_type, ipa_offload->enable); 4631 4632 buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf); 4633 4634 cmd = (wmi_ipa_offload_enable_disable_cmd_fixed_param *)buf_ptr; 4635 WMITLV_SET_HDR(&cmd->tlv_header, 4636 WMITLV_TAG_STRUCT_wmi_ipa_offload_enable_disable_cmd_fixed_param, 4637 WMITLV_GET_STRUCT_TLVLEN( 4638 wmi_ipa_offload_enable_disable_cmd_fixed_param)); 4639 4640 cmd->offload_type = ipa_offload->offload_type; 4641 cmd->vdev_id = ipa_offload->vdev_id; 4642 cmd->enable = ipa_offload->enable; 4643 4644 wmi_mtrace(WMI_IPA_OFFLOAD_ENABLE_DISABLE_CMDID, cmd->vdev_id, 0); 4645 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 4646 WMI_IPA_OFFLOAD_ENABLE_DISABLE_CMDID)) { 4647 WMI_LOGE("%s: failed to command", __func__); 4648 wmi_buf_free(wmi_buf); 4649 return QDF_STATUS_E_FAILURE; 4650 } 4651 4652 return QDF_STATUS_SUCCESS; 4653 } 4654 #endif 4655 4656 /** 4657 * send_pno_stop_cmd_tlv() - PNO stop request 4658 * @wmi_handle: wmi handle 4659 * @vdev_id: vdev id 4660 * 4661 * This function request FW to stop ongoing PNO operation. 4662 * 4663 * Return: CDF status 4664 */ 4665 static QDF_STATUS send_pno_stop_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id) 4666 { 4667 wmi_nlo_config_cmd_fixed_param *cmd; 4668 int32_t len = sizeof(*cmd); 4669 wmi_buf_t buf; 4670 uint8_t *buf_ptr; 4671 int ret; 4672 4673 /* 4674 * TLV place holder for array of structures nlo_configured_parameters 4675 * TLV place holder for array of uint32_t channel_list 4676 * TLV place holder for chnl prediction cfg 4677 */ 4678 len += WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE; 4679 buf = wmi_buf_alloc(wmi_handle, len); 4680 if (!buf) 4681 return QDF_STATUS_E_NOMEM; 4682 4683 cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf); 4684 buf_ptr = (uint8_t *) cmd; 4685 4686 WMITLV_SET_HDR(&cmd->tlv_header, 4687 WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param, 4688 WMITLV_GET_STRUCT_TLVLEN 4689 (wmi_nlo_config_cmd_fixed_param)); 4690 4691 cmd->vdev_id = vdev_id; 4692 cmd->flags = WMI_NLO_CONFIG_STOP; 4693 buf_ptr += sizeof(*cmd); 4694 4695 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0); 4696 buf_ptr += WMI_TLV_HDR_SIZE; 4697 4698 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0); 4699 buf_ptr += WMI_TLV_HDR_SIZE; 4700 4701 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0); 4702 buf_ptr += WMI_TLV_HDR_SIZE; 4703 4704 wmi_mtrace(WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID, cmd->vdev_id, 0); 4705 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 4706 WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID); 4707 if (ret) { 4708 WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__); 4709 wmi_buf_free(buf); 4710 return QDF_STATUS_E_FAILURE; 4711 } 4712 4713 return QDF_STATUS_SUCCESS; 4714 } 4715 4716 /** 4717 * wmi_set_pno_channel_prediction() - Set PNO channel prediction 4718 * @buf_ptr: Buffer passed by upper layers 4719 * @pno: Buffer to be sent to the firmware 4720 * 4721 * Copy the PNO Channel prediction configuration parameters 4722 * passed by the upper layers to a WMI format TLV and send it 4723 * down to the firmware. 4724 * 4725 * Return: None 4726 */ 4727 static void wmi_set_pno_channel_prediction(uint8_t *buf_ptr, 4728 struct pno_scan_req_params *pno) 4729 { 4730 nlo_channel_prediction_cfg *channel_prediction_cfg = 4731 (nlo_channel_prediction_cfg *) buf_ptr; 4732 WMITLV_SET_HDR(&channel_prediction_cfg->tlv_header, 4733 WMITLV_TAG_ARRAY_BYTE, 4734 WMITLV_GET_STRUCT_TLVLEN(nlo_channel_prediction_cfg)); 4735 #ifdef FEATURE_WLAN_SCAN_PNO 4736 channel_prediction_cfg->enable = pno->pno_channel_prediction; 4737 channel_prediction_cfg->top_k_num = pno->top_k_num_of_channels; 4738 channel_prediction_cfg->stationary_threshold = pno->stationary_thresh; 4739 channel_prediction_cfg->full_scan_period_ms = 4740 pno->channel_prediction_full_scan; 4741 #endif 4742 buf_ptr += sizeof(nlo_channel_prediction_cfg); 4743 WMI_LOGD("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d", 4744 channel_prediction_cfg->enable, 4745 channel_prediction_cfg->top_k_num, 4746 channel_prediction_cfg->stationary_threshold, 4747 channel_prediction_cfg->full_scan_period_ms); 4748 } 4749 4750 /** 4751 * send_nlo_mawc_cmd_tlv() - Send MAWC NLO configuration 4752 * @wmi_handle: wmi handle 4753 * @params: configuration parameters 4754 * 4755 * Return: QDF_STATUS 4756 */ 4757 static QDF_STATUS send_nlo_mawc_cmd_tlv(wmi_unified_t wmi_handle, 4758 struct nlo_mawc_params *params) 4759 { 4760 wmi_buf_t buf = NULL; 4761 QDF_STATUS status; 4762 int len; 4763 uint8_t *buf_ptr; 4764 wmi_nlo_configure_mawc_cmd_fixed_param *wmi_nlo_mawc_params; 4765 4766 len = sizeof(*wmi_nlo_mawc_params); 4767 buf = wmi_buf_alloc(wmi_handle, len); 4768 if (!buf) 4769 return QDF_STATUS_E_NOMEM; 4770 4771 buf_ptr = (uint8_t *) wmi_buf_data(buf); 4772 wmi_nlo_mawc_params = 4773 (wmi_nlo_configure_mawc_cmd_fixed_param *) buf_ptr; 4774 WMITLV_SET_HDR(&wmi_nlo_mawc_params->tlv_header, 4775 WMITLV_TAG_STRUC_wmi_nlo_configure_mawc_cmd_fixed_param, 4776 WMITLV_GET_STRUCT_TLVLEN 4777 (wmi_nlo_configure_mawc_cmd_fixed_param)); 4778 wmi_nlo_mawc_params->vdev_id = params->vdev_id; 4779 if (params->enable) 4780 wmi_nlo_mawc_params->enable = 1; 4781 else 4782 wmi_nlo_mawc_params->enable = 0; 4783 wmi_nlo_mawc_params->exp_backoff_ratio = params->exp_backoff_ratio; 4784 wmi_nlo_mawc_params->init_scan_interval = params->init_scan_interval; 4785 wmi_nlo_mawc_params->max_scan_interval = params->max_scan_interval; 4786 WMI_LOGD(FL("MAWC NLO en=%d, vdev=%d, ratio=%d, SCAN init=%d, max=%d"), 4787 wmi_nlo_mawc_params->enable, wmi_nlo_mawc_params->vdev_id, 4788 wmi_nlo_mawc_params->exp_backoff_ratio, 4789 wmi_nlo_mawc_params->init_scan_interval, 4790 wmi_nlo_mawc_params->max_scan_interval); 4791 4792 wmi_mtrace(WMI_NLO_CONFIGURE_MAWC_CMDID, NO_SESSION, 0); 4793 status = wmi_unified_cmd_send(wmi_handle, buf, 4794 len, WMI_NLO_CONFIGURE_MAWC_CMDID); 4795 if (QDF_IS_STATUS_ERROR(status)) { 4796 WMI_LOGE("WMI_NLO_CONFIGURE_MAWC_CMDID failed, Error %d", 4797 status); 4798 wmi_buf_free(buf); 4799 return QDF_STATUS_E_FAILURE; 4800 } 4801 4802 return QDF_STATUS_SUCCESS; 4803 } 4804 4805 /** 4806 * send_pno_start_cmd_tlv() - PNO start request 4807 * @wmi_handle: wmi handle 4808 * @pno: PNO request 4809 * 4810 * This function request FW to start PNO request. 4811 * Request: CDF status 4812 */ 4813 static QDF_STATUS send_pno_start_cmd_tlv(wmi_unified_t wmi_handle, 4814 struct pno_scan_req_params *pno) 4815 { 4816 wmi_nlo_config_cmd_fixed_param *cmd; 4817 nlo_configured_parameters *nlo_list; 4818 uint32_t *channel_list; 4819 int32_t len; 4820 wmi_buf_t buf; 4821 uint8_t *buf_ptr; 4822 uint8_t i; 4823 int ret; 4824 struct probe_req_whitelist_attr *ie_whitelist = &pno->ie_whitelist; 4825 connected_nlo_rssi_params *nlo_relative_rssi; 4826 connected_nlo_bss_band_rssi_pref *nlo_band_rssi; 4827 4828 /* 4829 * TLV place holder for array nlo_configured_parameters(nlo_list) 4830 * TLV place holder for array of uint32_t channel_list 4831 * TLV place holder for chnnl prediction cfg 4832 * TLV place holder for array of wmi_vendor_oui 4833 * TLV place holder for array of connected_nlo_bss_band_rssi_pref 4834 */ 4835 len = sizeof(*cmd) + 4836 WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + 4837 WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE; 4838 4839 len += sizeof(uint32_t) * QDF_MIN(pno->networks_list[0].channel_cnt, 4840 WMI_NLO_MAX_CHAN); 4841 len += sizeof(nlo_configured_parameters) * 4842 QDF_MIN(pno->networks_cnt, WMI_NLO_MAX_SSIDS); 4843 len += sizeof(nlo_channel_prediction_cfg); 4844 len += sizeof(enlo_candidate_score_params); 4845 len += sizeof(wmi_vendor_oui) * ie_whitelist->num_vendor_oui; 4846 len += sizeof(connected_nlo_rssi_params); 4847 len += sizeof(connected_nlo_bss_band_rssi_pref); 4848 4849 buf = wmi_buf_alloc(wmi_handle, len); 4850 if (!buf) 4851 return QDF_STATUS_E_NOMEM; 4852 4853 cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf); 4854 4855 buf_ptr = (uint8_t *) cmd; 4856 WMITLV_SET_HDR(&cmd->tlv_header, 4857 WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param, 4858 WMITLV_GET_STRUCT_TLVLEN 4859 (wmi_nlo_config_cmd_fixed_param)); 4860 cmd->vdev_id = pno->vdev_id; 4861 cmd->flags = WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN; 4862 4863 #ifdef FEATURE_WLAN_SCAN_PNO 4864 WMI_SCAN_SET_DWELL_MODE(cmd->flags, 4865 pno->adaptive_dwell_mode); 4866 #endif 4867 /* Current FW does not support min-max range for dwell time */ 4868 cmd->active_dwell_time = pno->active_dwell_time; 4869 cmd->passive_dwell_time = pno->passive_dwell_time; 4870 4871 if (pno->do_passive_scan) 4872 cmd->flags |= WMI_NLO_CONFIG_SCAN_PASSIVE; 4873 /* Copy scan interval */ 4874 cmd->fast_scan_period = pno->fast_scan_period; 4875 cmd->slow_scan_period = pno->slow_scan_period; 4876 cmd->delay_start_time = WMI_SEC_TO_MSEC(pno->delay_start_time); 4877 cmd->fast_scan_max_cycles = pno->fast_scan_max_cycles; 4878 cmd->scan_backoff_multiplier = pno->scan_backoff_multiplier; 4879 4880 /* mac randomization attributes */ 4881 if (pno->scan_random.randomize) { 4882 cmd->flags |= WMI_NLO_CONFIG_SPOOFED_MAC_IN_PROBE_REQ | 4883 WMI_NLO_CONFIG_RANDOM_SEQ_NO_IN_PROBE_REQ; 4884 wmi_copy_scan_random_mac(pno->scan_random.mac_addr, 4885 pno->scan_random.mac_mask, 4886 &cmd->mac_addr, 4887 &cmd->mac_mask); 4888 } 4889 4890 buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param); 4891 4892 cmd->no_of_ssids = QDF_MIN(pno->networks_cnt, WMI_NLO_MAX_SSIDS); 4893 4894 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 4895 cmd->no_of_ssids * sizeof(nlo_configured_parameters)); 4896 buf_ptr += WMI_TLV_HDR_SIZE; 4897 4898 nlo_list = (nlo_configured_parameters *) buf_ptr; 4899 for (i = 0; i < cmd->no_of_ssids; i++) { 4900 WMITLV_SET_HDR(&nlo_list[i].tlv_header, 4901 WMITLV_TAG_ARRAY_BYTE, 4902 WMITLV_GET_STRUCT_TLVLEN 4903 (nlo_configured_parameters)); 4904 /* Copy ssid and it's length */ 4905 nlo_list[i].ssid.valid = true; 4906 nlo_list[i].ssid.ssid.ssid_len = 4907 pno->networks_list[i].ssid.length; 4908 qdf_mem_copy(nlo_list[i].ssid.ssid.ssid, 4909 pno->networks_list[i].ssid.ssid, 4910 nlo_list[i].ssid.ssid.ssid_len); 4911 4912 /* Copy rssi threshold */ 4913 if (pno->networks_list[i].rssi_thresh && 4914 pno->networks_list[i].rssi_thresh > 4915 WMI_RSSI_THOLD_DEFAULT) { 4916 nlo_list[i].rssi_cond.valid = true; 4917 nlo_list[i].rssi_cond.rssi = 4918 pno->networks_list[i].rssi_thresh; 4919 } 4920 nlo_list[i].bcast_nw_type.valid = true; 4921 nlo_list[i].bcast_nw_type.bcast_nw_type = 4922 pno->networks_list[i].bc_new_type; 4923 } 4924 buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters); 4925 4926 /* Copy channel info */ 4927 cmd->num_of_channels = QDF_MIN(pno->networks_list[0].channel_cnt, 4928 WMI_NLO_MAX_CHAN); 4929 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 4930 (cmd->num_of_channels * sizeof(uint32_t))); 4931 buf_ptr += WMI_TLV_HDR_SIZE; 4932 4933 channel_list = (uint32_t *) buf_ptr; 4934 for (i = 0; i < cmd->num_of_channels; i++) { 4935 channel_list[i] = pno->networks_list[0].channels[i]; 4936 4937 if (channel_list[i] < WMI_NLO_FREQ_THRESH) 4938 channel_list[i] = 4939 wlan_chan_to_freq(pno-> 4940 networks_list[0].channels[i]); 4941 } 4942 buf_ptr += cmd->num_of_channels * sizeof(uint32_t); 4943 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 4944 sizeof(nlo_channel_prediction_cfg)); 4945 buf_ptr += WMI_TLV_HDR_SIZE; 4946 wmi_set_pno_channel_prediction(buf_ptr, pno); 4947 buf_ptr += sizeof(nlo_channel_prediction_cfg); 4948 /** TODO: Discrete firmware doesn't have command/option to configure 4949 * App IE which comes from wpa_supplicant as of part PNO start request. 4950 */ 4951 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_enlo_candidate_score_param, 4952 WMITLV_GET_STRUCT_TLVLEN(enlo_candidate_score_params)); 4953 buf_ptr += sizeof(enlo_candidate_score_params); 4954 4955 if (ie_whitelist->white_list) { 4956 cmd->flags |= WMI_NLO_CONFIG_ENABLE_IE_WHITELIST_IN_PROBE_REQ; 4957 wmi_fill_ie_whitelist_attrs(cmd->ie_bitmap, 4958 &cmd->num_vendor_oui, 4959 ie_whitelist); 4960 } 4961 4962 /* ie white list */ 4963 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 4964 ie_whitelist->num_vendor_oui * sizeof(wmi_vendor_oui)); 4965 buf_ptr += WMI_TLV_HDR_SIZE; 4966 if (cmd->num_vendor_oui != 0) { 4967 wmi_fill_vendor_oui(buf_ptr, cmd->num_vendor_oui, 4968 ie_whitelist->voui); 4969 buf_ptr += cmd->num_vendor_oui * sizeof(wmi_vendor_oui); 4970 } 4971 4972 if (pno->relative_rssi_set) 4973 cmd->flags |= WMI_NLO_CONFIG_ENABLE_CNLO_RSSI_CONFIG; 4974 4975 /* 4976 * Firmware calculation using connected PNO params: 4977 * New AP's RSSI >= (Connected AP's RSSI + relative_rssi +/- rssi_pref) 4978 * deduction of rssi_pref for chosen band_pref and 4979 * addition of rssi_pref for remaining bands (other than chosen band). 4980 */ 4981 nlo_relative_rssi = (connected_nlo_rssi_params *) buf_ptr; 4982 WMITLV_SET_HDR(&nlo_relative_rssi->tlv_header, 4983 WMITLV_TAG_STRUC_wmi_connected_nlo_rssi_params, 4984 WMITLV_GET_STRUCT_TLVLEN(connected_nlo_rssi_params)); 4985 nlo_relative_rssi->relative_rssi = pno->relative_rssi; 4986 buf_ptr += sizeof(*nlo_relative_rssi); 4987 4988 /* 4989 * As of now Kernel and Host supports one band and rssi preference. 4990 * Firmware supports array of band and rssi preferences 4991 */ 4992 cmd->num_cnlo_band_pref = 1; 4993 WMITLV_SET_HDR(buf_ptr, 4994 WMITLV_TAG_ARRAY_STRUC, 4995 cmd->num_cnlo_band_pref * 4996 sizeof(connected_nlo_bss_band_rssi_pref)); 4997 buf_ptr += WMI_TLV_HDR_SIZE; 4998 4999 nlo_band_rssi = (connected_nlo_bss_band_rssi_pref *) buf_ptr; 5000 for (i = 0; i < cmd->num_cnlo_band_pref; i++) { 5001 WMITLV_SET_HDR(&nlo_band_rssi[i].tlv_header, 5002 WMITLV_TAG_STRUC_wmi_connected_nlo_bss_band_rssi_pref, 5003 WMITLV_GET_STRUCT_TLVLEN( 5004 connected_nlo_bss_band_rssi_pref)); 5005 nlo_band_rssi[i].band = pno->band_rssi_pref.band; 5006 nlo_band_rssi[i].rssi_pref = pno->band_rssi_pref.rssi; 5007 } 5008 buf_ptr += cmd->num_cnlo_band_pref * sizeof(*nlo_band_rssi); 5009 5010 wmi_mtrace(WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID, cmd->vdev_id, 0); 5011 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5012 WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID); 5013 if (ret) { 5014 WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__); 5015 wmi_buf_free(buf); 5016 return QDF_STATUS_E_FAILURE; 5017 } 5018 5019 return QDF_STATUS_SUCCESS; 5020 } 5021 5022 #ifdef WLAN_FEATURE_LINK_LAYER_STATS 5023 /** 5024 * send_process_ll_stats_clear_cmd_tlv() - clear link layer stats 5025 * @wmi_handle: wmi handle 5026 * @clear_req: ll stats clear request command params 5027 * 5028 * Return: QDF_STATUS_SUCCESS for success or error code 5029 */ 5030 static QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle, 5031 const struct ll_stats_clear_params *clear_req) 5032 { 5033 wmi_clear_link_stats_cmd_fixed_param *cmd; 5034 int32_t len; 5035 wmi_buf_t buf; 5036 uint8_t *buf_ptr; 5037 int ret; 5038 5039 len = sizeof(*cmd); 5040 buf = wmi_buf_alloc(wmi_handle, len); 5041 5042 if (!buf) 5043 return QDF_STATUS_E_NOMEM; 5044 5045 buf_ptr = (uint8_t *) wmi_buf_data(buf); 5046 qdf_mem_zero(buf_ptr, len); 5047 cmd = (wmi_clear_link_stats_cmd_fixed_param *) buf_ptr; 5048 5049 WMITLV_SET_HDR(&cmd->tlv_header, 5050 WMITLV_TAG_STRUC_wmi_clear_link_stats_cmd_fixed_param, 5051 WMITLV_GET_STRUCT_TLVLEN 5052 (wmi_clear_link_stats_cmd_fixed_param)); 5053 5054 cmd->stop_stats_collection_req = clear_req->stop_req; 5055 cmd->vdev_id = clear_req->vdev_id; 5056 cmd->stats_clear_req_mask = clear_req->stats_clear_mask; 5057 5058 WMI_CHAR_ARRAY_TO_MAC_ADDR(clear_req->peer_macaddr.bytes, 5059 &cmd->peer_macaddr); 5060 5061 WMI_LOGD("LINK_LAYER_STATS - Clear Request Params"); 5062 WMI_LOGD("StopReq: %d", cmd->stop_stats_collection_req); 5063 WMI_LOGD("Vdev Id: %d", cmd->vdev_id); 5064 WMI_LOGD("Clear Stat Mask: %d", cmd->stats_clear_req_mask); 5065 WMI_LOGD("Peer MAC Addr: %pM", clear_req->peer_macaddr.bytes); 5066 5067 wmi_mtrace(WMI_CLEAR_LINK_STATS_CMDID, cmd->vdev_id, 0); 5068 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5069 WMI_CLEAR_LINK_STATS_CMDID); 5070 if (ret) { 5071 WMI_LOGE("%s: Failed to send clear link stats req", __func__); 5072 wmi_buf_free(buf); 5073 return QDF_STATUS_E_FAILURE; 5074 } 5075 5076 WMI_LOGD("Clear Link Layer Stats request sent successfully"); 5077 return QDF_STATUS_SUCCESS; 5078 } 5079 5080 /** 5081 * send_process_ll_stats_set_cmd_tlv() - link layer stats set request 5082 * @wmi_handle: wmi handle 5083 * @set_req: ll stats set request command params 5084 * 5085 * Return: QDF_STATUS_SUCCESS for success or error code 5086 */ 5087 static QDF_STATUS send_process_ll_stats_set_cmd_tlv(wmi_unified_t wmi_handle, 5088 const struct ll_stats_set_params *set_req) 5089 { 5090 wmi_start_link_stats_cmd_fixed_param *cmd; 5091 int32_t len; 5092 wmi_buf_t buf; 5093 uint8_t *buf_ptr; 5094 int ret; 5095 5096 len = sizeof(*cmd); 5097 buf = wmi_buf_alloc(wmi_handle, len); 5098 5099 if (!buf) 5100 return QDF_STATUS_E_NOMEM; 5101 5102 buf_ptr = (uint8_t *) wmi_buf_data(buf); 5103 qdf_mem_zero(buf_ptr, len); 5104 cmd = (wmi_start_link_stats_cmd_fixed_param *) buf_ptr; 5105 5106 WMITLV_SET_HDR(&cmd->tlv_header, 5107 WMITLV_TAG_STRUC_wmi_start_link_stats_cmd_fixed_param, 5108 WMITLV_GET_STRUCT_TLVLEN 5109 (wmi_start_link_stats_cmd_fixed_param)); 5110 5111 cmd->mpdu_size_threshold = set_req->mpdu_size_threshold; 5112 cmd->aggressive_statistics_gathering = 5113 set_req->aggressive_statistics_gathering; 5114 5115 WMI_LOGD("LINK_LAYER_STATS - Start/Set Params MPDU Size Thresh : %d Aggressive Gather: %d", 5116 cmd->mpdu_size_threshold, 5117 cmd->aggressive_statistics_gathering); 5118 5119 wmi_mtrace(WMI_START_LINK_STATS_CMDID, NO_SESSION, 0); 5120 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5121 WMI_START_LINK_STATS_CMDID); 5122 if (ret) { 5123 WMI_LOGE("%s: Failed to send set link stats request", __func__); 5124 wmi_buf_free(buf); 5125 return QDF_STATUS_E_FAILURE; 5126 } 5127 5128 return QDF_STATUS_SUCCESS; 5129 } 5130 5131 /** 5132 * send_process_ll_stats_get_cmd_tlv() - link layer stats get request 5133 * @wmi_handle: wmi handle 5134 * @get_req: ll stats get request command params 5135 * 5136 * Return: QDF_STATUS_SUCCESS for success or error code 5137 */ 5138 static QDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle, 5139 const struct ll_stats_get_params *get_req) 5140 { 5141 wmi_request_link_stats_cmd_fixed_param *cmd; 5142 int32_t len; 5143 wmi_buf_t buf; 5144 uint8_t *buf_ptr; 5145 int ret; 5146 5147 len = sizeof(*cmd); 5148 buf = wmi_buf_alloc(wmi_handle, len); 5149 5150 if (!buf) 5151 return QDF_STATUS_E_NOMEM; 5152 5153 buf_ptr = (uint8_t *) wmi_buf_data(buf); 5154 qdf_mem_zero(buf_ptr, len); 5155 cmd = (wmi_request_link_stats_cmd_fixed_param *) buf_ptr; 5156 5157 WMITLV_SET_HDR(&cmd->tlv_header, 5158 WMITLV_TAG_STRUC_wmi_request_link_stats_cmd_fixed_param, 5159 WMITLV_GET_STRUCT_TLVLEN 5160 (wmi_request_link_stats_cmd_fixed_param)); 5161 5162 cmd->request_id = get_req->req_id; 5163 cmd->stats_type = get_req->param_id_mask; 5164 cmd->vdev_id = get_req->vdev_id; 5165 5166 WMI_CHAR_ARRAY_TO_MAC_ADDR(get_req->peer_macaddr.bytes, 5167 &cmd->peer_macaddr); 5168 5169 WMI_LOGD("LINK_LAYER_STATS - Get Request Params Request ID: %u Stats Type: %0x Vdev ID: %d Peer MAC Addr: %pM", 5170 cmd->request_id, cmd->stats_type, cmd->vdev_id, 5171 get_req->peer_macaddr.bytes); 5172 5173 wmi_mtrace(WMI_REQUEST_LINK_STATS_CMDID, cmd->vdev_id, 0); 5174 ret = wmi_unified_cmd_send_pm_chk(wmi_handle, buf, len, 5175 WMI_REQUEST_LINK_STATS_CMDID); 5176 if (ret) { 5177 WMI_LOGE("%s: Failed to send get link stats request", __func__); 5178 wmi_buf_free(buf); 5179 return QDF_STATUS_E_FAILURE; 5180 } 5181 5182 return QDF_STATUS_SUCCESS; 5183 } 5184 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */ 5185 5186 /** 5187 * send_congestion_cmd_tlv() - send request to fw to get CCA 5188 * @wmi_handle: wmi handle 5189 * @vdev_id: vdev id 5190 * 5191 * Return: CDF status 5192 */ 5193 static QDF_STATUS send_congestion_cmd_tlv(wmi_unified_t wmi_handle, 5194 uint8_t vdev_id) 5195 { 5196 wmi_buf_t buf; 5197 wmi_request_stats_cmd_fixed_param *cmd; 5198 uint8_t len; 5199 uint8_t *buf_ptr; 5200 5201 len = sizeof(*cmd); 5202 buf = wmi_buf_alloc(wmi_handle, len); 5203 if (!buf) 5204 return QDF_STATUS_E_FAILURE; 5205 5206 buf_ptr = wmi_buf_data(buf); 5207 cmd = (wmi_request_stats_cmd_fixed_param *)buf_ptr; 5208 WMITLV_SET_HDR(&cmd->tlv_header, 5209 WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param, 5210 WMITLV_GET_STRUCT_TLVLEN 5211 (wmi_request_stats_cmd_fixed_param)); 5212 5213 cmd->stats_id = WMI_REQUEST_CONGESTION_STAT; 5214 cmd->vdev_id = vdev_id; 5215 WMI_LOGD("STATS REQ VDEV_ID:%d stats_id %d -->", 5216 cmd->vdev_id, cmd->stats_id); 5217 5218 wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0); 5219 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5220 WMI_REQUEST_STATS_CMDID)) { 5221 WMI_LOGE("%s: Failed to send WMI_REQUEST_STATS_CMDID", 5222 __func__); 5223 wmi_buf_free(buf); 5224 return QDF_STATUS_E_FAILURE; 5225 } 5226 5227 return QDF_STATUS_SUCCESS; 5228 } 5229 5230 /** 5231 * send_snr_request_cmd_tlv() - send request to fw to get RSSI stats 5232 * @wmi_handle: wmi handle 5233 * @rssi_req: get RSSI request 5234 * 5235 * Return: CDF status 5236 */ 5237 static QDF_STATUS send_snr_request_cmd_tlv(wmi_unified_t wmi_handle) 5238 { 5239 wmi_buf_t buf; 5240 wmi_request_stats_cmd_fixed_param *cmd; 5241 uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param); 5242 5243 buf = wmi_buf_alloc(wmi_handle, len); 5244 if (!buf) 5245 return QDF_STATUS_E_FAILURE; 5246 5247 cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf); 5248 WMITLV_SET_HDR(&cmd->tlv_header, 5249 WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param, 5250 WMITLV_GET_STRUCT_TLVLEN 5251 (wmi_request_stats_cmd_fixed_param)); 5252 cmd->stats_id = WMI_REQUEST_VDEV_STAT; 5253 wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0); 5254 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5255 WMI_REQUEST_STATS_CMDID)) { 5256 WMI_LOGE("Failed to send host stats request to fw"); 5257 wmi_buf_free(buf); 5258 return QDF_STATUS_E_FAILURE; 5259 } 5260 5261 return QDF_STATUS_SUCCESS; 5262 } 5263 5264 /** 5265 * send_snr_cmd_tlv() - get RSSI from fw 5266 * @wmi_handle: wmi handle 5267 * @vdev_id: vdev id 5268 * 5269 * Return: CDF status 5270 */ 5271 static QDF_STATUS send_snr_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id) 5272 { 5273 wmi_buf_t buf; 5274 wmi_request_stats_cmd_fixed_param *cmd; 5275 uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param); 5276 5277 buf = wmi_buf_alloc(wmi_handle, len); 5278 if (!buf) 5279 return QDF_STATUS_E_FAILURE; 5280 5281 cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf); 5282 cmd->vdev_id = vdev_id; 5283 5284 WMITLV_SET_HDR(&cmd->tlv_header, 5285 WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param, 5286 WMITLV_GET_STRUCT_TLVLEN 5287 (wmi_request_stats_cmd_fixed_param)); 5288 cmd->stats_id = WMI_REQUEST_VDEV_STAT; 5289 wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0); 5290 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5291 WMI_REQUEST_STATS_CMDID)) { 5292 WMI_LOGE("Failed to send host stats request to fw"); 5293 wmi_buf_free(buf); 5294 return QDF_STATUS_E_FAILURE; 5295 } 5296 5297 return QDF_STATUS_SUCCESS; 5298 } 5299 5300 /** 5301 * send_link_status_req_cmd_tlv() - process link status request from UMAC 5302 * @wmi_handle: wmi handle 5303 * @link_status: get link params 5304 * 5305 * Return: CDF status 5306 */ 5307 static QDF_STATUS send_link_status_req_cmd_tlv(wmi_unified_t wmi_handle, 5308 struct link_status_params *link_status) 5309 { 5310 wmi_buf_t buf; 5311 wmi_request_stats_cmd_fixed_param *cmd; 5312 uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param); 5313 5314 buf = wmi_buf_alloc(wmi_handle, len); 5315 if (!buf) 5316 return QDF_STATUS_E_FAILURE; 5317 5318 cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf); 5319 WMITLV_SET_HDR(&cmd->tlv_header, 5320 WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param, 5321 WMITLV_GET_STRUCT_TLVLEN 5322 (wmi_request_stats_cmd_fixed_param)); 5323 cmd->stats_id = WMI_REQUEST_VDEV_RATE_STAT; 5324 cmd->vdev_id = link_status->vdev_id; 5325 wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0); 5326 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5327 WMI_REQUEST_STATS_CMDID)) { 5328 WMI_LOGE("Failed to send WMI link status request to fw"); 5329 wmi_buf_free(buf); 5330 return QDF_STATUS_E_FAILURE; 5331 } 5332 5333 return QDF_STATUS_SUCCESS; 5334 } 5335 5336 #ifdef WLAN_SUPPORT_GREEN_AP 5337 /** 5338 * send_egap_conf_params_cmd_tlv() - send wmi cmd of egap configuration params 5339 * @wmi_handle: wmi handler 5340 * @egap_params: pointer to egap_params 5341 * 5342 * Return: 0 for success, otherwise appropriate error code 5343 */ 5344 static QDF_STATUS send_egap_conf_params_cmd_tlv(wmi_unified_t wmi_handle, 5345 struct wlan_green_ap_egap_params *egap_params) 5346 { 5347 wmi_ap_ps_egap_param_cmd_fixed_param *cmd; 5348 wmi_buf_t buf; 5349 int32_t err; 5350 5351 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 5352 if (!buf) 5353 return QDF_STATUS_E_NOMEM; 5354 5355 cmd = (wmi_ap_ps_egap_param_cmd_fixed_param *) wmi_buf_data(buf); 5356 WMITLV_SET_HDR(&cmd->tlv_header, 5357 WMITLV_TAG_STRUC_wmi_ap_ps_egap_param_cmd_fixed_param, 5358 WMITLV_GET_STRUCT_TLVLEN( 5359 wmi_ap_ps_egap_param_cmd_fixed_param)); 5360 5361 cmd->enable = egap_params->host_enable_egap; 5362 cmd->inactivity_time = egap_params->egap_inactivity_time; 5363 cmd->wait_time = egap_params->egap_wait_time; 5364 cmd->flags = egap_params->egap_feature_flags; 5365 wmi_mtrace(WMI_AP_PS_EGAP_PARAM_CMDID, NO_SESSION, 0); 5366 err = wmi_unified_cmd_send(wmi_handle, buf, 5367 sizeof(*cmd), WMI_AP_PS_EGAP_PARAM_CMDID); 5368 if (err) { 5369 WMI_LOGE("Failed to send ap_ps_egap cmd"); 5370 wmi_buf_free(buf); 5371 return QDF_STATUS_E_FAILURE; 5372 } 5373 5374 return QDF_STATUS_SUCCESS; 5375 } 5376 #endif 5377 5378 /** 5379 * wmi_unified_csa_offload_enable() - sen CSA offload enable command 5380 * @wmi_handle: wmi handle 5381 * @vdev_id: vdev id 5382 * 5383 * Return: QDF_STATUS_SUCCESS for success or error code 5384 */ 5385 static QDF_STATUS send_csa_offload_enable_cmd_tlv(wmi_unified_t wmi_handle, 5386 uint8_t vdev_id) 5387 { 5388 wmi_csa_offload_enable_cmd_fixed_param *cmd; 5389 wmi_buf_t buf; 5390 int32_t len = sizeof(*cmd); 5391 5392 WMI_LOGD("%s: vdev_id %d", __func__, vdev_id); 5393 buf = wmi_buf_alloc(wmi_handle, len); 5394 if (!buf) 5395 return QDF_STATUS_E_NOMEM; 5396 5397 cmd = (wmi_csa_offload_enable_cmd_fixed_param *) wmi_buf_data(buf); 5398 WMITLV_SET_HDR(&cmd->tlv_header, 5399 WMITLV_TAG_STRUC_wmi_csa_offload_enable_cmd_fixed_param, 5400 WMITLV_GET_STRUCT_TLVLEN 5401 (wmi_csa_offload_enable_cmd_fixed_param)); 5402 cmd->vdev_id = vdev_id; 5403 cmd->csa_offload_enable = WMI_CSA_OFFLOAD_ENABLE; 5404 wmi_mtrace(WMI_CSA_OFFLOAD_ENABLE_CMDID, cmd->vdev_id, 0); 5405 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5406 WMI_CSA_OFFLOAD_ENABLE_CMDID)) { 5407 WMI_LOGP("%s: Failed to send CSA offload enable command", 5408 __func__); 5409 wmi_buf_free(buf); 5410 return QDF_STATUS_E_FAILURE; 5411 } 5412 5413 return 0; 5414 } 5415 5416 #ifdef WLAN_FEATURE_CIF_CFR 5417 /** 5418 * send_oem_dma_cfg_cmd_tlv() - configure OEM DMA rings 5419 * @wmi_handle: wmi handle 5420 * @data_len: len of dma cfg req 5421 * @data: dma cfg req 5422 * 5423 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5424 */ 5425 static QDF_STATUS send_oem_dma_cfg_cmd_tlv(wmi_unified_t wmi_handle, 5426 wmi_oem_dma_ring_cfg_req_fixed_param *cfg) 5427 { 5428 wmi_buf_t buf; 5429 uint8_t *cmd; 5430 QDF_STATUS ret; 5431 5432 WMITLV_SET_HDR(cfg, 5433 WMITLV_TAG_STRUC_wmi_oem_dma_ring_cfg_req_fixed_param, 5434 (sizeof(*cfg) - WMI_TLV_HDR_SIZE)); 5435 5436 buf = wmi_buf_alloc(wmi_handle, sizeof(*cfg)); 5437 if (!buf) 5438 return QDF_STATUS_E_FAILURE; 5439 5440 cmd = (uint8_t *) wmi_buf_data(buf); 5441 qdf_mem_copy(cmd, cfg, sizeof(*cfg)); 5442 WMI_LOGI(FL("Sending OEM Data Request to target, data len %lu"), 5443 sizeof(*cfg)); 5444 wmi_mtrace(WMI_OEM_DMA_RING_CFG_REQ_CMDID, NO_SESSION, 0); 5445 ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cfg), 5446 WMI_OEM_DMA_RING_CFG_REQ_CMDID); 5447 if (QDF_IS_STATUS_ERROR(ret)) { 5448 WMI_LOGE(FL(":wmi cmd send failed")); 5449 wmi_buf_free(buf); 5450 } 5451 5452 return ret; 5453 } 5454 #endif 5455 5456 /** 5457 * send_start_11d_scan_cmd_tlv() - start 11d scan request 5458 * @wmi_handle: wmi handle 5459 * @start_11d_scan: 11d scan start request parameters 5460 * 5461 * This function request FW to start 11d scan. 5462 * 5463 * Return: QDF status 5464 */ 5465 static QDF_STATUS send_start_11d_scan_cmd_tlv(wmi_unified_t wmi_handle, 5466 struct reg_start_11d_scan_req *start_11d_scan) 5467 { 5468 wmi_11d_scan_start_cmd_fixed_param *cmd; 5469 int32_t len; 5470 wmi_buf_t buf; 5471 int ret; 5472 5473 len = sizeof(*cmd); 5474 buf = wmi_buf_alloc(wmi_handle, len); 5475 if (!buf) 5476 return QDF_STATUS_E_NOMEM; 5477 5478 cmd = (wmi_11d_scan_start_cmd_fixed_param *)wmi_buf_data(buf); 5479 5480 WMITLV_SET_HDR(&cmd->tlv_header, 5481 WMITLV_TAG_STRUC_wmi_11d_scan_start_cmd_fixed_param, 5482 WMITLV_GET_STRUCT_TLVLEN 5483 (wmi_11d_scan_start_cmd_fixed_param)); 5484 5485 cmd->vdev_id = start_11d_scan->vdev_id; 5486 cmd->scan_period_msec = start_11d_scan->scan_period_msec; 5487 cmd->start_interval_msec = start_11d_scan->start_interval_msec; 5488 5489 WMI_LOGD("vdev %d sending 11D scan start req", cmd->vdev_id); 5490 5491 wmi_mtrace(WMI_11D_SCAN_START_CMDID, cmd->vdev_id, 0); 5492 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5493 WMI_11D_SCAN_START_CMDID); 5494 if (ret) { 5495 WMI_LOGE("%s: Failed to send start 11d scan wmi cmd", __func__); 5496 wmi_buf_free(buf); 5497 return QDF_STATUS_E_FAILURE; 5498 } 5499 5500 return QDF_STATUS_SUCCESS; 5501 } 5502 5503 /** 5504 * send_stop_11d_scan_cmd_tlv() - stop 11d scan request 5505 * @wmi_handle: wmi handle 5506 * @start_11d_scan: 11d scan stop request parameters 5507 * 5508 * This function request FW to stop 11d scan. 5509 * 5510 * Return: QDF status 5511 */ 5512 static QDF_STATUS send_stop_11d_scan_cmd_tlv(wmi_unified_t wmi_handle, 5513 struct reg_stop_11d_scan_req *stop_11d_scan) 5514 { 5515 wmi_11d_scan_stop_cmd_fixed_param *cmd; 5516 int32_t len; 5517 wmi_buf_t buf; 5518 int ret; 5519 5520 len = sizeof(*cmd); 5521 buf = wmi_buf_alloc(wmi_handle, len); 5522 if (!buf) 5523 return QDF_STATUS_E_NOMEM; 5524 5525 cmd = (wmi_11d_scan_stop_cmd_fixed_param *)wmi_buf_data(buf); 5526 5527 WMITLV_SET_HDR(&cmd->tlv_header, 5528 WMITLV_TAG_STRUC_wmi_11d_scan_stop_cmd_fixed_param, 5529 WMITLV_GET_STRUCT_TLVLEN 5530 (wmi_11d_scan_stop_cmd_fixed_param)); 5531 5532 cmd->vdev_id = stop_11d_scan->vdev_id; 5533 5534 WMI_LOGD("vdev %d sending 11D scan stop req", cmd->vdev_id); 5535 5536 wmi_mtrace(WMI_11D_SCAN_STOP_CMDID, cmd->vdev_id, 0); 5537 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5538 WMI_11D_SCAN_STOP_CMDID); 5539 if (ret) { 5540 WMI_LOGE("%s: Failed to send stop 11d scan wmi cmd", __func__); 5541 wmi_buf_free(buf); 5542 return QDF_STATUS_E_FAILURE; 5543 } 5544 5545 return QDF_STATUS_SUCCESS; 5546 } 5547 5548 /** 5549 * send_start_oem_data_cmd_tlv() - start OEM data request to target 5550 * @wmi_handle: wmi handle 5551 * @data_len: the length of @data 5552 * @data: the pointer to data buf 5553 * 5554 * Return: CDF status 5555 */ 5556 static QDF_STATUS send_start_oem_data_cmd_tlv(wmi_unified_t wmi_handle, 5557 uint32_t data_len, 5558 uint8_t *data) 5559 { 5560 wmi_buf_t buf; 5561 uint8_t *cmd; 5562 QDF_STATUS ret; 5563 5564 buf = wmi_buf_alloc(wmi_handle, 5565 (data_len + WMI_TLV_HDR_SIZE)); 5566 if (!buf) 5567 return QDF_STATUS_E_FAILURE; 5568 5569 cmd = (uint8_t *) wmi_buf_data(buf); 5570 5571 WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE, data_len); 5572 cmd += WMI_TLV_HDR_SIZE; 5573 qdf_mem_copy(cmd, data, 5574 data_len); 5575 5576 WMI_LOGD(FL("Sending OEM Data Request to target, data len %d"), 5577 data_len); 5578 5579 wmi_mtrace(WMI_OEM_REQ_CMDID, NO_SESSION, 0); 5580 ret = wmi_unified_cmd_send(wmi_handle, buf, 5581 (data_len + 5582 WMI_TLV_HDR_SIZE), WMI_OEM_REQ_CMDID); 5583 5584 if (QDF_IS_STATUS_ERROR(ret)) { 5585 WMI_LOGE(FL(":wmi cmd send failed")); 5586 wmi_buf_free(buf); 5587 } 5588 5589 return ret; 5590 } 5591 5592 #ifdef FEATURE_OEM_DATA 5593 /** 5594 * send_start_oemv2_data_cmd_tlv() - start OEM data to target 5595 * @wmi_handle: wmi handle 5596 * @oem_data: the pointer to oem data 5597 * 5598 * Return: QDF status 5599 */ 5600 static QDF_STATUS send_start_oemv2_data_cmd_tlv(wmi_unified_t wmi_handle, 5601 struct oem_data *oem_data) 5602 { 5603 QDF_STATUS ret; 5604 wmi_oem_data_cmd_fixed_param *cmd; 5605 wmi_buf_t buf; 5606 uint16_t len = sizeof(*cmd); 5607 uint16_t oem_data_len_aligned; 5608 uint8_t *buf_ptr; 5609 5610 if (!oem_data || !oem_data->data) { 5611 wmi_err_rl("oem data is not valid"); 5612 return QDF_STATUS_E_FAILURE; 5613 } 5614 oem_data_len_aligned = roundup(oem_data->data_len, sizeof(uint32_t)); 5615 if (oem_data_len_aligned < oem_data->data_len) { 5616 wmi_err_rl("integer overflow while rounding up data_len"); 5617 return QDF_STATUS_E_FAILURE; 5618 } 5619 5620 if (oem_data_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) { 5621 wmi_err_rl("wmi_max_msg_size overflow for given data_len"); 5622 return QDF_STATUS_E_FAILURE; 5623 } 5624 5625 len += WMI_TLV_HDR_SIZE + oem_data_len_aligned; 5626 buf = wmi_buf_alloc(wmi_handle, len); 5627 if (!buf) 5628 return QDF_STATUS_E_NOMEM; 5629 5630 buf_ptr = (uint8_t *)wmi_buf_data(buf); 5631 cmd = (wmi_oem_data_cmd_fixed_param *)buf_ptr; 5632 WMITLV_SET_HDR(&cmd->tlv_header, 5633 WMITLV_TAG_STRUC_wmi_oem_data_cmd_fixed_param, 5634 WMITLV_GET_STRUCT_TLVLEN(wmi_oem_data_cmd_fixed_param)); 5635 5636 cmd->vdev_id = oem_data->vdev_id; 5637 cmd->data_len = oem_data->data_len; 5638 buf_ptr += sizeof(*cmd); 5639 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, oem_data_len_aligned); 5640 buf_ptr += WMI_TLV_HDR_SIZE; 5641 qdf_mem_copy(buf_ptr, oem_data->data, oem_data->data_len); 5642 5643 wmi_mtrace(WMI_OEM_DATA_CMDID, NO_SESSION, 0); 5644 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_OEM_DATA_CMDID); 5645 if (QDF_IS_STATUS_ERROR(ret)) { 5646 wmi_err_rl("Failed with ret = %d", ret); 5647 wmi_buf_free(buf); 5648 } 5649 5650 return ret; 5651 } 5652 #endif 5653 5654 /** 5655 * send_dfs_phyerr_filter_offload_en_cmd_tlv() - enable dfs phyerr filter 5656 * @wmi_handle: wmi handle 5657 * @dfs_phyerr_filter_offload: is dfs phyerr filter offload 5658 * 5659 * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or 5660 * WMI_DFS_PHYERR_FILTER_DIS_CMDID command 5661 * to firmware based on phyerr filtering 5662 * offload status. 5663 * 5664 * Return: 1 success, 0 failure 5665 */ 5666 static QDF_STATUS 5667 send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle, 5668 bool dfs_phyerr_filter_offload) 5669 { 5670 wmi_dfs_phyerr_filter_ena_cmd_fixed_param *enable_phyerr_offload_cmd; 5671 wmi_dfs_phyerr_filter_dis_cmd_fixed_param *disable_phyerr_offload_cmd; 5672 wmi_buf_t buf; 5673 uint16_t len; 5674 QDF_STATUS ret; 5675 5676 5677 if (false == dfs_phyerr_filter_offload) { 5678 WMI_LOGD("%s:Phyerror Filtering offload is Disabled in ini", 5679 __func__); 5680 len = sizeof(*disable_phyerr_offload_cmd); 5681 buf = wmi_buf_alloc(wmi_handle, len); 5682 if (!buf) 5683 return 0; 5684 5685 disable_phyerr_offload_cmd = 5686 (wmi_dfs_phyerr_filter_dis_cmd_fixed_param *) 5687 wmi_buf_data(buf); 5688 5689 WMITLV_SET_HDR(&disable_phyerr_offload_cmd->tlv_header, 5690 WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_dis_cmd_fixed_param, 5691 WMITLV_GET_STRUCT_TLVLEN 5692 (wmi_dfs_phyerr_filter_dis_cmd_fixed_param)); 5693 5694 /* 5695 * Send WMI_DFS_PHYERR_FILTER_DIS_CMDID 5696 * to the firmware to disable the phyerror 5697 * filtering offload. 5698 */ 5699 wmi_mtrace(WMI_DFS_PHYERR_FILTER_DIS_CMDID, NO_SESSION, 0); 5700 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5701 WMI_DFS_PHYERR_FILTER_DIS_CMDID); 5702 if (QDF_IS_STATUS_ERROR(ret)) { 5703 WMI_LOGE("%s: Failed to send WMI_DFS_PHYERR_FILTER_DIS_CMDID ret=%d", 5704 __func__, ret); 5705 wmi_buf_free(buf); 5706 return QDF_STATUS_E_FAILURE; 5707 } 5708 WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success", 5709 __func__); 5710 } else { 5711 WMI_LOGD("%s:Phyerror Filtering offload is Enabled in ini", 5712 __func__); 5713 5714 len = sizeof(*enable_phyerr_offload_cmd); 5715 buf = wmi_buf_alloc(wmi_handle, len); 5716 if (!buf) 5717 return QDF_STATUS_E_FAILURE; 5718 5719 enable_phyerr_offload_cmd = 5720 (wmi_dfs_phyerr_filter_ena_cmd_fixed_param *) 5721 wmi_buf_data(buf); 5722 5723 WMITLV_SET_HDR(&enable_phyerr_offload_cmd->tlv_header, 5724 WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_ena_cmd_fixed_param, 5725 WMITLV_GET_STRUCT_TLVLEN 5726 (wmi_dfs_phyerr_filter_ena_cmd_fixed_param)); 5727 5728 /* 5729 * Send a WMI_DFS_PHYERR_FILTER_ENA_CMDID 5730 * to the firmware to enable the phyerror 5731 * filtering offload. 5732 */ 5733 wmi_mtrace(WMI_DFS_PHYERR_FILTER_ENA_CMDID, NO_SESSION, 0); 5734 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5735 WMI_DFS_PHYERR_FILTER_ENA_CMDID); 5736 5737 if (QDF_IS_STATUS_ERROR(ret)) { 5738 WMI_LOGE("%s: Failed to send DFS PHYERR CMD ret=%d", 5739 __func__, ret); 5740 wmi_buf_free(buf); 5741 return QDF_STATUS_E_FAILURE; 5742 } 5743 WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success", 5744 __func__); 5745 } 5746 5747 return QDF_STATUS_SUCCESS; 5748 } 5749 5750 #if !defined(REMOVE_PKT_LOG) && defined(FEATURE_PKTLOG) 5751 /** 5752 * send_pktlog_wmi_send_cmd_tlv() - send pktlog enable/disable command to target 5753 * @wmi_handle: wmi handle 5754 * @pktlog_event: pktlog event 5755 * @cmd_id: pktlog cmd id 5756 * @user_triggered: user triggered input for PKTLOG enable mode 5757 * 5758 * Return: CDF status 5759 */ 5760 static QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle, 5761 WMI_PKTLOG_EVENT pktlog_event, 5762 WMI_CMD_ID cmd_id, uint8_t user_triggered) 5763 { 5764 WMI_PKTLOG_EVENT PKTLOG_EVENT; 5765 WMI_CMD_ID CMD_ID; 5766 wmi_pdev_pktlog_enable_cmd_fixed_param *cmd; 5767 wmi_pdev_pktlog_disable_cmd_fixed_param *disable_cmd; 5768 int len = 0; 5769 wmi_buf_t buf; 5770 int32_t idx, max_idx; 5771 5772 PKTLOG_EVENT = pktlog_event; 5773 CMD_ID = cmd_id; 5774 5775 max_idx = sizeof(pktlog_event_tlv) / (sizeof(pktlog_event_tlv[0])); 5776 switch (CMD_ID) { 5777 case WMI_PDEV_PKTLOG_ENABLE_CMDID: 5778 len = sizeof(*cmd); 5779 buf = wmi_buf_alloc(wmi_handle, len); 5780 if (!buf) 5781 return QDF_STATUS_E_NOMEM; 5782 5783 cmd = (wmi_pdev_pktlog_enable_cmd_fixed_param *) 5784 wmi_buf_data(buf); 5785 WMITLV_SET_HDR(&cmd->tlv_header, 5786 WMITLV_TAG_STRUC_wmi_pdev_pktlog_enable_cmd_fixed_param, 5787 WMITLV_GET_STRUCT_TLVLEN 5788 (wmi_pdev_pktlog_enable_cmd_fixed_param)); 5789 cmd->evlist = 0; 5790 for (idx = 0; idx < max_idx; idx++) { 5791 if (PKTLOG_EVENT & (1 << idx)) 5792 cmd->evlist |= pktlog_event_tlv[idx]; 5793 } 5794 cmd->enable = user_triggered ? WMI_PKTLOG_ENABLE_FORCE 5795 : WMI_PKTLOG_ENABLE_AUTO; 5796 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 5797 wmi_handle, 5798 WMI_HOST_PDEV_ID_SOC); 5799 wmi_mtrace(WMI_PDEV_PKTLOG_ENABLE_CMDID, NO_SESSION, 0); 5800 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5801 WMI_PDEV_PKTLOG_ENABLE_CMDID)) { 5802 WMI_LOGE("failed to send pktlog enable cmdid"); 5803 goto wmi_send_failed; 5804 } 5805 break; 5806 case WMI_PDEV_PKTLOG_DISABLE_CMDID: 5807 len = sizeof(*disable_cmd); 5808 buf = wmi_buf_alloc(wmi_handle, len); 5809 if (!buf) 5810 return QDF_STATUS_E_NOMEM; 5811 5812 disable_cmd = (wmi_pdev_pktlog_disable_cmd_fixed_param *) 5813 wmi_buf_data(buf); 5814 WMITLV_SET_HDR(&disable_cmd->tlv_header, 5815 WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param, 5816 WMITLV_GET_STRUCT_TLVLEN 5817 (wmi_pdev_pktlog_disable_cmd_fixed_param)); 5818 disable_cmd->pdev_id = 5819 wmi_handle->ops->convert_pdev_id_host_to_target( 5820 wmi_handle, 5821 WMI_HOST_PDEV_ID_SOC); 5822 wmi_mtrace(WMI_PDEV_PKTLOG_DISABLE_CMDID, NO_SESSION, 0); 5823 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5824 WMI_PDEV_PKTLOG_DISABLE_CMDID)) { 5825 WMI_LOGE("failed to send pktlog disable cmdid"); 5826 goto wmi_send_failed; 5827 } 5828 break; 5829 default: 5830 WMI_LOGD("%s: invalid PKTLOG command", __func__); 5831 break; 5832 } 5833 5834 return QDF_STATUS_SUCCESS; 5835 5836 wmi_send_failed: 5837 wmi_buf_free(buf); 5838 return QDF_STATUS_E_FAILURE; 5839 } 5840 #endif /* !REMOVE_PKT_LOG && FEATURE_PKTLOG */ 5841 5842 /** 5843 * send_stats_ext_req_cmd_tlv() - request ext stats from fw 5844 * @wmi_handle: wmi handle 5845 * @preq: stats ext params 5846 * 5847 * Return: CDF status 5848 */ 5849 static QDF_STATUS send_stats_ext_req_cmd_tlv(wmi_unified_t wmi_handle, 5850 struct stats_ext_params *preq) 5851 { 5852 QDF_STATUS ret; 5853 wmi_req_stats_ext_cmd_fixed_param *cmd; 5854 wmi_buf_t buf; 5855 size_t len; 5856 uint8_t *buf_ptr; 5857 5858 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + preq->request_data_len; 5859 5860 buf = wmi_buf_alloc(wmi_handle, len); 5861 if (!buf) 5862 return QDF_STATUS_E_NOMEM; 5863 5864 buf_ptr = (uint8_t *) wmi_buf_data(buf); 5865 cmd = (wmi_req_stats_ext_cmd_fixed_param *) buf_ptr; 5866 5867 WMITLV_SET_HDR(&cmd->tlv_header, 5868 WMITLV_TAG_STRUC_wmi_req_stats_ext_cmd_fixed_param, 5869 WMITLV_GET_STRUCT_TLVLEN 5870 (wmi_req_stats_ext_cmd_fixed_param)); 5871 cmd->vdev_id = preq->vdev_id; 5872 cmd->data_len = preq->request_data_len; 5873 5874 WMI_LOGD("%s: The data len value is %u and vdev id set is %u ", 5875 __func__, preq->request_data_len, preq->vdev_id); 5876 5877 buf_ptr += sizeof(wmi_req_stats_ext_cmd_fixed_param); 5878 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->data_len); 5879 5880 buf_ptr += WMI_TLV_HDR_SIZE; 5881 qdf_mem_copy(buf_ptr, preq->request_data, cmd->data_len); 5882 5883 wmi_mtrace(WMI_REQUEST_STATS_EXT_CMDID, cmd->vdev_id, 0); 5884 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 5885 WMI_REQUEST_STATS_EXT_CMDID); 5886 if (QDF_IS_STATUS_ERROR(ret)) { 5887 WMI_LOGE("%s: Failed to send notify cmd ret = %d", __func__, 5888 ret); 5889 wmi_buf_free(buf); 5890 } 5891 5892 return ret; 5893 } 5894 5895 /** 5896 * send_process_dhcpserver_offload_cmd_tlv() - enable DHCP server offload 5897 * @wmi_handle: wmi handle 5898 * @params: DHCP server offload info 5899 * 5900 * Return: QDF_STATUS_SUCCESS for success or error code 5901 */ 5902 static QDF_STATUS 5903 send_process_dhcpserver_offload_cmd_tlv(wmi_unified_t wmi_handle, 5904 struct dhcp_offload_info_params *params) 5905 { 5906 wmi_set_dhcp_server_offload_cmd_fixed_param *cmd; 5907 wmi_buf_t buf; 5908 QDF_STATUS status; 5909 5910 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 5911 if (!buf) 5912 return QDF_STATUS_E_NOMEM; 5913 5914 cmd = (wmi_set_dhcp_server_offload_cmd_fixed_param *) wmi_buf_data(buf); 5915 5916 WMITLV_SET_HDR(&cmd->tlv_header, 5917 WMITLV_TAG_STRUC_wmi_set_dhcp_server_offload_cmd_fixed_param, 5918 WMITLV_GET_STRUCT_TLVLEN 5919 (wmi_set_dhcp_server_offload_cmd_fixed_param)); 5920 cmd->vdev_id = params->vdev_id; 5921 cmd->enable = params->dhcp_offload_enabled; 5922 cmd->num_client = params->dhcp_client_num; 5923 cmd->srv_ipv4 = params->dhcp_srv_addr; 5924 cmd->start_lsb = 0; 5925 wmi_mtrace(WMI_SET_DHCP_SERVER_OFFLOAD_CMDID, cmd->vdev_id, 0); 5926 status = wmi_unified_cmd_send(wmi_handle, buf, 5927 sizeof(*cmd), 5928 WMI_SET_DHCP_SERVER_OFFLOAD_CMDID); 5929 if (QDF_IS_STATUS_ERROR(status)) { 5930 WMI_LOGE("Failed to send set_dhcp_server_offload cmd"); 5931 wmi_buf_free(buf); 5932 return QDF_STATUS_E_FAILURE; 5933 } 5934 WMI_LOGD("Set dhcp server offload to vdevId %d", 5935 params->vdev_id); 5936 5937 return status; 5938 } 5939 5940 /** 5941 * send_pdev_set_regdomain_cmd_tlv() - send set regdomain command to fw 5942 * @wmi_handle: wmi handle 5943 * @param: pointer to pdev regdomain params 5944 * 5945 * Return: 0 for success or error code 5946 */ 5947 static QDF_STATUS 5948 send_pdev_set_regdomain_cmd_tlv(wmi_unified_t wmi_handle, 5949 struct pdev_set_regdomain_params *param) 5950 { 5951 wmi_buf_t buf; 5952 wmi_pdev_set_regdomain_cmd_fixed_param *cmd; 5953 int32_t len = sizeof(*cmd); 5954 5955 buf = wmi_buf_alloc(wmi_handle, len); 5956 if (!buf) 5957 return QDF_STATUS_E_NOMEM; 5958 5959 cmd = (wmi_pdev_set_regdomain_cmd_fixed_param *) wmi_buf_data(buf); 5960 WMITLV_SET_HDR(&cmd->tlv_header, 5961 WMITLV_TAG_STRUC_wmi_pdev_set_regdomain_cmd_fixed_param, 5962 WMITLV_GET_STRUCT_TLVLEN 5963 (wmi_pdev_set_regdomain_cmd_fixed_param)); 5964 5965 cmd->reg_domain = param->currentRDinuse; 5966 cmd->reg_domain_2G = param->currentRD2G; 5967 cmd->reg_domain_5G = param->currentRD5G; 5968 cmd->conformance_test_limit_2G = param->ctl_2G; 5969 cmd->conformance_test_limit_5G = param->ctl_5G; 5970 cmd->dfs_domain = param->dfsDomain; 5971 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 5972 wmi_handle, 5973 param->pdev_id); 5974 5975 wmi_mtrace(WMI_PDEV_SET_REGDOMAIN_CMDID, NO_SESSION, 0); 5976 if (wmi_unified_cmd_send(wmi_handle, buf, len, 5977 WMI_PDEV_SET_REGDOMAIN_CMDID)) { 5978 WMI_LOGE("%s: Failed to send pdev set regdomain command", 5979 __func__); 5980 wmi_buf_free(buf); 5981 return QDF_STATUS_E_FAILURE; 5982 } 5983 5984 return QDF_STATUS_SUCCESS; 5985 } 5986 5987 /** 5988 * send_regdomain_info_to_fw_cmd_tlv() - send regdomain info to fw 5989 * @wmi_handle: wmi handle 5990 * @reg_dmn: reg domain 5991 * @regdmn2G: 2G reg domain 5992 * @regdmn5G: 5G reg domain 5993 * @ctl2G: 2G test limit 5994 * @ctl5G: 5G test limit 5995 * 5996 * Return: none 5997 */ 5998 static QDF_STATUS send_regdomain_info_to_fw_cmd_tlv(wmi_unified_t wmi_handle, 5999 uint32_t reg_dmn, uint16_t regdmn2G, 6000 uint16_t regdmn5G, uint8_t ctl2G, 6001 uint8_t ctl5G) 6002 { 6003 wmi_buf_t buf; 6004 wmi_pdev_set_regdomain_cmd_fixed_param *cmd; 6005 int32_t len = sizeof(*cmd); 6006 6007 6008 buf = wmi_buf_alloc(wmi_handle, len); 6009 if (!buf) 6010 return QDF_STATUS_E_NOMEM; 6011 6012 cmd = (wmi_pdev_set_regdomain_cmd_fixed_param *) wmi_buf_data(buf); 6013 WMITLV_SET_HDR(&cmd->tlv_header, 6014 WMITLV_TAG_STRUC_wmi_pdev_set_regdomain_cmd_fixed_param, 6015 WMITLV_GET_STRUCT_TLVLEN 6016 (wmi_pdev_set_regdomain_cmd_fixed_param)); 6017 cmd->reg_domain = reg_dmn; 6018 cmd->reg_domain_2G = regdmn2G; 6019 cmd->reg_domain_5G = regdmn5G; 6020 cmd->conformance_test_limit_2G = ctl2G; 6021 cmd->conformance_test_limit_5G = ctl5G; 6022 6023 wmi_debug("regd = %x, regd_2g = %x, regd_5g = %x, ctl_2g = %x, ctl_5g = %x", 6024 cmd->reg_domain, cmd->reg_domain_2G, cmd->reg_domain_5G, 6025 cmd->conformance_test_limit_2G, 6026 cmd->conformance_test_limit_5G); 6027 6028 wmi_mtrace(WMI_PDEV_SET_REGDOMAIN_CMDID, NO_SESSION, 0); 6029 if (wmi_unified_cmd_send(wmi_handle, buf, len, 6030 WMI_PDEV_SET_REGDOMAIN_CMDID)) { 6031 WMI_LOGP("%s: Failed to send pdev set regdomain command", 6032 __func__); 6033 wmi_buf_free(buf); 6034 return QDF_STATUS_E_FAILURE; 6035 } 6036 6037 return QDF_STATUS_SUCCESS; 6038 } 6039 6040 /** 6041 * copy_custom_aggr_bitmap() - copies host side bitmap using FW APIs 6042 * @param: param sent from the host side 6043 * @cmd: param to be sent to the fw side 6044 */ 6045 static inline void copy_custom_aggr_bitmap( 6046 struct set_custom_aggr_size_params *param, 6047 wmi_vdev_set_custom_aggr_size_cmd_fixed_param *cmd) 6048 { 6049 WMI_VDEV_CUSTOM_AGGR_AC_SET(cmd->enable_bitmap, 6050 param->ac); 6051 WMI_VDEV_CUSTOM_AGGR_TYPE_SET(cmd->enable_bitmap, 6052 param->aggr_type); 6053 WMI_VDEV_CUSTOM_TX_AGGR_SZ_DIS_SET(cmd->enable_bitmap, 6054 param->tx_aggr_size_disable); 6055 WMI_VDEV_CUSTOM_RX_AGGR_SZ_DIS_SET(cmd->enable_bitmap, 6056 param->rx_aggr_size_disable); 6057 WMI_VDEV_CUSTOM_TX_AC_EN_SET(cmd->enable_bitmap, 6058 param->tx_ac_enable); 6059 } 6060 6061 /** 6062 * send_vdev_set_custom_aggr_size_cmd_tlv() - custom aggr size param in fw 6063 * @wmi_handle: wmi handle 6064 * @param: pointer to hold custom aggr size params 6065 * 6066 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6067 */ 6068 static QDF_STATUS send_vdev_set_custom_aggr_size_cmd_tlv( 6069 wmi_unified_t wmi_handle, 6070 struct set_custom_aggr_size_params *param) 6071 { 6072 wmi_vdev_set_custom_aggr_size_cmd_fixed_param *cmd; 6073 wmi_buf_t buf; 6074 int32_t len = sizeof(*cmd); 6075 6076 buf = wmi_buf_alloc(wmi_handle, len); 6077 if (!buf) 6078 return QDF_STATUS_E_FAILURE; 6079 6080 cmd = (wmi_vdev_set_custom_aggr_size_cmd_fixed_param *) 6081 wmi_buf_data(buf); 6082 WMITLV_SET_HDR(&cmd->tlv_header, 6083 WMITLV_TAG_STRUC_wmi_vdev_set_custom_aggr_size_cmd_fixed_param, 6084 WMITLV_GET_STRUCT_TLVLEN( 6085 wmi_vdev_set_custom_aggr_size_cmd_fixed_param)); 6086 cmd->vdev_id = param->vdev_id; 6087 cmd->tx_aggr_size = param->tx_aggr_size; 6088 cmd->rx_aggr_size = param->rx_aggr_size; 6089 copy_custom_aggr_bitmap(param, cmd); 6090 6091 WMI_LOGD("Set custom aggr: vdev id=0x%X, tx aggr size=0x%X " 6092 "rx_aggr_size=0x%X access category=0x%X, agg_type=0x%X " 6093 "tx_aggr_size_disable=0x%X, rx_aggr_size_disable=0x%X " 6094 "tx_ac_enable=0x%X", 6095 param->vdev_id, param->tx_aggr_size, param->rx_aggr_size, 6096 param->ac, param->aggr_type, param->tx_aggr_size_disable, 6097 param->rx_aggr_size_disable, param->tx_ac_enable); 6098 6099 wmi_mtrace(WMI_VDEV_SET_CUSTOM_AGGR_SIZE_CMDID, cmd->vdev_id, 0); 6100 if (wmi_unified_cmd_send(wmi_handle, buf, len, 6101 WMI_VDEV_SET_CUSTOM_AGGR_SIZE_CMDID)) { 6102 WMI_LOGE("Seting custom aggregation size failed"); 6103 wmi_buf_free(buf); 6104 return QDF_STATUS_E_FAILURE; 6105 } 6106 6107 return QDF_STATUS_SUCCESS; 6108 } 6109 6110 /** 6111 * send_vdev_set_qdepth_thresh_cmd_tlv() - WMI set qdepth threshold 6112 * @param wmi_handle : handle to WMI. 6113 * @param param : pointer to tx antenna param 6114 * 6115 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6116 */ 6117 6118 static QDF_STATUS send_vdev_set_qdepth_thresh_cmd_tlv(wmi_unified_t wmi_handle, 6119 struct set_qdepth_thresh_params *param) 6120 { 6121 wmi_peer_tid_msduq_qdepth_thresh_update_cmd_fixed_param *cmd; 6122 wmi_msduq_qdepth_thresh_update *cmd_update; 6123 wmi_buf_t buf; 6124 int32_t len = 0; 6125 int i; 6126 uint8_t *buf_ptr; 6127 QDF_STATUS ret; 6128 6129 if (param->num_of_msduq_updates > QDEPTH_THRESH_MAX_UPDATES) { 6130 WMI_LOGE("%s: Invalid Update Count!", __func__); 6131 return QDF_STATUS_E_INVAL; 6132 } 6133 6134 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE; 6135 len += (sizeof(wmi_msduq_qdepth_thresh_update) * 6136 param->num_of_msduq_updates); 6137 buf = wmi_buf_alloc(wmi_handle, len); 6138 6139 if (!buf) 6140 return QDF_STATUS_E_NOMEM; 6141 6142 buf_ptr = (uint8_t *)wmi_buf_data(buf); 6143 cmd = (wmi_peer_tid_msduq_qdepth_thresh_update_cmd_fixed_param *) 6144 buf_ptr; 6145 6146 WMITLV_SET_HDR(&cmd->tlv_header, 6147 WMITLV_TAG_STRUC_wmi_peer_tid_msduq_qdepth_thresh_update_cmd_fixed_param 6148 , WMITLV_GET_STRUCT_TLVLEN( 6149 wmi_peer_tid_msduq_qdepth_thresh_update_cmd_fixed_param)); 6150 6151 cmd->pdev_id = 6152 wmi_handle->ops->convert_pdev_id_host_to_target( 6153 wmi_handle, 6154 param->pdev_id); 6155 cmd->vdev_id = param->vdev_id; 6156 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->mac_addr, &cmd->peer_mac_address); 6157 cmd->num_of_msduq_updates = param->num_of_msduq_updates; 6158 6159 buf_ptr += sizeof( 6160 wmi_peer_tid_msduq_qdepth_thresh_update_cmd_fixed_param); 6161 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 6162 param->num_of_msduq_updates * 6163 sizeof(wmi_msduq_qdepth_thresh_update)); 6164 buf_ptr += WMI_TLV_HDR_SIZE; 6165 cmd_update = (wmi_msduq_qdepth_thresh_update *)buf_ptr; 6166 6167 for (i = 0; i < cmd->num_of_msduq_updates; i++) { 6168 WMITLV_SET_HDR(&cmd_update->tlv_header, 6169 WMITLV_TAG_STRUC_wmi_msduq_qdepth_thresh_update, 6170 WMITLV_GET_STRUCT_TLVLEN( 6171 wmi_msduq_qdepth_thresh_update)); 6172 cmd_update->tid_num = param->update_params[i].tid_num; 6173 cmd_update->msduq_update_mask = 6174 param->update_params[i].msduq_update_mask; 6175 cmd_update->qdepth_thresh_value = 6176 param->update_params[i].qdepth_thresh_value; 6177 WMI_LOGD("Set QDepth Threshold: vdev=0x%X pdev=0x%X, tid=0x%X " 6178 "mac_addr_upper4=%X, mac_addr_lower2:%X," 6179 " update mask=0x%X thresh val=0x%X", 6180 cmd->vdev_id, cmd->pdev_id, cmd_update->tid_num, 6181 cmd->peer_mac_address.mac_addr31to0, 6182 cmd->peer_mac_address.mac_addr47to32, 6183 cmd_update->msduq_update_mask, 6184 cmd_update->qdepth_thresh_value); 6185 cmd_update++; 6186 } 6187 6188 wmi_mtrace(WMI_PEER_TID_MSDUQ_QDEPTH_THRESH_UPDATE_CMDID, 6189 cmd->vdev_id, 0); 6190 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 6191 WMI_PEER_TID_MSDUQ_QDEPTH_THRESH_UPDATE_CMDID); 6192 6193 if (ret != 0) { 6194 WMI_LOGE(" %s :WMI Failed", __func__); 6195 wmi_buf_free(buf); 6196 } 6197 6198 return ret; 6199 } 6200 6201 /** 6202 * send_set_vap_dscp_tid_map_cmd_tlv() - send vap dscp tid map cmd to fw 6203 * @wmi_handle: wmi handle 6204 * @param: pointer to hold vap dscp tid map param 6205 * 6206 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6207 */ 6208 static QDF_STATUS 6209 send_set_vap_dscp_tid_map_cmd_tlv(wmi_unified_t wmi_handle, 6210 struct vap_dscp_tid_map_params *param) 6211 { 6212 wmi_buf_t buf; 6213 wmi_vdev_set_dscp_tid_map_cmd_fixed_param *cmd; 6214 int32_t len = sizeof(*cmd); 6215 6216 buf = wmi_buf_alloc(wmi_handle, len); 6217 if (!buf) 6218 return QDF_STATUS_E_FAILURE; 6219 6220 cmd = (wmi_vdev_set_dscp_tid_map_cmd_fixed_param *)wmi_buf_data(buf); 6221 qdf_mem_copy(cmd->dscp_to_tid_map, param->dscp_to_tid_map, 6222 sizeof(uint32_t) * WMI_DSCP_MAP_MAX); 6223 6224 cmd->vdev_id = param->vdev_id; 6225 cmd->enable_override = 0; 6226 6227 WMI_LOGI("Setting dscp for vap id: %d", cmd->vdev_id); 6228 wmi_mtrace(WMI_VDEV_SET_DSCP_TID_MAP_CMDID, cmd->vdev_id, 0); 6229 if (wmi_unified_cmd_send(wmi_handle, buf, len, 6230 WMI_VDEV_SET_DSCP_TID_MAP_CMDID)) { 6231 WMI_LOGE("Failed to set dscp cmd"); 6232 wmi_buf_free(buf); 6233 return QDF_STATUS_E_FAILURE; 6234 } 6235 6236 return QDF_STATUS_SUCCESS; 6237 } 6238 6239 /** 6240 * send_vdev_set_fwtest_param_cmd_tlv() - send fwtest param in fw 6241 * @wmi_handle: wmi handle 6242 * @param: pointer to hold fwtest param 6243 * 6244 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6245 */ 6246 static QDF_STATUS send_vdev_set_fwtest_param_cmd_tlv(wmi_unified_t wmi_handle, 6247 struct set_fwtest_params *param) 6248 { 6249 wmi_fwtest_set_param_cmd_fixed_param *cmd; 6250 wmi_buf_t buf; 6251 int32_t len = sizeof(*cmd); 6252 6253 buf = wmi_buf_alloc(wmi_handle, len); 6254 6255 if (!buf) 6256 return QDF_STATUS_E_FAILURE; 6257 6258 cmd = (wmi_fwtest_set_param_cmd_fixed_param *)wmi_buf_data(buf); 6259 WMITLV_SET_HDR(&cmd->tlv_header, 6260 WMITLV_TAG_STRUC_wmi_fwtest_set_param_cmd_fixed_param, 6261 WMITLV_GET_STRUCT_TLVLEN( 6262 wmi_fwtest_set_param_cmd_fixed_param)); 6263 cmd->param_id = param->arg; 6264 cmd->param_value = param->value; 6265 6266 wmi_mtrace(WMI_FWTEST_CMDID, NO_SESSION, 0); 6267 if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_FWTEST_CMDID)) { 6268 WMI_LOGE("Setting FW test param failed"); 6269 wmi_buf_free(buf); 6270 return QDF_STATUS_E_FAILURE; 6271 } 6272 6273 return QDF_STATUS_SUCCESS; 6274 } 6275 6276 /** 6277 * send_phyerr_disable_cmd_tlv() - WMI phyerr disable function 6278 * 6279 * @param wmi_handle : handle to WMI. 6280 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6281 */ 6282 static QDF_STATUS send_phyerr_disable_cmd_tlv(wmi_unified_t wmi_handle) 6283 { 6284 wmi_pdev_dfs_disable_cmd_fixed_param *cmd; 6285 wmi_buf_t buf; 6286 QDF_STATUS ret; 6287 int32_t len; 6288 6289 len = sizeof(*cmd); 6290 6291 buf = wmi_buf_alloc(wmi_handle, len); 6292 if (!buf) 6293 return QDF_STATUS_E_FAILURE; 6294 6295 cmd = (wmi_pdev_dfs_disable_cmd_fixed_param *)wmi_buf_data(buf); 6296 WMITLV_SET_HDR(&cmd->tlv_header, 6297 WMITLV_TAG_STRUC_wmi_pdev_dfs_disable_cmd_fixed_param, 6298 WMITLV_GET_STRUCT_TLVLEN( 6299 wmi_pdev_dfs_disable_cmd_fixed_param)); 6300 /* Filling it with WMI_PDEV_ID_SOC for now */ 6301 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 6302 wmi_handle, 6303 WMI_HOST_PDEV_ID_SOC); 6304 6305 wmi_mtrace(WMI_PDEV_DFS_DISABLE_CMDID, NO_SESSION, 0); 6306 ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 6307 WMI_PDEV_DFS_DISABLE_CMDID); 6308 6309 if (ret != 0) { 6310 WMI_LOGE("Sending PDEV DFS disable cmd failed"); 6311 wmi_buf_free(buf); 6312 } 6313 6314 return ret; 6315 } 6316 6317 /** 6318 * send_phyerr_enable_cmd_tlv() - WMI phyerr disable function 6319 * 6320 * @param wmi_handle : handle to WMI. 6321 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6322 */ 6323 static QDF_STATUS send_phyerr_enable_cmd_tlv(wmi_unified_t wmi_handle) 6324 { 6325 wmi_pdev_dfs_enable_cmd_fixed_param *cmd; 6326 wmi_buf_t buf; 6327 QDF_STATUS ret; 6328 int32_t len; 6329 6330 len = sizeof(*cmd); 6331 6332 buf = wmi_buf_alloc(wmi_handle, len); 6333 if (!buf) 6334 return QDF_STATUS_E_FAILURE; 6335 6336 cmd = (wmi_pdev_dfs_enable_cmd_fixed_param *)wmi_buf_data(buf); 6337 WMITLV_SET_HDR(&cmd->tlv_header, 6338 WMITLV_TAG_STRUC_wmi_pdev_dfs_enable_cmd_fixed_param, 6339 WMITLV_GET_STRUCT_TLVLEN( 6340 wmi_pdev_dfs_enable_cmd_fixed_param)); 6341 /* Reserved for future use */ 6342 cmd->reserved0 = 0; 6343 6344 wmi_mtrace(WMI_PDEV_DFS_ENABLE_CMDID, NO_SESSION, 0); 6345 ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 6346 WMI_PDEV_DFS_ENABLE_CMDID); 6347 6348 if (ret != 0) { 6349 WMI_LOGE("Sending PDEV DFS enable cmd failed"); 6350 wmi_buf_free(buf); 6351 } 6352 6353 return ret; 6354 } 6355 6356 /** 6357 * send_periodic_chan_stats_config_cmd_tlv() - send periodic chan stats cmd 6358 * to fw 6359 * @wmi_handle: wmi handle 6360 * @param: pointer to hold periodic chan stats param 6361 * 6362 * Return: 0 for success or error code 6363 */ 6364 static QDF_STATUS 6365 send_periodic_chan_stats_config_cmd_tlv(wmi_unified_t wmi_handle, 6366 struct periodic_chan_stats_params *param) 6367 { 6368 wmi_set_periodic_channel_stats_config_fixed_param *cmd; 6369 wmi_buf_t buf; 6370 QDF_STATUS ret; 6371 int32_t len; 6372 6373 len = sizeof(*cmd); 6374 6375 buf = wmi_buf_alloc(wmi_handle, len); 6376 if (!buf) 6377 return QDF_STATUS_E_FAILURE; 6378 6379 cmd = (wmi_set_periodic_channel_stats_config_fixed_param *) 6380 wmi_buf_data(buf); 6381 WMITLV_SET_HDR(&cmd->tlv_header, 6382 WMITLV_TAG_STRUC_wmi_set_periodic_channel_stats_config_fixed_param, 6383 WMITLV_GET_STRUCT_TLVLEN( 6384 wmi_set_periodic_channel_stats_config_fixed_param)); 6385 cmd->enable = param->enable; 6386 cmd->stats_period = param->stats_period; 6387 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 6388 wmi_handle, 6389 param->pdev_id); 6390 6391 wmi_mtrace(WMI_SET_PERIODIC_CHANNEL_STATS_CONFIG_CMDID, NO_SESSION, 0); 6392 ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 6393 WMI_SET_PERIODIC_CHANNEL_STATS_CONFIG_CMDID); 6394 6395 if (ret != 0) { 6396 WMI_LOGE("Sending periodic chan stats config failed"); 6397 wmi_buf_free(buf); 6398 } 6399 6400 return ret; 6401 } 6402 6403 /** 6404 * send_simulation_test_cmd_tlv() - send simulation test command to fw 6405 * 6406 * @wmi_handle: wmi handle 6407 * @param: pointer to hold simulation test parameter 6408 * 6409 * Return: 0 for success or error code 6410 */ 6411 static QDF_STATUS send_simulation_test_cmd_tlv(wmi_unified_t wmi_handle, 6412 struct simulation_test_params 6413 *param) 6414 { 6415 wmi_simulation_test_cmd_fixed_param *cmd; 6416 u32 wmi_buf_len; 6417 wmi_buf_t buf; 6418 u8 *buf_ptr; 6419 u32 aligned_len = 0; 6420 6421 wmi_buf_len = sizeof(*cmd); 6422 if (param->buf_len) { 6423 aligned_len = roundup(param->buf_len, sizeof(A_UINT32)); 6424 wmi_buf_len += WMI_TLV_HDR_SIZE + aligned_len; 6425 } 6426 6427 buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); 6428 if (!buf) { 6429 WMI_LOGP("%s: wmi_buf_alloc failed", __func__); 6430 return QDF_STATUS_E_NOMEM; 6431 } 6432 6433 buf_ptr = wmi_buf_data(buf); 6434 cmd = (wmi_simulation_test_cmd_fixed_param *)buf_ptr; 6435 WMITLV_SET_HDR(&cmd->tlv_header, 6436 WMITLV_TAG_STRUC_wmi_simulation_test_cmd_fixed_param, 6437 WMITLV_GET_STRUCT_TLVLEN( 6438 wmi_simulation_test_cmd_fixed_param)); 6439 cmd->pdev_id = param->pdev_id; 6440 cmd->vdev_id = param->vdev_id; 6441 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_mac, &cmd->peer_macaddr); 6442 cmd->test_cmd_type = param->test_cmd_type; 6443 cmd->test_subcmd_type = param->test_subcmd_type; 6444 WMI_SIM_FRAME_TYPE_SET(cmd->frame_type_subtype_seq, param->frame_type); 6445 WMI_SIM_FRAME_SUBTYPE_SET(cmd->frame_type_subtype_seq, 6446 param->frame_subtype); 6447 WMI_SIM_FRAME_SEQ_SET(cmd->frame_type_subtype_seq, param->seq); 6448 WMI_SIM_FRAME_OFFSET_SET(cmd->frame_offset_length, param->offset); 6449 WMI_SIM_FRAME_LENGTH_SET(cmd->frame_offset_length, param->frame_length); 6450 cmd->buf_len = param->buf_len; 6451 6452 if (param->buf_len) { 6453 buf_ptr += sizeof(*cmd); 6454 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, aligned_len); 6455 buf_ptr += WMI_TLV_HDR_SIZE; 6456 qdf_mem_copy(buf_ptr, param->bufp, param->buf_len); 6457 } 6458 6459 if (wmi_unified_cmd_send(wmi_handle, buf, wmi_buf_len, 6460 WMI_SIMULATION_TEST_CMDID)) { 6461 WMI_LOGE("%s: Failed to send test simulation cmd", __func__); 6462 wmi_buf_free(buf); 6463 return QDF_STATUS_E_FAILURE; 6464 } 6465 6466 return QDF_STATUS_SUCCESS; 6467 } 6468 6469 /** 6470 * send_vdev_spectral_configure_cmd_tlv() - send VDEV spectral configure 6471 * command to fw 6472 * @wmi_handle: wmi handle 6473 * @param: pointer to hold spectral config parameter 6474 * 6475 * Return: 0 for success or error code 6476 */ 6477 static QDF_STATUS send_vdev_spectral_configure_cmd_tlv(wmi_unified_t wmi_handle, 6478 struct vdev_spectral_configure_params *param) 6479 { 6480 wmi_vdev_spectral_configure_cmd_fixed_param *cmd; 6481 wmi_buf_t buf; 6482 QDF_STATUS ret; 6483 int32_t len; 6484 6485 len = sizeof(*cmd); 6486 buf = wmi_buf_alloc(wmi_handle, len); 6487 if (!buf) 6488 return QDF_STATUS_E_FAILURE; 6489 6490 cmd = (wmi_vdev_spectral_configure_cmd_fixed_param *)wmi_buf_data(buf); 6491 WMITLV_SET_HDR(&cmd->tlv_header, 6492 WMITLV_TAG_STRUC_wmi_vdev_spectral_configure_cmd_fixed_param, 6493 WMITLV_GET_STRUCT_TLVLEN( 6494 wmi_vdev_spectral_configure_cmd_fixed_param)); 6495 6496 cmd->vdev_id = param->vdev_id; 6497 cmd->spectral_scan_count = param->count; 6498 cmd->spectral_scan_period = param->period; 6499 cmd->spectral_scan_priority = param->spectral_pri; 6500 cmd->spectral_scan_fft_size = param->fft_size; 6501 cmd->spectral_scan_gc_ena = param->gc_enable; 6502 cmd->spectral_scan_restart_ena = param->restart_enable; 6503 cmd->spectral_scan_noise_floor_ref = param->noise_floor_ref; 6504 cmd->spectral_scan_init_delay = param->init_delay; 6505 cmd->spectral_scan_nb_tone_thr = param->nb_tone_thr; 6506 cmd->spectral_scan_str_bin_thr = param->str_bin_thr; 6507 cmd->spectral_scan_wb_rpt_mode = param->wb_rpt_mode; 6508 cmd->spectral_scan_rssi_rpt_mode = param->rssi_rpt_mode; 6509 cmd->spectral_scan_rssi_thr = param->rssi_thr; 6510 cmd->spectral_scan_pwr_format = param->pwr_format; 6511 cmd->spectral_scan_rpt_mode = param->rpt_mode; 6512 cmd->spectral_scan_bin_scale = param->bin_scale; 6513 cmd->spectral_scan_dBm_adj = param->dbm_adj; 6514 cmd->spectral_scan_chn_mask = param->chn_mask; 6515 cmd->spectral_scan_mode = param->mode; 6516 cmd->spectral_scan_center_freq1 = param->center_freq1; 6517 cmd->spectral_scan_center_freq2 = param->center_freq2; 6518 cmd->spectral_scan_chan_width = param->chan_width; 6519 /* Not used, fill with zeros */ 6520 cmd->spectral_scan_chan_freq = 0; 6521 6522 wmi_mtrace(WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID, cmd->vdev_id, 0); 6523 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 6524 WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID); 6525 6526 if (ret != 0) { 6527 WMI_LOGE("Sending set quiet cmd failed"); 6528 wmi_buf_free(buf); 6529 } 6530 6531 WMI_LOGI("%s: Sent WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID", 6532 __func__); 6533 6534 WMI_LOGI("vdev_id = %u", param->vdev_id); 6535 WMI_LOGI("spectral_scan_count = %u", param->count); 6536 WMI_LOGI("spectral_scan_period = %u", param->period); 6537 WMI_LOGI("spectral_scan_priority = %u", param->spectral_pri); 6538 WMI_LOGI("spectral_scan_fft_size = %u", param->fft_size); 6539 WMI_LOGI("spectral_scan_gc_ena = %u", param->gc_enable); 6540 WMI_LOGI("spectral_scan_restart_ena = %u", param->restart_enable); 6541 WMI_LOGI("spectral_scan_noise_floor_ref = %u", param->noise_floor_ref); 6542 WMI_LOGI("spectral_scan_init_delay = %u", param->init_delay); 6543 WMI_LOGI("spectral_scan_nb_tone_thr = %u", param->nb_tone_thr); 6544 WMI_LOGI("spectral_scan_str_bin_thr = %u", param->str_bin_thr); 6545 WMI_LOGI("spectral_scan_wb_rpt_mode = %u", param->wb_rpt_mode); 6546 WMI_LOGI("spectral_scan_rssi_rpt_mode = %u", param->rssi_rpt_mode); 6547 WMI_LOGI("spectral_scan_rssi_thr = %u", param->rssi_thr); 6548 WMI_LOGI("spectral_scan_pwr_format = %u", param->pwr_format); 6549 WMI_LOGI("spectral_scan_rpt_mode = %u", param->rpt_mode); 6550 WMI_LOGI("spectral_scan_bin_scale = %u", param->bin_scale); 6551 WMI_LOGI("spectral_scan_dBm_adj = %u", param->dbm_adj); 6552 WMI_LOGI("spectral_scan_chn_mask = %u", param->chn_mask); 6553 WMI_LOGI("spectral_scan_mode = %u", param->mode); 6554 WMI_LOGI("spectral_scan_center_freq1 = %u", param->center_freq1); 6555 WMI_LOGI("spectral_scan_center_freq2 = %u", param->center_freq2); 6556 WMI_LOGI("spectral_scan_chan_freq = %u", param->chan_freq); 6557 WMI_LOGI("spectral_scan_chan_width = %u", param->chan_width); 6558 WMI_LOGI("%s: Status: %d", __func__, ret); 6559 6560 return ret; 6561 } 6562 6563 /** 6564 * send_vdev_spectral_enable_cmd_tlv() - send VDEV spectral configure 6565 * command to fw 6566 * @wmi_handle: wmi handle 6567 * @param: pointer to hold spectral enable parameter 6568 * 6569 * Return: 0 for success or error code 6570 */ 6571 static QDF_STATUS send_vdev_spectral_enable_cmd_tlv(wmi_unified_t wmi_handle, 6572 struct vdev_spectral_enable_params *param) 6573 { 6574 wmi_vdev_spectral_enable_cmd_fixed_param *cmd; 6575 wmi_buf_t buf; 6576 QDF_STATUS ret; 6577 int32_t len; 6578 6579 len = sizeof(*cmd); 6580 buf = wmi_buf_alloc(wmi_handle, len); 6581 if (!buf) 6582 return QDF_STATUS_E_FAILURE; 6583 6584 cmd = (wmi_vdev_spectral_enable_cmd_fixed_param *)wmi_buf_data(buf); 6585 WMITLV_SET_HDR(&cmd->tlv_header, 6586 WMITLV_TAG_STRUC_wmi_vdev_spectral_enable_cmd_fixed_param, 6587 WMITLV_GET_STRUCT_TLVLEN( 6588 wmi_vdev_spectral_enable_cmd_fixed_param)); 6589 6590 cmd->vdev_id = param->vdev_id; 6591 6592 if (param->active_valid) { 6593 cmd->trigger_cmd = param->active ? 1 : 2; 6594 /* 1: Trigger, 2: Clear Trigger */ 6595 } else { 6596 cmd->trigger_cmd = 0; /* 0: Ignore */ 6597 } 6598 6599 if (param->enabled_valid) { 6600 cmd->enable_cmd = param->enabled ? 1 : 2; 6601 /* 1: Enable 2: Disable */ 6602 } else { 6603 cmd->enable_cmd = 0; /* 0: Ignore */ 6604 } 6605 cmd->spectral_scan_mode = param->mode; 6606 6607 WMI_LOGI("vdev_id = %u", cmd->vdev_id); 6608 WMI_LOGI("trigger_cmd = %u", cmd->trigger_cmd); 6609 WMI_LOGI("enable_cmd = %u", cmd->enable_cmd); 6610 WMI_LOGI("spectral_scan_mode = %u", cmd->spectral_scan_mode); 6611 6612 wmi_mtrace(WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID, cmd->vdev_id, 0); 6613 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 6614 WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID); 6615 6616 if (ret != 0) { 6617 WMI_LOGE("Sending scan enable CMD failed"); 6618 wmi_buf_free(buf); 6619 } 6620 6621 WMI_LOGI("%s: Sent WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID", __func__); 6622 6623 WMI_LOGI("%s: Status: %d", __func__, ret); 6624 6625 return ret; 6626 } 6627 6628 #ifdef WLAN_CONV_SPECTRAL_ENABLE 6629 static QDF_STATUS 6630 extract_pdev_sscan_fw_cmd_fixed_param_tlv( 6631 wmi_unified_t wmi_handle, 6632 uint8_t *event, struct spectral_startscan_resp_params *param) 6633 { 6634 WMI_PDEV_SSCAN_FW_PARAM_EVENTID_param_tlvs *param_buf; 6635 wmi_pdev_sscan_fw_cmd_fixed_param *ev; 6636 6637 if (!wmi_handle) { 6638 WMI_LOGE("WMI handle is null"); 6639 return QDF_STATUS_E_INVAL; 6640 } 6641 6642 if (!event) { 6643 WMI_LOGE("WMI event is null"); 6644 return QDF_STATUS_E_INVAL; 6645 } 6646 6647 if (!param) { 6648 WMI_LOGE("Spectral startscan response params is null"); 6649 return QDF_STATUS_E_INVAL; 6650 } 6651 6652 param_buf = (WMI_PDEV_SSCAN_FW_PARAM_EVENTID_param_tlvs *)event; 6653 if (!param_buf) 6654 return QDF_STATUS_E_INVAL; 6655 6656 ev = param_buf->fixed_param; 6657 if (!ev) 6658 return QDF_STATUS_E_INVAL; 6659 6660 param->pdev_id = wmi_handle->ops->convert_target_pdev_id_to_host( 6661 wmi_handle, 6662 ev->pdev_id); 6663 param->smode = ev->spectral_scan_mode; 6664 param->num_fft_bin_index = param_buf->num_fft_bin_index; 6665 WMI_LOGD("%s:pdev id %u scan mode %u num_fft_bin_index %u", __func__, 6666 param->pdev_id, param->smode, param->num_fft_bin_index); 6667 6668 return QDF_STATUS_SUCCESS; 6669 } 6670 6671 static QDF_STATUS 6672 extract_pdev_sscan_fft_bin_index_tlv( 6673 wmi_unified_t wmi_handle, uint8_t *event, 6674 struct spectral_fft_bin_markers_160_165mhz *param) 6675 { 6676 WMI_PDEV_SSCAN_FW_PARAM_EVENTID_param_tlvs *param_buf; 6677 wmi_pdev_sscan_fft_bin_index *ev; 6678 6679 param_buf = (WMI_PDEV_SSCAN_FW_PARAM_EVENTID_param_tlvs *)event; 6680 if (!param_buf) 6681 return QDF_STATUS_E_INVAL; 6682 6683 ev = param_buf->fft_bin_index; 6684 if (!ev) 6685 return QDF_STATUS_E_INVAL; 6686 6687 param->start_pri80 = WMI_SSCAN_PRI80_START_BIN_GET(ev->pri80_bins); 6688 param->num_pri80 = WMI_SSCAN_PRI80_END_BIN_GET(ev->pri80_bins) - 6689 param->start_pri80 + 1; 6690 param->start_sec80 = WMI_SSCAN_SEC80_START_BIN_GET(ev->sec80_bins); 6691 param->num_sec80 = WMI_SSCAN_SEC80_END_BIN_GET(ev->sec80_bins) - 6692 param->start_sec80 + 1; 6693 param->start_5mhz = WMI_SSCAN_MID_5MHZ_START_BIN_GET(ev->mid_5mhz_bins); 6694 param->num_5mhz = WMI_SSCAN_MID_5MHZ_END_BIN_GET(ev->mid_5mhz_bins) - 6695 param->start_5mhz + 1; 6696 param->is_valid = true; 6697 6698 WMI_LOGD("%s:start_pri80 %u, num_pri80 %u", __func__, 6699 param->start_pri80, param->num_pri80); 6700 WMI_LOGD("%s:start_sec80 %u, num_sec80 %u", __func__, 6701 param->start_sec80, param->num_sec80); 6702 WMI_LOGD("%s:start_5mhz %u, num_5mhz %u", __func__, 6703 param->start_5mhz, param->num_5mhz); 6704 6705 return QDF_STATUS_SUCCESS; 6706 } 6707 #endif /* WLAN_CONV_SPECTRAL_ENABLE */ 6708 6709 /** 6710 * send_thermal_mitigation_param_cmd_tlv() - configure thermal mitigation params 6711 * @param wmi_handle : handle to WMI. 6712 * @param param : pointer to hold thermal mitigation param 6713 * 6714 * @return QDF_STATUS_SUCCESS on success and -ve on failure. 6715 */ 6716 static QDF_STATUS send_thermal_mitigation_param_cmd_tlv( 6717 wmi_unified_t wmi_handle, 6718 struct thermal_mitigation_params *param) 6719 { 6720 wmi_therm_throt_config_request_fixed_param *tt_conf = NULL; 6721 wmi_therm_throt_level_config_info *lvl_conf = NULL; 6722 wmi_buf_t buf = NULL; 6723 uint8_t *buf_ptr = NULL; 6724 int error; 6725 int32_t len; 6726 int i; 6727 6728 len = sizeof(*tt_conf) + WMI_TLV_HDR_SIZE + 6729 param->num_thermal_conf * 6730 sizeof(wmi_therm_throt_level_config_info); 6731 6732 buf = wmi_buf_alloc(wmi_handle, len); 6733 if (!buf) 6734 return QDF_STATUS_E_NOMEM; 6735 6736 tt_conf = (wmi_therm_throt_config_request_fixed_param *) wmi_buf_data(buf); 6737 6738 /* init fixed params */ 6739 WMITLV_SET_HDR(tt_conf, 6740 WMITLV_TAG_STRUC_wmi_therm_throt_config_request_fixed_param, 6741 (WMITLV_GET_STRUCT_TLVLEN(wmi_therm_throt_config_request_fixed_param))); 6742 6743 tt_conf->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 6744 wmi_handle, 6745 param->pdev_id); 6746 tt_conf->enable = param->enable; 6747 tt_conf->dc = param->dc; 6748 tt_conf->dc_per_event = param->dc_per_event; 6749 tt_conf->therm_throt_levels = param->num_thermal_conf; 6750 6751 buf_ptr = (uint8_t *) ++tt_conf; 6752 /* init TLV params */ 6753 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 6754 (param->num_thermal_conf * 6755 sizeof(wmi_therm_throt_level_config_info))); 6756 6757 lvl_conf = (wmi_therm_throt_level_config_info *) (buf_ptr + WMI_TLV_HDR_SIZE); 6758 for (i = 0; i < param->num_thermal_conf; i++) { 6759 WMITLV_SET_HDR(&lvl_conf->tlv_header, 6760 WMITLV_TAG_STRUC_wmi_therm_throt_level_config_info, 6761 WMITLV_GET_STRUCT_TLVLEN(wmi_therm_throt_level_config_info)); 6762 lvl_conf->temp_lwm = param->levelconf[i].tmplwm; 6763 lvl_conf->temp_hwm = param->levelconf[i].tmphwm; 6764 lvl_conf->dc_off_percent = param->levelconf[i].dcoffpercent; 6765 lvl_conf->prio = param->levelconf[i].priority; 6766 lvl_conf++; 6767 } 6768 6769 wmi_mtrace(WMI_THERM_THROT_SET_CONF_CMDID, NO_SESSION, 0); 6770 error = wmi_unified_cmd_send(wmi_handle, buf, len, 6771 WMI_THERM_THROT_SET_CONF_CMDID); 6772 if (QDF_IS_STATUS_ERROR(error)) { 6773 wmi_buf_free(buf); 6774 WMI_LOGE("Failed to send WMI_THERM_THROT_SET_CONF_CMDID command"); 6775 } 6776 6777 return error; 6778 } 6779 6780 /** 6781 * send_coex_config_cmd_tlv() - send coex config command to fw 6782 * @wmi_handle: wmi handle 6783 * @param: pointer to coex config param 6784 * 6785 * Return: 0 for success or error code 6786 */ 6787 static QDF_STATUS 6788 send_coex_config_cmd_tlv(wmi_unified_t wmi_handle, 6789 struct coex_config_params *param) 6790 { 6791 WMI_COEX_CONFIG_CMD_fixed_param *cmd; 6792 wmi_buf_t buf; 6793 QDF_STATUS ret; 6794 int32_t len; 6795 6796 len = sizeof(*cmd); 6797 buf = wmi_buf_alloc(wmi_handle, len); 6798 if (!buf) 6799 return QDF_STATUS_E_FAILURE; 6800 6801 cmd = (WMI_COEX_CONFIG_CMD_fixed_param *)wmi_buf_data(buf); 6802 WMITLV_SET_HDR(&cmd->tlv_header, 6803 WMITLV_TAG_STRUC_WMI_COEX_CONFIG_CMD_fixed_param, 6804 WMITLV_GET_STRUCT_TLVLEN( 6805 WMI_COEX_CONFIG_CMD_fixed_param)); 6806 6807 cmd->vdev_id = param->vdev_id; 6808 cmd->config_type = param->config_type; 6809 cmd->config_arg1 = param->config_arg1; 6810 cmd->config_arg2 = param->config_arg2; 6811 cmd->config_arg3 = param->config_arg3; 6812 cmd->config_arg4 = param->config_arg4; 6813 cmd->config_arg5 = param->config_arg5; 6814 cmd->config_arg6 = param->config_arg6; 6815 6816 wmi_mtrace(WMI_COEX_CONFIG_CMDID, cmd->vdev_id, 0); 6817 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 6818 WMI_COEX_CONFIG_CMDID); 6819 6820 if (ret != 0) { 6821 WMI_LOGE("Sending COEX CONFIG CMD failed"); 6822 wmi_buf_free(buf); 6823 } 6824 6825 return ret; 6826 } 6827 6828 #ifdef WLAN_SUPPORT_TWT 6829 static void wmi_copy_twt_resource_config(wmi_resource_config *resource_cfg, 6830 target_resource_config *tgt_res_cfg) 6831 { 6832 resource_cfg->twt_ap_pdev_count = tgt_res_cfg->twt_ap_pdev_count; 6833 resource_cfg->twt_ap_sta_count = tgt_res_cfg->twt_ap_sta_count; 6834 } 6835 #else 6836 static void wmi_copy_twt_resource_config(wmi_resource_config *resource_cfg, 6837 target_resource_config *tgt_res_cfg) 6838 { 6839 resource_cfg->twt_ap_pdev_count = 0; 6840 resource_cfg->twt_ap_sta_count = 0; 6841 } 6842 #endif 6843 6844 static 6845 void wmi_copy_resource_config(wmi_resource_config *resource_cfg, 6846 target_resource_config *tgt_res_cfg) 6847 { 6848 resource_cfg->num_vdevs = tgt_res_cfg->num_vdevs; 6849 resource_cfg->num_peers = tgt_res_cfg->num_peers; 6850 resource_cfg->num_offload_peers = tgt_res_cfg->num_offload_peers; 6851 resource_cfg->num_offload_reorder_buffs = 6852 tgt_res_cfg->num_offload_reorder_buffs; 6853 resource_cfg->num_peer_keys = tgt_res_cfg->num_peer_keys; 6854 resource_cfg->num_tids = tgt_res_cfg->num_tids; 6855 resource_cfg->ast_skid_limit = tgt_res_cfg->ast_skid_limit; 6856 resource_cfg->tx_chain_mask = tgt_res_cfg->tx_chain_mask; 6857 resource_cfg->rx_chain_mask = tgt_res_cfg->rx_chain_mask; 6858 resource_cfg->rx_timeout_pri[0] = tgt_res_cfg->rx_timeout_pri[0]; 6859 resource_cfg->rx_timeout_pri[1] = tgt_res_cfg->rx_timeout_pri[1]; 6860 resource_cfg->rx_timeout_pri[2] = tgt_res_cfg->rx_timeout_pri[2]; 6861 resource_cfg->rx_timeout_pri[3] = tgt_res_cfg->rx_timeout_pri[3]; 6862 resource_cfg->rx_decap_mode = tgt_res_cfg->rx_decap_mode; 6863 resource_cfg->scan_max_pending_req = 6864 tgt_res_cfg->scan_max_pending_req; 6865 resource_cfg->bmiss_offload_max_vdev = 6866 tgt_res_cfg->bmiss_offload_max_vdev; 6867 resource_cfg->roam_offload_max_vdev = 6868 tgt_res_cfg->roam_offload_max_vdev; 6869 resource_cfg->roam_offload_max_ap_profiles = 6870 tgt_res_cfg->roam_offload_max_ap_profiles; 6871 resource_cfg->num_mcast_groups = tgt_res_cfg->num_mcast_groups; 6872 resource_cfg->num_mcast_table_elems = 6873 tgt_res_cfg->num_mcast_table_elems; 6874 resource_cfg->mcast2ucast_mode = tgt_res_cfg->mcast2ucast_mode; 6875 resource_cfg->tx_dbg_log_size = tgt_res_cfg->tx_dbg_log_size; 6876 resource_cfg->num_wds_entries = tgt_res_cfg->num_wds_entries; 6877 resource_cfg->dma_burst_size = tgt_res_cfg->dma_burst_size; 6878 resource_cfg->mac_aggr_delim = tgt_res_cfg->mac_aggr_delim; 6879 resource_cfg->rx_skip_defrag_timeout_dup_detection_check = 6880 tgt_res_cfg->rx_skip_defrag_timeout_dup_detection_check; 6881 resource_cfg->vow_config = tgt_res_cfg->vow_config; 6882 resource_cfg->gtk_offload_max_vdev = tgt_res_cfg->gtk_offload_max_vdev; 6883 resource_cfg->num_msdu_desc = tgt_res_cfg->num_msdu_desc; 6884 resource_cfg->max_frag_entries = tgt_res_cfg->max_frag_entries; 6885 resource_cfg->num_tdls_vdevs = tgt_res_cfg->num_tdls_vdevs; 6886 resource_cfg->num_tdls_conn_table_entries = 6887 tgt_res_cfg->num_tdls_conn_table_entries; 6888 resource_cfg->beacon_tx_offload_max_vdev = 6889 tgt_res_cfg->beacon_tx_offload_max_vdev; 6890 resource_cfg->num_multicast_filter_entries = 6891 tgt_res_cfg->num_multicast_filter_entries; 6892 resource_cfg->num_wow_filters = 6893 tgt_res_cfg->num_wow_filters; 6894 resource_cfg->num_keep_alive_pattern = 6895 tgt_res_cfg->num_keep_alive_pattern; 6896 resource_cfg->keep_alive_pattern_size = 6897 tgt_res_cfg->keep_alive_pattern_size; 6898 resource_cfg->max_tdls_concurrent_sleep_sta = 6899 tgt_res_cfg->max_tdls_concurrent_sleep_sta; 6900 resource_cfg->max_tdls_concurrent_buffer_sta = 6901 tgt_res_cfg->max_tdls_concurrent_buffer_sta; 6902 resource_cfg->wmi_send_separate = 6903 tgt_res_cfg->wmi_send_separate; 6904 resource_cfg->num_ocb_vdevs = 6905 tgt_res_cfg->num_ocb_vdevs; 6906 resource_cfg->num_ocb_channels = 6907 tgt_res_cfg->num_ocb_channels; 6908 resource_cfg->num_ocb_schedules = 6909 tgt_res_cfg->num_ocb_schedules; 6910 resource_cfg->bpf_instruction_size = tgt_res_cfg->apf_instruction_size; 6911 resource_cfg->max_bssid_rx_filters = tgt_res_cfg->max_bssid_rx_filters; 6912 resource_cfg->use_pdev_id = tgt_res_cfg->use_pdev_id; 6913 resource_cfg->max_num_dbs_scan_duty_cycle = 6914 tgt_res_cfg->max_num_dbs_scan_duty_cycle; 6915 resource_cfg->sched_params = tgt_res_cfg->scheduler_params; 6916 resource_cfg->num_packet_filters = tgt_res_cfg->num_packet_filters; 6917 resource_cfg->num_max_sta_vdevs = tgt_res_cfg->num_max_sta_vdevs; 6918 resource_cfg->max_bssid_indicator = tgt_res_cfg->max_bssid_indicator; 6919 resource_cfg->max_num_group_keys = tgt_res_cfg->max_num_group_keys; 6920 /* Deferred AI: Max rnr neighbors supported in multisoc case 6921 * where in SoC can support 6ghz. During WMI init of a SoC 6922 * currently there is no way to figure if another SOC is plugged in 6923 * and it can support 6Ghz. 6924 */ 6925 resource_cfg->max_rnr_neighbours = MAX_SUPPORTED_NEIGHBORS; 6926 resource_cfg->ema_max_vap_cnt = tgt_res_cfg->ema_max_vap_cnt; 6927 resource_cfg->ema_max_profile_period = 6928 tgt_res_cfg->ema_max_profile_period; 6929 if (tgt_res_cfg->atf_config) 6930 WMI_RSRC_CFG_FLAG_ATF_CONFIG_ENABLE_SET(resource_cfg->flag1, 1); 6931 if (tgt_res_cfg->mgmt_comp_evt_bundle_support) 6932 WMI_RSRC_CFG_FLAG_MGMT_COMP_EVT_BUNDLE_SUPPORT_SET( 6933 resource_cfg->flag1, 1); 6934 if (tgt_res_cfg->tx_msdu_new_partition_id_support) 6935 WMI_RSRC_CFG_FLAG_TX_MSDU_ID_NEW_PARTITION_SUPPORT_SET( 6936 resource_cfg->flag1, 1); 6937 if (tgt_res_cfg->cce_disable) 6938 WMI_RSRC_CFG_FLAG_TCL_CCE_DISABLE_SET(resource_cfg->flag1, 1); 6939 if (tgt_res_cfg->eapol_minrate_set) { 6940 WMI_RSRC_CFG_FLAG_EAPOL_REKEY_MINRATE_SUPPORT_ENABLE_SET( 6941 resource_cfg->flag1, 1); 6942 if (tgt_res_cfg->eapol_minrate_ac_set != 3) { 6943 WMI_RSRC_CFG_FLAG_EAPOL_AC_OVERRIDE_VALID_SET( 6944 resource_cfg->flag1, 1); 6945 WMI_RSRC_CFG_FLAG_EAPOL_AC_OVERRIDE_SET( 6946 resource_cfg->flag1, 6947 tgt_res_cfg->eapol_minrate_ac_set); 6948 } 6949 } 6950 if (tgt_res_cfg->new_htt_msg_format) { 6951 WMI_RSRC_CFG_FLAG_HTT_H2T_NO_HTC_HDR_LEN_IN_MSG_LEN_SET( 6952 resource_cfg->flag1, 1); 6953 } 6954 6955 if (tgt_res_cfg->peer_unmap_conf_support) 6956 WMI_RSRC_CFG_FLAG_PEER_UNMAP_RESPONSE_SUPPORT_SET( 6957 resource_cfg->flag1, 1); 6958 6959 if (tgt_res_cfg->tstamp64_en) 6960 WMI_RSRC_CFG_FLAG_TX_COMPLETION_TX_TSF64_ENABLE_SET( 6961 resource_cfg->flag1, 1); 6962 6963 if (tgt_res_cfg->three_way_coex_config_legacy_en) 6964 WMI_RSRC_CFG_FLAG_THREE_WAY_COEX_CONFIG_LEGACY_SUPPORT_SET( 6965 resource_cfg->flag1, 1); 6966 if (tgt_res_cfg->pktcapture_support) 6967 WMI_RSRC_CFG_FLAG_PACKET_CAPTURE_SUPPORT_SET( 6968 resource_cfg->flag1, 1); 6969 6970 /* 6971 * Control padding using config param/ini of iphdr_pad_config 6972 */ 6973 if (tgt_res_cfg->iphdr_pad_config) 6974 WMI_RSRC_CFG_FLAG_IPHR_PAD_CONFIG_ENABLE_SET( 6975 resource_cfg->flag1, 1); 6976 6977 WMI_RSRC_CFG_FLAG_IPA_DISABLE_SET(resource_cfg->flag1, 6978 tgt_res_cfg->ipa_disable); 6979 6980 if (tgt_res_cfg->time_sync_ftm) 6981 WMI_RSRC_CFG_FLAG_AUDIO_SYNC_SUPPORT_SET(resource_cfg->flag1, 6982 1); 6983 6984 wmi_copy_twt_resource_config(resource_cfg, tgt_res_cfg); 6985 resource_cfg->peer_map_unmap_v2_support = 6986 tgt_res_cfg->peer_map_unmap_v2; 6987 resource_cfg->smart_ant_cap = tgt_res_cfg->smart_ant_cap; 6988 if (tgt_res_cfg->re_ul_resp) 6989 WMI_SET_BITS(resource_cfg->flags2, 0, 4, 6990 tgt_res_cfg->re_ul_resp); 6991 6992 6993 /* 6994 * Enable ast flow override per peer 6995 */ 6996 resource_cfg->msdu_flow_override_config0 = 0; 6997 WMI_MSDU_FLOW_AST_ENABLE_SET( 6998 resource_cfg->msdu_flow_override_config0, 6999 WMI_CONFIG_MSDU_AST_INDEX_1, 7000 tgt_res_cfg->ast_1_valid_mask_enable); 7001 7002 WMI_MSDU_FLOW_AST_ENABLE_SET( 7003 resource_cfg->msdu_flow_override_config0, 7004 WMI_CONFIG_MSDU_AST_INDEX_2, 7005 tgt_res_cfg->ast_2_valid_mask_enable); 7006 7007 WMI_MSDU_FLOW_AST_ENABLE_SET( 7008 resource_cfg->msdu_flow_override_config0, 7009 WMI_CONFIG_MSDU_AST_INDEX_3, 7010 tgt_res_cfg->ast_3_valid_mask_enable); 7011 7012 /* 7013 * Enable ast flow mask and TID valid mask configurations 7014 */ 7015 resource_cfg->msdu_flow_override_config1 = 0; 7016 7017 /*Enable UDP flow for Ast index 0*/ 7018 WMI_MSDU_FLOW_ASTX_MSDU_FLOW_MASKS_SET( 7019 resource_cfg->msdu_flow_override_config1, 7020 WMI_CONFIG_MSDU_AST_INDEX_0, 7021 tgt_res_cfg->ast_0_flow_mask_enable); 7022 7023 /*Enable Non UDP flow for Ast index 1*/ 7024 WMI_MSDU_FLOW_ASTX_MSDU_FLOW_MASKS_SET( 7025 resource_cfg->msdu_flow_override_config1, 7026 WMI_CONFIG_MSDU_AST_INDEX_1, 7027 tgt_res_cfg->ast_1_flow_mask_enable); 7028 7029 /*Enable Hi-Priority flow for Ast index 2*/ 7030 WMI_MSDU_FLOW_ASTX_MSDU_FLOW_MASKS_SET( 7031 resource_cfg->msdu_flow_override_config1, 7032 WMI_CONFIG_MSDU_AST_INDEX_2, 7033 tgt_res_cfg->ast_2_flow_mask_enable); 7034 7035 /*Enable Low-Priority flow for Ast index 3*/ 7036 WMI_MSDU_FLOW_ASTX_MSDU_FLOW_MASKS_SET( 7037 resource_cfg->msdu_flow_override_config1, 7038 WMI_CONFIG_MSDU_AST_INDEX_3, 7039 tgt_res_cfg->ast_3_flow_mask_enable); 7040 7041 /*Enable all 8 tid for Hi-Pririty Flow Queue*/ 7042 WMI_MSDU_FLOW_TID_VALID_HI_MASKS_SET( 7043 resource_cfg->msdu_flow_override_config1, 7044 tgt_res_cfg->ast_tid_high_mask_enable); 7045 7046 /*Enable all 8 tid for Low-Pririty Flow Queue*/ 7047 WMI_MSDU_FLOW_TID_VALID_LOW_MASKS_SET( 7048 resource_cfg->msdu_flow_override_config1, 7049 tgt_res_cfg->ast_tid_low_mask_enable); 7050 WMI_RSRC_CFG_HOST_SERVICE_FLAG_NAN_IFACE_SUPPORT_SET( 7051 resource_cfg->host_service_flags, 7052 tgt_res_cfg->nan_separate_iface_support); 7053 7054 } 7055 7056 /* copy_hw_mode_id_in_init_cmd() - Helper routine to copy hw_mode in init cmd 7057 * @wmi_handle: pointer to wmi handle 7058 * @buf_ptr: pointer to current position in init command buffer 7059 * @len: pointer to length. This will be updated with current length of cmd 7060 * @param: point host parameters for init command 7061 * 7062 * Return: Updated pointer of buf_ptr. 7063 */ 7064 static inline uint8_t *copy_hw_mode_in_init_cmd(struct wmi_unified *wmi_handle, 7065 uint8_t *buf_ptr, int *len, struct wmi_init_cmd_param *param) 7066 { 7067 uint16_t idx; 7068 7069 if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX) { 7070 wmi_pdev_set_hw_mode_cmd_fixed_param *hw_mode; 7071 wmi_pdev_band_to_mac *band_to_mac; 7072 7073 hw_mode = (wmi_pdev_set_hw_mode_cmd_fixed_param *) 7074 (buf_ptr + sizeof(wmi_init_cmd_fixed_param) + 7075 sizeof(wmi_resource_config) + 7076 WMI_TLV_HDR_SIZE + (param->num_mem_chunks * 7077 sizeof(wlan_host_memory_chunk))); 7078 7079 WMITLV_SET_HDR(&hw_mode->tlv_header, 7080 WMITLV_TAG_STRUC_wmi_pdev_set_hw_mode_cmd_fixed_param, 7081 (WMITLV_GET_STRUCT_TLVLEN 7082 (wmi_pdev_set_hw_mode_cmd_fixed_param))); 7083 7084 hw_mode->hw_mode_index = param->hw_mode_id; 7085 hw_mode->num_band_to_mac = param->num_band_to_mac; 7086 7087 buf_ptr = (uint8_t *) (hw_mode + 1); 7088 band_to_mac = (wmi_pdev_band_to_mac *) (buf_ptr + 7089 WMI_TLV_HDR_SIZE); 7090 for (idx = 0; idx < param->num_band_to_mac; idx++) { 7091 WMITLV_SET_HDR(&band_to_mac[idx].tlv_header, 7092 WMITLV_TAG_STRUC_wmi_pdev_band_to_mac, 7093 WMITLV_GET_STRUCT_TLVLEN 7094 (wmi_pdev_band_to_mac)); 7095 band_to_mac[idx].pdev_id = 7096 wmi_handle->ops->convert_pdev_id_host_to_target( 7097 wmi_handle, 7098 param->band_to_mac[idx].pdev_id); 7099 band_to_mac[idx].start_freq = 7100 param->band_to_mac[idx].start_freq; 7101 band_to_mac[idx].end_freq = 7102 param->band_to_mac[idx].end_freq; 7103 } 7104 *len += sizeof(wmi_pdev_set_hw_mode_cmd_fixed_param) + 7105 (param->num_band_to_mac * 7106 sizeof(wmi_pdev_band_to_mac)) + 7107 WMI_TLV_HDR_SIZE; 7108 7109 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 7110 (param->num_band_to_mac * 7111 sizeof(wmi_pdev_band_to_mac))); 7112 } 7113 7114 return buf_ptr; 7115 } 7116 7117 static inline void copy_fw_abi_version_tlv(wmi_unified_t wmi_handle, 7118 wmi_init_cmd_fixed_param *cmd) 7119 { 7120 int num_whitelist; 7121 wmi_abi_version my_vers; 7122 7123 num_whitelist = sizeof(version_whitelist) / 7124 sizeof(wmi_whitelist_version_info); 7125 my_vers.abi_version_0 = WMI_ABI_VERSION_0; 7126 my_vers.abi_version_1 = WMI_ABI_VERSION_1; 7127 my_vers.abi_version_ns_0 = WMI_ABI_VERSION_NS_0; 7128 my_vers.abi_version_ns_1 = WMI_ABI_VERSION_NS_1; 7129 my_vers.abi_version_ns_2 = WMI_ABI_VERSION_NS_2; 7130 my_vers.abi_version_ns_3 = WMI_ABI_VERSION_NS_3; 7131 7132 wmi_cmp_and_set_abi_version(num_whitelist, version_whitelist, 7133 &my_vers, 7134 (struct _wmi_abi_version *)&wmi_handle->fw_abi_version, 7135 &cmd->host_abi_vers); 7136 7137 qdf_print("%s: INIT_CMD version: %d, %d, 0x%x, 0x%x, 0x%x, 0x%x", 7138 __func__, 7139 WMI_VER_GET_MAJOR(cmd->host_abi_vers.abi_version_0), 7140 WMI_VER_GET_MINOR(cmd->host_abi_vers.abi_version_0), 7141 cmd->host_abi_vers.abi_version_ns_0, 7142 cmd->host_abi_vers.abi_version_ns_1, 7143 cmd->host_abi_vers.abi_version_ns_2, 7144 cmd->host_abi_vers.abi_version_ns_3); 7145 7146 /* Save version sent from host - 7147 * Will be used to check ready event 7148 */ 7149 qdf_mem_copy(&wmi_handle->final_abi_vers, &cmd->host_abi_vers, 7150 sizeof(wmi_abi_version)); 7151 } 7152 7153 /* 7154 * send_cfg_action_frm_tb_ppdu_cmd_tlv() - send action frame tb ppdu cfg to FW 7155 * @wmi_handle: Pointer to WMi handle 7156 * @ie_data: Pointer for ie data 7157 * 7158 * This function sends action frame tb ppdu cfg to FW 7159 * 7160 * Return: QDF_STATUS_SUCCESS for success otherwise failure 7161 * 7162 */ 7163 static QDF_STATUS send_cfg_action_frm_tb_ppdu_cmd_tlv(wmi_unified_t wmi_handle, 7164 struct cfg_action_frm_tb_ppdu_param *cfg_msg) 7165 { 7166 wmi_pdev_he_tb_action_frm_cmd_fixed_param *cmd; 7167 wmi_buf_t buf; 7168 uint8_t *buf_ptr; 7169 uint32_t len, frm_len_aligned; 7170 QDF_STATUS ret; 7171 7172 frm_len_aligned = roundup(cfg_msg->frm_len, sizeof(uint32_t)); 7173 /* Allocate memory for the WMI command */ 7174 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + frm_len_aligned; 7175 7176 buf = wmi_buf_alloc(wmi_handle, len); 7177 if (!buf) 7178 return QDF_STATUS_E_NOMEM; 7179 7180 buf_ptr = wmi_buf_data(buf); 7181 qdf_mem_zero(buf_ptr, len); 7182 7183 /* Populate the WMI command */ 7184 cmd = (wmi_pdev_he_tb_action_frm_cmd_fixed_param *)buf_ptr; 7185 7186 WMITLV_SET_HDR(&cmd->tlv_header, 7187 WMITLV_TAG_STRUC_wmi_pdev_he_tb_action_frm_cmd_fixed_param, 7188 WMITLV_GET_STRUCT_TLVLEN( 7189 wmi_pdev_he_tb_action_frm_cmd_fixed_param)); 7190 cmd->enable = cfg_msg->cfg; 7191 cmd->data_len = cfg_msg->frm_len; 7192 7193 buf_ptr += sizeof(*cmd); 7194 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, frm_len_aligned); 7195 buf_ptr += WMI_TLV_HDR_SIZE; 7196 7197 qdf_mem_copy(buf_ptr, cfg_msg->data, cmd->data_len); 7198 7199 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 7200 WMI_PDEV_HE_TB_ACTION_FRM_CMDID); 7201 if (QDF_IS_STATUS_ERROR(ret)) { 7202 WMI_LOGE(FL("HE TB action frame cmnd send fail, ret %d"), ret); 7203 wmi_buf_free(buf); 7204 } 7205 7206 return ret; 7207 } 7208 7209 static QDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf) 7210 { 7211 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 7212 wmi_service_ready_event_fixed_param *ev; 7213 7214 7215 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 7216 7217 ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param; 7218 if (!ev) 7219 return QDF_STATUS_E_FAILURE; 7220 7221 /*Save fw version from service ready message */ 7222 /*This will be used while sending INIT message */ 7223 qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, 7224 sizeof(wmi_handle->fw_abi_version)); 7225 7226 return QDF_STATUS_SUCCESS; 7227 } 7228 7229 /** 7230 * wmi_unified_save_fw_version_cmd() - save fw version 7231 * @wmi_handle: pointer to wmi handle 7232 * @res_cfg: resource config 7233 * @num_mem_chunks: no of mem chunck 7234 * @mem_chunk: pointer to mem chunck structure 7235 * 7236 * This function sends IE information to firmware 7237 * 7238 * Return: QDF_STATUS_SUCCESS for success otherwise failure 7239 * 7240 */ 7241 static QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle, 7242 void *evt_buf) 7243 { 7244 WMI_READY_EVENTID_param_tlvs *param_buf = NULL; 7245 wmi_ready_event_fixed_param *ev = NULL; 7246 7247 param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; 7248 ev = param_buf->fixed_param; 7249 if (!wmi_versions_are_compatible((struct _wmi_abi_version *) 7250 &wmi_handle->final_abi_vers, 7251 &ev->fw_abi_vers)) { 7252 /* 7253 * Error: Our host version and the given firmware version 7254 * are incompatible. 7255 **/ 7256 WMI_LOGD("%s: Error: Incompatible WMI version." 7257 "Host: %d,%d,0x%x 0x%x 0x%x 0x%x, FW: %d,%d,0x%x 0x%x 0x%x 0x%x", 7258 __func__, 7259 WMI_VER_GET_MAJOR(wmi_handle->final_abi_vers. 7260 abi_version_0), 7261 WMI_VER_GET_MINOR(wmi_handle->final_abi_vers. 7262 abi_version_0), 7263 wmi_handle->final_abi_vers.abi_version_ns_0, 7264 wmi_handle->final_abi_vers.abi_version_ns_1, 7265 wmi_handle->final_abi_vers.abi_version_ns_2, 7266 wmi_handle->final_abi_vers.abi_version_ns_3, 7267 WMI_VER_GET_MAJOR(ev->fw_abi_vers.abi_version_0), 7268 WMI_VER_GET_MINOR(ev->fw_abi_vers.abi_version_0), 7269 ev->fw_abi_vers.abi_version_ns_0, 7270 ev->fw_abi_vers.abi_version_ns_1, 7271 ev->fw_abi_vers.abi_version_ns_2, 7272 ev->fw_abi_vers.abi_version_ns_3); 7273 7274 return QDF_STATUS_E_FAILURE; 7275 } 7276 qdf_mem_copy(&wmi_handle->final_abi_vers, &ev->fw_abi_vers, 7277 sizeof(wmi_abi_version)); 7278 qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, 7279 sizeof(wmi_abi_version)); 7280 7281 return QDF_STATUS_SUCCESS; 7282 } 7283 7284 /** 7285 * send_log_supported_evt_cmd_tlv() - Enable/Disable FW diag/log events 7286 * @handle: wmi handle 7287 * @event: Event received from FW 7288 * @len: Length of the event 7289 * 7290 * Enables the low frequency events and disables the high frequency 7291 * events. Bit 17 indicates if the event if low/high frequency. 7292 * 1 - high frequency, 0 - low frequency 7293 * 7294 * Return: 0 on successfully enabling/disabling the events 7295 */ 7296 static QDF_STATUS send_log_supported_evt_cmd_tlv(wmi_unified_t wmi_handle, 7297 uint8_t *event, 7298 uint32_t len) 7299 { 7300 uint32_t num_of_diag_events_logs; 7301 wmi_diag_event_log_config_fixed_param *cmd; 7302 wmi_buf_t buf; 7303 uint8_t *buf_ptr; 7304 uint32_t *cmd_args, *evt_args; 7305 uint32_t buf_len, i; 7306 7307 WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID_param_tlvs *param_buf; 7308 wmi_diag_event_log_supported_event_fixed_params *wmi_event; 7309 7310 WMI_LOGI("Received WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID"); 7311 7312 param_buf = (WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID_param_tlvs *) event; 7313 if (!param_buf) { 7314 WMI_LOGE("Invalid log supported event buffer"); 7315 return QDF_STATUS_E_INVAL; 7316 } 7317 wmi_event = param_buf->fixed_param; 7318 num_of_diag_events_logs = wmi_event->num_of_diag_events_logs; 7319 7320 if (num_of_diag_events_logs > 7321 param_buf->num_diag_events_logs_list) { 7322 WMI_LOGE("message number of events %d is more than tlv hdr content %d", 7323 num_of_diag_events_logs, 7324 param_buf->num_diag_events_logs_list); 7325 return QDF_STATUS_E_INVAL; 7326 } 7327 7328 evt_args = param_buf->diag_events_logs_list; 7329 if (!evt_args) { 7330 WMI_LOGE("%s: Event list is empty, num_of_diag_events_logs=%d", 7331 __func__, num_of_diag_events_logs); 7332 return QDF_STATUS_E_INVAL; 7333 } 7334 7335 WMI_LOGD("%s: num_of_diag_events_logs=%d", 7336 __func__, num_of_diag_events_logs); 7337 7338 /* Free any previous allocation */ 7339 if (wmi_handle->events_logs_list) { 7340 qdf_mem_free(wmi_handle->events_logs_list); 7341 wmi_handle->events_logs_list = NULL; 7342 } 7343 7344 if (num_of_diag_events_logs > 7345 (WMI_SVC_MSG_MAX_SIZE / sizeof(uint32_t))) { 7346 WMI_LOGE("%s: excess num of logs:%d", __func__, 7347 num_of_diag_events_logs); 7348 QDF_ASSERT(0); 7349 return QDF_STATUS_E_INVAL; 7350 } 7351 /* Store the event list for run time enable/disable */ 7352 wmi_handle->events_logs_list = qdf_mem_malloc(num_of_diag_events_logs * 7353 sizeof(uint32_t)); 7354 if (!wmi_handle->events_logs_list) 7355 return QDF_STATUS_E_NOMEM; 7356 7357 wmi_handle->num_of_diag_events_logs = num_of_diag_events_logs; 7358 7359 /* Prepare the send buffer */ 7360 buf_len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + 7361 (num_of_diag_events_logs * sizeof(uint32_t)); 7362 7363 buf = wmi_buf_alloc(wmi_handle, buf_len); 7364 if (!buf) { 7365 qdf_mem_free(wmi_handle->events_logs_list); 7366 wmi_handle->events_logs_list = NULL; 7367 return QDF_STATUS_E_NOMEM; 7368 } 7369 7370 cmd = (wmi_diag_event_log_config_fixed_param *) wmi_buf_data(buf); 7371 buf_ptr = (uint8_t *) cmd; 7372 7373 WMITLV_SET_HDR(&cmd->tlv_header, 7374 WMITLV_TAG_STRUC_wmi_diag_event_log_config_fixed_param, 7375 WMITLV_GET_STRUCT_TLVLEN( 7376 wmi_diag_event_log_config_fixed_param)); 7377 7378 cmd->num_of_diag_events_logs = num_of_diag_events_logs; 7379 7380 buf_ptr += sizeof(wmi_diag_event_log_config_fixed_param); 7381 7382 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 7383 (num_of_diag_events_logs * sizeof(uint32_t))); 7384 7385 cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 7386 7387 /* Populate the events */ 7388 for (i = 0; i < num_of_diag_events_logs; i++) { 7389 /* Low freq (0) - Enable (1) the event 7390 * High freq (1) - Disable (0) the event 7391 */ 7392 WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[i], 7393 !(WMI_DIAG_FREQUENCY_GET(evt_args[i]))); 7394 /* Set the event ID */ 7395 WMI_DIAG_ID_SET(cmd_args[i], 7396 WMI_DIAG_ID_GET(evt_args[i])); 7397 /* Set the type */ 7398 WMI_DIAG_TYPE_SET(cmd_args[i], 7399 WMI_DIAG_TYPE_GET(evt_args[i])); 7400 /* Storing the event/log list in WMI */ 7401 wmi_handle->events_logs_list[i] = evt_args[i]; 7402 } 7403 7404 wmi_mtrace(WMI_DIAG_EVENT_LOG_CONFIG_CMDID, NO_SESSION, 0); 7405 if (wmi_unified_cmd_send(wmi_handle, buf, buf_len, 7406 WMI_DIAG_EVENT_LOG_CONFIG_CMDID)) { 7407 WMI_LOGE("%s: WMI_DIAG_EVENT_LOG_CONFIG_CMDID failed", 7408 __func__); 7409 wmi_buf_free(buf); 7410 /* Not clearing events_logs_list, though wmi cmd failed. 7411 * Host can still have this list 7412 */ 7413 return QDF_STATUS_E_INVAL; 7414 } 7415 7416 return 0; 7417 } 7418 7419 /** 7420 * send_enable_specific_fw_logs_cmd_tlv() - Start/Stop logging of diag log id 7421 * @wmi_handle: wmi handle 7422 * @start_log: Start logging related parameters 7423 * 7424 * Send the command to the FW based on which specific logging of diag 7425 * event/log id can be started/stopped 7426 * 7427 * Return: None 7428 */ 7429 static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle, 7430 struct wmi_wifi_start_log *start_log) 7431 { 7432 wmi_diag_event_log_config_fixed_param *cmd; 7433 wmi_buf_t buf; 7434 uint8_t *buf_ptr; 7435 uint32_t len, count, log_level, i; 7436 uint32_t *cmd_args; 7437 uint32_t total_len; 7438 count = 0; 7439 7440 if (!wmi_handle->events_logs_list) { 7441 WMI_LOGD("%s: Not received event/log list from FW, yet", 7442 __func__); 7443 return QDF_STATUS_E_NOMEM; 7444 } 7445 /* total_len stores the number of events where BITS 17 and 18 are set. 7446 * i.e., events of high frequency (17) and for extended debugging (18) 7447 */ 7448 total_len = 0; 7449 for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) { 7450 if ((WMI_DIAG_FREQUENCY_GET(wmi_handle->events_logs_list[i])) && 7451 (WMI_DIAG_EXT_FEATURE_GET(wmi_handle->events_logs_list[i]))) 7452 total_len++; 7453 } 7454 7455 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + 7456 (total_len * sizeof(uint32_t)); 7457 7458 buf = wmi_buf_alloc(wmi_handle, len); 7459 if (!buf) 7460 return QDF_STATUS_E_NOMEM; 7461 7462 cmd = (wmi_diag_event_log_config_fixed_param *) wmi_buf_data(buf); 7463 buf_ptr = (uint8_t *) cmd; 7464 7465 WMITLV_SET_HDR(&cmd->tlv_header, 7466 WMITLV_TAG_STRUC_wmi_diag_event_log_config_fixed_param, 7467 WMITLV_GET_STRUCT_TLVLEN( 7468 wmi_diag_event_log_config_fixed_param)); 7469 7470 cmd->num_of_diag_events_logs = total_len; 7471 7472 buf_ptr += sizeof(wmi_diag_event_log_config_fixed_param); 7473 7474 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 7475 (total_len * sizeof(uint32_t))); 7476 7477 cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 7478 7479 if (start_log->verbose_level >= WMI_LOG_LEVEL_ACTIVE) 7480 log_level = 1; 7481 else 7482 log_level = 0; 7483 7484 WMI_LOGD("%s: Length:%d, Log_level:%d", __func__, total_len, log_level); 7485 for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) { 7486 uint32_t val = wmi_handle->events_logs_list[i]; 7487 if ((WMI_DIAG_FREQUENCY_GET(val)) && 7488 (WMI_DIAG_EXT_FEATURE_GET(val))) { 7489 7490 WMI_DIAG_ID_SET(cmd_args[count], 7491 WMI_DIAG_ID_GET(val)); 7492 WMI_DIAG_TYPE_SET(cmd_args[count], 7493 WMI_DIAG_TYPE_GET(val)); 7494 WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[count], 7495 log_level); 7496 WMI_LOGD("%s: Idx:%d, val:%x", __func__, i, val); 7497 count++; 7498 } 7499 } 7500 7501 wmi_mtrace(WMI_DIAG_EVENT_LOG_CONFIG_CMDID, NO_SESSION, 0); 7502 if (wmi_unified_cmd_send(wmi_handle, buf, len, 7503 WMI_DIAG_EVENT_LOG_CONFIG_CMDID)) { 7504 WMI_LOGE("%s: WMI_DIAG_EVENT_LOG_CONFIG_CMDID failed", 7505 __func__); 7506 wmi_buf_free(buf); 7507 return QDF_STATUS_E_INVAL; 7508 } 7509 7510 return QDF_STATUS_SUCCESS; 7511 } 7512 7513 /** 7514 * send_flush_logs_to_fw_cmd_tlv() - Send log flush command to FW 7515 * @wmi_handle: WMI handle 7516 * 7517 * This function is used to send the flush command to the FW, 7518 * that will flush the fw logs that are residue in the FW 7519 * 7520 * Return: None 7521 */ 7522 static QDF_STATUS send_flush_logs_to_fw_cmd_tlv(wmi_unified_t wmi_handle) 7523 { 7524 wmi_debug_mesg_flush_fixed_param *cmd; 7525 wmi_buf_t buf; 7526 int len = sizeof(*cmd); 7527 QDF_STATUS ret; 7528 7529 buf = wmi_buf_alloc(wmi_handle, len); 7530 if (!buf) 7531 return QDF_STATUS_E_NOMEM; 7532 7533 cmd = (wmi_debug_mesg_flush_fixed_param *) wmi_buf_data(buf); 7534 WMITLV_SET_HDR(&cmd->tlv_header, 7535 WMITLV_TAG_STRUC_wmi_debug_mesg_flush_fixed_param, 7536 WMITLV_GET_STRUCT_TLVLEN( 7537 wmi_debug_mesg_flush_fixed_param)); 7538 cmd->reserved0 = 0; 7539 7540 wmi_mtrace(WMI_DEBUG_MESG_FLUSH_CMDID, NO_SESSION, 0); 7541 ret = wmi_unified_cmd_send(wmi_handle, 7542 buf, 7543 len, 7544 WMI_DEBUG_MESG_FLUSH_CMDID); 7545 if (QDF_IS_STATUS_ERROR(ret)) { 7546 WMI_LOGE("Failed to send WMI_DEBUG_MESG_FLUSH_CMDID"); 7547 wmi_buf_free(buf); 7548 return QDF_STATUS_E_INVAL; 7549 } 7550 WMI_LOGD("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW"); 7551 7552 return ret; 7553 } 7554 7555 #ifdef BIG_ENDIAN_HOST 7556 /** 7557 * fips_conv_data_be() - LE to BE conversion of FIPS ev data 7558 * @param data_len - data length 7559 * @param data - pointer to data 7560 * 7561 * Return: QDF_STATUS - success or error status 7562 */ 7563 static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle, 7564 struct fips_params *param) 7565 { 7566 unsigned char *key_unaligned, *data_unaligned; 7567 int c; 7568 u_int8_t *key_aligned = NULL; 7569 u_int8_t *data_aligned = NULL; 7570 7571 /* Assigning unaligned space to copy the key */ 7572 key_unaligned = qdf_mem_malloc( 7573 sizeof(u_int8_t)*param->key_len + FIPS_ALIGN); 7574 data_unaligned = qdf_mem_malloc( 7575 sizeof(u_int8_t)*param->data_len + FIPS_ALIGN); 7576 7577 /* Checking if kmalloc is successful to allocate space */ 7578 if (!key_unaligned) 7579 return QDF_STATUS_SUCCESS; 7580 /* Checking if space is aligned */ 7581 if (!FIPS_IS_ALIGNED(key_unaligned, FIPS_ALIGN)) { 7582 /* align to 4 */ 7583 key_aligned = 7584 (u_int8_t *)FIPS_ALIGNTO(key_unaligned, 7585 FIPS_ALIGN); 7586 } else { 7587 key_aligned = (u_int8_t *)key_unaligned; 7588 } 7589 7590 /* memset and copy content from key to key aligned */ 7591 OS_MEMSET(key_aligned, 0, param->key_len); 7592 OS_MEMCPY(key_aligned, param->key, param->key_len); 7593 7594 /* print a hexdump for host debug */ 7595 print_hex_dump(KERN_DEBUG, 7596 "\t Aligned and Copied Key:@@@@ ", 7597 DUMP_PREFIX_NONE, 7598 16, 1, key_aligned, param->key_len, true); 7599 7600 /* Checking if kmalloc is successful to allocate space */ 7601 if (!data_unaligned) 7602 return QDF_STATUS_SUCCESS; 7603 /* Checking of space is aligned */ 7604 if (!FIPS_IS_ALIGNED(data_unaligned, FIPS_ALIGN)) { 7605 /* align to 4 */ 7606 data_aligned = 7607 (u_int8_t *)FIPS_ALIGNTO(data_unaligned, 7608 FIPS_ALIGN); 7609 } else { 7610 data_aligned = (u_int8_t *)data_unaligned; 7611 } 7612 7613 /* memset and copy content from data to data aligned */ 7614 OS_MEMSET(data_aligned, 0, param->data_len); 7615 OS_MEMCPY(data_aligned, param->data, param->data_len); 7616 7617 /* print a hexdump for host debug */ 7618 print_hex_dump(KERN_DEBUG, 7619 "\t Properly Aligned and Copied Data:@@@@ ", 7620 DUMP_PREFIX_NONE, 7621 16, 1, data_aligned, param->data_len, true); 7622 7623 /* converting to little Endian both key_aligned and 7624 * data_aligned*/ 7625 for (c = 0; c < param->key_len/4; c++) { 7626 *((u_int32_t *)key_aligned+c) = 7627 qdf_cpu_to_le32(*((u_int32_t *)key_aligned+c)); 7628 } 7629 for (c = 0; c < param->data_len/4; c++) { 7630 *((u_int32_t *)data_aligned+c) = 7631 qdf_cpu_to_le32(*((u_int32_t *)data_aligned+c)); 7632 } 7633 7634 /* update endian data to key and data vectors */ 7635 OS_MEMCPY(param->key, key_aligned, param->key_len); 7636 OS_MEMCPY(param->data, data_aligned, param->data_len); 7637 7638 /* clean up allocated spaces */ 7639 qdf_mem_free(key_unaligned); 7640 key_unaligned = NULL; 7641 key_aligned = NULL; 7642 7643 qdf_mem_free(data_unaligned); 7644 data_unaligned = NULL; 7645 data_aligned = NULL; 7646 7647 return QDF_STATUS_SUCCESS; 7648 } 7649 #else 7650 /** 7651 * fips_align_data_be() - DUMMY for LE platform 7652 * 7653 * Return: QDF_STATUS - success 7654 */ 7655 static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle, 7656 struct fips_params *param) 7657 { 7658 return QDF_STATUS_SUCCESS; 7659 } 7660 #endif 7661 7662 #ifdef WLAN_FEATURE_DISA 7663 /** 7664 * send_encrypt_decrypt_send_cmd() - send encrypt/decrypt cmd to fw 7665 * @wmi_handle: wmi handle 7666 * @params: encrypt/decrypt params 7667 * 7668 * Return: QDF_STATUS_SUCCESS for success or error code 7669 */ 7670 static QDF_STATUS 7671 send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle, 7672 struct disa_encrypt_decrypt_req_params 7673 *encrypt_decrypt_params) 7674 { 7675 wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param *cmd; 7676 wmi_buf_t wmi_buf; 7677 uint8_t *buf_ptr; 7678 QDF_STATUS ret; 7679 uint32_t len; 7680 7681 WMI_LOGD(FL("Send encrypt decrypt cmd")); 7682 7683 len = sizeof(*cmd) + 7684 encrypt_decrypt_params->data_len + 7685 WMI_TLV_HDR_SIZE; 7686 wmi_buf = wmi_buf_alloc(wmi_handle, len); 7687 if (!wmi_buf) 7688 return QDF_STATUS_E_NOMEM; 7689 7690 buf_ptr = wmi_buf_data(wmi_buf); 7691 cmd = (wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param *)buf_ptr; 7692 7693 WMITLV_SET_HDR(&cmd->tlv_header, 7694 WMITLV_TAG_STRUC_wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param, 7695 WMITLV_GET_STRUCT_TLVLEN( 7696 wmi_vdev_encrypt_decrypt_data_req_cmd_fixed_param)); 7697 7698 cmd->vdev_id = encrypt_decrypt_params->vdev_id; 7699 cmd->key_flag = encrypt_decrypt_params->key_flag; 7700 cmd->key_idx = encrypt_decrypt_params->key_idx; 7701 cmd->key_cipher = encrypt_decrypt_params->key_cipher; 7702 cmd->key_len = encrypt_decrypt_params->key_len; 7703 cmd->key_txmic_len = encrypt_decrypt_params->key_txmic_len; 7704 cmd->key_rxmic_len = encrypt_decrypt_params->key_rxmic_len; 7705 7706 qdf_mem_copy(cmd->key_data, encrypt_decrypt_params->key_data, 7707 encrypt_decrypt_params->key_len); 7708 7709 qdf_mem_copy(cmd->mac_hdr, encrypt_decrypt_params->mac_header, 7710 MAX_MAC_HEADER_LEN); 7711 7712 cmd->data_len = encrypt_decrypt_params->data_len; 7713 7714 if (cmd->data_len) { 7715 buf_ptr += sizeof(*cmd); 7716 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 7717 roundup(encrypt_decrypt_params->data_len, 7718 sizeof(uint32_t))); 7719 buf_ptr += WMI_TLV_HDR_SIZE; 7720 qdf_mem_copy(buf_ptr, encrypt_decrypt_params->data, 7721 encrypt_decrypt_params->data_len); 7722 } 7723 7724 /* This conversion is to facilitate data to FW in little endian */ 7725 cmd->pn[5] = encrypt_decrypt_params->pn[0]; 7726 cmd->pn[4] = encrypt_decrypt_params->pn[1]; 7727 cmd->pn[3] = encrypt_decrypt_params->pn[2]; 7728 cmd->pn[2] = encrypt_decrypt_params->pn[3]; 7729 cmd->pn[1] = encrypt_decrypt_params->pn[4]; 7730 cmd->pn[0] = encrypt_decrypt_params->pn[5]; 7731 7732 wmi_mtrace(WMI_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMDID, cmd->vdev_id, 0); 7733 ret = wmi_unified_cmd_send(wmi_handle, 7734 wmi_buf, len, 7735 WMI_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMDID); 7736 if (QDF_IS_STATUS_ERROR(ret)) { 7737 WMI_LOGE("Failed to send ENCRYPT DECRYPT cmd: %d", ret); 7738 wmi_buf_free(wmi_buf); 7739 } 7740 7741 return ret; 7742 } 7743 #endif /* WLAN_FEATURE_DISA */ 7744 7745 /** 7746 * send_pdev_fips_cmd_tlv() - send pdev fips cmd to fw 7747 * @wmi_handle: wmi handle 7748 * @param: pointer to hold pdev fips param 7749 * 7750 * Return: 0 for success or error code 7751 */ 7752 static QDF_STATUS 7753 send_pdev_fips_cmd_tlv(wmi_unified_t wmi_handle, 7754 struct fips_params *param) 7755 { 7756 wmi_pdev_fips_cmd_fixed_param *cmd; 7757 wmi_buf_t buf; 7758 uint8_t *buf_ptr; 7759 uint32_t len = sizeof(wmi_pdev_fips_cmd_fixed_param); 7760 QDF_STATUS retval = QDF_STATUS_SUCCESS; 7761 7762 /* Length TLV placeholder for array of bytes */ 7763 len += WMI_TLV_HDR_SIZE; 7764 if (param->data_len) 7765 len += (param->data_len*sizeof(uint8_t)); 7766 7767 /* 7768 * Data length must be multiples of 16 bytes - checked against 0xF - 7769 * and must be less than WMI_SVC_MSG_SIZE - static size of 7770 * wmi_pdev_fips_cmd structure 7771 */ 7772 7773 /* do sanity on the input */ 7774 if (!(((param->data_len & 0xF) == 0) && 7775 ((param->data_len > 0) && 7776 (param->data_len < (WMI_HOST_MAX_BUFFER_SIZE - 7777 sizeof(wmi_pdev_fips_cmd_fixed_param)))))) { 7778 return QDF_STATUS_E_INVAL; 7779 } 7780 7781 buf = wmi_buf_alloc(wmi_handle, len); 7782 if (!buf) 7783 return QDF_STATUS_E_FAILURE; 7784 7785 buf_ptr = (uint8_t *) wmi_buf_data(buf); 7786 cmd = (wmi_pdev_fips_cmd_fixed_param *)buf_ptr; 7787 WMITLV_SET_HDR(&cmd->tlv_header, 7788 WMITLV_TAG_STRUC_wmi_pdev_fips_cmd_fixed_param, 7789 WMITLV_GET_STRUCT_TLVLEN 7790 (wmi_pdev_fips_cmd_fixed_param)); 7791 7792 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 7793 wmi_handle, 7794 param->pdev_id); 7795 if (param->key && param->data) { 7796 cmd->key_len = param->key_len; 7797 cmd->data_len = param->data_len; 7798 cmd->fips_cmd = !!(param->op); 7799 7800 if (fips_align_data_be(wmi_handle, param) != QDF_STATUS_SUCCESS) 7801 return QDF_STATUS_E_FAILURE; 7802 7803 qdf_mem_copy(cmd->key, param->key, param->key_len); 7804 7805 if (param->mode == FIPS_ENGINE_AES_CTR || 7806 param->mode == FIPS_ENGINE_AES_MIC) { 7807 cmd->mode = param->mode; 7808 } else { 7809 cmd->mode = FIPS_ENGINE_AES_CTR; 7810 } 7811 qdf_print("Key len = %d, Data len = %d", 7812 cmd->key_len, cmd->data_len); 7813 7814 print_hex_dump(KERN_DEBUG, "Key: ", DUMP_PREFIX_NONE, 16, 1, 7815 cmd->key, cmd->key_len, true); 7816 buf_ptr += sizeof(*cmd); 7817 7818 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->data_len); 7819 7820 buf_ptr += WMI_TLV_HDR_SIZE; 7821 if (param->data_len) 7822 qdf_mem_copy(buf_ptr, 7823 (uint8_t *) param->data, param->data_len); 7824 7825 print_hex_dump(KERN_DEBUG, "Plain text: ", DUMP_PREFIX_NONE, 7826 16, 1, buf_ptr, cmd->data_len, true); 7827 7828 buf_ptr += param->data_len; 7829 7830 wmi_mtrace(WMI_PDEV_FIPS_CMDID, NO_SESSION, 0); 7831 retval = wmi_unified_cmd_send(wmi_handle, buf, len, 7832 WMI_PDEV_FIPS_CMDID); 7833 qdf_print("%s return value %d", __func__, retval); 7834 } else { 7835 qdf_print("\n%s:%d Key or Data is NULL", __func__, __LINE__); 7836 wmi_buf_free(buf); 7837 retval = -QDF_STATUS_E_BADMSG; 7838 } 7839 7840 return retval; 7841 } 7842 7843 /** 7844 * send_wlan_profile_enable_cmd_tlv() - send wlan profile enable command 7845 * to fw 7846 * @wmi_handle: wmi handle 7847 * @param: pointer to wlan profile param 7848 * 7849 * Return: 0 for success or error code 7850 */ 7851 static QDF_STATUS 7852 send_wlan_profile_enable_cmd_tlv(wmi_unified_t wmi_handle, 7853 struct wlan_profile_params *param) 7854 { 7855 wmi_buf_t buf; 7856 uint16_t len; 7857 QDF_STATUS ret; 7858 wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd; 7859 7860 len = sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param); 7861 buf = wmi_buf_alloc(wmi_handle, len); 7862 if (!buf) { 7863 WMI_LOGE("Failed to send WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID"); 7864 return QDF_STATUS_E_NOMEM; 7865 } 7866 7867 profile_enable_cmd = 7868 (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *) 7869 wmi_buf_data(buf); 7870 WMITLV_SET_HDR(&profile_enable_cmd->tlv_header, 7871 WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param, 7872 WMITLV_GET_STRUCT_TLVLEN 7873 (wmi_wlan_profile_enable_profile_id_cmd_fixed_param)); 7874 7875 profile_enable_cmd->profile_id = param->profile_id; 7876 profile_enable_cmd->enable = param->enable; 7877 wmi_mtrace(WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID, 7878 NO_SESSION, 0); 7879 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 7880 WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID); 7881 if (ret) { 7882 WMI_LOGE("Failed to send PROFILE_ENABLE_PROFILE_ID_CMDID"); 7883 wmi_buf_free(buf); 7884 } 7885 return ret; 7886 } 7887 7888 /** 7889 * send_wlan_profile_trigger_cmd_tlv() - send wlan profile trigger command 7890 * to fw 7891 * @wmi_handle: wmi handle 7892 * @param: pointer to wlan profile param 7893 * 7894 * Return: 0 for success or error code 7895 */ 7896 static QDF_STATUS 7897 send_wlan_profile_trigger_cmd_tlv(wmi_unified_t wmi_handle, 7898 struct wlan_profile_params *param) 7899 { 7900 wmi_buf_t buf; 7901 uint16_t len; 7902 QDF_STATUS ret; 7903 wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd; 7904 7905 len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param); 7906 buf = wmi_buf_alloc(wmi_handle, len); 7907 if (!buf) { 7908 WMI_LOGE("Failed to send WMI_WLAN_PROFILE_TRIGGER_CMDID"); 7909 return QDF_STATUS_E_NOMEM; 7910 } 7911 7912 prof_trig_cmd = 7913 (wmi_wlan_profile_trigger_cmd_fixed_param *) 7914 wmi_buf_data(buf); 7915 7916 WMITLV_SET_HDR(&prof_trig_cmd->tlv_header, 7917 WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param, 7918 WMITLV_GET_STRUCT_TLVLEN 7919 (wmi_wlan_profile_trigger_cmd_fixed_param)); 7920 7921 prof_trig_cmd->enable = param->enable; 7922 wmi_mtrace(WMI_WLAN_PROFILE_TRIGGER_CMDID, NO_SESSION, 0); 7923 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 7924 WMI_WLAN_PROFILE_TRIGGER_CMDID); 7925 if (ret) { 7926 WMI_LOGE("Failed to send WMI_WLAN_PROFILE_TRIGGER_CMDID"); 7927 wmi_buf_free(buf); 7928 } 7929 return ret; 7930 } 7931 7932 /** 7933 * send_wlan_profile_hist_intvl_cmd_tlv() - send wlan profile interval command 7934 * to fw 7935 * @wmi_handle: wmi handle 7936 * @param: pointer to wlan profile param 7937 * 7938 * Return: 0 for success or error code 7939 */ 7940 static QDF_STATUS 7941 send_wlan_profile_hist_intvl_cmd_tlv(wmi_unified_t wmi_handle, 7942 struct wlan_profile_params *param) 7943 { 7944 wmi_buf_t buf; 7945 int32_t len = 0; 7946 QDF_STATUS ret; 7947 wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd; 7948 7949 len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param); 7950 buf = wmi_buf_alloc(wmi_handle, len); 7951 if (!buf) { 7952 WMI_LOGE("Failed to send WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID"); 7953 return QDF_STATUS_E_NOMEM; 7954 } 7955 7956 hist_intvl_cmd = 7957 (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *) 7958 wmi_buf_data(buf); 7959 7960 WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header, 7961 WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param, 7962 WMITLV_GET_STRUCT_TLVLEN 7963 (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param)); 7964 7965 hist_intvl_cmd->profile_id = param->profile_id; 7966 hist_intvl_cmd->value = param->enable; 7967 wmi_mtrace(WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID, 7968 NO_SESSION, 0); 7969 7970 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 7971 WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID); 7972 if (ret) { 7973 WMI_LOGE("Failed to send PROFILE_SET_HIST_INTVL_CMDID"); 7974 wmi_buf_free(buf); 7975 } 7976 return ret; 7977 } 7978 7979 /** 7980 * send_fw_test_cmd_tlv() - send fw test command to fw. 7981 * @wmi_handle: wmi handle 7982 * @wmi_fwtest: fw test command 7983 * 7984 * This function sends fw test command to fw. 7985 * 7986 * Return: CDF STATUS 7987 */ 7988 static 7989 QDF_STATUS send_fw_test_cmd_tlv(wmi_unified_t wmi_handle, 7990 struct set_fwtest_params *wmi_fwtest) 7991 { 7992 wmi_fwtest_set_param_cmd_fixed_param *cmd; 7993 wmi_buf_t wmi_buf; 7994 uint16_t len; 7995 7996 len = sizeof(*cmd); 7997 7998 wmi_buf = wmi_buf_alloc(wmi_handle, len); 7999 if (!wmi_buf) 8000 return QDF_STATUS_E_NOMEM; 8001 8002 cmd = (wmi_fwtest_set_param_cmd_fixed_param *) wmi_buf_data(wmi_buf); 8003 WMITLV_SET_HDR(&cmd->tlv_header, 8004 WMITLV_TAG_STRUC_wmi_fwtest_set_param_cmd_fixed_param, 8005 WMITLV_GET_STRUCT_TLVLEN( 8006 wmi_fwtest_set_param_cmd_fixed_param)); 8007 cmd->param_id = wmi_fwtest->arg; 8008 cmd->param_value = wmi_fwtest->value; 8009 8010 wmi_mtrace(WMI_FWTEST_CMDID, NO_SESSION, 0); 8011 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 8012 WMI_FWTEST_CMDID)) { 8013 WMI_LOGP("%s: failed to send fw test command", __func__); 8014 wmi_buf_free(wmi_buf); 8015 return QDF_STATUS_E_FAILURE; 8016 } 8017 8018 return QDF_STATUS_SUCCESS; 8019 } 8020 8021 /** 8022 * send_unit_test_cmd_tlv() - send unit test command to fw. 8023 * @wmi_handle: wmi handle 8024 * @wmi_utest: unit test command 8025 * 8026 * This function send unit test command to fw. 8027 * 8028 * Return: CDF STATUS 8029 */ 8030 static QDF_STATUS send_unit_test_cmd_tlv(wmi_unified_t wmi_handle, 8031 struct wmi_unit_test_cmd *wmi_utest) 8032 { 8033 wmi_unit_test_cmd_fixed_param *cmd; 8034 wmi_buf_t wmi_buf; 8035 uint8_t *buf_ptr; 8036 int i; 8037 uint16_t len, args_tlv_len; 8038 uint32_t *unit_test_cmd_args; 8039 8040 args_tlv_len = 8041 WMI_TLV_HDR_SIZE + wmi_utest->num_args * sizeof(uint32_t); 8042 len = sizeof(wmi_unit_test_cmd_fixed_param) + args_tlv_len; 8043 8044 wmi_buf = wmi_buf_alloc(wmi_handle, len); 8045 if (!wmi_buf) 8046 return QDF_STATUS_E_NOMEM; 8047 8048 cmd = (wmi_unit_test_cmd_fixed_param *) wmi_buf_data(wmi_buf); 8049 buf_ptr = (uint8_t *) cmd; 8050 WMITLV_SET_HDR(&cmd->tlv_header, 8051 WMITLV_TAG_STRUC_wmi_unit_test_cmd_fixed_param, 8052 WMITLV_GET_STRUCT_TLVLEN(wmi_unit_test_cmd_fixed_param)); 8053 cmd->vdev_id = wmi_utest->vdev_id; 8054 cmd->module_id = wmi_utest->module_id; 8055 cmd->num_args = wmi_utest->num_args; 8056 cmd->diag_token = wmi_utest->diag_token; 8057 buf_ptr += sizeof(wmi_unit_test_cmd_fixed_param); 8058 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 8059 (wmi_utest->num_args * sizeof(uint32_t))); 8060 unit_test_cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 8061 WMI_LOGI("%s: VDEV ID: %d", __func__, cmd->vdev_id); 8062 WMI_LOGI("%s: MODULE ID: %d", __func__, cmd->module_id); 8063 WMI_LOGI("%s: TOKEN: %d", __func__, cmd->diag_token); 8064 WMI_LOGI("%s: %d num of args = ", __func__, wmi_utest->num_args); 8065 for (i = 0; (i < wmi_utest->num_args && i < WMI_UNIT_TEST_MAX_NUM_ARGS); i++) { 8066 unit_test_cmd_args[i] = wmi_utest->args[i]; 8067 WMI_LOGI("%d,", wmi_utest->args[i]); 8068 } 8069 wmi_mtrace(WMI_UNIT_TEST_CMDID, cmd->vdev_id, 0); 8070 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 8071 WMI_UNIT_TEST_CMDID)) { 8072 WMI_LOGP("%s: failed to send unit test command", __func__); 8073 wmi_buf_free(wmi_buf); 8074 return QDF_STATUS_E_FAILURE; 8075 } 8076 8077 return QDF_STATUS_SUCCESS; 8078 } 8079 8080 /** 8081 * send_power_dbg_cmd_tlv() - send power debug commands 8082 * @wmi_handle: wmi handle 8083 * @param: wmi power debug parameter 8084 * 8085 * Send WMI_POWER_DEBUG_CMDID parameters to fw. 8086 * 8087 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 8088 */ 8089 static QDF_STATUS send_power_dbg_cmd_tlv(wmi_unified_t wmi_handle, 8090 struct wmi_power_dbg_params *param) 8091 { 8092 wmi_buf_t buf = NULL; 8093 QDF_STATUS status; 8094 int len, args_tlv_len; 8095 uint8_t *buf_ptr; 8096 uint8_t i; 8097 wmi_pdev_wal_power_debug_cmd_fixed_param *cmd; 8098 uint32_t *cmd_args; 8099 8100 /* Prepare and send power debug cmd parameters */ 8101 args_tlv_len = WMI_TLV_HDR_SIZE + param->num_args * sizeof(uint32_t); 8102 len = sizeof(*cmd) + args_tlv_len; 8103 buf = wmi_buf_alloc(wmi_handle, len); 8104 if (!buf) 8105 return QDF_STATUS_E_NOMEM; 8106 8107 buf_ptr = (uint8_t *) wmi_buf_data(buf); 8108 cmd = (wmi_pdev_wal_power_debug_cmd_fixed_param *) buf_ptr; 8109 WMITLV_SET_HDR(&cmd->tlv_header, 8110 WMITLV_TAG_STRUC_wmi_pdev_wal_power_debug_cmd_fixed_param, 8111 WMITLV_GET_STRUCT_TLVLEN 8112 (wmi_pdev_wal_power_debug_cmd_fixed_param)); 8113 8114 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8115 wmi_handle, 8116 param->pdev_id); 8117 cmd->module_id = param->module_id; 8118 cmd->num_args = param->num_args; 8119 buf_ptr += sizeof(*cmd); 8120 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 8121 (param->num_args * sizeof(uint32_t))); 8122 cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 8123 WMI_LOGI("%s: %d num of args = ", __func__, param->num_args); 8124 for (i = 0; (i < param->num_args && i < WMI_MAX_POWER_DBG_ARGS); i++) { 8125 cmd_args[i] = param->args[i]; 8126 WMI_LOGI("%d,", param->args[i]); 8127 } 8128 8129 wmi_mtrace(WMI_PDEV_WAL_POWER_DEBUG_CMDID, NO_SESSION, 0); 8130 status = wmi_unified_cmd_send(wmi_handle, buf, 8131 len, WMI_PDEV_WAL_POWER_DEBUG_CMDID); 8132 if (QDF_IS_STATUS_ERROR(status)) { 8133 WMI_LOGE("wmi_unified_cmd_send WMI_PDEV_WAL_POWER_DEBUG_CMDID returned Error %d", 8134 status); 8135 goto error; 8136 } 8137 8138 return QDF_STATUS_SUCCESS; 8139 error: 8140 wmi_buf_free(buf); 8141 8142 return status; 8143 } 8144 8145 /** 8146 * send_dfs_phyerr_offload_en_cmd_tlv() - send dfs phyerr offload enable cmd 8147 * @wmi_handle: wmi handle 8148 * @pdev_id: pdev id 8149 * 8150 * Send WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID command to firmware. 8151 * 8152 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 8153 */ 8154 static QDF_STATUS send_dfs_phyerr_offload_en_cmd_tlv(wmi_unified_t wmi_handle, 8155 uint32_t pdev_id) 8156 { 8157 wmi_pdev_dfs_phyerr_offload_enable_cmd_fixed_param *cmd; 8158 wmi_buf_t buf; 8159 uint16_t len; 8160 QDF_STATUS ret; 8161 8162 len = sizeof(*cmd); 8163 buf = wmi_buf_alloc(wmi_handle, len); 8164 8165 WMI_LOGI("%s: pdev_id=%d", __func__, pdev_id); 8166 8167 if (!buf) 8168 return QDF_STATUS_E_NOMEM; 8169 8170 cmd = (wmi_pdev_dfs_phyerr_offload_enable_cmd_fixed_param *) 8171 wmi_buf_data(buf); 8172 8173 WMITLV_SET_HDR(&cmd->tlv_header, 8174 WMITLV_TAG_STRUC_wmi_pdev_dfs_phyerr_offload_enable_cmd_fixed_param, 8175 WMITLV_GET_STRUCT_TLVLEN( 8176 wmi_pdev_dfs_phyerr_offload_enable_cmd_fixed_param)); 8177 8178 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8179 wmi_handle, 8180 pdev_id); 8181 wmi_mtrace(WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID, NO_SESSION, 0); 8182 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 8183 WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID); 8184 if (QDF_IS_STATUS_ERROR(ret)) { 8185 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d, pdev_id=%d", 8186 __func__, ret, pdev_id); 8187 wmi_buf_free(buf); 8188 return QDF_STATUS_E_FAILURE; 8189 } 8190 8191 return QDF_STATUS_SUCCESS; 8192 } 8193 8194 /** 8195 * send_dfs_phyerr_offload_dis_cmd_tlv() - send dfs phyerr offload disable cmd 8196 * @wmi_handle: wmi handle 8197 * @pdev_id: pdev id 8198 * 8199 * Send WMI_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMDID command to firmware. 8200 * 8201 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 8202 */ 8203 static QDF_STATUS send_dfs_phyerr_offload_dis_cmd_tlv(wmi_unified_t wmi_handle, 8204 uint32_t pdev_id) 8205 { 8206 wmi_pdev_dfs_phyerr_offload_disable_cmd_fixed_param *cmd; 8207 wmi_buf_t buf; 8208 uint16_t len; 8209 QDF_STATUS ret; 8210 8211 len = sizeof(*cmd); 8212 buf = wmi_buf_alloc(wmi_handle, len); 8213 8214 WMI_LOGI("%s: pdev_id=%d", __func__, pdev_id); 8215 8216 if (!buf) 8217 return QDF_STATUS_E_NOMEM; 8218 8219 cmd = (wmi_pdev_dfs_phyerr_offload_disable_cmd_fixed_param *) 8220 wmi_buf_data(buf); 8221 8222 WMITLV_SET_HDR(&cmd->tlv_header, 8223 WMITLV_TAG_STRUC_wmi_pdev_dfs_phyerr_offload_disable_cmd_fixed_param, 8224 WMITLV_GET_STRUCT_TLVLEN( 8225 wmi_pdev_dfs_phyerr_offload_disable_cmd_fixed_param)); 8226 8227 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8228 wmi_handle, 8229 pdev_id); 8230 wmi_mtrace(WMI_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMDID, NO_SESSION, 0); 8231 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 8232 WMI_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMDID); 8233 if (QDF_IS_STATUS_ERROR(ret)) { 8234 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d, pdev_id=%d", 8235 __func__, ret, pdev_id); 8236 wmi_buf_free(buf); 8237 return QDF_STATUS_E_FAILURE; 8238 } 8239 8240 return QDF_STATUS_SUCCESS; 8241 } 8242 8243 #ifdef QCA_SUPPORT_AGILE_DFS 8244 static 8245 QDF_STATUS send_adfs_ch_cfg_cmd_tlv(wmi_unified_t wmi_handle, 8246 struct vdev_adfs_ch_cfg_params *param) 8247 { 8248 /* wmi_unified_cmd_send set request of agile ADFS channel*/ 8249 wmi_vdev_adfs_ch_cfg_cmd_fixed_param *cmd; 8250 wmi_buf_t buf; 8251 QDF_STATUS ret; 8252 uint16_t len; 8253 8254 len = sizeof(*cmd); 8255 buf = wmi_buf_alloc(wmi_handle, len); 8256 8257 if (!buf) { 8258 WMI_LOGE("%s : wmi_buf_alloc failed", __func__); 8259 return QDF_STATUS_E_NOMEM; 8260 } 8261 8262 cmd = (wmi_vdev_adfs_ch_cfg_cmd_fixed_param *) 8263 wmi_buf_data(buf); 8264 8265 WMITLV_SET_HDR(&cmd->tlv_header, 8266 WMITLV_TAG_STRUC_wmi_vdev_adfs_ch_cfg_cmd_fixed_param, 8267 WMITLV_GET_STRUCT_TLVLEN 8268 (wmi_vdev_adfs_ch_cfg_cmd_fixed_param)); 8269 8270 cmd->vdev_id = param->vdev_id; 8271 cmd->ocac_mode = param->ocac_mode; 8272 cmd->center_freq1 = param->center_freq1; 8273 cmd->center_freq2 = param->center_freq2; 8274 cmd->chan_freq = param->chan_freq; 8275 cmd->chan_width = param->chan_width; 8276 cmd->min_duration_ms = param->min_duration_ms; 8277 cmd->max_duration_ms = param->max_duration_ms; 8278 WMI_LOGD("%s:cmd->vdev_id: %d ,cmd->ocac_mode: %d cmd->center_freq: %d", 8279 __func__, cmd->vdev_id, cmd->ocac_mode, 8280 cmd->center_freq); 8281 8282 wmi_mtrace(WMI_VDEV_ADFS_CH_CFG_CMDID, NO_SESSION, 0); 8283 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 8284 WMI_VDEV_ADFS_CH_CFG_CMDID); 8285 8286 if (QDF_IS_STATUS_ERROR(ret)) { 8287 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d", 8288 __func__, ret); 8289 wmi_buf_free(buf); 8290 return QDF_STATUS_E_FAILURE; 8291 } 8292 8293 return QDF_STATUS_SUCCESS; 8294 } 8295 8296 static 8297 QDF_STATUS send_adfs_ocac_abort_cmd_tlv(wmi_unified_t wmi_handle, 8298 struct vdev_adfs_abort_params *param) 8299 { 8300 /*wmi_unified_cmd_send with ocac abort on ADFS channel*/ 8301 wmi_vdev_adfs_ocac_abort_cmd_fixed_param *cmd; 8302 wmi_buf_t buf; 8303 QDF_STATUS ret; 8304 uint16_t len; 8305 8306 len = sizeof(*cmd); 8307 buf = wmi_buf_alloc(wmi_handle, len); 8308 8309 if (!buf) { 8310 WMI_LOGE("%s : wmi_buf_alloc failed", __func__); 8311 return QDF_STATUS_E_NOMEM; 8312 } 8313 8314 cmd = (wmi_vdev_adfs_ocac_abort_cmd_fixed_param *) 8315 wmi_buf_data(buf); 8316 8317 WMITLV_SET_HDR 8318 (&cmd->tlv_header, 8319 WMITLV_TAG_STRUC_wmi_vdev_adfs_ocac_abort_cmd_fixed_param, 8320 WMITLV_GET_STRUCT_TLVLEN 8321 (wmi_vdev_adfs_ocac_abort_cmd_fixed_param)); 8322 8323 cmd->vdev_id = param->vdev_id; 8324 8325 wmi_mtrace(WMI_VDEV_ADFS_OCAC_ABORT_CMDID, NO_SESSION, 0); 8326 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 8327 WMI_VDEV_ADFS_OCAC_ABORT_CMDID); 8328 8329 if (QDF_IS_STATUS_ERROR(ret)) { 8330 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d", 8331 __func__, ret); 8332 wmi_buf_free(buf); 8333 return QDF_STATUS_E_FAILURE; 8334 } 8335 8336 return QDF_STATUS_SUCCESS; 8337 } 8338 #endif 8339 8340 /** 8341 * is_service_enabled_tlv() - Check if service enabled 8342 * @param wmi_handle: wmi handle 8343 * @param service_id: service identifier 8344 * 8345 * Return: 1 enabled, 0 disabled 8346 */ 8347 static bool is_service_enabled_tlv(wmi_unified_t wmi_handle, 8348 uint32_t service_id) 8349 { 8350 struct wmi_soc *soc = wmi_handle->soc; 8351 8352 if (!soc->wmi_service_bitmap) { 8353 WMI_LOGE("WMI service bit map is not saved yet"); 8354 return false; 8355 } 8356 8357 /* if wmi_service_enabled was received with extended bitmap, 8358 * use WMI_SERVICE_EXT_IS_ENABLED to check the services. 8359 */ 8360 if (soc->wmi_ext_service_bitmap) 8361 return WMI_SERVICE_EXT_IS_ENABLED(soc->wmi_service_bitmap, 8362 soc->wmi_ext_service_bitmap, 8363 service_id); 8364 8365 if (service_id >= WMI_MAX_SERVICE) { 8366 WMI_LOGE("Service id %d but WMI ext service bitmap is NULL", 8367 service_id); 8368 return false; 8369 } 8370 8371 return WMI_SERVICE_IS_ENABLED(soc->wmi_service_bitmap, 8372 service_id); 8373 } 8374 8375 /** 8376 * init_cmd_send_tlv() - send initialization cmd to fw 8377 * @wmi_handle: wmi handle 8378 * @param param: pointer to wmi init param 8379 * 8380 * Return: QDF_STATUS_SUCCESS for success or error code 8381 */ 8382 static QDF_STATUS init_cmd_send_tlv(wmi_unified_t wmi_handle, 8383 struct wmi_init_cmd_param *param) 8384 { 8385 wmi_buf_t buf; 8386 wmi_init_cmd_fixed_param *cmd; 8387 uint8_t *buf_ptr; 8388 wmi_resource_config *resource_cfg; 8389 wlan_host_memory_chunk *host_mem_chunks; 8390 uint32_t mem_chunk_len = 0, hw_mode_len = 0; 8391 uint16_t idx; 8392 int len; 8393 QDF_STATUS ret; 8394 8395 len = sizeof(*cmd) + sizeof(wmi_resource_config) + 8396 WMI_TLV_HDR_SIZE; 8397 mem_chunk_len = (sizeof(wlan_host_memory_chunk) * MAX_MEM_CHUNKS); 8398 8399 if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX) 8400 hw_mode_len = sizeof(wmi_pdev_set_hw_mode_cmd_fixed_param) + 8401 WMI_TLV_HDR_SIZE + 8402 (param->num_band_to_mac * sizeof(wmi_pdev_band_to_mac)); 8403 8404 buf = wmi_buf_alloc(wmi_handle, len + mem_chunk_len + hw_mode_len); 8405 if (!buf) 8406 return QDF_STATUS_E_FAILURE; 8407 8408 buf_ptr = (uint8_t *) wmi_buf_data(buf); 8409 cmd = (wmi_init_cmd_fixed_param *) buf_ptr; 8410 resource_cfg = (wmi_resource_config *) (buf_ptr + sizeof(*cmd)); 8411 8412 host_mem_chunks = (wlan_host_memory_chunk *) 8413 (buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config) 8414 + WMI_TLV_HDR_SIZE); 8415 8416 WMITLV_SET_HDR(&cmd->tlv_header, 8417 WMITLV_TAG_STRUC_wmi_init_cmd_fixed_param, 8418 WMITLV_GET_STRUCT_TLVLEN(wmi_init_cmd_fixed_param)); 8419 8420 wmi_copy_resource_config(resource_cfg, param->res_cfg); 8421 WMITLV_SET_HDR(&resource_cfg->tlv_header, 8422 WMITLV_TAG_STRUC_wmi_resource_config, 8423 WMITLV_GET_STRUCT_TLVLEN(wmi_resource_config)); 8424 8425 for (idx = 0; idx < param->num_mem_chunks; ++idx) { 8426 WMITLV_SET_HDR(&(host_mem_chunks[idx].tlv_header), 8427 WMITLV_TAG_STRUC_wlan_host_memory_chunk, 8428 WMITLV_GET_STRUCT_TLVLEN 8429 (wlan_host_memory_chunk)); 8430 host_mem_chunks[idx].ptr = param->mem_chunks[idx].paddr; 8431 host_mem_chunks[idx].size = param->mem_chunks[idx].len; 8432 host_mem_chunks[idx].req_id = param->mem_chunks[idx].req_id; 8433 if (is_service_enabled_tlv(wmi_handle, 8434 WMI_SERVICE_SUPPORT_EXTEND_ADDRESS)) 8435 host_mem_chunks[idx].ptr_high = 8436 qdf_get_upper_32_bits( 8437 param->mem_chunks[idx].paddr); 8438 QDF_TRACE(QDF_MODULE_ID_ANY, QDF_TRACE_LEVEL_DEBUG, 8439 "chunk %d len %d requested ,ptr 0x%x ", 8440 idx, host_mem_chunks[idx].size, 8441 host_mem_chunks[idx].ptr); 8442 } 8443 cmd->num_host_mem_chunks = param->num_mem_chunks; 8444 len += (param->num_mem_chunks * sizeof(wlan_host_memory_chunk)); 8445 8446 WMITLV_SET_HDR((buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)), 8447 WMITLV_TAG_ARRAY_STRUC, 8448 (sizeof(wlan_host_memory_chunk) * 8449 param->num_mem_chunks)); 8450 8451 /* Fill hw mode id config */ 8452 buf_ptr = copy_hw_mode_in_init_cmd(wmi_handle, buf_ptr, &len, param); 8453 8454 /* Fill fw_abi_vers */ 8455 copy_fw_abi_version_tlv(wmi_handle, cmd); 8456 8457 wmi_mtrace(WMI_INIT_CMDID, NO_SESSION, 0); 8458 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_INIT_CMDID); 8459 if (QDF_IS_STATUS_ERROR(ret)) { 8460 WMI_LOGE("wmi_unified_cmd_send WMI_INIT_CMDID returned Error %d", 8461 ret); 8462 wmi_buf_free(buf); 8463 } 8464 8465 return ret; 8466 8467 } 8468 8469 /** 8470 * send_addba_send_cmd_tlv() - send addba send command to fw 8471 * @wmi_handle: wmi handle 8472 * @param: pointer to delba send params 8473 * @macaddr: peer mac address 8474 * 8475 * Send WMI_ADDBA_SEND_CMDID command to firmware 8476 * Return: QDF_STATUS_SUCCESS on success. QDF_STATUS_E** on error 8477 */ 8478 static QDF_STATUS 8479 send_addba_send_cmd_tlv(wmi_unified_t wmi_handle, 8480 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 8481 struct addba_send_params *param) 8482 { 8483 wmi_addba_send_cmd_fixed_param *cmd; 8484 wmi_buf_t buf; 8485 uint16_t len; 8486 QDF_STATUS ret; 8487 8488 len = sizeof(*cmd); 8489 8490 buf = wmi_buf_alloc(wmi_handle, len); 8491 if (!buf) 8492 return QDF_STATUS_E_NOMEM; 8493 8494 cmd = (wmi_addba_send_cmd_fixed_param *)wmi_buf_data(buf); 8495 8496 WMITLV_SET_HDR(&cmd->tlv_header, 8497 WMITLV_TAG_STRUC_wmi_addba_send_cmd_fixed_param, 8498 WMITLV_GET_STRUCT_TLVLEN(wmi_addba_send_cmd_fixed_param)); 8499 8500 cmd->vdev_id = param->vdev_id; 8501 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr); 8502 cmd->tid = param->tidno; 8503 cmd->buffersize = param->buffersize; 8504 8505 wmi_mtrace(WMI_ADDBA_SEND_CMDID, cmd->vdev_id, 0); 8506 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_ADDBA_SEND_CMDID); 8507 if (QDF_IS_STATUS_ERROR(ret)) { 8508 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d", __func__, ret); 8509 wmi_buf_free(buf); 8510 return QDF_STATUS_E_FAILURE; 8511 } 8512 8513 return QDF_STATUS_SUCCESS; 8514 } 8515 8516 /** 8517 * send_delba_send_cmd_tlv() - send delba send command to fw 8518 * @wmi_handle: wmi handle 8519 * @param: pointer to delba send params 8520 * @macaddr: peer mac address 8521 * 8522 * Send WMI_DELBA_SEND_CMDID command to firmware 8523 * Return: QDF_STATUS_SUCCESS on success. QDF_STATUS_E** on error 8524 */ 8525 static QDF_STATUS 8526 send_delba_send_cmd_tlv(wmi_unified_t wmi_handle, 8527 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 8528 struct delba_send_params *param) 8529 { 8530 wmi_delba_send_cmd_fixed_param *cmd; 8531 wmi_buf_t buf; 8532 uint16_t len; 8533 QDF_STATUS ret; 8534 8535 len = sizeof(*cmd); 8536 8537 buf = wmi_buf_alloc(wmi_handle, len); 8538 if (!buf) 8539 return QDF_STATUS_E_NOMEM; 8540 8541 cmd = (wmi_delba_send_cmd_fixed_param *)wmi_buf_data(buf); 8542 8543 WMITLV_SET_HDR(&cmd->tlv_header, 8544 WMITLV_TAG_STRUC_wmi_delba_send_cmd_fixed_param, 8545 WMITLV_GET_STRUCT_TLVLEN(wmi_delba_send_cmd_fixed_param)); 8546 8547 cmd->vdev_id = param->vdev_id; 8548 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr); 8549 cmd->tid = param->tidno; 8550 cmd->initiator = param->initiator; 8551 cmd->reasoncode = param->reasoncode; 8552 8553 wmi_mtrace(WMI_DELBA_SEND_CMDID, cmd->vdev_id, 0); 8554 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_DELBA_SEND_CMDID); 8555 if (QDF_IS_STATUS_ERROR(ret)) { 8556 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d", __func__, ret); 8557 wmi_buf_free(buf); 8558 return QDF_STATUS_E_FAILURE; 8559 } 8560 8561 return QDF_STATUS_SUCCESS; 8562 } 8563 8564 /** 8565 * send_addba_clearresponse_cmd_tlv() - send addba clear response command 8566 * to fw 8567 * @wmi_handle: wmi handle 8568 * @param: pointer to addba clearresp params 8569 * @macaddr: peer mac address 8570 * Return: 0 for success or error code 8571 */ 8572 static QDF_STATUS 8573 send_addba_clearresponse_cmd_tlv(wmi_unified_t wmi_handle, 8574 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 8575 struct addba_clearresponse_params *param) 8576 { 8577 wmi_addba_clear_resp_cmd_fixed_param *cmd; 8578 wmi_buf_t buf; 8579 uint16_t len; 8580 QDF_STATUS ret; 8581 8582 len = sizeof(*cmd); 8583 8584 buf = wmi_buf_alloc(wmi_handle, len); 8585 if (!buf) 8586 return QDF_STATUS_E_FAILURE; 8587 8588 cmd = (wmi_addba_clear_resp_cmd_fixed_param *)wmi_buf_data(buf); 8589 8590 WMITLV_SET_HDR(&cmd->tlv_header, 8591 WMITLV_TAG_STRUC_wmi_addba_clear_resp_cmd_fixed_param, 8592 WMITLV_GET_STRUCT_TLVLEN(wmi_addba_clear_resp_cmd_fixed_param)); 8593 8594 cmd->vdev_id = param->vdev_id; 8595 WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr); 8596 8597 wmi_mtrace(WMI_ADDBA_CLEAR_RESP_CMDID, cmd->vdev_id, 0); 8598 ret = wmi_unified_cmd_send(wmi_handle, 8599 buf, len, WMI_ADDBA_CLEAR_RESP_CMDID); 8600 if (QDF_IS_STATUS_ERROR(ret)) { 8601 WMI_LOGE("%s: Failed to send cmd to fw, ret=%d", __func__, ret); 8602 wmi_buf_free(buf); 8603 return QDF_STATUS_E_FAILURE; 8604 } 8605 8606 return QDF_STATUS_SUCCESS; 8607 } 8608 8609 #ifdef OBSS_PD 8610 /** 8611 * send_obss_spatial_reuse_set_def_thresh_cmd_tlv - send obss spatial reuse set 8612 * def thresh to fw 8613 * @wmi_handle: wmi handle 8614 * @thresh: pointer to obss_spatial_reuse_def_thresh 8615 * 8616 * Return: QDF_STATUS_SUCCESS for success or error code 8617 */ 8618 static 8619 QDF_STATUS send_obss_spatial_reuse_set_def_thresh_cmd_tlv( 8620 wmi_unified_t wmi_handle, 8621 struct wmi_host_obss_spatial_reuse_set_def_thresh 8622 *thresh) 8623 { 8624 wmi_buf_t buf; 8625 wmi_obss_spatial_reuse_set_def_obss_thresh_cmd_fixed_param *cmd; 8626 QDF_STATUS ret; 8627 uint32_t cmd_len; 8628 uint32_t tlv_len; 8629 8630 cmd_len = sizeof(*cmd); 8631 8632 buf = wmi_buf_alloc(wmi_handle, cmd_len); 8633 if (!buf) 8634 return QDF_STATUS_E_NOMEM; 8635 8636 cmd = (wmi_obss_spatial_reuse_set_def_obss_thresh_cmd_fixed_param *) 8637 wmi_buf_data(buf); 8638 8639 tlv_len = WMITLV_GET_STRUCT_TLVLEN( 8640 wmi_obss_spatial_reuse_set_def_obss_thresh_cmd_fixed_param); 8641 8642 WMITLV_SET_HDR(&cmd->tlv_header, 8643 WMITLV_TAG_STRUC_wmi_obss_spatial_reuse_set_def_obss_thresh_cmd_fixed_param, 8644 tlv_len); 8645 8646 cmd->obss_min = thresh->obss_min; 8647 cmd->obss_max = thresh->obss_max; 8648 cmd->vdev_type = thresh->vdev_type; 8649 ret = wmi_unified_cmd_send(wmi_handle, buf, cmd_len, 8650 WMI_PDEV_OBSS_PD_SPATIAL_REUSE_SET_DEF_OBSS_THRESH_CMDID); 8651 if (QDF_IS_STATUS_ERROR(ret)) 8652 wmi_buf_free(buf); 8653 8654 return ret; 8655 } 8656 8657 /** 8658 * send_obss_spatial_reuse_set_cmd_tlv - send obss spatial reuse set cmd to fw 8659 * @wmi_handle: wmi handle 8660 * @obss_spatial_reuse_param: pointer to obss_spatial_reuse_param 8661 * 8662 * Return: QDF_STATUS_SUCCESS for success or error code 8663 */ 8664 static 8665 QDF_STATUS send_obss_spatial_reuse_set_cmd_tlv(wmi_unified_t wmi_handle, 8666 struct wmi_host_obss_spatial_reuse_set_param 8667 *obss_spatial_reuse_param) 8668 { 8669 wmi_buf_t buf; 8670 wmi_obss_spatial_reuse_set_cmd_fixed_param *cmd; 8671 QDF_STATUS ret; 8672 uint32_t len; 8673 8674 len = sizeof(*cmd); 8675 8676 buf = wmi_buf_alloc(wmi_handle, len); 8677 if (!buf) 8678 return QDF_STATUS_E_FAILURE; 8679 8680 cmd = (wmi_obss_spatial_reuse_set_cmd_fixed_param *)wmi_buf_data(buf); 8681 WMITLV_SET_HDR(&cmd->tlv_header, 8682 WMITLV_TAG_STRUC_wmi_obss_spatial_reuse_set_cmd_fixed_param, 8683 WMITLV_GET_STRUCT_TLVLEN 8684 (wmi_obss_spatial_reuse_set_cmd_fixed_param)); 8685 8686 cmd->enable = obss_spatial_reuse_param->enable; 8687 cmd->obss_min = obss_spatial_reuse_param->obss_min; 8688 cmd->obss_max = obss_spatial_reuse_param->obss_max; 8689 cmd->vdev_id = obss_spatial_reuse_param->vdev_id; 8690 8691 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 8692 WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID); 8693 8694 if (QDF_IS_STATUS_ERROR(ret)) { 8695 WMI_LOGE( 8696 "WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID send returned Error %d", 8697 ret); 8698 wmi_buf_free(buf); 8699 } 8700 8701 return ret; 8702 } 8703 8704 /** 8705 * send_self_srg_bss_color_bitmap_set_cmd_tlv() - Send 64-bit BSS color bitmap 8706 * to be used by SRG based Spatial Reuse feature to the FW 8707 * @wmi_handle: wmi handle 8708 * @bitmap_0: lower 32 bits in BSS color bitmap 8709 * @bitmap_1: upper 32 bits in BSS color bitmap 8710 * @pdev_id: pdev ID 8711 * 8712 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8713 */ 8714 static QDF_STATUS 8715 send_self_srg_bss_color_bitmap_set_cmd_tlv( 8716 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8717 uint32_t bitmap_1, uint8_t pdev_id) 8718 { 8719 wmi_buf_t buf; 8720 wmi_pdev_srg_bss_color_bitmap_cmd_fixed_param *cmd; 8721 QDF_STATUS ret; 8722 uint32_t len; 8723 8724 len = sizeof(*cmd); 8725 8726 buf = wmi_buf_alloc(wmi_handle, len); 8727 if (!buf) 8728 return QDF_STATUS_E_FAILURE; 8729 8730 cmd = (wmi_pdev_srg_bss_color_bitmap_cmd_fixed_param *) 8731 wmi_buf_data(buf); 8732 8733 WMITLV_SET_HDR( 8734 &cmd->tlv_header, 8735 WMITLV_TAG_STRUC_wmi_pdev_srg_bss_color_bitmap_cmd_fixed_param, 8736 WMITLV_GET_STRUCT_TLVLEN 8737 (wmi_pdev_srg_bss_color_bitmap_cmd_fixed_param)); 8738 8739 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8740 wmi_handle, pdev_id); 8741 cmd->srg_bss_color_bitmap[0] = bitmap_0; 8742 cmd->srg_bss_color_bitmap[1] = bitmap_1; 8743 8744 ret = wmi_unified_cmd_send( 8745 wmi_handle, buf, len, 8746 WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID); 8747 8748 if (QDF_IS_STATUS_ERROR(ret)) { 8749 WMI_LOGE( 8750 "WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID send returned Error %d", 8751 ret); 8752 wmi_buf_free(buf); 8753 } 8754 8755 return ret; 8756 } 8757 8758 /** 8759 * send_self_srg_partial_bssid_bitmap_set_cmd_tlv() - Send 64-bit partial BSSID 8760 * bitmap to be used by SRG based Spatial Reuse feature to the FW 8761 * @wmi_handle: wmi handle 8762 * @bitmap_0: lower 32 bits in partial BSSID bitmap 8763 * @bitmap_1: upper 32 bits in partial BSSID bitmap 8764 * @pdev_id: pdev ID 8765 * 8766 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8767 */ 8768 static QDF_STATUS 8769 send_self_srg_partial_bssid_bitmap_set_cmd_tlv( 8770 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8771 uint32_t bitmap_1, uint8_t pdev_id) 8772 { 8773 wmi_buf_t buf; 8774 wmi_pdev_srg_partial_bssid_bitmap_cmd_fixed_param *cmd; 8775 QDF_STATUS ret; 8776 uint32_t len; 8777 8778 len = sizeof(*cmd); 8779 8780 buf = wmi_buf_alloc(wmi_handle, len); 8781 if (!buf) 8782 return QDF_STATUS_E_FAILURE; 8783 8784 cmd = (wmi_pdev_srg_partial_bssid_bitmap_cmd_fixed_param *) 8785 wmi_buf_data(buf); 8786 8787 WMITLV_SET_HDR( 8788 &cmd->tlv_header, 8789 WMITLV_TAG_STRUC_wmi_pdev_srg_partial_bssid_bitmap_cmd_fixed_param, 8790 WMITLV_GET_STRUCT_TLVLEN 8791 (wmi_pdev_srg_partial_bssid_bitmap_cmd_fixed_param)); 8792 8793 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8794 wmi_handle, pdev_id); 8795 8796 cmd->srg_partial_bssid_bitmap[0] = bitmap_0; 8797 cmd->srg_partial_bssid_bitmap[1] = bitmap_1; 8798 8799 ret = wmi_unified_cmd_send( 8800 wmi_handle, buf, len, 8801 WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID); 8802 8803 if (QDF_IS_STATUS_ERROR(ret)) { 8804 WMI_LOGE( 8805 "WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID send returned Error %d", 8806 ret); 8807 wmi_buf_free(buf); 8808 } 8809 8810 return ret; 8811 } 8812 8813 /** 8814 * send_self_srg_obss_color_enable_bitmap_cmd_tlv() - Send 64-bit BSS color 8815 * enable bitmap to be used by SRG based Spatial Reuse feature to the FW 8816 * @wmi_handle: wmi handle 8817 * @bitmap_0: lower 32 bits in BSS color enable bitmap 8818 * @bitmap_1: upper 32 bits in BSS color enable bitmap 8819 * @pdev_id: pdev ID 8820 * 8821 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8822 */ 8823 static QDF_STATUS 8824 send_self_srg_obss_color_enable_bitmap_cmd_tlv( 8825 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8826 uint32_t bitmap_1, uint8_t pdev_id) 8827 { 8828 wmi_buf_t buf; 8829 wmi_pdev_srg_obss_color_enable_bitmap_cmd_fixed_param *cmd; 8830 QDF_STATUS ret; 8831 uint32_t len; 8832 8833 len = sizeof(*cmd); 8834 8835 buf = wmi_buf_alloc(wmi_handle, len); 8836 if (!buf) 8837 return QDF_STATUS_E_FAILURE; 8838 8839 cmd = (wmi_pdev_srg_obss_color_enable_bitmap_cmd_fixed_param *) 8840 wmi_buf_data(buf); 8841 8842 WMITLV_SET_HDR( 8843 &cmd->tlv_header, 8844 WMITLV_TAG_STRUC_wmi_pdev_srg_obss_color_enable_bitmap_cmd_fixed_param, 8845 WMITLV_GET_STRUCT_TLVLEN 8846 (wmi_pdev_srg_obss_color_enable_bitmap_cmd_fixed_param)); 8847 8848 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8849 wmi_handle, pdev_id); 8850 cmd->srg_obss_en_color_bitmap[0] = bitmap_0; 8851 cmd->srg_obss_en_color_bitmap[1] = bitmap_1; 8852 8853 ret = wmi_unified_cmd_send( 8854 wmi_handle, buf, len, 8855 WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID); 8856 8857 if (QDF_IS_STATUS_ERROR(ret)) { 8858 WMI_LOGE( 8859 "WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID send returned Error %d", 8860 ret); 8861 wmi_buf_free(buf); 8862 } 8863 8864 return ret; 8865 } 8866 8867 /** 8868 * send_self_srg_obss_bssid_enable_bitmap_cmd_tlv() - Send 64-bit OBSS BSSID 8869 * enable bitmap to be used by SRG based Spatial Reuse feature to the FW 8870 * @wmi_handle: wmi handle 8871 * @bitmap_0: lower 32 bits in BSSID enable bitmap 8872 * @bitmap_1: upper 32 bits in BSSID enable bitmap 8873 * @pdev_id: pdev ID 8874 * 8875 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8876 */ 8877 static QDF_STATUS 8878 send_self_srg_obss_bssid_enable_bitmap_cmd_tlv( 8879 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8880 uint32_t bitmap_1, uint8_t pdev_id) 8881 { 8882 wmi_buf_t buf; 8883 wmi_pdev_srg_obss_bssid_enable_bitmap_cmd_fixed_param *cmd; 8884 QDF_STATUS ret; 8885 uint32_t len; 8886 8887 len = sizeof(*cmd); 8888 8889 buf = wmi_buf_alloc(wmi_handle, len); 8890 if (!buf) 8891 return QDF_STATUS_E_FAILURE; 8892 8893 cmd = (wmi_pdev_srg_obss_bssid_enable_bitmap_cmd_fixed_param *) 8894 wmi_buf_data(buf); 8895 8896 WMITLV_SET_HDR( 8897 &cmd->tlv_header, 8898 WMITLV_TAG_STRUC_wmi_pdev_srg_obss_bssid_enable_bitmap_cmd_fixed_param, 8899 WMITLV_GET_STRUCT_TLVLEN 8900 (wmi_pdev_srg_obss_bssid_enable_bitmap_cmd_fixed_param)); 8901 8902 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8903 wmi_handle, pdev_id); 8904 cmd->srg_obss_en_bssid_bitmap[0] = bitmap_0; 8905 cmd->srg_obss_en_bssid_bitmap[1] = bitmap_1; 8906 8907 ret = wmi_unified_cmd_send( 8908 wmi_handle, buf, len, 8909 WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID); 8910 8911 if (QDF_IS_STATUS_ERROR(ret)) { 8912 WMI_LOGE( 8913 "WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID send returned Error %d", 8914 ret); 8915 wmi_buf_free(buf); 8916 } 8917 8918 return ret; 8919 } 8920 8921 /** 8922 * send_self_non_srg_obss_color_enable_bitmap_cmd_tlv() - Send 64-bit BSS color 8923 * enable bitmap to be used by Non-SRG based Spatial Reuse feature to the FW 8924 * @wmi_handle: wmi handle 8925 * @bitmap_0: lower 32 bits in BSS color enable bitmap 8926 * @bitmap_1: upper 32 bits in BSS color enable bitmap 8927 * @pdev_id: pdev ID 8928 * 8929 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8930 */ 8931 static QDF_STATUS 8932 send_self_non_srg_obss_color_enable_bitmap_cmd_tlv( 8933 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8934 uint32_t bitmap_1, uint8_t pdev_id) 8935 { 8936 wmi_buf_t buf; 8937 wmi_pdev_non_srg_obss_color_enable_bitmap_cmd_fixed_param *cmd; 8938 QDF_STATUS ret; 8939 uint32_t len; 8940 8941 len = sizeof(*cmd); 8942 8943 buf = wmi_buf_alloc(wmi_handle, len); 8944 if (!buf) 8945 return QDF_STATUS_E_FAILURE; 8946 8947 cmd = (wmi_pdev_non_srg_obss_color_enable_bitmap_cmd_fixed_param *) 8948 wmi_buf_data(buf); 8949 8950 WMITLV_SET_HDR( 8951 &cmd->tlv_header, 8952 WMITLV_TAG_STRUC_wmi_pdev_non_srg_obss_color_enable_bitmap_cmd_fixed_param, 8953 WMITLV_GET_STRUCT_TLVLEN 8954 (wmi_pdev_non_srg_obss_color_enable_bitmap_cmd_fixed_param)); 8955 8956 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 8957 wmi_handle, pdev_id); 8958 cmd->non_srg_obss_en_color_bitmap[0] = bitmap_0; 8959 cmd->non_srg_obss_en_color_bitmap[1] = bitmap_1; 8960 8961 ret = wmi_unified_cmd_send( 8962 wmi_handle, buf, len, 8963 WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID); 8964 8965 if (QDF_IS_STATUS_ERROR(ret)) { 8966 WMI_LOGE( 8967 "WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID send returned Error %d", 8968 ret); 8969 wmi_buf_free(buf); 8970 } 8971 8972 return ret; 8973 } 8974 8975 /** 8976 * send_self_non_srg_obss_bssid_enable_bitmap_cmd_tlv() - Send 64-bit OBSS BSSID 8977 * enable bitmap to be used by Non-SRG based Spatial Reuse feature to the FW 8978 * @wmi_handle: wmi handle 8979 * @bitmap_0: lower 32 bits in BSSID enable bitmap 8980 * @bitmap_1: upper 32 bits in BSSID enable bitmap 8981 * @pdev_id: pdev ID 8982 * 8983 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 8984 */ 8985 static QDF_STATUS 8986 send_self_non_srg_obss_bssid_enable_bitmap_cmd_tlv( 8987 wmi_unified_t wmi_handle, uint32_t bitmap_0, 8988 uint32_t bitmap_1, uint8_t pdev_id) 8989 { 8990 wmi_buf_t buf; 8991 wmi_pdev_non_srg_obss_bssid_enable_bitmap_cmd_fixed_param *cmd; 8992 QDF_STATUS ret; 8993 uint32_t len; 8994 8995 len = sizeof(*cmd); 8996 8997 buf = wmi_buf_alloc(wmi_handle, len); 8998 if (!buf) 8999 return QDF_STATUS_E_FAILURE; 9000 9001 cmd = (wmi_pdev_non_srg_obss_bssid_enable_bitmap_cmd_fixed_param *) 9002 wmi_buf_data(buf); 9003 9004 WMITLV_SET_HDR( 9005 &cmd->tlv_header, 9006 WMITLV_TAG_STRUC_wmi_pdev_non_srg_obss_bssid_enable_bitmap_cmd_fixed_param, 9007 WMITLV_GET_STRUCT_TLVLEN 9008 (wmi_pdev_non_srg_obss_bssid_enable_bitmap_cmd_fixed_param)); 9009 9010 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 9011 wmi_handle, pdev_id); 9012 cmd->non_srg_obss_en_bssid_bitmap[0] = bitmap_0; 9013 cmd->non_srg_obss_en_bssid_bitmap[1] = bitmap_1; 9014 9015 ret = wmi_unified_cmd_send( 9016 wmi_handle, buf, len, 9017 WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID); 9018 9019 if (QDF_IS_STATUS_ERROR(ret)) { 9020 WMI_LOGE( 9021 "WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID send returned Error %d", 9022 ret); 9023 wmi_buf_free(buf); 9024 } 9025 9026 return ret; 9027 } 9028 #endif 9029 9030 static 9031 QDF_STATUS send_injector_config_cmd_tlv(wmi_unified_t wmi_handle, 9032 struct wmi_host_injector_frame_params *inject_config_params) 9033 { 9034 wmi_buf_t buf; 9035 wmi_frame_inject_cmd_fixed_param *cmd; 9036 QDF_STATUS ret; 9037 uint32_t len; 9038 9039 len = sizeof(*cmd); 9040 9041 buf = wmi_buf_alloc(wmi_handle, len); 9042 if (!buf) 9043 return QDF_STATUS_E_NOMEM; 9044 9045 cmd = (wmi_frame_inject_cmd_fixed_param *)wmi_buf_data(buf); 9046 WMITLV_SET_HDR(&cmd->tlv_header, 9047 WMITLV_TAG_STRUC_wmi_frame_inject_cmd_fixed_param, 9048 WMITLV_GET_STRUCT_TLVLEN 9049 (wmi_frame_inject_cmd_fixed_param)); 9050 9051 cmd->vdev_id = inject_config_params->vdev_id; 9052 cmd->enable = inject_config_params->enable; 9053 cmd->frame_type = inject_config_params->frame_type; 9054 cmd->frame_inject_period = inject_config_params->frame_inject_period; 9055 WMI_CHAR_ARRAY_TO_MAC_ADDR(inject_config_params->dstmac, 9056 &cmd->frame_addr1); 9057 9058 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 9059 WMI_PDEV_FRAME_INJECT_CMDID); 9060 9061 if (QDF_IS_STATUS_ERROR(ret)) { 9062 WMI_LOGE( 9063 "WMI_PDEV_FRAME_INJECT_CMDID send returned Error %d", 9064 ret); 9065 wmi_buf_free(buf); 9066 } 9067 9068 return ret; 9069 } 9070 #ifdef QCA_SUPPORT_CP_STATS 9071 /** 9072 * extract_cca_stats_tlv - api to extract congestion stats from event buffer 9073 * @wmi_handle: wma handle 9074 * @evt_buf: event buffer 9075 * @out_buff: buffer to populated after stats extraction 9076 * 9077 * Return: status of operation 9078 */ 9079 static QDF_STATUS extract_cca_stats_tlv(wmi_unified_t wmi_handle, 9080 void *evt_buf, struct wmi_host_congestion_stats *out_buff) 9081 { 9082 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 9083 wmi_congestion_stats *congestion_stats; 9084 9085 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf; 9086 congestion_stats = param_buf->congestion_stats; 9087 if (!congestion_stats) 9088 return QDF_STATUS_E_INVAL; 9089 9090 out_buff->vdev_id = congestion_stats->vdev_id; 9091 out_buff->congestion = congestion_stats->congestion; 9092 9093 WMI_LOGD("%s: cca stats event processed", __func__); 9094 return QDF_STATUS_SUCCESS; 9095 } 9096 #endif /* QCA_SUPPORT_CP_STATS */ 9097 9098 /** 9099 * extract_ctl_failsafe_check_ev_param_tlv() - extract ctl data from 9100 * event 9101 * @wmi_handle: wmi handle 9102 * @param evt_buf: pointer to event buffer 9103 * @param param: Pointer to hold peer ctl data 9104 * 9105 * Return: QDF_STATUS_SUCCESS for success or error code 9106 */ 9107 static QDF_STATUS extract_ctl_failsafe_check_ev_param_tlv( 9108 wmi_unified_t wmi_handle, 9109 void *evt_buf, 9110 struct wmi_host_pdev_ctl_failsafe_event *param) 9111 { 9112 WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID_param_tlvs *param_buf; 9113 wmi_pdev_ctl_failsafe_check_fixed_param *fix_param; 9114 9115 param_buf = (WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID_param_tlvs *)evt_buf; 9116 if (!param_buf) { 9117 WMI_LOGE("Invalid ctl_failsafe event buffer"); 9118 return QDF_STATUS_E_INVAL; 9119 } 9120 9121 fix_param = param_buf->fixed_param; 9122 param->ctl_failsafe_status = fix_param->ctl_FailsafeStatus; 9123 9124 return QDF_STATUS_SUCCESS; 9125 } 9126 9127 /** 9128 * save_service_bitmap_tlv() - save service bitmap 9129 * @wmi_handle: wmi handle 9130 * @param evt_buf: pointer to event buffer 9131 * @param bitmap_buf: bitmap buffer, for converged legacy support 9132 * 9133 * Return: QDF_STATUS 9134 */ 9135 static 9136 QDF_STATUS save_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf, 9137 void *bitmap_buf) 9138 { 9139 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9140 struct wmi_soc *soc = wmi_handle->soc; 9141 9142 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 9143 9144 /* If it is already allocated, use that buffer. This can happen 9145 * during target stop/start scenarios where host allocation is skipped. 9146 */ 9147 if (!soc->wmi_service_bitmap) { 9148 soc->wmi_service_bitmap = 9149 qdf_mem_malloc(WMI_SERVICE_BM_SIZE * sizeof(uint32_t)); 9150 if (!soc->wmi_service_bitmap) 9151 return QDF_STATUS_E_NOMEM; 9152 } 9153 9154 qdf_mem_copy(soc->wmi_service_bitmap, 9155 param_buf->wmi_service_bitmap, 9156 (WMI_SERVICE_BM_SIZE * sizeof(uint32_t))); 9157 9158 if (bitmap_buf) 9159 qdf_mem_copy(bitmap_buf, 9160 param_buf->wmi_service_bitmap, 9161 (WMI_SERVICE_BM_SIZE * sizeof(uint32_t))); 9162 9163 return QDF_STATUS_SUCCESS; 9164 } 9165 9166 /** 9167 * save_ext_service_bitmap_tlv() - save extendend service bitmap 9168 * @wmi_handle: wmi handle 9169 * @param evt_buf: pointer to event buffer 9170 * @param bitmap_buf: bitmap buffer, for converged legacy support 9171 * 9172 * Return: QDF_STATUS 9173 */ 9174 static 9175 QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf, 9176 void *bitmap_buf) 9177 { 9178 WMI_SERVICE_AVAILABLE_EVENTID_param_tlvs *param_buf; 9179 wmi_service_available_event_fixed_param *ev; 9180 struct wmi_soc *soc = wmi_handle->soc; 9181 9182 param_buf = (WMI_SERVICE_AVAILABLE_EVENTID_param_tlvs *) evt_buf; 9183 9184 ev = param_buf->fixed_param; 9185 9186 /* If it is already allocated, use that buffer. This can happen 9187 * during target stop/start scenarios where host allocation is skipped. 9188 */ 9189 if (!soc->wmi_ext_service_bitmap) { 9190 soc->wmi_ext_service_bitmap = qdf_mem_malloc( 9191 WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t)); 9192 if (!soc->wmi_ext_service_bitmap) 9193 return QDF_STATUS_E_NOMEM; 9194 } 9195 9196 qdf_mem_copy(soc->wmi_ext_service_bitmap, 9197 ev->wmi_service_segment_bitmap, 9198 (WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t))); 9199 9200 WMI_LOGD("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x", 9201 soc->wmi_ext_service_bitmap[0], soc->wmi_ext_service_bitmap[1], 9202 soc->wmi_ext_service_bitmap[2], soc->wmi_ext_service_bitmap[3]); 9203 9204 if (bitmap_buf) 9205 qdf_mem_copy(bitmap_buf, 9206 soc->wmi_ext_service_bitmap, 9207 (WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t))); 9208 9209 return QDF_STATUS_SUCCESS; 9210 } 9211 9212 static inline void copy_ht_cap_info(uint32_t ev_target_cap, 9213 struct wlan_psoc_target_capability_info *cap) 9214 { 9215 /* except LDPC all flags are common betwen legacy and here 9216 * also IBFEER is not defined for TLV 9217 */ 9218 cap->ht_cap_info |= ev_target_cap & ( 9219 WMI_HT_CAP_ENABLED 9220 | WMI_HT_CAP_HT20_SGI 9221 | WMI_HT_CAP_DYNAMIC_SMPS 9222 | WMI_HT_CAP_TX_STBC 9223 | WMI_HT_CAP_TX_STBC_MASK_SHIFT 9224 | WMI_HT_CAP_RX_STBC 9225 | WMI_HT_CAP_RX_STBC_MASK_SHIFT 9226 | WMI_HT_CAP_LDPC 9227 | WMI_HT_CAP_L_SIG_TXOP_PROT 9228 | WMI_HT_CAP_MPDU_DENSITY 9229 | WMI_HT_CAP_MPDU_DENSITY_MASK_SHIFT 9230 | WMI_HT_CAP_HT40_SGI); 9231 if (ev_target_cap & WMI_HT_CAP_LDPC) 9232 cap->ht_cap_info |= WMI_HOST_HT_CAP_RX_LDPC | 9233 WMI_HOST_HT_CAP_TX_LDPC; 9234 } 9235 /** 9236 * extract_service_ready_tlv() - extract service ready event 9237 * @wmi_handle: wmi handle 9238 * @param evt_buf: pointer to received event buffer 9239 * @param cap: pointer to hold target capability information extracted from even 9240 * 9241 * Return: QDF_STATUS_SUCCESS for success or error code 9242 */ 9243 static QDF_STATUS extract_service_ready_tlv(wmi_unified_t wmi_handle, 9244 void *evt_buf, struct wlan_psoc_target_capability_info *cap) 9245 { 9246 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9247 wmi_service_ready_event_fixed_param *ev; 9248 9249 9250 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 9251 9252 ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param; 9253 if (!ev) { 9254 qdf_print("%s: wmi_buf_alloc failed", __func__); 9255 return QDF_STATUS_E_FAILURE; 9256 } 9257 9258 cap->phy_capability = ev->phy_capability; 9259 cap->max_frag_entry = ev->max_frag_entry; 9260 cap->num_rf_chains = ev->num_rf_chains; 9261 copy_ht_cap_info(ev->ht_cap_info, cap); 9262 cap->vht_cap_info = ev->vht_cap_info; 9263 cap->vht_supp_mcs = ev->vht_supp_mcs; 9264 cap->hw_min_tx_power = ev->hw_min_tx_power; 9265 cap->hw_max_tx_power = ev->hw_max_tx_power; 9266 cap->sys_cap_info = ev->sys_cap_info; 9267 cap->min_pkt_size_enable = ev->min_pkt_size_enable; 9268 cap->max_bcn_ie_size = ev->max_bcn_ie_size; 9269 cap->max_num_scan_channels = ev->max_num_scan_channels; 9270 cap->max_supported_macs = ev->max_supported_macs; 9271 cap->wmi_fw_sub_feat_caps = ev->wmi_fw_sub_feat_caps; 9272 cap->txrx_chainmask = ev->txrx_chainmask; 9273 cap->default_dbs_hw_mode_index = ev->default_dbs_hw_mode_index; 9274 cap->num_msdu_desc = ev->num_msdu_desc; 9275 cap->fw_version = ev->fw_build_vers; 9276 /* fw_version_1 is not available in TLV. */ 9277 cap->fw_version_1 = 0; 9278 9279 return QDF_STATUS_SUCCESS; 9280 } 9281 9282 /* convert_wireless_modes_tlv() - Convert REGDMN_MODE values sent by target 9283 * to host internal WMI_HOST_REGDMN_MODE values. 9284 * REGULATORY TODO : REGDMN_MODE_11AC_VHT*_2G values are not used by the 9285 * host currently. Add this in the future if required. 9286 * 11AX (Phase II) : 11ax related values are not currently 9287 * advertised separately by FW. As part of phase II regulatory bring-up, 9288 * finalize the advertisement mechanism. 9289 * @target_wireless_mode: target wireless mode received in message 9290 * 9291 * Return: returns the host internal wireless mode. 9292 */ 9293 static inline uint32_t convert_wireless_modes_tlv(uint32_t target_wireless_mode) 9294 { 9295 9296 uint32_t wireless_modes = 0; 9297 9298 WMI_LOGD("Target wireless mode: 0x%x", target_wireless_mode); 9299 9300 if (target_wireless_mode & REGDMN_MODE_11A) 9301 wireless_modes |= WMI_HOST_REGDMN_MODE_11A; 9302 9303 if (target_wireless_mode & REGDMN_MODE_TURBO) 9304 wireless_modes |= WMI_HOST_REGDMN_MODE_TURBO; 9305 9306 if (target_wireless_mode & REGDMN_MODE_11B) 9307 wireless_modes |= WMI_HOST_REGDMN_MODE_11B; 9308 9309 if (target_wireless_mode & REGDMN_MODE_PUREG) 9310 wireless_modes |= WMI_HOST_REGDMN_MODE_PUREG; 9311 9312 if (target_wireless_mode & REGDMN_MODE_11G) 9313 wireless_modes |= WMI_HOST_REGDMN_MODE_11G; 9314 9315 if (target_wireless_mode & REGDMN_MODE_108G) 9316 wireless_modes |= WMI_HOST_REGDMN_MODE_108G; 9317 9318 if (target_wireless_mode & REGDMN_MODE_108A) 9319 wireless_modes |= WMI_HOST_REGDMN_MODE_108A; 9320 9321 if (target_wireless_mode & REGDMN_MODE_11AC_VHT20_2G) 9322 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT20_2G; 9323 9324 if (target_wireless_mode & REGDMN_MODE_XR) 9325 wireless_modes |= WMI_HOST_REGDMN_MODE_XR; 9326 9327 if (target_wireless_mode & REGDMN_MODE_11A_HALF_RATE) 9328 wireless_modes |= WMI_HOST_REGDMN_MODE_11A_HALF_RATE; 9329 9330 if (target_wireless_mode & REGDMN_MODE_11A_QUARTER_RATE) 9331 wireless_modes |= WMI_HOST_REGDMN_MODE_11A_QUARTER_RATE; 9332 9333 if (target_wireless_mode & REGDMN_MODE_11NG_HT20) 9334 wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT20; 9335 9336 if (target_wireless_mode & REGDMN_MODE_11NA_HT20) 9337 wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT20; 9338 9339 if (target_wireless_mode & REGDMN_MODE_11NG_HT40PLUS) 9340 wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT40PLUS; 9341 9342 if (target_wireless_mode & REGDMN_MODE_11NG_HT40MINUS) 9343 wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT40MINUS; 9344 9345 if (target_wireless_mode & REGDMN_MODE_11NA_HT40PLUS) 9346 wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT40PLUS; 9347 9348 if (target_wireless_mode & REGDMN_MODE_11NA_HT40MINUS) 9349 wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT40MINUS; 9350 9351 if (target_wireless_mode & REGDMN_MODE_11AC_VHT20) 9352 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT20; 9353 9354 if (target_wireless_mode & REGDMN_MODE_11AC_VHT40PLUS) 9355 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT40PLUS; 9356 9357 if (target_wireless_mode & REGDMN_MODE_11AC_VHT40MINUS) 9358 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT40MINUS; 9359 9360 if (target_wireless_mode & REGDMN_MODE_11AC_VHT80) 9361 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT80; 9362 9363 if (target_wireless_mode & REGDMN_MODE_11AC_VHT160) 9364 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT160; 9365 9366 if (target_wireless_mode & REGDMN_MODE_11AC_VHT80_80) 9367 wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT80_80; 9368 9369 return wireless_modes; 9370 } 9371 9372 /* convert_phybitmap_tlv() - Convert WMI_REGULATORY_PHYBITMAP values sent by 9373 * target to host internal REGULATORY_PHYMODE values. 9374 * 9375 * @target_target_phybitmap: target phybitmap received in the message. 9376 * 9377 * Return: returns the host internal REGULATORY_PHYMODE. 9378 */ 9379 static uint32_t convert_phybitmap_tlv(uint32_t target_phybitmap) 9380 { 9381 uint32_t phybitmap = 0; 9382 9383 WMI_LOGD("Target phybitmap: 0x%x", target_phybitmap); 9384 9385 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11A) 9386 phybitmap |= REGULATORY_PHYMODE_NO11A; 9387 9388 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11B) 9389 phybitmap |= REGULATORY_PHYMODE_NO11B; 9390 9391 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11G) 9392 phybitmap |= REGULATORY_PHYMODE_NO11G; 9393 9394 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11N) 9395 phybitmap |= REGULATORY_CHAN_NO11N; 9396 9397 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11AC) 9398 phybitmap |= REGULATORY_PHYMODE_NO11AC; 9399 9400 if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11AX) 9401 phybitmap |= REGULATORY_PHYMODE_NO11AX; 9402 9403 return phybitmap; 9404 } 9405 9406 /** 9407 * extract_hal_reg_cap_tlv() - extract HAL registered capabilities 9408 * @wmi_handle: wmi handle 9409 * @param evt_buf: Pointer to event buffer 9410 * @param cap: pointer to hold HAL reg capabilities 9411 * 9412 * Return: QDF_STATUS_SUCCESS for success or error code 9413 */ 9414 static QDF_STATUS extract_hal_reg_cap_tlv(wmi_unified_t wmi_handle, 9415 void *evt_buf, struct wlan_psoc_hal_reg_capability *cap) 9416 { 9417 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9418 9419 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 9420 if (!param_buf || !param_buf->hal_reg_capabilities) { 9421 WMI_LOGE("%s: Invalid arguments", __func__); 9422 return QDF_STATUS_E_FAILURE; 9423 } 9424 qdf_mem_copy(cap, (((uint8_t *)param_buf->hal_reg_capabilities) + 9425 sizeof(uint32_t)), 9426 sizeof(struct wlan_psoc_hal_reg_capability)); 9427 9428 cap->wireless_modes = convert_wireless_modes_tlv( 9429 param_buf->hal_reg_capabilities->wireless_modes); 9430 9431 return QDF_STATUS_SUCCESS; 9432 } 9433 9434 /** 9435 * extract_num_mem_reqs_tlv() - Extract number of memory entries requested 9436 * @wmi_handle: wmi handle 9437 * @evt_buf: pointer to event buffer 9438 * 9439 * Return: Number of entries requested 9440 */ 9441 static uint32_t extract_num_mem_reqs_tlv(wmi_unified_t wmi_handle, 9442 void *evt_buf) 9443 { 9444 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9445 wmi_service_ready_event_fixed_param *ev; 9446 9447 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 9448 9449 ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param; 9450 if (!ev) { 9451 qdf_print("%s: wmi_buf_alloc failed", __func__); 9452 return 0; 9453 } 9454 9455 if (ev->num_mem_reqs > param_buf->num_mem_reqs) { 9456 WMI_LOGE("Invalid num_mem_reqs %d:%d", 9457 ev->num_mem_reqs, param_buf->num_mem_reqs); 9458 return 0; 9459 } 9460 9461 return ev->num_mem_reqs; 9462 } 9463 9464 /** 9465 * extract_host_mem_req_tlv() - Extract host memory required from 9466 * service ready event 9467 * @wmi_handle: wmi handle 9468 * @evt_buf: pointer to event buffer 9469 * @mem_reqs: pointer to host memory request structure 9470 * @num_active_peers: number of active peers for peer cache 9471 * @num_peers: number of peers 9472 * @fw_prio: FW priority 9473 * @idx: index for memory request 9474 * 9475 * Return: Host memory request parameters requested by target 9476 */ 9477 static QDF_STATUS extract_host_mem_req_tlv(wmi_unified_t wmi_handle, 9478 void *evt_buf, 9479 host_mem_req *mem_reqs, 9480 uint32_t num_active_peers, 9481 uint32_t num_peers, 9482 enum wmi_fw_mem_prio fw_prio, 9483 uint16_t idx) 9484 { 9485 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9486 9487 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *)evt_buf; 9488 9489 mem_reqs->req_id = (uint32_t)param_buf->mem_reqs[idx].req_id; 9490 mem_reqs->unit_size = (uint32_t)param_buf->mem_reqs[idx].unit_size; 9491 mem_reqs->num_unit_info = 9492 (uint32_t)param_buf->mem_reqs[idx].num_unit_info; 9493 mem_reqs->num_units = (uint32_t)param_buf->mem_reqs[idx].num_units; 9494 mem_reqs->tgt_num_units = 0; 9495 9496 if (((fw_prio == WMI_FW_MEM_HIGH_PRIORITY) && 9497 (mem_reqs->num_unit_info & 9498 REQ_TO_HOST_FOR_CONT_MEMORY)) || 9499 ((fw_prio == WMI_FW_MEM_LOW_PRIORITY) && 9500 (!(mem_reqs->num_unit_info & 9501 REQ_TO_HOST_FOR_CONT_MEMORY)))) { 9502 /* First allocate the memory that requires contiguous memory */ 9503 mem_reqs->tgt_num_units = mem_reqs->num_units; 9504 if (mem_reqs->num_unit_info) { 9505 if (mem_reqs->num_unit_info & 9506 NUM_UNITS_IS_NUM_PEERS) { 9507 /* 9508 * number of units allocated is equal to number 9509 * of peers, 1 extra for self peer on target. 9510 * this needs to be fixed, host and target can 9511 * get out of sync 9512 */ 9513 mem_reqs->tgt_num_units = num_peers + 1; 9514 } 9515 if (mem_reqs->num_unit_info & 9516 NUM_UNITS_IS_NUM_ACTIVE_PEERS) { 9517 /* 9518 * Requesting allocation of memory using 9519 * num_active_peers in qcache. if qcache is 9520 * disabled in host, then it should allocate 9521 * memory for num_peers instead of 9522 * num_active_peers. 9523 */ 9524 if (num_active_peers) 9525 mem_reqs->tgt_num_units = 9526 num_active_peers + 1; 9527 else 9528 mem_reqs->tgt_num_units = 9529 num_peers + 1; 9530 } 9531 } 9532 9533 WMI_LOGI("idx %d req %d num_units %d num_unit_info %d" 9534 "unit size %d actual units %d", 9535 idx, mem_reqs->req_id, 9536 mem_reqs->num_units, 9537 mem_reqs->num_unit_info, 9538 mem_reqs->unit_size, 9539 mem_reqs->tgt_num_units); 9540 } 9541 9542 return QDF_STATUS_SUCCESS; 9543 } 9544 9545 /** 9546 * save_fw_version_in_service_ready_tlv() - Save fw version in service 9547 * ready function 9548 * @wmi_handle: wmi handle 9549 * @param evt_buf: pointer to event buffer 9550 * 9551 * Return: QDF_STATUS_SUCCESS for success or error code 9552 */ 9553 static QDF_STATUS 9554 save_fw_version_in_service_ready_tlv(wmi_unified_t wmi_handle, void *evt_buf) 9555 { 9556 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; 9557 wmi_service_ready_event_fixed_param *ev; 9558 9559 9560 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf; 9561 9562 ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param; 9563 if (!ev) { 9564 qdf_print("%s: wmi_buf_alloc failed", __func__); 9565 return QDF_STATUS_E_FAILURE; 9566 } 9567 9568 /*Save fw version from service ready message */ 9569 /*This will be used while sending INIT message */ 9570 qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, 9571 sizeof(wmi_handle->fw_abi_version)); 9572 9573 return QDF_STATUS_SUCCESS; 9574 } 9575 9576 /** 9577 * ready_extract_init_status_tlv() - Extract init status from ready event 9578 * @wmi_handle: wmi handle 9579 * @param evt_buf: Pointer to event buffer 9580 * 9581 * Return: ready status 9582 */ 9583 static uint32_t ready_extract_init_status_tlv(wmi_unified_t wmi_handle, 9584 void *evt_buf) 9585 { 9586 WMI_READY_EVENTID_param_tlvs *param_buf = NULL; 9587 wmi_ready_event_fixed_param *ev = NULL; 9588 9589 param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; 9590 ev = param_buf->fixed_param; 9591 9592 qdf_print("%s:%d", __func__, ev->status); 9593 9594 return ev->status; 9595 } 9596 9597 /** 9598 * ready_extract_mac_addr_tlv() - extract mac address from ready event 9599 * @wmi_handle: wmi handle 9600 * @param evt_buf: pointer to event buffer 9601 * @param macaddr: Pointer to hold MAC address 9602 * 9603 * Return: QDF_STATUS_SUCCESS for success or error code 9604 */ 9605 static QDF_STATUS ready_extract_mac_addr_tlv(wmi_unified_t wmi_hamdle, 9606 void *evt_buf, uint8_t *macaddr) 9607 { 9608 WMI_READY_EVENTID_param_tlvs *param_buf = NULL; 9609 wmi_ready_event_fixed_param *ev = NULL; 9610 9611 9612 param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; 9613 ev = param_buf->fixed_param; 9614 9615 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->mac_addr, macaddr); 9616 9617 return QDF_STATUS_SUCCESS; 9618 } 9619 9620 /** 9621 * ready_extract_mac_addr_list_tlv() - extract MAC address list from ready event 9622 * @wmi_handle: wmi handle 9623 * @param evt_buf: pointer to event buffer 9624 * @param macaddr: Pointer to hold number of MAC addresses 9625 * 9626 * Return: Pointer to addr list 9627 */ 9628 static wmi_host_mac_addr *ready_extract_mac_addr_list_tlv(wmi_unified_t wmi_hamdle, 9629 void *evt_buf, uint8_t *num_mac) 9630 { 9631 WMI_READY_EVENTID_param_tlvs *param_buf = NULL; 9632 wmi_ready_event_fixed_param *ev = NULL; 9633 9634 param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; 9635 ev = param_buf->fixed_param; 9636 9637 *num_mac = ev->num_extra_mac_addr; 9638 9639 return (wmi_host_mac_addr *) param_buf->mac_addr_list; 9640 } 9641 9642 /** 9643 * extract_ready_params_tlv() - Extract data from ready event apart from 9644 * status, macaddr and version. 9645 * @wmi_handle: Pointer to WMI handle. 9646 * @evt_buf: Pointer to Ready event buffer. 9647 * @ev_param: Pointer to host defined struct to copy the data from event. 9648 * 9649 * Return: QDF_STATUS_SUCCESS on success. 9650 */ 9651 static QDF_STATUS extract_ready_event_params_tlv(wmi_unified_t wmi_handle, 9652 void *evt_buf, struct wmi_host_ready_ev_param *ev_param) 9653 { 9654 WMI_READY_EVENTID_param_tlvs *param_buf = NULL; 9655 wmi_ready_event_fixed_param *ev = NULL; 9656 9657 param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; 9658 ev = param_buf->fixed_param; 9659 9660 ev_param->status = ev->status; 9661 ev_param->num_dscp_table = ev->num_dscp_table; 9662 ev_param->num_extra_mac_addr = ev->num_extra_mac_addr; 9663 ev_param->num_total_peer = ev->num_total_peers; 9664 ev_param->num_extra_peer = ev->num_extra_peers; 9665 /* Agile_capability in ready event is supported in TLV target, 9666 * as per aDFS FR 9667 */ 9668 ev_param->max_ast_index = ev->max_ast_index; 9669 ev_param->pktlog_defs_checksum = ev->pktlog_defs_checksum; 9670 ev_param->agile_capability = 1; 9671 9672 return QDF_STATUS_SUCCESS; 9673 } 9674 9675 /** 9676 * extract_dbglog_data_len_tlv() - extract debuglog data length 9677 * @wmi_handle: wmi handle 9678 * @param evt_buf: pointer to event buffer 9679 * 9680 * Return: length 9681 */ 9682 static uint8_t *extract_dbglog_data_len_tlv(wmi_unified_t wmi_handle, 9683 void *evt_buf, uint32_t *len) 9684 { 9685 WMI_DEBUG_MESG_EVENTID_param_tlvs *param_buf; 9686 9687 param_buf = (WMI_DEBUG_MESG_EVENTID_param_tlvs *) evt_buf; 9688 9689 *len = param_buf->num_bufp; 9690 9691 return param_buf->bufp; 9692 } 9693 9694 9695 #ifdef MGMT_FRAME_RX_DECRYPT_ERROR 9696 #define IS_WMI_RX_MGMT_FRAME_STATUS_INVALID(_status) false 9697 #else 9698 #define IS_WMI_RX_MGMT_FRAME_STATUS_INVALID(_status) \ 9699 ((_status) & WMI_RXERR_DECRYPT) 9700 #endif 9701 9702 /** 9703 * extract_mgmt_rx_params_tlv() - extract management rx params from event 9704 * @wmi_handle: wmi handle 9705 * @param evt_buf: pointer to event buffer 9706 * @param hdr: Pointer to hold header 9707 * @param bufp: Pointer to hold pointer to rx param buffer 9708 * 9709 * Return: QDF_STATUS_SUCCESS for success or error code 9710 */ 9711 static QDF_STATUS extract_mgmt_rx_params_tlv(wmi_unified_t wmi_handle, 9712 void *evt_buf, struct mgmt_rx_event_params *hdr, 9713 uint8_t **bufp) 9714 { 9715 WMI_MGMT_RX_EVENTID_param_tlvs *param_tlvs = NULL; 9716 wmi_mgmt_rx_hdr *ev_hdr = NULL; 9717 int i; 9718 9719 param_tlvs = (WMI_MGMT_RX_EVENTID_param_tlvs *) evt_buf; 9720 if (!param_tlvs) { 9721 WMI_LOGE("Get NULL point message from FW"); 9722 return QDF_STATUS_E_INVAL; 9723 } 9724 9725 ev_hdr = param_tlvs->hdr; 9726 if (!hdr) { 9727 WMI_LOGE("Rx event is NULL"); 9728 return QDF_STATUS_E_INVAL; 9729 } 9730 9731 if (IS_WMI_RX_MGMT_FRAME_STATUS_INVALID(ev_hdr->status)) { 9732 WMI_LOGE("%s: RX mgmt frame decrypt error, discard it", 9733 __func__); 9734 return QDF_STATUS_E_INVAL; 9735 } 9736 9737 hdr->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 9738 wmi_handle, 9739 ev_hdr->pdev_id); 9740 hdr->chan_freq = ev_hdr->chan_freq; 9741 hdr->channel = ev_hdr->channel; 9742 hdr->snr = ev_hdr->snr; 9743 hdr->rate = ev_hdr->rate; 9744 hdr->phy_mode = ev_hdr->phy_mode; 9745 hdr->buf_len = ev_hdr->buf_len; 9746 hdr->status = ev_hdr->status; 9747 hdr->flags = ev_hdr->flags; 9748 hdr->rssi = ev_hdr->rssi; 9749 hdr->tsf_delta = ev_hdr->tsf_delta; 9750 for (i = 0; i < ATH_MAX_ANTENNA; i++) 9751 hdr->rssi_ctl[i] = ev_hdr->rssi_ctl[i]; 9752 9753 *bufp = param_tlvs->bufp; 9754 9755 return QDF_STATUS_SUCCESS; 9756 } 9757 9758 /** 9759 * extract_vdev_roam_param_tlv() - extract vdev roam param from event 9760 * @wmi_handle: wmi handle 9761 * @param evt_buf: pointer to event buffer 9762 * @param param: Pointer to hold roam param 9763 * 9764 * Return: QDF_STATUS_SUCCESS for success or error code 9765 */ 9766 static QDF_STATUS extract_vdev_roam_param_tlv(wmi_unified_t wmi_handle, 9767 void *evt_buf, wmi_host_roam_event *param) 9768 { 9769 WMI_ROAM_EVENTID_param_tlvs *param_buf; 9770 wmi_roam_event_fixed_param *evt; 9771 9772 param_buf = (WMI_ROAM_EVENTID_param_tlvs *) evt_buf; 9773 if (!param_buf) { 9774 WMI_LOGE("Invalid roam event buffer"); 9775 return QDF_STATUS_E_INVAL; 9776 } 9777 9778 evt = param_buf->fixed_param; 9779 qdf_mem_zero(param, sizeof(*param)); 9780 9781 param->vdev_id = evt->vdev_id; 9782 param->reason = evt->reason; 9783 param->rssi = evt->rssi; 9784 9785 return QDF_STATUS_SUCCESS; 9786 } 9787 9788 /** 9789 * extract_vdev_scan_ev_param_tlv() - extract vdev scan param from event 9790 * @wmi_handle: wmi handle 9791 * @param evt_buf: pointer to event buffer 9792 * @param param: Pointer to hold vdev scan param 9793 * 9794 * Return: QDF_STATUS_SUCCESS for success or error code 9795 */ 9796 static QDF_STATUS extract_vdev_scan_ev_param_tlv(wmi_unified_t wmi_handle, 9797 void *evt_buf, struct scan_event *param) 9798 { 9799 WMI_SCAN_EVENTID_param_tlvs *param_buf = NULL; 9800 wmi_scan_event_fixed_param *evt = NULL; 9801 9802 param_buf = (WMI_SCAN_EVENTID_param_tlvs *) evt_buf; 9803 evt = param_buf->fixed_param; 9804 9805 qdf_mem_zero(param, sizeof(*param)); 9806 9807 switch (evt->event) { 9808 case WMI_SCAN_EVENT_STARTED: 9809 param->type = SCAN_EVENT_TYPE_STARTED; 9810 break; 9811 case WMI_SCAN_EVENT_COMPLETED: 9812 param->type = SCAN_EVENT_TYPE_COMPLETED; 9813 break; 9814 case WMI_SCAN_EVENT_BSS_CHANNEL: 9815 param->type = SCAN_EVENT_TYPE_BSS_CHANNEL; 9816 break; 9817 case WMI_SCAN_EVENT_FOREIGN_CHANNEL: 9818 param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL; 9819 break; 9820 case WMI_SCAN_EVENT_DEQUEUED: 9821 param->type = SCAN_EVENT_TYPE_DEQUEUED; 9822 break; 9823 case WMI_SCAN_EVENT_PREEMPTED: 9824 param->type = SCAN_EVENT_TYPE_PREEMPTED; 9825 break; 9826 case WMI_SCAN_EVENT_START_FAILED: 9827 param->type = SCAN_EVENT_TYPE_START_FAILED; 9828 break; 9829 case WMI_SCAN_EVENT_RESTARTED: 9830 param->type = SCAN_EVENT_TYPE_RESTARTED; 9831 break; 9832 case WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT: 9833 param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT; 9834 break; 9835 case WMI_SCAN_EVENT_MAX: 9836 default: 9837 param->type = SCAN_EVENT_TYPE_MAX; 9838 break; 9839 }; 9840 9841 switch (evt->reason) { 9842 case WMI_SCAN_REASON_NONE: 9843 param->reason = SCAN_REASON_NONE; 9844 break; 9845 case WMI_SCAN_REASON_COMPLETED: 9846 param->reason = SCAN_REASON_COMPLETED; 9847 break; 9848 case WMI_SCAN_REASON_CANCELLED: 9849 param->reason = SCAN_REASON_CANCELLED; 9850 break; 9851 case WMI_SCAN_REASON_PREEMPTED: 9852 param->reason = SCAN_REASON_PREEMPTED; 9853 break; 9854 case WMI_SCAN_REASON_TIMEDOUT: 9855 param->reason = SCAN_REASON_TIMEDOUT; 9856 break; 9857 case WMI_SCAN_REASON_INTERNAL_FAILURE: 9858 param->reason = SCAN_REASON_INTERNAL_FAILURE; 9859 break; 9860 case WMI_SCAN_REASON_SUSPENDED: 9861 param->reason = SCAN_REASON_SUSPENDED; 9862 break; 9863 case WMI_SCAN_REASON_DFS_VIOLATION: 9864 param->reason = SCAN_REASON_DFS_VIOLATION; 9865 break; 9866 case WMI_SCAN_REASON_MAX: 9867 param->reason = SCAN_REASON_MAX; 9868 break; 9869 default: 9870 param->reason = SCAN_REASON_MAX; 9871 break; 9872 }; 9873 9874 param->chan_freq = evt->channel_freq; 9875 param->requester = evt->requestor; 9876 param->scan_id = evt->scan_id; 9877 param->vdev_id = evt->vdev_id; 9878 param->timestamp = evt->tsf_timestamp; 9879 9880 return QDF_STATUS_SUCCESS; 9881 } 9882 9883 #ifdef FEATURE_WLAN_SCAN_PNO 9884 /** 9885 * extract_nlo_match_ev_param_tlv() - extract NLO match param from event 9886 * @wmi_handle: pointer to WMI handle 9887 * @evt_buf: pointer to WMI event buffer 9888 * @param: pointer to scan event param for NLO match 9889 * 9890 * Return: QDF_STATUS_SUCCESS for success or error code 9891 */ 9892 static QDF_STATUS extract_nlo_match_ev_param_tlv(wmi_unified_t wmi_handle, 9893 void *evt_buf, 9894 struct scan_event *param) 9895 { 9896 WMI_NLO_MATCH_EVENTID_param_tlvs *param_buf = evt_buf; 9897 wmi_nlo_event *evt = param_buf->fixed_param; 9898 9899 qdf_mem_zero(param, sizeof(*param)); 9900 9901 param->type = SCAN_EVENT_TYPE_NLO_MATCH; 9902 param->vdev_id = evt->vdev_id; 9903 9904 return QDF_STATUS_SUCCESS; 9905 } 9906 9907 /** 9908 * extract_nlo_complete_ev_param_tlv() - extract NLO complete param from event 9909 * @wmi_handle: pointer to WMI handle 9910 * @evt_buf: pointer to WMI event buffer 9911 * @param: pointer to scan event param for NLO complete 9912 * 9913 * Return: QDF_STATUS_SUCCESS for success or error code 9914 */ 9915 static QDF_STATUS extract_nlo_complete_ev_param_tlv(wmi_unified_t wmi_handle, 9916 void *evt_buf, 9917 struct scan_event *param) 9918 { 9919 WMI_NLO_SCAN_COMPLETE_EVENTID_param_tlvs *param_buf = evt_buf; 9920 wmi_nlo_event *evt = param_buf->fixed_param; 9921 9922 qdf_mem_zero(param, sizeof(*param)); 9923 9924 param->type = SCAN_EVENT_TYPE_NLO_COMPLETE; 9925 param->vdev_id = evt->vdev_id; 9926 9927 return QDF_STATUS_SUCCESS; 9928 } 9929 #endif 9930 9931 /** 9932 * extract_all_stats_counts_tlv() - extract all stats count from event 9933 * @wmi_handle: wmi handle 9934 * @param evt_buf: pointer to event buffer 9935 * @param stats_param: Pointer to hold stats count 9936 * 9937 * Return: QDF_STATUS_SUCCESS for success or error code 9938 */ 9939 static QDF_STATUS extract_all_stats_counts_tlv(wmi_unified_t wmi_handle, 9940 void *evt_buf, wmi_host_stats_event *stats_param) 9941 { 9942 wmi_stats_event_fixed_param *ev; 9943 wmi_per_chain_rssi_stats *rssi_event; 9944 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 9945 uint64_t min_data_len; 9946 9947 qdf_mem_zero(stats_param, sizeof(*stats_param)); 9948 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 9949 ev = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 9950 rssi_event = param_buf->chain_stats; 9951 if (!ev) { 9952 WMI_LOGE("%s: event fixed param NULL", __func__); 9953 return QDF_STATUS_E_FAILURE; 9954 } 9955 9956 if (param_buf->num_data > WMI_SVC_MSG_MAX_SIZE - sizeof(*ev)) { 9957 WMI_LOGE("num_data : %u is invalid", param_buf->num_data); 9958 return QDF_STATUS_E_FAULT; 9959 } 9960 9961 switch (ev->stats_id) { 9962 case WMI_REQUEST_PEER_STAT: 9963 stats_param->stats_id |= WMI_HOST_REQUEST_PEER_STAT; 9964 break; 9965 9966 case WMI_REQUEST_AP_STAT: 9967 stats_param->stats_id |= WMI_HOST_REQUEST_AP_STAT; 9968 break; 9969 9970 case WMI_REQUEST_PDEV_STAT: 9971 stats_param->stats_id |= WMI_HOST_REQUEST_PDEV_STAT; 9972 break; 9973 9974 case WMI_REQUEST_VDEV_STAT: 9975 stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_STAT; 9976 break; 9977 9978 case WMI_REQUEST_BCNFLT_STAT: 9979 stats_param->stats_id |= WMI_HOST_REQUEST_BCNFLT_STAT; 9980 break; 9981 9982 case WMI_REQUEST_VDEV_RATE_STAT: 9983 stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_RATE_STAT; 9984 break; 9985 9986 case WMI_REQUEST_BCN_STAT: 9987 stats_param->stats_id |= WMI_HOST_REQUEST_BCN_STAT; 9988 break; 9989 case WMI_REQUEST_PEER_EXTD_STAT: 9990 stats_param->stats_id |= WMI_REQUEST_PEER_EXTD_STAT; 9991 break; 9992 9993 case WMI_REQUEST_PEER_EXTD2_STAT: 9994 stats_param->stats_id |= WMI_HOST_REQUEST_PEER_ADV_STATS; 9995 break; 9996 9997 default: 9998 stats_param->stats_id = 0; 9999 break; 10000 10001 } 10002 10003 /* ev->num_*_stats may cause uint32_t overflow, so use uint64_t 10004 * to save total length calculated 10005 */ 10006 min_data_len = 10007 (((uint64_t)ev->num_pdev_stats) * sizeof(wmi_pdev_stats)) + 10008 (((uint64_t)ev->num_vdev_stats) * sizeof(wmi_vdev_stats)) + 10009 (((uint64_t)ev->num_peer_stats) * sizeof(wmi_peer_stats)) + 10010 (((uint64_t)ev->num_bcnflt_stats) * 10011 sizeof(wmi_bcnfilter_stats_t)) + 10012 (((uint64_t)ev->num_chan_stats) * sizeof(wmi_chan_stats)) + 10013 (((uint64_t)ev->num_mib_stats) * sizeof(wmi_mib_stats)) + 10014 (((uint64_t)ev->num_bcn_stats) * sizeof(wmi_bcn_stats)) + 10015 (((uint64_t)ev->num_peer_extd_stats) * 10016 sizeof(wmi_peer_extd_stats)) + 10017 (((uint64_t)ev->num_mib_extd_stats) * 10018 sizeof(wmi_mib_extd_stats)); 10019 if (param_buf->num_data != min_data_len) { 10020 WMI_LOGE("data len: %u isn't same as calculated: %llu", 10021 param_buf->num_data, min_data_len); 10022 return QDF_STATUS_E_FAULT; 10023 } 10024 10025 stats_param->last_event = ev->last_event; 10026 stats_param->num_pdev_stats = ev->num_pdev_stats; 10027 stats_param->num_pdev_ext_stats = 0; 10028 stats_param->num_vdev_stats = ev->num_vdev_stats; 10029 stats_param->num_peer_stats = ev->num_peer_stats; 10030 stats_param->num_peer_extd_stats = ev->num_peer_extd_stats; 10031 stats_param->num_bcnflt_stats = ev->num_bcnflt_stats; 10032 stats_param->num_chan_stats = ev->num_chan_stats; 10033 stats_param->num_mib_stats = ev->num_mib_stats; 10034 stats_param->num_mib_extd_stats = ev->num_mib_extd_stats; 10035 stats_param->num_bcn_stats = ev->num_bcn_stats; 10036 stats_param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 10037 wmi_handle, 10038 ev->pdev_id); 10039 10040 /* if chain_stats is not populated */ 10041 if (!param_buf->chain_stats || !param_buf->num_chain_stats) 10042 return QDF_STATUS_SUCCESS; 10043 10044 if (WMITLV_TAG_STRUC_wmi_per_chain_rssi_stats != 10045 WMITLV_GET_TLVTAG(rssi_event->tlv_header)) 10046 return QDF_STATUS_SUCCESS; 10047 10048 if (WMITLV_GET_STRUCT_TLVLEN(wmi_per_chain_rssi_stats) != 10049 WMITLV_GET_TLVLEN(rssi_event->tlv_header)) 10050 return QDF_STATUS_SUCCESS; 10051 10052 if (rssi_event->num_per_chain_rssi_stats >= 10053 WMITLV_GET_TLVLEN(rssi_event->tlv_header)) { 10054 WMI_LOGE("num_per_chain_rssi_stats:%u is out of bounds", 10055 rssi_event->num_per_chain_rssi_stats); 10056 return QDF_STATUS_E_INVAL; 10057 } 10058 stats_param->num_rssi_stats = rssi_event->num_per_chain_rssi_stats; 10059 10060 /* if peer_adv_stats is not populated */ 10061 if (!param_buf->num_peer_extd2_stats) 10062 return QDF_STATUS_SUCCESS; 10063 10064 stats_param->num_peer_adv_stats = param_buf->num_peer_extd2_stats; 10065 10066 return QDF_STATUS_SUCCESS; 10067 } 10068 10069 /** 10070 * extract_pdev_tx_stats() - extract pdev tx stats from event 10071 */ 10072 static void extract_pdev_tx_stats(wmi_host_dbg_tx_stats *tx, 10073 struct wlan_dbg_tx_stats *tx_stats) 10074 { 10075 /* Tx Stats */ 10076 tx->comp_queued = tx_stats->comp_queued; 10077 tx->comp_delivered = tx_stats->comp_delivered; 10078 tx->msdu_enqued = tx_stats->msdu_enqued; 10079 tx->mpdu_enqued = tx_stats->mpdu_enqued; 10080 tx->wmm_drop = tx_stats->wmm_drop; 10081 tx->local_enqued = tx_stats->local_enqued; 10082 tx->local_freed = tx_stats->local_freed; 10083 tx->hw_queued = tx_stats->hw_queued; 10084 tx->hw_reaped = tx_stats->hw_reaped; 10085 tx->underrun = tx_stats->underrun; 10086 tx->tx_abort = tx_stats->tx_abort; 10087 tx->mpdus_requed = tx_stats->mpdus_requed; 10088 tx->data_rc = tx_stats->data_rc; 10089 tx->self_triggers = tx_stats->self_triggers; 10090 tx->sw_retry_failure = tx_stats->sw_retry_failure; 10091 tx->illgl_rate_phy_err = tx_stats->illgl_rate_phy_err; 10092 tx->pdev_cont_xretry = tx_stats->pdev_cont_xretry; 10093 tx->pdev_tx_timeout = tx_stats->pdev_tx_timeout; 10094 tx->pdev_resets = tx_stats->pdev_resets; 10095 tx->stateless_tid_alloc_failure = tx_stats->stateless_tid_alloc_failure; 10096 tx->phy_underrun = tx_stats->phy_underrun; 10097 tx->txop_ovf = tx_stats->txop_ovf; 10098 10099 return; 10100 } 10101 10102 10103 /** 10104 * extract_pdev_rx_stats() - extract pdev rx stats from event 10105 */ 10106 static void extract_pdev_rx_stats(wmi_host_dbg_rx_stats *rx, 10107 struct wlan_dbg_rx_stats *rx_stats) 10108 { 10109 /* Rx Stats */ 10110 rx->mid_ppdu_route_change = rx_stats->mid_ppdu_route_change; 10111 rx->status_rcvd = rx_stats->status_rcvd; 10112 rx->r0_frags = rx_stats->r0_frags; 10113 rx->r1_frags = rx_stats->r1_frags; 10114 rx->r2_frags = rx_stats->r2_frags; 10115 /* Only TLV */ 10116 rx->r3_frags = 0; 10117 rx->htt_msdus = rx_stats->htt_msdus; 10118 rx->htt_mpdus = rx_stats->htt_mpdus; 10119 rx->loc_msdus = rx_stats->loc_msdus; 10120 rx->loc_mpdus = rx_stats->loc_mpdus; 10121 rx->oversize_amsdu = rx_stats->oversize_amsdu; 10122 rx->phy_errs = rx_stats->phy_errs; 10123 rx->phy_err_drop = rx_stats->phy_err_drop; 10124 rx->mpdu_errs = rx_stats->mpdu_errs; 10125 10126 return; 10127 } 10128 10129 /** 10130 * extract_pdev_stats_tlv() - extract pdev stats from event 10131 * @wmi_handle: wmi handle 10132 * @param evt_buf: pointer to event buffer 10133 * @param index: Index into pdev stats 10134 * @param pdev_stats: Pointer to hold pdev stats 10135 * 10136 * Return: QDF_STATUS_SUCCESS for success or error code 10137 */ 10138 static QDF_STATUS extract_pdev_stats_tlv(wmi_unified_t wmi_handle, 10139 void *evt_buf, uint32_t index, wmi_host_pdev_stats *pdev_stats) 10140 { 10141 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10142 wmi_stats_event_fixed_param *ev_param; 10143 uint8_t *data; 10144 10145 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10146 ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 10147 10148 data = param_buf->data; 10149 10150 if (index < ev_param->num_pdev_stats) { 10151 wmi_pdev_stats *ev = (wmi_pdev_stats *) ((data) + 10152 (index * sizeof(wmi_pdev_stats))); 10153 10154 pdev_stats->chan_nf = ev->chan_nf; 10155 pdev_stats->tx_frame_count = ev->tx_frame_count; 10156 pdev_stats->rx_frame_count = ev->rx_frame_count; 10157 pdev_stats->rx_clear_count = ev->rx_clear_count; 10158 pdev_stats->cycle_count = ev->cycle_count; 10159 pdev_stats->phy_err_count = ev->phy_err_count; 10160 pdev_stats->chan_tx_pwr = ev->chan_tx_pwr; 10161 10162 extract_pdev_tx_stats(&(pdev_stats->pdev_stats.tx), 10163 &(ev->pdev_stats.tx)); 10164 extract_pdev_rx_stats(&(pdev_stats->pdev_stats.rx), 10165 &(ev->pdev_stats.rx)); 10166 } 10167 10168 return QDF_STATUS_SUCCESS; 10169 } 10170 10171 /** 10172 * extract_unit_test_tlv() - extract unit test data 10173 * @wmi_handle: wmi handle 10174 * @param evt_buf: pointer to event buffer 10175 * @param unit_test: pointer to hold unit test data 10176 * @param maxspace: Amount of space in evt_buf 10177 * 10178 * Return: QDF_STATUS_SUCCESS for success or error code 10179 */ 10180 static QDF_STATUS extract_unit_test_tlv(wmi_unified_t wmi_handle, 10181 void *evt_buf, wmi_unit_test_event *unit_test, uint32_t maxspace) 10182 { 10183 WMI_UNIT_TEST_EVENTID_param_tlvs *param_buf; 10184 wmi_unit_test_event_fixed_param *ev_param; 10185 uint32_t num_bufp; 10186 uint32_t copy_size; 10187 uint8_t *bufp; 10188 10189 param_buf = (WMI_UNIT_TEST_EVENTID_param_tlvs *) evt_buf; 10190 ev_param = param_buf->fixed_param; 10191 bufp = param_buf->bufp; 10192 num_bufp = param_buf->num_bufp; 10193 unit_test->vdev_id = ev_param->vdev_id; 10194 unit_test->module_id = ev_param->module_id; 10195 unit_test->diag_token = ev_param->diag_token; 10196 unit_test->flag = ev_param->flag; 10197 unit_test->payload_len = ev_param->payload_len; 10198 WMI_LOGI("%s:vdev_id:%d mod_id:%d diag_token:%d flag:%d", __func__, 10199 ev_param->vdev_id, 10200 ev_param->module_id, 10201 ev_param->diag_token, 10202 ev_param->flag); 10203 WMI_LOGD("%s: Unit-test data given below %d", __func__, num_bufp); 10204 qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG, 10205 bufp, num_bufp); 10206 copy_size = (num_bufp < maxspace) ? num_bufp : maxspace; 10207 qdf_mem_copy(unit_test->buffer, bufp, copy_size); 10208 unit_test->buffer_len = copy_size; 10209 10210 return QDF_STATUS_SUCCESS; 10211 } 10212 10213 /** 10214 * extract_pdev_ext_stats_tlv() - extract extended pdev stats from event 10215 * @wmi_handle: wmi handle 10216 * @param evt_buf: pointer to event buffer 10217 * @param index: Index into extended pdev stats 10218 * @param pdev_ext_stats: Pointer to hold extended pdev stats 10219 * 10220 * Return: QDF_STATUS_SUCCESS for success or error code 10221 */ 10222 static QDF_STATUS extract_pdev_ext_stats_tlv(wmi_unified_t wmi_handle, 10223 void *evt_buf, uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats) 10224 { 10225 return QDF_STATUS_SUCCESS; 10226 } 10227 10228 /** 10229 * extract_vdev_stats_tlv() - extract vdev stats from event 10230 * @wmi_handle: wmi handle 10231 * @param evt_buf: pointer to event buffer 10232 * @param index: Index into vdev stats 10233 * @param vdev_stats: Pointer to hold vdev stats 10234 * 10235 * Return: QDF_STATUS_SUCCESS for success or error code 10236 */ 10237 static QDF_STATUS extract_vdev_stats_tlv(wmi_unified_t wmi_handle, 10238 void *evt_buf, uint32_t index, wmi_host_vdev_stats *vdev_stats) 10239 { 10240 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10241 wmi_stats_event_fixed_param *ev_param; 10242 uint8_t *data; 10243 10244 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10245 ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 10246 data = (uint8_t *) param_buf->data; 10247 10248 if (index < ev_param->num_vdev_stats) { 10249 wmi_vdev_stats *ev = (wmi_vdev_stats *) ((data) + 10250 ((ev_param->num_pdev_stats) * 10251 sizeof(wmi_pdev_stats)) + 10252 (index * sizeof(wmi_vdev_stats))); 10253 10254 vdev_stats->vdev_id = ev->vdev_id; 10255 vdev_stats->vdev_snr.bcn_snr = ev->vdev_snr.bcn_snr; 10256 vdev_stats->vdev_snr.dat_snr = ev->vdev_snr.dat_snr; 10257 10258 OS_MEMCPY(vdev_stats->tx_frm_cnt, ev->tx_frm_cnt, 10259 sizeof(ev->tx_frm_cnt)); 10260 vdev_stats->rx_frm_cnt = ev->rx_frm_cnt; 10261 OS_MEMCPY(vdev_stats->multiple_retry_cnt, 10262 ev->multiple_retry_cnt, 10263 sizeof(ev->multiple_retry_cnt)); 10264 OS_MEMCPY(vdev_stats->fail_cnt, ev->fail_cnt, 10265 sizeof(ev->fail_cnt)); 10266 vdev_stats->rts_fail_cnt = ev->rts_fail_cnt; 10267 vdev_stats->rts_succ_cnt = ev->rts_succ_cnt; 10268 vdev_stats->rx_err_cnt = ev->rx_err_cnt; 10269 vdev_stats->rx_discard_cnt = ev->rx_discard_cnt; 10270 vdev_stats->ack_fail_cnt = ev->ack_fail_cnt; 10271 OS_MEMCPY(vdev_stats->tx_rate_history, ev->tx_rate_history, 10272 sizeof(ev->tx_rate_history)); 10273 OS_MEMCPY(vdev_stats->bcn_rssi_history, ev->bcn_rssi_history, 10274 sizeof(ev->bcn_rssi_history)); 10275 10276 } 10277 10278 return QDF_STATUS_SUCCESS; 10279 } 10280 10281 /** 10282 * extract_per_chain_rssi_stats_tlv() - api to extract rssi stats from event 10283 * buffer 10284 * @wmi_handle: wmi handle 10285 * @evt_buf: pointer to event buffer 10286 * @index: Index into vdev stats 10287 * @rssi_stats: Pointer to hold rssi stats 10288 * 10289 * Return: QDF_STATUS_SUCCESS for success or error code 10290 */ 10291 static QDF_STATUS extract_per_chain_rssi_stats_tlv(wmi_unified_t wmi_handle, 10292 void *evt_buf, uint32_t index, 10293 struct wmi_host_per_chain_rssi_stats *rssi_stats) 10294 { 10295 uint8_t *data; 10296 wmi_rssi_stats *fw_rssi_stats; 10297 wmi_per_chain_rssi_stats *rssi_event; 10298 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10299 10300 if (!evt_buf) { 10301 WMI_LOGE("evt_buf is null"); 10302 return QDF_STATUS_E_NULL_VALUE; 10303 } 10304 10305 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10306 rssi_event = param_buf->chain_stats; 10307 10308 if (index >= rssi_event->num_per_chain_rssi_stats) { 10309 WMI_LOGE("invalid index"); 10310 return QDF_STATUS_E_INVAL; 10311 } 10312 10313 data = ((uint8_t *)(&rssi_event[1])) + WMI_TLV_HDR_SIZE; 10314 fw_rssi_stats = &((wmi_rssi_stats *)data)[index]; 10315 if (fw_rssi_stats->vdev_id >= WLAN_UMAC_PDEV_MAX_VDEVS) 10316 return QDF_STATUS_E_INVAL; 10317 10318 rssi_stats->vdev_id = fw_rssi_stats->vdev_id; 10319 qdf_mem_copy(rssi_stats->rssi_avg_beacon, 10320 fw_rssi_stats->rssi_avg_beacon, 10321 sizeof(fw_rssi_stats->rssi_avg_beacon)); 10322 qdf_mem_copy(rssi_stats->rssi_avg_data, 10323 fw_rssi_stats->rssi_avg_data, 10324 sizeof(fw_rssi_stats->rssi_avg_data)); 10325 qdf_mem_copy(&rssi_stats->peer_macaddr, 10326 &fw_rssi_stats->peer_macaddr, 10327 sizeof(fw_rssi_stats->peer_macaddr)); 10328 10329 return QDF_STATUS_SUCCESS; 10330 } 10331 10332 10333 10334 /** 10335 * extract_bcn_stats_tlv() - extract bcn stats from event 10336 * @wmi_handle: wmi handle 10337 * @param evt_buf: pointer to event buffer 10338 * @param index: Index into vdev stats 10339 * @param bcn_stats: Pointer to hold bcn stats 10340 * 10341 * Return: QDF_STATUS_SUCCESS for success or error code 10342 */ 10343 static QDF_STATUS extract_bcn_stats_tlv(wmi_unified_t wmi_handle, 10344 void *evt_buf, uint32_t index, wmi_host_bcn_stats *bcn_stats) 10345 { 10346 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10347 wmi_stats_event_fixed_param *ev_param; 10348 uint8_t *data; 10349 10350 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10351 ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 10352 data = (uint8_t *) param_buf->data; 10353 10354 if (index < ev_param->num_bcn_stats) { 10355 wmi_bcn_stats *ev = (wmi_bcn_stats *) ((data) + 10356 ((ev_param->num_pdev_stats) * sizeof(wmi_pdev_stats)) + 10357 ((ev_param->num_vdev_stats) * sizeof(wmi_vdev_stats)) + 10358 ((ev_param->num_peer_stats) * sizeof(wmi_peer_stats)) + 10359 ((ev_param->num_chan_stats) * sizeof(wmi_chan_stats)) + 10360 ((ev_param->num_mib_stats) * sizeof(wmi_mib_stats)) + 10361 (index * sizeof(wmi_bcn_stats))); 10362 10363 bcn_stats->vdev_id = ev->vdev_id; 10364 bcn_stats->tx_bcn_succ_cnt = ev->tx_bcn_succ_cnt; 10365 bcn_stats->tx_bcn_outage_cnt = ev->tx_bcn_outage_cnt; 10366 } 10367 10368 return QDF_STATUS_SUCCESS; 10369 } 10370 10371 /** 10372 * extract_peer_stats_tlv() - extract peer stats from event 10373 * @wmi_handle: wmi handle 10374 * @param evt_buf: pointer to event buffer 10375 * @param index: Index into peer stats 10376 * @param peer_stats: Pointer to hold peer stats 10377 * 10378 * Return: QDF_STATUS_SUCCESS for success or error code 10379 */ 10380 static QDF_STATUS extract_peer_stats_tlv(wmi_unified_t wmi_handle, 10381 void *evt_buf, uint32_t index, wmi_host_peer_stats *peer_stats) 10382 { 10383 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10384 wmi_stats_event_fixed_param *ev_param; 10385 uint8_t *data; 10386 10387 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10388 ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 10389 data = (uint8_t *) param_buf->data; 10390 10391 if (index < ev_param->num_peer_stats) { 10392 wmi_peer_stats *ev = (wmi_peer_stats *) ((data) + 10393 ((ev_param->num_pdev_stats) * sizeof(wmi_pdev_stats)) + 10394 ((ev_param->num_vdev_stats) * sizeof(wmi_vdev_stats)) + 10395 (index * sizeof(wmi_peer_stats))); 10396 10397 OS_MEMSET(peer_stats, 0, sizeof(wmi_host_peer_stats)); 10398 10399 OS_MEMCPY(&(peer_stats->peer_macaddr), 10400 &(ev->peer_macaddr), sizeof(wmi_mac_addr)); 10401 10402 peer_stats->peer_rssi = ev->peer_rssi; 10403 peer_stats->peer_tx_rate = ev->peer_tx_rate; 10404 peer_stats->peer_rx_rate = ev->peer_rx_rate; 10405 } 10406 10407 return QDF_STATUS_SUCCESS; 10408 } 10409 10410 /** 10411 * extract_bcnflt_stats_tlv() - extract bcn fault stats from event 10412 * @wmi_handle: wmi handle 10413 * @param evt_buf: pointer to event buffer 10414 * @param index: Index into bcn fault stats 10415 * @param bcnflt_stats: Pointer to hold bcn fault stats 10416 * 10417 * Return: QDF_STATUS_SUCCESS for success or error code 10418 */ 10419 static QDF_STATUS extract_bcnflt_stats_tlv(wmi_unified_t wmi_handle, 10420 void *evt_buf, uint32_t index, wmi_host_bcnflt_stats *peer_stats) 10421 { 10422 return QDF_STATUS_SUCCESS; 10423 } 10424 10425 /** 10426 * extract_peer_adv_stats_tlv() - extract adv peer stats from event 10427 * @wmi_handle: wmi handle 10428 * @param evt_buf: pointer to event buffer 10429 * @param index: Index into extended peer stats 10430 * @param peer_adv_stats: Pointer to hold adv peer stats 10431 * 10432 * Return: QDF_STATUS_SUCCESS for success or error code 10433 */ 10434 static QDF_STATUS extract_peer_adv_stats_tlv(wmi_unified_t wmi_handle, 10435 void *evt_buf, 10436 struct wmi_host_peer_adv_stats 10437 *peer_adv_stats) 10438 { 10439 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10440 wmi_peer_extd2_stats *adv_stats; 10441 int i; 10442 10443 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf; 10444 10445 adv_stats = param_buf->peer_extd2_stats; 10446 if (!adv_stats) { 10447 WMI_LOGD("%s: no peer_adv stats in event buffer", __func__); 10448 return QDF_STATUS_E_INVAL; 10449 } 10450 10451 for (i = 0; i < param_buf->num_peer_extd2_stats; i++) { 10452 WMI_MAC_ADDR_TO_CHAR_ARRAY(&adv_stats[i].peer_macaddr, 10453 peer_adv_stats[i].peer_macaddr); 10454 peer_adv_stats[i].fcs_count = adv_stats[i].rx_fcs_err; 10455 peer_adv_stats[i].rx_bytes = 10456 (uint64_t)adv_stats[i].rx_bytes_u32 << 10457 WMI_LOWER_BITS_SHIFT_32 | 10458 adv_stats[i].rx_bytes_l32; 10459 peer_adv_stats[i].rx_count = adv_stats[i].rx_mpdus; 10460 } 10461 10462 return QDF_STATUS_SUCCESS; 10463 } 10464 10465 /** 10466 * extract_peer_extd_stats_tlv() - extract extended peer stats from event 10467 * @wmi_handle: wmi handle 10468 * @param evt_buf: pointer to event buffer 10469 * @param index: Index into extended peer stats 10470 * @param peer_extd_stats: Pointer to hold extended peer stats 10471 * 10472 * Return: QDF_STATUS_SUCCESS for success or error code 10473 */ 10474 static QDF_STATUS extract_peer_extd_stats_tlv(wmi_unified_t wmi_handle, 10475 void *evt_buf, uint32_t index, 10476 wmi_host_peer_extd_stats *peer_extd_stats) 10477 { 10478 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10479 wmi_stats_event_fixed_param *ev_param; 10480 uint8_t *data; 10481 10482 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf; 10483 ev_param = (wmi_stats_event_fixed_param *)param_buf->fixed_param; 10484 data = (uint8_t *)param_buf->data; 10485 if (!data) 10486 return QDF_STATUS_E_FAILURE; 10487 10488 if (index < ev_param->num_peer_extd_stats) { 10489 wmi_peer_extd_stats *ev = (wmi_peer_extd_stats *) (data + 10490 (ev_param->num_pdev_stats * sizeof(wmi_pdev_stats)) + 10491 (ev_param->num_vdev_stats * sizeof(wmi_vdev_stats)) + 10492 (ev_param->num_peer_stats * sizeof(wmi_peer_stats)) + 10493 (ev_param->num_bcnflt_stats * 10494 sizeof(wmi_bcnfilter_stats_t)) + 10495 (ev_param->num_chan_stats * sizeof(wmi_chan_stats)) + 10496 (ev_param->num_mib_stats * sizeof(wmi_mib_stats)) + 10497 (ev_param->num_bcn_stats * sizeof(wmi_bcn_stats)) + 10498 (index * sizeof(wmi_peer_extd_stats))); 10499 10500 qdf_mem_zero(peer_extd_stats, sizeof(wmi_host_peer_extd_stats)); 10501 qdf_mem_copy(&peer_extd_stats->peer_macaddr, &ev->peer_macaddr, 10502 sizeof(wmi_mac_addr)); 10503 10504 peer_extd_stats->rx_mc_bc_cnt = ev->rx_mc_bc_cnt; 10505 } 10506 10507 return QDF_STATUS_SUCCESS; 10508 10509 } 10510 10511 /** 10512 * extract_chan_stats_tlv() - extract chan stats from event 10513 * @wmi_handle: wmi handle 10514 * @param evt_buf: pointer to event buffer 10515 * @param index: Index into chan stats 10516 * @param vdev_extd_stats: Pointer to hold chan stats 10517 * 10518 * Return: QDF_STATUS_SUCCESS for success or error code 10519 */ 10520 static QDF_STATUS extract_chan_stats_tlv(wmi_unified_t wmi_handle, 10521 void *evt_buf, uint32_t index, wmi_host_chan_stats *chan_stats) 10522 { 10523 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10524 wmi_stats_event_fixed_param *ev_param; 10525 uint8_t *data; 10526 10527 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf; 10528 ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param; 10529 data = (uint8_t *) param_buf->data; 10530 10531 if (index < ev_param->num_chan_stats) { 10532 wmi_chan_stats *ev = (wmi_chan_stats *) ((data) + 10533 ((ev_param->num_pdev_stats) * sizeof(wmi_pdev_stats)) + 10534 ((ev_param->num_vdev_stats) * sizeof(wmi_vdev_stats)) + 10535 ((ev_param->num_peer_stats) * sizeof(wmi_peer_stats)) + 10536 (index * sizeof(wmi_chan_stats))); 10537 10538 10539 /* Non-TLV doesn't have num_chan_stats */ 10540 chan_stats->chan_mhz = ev->chan_mhz; 10541 chan_stats->sampling_period_us = ev->sampling_period_us; 10542 chan_stats->rx_clear_count = ev->rx_clear_count; 10543 chan_stats->tx_duration_us = ev->tx_duration_us; 10544 chan_stats->rx_duration_us = ev->rx_duration_us; 10545 } 10546 10547 return QDF_STATUS_SUCCESS; 10548 } 10549 10550 #ifdef WLAN_FEATURE_MIB_STATS 10551 /** 10552 * extract_mib_stats_tlv() - extract mib stats from event 10553 * @wmi_handle: wmi handle 10554 * @param evt_buf: pointer to event buffer 10555 * @param mib_stats: pointer to hold mib stats 10556 * 10557 * Return: QDF_STATUS_SUCCESS for success or error code 10558 */ 10559 static QDF_STATUS extract_mib_stats_tlv(wmi_unified_t wmi_handle, 10560 void *evt_buf, 10561 struct mib_stats_metrics 10562 *mib_stats) 10563 { 10564 WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf; 10565 wmi_stats_event_fixed_param *ev_param; 10566 uint8_t *data; 10567 wmi_mib_stats *ev; 10568 wmi_mib_extd_stats *ev_extd; 10569 10570 param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf; 10571 ev_param = (wmi_stats_event_fixed_param *)param_buf->fixed_param; 10572 data = (uint8_t *)param_buf->data; 10573 10574 ev = (wmi_mib_stats *)(data + 10575 ev_param->num_pdev_stats * sizeof(wmi_pdev_stats) + 10576 ev_param->num_vdev_stats * sizeof(wmi_vdev_stats) + 10577 ev_param->num_peer_stats * sizeof(wmi_peer_stats) + 10578 ev_param->num_bcnflt_stats * 10579 sizeof(wmi_bcnfilter_stats_t) + 10580 ev_param->num_chan_stats * sizeof(wmi_chan_stats)); 10581 10582 qdf_mem_zero(mib_stats, sizeof(*mib_stats)); 10583 10584 mib_stats->mib_counters.tx_frags = 10585 ev->tx_mpdu_grp_frag_cnt; 10586 mib_stats->mib_counters.group_tx_frames = 10587 ev->tx_msdu_grp_frm_cnt; 10588 mib_stats->mib_counters.failed_cnt = ev->tx_msdu_fail_cnt; 10589 mib_stats->mib_counters.rx_frags = ev->rx_mpdu_frag_cnt; 10590 mib_stats->mib_counters.group_rx_frames = 10591 ev->rx_msdu_grp_frm_cnt; 10592 mib_stats->mib_counters.fcs_error_cnt = 10593 ev->rx_mpdu_fcs_err; 10594 mib_stats->mib_counters.tx_frames = 10595 ev->tx_msdu_frm_cnt; 10596 mib_stats->mib_mac_statistics.retry_cnt = 10597 ev->tx_msdu_retry_cnt; 10598 mib_stats->mib_mac_statistics.frame_dup_cnt = 10599 ev->rx_frm_dup_cnt; 10600 mib_stats->mib_mac_statistics.rts_success_cnt = 10601 ev->tx_rts_success_cnt; 10602 mib_stats->mib_mac_statistics.rts_fail_cnt = 10603 ev->tx_rts_fail_cnt; 10604 10605 mib_stats->mib_qos_counters.qos_tx_frag_cnt = 10606 ev->tx_Qos_mpdu_grp_frag_cnt; 10607 mib_stats->mib_qos_counters.qos_retry_cnt = 10608 ev->tx_Qos_msdu_retry_UP; 10609 mib_stats->mib_qos_counters.qos_failed_cnt = 10610 ev->tx_Qos_msdu_fail_UP; 10611 mib_stats->mib_qos_counters.qos_frame_dup_cnt = 10612 ev->rx_Qos_frm_dup_cnt_UP; 10613 mib_stats->mib_qos_counters.qos_rts_success_cnt = 10614 ev->tx_Qos_rts_success_cnt_UP; 10615 mib_stats->mib_qos_counters.qos_rts_fail_cnt = 10616 ev->tx_Qos_rts_fail_cnt_UP; 10617 mib_stats->mib_qos_counters.qos_rx_frag_cnt = 10618 ev->rx_Qos_mpdu_frag_cnt_UP; 10619 mib_stats->mib_qos_counters.qos_tx_frame_cnt = 10620 ev->tx_Qos_msdu_frm_cnt_UP; 10621 mib_stats->mib_qos_counters.qos_discarded_frame_cnt = 10622 ev->rx_Qos_msdu_discard_cnt_UP; 10623 mib_stats->mib_qos_counters.qos_mpdu_rx_cnt = 10624 ev->rx_Qos_mpdu_cnt; 10625 mib_stats->mib_qos_counters.qos_retries_rx_cnt = 10626 ev->rx_Qos_mpdu_retryBit_cnt; 10627 10628 mib_stats->mib_rsna_stats.tkip_icv_err = 10629 ev->rsna_TKIP_icv_err_cnt; 10630 mib_stats->mib_rsna_stats.tkip_replays = 10631 ev->rsna_TKIP_replay_err_cnt; 10632 mib_stats->mib_rsna_stats.ccmp_decrypt_err = 10633 ev->rsna_CCMP_decrypt_err_cnt; 10634 mib_stats->mib_rsna_stats.ccmp_replays = 10635 ev->rsna_CCMP_replay_err_cnt; 10636 10637 mib_stats->mib_counters_group3.tx_ampdu_cnt = 10638 ev->tx_ampdu_cnt; 10639 mib_stats->mib_counters_group3.tx_mpdus_in_ampdu_cnt = 10640 ev->tx_mpdu_cnt_in_ampdu; 10641 mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt = 10642 ev->tx_octets_in_ampdu.upload.high; 10643 mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt = 10644 mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt << 32; 10645 mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt += 10646 ev->tx_octets_in_ampdu.upload.low; 10647 10648 mib_stats->mib_counters_group3.ampdu_rx_cnt = 10649 ev->rx_ampdu_cnt; 10650 mib_stats->mib_counters_group3.mpdu_in_rx_ampdu_cnt = 10651 ev->rx_mpdu_cnt_in_ampdu; 10652 mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt = 10653 ev->rx_octets_in_ampdu.upload.rx_octets_in_ampdu_high; 10654 mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt = 10655 mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt << 32; 10656 mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt += 10657 ev->rx_octets_in_ampdu.upload.rx_octets_in_ampdu_low; 10658 10659 if (ev_param->num_mib_extd_stats) { 10660 ev_extd = (wmi_mib_extd_stats *)((uint8_t *)ev + 10661 ev_param->num_mib_stats * sizeof(wmi_mib_stats) + 10662 ev_param->num_bcn_stats * sizeof(wmi_bcn_stats) + 10663 ev_param->num_peer_extd_stats * 10664 sizeof(wmi_peer_extd_stats)); 10665 mib_stats->mib_mac_statistics.multi_retry_cnt = 10666 ev_extd->tx_msdu_multi_retry_cnt; 10667 mib_stats->mib_mac_statistics.tx_ack_fail_cnt = 10668 ev_extd->tx_ack_fail_cnt; 10669 10670 mib_stats->mib_qos_counters.qos_multi_retry_cnt = 10671 ev_extd->tx_qos_msdu_multi_retry_up; 10672 mib_stats->mib_qos_counters.tx_qos_ack_fail_cnt_up = 10673 ev_extd->tx_qos_ack_fail_cnt_up; 10674 10675 mib_stats->mib_rsna_stats.cmac_icv_err = 10676 ev_extd->rsna_cmac_icv_err_cnt; 10677 mib_stats->mib_rsna_stats.cmac_replays = 10678 ev_extd->rsna_cmac_replay_err_cnt; 10679 10680 mib_stats->mib_counters_group3.rx_ampdu_deli_crc_err_cnt = 10681 ev_extd->rx_ampdu_deli_crc_err_cnt; 10682 } 10683 10684 return QDF_STATUS_SUCCESS; 10685 } 10686 #endif 10687 10688 /** 10689 * extract_profile_ctx_tlv() - extract profile context from event 10690 * @wmi_handle: wmi handle 10691 * @param evt_buf: pointer to event buffer 10692 * @idx: profile stats index to extract 10693 * @param profile_ctx: Pointer to hold profile context 10694 * 10695 * Return: QDF_STATUS_SUCCESS for success or error code 10696 */ 10697 static QDF_STATUS extract_profile_ctx_tlv(wmi_unified_t wmi_handle, 10698 void *evt_buf, wmi_host_wlan_profile_ctx_t *profile_ctx) 10699 { 10700 WMI_WLAN_PROFILE_DATA_EVENTID_param_tlvs *param_buf; 10701 10702 wmi_wlan_profile_ctx_t *ev; 10703 10704 param_buf = (WMI_WLAN_PROFILE_DATA_EVENTID_param_tlvs *)evt_buf; 10705 if (!param_buf) { 10706 WMI_LOGE("%s: Invalid profile data event buf", __func__); 10707 return QDF_STATUS_E_INVAL; 10708 } 10709 10710 ev = param_buf->profile_ctx; 10711 10712 profile_ctx->tot = ev->tot; 10713 profile_ctx->tx_msdu_cnt = ev->tx_msdu_cnt; 10714 profile_ctx->tx_mpdu_cnt = ev->tx_mpdu_cnt; 10715 profile_ctx->tx_ppdu_cnt = ev->tx_ppdu_cnt; 10716 profile_ctx->rx_msdu_cnt = ev->rx_msdu_cnt; 10717 profile_ctx->rx_mpdu_cnt = ev->rx_mpdu_cnt; 10718 profile_ctx->bin_count = ev->bin_count; 10719 10720 return QDF_STATUS_SUCCESS; 10721 } 10722 10723 /** 10724 * extract_profile_data_tlv() - extract profile data from event 10725 * @wmi_handle: wmi handle 10726 * @param evt_buf: pointer to event buffer 10727 * @param profile_data: Pointer to hold profile data 10728 * 10729 * Return: QDF_STATUS_SUCCESS for success or error code 10730 */ 10731 static QDF_STATUS extract_profile_data_tlv(wmi_unified_t wmi_handle, 10732 void *evt_buf, uint8_t idx, wmi_host_wlan_profile_t *profile_data) 10733 { 10734 WMI_WLAN_PROFILE_DATA_EVENTID_param_tlvs *param_buf; 10735 wmi_wlan_profile_t *ev; 10736 uint8_t *buf_ptr; 10737 10738 param_buf = (WMI_WLAN_PROFILE_DATA_EVENTID_param_tlvs *)evt_buf; 10739 if (!param_buf) { 10740 WMI_LOGE("%s: Invalid profile data event buf", __func__); 10741 return QDF_STATUS_E_INVAL; 10742 } 10743 10744 buf_ptr = (uint8_t *)param_buf->profile_ctx; 10745 buf_ptr = buf_ptr + sizeof(wmi_wlan_profile_ctx_t) + WMI_TLV_HDR_SIZE; 10746 10747 buf_ptr = buf_ptr + (sizeof(wmi_wlan_profile_t) * idx); 10748 ev = (wmi_wlan_profile_t *)buf_ptr; 10749 10750 profile_data->id = ev->id; 10751 profile_data->cnt = ev->cnt; 10752 profile_data->tot = ev->tot; 10753 profile_data->min = ev->min; 10754 profile_data->max = ev->max; 10755 profile_data->hist_intvl = ev->hist_intvl; 10756 qdf_mem_copy(profile_data->hist, ev->hist, sizeof(profile_data->hist)); 10757 10758 return QDF_STATUS_SUCCESS; 10759 } 10760 10761 /** 10762 * extract_pdev_utf_event_tlv() - extract UTF data info from event 10763 * @wmi_handle: WMI handle 10764 * @param evt_buf: Pointer to event buffer 10765 * @param param: Pointer to hold data 10766 * 10767 * Return : QDF_STATUS_SUCCESS for success or error code 10768 */ 10769 static QDF_STATUS extract_pdev_utf_event_tlv(wmi_unified_t wmi_handle, 10770 uint8_t *evt_buf, 10771 struct wmi_host_pdev_utf_event *event) 10772 { 10773 WMI_PDEV_UTF_EVENTID_param_tlvs *param_buf; 10774 struct wmi_host_utf_seg_header_info *seg_hdr; 10775 10776 param_buf = (WMI_PDEV_UTF_EVENTID_param_tlvs *)evt_buf; 10777 event->data = param_buf->data; 10778 event->datalen = param_buf->num_data; 10779 10780 if (event->datalen < sizeof(struct wmi_host_utf_seg_header_info)) { 10781 WMI_LOGE("%s: Invalid datalen: %d ", __func__, event->datalen); 10782 return QDF_STATUS_E_INVAL; 10783 } 10784 seg_hdr = (struct wmi_host_utf_seg_header_info *)param_buf->data; 10785 /* Set pdev_id=1 until FW adds support to include pdev_id */ 10786 event->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 10787 wmi_handle, 10788 seg_hdr->pdev_id); 10789 10790 return QDF_STATUS_SUCCESS; 10791 } 10792 10793 #ifdef WLAN_SUPPORT_RF_CHARACTERIZATION 10794 static QDF_STATUS extract_num_rf_characterization_entries_tlv(wmi_unified_t wmi_handle, 10795 uint8_t *event, 10796 uint32_t *num_rf_characterization_entries) 10797 { 10798 WMI_CHAN_RF_CHARACTERIZATION_INFO_EVENTID_param_tlvs *param_buf; 10799 10800 param_buf = (WMI_CHAN_RF_CHARACTERIZATION_INFO_EVENTID_param_tlvs *)event; 10801 if (!param_buf) 10802 return QDF_STATUS_E_INVAL; 10803 10804 *num_rf_characterization_entries = 10805 param_buf->num_wmi_chan_rf_characterization_info; 10806 10807 return QDF_STATUS_SUCCESS; 10808 } 10809 10810 static QDF_STATUS extract_rf_characterization_entries_tlv(wmi_unified_t wmi_handle, 10811 uint8_t *event, 10812 uint32_t num_rf_characterization_entries, 10813 struct wmi_host_rf_characterization_event_param *rf_characterization_entries) 10814 { 10815 WMI_CHAN_RF_CHARACTERIZATION_INFO_EVENTID_param_tlvs *param_buf; 10816 WMI_CHAN_RF_CHARACTERIZATION_INFO *wmi_rf_characterization_entry; 10817 uint8_t ix; 10818 10819 param_buf = (WMI_CHAN_RF_CHARACTERIZATION_INFO_EVENTID_param_tlvs *)event; 10820 if (!param_buf) 10821 return QDF_STATUS_E_INVAL; 10822 10823 wmi_rf_characterization_entry = 10824 param_buf->wmi_chan_rf_characterization_info; 10825 if (!wmi_rf_characterization_entry) 10826 return QDF_STATUS_E_INVAL; 10827 10828 /* 10829 * Using num_wmi_chan_rf_characterization instead of param_buf value 10830 * since memory for rf_characterization_entries was allocated using 10831 * the former. 10832 */ 10833 for (ix = 0; ix < num_rf_characterization_entries; ix++) { 10834 rf_characterization_entries[ix].freq = 10835 WMI_CHAN_RF_CHARACTERIZATION_FREQ_GET( 10836 &wmi_rf_characterization_entry[ix]); 10837 10838 rf_characterization_entries[ix].bw = 10839 WMI_CHAN_RF_CHARACTERIZATION_BW_GET( 10840 &wmi_rf_characterization_entry[ix]); 10841 10842 rf_characterization_entries[ix].chan_metric = 10843 WMI_CHAN_RF_CHARACTERIZATION_CHAN_METRIC_GET( 10844 &wmi_rf_characterization_entry[ix]); 10845 10846 wmi_nofl_debug("rf_characterization_entries[%u]: freq: %u, " 10847 "bw: %u, chan_metric: %u", 10848 ix, rf_characterization_entries[ix].freq, 10849 rf_characterization_entries[ix].bw, 10850 rf_characterization_entries[ix].chan_metric); 10851 } 10852 10853 return QDF_STATUS_SUCCESS; 10854 } 10855 #endif 10856 10857 /** 10858 * extract_chainmask_tables_tlv() - extract chain mask tables from event 10859 * @wmi_handle: wmi handle 10860 * @param evt_buf: pointer to event buffer 10861 * @param param: Pointer to hold evt buf 10862 * 10863 * Return: QDF_STATUS_SUCCESS for success or error code 10864 */ 10865 static QDF_STATUS extract_chainmask_tables_tlv(wmi_unified_t wmi_handle, 10866 uint8_t *event, struct wlan_psoc_host_chainmask_table *chainmask_table) 10867 { 10868 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 10869 WMI_MAC_PHY_CHAINMASK_CAPABILITY *chainmask_caps; 10870 WMI_SOC_MAC_PHY_HW_MODE_CAPS *hw_caps; 10871 uint8_t i = 0, j = 0; 10872 uint32_t num_mac_phy_chainmask_caps = 0; 10873 10874 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event; 10875 if (!param_buf) 10876 return QDF_STATUS_E_INVAL; 10877 10878 hw_caps = param_buf->soc_hw_mode_caps; 10879 if (!hw_caps) 10880 return QDF_STATUS_E_INVAL; 10881 10882 if ((!hw_caps->num_chainmask_tables) || 10883 (hw_caps->num_chainmask_tables > PSOC_MAX_CHAINMASK_TABLES) || 10884 (hw_caps->num_chainmask_tables > 10885 param_buf->num_mac_phy_chainmask_combo)) 10886 return QDF_STATUS_E_INVAL; 10887 10888 chainmask_caps = param_buf->mac_phy_chainmask_caps; 10889 10890 if (!chainmask_caps) 10891 return QDF_STATUS_E_INVAL; 10892 10893 for (i = 0; i < hw_caps->num_chainmask_tables; i++) { 10894 if (chainmask_table[i].num_valid_chainmasks > 10895 (UINT_MAX - num_mac_phy_chainmask_caps)) { 10896 wmi_err_rl("integer overflow, num_mac_phy_chainmask_caps:%d, i:%d, um_valid_chainmasks:%d", 10897 num_mac_phy_chainmask_caps, i, 10898 chainmask_table[i].num_valid_chainmasks); 10899 return QDF_STATUS_E_INVAL; 10900 } 10901 num_mac_phy_chainmask_caps += 10902 chainmask_table[i].num_valid_chainmasks; 10903 } 10904 10905 if (num_mac_phy_chainmask_caps > 10906 param_buf->num_mac_phy_chainmask_caps) { 10907 wmi_err_rl("invalid chainmask caps num, num_mac_phy_chainmask_caps:%d, param_buf->num_mac_phy_chainmask_caps:%d", 10908 num_mac_phy_chainmask_caps, 10909 param_buf->num_mac_phy_chainmask_caps); 10910 return QDF_STATUS_E_INVAL; 10911 } 10912 10913 for (i = 0; i < hw_caps->num_chainmask_tables; i++) { 10914 10915 wmi_nofl_debug("Dumping chain mask combo data for table : %d", 10916 i); 10917 for (j = 0; j < chainmask_table[i].num_valid_chainmasks; j++) { 10918 10919 chainmask_table[i].cap_list[j].chainmask = 10920 chainmask_caps->chainmask; 10921 10922 chainmask_table[i].cap_list[j].supports_chan_width_20 = 10923 WMI_SUPPORT_CHAN_WIDTH_20_GET(chainmask_caps->supported_flags); 10924 10925 chainmask_table[i].cap_list[j].supports_chan_width_40 = 10926 WMI_SUPPORT_CHAN_WIDTH_40_GET(chainmask_caps->supported_flags); 10927 10928 chainmask_table[i].cap_list[j].supports_chan_width_80 = 10929 WMI_SUPPORT_CHAN_WIDTH_80_GET(chainmask_caps->supported_flags); 10930 10931 chainmask_table[i].cap_list[j].supports_chan_width_160 = 10932 WMI_SUPPORT_CHAN_WIDTH_160_GET(chainmask_caps->supported_flags); 10933 10934 chainmask_table[i].cap_list[j].supports_chan_width_80P80 = 10935 WMI_SUPPORT_CHAN_WIDTH_80P80_GET(chainmask_caps->supported_flags); 10936 10937 chainmask_table[i].cap_list[j].chain_mask_2G = 10938 WMI_SUPPORT_CHAIN_MASK_2G_GET(chainmask_caps->supported_flags); 10939 10940 chainmask_table[i].cap_list[j].chain_mask_5G = 10941 WMI_SUPPORT_CHAIN_MASK_5G_GET(chainmask_caps->supported_flags); 10942 10943 chainmask_table[i].cap_list[j].chain_mask_tx = 10944 WMI_SUPPORT_CHAIN_MASK_TX_GET(chainmask_caps->supported_flags); 10945 10946 chainmask_table[i].cap_list[j].chain_mask_rx = 10947 WMI_SUPPORT_CHAIN_MASK_RX_GET(chainmask_caps->supported_flags); 10948 10949 chainmask_table[i].cap_list[j].supports_aDFS = 10950 WMI_SUPPORT_CHAIN_MASK_ADFS_GET(chainmask_caps->supported_flags); 10951 10952 chainmask_table[i].cap_list[j].supports_aSpectral = 10953 WMI_SUPPORT_AGILE_SPECTRAL_GET(chainmask_caps->supported_flags); 10954 10955 chainmask_table[i].cap_list[j].supports_aSpectral_160 = 10956 WMI_SUPPORT_AGILE_SPECTRAL_160_GET(chainmask_caps->supported_flags); 10957 10958 chainmask_table[i].cap_list[j].supports_aDFS_160 = 10959 WMI_SUPPORT_ADFS_160_GET(chainmask_caps->supported_flags); 10960 10961 wmi_nofl_debug("supported_flags: 0x%08x chainmasks: 0x%08x", 10962 chainmask_caps->supported_flags, 10963 chainmask_caps->chainmask); 10964 chainmask_caps++; 10965 } 10966 } 10967 10968 return QDF_STATUS_SUCCESS; 10969 } 10970 10971 /** 10972 * extract_service_ready_ext_tlv() - extract basic extended service ready params 10973 * from event 10974 * @wmi_handle: wmi handle 10975 * @param evt_buf: pointer to event buffer 10976 * @param param: Pointer to hold evt buf 10977 * 10978 * Return: QDF_STATUS_SUCCESS for success or error code 10979 */ 10980 static QDF_STATUS extract_service_ready_ext_tlv(wmi_unified_t wmi_handle, 10981 uint8_t *event, struct wlan_psoc_host_service_ext_param *param) 10982 { 10983 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 10984 wmi_service_ready_ext_event_fixed_param *ev; 10985 WMI_SOC_MAC_PHY_HW_MODE_CAPS *hw_caps; 10986 WMI_SOC_HAL_REG_CAPABILITIES *reg_caps; 10987 WMI_MAC_PHY_CHAINMASK_COMBO *chain_mask_combo; 10988 uint8_t i = 0; 10989 10990 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event; 10991 if (!param_buf) 10992 return QDF_STATUS_E_INVAL; 10993 10994 ev = param_buf->fixed_param; 10995 if (!ev) 10996 return QDF_STATUS_E_INVAL; 10997 10998 /* Move this to host based bitmap */ 10999 param->default_conc_scan_config_bits = 11000 ev->default_conc_scan_config_bits; 11001 param->default_fw_config_bits = ev->default_fw_config_bits; 11002 param->he_cap_info = ev->he_cap_info; 11003 param->mpdu_density = ev->mpdu_density; 11004 param->max_bssid_rx_filters = ev->max_bssid_rx_filters; 11005 param->fw_build_vers_ext = ev->fw_build_vers_ext; 11006 param->num_dbr_ring_caps = param_buf->num_dma_ring_caps; 11007 param->num_bin_scaling_params = param_buf->num_wmi_bin_scaling_params; 11008 param->max_bssid_indicator = ev->max_bssid_indicator; 11009 qdf_mem_copy(¶m->ppet, &ev->ppet, sizeof(param->ppet)); 11010 11011 hw_caps = param_buf->soc_hw_mode_caps; 11012 if (hw_caps) 11013 param->num_hw_modes = hw_caps->num_hw_modes; 11014 else 11015 param->num_hw_modes = 0; 11016 11017 reg_caps = param_buf->soc_hal_reg_caps; 11018 if (reg_caps) 11019 param->num_phy = reg_caps->num_phy; 11020 else 11021 param->num_phy = 0; 11022 11023 if (hw_caps) { 11024 param->num_chainmask_tables = hw_caps->num_chainmask_tables; 11025 wmi_nofl_debug("Num chain mask tables: %d", 11026 hw_caps->num_chainmask_tables); 11027 } else 11028 param->num_chainmask_tables = 0; 11029 11030 if (param->num_chainmask_tables > PSOC_MAX_CHAINMASK_TABLES || 11031 param->num_chainmask_tables > 11032 param_buf->num_mac_phy_chainmask_combo) { 11033 wmi_err_rl("num_chainmask_tables is OOB: %u", 11034 param->num_chainmask_tables); 11035 return QDF_STATUS_E_INVAL; 11036 } 11037 chain_mask_combo = param_buf->mac_phy_chainmask_combo; 11038 11039 if (!chain_mask_combo) 11040 return QDF_STATUS_SUCCESS; 11041 11042 wmi_nofl_debug("Dumping chain mask combo data"); 11043 11044 for (i = 0; i < param->num_chainmask_tables; i++) { 11045 11046 wmi_nofl_debug("table_id : %d Num valid chainmasks: %d", 11047 chain_mask_combo->chainmask_table_id, 11048 chain_mask_combo->num_valid_chainmask); 11049 11050 param->chainmask_table[i].table_id = 11051 chain_mask_combo->chainmask_table_id; 11052 param->chainmask_table[i].num_valid_chainmasks = 11053 chain_mask_combo->num_valid_chainmask; 11054 chain_mask_combo++; 11055 } 11056 wmi_nofl_debug("chain mask combo end"); 11057 11058 return QDF_STATUS_SUCCESS; 11059 } 11060 11061 /** 11062 * extract_service_ready_ext2_tlv() - extract service ready ext2 params from 11063 * event 11064 * @wmi_handle: wmi handle 11065 * @event: pointer to event buffer 11066 * @param: Pointer to hold the params 11067 * 11068 * Return: QDF_STATUS_SUCCESS for success or error code 11069 */ 11070 static QDF_STATUS 11071 extract_service_ready_ext2_tlv(wmi_unified_t wmi_handle, uint8_t *event, 11072 struct wlan_psoc_host_service_ext2_param *param) 11073 { 11074 WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *param_buf; 11075 wmi_service_ready_ext2_event_fixed_param *ev; 11076 11077 param_buf = (WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *)event; 11078 if (!param_buf) 11079 return QDF_STATUS_E_INVAL; 11080 11081 ev = param_buf->fixed_param; 11082 if (!ev) 11083 return QDF_STATUS_E_INVAL; 11084 11085 param->reg_db_version_major = 11086 WMI_REG_DB_VERSION_MAJOR_GET( 11087 ev->reg_db_version); 11088 param->reg_db_version_minor = 11089 WMI_REG_DB_VERSION_MINOR_GET( 11090 ev->reg_db_version); 11091 param->bdf_reg_db_version_major = 11092 WMI_BDF_REG_DB_VERSION_MAJOR_GET( 11093 ev->reg_db_version); 11094 param->bdf_reg_db_version_minor = 11095 WMI_BDF_REG_DB_VERSION_MINOR_GET( 11096 ev->reg_db_version); 11097 11098 param->num_dbr_ring_caps = param_buf->num_dma_ring_caps; 11099 return QDF_STATUS_SUCCESS; 11100 } 11101 11102 /** 11103 * extract_sar_cap_service_ready_ext_tlv() - 11104 * extract SAR cap from service ready event 11105 * @wmi_handle: wmi handle 11106 * @event: pointer to event buffer 11107 * @ext_param: extended target info 11108 * 11109 * Return: QDF_STATUS_SUCCESS for success or error code 11110 */ 11111 static QDF_STATUS extract_sar_cap_service_ready_ext_tlv( 11112 wmi_unified_t wmi_handle, 11113 uint8_t *event, 11114 struct wlan_psoc_host_service_ext_param *ext_param) 11115 { 11116 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 11117 WMI_SAR_CAPABILITIES *sar_caps; 11118 11119 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *)event; 11120 11121 if (!param_buf) 11122 return QDF_STATUS_E_INVAL; 11123 11124 sar_caps = param_buf->sar_caps; 11125 if (sar_caps) 11126 ext_param->sar_version = sar_caps->active_version; 11127 else 11128 ext_param->sar_version = 0; 11129 11130 return QDF_STATUS_SUCCESS; 11131 } 11132 11133 /** 11134 * extract_hw_mode_cap_service_ready_ext_tlv() - 11135 * extract HW mode cap from service ready event 11136 * @wmi_handle: wmi handle 11137 * @param evt_buf: pointer to event buffer 11138 * @param param: Pointer to hold evt buf 11139 * @param hw_mode_idx: hw mode idx should be less than num_mode 11140 * 11141 * Return: QDF_STATUS_SUCCESS for success or error code 11142 */ 11143 static QDF_STATUS extract_hw_mode_cap_service_ready_ext_tlv( 11144 wmi_unified_t wmi_handle, 11145 uint8_t *event, uint8_t hw_mode_idx, 11146 struct wlan_psoc_host_hw_mode_caps *param) 11147 { 11148 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 11149 WMI_SOC_MAC_PHY_HW_MODE_CAPS *hw_caps; 11150 11151 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event; 11152 if (!param_buf) 11153 return QDF_STATUS_E_INVAL; 11154 11155 hw_caps = param_buf->soc_hw_mode_caps; 11156 if (!hw_caps) 11157 return QDF_STATUS_E_INVAL; 11158 11159 if (!hw_caps->num_hw_modes || 11160 !param_buf->hw_mode_caps || 11161 hw_caps->num_hw_modes > PSOC_MAX_HW_MODE || 11162 hw_caps->num_hw_modes > param_buf->num_hw_mode_caps) 11163 return QDF_STATUS_E_INVAL; 11164 11165 if (hw_mode_idx >= hw_caps->num_hw_modes) 11166 return QDF_STATUS_E_INVAL; 11167 11168 param->hw_mode_id = param_buf->hw_mode_caps[hw_mode_idx].hw_mode_id; 11169 param->phy_id_map = param_buf->hw_mode_caps[hw_mode_idx].phy_id_map; 11170 11171 param->hw_mode_config_type = 11172 param_buf->hw_mode_caps[hw_mode_idx].hw_mode_config_type; 11173 11174 return QDF_STATUS_SUCCESS; 11175 } 11176 11177 /** 11178 * extract_mac_phy_cap_service_ready_ext_tlv() - 11179 * extract MAC phy cap from service ready event 11180 * @wmi_handle: wmi handle 11181 * @param evt_buf: pointer to event buffer 11182 * @param param: Pointer to hold evt buf 11183 * @param hw_mode_idx: hw mode idx should be less than num_mode 11184 * @param phy_id: phy id within hw_mode 11185 * 11186 * Return: QDF_STATUS_SUCCESS for success or error code 11187 */ 11188 static QDF_STATUS extract_mac_phy_cap_service_ready_ext_tlv( 11189 wmi_unified_t wmi_handle, 11190 uint8_t *event, uint8_t hw_mode_id, uint8_t phy_id, 11191 struct wlan_psoc_host_mac_phy_caps *param) 11192 { 11193 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 11194 WMI_MAC_PHY_CAPABILITIES *mac_phy_caps; 11195 WMI_SOC_MAC_PHY_HW_MODE_CAPS *hw_caps; 11196 uint32_t phy_map; 11197 uint8_t hw_idx, phy_idx = 0; 11198 11199 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event; 11200 if (!param_buf) 11201 return QDF_STATUS_E_INVAL; 11202 11203 hw_caps = param_buf->soc_hw_mode_caps; 11204 if (!hw_caps) 11205 return QDF_STATUS_E_INVAL; 11206 if (hw_caps->num_hw_modes > PSOC_MAX_HW_MODE || 11207 hw_caps->num_hw_modes > param_buf->num_hw_mode_caps) { 11208 wmi_err_rl("invalid num_hw_modes %d, num_hw_mode_caps %d", 11209 hw_caps->num_hw_modes, param_buf->num_hw_mode_caps); 11210 return QDF_STATUS_E_INVAL; 11211 } 11212 11213 for (hw_idx = 0; hw_idx < hw_caps->num_hw_modes; hw_idx++) { 11214 if (hw_mode_id == param_buf->hw_mode_caps[hw_idx].hw_mode_id) 11215 break; 11216 11217 phy_map = param_buf->hw_mode_caps[hw_idx].phy_id_map; 11218 while (phy_map) { 11219 phy_map >>= 1; 11220 phy_idx++; 11221 } 11222 } 11223 11224 if (hw_idx == hw_caps->num_hw_modes) 11225 return QDF_STATUS_E_INVAL; 11226 11227 phy_idx += phy_id; 11228 if (phy_idx >= param_buf->num_mac_phy_caps) 11229 return QDF_STATUS_E_INVAL; 11230 11231 mac_phy_caps = ¶m_buf->mac_phy_caps[phy_idx]; 11232 11233 param->hw_mode_id = mac_phy_caps->hw_mode_id; 11234 param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 11235 wmi_handle, 11236 mac_phy_caps->pdev_id); 11237 param->tgt_pdev_id = mac_phy_caps->pdev_id; 11238 param->phy_id = mac_phy_caps->phy_id; 11239 param->supports_11b = 11240 WMI_SUPPORT_11B_GET(mac_phy_caps->supported_flags); 11241 param->supports_11g = 11242 WMI_SUPPORT_11G_GET(mac_phy_caps->supported_flags); 11243 param->supports_11a = 11244 WMI_SUPPORT_11A_GET(mac_phy_caps->supported_flags); 11245 param->supports_11n = 11246 WMI_SUPPORT_11N_GET(mac_phy_caps->supported_flags); 11247 param->supports_11ac = 11248 WMI_SUPPORT_11AC_GET(mac_phy_caps->supported_flags); 11249 param->supports_11ax = 11250 WMI_SUPPORT_11AX_GET(mac_phy_caps->supported_flags); 11251 11252 param->supported_bands = mac_phy_caps->supported_bands; 11253 param->ampdu_density = mac_phy_caps->ampdu_density; 11254 param->max_bw_supported_2G = mac_phy_caps->max_bw_supported_2G; 11255 param->ht_cap_info_2G = mac_phy_caps->ht_cap_info_2G; 11256 param->vht_cap_info_2G = mac_phy_caps->vht_cap_info_2G; 11257 param->vht_supp_mcs_2G = mac_phy_caps->vht_supp_mcs_2G; 11258 param->he_cap_info_2G[WMI_HOST_HECAP_MAC_WORD1] = 11259 mac_phy_caps->he_cap_info_2G; 11260 param->he_cap_info_2G[WMI_HOST_HECAP_MAC_WORD2] = 11261 mac_phy_caps->he_cap_info_2G_ext; 11262 param->he_supp_mcs_2G = mac_phy_caps->he_supp_mcs_2G; 11263 param->tx_chain_mask_2G = mac_phy_caps->tx_chain_mask_2G; 11264 param->rx_chain_mask_2G = mac_phy_caps->rx_chain_mask_2G; 11265 param->max_bw_supported_5G = mac_phy_caps->max_bw_supported_5G; 11266 param->ht_cap_info_5G = mac_phy_caps->ht_cap_info_5G; 11267 param->vht_cap_info_5G = mac_phy_caps->vht_cap_info_5G; 11268 param->vht_supp_mcs_5G = mac_phy_caps->vht_supp_mcs_5G; 11269 param->he_cap_info_5G[WMI_HOST_HECAP_MAC_WORD1] = 11270 mac_phy_caps->he_cap_info_5G; 11271 param->he_cap_info_5G[WMI_HOST_HECAP_MAC_WORD2] = 11272 mac_phy_caps->he_cap_info_5G_ext; 11273 param->he_supp_mcs_5G = mac_phy_caps->he_supp_mcs_5G; 11274 param->he_cap_info_internal = mac_phy_caps->he_cap_info_internal; 11275 param->tx_chain_mask_5G = mac_phy_caps->tx_chain_mask_5G; 11276 param->rx_chain_mask_5G = mac_phy_caps->rx_chain_mask_5G; 11277 qdf_mem_copy(¶m->he_cap_phy_info_2G, 11278 &mac_phy_caps->he_cap_phy_info_2G, 11279 sizeof(param->he_cap_phy_info_2G)); 11280 qdf_mem_copy(¶m->he_cap_phy_info_5G, 11281 &mac_phy_caps->he_cap_phy_info_5G, 11282 sizeof(param->he_cap_phy_info_5G)); 11283 qdf_mem_copy(¶m->he_ppet2G, &mac_phy_caps->he_ppet2G, 11284 sizeof(param->he_ppet2G)); 11285 qdf_mem_copy(¶m->he_ppet5G, &mac_phy_caps->he_ppet5G, 11286 sizeof(param->he_ppet5G)); 11287 param->chainmask_table_id = mac_phy_caps->chainmask_table_id; 11288 param->lmac_id = mac_phy_caps->lmac_id; 11289 param->reg_cap_ext.wireless_modes = convert_wireless_modes_tlv 11290 (mac_phy_caps->wireless_modes); 11291 param->reg_cap_ext.low_2ghz_chan = mac_phy_caps->low_2ghz_chan_freq; 11292 param->reg_cap_ext.high_2ghz_chan = mac_phy_caps->high_2ghz_chan_freq; 11293 param->reg_cap_ext.low_5ghz_chan = mac_phy_caps->low_5ghz_chan_freq; 11294 param->reg_cap_ext.high_5ghz_chan = mac_phy_caps->high_5ghz_chan_freq; 11295 param->nss_ratio_enabled = WMI_NSS_RATIO_ENABLE_DISABLE_GET( 11296 mac_phy_caps->nss_ratio); 11297 param->nss_ratio_info = WMI_NSS_RATIO_INFO_GET(mac_phy_caps->nss_ratio); 11298 11299 return QDF_STATUS_SUCCESS; 11300 } 11301 11302 /** 11303 * extract_reg_cap_service_ready_ext_tlv() - 11304 * extract REG cap from service ready event 11305 * @wmi_handle: wmi handle 11306 * @param evt_buf: pointer to event buffer 11307 * @param param: Pointer to hold evt buf 11308 * @param phy_idx: phy idx should be less than num_mode 11309 * 11310 * Return: QDF_STATUS_SUCCESS for success or error code 11311 */ 11312 static QDF_STATUS extract_reg_cap_service_ready_ext_tlv( 11313 wmi_unified_t wmi_handle, 11314 uint8_t *event, uint8_t phy_idx, 11315 struct wlan_psoc_host_hal_reg_capabilities_ext *param) 11316 { 11317 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 11318 WMI_SOC_HAL_REG_CAPABILITIES *reg_caps; 11319 WMI_HAL_REG_CAPABILITIES_EXT *ext_reg_cap; 11320 11321 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event; 11322 if (!param_buf) 11323 return QDF_STATUS_E_INVAL; 11324 11325 reg_caps = param_buf->soc_hal_reg_caps; 11326 if (!reg_caps) 11327 return QDF_STATUS_E_INVAL; 11328 11329 if (reg_caps->num_phy > param_buf->num_hal_reg_caps) 11330 return QDF_STATUS_E_INVAL; 11331 11332 if (phy_idx >= reg_caps->num_phy) 11333 return QDF_STATUS_E_INVAL; 11334 11335 if (!param_buf->hal_reg_caps) 11336 return QDF_STATUS_E_INVAL; 11337 11338 ext_reg_cap = ¶m_buf->hal_reg_caps[phy_idx]; 11339 11340 param->phy_id = ext_reg_cap->phy_id; 11341 param->eeprom_reg_domain = ext_reg_cap->eeprom_reg_domain; 11342 param->eeprom_reg_domain_ext = ext_reg_cap->eeprom_reg_domain_ext; 11343 param->regcap1 = ext_reg_cap->regcap1; 11344 param->regcap2 = ext_reg_cap->regcap2; 11345 param->wireless_modes = convert_wireless_modes_tlv( 11346 ext_reg_cap->wireless_modes); 11347 param->low_2ghz_chan = ext_reg_cap->low_2ghz_chan; 11348 param->high_2ghz_chan = ext_reg_cap->high_2ghz_chan; 11349 param->low_5ghz_chan = ext_reg_cap->low_5ghz_chan; 11350 param->high_5ghz_chan = ext_reg_cap->high_5ghz_chan; 11351 11352 return QDF_STATUS_SUCCESS; 11353 } 11354 11355 static QDF_STATUS validate_dbr_ring_caps_idx(uint8_t idx, 11356 uint8_t num_dma_ring_caps) 11357 { 11358 /* If dma_ring_caps is populated, num_dbr_ring_caps is non-zero */ 11359 if (!num_dma_ring_caps) { 11360 WMI_LOGI("%s: dma_ring_caps %d", __func__, num_dma_ring_caps); 11361 return QDF_STATUS_E_INVAL; 11362 } 11363 if (idx >= num_dma_ring_caps) { 11364 WMI_LOGE("%s: Index %d exceeds range", __func__, idx); 11365 return QDF_STATUS_E_INVAL; 11366 } 11367 return QDF_STATUS_SUCCESS; 11368 } 11369 11370 static void 11371 populate_dbr_ring_cap_elems(wmi_unified_t wmi_handle, 11372 struct wlan_psoc_host_dbr_ring_caps *param, 11373 WMI_DMA_RING_CAPABILITIES *dbr_ring_caps) 11374 { 11375 param->pdev_id = wmi_handle->ops->convert_target_pdev_id_to_host( 11376 wmi_handle, 11377 dbr_ring_caps->pdev_id); 11378 param->mod_id = dbr_ring_caps->mod_id; 11379 param->ring_elems_min = dbr_ring_caps->ring_elems_min; 11380 param->min_buf_size = dbr_ring_caps->min_buf_size; 11381 param->min_buf_align = dbr_ring_caps->min_buf_align; 11382 } 11383 11384 static QDF_STATUS extract_dbr_ring_cap_service_ready_ext_tlv( 11385 wmi_unified_t wmi_handle, 11386 uint8_t *event, uint8_t idx, 11387 struct wlan_psoc_host_dbr_ring_caps *param) 11388 { 11389 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf; 11390 QDF_STATUS status; 11391 11392 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *)event; 11393 if (!param_buf) 11394 return QDF_STATUS_E_INVAL; 11395 11396 status = validate_dbr_ring_caps_idx(idx, param_buf->num_dma_ring_caps); 11397 if (status != QDF_STATUS_SUCCESS) 11398 return status; 11399 11400 populate_dbr_ring_cap_elems(wmi_handle, param, 11401 ¶m_buf->dma_ring_caps[idx]); 11402 return QDF_STATUS_SUCCESS; 11403 } 11404 11405 static QDF_STATUS extract_dbr_ring_cap_service_ready_ext2_tlv( 11406 wmi_unified_t wmi_handle, 11407 uint8_t *event, uint8_t idx, 11408 struct wlan_psoc_host_dbr_ring_caps *param) 11409 { 11410 WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *param_buf; 11411 QDF_STATUS status; 11412 11413 param_buf = (WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *)event; 11414 if (!param_buf) 11415 return QDF_STATUS_E_INVAL; 11416 11417 status = validate_dbr_ring_caps_idx(idx, param_buf->num_dma_ring_caps); 11418 if (status != QDF_STATUS_SUCCESS) 11419 return status; 11420 11421 populate_dbr_ring_cap_elems(wmi_handle, param, 11422 ¶m_buf->dma_ring_caps[idx]); 11423 return QDF_STATUS_SUCCESS; 11424 } 11425 /** 11426 * extract_thermal_stats_tlv() - extract thermal stats from event 11427 * @wmi_handle: wmi handle 11428 * @param evt_buf: Pointer to event buffer 11429 * @param temp: Pointer to hold extracted temperature 11430 * @param level: Pointer to hold extracted level 11431 * 11432 * Return: 0 for success or error code 11433 */ 11434 static QDF_STATUS 11435 extract_thermal_stats_tlv(wmi_unified_t wmi_handle, 11436 void *evt_buf, uint32_t *temp, 11437 uint32_t *level, uint32_t *pdev_id) 11438 { 11439 WMI_THERM_THROT_STATS_EVENTID_param_tlvs *param_buf; 11440 wmi_therm_throt_stats_event_fixed_param *tt_stats_event; 11441 11442 param_buf = 11443 (WMI_THERM_THROT_STATS_EVENTID_param_tlvs *) evt_buf; 11444 if (!param_buf) 11445 return QDF_STATUS_E_INVAL; 11446 11447 tt_stats_event = param_buf->fixed_param; 11448 11449 *pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 11450 wmi_handle, 11451 tt_stats_event->pdev_id); 11452 *temp = tt_stats_event->temp; 11453 *level = tt_stats_event->level; 11454 11455 return QDF_STATUS_SUCCESS; 11456 } 11457 11458 /** 11459 * extract_thermal_level_stats_tlv() - extract thermal level stats from event 11460 * @wmi_handle: wmi handle 11461 * @param evt_buf: pointer to event buffer 11462 * @param idx: Index to level stats 11463 * @param levelcount: Pointer to hold levelcount 11464 * @param dccount: Pointer to hold dccount 11465 * 11466 * Return: 0 for success or error code 11467 */ 11468 static QDF_STATUS 11469 extract_thermal_level_stats_tlv(wmi_unified_t wmi_handle, 11470 void *evt_buf, uint8_t idx, uint32_t *levelcount, 11471 uint32_t *dccount) 11472 { 11473 WMI_THERM_THROT_STATS_EVENTID_param_tlvs *param_buf; 11474 wmi_therm_throt_level_stats_info *tt_level_info; 11475 11476 param_buf = 11477 (WMI_THERM_THROT_STATS_EVENTID_param_tlvs *) evt_buf; 11478 if (!param_buf) 11479 return QDF_STATUS_E_INVAL; 11480 11481 tt_level_info = param_buf->therm_throt_level_stats_info; 11482 11483 if (idx < THERMAL_LEVELS) { 11484 *levelcount = tt_level_info[idx].level_count; 11485 *dccount = tt_level_info[idx].dc_count; 11486 return QDF_STATUS_SUCCESS; 11487 } 11488 11489 return QDF_STATUS_E_FAILURE; 11490 } 11491 #ifdef BIG_ENDIAN_HOST 11492 /** 11493 * fips_conv_data_be() - LE to BE conversion of FIPS ev data 11494 * @param data_len - data length 11495 * @param data - pointer to data 11496 * 11497 * Return: QDF_STATUS - success or error status 11498 */ 11499 static QDF_STATUS fips_conv_data_be(uint32_t data_len, uint8_t *data) 11500 { 11501 uint8_t *data_aligned = NULL; 11502 int c; 11503 unsigned char *data_unaligned; 11504 11505 data_unaligned = qdf_mem_malloc(((sizeof(uint8_t) * data_len) + 11506 FIPS_ALIGN)); 11507 /* Assigning unaligned space to copy the data */ 11508 /* Checking if kmalloc does successful allocation */ 11509 if (!data_unaligned) 11510 return QDF_STATUS_E_FAILURE; 11511 11512 /* Checking if space is alligned */ 11513 if (!FIPS_IS_ALIGNED(data_unaligned, FIPS_ALIGN)) { 11514 /* align the data space */ 11515 data_aligned = 11516 (uint8_t *)FIPS_ALIGNTO(data_unaligned, FIPS_ALIGN); 11517 } else { 11518 data_aligned = (u_int8_t *)data_unaligned; 11519 } 11520 11521 /* memset and copy content from data to data aligned */ 11522 OS_MEMSET(data_aligned, 0, data_len); 11523 OS_MEMCPY(data_aligned, data, data_len); 11524 /* Endianness to LE */ 11525 for (c = 0; c < data_len/4; c++) { 11526 *((u_int32_t *)data_aligned + c) = 11527 qdf_le32_to_cpu(*((u_int32_t *)data_aligned + c)); 11528 } 11529 11530 /* Copy content to event->data */ 11531 OS_MEMCPY(data, data_aligned, data_len); 11532 11533 /* clean up allocated space */ 11534 qdf_mem_free(data_unaligned); 11535 data_aligned = NULL; 11536 data_unaligned = NULL; 11537 11538 /*************************************************************/ 11539 11540 return QDF_STATUS_SUCCESS; 11541 } 11542 #else 11543 /** 11544 * fips_conv_data_be() - DUMMY for LE platform 11545 * 11546 * Return: QDF_STATUS - success 11547 */ 11548 static QDF_STATUS fips_conv_data_be(uint32_t data_len, uint8_t *data) 11549 { 11550 return QDF_STATUS_SUCCESS; 11551 } 11552 #endif 11553 11554 /** 11555 * send_pdev_get_pn_cmd_tlv() - send get PN request params to fw 11556 * @wmi_handle - wmi handle 11557 * @params - PN request params for peer 11558 * 11559 * Return: QDF_STATUS - success or error status 11560 */ 11561 static QDF_STATUS 11562 send_pdev_get_pn_cmd_tlv(wmi_unified_t wmi_handle, 11563 struct peer_request_pn_param *params) 11564 { 11565 wmi_peer_tx_pn_request_cmd_fixed_param *cmd; 11566 wmi_buf_t buf; 11567 uint8_t *buf_ptr; 11568 uint32_t len = sizeof(wmi_peer_tx_pn_request_cmd_fixed_param); 11569 11570 buf = wmi_buf_alloc(wmi_handle, len); 11571 if (!buf) { 11572 WMI_LOGE("%s:wmi_buf_alloc failed\n", __func__); 11573 return QDF_STATUS_E_FAILURE; 11574 } 11575 11576 buf_ptr = (uint8_t *)wmi_buf_data(buf); 11577 cmd = (wmi_peer_tx_pn_request_cmd_fixed_param *)buf_ptr; 11578 11579 WMITLV_SET_HDR(&cmd->tlv_header, 11580 WMITLV_TAG_STRUC_wmi_peer_tx_pn_request_cmd_fixed_param, 11581 WMITLV_GET_STRUCT_TLVLEN(wmi_peer_tx_pn_request_cmd_fixed_param)); 11582 11583 cmd->vdev_id = params->vdev_id; 11584 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 11585 cmd->key_type = params->key_type; 11586 if (wmi_unified_cmd_send(wmi_handle, buf, len, 11587 WMI_PEER_TX_PN_REQUEST_CMDID)) { 11588 WMI_LOGE("%s:Failed to send WMI command\n", __func__); 11589 wmi_buf_free(buf); 11590 return QDF_STATUS_E_FAILURE; 11591 } 11592 return QDF_STATUS_SUCCESS; 11593 } 11594 11595 /** 11596 * extract_get_pn_data_tlv() - extract pn resp 11597 * @wmi_handle - wmi handle 11598 * @params - PN response params for peer 11599 * 11600 * Return: QDF_STATUS - success or error status 11601 */ 11602 static QDF_STATUS 11603 extract_get_pn_data_tlv(wmi_unified_t wmi_handle, void *evt_buf, 11604 struct wmi_host_get_pn_event *param) 11605 { 11606 WMI_PEER_TX_PN_RESPONSE_EVENTID_param_tlvs *param_buf; 11607 wmi_peer_tx_pn_response_event_fixed_param *event = NULL; 11608 11609 param_buf = (WMI_PEER_TX_PN_RESPONSE_EVENTID_param_tlvs *)evt_buf; 11610 event = 11611 (wmi_peer_tx_pn_response_event_fixed_param *)param_buf->fixed_param; 11612 11613 param->vdev_id = event->vdev_id; 11614 param->key_type = event->key_type; 11615 qdf_mem_copy(param->pn, event->pn, sizeof(event->pn)); 11616 WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, param->mac_addr); 11617 11618 return QDF_STATUS_SUCCESS; 11619 } 11620 11621 /** 11622 * extract_fips_event_data_tlv() - extract fips event data 11623 * @wmi_handle: wmi handle 11624 * @param evt_buf: pointer to event buffer 11625 * @param param: pointer FIPS event params 11626 * 11627 * Return: 0 for success or error code 11628 */ 11629 static QDF_STATUS extract_fips_event_data_tlv(wmi_unified_t wmi_handle, 11630 void *evt_buf, struct wmi_host_fips_event_param *param) 11631 { 11632 WMI_PDEV_FIPS_EVENTID_param_tlvs *param_buf; 11633 wmi_pdev_fips_event_fixed_param *event; 11634 11635 param_buf = (WMI_PDEV_FIPS_EVENTID_param_tlvs *) evt_buf; 11636 event = (wmi_pdev_fips_event_fixed_param *) param_buf->fixed_param; 11637 11638 if (fips_conv_data_be(event->data_len, param_buf->data) != 11639 QDF_STATUS_SUCCESS) 11640 return QDF_STATUS_E_FAILURE; 11641 11642 param->data = (uint32_t *)param_buf->data; 11643 param->data_len = event->data_len; 11644 param->error_status = event->error_status; 11645 param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 11646 wmi_handle, 11647 event->pdev_id); 11648 11649 return QDF_STATUS_SUCCESS; 11650 } 11651 11652 #ifdef WLAN_FEATURE_DISA 11653 /** 11654 * extract_encrypt_decrypt_resp_event_tlv() - extract encrypt decrypt resp 11655 * params from event 11656 * @wmi_handle: wmi handle 11657 * @evt_buf: pointer to event buffer 11658 * @resp: Pointer to hold resp parameters 11659 * 11660 * Return: QDF_STATUS_SUCCESS for success or error code 11661 */ 11662 static QDF_STATUS 11663 extract_encrypt_decrypt_resp_event_tlv(wmi_unified_t wmi_handle, 11664 void *evt_buf, 11665 struct disa_encrypt_decrypt_resp_params 11666 *resp) 11667 { 11668 WMI_VDEV_ENCRYPT_DECRYPT_DATA_RESP_EVENTID_param_tlvs *param_buf; 11669 wmi_vdev_encrypt_decrypt_data_resp_event_fixed_param *data_event; 11670 11671 param_buf = evt_buf; 11672 if (!param_buf) { 11673 WMI_LOGE("encrypt decrypt resp evt_buf is NULL"); 11674 return QDF_STATUS_E_INVAL; 11675 } 11676 11677 data_event = param_buf->fixed_param; 11678 11679 resp->vdev_id = data_event->vdev_id; 11680 resp->status = data_event->status; 11681 11682 if ((data_event->data_length > param_buf->num_enc80211_frame) || 11683 (data_event->data_length > WMI_SVC_MSG_MAX_SIZE - 11684 WMI_TLV_HDR_SIZE - sizeof(*data_event))) { 11685 WMI_LOGE("FW msg data_len %d more than TLV hdr %d", 11686 data_event->data_length, 11687 param_buf->num_enc80211_frame); 11688 return QDF_STATUS_E_INVAL; 11689 } 11690 11691 resp->data_len = data_event->data_length; 11692 11693 if (resp->data_len) 11694 resp->data = (uint8_t *)param_buf->enc80211_frame; 11695 11696 return QDF_STATUS_SUCCESS; 11697 } 11698 #endif /* WLAN_FEATURE_DISA */ 11699 11700 static bool is_management_record_tlv(uint32_t cmd_id) 11701 { 11702 switch (cmd_id) { 11703 case WMI_MGMT_TX_SEND_CMDID: 11704 case WMI_MGMT_TX_COMPLETION_EVENTID: 11705 case WMI_OFFCHAN_DATA_TX_SEND_CMDID: 11706 case WMI_MGMT_RX_EVENTID: 11707 return true; 11708 default: 11709 return false; 11710 } 11711 } 11712 11713 static bool is_diag_event_tlv(uint32_t event_id) 11714 { 11715 if (WMI_DIAG_EVENTID == event_id) 11716 return true; 11717 11718 return false; 11719 } 11720 11721 static uint16_t wmi_tag_fw_hang_cmd(wmi_unified_t wmi_handle) 11722 { 11723 uint16_t tag = 0; 11724 11725 if (qdf_atomic_read(&wmi_handle->is_target_suspended)) { 11726 qdf_nofl_err("%s: Target is already suspended, Ignore FW Hang Command", 11727 __func__); 11728 return tag; 11729 } 11730 11731 if (wmi_handle->tag_crash_inject) 11732 tag = HTC_TX_PACKET_TAG_AUTO_PM; 11733 11734 wmi_handle->tag_crash_inject = false; 11735 return tag; 11736 } 11737 11738 /** 11739 * wmi_set_htc_tx_tag_tlv() - set HTC TX tag for WMI commands 11740 * @wmi_handle: WMI handle 11741 * @buf: WMI buffer 11742 * @cmd_id: WMI command Id 11743 * 11744 * Return htc_tx_tag 11745 */ 11746 static uint16_t wmi_set_htc_tx_tag_tlv(wmi_unified_t wmi_handle, 11747 wmi_buf_t buf, 11748 uint32_t cmd_id) 11749 { 11750 uint16_t htc_tx_tag = 0; 11751 11752 switch (cmd_id) { 11753 case WMI_WOW_ENABLE_CMDID: 11754 case WMI_PDEV_SUSPEND_CMDID: 11755 case WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID: 11756 case WMI_PDEV_RESUME_CMDID: 11757 case WMI_HB_SET_ENABLE_CMDID: 11758 case WMI_WOW_SET_ACTION_WAKE_UP_CMDID: 11759 #ifdef FEATURE_WLAN_D0WOW 11760 case WMI_D0_WOW_ENABLE_DISABLE_CMDID: 11761 #endif 11762 htc_tx_tag = HTC_TX_PACKET_TAG_AUTO_PM; 11763 break; 11764 case WMI_FORCE_FW_HANG_CMDID: 11765 htc_tx_tag = wmi_tag_fw_hang_cmd(wmi_handle); 11766 break; 11767 default: 11768 break; 11769 } 11770 11771 return htc_tx_tag; 11772 } 11773 11774 static struct cur_reg_rule 11775 *create_reg_rules_from_wmi(uint32_t num_reg_rules, 11776 wmi_regulatory_rule_struct *wmi_reg_rule) 11777 { 11778 struct cur_reg_rule *reg_rule_ptr; 11779 uint32_t count; 11780 11781 if (!num_reg_rules) 11782 return NULL; 11783 11784 reg_rule_ptr = qdf_mem_malloc(num_reg_rules * 11785 sizeof(*reg_rule_ptr)); 11786 11787 if (!reg_rule_ptr) 11788 return NULL; 11789 11790 for (count = 0; count < num_reg_rules; count++) { 11791 reg_rule_ptr[count].start_freq = 11792 WMI_REG_RULE_START_FREQ_GET( 11793 wmi_reg_rule[count].freq_info); 11794 reg_rule_ptr[count].end_freq = 11795 WMI_REG_RULE_END_FREQ_GET( 11796 wmi_reg_rule[count].freq_info); 11797 reg_rule_ptr[count].max_bw = 11798 WMI_REG_RULE_MAX_BW_GET( 11799 wmi_reg_rule[count].bw_pwr_info); 11800 reg_rule_ptr[count].reg_power = 11801 WMI_REG_RULE_REG_POWER_GET( 11802 wmi_reg_rule[count].bw_pwr_info); 11803 reg_rule_ptr[count].ant_gain = 11804 WMI_REG_RULE_ANTENNA_GAIN_GET( 11805 wmi_reg_rule[count].bw_pwr_info); 11806 reg_rule_ptr[count].flags = 11807 WMI_REG_RULE_FLAGS_GET( 11808 wmi_reg_rule[count].flag_info); 11809 } 11810 11811 return reg_rule_ptr; 11812 } 11813 11814 static QDF_STATUS extract_reg_chan_list_update_event_tlv( 11815 wmi_unified_t wmi_handle, uint8_t *evt_buf, 11816 struct cur_regulatory_info *reg_info, uint32_t len) 11817 { 11818 WMI_REG_CHAN_LIST_CC_EVENTID_param_tlvs *param_buf; 11819 wmi_reg_chan_list_cc_event_fixed_param *chan_list_event_hdr; 11820 wmi_regulatory_rule_struct *wmi_reg_rule; 11821 uint32_t num_2g_reg_rules, num_5g_reg_rules; 11822 11823 WMI_LOGD("processing regulatory channel list"); 11824 11825 param_buf = (WMI_REG_CHAN_LIST_CC_EVENTID_param_tlvs *)evt_buf; 11826 if (!param_buf) { 11827 WMI_LOGE("invalid channel list event buf"); 11828 return QDF_STATUS_E_FAILURE; 11829 } 11830 11831 chan_list_event_hdr = param_buf->fixed_param; 11832 11833 reg_info->num_2g_reg_rules = chan_list_event_hdr->num_2g_reg_rules; 11834 reg_info->num_5g_reg_rules = chan_list_event_hdr->num_5g_reg_rules; 11835 num_2g_reg_rules = reg_info->num_2g_reg_rules; 11836 num_5g_reg_rules = reg_info->num_5g_reg_rules; 11837 if ((num_2g_reg_rules > MAX_REG_RULES) || 11838 (num_5g_reg_rules > MAX_REG_RULES) || 11839 (num_2g_reg_rules + num_5g_reg_rules > MAX_REG_RULES) || 11840 (num_2g_reg_rules + num_5g_reg_rules != 11841 param_buf->num_reg_rule_array)) { 11842 wmi_err_rl("Invalid num_2g_reg_rules: %u, num_5g_reg_rules: %u", 11843 num_2g_reg_rules, num_5g_reg_rules); 11844 return QDF_STATUS_E_FAILURE; 11845 } 11846 if (param_buf->num_reg_rule_array > 11847 (WMI_SVC_MSG_MAX_SIZE - sizeof(*chan_list_event_hdr)) / 11848 sizeof(*wmi_reg_rule)) { 11849 wmi_err_rl("Invalid num_reg_rule_array: %u", 11850 param_buf->num_reg_rule_array); 11851 return QDF_STATUS_E_FAILURE; 11852 } 11853 11854 qdf_mem_copy(reg_info->alpha2, &(chan_list_event_hdr->alpha2), 11855 REG_ALPHA2_LEN); 11856 reg_info->dfs_region = chan_list_event_hdr->dfs_region; 11857 reg_info->phybitmap = convert_phybitmap_tlv( 11858 chan_list_event_hdr->phybitmap); 11859 reg_info->offload_enabled = true; 11860 reg_info->num_phy = chan_list_event_hdr->num_phy; 11861 reg_info->phy_id = wmi_handle->ops->convert_phy_id_target_to_host( 11862 wmi_handle, chan_list_event_hdr->phy_id); 11863 reg_info->ctry_code = chan_list_event_hdr->country_id; 11864 reg_info->reg_dmn_pair = chan_list_event_hdr->domain_code; 11865 if (chan_list_event_hdr->status_code == WMI_REG_SET_CC_STATUS_PASS) 11866 reg_info->status_code = REG_SET_CC_STATUS_PASS; 11867 else if (chan_list_event_hdr->status_code == 11868 WMI_REG_CURRENT_ALPHA2_NOT_FOUND) 11869 reg_info->status_code = REG_CURRENT_ALPHA2_NOT_FOUND; 11870 else if (chan_list_event_hdr->status_code == 11871 WMI_REG_INIT_ALPHA2_NOT_FOUND) 11872 reg_info->status_code = REG_INIT_ALPHA2_NOT_FOUND; 11873 else if (chan_list_event_hdr->status_code == 11874 WMI_REG_SET_CC_CHANGE_NOT_ALLOWED) 11875 reg_info->status_code = REG_SET_CC_CHANGE_NOT_ALLOWED; 11876 else if (chan_list_event_hdr->status_code == 11877 WMI_REG_SET_CC_STATUS_NO_MEMORY) 11878 reg_info->status_code = REG_SET_CC_STATUS_NO_MEMORY; 11879 else if (chan_list_event_hdr->status_code == 11880 WMI_REG_SET_CC_STATUS_FAIL) 11881 reg_info->status_code = REG_SET_CC_STATUS_FAIL; 11882 11883 reg_info->min_bw_2g = chan_list_event_hdr->min_bw_2g; 11884 reg_info->max_bw_2g = chan_list_event_hdr->max_bw_2g; 11885 reg_info->min_bw_5g = chan_list_event_hdr->min_bw_5g; 11886 reg_info->max_bw_5g = chan_list_event_hdr->max_bw_5g; 11887 11888 WMI_LOGD(FL("num_phys = %u and phy_id = %u"), 11889 reg_info->num_phy, reg_info->phy_id); 11890 11891 WMI_LOGD("%s:cc %s dfs %d BW: min_2g %d max_2g %d min_5g %d max_5g %d", 11892 __func__, reg_info->alpha2, reg_info->dfs_region, 11893 reg_info->min_bw_2g, reg_info->max_bw_2g, 11894 reg_info->min_bw_5g, reg_info->max_bw_5g); 11895 11896 WMI_LOGD("%s: num_2g_reg_rules %d num_5g_reg_rules %d", __func__, 11897 num_2g_reg_rules, num_5g_reg_rules); 11898 wmi_reg_rule = 11899 (wmi_regulatory_rule_struct *)((uint8_t *)chan_list_event_hdr 11900 + sizeof(wmi_reg_chan_list_cc_event_fixed_param) 11901 + WMI_TLV_HDR_SIZE); 11902 reg_info->reg_rules_2g_ptr = create_reg_rules_from_wmi(num_2g_reg_rules, 11903 wmi_reg_rule); 11904 wmi_reg_rule += num_2g_reg_rules; 11905 11906 reg_info->reg_rules_5g_ptr = create_reg_rules_from_wmi(num_5g_reg_rules, 11907 wmi_reg_rule); 11908 11909 WMI_LOGD("processed regulatory channel list"); 11910 11911 return QDF_STATUS_SUCCESS; 11912 } 11913 11914 static QDF_STATUS extract_reg_11d_new_country_event_tlv( 11915 wmi_unified_t wmi_handle, uint8_t *evt_buf, 11916 struct reg_11d_new_country *reg_11d_country, uint32_t len) 11917 { 11918 wmi_11d_new_country_event_fixed_param *reg_11d_country_event; 11919 WMI_11D_NEW_COUNTRY_EVENTID_param_tlvs *param_buf; 11920 11921 param_buf = (WMI_11D_NEW_COUNTRY_EVENTID_param_tlvs *)evt_buf; 11922 if (!param_buf) { 11923 WMI_LOGE("invalid 11d country event buf"); 11924 return QDF_STATUS_E_FAILURE; 11925 } 11926 11927 reg_11d_country_event = param_buf->fixed_param; 11928 11929 qdf_mem_copy(reg_11d_country->alpha2, 11930 ®_11d_country_event->new_alpha2, REG_ALPHA2_LEN); 11931 reg_11d_country->alpha2[REG_ALPHA2_LEN] = '\0'; 11932 11933 WMI_LOGD("processed 11d country event, new cc %s", 11934 reg_11d_country->alpha2); 11935 11936 return QDF_STATUS_SUCCESS; 11937 } 11938 11939 static QDF_STATUS extract_reg_ch_avoid_event_tlv( 11940 wmi_unified_t wmi_handle, uint8_t *evt_buf, 11941 struct ch_avoid_ind_type *ch_avoid_ind, uint32_t len) 11942 { 11943 wmi_avoid_freq_ranges_event_fixed_param *afr_fixed_param; 11944 wmi_avoid_freq_range_desc *afr_desc; 11945 uint32_t num_freq_ranges, freq_range_idx; 11946 WMI_WLAN_FREQ_AVOID_EVENTID_param_tlvs *param_buf = 11947 (WMI_WLAN_FREQ_AVOID_EVENTID_param_tlvs *) evt_buf; 11948 11949 if (!param_buf) { 11950 WMI_LOGE("Invalid channel avoid event buffer"); 11951 return QDF_STATUS_E_INVAL; 11952 } 11953 11954 afr_fixed_param = param_buf->fixed_param; 11955 if (!afr_fixed_param) { 11956 WMI_LOGE("Invalid channel avoid event fixed param buffer"); 11957 return QDF_STATUS_E_INVAL; 11958 } 11959 11960 if (!ch_avoid_ind) { 11961 WMI_LOGE("Invalid channel avoid indication buffer"); 11962 return QDF_STATUS_E_INVAL; 11963 } 11964 if (param_buf->num_avd_freq_range < afr_fixed_param->num_freq_ranges) { 11965 WMI_LOGE(FL("no.of freq ranges exceeded the limit")); 11966 return QDF_STATUS_E_INVAL; 11967 } 11968 num_freq_ranges = (afr_fixed_param->num_freq_ranges > 11969 CH_AVOID_MAX_RANGE) ? CH_AVOID_MAX_RANGE : 11970 afr_fixed_param->num_freq_ranges; 11971 11972 WMI_LOGD("Channel avoid event received with %d ranges", 11973 num_freq_ranges); 11974 11975 ch_avoid_ind->ch_avoid_range_cnt = num_freq_ranges; 11976 afr_desc = (wmi_avoid_freq_range_desc *)(param_buf->avd_freq_range); 11977 for (freq_range_idx = 0; freq_range_idx < num_freq_ranges; 11978 freq_range_idx++) { 11979 ch_avoid_ind->avoid_freq_range[freq_range_idx].start_freq = 11980 afr_desc->start_freq; 11981 ch_avoid_ind->avoid_freq_range[freq_range_idx].end_freq = 11982 afr_desc->end_freq; 11983 WMI_LOGD("range %d tlv id %u, start freq %u, end freq %u", 11984 freq_range_idx, afr_desc->tlv_header, 11985 afr_desc->start_freq, afr_desc->end_freq); 11986 afr_desc++; 11987 } 11988 11989 return QDF_STATUS_SUCCESS; 11990 } 11991 11992 #ifdef DFS_COMPONENT_ENABLE 11993 /** 11994 * extract_dfs_cac_complete_event_tlv() - extract cac complete event 11995 * @wmi_handle: wma handle 11996 * @evt_buf: event buffer 11997 * @vdev_id: vdev id 11998 * @len: length of buffer 11999 * 12000 * Return: 0 for success or error code 12001 */ 12002 static QDF_STATUS extract_dfs_cac_complete_event_tlv(wmi_unified_t wmi_handle, 12003 uint8_t *evt_buf, 12004 uint32_t *vdev_id, 12005 uint32_t len) 12006 { 12007 WMI_VDEV_DFS_CAC_COMPLETE_EVENTID_param_tlvs *param_tlvs; 12008 wmi_vdev_dfs_cac_complete_event_fixed_param *cac_event; 12009 12010 param_tlvs = (WMI_VDEV_DFS_CAC_COMPLETE_EVENTID_param_tlvs *) evt_buf; 12011 if (!param_tlvs) { 12012 WMI_LOGE("invalid cac complete event buf"); 12013 return QDF_STATUS_E_FAILURE; 12014 } 12015 12016 cac_event = param_tlvs->fixed_param; 12017 *vdev_id = cac_event->vdev_id; 12018 WMI_LOGD("processed cac complete event vdev %d", *vdev_id); 12019 12020 return QDF_STATUS_SUCCESS; 12021 } 12022 12023 /** 12024 * extract_dfs_ocac_complete_event_tlv() - extract cac complete event 12025 * @wmi_handle: wma handle 12026 * @evt_buf: event buffer 12027 * @vdev_id: vdev id 12028 * @len: length of buffer 12029 * 12030 * Return: 0 for success or error code 12031 */ 12032 static QDF_STATUS 12033 extract_dfs_ocac_complete_event_tlv(wmi_unified_t wmi_handle, 12034 uint8_t *evt_buf, 12035 struct vdev_adfs_complete_status *param) 12036 { 12037 WMI_VDEV_ADFS_OCAC_COMPLETE_EVENTID_param_tlvs *param_tlvs; 12038 wmi_vdev_adfs_ocac_complete_event_fixed_param *ocac_complete_status; 12039 12040 param_tlvs = (WMI_VDEV_ADFS_OCAC_COMPLETE_EVENTID_param_tlvs *)evt_buf; 12041 if (!param_tlvs) { 12042 WMI_LOGE("invalid ocac complete event buf"); 12043 return QDF_STATUS_E_FAILURE; 12044 } 12045 12046 if (!param_tlvs->fixed_param) { 12047 WMI_LOGE("invalid param_tlvs->fixed_param"); 12048 return QDF_STATUS_E_FAILURE; 12049 } 12050 12051 ocac_complete_status = param_tlvs->fixed_param; 12052 param->vdev_id = ocac_complete_status->vdev_id; 12053 param->chan_freq = ocac_complete_status->chan_freq; 12054 param->center_freq = ocac_complete_status->center_freq; 12055 param->ocac_status = ocac_complete_status->status; 12056 param->chan_width = ocac_complete_status->chan_width; 12057 WMI_LOGD("processed ocac complete event vdev %d agile chan %d", 12058 param->vdev_id, param->center_freq); 12059 12060 return QDF_STATUS_SUCCESS; 12061 } 12062 12063 /** 12064 * extract_dfs_radar_detection_event_tlv() - extract radar found event 12065 * @wmi_handle: wma handle 12066 * @evt_buf: event buffer 12067 * @radar_found: radar found event info 12068 * @len: length of buffer 12069 * 12070 * Return: 0 for success or error code 12071 */ 12072 static QDF_STATUS extract_dfs_radar_detection_event_tlv( 12073 wmi_unified_t wmi_handle, 12074 uint8_t *evt_buf, 12075 struct radar_found_info *radar_found, 12076 uint32_t len) 12077 { 12078 WMI_PDEV_DFS_RADAR_DETECTION_EVENTID_param_tlvs *param_tlv; 12079 wmi_pdev_dfs_radar_detection_event_fixed_param *radar_event; 12080 12081 param_tlv = (WMI_PDEV_DFS_RADAR_DETECTION_EVENTID_param_tlvs *) evt_buf; 12082 if (!param_tlv) { 12083 WMI_LOGE("invalid radar detection event buf"); 12084 return QDF_STATUS_E_FAILURE; 12085 } 12086 12087 radar_event = param_tlv->fixed_param; 12088 12089 radar_found->pdev_id = convert_target_pdev_id_to_host_pdev_id( 12090 wmi_handle, 12091 radar_event->pdev_id); 12092 12093 if (radar_found->pdev_id == WMI_HOST_PDEV_ID_INVALID) 12094 return QDF_STATUS_E_FAILURE; 12095 12096 radar_found->detection_mode = radar_event->detection_mode; 12097 radar_found->chan_freq = radar_event->chan_freq; 12098 radar_found->chan_width = radar_event->chan_width; 12099 radar_found->detector_id = radar_event->detector_id; 12100 radar_found->segment_id = radar_event->segment_id; 12101 radar_found->timestamp = radar_event->timestamp; 12102 radar_found->is_chirp = radar_event->is_chirp; 12103 radar_found->freq_offset = radar_event->freq_offset; 12104 radar_found->sidx = radar_event->sidx; 12105 12106 WMI_LOGI("processed radar found event pdev %d," 12107 "Radar Event Info:pdev_id %d,timestamp %d,chan_freq (dur) %d," 12108 "chan_width (RSSI) %d,detector_id (false_radar) %d," 12109 "freq_offset (radar_check) %d,segment_id %d,sidx %d," 12110 "is_chirp %d,detection mode %d", 12111 radar_event->pdev_id, radar_found->pdev_id, 12112 radar_event->timestamp, radar_event->chan_freq, 12113 radar_event->chan_width, radar_event->detector_id, 12114 radar_event->freq_offset, radar_event->segment_id, 12115 radar_event->sidx, radar_event->is_chirp, 12116 radar_event->detection_mode); 12117 12118 return QDF_STATUS_SUCCESS; 12119 } 12120 12121 #ifdef QCA_MCL_DFS_SUPPORT 12122 /** 12123 * extract_wlan_radar_event_info_tlv() - extract radar pulse event 12124 * @wmi_handle: wma handle 12125 * @evt_buf: event buffer 12126 * @wlan_radar_event: Pointer to struct radar_event_info 12127 * @len: length of buffer 12128 * 12129 * Return: QDF_STATUS 12130 */ 12131 static QDF_STATUS extract_wlan_radar_event_info_tlv( 12132 wmi_unified_t wmi_handle, 12133 uint8_t *evt_buf, 12134 struct radar_event_info *wlan_radar_event, 12135 uint32_t len) 12136 { 12137 WMI_DFS_RADAR_EVENTID_param_tlvs *param_tlv; 12138 wmi_dfs_radar_event_fixed_param *radar_event; 12139 12140 param_tlv = (WMI_DFS_RADAR_EVENTID_param_tlvs *)evt_buf; 12141 if (!param_tlv) { 12142 WMI_LOGE("invalid wlan radar event buf"); 12143 return QDF_STATUS_E_FAILURE; 12144 } 12145 12146 radar_event = param_tlv->fixed_param; 12147 wlan_radar_event->pulse_is_chirp = radar_event->pulse_is_chirp; 12148 wlan_radar_event->pulse_center_freq = radar_event->pulse_center_freq; 12149 wlan_radar_event->pulse_duration = radar_event->pulse_duration; 12150 wlan_radar_event->rssi = radar_event->rssi; 12151 wlan_radar_event->pulse_detect_ts = radar_event->pulse_detect_ts; 12152 wlan_radar_event->upload_fullts_high = radar_event->upload_fullts_high; 12153 wlan_radar_event->upload_fullts_low = radar_event->upload_fullts_low; 12154 wlan_radar_event->peak_sidx = radar_event->peak_sidx; 12155 wlan_radar_event->delta_peak = radar_event->pulse_delta_peak; 12156 wlan_radar_event->delta_diff = radar_event->pulse_delta_diff; 12157 if (radar_event->pulse_flags & 12158 WMI_DFS_RADAR_PULSE_FLAG_MASK_PSIDX_DIFF_VALID) { 12159 wlan_radar_event->is_psidx_diff_valid = true; 12160 wlan_radar_event->psidx_diff = radar_event->psidx_diff; 12161 } else { 12162 wlan_radar_event->is_psidx_diff_valid = false; 12163 } 12164 12165 wlan_radar_event->pdev_id = radar_event->pdev_id; 12166 12167 return QDF_STATUS_SUCCESS; 12168 } 12169 #else 12170 static QDF_STATUS extract_wlan_radar_event_info_tlv( 12171 wmi_unified_t wmi_handle, 12172 uint8_t *evt_buf, 12173 struct radar_event_info *wlan_radar_event, 12174 uint32_t len) 12175 { 12176 return QDF_STATUS_SUCCESS; 12177 } 12178 #endif 12179 #endif 12180 12181 /** 12182 * send_get_rcpi_cmd_tlv() - send request for rcpi value 12183 * @wmi_handle: wmi handle 12184 * @get_rcpi_param: rcpi params 12185 * 12186 * Return: QDF status 12187 */ 12188 static QDF_STATUS send_get_rcpi_cmd_tlv(wmi_unified_t wmi_handle, 12189 struct rcpi_req *get_rcpi_param) 12190 { 12191 wmi_buf_t buf; 12192 wmi_request_rcpi_cmd_fixed_param *cmd; 12193 uint8_t len = sizeof(wmi_request_rcpi_cmd_fixed_param); 12194 12195 buf = wmi_buf_alloc(wmi_handle, len); 12196 if (!buf) 12197 return QDF_STATUS_E_NOMEM; 12198 12199 cmd = (wmi_request_rcpi_cmd_fixed_param *) wmi_buf_data(buf); 12200 WMITLV_SET_HDR(&cmd->tlv_header, 12201 WMITLV_TAG_STRUC_wmi_request_rcpi_cmd_fixed_param, 12202 WMITLV_GET_STRUCT_TLVLEN 12203 (wmi_request_rcpi_cmd_fixed_param)); 12204 12205 cmd->vdev_id = get_rcpi_param->vdev_id; 12206 WMI_CHAR_ARRAY_TO_MAC_ADDR(get_rcpi_param->mac_addr, 12207 &cmd->peer_macaddr); 12208 12209 switch (get_rcpi_param->measurement_type) { 12210 12211 case RCPI_MEASUREMENT_TYPE_AVG_MGMT: 12212 cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_AVG_MGMT; 12213 break; 12214 12215 case RCPI_MEASUREMENT_TYPE_AVG_DATA: 12216 cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_AVG_DATA; 12217 break; 12218 12219 case RCPI_MEASUREMENT_TYPE_LAST_MGMT: 12220 cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_LAST_MGMT; 12221 break; 12222 12223 case RCPI_MEASUREMENT_TYPE_LAST_DATA: 12224 cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_LAST_DATA; 12225 break; 12226 12227 default: 12228 /* 12229 * invalid rcpi measurement type, fall back to 12230 * RCPI_MEASUREMENT_TYPE_AVG_MGMT 12231 */ 12232 cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_AVG_MGMT; 12233 break; 12234 } 12235 WMI_LOGD("RCPI REQ VDEV_ID:%d-->", cmd->vdev_id); 12236 wmi_mtrace(WMI_REQUEST_RCPI_CMDID, cmd->vdev_id, 0); 12237 if (wmi_unified_cmd_send(wmi_handle, buf, len, 12238 WMI_REQUEST_RCPI_CMDID)) { 12239 12240 WMI_LOGE("%s: Failed to send WMI_REQUEST_RCPI_CMDID", 12241 __func__); 12242 wmi_buf_free(buf); 12243 return QDF_STATUS_E_FAILURE; 12244 } 12245 12246 return QDF_STATUS_SUCCESS; 12247 } 12248 12249 /** 12250 * extract_rcpi_response_event_tlv() - Extract RCPI event params 12251 * @wmi_handle: wmi handle 12252 * @evt_buf: pointer to event buffer 12253 * @res: pointer to hold rcpi response from firmware 12254 * 12255 * Return: QDF_STATUS_SUCCESS for successful event parse 12256 * else QDF_STATUS_E_INVAL or QDF_STATUS_E_FAILURE 12257 */ 12258 static QDF_STATUS 12259 extract_rcpi_response_event_tlv(wmi_unified_t wmi_handle, 12260 void *evt_buf, struct rcpi_res *res) 12261 { 12262 WMI_UPDATE_RCPI_EVENTID_param_tlvs *param_buf; 12263 wmi_update_rcpi_event_fixed_param *event; 12264 12265 param_buf = (WMI_UPDATE_RCPI_EVENTID_param_tlvs *)evt_buf; 12266 if (!param_buf) { 12267 WMI_LOGE(FL("Invalid rcpi event")); 12268 return QDF_STATUS_E_INVAL; 12269 } 12270 12271 event = param_buf->fixed_param; 12272 res->vdev_id = event->vdev_id; 12273 WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, res->mac_addr); 12274 12275 switch (event->measurement_type) { 12276 12277 case WMI_RCPI_MEASUREMENT_TYPE_AVG_MGMT: 12278 res->measurement_type = RCPI_MEASUREMENT_TYPE_AVG_MGMT; 12279 break; 12280 12281 case WMI_RCPI_MEASUREMENT_TYPE_AVG_DATA: 12282 res->measurement_type = RCPI_MEASUREMENT_TYPE_AVG_DATA; 12283 break; 12284 12285 case WMI_RCPI_MEASUREMENT_TYPE_LAST_MGMT: 12286 res->measurement_type = RCPI_MEASUREMENT_TYPE_LAST_MGMT; 12287 break; 12288 12289 case WMI_RCPI_MEASUREMENT_TYPE_LAST_DATA: 12290 res->measurement_type = RCPI_MEASUREMENT_TYPE_LAST_DATA; 12291 break; 12292 12293 default: 12294 WMI_LOGE(FL("Invalid rcpi measurement type from firmware")); 12295 res->measurement_type = RCPI_MEASUREMENT_TYPE_INVALID; 12296 return QDF_STATUS_E_FAILURE; 12297 } 12298 12299 if (event->status) 12300 return QDF_STATUS_E_FAILURE; 12301 else 12302 return QDF_STATUS_SUCCESS; 12303 } 12304 12305 /** 12306 * convert_host_pdev_id_to_target_pdev_id_legacy() - Convert pdev_id from 12307 * host to target defines. For legacy there is not conversion 12308 * required. Just return pdev_id as it is. 12309 * @param pdev_id: host pdev_id to be converted. 12310 * Return: target pdev_id after conversion. 12311 */ 12312 static uint32_t convert_host_pdev_id_to_target_pdev_id_legacy( 12313 wmi_unified_t wmi_handle, 12314 uint32_t pdev_id) 12315 { 12316 if (pdev_id == WMI_HOST_PDEV_ID_SOC) 12317 return WMI_PDEV_ID_SOC; 12318 12319 /*No conversion required*/ 12320 return pdev_id; 12321 } 12322 12323 /** 12324 * convert_target_pdev_id_to_host_pdev_id_legacy() - Convert pdev_id from 12325 * target to host defines. For legacy there is not conversion 12326 * required. Just return pdev_id as it is. 12327 * @param pdev_id: target pdev_id to be converted. 12328 * Return: host pdev_id after conversion. 12329 */ 12330 static uint32_t convert_target_pdev_id_to_host_pdev_id_legacy( 12331 wmi_unified_t wmi_handle, 12332 uint32_t pdev_id) 12333 { 12334 /*No conversion required*/ 12335 return pdev_id; 12336 } 12337 12338 /** 12339 * convert_host_phy_id_to_target_phy_id_legacy() - Convert phy_id from 12340 * host to target defines. For legacy there is not conversion 12341 * required. Just return phy_id as it is. 12342 * @param pdev_id: host phy_id to be converted. 12343 * Return: target phy_id after conversion. 12344 */ 12345 static uint32_t convert_host_phy_id_to_target_phy_id_legacy( 12346 wmi_unified_t wmi_handle, 12347 uint32_t phy_id) 12348 { 12349 /*No conversion required*/ 12350 return phy_id; 12351 } 12352 12353 /** 12354 * convert_target_phy_id_to_host_phy_id_legacy() - Convert phy_id from 12355 * target to host defines. For legacy there is not conversion 12356 * required. Just return phy_id as it is. 12357 * @param pdev_id: target phy_id to be converted. 12358 * Return: host phy_id after conversion. 12359 */ 12360 static uint32_t convert_target_phy_id_to_host_phy_id_legacy( 12361 wmi_unified_t wmi_handle, 12362 uint32_t phy_id) 12363 { 12364 /*No conversion required*/ 12365 return phy_id; 12366 } 12367 12368 /** 12369 * send_set_country_cmd_tlv() - WMI scan channel list function 12370 * @param wmi_handle : handle to WMI. 12371 * @param param : pointer to hold scan channel list parameter 12372 * 12373 * Return: 0 on success and -ve on failure. 12374 */ 12375 static QDF_STATUS send_set_country_cmd_tlv(wmi_unified_t wmi_handle, 12376 struct set_country *params) 12377 { 12378 wmi_buf_t buf; 12379 QDF_STATUS qdf_status; 12380 wmi_set_current_country_cmd_fixed_param *cmd; 12381 uint16_t len = sizeof(*cmd); 12382 uint8_t pdev_id = params->pdev_id; 12383 12384 buf = wmi_buf_alloc(wmi_handle, len); 12385 if (!buf) { 12386 qdf_status = QDF_STATUS_E_NOMEM; 12387 goto end; 12388 } 12389 12390 cmd = (wmi_set_current_country_cmd_fixed_param *)wmi_buf_data(buf); 12391 WMITLV_SET_HDR(&cmd->tlv_header, 12392 WMITLV_TAG_STRUC_wmi_set_current_country_cmd_fixed_param, 12393 WMITLV_GET_STRUCT_TLVLEN 12394 (wmi_set_current_country_cmd_fixed_param)); 12395 12396 cmd->pdev_id = wmi_handle->ops->convert_host_pdev_id_to_target( 12397 wmi_handle, 12398 pdev_id); 12399 WMI_LOGD("setting current country to %s and target pdev_id = %u", 12400 params->country, cmd->pdev_id); 12401 12402 qdf_mem_copy((uint8_t *)&cmd->new_alpha2, params->country, 3); 12403 12404 wmi_mtrace(WMI_SET_CURRENT_COUNTRY_CMDID, NO_SESSION, 0); 12405 qdf_status = wmi_unified_cmd_send(wmi_handle, 12406 buf, len, WMI_SET_CURRENT_COUNTRY_CMDID); 12407 12408 if (QDF_IS_STATUS_ERROR(qdf_status)) { 12409 WMI_LOGE("Failed to send WMI_SET_CURRENT_COUNTRY_CMDID"); 12410 wmi_buf_free(buf); 12411 } 12412 12413 end: 12414 return qdf_status; 12415 } 12416 12417 #define WMI_REG_COUNTRY_ALPHA_SET(alpha, val0, val1, val2) do { \ 12418 WMI_SET_BITS(alpha, 0, 8, val0); \ 12419 WMI_SET_BITS(alpha, 8, 8, val1); \ 12420 WMI_SET_BITS(alpha, 16, 8, val2); \ 12421 } while (0) 12422 12423 static QDF_STATUS send_user_country_code_cmd_tlv(wmi_unified_t wmi_handle, 12424 uint8_t pdev_id, struct cc_regdmn_s *rd) 12425 { 12426 wmi_set_init_country_cmd_fixed_param *cmd; 12427 uint16_t len; 12428 wmi_buf_t buf; 12429 int ret; 12430 12431 len = sizeof(wmi_set_init_country_cmd_fixed_param); 12432 buf = wmi_buf_alloc(wmi_handle, len); 12433 if (!buf) 12434 return QDF_STATUS_E_NOMEM; 12435 12436 cmd = (wmi_set_init_country_cmd_fixed_param *) wmi_buf_data(buf); 12437 WMITLV_SET_HDR(&cmd->tlv_header, 12438 WMITLV_TAG_STRUC_wmi_set_init_country_cmd_fixed_param, 12439 WMITLV_GET_STRUCT_TLVLEN 12440 (wmi_set_init_country_cmd_fixed_param)); 12441 12442 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 12443 wmi_handle, 12444 pdev_id); 12445 12446 if (rd->flags == CC_IS_SET) { 12447 cmd->countrycode_type = WMI_COUNTRYCODE_COUNTRY_ID; 12448 cmd->country_code.country_id = rd->cc.country_code; 12449 } else if (rd->flags == ALPHA_IS_SET) { 12450 cmd->countrycode_type = WMI_COUNTRYCODE_ALPHA2; 12451 WMI_REG_COUNTRY_ALPHA_SET(cmd->country_code.alpha2, 12452 rd->cc.alpha[0], 12453 rd->cc.alpha[1], 12454 rd->cc.alpha[2]); 12455 } else if (rd->flags == REGDMN_IS_SET) { 12456 cmd->countrycode_type = WMI_COUNTRYCODE_DOMAIN_CODE; 12457 cmd->country_code.domain_code = rd->cc.regdmn_id; 12458 } 12459 12460 wmi_mtrace(WMI_SET_INIT_COUNTRY_CMDID, NO_SESSION, 0); 12461 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 12462 WMI_SET_INIT_COUNTRY_CMDID); 12463 if (ret) { 12464 WMI_LOGE("Failed to config wow wakeup event"); 12465 wmi_buf_free(buf); 12466 return QDF_STATUS_E_FAILURE; 12467 } 12468 12469 return QDF_STATUS_SUCCESS; 12470 } 12471 12472 /** 12473 * send_obss_detection_cfg_cmd_tlv() - send obss detection 12474 * configurations to firmware. 12475 * @wmi_handle: wmi handle 12476 * @obss_cfg_param: obss detection configurations 12477 * 12478 * Send WMI_SAP_OBSS_DETECTION_CFG_CMDID parameters to fw. 12479 * 12480 * Return: QDF_STATUS 12481 */ 12482 static QDF_STATUS send_obss_detection_cfg_cmd_tlv(wmi_unified_t wmi_handle, 12483 struct wmi_obss_detection_cfg_param *obss_cfg_param) 12484 { 12485 wmi_buf_t buf; 12486 wmi_sap_obss_detection_cfg_cmd_fixed_param *cmd; 12487 uint8_t len = sizeof(wmi_sap_obss_detection_cfg_cmd_fixed_param); 12488 12489 buf = wmi_buf_alloc(wmi_handle, len); 12490 if (!buf) 12491 return QDF_STATUS_E_NOMEM; 12492 12493 cmd = (wmi_sap_obss_detection_cfg_cmd_fixed_param *)wmi_buf_data(buf); 12494 WMITLV_SET_HDR(&cmd->tlv_header, 12495 WMITLV_TAG_STRUC_wmi_sap_obss_detection_cfg_cmd_fixed_param, 12496 WMITLV_GET_STRUCT_TLVLEN 12497 (wmi_sap_obss_detection_cfg_cmd_fixed_param)); 12498 12499 cmd->vdev_id = obss_cfg_param->vdev_id; 12500 cmd->detect_period_ms = obss_cfg_param->obss_detect_period_ms; 12501 cmd->b_ap_detect_mode = obss_cfg_param->obss_11b_ap_detect_mode; 12502 cmd->b_sta_detect_mode = obss_cfg_param->obss_11b_sta_detect_mode; 12503 cmd->g_ap_detect_mode = obss_cfg_param->obss_11g_ap_detect_mode; 12504 cmd->a_detect_mode = obss_cfg_param->obss_11a_detect_mode; 12505 cmd->ht_legacy_detect_mode = obss_cfg_param->obss_ht_legacy_detect_mode; 12506 cmd->ht_mixed_detect_mode = obss_cfg_param->obss_ht_mixed_detect_mode; 12507 cmd->ht_20mhz_detect_mode = obss_cfg_param->obss_ht_20mhz_detect_mode; 12508 12509 wmi_mtrace(WMI_SAP_OBSS_DETECTION_CFG_CMDID, cmd->vdev_id, 0); 12510 if (wmi_unified_cmd_send(wmi_handle, buf, len, 12511 WMI_SAP_OBSS_DETECTION_CFG_CMDID)) { 12512 WMI_LOGE("Failed to send WMI_SAP_OBSS_DETECTION_CFG_CMDID"); 12513 wmi_buf_free(buf); 12514 return QDF_STATUS_E_FAILURE; 12515 } 12516 12517 return QDF_STATUS_SUCCESS; 12518 } 12519 12520 /** 12521 * extract_obss_detection_info_tlv() - Extract obss detection info 12522 * received from firmware. 12523 * @evt_buf: pointer to event buffer 12524 * @obss_detection: Pointer to hold obss detection info 12525 * 12526 * Return: QDF_STATUS 12527 */ 12528 static QDF_STATUS extract_obss_detection_info_tlv(uint8_t *evt_buf, 12529 struct wmi_obss_detect_info 12530 *obss_detection) 12531 { 12532 WMI_SAP_OBSS_DETECTION_REPORT_EVENTID_param_tlvs *param_buf; 12533 wmi_sap_obss_detection_info_evt_fixed_param *fix_param; 12534 12535 if (!obss_detection) { 12536 WMI_LOGE("%s: Invalid obss_detection event buffer", __func__); 12537 return QDF_STATUS_E_INVAL; 12538 } 12539 12540 param_buf = (WMI_SAP_OBSS_DETECTION_REPORT_EVENTID_param_tlvs *)evt_buf; 12541 if (!param_buf) { 12542 WMI_LOGE("%s: Invalid evt_buf", __func__); 12543 return QDF_STATUS_E_INVAL; 12544 } 12545 12546 fix_param = param_buf->fixed_param; 12547 obss_detection->vdev_id = fix_param->vdev_id; 12548 obss_detection->matched_detection_masks = 12549 fix_param->matched_detection_masks; 12550 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fix_param->matched_bssid_addr, 12551 &obss_detection->matched_bssid_addr[0]); 12552 switch (fix_param->reason) { 12553 case WMI_SAP_OBSS_DETECTION_EVENT_REASON_NOT_SUPPORT: 12554 obss_detection->reason = OBSS_OFFLOAD_DETECTION_DISABLED; 12555 break; 12556 case WMI_SAP_OBSS_DETECTION_EVENT_REASON_PRESENT_NOTIFY: 12557 obss_detection->reason = OBSS_OFFLOAD_DETECTION_PRESENT; 12558 break; 12559 case WMI_SAP_OBSS_DETECTION_EVENT_REASON_ABSENT_TIMEOUT: 12560 obss_detection->reason = OBSS_OFFLOAD_DETECTION_ABSENT; 12561 break; 12562 default: 12563 WMI_LOGE("%s: Invalid reason %d", __func__, fix_param->reason); 12564 return QDF_STATUS_E_INVAL; 12565 } 12566 12567 return QDF_STATUS_SUCCESS; 12568 } 12569 12570 /** 12571 * send_roam_scan_stats_cmd_tlv() - Send roam scan stats req command to fw 12572 * @wmi_handle: wmi handle 12573 * @params: pointer to request structure 12574 * 12575 * Return: QDF_STATUS 12576 */ 12577 static QDF_STATUS 12578 send_roam_scan_stats_cmd_tlv(wmi_unified_t wmi_handle, 12579 struct wmi_roam_scan_stats_req *params) 12580 { 12581 wmi_buf_t buf; 12582 wmi_request_roam_scan_stats_cmd_fixed_param *cmd; 12583 WMITLV_TAG_ID tag; 12584 uint32_t size; 12585 uint32_t len = sizeof(*cmd); 12586 12587 buf = wmi_buf_alloc(wmi_handle, len); 12588 if (!buf) 12589 return QDF_STATUS_E_FAILURE; 12590 12591 cmd = (wmi_request_roam_scan_stats_cmd_fixed_param *)wmi_buf_data(buf); 12592 12593 tag = WMITLV_TAG_STRUC_wmi_request_roam_scan_stats_cmd_fixed_param; 12594 size = WMITLV_GET_STRUCT_TLVLEN( 12595 wmi_request_roam_scan_stats_cmd_fixed_param); 12596 WMITLV_SET_HDR(&cmd->tlv_header, tag, size); 12597 12598 cmd->vdev_id = params->vdev_id; 12599 12600 WMI_LOGD(FL("Roam Scan Stats Req vdev_id: %u"), cmd->vdev_id); 12601 if (wmi_unified_cmd_send(wmi_handle, buf, len, 12602 WMI_REQUEST_ROAM_SCAN_STATS_CMDID)) { 12603 WMI_LOGE("%s: Failed to send WMI_REQUEST_ROAM_SCAN_STATS_CMDID", 12604 __func__); 12605 wmi_buf_free(buf); 12606 return QDF_STATUS_E_FAILURE; 12607 } 12608 12609 return QDF_STATUS_SUCCESS; 12610 } 12611 12612 /** 12613 * send_roam_scan_ch_list_req_cmd_tlv() - send wmi cmd to get roam scan 12614 * channel list from firmware 12615 * @wmi_handle: wmi handler 12616 * @vdev_id: vdev id 12617 * 12618 * Return: QDF_STATUS 12619 */ 12620 static QDF_STATUS send_roam_scan_ch_list_req_cmd_tlv(wmi_unified_t wmi_handle, 12621 uint32_t vdev_id) 12622 { 12623 wmi_buf_t buf; 12624 wmi_roam_get_scan_channel_list_cmd_fixed_param *cmd; 12625 uint16_t len = sizeof(*cmd); 12626 int ret; 12627 12628 buf = wmi_buf_alloc(wmi_handle, len); 12629 if (!buf) { 12630 WMI_LOGE("%s: Failed to allocate wmi buffer", __func__); 12631 return QDF_STATUS_E_NOMEM; 12632 } 12633 12634 cmd = (wmi_roam_get_scan_channel_list_cmd_fixed_param *) 12635 wmi_buf_data(buf); 12636 WMITLV_SET_HDR(&cmd->tlv_header, 12637 WMITLV_TAG_STRUC_wmi_roam_get_scan_channel_list_cmd_fixed_param, 12638 WMITLV_GET_STRUCT_TLVLEN( 12639 wmi_roam_get_scan_channel_list_cmd_fixed_param)); 12640 cmd->vdev_id = vdev_id; 12641 wmi_mtrace(WMI_ROAM_GET_SCAN_CHANNEL_LIST_CMDID, vdev_id, 0); 12642 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 12643 WMI_ROAM_GET_SCAN_CHANNEL_LIST_CMDID); 12644 if (QDF_IS_STATUS_ERROR(ret)) { 12645 WMI_LOGE("Failed to send get roam scan channels request = %d", 12646 ret); 12647 wmi_buf_free(buf); 12648 } 12649 return ret; 12650 } 12651 12652 /** 12653 * extract_roam_scan_stats_res_evt_tlv() - Extract roam scan stats event 12654 * @wmi_handle: wmi handle 12655 * @evt_buf: pointer to event buffer 12656 * @vdev_id: output pointer to hold vdev id 12657 * @res_param: output pointer to hold the allocated response 12658 * 12659 * Return: QDF_STATUS 12660 */ 12661 static QDF_STATUS 12662 extract_roam_scan_stats_res_evt_tlv(wmi_unified_t wmi_handle, void *evt_buf, 12663 uint32_t *vdev_id, 12664 struct wmi_roam_scan_stats_res **res_param) 12665 { 12666 WMI_ROAM_SCAN_STATS_EVENTID_param_tlvs *param_buf; 12667 wmi_roam_scan_stats_event_fixed_param *fixed_param; 12668 uint32_t *client_id = NULL; 12669 wmi_roaming_timestamp *timestamp = NULL; 12670 uint32_t *num_channels = NULL; 12671 uint32_t *chan_info = NULL; 12672 wmi_mac_addr *old_bssid = NULL; 12673 uint32_t *is_roaming_success = NULL; 12674 wmi_mac_addr *new_bssid = NULL; 12675 uint32_t *num_roam_candidates = NULL; 12676 wmi_roam_scan_trigger_reason *roam_reason = NULL; 12677 wmi_mac_addr *bssid = NULL; 12678 uint32_t *score = NULL; 12679 uint32_t *channel = NULL; 12680 uint32_t *rssi = NULL; 12681 int chan_idx = 0, cand_idx = 0; 12682 uint32_t total_len; 12683 struct wmi_roam_scan_stats_res *res; 12684 uint32_t i, j; 12685 uint32_t num_scans, scan_param_size; 12686 12687 *res_param = NULL; 12688 *vdev_id = 0xFF; /* Initialize to invalid vdev id */ 12689 param_buf = (WMI_ROAM_SCAN_STATS_EVENTID_param_tlvs *)evt_buf; 12690 if (!param_buf) { 12691 WMI_LOGE(FL("Invalid roam scan stats event")); 12692 return QDF_STATUS_E_INVAL; 12693 } 12694 12695 fixed_param = param_buf->fixed_param; 12696 12697 num_scans = fixed_param->num_roam_scans; 12698 scan_param_size = sizeof(struct wmi_roam_scan_stats_params); 12699 *vdev_id = fixed_param->vdev_id; 12700 if (num_scans > WMI_ROAM_SCAN_STATS_MAX) { 12701 wmi_err_rl("%u exceeded maximum roam scan stats: %u", 12702 num_scans, WMI_ROAM_SCAN_STATS_MAX); 12703 return QDF_STATUS_E_INVAL; 12704 } 12705 12706 total_len = sizeof(*res) + num_scans * scan_param_size; 12707 12708 res = qdf_mem_malloc(total_len); 12709 if (!res) 12710 return QDF_STATUS_E_NOMEM; 12711 12712 if (!num_scans) { 12713 *res_param = res; 12714 return QDF_STATUS_SUCCESS; 12715 } 12716 12717 if (param_buf->client_id && 12718 param_buf->num_client_id == num_scans) 12719 client_id = param_buf->client_id; 12720 12721 if (param_buf->timestamp && 12722 param_buf->num_timestamp == num_scans) 12723 timestamp = param_buf->timestamp; 12724 12725 if (param_buf->old_bssid && 12726 param_buf->num_old_bssid == num_scans) 12727 old_bssid = param_buf->old_bssid; 12728 12729 if (param_buf->new_bssid && 12730 param_buf->num_new_bssid == num_scans) 12731 new_bssid = param_buf->new_bssid; 12732 12733 if (param_buf->is_roaming_success && 12734 param_buf->num_is_roaming_success == num_scans) 12735 is_roaming_success = param_buf->is_roaming_success; 12736 12737 if (param_buf->roam_reason && 12738 param_buf->num_roam_reason == num_scans) 12739 roam_reason = param_buf->roam_reason; 12740 12741 if (param_buf->num_channels && 12742 param_buf->num_num_channels == num_scans) { 12743 uint32_t count, chan_info_sum = 0; 12744 12745 num_channels = param_buf->num_channels; 12746 for (count = 0; count < param_buf->num_num_channels; count++) { 12747 if (param_buf->num_channels[count] > 12748 WMI_ROAM_SCAN_STATS_CHANNELS_MAX) { 12749 wmi_err_rl("%u exceeded max scan channels %u", 12750 param_buf->num_channels[count], 12751 WMI_ROAM_SCAN_STATS_CHANNELS_MAX); 12752 goto error; 12753 } 12754 chan_info_sum += param_buf->num_channels[count]; 12755 } 12756 12757 if (param_buf->chan_info && 12758 param_buf->num_chan_info == chan_info_sum) 12759 chan_info = param_buf->chan_info; 12760 } 12761 12762 if (param_buf->num_roam_candidates && 12763 param_buf->num_num_roam_candidates == num_scans) { 12764 uint32_t cnt, roam_cand_sum = 0; 12765 12766 num_roam_candidates = param_buf->num_roam_candidates; 12767 for (cnt = 0; cnt < param_buf->num_num_roam_candidates; cnt++) { 12768 if (param_buf->num_roam_candidates[cnt] > 12769 WMI_ROAM_SCAN_STATS_CANDIDATES_MAX) { 12770 wmi_err_rl("%u exceeded max scan cand %u", 12771 param_buf->num_roam_candidates[cnt], 12772 WMI_ROAM_SCAN_STATS_CANDIDATES_MAX); 12773 goto error; 12774 } 12775 roam_cand_sum += param_buf->num_roam_candidates[cnt]; 12776 } 12777 12778 if (param_buf->bssid && 12779 param_buf->num_bssid == roam_cand_sum) 12780 bssid = param_buf->bssid; 12781 12782 if (param_buf->score && 12783 param_buf->num_score == roam_cand_sum) 12784 score = param_buf->score; 12785 12786 if (param_buf->channel && 12787 param_buf->num_channel == roam_cand_sum) 12788 channel = param_buf->channel; 12789 12790 if (param_buf->rssi && 12791 param_buf->num_rssi == roam_cand_sum) 12792 rssi = param_buf->rssi; 12793 } 12794 12795 res->num_roam_scans = num_scans; 12796 for (i = 0; i < num_scans; i++) { 12797 struct wmi_roam_scan_stats_params *roam = &res->roam_scan[i]; 12798 12799 if (timestamp) 12800 roam->time_stamp = timestamp[i].lower32bit | 12801 (timestamp[i].upper32bit << 31); 12802 12803 if (client_id) 12804 roam->client_id = client_id[i]; 12805 12806 if (num_channels) { 12807 roam->num_scan_chans = num_channels[i]; 12808 if (chan_info) { 12809 for (j = 0; j < num_channels[i]; j++) 12810 roam->scan_freqs[j] = 12811 chan_info[chan_idx++]; 12812 } 12813 } 12814 12815 if (is_roaming_success) 12816 roam->is_roam_successful = is_roaming_success[i]; 12817 12818 if (roam_reason) { 12819 roam->trigger_id = roam_reason[i].trigger_id; 12820 roam->trigger_value = roam_reason[i].trigger_value; 12821 } 12822 12823 if (num_roam_candidates) { 12824 roam->num_roam_candidates = num_roam_candidates[i]; 12825 12826 for (j = 0; j < num_roam_candidates[i]; j++) { 12827 if (score) 12828 roam->cand[j].score = score[cand_idx]; 12829 if (rssi) 12830 roam->cand[j].rssi = rssi[cand_idx]; 12831 if (channel) 12832 roam->cand[j].freq = 12833 channel[cand_idx]; 12834 12835 if (bssid) 12836 WMI_MAC_ADDR_TO_CHAR_ARRAY( 12837 &bssid[cand_idx], 12838 roam->cand[j].bssid); 12839 12840 cand_idx++; 12841 } 12842 } 12843 12844 if (old_bssid) 12845 WMI_MAC_ADDR_TO_CHAR_ARRAY(&old_bssid[i], 12846 roam->old_bssid); 12847 12848 if (new_bssid) 12849 WMI_MAC_ADDR_TO_CHAR_ARRAY(&new_bssid[i], 12850 roam->new_bssid); 12851 } 12852 12853 *res_param = res; 12854 12855 return QDF_STATUS_SUCCESS; 12856 error: 12857 qdf_mem_free(res); 12858 return QDF_STATUS_E_FAILURE; 12859 } 12860 12861 /** 12862 * extract_offload_bcn_tx_status_evt() - Extract beacon-tx status event 12863 * @wmi_handle: wmi handle 12864 * @evt_buf: pointer to event buffer 12865 * @vdev_id: output pointer to hold vdev id 12866 * @tx_status: output pointer to hold the tx_status 12867 * 12868 * Return: QDF_STATUS 12869 */ 12870 static QDF_STATUS extract_offload_bcn_tx_status_evt(wmi_unified_t wmi_handle, 12871 void *evt_buf, 12872 uint32_t *vdev_id, 12873 uint32_t *tx_status) { 12874 WMI_OFFLOAD_BCN_TX_STATUS_EVENTID_param_tlvs *param_buf; 12875 wmi_offload_bcn_tx_status_event_fixed_param *bcn_tx_status_event; 12876 12877 param_buf = (WMI_OFFLOAD_BCN_TX_STATUS_EVENTID_param_tlvs *)evt_buf; 12878 if (!param_buf) { 12879 WMI_LOGE("Invalid offload bcn tx status event buffer"); 12880 return QDF_STATUS_E_INVAL; 12881 } 12882 12883 bcn_tx_status_event = param_buf->fixed_param; 12884 *vdev_id = bcn_tx_status_event->vdev_id; 12885 *tx_status = bcn_tx_status_event->tx_status; 12886 12887 return QDF_STATUS_SUCCESS; 12888 } 12889 12890 #ifdef WLAN_SUPPORT_GREEN_AP 12891 static QDF_STATUS extract_green_ap_egap_status_info_tlv( 12892 uint8_t *evt_buf, 12893 struct wlan_green_ap_egap_status_info *egap_status_info_params) 12894 { 12895 WMI_AP_PS_EGAP_INFO_EVENTID_param_tlvs *param_buf; 12896 wmi_ap_ps_egap_info_event_fixed_param *egap_info_event; 12897 wmi_ap_ps_egap_info_chainmask_list *chainmask_event; 12898 12899 param_buf = (WMI_AP_PS_EGAP_INFO_EVENTID_param_tlvs *)evt_buf; 12900 if (!param_buf) { 12901 WMI_LOGE("Invalid EGAP Info status event buffer"); 12902 return QDF_STATUS_E_INVAL; 12903 } 12904 12905 egap_info_event = (wmi_ap_ps_egap_info_event_fixed_param *) 12906 param_buf->fixed_param; 12907 chainmask_event = (wmi_ap_ps_egap_info_chainmask_list *) 12908 param_buf->chainmask_list; 12909 12910 if (!egap_info_event || !chainmask_event) { 12911 WMI_LOGE("Invalid EGAP Info event or chainmask event"); 12912 return QDF_STATUS_E_INVAL; 12913 } 12914 12915 egap_status_info_params->status = egap_info_event->status; 12916 egap_status_info_params->mac_id = chainmask_event->mac_id; 12917 egap_status_info_params->tx_chainmask = chainmask_event->tx_chainmask; 12918 egap_status_info_params->rx_chainmask = chainmask_event->rx_chainmask; 12919 12920 return QDF_STATUS_SUCCESS; 12921 } 12922 #endif 12923 12924 /* 12925 * extract_comb_phyerr_tlv() - extract comb phy error from event 12926 * @wmi_handle: wmi handle 12927 * @evt_buf: pointer to event buffer 12928 * @datalen: data length of event buffer 12929 * @buf_offset: Pointer to hold value of current event buffer offset 12930 * post extraction 12931 * @phyerr: Pointer to hold phyerr 12932 * 12933 * Return: QDF_STATUS 12934 */ 12935 static QDF_STATUS extract_comb_phyerr_tlv(wmi_unified_t wmi_handle, 12936 void *evt_buf, 12937 uint16_t datalen, 12938 uint16_t *buf_offset, 12939 wmi_host_phyerr_t *phyerr) 12940 { 12941 WMI_PHYERR_EVENTID_param_tlvs *param_tlvs; 12942 wmi_comb_phyerr_rx_hdr *pe_hdr; 12943 12944 param_tlvs = (WMI_PHYERR_EVENTID_param_tlvs *)evt_buf; 12945 if (!param_tlvs) { 12946 WMI_LOGD("%s: Received null data from FW", __func__); 12947 return QDF_STATUS_E_FAILURE; 12948 } 12949 12950 pe_hdr = param_tlvs->hdr; 12951 if (!pe_hdr) { 12952 WMI_LOGD("%s: Received Data PE Header is NULL", __func__); 12953 return QDF_STATUS_E_FAILURE; 12954 } 12955 12956 /* Ensure it's at least the size of the header */ 12957 if (datalen < sizeof(*pe_hdr)) { 12958 WMI_LOGD("%s: Expected minimum size %zu, received %d", 12959 __func__, sizeof(*pe_hdr), datalen); 12960 return QDF_STATUS_E_FAILURE; 12961 } 12962 12963 phyerr->pdev_id = wmi_handle->ops-> 12964 convert_pdev_id_target_to_host(wmi_handle, pe_hdr->pdev_id); 12965 phyerr->tsf64 = pe_hdr->tsf_l32; 12966 phyerr->tsf64 |= (((uint64_t)pe_hdr->tsf_u32) << 32); 12967 phyerr->bufp = param_tlvs->bufp; 12968 12969 if (pe_hdr->buf_len > param_tlvs->num_bufp) { 12970 WMI_LOGD("Invalid buf_len %d, num_bufp %d", 12971 pe_hdr->buf_len, param_tlvs->num_bufp); 12972 return QDF_STATUS_E_FAILURE; 12973 } 12974 12975 phyerr->buf_len = pe_hdr->buf_len; 12976 phyerr->phy_err_mask0 = pe_hdr->rsPhyErrMask0; 12977 phyerr->phy_err_mask1 = pe_hdr->rsPhyErrMask1; 12978 *buf_offset = sizeof(*pe_hdr) + sizeof(uint32_t); 12979 12980 return QDF_STATUS_SUCCESS; 12981 } 12982 12983 /** 12984 * extract_single_phyerr_tlv() - extract single phy error from event 12985 * @wmi_handle: wmi handle 12986 * @evt_buf: pointer to event buffer 12987 * @datalen: data length of event buffer 12988 * @buf_offset: Pointer to hold value of current event buffer offset 12989 * post extraction 12990 * @phyerr: Pointer to hold phyerr 12991 * 12992 * Return: QDF_STATUS 12993 */ 12994 static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle, 12995 void *evt_buf, 12996 uint16_t datalen, 12997 uint16_t *buf_offset, 12998 wmi_host_phyerr_t *phyerr) 12999 { 13000 wmi_single_phyerr_rx_event *ev; 13001 uint16_t n = *buf_offset; 13002 uint8_t *data = (uint8_t *)evt_buf; 13003 13004 if (n < datalen) { 13005 if ((datalen - n) < sizeof(ev->hdr)) { 13006 WMI_LOGD("%s: Not enough space. len=%d, n=%d, hdr=%zu", 13007 __func__, datalen, n, sizeof(ev->hdr)); 13008 return QDF_STATUS_E_FAILURE; 13009 } 13010 13011 /* 13012 * Obtain a pointer to the beginning of the current event. 13013 * data[0] is the beginning of the WMI payload. 13014 */ 13015 ev = (wmi_single_phyerr_rx_event *)&data[n]; 13016 13017 /* 13018 * Sanity check the buffer length of the event against 13019 * what we currently have. 13020 * 13021 * Since buf_len is 32 bits, we check if it overflows 13022 * a large 32 bit value. It's not 0x7fffffff because 13023 * we increase n by (buf_len + sizeof(hdr)), which would 13024 * in itself cause n to overflow. 13025 * 13026 * If "int" is 64 bits then this becomes a moot point. 13027 */ 13028 if (ev->hdr.buf_len > PHYERROR_MAX_BUFFER_LENGTH) { 13029 WMI_LOGD("%s: buf_len is garbage 0x%x", 13030 __func__, ev->hdr.buf_len); 13031 return QDF_STATUS_E_FAILURE; 13032 } 13033 13034 if ((n + ev->hdr.buf_len) > datalen) { 13035 WMI_LOGD("%s: len exceeds n=%d, buf_len=%d, datalen=%d", 13036 __func__, n, ev->hdr.buf_len, datalen); 13037 return QDF_STATUS_E_FAILURE; 13038 } 13039 13040 phyerr->phy_err_code = WMI_UNIFIED_PHYERRCODE_GET(&ev->hdr); 13041 phyerr->tsf_timestamp = ev->hdr.tsf_timestamp; 13042 phyerr->bufp = &ev->bufp[0]; 13043 phyerr->buf_len = ev->hdr.buf_len; 13044 phyerr->rf_info.rssi_comb = WMI_UNIFIED_RSSI_COMB_GET(&ev->hdr); 13045 13046 /* 13047 * Advance the buffer pointer to the next PHY error. 13048 * buflen is the length of this payload, so we need to 13049 * advance past the current header _AND_ the payload. 13050 */ 13051 n += sizeof(*ev) + ev->hdr.buf_len; 13052 } 13053 *buf_offset = n; 13054 13055 return QDF_STATUS_SUCCESS; 13056 } 13057 13058 /** 13059 * extract_esp_estimation_ev_param_tlv() - extract air time from event 13060 * @wmi_handle: wmi handle 13061 * @evt_buf: pointer to event buffer 13062 * @param: Pointer to hold esp event 13063 * 13064 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_INVAL on failure 13065 */ 13066 static QDF_STATUS 13067 extract_esp_estimation_ev_param_tlv(wmi_unified_t wmi_handle, 13068 void *evt_buf, 13069 struct esp_estimation_event *param) 13070 { 13071 WMI_ESP_ESTIMATE_EVENTID_param_tlvs *param_buf; 13072 wmi_esp_estimate_event_fixed_param *esp_event; 13073 13074 param_buf = (WMI_ESP_ESTIMATE_EVENTID_param_tlvs *)evt_buf; 13075 if (!param_buf) { 13076 WMI_LOGE("Invalid ESP Estimate Event buffer"); 13077 return QDF_STATUS_E_INVAL; 13078 } 13079 esp_event = param_buf->fixed_param; 13080 param->ac_airtime_percentage = esp_event->ac_airtime_percentage; 13081 13082 param->pdev_id = convert_target_pdev_id_to_host_pdev_id( 13083 wmi_handle, 13084 esp_event->pdev_id); 13085 13086 if (param->pdev_id == WMI_HOST_PDEV_ID_INVALID) 13087 return QDF_STATUS_E_FAILURE; 13088 13089 return QDF_STATUS_SUCCESS; 13090 } 13091 13092 /* 13093 * send_bss_color_change_enable_cmd_tlv() - Send command to enable or disable of 13094 * updating bss color change within firmware when AP announces bss color change. 13095 * @wmi_handle: wmi handle 13096 * @vdev_id: vdev ID 13097 * @enable: enable bss color change within firmware 13098 * 13099 * Send WMI_BSS_COLOR_CHANGE_ENABLE_CMDID parameters to fw. 13100 * 13101 * Return: QDF_STATUS 13102 */ 13103 static QDF_STATUS send_bss_color_change_enable_cmd_tlv(wmi_unified_t wmi_handle, 13104 uint32_t vdev_id, 13105 bool enable) 13106 { 13107 wmi_buf_t buf; 13108 wmi_bss_color_change_enable_fixed_param *cmd; 13109 uint8_t len = sizeof(wmi_bss_color_change_enable_fixed_param); 13110 13111 buf = wmi_buf_alloc(wmi_handle, len); 13112 if (!buf) 13113 return QDF_STATUS_E_NOMEM; 13114 13115 cmd = (wmi_bss_color_change_enable_fixed_param *)wmi_buf_data(buf); 13116 WMITLV_SET_HDR(&cmd->tlv_header, 13117 WMITLV_TAG_STRUC_wmi_bss_color_change_enable_fixed_param, 13118 WMITLV_GET_STRUCT_TLVLEN 13119 (wmi_bss_color_change_enable_fixed_param)); 13120 cmd->vdev_id = vdev_id; 13121 cmd->enable = enable; 13122 wmi_mtrace(WMI_BSS_COLOR_CHANGE_ENABLE_CMDID, cmd->vdev_id, 0); 13123 if (wmi_unified_cmd_send(wmi_handle, buf, len, 13124 WMI_BSS_COLOR_CHANGE_ENABLE_CMDID)) { 13125 WMI_LOGE("Failed to send WMI_BSS_COLOR_CHANGE_ENABLE_CMDID"); 13126 wmi_buf_free(buf); 13127 return QDF_STATUS_E_FAILURE; 13128 } 13129 13130 return QDF_STATUS_SUCCESS; 13131 } 13132 13133 /** 13134 * send_obss_color_collision_cfg_cmd_tlv() - send bss color detection 13135 * configurations to firmware. 13136 * @wmi_handle: wmi handle 13137 * @cfg_param: obss detection configurations 13138 * 13139 * Send WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID parameters to fw. 13140 * 13141 * Return: QDF_STATUS 13142 */ 13143 static QDF_STATUS send_obss_color_collision_cfg_cmd_tlv( 13144 wmi_unified_t wmi_handle, 13145 struct wmi_obss_color_collision_cfg_param *cfg_param) 13146 { 13147 wmi_buf_t buf; 13148 wmi_obss_color_collision_det_config_fixed_param *cmd; 13149 uint8_t len = sizeof(wmi_obss_color_collision_det_config_fixed_param); 13150 13151 buf = wmi_buf_alloc(wmi_handle, len); 13152 if (!buf) 13153 return QDF_STATUS_E_NOMEM; 13154 13155 cmd = (wmi_obss_color_collision_det_config_fixed_param *)wmi_buf_data( 13156 buf); 13157 WMITLV_SET_HDR(&cmd->tlv_header, 13158 WMITLV_TAG_STRUC_wmi_obss_color_collision_det_config_fixed_param, 13159 WMITLV_GET_STRUCT_TLVLEN 13160 (wmi_obss_color_collision_det_config_fixed_param)); 13161 cmd->vdev_id = cfg_param->vdev_id; 13162 cmd->flags = cfg_param->flags; 13163 cmd->current_bss_color = cfg_param->current_bss_color; 13164 cmd->detection_period_ms = cfg_param->detection_period_ms; 13165 cmd->scan_period_ms = cfg_param->scan_period_ms; 13166 cmd->free_slot_expiry_time_ms = cfg_param->free_slot_expiry_time_ms; 13167 13168 switch (cfg_param->evt_type) { 13169 case OBSS_COLOR_COLLISION_DETECTION_DISABLE: 13170 cmd->evt_type = WMI_BSS_COLOR_COLLISION_DISABLE; 13171 break; 13172 case OBSS_COLOR_COLLISION_DETECTION: 13173 cmd->evt_type = WMI_BSS_COLOR_COLLISION_DETECTION; 13174 break; 13175 case OBSS_COLOR_FREE_SLOT_TIMER_EXPIRY: 13176 cmd->evt_type = WMI_BSS_COLOR_FREE_SLOT_TIMER_EXPIRY; 13177 break; 13178 case OBSS_COLOR_FREE_SLOT_AVAILABLE: 13179 cmd->evt_type = WMI_BSS_COLOR_FREE_SLOT_AVAILABLE; 13180 break; 13181 default: 13182 WMI_LOGE("%s: invalid event type: %d", 13183 __func__, cfg_param->evt_type); 13184 wmi_buf_free(buf); 13185 return QDF_STATUS_E_FAILURE; 13186 } 13187 13188 WMI_LOGD("%s: evt_type: %d vdev id: %d current_bss_color: %d\n" 13189 "detection_period_ms: %d scan_period_ms: %d\n" 13190 "free_slot_expiry_timer_ms: %d", 13191 __func__, cmd->evt_type, cmd->vdev_id, cmd->current_bss_color, 13192 cmd->detection_period_ms, cmd->scan_period_ms, 13193 cmd->free_slot_expiry_time_ms); 13194 13195 wmi_mtrace(WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID, cmd->vdev_id, 0); 13196 if (wmi_unified_cmd_send(wmi_handle, buf, len, 13197 WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID)) { 13198 WMI_LOGE("%s: Sending OBSS color det cmd failed, vdev_id: %d", 13199 __func__, cfg_param->vdev_id); 13200 wmi_buf_free(buf); 13201 return QDF_STATUS_E_FAILURE; 13202 } 13203 13204 return QDF_STATUS_SUCCESS; 13205 } 13206 13207 /** 13208 * extract_obss_color_collision_info_tlv() - Extract bss color collision info 13209 * received from firmware. 13210 * @evt_buf: pointer to event buffer 13211 * @info: Pointer to hold bss collision info 13212 * 13213 * Return: QDF_STATUS 13214 */ 13215 static QDF_STATUS extract_obss_color_collision_info_tlv(uint8_t *evt_buf, 13216 struct wmi_obss_color_collision_info *info) 13217 { 13218 WMI_OBSS_COLOR_COLLISION_DETECTION_EVENTID_param_tlvs *param_buf; 13219 wmi_obss_color_collision_evt_fixed_param *fix_param; 13220 13221 if (!info) { 13222 WMI_LOGE("%s: Invalid obss color buffer", __func__); 13223 return QDF_STATUS_E_INVAL; 13224 } 13225 13226 param_buf = (WMI_OBSS_COLOR_COLLISION_DETECTION_EVENTID_param_tlvs *) 13227 evt_buf; 13228 if (!param_buf) { 13229 WMI_LOGE("%s: Invalid evt_buf", __func__); 13230 return QDF_STATUS_E_INVAL; 13231 } 13232 13233 fix_param = param_buf->fixed_param; 13234 info->vdev_id = fix_param->vdev_id; 13235 info->obss_color_bitmap_bit0to31 = 13236 fix_param->bss_color_bitmap_bit0to31; 13237 info->obss_color_bitmap_bit32to63 = 13238 fix_param->bss_color_bitmap_bit32to63; 13239 13240 switch (fix_param->evt_type) { 13241 case WMI_BSS_COLOR_COLLISION_DISABLE: 13242 info->evt_type = OBSS_COLOR_COLLISION_DETECTION_DISABLE; 13243 break; 13244 case WMI_BSS_COLOR_COLLISION_DETECTION: 13245 info->evt_type = OBSS_COLOR_COLLISION_DETECTION; 13246 break; 13247 case WMI_BSS_COLOR_FREE_SLOT_TIMER_EXPIRY: 13248 info->evt_type = OBSS_COLOR_FREE_SLOT_TIMER_EXPIRY; 13249 break; 13250 case WMI_BSS_COLOR_FREE_SLOT_AVAILABLE: 13251 info->evt_type = OBSS_COLOR_FREE_SLOT_AVAILABLE; 13252 break; 13253 default: 13254 WMI_LOGE("%s: invalid event type: %d, vdev_id: %d", 13255 __func__, fix_param->evt_type, fix_param->vdev_id); 13256 return QDF_STATUS_E_FAILURE; 13257 } 13258 13259 return QDF_STATUS_SUCCESS; 13260 } 13261 13262 static void wmi_11ax_bss_color_attach_tlv(struct wmi_unified *wmi_handle) 13263 { 13264 struct wmi_ops *ops = wmi_handle->ops; 13265 13266 ops->send_obss_color_collision_cfg_cmd = 13267 send_obss_color_collision_cfg_cmd_tlv; 13268 ops->extract_obss_color_collision_info = 13269 extract_obss_color_collision_info_tlv; 13270 } 13271 13272 #if defined(WLAN_SUPPORT_FILS) || defined(CONFIG_BAND_6GHZ) 13273 static QDF_STATUS 13274 send_vdev_fils_enable_cmd_send(struct wmi_unified *wmi_handle, 13275 struct config_fils_params *param) 13276 { 13277 wmi_buf_t buf; 13278 wmi_enable_fils_cmd_fixed_param *cmd; 13279 uint8_t len = sizeof(wmi_enable_fils_cmd_fixed_param); 13280 13281 buf = wmi_buf_alloc(wmi_handle, len); 13282 if (!buf) 13283 return QDF_STATUS_E_NOMEM; 13284 13285 cmd = (wmi_enable_fils_cmd_fixed_param *)wmi_buf_data( 13286 buf); 13287 WMITLV_SET_HDR(&cmd->tlv_header, 13288 WMITLV_TAG_STRUC_wmi_enable_fils_cmd_fixed_param, 13289 WMITLV_GET_STRUCT_TLVLEN 13290 (wmi_enable_fils_cmd_fixed_param)); 13291 cmd->vdev_id = param->vdev_id; 13292 cmd->fd_period = param->fd_period; 13293 if (param->send_prb_rsp_frame) 13294 cmd->flags |= WMI_FILS_FLAGS_BITMAP_BCAST_PROBE_RSP; 13295 WMI_LOGD("%s: vdev id: %d fd_period: %d cmd->Flags %d", 13296 __func__, cmd->vdev_id, cmd->fd_period, cmd->flags); 13297 wmi_mtrace(WMI_ENABLE_FILS_CMDID, cmd->vdev_id, cmd->fd_period); 13298 if (wmi_unified_cmd_send(wmi_handle, buf, len, 13299 WMI_ENABLE_FILS_CMDID)) { 13300 WMI_LOGE("%s: Sending FILS cmd failed, vdev_id: %d", 13301 __func__, param->vdev_id); 13302 wmi_buf_free(buf); 13303 return QDF_STATUS_E_FAILURE; 13304 } 13305 13306 return QDF_STATUS_SUCCESS; 13307 } 13308 #endif 13309 13310 #ifdef WLAN_MWS_INFO_DEBUGFS 13311 /** 13312 * send_mws_coex_status_req_cmd_tlv() - send coex cmd to fw 13313 * 13314 * @wmi_handle: wmi handle 13315 * @vdev_id: vdev id 13316 * @cmd_id: Coex command id 13317 * 13318 * Send WMI_VDEV_GET_MWS_COEX_INFO_CMDID to fw. 13319 * 13320 * Return: QDF_STATUS 13321 */ 13322 static QDF_STATUS send_mws_coex_status_req_cmd_tlv(wmi_unified_t wmi_handle, 13323 uint32_t vdev_id, 13324 uint32_t cmd_id) 13325 { 13326 wmi_buf_t buf; 13327 wmi_vdev_get_mws_coex_info_cmd_fixed_param *cmd; 13328 uint16_t len = sizeof(*cmd); 13329 int ret; 13330 13331 buf = wmi_buf_alloc(wmi_handle, len); 13332 if (!buf) { 13333 WMI_LOGE("%s: Failed to allocate wmi buffer", __func__); 13334 return QDF_STATUS_E_NOMEM; 13335 } 13336 13337 cmd = (wmi_vdev_get_mws_coex_info_cmd_fixed_param *)wmi_buf_data(buf); 13338 WMITLV_SET_HDR(&cmd->tlv_header, 13339 WMITLV_TAG_STRUC_wmi_vdev_get_mws_coex_info_cmd_fixed_param, 13340 WMITLV_GET_STRUCT_TLVLEN 13341 (wmi_vdev_get_mws_coex_info_cmd_fixed_param)); 13342 cmd->vdev_id = vdev_id; 13343 cmd->cmd_id = cmd_id; 13344 wmi_mtrace(WMI_VDEV_GET_MWS_COEX_INFO_CMDID, vdev_id, 0); 13345 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 13346 WMI_VDEV_GET_MWS_COEX_INFO_CMDID); 13347 if (QDF_IS_STATUS_ERROR(ret)) { 13348 WMI_LOGE("Failed to send set param command ret = %d", ret); 13349 wmi_buf_free(buf); 13350 } 13351 return ret; 13352 } 13353 #endif 13354 13355 #ifdef WIFI_POS_CONVERGED 13356 /** 13357 * extract_oem_response_param_tlv() - Extract oem response params 13358 * @wmi_handle: wmi handle 13359 * @resp_buf: response buffer 13360 * @oem_resp_param: pointer to hold oem response params 13361 * 13362 * Return: QDF_STATUS_SUCCESS on success or proper error code. 13363 */ 13364 static QDF_STATUS 13365 extract_oem_response_param_tlv(wmi_unified_t wmi_handle, void *resp_buf, 13366 struct wmi_oem_response_param *oem_resp_param) 13367 { 13368 uint64_t temp_addr; 13369 WMI_OEM_RESPONSE_EVENTID_param_tlvs *param_buf = 13370 (WMI_OEM_RESPONSE_EVENTID_param_tlvs *)resp_buf; 13371 13372 if (!param_buf) { 13373 WMI_LOGE("Invalid OEM response"); 13374 return QDF_STATUS_E_INVAL; 13375 } 13376 13377 if (param_buf->num_data) { 13378 oem_resp_param->num_data1 = param_buf->num_data; 13379 oem_resp_param->data_1 = param_buf->data; 13380 } 13381 13382 if (param_buf->num_data2) { 13383 oem_resp_param->num_data2 = param_buf->num_data2; 13384 oem_resp_param->data_2 = param_buf->data2; 13385 } 13386 13387 if (param_buf->indirect_data) { 13388 oem_resp_param->indirect_data.pdev_id = 13389 param_buf->indirect_data->pdev_id; 13390 temp_addr = (param_buf->indirect_data->addr_hi) & 0xf; 13391 oem_resp_param->indirect_data.addr = 13392 param_buf->indirect_data->addr_lo + 13393 ((uint64_t)temp_addr << 32); 13394 oem_resp_param->indirect_data.len = 13395 param_buf->indirect_data->len; 13396 } 13397 13398 return QDF_STATUS_SUCCESS; 13399 } 13400 #endif /* WIFI_POS_CONVERGED */ 13401 13402 /** 13403 * extract_hw_mode_resp_event_status_tlv() - Extract HW mode change status 13404 * @wmi_handle: wmi handle 13405 * @event_buf: pointer to event buffer 13406 * @cmd_status: status of HW mode change command 13407 * 13408 * Return QDF_STATUS_SUCCESS on success or proper error code. 13409 */ 13410 static QDF_STATUS 13411 extract_hw_mode_resp_event_status_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13412 uint32_t *cmd_status) 13413 { 13414 WMI_PDEV_SET_HW_MODE_RESP_EVENTID_param_tlvs *param_buf; 13415 wmi_pdev_set_hw_mode_response_event_fixed_param *fixed_param; 13416 13417 param_buf = (WMI_PDEV_SET_HW_MODE_RESP_EVENTID_param_tlvs *)evt_buf; 13418 if (!param_buf) { 13419 WMI_LOGE("Invalid mode change event buffer"); 13420 return QDF_STATUS_E_INVAL; 13421 } 13422 13423 fixed_param = param_buf->fixed_param; 13424 if (!fixed_param) { 13425 WMI_LOGE("Invalid fixed param"); 13426 return QDF_STATUS_E_INVAL; 13427 } 13428 13429 *cmd_status = fixed_param->status; 13430 return QDF_STATUS_SUCCESS; 13431 } 13432 13433 #ifdef FEATURE_ANI_LEVEL_REQUEST 13434 static QDF_STATUS send_ani_level_cmd_tlv(wmi_unified_t wmi_handle, 13435 uint32_t *freqs, 13436 uint8_t num_freqs) 13437 { 13438 wmi_buf_t buf; 13439 wmi_get_channel_ani_cmd_fixed_param *cmd; 13440 QDF_STATUS ret; 13441 uint32_t len; 13442 A_UINT32 *chan_list; 13443 uint8_t i, *buf_ptr; 13444 13445 len = sizeof(wmi_get_channel_ani_cmd_fixed_param) + 13446 WMI_TLV_HDR_SIZE + 13447 num_freqs * sizeof(A_UINT32); 13448 13449 buf = wmi_buf_alloc(wmi_handle, len); 13450 if (!buf) 13451 return QDF_STATUS_E_FAILURE; 13452 13453 buf_ptr = (uint8_t *)wmi_buf_data(buf); 13454 cmd = (wmi_get_channel_ani_cmd_fixed_param *)buf_ptr; 13455 WMITLV_SET_HDR(&cmd->tlv_header, 13456 WMITLV_TAG_STRUC_wmi_get_channel_ani_cmd_fixed_param, 13457 WMITLV_GET_STRUCT_TLVLEN( 13458 wmi_get_channel_ani_cmd_fixed_param)); 13459 13460 buf_ptr += sizeof(wmi_get_channel_ani_cmd_fixed_param); 13461 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 13462 (num_freqs * sizeof(A_UINT32))); 13463 13464 chan_list = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE); 13465 for (i = 0; i < num_freqs; i++) { 13466 chan_list[i] = freqs[i]; 13467 WMI_LOGD("Requesting ANI for channel[%d]", chan_list[i]); 13468 } 13469 13470 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 13471 WMI_GET_CHANNEL_ANI_CMDID); 13472 13473 if (QDF_IS_STATUS_ERROR(ret)) { 13474 WMI_LOGE("WMI_GET_CHANNEL_ANI_CMDID send error %d", ret); 13475 wmi_buf_free(buf); 13476 } 13477 13478 return ret; 13479 } 13480 13481 static QDF_STATUS extract_ani_level_tlv(uint8_t *evt_buf, 13482 struct wmi_host_ani_level_event **info, 13483 uint32_t *num_freqs) 13484 { 13485 WMI_GET_CHANNEL_ANI_EVENTID_param_tlvs *param_buf; 13486 wmi_get_channel_ani_event_fixed_param *fixed_param; 13487 wmi_channel_ani_info_tlv_param *tlv_params; 13488 uint8_t *buf_ptr, i; 13489 13490 param_buf = (WMI_GET_CHANNEL_ANI_EVENTID_param_tlvs *)evt_buf; 13491 if (!param_buf) { 13492 wmi_err("Invalid ani level event buffer"); 13493 return QDF_STATUS_E_INVAL; 13494 } 13495 13496 fixed_param = 13497 (wmi_get_channel_ani_event_fixed_param *)param_buf->fixed_param; 13498 if (!fixed_param) { 13499 wmi_err("Invalid fixed param"); 13500 return QDF_STATUS_E_INVAL; 13501 } 13502 13503 buf_ptr = (uint8_t *)fixed_param; 13504 buf_ptr += sizeof(wmi_get_channel_ani_event_fixed_param); 13505 buf_ptr += WMI_TLV_HDR_SIZE; 13506 13507 *num_freqs = param_buf->num_ani_info; 13508 if (*num_freqs > MAX_NUM_FREQS_FOR_ANI_LEVEL) { 13509 wmi_err("Invalid number of freqs received"); 13510 return QDF_STATUS_E_INVAL; 13511 } 13512 13513 *info = qdf_mem_malloc(*num_freqs * 13514 sizeof(struct wmi_host_ani_level_event)); 13515 if (!(*info)) 13516 return QDF_STATUS_E_NOMEM; 13517 13518 tlv_params = (wmi_channel_ani_info_tlv_param *)buf_ptr; 13519 for (i = 0; i < param_buf->num_ani_info; i++) { 13520 (*info)[i].ani_level = tlv_params->ani_level; 13521 (*info)[i].chan_freq = tlv_params->chan_freq; 13522 tlv_params++; 13523 } 13524 13525 return QDF_STATUS_SUCCESS; 13526 } 13527 #endif /* FEATURE_ANI_LEVEL_REQUEST */ 13528 13529 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 13530 /** 13531 * extract_roam_trigger_stats_tlv() - Extract the Roam trigger stats 13532 * from the WMI_ROAM_STATS_EVENTID 13533 * @wmi_handle: wmi handle 13534 * @evt_buf: Pointer to the event buffer 13535 * @trig: Pointer to destination structure to fill data 13536 * @idx: TLV id 13537 */ 13538 static QDF_STATUS 13539 extract_roam_trigger_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13540 struct wmi_roam_trigger_info *trig, uint8_t idx) 13541 { 13542 WMI_ROAM_STATS_EVENTID_param_tlvs *param_buf; 13543 wmi_roam_trigger_reason *src_data = NULL; 13544 13545 param_buf = (WMI_ROAM_STATS_EVENTID_param_tlvs *)evt_buf; 13546 if (!param_buf || !param_buf->roam_trigger_reason) 13547 return QDF_STATUS_E_FAILURE; 13548 13549 src_data = ¶m_buf->roam_trigger_reason[idx]; 13550 13551 trig->present = true; 13552 trig->trigger_reason = src_data->trigger_reason; 13553 trig->trigger_sub_reason = src_data->trigger_sub_reason; 13554 trig->current_rssi = src_data->current_rssi; 13555 trig->timestamp = src_data->timestamp; 13556 13557 switch (trig->trigger_reason) { 13558 case WMI_ROAM_TRIGGER_REASON_PER: 13559 case WMI_ROAM_TRIGGER_REASON_BMISS: 13560 case WMI_ROAM_TRIGGER_REASON_HIGH_RSSI: 13561 case WMI_ROAM_TRIGGER_REASON_PERIODIC: 13562 case WMI_ROAM_TRIGGER_REASON_MAWC: 13563 case WMI_ROAM_TRIGGER_REASON_DENSE: 13564 case WMI_ROAM_TRIGGER_REASON_BACKGROUND: 13565 case WMI_ROAM_TRIGGER_REASON_IDLE: 13566 case WMI_ROAM_TRIGGER_REASON_FORCED: 13567 case WMI_ROAM_TRIGGER_REASON_UNIT_TEST: 13568 return QDF_STATUS_SUCCESS; 13569 13570 case WMI_ROAM_TRIGGER_REASON_BTM: 13571 trig->btm_trig_data.btm_request_mode = 13572 src_data->btm_request_mode; 13573 trig->btm_trig_data.disassoc_timer = 13574 src_data->disassoc_imminent_timer; 13575 trig->btm_trig_data.validity_interval = 13576 src_data->validity_internal; 13577 trig->btm_trig_data.candidate_list_count = 13578 src_data->candidate_list_count; 13579 trig->btm_trig_data.btm_resp_status = 13580 src_data->btm_response_status_code; 13581 return QDF_STATUS_SUCCESS; 13582 13583 case WMI_ROAM_TRIGGER_REASON_BSS_LOAD: 13584 trig->cu_trig_data.cu_load = src_data->cu_load; 13585 return QDF_STATUS_SUCCESS; 13586 13587 case WMI_ROAM_TRIGGER_REASON_DEAUTH: 13588 trig->deauth_trig_data.type = src_data->deauth_type; 13589 trig->deauth_trig_data.reason = src_data->deauth_reason; 13590 return QDF_STATUS_SUCCESS; 13591 13592 case WMI_ROAM_TRIGGER_REASON_LOW_RSSI: 13593 trig->rssi_trig_data.threshold = src_data->roam_rssi_threshold; 13594 return QDF_STATUS_SUCCESS; 13595 13596 default: 13597 return QDF_STATUS_SUCCESS; 13598 } 13599 13600 return QDF_STATUS_SUCCESS; 13601 } 13602 13603 /** 13604 * extract_roam_scan_ap_stats_tlv() - Extract the Roam trigger stats 13605 * from the WMI_ROAM_STATS_EVENTID 13606 * @wmi_handle: wmi handle 13607 * @evt_buf: Pointer to the event buffer 13608 * @dst: Pointer to destination structure to fill data 13609 * @ap_idx: TLV index for this roam scan 13610 * @num_cand: number of candidates list in the roam scan 13611 */ 13612 static QDF_STATUS 13613 extract_roam_scan_ap_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13614 struct wmi_roam_candidate_info *dst, 13615 uint8_t ap_idx, uint16_t num_cand) 13616 { 13617 WMI_ROAM_STATS_EVENTID_param_tlvs *param_buf; 13618 wmi_roam_ap_info *src = NULL; 13619 uint8_t i; 13620 13621 param_buf = (WMI_ROAM_STATS_EVENTID_param_tlvs *)evt_buf; 13622 if (!param_buf) { 13623 wmi_err("Param buf is NULL"); 13624 return QDF_STATUS_E_FAILURE; 13625 } 13626 13627 if (ap_idx >= param_buf->num_roam_ap_info) { 13628 wmi_err("Invalid roam scan AP tlv ap_idx:%d total_ap:%d", 13629 ap_idx, param_buf->num_roam_ap_info); 13630 return QDF_STATUS_E_FAILURE; 13631 } 13632 13633 src = ¶m_buf->roam_ap_info[ap_idx]; 13634 13635 for (i = 0; i < num_cand; i++) { 13636 WMI_MAC_ADDR_TO_CHAR_ARRAY(&src->bssid, dst->bssid.bytes); 13637 dst->type = src->candidate_type; 13638 dst->freq = src->channel; 13639 dst->etp = src->etp; 13640 dst->rssi = src->rssi; 13641 dst->rssi_score = src->rssi_score; 13642 dst->cu_load = src->cu_load; 13643 dst->cu_score = src->cu_score; 13644 dst->total_score = src->total_score; 13645 dst->timestamp = src->timestamp; 13646 13647 src++; 13648 dst++; 13649 } 13650 13651 return QDF_STATUS_SUCCESS; 13652 } 13653 13654 /** 13655 * extract_roam_scan_stats_tlv() - Extract the Roam trigger stats 13656 * from the WMI_ROAM_STATS_EVENTID 13657 * @wmi_handle: wmi handle 13658 * @evt_buf: Pointer to the event buffer 13659 * @dst: Pointer to destination structure to fill data 13660 * @idx: TLV id 13661 * @chan_idx: Index of the channel tlv for the current roam trigger 13662 * @ap_idx: Index of the candidate AP TLV for the current roam trigger 13663 */ 13664 static QDF_STATUS 13665 extract_roam_scan_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13666 struct wmi_roam_scan_data *dst, uint8_t idx, 13667 uint8_t chan_idx, uint8_t ap_idx) 13668 { 13669 WMI_ROAM_STATS_EVENTID_param_tlvs *param_buf; 13670 wmi_roam_scan_info *src_data = NULL; 13671 wmi_roam_scan_channel_info *src_chan = NULL; 13672 QDF_STATUS status; 13673 uint8_t i; 13674 13675 param_buf = (WMI_ROAM_STATS_EVENTID_param_tlvs *)evt_buf; 13676 if (!param_buf || !param_buf->roam_scan_info || 13677 idx >= param_buf->num_roam_scan_info) 13678 return QDF_STATUS_E_FAILURE; 13679 13680 src_data = ¶m_buf->roam_scan_info[idx]; 13681 13682 dst->present = true; 13683 dst->type = src_data->roam_scan_type; 13684 dst->num_chan = src_data->roam_scan_channel_count; 13685 dst->next_rssi_threshold = src_data->next_rssi_trigger_threshold; 13686 13687 /* Read the channel data only for dst->type is 0 (partial scan) */ 13688 if (dst->num_chan && !dst->type && param_buf->num_roam_scan_chan_info && 13689 chan_idx < param_buf->num_roam_scan_chan_info) { 13690 if (dst->num_chan > MAX_ROAM_SCAN_CHAN) 13691 dst->num_chan = MAX_ROAM_SCAN_CHAN; 13692 13693 src_chan = ¶m_buf->roam_scan_chan_info[chan_idx]; 13694 for (i = 0; i < dst->num_chan; i++) { 13695 dst->chan_freq[i] = src_chan->channel; 13696 src_chan++; 13697 } 13698 } 13699 13700 if (!src_data->roam_ap_count || !param_buf->num_roam_ap_info) 13701 return QDF_STATUS_SUCCESS; 13702 13703 dst->num_ap = src_data->roam_ap_count; 13704 if (dst->num_ap > MAX_ROAM_CANDIDATE_AP) 13705 dst->num_ap = MAX_ROAM_CANDIDATE_AP; 13706 13707 status = extract_roam_scan_ap_stats_tlv(wmi_handle, evt_buf, dst->ap, 13708 ap_idx, dst->num_ap); 13709 if (QDF_IS_STATUS_ERROR(status)) { 13710 WMI_LOGE("Extract candidate stats for tlv[%d] failed", idx); 13711 return status; 13712 } 13713 13714 return QDF_STATUS_SUCCESS; 13715 } 13716 13717 /** 13718 * extract_roam_scan_stats_tlv() - Extract the Roam trigger stats 13719 * from the WMI_ROAM_STATS_EVENTID 13720 * @wmi_handle: wmi handle 13721 * @evt_buf: Pointer to the event buffer 13722 * @dst: Pointer to destination structure to fill data 13723 * @idx: TLV id 13724 */ 13725 static QDF_STATUS 13726 extract_roam_result_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13727 struct wmi_roam_result *dst, uint8_t idx) 13728 { 13729 WMI_ROAM_STATS_EVENTID_param_tlvs *param_buf; 13730 wmi_roam_result *src_data = NULL; 13731 13732 param_buf = (WMI_ROAM_STATS_EVENTID_param_tlvs *)evt_buf; 13733 if (!param_buf || !param_buf->roam_result || 13734 idx >= param_buf->num_roam_result) 13735 return QDF_STATUS_E_FAILURE; 13736 13737 src_data = ¶m_buf->roam_result[idx]; 13738 13739 dst->present = true; 13740 dst->status = src_data->roam_status ? false : true; 13741 dst->timestamp = src_data->timestamp; 13742 dst->fail_reason = src_data->roam_fail_reason; 13743 13744 return QDF_STATUS_SUCCESS; 13745 } 13746 13747 /** 13748 * extract_roam_11kv_stats_tlv() - Extract the Roam trigger stats 13749 * from the WMI_ROAM_STATS_EVENTID 13750 * @wmi_handle: wmi handle 13751 * @evt_buf: Pointer to the event buffer 13752 * @dst: Pointer to destination structure to fill data 13753 * @idx: TLV id 13754 * @rpt_idx: Neighbor report Channel index 13755 */ 13756 static QDF_STATUS 13757 extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13758 struct wmi_neighbor_report_data *dst, 13759 uint8_t idx, uint8_t rpt_idx) 13760 { 13761 WMI_ROAM_STATS_EVENTID_param_tlvs *param_buf; 13762 wmi_roam_neighbor_report_info *src_data = NULL; 13763 wmi_roam_neighbor_report_channel_info *src_freq = NULL; 13764 uint8_t i; 13765 13766 param_buf = (WMI_ROAM_STATS_EVENTID_param_tlvs *)evt_buf; 13767 if (!param_buf || !param_buf->roam_neighbor_report_info || 13768 !param_buf->num_roam_neighbor_report_info || 13769 idx >= param_buf->num_roam_neighbor_report_info) { 13770 WMI_LOGD("%s: Invalid 1kv param buf", __func__); 13771 return QDF_STATUS_E_FAILURE; 13772 } 13773 13774 src_data = ¶m_buf->roam_neighbor_report_info[idx]; 13775 13776 dst->present = true; 13777 dst->req_type = src_data->request_type; 13778 dst->num_freq = src_data->neighbor_report_channel_count; 13779 dst->req_time = src_data->neighbor_report_request_timestamp; 13780 dst->resp_time = src_data->neighbor_report_response_timestamp; 13781 13782 if (!dst->num_freq || !param_buf->num_roam_neighbor_report_chan_info || 13783 rpt_idx >= param_buf->num_roam_neighbor_report_chan_info) 13784 return QDF_STATUS_SUCCESS; 13785 13786 if (!param_buf->roam_neighbor_report_chan_info) { 13787 WMI_LOGD("%s: 11kv channel present, but TLV is NULL num_freq:%d", 13788 __func__, dst->num_freq); 13789 dst->num_freq = 0; 13790 /* return success as its optional tlv and we can print neighbor 13791 * report received info 13792 */ 13793 return QDF_STATUS_SUCCESS; 13794 } 13795 13796 src_freq = ¶m_buf->roam_neighbor_report_chan_info[rpt_idx]; 13797 13798 if (dst->num_freq > MAX_ROAM_SCAN_CHAN) 13799 dst->num_freq = MAX_ROAM_SCAN_CHAN; 13800 13801 for (i = 0; i < dst->num_freq; i++) { 13802 dst->freq[i] = src_freq->channel; 13803 src_freq++; 13804 } 13805 13806 return QDF_STATUS_SUCCESS; 13807 } 13808 #else 13809 static inline QDF_STATUS 13810 extract_roam_trigger_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13811 struct wmi_roam_trigger_info *trig, uint8_t idx) 13812 { 13813 return QDF_STATUS_E_NOSUPPORT; 13814 } 13815 13816 static inline QDF_STATUS 13817 extract_roam_result_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13818 struct wmi_roam_result *dst, uint8_t idx) 13819 { 13820 return QDF_STATUS_E_NOSUPPORT; 13821 } 13822 13823 static QDF_STATUS 13824 extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13825 struct wmi_neighbor_report_data *dst, 13826 uint8_t idx, uint8_t rpt_idx) 13827 { 13828 return QDF_STATUS_E_NOSUPPORT; 13829 } 13830 13831 static QDF_STATUS 13832 extract_roam_scan_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, 13833 struct wmi_roam_scan_data *dst, uint8_t idx, 13834 uint8_t chan_idx, uint8_t ap_idx) 13835 { 13836 return QDF_STATUS_E_NOSUPPORT; 13837 } 13838 #endif 13839 13840 #ifdef WLAN_FEATURE_PKT_CAPTURE 13841 static QDF_STATUS 13842 extract_vdev_mgmt_offload_event_tlv(void *handle, void *evt_buf, 13843 struct mgmt_offload_event_params *params) 13844 { 13845 WMI_VDEV_MGMT_OFFLOAD_EVENTID_param_tlvs *param_tlvs; 13846 wmi_mgmt_hdr *hdr; 13847 13848 param_tlvs = (WMI_VDEV_MGMT_OFFLOAD_EVENTID_param_tlvs *)evt_buf; 13849 if (!param_tlvs) 13850 return QDF_STATUS_E_INVAL; 13851 13852 hdr = param_tlvs->fixed_param; 13853 if (!hdr) 13854 return QDF_STATUS_E_INVAL; 13855 13856 if (hdr->buf_len > param_tlvs->num_bufp) 13857 return QDF_STATUS_E_INVAL; 13858 13859 params->tsf_l32 = hdr->tsf_l32; 13860 params->chan_freq = hdr->chan_freq; 13861 params->rate_kbps = hdr->rate_kbps; 13862 params->rssi = hdr->rssi; 13863 params->buf_len = hdr->buf_len; 13864 params->tx_status = hdr->tx_status; 13865 params->buf = param_tlvs->bufp; 13866 params->tx_retry_cnt = hdr->tx_retry_cnt; 13867 return QDF_STATUS_SUCCESS; 13868 } 13869 #endif /* WLAN_FEATURE_PKT_CAPTURE */ 13870 13871 #ifdef FEATURE_WLAN_TIME_SYNC_FTM 13872 /** 13873 * send_wlan_ts_ftm_trigger_cmd_tlv(): send wlan time sync cmd to FW 13874 * 13875 * @wmi: wmi handle 13876 * @vdev_id: vdev id 13877 * @burst_mode: Indicates whether relation derived using FTM is needed for 13878 * each FTM frame or only aggregated result is required. 13879 * 13880 * Send WMI_AUDIO_SYNC_TRIGGER_CMDID to FW. 13881 * 13882 * Return: QDF_STATUS 13883 */ 13884 static QDF_STATUS send_wlan_ts_ftm_trigger_cmd_tlv(wmi_unified_t wmi, 13885 uint32_t vdev_id, 13886 bool burst_mode) 13887 { 13888 wmi_audio_sync_trigger_cmd_fixed_param *cmd; 13889 wmi_buf_t buf; 13890 int32_t len = sizeof(*cmd); 13891 13892 buf = wmi_buf_alloc(wmi, len); 13893 if (!buf) { 13894 WMI_LOGP("%s: wmi_buf_alloc failed", __func__); 13895 return QDF_STATUS_E_NOMEM; 13896 } 13897 cmd = (wmi_audio_sync_trigger_cmd_fixed_param *)wmi_buf_data(buf); 13898 WMITLV_SET_HDR(&cmd->tlv_header, 13899 WMITLV_TAG_STRUC_wmi_audio_sync_trigger_cmd_fixed_param, 13900 WMITLV_GET_STRUCT_TLVLEN(wmi_audio_sync_trigger_cmd_fixed_param)); 13901 cmd->vdev_id = vdev_id; 13902 cmd->agg_relation = burst_mode ? false : true; 13903 if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_AUDIO_SYNC_TRIGGER_CMDID)) { 13904 WMI_LOGE("%s: failed to send audio sync trigger cmd", __func__); 13905 wmi_buf_free(buf); 13906 return QDF_STATUS_E_FAILURE; 13907 } 13908 13909 return QDF_STATUS_SUCCESS; 13910 } 13911 13912 static QDF_STATUS send_wlan_ts_qtime_cmd_tlv(wmi_unified_t wmi, 13913 uint32_t vdev_id, 13914 uint64_t lpass_ts) 13915 { 13916 wmi_audio_sync_qtimer_cmd_fixed_param *cmd; 13917 wmi_buf_t buf; 13918 int32_t len = sizeof(*cmd); 13919 13920 buf = wmi_buf_alloc(wmi, len); 13921 if (!buf) { 13922 WMI_LOGP("%s: wmi_buf_alloc failed", __func__); 13923 return QDF_STATUS_E_NOMEM; 13924 } 13925 cmd = (wmi_audio_sync_qtimer_cmd_fixed_param *)wmi_buf_data(buf); 13926 WMITLV_SET_HDR(&cmd->tlv_header, 13927 WMITLV_TAG_STRUC_wmi_audio_sync_qtimer_cmd_fixed_param, 13928 WMITLV_GET_STRUCT_TLVLEN(wmi_audio_sync_qtimer_cmd_fixed_param)); 13929 cmd->vdev_id = vdev_id; 13930 cmd->qtimer_u32 = (uint32_t)((lpass_ts & 0xffffffff00000000LL) >> 32); 13931 cmd->qtimer_l32 = (uint32_t)(lpass_ts & 0xffffffffLL); 13932 13933 if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_AUDIO_SYNC_QTIMER_CMDID)) { 13934 WMI_LOGP("%s: Failed to send audio qtime command", __func__); 13935 wmi_buf_free(buf); 13936 return QDF_STATUS_E_FAILURE; 13937 } 13938 13939 return QDF_STATUS_SUCCESS; 13940 } 13941 13942 static QDF_STATUS extract_time_sync_ftm_start_stop_event_tlv( 13943 wmi_unified_t wmi, void *buf, 13944 struct ftm_time_sync_start_stop_params *param) 13945 { 13946 WMI_VDEV_AUDIO_SYNC_START_STOP_EVENTID_param_tlvs *param_buf; 13947 wmi_audio_sync_start_stop_event_fixed_param *resp_event; 13948 13949 param_buf = (WMI_VDEV_AUDIO_SYNC_START_STOP_EVENTID_param_tlvs *)buf; 13950 if (!param_buf) { 13951 WMI_LOGE("Invalid audio sync start stop event buffer"); 13952 return QDF_STATUS_E_FAILURE; 13953 } 13954 13955 resp_event = param_buf->fixed_param; 13956 if (!resp_event) { 13957 WMI_LOGE("Invalid audio sync start stop fixed param buffer"); 13958 return QDF_STATUS_E_FAILURE; 13959 } 13960 13961 param->vdev_id = resp_event->vdev_id; 13962 param->timer_interval = resp_event->periodicity; 13963 param->num_reads = resp_event->reads_needed; 13964 param->qtime = ((uint64_t)resp_event->qtimer_u32 << 32) | 13965 resp_event->qtimer_l32; 13966 param->mac_time = ((uint64_t)resp_event->mac_timer_u32 << 32) | 13967 resp_event->mac_timer_l32; 13968 13969 WMI_LOGI("%s: FTM time sync time_interval %d, num_reads %d", __func__, 13970 param->timer_interval, param->num_reads); 13971 13972 return QDF_STATUS_SUCCESS; 13973 } 13974 13975 static QDF_STATUS 13976 extract_time_sync_ftm_offset_event_tlv(wmi_unified_t wmi, void *buf, 13977 struct ftm_time_sync_offset *param) 13978 { 13979 WMI_VDEV_AUDIO_SYNC_Q_MASTER_SLAVE_OFFSET_EVENTID_param_tlvs *param_buf; 13980 wmi_audio_sync_q_master_slave_offset_event_fixed_param *resp_event; 13981 wmi_audio_sync_q_master_slave_times *q_pair; 13982 int iter; 13983 13984 param_buf = 13985 (WMI_VDEV_AUDIO_SYNC_Q_MASTER_SLAVE_OFFSET_EVENTID_param_tlvs *)buf; 13986 if (!param_buf) { 13987 WMI_LOGE("Invalid timesync ftm offset event buffer"); 13988 return QDF_STATUS_E_FAILURE; 13989 } 13990 13991 resp_event = param_buf->fixed_param; 13992 if (!resp_event) { 13993 WMI_LOGE("Invalid timesync ftm offset fixed param buffer"); 13994 return QDF_STATUS_E_FAILURE; 13995 } 13996 13997 param->vdev_id = resp_event->vdev_id; 13998 param->num_qtime = param_buf->num_audio_sync_q_master_slave_times; 13999 q_pair = param_buf->audio_sync_q_master_slave_times; 14000 if (!q_pair) { 14001 WMI_LOGE("Invalid q_master_slave_times buffer"); 14002 return QDF_STATUS_E_FAILURE; 14003 } 14004 14005 for (iter = 0; iter < param->num_qtime; iter++) { 14006 param->pairs[iter].qtime_master = ( 14007 (uint64_t)q_pair[iter].qmaster_u32 << 32) | 14008 q_pair[iter].qmaster_l32; 14009 param->pairs[iter].qtime_slave = ( 14010 (uint64_t)q_pair[iter].qslave_u32 << 32) | 14011 q_pair[iter].qslave_l32; 14012 } 14013 return QDF_STATUS_SUCCESS; 14014 } 14015 #endif /* FEATURE_WLAN_TIME_SYNC_FTM */ 14016 14017 struct wmi_ops tlv_ops = { 14018 .send_vdev_create_cmd = send_vdev_create_cmd_tlv, 14019 .send_vdev_delete_cmd = send_vdev_delete_cmd_tlv, 14020 .send_vdev_nss_chain_params_cmd = send_vdev_nss_chain_params_cmd_tlv, 14021 .send_vdev_down_cmd = send_vdev_down_cmd_tlv, 14022 .send_vdev_start_cmd = send_vdev_start_cmd_tlv, 14023 .send_peer_flush_tids_cmd = send_peer_flush_tids_cmd_tlv, 14024 .send_peer_param_cmd = send_peer_param_cmd_tlv, 14025 .send_vdev_up_cmd = send_vdev_up_cmd_tlv, 14026 .send_vdev_stop_cmd = send_vdev_stop_cmd_tlv, 14027 .send_peer_create_cmd = send_peer_create_cmd_tlv, 14028 .send_peer_delete_cmd = send_peer_delete_cmd_tlv, 14029 .send_peer_delete_all_cmd = send_peer_delete_all_cmd_tlv, 14030 .send_peer_rx_reorder_queue_setup_cmd = 14031 send_peer_rx_reorder_queue_setup_cmd_tlv, 14032 .send_peer_rx_reorder_queue_remove_cmd = 14033 send_peer_rx_reorder_queue_remove_cmd_tlv, 14034 .send_pdev_utf_cmd = send_pdev_utf_cmd_tlv, 14035 .send_pdev_param_cmd = send_pdev_param_cmd_tlv, 14036 .send_pdev_set_hw_mode_cmd = send_pdev_set_hw_mode_cmd_tlv, 14037 .send_suspend_cmd = send_suspend_cmd_tlv, 14038 .send_resume_cmd = send_resume_cmd_tlv, 14039 .send_wow_enable_cmd = send_wow_enable_cmd_tlv, 14040 .send_set_ap_ps_param_cmd = send_set_ap_ps_param_cmd_tlv, 14041 .send_set_sta_ps_param_cmd = send_set_sta_ps_param_cmd_tlv, 14042 .send_crash_inject_cmd = send_crash_inject_cmd_tlv, 14043 #ifdef FEATURE_FW_LOG_PARSING 14044 .send_dbglog_cmd = send_dbglog_cmd_tlv, 14045 #endif 14046 .send_vdev_set_param_cmd = send_vdev_set_param_cmd_tlv, 14047 .send_stats_request_cmd = send_stats_request_cmd_tlv, 14048 .send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv, 14049 .send_peer_based_pktlog_cmd = send_peer_based_pktlog_cmd, 14050 .send_time_stamp_sync_cmd = send_time_stamp_sync_cmd_tlv, 14051 .send_packet_log_disable_cmd = send_packet_log_disable_cmd_tlv, 14052 .send_beacon_tmpl_send_cmd = send_beacon_tmpl_send_cmd_tlv, 14053 .send_fd_tmpl_cmd = send_fd_tmpl_cmd_tlv, 14054 .send_peer_assoc_cmd = send_peer_assoc_cmd_tlv, 14055 .send_scan_start_cmd = send_scan_start_cmd_tlv, 14056 .send_scan_stop_cmd = send_scan_stop_cmd_tlv, 14057 .send_scan_chan_list_cmd = send_scan_chan_list_cmd_tlv, 14058 .send_mgmt_cmd = send_mgmt_cmd_tlv, 14059 .send_offchan_data_tx_cmd = send_offchan_data_tx_cmd_tlv, 14060 .send_modem_power_state_cmd = send_modem_power_state_cmd_tlv, 14061 .send_set_sta_ps_mode_cmd = send_set_sta_ps_mode_cmd_tlv, 14062 .send_idle_roam_monitor_cmd = send_idle_roam_monitor_cmd_tlv, 14063 .send_set_sta_uapsd_auto_trig_cmd = 14064 send_set_sta_uapsd_auto_trig_cmd_tlv, 14065 .send_get_temperature_cmd = send_get_temperature_cmd_tlv, 14066 .send_set_smps_params_cmd = send_set_smps_params_cmd_tlv, 14067 .send_set_mimops_cmd = send_set_mimops_cmd_tlv, 14068 .send_set_thermal_mgmt_cmd = send_set_thermal_mgmt_cmd_tlv, 14069 .send_lro_config_cmd = send_lro_config_cmd_tlv, 14070 .send_peer_rate_report_cmd = send_peer_rate_report_cmd_tlv, 14071 .send_probe_rsp_tmpl_send_cmd = 14072 send_probe_rsp_tmpl_send_cmd_tlv, 14073 .send_p2p_go_set_beacon_ie_cmd = 14074 send_p2p_go_set_beacon_ie_cmd_tlv, 14075 .send_setup_install_key_cmd = 14076 send_setup_install_key_cmd_tlv, 14077 .send_scan_probe_setoui_cmd = 14078 send_scan_probe_setoui_cmd_tlv, 14079 #ifdef IPA_OFFLOAD 14080 .send_ipa_offload_control_cmd = 14081 send_ipa_offload_control_cmd_tlv, 14082 #endif 14083 .send_pno_stop_cmd = send_pno_stop_cmd_tlv, 14084 .send_pno_start_cmd = send_pno_start_cmd_tlv, 14085 .send_nlo_mawc_cmd = send_nlo_mawc_cmd_tlv, 14086 #ifdef WLAN_FEATURE_LINK_LAYER_STATS 14087 .send_process_ll_stats_clear_cmd = send_process_ll_stats_clear_cmd_tlv, 14088 .send_process_ll_stats_set_cmd = send_process_ll_stats_set_cmd_tlv, 14089 .send_process_ll_stats_get_cmd = send_process_ll_stats_get_cmd_tlv, 14090 #endif /* WLAN_FEATURE_LINK_LAYER_STATS*/ 14091 .send_congestion_cmd = send_congestion_cmd_tlv, 14092 .send_snr_request_cmd = send_snr_request_cmd_tlv, 14093 .send_snr_cmd = send_snr_cmd_tlv, 14094 .send_link_status_req_cmd = send_link_status_req_cmd_tlv, 14095 #if !defined(REMOVE_PKT_LOG) && defined(FEATURE_PKTLOG) 14096 .send_pktlog_wmi_send_cmd = send_pktlog_wmi_send_cmd_tlv, 14097 #endif 14098 #ifdef WLAN_SUPPORT_GREEN_AP 14099 .send_egap_conf_params_cmd = send_egap_conf_params_cmd_tlv, 14100 .send_green_ap_ps_cmd = send_green_ap_ps_cmd_tlv, 14101 .extract_green_ap_egap_status_info = 14102 extract_green_ap_egap_status_info_tlv, 14103 #endif 14104 .send_csa_offload_enable_cmd = send_csa_offload_enable_cmd_tlv, 14105 .send_start_oem_data_cmd = send_start_oem_data_cmd_tlv, 14106 #ifdef FEATURE_OEM_DATA 14107 .send_start_oemv2_data_cmd = send_start_oemv2_data_cmd_tlv, 14108 #endif 14109 #ifdef WLAN_FEATURE_CIF_CFR 14110 .send_oem_dma_cfg_cmd = send_oem_dma_cfg_cmd_tlv, 14111 #endif 14112 .send_dfs_phyerr_filter_offload_en_cmd = 14113 send_dfs_phyerr_filter_offload_en_cmd_tlv, 14114 .send_stats_ext_req_cmd = send_stats_ext_req_cmd_tlv, 14115 .send_process_dhcpserver_offload_cmd = 14116 send_process_dhcpserver_offload_cmd_tlv, 14117 .send_pdev_set_regdomain_cmd = 14118 send_pdev_set_regdomain_cmd_tlv, 14119 .send_regdomain_info_to_fw_cmd = send_regdomain_info_to_fw_cmd_tlv, 14120 .send_cfg_action_frm_tb_ppdu_cmd = send_cfg_action_frm_tb_ppdu_cmd_tlv, 14121 .save_fw_version_cmd = save_fw_version_cmd_tlv, 14122 .check_and_update_fw_version = 14123 check_and_update_fw_version_cmd_tlv, 14124 .send_log_supported_evt_cmd = send_log_supported_evt_cmd_tlv, 14125 .send_enable_specific_fw_logs_cmd = 14126 send_enable_specific_fw_logs_cmd_tlv, 14127 .send_flush_logs_to_fw_cmd = send_flush_logs_to_fw_cmd_tlv, 14128 .send_unit_test_cmd = send_unit_test_cmd_tlv, 14129 #ifdef FEATURE_WLAN_APF 14130 .send_set_active_apf_mode_cmd = wmi_send_set_active_apf_mode_cmd_tlv, 14131 .send_apf_enable_cmd = wmi_send_apf_enable_cmd_tlv, 14132 .send_apf_write_work_memory_cmd = 14133 wmi_send_apf_write_work_memory_cmd_tlv, 14134 .send_apf_read_work_memory_cmd = 14135 wmi_send_apf_read_work_memory_cmd_tlv, 14136 .extract_apf_read_memory_resp_event = 14137 wmi_extract_apf_read_memory_resp_event_tlv, 14138 #endif /* FEATURE_WLAN_APF */ 14139 .init_cmd_send = init_cmd_send_tlv, 14140 .send_vdev_set_custom_aggr_size_cmd = 14141 send_vdev_set_custom_aggr_size_cmd_tlv, 14142 .send_vdev_set_qdepth_thresh_cmd = 14143 send_vdev_set_qdepth_thresh_cmd_tlv, 14144 .send_set_vap_dscp_tid_map_cmd = send_set_vap_dscp_tid_map_cmd_tlv, 14145 .send_vdev_set_fwtest_param_cmd = send_vdev_set_fwtest_param_cmd_tlv, 14146 .send_phyerr_disable_cmd = send_phyerr_disable_cmd_tlv, 14147 .send_phyerr_enable_cmd = send_phyerr_enable_cmd_tlv, 14148 .send_periodic_chan_stats_config_cmd = 14149 send_periodic_chan_stats_config_cmd_tlv, 14150 .send_simulation_test_cmd = send_simulation_test_cmd_tlv, 14151 .send_vdev_spectral_configure_cmd = 14152 send_vdev_spectral_configure_cmd_tlv, 14153 .send_vdev_spectral_enable_cmd = 14154 send_vdev_spectral_enable_cmd_tlv, 14155 #ifdef WLAN_CONV_SPECTRAL_ENABLE 14156 .extract_pdev_sscan_fw_cmd_fixed_param = 14157 extract_pdev_sscan_fw_cmd_fixed_param_tlv, 14158 .extract_pdev_sscan_fft_bin_index = 14159 extract_pdev_sscan_fft_bin_index_tlv, 14160 #endif /* WLAN_CONV_SPECTRAL_ENABLE */ 14161 .send_thermal_mitigation_param_cmd = 14162 send_thermal_mitigation_param_cmd_tlv, 14163 .send_process_update_edca_param_cmd = 14164 send_process_update_edca_param_cmd_tlv, 14165 .send_bss_color_change_enable_cmd = 14166 send_bss_color_change_enable_cmd_tlv, 14167 .send_coex_config_cmd = send_coex_config_cmd_tlv, 14168 .send_set_country_cmd = send_set_country_cmd_tlv, 14169 .send_addba_send_cmd = send_addba_send_cmd_tlv, 14170 .send_delba_send_cmd = send_delba_send_cmd_tlv, 14171 .send_addba_clearresponse_cmd = send_addba_clearresponse_cmd_tlv, 14172 .get_target_cap_from_service_ready = extract_service_ready_tlv, 14173 .extract_hal_reg_cap = extract_hal_reg_cap_tlv, 14174 .extract_num_mem_reqs = extract_num_mem_reqs_tlv, 14175 .extract_host_mem_req = extract_host_mem_req_tlv, 14176 .save_service_bitmap = save_service_bitmap_tlv, 14177 .save_ext_service_bitmap = save_ext_service_bitmap_tlv, 14178 .is_service_enabled = is_service_enabled_tlv, 14179 .save_fw_version = save_fw_version_in_service_ready_tlv, 14180 .ready_extract_init_status = ready_extract_init_status_tlv, 14181 .ready_extract_mac_addr = ready_extract_mac_addr_tlv, 14182 .ready_extract_mac_addr_list = ready_extract_mac_addr_list_tlv, 14183 .extract_ready_event_params = extract_ready_event_params_tlv, 14184 .extract_dbglog_data_len = extract_dbglog_data_len_tlv, 14185 .extract_mgmt_rx_params = extract_mgmt_rx_params_tlv, 14186 .extract_vdev_roam_param = extract_vdev_roam_param_tlv, 14187 .extract_vdev_scan_ev_param = extract_vdev_scan_ev_param_tlv, 14188 #ifdef FEATURE_WLAN_SCAN_PNO 14189 .extract_nlo_match_ev_param = extract_nlo_match_ev_param_tlv, 14190 .extract_nlo_complete_ev_param = extract_nlo_complete_ev_param_tlv, 14191 #endif 14192 .extract_all_stats_count = extract_all_stats_counts_tlv, 14193 .extract_pdev_stats = extract_pdev_stats_tlv, 14194 .extract_unit_test = extract_unit_test_tlv, 14195 .extract_pdev_ext_stats = extract_pdev_ext_stats_tlv, 14196 .extract_vdev_stats = extract_vdev_stats_tlv, 14197 .extract_per_chain_rssi_stats = extract_per_chain_rssi_stats_tlv, 14198 .extract_peer_stats = extract_peer_stats_tlv, 14199 .extract_bcn_stats = extract_bcn_stats_tlv, 14200 .extract_bcnflt_stats = extract_bcnflt_stats_tlv, 14201 .extract_peer_extd_stats = extract_peer_extd_stats_tlv, 14202 .extract_peer_adv_stats = extract_peer_adv_stats_tlv, 14203 .extract_chan_stats = extract_chan_stats_tlv, 14204 #ifdef WLAN_FEATURE_MIB_STATS 14205 .extract_mib_stats = extract_mib_stats_tlv, 14206 #endif 14207 .extract_profile_ctx = extract_profile_ctx_tlv, 14208 .extract_profile_data = extract_profile_data_tlv, 14209 .send_fw_test_cmd = send_fw_test_cmd_tlv, 14210 .send_power_dbg_cmd = send_power_dbg_cmd_tlv, 14211 .extract_service_ready_ext = extract_service_ready_ext_tlv, 14212 .extract_service_ready_ext2 = extract_service_ready_ext2_tlv, 14213 .extract_hw_mode_cap_service_ready_ext = 14214 extract_hw_mode_cap_service_ready_ext_tlv, 14215 .extract_mac_phy_cap_service_ready_ext = 14216 extract_mac_phy_cap_service_ready_ext_tlv, 14217 .extract_reg_cap_service_ready_ext = 14218 extract_reg_cap_service_ready_ext_tlv, 14219 .extract_dbr_ring_cap_service_ready_ext = 14220 extract_dbr_ring_cap_service_ready_ext_tlv, 14221 .extract_dbr_ring_cap_service_ready_ext2 = 14222 extract_dbr_ring_cap_service_ready_ext2_tlv, 14223 .extract_sar_cap_service_ready_ext = 14224 extract_sar_cap_service_ready_ext_tlv, 14225 .extract_pdev_utf_event = extract_pdev_utf_event_tlv, 14226 .wmi_set_htc_tx_tag = wmi_set_htc_tx_tag_tlv, 14227 .extract_fips_event_data = extract_fips_event_data_tlv, 14228 #if defined(WLAN_SUPPORT_FILS) || defined(CONFIG_BAND_6GHZ) 14229 .send_vdev_fils_enable_cmd = send_vdev_fils_enable_cmd_send, 14230 #endif 14231 #ifdef WLAN_FEATURE_DISA 14232 .extract_encrypt_decrypt_resp_event = 14233 extract_encrypt_decrypt_resp_event_tlv, 14234 #endif 14235 .send_pdev_fips_cmd = send_pdev_fips_cmd_tlv, 14236 .extract_get_pn_data = extract_get_pn_data_tlv, 14237 .send_pdev_get_pn_cmd = send_pdev_get_pn_cmd_tlv, 14238 .send_wlan_profile_enable_cmd = send_wlan_profile_enable_cmd_tlv, 14239 #ifdef WLAN_FEATURE_DISA 14240 .send_encrypt_decrypt_send_cmd = send_encrypt_decrypt_send_cmd_tlv, 14241 #endif 14242 .send_wlan_profile_trigger_cmd = send_wlan_profile_trigger_cmd_tlv, 14243 .send_wlan_profile_hist_intvl_cmd = 14244 send_wlan_profile_hist_intvl_cmd_tlv, 14245 .is_management_record = is_management_record_tlv, 14246 .is_diag_event = is_diag_event_tlv, 14247 #ifdef WLAN_FEATURE_ACTION_OUI 14248 .send_action_oui_cmd = send_action_oui_cmd_tlv, 14249 #endif 14250 .send_dfs_phyerr_offload_en_cmd = send_dfs_phyerr_offload_en_cmd_tlv, 14251 #ifdef QCA_SUPPORT_AGILE_DFS 14252 .send_adfs_ch_cfg_cmd = send_adfs_ch_cfg_cmd_tlv, 14253 .send_adfs_ocac_abort_cmd = send_adfs_ocac_abort_cmd_tlv, 14254 #endif 14255 .send_dfs_phyerr_offload_dis_cmd = send_dfs_phyerr_offload_dis_cmd_tlv, 14256 .extract_reg_chan_list_update_event = 14257 extract_reg_chan_list_update_event_tlv, 14258 #ifdef WLAN_SUPPORT_RF_CHARACTERIZATION 14259 .extract_num_rf_characterization_entries = 14260 extract_num_rf_characterization_entries_tlv, 14261 .extract_rf_characterization_entries = 14262 extract_rf_characterization_entries_tlv, 14263 #endif 14264 .extract_chainmask_tables = 14265 extract_chainmask_tables_tlv, 14266 .extract_thermal_stats = extract_thermal_stats_tlv, 14267 .extract_thermal_level_stats = extract_thermal_level_stats_tlv, 14268 .send_get_rcpi_cmd = send_get_rcpi_cmd_tlv, 14269 .extract_rcpi_response_event = extract_rcpi_response_event_tlv, 14270 #ifdef DFS_COMPONENT_ENABLE 14271 .extract_dfs_cac_complete_event = extract_dfs_cac_complete_event_tlv, 14272 .extract_dfs_ocac_complete_event = extract_dfs_ocac_complete_event_tlv, 14273 .extract_dfs_radar_detection_event = 14274 extract_dfs_radar_detection_event_tlv, 14275 .extract_wlan_radar_event_info = extract_wlan_radar_event_info_tlv, 14276 #endif 14277 .convert_pdev_id_host_to_target = 14278 convert_host_pdev_id_to_target_pdev_id_legacy, 14279 .convert_pdev_id_target_to_host = 14280 convert_target_pdev_id_to_host_pdev_id_legacy, 14281 14282 .convert_host_pdev_id_to_target = 14283 convert_host_pdev_id_to_target_pdev_id, 14284 .convert_target_pdev_id_to_host = 14285 convert_target_pdev_id_to_host_pdev_id, 14286 14287 .convert_phy_id_host_to_target = 14288 convert_host_phy_id_to_target_phy_id_legacy, 14289 .convert_phy_id_target_to_host = 14290 convert_target_phy_id_to_host_phy_id_legacy, 14291 14292 .convert_host_phy_id_to_target = 14293 convert_host_phy_id_to_target_phy_id, 14294 .convert_target_phy_id_to_host = 14295 convert_target_phy_id_to_host_phy_id, 14296 14297 .send_start_11d_scan_cmd = send_start_11d_scan_cmd_tlv, 14298 .send_stop_11d_scan_cmd = send_stop_11d_scan_cmd_tlv, 14299 .extract_reg_11d_new_country_event = 14300 extract_reg_11d_new_country_event_tlv, 14301 .send_user_country_code_cmd = send_user_country_code_cmd_tlv, 14302 .extract_reg_ch_avoid_event = 14303 extract_reg_ch_avoid_event_tlv, 14304 .send_obss_detection_cfg_cmd = send_obss_detection_cfg_cmd_tlv, 14305 .extract_obss_detection_info = extract_obss_detection_info_tlv, 14306 .wmi_pdev_id_conversion_enable = wmi_tlv_pdev_id_conversion_enable, 14307 .wmi_free_allocated_event = wmitlv_free_allocated_event_tlvs, 14308 .wmi_check_and_pad_event = wmitlv_check_and_pad_event_tlvs, 14309 .wmi_check_command_params = wmitlv_check_command_tlv_params, 14310 .extract_comb_phyerr = extract_comb_phyerr_tlv, 14311 .extract_single_phyerr = extract_single_phyerr_tlv, 14312 #ifdef QCA_SUPPORT_CP_STATS 14313 .extract_cca_stats = extract_cca_stats_tlv, 14314 #endif 14315 .extract_esp_estimation_ev_param = 14316 extract_esp_estimation_ev_param_tlv, 14317 .send_roam_scan_stats_cmd = send_roam_scan_stats_cmd_tlv, 14318 .extract_roam_scan_stats_res_evt = extract_roam_scan_stats_res_evt_tlv, 14319 #ifdef OBSS_PD 14320 .send_obss_spatial_reuse_set = send_obss_spatial_reuse_set_cmd_tlv, 14321 .send_obss_spatial_reuse_set_def_thresh = 14322 send_obss_spatial_reuse_set_def_thresh_cmd_tlv, 14323 .send_self_srg_bss_color_bitmap_set = 14324 send_self_srg_bss_color_bitmap_set_cmd_tlv, 14325 .send_self_srg_partial_bssid_bitmap_set = 14326 send_self_srg_partial_bssid_bitmap_set_cmd_tlv, 14327 .send_self_srg_obss_color_enable_bitmap = 14328 send_self_srg_obss_color_enable_bitmap_cmd_tlv, 14329 .send_self_srg_obss_bssid_enable_bitmap = 14330 send_self_srg_obss_bssid_enable_bitmap_cmd_tlv, 14331 .send_self_non_srg_obss_color_enable_bitmap = 14332 send_self_non_srg_obss_color_enable_bitmap_cmd_tlv, 14333 .send_self_non_srg_obss_bssid_enable_bitmap = 14334 send_self_non_srg_obss_bssid_enable_bitmap_cmd_tlv, 14335 #endif 14336 .extract_offload_bcn_tx_status_evt = extract_offload_bcn_tx_status_evt, 14337 .extract_ctl_failsafe_check_ev_param = 14338 extract_ctl_failsafe_check_ev_param_tlv, 14339 #ifdef WIFI_POS_CONVERGED 14340 .extract_oem_response_param = extract_oem_response_param_tlv, 14341 #endif /* WIFI_POS_CONVERGED */ 14342 #ifdef WLAN_MWS_INFO_DEBUGFS 14343 .send_mws_coex_status_req_cmd = send_mws_coex_status_req_cmd_tlv, 14344 #endif 14345 .extract_hw_mode_resp_event = extract_hw_mode_resp_event_status_tlv, 14346 #ifdef FEATURE_ANI_LEVEL_REQUEST 14347 .send_ani_level_cmd = send_ani_level_cmd_tlv, 14348 .extract_ani_level = extract_ani_level_tlv, 14349 #endif /* FEATURE_ANI_LEVEL_REQUEST */ 14350 .extract_roam_trigger_stats = extract_roam_trigger_stats_tlv, 14351 .extract_roam_scan_stats = extract_roam_scan_stats_tlv, 14352 .extract_roam_result_stats = extract_roam_result_stats_tlv, 14353 .extract_roam_11kv_stats = extract_roam_11kv_stats_tlv, 14354 #ifdef WLAN_FEATURE_PKT_CAPTURE 14355 .extract_vdev_mgmt_offload_event = extract_vdev_mgmt_offload_event_tlv, 14356 #endif 14357 14358 #ifdef FEATURE_WLAN_TIME_SYNC_FTM 14359 .send_wlan_time_sync_ftm_trigger_cmd = send_wlan_ts_ftm_trigger_cmd_tlv, 14360 .send_wlan_ts_qtime_cmd = send_wlan_ts_qtime_cmd_tlv, 14361 .extract_time_sync_ftm_start_stop_event = 14362 extract_time_sync_ftm_start_stop_event_tlv, 14363 .extract_time_sync_ftm_offset_event = 14364 extract_time_sync_ftm_offset_event_tlv, 14365 #endif /* FEATURE_WLAN_TIME_SYNC_FTM */ 14366 .send_roam_scan_ch_list_req_cmd = send_roam_scan_ch_list_req_cmd_tlv, 14367 .send_injector_config_cmd = send_injector_config_cmd_tlv, 14368 }; 14369 14370 /** 14371 * populate_tlv_event_id() - populates wmi event ids 14372 * 14373 * @param event_ids: Pointer to hold event ids 14374 * Return: None 14375 */ 14376 static void populate_tlv_events_id(uint32_t *event_ids) 14377 { 14378 event_ids[wmi_service_ready_event_id] = WMI_SERVICE_READY_EVENTID; 14379 event_ids[wmi_ready_event_id] = WMI_READY_EVENTID; 14380 event_ids[wmi_scan_event_id] = WMI_SCAN_EVENTID; 14381 event_ids[wmi_pdev_tpc_config_event_id] = WMI_PDEV_TPC_CONFIG_EVENTID; 14382 event_ids[wmi_chan_info_event_id] = WMI_CHAN_INFO_EVENTID; 14383 event_ids[wmi_phyerr_event_id] = WMI_PHYERR_EVENTID; 14384 event_ids[wmi_pdev_dump_event_id] = WMI_PDEV_DUMP_EVENTID; 14385 event_ids[wmi_tx_pause_event_id] = WMI_TX_PAUSE_EVENTID; 14386 event_ids[wmi_dfs_radar_event_id] = WMI_DFS_RADAR_EVENTID; 14387 event_ids[wmi_pdev_l1ss_track_event_id] = WMI_PDEV_L1SS_TRACK_EVENTID; 14388 event_ids[wmi_pdev_temperature_event_id] = WMI_PDEV_TEMPERATURE_EVENTID; 14389 event_ids[wmi_service_ready_ext_event_id] = 14390 WMI_SERVICE_READY_EXT_EVENTID; 14391 event_ids[wmi_service_ready_ext2_event_id] = 14392 WMI_SERVICE_READY_EXT2_EVENTID; 14393 event_ids[wmi_vdev_start_resp_event_id] = WMI_VDEV_START_RESP_EVENTID; 14394 event_ids[wmi_vdev_stopped_event_id] = WMI_VDEV_STOPPED_EVENTID; 14395 event_ids[wmi_vdev_install_key_complete_event_id] = 14396 WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID; 14397 event_ids[wmi_vdev_mcc_bcn_intvl_change_req_event_id] = 14398 WMI_VDEV_MCC_BCN_INTERVAL_CHANGE_REQ_EVENTID; 14399 14400 event_ids[wmi_vdev_tsf_report_event_id] = WMI_VDEV_TSF_REPORT_EVENTID; 14401 event_ids[wmi_peer_sta_kickout_event_id] = WMI_PEER_STA_KICKOUT_EVENTID; 14402 event_ids[wmi_peer_info_event_id] = WMI_PEER_INFO_EVENTID; 14403 event_ids[wmi_peer_tx_fail_cnt_thr_event_id] = 14404 WMI_PEER_TX_FAIL_CNT_THR_EVENTID; 14405 event_ids[wmi_peer_estimated_linkspeed_event_id] = 14406 WMI_PEER_ESTIMATED_LINKSPEED_EVENTID; 14407 event_ids[wmi_peer_state_event_id] = WMI_PEER_STATE_EVENTID; 14408 event_ids[wmi_peer_delete_response_event_id] = 14409 WMI_PEER_DELETE_RESP_EVENTID; 14410 event_ids[wmi_peer_delete_all_response_event_id] = 14411 WMI_VDEV_DELETE_ALL_PEER_RESP_EVENTID; 14412 event_ids[wmi_mgmt_rx_event_id] = WMI_MGMT_RX_EVENTID; 14413 event_ids[wmi_host_swba_event_id] = WMI_HOST_SWBA_EVENTID; 14414 event_ids[wmi_tbttoffset_update_event_id] = 14415 WMI_TBTTOFFSET_UPDATE_EVENTID; 14416 event_ids[wmi_ext_tbttoffset_update_event_id] = 14417 WMI_TBTTOFFSET_EXT_UPDATE_EVENTID; 14418 event_ids[wmi_offload_bcn_tx_status_event_id] = 14419 WMI_OFFLOAD_BCN_TX_STATUS_EVENTID; 14420 event_ids[wmi_offload_prob_resp_tx_status_event_id] = 14421 WMI_OFFLOAD_PROB_RESP_TX_STATUS_EVENTID; 14422 event_ids[wmi_mgmt_tx_completion_event_id] = 14423 WMI_MGMT_TX_COMPLETION_EVENTID; 14424 event_ids[wmi_pdev_nfcal_power_all_channels_event_id] = 14425 WMI_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID; 14426 event_ids[wmi_tx_delba_complete_event_id] = 14427 WMI_TX_DELBA_COMPLETE_EVENTID; 14428 event_ids[wmi_tx_addba_complete_event_id] = 14429 WMI_TX_ADDBA_COMPLETE_EVENTID; 14430 event_ids[wmi_ba_rsp_ssn_event_id] = WMI_BA_RSP_SSN_EVENTID; 14431 14432 event_ids[wmi_aggr_state_trig_event_id] = WMI_AGGR_STATE_TRIG_EVENTID; 14433 14434 event_ids[wmi_roam_event_id] = WMI_ROAM_EVENTID; 14435 event_ids[wmi_profile_match] = WMI_PROFILE_MATCH; 14436 14437 event_ids[wmi_roam_synch_event_id] = WMI_ROAM_SYNCH_EVENTID; 14438 event_ids[wmi_roam_synch_frame_event_id] = WMI_ROAM_SYNCH_FRAME_EVENTID; 14439 14440 event_ids[wmi_p2p_disc_event_id] = WMI_P2P_DISC_EVENTID; 14441 14442 event_ids[wmi_p2p_noa_event_id] = WMI_P2P_NOA_EVENTID; 14443 event_ids[wmi_p2p_lo_stop_event_id] = 14444 WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID; 14445 event_ids[wmi_vdev_add_macaddr_rx_filter_event_id] = 14446 WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID; 14447 event_ids[wmi_pdev_resume_event_id] = WMI_PDEV_RESUME_EVENTID; 14448 event_ids[wmi_wow_wakeup_host_event_id] = WMI_WOW_WAKEUP_HOST_EVENTID; 14449 event_ids[wmi_d0_wow_disable_ack_event_id] = 14450 WMI_D0_WOW_DISABLE_ACK_EVENTID; 14451 event_ids[wmi_wow_initial_wakeup_event_id] = 14452 WMI_WOW_INITIAL_WAKEUP_EVENTID; 14453 14454 event_ids[wmi_rtt_meas_report_event_id] = 14455 WMI_RTT_MEASUREMENT_REPORT_EVENTID; 14456 event_ids[wmi_tsf_meas_report_event_id] = 14457 WMI_TSF_MEASUREMENT_REPORT_EVENTID; 14458 event_ids[wmi_rtt_error_report_event_id] = WMI_RTT_ERROR_REPORT_EVENTID; 14459 event_ids[wmi_stats_ext_event_id] = WMI_STATS_EXT_EVENTID; 14460 event_ids[wmi_iface_link_stats_event_id] = WMI_IFACE_LINK_STATS_EVENTID; 14461 event_ids[wmi_peer_link_stats_event_id] = WMI_PEER_LINK_STATS_EVENTID; 14462 event_ids[wmi_radio_link_stats_link] = WMI_RADIO_LINK_STATS_EVENTID; 14463 event_ids[wmi_diag_event_id_log_supported_event_id] = 14464 WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID; 14465 event_ids[wmi_nlo_match_event_id] = WMI_NLO_MATCH_EVENTID; 14466 event_ids[wmi_nlo_scan_complete_event_id] = 14467 WMI_NLO_SCAN_COMPLETE_EVENTID; 14468 event_ids[wmi_apfind_event_id] = WMI_APFIND_EVENTID; 14469 event_ids[wmi_passpoint_match_event_id] = WMI_PASSPOINT_MATCH_EVENTID; 14470 14471 event_ids[wmi_gtk_offload_status_event_id] = 14472 WMI_GTK_OFFLOAD_STATUS_EVENTID; 14473 event_ids[wmi_gtk_rekey_fail_event_id] = WMI_GTK_REKEY_FAIL_EVENTID; 14474 event_ids[wmi_csa_handling_event_id] = WMI_CSA_HANDLING_EVENTID; 14475 event_ids[wmi_chatter_pc_query_event_id] = WMI_CHATTER_PC_QUERY_EVENTID; 14476 14477 event_ids[wmi_echo_event_id] = WMI_ECHO_EVENTID; 14478 14479 event_ids[wmi_pdev_utf_event_id] = WMI_PDEV_UTF_EVENTID; 14480 14481 event_ids[wmi_dbg_msg_event_id] = WMI_DEBUG_MESG_EVENTID; 14482 event_ids[wmi_update_stats_event_id] = WMI_UPDATE_STATS_EVENTID; 14483 event_ids[wmi_debug_print_event_id] = WMI_DEBUG_PRINT_EVENTID; 14484 event_ids[wmi_dcs_interference_event_id] = WMI_DCS_INTERFERENCE_EVENTID; 14485 event_ids[wmi_pdev_qvit_event_id] = WMI_PDEV_QVIT_EVENTID; 14486 event_ids[wmi_wlan_profile_data_event_id] = 14487 WMI_WLAN_PROFILE_DATA_EVENTID; 14488 event_ids[wmi_pdev_ftm_intg_event_id] = WMI_PDEV_FTM_INTG_EVENTID; 14489 event_ids[wmi_wlan_freq_avoid_event_id] = WMI_WLAN_FREQ_AVOID_EVENTID; 14490 event_ids[wmi_vdev_get_keepalive_event_id] = 14491 WMI_VDEV_GET_KEEPALIVE_EVENTID; 14492 event_ids[wmi_thermal_mgmt_event_id] = WMI_THERMAL_MGMT_EVENTID; 14493 14494 event_ids[wmi_diag_container_event_id] = 14495 WMI_DIAG_DATA_CONTAINER_EVENTID; 14496 14497 event_ids[wmi_host_auto_shutdown_event_id] = 14498 WMI_HOST_AUTO_SHUTDOWN_EVENTID; 14499 14500 event_ids[wmi_update_whal_mib_stats_event_id] = 14501 WMI_UPDATE_WHAL_MIB_STATS_EVENTID; 14502 14503 /*update ht/vht info based on vdev (rx and tx NSS and preamble) */ 14504 event_ids[wmi_update_vdev_rate_stats_event_id] = 14505 WMI_UPDATE_VDEV_RATE_STATS_EVENTID; 14506 14507 event_ids[wmi_diag_event_id] = WMI_DIAG_EVENTID; 14508 event_ids[wmi_unit_test_event_id] = WMI_UNIT_TEST_EVENTID; 14509 14510 /** Set OCB Sched Response, deprecated */ 14511 event_ids[wmi_ocb_set_sched_event_id] = WMI_OCB_SET_SCHED_EVENTID; 14512 14513 event_ids[wmi_dbg_mesg_flush_complete_event_id] = 14514 WMI_DEBUG_MESG_FLUSH_COMPLETE_EVENTID; 14515 event_ids[wmi_rssi_breach_event_id] = WMI_RSSI_BREACH_EVENTID; 14516 14517 /* GPIO Event */ 14518 event_ids[wmi_gpio_input_event_id] = WMI_GPIO_INPUT_EVENTID; 14519 event_ids[wmi_uploadh_event_id] = WMI_UPLOADH_EVENTID; 14520 14521 event_ids[wmi_captureh_event_id] = WMI_CAPTUREH_EVENTID; 14522 event_ids[wmi_rfkill_state_change_event_id] = 14523 WMI_RFKILL_STATE_CHANGE_EVENTID; 14524 14525 /* TDLS Event */ 14526 event_ids[wmi_tdls_peer_event_id] = WMI_TDLS_PEER_EVENTID; 14527 14528 event_ids[wmi_batch_scan_enabled_event_id] = 14529 WMI_BATCH_SCAN_ENABLED_EVENTID; 14530 event_ids[wmi_batch_scan_result_event_id] = 14531 WMI_BATCH_SCAN_RESULT_EVENTID; 14532 /* OEM Event */ 14533 event_ids[wmi_oem_cap_event_id] = WMI_OEM_CAPABILITY_EVENTID; 14534 event_ids[wmi_oem_meas_report_event_id] = 14535 WMI_OEM_MEASUREMENT_REPORT_EVENTID; 14536 event_ids[wmi_oem_report_event_id] = WMI_OEM_ERROR_REPORT_EVENTID; 14537 14538 /* NAN Event */ 14539 event_ids[wmi_nan_event_id] = WMI_NAN_EVENTID; 14540 14541 /* LPI Event */ 14542 event_ids[wmi_lpi_result_event_id] = WMI_LPI_RESULT_EVENTID; 14543 event_ids[wmi_lpi_status_event_id] = WMI_LPI_STATUS_EVENTID; 14544 event_ids[wmi_lpi_handoff_event_id] = WMI_LPI_HANDOFF_EVENTID; 14545 14546 /* ExtScan events */ 14547 event_ids[wmi_extscan_start_stop_event_id] = 14548 WMI_EXTSCAN_START_STOP_EVENTID; 14549 event_ids[wmi_extscan_operation_event_id] = 14550 WMI_EXTSCAN_OPERATION_EVENTID; 14551 event_ids[wmi_extscan_table_usage_event_id] = 14552 WMI_EXTSCAN_TABLE_USAGE_EVENTID; 14553 event_ids[wmi_extscan_cached_results_event_id] = 14554 WMI_EXTSCAN_CACHED_RESULTS_EVENTID; 14555 event_ids[wmi_extscan_wlan_change_results_event_id] = 14556 WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID; 14557 event_ids[wmi_extscan_hotlist_match_event_id] = 14558 WMI_EXTSCAN_HOTLIST_MATCH_EVENTID; 14559 event_ids[wmi_extscan_capabilities_event_id] = 14560 WMI_EXTSCAN_CAPABILITIES_EVENTID; 14561 event_ids[wmi_extscan_hotlist_ssid_match_event_id] = 14562 WMI_EXTSCAN_HOTLIST_SSID_MATCH_EVENTID; 14563 14564 /* mDNS offload events */ 14565 event_ids[wmi_mdns_stats_event_id] = WMI_MDNS_STATS_EVENTID; 14566 14567 /* SAP Authentication offload events */ 14568 event_ids[wmi_sap_ofl_add_sta_event_id] = WMI_SAP_OFL_ADD_STA_EVENTID; 14569 event_ids[wmi_sap_ofl_del_sta_event_id] = WMI_SAP_OFL_DEL_STA_EVENTID; 14570 14571 /** Out-of-context-of-bss (OCB) events */ 14572 event_ids[wmi_ocb_set_config_resp_event_id] = 14573 WMI_OCB_SET_CONFIG_RESP_EVENTID; 14574 event_ids[wmi_ocb_get_tsf_timer_resp_event_id] = 14575 WMI_OCB_GET_TSF_TIMER_RESP_EVENTID; 14576 event_ids[wmi_dcc_get_stats_resp_event_id] = 14577 WMI_DCC_GET_STATS_RESP_EVENTID; 14578 event_ids[wmi_dcc_update_ndl_resp_event_id] = 14579 WMI_DCC_UPDATE_NDL_RESP_EVENTID; 14580 event_ids[wmi_dcc_stats_event_id] = WMI_DCC_STATS_EVENTID; 14581 /* System-On-Chip events */ 14582 event_ids[wmi_soc_set_hw_mode_resp_event_id] = 14583 WMI_SOC_SET_HW_MODE_RESP_EVENTID; 14584 event_ids[wmi_soc_hw_mode_transition_event_id] = 14585 WMI_SOC_HW_MODE_TRANSITION_EVENTID; 14586 event_ids[wmi_soc_set_dual_mac_config_resp_event_id] = 14587 WMI_SOC_SET_DUAL_MAC_CONFIG_RESP_EVENTID; 14588 event_ids[wmi_pdev_fips_event_id] = WMI_PDEV_FIPS_EVENTID; 14589 event_ids[wmi_pdev_csa_switch_count_status_event_id] = 14590 WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID; 14591 event_ids[wmi_vdev_ocac_complete_event_id] = 14592 WMI_VDEV_ADFS_OCAC_COMPLETE_EVENTID; 14593 event_ids[wmi_reg_chan_list_cc_event_id] = WMI_REG_CHAN_LIST_CC_EVENTID; 14594 event_ids[wmi_inst_rssi_stats_event_id] = WMI_INST_RSSI_STATS_EVENTID; 14595 event_ids[wmi_pdev_tpc_config_event_id] = WMI_PDEV_TPC_CONFIG_EVENTID; 14596 event_ids[wmi_peer_sta_ps_statechg_event_id] = 14597 WMI_PEER_STA_PS_STATECHG_EVENTID; 14598 event_ids[wmi_pdev_channel_hopping_event_id] = 14599 WMI_PDEV_CHANNEL_HOPPING_EVENTID; 14600 event_ids[wmi_offchan_data_tx_completion_event] = 14601 WMI_OFFCHAN_DATA_TX_COMPLETION_EVENTID; 14602 event_ids[wmi_dfs_cac_complete_id] = WMI_VDEV_DFS_CAC_COMPLETE_EVENTID; 14603 event_ids[wmi_dfs_radar_detection_event_id] = 14604 WMI_PDEV_DFS_RADAR_DETECTION_EVENTID; 14605 event_ids[wmi_tt_stats_event_id] = WMI_THERM_THROT_STATS_EVENTID; 14606 event_ids[wmi_11d_new_country_event_id] = WMI_11D_NEW_COUNTRY_EVENTID; 14607 event_ids[wmi_pdev_tpc_event_id] = WMI_PDEV_TPC_EVENTID; 14608 event_ids[wmi_get_arp_stats_req_id] = WMI_VDEV_GET_ARP_STAT_EVENTID; 14609 event_ids[wmi_service_available_event_id] = 14610 WMI_SERVICE_AVAILABLE_EVENTID; 14611 event_ids[wmi_update_rcpi_event_id] = WMI_UPDATE_RCPI_EVENTID; 14612 event_ids[wmi_pdev_check_cal_version_event_id] = WMI_PDEV_CHECK_CAL_VERSION_EVENTID; 14613 /* NDP events */ 14614 event_ids[wmi_ndp_initiator_rsp_event_id] = 14615 WMI_NDP_INITIATOR_RSP_EVENTID; 14616 event_ids[wmi_ndp_indication_event_id] = WMI_NDP_INDICATION_EVENTID; 14617 event_ids[wmi_ndp_confirm_event_id] = WMI_NDP_CONFIRM_EVENTID; 14618 event_ids[wmi_ndp_responder_rsp_event_id] = 14619 WMI_NDP_RESPONDER_RSP_EVENTID; 14620 event_ids[wmi_ndp_end_indication_event_id] = 14621 WMI_NDP_END_INDICATION_EVENTID; 14622 event_ids[wmi_ndp_end_rsp_event_id] = WMI_NDP_END_RSP_EVENTID; 14623 event_ids[wmi_ndl_schedule_update_event_id] = 14624 WMI_NDL_SCHEDULE_UPDATE_EVENTID; 14625 event_ids[wmi_ndp_event_id] = WMI_NDP_EVENTID; 14626 14627 event_ids[wmi_oem_response_event_id] = WMI_OEM_RESPONSE_EVENTID; 14628 event_ids[wmi_peer_stats_info_event_id] = WMI_PEER_STATS_INFO_EVENTID; 14629 event_ids[wmi_pdev_chip_power_stats_event_id] = 14630 WMI_PDEV_CHIP_POWER_STATS_EVENTID; 14631 event_ids[wmi_ap_ps_egap_info_event_id] = WMI_AP_PS_EGAP_INFO_EVENTID; 14632 event_ids[wmi_peer_assoc_conf_event_id] = WMI_PEER_ASSOC_CONF_EVENTID; 14633 event_ids[wmi_vdev_delete_resp_event_id] = WMI_VDEV_DELETE_RESP_EVENTID; 14634 event_ids[wmi_apf_capability_info_event_id] = 14635 WMI_BPF_CAPABILIY_INFO_EVENTID; 14636 event_ids[wmi_vdev_encrypt_decrypt_data_rsp_event_id] = 14637 WMI_VDEV_ENCRYPT_DECRYPT_DATA_RESP_EVENTID; 14638 event_ids[wmi_report_rx_aggr_failure_event_id] = 14639 WMI_REPORT_RX_AGGR_FAILURE_EVENTID; 14640 event_ids[wmi_pdev_chip_pwr_save_failure_detect_event_id] = 14641 WMI_PDEV_CHIP_POWER_SAVE_FAILURE_DETECTED_EVENTID; 14642 event_ids[wmi_peer_antdiv_info_event_id] = WMI_PEER_ANTDIV_INFO_EVENTID; 14643 event_ids[wmi_pdev_set_hw_mode_rsp_event_id] = 14644 WMI_PDEV_SET_HW_MODE_RESP_EVENTID; 14645 event_ids[wmi_pdev_hw_mode_transition_event_id] = 14646 WMI_PDEV_HW_MODE_TRANSITION_EVENTID; 14647 event_ids[wmi_pdev_set_mac_config_resp_event_id] = 14648 WMI_PDEV_SET_MAC_CONFIG_RESP_EVENTID; 14649 event_ids[wmi_coex_bt_activity_event_id] = 14650 WMI_WLAN_COEX_BT_ACTIVITY_EVENTID; 14651 event_ids[wmi_mgmt_tx_bundle_completion_event_id] = 14652 WMI_MGMT_TX_BUNDLE_COMPLETION_EVENTID; 14653 event_ids[wmi_radio_tx_power_level_stats_event_id] = 14654 WMI_RADIO_TX_POWER_LEVEL_STATS_EVENTID; 14655 event_ids[wmi_report_stats_event_id] = WMI_REPORT_STATS_EVENTID; 14656 event_ids[wmi_dma_buf_release_event_id] = 14657 WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID; 14658 event_ids[wmi_sap_obss_detection_report_event_id] = 14659 WMI_SAP_OBSS_DETECTION_REPORT_EVENTID; 14660 event_ids[wmi_host_swfda_event_id] = WMI_HOST_SWFDA_EVENTID; 14661 event_ids[wmi_sar_get_limits_event_id] = WMI_SAR_GET_LIMITS_EVENTID; 14662 event_ids[wmi_obss_color_collision_report_event_id] = 14663 WMI_OBSS_COLOR_COLLISION_DETECTION_EVENTID; 14664 event_ids[wmi_pdev_div_rssi_antid_event_id] = 14665 WMI_PDEV_DIV_RSSI_ANTID_EVENTID; 14666 event_ids[wmi_twt_enable_complete_event_id] = 14667 WMI_TWT_ENABLE_COMPLETE_EVENTID; 14668 event_ids[wmi_twt_disable_complete_event_id] = 14669 WMI_TWT_DISABLE_COMPLETE_EVENTID; 14670 event_ids[wmi_apf_get_vdev_work_memory_resp_event_id] = 14671 WMI_BPF_GET_VDEV_WORK_MEMORY_RESP_EVENTID; 14672 event_ids[wmi_wlan_sar2_result_event_id] = WMI_SAR2_RESULT_EVENTID; 14673 event_ids[wmi_esp_estimate_event_id] = WMI_ESP_ESTIMATE_EVENTID; 14674 event_ids[wmi_roam_scan_stats_event_id] = WMI_ROAM_SCAN_STATS_EVENTID; 14675 #ifdef WLAN_FEATURE_INTEROP_ISSUES_AP 14676 event_ids[wmi_pdev_interop_issues_ap_event_id] = 14677 WMI_PDEV_RAP_INFO_EVENTID; 14678 #endif 14679 #ifdef AST_HKV1_WORKAROUND 14680 event_ids[wmi_wds_peer_event_id] = WMI_WDS_PEER_EVENTID; 14681 #endif 14682 event_ids[wmi_pdev_ctl_failsafe_check_event_id] = 14683 WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID; 14684 event_ids[wmi_vdev_bcn_reception_stats_event_id] = 14685 WMI_VDEV_BCN_RECEPTION_STATS_EVENTID; 14686 event_ids[wmi_roam_blacklist_event_id] = WMI_ROAM_BLACKLIST_EVENTID; 14687 event_ids[wmi_wlm_stats_event_id] = WMI_WLM_STATS_EVENTID; 14688 event_ids[wmi_peer_cfr_capture_event_id] = WMI_PEER_CFR_CAPTURE_EVENTID; 14689 event_ids[wmi_pdev_cold_boot_cal_event_id] = 14690 WMI_PDEV_COLD_BOOT_CAL_DATA_EVENTID; 14691 #ifdef WLAN_MWS_INFO_DEBUGFS 14692 event_ids[wmi_vdev_get_mws_coex_state_eventid] = 14693 WMI_VDEV_GET_MWS_COEX_STATE_EVENTID; 14694 event_ids[wmi_vdev_get_mws_coex_dpwb_state_eventid] = 14695 WMI_VDEV_GET_MWS_COEX_DPWB_STATE_EVENTID; 14696 event_ids[wmi_vdev_get_mws_coex_tdm_state_eventid] = 14697 WMI_VDEV_GET_MWS_COEX_TDM_STATE_EVENTID; 14698 event_ids[wmi_vdev_get_mws_coex_idrx_state_eventid] = 14699 WMI_VDEV_GET_MWS_COEX_IDRX_STATE_EVENTID; 14700 event_ids[wmi_vdev_get_mws_coex_antenna_sharing_state_eventid] = 14701 WMI_VDEV_GET_MWS_COEX_ANTENNA_SHARING_STATE_EVENTID; 14702 #endif 14703 event_ids[wmi_coex_report_antenna_isolation_event_id] = 14704 WMI_COEX_REPORT_ANTENNA_ISOLATION_EVENTID; 14705 event_ids[wmi_peer_ratecode_list_event_id] = 14706 WMI_PEER_RATECODE_LIST_EVENTID; 14707 event_ids[wmi_chan_rf_characterization_info_event_id] = 14708 WMI_CHAN_RF_CHARACTERIZATION_INFO_EVENTID; 14709 event_ids[wmi_roam_auth_offload_event_id] = 14710 WMI_ROAM_PREAUTH_START_EVENTID; 14711 event_ids[wmi_get_elna_bypass_event_id] = WMI_GET_ELNA_BYPASS_EVENTID; 14712 event_ids[wmi_motion_det_host_eventid] = WMI_MOTION_DET_HOST_EVENTID; 14713 event_ids[wmi_motion_det_base_line_host_eventid] = 14714 WMI_MOTION_DET_BASE_LINE_HOST_EVENTID; 14715 event_ids[wmi_get_ani_level_event_id] = WMI_GET_CHANNEL_ANI_EVENTID; 14716 event_ids[wmi_peer_tx_pn_response_event_id] = 14717 WMI_PEER_TX_PN_RESPONSE_EVENTID; 14718 event_ids[wmi_roam_stats_event_id] = WMI_ROAM_STATS_EVENTID; 14719 event_ids[wmi_oem_data_event_id] = WMI_OEM_DATA_EVENTID; 14720 event_ids[wmi_mgmt_offload_data_event_id] = 14721 WMI_VDEV_MGMT_OFFLOAD_EVENTID; 14722 event_ids[wmi_nan_dmesg_event_id] = 14723 WMI_NAN_DMESG_EVENTID; 14724 event_ids[wmi_pdev_multi_vdev_restart_response_event_id] = 14725 WMI_PDEV_MULTIPLE_VDEV_RESTART_RESP_EVENTID; 14726 event_ids[wmi_roam_pmkid_request_event_id] = 14727 WMI_ROAM_PMKID_REQUEST_EVENTID; 14728 #ifdef FEATURE_WLAN_TIME_SYNC_FTM 14729 event_ids[wmi_wlan_time_sync_ftm_start_stop_event_id] = 14730 WMI_VDEV_AUDIO_SYNC_START_STOP_EVENTID; 14731 event_ids[wmi_wlan_time_sync_q_master_slave_offset_eventid] = 14732 WMI_VDEV_AUDIO_SYNC_Q_MASTER_SLAVE_OFFSET_EVENTID; 14733 #endif 14734 event_ids[wmi_roam_scan_chan_list_id] = 14735 WMI_ROAM_SCAN_CHANNEL_LIST_EVENTID; 14736 event_ids[wmi_muedca_params_config_eventid] = 14737 WMI_MUEDCA_PARAMS_CONFIG_EVENTID; 14738 event_ids[wmi_pdev_sscan_fw_param_eventid] = 14739 WMI_PDEV_SSCAN_FW_PARAM_EVENTID; 14740 } 14741 14742 /** 14743 * populate_tlv_service() - populates wmi services 14744 * 14745 * @param wmi_service: Pointer to hold wmi_service 14746 * Return: None 14747 */ 14748 static void populate_tlv_service(uint32_t *wmi_service) 14749 { 14750 wmi_service[wmi_service_beacon_offload] = WMI_SERVICE_BEACON_OFFLOAD; 14751 wmi_service[wmi_service_ack_timeout] = WMI_SERVICE_ACK_TIMEOUT; 14752 wmi_service[wmi_service_scan_offload] = WMI_SERVICE_SCAN_OFFLOAD; 14753 wmi_service[wmi_service_roam_scan_offload] = 14754 WMI_SERVICE_ROAM_SCAN_OFFLOAD; 14755 wmi_service[wmi_service_bcn_miss_offload] = 14756 WMI_SERVICE_BCN_MISS_OFFLOAD; 14757 wmi_service[wmi_service_sta_pwrsave] = WMI_SERVICE_STA_PWRSAVE; 14758 wmi_service[wmi_service_sta_advanced_pwrsave] = 14759 WMI_SERVICE_STA_ADVANCED_PWRSAVE; 14760 wmi_service[wmi_service_ap_uapsd] = WMI_SERVICE_AP_UAPSD; 14761 wmi_service[wmi_service_ap_dfs] = WMI_SERVICE_AP_DFS; 14762 wmi_service[wmi_service_11ac] = WMI_SERVICE_11AC; 14763 wmi_service[wmi_service_blockack] = WMI_SERVICE_BLOCKACK; 14764 wmi_service[wmi_service_phyerr] = WMI_SERVICE_PHYERR; 14765 wmi_service[wmi_service_bcn_filter] = WMI_SERVICE_BCN_FILTER; 14766 wmi_service[wmi_service_rtt] = WMI_SERVICE_RTT; 14767 wmi_service[wmi_service_wow] = WMI_SERVICE_WOW; 14768 wmi_service[wmi_service_ratectrl_cache] = WMI_SERVICE_RATECTRL_CACHE; 14769 wmi_service[wmi_service_iram_tids] = WMI_SERVICE_IRAM_TIDS; 14770 wmi_service[wmi_service_arpns_offload] = WMI_SERVICE_ARPNS_OFFLOAD; 14771 wmi_service[wmi_service_nlo] = WMI_SERVICE_NLO; 14772 wmi_service[wmi_service_gtk_offload] = WMI_SERVICE_GTK_OFFLOAD; 14773 wmi_service[wmi_service_scan_sch] = WMI_SERVICE_SCAN_SCH; 14774 wmi_service[wmi_service_csa_offload] = WMI_SERVICE_CSA_OFFLOAD; 14775 wmi_service[wmi_service_chatter] = WMI_SERVICE_CHATTER; 14776 wmi_service[wmi_service_coex_freqavoid] = WMI_SERVICE_COEX_FREQAVOID; 14777 wmi_service[wmi_service_packet_power_save] = 14778 WMI_SERVICE_PACKET_POWER_SAVE; 14779 wmi_service[wmi_service_force_fw_hang] = WMI_SERVICE_FORCE_FW_HANG; 14780 wmi_service[wmi_service_gpio] = WMI_SERVICE_GPIO; 14781 wmi_service[wmi_service_sta_dtim_ps_modulated_dtim] = 14782 WMI_SERVICE_STA_DTIM_PS_MODULATED_DTIM; 14783 wmi_service[wmi_sta_uapsd_basic_auto_trig] = 14784 WMI_STA_UAPSD_BASIC_AUTO_TRIG; 14785 wmi_service[wmi_sta_uapsd_var_auto_trig] = WMI_STA_UAPSD_VAR_AUTO_TRIG; 14786 wmi_service[wmi_service_sta_keep_alive] = WMI_SERVICE_STA_KEEP_ALIVE; 14787 wmi_service[wmi_service_tx_encap] = WMI_SERVICE_TX_ENCAP; 14788 wmi_service[wmi_service_ap_ps_detect_out_of_sync] = 14789 WMI_SERVICE_AP_PS_DETECT_OUT_OF_SYNC; 14790 wmi_service[wmi_service_early_rx] = WMI_SERVICE_EARLY_RX; 14791 wmi_service[wmi_service_sta_smps] = WMI_SERVICE_STA_SMPS; 14792 wmi_service[wmi_service_fwtest] = WMI_SERVICE_FWTEST; 14793 wmi_service[wmi_service_sta_wmmac] = WMI_SERVICE_STA_WMMAC; 14794 wmi_service[wmi_service_tdls] = WMI_SERVICE_TDLS; 14795 wmi_service[wmi_service_burst] = WMI_SERVICE_BURST; 14796 wmi_service[wmi_service_mcc_bcn_interval_change] = 14797 WMI_SERVICE_MCC_BCN_INTERVAL_CHANGE; 14798 wmi_service[wmi_service_adaptive_ocs] = WMI_SERVICE_ADAPTIVE_OCS; 14799 wmi_service[wmi_service_ba_ssn_support] = WMI_SERVICE_BA_SSN_SUPPORT; 14800 wmi_service[wmi_service_filter_ipsec_natkeepalive] = 14801 WMI_SERVICE_FILTER_IPSEC_NATKEEPALIVE; 14802 wmi_service[wmi_service_wlan_hb] = WMI_SERVICE_WLAN_HB; 14803 wmi_service[wmi_service_lte_ant_share_support] = 14804 WMI_SERVICE_LTE_ANT_SHARE_SUPPORT; 14805 wmi_service[wmi_service_batch_scan] = WMI_SERVICE_BATCH_SCAN; 14806 wmi_service[wmi_service_qpower] = WMI_SERVICE_QPOWER; 14807 wmi_service[wmi_service_plmreq] = WMI_SERVICE_PLMREQ; 14808 wmi_service[wmi_service_thermal_mgmt] = WMI_SERVICE_THERMAL_MGMT; 14809 wmi_service[wmi_service_rmc] = WMI_SERVICE_RMC; 14810 wmi_service[wmi_service_mhf_offload] = WMI_SERVICE_MHF_OFFLOAD; 14811 wmi_service[wmi_service_coex_sar] = WMI_SERVICE_COEX_SAR; 14812 wmi_service[wmi_service_bcn_txrate_override] = 14813 WMI_SERVICE_BCN_TXRATE_OVERRIDE; 14814 wmi_service[wmi_service_nan] = WMI_SERVICE_NAN; 14815 wmi_service[wmi_service_l1ss_stat] = WMI_SERVICE_L1SS_STAT; 14816 wmi_service[wmi_service_estimate_linkspeed] = 14817 WMI_SERVICE_ESTIMATE_LINKSPEED; 14818 wmi_service[wmi_service_obss_scan] = WMI_SERVICE_OBSS_SCAN; 14819 wmi_service[wmi_service_tdls_offchan] = WMI_SERVICE_TDLS_OFFCHAN; 14820 wmi_service[wmi_service_tdls_uapsd_buffer_sta] = 14821 WMI_SERVICE_TDLS_UAPSD_BUFFER_STA; 14822 wmi_service[wmi_service_tdls_uapsd_sleep_sta] = 14823 WMI_SERVICE_TDLS_UAPSD_SLEEP_STA; 14824 wmi_service[wmi_service_ibss_pwrsave] = WMI_SERVICE_IBSS_PWRSAVE; 14825 wmi_service[wmi_service_lpass] = WMI_SERVICE_LPASS; 14826 wmi_service[wmi_service_extscan] = WMI_SERVICE_EXTSCAN; 14827 wmi_service[wmi_service_d0wow] = WMI_SERVICE_D0WOW; 14828 wmi_service[wmi_service_hsoffload] = WMI_SERVICE_HSOFFLOAD; 14829 wmi_service[wmi_service_roam_ho_offload] = WMI_SERVICE_ROAM_HO_OFFLOAD; 14830 wmi_service[wmi_service_rx_full_reorder] = WMI_SERVICE_RX_FULL_REORDER; 14831 wmi_service[wmi_service_dhcp_offload] = WMI_SERVICE_DHCP_OFFLOAD; 14832 wmi_service[wmi_service_sta_rx_ipa_offload_support] = 14833 WMI_SERVICE_STA_RX_IPA_OFFLOAD_SUPPORT; 14834 wmi_service[wmi_service_mdns_offload] = WMI_SERVICE_MDNS_OFFLOAD; 14835 wmi_service[wmi_service_sap_auth_offload] = 14836 WMI_SERVICE_SAP_AUTH_OFFLOAD; 14837 wmi_service[wmi_service_dual_band_simultaneous_support] = 14838 WMI_SERVICE_DUAL_BAND_SIMULTANEOUS_SUPPORT; 14839 wmi_service[wmi_service_ocb] = WMI_SERVICE_OCB; 14840 wmi_service[wmi_service_ap_arpns_offload] = 14841 WMI_SERVICE_AP_ARPNS_OFFLOAD; 14842 wmi_service[wmi_service_per_band_chainmask_support] = 14843 WMI_SERVICE_PER_BAND_CHAINMASK_SUPPORT; 14844 wmi_service[wmi_service_packet_filter_offload] = 14845 WMI_SERVICE_PACKET_FILTER_OFFLOAD; 14846 wmi_service[wmi_service_mgmt_tx_htt] = WMI_SERVICE_MGMT_TX_HTT; 14847 wmi_service[wmi_service_mgmt_tx_wmi] = WMI_SERVICE_MGMT_TX_WMI; 14848 wmi_service[wmi_service_ext_msg] = WMI_SERVICE_EXT_MSG; 14849 wmi_service[wmi_service_ext2_msg] = WMI_SERVICE_EXT2_MSG; 14850 wmi_service[wmi_service_mawc] = WMI_SERVICE_MAWC; 14851 wmi_service[wmi_service_multiple_vdev_restart] = 14852 WMI_SERVICE_MULTIPLE_VDEV_RESTART; 14853 wmi_service[wmi_service_smart_antenna_sw_support] = 14854 WMI_SERVICE_SMART_ANTENNA_SW_SUPPORT; 14855 wmi_service[wmi_service_smart_antenna_hw_support] = 14856 WMI_SERVICE_SMART_ANTENNA_HW_SUPPORT; 14857 14858 wmi_service[wmi_service_roam_offload] = WMI_SERVICE_UNAVAILABLE; 14859 wmi_service[wmi_service_ratectrl] = WMI_SERVICE_UNAVAILABLE; 14860 wmi_service[wmi_service_enhanced_proxy_sta] = WMI_SERVICE_UNAVAILABLE; 14861 wmi_service[wmi_service_tt] = WMI_SERVICE_THERM_THROT; 14862 wmi_service[wmi_service_atf] = WMI_SERVICE_ATF; 14863 wmi_service[wmi_service_peer_caching] = WMI_SERVICE_UNAVAILABLE; 14864 wmi_service[wmi_service_coex_gpio] = WMI_SERVICE_UNAVAILABLE; 14865 wmi_service[wmi_service_aux_spectral_intf] = WMI_SERVICE_UNAVAILABLE; 14866 wmi_service[wmi_service_aux_chan_load_intf] = WMI_SERVICE_UNAVAILABLE; 14867 wmi_service[wmi_service_bss_channel_info_64] = WMI_SERVICE_UNAVAILABLE; 14868 wmi_service[wmi_service_ext_res_cfg_support] = WMI_SERVICE_UNAVAILABLE; 14869 wmi_service[wmi_service_mesh] = WMI_SERVICE_UNAVAILABLE; 14870 wmi_service[wmi_service_restrt_chnl_support] = WMI_SERVICE_UNAVAILABLE; 14871 wmi_service[wmi_service_peer_stats] = WMI_SERVICE_UNAVAILABLE; 14872 wmi_service[wmi_service_mesh_11s] = WMI_SERVICE_UNAVAILABLE; 14873 wmi_service[wmi_service_periodic_chan_stat_support] = 14874 WMI_SERVICE_PERIODIC_CHAN_STAT_SUPPORT; 14875 wmi_service[wmi_service_tx_mode_push_only] = WMI_SERVICE_UNAVAILABLE; 14876 wmi_service[wmi_service_tx_mode_push_pull] = WMI_SERVICE_UNAVAILABLE; 14877 wmi_service[wmi_service_tx_mode_dynamic] = WMI_SERVICE_UNAVAILABLE; 14878 wmi_service[wmi_service_btcoex_duty_cycle] = WMI_SERVICE_UNAVAILABLE; 14879 wmi_service[wmi_service_4_wire_coex_support] = WMI_SERVICE_UNAVAILABLE; 14880 wmi_service[wmi_service_mesh] = WMI_SERVICE_ENTERPRISE_MESH; 14881 wmi_service[wmi_service_peer_assoc_conf] = WMI_SERVICE_PEER_ASSOC_CONF; 14882 wmi_service[wmi_service_egap] = WMI_SERVICE_EGAP; 14883 wmi_service[wmi_service_sta_pmf_offload] = WMI_SERVICE_STA_PMF_OFFLOAD; 14884 wmi_service[wmi_service_unified_wow_capability] = 14885 WMI_SERVICE_UNIFIED_WOW_CAPABILITY; 14886 wmi_service[wmi_service_enterprise_mesh] = WMI_SERVICE_ENTERPRISE_MESH; 14887 wmi_service[wmi_service_apf_offload] = WMI_SERVICE_BPF_OFFLOAD; 14888 wmi_service[wmi_service_sync_delete_cmds] = 14889 WMI_SERVICE_SYNC_DELETE_CMDS; 14890 wmi_service[wmi_service_ratectrl_limit_max_min_rates] = 14891 WMI_SERVICE_RATECTRL_LIMIT_MAX_MIN_RATES; 14892 wmi_service[wmi_service_nan_data] = WMI_SERVICE_NAN_DATA; 14893 wmi_service[wmi_service_nan_rtt] = WMI_SERVICE_NAN_RTT; 14894 wmi_service[wmi_service_11ax] = WMI_SERVICE_11AX; 14895 wmi_service[wmi_service_deprecated_replace] = 14896 WMI_SERVICE_DEPRECATED_REPLACE; 14897 wmi_service[wmi_service_tdls_conn_tracker_in_host_mode] = 14898 WMI_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE; 14899 wmi_service[wmi_service_enhanced_mcast_filter] = 14900 WMI_SERVICE_ENHANCED_MCAST_FILTER; 14901 wmi_service[wmi_service_half_rate_quarter_rate_support] = 14902 WMI_SERVICE_HALF_RATE_QUARTER_RATE_SUPPORT; 14903 wmi_service[wmi_service_vdev_rx_filter] = WMI_SERVICE_VDEV_RX_FILTER; 14904 wmi_service[wmi_service_p2p_listen_offload_support] = 14905 WMI_SERVICE_P2P_LISTEN_OFFLOAD_SUPPORT; 14906 wmi_service[wmi_service_mark_first_wakeup_packet] = 14907 WMI_SERVICE_MARK_FIRST_WAKEUP_PACKET; 14908 wmi_service[wmi_service_multiple_mcast_filter_set] = 14909 WMI_SERVICE_MULTIPLE_MCAST_FILTER_SET; 14910 wmi_service[wmi_service_host_managed_rx_reorder] = 14911 WMI_SERVICE_HOST_MANAGED_RX_REORDER; 14912 wmi_service[wmi_service_flash_rdwr_support] = 14913 WMI_SERVICE_FLASH_RDWR_SUPPORT; 14914 wmi_service[wmi_service_wlan_stats_report] = 14915 WMI_SERVICE_WLAN_STATS_REPORT; 14916 wmi_service[wmi_service_tx_msdu_id_new_partition_support] = 14917 WMI_SERVICE_TX_MSDU_ID_NEW_PARTITION_SUPPORT; 14918 wmi_service[wmi_service_dfs_phyerr_offload] = 14919 WMI_SERVICE_DFS_PHYERR_OFFLOAD; 14920 wmi_service[wmi_service_rcpi_support] = WMI_SERVICE_RCPI_SUPPORT; 14921 wmi_service[wmi_service_fw_mem_dump_support] = 14922 WMI_SERVICE_FW_MEM_DUMP_SUPPORT; 14923 wmi_service[wmi_service_peer_stats_info] = WMI_SERVICE_PEER_STATS_INFO; 14924 wmi_service[wmi_service_regulatory_db] = WMI_SERVICE_REGULATORY_DB; 14925 wmi_service[wmi_service_11d_offload] = WMI_SERVICE_11D_OFFLOAD; 14926 wmi_service[wmi_service_hw_data_filtering] = 14927 WMI_SERVICE_HW_DATA_FILTERING; 14928 wmi_service[wmi_service_pkt_routing] = WMI_SERVICE_PKT_ROUTING; 14929 wmi_service[wmi_service_offchan_tx_wmi] = WMI_SERVICE_OFFCHAN_TX_WMI; 14930 wmi_service[wmi_service_chan_load_info] = WMI_SERVICE_CHAN_LOAD_INFO; 14931 wmi_service[wmi_service_extended_nss_support] = 14932 WMI_SERVICE_EXTENDED_NSS_SUPPORT; 14933 wmi_service[wmi_service_widebw_scan] = WMI_SERVICE_SCAN_PHYMODE_SUPPORT; 14934 wmi_service[wmi_service_bcn_offload_start_stop_support] = 14935 WMI_SERVICE_BCN_OFFLOAD_START_STOP_SUPPORT; 14936 wmi_service[wmi_service_offchan_data_tid_support] = 14937 WMI_SERVICE_OFFCHAN_DATA_TID_SUPPORT; 14938 wmi_service[wmi_service_support_dma] = 14939 WMI_SERVICE_SUPPORT_DIRECT_DMA; 14940 wmi_service[wmi_service_8ss_tx_bfee] = WMI_SERVICE_8SS_TX_BFEE; 14941 wmi_service[wmi_service_fils_support] = WMI_SERVICE_FILS_SUPPORT; 14942 wmi_service[wmi_service_mawc_support] = WMI_SERVICE_MAWC_SUPPORT; 14943 wmi_service[wmi_service_wow_wakeup_by_timer_pattern] = 14944 WMI_SERVICE_WOW_WAKEUP_BY_TIMER_PATTERN; 14945 wmi_service[wmi_service_11k_neighbour_report_support] = 14946 WMI_SERVICE_11K_NEIGHBOUR_REPORT_SUPPORT; 14947 wmi_service[wmi_service_ap_obss_detection_offload] = 14948 WMI_SERVICE_AP_OBSS_DETECTION_OFFLOAD; 14949 wmi_service[wmi_service_bss_color_offload] = 14950 WMI_SERVICE_BSS_COLOR_OFFLOAD; 14951 wmi_service[wmi_service_gmac_offload_support] = 14952 WMI_SERVICE_GMAC_OFFLOAD_SUPPORT; 14953 wmi_service[wmi_service_dual_beacon_on_single_mac_scc_support] = 14954 WMI_SERVICE_DUAL_BEACON_ON_SINGLE_MAC_SCC_SUPPORT; 14955 wmi_service[wmi_service_dual_beacon_on_single_mac_mcc_support] = 14956 WMI_SERVICE_DUAL_BEACON_ON_SINGLE_MAC_MCC_SUPPORT; 14957 wmi_service[wmi_service_twt_requestor] = WMI_SERVICE_STA_TWT; 14958 wmi_service[wmi_service_twt_responder] = WMI_SERVICE_AP_TWT; 14959 wmi_service[wmi_service_listen_interval_offload_support] = 14960 WMI_SERVICE_LISTEN_INTERVAL_OFFLOAD_SUPPORT; 14961 wmi_service[wmi_service_esp_support] = WMI_SERVICE_ESP_SUPPORT; 14962 wmi_service[wmi_service_obss_spatial_reuse] = 14963 WMI_SERVICE_OBSS_SPATIAL_REUSE; 14964 wmi_service[wmi_service_per_vdev_chain_support] = 14965 WMI_SERVICE_PER_VDEV_CHAINMASK_CONFIG_SUPPORT; 14966 wmi_service[wmi_service_new_htt_msg_format] = 14967 WMI_SERVICE_HTT_H2T_NO_HTC_HDR_LEN_IN_MSG_LEN; 14968 wmi_service[wmi_service_peer_unmap_cnf_support] = 14969 WMI_SERVICE_PEER_UNMAP_RESPONSE_SUPPORT; 14970 wmi_service[wmi_service_beacon_reception_stats] = 14971 WMI_SERVICE_BEACON_RECEPTION_STATS; 14972 wmi_service[wmi_service_vdev_latency_config] = 14973 WMI_SERVICE_VDEV_LATENCY_CONFIG; 14974 wmi_service[wmi_service_nan_dbs_support] = WMI_SERVICE_NAN_DBS_SUPPORT; 14975 wmi_service[wmi_service_ndi_dbs_support] = WMI_SERVICE_NDI_DBS_SUPPORT; 14976 wmi_service[wmi_service_nan_sap_support] = WMI_SERVICE_NAN_SAP_SUPPORT; 14977 wmi_service[wmi_service_ndi_sap_support] = WMI_SERVICE_NDI_SAP_SUPPORT; 14978 wmi_service[wmi_service_nan_disable_support] = 14979 WMI_SERVICE_NAN_DISABLE_SUPPORT; 14980 wmi_service[wmi_service_sta_plus_sta_support] = 14981 WMI_SERVICE_STA_PLUS_STA_SUPPORT; 14982 wmi_service[wmi_service_hw_db2dbm_support] = 14983 WMI_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT; 14984 wmi_service[wmi_service_wlm_stats_support] = 14985 WMI_SERVICE_WLM_STATS_REQUEST; 14986 wmi_service[wmi_service_infra_mbssid] = WMI_SERVICE_INFRA_MBSSID; 14987 wmi_service[wmi_service_ema_ap_support] = WMI_SERVICE_EMA_AP_SUPPORT; 14988 wmi_service[wmi_service_ul_ru26_allowed] = WMI_SERVICE_UL_RU26_ALLOWED; 14989 wmi_service[wmi_service_cfr_capture_support] = 14990 WMI_SERVICE_CFR_CAPTURE_SUPPORT; 14991 wmi_service[wmi_service_bcast_twt_support] = 14992 WMI_SERVICE_BROADCAST_TWT; 14993 wmi_service[wmi_service_wpa3_ft_sae_support] = 14994 WMI_SERVICE_WPA3_FT_SAE_SUPPORT; 14995 wmi_service[wmi_service_wpa3_ft_suite_b_support] = 14996 WMI_SERVICE_WPA3_FT_SUITE_B_SUPPORT; 14997 wmi_service[wmi_service_ft_fils] = 14998 WMI_SERVICE_WPA3_FT_FILS; 14999 wmi_service[wmi_service_adaptive_11r_support] = 15000 WMI_SERVICE_ADAPTIVE_11R_ROAM; 15001 wmi_service[wmi_service_tx_compl_tsf64] = 15002 WMI_SERVICE_TX_COMPL_TSF64; 15003 wmi_service[wmi_service_data_stall_recovery_support] = 15004 WMI_SERVICE_DSM_ROAM_FILTER; 15005 wmi_service[wmi_service_vdev_delete_all_peer] = 15006 WMI_SERVICE_DELETE_ALL_PEER_SUPPORT; 15007 wmi_service[wmi_service_three_way_coex_config_legacy] = 15008 WMI_SERVICE_THREE_WAY_COEX_CONFIG_LEGACY; 15009 wmi_service[wmi_service_rx_fse_support] = 15010 WMI_SERVICE_RX_FSE_SUPPORT; 15011 wmi_service[wmi_service_sae_roam_support] = 15012 WMI_SERVICE_WPA3_SAE_ROAM_SUPPORT; 15013 wmi_service[wmi_service_owe_roam_support] = 15014 WMI_SERVICE_WPA3_OWE_ROAM_SUPPORT; 15015 wmi_service[wmi_service_6ghz_support] = 15016 WMI_SERVICE_6GHZ_SUPPORT; 15017 wmi_service[wmi_service_bw_165mhz_support] = 15018 WMI_SERVICE_BW_165MHZ_SUPPORT; 15019 wmi_service[wmi_service_bw_restricted_80p80_support] = 15020 WMI_SERVICE_BW_RESTRICTED_80P80_SUPPORT; 15021 wmi_service[wmi_service_packet_capture_support] = 15022 WMI_SERVICE_PACKET_CAPTURE_SUPPORT; 15023 wmi_service[wmi_service_nan_vdev] = WMI_SERVICE_NAN_VDEV_SUPPORT; 15024 wmi_service[wmi_service_peer_delete_no_peer_flush_tids_cmd] = 15025 WMI_SERVICE_PEER_DELETE_NO_PEER_FLUSH_TIDS_CMD; 15026 wmi_service[wmi_service_multiple_vdev_restart_ext] = 15027 WMI_SERVICE_UNAVAILABLE; 15028 wmi_service[wmi_service_time_sync_ftm] = 15029 WMI_SERVICE_AUDIO_SYNC_SUPPORT; 15030 wmi_service[wmi_service_nss_ratio_to_host_support] = 15031 WMI_SERVICE_NSS_RATIO_TO_HOST_SUPPORT; 15032 wmi_service[wmi_roam_scan_chan_list_to_host_support] = 15033 WMI_SERVICE_ROAM_SCAN_CHANNEL_LIST_TO_HOST_SUPPORT; 15034 wmi_service[wmi_beacon_protection_support] = 15035 WMI_SERVICE_BEACON_PROTECTION_SUPPORT; 15036 wmi_service[wmi_service_sta_nan_ndi_four_port] = 15037 WMI_SERVICE_NDI_NDI_STA_SUPPORT; 15038 wmi_service[wmi_service_host_scan_stop_vdev_all] = 15039 WMI_SERVICE_HOST_SCAN_STOP_VDEV_ALL_SUPPORT; 15040 wmi_service[wmi_support_extend_address] = 15041 WMI_SERVICE_SUPPORT_EXTEND_ADDRESS; 15042 wmi_service[wmi_service_srg_srp_spatial_reuse_support] = 15043 WMI_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT; 15044 } 15045 15046 /** 15047 * wmi_ocb_ut_attach() - Attach OCB test framework 15048 * @wmi_handle: wmi handle 15049 * 15050 * Return: None 15051 */ 15052 #ifdef WLAN_OCB_UT 15053 void wmi_ocb_ut_attach(struct wmi_unified *wmi_handle); 15054 #else 15055 static inline void wmi_ocb_ut_attach(struct wmi_unified *wmi_handle) 15056 { 15057 return; 15058 } 15059 #endif 15060 15061 /** 15062 * wmi_tlv_attach() - Attach TLV APIs 15063 * 15064 * Return: None 15065 */ 15066 void wmi_tlv_attach(wmi_unified_t wmi_handle) 15067 { 15068 wmi_handle->ops = &tlv_ops; 15069 wmi_ocb_ut_attach(wmi_handle); 15070 wmi_handle->soc->svc_ids = &multi_svc_ids[0]; 15071 #ifdef WMI_INTERFACE_EVENT_LOGGING 15072 /* Skip saving WMI_CMD_HDR and TLV HDR */ 15073 wmi_handle->soc->buf_offset_command = 8; 15074 /* WMI_CMD_HDR is already stripped, skip saving TLV HDR */ 15075 wmi_handle->soc->buf_offset_event = 4; 15076 #endif 15077 populate_tlv_events_id(wmi_handle->wmi_events); 15078 populate_tlv_service(wmi_handle->services); 15079 wmi_twt_attach_tlv(wmi_handle); 15080 wmi_extscan_attach_tlv(wmi_handle); 15081 wmi_smart_ant_attach_tlv(wmi_handle); 15082 wmi_dbr_attach_tlv(wmi_handle); 15083 wmi_atf_attach_tlv(wmi_handle); 15084 wmi_ap_attach_tlv(wmi_handle); 15085 wmi_bcn_attach_tlv(wmi_handle); 15086 wmi_ocb_attach_tlv(wmi_handle); 15087 wmi_nan_attach_tlv(wmi_handle); 15088 wmi_p2p_attach_tlv(wmi_handle); 15089 wmi_interop_issues_ap_attach_tlv(wmi_handle); 15090 wmi_dcs_attach_tlv(wmi_handle); 15091 wmi_roam_attach_tlv(wmi_handle); 15092 wmi_concurrency_attach_tlv(wmi_handle); 15093 wmi_pmo_attach_tlv(wmi_handle); 15094 wmi_sta_attach_tlv(wmi_handle); 15095 wmi_11ax_bss_color_attach_tlv(wmi_handle); 15096 wmi_fwol_attach_tlv(wmi_handle); 15097 wmi_vdev_attach_tlv(wmi_handle); 15098 wmi_cfr_attach_tlv(wmi_handle); 15099 } 15100 qdf_export_symbol(wmi_tlv_attach); 15101 15102 /** 15103 * wmi_tlv_init() - Initialize WMI TLV module by registering TLV attach routine 15104 * 15105 * Return: None 15106 */ 15107 void wmi_tlv_init(void) 15108 { 15109 wmi_unified_register_module(WMI_TLV_TARGET, &wmi_tlv_attach); 15110 } 15111