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