1 /* 2 * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include "wmi_unified_priv.h" 20 #include "wmi_unified_param.h" 21 #include "qdf_module.h" 22 #include "cdp_txrx_cmn_struct.h" 23 24 static const wmi_host_channel_width mode_to_width[WMI_HOST_MODE_MAX] = { 25 [WMI_HOST_MODE_11A] = WMI_HOST_CHAN_WIDTH_20, 26 [WMI_HOST_MODE_11G] = WMI_HOST_CHAN_WIDTH_20, 27 [WMI_HOST_MODE_11B] = WMI_HOST_CHAN_WIDTH_20, 28 [WMI_HOST_MODE_11GONLY] = WMI_HOST_CHAN_WIDTH_20, 29 [WMI_HOST_MODE_11NA_HT20] = WMI_HOST_CHAN_WIDTH_20, 30 [WMI_HOST_MODE_11NG_HT20] = WMI_HOST_CHAN_WIDTH_20, 31 [WMI_HOST_MODE_11AC_VHT20] = WMI_HOST_CHAN_WIDTH_20, 32 [WMI_HOST_MODE_11AC_VHT20_2G] = WMI_HOST_CHAN_WIDTH_20, 33 [WMI_HOST_MODE_11NA_HT40] = WMI_HOST_CHAN_WIDTH_40, 34 [WMI_HOST_MODE_11NG_HT40] = WMI_HOST_CHAN_WIDTH_40, 35 [WMI_HOST_MODE_11AC_VHT40] = WMI_HOST_CHAN_WIDTH_40, 36 [WMI_HOST_MODE_11AC_VHT40_2G] = WMI_HOST_CHAN_WIDTH_40, 37 [WMI_HOST_MODE_11AC_VHT80] = WMI_HOST_CHAN_WIDTH_80, 38 [WMI_HOST_MODE_11AC_VHT80_2G] = WMI_HOST_CHAN_WIDTH_80, 39 #if CONFIG_160MHZ_SUPPORT 40 [WMI_HOST_MODE_11AC_VHT80_80] = WMI_HOST_CHAN_WIDTH_80P80, 41 [WMI_HOST_MODE_11AC_VHT160] = WMI_HOST_CHAN_WIDTH_160, 42 #endif 43 44 #if SUPPORT_11AX 45 [WMI_HOST_MODE_11AX_HE20] = WMI_HOST_CHAN_WIDTH_20, 46 [WMI_HOST_MODE_11AX_HE40] = WMI_HOST_CHAN_WIDTH_40, 47 [WMI_HOST_MODE_11AX_HE80] = WMI_HOST_CHAN_WIDTH_80, 48 [WMI_HOST_MODE_11AX_HE80_80] = WMI_HOST_CHAN_WIDTH_80P80, 49 [WMI_HOST_MODE_11AX_HE160] = WMI_HOST_CHAN_WIDTH_160, 50 [WMI_HOST_MODE_11AX_HE20_2G] = WMI_HOST_CHAN_WIDTH_20, 51 [WMI_HOST_MODE_11AX_HE40_2G] = WMI_HOST_CHAN_WIDTH_40, 52 [WMI_HOST_MODE_11AX_HE80_2G] = WMI_HOST_CHAN_WIDTH_80, 53 #endif 54 }; 55 56 /** 57 * wmi_unified_vdev_create_send() - send VDEV create command to fw 58 * @wmi_handle: wmi handle 59 * @param: pointer to hold vdev create parameter 60 * @macaddr: vdev mac address 61 * 62 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 63 */ 64 QDF_STATUS wmi_unified_vdev_create_send(void *wmi_hdl, 65 uint8_t macaddr[IEEE80211_ADDR_LEN], 66 struct vdev_create_params *param) 67 { 68 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 69 70 if (wmi_handle->ops->send_vdev_create_cmd) 71 return wmi_handle->ops->send_vdev_create_cmd(wmi_handle, 72 macaddr, param); 73 74 return QDF_STATUS_E_FAILURE; 75 } 76 77 /** 78 * wmi_unified_vdev_delete_send() - send VDEV delete command to fw 79 * @wmi_handle: wmi handle 80 * @if_id: vdev id 81 * 82 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 83 */ 84 QDF_STATUS wmi_unified_vdev_delete_send(void *wmi_hdl, 85 uint8_t if_id) 86 { 87 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 88 89 if (wmi_handle->ops->send_vdev_delete_cmd) 90 return wmi_handle->ops->send_vdev_delete_cmd(wmi_handle, 91 if_id); 92 93 return QDF_STATUS_E_FAILURE; 94 } 95 96 QDF_STATUS 97 wmi_unified_vdev_nss_chain_params_send(void *wmi_hdl, 98 uint8_t vdev_id, 99 struct vdev_nss_chains *user_cfg) 100 { 101 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 102 103 if (wmi_handle->ops->send_vdev_nss_chain_params_cmd) 104 return wmi_handle->ops->send_vdev_nss_chain_params_cmd( 105 wmi_handle, 106 vdev_id, 107 user_cfg); 108 109 return QDF_STATUS_E_FAILURE; 110 } 111 112 /** 113 * wmi_unified_vdev_stop_send() - send vdev stop 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_stop_send(void *wmi_hdl, 120 uint8_t vdev_id) 121 { 122 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 123 124 if (wmi_handle->ops->send_vdev_stop_cmd) 125 return wmi_handle->ops->send_vdev_stop_cmd(wmi_handle, 126 vdev_id); 127 128 return QDF_STATUS_E_FAILURE; 129 } 130 131 /** 132 * wmi_unified_vdev_down_send() - send vdev down command to fw 133 * @wmi: wmi handle 134 * @vdev_id: vdev id 135 * 136 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 137 */ 138 QDF_STATUS wmi_unified_vdev_down_send(void *wmi_hdl, uint8_t vdev_id) 139 { 140 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 141 142 if (wmi_handle->ops->send_vdev_down_cmd) 143 return wmi_handle->ops->send_vdev_down_cmd(wmi_handle, vdev_id); 144 145 return QDF_STATUS_E_FAILURE; 146 } 147 148 /** 149 * wmi_unified_vdev_start_send() - send vdev start command to fw 150 * @wmi: wmi handle 151 * @vdev_id: vdev id 152 * 153 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 154 */ 155 QDF_STATUS wmi_unified_vdev_start_send(void *wmi_hdl, 156 struct vdev_start_params *req) 157 { 158 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 159 160 if (wmi_handle->ops->send_vdev_start_cmd) 161 return wmi_handle->ops->send_vdev_start_cmd(wmi_handle, req); 162 163 return QDF_STATUS_E_FAILURE; 164 } 165 166 /** 167 * wmi_unified_vdev_set_nac_rssi_send() - send NAC_RSSI command to fw 168 * @wmi: wmi handle 169 * @req: pointer to hold nac rssi request data 170 * 171 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 172 */ 173 QDF_STATUS wmi_unified_vdev_set_nac_rssi_send(void *wmi_hdl, 174 struct vdev_scan_nac_rssi_params *req) 175 { 176 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 177 178 if (wmi_handle->ops->send_vdev_set_nac_rssi_cmd) 179 return wmi_handle->ops->send_vdev_set_nac_rssi_cmd(wmi_handle, req); 180 181 return QDF_STATUS_E_FAILURE; 182 } 183 184 /** 185 * wmi_unified_hidden_ssid_vdev_restart_send() - restart vdev to set hidden ssid 186 * @wmi: wmi handle 187 * @restart_params: vdev restart params 188 * 189 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 190 */ 191 QDF_STATUS wmi_unified_hidden_ssid_vdev_restart_send(void *wmi_hdl, 192 struct hidden_ssid_vdev_restart_params *restart_params) 193 { 194 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 195 196 if (wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd) 197 return wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd( 198 wmi_handle, restart_params); 199 200 return QDF_STATUS_E_FAILURE; 201 } 202 203 /** 204 * wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw 205 * @wmi: wmi handle 206 * @peer_addr: peer mac address 207 * @param: pointer to hold peer flush tid parameter 208 * 209 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 210 */ 211 QDF_STATUS wmi_unified_peer_flush_tids_send(void *wmi_hdl, 212 uint8_t peer_addr[IEEE80211_ADDR_LEN], 213 struct peer_flush_params *param) 214 { 215 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 216 217 if (wmi_handle->ops->send_peer_flush_tids_cmd) 218 return wmi_handle->ops->send_peer_flush_tids_cmd(wmi_handle, 219 peer_addr, param); 220 221 return QDF_STATUS_E_FAILURE; 222 } 223 224 /** 225 * wmi_unified_peer_delete_send() - send PEER delete command to fw 226 * @wmi: wmi handle 227 * @peer_addr: peer mac addr 228 * @vdev_id: vdev id 229 * 230 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 231 */ 232 QDF_STATUS wmi_unified_peer_delete_send(void *wmi_hdl, 233 uint8_t 234 peer_addr[IEEE80211_ADDR_LEN], 235 uint8_t vdev_id) 236 { 237 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 238 239 if (wmi_handle->ops->send_peer_delete_cmd) 240 return wmi_handle->ops->send_peer_delete_cmd(wmi_handle, 241 peer_addr, vdev_id); 242 243 return QDF_STATUS_E_FAILURE; 244 } 245 246 /** 247 * wmi_set_peer_param() - set peer parameter in fw 248 * @wmi_ctx: wmi handle 249 * @peer_addr: peer mac address 250 * @param : pointer to hold peer set parameter 251 * 252 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 253 */ 254 QDF_STATUS wmi_set_peer_param_send(void *wmi_hdl, 255 uint8_t peer_addr[IEEE80211_ADDR_LEN], 256 struct peer_set_params *param) 257 { 258 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 259 260 if (wmi_handle->ops->send_peer_param_cmd) 261 return wmi_handle->ops->send_peer_param_cmd(wmi_handle, 262 peer_addr, param); 263 264 return QDF_STATUS_E_FAILURE; 265 } 266 267 /** 268 * wmi_unified_vdev_up_send() - send vdev up command in fw 269 * @wmi: wmi handle 270 * @bssid: bssid 271 * @vdev_up_params: pointer to hold vdev up parameter 272 * 273 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 274 */ 275 QDF_STATUS wmi_unified_vdev_up_send(void *wmi_hdl, 276 uint8_t bssid[IEEE80211_ADDR_LEN], 277 struct vdev_up_params *params) 278 { 279 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 280 281 if (wmi_handle->ops->send_vdev_up_cmd) 282 return wmi_handle->ops->send_vdev_up_cmd(wmi_handle, bssid, 283 params); 284 285 return QDF_STATUS_E_FAILURE; 286 } 287 288 /** 289 * wmi_unified_peer_create_send() - send peer create command to fw 290 * @wmi: wmi handle 291 * @peer_addr: peer mac address 292 * @peer_type: peer type 293 * @vdev_id: vdev id 294 * 295 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 296 */ 297 QDF_STATUS wmi_unified_peer_create_send(void *wmi_hdl, 298 struct peer_create_params *param) 299 { 300 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 301 302 if (wmi_handle->ops->send_peer_create_cmd) 303 return wmi_handle->ops->send_peer_create_cmd(wmi_handle, param); 304 305 return QDF_STATUS_E_FAILURE; 306 } 307 308 /** 309 * wmi_unified_peer_rx_reorder_queue_setup_send() - send rx reorder queue 310 * setup command to fw 311 * @wmi: wmi handle 312 * @rx_reorder_queue_setup_params: Rx reorder queue setup parameters 313 * 314 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 315 */ 316 QDF_STATUS wmi_unified_peer_rx_reorder_queue_setup_send(void *wmi_hdl, 317 struct rx_reorder_queue_setup_params *param) 318 { 319 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 320 321 if (wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd) 322 return wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd( 323 wmi_handle, param); 324 325 return QDF_STATUS_E_FAILURE; 326 } 327 328 /** 329 * wmi_unified_peer_rx_reorder_queue_remove_send() - send rx reorder queue 330 * remove command to fw 331 * @wmi: wmi handle 332 * @rx_reorder_queue_remove_params: Rx reorder queue remove parameters 333 * 334 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure 335 */ 336 QDF_STATUS wmi_unified_peer_rx_reorder_queue_remove_send(void *wmi_hdl, 337 struct rx_reorder_queue_remove_params *param) 338 { 339 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 340 341 if (wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd) 342 return wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd( 343 wmi_handle, param); 344 345 return QDF_STATUS_E_FAILURE; 346 } 347 348 #ifdef WLAN_SUPPORT_GREEN_AP 349 /** 350 * wmi_unified_green_ap_ps_send() - enable green ap powersave command 351 * @wmi_handle: wmi handle 352 * @value: value 353 * @pdev_id: pdev id to have radio context 354 * 355 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 356 */ 357 QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl, 358 uint32_t value, uint8_t pdev_id) 359 { 360 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 361 362 if (wmi_handle->ops->send_green_ap_ps_cmd) 363 return wmi_handle->ops->send_green_ap_ps_cmd(wmi_handle, value, 364 pdev_id); 365 366 return QDF_STATUS_E_FAILURE; 367 } 368 #else 369 QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl, 370 uint32_t value, uint8_t pdev_id) 371 { 372 return QDF_STATUS_SUCCESS; 373 } 374 #endif /* WLAN_SUPPORT_GREEN_AP */ 375 376 /** 377 * wmi_unified_pdev_utf_cmd() - send utf command to fw 378 * @wmi_handle: wmi handle 379 * @param: pointer to pdev_utf_params 380 * @mac_id: mac id to have radio context 381 * 382 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 383 */ 384 QDF_STATUS 385 wmi_unified_pdev_utf_cmd_send(void *wmi_hdl, 386 struct pdev_utf_params *param, 387 uint8_t mac_id) 388 { 389 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 390 391 if (wmi_handle->ops->send_pdev_utf_cmd) 392 return wmi_handle->ops->send_pdev_utf_cmd(wmi_handle, param, 393 mac_id); 394 395 return QDF_STATUS_E_FAILURE; 396 } 397 398 /** 399 * wmi_unified_pdev_param_send() - set pdev parameters 400 * @wmi_handle: wmi handle 401 * @param: pointer to pdev parameter 402 * @mac_id: radio context 403 * 404 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 405 * errno on failure 406 */ 407 QDF_STATUS 408 wmi_unified_pdev_param_send(void *wmi_hdl, 409 struct pdev_params *param, 410 uint8_t mac_id) 411 { 412 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 413 414 if (wmi_handle->ops->send_pdev_param_cmd) 415 return wmi_handle->ops->send_pdev_param_cmd(wmi_handle, param, 416 mac_id); 417 418 return QDF_STATUS_E_FAILURE; 419 } 420 421 /** 422 * wmi_unified_suspend_send() - WMI suspend function 423 * @param wmi_handle : handle to WMI. 424 * @param param : pointer to hold suspend parameter 425 * @mac_id: radio context 426 * 427 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 428 */ 429 QDF_STATUS wmi_unified_suspend_send(void *wmi_hdl, 430 struct suspend_params *param, 431 uint8_t mac_id) 432 { 433 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 434 435 if (wmi_handle->ops->send_suspend_cmd) 436 return wmi_handle->ops->send_suspend_cmd(wmi_handle, param, 437 mac_id); 438 439 return QDF_STATUS_E_FAILURE; 440 } 441 442 /** 443 * wmi_unified_resume_send - WMI resume function 444 * @param wmi_handle : handle to WMI. 445 * @mac_id: radio context 446 * 447 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 448 */ 449 QDF_STATUS wmi_unified_resume_send(void *wmi_hdl, 450 uint8_t mac_id) 451 { 452 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 453 454 if (wmi_handle->ops->send_resume_cmd) 455 return wmi_handle->ops->send_resume_cmd(wmi_handle, 456 mac_id); 457 458 return QDF_STATUS_E_FAILURE; 459 } 460 461 /** 462 * wmi_unified_wow_enable_send() - WMI wow enable function 463 * @param wmi_handle : handle to WMI. 464 * @param param : pointer to hold wow enable parameter 465 * @mac_id: radio context 466 * 467 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 468 */ 469 QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl, 470 struct wow_cmd_params *param, 471 uint8_t mac_id) 472 { 473 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 474 475 if (wmi_handle->ops->send_wow_enable_cmd) 476 return wmi_handle->ops->send_wow_enable_cmd(wmi_handle, param, 477 mac_id); 478 479 return QDF_STATUS_E_FAILURE; 480 } 481 482 /** 483 * wmi_unified_wow_wakeup_send() - WMI wow wakeup function 484 * @param wmi_hdl : handle to WMI. 485 * 486 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 487 */ 488 QDF_STATUS wmi_unified_wow_wakeup_send(void *wmi_hdl) 489 { 490 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 491 492 if (wmi_handle->ops->send_wow_wakeup_cmd) 493 return wmi_handle->ops->send_wow_wakeup_cmd(wmi_handle); 494 495 return QDF_STATUS_E_FAILURE; 496 } 497 498 /** 499 * wmi_unified_wow_add_wakeup_event_send() - WMI wow wakeup function 500 * @param wmi_handle : handle to WMI. 501 * @param: pointer to wow wakeup event parameter structure 502 * 503 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 504 */ 505 QDF_STATUS wmi_unified_wow_add_wakeup_event_send(void *wmi_hdl, 506 struct wow_add_wakeup_params *param) 507 { 508 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 509 510 if (wmi->ops->send_wow_add_wakeup_event_cmd) 511 return wmi->ops->send_wow_add_wakeup_event_cmd(wmi, 512 param); 513 514 return QDF_STATUS_E_FAILURE; 515 } 516 517 /** 518 * wmi_unified_wow_add_wakeup_pattern_send() - WMI wow wakeup pattern function 519 * @param wmi_handle : handle to WMI. 520 * @param: pointer to wow wakeup pattern parameter structure 521 * 522 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 523 */ 524 QDF_STATUS wmi_unified_wow_add_wakeup_pattern_send(void *wmi_hdl, 525 struct wow_add_wakeup_pattern_params *param) 526 { 527 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 528 529 if (wmi->ops->send_wow_add_wakeup_pattern_cmd) 530 return wmi->ops->send_wow_add_wakeup_pattern_cmd(wmi, param); 531 532 return QDF_STATUS_E_FAILURE; 533 } 534 535 /** 536 * wmi_unified_wow_remove_wakeup_pattern_send() - WMI wow wakeup pattern function 537 * @param wmi_handle : handle to WMI. 538 * @param: pointer to wow wakeup pattern parameter structure 539 * 540 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 541 */ 542 QDF_STATUS wmi_unified_wow_remove_wakeup_pattern_send(void *wmi_hdl, 543 struct wow_remove_wakeup_pattern_params *param) 544 { 545 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 546 547 if (wmi->ops->send_wow_remove_wakeup_pattern_cmd) 548 return wmi->ops->send_wow_remove_wakeup_pattern_cmd(wmi, param); 549 550 return QDF_STATUS_E_FAILURE; 551 } 552 553 /** 554 * wmi_unified_ap_ps_cmd_send() - set ap powersave parameters 555 * @wma_ctx: wma context 556 * @peer_addr: peer mac address 557 * @param: pointer to ap_ps parameter structure 558 * 559 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 560 */ 561 QDF_STATUS wmi_unified_ap_ps_cmd_send(void *wmi_hdl, 562 uint8_t *peer_addr, 563 struct ap_ps_params *param) 564 { 565 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 566 567 if (wmi_handle->ops->send_set_ap_ps_param_cmd) 568 return wmi_handle->ops->send_set_ap_ps_param_cmd(wmi_handle, 569 peer_addr, 570 param); 571 572 return QDF_STATUS_E_FAILURE; 573 } 574 575 /** 576 * wmi_unified_sta_ps_cmd_send() - set sta powersave parameters 577 * @wma_ctx: wma context 578 * @peer_addr: peer mac address 579 * @param: pointer to sta_ps parameter structure 580 * 581 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 582 */ 583 QDF_STATUS wmi_unified_sta_ps_cmd_send(void *wmi_hdl, 584 struct sta_ps_params *param) 585 { 586 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 587 588 if (wmi_handle->ops->send_set_sta_ps_param_cmd) 589 return wmi_handle->ops->send_set_sta_ps_param_cmd(wmi_handle, 590 param); 591 592 return QDF_STATUS_E_FAILURE; 593 } 594 595 /** 596 * wmi_crash_inject() - inject fw crash 597 * @wma_handle: wma handle 598 * @param: ponirt to crash inject parameter structure 599 * 600 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 601 */ 602 QDF_STATUS wmi_crash_inject(void *wmi_hdl, 603 struct crash_inject *param) 604 { 605 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 606 607 if (wmi_handle->ops->send_crash_inject_cmd) 608 return wmi_handle->ops->send_crash_inject_cmd(wmi_handle, 609 param); 610 611 return QDF_STATUS_E_FAILURE; 612 } 613 614 #ifdef FEATURE_FW_LOG_PARSING 615 /** 616 * wmi_unified_dbglog_cmd_send() - set debug log level 617 * @param wmi_handle : handle to WMI. 618 * @param param : pointer to hold dbglog level parameter 619 * 620 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 621 */ 622 QDF_STATUS 623 wmi_unified_dbglog_cmd_send(void *wmi_hdl, 624 struct dbglog_params *dbglog_param) 625 { 626 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 627 628 if (wmi_handle->ops->send_dbglog_cmd) 629 return wmi_handle->ops->send_dbglog_cmd(wmi_handle, 630 dbglog_param); 631 632 return QDF_STATUS_E_FAILURE; 633 } 634 qdf_export_symbol(wmi_unified_dbglog_cmd_send); 635 #endif 636 637 /** 638 * wmi_unified_vdev_set_param_send() - WMI vdev set parameter function 639 * @param wmi_handle : handle to WMI. 640 * @param macaddr : MAC address 641 * @param param : pointer to hold vdev set parameter 642 * 643 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 644 */ 645 QDF_STATUS wmi_unified_vdev_set_param_send(void *wmi_hdl, 646 struct vdev_set_params *param) 647 { 648 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 649 650 if (wmi_handle->ops->send_vdev_set_param_cmd) 651 return wmi_handle->ops->send_vdev_set_param_cmd(wmi_handle, 652 param); 653 654 return QDF_STATUS_E_FAILURE; 655 } 656 657 /** 658 * wmi_unified_sifs_trigger_send() - WMI vdev sifs trigger parameter function 659 * @param wmi_handle : handle to WMI. 660 * @param param : pointer to hold sifs trigger parameter 661 * 662 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 663 */ 664 QDF_STATUS wmi_unified_sifs_trigger_send(void *wmi_hdl, 665 struct sifs_trigger_param *param) 666 { 667 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 668 669 if (wmi_handle->ops->send_vdev_sifs_trigger_cmd) 670 return wmi_handle->ops->send_vdev_sifs_trigger_cmd(wmi_handle, 671 param); 672 673 return QDF_STATUS_E_FAILURE; 674 } 675 676 /** 677 * wmi_unified_stats_request_send() - WMI request stats function 678 * @param wmi_handle : handle to WMI. 679 * @param macaddr : MAC address 680 * @param param : pointer to hold stats request parameter 681 * 682 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 683 */ 684 QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle, 685 uint8_t macaddr[IEEE80211_ADDR_LEN], 686 struct stats_request_params *param) 687 { 688 if (wmi_handle->ops->send_stats_request_cmd) 689 return wmi_handle->ops->send_stats_request_cmd(wmi_handle, 690 macaddr, param); 691 692 return QDF_STATUS_E_FAILURE; 693 } 694 695 #ifdef CONFIG_MCL 696 /** 697 * wmi_unified_packet_log_enable_send() - WMI request stats function 698 * @param wmi_handle : handle to WMI. 699 * @param macaddr : MAC address 700 * @param param : pointer to hold stats request parameter 701 * 702 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 703 */ 704 QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, 705 uint8_t macaddr[IEEE80211_ADDR_LEN], 706 struct packet_enable_params *param) 707 { 708 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 709 710 if (wmi_handle->ops->send_packet_log_enable_cmd) 711 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle, 712 macaddr, param); 713 714 return QDF_STATUS_E_FAILURE; 715 } 716 #else 717 /** 718 * wmi_unified_packet_log_enable_send() - WMI request stats function 719 * @param wmi_handle : handle to WMI. 720 * @param macaddr : MAC address 721 * @param param : pointer to hold stats request parameter 722 * 723 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 724 */ 725 QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, 726 WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id) 727 { 728 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 729 730 if (wmi_handle->ops->send_packet_log_enable_cmd) 731 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle, 732 PKTLOG_EVENT, mac_id); 733 734 return QDF_STATUS_E_FAILURE; 735 } 736 737 /** 738 * wmi_unified_peer_based_pktlog_send() - WMI request enable peer 739 * based filtering 740 * @wmi_handle: handle to WMI. 741 * @macaddr: PEER mac address to be filtered 742 * @mac_id: Mac id 743 * @enb_dsb: Enable or Disable peer based pktlog 744 * filtering 745 * 746 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 747 */ 748 QDF_STATUS wmi_unified_peer_based_pktlog_send(void *wmi_hdl, 749 uint8_t *macaddr, 750 uint8_t mac_id, 751 uint8_t enb_dsb) 752 { 753 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 754 755 if (wmi_handle->ops->send_peer_based_pktlog_cmd) 756 return wmi_handle->ops->send_peer_based_pktlog_cmd 757 (wmi_handle, macaddr, mac_id, enb_dsb); 758 759 return QDF_STATUS_E_FAILURE; 760 } 761 #endif 762 /** 763 * wmi_unified_packet_log_disable__send() - WMI pktlog disable function 764 * @param wmi_handle : handle to WMI. 765 * @param PKTLOG_EVENT : packet log event 766 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 767 */ 768 QDF_STATUS wmi_unified_packet_log_disable_send(void *wmi_hdl, uint8_t mac_id) 769 { 770 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 771 772 if (wmi_handle->ops->send_packet_log_disable_cmd) 773 return wmi_handle->ops->send_packet_log_disable_cmd(wmi_handle, 774 mac_id); 775 776 return QDF_STATUS_E_FAILURE; 777 } 778 779 /** 780 * wmi_unified_beacon_tmpl_send_cmd() - WMI beacon send function 781 * @param wmi_handle : handle to WMI. 782 * @param macaddr : MAC address 783 * @param param : pointer to hold beacon send cmd parameter 784 * 785 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 786 */ 787 QDF_STATUS wmi_unified_beacon_tmpl_send_cmd(void *wmi_hdl, 788 struct beacon_tmpl_params *param) 789 { 790 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 791 792 if (wmi_handle->ops->send_beacon_tmpl_send_cmd) 793 return wmi_handle->ops->send_beacon_tmpl_send_cmd(wmi_handle, 794 param); 795 796 return QDF_STATUS_E_FAILURE; 797 } 798 /** 799 * wmi_unified_peer_assoc_send() - WMI peer assoc function 800 * @param wmi_handle : handle to WMI. 801 * @param macaddr : MAC address 802 * @param param : pointer to peer assoc parameter 803 * 804 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 805 */ 806 QDF_STATUS wmi_unified_peer_assoc_send(void *wmi_hdl, 807 struct peer_assoc_params *param) 808 { 809 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 810 811 if (wmi_handle->ops->send_peer_assoc_cmd) 812 return wmi_handle->ops->send_peer_assoc_cmd(wmi_handle, 813 param); 814 815 return QDF_STATUS_E_FAILURE; 816 } 817 818 /** 819 * wmi_unified_scan_start_cmd_send() - WMI scan start function 820 * @param wmi_handle : handle to WMI. 821 * @param macaddr : MAC address 822 * @param param : pointer to hold scan start cmd parameter 823 * 824 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 825 */ 826 QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl, 827 struct scan_req_params *param) 828 { 829 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 830 831 if (wmi_handle->ops->send_scan_start_cmd) 832 return wmi_handle->ops->send_scan_start_cmd(wmi_handle, 833 param); 834 835 return QDF_STATUS_E_FAILURE; 836 } 837 838 /** 839 * wmi_unified_scan_stop_cmd_send() - WMI scan start function 840 * @param wmi_handle : handle to WMI. 841 * @param macaddr : MAC address 842 * @param param : pointer to hold scan start cmd parameter 843 * 844 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 845 */ 846 QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl, 847 struct scan_cancel_param *param) 848 { 849 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 850 851 if (wmi_handle->ops->send_scan_stop_cmd) 852 return wmi_handle->ops->send_scan_stop_cmd(wmi_handle, 853 param); 854 855 return QDF_STATUS_E_FAILURE; 856 } 857 858 /** 859 * wmi_unified_scan_chan_list_cmd_send() - WMI scan channel list function 860 * @param wmi_handle : handle to WMI. 861 * @param macaddr : MAC address 862 * @param param : pointer to hold scan channel list parameter 863 * 864 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 865 */ 866 QDF_STATUS wmi_unified_scan_chan_list_cmd_send(void *wmi_hdl, 867 struct scan_chan_list_params *param) 868 { 869 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 870 871 if (wmi_handle->ops->send_scan_chan_list_cmd) 872 return wmi_handle->ops->send_scan_chan_list_cmd(wmi_handle, 873 param); 874 875 return QDF_STATUS_E_FAILURE; 876 } 877 878 /** 879 * wmi_mgmt_unified_cmd_send() - management cmd over wmi layer 880 * @wmi_hdl : handle to WMI. 881 * @param : pointer to hold mgmt cmd parameter 882 * 883 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 884 */ 885 QDF_STATUS wmi_mgmt_unified_cmd_send(void *wmi_hdl, 886 struct wmi_mgmt_params *param) 887 { 888 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 889 890 if (wmi_handle->ops->send_mgmt_cmd) 891 return wmi_handle->ops->send_mgmt_cmd(wmi_handle, 892 param); 893 894 return QDF_STATUS_E_FAILURE; 895 } 896 897 /** 898 * wmi_offchan_data_tx_cmd_send() - Send offchan data tx cmd over wmi layer 899 * @wmi_hdl : handle to WMI. 900 * @param : pointer to hold offchan data cmd parameter 901 * 902 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 903 */ 904 QDF_STATUS wmi_offchan_data_tx_cmd_send(void *wmi_hdl, 905 struct wmi_offchan_data_tx_params *param) 906 { 907 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 908 909 if (wmi_handle->ops->send_offchan_data_tx_cmd) 910 return wmi_handle->ops->send_offchan_data_tx_cmd(wmi_handle, 911 param); 912 913 return QDF_STATUS_E_FAILURE; 914 } 915 916 /** 917 * wmi_unified_modem_power_state() - set modem power state to fw 918 * @wmi_hdl: wmi handle 919 * @param_value: parameter value 920 * 921 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 922 */ 923 QDF_STATUS wmi_unified_modem_power_state(void *wmi_hdl, 924 uint32_t param_value) 925 { 926 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 927 928 if (wmi_handle->ops->send_modem_power_state_cmd) 929 return wmi_handle->ops->send_modem_power_state_cmd(wmi_handle, 930 param_value); 931 932 return QDF_STATUS_E_FAILURE; 933 } 934 935 /** 936 * wmi_unified_set_sta_ps_mode() - set sta powersave params in fw 937 * @wmi_hdl: wmi handle 938 * @vdev_id: vdev id 939 * @val: value 940 * 941 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 942 */ 943 QDF_STATUS wmi_unified_set_sta_ps_mode(void *wmi_hdl, 944 uint32_t vdev_id, uint8_t val) 945 { 946 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 947 948 if (wmi_handle->ops->send_set_sta_ps_mode_cmd) 949 return wmi_handle->ops->send_set_sta_ps_mode_cmd(wmi_handle, 950 vdev_id, val); 951 952 return QDF_STATUS_E_FAILURE; 953 } 954 955 /** 956 * wmi_set_mimops() - set MIMO powersave 957 * @wmi_hdl: wmi handle 958 * @vdev_id: vdev id 959 * @value: value 960 * 961 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 962 */ 963 QDF_STATUS wmi_unified_set_mimops(void *wmi_hdl, uint8_t vdev_id, int value) 964 { 965 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 966 967 if (wmi_handle->ops->send_set_mimops_cmd) 968 return wmi_handle->ops->send_set_mimops_cmd(wmi_handle, 969 vdev_id, value); 970 971 return QDF_STATUS_E_FAILURE; 972 } 973 974 /** 975 * wmi_set_smps_params() - set smps params 976 * @wmi_hdl: wmi handle 977 * @vdev_id: vdev id 978 * @value: value 979 * 980 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 981 */ 982 QDF_STATUS wmi_unified_set_smps_params(void *wmi_hdl, uint8_t vdev_id, 983 int value) 984 { 985 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 986 987 if (wmi_handle->ops->send_set_smps_params_cmd) 988 return wmi_handle->ops->send_set_smps_params_cmd(wmi_handle, 989 vdev_id, value); 990 991 return QDF_STATUS_E_FAILURE; 992 } 993 994 /** 995 * wmi_get_temperature() - get pdev temperature req 996 * @wmi_hdl: wmi handle 997 * 998 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 999 */ 1000 QDF_STATUS wmi_unified_get_temperature(void *wmi_hdl) 1001 { 1002 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1003 1004 if (wmi_handle->ops->send_get_temperature_cmd) 1005 return wmi_handle->ops->send_get_temperature_cmd(wmi_handle); 1006 1007 return QDF_STATUS_E_FAILURE; 1008 } 1009 1010 /** 1011 * wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command 1012 * @wmi_hdl: wmi handle 1013 * @end_set_sta_ps_mode_cmd: cmd parameter strcture 1014 * 1015 * This function sets the trigger 1016 * uapsd params such as service interval, delay interval 1017 * and suspend interval which will be used by the firmware 1018 * to send trigger frames periodically when there is no 1019 * traffic on the transmit side. 1020 * 1021 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure. 1022 */ 1023 QDF_STATUS 1024 wmi_unified_set_sta_uapsd_auto_trig_cmd(void *wmi_hdl, 1025 struct sta_uapsd_trig_params *param) 1026 { 1027 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1028 1029 if (wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd) 1030 return wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd(wmi_handle, 1031 param); 1032 1033 return QDF_STATUS_E_FAILURE; 1034 } 1035 1036 1037 /** 1038 * wmi_unified_set_thermal_mgmt_cmd() - set thermal mgmt command to fw 1039 * @wmi_handle: Pointer to wmi handle 1040 * @thermal_info: Thermal command information 1041 * 1042 * This function sends the thermal management command 1043 * to the firmware 1044 * 1045 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1046 */ 1047 QDF_STATUS wmi_unified_set_thermal_mgmt_cmd(void *wmi_hdl, 1048 struct thermal_cmd_params *thermal_info) 1049 { 1050 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1051 1052 if (wmi_handle->ops->send_set_thermal_mgmt_cmd) 1053 return wmi_handle->ops->send_set_thermal_mgmt_cmd(wmi_handle, 1054 thermal_info); 1055 1056 return QDF_STATUS_E_FAILURE; 1057 } 1058 1059 1060 /** 1061 * wmi_unified_lro_config_cmd() - process the LRO config command 1062 * @wmi: Pointer to wmi handle 1063 * @wmi_lro_cmd: Pointer to LRO configuration parameters 1064 * 1065 * This function sends down the LRO configuration parameters to 1066 * the firmware to enable LRO, sets the TCP flags and sets the 1067 * seed values for the toeplitz hash generation 1068 * 1069 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1070 */ 1071 QDF_STATUS wmi_unified_lro_config_cmd(void *wmi_hdl, 1072 struct wmi_lro_config_cmd_t *wmi_lro_cmd) 1073 { 1074 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1075 1076 if (wmi_handle->ops->send_lro_config_cmd) 1077 return wmi_handle->ops->send_lro_config_cmd(wmi_handle, 1078 wmi_lro_cmd); 1079 1080 return QDF_STATUS_E_FAILURE; 1081 } 1082 1083 #ifdef CONFIG_MCL 1084 /** 1085 * wmi_unified_peer_rate_report_cmd() - process the peer rate report command 1086 * @wmi_hdl: Pointer to wmi handle 1087 * @rate_report_params: Pointer to peer rate report parameters 1088 * 1089 * 1090 * Return: QDF_STATUS_SUCCESS for success otherwise failure 1091 */ 1092 QDF_STATUS wmi_unified_peer_rate_report_cmd(void *wmi_hdl, 1093 struct wmi_peer_rate_report_params *rate_report_params) 1094 { 1095 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1096 1097 if (wmi_handle->ops->send_peer_rate_report_cmd) 1098 return wmi_handle->ops->send_peer_rate_report_cmd(wmi_handle, 1099 rate_report_params); 1100 1101 return QDF_STATUS_E_FAILURE; 1102 } 1103 #endif 1104 1105 /** 1106 * wmi_unified_process_update_edca_param() - update EDCA params 1107 * @wmi_hdl: wmi handle 1108 * @vdev_id: vdev id. 1109 * @mu_edca_param: mu_edca_param. 1110 * @wmm_vparams: edca parameters 1111 * 1112 * This function updates EDCA parameters to the target 1113 * 1114 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1115 */ 1116 QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl, 1117 uint8_t vdev_id, bool mu_edca_param, 1118 struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]) 1119 { 1120 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1121 1122 if (wmi_handle->ops->send_process_update_edca_param_cmd) 1123 return wmi_handle->ops->send_process_update_edca_param_cmd(wmi_handle, 1124 vdev_id, mu_edca_param, wmm_vparams); 1125 1126 return QDF_STATUS_E_FAILURE; 1127 } 1128 1129 /** 1130 * wmi_unified_probe_rsp_tmpl_send_cmd() - send probe response template to fw 1131 * @wmi_hdl: wmi handle 1132 * @vdev_id: vdev id 1133 * @probe_rsp_info: probe response info 1134 * 1135 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1136 */ 1137 QDF_STATUS wmi_unified_probe_rsp_tmpl_send_cmd(void *wmi_hdl, 1138 uint8_t vdev_id, 1139 struct wmi_probe_resp_params *probe_rsp_info) 1140 { 1141 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1142 1143 if (wmi_handle->ops->send_probe_rsp_tmpl_send_cmd) 1144 return wmi_handle->ops->send_probe_rsp_tmpl_send_cmd(wmi_handle, 1145 vdev_id, probe_rsp_info); 1146 1147 return QDF_STATUS_E_FAILURE; 1148 } 1149 1150 /** 1151 * wmi_unified_setup_install_key_cmd - send key to install to fw 1152 * @wmi_hdl: wmi handle 1153 * @key_params: key parameters 1154 * 1155 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1156 */ 1157 QDF_STATUS wmi_unified_setup_install_key_cmd(void *wmi_hdl, 1158 struct set_key_params *key_params) 1159 { 1160 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1161 1162 if (wmi_handle->ops->send_setup_install_key_cmd) 1163 return wmi_handle->ops->send_setup_install_key_cmd(wmi_handle, 1164 key_params); 1165 1166 return QDF_STATUS_E_FAILURE; 1167 } 1168 1169 /** 1170 * wmi_unified_p2p_go_set_beacon_ie_cmd() - set beacon IE for p2p go 1171 * @wma_handle: wma handle 1172 * @vdev_id: vdev id 1173 * @p2p_ie: p2p IE 1174 * 1175 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1176 */ 1177 QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(void *wmi_hdl, 1178 uint32_t vdev_id, uint8_t *p2p_ie) 1179 { 1180 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1181 1182 if (wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd) 1183 return wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd(wmi_handle, 1184 vdev_id, p2p_ie); 1185 1186 return QDF_STATUS_E_FAILURE; 1187 } 1188 1189 /** 1190 * wmi_unified_scan_probe_setoui_cmd() - set scan probe OUI 1191 * @wmi_hdl: wmi handle 1192 * @psetoui: OUI parameters 1193 * 1194 * set scan probe OUI parameters in firmware 1195 * 1196 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1197 */ 1198 QDF_STATUS wmi_unified_scan_probe_setoui_cmd(void *wmi_hdl, 1199 struct scan_mac_oui *psetoui) 1200 { 1201 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1202 1203 if (wmi_handle->ops->send_scan_probe_setoui_cmd) 1204 return wmi_handle->ops->send_scan_probe_setoui_cmd(wmi_handle, 1205 psetoui); 1206 1207 return QDF_STATUS_E_FAILURE; 1208 } 1209 1210 #ifdef IPA_OFFLOAD 1211 /** wmi_unified_ipa_offload_control_cmd() - ipa offload control parameter 1212 * @wmi_hdl: wmi handle 1213 * @ipa_offload: ipa offload control parameter 1214 * 1215 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures, 1216 * error number otherwise 1217 */ 1218 QDF_STATUS wmi_unified_ipa_offload_control_cmd(void *wmi_hdl, 1219 struct ipa_uc_offload_control_params *ipa_offload) 1220 { 1221 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1222 1223 if (!wmi_handle) 1224 return QDF_STATUS_E_FAILURE; 1225 1226 if (wmi_handle->ops->send_ipa_offload_control_cmd) 1227 return wmi_handle->ops->send_ipa_offload_control_cmd(wmi_handle, 1228 ipa_offload); 1229 1230 return QDF_STATUS_E_FAILURE; 1231 } 1232 #endif 1233 1234 /** 1235 * send_pno_stop_cmd() - PNO stop request 1236 * @wmi_hdl: wmi handle 1237 * @vdev_id: vdev id 1238 * 1239 * This function request FW to stop ongoing PNO operation. 1240 * 1241 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1242 */ 1243 QDF_STATUS wmi_unified_pno_stop_cmd(void *wmi_hdl, uint8_t vdev_id) 1244 { 1245 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1246 1247 if (wmi_handle->ops->send_pno_stop_cmd) 1248 return wmi_handle->ops->send_pno_stop_cmd(wmi_handle, 1249 vdev_id); 1250 1251 return QDF_STATUS_E_FAILURE; 1252 } 1253 1254 /** 1255 * wmi_unified_pno_start_cmd() - PNO start request 1256 * @wmi_hdl: wmi handle 1257 * @pno: PNO request 1258 * 1259 * This function request FW to start PNO request. 1260 * Request: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1261 */ 1262 #ifdef FEATURE_WLAN_SCAN_PNO 1263 QDF_STATUS wmi_unified_pno_start_cmd(void *wmi_hdl, 1264 struct pno_scan_req_params *pno) 1265 { 1266 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1267 1268 if (wmi_handle->ops->send_pno_start_cmd) 1269 return wmi_handle->ops->send_pno_start_cmd(wmi_handle, 1270 pno); 1271 1272 return QDF_STATUS_E_FAILURE; 1273 } 1274 #endif 1275 1276 /** 1277 * wmi_unified_nlo_mawc_cmd() - NLO MAWC cmd configuration 1278 * @wmi_hdl: wmi handle 1279 * @params: Configuration parameters 1280 * 1281 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1282 */ 1283 QDF_STATUS wmi_unified_nlo_mawc_cmd(void *wmi_hdl, 1284 struct nlo_mawc_params *params) 1285 { 1286 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1287 1288 if (wmi_handle->ops->send_nlo_mawc_cmd) 1289 return wmi_handle->ops->send_nlo_mawc_cmd(wmi_handle, params); 1290 1291 return QDF_STATUS_E_FAILURE; 1292 } 1293 1294 #ifdef WLAN_FEATURE_LINK_LAYER_STATS 1295 /** 1296 * wmi_unified_process_ll_stats_clear_cmd() - clear link layer stats 1297 * @wmi_hdl: wmi handle 1298 * @clear_req: ll stats clear request command params 1299 * @addr: mac address 1300 * 1301 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1302 */ 1303 QDF_STATUS wmi_unified_process_ll_stats_clear_cmd(void *wmi_hdl, 1304 const struct ll_stats_clear_params *clear_req, 1305 uint8_t addr[IEEE80211_ADDR_LEN]) 1306 { 1307 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1308 1309 if (wmi_handle->ops->send_process_ll_stats_clear_cmd) 1310 return wmi_handle->ops->send_process_ll_stats_clear_cmd(wmi_handle, 1311 clear_req, addr); 1312 1313 return QDF_STATUS_E_FAILURE; 1314 } 1315 1316 /** 1317 * wmi_unified_process_ll_stats_get_cmd() - link layer stats get request 1318 * @wmi_hdl:wmi handle 1319 * @get_req:ll stats get request command params 1320 * 1321 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1322 */ 1323 QDF_STATUS wmi_unified_process_ll_stats_get_cmd(void *wmi_hdl, 1324 const struct ll_stats_get_params *get_req, 1325 uint8_t addr[IEEE80211_ADDR_LEN]) 1326 { 1327 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1328 1329 if (wmi_handle->ops->send_process_ll_stats_get_cmd) 1330 return wmi_handle->ops->send_process_ll_stats_get_cmd(wmi_handle, 1331 get_req, addr); 1332 1333 return QDF_STATUS_E_FAILURE; 1334 } 1335 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */ 1336 1337 /** 1338 * wmi_unified_congestion_request_cmd() - send request to fw to get CCA 1339 * @wmi_hdl: wma handle 1340 * @vdev_id: vdev id 1341 * 1342 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1343 */ 1344 QDF_STATUS wmi_unified_congestion_request_cmd(void *wmi_hdl, 1345 uint8_t vdev_id) 1346 { 1347 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1348 1349 if (wmi_handle->ops->send_congestion_cmd) 1350 return wmi_handle->ops->send_congestion_cmd(wmi_handle, 1351 vdev_id); 1352 1353 return QDF_STATUS_E_FAILURE; 1354 } 1355 1356 #ifdef WLAN_FEATURE_LINK_LAYER_STATS 1357 /** 1358 * wmi_unified_process_ll_stats_set_cmd() - link layer stats set request 1359 * @wmi_handle: wmi handle 1360 * @set_req: ll stats set request command params 1361 * 1362 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1363 */ 1364 QDF_STATUS wmi_unified_process_ll_stats_set_cmd(void *wmi_hdl, 1365 const struct ll_stats_set_params *set_req) 1366 { 1367 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1368 1369 if (wmi_handle->ops->send_process_ll_stats_set_cmd) 1370 return wmi_handle->ops->send_process_ll_stats_set_cmd(wmi_handle, 1371 set_req); 1372 1373 return QDF_STATUS_E_FAILURE; 1374 } 1375 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */ 1376 1377 /** 1378 * wmi_unified_snr_request_cmd() - send request to fw to get RSSI stats 1379 * @wmi_handle: wmi handle 1380 * @rssi_req: get RSSI request 1381 * 1382 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1383 */ 1384 QDF_STATUS wmi_unified_snr_request_cmd(void *wmi_hdl) 1385 { 1386 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1387 1388 if (wmi_handle->ops->send_snr_request_cmd) 1389 return wmi_handle->ops->send_snr_request_cmd(wmi_handle); 1390 1391 return QDF_STATUS_E_FAILURE; 1392 } 1393 1394 /** 1395 * wmi_unified_snr_cmd() - get RSSI from fw 1396 * @wmi_handle: wmi handle 1397 * @vdev_id: vdev id 1398 * 1399 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1400 */ 1401 QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id) 1402 { 1403 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1404 1405 if (wmi_handle->ops->send_snr_cmd) 1406 return wmi_handle->ops->send_snr_cmd(wmi_handle, 1407 vdev_id); 1408 1409 return QDF_STATUS_E_FAILURE; 1410 } 1411 1412 /** 1413 * wmi_unified_link_status_req_cmd() - process link status request from UMAC 1414 * @wmi_handle: wmi handle 1415 * @params: get link status params 1416 * 1417 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1418 */ 1419 QDF_STATUS wmi_unified_link_status_req_cmd(wmi_unified_t wmi_handle, 1420 struct link_status_params *params) 1421 { 1422 if (wmi_handle->ops->send_link_status_req_cmd) 1423 return wmi_handle->ops->send_link_status_req_cmd(wmi_handle, 1424 params); 1425 1426 return QDF_STATUS_E_FAILURE; 1427 } 1428 1429 #ifdef WLAN_SUPPORT_GREEN_AP 1430 /** 1431 * wmi_unified_egap_conf_params_cmd() - send wmi cmd of egap configuration params 1432 * @wmi_handle: wmi handler 1433 * @egap_params: pointer to egap_params 1434 * 1435 * Return: 0 for success, otherwise appropriate error code 1436 */ 1437 QDF_STATUS wmi_unified_egap_conf_params_cmd(void *wmi_hdl, 1438 struct wlan_green_ap_egap_params *egap_params) 1439 { 1440 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1441 1442 if (wmi_handle->ops->send_egap_conf_params_cmd) 1443 return wmi_handle->ops->send_egap_conf_params_cmd(wmi_handle, 1444 egap_params); 1445 1446 return QDF_STATUS_E_FAILURE; 1447 } 1448 #endif 1449 1450 /** 1451 * wmi_unified_csa_offload_enable() - send CSA offload enable command 1452 * @wmi_hdl: wmi handle 1453 * @vdev_id: vdev id 1454 * 1455 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1456 */ 1457 QDF_STATUS wmi_unified_csa_offload_enable(void *wmi_hdl, uint8_t vdev_id) 1458 { 1459 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1460 1461 if (wmi_handle->ops->send_csa_offload_enable_cmd) 1462 return wmi_handle->ops->send_csa_offload_enable_cmd(wmi_handle, 1463 vdev_id); 1464 1465 return QDF_STATUS_E_FAILURE; 1466 } 1467 1468 #ifdef WLAN_FEATURE_CIF_CFR 1469 QDF_STATUS wmi_unified_oem_dma_ring_cfg(void *wmi_hdl, 1470 wmi_oem_dma_ring_cfg_req_fixed_param *cfg) 1471 { 1472 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1473 1474 if (wmi_handle->ops->send_start_oem_data_cmd) 1475 return wmi_handle->ops->send_oem_dma_cfg_cmd(wmi_handle, cfg); 1476 1477 return QDF_STATUS_E_FAILURE; 1478 } 1479 #endif 1480 1481 /** 1482 * wmi_unified_start_oem_data_cmd() - start OEM data request to target 1483 * @wmi_handle: wmi handle 1484 * @startOemDataReq: start request params 1485 * 1486 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1487 */ 1488 QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl, 1489 uint32_t data_len, 1490 uint8_t *data) 1491 { 1492 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1493 1494 if (wmi_handle->ops->send_start_oem_data_cmd) 1495 return wmi_handle->ops->send_start_oem_data_cmd(wmi_handle, 1496 data_len, data); 1497 1498 return QDF_STATUS_E_FAILURE; 1499 } 1500 1501 /** 1502 * wmi_unified_dfs_phyerr_filter_offload_en_cmd() - enable dfs phyerr filter 1503 * @wmi_handle: wmi handle 1504 * @dfs_phyerr_filter_offload: is dfs phyerr filter offload 1505 * 1506 * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or 1507 * WMI_DFS_PHYERR_FILTER_DIS_CMDID command 1508 * to firmware based on phyerr filtering 1509 * offload status. 1510 * 1511 * Return: 1 success, 0 failure 1512 */ 1513 QDF_STATUS 1514 wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl, 1515 bool dfs_phyerr_filter_offload) 1516 { 1517 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1518 1519 if (wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd) 1520 return wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd(wmi_handle, 1521 dfs_phyerr_filter_offload); 1522 1523 return QDF_STATUS_E_FAILURE; 1524 } 1525 1526 #if !defined(REMOVE_PKT_LOG) 1527 /** 1528 * wmi_unified_pktlog_wmi_send_cmd() - send pktlog enable/disable command to target 1529 * @wmi_handle: wmi handle 1530 * @pktlog_event: pktlog event 1531 * @cmd_id: pktlog cmd id 1532 * 1533 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1534 */ 1535 #ifdef CONFIG_MCL 1536 QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl, 1537 WMI_PKTLOG_EVENT pktlog_event, 1538 uint32_t cmd_id, 1539 uint8_t user_triggered) 1540 { 1541 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1542 1543 if (wmi_handle->ops->send_pktlog_wmi_send_cmd) 1544 return wmi_handle->ops->send_pktlog_wmi_send_cmd(wmi_handle, 1545 pktlog_event, cmd_id, user_triggered); 1546 1547 return QDF_STATUS_E_FAILURE; 1548 } 1549 #endif 1550 #endif /* REMOVE_PKT_LOG */ 1551 1552 /** 1553 * wmi_unified_stats_ext_req_cmd() - request ext stats from fw 1554 * @wmi_handle: wmi handle 1555 * @preq: stats ext params 1556 * 1557 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1558 */ 1559 QDF_STATUS wmi_unified_stats_ext_req_cmd(void *wmi_hdl, 1560 struct stats_ext_params *preq) 1561 { 1562 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1563 1564 if (wmi_handle->ops->send_stats_ext_req_cmd) 1565 return wmi_handle->ops->send_stats_ext_req_cmd(wmi_handle, 1566 preq); 1567 1568 return QDF_STATUS_E_FAILURE; 1569 } 1570 1571 /** 1572 * wmi_unified_process_dhcpserver_offload_cmd() - enable DHCP server offload 1573 * @wmi_handle: wmi handle 1574 * @pDhcpSrvOffloadInfo: DHCP server offload info 1575 * 1576 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1577 */ 1578 QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd(void *wmi_hdl, 1579 struct dhcp_offload_info_params *params) 1580 { 1581 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1582 1583 if (wmi_handle->ops->send_process_dhcpserver_offload_cmd) 1584 return wmi_handle->ops->send_process_dhcpserver_offload_cmd(wmi_handle, 1585 params); 1586 1587 return QDF_STATUS_E_FAILURE; 1588 } 1589 1590 /** 1591 * wmi_unified_send_regdomain_info_to_fw_cmd() - send regdomain info to fw 1592 * @wmi_handle: wmi handle 1593 * @reg_dmn: reg domain 1594 * @regdmn2G: 2G reg domain 1595 * @regdmn5G: 5G reg domain 1596 * @ctl2G: 2G test limit 1597 * @ctl5G: 5G test limit 1598 * 1599 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1600 */ 1601 QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(void *wmi_hdl, 1602 uint32_t reg_dmn, uint16_t regdmn2G, 1603 uint16_t regdmn5G, uint8_t ctl2G, 1604 uint8_t ctl5G) 1605 { 1606 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1607 1608 if (wmi_handle->ops->send_regdomain_info_to_fw_cmd) 1609 return wmi_handle->ops->send_regdomain_info_to_fw_cmd(wmi_handle, 1610 reg_dmn, regdmn2G, 1611 regdmn5G, ctl2G, 1612 ctl5G); 1613 1614 return QDF_STATUS_E_FAILURE; 1615 } 1616 1617 /** 1618 * wmi_unified_cfg_action_frm_tb_ppdu_cmd()-send action frame TB PPDU cfg to FW 1619 * @wmi_handle: Pointer to WMi handle 1620 * @cfg_info: Pointer to cfg msg 1621 * 1622 * This function sends action frame TB PPDU cfg to firmware 1623 * 1624 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1625 * 1626 */ 1627 QDF_STATUS 1628 wmi_unified_cfg_action_frm_tb_ppdu_cmd(void *wmi_hdl, 1629 struct cfg_action_frm_tb_ppdu_param 1630 *cfg_info) 1631 { 1632 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1633 1634 if (wmi_handle->ops->send_cfg_action_frm_tb_ppdu_cmd) 1635 return wmi_handle->ops->send_cfg_action_frm_tb_ppdu_cmd( 1636 wmi_handle, cfg_info); 1637 1638 return QDF_STATUS_E_FAILURE; 1639 } 1640 1641 /** 1642 * wmi_unified_save_fw_version_cmd() - save fw version 1643 * @wmi_handle: pointer to wmi handle 1644 * @res_cfg: resource config 1645 * @num_mem_chunks: no of mem chunck 1646 * @mem_chunk: pointer to mem chunck structure 1647 * 1648 * This function sends IE information to firmware 1649 * 1650 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1651 * 1652 */ 1653 QDF_STATUS wmi_unified_save_fw_version_cmd(void *wmi_hdl, 1654 void *evt_buf) 1655 { 1656 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1657 1658 if (wmi_handle->ops->save_fw_version_cmd) 1659 return wmi_handle->ops->save_fw_version_cmd(wmi_handle, 1660 evt_buf); 1661 1662 return QDF_STATUS_E_FAILURE; 1663 } 1664 1665 /** 1666 * wmi_unified_log_supported_evt_cmd() - Enable/Disable FW diag/log events 1667 * @wmi_hdl: wmi handle 1668 * @event: Event received from FW 1669 * @len: Length of the event 1670 * 1671 * Enables the low frequency events and disables the high frequency 1672 * events. Bit 17 indicates if the event if low/high frequency. 1673 * 1 - high frequency, 0 - low frequency 1674 * 1675 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures 1676 */ 1677 QDF_STATUS wmi_unified_log_supported_evt_cmd(void *wmi_hdl, 1678 uint8_t *event, 1679 uint32_t len) 1680 { 1681 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1682 1683 if (wmi_handle->ops->send_log_supported_evt_cmd) 1684 return wmi_handle->ops->send_log_supported_evt_cmd(wmi_handle, 1685 event, len); 1686 1687 return QDF_STATUS_E_FAILURE; 1688 } 1689 1690 void wmi_send_time_stamp_sync_cmd_tlv(void *wmi_hdl) 1691 { 1692 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1693 if (wmi_handle->ops->send_time_stamp_sync_cmd) 1694 wmi_handle->ops->send_time_stamp_sync_cmd(wmi_handle); 1695 1696 } 1697 /** 1698 * wmi_unified_enable_specific_fw_logs_cmd() - Start/Stop logging of diag log id 1699 * @wmi_hdl: wmi handle 1700 * @start_log: Start logging related parameters 1701 * 1702 * Send the command to the FW based on which specific logging of diag 1703 * event/log id can be started/stopped 1704 * 1705 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1706 */ 1707 QDF_STATUS wmi_unified_enable_specific_fw_logs_cmd(void *wmi_hdl, 1708 struct wmi_wifi_start_log *start_log) 1709 { 1710 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1711 1712 if (wmi_handle->ops->send_enable_specific_fw_logs_cmd) 1713 return wmi_handle->ops->send_enable_specific_fw_logs_cmd(wmi_handle, 1714 start_log); 1715 1716 return QDF_STATUS_E_FAILURE; 1717 } 1718 1719 /** 1720 * wmi_unified_flush_logs_to_fw_cmd() - Send log flush command to FW 1721 * @wmi_hdl: WMI handle 1722 * 1723 * This function is used to send the flush command to the FW, 1724 * that will flush the fw logs that are residue in the FW 1725 * 1726 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1727 */ 1728 QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(void *wmi_hdl) 1729 { 1730 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1731 1732 if (wmi_handle->ops->send_flush_logs_to_fw_cmd) 1733 return wmi_handle->ops->send_flush_logs_to_fw_cmd(wmi_handle); 1734 1735 return QDF_STATUS_E_FAILURE; 1736 } 1737 1738 /** 1739 * wmi_unified_fw_test_cmd() - send fw test command to fw. 1740 * @wmi_hdl: wmi handle 1741 * @wmi_fwtest: fw test command 1742 * 1743 * This function sends fw test command to fw. 1744 * 1745 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1746 */ 1747 QDF_STATUS wmi_unified_fw_test_cmd(void *wmi_hdl, 1748 struct set_fwtest_params *wmi_fwtest) 1749 { 1750 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1751 1752 if (wmi_handle->ops->send_fw_test_cmd) 1753 return wmi_handle->ops->send_fw_test_cmd(wmi_handle, 1754 wmi_fwtest); 1755 1756 return QDF_STATUS_E_FAILURE; 1757 1758 } 1759 1760 /** 1761 * wmi_unified_unit_test_cmd() - send unit test command to fw. 1762 * @wmi_hdl: wmi handle 1763 * @wmi_utest: unit test command 1764 * 1765 * This function send unit test command to fw. 1766 * 1767 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1768 */ 1769 QDF_STATUS wmi_unified_unit_test_cmd(void *wmi_hdl, 1770 struct wmi_unit_test_cmd *wmi_utest) 1771 { 1772 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1773 1774 if (wmi_handle->ops->send_unit_test_cmd) 1775 return wmi_handle->ops->send_unit_test_cmd(wmi_handle, 1776 wmi_utest); 1777 1778 return QDF_STATUS_E_FAILURE; 1779 } 1780 1781 #ifdef FEATURE_WLAN_APF 1782 QDF_STATUS 1783 wmi_unified_set_active_apf_mode_cmd(wmi_unified_t wmi, uint8_t vdev_id, 1784 enum wmi_host_active_apf_mode ucast_mode, 1785 enum wmi_host_active_apf_mode 1786 mcast_bcast_mode) 1787 { 1788 if (wmi->ops->send_set_active_apf_mode_cmd) 1789 return wmi->ops->send_set_active_apf_mode_cmd(wmi, vdev_id, 1790 ucast_mode, 1791 mcast_bcast_mode); 1792 return QDF_STATUS_E_FAILURE; 1793 } 1794 1795 QDF_STATUS 1796 wmi_unified_send_apf_enable_cmd(wmi_unified_t wmi, 1797 uint32_t vdev_id, bool enable) 1798 { 1799 if (wmi->ops->send_apf_enable_cmd) 1800 return wmi->ops->send_apf_enable_cmd(wmi, vdev_id, enable); 1801 return QDF_STATUS_E_FAILURE; 1802 } 1803 1804 QDF_STATUS 1805 wmi_unified_send_apf_write_work_memory_cmd(wmi_unified_t wmi, 1806 struct wmi_apf_write_memory_params 1807 *write_params) 1808 { 1809 if (wmi->ops->send_apf_write_work_memory_cmd) 1810 return wmi->ops->send_apf_write_work_memory_cmd(wmi, 1811 write_params); 1812 1813 return QDF_STATUS_E_FAILURE; 1814 } 1815 1816 QDF_STATUS 1817 wmi_unified_send_apf_read_work_memory_cmd(wmi_unified_t wmi, 1818 struct wmi_apf_read_memory_params 1819 *read_params) 1820 { 1821 if (wmi->ops->send_apf_read_work_memory_cmd) 1822 return wmi->ops->send_apf_read_work_memory_cmd(wmi, 1823 read_params); 1824 1825 return QDF_STATUS_E_FAILURE; 1826 } 1827 1828 QDF_STATUS 1829 wmi_extract_apf_read_memory_resp_event(wmi_unified_t wmi, void *evt_buf, 1830 struct wmi_apf_read_memory_resp_event_params 1831 *read_mem_evt) 1832 { 1833 if (wmi->ops->extract_apf_read_memory_resp_event) 1834 return wmi->ops->extract_apf_read_memory_resp_event(wmi, 1835 evt_buf, 1836 read_mem_evt); 1837 1838 return QDF_STATUS_E_FAILURE; 1839 } 1840 #endif /* FEATURE_WLAN_APF */ 1841 1842 /** 1843 * wmi_unified_pdev_fips_cmd_send() - WMI pdev fips cmd function 1844 * @param wmi_handle : handle to WMI. 1845 * @param param : pointer to hold pdev fips param 1846 * 1847 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1848 */ 1849 QDF_STATUS wmi_unified_pdev_fips_cmd_send(void *wmi_hdl, 1850 struct fips_params *param) 1851 { 1852 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1853 1854 if (wmi_handle->ops->send_pdev_fips_cmd) 1855 return wmi_handle->ops->send_pdev_fips_cmd(wmi_handle, param); 1856 1857 return QDF_STATUS_E_FAILURE; 1858 } 1859 1860 /** 1861 * wmi_unified_wlan_profile_enable_cmd_send() - WMI wlan profile enable cmd function 1862 * @param wmi_handle : handle to WMI. 1863 * @param param : pointer to hold wlan profile param 1864 * 1865 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1866 */ 1867 QDF_STATUS wmi_unified_wlan_profile_enable_cmd_send(void *wmi_hdl, 1868 struct wlan_profile_params *param) 1869 { 1870 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1871 1872 if (wmi_handle->ops->send_wlan_profile_enable_cmd) 1873 return wmi_handle->ops->send_wlan_profile_enable_cmd(wmi_handle, 1874 param); 1875 1876 return QDF_STATUS_E_FAILURE; 1877 } 1878 1879 /** 1880 * wmi_unified_wlan_profile_trigger_cmd_send() - WMI wlan profile trigger cmd function 1881 * @param wmi_handle : handle to WMI. 1882 * @param param : pointer to hold wlan profile param 1883 * 1884 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1885 */ 1886 QDF_STATUS wmi_unified_wlan_profile_trigger_cmd_send(void *wmi_hdl, 1887 struct wlan_profile_params *param) 1888 { 1889 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 1890 1891 if (wmi->ops->send_wlan_profile_trigger_cmd) 1892 return wmi->ops->send_wlan_profile_trigger_cmd(wmi, 1893 param); 1894 1895 return QDF_STATUS_E_FAILURE; 1896 } 1897 1898 /** 1899 * wmi_unified_set_chan_cmd_send() - WMI set channel cmd function 1900 * @param wmi_handle : handle to WMI. 1901 * @param param : pointer to hold channel param 1902 * 1903 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1904 */ 1905 QDF_STATUS wmi_unified_set_chan_cmd_send(void *wmi_hdl, 1906 struct channel_param *param) 1907 { 1908 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1909 1910 if (wmi_handle->ops->send_pdev_set_chan_cmd) 1911 return wmi_handle->ops->send_pdev_set_chan_cmd(wmi_handle, 1912 param); 1913 1914 return QDF_STATUS_E_FAILURE; 1915 } 1916 1917 /** 1918 * wmi_unified_set_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 1919 * @param wmi_handle : handle to WMI. 1920 * @param param : pointer to hold ratepwr table param 1921 * 1922 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1923 */ 1924 QDF_STATUS wmi_unified_set_ratepwr_table_cmd_send(void *wmi_hdl, 1925 struct ratepwr_table_params *param) 1926 { 1927 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1928 1929 if (wmi_handle->ops->send_set_ratepwr_table_cmd) 1930 return wmi_handle->ops->send_set_ratepwr_table_cmd(wmi_handle, 1931 param); 1932 1933 return QDF_STATUS_E_FAILURE; 1934 } 1935 1936 /** 1937 * wmi_unified_get_ratepwr_table_cmd_send() - WMI ratepwr table cmd function 1938 * @param wmi_handle : handle to WMI. 1939 * 1940 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1941 */ 1942 QDF_STATUS wmi_unified_get_ratepwr_table_cmd_send(void *wmi_hdl) 1943 { 1944 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1945 1946 if (wmi_handle->ops->send_get_ratepwr_table_cmd) 1947 return wmi_handle->ops->send_get_ratepwr_table_cmd(wmi_handle); 1948 1949 return QDF_STATUS_E_FAILURE; 1950 } 1951 1952 /** 1953 * wmi_unified_set_ratepwr_chainmsk_cmd_send() - WMI ratepwr 1954 * chainmsk cmd function 1955 * @param wmi_handle : handle to WMI. 1956 * @param param : pointer to hold ratepwr chainmsk param 1957 * 1958 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1959 */ 1960 QDF_STATUS wmi_unified_set_ratepwr_chainmsk_cmd_send(void *wmi_hdl, 1961 struct ratepwr_chainmsk_params *param) 1962 { 1963 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 1964 1965 if (wmi->ops->send_set_ratepwr_chainmsk_cmd) 1966 return wmi->ops->send_set_ratepwr_chainmsk_cmd(wmi, param); 1967 1968 return QDF_STATUS_E_FAILURE; 1969 } 1970 1971 /** 1972 * wmi_unified_set_macaddr_cmd_send() - WMI set macaddr cmd function 1973 * @param wmi_handle : handle to WMI. 1974 * @param param : pointer to hold macaddr param 1975 * 1976 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1977 */ 1978 QDF_STATUS wmi_unified_set_macaddr_cmd_send(void *wmi_hdl, 1979 struct macaddr_params *param) 1980 { 1981 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1982 1983 if (wmi_handle->ops->send_set_macaddr_cmd) 1984 return wmi_handle->ops->send_set_macaddr_cmd(wmi_handle, param); 1985 1986 return QDF_STATUS_E_FAILURE; 1987 } 1988 1989 /** 1990 * wmi_unified_pdev_scan_start_cmd_send() - WMI pdev scan start cmd function 1991 * @param wmi_handle : handle to WMI. 1992 * 1993 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 1994 */ 1995 QDF_STATUS wmi_unified_pdev_scan_start_cmd_send(void *wmi_hdl) 1996 { 1997 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 1998 1999 if (wmi_handle->ops->send_pdev_scan_start_cmd) 2000 return wmi_handle->ops->send_pdev_scan_start_cmd(wmi_handle); 2001 2002 return QDF_STATUS_E_FAILURE; 2003 } 2004 2005 /** 2006 * wmi_unified_pdev_scan_end_cmd_send() - WMI pdev scan end cmd function 2007 * @param wmi_handle : handle to WMI. 2008 * 2009 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2010 */ 2011 QDF_STATUS wmi_unified_pdev_scan_end_cmd_send(void *wmi_hdl) 2012 { 2013 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2014 2015 if (wmi_handle->ops->send_pdev_scan_end_cmd) 2016 return wmi_handle->ops->send_pdev_scan_end_cmd(wmi_handle); 2017 2018 return QDF_STATUS_E_FAILURE; 2019 } 2020 2021 /** 2022 * wmi_unified_set_acparams_cmd_send() - WMI set acparams cmd function 2023 * @param wmi_handle : handle to WMI. 2024 * @param param : pointer to hold acparams param 2025 * 2026 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2027 */ 2028 QDF_STATUS wmi_unified_set_acparams_cmd_send(void *wmi_hdl, 2029 struct acparams_params *param) 2030 { 2031 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2032 2033 if (wmi_handle->ops->send_set_acparams_cmd) 2034 return wmi_handle->ops->send_set_acparams_cmd(wmi_handle, 2035 param); 2036 2037 return QDF_STATUS_E_FAILURE; 2038 } 2039 2040 /** 2041 * wmi_unified_set_vap_dscp_tid_map_cmd_send() - WMI set vap dscp 2042 * tid map cmd function 2043 * @param wmi_handle : handle to WMI. 2044 * @param param : pointer to hold dscp param 2045 * 2046 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2047 */ 2048 QDF_STATUS wmi_unified_set_vap_dscp_tid_map_cmd_send(void *wmi_hdl, 2049 struct vap_dscp_tid_map_params *param) 2050 { 2051 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2052 2053 if (wmi->ops->send_set_vap_dscp_tid_map_cmd) 2054 return wmi->ops->send_set_vap_dscp_tid_map_cmd(wmi, param); 2055 2056 return QDF_STATUS_E_FAILURE; 2057 } 2058 2059 /** 2060 * wmi_unified_proxy_ast_reserve_cmd_send() - WMI proxy ast 2061 * reserve cmd function 2062 * @param wmi_handle : handle to WMI. 2063 * @param param : pointer to hold ast param 2064 * 2065 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2066 */ 2067 QDF_STATUS wmi_unified_proxy_ast_reserve_cmd_send(void *wmi_hdl, 2068 struct proxy_ast_reserve_params *param) 2069 { 2070 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2071 2072 if (wmi_handle->ops->send_proxy_ast_reserve_cmd) 2073 return wmi_handle->ops->send_proxy_ast_reserve_cmd(wmi_handle, 2074 param); 2075 2076 return QDF_STATUS_E_FAILURE; 2077 } 2078 2079 /** 2080 * wmi_unified_set_bridge_mac_addr_cmd_send() - WMI set bridge mac addr cmd function 2081 * @param wmi_hdl : handle to WMI. 2082 * @param param : pointer to hold bridge mac addr param 2083 * 2084 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2085 */ 2086 QDF_STATUS wmi_unified_set_bridge_mac_addr_cmd_send(void *wmi_hdl, 2087 struct set_bridge_mac_addr_params *param) 2088 { 2089 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2090 2091 if (wmi_handle->ops->send_set_bridge_mac_addr_cmd) 2092 return wmi_handle->ops->send_set_bridge_mac_addr_cmd(wmi_handle, 2093 param); 2094 2095 return QDF_STATUS_E_FAILURE; 2096 } 2097 2098 /** 2099 * wmi_unified_phyerr_enable_cmd_send() - WMI phyerr enable cmd function 2100 * @param wmi_handle : handle to WMI. 2101 * @param param : pointer to hold phyerr enable param 2102 * 2103 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2104 */ 2105 QDF_STATUS wmi_unified_phyerr_enable_cmd_send(void *wmi_hdl) 2106 { 2107 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2108 2109 if (wmi_handle->ops->send_phyerr_enable_cmd) 2110 return wmi_handle->ops->send_phyerr_enable_cmd(wmi_handle); 2111 2112 return QDF_STATUS_E_FAILURE; 2113 } 2114 2115 /** 2116 * wmi_unified_phyerr_disable_cmd_send() - WMI phyerr disable cmd function 2117 * @param wmi_handle : handle to WMI. 2118 * @param param : pointer to hold phyerr disable param 2119 * 2120 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2121 */ 2122 QDF_STATUS wmi_unified_phyerr_disable_cmd_send(void *wmi_hdl) 2123 { 2124 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2125 2126 if (wmi_handle->ops->send_phyerr_disable_cmd) 2127 return wmi_handle->ops->send_phyerr_disable_cmd(wmi_handle); 2128 2129 return QDF_STATUS_E_FAILURE; 2130 } 2131 2132 /** 2133 * wmi_unified_smart_ant_enable_tx_feedback_cmd_send() - WMI set tx antenna function 2134 * @param wmi_handle : handle to WMI. 2135 * @param param : pointer to hold antenna param 2136 * 2137 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2138 */ 2139 QDF_STATUS wmi_unified_smart_ant_enable_tx_feedback_cmd_send(void *wmi_hdl, 2140 struct smart_ant_enable_tx_feedback_params *param) 2141 { 2142 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2143 2144 if (wmi->ops->send_smart_ant_enable_tx_feedback_cmd) 2145 return wmi->ops->send_smart_ant_enable_tx_feedback_cmd(wmi, 2146 param); 2147 2148 return QDF_STATUS_E_FAILURE; 2149 } 2150 qdf_export_symbol(wmi_unified_smart_ant_enable_tx_feedback_cmd_send); 2151 2152 /** 2153 * wmi_unified_vdev_spectral_configure_cmd_send() - WMI set spectral config function 2154 * @param wmi_handle : handle to WMI. 2155 * @param param : pointer to hold spectral config param 2156 * 2157 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2158 */ 2159 QDF_STATUS wmi_unified_vdev_spectral_configure_cmd_send(void *wmi_hdl, 2160 struct vdev_spectral_configure_params *param) 2161 { 2162 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2163 2164 if (wmi->ops->send_vdev_spectral_configure_cmd) 2165 return wmi->ops->send_vdev_spectral_configure_cmd(wmi, param); 2166 2167 return QDF_STATUS_E_FAILURE; 2168 } 2169 2170 /** 2171 * wmi_unified_vdev_spectral_enable_cmd_send() - WMI enable spectral function 2172 * @param wmi_handle : handle to WMI. 2173 * @param param : pointer to hold enable spectral param 2174 * 2175 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2176 */ 2177 QDF_STATUS wmi_unified_vdev_spectral_enable_cmd_send(void *wmi_hdl, 2178 struct vdev_spectral_enable_params *param) 2179 { 2180 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2181 2182 if (wmi->ops->send_vdev_spectral_enable_cmd) 2183 return wmi->ops->send_vdev_spectral_enable_cmd(wmi, param); 2184 2185 return QDF_STATUS_E_FAILURE; 2186 } 2187 2188 /** 2189 * wmi_unified_bss_chan_info_request_cmd_send() - WMI bss chan info request function 2190 * @param wmi_handle : handle to WMI. 2191 * @param param : pointer to hold chan info param 2192 * 2193 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2194 */ 2195 QDF_STATUS wmi_unified_bss_chan_info_request_cmd_send(void *wmi_hdl, 2196 struct bss_chan_info_request_params *param) 2197 { 2198 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2199 2200 if (wmi->ops->send_bss_chan_info_request_cmd) 2201 return wmi->ops->send_bss_chan_info_request_cmd(wmi, param); 2202 2203 return QDF_STATUS_E_FAILURE; 2204 } 2205 2206 /** 2207 * wmi_unified_thermal_mitigation_param_cmd_send() - WMI thermal mitigation function 2208 * @param wmi_handle : handle to WMI. 2209 * @param param : pointer to hold thermal mitigation param 2210 * 2211 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2212 */ 2213 QDF_STATUS wmi_unified_thermal_mitigation_param_cmd_send(void *wmi_hdl, 2214 struct thermal_mitigation_params *param) 2215 { 2216 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2217 2218 if (wmi->ops->send_thermal_mitigation_param_cmd) 2219 return wmi->ops->send_thermal_mitigation_param_cmd(wmi, param); 2220 2221 return QDF_STATUS_E_FAILURE; 2222 } 2223 2224 /** 2225 * wmi_unified_vdev_set_fwtest_param_cmd_send() - WMI set fwtest function 2226 * @param wmi_handle : handle to WMI. 2227 * @param param : pointer to hold fwtest param 2228 * 2229 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2230 */ 2231 QDF_STATUS wmi_unified_vdev_set_fwtest_param_cmd_send(void *wmi_hdl, 2232 struct set_fwtest_params *param) 2233 { 2234 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2235 2236 if (wmi->ops->send_vdev_set_fwtest_param_cmd) 2237 return wmi->ops->send_vdev_set_fwtest_param_cmd(wmi, param); 2238 2239 return QDF_STATUS_E_FAILURE; 2240 } 2241 2242 /** 2243 * wmi_unified_vdev_set_custom_aggr_size_cmd_send() - WMI set custom aggr 2244 * size function 2245 * @param wmi_handle : handle to WMI 2246 * @param param : pointer to hold custom aggr size param 2247 * 2248 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_R_FAILURE for failure 2249 */ 2250 QDF_STATUS wmi_unified_vdev_set_custom_aggr_size_cmd_send(void *wmi_hdl, 2251 struct set_custom_aggr_size_params *param) 2252 { 2253 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 2254 2255 if (wmi->ops->send_vdev_set_custom_aggr_size_cmd) 2256 return wmi->ops->send_vdev_set_custom_aggr_size_cmd(wmi, param); 2257 2258 return QDF_STATUS_E_FAILURE; 2259 } 2260 2261 /** 2262 * wmi_unified_vdev_set_qdepth_thresh_cmd_send() - WMI set qdepth threshold 2263 * @param wmi_handle : handle to WMI 2264 * @param param : pointer to hold qdepth threshold params 2265 * 2266 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_R_FAILURE for failure 2267 */ 2268 QDF_STATUS wmi_unified_vdev_set_qdepth_thresh_cmd_send(void *wmi_hdl, 2269 struct set_qdepth_thresh_params *param) 2270 { 2271 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 2272 2273 if (wmi->ops->send_vdev_set_qdepth_thresh_cmd) 2274 return wmi->ops->send_vdev_set_qdepth_thresh_cmd(wmi, param); 2275 2276 return QDF_STATUS_E_FAILURE; 2277 } 2278 2279 /** 2280 * wmi_unified_pdev_set_regdomain_params_cmd_send() - WMI set regdomain function 2281 * @param wmi_handle : handle to WMI. 2282 * @param param : pointer to hold regdomain param 2283 * 2284 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2285 */ 2286 QDF_STATUS wmi_unified_pdev_set_regdomain_cmd_send(void *wmi_hdl, 2287 struct pdev_set_regdomain_params *param) 2288 { 2289 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2290 2291 if (wmi_handle->ops->send_pdev_set_regdomain_cmd) 2292 return wmi_handle->ops->send_pdev_set_regdomain_cmd(wmi_handle, 2293 param); 2294 2295 return QDF_STATUS_E_FAILURE; 2296 } 2297 2298 /** 2299 * wmi_unified_set_beacon_filter_cmd_send() - WMI set beacon filter function 2300 * @param wmi_handle : handle to WMI. 2301 * @param param : pointer to hold beacon filter param 2302 * 2303 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2304 */ 2305 QDF_STATUS wmi_unified_set_beacon_filter_cmd_send(void *wmi_hdl, 2306 struct set_beacon_filter_params *param) 2307 { 2308 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2309 2310 if (wmi_handle->ops->send_set_beacon_filter_cmd) 2311 return wmi_handle->ops->send_set_beacon_filter_cmd(wmi_handle, 2312 param); 2313 2314 return QDF_STATUS_E_FAILURE; 2315 } 2316 2317 /** 2318 * wmi_unified_remove_beacon_filter_cmd_send() - WMI set beacon filter function 2319 * @param wmi_handle : handle to WMI. 2320 * @param param : pointer to hold beacon filter param 2321 * 2322 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2323 */ 2324 QDF_STATUS wmi_unified_remove_beacon_filter_cmd_send(void *wmi_hdl, 2325 struct remove_beacon_filter_params *param) 2326 { 2327 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2328 2329 if (wmi->ops->send_remove_beacon_filter_cmd) 2330 return wmi->ops->send_remove_beacon_filter_cmd(wmi, param); 2331 2332 return QDF_STATUS_E_FAILURE; 2333 } 2334 2335 /** 2336 * wmi_unified_mgmt_cmd_send() - WMI mgmt cmd function 2337 * @param wmi_handle : handle to WMI. 2338 * @param macaddr : MAC address 2339 * @param param : pointer to hold mgmt parameter 2340 * 2341 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2342 */ 2343 #if 0 2344 QDF_STATUS wmi_unified_mgmt_cmd_send(void *wmi_hdl, 2345 uint8_t macaddr[IEEE80211_ADDR_LEN], 2346 struct mgmt_params *param) 2347 { 2348 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2349 2350 if (wmi_handle->ops->send_mgmt_cmd) 2351 return wmi_handle->ops->send_mgmt_cmd(wmi_handle, 2352 macaddr, param); 2353 2354 return QDF_STATUS_E_FAILURE; 2355 } 2356 #endif 2357 2358 /** 2359 * wmi_unified_addba_clearresponse_cmd_send() - WMI addba resp cmd function 2360 * @param wmi_handle : handle to WMI. 2361 * @param macaddr : MAC address 2362 * @param param : pointer to hold addba resp parameter 2363 * 2364 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2365 */ 2366 QDF_STATUS wmi_unified_addba_clearresponse_cmd_send(void *wmi_hdl, 2367 uint8_t macaddr[IEEE80211_ADDR_LEN], 2368 struct addba_clearresponse_params *param) 2369 { 2370 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2371 2372 if (wmi_handle->ops->send_addba_clearresponse_cmd) 2373 return wmi_handle->ops->send_addba_clearresponse_cmd(wmi_handle, 2374 macaddr, param); 2375 2376 return QDF_STATUS_E_FAILURE; 2377 } 2378 2379 /** 2380 * wmi_unified_addba_send_cmd_send() - WMI addba send function 2381 * @param wmi_handle : handle to WMI. 2382 * @param macaddr : MAC address 2383 * @param param : pointer to hold addba parameter 2384 * 2385 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2386 */ 2387 QDF_STATUS wmi_unified_addba_send_cmd_send(void *wmi_hdl, 2388 uint8_t macaddr[IEEE80211_ADDR_LEN], 2389 struct addba_send_params *param) 2390 { 2391 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2392 2393 if (wmi_handle->ops->send_addba_send_cmd) 2394 return wmi_handle->ops->send_addba_send_cmd(wmi_handle, 2395 macaddr, param); 2396 2397 return QDF_STATUS_E_FAILURE; 2398 } 2399 2400 /** 2401 * wmi_unified_delba_send_cmd_send() - WMI delba cmd function 2402 * @param wmi_handle : handle to WMI. 2403 * @param macaddr : MAC address 2404 * @param param : pointer to hold delba parameter 2405 * 2406 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2407 */ 2408 QDF_STATUS wmi_unified_delba_send_cmd_send(void *wmi_hdl, 2409 uint8_t macaddr[IEEE80211_ADDR_LEN], 2410 struct delba_send_params *param) 2411 { 2412 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2413 2414 if (wmi_handle->ops->send_delba_send_cmd) 2415 return wmi_handle->ops->send_delba_send_cmd(wmi_handle, 2416 macaddr, param); 2417 2418 return QDF_STATUS_E_FAILURE; 2419 } 2420 2421 /** 2422 * wmi_unified_addba_setresponse_cmd_send() - WMI addba set resp cmd function 2423 * @param wmi_handle : handle to WMI. 2424 * @param macaddr : MAC address 2425 * @param param : pointer to hold addba set resp parameter 2426 * 2427 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2428 */ 2429 QDF_STATUS wmi_unified_addba_setresponse_cmd_send(void *wmi_hdl, 2430 uint8_t macaddr[IEEE80211_ADDR_LEN], 2431 struct addba_setresponse_params *param) 2432 { 2433 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2434 2435 if (wmi_handle->ops->send_addba_setresponse_cmd) 2436 return wmi_handle->ops->send_addba_setresponse_cmd(wmi_handle, 2437 macaddr, param); 2438 2439 return QDF_STATUS_E_FAILURE; 2440 } 2441 2442 /** 2443 * wmi_unified_singleamsdu_cmd_send() - WMI singleamsdu function 2444 * @param wmi_handle : handle to WMI. 2445 * @param macaddr : MAC address 2446 * @param param : pointer to hold singleamsdu parameter 2447 * 2448 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2449 */ 2450 QDF_STATUS wmi_unified_singleamsdu_cmd_send(void *wmi_hdl, 2451 uint8_t macaddr[IEEE80211_ADDR_LEN], 2452 struct singleamsdu_params *param) 2453 { 2454 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2455 2456 if (wmi_handle->ops->send_singleamsdu_cmd) 2457 return wmi_handle->ops->send_singleamsdu_cmd(wmi_handle, 2458 macaddr, param); 2459 2460 return QDF_STATUS_E_FAILURE; 2461 } 2462 2463 /** 2464 * wmi_unified_mu_scan_cmd_send() - WMI set mu scan function 2465 * @param wmi_handle : handle to WMI. 2466 * @param param : pointer to hold mu scan param 2467 * 2468 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2469 */ 2470 QDF_STATUS wmi_unified_mu_scan_cmd_send(void *wmi_hdl, 2471 struct mu_scan_params *param) 2472 { 2473 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2474 2475 if (wmi_handle->ops->send_mu_scan_cmd) 2476 return wmi_handle->ops->send_mu_scan_cmd(wmi_handle, param); 2477 2478 return QDF_STATUS_E_FAILURE; 2479 } 2480 2481 /** 2482 * wmi_unified_lteu_config_cmd_send() - WMI set mu scan function 2483 * @param wmi_handle : handle to WMI. 2484 * @param param : pointer to hold mu scan param 2485 * 2486 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2487 */ 2488 QDF_STATUS wmi_unified_lteu_config_cmd_send(void *wmi_hdl, 2489 struct lteu_config_params *param) 2490 { 2491 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2492 2493 if (wmi_handle->ops->send_lteu_config_cmd) 2494 return wmi_handle->ops->send_lteu_config_cmd(wmi_handle, param); 2495 2496 return QDF_STATUS_E_FAILURE; 2497 } 2498 2499 /** 2500 * wmi_unified_set_psmode_cmd_send() - WMI set mu scan function 2501 * @param wmi_handle : handle to WMI. 2502 * @param param : pointer to hold mu scan param 2503 * 2504 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2505 */ 2506 QDF_STATUS wmi_unified_set_psmode_cmd_send(void *wmi_hdl, 2507 struct set_ps_mode_params *param) 2508 { 2509 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2510 2511 if (wmi_handle->ops->send_set_ps_mode_cmd) 2512 return wmi_handle->ops->send_set_ps_mode_cmd(wmi_handle, param); 2513 2514 return QDF_STATUS_E_FAILURE; 2515 } 2516 2517 /** 2518 * wmi_unified_init_cmd_send() - send initialization cmd to fw 2519 * @wmi_handle: wmi handle 2520 * @param param: pointer to wmi init param 2521 * 2522 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2523 */ 2524 QDF_STATUS wmi_unified_init_cmd_send(void *wmi_hdl, 2525 struct wmi_init_cmd_param *param) 2526 { 2527 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2528 2529 if (wmi_handle->ops->init_cmd_send) 2530 return wmi_handle->ops->init_cmd_send(wmi_handle, param); 2531 2532 return QDF_STATUS_E_FAILURE; 2533 } 2534 2535 /** 2536 * wmi_save_service_bitmap() - save service bitmap 2537 * @wmi_handle: wmi handle 2538 * @param evt_buf: pointer to event buffer 2539 * 2540 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2541 */ 2542 QDF_STATUS wmi_save_service_bitmap(void *wmi_hdl, void *evt_buf, 2543 void *bitmap_buf) 2544 { 2545 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 2546 2547 if (wmi_handle->ops->save_service_bitmap) { 2548 return wmi_handle->ops->save_service_bitmap(wmi_handle, evt_buf, 2549 bitmap_buf); 2550 } 2551 return QDF_STATUS_E_FAILURE; 2552 } 2553 2554 /** 2555 * wmi_save_ext_service_bitmap() - save extended service bitmap 2556 * @wmi_handle: wmi handle 2557 * @param evt_buf: pointer to event buffer 2558 * 2559 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2560 */ 2561 QDF_STATUS wmi_save_ext_service_bitmap(void *wmi_hdl, void *evt_buf, 2562 void *bitmap_buf) 2563 { 2564 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 2565 2566 if (wmi_handle->ops->save_ext_service_bitmap) { 2567 return wmi_handle->ops->save_ext_service_bitmap(wmi_handle, 2568 evt_buf, bitmap_buf); 2569 } 2570 return QDF_STATUS_E_FAILURE; 2571 } 2572 2573 /** 2574 * wmi_save_fw_version() - Save fw version 2575 * @wmi_handle: wmi handle 2576 * @param evt_buf: pointer to event buffer 2577 * 2578 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2579 */ 2580 QDF_STATUS wmi_save_fw_version(void *wmi_hdl, void *evt_buf) 2581 { 2582 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 2583 2584 if (wmi_handle->ops->save_fw_version) { 2585 wmi_handle->ops->save_fw_version(wmi_handle, evt_buf); 2586 return 0; 2587 } 2588 return QDF_STATUS_E_FAILURE; 2589 } 2590 2591 /** 2592 * wmi_check_and_update_fw_version() - Ready and fw version check 2593 * @wmi_handle: wmi handle 2594 * @param evt_buf: pointer to event buffer 2595 * 2596 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2597 */ 2598 QDF_STATUS wmi_check_and_update_fw_version(void *wmi_hdl, void *evt_buf) 2599 { 2600 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl; 2601 2602 if (wmi_handle->ops->check_and_update_fw_version) 2603 return wmi_handle->ops->check_and_update_fw_version(wmi_handle, 2604 evt_buf); 2605 2606 return QDF_STATUS_E_FAILURE; 2607 } 2608 2609 /** 2610 * wmi_service_enabled() - Check if service enabled 2611 * @param wmi_handle: wmi handle 2612 * @param service_id: service identifier 2613 * 2614 * Return: 1 enabled, 0 disabled 2615 */ 2616 bool wmi_service_enabled(void *wmi_hdl, uint32_t service_id) 2617 { 2618 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2619 2620 if ((service_id < wmi_services_max) && 2621 (wmi_handle->services[service_id] != WMI_SERVICE_UNAVAILABLE)) { 2622 if (wmi_handle->ops->is_service_enabled) { 2623 return wmi_handle->ops->is_service_enabled(wmi_handle, 2624 wmi_handle->services[service_id]); 2625 } 2626 } else { 2627 WMI_LOGI("Service %d not supported", service_id); 2628 } 2629 2630 return false; 2631 } 2632 2633 /** 2634 * wmi_get_target_cap_from_service_ready() - extract service ready event 2635 * @wmi_handle: wmi handle 2636 * @param evt_buf: pointer to received event buffer 2637 * @param ev: pointer to hold target capability information extracted from even 2638 * 2639 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2640 */ 2641 QDF_STATUS wmi_get_target_cap_from_service_ready(void *wmi_hdl, 2642 void *evt_buf, struct wlan_psoc_target_capability_info *ev) 2643 { 2644 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2645 2646 if (wmi->ops->get_target_cap_from_service_ready) 2647 return wmi->ops->get_target_cap_from_service_ready(wmi, 2648 evt_buf, ev); 2649 2650 return QDF_STATUS_E_FAILURE; 2651 } 2652 2653 /** 2654 * wmi_extract_fw_version() - extract fw version 2655 * @wmi_handle: wmi handle 2656 * @param evt_buf: pointer to event buffer 2657 * @param fw_ver: Pointer to hold fw version 2658 * 2659 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2660 */ 2661 QDF_STATUS wmi_extract_fw_version(void *wmi_hdl, 2662 void *evt_buf, struct wmi_host_fw_ver *fw_ver) 2663 { 2664 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2665 2666 if (wmi_handle->ops->extract_fw_version) 2667 return wmi_handle->ops->extract_fw_version(wmi_handle, 2668 evt_buf, fw_ver); 2669 2670 return QDF_STATUS_E_FAILURE; 2671 } 2672 2673 /** 2674 * wmi_extract_fw_abi_version() - extract fw abi version 2675 * @wmi_handle: wmi handle 2676 * @param evt_buf: Pointer to event buffer 2677 * @param fw_ver: Pointer to hold fw abi version 2678 * 2679 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2680 */ 2681 QDF_STATUS wmi_extract_fw_abi_version(void *wmi_hdl, 2682 void *evt_buf, struct wmi_host_fw_abi_ver *fw_ver) 2683 { 2684 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2685 2686 if (wmi_handle->ops->extract_fw_abi_version) 2687 return wmi_handle->ops->extract_fw_abi_version(wmi_handle, 2688 evt_buf, fw_ver); 2689 2690 return QDF_STATUS_E_FAILURE; 2691 } 2692 2693 /** 2694 * wmi_extract_hal_reg_cap() - extract HAL registered capabilities 2695 * @wmi_handle: wmi handle 2696 * @param evt_buf: Pointer to event buffer 2697 * @param hal_reg_cap: pointer to hold HAL reg capabilities 2698 * 2699 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2700 */ 2701 QDF_STATUS wmi_extract_hal_reg_cap(void *wmi_hdl, void *evt_buf, 2702 struct wlan_psoc_hal_reg_capability *hal_reg_cap) 2703 { 2704 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2705 2706 if (wmi_handle->ops->extract_hal_reg_cap) 2707 return wmi_handle->ops->extract_hal_reg_cap(wmi_handle, 2708 evt_buf, hal_reg_cap); 2709 2710 return QDF_STATUS_E_FAILURE; 2711 } 2712 2713 /** 2714 * wmi_extract_host_mem_req_from_service_ready() - Extract host memory 2715 * request event 2716 * @wmi_handle: wmi handle 2717 * @param evt_buf: pointer to event buffer 2718 * @param num_entries: pointer to hold number of entries requested 2719 * 2720 * Return: Number of entries requested 2721 */ 2722 host_mem_req *wmi_extract_host_mem_req_from_service_ready(void *wmi_hdl, 2723 void *evt_buf, uint8_t *num_entries) 2724 { 2725 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2726 2727 if (wmi_handle->ops->extract_host_mem_req) 2728 return wmi_handle->ops->extract_host_mem_req(wmi_handle, 2729 evt_buf, num_entries); 2730 2731 *num_entries = 0; 2732 return NULL; 2733 } 2734 2735 /** 2736 * wmi_ready_extract_init_status() - Extract init status from ready event 2737 * @wmi_handle: wmi handle 2738 * @param ev: Pointer to event buffer 2739 * 2740 * Return: ready status 2741 */ 2742 uint32_t wmi_ready_extract_init_status(void *wmi_hdl, void *ev) 2743 { 2744 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2745 2746 if (wmi_handle->ops->ready_extract_init_status) 2747 return wmi_handle->ops->ready_extract_init_status(wmi_handle, 2748 ev); 2749 2750 2751 return 1; 2752 2753 } 2754 2755 /** 2756 * wmi_ready_extract_mac_addr() - extract mac address from ready event 2757 * @wmi_handle: wmi handle 2758 * @param ev: pointer to event buffer 2759 * @param macaddr: Pointer to hold MAC address 2760 * 2761 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2762 */ 2763 QDF_STATUS wmi_ready_extract_mac_addr(void *wmi_hdl, void *ev, uint8_t *macaddr) 2764 { 2765 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2766 2767 if (wmi_handle->ops->ready_extract_mac_addr) 2768 return wmi_handle->ops->ready_extract_mac_addr(wmi_handle, 2769 ev, macaddr); 2770 2771 2772 return QDF_STATUS_E_FAILURE; 2773 } 2774 2775 /** 2776 * wmi_ready_extract_mac_addr() - extract MAC address list from ready event 2777 * @wmi_handle: wmi handle 2778 * @param ev: pointer to event buffer 2779 * @param num_mac_addr: Pointer to number of entries 2780 * 2781 * Return: address to start of mac addr list 2782 */ 2783 wmi_host_mac_addr *wmi_ready_extract_mac_addr_list(void *wmi_hdl, void *ev, 2784 uint8_t *num_mac_addr) 2785 { 2786 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2787 2788 if (wmi_handle->ops->ready_extract_mac_addr_list) 2789 return wmi_handle->ops->ready_extract_mac_addr_list(wmi_handle, 2790 ev, num_mac_addr); 2791 2792 *num_mac_addr = 0; 2793 2794 return NULL; 2795 } 2796 2797 /** 2798 * wmi_extract_ready_params() - Extract data from ready event apart from 2799 * status, macaddr and version. 2800 * @wmi_handle: Pointer to WMI handle. 2801 * @evt_buf: Pointer to Ready event buffer. 2802 * @ev_param: Pointer to host defined struct to copy the data from event. 2803 * 2804 * Return: QDF_STATUS_SUCCESS on success. 2805 */ 2806 QDF_STATUS wmi_extract_ready_event_params(void *wmi_hdl, 2807 void *evt_buf, struct wmi_host_ready_ev_param *ev_param) 2808 { 2809 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2810 2811 if (wmi_handle->ops->extract_ready_event_params) 2812 return wmi_handle->ops->extract_ready_event_params(wmi_handle, 2813 evt_buf, ev_param); 2814 2815 return QDF_STATUS_E_FAILURE; 2816 } 2817 2818 /** 2819 * wmi_extract_dbglog_data_len() - extract debuglog data length 2820 * @wmi_handle: wmi handle 2821 * @param evt_buf: pointer to event buffer 2822 * @param len: length of buffer 2823 * 2824 * Return: length 2825 */ 2826 uint8_t *wmi_extract_dbglog_data_len(void *wmi_hdl, void *evt_buf, 2827 uint32_t *len) 2828 { 2829 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2830 2831 if (wmi_handle->ops->extract_dbglog_data_len) 2832 return wmi_handle->ops->extract_dbglog_data_len(wmi_handle, 2833 evt_buf, len); 2834 2835 2836 return NULL; 2837 } 2838 qdf_export_symbol(wmi_extract_dbglog_data_len); 2839 2840 /** 2841 * wmi_send_ext_resource_config() - send extended resource configuration 2842 * @wmi_handle: wmi handle 2843 * @param ext_cfg: pointer to extended resource configuration 2844 * 2845 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2846 */ 2847 QDF_STATUS wmi_send_ext_resource_config(void *wmi_hdl, 2848 wmi_host_ext_resource_config *ext_cfg) 2849 { 2850 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2851 2852 if (wmi_handle->ops->send_ext_resource_config) 2853 return wmi_handle->ops->send_ext_resource_config(wmi_handle, 2854 ext_cfg); 2855 2856 return QDF_STATUS_E_FAILURE; 2857 } 2858 2859 /** 2860 * wmi_unified_rtt_meas_req_test_cmd_send() - WMI rtt meas req test function 2861 * @param wmi_handle : handle to WMI. 2862 * @param param : pointer to hold rtt meas req test param 2863 * 2864 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2865 */ 2866 QDF_STATUS wmi_unified_rtt_meas_req_test_cmd_send(void *wmi_hdl, 2867 struct rtt_meas_req_test_params *param) 2868 { 2869 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2870 2871 if (wmi_handle->ops->send_rtt_meas_req_test_cmd) 2872 return wmi_handle->ops->send_rtt_meas_req_test_cmd(wmi_handle, 2873 param); 2874 2875 return QDF_STATUS_E_FAILURE; 2876 } 2877 2878 /** 2879 * wmi_unified_rtt_meas_req_cmd_send() - WMI rtt meas req function 2880 * @param wmi_handle : handle to WMI. 2881 * @param param : pointer to hold rtt meas req param 2882 * 2883 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2884 */ 2885 QDF_STATUS wmi_unified_rtt_meas_req_cmd_send(void *wmi_hdl, 2886 struct rtt_meas_req_params *param) 2887 { 2888 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2889 2890 if (wmi_handle->ops->send_rtt_meas_req_cmd) 2891 return wmi_handle->ops->send_rtt_meas_req_cmd(wmi_handle, 2892 param); 2893 2894 return QDF_STATUS_E_FAILURE; 2895 } 2896 2897 /** 2898 * wmi_unified_lci_set_cmd_send() - WMI lci set function 2899 * @param wmi_handle : handle to WMI. 2900 * @param param : pointer to hold lci param 2901 * 2902 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2903 */ 2904 QDF_STATUS wmi_unified_lci_set_cmd_send(void *wmi_hdl, 2905 struct lci_set_params *param) 2906 { 2907 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2908 2909 if (wmi_handle->ops->send_lci_set_cmd) 2910 return wmi_handle->ops->send_lci_set_cmd(wmi_handle, param); 2911 2912 return QDF_STATUS_E_FAILURE; 2913 } 2914 2915 /** 2916 * wmi_unified_lcr_set_cmd_send() - WMI lcr set function 2917 * @param wmi_handle : handle to WMI. 2918 * @param param : pointer to hold lcr param 2919 * 2920 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2921 */ 2922 QDF_STATUS wmi_unified_lcr_set_cmd_send(void *wmi_hdl, 2923 struct lcr_set_params *param) 2924 { 2925 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2926 2927 if (wmi_handle->ops->send_lcr_set_cmd) 2928 return wmi_handle->ops->send_lcr_set_cmd(wmi_handle, param); 2929 2930 return QDF_STATUS_E_FAILURE; 2931 } 2932 2933 /** 2934 * wmi_unified_rtt_keepalive_req_cmd_send() - WMI rtt meas req test function 2935 * @param wmi_handle : handle to WMI. 2936 * @param param : pointer to hold rtt meas req test param 2937 * 2938 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2939 */ 2940 QDF_STATUS wmi_unified_rtt_keepalive_req_cmd_send(void *wmi_hdl, 2941 struct rtt_keepalive_req_params *param) 2942 { 2943 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2944 2945 if (wmi_handle->ops->send_rtt_keepalive_req_cmd) 2946 return wmi_handle->ops->send_rtt_keepalive_req_cmd(wmi_handle, 2947 param); 2948 2949 return QDF_STATUS_E_FAILURE; 2950 } 2951 2952 /** 2953 * wmi_unified_send_periodic_chan_stats_config_cmd() - send periodic chan stats cmd 2954 * to fw 2955 * @wmi_handle: wmi handle 2956 * @param: pointer to hold periodic chan stats param 2957 * 2958 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2959 */ 2960 QDF_STATUS wmi_unified_send_periodic_chan_stats_config_cmd(void *wmi_hdl, 2961 struct periodic_chan_stats_params *param) 2962 { 2963 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 2964 2965 if (wmi->ops->send_periodic_chan_stats_config_cmd) 2966 return wmi->ops->send_periodic_chan_stats_config_cmd(wmi, 2967 param); 2968 2969 return QDF_STATUS_E_FAILURE; 2970 } 2971 2972 /** 2973 * wmi_send_get_user_position_cmd() - send get user position command to fw 2974 * @wmi_handle: wmi handle 2975 * 2976 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2977 */ 2978 QDF_STATUS 2979 wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value) 2980 { 2981 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 2982 2983 if (wmi_handle->ops->send_get_user_position_cmd) 2984 return wmi_handle->ops->send_get_user_position_cmd(wmi_handle, 2985 value); 2986 2987 return QDF_STATUS_E_FAILURE; 2988 } 2989 2990 /** 2991 * wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count 2992 * command to fw 2993 * @wmi_handle: wmi handle 2994 * @value: user pos value 2995 * 2996 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 2997 */ 2998 QDF_STATUS 2999 wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value) 3000 { 3001 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3002 3003 if (wmi->ops->send_get_peer_mumimo_tx_count_cmd) 3004 return wmi->ops->send_get_peer_mumimo_tx_count_cmd(wmi, value); 3005 3006 return QDF_STATUS_E_FAILURE; 3007 } 3008 3009 /** 3010 * wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo 3011 * tx count to fw 3012 * @wmi_handle: wmi handle 3013 * @value: reset tx count value 3014 * 3015 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3016 */ 3017 QDF_STATUS 3018 wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value) 3019 { 3020 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3021 3022 if (wmi->ops->send_reset_peer_mumimo_tx_count_cmd) 3023 return wmi->ops->send_reset_peer_mumimo_tx_count_cmd(wmi, 3024 value); 3025 3026 return QDF_STATUS_E_FAILURE; 3027 } 3028 3029 /* Extract - APIs */ 3030 /** 3031 * wmi_extract_ctl_failsafe_check_ev_param() - extract ctl data 3032 * from event 3033 * @wmi_handle: wmi handle 3034 * @param evt_buf: pointer to event buffer 3035 * @param param: Pointer to hold ctl data 3036 * 3037 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3038 */ 3039 QDF_STATUS 3040 wmi_extract_ctl_failsafe_check_ev_param(void *wmi_hdl, 3041 void *evt_buf, 3042 struct wmi_host_pdev_ctl_failsafe_event 3043 *param) 3044 { 3045 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 3046 3047 if (wmi->ops->extract_ctl_failsafe_check_ev_param) 3048 return wmi->ops->extract_ctl_failsafe_check_ev_param( 3049 wmi, evt_buf, param); 3050 3051 return QDF_STATUS_E_FAILURE; 3052 } 3053 3054 /** 3055 * wmi_extract_fips_event_data() - extract fips event data 3056 * @wmi_handle: wmi handle 3057 * @param evt_buf: pointer to event buffer 3058 * @param param: pointer to FIPS event param 3059 * 3060 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3061 */ 3062 QDF_STATUS wmi_extract_fips_event_data(void *wmi_hdl, void *evt_buf, 3063 struct wmi_host_fips_event_param *param) 3064 { 3065 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3066 3067 if (wmi_handle->ops->extract_fips_event_data) { 3068 return wmi_handle->ops->extract_fips_event_data(wmi_handle, 3069 evt_buf, param); 3070 } 3071 return QDF_STATUS_E_FAILURE; 3072 } 3073 3074 /** 3075 * wmi_extract_mgmt_rx_params() - extract management rx params from event 3076 * @wmi_handle: wmi handle 3077 * @param evt_buf: pointer to event buffer 3078 * @param hdr: Pointer to hold header 3079 * @param bufp: Pointer to hold pointer to rx param buffer 3080 * 3081 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3082 */ 3083 QDF_STATUS wmi_extract_mgmt_rx_params(void *wmi_hdl, void *evt_buf, 3084 struct mgmt_rx_event_params *hdr, uint8_t **bufp) 3085 { 3086 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3087 3088 if (wmi_handle->ops->extract_mgmt_rx_params) 3089 return wmi_handle->ops->extract_mgmt_rx_params(wmi_handle, 3090 evt_buf, hdr, bufp); 3091 3092 return QDF_STATUS_E_FAILURE; 3093 } 3094 3095 /** 3096 * wmi_extract_vdev_roam_param() - extract vdev roam param from event 3097 * @wmi_handle: wmi handle 3098 * @param evt_buf: pointer to event buffer 3099 * @param param: Pointer to hold roam param 3100 * 3101 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3102 */ 3103 QDF_STATUS wmi_extract_vdev_roam_param(void *wmi_hdl, void *evt_buf, 3104 wmi_host_roam_event *param) 3105 { 3106 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3107 3108 if (wmi_handle->ops->extract_vdev_roam_param) 3109 return wmi_handle->ops->extract_vdev_roam_param(wmi_handle, 3110 evt_buf, param); 3111 3112 return QDF_STATUS_E_FAILURE; 3113 } 3114 3115 /** 3116 * wmi_extract_vdev_scan_ev_param() - extract vdev scan param from event 3117 * @wmi_handle: wmi handle 3118 * @param evt_buf: pointer to event buffer 3119 * @param param: Pointer to hold vdev scan param 3120 * 3121 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3122 */ 3123 QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf, 3124 struct scan_event *param) 3125 { 3126 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3127 3128 if (wmi_handle->ops->extract_vdev_scan_ev_param) 3129 return wmi_handle->ops->extract_vdev_scan_ev_param(wmi_handle, 3130 evt_buf, param); 3131 3132 return QDF_STATUS_E_FAILURE; 3133 } 3134 3135 /** 3136 * wmi_extract_mu_ev_param() - extract mu param from event 3137 * @wmi_handle: wmi handle 3138 * @param evt_buf: pointer to event buffer 3139 * @param param: Pointer to hold mu report 3140 * 3141 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3142 */ 3143 QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf, 3144 wmi_host_mu_report_event *param) 3145 { 3146 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3147 3148 if (wmi_handle->ops->extract_mu_ev_param) 3149 return wmi_handle->ops->extract_mu_ev_param(wmi_handle, evt_buf, 3150 param); 3151 3152 return QDF_STATUS_E_FAILURE; 3153 } 3154 3155 /** 3156 * wmi_extract_mu_db_entry() - extract mu db entry from event 3157 * @wmi_handle: wmi handle 3158 * @param evt_buf: pointer to event buffer 3159 * @param param: Pointer to hold mu db entry 3160 * 3161 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3162 */ 3163 QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf, 3164 uint8_t idx, wmi_host_mu_db_entry *param) 3165 { 3166 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3167 3168 if (wmi_handle->ops->extract_mu_db_entry) 3169 return wmi_handle->ops->extract_mu_db_entry(wmi_handle, evt_buf, 3170 idx, param); 3171 3172 return QDF_STATUS_E_FAILURE; 3173 } 3174 3175 /** 3176 * wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event 3177 * @wmi_handle: wmi handle 3178 * @param evt_buf: pointer to event buffer 3179 * @param param: Pointer to hold mumimo tx count 3180 * 3181 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3182 */ 3183 QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf, 3184 wmi_host_peer_txmu_cnt_event *param) 3185 { 3186 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3187 3188 if (wmi->ops->extract_mumimo_tx_count_ev_param) 3189 return wmi->ops->extract_mumimo_tx_count_ev_param(wmi, 3190 evt_buf, param); 3191 3192 return QDF_STATUS_E_FAILURE; 3193 } 3194 3195 /** 3196 * wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list 3197 * from event 3198 * @wmi_handle: wmi handle 3199 * @param evt_buf: pointer to event buffer 3200 * @param param: Pointer to hold peer gid userposition list 3201 * 3202 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3203 */ 3204 QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl, 3205 void *evt_buf, 3206 wmi_host_peer_gid_userpos_list_event *param) 3207 { 3208 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3209 3210 if (wmi->ops->extract_peer_gid_userpos_list_ev_param) 3211 return wmi->ops->extract_peer_gid_userpos_list_ev_param(wmi, 3212 evt_buf, param); 3213 3214 return QDF_STATUS_E_FAILURE; 3215 } 3216 3217 /** 3218 * wmi_extract_esp_estimate_ev_param() - extract air time from event 3219 * @wmi_handle: wmi handle 3220 * @evt_buf: pointer to event buffer 3221 * @param: Pointer to hold esp event 3222 * 3223 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3224 */ 3225 QDF_STATUS 3226 wmi_extract_esp_estimate_ev_param(void *wmi_hdl, void *evt_buf, 3227 struct esp_estimation_event *param) 3228 { 3229 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 3230 3231 if (wmi_handle->ops->extract_esp_estimation_ev_param) 3232 return wmi_handle->ops->extract_esp_estimation_ev_param( 3233 wmi_handle, evt_buf, param); 3234 3235 return QDF_STATUS_E_FAILURE; 3236 } 3237 3238 /** 3239 * wmi_extract_gpio_input_ev_param() - extract gpio input param from event 3240 * @wmi_handle: wmi handle 3241 * @param evt_buf: pointer to event buffer 3242 * @param gpio_num: Pointer to hold gpio number 3243 * 3244 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3245 */ 3246 QDF_STATUS wmi_extract_gpio_input_ev_param(void *wmi_hdl, 3247 void *evt_buf, uint32_t *gpio_num) 3248 { 3249 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3250 3251 if (wmi_handle->ops->extract_gpio_input_ev_param) 3252 return wmi_handle->ops->extract_gpio_input_ev_param(wmi_handle, 3253 evt_buf, gpio_num); 3254 3255 return QDF_STATUS_E_FAILURE; 3256 } 3257 3258 /** 3259 * wmi_extract_pdev_reserve_ast_ev_param() - extract reserve ast entry 3260 * param from event 3261 * @wmi_handle: wmi handle 3262 * @param evt_buf: pointer to event buffer 3263 * @param param: Pointer to hold reserve ast entry param 3264 * 3265 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3266 */ 3267 QDF_STATUS wmi_extract_pdev_reserve_ast_ev_param(void *wmi_hdl, 3268 void *evt_buf, struct wmi_host_proxy_ast_reserve_param *param) 3269 { 3270 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3271 3272 if (wmi->ops->extract_pdev_reserve_ast_ev_param) 3273 return wmi->ops->extract_pdev_reserve_ast_ev_param(wmi, 3274 evt_buf, param); 3275 3276 return QDF_STATUS_E_FAILURE; 3277 } 3278 3279 /** 3280 * wmi_extract_pdev_generic_buffer_ev_param() - extract pdev generic buffer 3281 * from event 3282 * @wmi_handle: wmi handle 3283 * @param evt_buf: pointer to event buffer 3284 * @param param: Pointer to generic buffer param 3285 * 3286 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3287 */ 3288 QDF_STATUS wmi_extract_pdev_generic_buffer_ev_param(void *wmi_hdl, 3289 void *evt_buf, wmi_host_pdev_generic_buffer_event *param) 3290 { 3291 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3292 3293 if (wmi->ops->extract_pdev_generic_buffer_ev_param) 3294 return wmi->ops->extract_pdev_generic_buffer_ev_param(wmi, 3295 evt_buf, param); 3296 3297 return QDF_STATUS_E_FAILURE; 3298 3299 } 3300 3301 /** 3302 * wmi_extract_peer_ratecode_list_ev() - extract peer ratecode from event 3303 * @wmi_handle: wmi handle 3304 * @param evt_buf: pointer to event buffer 3305 * @param peer_mac: Pointer to hold peer mac address 3306 * @param rate_cap: Pointer to hold ratecode 3307 * 3308 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3309 */ 3310 QDF_STATUS wmi_extract_peer_ratecode_list_ev(void *wmi_hdl, void *evt_buf, 3311 uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap) 3312 { 3313 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3314 3315 if (wmi->ops->extract_peer_ratecode_list_ev) 3316 return wmi->ops->extract_peer_ratecode_list_ev(wmi, 3317 evt_buf, peer_mac, rate_cap); 3318 3319 return QDF_STATUS_E_FAILURE; 3320 3321 } 3322 3323 /** 3324 * wmi_extract_comb_phyerr() - extract comb phy error from event 3325 * @wmi_handle: wmi handle 3326 * @param evt_buf: pointer to event buffer 3327 * @param datalen: data length of event buffer 3328 * @param buf_offset: Pointer to hold value of current event buffer offset 3329 * post extraction 3330 * @param phyer: Pointer to hold phyerr 3331 * 3332 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3333 */ 3334 QDF_STATUS wmi_extract_comb_phyerr(void *wmi_hdl, void *evt_buf, 3335 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr) 3336 { 3337 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3338 3339 if (wmi_handle->ops->extract_comb_phyerr) 3340 return wmi_handle->ops->extract_comb_phyerr(wmi_handle, 3341 evt_buf, datalen, buf_offset, phyerr); 3342 3343 return QDF_STATUS_E_FAILURE; 3344 3345 } 3346 3347 /** 3348 * wmi_extract_single_phyerr() - extract single phy error from event 3349 * @wmi_handle: wmi handle 3350 * @param evt_buf: pointer to event buffer 3351 * @param datalen: data length of event buffer 3352 * @param buf_offset: Pointer to hold value of current event buffer offset 3353 * post extraction 3354 * @param phyerr: Pointer to hold phyerr 3355 * 3356 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3357 */ 3358 QDF_STATUS wmi_extract_single_phyerr(void *wmi_hdl, void *evt_buf, 3359 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr) 3360 { 3361 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3362 3363 if (wmi_handle->ops->extract_single_phyerr) 3364 return wmi_handle->ops->extract_single_phyerr(wmi_handle, 3365 evt_buf, datalen, buf_offset, phyerr); 3366 3367 return QDF_STATUS_E_FAILURE; 3368 3369 } 3370 3371 /** 3372 * wmi_extract_composite_phyerr() - extract composite phy error from event 3373 * @wmi_handle: wmi handle 3374 * @param evt_buf: pointer to event buffer 3375 * @param datalen: Length of event buffer 3376 * @param phyerr: Pointer to hold phy error 3377 * 3378 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3379 */ 3380 QDF_STATUS wmi_extract_composite_phyerr(void *wmi_hdl, void *evt_buf, 3381 uint16_t datalen, wmi_host_phyerr_t *phyerr) 3382 { 3383 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3384 3385 if (wmi_handle->ops->extract_composite_phyerr) 3386 return wmi_handle->ops->extract_composite_phyerr(wmi_handle, 3387 evt_buf, datalen, phyerr); 3388 3389 return QDF_STATUS_E_FAILURE; 3390 3391 } 3392 3393 /** 3394 * wmi_extract_stats_param() - extract all stats count from event 3395 * @wmi_handle: wmi handle 3396 * @param evt_buf: pointer to event buffer 3397 * @param stats_param: Pointer to hold stats count 3398 * 3399 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3400 */ 3401 QDF_STATUS wmi_extract_stats_param(void *wmi_hdl, void *evt_buf, 3402 wmi_host_stats_event *stats_param) 3403 { 3404 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3405 3406 if (wmi_handle->ops->extract_all_stats_count) 3407 return wmi_handle->ops->extract_all_stats_count(wmi_handle, 3408 evt_buf, stats_param); 3409 3410 return QDF_STATUS_E_FAILURE; 3411 } 3412 3413 /** 3414 * wmi_extract_pdev_stats() - extract pdev stats from event 3415 * @wmi_handle: wmi handle 3416 * @param evt_buf: pointer to event buffer 3417 * @param index: Index into pdev stats 3418 * @param pdev_stats: Pointer to hold pdev stats 3419 * 3420 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3421 */ 3422 QDF_STATUS wmi_extract_pdev_stats(void *wmi_hdl, void *evt_buf, 3423 uint32_t index, wmi_host_pdev_stats *pdev_stats) 3424 { 3425 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3426 3427 if (wmi_handle->ops->extract_pdev_stats) 3428 return wmi_handle->ops->extract_pdev_stats(wmi_handle, 3429 evt_buf, index, pdev_stats); 3430 3431 return QDF_STATUS_E_FAILURE; 3432 } 3433 3434 /** 3435 * extract_unit_test() - extract unit test from event 3436 * @wmi_handle: wmi handle 3437 * @param evt_buf: pointer to event buffer 3438 * @param unit_test: Pointer to hold unit-test header 3439 * @param maxspace: The amount of space in evt_buf 3440 * 3441 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3442 */ 3443 QDF_STATUS wmi_extract_unit_test(void *wmi_hdl, void *evt_buf, 3444 wmi_unit_test_event *unit_test, uint32_t maxspace) 3445 { 3446 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3447 3448 if (wmi_handle->ops->extract_unit_test) 3449 return wmi_handle->ops->extract_unit_test(wmi_handle, 3450 evt_buf, unit_test, maxspace); 3451 3452 return QDF_STATUS_E_FAILURE; 3453 } 3454 3455 /** 3456 * wmi_extract_pdev_ext_stats() - extract extended pdev stats from event 3457 * @wmi_handle: wmi handle 3458 * @param evt_buf: pointer to event buffer 3459 * @param index: Index into extended pdev stats 3460 * @param pdev_ext_stats: Pointer to hold extended pdev stats 3461 * 3462 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3463 */ 3464 QDF_STATUS wmi_extract_pdev_ext_stats(void *wmi_hdl, void *evt_buf, 3465 uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats) 3466 { 3467 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3468 3469 if (wmi_handle->ops->extract_pdev_ext_stats) 3470 return wmi_handle->ops->extract_pdev_ext_stats(wmi_handle, 3471 evt_buf, index, pdev_ext_stats); 3472 3473 return QDF_STATUS_E_FAILURE; 3474 } 3475 3476 /** 3477 * wmi_extract_peer_stats() - extract peer stats from event 3478 * @wmi_handle: wmi handle 3479 * @param evt_buf: pointer to event buffer 3480 * @param index: Index into peer stats 3481 * @param peer_stats: Pointer to hold peer stats 3482 * 3483 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3484 */ 3485 QDF_STATUS wmi_extract_peer_stats(void *wmi_hdl, void *evt_buf, 3486 uint32_t index, wmi_host_peer_stats *peer_stats) 3487 { 3488 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3489 3490 if (wmi_handle->ops->extract_peer_stats) 3491 return wmi_handle->ops->extract_peer_stats(wmi_handle, 3492 evt_buf, index, peer_stats); 3493 3494 return QDF_STATUS_E_FAILURE; 3495 } 3496 3497 /** 3498 * wmi_extract_vdev_stats() - extract vdev stats from event 3499 * @wmi_handle: wmi handle 3500 * @param evt_buf: pointer to event buffer 3501 * @param index: Index into vdev stats 3502 * @param vdev_stats: Pointer to hold vdev stats 3503 * 3504 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3505 */ 3506 QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf, 3507 uint32_t index, wmi_host_vdev_stats *vdev_stats) 3508 { 3509 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3510 3511 if (wmi_handle->ops->extract_vdev_stats) 3512 return wmi_handle->ops->extract_vdev_stats(wmi_handle, 3513 evt_buf, index, vdev_stats); 3514 3515 return QDF_STATUS_E_FAILURE; 3516 } 3517 3518 /** 3519 * wmi_extract_per_chain_rssi_stats() - extract rssi stats from event 3520 * @wmi_handle: wmi handle 3521 * @param evt_buf: pointer to event buffer 3522 * @param index: Index into rssi stats 3523 * @param rssi_stats: Pointer to hold rssi stats 3524 * 3525 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3526 */ 3527 QDF_STATUS wmi_extract_per_chain_rssi_stats(void *wmi_hdl, void *evt_buf, 3528 uint32_t index, struct wmi_host_per_chain_rssi_stats *rssi_stats) 3529 { 3530 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3531 3532 if (wmi_handle->ops->extract_per_chain_rssi_stats) 3533 return wmi_handle->ops->extract_per_chain_rssi_stats(wmi_handle, 3534 evt_buf, index, rssi_stats); 3535 3536 return QDF_STATUS_E_FAILURE; 3537 } 3538 3539 /** 3540 * wmi_extract_rtt_hdr() - extract rtt header from event 3541 * @wmi_handle: wmi handle 3542 * @param evt_buf: pointer to event buffer 3543 * @param ev: Pointer to hold rtt header 3544 * 3545 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3546 */ 3547 QDF_STATUS wmi_extract_rtt_hdr(void *wmi_hdl, void *evt_buf, 3548 wmi_host_rtt_event_hdr *ev) 3549 { 3550 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3551 3552 if (wmi_handle->ops->extract_rtt_hdr) 3553 return wmi_handle->ops->extract_rtt_hdr(wmi_handle, 3554 evt_buf, ev); 3555 3556 return QDF_STATUS_E_FAILURE; 3557 } 3558 3559 /** 3560 * wmi_extract_bcnflt_stats() - extract bcn fault stats from event 3561 * @wmi_handle: wmi handle 3562 * @param evt_buf: pointer to event buffer 3563 * @param index: Index into bcn fault stats 3564 * @param bcnflt_stats: Pointer to hold bcn fault stats 3565 * 3566 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3567 */ 3568 QDF_STATUS wmi_extract_bcnflt_stats(void *wmi_hdl, void *evt_buf, 3569 uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats) 3570 { 3571 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3572 3573 if (wmi_handle->ops->extract_bcnflt_stats) 3574 return wmi_handle->ops->extract_bcnflt_stats(wmi_handle, 3575 evt_buf, index, bcnflt_stats); 3576 3577 return QDF_STATUS_E_FAILURE; 3578 } 3579 3580 /** 3581 * wmi_extract_rtt_ev() - extract rtt event 3582 * @wmi_handle: wmi handle 3583 * @param evt_buf: Pointer to event buffer 3584 * @param ev: Pointer to hold rtt event 3585 * @param hdump: Pointer to hold hex dump 3586 * @param hdump_len: hex dump length 3587 * 3588 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3589 */ 3590 QDF_STATUS wmi_extract_rtt_ev(void *wmi_hdl, void *evt_buf, 3591 wmi_host_rtt_meas_event *ev, uint8_t *hdump, uint16_t hdump_len) 3592 { 3593 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3594 3595 if (wmi_handle->ops->extract_rtt_ev) 3596 return wmi_handle->ops->extract_rtt_ev(wmi_handle, 3597 evt_buf, ev, hdump, hdump_len); 3598 3599 return QDF_STATUS_E_FAILURE; 3600 } 3601 3602 /** 3603 * wmi_extract_peer_extd_stats() - extract extended peer stats from event 3604 * @wmi_handle: wmi handle 3605 * @param evt_buf: pointer to event buffer 3606 * @param index: Index into extended peer stats 3607 * @param peer_extd_stats: Pointer to hold extended peer stats 3608 * 3609 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3610 */ 3611 QDF_STATUS wmi_extract_peer_extd_stats(void *wmi_hdl, void *evt_buf, 3612 uint32_t index, wmi_host_peer_extd_stats *peer_extd_stats) 3613 { 3614 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3615 3616 if (wmi_handle->ops->extract_peer_extd_stats) 3617 return wmi_handle->ops->extract_peer_extd_stats(wmi_handle, 3618 evt_buf, index, peer_extd_stats); 3619 3620 return QDF_STATUS_E_FAILURE; 3621 } 3622 3623 QDF_STATUS wmi_extract_peer_retry_stats(void *wmi_hdl, void *evt_buf, 3624 uint32_t index, struct wmi_host_peer_retry_stats *peer_retry_stats) 3625 { 3626 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 3627 3628 if (wmi_handle->ops->extract_peer_retry_stats) 3629 return wmi_handle->ops->extract_peer_retry_stats(wmi_handle, 3630 evt_buf, index, peer_retry_stats); 3631 3632 return QDF_STATUS_E_FAILURE; 3633 } 3634 3635 /** 3636 * wmi_extract_rtt_error_report_ev() - extract rtt error report from event 3637 * @wmi_handle: wmi handle 3638 * @param evt_buf: pointer to event buffer 3639 * @param wds_ev: Pointer to hold rtt error report 3640 * 3641 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3642 */ 3643 QDF_STATUS wmi_extract_rtt_error_report_ev(void *wmi_hdl, void *evt_buf, 3644 wmi_host_rtt_error_report_event *ev) 3645 { 3646 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3647 3648 if (wmi_handle->ops->extract_rtt_error_report_ev) 3649 return wmi_handle->ops->extract_rtt_error_report_ev(wmi_handle, 3650 evt_buf, ev); 3651 3652 return QDF_STATUS_E_FAILURE; 3653 } 3654 3655 /** 3656 * wmi_extract_chan_stats() - extract chan stats from event 3657 * @wmi_handle: wmi handle 3658 * @param evt_buf: pointer to event buffer 3659 * @param index: Index into chan stats 3660 * @param chanstats: Pointer to hold chan stats 3661 * 3662 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3663 */ 3664 QDF_STATUS wmi_extract_chan_stats(void *wmi_hdl, void *evt_buf, 3665 uint32_t index, wmi_host_chan_stats *chan_stats) 3666 { 3667 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3668 3669 if (wmi_handle->ops->extract_chan_stats) 3670 return wmi_handle->ops->extract_chan_stats(wmi_handle, 3671 evt_buf, index, chan_stats); 3672 3673 return QDF_STATUS_E_FAILURE; 3674 } 3675 3676 /** 3677 * wmi_extract_thermal_stats() - extract thermal stats from event 3678 * @wmi_handle: wmi handle 3679 * @param evt_buf: Pointer to event buffer 3680 * @param temp: Pointer to hold extracted temperature 3681 * @param level: Pointer to hold extracted level 3682 * @param pdev_id: Pointer to hold extracted pdev_id 3683 * 3684 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3685 */ 3686 QDF_STATUS wmi_extract_thermal_stats(void *wmi_hdl, void *evt_buf, 3687 uint32_t *temp, uint32_t *level, uint32_t *pdev_id) 3688 { 3689 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3690 3691 if (wmi_handle->ops->extract_thermal_stats) 3692 return wmi_handle->ops->extract_thermal_stats(wmi_handle, 3693 evt_buf, temp, level, pdev_id); 3694 3695 return QDF_STATUS_E_FAILURE; 3696 } 3697 3698 /** 3699 * wmi_extract_profile_ctx() - extract profile context from event 3700 * @wmi_handle: wmi handle 3701 * @param evt_buf: pointer to event buffer 3702 * @param profile_ctx: Pointer to hold profile context 3703 * 3704 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3705 */ 3706 QDF_STATUS wmi_extract_profile_ctx(void *wmi_hdl, void *evt_buf, 3707 wmi_host_wlan_profile_ctx_t *profile_ctx) 3708 { 3709 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3710 3711 if (wmi_handle->ops->extract_profile_ctx) 3712 return wmi_handle->ops->extract_profile_ctx(wmi_handle, 3713 evt_buf, profile_ctx); 3714 3715 return QDF_STATUS_E_FAILURE; 3716 } 3717 3718 /** 3719 * wmi_extract_thermal_level_stats() - extract thermal level stats from 3720 * event 3721 * @wmi_handle: wmi handle 3722 * @param evt_buf: pointer to event buffer 3723 * @param idx: Index to level stats 3724 * @param levelcount: Pointer to hold levelcount 3725 * @param dccount: Pointer to hold dccount 3726 * 3727 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3728 */ 3729 QDF_STATUS wmi_extract_thermal_level_stats(void *wmi_hdl, void *evt_buf, 3730 uint8_t idx, uint32_t *levelcount, uint32_t *dccount) 3731 { 3732 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3733 3734 if (wmi_handle->ops->extract_thermal_level_stats) 3735 return wmi_handle->ops->extract_thermal_level_stats(wmi_handle, 3736 evt_buf, idx, levelcount, dccount); 3737 3738 return QDF_STATUS_E_FAILURE; 3739 } 3740 3741 /** 3742 * wmi_extract_profile_data() - extract profile data from event 3743 * @wmi_handle: wmi handle 3744 * @param evt_buf: pointer to event buffer 3745 * @idx index: index of profile data 3746 * @param profile_data: Pointer to hold profile data 3747 * 3748 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3749 */ 3750 QDF_STATUS wmi_extract_profile_data(void *wmi_hdl, void *evt_buf, uint8_t idx, 3751 wmi_host_wlan_profile_t *profile_data) 3752 { 3753 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3754 3755 if (wmi_handle->ops->extract_profile_data) 3756 return wmi_handle->ops->extract_profile_data(wmi_handle, 3757 evt_buf, idx, profile_data); 3758 3759 return QDF_STATUS_E_FAILURE; 3760 } 3761 3762 /** 3763 * wmi_extract_bss_chan_info_event() - extract bss channel information 3764 * from event 3765 * @wmi_handle: wmi handle 3766 * @param evt_buf: pointer to event buffer 3767 * @param bss_chan_info: Pointer to hold bss channel information 3768 * 3769 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3770 */ 3771 QDF_STATUS wmi_extract_bss_chan_info_event(void *wmi_hdl, void *evt_buf, 3772 wmi_host_pdev_bss_chan_info_event *bss_chan_info) 3773 { 3774 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3775 3776 if (wmi_handle->ops->extract_bss_chan_info_event) 3777 return wmi_handle->ops->extract_bss_chan_info_event(wmi_handle, 3778 evt_buf, bss_chan_info); 3779 3780 return QDF_STATUS_E_FAILURE; 3781 } 3782 3783 /** 3784 * wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control 3785 * from event 3786 * @wmi_handle: wmi handle 3787 * @param evt_buf: pointer to event buffer 3788 * @param ev: Pointer to hold data traffic control 3789 * 3790 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3791 */ 3792 QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf, 3793 wmi_host_tx_data_traffic_ctrl_event *ev) 3794 { 3795 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3796 3797 if (wmi->ops->extract_tx_data_traffic_ctrl_ev) 3798 return wmi->ops->extract_tx_data_traffic_ctrl_ev(wmi, 3799 evt_buf, ev); 3800 3801 return QDF_STATUS_E_FAILURE; 3802 } 3803 3804 /** 3805 * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event 3806 * @wmi_handle: wmi handle 3807 * @param evt_buf: pointer to event buffer 3808 * @param index: Index into extended vdev stats 3809 * @param vdev_extd_stats: Pointer to hold extended vdev stats 3810 * 3811 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3812 */ 3813 QDF_STATUS wmi_extract_vdev_extd_stats(void *wmi_hdl, void *evt_buf, 3814 uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats) 3815 { 3816 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3817 3818 if (wmi_handle->ops->extract_vdev_extd_stats) 3819 return wmi_handle->ops->extract_vdev_extd_stats(wmi_handle, 3820 evt_buf, index, vdev_extd_stats); 3821 return QDF_STATUS_E_FAILURE; 3822 } 3823 3824 /** 3825 * wmi_extract_bcn_stats() - extract beacon stats from event 3826 * @wmi_handle: wmi handle 3827 * @evt_buf: pointer to event buffer 3828 * @index: Index into beacon stats 3829 * @vdev_bcn_stats: Pointer to hold beacon stats 3830 * 3831 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3832 */ 3833 QDF_STATUS wmi_extract_bcn_stats(void *wmi_hdl, void *evt_buf, 3834 uint32_t index, wmi_host_bcn_stats *vdev_bcn_stats) 3835 { 3836 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3837 3838 if (wmi_handle->ops->extract_bcn_stats) 3839 return wmi_handle->ops->extract_bcn_stats(wmi_handle, 3840 evt_buf, index, vdev_bcn_stats); 3841 return QDF_STATUS_E_FAILURE; 3842 } 3843 3844 /** 3845 * wmi_extract_vdev_nac_rssi_stats() - extract NAC_RSSI stats from event 3846 * @wmi_handle: wmi handle 3847 * @param evt_buf: pointer to event buffer 3848 * @param vdev_extd_stats: Pointer to hold nac rssi stats 3849 * 3850 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 3851 */ 3852 QDF_STATUS wmi_extract_vdev_nac_rssi_stats(void *wmi_hdl, void *evt_buf, 3853 struct wmi_host_vdev_nac_rssi_event *vdev_nac_rssi_stats) 3854 { 3855 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3856 3857 if (wmi_handle->ops->extract_vdev_nac_rssi_stats) 3858 return wmi_handle->ops->extract_vdev_nac_rssi_stats(wmi_handle, 3859 evt_buf, vdev_nac_rssi_stats); 3860 3861 return QDF_STATUS_E_FAILURE; 3862 } 3863 3864 /** 3865 * wmi_unified_send_power_dbg_cmd() - send power debug commands 3866 * @wmi_handle: wmi handle 3867 * @param: wmi power debug parameter 3868 * 3869 * Send WMI_POWER_DEBUG_CMDID parameters to fw. 3870 * 3871 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3872 */ 3873 QDF_STATUS wmi_unified_send_power_dbg_cmd(void *wmi_hdl, 3874 struct wmi_power_dbg_params *param) 3875 { 3876 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3877 3878 if (wmi_handle->ops->send_power_dbg_cmd) 3879 return wmi_handle->ops->send_power_dbg_cmd(wmi_handle, 3880 param); 3881 3882 return QDF_STATUS_E_FAILURE; 3883 } 3884 3885 /* 3886 * wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands 3887 * @wmi_handle: wmi handle 3888 * @param : wmi btcoex cfg params 3889 * 3890 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 3891 * 3892 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3893 */ 3894 QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl, 3895 struct btcoex_cfg_params *param) 3896 { 3897 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3898 3899 if (wmi->ops->send_btcoex_wlan_priority_cmd) 3900 return wmi->ops->send_btcoex_wlan_priority_cmd(wmi, 3901 param); 3902 3903 return QDF_STATUS_E_FAILURE; 3904 } 3905 /** 3906 * wmi_unified_send_btcoex_duty_cycle_cmd() - send btcoex duty cycle commands 3907 * @wmi_handle: wmi handle 3908 * @param: wmi btcoex cfg params 3909 * 3910 * Send WMI_BTCOEX_CFG_CMDID parameters to fw. 3911 * 3912 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3913 */ 3914 QDF_STATUS wmi_unified_send_btcoex_duty_cycle_cmd(void *wmi_hdl, 3915 struct btcoex_cfg_params *param) 3916 { 3917 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl; 3918 3919 if (wmi->ops->send_btcoex_duty_cycle_cmd) 3920 return wmi->ops->send_btcoex_duty_cycle_cmd(wmi, 3921 param); 3922 3923 return QDF_STATUS_E_FAILURE; 3924 } 3925 3926 /* 3927 * wmi_extract_service_ready_ext() - extract extended service ready 3928 * @wmi_handle: wmi handle 3929 * @param: wmi power debug parameter 3930 * 3931 * 3932 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 3933 */ 3934 QDF_STATUS wmi_extract_service_ready_ext(void *wmi_hdl, uint8_t *evt_buf, 3935 struct wlan_psoc_host_service_ext_param *param) 3936 { 3937 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3938 3939 if (wmi_handle->ops->extract_service_ready_ext) 3940 return wmi_handle->ops->extract_service_ready_ext(wmi_handle, 3941 evt_buf, param); 3942 3943 return QDF_STATUS_E_FAILURE; 3944 } 3945 3946 /** 3947 * wmi_extract_sar_cap_service_ready_ext() - 3948 * extract sar cap from service ready event 3949 * @wmi_handle: wmi handle 3950 * @evt_buf: pointer to event buffer 3951 * @ext_param: extended target info 3952 * 3953 * Return: QDF_STATUS_SUCCESS for success or error code 3954 */ 3955 QDF_STATUS wmi_extract_sar_cap_service_ready_ext( 3956 void *wmi_hdl, 3957 uint8_t *evt_buf, 3958 struct wlan_psoc_host_service_ext_param *ext_param) 3959 { 3960 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3961 3962 if (wmi_handle->ops->extract_sar_cap_service_ready_ext) 3963 return wmi_handle->ops->extract_sar_cap_service_ready_ext( 3964 wmi_handle, 3965 evt_buf, ext_param); 3966 3967 return QDF_STATUS_E_FAILURE; 3968 } 3969 3970 /** 3971 * wmi_extract_hw_mode_cap_service_ready_ext() - 3972 * extract HW mode cap from service ready event 3973 * @wmi_handle: wmi handle 3974 * @param evt_buf: pointer to event buffer 3975 * @param param: Pointer to hold evt buf 3976 * @param hw_mode_idx: hw mode idx should be less than num_mode 3977 * 3978 * Return: QDF_STATUS_SUCCESS for success or error code 3979 */ 3980 QDF_STATUS wmi_extract_hw_mode_cap_service_ready_ext( 3981 void *wmi_hdl, 3982 uint8_t *evt_buf, uint8_t hw_mode_idx, 3983 struct wlan_psoc_host_hw_mode_caps *param) 3984 { 3985 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 3986 3987 if (wmi_handle->ops->extract_hw_mode_cap_service_ready_ext) 3988 return wmi_handle->ops->extract_hw_mode_cap_service_ready_ext( 3989 wmi_handle, 3990 evt_buf, hw_mode_idx, param); 3991 3992 return QDF_STATUS_E_FAILURE; 3993 } 3994 /** 3995 * wmi_extract_mac_phy_cap_service_ready_ext() - 3996 * extract MAC phy cap from service ready event 3997 * @wmi_handle: wmi handle 3998 * @param evt_buf: pointer to event buffer 3999 * @param hw_mode_id: hw mode id of hw_mode_caps 4000 * @param phy_id: phy_id within hw_mode_cap 4001 * @param param: pointer to mac phy caps structure to hold the values from event 4002 * 4003 * Return: QDF_STATUS_SUCCESS for success or error code 4004 */ 4005 QDF_STATUS wmi_extract_mac_phy_cap_service_ready_ext( 4006 void *wmi_hdl, 4007 uint8_t *evt_buf, 4008 uint8_t hw_mode_id, 4009 uint8_t phy_id, 4010 struct wlan_psoc_host_mac_phy_caps *param) 4011 { 4012 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4013 4014 if (wmi_handle->ops->extract_mac_phy_cap_service_ready_ext) 4015 return wmi_handle->ops->extract_mac_phy_cap_service_ready_ext( 4016 wmi_handle, 4017 evt_buf, hw_mode_id, phy_id, param); 4018 4019 return QDF_STATUS_E_FAILURE; 4020 } 4021 4022 /** 4023 * wmi_extract_reg_cap_service_ready_ext() - 4024 * extract REG cap from service ready event 4025 * @wmi_handle: wmi handle 4026 * @param evt_buf: pointer to event buffer 4027 * @param param: Pointer to hold evt buf 4028 * @param phy_idx: phy idx should be less than num_mode 4029 * 4030 * Return: QDF_STATUS_SUCCESS for success or error code 4031 */ 4032 QDF_STATUS wmi_extract_reg_cap_service_ready_ext( 4033 void *wmi_hdl, 4034 uint8_t *evt_buf, uint8_t phy_idx, 4035 struct wlan_psoc_host_hal_reg_capabilities_ext *param) 4036 { 4037 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4038 4039 if (wmi_handle->ops->extract_reg_cap_service_ready_ext) 4040 return wmi_handle->ops->extract_reg_cap_service_ready_ext( 4041 wmi_handle, 4042 evt_buf, phy_idx, param); 4043 4044 return QDF_STATUS_E_FAILURE; 4045 } 4046 4047 QDF_STATUS wmi_extract_dbr_ring_cap_service_ready_ext( 4048 void *wmi_hdl, 4049 uint8_t *evt_buf, uint8_t idx, 4050 struct wlan_psoc_host_dbr_ring_caps *param) 4051 { 4052 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4053 4054 if (wmi_handle->ops->extract_dbr_ring_cap_service_ready_ext) 4055 return wmi_handle->ops->extract_dbr_ring_cap_service_ready_ext( 4056 wmi_handle, 4057 evt_buf, idx, param); 4058 4059 return QDF_STATUS_E_FAILURE; 4060 } 4061 4062 QDF_STATUS wmi_extract_spectral_scaling_params_service_ready_ext( 4063 void *wmi_hdl, 4064 uint8_t *evt_buf, uint8_t idx, 4065 struct wlan_psoc_host_spectral_scaling_params *param) 4066 { 4067 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4068 4069 if (wmi_handle->ops->extract_scaling_params_service_ready_ext) 4070 return wmi_handle->ops->extract_scaling_params_service_ready_ext 4071 (wmi_handle, evt_buf, idx, param); 4072 4073 return QDF_STATUS_E_FAILURE; 4074 } 4075 4076 /** 4077 * wmi_extract_pdev_utf_event() - 4078 * extract UTF data from pdev utf event 4079 * @wmi_handle: wmi handle 4080 * @param evt_buf: pointer to event buffer 4081 * @param param: Pointer to hold evt buf 4082 * 4083 * Return: QDF_STATUS_SUCCESS for success or error code 4084 */ 4085 QDF_STATUS wmi_extract_pdev_utf_event(void *wmi_hdl, 4086 uint8_t *evt_buf, 4087 struct wmi_host_pdev_utf_event *param) 4088 { 4089 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4090 4091 if (wmi_handle->ops->extract_pdev_utf_event) 4092 return wmi_handle->ops->extract_pdev_utf_event( 4093 wmi_handle, 4094 evt_buf, param); 4095 4096 return QDF_STATUS_E_FAILURE; 4097 } 4098 4099 /** 4100 * wmi_extract_pdev_qvit_event() - 4101 * extract UTF data from pdev qvit event 4102 * @wmi_handle: wmi handle 4103 * @param evt_buf: pointer to event buffer 4104 * @param param: Pointer to hold evt buf 4105 * 4106 * Return: QDF_STATUS_SUCCESS for success or error code 4107 */ 4108 QDF_STATUS wmi_extract_pdev_qvit_event(void *wmi_hdl, 4109 uint8_t *evt_buf, 4110 struct wmi_host_pdev_qvit_event *param) 4111 { 4112 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4113 4114 if (wmi_handle->ops->extract_pdev_qvit_event) 4115 return wmi_handle->ops->extract_pdev_qvit_event( 4116 wmi_handle, 4117 evt_buf, param); 4118 4119 return QDF_STATUS_E_FAILURE; 4120 } 4121 4122 /** 4123 * wmi_unified_send_coex_ver_cfg_cmd() - send coex ver cfg command 4124 * @wmi_handle: wmi handle 4125 * @param: wmi coex ver cfg params 4126 * 4127 * Send WMI_COEX_VERSION_CFG_CMID parameters to fw. 4128 * 4129 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 4130 */ 4131 QDF_STATUS wmi_unified_send_coex_ver_cfg_cmd(void *wmi_hdl, 4132 coex_ver_cfg_t *param) 4133 { 4134 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4135 4136 if (wmi_handle->ops->send_coex_ver_cfg_cmd) 4137 return wmi_handle->ops->send_coex_ver_cfg_cmd(wmi_handle, 4138 param); 4139 4140 return QDF_STATUS_E_FAILURE; 4141 } 4142 4143 /** 4144 * wmi_unified_send_coex_config_cmd() - send coex ver cfg command 4145 * @wmi_handle: wmi handle 4146 * @param: wmi coex cfg cmd params 4147 * 4148 * Send WMI_COEX_CFG_CMD parameters to fw. 4149 * 4150 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 4151 */ 4152 QDF_STATUS wmi_unified_send_coex_config_cmd(void *wmi_hdl, 4153 struct coex_config_params *param) 4154 { 4155 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4156 4157 if (wmi_handle->ops->send_coex_config_cmd) 4158 return wmi_handle->ops->send_coex_config_cmd(wmi_handle, 4159 param); 4160 4161 return QDF_STATUS_E_FAILURE; 4162 } 4163 4164 QDF_STATUS wmi_unified_send_request_get_rcpi_cmd(void *wmi_hdl, 4165 struct rcpi_req *get_rcpi_param) 4166 { 4167 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4168 4169 if (wmi_handle->ops->send_get_rcpi_cmd) 4170 return wmi_handle->ops->send_get_rcpi_cmd(wmi_handle, 4171 get_rcpi_param); 4172 4173 return QDF_STATUS_E_FAILURE; 4174 } 4175 4176 QDF_STATUS wmi_extract_rcpi_response_event(void *wmi_hdl, void *evt_buf, 4177 struct rcpi_res *res) 4178 { 4179 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4180 struct wmi_ops *ops = wmi_handle->ops; 4181 4182 if (ops->extract_rcpi_response_event) 4183 return ops->extract_rcpi_response_event(wmi_handle, evt_buf, 4184 res); 4185 4186 return QDF_STATUS_E_FAILURE; 4187 } 4188 4189 QDF_STATUS 4190 wmi_unified_dfs_phyerr_offload_en_cmd(void *wmi_hdl, 4191 uint32_t pdev_id) 4192 { 4193 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4194 4195 if (wmi_handle->ops->send_dfs_phyerr_offload_en_cmd) 4196 return wmi_handle->ops->send_dfs_phyerr_offload_en_cmd( 4197 wmi_handle, pdev_id); 4198 4199 return QDF_STATUS_E_FAILURE; 4200 } 4201 4202 QDF_STATUS 4203 wmi_unified_dfs_phyerr_offload_dis_cmd(void *wmi_hdl, 4204 uint32_t pdev_id) 4205 { 4206 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4207 4208 if (wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd) 4209 return wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd( 4210 wmi_handle, pdev_id); 4211 4212 return QDF_STATUS_E_FAILURE; 4213 } 4214 4215 /* 4216 * wmi_extract_chainmask_tables_tlv() - extract chain mask tables 4217 * @wmi_handle: wmi handle 4218 * @evt_buf: pointer to event buffer. 4219 * @chainmask_table: pointer to struct wlan_psoc_host_chainmask_table 4220 * 4221 * 4222 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 4223 */ 4224 QDF_STATUS wmi_extract_chainmask_tables(void *wmi_hdl, uint8_t *evt_buf, 4225 struct wlan_psoc_host_chainmask_table *chainmask_table) 4226 { 4227 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4228 4229 if (wmi_handle->ops->extract_chainmask_tables) 4230 return wmi_handle->ops->extract_chainmask_tables(wmi_handle, 4231 evt_buf, chainmask_table); 4232 4233 return QDF_STATUS_E_FAILURE; 4234 } 4235 /** 4236 * wmi_unified_set_country_cmd_send() - WMI set country function 4237 * @param wmi_handle : handle to WMI. 4238 * @param param : pointer to hold set country cmd parameter 4239 * 4240 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure 4241 */ 4242 QDF_STATUS wmi_unified_set_country_cmd_send(void *wmi_hdl, 4243 struct set_country *param) 4244 { 4245 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4246 4247 if (wmi_handle->ops->send_set_country_cmd) 4248 return wmi_handle->ops->send_set_country_cmd(wmi_handle, 4249 param); 4250 4251 return QDF_STATUS_E_FAILURE; 4252 } 4253 4254 #ifdef WLAN_FEATURE_ACTION_OUI 4255 QDF_STATUS 4256 wmi_unified_send_action_oui_cmd(void *wmi_hdl, 4257 struct action_oui_request *req) 4258 { 4259 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4260 4261 if (wmi_handle->ops->send_action_oui_cmd) 4262 return wmi_handle->ops->send_action_oui_cmd(wmi_handle, 4263 req); 4264 4265 return QDF_STATUS_E_FAILURE; 4266 } 4267 #endif 4268 4269 /** 4270 * wmi_unified_send_wds_entry_list_cmd() - WMI function to get list of 4271 * wds entries from FW 4272 * @wmi_handle: wmi handle 4273 * 4274 * Send WMI_PDEV_WDS_ENTRY_LIST_CMDID parameters to fw. 4275 * 4276 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error 4277 */ 4278 QDF_STATUS wmi_unified_send_dump_wds_table_cmd(void *wmi_hdl) 4279 { 4280 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4281 4282 if (wmi_handle->ops->send_wds_entry_list_cmd) 4283 return wmi_handle->ops->send_wds_entry_list_cmd(wmi_handle); 4284 4285 return QDF_STATUS_E_FAILURE; 4286 } 4287 4288 /** 4289 * wmi_extract_wds_entry - api to extract wds entry 4290 * @wmi_handle: wma handle 4291 * @evt_buf: pointer to event buffer 4292 * @wds_entry: wds entry 4293 * @idx: index to point wds entry in event buffer 4294 * 4295 * Return: QDF_STATUS_SUCCESS for successful event parse 4296 * else QDF_STATUS_E_INVAL or QDF_STATUS_E_FAILURE 4297 */ 4298 QDF_STATUS wmi_extract_wds_entry(void *wmi_hdl, uint8_t *evt_buf, 4299 struct wdsentry *wds_entry, 4300 u_int32_t idx) 4301 { 4302 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; 4303 4304 if (wmi_handle->ops->extract_wds_entry) 4305 return wmi_handle->ops->extract_wds_entry(wmi_handle, 4306 evt_buf, wds_entry, idx); 4307 4308 return QDF_STATUS_E_FAILURE; 4309 } 4310 qdf_export_symbol(wmi_extract_wds_entry); 4311 4312 QDF_STATUS wmi_unified_send_obss_detection_cfg_cmd(void *wmi_hdl, 4313 struct wmi_obss_detection_cfg_param *obss_cfg_param) 4314 { 4315 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4316 4317 if (wmi_handle->ops->send_obss_detection_cfg_cmd) 4318 return wmi_handle->ops->send_obss_detection_cfg_cmd(wmi_handle, 4319 obss_cfg_param); 4320 4321 return QDF_STATUS_E_FAILURE; 4322 } 4323 4324 QDF_STATUS wmi_unified_extract_obss_detection_info(void *wmi_hdl, 4325 uint8_t *data, 4326 struct wmi_obss_detect_info 4327 *info) 4328 { 4329 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4330 4331 if (wmi_handle->ops->extract_obss_detection_info) 4332 return wmi_handle->ops->extract_obss_detection_info(data, info); 4333 4334 return QDF_STATUS_E_FAILURE; 4335 } 4336 4337 #ifdef WLAN_SUPPORT_GREEN_AP 4338 QDF_STATUS wmi_extract_green_ap_egap_status_info( 4339 void *wmi_hdl, uint8_t *evt_buf, 4340 struct wlan_green_ap_egap_status_info *egap_status_info_params) 4341 { 4342 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4343 4344 if (wmi_handle->ops->extract_green_ap_egap_status_info) 4345 return wmi_handle->ops->extract_green_ap_egap_status_info( 4346 evt_buf, egap_status_info_params); 4347 4348 return QDF_STATUS_E_FAILURE; 4349 } 4350 #endif 4351 4352 wmi_host_channel_width wmi_get_ch_width_from_phy_mode(void *wmi_hdl, 4353 WMI_HOST_WLAN_PHY_MODE phymode) 4354 { 4355 /* 4356 * this API does translation between host only strcutres, hence 4357 * does not need separate TLV, non-TLV definitions 4358 */ 4359 4360 if (phymode >= WMI_HOST_MODE_11A && phymode < WMI_HOST_MODE_MAX) 4361 return mode_to_width[phymode]; 4362 else 4363 return WMI_HOST_CHAN_WIDTH_20; 4364 } 4365 4366 #ifdef QCA_SUPPORT_CP_STATS 4367 QDF_STATUS wmi_extract_cca_stats(wmi_unified_t wmi_handle, void *evt_buf, 4368 struct wmi_host_congestion_stats *stats) 4369 { 4370 if (wmi_handle->ops->extract_cca_stats) 4371 return wmi_handle->ops->extract_cca_stats(wmi_handle, evt_buf, 4372 stats); 4373 4374 return QDF_STATUS_E_FAILURE; 4375 } 4376 #endif /* QCA_SUPPORT_CP_STATS */ 4377 4378 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 4379 QDF_STATUS 4380 wmi_unified_dfs_send_avg_params_cmd(void *wmi_hdl, 4381 struct dfs_radar_found_params *params) 4382 { 4383 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4384 4385 if (wmi_handle->ops->send_dfs_average_radar_params_cmd) 4386 return wmi_handle->ops->send_dfs_average_radar_params_cmd( 4387 wmi_handle, params); 4388 4389 return QDF_STATUS_E_FAILURE; 4390 } 4391 4392 QDF_STATUS wmi_extract_dfs_status_from_fw(void *wmi_hdl, void *evt_buf, 4393 uint32_t *dfs_status_check) 4394 { 4395 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4396 4397 if (wmi_handle->ops->extract_dfs_status_from_fw) 4398 return wmi_handle->ops->extract_dfs_status_from_fw(wmi_handle, 4399 evt_buf, dfs_status_check); 4400 4401 return QDF_STATUS_E_FAILURE; 4402 } 4403 #endif 4404 4405 #ifdef OL_ATH_SMART_LOGGING 4406 QDF_STATUS wmi_unified_send_smart_logging_enable_cmd(void *wmi_hdl, 4407 uint32_t param) 4408 { 4409 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4410 4411 if (wmi_handle->ops->send_smart_logging_enable_cmd) 4412 return wmi_handle->ops->send_smart_logging_enable_cmd( 4413 wmi_handle, 4414 param); 4415 4416 return QDF_STATUS_E_FAILURE; 4417 } 4418 4419 QDF_STATUS 4420 wmi_unified_send_smart_logging_fatal_cmd(void *wmi_hdl, 4421 struct wmi_debug_fatal_events *param) 4422 { 4423 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4424 4425 if (wmi_handle->ops->send_smart_logging_fatal_cmd) 4426 return wmi_handle->ops->send_smart_logging_fatal_cmd(wmi_handle, 4427 param); 4428 4429 return QDF_STATUS_E_FAILURE; 4430 } 4431 4432 QDF_STATUS wmi_extract_smartlog_ev(void *wmi_hdl, 4433 void *evt_buf, 4434 struct wmi_debug_fatal_events *ev) 4435 { 4436 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4437 4438 if (wmi->ops->extract_smartlog_event) 4439 return wmi->ops->extract_smartlog_event(wmi, evt_buf, ev); 4440 4441 return QDF_STATUS_E_FAILURE; 4442 } 4443 4444 qdf_export_symbol(wmi_extract_smartlog_ev); 4445 #endif /* OL_ATH_SMART_LOGGING */ 4446 4447 QDF_STATUS 4448 wmi_unified_send_roam_scan_stats_cmd(void *wmi_hdl, 4449 struct wmi_roam_scan_stats_req *params) 4450 { 4451 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4452 4453 if (wmi_handle->ops->send_roam_scan_stats_cmd) 4454 return wmi_handle->ops->send_roam_scan_stats_cmd(wmi_handle, 4455 params); 4456 4457 return QDF_STATUS_E_FAILURE; 4458 } 4459 4460 #ifdef CRYPTO_SET_KEY_CONVERGED 4461 uint8_t wlan_crypto_cipher_to_wmi_cipher( 4462 enum wlan_crypto_cipher_type crypto_cipher) 4463 { 4464 switch (crypto_cipher) { 4465 case WLAN_CRYPTO_CIPHER_NONE: 4466 return WMI_CIPHER_NONE; 4467 case WLAN_CRYPTO_CIPHER_WEP: 4468 return WMI_CIPHER_WEP; 4469 case WLAN_CRYPTO_CIPHER_TKIP: 4470 return WMI_CIPHER_TKIP; 4471 case WLAN_CRYPTO_CIPHER_WAPI_SMS4: 4472 case WLAN_CRYPTO_CIPHER_WAPI_GCM4: 4473 return WMI_CIPHER_WAPI; 4474 case WLAN_CRYPTO_CIPHER_AES_CCM: 4475 case WLAN_CRYPTO_CIPHER_AES_CCM_256: 4476 return WMI_CIPHER_AES_CCM; 4477 case WLAN_CRYPTO_CIPHER_AES_CMAC: 4478 return WMI_CIPHER_AES_CMAC; 4479 case WLAN_CRYPTO_CIPHER_AES_GMAC: 4480 case WLAN_CRYPTO_CIPHER_AES_GMAC_256: 4481 return WMI_CIPHER_AES_GMAC; 4482 case WLAN_CRYPTO_CIPHER_AES_GCM: 4483 case WLAN_CRYPTO_CIPHER_AES_GCM_256: 4484 return WMI_CIPHER_AES_GCM; 4485 default: 4486 return 0; 4487 } 4488 } 4489 4490 enum cdp_sec_type wlan_crypto_cipher_to_cdp_sec_type( 4491 enum wlan_crypto_cipher_type crypto_cipher) 4492 { 4493 switch (crypto_cipher) { 4494 case WLAN_CRYPTO_CIPHER_NONE: 4495 return cdp_sec_type_none; 4496 case WLAN_CRYPTO_CIPHER_WEP: 4497 return cdp_sec_type_wep104; 4498 case WLAN_CRYPTO_CIPHER_TKIP: 4499 return cdp_sec_type_tkip; 4500 case WLAN_CRYPTO_CIPHER_WAPI_SMS4: 4501 case WLAN_CRYPTO_CIPHER_WAPI_GCM4: 4502 return cdp_sec_type_wapi; 4503 case WLAN_CRYPTO_CIPHER_AES_CCM: 4504 return cdp_sec_type_aes_ccmp; 4505 case WLAN_CRYPTO_CIPHER_AES_CCM_256: 4506 return cdp_sec_type_aes_ccmp_256; 4507 case WLAN_CRYPTO_CIPHER_AES_GCM: 4508 return cdp_sec_type_aes_gcmp; 4509 case WLAN_CRYPTO_CIPHER_AES_GCM_256: 4510 return cdp_sec_type_aes_gcmp_256; 4511 default: 4512 return cdp_sec_type_none; 4513 } 4514 } 4515 #endif /* CRYPTO_SET_KEY_CONVERGED */ 4516 4517 QDF_STATUS 4518 wmi_extract_roam_scan_stats_res_evt(wmi_unified_t wmi, void *evt_buf, 4519 uint32_t *vdev_id, 4520 struct wmi_roam_scan_stats_res **res_param) 4521 { 4522 if (wmi->ops->extract_roam_scan_stats_res_evt) 4523 return wmi->ops->extract_roam_scan_stats_res_evt(wmi, 4524 evt_buf, 4525 vdev_id, res_param); 4526 4527 return QDF_STATUS_E_FAILURE; 4528 } 4529 4530 QDF_STATUS 4531 wmi_extract_offload_bcn_tx_status_evt(void *wmi_hdl, void *evt_buf, 4532 uint32_t *vdev_id, 4533 uint32_t *tx_status) { 4534 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4535 4536 if (wmi->ops->extract_offload_bcn_tx_status_evt) 4537 return wmi->ops->extract_offload_bcn_tx_status_evt(wmi, 4538 evt_buf, 4539 vdev_id, tx_status); 4540 4541 return QDF_STATUS_E_FAILURE; 4542 } 4543 4544 #ifdef OBSS_PD 4545 QDF_STATUS 4546 wmi_unified_send_obss_spatial_reuse_set_cmd(void *wmi_hdl, 4547 struct wmi_host_obss_spatial_reuse_set_param 4548 *obss_spatial_reuse_param) 4549 { 4550 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4551 4552 if (wmi->ops->send_obss_spatial_reuse_set) 4553 return wmi->ops->send_obss_spatial_reuse_set(wmi, 4554 obss_spatial_reuse_param); 4555 4556 return QDF_STATUS_E_FAILURE; 4557 } 4558 4559 QDF_STATUS 4560 wmi_unified_send_obss_spatial_reuse_set_def_thresh_cmd(void *wmi_hdl, 4561 struct wmi_host_obss_spatial_reuse_set_def_thresh *thresh) 4562 { 4563 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl; 4564 4565 if (wmi->ops->send_obss_spatial_reuse_set_def_thresh) 4566 return wmi->ops->send_obss_spatial_reuse_set_def_thresh(wmi, 4567 thresh); 4568 4569 return QDF_STATUS_E_FAILURE; 4570 } 4571 #endif 4572 4573 QDF_STATUS wmi_convert_pdev_id_host_to_target(void *wmi_hdl, 4574 uint32_t host_pdev_id, 4575 uint32_t *target_pdev_id) 4576 { 4577 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4578 4579 if (wmi_handle->ops->convert_pdev_id_host_to_target) { 4580 *target_pdev_id = 4581 wmi_handle->ops->convert_pdev_id_host_to_target( 4582 host_pdev_id); 4583 return QDF_STATUS_SUCCESS; 4584 } 4585 4586 return QDF_STATUS_E_FAILURE; 4587 } 4588 4589 QDF_STATUS wmi_unified_send_bss_color_change_enable_cmd(void *wmi_hdl, 4590 uint32_t vdev_id, 4591 bool enable) 4592 { 4593 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4594 4595 if (wmi_handle->ops->send_bss_color_change_enable_cmd) 4596 return wmi_handle->ops->send_bss_color_change_enable_cmd( 4597 wmi_handle, vdev_id, enable); 4598 4599 return QDF_STATUS_E_FAILURE; 4600 } 4601 4602 QDF_STATUS wmi_unified_send_obss_color_collision_cfg_cmd(void *wmi_hdl, 4603 struct wmi_obss_color_collision_cfg_param *cfg) 4604 { 4605 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4606 4607 if (wmi_handle->ops->send_obss_color_collision_cfg_cmd) 4608 return wmi_handle->ops->send_obss_color_collision_cfg_cmd( 4609 wmi_handle, cfg); 4610 4611 return QDF_STATUS_E_FAILURE; 4612 } 4613 4614 QDF_STATUS wmi_unified_extract_obss_color_collision_info(void *wmi_hdl, 4615 uint8_t *data, struct wmi_obss_color_collision_info *info) 4616 { 4617 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4618 4619 if (wmi_handle->ops->extract_obss_color_collision_info) 4620 return wmi_handle->ops->extract_obss_color_collision_info(data, 4621 info); 4622 4623 return QDF_STATUS_E_FAILURE; 4624 } 4625 4626 #ifdef WLAN_CFR_ENABLE 4627 QDF_STATUS wmi_unified_send_peer_cfr_capture_cmd(void *wmi_hdl, 4628 struct peer_cfr_params *param) 4629 { 4630 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl; 4631 4632 if (wmi_handle->ops->send_peer_cfr_capture_cmd) 4633 return wmi_handle->ops->send_peer_cfr_capture_cmd(wmi_hdl, 4634 param); 4635 4636 return QDF_STATUS_E_FAILURE; 4637 } 4638 #endif /* WLAN_CFR_ENABLE */ 4639