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