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