1 /* 2 * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved. 3 * 4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc. 5 * 6 * 7 * Permission to use, copy, modify, and/or distribute this software for 8 * any purpose with or without fee is hereby granted, provided that the 9 * above copyright notice and this permission notice appear in all 10 * copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 19 * PERFORMANCE OF THIS SOFTWARE. 20 */ 21 22 /* 23 * This file was originally distributed by Qualcomm Atheros, Inc. 24 * under proprietary terms before Copyright ownership was assigned 25 * to the Linux Foundation. 26 */ 27 #include "wmi_unified_priv.h" 28 #include "wmi_unified_param.h" 29 #include "qdf_module.h" 30 31 /** 32 * wmi_unified_vdev_create_send() - send VDEV create command to fw 33 * @wmi_handle: wmi handle 34 * @param: pointer to hold vdev create parameter 35 * @macaddr: vdev mac address 36 * 37 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 38 */ 39 QDF_STATUS wmi_unified_vdev_create_send(void *wmi_hdl, 40 uint8_t macaddr[IEEE80211_ADDR_LEN], 41 struct vdev_create_params *param) 42 { 43 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 44 45 if (wmi_handle->ops->send_vdev_create_cmd) 46 return wmi_handle->ops->send_vdev_create_cmd(wmi_handle, 47 macaddr, param); 48 49 return QDF_STATUS_E_FAILURE; 50 } 51 52 /** 53 * wmi_unified_vdev_delete_send() - send VDEV delete command to fw 54 * @wmi_handle: wmi handle 55 * @if_id: vdev id 56 * 57 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 58 */ 59 QDF_STATUS wmi_unified_vdev_delete_send(void *wmi_hdl, 60 uint8_t if_id) 61 { 62 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 63 64 if (wmi_handle->ops->send_vdev_delete_cmd) 65 return wmi_handle->ops->send_vdev_delete_cmd(wmi_handle, 66 if_id); 67 68 return QDF_STATUS_E_FAILURE; 69 } 70 71 /** 72 * wmi_unified_vdev_stop_send() - send vdev stop command to fw 73 * @wmi: wmi handle 74 * @vdev_id: vdev id 75 * 76 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 77 */ 78 QDF_STATUS wmi_unified_vdev_stop_send(void *wmi_hdl, 79 uint8_t vdev_id) 80 { 81 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 82 83 if (wmi_handle->ops->send_vdev_stop_cmd) 84 return wmi_handle->ops->send_vdev_stop_cmd(wmi_handle, 85 vdev_id); 86 87 return QDF_STATUS_E_FAILURE; 88 } 89 90 /** 91 * wmi_unified_vdev_down_send() - send vdev down command to fw 92 * @wmi: wmi handle 93 * @vdev_id: vdev id 94 * 95 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 96 */ 97 QDF_STATUS wmi_unified_vdev_down_send(void *wmi_hdl, uint8_t vdev_id) 98 { 99 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 100 101 if (wmi_handle->ops->send_vdev_down_cmd) 102 return wmi_handle->ops->send_vdev_down_cmd(wmi_handle, vdev_id); 103 104 return QDF_STATUS_E_FAILURE; 105 } 106 107 /** 108 * wmi_unified_vdev_start_send() - send vdev start command to fw 109 * @wmi: wmi handle 110 * @vdev_id: vdev id 111 * 112 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 113 */ 114 QDF_STATUS wmi_unified_vdev_start_send(void *wmi_hdl, 115 struct vdev_start_params *req) 116 { 117 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 118 119 if (wmi_handle->ops->send_vdev_start_cmd) 120 return wmi_handle->ops->send_vdev_start_cmd(wmi_handle, req); 121 122 return QDF_STATUS_E_FAILURE; 123 } 124 125 /** 126 * wmi_unified_vdev_set_nac_rssi_send() - send NAC_RSSI command to fw 127 * @wmi: wmi handle 128 * @req: pointer to hold nac rssi request data 129 * 130 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 131 */ 132 QDF_STATUS wmi_unified_vdev_set_nac_rssi_send(void *wmi_hdl, 133 struct vdev_scan_nac_rssi_params *req) 134 { 135 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 136 137 if (wmi_handle->ops->send_vdev_set_nac_rssi_cmd) 138 return wmi_handle->ops->send_vdev_set_nac_rssi_cmd(wmi_handle, req); 139 140 return QDF_STATUS_E_FAILURE; 141 } 142 143 /** 144 * wmi_unified_hidden_ssid_vdev_restart_send() - restart vdev to set hidden ssid 145 * @wmi: wmi handle 146 * @restart_params: vdev restart params 147 * 148 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 149 */ 150 QDF_STATUS wmi_unified_hidden_ssid_vdev_restart_send(void *wmi_hdl, 151 struct hidden_ssid_vdev_restart_params *restart_params) 152 { 153 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 154 155 if (wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd) 156 return wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd( 157 wmi_handle, restart_params); 158 159 return QDF_STATUS_E_FAILURE; 160 } 161 162 /** 163 * wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw 164 * @wmi: wmi handle 165 * @peer_addr: peer mac address 166 * @param: pointer to hold peer flush tid parameter 167 * 168 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 169 */ 170 QDF_STATUS wmi_unified_peer_flush_tids_send(void *wmi_hdl, 171 uint8_t peer_addr[IEEE80211_ADDR_LEN], 172 struct peer_flush_params *param) 173 { 174 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 175 176 if (wmi_handle->ops->send_peer_flush_tids_cmd) 177 return wmi_handle->ops->send_peer_flush_tids_cmd(wmi_handle, 178 peer_addr, param); 179 180 return QDF_STATUS_E_FAILURE; 181 } 182 183 /** 184 * wmi_unified_peer_delete_send() - send PEER delete command to fw 185 * @wmi: wmi handle 186 * @peer_addr: peer mac addr 187 * @vdev_id: vdev id 188 * 189 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 190 */ 191 QDF_STATUS wmi_unified_peer_delete_send(void *wmi_hdl, 192 uint8_t 193 peer_addr[IEEE80211_ADDR_LEN], 194 uint8_t vdev_id) 195 { 196 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 197 198 if (wmi_handle->ops->send_peer_delete_cmd) 199 return wmi_handle->ops->send_peer_delete_cmd(wmi_handle, 200 peer_addr, vdev_id); 201 202 return QDF_STATUS_E_FAILURE; 203 } 204 205 /** 206 * wmi_set_peer_param() - set peer parameter in fw 207 * @wmi_ctx: wmi handle 208 * @peer_addr: peer mac address 209 * @param : pointer to hold peer set parameter 210 * 211 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 212 */ 213 QDF_STATUS wmi_set_peer_param_send(void *wmi_hdl, 214 uint8_t peer_addr[IEEE80211_ADDR_LEN], 215 struct peer_set_params *param) 216 { 217 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 218 219 if (wmi_handle->ops->send_peer_param_cmd) 220 return wmi_handle->ops->send_peer_param_cmd(wmi_handle, 221 peer_addr, param); 222 223 return QDF_STATUS_E_FAILURE; 224 } 225 226 /** 227 * wmi_unified_vdev_up_send() - send vdev up command in fw 228 * @wmi: wmi handle 229 * @bssid: bssid 230 * @vdev_up_params: pointer to hold vdev up parameter 231 * 232 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 233 */ 234 QDF_STATUS wmi_unified_vdev_up_send(void *wmi_hdl, 235 uint8_t bssid[IEEE80211_ADDR_LEN], 236 struct vdev_up_params *params) 237 { 238 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 239 240 if (wmi_handle->ops->send_vdev_up_cmd) 241 return wmi_handle->ops->send_vdev_up_cmd(wmi_handle, bssid, 242 params); 243 244 return QDF_STATUS_E_FAILURE; 245 } 246 247 /** 248 * wmi_unified_peer_create_send() - send peer create command to fw 249 * @wmi: wmi handle 250 * @peer_addr: peer mac address 251 * @peer_type: peer type 252 * @vdev_id: vdev id 253 * 254 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 255 */ 256 QDF_STATUS wmi_unified_peer_create_send(void *wmi_hdl, 257 struct peer_create_params *param) 258 { 259 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 260 261 if (wmi_handle->ops->send_peer_create_cmd) 262 return wmi_handle->ops->send_peer_create_cmd(wmi_handle, param); 263 264 return QDF_STATUS_E_FAILURE; 265 } 266 267 /** 268 * wmi_unified_peer_rx_reorder_queue_setup_send() - send rx reorder queue 269 * setup command to fw 270 * @wmi: wmi handle 271 * @rx_reorder_queue_setup_params: Rx reorder queue setup parameters 272 * 273 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 274 */ 275 QDF_STATUS wmi_unified_peer_rx_reorder_queue_setup_send(void *wmi_hdl, 276 struct rx_reorder_queue_setup_params *param) 277 { 278 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 279 280 if (wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd) 281 return wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd( 282 wmi_handle, param); 283 284 return QDF_STATUS_E_FAILURE; 285 } 286 287 /** 288 * wmi_unified_peer_rx_reorder_queue_remove_send() - send rx reorder queue 289 * remove command to fw 290 * @wmi: wmi handle 291 * @rx_reorder_queue_remove_params: Rx reorder queue remove parameters 292 * 293 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 294 */ 295 QDF_STATUS wmi_unified_peer_rx_reorder_queue_remove_send(void *wmi_hdl, 296 struct rx_reorder_queue_remove_params *param) 297 { 298 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 299 300 if (wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd) 301 return wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd( 302 wmi_handle, param); 303 304 return QDF_STATUS_E_FAILURE; 305 } 306 307 #ifdef WLAN_SUPPORT_GREEN_AP 308 /** 309 * wmi_unified_green_ap_ps_send() - enable green ap powersave command 310 * @wmi_handle: wmi handle 311 * @value: value 312 * @pdev_id: pdev id to have radio context 313 * 314 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 315 */ 316 QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl, 317 uint32_t value, uint8_t pdev_id) 318 { 319 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 320 321 if (wmi_handle->ops->send_green_ap_ps_cmd) 322 return wmi_handle->ops->send_green_ap_ps_cmd(wmi_handle, value, 323 pdev_id); 324 325 return QDF_STATUS_E_FAILURE; 326 } 327 #else 328 QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl, 329 uint32_t value, uint8_t pdev_id) 330 { 331 return QDF_STATUS_SUCCESS; 332 } 333 #endif /* WLAN_SUPPORT_GREEN_AP */ 334 335 /** 336 * wmi_unified_pdev_utf_cmd() - send utf command to fw 337 * @wmi_handle: wmi handle 338 * @param: pointer to pdev_utf_params 339 * @mac_id: mac id to have radio context 340 * 341 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 342 */ 343 QDF_STATUS 344 wmi_unified_pdev_utf_cmd_send(void *wmi_hdl, 345 struct pdev_utf_params *param, 346 uint8_t mac_id) 347 { 348 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 349 350 if (wmi_handle->ops->send_pdev_utf_cmd) 351 return wmi_handle->ops->send_pdev_utf_cmd(wmi_handle, param, 352 mac_id); 353 354 return QDF_STATUS_E_FAILURE; 355 } 356 357 /** 358 * wmi_unified_pdev_param_send() - set pdev parameters 359 * @wmi_handle: wmi handle 360 * @param: pointer to pdev parameter 361 * @mac_id: radio context 362 * 363 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 364 * errno on failure 365 */ 366 QDF_STATUS 367 wmi_unified_pdev_param_send(void *wmi_hdl, 368 struct pdev_params *param, 369 uint8_t mac_id) 370 { 371 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 372 373 if (wmi_handle->ops->send_pdev_param_cmd) 374 return wmi_handle->ops->send_pdev_param_cmd(wmi_handle, param, 375 mac_id); 376 377 return QDF_STATUS_E_FAILURE; 378 } 379 380 /** 381 * wmi_unified_suspend_send() - WMI suspend function 382 * @param wmi_handle : handle to WMI. 383 * @param param : pointer to hold suspend parameter 384 * @mac_id: radio context 385 * 386 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 387 */ 388 QDF_STATUS wmi_unified_suspend_send(void *wmi_hdl, 389 struct suspend_params *param, 390 uint8_t mac_id) 391 { 392 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 393 394 if (wmi_handle->ops->send_suspend_cmd) 395 return wmi_handle->ops->send_suspend_cmd(wmi_handle, param, 396 mac_id); 397 398 return QDF_STATUS_E_FAILURE; 399 } 400 401 /** 402 * wmi_unified_resume_send - WMI resume function 403 * @param wmi_handle : handle to WMI. 404 * @mac_id: radio context 405 * 406 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 407 */ 408 QDF_STATUS wmi_unified_resume_send(void *wmi_hdl, 409 uint8_t mac_id) 410 { 411 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 412 413 if (wmi_handle->ops->send_resume_cmd) 414 return wmi_handle->ops->send_resume_cmd(wmi_handle, 415 mac_id); 416 417 return QDF_STATUS_E_FAILURE; 418 } 419 420 #ifdef FEATURE_WLAN_D0WOW 421 /** 422 * wmi_unified_d0wow_enable_send() - WMI d0 wow enable function 423 * @param wmi_handle: handle to WMI. 424 * @mac_id: radio context 425 * 426 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 427 */ 428 QDF_STATUS wmi_unified_d0wow_enable_send(void *wmi_hdl, 429 uint8_t mac_id) 430 { 431 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 432 433 if (wmi_handle->ops->send_d0wow_enable_cmd) 434 return wmi_handle->ops->send_d0wow_enable_cmd( 435 wmi_handle, mac_id); 436 437 return QDF_STATUS_E_FAILURE; 438 } 439 440 /** 441 * wmi_unified_d0wow_disable_send() - WMI d0 wow disable function 442 * @param wmi_handle: handle to WMI. 443 * @mac_id: radio context 444 * 445 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 446 */ 447 QDF_STATUS wmi_unified_d0wow_disable_send(void *wmi_hdl, 448 uint8_t mac_id) 449 { 450 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 451 452 if (wmi_handle->ops->send_d0wow_disable_cmd) 453 return wmi_handle->ops->send_d0wow_disable_cmd( 454 wmi_handle, mac_id); 455 456 return QDF_STATUS_E_FAILURE; 457 } 458 #endif 459 460 /** 461 * wmi_unified_wow_enable_send() - WMI wow enable function 462 * @param wmi_handle : handle to WMI. 463 * @param param : pointer to hold wow enable parameter 464 * @mac_id: radio context 465 * 466 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 467 */ 468 QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl, 469 struct wow_cmd_params *param, 470 uint8_t mac_id) 471 { 472 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 473 474 if (wmi_handle->ops->send_wow_enable_cmd) 475 return wmi_handle->ops->send_wow_enable_cmd(wmi_handle, param, 476 mac_id); 477 478 return QDF_STATUS_E_FAILURE; 479 } 480 481 /** 482 * wmi_unified_wow_wakeup_send() - WMI wow wakeup function 483 * @param wmi_hdl : handle to WMI. 484 * 485 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 486 */ 487 QDF_STATUS wmi_unified_wow_wakeup_send(void *wmi_hdl) 488 { 489 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 490 491 if (wmi_handle->ops->send_wow_wakeup_cmd) 492 return wmi_handle->ops->send_wow_wakeup_cmd(wmi_handle); 493 494 return QDF_STATUS_E_FAILURE; 495 } 496 497 /** 498 * wmi_unified_wow_add_wakeup_event_send() - WMI wow wakeup function 499 * @param wmi_handle : handle to WMI. 500 * @param: pointer to wow wakeup event parameter structure 501 * 502 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 503 */ 504 QDF_STATUS wmi_unified_wow_add_wakeup_event_send(void *wmi_hdl, 505 struct wow_add_wakeup_params *param) 506 { 507 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 508 509 if (wmi->ops->send_wow_add_wakeup_event_cmd) 510 return wmi->ops->send_wow_add_wakeup_event_cmd(wmi, 511 param); 512 513 return QDF_STATUS_E_FAILURE; 514 } 515 516 /** 517 * wmi_unified_wow_add_wakeup_pattern_send() - WMI wow wakeup pattern function 518 * @param wmi_handle : handle to WMI. 519 * @param: pointer to wow wakeup pattern parameter structure 520 * 521 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 522 */ 523 QDF_STATUS wmi_unified_wow_add_wakeup_pattern_send(void *wmi_hdl, 524 struct wow_add_wakeup_pattern_params *param) 525 { 526 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 527 528 if (wmi->ops->send_wow_add_wakeup_pattern_cmd) 529 return wmi->ops->send_wow_add_wakeup_pattern_cmd(wmi, param); 530 531 return QDF_STATUS_E_FAILURE; 532 } 533 534 /** 535 * wmi_unified_wow_remove_wakeup_pattern_send() - WMI wow wakeup pattern function 536 * @param wmi_handle : handle to WMI. 537 * @param: pointer to wow wakeup pattern parameter structure 538 * 539 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 540 */ 541 QDF_STATUS wmi_unified_wow_remove_wakeup_pattern_send(void *wmi_hdl, 542 struct wow_remove_wakeup_pattern_params *param) 543 { 544 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 545 546 if (wmi->ops->send_wow_remove_wakeup_pattern_cmd) 547 return wmi->ops->send_wow_remove_wakeup_pattern_cmd(wmi, param); 548 549 return QDF_STATUS_E_FAILURE; 550 } 551 552 /** 553 * wmi_unified_ap_ps_cmd_send() - set ap powersave parameters 554 * @wma_ctx: wma context 555 * @peer_addr: peer mac address 556 * @param: pointer to ap_ps parameter structure 557 * 558 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 559 */ 560 QDF_STATUS wmi_unified_ap_ps_cmd_send(void *wmi_hdl, 561 uint8_t *peer_addr, 562 struct ap_ps_params *param) 563 { 564 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 565 566 if (wmi_handle->ops->send_set_ap_ps_param_cmd) 567 return wmi_handle->ops->send_set_ap_ps_param_cmd(wmi_handle, 568 peer_addr, 569 param); 570 571 return QDF_STATUS_E_FAILURE; 572 } 573 574 /** 575 * wmi_unified_sta_ps_cmd_send() - set sta powersave parameters 576 * @wma_ctx: wma context 577 * @peer_addr: peer mac address 578 * @param: pointer to sta_ps parameter structure 579 * 580 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 581 */ 582 QDF_STATUS wmi_unified_sta_ps_cmd_send(void *wmi_hdl, 583 struct sta_ps_params *param) 584 { 585 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 586 587 if (wmi_handle->ops->send_set_sta_ps_param_cmd) 588 return wmi_handle->ops->send_set_sta_ps_param_cmd(wmi_handle, 589 param); 590 591 return QDF_STATUS_E_FAILURE; 592 } 593 594 /** 595 * wmi_crash_inject() - inject fw crash 596 * @wma_handle: wma handle 597 * @param: ponirt to crash inject paramter structure 598 * 599 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 600 */ 601 QDF_STATUS wmi_crash_inject(void *wmi_hdl, 602 struct crash_inject *param) 603 { 604 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 605 606 if (wmi_handle->ops->send_crash_inject_cmd) 607 return wmi_handle->ops->send_crash_inject_cmd(wmi_handle, 608 param); 609 610 return QDF_STATUS_E_FAILURE; 611 } 612 613 /** 614 * wmi_unified_dbglog_cmd_send() - set debug log level 615 * @param wmi_handle : handle to WMI. 616 * @param param : pointer to hold dbglog level parameter 617 * 618 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 619 */ 620 QDF_STATUS 621 wmi_unified_dbglog_cmd_send(void *wmi_hdl, 622 struct dbglog_params *dbglog_param) 623 { 624 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 625 626 if (wmi_handle->ops->send_dbglog_cmd) 627 return wmi_handle->ops->send_dbglog_cmd(wmi_handle, 628 dbglog_param); 629 630 return QDF_STATUS_E_FAILURE; 631 } 632 qdf_export_symbol(wmi_unified_dbglog_cmd_send); 633 634 /** 635 * wmi_unified_vdev_set_param_send() - WMI vdev set parameter function 636 * @param wmi_handle : handle to WMI. 637 * @param macaddr : MAC address 638 * @param param : pointer to hold vdev set parameter 639 * 640 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 641 */ 642 QDF_STATUS wmi_unified_vdev_set_param_send(void *wmi_hdl, 643 struct vdev_set_params *param) 644 { 645 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 646 647 if (wmi_handle->ops->send_vdev_set_param_cmd) 648 return wmi_handle->ops->send_vdev_set_param_cmd(wmi_handle, 649 param); 650 651 return QDF_STATUS_E_FAILURE; 652 } 653 654 /** 655 * wmi_unified_stats_request_send() - WMI request stats function 656 * @param wmi_handle : handle to WMI. 657 * @param macaddr : MAC address 658 * @param param : pointer to hold stats request parameter 659 * 660 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 661 */ 662 QDF_STATUS wmi_unified_stats_request_send(void *wmi_hdl, 663 uint8_t macaddr[IEEE80211_ADDR_LEN], 664 struct stats_request_params *param) 665 { 666 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 667 668 if (wmi_handle->ops->send_stats_request_cmd) 669 return wmi_handle->ops->send_stats_request_cmd(wmi_handle, 670 macaddr, param); 671 672 return QDF_STATUS_E_FAILURE; 673 } 674 675 #ifdef CONFIG_MCL 676 /** 677 * wmi_unified_packet_log_enable_send() - WMI request stats function 678 * @param wmi_handle : handle to WMI. 679 * @param macaddr : MAC address 680 * @param param : pointer to hold stats request parameter 681 * 682 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 683 */ 684 QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, 685 uint8_t macaddr[IEEE80211_ADDR_LEN], 686 struct packet_enable_params *param) 687 { 688 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 689 690 if (wmi_handle->ops->send_packet_log_enable_cmd) 691 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle, 692 macaddr, param); 693 694 return QDF_STATUS_E_FAILURE; 695 } 696 #else 697 /** 698 * wmi_unified_packet_log_enable_send() - WMI request stats function 699 * @param wmi_handle : handle to WMI. 700 * @param macaddr : MAC address 701 * @param param : pointer to hold stats request parameter 702 * 703 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 704 */ 705 QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, 706 WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id) 707 { 708 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 709 710 if (wmi_handle->ops->send_packet_log_enable_cmd) 711 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle, 712 PKTLOG_EVENT, mac_id); 713 714 return QDF_STATUS_E_FAILURE; 715 } 716 717 #endif 718 /** 719 * wmi_unified_packet_log_disable__send() - WMI pktlog disable function 720 * @param wmi_handle : handle to WMI. 721 * @param PKTLOG_EVENT : packet log event 722 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 723 */ 724 QDF_STATUS wmi_unified_packet_log_disable_send(void *wmi_hdl, uint8_t mac_id) 725 { 726 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 727 728 if (wmi_handle->ops->send_packet_log_disable_cmd) 729 return wmi_handle->ops->send_packet_log_disable_cmd(wmi_handle, 730 mac_id); 731 732 return QDF_STATUS_E_FAILURE; 733 } 734 735 /** 736 * wmi_unified_beacon_send_cmd() - WMI beacon send function 737 * @param wmi_handle : handle to WMI. 738 * @param macaddr : MAC address 739 * @param param : pointer to hold beacon send cmd parameter 740 * 741 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 742 */ 743 QDF_STATUS wmi_unified_beacon_send_cmd(void *wmi_hdl, 744 struct beacon_params *param) 745 { 746 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 747 748 if (wmi_handle->ops->send_beacon_send_cmd) 749 return wmi_handle->ops->send_beacon_send_cmd(wmi_handle, 750 param); 751 752 return QDF_STATUS_E_FAILURE; 753 } 754 755 /** 756 * wmi_unified_beacon_tmpl_send_cmd() - WMI beacon send function 757 * @param wmi_handle : handle to WMI. 758 * @param macaddr : MAC address 759 * @param param : pointer to hold beacon send cmd parameter 760 * 761 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 762 */ 763 QDF_STATUS wmi_unified_beacon_tmpl_send_cmd(void *wmi_hdl, 764 struct beacon_tmpl_params *param) 765 { 766 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 767 768 if (wmi_handle->ops->send_beacon_tmpl_send_cmd) 769 return wmi_handle->ops->send_beacon_tmpl_send_cmd(wmi_handle, 770 param); 771 772 return QDF_STATUS_E_FAILURE; 773 } 774 /** 775 * wmi_unified_peer_assoc_send() - WMI peer assoc function 776 * @param wmi_handle : handle to WMI. 777 * @param macaddr : MAC address 778 * @param param : pointer to peer assoc parameter 779 * 780 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 781 */ 782 QDF_STATUS wmi_unified_peer_assoc_send(void *wmi_hdl, 783 struct peer_assoc_params *param) 784 { 785 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 786 787 if (wmi_handle->ops->send_peer_assoc_cmd) 788 return wmi_handle->ops->send_peer_assoc_cmd(wmi_handle, 789 param); 790 791 return QDF_STATUS_E_FAILURE; 792 } 793 794 /** 795 * wmi_unified_scan_start_cmd_send() - WMI scan start function 796 * @param wmi_handle : handle to WMI. 797 * @param macaddr : MAC address 798 * @param param : pointer to hold scan start cmd parameter 799 * 800 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 801 */ 802 QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl, 803 struct scan_req_params *param) 804 { 805 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 806 807 if (wmi_handle->ops->send_scan_start_cmd) 808 return wmi_handle->ops->send_scan_start_cmd(wmi_handle, 809 param); 810 811 return QDF_STATUS_E_FAILURE; 812 } 813 814 /** 815 * wmi_unified_scan_stop_cmd_send() - WMI scan start function 816 * @param wmi_handle : handle to WMI. 817 * @param macaddr : MAC address 818 * @param param : pointer to hold scan start cmd parameter 819 * 820 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 821 */ 822 QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl, 823 struct scan_cancel_param *param) 824 { 825 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 826 827 if (wmi_handle->ops->send_scan_stop_cmd) 828 return wmi_handle->ops->send_scan_stop_cmd(wmi_handle, 829 param); 830 831 return QDF_STATUS_E_FAILURE; 832 } 833 834 /** 835 * wmi_unified_scan_chan_list_cmd_send() - WMI scan channel list function 836 * @param wmi_handle : handle to WMI. 837 * @param macaddr : MAC address 838 * @param param : pointer to hold scan channel list parameter 839 * 840 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 841 */ 842 QDF_STATUS wmi_unified_scan_chan_list_cmd_send(void *wmi_hdl, 843 struct scan_chan_list_params *param) 844 { 845 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 846 847 if (wmi_handle->ops->send_scan_chan_list_cmd) 848 return wmi_handle->ops->send_scan_chan_list_cmd(wmi_handle, 849 param); 850 851 return QDF_STATUS_E_FAILURE; 852 } 853 854 /** 855 * wmi_mgmt_unified_cmd_send() - management cmd over wmi layer 856 * @wmi_hdl : handle to WMI. 857 * @param : pointer to hold mgmt cmd parameter 858 * 859 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 860 */ 861 QDF_STATUS wmi_mgmt_unified_cmd_send(void *wmi_hdl, 862 struct wmi_mgmt_params *param) 863 { 864 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 865 866 if (wmi_handle->ops->send_mgmt_cmd) 867 return wmi_handle->ops->send_mgmt_cmd(wmi_handle, 868 param); 869 870 return QDF_STATUS_E_FAILURE; 871 } 872 873 /** 874 * wmi_offchan_data_tx_cmd_send() - Send offchan data tx cmd over wmi layer 875 * @wmi_hdl : handle to WMI. 876 * @param : pointer to hold offchan data cmd parameter 877 * 878 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 879 */ 880 QDF_STATUS wmi_offchan_data_tx_cmd_send(void *wmi_hdl, 881 struct wmi_offchan_data_tx_params *param) 882 { 883 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 884 885 if (wmi_handle->ops->send_offchan_data_tx_cmd) 886 return wmi_handle->ops->send_offchan_data_tx_cmd(wmi_handle, 887 param); 888 889 return QDF_STATUS_E_FAILURE; 890 } 891 892 /** 893 * wmi_unified_modem_power_state() - set modem power state to fw 894 * @wmi_hdl: wmi handle 895 * @param_value: parameter value 896 * 897 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 898 */ 899 QDF_STATUS wmi_unified_modem_power_state(void *wmi_hdl, 900 uint32_t param_value) 901 { 902 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 903 904 if (wmi_handle->ops->send_modem_power_state_cmd) 905 return wmi_handle->ops->send_modem_power_state_cmd(wmi_handle, 906 param_value); 907 908 return QDF_STATUS_E_FAILURE; 909 } 910 911 /** 912 * wmi_unified_set_sta_ps_mode() - set sta powersave params in fw 913 * @wmi_hdl: wmi handle 914 * @vdev_id: vdev id 915 * @val: value 916 * 917 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 918 */ 919 QDF_STATUS wmi_unified_set_sta_ps_mode(void *wmi_hdl, 920 uint32_t vdev_id, uint8_t val) 921 { 922 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 923 924 if (wmi_handle->ops->send_set_sta_ps_mode_cmd) 925 return wmi_handle->ops->send_set_sta_ps_mode_cmd(wmi_handle, 926 vdev_id, val); 927 928 return QDF_STATUS_E_FAILURE; 929 } 930 931 /** 932 * wmi_set_mimops() - set MIMO powersave 933 * @wmi_hdl: wmi handle 934 * @vdev_id: vdev id 935 * @value: value 936 * 937 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 938 */ 939 QDF_STATUS wmi_unified_set_mimops(void *wmi_hdl, uint8_t vdev_id, int value) 940 { 941 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 942 943 if (wmi_handle->ops->send_set_mimops_cmd) 944 return wmi_handle->ops->send_set_mimops_cmd(wmi_handle, 945 vdev_id, value); 946 947 return QDF_STATUS_E_FAILURE; 948 } 949 950 /** 951 * wmi_set_smps_params() - set smps params 952 * @wmi_hdl: wmi handle 953 * @vdev_id: vdev id 954 * @value: value 955 * 956 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 957 */ 958 QDF_STATUS wmi_unified_set_smps_params(void *wmi_hdl, uint8_t vdev_id, 959 int value) 960 { 961 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 962 963 if (wmi_handle->ops->send_set_smps_params_cmd) 964 return wmi_handle->ops->send_set_smps_params_cmd(wmi_handle, 965 vdev_id, value); 966 967 return QDF_STATUS_E_FAILURE; 968 } 969 970 971 /** 972 * wmi_set_p2pgo_oppps_req() - send p2p go opp power save request to fw 973 * @wmi_hdl: wmi handle 974 * @opps: p2p opp power save parameters 975 * 976 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 977 */ 978 QDF_STATUS wmi_unified_set_p2pgo_oppps_req(void *wmi_hdl, 979 struct p2p_ps_params *oppps) 980 { 981 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 982 983 if (wmi_handle->ops->send_set_p2pgo_oppps_req_cmd) 984 return wmi_handle->ops->send_set_p2pgo_oppps_req_cmd(wmi_handle, 985 oppps); 986 987 return QDF_STATUS_E_FAILURE; 988 } 989 990 /** 991 * wmi_unified_set_p2pgo_noa_req_cmd() - send p2p go noa request to fw 992 * @wmi_hdl: wmi handle 993 * @noa: p2p power save parameters 994 * 995 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 996 */ 997 QDF_STATUS wmi_unified_set_p2pgo_noa_req_cmd(void *wmi_hdl, 998 struct p2p_ps_params *noa) 999 { 1000 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1001 1002 if (wmi_handle->ops->send_set_p2pgo_noa_req_cmd) 1003 return wmi_handle->ops->send_set_p2pgo_noa_req_cmd(wmi_handle, 1004 noa); 1005 1006 return QDF_STATUS_E_FAILURE; 1007 } 1008 1009 #ifdef CONVERGED_P2P_ENABLE 1010 /** 1011 * wmi_unified_p2p_lo_start_cmd() - send p2p lo start request to fw 1012 * @wmi_hdl: wmi handle 1013 * @param: p2p listen offload start parameters 1014 * 1015 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1016 */ 1017 QDF_STATUS wmi_unified_p2p_lo_start_cmd(void *wmi_hdl, 1018 struct p2p_lo_start *param) 1019 { 1020 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1021 1022 if (!wmi_handle) { 1023 WMI_LOGE("wmi handle is null"); 1024 return QDF_STATUS_E_INVAL; 1025 } 1026 1027 if (wmi_handle->ops->send_p2p_lo_start_cmd) 1028 return wmi_handle->ops->send_p2p_lo_start_cmd(wmi_handle, 1029 param); 1030 1031 return QDF_STATUS_E_FAILURE; 1032 } 1033 1034 /** 1035 * wmi_unified_p2p_lo_stop_cmd() - send p2p lo stop request to fw 1036 * @wmi_hdl: wmi handle 1037 * @vdev_id: vdev id 1038 * 1039 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1040 */ 1041 QDF_STATUS wmi_unified_p2p_lo_stop_cmd(void *wmi_hdl, uint8_t vdev_id) 1042 { 1043 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1044 1045 if (!wmi_handle) { 1046 WMI_LOGE("wmi handle is null"); 1047 return QDF_STATUS_E_INVAL; 1048 } 1049 1050 if (wmi_handle->ops->send_p2p_lo_start_cmd) 1051 return wmi_handle->ops->send_p2p_lo_stop_cmd(wmi_handle, 1052 vdev_id); 1053 1054 return QDF_STATUS_E_FAILURE; 1055 } 1056 #endif /* End of CONVERGED_P2P_ENABLE */ 1057 1058 /** 1059 * wmi_get_temperature() - get pdev temperature req 1060 * @wmi_hdl: wmi handle 1061 * 1062 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1063 */ 1064 QDF_STATUS wmi_unified_get_temperature(void *wmi_hdl) 1065 { 1066 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1067 1068 if (wmi_handle->ops->send_get_temperature_cmd) 1069 return wmi_handle->ops->send_get_temperature_cmd(wmi_handle); 1070 1071 return QDF_STATUS_E_FAILURE; 1072 } 1073 1074 /** 1075 * wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command 1076 * @wmi_hdl: wmi handle 1077 * @end_set_sta_ps_mode_cmd: cmd paramter strcture 1078 * 1079 * This function sets the trigger 1080 * uapsd params such as service interval, delay interval 1081 * and suspend interval which will be used by the firmware 1082 * to send trigger frames periodically when there is no 1083 * traffic on the transmit side. 1084 * 1085 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1086 */ 1087 QDF_STATUS 1088 wmi_unified_set_sta_uapsd_auto_trig_cmd(void *wmi_hdl, 1089 struct sta_uapsd_trig_params *param) 1090 { 1091 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1092 1093 if (wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd) 1094 return wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd(wmi_handle, 1095 param); 1096 1097 return QDF_STATUS_E_FAILURE; 1098 } 1099 1100 #ifdef WLAN_FEATURE_DSRC 1101 QDF_STATUS wmi_unified_ocb_start_timing_advert(struct wmi_unified *wmi_hdl, 1102 struct ocb_timing_advert_param *timing_advert) 1103 { 1104 if (wmi_hdl->ops->send_ocb_start_timing_advert_cmd) 1105 return wmi_hdl->ops->send_ocb_start_timing_advert_cmd(wmi_hdl, 1106 timing_advert); 1107 1108 return QDF_STATUS_E_FAILURE; 1109 } 1110 1111 QDF_STATUS wmi_unified_ocb_stop_timing_advert(struct wmi_unified *wmi_hdl, 1112 struct ocb_timing_advert_param *timing_advert) 1113 { 1114 if (wmi_hdl->ops->send_ocb_stop_timing_advert_cmd) 1115 return wmi_hdl->ops->send_ocb_stop_timing_advert_cmd(wmi_hdl, 1116 timing_advert); 1117 1118 return QDF_STATUS_E_FAILURE; 1119 } 1120 1121 QDF_STATUS wmi_unified_ocb_set_utc_time_cmd(struct wmi_unified *wmi_hdl, 1122 struct ocb_utc_param *utc) 1123 { 1124 if (wmi_hdl->ops->send_ocb_set_utc_time_cmd) 1125 return wmi_hdl->ops->send_ocb_set_utc_time_cmd(wmi_hdl, utc); 1126 1127 return QDF_STATUS_E_FAILURE; 1128 } 1129 1130 QDF_STATUS wmi_unified_ocb_get_tsf_timer(struct wmi_unified *wmi_hdl, 1131 struct ocb_get_tsf_timer_param *req) 1132 { 1133 if (wmi_hdl->ops->send_ocb_get_tsf_timer_cmd) 1134 return wmi_hdl->ops->send_ocb_get_tsf_timer_cmd(wmi_hdl, 1135 req->vdev_id); 1136 1137 return QDF_STATUS_E_FAILURE; 1138 } 1139 1140 QDF_STATUS wmi_unified_dcc_get_stats_cmd(struct wmi_unified *wmi_hdl, 1141 struct ocb_dcc_get_stats_param *get_stats_param) 1142 { 1143 if (wmi_hdl->ops->send_dcc_get_stats_cmd) 1144 return wmi_hdl->ops->send_dcc_get_stats_cmd(wmi_hdl, 1145 get_stats_param); 1146 1147 return QDF_STATUS_E_FAILURE; 1148 } 1149 1150 QDF_STATUS wmi_unified_dcc_clear_stats(struct wmi_unified *wmi_hdl, 1151 struct ocb_dcc_clear_stats_param *clear_stats_param) 1152 { 1153 if (wmi_hdl->ops->send_dcc_clear_stats_cmd) 1154 return wmi_hdl->ops->send_dcc_clear_stats_cmd(wmi_hdl, 1155 clear_stats_param->vdev_id, 1156 clear_stats_param->dcc_stats_bitmap); 1157 1158 return QDF_STATUS_E_FAILURE; 1159 } 1160 1161 QDF_STATUS wmi_unified_dcc_update_ndl(struct wmi_unified *wmi_hdl, 1162 struct ocb_dcc_update_ndl_param *update_ndl_param) 1163 { 1164 if (wmi_hdl->ops->send_dcc_update_ndl_cmd) 1165 return wmi_hdl->ops->send_dcc_update_ndl_cmd(wmi_hdl, 1166 update_ndl_param); 1167 1168 return QDF_STATUS_E_FAILURE; 1169 } 1170 1171 QDF_STATUS wmi_unified_ocb_set_config(struct wmi_unified *wmi_hdl, 1172 struct ocb_config *config) 1173 { 1174 if (wmi_hdl->ops->send_ocb_set_config_cmd) 1175 return wmi_hdl->ops->send_ocb_set_config_cmd(wmi_hdl, 1176 config); 1177 1178 return QDF_STATUS_E_FAILURE; 1179 } 1180 1181 QDF_STATUS 1182 wmi_extract_ocb_set_channel_config_resp(struct wmi_unified *wmi_hdl, 1183 void *evt_buf, 1184 uint32_t *status) 1185 { 1186 if (wmi_hdl->ops->extract_ocb_chan_config_resp) 1187 return wmi_hdl->ops->extract_ocb_chan_config_resp(wmi_hdl, 1188 evt_buf, 1189 status); 1190 1191 return QDF_STATUS_E_FAILURE; 1192 } 1193 1194 QDF_STATUS wmi_extract_ocb_tsf_timer(struct wmi_unified *wmi_hdl, 1195 void *evt_buf, 1196 struct ocb_get_tsf_timer_response *resp) 1197 { 1198 if (wmi_hdl->ops->extract_ocb_tsf_timer) 1199 return wmi_hdl->ops->extract_ocb_tsf_timer(wmi_hdl, 1200 evt_buf, 1201 resp); 1202 1203 return QDF_STATUS_E_FAILURE; 1204 } 1205 1206 QDF_STATUS wmi_extract_dcc_update_ndl_resp(struct wmi_unified *wmi_hdl, 1207 void *evt_buf, struct ocb_dcc_update_ndl_response *resp) 1208 { 1209 if (wmi_hdl->ops->extract_dcc_update_ndl_resp) 1210 return wmi_hdl->ops->extract_dcc_update_ndl_resp(wmi_hdl, 1211 evt_buf, 1212 resp); 1213 1214 return QDF_STATUS_E_FAILURE; 1215 } 1216 1217 QDF_STATUS wmi_extract_dcc_stats(struct wmi_unified *wmi_hdl, 1218 void *evt_buf, 1219 struct ocb_dcc_get_stats_response **resp) 1220 { 1221 if (wmi_hdl->ops->extract_dcc_stats) 1222 return wmi_hdl->ops->extract_dcc_stats(wmi_hdl, 1223 evt_buf, 1224 resp); 1225 1226 return QDF_STATUS_E_FAILURE; 1227 } 1228 #endif 1229 1230 /** 1231 * wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd() - control mcc scheduler 1232 * @wmi_handle: wmi handle 1233 * @mcc_adaptive_scheduler: enable/disable 1234 * 1235 * This function enable/disable mcc adaptive scheduler in fw. 1236 * 1237 * Return: QDF_STATUS_SUCCESS for sucess or error code 1238 */ 1239 QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd( 1240 void *wmi_hdl, uint32_t mcc_adaptive_scheduler, 1241 uint32_t pdev_id) 1242 { 1243 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1244 1245 if (wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd) 1246 return wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd(wmi_handle, 1247 mcc_adaptive_scheduler, pdev_id); 1248 1249 return QDF_STATUS_E_FAILURE; 1250 } 1251 1252 /** 1253 * wmi_unified_set_mcc_channel_time_latency_cmd() - set MCC channel time latency 1254 * @wmi: wmi handle 1255 * @mcc_channel: mcc channel 1256 * @mcc_channel_time_latency: MCC channel time latency. 1257 * 1258 * Currently used to set time latency for an MCC vdev/adapter using operating 1259 * channel of it and channel number. The info is provided run time using 1260 * iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>. 1261 * 1262 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1263 */ 1264 QDF_STATUS wmi_unified_set_mcc_channel_time_latency_cmd(void *wmi_hdl, 1265 uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency) 1266 { 1267 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1268 1269 if (wmi_handle->ops->send_set_mcc_channel_time_latency_cmd) 1270 return wmi_handle->ops->send_set_mcc_channel_time_latency_cmd(wmi_handle, 1271 mcc_channel_freq, 1272 mcc_channel_time_latency); 1273 1274 return QDF_STATUS_E_FAILURE; 1275 } 1276 1277 /** 1278 * wmi_unified_set_mcc_channel_time_quota_cmd() - set MCC channel time quota 1279 * @wmi: wmi handle 1280 * @adapter_1_chan_number: adapter 1 channel number 1281 * @adapter_1_quota: adapter 1 quota 1282 * @adapter_2_chan_number: adapter 2 channel number 1283 * 1284 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1285 */ 1286 QDF_STATUS wmi_unified_set_mcc_channel_time_quota_cmd(void *wmi_hdl, 1287 uint32_t adapter_1_chan_freq, 1288 uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq) 1289 { 1290 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1291 1292 if (wmi_handle->ops->send_set_mcc_channel_time_quota_cmd) 1293 return wmi_handle->ops->send_set_mcc_channel_time_quota_cmd(wmi_handle, 1294 adapter_1_chan_freq, 1295 adapter_1_quota, 1296 adapter_2_chan_freq); 1297 1298 return QDF_STATUS_E_FAILURE; 1299 } 1300 1301 /** 1302 * wmi_unified_set_thermal_mgmt_cmd() - set thermal mgmt command to fw 1303 * @wmi_handle: Pointer to wmi handle 1304 * @thermal_info: Thermal command information 1305 * 1306 * This function sends the thermal management command 1307 * to the firmware 1308 * 1309 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1310 */ 1311 QDF_STATUS wmi_unified_set_thermal_mgmt_cmd(void *wmi_hdl, 1312 struct thermal_cmd_params *thermal_info) 1313 { 1314 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1315 1316 if (wmi_handle->ops->send_set_thermal_mgmt_cmd) 1317 return wmi_handle->ops->send_set_thermal_mgmt_cmd(wmi_handle, 1318 thermal_info); 1319 1320 return QDF_STATUS_E_FAILURE; 1321 } 1322 1323 1324 /** 1325 * wmi_unified_lro_config_cmd() - process the LRO config command 1326 * @wmi: Pointer to wmi handle 1327 * @wmi_lro_cmd: Pointer to LRO configuration parameters 1328 * 1329 * This function sends down the LRO configuration parameters to 1330 * the firmware to enable LRO, sets the TCP flags and sets the 1331 * seed values for the toeplitz hash generation 1332 * 1333 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1334 */ 1335 QDF_STATUS wmi_unified_lro_config_cmd(void *wmi_hdl, 1336 struct wmi_lro_config_cmd_t *wmi_lro_cmd) 1337 { 1338 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1339 1340 if (wmi_handle->ops->send_lro_config_cmd) 1341 return wmi_handle->ops->send_lro_config_cmd(wmi_handle, 1342 wmi_lro_cmd); 1343 1344 return QDF_STATUS_E_FAILURE; 1345 } 1346 1347 #ifdef CONFIG_MCL 1348 /** 1349 * wmi_unified_peer_rate_report_cmd() - process the peer rate report command 1350 * @wmi_hdl: Pointer to wmi handle 1351 * @rate_report_params: Pointer to peer rate report parameters 1352 * 1353 * 1354 * Return: QDF_STATUS_SUCCESS for success otherwise failure 1355 */ 1356 QDF_STATUS wmi_unified_peer_rate_report_cmd(void *wmi_hdl, 1357 struct wmi_peer_rate_report_params *rate_report_params) 1358 { 1359 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1360 1361 if (wmi_handle->ops->send_peer_rate_report_cmd) 1362 return wmi_handle->ops->send_peer_rate_report_cmd(wmi_handle, 1363 rate_report_params); 1364 1365 return QDF_STATUS_E_FAILURE; 1366 } 1367 1368 /** 1369 * wmi_unified_bcn_buf_ll_cmd() - prepare and send beacon buffer to fw for LL 1370 * @wmi_hdl: wmi handle 1371 * @param: bcn ll cmd parameter 1372 * 1373 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1374 */ 1375 QDF_STATUS wmi_unified_bcn_buf_ll_cmd(void *wmi_hdl, 1376 wmi_bcn_send_from_host_cmd_fixed_param *param) 1377 { 1378 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1379 1380 if (wmi_handle->ops->send_bcn_buf_ll_cmd) 1381 return wmi_handle->ops->send_bcn_buf_ll_cmd(wmi_handle, 1382 param); 1383 1384 return QDF_STATUS_E_FAILURE; 1385 } 1386 #endif 1387 1388 /** 1389 * wmi_unified_set_sta_sa_query_param_cmd() - set sta sa query parameters 1390 * @wmi_hdl: wmi handle 1391 * @vdev_id: vdev id 1392 * @max_retries: max retries 1393 * @retry_interval: retry interval 1394 * This function sets sta query related parameters in fw. 1395 * 1396 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1397 */ 1398 1399 QDF_STATUS wmi_unified_set_sta_sa_query_param_cmd(void *wmi_hdl, 1400 uint8_t vdev_id, uint32_t max_retries, 1401 uint32_t retry_interval) 1402 { 1403 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1404 1405 if (wmi_handle->ops->send_set_sta_sa_query_param_cmd) 1406 return wmi_handle->ops->send_set_sta_sa_query_param_cmd(wmi_handle, 1407 vdev_id, max_retries, 1408 retry_interval); 1409 1410 return QDF_STATUS_E_FAILURE; 1411 } 1412 1413 /** 1414 * wmi_unified_set_sta_keep_alive_cmd() - set sta keep alive parameters 1415 * @wmi_hdl: wmi handle 1416 * @params: sta keep alive parameter 1417 * 1418 * This function sets keep alive related parameters in fw. 1419 * 1420 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1421 */ 1422 QDF_STATUS wmi_unified_set_sta_keep_alive_cmd(void *wmi_hdl, 1423 struct sta_params *params) 1424 { 1425 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1426 1427 if (wmi_handle->ops->send_set_sta_keep_alive_cmd) 1428 return wmi_handle->ops->send_set_sta_keep_alive_cmd(wmi_handle, 1429 params); 1430 1431 return QDF_STATUS_E_FAILURE; 1432 } 1433 1434 /** 1435 * wmi_unified_vdev_set_gtx_cfg_cmd() - set GTX params 1436 * @wmi_hdl: wmi handle 1437 * @if_id: vdev id 1438 * @gtx_info: GTX config params 1439 * 1440 * This function set GTX related params in firmware. 1441 * 1442 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1443 */ 1444 QDF_STATUS wmi_unified_vdev_set_gtx_cfg_cmd(void *wmi_hdl, uint32_t if_id, 1445 struct wmi_gtx_config *gtx_info) 1446 { 1447 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1448 1449 if (wmi_handle->ops->send_vdev_set_gtx_cfg_cmd) 1450 return wmi_handle->ops->send_vdev_set_gtx_cfg_cmd(wmi_handle, 1451 if_id, gtx_info); 1452 1453 return QDF_STATUS_E_FAILURE; 1454 } 1455 1456 /** 1457 * wmi_unified_process_update_edca_param() - update EDCA params 1458 * @wmi_hdl: wmi handle 1459 * @vdev_id: vdev id. 1460 * @wmm_vparams: edca parameters 1461 * 1462 * This function updates EDCA parameters to the target 1463 * 1464 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1465 */ 1466 QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl, 1467 uint8_t vdev_id, 1468 struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]) 1469 { 1470 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1471 1472 if (wmi_handle->ops->send_process_update_edca_param_cmd) 1473 return wmi_handle->ops->send_process_update_edca_param_cmd(wmi_handle, 1474 vdev_id, wmm_vparams); 1475 1476 return QDF_STATUS_E_FAILURE; 1477 } 1478 1479 /** 1480 * wmi_unified_probe_rsp_tmpl_send_cmd() - send probe response template to fw 1481 * @wmi_hdl: wmi handle 1482 * @vdev_id: vdev id 1483 * @probe_rsp_info: probe response info 1484 * 1485 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1486 */ 1487 QDF_STATUS wmi_unified_probe_rsp_tmpl_send_cmd(void *wmi_hdl, 1488 uint8_t vdev_id, 1489 struct wmi_probe_resp_params *probe_rsp_info) 1490 { 1491 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1492 1493 if (wmi_handle->ops->send_probe_rsp_tmpl_send_cmd) 1494 return wmi_handle->ops->send_probe_rsp_tmpl_send_cmd(wmi_handle, 1495 vdev_id, probe_rsp_info); 1496 1497 return QDF_STATUS_E_FAILURE; 1498 } 1499 1500 /** 1501 * wmi_unified_setup_install_key_cmd - send key to install to fw 1502 * @wmi_hdl: wmi handle 1503 * @key_params: key parameters 1504 * 1505 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1506 */ 1507 QDF_STATUS wmi_unified_setup_install_key_cmd(void *wmi_hdl, 1508 struct set_key_params *key_params) 1509 { 1510 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1511 1512 if (wmi_handle->ops->send_setup_install_key_cmd) 1513 return wmi_handle->ops->send_setup_install_key_cmd(wmi_handle, 1514 key_params); 1515 1516 return QDF_STATUS_E_FAILURE; 1517 } 1518 1519 /** 1520 * wmi_unified_p2p_go_set_beacon_ie_cmd() - set beacon IE for p2p go 1521 * @wma_handle: wma handle 1522 * @vdev_id: vdev id 1523 * @p2p_ie: p2p IE 1524 * 1525 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1526 */ 1527 QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(void *wmi_hdl, 1528 A_UINT32 vdev_id, uint8_t *p2p_ie) 1529 { 1530 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1531 1532 if (wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd) 1533 return wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd(wmi_handle, 1534 vdev_id, p2p_ie); 1535 1536 return QDF_STATUS_E_FAILURE; 1537 } 1538 1539 /** 1540 * wmi_unified_set_gateway_params_cmd() - set gateway parameters 1541 * @wmi_hdl: wmi handle 1542 * @req: gateway parameter update request structure 1543 * 1544 * This function reads the incoming @req and fill in the destination 1545 * WMI structure and sends down the gateway configs down to the firmware 1546 * 1547 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures; 1548 * error number otherwise 1549 */ 1550 QDF_STATUS wmi_unified_set_gateway_params_cmd(void *wmi_hdl, 1551 struct gateway_update_req_param *req) 1552 { 1553 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1554 1555 if (wmi_handle->ops->send_set_gateway_params_cmd) 1556 return wmi_handle->ops->send_set_gateway_params_cmd(wmi_handle, 1557 req); 1558 1559 return QDF_STATUS_E_FAILURE; 1560 } 1561 1562 /** 1563 * wmi_unified_set_rssi_monitoring_cmd() - set rssi monitoring 1564 * @wmi_hdl: wmi handle 1565 * @req: rssi monitoring request structure 1566 * 1567 * This function reads the incoming @req and fill in the destination 1568 * WMI structure and send down the rssi monitoring configs down to the firmware 1569 * 1570 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures; 1571 * error number otherwise 1572 */ 1573 QDF_STATUS wmi_unified_set_rssi_monitoring_cmd(void *wmi_hdl, 1574 struct rssi_monitor_param *req) 1575 { 1576 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1577 1578 if (wmi_handle->ops->send_set_rssi_monitoring_cmd) 1579 return wmi_handle->ops->send_set_rssi_monitoring_cmd(wmi_handle, 1580 req); 1581 1582 return QDF_STATUS_E_FAILURE; 1583 } 1584 1585 /** 1586 * wmi_unified_scan_probe_setoui_cmd() - set scan probe OUI 1587 * @wmi_hdl: wmi handle 1588 * @psetoui: OUI parameters 1589 * 1590 * set scan probe OUI parameters in firmware 1591 * 1592 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1593 */ 1594 QDF_STATUS wmi_unified_scan_probe_setoui_cmd(void *wmi_hdl, 1595 struct scan_mac_oui *psetoui) 1596 { 1597 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1598 1599 if (wmi_handle->ops->send_scan_probe_setoui_cmd) 1600 return wmi_handle->ops->send_scan_probe_setoui_cmd(wmi_handle, 1601 psetoui); 1602 1603 return QDF_STATUS_E_FAILURE; 1604 } 1605 1606 /** 1607 * wmi_unified_reset_passpoint_network_list_cmd() - reset passpoint network list 1608 * @wmi_hdl: wmi handle 1609 * @req: passpoint network request structure 1610 * 1611 * This function sends down WMI command with network id set to wildcard id. 1612 * firmware shall clear all the config entries 1613 * 1614 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1615 */ 1616 QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(void *wmi_hdl, 1617 struct wifi_passpoint_req_param *req) 1618 { 1619 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1620 1621 if (wmi_handle->ops->send_reset_passpoint_network_list_cmd) 1622 return wmi_handle->ops->send_reset_passpoint_network_list_cmd(wmi_handle, 1623 req); 1624 1625 return QDF_STATUS_E_FAILURE; 1626 } 1627 1628 /** 1629 * wmi_unified_set_passpoint_network_list_cmd() - set passpoint network list 1630 * @wmi_hdl: wmi handle 1631 * @req: passpoint network request structure 1632 * 1633 * This function reads the incoming @req and fill in the destination 1634 * WMI structure and send down the passpoint configs down to the firmware 1635 * 1636 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1637 */ 1638 QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(void *wmi_hdl, 1639 struct wifi_passpoint_req_param *req) 1640 { 1641 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1642 1643 if (wmi_handle->ops->send_set_passpoint_network_list_cmd) 1644 return wmi_handle->ops->send_set_passpoint_network_list_cmd(wmi_handle, 1645 req); 1646 1647 return QDF_STATUS_E_FAILURE; 1648 } 1649 1650 /** wmi_unified_set_epno_network_list_cmd() - set epno network list 1651 * @wmi_hdl: wmi handle 1652 * @req: epno config params request structure 1653 * 1654 * This function reads the incoming epno config request structure 1655 * and constructs the WMI message to the firmware. 1656 * 1657 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 1658 * error number otherwise 1659 */ 1660 QDF_STATUS wmi_unified_set_epno_network_list_cmd(void *wmi_hdl, 1661 struct wifi_enhanched_pno_params *req) 1662 { 1663 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1664 1665 if (wmi_handle->ops->send_set_epno_network_list_cmd) 1666 return wmi_handle->ops->send_set_epno_network_list_cmd(wmi_handle, 1667 req); 1668 1669 return QDF_STATUS_E_FAILURE; 1670 } 1671 1672 #ifdef CONFIG_MCL 1673 /** 1674 * wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters 1675 * @wmi_hdl: wmi handle 1676 * @scan_cmd_fp: scan related parameters 1677 * @roam_req: roam related parameters 1678 * 1679 * This function reads the incoming @roam_req and fill in the destination 1680 * WMI structure and send down the roam scan configs down to the firmware 1681 * 1682 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1683 */ 1684 QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(void *wmi_hdl, 1685 wmi_start_scan_cmd_fixed_param *scan_cmd_fp, 1686 struct roam_offload_scan_params *roam_req) 1687 { 1688 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1689 1690 if (wmi_handle->ops->send_roam_scan_offload_mode_cmd) 1691 return wmi_handle->ops->send_roam_scan_offload_mode_cmd( 1692 wmi_handle, scan_cmd_fp, roam_req); 1693 1694 return QDF_STATUS_E_FAILURE; 1695 } 1696 #endif 1697 1698 /** 1699 * wmi_unified_roam_scan_offload_rssi_thresh_cmd() - set roam scan rssi 1700 * parameters 1701 * @wmi_hdl: wmi handle 1702 * @roam_req: roam rssi related parameters 1703 * 1704 * This function reads the incoming @roam_req and fill in the destination 1705 * WMI structure and send down the roam scan rssi configs down to the firmware 1706 * 1707 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1708 */ 1709 QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(void *wmi_hdl, 1710 struct roam_offload_scan_rssi_params 1711 *roam_req) 1712 { 1713 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1714 1715 if (wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd) 1716 return wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd( 1717 wmi_handle, roam_req); 1718 1719 return QDF_STATUS_E_FAILURE; 1720 } 1721 1722 QDF_STATUS wmi_unified_roam_mawc_params_cmd( 1723 void *wmi_hdl, struct wmi_mawc_roam_params *params) 1724 { 1725 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1726 1727 if (wmi_handle->ops->send_roam_mawc_params_cmd) 1728 return wmi_handle->ops->send_roam_mawc_params_cmd( 1729 wmi_handle, params); 1730 1731 return QDF_STATUS_E_FAILURE; 1732 } 1733 /** 1734 * wmi_unified_roam_scan_filter_cmd() - send roam scan whitelist, 1735 * blacklist and preferred list 1736 * @wmi_hdl: wmi handle 1737 * @roam_req: roam scan lists related parameters 1738 * 1739 * This function reads the incoming @roam_req and fill in the destination 1740 * WMI structure and send down the different roam scan lists down to the fw 1741 * 1742 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1743 */ 1744 QDF_STATUS wmi_unified_roam_scan_filter_cmd(void *wmi_hdl, 1745 struct roam_scan_filter_params *roam_req) 1746 { 1747 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1748 1749 if (wmi_handle->ops->send_roam_scan_filter_cmd) 1750 return wmi_handle->ops->send_roam_scan_filter_cmd( 1751 wmi_handle, roam_req); 1752 1753 return QDF_STATUS_E_FAILURE; 1754 } 1755 1756 /** wmi_unified_ipa_offload_control_cmd() - ipa offload control parameter 1757 * @wmi_hdl: wmi handle 1758 * @ipa_offload: ipa offload control parameter 1759 * 1760 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 1761 * error number otherwise 1762 */ 1763 QDF_STATUS wmi_unified_ipa_offload_control_cmd(void *wmi_hdl, 1764 struct ipa_offload_control_params *ipa_offload) 1765 { 1766 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1767 1768 if (wmi_handle->ops->send_ipa_offload_control_cmd) 1769 return wmi_handle->ops->send_ipa_offload_control_cmd(wmi_handle, 1770 ipa_offload); 1771 1772 return QDF_STATUS_E_FAILURE; 1773 } 1774 1775 /** 1776 * wmi_unified_extscan_get_capabilities_cmd() - extscan get capabilities 1777 * @wmi_hdl: wmi handle 1778 * @pgetcapab: get capabilities params 1779 * 1780 * This function send request to fw to get extscan capabilities. 1781 * 1782 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1783 */ 1784 QDF_STATUS wmi_unified_extscan_get_capabilities_cmd(void *wmi_hdl, 1785 struct extscan_capabilities_params *pgetcapab) 1786 { 1787 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1788 1789 if (wmi_handle->ops->send_extscan_get_capabilities_cmd) 1790 return wmi_handle->ops->send_extscan_get_capabilities_cmd(wmi_handle, 1791 pgetcapab); 1792 1793 return QDF_STATUS_E_FAILURE; 1794 } 1795 1796 /** 1797 * wmi_unified_extscan_get_cached_results_cmd() - extscan get cached results 1798 * @wmi_hdl: wmi handle 1799 * @pcached_results: cached results parameters 1800 * 1801 * This function send request to fw to get cached results. 1802 * 1803 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1804 */ 1805 QDF_STATUS wmi_unified_extscan_get_cached_results_cmd(void *wmi_hdl, 1806 struct extscan_cached_result_params *pcached_results) 1807 { 1808 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1809 1810 if (wmi_handle->ops->send_extscan_get_cached_results_cmd) 1811 return wmi_handle->ops->send_extscan_get_cached_results_cmd(wmi_handle, 1812 pcached_results); 1813 1814 return QDF_STATUS_E_FAILURE; 1815 } 1816 1817 /** 1818 * wmi_unified_extscan_stop_change_monitor_cmd() - send stop change monitor cmd 1819 * @wmi_hdl: wmi handle 1820 * @reset_req: Reset change request params 1821 * 1822 * This function sends stop change monitor request to fw. 1823 * 1824 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1825 */ 1826 QDF_STATUS wmi_unified_extscan_stop_change_monitor_cmd(void *wmi_hdl, 1827 struct extscan_capabilities_reset_params *reset_req) 1828 { 1829 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1830 1831 if (wmi_handle->ops->send_extscan_stop_change_monitor_cmd) 1832 return wmi_handle->ops->send_extscan_stop_change_monitor_cmd(wmi_handle, 1833 reset_req); 1834 1835 return QDF_STATUS_E_FAILURE; 1836 } 1837 1838 1839 1840 /** 1841 * wmi_unified_extscan_start_change_monitor_cmd() - start change monitor cmd 1842 * @wmi_hdl: wmi handle 1843 * @psigchange: change monitor request params 1844 * 1845 * This function sends start change monitor request to fw. 1846 * 1847 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1848 */ 1849 QDF_STATUS wmi_unified_extscan_start_change_monitor_cmd(void *wmi_hdl, 1850 struct extscan_set_sig_changereq_params * 1851 psigchange) 1852 { 1853 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1854 1855 if (wmi_handle->ops->send_extscan_start_change_monitor_cmd) 1856 return wmi_handle->ops->send_extscan_start_change_monitor_cmd(wmi_handle, 1857 psigchange); 1858 1859 return QDF_STATUS_E_FAILURE; 1860 } 1861 1862 /** 1863 * wmi_unified_extscan_stop_hotlist_monitor_cmd() - stop hotlist monitor 1864 * @wmi_hdl: wmi handle 1865 * @photlist_reset: hotlist reset params 1866 * 1867 * This function configures hotlist monitor to stop in fw. 1868 * 1869 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1870 */ 1871 QDF_STATUS wmi_unified_extscan_stop_hotlist_monitor_cmd(void *wmi_hdl, 1872 struct extscan_bssid_hotlist_reset_params *photlist_reset) 1873 { 1874 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1875 1876 if (wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd) 1877 return wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd(wmi_handle, 1878 photlist_reset); 1879 1880 return QDF_STATUS_E_FAILURE; 1881 } 1882 1883 /** 1884 * wmi_unified_stop_extscan_cmd() - stop extscan command to fw. 1885 * @wmi_hdl: wmi handle 1886 * @pstopcmd: stop scan command request params 1887 * 1888 * This function sends stop extscan request to fw. 1889 * 1890 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1891 */ 1892 QDF_STATUS wmi_unified_stop_extscan_cmd(void *wmi_hdl, 1893 struct extscan_stop_req_params *pstopcmd) 1894 { 1895 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1896 1897 if (wmi_handle->ops->send_stop_extscan_cmd) 1898 return wmi_handle->ops->send_stop_extscan_cmd(wmi_handle, 1899 pstopcmd); 1900 1901 return QDF_STATUS_E_FAILURE; 1902 } 1903 1904 /** 1905 * wmi_unified_start_extscan_cmd() - start extscan command to fw. 1906 * @wmi_hdl: wmi handle 1907 * @pstart: scan command request params 1908 * 1909 * This function sends start extscan request to fw. 1910 * 1911 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1912 */ 1913 QDF_STATUS wmi_unified_start_extscan_cmd(void *wmi_hdl, 1914 struct wifi_scan_cmd_req_params *pstart) 1915 { 1916 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1917 1918 if (wmi_handle->ops->send_start_extscan_cmd) 1919 return wmi_handle->ops->send_start_extscan_cmd(wmi_handle, 1920 pstart); 1921 1922 return QDF_STATUS_E_FAILURE; 1923 } 1924 1925 /** 1926 * wmi_unified_plm_stop_cmd() - plm stop request 1927 * @wmi_hdl: wmi handle 1928 * @plm: plm request parameters 1929 * 1930 * This function request FW to stop PLM. 1931 * 1932 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1933 */ 1934 QDF_STATUS wmi_unified_plm_stop_cmd(void *wmi_hdl, 1935 const struct plm_req_params *plm) 1936 { 1937 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1938 1939 if (wmi_handle->ops->send_plm_stop_cmd) 1940 return wmi_handle->ops->send_plm_stop_cmd(wmi_handle, 1941 plm); 1942 1943 return QDF_STATUS_E_FAILURE; 1944 } 1945 1946 /** 1947 * wmi_unified_plm_start_cmd() - plm start request 1948 * @wmi_hdl: wmi handle 1949 * @plm: plm request parameters 1950 * 1951 * This function request FW to start PLM. 1952 * 1953 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1954 */ 1955 QDF_STATUS wmi_unified_plm_start_cmd(void *wmi_hdl, 1956 const struct plm_req_params *plm, 1957 uint32_t *gchannel_list) 1958 { 1959 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1960 1961 if (wmi_handle->ops->send_plm_start_cmd) 1962 return wmi_handle->ops->send_plm_start_cmd(wmi_handle, 1963 plm, gchannel_list); 1964 1965 return QDF_STATUS_E_FAILURE; 1966 } 1967 1968 /** 1969 * send_pno_stop_cmd() - PNO stop request 1970 * @wmi_hdl: wmi handle 1971 * @vdev_id: vdev id 1972 * 1973 * This function request FW to stop ongoing PNO operation. 1974 * 1975 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1976 */ 1977 QDF_STATUS wmi_unified_pno_stop_cmd(void *wmi_hdl, uint8_t vdev_id) 1978 { 1979 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1980 1981 if (wmi_handle->ops->send_pno_stop_cmd) 1982 return wmi_handle->ops->send_pno_stop_cmd(wmi_handle, 1983 vdev_id); 1984 1985 return QDF_STATUS_E_FAILURE; 1986 } 1987 1988 /** 1989 * wmi_unified_pno_start_cmd() - PNO start request 1990 * @wmi_hdl: wmi handle 1991 * @pno: PNO request 1992 * 1993 * This function request FW to start PNO request. 1994 * Request: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1995 */ 1996 #ifdef FEATURE_WLAN_SCAN_PNO 1997 QDF_STATUS wmi_unified_pno_start_cmd(void *wmi_hdl, 1998 struct pno_scan_req_params *pno) 1999 { 2000 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2001 2002 if (wmi_handle->ops->send_pno_start_cmd) 2003 return wmi_handle->ops->send_pno_start_cmd(wmi_handle, 2004 pno); 2005 2006 return QDF_STATUS_E_FAILURE; 2007 } 2008 #endif 2009 2010 /** 2011 * wmi_unified_nlo_mawc_cmd() - NLO MAWC cmd configuration 2012 * @wmi_hdl: wmi handle 2013 * @params: Configuration parameters 2014 * 2015 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2016 */ 2017 QDF_STATUS wmi_unified_nlo_mawc_cmd(void *wmi_hdl, 2018 struct nlo_mawc_params *params) 2019 { 2020 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2021 2022 if (wmi_handle->ops->send_nlo_mawc_cmd) 2023 return wmi_handle->ops->send_nlo_mawc_cmd(wmi_handle, params); 2024 2025 return QDF_STATUS_E_FAILURE; 2026 } 2027 2028 /* wmi_unified_set_ric_req_cmd() - set ric request element 2029 * @wmi_hdl: wmi handle 2030 * @msg: message 2031 * @is_add_ts: is addts required 2032 * 2033 * This function sets ric request element for 11r roaming. 2034 * 2035 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2036 */ 2037 QDF_STATUS wmi_unified_set_ric_req_cmd(void *wmi_hdl, void *msg, 2038 uint8_t is_add_ts) 2039 { 2040 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2041 2042 if (wmi_handle->ops->send_set_ric_req_cmd) 2043 return wmi_handle->ops->send_set_ric_req_cmd(wmi_handle, msg, 2044 is_add_ts); 2045 2046 return QDF_STATUS_E_FAILURE; 2047 } 2048 2049 /** 2050 * wmi_unified_process_ll_stats_clear_cmd() - clear link layer stats 2051 * @wmi_hdl: wmi handle 2052 * @clear_req: ll stats clear request command params 2053 * @addr: mac address 2054 * 2055 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2056 */ 2057 QDF_STATUS wmi_unified_process_ll_stats_clear_cmd(void *wmi_hdl, 2058 const struct ll_stats_clear_params *clear_req, 2059 uint8_t addr[IEEE80211_ADDR_LEN]) 2060 { 2061 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2062 2063 if (wmi_handle->ops->send_process_ll_stats_clear_cmd) 2064 return wmi_handle->ops->send_process_ll_stats_clear_cmd(wmi_handle, 2065 clear_req, addr); 2066 2067 return QDF_STATUS_E_FAILURE; 2068 } 2069 2070 /** 2071 * wmi_unified_process_ll_stats_get_cmd() - link layer stats get request 2072 * @wmi_hdl:wmi handle 2073 * @get_req:ll stats get request command params 2074 * 2075 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2076 */ 2077 QDF_STATUS wmi_unified_process_ll_stats_get_cmd(void *wmi_hdl, 2078 const struct ll_stats_get_params *get_req, 2079 uint8_t addr[IEEE80211_ADDR_LEN]) 2080 { 2081 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2082 2083 if (wmi_handle->ops->send_process_ll_stats_get_cmd) 2084 return wmi_handle->ops->send_process_ll_stats_get_cmd(wmi_handle, 2085 get_req, addr); 2086 2087 return QDF_STATUS_E_FAILURE; 2088 } 2089 2090 /** 2091 * wmi_unified_congestion_request_cmd() - send request to fw to get CCA 2092 * @wmi_hdl: wma handle 2093 * @vdev_id: vdev id 2094 * 2095 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2096 */ 2097 QDF_STATUS wmi_unified_congestion_request_cmd(void *wmi_hdl, 2098 uint8_t vdev_id) 2099 { 2100 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2101 2102 if (wmi_handle->ops->send_congestion_cmd) 2103 return wmi_handle->ops->send_congestion_cmd(wmi_handle, 2104 vdev_id); 2105 2106 return QDF_STATUS_E_FAILURE; 2107 } 2108 2109 /** 2110 * wmi_unified_process_ll_stats_set_cmd() - link layer stats set request 2111 * @wmi_handle: wmi handle 2112 * @set_req: ll stats set request command params 2113 * 2114 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2115 */ 2116 QDF_STATUS wmi_unified_process_ll_stats_set_cmd(void *wmi_hdl, 2117 const struct ll_stats_set_params *set_req) 2118 { 2119 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2120 2121 if (wmi_handle->ops->send_process_ll_stats_set_cmd) 2122 return wmi_handle->ops->send_process_ll_stats_set_cmd(wmi_handle, 2123 set_req); 2124 2125 return QDF_STATUS_E_FAILURE; 2126 } 2127 2128 /** 2129 * wmi_unified_snr_request_cmd() - send request to fw to get RSSI stats 2130 * @wmi_handle: wmi handle 2131 * @rssi_req: get RSSI request 2132 * 2133 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2134 */ 2135 QDF_STATUS wmi_unified_snr_request_cmd(void *wmi_hdl) 2136 { 2137 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2138 2139 if (wmi_handle->ops->send_snr_request_cmd) 2140 return wmi_handle->ops->send_snr_request_cmd(wmi_handle); 2141 2142 return QDF_STATUS_E_FAILURE; 2143 } 2144 2145 /** 2146 * wmi_unified_snr_cmd() - get RSSI from fw 2147 * @wmi_handle: wmi handle 2148 * @vdev_id: vdev id 2149 * 2150 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2151 */ 2152 QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id) 2153 { 2154 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2155 2156 if (wmi_handle->ops->send_snr_cmd) 2157 return wmi_handle->ops->send_snr_cmd(wmi_handle, 2158 vdev_id); 2159 2160 return QDF_STATUS_E_FAILURE; 2161 } 2162 2163 /** 2164 * wmi_unified_link_status_req_cmd() - process link status request from UMAC 2165 * @wmi_handle: wmi handle 2166 * @link_status: get link params 2167 * 2168 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2169 */ 2170 QDF_STATUS wmi_unified_link_status_req_cmd(void *wmi_hdl, 2171 struct link_status_params *link_status) 2172 { 2173 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2174 2175 if (wmi_handle->ops->send_link_status_req_cmd) 2176 return wmi_handle->ops->send_link_status_req_cmd(wmi_handle, 2177 link_status); 2178 2179 return QDF_STATUS_E_FAILURE; 2180 } 2181 2182 /** 2183 * wmi_unified_process_dhcp_ind() - process dhcp indication from SME 2184 * @wmi_handle: wmi handle 2185 * @ta_dhcp_ind: DHCP indication parameter 2186 * 2187 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2188 */ 2189 #ifdef CONFIG_MCL 2190 QDF_STATUS wmi_unified_process_dhcp_ind(void *wmi_hdl, 2191 wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind) 2192 { 2193 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2194 2195 if (wmi_handle->ops->send_process_dhcp_ind_cmd) 2196 return wmi_handle->ops->send_process_dhcp_ind_cmd(wmi_handle, 2197 ta_dhcp_ind); 2198 2199 return QDF_STATUS_E_FAILURE; 2200 } 2201 2202 /** 2203 * wmi_unified_get_link_speed_cmd() -send command to get linkspeed 2204 * @wmi_handle: wmi handle 2205 * @pLinkSpeed: link speed info 2206 * 2207 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2208 */ 2209 QDF_STATUS wmi_unified_get_link_speed_cmd(void *wmi_hdl, 2210 wmi_mac_addr peer_macaddr) 2211 { 2212 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2213 2214 if (wmi_handle->ops->send_get_link_speed_cmd) 2215 return wmi_handle->ops->send_get_link_speed_cmd(wmi_handle, 2216 peer_macaddr); 2217 2218 return QDF_STATUS_E_FAILURE; 2219 } 2220 #endif 2221 2222 #ifdef WLAN_SUPPORT_GREEN_AP 2223 /** 2224 * wmi_unified_egap_conf_params_cmd() - send wmi cmd of egap configuration params 2225 * @wmi_handle: wmi handler 2226 * @egap_params: pointer to egap_params 2227 * 2228 * Return: 0 for success, otherwise appropriate error code 2229 */ 2230 QDF_STATUS wmi_unified_egap_conf_params_cmd(void *wmi_hdl, 2231 struct wlan_green_ap_egap_params *egap_params) 2232 { 2233 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2234 2235 if (wmi_handle->ops->send_egap_conf_params_cmd) 2236 return wmi_handle->ops->send_egap_conf_params_cmd(wmi_handle, 2237 egap_params); 2238 2239 return QDF_STATUS_E_FAILURE; 2240 } 2241 #endif 2242 2243 /** 2244 * wmi_unified_fw_profiling_data_cmd() - send FW profiling cmd to WLAN FW 2245 * @wmi_handl: wmi handle 2246 * @cmd: Profiling command index 2247 * @value1: parameter1 value 2248 * @value2: parameter2 value 2249 * 2250 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2251 */ 2252 QDF_STATUS wmi_unified_fw_profiling_data_cmd(void *wmi_hdl, 2253 uint32_t cmd, uint32_t value1, uint32_t value2) 2254 { 2255 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2256 2257 if (wmi_handle->ops->send_fw_profiling_cmd) 2258 return wmi_handle->ops->send_fw_profiling_cmd(wmi_handle, 2259 cmd, value1, value2); 2260 2261 return QDF_STATUS_E_FAILURE; 2262 } 2263 2264 /** 2265 * wmi_unified_wow_timer_pattern_cmd() - set timer pattern tlv, so that firmware 2266 * will wake up host after specified time is elapsed 2267 * @wmi_handle: wmi handle 2268 * @vdev_id: vdev id 2269 * @cookie: value to identify reason why host set up wake call. 2270 * @time: time in ms 2271 * 2272 * Return: QDF status 2273 */ 2274 QDF_STATUS wmi_unified_wow_timer_pattern_cmd(void *wmi_hdl, uint8_t vdev_id, 2275 uint32_t cookie, uint32_t time) 2276 { 2277 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2278 2279 if (wmi_handle->ops->send_wow_timer_pattern_cmd) 2280 return wmi_handle->ops->send_wow_timer_pattern_cmd(wmi_handle, 2281 vdev_id, cookie, time); 2282 2283 return QDF_STATUS_E_FAILURE; 2284 } 2285 2286 /** 2287 * wmi_unified_nat_keepalive_en_cmd() - enable NAT keepalive filter 2288 * @wmi_handle: wmi handle 2289 * @vdev_id: vdev id 2290 * 2291 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2292 */ 2293 QDF_STATUS wmi_unified_nat_keepalive_en_cmd(void *wmi_hdl, uint8_t vdev_id) 2294 { 2295 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2296 2297 if (wmi_handle->ops->send_nat_keepalive_en_cmd) 2298 return wmi_handle->ops->send_nat_keepalive_en_cmd(wmi_handle, 2299 vdev_id); 2300 2301 return QDF_STATUS_E_FAILURE; 2302 } 2303 2304 QDF_STATUS wmi_unified_wlm_latency_level_cmd(void *wmi_hdl, 2305 struct wlm_latency_level_param *param) 2306 { 2307 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2308 2309 if (wmi_handle->ops->send_wlm_latency_level_cmd) 2310 return wmi_handle->ops->send_wlm_latency_level_cmd(wmi_handle, 2311 param); 2312 2313 return QDF_STATUS_E_FAILURE; 2314 } 2315 2316 /** 2317 * wmi_unified_csa_offload_enable() - send CSA offload enable command 2318 * @wmi_hdl: wmi handle 2319 * @vdev_id: vdev id 2320 * 2321 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2322 */ 2323 QDF_STATUS wmi_unified_csa_offload_enable(void *wmi_hdl, uint8_t vdev_id) 2324 { 2325 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2326 2327 if (wmi_handle->ops->send_csa_offload_enable_cmd) 2328 return wmi_handle->ops->send_csa_offload_enable_cmd(wmi_handle, 2329 vdev_id); 2330 2331 return QDF_STATUS_E_FAILURE; 2332 } 2333 2334 #ifdef WLAN_FEATURE_CIF_CFR 2335 QDF_STATUS wmi_unified_oem_dma_ring_cfg(void *wmi_hdl, 2336 wmi_oem_dma_ring_cfg_req_fixed_param *cfg) 2337 { 2338 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2339 2340 if (wmi_handle->ops->send_start_oem_data_cmd) 2341 return wmi_handle->ops->send_oem_dma_cfg_cmd(wmi_handle, cfg); 2342 2343 return QDF_STATUS_E_FAILURE; 2344 } 2345 #endif 2346 2347 QDF_STATUS wmi_unified_dbr_ring_cfg(void *wmi_hdl, 2348 struct direct_buf_rx_cfg_req *cfg) 2349 { 2350 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2351 2352 if (wmi_handle->ops->send_dbr_cfg_cmd) 2353 return wmi_handle->ops->send_dbr_cfg_cmd(wmi_handle, cfg); 2354 2355 return QDF_STATUS_E_FAILURE; 2356 } 2357 2358 /** 2359 * wmi_unified_start_oem_data_cmd() - start OEM data request to target 2360 * @wmi_handle: wmi handle 2361 * @startOemDataReq: start request params 2362 * 2363 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2364 */ 2365 QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl, 2366 uint32_t data_len, 2367 uint8_t *data) 2368 { 2369 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2370 2371 if (wmi_handle->ops->send_start_oem_data_cmd) 2372 return wmi_handle->ops->send_start_oem_data_cmd(wmi_handle, 2373 data_len, data); 2374 2375 return QDF_STATUS_E_FAILURE; 2376 } 2377 2378 /** 2379 * wmi_unified_dfs_phyerr_filter_offload_en_cmd() - enable dfs phyerr filter 2380 * @wmi_handle: wmi handle 2381 * @dfs_phyerr_filter_offload: is dfs phyerr filter offload 2382 * 2383 * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or 2384 * WMI_DFS_PHYERR_FILTER_DIS_CMDID command 2385 * to firmware based on phyerr filtering 2386 * offload status. 2387 * 2388 * Return: 1 success, 0 failure 2389 */ 2390 QDF_STATUS 2391 wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl, 2392 bool dfs_phyerr_filter_offload) 2393 { 2394 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2395 2396 if (wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd) 2397 return wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd(wmi_handle, 2398 dfs_phyerr_filter_offload); 2399 2400 return QDF_STATUS_E_FAILURE; 2401 } 2402 2403 #if !defined(REMOVE_PKT_LOG) 2404 /** 2405 * wmi_unified_pktlog_wmi_send_cmd() - send pktlog enable/disable command to target 2406 * @wmi_handle: wmi handle 2407 * @pktlog_event: pktlog event 2408 * @cmd_id: pktlog cmd id 2409 * 2410 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2411 */ 2412 #ifdef CONFIG_MCL 2413 QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl, 2414 WMI_PKTLOG_EVENT pktlog_event, 2415 uint32_t cmd_id, 2416 uint8_t user_triggered) 2417 { 2418 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2419 2420 if (wmi_handle->ops->send_pktlog_wmi_send_cmd) 2421 return wmi_handle->ops->send_pktlog_wmi_send_cmd(wmi_handle, 2422 pktlog_event, cmd_id, user_triggered); 2423 2424 return QDF_STATUS_E_FAILURE; 2425 } 2426 #endif 2427 #endif /* REMOVE_PKT_LOG */ 2428 2429 /** 2430 * wmi_unified_wow_delete_pattern_cmd() - delete wow pattern in target 2431 * @wmi_handle: wmi handle 2432 * @ptrn_id: pattern id 2433 * @vdev_id: vdev id 2434 * 2435 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2436 */ 2437 QDF_STATUS wmi_unified_wow_delete_pattern_cmd(void *wmi_hdl, uint8_t ptrn_id, 2438 uint8_t vdev_id) 2439 { 2440 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2441 2442 if (wmi_handle->ops->send_wow_delete_pattern_cmd) 2443 return wmi_handle->ops->send_wow_delete_pattern_cmd(wmi_handle, 2444 ptrn_id, vdev_id); 2445 2446 return QDF_STATUS_E_FAILURE; 2447 } 2448 2449 /** 2450 * wmi_unified_host_wakeup_ind_to_fw_cmd() - send wakeup ind to fw 2451 * @wmi_handle: wmi handle 2452 * 2453 * Sends host wakeup indication to FW. On receiving this indication, 2454 * FW will come out of WOW. 2455 * 2456 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2457 */ 2458 QDF_STATUS wmi_unified_host_wakeup_ind_to_fw_cmd(void *wmi_hdl) 2459 { 2460 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2461 2462 if (wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd) 2463 return wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd(wmi_handle); 2464 2465 return QDF_STATUS_E_FAILURE; 2466 } 2467 2468 /** 2469 * wmi_unified_del_ts_cmd() - send DELTS request to fw 2470 * @wmi_handle: wmi handle 2471 * @msg: delts params 2472 * 2473 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2474 */ 2475 QDF_STATUS wmi_unified_del_ts_cmd(void *wmi_hdl, uint8_t vdev_id, 2476 uint8_t ac) 2477 { 2478 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2479 2480 if (wmi_handle->ops->send_del_ts_cmd) 2481 return wmi_handle->ops->send_del_ts_cmd(wmi_handle, 2482 vdev_id, ac); 2483 2484 return QDF_STATUS_E_FAILURE; 2485 } 2486 2487 /** 2488 * wmi_unified_aggr_qos_cmd() - send aggr qos request to fw 2489 * @wmi_handle: handle to wmi 2490 * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests. 2491 * 2492 * A function to handle WMI_AGGR_QOS_REQ. This will send out 2493 * ADD_TS requestes to firmware in loop for all the ACs with 2494 * active flow. 2495 * 2496 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2497 */ 2498 QDF_STATUS wmi_unified_aggr_qos_cmd(void *wmi_hdl, 2499 struct aggr_add_ts_param *aggr_qos_rsp_msg) 2500 { 2501 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2502 2503 if (wmi_handle->ops->send_aggr_qos_cmd) 2504 return wmi_handle->ops->send_aggr_qos_cmd(wmi_handle, 2505 aggr_qos_rsp_msg); 2506 2507 return QDF_STATUS_E_FAILURE; 2508 } 2509 2510 /** 2511 * wmi_unified_add_ts_cmd() - send ADDTS request to fw 2512 * @wmi_handle: wmi handle 2513 * @msg: ADDTS params 2514 * 2515 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2516 */ 2517 QDF_STATUS wmi_unified_add_ts_cmd(void *wmi_hdl, 2518 struct add_ts_param *msg) 2519 { 2520 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2521 2522 if (wmi_handle->ops->send_add_ts_cmd) 2523 return wmi_handle->ops->send_add_ts_cmd(wmi_handle, 2524 msg); 2525 2526 return QDF_STATUS_E_FAILURE; 2527 } 2528 2529 /** 2530 * wmi_unified_process_add_periodic_tx_ptrn_cmd - add periodic tx ptrn 2531 * @wmi_handle: wmi handle 2532 * @pAddPeriodicTxPtrnParams: tx ptrn params 2533 * 2534 * Retrun: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2535 */ 2536 QDF_STATUS wmi_unified_process_add_periodic_tx_ptrn_cmd(void *wmi_hdl, 2537 struct periodic_tx_pattern * 2538 pAddPeriodicTxPtrnParams, 2539 uint8_t vdev_id) 2540 { 2541 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2542 2543 if (wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd) 2544 return wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd(wmi_handle, 2545 pAddPeriodicTxPtrnParams, 2546 vdev_id); 2547 2548 return QDF_STATUS_E_FAILURE; 2549 } 2550 2551 /** 2552 * wmi_unified_process_del_periodic_tx_ptrn_cmd - del periodic tx ptrn 2553 * @wmi_handle: wmi handle 2554 * @vdev_id: vdev id 2555 * @pattern_id: pattern id 2556 * 2557 * Retrun: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2558 */ 2559 QDF_STATUS wmi_unified_process_del_periodic_tx_ptrn_cmd(void *wmi_hdl, 2560 uint8_t vdev_id, 2561 uint8_t pattern_id) 2562 { 2563 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2564 2565 if (wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd) 2566 return wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd(wmi_handle, 2567 vdev_id, 2568 pattern_id); 2569 2570 return QDF_STATUS_E_FAILURE; 2571 } 2572 2573 /** 2574 * wmi_unified_stats_ext_req_cmd() - request ext stats from fw 2575 * @wmi_handle: wmi handle 2576 * @preq: stats ext params 2577 * 2578 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2579 */ 2580 QDF_STATUS wmi_unified_stats_ext_req_cmd(void *wmi_hdl, 2581 struct stats_ext_params *preq) 2582 { 2583 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2584 2585 if (wmi_handle->ops->send_stats_ext_req_cmd) 2586 return wmi_handle->ops->send_stats_ext_req_cmd(wmi_handle, 2587 preq); 2588 2589 return QDF_STATUS_E_FAILURE; 2590 } 2591 2592 /** 2593 * wmi_unified_enable_ext_wow_cmd() - enable ext wow in fw 2594 * @wmi_handle: wmi handle 2595 * @params: ext wow params 2596 * 2597 * Return:QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2598 */ 2599 QDF_STATUS wmi_unified_enable_ext_wow_cmd(void *wmi_hdl, 2600 struct ext_wow_params *params) 2601 { 2602 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2603 2604 if (wmi_handle->ops->send_enable_ext_wow_cmd) 2605 return wmi_handle->ops->send_enable_ext_wow_cmd(wmi_handle, 2606 params); 2607 2608 return QDF_STATUS_E_FAILURE; 2609 } 2610 2611 /** 2612 * wmi_unified_set_app_type2_params_in_fw_cmd() - set app type2 params in fw 2613 * @wmi_handle: wmi handle 2614 * @appType2Params: app type2 params 2615 * 2616 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2617 */ 2618 QDF_STATUS wmi_unified_set_app_type2_params_in_fw_cmd(void *wmi_hdl, 2619 struct app_type2_params *appType2Params) 2620 { 2621 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2622 2623 if (wmi_handle->ops->send_set_app_type2_params_in_fw_cmd) 2624 return wmi_handle->ops->send_set_app_type2_params_in_fw_cmd(wmi_handle, 2625 appType2Params); 2626 2627 return QDF_STATUS_E_FAILURE; 2628 2629 } 2630 2631 /** 2632 * wmi_unified_set_auto_shutdown_timer_cmd() - sets auto shutdown timer in firmware 2633 * @wmi_handle: wmi handle 2634 * @timer_val: auto shutdown timer value 2635 * 2636 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2637 */ 2638 QDF_STATUS wmi_unified_set_auto_shutdown_timer_cmd(void *wmi_hdl, 2639 uint32_t timer_val) 2640 { 2641 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2642 2643 if (wmi_handle->ops->send_set_auto_shutdown_timer_cmd) 2644 return wmi_handle->ops->send_set_auto_shutdown_timer_cmd(wmi_handle, 2645 timer_val); 2646 2647 return QDF_STATUS_E_FAILURE; 2648 } 2649 2650 /** 2651 * wmi_unified_nan_req_cmd() - to send nan request to target 2652 * @wmi_handle: wmi handle 2653 * @nan_req: request data which will be non-null 2654 * 2655 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2656 */ 2657 QDF_STATUS wmi_unified_nan_req_cmd(void *wmi_hdl, 2658 struct nan_req_params *nan_req) 2659 { 2660 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2661 2662 if (wmi_handle->ops->send_nan_req_cmd) 2663 return wmi_handle->ops->send_nan_req_cmd(wmi_handle, 2664 nan_req); 2665 2666 return QDF_STATUS_E_FAILURE; 2667 } 2668 2669 /** 2670 * wmi_unified_process_dhcpserver_offload_cmd() - enable DHCP server offload 2671 * @wmi_handle: wmi handle 2672 * @pDhcpSrvOffloadInfo: DHCP server offload info 2673 * 2674 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2675 */ 2676 QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd(void *wmi_hdl, 2677 struct dhcp_offload_info_params *params) 2678 { 2679 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2680 2681 if (wmi_handle->ops->send_process_dhcpserver_offload_cmd) 2682 return wmi_handle->ops->send_process_dhcpserver_offload_cmd(wmi_handle, 2683 params); 2684 2685 return QDF_STATUS_E_FAILURE; 2686 } 2687 2688 /** 2689 * wmi_unified_process_ch_avoid_update_cmd() - handles channel avoid update request 2690 * @wmi_handle: wmi handle 2691 * @ch_avoid_update_req: channel avoid update params 2692 * 2693 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2694 */ 2695 QDF_STATUS wmi_unified_process_ch_avoid_update_cmd(void *wmi_hdl) 2696 { 2697 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2698 2699 if (wmi_handle->ops->send_process_ch_avoid_update_cmd) 2700 return wmi_handle->ops->send_process_ch_avoid_update_cmd(wmi_handle); 2701 2702 return QDF_STATUS_E_FAILURE; 2703 } 2704 2705 /** 2706 * wmi_unified_send_regdomain_info_to_fw_cmd() - send regdomain info to fw 2707 * @wmi_handle: wmi handle 2708 * @reg_dmn: reg domain 2709 * @regdmn2G: 2G reg domain 2710 * @regdmn5G: 5G reg domain 2711 * @ctl2G: 2G test limit 2712 * @ctl5G: 5G test limit 2713 * 2714 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2715 */ 2716 QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(void *wmi_hdl, 2717 uint32_t reg_dmn, uint16_t regdmn2G, 2718 uint16_t regdmn5G, uint8_t ctl2G, 2719 uint8_t ctl5G) 2720 { 2721 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2722 2723 if (wmi_handle->ops->send_regdomain_info_to_fw_cmd) 2724 return wmi_handle->ops->send_regdomain_info_to_fw_cmd(wmi_handle, 2725 reg_dmn, regdmn2G, 2726 regdmn5G, ctl2G, 2727 ctl5G); 2728 2729 return QDF_STATUS_E_FAILURE; 2730 } 2731 2732 2733 /** 2734 * wmi_unified_set_tdls_offchan_mode_cmd() - set tdls off channel mode 2735 * @wmi_handle: wmi handle 2736 * @chan_switch_params: Pointer to tdls channel switch parameter structure 2737 * 2738 * This function sets tdls off channel mode 2739 * 2740 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures; 2741 * Negative errno otherwise 2742 */ 2743 QDF_STATUS wmi_unified_set_tdls_offchan_mode_cmd(void *wmi_hdl, 2744 struct tdls_channel_switch_params *chan_switch_params) 2745 { 2746 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2747 2748 if (wmi_handle->ops->send_set_tdls_offchan_mode_cmd) 2749 return wmi_handle->ops->send_set_tdls_offchan_mode_cmd(wmi_handle, 2750 chan_switch_params); 2751 2752 return QDF_STATUS_E_FAILURE; 2753 } 2754 2755 /** 2756 * wmi_unified_update_fw_tdls_state_cmd() - send enable/disable tdls for a vdev 2757 * @wmi_handle: wmi handle 2758 * @pwmaTdlsparams: TDLS params 2759 * 2760 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2761 */ 2762 QDF_STATUS wmi_unified_update_fw_tdls_state_cmd(void *wmi_hdl, 2763 void *tdls_param, uint8_t tdls_state) 2764 { 2765 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2766 2767 if (wmi_handle->ops->send_update_fw_tdls_state_cmd) 2768 return wmi_handle->ops->send_update_fw_tdls_state_cmd(wmi_handle, 2769 tdls_param, tdls_state); 2770 2771 return QDF_STATUS_E_FAILURE; 2772 } 2773 2774 /** 2775 * wmi_unified_update_tdls_peer_state_cmd() - update TDLS peer state 2776 * @wmi_handle: wmi handle 2777 * @peerStateParams: TDLS peer state params 2778 * 2779 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2780 */ 2781 QDF_STATUS wmi_unified_update_tdls_peer_state_cmd(void *wmi_hdl, 2782 struct tdls_peer_state_params *peerStateParams, 2783 uint32_t *ch_mhz) 2784 { 2785 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2786 2787 if (wmi_handle->ops->send_update_tdls_peer_state_cmd) 2788 return wmi_handle->ops->send_update_tdls_peer_state_cmd(wmi_handle, 2789 peerStateParams, ch_mhz); 2790 2791 return QDF_STATUS_E_FAILURE; 2792 } 2793 2794 /** 2795 * wmi_unified_process_set_ie_info_cmd() - Function to send IE info to firmware 2796 * @wmi_handle: Pointer to WMi handle 2797 * @ie_data: Pointer for ie data 2798 * 2799 * This function sends IE information to firmware 2800 * 2801 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2802 * 2803 */ 2804 QDF_STATUS wmi_unified_process_set_ie_info_cmd(void *wmi_hdl, 2805 struct vdev_ie_info_param *ie_info) 2806 { 2807 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2808 2809 if (wmi_handle->ops->send_process_set_ie_info_cmd) 2810 return wmi_handle->ops->send_process_set_ie_info_cmd(wmi_handle, 2811 ie_info); 2812 2813 return QDF_STATUS_E_FAILURE; 2814 } 2815 2816 /** 2817 * wmi_unified_save_fw_version_cmd() - save fw version 2818 * @wmi_handle: pointer to wmi handle 2819 * @res_cfg: resource config 2820 * @num_mem_chunks: no of mem chunck 2821 * @mem_chunk: pointer to mem chunck structure 2822 * 2823 * This function sends IE information to firmware 2824 * 2825 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2826 * 2827 */ 2828 QDF_STATUS wmi_unified_save_fw_version_cmd(void *wmi_hdl, 2829 void *evt_buf) 2830 { 2831 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2832 2833 if (wmi_handle->ops->save_fw_version_cmd) 2834 return wmi_handle->ops->save_fw_version_cmd(wmi_handle, 2835 evt_buf); 2836 2837 return QDF_STATUS_E_FAILURE; 2838 } 2839 2840 /** 2841 * send_set_base_macaddr_indicate_cmd() - set base mac address in fw 2842 * @wmi_hdl: wmi handle 2843 * @custom_addr: base mac address 2844 * 2845 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2846 */ 2847 QDF_STATUS wmi_unified_set_base_macaddr_indicate_cmd(void *wmi_hdl, 2848 uint8_t *custom_addr) 2849 { 2850 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2851 2852 if (wmi_handle->ops->send_set_base_macaddr_indicate_cmd) 2853 return wmi_handle->ops->send_set_base_macaddr_indicate_cmd(wmi_handle, 2854 custom_addr); 2855 2856 return QDF_STATUS_E_FAILURE; 2857 } 2858 2859 /** 2860 * wmi_unified_log_supported_evt_cmd() - Enable/Disable FW diag/log events 2861 * @wmi_hdl: wmi handle 2862 * @event: Event received from FW 2863 * @len: Length of the event 2864 * 2865 * Enables the low frequency events and disables the high frequency 2866 * events. Bit 17 indicates if the event if low/high frequency. 2867 * 1 - high frequency, 0 - low frequency 2868 * 2869 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures 2870 */ 2871 QDF_STATUS wmi_unified_log_supported_evt_cmd(void *wmi_hdl, 2872 uint8_t *event, 2873 uint32_t len) 2874 { 2875 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2876 2877 if (wmi_handle->ops->send_log_supported_evt_cmd) 2878 return wmi_handle->ops->send_log_supported_evt_cmd(wmi_handle, 2879 event, len); 2880 2881 return QDF_STATUS_E_FAILURE; 2882 } 2883 2884 void wmi_send_time_stamp_sync_cmd_tlv(void *wmi_hdl) 2885 { 2886 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2887 if (wmi_handle->ops->send_time_stamp_sync_cmd) 2888 wmi_handle->ops->send_time_stamp_sync_cmd(wmi_handle); 2889 2890 } 2891 /** 2892 * wmi_unified_enable_specific_fw_logs_cmd() - Start/Stop logging of diag log id 2893 * @wmi_hdl: wmi handle 2894 * @start_log: Start logging related parameters 2895 * 2896 * Send the command to the FW based on which specific logging of diag 2897 * event/log id can be started/stopped 2898 * 2899 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2900 */ 2901 QDF_STATUS wmi_unified_enable_specific_fw_logs_cmd(void *wmi_hdl, 2902 struct wmi_wifi_start_log *start_log) 2903 { 2904 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2905 2906 if (wmi_handle->ops->send_enable_specific_fw_logs_cmd) 2907 return wmi_handle->ops->send_enable_specific_fw_logs_cmd(wmi_handle, 2908 start_log); 2909 2910 return QDF_STATUS_E_FAILURE; 2911 } 2912 2913 /** 2914 * wmi_unified_flush_logs_to_fw_cmd() - Send log flush command to FW 2915 * @wmi_hdl: WMI handle 2916 * 2917 * This function is used to send the flush command to the FW, 2918 * that will flush the fw logs that are residue in the FW 2919 * 2920 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2921 */ 2922 QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(void *wmi_hdl) 2923 { 2924 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2925 2926 if (wmi_handle->ops->send_flush_logs_to_fw_cmd) 2927 return wmi_handle->ops->send_flush_logs_to_fw_cmd(wmi_handle); 2928 2929 return QDF_STATUS_E_FAILURE; 2930 } 2931 2932 /** 2933 * wmi_unified_pdev_set_pcl_cmd() - Send WMI_SOC_SET_PCL_CMDID to FW 2934 * @wmi_hdl: wmi handle 2935 * @msg: PCL structure containing the PCL and the number of channels 2936 * 2937 * WMI_SOC_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN 2938 * firmware. The DBS Manager is the consumer of this information in the WLAN 2939 * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs 2940 * to migrate to a new channel without host driver involvement. An example of 2941 * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will 2942 * manage the channel selection without firmware involvement. 2943 * 2944 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2945 */ 2946 QDF_STATUS wmi_unified_pdev_set_pcl_cmd(void *wmi_hdl, 2947 struct wmi_pcl_chan_weights *msg) 2948 { 2949 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2950 2951 if (wmi_handle->ops->send_pdev_set_pcl_cmd) 2952 return wmi_handle->ops->send_pdev_set_pcl_cmd(wmi_handle, msg); 2953 2954 return QDF_STATUS_E_FAILURE; 2955 } 2956 2957 /** 2958 * wmi_unified_soc_set_hw_mode_cmd() - Send WMI_SOC_SET_HW_MODE_CMDID to FW 2959 * @wmi_hdl: wmi handle 2960 * @msg: Structure containing the following parameters 2961 * 2962 * - hw_mode_index: The HW_Mode field is a enumerated type that is selected 2963 * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID. 2964 * 2965 * Provides notification to the WLAN firmware that host driver is requesting a 2966 * HardWare (HW) Mode change. This command is needed to support iHelium in the 2967 * configurations that include the Dual Band Simultaneous (DBS) feature. 2968 * 2969 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2970 */ 2971 QDF_STATUS wmi_unified_soc_set_hw_mode_cmd(void *wmi_hdl, 2972 uint32_t hw_mode_index) 2973 { 2974 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2975 2976 if (wmi_handle->ops->send_pdev_set_hw_mode_cmd) 2977 return wmi_handle->ops->send_pdev_set_hw_mode_cmd(wmi_handle, 2978 hw_mode_index); 2979 2980 return QDF_STATUS_E_FAILURE; 2981 } 2982 2983 /** 2984 * wmi_unified_pdev_set_dual_mac_config_cmd() - Set dual mac config to FW 2985 * @wmi_hdl: wmi handle 2986 * @msg: Dual MAC config parameters 2987 * 2988 * Configures WLAN firmware with the dual MAC features 2989 * 2990 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures. 2991 */ 2992 QDF_STATUS wmi_unified_pdev_set_dual_mac_config_cmd(void *wmi_hdl, 2993 struct wmi_dual_mac_config *msg) 2994 { 2995 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2996 2997 if (wmi_handle->ops->send_pdev_set_dual_mac_config_cmd) 2998 return wmi_handle->ops->send_pdev_set_dual_mac_config_cmd(wmi_handle, 2999 msg); 3000 3001 return QDF_STATUS_E_FAILURE; 3002 } 3003 3004 /** 3005 * wmi_unified_set_led_flashing_cmd() - set led flashing in fw 3006 * @wmi_hdl: wmi handle 3007 * @flashing: flashing request 3008 * 3009 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3010 */ 3011 QDF_STATUS wmi_unified_set_led_flashing_cmd(void *wmi_hdl, 3012 struct flashing_req_params *flashing) 3013 { 3014 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3015 3016 if (wmi_handle->ops->send_set_led_flashing_cmd) 3017 return wmi_handle->ops->send_set_led_flashing_cmd(wmi_handle, 3018 flashing); 3019 3020 return QDF_STATUS_E_FAILURE; 3021 } 3022 3023 /** 3024 * wmi_unified_app_type1_params_in_fw_cmd() - set app type1 params in fw 3025 * @wmi_hdl: wmi handle 3026 * @appType1Params: app type1 params 3027 * 3028 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3029 */ 3030 QDF_STATUS wmi_unified_app_type1_params_in_fw_cmd(void *wmi_hdl, 3031 struct app_type1_params *app_type1_params) 3032 { 3033 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3034 3035 if (wmi_handle->ops->send_app_type1_params_in_fw_cmd) 3036 return wmi_handle->ops->send_app_type1_params_in_fw_cmd(wmi_handle, 3037 app_type1_params); 3038 3039 return QDF_STATUS_E_FAILURE; 3040 } 3041 3042 /** 3043 * wmi_unified_set_ssid_hotlist_cmd() - Handle an SSID hotlist set request 3044 * @wmi_hdl: wmi handle 3045 * @request: SSID hotlist set request 3046 * 3047 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3048 */ 3049 QDF_STATUS 3050 wmi_unified_set_ssid_hotlist_cmd(void *wmi_hdl, 3051 struct ssid_hotlist_request_params *request) 3052 { 3053 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3054 3055 if (wmi_handle->ops->send_set_ssid_hotlist_cmd) 3056 return wmi_handle->ops->send_set_ssid_hotlist_cmd(wmi_handle, 3057 request); 3058 3059 return QDF_STATUS_E_FAILURE; 3060 } 3061 3062 /** 3063 * wmi_unified_roam_synch_complete_cmd() - roam synch complete command to fw. 3064 * @wmi_hdl: wmi handle 3065 * @vdev_id: vdev id 3066 * 3067 * This function sends roam synch complete event to fw. 3068 * 3069 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3070 */ 3071 QDF_STATUS wmi_unified_roam_synch_complete_cmd(void *wmi_hdl, 3072 uint8_t vdev_id) 3073 { 3074 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3075 3076 if (wmi_handle->ops->send_process_roam_synch_complete_cmd) 3077 return wmi_handle->ops->send_process_roam_synch_complete_cmd(wmi_handle, 3078 vdev_id); 3079 3080 return QDF_STATUS_E_FAILURE; 3081 } 3082 3083 /** 3084 * wmi_unified_fw_test_cmd() - send fw test command to fw. 3085 * @wmi_hdl: wmi handle 3086 * @wmi_fwtest: fw test command 3087 * 3088 * This function sends fw test command to fw. 3089 * 3090 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3091 */ 3092 QDF_STATUS wmi_unified_fw_test_cmd(void *wmi_hdl, 3093 struct set_fwtest_params *wmi_fwtest) 3094 { 3095 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3096 3097 if (wmi_handle->ops->send_fw_test_cmd) 3098 return wmi_handle->ops->send_fw_test_cmd(wmi_handle, 3099 wmi_fwtest); 3100 3101 return QDF_STATUS_E_FAILURE; 3102 3103 } 3104 3105 /** 3106 * wmi_unified_unit_test_cmd() - send unit test command to fw. 3107 * @wmi_hdl: wmi handle 3108 * @wmi_utest: unit test command 3109 * 3110 * This function send unit test command to fw. 3111 * 3112 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3113 */ 3114 QDF_STATUS wmi_unified_unit_test_cmd(void *wmi_hdl, 3115 struct wmi_unit_test_cmd *wmi_utest) 3116 { 3117 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3118 3119 if (wmi_handle->ops->send_unit_test_cmd) 3120 return wmi_handle->ops->send_unit_test_cmd(wmi_handle, 3121 wmi_utest); 3122 3123 return QDF_STATUS_E_FAILURE; 3124 } 3125 3126 /** 3127 * wmi_unified__roam_invoke_cmd() - send roam invoke command to fw. 3128 * @wmi_hdl: wmi handle 3129 * @roaminvoke: roam invoke command 3130 * 3131 * Send roam invoke command to fw for fastreassoc. 3132 * 3133 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3134 */ 3135 QDF_STATUS wmi_unified_roam_invoke_cmd(void *wmi_hdl, 3136 struct wmi_roam_invoke_cmd *roaminvoke, 3137 uint32_t ch_hz) 3138 { 3139 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3140 3141 if (wmi_handle->ops->send_roam_invoke_cmd) 3142 return wmi_handle->ops->send_roam_invoke_cmd(wmi_handle, 3143 roaminvoke, ch_hz); 3144 3145 return QDF_STATUS_E_FAILURE; 3146 } 3147 3148 /** 3149 * wmi_unified_roam_scan_offload_cmd() - set roam offload command 3150 * @wmi_hdl: wmi handle 3151 * @command: command 3152 * @vdev_id: vdev id 3153 * 3154 * This function set roam offload command to fw. 3155 * 3156 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3157 */ 3158 QDF_STATUS wmi_unified_roam_scan_offload_cmd(void *wmi_hdl, 3159 uint32_t command, uint32_t vdev_id) 3160 { 3161 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3162 3163 if (wmi_handle->ops->send_roam_scan_offload_cmd) 3164 return wmi_handle->ops->send_roam_scan_offload_cmd(wmi_handle, 3165 command, vdev_id); 3166 3167 return QDF_STATUS_E_FAILURE; 3168 } 3169 #ifdef CONFIG_MCL 3170 /** 3171 * wmi_unified_send_roam_scan_offload_ap_cmd() - set roam ap profile in fw 3172 * @wmi_hdl: wmi handle 3173 * @ap_profile: ap profile params 3174 * 3175 * Send WMI_ROAM_AP_PROFILE to firmware 3176 * 3177 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3178 */ 3179 QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd(void *wmi_hdl, 3180 struct ap_profile_params *ap_profile) 3181 { 3182 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3183 3184 if (wmi_handle->ops->send_roam_scan_offload_ap_profile_cmd) 3185 return wmi_handle->ops->send_roam_scan_offload_ap_profile_cmd( 3186 wmi_handle, ap_profile); 3187 3188 return QDF_STATUS_E_FAILURE; 3189 } 3190 #endif 3191 /** 3192 * wmi_unified_roam_scan_offload_scan_period() - set roam offload scan period 3193 * @wmi_handle: wmi handle 3194 * @scan_period: scan period 3195 * @scan_age: scan age 3196 * @vdev_id: vdev id 3197 * 3198 * Send WMI_ROAM_SCAN_PERIOD parameters to fw. 3199 * 3200 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3201 */ 3202 QDF_STATUS wmi_unified_roam_scan_offload_scan_period(void *wmi_hdl, 3203 uint32_t scan_period, 3204 uint32_t scan_age, 3205 uint32_t vdev_id) 3206 { 3207 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3208 3209 if (wmi_handle->ops->send_roam_scan_offload_scan_period_cmd) 3210 return wmi_handle->ops->send_roam_scan_offload_scan_period_cmd(wmi_handle, 3211 scan_period, scan_age, vdev_id); 3212 3213 return QDF_STATUS_E_FAILURE; 3214 } 3215 3216 /** 3217 * wmi_unified_roam_scan_offload_chan_list_cmd() - set roam offload channel list 3218 * @wmi_handle: wmi handle 3219 * @chan_count: channel count 3220 * @chan_list: channel list 3221 * @list_type: list type 3222 * @vdev_id: vdev id 3223 * 3224 * Set roam offload channel list. 3225 * 3226 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3227 */ 3228 QDF_STATUS wmi_unified_roam_scan_offload_chan_list_cmd(void *wmi_hdl, 3229 uint8_t chan_count, 3230 uint32_t *chan_list, 3231 uint8_t list_type, uint32_t vdev_id) 3232 { 3233 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3234 3235 if (wmi_handle->ops->send_roam_scan_offload_chan_list_cmd) 3236 return wmi_handle->ops->send_roam_scan_offload_chan_list_cmd(wmi_handle, 3237 chan_count, chan_list, 3238 list_type, vdev_id); 3239 3240 return QDF_STATUS_E_FAILURE; 3241 } 3242 3243 /** 3244 * wmi_unified_roam_scan_offload_rssi_change_cmd() - set roam offload RSSI th 3245 * @wmi_hdl: wmi handle 3246 * @rssi_change_thresh: RSSI Change threshold 3247 * @bcn_rssi_weight: beacon RSSI weight 3248 * @vdev_id: vdev id 3249 * 3250 * Send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD parameters to fw. 3251 * 3252 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3253 */ 3254 QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd(void *wmi_hdl, 3255 uint32_t vdev_id, 3256 int32_t rssi_change_thresh, 3257 uint32_t bcn_rssi_weight, 3258 uint32_t hirssi_delay_btw_scans) 3259 { 3260 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3261 3262 if (wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd) 3263 return wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd(wmi_handle, 3264 vdev_id, rssi_change_thresh, 3265 bcn_rssi_weight, hirssi_delay_btw_scans); 3266 3267 return QDF_STATUS_E_FAILURE; 3268 } 3269 3270 QDF_STATUS wmi_unified_set_per_roam_config(void *wmi_hdl, 3271 struct wmi_per_roam_config_req *req_buf) 3272 { 3273 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3274 3275 if (wmi_handle->ops->send_per_roam_config_cmd) 3276 return wmi_handle->ops->send_per_roam_config_cmd(wmi_handle, 3277 req_buf); 3278 3279 return QDF_STATUS_E_FAILURE; 3280 } 3281 3282 /** 3283 * wmi_unified_set_arp_stats_req() - set arp stats request 3284 * @wmi_hdl: wmi handle 3285 * @req_buf: pointer to set_arp_stats 3286 * 3287 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3288 */ 3289 QDF_STATUS wmi_unified_set_arp_stats_req(void *wmi_hdl, 3290 struct set_arp_stats *req_buf) 3291 { 3292 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3293 3294 if (wmi_handle->ops->send_set_arp_stats_req_cmd) 3295 return wmi_handle->ops->send_set_arp_stats_req_cmd(wmi_handle, 3296 req_buf); 3297 3298 return QDF_STATUS_E_FAILURE; 3299 } 3300 3301 /** 3302 * wmi_unified_get_arp_stats_req() - get arp stats request 3303 * @wmi_hdl: wmi handle 3304 * @req_buf: pointer to get_arp_stats 3305 * 3306 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3307 */ 3308 QDF_STATUS wmi_unified_get_arp_stats_req(void *wmi_hdl, 3309 struct get_arp_stats *req_buf) 3310 { 3311 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3312 3313 if (wmi_handle->ops->send_get_arp_stats_req_cmd) 3314 return wmi_handle->ops->send_get_arp_stats_req_cmd(wmi_handle, 3315 req_buf); 3316 3317 return QDF_STATUS_E_FAILURE; 3318 } 3319 3320 QDF_STATUS wmi_unified_set_del_pmkid_cache(void *wmi_hdl, 3321 struct wmi_unified_pmk_cache *req_buf) 3322 { 3323 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3324 3325 if (wmi_handle->ops->send_set_del_pmkid_cache_cmd) 3326 return wmi_handle->ops->send_set_del_pmkid_cache_cmd(wmi_handle, 3327 req_buf); 3328 3329 return QDF_STATUS_E_FAILURE; 3330 } 3331 3332 #if defined(WLAN_FEATURE_FILS_SK) 3333 QDF_STATUS wmi_unified_roam_send_hlp_cmd(void *wmi_hdl, 3334 struct hlp_params *req_buf) 3335 { 3336 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3337 3338 if (wmi_handle->ops->send_roam_scan_hlp_cmd) 3339 return wmi_handle->ops->send_roam_scan_hlp_cmd(wmi_handle, 3340 req_buf); 3341 3342 return QDF_STATUS_E_FAILURE; 3343 } 3344 #endif 3345 3346 /** 3347 * wmi_unified_get_buf_extscan_hotlist_cmd() - prepare hotlist command 3348 * @wmi_hdl: wmi handle 3349 * @photlist: hotlist command params 3350 * @buf_len: buffer length 3351 * 3352 * This function fills individual elements for hotlist request and 3353 * TLV for bssid entries 3354 * 3355 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 3356 */ 3357 QDF_STATUS wmi_unified_get_buf_extscan_hotlist_cmd(void *wmi_hdl, 3358 struct ext_scan_setbssi_hotlist_params * 3359 photlist, int *buf_len) 3360 { 3361 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3362 3363 if (wmi_handle->ops->send_get_buf_extscan_hotlist_cmd) 3364 return wmi_handle->ops->send_get_buf_extscan_hotlist_cmd(wmi_handle, 3365 photlist, buf_len); 3366 3367 return QDF_STATUS_E_FAILURE; 3368 } 3369 3370 QDF_STATUS wmi_unified_set_active_bpf_mode_cmd(void *wmi_hdl, 3371 uint8_t vdev_id, 3372 enum wmi_host_active_bpf_mode ucast_mode, 3373 enum wmi_host_active_bpf_mode mcast_bcast_mode) 3374 { 3375 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 3376 3377 if (!wmi->ops->send_set_active_bpf_mode_cmd) { 3378 WMI_LOGD("send_set_active_bpf_mode_cmd op is NULL"); 3379 return QDF_STATUS_E_FAILURE; 3380 } 3381 3382 return wmi->ops->send_set_active_bpf_mode_cmd(wmi, vdev_id, 3383 ucast_mode, 3384 mcast_bcast_mode); 3385 } 3386 3387 /** 3388 * wmi_unified_pdev_get_tpc_config_cmd_send() - WMI get tpc config function 3389 * @param wmi_handle : handle to WMI. 3390 * @param param : tpc config param 3391 * 3392 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3393 */ 3394 QDF_STATUS wmi_unified_pdev_get_tpc_config_cmd_send(void *wmi_hdl, 3395 uint32_t param) 3396 { 3397 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3398 3399 if (wmi_handle->ops->send_pdev_get_tpc_config_cmd) 3400 return wmi_handle->ops->send_pdev_get_tpc_config_cmd(wmi_handle, 3401 param); 3402 3403 return QDF_STATUS_E_FAILURE; 3404 } 3405 3406 /** 3407 * wmi_unified_set_bwf_cmd_send() - WMI set bwf function 3408 * @param wmi_handle : handle to WMI. 3409 * @param param : pointer to set bwf param 3410 * 3411 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3412 */ 3413 QDF_STATUS wmi_unified_set_bwf_cmd_send(void *wmi_hdl, 3414 struct set_bwf_params *param) 3415 { 3416 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3417 3418 if (wmi_handle->ops->send_set_bwf_cmd) 3419 return wmi_handle->ops->send_set_bwf_cmd(wmi_handle, param); 3420 3421 return QDF_STATUS_E_FAILURE; 3422 } 3423 3424 /** 3425 * wmi_unified_set_atf_cmd_send() - WMI set atf function 3426 * @param wmi_handle : handle to WMI. 3427 * @param param : pointer to set atf param 3428 * 3429 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3430 */ 3431 QDF_STATUS wmi_unified_set_atf_cmd_send(void *wmi_hdl, 3432 struct set_atf_params *param) 3433 { 3434 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3435 3436 if (wmi_handle->ops->send_set_atf_cmd) 3437 return wmi_handle->ops->send_set_atf_cmd(wmi_handle, param); 3438 3439 return QDF_STATUS_E_FAILURE; 3440 } 3441 3442 /** 3443 * wmi_unified_pdev_fips_cmd_send() - WMI pdev fips cmd function 3444 * @param wmi_handle : handle to WMI. 3445 * @param param : pointer to hold pdev fips param 3446 * 3447 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3448 */ 3449 QDF_STATUS wmi_unified_pdev_fips_cmd_send(void *wmi_hdl, 3450 struct fips_params *param) 3451 { 3452 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3453 3454 if (wmi_handle->ops->send_pdev_fips_cmd) 3455 return wmi_handle->ops->send_pdev_fips_cmd(wmi_handle, param); 3456 3457 return QDF_STATUS_E_FAILURE; 3458 } 3459 3460 /** 3461 * wmi_unified_wlan_profile_enable_cmd_send() - WMI wlan profile enable cmd function 3462 * @param wmi_handle : handle to WMI. 3463 * @param param : pointer to hold wlan profile param 3464 * 3465 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3466 */ 3467 QDF_STATUS wmi_unified_wlan_profile_enable_cmd_send(void *wmi_hdl, 3468 struct wlan_profile_params *param) 3469 { 3470 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3471 3472 if (wmi_handle->ops->send_wlan_profile_enable_cmd) 3473 return wmi_handle->ops->send_wlan_profile_enable_cmd(wmi_handle, 3474 param); 3475 3476 return QDF_STATUS_E_FAILURE; 3477 } 3478 3479 /** 3480 * wmi_unified_wlan_profile_trigger_cmd_send() - WMI wlan profile trigger cmd function 3481 * @param wmi_handle : handle to WMI. 3482 * @param param : pointer to hold wlan profile param 3483 * 3484 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3485 */ 3486 QDF_STATUS wmi_unified_wlan_profile_trigger_cmd_send(void *wmi_hdl, 3487 struct wlan_profile_params *param) 3488 { 3489 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3490 3491 if (wmi->ops->send_wlan_profile_trigger_cmd) 3492 return wmi->ops->send_wlan_profile_trigger_cmd(wmi, 3493 param); 3494 3495 return QDF_STATUS_E_FAILURE; 3496 } 3497 3498 /** 3499 * wmi_unified_set_chan_cmd_send() - WMI set channel cmd function 3500 * @param wmi_handle : handle to WMI. 3501 * @param param : pointer to hold channel param 3502 * 3503 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3504 */ 3505 QDF_STATUS wmi_unified_set_chan_cmd_send(void *wmi_hdl, 3506 struct channel_param *param) 3507 { 3508 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3509 3510 if (wmi_handle->ops->send_pdev_set_chan_cmd) 3511 return wmi_handle->ops->send_pdev_set_chan_cmd(wmi_handle, 3512 param); 3513 3514 return QDF_STATUS_E_FAILURE; 3515 } 3516 3517 /** 3518 * wmi_unified_set_ht_ie_cmd_send() - WMI set channel cmd function 3519 * @param wmi_handle : handle to WMI. 3520 * @param param : pointer to hold channel param 3521 * 3522 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3523 */ 3524 QDF_STATUS wmi_unified_set_ht_ie_cmd_send(void *wmi_hdl, 3525 struct ht_ie_params *param) 3526 { 3527 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3528 3529 if (wmi_handle->ops->send_set_ht_ie_cmd) 3530 return wmi_handle->ops->send_set_ht_ie_cmd(wmi_handle, param); 3531 3532 return QDF_STATUS_E_FAILURE; 3533 } 3534 3535 /** 3536 * wmi_unified_set_vht_ie_cmd_send() - WMI set channel cmd function 3537 * @param wmi_handle : handle to WMI. 3538 * @param param : pointer to hold channel param 3539 * 3540 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3541 */ 3542 QDF_STATUS wmi_unified_set_vht_ie_cmd_send(void *wmi_hdl, 3543 struct vht_ie_params *param) 3544 { 3545 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3546 3547 if (wmi_handle->ops->send_set_vht_ie_cmd) 3548 return wmi_handle->ops->send_set_vht_ie_cmd(wmi_handle, param); 3549 3550 return QDF_STATUS_E_FAILURE; 3551 } 3552 3553 /** 3554 * wmi_unified_wmm_update_cmd_send() - WMI wmm update cmd function 3555 * @param wmi_handle : handle to WMI. 3556 * @param param : pointer to hold wmm param 3557 * 3558 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3559 */ 3560 QDF_STATUS wmi_unified_wmm_update_cmd_send(void *wmi_hdl, 3561 struct wmm_update_params *param) 3562 { 3563 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3564 3565 if (wmi_handle->ops->send_wmm_update_cmd) 3566 return wmi_handle->ops->send_wmm_update_cmd(wmi_handle, param); 3567 3568 return QDF_STATUS_E_FAILURE; 3569 } 3570 3571 /** 3572 * wmi_unified_set_ant_switch_tbl_cmd_send() - WMI ant switch tbl cmd function 3573 * @param wmi_handle : handle to WMI. 3574 * @param param : pointer to hold ant switch tbl param 3575 * 3576 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3577 */ 3578 QDF_STATUS wmi_unified_set_ant_switch_tbl_cmd_send(void *wmi_hdl, 3579 struct ant_switch_tbl_params *param) 3580 { 3581 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3582 3583 if (wmi_handle->ops->send_set_ant_switch_tbl_cmd) 3584 return wmi_handle->ops->send_set_ant_switch_tbl_cmd(wmi_handle, 3585 param); 3586 3587 return QDF_STATUS_E_FAILURE; 3588 } 3589 3590 /** 3591 * wmi_unified_set_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 3592 * @param wmi_handle : handle to WMI. 3593 * @param param : pointer to hold ratepwr table param 3594 * 3595 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3596 */ 3597 QDF_STATUS wmi_unified_set_ratepwr_table_cmd_send(void *wmi_hdl, 3598 struct ratepwr_table_params *param) 3599 { 3600 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3601 3602 if (wmi_handle->ops->send_set_ratepwr_table_cmd) 3603 return wmi_handle->ops->send_set_ratepwr_table_cmd(wmi_handle, 3604 param); 3605 3606 return QDF_STATUS_E_FAILURE; 3607 } 3608 3609 /** 3610 * wmi_unified_get_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 3611 * @param wmi_handle : handle to WMI. 3612 * 3613 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3614 */ 3615 QDF_STATUS wmi_unified_get_ratepwr_table_cmd_send(void *wmi_hdl) 3616 { 3617 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3618 3619 if (wmi_handle->ops->send_get_ratepwr_table_cmd) 3620 return wmi_handle->ops->send_get_ratepwr_table_cmd(wmi_handle); 3621 3622 return QDF_STATUS_E_FAILURE; 3623 } 3624 3625 /** 3626 * wmi_unified_set_ctl_table_cmd_send() - WMI ctl table cmd function 3627 * @param wmi_handle : handle to WMI. 3628 * @param param : pointer to hold ctl table param 3629 * 3630 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3631 */ 3632 QDF_STATUS wmi_unified_set_ctl_table_cmd_send(void *wmi_hdl, 3633 struct ctl_table_params *param) 3634 { 3635 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3636 3637 if (wmi_handle->ops->send_set_ctl_table_cmd) 3638 return wmi_handle->ops->send_set_ctl_table_cmd(wmi_handle, 3639 param); 3640 3641 return QDF_STATUS_E_FAILURE; 3642 } 3643 3644 /** 3645 * wmi_unified_set_mimogain_table_cmd_send() - WMI set mimogain cmd function 3646 * @param wmi_handle : handle to WMI. 3647 * @param param : pointer to hold mimogain param 3648 * 3649 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3650 */ 3651 QDF_STATUS wmi_unified_set_mimogain_table_cmd_send(void *wmi_hdl, 3652 struct mimogain_table_params *param) 3653 { 3654 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3655 3656 if (wmi_handle->ops->send_set_mimogain_table_cmd) 3657 return wmi_handle->ops->send_set_mimogain_table_cmd(wmi_handle, 3658 param); 3659 3660 return QDF_STATUS_E_FAILURE; 3661 } 3662 3663 /** 3664 * wmi_unified_set_ratepwr_chainmsk_cmd_send() - WMI ratepwr 3665 * chainmsk cmd function 3666 * @param wmi_handle : handle to WMI. 3667 * @param param : pointer to hold ratepwr chainmsk param 3668 * 3669 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3670 */ 3671 QDF_STATUS wmi_unified_set_ratepwr_chainmsk_cmd_send(void *wmi_hdl, 3672 struct ratepwr_chainmsk_params *param) 3673 { 3674 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3675 3676 if (wmi->ops->send_set_ratepwr_chainmsk_cmd) 3677 return wmi->ops->send_set_ratepwr_chainmsk_cmd(wmi, param); 3678 3679 return QDF_STATUS_E_FAILURE; 3680 } 3681 3682 /** 3683 * wmi_unified_set_macaddr_cmd_send() - WMI set macaddr cmd function 3684 * @param wmi_handle : handle to WMI. 3685 * @param param : pointer to hold macaddr param 3686 * 3687 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3688 */ 3689 QDF_STATUS wmi_unified_set_macaddr_cmd_send(void *wmi_hdl, 3690 struct macaddr_params *param) 3691 { 3692 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3693 3694 if (wmi_handle->ops->send_set_macaddr_cmd) 3695 return wmi_handle->ops->send_set_macaddr_cmd(wmi_handle, param); 3696 3697 return QDF_STATUS_E_FAILURE; 3698 } 3699 3700 /** 3701 * wmi_unified_pdev_scan_start_cmd_send() - WMI pdev scan start cmd function 3702 * @param wmi_handle : handle to WMI. 3703 * 3704 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3705 */ 3706 QDF_STATUS wmi_unified_pdev_scan_start_cmd_send(void *wmi_hdl) 3707 { 3708 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3709 3710 if (wmi_handle->ops->send_pdev_scan_start_cmd) 3711 return wmi_handle->ops->send_pdev_scan_start_cmd(wmi_handle); 3712 3713 return QDF_STATUS_E_FAILURE; 3714 } 3715 3716 /** 3717 * wmi_unified_pdev_scan_end_cmd_send() - WMI pdev scan end cmd function 3718 * @param wmi_handle : handle to WMI. 3719 * 3720 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3721 */ 3722 QDF_STATUS wmi_unified_pdev_scan_end_cmd_send(void *wmi_hdl) 3723 { 3724 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3725 3726 if (wmi_handle->ops->send_pdev_scan_end_cmd) 3727 return wmi_handle->ops->send_pdev_scan_end_cmd(wmi_handle); 3728 3729 return QDF_STATUS_E_FAILURE; 3730 } 3731 3732 /** 3733 * wmi_unified_set_acparams_cmd_send() - WMI set acparams cmd function 3734 * @param wmi_handle : handle to WMI. 3735 * @param param : pointer to hold acparams param 3736 * 3737 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3738 */ 3739 QDF_STATUS wmi_unified_set_acparams_cmd_send(void *wmi_hdl, 3740 struct acparams_params *param) 3741 { 3742 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3743 3744 if (wmi_handle->ops->send_set_acparams_cmd) 3745 return wmi_handle->ops->send_set_acparams_cmd(wmi_handle, 3746 param); 3747 3748 return QDF_STATUS_E_FAILURE; 3749 } 3750 3751 /** 3752 * wmi_unified_set_vap_dscp_tid_map_cmd_send() - WMI set vap dscp 3753 * tid map cmd function 3754 * @param wmi_handle : handle to WMI. 3755 * @param param : pointer to hold dscp param 3756 * 3757 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3758 */ 3759 QDF_STATUS wmi_unified_set_vap_dscp_tid_map_cmd_send(void *wmi_hdl, 3760 struct vap_dscp_tid_map_params *param) 3761 { 3762 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3763 3764 if (wmi->ops->send_set_vap_dscp_tid_map_cmd) 3765 return wmi->ops->send_set_vap_dscp_tid_map_cmd(wmi, param); 3766 3767 return QDF_STATUS_E_FAILURE; 3768 } 3769 3770 /** 3771 * wmi_unified_proxy_ast_reserve_cmd_send() - WMI proxy ast 3772 * reserve cmd function 3773 * @param wmi_handle : handle to WMI. 3774 * @param param : pointer to hold ast param 3775 * 3776 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3777 */ 3778 QDF_STATUS wmi_unified_proxy_ast_reserve_cmd_send(void *wmi_hdl, 3779 struct proxy_ast_reserve_params *param) 3780 { 3781 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3782 3783 if (wmi_handle->ops->send_proxy_ast_reserve_cmd) 3784 return wmi_handle->ops->send_proxy_ast_reserve_cmd(wmi_handle, 3785 param); 3786 3787 return QDF_STATUS_E_FAILURE; 3788 } 3789 3790 /** 3791 * wmi_unified_pdev_qvit_cmd_send() - WMI pdev qvit cmd function 3792 * @param wmi_handle : handle to WMI. 3793 * @param param : pointer to hold qvit param 3794 * 3795 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3796 */ 3797 QDF_STATUS wmi_unified_pdev_qvit_cmd_send(void *wmi_hdl, 3798 struct pdev_qvit_params *param) 3799 { 3800 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3801 3802 if (wmi_handle->ops->send_pdev_qvit_cmd) 3803 return wmi_handle->ops->send_pdev_qvit_cmd(wmi_handle, param); 3804 3805 return QDF_STATUS_E_FAILURE; 3806 } 3807 3808 /** 3809 * wmi_unified_mcast_group_update_cmd_send() - WMI mcast grp update cmd function 3810 * @param wmi_handle : handle to WMI. 3811 * @param param : pointer to hold mcast grp param 3812 * 3813 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3814 */ 3815 QDF_STATUS wmi_unified_mcast_group_update_cmd_send(void *wmi_hdl, 3816 struct mcast_group_update_params *param) 3817 { 3818 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3819 3820 if (wmi_handle->ops->send_mcast_group_update_cmd) 3821 return wmi_handle->ops->send_mcast_group_update_cmd(wmi_handle, 3822 param); 3823 3824 return QDF_STATUS_E_FAILURE; 3825 } 3826 3827 /** 3828 * wmi_unified_peer_add_wds_entry_cmd_send() - WMI add wds entry cmd function 3829 * @param wmi_handle : handle to WMI. 3830 * @param param : pointer to hold wds entry param 3831 * 3832 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3833 */ 3834 QDF_STATUS wmi_unified_peer_add_wds_entry_cmd_send(void *wmi_hdl, 3835 struct peer_add_wds_entry_params *param) 3836 { 3837 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3838 3839 if (wmi_handle->ops->send_peer_add_wds_entry_cmd) 3840 return wmi_handle->ops->send_peer_add_wds_entry_cmd(wmi_handle, 3841 param); 3842 3843 return QDF_STATUS_E_FAILURE; 3844 } 3845 3846 /** 3847 * wmi_unified_peer_del_wds_entry_cmd_send() - WMI del wds entry cmd function 3848 * @param wmi_handle : handle to WMI. 3849 * @param param : pointer to hold wds entry param 3850 * 3851 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3852 */ 3853 QDF_STATUS wmi_unified_peer_del_wds_entry_cmd_send(void *wmi_hdl, 3854 struct peer_del_wds_entry_params *param) 3855 { 3856 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3857 3858 if (wmi_handle->ops->send_peer_del_wds_entry_cmd) 3859 return wmi_handle->ops->send_peer_del_wds_entry_cmd(wmi_handle, 3860 param); 3861 3862 return QDF_STATUS_E_FAILURE; 3863 } 3864 3865 /** 3866 * wmi_unified_set_bridge_mac_addr_cmd_send() - WMI set bridge mac addr cmd function 3867 * @param wmi_hdl : handle to WMI. 3868 * @param param : pointer to hold bridge mac addr param 3869 * 3870 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3871 */ 3872 QDF_STATUS wmi_unified_set_bridge_mac_addr_cmd_send(void *wmi_hdl, 3873 struct set_bridge_mac_addr_params *param) 3874 { 3875 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3876 3877 if (wmi_handle->ops->send_set_bridge_mac_addr_cmd) 3878 return wmi_handle->ops->send_set_bridge_mac_addr_cmd(wmi_handle, 3879 param); 3880 3881 return QDF_STATUS_E_FAILURE; 3882 } 3883 3884 /** 3885 * wmi_unified_peer_update_wds_entry_cmd_send() - WMI update wds entry cmd function 3886 * @param wmi_handle : handle to WMI. 3887 * @param param : pointer to hold wds entry param 3888 * 3889 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3890 */ 3891 QDF_STATUS wmi_unified_peer_update_wds_entry_cmd_send(void *wmi_hdl, 3892 struct peer_update_wds_entry_params *param) 3893 { 3894 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3895 3896 if (wmi->ops->send_peer_update_wds_entry_cmd) 3897 return wmi->ops->send_peer_update_wds_entry_cmd(wmi, param); 3898 3899 return QDF_STATUS_E_FAILURE; 3900 } 3901 3902 /** 3903 * wmi_unified_phyerr_enable_cmd_send() - WMI phyerr enable cmd function 3904 * @param wmi_handle : handle to WMI. 3905 * @param param : pointer to hold phyerr enable param 3906 * 3907 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3908 */ 3909 QDF_STATUS wmi_unified_phyerr_enable_cmd_send(void *wmi_hdl) 3910 { 3911 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3912 3913 if (wmi_handle->ops->send_phyerr_enable_cmd) 3914 return wmi_handle->ops->send_phyerr_enable_cmd(wmi_handle); 3915 3916 return QDF_STATUS_E_FAILURE; 3917 } 3918 3919 /** 3920 * wmi_unified_phyerr_disable_cmd_send() - WMI phyerr disable cmd function 3921 * @param wmi_handle : handle to WMI. 3922 * @param param : pointer to hold phyerr disable param 3923 * 3924 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3925 */ 3926 QDF_STATUS wmi_unified_phyerr_disable_cmd_send(void *wmi_hdl) 3927 { 3928 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3929 3930 if (wmi_handle->ops->send_phyerr_disable_cmd) 3931 return wmi_handle->ops->send_phyerr_disable_cmd(wmi_handle); 3932 3933 return QDF_STATUS_E_FAILURE; 3934 } 3935 3936 /** 3937 * wmi_unified_smart_ant_enable_cmd_send() - WMI smart ant enable function 3938 * @param wmi_handle : handle to WMI. 3939 * @param param : pointer to hold antenna param 3940 * 3941 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3942 */ 3943 QDF_STATUS wmi_unified_smart_ant_enable_cmd_send(void *wmi_hdl, 3944 struct smart_ant_enable_params *param) 3945 { 3946 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3947 3948 if (wmi_handle->ops->send_smart_ant_enable_cmd) 3949 return wmi_handle->ops->send_smart_ant_enable_cmd(wmi_handle, 3950 param); 3951 3952 return QDF_STATUS_E_FAILURE; 3953 } 3954 3955 /** 3956 * wmi_unified_smart_ant_set_rx_ant_cmd_send() - WMI set rx antenna function 3957 * @param wmi_handle : handle to WMI. 3958 * @param param : pointer to hold antenna param 3959 * 3960 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3961 */ 3962 QDF_STATUS wmi_unified_smart_ant_set_rx_ant_cmd_send(void *wmi_hdl, 3963 struct smart_ant_rx_ant_params *param) 3964 { 3965 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3966 3967 if (wmi->ops->send_smart_ant_set_rx_ant_cmd) 3968 return wmi->ops->send_smart_ant_set_rx_ant_cmd(wmi, param); 3969 3970 return QDF_STATUS_E_FAILURE; 3971 } 3972 3973 /** 3974 * wmi_unified_smart_ant_set_tx_ant_cmd_send() - WMI set tx antenna function 3975 * @param wmi_handle : handle to WMI. 3976 * @param param : pointer to hold antenna param 3977 * 3978 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3979 */ 3980 QDF_STATUS wmi_unified_smart_ant_set_tx_ant_cmd_send(void *wmi_hdl, 3981 uint8_t macaddr[IEEE80211_ADDR_LEN], 3982 struct smart_ant_tx_ant_params *param) 3983 { 3984 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3985 3986 if (wmi->ops->send_smart_ant_set_tx_ant_cmd) 3987 return wmi->ops->send_smart_ant_set_tx_ant_cmd(wmi, macaddr, 3988 param); 3989 3990 return QDF_STATUS_E_FAILURE; 3991 } 3992 3993 /** 3994 * wmi_unified_smart_ant_set_training_info_cmd_send() - WMI set tx antenna function 3995 * @param wmi_handle : handle to WMI. 3996 * @param param : pointer to hold antenna param 3997 * 3998 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3999 */ 4000 QDF_STATUS wmi_unified_smart_ant_set_training_info_cmd_send(void *wmi_hdl, 4001 uint8_t macaddr[IEEE80211_ADDR_LEN], 4002 struct smart_ant_training_info_params *param) 4003 { 4004 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4005 4006 if (wmi->ops->send_smart_ant_set_training_info_cmd) 4007 return wmi->ops->send_smart_ant_set_training_info_cmd(wmi, 4008 macaddr, param); 4009 4010 return QDF_STATUS_E_FAILURE; 4011 } 4012 4013 /** 4014 * wmi_unified_smart_ant_node_config_cmd_send() - WMI set node config function 4015 * @param wmi_handle : handle to WMI. 4016 * @param macaddr : MAC address 4017 * @param param : pointer to hold node parameter 4018 * 4019 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4020 */ 4021 QDF_STATUS wmi_unified_smart_ant_node_config_cmd_send(void *wmi_hdl, 4022 uint8_t macaddr[IEEE80211_ADDR_LEN], 4023 struct smart_ant_node_config_params *param) 4024 { 4025 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4026 4027 if (wmi->ops->send_smart_ant_set_node_config_cmd) 4028 return wmi->ops->send_smart_ant_set_node_config_cmd(wmi, 4029 macaddr, param); 4030 4031 return QDF_STATUS_E_FAILURE; 4032 } 4033 4034 /** 4035 * wmi_unified_smart_ant_enable_tx_feedback_cmd_send() - WMI set tx antenna function 4036 * @param wmi_handle : handle to WMI. 4037 * @param param : pointer to hold antenna param 4038 * 4039 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4040 */ 4041 QDF_STATUS wmi_unified_smart_ant_enable_tx_feedback_cmd_send(void *wmi_hdl, 4042 struct smart_ant_enable_tx_feedback_params *param) 4043 { 4044 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4045 4046 if (wmi->ops->send_smart_ant_enable_tx_feedback_cmd) 4047 return wmi->ops->send_smart_ant_enable_tx_feedback_cmd(wmi, 4048 param); 4049 4050 return QDF_STATUS_E_FAILURE; 4051 } 4052 qdf_export_symbol(wmi_unified_smart_ant_enable_tx_feedback_cmd_send); 4053 4054 /** 4055 * wmi_unified_vdev_spectral_configure_cmd_send() - WMI set spectral config function 4056 * @param wmi_handle : handle to WMI. 4057 * @param param : pointer to hold spectral config param 4058 * 4059 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4060 */ 4061 QDF_STATUS wmi_unified_vdev_spectral_configure_cmd_send(void *wmi_hdl, 4062 struct vdev_spectral_configure_params *param) 4063 { 4064 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4065 4066 if (wmi->ops->send_vdev_spectral_configure_cmd) 4067 return wmi->ops->send_vdev_spectral_configure_cmd(wmi, param); 4068 4069 return QDF_STATUS_E_FAILURE; 4070 } 4071 4072 /** 4073 * wmi_unified_vdev_spectral_enable_cmd_send() - WMI enable spectral function 4074 * @param wmi_handle : handle to WMI. 4075 * @param param : pointer to hold enable spectral param 4076 * 4077 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4078 */ 4079 QDF_STATUS wmi_unified_vdev_spectral_enable_cmd_send(void *wmi_hdl, 4080 struct vdev_spectral_enable_params *param) 4081 { 4082 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4083 4084 if (wmi->ops->send_vdev_spectral_enable_cmd) 4085 return wmi->ops->send_vdev_spectral_enable_cmd(wmi, param); 4086 4087 return QDF_STATUS_E_FAILURE; 4088 } 4089 4090 /** 4091 * wmi_unified_bss_chan_info_request_cmd_send() - WMI bss chan info request function 4092 * @param wmi_handle : handle to WMI. 4093 * @param param : pointer to hold chan info param 4094 * 4095 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4096 */ 4097 QDF_STATUS wmi_unified_bss_chan_info_request_cmd_send(void *wmi_hdl, 4098 struct bss_chan_info_request_params *param) 4099 { 4100 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4101 4102 if (wmi->ops->send_bss_chan_info_request_cmd) 4103 return wmi->ops->send_bss_chan_info_request_cmd(wmi, param); 4104 4105 return QDF_STATUS_E_FAILURE; 4106 } 4107 4108 /** 4109 * wmi_unified_thermal_mitigation_param_cmd_send() - WMI thermal mitigation function 4110 * @param wmi_handle : handle to WMI. 4111 * @param param : pointer to hold thermal mitigation param 4112 * 4113 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4114 */ 4115 QDF_STATUS wmi_unified_thermal_mitigation_param_cmd_send(void *wmi_hdl, 4116 struct thermal_mitigation_params *param) 4117 { 4118 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4119 4120 if (wmi->ops->send_thermal_mitigation_param_cmd) 4121 return wmi->ops->send_thermal_mitigation_param_cmd(wmi, param); 4122 4123 return QDF_STATUS_E_FAILURE; 4124 } 4125 4126 /** 4127 * wmi_unified_vdev_set_neighbour_rx_cmd_send() - WMI set neighbour rx function 4128 * @param wmi_handle : handle to WMI. 4129 * @param macaddr : MAC address 4130 * @param param : pointer to hold neighbour rx parameter 4131 * 4132 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4133 */ 4134 QDF_STATUS wmi_unified_vdev_set_neighbour_rx_cmd_send(void *wmi_hdl, 4135 uint8_t macaddr[IEEE80211_ADDR_LEN], 4136 struct set_neighbour_rx_params *param) 4137 { 4138 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4139 4140 if (wmi->ops->send_vdev_set_neighbour_rx_cmd) 4141 return wmi->ops->send_vdev_set_neighbour_rx_cmd(wmi, 4142 macaddr, param); 4143 4144 return QDF_STATUS_E_FAILURE; 4145 } 4146 4147 /** 4148 * wmi_unified_vdev_set_fwtest_param_cmd_send() - WMI set fwtest function 4149 * @param wmi_handle : handle to WMI. 4150 * @param param : pointer to hold fwtest param 4151 * 4152 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4153 */ 4154 QDF_STATUS wmi_unified_vdev_set_fwtest_param_cmd_send(void *wmi_hdl, 4155 struct set_fwtest_params *param) 4156 { 4157 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4158 4159 if (wmi->ops->send_vdev_set_fwtest_param_cmd) 4160 return wmi->ops->send_vdev_set_fwtest_param_cmd(wmi, param); 4161 4162 return QDF_STATUS_E_FAILURE; 4163 } 4164 4165 #ifdef WLAN_SUPPORT_FILS 4166 QDF_STATUS 4167 wmi_unified_fils_discovery_send_cmd(void *wmi_hdl, struct fd_params *param) 4168 { 4169 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4170 4171 if (wmi_handle->ops->send_fils_discovery_send_cmd) 4172 return wmi_handle->ops->send_fils_discovery_send_cmd(wmi_handle, 4173 param); 4174 4175 return QDF_STATUS_E_FAILURE; 4176 } 4177 4178 QDF_STATUS 4179 wmi_unified_fils_vdev_config_send_cmd(void *wmi_hdl, 4180 struct config_fils_params *param) 4181 { 4182 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4183 4184 if (wmi->ops->send_vdev_fils_enable_cmd) 4185 return wmi->ops->send_vdev_fils_enable_cmd(wmi, param); 4186 4187 return QDF_STATUS_E_FAILURE; 4188 } 4189 4190 QDF_STATUS 4191 wmi_extract_swfda_vdev_id(void *wmi_hdl, void *evt_buf, 4192 uint32_t *vdev_id) 4193 { 4194 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4195 4196 if (wmi_handle->ops->extract_swfda_vdev_id) 4197 return wmi_handle->ops->extract_swfda_vdev_id(wmi_handle, 4198 evt_buf, vdev_id); 4199 4200 return QDF_STATUS_E_FAILURE; 4201 } 4202 #endif /* WLAN_SUPPORT_FILS */ 4203 4204 /** 4205 * wmi_unified_vdev_config_ratemask_cmd_send() - WMI config ratemask function 4206 * @param wmi_handle : handle to WMI. 4207 * @param param : pointer to hold config ratemask param 4208 * 4209 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4210 */ 4211 QDF_STATUS wmi_unified_vdev_config_ratemask_cmd_send(void *wmi_hdl, 4212 struct config_ratemask_params *param) 4213 { 4214 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4215 4216 if (wmi->ops->send_vdev_config_ratemask_cmd) 4217 return wmi->ops->send_vdev_config_ratemask_cmd(wmi, param); 4218 4219 return QDF_STATUS_E_FAILURE; 4220 } 4221 4222 /** 4223 * wmi_unified_vdev_set_custom_aggr_size_cmd_send() - WMI set custom aggr 4224 * size function 4225 * @param wmi_handle : handle to WMI 4226 * @param param : pointer to hold custom aggr size param 4227 * 4228 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_R_FAILURE for failure 4229 */ 4230 QDF_STATUS wmi_unified_vdev_set_custom_aggr_size_cmd_send(void *wmi_hdl, 4231 struct set_custom_aggr_size_params *param) 4232 { 4233 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4234 4235 if (wmi->ops->send_vdev_set_custom_aggr_size_cmd) 4236 return wmi->ops->send_vdev_set_custom_aggr_size_cmd(wmi, param); 4237 4238 return QDF_STATUS_E_FAILURE; 4239 } 4240 4241 /** 4242 * wmi_unified_vdev_set_qdepth_thresh_cmd_send() - WMI set qdepth threshold 4243 * @param wmi_handle : handle to WMI 4244 * @param param : pointer to hold qdepth threshold params 4245 * 4246 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_R_FAILURE for failure 4247 */ 4248 QDF_STATUS wmi_unified_vdev_set_qdepth_thresh_cmd_send(void *wmi_hdl, 4249 struct set_qdepth_thresh_params *param) 4250 { 4251 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4252 4253 if (wmi->ops->send_vdev_set_qdepth_thresh_cmd) 4254 return wmi->ops->send_vdev_set_qdepth_thresh_cmd(wmi, param); 4255 4256 return QDF_STATUS_E_FAILURE; 4257 } 4258 4259 /** 4260 * wmi_unified_pdev_set_regdomain_params_cmd_send() - WMI set regdomain function 4261 * @param wmi_handle : handle to WMI. 4262 * @param param : pointer to hold regdomain param 4263 * 4264 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4265 */ 4266 QDF_STATUS wmi_unified_pdev_set_regdomain_cmd_send(void *wmi_hdl, 4267 struct pdev_set_regdomain_params *param) 4268 { 4269 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4270 4271 if (wmi_handle->ops->send_pdev_set_regdomain_cmd) 4272 return wmi_handle->ops->send_pdev_set_regdomain_cmd(wmi_handle, 4273 param); 4274 4275 return QDF_STATUS_E_FAILURE; 4276 } 4277 4278 /** 4279 * wmi_unified_set_quiet_mode_cmd_send() - WMI set quiet mode function 4280 * @param wmi_handle : handle to WMI. 4281 * @param param : pointer to hold quiet mode param 4282 * 4283 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4284 */ 4285 QDF_STATUS wmi_unified_set_quiet_mode_cmd_send(void *wmi_hdl, 4286 struct set_quiet_mode_params *param) 4287 { 4288 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4289 4290 if (wmi_handle->ops->send_set_quiet_mode_cmd) 4291 return wmi_handle->ops->send_set_quiet_mode_cmd(wmi_handle, 4292 param); 4293 4294 return QDF_STATUS_E_FAILURE; 4295 } 4296 4297 /** 4298 * wmi_unified_set_beacon_filter_cmd_send() - WMI set beacon filter function 4299 * @param wmi_handle : handle to WMI. 4300 * @param param : pointer to hold beacon filter param 4301 * 4302 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4303 */ 4304 QDF_STATUS wmi_unified_set_beacon_filter_cmd_send(void *wmi_hdl, 4305 struct set_beacon_filter_params *param) 4306 { 4307 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4308 4309 if (wmi_handle->ops->send_set_beacon_filter_cmd) 4310 return wmi_handle->ops->send_set_beacon_filter_cmd(wmi_handle, 4311 param); 4312 4313 return QDF_STATUS_E_FAILURE; 4314 } 4315 4316 /** 4317 * wmi_unified_remove_beacon_filter_cmd_send() - WMI set beacon filter function 4318 * @param wmi_handle : handle to WMI. 4319 * @param param : pointer to hold beacon filter param 4320 * 4321 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4322 */ 4323 QDF_STATUS wmi_unified_remove_beacon_filter_cmd_send(void *wmi_hdl, 4324 struct remove_beacon_filter_params *param) 4325 { 4326 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4327 4328 if (wmi->ops->send_remove_beacon_filter_cmd) 4329 return wmi->ops->send_remove_beacon_filter_cmd(wmi, param); 4330 4331 return QDF_STATUS_E_FAILURE; 4332 } 4333 4334 /** 4335 * wmi_unified_mgmt_cmd_send() - WMI mgmt cmd function 4336 * @param wmi_handle : handle to WMI. 4337 * @param macaddr : MAC address 4338 * @param param : pointer to hold mgmt parameter 4339 * 4340 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4341 */ 4342 #if 0 4343 QDF_STATUS wmi_unified_mgmt_cmd_send(void *wmi_hdl, 4344 uint8_t macaddr[IEEE80211_ADDR_LEN], 4345 struct mgmt_params *param) 4346 { 4347 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4348 4349 if (wmi_handle->ops->send_mgmt_cmd) 4350 return wmi_handle->ops->send_mgmt_cmd(wmi_handle, 4351 macaddr, param); 4352 4353 return QDF_STATUS_E_FAILURE; 4354 } 4355 #endif 4356 4357 /** 4358 * wmi_unified_addba_clearresponse_cmd_send() - WMI addba resp cmd function 4359 * @param wmi_handle : handle to WMI. 4360 * @param macaddr : MAC address 4361 * @param param : pointer to hold addba resp parameter 4362 * 4363 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4364 */ 4365 QDF_STATUS wmi_unified_addba_clearresponse_cmd_send(void *wmi_hdl, 4366 uint8_t macaddr[IEEE80211_ADDR_LEN], 4367 struct addba_clearresponse_params *param) 4368 { 4369 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4370 4371 if (wmi_handle->ops->send_addba_clearresponse_cmd) 4372 return wmi_handle->ops->send_addba_clearresponse_cmd(wmi_handle, 4373 macaddr, param); 4374 4375 return QDF_STATUS_E_FAILURE; 4376 } 4377 4378 /** 4379 * wmi_unified_addba_send_cmd_send() - WMI addba send function 4380 * @param wmi_handle : handle to WMI. 4381 * @param macaddr : MAC address 4382 * @param param : pointer to hold addba parameter 4383 * 4384 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4385 */ 4386 QDF_STATUS wmi_unified_addba_send_cmd_send(void *wmi_hdl, 4387 uint8_t macaddr[IEEE80211_ADDR_LEN], 4388 struct addba_send_params *param) 4389 { 4390 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4391 4392 if (wmi_handle->ops->send_addba_send_cmd) 4393 return wmi_handle->ops->send_addba_send_cmd(wmi_handle, 4394 macaddr, param); 4395 4396 return QDF_STATUS_E_FAILURE; 4397 } 4398 4399 /** 4400 * wmi_unified_delba_send_cmd_send() - WMI delba cmd function 4401 * @param wmi_handle : handle to WMI. 4402 * @param macaddr : MAC address 4403 * @param param : pointer to hold delba parameter 4404 * 4405 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4406 */ 4407 QDF_STATUS wmi_unified_delba_send_cmd_send(void *wmi_hdl, 4408 uint8_t macaddr[IEEE80211_ADDR_LEN], 4409 struct delba_send_params *param) 4410 { 4411 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4412 4413 if (wmi_handle->ops->send_delba_send_cmd) 4414 return wmi_handle->ops->send_delba_send_cmd(wmi_handle, 4415 macaddr, param); 4416 4417 return QDF_STATUS_E_FAILURE; 4418 } 4419 4420 /** 4421 * wmi_unified_addba_setresponse_cmd_send() - WMI addba set resp cmd function 4422 * @param wmi_handle : handle to WMI. 4423 * @param macaddr : MAC address 4424 * @param param : pointer to hold addba set resp parameter 4425 * 4426 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4427 */ 4428 QDF_STATUS wmi_unified_addba_setresponse_cmd_send(void *wmi_hdl, 4429 uint8_t macaddr[IEEE80211_ADDR_LEN], 4430 struct addba_setresponse_params *param) 4431 { 4432 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4433 4434 if (wmi_handle->ops->send_addba_setresponse_cmd) 4435 return wmi_handle->ops->send_addba_setresponse_cmd(wmi_handle, 4436 macaddr, param); 4437 4438 return QDF_STATUS_E_FAILURE; 4439 } 4440 4441 /** 4442 * wmi_unified_singleamsdu_cmd_send() - WMI singleamsdu function 4443 * @param wmi_handle : handle to WMI. 4444 * @param macaddr : MAC address 4445 * @param param : pointer to hold singleamsdu parameter 4446 * 4447 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4448 */ 4449 QDF_STATUS wmi_unified_singleamsdu_cmd_send(void *wmi_hdl, 4450 uint8_t macaddr[IEEE80211_ADDR_LEN], 4451 struct singleamsdu_params *param) 4452 { 4453 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4454 4455 if (wmi_handle->ops->send_singleamsdu_cmd) 4456 return wmi_handle->ops->send_singleamsdu_cmd(wmi_handle, 4457 macaddr, param); 4458 4459 return QDF_STATUS_E_FAILURE; 4460 } 4461 4462 /** 4463 * wmi_unified_set_qboost_param_cmd_send() - WMI set_qboost function 4464 * @param wmi_handle : handle to WMI. 4465 * @param macaddr : MAC address 4466 * @param param : pointer to hold set_qboost parameter 4467 * 4468 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4469 */ 4470 QDF_STATUS wmi_unified_set_qboost_param_cmd_send(void *wmi_hdl, 4471 uint8_t macaddr[IEEE80211_ADDR_LEN], 4472 struct set_qboost_params *param) 4473 { 4474 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4475 4476 if (wmi_handle->ops->send_set_qboost_param_cmd) 4477 return wmi_handle->ops->send_set_qboost_param_cmd(wmi_handle, 4478 macaddr, param); 4479 4480 return QDF_STATUS_E_FAILURE; 4481 } 4482 4483 /** 4484 * wmi_unified_mu_scan_cmd_send() - WMI set mu scan function 4485 * @param wmi_handle : handle to WMI. 4486 * @param param : pointer to hold mu scan param 4487 * 4488 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4489 */ 4490 QDF_STATUS wmi_unified_mu_scan_cmd_send(void *wmi_hdl, 4491 struct mu_scan_params *param) 4492 { 4493 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4494 4495 if (wmi_handle->ops->send_mu_scan_cmd) 4496 return wmi_handle->ops->send_mu_scan_cmd(wmi_handle, param); 4497 4498 return QDF_STATUS_E_FAILURE; 4499 } 4500 4501 /** 4502 * wmi_unified_lteu_config_cmd_send() - WMI set mu scan function 4503 * @param wmi_handle : handle to WMI. 4504 * @param param : pointer to hold mu scan param 4505 * 4506 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4507 */ 4508 QDF_STATUS wmi_unified_lteu_config_cmd_send(void *wmi_hdl, 4509 struct lteu_config_params *param) 4510 { 4511 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4512 4513 if (wmi_handle->ops->send_lteu_config_cmd) 4514 return wmi_handle->ops->send_lteu_config_cmd(wmi_handle, param); 4515 4516 return QDF_STATUS_E_FAILURE; 4517 } 4518 4519 /** 4520 * wmi_unified_set_psmode_cmd_send() - WMI set mu scan function 4521 * @param wmi_handle : handle to WMI. 4522 * @param param : pointer to hold mu scan param 4523 * 4524 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4525 */ 4526 QDF_STATUS wmi_unified_set_psmode_cmd_send(void *wmi_hdl, 4527 struct set_ps_mode_params *param) 4528 { 4529 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4530 4531 if (wmi_handle->ops->send_set_ps_mode_cmd) 4532 return wmi_handle->ops->send_set_ps_mode_cmd(wmi_handle, param); 4533 4534 return QDF_STATUS_E_FAILURE; 4535 } 4536 4537 /** 4538 * wmi_unified_init_cmd_send() - send initialization cmd to fw 4539 * @wmi_handle: wmi handle 4540 * @param param: pointer to wmi init param 4541 * 4542 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4543 */ 4544 QDF_STATUS wmi_unified_init_cmd_send(void *wmi_hdl, 4545 struct wmi_init_cmd_param *param) 4546 { 4547 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4548 4549 if (wmi_handle->ops->init_cmd_send) 4550 return wmi_handle->ops->init_cmd_send(wmi_handle, param); 4551 4552 return QDF_STATUS_E_FAILURE; 4553 } 4554 4555 /** 4556 * wmi_save_service_bitmap() - save service bitmap 4557 * @wmi_handle: wmi handle 4558 * @param evt_buf: pointer to event buffer 4559 * 4560 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4561 */ 4562 QDF_STATUS wmi_save_service_bitmap(void *wmi_hdl, void *evt_buf, 4563 void *bitmap_buf) 4564 { 4565 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 4566 4567 if (wmi_handle->ops->save_service_bitmap) { 4568 return wmi_handle->ops->save_service_bitmap(wmi_handle, evt_buf, 4569 bitmap_buf); 4570 } 4571 return QDF_STATUS_E_FAILURE; 4572 } 4573 4574 /** 4575 * wmi_save_ext_service_bitmap() - save extended service bitmap 4576 * @wmi_handle: wmi handle 4577 * @param evt_buf: pointer to event buffer 4578 * 4579 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4580 */ 4581 QDF_STATUS wmi_save_ext_service_bitmap(void *wmi_hdl, void *evt_buf, 4582 void *bitmap_buf) 4583 { 4584 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 4585 4586 if (wmi_handle->ops->save_ext_service_bitmap) { 4587 return wmi_handle->ops->save_ext_service_bitmap(wmi_handle, 4588 evt_buf, bitmap_buf); 4589 } 4590 return QDF_STATUS_E_FAILURE; 4591 } 4592 4593 /** 4594 * wmi_save_fw_version() - Save fw version 4595 * @wmi_handle: wmi handle 4596 * @param evt_buf: pointer to event buffer 4597 * 4598 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4599 */ 4600 QDF_STATUS wmi_save_fw_version(void *wmi_hdl, void *evt_buf) 4601 { 4602 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 4603 4604 if (wmi_handle->ops->save_fw_version) { 4605 wmi_handle->ops->save_fw_version(wmi_handle, evt_buf); 4606 return 0; 4607 } 4608 return QDF_STATUS_E_FAILURE; 4609 4610 } 4611 4612 /** 4613 * wmi_check_and_update_fw_version() - Ready and fw version check 4614 * @wmi_handle: wmi handle 4615 * @param evt_buf: pointer to event buffer 4616 * 4617 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4618 */ 4619 QDF_STATUS wmi_check_and_update_fw_version(void *wmi_hdl, void *evt_buf) 4620 { 4621 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 4622 4623 if (wmi_handle->ops->check_and_update_fw_version) 4624 return wmi_handle->ops->check_and_update_fw_version(wmi_handle, 4625 evt_buf); 4626 4627 return QDF_STATUS_E_FAILURE; 4628 4629 } 4630 4631 /** 4632 * wmi_service_enabled() - Check if service enabled 4633 * @param wmi_handle: wmi handle 4634 * @param service_id: service identifier 4635 * 4636 * Return: 1 enabled, 0 disabled 4637 */ 4638 bool wmi_service_enabled(void *wmi_hdl, uint32_t service_id) 4639 { 4640 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4641 4642 if ((service_id < wmi_services_max) && 4643 (wmi_handle->services[service_id] != WMI_SERVICE_UNAVAILABLE)) { 4644 if (wmi_handle->ops->is_service_enabled) { 4645 return wmi_handle->ops->is_service_enabled(wmi_handle, 4646 wmi_handle->services[service_id]); 4647 } 4648 } else { 4649 qdf_print("Support not added yet for Service %d\n", service_id); 4650 } 4651 4652 return false; 4653 } 4654 4655 /** 4656 * wmi_get_target_cap_from_service_ready() - extract service ready event 4657 * @wmi_handle: wmi handle 4658 * @param evt_buf: pointer to received event buffer 4659 * @param ev: pointer to hold target capability information extracted from even 4660 * 4661 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4662 */ 4663 QDF_STATUS wmi_get_target_cap_from_service_ready(void *wmi_hdl, 4664 void *evt_buf, struct wlan_psoc_target_capability_info *ev) 4665 { 4666 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4667 4668 if (wmi->ops->get_target_cap_from_service_ready) 4669 return wmi->ops->get_target_cap_from_service_ready(wmi, 4670 evt_buf, ev); 4671 4672 return QDF_STATUS_E_FAILURE; 4673 } 4674 4675 /** 4676 * wmi_extract_fw_version() - extract fw version 4677 * @wmi_handle: wmi handle 4678 * @param evt_buf: pointer to event buffer 4679 * @param fw_ver: Pointer to hold fw version 4680 * 4681 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4682 */ 4683 QDF_STATUS wmi_extract_fw_version(void *wmi_hdl, 4684 void *evt_buf, struct wmi_host_fw_ver *fw_ver) 4685 { 4686 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4687 4688 if (wmi_handle->ops->extract_fw_version) 4689 return wmi_handle->ops->extract_fw_version(wmi_handle, 4690 evt_buf, fw_ver); 4691 4692 return QDF_STATUS_E_FAILURE; 4693 } 4694 4695 /** 4696 * wmi_extract_fw_abi_version() - extract fw abi version 4697 * @wmi_handle: wmi handle 4698 * @param evt_buf: Pointer to event buffer 4699 * @param fw_ver: Pointer to hold fw abi version 4700 * 4701 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4702 */ 4703 QDF_STATUS wmi_extract_fw_abi_version(void *wmi_hdl, 4704 void *evt_buf, struct wmi_host_fw_abi_ver *fw_ver) 4705 { 4706 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4707 4708 if (wmi_handle->ops->extract_fw_abi_version) 4709 return wmi_handle->ops->extract_fw_abi_version(wmi_handle, 4710 evt_buf, fw_ver); 4711 4712 return QDF_STATUS_E_FAILURE; 4713 } 4714 4715 /** 4716 * wmi_extract_hal_reg_cap() - extract HAL registered capabilities 4717 * @wmi_handle: wmi handle 4718 * @param evt_buf: Pointer to event buffer 4719 * @param hal_reg_cap: pointer to hold HAL reg capabilities 4720 * 4721 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4722 */ 4723 QDF_STATUS wmi_extract_hal_reg_cap(void *wmi_hdl, void *evt_buf, 4724 struct wlan_psoc_hal_reg_capability *hal_reg_cap) 4725 { 4726 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4727 4728 if (wmi_handle->ops->extract_hal_reg_cap) 4729 return wmi_handle->ops->extract_hal_reg_cap(wmi_handle, 4730 evt_buf, hal_reg_cap); 4731 4732 return QDF_STATUS_E_FAILURE; 4733 } 4734 4735 /** 4736 * wmi_extract_host_mem_req_from_service_ready() - Extract host memory 4737 * request event 4738 * @wmi_handle: wmi handle 4739 * @param evt_buf: pointer to event buffer 4740 * @param num_entries: pointer to hold number of entries requested 4741 * 4742 * Return: Number of entries requested 4743 */ 4744 host_mem_req *wmi_extract_host_mem_req_from_service_ready(void *wmi_hdl, 4745 void *evt_buf, uint8_t *num_entries) 4746 { 4747 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4748 4749 if (wmi_handle->ops->extract_host_mem_req) 4750 return wmi_handle->ops->extract_host_mem_req(wmi_handle, 4751 evt_buf, num_entries); 4752 4753 *num_entries = 0; 4754 return NULL; 4755 } 4756 4757 /** 4758 * wmi_ready_extract_init_status() - Extract init status from ready event 4759 * @wmi_handle: wmi handle 4760 * @param ev: Pointer to event buffer 4761 * 4762 * Return: ready status 4763 */ 4764 uint32_t wmi_ready_extract_init_status(void *wmi_hdl, void *ev) 4765 { 4766 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4767 4768 if (wmi_handle->ops->ready_extract_init_status) 4769 return wmi_handle->ops->ready_extract_init_status(wmi_handle, 4770 ev); 4771 4772 4773 return 1; 4774 4775 } 4776 4777 /** 4778 * wmi_ready_extract_mac_addr() - extract mac address from ready event 4779 * @wmi_handle: wmi handle 4780 * @param ev: pointer to event buffer 4781 * @param macaddr: Pointer to hold MAC address 4782 * 4783 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4784 */ 4785 QDF_STATUS wmi_ready_extract_mac_addr(void *wmi_hdl, void *ev, uint8_t *macaddr) 4786 { 4787 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4788 4789 if (wmi_handle->ops->ready_extract_mac_addr) 4790 return wmi_handle->ops->ready_extract_mac_addr(wmi_handle, 4791 ev, macaddr); 4792 4793 4794 return QDF_STATUS_E_FAILURE; 4795 } 4796 4797 /** 4798 * wmi_ready_extract_mac_addr() - extract MAC address list from ready event 4799 * @wmi_handle: wmi handle 4800 * @param ev: pointer to event buffer 4801 * @param num_mac_addr: Pointer to number of entries 4802 * 4803 * Return: address to start of mac addr list 4804 */ 4805 wmi_host_mac_addr *wmi_ready_extract_mac_addr_list(void *wmi_hdl, void *ev, 4806 uint8_t *num_mac_addr) 4807 { 4808 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4809 4810 if (wmi_handle->ops->ready_extract_mac_addr_list) 4811 return wmi_handle->ops->ready_extract_mac_addr_list(wmi_handle, 4812 ev, num_mac_addr); 4813 4814 *num_mac_addr = 0; 4815 4816 return NULL; 4817 } 4818 4819 /** 4820 * wmi_extract_ready_params() - Extract data from ready event apart from 4821 * status, macaddr and version. 4822 * @wmi_handle: Pointer to WMI handle. 4823 * @evt_buf: Pointer to Ready event buffer. 4824 * @ev_param: Pointer to host defined struct to copy the data from event. 4825 * 4826 * Return: QDF_STATUS_SUCCESS on success. 4827 */ 4828 QDF_STATUS wmi_extract_ready_event_params(void *wmi_hdl, 4829 void *evt_buf, struct wmi_host_ready_ev_param *ev_param) 4830 { 4831 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4832 4833 if (wmi_handle->ops->extract_ready_event_params) 4834 return wmi_handle->ops->extract_ready_event_params(wmi_handle, 4835 evt_buf, ev_param); 4836 4837 return QDF_STATUS_E_FAILURE; 4838 } 4839 4840 /** 4841 * wmi_extract_dbglog_data_len() - extract debuglog data length 4842 * @wmi_handle: wmi handle 4843 * @param evt_buf: pointer to event buffer 4844 * @param len: length of buffer 4845 * 4846 * Return: length 4847 */ 4848 uint8_t *wmi_extract_dbglog_data_len(void *wmi_hdl, void *evt_buf, 4849 uint32_t *len) 4850 { 4851 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4852 4853 if (wmi_handle->ops->extract_dbglog_data_len) 4854 return wmi_handle->ops->extract_dbglog_data_len(wmi_handle, 4855 evt_buf, len); 4856 4857 4858 return NULL; 4859 } 4860 qdf_export_symbol(wmi_extract_dbglog_data_len); 4861 4862 /** 4863 * wmi_send_ext_resource_config() - send extended resource configuration 4864 * @wmi_handle: wmi handle 4865 * @param ext_cfg: pointer to extended resource configuration 4866 * 4867 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4868 */ 4869 QDF_STATUS wmi_send_ext_resource_config(void *wmi_hdl, 4870 wmi_host_ext_resource_config *ext_cfg) 4871 { 4872 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4873 4874 if (wmi_handle->ops->send_ext_resource_config) 4875 return wmi_handle->ops->send_ext_resource_config(wmi_handle, 4876 ext_cfg); 4877 4878 return QDF_STATUS_E_FAILURE; 4879 } 4880 4881 /** 4882 * wmi_unified_nf_dbr_dbm_info_get_cmd_send() - WMI request nf info function 4883 * @param wmi_handle : handle to WMI. 4884 * @mac_id: mac_id 4885 * 4886 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4887 */ 4888 QDF_STATUS wmi_unified_nf_dbr_dbm_info_get_cmd_send(void *wmi_hdl, 4889 uint8_t mac_id) 4890 { 4891 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4892 4893 if (wmi->ops->send_nf_dbr_dbm_info_get_cmd) 4894 return wmi->ops->send_nf_dbr_dbm_info_get_cmd(wmi, mac_id); 4895 4896 return QDF_STATUS_E_FAILURE; 4897 } 4898 4899 /** 4900 * wmi_unified_packet_power_info_get_cmd_send() - WMI get packet power info function 4901 * @param wmi_handle : handle to WMI. 4902 * @param param : pointer to hold packet power info param 4903 * 4904 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4905 */ 4906 QDF_STATUS wmi_unified_packet_power_info_get_cmd_send(void *wmi_hdl, 4907 struct packet_power_info_params *param) 4908 { 4909 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 4910 4911 if (wmi->ops->send_packet_power_info_get_cmd) 4912 return wmi->ops->send_packet_power_info_get_cmd(wmi, param); 4913 4914 return QDF_STATUS_E_FAILURE; 4915 } 4916 4917 /** 4918 * wmi_unified_gpio_config_cmd_send() - WMI gpio config function 4919 * @param wmi_handle : handle to WMI. 4920 * @param param : pointer to hold gpio config param 4921 * 4922 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4923 */ 4924 QDF_STATUS wmi_unified_gpio_config_cmd_send(void *wmi_hdl, 4925 struct gpio_config_params *param) 4926 { 4927 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4928 4929 if (wmi_handle->ops->send_gpio_config_cmd) 4930 return wmi_handle->ops->send_gpio_config_cmd(wmi_handle, param); 4931 4932 return QDF_STATUS_E_FAILURE; 4933 } 4934 4935 /** 4936 * wmi_unified_gpio_output_cmd_send() - WMI gpio config function 4937 * @param wmi_handle : handle to WMI. 4938 * @param param : pointer to hold gpio config param 4939 * 4940 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4941 */ 4942 QDF_STATUS wmi_unified_gpio_output_cmd_send(void *wmi_hdl, 4943 struct gpio_output_params *param) 4944 { 4945 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4946 4947 if (wmi_handle->ops->send_gpio_output_cmd) 4948 return wmi_handle->ops->send_gpio_output_cmd(wmi_handle, param); 4949 4950 return QDF_STATUS_E_FAILURE; 4951 } 4952 4953 /** 4954 * wmi_unified_rtt_meas_req_test_cmd_send() - WMI rtt meas req test function 4955 * @param wmi_handle : handle to WMI. 4956 * @param param : pointer to hold rtt meas req test param 4957 * 4958 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4959 */ 4960 QDF_STATUS wmi_unified_rtt_meas_req_test_cmd_send(void *wmi_hdl, 4961 struct rtt_meas_req_test_params *param) 4962 { 4963 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4964 4965 if (wmi_handle->ops->send_rtt_meas_req_test_cmd) 4966 return wmi_handle->ops->send_rtt_meas_req_test_cmd(wmi_handle, 4967 param); 4968 4969 return QDF_STATUS_E_FAILURE; 4970 } 4971 4972 /** 4973 * wmi_unified_rtt_meas_req_cmd_send() - WMI rtt meas req function 4974 * @param wmi_handle : handle to WMI. 4975 * @param param : pointer to hold rtt meas req param 4976 * 4977 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4978 */ 4979 QDF_STATUS wmi_unified_rtt_meas_req_cmd_send(void *wmi_hdl, 4980 struct rtt_meas_req_params *param) 4981 { 4982 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4983 4984 if (wmi_handle->ops->send_rtt_meas_req_cmd) 4985 return wmi_handle->ops->send_rtt_meas_req_cmd(wmi_handle, 4986 param); 4987 4988 return QDF_STATUS_E_FAILURE; 4989 } 4990 4991 /** 4992 * wmi_unified_lci_set_cmd_send() - WMI lci set function 4993 * @param wmi_handle : handle to WMI. 4994 * @param param : pointer to hold lci param 4995 * 4996 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4997 */ 4998 QDF_STATUS wmi_unified_lci_set_cmd_send(void *wmi_hdl, 4999 struct lci_set_params *param) 5000 { 5001 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5002 5003 if (wmi_handle->ops->send_lci_set_cmd) 5004 return wmi_handle->ops->send_lci_set_cmd(wmi_handle, param); 5005 5006 return QDF_STATUS_E_FAILURE; 5007 } 5008 5009 /** 5010 * wmi_unified_lcr_set_cmd_send() - WMI lcr set function 5011 * @param wmi_handle : handle to WMI. 5012 * @param param : pointer to hold lcr param 5013 * 5014 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5015 */ 5016 QDF_STATUS wmi_unified_lcr_set_cmd_send(void *wmi_hdl, 5017 struct lcr_set_params *param) 5018 { 5019 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5020 5021 if (wmi_handle->ops->send_lcr_set_cmd) 5022 return wmi_handle->ops->send_lcr_set_cmd(wmi_handle, param); 5023 5024 return QDF_STATUS_E_FAILURE; 5025 } 5026 5027 /** 5028 * wmi_unified_rtt_keepalive_req_cmd_send() - WMI rtt meas req test function 5029 * @param wmi_handle : handle to WMI. 5030 * @param param : pointer to hold rtt meas req test param 5031 * 5032 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5033 */ 5034 QDF_STATUS wmi_unified_rtt_keepalive_req_cmd_send(void *wmi_hdl, 5035 struct rtt_keepalive_req_params *param) 5036 { 5037 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5038 5039 if (wmi_handle->ops->send_rtt_keepalive_req_cmd) 5040 return wmi_handle->ops->send_rtt_keepalive_req_cmd(wmi_handle, 5041 param); 5042 5043 return QDF_STATUS_E_FAILURE; 5044 } 5045 5046 /** 5047 * wmi_unified_send_periodic_chan_stats_config_cmd() - send periodic chan stats cmd 5048 * to fw 5049 * @wmi_handle: wmi handle 5050 * @param: pointer to hold periodic chan stats param 5051 * 5052 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5053 */ 5054 QDF_STATUS wmi_unified_send_periodic_chan_stats_config_cmd(void *wmi_hdl, 5055 struct periodic_chan_stats_params *param) 5056 { 5057 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5058 5059 if (wmi->ops->send_periodic_chan_stats_config_cmd) 5060 return wmi->ops->send_periodic_chan_stats_config_cmd(wmi, 5061 param); 5062 5063 return QDF_STATUS_E_FAILURE; 5064 } 5065 5066 /** 5067 * wmi_send_atf_peer_request_cmd() - send atf peer request command to fw 5068 * @wmi_handle: wmi handle 5069 * @param: pointer to atf peer request param 5070 * 5071 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5072 */ 5073 QDF_STATUS 5074 wmi_send_atf_peer_request_cmd(void *wmi_hdl, 5075 struct atf_peer_request_params *param) 5076 { 5077 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5078 5079 if (wmi_handle->ops->send_atf_peer_request_cmd) 5080 return wmi_handle->ops->send_atf_peer_request_cmd(wmi_handle, 5081 param); 5082 5083 return QDF_STATUS_E_FAILURE; 5084 } 5085 5086 /** 5087 * wmi_send_set_atf_grouping_cmd() - send set atf grouping command to fw 5088 * @wmi_handle: wmi handle 5089 * @param: pointer to set atf grouping param 5090 * 5091 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5092 */ 5093 QDF_STATUS 5094 wmi_send_set_atf_grouping_cmd(void *wmi_hdl, 5095 struct atf_grouping_params *param) 5096 { 5097 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5098 5099 if (wmi_handle->ops->send_set_atf_grouping_cmd) 5100 return wmi_handle->ops->send_set_atf_grouping_cmd(wmi_handle, 5101 param); 5102 5103 return QDF_STATUS_E_FAILURE; 5104 5105 } 5106 5107 /** 5108 * wmi_send_get_user_position_cmd() - send get user position command to fw 5109 * @wmi_handle: wmi handle 5110 * 5111 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5112 */ 5113 QDF_STATUS 5114 wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value) 5115 { 5116 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5117 5118 if (wmi_handle->ops->send_get_user_position_cmd) 5119 return wmi_handle->ops->send_get_user_position_cmd(wmi_handle, 5120 value); 5121 5122 return QDF_STATUS_E_FAILURE; 5123 } 5124 5125 /** 5126 * wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count 5127 * command to fw 5128 * @wmi_handle: wmi handle 5129 * @value: user pos value 5130 * 5131 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5132 */ 5133 QDF_STATUS 5134 wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value) 5135 { 5136 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5137 5138 if (wmi->ops->send_get_peer_mumimo_tx_count_cmd) 5139 return wmi->ops->send_get_peer_mumimo_tx_count_cmd(wmi, value); 5140 5141 return QDF_STATUS_E_FAILURE; 5142 } 5143 5144 /** 5145 * wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo 5146 * tx count to fw 5147 * @wmi_handle: wmi handle 5148 * @value: reset tx count value 5149 * 5150 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5151 */ 5152 QDF_STATUS 5153 wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value) 5154 { 5155 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5156 5157 if (wmi->ops->send_reset_peer_mumimo_tx_count_cmd) 5158 return wmi->ops->send_reset_peer_mumimo_tx_count_cmd(wmi, 5159 value); 5160 5161 return QDF_STATUS_E_FAILURE; 5162 } 5163 5164 /** 5165 * wmi_send_pdev_caldata_version_check_cmd() - send reset peer mumimo 5166 * tx count to fw 5167 * @wmi_handle: wmi handle 5168 * @value: value 5169 * 5170 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5171 */ 5172 QDF_STATUS 5173 wmi_send_pdev_caldata_version_check_cmd(void *wmi_hdl, uint32_t value) 5174 { 5175 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5176 5177 if (wmi->ops->send_pdev_caldata_version_check_cmd) 5178 return wmi->ops->send_pdev_caldata_version_check_cmd(wmi, 5179 value); 5180 5181 return QDF_STATUS_E_FAILURE; 5182 } 5183 5184 /* Extract - APIs */ 5185 /** 5186 * wmi_extract_wds_addr_event - Extract WDS addr WMI event 5187 * 5188 * @param wmi_handle : handle to WMI. 5189 * @param evt_buf : pointer to event buffer 5190 * @param len : length of the event buffer 5191 * @param wds_ev: pointer to strct to extract 5192 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5193 */ 5194 QDF_STATUS wmi_extract_wds_addr_event(void *wmi_hdl, void *evt_buf, 5195 uint16_t len, wds_addr_event_t *wds_ev) 5196 { 5197 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5198 5199 if (wmi_handle->ops->extract_wds_addr_event) { 5200 return wmi_handle->ops->extract_wds_addr_event(wmi_handle, 5201 evt_buf, len, wds_ev); 5202 } 5203 return QDF_STATUS_E_FAILURE; 5204 } 5205 qdf_export_symbol(wmi_extract_wds_addr_event); 5206 5207 /** 5208 * wmi_extract_dcs_interference_type() - extract dcs interference type 5209 * @wmi_handle: wmi handle 5210 * @param evt_buf: pointer to event buffer 5211 * @param param: Pointer to hold dcs interference param 5212 * 5213 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5214 */ 5215 QDF_STATUS wmi_extract_dcs_interference_type(void *wmi_hdl, 5216 void *evt_buf, struct wmi_host_dcs_interference_param *param) 5217 { 5218 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5219 5220 if (wmi->ops->extract_dcs_interference_type) { 5221 return wmi->ops->extract_dcs_interference_type(wmi, 5222 evt_buf, param); 5223 } 5224 return QDF_STATUS_E_FAILURE; 5225 } 5226 5227 /* 5228 * wmi_extract_dcs_cw_int() - extract dcs cw interference from event 5229 * @wmi_handle: wmi handle 5230 * @param evt_buf: pointer to event buffer 5231 * @param cw_int: Pointer to hold cw interference 5232 * 5233 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5234 */ 5235 QDF_STATUS wmi_extract_dcs_cw_int(void *wmi_hdl, void *evt_buf, 5236 wmi_host_ath_dcs_cw_int *cw_int) 5237 { 5238 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5239 5240 if (wmi_handle->ops->extract_dcs_cw_int) { 5241 return wmi_handle->ops->extract_dcs_cw_int(wmi_handle, 5242 evt_buf, cw_int); 5243 } 5244 return QDF_STATUS_E_FAILURE; 5245 } 5246 5247 /** 5248 * wmi_extract_dcs_im_tgt_stats() - extract dcs im target stats from event 5249 * @wmi_handle: wmi handle 5250 * @param evt_buf: pointer to event buffer 5251 * @param wlan_stat: Pointer to hold wlan stats 5252 * 5253 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5254 */ 5255 QDF_STATUS wmi_extract_dcs_im_tgt_stats(void *wmi_hdl, void *evt_buf, 5256 wmi_host_dcs_im_tgt_stats_t *wlan_stat) 5257 { 5258 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5259 5260 if (wmi_handle->ops->extract_dcs_im_tgt_stats) { 5261 return wmi_handle->ops->extract_dcs_im_tgt_stats(wmi_handle, 5262 evt_buf, wlan_stat); 5263 } 5264 return QDF_STATUS_E_FAILURE; 5265 } 5266 5267 /** 5268 * wmi_extract_fips_event_data() - extract fips event data 5269 * @wmi_handle: wmi handle 5270 * @param evt_buf: pointer to event buffer 5271 * @param param: pointer to FIPS event param 5272 * 5273 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5274 */ 5275 QDF_STATUS wmi_extract_fips_event_data(void *wmi_hdl, void *evt_buf, 5276 struct wmi_host_fips_event_param *param) 5277 { 5278 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5279 5280 if (wmi_handle->ops->extract_fips_event_data) { 5281 return wmi_handle->ops->extract_fips_event_data(wmi_handle, 5282 evt_buf, param); 5283 } 5284 return QDF_STATUS_E_FAILURE; 5285 } 5286 5287 /** 5288 * wmi_extract_vdev_start_resp() - extract vdev start response 5289 * @wmi_handle: wmi handle 5290 * @param evt_buf: pointer to event buffer 5291 * @param vdev_rsp: Pointer to hold vdev response 5292 * 5293 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5294 */ 5295 QDF_STATUS wmi_extract_vdev_start_resp(void *wmi_hdl, void *evt_buf, 5296 wmi_host_vdev_start_resp *vdev_rsp) 5297 { 5298 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5299 5300 if (wmi_handle->ops->extract_vdev_start_resp) 5301 return wmi_handle->ops->extract_vdev_start_resp(wmi_handle, 5302 evt_buf, vdev_rsp); 5303 5304 return QDF_STATUS_E_FAILURE; 5305 } 5306 5307 /** 5308 * wmi_extract_vdev_delete_resp() - extract vdev delete response 5309 * @wmi_handle: wmi handle 5310 * @param evt_buf: pointer to event buffer 5311 * @param delete_rsp: Pointer to hold vdev delete response 5312 * 5313 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5314 */ 5315 QDF_STATUS wmi_extract_vdev_delete_resp(void *wmi_hdl, void *evt_buf, 5316 struct wmi_host_vdev_delete_resp *delete_rsp) 5317 { 5318 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5319 5320 if (wmi_handle->ops->extract_vdev_delete_resp) 5321 return wmi_handle->ops->extract_vdev_delete_resp(wmi_handle, 5322 evt_buf, delete_rsp); 5323 5324 return QDF_STATUS_E_FAILURE; 5325 } 5326 5327 5328 /** 5329 * wmi_extract_tbttoffset_num_vdevs() - extract tbtt offset num vdev 5330 * @wmi_handle: wmi handle 5331 * @param evt_buf: pointer to event buffer 5332 * @param vdev_map: Pointer to hold num vdev 5333 * 5334 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5335 */ 5336 QDF_STATUS wmi_extract_tbttoffset_num_vdevs(void *wmi_hdl, void *evt_buf, 5337 uint32_t *num_vdevs) 5338 { 5339 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5340 5341 if (wmi->ops->extract_tbttoffset_num_vdevs) 5342 return wmi->ops->extract_tbttoffset_num_vdevs(wmi, 5343 evt_buf, num_vdevs); 5344 5345 return QDF_STATUS_E_FAILURE; 5346 } 5347 5348 /** 5349 * wmi_extract_ext_tbttoffset_num_vdevs() - extract ext tbtt offset num vdev 5350 * @wmi_handle: wmi handle 5351 * @param evt_buf: pointer to event buffer 5352 * @param vdev_map: Pointer to hold num vdev 5353 * 5354 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5355 */ 5356 QDF_STATUS wmi_extract_ext_tbttoffset_num_vdevs(void *wmi_hdl, void *evt_buf, 5357 uint32_t *num_vdevs) 5358 { 5359 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5360 5361 if (wmi->ops->extract_ext_tbttoffset_num_vdevs) 5362 return wmi->ops->extract_ext_tbttoffset_num_vdevs(wmi, 5363 evt_buf, num_vdevs); 5364 5365 return QDF_STATUS_E_FAILURE; 5366 } 5367 5368 /** 5369 * wmi_extract_tbttoffset_update_params() - extract tbtt offset update param 5370 * @wmi_handle: wmi handle 5371 * @param evt_buf: pointer to event buffer 5372 * @param idx: Index refering to a vdev 5373 * @param tbtt_param: Pointer to tbttoffset event param 5374 * 5375 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5376 */ 5377 QDF_STATUS wmi_extract_tbttoffset_update_params(void *wmi_hdl, void *evt_buf, 5378 uint8_t idx, struct tbttoffset_params *tbtt_param) 5379 { 5380 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5381 5382 if (wmi->ops->extract_tbttoffset_update_params) 5383 return wmi->ops->extract_tbttoffset_update_params(wmi, 5384 evt_buf, idx, tbtt_param); 5385 5386 return QDF_STATUS_E_FAILURE; 5387 } 5388 5389 /** 5390 * wmi_extract_ext_tbttoffset_update_params() - extract tbtt offset update param 5391 * @wmi_handle: wmi handle 5392 * @param evt_buf: pointer to event buffer 5393 * @param idx: Index refering to a vdev 5394 * @param tbtt_param: Pointer to tbttoffset event param 5395 * 5396 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5397 */ 5398 QDF_STATUS wmi_extract_ext_tbttoffset_update_params(void *wmi_hdl, 5399 void *evt_buf, uint8_t idx, struct tbttoffset_params *tbtt_param) 5400 { 5401 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5402 5403 if (wmi->ops->extract_ext_tbttoffset_update_params) 5404 return wmi->ops->extract_ext_tbttoffset_update_params(wmi, 5405 evt_buf, idx, tbtt_param); 5406 5407 return QDF_STATUS_E_FAILURE; 5408 } 5409 5410 /** 5411 * wmi_extract_mgmt_rx_params() - extract management rx params from event 5412 * @wmi_handle: wmi handle 5413 * @param evt_buf: pointer to event buffer 5414 * @param hdr: Pointer to hold header 5415 * @param bufp: Pointer to hold pointer to rx param buffer 5416 * 5417 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5418 */ 5419 QDF_STATUS wmi_extract_mgmt_rx_params(void *wmi_hdl, void *evt_buf, 5420 struct mgmt_rx_event_params *hdr, uint8_t **bufp) 5421 { 5422 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5423 5424 if (wmi_handle->ops->extract_mgmt_rx_params) 5425 return wmi_handle->ops->extract_mgmt_rx_params(wmi_handle, 5426 evt_buf, hdr, bufp); 5427 5428 return QDF_STATUS_E_FAILURE; 5429 } 5430 5431 /** 5432 * wmi_extract_vdev_stopped_param() - extract vdev stop param from event 5433 * @wmi_handle: wmi handle 5434 * @param evt_buf: pointer to event buffer 5435 * @param vdev_id: Pointer to hold vdev identifier 5436 * 5437 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5438 */ 5439 QDF_STATUS wmi_extract_vdev_stopped_param(void *wmi_hdl, void *evt_buf, 5440 uint32_t *vdev_id) 5441 { 5442 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5443 5444 if (wmi_handle->ops->extract_vdev_stopped_param) 5445 return wmi_handle->ops->extract_vdev_stopped_param(wmi_handle, 5446 evt_buf, vdev_id); 5447 5448 return QDF_STATUS_E_FAILURE; 5449 } 5450 5451 /** 5452 * wmi_extract_vdev_roam_param() - extract vdev roam param from event 5453 * @wmi_handle: wmi handle 5454 * @param evt_buf: pointer to event buffer 5455 * @param param: Pointer to hold roam param 5456 * 5457 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5458 */ 5459 QDF_STATUS wmi_extract_vdev_roam_param(void *wmi_hdl, void *evt_buf, 5460 wmi_host_roam_event *param) 5461 { 5462 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5463 5464 if (wmi_handle->ops->extract_vdev_roam_param) 5465 return wmi_handle->ops->extract_vdev_roam_param(wmi_handle, 5466 evt_buf, param); 5467 5468 return QDF_STATUS_E_FAILURE; 5469 } 5470 5471 /** 5472 * wmi_extract_vdev_scan_ev_param() - extract vdev scan param from event 5473 * @wmi_handle: wmi handle 5474 * @param evt_buf: pointer to event buffer 5475 * @param param: Pointer to hold vdev scan param 5476 * 5477 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5478 */ 5479 QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf, 5480 struct scan_event *param) 5481 { 5482 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5483 5484 if (wmi_handle->ops->extract_vdev_scan_ev_param) 5485 return wmi_handle->ops->extract_vdev_scan_ev_param(wmi_handle, 5486 evt_buf, param); 5487 5488 return QDF_STATUS_E_FAILURE; 5489 } 5490 5491 #ifdef CONVERGED_TDLS_ENABLE 5492 QDF_STATUS wmi_extract_vdev_tdls_ev_param(void *wmi_hdl, void *evt_buf, 5493 struct tdls_event_info *param) 5494 { 5495 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 5496 5497 if (wmi_handle->ops->extract_vdev_tdls_ev_param) 5498 return wmi_handle->ops->extract_vdev_tdls_ev_param(wmi_handle, 5499 evt_buf, param); 5500 5501 return QDF_STATUS_E_FAILURE; 5502 } 5503 #endif 5504 5505 /** 5506 * wmi_extract_mu_ev_param() - extract mu param from event 5507 * @wmi_handle: wmi handle 5508 * @param evt_buf: pointer to event buffer 5509 * @param param: Pointer to hold mu report 5510 * 5511 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5512 */ 5513 QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf, 5514 wmi_host_mu_report_event *param) 5515 { 5516 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5517 5518 if (wmi_handle->ops->extract_mu_ev_param) 5519 return wmi_handle->ops->extract_mu_ev_param(wmi_handle, evt_buf, 5520 param); 5521 5522 return QDF_STATUS_E_FAILURE; 5523 } 5524 5525 /** 5526 * wmi_extract_mu_db_entry() - extract mu db entry from event 5527 * @wmi_handle: wmi handle 5528 * @param evt_buf: pointer to event buffer 5529 * @param param: Pointer to hold mu db entry 5530 * 5531 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5532 */ 5533 QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf, 5534 uint8_t idx, wmi_host_mu_db_entry *param) 5535 { 5536 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5537 5538 if (wmi_handle->ops->extract_mu_db_entry) 5539 return wmi_handle->ops->extract_mu_db_entry(wmi_handle, evt_buf, 5540 idx, param); 5541 5542 return QDF_STATUS_E_FAILURE; 5543 } 5544 5545 /** 5546 * wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event 5547 * @wmi_handle: wmi handle 5548 * @param evt_buf: pointer to event buffer 5549 * @param param: Pointer to hold mumimo tx count 5550 * 5551 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5552 */ 5553 QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf, 5554 wmi_host_peer_txmu_cnt_event *param) 5555 { 5556 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5557 5558 if (wmi->ops->extract_mumimo_tx_count_ev_param) 5559 return wmi->ops->extract_mumimo_tx_count_ev_param(wmi, 5560 evt_buf, param); 5561 5562 return QDF_STATUS_E_FAILURE; 5563 } 5564 5565 /** 5566 * wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list 5567 * from event 5568 * @wmi_handle: wmi handle 5569 * @param evt_buf: pointer to event buffer 5570 * @param param: Pointer to hold peer gid userposition list 5571 * 5572 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5573 */ 5574 QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl, 5575 void *evt_buf, 5576 wmi_host_peer_gid_userpos_list_event *param) 5577 { 5578 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5579 5580 if (wmi->ops->extract_peer_gid_userpos_list_ev_param) 5581 return wmi->ops->extract_peer_gid_userpos_list_ev_param(wmi, 5582 evt_buf, param); 5583 5584 return QDF_STATUS_E_FAILURE; 5585 } 5586 5587 /** 5588 * wmi_extract_pdev_caldata_version_check_ev_param() - extract caldata 5589 * from event 5590 * @wmi_handle: wmi handle 5591 * @param evt_buf: pointer to event buffer 5592 * @param param: Pointer to hold caldata version data 5593 * 5594 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5595 */ 5596 QDF_STATUS wmi_extract_pdev_caldata_version_check_ev_param(void *wmi_hdl, 5597 void *evt_buf, 5598 wmi_host_pdev_check_cal_version_event *param) 5599 { 5600 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5601 5602 if (wmi->ops->extract_pdev_caldata_version_check_ev_param) 5603 return wmi->ops->extract_pdev_caldata_version_check_ev_param( 5604 wmi, evt_buf, param); 5605 5606 return QDF_STATUS_E_FAILURE; 5607 } 5608 5609 /** 5610 * wmi_extract_pdev_tpc_config_ev_param() - extract pdev tpc configuration 5611 * param from event 5612 * @wmi_handle: wmi handle 5613 * @param evt_buf: pointer to event buffer 5614 * @param param: Pointer to hold tpc configuration 5615 * 5616 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5617 */ 5618 QDF_STATUS wmi_extract_pdev_tpc_config_ev_param(void *wmi_hdl, void *evt_buf, 5619 wmi_host_pdev_tpc_config_event *param) 5620 { 5621 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5622 5623 if (wmi->ops->extract_pdev_tpc_config_ev_param) 5624 return wmi->ops->extract_pdev_tpc_config_ev_param(wmi, 5625 evt_buf, param); 5626 5627 return QDF_STATUS_E_FAILURE; 5628 5629 } 5630 5631 /** 5632 * wmi_extract_gpio_input_ev_param() - extract gpio input param from event 5633 * @wmi_handle: wmi handle 5634 * @param evt_buf: pointer to event buffer 5635 * @param gpio_num: Pointer to hold gpio number 5636 * 5637 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5638 */ 5639 QDF_STATUS wmi_extract_gpio_input_ev_param(void *wmi_hdl, 5640 void *evt_buf, uint32_t *gpio_num) 5641 { 5642 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5643 5644 if (wmi_handle->ops->extract_gpio_input_ev_param) 5645 return wmi_handle->ops->extract_gpio_input_ev_param(wmi_handle, 5646 evt_buf, gpio_num); 5647 5648 return QDF_STATUS_E_FAILURE; 5649 } 5650 5651 /** 5652 * wmi_extract_pdev_reserve_ast_ev_param() - extract reserve ast entry 5653 * param from event 5654 * @wmi_handle: wmi handle 5655 * @param evt_buf: pointer to event buffer 5656 * @param param: Pointer to hold reserve ast entry param 5657 * 5658 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5659 */ 5660 QDF_STATUS wmi_extract_pdev_reserve_ast_ev_param(void *wmi_hdl, 5661 void *evt_buf, struct wmi_host_proxy_ast_reserve_param *param) 5662 { 5663 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5664 5665 if (wmi->ops->extract_pdev_reserve_ast_ev_param) 5666 return wmi->ops->extract_pdev_reserve_ast_ev_param(wmi, 5667 evt_buf, param); 5668 5669 return QDF_STATUS_E_FAILURE; 5670 } 5671 5672 /** 5673 * wmi_extract_nfcal_power_ev_param() - extract noise floor calibration 5674 * power param from event 5675 * @wmi_handle: wmi handle 5676 * @param evt_buf: pointer to event buffer 5677 * @param param: Pointer to hold nf cal power param 5678 * 5679 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5680 */ 5681 QDF_STATUS wmi_extract_nfcal_power_ev_param(void *wmi_hdl, void *evt_buf, 5682 wmi_host_pdev_nfcal_power_all_channels_event *param) 5683 { 5684 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5685 5686 if (wmi_handle->ops->extract_nfcal_power_ev_param) 5687 return wmi_handle->ops->extract_nfcal_power_ev_param(wmi_handle, 5688 evt_buf, param); 5689 5690 return QDF_STATUS_E_FAILURE; 5691 5692 } 5693 5694 /** 5695 * wmi_extract_pdev_tpc_ev_param() - extract tpc param from event 5696 * @wmi_handle: wmi handle 5697 * @param evt_buf: pointer to event buffer 5698 * @param param: Pointer to hold tpc param 5699 * 5700 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5701 */ 5702 QDF_STATUS wmi_extract_pdev_tpc_ev_param(void *wmi_hdl, void *evt_buf, 5703 wmi_host_pdev_tpc_event *param) 5704 { 5705 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5706 5707 if (wmi_handle->ops->extract_pdev_tpc_ev_param) 5708 return wmi_handle->ops->extract_pdev_tpc_ev_param(wmi_handle, 5709 evt_buf, param); 5710 5711 return QDF_STATUS_E_FAILURE; 5712 5713 } 5714 5715 /** 5716 * wmi_extract_pdev_generic_buffer_ev_param() - extract pdev generic buffer 5717 * from event 5718 * @wmi_handle: wmi handle 5719 * @param evt_buf: pointer to event buffer 5720 * @param param: Pointer to generic buffer param 5721 * 5722 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5723 */ 5724 QDF_STATUS wmi_extract_pdev_generic_buffer_ev_param(void *wmi_hdl, 5725 void *evt_buf, wmi_host_pdev_generic_buffer_event *param) 5726 { 5727 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5728 5729 if (wmi->ops->extract_pdev_generic_buffer_ev_param) 5730 return wmi->ops->extract_pdev_generic_buffer_ev_param(wmi, 5731 evt_buf, param); 5732 5733 return QDF_STATUS_E_FAILURE; 5734 5735 } 5736 5737 /** 5738 * wmi_extract_mgmt_tx_compl_param() - extract mgmt tx completion param 5739 * from event 5740 * @wmi_hdl: wmi handle 5741 * @evt_buf: pointer to event buffer 5742 * @param: Pointer to mgmt tx completion param 5743 * 5744 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5745 */ 5746 QDF_STATUS wmi_extract_mgmt_tx_compl_param(void *wmi_hdl, void *evt_buf, 5747 wmi_host_mgmt_tx_compl_event *param) 5748 { 5749 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5750 5751 if (wmi_handle->ops->extract_mgmt_tx_compl_param) 5752 return wmi_handle->ops->extract_mgmt_tx_compl_param(wmi_handle, 5753 evt_buf, param); 5754 5755 5756 return QDF_STATUS_E_FAILURE; 5757 } 5758 5759 /** 5760 * wmi_extract_offchan_data_tx_compl_param() - 5761 * extract offchan data tx completion param from event 5762 * @wmi_hdl: wmi handle 5763 * @evt_buf: pointer to event buffer 5764 * @param: Pointer to offchan data tx completion param 5765 * 5766 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5767 */ 5768 QDF_STATUS wmi_extract_offchan_data_tx_compl_param(void *wmi_hdl, void *evt_buf, 5769 struct wmi_host_offchan_data_tx_compl_event *param) 5770 { 5771 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5772 5773 if (wmi_handle->ops->extract_offchan_data_tx_compl_param) 5774 return wmi_handle->ops->extract_offchan_data_tx_compl_param( 5775 wmi_handle, evt_buf, param); 5776 5777 5778 return QDF_STATUS_E_FAILURE; 5779 } 5780 5781 /** 5782 * wmi_extract_pdev_csa_switch_count_status() - extract CSA switch count status 5783 * from event 5784 * @wmi_handle: wmi handle 5785 * @param evt_buf: pointer to event buffer 5786 * @param param: Pointer to CSA switch count status param 5787 * 5788 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5789 */ 5790 QDF_STATUS wmi_extract_pdev_csa_switch_count_status(void *wmi_hdl, 5791 void *evt_buf, 5792 struct pdev_csa_switch_count_status *param) 5793 { 5794 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5795 5796 if (wmi_handle->ops->extract_pdev_csa_switch_count_status) 5797 return wmi_handle->ops->extract_pdev_csa_switch_count_status( 5798 wmi_handle, 5799 evt_buf, 5800 param); 5801 5802 return QDF_STATUS_E_FAILURE; 5803 } 5804 5805 5806 /** 5807 * wmi_extract_swba_num_vdevs() - extract swba num vdevs from event 5808 * @wmi_handle: wmi handle 5809 * @param evt_buf: pointer to event buffer 5810 * @param num_vdevs: Pointer to hold num vdevs 5811 * 5812 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5813 */ 5814 QDF_STATUS wmi_extract_swba_num_vdevs(void *wmi_hdl, void *evt_buf, 5815 uint32_t *num_vdevs) 5816 { 5817 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5818 5819 if (wmi_handle->ops->extract_swba_num_vdevs) 5820 return wmi_handle->ops->extract_swba_num_vdevs(wmi_handle, 5821 evt_buf, num_vdevs); 5822 5823 return QDF_STATUS_E_FAILURE; 5824 } 5825 5826 /** 5827 * wmi_extract_swba_tim_info() - extract swba tim info from event 5828 * @wmi_handle: wmi handle 5829 * @param evt_buf: pointer to event buffer 5830 * @param idx: Index to bcn info 5831 * @param tim_info: Pointer to hold tim info 5832 * 5833 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5834 */ 5835 QDF_STATUS wmi_extract_swba_tim_info(void *wmi_hdl, void *evt_buf, 5836 uint32_t idx, wmi_host_tim_info *tim_info) 5837 { 5838 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5839 5840 if (wmi_handle->ops->extract_swba_tim_info) 5841 return wmi_handle->ops->extract_swba_tim_info(wmi_handle, 5842 evt_buf, idx, tim_info); 5843 5844 return QDF_STATUS_E_FAILURE; 5845 } 5846 5847 /** 5848 * wmi_extract_swba_noa_info() - extract swba NoA information from event 5849 * @wmi_handle: wmi handle 5850 * @param evt_buf: pointer to event buffer 5851 * @param idx: Index to bcn info 5852 * @param p2p_desc: Pointer to hold p2p NoA info 5853 * 5854 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5855 */ 5856 QDF_STATUS wmi_extract_swba_noa_info(void *wmi_hdl, void *evt_buf, 5857 uint32_t idx, wmi_host_p2p_noa_info *p2p_desc) 5858 { 5859 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5860 5861 if (wmi_handle->ops->extract_swba_noa_info) 5862 return wmi_handle->ops->extract_swba_noa_info(wmi_handle, 5863 evt_buf, idx, p2p_desc); 5864 5865 return QDF_STATUS_E_FAILURE; 5866 } 5867 5868 #ifdef CONVERGED_P2P_ENABLE 5869 /** 5870 * wmi_extract_p2p_lo_stop_ev_param() - extract p2p lo stop param from event 5871 * @wmi_handle: wmi handle 5872 * @evt_buf: pointer to event buffer 5873 * @param: Pointer to hold listen offload stop param 5874 * 5875 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5876 */ 5877 QDF_STATUS wmi_extract_p2p_lo_stop_ev_param(void *wmi_hdl, void *evt_buf, 5878 struct p2p_lo_event *param) 5879 { 5880 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5881 5882 if (!wmi_handle) { 5883 WMI_LOGE("wmi handle is null"); 5884 return QDF_STATUS_E_INVAL; 5885 } 5886 5887 if (wmi_handle->ops->extract_p2p_lo_stop_ev_param) 5888 return wmi_handle->ops->extract_p2p_lo_stop_ev_param( 5889 wmi_handle, evt_buf, param); 5890 5891 return QDF_STATUS_E_FAILURE; 5892 } 5893 5894 /** 5895 * wmi_extract_p2p_noa_ev_param() - extract p2p noa param from event 5896 * @wmi_handle: wmi handle 5897 * @evt_buf: pointer to event buffer 5898 * @param: Pointer to hold p2p noa param 5899 * 5900 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5901 */ 5902 QDF_STATUS wmi_extract_p2p_noa_ev_param(void *wmi_hdl, void *evt_buf, 5903 struct p2p_noa_info *param) 5904 { 5905 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5906 5907 if (!wmi_handle) { 5908 WMI_LOGE("wmi handle is null"); 5909 return QDF_STATUS_E_INVAL; 5910 } 5911 5912 if (wmi_handle->ops->extract_p2p_noa_ev_param) 5913 return wmi_handle->ops->extract_p2p_noa_ev_param( 5914 wmi_handle, evt_buf, param); 5915 5916 return QDF_STATUS_E_FAILURE; 5917 } 5918 #endif 5919 5920 /** 5921 * wmi_extract_peer_sta_ps_statechange_ev() - extract peer sta ps state 5922 * from event 5923 * @wmi_handle: wmi handle 5924 * @param evt_buf: pointer to event buffer 5925 * @param ev: Pointer to hold peer param and ps state 5926 * 5927 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5928 */ 5929 QDF_STATUS wmi_extract_peer_sta_ps_statechange_ev(void *wmi_hdl, void *evt_buf, 5930 wmi_host_peer_sta_ps_statechange_event *ev) 5931 { 5932 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5933 5934 if (wmi->ops->extract_peer_sta_ps_statechange_ev) 5935 return wmi->ops->extract_peer_sta_ps_statechange_ev(wmi, 5936 evt_buf, ev); 5937 5938 return QDF_STATUS_E_FAILURE; 5939 } 5940 5941 /** 5942 * wmi_extract_peer_sta_kickout_ev() - extract peer sta kickout event 5943 * @wmi_handle: wmi handle 5944 * @param evt_buf: pointer to event buffer 5945 * @param ev: Pointer to hold peer param 5946 * 5947 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5948 */ 5949 QDF_STATUS wmi_extract_peer_sta_kickout_ev(void *wmi_hdl, void *evt_buf, 5950 wmi_host_peer_sta_kickout_event *ev) 5951 { 5952 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5953 5954 if (wmi_handle->ops->extract_peer_sta_kickout_ev) 5955 return wmi_handle->ops->extract_peer_sta_kickout_ev(wmi_handle, 5956 evt_buf, ev); 5957 5958 return QDF_STATUS_E_FAILURE; 5959 } 5960 5961 /** 5962 * wmi_extract_peer_ratecode_list_ev() - extract peer ratecode from event 5963 * @wmi_handle: wmi handle 5964 * @param evt_buf: pointer to event buffer 5965 * @param peer_mac: Pointer to hold peer mac address 5966 * @param rate_cap: Pointer to hold ratecode 5967 * 5968 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5969 */ 5970 QDF_STATUS wmi_extract_peer_ratecode_list_ev(void *wmi_hdl, void *evt_buf, 5971 uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap) 5972 { 5973 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 5974 5975 if (wmi->ops->extract_peer_ratecode_list_ev) 5976 return wmi->ops->extract_peer_ratecode_list_ev(wmi, 5977 evt_buf, peer_mac, rate_cap); 5978 5979 return QDF_STATUS_E_FAILURE; 5980 5981 } 5982 5983 /** 5984 * wmi_extract_comb_phyerr() - extract comb phy error from event 5985 * @wmi_handle: wmi handle 5986 * @param evt_buf: pointer to event buffer 5987 * @param datalen: data length of event buffer 5988 * @param buf_offset: Pointer to hold value of current event buffer offset 5989 * post extraction 5990 * @param phyer: Pointer to hold phyerr 5991 * 5992 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 5993 */ 5994 QDF_STATUS wmi_extract_comb_phyerr(void *wmi_hdl, void *evt_buf, 5995 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr) 5996 { 5997 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 5998 5999 if (wmi_handle->ops->extract_comb_phyerr) 6000 return wmi_handle->ops->extract_comb_phyerr(wmi_handle, 6001 evt_buf, datalen, buf_offset, phyerr); 6002 6003 return QDF_STATUS_E_FAILURE; 6004 6005 } 6006 6007 /** 6008 * wmi_extract_single_phyerr() - extract single phy error from event 6009 * @wmi_handle: wmi handle 6010 * @param evt_buf: pointer to event buffer 6011 * @param datalen: data length of event buffer 6012 * @param buf_offset: Pointer to hold value of current event buffer offset 6013 * post extraction 6014 * @param phyerr: Pointer to hold phyerr 6015 * 6016 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6017 */ 6018 QDF_STATUS wmi_extract_single_phyerr(void *wmi_hdl, void *evt_buf, 6019 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr) 6020 { 6021 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6022 6023 if (wmi_handle->ops->extract_single_phyerr) 6024 return wmi_handle->ops->extract_single_phyerr(wmi_handle, 6025 evt_buf, datalen, buf_offset, phyerr); 6026 6027 return QDF_STATUS_E_FAILURE; 6028 6029 } 6030 6031 /** 6032 * wmi_extract_composite_phyerr() - extract composite phy error from event 6033 * @wmi_handle: wmi handle 6034 * @param evt_buf: pointer to event buffer 6035 * @param datalen: Length of event buffer 6036 * @param phyerr: Pointer to hold phy error 6037 * 6038 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6039 */ 6040 QDF_STATUS wmi_extract_composite_phyerr(void *wmi_hdl, void *evt_buf, 6041 uint16_t datalen, wmi_host_phyerr_t *phyerr) 6042 { 6043 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6044 6045 if (wmi_handle->ops->extract_composite_phyerr) 6046 return wmi_handle->ops->extract_composite_phyerr(wmi_handle, 6047 evt_buf, datalen, phyerr); 6048 6049 return QDF_STATUS_E_FAILURE; 6050 6051 } 6052 6053 /** 6054 * wmi_extract_stats_param() - extract all stats count from event 6055 * @wmi_handle: wmi handle 6056 * @param evt_buf: pointer to event buffer 6057 * @param stats_param: Pointer to hold stats count 6058 * 6059 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6060 */ 6061 QDF_STATUS wmi_extract_stats_param(void *wmi_hdl, void *evt_buf, 6062 wmi_host_stats_event *stats_param) 6063 { 6064 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6065 6066 if (wmi_handle->ops->extract_all_stats_count) 6067 return wmi_handle->ops->extract_all_stats_count(wmi_handle, 6068 evt_buf, stats_param); 6069 6070 return QDF_STATUS_E_FAILURE; 6071 } 6072 6073 /** 6074 * wmi_extract_pdev_stats() - extract pdev stats from event 6075 * @wmi_handle: wmi handle 6076 * @param evt_buf: pointer to event buffer 6077 * @param index: Index into pdev stats 6078 * @param pdev_stats: Pointer to hold pdev stats 6079 * 6080 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6081 */ 6082 QDF_STATUS wmi_extract_pdev_stats(void *wmi_hdl, void *evt_buf, 6083 uint32_t index, wmi_host_pdev_stats *pdev_stats) 6084 { 6085 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6086 6087 if (wmi_handle->ops->extract_pdev_stats) 6088 return wmi_handle->ops->extract_pdev_stats(wmi_handle, 6089 evt_buf, index, pdev_stats); 6090 6091 return QDF_STATUS_E_FAILURE; 6092 } 6093 6094 /** 6095 * extract_unit_test() - extract unit test from event 6096 * @wmi_handle: wmi handle 6097 * @param evt_buf: pointer to event buffer 6098 * @param unit_test: Pointer to hold unit-test header 6099 * @param maxspace: The amount of space in evt_buf 6100 * 6101 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6102 */ 6103 QDF_STATUS wmi_extract_unit_test(void *wmi_hdl, void *evt_buf, 6104 wmi_unit_test_event *unit_test, uint32_t maxspace) 6105 { 6106 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6107 6108 if (wmi_handle->ops->extract_unit_test) 6109 return wmi_handle->ops->extract_unit_test(wmi_handle, 6110 evt_buf, unit_test, maxspace); 6111 6112 return QDF_STATUS_E_FAILURE; 6113 } 6114 6115 /** 6116 * wmi_extract_pdev_ext_stats() - extract extended pdev stats from event 6117 * @wmi_handle: wmi handle 6118 * @param evt_buf: pointer to event buffer 6119 * @param index: Index into extended pdev stats 6120 * @param pdev_ext_stats: Pointer to hold extended pdev stats 6121 * 6122 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6123 */ 6124 QDF_STATUS wmi_extract_pdev_ext_stats(void *wmi_hdl, void *evt_buf, 6125 uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats) 6126 { 6127 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6128 6129 if (wmi_handle->ops->extract_pdev_ext_stats) 6130 return wmi_handle->ops->extract_pdev_ext_stats(wmi_handle, 6131 evt_buf, index, pdev_ext_stats); 6132 6133 return QDF_STATUS_E_FAILURE; 6134 } 6135 6136 /** 6137 * wmi_extract_peer_stats() - extract peer stats from event 6138 * @wmi_handle: wmi handle 6139 * @param evt_buf: pointer to event buffer 6140 * @param index: Index into peer stats 6141 * @param peer_stats: Pointer to hold peer stats 6142 * 6143 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6144 */ 6145 QDF_STATUS wmi_extract_peer_stats(void *wmi_hdl, void *evt_buf, 6146 uint32_t index, wmi_host_peer_stats *peer_stats) 6147 { 6148 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6149 6150 if (wmi_handle->ops->extract_peer_stats) 6151 return wmi_handle->ops->extract_peer_stats(wmi_handle, 6152 evt_buf, index, peer_stats); 6153 6154 return QDF_STATUS_E_FAILURE; 6155 } 6156 6157 /** 6158 * wmi_extract_vdev_stats() - extract vdev stats from event 6159 * @wmi_handle: wmi handle 6160 * @param evt_buf: pointer to event buffer 6161 * @param index: Index into vdev stats 6162 * @param vdev_stats: Pointer to hold vdev stats 6163 * 6164 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6165 */ 6166 QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf, 6167 uint32_t index, wmi_host_vdev_stats *vdev_stats) 6168 { 6169 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6170 6171 if (wmi_handle->ops->extract_vdev_stats) 6172 return wmi_handle->ops->extract_vdev_stats(wmi_handle, 6173 evt_buf, index, vdev_stats); 6174 6175 return QDF_STATUS_E_FAILURE; 6176 } 6177 6178 /** 6179 * wmi_extract_rtt_hdr() - extract rtt header from event 6180 * @wmi_handle: wmi handle 6181 * @param evt_buf: pointer to event buffer 6182 * @param ev: Pointer to hold rtt header 6183 * 6184 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6185 */ 6186 QDF_STATUS wmi_extract_rtt_hdr(void *wmi_hdl, void *evt_buf, 6187 wmi_host_rtt_event_hdr *ev) 6188 { 6189 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6190 6191 if (wmi_handle->ops->extract_rtt_hdr) 6192 return wmi_handle->ops->extract_rtt_hdr(wmi_handle, 6193 evt_buf, ev); 6194 6195 return QDF_STATUS_E_FAILURE; 6196 } 6197 6198 /** 6199 * wmi_extract_bcnflt_stats() - extract bcn fault stats from event 6200 * @wmi_handle: wmi handle 6201 * @param evt_buf: pointer to event buffer 6202 * @param index: Index into bcn fault stats 6203 * @param bcnflt_stats: Pointer to hold bcn fault stats 6204 * 6205 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6206 */ 6207 QDF_STATUS wmi_extract_bcnflt_stats(void *wmi_hdl, void *evt_buf, 6208 uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats) 6209 { 6210 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6211 6212 if (wmi_handle->ops->extract_bcnflt_stats) 6213 return wmi_handle->ops->extract_bcnflt_stats(wmi_handle, 6214 evt_buf, index, bcnflt_stats); 6215 6216 return QDF_STATUS_E_FAILURE; 6217 } 6218 6219 /** 6220 * wmi_extract_rtt_ev() - extract rtt event 6221 * @wmi_handle: wmi handle 6222 * @param evt_buf: Pointer to event buffer 6223 * @param ev: Pointer to hold rtt event 6224 * @param hdump: Pointer to hold hex dump 6225 * @param hdump_len: hex dump length 6226 * 6227 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6228 */ 6229 QDF_STATUS wmi_extract_rtt_ev(void *wmi_hdl, void *evt_buf, 6230 wmi_host_rtt_meas_event *ev, uint8_t *hdump, uint16_t hdump_len) 6231 { 6232 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6233 6234 if (wmi_handle->ops->extract_rtt_ev) 6235 return wmi_handle->ops->extract_rtt_ev(wmi_handle, 6236 evt_buf, ev, hdump, hdump_len); 6237 6238 return QDF_STATUS_E_FAILURE; 6239 } 6240 6241 /** 6242 * wmi_extract_peer_extd_stats() - extract extended peer stats from event 6243 * @wmi_handle: wmi handle 6244 * @param evt_buf: pointer to event buffer 6245 * @param index: Index into extended peer stats 6246 * @param peer_extd_stats: Pointer to hold extended peer stats 6247 * 6248 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6249 */ 6250 QDF_STATUS wmi_extract_peer_extd_stats(void *wmi_hdl, void *evt_buf, 6251 uint32_t index, wmi_host_peer_extd_stats *peer_extd_stats) 6252 { 6253 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6254 6255 if (wmi_handle->ops->extract_peer_extd_stats) 6256 return wmi_handle->ops->extract_peer_extd_stats(wmi_handle, 6257 evt_buf, index, peer_extd_stats); 6258 6259 return QDF_STATUS_E_FAILURE; 6260 } 6261 6262 /** 6263 * wmi_extract_rtt_error_report_ev() - extract rtt error report from event 6264 * @wmi_handle: wmi handle 6265 * @param evt_buf: pointer to event buffer 6266 * @param wds_ev: Pointer to hold rtt error report 6267 * 6268 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6269 */ 6270 QDF_STATUS wmi_extract_rtt_error_report_ev(void *wmi_hdl, void *evt_buf, 6271 wmi_host_rtt_error_report_event *ev) 6272 { 6273 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6274 6275 if (wmi_handle->ops->extract_rtt_error_report_ev) 6276 return wmi_handle->ops->extract_rtt_error_report_ev(wmi_handle, 6277 evt_buf, ev); 6278 6279 return QDF_STATUS_E_FAILURE; 6280 } 6281 6282 /** 6283 * wmi_extract_chan_stats() - extract chan stats from event 6284 * @wmi_handle: wmi handle 6285 * @param evt_buf: pointer to event buffer 6286 * @param index: Index into chan stats 6287 * @param chanstats: Pointer to hold chan stats 6288 * 6289 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6290 */ 6291 QDF_STATUS wmi_extract_chan_stats(void *wmi_hdl, void *evt_buf, 6292 uint32_t index, wmi_host_chan_stats *chan_stats) 6293 { 6294 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6295 6296 if (wmi_handle->ops->extract_chan_stats) 6297 return wmi_handle->ops->extract_chan_stats(wmi_handle, 6298 evt_buf, index, chan_stats); 6299 6300 return QDF_STATUS_E_FAILURE; 6301 } 6302 6303 /** 6304 * wmi_extract_thermal_stats() - extract thermal stats from event 6305 * @wmi_handle: wmi handle 6306 * @param evt_buf: Pointer to event buffer 6307 * @param temp: Pointer to hold extracted temperature 6308 * @param level: Pointer to hold extracted level 6309 * @param pdev_id: Pointer to hold extracted pdev_id 6310 * 6311 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6312 */ 6313 QDF_STATUS wmi_extract_thermal_stats(void *wmi_hdl, void *evt_buf, 6314 uint32_t *temp, uint32_t *level, uint32_t *pdev_id) 6315 { 6316 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6317 6318 if (wmi_handle->ops->extract_thermal_stats) 6319 return wmi_handle->ops->extract_thermal_stats(wmi_handle, 6320 evt_buf, temp, level, pdev_id); 6321 6322 return QDF_STATUS_E_FAILURE; 6323 } 6324 6325 /** 6326 * wmi_extract_profile_ctx() - extract profile context from event 6327 * @wmi_handle: wmi handle 6328 * @param evt_buf: pointer to event buffer 6329 * @param profile_ctx: Pointer to hold profile context 6330 * 6331 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6332 */ 6333 QDF_STATUS wmi_extract_profile_ctx(void *wmi_hdl, void *evt_buf, 6334 wmi_host_wlan_profile_ctx_t *profile_ctx) 6335 { 6336 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6337 6338 if (wmi_handle->ops->extract_profile_ctx) 6339 return wmi_handle->ops->extract_profile_ctx(wmi_handle, 6340 evt_buf, profile_ctx); 6341 6342 return QDF_STATUS_E_FAILURE; 6343 } 6344 6345 /** 6346 * wmi_extract_thermal_level_stats() - extract thermal level stats from 6347 * event 6348 * @wmi_handle: wmi handle 6349 * @param evt_buf: pointer to event buffer 6350 * @param idx: Index to level stats 6351 * @param levelcount: Pointer to hold levelcount 6352 * @param dccount: Pointer to hold dccount 6353 * 6354 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6355 */ 6356 QDF_STATUS wmi_extract_thermal_level_stats(void *wmi_hdl, void *evt_buf, 6357 uint8_t idx, uint32_t *levelcount, uint32_t *dccount) 6358 { 6359 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6360 6361 if (wmi_handle->ops->extract_thermal_level_stats) 6362 return wmi_handle->ops->extract_thermal_level_stats(wmi_handle, 6363 evt_buf, idx, levelcount, dccount); 6364 6365 return QDF_STATUS_E_FAILURE; 6366 } 6367 6368 /** 6369 * wmi_extract_profile_data() - extract profile data from event 6370 * @wmi_handle: wmi handle 6371 * @param evt_buf: pointer to event buffer 6372 * @idx index: index of profile data 6373 * @param profile_data: Pointer to hold profile data 6374 * 6375 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6376 */ 6377 QDF_STATUS wmi_extract_profile_data(void *wmi_hdl, void *evt_buf, uint8_t idx, 6378 wmi_host_wlan_profile_t *profile_data) 6379 { 6380 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6381 6382 if (wmi_handle->ops->extract_profile_data) 6383 return wmi_handle->ops->extract_profile_data(wmi_handle, 6384 evt_buf, idx, profile_data); 6385 6386 return QDF_STATUS_E_FAILURE; 6387 } 6388 6389 /** 6390 * wmi_extract_chan_info_event() - extract chan information from event 6391 * @wmi_handle: wmi handle 6392 * @param evt_buf: pointer to event buffer 6393 * @param chan_info: Pointer to hold chan information 6394 * 6395 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6396 */ 6397 QDF_STATUS wmi_extract_chan_info_event(void *wmi_hdl, void *evt_buf, 6398 wmi_host_chan_info_event *chan_info) 6399 { 6400 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6401 6402 if (wmi_handle->ops->extract_chan_info_event) 6403 return wmi_handle->ops->extract_chan_info_event(wmi_handle, 6404 evt_buf, chan_info); 6405 6406 return QDF_STATUS_E_FAILURE; 6407 } 6408 6409 /** 6410 * wmi_extract_channel_hopping_event() - extract channel hopping param 6411 * from event 6412 * @wmi_handle: wmi handle 6413 * @param evt_buf: pointer to event buffer 6414 * @param ch_hopping: Pointer to hold channel hopping param 6415 * 6416 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6417 */ 6418 QDF_STATUS wmi_extract_channel_hopping_event(void *wmi_hdl, void *evt_buf, 6419 wmi_host_pdev_channel_hopping_event *ch_hopping) 6420 { 6421 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6422 6423 if (wmi->ops->extract_channel_hopping_event) 6424 return wmi->ops->extract_channel_hopping_event(wmi, 6425 evt_buf, ch_hopping); 6426 6427 return QDF_STATUS_E_FAILURE; 6428 } 6429 6430 /** 6431 * wmi_extract_bss_chan_info_event() - extract bss channel information 6432 * from event 6433 * @wmi_handle: wmi handle 6434 * @param evt_buf: pointer to event buffer 6435 * @param bss_chan_info: Pointer to hold bss channel information 6436 * 6437 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6438 */ 6439 QDF_STATUS wmi_extract_bss_chan_info_event(void *wmi_hdl, void *evt_buf, 6440 wmi_host_pdev_bss_chan_info_event *bss_chan_info) 6441 { 6442 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6443 6444 if (wmi_handle->ops->extract_bss_chan_info_event) 6445 return wmi_handle->ops->extract_bss_chan_info_event(wmi_handle, 6446 evt_buf, bss_chan_info); 6447 6448 return QDF_STATUS_E_FAILURE; 6449 } 6450 6451 /** 6452 * wmi_extract_inst_rssi_stats_event() - extract inst rssi stats from event 6453 * @wmi_handle: wmi handle 6454 * @param evt_buf: pointer to event buffer 6455 * @param inst_rssi_resp: Pointer to hold inst rssi response 6456 * 6457 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6458 */ 6459 QDF_STATUS wmi_extract_inst_rssi_stats_event(void *wmi_hdl, void *evt_buf, 6460 wmi_host_inst_stats_resp *inst_rssi_resp) 6461 { 6462 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6463 6464 if (wmi->ops->extract_inst_rssi_stats_event) 6465 return wmi->ops->extract_inst_rssi_stats_event(wmi, 6466 evt_buf, inst_rssi_resp); 6467 6468 return QDF_STATUS_E_FAILURE; 6469 } 6470 6471 /** 6472 * wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control 6473 * from event 6474 * @wmi_handle: wmi handle 6475 * @param evt_buf: pointer to event buffer 6476 * @param ev: Pointer to hold data traffic control 6477 * 6478 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6479 */ 6480 QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf, 6481 wmi_host_tx_data_traffic_ctrl_event *ev) 6482 { 6483 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6484 6485 if (wmi->ops->extract_tx_data_traffic_ctrl_ev) 6486 return wmi->ops->extract_tx_data_traffic_ctrl_ev(wmi, 6487 evt_buf, ev); 6488 6489 return QDF_STATUS_E_FAILURE; 6490 } 6491 6492 /** 6493 * wmi_extract_atf_peer_stats_ev() - extract atf peer stats 6494 * from event 6495 * @wmi_handle: wmi handle 6496 * @param evt_buf: pointer to event buffer 6497 * @param ev: Pointer to hold atf peer stats 6498 * 6499 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6500 */ 6501 QDF_STATUS wmi_extract_atf_peer_stats_ev(void *wmi_hdl, void *evt_buf, 6502 wmi_host_atf_peer_stats_event *ev) 6503 { 6504 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6505 6506 if (wmi->ops->extract_atf_peer_stats_ev) 6507 return wmi->ops->extract_atf_peer_stats_ev(wmi, 6508 evt_buf, ev); 6509 6510 return QDF_STATUS_E_FAILURE; 6511 } 6512 6513 /** 6514 * wmi_extract_atf_token_info_ev() - extract atf token info 6515 * from event 6516 * @wmi_handle: wmi handle 6517 * @param evt_buf: pointer to event buffer 6518 * @param idx: Index indicating the peer number 6519 * @param ev: Pointer to hold atf token info 6520 * 6521 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6522 */ 6523 QDF_STATUS wmi_extract_atf_token_info_ev(void *wmi_hdl, void *evt_buf, 6524 uint8_t idx, wmi_host_atf_peer_stats_info *ev) 6525 { 6526 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6527 6528 if (wmi->ops->extract_atf_token_info_ev) 6529 return wmi->ops->extract_atf_token_info_ev(wmi, 6530 evt_buf, idx, ev); 6531 6532 return QDF_STATUS_E_FAILURE; 6533 } 6534 6535 /** 6536 * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event 6537 * @wmi_handle: wmi handle 6538 * @param evt_buf: pointer to event buffer 6539 * @param index: Index into extended vdev stats 6540 * @param vdev_extd_stats: Pointer to hold extended vdev stats 6541 * 6542 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6543 */ 6544 QDF_STATUS wmi_extract_vdev_extd_stats(void *wmi_hdl, void *evt_buf, 6545 uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats) 6546 { 6547 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6548 6549 if (wmi_handle->ops->extract_vdev_extd_stats) 6550 return wmi_handle->ops->extract_vdev_extd_stats(wmi_handle, 6551 evt_buf, index, vdev_extd_stats); 6552 return QDF_STATUS_E_FAILURE; 6553 } 6554 6555 /** 6556 * wmi_extract_bcn_stats() - extract beacon stats from event 6557 * @wmi_handle: wmi handle 6558 * @evt_buf: pointer to event buffer 6559 * @index: Index into beacon stats 6560 * @vdev_bcn_stats: Pointer to hold beacon stats 6561 * 6562 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6563 */ 6564 QDF_STATUS wmi_extract_bcn_stats(void *wmi_hdl, void *evt_buf, 6565 uint32_t index, wmi_host_bcn_stats *vdev_bcn_stats) 6566 { 6567 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6568 6569 if (wmi_handle->ops->extract_bcn_stats) 6570 return wmi_handle->ops->extract_bcn_stats(wmi_handle, 6571 evt_buf, index, vdev_bcn_stats); 6572 return QDF_STATUS_E_FAILURE; 6573 } 6574 6575 /** 6576 * wmi_extract_vdev_nac_rssi_stats() - extract NAC_RSSI stats from event 6577 * @wmi_handle: wmi handle 6578 * @param evt_buf: pointer to event buffer 6579 * @param vdev_extd_stats: Pointer to hold nac rssi stats 6580 * 6581 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 6582 */ 6583 QDF_STATUS wmi_extract_vdev_nac_rssi_stats(void *wmi_hdl, void *evt_buf, 6584 struct wmi_host_vdev_nac_rssi_event *vdev_nac_rssi_stats) 6585 { 6586 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6587 6588 if (wmi_handle->ops->extract_vdev_nac_rssi_stats) 6589 return wmi_handle->ops->extract_vdev_nac_rssi_stats(wmi_handle, 6590 evt_buf, vdev_nac_rssi_stats); 6591 6592 return QDF_STATUS_E_FAILURE; 6593 } 6594 6595 /** 6596 * wmi_unified_send_adapt_dwelltime_params_cmd() - send wmi cmd of 6597 * adaptive dwelltime configuration params 6598 * @wma_handle: wma handler 6599 * @dwelltime_params: pointer to dwelltime_params 6600 * 6601 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure 6602 */ 6603 QDF_STATUS wmi_unified_send_adapt_dwelltime_params_cmd(void *wmi_hdl, 6604 struct wmi_adaptive_dwelltime_params *dwelltime_params) 6605 { 6606 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6607 6608 if (wmi_handle->ops->send_adapt_dwelltime_params_cmd) 6609 return wmi_handle->ops-> 6610 send_adapt_dwelltime_params_cmd(wmi_handle, 6611 dwelltime_params); 6612 6613 return QDF_STATUS_E_FAILURE; 6614 } 6615 6616 /** 6617 * wmi_unified_send_power_dbg_cmd() - send power debug commands 6618 * @wmi_handle: wmi handle 6619 * @param: wmi power debug parameter 6620 * 6621 * Send WMI_POWER_DEBUG_CMDID parameters to fw. 6622 * 6623 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6624 */ 6625 QDF_STATUS wmi_unified_send_power_dbg_cmd(void *wmi_hdl, 6626 struct wmi_power_dbg_params *param) 6627 { 6628 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6629 6630 if (wmi_handle->ops->send_power_dbg_cmd) 6631 return wmi_handle->ops->send_power_dbg_cmd(wmi_handle, 6632 param); 6633 6634 return QDF_STATUS_E_FAILURE; 6635 } 6636 6637 /** 6638 * wmi_unified_send_multiple_vdev_restart_req_cmd() - send multiple vdev restart 6639 * @wmi_handle: wmi handle 6640 * @param: multiple vdev restart parameter 6641 * 6642 * Send WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID parameters to fw. 6643 * 6644 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6645 */ 6646 QDF_STATUS wmi_unified_send_multiple_vdev_restart_req_cmd(void *wmi_hdl, 6647 struct multiple_vdev_restart_params *param) 6648 { 6649 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6650 6651 if (wmi_handle->ops->send_multiple_vdev_restart_req_cmd) 6652 return wmi_handle->ops->send_multiple_vdev_restart_req_cmd( 6653 wmi_handle, 6654 param); 6655 6656 return QDF_STATUS_E_FAILURE; 6657 } 6658 6659 QDF_STATUS wmi_unified_send_sar_limit_cmd(void *wmi_hdl, 6660 struct sar_limit_cmd_params *params) 6661 { 6662 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6663 6664 if (wmi_handle->ops->send_sar_limit_cmd) 6665 return wmi_handle->ops->send_sar_limit_cmd( 6666 wmi_handle, 6667 params); 6668 return QDF_STATUS_E_FAILURE; 6669 } 6670 6671 QDF_STATUS wmi_unified_get_sar_limit_cmd(void *wmi_hdl) 6672 { 6673 wmi_unified_t wmi_handle = wmi_hdl; 6674 6675 if (wmi_handle->ops->get_sar_limit_cmd) 6676 return wmi_handle->ops->get_sar_limit_cmd(wmi_handle); 6677 6678 return QDF_STATUS_E_FAILURE; 6679 } 6680 6681 QDF_STATUS wmi_unified_extract_sar_limit_event(void *wmi_hdl, 6682 uint8_t *evt_buf, 6683 struct sar_limit_event *event) 6684 { 6685 wmi_unified_t wmi_handle = wmi_hdl; 6686 6687 if (wmi_handle->ops->extract_sar_limit_event) 6688 return wmi_handle->ops->extract_sar_limit_event(wmi_handle, 6689 evt_buf, 6690 event); 6691 6692 return QDF_STATUS_E_FAILURE; 6693 } 6694 6695 6696 #ifdef WLAN_FEATURE_DISA 6697 QDF_STATUS wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl, 6698 struct disa_encrypt_decrypt_req_params *params) 6699 { 6700 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6701 6702 if (wmi_handle->ops->send_encrypt_decrypt_send_cmd) 6703 return wmi_handle->ops->send_encrypt_decrypt_send_cmd( 6704 wmi_handle, 6705 params); 6706 return QDF_STATUS_E_FAILURE; 6707 } 6708 6709 QDF_STATUS wmi_extract_encrypt_decrypt_resp_params(void *wmi_hdl, 6710 uint8_t *evt_buf, 6711 struct disa_encrypt_decrypt_resp_params *resp) 6712 { 6713 struct wmi_unified *wmi_handle = (struct wmi_unified *)wmi_hdl; 6714 6715 if (wmi_handle->ops->extract_encrypt_decrypt_resp_event) 6716 return wmi_handle->ops->extract_encrypt_decrypt_resp_event( 6717 wmi_handle, evt_buf, resp); 6718 6719 return QDF_STATUS_E_FAILURE; 6720 } 6721 6722 #endif 6723 6724 /* 6725 * wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands 6726 * @wmi_handle: wmi handle 6727 * @param : wmi btcoex cfg params 6728 * 6729 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 6730 * 6731 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6732 */ 6733 QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl, 6734 struct btcoex_cfg_params *param) 6735 { 6736 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6737 6738 if (wmi->ops->send_btcoex_wlan_priority_cmd) 6739 return wmi->ops->send_btcoex_wlan_priority_cmd(wmi, 6740 param); 6741 6742 return QDF_STATUS_E_FAILURE; 6743 } 6744 /** 6745 * wmi_unified_send_btcoex_duty_cycle_cmd() - send btcoex duty cycle commands 6746 * @wmi_handle: wmi handle 6747 * @param: wmi btcoex cfg params 6748 * 6749 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 6750 * 6751 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6752 */ 6753 QDF_STATUS wmi_unified_send_btcoex_duty_cycle_cmd(void *wmi_hdl, 6754 struct btcoex_cfg_params *param) 6755 { 6756 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 6757 6758 if (wmi->ops->send_btcoex_duty_cycle_cmd) 6759 return wmi->ops->send_btcoex_duty_cycle_cmd(wmi, 6760 param); 6761 6762 return QDF_STATUS_E_FAILURE; 6763 } 6764 6765 /* 6766 * wmi_extract_service_ready_ext() - extract extended service ready 6767 * @wmi_handle: wmi handle 6768 * @param: wmi power debug parameter 6769 * 6770 * 6771 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6772 */ 6773 QDF_STATUS wmi_extract_service_ready_ext(void *wmi_hdl, uint8_t *evt_buf, 6774 struct wlan_psoc_host_service_ext_param *param) 6775 { 6776 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6777 6778 if (wmi_handle->ops->extract_service_ready_ext) 6779 return wmi_handle->ops->extract_service_ready_ext(wmi_handle, 6780 evt_buf, param); 6781 6782 return QDF_STATUS_E_FAILURE; 6783 } 6784 6785 /** 6786 * wmi_extract_hw_mode_cap_service_ready_ext() - 6787 * extract HW mode cap from service ready event 6788 * @wmi_handle: wmi handle 6789 * @param evt_buf: pointer to event buffer 6790 * @param param: Pointer to hold evt buf 6791 * @param hw_mode_idx: hw mode idx should be less than num_mode 6792 * 6793 * Return: QDF_STATUS_SUCCESS for success or error code 6794 */ 6795 QDF_STATUS wmi_extract_hw_mode_cap_service_ready_ext( 6796 void *wmi_hdl, 6797 uint8_t *evt_buf, uint8_t hw_mode_idx, 6798 struct wlan_psoc_host_hw_mode_caps *param) 6799 { 6800 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6801 6802 if (wmi_handle->ops->extract_hw_mode_cap_service_ready_ext) 6803 return wmi_handle->ops->extract_hw_mode_cap_service_ready_ext( 6804 wmi_handle, 6805 evt_buf, hw_mode_idx, param); 6806 6807 return QDF_STATUS_E_FAILURE; 6808 } 6809 /** 6810 * wmi_extract_mac_phy_cap_service_ready_ext() - 6811 * extract MAC phy cap from service ready event 6812 * @wmi_handle: wmi handle 6813 * @param evt_buf: pointer to event buffer 6814 * @param hw_mode_id: hw mode id of hw_mode_caps 6815 * @param phy_id: phy_id within hw_mode_cap 6816 * @param param: pointer to mac phy caps structure to hold the values from event 6817 * 6818 * Return: QDF_STATUS_SUCCESS for success or error code 6819 */ 6820 QDF_STATUS wmi_extract_mac_phy_cap_service_ready_ext( 6821 void *wmi_hdl, 6822 uint8_t *evt_buf, 6823 uint8_t hw_mode_id, 6824 uint8_t phy_id, 6825 struct wlan_psoc_host_mac_phy_caps *param) 6826 { 6827 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6828 6829 if (wmi_handle->ops->extract_mac_phy_cap_service_ready_ext) 6830 return wmi_handle->ops->extract_mac_phy_cap_service_ready_ext( 6831 wmi_handle, 6832 evt_buf, hw_mode_id, phy_id, param); 6833 6834 return QDF_STATUS_E_FAILURE; 6835 } 6836 6837 /** 6838 * wmi_extract_reg_cap_service_ready_ext() - 6839 * extract REG cap from service ready event 6840 * @wmi_handle: wmi handle 6841 * @param evt_buf: pointer to event buffer 6842 * @param param: Pointer to hold evt buf 6843 * @param phy_idx: phy idx should be less than num_mode 6844 * 6845 * Return: QDF_STATUS_SUCCESS for success or error code 6846 */ 6847 QDF_STATUS wmi_extract_reg_cap_service_ready_ext( 6848 void *wmi_hdl, 6849 uint8_t *evt_buf, uint8_t phy_idx, 6850 struct wlan_psoc_host_hal_reg_capabilities_ext *param) 6851 { 6852 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6853 6854 if (wmi_handle->ops->extract_reg_cap_service_ready_ext) 6855 return wmi_handle->ops->extract_reg_cap_service_ready_ext( 6856 wmi_handle, 6857 evt_buf, phy_idx, param); 6858 6859 return QDF_STATUS_E_FAILURE; 6860 } 6861 6862 QDF_STATUS wmi_extract_dbr_ring_cap_service_ready_ext( 6863 void *wmi_hdl, 6864 uint8_t *evt_buf, uint8_t idx, 6865 struct wlan_psoc_host_dbr_ring_caps *param) 6866 { 6867 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6868 6869 if (wmi_handle->ops->extract_dbr_ring_cap_service_ready_ext) 6870 return wmi_handle->ops->extract_dbr_ring_cap_service_ready_ext( 6871 wmi_handle, 6872 evt_buf, idx, param); 6873 6874 return QDF_STATUS_E_FAILURE; 6875 } 6876 6877 QDF_STATUS wmi_extract_dbr_buf_release_fixed( 6878 void *wmi_hdl, 6879 uint8_t *evt_buf, 6880 struct direct_buf_rx_rsp *param) 6881 { 6882 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6883 6884 if (wmi_handle->ops->extract_dbr_buf_release_fixed) 6885 return wmi_handle->ops->extract_dbr_buf_release_fixed( 6886 wmi_handle, 6887 evt_buf, param); 6888 6889 return QDF_STATUS_E_FAILURE; 6890 } 6891 6892 QDF_STATUS wmi_extract_dbr_buf_release_entry( 6893 void *wmi_hdl, 6894 uint8_t *evt_buf, uint8_t idx, 6895 struct direct_buf_rx_entry *param) 6896 { 6897 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6898 6899 if (wmi_handle->ops->extract_dbr_buf_release_entry) 6900 return wmi_handle->ops->extract_dbr_buf_release_entry( 6901 wmi_handle, 6902 evt_buf, idx, param); 6903 6904 return QDF_STATUS_E_FAILURE; 6905 } 6906 6907 /** 6908 * wmi_extract_pdev_utf_event() - 6909 * extract UTF data from pdev utf event 6910 * @wmi_handle: wmi handle 6911 * @param evt_buf: pointer to event buffer 6912 * @param param: Pointer to hold evt buf 6913 * 6914 * Return: QDF_STATUS_SUCCESS for success or error code 6915 */ 6916 QDF_STATUS wmi_extract_pdev_utf_event(void *wmi_hdl, 6917 uint8_t *evt_buf, 6918 struct wmi_host_pdev_utf_event *param) 6919 { 6920 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6921 6922 if (wmi_handle->ops->extract_pdev_utf_event) 6923 return wmi_handle->ops->extract_pdev_utf_event( 6924 wmi_handle, 6925 evt_buf, param); 6926 6927 return QDF_STATUS_E_FAILURE; 6928 } 6929 6930 /** 6931 * wmi_extract_pdev_qvit_event() - 6932 * extract UTF data from pdev qvit event 6933 * @wmi_handle: wmi handle 6934 * @param evt_buf: pointer to event buffer 6935 * @param param: Pointer to hold evt buf 6936 * 6937 * Return: QDF_STATUS_SUCCESS for success or error code 6938 */ 6939 QDF_STATUS wmi_extract_pdev_qvit_event(void *wmi_hdl, 6940 uint8_t *evt_buf, 6941 struct wmi_host_pdev_qvit_event *param) 6942 { 6943 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6944 6945 if (wmi_handle->ops->extract_pdev_qvit_event) 6946 return wmi_handle->ops->extract_pdev_qvit_event( 6947 wmi_handle, 6948 evt_buf, param); 6949 6950 return QDF_STATUS_E_FAILURE; 6951 } 6952 6953 /** 6954 * wmi_unified_send_coex_ver_cfg_cmd() - send coex ver cfg command 6955 * @wmi_handle: wmi handle 6956 * @param: wmi coex ver cfg params 6957 * 6958 * Send WMI_COEX_VERSION_CFG_CMID parameters to fw. 6959 * 6960 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6961 */ 6962 QDF_STATUS wmi_unified_send_coex_ver_cfg_cmd(void *wmi_hdl, 6963 coex_ver_cfg_t *param) 6964 { 6965 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6966 6967 if (wmi_handle->ops->send_coex_ver_cfg_cmd) 6968 return wmi_handle->ops->send_coex_ver_cfg_cmd(wmi_handle, 6969 param); 6970 6971 return QDF_STATUS_E_FAILURE; 6972 } 6973 6974 /** 6975 * wmi_unified_send_coex_config_cmd() - send coex ver cfg command 6976 * @wmi_handle: wmi handle 6977 * @param: wmi coex cfg cmd params 6978 * 6979 * Send WMI_COEX_CFG_CMD parameters to fw. 6980 * 6981 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 6982 */ 6983 QDF_STATUS wmi_unified_send_coex_config_cmd(void *wmi_hdl, 6984 struct coex_config_params *param) 6985 { 6986 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6987 6988 if (wmi_handle->ops->send_coex_config_cmd) 6989 return wmi_handle->ops->send_coex_config_cmd(wmi_handle, 6990 param); 6991 6992 return QDF_STATUS_E_FAILURE; 6993 } 6994 6995 QDF_STATUS wmi_unified_send_request_get_rcpi_cmd(void *wmi_hdl, 6996 struct rcpi_req *get_rcpi_param) 6997 { 6998 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 6999 7000 if (wmi_handle->ops->send_get_rcpi_cmd) 7001 return wmi_handle->ops->send_get_rcpi_cmd(wmi_handle, 7002 get_rcpi_param); 7003 7004 return QDF_STATUS_E_FAILURE; 7005 } 7006 7007 QDF_STATUS wmi_extract_rcpi_response_event(void *wmi_hdl, void *evt_buf, 7008 struct rcpi_res *res) 7009 { 7010 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7011 struct wmi_ops *ops = wmi_handle->ops; 7012 7013 if (ops->extract_rcpi_response_event) 7014 return ops->extract_rcpi_response_event(wmi_handle, evt_buf, 7015 res); 7016 7017 return QDF_STATUS_E_FAILURE; 7018 } 7019 7020 /** 7021 * wmi_extract_peer_delete_response_event() - 7022 * extract vdev id and peer mac addresse from peer delete response event 7023 * @wmi_handle: wmi handle 7024 * @param evt_buf: pointer to event buffer 7025 * @param param: Pointer to hold evt buf 7026 * 7027 * Return: QDF_STATUS_SUCCESS for success or error code 7028 */ 7029 QDF_STATUS wmi_extract_peer_delete_response_event( 7030 void *wmi_hdl, 7031 uint8_t *evt_buf, 7032 struct wmi_host_peer_delete_response_event *param) 7033 { 7034 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7035 7036 if (wmi_handle->ops->extract_peer_delete_response_event) 7037 return wmi_handle->ops->extract_peer_delete_response_event( 7038 wmi_handle, 7039 evt_buf, param); 7040 7041 return QDF_STATUS_E_FAILURE; 7042 } 7043 7044 QDF_STATUS 7045 wmi_unified_dfs_phyerr_offload_en_cmd(void *wmi_hdl, 7046 uint32_t pdev_id) 7047 { 7048 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7049 7050 if (wmi_handle->ops->send_dfs_phyerr_offload_en_cmd) 7051 return wmi_handle->ops->send_dfs_phyerr_offload_en_cmd( 7052 wmi_handle, pdev_id); 7053 7054 return QDF_STATUS_E_FAILURE; 7055 } 7056 7057 QDF_STATUS 7058 wmi_unified_dfs_phyerr_offload_dis_cmd(void *wmi_hdl, 7059 uint32_t pdev_id) 7060 { 7061 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7062 7063 if (wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd) 7064 return wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd( 7065 wmi_handle, pdev_id); 7066 7067 return QDF_STATUS_E_FAILURE; 7068 } 7069 7070 /* 7071 * wmi_extract_chainmask_tables_tlv() - extract chain mask tables 7072 * @wmi_handle: wmi handle 7073 * @evt_buf: pointer to event buffer. 7074 * @chainmask_table: pointer to struct wlan_psoc_host_chainmask_table 7075 * 7076 * 7077 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 7078 */ 7079 QDF_STATUS wmi_extract_chainmask_tables(void *wmi_hdl, uint8_t *evt_buf, 7080 struct wlan_psoc_host_chainmask_table *chainmask_table) 7081 { 7082 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7083 7084 if (wmi_handle->ops->extract_chainmask_tables) 7085 return wmi_handle->ops->extract_chainmask_tables(wmi_handle, 7086 evt_buf, chainmask_table); 7087 7088 return QDF_STATUS_E_FAILURE; 7089 } 7090 /** 7091 * wmi_unified_set_country_cmd_send() - WMI set country function 7092 * @param wmi_handle : handle to WMI. 7093 * @param param : pointer to hold set country cmd parameter 7094 * 7095 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 7096 */ 7097 QDF_STATUS wmi_unified_set_country_cmd_send(void *wmi_hdl, 7098 struct set_country *param) 7099 { 7100 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7101 7102 if (wmi_handle->ops->send_set_country_cmd) 7103 return wmi_handle->ops->send_set_country_cmd(wmi_handle, 7104 param); 7105 7106 return QDF_STATUS_E_FAILURE; 7107 } 7108 7109 /** 7110 * wmi_unified_send_dbs_scan_sel_params_cmd() - send wmi cmd of 7111 * DBS scan selection configuration params 7112 * @wma_handle: wma handler 7113 * @dbs_scan_params: pointer to wmi_dbs_scan_sel_params 7114 * 7115 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure 7116 */ 7117 QDF_STATUS wmi_unified_send_dbs_scan_sel_params_cmd(void *wmi_hdl, 7118 struct wmi_dbs_scan_sel_params *dbs_scan_params) 7119 { 7120 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7121 7122 if (wmi_handle->ops->send_dbs_scan_sel_params_cmd) 7123 return wmi_handle->ops-> 7124 send_dbs_scan_sel_params_cmd(wmi_handle, 7125 dbs_scan_params); 7126 7127 return QDF_STATUS_E_FAILURE; 7128 } 7129 7130 /** 7131 * wmi_unified_send_limit_off_chan_cmd() - send wmi cmd of limit off channel 7132 * configuration params 7133 * @wmi_hdl: wmi handler 7134 * @limit_off_chan_param: pointer to wmi_limit_off_chan_param 7135 * 7136 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code on failure 7137 */ 7138 QDF_STATUS wmi_unified_send_limit_off_chan_cmd(void *wmi_hdl, 7139 struct wmi_limit_off_chan_param *limit_off_chan_param) 7140 { 7141 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7142 7143 if (wmi_handle->ops->send_limit_off_chan_cmd) 7144 return wmi_handle->ops->send_limit_off_chan_cmd(wmi_handle, 7145 limit_off_chan_param); 7146 7147 return QDF_STATUS_E_FAILURE; 7148 } 7149 7150 /** 7151 * wmi_send_bcn_offload_control_cmd - send beacon ofload control cmd to fw 7152 * @wmi_hdl: wmi handle 7153 * @bcn_ctrl_param: pointer to bcn_offload_control param 7154 * 7155 * Return: QDF_STATUS_SUCCESS for success or error code 7156 */ 7157 QDF_STATUS wmi_send_bcn_offload_control_cmd(void *wmi_hdl, 7158 struct bcn_offload_control *bcn_ctrl_param) 7159 { 7160 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7161 7162 if (wmi_handle->ops->send_bcn_offload_control_cmd) 7163 return wmi_handle->ops->send_bcn_offload_control_cmd(wmi_handle, 7164 bcn_ctrl_param); 7165 7166 return QDF_STATUS_E_FAILURE; 7167 } 7168 7169 /** 7170 * wmi_unified_send_wds_entry_list_cmd() - WMI function to get list of 7171 * wds entries from FW 7172 * @wmi_handle: wmi handle 7173 * 7174 * Send WMI_PDEV_WDS_ENTRY_LIST_CMDID parameters to fw. 7175 * 7176 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 7177 */ 7178 QDF_STATUS wmi_unified_send_dump_wds_table_cmd(void *wmi_hdl) 7179 { 7180 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7181 7182 if (wmi_handle->ops->send_wds_entry_list_cmd) 7183 return wmi_handle->ops->send_wds_entry_list_cmd(wmi_handle); 7184 7185 return QDF_STATUS_E_FAILURE; 7186 } 7187 7188 /** 7189 * wmi_extract_wds_entry - api to extract wds entry 7190 * @wmi_handle: wma handle 7191 * @evt_buf: pointer to event buffer 7192 * @wds_entry: wds entry 7193 * @idx: index to point wds entry in event buffer 7194 * 7195 * Return: QDF_STATUS_SUCCESS for successful event parse 7196 * else QDF_STATUS_E_INVAL or QDF_STATUS_E_FAILURE 7197 */ 7198 QDF_STATUS wmi_extract_wds_entry(void *wmi_hdl, uint8_t *evt_buf, 7199 struct wdsentry *wds_entry, 7200 u_int32_t idx) 7201 { 7202 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7203 7204 if (wmi_handle->ops->extract_wds_entry) 7205 return wmi_handle->ops->extract_wds_entry(wmi_handle, 7206 evt_buf, wds_entry, idx); 7207 7208 return QDF_STATUS_E_FAILURE; 7209 } 7210 qdf_export_symbol(wmi_extract_wds_entry); 7211 7212 #ifdef WLAN_FEATURE_NAN_CONVERGENCE 7213 QDF_STATUS wmi_unified_ndp_initiator_req_cmd_send(void *wmi_hdl, 7214 struct nan_datapath_initiator_req *req) 7215 { 7216 wmi_unified_t wmi_handle = wmi_hdl; 7217 7218 if (wmi_handle->ops->send_ndp_initiator_req_cmd) 7219 return wmi_handle->ops->send_ndp_initiator_req_cmd(wmi_handle, 7220 req); 7221 7222 return QDF_STATUS_E_FAILURE; 7223 } 7224 7225 QDF_STATUS wmi_unified_ndp_responder_req_cmd_send(void *wmi_hdl, 7226 struct nan_datapath_responder_req *req) 7227 { 7228 wmi_unified_t wmi_handle = wmi_hdl; 7229 7230 if (wmi_handle->ops->send_ndp_responder_req_cmd) 7231 return wmi_handle->ops->send_ndp_responder_req_cmd(wmi_handle, 7232 req); 7233 7234 return QDF_STATUS_E_FAILURE; 7235 } 7236 7237 QDF_STATUS wmi_unified_ndp_end_req_cmd_send(void *wmi_hdl, 7238 struct nan_datapath_end_req *req) 7239 { 7240 wmi_unified_t wmi_handle = wmi_hdl; 7241 7242 if (wmi_handle->ops->send_ndp_end_req_cmd) 7243 return wmi_handle->ops->send_ndp_end_req_cmd(wmi_handle, 7244 req); 7245 7246 return QDF_STATUS_E_FAILURE; 7247 } 7248 7249 QDF_STATUS wmi_extract_ndp_initiator_rsp(wmi_unified_t wmi_handle, 7250 uint8_t *data, struct nan_datapath_initiator_rsp **rsp) 7251 { 7252 if (wmi_handle->ops->extract_ndp_initiator_rsp) 7253 return wmi_handle->ops->extract_ndp_initiator_rsp(wmi_handle, 7254 data, rsp); 7255 7256 return QDF_STATUS_E_FAILURE; 7257 } 7258 7259 QDF_STATUS wmi_extract_ndp_ind(wmi_unified_t wmi_handle, uint8_t *data, 7260 struct nan_datapath_indication_event **ind) 7261 { 7262 if (wmi_handle->ops->extract_ndp_ind) 7263 return wmi_handle->ops->extract_ndp_ind(wmi_handle, 7264 data, ind); 7265 7266 return QDF_STATUS_E_FAILURE; 7267 } 7268 7269 QDF_STATUS wmi_extract_ndp_confirm(wmi_unified_t wmi_handle, uint8_t *data, 7270 struct nan_datapath_confirm_event **ev) 7271 { 7272 if (wmi_handle->ops->extract_ndp_confirm) 7273 return wmi_handle->ops->extract_ndp_confirm(wmi_handle, 7274 data, ev); 7275 7276 return QDF_STATUS_E_FAILURE; 7277 } 7278 7279 QDF_STATUS wmi_extract_ndp_responder_rsp(wmi_unified_t wmi_handle, 7280 uint8_t *data, struct nan_datapath_responder_rsp **rsp) 7281 { 7282 if (wmi_handle->ops->extract_ndp_responder_rsp) 7283 return wmi_handle->ops->extract_ndp_responder_rsp(wmi_handle, 7284 data, rsp); 7285 7286 return QDF_STATUS_E_FAILURE; 7287 } 7288 7289 QDF_STATUS wmi_extract_ndp_end_rsp(wmi_unified_t wmi_handle, uint8_t *data, 7290 struct nan_datapath_end_rsp_event **rsp) 7291 { 7292 if (wmi_handle->ops->extract_ndp_end_rsp) 7293 return wmi_handle->ops->extract_ndp_end_rsp(wmi_handle, 7294 data, rsp); 7295 7296 return QDF_STATUS_E_FAILURE; 7297 } 7298 7299 QDF_STATUS wmi_extract_ndp_end_ind(wmi_unified_t wmi_handle, uint8_t *data, 7300 struct nan_datapath_end_indication_event **ind) 7301 { 7302 if (wmi_handle->ops->extract_ndp_end_ind) 7303 return wmi_handle->ops->extract_ndp_end_ind(wmi_handle, 7304 data, ind); 7305 7306 return QDF_STATUS_E_FAILURE; 7307 } 7308 #endif 7309 QDF_STATUS wmi_unified_send_btm_config(void *wmi_hdl, 7310 struct wmi_btm_config *params) 7311 { 7312 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7313 7314 if (wmi_handle->ops->send_btm_config) 7315 return wmi_handle->ops->send_btm_config(wmi_handle, 7316 params); 7317 7318 return QDF_STATUS_E_FAILURE; 7319 } 7320 7321 QDF_STATUS wmi_unified_send_obss_detection_cfg_cmd(void *wmi_hdl, 7322 struct wmi_obss_detection_cfg_param *obss_cfg_param) 7323 { 7324 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7325 7326 if (wmi_handle->ops->send_obss_detection_cfg_cmd) 7327 return wmi_handle->ops->send_obss_detection_cfg_cmd(wmi_handle, 7328 obss_cfg_param); 7329 7330 return QDF_STATUS_E_FAILURE; 7331 } 7332 7333 QDF_STATUS wmi_unified_extract_obss_detection_info(void *wmi_hdl, 7334 uint8_t *data, 7335 struct wmi_obss_detect_info 7336 *info) 7337 { 7338 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7339 7340 if (wmi_handle->ops->extract_obss_detection_info) 7341 return wmi_handle->ops->extract_obss_detection_info(data, info); 7342 7343 return QDF_STATUS_E_FAILURE; 7344 } 7345 7346 QDF_STATUS wmi_unified_offload_11k_cmd(void *wmi_hdl, 7347 struct wmi_11k_offload_params *params) 7348 { 7349 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7350 7351 if (wmi_handle->ops->send_offload_11k_cmd) 7352 return wmi_handle->ops->send_offload_11k_cmd( 7353 wmi_handle, params); 7354 7355 return QDF_STATUS_E_FAILURE; 7356 } 7357 7358 QDF_STATUS wmi_unified_invoke_neighbor_report_cmd(void *wmi_hdl, 7359 struct wmi_invoke_neighbor_report_params *params) 7360 { 7361 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 7362 7363 if (wmi_handle->ops->send_invoke_neighbor_report_cmd) 7364 return wmi_handle->ops->send_invoke_neighbor_report_cmd( 7365 wmi_handle, params); 7366 7367 return QDF_STATUS_E_FAILURE; 7368 } 7369 7370 #ifdef WLAN_SUPPORT_GREEN_AP 7371 QDF_STATUS wmi_extract_green_ap_egap_status_info( 7372 void *wmi_hdl, uint8_t *evt_buf, 7373 struct wlan_green_ap_egap_status_info *egap_status_info_params) 7374 { 7375 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7376 7377 if (wmi_handle->ops->extract_green_ap_egap_status_info) 7378 return wmi_handle->ops->extract_green_ap_egap_status_info( 7379 evt_buf, egap_status_info_params); 7380 7381 return QDF_STATUS_E_FAILURE; 7382 } 7383 #endif 7384 7385 QDF_STATUS wmi_unified_send_bss_color_change_enable_cmd(void *wmi_hdl, 7386 uint32_t vdev_id, 7387 bool enable) 7388 { 7389 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7390 7391 if (wmi_handle->ops->send_bss_color_change_enable_cmd) 7392 return wmi_handle->ops->send_bss_color_change_enable_cmd( 7393 wmi_handle, vdev_id, enable); 7394 7395 return QDF_STATUS_E_FAILURE; 7396 } 7397 7398 QDF_STATUS wmi_unified_send_obss_color_collision_cfg_cmd(void *wmi_hdl, 7399 struct wmi_obss_color_collision_cfg_param *cfg) 7400 { 7401 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7402 7403 if (wmi_handle->ops->send_obss_color_collision_cfg_cmd) 7404 return wmi_handle->ops->send_obss_color_collision_cfg_cmd( 7405 wmi_handle, cfg); 7406 7407 return QDF_STATUS_E_FAILURE; 7408 } 7409 7410 QDF_STATUS wmi_unified_extract_obss_color_collision_info(void *wmi_hdl, 7411 uint8_t *data, struct wmi_obss_color_collision_info *info) 7412 { 7413 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 7414 7415 if (wmi_handle->ops->extract_obss_color_collision_info) 7416 return wmi_handle->ops->extract_obss_color_collision_info(data, 7417 info); 7418 7419 return QDF_STATUS_E_FAILURE; 7420 } 7421