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