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