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