1 /* 2 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 /** 20 * DOC: declare UCFG APIs exposed by the mlme component 21 */ 22 23 #ifndef _WLAN_MLME_UCFG_API_H_ 24 #define _WLAN_MLME_UCFG_API_H_ 25 26 #include <wlan_mlme_public_struct.h> 27 #include <wlan_objmgr_psoc_obj.h> 28 #include <wlan_objmgr_global_obj.h> 29 #include <wlan_cmn.h> 30 #include <wlan_mlme_api.h> 31 #include <wlan_mlme_main.h> 32 #include "wma_tgt_cfg.h" 33 #include "wlan_mlme_vdev_mgr_interface.h" 34 35 /** 36 * ucfg_mlme_init() - initialize mlme_ctx context. 37 * 38 * This function initializes the mlme context. 39 * 40 * Return: QDF_STATUS_SUCCESS - in case of success else return error 41 */ 42 QDF_STATUS ucfg_mlme_init(void); 43 44 /** 45 * ucfg_mlme_deinit() - De initialize mlme_ctx context. 46 * 47 * This function De initializes mlme context. 48 * 49 * Return: QDF_STATUS_SUCCESS - in case of success else return error 50 */ 51 QDF_STATUS ucfg_mlme_deinit(void); 52 53 /** 54 * ucfg_mlme_psoc_open() - MLME component Open 55 * @psoc: pointer to psoc object 56 * 57 * Open the MLME component and initialize the MLME structure 58 * 59 * Return: QDF Status 60 */ 61 QDF_STATUS ucfg_mlme_psoc_open(struct wlan_objmgr_psoc *psoc); 62 63 /** 64 * ucfg_mlme_psoc_close() - MLME component close 65 * @psoc: pointer to psoc object 66 * 67 * Close the MLME component and clear the MLME structures 68 * 69 * Return: None 70 */ 71 void ucfg_mlme_psoc_close(struct wlan_objmgr_psoc *psoc); 72 73 /** 74 * ucfg_mlme_pdev_open() - MLME component pdev Open 75 * @pdev: pointer to pdev object 76 * 77 * Open the MLME component and initialize the MLME pdev structure 78 * 79 * Return: QDF Status 80 */ 81 QDF_STATUS ucfg_mlme_pdev_open(struct wlan_objmgr_pdev *pdev); 82 83 /** 84 * ucfg_mlme_set_ml_link_control_mode() - set ml_link_control_mode 85 * @psoc: pointer to psoc object 86 * @vdev_id: vdev id 87 * @value: value to set 88 * 89 * API get call when host receives vendor command 90 * QCA_NL80211_VENDOR_SUBCMD_MLO_LINK_STATE to configure link control mode. 91 * 92 * Return: none 93 */ 94 void ucfg_mlme_set_ml_link_control_mode(struct wlan_objmgr_psoc *psoc, 95 uint8_t vdev_id, uint8_t value); 96 97 /** 98 * ucfg_mlme_set_bt_profile_con() - set Bluetooth connection profile 99 * @psoc: Pointer to psoc object 100 * @bt_profile_con: Bluetooth connection profile indicator 101 * 102 * Return: None 103 */ 104 void ucfg_mlme_set_bt_profile_con(struct wlan_objmgr_psoc *psoc, 105 bool bt_profile_con); 106 /** 107 * ucfg_mlme_get_ml_link_control_mode() - get ml_link_control_mode 108 * @psoc: pointer to psoc object 109 * @vdev_id: vdev id 110 * 111 * Return: value of ml_link_control_mode in success 112 */ 113 uint8_t ucfg_mlme_get_ml_link_control_mode(struct wlan_objmgr_psoc *psoc, 114 uint8_t vdev_id); 115 116 /** 117 * ucfg_mlme_pdev_close() - MLME component pdev close 118 * @pdev: pointer to pdev object 119 * 120 * close the MLME pdev information 121 * 122 * Return: QDF Status 123 */ 124 QDF_STATUS ucfg_mlme_pdev_close(struct wlan_objmgr_pdev *pdev); 125 126 /** 127 * ucfg_mlme_global_init() - initialize global mlme ops and structure 128 * 129 * Return: QDF Status 130 */ 131 QDF_STATUS ucfg_mlme_global_init(void); 132 /** 133 * ucfg_mlme_global_deinit() - deinitialize global mlme ops and structure 134 * 135 * Return: QDF Status 136 */ 137 QDF_STATUS ucfg_mlme_global_deinit(void); 138 139 /** 140 * ucfg_mlme_cfg_chan_to_freq() - convert channel numbers to frequencies 141 * @pdev: pointer to pdev object 142 * 143 * convert the channels numbers received as part of cfg items to 144 * frequencies. 145 * 146 * Return: None 147 */ 148 void ucfg_mlme_cfg_chan_to_freq(struct wlan_objmgr_pdev *pdev); 149 150 /** 151 * ucfg_mlme_get_power_usage() - Get the power usage info 152 * @psoc: pointer to psoc object 153 * 154 * Return: pointer to character array of power usage 155 */ 156 static inline 157 char *ucfg_mlme_get_power_usage(struct wlan_objmgr_psoc *psoc) 158 { 159 return wlan_mlme_get_power_usage(psoc); 160 } 161 162 /** 163 * ucfg_get_tx_power() - Get the max tx power in particular band 164 * @psoc: pointer to psoc object 165 * @band: 2ghz/5ghz band 166 * 167 * Return: value of tx power in the respective band 168 */ 169 static inline 170 uint8_t ucfg_get_tx_power(struct wlan_objmgr_psoc *psoc, uint8_t band) 171 { 172 return wlan_mlme_get_tx_power(psoc, band); 173 } 174 175 /** 176 * ucfg_mlme_get_phy_max_freq_range() - Get phy supported max channel 177 * frequency range 178 * @psoc: psoc for country information 179 * @low_2ghz_chan: 2.4 GHz low channel frequency 180 * @high_2ghz_chan: 2.4 GHz high channel frequency 181 * @low_5ghz_chan: 5 GHz low channel frequency 182 * @high_5ghz_chan: 5 GHz high channel frequency 183 * 184 * Return: QDF status 185 */ 186 static inline 187 QDF_STATUS ucfg_mlme_get_phy_max_freq_range(struct wlan_objmgr_psoc *psoc, 188 uint32_t *low_2ghz_chan, 189 uint32_t *high_2ghz_chan, 190 uint32_t *low_5ghz_chan, 191 uint32_t *high_5ghz_chan) 192 { 193 return wlan_mlme_get_phy_max_freq_range(psoc, 194 low_2ghz_chan, 195 high_2ghz_chan, 196 low_5ghz_chan, 197 high_5ghz_chan); 198 } 199 200 /** 201 * ucfg_mlme_get_ht_cap_info() - Get the HT cap info config 202 * @psoc: pointer to psoc object 203 * @ht_cap_info: pointer to the value which will be filled for the caller 204 * 205 * Inline UCFG API to be used by HDD/OSIF callers 206 * 207 * Return: QDF Status 208 */ 209 static inline 210 QDF_STATUS ucfg_mlme_get_ht_cap_info(struct wlan_objmgr_psoc *psoc, 211 struct mlme_ht_capabilities_info 212 *ht_cap_info) 213 { 214 return wlan_mlme_get_ht_cap_info(psoc, ht_cap_info); 215 } 216 217 /** 218 * ucfg_mlme_set_ht_cap_info() - Set the HT cap info config 219 * @psoc: pointer to psoc object 220 * @ht_cap_info: Value that needs to be set from the caller 221 * 222 * Inline UCFG API to be used by HDD/OSIF callers 223 * 224 * Return: QDF Status 225 */ 226 static inline 227 QDF_STATUS ucfg_mlme_set_ht_cap_info(struct wlan_objmgr_psoc *psoc, 228 struct mlme_ht_capabilities_info 229 ht_cap_info) 230 { 231 return wlan_mlme_set_ht_cap_info(psoc, ht_cap_info); 232 } 233 234 /** 235 * ucfg_mlme_get_max_amsdu_num() - get the max amsdu num 236 * @psoc: pointer to psoc object 237 * @value: pointer to the value where the max_amsdu num is to be filled 238 * 239 * Return: QDF_STATUS 240 */ 241 static inline 242 QDF_STATUS ucfg_mlme_get_max_amsdu_num(struct wlan_objmgr_psoc *psoc, 243 uint8_t *value) 244 { 245 return wlan_mlme_get_max_amsdu_num(psoc, value); 246 } 247 248 /** 249 * ucfg_mlme_set_max_amsdu_num() - set the max amsdu num 250 * @psoc: pointer to psoc object 251 * @value: value to be set for max_amsdu_num 252 * 253 * Return: QDF_STATUS 254 */ 255 static inline 256 QDF_STATUS ucfg_mlme_set_max_amsdu_num(struct wlan_objmgr_psoc *psoc, 257 uint8_t value) 258 { 259 return wlan_mlme_set_max_amsdu_num(psoc, value); 260 } 261 262 /** 263 * ucfg_mlme_get_ht_mpdu_density() - get the ht mpdu density 264 * @psoc: pointer to psoc object 265 * @value: pointer to the value where the ht mpdu density is to be filled 266 * 267 * Return: QDF_STATUS 268 */ 269 static inline 270 QDF_STATUS ucfg_mlme_get_ht_mpdu_density(struct wlan_objmgr_psoc *psoc, 271 uint8_t *value) 272 { 273 return wlan_mlme_get_ht_mpdu_density(psoc, value); 274 } 275 276 /** 277 * ucfg_mlme_set_ht_mpdu_density() - set the ht mpdu density 278 * @psoc: pointer to psoc object 279 * @value: value to be set for ht mpdu density 280 * 281 * Return: QDF_STATUS 282 */ 283 static inline 284 QDF_STATUS ucfg_mlme_set_ht_mpdu_density(struct wlan_objmgr_psoc *psoc, 285 uint8_t value) 286 { 287 return wlan_mlme_set_ht_mpdu_density(psoc, value); 288 } 289 290 /** 291 * ucfg_mlme_get_band_capability() - Get the Band capability config 292 * @psoc: pointer to psoc object 293 * @band_capability: Pointer to the variable from caller 294 * 295 * Return: QDF Status 296 */ 297 static inline 298 QDF_STATUS ucfg_mlme_get_band_capability(struct wlan_objmgr_psoc *psoc, 299 uint32_t *band_capability) 300 { 301 return wlan_mlme_get_band_capability(psoc, band_capability); 302 } 303 304 /** 305 * ucfg_mlme_peer_config_vlan() - Send VLAN id to FW for 306 * RX packet 307 * @vdev: vdev pointer 308 * @macaddr: Peer mac address 309 * 310 * Return: QDF_STATUS 311 */ 312 static inline QDF_STATUS 313 ucfg_mlme_peer_config_vlan(struct wlan_objmgr_vdev *vdev, 314 uint8_t *macaddr) 315 { 316 return wlan_mlme_peer_config_vlan(vdev, macaddr); 317 } 318 319 /** 320 * ucfg_mlme_get_tdls_prohibited() - get if TDLS prohibited is advertised by 321 * the connected AP. 322 * @vdev: vdev pointer 323 * 324 * Return: bool 325 */ 326 static inline 327 bool ucfg_mlme_get_tdls_prohibited(struct wlan_objmgr_vdev *vdev) 328 { 329 return mlme_get_tdls_prohibited(vdev); 330 } 331 332 /** 333 * ucfg_mlme_get_tdls_chan_switch_prohibited() - get tdls chan switch prohibited 334 * @vdev: vdev pointer 335 * 336 * Return: bool 337 */ 338 static inline 339 bool ucfg_mlme_get_tdls_chan_switch_prohibited(struct wlan_objmgr_vdev *vdev) 340 { 341 return mlme_get_tdls_chan_switch_prohibited(vdev); 342 } 343 #ifdef MULTI_CLIENT_LL_SUPPORT 344 /** 345 * ucfg_mlme_get_wlm_multi_client_ll_caps() - Get multi client latency level 346 * capability of FW 347 * @psoc: pointer to psoc object 348 * 349 * Return: true if multi client feature supported 350 */ 351 bool ucfg_mlme_get_wlm_multi_client_ll_caps(struct wlan_objmgr_psoc *psoc); 352 353 /** 354 * ucfg_mlme_cfg_get_multi_client_ll_ini_support() - Get multi client latency 355 * level ini support value 356 * @psoc: pointer to psoc object 357 * @multi_client_ll_support: parameter that needs to be filled 358 * 359 * Return: QDF Status 360 */ 361 QDF_STATUS 362 ucfg_mlme_cfg_get_multi_client_ll_ini_support(struct wlan_objmgr_psoc *psoc, 363 bool *multi_client_ll_support); 364 #else 365 static inline 366 bool ucfg_mlme_get_wlm_multi_client_ll_caps(struct wlan_objmgr_psoc *psoc) 367 { 368 return false; 369 } 370 371 static inline QDF_STATUS 372 ucfg_mlme_cfg_get_multi_client_ll_ini_support(struct wlan_objmgr_psoc *psoc, 373 bool *multi_client_ll_support) 374 { 375 return QDF_STATUS_E_FAILURE; 376 } 377 #endif 378 379 /** 380 * ucfg_mlme_set_band_capability() - Set the Band capability config 381 * @psoc: pointer to psoc object 382 * @band_capability: Value to be set from the caller 383 * 384 * Return: QDF Status 385 */ 386 static inline 387 QDF_STATUS ucfg_mlme_set_band_capability(struct wlan_objmgr_psoc *psoc, 388 uint32_t band_capability) 389 { 390 return wlan_mlme_set_band_capability(psoc, band_capability); 391 } 392 393 #ifdef WLAN_VENDOR_HANDOFF_CONTROL 394 /** 395 * ucfg_mlme_get_vendor_handoff_control_caps() - Get vendor handoff control 396 * capability of FW 397 * @psoc: pointer to psoc object 398 * 399 * Return: true if vendor handoff feature supported 400 */ 401 bool ucfg_mlme_get_vendor_handoff_control_caps(struct wlan_objmgr_psoc *psoc); 402 #else 403 static inline 404 bool ucfg_mlme_get_vendor_handoff_control_caps(struct wlan_objmgr_psoc *psoc) 405 { 406 return false; 407 } 408 #endif 409 410 /** 411 * ucfg_mlme_set_dual_sta_policy() - Configures the Concurrent STA policy 412 * value 413 * @psoc: pointer to psoc object 414 * @dual_sta_config: Concurrent STA policy configuration value 415 * 416 * Return: QDF Status 417 */ 418 static inline 419 QDF_STATUS ucfg_mlme_set_dual_sta_policy(struct wlan_objmgr_psoc *psoc, 420 uint8_t dual_sta_config) 421 { 422 return wlan_mlme_set_dual_sta_policy(psoc, dual_sta_config); 423 } 424 425 /** 426 * ucfg_mlme_get_dual_sta_policy() - Get the Concurrent STA policy value 427 * @psoc: pointer to psoc object 428 * @dual_sta_config: Pointer to the variable from caller 429 * 430 * Return: QDF Status 431 */ 432 static inline 433 QDF_STATUS ucfg_mlme_get_dual_sta_policy(struct wlan_objmgr_psoc *psoc, 434 uint8_t *dual_sta_config) 435 { 436 return wlan_mlme_get_dual_sta_policy(psoc, dual_sta_config); 437 } 438 439 /** 440 * ucfg_mlme_set_ap_policy() - Configures the AP policy value 441 * @vdev: pointer to vdev object 442 * @ap_cfg_policy: AP policy configuration value 443 * 444 * Return: QDF Status 445 */ 446 static inline 447 QDF_STATUS ucfg_mlme_set_ap_policy(struct wlan_objmgr_vdev *vdev, 448 enum host_concurrent_ap_policy ap_cfg_policy) 449 { 450 return wlan_mlme_set_ap_policy(vdev, ap_cfg_policy); 451 } 452 453 /** 454 * ucfg_mlme_get_ap_policy() - Get the AP policy value 455 * @vdev: pointer to vdev object 456 * 457 * Return: enum host_concurrent_ap_policy 458 */ 459 static inline enum host_concurrent_ap_policy 460 ucfg_mlme_get_ap_policy(struct wlan_objmgr_vdev *vdev) 461 { 462 return wlan_mlme_get_ap_policy(vdev); 463 } 464 465 /** 466 * ucfg_mlme_get_prevent_link_down() - Get the prevent link down config 467 * @psoc: pointer to psoc object 468 * @prevent_link_down: Pointer to the variable from caller 469 * 470 * Return: QDF Status 471 */ 472 static inline 473 QDF_STATUS ucfg_mlme_get_prevent_link_down(struct wlan_objmgr_psoc *psoc, 474 bool *prevent_link_down) 475 { 476 return wlan_mlme_get_prevent_link_down(psoc, prevent_link_down); 477 } 478 479 /** 480 * ucfg_mlme_get_select_5ghz_margin() - Get the select 5Ghz margin config 481 * @psoc: pointer to psoc object 482 * @select_5ghz_margin: Pointer to the variable from caller 483 * 484 * Return: QDF Status 485 */ 486 static inline 487 QDF_STATUS ucfg_mlme_get_select_5ghz_margin(struct wlan_objmgr_psoc *psoc, 488 uint8_t *select_5ghz_margin) 489 { 490 return wlan_mlme_get_select_5ghz_margin(psoc, select_5ghz_margin); 491 } 492 493 /** 494 * ucfg_mlme_get_rtt_mac_randomization() - Get the RTT MAC randomization config 495 * @psoc: pointer to psoc object 496 * @rtt_mac_randomization: Pointer to the variable from caller 497 * 498 * Return: QDF Status 499 */ 500 static inline 501 QDF_STATUS ucfg_mlme_get_rtt_mac_randomization(struct wlan_objmgr_psoc *psoc, 502 bool *rtt_mac_randomization) 503 { 504 return wlan_mlme_get_rtt_mac_randomization(psoc, rtt_mac_randomization); 505 } 506 507 /** 508 * ucfg_mlme_get_crash_inject() - Get the crash inject config 509 * @psoc: pointer to psoc object 510 * @crash_inject: Pointer to the variable from caller 511 * 512 * Return: QDF Status 513 */ 514 static inline 515 QDF_STATUS ucfg_mlme_get_crash_inject(struct wlan_objmgr_psoc *psoc, 516 bool *crash_inject) 517 { 518 return wlan_mlme_get_crash_inject(psoc, crash_inject); 519 } 520 521 /** 522 * ucfg_mlme_get_lpass_support() - Get the LPASS Support config 523 * @psoc: pointer to psoc object 524 * @lpass_support: Pointer to the variable from caller 525 * 526 * Return: QDF Status 527 */ 528 static inline 529 QDF_STATUS ucfg_mlme_get_lpass_support(struct wlan_objmgr_psoc *psoc, 530 bool *lpass_support) 531 { 532 return wlan_mlme_get_lpass_support(psoc, lpass_support); 533 } 534 535 /** 536 * ucfg_mlme_get_wls_6ghz_cap() - Get the WiFi Location Service(WLS) 537 * 6ghz capability 538 * @psoc: pointer to psoc object 539 * @wls_6ghz_capable: Pointer to the variable from caller 540 * 541 * Return: void 542 */ 543 static inline 544 void ucfg_mlme_get_wls_6ghz_cap(struct wlan_objmgr_psoc *psoc, 545 bool *wls_6ghz_capable) 546 { 547 wlan_mlme_get_wls_6ghz_cap(psoc, wls_6ghz_capable); 548 } 549 550 /** 551 * ucfg_mlme_get_self_recovery() - Get the self recovery config 552 * @psoc: pointer to psoc object 553 * @self_recovery: Pointer to the variable from caller 554 * 555 * Return: QDF Status 556 */ 557 static inline 558 QDF_STATUS ucfg_mlme_get_self_recovery(struct wlan_objmgr_psoc *psoc, 559 bool *self_recovery) 560 { 561 return wlan_mlme_get_self_recovery(psoc, self_recovery); 562 } 563 564 /** 565 * ucfg_mlme_get_sub_20_chan_width() - Get the sub 20 chan width config 566 * @psoc: pointer to psoc object 567 * @sub_20_chan_width: Pointer to the variable from caller 568 * 569 * Return: QDF Status 570 */ 571 static inline 572 QDF_STATUS ucfg_mlme_get_sub_20_chan_width(struct wlan_objmgr_psoc *psoc, 573 uint8_t *sub_20_chan_width) 574 { 575 return wlan_mlme_get_sub_20_chan_width(psoc, sub_20_chan_width); 576 } 577 578 /** 579 * ucfg_mlme_get_fw_timeout_crash() - Get the fw timeout crash config 580 * @psoc: pointer to psoc object 581 * @fw_timeout_crash: Pointer to the variable from caller 582 * 583 * Return: QDF Status 584 */ 585 static inline 586 QDF_STATUS ucfg_mlme_get_fw_timeout_crash(struct wlan_objmgr_psoc *psoc, 587 bool *fw_timeout_crash) 588 { 589 return wlan_mlme_get_fw_timeout_crash(psoc, fw_timeout_crash); 590 } 591 592 /** 593 * ucfg_mlme_get_ito_repeat_count() - Get the fw timeout crash config 594 * @psoc: pointer to psoc object 595 * @ito_repeat_count: Pointer to the variable from caller 596 * 597 * Return: QDF Status 598 */ 599 static inline 600 QDF_STATUS ucfg_mlme_get_ito_repeat_count(struct wlan_objmgr_psoc *psoc, 601 uint8_t *ito_repeat_count) 602 { 603 return wlan_mlme_get_ito_repeat_count(psoc, ito_repeat_count); 604 } 605 606 /** 607 * ucfg_mlme_get_acs_with_more_param() - Get the flag for acs with 608 * more param 609 * @psoc: pointer to psoc object 610 * @value: Value that needs to be set from the caller 611 * 612 * Inline UCFG API to be used by HDD/OSIF callers 613 * 614 * Return: QDF Status 615 */ 616 static inline 617 QDF_STATUS ucfg_mlme_get_acs_with_more_param(struct wlan_objmgr_psoc *psoc, 618 bool *value) 619 { 620 return wlan_mlme_get_acs_with_more_param(psoc, value); 621 } 622 623 /** 624 * ucfg_mlme_get_auto_channel_weight() - Get the auto channel select weight 625 * @psoc: pointer to psoc object 626 * @value: Value that needs to be set from the caller 627 * 628 * Inline UCFG API to be used by HDD/OSIF callers 629 * 630 * Return: QDF Status 631 */ 632 static inline 633 QDF_STATUS ucfg_mlme_get_auto_channel_weight(struct wlan_objmgr_psoc *psoc, 634 uint32_t *value) 635 { 636 return wlan_mlme_get_auto_channel_weight(psoc, value); 637 } 638 639 /** 640 * ucfg_mlme_get_vendor_acs_support() - Get the flag for 641 * vendor acs support 642 * @psoc: pointer to psoc object 643 * @value: Value that needs to be set from the caller 644 * 645 * Inline UCFG API to be used by HDD/OSIF callers 646 * 647 * Return: QDF Status 648 */ 649 static inline 650 QDF_STATUS ucfg_mlme_get_vendor_acs_support(struct wlan_objmgr_psoc *psoc, 651 bool *value) 652 { 653 return wlan_mlme_get_vendor_acs_support(psoc, value); 654 } 655 656 /** 657 * ucfg_mlme_get_external_acs_policy() - Get flag for external control 658 * acs policy 659 * @psoc: pointer to psoc object 660 * @value: Value that needs to be set from the caller 661 * 662 * Inline UCFG API to be used by HDD/OSIF callers 663 * 664 * Return: QDF Status 665 */ 666 static inline QDF_STATUS 667 ucfg_mlme_get_external_acs_policy(struct wlan_objmgr_psoc *psoc, 668 bool *value) 669 { 670 return wlan_mlme_get_external_acs_policy(psoc, value); 671 } 672 673 /** 674 * ucfg_mlme_get_acs_support_for_dfs_ltecoex() - Is DFS LTE CoEx ACS supported 675 * @psoc: pointer to psoc object 676 * @value: Value that needs to be set from the caller 677 * 678 * Inline UCFG API to be used by HDD/OSIF callers 679 * 680 * Return: QDF Status 681 */ 682 static inline 683 QDF_STATUS 684 ucfg_mlme_get_acs_support_for_dfs_ltecoex(struct wlan_objmgr_psoc *psoc, 685 bool *value) 686 { 687 return wlan_mlme_get_acs_support_for_dfs_ltecoex(psoc, value); 688 } 689 690 /** 691 * ucfg_mlme_get_wmm_dir_ac_vo() - Get TSPEC direction for VO 692 * @psoc: pointer to psoc object 693 * @value: Value that needs to be set from the caller 694 * 695 * Inline UCFG API to be used by HDD/OSIF callers 696 * 697 * Return: QDF Status 698 */ 699 static inline QDF_STATUS 700 ucfg_mlme_get_wmm_dir_ac_vo(struct wlan_objmgr_psoc *psoc, 701 uint8_t *value) 702 { 703 return wlan_mlme_get_wmm_dir_ac_vo(psoc, value); 704 } 705 706 /** 707 * ucfg_mlme_get_wmm_nom_msdu_size_ac_vo() - Get normal 708 * MSDU size for VO 709 * @psoc: pointer to psoc object 710 * @value: Value that needs to be set from the caller 711 * 712 * Inline UCFG API to be used by HDD/OSIF callers 713 * 714 * Return: QDF Status 715 */ 716 static inline QDF_STATUS 717 ucfg_mlme_get_wmm_nom_msdu_size_ac_vo(struct wlan_objmgr_psoc *psoc, 718 uint16_t *value) 719 { 720 return wlan_mlme_get_wmm_nom_msdu_size_ac_vo(psoc, value); 721 } 722 723 /** 724 * ucfg_mlme_get_wmm_mean_data_rate_ac_vo() - mean data rate for VO 725 * @psoc: pointer to psoc object 726 * @value: Value that needs to be set from the caller 727 * 728 * Inline UCFG API to be used by HDD/OSIF callers 729 * 730 * Return: QDF Status 731 */ 732 static inline QDF_STATUS 733 ucfg_mlme_get_wmm_mean_data_rate_ac_vo(struct wlan_objmgr_psoc *psoc, 734 uint32_t *value) 735 { 736 return wlan_mlme_get_wmm_mean_data_rate_ac_vo(psoc, value); 737 } 738 739 /** 740 * ucfg_mlme_get_wmm_min_phy_rate_ac_vo() - min PHY 741 * rate for VO 742 * @psoc: pointer to psoc object 743 * @value: Value that needs to be set from the caller 744 * 745 * Inline UCFG API to be used by HDD/OSIF callers 746 * 747 * Return: QDF Status 748 */ 749 static inline QDF_STATUS 750 ucfg_mlme_get_wmm_min_phy_rate_ac_vo(struct wlan_objmgr_psoc *psoc, 751 uint32_t *value) 752 { 753 return wlan_mlme_get_wmm_min_phy_rate_ac_vo(psoc, value); 754 } 755 756 /** 757 * ucfg_mlme_get_wmm_sba_ac_vo() - surplus bandwidth 758 * allowance for VO 759 * @psoc: pointer to psoc object 760 * @value: Value that needs to be set from the caller 761 * 762 * Inline UCFG API to be used by HDD/OSIF callers 763 * 764 * Return: QDF Status 765 */ 766 static inline QDF_STATUS 767 ucfg_mlme_get_wmm_sba_ac_vo(struct wlan_objmgr_psoc *psoc, 768 uint16_t *value) 769 { 770 return wlan_mlme_get_wmm_sba_ac_vo(psoc, value); 771 } 772 773 /** 774 * ucfg_mlme_get_wmm_uapsd_vo_srv_intv() - Get Uapsd service 775 * interval for voice 776 * @psoc: pointer to psoc object 777 * @value: pointer to the value which will be filled for the caller 778 * 779 * Inline UCFG API to be used by HDD/OSIF callers 780 * 781 * Return: QDF Status 782 */ 783 static inline QDF_STATUS 784 ucfg_mlme_get_wmm_uapsd_vo_srv_intv(struct wlan_objmgr_psoc *psoc, 785 uint32_t *value) 786 { 787 return wlan_mlme_get_wmm_uapsd_vo_srv_intv(psoc, value); 788 } 789 790 /** 791 * ucfg_mlme_get_wmm_uapsd_vo_sus_intv() - Get Uapsd suspension 792 * interval for voice 793 * @psoc: pointer to psoc object 794 * @value: Value that needs to be set from the caller 795 * 796 * Inline UCFG API to be used by HDD/OSIF callers 797 * 798 * Return: QDF Status 799 */ 800 static inline QDF_STATUS 801 ucfg_mlme_get_wmm_uapsd_vo_sus_intv(struct wlan_objmgr_psoc *psoc, 802 uint32_t *value) 803 { 804 return wlan_mlme_get_wmm_uapsd_vo_sus_intv(psoc, value); 805 } 806 807 /** 808 * ucfg_mlme_get_sap_inactivity_override() - Check if sap max inactivity 809 * override flag is set. 810 * @psoc: pointer to psoc object 811 * @value: Value that needs to be set from the caller 812 * 813 * Inline UCFG API to be used by HDD/OSIF callers to call 814 * the mlme function wlan_mlme_get_sap_inactivity_override 815 * 816 * Return: QDF Status 817 */ 818 static inline 819 void ucfg_mlme_get_sap_inactivity_override(struct wlan_objmgr_psoc *psoc, 820 bool *value) 821 { 822 wlan_mlme_get_sap_inactivity_override(psoc, value); 823 } 824 825 /** 826 * ucfg_mlme_get_tx_chainmask_1ss() - Get the tx_chainmask_1ss value 827 * 828 * @psoc: pointer to psoc object 829 * @value: Value that needs to be set from the caller 830 * 831 * Return: QDF_STATUS_FAILURE or QDF_STATUS_SUCCESS 832 */ 833 static inline 834 QDF_STATUS ucfg_mlme_get_tx_chainmask_1ss(struct wlan_objmgr_psoc *psoc, 835 uint8_t *value) 836 { 837 return wlan_mlme_get_tx_chainmask_1ss(psoc, value); 838 } 839 840 /** 841 * ucfg_mlme_get_num_11b_tx_chains() - Get the number of 11b only tx chains 842 * 843 * @psoc: pointer to psoc object 844 * @value: Value that needs to be set from the caller 845 * 846 * Return: QDF_STATUS_FAILURE or QDF_STATUS_SUCCESS 847 */ 848 static inline 849 QDF_STATUS ucfg_mlme_get_num_11b_tx_chains(struct wlan_objmgr_psoc *psoc, 850 uint16_t *value) 851 { 852 return wlan_mlme_get_num_11b_tx_chains(psoc, value); 853 } 854 855 /** 856 * ucfg_mlme_get_num_11ag_tx_chains() - get the total number of 11a/g tx chains 857 * 858 * @psoc: pointer to psoc object 859 * @value: Value that needs to be set from the caller 860 * 861 * Return: QDF_STATUS_FAILURE or QDF_STATUS_SUCCESS 862 */ 863 static inline 864 QDF_STATUS ucfg_mlme_get_num_11ag_tx_chains(struct wlan_objmgr_psoc *psoc, 865 uint16_t *value) 866 { 867 return wlan_mlme_get_num_11ag_tx_chains(psoc, value); 868 } 869 870 /** 871 * ucfg_mlme_get_bt_chain_separation_flag() - bt chain separation enable/disable 872 * @psoc: pointer to psoc object 873 * @value: Value that needs to be got for the caller 874 * 875 * Return: QDF_STATUS_FAILURE or QDF_STATUS_SUCCESS 876 */ 877 static inline 878 QDF_STATUS ucfg_mlme_get_bt_chain_separation_flag(struct wlan_objmgr_psoc *psoc, 879 bool *value) 880 { 881 return wlan_mlme_get_bt_chain_separation_flag(psoc, value); 882 } 883 884 /** 885 * ucfg_mlme_configure_chain_mask() - configure chainmask parameters 886 * 887 * @psoc: pointer to psoc object 888 * @session_id: vdev_id 889 * 890 * Return: QDF_STATUS_FAILURE or QDF_STATUS_SUCCESS 891 */ 892 static inline 893 QDF_STATUS ucfg_mlme_configure_chain_mask(struct wlan_objmgr_psoc *psoc, 894 uint8_t session_id) 895 { 896 return wlan_mlme_configure_chain_mask(psoc, session_id); 897 } 898 899 /** 900 * ucfg_mlme_is_chain_mask_supported() - check if configure chainmask can 901 * be supported 902 * @psoc: pointer to psoc object 903 * 904 * Return: true if supported else false 905 */ 906 static inline 907 bool ucfg_mlme_is_chain_mask_supported(struct wlan_objmgr_psoc *psoc) 908 { 909 return wlan_mlme_is_chain_mask_supported(psoc); 910 } 911 912 /* 913 * ucfg_mlme_get_sta_keep_alive_period() - Get the sta keep alive period 914 * @psoc: pointer to psoc object 915 * @val: Pointer to the value which will be filled for the caller 916 * 917 * Return: QDF Status 918 */ 919 QDF_STATUS 920 ucfg_mlme_get_sta_keep_alive_period(struct wlan_objmgr_psoc *psoc, 921 uint32_t *val); 922 923 /* 924 * ucfg_mlme_get_dfs_master_capability() - Get the dfs master capability 925 * @psoc: pointer to psoc object 926 * @val: Pointer to the value which will be filled for the caller 927 * 928 * Return: QDF Status 929 */ 930 QDF_STATUS 931 ucfg_mlme_get_dfs_master_capability(struct wlan_objmgr_psoc *psoc, 932 bool *val); 933 934 /* 935 * ucfg_mlme_get_dfs_disable_channel_switch() - Get the dfs channel switch 936 * @psoc: pointer to psoc object 937 * @dfs_disable_channel_switch: Pointer to the value which will be filled 938 * 939 * Return: QDF Status 940 */ 941 QDF_STATUS 942 ucfg_mlme_get_dfs_disable_channel_switch(struct wlan_objmgr_psoc *psoc, 943 bool *dfs_disable_channel_switch); 944 945 /* 946 * ucfg_mlme_set_dfs_disable_channel_switch() - Set the dfs channel switch 947 * @psoc: pointer to psoc object 948 * @dfs_disable_channel_switch: Value that needs to be set. 949 * 950 * Return: QDF Status 951 */ 952 QDF_STATUS 953 ucfg_mlme_set_dfs_disable_channel_switch(struct wlan_objmgr_psoc *psoc, 954 bool dfs_disable_channel_switch); 955 /* 956 * ucfg_mlme_get_dfs_ignore_cac() - GSet the dfs ignore cac 957 * @psoc: pointer to psoc object 958 * @dfs_ignore_cac: Pointer to the value which will be filled for the caller 959 * 960 * Return: QDF Status 961 */ 962 QDF_STATUS 963 ucfg_mlme_get_dfs_ignore_cac(struct wlan_objmgr_psoc *psoc, 964 bool *dfs_ignore_cac); 965 966 /* 967 * ucfg_mlme_set_dfs_ignore_cac() - Set the dfs ignore cac 968 * @psoc: pointer to psoc object 969 * @dfs_ignore_cac: Value that needs to be set. 970 * 971 * Return: QDF Status 972 */ 973 QDF_STATUS 974 ucfg_mlme_set_dfs_ignore_cac(struct wlan_objmgr_psoc *psoc, 975 bool dfs_ignore_cac); 976 977 /* 978 * ucfg_mlme_get_sap_tx_leakage_threshold() - Get sap tx leakage threshold 979 * @psoc: pointer to psoc object 980 * @sap_tx_leakage_threshold: Pointer to the value which will be filled 981 * 982 * Return: QDF Status 983 */ 984 QDF_STATUS 985 ucfg_mlme_get_sap_tx_leakage_threshold(struct wlan_objmgr_psoc *psoc, 986 uint32_t *sap_tx_leakage_threshold); 987 988 /* 989 * ucfg_mlme_set_sap_tx_leakage_threshold() - Set sap tx leakage threshold 990 * @psoc: pointer to psoc object 991 * @sap_tx_leakage_threshold: Value that needs to be set. 992 * 993 * Return: QDF Status 994 */ 995 QDF_STATUS 996 ucfg_mlme_set_sap_tx_leakage_threshold(struct wlan_objmgr_psoc *psoc, 997 uint32_t sap_tx_leakage_threshold); 998 999 /* 1000 * ucfg_mlme_get_dfs_pri_multiplier() - Get dfs pri multiplier 1001 * @psoc: pointer to psoc object 1002 * @dfs_pri_multiplier: Pointer to the value which will be filled 1003 * 1004 * Return: QDF Status 1005 */ 1006 QDF_STATUS 1007 ucfg_mlme_get_dfs_pri_multiplier(struct wlan_objmgr_psoc *psoc, 1008 uint32_t *dfs_pri_multiplier); 1009 1010 /* 1011 * ucfg_mlme_set_dfs_pri_multiplier() - Set dfs pri multiplier 1012 * @psoc: pointer to psoc object 1013 * @dfs_pri_multiplier: Value that needs to be set. 1014 * 1015 * Return: QDF Status 1016 */ 1017 QDF_STATUS 1018 ucfg_mlme_set_dfs_pri_multiplier(struct wlan_objmgr_psoc *psoc, 1019 uint32_t dfs_pri_multiplier); 1020 1021 /* 1022 * ucfg_mlme_get_dfs_filter_offload() - Get the dfs filter offload 1023 * @psoc: pointer to psoc object 1024 * @dfs_filter_offload: Pointer to the value which will be filled 1025 * 1026 * Return: QDF Status 1027 */ 1028 QDF_STATUS 1029 ucfg_mlme_get_dfs_filter_offload(struct wlan_objmgr_psoc *psoc, 1030 bool *dfs_filter_offload); 1031 1032 /* 1033 * ucfg_mlme_set_dfs_filter_offload() - Set the dfs filter offload 1034 * @psoc: pointer to psoc object 1035 * @dfs_filter_offload: Value that needs to be set. 1036 * 1037 * Return: QDF Status 1038 */ 1039 QDF_STATUS 1040 ucfg_mlme_set_dfs_filter_offload(struct wlan_objmgr_psoc *psoc, 1041 bool dfs_filter_offload); 1042 1043 /** 1044 * ucfg_mlme_get_oem_6g_supported() - Get oem 6Ghz supported 1045 * @psoc: pointer to psoc object 1046 * @oem_6g_supported: Pointer to the value which will be filled for the caller 1047 * 1048 * Return: QDF Status 1049 */ 1050 QDF_STATUS 1051 ucfg_mlme_get_oem_6g_supported(struct wlan_objmgr_psoc *psoc, 1052 bool *oem_6g_supported); 1053 1054 /** 1055 * ucfg_mlme_get_fine_time_meas_cap() - Get fine timing measurement capability 1056 * @psoc: pointer to psoc object 1057 * @fine_time_meas_cap: Pointer to the value which will be filled for the caller 1058 * 1059 * Return: QDF Status 1060 */ 1061 QDF_STATUS 1062 ucfg_mlme_get_fine_time_meas_cap(struct wlan_objmgr_psoc *psoc, 1063 uint32_t *fine_time_meas_cap); 1064 1065 /** 1066 * ucfg_mlme_set_fine_time_meas_cap() - Set fine timing measurement capability 1067 * @psoc: pointer to psoc object 1068 * @fine_time_meas_cap: Value to be set 1069 * 1070 * Return: QDF Status 1071 */ 1072 QDF_STATUS 1073 ucfg_mlme_set_fine_time_meas_cap(struct wlan_objmgr_psoc *psoc, 1074 uint32_t fine_time_meas_cap); 1075 1076 /** 1077 * ucfg_mlme_get_pmkid_modes() - Get PMKID modes 1078 * @psoc: pointer to psoc object 1079 * @val: Pointer to the value which will be filled for the caller 1080 * 1081 * Return: QDF Status 1082 */ 1083 QDF_STATUS 1084 ucfg_mlme_get_pmkid_modes(struct wlan_objmgr_psoc *psoc, 1085 uint32_t *val); 1086 1087 /** 1088 * ucfg_mlme_set_pmkid_modes() - Set PMKID modes 1089 * @psoc: pointer to psoc object 1090 * @val: Pointer to the value which will be filled for the caller 1091 * 1092 * Return: QDF Status 1093 */ 1094 QDF_STATUS 1095 ucfg_mlme_set_pmkid_modes(struct wlan_objmgr_psoc *psoc, 1096 uint32_t val); 1097 1098 /** 1099 * ucfg_mlme_get_dot11p_mode() - Get the setting about 802.11p mode 1100 * @psoc: pointer to psoc object 1101 * @out_mode: Pointer to the mode which will be filled for the caller 1102 * 1103 * Return: QDF Status 1104 */ 1105 QDF_STATUS 1106 ucfg_mlme_get_dot11p_mode(struct wlan_objmgr_psoc *psoc, 1107 enum dot11p_mode *out_mode); 1108 1109 /** 1110 * ucfg_mlme_get_go_cts2self_for_sta() - Stop NOA and start using cts2self 1111 * @psoc: pointer to psoc object 1112 * @val: Pointer to the value which will be filled for the caller 1113 * 1114 * Return: QDF Status 1115 */ 1116 QDF_STATUS 1117 ucfg_mlme_get_go_cts2self_for_sta(struct wlan_objmgr_psoc *psoc, 1118 bool *val); 1119 1120 /** 1121 * ucfg_mlme_get_qcn_ie_support() - QCN IE support or not 1122 * @psoc: pointer to psoc object 1123 * @val: Pointer to the value which will be filled for the caller 1124 * 1125 * Return: QDF Status 1126 */ 1127 QDF_STATUS 1128 ucfg_mlme_get_qcn_ie_support(struct wlan_objmgr_psoc *psoc, 1129 bool *val); 1130 1131 /** 1132 * ucfg_mlme_get_tgt_gtx_usr_cfg() - Get the target gtx user config 1133 * @psoc: pointer to psoc object 1134 * @val: Pointer to the value which will be filled for the caller 1135 * 1136 * Return: QDF Status 1137 */ 1138 QDF_STATUS 1139 ucfg_mlme_get_tgt_gtx_usr_cfg(struct wlan_objmgr_psoc *psoc, 1140 uint32_t *val); 1141 1142 /** 1143 * ucfg_mlme_is_override_ht20_40_24g() - use channel bonding in 2.4 GHz or not 1144 * @psoc: pointer to psoc object 1145 * @val: Pointer to the value which will be filled for the caller 1146 * 1147 * Return: QDF Status 1148 */ 1149 QDF_STATUS 1150 ucfg_mlme_is_override_ht20_40_24g(struct wlan_objmgr_psoc *psoc, bool *val); 1151 1152 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 1153 /** 1154 * ucfg_mlme_get_roam_disable_config() - Get sta roam disable value 1155 * @psoc: pointer to psoc object 1156 * @val: Pointer to bitmap of interfaces for those sta roaming is disabled 1157 * 1158 * Return: QDF Status 1159 */ 1160 QDF_STATUS 1161 ucfg_mlme_get_roam_disable_config(struct wlan_objmgr_psoc *psoc, 1162 uint32_t *val); 1163 1164 /** 1165 * ucfg_mlme_get_roaming_offload() - Get roaming offload setting 1166 * @psoc: pointer to psoc object 1167 * @val: Pointer to enable/disable roaming offload 1168 * 1169 * Return: QDF Status 1170 */ 1171 QDF_STATUS 1172 ucfg_mlme_get_roaming_offload(struct wlan_objmgr_psoc *psoc, 1173 bool *val); 1174 1175 /** 1176 * ucfg_mlme_set_roaming_offload() - Enable/disable roaming offload 1177 * @psoc: pointer to psoc object 1178 * @val: enable/disable roaming offload 1179 * 1180 * Return: QDF Status 1181 */ 1182 QDF_STATUS 1183 ucfg_mlme_set_roaming_offload(struct wlan_objmgr_psoc *psoc, 1184 bool val); 1185 1186 /** 1187 * ucfg_mlme_get_roaming_triggers() - Get roaming triggers bitmap 1188 * value 1189 * @psoc: pointer to psoc object 1190 * 1191 * Return: Roaming triggers value 1192 */ 1193 static inline uint32_t 1194 ucfg_mlme_get_roaming_triggers(struct wlan_objmgr_psoc *psoc) 1195 { 1196 return wlan_mlme_get_roaming_triggers(psoc); 1197 } 1198 1199 /** 1200 * ucfg_mlme_set_roaming_triggers() - Set roaming triggers bitmap 1201 * value 1202 * @psoc: pointer to psoc object 1203 * @trigger_bitmap: Roaming triggers bitmap to set 1204 * 1205 * Return: void 1206 */ 1207 static inline void 1208 ucfg_mlme_set_roaming_triggers(struct wlan_objmgr_psoc *psoc, 1209 uint32_t trigger_bitmap) 1210 { 1211 wlan_mlme_set_roaming_triggers(psoc, trigger_bitmap); 1212 } 1213 #else 1214 static inline QDF_STATUS 1215 ucfg_mlme_get_roam_disable_config(struct wlan_objmgr_psoc *psoc, 1216 uint32_t *val) 1217 { 1218 return QDF_STATUS_E_FAILURE; 1219 } 1220 1221 static inline QDF_STATUS 1222 ucfg_mlme_get_roaming_offload(struct wlan_objmgr_psoc *psoc, 1223 bool *val) 1224 { 1225 *val = false; 1226 1227 return QDF_STATUS_SUCCESS; 1228 } 1229 1230 static inline QDF_STATUS 1231 ucfg_mlme_set_roaming_offload(struct wlan_objmgr_psoc *psoc, 1232 bool val) 1233 { 1234 return QDF_STATUS_SUCCESS; 1235 } 1236 1237 static inline uint32_t 1238 ucfg_mlme_get_roaming_triggers(struct wlan_objmgr_psoc *psoc) 1239 { 1240 return 0xffff; 1241 } 1242 1243 static inline void 1244 ucfg_mlme_set_roaming_triggers(struct wlan_objmgr_psoc *psoc, 1245 uint32_t trigger_bitmap) 1246 { 1247 } 1248 #endif 1249 1250 /** 1251 * ucfg_mlme_is_mawc_enabled() - MAWC enabled or not 1252 * @psoc: pointer to psoc object 1253 * @val: Pointer to the value which will be filled for the caller 1254 * 1255 * Return: QDF Status 1256 */ 1257 QDF_STATUS 1258 ucfg_mlme_is_mawc_enabled(struct wlan_objmgr_psoc *psoc, bool *val); 1259 1260 /** 1261 * ucfg_mlme_set_mawc_enabled() - Set MAWC enable or disable 1262 * @psoc: pointer to psoc object 1263 * @val: enable or disable MAWC 1264 * 1265 * Return: QDF Status 1266 */ 1267 QDF_STATUS 1268 ucfg_mlme_set_mawc_enabled(struct wlan_objmgr_psoc *psoc, bool val); 1269 1270 /** 1271 * ucfg_mlme_is_fast_transition_enabled() - Fast transition enable or not 1272 * @psoc: pointer to psoc object 1273 * @val: Pointer to the value which will be filled for the caller 1274 * 1275 * Return: QDF Status 1276 */ 1277 QDF_STATUS 1278 ucfg_mlme_is_fast_transition_enabled(struct wlan_objmgr_psoc *psoc, 1279 bool *val); 1280 1281 /** 1282 * ucfg_mlme_set_fast_transition_enabled() - Set fast transition enable 1283 * @psoc: pointer to psoc object 1284 * @val: Fast transition enable or disable 1285 * 1286 * Return: QDF Status 1287 */ 1288 QDF_STATUS 1289 ucfg_mlme_set_fast_transition_enabled(struct wlan_objmgr_psoc *psoc, 1290 bool val); 1291 1292 /** 1293 * ucfg_mlme_is_roam_scan_offload_enabled() - Roam scan offload enable or not 1294 * @psoc: pointer to psoc object 1295 * @val: Pointer to the value which will be filled for the caller 1296 * 1297 * Return: QDF Status 1298 */ 1299 QDF_STATUS 1300 ucfg_mlme_is_roam_scan_offload_enabled(struct wlan_objmgr_psoc *psoc, 1301 bool *val); 1302 1303 #ifdef WLAN_ADAPTIVE_11R 1304 /** 1305 * ucfg_mlme_set_tgt_adaptive_11r_cap() - Set adaptive 11r target service 1306 * capability 1307 * @psoc: pointer to psoc object 1308 * @val: Target capability of adaptive 11r 1309 * 1310 * Return: QDF Status 1311 */ 1312 QDF_STATUS 1313 ucfg_mlme_set_tgt_adaptive_11r_cap(struct wlan_objmgr_psoc *psoc, 1314 bool val); 1315 /** 1316 * ucfg_mlme_get_adaptive11r_enabled() - get adaptive 11R enabled status 1317 * @psoc: pointer to psoc object 1318 * @value: pointer to the value which will be filled for the caller 1319 * 1320 * Return: QDF Status 1321 */ 1322 QDF_STATUS 1323 ucfg_mlme_get_adaptive11r_enabled(struct wlan_objmgr_psoc *psoc, 1324 bool *value); 1325 #else 1326 static inline QDF_STATUS 1327 ucfg_mlme_set_tgt_adaptive_11r_cap(struct wlan_objmgr_psoc *psoc, 1328 bool val) 1329 { 1330 return QDF_STATUS_SUCCESS; 1331 } 1332 1333 static inline QDF_STATUS 1334 ucfg_mlme_get_adaptive11r_enabled(struct wlan_objmgr_psoc *psoc, 1335 bool *value) 1336 { 1337 *value = false; 1338 return QDF_STATUS_SUCCESS; 1339 } 1340 #endif 1341 1342 /** 1343 * ucfg_mlme_set_roam_scan_offload_enabled() - Set roam scan offload enable 1344 * @psoc: pointer to psoc object 1345 * @val: Roam scan offload enable or disable 1346 * 1347 * Return: QDF Status 1348 */ 1349 QDF_STATUS 1350 ucfg_mlme_set_roam_scan_offload_enabled(struct wlan_objmgr_psoc *psoc, 1351 bool val); 1352 1353 /** 1354 * ucfg_mlme_get_neighbor_scan_max_chan_time() - Get neighbor scan max 1355 * channel time 1356 * @psoc: pointer to psoc object 1357 * @val: Pointer to the value which will be filled for the caller 1358 * 1359 * Return: QDF Status 1360 */ 1361 QDF_STATUS 1362 ucfg_mlme_get_neighbor_scan_max_chan_time(struct wlan_objmgr_psoc *psoc, 1363 uint16_t *val); 1364 1365 /** 1366 * ucfg_mlme_get_neighbor_scan_min_chan_time() - Get neighbor scan min 1367 * channel time 1368 * @psoc: pointer to psoc object 1369 * @val: Pointer to the value which will be filled for the caller 1370 * 1371 * Return: QDF Status 1372 */ 1373 QDF_STATUS 1374 ucfg_mlme_get_neighbor_scan_min_chan_time(struct wlan_objmgr_psoc *psoc, 1375 uint16_t *val); 1376 1377 /** 1378 * ucfg_mlme_get_delay_before_vdev_stop() - Get the delay before vdev stop 1379 * @psoc: pointer to psoc object 1380 * @val: Pointer to the value which will be filled for the caller 1381 * 1382 * Return: QDF Status 1383 */ 1384 QDF_STATUS 1385 ucfg_mlme_get_delay_before_vdev_stop(struct wlan_objmgr_psoc *psoc, 1386 uint8_t *val); 1387 1388 /** 1389 * ucfg_mlme_get_roam_bmiss_final_bcnt() - Get roam bmiss first count 1390 * @psoc: pointer to psoc object 1391 * @val: Pointer to the value which will be filled for the caller 1392 * 1393 * Return: QDF Status 1394 */ 1395 QDF_STATUS 1396 ucfg_mlme_get_roam_bmiss_final_bcnt(struct wlan_objmgr_psoc *psoc, 1397 uint8_t *val); 1398 1399 /** 1400 * ucfg_mlme_validate_roam_bmiss_final_bcnt() - Validate roam bmiss final bcnt 1401 * @bmiss_final_bcnt: Roam bmiss final bcnt 1402 * 1403 * Return: True if bmiss_final_bcnt is in expected range, false otherwise. 1404 */ 1405 bool 1406 ucfg_mlme_validate_roam_bmiss_final_bcnt(uint32_t bmiss_final_bcnt); 1407 1408 /** 1409 * ucfg_mlme_get_dual_sta_roaming_enabled() - Get dual sta roaming enable flag 1410 * @psoc: pointer to psoc object 1411 * 1412 * Return: true if dual sta roaming allowed in fw 1413 */ 1414 bool 1415 ucfg_mlme_get_dual_sta_roaming_enabled(struct wlan_objmgr_psoc *psoc); 1416 1417 /** 1418 * ucfg_mlme_get_roam_bmiss_first_bcnt() - Get roam bmiss final count 1419 * @psoc: pointer to psoc object 1420 * @val: Pointer to the value which will be filled for the caller 1421 * 1422 * Return: QDF Status 1423 */ 1424 QDF_STATUS 1425 ucfg_mlme_get_roam_bmiss_first_bcnt(struct wlan_objmgr_psoc *psoc, 1426 uint8_t *val); 1427 1428 /** 1429 * ucfg_mlme_is_lfr_enabled() - LFR enable or not 1430 * @psoc: pointer to psoc object 1431 * @val: Pointer to the value which will be filled for the caller 1432 * 1433 * Return: QDF Status 1434 */ 1435 QDF_STATUS 1436 ucfg_mlme_is_lfr_enabled(struct wlan_objmgr_psoc *psoc, bool *val); 1437 1438 /** 1439 * ucfg_mlme_set_lfr_enabled() - Enable or disable LFR 1440 * @psoc: pointer to psoc object 1441 * @val: Enable or disable LFR 1442 * 1443 * Return: QDF Status 1444 */ 1445 QDF_STATUS 1446 ucfg_mlme_set_lfr_enabled(struct wlan_objmgr_psoc *psoc, bool val); 1447 1448 /** 1449 * ucfg_mlme_is_roam_prefer_5ghz() - prefer 5ghz or not 1450 * @psoc: pointer to psoc object 1451 * @val: Pointer to the value which will be filled for the caller 1452 * 1453 * Return: QDF Status 1454 */ 1455 QDF_STATUS 1456 ucfg_mlme_is_roam_prefer_5ghz(struct wlan_objmgr_psoc *psoc, bool *val); 1457 1458 /** 1459 * ucfg_mlme_is_roam_intra_band() - Get the preference to roam within band 1460 * @psoc: pointer to psoc object 1461 * 1462 * Return: True if vdev should roam within band, false otherwise 1463 */ 1464 bool ucfg_mlme_is_roam_intra_band(struct wlan_objmgr_psoc *psoc); 1465 1466 /** 1467 * ucfg_mlme_set_roam_intra_band() - Set roam intra modes 1468 * @psoc: pointer to psoc object 1469 * @val: roam intra modes or not 1470 * 1471 * Return: QDF Status 1472 */ 1473 QDF_STATUS 1474 ucfg_mlme_set_roam_intra_band(struct wlan_objmgr_psoc *psoc, bool val); 1475 1476 /** 1477 * ucfg_mlme_get_home_away_time() - Get home away time 1478 * @psoc: pointer to psoc object 1479 * @val: Pointer to the value which will be filled for the caller 1480 * 1481 * Return: QDF Status 1482 */ 1483 QDF_STATUS 1484 ucfg_mlme_get_home_away_time(struct wlan_objmgr_psoc *psoc, uint16_t *val); 1485 1486 /** 1487 * ucfg_mlme_set_fast_roam_in_concurrency_enabled() - Enable fast roam in 1488 * concurrency 1489 * @psoc: pointer to psoc object 1490 * @val: Enable or disable fast roam in concurrency 1491 * 1492 * Return: QDF Status 1493 */ 1494 QDF_STATUS 1495 ucfg_mlme_set_fast_roam_in_concurrency_enabled(struct wlan_objmgr_psoc *psoc, 1496 bool val); 1497 1498 /** 1499 * ucfg_mlme_get_wmi_wq_watchdog_timeout() - Get timeout for wmi watchdog bite 1500 * @psoc: pointer to psoc object 1501 * @wmi_wq_watchdog_timeout: buffer to hold value 1502 * 1503 * Return: QDF Status 1504 */ 1505 QDF_STATUS 1506 ucfg_mlme_get_wmi_wq_watchdog_timeout(struct wlan_objmgr_psoc *psoc, 1507 uint32_t *wmi_wq_watchdog_timeout); 1508 1509 /** 1510 * ucfg_mlme_set_wmi_wq_watchdog_timeout() - Set timeout for wmi watchdog bite 1511 * @psoc: pointer to psoc object 1512 * @wmi_wq_watchdog_timeout: value to be set 1513 * 1514 * Return: QDF Status 1515 */ 1516 QDF_STATUS 1517 ucfg_mlme_set_wmi_wq_watchdog_timeout(struct wlan_objmgr_psoc *psoc, 1518 uint32_t wmi_wq_watchdog_timeout); 1519 1520 /** 1521 * ucfg_mlme_set_sap_listen_interval() - Set the Sap listen interval 1522 * @psoc: pointer to psoc object 1523 * @value: Value that needs to be set from the caller 1524 * 1525 * Inline UCFG API to be used by HDD/OSIF callers 1526 * 1527 * Return: QDF Status 1528 */ 1529 static inline 1530 QDF_STATUS ucfg_mlme_set_sap_listen_interval(struct wlan_objmgr_psoc *psoc, 1531 int value) 1532 { 1533 return wlan_mlme_set_sap_listen_interval(psoc, value); 1534 } 1535 1536 /** 1537 * ucfg_mlme_set_assoc_sta_limit() - Set the assoc sta limit 1538 * @psoc: pointer to psoc object 1539 * @value: Value that needs to be set from the caller 1540 * 1541 * Inline UCFG API to be used by HDD/OSIF callers 1542 * 1543 * Return: QDF Status 1544 */ 1545 static inline 1546 QDF_STATUS ucfg_mlme_set_assoc_sta_limit(struct wlan_objmgr_psoc *psoc, 1547 int value) 1548 { 1549 return wlan_mlme_set_assoc_sta_limit(psoc, value); 1550 } 1551 1552 /** 1553 * ucfg_mlme_get_assoc_sta_limit() - Get the assoc sta limit 1554 * @psoc: pointer to psoc object 1555 * @value: Pointer to variable that needs to be filled by MLME 1556 * 1557 * Inline UCFG API to be used by HDD/OSIF callers 1558 * 1559 * Return: QDF Status 1560 */ 1561 static inline 1562 QDF_STATUS ucfg_mlme_get_assoc_sta_limit(struct wlan_objmgr_psoc *psoc, 1563 int *value) 1564 { 1565 return wlan_mlme_get_assoc_sta_limit(psoc, value); 1566 } 1567 1568 /** 1569 * ucfg_mlme_get_listen_interval() - Get listen interval 1570 * @psoc: pointer to psoc object 1571 * @value: Pointer to variable that needs to be filled by MLME 1572 * 1573 * Inline UCFG API to be used by HDD/OSIF callers 1574 * 1575 * Return: QDF Status 1576 */ 1577 static inline 1578 QDF_STATUS ucfg_mlme_get_listen_interval(struct wlan_objmgr_psoc *psoc, 1579 int *value) 1580 { 1581 return wlan_mlme_get_listen_interval(psoc, value); 1582 } 1583 1584 1585 /** 1586 * ucfg_mlme_get_sap_get_peer_info() - get the sap get peer info 1587 * @psoc: pointer to psoc object 1588 * @value: Value that needs to be set from the caller 1589 * 1590 * Inline UCFG API to be used by HDD/OSIF callers 1591 * 1592 * Return: QDF Status 1593 */ 1594 static inline 1595 QDF_STATUS ucfg_mlme_get_sap_get_peer_info(struct wlan_objmgr_psoc *psoc, 1596 bool *value) 1597 { 1598 return wlan_mlme_get_sap_get_peer_info(psoc, value); 1599 } 1600 1601 /** 1602 * ucfg_mlme_set_sap_get_peer_info() - set the sap get peer info 1603 * @psoc: pointer to psoc object 1604 * @value: value to overwrite the sap get peer info 1605 * 1606 * Inline UCFG API to be used by HDD/OSIF callers 1607 * 1608 * Return: QDF Status 1609 */ 1610 static inline 1611 QDF_STATUS ucfg_mlme_set_sap_get_peer_info(struct wlan_objmgr_psoc *psoc, 1612 bool value) 1613 { 1614 return wlan_mlme_set_sap_get_peer_info(psoc, value); 1615 } 1616 1617 /** 1618 * ucfg_mlme_get_sap_bcast_deauth_enabled() - get the sap bcast deauth 1619 * enabled value 1620 * @psoc: pointer to psoc object 1621 * @value: Value that needs to be get from the caller 1622 * 1623 * Inline UCFG API to be used by HDD/OSIF callers 1624 * 1625 * Return: QDF Status 1626 */ 1627 static inline QDF_STATUS 1628 ucfg_mlme_get_sap_bcast_deauth_enabled(struct wlan_objmgr_psoc *psoc, 1629 bool *value) 1630 { 1631 return wlan_mlme_get_sap_bcast_deauth_enabled(psoc, value); 1632 } 1633 1634 /** 1635 * ucfg_mlme_is_6g_sap_fd_enabled() - get the sap fils discovery 1636 * enabled value 1637 * @psoc: pointer to psoc object 1638 * @value: Value that needs to be get from the caller 1639 * 1640 * Inline UCFG API to be used by HDD/OSIF callers 1641 * 1642 * Return: QDF Status 1643 */ 1644 static inline QDF_STATUS 1645 ucfg_mlme_is_6g_sap_fd_enabled(struct wlan_objmgr_psoc *psoc, 1646 bool *value) 1647 { 1648 return wlan_mlme_is_6g_sap_fd_enabled(psoc, value); 1649 } 1650 1651 /** 1652 * ucfg_mlme_get_sap_allow_all_channels() - get the sap allow all channels 1653 * @psoc: pointer to psoc object 1654 * @value: Value that needs to be set from the caller 1655 * 1656 * Inline UCFG API to be used by HDD/OSIF callers 1657 * 1658 * Return: QDF Status 1659 */ 1660 static inline 1661 QDF_STATUS ucfg_mlme_get_sap_allow_all_channels(struct wlan_objmgr_psoc *psoc, 1662 bool *value) 1663 { 1664 return wlan_mlme_get_sap_allow_all_channels(psoc, value); 1665 } 1666 1667 /** 1668 * ucfg_mlme_get_sap_max_peers() - get the sap max peers 1669 * @psoc: pointer to psoc object 1670 * @value: Value that needs to be set from the caller 1671 * 1672 * Inline UCFG API to be used by HDD/OSIF callers 1673 * 1674 * Return: QDF Status 1675 */ 1676 static inline 1677 QDF_STATUS ucfg_mlme_get_sap_max_peers(struct wlan_objmgr_psoc *psoc, 1678 int *value) 1679 { 1680 return wlan_mlme_get_sap_max_peers(psoc, value); 1681 } 1682 1683 /** 1684 * ucfg_mlme_set_sap_max_peers() - Set the sap max peers 1685 * @psoc: pointer to psoc object 1686 * @value: Value that needs to be set from the caller 1687 * 1688 * Inline UCFG API to be used by HDD/OSIF callers 1689 * 1690 * Return: QDF Status 1691 */ 1692 static inline 1693 QDF_STATUS ucfg_mlme_set_sap_max_peers(struct wlan_objmgr_psoc *psoc, int value) 1694 { 1695 return wlan_mlme_set_sap_max_peers(psoc, value); 1696 } 1697 1698 /** 1699 * ucfg_mlme_get_sap_max_offload_peers() - get the sap max offload peers 1700 * @psoc: pointer to psoc object 1701 * @value: Value that needs to be set from the caller 1702 * 1703 * Inline UCFG API to be used by HDD/OSIF callers 1704 * 1705 * Return: QDF Status 1706 */ 1707 static inline 1708 QDF_STATUS ucfg_mlme_get_sap_max_offload_peers(struct wlan_objmgr_psoc *psoc, 1709 int *value) 1710 { 1711 return wlan_mlme_get_sap_max_offload_peers(psoc, value); 1712 } 1713 1714 /** 1715 * ucfg_mlme_get_sap_max_offload_reorder_buffs() - get the sap max offload 1716 * reorder buffs 1717 * @psoc: pointer to psoc object 1718 * @value: Value that needs to be set from the caller 1719 * 1720 * Inline UCFG API to be used by HDD/OSIF callers 1721 * 1722 * Return: QDF Status 1723 */ 1724 static inline 1725 QDF_STATUS ucfg_mlme_get_sap_max_offload_reorder_buffs(struct wlan_objmgr_psoc 1726 *psoc, int *value) 1727 { 1728 return wlan_mlme_get_sap_max_offload_reorder_buffs(psoc, value); 1729 } 1730 1731 /** 1732 * ucfg_mlme_get_sap_chn_switch_bcn_count() - get the sap channel 1733 * switch beacon count 1734 * @psoc: pointer to psoc object 1735 * @value: Value that needs to be set from the caller 1736 * 1737 * Inline UCFG API to be used by HDD/OSIF callers 1738 * 1739 * Return: QDF Status 1740 */ 1741 static inline 1742 QDF_STATUS ucfg_mlme_get_sap_chn_switch_bcn_count(struct wlan_objmgr_psoc *psoc, 1743 int *value) 1744 { 1745 return wlan_mlme_get_sap_chn_switch_bcn_count(psoc, value); 1746 } 1747 1748 /** 1749 * ucfg_mlme_get_sap_channel_switch_mode() - get the sap channel switch mode 1750 * @psoc: pointer to psoc object 1751 * @value: Value that needs to be set from the caller 1752 * 1753 * Inline UCFG API to be used by HDD/OSIF callers 1754 * 1755 * Return: QDF Status 1756 */ 1757 static inline 1758 QDF_STATUS ucfg_mlme_get_sap_channel_switch_mode(struct wlan_objmgr_psoc *psoc, 1759 bool *value) 1760 { 1761 return wlan_mlme_get_sap_chn_switch_mode(psoc, value); 1762 } 1763 1764 /** 1765 * ucfg_mlme_get_sap_internal_restart() - get sap internal restart value 1766 * @psoc: pointer to psoc object 1767 * @value: Value that needs to be set from the caller 1768 * 1769 * Inline UCFG API to be used by HDD/OSIF callers 1770 * 1771 * Return: QDF Status 1772 */ 1773 static inline 1774 QDF_STATUS ucfg_mlme_get_sap_internal_restart(struct wlan_objmgr_psoc *psoc, 1775 bool *value) 1776 { 1777 return wlan_mlme_get_sap_internal_restart(psoc, value); 1778 } 1779 1780 /** 1781 * ucfg_mlme_get_sap_max_modulated_dtim() - get sap max modulated dtim 1782 * @psoc: pointer to psoc object 1783 * @value: Value that needs to be set from the caller 1784 * 1785 * Inline UCFG API to be used by HDD/OSIF callers 1786 * 1787 * Return: QDF Status 1788 */ 1789 static inline 1790 QDF_STATUS ucfg_mlme_get_sap_max_modulated_dtim(struct wlan_objmgr_psoc *psoc, 1791 uint8_t *value) 1792 { 1793 return wlan_mlme_get_sap_max_modulated_dtim(psoc, value); 1794 } 1795 1796 /** 1797 * ucfg_mlme_get_pref_chan_location() - get sap pref chan location 1798 * @psoc: pointer to psoc object 1799 * @value: Value that needs to be set from the caller 1800 * 1801 * Inline UCFG API to be used by HDD/OSIF callers 1802 * 1803 * Return: QDF Status 1804 */ 1805 static inline 1806 QDF_STATUS ucfg_mlme_get_pref_chan_location(struct wlan_objmgr_psoc *psoc, 1807 uint8_t *value) 1808 { 1809 return wlan_mlme_get_sap_chan_pref_location(psoc, value); 1810 } 1811 1812 /** 1813 * ucfg_mlme_get_sap_country_priority() - get sap country code priority 1814 * @psoc: pointer to psoc object 1815 * @value: Value that needs to be set from the caller 1816 * 1817 * Inline UCFG API to be used by HDD/OSIF callers 1818 * 1819 * Return: QDF Status 1820 */ 1821 static inline 1822 QDF_STATUS ucfg_mlme_get_sap_country_priority(struct wlan_objmgr_psoc *psoc, 1823 bool *value) 1824 { 1825 return wlan_mlme_get_sap_country_priority(psoc, value); 1826 } 1827 1828 /** 1829 * ucfg_mlme_get_sap_reduces_beacon_interval() - get the sap reduces beacon 1830 * interval 1831 * @psoc: pointer to psoc object 1832 * @value: Value that needs to be set from the caller 1833 * 1834 * Inline UCFG API to be used by HDD/OSIF callers 1835 * 1836 * Return: QDF Status 1837 */ 1838 static inline 1839 QDF_STATUS ucfg_mlme_get_sap_reduces_beacon_interval(struct wlan_objmgr_psoc 1840 *psoc, int *value) 1841 { 1842 return wlan_mlme_get_sap_reduced_beacon_interval(psoc, value); 1843 } 1844 1845 /** 1846 * ucfg_mlme_get_sap_chan_switch_rate_enabled() - get the sap channel 1847 * switch rate enabled. 1848 * @psoc: pointer to psoc object 1849 * @value: Value that needs to be set from the caller 1850 * 1851 * Inline UCFG API to be used by HDD/OSIF callers 1852 * 1853 * Return: QDF Status 1854 */ 1855 static inline 1856 QDF_STATUS ucfg_mlme_get_sap_chan_switch_rate_enabled(struct wlan_objmgr_psoc 1857 *psoc, bool *value) 1858 { 1859 return wlan_mlme_get_sap_chan_switch_rate_enabled(psoc, value); 1860 } 1861 1862 /** 1863 * ucfg_mlme_get_sap_force_11n_for_11ac() - get the sap 11n for 11ac 1864 * 1865 * @psoc: pointer to psoc object 1866 * @value: Value that needs to be set from the caller 1867 * 1868 * Inline UCFG API to be used by HDD/OSIF callers 1869 * 1870 * Return: QDF Status 1871 */ 1872 static inline 1873 QDF_STATUS ucfg_mlme_get_sap_force_11n_for_11ac(struct wlan_objmgr_psoc 1874 *psoc, bool *value) 1875 { 1876 return wlan_mlme_get_sap_force_11n_for_11ac(psoc, value); 1877 } 1878 1879 /** 1880 * ucfg_mlme_get_go_force_11n_for_11ac() - get the GO 11n for 11ac 1881 * 1882 * @psoc: pointer to psoc object 1883 * @value: Value that needs to be set from the caller 1884 * 1885 * Inline UCFG API to be used by HDD/OSIF callers 1886 * 1887 * Return: QDF Status 1888 */ 1889 static inline 1890 QDF_STATUS ucfg_mlme_get_go_force_11n_for_11ac(struct wlan_objmgr_psoc 1891 *psoc, bool *value) 1892 { 1893 return wlan_mlme_get_go_force_11n_for_11ac(psoc, value); 1894 } 1895 1896 /** 1897 * ucfg_mlme_is_sap_11ac_override() - Override 11ac bandwdith for SAP 1898 * 1899 * @psoc: pointer to psoc object 1900 * @value: Value that needs to be set from the caller 1901 * 1902 * Return: QDF Status 1903 */ 1904 static inline 1905 QDF_STATUS ucfg_mlme_is_sap_11ac_override(struct wlan_objmgr_psoc *psoc, 1906 bool *value) 1907 { 1908 return wlan_mlme_is_sap_11ac_override(psoc, value); 1909 } 1910 1911 /** 1912 * ucfg_mlme_is_go_11ac_override() - Override 11ac bandwdith for P2P GO 1913 * 1914 * @psoc: pointer to psoc object 1915 * @value: pointer to the value which will be filled for the caller 1916 * 1917 * Return: QDF Status 1918 */ 1919 static inline 1920 QDF_STATUS ucfg_mlme_is_go_11ac_override(struct wlan_objmgr_psoc *psoc, 1921 bool *value) 1922 { 1923 return wlan_mlme_is_go_11ac_override(psoc, value); 1924 } 1925 1926 /** 1927 * ucfg_mlme_set_sap_11ac_override() - Set override 11ac bandwdith for SAP 1928 * 1929 * @psoc: pointer to psoc object 1930 * @value: Value that needs to be set from the caller 1931 * 1932 * Return: QDF Status 1933 */ 1934 static inline 1935 QDF_STATUS ucfg_mlme_set_sap_11ac_override(struct wlan_objmgr_psoc *psoc, 1936 bool value) 1937 { 1938 return wlan_mlme_set_sap_11ac_override(psoc, value); 1939 } 1940 1941 /** 1942 * ucfg_mlme_set_go_11ac_override() - Set override 11ac bandwdith for P2P GO 1943 * 1944 * @psoc: pointer to psoc object 1945 * @value: pointer to the value which will be filled for the caller 1946 * 1947 * Return: QDF Status 1948 */ 1949 static inline 1950 QDF_STATUS ucfg_mlme_set_go_11ac_override(struct wlan_objmgr_psoc *psoc, 1951 bool value) 1952 { 1953 return wlan_mlme_set_go_11ac_override(psoc, value); 1954 } 1955 1956 /** 1957 * ucfg_mlme_get_oce_sta_enabled_info() - Get OCE feature enable/disable 1958 * info for STA 1959 * 1960 * @psoc: pointer to psoc object 1961 * @value: pointer to the value which will be filled for the caller 1962 * 1963 * Inline UCFG API to be used by HDD/OSIF callers to get the 1964 * OCE STA feature enable value 1965 * 1966 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 1967 */ 1968 static inline 1969 QDF_STATUS ucfg_mlme_get_oce_sta_enabled_info(struct wlan_objmgr_psoc *psoc, 1970 bool *value) 1971 { 1972 return wlan_mlme_get_oce_sta_enabled_info(psoc, value); 1973 } 1974 1975 /** 1976 * ucfg_mlme_get_bigtk_support() - Get whether bigtk is supported or not. 1977 * 1978 * @psoc: pointer to psoc object 1979 * @value: pointer to the value which will be filled for the caller 1980 * 1981 * Inline UCFG API to be used by HDD/OSIF callers to get the BIGTK support 1982 * 1983 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 1984 */ 1985 static inline 1986 QDF_STATUS ucfg_mlme_get_bigtk_support(struct wlan_objmgr_psoc *psoc, 1987 bool *value) 1988 { 1989 return wlan_mlme_get_bigtk_support(psoc, value); 1990 } 1991 1992 /** 1993 * ucfg_mlme_get_ocv_support() - Get whether ocv is supported or not. 1994 * 1995 * @psoc: pointer to psoc object 1996 * @value: pointer to the value which will be filled for the caller 1997 * 1998 * Inline UCFG API to be used by HDD/OSIF callers to get the OCV support 1999 * 2000 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2001 */ 2002 static inline 2003 QDF_STATUS ucfg_mlme_get_ocv_support(struct wlan_objmgr_psoc *psoc, 2004 bool *value) 2005 { 2006 return wlan_mlme_get_ocv_support(psoc, value); 2007 } 2008 2009 /** 2010 * ucfg_mlme_get_oce_sap_enabled_info() - Get OCE feature enable/disable 2011 * info for SAP 2012 * 2013 * @psoc: pointer to psoc object 2014 * @value: pointer to the value which will be filled for the caller 2015 * 2016 * Inline UCFG API to be used by HDD/OSIF callers to get the 2017 * OCE SAP feature enable value 2018 * 2019 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2020 */ 2021 static inline 2022 QDF_STATUS ucfg_mlme_get_oce_sap_enabled_info(struct wlan_objmgr_psoc *psoc, 2023 bool *value) 2024 { 2025 return wlan_mlme_get_oce_sap_enabled_info(psoc, value); 2026 } 2027 2028 /** 2029 * ucfg_mlme_update_oce_flags: Update the OCE flags 2030 * 2031 * @pdev: pointer to pdev object 2032 * 2033 * Inline UCFG API to be used by HDD/OSIF callers to update the 2034 * OCE feature flags 2035 * 2036 * Return: void 2037 */ 2038 static inline 2039 void ucfg_mlme_update_oce_flags(struct wlan_objmgr_pdev *pdev) 2040 { 2041 wlan_mlme_update_oce_flags(pdev); 2042 } 2043 2044 /** 2045 * ucfg_mlme_is_ap_prot_enabled() - Check if sap is enabled 2046 * @psoc: pointer to psoc object 2047 * 2048 * Inline UCFG API to be used by HDD/OSIF callers to get the 2049 * sap protection enabled/disabled 2050 * 2051 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2052 */ 2053 static inline 2054 bool ucfg_mlme_is_ap_prot_enabled(struct wlan_objmgr_psoc *psoc) 2055 { 2056 return wlan_mlme_is_ap_prot_enabled(psoc); 2057 } 2058 2059 /** 2060 * ucfg_mlme_get_ap_protection_mode() - Get ap protection mode info 2061 * @psoc: pointer to psoc object 2062 * @value: pointer to the value which will be filled for the caller 2063 * 2064 * Inline UCFG API to be used by HDD/OSIF callers to get the 2065 * ap protection mode value 2066 * 2067 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2068 */ 2069 static inline 2070 QDF_STATUS ucfg_mlme_get_ap_protection_mode(struct wlan_objmgr_psoc *psoc, 2071 uint16_t *value) 2072 { 2073 return wlan_mlme_get_ap_protection_mode(psoc, value); 2074 } 2075 2076 /** 2077 * ucfg_mlme_is_ap_obss_prot_enabled() - Get ap obss protection enable/disable 2078 * @psoc: pointer to psoc object 2079 * @value: pointer to the value which will be filled for the caller 2080 * 2081 * Inline UCFG API to be used by HDD/OSIF callers to get the 2082 * obss protection enable value 2083 * 2084 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2085 */ 2086 static inline 2087 QDF_STATUS ucfg_mlme_is_ap_obss_prot_enabled(struct wlan_objmgr_psoc *psoc, 2088 bool *value) 2089 { 2090 return wlan_mlme_is_ap_obss_prot_enabled(psoc, value); 2091 } 2092 2093 /** 2094 * ucfg_mlme_get_rts_threshold() - Get the rts threshold config 2095 * @psoc: pointer to psoc object 2096 * @value: pointer to the value which will be filled for the caller 2097 * 2098 * Inline UCFG API to be used by HDD/OSIF callers 2099 * 2100 * Return: QDF Status 2101 */ 2102 static inline 2103 QDF_STATUS ucfg_mlme_get_rts_threshold(struct wlan_objmgr_psoc *psoc, 2104 uint32_t *value) 2105 { 2106 return wlan_mlme_get_rts_threshold(psoc, value); 2107 } 2108 2109 /** 2110 * ucfg_mlme_set_rts_threshold() - Set the rts threshold config 2111 * @psoc: pointer to psoc object 2112 * @value: pointer to the value which will be filled for the caller 2113 * 2114 * Inline UCFG API to be used by HDD/OSIF callers 2115 * 2116 * Return: QDF Status 2117 */ 2118 static inline 2119 QDF_STATUS ucfg_mlme_set_rts_threshold(struct wlan_objmgr_psoc *psoc, 2120 uint32_t value) 2121 { 2122 return wlan_mlme_set_rts_threshold(psoc, value); 2123 } 2124 2125 /** 2126 * ucfg_mlme_get_frag_threshold() - Get the fragmentation threshold 2127 * config 2128 * @psoc: pointer to psoc object 2129 * @value: Value that needs to be set from the caller 2130 * 2131 * Inline UCFG API to be used by HDD/OSIF callers 2132 * 2133 * Return: QDF Status 2134 */ 2135 static inline 2136 QDF_STATUS ucfg_mlme_get_frag_threshold(struct wlan_objmgr_psoc *psoc, 2137 uint32_t *value) 2138 { 2139 return wlan_mlme_get_frag_threshold(psoc, value); 2140 } 2141 2142 /** 2143 * ucfg_mlme_set_frag_threshold() - set the frag threshold config 2144 * @psoc: pointer to psoc object 2145 * @value: pointer to the value which will be filled for the caller 2146 * 2147 * Inline UCFG API to be used by HDD/OSIF callers 2148 * 2149 * Return: QDF Status 2150 */ 2151 static inline 2152 QDF_STATUS ucfg_mlme_set_frag_threshold(struct wlan_objmgr_psoc *psoc, 2153 uint32_t value) 2154 { 2155 return wlan_mlme_set_frag_threshold(psoc, value); 2156 } 2157 2158 /** 2159 * ucfg_mlme_get_fils_enabled_info() - Get fils enable/disable info 2160 * 2161 * @psoc: pointer to psoc object 2162 * @value: pointer to the value which will be filled for the caller 2163 * 2164 * Inline UCFG API to be used by HDD/OSIF callers to get the 2165 * fils enable value 2166 * 2167 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2168 */ 2169 static inline 2170 QDF_STATUS ucfg_mlme_get_fils_enabled_info(struct wlan_objmgr_psoc *psoc, 2171 bool *value) 2172 { 2173 return wlan_mlme_get_fils_enabled_info(psoc, value); 2174 } 2175 2176 /** 2177 * ucfg_mlme_set_fils_enabled_info() - Set fils enable info 2178 * 2179 * @psoc: pointer to psoc object 2180 * @value: value that needs to be set from the caller 2181 * 2182 * Inline UCFG API to be used by HDD/OSIF callers to set the 2183 * fils enable value 2184 * 2185 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2186 */ 2187 static inline 2188 QDF_STATUS ucfg_mlme_set_fils_enabled_info(struct wlan_objmgr_psoc *psoc, 2189 bool value) 2190 { 2191 return wlan_mlme_set_fils_enabled_info(psoc, value); 2192 } 2193 2194 /** 2195 * ucfg_mlme_set_primary_interface() - Set primary STA iface id 2196 * 2197 * @psoc: pointer to psoc object 2198 * @value: value that needs to be set from the caller 2199 * 2200 * When a vdev is set as primary then based on the dual sta policy 2201 * "qca_wlan_concurrent_sta_policy_config" mcc preference and roaming has 2202 * to be enabled on the primary vdev 2203 * 2204 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2205 */ 2206 static inline 2207 QDF_STATUS ucfg_mlme_set_primary_interface(struct wlan_objmgr_psoc *psoc, 2208 uint8_t value) 2209 { 2210 return wlan_mlme_set_primary_interface(psoc, value); 2211 } 2212 2213 /** 2214 * ucfg_mlme_get_mcc_duty_cycle_percentage() - Get primary STA iface MCC 2215 * duty-cycle 2216 * @pdev: pointer to pdev object 2217 * 2218 * primary and secondary STA iface MCC duty-cycle value in below format 2219 * ****************************************************** 2220 * |bit 31-24 | bit 23-16 | bits 15-8 |bits 7-0 | 2221 * | Unused | Quota for | chan. # for |chan. # for| 2222 * | | 1st chan | 1st chan. |2nd chan. | 2223 * ***************************************************** 2224 * 2225 * Return: primary iface MCC duty-cycle value 2226 */ 2227 static inline 2228 int ucfg_mlme_get_mcc_duty_cycle_percentage(struct wlan_objmgr_pdev *pdev) 2229 { 2230 return wlan_mlme_get_mcc_duty_cycle_percentage(pdev); 2231 } 2232 2233 /** 2234 * ucfg_mlme_set_enable_bcast_probe_rsp() - Set enable bcast probe resp info 2235 * @psoc: pointer to psoc object 2236 * @value: value that needs to be set from the caller 2237 * 2238 * Inline UCFG API to be used by HDD/OSIF callers to set the 2239 * enable bcast probe resp info 2240 * 2241 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2242 */ 2243 static inline 2244 QDF_STATUS ucfg_mlme_set_enable_bcast_probe_rsp(struct wlan_objmgr_psoc *psoc, 2245 bool value) 2246 { 2247 return wlan_mlme_set_enable_bcast_probe_rsp(psoc, value); 2248 } 2249 2250 /** 2251 * ucfg_mlme_set_vht_ch_width() - set the vht supported channel width cfg 2252 * @psoc: psoc context 2253 * @value: data to be set 2254 * 2255 * Inline UCFG API to be used by HDD/OSIF callers 2256 * 2257 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2258 */ 2259 static inline QDF_STATUS 2260 ucfg_mlme_set_vht_ch_width(struct wlan_objmgr_psoc *psoc, uint8_t value) 2261 { 2262 return wlan_mlme_cfg_set_vht_chan_width(psoc, value); 2263 } 2264 2265 /** 2266 * ucfg_mlme_cfg_get_vht_chan_width() - gets vht supported channel width into 2267 * cfg item 2268 * @psoc: psoc context 2269 * @value: data to be set 2270 * 2271 * Inline UCFG API to be used by HDD/OSIF callers 2272 * 2273 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2274 */ 2275 static inline QDF_STATUS 2276 ucfg_mlme_cfg_get_vht_chan_width(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2277 { 2278 return wlan_mlme_cfg_get_vht_chan_width(psoc, value); 2279 } 2280 2281 /** 2282 * ucfg_mlme_cfg_set_vht_ldpc_coding_cap() - sets vht ldpc coding cap into 2283 * cfg item 2284 * @psoc: psoc context 2285 * @value: data to be set 2286 * 2287 * Inline UCFG API to be used by HDD/OSIF callers 2288 * 2289 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2290 */ 2291 static inline QDF_STATUS 2292 ucfg_mlme_cfg_set_vht_ldpc_coding_cap(struct wlan_objmgr_psoc *psoc, bool value) 2293 { 2294 return wlan_mlme_cfg_set_vht_ldpc_coding_cap(psoc, value); 2295 } 2296 2297 /** 2298 * ucfg_mlme_cfg_get_short_gi_160_mhz() - Get SHORT GI 160MHZ from cfg item 2299 * @psoc: psoc context 2300 * @value: data to be set 2301 * 2302 * Inline UCFG API to be used by HDD/OSIF callers to get the 2303 * ignore_peer_ht_opmode flag value 2304 * 2305 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2306 */ 2307 static inline QDF_STATUS 2308 ucfg_mlme_cfg_get_short_gi_160_mhz(struct wlan_objmgr_psoc *psoc, bool *value) 2309 { 2310 return wlan_mlme_cfg_get_short_gi_160_mhz(psoc, value); 2311 } 2312 2313 /** 2314 * ucfg_mlme_cfg_set_short_gi_160_mhz() - sets basic set SHORT GI 160MHZ into 2315 * cfg item 2316 * @psoc: psoc context 2317 * @value: data to be set 2318 * 2319 * Inline UCFG API to be used by HDD/OSIF callers to get the 2320 * ignore_peer_ht_opmode flag value 2321 * 2322 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2323 */ 2324 static inline QDF_STATUS 2325 ucfg_mlme_cfg_set_short_gi_160_mhz(struct wlan_objmgr_psoc *psoc, bool value) 2326 { 2327 return wlan_mlme_cfg_set_short_gi_160_mhz(psoc, value); 2328 } 2329 2330 /** 2331 * ucfg_mlme_cfg_get_vht_tx_stbc() - gets vht tx stbc from 2332 * cfg item 2333 * @psoc: psoc context 2334 * @value: pointer to get required data 2335 * 2336 * Inline UCFG API to be used by HDD/OSIF callers to get the 2337 * ignore_peer_ht_opmode flag value 2338 * 2339 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2340 */ 2341 static inline QDF_STATUS 2342 ucfg_mlme_cfg_get_vht_tx_stbc(struct wlan_objmgr_psoc *psoc, bool *value) 2343 { 2344 return wlan_mlme_cfg_get_vht_tx_stbc(psoc, value); 2345 } 2346 2347 /** 2348 * ucfg_mlme_cfg_get_vht_rx_stbc() - gets vht rx stbc from 2349 * cfg item 2350 * @psoc: psoc context 2351 * @value: pointer to get required data 2352 * 2353 * Inline UCFG API to be used by HDD/OSIF callers to get the 2354 * ignore_peer_ht_opmode flag value 2355 * 2356 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2357 */ 2358 static inline QDF_STATUS 2359 ucfg_mlme_cfg_get_vht_rx_stbc(struct wlan_objmgr_psoc *psoc, bool *value) 2360 { 2361 return wlan_mlme_cfg_get_vht_rx_stbc(psoc, value); 2362 } 2363 2364 /** 2365 * ucfg_mlme_cfg_set_vht_tx_bfee_ant_supp() - sets vht Beamformee antenna 2366 * support cap into cfg item 2367 * @psoc: psoc context 2368 * @value: data to be set 2369 * 2370 * Inline UCFG API to be used by HDD/OSIF callers 2371 * 2372 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2373 */ 2374 static inline 2375 QDF_STATUS ucfg_mlme_cfg_set_vht_tx_bfee_ant_supp(struct wlan_objmgr_psoc *psoc, 2376 uint8_t value) 2377 { 2378 return wlan_mlme_cfg_set_vht_tx_bfee_ant_supp(psoc, value); 2379 } 2380 2381 /** 2382 * ucfg_mlme_cfg_get_vht_tx_bfee_ant_supp() - gets vht Beamformee antenna 2383 * support cap into cfg item 2384 * @psoc: psoc context 2385 * @value: data to be set 2386 * 2387 * Inline UCFG API to be used by HDD/OSIF callers 2388 * 2389 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2390 */ 2391 static inline 2392 QDF_STATUS ucfg_mlme_cfg_get_vht_tx_bfee_ant_supp(struct wlan_objmgr_psoc *psoc, 2393 uint8_t *value) 2394 { 2395 return wlan_mlme_cfg_get_vht_tx_bfee_ant_supp(psoc, value); 2396 } 2397 2398 /** 2399 * ucfg_mlme_cfg_get_vht_rx_mcs_map() - gets vht rx mcs map from 2400 * cfg item 2401 * @psoc: psoc context 2402 * @value: pointer to get required data 2403 * 2404 * Inline UCFG API to be used by HDD/OSIF callers to get the 2405 * ignore_peer_ht_opmode flag value 2406 * 2407 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2408 */ 2409 static inline QDF_STATUS 2410 ucfg_mlme_cfg_get_vht_rx_mcs_map(struct wlan_objmgr_psoc *psoc, uint32_t *value) 2411 { 2412 return wlan_mlme_cfg_get_vht_rx_mcs_map(psoc, value); 2413 } 2414 2415 /** 2416 * ucfg_mlme_cfg_set_vht_rx_mcs_map() - sets rx mcs map into 2417 * cfg item 2418 * @psoc: psoc context 2419 * @value: data to be set 2420 * 2421 * Inline UCFG API to be used by HDD/OSIF callers 2422 * 2423 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2424 */ 2425 static inline QDF_STATUS 2426 ucfg_mlme_cfg_set_vht_rx_mcs_map(struct wlan_objmgr_psoc *psoc, uint32_t value) 2427 { 2428 return wlan_mlme_cfg_set_vht_rx_mcs_map(psoc, value); 2429 } 2430 2431 /** 2432 * ucfg_mlme_cfg_get_vht_tx_mcs_map() - gets vht tx mcs map from 2433 * cfg item 2434 * @psoc: psoc context 2435 * @value: pointer to get required data 2436 * 2437 * Inline UCFG API to be used by HDD/OSIF callers to get the 2438 * ignore_peer_ht_opmode flag value 2439 * 2440 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2441 */ 2442 static inline QDF_STATUS 2443 ucfg_mlme_cfg_get_vht_tx_mcs_map(struct wlan_objmgr_psoc *psoc, uint32_t *value) 2444 { 2445 return wlan_mlme_cfg_get_vht_tx_mcs_map(psoc, value); 2446 } 2447 2448 /** 2449 * ucfg_mlme_cfg_set_vht_tx_mcs_map() - sets tx mcs map into 2450 * cfg item 2451 * @psoc: psoc context 2452 * @value: data to be set 2453 * 2454 * Inline UCFG API to be used by HDD/OSIF callers 2455 * 2456 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2457 */ 2458 static inline QDF_STATUS 2459 ucfg_mlme_cfg_set_vht_tx_mcs_map(struct wlan_objmgr_psoc *psoc, uint32_t value) 2460 { 2461 return wlan_mlme_cfg_set_vht_tx_mcs_map(psoc, value); 2462 } 2463 2464 /** 2465 * ucfg_mlme_cfg_set_vht_rx_supp_data_rate() - sets rx supported data 2466 * rate into cfg item 2467 * @psoc: psoc context 2468 * @value: data to be set 2469 * 2470 * Inline UCFG API to be used by HDD/OSIF callers 2471 * 2472 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2473 */ 2474 static inline QDF_STATUS 2475 ucfg_mlme_cfg_set_vht_rx_supp_data_rate(struct wlan_objmgr_psoc *psoc, 2476 uint32_t value) 2477 { 2478 return wlan_mlme_cfg_set_vht_rx_supp_data_rate(psoc, value); 2479 } 2480 2481 /** 2482 * ucfg_mlme_cfg_set_vht_tx_supp_data_rate() - sets tx supported data rate into 2483 * cfg item 2484 * @psoc: psoc context 2485 * @value: data to be set 2486 * 2487 * Inline UCFG API to be used by HDD/OSIF callers 2488 * 2489 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2490 */ 2491 static inline QDF_STATUS 2492 ucfg_mlme_cfg_set_vht_tx_supp_data_rate(struct wlan_objmgr_psoc *psoc, 2493 uint32_t value) 2494 { 2495 return wlan_mlme_cfg_set_vht_tx_supp_data_rate(psoc, value); 2496 } 2497 2498 /** 2499 * ucfg_mlme_cfg_get_vht_basic_mcs_set() - gets basic mcs set from 2500 * cfg item 2501 * @psoc: psoc context 2502 * @value: data to be set 2503 * 2504 * Inline UCFG API to be used by HDD/OSIF callers to get the 2505 * ignore_peer_ht_opmode flag value 2506 * 2507 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2508 */ 2509 static inline QDF_STATUS 2510 ucfg_mlme_cfg_get_vht_basic_mcs_set(struct wlan_objmgr_psoc *psoc, 2511 uint32_t *value) 2512 { 2513 return wlan_mlme_cfg_get_vht_basic_mcs_set(psoc, value); 2514 } 2515 2516 /** 2517 * ucfg_mlme_cfg_set_vht_basic_mcs_set() - sets basic mcs set into 2518 * cfg item 2519 * @psoc: psoc context 2520 * @value: data to be set 2521 * 2522 * Inline UCFG API to be used by HDD/OSIF callers to get the 2523 * ignore_peer_ht_opmode flag value 2524 * 2525 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2526 */ 2527 static inline QDF_STATUS 2528 ucfg_mlme_cfg_set_vht_basic_mcs_set(struct wlan_objmgr_psoc *psoc, 2529 uint32_t value) 2530 { 2531 return wlan_mlme_cfg_set_vht_basic_mcs_set(psoc, value); 2532 } 2533 2534 /** 2535 * ucfg_mlme_get_vht_enable_tx_bf() - gets enable TXBF for 20MHZ 2536 * for 11ac 2537 * @psoc: psoc context 2538 * @value: data to be set 2539 * 2540 * Inline UCFG API to be used by HDD/OSIF callers to get the 2541 * ignore_peer_ht_opmode flag value 2542 * 2543 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2544 */ 2545 static inline QDF_STATUS 2546 ucfg_mlme_get_vht_enable_tx_bf(struct wlan_objmgr_psoc *psoc, bool *value) 2547 { 2548 return wlan_mlme_get_vht_enable_tx_bf(psoc, value); 2549 } 2550 2551 /** 2552 * ucfg_mlme_get_vht_tx_su_beamformer() - gets enable tx_su_beamformer 2553 * for 11ac 2554 * @psoc: psoc context 2555 * @value: data to be set 2556 * 2557 * Inline UCFG API to be used by HDD/OSIF callers to get the 2558 * ignore_peer_ht_opmode flag value 2559 * 2560 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2561 */ 2562 static inline QDF_STATUS 2563 ucfg_mlme_get_vht_tx_su_beamformer(struct wlan_objmgr_psoc *psoc, bool *value) 2564 { 2565 return wlan_mlme_get_vht_tx_su_beamformer(psoc, value); 2566 } 2567 2568 /** 2569 * ucfg_mlme_get_vht_channel_width() - gets Channel width capability 2570 * for 11ac 2571 * @psoc: psoc context 2572 * @value: data to be set 2573 * 2574 * Inline UCFG API to be used by HDD/OSIF callers to get the 2575 * ignore_peer_ht_opmode flag value 2576 * 2577 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2578 */ 2579 static inline QDF_STATUS 2580 ucfg_mlme_get_vht_channel_width(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2581 { 2582 return wlan_mlme_get_vht_channel_width(psoc, value); 2583 } 2584 2585 /** 2586 * ucfg_mlme_get_vht_rx_mcs_8_9() - VHT Rx MCS capability for 1x1 mode 2587 * for 11ac 2588 * @psoc: psoc context 2589 * @value: data to be set 2590 * 2591 * Inline UCFG API to be used by HDD/OSIF callers to get the 2592 * ignore_peer_ht_opmode flag value 2593 * 2594 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2595 */ 2596 static inline QDF_STATUS 2597 ucfg_mlme_get_vht_rx_mcs_8_9(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2598 { 2599 return wlan_mlme_get_vht_rx_mcs_8_9(psoc, value); 2600 } 2601 2602 /** 2603 * ucfg_mlme_get_vht_tx_mcs_8_9() - VHT Tx MCS capability for 1x1 mode 2604 * for 11ac 2605 * @psoc: psoc context 2606 * @value: data to be set 2607 * 2608 * Inline UCFG API to be used by HDD/OSIF callers to get the 2609 * ignore_peer_ht_opmode flag value 2610 * 2611 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2612 */ 2613 static inline QDF_STATUS 2614 ucfg_mlme_get_vht_tx_mcs_8_9(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2615 { 2616 return wlan_mlme_get_vht_tx_mcs_8_9(psoc, value); 2617 } 2618 2619 /** 2620 * ucfg_mlme_get_vht_rx_mcs_2x2() - VHT Rx MCS capability for 2x2 mode 2621 * for 11ac 2622 * @psoc: psoc context 2623 * @value: data to be set 2624 * 2625 * Inline UCFG API to be used by HDD/OSIF callers to get the 2626 * ignore_peer_ht_opmode flag value 2627 * 2628 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2629 */ 2630 static inline QDF_STATUS 2631 ucfg_mlme_get_vht_rx_mcs_2x2(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2632 { 2633 return wlan_mlme_get_vht_rx_mcs_2x2(psoc, value); 2634 } 2635 2636 /** 2637 * ucfg_mlme_get_vht_tx_mcs_2x2() - VHT Tx MCS capability for 2x2 mode 2638 * for 11ac 2639 * @psoc: psoc context 2640 * @value: data to be set 2641 * 2642 * Inline UCFG API to be used by HDD/OSIF callers to get the 2643 * ignore_peer_ht_opmode flag value 2644 * 2645 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2646 */ 2647 static inline QDF_STATUS 2648 ucfg_mlme_get_vht_tx_mcs_2x2(struct wlan_objmgr_psoc *psoc, uint8_t *value) 2649 { 2650 return wlan_mlme_get_vht_tx_mcs_2x2(psoc, value); 2651 } 2652 2653 /** 2654 * ucfg_mlme_peer_get_assoc_rsp_ies() - Get assoc response sent to peer 2655 * @peer: WLAN peer objmgr 2656 * @ie_buf: Pointer to IE buffer 2657 * @ie_len: Length of the IE buffer 2658 * 2659 * This API is used to get the assoc response sent to peer 2660 * as part of association. 2661 * Caller to hold reference for peer. 2662 * 2663 * Return: QDF_STATUS 2664 */ 2665 static inline QDF_STATUS 2666 ucfg_mlme_peer_get_assoc_rsp_ies(struct wlan_objmgr_peer *peer, 2667 const uint8_t **ie_buf, 2668 size_t *ie_len) 2669 { 2670 return wlan_mlme_peer_get_assoc_rsp_ies(peer, ie_buf, ie_len); 2671 } 2672 2673 /** 2674 * ucfg_mlme_get_ini_vdev_config() - get the ini capability of vdev 2675 * @vdev: pointer to the vdev obj 2676 * 2677 * This API will get the ini config of the vdev related to 2678 * the nss, chains params 2679 * 2680 * Return: pointer to the nss, chain param ini cfg structure 2681 */ 2682 static inline struct wlan_mlme_nss_chains * 2683 ucfg_mlme_get_ini_vdev_config(struct wlan_objmgr_vdev *vdev) 2684 { 2685 return mlme_get_ini_vdev_config(vdev); 2686 } 2687 2688 /** 2689 * ucfg_mlme_get_dynamic_vdev_config() - get the dynamic capability of vdev 2690 * @vdev: pointer to the vdev obj 2691 * 2692 * This API will get the dynamic config of the vdev related to nss, 2693 * chains params 2694 * 2695 * Return: pointer to the nss, chain param dynamic cfg structure 2696 */ 2697 static inline struct wlan_mlme_nss_chains * 2698 ucfg_mlme_get_dynamic_vdev_config(struct wlan_objmgr_vdev *vdev) 2699 { 2700 return mlme_get_dynamic_vdev_config(vdev); 2701 } 2702 2703 /** 2704 * ucfg_mlme_get_vht20_mcs9() - Enables VHT MCS9 in 20M BW operation 2705 * @psoc: psoc context 2706 * @value: data to be set 2707 * 2708 * Inline UCFG API to be used by HDD/OSIF callers to get the 2709 * ignore_peer_ht_opmode flag value 2710 * 2711 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2712 */ 2713 static inline QDF_STATUS 2714 ucfg_mlme_get_vht20_mcs9(struct wlan_objmgr_psoc *psoc, bool *value) 2715 { 2716 return wlan_mlme_get_vht20_mcs9(psoc, value); 2717 } 2718 2719 /** 2720 * ucfg_mlme_get_enable_dynamic_nss_chains_cfg() - API to get whether dynamic 2721 * nss and chain config is enabled or not 2722 * @psoc: psoc context 2723 * @value: data to be set 2724 * 2725 * API to get whether dynamic nss and chain config is enabled or not 2726 * 2727 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2728 */ 2729 static inline QDF_STATUS 2730 ucfg_mlme_get_enable_dynamic_nss_chains_cfg(struct wlan_objmgr_psoc *psoc, 2731 bool *value) 2732 { 2733 return wlan_mlme_get_enable_dynamic_nss_chains_cfg(psoc, value); 2734 } 2735 2736 /** 2737 * ucfg_mlme_get_restart_sap_on_dynamic_nss_chains_cfg() - API to get whether 2738 * SAP needs to be restarted or not on dynamic nss chain config 2739 * @psoc: psoc context 2740 * @value: data to be set 2741 * 2742 * API to get whether SAP needs to be restarted or not on dynamic nss chain 2743 * config 2744 * 2745 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2746 */ 2747 static inline QDF_STATUS 2748 ucfg_mlme_get_restart_sap_on_dynamic_nss_chains_cfg( 2749 struct wlan_objmgr_psoc *psoc, 2750 bool *value) 2751 { 2752 return wlan_mlme_get_restart_sap_on_dynamic_nss_chains_cfg(psoc, value); 2753 } 2754 2755 /** 2756 * ucfg_mlme_update_dynamic_nss_chains_support() - API to update 2757 * dynamic_nss_chains_support 2758 * 2759 * @psoc: psoc context 2760 * @val: data to be set 2761 * 2762 * API is used to update dynamic_nss_chains_support flag in wlan_mlme_cfg 2763 * to maintain this value in mlme context 2764 * 2765 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2766 */ 2767 static inline QDF_STATUS 2768 ucfg_mlme_update_dynamic_nss_chains_support(struct wlan_objmgr_psoc *psoc, 2769 bool val) 2770 { 2771 return wlan_mlme_cfg_set_dynamic_nss_chains_support(psoc, val); 2772 } 2773 2774 /** 2775 * ucfg_mlme_get_sta_num_tx_chains() - UCFG API to get station num tx chains 2776 * 2777 * @psoc: psoc context 2778 * @vdev: pointer to vdev 2779 * @tx_chains : tx_chains out parameter 2780 * 2781 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2782 */ 2783 static inline QDF_STATUS 2784 ucfg_mlme_get_sta_num_tx_chains(struct wlan_objmgr_psoc *psoc, 2785 struct wlan_objmgr_vdev *vdev, 2786 uint8_t *tx_chains) 2787 { 2788 return wlan_mlme_get_sta_num_tx_chains(psoc, vdev, tx_chains); 2789 } 2790 2791 /** 2792 * ucfg_mlme_get_sta_num_rx_chains() - UCFG API to get station num rx chains 2793 * 2794 * @psoc: psoc context 2795 * @vdev: pointer to vdev 2796 * @rx_chains : rx_chains out parameter 2797 * 2798 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2799 */ 2800 static inline QDF_STATUS 2801 ucfg_mlme_get_sta_num_rx_chains(struct wlan_objmgr_psoc *psoc, 2802 struct wlan_objmgr_vdev *vdev, 2803 uint8_t *rx_chains) 2804 { 2805 return wlan_mlme_get_sta_num_rx_chains(psoc, vdev, rx_chains); 2806 } 2807 2808 /** 2809 * ucfg_mlme_get_sta_tx_nss() - UCFG API to get station tx NSS 2810 * 2811 * @psoc: psoc context 2812 * @vdev: pointer to vdev 2813 * @tx_nss : tx_nss out parameter 2814 * 2815 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2816 */ 2817 static inline QDF_STATUS 2818 ucfg_mlme_get_sta_tx_nss(struct wlan_objmgr_psoc *psoc, 2819 struct wlan_objmgr_vdev *vdev, uint8_t *tx_nss) 2820 { 2821 return wlan_mlme_get_sta_tx_nss(psoc, vdev, tx_nss); 2822 } 2823 2824 /** 2825 * ucfg_mlme_get_sta_rx_nss() - UCFG API to get station rx NSS 2826 * 2827 * @psoc: psoc context 2828 * @vdev: pointer to vdev 2829 * @rx_nss : rx_nss out parameter 2830 * 2831 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2832 */ 2833 static inline QDF_STATUS 2834 ucfg_mlme_get_sta_rx_nss(struct wlan_objmgr_psoc *psoc, 2835 struct wlan_objmgr_vdev *vdev, 2836 uint8_t *rx_nss) 2837 { 2838 return wlan_mlme_get_sta_rx_nss(psoc, vdev, rx_nss); 2839 } 2840 2841 /** 2842 * ucfg_mlme_get_vht_enable2x2() - Enables/disables VHT Tx/Rx MCS values for 2x2 2843 * @psoc: psoc context 2844 * @value: data to be set 2845 * 2846 * Inline UCFG API to be used by HDD/OSIF callers to get the 2847 * ignore_peer_ht_opmode flag value 2848 * 2849 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2850 */ 2851 static inline QDF_STATUS 2852 ucfg_mlme_get_vht_enable2x2(struct wlan_objmgr_psoc *psoc, bool *value) 2853 { 2854 return wlan_mlme_get_vht_enable2x2(psoc, value); 2855 } 2856 2857 /** 2858 * ucfg_mlme_get_force_sap_enabled() - Get the value of force SAP enabled 2859 * @psoc: psoc context 2860 * @value: data to get 2861 * 2862 * Get the value of force SAP enabled 2863 * 2864 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2865 */ 2866 static inline QDF_STATUS 2867 ucfg_mlme_get_force_sap_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 2868 { 2869 return wlan_mlme_get_force_sap_enabled(psoc, value); 2870 } 2871 2872 /** 2873 * ucfg_mlme_set_vht_enable2x2() - Enables/disables VHT Tx/Rx MCS values for 2x2 2874 * @psoc: psoc context 2875 * @value: data to be set 2876 * 2877 * Inline UCFG API to be used by HDD/OSIF callers to get the 2878 * ignore_peer_ht_opmode flag value 2879 * 2880 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2881 */ 2882 static inline QDF_STATUS 2883 ucfg_mlme_set_vht_enable2x2(struct wlan_objmgr_psoc *psoc, bool value) 2884 { 2885 return wlan_mlme_set_vht_enable2x2(psoc, value); 2886 } 2887 2888 /** 2889 * ucfg_mlme_get_vht_enable_paid() - Enables/disables paid feature 2890 * @psoc: psoc context 2891 * @value: data to be set 2892 * 2893 * Inline UCFG API to be used by HDD/OSIF callers to get the 2894 * ignore_peer_ht_opmode flag value 2895 * 2896 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2897 */ 2898 static inline QDF_STATUS 2899 ucfg_mlme_get_vht_enable_paid(struct wlan_objmgr_psoc *psoc, bool *value) 2900 { 2901 return wlan_mlme_get_vht_enable_paid(psoc, value); 2902 } 2903 2904 /** 2905 * ucfg_mlme_get_vht_enable_gid() - Enables/disables gid feature 2906 * @psoc: psoc context 2907 * @value: data to be set 2908 * 2909 * Inline UCFG API to be used by HDD/OSIF callers to get the 2910 * ignore_peer_ht_opmode flag value 2911 * 2912 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2913 */ 2914 static inline QDF_STATUS 2915 ucfg_mlme_get_vht_enable_gid(struct wlan_objmgr_psoc *psoc, bool *value) 2916 { 2917 return wlan_mlme_get_vht_enable_gid(psoc, value); 2918 } 2919 2920 /** 2921 * ucfg_mlme_get_vht_for_24ghz() - Get mlme cfg of vht for 24ghz 2922 * @psoc: psoc context 2923 * @value: data to get 2924 * 2925 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2926 */ 2927 static inline QDF_STATUS 2928 ucfg_mlme_get_vht_for_24ghz(struct wlan_objmgr_psoc *psoc, bool *value) 2929 { 2930 return wlan_mlme_get_vht_for_24ghz(psoc, value); 2931 } 2932 2933 /** 2934 * ucfg_mlme_set_vht_for_24ghz() - Enables/disables vht for 24ghz 2935 * @psoc: psoc context 2936 * @value: data to be set 2937 * 2938 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2939 */ 2940 static inline QDF_STATUS 2941 ucfg_mlme_set_vht_for_24ghz(struct wlan_objmgr_psoc *psoc, bool value) 2942 { 2943 return wlan_mlme_set_vht_for_24ghz(psoc, value); 2944 } 2945 2946 /** 2947 * ucfg_mlme_get_vendor_vht_for_24ghz() - Get mlme cfg of vendor vht for 24ghz 2948 * @psoc: psoc context 2949 * @value: data to be set 2950 * 2951 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2952 */ 2953 static inline QDF_STATUS 2954 ucfg_mlme_get_vendor_vht_for_24ghz(struct wlan_objmgr_psoc *psoc, bool *value) 2955 { 2956 return wlan_mlme_get_vendor_vht_for_24ghz(psoc, value); 2957 } 2958 2959 /** 2960 * ucfg_mlme_update_vht_cap() - Update vht capabilities 2961 * @psoc: psoc context 2962 * @cfg: data to be set 2963 * 2964 * Inline UCFG API to be used by HDD/OSIF callers to get the 2965 * ignore_peer_ht_opmode flag value 2966 * 2967 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2968 */ 2969 static inline 2970 QDF_STATUS ucfg_mlme_update_vht_cap(struct wlan_objmgr_psoc *psoc, 2971 struct wma_tgt_vht_cap *cfg) 2972 { 2973 return mlme_update_vht_cap(psoc, cfg); 2974 } 2975 2976 /** 2977 * ucfg_mlme_update_nss_vht_cap() - Update the number of spatial 2978 * streams supported for vht 2979 * @psoc: psoc context 2980 * 2981 * Inline UCFG API to be used by HDD/OSIF callers to get the 2982 * ignore_peer_ht_opmode flag value 2983 * 2984 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 2985 */ 2986 static inline QDF_STATUS 2987 ucfg_mlme_update_nss_vht_cap(struct wlan_objmgr_psoc *psoc) 2988 { 2989 return mlme_update_nss_vht_cap(psoc); 2990 } 2991 2992 /** 2993 * ucfg_mlme_is_11h_enabled() - Get 11h flag 2994 * @psoc: pointer to psoc object 2995 * @value: Value that needs to be set from the caller 2996 * 2997 * Inline UCFG API to be used by HDD/OSIF callers 2998 * 2999 * Return: QDF Status 3000 */ 3001 static inline QDF_STATUS 3002 ucfg_mlme_is_11h_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 3003 { 3004 return wlan_mlme_is_11h_enabled(psoc, value); 3005 } 3006 3007 /** 3008 * ucfg_mlme_set_11h_enabled() - Set 11h flag 3009 * @psoc: pointer to psoc object 3010 * @value: Value that needs to be set from the caller 3011 * 3012 * Inline UCFG API to be used by HDD/OSIF callers 3013 * 3014 * Return: QDF Status 3015 */ 3016 static inline QDF_STATUS 3017 ucfg_mlme_set_11h_enabled(struct wlan_objmgr_psoc *psoc, bool value) 3018 { 3019 return wlan_mlme_set_11h_enabled(psoc, value); 3020 } 3021 3022 /** 3023 * ucfg_mlme_is_11d_enabled() - Get 11d flag 3024 * @psoc: pointer to psoc object 3025 * @value: Value that needs to be set from the caller 3026 * 3027 * Inline UCFG API to be used by HDD/OSIF callers 3028 * 3029 * Return: QDF Status 3030 */ 3031 static inline QDF_STATUS 3032 ucfg_mlme_is_11d_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 3033 { 3034 return wlan_mlme_is_11d_enabled(psoc, value); 3035 } 3036 3037 /** 3038 * ucfg_mlme_set_11d_enabled() - Set 11d flag 3039 * @psoc: pointer to psoc object 3040 * @value: Value that needs to be set from the caller 3041 * 3042 * Inline UCFG API to be used by HDD/OSIF callers 3043 * 3044 * Return: QDF Status 3045 */ 3046 static inline QDF_STATUS 3047 ucfg_mlme_set_11d_enabled(struct wlan_objmgr_psoc *psoc, bool value) 3048 { 3049 return wlan_mlme_set_11d_enabled(psoc, value); 3050 } 3051 3052 /** 3053 * ucfg_mlme_is_rf_test_mode_enabled() - Get rf test mode flag 3054 * @psoc: pointer to psoc object 3055 * @value: Value that needs to be set from the caller 3056 * 3057 * Inline UCFG API to be used by HDD/OSIF callers 3058 * 3059 * Return: QDF Status 3060 */ 3061 static inline QDF_STATUS 3062 ucfg_mlme_is_rf_test_mode_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 3063 { 3064 return wlan_mlme_is_rf_test_mode_enabled(psoc, value); 3065 } 3066 3067 /** 3068 * ucfg_mlme_set_rf_test_mode_enabled() - Set rf test mode flag 3069 * @psoc: pointer to psoc object 3070 * @value: Value that needs to be set from the caller 3071 * 3072 * Inline UCFG API to be used by HDD/OSIF callers 3073 * 3074 * Return: QDF Status 3075 */ 3076 static inline QDF_STATUS 3077 ucfg_mlme_set_rf_test_mode_enabled(struct wlan_objmgr_psoc *psoc, bool value) 3078 { 3079 return wlan_mlme_set_rf_test_mode_enabled(psoc, value); 3080 } 3081 3082 /** 3083 * ucfg_mlme_is_disable_vlp_sta_conn_to_sp_ap_enabled() - Get disable vlp sta 3084 * conn to sp ap flag 3085 * @psoc: pointer to psoc object 3086 * @value: pointer to hold the value of flag 3087 * 3088 * Inline UCFG API to be used by HDD/OSIF callers 3089 * 3090 * Return: QDF Status 3091 */ 3092 static inline QDF_STATUS 3093 ucfg_mlme_is_disable_vlp_sta_conn_to_sp_ap_enabled( 3094 struct wlan_objmgr_psoc *psoc, 3095 bool *value) 3096 { 3097 return wlan_mlme_is_disable_vlp_sta_conn_to_sp_ap_enabled(psoc, value); 3098 } 3099 3100 /** 3101 * ucfg_mlme_is_standard_6ghz_conn_policy_enabled() - Get 6ghz standard 3102 * connection policy flag 3103 * @psoc: pointer to psoc object 3104 * @value: pointer to hold the value of flag 3105 * 3106 * Inline UCFG API to be used by HDD/OSIF callers 3107 * 3108 * Return: QDF Status 3109 */ 3110 static inline QDF_STATUS 3111 ucfg_mlme_is_standard_6ghz_conn_policy_enabled(struct wlan_objmgr_psoc *psoc, 3112 bool *value) 3113 { 3114 return wlan_mlme_is_standard_6ghz_conn_policy_enabled(psoc, value); 3115 } 3116 3117 /** 3118 * ucfg_mlme_set_eht_mode() - Set EHT mode of operation 3119 * @psoc: pointer to psoc object 3120 * @value: EHT mode value that needs to be set from the caller 3121 * 3122 * Inline UCFG API to be used by HDD/OSIF callers 3123 * 3124 * Return: QDF Status 3125 */ 3126 static inline QDF_STATUS 3127 ucfg_mlme_set_eht_mode(struct wlan_objmgr_psoc *psoc, enum wlan_eht_mode value) 3128 { 3129 return wlan_mlme_set_eht_mode(psoc, value); 3130 } 3131 3132 /** 3133 * ucfg_mlme_get_eht_mode() - Get EHT mode of operation 3134 * @psoc: pointer to psoc object 3135 * @value: EHT mode value that is set by the user 3136 * 3137 * Inline UCFG API to be used by HDD/OSIF callers 3138 * 3139 * Return: QDF Status 3140 */ 3141 static inline QDF_STATUS 3142 ucfg_mlme_get_eht_mode(struct wlan_objmgr_psoc *psoc, enum wlan_eht_mode *value) 3143 { 3144 return wlan_mlme_get_eht_mode(psoc, value); 3145 } 3146 3147 /** 3148 * ucfg_mlme_is_multipass_sap() - check whether FW supports 3149 * multipass sap capabilities 3150 * @psoc: pointer to psoc object 3151 * 3152 * Inline UCFG API to be used by HDD/OSIF callers 3153 * 3154 * Return: True if FW support mulitpass sap 3155 */ 3156 static inline bool 3157 ucfg_mlme_is_multipass_sap(struct wlan_objmgr_psoc *psoc) 3158 { 3159 return wlan_mlme_is_multipass_sap(psoc); 3160 } 3161 3162 /** 3163 * ucfg_mlme_set_emlsr_mode_enabled() - Set eMLSR mode flag 3164 * @psoc: pointer to psoc object 3165 * @value: Value that needs to be set from the caller 3166 * 3167 * Inline UCFG API to be used by HDD/OSIF callers 3168 * 3169 * Return: QDF Status 3170 */ 3171 static inline QDF_STATUS 3172 ucfg_mlme_set_emlsr_mode_enabled(struct wlan_objmgr_psoc *psoc, bool value) 3173 { 3174 return wlan_mlme_set_emlsr_mode_enabled(psoc, value); 3175 } 3176 3177 /** 3178 * ucfg_mlme_get_emlsr_mode_enabled() - Get eMLSR mode flag 3179 * @psoc: pointer to psoc object 3180 * @value: Value that is set by the user 3181 * 3182 * Inline UCFG API to be used by HDD/OSIF callers 3183 * 3184 * Return: QDF Status 3185 */ 3186 static inline QDF_STATUS 3187 ucfg_mlme_get_emlsr_mode_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 3188 { 3189 return wlan_mlme_get_emlsr_mode_enabled(psoc, value); 3190 } 3191 3192 /** 3193 * ucfg_mlme_set_t2lm_negotiation_supported() - Enables/disables t2lm 3194 * negotiation support value 3195 * @psoc: psoc context 3196 * @value: data to be set 3197 * 3198 * Inline UCFG API to be used by HDD/OSIF callers to set the 3199 * t2lm negotiation supported value 3200 * 3201 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 3202 */ 3203 static inline QDF_STATUS 3204 ucfg_mlme_set_t2lm_negotiation_supported(struct wlan_objmgr_psoc *psoc, 3205 bool value) 3206 { 3207 return wlan_mlme_set_t2lm_negotiation_supported(psoc, value); 3208 } 3209 3210 /** 3211 * ucfg_mlme_get_opr_rate() - Get operational rate set 3212 * @vdev: pointer to vdev object 3213 * @buf: buffer to get rates set 3214 * @len: length of the buffer 3215 * 3216 * Return: length of the rates set 3217 */ 3218 static inline qdf_size_t 3219 ucfg_mlme_get_opr_rate(struct wlan_objmgr_vdev *vdev, uint8_t *buf, 3220 qdf_size_t len) 3221 { 3222 return mlme_get_opr_rate(vdev, buf, len); 3223 } 3224 3225 /** 3226 * ucfg_mlme_get_ext_opr_rate() - Get extended operational rate set 3227 * @vdev: pointer to vdev object 3228 * @buf: buffer to get rates set 3229 * @len: length of the buffer 3230 * 3231 * Return: length of the rates set 3232 */ 3233 static inline qdf_size_t 3234 ucfg_mlme_get_ext_opr_rate(struct wlan_objmgr_vdev *vdev, uint8_t *buf, 3235 qdf_size_t len) 3236 { 3237 return mlme_get_ext_opr_rate(vdev, buf, len); 3238 } 3239 3240 /** 3241 * ucfg_mlme_get_mcs_rate() - Get MCS based rate set 3242 * @vdev: pointer to vdev object 3243 * @buf: buffer to get rates set 3244 * @len: length of the buffer 3245 * 3246 * Return: length of the rates set 3247 */ 3248 static inline qdf_size_t 3249 ucfg_mlme_get_mcs_rate(struct wlan_objmgr_vdev *vdev, uint8_t *buf, 3250 qdf_size_t len) 3251 { 3252 return mlme_get_mcs_rate(vdev, buf, len); 3253 } 3254 3255 /** 3256 * ucfg_mlme_get_supported_mcs_set() - Get Supported MCS set 3257 * @psoc: pointer to psoc object 3258 * @buf: caller buffer to copy mcs set info 3259 * @len: length of the buffer 3260 * Return: QDF Status 3261 */ 3262 QDF_STATUS 3263 ucfg_mlme_get_supported_mcs_set(struct wlan_objmgr_psoc *psoc, uint8_t *buf, 3264 qdf_size_t *len); 3265 3266 /** 3267 * ucfg_mlme_set_supported_mcs_set() - Get Supported MCS set 3268 * @psoc: pointer to psoc object 3269 * @buf: caller buffer having mcs set info 3270 * @len: length of the buffer 3271 * Return: QDF Status 3272 */ 3273 QDF_STATUS 3274 ucfg_mlme_set_supported_mcs_set(struct wlan_objmgr_psoc *psoc, uint8_t *buf, 3275 qdf_size_t len); 3276 3277 /** 3278 * ucfg_mlme_get_current_mcs_set() - Get current MCS set 3279 * @psoc: pointer to psoc object 3280 * @buf: caller buffer to copy mcs set info 3281 * @len: length of the buffer 3282 * Return: QDF Status 3283 */ 3284 QDF_STATUS 3285 ucfg_mlme_get_current_mcs_set(struct wlan_objmgr_psoc *psoc, uint8_t *buf, 3286 qdf_size_t *len); 3287 3288 /** 3289 * ucfg_mlme_get_sta_keepalive_method() - Get sta_keepalive_method 3290 * @psoc: pointer to psoc object 3291 * @val: Value to pass to the caller 3292 * 3293 * Return: QDF Status 3294 */ 3295 QDF_STATUS 3296 ucfg_mlme_get_sta_keepalive_method(struct wlan_objmgr_psoc *psoc, 3297 enum station_keepalive_method *val); 3298 3299 /** 3300 * ucfg_mlme_stats_get_periodic_display_time() - get display time 3301 * @psoc: pointer to psoc object 3302 * @periodic_display_time: buffer to hold value 3303 * 3304 * Return: QDF Status 3305 */ 3306 QDF_STATUS 3307 ucfg_mlme_stats_get_periodic_display_time(struct wlan_objmgr_psoc *psoc, 3308 uint32_t *periodic_display_time); 3309 3310 /** 3311 * ucfg_mlme_stats_get_cfg_values() - get stats cfg values 3312 * @psoc: pointer to psoc object 3313 * @link_speed_rssi_high: link speed high limit 3314 * @link_speed_rssi_mid: link speed high mid 3315 * @link_speed_rssi_low: link speed high low 3316 * @link_speed_rssi_report: link speed report limit 3317 * 3318 * Return: QDF Status 3319 */ 3320 QDF_STATUS 3321 ucfg_mlme_stats_get_cfg_values(struct wlan_objmgr_psoc *psoc, 3322 int *link_speed_rssi_high, 3323 int *link_speed_rssi_mid, 3324 int *link_speed_rssi_low, 3325 uint32_t *link_speed_rssi_report); 3326 3327 /** 3328 * ucfg_mlme_stats_is_link_speed_report_actual() - is link speed report set 3329 * actual 3330 * @psoc: pointer to psoc object 3331 * 3332 * Return: True is report set to actual 3333 */ 3334 bool 3335 ucfg_mlme_stats_is_link_speed_report_actual(struct wlan_objmgr_psoc *psoc); 3336 3337 /** 3338 * ucfg_mlme_stats_is_link_speed_report_max() - is link speed report set max 3339 * @psoc: pointer to psoc object 3340 * 3341 * Return: True is report set to max 3342 */ 3343 bool 3344 ucfg_mlme_stats_is_link_speed_report_max(struct wlan_objmgr_psoc *psoc); 3345 3346 /** 3347 * ucfg_mlme_stats_is_link_speed_report_max_scaled() - is link speed report set 3348 * max scaled 3349 * @psoc: pointer to psoc object 3350 * 3351 * Return: True is report set to max scaled 3352 */ 3353 bool 3354 ucfg_mlme_stats_is_link_speed_report_max_scaled(struct wlan_objmgr_psoc *psoc); 3355 3356 /** 3357 * ucfg_mlme_get_tl_delayed_trgr_frm_int() - Get delay interval(in ms) 3358 * of UAPSD auto trigger. 3359 * @psoc: pointer to psoc object 3360 * @value: Value that needs to be set from the caller 3361 * 3362 * Inline UCFG API to be used by HDD/OSIF callers 3363 * 3364 * Return: None 3365 */ 3366 static inline 3367 void ucfg_mlme_get_tl_delayed_trgr_frm_int(struct wlan_objmgr_psoc *psoc, 3368 uint32_t *value) 3369 { 3370 wlan_mlme_get_tl_delayed_trgr_frm_int(psoc, value); 3371 } 3372 3373 /** 3374 * ucfg_mlme_get_wmm_dir_ac_vi() - Get TSPEC direction for VI 3375 * @psoc: pointer to psoc object 3376 * @value: Value that needs to be set from the caller 3377 * 3378 * Inline UCFG API to be used by HDD/OSIF callers 3379 * 3380 * Return: QDF Status 3381 */ 3382 static inline QDF_STATUS 3383 ucfg_mlme_get_wmm_dir_ac_vi(struct wlan_objmgr_psoc *psoc, uint8_t *value) 3384 { 3385 return wlan_mlme_get_wmm_dir_ac_vi(psoc, value); 3386 } 3387 3388 /** 3389 * ucfg_mlme_get_wmm_nom_msdu_size_ac_vi() - Get normal MSDU size for VI 3390 * @psoc: pointer to psoc object 3391 * @value: Value that needs to be set from the caller 3392 * 3393 * Inline UCFG API to be used by HDD/OSIF callers 3394 * 3395 * Return: QDF Status 3396 */ 3397 static inline 3398 QDF_STATUS ucfg_mlme_get_wmm_nom_msdu_size_ac_vi(struct wlan_objmgr_psoc *psoc, 3399 uint16_t *value) 3400 { 3401 return wlan_mlme_get_wmm_nom_msdu_size_ac_vi(psoc, value); 3402 } 3403 3404 /** 3405 * ucfg_mlme_get_wmm_mean_data_rate_ac_vi() - mean data rate for VI 3406 * @psoc: pointer to psoc object 3407 * @value: Value that needs to be set from the caller 3408 * 3409 * Inline UCFG API to be used by HDD/OSIF callers 3410 * 3411 * Return: QDF Status 3412 */ 3413 static inline 3414 QDF_STATUS ucfg_mlme_get_wmm_mean_data_rate_ac_vi(struct wlan_objmgr_psoc *psoc, 3415 uint32_t *value) 3416 { 3417 return wlan_mlme_get_wmm_mean_data_rate_ac_vi(psoc, value); 3418 } 3419 3420 /** 3421 * ucfg_mlme_get_wmm_min_phy_rate_ac_vi() - min PHY rate for VI 3422 * @psoc: pointer to psoc object 3423 * @value: Value that needs to be set from the caller 3424 * 3425 * Inline UCFG API to be used by HDD/OSIF callers 3426 * 3427 * Return: QDF Status 3428 */ 3429 static inline 3430 QDF_STATUS ucfg_mlme_get_wmm_min_phy_rate_ac_vi(struct wlan_objmgr_psoc *psoc, 3431 uint32_t *value) 3432 { 3433 return wlan_mlme_get_wmm_min_phy_rate_ac_vi(psoc, value); 3434 } 3435 3436 /** 3437 * ucfg_mlme_get_wmm_sba_ac_vi() - surplus bandwidth allowance for VI 3438 * @psoc: pointer to psoc object 3439 * @value: Value that needs to be set from the caller 3440 * 3441 * Inline UCFG API to be used by HDD/OSIF callers 3442 * 3443 * Return: QDF Status 3444 */ 3445 static inline QDF_STATUS 3446 ucfg_mlme_get_wmm_sba_ac_vi(struct wlan_objmgr_psoc *psoc, uint16_t *value) 3447 { 3448 return wlan_mlme_get_wmm_sba_ac_vi(psoc, value); 3449 } 3450 3451 /** 3452 * ucfg_mlme_get_wmm_uapsd_vi_srv_intv() - Get Uapsd service 3453 * interval for video 3454 * @psoc: pointer to psoc object 3455 * @value: pointer to the value which will be filled for the caller 3456 * 3457 * Inline UCFG API to be used by HDD/OSIF callers 3458 * 3459 * Return: QDF Status 3460 */ 3461 static inline QDF_STATUS 3462 ucfg_mlme_get_wmm_uapsd_vi_srv_intv(struct wlan_objmgr_psoc *psoc, 3463 uint32_t *value) 3464 { 3465 return wlan_mlme_get_wmm_uapsd_vi_srv_intv(psoc, value); 3466 } 3467 3468 /** 3469 * ucfg_mlme_get_wmm_uapsd_vi_sus_intv() - Get Uapsd suspension 3470 * interval for video 3471 * @psoc: pointer to psoc object 3472 * @value: Value that needs to be set from the caller 3473 * 3474 * Inline UCFG API to be used by HDD/OSIF callers 3475 * 3476 * Return: QDF Status 3477 */ 3478 static inline QDF_STATUS 3479 ucfg_mlme_get_wmm_uapsd_vi_sus_intv(struct wlan_objmgr_psoc *psoc, 3480 uint32_t *value) 3481 { 3482 return wlan_mlme_get_wmm_uapsd_vi_sus_intv(psoc, value); 3483 } 3484 3485 /** 3486 * ucfg_mlme_get_wmm_dir_ac_be() - Get TSPEC direction for BE 3487 * @psoc: pointer to psoc object 3488 * @value: Value that needs to be set from the caller 3489 * 3490 * Inline UCFG API to be used by HDD/OSIF callers 3491 * 3492 * Return: QDF Status 3493 */ 3494 static inline QDF_STATUS 3495 ucfg_mlme_get_wmm_dir_ac_be(struct wlan_objmgr_psoc *psoc, uint8_t *value) 3496 { 3497 return wlan_mlme_get_wmm_dir_ac_be(psoc, value); 3498 } 3499 3500 /** 3501 * ucfg_mlme_get_wmm_nom_msdu_size_ac_be() - Get normal MSDU size for BE 3502 * @psoc: pointer to psoc object 3503 * @value: Value that needs to be set from the caller 3504 * 3505 * Inline UCFG API to be used by HDD/OSIF callers 3506 * 3507 * Return: QDF Status 3508 */ 3509 static inline 3510 QDF_STATUS ucfg_mlme_get_wmm_nom_msdu_size_ac_be(struct wlan_objmgr_psoc *psoc, 3511 uint16_t *value) 3512 { 3513 return wlan_mlme_get_wmm_nom_msdu_size_ac_be(psoc, value); 3514 } 3515 3516 /** 3517 * ucfg_mlme_get_wmm_mean_data_rate_ac_be() - mean data rate for BE 3518 * @psoc: pointer to psoc object 3519 * @value: Value that needs to be set from the caller 3520 * 3521 * Inline UCFG API to be used by HDD/OSIF callers 3522 * 3523 * Return: QDF Status 3524 */ 3525 static inline 3526 QDF_STATUS ucfg_mlme_get_wmm_mean_data_rate_ac_be(struct wlan_objmgr_psoc *psoc, 3527 uint32_t *value) 3528 { 3529 return wlan_mlme_get_wmm_mean_data_rate_ac_be(psoc, value); 3530 } 3531 3532 /** 3533 * ucfg_mlme_get_wmm_min_phy_rate_ac_be() - min PHY rate for BE 3534 * @psoc: pointer to psoc object 3535 * @value: Value that needs to be set from the caller 3536 * 3537 * Inline UCFG API to be used by HDD/OSIF callers 3538 * 3539 * Return: QDF Status 3540 */ 3541 static inline 3542 QDF_STATUS ucfg_mlme_get_wmm_min_phy_rate_ac_be(struct wlan_objmgr_psoc *psoc, 3543 uint32_t *value) 3544 { 3545 return wlan_mlme_get_wmm_min_phy_rate_ac_be(psoc, value); 3546 } 3547 3548 /** 3549 * ucfg_mlme_get_wmm_sba_ac_be() - surplus bandwidth allowance for BE 3550 * @psoc: pointer to psoc object 3551 * @value: Value that needs to be set from the caller 3552 * 3553 * Inline UCFG API to be used by HDD/OSIF callers 3554 * 3555 * Return: QDF Status 3556 */ 3557 static inline QDF_STATUS 3558 ucfg_mlme_get_wmm_sba_ac_be(struct wlan_objmgr_psoc *psoc, uint16_t *value) 3559 { 3560 return wlan_mlme_get_wmm_sba_ac_be(psoc, value); 3561 } 3562 3563 /** 3564 * ucfg_mlme_get_wmm_uapsd_be_srv_intv() - Get Uapsd service interval for BE 3565 * @psoc: pointer to psoc object 3566 * @value: pointer to the value which will be filled for the caller 3567 * 3568 * Inline UCFG API to be used by HDD/OSIF callers 3569 * 3570 * Return: QDF Status 3571 */ 3572 static inline QDF_STATUS 3573 ucfg_mlme_get_wmm_uapsd_be_srv_intv(struct wlan_objmgr_psoc *psoc, 3574 uint32_t *value) 3575 { 3576 return wlan_mlme_get_wmm_uapsd_be_srv_intv(psoc, value); 3577 } 3578 3579 /** 3580 * ucfg_mlme_get_wmm_uapsd_be_sus_intv() - Get Uapsd suspension interval for BE 3581 * @psoc: pointer to psoc object 3582 * @value: Value that needs to be set from the caller 3583 * 3584 * Inline UCFG API to be used by HDD/OSIF callers 3585 * 3586 * Return: QDF Status 3587 */ 3588 static inline QDF_STATUS 3589 ucfg_mlme_get_wmm_uapsd_be_sus_intv(struct wlan_objmgr_psoc *psoc, 3590 uint32_t *value) 3591 { 3592 return wlan_mlme_get_wmm_uapsd_be_sus_intv(psoc, value); 3593 } 3594 3595 /** 3596 * ucfg_mlme_get_wmm_dir_ac_bk() - Get TSPEC direction for BK 3597 * @psoc: pointer to psoc object 3598 * @value: Value that needs to be set from the caller 3599 * 3600 * Inline UCFG API to be used by HDD/OSIF callers 3601 * 3602 * Return: QDF Status 3603 */ 3604 static inline QDF_STATUS 3605 ucfg_mlme_get_wmm_dir_ac_bk(struct wlan_objmgr_psoc *psoc, uint8_t *value) 3606 { 3607 return wlan_mlme_get_wmm_dir_ac_bk(psoc, value); 3608 } 3609 3610 /** 3611 * ucfg_mlme_get_wmm_nom_msdu_size_ac_bk() - Get normal MSDU size for BK 3612 * @psoc: pointer to psoc object 3613 * @value: Value that needs to be set from the caller 3614 * 3615 * Inline UCFG API to be used by HDD/OSIF callers 3616 * 3617 * Return: QDF Status 3618 */ 3619 static inline 3620 QDF_STATUS ucfg_mlme_get_wmm_nom_msdu_size_ac_bk(struct wlan_objmgr_psoc *psoc, 3621 uint16_t *value) 3622 { 3623 return wlan_mlme_get_wmm_nom_msdu_size_ac_bk(psoc, value); 3624 } 3625 3626 /** 3627 * ucfg_mlme_get_wmm_mean_data_rate_ac_bk() - mean data rate for BK 3628 * @psoc: pointer to psoc object 3629 * @value: Value that needs to be set from the caller 3630 * 3631 * Inline UCFG API to be used by HDD/OSIF callers 3632 * 3633 * Return: QDF Status 3634 */ 3635 static inline 3636 QDF_STATUS ucfg_mlme_get_wmm_mean_data_rate_ac_bk(struct wlan_objmgr_psoc *psoc, 3637 uint32_t *value) 3638 { 3639 return wlan_mlme_get_wmm_mean_data_rate_ac_bk(psoc, value); 3640 } 3641 3642 /** 3643 * ucfg_mlme_get_wmm_min_phy_rate_ac_bk() - min PHY rate for BE 3644 * @psoc: pointer to psoc object 3645 * @value: Value that needs to be set from the caller 3646 * 3647 * Inline UCFG API to be used by HDD/OSIF callers 3648 * 3649 * Return: QDF Status 3650 */ 3651 static inline 3652 QDF_STATUS ucfg_mlme_get_wmm_min_phy_rate_ac_bk(struct wlan_objmgr_psoc *psoc, 3653 uint32_t *value) 3654 { 3655 return wlan_mlme_get_wmm_min_phy_rate_ac_bk(psoc, value); 3656 } 3657 3658 /** 3659 * ucfg_mlme_get_wmm_sba_ac_bk() - surplus bandwidt allowance for BE 3660 * @psoc: pointer to psoc object 3661 * @value: Value that needs to be set from the caller 3662 * 3663 * Inline UCFG API to be used by HDD/OSIF callers 3664 * 3665 * Return: QDF Status 3666 */ 3667 static inline QDF_STATUS 3668 ucfg_mlme_get_wmm_sba_ac_bk(struct wlan_objmgr_psoc *psoc, uint16_t *value) 3669 { 3670 return wlan_mlme_get_wmm_sba_ac_bk(psoc, value); 3671 } 3672 3673 /** 3674 * ucfg_mlme_get_wmm_uapsd_bk_srv_intv() - Get Uapsd service interval for BK 3675 * @psoc: pointer to psoc object 3676 * @value: pointer to the value which will be filled for the caller 3677 * 3678 * Inline UCFG API to be used by HDD/OSIF callers 3679 * 3680 * Return: QDF Status 3681 */ 3682 static inline QDF_STATUS 3683 ucfg_mlme_get_wmm_uapsd_bk_srv_intv(struct wlan_objmgr_psoc *psoc, 3684 uint32_t *value) 3685 { 3686 return wlan_mlme_get_wmm_uapsd_bk_srv_intv(psoc, value); 3687 } 3688 3689 /** 3690 * ucfg_mlme_get_wmm_uapsd_bk_sus_intv() - Get Uapsd suspension interval for BK 3691 * @psoc: pointer to psoc object 3692 * @value: Value that needs to be set from the caller 3693 * 3694 * Inline UCFG API to be used by HDD/OSIF callers 3695 * 3696 * Return: QDF Status 3697 */ 3698 static inline QDF_STATUS 3699 ucfg_mlme_get_wmm_uapsd_bk_sus_intv(struct wlan_objmgr_psoc *psoc, 3700 uint32_t *value) 3701 { 3702 return wlan_mlme_get_wmm_uapsd_bk_sus_intv(psoc, value); 3703 } 3704 3705 /** 3706 * ucfg_mlme_get_wmm_mode() - Enable WMM feature 3707 * @psoc: pointer to psoc object 3708 * @value: Value that needs to be set from the caller 3709 * 3710 * Inline UCFG API to be used by HDD/OSIF callers 3711 * 3712 * Return: QDF Status 3713 */ 3714 static inline QDF_STATUS 3715 ucfg_mlme_get_wmm_mode(struct wlan_objmgr_psoc *psoc, uint8_t *value) 3716 { 3717 return wlan_mlme_get_wmm_mode(psoc, value); 3718 } 3719 3720 /** 3721 * ucfg_mlme_cfg_get_wlm_level() - Get the WLM level value 3722 * @psoc: pointer to psoc object 3723 * @level: level that needs to be filled. 3724 * 3725 * Return: QDF Status 3726 */ 3727 static inline 3728 QDF_STATUS ucfg_mlme_cfg_get_wlm_level(struct wlan_objmgr_psoc *psoc, 3729 uint8_t *level) 3730 { 3731 return mlme_get_cfg_wlm_level(psoc, level); 3732 } 3733 3734 /** 3735 * ucfg_mlme_cfg_get_wlm_reset() - Get the WLM reset flag 3736 * @psoc: pointer to psoc object 3737 * @reset: reset that needs to be filled. 3738 * 3739 * Return: QDF Status 3740 */ 3741 static inline 3742 QDF_STATUS ucfg_mlme_cfg_get_wlm_reset(struct wlan_objmgr_psoc *psoc, 3743 bool *reset) 3744 { 3745 return mlme_get_cfg_wlm_reset(psoc, reset); 3746 } 3747 3748 #ifdef WLAN_FEATURE_11AX 3749 /** 3750 * ucfg_mlme_update_tgt_he_cap() - Update tgt he cap in mlme component 3751 * 3752 * @psoc: pointer to psoc object 3753 * @cfg: pointer to config params from target 3754 * 3755 * Inline UCFG API to be used by HDD/OSIF callers to update 3756 * he caps in mlme. 3757 * 3758 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 3759 */ 3760 static inline QDF_STATUS 3761 ucfg_mlme_update_tgt_he_cap(struct wlan_objmgr_psoc *psoc, 3762 struct wma_tgt_cfg *cfg) 3763 { 3764 return mlme_update_tgt_he_caps_in_cfg(psoc, cfg); 3765 } 3766 3767 /** 3768 * ucfg_mlme_cfg_get_he_caps() - Get the HE capability info 3769 * @psoc: pointer to psoc object 3770 * @he_cap: Caps that needs to be filled. 3771 * 3772 * Return: QDF Status 3773 */ 3774 static inline 3775 QDF_STATUS ucfg_mlme_cfg_get_he_caps(struct wlan_objmgr_psoc *psoc, 3776 tDot11fIEhe_cap *he_cap) 3777 { 3778 return mlme_cfg_get_he_caps(psoc, he_cap); 3779 } 3780 3781 /** 3782 * ucfg_mlme_cfg_get_he_ul_mumimo() - Get the HE Ul Mumio 3783 * @psoc: pointer to psoc object 3784 * @value: Value that needs to be set from the caller 3785 * 3786 * Return: QDF Status 3787 */ 3788 static inline 3789 QDF_STATUS ucfg_mlme_cfg_get_he_ul_mumimo(struct wlan_objmgr_psoc *psoc, 3790 uint32_t *value) 3791 { 3792 return wlan_mlme_cfg_get_he_ul_mumimo(psoc, value); 3793 } 3794 3795 /** 3796 * ucfg_mlme_cfg_set_he_ul_mumimo() - Set the HE Ul Mumio 3797 * @psoc: pointer to psoc object 3798 * @value: Value that needs to be set from the caller 3799 * 3800 * Return: QDF Status 3801 */ 3802 static inline 3803 QDF_STATUS ucfg_mlme_cfg_set_he_ul_mumimo(struct wlan_objmgr_psoc *psoc, 3804 uint32_t value) 3805 { 3806 return wlan_mlme_cfg_set_he_ul_mumimo(psoc, value); 3807 } 3808 3809 /** 3810 * ucfg_mlme_cfg_get_enable_ul_mimo() - Get the HE Ul mimo 3811 * @psoc: pointer to psoc object 3812 * @value: Value that needs to be set from the caller 3813 * 3814 * Return: QDF Status 3815 */ 3816 static inline 3817 QDF_STATUS ucfg_mlme_cfg_get_enable_ul_mimo(struct wlan_objmgr_psoc *psoc, 3818 uint8_t *value) 3819 { 3820 return wlan_mlme_cfg_get_enable_ul_mimo(psoc, value); 3821 } 3822 3823 /** 3824 * ucfg_mlme_cfg_get_enable_ul_ofdm() - Get enable ul ofdm 3825 * @psoc: pointer to psoc object 3826 * @value: Value that needs to be set from the caller 3827 * 3828 * Return: QDF Status 3829 */ 3830 static inline 3831 QDF_STATUS ucfg_mlme_cfg_get_enable_ul_ofdm(struct wlan_objmgr_psoc *psoc, 3832 uint8_t *value) 3833 { 3834 return wlan_mlme_cfg_get_enable_ul_ofdm(psoc, value); 3835 } 3836 #endif 3837 3838 #ifdef WLAN_FEATURE_11BE 3839 /** 3840 * ucfg_mlme_update_tgt_eht_cap() - Update tgt EHT cap in mlme component 3841 * 3842 * @psoc: pointer to psoc object 3843 * @cfg: pointer to config params from target 3844 * 3845 * Inline UCFG API to be used by HDD/OSIF callers to update 3846 * EHT caps in mlme. 3847 * 3848 * Return: QDF_STATUS_SUCCESS or QDF_STATUS_FAILURE 3849 */ 3850 static inline QDF_STATUS 3851 ucfg_mlme_update_tgt_eht_cap(struct wlan_objmgr_psoc *psoc, 3852 struct wma_tgt_cfg *cfg) 3853 { 3854 return mlme_update_tgt_eht_caps_in_cfg(psoc, cfg); 3855 } 3856 3857 static inline QDF_STATUS 3858 ucfg_mlme_update_tgt_mlo_cap(struct wlan_objmgr_psoc *psoc) 3859 { 3860 return mlme_update_tgt_mlo_caps_in_cfg(psoc); 3861 } 3862 3863 /** 3864 * ucfg_mlme_get_usr_disable_sta_eht() - Get user disable sta eht flag 3865 * @psoc: psoc object 3866 * 3867 * Return: true if user has disabled eht in connect request 3868 */ 3869 static inline 3870 bool ucfg_mlme_get_usr_disable_sta_eht(struct wlan_objmgr_psoc *psoc) 3871 { 3872 return wlan_mlme_get_usr_disable_sta_eht(psoc); 3873 } 3874 3875 /** 3876 * ucfg_mlme_set_usr_disable_sta_eht() - Set user disable sta eht flag 3877 * @psoc: psoc object 3878 * @disable: eht disable flag 3879 * 3880 * Return: void 3881 */ 3882 static inline 3883 void ucfg_mlme_set_usr_disable_sta_eht(struct wlan_objmgr_psoc *psoc, 3884 bool disable) 3885 { 3886 wlan_mlme_set_usr_disable_sta_eht(psoc, disable); 3887 } 3888 #else 3889 static inline QDF_STATUS 3890 ucfg_mlme_update_tgt_mlo_cap(struct wlan_objmgr_psoc *psoc) 3891 { 3892 return QDF_STATUS_SUCCESS; 3893 } 3894 3895 static inline 3896 bool ucfg_mlme_get_usr_disable_sta_eht(struct wlan_objmgr_psoc *psoc) 3897 { 3898 return true; 3899 } 3900 3901 static inline 3902 void ucfg_mlme_set_usr_disable_sta_eht(struct wlan_objmgr_psoc *psoc, 3903 bool disable) 3904 { 3905 } 3906 #endif 3907 3908 #ifdef WLAN_FEATURE_11BE_MLO 3909 /** 3910 * ucfg_mlme_get_eht_mld_id() - Get the MLD ID of the requested BSS 3911 * @psoc: pointer to psoc object 3912 * 3913 * This API gives the MLD ID of the requested BSS 3914 * 3915 * Return: MLD ID of the requested BSS 3916 */ 3917 static inline uint8_t 3918 ucfg_mlme_get_eht_mld_id(struct wlan_objmgr_psoc *psoc) 3919 { 3920 return wlan_mlme_get_eht_mld_id(psoc); 3921 } 3922 3923 /** 3924 * ucfg_mlme_set_eht_mld_id() - Set MLD ID of the requested BSS information 3925 * @psoc: pointer to psoc object 3926 * @value: set MLD ID 3927 * 3928 * This API sets the MLD ID of the requested BSS information within the ML 3929 * probe request. 3930 * 3931 * Return: QDF_STATUS 3932 */ 3933 static inline QDF_STATUS 3934 ucfg_mlme_set_eht_mld_id(struct wlan_objmgr_psoc *psoc, 3935 uint8_t value) 3936 { 3937 return wlan_mlme_set_eht_mld_id(psoc, value); 3938 } 3939 #else 3940 static inline uint8_t 3941 ucfg_mlme_get_eht_mld_id(struct wlan_objmgr_psoc *psoc) 3942 { 3943 return 0; 3944 } 3945 3946 static inline QDF_STATUS 3947 ucfg_mlme_set_eht_mld_id(struct wlan_objmgr_psoc *psoc, uint8_t value) 3948 { 3949 return QDF_STATUS_E_NOSUPPORT; 3950 } 3951 #endif /* WLAN_FEATURE_11BE_MLO */ 3952 3953 /** 3954 * ucfg_mlme_get_80211e_is_enabled() - Enable 802.11e feature 3955 * @psoc: pointer to psoc object 3956 * @value: Value that needs to be set from the caller 3957 * 3958 * Inline UCFG API to be used by HDD/OSIF callers 3959 * 3960 * Return: QDF Status 3961 */ 3962 static inline QDF_STATUS 3963 ucfg_mlme_get_80211e_is_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 3964 { 3965 return wlan_mlme_get_80211e_is_enabled(psoc, value); 3966 } 3967 3968 /** 3969 * ucfg_mlme_get_wmm_uapsd_mask() - setup U-APSD mask for ACs 3970 * @psoc: pointer to psoc object 3971 * @value: Value that needs to be set from the caller 3972 * 3973 * Inline UCFG API to be used by HDD/OSIF callers 3974 * 3975 * Return: QDF Status 3976 */ 3977 static inline QDF_STATUS 3978 ucfg_mlme_get_wmm_uapsd_mask(struct wlan_objmgr_psoc *psoc, uint8_t *value) 3979 { 3980 return wlan_mlme_get_wmm_uapsd_mask(psoc, value); 3981 } 3982 3983 #ifdef FEATURE_WLAN_ESE 3984 /** 3985 * ucfg_mlme_get_inactivity_interval() - Infra Inactivity Interval 3986 * @psoc: pointer to psoc object 3987 * @value: Value that needs to be get from the caller 3988 * 3989 * Inline UCFG API to be used by HDD/OSIF callers 3990 * 3991 * Return: None 3992 */ 3993 static inline void 3994 ucfg_mlme_get_inactivity_interval(struct wlan_objmgr_psoc *psoc, 3995 uint32_t *value) 3996 { 3997 wlan_mlme_get_inactivity_interval(psoc, value); 3998 } 3999 4000 /** 4001 * ucfg_mlme_is_ese_enabled() - ese feature enable or not 4002 * @psoc: pointer to psoc object 4003 * @val: Pointer to the value which will be filled for the caller 4004 * 4005 * Return: QDF Status 4006 */ 4007 QDF_STATUS 4008 ucfg_mlme_is_ese_enabled(struct wlan_objmgr_psoc *psoc, bool *val); 4009 #endif /* FEATURE_WLAN_ESE */ 4010 4011 /** 4012 * ucfg_mlme_get_is_ts_burst_size_enable() - Get TS burst size flag 4013 * @psoc: pointer to psoc object 4014 * @value: Value that needs to be get from the caller 4015 * 4016 * Inline UCFG API to be used by HDD/OSIF callers 4017 * 4018 * Return: None 4019 */ 4020 static inline 4021 void ucfg_mlme_get_is_ts_burst_size_enable(struct wlan_objmgr_psoc *psoc, 4022 bool *value) 4023 { 4024 wlan_mlme_get_is_ts_burst_size_enable(psoc, value); 4025 } 4026 4027 /** 4028 * ucfg_mlme_get_ts_info_ack_policy() - Get TS ack policy 4029 * @psoc: pointer to psoc object 4030 * @value: Value that needs to be get from the caller 4031 * 4032 * Inline UCFG API to be used by HDD/OSIF callers 4033 * 4034 * Return: None 4035 */ 4036 static inline void 4037 ucfg_mlme_get_ts_info_ack_policy(struct wlan_objmgr_psoc *psoc, 4038 enum mlme_ts_info_ack_policy *value) 4039 { 4040 wlan_mlme_get_ts_info_ack_policy(psoc, value); 4041 } 4042 4043 /** 4044 * ucfg_mlme_get_ts_acm_value_for_ac() - Get ACM value for AC 4045 * @psoc: pointer to psoc object 4046 * @value: Value that needs to be get from the caller 4047 * 4048 * 4049 * Inline UCFG API to be used by HDD/OSIF callers 4050 * 4051 * Return: QDF Status 4052 */ 4053 static inline QDF_STATUS 4054 ucfg_mlme_get_ts_acm_value_for_ac(struct wlan_objmgr_psoc *psoc, bool *value) 4055 { 4056 return wlan_mlme_get_ts_acm_value_for_ac(psoc, value); 4057 } 4058 4059 /* 4060 * ucfg_mlme_is_sap_uapsd_enabled() - SAP UAPSD enabled status. 4061 * @psoc: pointer to psoc object 4062 * @value: sap uapsd enabled flag value requested from the caller 4063 * 4064 * Inline UCFG API to be used by HDD/OSIF callers 4065 * 4066 * Return: QDF Status 4067 */ 4068 static inline QDF_STATUS 4069 ucfg_mlme_is_sap_uapsd_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 4070 { 4071 return wlan_mlme_is_sap_uapsd_enabled(psoc, value); 4072 } 4073 4074 /* 4075 * ucfg_mlme_set_sap_uapsd_flag() - SAP UAPSD enabled status. 4076 * @psoc: pointer to psoc object 4077 * @value: Value that needs to be set from the caller 4078 * 4079 * Inline UCFG API to be used by HDD/OSIF callers 4080 * 4081 * Return: QDF Status 4082 */ 4083 static inline QDF_STATUS 4084 ucfg_mlme_set_sap_uapsd_flag(struct wlan_objmgr_psoc *psoc, bool value) 4085 { 4086 return wlan_mlme_set_sap_uapsd_flag(psoc, value); 4087 } 4088 4089 /** 4090 * ucfg_mlme_get_enable_deauth_to_disassoc_map() - Enable deauth_to_disassoc_map 4091 * @psoc: pointer to psoc object 4092 * @value: Value that needs to be set from the caller 4093 * 4094 * UCFG API to be used by HDD/OSIF callers 4095 * 4096 * Return: QDF Status 4097 */ 4098 QDF_STATUS 4099 ucfg_mlme_get_enable_deauth_to_disassoc_map(struct wlan_objmgr_psoc *psoc, 4100 bool *value); 4101 4102 /** 4103 * ucfg_mlme_get_ap_random_bssid_enable() - Enable random bssid 4104 * @psoc: pointer to psoc object 4105 * @value: Value that needs to be set from the caller 4106 * 4107 * UCFG API to be used by HDD/OSIF callers 4108 * 4109 * Return: QDF Status 4110 */ 4111 QDF_STATUS 4112 ucfg_mlme_get_ap_random_bssid_enable(struct wlan_objmgr_psoc *psoc, 4113 bool *value); 4114 4115 /** 4116 * ucfg_mlme_get_sta_miracast_mcc_rest_time() - Get STA/MIRACAST MCC rest time 4117 * 4118 * @psoc: pointer to psoc object 4119 * @value: value which needs to filled by API 4120 * 4121 * This API gives rest time to be used when STA and MIRACAST MCC conc happens 4122 * 4123 * Return: QDF_STATUS 4124 */ 4125 static inline QDF_STATUS 4126 ucfg_mlme_get_sta_miracast_mcc_rest_time(struct wlan_objmgr_psoc *psoc, 4127 uint32_t *value) 4128 { 4129 return wlan_mlme_get_sta_miracast_mcc_rest_time(psoc, value); 4130 } 4131 4132 /** 4133 * ucfg_mlme_get_max_modulated_dtim_ms() - get sap max modulated dtim 4134 * @psoc: pointer to psoc object 4135 * @value: Value that needs to be set from the caller 4136 * 4137 * Inline UCFG API to be used by HDD/OSIF callers 4138 * 4139 * Return: QDF Status 4140 */ 4141 static inline QDF_STATUS 4142 ucfg_mlme_get_max_modulated_dtim_ms(struct wlan_objmgr_psoc *psoc, 4143 uint16_t *value) 4144 { 4145 return wlan_mlme_get_max_modulated_dtim_ms(psoc, value); 4146 } 4147 4148 /** 4149 * ucfg_mlme_get_sap_mcc_chnl_avoid() - Check if SAP MCC needs to be avoided 4150 * 4151 * @psoc: pointer to psoc object 4152 * @value: value which needs to filled by API 4153 * 4154 * This API fetches the user setting to determine if SAP MCC with other persona 4155 * to be avoided. 4156 * 4157 * Return: QDF_STATUS 4158 */ 4159 static inline QDF_STATUS 4160 ucfg_mlme_get_sap_mcc_chnl_avoid(struct wlan_objmgr_psoc *psoc, 4161 uint8_t *value) 4162 { 4163 return wlan_mlme_get_sap_mcc_chnl_avoid(psoc, value); 4164 } 4165 4166 /** 4167 * ucfg_mlme_get_mcc_bcast_prob_resp() - Get broadcast probe rsp in MCC 4168 * 4169 * @psoc: pointer to psoc object 4170 * @value: value which needs to filled by API 4171 * 4172 * To get INI value which helps to determe whether to enable/disable use of 4173 * broadcast probe response to increase the detectability of SAP in MCC mode. 4174 * 4175 * 4176 * Return: QDF_STATUS 4177 */ 4178 static inline QDF_STATUS 4179 ucfg_mlme_get_mcc_bcast_prob_resp(struct wlan_objmgr_psoc *psoc, 4180 uint8_t *value) 4181 { 4182 return wlan_mlme_get_mcc_bcast_prob_resp(psoc, value); 4183 } 4184 4185 /** 4186 * ucfg_mlme_get_mcc_rts_cts_prot() - To get RTS-CTS protection in MCC. 4187 * 4188 * @psoc: pointer to psoc object 4189 * @value: value which needs to filled by API 4190 * 4191 * To get INI value which helps to determine whether to enable/disable 4192 * use of long duration RTS-CTS protection when SAP goes off 4193 * channel in MCC mode. 4194 * 4195 * Return: QDF_STATUS 4196 */ 4197 static inline QDF_STATUS 4198 ucfg_mlme_get_mcc_rts_cts_prot(struct wlan_objmgr_psoc *psoc, 4199 uint8_t *value) 4200 { 4201 return wlan_mlme_get_mcc_rts_cts_prot(psoc, value); 4202 } 4203 4204 /** 4205 * ucfg_mlme_get_mcc_feature() - To find out to enable/disable MCC feature 4206 * 4207 * @psoc: pointer to psoc object 4208 * @value: value which needs to filled by API 4209 * 4210 * To get INI value which helps to determine whether to enable MCC feature 4211 * 4212 * Return: QDF_STATUS 4213 */ 4214 static inline QDF_STATUS 4215 ucfg_mlme_get_mcc_feature(struct wlan_objmgr_psoc *psoc, 4216 uint8_t *value) 4217 { 4218 return wlan_mlme_get_mcc_feature(psoc, value); 4219 } 4220 4221 /** 4222 * ucfg_wlan_mlme_get_rrm_enabled() - Get the rrm enabled 4223 * @psoc: pointer to psoc object 4224 * @value: Value that needs to be get from the caller 4225 * 4226 * Return: QDF Status 4227 */ 4228 static inline 4229 QDF_STATUS ucfg_wlan_mlme_get_rrm_enabled(struct wlan_objmgr_psoc *psoc, 4230 bool *value) 4231 { 4232 return wlan_mlme_get_rrm_enabled(psoc, value); 4233 } 4234 4235 /** 4236 * ucfg_mlme_get_latency_enable() - Get the latency_enable 4237 * @psoc: pointer to psoc object 4238 * @value: Value that needs to be get from the caller 4239 * 4240 * Return: QDF Status 4241 */ 4242 QDF_STATUS 4243 ucfg_mlme_get_latency_enable(struct wlan_objmgr_psoc *psoc, bool *value); 4244 4245 /** 4246 * ucfg_mlme_get_latency_level() - Get the latency level 4247 * @psoc: pointer to psoc object 4248 * @value: Value that needs to be get from the caller 4249 * latency values are defined in WMI_WLM_LATENCY_LEVEL 4250 * 4251 * Return: QDF Status 4252 */ 4253 QDF_STATUS 4254 ucfg_mlme_get_latency_level(struct wlan_objmgr_psoc *psoc, uint8_t *value); 4255 4256 /** 4257 * ucfg_mlme_get_latency_host_flags() - Get host flags for latency level 4258 * @psoc: pointer to psoc object 4259 * @latency_level: latency level 4260 * @value: Value that needs to be get from the caller 4261 * 4262 * Return: QDF Status 4263 */ 4264 QDF_STATUS 4265 ucfg_mlme_get_latency_host_flags(struct wlan_objmgr_psoc *psoc, 4266 uint8_t latency_level, uint32_t *value); 4267 4268 /** 4269 * ucfg_mlme_get_dtim_selection_diversity() - get dtim selection diversity 4270 * bitmap 4271 * @psoc: pointer to psoc object 4272 * @dtim_selection_div: value that is requested by the caller 4273 * 4274 * Inline UCFG API to be used by HDD/OSIF callers 4275 * 4276 * Return: QDF_STATUS_SUCCESS - in case of success 4277 */ 4278 static inline QDF_STATUS 4279 ucfg_mlme_get_dtim_selection_diversity(struct wlan_objmgr_psoc *psoc, 4280 uint32_t *dtim_selection_div) 4281 { 4282 return wlan_mlme_get_dtim_selection_diversity(psoc, dtim_selection_div); 4283 } 4284 4285 /** 4286 * ucfg_mlme_get_bmps_min_listen_interval() - get beacon mode powersave 4287 * minimum listen interval value 4288 * @psoc: pointer to psoc object 4289 * @value: value that is requested by the caller 4290 * 4291 * Inline UCFG API to be used by HDD/OSIF callers 4292 * 4293 * Return: QDF_STATUS_SUCCESS - in case of success 4294 */ 4295 static inline QDF_STATUS 4296 ucfg_mlme_get_bmps_min_listen_interval(struct wlan_objmgr_psoc *psoc, 4297 uint32_t *value) 4298 { 4299 return wlan_mlme_get_bmps_min_listen_interval(psoc, value); 4300 } 4301 4302 /** 4303 * ucfg_mlme_get_bmps_max_listen_interval() - get beacon mode powersave 4304 * maximum listen interval value 4305 * @psoc: pointer to psoc object 4306 * @value: value that is requested by the caller 4307 * 4308 * Inline UCFG API to be used by HDD/OSIF callers 4309 * 4310 * Return: QDF_STATUS_SUCCESS - in case of success 4311 */ 4312 static inline QDF_STATUS 4313 ucfg_mlme_get_bmps_max_listen_interval(struct wlan_objmgr_psoc *psoc, 4314 uint32_t *value) 4315 { 4316 return wlan_mlme_get_bmps_max_listen_interval(psoc, value); 4317 } 4318 4319 /** 4320 * ucfg_mlme_get_auto_bmps_timer_value() - get bmps timer value 4321 * minimum listen interval value 4322 * @psoc: pointer to psoc object 4323 * @value: value that is requested by the caller 4324 * 4325 * Inline UCFG API to be used by HDD/OSIF callers 4326 * 4327 * Return: QDF_STATUS_SUCCESS - in case of success 4328 */ 4329 static inline QDF_STATUS 4330 ucfg_mlme_get_auto_bmps_timer_value(struct wlan_objmgr_psoc *psoc, 4331 uint32_t *value) 4332 { 4333 return wlan_mlme_get_auto_bmps_timer_value(psoc, value); 4334 } 4335 4336 /** 4337 * ucfg_mlme_is_bmps_enabled() - check if beacon mode powersave is 4338 * enabled/disabled 4339 * @psoc: pointer to psoc object 4340 * @value: value that is requested by the caller 4341 * 4342 * Inline UCFG API to be used by HDD/OSIF callers 4343 * 4344 * Return: QDF_STATUS_SUCCESS - in case of success 4345 */ 4346 static inline QDF_STATUS 4347 ucfg_mlme_is_bmps_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 4348 { 4349 return wlan_mlme_is_bmps_enabled(psoc, value); 4350 } 4351 4352 /** 4353 * ucfg_mlme_is_imps_enabled() - check if idle mode powersave is 4354 * enabled/disabled 4355 * @psoc: pointer to psoc object 4356 * @value: value that is requested by the caller 4357 * 4358 * Inline UCFG API to be used by HDD/OSIF callers 4359 * 4360 * Return: QDF_STATUS_SUCCESS - in case of success 4361 */ 4362 static inline QDF_STATUS 4363 ucfg_mlme_is_imps_enabled(struct wlan_objmgr_psoc *psoc, bool *value) 4364 { 4365 return wlan_mlme_is_imps_enabled(psoc, value); 4366 } 4367 4368 /** 4369 * ucfg_mlme_override_bmps_imps() - disable imps/bmps as part of 4370 * override to disable all ps features 4371 * @psoc: pointer to psoc object 4372 * Inline UCFG API to be used by HDD/OSIF callers 4373 * 4374 * Return: QDF_STATUS_SUCCESS - in case of success 4375 */ 4376 static inline QDF_STATUS 4377 ucfg_mlme_override_bmps_imps(struct wlan_objmgr_psoc *psoc) 4378 { 4379 return wlan_mlme_override_bmps_imps(psoc); 4380 } 4381 4382 #ifdef MWS_COEX 4383 /** 4384 * ucfg_mlme_get_mws_coex_4g_quick_tdm() - Get mws coex 4g quick tdm 4385 * @psoc: pointer to psoc object 4386 * @val: Pointer to the value which will be filled for the caller 4387 * 4388 * Return: QDF Status 4389 */ 4390 QDF_STATUS 4391 ucfg_mlme_get_mws_coex_4g_quick_tdm(struct wlan_objmgr_psoc *psoc, 4392 uint32_t *val); 4393 4394 /** 4395 * ucfg_mlme_get_mws_coex_5g_nr_pwr_limit() - Get mws coex 5g nr pwr limit 4396 * @psoc: pointer to psoc object 4397 * @val: Pointer to the value which will be filled for the caller 4398 * 4399 * Return: QDF Status 4400 */ 4401 QDF_STATUS 4402 ucfg_mlme_get_mws_coex_5g_nr_pwr_limit(struct wlan_objmgr_psoc *psoc, 4403 uint32_t *val); 4404 4405 /** 4406 * ucfg_mlme_get_mws_coex_pcc_channel_avoid_delay() - Get mws coex pcc 4407 * avoid channel delay 4408 * @psoc: pointer to psoc object 4409 * @val: Pointer to the value which will be filled for the caller 4410 * 4411 * Return: QDF Status 4412 */ 4413 QDF_STATUS 4414 ucfg_mlme_get_mws_coex_pcc_channel_avoid_delay(struct wlan_objmgr_psoc *psoc, 4415 uint32_t *val); 4416 4417 /** 4418 * ucfg_mlme_get_mws_coex_scc_channel_avoid_delay() - Get mws coex scc 4419 * avoidance channel delay 4420 * @psoc: pointer to psoc object 4421 * @val: Pointer to the value which will be filled for the caller 4422 * 4423 * Return: QDF Status 4424 */ 4425 QDF_STATUS 4426 ucfg_mlme_get_mws_coex_scc_channel_avoid_delay(struct wlan_objmgr_psoc *psoc, 4427 uint32_t *val); 4428 #endif 4429 4430 /** 4431 * ucfg_mlme_get_etsi_srd_chan_in_master_mode - get etsi srd chan 4432 * in master mode 4433 * @psoc: pointer to psoc object 4434 * @value: pointer to the value which will be filled for the caller 4435 * 4436 * Return: QDF Status 4437 */ 4438 QDF_STATUS 4439 ucfg_mlme_get_etsi_srd_chan_in_master_mode(struct wlan_objmgr_psoc *psoc, 4440 uint8_t *value); 4441 4442 /** 4443 * ucfg_mlme_get_5dot9_ghz_chan_in_master_mode - get fcc 5.9 GHz chan 4444 * in master mode 4445 * @psoc: pointer to psoc object 4446 * @value: pointer to the value which will be filled for the caller 4447 * 4448 * Return: QDF Status 4449 */ 4450 QDF_STATUS 4451 ucfg_mlme_get_5dot9_ghz_chan_in_master_mode(struct wlan_objmgr_psoc *psoc, 4452 bool *value); 4453 4454 /** 4455 * ucfg_mlme_get_srd_master_mode_for_vdev() - Get SRD master mode for vdev 4456 * @psoc: pointer to psoc object 4457 * @vdev_opmode: vdev opmode 4458 * @value: pointer to the value which will be filled for the caller 4459 * 4460 * Return: QDF Status 4461 */ 4462 QDF_STATUS 4463 ucfg_mlme_get_srd_master_mode_for_vdev(struct wlan_objmgr_psoc *psoc, 4464 enum QDF_OPMODE vdev_opmode, 4465 bool *value); 4466 4467 #ifdef SAP_AVOID_ACS_FREQ_LIST 4468 /** 4469 * ucfg_mlme_get_acs_avoid_freq_list - get acs avoid frequency list 4470 * @psoc: pointer to psoc object 4471 * @freq_list: Pointer to output freq list 4472 * @freq_list_num: Pointer to the output number of frequencies filled 4473 * in the freq_list 4474 * 4475 * Return: QDF Status 4476 */ 4477 QDF_STATUS 4478 ucfg_mlme_get_acs_avoid_freq_list(struct wlan_objmgr_psoc *psoc, 4479 uint16_t *freq_list, uint8_t *freq_list_num); 4480 4481 #else 4482 static inline QDF_STATUS 4483 ucfg_mlme_get_acs_avoid_freq_list(struct wlan_objmgr_psoc *psoc, 4484 uint16_t *freq_list, uint8_t *freq_list_num) 4485 { 4486 *freq_list_num = 0; 4487 return QDF_STATUS_E_INVAL; 4488 } 4489 #endif 4490 4491 /** 4492 * ucfg_mlme_get_11d_in_world_mode - get whether 11d is enabled in world mode 4493 * in master mode 4494 * @psoc: pointer to psoc object 4495 * @value: pointer to the value which will be filled for the caller 4496 * 4497 * Return: QDF Status 4498 */ 4499 QDF_STATUS 4500 ucfg_mlme_get_11d_in_world_mode(struct wlan_objmgr_psoc *psoc, 4501 bool *value); 4502 4503 /** 4504 * ucfg_mlme_get_restart_beaconing_on_ch_avoid() - get restart beaconing on 4505 * channel avoid 4506 * @psoc: pointer to psoc object 4507 * @value: pointer to the value which will be filled for the caller 4508 * 4509 * Return: QDF Status 4510 */ 4511 QDF_STATUS 4512 ucfg_mlme_get_restart_beaconing_on_ch_avoid(struct wlan_objmgr_psoc *psoc, 4513 uint32_t *value); 4514 4515 /** 4516 * ucfg_mlme_get_indoor_channel_support() - get indoor channel support 4517 * @psoc: pointer to psoc object 4518 * @value: pointer to the value which will be filled for the caller 4519 * 4520 * Return: QDF Status 4521 */ 4522 QDF_STATUS 4523 ucfg_mlme_get_indoor_channel_support(struct wlan_objmgr_psoc *psoc, 4524 bool *value); 4525 4526 /** 4527 * ucfg_mlme_get_scan_11d_interval() - get scan 11d interval 4528 * @psoc: pointer to psoc object 4529 * @value: Pointer to the value which will be filled for the caller 4530 * 4531 * Return: QDF Status 4532 */ 4533 QDF_STATUS 4534 ucfg_mlme_get_scan_11d_interval(struct wlan_objmgr_psoc *psoc, 4535 uint32_t *value); 4536 4537 /** 4538 * ucfg_mlme_get_nol_across_regdmn() - get scan 11d interval 4539 * @psoc: pointer to psoc object 4540 * @value: Pointer to the value which will be filled for the caller 4541 * 4542 * Return: QDF Status 4543 */ 4544 4545 QDF_STATUS 4546 ucfg_mlme_get_nol_across_regdmn(struct wlan_objmgr_psoc *psoc, bool *value); 4547 4548 /** 4549 * ucfg_mlme_get_valid_channel_freq_list() - get valid channel 4550 * list 4551 * @psoc: pointer to psoc object 4552 * @channel_list: pointer to return channel list 4553 * @channel_list_num: pointer to return channel list number 4554 * 4555 * Return: QDF Status 4556 */ 4557 QDF_STATUS 4558 ucfg_mlme_get_valid_channel_freq_list(struct wlan_objmgr_psoc *psoc, 4559 uint32_t *channel_list, 4560 uint32_t *channel_list_num); 4561 4562 #ifdef FEATURE_LFR_SUBNET_DETECTION 4563 /** 4564 * ucfg_mlme_is_subnet_detection_enabled() - check if sub net detection is 4565 * enabled/disabled 4566 * @psoc: pointer to psoc object 4567 * @val: value that is requested by the caller 4568 * 4569 * Inline UCFG API to be used by HDD/OSIF callers 4570 * 4571 * Return: QDF_STATUS_SUCCESS - in case of success 4572 */ 4573 QDF_STATUS 4574 ucfg_mlme_is_subnet_detection_enabled(struct wlan_objmgr_psoc *psoc, bool *val); 4575 #else 4576 static QDF_STATUS 4577 ucfg_mlme_is_subnet_detection_enabled(struct wlan_objmgr_psoc *psoc, bool *val) 4578 { 4579 *val = false; 4580 4581 return QDF_STATUS_SUCCESS; 4582 } 4583 #endif /* FEATURE_LFR_SUBNET_DETECTION */ 4584 4585 /** 4586 * ucfg_mlme_set_current_tx_power_level() - set current tx power level 4587 * @psoc: pointer to psoc object 4588 * @value: data to be set 4589 * 4590 * Return: QDF Status 4591 */ 4592 QDF_STATUS 4593 ucfg_mlme_set_current_tx_power_level(struct wlan_objmgr_psoc *psoc, 4594 uint8_t value); 4595 4596 /** 4597 * ucfg_mlme_get_current_tx_power_level() - get current tx power level 4598 * @psoc: pointer to psoc object 4599 * @value: pointer to the value which will be filled for the caller 4600 * 4601 * Return: QDF Status 4602 */ 4603 QDF_STATUS 4604 ucfg_mlme_get_current_tx_power_level(struct wlan_objmgr_psoc *psoc, 4605 uint8_t *value); 4606 4607 /** 4608 * ucfg_wlan_mlme_get_reg_tpc_info() - get current regulatory tpc info 4609 * @vdev: pointer to vdev object 4610 * @tpc_info: pointer to tpc info buffer 4611 * 4612 * Return: QDF Status 4613 */ 4614 QDF_STATUS 4615 ucfg_wlan_mlme_get_reg_tpc_info(struct wlan_objmgr_vdev *vdev, 4616 struct reg_tpc_power_info *tpc_info); 4617 4618 /** 4619 * ucfg_mlme_set_obss_detection_offload_enabled() - Enable obss offload 4620 * @psoc: pointer to psoc object 4621 * @value: enable or disable 4622 * 4623 * Return: QDF Status 4624 */ 4625 QDF_STATUS 4626 ucfg_mlme_set_obss_detection_offload_enabled(struct wlan_objmgr_psoc *psoc, 4627 uint8_t value); 4628 4629 /** 4630 * ucfg_mlme_set_obss_color_collision_offload_enabled() - Enable obss color 4631 * collision offload 4632 * @psoc: pointer to psoc object 4633 * @value: enable or disable 4634 * 4635 * Return: QDF Status 4636 */ 4637 QDF_STATUS 4638 ucfg_mlme_set_obss_color_collision_offload_enabled( 4639 struct wlan_objmgr_psoc *psoc, uint8_t value); 4640 4641 /** 4642 * ucfg_mlme_set_bss_color_collision_det_sta() - Enable bss color 4643 * collision detection offload for STA mode 4644 * @psoc: pointer to psoc object 4645 * @value: enable or disable 4646 * 4647 * Return: QDF Status 4648 */ 4649 QDF_STATUS 4650 ucfg_mlme_set_bss_color_collision_det_sta(struct wlan_objmgr_psoc *psoc, 4651 bool value); 4652 4653 /** 4654 * ucfg_mlme_set_bss_color_collision_det_support() - Set bss color collision 4655 * detection offload support from FW for STA mode 4656 * @psoc: pointer to psoc object 4657 * @value: enable or disable 4658 * 4659 * Return: QDF Status 4660 */ 4661 QDF_STATUS 4662 ucfg_mlme_set_bss_color_collision_det_support(struct wlan_objmgr_psoc *psoc, 4663 bool value); 4664 4665 /** 4666 * ucfg_mlme_get_bss_color_collision_det_support() - Get bss color collision 4667 * detection offload FW support for STA mode 4668 * @psoc: pointer to psoc object 4669 * @value: pointer to the value which will be filled for the caller 4670 * 4671 * Return: QDF Status 4672 */ 4673 QDF_STATUS 4674 ucfg_mlme_get_bss_color_collision_det_support(struct wlan_objmgr_psoc *psoc, 4675 bool *value); 4676 4677 /** 4678 * ucfg_mlme_set_restricted_80p80_bw_supp() - Set the restricted 80p80 support 4679 * @psoc: pointer to psoc object 4680 * @restricted_80p80_supp: Value to be set from the caller 4681 * 4682 * Return: QDF Status 4683 */ 4684 QDF_STATUS ucfg_mlme_set_restricted_80p80_bw_supp(struct wlan_objmgr_psoc *psoc, 4685 bool restricted_80p80_supp); 4686 4687 /** 4688 * ucfg_mlme_get_restricted_80p80_bw_supp() - Get the restricted 80p80 support 4689 * @psoc: pointer to psoc object 4690 * 4691 * Return: true or false 4692 */ 4693 bool ucfg_mlme_get_restricted_80p80_bw_supp(struct wlan_objmgr_psoc *psoc); 4694 4695 /** 4696 * ucfg_mlme_get_update_chan_width_allowed - Get value of INI 4697 * is_update_chan_width_allowed 4698 * @psoc: pointer to psoc object 4699 * @value: pointer to the value which will be filled for the caller 4700 * 4701 * Return: QDF Status 4702 */ 4703 QDF_STATUS 4704 ucfg_mlme_get_update_chan_width_allowed(struct wlan_objmgr_psoc *psoc, 4705 bool *value); 4706 4707 /** 4708 * ucfg_mlme_get_channel_bonding_24ghz() - get channel bonding mode of 24ghz 4709 * @psoc: pointer to psoc object 4710 * @value: pointer to the value which will be filled for the caller 4711 * 4712 * Return: QDF Status 4713 */ 4714 QDF_STATUS 4715 ucfg_mlme_get_channel_bonding_24ghz(struct wlan_objmgr_psoc *psoc, 4716 uint32_t *value); 4717 4718 /** 4719 * ucfg_mlme_set_channel_bonding_24ghz() - set channel bonding mode for 24ghz 4720 * @psoc: pointer to psoc object 4721 * @value: channel bonding mode 4722 * 4723 * Return: QDF Status 4724 */ 4725 QDF_STATUS 4726 ucfg_mlme_set_channel_bonding_24ghz(struct wlan_objmgr_psoc *psoc, 4727 uint32_t value); 4728 4729 /** 4730 * ucfg_mlme_get_channel_bonding_5ghz() - get channel bonding mode of 5ghz 4731 * @psoc: pointer to psoc object 4732 * @value: pointer to the value which will be filled for the caller 4733 * 4734 * Return: QDF Status 4735 */ 4736 QDF_STATUS 4737 ucfg_mlme_get_channel_bonding_5ghz(struct wlan_objmgr_psoc *psoc, 4738 uint32_t *value); 4739 4740 /** 4741 * ucfg_mlme_set_channel_bonding_5ghz() - set channel bonding mode for 5ghz 4742 * @psoc: pointer to psoc object 4743 * @value: channel bonding mode 4744 * 4745 * Return: QDF Status 4746 */ 4747 QDF_STATUS 4748 ucfg_mlme_set_channel_bonding_5ghz(struct wlan_objmgr_psoc *psoc, 4749 uint32_t value); 4750 4751 /** 4752 * ucfg_mlme_get_scan_probe_unicast_ra() - Get scan probe unicast RA cfg 4753 * 4754 * @psoc: pointer to psoc object 4755 * @value: value which needs to filled by API 4756 * 4757 * This API gives scan probe request with unicast RA user config 4758 * 4759 * Return: QDF_STATUS 4760 */ 4761 static inline QDF_STATUS 4762 ucfg_mlme_get_scan_probe_unicast_ra(struct wlan_objmgr_psoc *psoc, 4763 bool *value) 4764 { 4765 return wlan_mlme_get_scan_probe_unicast_ra(psoc, value); 4766 } 4767 4768 /** 4769 * ucfg_mlme_set_scan_probe_unicast_ra() - Set scan probe unicast RA cfg 4770 * 4771 * @psoc: pointer to psoc object 4772 * @value: set value 4773 * 4774 * This API sets scan probe request with unicast RA user config 4775 * 4776 * Return: QDF_STATUS 4777 */ 4778 static inline QDF_STATUS 4779 ucfg_mlme_set_scan_probe_unicast_ra(struct wlan_objmgr_psoc *psoc, 4780 bool value) 4781 { 4782 return wlan_mlme_set_scan_probe_unicast_ra(psoc, value); 4783 } 4784 4785 /** 4786 * ucfg_mlme_get_peer_phymode() - get phymode of peer 4787 * @psoc: pointer to psoc object 4788 * @mac: Pointer to the mac addr of the peer 4789 * @peer_phymode: phymode 4790 * 4791 * Return: QDF Status 4792 */ 4793 static inline QDF_STATUS 4794 ucfg_mlme_get_peer_phymode(struct wlan_objmgr_psoc *psoc, uint8_t *mac, 4795 enum wlan_phymode *peer_phymode) 4796 { 4797 return mlme_get_peer_phymode(psoc, mac, peer_phymode); 4798 } 4799 4800 /** 4801 * ucfg_mlme_validate_full_roam_scan_period() - Validate full roam scan period 4802 * @full_roam_scan_period: Idle period in seconds between two successive 4803 * full channel roam scans 4804 * 4805 * Return: True if full_roam_scan_period is in expected range, false otherwise. 4806 */ 4807 bool ucfg_mlme_validate_full_roam_scan_period(uint32_t full_roam_scan_period); 4808 4809 /** 4810 * ucfg_mlme_validate_scan_period() - Validate if scan period is in valid range 4811 * @psoc: Pointer to soc 4812 * @roam_scan_period: Scan period in msec 4813 * 4814 * Return: True if roam_scan_period is in expected range, false otherwise. 4815 */ 4816 bool ucfg_mlme_validate_scan_period(struct wlan_objmgr_psoc *psoc, 4817 uint32_t roam_scan_period); 4818 /** 4819 * ucfg_mlme_get_ignore_fw_reg_offload_ind() - Get the 4820 * ignore_fw_reg_offload_ind ini 4821 * @psoc: pointer to psoc object 4822 * @disabled: output pointer to hold user config 4823 * 4824 * Return: QDF Status 4825 */ 4826 static inline QDF_STATUS 4827 ucfg_mlme_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc, 4828 bool *disabled) 4829 { 4830 return wlan_mlme_get_ignore_fw_reg_offload_ind(psoc, disabled); 4831 } 4832 4833 /** 4834 * ucfg_mlme_get_peer_unmap_conf() - Indicate if peer unmap confirmation 4835 * support is enabled or disabled 4836 * @psoc: pointer to psoc object 4837 * 4838 * Return: true if peer unmap confirmation support is enabled, else false 4839 */ 4840 static inline 4841 QDF_STATUS ucfg_mlme_get_peer_unmap_conf(struct wlan_objmgr_psoc *psoc) 4842 { 4843 return wlan_mlme_get_peer_unmap_conf(psoc); 4844 } 4845 4846 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 4847 /** 4848 * ucfg_mlme_get_roam_reason_vsie_status() - Get roam reason vsie is 4849 * enabled or disabled 4850 * @psoc: pointer to psoc object 4851 * @roam_reason_vsie_enabled: pointer to hold value of roam reason vsie 4852 * 4853 * Return: Success if able to get bcn rpt err vsie value, else failure 4854 */ 4855 static inline QDF_STATUS 4856 ucfg_mlme_get_roam_reason_vsie_status(struct wlan_objmgr_psoc *psoc, 4857 uint8_t *roam_reason_vsie_enabled) 4858 { 4859 return wlan_mlme_get_roam_reason_vsie_status(psoc, 4860 roam_reason_vsie_enabled); 4861 } 4862 4863 /** 4864 * ucfg_mlme_set_roam_reason_vsie_status() - Update roam reason vsie status 4865 * value with user configured value 4866 * @psoc: pointer to psoc object 4867 * @roam_reason_vsie_enabled: value of roam reason vsie status 4868 * 4869 * Return: Success if able to get bcn rpt err vsie value, else failure 4870 */ 4871 static inline QDF_STATUS 4872 ucfg_mlme_set_roam_reason_vsie_status(struct wlan_objmgr_psoc *psoc, 4873 uint8_t roam_reason_vsie_enabled) 4874 { 4875 return wlan_mlme_set_roam_reason_vsie_status(psoc, 4876 roam_reason_vsie_enabled); 4877 } 4878 4879 #endif 4880 4881 /** 4882 * ucfg_mlme_set_vdev_wifi_std() - Set vdev wifi standard support 4883 * @psoc: pointer to psoc object 4884 * @vdev_id: Vdev id 4885 * @wifi_std: wifi standard version 4886 * 4887 * Return: QDF_STATUS 4888 */ 4889 QDF_STATUS 4890 ucfg_mlme_set_vdev_wifi_std(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 4891 WMI_HOST_WIFI_STANDARD wifi_std); 4892 4893 /** 4894 * ucfg_mlme_set_vdev_traffic_low_latency() - Set/clear vdev low latency 4895 * config 4896 * @psoc: pointer to psoc object 4897 * @vdev_id: Vdev id 4898 * @set: Flag to indicate set or clear 4899 * 4900 * Return: QDF_STATUS 4901 */ 4902 QDF_STATUS 4903 ucfg_mlme_set_vdev_traffic_low_latency(struct wlan_objmgr_psoc *psoc, 4904 uint8_t vdev_id, bool set); 4905 4906 /** 4907 * ucfg_mlme_update_bss_rate_flags() - update bss rate flag as per new channel 4908 * width 4909 * @psoc: pointer to psoc object 4910 * @vdev_id: Vdev id 4911 * @ch_width: channel width to update 4912 * @eht_present: connected bss is eht capable or not 4913 * @he_present: connected bss is he capable or not 4914 * @vht_present: connected bss is vht capable or not 4915 * @ht_present: connected bss is ht capable or not 4916 * 4917 * Return: QDF_STATUS 4918 */ 4919 QDF_STATUS ucfg_mlme_update_bss_rate_flags(struct wlan_objmgr_psoc *psoc, 4920 uint8_t vdev_id, 4921 enum phy_ch_width ch_width, 4922 uint8_t eht_present, 4923 uint8_t he_present, 4924 uint8_t vht_present, 4925 uint8_t ht_present); 4926 4927 /** 4928 * ucfg_mlme_send_ch_width_update_with_notify() - Send chwidth with notify 4929 * capability of FW 4930 * @psoc: pointer to psoc object 4931 * @link_vdev: Link VDEV object 4932 * @ch_width: channel width to update 4933 * @link_vdev_id: vdev id for each link 4934 * 4935 * Return: QDF_STATUS 4936 */ 4937 QDF_STATUS 4938 ucfg_mlme_send_ch_width_update_with_notify(struct wlan_objmgr_psoc *psoc, 4939 struct wlan_objmgr_vdev *link_vdev, 4940 enum phy_ch_width ch_width, 4941 uint8_t link_vdev_id); 4942 4943 /** 4944 * ucfg_mlme_is_chwidth_with_notify_supported() - Get chwidth with notify 4945 * capability of FW 4946 * @psoc: pointer to psoc object 4947 * 4948 * Return: true if chwidth with notify feature supported 4949 */ 4950 bool 4951 ucfg_mlme_is_chwidth_with_notify_supported(struct wlan_objmgr_psoc *psoc); 4952 4953 /** 4954 * ucfg_mlme_connected_chan_stats_request() - process connected channel stats 4955 * request 4956 * @psoc: pointer to psoc object 4957 * @vdev_id: Vdev id 4958 * 4959 * Return: QDF_STATUS 4960 */ 4961 QDF_STATUS ucfg_mlme_connected_chan_stats_request(struct wlan_objmgr_psoc *psoc, 4962 uint8_t vdev_id); 4963 4964 /** 4965 * ucfg_mlme_set_vdev_traffic_high_throughput() - Set/clear vdev high 4966 * throughput config 4967 * @psoc: pointer to psoc object 4968 * @vdev_id: Vdev id 4969 * @set: Flag to indicate set or clear 4970 * 4971 * Return: QDF_STATUS 4972 */ 4973 QDF_STATUS 4974 ucfg_mlme_set_vdev_traffic_high_throughput(struct wlan_objmgr_psoc *psoc, 4975 uint8_t vdev_id, bool set); 4976 4977 /** 4978 * ucfg_mlme_set_user_ps() - Set the PS user config 4979 * @psoc: pointer to psoc object 4980 * @vdev_id: Vdev id 4981 * @ps_enable: Flag to indicate if user PS is enabled 4982 * 4983 * Return: QDF_STATUS 4984 */ 4985 static inline 4986 QDF_STATUS ucfg_mlme_set_user_ps(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 4987 bool ps_enable) 4988 { 4989 return mlme_set_user_ps(psoc, vdev_id, ps_enable); 4990 } 4991 4992 /** 4993 * ucfg_mlme_get_user_ps() - Get user PS flag 4994 * @psoc: pointer to psoc object 4995 * @vdev_id: Vdev id 4996 * 4997 * Return: True if user ps is enabled else false 4998 */ 4999 static inline 5000 bool ucfg_mlme_get_user_ps(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 5001 { 5002 return mlme_get_user_ps(psoc, vdev_id); 5003 } 5004 5005 /** 5006 * ucfg_mlme_set_ft_over_ds() - update ft_over_ds status with user configured 5007 * value 5008 * @psoc: pointer to psoc object 5009 * @ft_over_ds_enable: value of ft_over_ds 5010 * 5011 * Return: QDF Status 5012 */ 5013 static inline QDF_STATUS 5014 ucfg_mlme_set_ft_over_ds(struct wlan_objmgr_psoc *psoc, 5015 uint8_t ft_over_ds_enable) 5016 { 5017 return wlan_mlme_set_ft_over_ds(psoc, ft_over_ds_enable); 5018 } 5019 5020 /** 5021 * ucfg_mlme_is_sta_mon_conc_supported() - Check if STA + Monitor mode 5022 * concurrency is supported 5023 * @psoc: pointer to psoc object 5024 * 5025 * Return: True if supported, else false. 5026 */ 5027 static inline bool 5028 ucfg_mlme_is_sta_mon_conc_supported(struct wlan_objmgr_psoc *psoc) 5029 { 5030 return wlan_mlme_is_sta_mon_conc_supported(psoc); 5031 } 5032 5033 /** 5034 * ucfg_mlme_cfg_get_eht_caps() - Get the EHT capability info 5035 * @psoc: pointer to psoc object 5036 * @eht_cap: Caps that needs to be filled. 5037 * 5038 * Return: QDF Status 5039 */ 5040 static inline 5041 QDF_STATUS ucfg_mlme_cfg_get_eht_caps(struct wlan_objmgr_psoc *psoc, 5042 tDot11fIEeht_cap *eht_cap) 5043 { 5044 return mlme_cfg_get_eht_caps(psoc, eht_cap); 5045 } 5046 5047 static inline QDF_STATUS 5048 ucfg_mlme_cfg_get_vht_ampdu_len_exp(struct wlan_objmgr_psoc *psoc, 5049 uint8_t *value) 5050 { 5051 return wlan_mlme_cfg_get_vht_ampdu_len_exp(psoc, value); 5052 } 5053 5054 static inline QDF_STATUS 5055 ucfg_mlme_cfg_get_vht_max_mpdu_len(struct wlan_objmgr_psoc *psoc, 5056 uint8_t *value) 5057 { 5058 return wlan_mlme_cfg_get_vht_max_mpdu_len(psoc, value); 5059 } 5060 5061 static inline QDF_STATUS 5062 ucfg_mlme_cfg_get_ht_smps(struct wlan_objmgr_psoc *psoc, 5063 uint8_t *value) 5064 { 5065 return wlan_mlme_cfg_get_ht_smps(psoc, value); 5066 } 5067 5068 #ifdef FEATURE_WLAN_CH_AVOID_EXT 5069 /** 5070 * ucfg_mlme_get_coex_unsafe_chan_nb_user_prefer() - get coex unsafe nb 5071 * support 5072 * @psoc: pointer to psoc object 5073 * 5074 * Return: coex_unsafe_chan_nb_user_prefer 5075 */ 5076 bool ucfg_mlme_get_coex_unsafe_chan_nb_user_prefer( 5077 struct wlan_objmgr_psoc *psoc); 5078 5079 bool ucfg_mlme_get_coex_unsafe_chan_nb_user_prefer_for_sap( 5080 struct wlan_objmgr_psoc *psoc); 5081 5082 /** 5083 * ucfg_mlme_get_coex_unsafe_chan_reg_disable() - get reg disable cap for 5084 * coex unsafe channels support 5085 * @psoc: pointer to psoc object 5086 * 5087 * Return: coex_unsafe_chan_reg_disable 5088 */ 5089 bool ucfg_mlme_get_coex_unsafe_chan_reg_disable( 5090 struct wlan_objmgr_psoc *psoc); 5091 #else 5092 static inline 5093 bool ucfg_mlme_get_coex_unsafe_chan_nb_user_prefer( 5094 struct wlan_objmgr_psoc *psoc) 5095 { 5096 return false; 5097 } 5098 5099 static inline 5100 bool ucfg_mlme_get_coex_unsafe_chan_nb_user_prefer_for_sap( 5101 struct wlan_objmgr_psoc *psoc) 5102 { 5103 return false; 5104 } 5105 5106 static inline 5107 bool ucfg_mlme_get_coex_unsafe_chan_reg_disable( 5108 struct wlan_objmgr_psoc *psoc) 5109 { 5110 return false; 5111 } 5112 #endif 5113 5114 /** 5115 * ucfg_set_ratemask_params() - Set ratemask config 5116 * @vdev: pointer to vdev object 5117 * @num_ratemask: number of ratemask params 5118 * @rate_params: ratemask params 5119 * 5120 * Return: QDF_STATUS 5121 */ 5122 static inline QDF_STATUS 5123 ucfg_set_ratemask_params(struct wlan_objmgr_vdev *vdev, 5124 uint8_t num_ratemask, 5125 struct config_ratemask_params *rate_params) 5126 { 5127 return wlan_mlme_update_ratemask_params(vdev, num_ratemask, 5128 rate_params); 5129 } 5130 5131 /* 5132 * ucfg_mlme_set_user_mcc_quota() - Set the user set mcc quota in mlme 5133 * value 5134 * @psoc: pointer to psoc object 5135 * @quota: pointer to user mcc quota object 5136 * 5137 * Return: QDF Status 5138 */ 5139 static inline 5140 QDF_STATUS ucfg_mlme_set_user_mcc_quota(struct wlan_objmgr_psoc *psoc, 5141 struct wlan_user_mcc_quota *quota) 5142 { 5143 return wlan_mlme_set_user_mcc_quota(psoc, quota); 5144 } 5145 5146 /** 5147 * ucfg_mlme_get_user_mcc_quota() - Get the user set mcc quota from mlme 5148 * value 5149 * @psoc: pointer to psoc object 5150 * @quota: pointer to user mcc quota object 5151 * 5152 * Return: QDF Status 5153 */ 5154 static inline 5155 QDF_STATUS ucfg_mlme_get_user_mcc_quota(struct wlan_objmgr_psoc *psoc, 5156 struct wlan_user_mcc_quota *quota) 5157 { 5158 return wlan_mlme_get_user_mcc_quota(psoc, quota); 5159 } 5160 5161 /** 5162 * ucfg_mlme_get_user_mcc_quota_percentage() - Get user mcc quota percentage 5163 * duty-cycle for a i/f type or mode 5164 * @psoc: pointer to psoc object 5165 * 5166 * MCC duty-cycle value in below format 5167 * ****************************************************** 5168 * |bit 31-24 | bit 23-16 | bits 15-8 |bits 7-0 | 5169 * | Unused | Quota for | chan. # for |chan. # for| 5170 * | | 1st chan | 1st chan. |2nd chan. | 5171 * ***************************************************** 5172 * 5173 * Return: primary iface MCC duty-cycle value 5174 */ 5175 static inline 5176 uint32_t ucfg_mlme_get_user_mcc_quota_percentage(struct wlan_objmgr_psoc *psoc) 5177 { 5178 return wlan_mlme_get_user_mcc_duty_cycle_percentage(psoc); 5179 } 5180 5181 /** 5182 * ucfg_mlme_get_wds_mode() - Get the configured WDS mode 5183 * @psoc: pointer to psoc object 5184 * 5185 * Return: supported wds mode from enum wlan_wds_mode 5186 */ 5187 static inline uint32_t 5188 ucfg_mlme_get_wds_mode(struct wlan_objmgr_psoc *psoc) 5189 { 5190 return wlan_mlme_get_wds_mode(psoc); 5191 } 5192 5193 /** 5194 * ucfg_mlme_set_wds_mode() - Set the configured WDS mode 5195 * @psoc: pointer to psoc object 5196 * @mode: wds mode to set 5197 * 5198 * Return: void 5199 */ 5200 static inline void 5201 ucfg_mlme_set_wds_mode(struct wlan_objmgr_psoc *psoc, uint32_t mode) 5202 { 5203 wlan_mlme_set_wds_mode(psoc, mode); 5204 } 5205 5206 #ifdef WLAN_FEATURE_SON 5207 /** 5208 * ucfg_mlme_get_vdev_max_mcs_idx() - Get max mcs idx of given vdev 5209 * @vdev: pointer to vdev object 5210 * 5211 * Return: max mcs idx of given vdev 5212 */ 5213 static inline uint8_t 5214 ucfg_mlme_get_vdev_max_mcs_idx(struct wlan_objmgr_vdev *vdev) 5215 { 5216 return mlme_get_vdev_max_mcs_idx(vdev); 5217 } 5218 #endif /* WLAN_FEATURE_SON */ 5219 5220 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 5221 /** 5222 * ucfg_mlme_get_enable_6ghz_sp_mode_support() - Get 6 GHz SP mode support cfg 5223 * @psoc: pointer to psoc object 5224 * @value: value to be set 5225 * 5226 * Return: QDF Status 5227 */ 5228 QDF_STATUS 5229 ucfg_mlme_get_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc, 5230 bool *value); 5231 5232 /** 5233 * ucfg_mlme_get_afc_disable_timer_check() - Get AFC timer check cfg 5234 * @psoc: pointer to psoc object 5235 * @value: value to be set 5236 * 5237 * Return: QDF Status 5238 */ 5239 QDF_STATUS 5240 ucfg_mlme_get_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc, 5241 bool *value); 5242 /** 5243 * ucfg_mlme_get_afc_disable_request_id_check() - Get AFC request id check cfg 5244 * @psoc: pointer to psoc object 5245 * @value: value to be set 5246 * 5247 * Return: QDF Status 5248 */ 5249 QDF_STATUS 5250 ucfg_mlme_get_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc, 5251 bool *value); 5252 5253 /** 5254 * ucfg_mlme_get_afc_reg_noaction() - Get AFC no action cfg 5255 * @psoc: pointer to psoc object 5256 * @value: value to be set 5257 * 5258 * Return: QDF Status 5259 */ 5260 QDF_STATUS 5261 ucfg_mlme_get_afc_reg_noaction(struct wlan_objmgr_psoc *psoc, bool *value); 5262 #else 5263 static inline QDF_STATUS 5264 ucfg_mlme_get_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc, 5265 bool *value) 5266 { 5267 return QDF_STATUS_E_NOSUPPORT; 5268 } 5269 5270 static inline QDF_STATUS 5271 ucfg_mlme_get_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc, 5272 bool *value) 5273 { 5274 return QDF_STATUS_E_NOSUPPORT; 5275 } 5276 5277 static inline QDF_STATUS 5278 ucfg_mlme_get_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc, 5279 bool *value) 5280 { 5281 return QDF_STATUS_E_NOSUPPORT; 5282 } 5283 5284 static inline QDF_STATUS 5285 ucfg_mlme_get_afc_reg_noaction(struct wlan_objmgr_psoc *psoc, bool *value) 5286 { 5287 return QDF_STATUS_E_NOSUPPORT; 5288 } 5289 #endif 5290 5291 #ifdef CONNECTION_ROAMING_CFG 5292 /** 5293 * ucfg_mlme_set_connection_roaming_ini_present() - Set connection roaming ini 5294 * present 5295 * @psoc: pointer to psoc object 5296 * @value: Value to be set 5297 * 5298 * Return: QDF Status 5299 */ 5300 QDF_STATUS 5301 ucfg_mlme_set_connection_roaming_ini_present(struct wlan_objmgr_psoc *psoc, 5302 bool value); 5303 5304 /** 5305 * ucfg_mlme_get_connection_roaming_ini_present() - Get connection roaming ini 5306 * present 5307 * @psoc: pointer to psoc object 5308 * @value: Value to be get 5309 * 5310 * Return: QDF Status 5311 */ 5312 QDF_STATUS 5313 ucfg_mlme_get_connection_roaming_ini_present(struct wlan_objmgr_psoc *psoc, 5314 bool *value); 5315 #else 5316 static inline QDF_STATUS 5317 ucfg_mlme_set_connection_roaming_ini_present(struct wlan_objmgr_psoc *psoc, 5318 bool value) 5319 { 5320 return QDF_STATUS_E_NOSUPPORT; 5321 } 5322 5323 static inline QDF_STATUS 5324 ucfg_mlme_get_connection_roaming_ini_present(struct wlan_objmgr_psoc *psoc, 5325 bool *value) 5326 { 5327 return QDF_STATUS_E_NOSUPPORT; 5328 } 5329 #endif /* CONNECTION_ROAMING_CFG */ 5330 5331 /** 5332 * ucfg_mlme_get_ch_width_from_phymode() - Convert phymode to ch_width 5333 * @phy_mode: phy mode 5334 * 5335 * Return: enum phy_ch_width 5336 */ 5337 static inline enum phy_ch_width 5338 ucfg_mlme_get_ch_width_from_phymode(enum wlan_phymode phy_mode) 5339 { 5340 return wlan_mlme_get_ch_width_from_phymode(phy_mode); 5341 } 5342 5343 /** 5344 * ucfg_mlme_get_peer_ch_width() - get ch_width of the given peer 5345 * @psoc: pointer to psoc object 5346 * @mac: peer mac 5347 * 5348 * Return: enum phy_ch_width 5349 */ 5350 static inline enum phy_ch_width 5351 ucfg_mlme_get_peer_ch_width(struct wlan_objmgr_psoc *psoc, uint8_t *mac) 5352 { 5353 return wlan_mlme_get_peer_ch_width(psoc, mac); 5354 } 5355 5356 /** 5357 * ucfg_mlme_get_vdev_phy_mode() - Get phymode of a vdev 5358 * @psoc: pointer to psoc object 5359 * @vdev_id: vdev id 5360 * 5361 * Return: enum wlan_phymode 5362 */ 5363 enum wlan_phymode 5364 ucfg_mlme_get_vdev_phy_mode(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id); 5365 5366 #if defined(WLAN_FEATURE_SR) 5367 /** 5368 * ucfg_mlme_get_sr_enable_modes() - check for which mode SR is enabled 5369 * 5370 * @psoc: pointer to psoc object 5371 * @val: SR(Spatial Reuse) enable modes 5372 * 5373 * Return: void 5374 */ 5375 static inline void 5376 ucfg_mlme_get_sr_enable_modes(struct wlan_objmgr_psoc *psoc, 5377 uint8_t *val) 5378 { 5379 wlan_mlme_get_sr_enable_modes(psoc, val); 5380 } 5381 #else 5382 static inline void 5383 ucfg_mlme_get_sr_enable_modes(struct wlan_objmgr_psoc *psoc, 5384 uint8_t *val) 5385 { 5386 *val = 0; 5387 } 5388 #endif 5389 5390 /** 5391 * ucfg_mlme_get_valid_channels - get valid channels for 5392 * current regulatory domain 5393 * @psoc: pointer to psoc object 5394 * @ch_freq_list: list of the valid channel frequencies 5395 * @list_len: length of the channel list 5396 * 5397 * This function will get valid channels for current regulatory domain 5398 * 5399 * Return: QDF_STATUS_SUCCESS or non-zero on failure 5400 */ 5401 QDF_STATUS 5402 ucfg_mlme_get_valid_channels(struct wlan_objmgr_psoc *psoc, 5403 uint32_t *ch_freq_list, uint32_t *list_len); 5404 5405 /** 5406 * ucfg_mlme_set_ul_mu_config - set ul mu config 5407 * @psoc: pointer to psoc object 5408 * @vdev_id : vdev ID 5409 * @ulmu_disable: ul mu value 5410 * 5411 * Inline UCFG API to be used by HDD/OSIF callers 5412 * 5413 * Return: QDF_STATUS_SUCCESS or non-zero on failure 5414 */ 5415 static inline 5416 QDF_STATUS ucfg_mlme_set_ul_mu_config(struct wlan_objmgr_psoc *psoc, 5417 uint8_t vdev_id, 5418 uint8_t ulmu_disable) 5419 { 5420 return wlan_mlme_set_ul_mu_config(psoc, vdev_id, ulmu_disable); 5421 } 5422 5423 /** 5424 * ucfg_mlme_assemble_rate_code - assemble rate code to be sent to FW 5425 * @preamble: rate preamble 5426 * @nss: number of spatial streams 5427 * @rate: rate index 5428 * 5429 * Rate code assembling is different for targets which are 11ax capable. 5430 * Check for the target support and assemble the rate code accordingly. 5431 * 5432 * Return: assembled rate code 5433 */ 5434 static inline uint32_t 5435 ucfg_mlme_assemble_rate_code(uint8_t preamble, uint8_t nss, uint8_t rate) 5436 { 5437 return wlan_mlme_assemble_rate_code(preamble, nss, rate); 5438 } 5439 5440 /** 5441 * ucfg_mlme_get_keepalive_period() - Get keep alive period 5442 * @vdev: VDEV object 5443 * 5444 * Return: Keep alive period. 5445 */ 5446 static inline 5447 uint16_t ucfg_mlme_get_keepalive_period(struct wlan_objmgr_vdev *vdev) 5448 { 5449 return wlan_mlme_get_keepalive_period(vdev); 5450 } 5451 #endif /* _WLAN_MLME_UCFG_API_H_ */ 5452