1 /* 2 * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <osdep.h> 21 #include "wmi.h" 22 #include "wmi_version.h" 23 #include "wmi_unified_priv.h" 24 #include "wmi_unified_sta_param.h" 25 #include "wmi_unified_sta_api.h" 26 #ifdef FEATURE_WLAN_TDLS 27 #include <wlan_tdls_public_structs.h> 28 #endif 29 30 /** 31 * send_set_sta_sa_query_param_cmd_tlv() - set sta sa query parameters 32 * @wmi_handle: wmi handle 33 * @vdev_id: vdev id 34 * @max_retries: max retries 35 * @retry_interval: retry interval 36 * This function sets sta query related parameters in fw. 37 * 38 * Return: QDF_STATUS_SUCCESS for success otherwise failure 39 */ 40 static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle, 41 uint8_t vdev_id, 42 uint32_t max_retries, 43 uint32_t retry_interval) 44 { 45 wmi_buf_t buf; 46 WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *cmd; 47 int len; 48 49 len = sizeof(*cmd); 50 buf = wmi_buf_alloc(wmi_handle, len); 51 if (!buf) { 52 return QDF_STATUS_E_FAILURE; 53 } 54 55 cmd = (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *)wmi_buf_data(buf); 56 WMITLV_SET_HDR(&cmd->tlv_header, 57 WMITLV_TAG_STRUC_WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param, 58 WMITLV_GET_STRUCT_TLVLEN 59 (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param)); 60 61 cmd->vdev_id = vdev_id; 62 cmd->sa_query_max_retry_count = max_retries; 63 cmd->sa_query_retry_interval = retry_interval; 64 65 wmi_debug("STA sa query: vdev_id:%d interval:%u retry count:%d", 66 vdev_id, retry_interval, max_retries); 67 68 wmi_mtrace(WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID, cmd->vdev_id, 0); 69 if (wmi_unified_cmd_send(wmi_handle, buf, len, 70 WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID)) { 71 wmi_err("Failed to offload STA SA Query"); 72 wmi_buf_free(buf); 73 return QDF_STATUS_E_FAILURE; 74 } 75 76 wmi_debug("Exit"); 77 return 0; 78 } 79 80 /** 81 * send_set_sta_keep_alive_cmd_tlv() - set sta keep alive parameters 82 * @wmi_handle: wmi handle 83 * @params: sta keep alive parameter 84 * 85 * This function sets keep alive related parameters in fw. 86 * 87 * Return: CDF status 88 */ 89 static QDF_STATUS 90 send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle, 91 struct sta_keep_alive_params *params) 92 { 93 wmi_buf_t buf; 94 WMI_STA_KEEPALIVE_CMD_fixed_param *cmd; 95 WMI_STA_KEEPALVE_ARP_RESPONSE *arp_rsp; 96 uint8_t *buf_ptr; 97 int len; 98 QDF_STATUS ret; 99 100 wmi_debug("Enter"); 101 102 len = sizeof(*cmd) + sizeof(*arp_rsp); 103 buf = wmi_buf_alloc(wmi_handle, len); 104 if (!buf) { 105 return QDF_STATUS_E_FAILURE; 106 } 107 108 cmd = (WMI_STA_KEEPALIVE_CMD_fixed_param *) wmi_buf_data(buf); 109 buf_ptr = (uint8_t *) cmd; 110 WMITLV_SET_HDR(&cmd->tlv_header, 111 WMITLV_TAG_STRUC_WMI_STA_KEEPALIVE_CMD_fixed_param, 112 WMITLV_GET_STRUCT_TLVLEN 113 (WMI_STA_KEEPALIVE_CMD_fixed_param)); 114 cmd->interval = params->timeperiod; 115 cmd->enable = (params->timeperiod) ? 1 : 0; 116 cmd->vdev_id = params->vdev_id; 117 wmi_debug("Keep Alive: vdev_id:%d interval:%u method:%d", 118 params->vdev_id, params->timeperiod, params->method); 119 arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd)); 120 WMITLV_SET_HDR(&arp_rsp->tlv_header, 121 WMITLV_TAG_STRUC_WMI_STA_KEEPALVE_ARP_RESPONSE, 122 WMITLV_GET_STRUCT_TLVLEN(WMI_STA_KEEPALVE_ARP_RESPONSE)); 123 124 if ((params->method == WMI_KEEP_ALIVE_UNSOLICIT_ARP_RSP) || 125 (params->method == 126 WMI_STA_KEEPALIVE_METHOD_GRATUITOUS_ARP_REQUEST)) { 127 cmd->method = params->method; 128 qdf_mem_copy(&arp_rsp->sender_prot_addr, params->hostv4addr, 129 QDF_IPV4_ADDR_SIZE); 130 qdf_mem_copy(&arp_rsp->target_prot_addr, params->destv4addr, 131 QDF_IPV4_ADDR_SIZE); 132 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->destmac, 133 &arp_rsp->dest_mac_addr); 134 } else if (WMI_KEEP_ALIVE_MGMT_FRAME == params->method) { 135 cmd->method = WMI_STA_KEEPALIVE_METHOD_MGMT_VENDOR_ACTION; 136 } else { 137 cmd->method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME; 138 } 139 140 wmi_mtrace(WMI_STA_KEEPALIVE_CMDID, cmd->vdev_id, 0); 141 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 142 WMI_STA_KEEPALIVE_CMDID); 143 if (QDF_IS_STATUS_ERROR(ret)) { 144 wmi_err("Failed to set KeepAlive"); 145 wmi_buf_free(buf); 146 } 147 148 wmi_debug("Exit"); 149 return ret; 150 } 151 152 /** 153 * send_vdev_set_gtx_cfg_cmd_tlv() - set GTX params 154 * @wmi_handle: wmi handle 155 * @if_id: vdev id 156 * @gtx_info: GTX config params 157 * 158 * This function set GTX related params in firmware. 159 * 160 * Return: QDF_STATUS_SUCCESS for success or error code 161 */ 162 static QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32_t if_id, 163 struct wmi_gtx_config *gtx_info) 164 { 165 wmi_vdev_set_gtx_params_cmd_fixed_param *cmd; 166 wmi_buf_t buf; 167 QDF_STATUS ret; 168 int len = sizeof(wmi_vdev_set_gtx_params_cmd_fixed_param); 169 170 buf = wmi_buf_alloc(wmi_handle, len); 171 if (!buf) { 172 return QDF_STATUS_E_NOMEM; 173 } 174 cmd = (wmi_vdev_set_gtx_params_cmd_fixed_param *) wmi_buf_data(buf); 175 WMITLV_SET_HDR(&cmd->tlv_header, 176 WMITLV_TAG_STRUC_wmi_vdev_set_gtx_params_cmd_fixed_param, 177 WMITLV_GET_STRUCT_TLVLEN 178 (wmi_vdev_set_gtx_params_cmd_fixed_param)); 179 cmd->vdev_id = if_id; 180 181 cmd->gtxRTMask[0] = gtx_info->gtx_rt_mask[0]; 182 cmd->gtxRTMask[1] = gtx_info->gtx_rt_mask[1]; 183 cmd->userGtxMask = gtx_info->gtx_usrcfg; 184 cmd->gtxPERThreshold = gtx_info->gtx_threshold; 185 cmd->gtxPERMargin = gtx_info->gtx_margin; 186 cmd->gtxTPCstep = gtx_info->gtx_tpcstep; 187 cmd->gtxTPCMin = gtx_info->gtx_tpcmin; 188 cmd->gtxBWMask = gtx_info->gtx_bwmask; 189 190 wmi_debug("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \ 191 gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \ 192 gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1], 193 cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin, 194 cmd->gtxTPCstep, cmd->gtxTPCMin, cmd->gtxBWMask); 195 196 wmi_mtrace(WMI_VDEV_SET_GTX_PARAMS_CMDID, cmd->vdev_id, 0); 197 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 198 WMI_VDEV_SET_GTX_PARAMS_CMDID); 199 if (QDF_IS_STATUS_ERROR(ret)) { 200 wmi_err("Failed to set GTX PARAMS"); 201 wmi_buf_free(buf); 202 } 203 return ret; 204 } 205 206 /** 207 * send_process_dhcp_ind_cmd_tlv() - process dhcp indication from SME 208 * @wmi_handle: wmi handle 209 * @ta_dhcp_ind: DHCP indication parameter 210 * 211 * Return: CDF Status 212 */ 213 static QDF_STATUS send_process_dhcp_ind_cmd_tlv(wmi_unified_t wmi_handle, 214 wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind) 215 { 216 QDF_STATUS status; 217 wmi_buf_t buf = NULL; 218 uint8_t *buf_ptr; 219 wmi_peer_set_param_cmd_fixed_param *peer_set_param_fp; 220 int len = sizeof(wmi_peer_set_param_cmd_fixed_param); 221 222 buf = wmi_buf_alloc(wmi_handle, len); 223 if (!buf) { 224 return QDF_STATUS_E_NOMEM; 225 } 226 227 buf_ptr = (uint8_t *) wmi_buf_data(buf); 228 peer_set_param_fp = (wmi_peer_set_param_cmd_fixed_param *) buf_ptr; 229 WMITLV_SET_HDR(&peer_set_param_fp->tlv_header, 230 WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param, 231 WMITLV_GET_STRUCT_TLVLEN 232 (wmi_peer_set_param_cmd_fixed_param)); 233 234 /* fill in values */ 235 peer_set_param_fp->vdev_id = ta_dhcp_ind->vdev_id; 236 peer_set_param_fp->param_id = ta_dhcp_ind->param_id; 237 peer_set_param_fp->param_value = ta_dhcp_ind->param_value; 238 qdf_mem_copy(&peer_set_param_fp->peer_macaddr, 239 &ta_dhcp_ind->peer_macaddr, 240 sizeof(ta_dhcp_ind->peer_macaddr)); 241 242 wmi_mtrace(WMI_PEER_SET_PARAM_CMDID, NO_SESSION, 0); 243 status = wmi_unified_cmd_send(wmi_handle, buf, 244 len, WMI_PEER_SET_PARAM_CMDID); 245 if (QDF_IS_STATUS_ERROR(status)) { 246 wmi_err("wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD" 247 " returned Error %d", status); 248 wmi_buf_free(buf); 249 } 250 251 return status; 252 } 253 254 /** 255 * send_get_link_speed_cmd_tlv() -send command to get linkspeed 256 * @wmi_handle: wmi handle 257 * @pLinkSpeed: link speed info 258 * 259 * Return: CDF status 260 */ 261 static QDF_STATUS send_get_link_speed_cmd_tlv(wmi_unified_t wmi_handle, 262 wmi_mac_addr peer_macaddr) 263 { 264 wmi_peer_get_estimated_linkspeed_cmd_fixed_param *cmd; 265 wmi_buf_t wmi_buf; 266 uint32_t len; 267 uint8_t *buf_ptr; 268 269 len = sizeof(wmi_peer_get_estimated_linkspeed_cmd_fixed_param); 270 wmi_buf = wmi_buf_alloc(wmi_handle, len); 271 if (!wmi_buf) { 272 return QDF_STATUS_E_NOMEM; 273 } 274 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 275 276 cmd = (wmi_peer_get_estimated_linkspeed_cmd_fixed_param *) buf_ptr; 277 WMITLV_SET_HDR(&cmd->tlv_header, 278 WMITLV_TAG_STRUC_wmi_peer_get_estimated_linkspeed_cmd_fixed_param, 279 WMITLV_GET_STRUCT_TLVLEN 280 (wmi_peer_get_estimated_linkspeed_cmd_fixed_param)); 281 282 /* Copy the peer macaddress to the wma buffer */ 283 qdf_mem_copy(&cmd->peer_macaddr, 284 &peer_macaddr, 285 sizeof(peer_macaddr)); 286 287 wmi_mtrace(WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID, cmd->vdev_id, 0); 288 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 289 WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) { 290 wmi_err("Failed to send link speed command"); 291 wmi_buf_free(wmi_buf); 292 return QDF_STATUS_E_FAILURE; 293 } 294 return QDF_STATUS_SUCCESS; 295 } 296 297 /** 298 * send_fw_profiling_cmd_tlv() - send FW profiling cmd to WLAN FW 299 * @wmi_handl: wmi handle 300 * @cmd: Profiling command index 301 * @value1: parameter1 value 302 * @value2: parameter2 value 303 * 304 * Return: QDF_STATUS_SUCCESS for success else error code 305 */ 306 static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle, 307 uint32_t cmd, uint32_t value1, uint32_t value2) 308 { 309 wmi_buf_t buf; 310 int32_t len = 0; 311 int ret; 312 wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd; 313 wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd; 314 wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd; 315 wmi_wlan_profile_get_prof_data_cmd_fixed_param *profile_getdata_cmd; 316 317 switch (cmd) { 318 case WMI_WLAN_PROFILE_TRIGGER_CMDID: 319 len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param); 320 buf = wmi_buf_alloc(wmi_handle, len); 321 if (!buf) { 322 return QDF_STATUS_E_NOMEM; 323 } 324 prof_trig_cmd = 325 (wmi_wlan_profile_trigger_cmd_fixed_param *) 326 wmi_buf_data(buf); 327 WMITLV_SET_HDR(&prof_trig_cmd->tlv_header, 328 WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param, 329 WMITLV_GET_STRUCT_TLVLEN 330 (wmi_wlan_profile_trigger_cmd_fixed_param)); 331 prof_trig_cmd->enable = value1; 332 wmi_mtrace(WMI_WLAN_PROFILE_TRIGGER_CMDID, NO_SESSION, 0); 333 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 334 WMI_WLAN_PROFILE_TRIGGER_CMDID); 335 if (ret) { 336 wmi_err("PROFILE_TRIGGER cmd Failed with value %d", 337 value1); 338 wmi_buf_free(buf); 339 return ret; 340 } 341 break; 342 343 case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID: 344 len = sizeof(wmi_wlan_profile_get_prof_data_cmd_fixed_param); 345 buf = wmi_buf_alloc(wmi_handle, len); 346 if (!buf) { 347 return QDF_STATUS_E_NOMEM; 348 } 349 profile_getdata_cmd = 350 (wmi_wlan_profile_get_prof_data_cmd_fixed_param *) 351 wmi_buf_data(buf); 352 WMITLV_SET_HDR(&profile_getdata_cmd->tlv_header, 353 WMITLV_TAG_STRUC_wmi_wlan_profile_get_prof_data_cmd_fixed_param, 354 WMITLV_GET_STRUCT_TLVLEN 355 (wmi_wlan_profile_get_prof_data_cmd_fixed_param)); 356 wmi_mtrace(WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID, 357 NO_SESSION, 0); 358 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 359 WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID); 360 if (ret) { 361 wmi_err("PROFILE_DATA cmd Failed for id %d value %d", 362 value1, value2); 363 wmi_buf_free(buf); 364 return ret; 365 } 366 break; 367 368 case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID: 369 len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param); 370 buf = wmi_buf_alloc(wmi_handle, len); 371 if (!buf) { 372 return QDF_STATUS_E_NOMEM; 373 } 374 hist_intvl_cmd = 375 (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *) 376 wmi_buf_data(buf); 377 WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header, 378 WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param, 379 WMITLV_GET_STRUCT_TLVLEN 380 (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param)); 381 hist_intvl_cmd->profile_id = value1; 382 hist_intvl_cmd->value = value2; 383 wmi_mtrace(WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID, 384 NO_SESSION, 0); 385 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 386 WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID); 387 if (ret) { 388 wmi_err("HIST_INTVL cmd Failed for id %d value %d", 389 value1, value2); 390 wmi_buf_free(buf); 391 return ret; 392 } 393 break; 394 395 case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID: 396 len = 397 sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param); 398 buf = wmi_buf_alloc(wmi_handle, len); 399 if (!buf) { 400 return QDF_STATUS_E_NOMEM; 401 } 402 profile_enable_cmd = 403 (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *) 404 wmi_buf_data(buf); 405 WMITLV_SET_HDR(&profile_enable_cmd->tlv_header, 406 WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param, 407 WMITLV_GET_STRUCT_TLVLEN 408 (wmi_wlan_profile_enable_profile_id_cmd_fixed_param)); 409 profile_enable_cmd->profile_id = value1; 410 profile_enable_cmd->enable = value2; 411 wmi_mtrace(WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID, 412 NO_SESSION, 0); 413 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 414 WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID); 415 if (ret) { 416 wmi_err("enable cmd Failed for id %d value %d", 417 value1, value2); 418 wmi_buf_free(buf); 419 return ret; 420 } 421 break; 422 423 default: 424 wmi_debug("Invalid profiling command: %u", cmd); 425 break; 426 } 427 428 return 0; 429 } 430 431 /** 432 * send_nat_keepalive_en_cmd_tlv() - enable NAT keepalive filter 433 * @wmi_handle: wmi handle 434 * @vdev_id: vdev id 435 * 436 * Return: QDF_STATUS_SUCCESS for success or error code 437 */ 438 static QDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id) 439 { 440 WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *cmd; 441 wmi_buf_t buf; 442 int32_t len = sizeof(*cmd); 443 444 wmi_debug("vdev_id: %d", vdev_id); 445 buf = wmi_buf_alloc(wmi_handle, len); 446 if (!buf) { 447 return QDF_STATUS_E_NOMEM; 448 } 449 cmd = (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *) 450 wmi_buf_data(buf); 451 WMITLV_SET_HDR(&cmd->tlv_header, 452 WMITLV_TAG_STRUC_WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param, 453 WMITLV_GET_STRUCT_TLVLEN 454 (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param)); 455 cmd->vdev_id = vdev_id; 456 cmd->action = IPSEC_NATKEEPALIVE_FILTER_ENABLE; 457 wmi_mtrace(WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID, cmd->vdev_id, 0); 458 if (wmi_unified_cmd_send(wmi_handle, buf, len, 459 WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID)) { 460 wmi_err("Failed to send NAT keepalive enable command"); 461 wmi_buf_free(buf); 462 return QDF_STATUS_E_FAILURE; 463 } 464 465 return 0; 466 } 467 468 #ifdef MULTI_CLIENT_LL_SUPPORT 469 /** 470 * fill_multi_client_ll_info - Fill multi client low latency info to wlm cmd 471 * @cmd: wlm config command 472 * @params: wlm params 473 * 474 * Return: none 475 */ 476 static void fill_multi_client_ll_info(wmi_wlm_config_cmd_fixed_param *cmd, 477 struct wlm_latency_level_param *params) 478 { 479 cmd->client_id_bitmask = params->client_id_bitmask; 480 WLM_FLAGS_SET_FORCE_DEFAULT_LATENCY(cmd->flags_ext, 481 params->force_reset); 482 } 483 #else 484 static inline void 485 fill_multi_client_ll_info(wmi_wlm_config_cmd_fixed_param *cmd, 486 struct wlm_latency_level_param *params) 487 { 488 } 489 #endif 490 491 static QDF_STATUS send_wlm_latency_level_cmd_tlv(wmi_unified_t wmi_handle, 492 struct wlm_latency_level_param *params) 493 { 494 wmi_wlm_config_cmd_fixed_param *cmd; 495 wmi_buf_t buf; 496 uint32_t len = sizeof(*cmd); 497 static uint32_t ll[4] = {100, 60, 40, 20}; 498 499 buf = wmi_buf_alloc(wmi_handle, len); 500 if (!buf) { 501 return QDF_STATUS_E_NOMEM; 502 } 503 cmd = (wmi_wlm_config_cmd_fixed_param *)wmi_buf_data(buf); 504 WMITLV_SET_HDR(&cmd->tlv_header, 505 WMITLV_TAG_STRUC_wmi_wlm_config_cmd_fixed_param, 506 WMITLV_GET_STRUCT_TLVLEN 507 (wmi_wlm_config_cmd_fixed_param)); 508 cmd->vdev_id = params->vdev_id; 509 cmd->latency_level = params->wlm_latency_level; 510 cmd->ul_latency = ll[params->wlm_latency_level]; 511 cmd->dl_latency = ll[params->wlm_latency_level]; 512 cmd->flags = params->wlm_latency_flags; 513 fill_multi_client_ll_info(cmd, params); 514 515 wmi_mtrace(WMI_WLM_CONFIG_CMDID, cmd->vdev_id, 0); 516 if (wmi_unified_cmd_send(wmi_handle, buf, len, 517 WMI_WLM_CONFIG_CMDID)) { 518 wmi_err("Failed to send setting latency config command"); 519 wmi_buf_free(buf); 520 return QDF_STATUS_E_FAILURE; 521 } 522 523 return 0; 524 } 525 526 #ifdef FEATURE_WLAN_TDLS 527 /** 528 * tdls_get_wmi_offchannel_mode - Get WMI tdls off channel mode 529 * @tdls_sw_mode: tdls_sw_mode 530 * 531 * This function returns wmi tdls offchannel mode 532 * 533 * Return: enum value of wmi tdls offchannel mode 534 */ 535 static uint8_t tdls_get_wmi_offchannel_mode(uint8_t tdls_sw_mode) 536 { 537 uint8_t off_chan_mode; 538 539 switch (tdls_sw_mode) { 540 case ENABLE_CHANSWITCH: 541 off_chan_mode = WMI_TDLS_ENABLE_OFFCHANNEL; 542 break; 543 544 case DISABLE_CHANSWITCH: 545 off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL; 546 break; 547 548 default: 549 wmi_debug("unknown tdls_sw_mode: %d", tdls_sw_mode); 550 off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL; 551 } 552 return off_chan_mode; 553 } 554 555 /** 556 * tdls_get_wmi_offchannel_bw - Get WMI tdls off channel Bandwidth 557 * @tdls_sw_mode: tdls_sw_mode 558 * 559 * This function returns wmi tdls offchannel bandwidth 560 * 561 * Return: TDLS offchannel bandwidth 562 */ 563 static uint8_t tdls_get_wmi_offchannel_bw(uint16_t tdls_off_ch_bw_offset) 564 { 565 uint8_t off_chan_bw; 566 567 switch (tdls_off_ch_bw_offset) { 568 case BW20: 569 off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ; 570 break; 571 case BW40_LOW_PRIMARY: 572 case BW40_HIGH_PRIMARY: 573 off_chan_bw = WMI_TDLS_OFFCHAN_40MHZ; 574 break; 575 case BW80: 576 off_chan_bw = WMI_TDLS_OFFCHAN_80MHZ; 577 break; 578 case BWALL: 579 off_chan_bw = WMI_TDLS_OFFCHAN_160MHZ; 580 break; 581 default: 582 wmi_debug("unknown tdls offchannel bw offset: %d", 583 tdls_off_ch_bw_offset); 584 off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ; 585 } 586 return off_chan_bw; 587 } 588 589 /** 590 * send_set_tdls_offchan_mode_cmd_tlv() - set tdls off channel mode 591 * @wmi_handle: wmi handle 592 * @chan_switch_params: Pointer to tdls channel switch parameter structure 593 * 594 * This function sets tdls off channel mode 595 * 596 * Return: 0 on success; Negative errno otherwise 597 */ 598 static QDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle, 599 struct tdls_channel_switch_params *chan_switch_params) 600 { 601 wmi_tdls_set_offchan_mode_cmd_fixed_param *cmd; 602 wmi_buf_t wmi_buf; 603 u_int16_t len = sizeof(wmi_tdls_set_offchan_mode_cmd_fixed_param); 604 605 wmi_buf = wmi_buf_alloc(wmi_handle, len); 606 if (!wmi_buf) { 607 return QDF_STATUS_E_FAILURE; 608 } 609 cmd = (wmi_tdls_set_offchan_mode_cmd_fixed_param *) 610 wmi_buf_data(wmi_buf); 611 WMITLV_SET_HDR(&cmd->tlv_header, 612 WMITLV_TAG_STRUC_wmi_tdls_set_offchan_mode_cmd_fixed_param, 613 WMITLV_GET_STRUCT_TLVLEN( 614 wmi_tdls_set_offchan_mode_cmd_fixed_param)); 615 616 WMI_CHAR_ARRAY_TO_MAC_ADDR(chan_switch_params->peer_mac_addr, 617 &cmd->peer_macaddr); 618 cmd->vdev_id = chan_switch_params->vdev_id; 619 cmd->offchan_mode = 620 tdls_get_wmi_offchannel_mode(chan_switch_params->tdls_sw_mode); 621 cmd->is_peer_responder = chan_switch_params->is_responder; 622 cmd->offchan_freq = chan_switch_params->tdls_off_chan_freq; 623 cmd->offchan_num = chan_switch_params->tdls_off_ch; 624 cmd->offchan_bw_bitmap = 625 tdls_get_wmi_offchannel_bw( 626 chan_switch_params->tdls_off_ch_bw_offset); 627 cmd->offchan_oper_class = chan_switch_params->oper_class; 628 629 wmi_debug("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x", 630 cmd->peer_macaddr.mac_addr31to0, 631 cmd->peer_macaddr.mac_addr47to32); 632 633 wmi_debug("vdev_id: %d, off channel mode: %d, off channel Num: %d, " 634 "off channel frequency: %u off channel offset: 0x%x, " 635 "is_peer_responder: %d, operating class: %d", 636 cmd->vdev_id, 637 cmd->offchan_mode, 638 cmd->offchan_num, 639 cmd->offchan_freq, 640 cmd->offchan_bw_bitmap, 641 cmd->is_peer_responder, 642 cmd->offchan_oper_class); 643 644 wmi_mtrace(WMI_TDLS_SET_OFFCHAN_MODE_CMDID, cmd->vdev_id, 0); 645 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 646 WMI_TDLS_SET_OFFCHAN_MODE_CMDID)) { 647 wmi_err("failed to send tdls off chan command"); 648 wmi_buf_free(wmi_buf); 649 return QDF_STATUS_E_FAILURE; 650 } 651 652 return QDF_STATUS_SUCCESS; 653 } 654 655 /** 656 * send_update_fw_tdls_state_cmd_tlv() - send enable/disable tdls for a vdev 657 * @wmi_handle: wmi handle 658 * @pwmaTdlsparams: TDLS params 659 * 660 * Return: 0 for success or error code 661 */ 662 static QDF_STATUS 663 send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle, 664 struct tdls_info *tdls_param, 665 enum wmi_tdls_state tdls_state) 666 { 667 wmi_tdls_set_state_cmd_fixed_param *cmd; 668 wmi_buf_t wmi_buf; 669 670 uint16_t len = sizeof(wmi_tdls_set_state_cmd_fixed_param); 671 672 wmi_buf = wmi_buf_alloc(wmi_handle, len); 673 if (!wmi_buf) { 674 return QDF_STATUS_E_FAILURE; 675 } 676 cmd = (wmi_tdls_set_state_cmd_fixed_param *) wmi_buf_data(wmi_buf); 677 WMITLV_SET_HDR(&cmd->tlv_header, 678 WMITLV_TAG_STRUC_wmi_tdls_set_state_cmd_fixed_param, 679 WMITLV_GET_STRUCT_TLVLEN 680 (wmi_tdls_set_state_cmd_fixed_param)); 681 cmd->vdev_id = tdls_param->vdev_id; 682 cmd->state = (A_UINT32)tdls_state; 683 cmd->notification_interval_ms = tdls_param->notification_interval_ms; 684 cmd->tx_discovery_threshold = tdls_param->tx_discovery_threshold; 685 cmd->tx_teardown_threshold = tdls_param->tx_teardown_threshold; 686 cmd->rssi_teardown_threshold = tdls_param->rssi_teardown_threshold; 687 cmd->rssi_delta = tdls_param->rssi_delta; 688 cmd->tdls_options = tdls_param->tdls_options; 689 cmd->tdls_peer_traffic_ind_window = tdls_param->peer_traffic_ind_window; 690 cmd->tdls_peer_traffic_response_timeout_ms = 691 tdls_param->peer_traffic_response_timeout; 692 cmd->tdls_puapsd_mask = tdls_param->puapsd_mask; 693 cmd->tdls_puapsd_inactivity_time_ms = 694 tdls_param->puapsd_inactivity_time; 695 cmd->tdls_puapsd_rx_frame_threshold = 696 tdls_param->puapsd_rx_frame_threshold; 697 cmd->teardown_notification_ms = 698 tdls_param->teardown_notification_ms; 699 cmd->tdls_peer_kickout_threshold = 700 tdls_param->tdls_peer_kickout_threshold; 701 cmd->tdls_discovery_wake_timeout = 702 tdls_param->tdls_discovery_wake_timeout; 703 704 wmi_debug("vdev %d tdls_state: %d, state: %d, " 705 "notification_interval_ms: %d, " 706 "tx_discovery_threshold: %d, " 707 "tx_teardown_threshold: %d, " 708 "rssi_teardown_threshold: %d, " 709 "rssi_delta: %d, " 710 "tdls_options: 0x%x, " 711 "tdls_peer_traffic_ind_window: %d, " 712 "tdls_peer_traffic_response_timeout: %d, " 713 "tdls_puapsd_mask: 0x%x, " 714 "tdls_puapsd_inactivity_time: %d, " 715 "tdls_puapsd_rx_frame_threshold: %d, " 716 "teardown_notification_ms: %d, " 717 "tdls_peer_kickout_threshold: %d, " 718 "tdls_discovery_wake_timeout: %d", 719 tdls_param->vdev_id, tdls_state, cmd->state, 720 cmd->notification_interval_ms, 721 cmd->tx_discovery_threshold, 722 cmd->tx_teardown_threshold, 723 cmd->rssi_teardown_threshold, 724 cmd->rssi_delta, 725 cmd->tdls_options, 726 cmd->tdls_peer_traffic_ind_window, 727 cmd->tdls_peer_traffic_response_timeout_ms, 728 cmd->tdls_puapsd_mask, 729 cmd->tdls_puapsd_inactivity_time_ms, 730 cmd->tdls_puapsd_rx_frame_threshold, 731 cmd->teardown_notification_ms, 732 cmd->tdls_peer_kickout_threshold, 733 cmd->tdls_discovery_wake_timeout); 734 735 wmi_mtrace(WMI_TDLS_SET_STATE_CMDID, cmd->vdev_id, 0); 736 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 737 WMI_TDLS_SET_STATE_CMDID)) { 738 wmi_err("Failed to send tdls set state command"); 739 wmi_buf_free(wmi_buf); 740 return QDF_STATUS_E_FAILURE; 741 } 742 743 return QDF_STATUS_SUCCESS; 744 } 745 746 /** 747 * send_update_tdls_peer_state_cmd_tlv() - update TDLS peer state 748 * @wmi_handle: wmi handle 749 * @peer_state: TDLS peer state params 750 * 751 * Return: QDF_STATUS_SUCCESS for success or error code 752 */ 753 static QDF_STATUS 754 send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle, 755 struct tdls_peer_update_state *peer_state, 756 uint32_t *ch_mhz) 757 { 758 struct tdls_peer_params *in_peer_cap; 759 struct tdls_ch_params *in_chan_info; 760 wmi_tdls_peer_update_cmd_fixed_param *cmd; 761 wmi_tdls_peer_capabilities *peer_cap; 762 wmi_channel *chan_info; 763 wmi_buf_t wmi_buf; 764 uint8_t *buf_ptr; 765 uint32_t i; 766 int32_t len = sizeof(wmi_tdls_peer_update_cmd_fixed_param) + 767 sizeof(wmi_tdls_peer_capabilities); 768 769 in_peer_cap = &peer_state->peer_cap; 770 len += WMI_TLV_HDR_SIZE + 771 sizeof(wmi_channel) * in_peer_cap->peer_chanlen; 772 773 wmi_buf = wmi_buf_alloc(wmi_handle, len); 774 if (!wmi_buf) { 775 return QDF_STATUS_E_FAILURE; 776 } 777 778 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 779 cmd = (wmi_tdls_peer_update_cmd_fixed_param *) buf_ptr; 780 WMITLV_SET_HDR(&cmd->tlv_header, 781 WMITLV_TAG_STRUC_wmi_tdls_peer_update_cmd_fixed_param, 782 WMITLV_GET_STRUCT_TLVLEN 783 (wmi_tdls_peer_update_cmd_fixed_param)); 784 785 cmd->vdev_id = peer_state->vdev_id; 786 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_state->peer_macaddr, 787 &cmd->peer_macaddr); 788 789 cmd->peer_state = peer_state->peer_state; 790 791 wmi_debug("vdev_id: %d, peermac: "QDF_MAC_ADDR_FMT", " 792 "peer_macaddr.mac_addr31to0: 0x%x, " 793 "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d", 794 cmd->vdev_id, 795 QDF_MAC_ADDR_REF(peer_state->peer_macaddr), 796 cmd->peer_macaddr.mac_addr31to0, 797 cmd->peer_macaddr.mac_addr47to32, cmd->peer_state); 798 799 buf_ptr += sizeof(wmi_tdls_peer_update_cmd_fixed_param); 800 peer_cap = (wmi_tdls_peer_capabilities *) buf_ptr; 801 WMITLV_SET_HDR(&peer_cap->tlv_header, 802 WMITLV_TAG_STRUC_wmi_tdls_peer_capabilities, 803 WMITLV_GET_STRUCT_TLVLEN(wmi_tdls_peer_capabilities)); 804 805 if ((in_peer_cap->peer_uapsd_queue & 0x08) >> 3) 806 WMI_SET_TDLS_PEER_VO_UAPSD(peer_cap); 807 if ((in_peer_cap->peer_uapsd_queue & 0x04) >> 2) 808 WMI_SET_TDLS_PEER_VI_UAPSD(peer_cap); 809 if ((in_peer_cap->peer_uapsd_queue & 0x02) >> 1) 810 WMI_SET_TDLS_PEER_BK_UAPSD(peer_cap); 811 if (in_peer_cap->peer_uapsd_queue & 0x01) 812 WMI_SET_TDLS_PEER_BE_UAPSD(peer_cap); 813 814 /* Ack and More Data Ack are sent as 0, so no need to set 815 * but fill SP 816 */ 817 WMI_SET_TDLS_PEER_SP_UAPSD(peer_cap, in_peer_cap->peer_max_sp); 818 819 peer_cap->buff_sta_support = in_peer_cap->peer_buff_sta_support; 820 peer_cap->off_chan_support = in_peer_cap->peer_off_chan_support; 821 peer_cap->peer_curr_operclass = in_peer_cap->peer_curr_operclass; 822 /* self curr operclass is not being used and so pass op class for 823 * preferred off chan in it. 824 */ 825 peer_cap->self_curr_operclass = in_peer_cap->opclass_for_prefoffchan; 826 peer_cap->peer_chan_len = in_peer_cap->peer_chanlen; 827 peer_cap->peer_operclass_len = in_peer_cap->peer_oper_classlen; 828 829 wmi_debug("peer_operclass_len: %d", peer_cap->peer_operclass_len); 830 for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) { 831 peer_cap->peer_operclass[i] = in_peer_cap->peer_oper_class[i]; 832 } 833 qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG, 834 (uint8_t *)peer_cap->peer_operclass, 835 WMI_TDLS_MAX_SUPP_OPER_CLASSES); 836 837 peer_cap->is_peer_responder = in_peer_cap->is_peer_responder; 838 peer_cap->pref_offchan_freq = in_peer_cap->pref_offchan_freq; 839 peer_cap->pref_offchan_num = in_peer_cap->pref_off_channum; 840 peer_cap->pref_offchan_bw = in_peer_cap->pref_off_chan_bandwidth; 841 842 wmi_debug("peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, " 843 "peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: " 844 "%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:" 845 " %d, pref_offchan_bw: %d, pref_offchan_freq: %u", 846 peer_cap->peer_qos, peer_cap->buff_sta_support, 847 peer_cap->off_chan_support, peer_cap->peer_curr_operclass, 848 peer_cap->self_curr_operclass, peer_cap->peer_chan_len, 849 peer_cap->peer_operclass_len, peer_cap->is_peer_responder, 850 peer_cap->pref_offchan_num, peer_cap->pref_offchan_bw, 851 peer_cap->pref_offchan_freq); 852 853 /* next fill variable size array of peer chan info */ 854 buf_ptr += sizeof(wmi_tdls_peer_capabilities); 855 WMITLV_SET_HDR(buf_ptr, 856 WMITLV_TAG_ARRAY_STRUC, 857 sizeof(wmi_channel) * 858 in_peer_cap->peer_chanlen); 859 860 chan_info = (wmi_channel *) (buf_ptr + WMI_TLV_HDR_SIZE); 861 in_chan_info = in_peer_cap->peer_chan; 862 863 for (i = 0; i < in_peer_cap->peer_chanlen; ++i) { 864 WMITLV_SET_HDR(&chan_info->tlv_header, 865 WMITLV_TAG_STRUC_wmi_channel, 866 WMITLV_GET_STRUCT_TLVLEN(wmi_channel)); 867 chan_info->mhz = ch_mhz[i]; 868 chan_info->band_center_freq1 = chan_info->mhz; 869 chan_info->band_center_freq2 = 0; 870 871 wmi_debug("chan[%d] = %u", i, chan_info->mhz); 872 873 if (in_chan_info->dfs_set) { 874 WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE); 875 wmi_debug("chan_freq[%d] DFS[%d]", 876 in_chan_info->ch_freq, 877 in_chan_info->dfs_set); 878 } 879 880 if (chan_info->mhz < WMI_2_4_GHZ_MAX_FREQ) 881 WMI_SET_CHANNEL_MODE(chan_info, MODE_11G); 882 else 883 WMI_SET_CHANNEL_MODE(chan_info, MODE_11A); 884 885 WMI_SET_CHANNEL_MAX_TX_POWER(chan_info, in_chan_info->pwr); 886 WMI_SET_CHANNEL_REG_POWER(chan_info, in_chan_info->pwr); 887 wmi_debug("Channel TX power[%d] = %u: %d", i, chan_info->mhz, 888 in_chan_info->pwr); 889 890 chan_info++; 891 in_chan_info++; 892 } 893 894 wmi_mtrace(WMI_TDLS_PEER_UPDATE_CMDID, cmd->vdev_id, 0); 895 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 896 WMI_TDLS_PEER_UPDATE_CMDID)) { 897 wmi_err("Failed to send tdls peer update state command"); 898 wmi_buf_free(wmi_buf); 899 return QDF_STATUS_E_FAILURE; 900 } 901 902 return QDF_STATUS_SUCCESS; 903 } 904 905 /** 906 * extract_vdev_tdls_ev_param_tlv() - extract vdev tdls param from event 907 * @wmi_handle: wmi handle 908 * @param evt_buf: pointer to event buffer 909 * @param param: Pointer to hold vdev tdls param 910 * 911 * Return: QDF_STATUS_SUCCESS for success or error code 912 */ 913 static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle, 914 void *evt_buf, struct tdls_event_info *param) 915 { 916 WMI_TDLS_PEER_EVENTID_param_tlvs *param_buf; 917 wmi_tdls_peer_event_fixed_param *evt; 918 919 param_buf = (WMI_TDLS_PEER_EVENTID_param_tlvs *)evt_buf; 920 if (!param_buf) { 921 wmi_err("NULL param_buf"); 922 return QDF_STATUS_E_NULL_VALUE; 923 } 924 925 evt = param_buf->fixed_param; 926 927 qdf_mem_zero(param, sizeof(*param)); 928 929 param->vdev_id = evt->vdev_id; 930 WMI_MAC_ADDR_TO_CHAR_ARRAY(&evt->peer_macaddr, 931 param->peermac.bytes); 932 switch (evt->peer_status) { 933 case WMI_TDLS_SHOULD_DISCOVER: 934 param->message_type = TDLS_SHOULD_DISCOVER; 935 break; 936 case WMI_TDLS_SHOULD_TEARDOWN: 937 param->message_type = TDLS_SHOULD_TEARDOWN; 938 break; 939 case WMI_TDLS_PEER_DISCONNECTED: 940 param->message_type = TDLS_PEER_DISCONNECTED; 941 break; 942 case WMI_TDLS_CONNECTION_TRACKER_NOTIFICATION: 943 param->message_type = TDLS_CONNECTION_TRACKER_NOTIFY; 944 break; 945 default: 946 wmi_err("Discarding unknown tdls event %d from target", 947 evt->peer_status); 948 return QDF_STATUS_E_INVAL; 949 }; 950 951 switch (evt->peer_reason) { 952 case WMI_TDLS_TEARDOWN_REASON_TX: 953 param->peer_reason = TDLS_TEARDOWN_TX; 954 break; 955 case WMI_TDLS_TEARDOWN_REASON_RSSI: 956 param->peer_reason = TDLS_TEARDOWN_RSSI; 957 break; 958 case WMI_TDLS_TEARDOWN_REASON_SCAN: 959 param->peer_reason = TDLS_TEARDOWN_SCAN; 960 break; 961 case WMI_TDLS_DISCONNECTED_REASON_PEER_DELETE: 962 param->peer_reason = TDLS_DISCONNECTED_PEER_DELETE; 963 break; 964 case WMI_TDLS_TEARDOWN_REASON_PTR_TIMEOUT: 965 param->peer_reason = TDLS_TEARDOWN_PTR_TIMEOUT; 966 break; 967 case WMI_TDLS_TEARDOWN_REASON_BAD_PTR: 968 param->peer_reason = TDLS_TEARDOWN_BAD_PTR; 969 break; 970 case WMI_TDLS_TEARDOWN_REASON_NO_RESPONSE: 971 param->peer_reason = TDLS_TEARDOWN_NO_RSP; 972 break; 973 case WMI_TDLS_ENTER_BUF_STA: 974 param->peer_reason = TDLS_PEER_ENTER_BUF_STA; 975 break; 976 case WMI_TDLS_EXIT_BUF_STA: 977 param->peer_reason = TDLS_PEER_EXIT_BUF_STA; 978 break; 979 case WMI_TDLS_ENTER_BT_BUSY_MODE: 980 param->peer_reason = TDLS_ENTER_BT_BUSY; 981 break; 982 case WMI_TDLS_EXIT_BT_BUSY_MODE: 983 param->peer_reason = TDLS_EXIT_BT_BUSY; 984 break; 985 case WMI_TDLS_SCAN_STARTED_EVENT: 986 param->peer_reason = TDLS_SCAN_STARTED; 987 break; 988 case WMI_TDLS_SCAN_COMPLETED_EVENT: 989 param->peer_reason = TDLS_SCAN_COMPLETED; 990 break; 991 992 default: 993 wmi_err("Unknown reason %d in tdls event %d from target", 994 evt->peer_reason, evt->peer_status); 995 return QDF_STATUS_E_INVAL; 996 }; 997 998 wmi_debug("tdls event, peer: "QDF_MAC_ADDR_FMT", type: 0x%x, reason: %d, vdev: %d", 999 QDF_MAC_ADDR_REF(param->peermac.bytes), 1000 param->message_type, 1001 param->peer_reason, param->vdev_id); 1002 1003 return QDF_STATUS_SUCCESS; 1004 } 1005 1006 void wmi_tdls_attach_tlv(struct wmi_unified *wmi_handle) 1007 { 1008 struct wmi_ops *ops = wmi_handle->ops; 1009 1010 ops->send_set_tdls_offchan_mode_cmd = 1011 send_set_tdls_offchan_mode_cmd_tlv; 1012 ops->send_update_fw_tdls_state_cmd = 1013 send_update_fw_tdls_state_cmd_tlv; 1014 ops->send_update_tdls_peer_state_cmd = 1015 send_update_tdls_peer_state_cmd_tlv; 1016 ops->extract_vdev_tdls_ev_param = extract_vdev_tdls_ev_param_tlv; 1017 } 1018 #endif /* FEATURE_WLAN_TDLS */ 1019 1020 /* 1021 * send_process_set_ie_info_cmd_tlv() - Function to send IE info to firmware 1022 * @wmi_handle: Pointer to WMi handle 1023 * @ie_data: Pointer for ie data 1024 * 1025 * This function sends IE information to firmware 1026 * 1027 * Return: QDF_STATUS_SUCCESS for success otherwise failure 1028 * 1029 */ 1030 static QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle, 1031 struct vdev_ie_info_param *ie_info) 1032 { 1033 wmi_vdev_set_ie_cmd_fixed_param *cmd; 1034 wmi_buf_t buf; 1035 uint8_t *buf_ptr; 1036 uint32_t len, ie_len_aligned; 1037 QDF_STATUS ret; 1038 1039 ie_len_aligned = roundup(ie_info->length, sizeof(uint32_t)); 1040 /* Allocate memory for the WMI command */ 1041 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + ie_len_aligned; 1042 1043 buf = wmi_buf_alloc(wmi_handle, len); 1044 if (!buf) { 1045 return QDF_STATUS_E_NOMEM; 1046 } 1047 1048 buf_ptr = wmi_buf_data(buf); 1049 qdf_mem_zero(buf_ptr, len); 1050 1051 /* Populate the WMI command */ 1052 cmd = (wmi_vdev_set_ie_cmd_fixed_param *)buf_ptr; 1053 1054 WMITLV_SET_HDR(&cmd->tlv_header, 1055 WMITLV_TAG_STRUC_wmi_vdev_set_ie_cmd_fixed_param, 1056 WMITLV_GET_STRUCT_TLVLEN( 1057 wmi_vdev_set_ie_cmd_fixed_param)); 1058 cmd->vdev_id = ie_info->vdev_id; 1059 cmd->ie_id = ie_info->ie_id; 1060 cmd->ie_len = ie_info->length; 1061 cmd->band = ie_info->band; 1062 1063 wmi_debug("IE:%d of size:%d sent for vdev:%d", ie_info->ie_id, 1064 ie_info->length, ie_info->vdev_id); 1065 1066 buf_ptr += sizeof(*cmd); 1067 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned); 1068 buf_ptr += WMI_TLV_HDR_SIZE; 1069 1070 qdf_mem_copy(buf_ptr, ie_info->data, cmd->ie_len); 1071 1072 wmi_mtrace(WMI_VDEV_SET_IE_CMDID, cmd->vdev_id, 0); 1073 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 1074 WMI_VDEV_SET_IE_CMDID); 1075 if (QDF_IS_STATUS_ERROR(ret)) { 1076 wmi_err("Failed to send set IE command ret = %d", ret); 1077 wmi_buf_free(buf); 1078 } 1079 1080 return ret; 1081 } 1082 1083 /** 1084 * send_set_base_macaddr_indicate_cmd_tlv() - set base mac address in fw 1085 * @wmi_handle: wmi handle 1086 * @custom_addr: base mac address 1087 * 1088 * Return: QDF_STATUS_SUCCESS for success or error code 1089 */ 1090 static QDF_STATUS send_set_base_macaddr_indicate_cmd_tlv(wmi_unified_t wmi_handle, 1091 uint8_t *custom_addr) 1092 { 1093 wmi_pdev_set_base_macaddr_cmd_fixed_param *cmd; 1094 wmi_buf_t buf; 1095 int err; 1096 1097 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1098 if (!buf) { 1099 return QDF_STATUS_E_NOMEM; 1100 } 1101 1102 cmd = (wmi_pdev_set_base_macaddr_cmd_fixed_param *) wmi_buf_data(buf); 1103 qdf_mem_zero(cmd, sizeof(*cmd)); 1104 1105 WMITLV_SET_HDR(&cmd->tlv_header, 1106 WMITLV_TAG_STRUC_wmi_pdev_set_base_macaddr_cmd_fixed_param, 1107 WMITLV_GET_STRUCT_TLVLEN 1108 (wmi_pdev_set_base_macaddr_cmd_fixed_param)); 1109 WMI_CHAR_ARRAY_TO_MAC_ADDR(custom_addr, &cmd->base_macaddr); 1110 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 1111 wmi_handle, 1112 WMI_HOST_PDEV_ID_SOC); 1113 wmi_mtrace(WMI_PDEV_SET_BASE_MACADDR_CMDID, NO_SESSION, 0); 1114 err = wmi_unified_cmd_send(wmi_handle, buf, 1115 sizeof(*cmd), 1116 WMI_PDEV_SET_BASE_MACADDR_CMDID); 1117 if (err) { 1118 wmi_err("Failed to send set_base_macaddr cmd"); 1119 wmi_buf_free(buf); 1120 return QDF_STATUS_E_FAILURE; 1121 } 1122 1123 return 0; 1124 } 1125 1126 #if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(FEATURE_DENYLIST_MGR) 1127 1128 static WMI_BSSID_DISALLOW_LIST_TYPE 1129 wmi_get_wmi_reject_ap_type(enum dlm_reject_ap_type reject_ap_type) 1130 { 1131 switch (reject_ap_type) { 1132 case USERSPACE_AVOID_TYPE: 1133 return WMI_BSSID_DISALLOW_USER_SPACE_AVOID_LIST; 1134 case DRIVER_AVOID_TYPE: 1135 return WMI_BSSID_DISALLOW_DRIVER_AVOID_LIST; 1136 case USERSPACE_DENYLIST_TYPE: 1137 return WMI_BSSID_DISALLOW_USER_SPACE_BLACK_LIST; 1138 case DRIVER_DENYLIST_TYPE: 1139 return WMI_BSSID_DISALLOW_DRIVER_BLACK_LIST; 1140 case DRIVER_RSSI_REJECT_TYPE: 1141 return WMI_BSSID_DISALLOW_RSSI_REJECT_LIST; 1142 default: 1143 return WMI_BSSID_DISALLOW_DRIVER_AVOID_LIST; 1144 } 1145 } 1146 1147 static WMI_BLACKLIST_REASON_ID 1148 wmi_get_reject_reason(enum dlm_reject_ap_reason reject_reason) 1149 { 1150 switch(reject_reason) { 1151 case REASON_NUD_FAILURE: 1152 return WMI_BL_REASON_NUD_FAILURE; 1153 case REASON_STA_KICKOUT: 1154 return WMI_BL_REASON_STA_KICKOUT; 1155 case REASON_ROAM_HO_FAILURE: 1156 return WMI_BL_REASON_ROAM_HO_FAILURE; 1157 case REASON_ASSOC_REJECT_POOR_RSSI: 1158 return WMI_BL_REASON_ASSOC_REJECT_POOR_RSSI; 1159 case REASON_ASSOC_REJECT_OCE: 1160 return WMI_BL_REASON_ASSOC_REJECT_OCE; 1161 case REASON_USERSPACE_BL: 1162 return WMI_BL_REASON_USERSPACE_BL; 1163 case REASON_USERSPACE_AVOID_LIST: 1164 return WMI_BL_REASON_USERSPACE_AVOID_LIST; 1165 case REASON_BTM_DISASSOC_IMMINENT: 1166 return WMI_BL_REASON_BTM_DIASSOC_IMMINENT; 1167 case REASON_BTM_BSS_TERMINATION: 1168 return WMI_BL_REASON_BTM_BSS_TERMINATION; 1169 case REASON_BTM_MBO_RETRY: 1170 return WMI_BL_REASON_BTM_MBO_RETRY; 1171 case REASON_REASSOC_RSSI_REJECT: 1172 return WMI_BL_REASON_REASSOC_RSSI_REJECT; 1173 case REASON_REASSOC_NO_MORE_STAS: 1174 return WMI_BL_REASON_REASSOC_NO_MORE_STAS; 1175 default: 1176 return 0; 1177 } 1178 } 1179 1180 static QDF_STATUS 1181 send_reject_ap_list_cmd_tlv(wmi_unified_t wmi_handle, 1182 struct reject_ap_params *reject_params) 1183 { 1184 wmi_buf_t buf; 1185 QDF_STATUS status; 1186 uint32_t len, list_tlv_len; 1187 int i; 1188 uint8_t *buf_ptr; 1189 wmi_pdev_dsm_filter_fixed_param *chan_list_fp; 1190 wmi_pdev_bssid_disallow_list_config_param *chan_list; 1191 struct reject_ap_config_params *reject_list = reject_params->bssid_list; 1192 uint8_t num_of_reject_bssid = reject_params->num_of_reject_bssid; 1193 1194 list_tlv_len = sizeof(*chan_list) * num_of_reject_bssid; 1195 1196 len = sizeof(*chan_list_fp) + list_tlv_len + WMI_TLV_HDR_SIZE; 1197 buf = wmi_buf_alloc(wmi_handle, len); 1198 if (!buf) 1199 return QDF_STATUS_E_NOMEM; 1200 1201 wmi_debug("num of reject BSSIDs %d", num_of_reject_bssid); 1202 1203 buf_ptr = (uint8_t *)wmi_buf_data(buf); 1204 chan_list_fp = (wmi_pdev_dsm_filter_fixed_param *)buf_ptr; 1205 WMITLV_SET_HDR(&chan_list_fp->tlv_header, 1206 WMITLV_TAG_STRUC_wmi_pdev_dsm_filter_fixed_param, 1207 WMITLV_GET_STRUCT_TLVLEN 1208 (wmi_pdev_dsm_filter_fixed_param)); 1209 1210 buf_ptr += sizeof(wmi_pdev_dsm_filter_fixed_param); 1211 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, list_tlv_len); 1212 1213 buf_ptr += WMI_TLV_HDR_SIZE; 1214 chan_list = (wmi_pdev_bssid_disallow_list_config_param *)buf_ptr; 1215 for (i = 0; i < num_of_reject_bssid; i++) { 1216 1217 WMITLV_SET_HDR(&chan_list->tlv_header, 1218 WMITLV_TAG_STRUC_wmi_pdev_bssid_disallow_list_config_param, 1219 WMITLV_GET_STRUCT_TLVLEN 1220 (wmi_pdev_bssid_disallow_list_config_param)); 1221 WMI_CHAR_ARRAY_TO_MAC_ADDR(reject_list[i].bssid.bytes, 1222 &chan_list->bssid); 1223 chan_list->bssid_type = 1224 wmi_get_wmi_reject_ap_type(reject_list[i].reject_ap_type); 1225 chan_list->expected_rssi = reject_list[i].expected_rssi; 1226 chan_list->remaining_disallow_duration = 1227 reject_list[i].reject_duration; 1228 chan_list->reason = 1229 wmi_get_reject_reason(reject_list[i].reject_reason); 1230 chan_list->original_timeout = reject_list[i].original_timeout; 1231 chan_list->timestamp = reject_list[i].received_time; 1232 chan_list->source = reject_list[i].source; 1233 chan_list++; 1234 } 1235 1236 wmi_mtrace(WMI_PDEV_DSM_FILTER_CMDID, NO_SESSION, 0); 1237 status = wmi_unified_cmd_send(wmi_handle, buf, 1238 len, WMI_PDEV_DSM_FILTER_CMDID); 1239 if (QDF_IS_STATUS_ERROR(status)) { 1240 wmi_err("wmi_unified_cmd_send WMI_PDEV_DSM_FILTER_CMDID returned Error %d", 1241 status); 1242 goto error; 1243 } 1244 1245 return QDF_STATUS_SUCCESS; 1246 error: 1247 wmi_buf_free(buf); 1248 return status; 1249 } 1250 1251 void wmi_denylist_mgr_attach_tlv(struct wmi_unified *wmi_handle) 1252 { 1253 struct wmi_ops *ops = wmi_handle->ops; 1254 1255 ops->send_reject_ap_list_cmd = send_reject_ap_list_cmd_tlv; 1256 } 1257 #endif 1258 1259 /** 1260 * send_sar_limit_cmd_tlv() - send sar limit cmd to fw 1261 * @wmi_handle: wmi handle 1262 * @params: sar limit params 1263 * 1264 * Return: QDF_STATUS_SUCCESS for success or error code 1265 */ 1266 static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle, 1267 struct sar_limit_cmd_params *sar_limit_params) 1268 { 1269 wmi_buf_t buf; 1270 QDF_STATUS qdf_status; 1271 wmi_sar_limits_cmd_fixed_param *cmd; 1272 int i; 1273 uint8_t *buf_ptr; 1274 wmi_sar_limit_cmd_row *wmi_sar_rows_list; 1275 struct sar_limit_cmd_row *sar_rows_list; 1276 uint32_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE; 1277 1278 len += sizeof(wmi_sar_limit_cmd_row) * sar_limit_params->num_limit_rows; 1279 buf = wmi_buf_alloc(wmi_handle, len); 1280 if (!buf) { 1281 qdf_status = QDF_STATUS_E_NOMEM; 1282 goto end; 1283 } 1284 1285 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1286 cmd = (wmi_sar_limits_cmd_fixed_param *) buf_ptr; 1287 WMITLV_SET_HDR(&cmd->tlv_header, 1288 WMITLV_TAG_STRUC_wmi_sar_limits_cmd_fixed_param, 1289 WMITLV_GET_STRUCT_TLVLEN 1290 (wmi_sar_limits_cmd_fixed_param)); 1291 cmd->sar_enable = sar_limit_params->sar_enable; 1292 cmd->commit_limits = sar_limit_params->commit_limits; 1293 cmd->num_limit_rows = sar_limit_params->num_limit_rows; 1294 1295 wmi_debug("no of sar rows = %d, len = %d", 1296 sar_limit_params->num_limit_rows, len); 1297 buf_ptr += sizeof(*cmd); 1298 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 1299 sizeof(wmi_sar_limit_cmd_row) * 1300 sar_limit_params->num_limit_rows); 1301 if (cmd->num_limit_rows == 0) 1302 goto send_sar_limits; 1303 1304 wmi_sar_rows_list = (wmi_sar_limit_cmd_row *) 1305 (buf_ptr + WMI_TLV_HDR_SIZE); 1306 sar_rows_list = sar_limit_params->sar_limit_row_list; 1307 1308 for (i = 0; i < sar_limit_params->num_limit_rows; i++) { 1309 WMITLV_SET_HDR(&wmi_sar_rows_list->tlv_header, 1310 WMITLV_TAG_STRUC_wmi_sar_limit_cmd_row, 1311 WMITLV_GET_STRUCT_TLVLEN(wmi_sar_limit_cmd_row)); 1312 wmi_sar_rows_list->band_id = sar_rows_list->band_id; 1313 wmi_sar_rows_list->chain_id = sar_rows_list->chain_id; 1314 wmi_sar_rows_list->mod_id = sar_rows_list->mod_id; 1315 wmi_sar_rows_list->limit_value = sar_rows_list->limit_value; 1316 wmi_sar_rows_list->validity_bitmap = 1317 sar_rows_list->validity_bitmap; 1318 wmi_debug("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d", 1319 i, wmi_sar_rows_list->band_id, 1320 wmi_sar_rows_list->chain_id, 1321 wmi_sar_rows_list->mod_id, 1322 wmi_sar_rows_list->limit_value, 1323 wmi_sar_rows_list->validity_bitmap); 1324 sar_rows_list++; 1325 wmi_sar_rows_list++; 1326 } 1327 send_sar_limits: 1328 wmi_mtrace(WMI_SAR_LIMITS_CMDID, NO_SESSION, 0); 1329 qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len, 1330 WMI_SAR_LIMITS_CMDID); 1331 1332 if (QDF_IS_STATUS_ERROR(qdf_status)) { 1333 wmi_err("Failed to send WMI_SAR_LIMITS_CMDID"); 1334 wmi_buf_free(buf); 1335 } 1336 1337 end: 1338 return qdf_status; 1339 } 1340 1341 static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle) 1342 { 1343 wmi_sar_get_limits_cmd_fixed_param *cmd; 1344 wmi_buf_t wmi_buf; 1345 uint32_t len; 1346 QDF_STATUS status; 1347 1348 wmi_debug("Enter"); 1349 1350 len = sizeof(*cmd); 1351 wmi_buf = wmi_buf_alloc(wmi_handle, len); 1352 if (!wmi_buf) { 1353 return QDF_STATUS_E_NOMEM; 1354 } 1355 1356 cmd = (wmi_sar_get_limits_cmd_fixed_param *)wmi_buf_data(wmi_buf); 1357 1358 WMITLV_SET_HDR(&cmd->tlv_header, 1359 WMITLV_TAG_STRUC_wmi_sar_get_limits_cmd_fixed_param, 1360 WMITLV_GET_STRUCT_TLVLEN 1361 (wmi_sar_get_limits_cmd_fixed_param)); 1362 1363 cmd->reserved = 0; 1364 1365 wmi_mtrace(WMI_SAR_GET_LIMITS_CMDID, NO_SESSION, 0); 1366 status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 1367 WMI_SAR_GET_LIMITS_CMDID); 1368 if (QDF_IS_STATUS_ERROR(status)) { 1369 wmi_err("Failed to send get SAR limit cmd: %d", status); 1370 wmi_buf_free(wmi_buf); 1371 } 1372 1373 wmi_debug("Exit"); 1374 1375 return status; 1376 } 1377 1378 /** 1379 * wmi_sar2_result_string() - return string conversion of sar2 result 1380 * @result: sar2 result value 1381 * 1382 * This utility function helps log string conversion of sar2 result. 1383 * 1384 * Return: string conversion of sar 2 result, if match found; 1385 * "Unknown response" otherwise. 1386 */ 1387 static const char *wmi_sar2_result_string(uint32_t result) 1388 { 1389 switch (result) { 1390 CASE_RETURN_STRING(WMI_SAR2_SUCCESS); 1391 CASE_RETURN_STRING(WMI_SAR2_INVALID_ANTENNA_INDEX); 1392 CASE_RETURN_STRING(WMI_SAR2_INVALID_TABLE_INDEX); 1393 CASE_RETURN_STRING(WMI_SAR2_STATE_ERROR); 1394 CASE_RETURN_STRING(WMI_SAR2_BDF_NO_TABLE); 1395 default: 1396 return "Unknown response"; 1397 } 1398 } 1399 1400 /** 1401 * extract_sar2_result_event_tlv() - process sar response event from FW. 1402 * @handle: wma handle 1403 * @event: event buffer 1404 * @len: buffer length 1405 * 1406 * Return: 0 for success or error code 1407 */ 1408 static QDF_STATUS extract_sar2_result_event_tlv(void *handle, 1409 uint8_t *event, 1410 uint32_t len) 1411 { 1412 wmi_sar2_result_event_fixed_param *sar2_fixed_param; 1413 1414 WMI_SAR2_RESULT_EVENTID_param_tlvs *param_buf = 1415 (WMI_SAR2_RESULT_EVENTID_param_tlvs *)event; 1416 1417 if (!param_buf) { 1418 wmi_err("Invalid sar2 result event buffer"); 1419 return QDF_STATUS_E_INVAL; 1420 } 1421 1422 sar2_fixed_param = param_buf->fixed_param; 1423 if (!sar2_fixed_param) { 1424 wmi_err("Invalid sar2 result event fixed param buffer"); 1425 return QDF_STATUS_E_INVAL; 1426 } 1427 1428 wmi_debug("SAR2 result: %s", 1429 wmi_sar2_result_string(sar2_fixed_param->result)); 1430 1431 return QDF_STATUS_SUCCESS; 1432 } 1433 1434 static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle, 1435 uint8_t *evt_buf, 1436 struct sar_limit_event *event) 1437 { 1438 wmi_sar_get_limits_event_fixed_param *fixed_param; 1439 WMI_SAR_GET_LIMITS_EVENTID_param_tlvs *param_buf; 1440 wmi_sar_get_limit_event_row *row_in; 1441 struct sar_limit_event_row *row_out; 1442 uint32_t row; 1443 1444 if (!evt_buf) { 1445 wmi_err("input event is NULL"); 1446 return QDF_STATUS_E_INVAL; 1447 } 1448 if (!event) { 1449 wmi_err("output event is NULL"); 1450 return QDF_STATUS_E_INVAL; 1451 } 1452 1453 param_buf = (WMI_SAR_GET_LIMITS_EVENTID_param_tlvs *)evt_buf; 1454 1455 fixed_param = param_buf->fixed_param; 1456 if (!fixed_param) { 1457 wmi_err("Invalid fixed param"); 1458 return QDF_STATUS_E_INVAL; 1459 } 1460 1461 event->sar_enable = fixed_param->sar_enable; 1462 event->num_limit_rows = fixed_param->num_limit_rows; 1463 1464 if (event->num_limit_rows > param_buf->num_sar_get_limits) { 1465 wmi_err("Num rows %d exceeds sar_get_limits rows len %d", 1466 event->num_limit_rows, param_buf->num_sar_get_limits); 1467 return QDF_STATUS_E_INVAL; 1468 } 1469 1470 if (event->num_limit_rows > MAX_SAR_LIMIT_ROWS_SUPPORTED) { 1471 QDF_ASSERT(0); 1472 wmi_err("Num rows %d exceeds max of %d", 1473 event->num_limit_rows, 1474 MAX_SAR_LIMIT_ROWS_SUPPORTED); 1475 event->num_limit_rows = MAX_SAR_LIMIT_ROWS_SUPPORTED; 1476 } 1477 1478 row_in = param_buf->sar_get_limits; 1479 if (!row_in) { 1480 wmi_debug("sar_get_limits is NULL"); 1481 } else { 1482 row_out = &event->sar_limit_row[0]; 1483 for (row = 0; row < event->num_limit_rows; row++) { 1484 row_out->band_id = row_in->band_id; 1485 row_out->chain_id = row_in->chain_id; 1486 row_out->mod_id = row_in->mod_id; 1487 row_out->limit_value = row_in->limit_value; 1488 row_out++; 1489 row_in++; 1490 } 1491 } 1492 1493 return QDF_STATUS_SUCCESS; 1494 } 1495 1496 /** 1497 * send_set_del_pmkid_cache_cmd_tlv() - send wmi cmd of set del pmkid 1498 * @wmi_handle: wmi handler 1499 * @pmk_info: pointer to PMK cache entry 1500 * @vdev_id: vdev id 1501 * 1502 * Return: 0 for success and non zero for failure 1503 */ 1504 static QDF_STATUS send_set_del_pmkid_cache_cmd_tlv(wmi_unified_t wmi_handle, 1505 struct wmi_unified_pmk_cache *pmk_info) 1506 { 1507 wmi_pdev_update_pmk_cache_cmd_fixed_param *cmd; 1508 wmi_buf_t buf; 1509 QDF_STATUS status; 1510 uint8_t *buf_ptr; 1511 wmi_pmk_cache *pmksa; 1512 uint32_t len = sizeof(*cmd); 1513 1514 if (!pmk_info) 1515 return QDF_STATUS_E_INVAL; 1516 1517 if (!pmk_info->is_flush_all) 1518 len += WMI_TLV_HDR_SIZE + sizeof(*pmksa); 1519 1520 buf = wmi_buf_alloc(wmi_handle, len); 1521 if (!buf) { 1522 return QDF_STATUS_E_NOMEM; 1523 } 1524 1525 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1526 cmd = (wmi_pdev_update_pmk_cache_cmd_fixed_param *) buf_ptr; 1527 1528 WMITLV_SET_HDR(&cmd->tlv_header, 1529 WMITLV_TAG_STRUC_wmi_pdev_update_pmk_cache_cmd_fixed_param, 1530 WMITLV_GET_STRUCT_TLVLEN( 1531 wmi_pdev_update_pmk_cache_cmd_fixed_param)); 1532 1533 cmd->vdev_id = pmk_info->vdev_id; 1534 1535 /* If pmk_info->is_flush_all is true, this is a flush request */ 1536 if (pmk_info->is_flush_all) { 1537 cmd->op_flag = WMI_PMK_CACHE_OP_FLAG_FLUSH_ALL; 1538 cmd->num_cache = 0; 1539 goto send_cmd; 1540 } 1541 1542 cmd->num_cache = 1; 1543 buf_ptr += sizeof(*cmd); 1544 1545 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 1546 sizeof(*pmksa)); 1547 buf_ptr += WMI_TLV_HDR_SIZE; 1548 1549 pmksa = (wmi_pmk_cache *)buf_ptr; 1550 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_wmi_pmk_cache, 1551 WMITLV_GET_STRUCT_TLVLEN 1552 (wmi_pmk_cache)); 1553 pmksa->pmk_len = pmk_info->pmk_len; 1554 qdf_mem_copy(pmksa->pmk, pmk_info->pmk, pmksa->pmk_len); 1555 pmksa->pmkid_len = pmk_info->pmkid_len; 1556 qdf_mem_copy(pmksa->pmkid, pmk_info->pmkid, pmksa->pmkid_len); 1557 qdf_mem_copy(&(pmksa->bssid), &(pmk_info->bssid), sizeof(wmi_mac_addr)); 1558 pmksa->ssid.ssid_len = pmk_info->ssid.length; 1559 qdf_mem_copy(&(pmksa->ssid.ssid), &(pmk_info->ssid.ssid), 1560 pmksa->ssid.ssid_len); 1561 pmksa->cache_id = pmk_info->cache_id; 1562 pmksa->cat_flag = pmk_info->cat_flag; 1563 pmksa->action_flag = pmk_info->action_flag; 1564 1565 send_cmd: 1566 wmi_mtrace(WMI_PDEV_UPDATE_PMK_CACHE_CMDID, cmd->vdev_id, 0); 1567 status = wmi_unified_cmd_send(wmi_handle, buf, len, 1568 WMI_PDEV_UPDATE_PMK_CACHE_CMDID); 1569 if (status != QDF_STATUS_SUCCESS) { 1570 wmi_err("Failed to send set del pmkid cache command %d", 1571 status); 1572 wmi_buf_free(buf); 1573 } 1574 1575 return status; 1576 } 1577 1578 /** 1579 * send_del_ts_cmd_tlv() - send DELTS request to fw 1580 * @wmi_handle: wmi handle 1581 * @msg: delts params 1582 * 1583 * Return: CDF status 1584 */ 1585 static QDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id, 1586 uint8_t ac) 1587 { 1588 wmi_vdev_wmm_delts_cmd_fixed_param *cmd; 1589 wmi_buf_t buf; 1590 int32_t len = sizeof(*cmd); 1591 1592 buf = wmi_buf_alloc(wmi_handle, len); 1593 if (!buf) { 1594 return QDF_STATUS_E_NOMEM; 1595 } 1596 cmd = (wmi_vdev_wmm_delts_cmd_fixed_param *) wmi_buf_data(buf); 1597 WMITLV_SET_HDR(&cmd->tlv_header, 1598 WMITLV_TAG_STRUC_wmi_vdev_wmm_delts_cmd_fixed_param, 1599 WMITLV_GET_STRUCT_TLVLEN 1600 (wmi_vdev_wmm_delts_cmd_fixed_param)); 1601 cmd->vdev_id = vdev_id; 1602 cmd->ac = ac; 1603 1604 wmi_debug("Delts vdev:%d, ac:%d", cmd->vdev_id, cmd->ac); 1605 wmi_mtrace(WMI_VDEV_WMM_DELTS_CMDID, cmd->vdev_id, 0); 1606 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1607 WMI_VDEV_WMM_DELTS_CMDID)) { 1608 wmi_err("Failed to send vdev DELTS command"); 1609 wmi_buf_free(buf); 1610 return QDF_STATUS_E_FAILURE; 1611 } 1612 1613 return QDF_STATUS_SUCCESS; 1614 } 1615 1616 /** 1617 * send_aggr_qos_cmd_tlv() - send aggr qos request to fw 1618 * @wmi_handle: handle to wmi 1619 * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests. 1620 * 1621 * A function to handle WMI_AGGR_QOS_REQ. This will send out 1622 * ADD_TS requests to firmware in loop for all the ACs with 1623 * active flow. 1624 * 1625 * Return: CDF status 1626 */ 1627 static QDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle, 1628 struct aggr_add_ts_param *aggr_qos_rsp_msg) 1629 { 1630 int i = 0; 1631 wmi_vdev_wmm_addts_cmd_fixed_param *cmd; 1632 wmi_buf_t buf; 1633 int32_t len = sizeof(*cmd); 1634 1635 for (i = 0; i < WMI_QOS_NUM_AC_MAX; i++) { 1636 /* if flow in this AC is active */ 1637 if (((1 << i) & aggr_qos_rsp_msg->tspecIdx)) { 1638 /* 1639 * as per implementation of wma_add_ts_req() we 1640 * are not waiting any response from firmware so 1641 * apart from sending ADDTS to firmware just send 1642 * success to upper layers 1643 */ 1644 aggr_qos_rsp_msg->status[i] = QDF_STATUS_SUCCESS; 1645 1646 buf = wmi_buf_alloc(wmi_handle, len); 1647 if (!buf) { 1648 return QDF_STATUS_E_NOMEM; 1649 } 1650 cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) 1651 wmi_buf_data(buf); 1652 WMITLV_SET_HDR(&cmd->tlv_header, 1653 WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param, 1654 WMITLV_GET_STRUCT_TLVLEN 1655 (wmi_vdev_wmm_addts_cmd_fixed_param)); 1656 cmd->vdev_id = aggr_qos_rsp_msg->vdev_id; 1657 cmd->ac = 1658 WMI_TID_TO_AC(aggr_qos_rsp_msg->tspec[i].tsinfo. 1659 traffic.userPrio); 1660 cmd->medium_time_us = 1661 aggr_qos_rsp_msg->tspec[i].mediumTime * 32; 1662 cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO; 1663 wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d", 1664 cmd->vdev_id, cmd->ac, 1665 cmd->medium_time_us, cmd->downgrade_type); 1666 wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0); 1667 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1668 WMI_VDEV_WMM_ADDTS_CMDID)) { 1669 wmi_err("Failed to send vdev ADDTS command"); 1670 aggr_qos_rsp_msg->status[i] = 1671 QDF_STATUS_E_FAILURE; 1672 wmi_buf_free(buf); 1673 return QDF_STATUS_E_FAILURE; 1674 } 1675 } 1676 } 1677 1678 return QDF_STATUS_SUCCESS; 1679 } 1680 1681 /** 1682 * send_add_ts_cmd_tlv() - send ADDTS request to fw 1683 * @wmi_handle: wmi handle 1684 * @msg: ADDTS params 1685 * 1686 * Return: CDF status 1687 */ 1688 static QDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle, 1689 struct add_ts_param *msg) 1690 { 1691 wmi_vdev_wmm_addts_cmd_fixed_param *cmd; 1692 wmi_buf_t buf; 1693 int32_t len = sizeof(*cmd); 1694 1695 msg->status = QDF_STATUS_SUCCESS; 1696 1697 buf = wmi_buf_alloc(wmi_handle, len); 1698 if (!buf) { 1699 return QDF_STATUS_E_NOMEM; 1700 } 1701 cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) wmi_buf_data(buf); 1702 WMITLV_SET_HDR(&cmd->tlv_header, 1703 WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param, 1704 WMITLV_GET_STRUCT_TLVLEN 1705 (wmi_vdev_wmm_addts_cmd_fixed_param)); 1706 cmd->vdev_id = msg->vdev_id; 1707 cmd->ac = msg->tspec.tsinfo.traffic.userPrio; 1708 cmd->medium_time_us = msg->tspec.mediumTime * 32; 1709 cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP; 1710 wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d", 1711 cmd->vdev_id, cmd->ac, cmd->medium_time_us, 1712 cmd->downgrade_type); 1713 wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0); 1714 if (wmi_unified_cmd_send(wmi_handle, buf, len, 1715 WMI_VDEV_WMM_ADDTS_CMDID)) { 1716 wmi_err("Failed to send vdev ADDTS command"); 1717 msg->status = QDF_STATUS_E_FAILURE; 1718 wmi_buf_free(buf); 1719 return QDF_STATUS_E_FAILURE; 1720 } 1721 1722 return QDF_STATUS_SUCCESS; 1723 } 1724 1725 /** 1726 * send_process_add_periodic_tx_ptrn_cmd_tlv() - add periodic tx pattern 1727 * @wmi_handle: wmi handle 1728 * @pattern: tx pattern params 1729 * @vdev_id: vdev id 1730 * 1731 * Return: QDF status 1732 */ 1733 static QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv( 1734 wmi_unified_t wmi_handle, 1735 struct periodic_tx_pattern *pattern, 1736 uint8_t vdev_id) 1737 { 1738 WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd; 1739 wmi_buf_t wmi_buf; 1740 uint32_t len; 1741 uint8_t *buf_ptr; 1742 uint32_t ptrn_len, ptrn_len_aligned; 1743 int j; 1744 1745 ptrn_len = pattern->ucPtrnSize; 1746 ptrn_len_aligned = roundup(ptrn_len, sizeof(uint32_t)); 1747 len = sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param) + 1748 WMI_TLV_HDR_SIZE + ptrn_len_aligned; 1749 1750 wmi_buf = wmi_buf_alloc(wmi_handle, len); 1751 if (!wmi_buf) { 1752 return QDF_STATUS_E_NOMEM; 1753 } 1754 1755 buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); 1756 1757 cmd = (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *) buf_ptr; 1758 WMITLV_SET_HDR(&cmd->tlv_header, 1759 WMITLV_TAG_STRUC_WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param, 1760 WMITLV_GET_STRUCT_TLVLEN 1761 (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param)); 1762 1763 /* Pass the pattern id to delete for the corresponding vdev id */ 1764 cmd->vdev_id = vdev_id; 1765 cmd->pattern_id = pattern->ucPtrnId; 1766 cmd->timeout = pattern->usPtrnIntervalMs; 1767 cmd->length = pattern->ucPtrnSize; 1768 1769 /* Pattern info */ 1770 buf_ptr += sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param); 1771 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ptrn_len_aligned); 1772 buf_ptr += WMI_TLV_HDR_SIZE; 1773 qdf_mem_copy(buf_ptr, pattern->ucPattern, ptrn_len); 1774 for (j = 0; j < pattern->ucPtrnSize; j++) 1775 wmi_debug("Add Ptrn: %02x", buf_ptr[j] & 0xff); 1776 1777 wmi_debug("Add ptrn id: %d vdev_id: %d", 1778 cmd->pattern_id, cmd->vdev_id); 1779 1780 wmi_mtrace(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0); 1781 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 1782 WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID)) { 1783 wmi_err("Failed to add pattern set state command"); 1784 wmi_buf_free(wmi_buf); 1785 return QDF_STATUS_E_FAILURE; 1786 } 1787 return QDF_STATUS_SUCCESS; 1788 } 1789 1790 /** 1791 * send_process_del_periodic_tx_ptrn_cmd_tlv() - del periodic tx pattern 1792 * @wmi_handle: wmi handle 1793 * @vdev_id: vdev id 1794 * @pattern_id: pattern id 1795 * 1796 * Return: QDF status 1797 */ 1798 static QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv( 1799 wmi_unified_t wmi_handle, 1800 uint8_t vdev_id, 1801 uint8_t pattern_id) 1802 { 1803 WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd; 1804 wmi_buf_t wmi_buf; 1805 uint32_t len = 1806 sizeof(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param); 1807 1808 wmi_buf = wmi_buf_alloc(wmi_handle, len); 1809 if (!wmi_buf) { 1810 return QDF_STATUS_E_NOMEM; 1811 } 1812 1813 cmd = (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *) 1814 wmi_buf_data(wmi_buf); 1815 WMITLV_SET_HDR(&cmd->tlv_header, 1816 WMITLV_TAG_STRUC_WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param, 1817 WMITLV_GET_STRUCT_TLVLEN 1818 (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param)); 1819 1820 /* Pass the pattern id to delete for the corresponding vdev id */ 1821 cmd->vdev_id = vdev_id; 1822 cmd->pattern_id = pattern_id; 1823 wmi_debug("Del ptrn id: %d vdev_id: %d", 1824 cmd->pattern_id, cmd->vdev_id); 1825 1826 wmi_mtrace(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0); 1827 if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len, 1828 WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID)) { 1829 wmi_err("Failed to send del pattern command"); 1830 wmi_buf_free(wmi_buf); 1831 return QDF_STATUS_E_FAILURE; 1832 } 1833 return QDF_STATUS_SUCCESS; 1834 } 1835 1836 /** 1837 * send_set_auto_shutdown_timer_cmd_tlv() - sets auto shutdown timer in firmware 1838 * @wmi_handle: wmi handle 1839 * @timer_val: auto shutdown timer value 1840 * 1841 * Return: CDF status 1842 */ 1843 static QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle, 1844 uint32_t timer_val) 1845 { 1846 QDF_STATUS status; 1847 wmi_buf_t buf = NULL; 1848 uint8_t *buf_ptr; 1849 wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd; 1850 int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param); 1851 1852 wmi_debug("Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d", 1853 timer_val); 1854 1855 buf = wmi_buf_alloc(wmi_handle, len); 1856 if (!buf) { 1857 return QDF_STATUS_E_NOMEM; 1858 } 1859 1860 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1861 wmi_auto_sh_cmd = 1862 (wmi_host_auto_shutdown_cfg_cmd_fixed_param *) buf_ptr; 1863 wmi_auto_sh_cmd->timer_value = timer_val; 1864 1865 WMITLV_SET_HDR(&wmi_auto_sh_cmd->tlv_header, 1866 WMITLV_TAG_STRUC_wmi_host_auto_shutdown_cfg_cmd_fixed_param, 1867 WMITLV_GET_STRUCT_TLVLEN 1868 (wmi_host_auto_shutdown_cfg_cmd_fixed_param)); 1869 1870 wmi_mtrace(WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID, NO_SESSION, 0); 1871 status = wmi_unified_cmd_send(wmi_handle, buf, 1872 len, WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID); 1873 if (QDF_IS_STATUS_ERROR(status)) { 1874 wmi_err("WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d", status); 1875 wmi_buf_free(buf); 1876 } 1877 1878 return status; 1879 } 1880 1881 /** 1882 * send_set_led_flashing_cmd_tlv() - set led flashing in fw 1883 * @wmi_handle: wmi handle 1884 * @flashing: flashing request 1885 * 1886 * Return: CDF status 1887 */ 1888 static QDF_STATUS send_set_led_flashing_cmd_tlv(wmi_unified_t wmi_handle, 1889 struct flashing_req_params *flashing) 1890 { 1891 wmi_set_led_flashing_cmd_fixed_param *cmd; 1892 QDF_STATUS status; 1893 wmi_buf_t buf; 1894 uint8_t *buf_ptr; 1895 int32_t len = sizeof(wmi_set_led_flashing_cmd_fixed_param); 1896 1897 buf = wmi_buf_alloc(wmi_handle, len); 1898 if (!buf) { 1899 return QDF_STATUS_E_NOMEM; 1900 } 1901 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1902 cmd = (wmi_set_led_flashing_cmd_fixed_param *) buf_ptr; 1903 WMITLV_SET_HDR(&cmd->tlv_header, 1904 WMITLV_TAG_STRUC_wmi_set_led_flashing_cmd_fixed_param, 1905 WMITLV_GET_STRUCT_TLVLEN 1906 (wmi_set_led_flashing_cmd_fixed_param)); 1907 cmd->pattern_id = flashing->pattern_id; 1908 cmd->led_x0 = flashing->led_x0; 1909 cmd->led_x1 = flashing->led_x1; 1910 1911 wmi_mtrace(WMI_PDEV_SET_LED_FLASHING_CMDID, NO_SESSION, 0); 1912 status = wmi_unified_cmd_send(wmi_handle, buf, len, 1913 WMI_PDEV_SET_LED_FLASHING_CMDID); 1914 if (QDF_IS_STATUS_ERROR(status)) { 1915 wmi_err("wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD" 1916 " returned Error %d", status); 1917 wmi_buf_free(buf); 1918 } 1919 1920 return status; 1921 } 1922 1923 /** 1924 * send_process_ch_avoid_update_cmd_tlv() - handles channel avoid update request 1925 * @wmi_handle: wmi handle 1926 * @ch_avoid_update_req: channel avoid update params 1927 * 1928 * Return: CDF status 1929 */ 1930 static QDF_STATUS send_process_ch_avoid_update_cmd_tlv(wmi_unified_t wmi_handle) 1931 { 1932 QDF_STATUS status; 1933 wmi_buf_t buf = NULL; 1934 uint8_t *buf_ptr; 1935 wmi_chan_avoid_update_cmd_param *ch_avoid_update_fp; 1936 int len = sizeof(wmi_chan_avoid_update_cmd_param); 1937 1938 buf = wmi_buf_alloc(wmi_handle, len); 1939 if (!buf) { 1940 return QDF_STATUS_E_NOMEM; 1941 } 1942 1943 buf_ptr = (uint8_t *) wmi_buf_data(buf); 1944 ch_avoid_update_fp = (wmi_chan_avoid_update_cmd_param *) buf_ptr; 1945 WMITLV_SET_HDR(&ch_avoid_update_fp->tlv_header, 1946 WMITLV_TAG_STRUC_wmi_chan_avoid_update_cmd_param, 1947 WMITLV_GET_STRUCT_TLVLEN 1948 (wmi_chan_avoid_update_cmd_param)); 1949 1950 wmi_mtrace(WMI_CHAN_AVOID_UPDATE_CMDID, NO_SESSION, 0); 1951 status = wmi_unified_cmd_send(wmi_handle, buf, 1952 len, WMI_CHAN_AVOID_UPDATE_CMDID); 1953 if (QDF_IS_STATUS_ERROR(status)) { 1954 wmi_err("wmi_unified_cmd_send" 1955 " WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE" 1956 " returned Error %d", status); 1957 wmi_buf_free(buf); 1958 } 1959 1960 return status; 1961 } 1962 1963 /** 1964 * send_pdev_set_pcl_cmd_tlv() - Send WMI_SOC_SET_PCL_CMDID to FW 1965 * @wmi_handle: wmi handle 1966 * @msg: PCL structure containing the PCL and the number of channels 1967 * 1968 * WMI_PDEV_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN 1969 * firmware. The DBS Manager is the consumer of this information in the WLAN 1970 * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs 1971 * to migrate to a new channel without host driver involvement. An example of 1972 * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will 1973 * manage the channel selection without firmware involvement. 1974 * 1975 * WMI_PDEV_SET_PCL_CMDID will carry only the weight list and not the actual 1976 * channel list. The weights corresponds to the channels sent in 1977 * WMI_SCAN_CHAN_LIST_CMDID. The channels from PCL would be having a higher 1978 * weightage compared to the non PCL channels. 1979 * 1980 * Return: Success if the cmd is sent successfully to the firmware 1981 */ 1982 static QDF_STATUS send_pdev_set_pcl_cmd_tlv(wmi_unified_t wmi_handle, 1983 struct wmi_pcl_chan_weights *msg) 1984 { 1985 wmi_pdev_set_pcl_cmd_fixed_param *cmd; 1986 wmi_buf_t buf; 1987 uint8_t *buf_ptr; 1988 uint32_t *cmd_args, i, len; 1989 uint32_t chan_len; 1990 1991 chan_len = msg->saved_num_chan; 1992 1993 len = sizeof(*cmd) + 1994 WMI_TLV_HDR_SIZE + (chan_len * sizeof(uint32_t)); 1995 1996 buf = wmi_buf_alloc(wmi_handle, len); 1997 if (!buf) { 1998 return QDF_STATUS_E_NOMEM; 1999 } 2000 2001 cmd = (wmi_pdev_set_pcl_cmd_fixed_param *) wmi_buf_data(buf); 2002 buf_ptr = (uint8_t *) cmd; 2003 WMITLV_SET_HDR(&cmd->tlv_header, 2004 WMITLV_TAG_STRUC_wmi_pdev_set_pcl_cmd_fixed_param, 2005 WMITLV_GET_STRUCT_TLVLEN(wmi_pdev_set_pcl_cmd_fixed_param)); 2006 2007 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 2008 wmi_handle, 2009 WMI_HOST_PDEV_ID_SOC); 2010 cmd->num_chan = chan_len; 2011 buf_ptr += sizeof(wmi_pdev_set_pcl_cmd_fixed_param); 2012 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 2013 (chan_len * sizeof(uint32_t))); 2014 cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); 2015 for (i = 0; i < chan_len ; i++) 2016 cmd_args[i] = msg->weighed_valid_list[i]; 2017 wmi_mtrace(WMI_PDEV_SET_PCL_CMDID, NO_SESSION, 0); 2018 if (wmi_unified_cmd_send(wmi_handle, buf, len, 2019 WMI_PDEV_SET_PCL_CMDID)) { 2020 wmi_err("Failed to send WMI_PDEV_SET_PCL_CMDID"); 2021 wmi_buf_free(buf); 2022 return QDF_STATUS_E_FAILURE; 2023 } 2024 return QDF_STATUS_SUCCESS; 2025 } 2026 2027 #ifdef WLAN_POLICY_MGR_ENABLE 2028 /** 2029 * send_pdev_set_dual_mac_config_cmd_tlv() - Set dual mac config to FW 2030 * @wmi_handle: wmi handle 2031 * @msg: Dual MAC config parameters 2032 * 2033 * Configures WLAN firmware with the dual MAC features 2034 * 2035 * Return: QDF_STATUS. 0 on success. 2036 */ 2037 static 2038 QDF_STATUS send_pdev_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle, 2039 struct policy_mgr_dual_mac_config *msg) 2040 { 2041 wmi_pdev_set_mac_config_cmd_fixed_param *cmd; 2042 wmi_buf_t buf; 2043 uint32_t len; 2044 2045 len = sizeof(*cmd); 2046 2047 buf = wmi_buf_alloc(wmi_handle, len); 2048 if (!buf) { 2049 return QDF_STATUS_E_FAILURE; 2050 } 2051 2052 cmd = (wmi_pdev_set_mac_config_cmd_fixed_param *) wmi_buf_data(buf); 2053 WMITLV_SET_HDR(&cmd->tlv_header, 2054 WMITLV_TAG_STRUC_wmi_pdev_set_mac_config_cmd_fixed_param, 2055 WMITLV_GET_STRUCT_TLVLEN( 2056 wmi_pdev_set_mac_config_cmd_fixed_param)); 2057 2058 cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target( 2059 wmi_handle, 2060 WMI_HOST_PDEV_ID_SOC); 2061 cmd->concurrent_scan_config_bits = msg->scan_config; 2062 cmd->fw_mode_config_bits = msg->fw_mode_config; 2063 wmi_debug("scan_config:%x fw_mode_config:%x", 2064 msg->scan_config, msg->fw_mode_config); 2065 2066 wmi_mtrace(WMI_PDEV_SET_MAC_CONFIG_CMDID, NO_SESSION, 0); 2067 if (wmi_unified_cmd_send(wmi_handle, buf, len, 2068 WMI_PDEV_SET_MAC_CONFIG_CMDID)) { 2069 wmi_err("Failed to send WMI_PDEV_SET_MAC_CONFIG_CMDID"); 2070 wmi_buf_free(buf); 2071 return QDF_STATUS_E_FAILURE; 2072 } 2073 return QDF_STATUS_SUCCESS; 2074 } 2075 2076 void wmi_policy_mgr_attach_tlv(struct wmi_unified *wmi_handle) 2077 { 2078 struct wmi_ops *ops = wmi_handle->ops; 2079 2080 ops->send_pdev_set_dual_mac_config_cmd = 2081 send_pdev_set_dual_mac_config_cmd_tlv; 2082 } 2083 #endif /* WLAN_POLICY_MGR_ENABLE */ 2084 2085 /** 2086 * send_adapt_dwelltime_params_cmd_tlv() - send wmi cmd of adaptive dwelltime 2087 * configuration params 2088 * @wma_handle: wma handler 2089 * @dwelltime_params: pointer to dwelltime_params 2090 * 2091 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure 2092 */ 2093 static 2094 QDF_STATUS send_adapt_dwelltime_params_cmd_tlv(wmi_unified_t wmi_handle, 2095 struct wmi_adaptive_dwelltime_params *dwelltime_params) 2096 { 2097 wmi_scan_adaptive_dwell_config_fixed_param *dwell_param; 2098 wmi_scan_adaptive_dwell_parameters_tlv *cmd; 2099 wmi_buf_t buf; 2100 uint8_t *buf_ptr; 2101 int32_t err; 2102 int len; 2103 2104 len = sizeof(wmi_scan_adaptive_dwell_config_fixed_param); 2105 len += WMI_TLV_HDR_SIZE; /* TLV for ext_thresholds*/ 2106 len += sizeof(wmi_scan_adaptive_dwell_parameters_tlv); 2107 buf = wmi_buf_alloc(wmi_handle, len); 2108 if (!buf) { 2109 return QDF_STATUS_E_NOMEM; 2110 } 2111 buf_ptr = (uint8_t *) wmi_buf_data(buf); 2112 dwell_param = (wmi_scan_adaptive_dwell_config_fixed_param *) buf_ptr; 2113 WMITLV_SET_HDR(&dwell_param->tlv_header, 2114 WMITLV_TAG_STRUC_wmi_scan_adaptive_dwell_config_fixed_param, 2115 WMITLV_GET_STRUCT_TLVLEN 2116 (wmi_scan_adaptive_dwell_config_fixed_param)); 2117 2118 dwell_param->enable = dwelltime_params->is_enabled; 2119 buf_ptr += sizeof(wmi_scan_adaptive_dwell_config_fixed_param); 2120 WMITLV_SET_HDR(buf_ptr, 2121 WMITLV_TAG_ARRAY_STRUC, 2122 sizeof(wmi_scan_adaptive_dwell_parameters_tlv)); 2123 buf_ptr += WMI_TLV_HDR_SIZE; 2124 2125 cmd = (wmi_scan_adaptive_dwell_parameters_tlv *) buf_ptr; 2126 WMITLV_SET_HDR(&cmd->tlv_header, 2127 WMITLV_TAG_STRUC_wmi_scan_adaptive_dwell_parameters_tlv, 2128 WMITLV_GET_STRUCT_TLVLEN( 2129 wmi_scan_adaptive_dwell_parameters_tlv)); 2130 2131 cmd->default_adaptive_dwell_mode = dwelltime_params->dwelltime_mode; 2132 cmd->adapative_lpf_weight = dwelltime_params->lpf_weight; 2133 cmd->passive_monitor_interval_ms = dwelltime_params->passive_mon_intval; 2134 cmd->wifi_activity_threshold_pct = dwelltime_params->wifi_act_threshold; 2135 wmi_mtrace(WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID, NO_SESSION, 0); 2136 err = wmi_unified_cmd_send(wmi_handle, buf, 2137 len, WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID); 2138 if (err) { 2139 wmi_err("Failed to send adapt dwelltime cmd err=%d", err); 2140 wmi_buf_free(buf); 2141 return QDF_STATUS_E_FAILURE; 2142 } 2143 2144 return QDF_STATUS_SUCCESS; 2145 } 2146 2147 /** 2148 * send_dbs_scan_sel_params_cmd_tlv() - send wmi cmd of DBS scan selection 2149 * configuration params 2150 * @wmi_handle: wmi handler 2151 * @dbs_scan_params: pointer to wmi_dbs_scan_sel_params 2152 * 2153 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure 2154 */ 2155 static QDF_STATUS send_dbs_scan_sel_params_cmd_tlv(wmi_unified_t wmi_handle, 2156 struct wmi_dbs_scan_sel_params *dbs_scan_params) 2157 { 2158 wmi_scan_dbs_duty_cycle_fixed_param *dbs_scan_param; 2159 wmi_scan_dbs_duty_cycle_tlv_param *cmd; 2160 wmi_buf_t buf; 2161 uint8_t *buf_ptr; 2162 QDF_STATUS err; 2163 uint32_t i; 2164 int len; 2165 2166 len = sizeof(*dbs_scan_param); 2167 len += WMI_TLV_HDR_SIZE; 2168 len += dbs_scan_params->num_clients * sizeof(*cmd); 2169 2170 buf = wmi_buf_alloc(wmi_handle, len); 2171 if (!buf) { 2172 return QDF_STATUS_E_NOMEM; 2173 } 2174 2175 buf_ptr = (uint8_t *) wmi_buf_data(buf); 2176 dbs_scan_param = (wmi_scan_dbs_duty_cycle_fixed_param *) buf_ptr; 2177 WMITLV_SET_HDR(&dbs_scan_param->tlv_header, 2178 WMITLV_TAG_STRUC_wmi_scan_dbs_duty_cycle_fixed_param, 2179 WMITLV_GET_STRUCT_TLVLEN 2180 (wmi_scan_dbs_duty_cycle_fixed_param)); 2181 2182 dbs_scan_param->num_clients = dbs_scan_params->num_clients; 2183 dbs_scan_param->pdev_id = dbs_scan_params->pdev_id; 2184 buf_ptr += sizeof(*dbs_scan_param); 2185 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 2186 (sizeof(*cmd) * dbs_scan_params->num_clients)); 2187 buf_ptr = buf_ptr + (uint8_t) WMI_TLV_HDR_SIZE; 2188 2189 for (i = 0; i < dbs_scan_params->num_clients; i++) { 2190 cmd = (wmi_scan_dbs_duty_cycle_tlv_param *) buf_ptr; 2191 WMITLV_SET_HDR(&cmd->tlv_header, 2192 WMITLV_TAG_STRUC_wmi_scan_dbs_duty_cycle_param_tlv, 2193 WMITLV_GET_STRUCT_TLVLEN( 2194 wmi_scan_dbs_duty_cycle_tlv_param)); 2195 cmd->module_id = dbs_scan_params->module_id[i]; 2196 cmd->num_dbs_scans = dbs_scan_params->num_dbs_scans[i]; 2197 cmd->num_non_dbs_scans = dbs_scan_params->num_non_dbs_scans[i]; 2198 buf_ptr = buf_ptr + (uint8_t) sizeof(*cmd); 2199 } 2200 2201 wmi_mtrace(WMI_SET_SCAN_DBS_DUTY_CYCLE_CMDID, NO_SESSION, 0); 2202 err = wmi_unified_cmd_send(wmi_handle, buf, 2203 len, WMI_SET_SCAN_DBS_DUTY_CYCLE_CMDID); 2204 if (QDF_IS_STATUS_ERROR(err)) { 2205 wmi_err("Failed to send dbs scan selection cmd err=%d", err); 2206 wmi_buf_free(buf); 2207 return QDF_STATUS_E_FAILURE; 2208 } 2209 2210 return QDF_STATUS_SUCCESS; 2211 } 2212 2213 /** 2214 * send_set_arp_stats_req_cmd_tlv() - send wmi cmd to set arp stats request 2215 * @wmi_handle: wmi handler 2216 * @req_buf: set arp stats request buffer 2217 * 2218 * Return: 0 for success and non zero for failure 2219 */ 2220 static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle, 2221 struct set_arp_stats *req_buf) 2222 { 2223 wmi_buf_t buf = NULL; 2224 QDF_STATUS status; 2225 int len; 2226 uint8_t *buf_ptr; 2227 wmi_vdev_set_arp_stats_cmd_fixed_param *wmi_set_arp; 2228 2229 len = sizeof(wmi_vdev_set_arp_stats_cmd_fixed_param); 2230 if (req_buf->pkt_type_bitmap) { 2231 len += WMI_TLV_HDR_SIZE; 2232 len += sizeof(wmi_vdev_set_connectivity_check_stats); 2233 } 2234 buf = wmi_buf_alloc(wmi_handle, len); 2235 if (!buf) { 2236 return QDF_STATUS_E_NOMEM; 2237 } 2238 2239 buf_ptr = (uint8_t *) wmi_buf_data(buf); 2240 wmi_set_arp = 2241 (wmi_vdev_set_arp_stats_cmd_fixed_param *) buf_ptr; 2242 WMITLV_SET_HDR(&wmi_set_arp->tlv_header, 2243 WMITLV_TAG_STRUC_wmi_vdev_set_arp_stats_cmd_fixed_param, 2244 WMITLV_GET_STRUCT_TLVLEN 2245 (wmi_vdev_set_arp_stats_cmd_fixed_param)); 2246 2247 /* fill in per roam config values */ 2248 wmi_set_arp->vdev_id = req_buf->vdev_id; 2249 2250 wmi_set_arp->set_clr = req_buf->flag; 2251 wmi_set_arp->pkt_type = req_buf->pkt_type; 2252 wmi_set_arp->ipv4 = req_buf->ip_addr; 2253 2254 wmi_debug("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u", 2255 wmi_set_arp->vdev_id, wmi_set_arp->set_clr, 2256 wmi_set_arp->pkt_type, wmi_set_arp->ipv4); 2257 2258 /* 2259 * pkt_type_bitmap should be non-zero to ensure 2260 * presence of additional stats. 2261 */ 2262 if (req_buf->pkt_type_bitmap) { 2263 wmi_vdev_set_connectivity_check_stats *wmi_set_connect_stats; 2264 2265 buf_ptr += sizeof(wmi_vdev_set_arp_stats_cmd_fixed_param); 2266 WMITLV_SET_HDR(buf_ptr, 2267 WMITLV_TAG_ARRAY_STRUC, 2268 sizeof(wmi_vdev_set_connectivity_check_stats)); 2269 buf_ptr += WMI_TLV_HDR_SIZE; 2270 wmi_set_connect_stats = 2271 (wmi_vdev_set_connectivity_check_stats *)buf_ptr; 2272 WMITLV_SET_HDR(&wmi_set_connect_stats->tlv_header, 2273 WMITLV_TAG_STRUC_wmi_vdev_set_connectivity_check_stats, 2274 WMITLV_GET_STRUCT_TLVLEN( 2275 wmi_vdev_set_connectivity_check_stats)); 2276 wmi_set_connect_stats->pkt_type_bitmap = 2277 req_buf->pkt_type_bitmap; 2278 wmi_set_connect_stats->tcp_src_port = req_buf->tcp_src_port; 2279 wmi_set_connect_stats->tcp_dst_port = req_buf->tcp_dst_port; 2280 wmi_set_connect_stats->icmp_ipv4 = req_buf->icmp_ipv4; 2281 2282 wmi_debug("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u", 2283 wmi_set_connect_stats->pkt_type_bitmap, 2284 wmi_set_connect_stats->tcp_src_port, 2285 wmi_set_connect_stats->tcp_dst_port, 2286 wmi_set_connect_stats->icmp_ipv4); 2287 } 2288 2289 /* Send per roam config parameters */ 2290 wmi_mtrace(WMI_VDEV_SET_ARP_STAT_CMDID, NO_SESSION, 0); 2291 status = wmi_unified_cmd_send(wmi_handle, buf, 2292 len, WMI_VDEV_SET_ARP_STAT_CMDID); 2293 if (QDF_IS_STATUS_ERROR(status)) { 2294 wmi_err("WMI_SET_ARP_STATS_CMDID failed, Error %d", status); 2295 goto error; 2296 } 2297 2298 wmi_debug("set arp stats flag=%d, vdev=%d", 2299 req_buf->flag, req_buf->vdev_id); 2300 return QDF_STATUS_SUCCESS; 2301 error: 2302 wmi_buf_free(buf); 2303 2304 return status; 2305 } 2306 2307 /** 2308 * send_get_arp_stats_req_cmd_tlv() - send wmi cmd to get arp stats request 2309 * @wmi_handle: wmi handler 2310 * @req_buf: get arp stats request buffer 2311 * 2312 * Return: 0 for success and non zero for failure 2313 */ 2314 static QDF_STATUS send_get_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle, 2315 struct get_arp_stats *req_buf) 2316 { 2317 wmi_buf_t buf = NULL; 2318 QDF_STATUS status; 2319 int len; 2320 uint8_t *buf_ptr; 2321 wmi_vdev_get_arp_stats_cmd_fixed_param *get_arp_stats; 2322 2323 len = sizeof(wmi_vdev_get_arp_stats_cmd_fixed_param); 2324 buf = wmi_buf_alloc(wmi_handle, len); 2325 if (!buf) { 2326 return QDF_STATUS_E_NOMEM; 2327 } 2328 2329 buf_ptr = (uint8_t *) wmi_buf_data(buf); 2330 get_arp_stats = 2331 (wmi_vdev_get_arp_stats_cmd_fixed_param *) buf_ptr; 2332 WMITLV_SET_HDR(&get_arp_stats->tlv_header, 2333 WMITLV_TAG_STRUC_wmi_vdev_get_arp_stats_cmd_fixed_param, 2334 WMITLV_GET_STRUCT_TLVLEN 2335 (wmi_vdev_get_arp_stats_cmd_fixed_param)); 2336 2337 /* fill in arp stats req cmd values */ 2338 get_arp_stats->vdev_id = req_buf->vdev_id; 2339 2340 wmi_debug("vdev=%d", req_buf->vdev_id); 2341 /* Send per roam config parameters */ 2342 wmi_mtrace(WMI_VDEV_GET_ARP_STAT_CMDID, NO_SESSION, 0); 2343 status = wmi_unified_cmd_send(wmi_handle, buf, 2344 len, WMI_VDEV_GET_ARP_STAT_CMDID); 2345 if (QDF_IS_STATUS_ERROR(status)) { 2346 wmi_err("WMI_GET_ARP_STATS_CMDID failed, Error %d", status); 2347 goto error; 2348 } 2349 2350 return QDF_STATUS_SUCCESS; 2351 error: 2352 wmi_buf_free(buf); 2353 2354 return status; 2355 } 2356 2357 /** 2358 * send_peer_unmap_conf_cmd_tlv() - send PEER UNMAP conf command to fw 2359 * @wmi: wmi handle 2360 * @vdev_id: vdev id 2361 * @peer_id_cnt: no. of peer ids 2362 * @peer_id_list: list of peer ids 2363 * 2364 * Return: QDF_STATUS_SUCCESS for success or error code 2365 */ 2366 static QDF_STATUS send_peer_unmap_conf_cmd_tlv(wmi_unified_t wmi, 2367 uint8_t vdev_id, 2368 uint32_t peer_id_cnt, 2369 uint16_t *peer_id_list) 2370 { 2371 int i; 2372 wmi_buf_t buf; 2373 uint8_t *buf_ptr; 2374 A_UINT32 *peer_ids; 2375 wmi_peer_unmap_response_cmd_fixed_param *cmd; 2376 uint32_t peer_id_list_len; 2377 uint32_t len = sizeof(*cmd); 2378 QDF_STATUS status; 2379 2380 if (!peer_id_cnt || !peer_id_list) 2381 return QDF_STATUS_E_FAILURE; 2382 2383 len += WMI_TLV_HDR_SIZE; 2384 2385 peer_id_list_len = peer_id_cnt * sizeof(A_UINT32); 2386 2387 len += peer_id_list_len; 2388 2389 buf = wmi_buf_alloc(wmi, len); 2390 2391 if (!buf) { 2392 wmi_err("wmi_buf_alloc failed"); 2393 return QDF_STATUS_E_NOMEM; 2394 } 2395 2396 cmd = (wmi_peer_unmap_response_cmd_fixed_param *)wmi_buf_data(buf); 2397 buf_ptr = (uint8_t *)wmi_buf_data(buf); 2398 2399 WMITLV_SET_HDR(&cmd->tlv_header, 2400 WMITLV_TAG_STRUC_wmi_peer_unmap_response_cmd_fixed_param, 2401 WMITLV_GET_STRUCT_TLVLEN 2402 (wmi_peer_unmap_response_cmd_fixed_param)); 2403 2404 buf_ptr += sizeof(wmi_peer_unmap_response_cmd_fixed_param); 2405 2406 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 2407 peer_id_list_len); 2408 2409 peer_ids = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE); 2410 2411 for (i = 0; i < peer_id_cnt; i++) 2412 peer_ids[i] = peer_id_list[i]; 2413 2414 wmi_debug("vdev_id %d peer_id_cnt %d", vdev_id, peer_id_cnt); 2415 wmi_mtrace(WMI_PEER_UNMAP_RESPONSE_CMDID, vdev_id, 0); 2416 status = wmi_unified_cmd_send(wmi, buf, len, 2417 WMI_PEER_UNMAP_RESPONSE_CMDID); 2418 if (QDF_IS_STATUS_ERROR(status)) { 2419 wmi_err("Failed to send peer unmap conf command: Err[%d]", 2420 status); 2421 wmi_buf_free(buf); 2422 return status; 2423 } 2424 2425 return QDF_STATUS_SUCCESS; 2426 } 2427 2428 void wmi_sta_attach_tlv(wmi_unified_t wmi_handle) 2429 { 2430 struct wmi_ops *ops = wmi_handle->ops; 2431 2432 ops->send_set_sta_sa_query_param_cmd = 2433 send_set_sta_sa_query_param_cmd_tlv; 2434 ops->send_set_sta_keep_alive_cmd = send_set_sta_keep_alive_cmd_tlv; 2435 ops->send_vdev_set_gtx_cfg_cmd = send_vdev_set_gtx_cfg_cmd_tlv; 2436 ops->send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv; 2437 ops->send_get_link_speed_cmd = send_get_link_speed_cmd_tlv; 2438 ops->send_fw_profiling_cmd = send_fw_profiling_cmd_tlv; 2439 ops->send_nat_keepalive_en_cmd = send_nat_keepalive_en_cmd_tlv; 2440 ops->send_wlm_latency_level_cmd = send_wlm_latency_level_cmd_tlv; 2441 ops->send_process_set_ie_info_cmd = send_process_set_ie_info_cmd_tlv; 2442 ops->send_set_base_macaddr_indicate_cmd = 2443 send_set_base_macaddr_indicate_cmd_tlv; 2444 ops->send_sar_limit_cmd = send_sar_limit_cmd_tlv; 2445 ops->get_sar_limit_cmd = get_sar_limit_cmd_tlv; 2446 ops->extract_sar_limit_event = extract_sar_limit_event_tlv; 2447 ops->extract_sar2_result_event = extract_sar2_result_event_tlv; 2448 ops->send_set_del_pmkid_cache_cmd = send_set_del_pmkid_cache_cmd_tlv; 2449 ops->send_del_ts_cmd = send_del_ts_cmd_tlv; 2450 ops->send_aggr_qos_cmd = send_aggr_qos_cmd_tlv; 2451 ops->send_add_ts_cmd = send_add_ts_cmd_tlv; 2452 ops->send_process_add_periodic_tx_ptrn_cmd = 2453 send_process_add_periodic_tx_ptrn_cmd_tlv; 2454 ops->send_process_del_periodic_tx_ptrn_cmd = 2455 send_process_del_periodic_tx_ptrn_cmd_tlv; 2456 ops->send_set_auto_shutdown_timer_cmd = 2457 send_set_auto_shutdown_timer_cmd_tlv; 2458 ops->send_set_led_flashing_cmd = send_set_led_flashing_cmd_tlv; 2459 ops->send_process_ch_avoid_update_cmd = 2460 send_process_ch_avoid_update_cmd_tlv; 2461 ops->send_pdev_set_pcl_cmd = send_pdev_set_pcl_cmd_tlv; 2462 ops->send_adapt_dwelltime_params_cmd = 2463 send_adapt_dwelltime_params_cmd_tlv; 2464 ops->send_dbs_scan_sel_params_cmd = 2465 send_dbs_scan_sel_params_cmd_tlv; 2466 ops->send_set_arp_stats_req_cmd = send_set_arp_stats_req_cmd_tlv; 2467 ops->send_get_arp_stats_req_cmd = send_get_arp_stats_req_cmd_tlv; 2468 ops->send_peer_unmap_conf_cmd = send_peer_unmap_conf_cmd_tlv; 2469 2470 wmi_tdls_attach_tlv(wmi_handle); 2471 wmi_policy_mgr_attach_tlv(wmi_handle); 2472 wmi_denylist_mgr_attach_tlv(wmi_handle); 2473 } 2474 2475