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