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