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