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