1 /* 2 * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 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 /* 21 * This file contains the API definitions for the Unified Wireless Module 22 * Interface (WMI). 23 */ 24 25 #ifndef _WMI_UNIFIED_API_H_ 26 #define _WMI_UNIFIED_API_H_ 27 28 #include <osdep.h> 29 #include "htc_api.h" 30 #include "wmi_unified_param.h" 31 #include "service_ready_param.h" 32 #include "wlan_objmgr_psoc_obj.h" 33 #include "wlan_mgmt_txrx_utils_api.h" 34 #include <wlan_dfs_public_struct.h> 35 #include <wlan_crypto_global_def.h> 36 #include "wlan_thermal_public_struct.h" 37 #ifdef WLAN_POWER_MANAGEMENT_OFFLOAD 38 #include "wmi_unified_pmo_api.h" 39 #endif 40 #ifdef WLAN_FEATURE_MIB_STATS 41 #include "wlan_cp_stats_mc_defs.h" 42 #endif 43 #include "wlan_scan_public_structs.h" 44 #ifdef WLAN_FEATURE_ACTION_OUI 45 #include "wlan_action_oui_public_struct.h" 46 #endif 47 #ifdef WLAN_SUPPORT_GREEN_AP 48 #include "wlan_green_ap_api.h" 49 #endif 50 #ifdef WLAN_FEATURE_DSRC 51 #include "wlan_ocb_public_structs.h" 52 #endif 53 #ifdef WLAN_SUPPORT_TWT 54 #include "wmi_unified_twt_param.h" 55 #include "wmi_unified_twt_api.h" 56 #endif 57 #ifdef WDS_CONV_TARGET_IF_OPS_ENABLE 58 #include "wmi_unified_wds_api.h" 59 #endif 60 #ifdef FEATURE_WLAN_EXTSCAN 61 #include "wmi_unified_extscan_api.h" 62 #endif 63 64 #ifdef IPA_OFFLOAD 65 #include "wlan_ipa_public_struct.h" 66 #endif 67 68 #ifdef WMI_SMART_ANT_SUPPORT 69 #include "wmi_unified_smart_ant_api.h" 70 #endif 71 72 #ifdef WMI_DBR_SUPPORT 73 #include "wmi_unified_dbr_api.h" 74 #endif 75 76 #ifdef WMI_ATF_SUPPORT 77 #include "wmi_unified_atf_api.h" 78 #endif 79 80 #ifdef WMI_AP_SUPPORT 81 #include "wmi_unified_ap_api.h" 82 #endif 83 84 #ifdef WLAN_FEATURE_DSRC 85 #include "wmi_unified_ocb_api.h" 86 #endif 87 88 #ifdef WLAN_FEATURE_NAN 89 #include "wmi_unified_nan_api.h" 90 #endif 91 92 #ifdef CONVERGED_P2P_ENABLE 93 #include <wmi_unified_p2p_api.h> 94 #endif 95 96 #ifdef WMI_ROAM_SUPPORT 97 #include "wmi_unified_roam_api.h" 98 #endif 99 100 #ifdef WMI_CONCURRENCY_SUPPORT 101 #include "wmi_unified_concurrency_api.h" 102 #endif 103 104 #ifdef WMI_STA_SUPPORT 105 #include "wmi_unified_sta_api.h" 106 #endif 107 108 #ifdef WLAN_FW_OFFLOAD 109 #include "wmi_unified_fwol_api.h" 110 #endif 111 112 #ifdef WLAN_FEATURE_PKT_CAPTURE 113 #include "wlan_pkt_capture_public_structs.h" 114 #endif 115 116 #ifdef WLAN_IOT_SIM_SUPPORT 117 #include "wlan_iot_sim_public_structs.h" 118 #endif 119 120 #include "wmi_unified_cp_stats_api.h" 121 122 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 123 #include "wmi_unified_11be_setup_api.h" 124 #endif 125 126 #ifdef WLAN_FEATURE_DBAM_CONFIG 127 #include "wlan_coex_public_structs.h" 128 #endif 129 130 typedef qdf_nbuf_t wmi_buf_t; 131 #define wmi_buf_data(_buf) qdf_nbuf_data(_buf) 132 133 /* Number of bits to shift to combine 32 bit integer to 64 bit */ 134 #define WMI_LOWER_BITS_SHIFT_32 0x20 135 136 #define PHYERROR_MAX_BUFFER_LENGTH 0x7F000000 137 138 struct wmi_soc; 139 struct policy_mgr_dual_mac_config; 140 141 /** 142 * enum wmi_target_type - type of supported wmi command 143 * @WMI_TLV_TARGET: tlv based target 144 * @WMI_NON_TLV_TARGET: non-tlv based target 145 * @WMI_MAX_TARGET_TYPE: max value 146 * 147 */ 148 enum wmi_target_type { 149 WMI_TLV_TARGET, 150 WMI_NON_TLV_TARGET, 151 WMI_MAX_TARGET_TYPE 152 }; 153 154 /** 155 * enum wmi_rx_exec_ctx - wmi rx execution context 156 * @WMI_RX_WORK_CTX: work queue context execution provided by WMI layer 157 * @WMI_RX_UMAC_CTX: execution context provided by umac layer 158 * @WMI_RX_TASKLET_CTX: legacy name for UMAC context 159 * @WMI_RX_SERIALIZER_CTX: Execution context is serialized thread context 160 * @WMI_RX_DIAG_WORK_CTX: work queue execution context for FW diag events 161 */ 162 enum wmi_rx_exec_ctx { 163 WMI_RX_WORK_CTX, 164 WMI_RX_UMAC_CTX, 165 WMI_RX_TASKLET_CTX = WMI_RX_UMAC_CTX, 166 WMI_RX_SERIALIZER_CTX = 2, 167 WMI_RX_DIAG_WORK_CTX 168 }; 169 170 /** 171 * enum wmi_rx_buff_type - wmi rx event buffer type 172 * @WMI_RX_PROCESSED_BUFF: processed event buffer provided by WMI layer 173 * @WMI_RX_RAW_BUFF: raw event buffer provided by WMI layer 174 * 175 */ 176 enum wmi_rx_buff_type { 177 WMI_RX_PROCESSED_BUFF, 178 WMI_RX_RAW_BUFF 179 }; 180 181 /** 182 * enum wmi_fw_mem_prio - defines FW Memory requirement type 183 * @WMI_FW_MEM_HIGH_PRIORITY: Memory requires contiguous memory allocation 184 * @WMI_FW_MEM_LOW_PRIORITY: Memory can be fragmented 185 * @WMI_FW_PRIORITY_MAX: Invalid type 186 */ 187 enum wmi_fw_mem_prio { 188 WMI_FW_MEM_HIGH_PRIORITY = 0, 189 WMI_FW_MEM_LOW_PRIORITY, 190 WMI_FW_PRIORITY_MAX 191 }; 192 193 /** 194 * struct wmi_unified_attach_params - wmi init parameters 195 * @osdev: NIC device 196 * @target_type: type of supported wmi command 197 * @use_cookie: flag to indicate cookie based allocation 198 * @is_async_ep: queueing interrupt or non-interrupt endpoint 199 * @rx_ops: handle to wmi ops 200 * @psoc: objmgr psoc 201 * @max_commands: max commands 202 * @soc_id: SoC device instance id 203 */ 204 struct wmi_unified_attach_params { 205 osdev_t osdev; 206 enum wmi_target_type target_type; 207 bool use_cookie; 208 bool is_async_ep; 209 struct wlan_objmgr_psoc *psoc; 210 uint16_t max_commands; 211 uint32_t soc_id; 212 }; 213 214 /** 215 * struct wmi_unified_exec_ctx - wmi execution ctx and handler buff 216 * @exec_ctx: execution context of event 217 * @buff_type: buffer type for event handler 218 */ 219 struct wmi_unified_exec_ctx { 220 enum wmi_rx_exec_ctx exec_ctx; 221 enum wmi_rx_buff_type buff_type; 222 }; 223 224 /** 225 * wmi_unified_attach() - attach for unified WMI 226 * @scn_handle: handle to SCN. 227 * @params: attach params for WMI 228 * 229 */ 230 void *wmi_unified_attach(void *scn_handle, 231 struct wmi_unified_attach_params *params); 232 233 234 235 /** 236 * wmi_mgmt_cmd_record() - Wrapper function for mgmt command logging macro 237 * 238 * @wmi_handle: wmi handle 239 * @cmd: mgmt command 240 * @header: pointer to 802.11 header 241 * @vdev_id: vdev id 242 * @chanfreq: channel frequency 243 * 244 * Return: none 245 */ 246 void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, uint32_t cmd, 247 void *header, uint32_t vdev_id, uint32_t chanfreq); 248 249 /** 250 * wmi_unified_detach() - detach for unified WMI 251 * @wmi_handle: handle to WMI. 252 * 253 * Return: void. 254 */ 255 void wmi_unified_detach(struct wmi_unified *wmi_handle); 256 257 /** 258 * wmi_send_time_stamp_sync_cmd_tlv() - API to sync time between host and 259 * firmware 260 * @wmi_handle: handle to WMI. 261 * 262 * Return: none 263 */ 264 void wmi_send_time_stamp_sync_cmd_tlv(wmi_unified_t wmi_handle); 265 266 /** 267 * wmi_unified_remove_work() - detach for WMI work 268 * @wmi_handle: handle to WMI 269 * 270 * A function that does not fully detach WMI, but just remove work 271 * queue items associated with it. This is used to make sure that 272 * before any other processing code that may destroy related contexts 273 * (HTC, etc), work queue processing on WMI has already been stopped. 274 * 275 * Return: None 276 */ 277 void 278 wmi_unified_remove_work(struct wmi_unified *wmi_handle); 279 280 /** 281 * wmi_buf_alloc() - generic function to allocate WMI buffer 282 * @wmi_handle: handle to WMI. 283 * @len: length of the buffer 284 * 285 * Return: return wmi_buf_t or null if memory alloc fails 286 */ 287 #ifdef NBUF_MEMORY_DEBUG 288 #define wmi_buf_alloc(wmi_handle, len) \ 289 wmi_buf_alloc_debug(wmi_handle, len, __func__, __LINE__) 290 291 wmi_buf_t 292 wmi_buf_alloc_debug(wmi_unified_t wmi_handle, uint32_t len, 293 const char *func_name, uint32_t line_num); 294 #else 295 #define wmi_buf_alloc(wmi_handle, len) \ 296 wmi_buf_alloc_fl(wmi_handle, len, __func__, __LINE__) 297 298 wmi_buf_t wmi_buf_alloc_fl(wmi_unified_t wmi_handle, uint32_t len, 299 const char *func, uint32_t line); 300 #endif 301 302 /** 303 * wmi_buf_free() - generic function frees WMI net buffer 304 * 305 * @net_buf : Pointer to net_buf to be freed 306 */ 307 void wmi_buf_free(wmi_buf_t net_buf); 308 309 /** 310 * wmi_unified_cmd_send() - generic function to send unified WMI command 311 * @wmi_handle: handle to WMI. 312 * @buf: wmi command buffer 313 * @buflen: wmi command buffer length 314 * @cmd_id: WMI cmd id 315 * 316 * Note, it is NOT safe to access buf after calling this function! 317 * 318 * Return: QDF_STATUS 319 */ 320 #define wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id) \ 321 wmi_unified_cmd_send_fl(wmi_handle, buf, buflen, \ 322 cmd_id, __func__, __LINE__) 323 324 QDF_STATUS 325 wmi_unified_cmd_send_fl(wmi_unified_t wmi_handle, wmi_buf_t buf, 326 uint32_t buflen, uint32_t cmd_id, 327 const char *func, uint32_t line); 328 329 #ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI 330 /** 331 * wmi_unified_cmd_send_over_qmi() - generic function to send unified WMI command 332 * over QMI 333 * @wmi_handle: handle to WMI. 334 * @buf: wmi command buffer 335 * @buflen: wmi command buffer length 336 * @cmd_id: WMI cmd id 337 * 338 * Return: QDF_STATUS 339 */ 340 QDF_STATUS wmi_unified_cmd_send_over_qmi(struct wmi_unified *wmi_handle, 341 wmi_buf_t buf, uint32_t buflen, 342 uint32_t cmd_id); 343 344 /** 345 * wmi_process_qmi_fw_event() - Process WMI event received over QMI 346 * @wmi_cb_ctx: WMI handle received as call back context 347 * @buf: Pointer to WMI event buffer 348 * @len: Len of WMI buffer received 349 * 350 * Return: None 351 */ 352 int wmi_process_qmi_fw_event(void *wmi_cb_ctx, void *buf, int len); 353 #else 354 static inline 355 QDF_STATUS wmi_unified_cmd_send_over_qmi(struct wmi_unified *wmi_handle, 356 wmi_buf_t buf, uint32_t buflen, 357 uint32_t cmd_id) 358 { 359 return QDF_STATUS_E_NOSUPPORT; 360 } 361 362 static inline int wmi_process_qmi_fw_event(void *wmi_cb_ctx, void *buf, int len) 363 { 364 return -EINVAL; 365 } 366 #endif 367 368 #ifdef WLAN_SUPPORT_GAP_LL_PS_MODE 369 /** 370 * wmi_unified_green_ap_ll_ps_send() - Send unified WMI command to 371 * enable/disable green ap low latency power save mode 372 * @wmi_handle: handle to WMI. 373 * @green_ap_ll_ps_params: low latency power save mode parameter 374 * 375 * Return: None 376 */ 377 QDF_STATUS wmi_unified_green_ap_ll_ps_send(wmi_unified_t wmi_handle, 378 struct green_ap_ll_ps_cmd_param *green_ap_ll_ps_params); 379 #endif 380 381 /** 382 * wmi_unified_cmd_send_pm_chk() - send unified WMI command with PM check, 383 * if target is in suspended state, WMI command will be sent over QMI. 384 * @wmi_handle: handle to WMI. 385 * @buf: wmi command buffer 386 * @buflen: wmi command buffer length 387 * @cmd_id: WMI cmd id 388 * @is_qmi_send_support:send by qmi is supported 389 * 390 * Note, it is NOT safe to access buf after calling this function! 391 * 392 * Return: QDF_STATUS 393 */ 394 QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle, 395 wmi_buf_t buf, uint32_t buflen, 396 uint32_t cmd_id, 397 bool is_qmi_send_support); 398 399 /** 400 * wmi_unified_register_event() - WMI event handler 401 * registration function for converged components 402 * @wmi_handle: handle to WMI. 403 * @event_id: WMI event ID 404 * @handler_func: Event handler call back function 405 * 406 * Return: QDF_STATUS 407 */ 408 QDF_STATUS 409 wmi_unified_register_event(wmi_unified_t wmi_handle, 410 uint32_t event_id, 411 wmi_unified_event_handler handler_func); 412 413 /** 414 * wmi_unified_register_event_handler() - WMI event handler 415 * registration function 416 * @wmi_handle: handle to WMI. 417 * @event_id: WMI event ID 418 * @handler_func: Event handler call back function 419 * @rx_ctx: rx event processing context 420 * 421 * Return: QDF_STATUS 422 */ 423 QDF_STATUS 424 wmi_unified_register_event_handler(wmi_unified_t wmi_handle, 425 wmi_conv_event_id event_id, 426 wmi_unified_event_handler handler_func, 427 uint8_t rx_ctx); 428 429 /** 430 * wmi_unified_unregister_event() - WMI event handler unregister function 431 * for converged components 432 * @wmi_handle: handle to WMI. 433 * @event_id: WMI event ID 434 * 435 * Return: QDF_STATUS 436 */ 437 QDF_STATUS 438 wmi_unified_unregister_event(wmi_unified_t wmi_handle, 439 uint32_t event_id); 440 441 /** 442 * wmi_unified_register_raw_event_handler() - WMI event handler 443 * registration function. 444 * @wmi_handle: handle to WMI. 445 * @event_id: WMI event ID 446 * @handler_func: Event handler call back function 447 * @rx_ctx: rx event processing context 448 * 449 * Register event handler to get struct wmi_raw_event_buffer as arg 450 * 451 * Return: QDF_STATUS 452 */ 453 QDF_STATUS 454 wmi_unified_register_raw_event_handler(wmi_unified_t wmi_handle, 455 wmi_conv_event_id event_id, 456 wmi_unified_event_handler handler_func, 457 enum wmi_rx_exec_ctx rx_ctx); 458 459 /** 460 * wmi_unified_unregister_event_handler() - WMI event handler unregister 461 * function 462 * @wmi_handle: handle to WMI. 463 * @event_id: WMI event ID 464 * 465 * Return: QDF_STATUS 466 */ 467 QDF_STATUS 468 wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle, 469 wmi_conv_event_id event_id); 470 471 /** 472 * wmi_unified_connect_htc_service() - WMI API to get connect to HTC service 473 * @wmi_handle: handle to WMI. 474 * @htc_handle: handle to HTC. 475 * 476 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAULT for failure 477 */ 478 QDF_STATUS 479 wmi_unified_connect_htc_service(struct wmi_unified *wmi_handle, 480 HTC_HANDLE htc_handle); 481 482 #if defined(WLAN_FEATURE_WMI_DIAG_OVER_CE7) || \ 483 defined(WLAN_DIAG_AND_DBR_OVER_SEPARATE_CE) 484 /** 485 * wmi_diag_connect_pdev_htc_service() 486 * WMI DIAG API to get connect to HTC service 487 * @wmi_handle: handle to WMI. 488 * @htc_handle: handle to HTC. 489 * 490 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAULT for failure 491 */ 492 QDF_STATUS 493 wmi_diag_connect_pdev_htc_service(struct wmi_unified *wmi_handle, 494 HTC_HANDLE htc_handle); 495 #else 496 static inline QDF_STATUS 497 wmi_diag_connect_pdev_htc_service(struct wmi_unified *wmi_handle, 498 HTC_HANDLE htc_handle) 499 { 500 return QDF_STATUS_SUCCESS; 501 } 502 #endif 503 504 #if defined(WLAN_DIAG_AND_DBR_OVER_SEPARATE_CE) 505 /** 506 * wmi_dbr_connect_pdev_htc_service() - WMI DBR API to connect to HTC service 507 * @wmi_handle: handle to WMI. 508 * @htc_handle: handle to HTC. 509 * 510 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAULT for failure 511 */ 512 QDF_STATUS 513 wmi_dbr_connect_pdev_htc_service(struct wmi_unified *wmi_handle, 514 HTC_HANDLE htc_handle); 515 #else 516 static inline QDF_STATUS 517 wmi_dbr_connect_pdev_htc_service(struct wmi_unified *wmi_handle, 518 HTC_HANDLE htc_handle) 519 { 520 return QDF_STATUS_SUCCESS; 521 } 522 #endif 523 524 /** 525 * wmi_is_suspend_ready() - WMI API to verify the host has enough credits 526 * to suspend 527 * @wmi_handle: handle to WMI. 528 */ 529 530 int wmi_is_suspend_ready(wmi_unified_t wmi_handle); 531 532 /** 533 * wmi_get_host_credits() - WMI API to get updated host_credits 534 * @wmi_handle : handle to WMI. 535 */ 536 537 int wmi_get_host_credits(wmi_unified_t wmi_handle); 538 539 /** 540 * wmi_get_pending_cmds() - WMI API to get WMI Pending Commands in the HTC 541 * queue 542 * @wmi_handle: handle to WMI. 543 */ 544 545 int wmi_get_pending_cmds(wmi_unified_t wmi_handle); 546 547 /** 548 * wmi_set_target_suspend() - WMI API to set target suspend state 549 * @wmi_handle: handle to WMI. 550 * @val: suspend state boolean 551 */ 552 void wmi_set_target_suspend(wmi_unified_t wmi_handle, bool val); 553 554 /** 555 * wmi_set_target_suspend_acked() - WMI API to set target suspend command 556 * acked flag 557 * @wmi_handle: handle to WMI. 558 * @val: suspend command acked flag boolean 559 */ 560 void wmi_set_target_suspend_acked(wmi_unified_t wmi_handle, bool val); 561 562 /** 563 * wmi_is_target_suspended() - WMI API to check target suspend state 564 * @wmi_handle: handle to WMI. 565 * 566 * WMI API to check target suspend state 567 * 568 * Return: true if target is suspended, else false. 569 */ 570 bool wmi_is_target_suspended(struct wmi_unified *wmi_handle); 571 572 /** 573 * wmi_is_target_suspend_acked() - WMI API to check target suspend command is 574 * acked or not 575 * @wmi_handle: handle to WMI. 576 * 577 * WMI API to check whether the target suspend command is acked or not 578 * 579 * Return: true if target suspend command is acked, else false. 580 */ 581 bool wmi_is_target_suspend_acked(struct wmi_unified *wmi_handle); 582 583 #ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI 584 /** 585 * wmi_set_qmi_stats() - WMI API to set qmi stats enabled/disabled 586 * @wmi_handle: handle to WMI. 587 * @val: suspend state boolean 588 */ 589 void wmi_set_qmi_stats(wmi_unified_t wmi_handle, bool val); 590 591 /** 592 * wmi_is_qmi_stats_enabled() - WMI API to check if periodic stats 593 * over qmi is enableid 594 * @wmi_handle: handle to WMI. 595 * 596 * WMI API to check if periodic stats over qmi is enabled 597 * 598 * Return: true if qmi stats is enabled, else false. 599 */ 600 bool wmi_is_qmi_stats_enabled(struct wmi_unified *wmi_handle); 601 #else 602 static inline 603 void wmi_set_qmi_stats(wmi_unified_t wmi_handle, bool val) 604 {} 605 606 static inline 607 bool wmi_is_qmi_stats_enabled(struct wmi_unified *wmi_handle) 608 { 609 return false; 610 } 611 #endif /* end if of WLAN_FEATURE_WMI_SEND_RECV_QMI */ 612 613 /** 614 * wmi_set_is_wow_bus_suspended() - WMI API to set bus suspend state 615 * @wmi_handle: handle to WMI. 616 * @val: suspend state boolean 617 */ 618 void wmi_set_is_wow_bus_suspended(wmi_unified_t wmi_handle, A_BOOL val); 619 620 /** 621 * wmi_tag_crash_inject() - WMI API to set crash injection state 622 * @wmi_handle: handle to WMI. 623 * @flag: crash injection state boolean 624 */ 625 void wmi_tag_crash_inject(wmi_unified_t wmi_handle, A_BOOL flag); 626 627 /** 628 * wmi_set_tgt_assert() - WMI API to set target assert 629 * @wmi_handle: handle to WMI. 630 * @val: target assert config value. 631 * 632 * Return: none. 633 */ 634 void wmi_set_tgt_assert(wmi_unified_t wmi_handle, bool val); 635 636 /** 637 * wmi_stop() - generic function to block unified WMI command 638 * @wmi_handle: handle to WMI. 639 * 640 * Return: 0 on success and -ve on failure. 641 */ 642 int 643 wmi_stop(wmi_unified_t wmi_handle); 644 645 /** 646 * wmi_start() - generic function to start unified WMI command 647 * @wmi_handle: handle to WMI. 648 * 649 * Return: 0 on success and -ve on failure. 650 */ 651 int 652 wmi_start(wmi_unified_t wmi_handle); 653 654 /** 655 * wmi_is_blocked() - generic function to check if WMI is blocked 656 * @wmi_handle: handle to WMI. 657 * 658 * Return: true, if blocked, false if not blocked 659 */ 660 bool 661 wmi_is_blocked(wmi_unified_t wmi_handle); 662 663 /** 664 * wmi_flush_endpoint() - API to flush all the previous packets associated 665 * with the wmi endpoint 666 * 667 * @wmi_handle: handle to WMI. 668 */ 669 void 670 wmi_flush_endpoint(wmi_unified_t wmi_handle); 671 672 /** 673 * wmi_interface_sequence_stop() - API to stop wmi sequence check 674 * 675 * @wmi_handle: handle to WMI. 676 */ 677 void 678 wmi_interface_sequence_stop(wmi_unified_t wmi_handle); 679 680 /** 681 * wmi_pdev_id_conversion_enable() - API to enable pdev_id and phy_id 682 * conversion in WMI. By default pdev_id and 683 * phyid conversion is not done in WMI. 684 * This API can be used enable conversion in WMI. 685 * @wmi_handle: handle to WMI 686 * @pdev_id_map: pdev conversion map 687 * @size: size of pdev_id_map 688 * 689 * Return: none 690 */ 691 void wmi_pdev_id_conversion_enable(wmi_unified_t wmi_handle, 692 uint32_t *pdev_id_map, 693 uint8_t size); 694 695 /** 696 * __wmi_control_rx() - API to handle wmi rx event after UMAC has taken care 697 * of execution context 698 * 699 * @wmi_handle: handle to WMI. 700 * @evt_buf: wmi event buffer 701 */ 702 void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf); 703 #ifdef FEATURE_RUNTIME_PM 704 /** 705 * wmi_set_runtime_pm_inprogress() - set runtime pm progress flag 706 * @wmi_handle: wmi context 707 * @val: runtime pm progress flag 708 */ 709 void 710 wmi_set_runtime_pm_inprogress(wmi_unified_t wmi_handle, bool val); 711 712 /** 713 * wmi_get_runtime_pm_inprogress() - get runtime pm progress flag 714 * @wmi_handle: wmi context 715 * 716 * Return: value of runtime pm progress flag 717 */ 718 bool wmi_get_runtime_pm_inprogress(wmi_unified_t wmi_handle); 719 #else 720 static inline void 721 wmi_set_runtime_pm_inprogress(wmi_unified_t wmi_handle, bool val) 722 { 723 return; 724 } 725 static inline bool wmi_get_runtime_pm_inprogress(wmi_unified_t wmi_handle) 726 { 727 return false; 728 } 729 #endif 730 731 /** 732 * wmi_unified_get_soc_handle: Get WMI SoC handle 733 * @wmi_handle: WMI context got from wmi_attach 734 * 735 * Return: Pointer to Soc handle 736 */ 737 void *wmi_unified_get_soc_handle(struct wmi_unified *wmi_handle); 738 739 /** 740 * wmi_unified_get_pdev_handle: Get WMI SoC handle 741 * @soc: Pointer to wmi soc object 742 * @pdev_idx: pdev index 743 * 744 * Return: Pointer to wmi handle or NULL on failure 745 */ 746 void *wmi_unified_get_pdev_handle(struct wmi_soc *soc, uint32_t pdev_idx); 747 748 /** 749 * wmi_process_fw_event() - UMAC Callback to process fw event. 750 * @wmi_handle: handle to WMI. 751 * @evt_buf: wmi event buffer 752 * 753 * This function process fw event in caller context 754 * 755 * Return: none 756 */ 757 void wmi_process_fw_event(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf); 758 759 /** 760 * wmi_get_max_msg_len() - get maximum WMI message length 761 * @wmi_handle: WMI handle. 762 * 763 * This function returns the maximum WMI message length 764 * 765 * Return: maximum WMI message length 766 */ 767 uint16_t wmi_get_max_msg_len(wmi_unified_t wmi_handle); 768 769 /** 770 * wmi_unified_soc_set_hw_mode_cmd() - Send WMI_SOC_SET_HW_MODE_CMDID to FW 771 * @wmi_handle: wmi handle 772 * @hw_mode_index: The HW_Mode field is a enumerated type that is selected 773 * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID. 774 * 775 * Request HardWare (HW) Mode change to WLAN firmware 776 * 777 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 778 */ 779 QDF_STATUS wmi_unified_soc_set_hw_mode_cmd(wmi_unified_t wmi_handle, 780 uint32_t hw_mode_index); 781 782 /** 783 * wmi_unified_extract_hw_mode_resp() - Extract HW mode change response 784 * @wmi: WMI handle 785 * @evt_buf: Buffer holding event data 786 * @cmd_status: command status 787 * 788 * Return: QDF_STATUS_SUCCESS if success, else returns proper error code. 789 */ 790 QDF_STATUS 791 wmi_unified_extract_hw_mode_resp(wmi_unified_t wmi, 792 void *evt_buf, 793 uint32_t *cmd_status); 794 795 /** 796 * wmi_unified_extract_roam_trigger_stats() - Extract roam trigger related 797 * stats 798 * @wmi: wmi handle 799 * @evt_buf: Pointer to the event buffer 800 * @trig: Pointer to destination structure to fill data 801 * @idx: TLV id 802 * @btm_idx: BTM candidates index 803 * 804 * Return: QDF_STATUS 805 */ 806 QDF_STATUS 807 wmi_unified_extract_roam_trigger_stats(wmi_unified_t wmi, void *evt_buf, 808 struct wmi_roam_trigger_info *trig, 809 uint8_t idx, uint8_t btm_idx); 810 811 /** 812 * wmi_unified_extract_roam_scan_stats() - Extract roam scan stats from 813 * firmware 814 * @wmi: wmi handle 815 * @evt_buf: Pointer to the event buffer 816 * @dst: Pointer to destination structure to fill data 817 * @idx: TLV id 818 * @chan_idx: Index of the channel frequency for this roam trigger 819 * @ap_idx: Index of the candidate AP for this roam trigger 820 * 821 * Return: QDF_STATUS 822 */ 823 QDF_STATUS 824 wmi_unified_extract_roam_scan_stats(wmi_unified_t wmi, void *evt_buf, 825 struct wmi_roam_scan_data *dst, uint8_t idx, 826 uint8_t chan_idx, uint8_t ap_idx); 827 828 /** 829 * wmi_unified_extract_roam_result_stats() - Extract roam result related stats 830 * @wmi: wmi handle 831 * @evt_buf: Pointer to the event buffer 832 * @dst: Pointer to destination structure to fill data 833 * @idx: TLV id 834 * 835 * Return: QDF_STATUS 836 */ 837 QDF_STATUS 838 wmi_unified_extract_roam_result_stats(wmi_unified_t wmi, void *evt_buf, 839 struct wmi_roam_result *dst, 840 uint8_t idx); 841 842 /** 843 * wmi_unified_extract_roam_11kv_stats() - Extract BTM/Neigh report stats 844 * @wmi: wmi handle 845 * @evt_buf: Pointer to the event buffer 846 * @dst: Pointer to destination structure to fill data 847 * @idx: TLV id 848 * @rpt_idx: index of the current channel 849 * 850 * Return: QDF_STATUS 851 */ 852 QDF_STATUS 853 wmi_unified_extract_roam_11kv_stats(wmi_unified_t wmi, void *evt_buf, 854 struct wmi_neighbor_report_data *dst, 855 uint8_t idx, uint8_t rpt_idx); 856 857 /** 858 * wmi_unified_vdev_create_send() - send VDEV create command to fw 859 * @wmi_handle: wmi handle 860 * @param: pointer to hold vdev create parameter 861 * @macaddr: vdev mac address 862 * 863 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 864 */ 865 QDF_STATUS wmi_unified_vdev_create_send(wmi_unified_t wmi_handle, 866 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 867 struct vdev_create_params *param); 868 869 /** 870 * wmi_unified_vdev_delete_send() - send VDEV delete command to fw 871 * @wmi_handle: wmi handle 872 * @if_id: vdev id 873 * 874 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 875 */ 876 QDF_STATUS wmi_unified_vdev_delete_send(wmi_unified_t wmi_handle, 877 uint8_t if_id); 878 879 /** 880 * wmi_unified_vdev_nss_chain_params_send() - send VDEV nss chain params to fw 881 * @wmi_handle: wmi handle 882 * @vdev_id: vdev id 883 * @nss_chains_user_cfg: user configured params to send 884 * 885 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 886 */ 887 QDF_STATUS 888 wmi_unified_vdev_nss_chain_params_send( 889 wmi_unified_t wmi_handle, 890 uint8_t vdev_id, 891 struct vdev_nss_chains *nss_chains_user_cfg); 892 893 /** 894 * wmi_unified_vdev_stop_send() - send vdev stop command to fw 895 * @wmi_handle: wmi handle 896 * @vdev_id: vdev id 897 * 898 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 899 */ 900 QDF_STATUS wmi_unified_vdev_stop_send(wmi_unified_t wmi_handle, 901 uint8_t vdev_id); 902 903 /** 904 * wmi_unified_vdev_up_send() - send vdev up command in fw 905 * @wmi_handle: wmi handle 906 * @bssid: bssid 907 * @params: pointer to hold vdev up parameter 908 * 909 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 910 */ 911 QDF_STATUS wmi_unified_vdev_up_send(wmi_unified_t wmi_handle, 912 uint8_t bssid[QDF_MAC_ADDR_SIZE], 913 struct vdev_up_params *params); 914 915 /** 916 * wmi_unified_vdev_down_send() - send vdev down command to fw 917 * @wmi_handle: wmi handle 918 * @vdev_id: vdev id 919 * 920 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 921 */ 922 QDF_STATUS wmi_unified_vdev_down_send(wmi_unified_t wmi_handle, 923 uint8_t vdev_id); 924 925 /** 926 * wmi_unified_vdev_start_send() - send vdev start command to fw 927 * @wmi_handle: wmi handle 928 * @req: pointer to hold vdev start parameters 929 * 930 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 931 */ 932 QDF_STATUS wmi_unified_vdev_start_send(wmi_unified_t wmi_handle, 933 struct vdev_start_params *req); 934 935 /** 936 * wmi_unified_vdev_set_nac_rssi_send() - send NAC_RSSI command to fw 937 * @wmi_handle: handle to WMI 938 * @req: pointer to hold nac rssi request data 939 * 940 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 941 */ 942 QDF_STATUS 943 wmi_unified_vdev_set_nac_rssi_send(wmi_unified_t wmi_handle, 944 struct vdev_scan_nac_rssi_params *req); 945 946 /** 947 * wmi_unified_vdev_set_param_send() - WMI vdev set parameter function 948 * @wmi_handle: handle to WMI. 949 * @param: pointer to hold vdev set parameter 950 * 951 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 952 */ 953 QDF_STATUS 954 wmi_unified_vdev_set_param_send(wmi_unified_t wmi_handle, 955 struct vdev_set_params *param); 956 957 /** 958 * wmi_unified_multiple_vdev_param_send() - sends multiple vdev set params 959 * @wmi_handle: handle to WMI. 960 * @params: pointer to hold set_multiple_pdev_vdev_param info. 961 * 962 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 963 */ 964 QDF_STATUS 965 wmi_unified_multiple_vdev_param_send(wmi_unified_t wmi_handle, 966 struct set_multiple_pdev_vdev_param *params); 967 968 /** 969 * wmi_unified_set_mac_addr_rx_filter() - set mac addr rx filter cmd 970 * @wmi_handle: wmi handle 971 * @param: Pointer to set mac filter struct 972 * 973 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 974 */ 975 QDF_STATUS 976 wmi_unified_set_mac_addr_rx_filter(wmi_unified_t wmi_handle, 977 struct set_rx_mac_filter *param); 978 /** 979 * wmi_unified_multiple_pdev_param_send() - sends multiple pdev set params 980 * @wmi_handle: handle to WMI. 981 * @params: pointer to hold set_multiple_pdev_vdev_param info 982 * 983 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 984 */ 985 QDF_STATUS 986 wmi_unified_multiple_pdev_param_send(wmi_unified_t wmi_handle, 987 struct set_multiple_pdev_vdev_param *params); 988 989 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 990 /** 991 * wmi_unified_roam_set_param_send() - WMI roam set parameter function 992 * @wmi_handle: handle to WMI. 993 * @roam_param: pointer to hold roam set parameter 994 * 995 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 996 */ 997 QDF_STATUS 998 wmi_unified_roam_set_param_send(wmi_unified_t wmi_handle, 999 struct vdev_set_params *roam_param); 1000 #else 1001 static inline QDF_STATUS 1002 wmi_unified_roam_set_param_send(wmi_unified_t wmi_handle, 1003 struct vdev_set_params *roam_param) 1004 { 1005 return QDF_STATUS_SUCCESS; 1006 } 1007 #endif 1008 1009 /** 1010 * wmi_unified_vdev_set_mu_snif_send() - Set vdev MU sniffer parameters 1011 * @wmi_handle: handle to WMI. 1012 * @param: vdev MU sniffer parameters 1013 * 1014 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1015 */ 1016 QDF_STATUS 1017 wmi_unified_vdev_set_mu_snif_send(wmi_unified_t wmi_handle, 1018 struct vdev_set_mu_snif_param *param); 1019 1020 /** 1021 * wmi_unified_sifs_trigger_send() - WMI vdev sifs trigger parameter function 1022 * @wmi_handle: handle to WMI. 1023 * @param: pointer to hold sifs trigger parameter 1024 * 1025 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1026 */ 1027 QDF_STATUS wmi_unified_sifs_trigger_send(wmi_unified_t wmi_handle, 1028 struct sifs_trigger_param *param); 1029 1030 /** 1031 * wmi_unified_peer_delete_send() - send PEER delete command to fw 1032 * @wmi_handle: wmi handle 1033 * @peer_addr: peer mac addr 1034 * @param: pointer to hold peer delete parameters 1035 * 1036 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1037 */ 1038 QDF_STATUS 1039 wmi_unified_peer_delete_send(wmi_unified_t wmi_handle, 1040 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1041 struct peer_delete_cmd_params *param); 1042 1043 /** 1044 * wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw 1045 * @wmi_handle: wmi handle 1046 * @peer_addr: peer mac address 1047 * @param: pointer to hold peer flush tid parameter 1048 * 1049 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1050 */ 1051 QDF_STATUS 1052 wmi_unified_peer_flush_tids_send(wmi_unified_t wmi_handle, 1053 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1054 struct peer_flush_params *param); 1055 #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF 1056 /** 1057 * wmi_unified_peer_txq_flush_config_send() - peer txq flush policy config in fw 1058 * @wmi_handle: wmi handle 1059 * @pr: peer txq flush config parameters 1060 * 1061 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1062 */ 1063 QDF_STATUS 1064 wmi_unified_peer_txq_flush_config_send(wmi_unified_t wmi_handle, 1065 struct peer_txq_flush_config_params *pr); 1066 #endif 1067 1068 /** 1069 * wmi_unified_peer_delete_all_send() - send PEER delete all command to fw 1070 * @wmi_hdl: wmi handle 1071 * @param: pointer to hold peer delete all parameters 1072 * 1073 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1074 */ 1075 QDF_STATUS wmi_unified_peer_delete_all_send( 1076 wmi_unified_t wmi_hdl, 1077 struct peer_delete_all_params *param); 1078 1079 /** 1080 * wmi_set_peer_param_send() - set peer parameter in fw 1081 * @wmi_handle: wmi handle 1082 * @peer_addr: peer mac address 1083 * @param: pointer to hold peer set parameter 1084 * 1085 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1086 */ 1087 QDF_STATUS 1088 wmi_set_peer_param_send(wmi_unified_t wmi_handle, 1089 uint8_t peer_addr[QDF_MAC_ADDR_SIZE], 1090 struct peer_set_params *param); 1091 1092 /** 1093 * wmi_unified_peer_create_send() - send peer create command to fw 1094 * @wmi_handle: wmi handle 1095 * @param: peer create parameters 1096 * 1097 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1098 */ 1099 QDF_STATUS wmi_unified_peer_create_send(wmi_unified_t wmi_handle, 1100 struct peer_create_params *param); 1101 1102 /** 1103 * wmi_unified_green_ap_ps_send() - enable green ap powersave command 1104 * @wmi_handle: wmi handle 1105 * @value: value 1106 * @pdev_id: pdev id to have radio context 1107 * 1108 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1109 */ 1110 QDF_STATUS wmi_unified_green_ap_ps_send(wmi_unified_t wmi_handle, 1111 uint32_t value, uint8_t pdev_id); 1112 1113 /** 1114 * wmi_unified_wow_enable_send() - WMI wow enable function 1115 * @wmi_handle: handle to WMI. 1116 * @param: pointer to hold wow enable parameter 1117 * @mac_id: radio context 1118 * 1119 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1120 */ 1121 QDF_STATUS wmi_unified_wow_enable_send(wmi_unified_t wmi_handle, 1122 struct wow_cmd_params *param, 1123 uint8_t mac_id); 1124 1125 /** 1126 * wmi_unified_wow_wakeup_send() - WMI wow wakeup function 1127 * @wmi_handle: handle to WMI. 1128 * 1129 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1130 */ 1131 QDF_STATUS wmi_unified_wow_wakeup_send(wmi_unified_t wmi_handle); 1132 1133 /** 1134 * wmi_unified_wow_add_wakeup_event_send() - WMI wow wakeup function 1135 * @wmi_handle: handle to WMI. 1136 * @param: pointer to wow wakeup event parameter structure 1137 * 1138 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1139 */ 1140 QDF_STATUS 1141 wmi_unified_wow_add_wakeup_event_send(wmi_unified_t wmi_handle, 1142 struct wow_add_wakeup_params *param); 1143 1144 /** 1145 * wmi_unified_wow_add_wakeup_pattern_send() - WMI wow wakeup pattern function 1146 * @wmi_handle: handle to WMI. 1147 * @param: pointer to wow wakeup pattern parameter structure 1148 * 1149 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1150 */ 1151 QDF_STATUS 1152 wmi_unified_wow_add_wakeup_pattern_send( 1153 wmi_unified_t wmi_handle, 1154 struct wow_add_wakeup_pattern_params *param); 1155 1156 /** 1157 * wmi_unified_wow_remove_wakeup_pattern_send() - wow wakeup pattern function 1158 * @wmi_handle: handle to WMI. 1159 * @param: pointer to wow wakeup pattern parameter structure 1160 * 1161 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1162 */ 1163 QDF_STATUS 1164 wmi_unified_wow_remove_wakeup_pattern_send( 1165 wmi_unified_t wmi_handle, 1166 struct wow_remove_wakeup_pattern_params *param); 1167 1168 /** 1169 * wmi_unified_packet_log_enable_send() - WMI request stats function 1170 * @wmi_handle : handle to WMI. 1171 * @PKTLOG_EVENT : PKTLOG Event 1172 * @mac_id : MAC id corresponds to pdev id 1173 * 1174 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1175 */ 1176 QDF_STATUS 1177 wmi_unified_packet_log_enable_send(wmi_unified_t wmi_handle, 1178 WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, 1179 uint8_t mac_id); 1180 1181 /** 1182 * wmi_unified_peer_based_pktlog_send() - WMI request enable peer 1183 * based filtering 1184 * @wmi_handle: handle to WMI. 1185 * @macaddr: PEER mac address to be filtered 1186 * @mac_id: Mac id 1187 * @enb_dsb: Enable or Disable peer based pktlog 1188 * filtering 1189 * 1190 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1191 */ 1192 QDF_STATUS wmi_unified_peer_based_pktlog_send(wmi_unified_t wmi_handle, 1193 uint8_t *macaddr, 1194 uint8_t mac_id, 1195 uint8_t enb_dsb); 1196 1197 /** 1198 * wmi_unified_packet_log_disable_send() - WMI pktlog disable function 1199 * @wmi_handle: handle to WMI. 1200 * @mac_id: Mac id 1201 * 1202 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1203 */ 1204 QDF_STATUS wmi_unified_packet_log_disable_send(wmi_unified_t wmi_handle, 1205 uint8_t mac_id); 1206 1207 /** 1208 * wmi_unified_suspend_send() - WMI suspend function 1209 * @wmi_handle: handle to WMI. 1210 * @param: pointer to hold suspend parameter 1211 * @mac_id: radio context 1212 * 1213 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1214 */ 1215 QDF_STATUS wmi_unified_suspend_send(wmi_unified_t wmi_handle, 1216 struct suspend_params *param, 1217 uint8_t mac_id); 1218 1219 /** 1220 * wmi_unified_resume_send - WMI resume function 1221 * @wmi_handle : handle to WMI. 1222 * @mac_id: radio context 1223 * 1224 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1225 */ 1226 QDF_STATUS wmi_unified_resume_send(wmi_unified_t wmi_handle, 1227 uint8_t mac_id); 1228 1229 /** 1230 * wmi_unified_pdev_param_send() - set pdev parameters 1231 * @wmi_handle: wmi handle 1232 * @param: pointer to pdev parameter 1233 * @mac_id: radio context 1234 * 1235 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 1236 * errno on failure 1237 */ 1238 QDF_STATUS 1239 wmi_unified_pdev_param_send(wmi_unified_t wmi_handle, 1240 struct pdev_params *param, 1241 uint8_t mac_id); 1242 1243 /** 1244 * wmi_unified_fd_tmpl_send_cmd() - WMI FILS Discovery send function 1245 * @wmi_handle: handle to WMI. 1246 * @param: pointer to hold FILS Discovery send cmd parameter 1247 * 1248 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1249 */ 1250 QDF_STATUS 1251 wmi_unified_fd_tmpl_send_cmd(wmi_unified_t wmi_handle, 1252 struct fils_discovery_tmpl_params *param); 1253 1254 /** 1255 * wmi_unified_beacon_tmpl_send_cmd() - WMI beacon send function 1256 * @wmi_handle: handle to WMI. 1257 * @param: pointer to hold beacon send cmd parameter 1258 * 1259 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1260 */ 1261 QDF_STATUS 1262 wmi_unified_beacon_tmpl_send_cmd(wmi_unified_t wmi_handle, 1263 struct beacon_tmpl_params *param); 1264 1265 /** 1266 * wmi_unified_peer_assoc_send() - WMI peer assoc function 1267 * @wmi_handle: handle to WMI. 1268 * @param: pointer to peer assoc parameter 1269 * 1270 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1271 */ 1272 QDF_STATUS wmi_unified_peer_assoc_send(wmi_unified_t wmi_handle, 1273 struct peer_assoc_params *param); 1274 1275 /** 1276 * wmi_unified_sta_ps_cmd_send() - set sta powersave parameters 1277 * @wmi_handle: wmi handle 1278 * @param: pointer to sta_ps parameter structure 1279 * 1280 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1281 */ 1282 QDF_STATUS wmi_unified_sta_ps_cmd_send(wmi_unified_t wmi_handle, 1283 struct sta_ps_params *param); 1284 1285 /** 1286 * wmi_unified_ap_ps_cmd_send() - set ap powersave parameters 1287 * @wmi_handle: wmi handle 1288 * @macaddr: peer mac address 1289 * @param: pointer to ap_ps parameter structure 1290 * 1291 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1292 */ 1293 QDF_STATUS wmi_unified_ap_ps_cmd_send(wmi_unified_t wmi_handle, 1294 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 1295 struct ap_ps_params *param); 1296 1297 /** 1298 * wmi_unified_scan_start_cmd_send() - WMI scan start function 1299 * @wmi_handle: handle to WMI. 1300 * @param: pointer to hold scan start cmd parameter 1301 * 1302 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1303 */ 1304 QDF_STATUS 1305 wmi_unified_scan_start_cmd_send(wmi_unified_t wmi_handle, 1306 struct scan_req_params *param); 1307 1308 /** 1309 * wmi_unified_scan_stop_cmd_send() - WMI scan start function 1310 * @wmi_handle: handle to WMI. 1311 * @param: pointer to hold scan start cmd parameter 1312 * 1313 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1314 */ 1315 QDF_STATUS 1316 wmi_unified_scan_stop_cmd_send(wmi_unified_t wmi_handle, 1317 struct scan_cancel_param *param); 1318 1319 /** 1320 * wmi_unified_scan_chan_list_cmd_send() - WMI scan channel list function 1321 * @wmi_handle: handle to WMI. 1322 * @param: pointer to hold scan channel list parameter 1323 * 1324 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1325 */ 1326 QDF_STATUS 1327 wmi_unified_scan_chan_list_cmd_send(wmi_unified_t wmi_handle, 1328 struct scan_chan_list_params *param); 1329 1330 1331 /** 1332 * wmi_crash_inject() - inject fw crash 1333 * @wmi_handle: wmi handle 1334 * @param: pointer to crash inject parameter structure 1335 * 1336 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1337 */ 1338 QDF_STATUS wmi_crash_inject(wmi_unified_t wmi_handle, 1339 struct crash_inject *param); 1340 1341 /** 1342 * wmi_unified_pdev_utf_cmd_send() - send utf command to fw 1343 * @wmi_handle: wmi handle 1344 * @param: pointer to pdev_utf_params 1345 * @mac_id: mac id to have radio context 1346 * 1347 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1348 */ 1349 QDF_STATUS wmi_unified_pdev_utf_cmd_send(wmi_unified_t wmi_handle, 1350 struct pdev_utf_params *param, 1351 uint8_t mac_id); 1352 1353 /** 1354 * wmi_unified_dbglog_cmd_send() - set debug log level 1355 * @wmi_handle: handle to WMI. 1356 * @param: pointer to hold dbglog level parameter 1357 * 1358 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1359 */ 1360 QDF_STATUS wmi_unified_dbglog_cmd_send(wmi_unified_t wmi_handle, 1361 struct dbglog_params *param); 1362 1363 /** 1364 * wmi_mgmt_unified_cmd_send() - management cmd over wmi layer 1365 * @wmi_handle: handle to WMI. 1366 * @param: pointer to hold mgmt cmd parameter 1367 * 1368 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1369 */ 1370 QDF_STATUS wmi_mgmt_unified_cmd_send(wmi_unified_t wmi_handle, 1371 struct wmi_mgmt_params *param); 1372 1373 /** 1374 * wmi_offchan_data_tx_cmd_send() - Send offchan data tx cmd over wmi layer 1375 * @wmi_handle: handle to WMI. 1376 * @param: pointer to hold offchan data cmd parameter 1377 * 1378 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1379 */ 1380 QDF_STATUS wmi_offchan_data_tx_cmd_send( 1381 wmi_unified_t wmi_handle, 1382 struct wmi_offchan_data_tx_params *param); 1383 1384 /** 1385 * wmi_unified_modem_power_state() - set modem power state to fw 1386 * @wmi_handle: wmi handle 1387 * @param_value: parameter value 1388 * 1389 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1390 */ 1391 QDF_STATUS wmi_unified_modem_power_state(wmi_unified_t wmi_handle, 1392 uint32_t param_value); 1393 1394 /** 1395 * wmi_unified_set_sta_ps_mode() - set sta powersave params in fw 1396 * @wmi_handle: wmi handle 1397 * @vdev_id: vdev id 1398 * @val: value 1399 * 1400 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1401 */ 1402 QDF_STATUS wmi_unified_set_sta_ps_mode(wmi_unified_t wmi_handle, 1403 uint32_t vdev_id, 1404 uint8_t val); 1405 1406 /** 1407 * wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command 1408 * @wmi_handle: wmi handle 1409 * @param: uapsd cmd parameter structure 1410 * 1411 * This function sets the trigger 1412 * uapsd params such as service interval, delay interval 1413 * and suspend interval which will be used by the firmware 1414 * to send trigger frames periodically when there is no 1415 * traffic on the transmit side. 1416 * 1417 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1418 */ 1419 QDF_STATUS 1420 wmi_unified_set_sta_uapsd_auto_trig_cmd(wmi_unified_t wmi_handle, 1421 struct sta_uapsd_trig_params *param); 1422 1423 /** 1424 * wmi_unified_get_temperature() - get pdev temperature req 1425 * @wmi_handle: wmi handle 1426 * 1427 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1428 */ 1429 QDF_STATUS wmi_unified_get_temperature(wmi_unified_t wmi_handle); 1430 1431 /** 1432 * wmi_unified_set_smps_params() - set smps params 1433 * @wmi_handle: wmi handle 1434 * @vdev_id: vdev id 1435 * @value: value 1436 * 1437 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1438 */ 1439 QDF_STATUS wmi_unified_set_smps_params(wmi_unified_t wmi_handle, 1440 uint8_t vdev_id, 1441 int value); 1442 1443 /** 1444 * wmi_unified_set_mimops() - set MIMO powersave 1445 * @wmi_handle: wmi handle 1446 * @vdev_id: vdev id 1447 * @value: value 1448 * 1449 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1450 */ 1451 QDF_STATUS wmi_unified_set_mimops(wmi_unified_t wmi_handle, 1452 uint8_t vdev_id, int value); 1453 1454 /** 1455 * wmi_unified_lro_config_cmd() - process the LRO config command 1456 * @wmi_handle: Pointer to wmi handle 1457 * @wmi_lro_cmd: Pointer to LRO configuration parameters 1458 * 1459 * This function sends down the LRO configuration parameters to 1460 * the firmware to enable LRO, sets the TCP flags and sets the 1461 * seed values for the toeplitz hash generation 1462 * 1463 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1464 */ 1465 QDF_STATUS 1466 wmi_unified_lro_config_cmd(wmi_unified_t wmi_handle, 1467 struct wmi_lro_config_cmd_t *wmi_lro_cmd); 1468 1469 /** 1470 * wmi_unified_set_thermal_mgmt_cmd() - set thermal mgmt command to fw 1471 * @wmi_handle: Pointer to wmi handle 1472 * @thermal_info: Thermal command information 1473 * 1474 * This function sends the thermal management command 1475 * to the firmware 1476 * 1477 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1478 */ 1479 QDF_STATUS 1480 wmi_unified_set_thermal_mgmt_cmd(wmi_unified_t wmi_handle, 1481 struct thermal_cmd_params *thermal_info); 1482 1483 /** 1484 * wmi_unified_peer_rate_report_cmd() - process the peer rate report command 1485 * @wmi_handle: Pointer to wmi handle 1486 * @rate_report_params: Pointer to peer rate report parameters 1487 * 1488 * 1489 * Return: QDF_STATUS_SUCCESS for success otherwise failure 1490 */ 1491 QDF_STATUS 1492 wmi_unified_peer_rate_report_cmd( 1493 wmi_unified_t wmi_handle, 1494 struct wmi_peer_rate_report_params *rate_report_params); 1495 1496 /** 1497 * wmi_unified_process_update_edca_param() - update EDCA params 1498 * @wmi_handle: wmi handle 1499 * @vdev_id: vdev id. 1500 * @mu_edca_param: mu_edca_param. 1501 * @wmm_vparams: edca parameters 1502 * 1503 * This function updates EDCA parameters to the target 1504 * 1505 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1506 */ 1507 QDF_STATUS 1508 wmi_unified_process_update_edca_param( 1509 wmi_unified_t wmi_handle, 1510 uint8_t vdev_id, 1511 bool mu_edca_param, 1512 struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]); 1513 1514 /** 1515 * wmi_unified_probe_rsp_tmpl_send_cmd() - send probe response template to fw 1516 * @wmi_handle: wmi handle 1517 * @vdev_id: vdev id 1518 * @probe_rsp_info: probe response info 1519 * 1520 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1521 */ 1522 QDF_STATUS 1523 wmi_unified_probe_rsp_tmpl_send_cmd( 1524 wmi_unified_t wmi_handle, 1525 uint8_t vdev_id, 1526 struct wmi_probe_resp_params *probe_rsp_info); 1527 1528 /** 1529 * wmi_unified_setup_install_key_cmd - send key to install to fw 1530 * @wmi_handle: wmi handle 1531 * @key_params: key parameters 1532 * 1533 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1534 */ 1535 QDF_STATUS 1536 wmi_unified_setup_install_key_cmd(wmi_unified_t wmi_handle, 1537 struct set_key_params *key_params); 1538 1539 /** 1540 * wmi_unified_get_pn_send_cmd() - send command to fw get PN for peer 1541 * @wmi_hdl: wmi handle 1542 * @pn_params: PN parameters 1543 * 1544 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1545 */ 1546 QDF_STATUS 1547 wmi_unified_get_pn_send_cmd(wmi_unified_t wmi_hdl, 1548 struct peer_request_pn_param *pn_params); 1549 1550 /** 1551 * wmi_unified_get_rxpn_send_cmd() - send command to fw get Rx PN for peer 1552 * @wmi_hdl: wmi handle 1553 * @pn_params: PN parameters 1554 * 1555 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1556 */ 1557 QDF_STATUS 1558 wmi_unified_get_rxpn_send_cmd(wmi_unified_t wmi_hdl, 1559 struct peer_request_rxpn_param *pn_params); 1560 1561 /** 1562 * wmi_unified_p2p_go_set_beacon_ie_cmd() - set beacon IE for p2p go 1563 * @wmi_hdl: wmi handle 1564 * @vdev_id: vdev id 1565 * @p2p_ie: p2p IE 1566 * 1567 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1568 */ 1569 QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(wmi_unified_t wmi_hdl, 1570 uint32_t vdev_id, 1571 uint8_t *p2p_ie); 1572 1573 /** 1574 * wmi_unified_scan_probe_setoui_cmd() - set scan probe OUI 1575 * @wmi_handle: wmi handle 1576 * @psetoui: OUI parameters 1577 * 1578 * set scan probe OUI parameters in firmware 1579 * 1580 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1581 */ 1582 QDF_STATUS wmi_unified_scan_probe_setoui_cmd(wmi_unified_t wmi_handle, 1583 struct scan_mac_oui *psetoui); 1584 1585 #ifdef IPA_OFFLOAD 1586 /** 1587 * wmi_unified_ipa_offload_control_cmd() - ipa offload control parameter 1588 * @wmi_handle: wmi handle 1589 * @ipa_offload: ipa offload control parameter 1590 * 1591 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 1592 * error number otherwise 1593 */ 1594 QDF_STATUS 1595 wmi_unified_ipa_offload_control_cmd( 1596 wmi_unified_t wmi_handle, 1597 struct ipa_uc_offload_control_params *ipa_offload); 1598 #endif 1599 1600 /** 1601 * wmi_unified_pno_stop_cmd() - PNO stop request 1602 * @wmi_handle: wmi handle 1603 * @vdev_id: vdev id 1604 * 1605 * This function request FW to stop ongoing PNO operation. 1606 * 1607 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1608 */ 1609 QDF_STATUS wmi_unified_pno_stop_cmd(wmi_unified_t wmi_handle, uint8_t vdev_id); 1610 1611 /** 1612 * wmi_unified_obss_disable_cmd() - disable obss scan request 1613 * @wmi_handle: wmi handle 1614 * @vdev_id: vdev id 1615 * 1616 * This function request FW to disable obss scan. 1617 * 1618 * Return: QDF_STATUS_SUCCESS on success and others for failure 1619 */ 1620 QDF_STATUS wmi_unified_obss_disable_cmd(wmi_unified_t wmi_handle, 1621 uint8_t vdev_id); 1622 1623 #ifdef FEATURE_WLAN_SCAN_PNO 1624 /** 1625 * wmi_unified_pno_start_cmd() - PNO start request 1626 * @wmi_handle: wmi handle 1627 * @pno: PNO request 1628 * 1629 * This function request FW to start PNO request. 1630 * Request: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1631 */ 1632 QDF_STATUS wmi_unified_pno_start_cmd(wmi_unified_t wmi_handle, 1633 struct pno_scan_req_params *pno); 1634 #endif 1635 1636 /** 1637 * wmi_unified_nlo_mawc_cmd() - NLO MAWC cmd configuration 1638 * @wmi_handle: wmi handle 1639 * @params: Configuration parameters 1640 * 1641 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1642 */ 1643 QDF_STATUS wmi_unified_nlo_mawc_cmd(wmi_unified_t wmi_handle, 1644 struct nlo_mawc_params *params); 1645 1646 #ifdef WLAN_FEATURE_LINK_LAYER_STATS 1647 /** 1648 * wmi_unified_process_ll_stats_clear_cmd() - clear link layer stats 1649 * @wmi_handle: wmi handle 1650 * @clear_req: ll stats clear request command params 1651 * 1652 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1653 */ 1654 QDF_STATUS wmi_unified_process_ll_stats_clear_cmd(wmi_unified_t wmi_handle, 1655 const struct ll_stats_clear_params *clear_req); 1656 1657 /** 1658 * wmi_unified_process_ll_stats_set_cmd() - link layer stats set request 1659 * @wmi_handle: wmi handle 1660 * @set_req: ll stats set request command params 1661 * 1662 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1663 */ 1664 QDF_STATUS wmi_unified_process_ll_stats_set_cmd(wmi_unified_t wmi_handle, 1665 const struct ll_stats_set_params *set_req); 1666 1667 /** 1668 * wmi_unified_process_ll_stats_get_cmd() - link layer stats get request 1669 * @wmi_handle: wmi handle 1670 * @get_req: ll stats get request command params 1671 * 1672 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1673 */ 1674 QDF_STATUS wmi_unified_process_ll_stats_get_cmd(wmi_unified_t wmi_handle, 1675 const struct ll_stats_get_params *get_req); 1676 1677 #ifdef FEATURE_CLUB_LL_STATS_AND_GET_STATION 1678 /** 1679 * wmi_process_unified_ll_stats_get_sta_cmd() - unified link layer stats and 1680 * get station request 1681 * @wmi_handle: wmi handle 1682 * @get_req: unified ll stats and get station request command params 1683 * 1684 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1685 */ 1686 QDF_STATUS wmi_process_unified_ll_stats_get_sta_cmd( 1687 wmi_unified_t wmi_handle, 1688 const struct ll_stats_get_params *get_req); 1689 #endif /* FEATURE_CLUB_LL_STATS_AND_GET_STATION */ 1690 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */ 1691 1692 /** 1693 * wmi_unified_congestion_request_cmd() - send request to fw to get CCA 1694 * @wmi_handle: wma handle 1695 * @vdev_id: vdev id 1696 * 1697 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1698 */ 1699 QDF_STATUS wmi_unified_congestion_request_cmd(wmi_unified_t wmi_handle, 1700 uint8_t vdev_id); 1701 1702 /** 1703 * wmi_unified_snr_request_cmd() - send request to fw to get RSSI stats 1704 * @wmi_handle: wmi handle 1705 * 1706 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1707 */ 1708 QDF_STATUS wmi_unified_snr_request_cmd(wmi_unified_t wmi_handle); 1709 1710 /** 1711 * wmi_unified_snr_cmd() - get RSSI from fw 1712 * @wmi_handle: wmi handle 1713 * @vdev_id: vdev id 1714 * 1715 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1716 */ 1717 QDF_STATUS wmi_unified_snr_cmd(wmi_unified_t wmi_handle, uint8_t vdev_id); 1718 1719 /** 1720 * wmi_unified_link_status_req_cmd() - process link status request from UMAC 1721 * @wmi_handle: wmi handle 1722 * @params: get link status params 1723 * 1724 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1725 */ 1726 QDF_STATUS wmi_unified_link_status_req_cmd(wmi_unified_t wmi_handle, 1727 struct link_status_params *params); 1728 1729 #ifdef WLAN_SUPPORT_GREEN_AP 1730 /** 1731 * wmi_unified_egap_conf_params_cmd() - send wmi cmd of egap config params 1732 * @wmi_handle: wmi handler 1733 * @egap_params: pointer to egap_params 1734 * 1735 * Return: 0 for success, otherwise appropriate error code 1736 */ 1737 QDF_STATUS 1738 wmi_unified_egap_conf_params_cmd( 1739 wmi_unified_t wmi_handle, 1740 struct wlan_green_ap_egap_params *egap_params); 1741 #endif 1742 1743 /** 1744 * wmi_unified_csa_offload_enable() - send CSA offload enable command 1745 * @wmi_handle: wmi handle 1746 * @vdev_id: vdev id 1747 * 1748 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1749 */ 1750 QDF_STATUS wmi_unified_csa_offload_enable(wmi_unified_t wmi_handle, 1751 uint8_t vdev_id); 1752 1753 #ifdef WLAN_FEATURE_CIF_CFR 1754 /** 1755 * wmi_unified_oem_dma_ring_cfg() - configure OEM DMA rings 1756 * @wmi_handle: wmi handle 1757 * @cfg: dma cfg req 1758 * 1759 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1760 */ 1761 QDF_STATUS 1762 wmi_unified_oem_dma_ring_cfg(wmi_unified_t wmi_handle, 1763 wmi_oem_dma_ring_cfg_req_fixed_param *cfg); 1764 #endif 1765 1766 /** 1767 * wmi_unified_start_oem_data_cmd() - start oem data request to target 1768 * @wmi_handle: wmi handle 1769 * @data_len: the length of @data 1770 * @data: the pointer to data buf 1771 * 1772 * This is legacy api for oem data request, using wmi command 1773 * WMI_OEM_REQ_CMDID. 1774 * 1775 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1776 */ 1777 QDF_STATUS wmi_unified_start_oem_data_cmd(wmi_unified_t wmi_handle, 1778 uint32_t data_len, 1779 uint8_t *data); 1780 1781 #ifdef FEATURE_OEM_DATA 1782 /** 1783 * wmi_unified_start_oemv2_data_cmd() - start oem data cmd to target 1784 * @wmi_handle: wmi handle 1785 * @params: oem data params 1786 * 1787 * This is common api for oem data, using wmi command WMI_OEM_DATA_CMDID. 1788 * 1789 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1790 */ 1791 QDF_STATUS wmi_unified_start_oemv2_data_cmd(wmi_unified_t wmi_handle, 1792 struct oem_data *params); 1793 #endif 1794 1795 /** 1796 * wmi_unified_dfs_phyerr_filter_offload_en_cmd() - enable dfs phyerr filter 1797 * @wmi_handle: wmi handle 1798 * @dfs_phyerr_filter_offload: is dfs phyerr filter offload 1799 * 1800 * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or 1801 * WMI_DFS_PHYERR_FILTER_DIS_CMDID command 1802 * to firmware based on phyerr filtering 1803 * offload status. 1804 * 1805 * Return: 1 success, 0 failure 1806 */ 1807 QDF_STATUS 1808 wmi_unified_dfs_phyerr_filter_offload_en_cmd(wmi_unified_t wmi_handle, 1809 bool dfs_phyerr_filter_offload); 1810 1811 #if !defined(REMOVE_PKT_LOG) && defined(FEATURE_PKTLOG) 1812 /** 1813 * wmi_unified_pktlog_wmi_send_cmd() - send pktlog event command to target 1814 * @wmi_handle: wmi handle 1815 * @pktlog_event: pktlog event 1816 * @cmd_id: pktlog cmd id 1817 * @user_triggered: user triggered input for PKTLOG enable mode 1818 * 1819 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1820 */ 1821 QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(wmi_unified_t wmi_handle, 1822 WMI_PKTLOG_EVENT pktlog_event, 1823 uint32_t cmd_id, 1824 uint8_t user_triggered); 1825 #endif 1826 1827 /** 1828 * wmi_unified_stats_ext_req_cmd() - request ext stats from fw 1829 * @wmi_handle: wmi handle 1830 * @preq: stats ext params 1831 * 1832 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1833 */ 1834 QDF_STATUS wmi_unified_stats_ext_req_cmd(wmi_unified_t wmi_handle, 1835 struct stats_ext_params *preq); 1836 1837 /** 1838 * wmi_unified_process_dhcpserver_offload_cmd() - enable DHCP server offload 1839 * @wmi_handle: wmi handle 1840 * @params: DHCP server offload info 1841 * 1842 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1843 */ 1844 QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd( 1845 wmi_unified_t wmi_handle, 1846 struct dhcp_offload_info_params *params); 1847 1848 /** 1849 * wmi_unified_send_regdomain_info_to_fw_cmd() - send regdomain info to fw 1850 * @wmi_handle: wmi handle 1851 * @reg_dmn: reg domain 1852 * @regdmn2G: 2G reg domain 1853 * @regdmn5G: 5G reg domain 1854 * @ctl2G: 2G test limit 1855 * @ctl5G: 5G test limit 1856 * 1857 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1858 */ 1859 QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(wmi_unified_t wmi_handle, 1860 uint32_t reg_dmn, 1861 uint16_t regdmn2G, 1862 uint16_t regdmn5G, 1863 uint8_t ctl2G, 1864 uint8_t ctl5G); 1865 1866 QDF_STATUS 1867 wmi_unified_process_fw_mem_dump_cmd(wmi_unified_t wmi_hdl, 1868 struct fw_dump_req_param *mem_dump_req); 1869 1870 /** 1871 * wmi_unified_cfg_action_frm_tb_ppdu_cmd()-send action frame TB PPDU cfg to FW 1872 * @wmi_handle: Pointer to WMi handle 1873 * @cfg_info: Pointer to cfg msg 1874 * 1875 * This function sends action frame TB PPDU cfg to firmware 1876 * 1877 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1878 * 1879 */ 1880 QDF_STATUS 1881 wmi_unified_cfg_action_frm_tb_ppdu_cmd( 1882 wmi_unified_t wmi_handle, 1883 struct cfg_action_frm_tb_ppdu_param *cfg_info); 1884 1885 /** 1886 * wmi_unified_save_fw_version_cmd() - save fw version 1887 * @wmi_handle: pointer to wmi handle 1888 * @evt_buf: Event buffer 1889 * 1890 * 1891 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1892 * 1893 */ 1894 QDF_STATUS wmi_unified_save_fw_version_cmd(wmi_unified_t wmi_handle, 1895 void *evt_buf); 1896 1897 /** 1898 * wmi_unified_log_supported_evt_cmd() - Enable/Disable FW diag/log events 1899 * @wmi_handle: wmi handle 1900 * @event: Event received from FW 1901 * @len: Length of the event 1902 * 1903 * Enables the low frequency events and disables the high frequency 1904 * events. Bit 17 indicates if the event if low/high frequency. 1905 * 1 - high frequency, 0 - low frequency 1906 * 1907 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures 1908 */ 1909 QDF_STATUS wmi_unified_log_supported_evt_cmd(wmi_unified_t wmi_handle, 1910 uint8_t *event, 1911 uint32_t len); 1912 1913 /** 1914 * wmi_unified_enable_specific_fw_logs_cmd() - Start/Stop logging of diag log id 1915 * @wmi_handle: wmi handle 1916 * @start_log: Start logging related parameters 1917 * 1918 * Send the command to the FW based on which specific logging of diag 1919 * event/log id can be started/stopped 1920 * 1921 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1922 */ 1923 QDF_STATUS 1924 wmi_unified_enable_specific_fw_logs_cmd(wmi_unified_t wmi_handle, 1925 struct wmi_wifi_start_log *start_log); 1926 1927 /** 1928 * wmi_unified_flush_logs_to_fw_cmd() - Send log flush command to FW 1929 * @wmi_handle: WMI handle 1930 * 1931 * This function is used to send the flush command to the FW, 1932 * that will flush the fw logs that are residue in the FW 1933 * 1934 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1935 */ 1936 QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(wmi_unified_t wmi_handle); 1937 1938 /** 1939 * wmi_unified_unit_test_cmd() - send unit test command to fw. 1940 * @wmi_handle: wmi handle 1941 * @wmi_utest: unit test command 1942 * 1943 * This function send unit test command to fw. 1944 * 1945 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1946 */ 1947 QDF_STATUS wmi_unified_unit_test_cmd(wmi_unified_t wmi_handle, 1948 struct wmi_unit_test_cmd *wmi_utest); 1949 1950 #ifdef FEATURE_WLAN_APF 1951 /** 1952 * wmi_unified_set_active_apf_mode_cmd() - config active APF mode in FW 1953 * @wmi: the WMI handle 1954 * @vdev_id: the Id of the vdev to apply the configuration to 1955 * @ucast_mode: the active APF mode to configure for unicast packets 1956 * @mcast_bcast_mode: the active APF mode to configure for multicast/broadcast 1957 * packets 1958 */ 1959 QDF_STATUS 1960 wmi_unified_set_active_apf_mode_cmd(wmi_unified_t wmi, uint8_t vdev_id, 1961 enum wmi_host_active_apf_mode ucast_mode, 1962 enum wmi_host_active_apf_mode 1963 mcast_bcast_mode); 1964 1965 /** 1966 * wmi_unified_send_apf_enable_cmd() - send apf enable/disable cmd 1967 * @wmi: wmi handle 1968 * @vdev_id: VDEV id 1969 * @enable: true: enable, false: disable 1970 * 1971 * This function passes the apf enable command to fw 1972 * 1973 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1974 */ 1975 QDF_STATUS wmi_unified_send_apf_enable_cmd(wmi_unified_t wmi, 1976 uint32_t vdev_id, bool enable); 1977 1978 /** 1979 * wmi_unified_send_apf_write_work_memory_cmd() - send cmd to write into the APF 1980 * work memory. 1981 * @wmi: wmi handle 1982 * @write_params: parameters and buffer pointer for the write 1983 * 1984 * This function passes the write apf work mem command to fw 1985 * 1986 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1987 */ 1988 QDF_STATUS wmi_unified_send_apf_write_work_memory_cmd(wmi_unified_t wmi, 1989 struct wmi_apf_write_memory_params *write_params); 1990 1991 /** 1992 * wmi_unified_send_apf_read_work_memory_cmd() - send cmd to read part of APF 1993 * work memory 1994 * @wmi: wmi handle 1995 * @read_params: contains relative address and length to read from 1996 * 1997 * This function passes the read apf work mem command to fw 1998 * 1999 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2000 */ 2001 QDF_STATUS wmi_unified_send_apf_read_work_memory_cmd(wmi_unified_t wmi, 2002 struct wmi_apf_read_memory_params *read_params); 2003 2004 /** 2005 * wmi_extract_apf_read_memory_resp_event() - extract read mem resp event 2006 * @wmi: wmi handle 2007 * @evt_buf: Pointer to the event buffer 2008 * @read_mem_evt: pointer to memory to extract event parameters into 2009 * 2010 * This function exctracts read mem response event into the given structure ptr 2011 * 2012 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2013 */ 2014 QDF_STATUS 2015 wmi_extract_apf_read_memory_resp_event(wmi_unified_t wmi, void *evt_buf, 2016 struct wmi_apf_read_memory_resp_event_params 2017 *read_mem_evt); 2018 #endif /* FEATURE_WLAN_APF */ 2019 2020 /** 2021 * wmi_send_get_user_position_cmd() - send get user position command to fw 2022 * @wmi_handle: wmi handle 2023 * @value: user pos value 2024 * 2025 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2026 */ 2027 QDF_STATUS 2028 wmi_send_get_user_position_cmd(wmi_unified_t wmi_handle, uint32_t value); 2029 2030 /** 2031 * wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count 2032 * command to fw 2033 * @wmi_handle: wmi handle 2034 * @value: user pos value 2035 * 2036 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2037 */ 2038 QDF_STATUS 2039 wmi_send_get_peer_mumimo_tx_count_cmd(wmi_unified_t wmi_handle, 2040 uint32_t value); 2041 2042 /** 2043 * wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo 2044 * tx count to fw 2045 * @wmi_handle: wmi handle 2046 * @value: reset tx count value 2047 * 2048 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2049 */ 2050 QDF_STATUS 2051 wmi_send_reset_peer_mumimo_tx_count_cmd(wmi_unified_t wmi_handle, 2052 uint32_t value); 2053 2054 /** 2055 * wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands 2056 * @wmi_handle: wmi handle 2057 * @param: wmi btcoex cfg params 2058 * 2059 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 2060 * 2061 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2062 */ 2063 QDF_STATUS 2064 wmi_unified_send_btcoex_wlan_priority_cmd(wmi_unified_t wmi_handle, 2065 struct btcoex_cfg_params *param); 2066 2067 /** 2068 * wmi_unified_send_btcoex_duty_cycle_cmd() - send btcoex duty cycle commands 2069 * @wmi_handle: wmi handle 2070 * @param: wmi btcoex cfg params 2071 * 2072 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 2073 * 2074 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2075 */ 2076 QDF_STATUS 2077 wmi_unified_send_btcoex_duty_cycle_cmd(wmi_unified_t wmi_handle, 2078 struct btcoex_cfg_params *param); 2079 2080 /** 2081 * wmi_unified_send_coex_ver_cfg_cmd() - send coex ver cfg command 2082 * @wmi_handle: wmi handle 2083 * @param: wmi coex ver cfg params 2084 * 2085 * Send WMI_COEX_VERSION_CFG_CMID parameters to fw. 2086 * 2087 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2088 */ 2089 QDF_STATUS 2090 wmi_unified_send_coex_ver_cfg_cmd(wmi_unified_t wmi_handle, 2091 coex_ver_cfg_t *param); 2092 2093 /** 2094 * wmi_unified_send_coex_config_cmd() - send coex ver cfg command 2095 * @wmi_handle: wmi handle 2096 * @param: wmi coex cfg cmd params 2097 * 2098 * Send WMI_COEX_CFG_CMD parameters to fw. 2099 * 2100 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2101 */ 2102 QDF_STATUS 2103 wmi_unified_send_coex_config_cmd(wmi_unified_t wmi_handle, 2104 struct coex_config_params *param); 2105 #ifdef WLAN_FEATURE_DBAM_CONFIG 2106 /** 2107 * wmi_unified_send_dbam_config_cmd() - send dbam config command 2108 * @wmi_handle: wmi handle 2109 * @param: dbam config mode param 2110 * 2111 * Send WMI_COEX_DBAM_CMD param to fw. 2112 * 2113 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2114 */ 2115 QDF_STATUS 2116 wmi_unified_send_dbam_config_cmd(wmi_unified_t wmi_handle, 2117 struct coex_dbam_config_params *param); 2118 2119 /** 2120 * wmi_extract_dbam_config_response() - extract dbam config resp sent by FW 2121 * @wmi_handle: wmi handle 2122 * @evt_buf: pointer to event buffer 2123 * @resp: struct containing dbam config response sent by FW 2124 * 2125 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 2126 */ 2127 QDF_STATUS 2128 wmi_extract_dbam_config_response(wmi_unified_t wmi_handle, void *evt_buf, 2129 struct coex_dbam_config_resp *resp); 2130 #endif 2131 2132 /** 2133 * wmi_unified_pdev_fips_cmd_send() - WMI pdev fips cmd function 2134 * @wmi_handle: handle to WMI. 2135 * @param: pointer to hold pdev fips param 2136 * 2137 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2138 */ 2139 QDF_STATUS 2140 wmi_unified_pdev_fips_cmd_send(wmi_unified_t wmi_handle, 2141 struct fips_params *param); 2142 2143 #ifdef WLAN_FEATURE_FIPS_BER_CCMGCM 2144 /** 2145 * wmi_unified_pdev_fips_extend_cmd_send() - WMI pdev fips extend cmd function 2146 * @wmi_handle: handle to WMI. 2147 * @param: pointer to hold pdev fips extend param 2148 * 2149 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2150 */ 2151 QDF_STATUS 2152 wmi_unified_pdev_fips_extend_cmd_send(wmi_unified_t wmi_handle, 2153 struct fips_extend_params *param); 2154 2155 /** 2156 * wmi_unified_pdev_fips_mode_set_cmd() - WMI pdev fips mode enable cmd 2157 * @wmi_handle: handle to WMI. 2158 * @param: pointer to hold pdev fips mode param 2159 * 2160 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2161 */ 2162 QDF_STATUS 2163 wmi_unified_pdev_fips_mode_set_cmd(wmi_unified_t wmi_handle, 2164 struct fips_mode_set_params *param); 2165 2166 /** 2167 * wmi_extract_fips_extend_event_data() - extract fips extend event data 2168 * @wmi_handle: wmi handle 2169 * @evt_buf: pointer to event buffer 2170 * @param: pointer to FIPS extend event param 2171 * 2172 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2173 */ 2174 QDF_STATUS 2175 wmi_extract_fips_extend_event_data(wmi_unified_t wmi_handle, void *evt_buf, 2176 struct wmi_host_fips_extend_event_param 2177 *param); 2178 #endif 2179 2180 #ifdef WLAN_FEATURE_DISA 2181 /** 2182 * wmi_unified_encrypt_decrypt_send_cmd() - send encryptdecrypt cmd to fw 2183 * @wmi_hdl: wmi handle 2184 * @params: encrypt/decrypt params 2185 * 2186 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2187 */ 2188 QDF_STATUS 2189 wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl, 2190 struct disa_encrypt_decrypt_req_params 2191 *params); 2192 #endif /* WLAN_FEATURE_DISA */ 2193 2194 /** 2195 * wmi_unified_wlan_profile_enable_cmd_send() - WMI wlan profile enable 2196 * cmd function 2197 * @wmi_handle: handle to WMI. 2198 * @param: pointer to hold wlan profile param 2199 * 2200 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2201 */ 2202 QDF_STATUS 2203 wmi_unified_wlan_profile_enable_cmd_send(wmi_unified_t wmi_handle, 2204 struct wlan_profile_params *param); 2205 2206 /** 2207 * wmi_unified_wlan_profile_trigger_cmd_send() - WMI wlan profile trigger 2208 * cmd function 2209 * @wmi_handle: handle to WMI. 2210 * @param: pointer to hold wlan profile param 2211 * 2212 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2213 */ 2214 QDF_STATUS 2215 wmi_unified_wlan_profile_trigger_cmd_send(wmi_unified_t wmi_handle, 2216 struct wlan_profile_params *param); 2217 2218 /** 2219 * wmi_unified_wlan_profile_hist_intvl_cmd_send() - WMI wlan profile history 2220 * cmd function 2221 * @wmi_handle: handle to WMI. 2222 * @param: pointer to hold wlan profile param 2223 * 2224 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2225 */ 2226 QDF_STATUS 2227 wmi_unified_wlan_profile_hist_intvl_cmd_send(wmi_unified_t wmi_handle, 2228 struct wlan_profile_params *param); 2229 2230 /** 2231 * wmi_unified_set_chan_cmd_send() - WMI set channel cmd function 2232 * @wmi_handle: handle to WMI. 2233 * @param: pointer to hold channel param 2234 * 2235 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2236 */ 2237 QDF_STATUS 2238 wmi_unified_set_chan_cmd_send(wmi_unified_t wmi_handle, 2239 struct channel_param *param); 2240 2241 /** 2242 * wmi_unified_set_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 2243 * @wmi_handle: handle to WMI. 2244 * @param: pointer to hold ratepwr table param 2245 * 2246 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2247 */ 2248 QDF_STATUS 2249 wmi_unified_set_ratepwr_table_cmd_send(wmi_unified_t wmi_handle, 2250 struct ratepwr_table_params *param); 2251 2252 /** 2253 * wmi_unified_get_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 2254 * @wmi_handle: handle to WMI. 2255 * 2256 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2257 */ 2258 QDF_STATUS wmi_unified_get_ratepwr_table_cmd_send(wmi_unified_t wmi_handle); 2259 2260 /** 2261 * wmi_unified_set_ratepwr_chainmsk_cmd_send() - WMI ratepwr 2262 * chainmsk cmd function 2263 * @wmi_handle: handle to WMI. 2264 * @param: pointer to hold ratepwr chainmsk param 2265 * 2266 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2267 */ 2268 QDF_STATUS 2269 wmi_unified_set_ratepwr_chainmsk_cmd_send(wmi_unified_t wmi_handle, 2270 struct ratepwr_chainmsk_params 2271 *param); 2272 2273 /** 2274 * wmi_unified_set_macaddr_cmd_send() - WMI set macaddr cmd function 2275 * @wmi_handle: handle to WMI. 2276 * @param: pointer to hold macaddr param 2277 * 2278 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2279 */ 2280 QDF_STATUS wmi_unified_set_macaddr_cmd_send(wmi_unified_t wmi_handle, 2281 struct macaddr_params *param); 2282 2283 /** 2284 * wmi_unified_pdev_scan_start_cmd_send() - WMI pdev scan start cmd function 2285 * @wmi_handle: handle to WMI. 2286 * 2287 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2288 */ 2289 QDF_STATUS wmi_unified_pdev_scan_start_cmd_send(wmi_unified_t wmi_handle); 2290 2291 /** 2292 * wmi_unified_pdev_scan_end_cmd_send() - WMI pdev scan end cmd function 2293 * @wmi_handle: handle to WMI. 2294 * 2295 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2296 */ 2297 QDF_STATUS wmi_unified_pdev_scan_end_cmd_send(wmi_unified_t wmi_handle); 2298 2299 /** 2300 * wmi_unified_set_acparams_cmd_send() - WMI set acparams cmd function 2301 * @wmi_handle: handle to WMI. 2302 * @param: pointer to hold acparams param 2303 * 2304 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2305 */ 2306 QDF_STATUS 2307 wmi_unified_set_acparams_cmd_send(wmi_unified_t wmi_handle, 2308 struct acparams_params *param); 2309 2310 /** 2311 * wmi_unified_set_vap_dscp_tid_map_cmd_send() - WMI set vap dscp 2312 * tid map cmd function 2313 * @wmi_handle: handle to WMI. 2314 * @param: pointer to hold dscp param 2315 * 2316 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2317 */ 2318 QDF_STATUS 2319 wmi_unified_set_vap_dscp_tid_map_cmd_send( 2320 wmi_unified_t wmi_handle, 2321 struct vap_dscp_tid_map_params *param); 2322 2323 /** 2324 * wmi_unified_proxy_ast_reserve_cmd_send() - WMI proxy ast 2325 * reserve cmd function 2326 * @wmi_handle: handle to WMI. 2327 * @param: pointer to hold ast param 2328 * 2329 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2330 */ 2331 QDF_STATUS 2332 wmi_unified_proxy_ast_reserve_cmd_send(wmi_unified_t wmi_handle, 2333 struct proxy_ast_reserve_params *param); 2334 2335 /** 2336 * wmi_unified_set_bridge_mac_addr_cmd_send() - WMI set bridge mac 2337 * addr cmd function 2338 * @wmi_handle: handle to WMI. 2339 * @param: pointer to hold bridge mac addr param 2340 * 2341 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2342 */ 2343 QDF_STATUS wmi_unified_set_bridge_mac_addr_cmd_send( 2344 wmi_unified_t wmi_handle, 2345 struct set_bridge_mac_addr_params *param); 2346 2347 /** 2348 * wmi_unified_phyerr_enable_cmd_send() - WMI phyerr enable cmd function 2349 * @wmi_handle: handle to WMI. 2350 * 2351 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2352 */ 2353 QDF_STATUS wmi_unified_phyerr_enable_cmd_send(wmi_unified_t wmi_handle); 2354 2355 /** 2356 * wmi_unified_phyerr_disable_cmd_send() - WMI phyerr disable cmd function 2357 * @wmi_handle: handle to WMI. 2358 * 2359 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2360 */ 2361 QDF_STATUS wmi_unified_phyerr_disable_cmd_send(wmi_unified_t wmi_handle); 2362 2363 /** 2364 * wmi_unified_smart_ant_enable_tx_feedback_cmd_send() - 2365 * WMI set tx antenna function 2366 * @wmi_handle: handle to WMI. 2367 * @param: pointer to hold antenna param 2368 * 2369 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2370 */ 2371 QDF_STATUS wmi_unified_smart_ant_enable_tx_feedback_cmd_send( 2372 wmi_unified_t wmi_handle, 2373 struct smart_ant_enable_tx_feedback_params *param); 2374 2375 #ifdef WLAN_IOT_SIM_SUPPORT 2376 /** 2377 * wmi_unified_simulation_test_cmd_send() - 2378 * WMI simulation test command 2379 * @wmi_handle: handle to WMI. 2380 * @param: pointer to hold simulation test param 2381 * 2382 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2383 */ 2384 QDF_STATUS wmi_unified_simulation_test_cmd_send(wmi_unified_t wmi_handle, 2385 struct simulation_test_params 2386 *param); 2387 #endif 2388 2389 /** 2390 * wmi_unified_vdev_spectral_configure_cmd_send() - 2391 * WMI set spectral config function 2392 * @wmi_handle: handle to WMI. 2393 * @param: pointer to hold spectral config param 2394 * 2395 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2396 */ 2397 QDF_STATUS wmi_unified_vdev_spectral_configure_cmd_send( 2398 wmi_unified_t wmi_handle, 2399 struct vdev_spectral_configure_params *param); 2400 2401 /** 2402 * wmi_unified_vdev_spectral_enable_cmd_send() - WMI enable spectral function 2403 * @wmi_handle: handle to WMI. 2404 * @param: pointer to hold enable spectral param 2405 * 2406 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2407 */ 2408 QDF_STATUS wmi_unified_vdev_spectral_enable_cmd_send( 2409 wmi_unified_t wmi_handle, 2410 struct vdev_spectral_enable_params *param); 2411 2412 #ifdef WLAN_CONV_SPECTRAL_ENABLE 2413 /** 2414 * wmi_extract_pdev_sscan_fw_cmd_fixed_param() - Extract fixed params 2415 * from start scan response event 2416 * @wmi_handle: handle to WMI. 2417 * @evt_buf: Event buffer 2418 * @param: pointer to hold fixed params from fw params event 2419 * 2420 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2421 */ 2422 QDF_STATUS wmi_extract_pdev_sscan_fw_cmd_fixed_param( 2423 wmi_unified_t wmi_handle, 2424 uint8_t *evt_buf, 2425 struct spectral_startscan_resp_params *param); 2426 2427 /** 2428 * wmi_extract_pdev_sscan_fft_bin_index() - Extract FFT bin indexes 2429 * from start scan response event 2430 * @wmi_handle: handle to WMI. 2431 * @evt_buf: Event buffer 2432 * @param: pointer to hold FFT bin indexes from fw params event 2433 * 2434 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2435 */ 2436 QDF_STATUS wmi_extract_pdev_sscan_fft_bin_index( 2437 wmi_unified_t wmi_handle, 2438 uint8_t *evt_buf, 2439 struct spectral_fft_bin_markers_160_165mhz *param); 2440 2441 /** 2442 * wmi_extract_pdev_spectral_session_chan_info() - Extract channel information 2443 * for a spectral scan session 2444 * @wmi_handle: handle to WMI. 2445 * @event: Event buffer 2446 * @chan_info: Spectral session channel information data structure to be filled 2447 * by this API 2448 * 2449 * Return: QDF_STATUS of operation 2450 */ 2451 QDF_STATUS wmi_extract_pdev_spectral_session_chan_info( 2452 wmi_unified_t wmi_handle, void *event, 2453 struct spectral_session_chan_info *chan_info); 2454 2455 /** 2456 * wmi_extract_pdev_spectral_session_detector_info() - Extract detector 2457 * information for a spectral scan session 2458 * @wmi_handle: handle to WMI. 2459 * @event: Event buffer 2460 * @det_info: Spectral session detector information data structure to be filled 2461 * by this API 2462 * @det_info_idx: index in the array of spectral scan detector info TLVs 2463 * 2464 * Return: QDF_STATUS of operation 2465 */ 2466 QDF_STATUS wmi_extract_pdev_spectral_session_detector_info( 2467 wmi_unified_t wmi_handle, void *event, 2468 struct spectral_session_det_info *det_info, 2469 uint8_t det_info_idx); 2470 2471 /** 2472 * wmi_extract_spectral_caps_fixed_param() - Extract fixed params from Spectral 2473 * capabilities WMI event 2474 * @wmi_handle: handle to WMI. 2475 * @event: Event buffer 2476 * @param: Spectral capabilities event parameters data structure to be filled 2477 * by this API 2478 * 2479 * Return: QDF_STATUS of operation 2480 */ 2481 QDF_STATUS wmi_extract_spectral_caps_fixed_param( 2482 wmi_unified_t wmi_handle, void *event, 2483 struct spectral_capabilities_event_params *param); 2484 2485 /** 2486 * wmi_extract_spectral_scan_bw_caps() - Extract bandwidth caps from 2487 * Spectral capabilities WMI event 2488 * @wmi_handle: handle to WMI. 2489 * @event: Event buffer 2490 * @bw_caps: Data structure to be populated by this API after extraction 2491 * 2492 * Return: QDF_STATUS of operation 2493 */ 2494 QDF_STATUS wmi_extract_spectral_scan_bw_caps( 2495 wmi_unified_t wmi_handle, void *event, 2496 struct spectral_scan_bw_capabilities *bw_caps); 2497 2498 /** 2499 * wmi_extract_spectral_fft_size_caps() - Extract FFT size caps from 2500 * Spectral capabilities WMI event 2501 * @wmi_handle: handle to WMI. 2502 * @event: Event buffer 2503 * @fft_size_caps: Data structure to be populated by this API after extraction 2504 * 2505 * Return: QDF_STATUS of operation 2506 */ 2507 QDF_STATUS wmi_extract_spectral_fft_size_caps( 2508 wmi_unified_t wmi_handle, void *event, 2509 struct spectral_fft_size_capabilities *fft_size_caps); 2510 #endif /* WLAN_CONV_SPECTRAL_ENABLE */ 2511 2512 #if defined(WLAN_SUPPORT_FILS) || defined(CONFIG_BAND_6GHZ) 2513 /** 2514 * wmi_unified_vdev_fils_enable_cmd_send() - WMI send fils enable command 2515 * @wmi_handle: handle to WMI. 2516 * @param: fils enable parameters 2517 * 2518 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2519 */ 2520 QDF_STATUS 2521 wmi_unified_vdev_fils_enable_cmd_send(struct wmi_unified *wmi_handle, 2522 struct config_fils_params *param); 2523 #endif 2524 2525 /** 2526 * wmi_unified_bss_chan_info_request_cmd_send() - WMI bss chan info 2527 * request function 2528 * @wmi_handle: handle to WMI. 2529 * @param: pointer to hold chan info param 2530 * 2531 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2532 */ 2533 QDF_STATUS wmi_unified_bss_chan_info_request_cmd_send( 2534 wmi_unified_t wmi_handle, 2535 struct bss_chan_info_request_params *param); 2536 2537 /** 2538 * wmi_unified_thermal_mitigation_param_cmd_send() - 2539 * WMI thermal mitigation function 2540 * @wmi_handle: handle to WMI. 2541 * @param: pointer to hold thermal mitigation param 2542 * 2543 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2544 */ 2545 QDF_STATUS wmi_unified_thermal_mitigation_param_cmd_send( 2546 wmi_unified_t wmi_handle, 2547 struct thermal_mitigation_params *param); 2548 2549 /** 2550 * wmi_unified_vdev_set_fwtest_param_cmd_send() - WMI set fwtest function 2551 * @wmi_handle: handle to WMI. 2552 * @param: pointer to hold fwtest param 2553 * 2554 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2555 */ 2556 QDF_STATUS wmi_unified_vdev_set_fwtest_param_cmd_send( 2557 wmi_unified_t wmi_handle, 2558 struct set_fwtest_params *param); 2559 2560 /** 2561 * wmi_unified_vdev_set_custom_aggr_size_cmd_send() - WMI set custom aggr 2562 * size command 2563 * @wmi_handle: handle to WMI. 2564 * @param: pointer to hold custom aggr size param 2565 * 2566 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2567 */ 2568 QDF_STATUS wmi_unified_vdev_set_custom_aggr_size_cmd_send( 2569 wmi_unified_t wmi_handle, 2570 struct set_custom_aggr_size_params *param); 2571 2572 /** 2573 * wmi_unified_vdev_set_qdepth_thresh_cmd_send() - WMI set qdepth threshold 2574 * @wmi_handle: handle to WMI. 2575 * @param: pointer to hold set qdepth thresh param 2576 * 2577 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2578 */ 2579 QDF_STATUS wmi_unified_vdev_set_qdepth_thresh_cmd_send( 2580 wmi_unified_t wmi_handle, 2581 struct set_qdepth_thresh_params *param); 2582 2583 #ifdef WLAN_REG_PARTIAL_OFFLOAD 2584 /** 2585 * wmi_unified_pdev_set_regdomain_cmd_send() - WMI set regdomain function 2586 * @wmi_handle: handle to WMI. 2587 * @param: pointer to hold regdomain param 2588 * 2589 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2590 */ 2591 QDF_STATUS wmi_unified_pdev_set_regdomain_cmd_send( 2592 wmi_unified_t wmi_handle, 2593 struct pdev_set_regdomain_params *param); 2594 #endif 2595 2596 /** 2597 * wmi_unified_set_beacon_filter_cmd_send() - WMI set beacon filter function 2598 * @wmi_handle: handle to WMI. 2599 * @param: pointer to hold beacon filter param 2600 * 2601 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2602 */ 2603 QDF_STATUS wmi_unified_set_beacon_filter_cmd_send( 2604 wmi_unified_t wmi_handle, 2605 struct set_beacon_filter_params *param); 2606 2607 /** 2608 * wmi_unified_remove_beacon_filter_cmd_send() - WMI set beacon filter function 2609 * @wmi_handle: handle to WMI. 2610 * @param: pointer to hold beacon filter param 2611 * 2612 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2613 */ 2614 QDF_STATUS wmi_unified_remove_beacon_filter_cmd_send( 2615 wmi_unified_t wmi_handle, 2616 struct remove_beacon_filter_params *param); 2617 2618 /** 2619 * wmi_unified_addba_clearresponse_cmd_send() - WMI addba resp cmd function 2620 * @wmi_handle: handle to WMI. 2621 * @macaddr: MAC address 2622 * @param: pointer to hold addba resp parameter 2623 * 2624 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2625 */ 2626 QDF_STATUS wmi_unified_addba_clearresponse_cmd_send( 2627 wmi_unified_t wmi_handle, 2628 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2629 struct addba_clearresponse_params *param); 2630 2631 /** 2632 * wmi_unified_addba_send_cmd_send() - WMI addba send function 2633 * @wmi_handle: handle to WMI. 2634 * @macaddr: MAC address 2635 * @param: pointer to hold addba parameter 2636 * 2637 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2638 */ 2639 QDF_STATUS 2640 wmi_unified_addba_send_cmd_send(wmi_unified_t wmi_handle, 2641 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2642 struct addba_send_params *param); 2643 2644 /** 2645 * wmi_unified_delba_send_cmd_send() - WMI delba cmd function 2646 * @wmi_handle: handle to WMI. 2647 * @macaddr: MAC address 2648 * @param: pointer to hold delba parameter 2649 * 2650 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2651 */ 2652 QDF_STATUS 2653 wmi_unified_delba_send_cmd_send(wmi_unified_t wmi_handle, 2654 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2655 struct delba_send_params *param); 2656 2657 /** 2658 * wmi_unified_addba_setresponse_cmd_send() - WMI addba set resp cmd function 2659 * @wmi_handle: handle to WMI. 2660 * @macaddr: MAC address 2661 * @param: pointer to hold addba set resp parameter 2662 * 2663 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2664 */ 2665 QDF_STATUS 2666 wmi_unified_addba_setresponse_cmd_send(wmi_unified_t wmi_handle, 2667 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2668 struct addba_setresponse_params *param); 2669 2670 /** 2671 * wmi_unified_singleamsdu_cmd_send() - WMI singleamsdu function 2672 * @wmi_handle: handle to WMI. 2673 * @macaddr: MAC address 2674 * @param: pointer to hold singleamsdu parameter 2675 * 2676 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2677 */ 2678 QDF_STATUS 2679 wmi_unified_singleamsdu_cmd_send(wmi_unified_t wmi_handle, 2680 uint8_t macaddr[QDF_MAC_ADDR_SIZE], 2681 struct singleamsdu_params *param); 2682 2683 /** 2684 * wmi_unified_mu_scan_cmd_send() - WMI set mu scan function 2685 * @wmi_handle: handle to WMI. 2686 * @param: pointer to hold mu scan param 2687 * 2688 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2689 */ 2690 QDF_STATUS 2691 wmi_unified_mu_scan_cmd_send(wmi_unified_t wmi_handle, 2692 struct mu_scan_params *param); 2693 2694 /** 2695 * wmi_unified_lteu_config_cmd_send() - WMI set mu scan function 2696 * @wmi_handle: handle to WMI. 2697 * @param: pointer to hold mu scan param 2698 * 2699 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2700 */ 2701 QDF_STATUS 2702 wmi_unified_lteu_config_cmd_send(wmi_unified_t wmi_handle, 2703 struct lteu_config_params *param); 2704 2705 /** 2706 * wmi_unified_set_psmode_cmd_send() - WMI set mu scan function 2707 * @wmi_handle: handle to WMI. 2708 * @param: pointer to hold mu scan param 2709 * 2710 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2711 */ 2712 QDF_STATUS 2713 wmi_unified_set_psmode_cmd_send(wmi_unified_t wmi_handle, 2714 struct set_ps_mode_params *param); 2715 2716 /** 2717 * wmi_unified_init_cmd_send() - send initialization cmd to fw 2718 * @wmi_handle: wmi handle 2719 * @param: pointer to wmi init param 2720 * 2721 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2722 */ 2723 QDF_STATUS 2724 wmi_unified_init_cmd_send(wmi_unified_t wmi_handle, 2725 struct wmi_init_cmd_param *param); 2726 2727 /** 2728 * wmi_service_enabled() - Check if service enabled 2729 * @wmi_handle: wmi handle 2730 * @service_id: service identifier 2731 * 2732 * Return: 1 enabled, 0 disabled 2733 */ 2734 bool wmi_service_enabled(wmi_unified_t wmi_handle, uint32_t service_id); 2735 2736 /** 2737 * wmi_save_service_bitmap() - save service bitmap 2738 * @wmi_handle: wmi handle 2739 * @evt_buf: pointer to event buffer 2740 * @bitmap_buf: bitmap buffer 2741 * 2742 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS failure code 2743 */ 2744 QDF_STATUS wmi_save_service_bitmap(wmi_unified_t wmi_handle, void *evt_buf, 2745 void *bitmap_buf); 2746 2747 /** 2748 * wmi_save_ext_service_bitmap() - save extended service bitmap 2749 * @wmi_handle: wmi handle 2750 * @bitmap_buf: pointer to event buffer 2751 * @evt_buf: pointer to event buffer 2752 * 2753 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS failure code 2754 */ 2755 QDF_STATUS wmi_save_ext_service_bitmap(wmi_unified_t wmi_handle, void *evt_buf, 2756 void *bitmap_buf); 2757 2758 /** 2759 * wmi_save_fw_version() - Save fw version 2760 * @wmi_handle: wmi handle 2761 * @evt_buf: pointer to event buffer 2762 * 2763 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2764 */ 2765 QDF_STATUS wmi_save_fw_version(wmi_unified_t wmi_handle, void *evt_buf); 2766 2767 /** 2768 * wmi_get_target_cap_from_service_ready() - extract service ready event 2769 * @wmi_handle: wmi handle 2770 * @evt_buf: pointer to received event buffer 2771 * @ev: pointer to hold target capability information extracted from even 2772 * 2773 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2774 */ 2775 QDF_STATUS wmi_get_target_cap_from_service_ready( 2776 wmi_unified_t wmi_handle, void *evt_buf, 2777 struct wlan_psoc_target_capability_info *ev); 2778 2779 /** 2780 * wmi_extract_hal_reg_cap() - extract HAL registered capabilities 2781 * @wmi_handle: wmi handle 2782 * @evt_buf: Pointer to event buffer 2783 * @hal_reg_cap: pointer to hold HAL reg capabilities 2784 * 2785 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2786 */ 2787 QDF_STATUS 2788 wmi_extract_hal_reg_cap(wmi_unified_t wmi_handle, void *evt_buf, 2789 struct wlan_psoc_hal_reg_capability *hal_reg_cap); 2790 2791 /** 2792 * wmi_extract_hal_reg_cap_ext2() - Extract HAL reg capabilities from service 2793 * ready ext2 event 2794 * @wmi_handle: wmi handle 2795 * @evt_buf: Pointer to event buffer 2796 * @phy_idx: Phy id 2797 * @hal_reg_cap: pointer to hold HAL reg capabilities ext2 structure 2798 * 2799 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2800 */ 2801 QDF_STATUS 2802 wmi_extract_hal_reg_cap_ext2( 2803 wmi_unified_t wmi_handle, void *evt_buf, uint8_t phy_idx, 2804 struct wlan_psoc_host_hal_reg_capabilities_ext2 *hal_reg_cap); 2805 2806 /** 2807 * wmi_extract_num_mem_reqs_from_service_ready() - Extract number of memory 2808 * entries requested 2809 * @wmi_handle: wmi handle 2810 * @evt_buf: pointer to event buffer 2811 * 2812 * Return: Number of entries requested 2813 */ 2814 uint32_t wmi_extract_num_mem_reqs_from_service_ready( 2815 wmi_unified_t wmi_handle, 2816 void *evt_buf); 2817 2818 /** 2819 * wmi_extract_host_mem_req_from_service_ready() - Extract host memory 2820 * request event 2821 * @wmi_handle: wmi handle 2822 * @evt_buf: pointer to event buffer 2823 * @mem_reqs: pointer to host memory request structure 2824 * @num_active_peers: number of active peers for peer cache 2825 * @num_peers: number of peers 2826 * @fw_prio: FW priority 2827 * @idx: Index for memory request 2828 * 2829 * Return: Host memory request parameters requested by target 2830 */ 2831 QDF_STATUS wmi_extract_host_mem_req_from_service_ready( 2832 wmi_unified_t wmi_handle, void *evt_buf, host_mem_req *mem_reqs, 2833 uint32_t num_active_peers, uint32_t num_peers, 2834 enum wmi_fw_mem_prio fw_prio, uint16_t idx); 2835 2836 /** 2837 * wmi_ready_extract_init_status() - Extract init status from ready event 2838 * @wmi_handle: wmi handle 2839 * @ev: Pointer to event buffer 2840 * 2841 * Return: ready status 2842 */ 2843 uint32_t wmi_ready_extract_init_status(wmi_unified_t wmi_handle, void *ev); 2844 2845 /** 2846 * wmi_ready_extract_mac_addr() - extract mac address from ready event 2847 * @wmi_handle: wmi handle 2848 * @ev: pointer to event buffer 2849 * @macaddr: Pointer to hold MAC address 2850 * 2851 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2852 */ 2853 QDF_STATUS wmi_ready_extract_mac_addr(wmi_unified_t wmi_handle, 2854 void *ev, uint8_t *macaddr); 2855 2856 /** 2857 * wmi_ready_extract_mac_addr_list() - extract MAC address list from ready event 2858 * @wmi_handle: wmi handle 2859 * @ev: pointer to event buffer 2860 * @num_mac_addr: Pointer to number of entries 2861 * 2862 * Return: address to start of mac addr list 2863 */ 2864 wmi_host_mac_addr 2865 *wmi_ready_extract_mac_addr_list(wmi_unified_t wmi_handle, void *ev, 2866 uint8_t *num_mac_addr); 2867 2868 /** 2869 * wmi_extract_ready_event_params() - Extract data from ready event apart from 2870 * status, macaddr and version. 2871 * @wmi_handle: Pointer to WMI handle. 2872 * @evt_buf: Pointer to Ready event buffer. 2873 * @ev_param: Pointer to host defined struct to copy the data from event. 2874 * 2875 * Return: QDF_STATUS_SUCCESS on success. 2876 */ 2877 QDF_STATUS wmi_extract_ready_event_params( 2878 wmi_unified_t wmi_handle, void *evt_buf, 2879 struct wmi_host_ready_ev_param *ev_param); 2880 2881 /** 2882 * wmi_extract_fw_version() - extract fw version 2883 * @wmi_handle: wmi handle 2884 * @ev: pointer to event buffer 2885 * @fw_ver: Pointer to hold fw version 2886 * 2887 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2888 */ 2889 QDF_STATUS wmi_extract_fw_version(wmi_unified_t wmi_handle, void *ev, 2890 struct wmi_host_fw_ver *fw_ver); 2891 2892 /** 2893 * wmi_extract_fw_abi_version() - extract fw abi version 2894 * @wmi_handle: wmi handle 2895 * @ev: Pointer to event buffer 2896 * @fw_ver: Pointer to hold fw abi version 2897 * 2898 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2899 */ 2900 QDF_STATUS wmi_extract_fw_abi_version(wmi_unified_t wmi_handle, void *ev, 2901 struct wmi_host_fw_abi_ver *fw_ver); 2902 2903 /** 2904 * wmi_check_and_update_fw_version() - Ready and fw version check 2905 * @wmi_handle: wmi handle 2906 * @ev: pointer to event buffer 2907 * 2908 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2909 */ 2910 QDF_STATUS wmi_check_and_update_fw_version(wmi_unified_t wmi_handle, void *ev); 2911 2912 /** 2913 * wmi_extract_dbglog_data_len() - extract debuglog data length 2914 * @wmi_handle: wmi handle 2915 * @evt_b: pointer to event buffer 2916 * @len: length of buffer 2917 * 2918 * Return: length 2919 */ 2920 uint8_t *wmi_extract_dbglog_data_len(wmi_unified_t wmi_handle, 2921 void *evt_b, uint32_t *len); 2922 2923 /** 2924 * wmi_send_ext_resource_config() - send extended resource configuration 2925 * @wmi_handle: wmi handle 2926 * @ext_cfg: pointer to extended resource configuration 2927 * 2928 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2929 */ 2930 QDF_STATUS wmi_send_ext_resource_config(wmi_unified_t wmi_handle, 2931 wmi_host_ext_resource_config *ext_cfg); 2932 2933 /** 2934 * wmi_unified_rtt_meas_req_test_cmd_send() - WMI rtt meas req test function 2935 * @wmi_handle: handle to WMI. 2936 * @param: pointer to hold rtt meas req test param 2937 * 2938 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2939 */ 2940 QDF_STATUS 2941 wmi_unified_rtt_meas_req_test_cmd_send(wmi_unified_t wmi_handle, 2942 struct rtt_meas_req_test_params *param); 2943 2944 /** 2945 * wmi_unified_rtt_meas_req_cmd_send() - WMI rtt meas req function 2946 * @wmi_handle: handle to WMI. 2947 * @param: pointer to hold rtt meas req param 2948 * 2949 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2950 */ 2951 QDF_STATUS 2952 wmi_unified_rtt_meas_req_cmd_send(wmi_unified_t wmi_handle, 2953 struct rtt_meas_req_params *param); 2954 2955 /** 2956 * wmi_unified_rtt_keepalive_req_cmd_send() - WMI rtt meas req test function 2957 * @wmi_handle: handle to WMI. 2958 * @param: pointer to hold rtt meas req test param 2959 * 2960 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2961 */ 2962 QDF_STATUS 2963 wmi_unified_rtt_keepalive_req_cmd_send(wmi_unified_t wmi_handle, 2964 struct rtt_keepalive_req_params *param); 2965 2966 /** 2967 * wmi_unified_lci_set_cmd_send() - WMI lci set function 2968 * @wmi_handle: handle to WMI. 2969 * @param: pointer to hold lci param 2970 * 2971 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2972 */ 2973 QDF_STATUS wmi_unified_lci_set_cmd_send(wmi_unified_t wmi_handle, 2974 struct lci_set_params *param); 2975 2976 /** 2977 * wmi_unified_lcr_set_cmd_send() - WMI lcr set function 2978 * @wmi_handle: handle to WMI. 2979 * @param: pointer to hold lcr param 2980 * 2981 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2982 */ 2983 QDF_STATUS wmi_unified_lcr_set_cmd_send(wmi_unified_t wmi_handle, 2984 struct lcr_set_params *param); 2985 2986 /** 2987 * wmi_unified_extract_pn() - extract pn event data 2988 * @wmi_hdl: wmi handle 2989 * @evt_buf: pointer to event buffer 2990 * @param: pointer to get pn event param 2991 * 2992 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2993 */ 2994 QDF_STATUS wmi_unified_extract_pn(wmi_unified_t wmi_hdl, void *evt_buf, 2995 struct wmi_host_get_pn_event *param); 2996 2997 /** 2998 * wmi_unified_extract_rxpn() - extract Rx PN event data 2999 * @wmi_hdl: wmi handle 3000 * @evt_buf: pointer to event buffer 3001 * @param: pointer to get Rx PN event param 3002 * 3003 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3004 */ 3005 QDF_STATUS wmi_unified_extract_rxpn(wmi_unified_t wmi_hdl, void *evt_buf, 3006 struct wmi_host_get_rxpn_event *param); 3007 3008 /** 3009 * wmi_unified_send_periodic_chan_stats_config_cmd() - send periodic chan 3010 * stats cmd to fw 3011 * @wmi_handle: wmi handle 3012 * @param: pointer to hold periodic chan stats param 3013 * 3014 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3015 */ 3016 QDF_STATUS wmi_unified_send_periodic_chan_stats_config_cmd( 3017 wmi_unified_t wmi_handle, 3018 struct periodic_chan_stats_params *param); 3019 3020 /* Extract APIs */ 3021 3022 /** 3023 * wmi_extract_fips_event_data() - extract fips event data 3024 * @wmi_handle: wmi handle 3025 * @evt_buf: pointer to event buffer 3026 * @param: pointer to FIPS event param 3027 * 3028 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3029 */ 3030 QDF_STATUS 3031 wmi_extract_fips_event_data(wmi_unified_t wmi_handle, void *evt_buf, 3032 struct wmi_host_fips_event_param *param); 3033 3034 #ifdef WLAN_FEATURE_DISA 3035 /** 3036 * wmi_extract_encrypt_decrypt_resp_params() - 3037 * extract encrypt decrypt resp params from event buffer 3038 * @wmi_hdl: wmi handle 3039 * @evt_buf: pointer to event buffer 3040 * @param: encrypt decrypt resp params 3041 * 3042 * Return: QDF_STATUS_SUCCESS for success or error code 3043 */ 3044 QDF_STATUS 3045 wmi_extract_encrypt_decrypt_resp_params(void *wmi_hdl, void *evt_buf, 3046 struct disa_encrypt_decrypt_resp_params 3047 *param); 3048 #endif /* WLAN_FEATURE_DISA */ 3049 3050 /** 3051 * wmi_extract_mgmt_rx_params() - extract management rx params from event 3052 * @wmi_handle: wmi handle 3053 * @evt_buf: pointer to event buffer 3054 * @hdr: Pointer to hold header 3055 * @bufp: Pointer to hold pointer to rx param buffer 3056 * 3057 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3058 */ 3059 QDF_STATUS 3060 wmi_extract_mgmt_rx_params(wmi_unified_t wmi_handle, void *evt_buf, 3061 struct mgmt_rx_event_params *hdr, uint8_t **bufp); 3062 3063 /** 3064 * wmi_extract_mgmt_rx_ext_params() - extract extended rx params from event 3065 * @wmi_handle: wmi handle 3066 * @evt_buf: pointer to event buffer 3067 * @params: Pointer to hold ext params 3068 * 3069 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3070 */ 3071 QDF_STATUS 3072 wmi_extract_mgmt_rx_ext_params(wmi_unified_t wmi_handle, void *evt_buf, 3073 struct mgmt_rx_event_ext_params *params); 3074 3075 #ifdef WLAN_MGMT_RX_REO_SUPPORT 3076 /** 3077 * wmi_extract_mgmt_rx_fw_consumed() - extract MGMT Rx FW consumed event 3078 * @wmi_handle: wmi handle 3079 * @evt_buf: pointer to event buffer 3080 * @params: Pointer to MGMT Rx REO parameters 3081 * 3082 * Return: QDF_STATUS_SUCCESS for success or error code 3083 */ 3084 QDF_STATUS 3085 wmi_extract_mgmt_rx_fw_consumed(wmi_unified_t wmi_handle, void *evt_buf, 3086 struct mgmt_rx_reo_params *params); 3087 3088 /** 3089 * wmi_extract_mgmt_rx_reo_params() - extract MGMT Rx REO params from 3090 * MGMT_RX_EVENT_ID 3091 * @wmi_handle: wmi handle 3092 * @evt_buf: pointer to event buffer 3093 * @params: Pointer to MGMT Rx REO parameters 3094 * 3095 * Return: QDF_STATUS_SUCCESS for success or error code 3096 */ 3097 QDF_STATUS 3098 wmi_extract_mgmt_rx_reo_params(wmi_unified_t wmi_handle, void *evt_buf, 3099 struct mgmt_rx_reo_params *params); 3100 3101 /** 3102 * wmi_unified_mgmt_rx_reo_filter_config_cmd() - Send MGMT Rx REO filter 3103 * configuration command 3104 * @wmi_handle: wmi handle 3105 * @pdev_id: pdev ID of the radio 3106 * @filter: Pointer to MGMT Rx REO filter 3107 * 3108 * Return: QDF_STATUS_SUCCESS for success or error code 3109 */ 3110 QDF_STATUS wmi_unified_mgmt_rx_reo_filter_config_cmd( 3111 wmi_unified_t wmi_handle, 3112 uint8_t pdev_id, 3113 struct mgmt_rx_reo_filter *filter); 3114 #endif 3115 3116 /** 3117 * wmi_extract_frame_pn_params() - extract PN params from event 3118 * @wmi_handle: wmi handle 3119 * @evt_buf: pointer to event buffer 3120 * @pn_params: Pointer to Frame PN params 3121 * 3122 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3123 */ 3124 QDF_STATUS 3125 wmi_extract_frame_pn_params(wmi_unified_t wmi_handle, void *evt_buf, 3126 struct frame_pn_params *pn_params); 3127 3128 /** 3129 * wmi_extract_is_conn_ap_frame() - extract is_conn_ap_frame param from event 3130 * @wmi_handle: wmi handle 3131 * @evt_buf: pointer to event buffer 3132 * @is_conn_ap: is_conn_ap param 3133 * 3134 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3135 */ 3136 QDF_STATUS 3137 wmi_extract_is_conn_ap_frame(wmi_unified_t wmi_handle, void *evt_buf, 3138 struct frm_conn_ap *is_conn_ap); 3139 3140 /** 3141 * wmi_extract_vdev_roam_param() - extract vdev roam param from event 3142 * @wmi_handle: wmi handle 3143 * @evt_buf: pointer to event buffer 3144 * @ev: Pointer to hold roam param 3145 * 3146 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3147 */ 3148 QDF_STATUS 3149 wmi_extract_vdev_roam_param(wmi_unified_t wmi_handle, void *evt_buf, 3150 wmi_host_roam_event *ev); 3151 3152 /** 3153 * wmi_extract_vdev_scan_ev_param() - extract vdev scan param from event 3154 * @wmi_handle: wmi handle 3155 * @evt_buf: pointer to event buffer 3156 * @param: Pointer to hold vdev scan param 3157 * 3158 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3159 */ 3160 QDF_STATUS 3161 wmi_extract_vdev_scan_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3162 struct scan_event *param); 3163 3164 #ifdef FEATURE_WLAN_SCAN_PNO 3165 /** 3166 * wmi_extract_nlo_match_ev_param() - extract NLO match param from event 3167 * @wmi_handle: pointer to WMI handle 3168 * @evt_buf: pointer to WMI event buffer 3169 * @param: pointer to scan event param for NLO match 3170 * 3171 * Return: QDF_STATUS_SUCCESS for success or error code 3172 */ 3173 QDF_STATUS 3174 wmi_extract_nlo_match_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3175 struct scan_event *param); 3176 3177 /** 3178 * wmi_extract_nlo_complete_ev_param() - extract NLO complete param from event 3179 * @wmi_handle: pointer to WMI handle 3180 * @evt_buf: pointer to WMI event buffer 3181 * @param: pointer to scan event param for NLO complete 3182 * 3183 * Return: QDF_STATUS_SUCCESS for success or error code 3184 */ 3185 QDF_STATUS 3186 wmi_extract_nlo_complete_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3187 struct scan_event *param); 3188 #endif 3189 3190 /** 3191 * wmi_extract_mu_ev_param() - extract mu param from event 3192 * @wmi_handle: wmi handle 3193 * @evt_buf: pointer to event buffer 3194 * @param: Pointer to hold mu report 3195 * 3196 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3197 */ 3198 QDF_STATUS 3199 wmi_extract_mu_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3200 wmi_host_mu_report_event *param); 3201 3202 /** 3203 * wmi_extract_mu_db_entry() - extract mu db entry from event 3204 * @wmi_handle: wmi handle 3205 * @evt_buf: pointer to event buffer 3206 * @idx: index 3207 * @param: Pointer to hold mu db entry 3208 * 3209 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3210 */ 3211 QDF_STATUS 3212 wmi_extract_mu_db_entry(wmi_unified_t wmi_handle, void *evt_buf, 3213 uint8_t idx, wmi_host_mu_db_entry *param); 3214 3215 /** 3216 * wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event 3217 * @wmi_handle: wmi handle 3218 * @evt_buf: pointer to event buffer 3219 * @param: Pointer to hold mumimo tx count 3220 * 3221 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3222 */ 3223 QDF_STATUS 3224 wmi_extract_mumimo_tx_count_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3225 wmi_host_peer_txmu_cnt_event *param); 3226 3227 /** 3228 * wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list 3229 * from event 3230 * @wmi_handle: wmi handle 3231 * @evt_buf: pointer to event buffer 3232 * @param: Pointer to hold peer gid userposition list 3233 * 3234 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3235 */ 3236 QDF_STATUS 3237 wmi_extract_peer_gid_userpos_list_ev_param( 3238 wmi_unified_t wmi_handle, 3239 void *evt_buf, 3240 wmi_host_peer_gid_userpos_list_event *param); 3241 3242 /** 3243 * wmi_extract_esp_estimate_ev_param() - extract air time from event 3244 * @wmi_handle: wmi handle 3245 * @evt_buf: pointer to event buffer 3246 * @param: Pointer to hold esp event 3247 * 3248 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3249 */ 3250 QDF_STATUS 3251 wmi_extract_esp_estimate_ev_param(wmi_unified_t wmi_handle, void *evt_buf, 3252 struct esp_estimation_event *param); 3253 3254 /** 3255 * wmi_extract_gpio_input_ev_param() - extract gpio input param from event 3256 * @wmi_handle: wmi handle 3257 * @evt_buf: pointer to event buffer 3258 * @gpio_num: Pointer to hold gpio number 3259 * 3260 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3261 */ 3262 QDF_STATUS wmi_extract_gpio_input_ev_param(wmi_unified_t wmi_handle, 3263 void *evt_buf, uint32_t *gpio_num); 3264 3265 /** 3266 * wmi_extract_pdev_reserve_ast_ev_param() - extract reserve ast entry 3267 * param from event 3268 * @wmi_handle: wmi handle 3269 * @evt_buf: pointer to event buffer 3270 * @param: Pointer to hold reserve ast entry param 3271 * 3272 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3273 */ 3274 QDF_STATUS wmi_extract_pdev_reserve_ast_ev_param( 3275 wmi_unified_t wmi_handle, void *evt_buf, 3276 struct wmi_host_proxy_ast_reserve_param *param); 3277 /** 3278 * wmi_extract_pdev_generic_buffer_ev_param() - extract pdev generic buffer 3279 * from event 3280 * @wmi_handle: wmi handle 3281 * @evt_buf: pointer to event buffer 3282 * @param: Pointer to generic buffer param 3283 * 3284 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3285 */ 3286 QDF_STATUS wmi_extract_pdev_generic_buffer_ev_param( 3287 wmi_unified_t wmi_handle, void *evt_buf, 3288 wmi_host_pdev_generic_buffer_event *param); 3289 3290 /** 3291 * wmi_extract_peer_ratecode_list_ev() - extract peer ratecode from event 3292 * @wmi_handle: wmi handle 3293 * @evt_buf: pointer to event buffer 3294 * @peer_mac: Pointer to hold peer mac address 3295 * @pdev_id: Pointer to hold pdev_id 3296 * @rate_cap: Pointer to hold ratecode 3297 * 3298 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3299 */ 3300 QDF_STATUS wmi_extract_peer_ratecode_list_ev( 3301 wmi_unified_t wmi_handle, void *evt_buf, 3302 uint8_t *peer_mac, uint32_t *pdev_id, 3303 wmi_sa_rate_cap *rate_cap); 3304 3305 /** 3306 * wmi_extract_bcnflt_stats() - extract bcn fault stats from event 3307 * @wmi_handle: wmi handle 3308 * @evt_buf: pointer to event buffer 3309 * @index: Index into bcn fault stats 3310 * @bcnflt_stats: Pointer to hold bcn fault stats 3311 * 3312 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3313 */ 3314 QDF_STATUS wmi_extract_bcnflt_stats( 3315 wmi_unified_t wmi_handle, void *evt_buf, 3316 uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats); 3317 3318 /** 3319 * wmi_extract_rtt_hdr() - extract rtt header from event 3320 * @wmi_handle: wmi handle 3321 * @evt_buf: pointer to event buffer 3322 * @ev: Pointer to hold rtt header 3323 * 3324 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3325 */ 3326 QDF_STATUS wmi_extract_rtt_hdr(wmi_unified_t wmi_handle, void *evt_buf, 3327 wmi_host_rtt_event_hdr *ev); 3328 3329 /** 3330 * wmi_extract_rtt_ev() - extract rtt event 3331 * @wmi_handle: wmi handle 3332 * @evt_buf: Pointer to event buffer 3333 * @ev: Pointer to hold rtt event 3334 * @hdump: Pointer to hold hex dump 3335 * @hdump_len: hex dump length 3336 * 3337 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3338 */ 3339 QDF_STATUS wmi_extract_rtt_ev(wmi_unified_t wmi_handle, void *evt_buf, 3340 wmi_host_rtt_meas_event *ev, 3341 uint8_t *hdump, uint16_t hdump_len); 3342 3343 /** 3344 * wmi_extract_rtt_error_report_ev() - extract rtt error report from event 3345 * @wmi_handle: wmi handle 3346 * @evt_buf: pointer to event buffer 3347 * @ev: Pointer to hold rtt error report 3348 * 3349 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3350 */ 3351 QDF_STATUS 3352 wmi_extract_rtt_error_report_ev(wmi_unified_t wmi_handle, void *evt_buf, 3353 wmi_host_rtt_error_report_event *ev); 3354 3355 /** 3356 * wmi_extract_chan_stats() - extract chan stats from event 3357 * @wmi_handle: wmi handle 3358 * @evt_buf: pointer to event buffer 3359 * @index: Index into chan stats 3360 * @chan_stats: Pointer to hold chan stats 3361 * 3362 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3363 */ 3364 QDF_STATUS 3365 wmi_extract_chan_stats(wmi_unified_t wmi_handle, void *evt_buf, 3366 uint32_t index, wmi_host_chan_stats *chan_stats); 3367 3368 /** 3369 * wmi_extract_thermal_stats() - extract thermal stats from event 3370 * @wmi_handle: wmi handle 3371 * @evt_buf: Pointer to event buffer 3372 * @temp: Pointer to hold extracted temperature 3373 * @level: Pointer to hold extracted level in host enum 3374 * @therm_throt_levels: Pointer to hold extracted number of level in thermal 3375 * stats 3376 * @tt_stats: Pointer to hold extracted thermal stats for each level 3377 * @pdev_id: Pointer to hold extracted pdev_id 3378 * 3379 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3380 */ 3381 QDF_STATUS wmi_extract_thermal_stats(wmi_unified_t wmi_handle, void *evt_buf, 3382 uint32_t *temp, 3383 enum thermal_throttle_level *level, 3384 uint32_t *therm_throt_levels, 3385 struct thermal_throt_level_stats *tt_stats, 3386 uint32_t *pdev_id); 3387 3388 /** 3389 * wmi_extract_thermal_level_stats() - extract thermal level stats from 3390 * event 3391 * @wmi_handle: wmi handle 3392 * @evt_buf: pointer to event buffer 3393 * @idx: Index to level stats 3394 * @levelcount: Pointer to hold levelcount 3395 * @dccount: Pointer to hold dccount 3396 * 3397 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3398 */ 3399 QDF_STATUS 3400 wmi_extract_thermal_level_stats(wmi_unified_t wmi_handle, void *evt_buf, 3401 uint8_t idx, uint32_t *levelcount, 3402 uint32_t *dccount); 3403 3404 /** 3405 * wmi_extract_comb_phyerr() - extract comb phy error from event 3406 * @wmi_handle: wmi handle 3407 * @evt_buf: pointer to event buffer 3408 * @datalen: data length of event buffer 3409 * @buf_offset: Pointer to hold value of current event buffer offset 3410 * post extraction 3411 * @phyerr: Pointer to hold phyerr 3412 * 3413 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3414 */ 3415 QDF_STATUS 3416 wmi_extract_comb_phyerr(wmi_unified_t wmi_handle, void *evt_buf, 3417 uint16_t datalen, uint16_t *buf_offset, 3418 wmi_host_phyerr_t *phyerr); 3419 3420 /** 3421 * wmi_extract_single_phyerr() - extract single phy error from event 3422 * @wmi_handle: wmi handle 3423 * @evt_buf: pointer to event buffer 3424 * @datalen: data length of event buffer 3425 * @buf_offset: Pointer to hold value of current event buffer offset 3426 * post extraction 3427 * @phyerr: Pointer to hold phyerr 3428 * 3429 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3430 */ 3431 QDF_STATUS 3432 wmi_extract_single_phyerr(wmi_unified_t wmi_handle, void *evt_buf, 3433 uint16_t datalen, uint16_t *buf_offset, 3434 wmi_host_phyerr_t *phyerr); 3435 3436 /** 3437 * wmi_extract_composite_phyerr() - extract composite phy error from event 3438 * @wmi_handle: wmi handle 3439 * @evt_buf: pointer to event buffer 3440 * @datalen: Length of event buffer 3441 * @phyerr: Pointer to hold phy error 3442 * 3443 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3444 */ 3445 QDF_STATUS 3446 wmi_extract_composite_phyerr(wmi_unified_t wmi_handle, void *evt_buf, 3447 uint16_t datalen, wmi_host_phyerr_t *phyerr); 3448 3449 /** 3450 * wmi_extract_profile_ctx() - extract profile context from event 3451 * @wmi_handle: wmi handle 3452 * @evt_buf: pointer to event buffer 3453 * @profile_ctx: Pointer to hold profile context 3454 * 3455 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3456 */ 3457 QDF_STATUS 3458 wmi_extract_profile_ctx(wmi_unified_t wmi_handle, void *evt_buf, 3459 wmi_host_wlan_profile_ctx_t *profile_ctx); 3460 3461 /** 3462 * wmi_extract_profile_data() - extract profile data from event 3463 * @wmi_handle: wmi handle 3464 * @evt_buf: pointer to event buffer 3465 * @idx: index of profile data 3466 * @profile_data: Pointer to hold profile data 3467 * 3468 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3469 */ 3470 QDF_STATUS 3471 wmi_extract_profile_data(wmi_unified_t wmi_handle, void *evt_buf, uint8_t idx, 3472 wmi_host_wlan_profile_t *profile_data); 3473 3474 /** 3475 * wmi_extract_pmf_bcn_protect_stats() - extract pmf bcn stats from event 3476 * @wmi_handle: wmi handle 3477 * @evt_buf: pointer to event buffer 3478 * @bcn_stats: Pointer to hold pmf bcn protect stats 3479 * 3480 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3481 */ 3482 QDF_STATUS 3483 wmi_extract_pmf_bcn_protect_stats(wmi_unified_t wmi_handle, void *evt_buf, 3484 wmi_host_pmf_bcn_protect_stats *bcn_stats); 3485 3486 /** 3487 * wmi_extract_unit_test() - extract unit test from event 3488 * @wmi_handle: wmi handle 3489 * @evt_buf: pointer to event buffer 3490 * @unit_test: Pointer to hold unit-test header 3491 * @maxspace: The amount of space in evt_buf 3492 * 3493 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3494 */ 3495 QDF_STATUS 3496 wmi_extract_unit_test(wmi_unified_t wmi_handle, void *evt_buf, 3497 wmi_unit_test_event *unit_test, uint32_t maxspace); 3498 3499 /** 3500 * wmi_extract_pdev_ext_stats() - extract extended pdev stats from event 3501 * @wmi_handle: wmi handle 3502 * @evt_buf: pointer to event buffer 3503 * @index: Index into extended pdev stats 3504 * @pdev_ext_stats: Pointer to hold extended pdev stats 3505 * 3506 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3507 */ 3508 QDF_STATUS 3509 wmi_extract_pdev_ext_stats(wmi_unified_t wmi_handle, void *evt_buf, 3510 uint32_t index, 3511 wmi_host_pdev_ext_stats *pdev_ext_stats); 3512 3513 /** 3514 * wmi_extract_bss_chan_info_event() - extract bss channel information 3515 * from event 3516 * @wmi_handle: wmi handle 3517 * @evt_buf: pointer to event buffer 3518 * @bss_chan_info: Pointer to hold bss channel information 3519 * 3520 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3521 */ 3522 QDF_STATUS wmi_extract_bss_chan_info_event( 3523 wmi_unified_t wmi_handle, void *evt_buf, 3524 wmi_host_pdev_bss_chan_info_event *bss_chan_info); 3525 3526 /** 3527 * wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control 3528 * from event 3529 * @wmi_handle: wmi handle 3530 * @evt_buf: pointer to event buffer 3531 * @ev: Pointer to hold data traffic control 3532 * 3533 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3534 */ 3535 QDF_STATUS 3536 wmi_extract_tx_data_traffic_ctrl_ev(wmi_unified_t wmi_handle, void *evt_buf, 3537 wmi_host_tx_data_traffic_ctrl_event *ev); 3538 3539 /** 3540 * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event 3541 * @wmi_handle: wmi handle 3542 * @evt_buf: pointer to event buffer 3543 * @index: Index into extended vdev stats 3544 * @vdev_extd_stats: Pointer to hold extended vdev stats 3545 * 3546 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3547 */ 3548 QDF_STATUS 3549 wmi_extract_vdev_extd_stats(wmi_unified_t wmi_handle, void *evt_buf, 3550 uint32_t index, 3551 wmi_host_vdev_extd_stats *vdev_extd_stats); 3552 3553 /** 3554 * wmi_extract_bcn_stats() - extract beacon stats from event 3555 * @wmi_handle: wmi handle 3556 * @evt_buf: pointer to event buffer 3557 * @index: Index into beacon stats 3558 * @vdev_bcn_stats: Pointer to hold beacon stats 3559 * 3560 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3561 */ 3562 QDF_STATUS 3563 wmi_extract_bcn_stats(wmi_unified_t wmi_handle, void *evt_buf, 3564 uint32_t index, wmi_host_bcn_stats *vdev_bcn_stats); 3565 3566 /** 3567 * wmi_extract_vdev_nac_rssi_stats() - extract NAC_RSSI stats from event 3568 * @wmi_handle: wmi handle 3569 * @evt_buf: pointer to event buffer 3570 * @vdev_nac_rssi_stats: Pointer to hold nac rssi stats 3571 * 3572 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3573 */ 3574 QDF_STATUS wmi_extract_vdev_nac_rssi_stats( 3575 wmi_unified_t wmi_handle, void *evt_buf, 3576 struct wmi_host_vdev_nac_rssi_event *vdev_nac_rssi_stats); 3577 3578 /** 3579 * wmi_extract_vdev_prb_fils_stats() - extract probe and fils vdev 3580 * stats from event 3581 * @wmi_handle: wmi handle 3582 * @evt_buf: pointer to event buffer 3583 * @index: Index into extended vdev stats 3584 * @vdev_prb_fils_stats: Pointer to hold probe and fils vdev stats 3585 * 3586 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3587 */ 3588 QDF_STATUS wmi_extract_vdev_prb_fils_stats( 3589 wmi_unified_t wmi_handle, void *evt_buf, 3590 uint32_t index, 3591 struct wmi_host_vdev_prb_fils_stats *vdev_prb_fils_stats); 3592 3593 /** 3594 * wmi_extract_peer_retry_stats() - extract peer retry stats from event 3595 * @wmi_handle: wmi handle 3596 * @evt_buf: pointer to event buffer 3597 * @index: Index into peer retry stats 3598 * @peer_retry_stats: Pointer to hold peer retry stats 3599 * 3600 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3601 */ 3602 QDF_STATUS wmi_extract_peer_retry_stats( 3603 wmi_unified_t wmi_handle, void *evt_buf, 3604 uint32_t index, struct wmi_host_peer_retry_stats *peer_retry_stats); 3605 3606 /** 3607 * wmi_unified_send_power_dbg_cmd() - send power debug commands 3608 * @wmi_handle: wmi handle 3609 * @param: wmi power debug parameter 3610 * 3611 * Send WMI_POWER_DEBUG_CMDID parameters to fw. 3612 * 3613 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3614 */ 3615 QDF_STATUS wmi_unified_send_power_dbg_cmd(wmi_unified_t wmi_handle, 3616 struct wmi_power_dbg_params *param); 3617 3618 /** 3619 * wmi_extract_sar_cap_service_ready_ext() - extract SAR cap from 3620 * FW service ready event 3621 * @wmi_handle: wmi handle 3622 * @evt_buf: event buffer received from firmware 3623 * @ext_param: extended target info 3624 * 3625 * Return: QDF_STATUS_SUCCESS for success or error code 3626 */ 3627 QDF_STATUS wmi_extract_sar_cap_service_ready_ext( 3628 wmi_unified_t wmi_handle, 3629 uint8_t *evt_buf, 3630 struct wlan_psoc_host_service_ext_param *ext_param); 3631 3632 /** 3633 * wmi_unified_fw_test_cmd() - send fw test command to fw. 3634 * @wmi_handle: wmi handle 3635 * @wmi_fwtest: fw test command 3636 * 3637 * This function sends fw test command to fw. 3638 * 3639 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3640 */ 3641 QDF_STATUS wmi_unified_fw_test_cmd(wmi_unified_t wmi_handle, 3642 struct set_fwtest_params *wmi_fwtest); 3643 3644 /** 3645 * wmi_unified_wfa_test_cmd() - send wfa test command to fw. 3646 * @wmi_handle: wmi handle 3647 * @wmi_wfatest: wfa test param 3648 * 3649 * This function send wfa test command to fw. 3650 * 3651 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3652 */ 3653 QDF_STATUS wmi_unified_wfa_test_cmd(wmi_unified_t wmi_handle, 3654 struct set_wfatest_params *wmi_wfatest); 3655 3656 /** 3657 * wmi_unified_peer_rx_reorder_queue_setup_send() - send rx reorder queue 3658 * setup command to fw 3659 * @wmi_handle: wmi handle 3660 * @param: Rx reorder queue setup parameters 3661 * 3662 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 3663 */ 3664 QDF_STATUS wmi_unified_peer_rx_reorder_queue_setup_send( 3665 wmi_unified_t wmi_handle, 3666 struct rx_reorder_queue_setup_params *param); 3667 3668 /** 3669 * wmi_unified_peer_rx_reorder_queue_remove_send() - send rx reorder queue 3670 * remove command to fw 3671 * @wmi_handle: wmi handle 3672 * @param: Rx reorder queue remove parameters 3673 * 3674 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 3675 */ 3676 QDF_STATUS wmi_unified_peer_rx_reorder_queue_remove_send( 3677 wmi_unified_t wmi_handle, 3678 struct rx_reorder_queue_remove_params *param); 3679 3680 /** 3681 * wmi_extract_service_ready_ext() - extract extended service ready 3682 * @wmi_handle: wmi handle 3683 * @evt_buf: pointer to event buffer 3684 * @param: wmi power debug parameter 3685 * 3686 * 3687 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3688 */ 3689 QDF_STATUS wmi_extract_service_ready_ext( 3690 wmi_unified_t wmi_handle, uint8_t *evt_buf, 3691 struct wlan_psoc_host_service_ext_param *param); 3692 3693 /** 3694 * wmi_extract_service_ready_ext2() - extract extended2 service ready 3695 * @wmi_handle: wmi handle 3696 * @evt_buf: pointer to event buffer 3697 * @param: wmi ext2 base parameters 3698 * 3699 * 3700 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3701 */ 3702 QDF_STATUS wmi_extract_service_ready_ext2( 3703 struct wmi_unified *wmi_handle, uint8_t *evt_buf, 3704 struct wlan_psoc_host_service_ext2_param *param); 3705 3706 /** 3707 * wmi_extract_dbs_or_sbs_cap_service_ready_ext2() - extract dbs_or_sbs cap from 3708 * service ready ext 2 3709 * 3710 * @wmi_handle: wmi handle 3711 * @evt_buf: pointer to event buffer 3712 * @sbs_lower_band_end_freq: If sbs_lower_band_end_freq is set to non-zero, 3713 * it indicates async SBS mode is supported, and 3714 * lower-band/higher band to MAC mapping is 3715 * switch-able. unit: mhz. examples 5180, 5320 3716 * 3717 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3718 */ 3719 QDF_STATUS wmi_extract_dbs_or_sbs_cap_service_ready_ext2( 3720 wmi_unified_t wmi_handle, 3721 uint8_t *evt_buf, uint32_t *sbs_lower_band_end_freq); 3722 3723 /** 3724 * wmi_extract_hw_mode_cap_service_ready_ext() - 3725 * extract HW mode cap from service ready event 3726 * @wmi_handle: wmi handle 3727 * @evt_buf: pointer to event buffer 3728 * @hw_mode_idx: hw mode idx should be less than num_mode 3729 * @param: Pointer to hold evt buf 3730 * 3731 * Return: QDF_STATUS_SUCCESS for success or error code 3732 */ 3733 QDF_STATUS wmi_extract_hw_mode_cap_service_ready_ext( 3734 wmi_unified_t wmi_handle, 3735 uint8_t *evt_buf, uint8_t hw_mode_idx, 3736 struct wlan_psoc_host_hw_mode_caps *param); 3737 3738 /** 3739 * wmi_extract_mac_phy_cap_service_ready_ext() - 3740 * extract MAC phy cap from service ready event 3741 * @wmi_handle: wmi handle 3742 * @evt_buf: pointer to event buffer 3743 * @hw_mode_id: hw mode id of hw_mode_caps 3744 * @phy_id: phy_id within hw_mode_cap 3745 * @param: pointer to mac phy caps structure to hold the values from event 3746 * 3747 * Return: QDF_STATUS_SUCCESS for success or error code 3748 */ 3749 QDF_STATUS wmi_extract_mac_phy_cap_service_ready_ext( 3750 wmi_unified_t wmi_handle, 3751 uint8_t *evt_buf, 3752 uint8_t hw_mode_id, 3753 uint8_t phy_id, 3754 struct wlan_psoc_host_mac_phy_caps *param); 3755 3756 /** 3757 * wmi_extract_mac_phy_cap_service_ready_ext2() - Extract MAC phy cap from 3758 * service ready ext2 event. 3759 * @wmi_handle: wmi handle 3760 * @evt_buf: pointer to event buffer 3761 * @hw_mode_id: hw mode id of hw_mode_caps 3762 * @phy_id: phy_id within hw_mode_cap 3763 * @phy_idx: index to hw_mode_cap for the given hw_mode_id and phy_id 3764 * @mac_phy_cap: Pointer to mac_phy_cap_ext2 structure 3765 * 3766 * Return: QDF_STATUS_SUCCESS for success or error code 3767 */ 3768 QDF_STATUS wmi_extract_mac_phy_cap_service_ready_ext2( 3769 wmi_unified_t wmi_handle, 3770 uint8_t *evt_buf, 3771 uint8_t hw_mode_id, 3772 uint8_t phy_id, 3773 uint8_t phy_idx, 3774 struct wlan_psoc_host_mac_phy_caps_ext2 *mac_phy_cap); 3775 3776 /** 3777 * wmi_extract_reg_cap_service_ready_ext() - 3778 * extract REG cap from service ready event 3779 * @wmi_handle: wmi handle 3780 * @evt_buf: pointer to event buffer 3781 * @phy_idx: phy idx should be less than num_mode 3782 * @param: Pointer to hold evt buf 3783 * 3784 * Return: QDF_STATUS_SUCCESS for success or error code 3785 */ 3786 QDF_STATUS 3787 wmi_extract_reg_cap_service_ready_ext( 3788 wmi_unified_t wmi_handle, 3789 uint8_t *evt_buf, uint8_t phy_idx, 3790 struct wlan_psoc_host_hal_reg_capabilities_ext *param); 3791 3792 /** 3793 * wmi_extract_dbr_ring_cap_service_ready_ext: Extract direct buffer rx 3794 * capability received through 3795 * extended service ready event 3796 * @wmi_handle: WMI handle 3797 * @evt_buf: Event buffer 3798 * @idx: Index of the module for which capability is received 3799 * @param: Pointer to direct buffer rx ring cap struct 3800 * 3801 * Return: QDF status of operation 3802 */ 3803 QDF_STATUS wmi_extract_dbr_ring_cap_service_ready_ext( 3804 wmi_unified_t wmi_handle, 3805 uint8_t *evt_buf, uint8_t idx, 3806 struct wlan_psoc_host_dbr_ring_caps *param); 3807 3808 /** 3809 * wmi_extract_dbr_ring_cap_service_ready_ext2: Extract direct buffer rx 3810 * capability received through 3811 * extended service ready2 event 3812 * @wmi_handle: WMI handle 3813 * @evt_buf: Event buffer 3814 * @idx: Index of the module for which capability is received 3815 * @param: Pointer to direct buffer rx ring cap struct 3816 * 3817 * Return: QDF status of operation 3818 */ 3819 QDF_STATUS wmi_extract_dbr_ring_cap_service_ready_ext2( 3820 wmi_unified_t wmi_handle, 3821 uint8_t *evt_buf, uint8_t idx, 3822 struct wlan_psoc_host_dbr_ring_caps *param); 3823 3824 /** 3825 * wmi_extract_scan_radio_cap_service_ready_ext2: Extract scan radio capability 3826 * received through extended service ready2 event 3827 * @wmi_handle: WMI handle 3828 * @evt_buf: Event buffer 3829 * @idx: Index of the module for which capability is received 3830 * @param: Pointer to scan radio cap struct 3831 * 3832 * Return: QDF status of operation 3833 */ 3834 QDF_STATUS wmi_extract_scan_radio_cap_service_ready_ext2( 3835 wmi_unified_t wmi_handle, 3836 uint8_t *evt_buf, uint8_t idx, 3837 struct wlan_psoc_host_scan_radio_caps *param); 3838 3839 /** 3840 * wmi_extract_sw_cal_ver_ext2: Extract sw cal version received through 3841 * extended service ready2 event 3842 * @wmi_handle: WMI handle 3843 * @event: Event buffer 3844 * @cal: Pointer to sw cal ver struct 3845 * 3846 * Return: QDF status of operation 3847 */ 3848 QDF_STATUS wmi_extract_sw_cal_ver_ext2(wmi_unified_t wmi_handle, 3849 uint8_t *event, 3850 struct wmi_host_sw_cal_ver *cal); 3851 3852 /** 3853 * wmi_extract_spectral_scaling_params_service_ready_ext: Extract Spectral 3854 * scaling params received through 3855 * extended service ready event 3856 * @wmi_handle: WMI handle 3857 * @evt_buf: Event buffer 3858 * @idx: Index 3859 * @param: Pointer to Spectral scaling params 3860 * 3861 * Return: QDF status of operation 3862 */ 3863 QDF_STATUS wmi_extract_spectral_scaling_params_service_ready_ext( 3864 wmi_unified_t wmi_handle, 3865 uint8_t *evt_buf, uint8_t idx, 3866 struct wlan_psoc_host_spectral_scaling_params *param); 3867 3868 /** 3869 * wmi_extract_pdev_utf_event() - 3870 * extract UTF data from pdev utf event 3871 * @wmi_handle: wmi handle 3872 * @evt_buf: pointer to event buffer 3873 * @param: Pointer to hold evt buf 3874 * 3875 * Return: QDF_STATUS_SUCCESS for success or error code 3876 */ 3877 QDF_STATUS wmi_extract_pdev_utf_event(wmi_unified_t wmi_handle, 3878 uint8_t *evt_buf, 3879 struct wmi_host_pdev_utf_event *param); 3880 3881 /** 3882 * wmi_extract_pdev_qvit_event() - 3883 * extract UTF data from pdev qvit event 3884 * @wmi_handle: wmi handle 3885 * @evt_buf: pointer to event buffer 3886 * @param: Pointer to hold evt buf 3887 * 3888 * Return: QDF_STATUS_SUCCESS for success or error code 3889 */ 3890 QDF_STATUS wmi_extract_pdev_qvit_event(wmi_unified_t wmi_handle, 3891 uint8_t *evt_buf, 3892 struct wmi_host_pdev_qvit_event *param); 3893 3894 #ifdef WLAN_SUPPORT_RF_CHARACTERIZATION 3895 /** 3896 * wmi_extract_num_rf_characterization_entries - Extract number of RF 3897 * characterization metrics received from the RF characterization event. 3898 * @wmi_hdl: WMI handle 3899 * @evt_buf: Event buffer 3900 * @num_rf_characterization_entries: Number of RF characterization metrics 3901 * 3902 * Return: QDF status of operation 3903 */ 3904 QDF_STATUS wmi_extract_num_rf_characterization_entries(wmi_unified_t wmi_hdl, 3905 uint8_t *evt_buf, 3906 uint32_t *num_rf_characterization_entries); 3907 3908 /** 3909 * wmi_extract_rf_characterization_entries - Extract RF characterization 3910 * metrics received from the RF characterization event. 3911 * @wmi_hdl: WMI handle 3912 * @evt_buf: Event buffer 3913 * @num_rf_characterization_entries: Number of RF characterization metrics 3914 * @rf_characterization_entries: Pointer to RF characterization metrics 3915 * 3916 * Return: QDF status of operation 3917 */ 3918 QDF_STATUS wmi_extract_rf_characterization_entries(wmi_unified_t wmi_hdl, 3919 uint8_t *evt_buf, 3920 uint32_t num_rf_characterization_entries, 3921 struct wmi_host_rf_characterization_event_param *rf_characterization_entries); 3922 #endif 3923 3924 /** 3925 * wmi_extract_chainmask_tables() - extract chain mask tables 3926 * @wmi_handle: wmi handle 3927 * @evt_buf: pointer to event buffer. 3928 * @chainmask_table: pointer to struct wlan_psoc_host_chainmask_table 3929 * 3930 * 3931 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3932 */ 3933 QDF_STATUS wmi_extract_chainmask_tables( 3934 wmi_unified_t wmi_handle, uint8_t *evt_buf, 3935 struct wlan_psoc_host_chainmask_table *chainmask_table); 3936 3937 /** 3938 * wmi_unified_dfs_phyerr_offload_en_cmd() - enable dfs phyerr offload 3939 * @wmi_handle: wmi handle 3940 * @pdev_id: pdev id 3941 * 3942 * Return: QDF_STATUS 3943 */ 3944 QDF_STATUS wmi_unified_dfs_phyerr_offload_en_cmd(wmi_unified_t wmi_handle, 3945 uint32_t pdev_id); 3946 3947 /** 3948 * wmi_unified_dfs_phyerr_offload_dis_cmd() - disable dfs phyerr offload 3949 * @wmi_handle: wmi handle 3950 * @pdev_id: pdev id 3951 * 3952 * Return: QDF_STATUS 3953 */ 3954 QDF_STATUS wmi_unified_dfs_phyerr_offload_dis_cmd(wmi_unified_t wmi_handle, 3955 uint32_t pdev_id); 3956 3957 #ifdef QCA_SUPPORT_AGILE_DFS 3958 /** 3959 * wmi_unified_send_vdev_adfs_ch_cfg_cmd() - send adfs channel config command 3960 * @wmi_handle: wmi handle 3961 * @param: adfs channel config params 3962 * 3963 * Return: QDF_STATUS 3964 */ 3965 QDF_STATUS 3966 wmi_unified_send_vdev_adfs_ch_cfg_cmd(wmi_unified_t wmi_handle, 3967 struct vdev_adfs_ch_cfg_params *param); 3968 3969 /** 3970 * wmi_unified_send_vdev_adfs_ocac_abort_cmd() - send adfs o-cac abort command 3971 * @wmi_handle: wmi handle 3972 * @param: adfs channel o-cac abort params 3973 * 3974 * Return: QDF_STATUS 3975 */ 3976 QDF_STATUS 3977 wmi_unified_send_vdev_adfs_ocac_abort_cmd(wmi_unified_t wmi_handle, 3978 struct vdev_adfs_abort_params *param); 3979 #endif 3980 3981 /** 3982 * wmi_unified_set_country_cmd_send() - WMI set country function 3983 * @wmi_handle: handle to WMI. 3984 * @param: pointer to hold set country cmd parameter 3985 * 3986 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3987 */ 3988 QDF_STATUS wmi_unified_set_country_cmd_send(wmi_unified_t wmi_handle, 3989 struct set_country *param); 3990 3991 #ifdef WLAN_FEATURE_ACTION_OUI 3992 /** 3993 * wmi_unified_send_action_oui_cmd() - send action oui cmd to fw 3994 * @wmi_handle: wma handle 3995 * @req: wmi action oui message to be send 3996 * 3997 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3998 */ 3999 QDF_STATUS 4000 wmi_unified_send_action_oui_cmd(wmi_unified_t wmi_handle, 4001 struct action_oui_request *req); 4002 #endif /* WLAN_FEATURE_ACTION_OUI */ 4003 4004 /** 4005 * wmi_unified_send_request_get_rcpi_cmd() - command to request rcpi value 4006 * @wmi_handle: wma handle 4007 * @get_rcpi_param: rcpi params 4008 * 4009 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4010 */ 4011 QDF_STATUS 4012 wmi_unified_send_request_get_rcpi_cmd(wmi_unified_t wmi_handle, 4013 struct rcpi_req *get_rcpi_param); 4014 4015 /** 4016 * wmi_extract_rcpi_response_event - api to extract RCPI event params 4017 * @wmi_handle: wma handle 4018 * @evt_buf: pointer to event buffer 4019 * @res: pointer to hold rcpi response from firmware 4020 * 4021 * Return: QDF_STATUS_SUCCESS for successful event parse 4022 * else QDF_STATUS_E_INVAL or QDF_STATUS_E_FAILURE 4023 */ 4024 QDF_STATUS 4025 wmi_extract_rcpi_response_event(wmi_unified_t wmi_handle, void *evt_buf, 4026 struct rcpi_res *res); 4027 4028 #ifdef WMI_INTERFACE_EVENT_LOGGING 4029 void wmi_print_cmd_log(wmi_unified_t wmi, uint32_t count, 4030 qdf_abstract_print *print, void *print_priv); 4031 4032 void wmi_print_cmd_tx_cmp_log(wmi_unified_t wmi, uint32_t count, 4033 qdf_abstract_print *print, void *print_priv); 4034 4035 void wmi_print_mgmt_cmd_log(wmi_unified_t wmi, uint32_t count, 4036 qdf_abstract_print *print, void *print_priv); 4037 4038 void wmi_print_mgmt_cmd_tx_cmp_log(wmi_unified_t wmi, uint32_t count, 4039 qdf_abstract_print *print, void *print_priv); 4040 4041 void wmi_print_event_log(wmi_unified_t wmi, uint32_t count, 4042 qdf_abstract_print *print, void *print_priv); 4043 4044 void wmi_print_rx_event_log(wmi_unified_t wmi, uint32_t count, 4045 qdf_abstract_print *print, void *print_priv); 4046 4047 void wmi_print_mgmt_event_log(wmi_unified_t wmi, uint32_t count, 4048 qdf_abstract_print *print, void *print_priv); 4049 4050 #endif /* WMI_INTERFACE_EVENT_LOGGING */ 4051 4052 /** 4053 * wmi_unified_send_dump_wds_table_cmd() - WMI function to get list of 4054 * wds entries from FW 4055 * @wmi_handle: wmi handle 4056 * 4057 * Send WMI_PDEV_WDS_ENTRY_LIST_CMDID parameters to fw. 4058 * 4059 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 4060 */ 4061 QDF_STATUS wmi_unified_send_dump_wds_table_cmd(wmi_unified_t wmi_handle); 4062 4063 /** 4064 * wmi_extract_wds_entry - api to extract wds entry 4065 * @wmi_handle: wmi handle 4066 * @evt_buf: pointer to event buffer 4067 * @wds_entry: wds entry 4068 * @idx: index to point wds entry in event buffer 4069 * 4070 * Return: QDF_STATUS_SUCCESS for successful event parse 4071 * else QDF_STATUS_E_INVAL or QDF_STATUS_E_FAILURE 4072 */ 4073 QDF_STATUS 4074 wmi_extract_wds_entry(wmi_unified_t wmi_handle, uint8_t *evt_buf, 4075 struct wdsentry *wds_entry, u_int32_t idx); 4076 4077 /** 4078 * wmi_unified_send_obss_detection_cfg_cmd() - WMI function to send obss 4079 * detection configuration to FW. 4080 * @wmi_handle: wmi handle 4081 * @cfg: obss detection configuration 4082 * 4083 * Send WMI_SAP_OBSS_DETECTION_CFG_CMDID parameters to fw. 4084 * 4085 * Return: QDF_STATUS 4086 */ 4087 4088 QDF_STATUS wmi_unified_send_obss_detection_cfg_cmd( 4089 wmi_unified_t wmi_handle, 4090 struct wmi_obss_detection_cfg_param *cfg); 4091 4092 /** 4093 * wmi_unified_extract_obss_detection_info() - WMI function to extract obss 4094 * detection info from FW. 4095 * @wmi_handle: wmi handle 4096 * @data: event data from firmware 4097 * @info: Pointer to hold obss detection info 4098 * 4099 * This function is used to extract obss info from firmware. 4100 * 4101 * Return: QDF_STATUS 4102 */ 4103 4104 QDF_STATUS wmi_unified_extract_obss_detection_info( 4105 wmi_unified_t wmi_handle, 4106 uint8_t *data, 4107 struct wmi_obss_detect_info *info); 4108 4109 #ifdef WLAN_SUPPORT_GREEN_AP 4110 QDF_STATUS wmi_extract_green_ap_egap_status_info( 4111 wmi_unified_t wmi_hdl, uint8_t *evt_buf, 4112 struct wlan_green_ap_egap_status_info *egap_status_info_params); 4113 #endif 4114 4115 #ifdef WLAN_SUPPORT_GAP_LL_PS_MODE 4116 /** 4117 * wmi_unified_extract_green_ap_ll_ps_param() - API to extract Green AP low 4118 * latency power save event parameter 4119 * @wmi_handle: wmi handle 4120 * @evt_buf: pointer to the event buffer 4121 * @green_ap_ll_ps_event_param: Event parameter 4122 * 4123 * Return: QDF_STATUS 4124 */ 4125 QDF_STATUS wmi_unified_extract_green_ap_ll_ps_param( 4126 wmi_unified_t wmi_handle, uint8_t *evt_buf, 4127 struct wlan_green_ap_ll_ps_event_param *green_ap_ll_ps_event_param); 4128 #endif 4129 4130 /** 4131 * wmi_unified_send_roam_scan_stats_cmd() - Wrapper to request roam scan stats 4132 * @wmi_handle: wmi handle 4133 * @params: request params 4134 * 4135 * This function is used to send the roam scan stats request command to 4136 * firmware. 4137 * 4138 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4139 */ 4140 QDF_STATUS 4141 wmi_unified_send_roam_scan_stats_cmd(wmi_unified_t wmi_handle, 4142 struct wmi_roam_scan_stats_req *params); 4143 4144 /** 4145 * wmi_extract_roam_scan_stats_res_evt() - API to extract roam scan stats res 4146 * @wmi: wmi handle 4147 * @evt_buf: pointer to the event buffer 4148 * @vdev_id: output pointer to hold vdev id 4149 * @res_param: output pointer to hold extracted memory 4150 * 4151 * Return: QDF_STATUS 4152 */ 4153 QDF_STATUS 4154 wmi_extract_roam_scan_stats_res_evt(wmi_unified_t wmi, void *evt_buf, 4155 uint32_t *vdev_id, 4156 struct wmi_roam_scan_stats_res **res_param); 4157 4158 /** 4159 * wmi_extract_offload_bcn_tx_status_evt() - API to extract bcn tx status event 4160 * @wmi_handle: wmi handle 4161 * @evt_buf: pointer to the event buffer 4162 * @vdev_id: output pointer to hold vdev id 4163 * @tx_status: output pointer to hold bcn tx status 4164 * 4165 * Return: QDF_STATUS 4166 */ 4167 QDF_STATUS 4168 wmi_extract_offload_bcn_tx_status_evt(wmi_unified_t wmi_handle, void *evt_buf, 4169 uint32_t *vdev_id, uint32_t *tx_status); 4170 4171 /** 4172 * wmi_get_ch_width_from_phy_mode() - convert phy mode to channel width 4173 * @wmi_handle: wmi handle 4174 * @phymode: phy mode 4175 * 4176 * Return: wmi channel width 4177 */ 4178 wmi_host_channel_width wmi_get_ch_width_from_phy_mode( 4179 wmi_unified_t wmi_handle, WMI_HOST_WLAN_PHY_MODE phymode); 4180 4181 #ifdef QCA_SUPPORT_CP_STATS 4182 /** 4183 * wmi_extract_cca_stats() - api to extract congestion stats from event buffer 4184 * @wmi_handle: wma handle 4185 * @evt_buf: event buffer 4186 * @stats: buffer to populated after stats extraction 4187 * 4188 * Return: status of operation 4189 */ 4190 QDF_STATUS wmi_extract_cca_stats(wmi_unified_t wmi_handle, void *evt_buf, 4191 struct wmi_host_congestion_stats *stats); 4192 #endif /* QCA_SUPPORT_CP_STATS */ 4193 4194 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 4195 /** 4196 * wmi_unified_dfs_send_avg_params_cmd() - send average radar parameters cmd. 4197 * @wmi_handle: wmi handle 4198 * @params: radar found params 4199 * 4200 * This function passes the average radar parameters to fw 4201 * 4202 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4203 */ 4204 QDF_STATUS 4205 wmi_unified_dfs_send_avg_params_cmd(wmi_unified_t wmi_handle, 4206 struct dfs_radar_found_params *params); 4207 4208 /** 4209 * wmi_extract_dfs_status_from_fw() - extract host dfs status from fw. 4210 * @wmi_handle: wmi handle 4211 * @evt_buf: pointer to event buffer 4212 * @dfs_status_check: pointer to the host dfs status 4213 * 4214 * This function extracts the result of host dfs from fw 4215 * 4216 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4217 */ 4218 QDF_STATUS wmi_extract_dfs_status_from_fw(wmi_unified_t wmi_handle, 4219 void *evt_buf, 4220 uint32_t *dfs_status_check); 4221 #endif 4222 #ifdef OL_ATH_SMART_LOGGING 4223 /** 4224 * wmi_unified_send_smart_logging_enable_cmd() - send smart logging enable cmd 4225 * @wmi_handle: wmi handle 4226 * @param: enable/disable 4227 * 4228 * This function enables/disable the smart logging feature 4229 * 4230 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4231 */ 4232 QDF_STATUS wmi_unified_send_smart_logging_enable_cmd(wmi_unified_t wmi_handle, 4233 uint32_t param); 4234 4235 /** 4236 * wmi_unified_send_smart_logging_fatal_cmd() - send smart logging fatal cmd 4237 * @wmi_handle: wmi handle 4238 * @param: Fatal event 4239 * 4240 * This function sends the smart log fatal events to the FW 4241 * 4242 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4243 */ 4244 QDF_STATUS 4245 wmi_unified_send_smart_logging_fatal_cmd(wmi_unified_t wmi_handle, 4246 struct wmi_debug_fatal_events *param); 4247 4248 /** 4249 * wmi_extract_smartlog_ev() - extract smartlog event info from event 4250 * @wmi_handle: wmi handle 4251 * @evt_buf: pointer to event buffer 4252 * @ev: Pointer to hold fatal events 4253 * 4254 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4255 */ 4256 QDF_STATUS 4257 wmi_extract_smartlog_ev(wmi_unified_t wmi_handle, void *evt_buf, 4258 struct wmi_debug_fatal_events *ev); 4259 4260 #endif /* OL_ATH_SMART_LOGGING */ 4261 4262 /** 4263 * wmi_process_fw_event_worker_thread_ctx() - process in worker thread context 4264 * @wmi_handle: handle to wmi 4265 * @evt_buf: pointer to event buffer 4266 * 4267 * Event process by below function will be in worker thread context. 4268 * Use this method for events which are not critical and not 4269 * handled in protocol stack. 4270 * 4271 * Return: none 4272 */ 4273 void wmi_process_fw_event_worker_thread_ctx(struct wmi_unified *wmi_handle, 4274 void *evt_buf); 4275 4276 /** 4277 * wmi_extract_ctl_failsafe_check_ev_param() - extract ctl failsafe 4278 * status from event 4279 * @wmi_handle: wmi handle 4280 * @evt_buf: pointer to event buffer 4281 * @param: Pointer to hold ctl status 4282 * 4283 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4284 */ 4285 QDF_STATUS wmi_extract_ctl_failsafe_check_ev_param( 4286 wmi_unified_t wmi_handle, 4287 void *evt_buf, 4288 struct wmi_host_pdev_ctl_failsafe_event *param); 4289 4290 #ifdef OBSS_PD 4291 /** 4292 * wmi_unified_send_obss_spatial_reuse_set_cmd() - send obss pd offset 4293 * @wmi_handle: wmi handle 4294 * @obss_spatial_reuse_param: Pointer to obsspd min max offset 4295 * 4296 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4297 */ 4298 QDF_STATUS wmi_unified_send_obss_spatial_reuse_set_cmd( 4299 wmi_unified_t wmi_handle, 4300 struct wmi_host_obss_spatial_reuse_set_param *obss_spatial_reuse_param); 4301 4302 /** 4303 * wmi_unified_send_obss_spatial_reuse_set_def_thresh_cmd() - send def thresh 4304 * @wmi_handle: wmi handle 4305 * @thresh: Pointer to def thresh 4306 * 4307 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4308 */ 4309 QDF_STATUS wmi_unified_send_obss_spatial_reuse_set_def_thresh_cmd( 4310 wmi_unified_t wmi_handle, 4311 struct wmi_host_obss_spatial_reuse_set_def_thresh *thresh); 4312 4313 /** 4314 * wmi_unified_send_self_srg_bss_color_bitmap_set_cmd() - Send 64-bit BSS color 4315 * bitmap to be used by SRG based Spatial Reuse feature 4316 * @wmi_handle: wmi handle 4317 * @bitmap_0: lower 32 bits in BSS color bitmap 4318 * @bitmap_1: upper 32 bits in BSS color bitmap 4319 * @pdev_id: pdev ID 4320 * 4321 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4322 */ 4323 QDF_STATUS wmi_unified_send_self_srg_bss_color_bitmap_set_cmd( 4324 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4325 uint32_t bitmap_1, uint8_t pdev_id); 4326 4327 /** 4328 * wmi_unified_send_self_srg_partial_bssid_bitmap_set_cmd() - Send 64-bit 4329 * partial BSSID bitmap to be used by SRG based Spatial Reuse feature 4330 * @wmi_handle: wmi handle 4331 * @bitmap_0: lower 32 bits in partial BSSID bitmap 4332 * @bitmap_1: upper 32 bits in partial BSSID bitmap 4333 * @pdev_id: pdev ID 4334 * 4335 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4336 */ 4337 QDF_STATUS wmi_unified_send_self_srg_partial_bssid_bitmap_set_cmd( 4338 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4339 uint32_t bitmap_1, uint8_t pdev_id); 4340 4341 /** 4342 * wmi_unified_send_self_srg_obss_color_enable_bitmap_cmd() - Send 64-bit BSS 4343 * color enable bitmap to be used by SRG based Spatial Reuse feature to the FW 4344 * @wmi_handle: wmi handle 4345 * @bitmap_0: lower 32 bits in BSS color enable bitmap 4346 * @bitmap_1: upper 32 bits in BSS color enable bitmap 4347 * @pdev_id: pdev ID 4348 * 4349 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4350 */ 4351 QDF_STATUS wmi_unified_send_self_srg_obss_color_enable_bitmap_cmd( 4352 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4353 uint32_t bitmap_1, uint8_t pdev_id); 4354 4355 /** 4356 * wmi_unified_send_self_srg_obss_bssid_enable_bitmap_cmd() - Send 64-bit OBSS 4357 * BSSID enable bitmap to be used by SRG based Spatial Reuse feature to the FW 4358 * @wmi_handle: wmi handle 4359 * @bitmap_0: lower 32 bits in BSSID enable bitmap 4360 * @bitmap_1: upper 32 bits in BSSID enable bitmap 4361 * @pdev_id: pdev ID 4362 * 4363 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4364 */ 4365 QDF_STATUS wmi_unified_send_self_srg_obss_bssid_enable_bitmap_cmd( 4366 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4367 uint32_t bitmap_1, uint8_t pdev_id); 4368 4369 /** 4370 * wmi_unified_send_self_non_srg_obss_color_enable_bitmap_cmd() - Send 64-bit 4371 * BSS color enable bitmap to be used by Non-SRG based Spatial Reuse 4372 * feature to the FW 4373 * @wmi_handle: wmi handle 4374 * @bitmap_0: lower 32 bits in BSS color enable bitmap 4375 * @bitmap_1: upper 32 bits in BSS color enable bitmap 4376 * @pdev_id: pdev ID 4377 * 4378 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4379 */ 4380 QDF_STATUS wmi_unified_send_self_non_srg_obss_color_enable_bitmap_cmd( 4381 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4382 uint32_t bitmap_1, uint8_t pdev_id); 4383 4384 /** 4385 * wmi_unified_send_self_non_srg_obss_bssid_enable_bitmap_cmd() - Send 64-bit 4386 * OBSS BSSID enable bitmap to be used by Non-SRG based Spatial Reuse 4387 * feature to the FW 4388 * @wmi_handle: wmi handle 4389 * @bitmap_0: lower 32 bits in BSSID enable bitmap 4390 * @bitmap_1: upper 32 bits in BSSID enable bitmap 4391 * @pdev_id: pdev ID 4392 * 4393 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4394 */ 4395 QDF_STATUS wmi_unified_send_self_non_srg_obss_bssid_enable_bitmap_cmd( 4396 wmi_unified_t wmi_handle, uint32_t bitmap_0, 4397 uint32_t bitmap_1, uint8_t pdev_id); 4398 #endif /* OBSS_PD */ 4399 4400 /** 4401 * wmi_convert_pdev_id_host_to_target() - Convert pdev_id from host to target 4402 * defines. For legacy there is not conversion required. Just return pdev_id as 4403 * it is. 4404 * @wmi_handle: wmi handle 4405 * @host_pdev_id: host pdev_id to be converted. 4406 * @target_pdev_id: Output target pdev id. 4407 * 4408 * Return: QDF_STATUS 4409 */ 4410 QDF_STATUS wmi_convert_pdev_id_host_to_target(wmi_unified_t wmi_handle, 4411 uint32_t host_pdev_id, 4412 uint32_t *target_pdev_id); 4413 4414 #ifndef CNSS_GENL 4415 /** 4416 * wmi_convert_pdev_id_target_to_host() - Convert pdev_id from target to host 4417 * defines. For legacy there is not conversion required. Just return pdev_id as 4418 * it is. 4419 * @wmi_handle: wmi handle 4420 * @target_pdev_id: target pdev_id to be converted. 4421 * @host_pdev_id: Output host pdev id. 4422 * 4423 * Return: QDF_STATUS 4424 */ 4425 QDF_STATUS wmi_convert_pdev_id_target_to_host(wmi_unified_t wmi_handle, 4426 uint32_t target_pdev_id, 4427 uint32_t *host_pdev_id); 4428 4429 #ifdef WLAN_RTT_MEASUREMENT_NOTIFICATION 4430 /** 4431 * wmi_unified_extract_measreq_chan_info() - Extract the channel info from the 4432 * LOWI measurement request buffer. 4433 * @wmi_handle: wmi handle 4434 * @data_len: the length of @data 4435 * @data: the pointer to data buf 4436 * @chinfo: Pointer to a structure to save channel info 4437 */ 4438 QDF_STATUS wmi_unified_extract_measreq_chan_info( 4439 wmi_unified_t wmi_handle, uint32_t data_len, uint8_t *data, 4440 struct rtt_channel_info *chinfo); 4441 #endif /* WLAN_RTT_MEASUREMENT_NOTIFICATION */ 4442 #endif /* CNSS_GENL */ 4443 4444 /** 4445 * wmi_unified_send_bss_color_change_enable_cmd() - WMI function to send bss 4446 * color change enable to FW. 4447 * @wmi_handle: wmi handle 4448 * @vdev_id: vdev ID 4449 * @enable: enable or disable color change handling within firmware 4450 * 4451 * Send WMI_BSS_COLOR_CHANGE_ENABLE_CMDID parameters to fw, 4452 * thereby firmware updates bss color when AP announces bss color change. 4453 * 4454 * Return: QDF_STATUS 4455 */ 4456 QDF_STATUS 4457 wmi_unified_send_bss_color_change_enable_cmd(wmi_unified_t wmi_handle, 4458 uint32_t vdev_id, 4459 bool enable); 4460 4461 /** 4462 * wmi_unified_send_obss_color_collision_cfg_cmd() - WMI function to send bss 4463 * color collision detection configuration to FW. 4464 * @wmi_handle: wmi handle 4465 * @cfg: obss color collision detection configuration 4466 * 4467 * Send WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID parameters to fw. 4468 * 4469 * Return: QDF_STATUS 4470 */ 4471 QDF_STATUS wmi_unified_send_obss_color_collision_cfg_cmd( 4472 wmi_unified_t wmi_handle, 4473 struct wmi_obss_color_collision_cfg_param *cfg); 4474 4475 /** 4476 * wmi_unified_extract_obss_color_collision_info() - WMI function to extract 4477 * obss color collision info from FW. 4478 * @wmi_handle: wmi handle 4479 * @data: event data from firmware 4480 * @info: Pointer to hold bss color collision info 4481 * 4482 * This function is used to extract bss collision info from firmware. 4483 * 4484 * Return: QDF_STATUS 4485 */ 4486 QDF_STATUS wmi_unified_extract_obss_color_collision_info( 4487 wmi_unified_t wmi_handle, 4488 uint8_t *data, struct wmi_obss_color_collision_info *info); 4489 4490 #ifdef CRYPTO_SET_KEY_CONVERGED 4491 /** 4492 * wlan_crypto_cipher_to_wmi_cipher() - Convert crypto cipher to WMI cipher 4493 * @crypto_cipher: cipher type in crypto format 4494 * 4495 * Return: cipher type in WMI cipher type 4496 */ 4497 uint8_t wlan_crypto_cipher_to_wmi_cipher( 4498 enum wlan_crypto_cipher_type crypto_cipher); 4499 4500 /** 4501 * wlan_crypto_cipher_to_cdp_sec_type() - Convert crypto cipher to CDP type 4502 * @crypto_cipher: cipher type in crypto format 4503 * 4504 * Return: security type in cdp_sec_type data format type 4505 */ 4506 enum cdp_sec_type wlan_crypto_cipher_to_cdp_sec_type( 4507 enum wlan_crypto_cipher_type crypto_cipher); 4508 4509 #endif 4510 4511 /** 4512 * wmi_unified_send_mws_coex_req_cmd() - WMI function to send coex req cmd 4513 * @wmi_handle: wmi handle 4514 * @vdev_id: Vdev Id 4515 * @cmd_id: Coex cmd for which info is required 4516 * 4517 * Send wmi coex command to fw. 4518 * 4519 * Return: QDF_STATUS 4520 */ 4521 QDF_STATUS wmi_unified_send_mws_coex_req_cmd(struct wmi_unified *wmi_handle, 4522 uint32_t vdev_id, uint32_t cmd_id); 4523 4524 /** 4525 * wmi_unified_send_idle_trigger_monitor() - send idle trigger monitor command 4526 * @wmi_handle: WMI handle 4527 * @val: idle trigger monitor value - 1 for idle monitor on, 0 for idle monitor 4528 * off 4529 * 4530 * Return: QDF_STATUS_SUCCESS if success, else returns proper error code. 4531 */ 4532 QDF_STATUS 4533 wmi_unified_send_idle_trigger_monitor(wmi_unified_t wmi_handle, uint8_t val); 4534 4535 4536 #ifdef WIFI_POS_CONVERGED 4537 /** 4538 * wmi_extract_oem_response_param() - WMI function to extract OEM response param 4539 * @wmi_hdl: WMI handle 4540 * @resp_buf: Buffer holding response data 4541 * @oem_resp_param: zero-filled structure pointer to hold oem response data 4542 * 4543 * Return: QDF_STATUS_SUCCESS if success, else returns proper error code. 4544 */ 4545 QDF_STATUS 4546 wmi_extract_oem_response_param(wmi_unified_t wmi_hdl, void *resp_buf, 4547 struct wmi_oem_response_param *oem_resp_param); 4548 #endif /* WIFI_POS_CONVERGED */ 4549 4550 #if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT) 4551 /** 4552 * wmi_extract_pasn_peer_create_req() - Extract peer create request event 4553 * @wmi: WMI handle 4554 * @evt_buf: Event buffer 4555 * @dst: Destination buffer 4556 * 4557 * Return: QDF_STATUS 4558 */ 4559 QDF_STATUS 4560 wmi_extract_pasn_peer_create_req(wmi_unified_t wmi, void *evt_buf, 4561 struct wifi_pos_pasn_peer_data *dst); 4562 4563 /** 4564 * wmi_extract_pasn_peer_delete_req() - Extract PASN peer delete request 4565 * @wmi: WMI handle 4566 * @evt_buf: Event buffer 4567 * @dst: Destination buffer pointer 4568 * 4569 * Return: QDF_STATUS 4570 */ 4571 QDF_STATUS 4572 wmi_extract_pasn_peer_delete_req(wmi_unified_t wmi, void *evt_buf, 4573 struct wifi_pos_pasn_peer_data *dst); 4574 4575 /** 4576 * wmi_send_rtt_pasn_auth_status_cmd - Send PASN authentication status of all 4577 * the PASN peers. 4578 * @wmi: WMI handle 4579 * @data: Auth status data 4580 * 4581 * Return: QDF_STATUS 4582 */ 4583 QDF_STATUS 4584 wmi_send_rtt_pasn_auth_status_cmd(wmi_unified_t wmi, 4585 struct wlan_pasn_auth_status *data); 4586 4587 /** 4588 * wmi_send_rtt_pasn_deauth_cmd - Send RTT pasn deauthentication command 4589 * @wmi: WMI handle 4590 * @peer_mac: peer mac address 4591 * 4592 * Return: QDF_STATUS 4593 */ 4594 QDF_STATUS 4595 wmi_send_rtt_pasn_deauth_cmd(wmi_unified_t wmi, struct qdf_mac_addr *peer_mac); 4596 #endif 4597 4598 /** 4599 * wmi_critical_events_in_flight() - get the number of critical events in flight 4600 * 4601 * @wmi: WMI handle 4602 * 4603 * Return: the number of critical events in flight. 4604 */ 4605 uint32_t wmi_critical_events_in_flight(struct wmi_unified *wmi); 4606 4607 4608 #ifdef FEATURE_ANI_LEVEL_REQUEST 4609 /** 4610 * wmi_unified_ani_level_cmd_send() - WMI function to send get ani level cmd 4611 * @wmi_handle: WMI handle 4612 * @freqs: pointer to list of freqs for which ANI levels are to be fetched 4613 * @num_freqs: number of freqs in the above parameter 4614 * 4615 * Return: QDF_STATUS_SUCCESS if success, else returns proper error code. 4616 */ 4617 QDF_STATUS wmi_unified_ani_level_cmd_send(wmi_unified_t wmi_handle, 4618 uint32_t *freqs, 4619 uint8_t num_freqs); 4620 4621 /** 4622 * wmi_unified_extract_ani_level() - WMI function to receive ani level cmd 4623 * @wmi_handle: WMI handle 4624 * @data: event data 4625 * @info: pointer to ANI data received from the FW and stored in HOST 4626 * @num_freqs: number of freqs in the above parameter 4627 * 4628 * Return: QDF_STATUS_SUCCESS if success, else returns proper error code. 4629 */ 4630 QDF_STATUS wmi_unified_extract_ani_level(wmi_unified_t wmi_handle, 4631 uint8_t *data, 4632 struct wmi_host_ani_level_event **info, 4633 uint32_t *num_freqs); 4634 #endif /* FEATURE_ANI_LEVEL_REQUEST */ 4635 4636 #ifdef WLAN_FEATURE_PKT_CAPTURE 4637 /** 4638 * wmi_unified_extract_vdev_mgmt_offload_event() - Extract mgmt offload params 4639 * @wmi: WMI handle 4640 * @evt_buf: Event buffer 4641 * @params: Management offload event params 4642 * 4643 * WMI function to extract management offload event params 4644 * 4645 * Return: QDF_STATUS 4646 */ 4647 QDF_STATUS 4648 wmi_unified_extract_vdev_mgmt_offload_event(wmi_unified_t wmi, void *evt_buf, 4649 struct mgmt_offload_event_params *params); 4650 #endif 4651 4652 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 4653 /** 4654 * wmi_unified_extract_smart_monitor_event() - Extract smu event params 4655 * @wmi: WMI handle 4656 * @evt_buf: Event buffer 4657 * @params: Smart monitor event params 4658 * 4659 * Return: QDF_STATUS 4660 */ 4661 QDF_STATUS 4662 wmi_unified_extract_smart_monitor_event(wmi_unified_t wmi, void *evt_buf, 4663 struct smu_event_params *params); 4664 #endif 4665 4666 #ifdef FEATURE_WLAN_TIME_SYNC_FTM 4667 /** 4668 * wmi_unified_send_wlan_time_sync_ftm_trigger() - send ftm timesync trigger cmd 4669 * @wmi_handle: wmi handle 4670 * @vdev_id: vdev id 4671 * @burst_mode: mode reg getting time sync relation from FW 4672 * 4673 * This function indicates the FW to trigger wlan time sync using FTM 4674 * 4675 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4676 */ 4677 QDF_STATUS 4678 wmi_unified_send_wlan_time_sync_ftm_trigger(wmi_unified_t wmi_handle, 4679 uint32_t vdev_id, 4680 bool burst_mode); 4681 4682 /** 4683 * wmi_unified_send_wlan_time_sync_qtime() - send ftm time sync qtime cmd. 4684 * @wmi_handle: wmi handle 4685 * @vdev_id: vdev id 4686 * @lpass_ts: audio qtime 4687 * 4688 * This function sends the wmi cmd to FW having audio qtime 4689 * 4690 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4691 */ 4692 QDF_STATUS 4693 wmi_unified_send_wlan_time_sync_qtime(wmi_unified_t wmi_handle, 4694 uint32_t vdev_id, uint64_t lpass_ts); 4695 4696 /** 4697 * wmi_unified_extract_time_sync_ftm_start_stop_params() - extract FTM time sync 4698 * params 4699 * @wmi_handle: wmi handle 4700 * @evt_buf: event buffer 4701 * @param: params received in start stop ftm timesync event 4702 * 4703 * This function extracts the params from ftm timesync start stop event 4704 * 4705 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4706 */ 4707 QDF_STATUS 4708 wmi_unified_extract_time_sync_ftm_start_stop_params( 4709 wmi_unified_t wmi_handle, void *evt_buf, 4710 struct ftm_time_sync_start_stop_params *param); 4711 4712 /** 4713 * wmi_unified_extract_time_sync_ftm_offset() - extract timesync FTM offset 4714 * @wmi_handle: wmi handle 4715 * @evt_buf: event buffer 4716 * @param: params received in ftm timesync offset event 4717 * 4718 * This function extracts the params from ftm timesync offset event 4719 * 4720 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4721 */ 4722 QDF_STATUS 4723 wmi_unified_extract_time_sync_ftm_offset(wmi_unified_t wmi_handle, 4724 void *evt_buf, 4725 struct ftm_time_sync_offset *param); 4726 #endif /* FEATURE_WLAN_TIME_SYNC_FTM */ 4727 4728 /** 4729 * wmi_unified_send_injector_frame_config_cmd() - configure injector frame 4730 * @wmi_handle: wmi handle 4731 * @param: params received in the injector frame configure command 4732 * 4733 * This function configures the AP to send out injector frames 4734 * 4735 * Return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4736 */ 4737 QDF_STATUS 4738 wmi_unified_send_injector_frame_config_cmd(wmi_unified_t wmi_handle, 4739 struct wmi_host_injector_frame_params *param); 4740 4741 /** 4742 * wmi_unified_send_cp_stats_cmd() - Send cp stats command 4743 * @wmi_handle: wmi handle 4744 * @buf_ptr: buf_ptr received from wifistats 4745 * @buf_len: length of buffer received from wifistats 4746 * 4747 * This function sends cp stats cmd to get cp stats. 4748 * 4749 * Return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4750 */ 4751 QDF_STATUS wmi_unified_send_cp_stats_cmd(wmi_unified_t wmi_handle, 4752 void *buf_ptr, uint32_t buf_len); 4753 4754 4755 /** 4756 * wmi_unified_send_halphy_stats_cmd() - Send halphy stats command 4757 * @wmi_handle: wmi handle 4758 * @buf_ptr: buf_ptr received from wifistats 4759 * @buf_len: length of buffer received from wifistats 4760 * 4761 * This function sends halphy stats cmd to get halphy stats. 4762 * 4763 * Return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4764 */ 4765 QDF_STATUS wmi_unified_send_halphy_stats_cmd(wmi_unified_t wmi_handle, 4766 void *buf_ptr, uint32_t buf_len); 4767 4768 /** 4769 * wmi_unified_extract_cp_stats_more_pending() - extract more flag 4770 * @wmi_handle: wmi handle 4771 * @evt_buf: event buffer 4772 * @more_flag: more flag 4773 * 4774 * This function extracts the more_flag from fixed param 4775 * 4776 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4777 */ 4778 QDF_STATUS 4779 wmi_unified_extract_cp_stats_more_pending(wmi_unified_t wmi_handle, 4780 void *evt_buf, uint32_t *more_flag); 4781 4782 /** 4783 * wmi_unified_extract_halphy_stats_end_of_event() - extract end_of_event flag 4784 * @wmi_handle: wmi handle 4785 * @evt_buf: event buffer 4786 * @end_of_event_flag: end_of_event flag 4787 * 4788 * This function extracts the end_of_event_flag from fixed param 4789 * 4790 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4791 */ 4792 QDF_STATUS 4793 wmi_unified_extract_halphy_stats_end_of_event(wmi_unified_t wmi_handle, 4794 void *evt_buf, 4795 uint32_t *end_of_event_flag); 4796 4797 /** 4798 * wmi_unified_extract_halphy_stats_event_count() - extract event_count flag 4799 * @wmi_handle: wmi handle 4800 * @evt_buf: event buffer 4801 * @event_count_flag: event count flag 4802 * 4803 * This function extracts the event_count_flag from fixed param 4804 * 4805 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4806 */ 4807 QDF_STATUS 4808 wmi_unified_extract_halphy_stats_event_count(wmi_unified_t wmi_handle, 4809 void *evt_buf, 4810 uint32_t *event_count_flag); 4811 4812 /** 4813 * wmi_unified_send_vdev_tsf_tstamp_action_cmd() - send vdev tsf action command 4814 * @wmi_hdl: wmi handle 4815 * @vdev_id: vdev id 4816 * 4817 * TSF_TSTAMP_READ_VALUE is the only operation supported 4818 * Return: QDF_STATUS_SUCCESS for success or error code 4819 */ 4820 QDF_STATUS wmi_unified_send_vdev_tsf_tstamp_action_cmd(wmi_unified_t wmi_hdl, 4821 uint8_t vdev_id); 4822 4823 /** 4824 * wmi_extract_vdev_tsf_report_event() - extract vdev tsf report from event 4825 * @wmi_hdl: wmi handle 4826 * @evt_buf: pointer to event buffer 4827 * @param: Pointer to hold event info 4828 * 4829 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4830 */ 4831 QDF_STATUS wmi_extract_vdev_tsf_report_event(wmi_unified_t wmi_hdl, 4832 uint8_t *evt_buf, 4833 struct wmi_host_tsf_event *param); 4834 4835 /** 4836 * wmi_extract_pdev_csa_switch_count_status() - extract CSA switch count status 4837 * from event 4838 * @wmi_handle: wmi handle 4839 * @evt_buf: pointer to event buffer 4840 * @param: Pointer to CSA switch count status param 4841 * 4842 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4843 */ 4844 QDF_STATUS wmi_extract_pdev_csa_switch_count_status( 4845 wmi_unified_t wmi_handle, 4846 void *evt_buf, 4847 struct pdev_csa_switch_count_status *param); 4848 4849 /** 4850 * wmi_validate_handle() - Validate WMI handle 4851 * @wmi_handle: wmi handle 4852 * 4853 * This function will log on error and hence caller should not log on error 4854 * 4855 * Return: errno if WMI handle is NULL; 0 otherwise 4856 */ 4857 #define wmi_validate_handle(wmi_handle) \ 4858 __wmi_validate_handle(wmi_handle, __func__) 4859 int __wmi_validate_handle(wmi_unified_t wmi_handle, const char *func); 4860 4861 #ifdef CONFIG_AFC_SUPPORT 4862 /** 4863 * wmi_unified_send_afc_cmd() - send afc indication info 4864 * @wmi_handle: wmi handle 4865 * @pdev_id: pdev id 4866 * @param: regulatory AFC indication info 4867 * 4868 * Return: QDF_STATUS_SUCCESS for success or error code 4869 */ 4870 QDF_STATUS 4871 wmi_unified_send_afc_cmd(wmi_unified_t wmi_handle, 4872 uint8_t pdev_id, 4873 struct reg_afc_resp_rx_ind_info *param); 4874 #endif 4875 4876 /** 4877 * wmi_unified_send_set_tpc_power_cmd() - send set transmit power info 4878 * @wmi_handle: wmi handle 4879 * @vdev_id: vdev id 4880 * @param: regulatory TPC info 4881 * 4882 * Return: QDF_STATUS_SUCCESS for success or error code 4883 */ 4884 QDF_STATUS wmi_unified_send_set_tpc_power_cmd(wmi_unified_t wmi_handle, 4885 uint8_t vdev_id, 4886 struct reg_tpc_power_info *param); 4887 4888 /** 4889 * wmi_extract_dpd_status_ev_param() - extract dpd status from FW event 4890 * @wmi_handle: wmi handle 4891 * @evt_buf: pointer to event buf 4892 * @param: dpd status info 4893 * 4894 * Return: QDF_STATUS_SUCCESS for success or error code 4895 */ 4896 QDF_STATUS wmi_extract_dpd_status_ev_param(wmi_unified_t wmi_handle, 4897 void *evt_buf, 4898 struct wmi_host_pdev_get_dpd_status_event *param); 4899 4900 /** 4901 * wmi_extract_halphy_cal_status_ev_param() - extract halphy cal status from FW event 4902 * @wmi_handle: wmi handle 4903 * @evt_buf: pointer to event buf 4904 * @param: halphy cal status info 4905 * 4906 * Return: QDF_STATUS_SUCCESS for success or error code 4907 */ 4908 QDF_STATUS 4909 wmi_extract_halphy_cal_status_ev_param(wmi_unified_t wmi_handle, 4910 void *evt_buf, 4911 struct wmi_host_pdev_get_halphy_cal_status_event *param); 4912 4913 /** 4914 * wmi_unified_send_set_halphy_cal() - send set halphy cal bmap 4915 * @wmi_handle: wmi handle 4916 * @param: set halphy cal input info 4917 * 4918 * Return: QDF_STATUS_SUCCESS for success or error code 4919 */ 4920 QDF_STATUS wmi_unified_send_set_halphy_cal(wmi_unified_t wmi_handle, 4921 struct wmi_host_send_set_halphy_cal_info *param); 4922 4923 /** 4924 * wmi_extract_halphy_cal_ev_param() - extract halphy cal status from FW event 4925 * @wmi_handle: wmi handle 4926 * @evt_buf: pointer to event buf 4927 * @param: halphy cal status info 4928 * 4929 * Return: QDF_STATUS_SUCCESS for success or error code 4930 */ 4931 QDF_STATUS 4932 wmi_extract_halphy_cal_ev_param(wmi_unified_t wmi_handle, 4933 void *evt_buf, 4934 struct wmi_host_pdev_set_halphy_cal_event *param); 4935 4936 #ifdef FEATURE_MEC_OFFLOAD 4937 /** 4938 * wmi_unified_pdev_set_mec_timer() - set mec timer value 4939 * @wmi_handle: wmi handle 4940 * @param: params needed for mec timer config 4941 * 4942 * Return: QDF_STATUS_SUCCESS for success or error code 4943 */ 4944 QDF_STATUS 4945 wmi_unified_pdev_set_mec_timer(struct wmi_unified *wmi_handle, 4946 struct set_mec_timer_params *param); 4947 #endif 4948 4949 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE 4950 /** 4951 * wmi_unified_send_set_mac_addr() - Send VDEV set MAC address command to FW 4952 * @wmi_handle: WMI handle 4953 * @params: Set MAC address command params 4954 * 4955 * Return: QDF_STATUS_SUCCESS for success or error code 4956 */ 4957 QDF_STATUS wmi_unified_send_set_mac_addr(struct wmi_unified *wmi_handle, 4958 struct set_mac_addr_params *params); 4959 4960 /** 4961 * wmi_extract_update_mac_address_event() - Extract update MAC address event 4962 * @wmi_handle: WMI handle 4963 * @evt_buf: event buffer 4964 * @vdev_id: VDEV ID 4965 * @status: FW status for the set MAC address operation 4966 * 4967 * Return: QDF_STATUS_SUCCESS for success or error code 4968 */ 4969 QDF_STATUS wmi_extract_update_mac_address_event(wmi_unified_t wmi_handle, 4970 void *evt_buf, uint8_t *vdev_id, 4971 uint8_t *status); 4972 #endif 4973 4974 #ifdef WLAN_FEATURE_11BE_MLO 4975 /** 4976 * wmi_extract_quiet_offload_event() - Extra mlo sta quiet IE offload event 4977 * @wmi_handle: WMI handle 4978 * @evt_buf: event buffer 4979 * @quiet_event: pointer to struct vdev_sta_quiet_event 4980 * 4981 * Return: QDF_STATUS_SUCCESS for success or error code 4982 */ 4983 QDF_STATUS wmi_extract_quiet_offload_event( 4984 struct wmi_unified *wmi_handle, void *evt_buf, 4985 struct vdev_sta_quiet_event *quiet_event); 4986 #endif 4987 4988 #ifdef WLAN_SUPPORT_PPEDS 4989 /** 4990 * wmi_unified_peer_ppe_ds_param_send - Set the PPEDS configs 4991 * @wmi_handle: WMI handle 4992 * @param: Peer PPE DS param 4993 * 4994 * Return: QDF_STATUS_SUCCESS for success or error code. 4995 */ 4996 QDF_STATUS 4997 wmi_unified_peer_ppe_ds_param_send(wmi_unified_t wmi_handle, 4998 struct peer_ppe_ds_param *param); 4999 #endif /* WLAN_SUPPORT_PPEDS */ 5000 5001 /** 5002 * wmi_extract_pktlog_decode_info_event() - Extract pktlog decode info 5003 * @wmi_handle: WMI handle 5004 * @evt_buf: event buffer 5005 * @pdev_id: pdev_id 5006 * @software_image: software image version 5007 * @chip_info: chip info 5008 * @pktlog_json_version: pktlog json version 5009 * 5010 * Return: QDF_STATUS_SUCCESS for success or error code 5011 */ 5012 QDF_STATUS 5013 wmi_extract_pktlog_decode_info_event(wmi_unified_t wmi_handle, 5014 void *evt_buf, 5015 uint8_t *pdev_id, 5016 uint8_t *software_image, 5017 uint8_t *chip_info, 5018 uint32_t *pktlog_json_version); 5019 5020 /** 5021 * wmi_unified_pn_mgmt_rxfilter_send_cmd() - Send PN mgmt RxFilter command to FW 5022 * @wmi_handle: WMI handle 5023 * @params: RxFilter params 5024 * 5025 * Return: QDF_STATUS_SUCCESS for success or error code 5026 */ 5027 QDF_STATUS wmi_unified_pn_mgmt_rxfilter_send_cmd( 5028 struct wmi_unified *wmi_handle, 5029 struct vdev_pn_mgmt_rxfilter_params *params); 5030 5031 /** 5032 * wmi_extract_pdev_telemetry_stats - extract pdev telemetry stats 5033 * @wmi_handle: wmi handle 5034 * @evt_buf: pointer to event buffer 5035 * @pdev_stats: Pointer to hold pdev telemetry stats 5036 * 5037 * Return: QDF_STATUS_SUCCESS for success or error code 5038 */ 5039 QDF_STATUS wmi_extract_pdev_telemetry_stats( 5040 wmi_unified_t wmi_handle, void *evt_buf, 5041 struct wmi_host_pdev_telemetry_stats *pdev_stats); 5042 5043 #ifdef FEATURE_SET 5044 /** 5045 * wmi_feature_set_cmd_send - Send feature set command to fw 5046 * @wmi_handle: wmi handle 5047 * @feature_set: pointer feature set info which needs to be send to fw 5048 * 5049 * Return: QDF_STATUS_SUCCESS for success or error code 5050 */ 5051 QDF_STATUS wmi_feature_set_cmd_send( 5052 wmi_unified_t wmi_handle, 5053 struct target_feature_set *feature_set); 5054 #endif 5055 5056 #ifdef HEALTH_MON_SUPPORT 5057 /** 5058 * wmi_extract_health_mon_event - extract health monitor params 5059 * @wmi_handle: wmi handle 5060 * @ev: pointer to event buffer 5061 * @param: health monitor params 5062 * 5063 * Return: QDF_STATUS_SUCCESS for success or error code 5064 */ 5065 5066 QDF_STATUS wmi_extract_health_mon_event( 5067 wmi_unified_t wmi_handle, 5068 void *ev, 5069 struct wmi_health_mon_params *param); 5070 #endif /* HEALTH_MON_SUPPORT */ 5071 5072 /** 5073 * wmi_unified_update_edca_pifs_param() - update EDCA/PIFS params 5074 * @wmi_handle: wmi handle 5075 * @edca_pifs_param: pointer to edca_pifs_vparam struct 5076 * 5077 * This function updates EDCA/PIFS parameters to the target 5078 * 5079 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5080 */ 5081 QDF_STATUS 5082 wmi_unified_update_edca_pifs_param( 5083 wmi_unified_t wmi_handle, 5084 struct edca_pifs_vparam *edca_pifs_param); 5085 5086 /** 5087 * wmi_extract_sap_coex_cap_service_ready_ext2() - extract sap coex capability 5088 * @wmi_handle: wmi handle 5089 * @evt_buf: pointer to event buffer 5090 * @cap: It's set to 1 if fixed chan SAP is supported by firmware even when the 5091 * channel is unsafe due to coex. 5092 * 5093 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 5094 */ 5095 QDF_STATUS wmi_extract_sap_coex_cap_service_ready_ext2( 5096 wmi_unified_t wmi_handle, 5097 uint8_t *evt_buf, 5098 struct wmi_host_coex_fix_chan_cap *cap); 5099 #endif /* _WMI_UNIFIED_API_H_ */ 5100