1 /* 2 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 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: define internal APIs related to the mlme component 21 */ 22 23 #include "wlan_mlme_main.h" 24 #include "include/wlan_vdev_mlme.h" 25 #include "cfg_ucfg_api.h" 26 #include "wmi_unified.h" 27 #include "wlan_scan_public_structs.h" 28 #include "wlan_psoc_mlme_api.h" 29 #include "wlan_vdev_mlme_api.h" 30 #include "wlan_mlme_api.h" 31 #include <wlan_crypto_global_api.h> 32 #include <wlan_mlo_mgr_cmn.h> 33 #include "wlan_mlme_ucfg_api.h" 34 #include "wifi_pos_ucfg_i.h" 35 #include "wlan_mlo_mgr_sta.h" 36 #include "twt/core/src/wlan_twt_cfg.h" 37 #include "wlan_scan_api.h" 38 #include "wlan_mlme_vdev_mgr_interface.h" 39 #include "wlan_vdev_mgr_utils_api.h" 40 #include <wmi_unified_priv.h> 41 #include <target_if.h> 42 43 #define NUM_OF_SOUNDING_DIMENSIONS 1 /*Nss - 1, (Nss = 2 for 2x2)*/ 44 45 /* Time to passive scan dwell for scan to get channel stats, in milliseconds */ 46 #define MLME_GET_CHAN_STATS_PASSIVE_SCAN_TIME 40 47 #define MLME_GET_CHAN_STATS_WIDE_BAND_PASSIVE_SCAN_TIME 110 48 49 struct wlan_mlme_rx_ops * 50 mlme_get_rx_ops(struct wlan_objmgr_psoc *psoc) 51 { 52 struct wlan_mlme_psoc_ext_obj *psoc_ext_priv; 53 54 if (!psoc) { 55 mlme_err("psoc object is NULL"); 56 return NULL; 57 } 58 psoc_ext_priv = wlan_psoc_mlme_get_ext_hdl(psoc); 59 if (!psoc_ext_priv) { 60 mlme_err("psoc legacy private object is NULL"); 61 return NULL; 62 } 63 64 return &psoc_ext_priv->mlme_rx_ops; 65 } 66 67 void wlan_mlme_register_rx_ops(struct wlan_mlme_rx_ops *rx_ops) 68 { 69 rx_ops->peer_oper_mode_eventid = wlan_mlme_set_peer_indicated_ch_width; 70 } 71 72 struct wlan_mlme_psoc_ext_obj *mlme_get_psoc_ext_obj_fl( 73 struct wlan_objmgr_psoc *psoc, 74 const char *func, uint32_t line) 75 { 76 77 return wlan_psoc_mlme_get_ext_hdl(psoc); 78 } 79 80 struct wlan_mlme_nss_chains *mlme_get_dynamic_vdev_config( 81 struct wlan_objmgr_vdev *vdev) 82 { 83 struct mlme_legacy_priv *mlme_priv; 84 85 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 86 if (!mlme_priv) { 87 mlme_legacy_err("vdev legacy private object is NULL"); 88 return NULL; 89 } 90 91 return &mlme_priv->dynamic_cfg; 92 } 93 94 /* Buffer len size to consider the 4 char freq, and a space, Total 5 */ 95 #define MLME_CHAN_WEIGHT_CHAR_LEN 5 96 #define MLME_MAX_CHAN_TO_PRINT 39 97 98 /** 99 * mlme_fill_freq_in_scan_start_request() - Fill frequencies in scan req 100 * @vdev: vdev common object 101 * @req: pointer to scan request 102 * 103 * Return: QDF_STATUS 104 */ 105 static QDF_STATUS 106 mlme_fill_freq_in_scan_start_request(struct wlan_objmgr_vdev *vdev, 107 struct scan_start_request *req) 108 { 109 const struct bonded_channel_freq *range; 110 struct mlme_legacy_priv *mlme_priv; 111 enum phy_ch_width associated_ch_width; 112 uint8_t i; 113 struct chan_list *scan_chan_list; 114 qdf_freq_t first_freq, operation_chan_freq, sec_2g_freq; 115 char *chan_buff = NULL; 116 uint32_t buff_len, buff_num = 0, chan_count = 0; 117 118 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 119 if (!mlme_priv) 120 return QDF_STATUS_E_FAILURE; 121 122 operation_chan_freq = wlan_get_operation_chan_freq(vdev); 123 associated_ch_width = 124 mlme_priv->connect_info.assoc_chan_info.assoc_ch_width; 125 if (associated_ch_width == CH_WIDTH_INVALID) { 126 mlme_debug("vdev %d : Invalid associated ch width for freq %d", 127 req->scan_req.vdev_id, operation_chan_freq); 128 return QDF_STATUS_E_FAILURE; 129 } 130 131 req->scan_req.dwell_time_passive = 132 MLME_GET_CHAN_STATS_PASSIVE_SCAN_TIME; 133 req->scan_req.dwell_time_passive_6g = 134 MLME_GET_CHAN_STATS_PASSIVE_SCAN_TIME; 135 136 if (associated_ch_width == CH_WIDTH_20MHZ) { 137 mlme_debug("vdev %d :Trigger scan for associated freq %d bw %d", 138 req->scan_req.vdev_id, operation_chan_freq, 139 associated_ch_width); 140 req->scan_req.chan_list.num_chan = 1; 141 req->scan_req.chan_list.chan[0].freq = operation_chan_freq; 142 return QDF_STATUS_SUCCESS; 143 } 144 145 if (wlan_reg_is_24ghz_ch_freq(operation_chan_freq) && 146 associated_ch_width == CH_WIDTH_40MHZ) { 147 sec_2g_freq = 148 mlme_priv->connect_info.assoc_chan_info.sec_2g_freq; 149 if (!sec_2g_freq) { 150 mlme_debug("vdev %d : Invalid sec 2g freq for freq: %d", 151 req->scan_req.vdev_id, operation_chan_freq); 152 return QDF_STATUS_E_FAILURE; 153 } 154 155 if (operation_chan_freq > sec_2g_freq) { 156 req->scan_req.chan_list.chan[0].freq = sec_2g_freq; 157 req->scan_req.chan_list.chan[1].freq = 158 operation_chan_freq; 159 } else { 160 req->scan_req.chan_list.chan[0].freq = 161 operation_chan_freq; 162 req->scan_req.chan_list.chan[1].freq = sec_2g_freq; 163 } 164 165 req->scan_req.chan_list.num_chan = 2; 166 return QDF_STATUS_SUCCESS; 167 } 168 169 range = wlan_reg_get_bonded_chan_entry(operation_chan_freq, 170 associated_ch_width, 0); 171 if (!range) { 172 mlme_debug("vdev %d: Invalid freq range for freq: %d bw: %d", 173 req->scan_req.vdev_id, operation_chan_freq, 174 associated_ch_width); 175 return QDF_STATUS_E_FAILURE; 176 } 177 178 scan_chan_list = qdf_mem_malloc(sizeof(*scan_chan_list)); 179 if (!scan_chan_list) 180 return QDF_STATUS_E_NOMEM; 181 182 scan_chan_list->num_chan = 0; 183 first_freq = range->start_freq; 184 for (; first_freq <= range->end_freq; first_freq += BW_20_MHZ) { 185 scan_chan_list->chan[scan_chan_list->num_chan].freq = 186 first_freq; 187 scan_chan_list->num_chan++; 188 } 189 190 req->scan_req.chan_list.num_chan = scan_chan_list->num_chan; 191 192 mlme_debug("vdev %d : freq %d bw %d, range [%d-%d], Total freq %d", 193 req->scan_req.vdev_id, operation_chan_freq, 194 associated_ch_width, range->start_freq, 195 range->end_freq, req->scan_req.chan_list.num_chan); 196 197 buff_len = (QDF_MIN(req->scan_req.chan_list.num_chan, 198 MLME_MAX_CHAN_TO_PRINT) * MLME_CHAN_WEIGHT_CHAR_LEN) + 1; 199 200 chan_buff = qdf_mem_malloc(buff_len); 201 if (!chan_buff) { 202 qdf_mem_free(scan_chan_list); 203 return QDF_STATUS_E_NOMEM; 204 } 205 for (i = 0; i < req->scan_req.chan_list.num_chan; i++) { 206 req->scan_req.chan_list.chan[i].freq = 207 scan_chan_list->chan[i].freq; 208 buff_num += qdf_scnprintf(chan_buff + buff_num, 209 buff_len - buff_num, " %d", 210 req->scan_req.chan_list.chan[i].freq); 211 chan_count++; 212 if (chan_count >= MLME_MAX_CHAN_TO_PRINT) { 213 mlme_debug("Freq list: %s", chan_buff); 214 buff_num = 0; 215 chan_count = 0; 216 } 217 } 218 219 if (buff_num) 220 mlme_debug("Freq list: %s", chan_buff); 221 222 qdf_mem_free(chan_buff); 223 qdf_mem_free(scan_chan_list); 224 225 return QDF_STATUS_SUCCESS; 226 } 227 228 #ifdef WLAN_FEATURE_11BE 229 static enum scan_phy_mode mlme_get_scan_phy_mode(void) 230 { 231 return SCAN_PHY_MODE_11BE_EHT160; 232 } 233 234 static enum scan_phy_mode 235 wlan_scan_get_11be_scan_phy_mode(enum wlan_phymode ch_phymode) 236 { 237 enum scan_phy_mode scan_phymode; 238 239 switch (ch_phymode) { 240 case WLAN_PHYMODE_11BEA_EHT20: 241 scan_phymode = SCAN_PHY_MODE_11BE_EHT20; 242 break; 243 case WLAN_PHYMODE_11BEG_EHT20: 244 scan_phymode = SCAN_PHY_MODE_11BE_EHT20_2G; 245 break; 246 case WLAN_PHYMODE_11BEA_EHT40: 247 scan_phymode = SCAN_PHY_MODE_11BE_EHT40; 248 break; 249 case WLAN_PHYMODE_11BEG_EHT40: 250 scan_phymode = SCAN_PHY_MODE_11BE_EHT40_2G; 251 break; 252 case WLAN_PHYMODE_11BEA_EHT80: 253 scan_phymode = SCAN_PHY_MODE_11BE_EHT80; 254 break; 255 case WLAN_PHYMODE_11BEG_EHT80: 256 scan_phymode = SCAN_PHY_MODE_11BE_EHT80_2G; 257 break; 258 case WLAN_PHYMODE_11BEA_EHT160: 259 scan_phymode = SCAN_PHY_MODE_11BE_EHT160; 260 break; 261 case WLAN_PHYMODE_11BEA_EHT320: 262 scan_phymode = SCAN_PHY_MODE_11BE_EHT320; 263 break; 264 default: 265 scan_phymode = SCAN_PHY_MODE_UNKNOWN; 266 break; 267 } 268 269 return scan_phymode; 270 } 271 #else 272 static inline enum scan_phy_mode mlme_get_scan_phy_mode(void) 273 { 274 return SCAN_PHY_MODE_UNKNOWN; 275 } 276 277 static inline enum scan_phy_mode 278 wlan_scan_get_11be_scan_phy_mode(enum wlan_phymode ch_phymode) 279 { 280 return SCAN_PHY_MODE_UNKNOWN; 281 } 282 #endif 283 284 /** 285 * wlan_scan_get_scan_phy_mode() - get scan phymode from channel phy mode 286 * @vdev: vdev common object 287 * @op_freq: operational frequency 288 * @vdev_id: vdev id 289 * 290 * Return: enum scan_phy_mode 291 */ 292 static enum scan_phy_mode 293 wlan_scan_get_scan_phy_mode(struct wlan_objmgr_vdev *vdev, qdf_freq_t op_freq, 294 uint32_t vdev_id) 295 { 296 struct wlan_channel *des_chan; 297 enum scan_phy_mode scan_phymode = SCAN_PHY_MODE_UNKNOWN; 298 299 des_chan = wlan_vdev_mlme_get_des_chan(vdev); 300 if (!des_chan) { 301 mlme_debug("vdev %d : des_chan is null", vdev_id); 302 return scan_phymode; 303 } 304 305 switch (des_chan->ch_phymode) { 306 case WLAN_PHYMODE_11A: 307 scan_phymode = SCAN_PHY_MODE_11A; 308 break; 309 case WLAN_PHYMODE_11B: 310 scan_phymode = SCAN_PHY_MODE_11B; 311 break; 312 case WLAN_PHYMODE_11G: 313 scan_phymode = SCAN_PHY_MODE_11G; 314 break; 315 case WLAN_PHYMODE_11G_ONLY: 316 scan_phymode = SCAN_PHY_MODE_11GONLY; 317 break; 318 case WLAN_PHYMODE_11NA_HT20: 319 scan_phymode = SCAN_PHY_MODE_11NA_HT20; 320 break; 321 case WLAN_PHYMODE_11NG_HT20: 322 scan_phymode = SCAN_PHY_MODE_11NG_HT20; 323 break; 324 case WLAN_PHYMODE_11NA_HT40: 325 scan_phymode = SCAN_PHY_MODE_11NA_HT40; 326 break; 327 case WLAN_PHYMODE_11NG_HT40: 328 scan_phymode = SCAN_PHY_MODE_11NG_HT40; 329 break; 330 case WLAN_PHYMODE_11AC_VHT20: 331 scan_phymode = SCAN_PHY_MODE_11AC_VHT20; 332 break; 333 case WLAN_PHYMODE_11AC_VHT40: 334 scan_phymode = SCAN_PHY_MODE_11AC_VHT40; 335 break; 336 case WLAN_PHYMODE_11AC_VHT80: 337 scan_phymode = SCAN_PHY_MODE_11AC_VHT80; 338 break; 339 case WLAN_PHYMODE_11AC_VHT20_2G: 340 scan_phymode = SCAN_PHY_MODE_11AC_VHT20_2G; 341 break; 342 case WLAN_PHYMODE_11AC_VHT40_2G: 343 scan_phymode = SCAN_PHY_MODE_11AC_VHT40_2G; 344 break; 345 case WLAN_PHYMODE_11AC_VHT80_2G: 346 scan_phymode = SCAN_PHY_MODE_11AC_VHT80_2G; 347 break; 348 case WLAN_PHYMODE_11AC_VHT80_80: 349 scan_phymode = SCAN_PHY_MODE_11AC_VHT80_80; 350 break; 351 case WLAN_PHYMODE_11AC_VHT160: 352 scan_phymode = SCAN_PHY_MODE_11AC_VHT160; 353 break; 354 case WLAN_PHYMODE_11AXA_HE20: 355 scan_phymode = SCAN_PHY_MODE_11AX_HE20; 356 break; 357 case WLAN_PHYMODE_11AXG_HE20: 358 scan_phymode = SCAN_PHY_MODE_11AX_HE20_2G; 359 break; 360 case WLAN_PHYMODE_11AXA_HE40: 361 scan_phymode = SCAN_PHY_MODE_11AX_HE40; 362 break; 363 case WLAN_PHYMODE_11AXG_HE40: 364 scan_phymode = SCAN_PHY_MODE_11AX_HE40_2G; 365 break; 366 case WLAN_PHYMODE_11AXA_HE80: 367 scan_phymode = SCAN_PHY_MODE_11AX_HE80; 368 break; 369 case WLAN_PHYMODE_11AXG_HE80: 370 scan_phymode = SCAN_PHY_MODE_11AX_HE80_2G; 371 break; 372 case WLAN_PHYMODE_11AXA_HE80_80: 373 scan_phymode = SCAN_PHY_MODE_11AX_HE80_80; 374 break; 375 case WLAN_PHYMODE_11AXA_HE160: 376 scan_phymode = SCAN_PHY_MODE_11AX_HE160; 377 break; 378 default: 379 scan_phymode = SCAN_PHY_MODE_UNKNOWN; 380 break; 381 } 382 383 if (scan_phymode != SCAN_PHY_MODE_UNKNOWN) 384 return scan_phymode; 385 386 scan_phymode = wlan_scan_get_11be_scan_phy_mode(des_chan->ch_phymode); 387 388 return scan_phymode; 389 } 390 391 QDF_STATUS 392 mlme_update_freq_in_scan_start_req(struct wlan_objmgr_vdev *vdev, 393 struct scan_start_request *req, 394 enum phy_ch_width scan_ch_width, 395 qdf_freq_t scan_freq) 396 { 397 const struct bonded_channel_freq *range; 398 uint8_t num_chan; 399 qdf_freq_t op_freq, center_20_freq, start_freq, end_freq; 400 enum scan_phy_mode phymode = SCAN_PHY_MODE_UNKNOWN; 401 uint8_t vdev_id; 402 403 vdev_id = vdev->vdev_objmgr.vdev_id; 404 405 if (scan_freq != INVALID_CHANNEL) 406 op_freq = scan_freq; 407 else 408 op_freq = wlan_get_operation_chan_freq(vdev); 409 410 mlme_debug("vdev %d : fill ch list for op_freq:%d, scan_ch_width: %d", 411 vdev_id, op_freq, scan_ch_width); 412 413 if (scan_ch_width == CH_WIDTH_320MHZ) { 414 range = wlan_reg_get_bonded_chan_entry(op_freq, 415 scan_ch_width, 0); 416 if (!range) { 417 mlme_debug("vdev %d : range is null for freq %d", 418 vdev_id, op_freq); 419 return QDF_STATUS_E_FAILURE; 420 } 421 422 phymode = mlme_get_scan_phy_mode(); 423 if (phymode == SCAN_PHY_MODE_UNKNOWN) { 424 mlme_debug("vdev %d : invalid scan phymode for freq %d", 425 vdev_id, op_freq); 426 return QDF_STATUS_E_FAILURE; 427 } 428 429 start_freq = range->start_freq; 430 end_freq = range->end_freq; 431 432 /* fill connected 6 GHz ML link freq in wide band scan list */ 433 center_20_freq = start_freq + (7 * BW_20_MHZ); 434 if (op_freq > center_20_freq) 435 end_freq = op_freq; 436 else 437 start_freq = op_freq; 438 439 num_chan = req->scan_req.chan_list.num_chan; 440 req->scan_req.chan_list.chan[num_chan].freq = start_freq; 441 req->scan_req.chan_list.chan[num_chan].phymode = phymode; 442 num_chan += 1; 443 req->scan_req.chan_list.chan[num_chan].freq = end_freq; 444 req->scan_req.chan_list.chan[num_chan].phymode = phymode; 445 num_chan += 1; 446 req->scan_req.chan_list.num_chan = num_chan; 447 } else { 448 phymode = wlan_scan_get_scan_phy_mode(vdev, op_freq, vdev_id); 449 if (phymode == SCAN_PHY_MODE_UNKNOWN) { 450 mlme_debug("vdev %d : invalid scan phymode for freq %d", 451 vdev_id, op_freq); 452 return QDF_STATUS_E_FAILURE; 453 } 454 455 num_chan = req->scan_req.chan_list.num_chan; 456 req->scan_req.chan_list.chan[num_chan].freq = op_freq; 457 req->scan_req.chan_list.chan[num_chan].phymode = phymode; 458 req->scan_req.chan_list.num_chan += 1; 459 } 460 461 return QDF_STATUS_SUCCESS; 462 } 463 464 #ifdef WLAN_FEATURE_11BE_MLO 465 /** 466 * mlme_fill_freq_in_mlo_wide_band_scan_start_req() - Fill frequencies in wide 467 * band scan req for mlo connection 468 * @vdev: vdev common object 469 * @req: pointer to scan request 470 * 471 * Return: QDF_STATUS 472 */ 473 static QDF_STATUS 474 mlme_fill_freq_in_mlo_wide_band_scan_start_req(struct wlan_objmgr_vdev *vdev, 475 struct scan_start_request *req) 476 { 477 struct wlan_mlo_dev_context *mlo_dev_ctx; 478 struct wlan_mlo_sta *sta_ctx = NULL; 479 uint8_t i; 480 QDF_STATUS status; 481 struct wlan_objmgr_vdev *mlo_vdev; 482 struct mlme_legacy_priv *mlme_priv; 483 enum phy_ch_width associated_ch_width = CH_WIDTH_INVALID; 484 struct assoc_channel_info *assoc_chan_info; 485 486 mlo_dev_ctx = vdev->mlo_dev_ctx; 487 if (!mlo_dev_ctx) { 488 mlme_err("vdev %d :mlo_dev_ctx is NULL", req->scan_req.vdev_id); 489 return QDF_STATUS_E_FAILURE; 490 } 491 492 sta_ctx = mlo_dev_ctx->sta_ctx; 493 if (!sta_ctx) { 494 mlme_err("vdev %d :mlo_dev_ctx is NULL", req->scan_req.vdev_id); 495 return QDF_STATUS_E_FAILURE; 496 } 497 498 for (i = 0; i < WLAN_UMAC_MLO_MAX_VDEVS; i++) { 499 if (!mlo_dev_ctx->wlan_vdev_list[i]) 500 continue; 501 if (qdf_test_bit(i, sta_ctx->wlan_connected_links)) { 502 mlo_vdev = mlo_dev_ctx->wlan_vdev_list[i]; 503 mlme_priv = wlan_vdev_mlme_get_ext_hdl(mlo_vdev); 504 if (!mlme_priv) { 505 mlme_legacy_err("vdev legacy priv obj is NULL"); 506 return QDF_STATUS_E_FAILURE; 507 } 508 509 assoc_chan_info = 510 &mlme_priv->connect_info.assoc_chan_info; 511 associated_ch_width = assoc_chan_info->assoc_ch_width; 512 if (associated_ch_width == CH_WIDTH_INVALID) { 513 mlme_debug("vdev %d :Invalid assoc ch_width", 514 req->scan_req.vdev_id); 515 return QDF_STATUS_E_FAILURE; 516 } 517 518 status = mlme_update_freq_in_scan_start_req(mlo_vdev, 519 req, associated_ch_width, 520 INVALID_CHANNEL); 521 if (QDF_IS_STATUS_ERROR(status)) 522 return QDF_STATUS_E_FAILURE; 523 } 524 } 525 526 mlme_debug("vdev %d :trigger wide band scan for mlo conn, num freq %d", 527 req->scan_req.vdev_id, req->scan_req.chan_list.num_chan); 528 return QDF_STATUS_SUCCESS; 529 } 530 #else 531 static inline QDF_STATUS 532 mlme_fill_freq_in_mlo_wide_band_scan_start_req(struct wlan_objmgr_vdev *vdev, 533 struct scan_start_request *req) 534 { 535 return QDF_STATUS_E_FAILURE; 536 } 537 #endif 538 539 /** 540 * mlme_fill_freq_in_wide_scan_start_request() - Fill frequencies in wide band 541 * scan req 542 * @vdev: vdev common object 543 * @req: pointer to scan request 544 * 545 * Return: QDF_STATUS 546 */ 547 static QDF_STATUS 548 mlme_fill_freq_in_wide_scan_start_request(struct wlan_objmgr_vdev *vdev, 549 struct scan_start_request *req) 550 { 551 struct mlme_legacy_priv *mlme_priv; 552 enum phy_ch_width associated_ch_width; 553 QDF_STATUS status; 554 555 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 556 if (!mlme_priv) 557 return QDF_STATUS_E_FAILURE; 558 559 req->scan_req.chan_list.num_chan = 0; 560 561 if (wlan_vdev_mlme_is_mlo_vdev(vdev)) { 562 status = mlme_fill_freq_in_mlo_wide_band_scan_start_req(vdev, 563 req); 564 if (QDF_IS_STATUS_ERROR(status)) 565 return QDF_STATUS_E_FAILURE; 566 goto update_param; 567 } 568 569 associated_ch_width = 570 mlme_priv->connect_info.assoc_chan_info.assoc_ch_width; 571 if (associated_ch_width == CH_WIDTH_INVALID) { 572 mlme_debug("vdev %d :Invalid associated ch_width", 573 req->scan_req.vdev_id); 574 return QDF_STATUS_E_FAILURE; 575 } 576 577 status = mlme_update_freq_in_scan_start_req(vdev, req, 578 associated_ch_width, 579 INVALID_CHANNEL); 580 if (QDF_IS_STATUS_ERROR(status)) 581 return QDF_STATUS_E_FAILURE; 582 583 mlme_debug("vdev %d :trigger wide band scan, num freq %d", 584 req->scan_req.vdev_id, req->scan_req.chan_list.num_chan); 585 586 update_param: 587 req->scan_req.dwell_time_passive = 588 MLME_GET_CHAN_STATS_WIDE_BAND_PASSIVE_SCAN_TIME; 589 req->scan_req.dwell_time_passive_6g = 590 MLME_GET_CHAN_STATS_WIDE_BAND_PASSIVE_SCAN_TIME; 591 592 req->scan_req.scan_f_wide_band = true; 593 /* 594 * FW report CCA busy for each possible 20Mhz subbands of the 595 * wideband scan channel if below flag is true 596 */ 597 req->scan_req.scan_f_report_cca_busy_for_each_20mhz = true; 598 599 return QDF_STATUS_SUCCESS; 600 } 601 602 QDF_STATUS mlme_connected_chan_stats_request(struct wlan_objmgr_psoc *psoc, 603 uint8_t vdev_id) 604 { 605 struct wlan_mlme_psoc_ext_obj *mlme_obj; 606 QDF_STATUS status; 607 struct wlan_objmgr_vdev *vdev; 608 struct scan_start_request *req; 609 610 mlme_obj = mlme_get_psoc_ext_obj(psoc); 611 if (!mlme_obj) { 612 mlme_debug("vdev %d : NULL mlme psoc object", vdev_id); 613 return QDF_STATUS_E_FAILURE; 614 } 615 616 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 617 WLAN_MLME_NB_ID); 618 if (!vdev) { 619 mlme_debug("vdev %d : NULL vdev object", vdev_id); 620 return QDF_STATUS_E_FAILURE; 621 } 622 623 req = qdf_mem_malloc(sizeof(*req)); 624 if (!req) { 625 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID); 626 return QDF_STATUS_E_NOMEM; 627 } 628 629 status = wlan_scan_init_default_params(vdev, req); 630 if (QDF_IS_STATUS_ERROR(status)) 631 goto release; 632 633 req->scan_req.scan_id = wlan_scan_get_scan_id(psoc); 634 req->scan_req.scan_req_id = mlme_obj->scan_requester_id; 635 req->scan_req.vdev_id = vdev_id; 636 637 req->scan_req.scan_type = SCAN_TYPE_DEFAULT; 638 639 /* Fill channel list as per fw capability */ 640 if (wlan_psoc_nif_fw_ext2_cap_get(psoc, 641 WLAN_CCA_BUSY_INFO_FOREACH_20MHZ)) { 642 status = mlme_fill_freq_in_wide_scan_start_request(vdev, req); 643 if (QDF_IS_STATUS_ERROR(status)) 644 goto release; 645 } else { 646 status = mlme_fill_freq_in_scan_start_request(vdev, req); 647 if (QDF_IS_STATUS_ERROR(status)) 648 goto release; 649 } 650 651 /* disable adatptive dwell time */ 652 req->scan_req.adaptive_dwell_time_mode = SCAN_DWELL_MODE_STATIC; 653 /* to disable early 6Ghz scan bail out */ 654 req->scan_req.min_dwell_time_6g = 0; 655 /* passive scan for CCA measurement */ 656 req->scan_req.scan_f_passive = true; 657 /* Fw pause home channel when scan channel is same as home channel */ 658 req->scan_req.scan_f_pause_home_channel = true; 659 660 status = wlan_scan_start(req); 661 if (QDF_IS_STATUS_ERROR(status)) { 662 mlme_debug("vdev %d :Failed to send scan req, status %d", 663 vdev_id, status); 664 goto release; 665 } 666 667 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID); 668 return status; 669 release: 670 qdf_mem_free(req); 671 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID); 672 return status; 673 } 674 675 uint32_t mlme_get_vdev_he_ops(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 676 { 677 struct vdev_mlme_obj *mlme_obj; 678 uint32_t he_ops = 0; 679 struct wlan_objmgr_vdev *vdev; 680 681 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 682 WLAN_MLME_NB_ID); 683 if (!vdev) 684 return he_ops; 685 686 mlme_obj = wlan_vdev_mlme_get_cmpt_obj(vdev); 687 if (!mlme_obj) { 688 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID); 689 mlme_legacy_err("Failed to get vdev MLME Obj"); 690 return he_ops; 691 } 692 693 he_ops = mlme_obj->proto.he_ops_info.he_ops; 694 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID); 695 696 return he_ops; 697 } 698 699 struct wlan_mlme_nss_chains *mlme_get_ini_vdev_config( 700 struct wlan_objmgr_vdev *vdev) 701 { 702 struct mlme_legacy_priv *mlme_priv; 703 704 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 705 if (!mlme_priv) { 706 mlme_legacy_err("vdev legacy private object is NULL"); 707 return NULL; 708 } 709 710 return &mlme_priv->ini_cfg; 711 } 712 713 uint8_t *mlme_get_dynamic_oce_flags(struct wlan_objmgr_vdev *vdev) 714 { 715 struct mlme_legacy_priv *mlme_priv; 716 717 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 718 if (!mlme_priv) { 719 mlme_legacy_err("vdev legacy private object is NULL"); 720 return NULL; 721 } 722 723 return &mlme_priv->sta_dynamic_oce_value; 724 } 725 726 QDF_STATUS mlme_init_rate_config(struct vdev_mlme_obj *vdev_mlme) 727 { 728 struct mlme_legacy_priv *mlme_priv; 729 730 mlme_priv = vdev_mlme->ext_vdev_ptr; 731 if (!mlme_priv) { 732 mlme_legacy_err("vdev legacy private object is NULL"); 733 return QDF_STATUS_E_FAILURE; 734 } 735 736 mlme_priv->opr_rate_set.max_len = 737 QDF_MIN(CFG_OPERATIONAL_RATE_SET_LEN, CFG_STR_DATA_LEN); 738 mlme_priv->opr_rate_set.len = 0; 739 mlme_priv->ext_opr_rate_set.max_len = 740 QDF_MIN(CFG_EXTENDED_OPERATIONAL_RATE_SET_LEN, 741 CFG_STR_DATA_LEN); 742 mlme_priv->ext_opr_rate_set.len = 0; 743 mlme_priv->mcs_rate_set.max_len = 744 QDF_MIN(CFG_SUPPORTED_MCS_SET_LEN, CFG_STR_DATA_LEN); 745 mlme_priv->mcs_rate_set.len = 0; 746 747 return QDF_STATUS_SUCCESS; 748 } 749 750 QDF_STATUS mlme_init_connect_chan_info_config(struct vdev_mlme_obj *vdev_mlme) 751 { 752 struct mlme_legacy_priv *mlme_priv; 753 754 mlme_priv = vdev_mlme->ext_vdev_ptr; 755 if (!mlme_priv) { 756 mlme_legacy_err("vdev legacy private object is NULL"); 757 return QDF_STATUS_E_FAILURE; 758 } 759 760 mlme_priv->connect_info.assoc_chan_info.assoc_ch_width = 761 CH_WIDTH_INVALID; 762 mlme_priv->connect_info.assoc_chan_info.sec_2g_freq = 0; 763 764 return QDF_STATUS_SUCCESS; 765 } 766 767 QDF_STATUS mlme_get_peer_mic_len(struct wlan_objmgr_psoc *psoc, uint8_t pdev_id, 768 uint8_t *peer_mac, uint8_t *mic_len, 769 uint8_t *mic_hdr_len) 770 { 771 struct wlan_objmgr_peer *peer; 772 int32_t key_cipher; 773 774 if (!psoc || !mic_len || !mic_hdr_len || !peer_mac) { 775 mlme_legacy_debug("psoc/mic_len/mic_hdr_len/peer_mac null"); 776 return QDF_STATUS_E_NULL_VALUE; 777 } 778 779 peer = wlan_objmgr_get_peer(psoc, pdev_id, 780 peer_mac, WLAN_LEGACY_MAC_ID); 781 if (!peer) { 782 mlme_legacy_debug("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found", 783 QDF_MAC_ADDR_REF(peer_mac)); 784 return QDF_STATUS_E_INVAL; 785 } 786 787 key_cipher = 788 wlan_crypto_get_peer_param(peer, 789 WLAN_CRYPTO_PARAM_UCAST_CIPHER); 790 791 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 792 793 if (key_cipher < 0) { 794 mlme_legacy_err("Invalid mgmt cipher"); 795 return QDF_STATUS_E_INVAL; 796 } 797 798 if (key_cipher & (1 << WLAN_CRYPTO_CIPHER_AES_GCM) || 799 key_cipher & (1 << WLAN_CRYPTO_CIPHER_AES_GCM_256)) { 800 *mic_hdr_len = WLAN_IEEE80211_GCMP_HEADERLEN; 801 *mic_len = WLAN_IEEE80211_GCMP_MICLEN; 802 } else { 803 *mic_hdr_len = IEEE80211_CCMP_HEADERLEN; 804 *mic_len = IEEE80211_CCMP_MICLEN; 805 } 806 mlme_legacy_debug("peer "QDF_MAC_ADDR_FMT" hdr_len %d mic_len %d key_cipher 0x%x", 807 QDF_MAC_ADDR_REF(peer_mac), 808 *mic_hdr_len, *mic_len, key_cipher); 809 810 return QDF_STATUS_SUCCESS; 811 } 812 813 void 814 wlan_acquire_peer_key_wakelock(struct wlan_objmgr_pdev *pdev, uint8_t *mac_addr) 815 { 816 uint8_t pdev_id; 817 struct wlan_objmgr_peer *peer; 818 struct peer_mlme_priv_obj *peer_priv; 819 struct wlan_objmgr_psoc *psoc; 820 821 psoc = wlan_pdev_get_psoc(pdev); 822 if (!psoc) 823 return; 824 825 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 826 peer = wlan_objmgr_get_peer(psoc, pdev_id, mac_addr, 827 WLAN_LEGACY_MAC_ID); 828 if (!peer) 829 return; 830 831 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 832 WLAN_UMAC_COMP_MLME); 833 if (!peer_priv) { 834 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 835 return; 836 } 837 838 if (peer_priv->is_key_wakelock_set) { 839 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 840 return; 841 } 842 843 mlme_debug(QDF_MAC_ADDR_FMT ": Acquire set key wake lock for %d ms", 844 QDF_MAC_ADDR_REF(mac_addr), 845 MLME_PEER_SET_KEY_WAKELOCK_TIMEOUT); 846 qdf_wake_lock_timeout_acquire(&peer_priv->peer_set_key_wakelock, 847 MLME_PEER_SET_KEY_WAKELOCK_TIMEOUT); 848 qdf_runtime_pm_prevent_suspend( 849 &peer_priv->peer_set_key_runtime_wakelock); 850 peer_priv->is_key_wakelock_set = true; 851 852 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 853 } 854 855 void 856 wlan_release_peer_key_wakelock(struct wlan_objmgr_pdev *pdev, uint8_t *mac_addr) 857 { 858 uint8_t pdev_id; 859 struct wlan_objmgr_peer *peer; 860 struct peer_mlme_priv_obj *peer_priv; 861 struct wlan_objmgr_psoc *psoc; 862 863 psoc = wlan_pdev_get_psoc(pdev); 864 if (!psoc) 865 return; 866 867 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 868 peer = wlan_objmgr_get_peer(psoc, pdev_id, mac_addr, 869 WLAN_LEGACY_MAC_ID); 870 if (!peer) 871 return; 872 873 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 874 WLAN_UMAC_COMP_MLME); 875 if (!peer_priv) { 876 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 877 return; 878 } 879 880 if (!peer_priv->is_key_wakelock_set) { 881 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 882 return; 883 } 884 885 peer_priv->is_key_wakelock_set = false; 886 mlme_debug(QDF_MAC_ADDR_FMT ": Release set key wake lock", 887 QDF_MAC_ADDR_REF(mac_addr)); 888 qdf_wake_lock_release(&peer_priv->peer_set_key_wakelock, 889 WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP); 890 qdf_runtime_pm_allow_suspend( 891 &peer_priv->peer_set_key_runtime_wakelock); 892 893 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 894 } 895 896 QDF_STATUS 897 mlme_peer_object_created_notification(struct wlan_objmgr_peer *peer, 898 void *arg) 899 { 900 struct peer_mlme_priv_obj *peer_priv; 901 QDF_STATUS status; 902 903 if (!peer) { 904 mlme_legacy_err(" peer is NULL"); 905 return QDF_STATUS_E_FAILURE; 906 } 907 908 peer_priv = qdf_mem_malloc(sizeof(*peer_priv)); 909 if (!peer_priv) 910 return QDF_STATUS_E_NOMEM; 911 912 status = wlan_objmgr_peer_component_obj_attach(peer, 913 WLAN_UMAC_COMP_MLME, 914 (void *)peer_priv, 915 QDF_STATUS_SUCCESS); 916 917 if (QDF_IS_STATUS_ERROR(status)) { 918 mlme_legacy_err("unable to attach peer_priv obj to peer obj"); 919 qdf_mem_free(peer_priv); 920 return status; 921 } 922 923 qdf_wake_lock_create(&peer_priv->peer_set_key_wakelock, "peer_set_key"); 924 qdf_runtime_lock_init(&peer_priv->peer_set_key_runtime_wakelock); 925 peer_priv->is_key_wakelock_set = false; 926 peer_priv->peer_ind_bw = CH_WIDTH_INVALID; 927 928 return status; 929 } 930 931 QDF_STATUS 932 mlme_peer_object_destroyed_notification(struct wlan_objmgr_peer *peer, 933 void *arg) 934 { 935 struct peer_mlme_priv_obj *peer_priv; 936 QDF_STATUS status; 937 938 if (!peer) { 939 mlme_legacy_err(" peer is NULL"); 940 return QDF_STATUS_E_FAILURE; 941 } 942 943 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 944 WLAN_UMAC_COMP_MLME); 945 if (!peer_priv) { 946 mlme_legacy_err(" peer MLME component object is NULL"); 947 return QDF_STATUS_E_FAILURE; 948 } 949 950 peer_priv->is_key_wakelock_set = false; 951 qdf_runtime_lock_deinit(&peer_priv->peer_set_key_runtime_wakelock); 952 qdf_wake_lock_destroy(&peer_priv->peer_set_key_wakelock); 953 954 status = wlan_objmgr_peer_component_obj_detach(peer, 955 WLAN_UMAC_COMP_MLME, 956 peer_priv); 957 958 if (QDF_IS_STATUS_ERROR(status)) 959 mlme_legacy_err("unable to detach peer_priv obj to peer obj"); 960 961 mlme_free_peer_assoc_rsp_ie(peer_priv); 962 qdf_mem_free(peer_priv); 963 964 return status; 965 } 966 967 static void mlme_init_chainmask_cfg(struct wlan_objmgr_psoc *psoc, 968 struct wlan_mlme_chainmask *chainmask_info) 969 { 970 chainmask_info->txchainmask1x1 = 971 cfg_get(psoc, CFG_VHT_ENABLE_1x1_TX_CHAINMASK); 972 973 chainmask_info->rxchainmask1x1 = 974 cfg_get(psoc, CFG_VHT_ENABLE_1x1_RX_CHAINMASK); 975 976 chainmask_info->tx_chain_mask_cck = 977 cfg_get(psoc, CFG_TX_CHAIN_MASK_CCK); 978 979 chainmask_info->tx_chain_mask_1ss = 980 cfg_get(psoc, CFG_TX_CHAIN_MASK_1SS); 981 982 chainmask_info->num_11b_tx_chains = 983 cfg_get(psoc, CFG_11B_NUM_TX_CHAIN); 984 985 chainmask_info->num_11ag_tx_chains = 986 cfg_get(psoc, CFG_11AG_NUM_TX_CHAIN); 987 988 chainmask_info->tx_chain_mask_2g = 989 cfg_get(psoc, CFG_TX_CHAIN_MASK_2G); 990 991 chainmask_info->rx_chain_mask_2g = 992 cfg_get(psoc, CFG_RX_CHAIN_MASK_2G); 993 994 chainmask_info->tx_chain_mask_5g = 995 cfg_get(psoc, CFG_TX_CHAIN_MASK_5G); 996 997 chainmask_info->rx_chain_mask_5g = 998 cfg_get(psoc, CFG_RX_CHAIN_MASK_5G); 999 1000 chainmask_info->enable_bt_chain_separation = 1001 cfg_get(psoc, CFG_ENABLE_BT_CHAIN_SEPARATION); 1002 } 1003 1004 static void mlme_init_ratemask_cfg(struct wlan_objmgr_psoc *psoc, 1005 struct wlan_mlme_ratemask *ratemask_cfg) 1006 { 1007 uint32_t masks[CFG_MLME_RATE_MASK_LEN] = { 0 }; 1008 qdf_size_t len = 0; 1009 QDF_STATUS status; 1010 1011 ratemask_cfg->type = cfg_get(psoc, CFG_RATEMASK_TYPE); 1012 if ((ratemask_cfg->type <= WLAN_MLME_RATEMASK_TYPE_NO_MASK) || 1013 (ratemask_cfg->type >= WLAN_MLME_RATEMASK_TYPE_MAX)) { 1014 mlme_legacy_debug("Ratemask disabled"); 1015 return; 1016 } 1017 1018 status = qdf_uint32_array_parse(cfg_get(psoc, CFG_RATEMASK_SET), 1019 masks, 1020 CFG_MLME_RATE_MASK_LEN, 1021 &len); 1022 1023 if (status != QDF_STATUS_SUCCESS || len != CFG_MLME_RATE_MASK_LEN) { 1024 /* Do not enable ratemask if config is invalid */ 1025 ratemask_cfg->type = WLAN_MLME_RATEMASK_TYPE_NO_MASK; 1026 mlme_legacy_err("Failed to parse ratemask"); 1027 return; 1028 } 1029 1030 ratemask_cfg->lower32 = masks[0]; 1031 ratemask_cfg->higher32 = masks[1]; 1032 ratemask_cfg->lower32_2 = masks[2]; 1033 ratemask_cfg->higher32_2 = masks[3]; 1034 mlme_legacy_debug("Ratemask type: %d, masks:0x%x, 0x%x, 0x%x, 0x%x", 1035 ratemask_cfg->type, ratemask_cfg->lower32, 1036 ratemask_cfg->higher32, ratemask_cfg->lower32_2, 1037 ratemask_cfg->higher32_2); 1038 } 1039 1040 static void mlme_init_pmf_cfg(struct wlan_objmgr_psoc *psoc, 1041 struct wlan_mlme_generic *gen) 1042 { 1043 gen->pmf_sa_query_max_retries = 1044 cfg_get(psoc, CFG_PMF_SA_QUERY_MAX_RETRIES); 1045 gen->pmf_sa_query_retry_interval = 1046 cfg_get(psoc, CFG_PMF_SA_QUERY_RETRY_INTERVAL); 1047 } 1048 1049 #ifdef WLAN_FEATURE_LPSS 1050 static inline void 1051 mlme_init_lpass_support_cfg(struct wlan_objmgr_psoc *psoc, 1052 struct wlan_mlme_generic *gen) 1053 { 1054 gen->lpass_support = cfg_get(psoc, CFG_ENABLE_LPASS_SUPPORT); 1055 } 1056 #else 1057 static inline void 1058 mlme_init_lpass_support_cfg(struct wlan_objmgr_psoc *psoc, 1059 struct wlan_mlme_generic *gen) 1060 { 1061 gen->lpass_support = cfg_default(CFG_ENABLE_LPASS_SUPPORT); 1062 } 1063 #endif 1064 1065 #ifdef FEATURE_WDS 1066 /** 1067 * mlme_init_wds_config_cfg() - initialize wds_mode flag 1068 * @psoc: Pointer to PSOC 1069 * @gen: pointer to generic CFG items 1070 * 1071 * Return: None 1072 */ 1073 static void mlme_init_wds_config_cfg(struct wlan_objmgr_psoc *psoc, 1074 struct wlan_mlme_generic *gen) 1075 { 1076 gen->wds_mode = cfg_get(psoc, CFG_WDS_MODE); 1077 } 1078 #else 1079 static void mlme_init_wds_config_cfg(struct wlan_objmgr_psoc *psoc, 1080 struct wlan_mlme_generic *gen) 1081 { 1082 } 1083 #endif 1084 1085 #ifdef CONFIG_BAND_6GHZ 1086 /** 1087 * mlme_init_disable_vlp_sta_conn_to_sp_ap() - initialize disable vlp STA 1088 * connection to sp AP flag 1089 * @psoc: Pointer to PSOC 1090 * @gen: pointer to generic CFG items 1091 * 1092 * Return: None 1093 */ 1094 static void mlme_init_disable_vlp_sta_conn_to_sp_ap( 1095 struct wlan_objmgr_psoc *psoc, 1096 struct wlan_mlme_generic *gen) 1097 { 1098 gen->disable_vlp_sta_conn_to_sp_ap = 1099 cfg_default(CFG_DISABLE_VLP_STA_CONN_TO_SP_AP); 1100 } 1101 #else 1102 static void mlme_init_disable_vlp_sta_conn_to_sp_ap( 1103 struct wlan_objmgr_psoc *psoc, 1104 struct wlan_mlme_generic *gen) 1105 { 1106 } 1107 #endif 1108 1109 #ifdef CONFIG_BAND_6GHZ 1110 /** 1111 * mlme_init_standard_6ghz_conn_policy() - initialize standard 6GHz 1112 * policy connection flag 1113 * @psoc: Pointer to PSOC 1114 * @gen: pointer to generic CFG items 1115 * 1116 * Return: None 1117 */ 1118 static void mlme_init_standard_6ghz_conn_policy(struct wlan_objmgr_psoc *psoc, 1119 struct wlan_mlme_generic *gen) 1120 { 1121 gen->std_6ghz_conn_policy = 1122 cfg_get(psoc, CFG_6GHZ_STANDARD_CONNECTION_POLICY); 1123 } 1124 #else 1125 static void mlme_init_standard_6ghz_conn_policy(struct wlan_objmgr_psoc *psoc, 1126 struct wlan_mlme_generic *gen) 1127 { 1128 } 1129 #endif 1130 1131 /** 1132 * mlme_init_mgmt_hw_tx_retry_count_cfg() - initialize mgmt hw tx retry count 1133 * @psoc: Pointer to PSOC 1134 * @gen: pointer to generic CFG items 1135 * 1136 * Return: None 1137 */ 1138 static void mlme_init_mgmt_hw_tx_retry_count_cfg( 1139 struct wlan_objmgr_psoc *psoc, 1140 struct wlan_mlme_generic *gen) 1141 { 1142 uint32_t i; 1143 qdf_size_t out_size = 0; 1144 uint8_t count_array[MGMT_FRM_HW_TX_RETRY_COUNT_STR_LEN]; 1145 1146 qdf_uint8_array_parse(cfg_get(psoc, CFG_MGMT_FRAME_HW_TX_RETRY_COUNT), 1147 count_array, 1148 MGMT_FRM_HW_TX_RETRY_COUNT_STR_LEN, 1149 &out_size); 1150 1151 for (i = 0; i + 1 < out_size; i += 2) { 1152 if (count_array[i] >= CFG_FRAME_TYPE_MAX) { 1153 mlme_legacy_debug("invalid frm type %d", 1154 count_array[i]); 1155 continue; 1156 } 1157 if (count_array[i + 1] >= MAX_MGMT_HW_TX_RETRY_COUNT) { 1158 mlme_legacy_debug("mgmt hw tx retry count %d for frm %d, limit to %d", 1159 count_array[i + 1], 1160 count_array[i], 1161 MAX_MGMT_HW_TX_RETRY_COUNT); 1162 gen->mgmt_hw_tx_retry_count[count_array[i]] = 1163 MAX_MGMT_HW_TX_RETRY_COUNT; 1164 } else { 1165 mlme_legacy_debug("mgmt hw tx retry count %d for frm %d", 1166 count_array[i + 1], 1167 count_array[i]); 1168 gen->mgmt_hw_tx_retry_count[count_array[i]] = 1169 count_array[i + 1]; 1170 } 1171 } 1172 } 1173 1174 #ifdef WLAN_FEATURE_11BE_MLO 1175 /** 1176 * mlme_init_emlsr_mode() - initialize emlsr mode enable flag 1177 * @psoc: Pointer to PSOC 1178 * @gen: pointer to generic CFG items 1179 * 1180 * Return: None 1181 */ 1182 static void mlme_init_emlsr_mode(struct wlan_objmgr_psoc *psoc, 1183 struct wlan_mlme_generic *gen) 1184 { 1185 gen->enable_emlsr_mode = cfg_default(CFG_EMLSR_MODE_ENABLE); 1186 } 1187 1188 /** 1189 * mlme_init_tl2m_negotiation_support() - initialize t2lm support 1190 * @psoc: Pointer to PSOC 1191 * @gen: pointer to generic CFG items 1192 * 1193 * Return: None 1194 */ 1195 static void mlme_init_tl2m_negotiation_support(struct wlan_objmgr_psoc *psoc, 1196 struct wlan_mlme_generic *gen) 1197 { 1198 gen->t2lm_negotiation_support = cfg_default(CFG_T2LM_NEGOTIATION_SUPPORT); 1199 } 1200 #else 1201 static void mlme_init_emlsr_mode(struct wlan_objmgr_psoc *psoc, 1202 struct wlan_mlme_generic *gen) 1203 { 1204 } 1205 1206 static void mlme_init_tl2m_negotiation_support(struct wlan_objmgr_psoc *psoc, 1207 struct wlan_mlme_generic *gen) 1208 { 1209 } 1210 #endif 1211 1212 #if defined(WLAN_FEATURE_SR) 1213 /** 1214 * mlme_init_sr_ini_cfg() - initialize SR(Spatial Reuse) ini 1215 * @psoc: Pointer to PSOC 1216 * @gen: pointer to generic CFG items 1217 * 1218 * Return: None 1219 */ 1220 static void mlme_init_sr_ini_cfg(struct wlan_objmgr_psoc *psoc, 1221 struct wlan_mlme_generic *gen) 1222 { 1223 gen->sr_enable_modes = cfg_get(psoc, CFG_SR_ENABLE_MODES); 1224 } 1225 #else 1226 static void mlme_init_sr_ini_cfg(struct wlan_objmgr_psoc *psoc, 1227 struct wlan_mlme_generic *gen) 1228 {} 1229 #endif 1230 1231 static void mlme_init_generic_cfg(struct wlan_objmgr_psoc *psoc, 1232 struct wlan_mlme_generic *gen) 1233 { 1234 gen->rtt3_enabled = cfg_default(CFG_RTT3_ENABLE); 1235 gen->rtt_mac_randomization = 1236 cfg_get(psoc, CFG_ENABLE_RTT_MAC_RANDOMIZATION); 1237 gen->band_capability = 1238 cfg_get(psoc, CFG_BAND_CAPABILITY); 1239 if (!gen->band_capability) 1240 gen->band_capability = REG_BAND_MASK_ALL; 1241 gen->band = gen->band_capability; 1242 gen->select_5ghz_margin = 1243 cfg_get(psoc, CFG_SELECT_5GHZ_MARGIN); 1244 gen->sub_20_chan_width = 1245 cfg_get(psoc, CFG_SUB_20_CHANNEL_WIDTH); 1246 gen->ito_repeat_count = 1247 cfg_get(psoc, CFG_ITO_REPEAT_COUNT); 1248 gen->dropped_pkt_disconnect_thresh = 1249 cfg_get(psoc, CFG_DROPPED_PKT_DISCONNECT_THRESHOLD); 1250 gen->prevent_link_down = 1251 cfg_get(psoc, CFG_PREVENT_LINK_DOWN); 1252 gen->memory_deep_sleep = 1253 cfg_get(psoc, CFG_ENABLE_MEM_DEEP_SLEEP); 1254 gen->cck_tx_fir_override = 1255 cfg_get(psoc, CFG_ENABLE_CCK_TX_FIR_OVERRIDE); 1256 gen->crash_inject = 1257 cfg_get(psoc, CFG_ENABLE_CRASH_INJECT); 1258 gen->self_recovery = 1259 cfg_get(psoc, CFG_ENABLE_SELF_RECOVERY); 1260 gen->sap_dot11mc = 1261 cfg_get(psoc, CFG_SAP_DOT11MC); 1262 gen->fatal_event_trigger = 1263 cfg_get(psoc, CFG_ENABLE_FATAL_EVENT_TRIGGER); 1264 gen->optimize_ca_event = 1265 cfg_get(psoc, CFG_OPTIMIZE_CA_EVENT); 1266 gen->fw_timeout_crash = 1267 cfg_get(psoc, CFG_CRASH_FW_TIMEOUT); 1268 gen->debug_packet_log = cfg_get(psoc, CFG_ENABLE_DEBUG_PACKET_LOG); 1269 gen->enable_deauth_to_disassoc_map = 1270 cfg_get(psoc, CFG_ENABLE_DEAUTH_TO_DISASSOC_MAP); 1271 gen->wls_6ghz_capable = cfg_get(psoc, CFG_WLS_6GHZ_CAPABLE); 1272 mlme_init_pmf_cfg(psoc, gen); 1273 mlme_init_lpass_support_cfg(psoc, gen); 1274 gen->enabled_rf_test_mode = cfg_default(CFG_RF_TEST_MODE_SUPP_ENABLED); 1275 gen->enabled_11h = cfg_get(psoc, CFG_11H_SUPPORT_ENABLED); 1276 gen->enabled_11d = cfg_get(psoc, CFG_11D_SUPPORT_ENABLED); 1277 gen->enable_beacon_reception_stats = 1278 cfg_get(psoc, CFG_ENABLE_BEACON_RECEPTION_STATS); 1279 gen->disable_4way_hs_offload = 1280 cfg_get(psoc, CFG_DISABLE_4WAY_HS_OFFLOAD); 1281 gen->mgmt_retry_max = cfg_get(psoc, CFG_MGMT_RETRY_MAX); 1282 gen->bmiss_skip_full_scan = cfg_get(psoc, CFG_BMISS_SKIP_FULL_SCAN); 1283 gen->enable_ring_buffer = cfg_get(psoc, CFG_ENABLE_RING_BUFFER); 1284 gen->enable_peer_unmap_conf_support = 1285 cfg_get(psoc, CFG_DP_ENABLE_PEER_UMAP_CONF_SUPPORT); 1286 gen->dfs_chan_ageout_time = 1287 cfg_get(psoc, CFG_DFS_CHAN_AGEOUT_TIME); 1288 gen->sae_connect_retries = 1289 cfg_get(psoc, CFG_SAE_CONNECION_RETRIES); 1290 gen->monitor_mode_concurrency = 1291 cfg_get(psoc, CFG_MONITOR_MODE_CONCURRENCY); 1292 gen->tx_retry_multiplier = cfg_get(psoc, CFG_TX_RETRY_MULTIPLIER); 1293 gen->enable_he_mcs0_for_6ghz_mgmt = 1294 cfg_get(psoc, CFG_ENABLE_HE_MCS0_MGMT_6GHZ); 1295 mlme_init_sr_ini_cfg(psoc, gen); 1296 mlme_init_wds_config_cfg(psoc, gen); 1297 mlme_init_mgmt_hw_tx_retry_count_cfg(psoc, gen); 1298 mlme_init_emlsr_mode(psoc, gen); 1299 mlme_init_tl2m_negotiation_support(psoc, gen); 1300 mlme_init_standard_6ghz_conn_policy(psoc, gen); 1301 mlme_init_disable_vlp_sta_conn_to_sp_ap(psoc, gen); 1302 } 1303 1304 static void mlme_init_edca_ani_cfg(struct wlan_objmgr_psoc *psoc, 1305 struct wlan_mlme_edca_params *edca_params) 1306 { 1307 /* initialize the max allowed array length for read/write */ 1308 edca_params->ani_acbe_l.max_len = CFG_EDCA_DATA_LEN; 1309 edca_params->ani_acbk_l.max_len = CFG_EDCA_DATA_LEN; 1310 edca_params->ani_acvi_l.max_len = CFG_EDCA_DATA_LEN; 1311 edca_params->ani_acvo_l.max_len = CFG_EDCA_DATA_LEN; 1312 1313 edca_params->ani_acbe_b.max_len = CFG_EDCA_DATA_LEN; 1314 edca_params->ani_acbk_b.max_len = CFG_EDCA_DATA_LEN; 1315 edca_params->ani_acvi_b.max_len = CFG_EDCA_DATA_LEN; 1316 edca_params->ani_acvo_b.max_len = CFG_EDCA_DATA_LEN; 1317 1318 /* parse the ETSI edca parameters from cfg string for BK,BE,VI,VO ac */ 1319 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACBK_LOCAL), 1320 edca_params->ani_acbk_l.data, 1321 CFG_EDCA_DATA_LEN, 1322 &edca_params->ani_acbk_l.len); 1323 1324 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACBE_LOCAL), 1325 edca_params->ani_acbe_l.data, 1326 CFG_EDCA_DATA_LEN, 1327 &edca_params->ani_acbe_l.len); 1328 1329 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACVI_LOCAL), 1330 edca_params->ani_acvi_l.data, 1331 CFG_EDCA_DATA_LEN, 1332 &edca_params->ani_acvi_l.len); 1333 1334 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACVO_LOCAL), 1335 edca_params->ani_acvo_l.data, 1336 CFG_EDCA_DATA_LEN, 1337 &edca_params->ani_acvo_l.len); 1338 1339 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACBK), 1340 edca_params->ani_acbk_b.data, 1341 CFG_EDCA_DATA_LEN, 1342 &edca_params->ani_acbk_b.len); 1343 1344 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACBE), 1345 edca_params->ani_acbe_b.data, 1346 CFG_EDCA_DATA_LEN, 1347 &edca_params->ani_acbe_b.len); 1348 1349 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACVI), 1350 edca_params->ani_acvi_b.data, 1351 CFG_EDCA_DATA_LEN, 1352 &edca_params->ani_acvi_b.len); 1353 1354 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ANI_ACVO), 1355 edca_params->ani_acvo_b.data, 1356 CFG_EDCA_DATA_LEN, 1357 &edca_params->ani_acvo_b.len); 1358 } 1359 1360 static void mlme_init_edca_wme_cfg(struct wlan_objmgr_psoc *psoc, 1361 struct wlan_mlme_edca_params *edca_params) 1362 { 1363 /* initialize the max allowed array length for read/write */ 1364 edca_params->wme_acbk_l.max_len = CFG_EDCA_DATA_LEN; 1365 edca_params->wme_acbe_l.max_len = CFG_EDCA_DATA_LEN; 1366 edca_params->wme_acvi_l.max_len = CFG_EDCA_DATA_LEN; 1367 edca_params->wme_acvo_l.max_len = CFG_EDCA_DATA_LEN; 1368 1369 edca_params->wme_acbk_b.max_len = CFG_EDCA_DATA_LEN; 1370 edca_params->wme_acbe_b.max_len = CFG_EDCA_DATA_LEN; 1371 edca_params->wme_acvi_b.max_len = CFG_EDCA_DATA_LEN; 1372 edca_params->wme_acvo_b.max_len = CFG_EDCA_DATA_LEN; 1373 1374 /* parse the WME edca parameters from cfg string for BK,BE,VI,VO ac */ 1375 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACBK_LOCAL), 1376 edca_params->wme_acbk_l.data, 1377 CFG_EDCA_DATA_LEN, 1378 &edca_params->wme_acbk_l.len); 1379 1380 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACBE_LOCAL), 1381 edca_params->wme_acbe_l.data, 1382 CFG_EDCA_DATA_LEN, 1383 &edca_params->wme_acbe_l.len); 1384 1385 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACVI_LOCAL), 1386 edca_params->wme_acvi_l.data, 1387 CFG_EDCA_DATA_LEN, 1388 &edca_params->wme_acvi_l.len); 1389 1390 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACVO_LOCAL), 1391 edca_params->wme_acvo_l.data, 1392 CFG_EDCA_DATA_LEN, 1393 &edca_params->wme_acvo_l.len); 1394 1395 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACBK), 1396 edca_params->wme_acbk_b.data, 1397 CFG_EDCA_DATA_LEN, 1398 &edca_params->wme_acbk_b.len); 1399 1400 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACBE), 1401 edca_params->wme_acbe_b.data, 1402 CFG_EDCA_DATA_LEN, 1403 &edca_params->wme_acbe_b.len); 1404 1405 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACVI), 1406 edca_params->wme_acvi_b.data, 1407 CFG_EDCA_DATA_LEN, 1408 &edca_params->wme_acvi_b.len); 1409 1410 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_WME_ACVO), 1411 edca_params->wme_acvo_b.data, 1412 CFG_EDCA_DATA_LEN, 1413 &edca_params->wme_acvo_b.len); 1414 } 1415 1416 static void mlme_init_edca_etsi_cfg(struct wlan_objmgr_psoc *psoc, 1417 struct wlan_mlme_edca_params *edca_params) 1418 { 1419 /* initialize the max allowed array length for read/write */ 1420 edca_params->etsi_acbe_l.max_len = CFG_EDCA_DATA_LEN; 1421 edca_params->etsi_acbk_l.max_len = CFG_EDCA_DATA_LEN; 1422 edca_params->etsi_acvi_l.max_len = CFG_EDCA_DATA_LEN; 1423 edca_params->etsi_acvo_l.max_len = CFG_EDCA_DATA_LEN; 1424 1425 edca_params->etsi_acbe_b.max_len = CFG_EDCA_DATA_LEN; 1426 edca_params->etsi_acbk_b.max_len = CFG_EDCA_DATA_LEN; 1427 edca_params->etsi_acvi_b.max_len = CFG_EDCA_DATA_LEN; 1428 edca_params->etsi_acvo_b.max_len = CFG_EDCA_DATA_LEN; 1429 1430 /* parse the ETSI edca parameters from cfg string for BK,BE,VI,VO ac */ 1431 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACBK_LOCAL), 1432 edca_params->etsi_acbk_l.data, 1433 CFG_EDCA_DATA_LEN, 1434 &edca_params->etsi_acbk_l.len); 1435 1436 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACBE_LOCAL), 1437 edca_params->etsi_acbe_l.data, 1438 CFG_EDCA_DATA_LEN, 1439 &edca_params->etsi_acbe_l.len); 1440 1441 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACVI_LOCAL), 1442 edca_params->etsi_acvi_l.data, 1443 CFG_EDCA_DATA_LEN, 1444 &edca_params->etsi_acvi_l.len); 1445 1446 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACVO_LOCAL), 1447 edca_params->etsi_acvo_l.data, 1448 CFG_EDCA_DATA_LEN, 1449 &edca_params->etsi_acvo_l.len); 1450 1451 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACBK), 1452 edca_params->etsi_acbk_b.data, 1453 CFG_EDCA_DATA_LEN, 1454 &edca_params->etsi_acbk_b.len); 1455 1456 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACBE), 1457 edca_params->etsi_acbe_b.data, 1458 CFG_EDCA_DATA_LEN, 1459 &edca_params->etsi_acbe_b.len); 1460 1461 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACVI), 1462 edca_params->etsi_acvi_b.data, 1463 CFG_EDCA_DATA_LEN, 1464 &edca_params->etsi_acvi_b.len); 1465 1466 qdf_uint8_array_parse(cfg_get(psoc, CFG_EDCA_ETSI_ACVO), 1467 edca_params->etsi_acvo_b.data, 1468 CFG_EDCA_DATA_LEN, 1469 &edca_params->etsi_acvo_b.len); 1470 } 1471 1472 static void 1473 mlme_init_qos_edca_params(struct wlan_objmgr_psoc *psoc, 1474 struct wlan_mlme_edca_params *edca_params) 1475 { 1476 edca_params->enable_edca_params = 1477 cfg_get(psoc, CFG_EDCA_ENABLE_PARAM); 1478 1479 edca_params->enable_wmm_txop = 1480 cfg_get(psoc, CFG_ENABLE_WMM_TXOP); 1481 edca_params->edca_ac_vo.vo_cwmin = 1482 cfg_get(psoc, CFG_EDCA_VO_CWMIN); 1483 edca_params->edca_ac_vo.vo_cwmax = 1484 cfg_get(psoc, CFG_EDCA_VO_CWMAX); 1485 edca_params->edca_ac_vo.vo_aifs = 1486 cfg_get(psoc, CFG_EDCA_VO_AIFS); 1487 1488 edca_params->edca_ac_vi.vi_cwmin = 1489 cfg_get(psoc, CFG_EDCA_VI_CWMIN); 1490 edca_params->edca_ac_vi.vi_cwmax = 1491 cfg_get(psoc, CFG_EDCA_VI_CWMAX); 1492 edca_params->edca_ac_vi.vi_aifs = 1493 cfg_get(psoc, CFG_EDCA_VI_AIFS); 1494 1495 edca_params->edca_ac_bk.bk_cwmin = 1496 cfg_get(psoc, CFG_EDCA_BK_CWMIN); 1497 edca_params->edca_ac_bk.bk_cwmax = 1498 cfg_get(psoc, CFG_EDCA_BK_CWMAX); 1499 edca_params->edca_ac_bk.bk_aifs = 1500 cfg_get(psoc, CFG_EDCA_BK_AIFS); 1501 1502 edca_params->edca_ac_be.be_cwmin = 1503 cfg_get(psoc, CFG_EDCA_BE_CWMIN); 1504 edca_params->edca_ac_be.be_cwmax = 1505 cfg_get(psoc, CFG_EDCA_BE_CWMAX); 1506 edca_params->edca_ac_be.be_aifs = 1507 cfg_get(psoc, CFG_EDCA_BE_AIFS); 1508 1509 edca_params->edca_param_type = 1510 cfg_get(psoc, CFG_EDCA_PIFS_PARAM_TYPE); 1511 } 1512 1513 static void mlme_init_edca_params(struct wlan_objmgr_psoc *psoc, 1514 struct wlan_mlme_edca_params *edca_params) 1515 { 1516 mlme_init_edca_ani_cfg(psoc, edca_params); 1517 mlme_init_edca_wme_cfg(psoc, edca_params); 1518 mlme_init_edca_etsi_cfg(psoc, edca_params); 1519 mlme_init_qos_edca_params(psoc, edca_params); 1520 } 1521 1522 static void mlme_init_timeout_cfg(struct wlan_objmgr_psoc *psoc, 1523 struct wlan_mlme_timeout *timeouts) 1524 { 1525 timeouts->join_failure_timeout = 1526 cfg_get(psoc, CFG_JOIN_FAILURE_TIMEOUT); 1527 timeouts->join_failure_timeout_ori = timeouts->join_failure_timeout; 1528 timeouts->probe_req_retry_timeout = JOIN_PROBE_REQ_TIMER_MS; 1529 timeouts->auth_failure_timeout = 1530 cfg_get(psoc, CFG_AUTH_FAILURE_TIMEOUT); 1531 timeouts->auth_rsp_timeout = 1532 cfg_get(psoc, CFG_AUTH_RSP_TIMEOUT); 1533 timeouts->assoc_failure_timeout = 1534 cfg_get(psoc, CFG_ASSOC_FAILURE_TIMEOUT); 1535 timeouts->reassoc_failure_timeout = 1536 cfg_get(psoc, CFG_REASSOC_FAILURE_TIMEOUT); 1537 timeouts->olbc_detect_timeout = 1538 cfg_get(psoc, CFG_OLBC_DETECT_TIMEOUT); 1539 timeouts->addts_rsp_timeout = 1540 cfg_get(psoc, CFG_ADDTS_RSP_TIMEOUT); 1541 timeouts->heart_beat_threshold = 1542 cfg_get(psoc, CFG_HEART_BEAT_THRESHOLD); 1543 timeouts->ap_keep_alive_timeout = 1544 cfg_get(psoc, CFG_AP_KEEP_ALIVE_TIMEOUT); 1545 timeouts->ap_link_monitor_timeout = 1546 cfg_get(psoc, CFG_AP_LINK_MONITOR_TIMEOUT); 1547 timeouts->wmi_wq_watchdog_timeout = 1548 cfg_get(psoc, CFG_WMI_WQ_WATCHDOG); 1549 timeouts->sae_auth_failure_timeout = 1550 cfg_get(psoc, CFG_SAE_AUTH_FAILURE_TIMEOUT); 1551 } 1552 1553 static void mlme_init_ht_cap_in_cfg(struct wlan_objmgr_psoc *psoc, 1554 struct wlan_mlme_ht_caps *ht_caps) 1555 { 1556 union { 1557 uint16_t val_16; 1558 struct mlme_ht_capabilities_info ht_cap_info; 1559 } u1; 1560 1561 union { 1562 uint16_t val_16; 1563 struct mlme_ht_ext_cap_info ext_cap_info; 1564 } u2; 1565 1566 union { 1567 uint8_t val_8; 1568 struct mlme_ht_info_field_1 info_field_1; 1569 } u3; 1570 1571 union { 1572 uint16_t val_16; 1573 struct mlme_ht_info_field_2 info_field_2; 1574 } u4; 1575 1576 union { 1577 uint16_t val_16; 1578 struct mlme_ht_info_field_3 info_field_3; 1579 } u5; 1580 1581 /* HT Capabilities - HT Caps Info Field */ 1582 u1.val_16 = (uint16_t)cfg_default(CFG_HT_CAP_INFO); 1583 u1.ht_cap_info.adv_coding_cap = 1584 cfg_get(psoc, CFG_RX_LDPC_ENABLE); 1585 u1.ht_cap_info.rx_stbc = cfg_get(psoc, CFG_RX_STBC_ENABLE); 1586 u1.ht_cap_info.tx_stbc = cfg_get(psoc, CFG_TX_STBC_ENABLE); 1587 u1.ht_cap_info.short_gi_20_mhz = 1588 cfg_get(psoc, CFG_SHORT_GI_20MHZ); 1589 u1.ht_cap_info.short_gi_40_mhz = 1590 cfg_get(psoc, CFG_SHORT_GI_40MHZ); 1591 ht_caps->ht_cap_info = u1.ht_cap_info; 1592 1593 /* HT Capapabilties - AMPDU Params */ 1594 ht_caps->ampdu_params.max_rx_ampdu_factor = 1595 cfg_get(psoc, CFG_MAX_RX_AMPDU_FACTOR); 1596 ht_caps->ampdu_params.mpdu_density = 1597 cfg_get(psoc, CFG_MPDU_DENSITY); 1598 ht_caps->ampdu_params.reserved = 0; 1599 1600 /* HT Capabilities - Extended Capabilities field */ 1601 u2.val_16 = (uint16_t)cfg_default(CFG_EXT_HT_CAP_INFO); 1602 ht_caps->ext_cap_info = u2.ext_cap_info; 1603 1604 /* HT Operation - Information subset 1 of 3 */ 1605 u3.val_8 = (uint8_t)cfg_default(CFG_HT_INFO_FIELD_1); 1606 ht_caps->info_field_1 = u3.info_field_1; 1607 1608 /* HT Operation - Information subset 2 of 3 */ 1609 u4.val_16 = (uint16_t)cfg_default(CFG_HT_INFO_FIELD_2); 1610 ht_caps->info_field_2 = u4.info_field_2; 1611 1612 /* HT Operation - Information subset 3 of 3 */ 1613 u5.val_16 = (uint16_t)cfg_default(CFG_HT_INFO_FIELD_3); 1614 ht_caps->info_field_3 = u5.info_field_3; 1615 1616 ht_caps->short_preamble = cfg_get(psoc, CFG_SHORT_PREAMBLE); 1617 ht_caps->enable_ampdu_ps = cfg_get(psoc, CFG_ENABLE_AMPDUPS); 1618 ht_caps->enable_smps = cfg_get(psoc, CFG_ENABLE_HT_SMPS); 1619 ht_caps->smps = cfg_get(psoc, CFG_HT_SMPS_MODE); 1620 ht_caps->max_num_amsdu = cfg_get(psoc, CFG_MAX_AMSDU_NUM); 1621 ht_caps->tx_ldpc_enable = cfg_get(psoc, CFG_TX_LDPC_ENABLE); 1622 ht_caps->short_slot_time_enabled = 1623 cfg_get(psoc, CFG_SHORT_SLOT_TIME_ENABLED); 1624 } 1625 1626 static void mlme_init_qos_cfg(struct wlan_objmgr_psoc *psoc, 1627 struct wlan_mlme_qos *qos_aggr_params) 1628 { 1629 qos_aggr_params->tx_aggregation_size = 1630 cfg_get(psoc, CFG_TX_AGGREGATION_SIZE); 1631 qos_aggr_params->tx_aggregation_size_be = 1632 cfg_get(psoc, CFG_TX_AGGREGATION_SIZEBE); 1633 qos_aggr_params->tx_aggregation_size_bk = 1634 cfg_get(psoc, CFG_TX_AGGREGATION_SIZEBK); 1635 qos_aggr_params->tx_aggregation_size_vi = 1636 cfg_get(psoc, CFG_TX_AGGREGATION_SIZEVI); 1637 qos_aggr_params->tx_aggregation_size_vo = 1638 cfg_get(psoc, CFG_TX_AGGREGATION_SIZEVO); 1639 qos_aggr_params->rx_aggregation_size = 1640 cfg_get(psoc, CFG_RX_AGGREGATION_SIZE); 1641 qos_aggr_params->tx_aggr_sw_retry_threshold_be = 1642 cfg_get(psoc, CFG_TX_AGGR_SW_RETRY_BE); 1643 qos_aggr_params->tx_aggr_sw_retry_threshold_bk = 1644 cfg_get(psoc, CFG_TX_AGGR_SW_RETRY_BK); 1645 qos_aggr_params->tx_aggr_sw_retry_threshold_vi = 1646 cfg_get(psoc, CFG_TX_AGGR_SW_RETRY_VI); 1647 qos_aggr_params->tx_aggr_sw_retry_threshold_vo = 1648 cfg_get(psoc, CFG_TX_AGGR_SW_RETRY_VO); 1649 qos_aggr_params->tx_aggr_sw_retry_threshold = 1650 cfg_get(psoc, CFG_TX_AGGR_SW_RETRY); 1651 qos_aggr_params->tx_non_aggr_sw_retry_threshold_be = 1652 cfg_get(psoc, CFG_TX_NON_AGGR_SW_RETRY_BE); 1653 qos_aggr_params->tx_non_aggr_sw_retry_threshold_bk = 1654 cfg_get(psoc, CFG_TX_NON_AGGR_SW_RETRY_BK); 1655 qos_aggr_params->tx_non_aggr_sw_retry_threshold_vi = 1656 cfg_get(psoc, CFG_TX_NON_AGGR_SW_RETRY_VI); 1657 qos_aggr_params->tx_non_aggr_sw_retry_threshold_vo = 1658 cfg_get(psoc, CFG_TX_NON_AGGR_SW_RETRY_VO); 1659 qos_aggr_params->tx_non_aggr_sw_retry_threshold = 1660 cfg_get(psoc, CFG_TX_NON_AGGR_SW_RETRY); 1661 qos_aggr_params->sap_max_inactivity_override = 1662 cfg_get(psoc, CFG_SAP_MAX_INACTIVITY_OVERRIDE); 1663 qos_aggr_params->sap_uapsd_enabled = 1664 cfg_get(psoc, CFG_SAP_QOS_UAPSD); 1665 } 1666 1667 static void mlme_init_mbo_cfg(struct wlan_objmgr_psoc *psoc, 1668 struct wlan_mlme_mbo *mbo_params) 1669 { 1670 mbo_params->mbo_candidate_rssi_thres = 1671 cfg_get(psoc, CFG_MBO_CANDIDATE_RSSI_THRESHOLD); 1672 mbo_params->mbo_current_rssi_thres = 1673 cfg_get(psoc, CFG_MBO_CURRENT_RSSI_THRESHOLD); 1674 mbo_params->mbo_current_rssi_mcc_thres = 1675 cfg_get(psoc, CFG_MBO_CUR_RSSI_MCC_THRESHOLD); 1676 mbo_params->mbo_candidate_rssi_btc_thres = 1677 cfg_get(psoc, CFG_MBO_CAND_RSSI_BTC_THRESHOLD); 1678 } 1679 1680 static void mlme_init_vht_cap_cfg(struct wlan_objmgr_psoc *psoc, 1681 struct mlme_vht_capabilities_info 1682 *vht_cap_info) 1683 { 1684 vht_cap_info->supp_chan_width = 1685 cfg_default(CFG_VHT_SUPP_CHAN_WIDTH); 1686 vht_cap_info->num_soundingdim = 1687 cfg_default(CFG_VHT_NUM_SOUNDING_DIMENSIONS); 1688 vht_cap_info->htc_vhtc = 1689 cfg_default(CFG_VHT_HTC_VHTC); 1690 vht_cap_info->link_adap_cap = 1691 cfg_default(CFG_VHT_LINK_ADAPTATION_CAP); 1692 vht_cap_info->rx_antpattern = 1693 cfg_default(CFG_VHT_RX_ANT_PATTERN); 1694 vht_cap_info->tx_antpattern = 1695 cfg_default(CFG_VHT_TX_ANT_PATTERN); 1696 vht_cap_info->rx_supp_data_rate = 1697 cfg_default(CFG_VHT_RX_SUPP_DATA_RATE); 1698 vht_cap_info->tx_supp_data_rate = 1699 cfg_default(CFG_VHT_TX_SUPP_DATA_RATE); 1700 vht_cap_info->txop_ps = 1701 cfg_default(CFG_VHT_TXOP_PS); 1702 vht_cap_info->rx_mcs_map = 1703 CFG_VHT_RX_MCS_MAP_STADEF; 1704 vht_cap_info->tx_mcs_map = 1705 CFG_VHT_TX_MCS_MAP_STADEF; 1706 vht_cap_info->basic_mcs_set = 1707 CFG_VHT_BASIC_MCS_SET_STADEF; 1708 1709 vht_cap_info->tx_bfee_ant_supp = 1710 cfg_get(psoc, CFG_VHT_BEAMFORMEE_ANT_SUPP); 1711 1712 vht_cap_info->enable_txbf_20mhz = 1713 cfg_get(psoc, CFG_VHT_ENABLE_TXBF_IN_20MHZ); 1714 vht_cap_info->ampdu_len = 1715 cfg_get(psoc, CFG_VHT_MPDU_LEN); 1716 1717 vht_cap_info->ldpc_coding_cap = 1718 cfg_get(psoc, CFG_RX_LDPC_ENABLE); 1719 vht_cap_info->short_gi_80mhz = 1720 cfg_get(psoc, CFG_SHORT_GI_40MHZ); 1721 vht_cap_info->short_gi_160mhz = 1722 cfg_get(psoc, CFG_SHORT_GI_40MHZ); 1723 vht_cap_info->tx_stbc = 1724 cfg_get(psoc, CFG_TX_STBC_ENABLE); 1725 vht_cap_info->rx_stbc = 1726 cfg_get(psoc, CFG_RX_STBC_ENABLE); 1727 1728 vht_cap_info->su_bformee = 1729 cfg_get(psoc, CFG_VHT_SU_BEAMFORMEE_CAP); 1730 1731 vht_cap_info->mu_bformer = 1732 cfg_default(CFG_VHT_MU_BEAMFORMER_CAP); 1733 1734 vht_cap_info->enable_mu_bformee = 1735 cfg_get(psoc, CFG_VHT_ENABLE_MU_BFORMEE_CAP_FEATURE); 1736 vht_cap_info->ampdu_len_exponent = 1737 cfg_get(psoc, CFG_VHT_AMPDU_LEN_EXPONENT); 1738 vht_cap_info->channel_width = 1739 cfg_get(psoc, CFG_VHT_CHANNEL_WIDTH); 1740 vht_cap_info->rx_mcs = 1741 cfg_get(psoc, CFG_VHT_ENABLE_RX_MCS_8_9); 1742 vht_cap_info->tx_mcs = 1743 cfg_get(psoc, CFG_VHT_ENABLE_TX_MCS_8_9); 1744 vht_cap_info->rx_mcs2x2 = 1745 cfg_get(psoc, CFG_VHT_ENABLE_RX_MCS2x2_8_9); 1746 vht_cap_info->tx_mcs2x2 = 1747 cfg_get(psoc, CFG_VHT_ENABLE_TX_MCS2x2_8_9); 1748 vht_cap_info->enable_vht20_mcs9 = 1749 cfg_get(psoc, CFG_ENABLE_VHT20_MCS9); 1750 vht_cap_info->enable2x2 = 1751 cfg_get(psoc, CFG_VHT_ENABLE_2x2_CAP_FEATURE); 1752 vht_cap_info->enable_paid = 1753 cfg_get(psoc, CFG_VHT_ENABLE_PAID_FEATURE); 1754 vht_cap_info->enable_gid = 1755 cfg_get(psoc, CFG_VHT_ENABLE_GID_FEATURE); 1756 vht_cap_info->b24ghz_band = 1757 cfg_get(psoc, CFG_ENABLE_VHT_FOR_24GHZ); 1758 vht_cap_info->vendor_24ghz_band = 1759 cfg_get(psoc, CFG_ENABLE_VENDOR_VHT_FOR_24GHZ); 1760 vht_cap_info->tx_bfee_sap = 1761 cfg_get(psoc, CFG_VHT_ENABLE_TXBF_SAP_MODE); 1762 vht_cap_info->vendor_vhtie = 1763 cfg_get(psoc, CFG_ENABLE_SUBFEE_IN_VENDOR_VHTIE); 1764 1765 if (vht_cap_info->enable2x2) 1766 vht_cap_info->su_bformer = 1767 cfg_get(psoc, CFG_VHT_ENABLE_TX_SU_BEAM_FORMER); 1768 1769 if (vht_cap_info->enable2x2 && vht_cap_info->su_bformer) 1770 vht_cap_info->num_soundingdim = NUM_OF_SOUNDING_DIMENSIONS; 1771 1772 vht_cap_info->tx_bf_cap = cfg_default(CFG_TX_BF_CAP); 1773 vht_cap_info->as_cap = cfg_default(CFG_AS_CAP); 1774 vht_cap_info->disable_ldpc_with_txbf_ap = 1775 cfg_get(psoc, CFG_DISABLE_LDPC_WITH_TXBF_AP); 1776 } 1777 1778 static void mlme_init_rates_in_cfg(struct wlan_objmgr_psoc *psoc, 1779 struct wlan_mlme_rates *rates) 1780 { 1781 rates->cfp_period = cfg_default(CFG_CFP_PERIOD); 1782 rates->cfp_max_duration = cfg_default(CFG_CFP_MAX_DURATION); 1783 rates->max_htmcs_txdata = cfg_get(psoc, CFG_MAX_HT_MCS_FOR_TX_DATA); 1784 rates->disable_abg_rate_txdata = cfg_get(psoc, 1785 CFG_DISABLE_ABG_RATE_FOR_TX_DATA); 1786 rates->sap_max_mcs_txdata = cfg_get(psoc, 1787 CFG_SAP_MAX_MCS_FOR_TX_DATA); 1788 rates->disable_high_ht_mcs_2x2 = cfg_get(psoc, 1789 CFG_DISABLE_HIGH_HT_RX_MCS_2x2); 1790 1791 rates->supported_11b.max_len = CFG_SUPPORTED_RATES_11B_LEN; 1792 qdf_uint8_array_parse(cfg_default(CFG_SUPPORTED_RATES_11B), 1793 rates->supported_11b.data, 1794 sizeof(rates->supported_11b.data), 1795 &rates->supported_11b.len); 1796 rates->supported_11a.max_len = CFG_SUPPORTED_RATES_11A_LEN; 1797 qdf_uint8_array_parse(cfg_default(CFG_SUPPORTED_RATES_11A), 1798 rates->supported_11a.data, 1799 sizeof(rates->supported_11a.data), 1800 &rates->supported_11a.len); 1801 rates->supported_mcs_set.max_len = CFG_SUPPORTED_MCS_SET_LEN; 1802 qdf_uint8_array_parse(cfg_default(CFG_SUPPORTED_MCS_SET), 1803 rates->supported_mcs_set.data, 1804 sizeof(rates->supported_mcs_set.data), 1805 &rates->supported_mcs_set.len); 1806 rates->basic_mcs_set.max_len = CFG_BASIC_MCS_SET_LEN; 1807 qdf_uint8_array_parse(cfg_default(CFG_BASIC_MCS_SET), 1808 rates->basic_mcs_set.data, 1809 sizeof(rates->basic_mcs_set.data), 1810 &rates->basic_mcs_set.len); 1811 rates->current_mcs_set.max_len = CFG_CURRENT_MCS_SET_LEN; 1812 qdf_uint8_array_parse(cfg_default(CFG_CURRENT_MCS_SET), 1813 rates->current_mcs_set.data, 1814 sizeof(rates->current_mcs_set.data), 1815 &rates->current_mcs_set.len); 1816 } 1817 1818 static void mlme_init_dfs_cfg(struct wlan_objmgr_psoc *psoc, 1819 struct wlan_mlme_dfs_cfg *dfs_cfg) 1820 { 1821 dfs_cfg->dfs_ignore_cac = cfg_get(psoc, CFG_IGNORE_CAC); 1822 dfs_cfg->dfs_master_capable = 1823 cfg_get(psoc, CFG_ENABLE_DFS_MASTER_CAPABILITY); 1824 dfs_cfg->dfs_disable_channel_switch = 1825 cfg_get(psoc, CFG_DISABLE_DFS_CH_SWITCH); 1826 dfs_cfg->dfs_filter_offload = 1827 cfg_get(psoc, CFG_ENABLE_DFS_PHYERR_FILTEROFFLOAD); 1828 dfs_cfg->dfs_prefer_non_dfs = 1829 cfg_get(psoc, CFG_ENABLE_NON_DFS_CHAN_ON_RADAR); 1830 dfs_cfg->dfs_beacon_tx_enhanced = 1831 cfg_get(psoc, CFG_DFS_BEACON_TX_ENHANCED); 1832 dfs_cfg->dfs_disable_japan_w53 = 1833 cfg_get(psoc, CFG_DISABLE_DFS_JAPAN_W53); 1834 dfs_cfg->sap_tx_leakage_threshold = 1835 cfg_get(psoc, CFG_SAP_TX_LEAKAGE_THRESHOLD); 1836 dfs_cfg->dfs_pri_multiplier = 1837 cfg_get(psoc, CFG_DFS_RADAR_PRI_MULTIPLIER); 1838 } 1839 1840 static void mlme_init_feature_flag_in_cfg( 1841 struct wlan_objmgr_psoc *psoc, 1842 struct wlan_mlme_feature_flag *feature_flags) 1843 { 1844 feature_flags->accept_short_slot_assoc = 1845 cfg_default(CFG_ACCEPT_SHORT_SLOT_ASSOC_ONLY); 1846 feature_flags->enable_hcf = cfg_default(CFG_HCF_ENABLED); 1847 feature_flags->enable_rsn = cfg_default(CFG_RSN_ENABLED); 1848 feature_flags->enable_short_preamble_11g = 1849 cfg_default(CFG_11G_SHORT_PREAMBLE_ENABLED); 1850 feature_flags->enable_short_slot_time_11g = 1851 cfg_default(CFG_11G_SHORT_SLOT_TIME_ENABLED); 1852 feature_flags->channel_bonding_mode = 1853 cfg_default(CFG_CHANNEL_BONDING_MODE); 1854 feature_flags->enable_block_ack = cfg_default(CFG_BLOCK_ACK_ENABLED); 1855 feature_flags->enable_ampdu = cfg_get(psoc, CFG_ENABLE_AMPDUPS); 1856 feature_flags->mcc_rts_cts_prot = cfg_get(psoc, 1857 CFG_FW_MCC_RTS_CTS_PROT); 1858 feature_flags->mcc_bcast_prob_rsp = cfg_get(psoc, 1859 CFG_FW_MCC_BCAST_PROB_RESP); 1860 feature_flags->enable_mcc = cfg_get(psoc, CFG_MCC_FEATURE); 1861 feature_flags->channel_bonding_mode_24ghz = 1862 cfg_get(psoc, CFG_CHANNEL_BONDING_MODE_24GHZ); 1863 feature_flags->channel_bonding_mode_5ghz = 1864 cfg_get(psoc, CFG_CHANNEL_BONDING_MODE_5GHZ); 1865 } 1866 1867 static void mlme_init_sap_protection_cfg(struct wlan_objmgr_psoc *psoc, 1868 struct wlan_mlme_sap_protection 1869 *sap_protection_params) 1870 { 1871 sap_protection_params->protection_enabled = 1872 cfg_default(CFG_PROTECTION_ENABLED); 1873 sap_protection_params->protection_force_policy = 1874 cfg_default(CFG_FORCE_POLICY_PROTECTION); 1875 sap_protection_params->ignore_peer_ht_opmode = 1876 cfg_get(psoc, CFG_IGNORE_PEER_HT_MODE); 1877 sap_protection_params->enable_ap_obss_protection = 1878 cfg_get(psoc, CFG_AP_OBSS_PROTECTION_ENABLE); 1879 sap_protection_params->is_ap_prot_enabled = 1880 cfg_get(psoc, CFG_AP_ENABLE_PROTECTION_MODE); 1881 sap_protection_params->ap_protection_mode = 1882 cfg_get(psoc, CFG_AP_PROTECTION_MODE); 1883 } 1884 1885 #ifdef WLAN_FEATURE_11AX 1886 1887 #define HE_MCS12_13_24G_INDEX 0 1888 #define HE_MCS12_13_5G_INDEX 1 1889 #define HE_MCS12_13_BITS 16 1890 1891 static void mlme_init_he_cap_in_cfg(struct wlan_objmgr_psoc *psoc, 1892 struct wlan_mlme_cfg *mlme_cfg) 1893 { 1894 uint32_t chan_width, mcs_12_13; 1895 uint16_t value = 0; 1896 struct wlan_mlme_he_caps *he_caps = &mlme_cfg->he_caps; 1897 bool is_twt_enabled = false; 1898 1899 he_caps->dot11_he_cap.htc_he = cfg_default(CFG_HE_CONTROL); 1900 he_caps->dot11_he_cap.twt_request = 1901 cfg_get(psoc, CFG_TWT_REQUESTOR); 1902 he_caps->dot11_he_cap.twt_responder = 1903 cfg_get(psoc, CFG_TWT_RESPONDER); 1904 /* 1905 * Broadcast TWT capability will be filled in 1906 * populate_dot11f_he_caps() based on STA/SAP 1907 * role and "twt_bcast_req_resp_config" ini 1908 */ 1909 he_caps->dot11_he_cap.broadcast_twt = 0; 1910 1911 is_twt_enabled = wlan_twt_cfg_is_twt_enabled(psoc); 1912 1913 if (is_twt_enabled) 1914 he_caps->dot11_he_cap.flex_twt_sched = 1915 cfg_default(CFG_HE_FLEX_TWT_SCHED); 1916 he_caps->dot11_he_cap.fragmentation = 1917 cfg_default(CFG_HE_FRAGMENTATION); 1918 he_caps->dot11_he_cap.max_num_frag_msdu_amsdu_exp = 1919 cfg_default(CFG_HE_MAX_FRAG_MSDU); 1920 he_caps->dot11_he_cap.min_frag_size = cfg_default(CFG_HE_MIN_FRAG_SIZE); 1921 he_caps->dot11_he_cap.trigger_frm_mac_pad = 1922 cfg_default(CFG_HE_TRIG_PAD); 1923 he_caps->dot11_he_cap.multi_tid_aggr_rx_supp = 1924 cfg_default(CFG_HE_MTID_AGGR_RX); 1925 he_caps->dot11_he_cap.he_link_adaptation = 1926 cfg_default(CFG_HE_LINK_ADAPTATION); 1927 he_caps->dot11_he_cap.all_ack = cfg_default(CFG_HE_ALL_ACK); 1928 he_caps->dot11_he_cap.trigd_rsp_sched = 1929 cfg_default(CFG_HE_TRIGD_RSP_SCHEDULING); 1930 he_caps->dot11_he_cap.a_bsr = cfg_default(CFG_HE_BUFFER_STATUS_RPT); 1931 he_caps->dot11_he_cap.ba_32bit_bitmap = cfg_default(CFG_HE_BA_32BIT); 1932 he_caps->dot11_he_cap.mu_cascade = cfg_default(CFG_HE_MU_CASCADING); 1933 he_caps->dot11_he_cap.ack_enabled_multitid = 1934 cfg_default(CFG_HE_MULTI_TID); 1935 he_caps->dot11_he_cap.omi_a_ctrl = cfg_default(CFG_HE_OMI); 1936 he_caps->dot11_he_cap.ofdma_ra = cfg_default(CFG_HE_OFDMA_RA); 1937 he_caps->dot11_he_cap.max_ampdu_len_exp_ext = 1938 cfg_default(CFG_HE_MAX_AMPDU_LEN); 1939 he_caps->dot11_he_cap.amsdu_frag = cfg_default(CFG_HE_AMSDU_FRAG); 1940 1941 he_caps->dot11_he_cap.rx_ctrl_frame = cfg_default(CFG_HE_RX_CTRL); 1942 he_caps->dot11_he_cap.bsrp_ampdu_aggr = 1943 cfg_default(CFG_HE_BSRP_AMPDU_AGGR); 1944 he_caps->dot11_he_cap.qtp = cfg_default(CFG_HE_QTP); 1945 he_caps->dot11_he_cap.a_bqr = cfg_default(CFG_HE_A_BQR); 1946 he_caps->dot11_he_cap.spatial_reuse_param_rspder = 1947 cfg_default(CFG_HE_SR_RESPONDER); 1948 he_caps->dot11_he_cap.ndp_feedback_supp = 1949 cfg_default(CFG_HE_NDP_FEEDBACK_SUPP); 1950 he_caps->dot11_he_cap.ops_supp = cfg_default(CFG_HE_OPS_SUPP); 1951 he_caps->dot11_he_cap.amsdu_in_ampdu = 1952 cfg_default(CFG_HE_AMSDU_IN_AMPDU); 1953 1954 chan_width = cfg_default(CFG_HE_CHAN_WIDTH); 1955 he_caps->dot11_he_cap.chan_width_0 = HE_CH_WIDTH_GET_BIT(chan_width, 0); 1956 he_caps->dot11_he_cap.chan_width_1 = HE_CH_WIDTH_GET_BIT(chan_width, 1); 1957 he_caps->dot11_he_cap.chan_width_2 = HE_CH_WIDTH_GET_BIT(chan_width, 2); 1958 he_caps->dot11_he_cap.chan_width_3 = HE_CH_WIDTH_GET_BIT(chan_width, 3); 1959 he_caps->dot11_he_cap.chan_width_4 = HE_CH_WIDTH_GET_BIT(chan_width, 4); 1960 he_caps->dot11_he_cap.chan_width_5 = HE_CH_WIDTH_GET_BIT(chan_width, 5); 1961 he_caps->dot11_he_cap.chan_width_6 = HE_CH_WIDTH_GET_BIT(chan_width, 6); 1962 1963 he_caps->dot11_he_cap.multi_tid_aggr_tx_supp = 1964 cfg_default(CFG_HE_MTID_AGGR_TX); 1965 he_caps->dot11_he_cap.he_sub_ch_sel_tx_supp = 1966 cfg_default(CFG_HE_SUB_CH_SEL_TX); 1967 he_caps->dot11_he_cap.ul_2x996_tone_ru_supp = 1968 cfg_default(CFG_HE_UL_2X996_RU); 1969 he_caps->dot11_he_cap.om_ctrl_ul_mu_data_dis_rx = 1970 cfg_default(CFG_HE_OM_CTRL_UL_MU_DIS_RX); 1971 he_caps->dot11_he_cap.he_dynamic_smps = 1972 cfg_default(CFG_HE_DYNAMIC_SMPS); 1973 he_caps->dot11_he_cap.punctured_sounding_supp = 1974 cfg_default(CFG_HE_PUNCTURED_SOUNDING); 1975 he_caps->dot11_he_cap.ht_vht_trg_frm_rx_supp = 1976 cfg_default(CFG_HE_HT_VHT_TRG_FRM_RX); 1977 he_caps->dot11_he_cap.rx_pream_puncturing = 1978 cfg_get(psoc, CFG_HE_RX_PREAM_PUNC); 1979 he_caps->dot11_he_cap.device_class = 1980 cfg_default(CFG_HE_CLASS_OF_DEVICE); 1981 he_caps->dot11_he_cap.ldpc_coding = cfg_default(CFG_HE_LDPC); 1982 he_caps->dot11_he_cap.he_1x_ltf_800_gi_ppdu = 1983 cfg_default(CFG_HE_LTF_PPDU); 1984 he_caps->dot11_he_cap.midamble_tx_rx_max_nsts = 1985 cfg_default(CFG_HE_MIDAMBLE_RX_MAX_NSTS); 1986 he_caps->dot11_he_cap.he_4x_ltf_3200_gi_ndp = 1987 cfg_default(CFG_HE_LTF_NDP); 1988 he_caps->dot11_he_cap.tb_ppdu_tx_stbc_lt_80mhz = 1989 cfg_default(CFG_HE_TX_STBC_LT80); 1990 he_caps->dot11_he_cap.rx_stbc_lt_80mhz = 1991 cfg_default(CFG_HE_RX_STBC_LT80); 1992 he_caps->dot11_he_cap.doppler = cfg_default(CFG_HE_DOPPLER); 1993 he_caps->dot11_he_cap.ul_mu = 1994 cfg_get(psoc, CFG_HE_UL_MUMIMO); 1995 he_caps->dot11_he_cap.dcm_enc_tx = cfg_default(CFG_HE_DCM_TX); 1996 he_caps->dot11_he_cap.dcm_enc_rx = cfg_default(CFG_HE_DCM_RX); 1997 he_caps->dot11_he_cap.ul_he_mu = cfg_default(CFG_HE_MU_PPDU); 1998 he_caps->dot11_he_cap.su_beamformer = cfg_default(CFG_HE_SU_BEAMFORMER); 1999 he_caps->dot11_he_cap.su_beamformee = cfg_default(CFG_HE_SU_BEAMFORMEE); 2000 he_caps->dot11_he_cap.mu_beamformer = cfg_default(CFG_HE_MU_BEAMFORMER); 2001 he_caps->dot11_he_cap.bfee_sts_lt_80 = 2002 cfg_default(CFG_HE_BFEE_STS_LT80); 2003 he_caps->dot11_he_cap.bfee_sts_gt_80 = 2004 cfg_default(CFG_HE_BFEE_STS_GT80); 2005 he_caps->dot11_he_cap.num_sounding_lt_80 = 2006 cfg_default(CFG_HE_NUM_SOUND_LT80); 2007 he_caps->dot11_he_cap.num_sounding_gt_80 = 2008 cfg_default(CFG_HE_NUM_SOUND_GT80); 2009 he_caps->dot11_he_cap.su_feedback_tone16 = 2010 cfg_default(CFG_HE_SU_FEED_TONE16); 2011 he_caps->dot11_he_cap.mu_feedback_tone16 = 2012 cfg_default(CFG_HE_MU_FEED_TONE16); 2013 he_caps->dot11_he_cap.codebook_su = cfg_default(CFG_HE_CODEBOOK_SU); 2014 he_caps->dot11_he_cap.codebook_mu = cfg_default(CFG_HE_CODEBOOK_MU); 2015 he_caps->dot11_he_cap.beamforming_feedback = 2016 cfg_default(CFG_HE_BFRM_FEED); 2017 he_caps->dot11_he_cap.he_er_su_ppdu = cfg_default(CFG_HE_ER_SU_PPDU); 2018 he_caps->dot11_he_cap.dl_mu_mimo_part_bw = 2019 cfg_default(CFG_HE_DL_PART_BW); 2020 he_caps->dot11_he_cap.ppet_present = cfg_default(CFG_HE_PPET_PRESENT); 2021 he_caps->dot11_he_cap.srp = cfg_default(CFG_HE_SRP); 2022 he_caps->dot11_he_cap.power_boost = cfg_default(CFG_HE_POWER_BOOST); 2023 he_caps->dot11_he_cap.he_ltf_800_gi_4x = cfg_default(CFG_HE_4x_LTF_GI); 2024 he_caps->dot11_he_cap.max_nc = cfg_default(CFG_HE_MAX_NC); 2025 he_caps->dot11_he_cap.tb_ppdu_tx_stbc_gt_80mhz = 2026 cfg_default(CFG_HE_TX_STBC_GT80); 2027 he_caps->dot11_he_cap.rx_stbc_gt_80mhz = 2028 cfg_default(CFG_HE_RX_STBC_GT80); 2029 he_caps->dot11_he_cap.er_he_ltf_800_gi_4x = 2030 cfg_default(CFG_HE_ER_4x_LTF_GI); 2031 he_caps->dot11_he_cap.he_ppdu_20_in_40Mhz_2G = 2032 cfg_default(CFG_HE_PPDU_20_IN_40MHZ_2G); 2033 he_caps->dot11_he_cap.he_ppdu_20_in_160_80p80Mhz = 2034 cfg_default(CFG_HE_PPDU_20_IN_160_80P80MHZ); 2035 he_caps->dot11_he_cap.he_ppdu_80_in_160_80p80Mhz = 2036 cfg_default(CFG_HE_PPDU_80_IN_160_80P80MHZ); 2037 he_caps->dot11_he_cap.er_1x_he_ltf_gi = 2038 cfg_default(CFG_HE_ER_1X_HE_LTF_GI); 2039 he_caps->dot11_he_cap.midamble_tx_rx_1x_he_ltf = 2040 cfg_default(CFG_HE_MIDAMBLE_TXRX_1X_HE_LTF); 2041 he_caps->dot11_he_cap.dcm_max_bw = cfg_default(CFG_HE_DCM_MAX_BW); 2042 he_caps->dot11_he_cap.longer_than_16_he_sigb_ofdm_sym = 2043 cfg_default(CFG_HE_LONGER_16_SIGB_OFDM_SYM); 2044 he_caps->dot11_he_cap.non_trig_cqi_feedback = 2045 cfg_default(CFG_HE_NON_TRIG_CQI_FEEDBACK); 2046 he_caps->dot11_he_cap.tx_1024_qam_lt_242_tone_ru = 2047 cfg_default(CFG_HE_TX_1024_QAM_LT_242_RU); 2048 he_caps->dot11_he_cap.rx_1024_qam_lt_242_tone_ru = 2049 cfg_default(CFG_HE_RX_1024_QAM_LT_242_RU); 2050 he_caps->dot11_he_cap.rx_full_bw_su_he_mu_compress_sigb = 2051 cfg_default(CFG_HE_RX_FULL_BW_MU_CMPR_SIGB); 2052 he_caps->dot11_he_cap.rx_full_bw_su_he_mu_non_cmpr_sigb = 2053 cfg_default(CFG_HE_RX_FULL_BW_MU_NON_CMPR_SIGB); 2054 he_caps->dot11_he_cap.rx_he_mcs_map_lt_80 = 2055 cfg_get(psoc, CFG_HE_RX_MCS_MAP_LT_80); 2056 he_caps->dot11_he_cap.tx_he_mcs_map_lt_80 = 2057 cfg_get(psoc, CFG_HE_TX_MCS_MAP_LT_80); 2058 value = cfg_get(psoc, CFG_HE_RX_MCS_MAP_160); 2059 qdf_mem_copy(he_caps->dot11_he_cap.rx_he_mcs_map_160, &value, 2060 sizeof(uint16_t)); 2061 value = cfg_get(psoc, CFG_HE_TX_MCS_MAP_160); 2062 qdf_mem_copy(he_caps->dot11_he_cap.tx_he_mcs_map_160, &value, 2063 sizeof(uint16_t)); 2064 value = cfg_default(CFG_HE_RX_MCS_MAP_80_80); 2065 qdf_mem_copy(he_caps->dot11_he_cap.rx_he_mcs_map_80_80, &value, 2066 sizeof(uint16_t)); 2067 value = cfg_default(CFG_HE_TX_MCS_MAP_80_80); 2068 qdf_mem_copy(he_caps->dot11_he_cap.tx_he_mcs_map_80_80, &value, 2069 sizeof(uint16_t)); 2070 he_caps->he_ops_basic_mcs_nss = cfg_default(CFG_HE_OPS_BASIC_MCS_NSS); 2071 he_caps->he_dynamic_fragmentation = 2072 cfg_get(psoc, CFG_HE_DYNAMIC_FRAGMENTATION); 2073 he_caps->enable_ul_mimo = 2074 cfg_get(psoc, CFG_ENABLE_UL_MIMO); 2075 he_caps->enable_ul_ofdm = 2076 cfg_get(psoc, CFG_ENABLE_UL_OFDMA); 2077 he_caps->he_sta_obsspd = 2078 cfg_get(psoc, CFG_HE_STA_OBSSPD); 2079 qdf_mem_zero(he_caps->he_ppet_2g, MLME_HE_PPET_LEN); 2080 qdf_mem_zero(he_caps->he_ppet_5g, MLME_HE_PPET_LEN); 2081 2082 mcs_12_13 = cfg_get(psoc, CFG_HE_MCS_12_13_SUPPORT); 2083 /* Get 2.4Ghz and 5Ghz value */ 2084 mlme_cfg->he_caps.he_mcs_12_13_supp_2g = 2085 QDF_GET_BITS(mcs_12_13, 2086 HE_MCS12_13_24G_INDEX * HE_MCS12_13_BITS, 2087 HE_MCS12_13_BITS); 2088 mlme_cfg->he_caps.he_mcs_12_13_supp_5g = 2089 QDF_GET_BITS(mcs_12_13, 2090 HE_MCS12_13_5G_INDEX * HE_MCS12_13_BITS, 2091 HE_MCS12_13_BITS); 2092 } 2093 #else 2094 static void mlme_init_he_cap_in_cfg(struct wlan_objmgr_psoc *psoc, 2095 struct wlan_mlme_cfg *mlme_cfg) 2096 { 2097 } 2098 #endif 2099 2100 #ifdef WLAN_SUPPORT_TWT 2101 static void mlme_init_twt_cfg(struct wlan_objmgr_psoc *psoc, 2102 struct wlan_mlme_cfg_twt *twt_cfg) 2103 { 2104 uint32_t bcast_conf = cfg_get(psoc, CFG_BCAST_TWT_REQ_RESP); 2105 2106 twt_cfg->is_twt_enabled = cfg_get(psoc, CFG_ENABLE_TWT); 2107 twt_cfg->twt_congestion_timeout = cfg_get(psoc, CFG_TWT_CONGESTION_TIMEOUT); 2108 twt_cfg->enable_twt_24ghz = cfg_get(psoc, CFG_ENABLE_TWT_24GHZ); 2109 twt_cfg->is_bcast_requestor_enabled = CFG_TWT_GET_BCAST_REQ(bcast_conf); 2110 twt_cfg->is_bcast_responder_enabled = CFG_TWT_GET_BCAST_RES(bcast_conf); 2111 } 2112 #else 2113 static void mlme_init_twt_cfg(struct wlan_objmgr_psoc *psoc, 2114 struct wlan_mlme_cfg_twt *twt_cfg) 2115 { 2116 } 2117 #endif 2118 2119 #ifdef WLAN_FEATURE_11BE 2120 static void mlme_init_eht_cap_in_cfg(struct wlan_objmgr_psoc *psoc, 2121 struct wlan_mlme_cfg *mlme_cfg) 2122 { 2123 struct wlan_mlme_eht_caps *eht_caps = &mlme_cfg->eht_caps; 2124 2125 eht_caps->dot11_eht_cap.su_beamformer = 2126 cfg_default(CFG_EHT_SU_BEAMFORMER); 2127 eht_caps->dot11_eht_cap.su_beamformee = 2128 cfg_default(CFG_EHT_SU_BEAMFORMEE); 2129 eht_caps->dot11_eht_cap.mu_bformer_le_80mhz = 2130 cfg_default(CFG_EHT_MU_BFORMER_LE_80MHZ); 2131 eht_caps->dot11_eht_cap.mu_bformer_160mhz = 2132 cfg_default(CFG_EHT_MU_BFORMER_160MHZ); 2133 eht_caps->dot11_eht_cap.mu_bformer_320mhz = 2134 cfg_default(CFG_EHT_MU_BFORMER_320MHZ); 2135 eht_caps->dot11_eht_cap.bfee_ss_le_80mhz = 2136 cfg_default(CFG_EHT_BFEE_SS_LE_80MHZ); 2137 eht_caps->dot11_eht_cap.bfee_ss_160mhz = 2138 cfg_default(CFG_EHT_BFEE_SS_160MHZ); 2139 eht_caps->dot11_eht_cap.bfee_ss_320mhz = 2140 cfg_default(CFG_EHT_BFEE_SS_320MHZ); 2141 eht_caps->dot11_eht_cap.num_sounding_dim_le_80mhz = 2142 cfg_default(CFG_EHT_NUM_SOUNDING_DIM_LE_80MHZ); 2143 eht_caps->dot11_eht_cap.num_sounding_dim_160mhz = 2144 cfg_default(CFG_EHT_NUM_SOUNDING_DIM_160MHZ); 2145 eht_caps->dot11_eht_cap.num_sounding_dim_320mhz = 2146 cfg_default(CFG_EHT_NUM_SOUNDING_DIM_320MHZ); 2147 } 2148 #else 2149 static void mlme_init_eht_cap_in_cfg(struct wlan_objmgr_psoc *psoc, 2150 struct wlan_mlme_cfg *mlme_cfg) 2151 { 2152 } 2153 #endif 2154 2155 #ifdef WLAN_FEATURE_SAE 2156 static bool is_sae_sap_enabled(struct wlan_objmgr_psoc *psoc) 2157 { 2158 return cfg_get(psoc, CFG_IS_SAP_SAE_ENABLED); 2159 } 2160 2161 bool wlan_vdev_is_sae_auth_type(struct wlan_objmgr_vdev *vdev) 2162 { 2163 int32_t auth_mode; 2164 2165 auth_mode = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_AUTH_MODE); 2166 2167 if (auth_mode == -1) 2168 return false; 2169 2170 if (QDF_HAS_PARAM(auth_mode, WLAN_CRYPTO_AUTH_SAE)) 2171 return true; 2172 2173 return false; 2174 } 2175 #else 2176 static bool is_sae_sap_enabled(struct wlan_objmgr_psoc *psoc) 2177 { 2178 return false; 2179 } 2180 #endif 2181 uint16_t wlan_get_rand_from_lst_for_freq(uint16_t *freq_lst, 2182 uint8_t num_chan) 2183 { 2184 uint8_t i; 2185 uint32_t rand_byte = 0; 2186 2187 if (!num_chan || !freq_lst) { 2188 mlme_legacy_debug("invalid param freq_lst %pK, num_chan = %d", 2189 freq_lst, num_chan); 2190 return 0; 2191 } 2192 2193 get_random_bytes((uint8_t *)&rand_byte, 1); 2194 i = (rand_byte + qdf_mc_timer_get_system_ticks()) % num_chan; 2195 2196 return freq_lst[i]; 2197 } 2198 2199 static void mlme_init_sap_cfg(struct wlan_objmgr_psoc *psoc, 2200 struct wlan_mlme_cfg_sap *sap_cfg) 2201 { 2202 sap_cfg->beacon_interval = cfg_get(psoc, CFG_BEACON_INTERVAL); 2203 sap_cfg->dtim_interval = cfg_default(CFG_DTIM_PERIOD); 2204 sap_cfg->listen_interval = cfg_default(CFG_LISTEN_INTERVAL); 2205 sap_cfg->sap_11g_policy = cfg_default(CFG_11G_ONLY_POLICY); 2206 sap_cfg->assoc_sta_limit = cfg_default(CFG_ASSOC_STA_LIMIT); 2207 sap_cfg->enable_lte_coex = cfg_get(psoc, CFG_ENABLE_LTE_COEX); 2208 sap_cfg->rate_tx_mgmt = cfg_get(psoc, CFG_RATE_FOR_TX_MGMT); 2209 sap_cfg->rate_tx_mgmt_2g = cfg_get(psoc, CFG_RATE_FOR_TX_MGMT_2G); 2210 sap_cfg->rate_tx_mgmt_5g = cfg_get(psoc, CFG_RATE_FOR_TX_MGMT_5G); 2211 sap_cfg->tele_bcn_wakeup_en = cfg_get(psoc, CFG_TELE_BCN_WAKEUP_EN); 2212 sap_cfg->tele_bcn_max_li = cfg_get(psoc, CFG_TELE_BCN_MAX_LI); 2213 sap_cfg->sap_get_peer_info = cfg_get(psoc, CFG_SAP_GET_PEER_INFO); 2214 sap_cfg->sap_allow_all_chan_param_name = 2215 cfg_get(psoc, CFG_SAP_ALLOW_ALL_CHANNEL_PARAM); 2216 sap_cfg->sap_max_no_peers = cfg_get(psoc, CFG_SAP_MAX_NO_PEERS); 2217 sap_cfg->sap_max_offload_peers = 2218 cfg_get(psoc, CFG_SAP_MAX_OFFLOAD_PEERS); 2219 sap_cfg->sap_max_offload_reorder_buffs = 2220 cfg_get(psoc, CFG_SAP_MAX_OFFLOAD_REORDER_BUFFS); 2221 sap_cfg->sap_ch_switch_beacon_cnt = 2222 cfg_get(psoc, CFG_SAP_CH_SWITCH_BEACON_CNT); 2223 sap_cfg->sap_ch_switch_mode = cfg_get(psoc, CFG_SAP_CH_SWITCH_MODE); 2224 sap_cfg->sap_internal_restart = 2225 cfg_get(psoc, CFG_SAP_INTERNAL_RESTART); 2226 sap_cfg->chan_switch_hostapd_rate_enabled_name = 2227 cfg_get(psoc, CFG_CHAN_SWITCH_HOSTAPD_RATE_ENABLED_NAME); 2228 sap_cfg->reduced_beacon_interval = 2229 cfg_get(psoc, CFG_REDUCED_BEACON_INTERVAL); 2230 sap_cfg->max_li_modulated_dtim_time = 2231 cfg_get(psoc, CFG_MAX_LI_MODULATED_DTIM); 2232 sap_cfg->country_code_priority = 2233 cfg_get(psoc, CFG_COUNTRY_CODE_PRIORITY); 2234 sap_cfg->sap_pref_chan_location = 2235 cfg_get(psoc, CFG_SAP_PREF_CHANNEL_LOCATION); 2236 sap_cfg->sap_force_11n_for_11ac = 2237 cfg_get(psoc, CFG_SAP_FORCE_11N_FOR_11AC); 2238 sap_cfg->go_force_11n_for_11ac = 2239 cfg_get(psoc, CFG_GO_FORCE_11N_FOR_11AC); 2240 sap_cfg->ap_random_bssid_enable = 2241 cfg_get(psoc, CFG_AP_ENABLE_RANDOM_BSSID); 2242 sap_cfg->sap_mcc_chnl_avoid = 2243 cfg_get(psoc, CFG_SAP_MCC_CHANNEL_AVOIDANCE); 2244 sap_cfg->sap_11ac_override = 2245 cfg_get(psoc, CFG_SAP_11AC_OVERRIDE); 2246 sap_cfg->go_11ac_override = 2247 cfg_get(psoc, CFG_GO_11AC_OVERRIDE); 2248 sap_cfg->sap_sae_enabled = is_sae_sap_enabled(psoc); 2249 sap_cfg->is_sap_bcast_deauth_enabled = 2250 cfg_get(psoc, CFG_IS_SAP_BCAST_DEAUTH_ENABLED); 2251 sap_cfg->is_6g_sap_fd_enabled = 2252 cfg_get(psoc, CFG_6G_SAP_FILS_DISCOVERY_ENABLED); 2253 sap_cfg->disable_bcn_prot = 2254 cfg_get(psoc, CFG_DISABLE_SAP_BCN_PROT); 2255 sap_cfg->sap_ps_with_twt_enable = 2256 cfg_get(psoc, CFG_SAP_PS_WITH_TWT); 2257 } 2258 2259 static void mlme_init_obss_ht40_cfg(struct wlan_objmgr_psoc *psoc, 2260 struct wlan_mlme_obss_ht40 *obss_ht40) 2261 { 2262 obss_ht40->active_dwelltime = 2263 cfg_get(psoc, CFG_OBSS_HT40_SCAN_ACTIVE_DWELL_TIME); 2264 obss_ht40->passive_dwelltime = 2265 cfg_get(psoc, CFG_OBSS_HT40_SCAN_PASSIVE_DWELL_TIME); 2266 obss_ht40->width_trigger_interval = 2267 cfg_get(psoc, CFG_OBSS_HT40_SCAN_WIDTH_TRIGGER_INTERVAL); 2268 obss_ht40->passive_per_channel = (uint32_t) 2269 cfg_default(CFG_OBSS_HT40_SCAN_PASSIVE_TOTAL_PER_CHANNEL); 2270 obss_ht40->active_per_channel = (uint32_t) 2271 cfg_default(CFG_OBSS_HT40_SCAN_ACTIVE_TOTAL_PER_CHANNEL); 2272 obss_ht40->width_trans_delay = (uint32_t) 2273 cfg_default(CFG_OBSS_HT40_WIDTH_CH_TRANSITION_DELAY); 2274 obss_ht40->scan_activity_threshold = (uint32_t) 2275 cfg_default(CFG_OBSS_HT40_SCAN_ACTIVITY_THRESHOLD); 2276 obss_ht40->is_override_ht20_40_24g = 2277 cfg_get(psoc, CFG_OBSS_HT40_OVERRIDE_HT40_20_24GHZ); 2278 obss_ht40->obss_detection_offload_enabled = 2279 (bool)cfg_default(CFG_OBSS_DETECTION_OFFLOAD); 2280 obss_ht40->obss_color_collision_offload_enabled = 2281 (bool)cfg_default(CFG_OBSS_COLOR_COLLISION_OFFLOAD); 2282 obss_ht40->bss_color_collision_det_sta = 2283 cfg_get(psoc, CFG_BSS_CLR_COLLISION_DETCN_STA); 2284 } 2285 2286 static void mlme_init_threshold_cfg(struct wlan_objmgr_psoc *psoc, 2287 struct wlan_mlme_threshold *threshold) 2288 { 2289 threshold->rts_threshold = cfg_get(psoc, CFG_RTS_THRESHOLD); 2290 threshold->frag_threshold = cfg_get(psoc, CFG_FRAG_THRESHOLD); 2291 } 2292 2293 static bool 2294 mlme_is_freq_present_in_list(struct acs_weight *normalize_weight_chan_list, 2295 uint8_t num_freq, uint32_t freq, uint8_t *index) 2296 { 2297 uint8_t i; 2298 2299 for (i = 0; i < num_freq && i < NUM_CHANNELS; i++) { 2300 if (normalize_weight_chan_list[i].chan_freq == freq) { 2301 *index = i; 2302 return true; 2303 } 2304 } 2305 2306 return false; 2307 } 2308 2309 static void 2310 mlme_acs_parse_weight_list(struct wlan_objmgr_psoc *psoc, 2311 struct wlan_mlme_acs *acs) 2312 { 2313 char *acs_weight, *str1, *str2 = NULL, *acs_weight_temp, is_range = '-'; 2314 int freq1, freq2, normalize_factor; 2315 uint8_t num_acs_weight = 0, num_acs_weight_range = 0, index = 0; 2316 struct acs_weight *weight_list = acs->normalize_weight_chan; 2317 struct acs_weight_range *range_list = acs->normalize_weight_range; 2318 2319 if (!qdf_str_len(cfg_get(psoc, CFG_NORMALIZE_ACS_WEIGHT))) 2320 return; 2321 2322 acs_weight = qdf_mem_malloc(ACS_WEIGHT_MAX_STR_LEN); 2323 if (!acs_weight) 2324 return; 2325 2326 qdf_mem_copy(acs_weight, cfg_get(psoc, CFG_NORMALIZE_ACS_WEIGHT), 2327 ACS_WEIGHT_MAX_STR_LEN); 2328 acs_weight_temp = acs_weight; 2329 2330 while(acs_weight_temp) { 2331 str1 = strsep(&acs_weight_temp, ","); 2332 if (!str1) 2333 goto end; 2334 freq1 = 0; 2335 freq2 = 0; 2336 if (strchr(str1, is_range)) { 2337 str2 = strsep(&str1, "-"); 2338 sscanf(str2, "%d", &freq1); 2339 sscanf(str1, "%d", &freq2); 2340 strsep(&str1, "="); 2341 if (!str1) 2342 goto end; 2343 sscanf(str1, "%d", &normalize_factor); 2344 2345 if (num_acs_weight_range == MAX_ACS_WEIGHT_RANGE) 2346 continue; 2347 range_list[num_acs_weight_range].normalize_weight = 2348 normalize_factor; 2349 range_list[num_acs_weight_range].start_freq = freq1; 2350 range_list[num_acs_weight_range++].end_freq = freq2; 2351 } else { 2352 sscanf(str1, "%d", &freq1); 2353 strsep(&str1, "="); 2354 if (!str1 || !weight_list) 2355 goto end; 2356 sscanf(str1, "%d", &normalize_factor); 2357 if (mlme_is_freq_present_in_list(weight_list, 2358 num_acs_weight, freq1, 2359 &index)) { 2360 weight_list[index].normalize_weight = 2361 normalize_factor; 2362 } else { 2363 if (num_acs_weight == NUM_CHANNELS) 2364 continue; 2365 2366 weight_list[num_acs_weight].chan_freq = freq1; 2367 weight_list[num_acs_weight++].normalize_weight = 2368 normalize_factor; 2369 } 2370 } 2371 } 2372 2373 acs->normalize_weight_num_chan = num_acs_weight; 2374 acs->num_weight_range = num_acs_weight_range; 2375 2376 end: 2377 qdf_mem_free(acs_weight); 2378 } 2379 2380 static void mlme_init_acs_cfg(struct wlan_objmgr_psoc *psoc, 2381 struct wlan_mlme_acs *acs) 2382 { 2383 acs->is_acs_with_more_param = 2384 cfg_get(psoc, CFG_ACS_WITH_MORE_PARAM); 2385 acs->auto_channel_select_weight = 2386 cfg_get(psoc, CFG_AUTO_CHANNEL_SELECT_WEIGHT); 2387 acs->is_vendor_acs_support = 2388 cfg_get(psoc, CFG_USER_AUTO_CHANNEL_SELECTION); 2389 acs->force_sap_start = 2390 cfg_get(psoc, CFG_ACS_FORCE_START_SAP); 2391 acs->is_acs_support_for_dfs_ltecoex = 2392 cfg_get(psoc, CFG_USER_ACS_DFS_LTE); 2393 acs->is_external_acs_policy = 2394 cfg_get(psoc, CFG_EXTERNAL_ACS_POLICY); 2395 acs->np_chan_weightage = cfg_get(psoc, CFG_ACS_NP_CHAN_WEIGHT); 2396 acs->acs_prefer_6ghz_psc = cfg_default(CFG_ACS_PREFER_6GHZ_PSC); 2397 mlme_acs_parse_weight_list(psoc, acs); 2398 } 2399 2400 static void 2401 mlme_init_product_details_cfg(struct wlan_mlme_product_details_cfg 2402 *product_details) 2403 { 2404 qdf_str_lcopy(product_details->manufacturer_name, 2405 cfg_default(CFG_MFR_NAME), 2406 sizeof(product_details->manufacturer_name)); 2407 qdf_str_lcopy(product_details->manufacture_product_name, 2408 cfg_default(CFG_MFR_PRODUCT_NAME), 2409 sizeof(product_details->manufacture_product_name)); 2410 qdf_str_lcopy(product_details->manufacture_product_version, 2411 cfg_default(CFG_MFR_PRODUCT_VERSION), 2412 sizeof(product_details->manufacture_product_version)); 2413 qdf_str_lcopy(product_details->model_name, 2414 cfg_default(CFG_MODEL_NAME), 2415 sizeof(product_details->model_name)); 2416 qdf_str_lcopy(product_details->model_number, 2417 cfg_default(CFG_MODEL_NUMBER), 2418 sizeof(product_details->model_number)); 2419 } 2420 2421 #ifdef WLAN_FEATURE_11BE_MLO 2422 static void mlme_init_sta_mlo_cfg(struct wlan_objmgr_psoc *psoc, 2423 struct wlan_mlme_sta_cfg *sta) 2424 { 2425 sta->mlo_support_link_num = 2426 cfg_get(psoc, CFG_MLO_SUPPORT_LINK_NUM); 2427 sta->mlo_support_link_band = 2428 cfg_default(CFG_MLO_SUPPORT_LINK_BAND); 2429 sta->mlo_max_simultaneous_links = 2430 cfg_default(CFG_MLO_MAX_SIMULTANEOUS_LINKS); 2431 sta->mlo_prefer_percentage = 2432 cfg_get(psoc, CFG_MLO_PREFER_PERCENTAGE); 2433 sta->mlo_same_link_mld_address = 2434 cfg_default(CFG_MLO_SAME_LINK_MLD_ADDR); 2435 } 2436 2437 static bool 2438 wlan_get_vdev_link_removed_flag(struct wlan_objmgr_vdev *vdev) 2439 { 2440 bool is_mlo_link_removed = false; 2441 uint8_t link_id; 2442 struct mlo_link_info *link_info; 2443 2444 if (!mlo_is_mld_sta(vdev)) 2445 return false; 2446 2447 link_id = wlan_vdev_get_link_id(vdev); 2448 link_info = mlo_mgr_get_ap_link_by_link_id(vdev, link_id); 2449 if (link_info) 2450 is_mlo_link_removed = 2451 !!qdf_atomic_test_bit(LS_F_AP_REMOVAL_BIT, 2452 &link_info->link_status_flags); 2453 else 2454 mlme_legacy_err("link info null, id %d", link_id); 2455 2456 return is_mlo_link_removed; 2457 } 2458 2459 bool wlan_get_vdev_link_removed_flag_by_vdev_id(struct wlan_objmgr_psoc *psoc, 2460 uint8_t vdev_id) 2461 { 2462 struct wlan_objmgr_vdev *vdev; 2463 bool is_mlo_link_removed; 2464 2465 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 2466 WLAN_MLME_OBJMGR_ID); 2467 if (!vdev) { 2468 mlme_legacy_err("get vdev failed for id %d", vdev_id); 2469 return false; 2470 } 2471 2472 is_mlo_link_removed = wlan_get_vdev_link_removed_flag(vdev); 2473 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2474 2475 return is_mlo_link_removed; 2476 } 2477 2478 static QDF_STATUS 2479 wlan_set_vdev_link_removed_flag(struct wlan_objmgr_vdev *vdev, bool removed) 2480 { 2481 uint8_t link_id; 2482 struct mlo_link_info *link_info; 2483 bool is_mlo_link_removed; 2484 2485 if (!vdev) { 2486 mlme_legacy_err("vdev NULL"); 2487 return QDF_STATUS_E_INVAL; 2488 } 2489 2490 if (!mlo_is_mld_sta(vdev)) { 2491 mlme_legacy_debug("vdev not mld sta"); 2492 return QDF_STATUS_E_INVAL; 2493 } 2494 2495 link_id = wlan_vdev_get_link_id(vdev); 2496 link_info = mlo_mgr_get_ap_link_by_link_id(vdev, link_id); 2497 if (!link_info) { 2498 mlme_legacy_err("link info null, id %d", link_id); 2499 return QDF_STATUS_E_INVAL; 2500 } 2501 is_mlo_link_removed = 2502 !!qdf_atomic_test_bit(LS_F_AP_REMOVAL_BIT, 2503 &link_info->link_status_flags); 2504 if (removed == is_mlo_link_removed) 2505 return QDF_STATUS_SUCCESS; 2506 2507 mlme_legacy_debug("mlo sta vdev %d link %d link removed flag %d", 2508 wlan_vdev_get_id(vdev), link_id, removed); 2509 if (removed) 2510 qdf_atomic_set_bit(LS_F_AP_REMOVAL_BIT, 2511 &link_info->link_status_flags); 2512 else 2513 qdf_atomic_clear_bit(LS_F_AP_REMOVAL_BIT, 2514 &link_info->link_status_flags); 2515 2516 return QDF_STATUS_SUCCESS; 2517 } 2518 2519 QDF_STATUS 2520 wlan_set_vdev_link_removed_flag_by_vdev_id(struct wlan_objmgr_psoc *psoc, 2521 uint8_t vdev_id, bool removed) 2522 { 2523 struct wlan_objmgr_vdev *vdev; 2524 QDF_STATUS status; 2525 2526 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 2527 WLAN_MLME_OBJMGR_ID); 2528 if (!vdev) { 2529 mlme_legacy_err("vdev null for id %d", vdev_id); 2530 return QDF_STATUS_E_INVAL; 2531 } 2532 2533 if (!mlo_is_mld_sta(vdev)) { 2534 mlme_legacy_debug("vdev %d not mld sta", vdev_id); 2535 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2536 return QDF_STATUS_E_INVAL; 2537 } 2538 2539 status = wlan_set_vdev_link_removed_flag(vdev, removed); 2540 2541 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2542 2543 return status; 2544 } 2545 2546 void wlan_clear_mlo_sta_link_removed_flag(struct wlan_objmgr_vdev *vdev) 2547 { 2548 uint8_t i; 2549 struct mlo_link_info *link_info; 2550 2551 if (!vdev || !mlo_is_mld_sta(vdev)) 2552 return; 2553 2554 link_info = mlo_mgr_get_ap_link(vdev); 2555 if (!link_info) 2556 return; 2557 2558 for (i = 0; i < WLAN_MAX_ML_BSS_LINKS; i++) 2559 qdf_atomic_clear_bit(LS_F_AP_REMOVAL_BIT, 2560 &link_info[i].link_status_flags); 2561 } 2562 2563 bool wlan_drop_mgmt_frame_on_link_removal(struct wlan_objmgr_vdev *vdev) 2564 { 2565 if (!vdev || !mlo_is_mld_sta(vdev)) 2566 return false; 2567 2568 return wlan_get_vdev_link_removed_flag(vdev); 2569 } 2570 #else 2571 static void mlme_init_sta_mlo_cfg(struct wlan_objmgr_psoc *psoc, 2572 struct wlan_mlme_sta_cfg *sta) 2573 { 2574 } 2575 #endif 2576 2577 static void mlme_init_sta_cfg(struct wlan_objmgr_psoc *psoc, 2578 struct wlan_mlme_sta_cfg *sta) 2579 { 2580 sta->sta_keep_alive_period = 2581 cfg_get(psoc, CFG_INFRA_STA_KEEP_ALIVE_PERIOD); 2582 sta->bss_max_idle_period = 2583 (uint32_t)cfg_default(CFG_STA_BSS_MAX_IDLE_PERIOD); 2584 sta->tgt_gtx_usr_cfg = 2585 cfg_get(psoc, CFG_TGT_GTX_USR_CFG); 2586 sta->pmkid_modes = 2587 cfg_get(psoc, CFG_PMKID_MODES); 2588 sta->ignore_peer_erp_info = 2589 cfg_get(psoc, CFG_IGNORE_PEER_ERP_INFO); 2590 sta->sta_prefer_80mhz_over_160mhz = 2591 cfg_get(psoc, CFG_STA_PREFER_80MHZ_OVER_160MHZ); 2592 sta->enable_5g_ebt = 2593 cfg_get(psoc, CFG_PPS_ENABLE_5G_EBT); 2594 sta->deauth_before_connection = 2595 cfg_get(psoc, CFG_ENABLE_DEAUTH_BEFORE_CONNECTION); 2596 sta->dot11p_mode = 2597 cfg_get(psoc, CFG_DOT11P_MODE); 2598 sta->enable_go_cts2self_for_sta = 2599 cfg_get(psoc, CFG_ENABLE_GO_CTS2SELF_FOR_STA); 2600 sta->qcn_ie_support = 2601 cfg_get(psoc, CFG_QCN_IE_SUPPORT); 2602 sta->fils_max_chan_guard_time = 2603 cfg_get(psoc, CFG_FILS_MAX_CHAN_GUARD_TIME); 2604 sta->deauth_retry_cnt = cfg_get(psoc, CFG_DEAUTH_RETRY_CNT); 2605 sta->single_tid = 2606 cfg_get(psoc, CFG_SINGLE_TID_RC); 2607 sta->sta_miracast_mcc_rest_time = 2608 cfg_get(psoc, CFG_STA_MCAST_MCC_REST_TIME); 2609 sta->wait_cnf_timeout = 2610 (uint32_t)cfg_default(CFG_WT_CNF_TIMEOUT); 2611 sta->current_rssi = 2612 (uint32_t)cfg_default(CFG_CURRENT_RSSI); 2613 sta->allow_tpc_from_ap = cfg_get(psoc, CFG_TX_POWER_CTRL); 2614 sta->sta_keepalive_method = 2615 cfg_get(psoc, CFG_STA_KEEPALIVE_METHOD); 2616 sta->max_li_modulated_dtim_time_ms = 2617 cfg_get(psoc, CFG_MAX_LI_MODULATED_DTIM_MS); 2618 2619 mlme_init_sta_mlo_cfg(psoc, sta); 2620 wlan_mlme_set_epcs_capability(psoc, false); 2621 wlan_mlme_set_usr_disable_sta_eht(psoc, false); 2622 } 2623 2624 static void mlme_init_stats_cfg(struct wlan_objmgr_psoc *psoc, 2625 struct wlan_mlme_stats_cfg *stats) 2626 { 2627 stats->stats_periodic_display_time = 2628 cfg_get(psoc, CFG_PERIODIC_STATS_DISPLAY_TIME); 2629 stats->stats_link_speed_rssi_high = 2630 cfg_get(psoc, CFG_LINK_SPEED_RSSI_HIGH); 2631 stats->stats_link_speed_rssi_med = 2632 cfg_get(psoc, CFG_LINK_SPEED_RSSI_MID); 2633 stats->stats_link_speed_rssi_low = 2634 cfg_get(psoc, CFG_LINK_SPEED_RSSI_LOW); 2635 stats->stats_report_max_link_speed_rssi = 2636 cfg_get(psoc, CFG_REPORT_MAX_LINK_SPEED); 2637 } 2638 2639 #ifdef WLAN_ADAPTIVE_11R 2640 /** 2641 * mlme_init_adaptive_11r_cfg() - initialize enable_adaptive_11r 2642 * flag 2643 * @psoc: Pointer to PSOC 2644 * @lfr: pointer to mlme lfr config 2645 * 2646 * Return: None 2647 */ 2648 static void 2649 mlme_init_adaptive_11r_cfg(struct wlan_objmgr_psoc *psoc, 2650 struct wlan_mlme_lfr_cfg *lfr) 2651 { 2652 lfr->enable_adaptive_11r = cfg_get(psoc, CFG_ADAPTIVE_11R); 2653 } 2654 2655 #else 2656 static inline void 2657 mlme_init_adaptive_11r_cfg(struct wlan_objmgr_psoc *psoc, 2658 struct wlan_mlme_lfr_cfg *lfr) 2659 { 2660 } 2661 #endif 2662 2663 #if defined(WLAN_SAE_SINGLE_PMK) && defined(WLAN_FEATURE_ROAM_OFFLOAD) 2664 /** 2665 * mlme_init_sae_single_pmk_cfg() - initialize sae_same_pmk_config 2666 * flag 2667 * @psoc: Pointer to PSOC 2668 * @lfr: pointer to mlme lfr config 2669 * 2670 * Return: None 2671 */ 2672 static void 2673 mlme_init_sae_single_pmk_cfg(struct wlan_objmgr_psoc *psoc, 2674 struct wlan_mlme_lfr_cfg *lfr) 2675 { 2676 lfr->sae_single_pmk_feature_enabled = cfg_get(psoc, CFG_SAE_SINGLE_PMK); 2677 } 2678 2679 #else 2680 static inline void 2681 mlme_init_sae_single_pmk_cfg(struct wlan_objmgr_psoc *psoc, 2682 struct wlan_mlme_lfr_cfg *lfr) 2683 { 2684 } 2685 #endif 2686 2687 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 2688 static void mlme_init_roam_offload_cfg(struct wlan_objmgr_psoc *psoc, 2689 struct wlan_mlme_lfr_cfg *lfr) 2690 { 2691 bool val = false; 2692 2693 lfr->lfr3_roaming_offload = 2694 cfg_get(psoc, CFG_LFR3_ROAMING_OFFLOAD); 2695 lfr->lfr3_dual_sta_roaming_enabled = 2696 cfg_get(psoc, CFG_ENABLE_DUAL_STA_ROAM_OFFLOAD); 2697 lfr->enable_self_bss_roam = cfg_get(psoc, CFG_LFR3_ENABLE_SELF_BSS_ROAM); 2698 lfr->enable_roam_reason_vsie = 2699 cfg_get(psoc, CFG_ENABLE_ROAM_REASON_VSIE); 2700 lfr->enable_disconnect_roam_offload = 2701 cfg_get(psoc, CFG_LFR_ENABLE_DISCONNECT_ROAM); 2702 lfr->enable_idle_roam = 2703 cfg_get(psoc, CFG_LFR_ENABLE_IDLE_ROAM); 2704 lfr->idle_roam_rssi_delta = 2705 cfg_get(psoc, CFG_LFR_IDLE_ROAM_RSSI_DELTA); 2706 lfr->roam_info_stats_num = 2707 cfg_get(psoc, CFG_LFR3_ROAM_INFO_STATS_NUM); 2708 2709 ucfg_mlme_get_connection_roaming_ini_present(psoc, &val); 2710 if (val) { 2711 lfr->idle_roam_inactive_time = 2712 cfg_get(psoc, CFG_ROAM_IDLE_INACTIVE_TIME) * 1000; 2713 } else { 2714 lfr->idle_roam_inactive_time = 2715 cfg_get(psoc, CFG_LFR_IDLE_ROAM_INACTIVE_TIME); 2716 } 2717 2718 lfr->idle_data_packet_count = 2719 cfg_get(psoc, CFG_LFR_IDLE_ROAM_PACKET_COUNT); 2720 lfr->idle_roam_min_rssi = cfg_get(psoc, CFG_LFR_IDLE_ROAM_MIN_RSSI); 2721 lfr->roam_trigger_bitmap = 2722 cfg_get(psoc, CFG_ROAM_TRIGGER_BITMAP); 2723 lfr->vendor_btm_param.user_roam_reason = DISABLE_VENDOR_BTM_CONFIG; 2724 2725 lfr->idle_roam_band = cfg_get(psoc, CFG_LFR_IDLE_ROAM_BAND); 2726 lfr->sta_roam_disable = cfg_get(psoc, CFG_STA_DISABLE_ROAM); 2727 mlme_init_sae_single_pmk_cfg(psoc, lfr); 2728 qdf_mem_zero(&lfr->roam_rt_stats, sizeof(lfr->roam_rt_stats)); 2729 } 2730 2731 void 2732 wlan_mlme_defer_pmk_set_in_roaming(struct wlan_objmgr_psoc *psoc, 2733 uint8_t vdev_id, bool set_pmk_pending) 2734 { 2735 struct wlan_objmgr_vdev *vdev; 2736 struct mlme_legacy_priv *mlme_priv; 2737 2738 if (set_pmk_pending && !MLME_IS_ROAM_SYNCH_IN_PROGRESS(psoc, vdev_id)) 2739 return; 2740 2741 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 2742 WLAN_MLME_OBJMGR_ID); 2743 2744 if (!vdev) { 2745 mlme_err("get vdev failed"); 2746 return; 2747 } 2748 2749 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 2750 2751 if (!mlme_priv) { 2752 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2753 mlme_legacy_err("vdev legacy private object is NULL"); 2754 return; 2755 } 2756 2757 mlme_priv->mlme_roam.set_pmk_pending = set_pmk_pending; 2758 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2759 } 2760 2761 bool 2762 wlan_mlme_is_pmk_set_deferred(struct wlan_objmgr_psoc *psoc, 2763 uint8_t vdev_id) 2764 { 2765 struct wlan_objmgr_vdev *vdev; 2766 struct mlme_legacy_priv *mlme_priv; 2767 bool set_pmk_pending; 2768 2769 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 2770 WLAN_MLME_OBJMGR_ID); 2771 2772 if (!vdev) { 2773 mlme_err("get vdev failed"); 2774 return false; 2775 } 2776 2777 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 2778 2779 if (!mlme_priv) { 2780 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2781 mlme_legacy_err("vdev legacy private object is NULL"); 2782 return false; 2783 } 2784 2785 set_pmk_pending = mlme_priv->mlme_roam.set_pmk_pending; 2786 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 2787 2788 return set_pmk_pending; 2789 } 2790 #else 2791 static void mlme_init_roam_offload_cfg(struct wlan_objmgr_psoc *psoc, 2792 struct wlan_mlme_lfr_cfg *lfr) 2793 { 2794 } 2795 2796 #endif 2797 2798 #ifdef FEATURE_WLAN_ESE 2799 static void mlme_init_ese_cfg(struct wlan_objmgr_psoc *psoc, 2800 struct wlan_mlme_lfr_cfg *lfr) 2801 { 2802 lfr->ese_enabled = cfg_get(psoc, CFG_LFR_ESE_FEATURE_ENABLED); 2803 } 2804 #else 2805 static void mlme_init_ese_cfg(struct wlan_objmgr_psoc *psoc, 2806 struct wlan_mlme_lfr_cfg *lfr) 2807 { 2808 } 2809 #endif 2810 2811 #ifdef FEATURE_LFR_SUBNET_DETECTION 2812 static void mlme_init_subnet_detection(struct wlan_objmgr_psoc *psoc, 2813 struct wlan_mlme_lfr_cfg *lfr) 2814 { 2815 lfr->enable_lfr_subnet_detection = 2816 cfg_get(psoc, CFG_LFR3_ENABLE_SUBNET_DETECTION); 2817 } 2818 #else 2819 static void mlme_init_subnet_detection(struct wlan_objmgr_psoc *psoc, 2820 struct wlan_mlme_lfr_cfg *lfr) 2821 { 2822 } 2823 #endif 2824 2825 static void 2826 mlme_init_bss_load_trigger_params(struct wlan_objmgr_psoc *psoc, 2827 struct bss_load_trigger *bss_load_trig) 2828 { 2829 bool val = false; 2830 2831 bss_load_trig->enabled = 2832 cfg_get(psoc, CFG_ENABLE_BSS_LOAD_TRIGGERED_ROAM); 2833 bss_load_trig->threshold = cfg_get(psoc, CFG_BSS_LOAD_THRESHOLD); 2834 2835 ucfg_mlme_get_connection_roaming_ini_present(psoc, &val); 2836 if (val) 2837 bss_load_trig->sample_time = 2838 cfg_get(psoc, CFG_ROAM_CU_MONITOR_TIME) * 1000; 2839 else 2840 bss_load_trig->sample_time = cfg_get(psoc, 2841 CFG_BSS_LOAD_SAMPLE_TIME); 2842 2843 bss_load_trig->rssi_threshold_6ghz = 2844 cfg_get(psoc, CFG_BSS_LOAD_TRIG_6G_RSSI_THRES); 2845 bss_load_trig->rssi_threshold_5ghz = 2846 cfg_get(psoc, CFG_BSS_LOAD_TRIG_5G_RSSI_THRES); 2847 bss_load_trig->rssi_threshold_24ghz = 2848 cfg_get(psoc, CFG_BSS_LOAD_TRIG_2G_RSSI_THRES); 2849 } 2850 2851 void mlme_reinit_control_config_lfr_params(struct wlan_objmgr_psoc *psoc, 2852 struct wlan_mlme_lfr_cfg *lfr) 2853 { 2854 /* Restore the params set through SETDFSSCANMODE */ 2855 lfr->roaming_dfs_channel = 2856 cfg_get(psoc, CFG_LFR_ROAMING_DFS_CHANNEL); 2857 2858 /* Restore the params set through SETWESMODE */ 2859 lfr->wes_mode_enabled = cfg_get(psoc, CFG_LFR_ENABLE_WES_MODE); 2860 } 2861 2862 static void mlme_init_lfr_cfg(struct wlan_objmgr_psoc *psoc, 2863 struct wlan_mlme_lfr_cfg *lfr) 2864 { 2865 qdf_size_t neighbor_scan_chan_list_num = 0; 2866 bool val = false; 2867 2868 lfr->mawc_roam_enabled = 2869 cfg_get(psoc, CFG_LFR_MAWC_ROAM_ENABLED); 2870 lfr->enable_fast_roam_in_concurrency = 2871 cfg_get(psoc, CFG_LFR_ENABLE_FAST_ROAM_IN_CONCURRENCY); 2872 lfr->early_stop_scan_enable = 2873 cfg_get(psoc, CFG_LFR_EARLY_STOP_SCAN_ENABLE); 2874 lfr->enable_5g_band_pref = 2875 cfg_get(psoc, CFG_LFR_ENABLE_5G_BAND_PREF); 2876 lfr->lfr_enabled = cfg_get(psoc, CFG_LFR_FEATURE_ENABLED); 2877 lfr->mawc_enabled = cfg_get(psoc, CFG_LFR_MAWC_FEATURE_ENABLED); 2878 lfr->fast_transition_enabled = 2879 cfg_get(psoc, CFG_LFR_FAST_TRANSITION_ENABLED); 2880 lfr->wes_mode_enabled = cfg_get(psoc, CFG_LFR_ENABLE_WES_MODE); 2881 lfr->mawc_roam_traffic_threshold = 2882 cfg_get(psoc, CFG_LFR_MAWC_ROAM_TRAFFIC_THRESHOLD); 2883 lfr->mawc_roam_ap_rssi_threshold = 2884 cfg_get(psoc, CFG_LFR_MAWC_ROAM_AP_RSSI_THRESHOLD); 2885 lfr->mawc_roam_rssi_high_adjust = 2886 cfg_get(psoc, CFG_LFR_MAWC_ROAM_RSSI_HIGH_ADJUST); 2887 lfr->mawc_roam_rssi_low_adjust = 2888 cfg_get(psoc, CFG_LFR_MAWC_ROAM_RSSI_LOW_ADJUST); 2889 lfr->roam_rssi_abs_threshold = 2890 cfg_get(psoc, CFG_LFR_ROAM_RSSI_ABS_THRESHOLD); 2891 lfr->rssi_threshold_offset_5g = 2892 cfg_get(psoc, CFG_LFR_5G_RSSI_THRESHOLD_OFFSET); 2893 lfr->early_stop_scan_min_threshold = 2894 cfg_get(psoc, CFG_LFR_EARLY_STOP_SCAN_MIN_THRESHOLD); 2895 lfr->early_stop_scan_max_threshold = 2896 cfg_get(psoc, CFG_LFR_EARLY_STOP_SCAN_MAX_THRESHOLD); 2897 lfr->roam_dense_traffic_threshold = 2898 cfg_get(psoc, CFG_LFR_ROAM_DENSE_TRAFFIC_THRESHOLD); 2899 lfr->roam_dense_rssi_thre_offset = 2900 cfg_get(psoc, CFG_LFR_ROAM_DENSE_RSSI_THRE_OFFSET); 2901 lfr->roam_dense_min_aps = 2902 cfg_get(psoc, CFG_LFR_ROAM_DENSE_MIN_APS); 2903 lfr->roam_bg_scan_bad_rssi_threshold = 2904 cfg_get(psoc, CFG_LFR_ROAM_BG_SCAN_BAD_RSSI_THRESHOLD); 2905 lfr->roam_bg_scan_client_bitmap = 2906 cfg_get(psoc, CFG_LFR_ROAM_BG_SCAN_CLIENT_BITMAP); 2907 lfr->roam_bg_scan_bad_rssi_offset_2g = 2908 cfg_get(psoc, CFG_LFR_ROAM_BG_SCAN_BAD_RSSI_OFFSET_2G); 2909 lfr->roam_data_rssi_threshold_triggers = 2910 cfg_get(psoc, CFG_ROAM_DATA_RSSI_THRESHOLD_TRIGGERS); 2911 lfr->roam_data_rssi_threshold = 2912 cfg_get(psoc, CFG_ROAM_DATA_RSSI_THRESHOLD); 2913 lfr->rx_data_inactivity_time = 2914 cfg_get(psoc, CFG_RX_DATA_INACTIVITY_TIME); 2915 lfr->adaptive_roamscan_dwell_mode = 2916 cfg_get(psoc, CFG_LFR_ADAPTIVE_ROAMSCAN_DWELL_MODE); 2917 lfr->per_roam_enable = 2918 cfg_get(psoc, CFG_LFR_PER_ROAM_ENABLE); 2919 lfr->per_roam_config_high_rate_th = 2920 cfg_get(psoc, CFG_LFR_PER_ROAM_CONFIG_HIGH_RATE_TH); 2921 lfr->per_roam_config_low_rate_th = 2922 cfg_get(psoc, CFG_LFR_PER_ROAM_CONFIG_LOW_RATE_TH); 2923 lfr->per_roam_config_rate_th_percent = 2924 cfg_get(psoc, CFG_LFR_PER_ROAM_CONFIG_RATE_TH_PERCENT); 2925 lfr->per_roam_rest_time = 2926 cfg_get(psoc, CFG_LFR_PER_ROAM_REST_TIME); 2927 lfr->per_roam_monitor_time = 2928 cfg_get(psoc, CFG_LFR_PER_ROAM_MONITOR_TIME); 2929 lfr->per_roam_min_candidate_rssi = 2930 cfg_get(psoc, CFG_LFR_PER_ROAM_MIN_CANDIDATE_RSSI); 2931 lfr->lfr3_disallow_duration = 2932 cfg_get(psoc, CFG_LFR3_ROAM_DISALLOW_DURATION); 2933 lfr->lfr3_rssi_channel_penalization = 2934 cfg_get(psoc, CFG_LFR3_ROAM_RSSI_CHANNEL_PENALIZATION); 2935 lfr->lfr3_num_disallowed_aps = 2936 cfg_get(psoc, CFG_LFR3_ROAM_NUM_DISALLOWED_APS); 2937 2938 if (lfr->enable_5g_band_pref) { 2939 lfr->rssi_boost_threshold_5g = 2940 cfg_get(psoc, CFG_LFR_5G_RSSI_BOOST_THRESHOLD); 2941 lfr->rssi_boost_factor_5g = 2942 cfg_get(psoc, CFG_LFR_5G_RSSI_BOOST_FACTOR); 2943 lfr->max_rssi_boost_5g = 2944 cfg_get(psoc, CFG_LFR_5G_MAX_RSSI_BOOST); 2945 lfr->rssi_penalize_threshold_5g = 2946 cfg_get(psoc, CFG_LFR_5G_RSSI_PENALIZE_THRESHOLD); 2947 lfr->rssi_penalize_factor_5g = 2948 cfg_get(psoc, CFG_LFR_5G_RSSI_PENALIZE_FACTOR); 2949 lfr->max_rssi_penalize_5g = 2950 cfg_get(psoc, CFG_LFR_5G_MAX_RSSI_PENALIZE); 2951 } 2952 2953 lfr->max_num_pre_auth = (uint32_t) 2954 cfg_default(CFG_LFR_MAX_NUM_PRE_AUTH); 2955 lfr->roam_preauth_no_ack_timeout = 2956 cfg_get(psoc, CFG_LFR3_ROAM_PREAUTH_NO_ACK_TIMEOUT); 2957 lfr->roam_preauth_retry_count = 2958 cfg_get(psoc, CFG_LFR3_ROAM_PREAUTH_RETRY_COUNT); 2959 lfr->roam_rssi_diff = cfg_get(psoc, CFG_LFR_ROAM_RSSI_DIFF); 2960 lfr->roam_rssi_diff_6ghz = cfg_get(psoc, CFG_LFR_ROAM_RSSI_DIFF_6GHZ); 2961 lfr->bg_rssi_threshold = cfg_get(psoc, CFG_LFR_ROAM_BG_RSSI_TH); 2962 lfr->roam_scan_offload_enabled = 2963 cfg_get(psoc, CFG_LFR_ROAM_SCAN_OFFLOAD_ENABLED); 2964 lfr->neighbor_scan_timer_period = 2965 cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_TIMER_PERIOD); 2966 lfr->neighbor_scan_min_timer_period = 2967 cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_MIN_TIMER_PERIOD); 2968 lfr->neighbor_lookup_rssi_threshold = 2969 abs(cfg_get(psoc, CFG_LFR_NEIGHBOR_LOOKUP_RSSI_THRESHOLD)); 2970 lfr->opportunistic_scan_threshold_diff = 2971 cfg_get(psoc, CFG_LFR_OPPORTUNISTIC_SCAN_THRESHOLD_DIFF); 2972 lfr->roam_rescan_rssi_diff = 2973 cfg_get(psoc, CFG_LFR_ROAM_RESCAN_RSSI_DIFF); 2974 lfr->neighbor_scan_min_chan_time = 2975 cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_MIN_CHAN_TIME); 2976 lfr->neighbor_scan_max_chan_time = 2977 cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_MAX_CHAN_TIME); 2978 lfr->passive_max_channel_time = 2979 cfg_get(psoc, CFG_ROAM_PASSIVE_MAX_CHANNEL_TIME); 2980 lfr->neighbor_scan_results_refresh_period = 2981 cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_RESULTS_REFRESH_PERIOD); 2982 2983 ucfg_mlme_get_connection_roaming_ini_present(psoc, &val); 2984 if (val) 2985 lfr->empty_scan_refresh_period = 2986 cfg_get(psoc, CFG_ROAM_SCAN_FIRST_TIMER) * 1000; 2987 else 2988 lfr->empty_scan_refresh_period = 2989 cfg_get(psoc, CFG_LFR_EMPTY_SCAN_REFRESH_PERIOD); 2990 lfr->roam_bmiss_first_bcnt = 2991 cfg_get(psoc, CFG_LFR_ROAM_BMISS_FIRST_BCNT); 2992 lfr->roam_bmiss_final_bcnt = 2993 cfg_get(psoc, CFG_LFR_ROAM_BMISS_FINAL_BCNT); 2994 lfr->roaming_dfs_channel = 2995 cfg_get(psoc, CFG_LFR_ROAMING_DFS_CHANNEL); 2996 lfr->roam_scan_hi_rssi_maxcount = 2997 cfg_get(psoc, CFG_LFR_ROAM_SCAN_HI_RSSI_MAXCOUNT); 2998 lfr->roam_scan_hi_rssi_delta = 2999 cfg_get(psoc, CFG_LFR_ROAM_SCAN_HI_RSSI_DELTA); 3000 lfr->roam_scan_hi_rssi_delay = 3001 cfg_get(psoc, CFG_LFR_ROAM_SCAN_HI_RSSI_DELAY); 3002 lfr->roam_scan_hi_rssi_ub = 3003 cfg_get(psoc, CFG_LFR_ROAM_SCAN_HI_RSSI_UB); 3004 lfr->roam_prefer_5ghz = 3005 cfg_get(psoc, CFG_LFR_ROAM_PREFER_5GHZ); 3006 lfr->roam_intra_band = 3007 cfg_get(psoc, CFG_LFR_ROAM_INTRA_BAND); 3008 lfr->roam_scan_home_away_time = 3009 cfg_get(psoc, CFG_LFR_ROAM_SCAN_HOME_AWAY_TIME); 3010 lfr->roam_scan_n_probes = 3011 cfg_get(psoc, CFG_LFR_ROAM_SCAN_N_PROBES); 3012 lfr->delay_before_vdev_stop = 3013 cfg_get(psoc, CFG_LFR_DELAY_BEFORE_VDEV_STOP); 3014 qdf_uint8_array_parse(cfg_get(psoc, CFG_LFR_NEIGHBOR_SCAN_CHANNEL_LIST), 3015 lfr->neighbor_scan_channel_list, 3016 CFG_VALID_CHANNEL_LIST_LEN, 3017 &neighbor_scan_chan_list_num); 3018 lfr->neighbor_scan_channel_list_num = 3019 (uint8_t)neighbor_scan_chan_list_num; 3020 lfr->ho_delay_for_rx = 3021 cfg_get(psoc, CFG_LFR3_ROAM_HO_DELAY_FOR_RX); 3022 lfr->min_delay_btw_roam_scans = 3023 cfg_get(psoc, CFG_LFR_MIN_DELAY_BTW_ROAM_SCAN); 3024 lfr->roam_trigger_reason_bitmask = 3025 cfg_get(psoc, CFG_LFR_ROAM_SCAN_TRIGGER_REASON_BITMASK); 3026 lfr->enable_ftopen = 3027 cfg_get(psoc, CFG_LFR_ROAM_FT_OPEN_ENABLE); 3028 lfr->roam_force_rssi_trigger = 3029 cfg_get(psoc, CFG_LFR_ROAM_FORCE_RSSI_TRIGGER); 3030 lfr->roaming_scan_policy = 3031 cfg_get(psoc, CFG_ROAM_SCAN_SCAN_POLICY); 3032 3033 if (val) 3034 lfr->roam_scan_inactivity_time = 3035 cfg_get(psoc, CFG_ROAM_SCAN_INACTIVE_TIMER) * 1000; 3036 else 3037 lfr->roam_scan_inactivity_time = 3038 cfg_get(psoc, CFG_ROAM_SCAN_INACTIVITY_TIME); 3039 3040 lfr->roam_inactive_data_packet_count = 3041 cfg_get(psoc, CFG_ROAM_INACTIVE_COUNT); 3042 3043 lfr->fw_akm_bitmap = 0; 3044 lfr->enable_ft_im_roaming = cfg_get(psoc, CFG_FT_IM_ROAMING); 3045 lfr->enable_ft_over_ds = !ENABLE_FT_OVER_DS; 3046 3047 mlme_init_roam_offload_cfg(psoc, lfr); 3048 mlme_init_ese_cfg(psoc, lfr); 3049 mlme_init_bss_load_trigger_params(psoc, &lfr->bss_load_trig); 3050 mlme_init_adaptive_11r_cfg(psoc, lfr); 3051 mlme_init_subnet_detection(psoc, lfr); 3052 lfr->rso_user_config.cat_rssi_offset = DEFAULT_RSSI_DB_GAP; 3053 lfr->beaconloss_timeout_onwakeup = 3054 cfg_get(psoc, CFG_LFR_BEACONLOSS_TIMEOUT_ON_WAKEUP); 3055 lfr->beaconloss_timeout_onsleep = 3056 cfg_get(psoc, CFG_LFR_BEACONLOSS_TIMEOUT_ON_SLEEP); 3057 } 3058 3059 static void mlme_init_power_cfg(struct wlan_objmgr_psoc *psoc, 3060 struct wlan_mlme_power *power) 3061 { 3062 power->tx_power_2g = cfg_get(psoc, CFG_SET_TXPOWER_LIMIT2G); 3063 power->tx_power_5g = cfg_get(psoc, CFG_SET_TXPOWER_LIMIT5G); 3064 3065 power->max_tx_power_24_chan.max_len = CFG_MAX_TX_POWER_2_4_LEN; 3066 qdf_uint8_array_parse(cfg_default(CFG_MAX_TX_POWER_2_4), 3067 power->max_tx_power_24_chan.data, 3068 sizeof(power->max_tx_power_24_chan.data), 3069 &power->max_tx_power_24_chan.len); 3070 3071 power->max_tx_power_5_chan.max_len = CFG_MAX_TX_POWER_5_LEN; 3072 qdf_uint8_array_parse(cfg_default(CFG_MAX_TX_POWER_5), 3073 power->max_tx_power_5_chan.data, 3074 sizeof(power->max_tx_power_5_chan.data), 3075 &power->max_tx_power_5_chan.len); 3076 3077 power->power_usage.max_len = CFG_POWER_USAGE_MAX_LEN; 3078 power->power_usage.len = CFG_POWER_USAGE_MAX_LEN; 3079 qdf_mem_copy(power->power_usage.data, cfg_get(psoc, CFG_POWER_USAGE), 3080 power->power_usage.len); 3081 power->current_tx_power_level = 3082 (uint8_t)cfg_default(CFG_CURRENT_TX_POWER_LEVEL); 3083 power->local_power_constraint = 3084 (uint8_t)cfg_default(CFG_LOCAL_POWER_CONSTRAINT); 3085 power->skip_tpe = cfg_get(psoc, CFG_SKIP_TPE_CONSIDERATION); 3086 } 3087 3088 static void mlme_init_roam_scoring_cfg(struct wlan_objmgr_psoc *psoc, 3089 struct wlan_mlme_roam_scoring_cfg *scoring_cfg) 3090 { 3091 bool val = false; 3092 3093 scoring_cfg->enable_scoring_for_roam = 3094 cfg_get(psoc, CFG_ENABLE_SCORING_FOR_ROAM); 3095 scoring_cfg->roam_trigger_bitmap = 3096 cfg_get(psoc, CFG_ROAM_SCORE_DELTA_TRIGGER_BITMAP); 3097 scoring_cfg->roam_score_delta = cfg_get(psoc, CFG_ROAM_SCORE_DELTA); 3098 scoring_cfg->apsd_enabled = (bool)cfg_default(CFG_APSD_ENABLED); 3099 3100 ucfg_mlme_get_connection_roaming_ini_present(psoc, &val); 3101 if (val) { 3102 scoring_cfg->min_roam_score_delta = 3103 cfg_get(psoc, CFG_ROAM_COMMON_MIN_ROAM_DELTA) * 100; 3104 } else { 3105 scoring_cfg->min_roam_score_delta = 3106 cfg_get(psoc, CFG_CAND_MIN_ROAM_SCORE_DELTA); 3107 } 3108 } 3109 3110 static void mlme_init_oce_cfg(struct wlan_objmgr_psoc *psoc, 3111 struct wlan_mlme_oce *oce) 3112 { 3113 uint8_t val; 3114 bool rssi_assoc_reject_enabled; 3115 bool probe_req_rate_enabled; 3116 bool probe_resp_rate_enabled; 3117 bool beacon_rate_enabled; 3118 bool probe_req_deferral_enabled; 3119 bool fils_discovery_sap_enabled; 3120 bool esp_for_roam_enabled; 3121 3122 oce->enable_bcast_probe_rsp = 3123 cfg_get(psoc, CFG_ENABLE_BCAST_PROBE_RESP); 3124 oce->oce_sta_enabled = cfg_get(psoc, CFG_OCE_ENABLE_STA); 3125 oce->oce_sap_enabled = cfg_get(psoc, CFG_OCE_ENABLE_SAP); 3126 oce->fils_enabled = cfg_get(psoc, CFG_IS_FILS_ENABLED); 3127 3128 rssi_assoc_reject_enabled = 3129 cfg_get(psoc, CFG_OCE_ENABLE_RSSI_BASED_ASSOC_REJECT); 3130 probe_req_rate_enabled = cfg_get(psoc, CFG_OCE_PROBE_REQ_RATE); 3131 probe_resp_rate_enabled = cfg_get(psoc, CFG_OCE_PROBE_RSP_RATE); 3132 beacon_rate_enabled = cfg_get(psoc, CFG_OCE_BEACON_RATE); 3133 probe_req_deferral_enabled = 3134 cfg_get(psoc, CFG_ENABLE_PROBE_REQ_DEFERRAL); 3135 fils_discovery_sap_enabled = 3136 cfg_get(psoc, CFG_ENABLE_FILS_DISCOVERY_SAP); 3137 esp_for_roam_enabled = cfg_get(psoc, CFG_ENABLE_ESP_FEATURE); 3138 3139 if (!rssi_assoc_reject_enabled || 3140 !oce->enable_bcast_probe_rsp) { 3141 oce->oce_sta_enabled = 0; 3142 } 3143 3144 val = (probe_req_rate_enabled * 3145 WMI_VDEV_OCE_PROBE_REQUEST_RATE_FEATURE_BITMAP) + 3146 (probe_resp_rate_enabled * 3147 WMI_VDEV_OCE_PROBE_RESPONSE_RATE_FEATURE_BITMAP) + 3148 (beacon_rate_enabled * 3149 WMI_VDEV_OCE_BEACON_RATE_FEATURE_BITMAP) + 3150 (probe_req_deferral_enabled * 3151 WMI_VDEV_OCE_PROBE_REQUEST_DEFERRAL_FEATURE_BITMAP) + 3152 (fils_discovery_sap_enabled * 3153 WMI_VDEV_OCE_FILS_DISCOVERY_FRAME_FEATURE_BITMAP) + 3154 (esp_for_roam_enabled * 3155 WMI_VDEV_OCE_ESP_FEATURE_BITMAP) + 3156 (rssi_assoc_reject_enabled * 3157 WMI_VDEV_OCE_REASSOC_REJECT_FEATURE_BITMAP); 3158 oce->feature_bitmap = val; 3159 } 3160 3161 static void mlme_init_nss_chains(struct wlan_objmgr_psoc *psoc, 3162 struct wlan_mlme_nss_chains *nss_chains) 3163 { 3164 nss_chains->num_rx_chains[NSS_CHAINS_BAND_2GHZ] = 3165 cfg_get(psoc, CFG_NUM_RX_CHAINS_2G); 3166 nss_chains->num_rx_chains[NSS_CHAINS_BAND_5GHZ] = 3167 cfg_get(psoc, CFG_NUM_RX_CHAINS_5G); 3168 nss_chains->num_tx_chains[NSS_CHAINS_BAND_2GHZ] = 3169 cfg_get(psoc, CFG_NUM_TX_CHAINS_2G); 3170 nss_chains->num_tx_chains[NSS_CHAINS_BAND_5GHZ] = 3171 cfg_get(psoc, CFG_NUM_TX_CHAINS_5G); 3172 3173 nss_chains->tx_nss[NSS_CHAINS_BAND_2GHZ] = cfg_get(psoc, CFG_TX_NSS_2G); 3174 nss_chains->tx_nss[NSS_CHAINS_BAND_5GHZ] = cfg_get(psoc, CFG_TX_NSS_5G); 3175 nss_chains->rx_nss[NSS_CHAINS_BAND_2GHZ] = cfg_get(psoc, CFG_RX_NSS_2G); 3176 nss_chains->rx_nss[NSS_CHAINS_BAND_5GHZ] = cfg_get(psoc, CFG_RX_NSS_5G); 3177 3178 nss_chains->num_tx_chains_11b = cfg_get(psoc, CFG_NUM_TX_CHAINS_11b); 3179 nss_chains->num_tx_chains_11g = cfg_get(psoc, CFG_NUM_TX_CHAINS_11g); 3180 nss_chains->num_tx_chains_11a = cfg_get(psoc, CFG_NUM_TX_CHAINS_11a); 3181 3182 nss_chains->disable_rx_mrc[NSS_CHAINS_BAND_2GHZ] = 3183 cfg_get(psoc, CFG_DISABLE_RX_MRC_2G); 3184 nss_chains->disable_rx_mrc[NSS_CHAINS_BAND_5GHZ] = 3185 cfg_get(psoc, CFG_DISABLE_RX_MRC_5G); 3186 nss_chains->disable_tx_mrc[NSS_CHAINS_BAND_2GHZ] = 3187 cfg_get(psoc, CFG_DISABLE_TX_MRC_2G); 3188 nss_chains->disable_tx_mrc[NSS_CHAINS_BAND_5GHZ] = 3189 cfg_get(psoc, CFG_DISABLE_TX_MRC_5G); 3190 nss_chains->enable_dynamic_nss_chains_cfg = 3191 cfg_get(psoc, CFG_ENABLE_DYNAMIC_NSS_CHAIN_CONFIG); 3192 nss_chains->restart_sap_on_dyn_nss_chains_cfg = 3193 cfg_get(psoc, 3194 CFG_RESTART_SAP_ON_DYNAMIC_NSS_CHAINS_CONFIG); 3195 } 3196 3197 static void mlme_init_wep_cfg(struct wlan_mlme_wep_cfg *wep_params) 3198 { 3199 wep_params->is_privacy_enabled = cfg_default(CFG_PRIVACY_ENABLED); 3200 wep_params->auth_type = cfg_default(CFG_AUTHENTICATION_TYPE); 3201 wep_params->is_shared_key_auth = 3202 cfg_default(CFG_SHARED_KEY_AUTH_ENABLE); 3203 wep_params->is_auth_open_system = 3204 cfg_default(CFG_OPEN_SYSTEM_AUTH_ENABLE); 3205 3206 wep_params->wep_default_key_id = cfg_default(CFG_WEP_DEFAULT_KEYID); 3207 } 3208 3209 #if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT) 3210 static void 3211 mlme_init_wifi_pos_11az_config(struct wlan_objmgr_psoc *psoc, 3212 struct wlan_mlme_wifi_pos_cfg *wifi_pos_cfg) 3213 { 3214 bool rsta_sec_ltf_enabled = 3215 cfg_get(psoc, CFG_RESPONDER_SECURE_LTF_SUPPORT); 3216 bool rsta_11az_ranging_enabled = cfg_get(psoc, 3217 CFG_RESPONDER_11AZ_SUPPORT); 3218 3219 wifi_pos_set_rsta_11az_ranging_cap(rsta_11az_ranging_enabled); 3220 wifi_pos_set_rsta_sec_ltf_cap(rsta_sec_ltf_enabled); 3221 } 3222 #else 3223 static inline void 3224 mlme_init_wifi_pos_11az_config(struct wlan_objmgr_psoc *psoc, 3225 struct wlan_mlme_wifi_pos_cfg *wifi_pos_cfg) 3226 {} 3227 #endif 3228 3229 static void mlme_init_wifi_pos_cfg(struct wlan_objmgr_psoc *psoc, 3230 struct wlan_mlme_wifi_pos_cfg *wifi_pos_cfg) 3231 { 3232 wifi_pos_cfg->fine_time_meas_cap = 3233 cfg_get(psoc, CFG_FINE_TIME_MEAS_CAPABILITY); 3234 wifi_pos_cfg->oem_6g_support_disable = 3235 cfg_get(psoc, CFG_OEM_SIXG_SUPPORT_DISABLE); 3236 3237 mlme_init_wifi_pos_11az_config(psoc, wifi_pos_cfg); 3238 } 3239 3240 #ifdef FEATURE_WLAN_ESE 3241 static void mlme_init_inactivity_intv(struct wlan_objmgr_psoc *psoc, 3242 struct wlan_mlme_wmm_params *wmm_params) 3243 { 3244 wmm_params->wmm_tspec_element.inactivity_intv = 3245 cfg_get(psoc, CFG_QOS_WMM_INACTIVITY_INTERVAL); 3246 } 3247 #else 3248 static inline void 3249 mlme_init_inactivity_intv(struct wlan_objmgr_psoc *psoc, 3250 struct wlan_mlme_wmm_params *wmm_params) 3251 { 3252 } 3253 #endif /* FEATURE_WLAN_ESE */ 3254 3255 static void mlme_init_wmm_in_cfg(struct wlan_objmgr_psoc *psoc, 3256 struct wlan_mlme_wmm_params *wmm_params) 3257 { 3258 wmm_params->qos_enabled = cfg_default(CFG_QOS_ENABLED); 3259 wmm_params->wme_enabled = cfg_default(CFG_WME_ENABLED); 3260 wmm_params->max_sp_length = cfg_default(CFG_MAX_SP_LENGTH); 3261 wmm_params->wsm_enabled = cfg_default(CFG_WSM_ENABLED); 3262 wmm_params->edca_profile = cfg_default(CFG_EDCA_PROFILE); 3263 3264 wmm_params->ac_vo.dir_ac_vo = cfg_get(psoc, CFG_QOS_WMM_DIR_AC_VO); 3265 wmm_params->ac_vo.nom_msdu_size_ac_vo = 3266 cfg_get(psoc, CFG_QOS_WMM_NOM_MSDU_SIZE_AC_VO); 3267 wmm_params->ac_vo.mean_data_rate_ac_vo = 3268 cfg_get(psoc, CFG_QOS_WMM_MEAN_DATA_RATE_AC_VO); 3269 wmm_params->ac_vo.min_phy_rate_ac_vo = 3270 cfg_get(psoc, CFG_QOS_WMM_MIN_PHY_RATE_AC_VO); 3271 wmm_params->ac_vo.sba_ac_vo = cfg_get(psoc, CFG_QOS_WMM_SBA_AC_VO); 3272 wmm_params->ac_vo.uapsd_vo_srv_intv = 3273 cfg_get(psoc, CFG_QOS_WMM_UAPSD_VO_SRV_INTV); 3274 wmm_params->ac_vo.uapsd_vo_sus_intv = 3275 cfg_get(psoc, CFG_QOS_WMM_UAPSD_VO_SUS_INTV); 3276 3277 wmm_params->ac_vi.dir_ac_vi = 3278 cfg_get(psoc, CFG_QOS_WMM_DIR_AC_VI); 3279 wmm_params->ac_vi.nom_msdu_size_ac_vi = 3280 cfg_get(psoc, CFG_QOS_WMM_NOM_MSDU_SIZE_AC_VI); 3281 wmm_params->ac_vi.mean_data_rate_ac_vi = 3282 cfg_get(psoc, CFG_QOS_WMM_MEAN_DATA_RATE_AC_VI); 3283 wmm_params->ac_vi.min_phy_rate_ac_vi = 3284 cfg_get(psoc, CFG_QOS_WMM_MIN_PHY_RATE_AC_VI); 3285 wmm_params->ac_vi.sba_ac_vi = 3286 cfg_get(psoc, CFG_QOS_WMM_SBA_AC_VI); 3287 wmm_params->ac_vi.uapsd_vi_srv_intv = 3288 cfg_get(psoc, CFG_QOS_WMM_UAPSD_VI_SRV_INTV); 3289 wmm_params->ac_vi.uapsd_vi_sus_intv = 3290 cfg_get(psoc, CFG_QOS_WMM_UAPSD_VI_SUS_INTV); 3291 3292 wmm_params->ac_be.dir_ac_be = 3293 cfg_get(psoc, CFG_QOS_WMM_DIR_AC_BE); 3294 wmm_params->ac_be.nom_msdu_size_ac_be = 3295 cfg_get(psoc, CFG_QOS_WMM_NOM_MSDU_SIZE_AC_BE); 3296 wmm_params->ac_be.mean_data_rate_ac_be = 3297 cfg_get(psoc, CFG_QOS_WMM_MEAN_DATA_RATE_AC_BE); 3298 wmm_params->ac_be.min_phy_rate_ac_be = 3299 cfg_get(psoc, CFG_QOS_WMM_MIN_PHY_RATE_AC_BE); 3300 wmm_params->ac_be.sba_ac_be = 3301 cfg_get(psoc, CFG_QOS_WMM_SBA_AC_BE); 3302 wmm_params->ac_be.uapsd_be_srv_intv = 3303 cfg_get(psoc, CFG_QOS_WMM_UAPSD_BE_SRV_INTV); 3304 wmm_params->ac_be.uapsd_be_sus_intv = 3305 cfg_get(psoc, CFG_QOS_WMM_UAPSD_BE_SUS_INTV); 3306 3307 wmm_params->ac_bk.dir_ac_bk = 3308 cfg_get(psoc, CFG_QOS_WMM_DIR_AC_BK); 3309 wmm_params->ac_bk.nom_msdu_size_ac_bk = 3310 cfg_get(psoc, CFG_QOS_WMM_NOM_MSDU_SIZE_AC_BK); 3311 wmm_params->ac_bk.mean_data_rate_ac_bk = 3312 cfg_get(psoc, CFG_QOS_WMM_MEAN_DATA_RATE_AC_BK); 3313 wmm_params->ac_bk.min_phy_rate_ac_bk = 3314 cfg_get(psoc, CFG_QOS_WMM_MIN_PHY_RATE_AC_BK); 3315 wmm_params->ac_bk.sba_ac_bk = 3316 cfg_get(psoc, CFG_QOS_WMM_SBA_AC_BK); 3317 wmm_params->ac_bk.uapsd_bk_srv_intv = 3318 cfg_get(psoc, CFG_QOS_WMM_UAPSD_BK_SRV_INTV); 3319 wmm_params->ac_bk.uapsd_bk_sus_intv = 3320 cfg_get(psoc, CFG_QOS_WMM_UAPSD_BK_SUS_INTV); 3321 3322 wmm_params->wmm_config.wmm_mode = 3323 cfg_get(psoc, CFG_QOS_WMM_MODE); 3324 wmm_params->wmm_config.b80211e_is_enabled = 3325 cfg_get(psoc, CFG_QOS_WMM_80211E_ENABLED); 3326 wmm_params->wmm_config.uapsd_mask = 3327 cfg_get(psoc, CFG_QOS_WMM_UAPSD_MASK); 3328 3329 mlme_init_inactivity_intv(psoc, wmm_params); 3330 wmm_params->wmm_tspec_element.burst_size_def = 3331 cfg_get(psoc, CFG_QOS_WMM_BURST_SIZE_DEFN); 3332 wmm_params->wmm_tspec_element.ts_ack_policy = 3333 cfg_get(psoc, CFG_QOS_WMM_TS_INFO_ACK_POLICY); 3334 wmm_params->wmm_tspec_element.ts_acm_is_off = 3335 cfg_get(psoc, CFG_QOS_ADDTS_WHEN_ACM_IS_OFF); 3336 wmm_params->delayed_trigger_frm_int = 3337 cfg_get(psoc, CFG_TL_DELAYED_TRGR_FRM_INTERVAL); 3338 3339 } 3340 3341 static void mlme_init_wps_params_cfg(struct wlan_objmgr_psoc *psoc, 3342 struct wlan_mlme_wps_params *wps_params) 3343 { 3344 wps_params->enable_wps = cfg_default(CFG_WPS_ENABLE); 3345 wps_params->wps_cfg_method = cfg_default(CFG_WPS_CFG_METHOD); 3346 wps_params->wps_device_password_id = 3347 cfg_default(CFG_WPS_DEVICE_PASSWORD_ID); 3348 wps_params->wps_device_sub_category = 3349 cfg_default(CFG_WPS_DEVICE_SUB_CATEGORY); 3350 wps_params->wps_primary_device_category = 3351 cfg_default(CFG_WPS_PRIMARY_DEVICE_CATEGORY); 3352 wps_params->wps_primary_device_oui = 3353 cfg_default(CFG_WPS_PIMARY_DEVICE_OUI); 3354 wps_params->wps_state = cfg_default(CFG_WPS_STATE); 3355 wps_params->wps_version = cfg_default(CFG_WPS_VERSION); 3356 wps_params->wps_uuid.max_len = MLME_CFG_WPS_UUID_MAX_LEN; 3357 qdf_uint8_array_parse(cfg_default(CFG_WPS_UUID), 3358 wps_params->wps_uuid.data, 3359 MLME_CFG_WPS_UUID_MAX_LEN, 3360 &wps_params->wps_uuid.len); 3361 } 3362 3363 static void mlme_init_btm_cfg(struct wlan_objmgr_psoc *psoc, 3364 struct wlan_mlme_btm *btm) 3365 { 3366 btm->btm_offload_config = cfg_get(psoc, CFG_BTM_ENABLE); 3367 btm->prefer_btm_query = cfg_get(psoc, CFG_PREFER_BTM_QUERY); 3368 if (btm->prefer_btm_query) 3369 MLME_SET_BIT(btm->btm_offload_config, BTM_OFFLOAD_CONFIG_BIT_8); 3370 3371 btm->abridge_flag = cfg_get(psoc, CFG_ENABLE_BTM_ABRIDGE); 3372 if (btm->abridge_flag) 3373 MLME_SET_BIT(btm->btm_offload_config, BTM_OFFLOAD_CONFIG_BIT_7); 3374 3375 btm->btm_solicited_timeout = cfg_get(psoc, CFG_BTM_SOLICITED_TIMEOUT); 3376 btm->btm_max_attempt_cnt = cfg_get(psoc, CFG_BTM_MAX_ATTEMPT_CNT); 3377 btm->btm_sticky_time = cfg_get(psoc, CFG_BTM_STICKY_TIME); 3378 btm->rct_validity_timer = cfg_get(psoc, CFG_BTM_VALIDITY_TIMER); 3379 btm->disassoc_timer_threshold = 3380 cfg_get(psoc, CFG_BTM_DISASSOC_TIMER_THRESHOLD); 3381 btm->btm_query_bitmask = cfg_get(psoc, CFG_BTM_QUERY_BITMASK); 3382 btm->btm_trig_min_candidate_score = 3383 cfg_get(psoc, CFG_MIN_BTM_CANDIDATE_SCORE); 3384 } 3385 3386 static void 3387 mlme_init_roam_score_config(struct wlan_objmgr_psoc *psoc, 3388 struct wlan_mlme_cfg *mlme_cfg) 3389 { 3390 struct roam_trigger_score_delta *score_delta_param; 3391 struct roam_trigger_min_rssi *min_rssi_param; 3392 3393 score_delta_param = &mlme_cfg->trig_score_delta[IDLE_ROAM_TRIGGER]; 3394 score_delta_param->roam_score_delta = 3395 cfg_get(psoc, CFG_IDLE_ROAM_SCORE_DELTA); 3396 score_delta_param->trigger_reason = ROAM_TRIGGER_REASON_IDLE; 3397 3398 score_delta_param = &mlme_cfg->trig_score_delta[BTM_ROAM_TRIGGER]; 3399 score_delta_param->roam_score_delta = 3400 cfg_get(psoc, CFG_BTM_ROAM_SCORE_DELTA); 3401 score_delta_param->trigger_reason = ROAM_TRIGGER_REASON_BTM; 3402 3403 min_rssi_param = &mlme_cfg->trig_min_rssi[DEAUTH_MIN_RSSI]; 3404 min_rssi_param->min_rssi = 3405 cfg_get(psoc, CFG_DISCONNECT_ROAM_TRIGGER_MIN_RSSI); 3406 min_rssi_param->trigger_reason = ROAM_TRIGGER_REASON_DEAUTH; 3407 3408 min_rssi_param = &mlme_cfg->trig_min_rssi[BMISS_MIN_RSSI]; 3409 min_rssi_param->min_rssi = 3410 cfg_get(psoc, CFG_BMISS_ROAM_MIN_RSSI); 3411 min_rssi_param->trigger_reason = ROAM_TRIGGER_REASON_BMISS; 3412 3413 min_rssi_param = &mlme_cfg->trig_min_rssi[MIN_RSSI_2G_TO_5G_ROAM]; 3414 min_rssi_param->min_rssi = 3415 cfg_get(psoc, CFG_2G_TO_5G_ROAM_MIN_RSSI); 3416 min_rssi_param->trigger_reason = ROAM_TRIGGER_REASON_HIGH_RSSI; 3417 3418 } 3419 3420 #ifdef MULTI_CLIENT_LL_SUPPORT 3421 static void 3422 mlme_init_wlm_multi_client_ll_support(struct wlan_objmgr_psoc *psoc, 3423 struct wlan_mlme_fe_wlm *wlm_config) 3424 { 3425 wlm_config->multi_client_ll_support = 3426 cfg_get(psoc, CFG_WLM_MULTI_CLIENT_LL_SUPPORT); 3427 } 3428 3429 QDF_STATUS 3430 mlme_get_cfg_multi_client_ll_ini_support(struct wlan_objmgr_psoc *psoc, 3431 bool *multi_client_ll_support) 3432 { 3433 struct wlan_mlme_psoc_ext_obj *mlme_obj; 3434 3435 mlme_obj = mlme_get_psoc_ext_obj(psoc); 3436 if (!mlme_obj) 3437 return QDF_STATUS_E_FAILURE; 3438 3439 *multi_client_ll_support = 3440 mlme_obj->cfg.wlm_config.multi_client_ll_support; 3441 3442 return QDF_STATUS_SUCCESS; 3443 } 3444 #else 3445 static inline void 3446 mlme_init_wlm_multi_client_ll_support(struct wlan_objmgr_psoc *psoc, 3447 struct wlan_mlme_fe_wlm *wlm_config) 3448 { 3449 } 3450 #endif 3451 3452 /** 3453 * mlme_init_fe_wlm_in_cfg() - Populate WLM INI in MLME cfg 3454 * @psoc: pointer to the psoc object 3455 * @wlm_config: pointer to the MLME WLM cfg 3456 * 3457 * Return: None 3458 */ 3459 static void mlme_init_fe_wlm_in_cfg(struct wlan_objmgr_psoc *psoc, 3460 struct wlan_mlme_fe_wlm *wlm_config) 3461 { 3462 uint64_t flags = 0; 3463 QDF_STATUS status; 3464 3465 wlm_config->latency_enable = cfg_get(psoc, CFG_LATENCY_ENABLE); 3466 wlm_config->latency_reset = cfg_get(psoc, CFG_LATENCY_RESET); 3467 wlm_config->latency_level = cfg_get(psoc, CFG_LATENCY_LEVEL); 3468 mlme_init_wlm_multi_client_ll_support(psoc, wlm_config); 3469 3470 status = qdf_uint64_parse(cfg_get(psoc, CFG_LATENCY_FLAGS_NORMAL), 3471 &flags); 3472 if (status != QDF_STATUS_SUCCESS) { 3473 flags = 0; 3474 mlme_legacy_err("normal latency flags parsing failed"); 3475 } 3476 3477 wlm_config->latency_flags[0] = flags & 0xFFFFFFFF; 3478 wlm_config->latency_host_flags[0] = flags >> 32; 3479 mlme_legacy_debug("normal latency flags 0x%x host flags 0x%x", 3480 wlm_config->latency_flags[0], 3481 wlm_config->latency_host_flags[0]); 3482 3483 status = qdf_uint64_parse(cfg_get(psoc, CFG_LATENCY_FLAGS_XR), 3484 &flags); 3485 if (status != QDF_STATUS_SUCCESS) { 3486 flags = 0; 3487 mlme_legacy_err("xr latency flags parsing failed"); 3488 } 3489 3490 wlm_config->latency_flags[1] = flags & 0xFFFFFFFF; 3491 wlm_config->latency_host_flags[1] = flags >> 32; 3492 mlme_legacy_debug("xr latency flags 0x%x host flags 0x%x", 3493 wlm_config->latency_flags[1], 3494 wlm_config->latency_host_flags[1]); 3495 3496 status = qdf_uint64_parse(cfg_get(psoc, CFG_LATENCY_FLAGS_LOW), 3497 &flags); 3498 if (status != QDF_STATUS_SUCCESS) { 3499 flags = 0; 3500 mlme_legacy_err("low latency flags parsing failed"); 3501 } 3502 3503 wlm_config->latency_flags[2] = flags & 0xFFFFFFFF; 3504 wlm_config->latency_host_flags[2] = flags >> 32; 3505 mlme_legacy_debug("low latency flags 0x%x host flags 0x%x", 3506 wlm_config->latency_flags[2], 3507 wlm_config->latency_host_flags[2]); 3508 3509 status = qdf_uint64_parse(cfg_get(psoc, CFG_LATENCY_FLAGS_ULTLOW), 3510 &flags); 3511 if (status != QDF_STATUS_SUCCESS) { 3512 flags = 0; 3513 mlme_legacy_err("ultra-low latency flags parsing failed"); 3514 } 3515 3516 wlm_config->latency_flags[3] = flags & 0xFFFFFFFF; 3517 wlm_config->latency_host_flags[3] = flags >> 32; 3518 mlme_legacy_debug("ultra-low latency flags 0x%x host flags 0x%x", 3519 wlm_config->latency_flags[3], 3520 wlm_config->latency_host_flags[3]); 3521 } 3522 3523 /** 3524 * mlme_init_fe_rrm_in_cfg() - Populate RRM INI in MLME cfg 3525 * @psoc: pointer to the psoc object 3526 * @rrm_config: pointer to the MLME RRM cfg 3527 * 3528 * Return: None 3529 */ 3530 static void mlme_init_fe_rrm_in_cfg(struct wlan_objmgr_psoc *psoc, 3531 struct wlan_mlme_fe_rrm *rrm_config) 3532 { 3533 qdf_size_t len; 3534 3535 rrm_config->rrm_enabled = cfg_get(psoc, CFG_RRM_ENABLE); 3536 rrm_config->sap_rrm_enabled = cfg_get(psoc, CFG_SAP_RRM_ENABLE); 3537 rrm_config->rrm_rand_interval = cfg_get(psoc, CFG_RRM_MEAS_RAND_INTVL); 3538 3539 qdf_uint8_array_parse(cfg_get(psoc, CFG_RM_CAPABILITY), 3540 rrm_config->rm_capability, 3541 sizeof(rrm_config->rm_capability), &len); 3542 3543 if (len < MLME_RMENABLEDCAP_MAX_LEN) { 3544 mlme_legacy_debug("Incorrect RM capability, using default"); 3545 qdf_uint8_array_parse(cfg_default(CFG_RM_CAPABILITY), 3546 rrm_config->rm_capability, 3547 sizeof(rrm_config->rm_capability), &len); 3548 } 3549 } 3550 3551 static void mlme_init_powersave_params(struct wlan_objmgr_psoc *psoc, 3552 struct wlan_mlme_powersave *ps_cfg) 3553 { 3554 ps_cfg->is_imps_enabled = cfg_get(psoc, CFG_ENABLE_IMPS); 3555 ps_cfg->is_bmps_enabled = cfg_get(psoc, CFG_ENABLE_PS); 3556 ps_cfg->auto_bmps_timer_val = cfg_get(psoc, CFG_AUTO_BMPS_ENABLE_TIMER); 3557 ps_cfg->bmps_min_listen_interval = cfg_get(psoc, CFG_BMPS_MINIMUM_LI); 3558 ps_cfg->bmps_max_listen_interval = cfg_get(psoc, CFG_BMPS_MAXIMUM_LI); 3559 ps_cfg->dtim_selection_diversity = 3560 cfg_get(psoc, CFG_DTIM_SELECTION_DIVERSITY); 3561 } 3562 3563 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 3564 static void mlme_init_afc_cfg(struct wlan_objmgr_psoc *psoc, 3565 struct wlan_mlme_reg *reg) 3566 { 3567 reg->enable_6ghz_sp_pwrmode_supp = 3568 cfg_get(psoc, CFG_6GHZ_SP_POWER_MODE_SUPP); 3569 reg->afc_disable_timer_check = 3570 cfg_default(CFG_AFC_TIMER_CHECK_DIS); 3571 reg->afc_disable_request_id_check = 3572 cfg_default(CFG_AFC_REQ_ID_CHECK_DIS); 3573 reg->is_afc_reg_noaction = 3574 cfg_default(CFG_AFC_REG_NO_ACTION); 3575 } 3576 #else 3577 static inline void mlme_init_afc_cfg(struct wlan_objmgr_psoc *psoc, 3578 struct wlan_mlme_reg *reg) 3579 { 3580 } 3581 #endif 3582 3583 #ifdef MWS_COEX 3584 static void mlme_init_mwc_cfg(struct wlan_objmgr_psoc *psoc, 3585 struct wlan_mlme_mwc *mwc) 3586 { 3587 mwc->mws_coex_4g_quick_tdm = 3588 cfg_get(psoc, CFG_MWS_COEX_4G_QUICK_FTDM); 3589 mwc->mws_coex_5g_nr_pwr_limit = 3590 cfg_get(psoc, CFG_MWS_COEX_5G_NR_PWR_LIMIT); 3591 mwc->mws_coex_pcc_channel_avoid_delay = 3592 cfg_get(psoc, CFG_MWS_COEX_PCC_CHANNEL_AVOID_DELAY); 3593 mwc->mws_coex_scc_channel_avoid_delay = 3594 cfg_get(psoc, CFG_MWS_COEX_SCC_CHANNEL_AVOID_DELAY); 3595 } 3596 #else 3597 static void mlme_init_mwc_cfg(struct wlan_objmgr_psoc *psoc, 3598 struct wlan_mlme_mwc *mwc) 3599 { 3600 } 3601 #endif 3602 3603 #ifdef SAP_AVOID_ACS_FREQ_LIST 3604 static void mlme_init_acs_avoid_freq_list(struct wlan_objmgr_psoc *psoc, 3605 struct wlan_mlme_reg *reg) 3606 { 3607 qdf_size_t avoid_acs_freq_list_num = 0; 3608 uint8_t i; 3609 3610 qdf_uint16_array_parse(cfg_get(psoc, CFG_SAP_AVOID_ACS_FREQ_LIST), 3611 reg->avoid_acs_freq_list, 3612 CFG_VALID_CHANNEL_LIST_LEN, 3613 &avoid_acs_freq_list_num); 3614 reg->avoid_acs_freq_list_num = avoid_acs_freq_list_num; 3615 3616 for (i = 0; i < avoid_acs_freq_list_num; i++) 3617 mlme_legacy_debug("avoid_acs_freq %d", 3618 reg->avoid_acs_freq_list[i]); 3619 } 3620 #else 3621 static void mlme_init_acs_avoid_freq_list(struct wlan_objmgr_psoc *psoc, 3622 struct wlan_mlme_reg *reg) 3623 { 3624 } 3625 #endif 3626 3627 #ifdef FEATURE_WLAN_CH_AVOID_EXT 3628 static void mlme_init_coex_unsafe_chan_cfg(struct wlan_objmgr_psoc *psoc, 3629 struct wlan_mlme_reg *reg) 3630 { 3631 reg->coex_unsafe_chan_nb_user_prefer = 3632 cfg_get(psoc, CFG_COEX_UNSAFE_CHAN_NB_USER_PREFER); 3633 } 3634 3635 static void mlme_init_coex_unsafe_chan_reg_disable_cfg( 3636 struct wlan_objmgr_psoc *psoc, struct wlan_mlme_reg *reg) 3637 { 3638 reg->coex_unsafe_chan_reg_disable = 3639 cfg_get(psoc, CFG_COEX_UNSAFE_CHAN_REG_DISABLE); 3640 } 3641 #else 3642 static void mlme_init_coex_unsafe_chan_cfg(struct wlan_objmgr_psoc *psoc, 3643 struct wlan_mlme_reg *reg) 3644 { 3645 } 3646 3647 static void mlme_init_coex_unsafe_chan_reg_disable_cfg( 3648 struct wlan_objmgr_psoc *psoc, struct wlan_mlme_reg *reg) 3649 { 3650 } 3651 #endif 3652 3653 static void mlme_init_reg_cfg(struct wlan_objmgr_psoc *psoc, 3654 struct wlan_mlme_reg *reg) 3655 { 3656 reg->self_gen_frm_pwr = cfg_get(psoc, CFG_SELF_GEN_FRM_PWR); 3657 reg->etsi_srd_chan_in_master_mode = 3658 cfg_get(psoc, CFG_ETSI_SRD_CHAN_IN_MASTER_MODE); 3659 reg->fcc_5dot9_ghz_chan_in_master_mode = 3660 cfg_get(psoc, CFG_FCC_5DOT9_GHZ_CHAN_IN_MASTER_MODE); 3661 reg->restart_beaconing_on_ch_avoid = 3662 cfg_get(psoc, CFG_RESTART_BEACONING_ON_CH_AVOID); 3663 reg->indoor_channel_support = cfg_get(psoc, CFG_INDOOR_CHANNEL_SUPPORT); 3664 reg->enable_11d_in_world_mode = cfg_get(psoc, 3665 CFG_ENABLE_11D_IN_WORLD_MODE); 3666 reg->scan_11d_interval = cfg_get(psoc, CFG_SCAN_11D_INTERVAL); 3667 reg->enable_pending_chan_list_req = cfg_get(psoc, 3668 CFG_ENABLE_PENDING_CHAN_LIST_REQ); 3669 reg->ignore_fw_reg_offload_ind = cfg_get( 3670 psoc, 3671 CFG_IGNORE_FW_REG_OFFLOAD_IND); 3672 reg->retain_nol_across_regdmn_update = 3673 cfg_get(psoc, CFG_RETAIN_NOL_ACROSS_REG_DOMAIN); 3674 3675 reg->enable_nan_on_indoor_channels = 3676 cfg_get(psoc, CFG_INDOOR_CHANNEL_SUPPORT_FOR_NAN); 3677 3678 mlme_init_afc_cfg(psoc, reg); 3679 mlme_init_acs_avoid_freq_list(psoc, reg); 3680 mlme_init_coex_unsafe_chan_cfg(psoc, reg); 3681 mlme_init_coex_unsafe_chan_reg_disable_cfg(psoc, reg); 3682 } 3683 3684 static void 3685 mlme_init_dot11_mode_cfg(struct wlan_objmgr_psoc *psoc, 3686 struct wlan_mlme_dot11_mode *dot11_mode) 3687 { 3688 dot11_mode->dot11_mode = cfg_default(CFG_DOT11_MODE); 3689 dot11_mode->vdev_type_dot11_mode = cfg_get(psoc, CFG_VDEV_DOT11_MODE); 3690 } 3691 3692 /** 3693 * mlme_iot_parse_aggr_info - parse aggr related items in ini 3694 * @psoc: PSOC pointer 3695 * @iot: IOT related CFG items 3696 * 3697 * Return: None 3698 */ 3699 static void 3700 mlme_iot_parse_aggr_info(struct wlan_objmgr_psoc *psoc, 3701 struct wlan_mlme_iot *iot) 3702 { 3703 char *aggr_info, *oui, *msdu, *mpdu, *aggr_info_temp; 3704 uint32_t ampdu_sz, amsdu_sz, index = 0, oui_len, cfg_str_len; 3705 struct wlan_iot_aggr *aggr_info_list; 3706 const char *cfg_str; 3707 int ret; 3708 3709 cfg_str = cfg_get(psoc, CFG_TX_IOT_AGGR); 3710 if (!cfg_str) 3711 return; 3712 3713 cfg_str_len = qdf_str_len(cfg_str); 3714 if (!cfg_str_len) 3715 return; 3716 3717 aggr_info = qdf_mem_malloc(cfg_str_len + 1); 3718 if (!aggr_info) 3719 return; 3720 3721 aggr_info_list = iot->aggr; 3722 qdf_mem_copy(aggr_info, cfg_str, cfg_str_len); 3723 mlme_legacy_debug("aggr_info=[%s]", aggr_info); 3724 3725 aggr_info_temp = aggr_info; 3726 while (aggr_info_temp) { 3727 /* skip possible spaces before oui string */ 3728 while (*aggr_info_temp == ' ') 3729 aggr_info_temp++; 3730 3731 oui = strsep(&aggr_info_temp, ","); 3732 if (!oui) { 3733 mlme_legacy_err("oui error"); 3734 goto end; 3735 } 3736 3737 oui_len = qdf_str_len(oui) / 2; 3738 if (oui_len > sizeof(aggr_info_list[index].oui)) { 3739 mlme_legacy_err("size error"); 3740 goto end; 3741 } 3742 3743 amsdu_sz = 0; 3744 msdu = strsep(&aggr_info_temp, ","); 3745 if (!msdu) { 3746 mlme_legacy_err("msdu error"); 3747 goto end; 3748 } 3749 3750 ret = kstrtou32(msdu, 10, &amsdu_sz); 3751 if (ret || amsdu_sz > IOT_AGGR_MSDU_MAX_NUM) { 3752 mlme_legacy_err("invalid msdu no. %s [%u]", 3753 msdu, amsdu_sz); 3754 goto end; 3755 } 3756 3757 ampdu_sz = 0; 3758 mpdu = strsep(&aggr_info_temp, ","); 3759 if (!mpdu) { 3760 mlme_legacy_err("mpdu error"); 3761 goto end; 3762 } 3763 3764 ret = kstrtou32(mpdu, 10, &du_sz); 3765 if (ret || ampdu_sz > IOT_AGGR_MPDU_MAX_NUM) { 3766 mlme_legacy_err("invalid mpdu no. %s [%u]", 3767 mpdu, ampdu_sz); 3768 goto end; 3769 } 3770 3771 mlme_legacy_debug("id %u oui[%s] len %u msdu %u mpdu %u", 3772 index, oui, oui_len, amsdu_sz, ampdu_sz); 3773 3774 ret = qdf_hex_str_to_binary(aggr_info_list[index].oui, 3775 oui, oui_len); 3776 if (ret) { 3777 mlme_legacy_err("oui error: %d", ret); 3778 goto end; 3779 } 3780 3781 aggr_info_list[index].amsdu_sz = amsdu_sz; 3782 aggr_info_list[index].ampdu_sz = ampdu_sz; 3783 aggr_info_list[index].oui_len = oui_len; 3784 index++; 3785 if (index >= IOT_AGGR_INFO_MAX_NUM) { 3786 mlme_legacy_err("exceed max num, index = %d", index); 3787 break; 3788 } 3789 } 3790 iot->aggr_num = index; 3791 3792 end: 3793 mlme_legacy_debug("configured aggr num %d", iot->aggr_num); 3794 qdf_mem_free(aggr_info); 3795 } 3796 3797 /** 3798 * mlme_init_iot_cfg() - parse IOT related items in ini 3799 * @psoc: PSOC pointer 3800 * @iot: IOT related CFG items 3801 * 3802 * Return: None 3803 */ 3804 static void 3805 mlme_init_iot_cfg(struct wlan_objmgr_psoc *psoc, 3806 struct wlan_mlme_iot *iot) 3807 { 3808 mlme_iot_parse_aggr_info(psoc, iot); 3809 } 3810 3811 /** 3812 * mlme_init_dual_sta_config - Initialize dual sta configurations 3813 * @gen: Generic CFG config items 3814 * 3815 * Return: None 3816 */ 3817 static void 3818 mlme_init_dual_sta_config(struct wlan_mlme_generic *gen) 3819 { 3820 gen->dual_sta_policy.primary_vdev_id = WLAN_UMAC_VDEV_ID_MAX; 3821 gen->dual_sta_policy.concurrent_sta_policy = 3822 QCA_WLAN_CONCURRENT_STA_POLICY_UNBIASED; 3823 } 3824 3825 #ifdef WLAN_FEATURE_MCC_QUOTA 3826 /** 3827 * mlme_init_user_mcc_quota_config - Initialize mcc quota 3828 * @gen: Generic CFG config items 3829 * 3830 * Return: None 3831 */ 3832 static void 3833 mlme_init_user_mcc_quota_config(struct wlan_mlme_generic *gen) 3834 { 3835 gen->user_mcc_quota.quota = 0; 3836 gen->user_mcc_quota.op_mode = QDF_MAX_NO_OF_MODE; 3837 gen->user_mcc_quota.vdev_id = WLAN_UMAC_VDEV_ID_MAX; 3838 } 3839 #else 3840 static void 3841 mlme_init_user_mcc_quota_config(struct wlan_mlme_generic *gen) 3842 { 3843 } 3844 #endif 3845 QDF_STATUS mlme_cfg_on_psoc_enable(struct wlan_objmgr_psoc *psoc) 3846 { 3847 struct wlan_mlme_psoc_ext_obj *mlme_obj; 3848 struct wlan_mlme_cfg *mlme_cfg; 3849 QDF_STATUS status = QDF_STATUS_SUCCESS; 3850 3851 mlme_obj = mlme_get_psoc_ext_obj(psoc); 3852 if (!mlme_obj) { 3853 mlme_legacy_err("Failed to get MLME Obj"); 3854 return QDF_STATUS_E_FAILURE; 3855 } 3856 3857 mlme_cfg = &mlme_obj->cfg; 3858 mlme_init_generic_cfg(psoc, &mlme_cfg->gen); 3859 mlme_init_timeout_cfg(psoc, &mlme_cfg->timeouts); 3860 mlme_init_edca_params(psoc, &mlme_cfg->edca_params); 3861 mlme_init_ht_cap_in_cfg(psoc, &mlme_cfg->ht_caps); 3862 mlme_init_wmm_in_cfg(psoc, &mlme_cfg->wmm_params); 3863 mlme_init_mbo_cfg(psoc, &mlme_cfg->mbo_cfg); 3864 mlme_init_qos_cfg(psoc, &mlme_cfg->qos_mlme_params); 3865 mlme_init_rates_in_cfg(psoc, &mlme_cfg->rates); 3866 mlme_init_dfs_cfg(psoc, &mlme_cfg->dfs_cfg); 3867 mlme_init_sap_protection_cfg(psoc, &mlme_cfg->sap_protection_cfg); 3868 mlme_init_vht_cap_cfg(psoc, &mlme_cfg->vht_caps.vht_cap_info); 3869 mlme_init_chainmask_cfg(psoc, &mlme_cfg->chainmask_cfg); 3870 mlme_init_sap_cfg(psoc, &mlme_cfg->sap_cfg); 3871 mlme_init_nss_chains(psoc, &mlme_cfg->nss_chains_ini_cfg); 3872 mlme_init_twt_cfg(psoc, &mlme_cfg->twt_cfg); 3873 mlme_init_he_cap_in_cfg(psoc, mlme_cfg); 3874 mlme_init_eht_cap_in_cfg(psoc, mlme_cfg); 3875 mlme_init_obss_ht40_cfg(psoc, &mlme_cfg->obss_ht40); 3876 mlme_init_product_details_cfg(&mlme_cfg->product_details); 3877 mlme_init_powersave_params(psoc, &mlme_cfg->ps_params); 3878 mlme_init_sta_cfg(psoc, &mlme_cfg->sta); 3879 mlme_init_stats_cfg(psoc, &mlme_cfg->stats); 3880 mlme_init_lfr_cfg(psoc, &mlme_cfg->lfr); 3881 mlme_init_feature_flag_in_cfg(psoc, &mlme_cfg->feature_flags); 3882 mlme_init_roam_scoring_cfg(psoc, &mlme_cfg->roam_scoring); 3883 mlme_init_dot11_mode_cfg(psoc, &mlme_cfg->dot11_mode); 3884 mlme_init_threshold_cfg(psoc, &mlme_cfg->threshold); 3885 mlme_init_acs_cfg(psoc, &mlme_cfg->acs); 3886 mlme_init_power_cfg(psoc, &mlme_cfg->power); 3887 mlme_init_oce_cfg(psoc, &mlme_cfg->oce); 3888 mlme_init_wep_cfg(&mlme_cfg->wep_params); 3889 mlme_init_wifi_pos_cfg(psoc, &mlme_cfg->wifi_pos_cfg); 3890 mlme_init_wps_params_cfg(psoc, &mlme_cfg->wps_params); 3891 mlme_init_fe_wlm_in_cfg(psoc, &mlme_cfg->wlm_config); 3892 mlme_init_fe_rrm_in_cfg(psoc, &mlme_cfg->rrm_config); 3893 mlme_init_mwc_cfg(psoc, &mlme_cfg->mwc); 3894 mlme_init_reg_cfg(psoc, &mlme_cfg->reg); 3895 mlme_init_btm_cfg(psoc, &mlme_cfg->btm); 3896 mlme_init_roam_score_config(psoc, mlme_cfg); 3897 mlme_init_ratemask_cfg(psoc, &mlme_cfg->ratemask_cfg); 3898 mlme_init_iot_cfg(psoc, &mlme_cfg->iot); 3899 mlme_init_dual_sta_config(&mlme_cfg->gen); 3900 mlme_init_user_mcc_quota_config(&mlme_cfg->gen); 3901 3902 return status; 3903 } 3904 3905 struct sae_auth_retry *mlme_get_sae_auth_retry(struct wlan_objmgr_vdev *vdev) 3906 { 3907 struct mlme_legacy_priv *mlme_priv; 3908 3909 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 3910 if (!mlme_priv) { 3911 mlme_legacy_err("vdev legacy private object is NULL"); 3912 return NULL; 3913 } 3914 3915 return &mlme_priv->sae_retry; 3916 } 3917 3918 void mlme_free_sae_auth_retry(struct wlan_objmgr_vdev *vdev) 3919 { 3920 struct mlme_legacy_priv *mlme_priv; 3921 3922 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 3923 if (!mlme_priv) { 3924 mlme_legacy_err("vdev legacy private object is NULL"); 3925 return; 3926 } 3927 3928 mlme_priv->sae_retry.sae_auth_max_retry = 0; 3929 if (mlme_priv->sae_retry.sae_auth.ptr) 3930 qdf_mem_free(mlme_priv->sae_retry.sae_auth.ptr); 3931 mlme_priv->sae_retry.sae_auth.ptr = NULL; 3932 mlme_priv->sae_retry.sae_auth.len = 0; 3933 } 3934 3935 void mlme_set_self_disconnect_ies(struct wlan_objmgr_vdev *vdev, 3936 struct element_info *ie) 3937 { 3938 struct mlme_legacy_priv *mlme_priv; 3939 3940 if (!ie || !ie->len || !ie->ptr) { 3941 mlme_legacy_debug("disocnnect IEs are NULL"); 3942 return; 3943 } 3944 3945 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 3946 if (!mlme_priv) { 3947 mlme_legacy_err("vdev legacy private object is NULL"); 3948 return; 3949 } 3950 3951 if (mlme_priv->disconnect_info.self_discon_ies.ptr) { 3952 qdf_mem_free(mlme_priv->disconnect_info.self_discon_ies.ptr); 3953 mlme_priv->disconnect_info.self_discon_ies.len = 0; 3954 } 3955 3956 mlme_priv->disconnect_info.self_discon_ies.ptr = 3957 qdf_mem_malloc(ie->len); 3958 if (!mlme_priv->disconnect_info.self_discon_ies.ptr) 3959 return; 3960 3961 qdf_mem_copy(mlme_priv->disconnect_info.self_discon_ies.ptr, 3962 ie->ptr, ie->len); 3963 mlme_priv->disconnect_info.self_discon_ies.len = ie->len; 3964 3965 mlme_legacy_debug("Self disconnect IEs"); 3966 QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_MLME, QDF_TRACE_LEVEL_DEBUG, 3967 mlme_priv->disconnect_info.self_discon_ies.ptr, 3968 mlme_priv->disconnect_info.self_discon_ies.len); 3969 } 3970 3971 void mlme_free_self_disconnect_ies(struct wlan_objmgr_vdev *vdev) 3972 { 3973 struct mlme_legacy_priv *mlme_priv; 3974 3975 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 3976 if (!mlme_priv) { 3977 mlme_legacy_err("vdev legacy private object is NULL"); 3978 return; 3979 } 3980 3981 if (mlme_priv->disconnect_info.self_discon_ies.ptr) { 3982 qdf_mem_free(mlme_priv->disconnect_info.self_discon_ies.ptr); 3983 mlme_priv->disconnect_info.self_discon_ies.ptr = NULL; 3984 mlme_priv->disconnect_info.self_discon_ies.len = 0; 3985 } 3986 } 3987 3988 struct element_info *mlme_get_self_disconnect_ies(struct wlan_objmgr_vdev *vdev) 3989 { 3990 struct mlme_legacy_priv *mlme_priv; 3991 3992 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 3993 if (!mlme_priv) { 3994 mlme_legacy_err("vdev legacy private object is NULL"); 3995 return NULL; 3996 } 3997 3998 return &mlme_priv->disconnect_info.self_discon_ies; 3999 } 4000 4001 void mlme_set_peer_disconnect_ies(struct wlan_objmgr_vdev *vdev, 4002 struct element_info *ie) 4003 { 4004 struct mlme_legacy_priv *mlme_priv; 4005 4006 if (!ie || !ie->len || !ie->ptr) { 4007 mlme_legacy_debug("disocnnect IEs are NULL"); 4008 return; 4009 } 4010 4011 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4012 if (!mlme_priv) { 4013 mlme_legacy_err("vdev legacy private object is NULL"); 4014 return; 4015 } 4016 4017 if (mlme_priv->disconnect_info.peer_discon_ies.ptr) { 4018 qdf_mem_free(mlme_priv->disconnect_info.peer_discon_ies.ptr); 4019 mlme_priv->disconnect_info.peer_discon_ies.len = 0; 4020 } 4021 4022 mlme_priv->disconnect_info.peer_discon_ies.ptr = 4023 qdf_mem_malloc(ie->len); 4024 if (!mlme_priv->disconnect_info.peer_discon_ies.ptr) 4025 return; 4026 4027 qdf_mem_copy(mlme_priv->disconnect_info.peer_discon_ies.ptr, 4028 ie->ptr, ie->len); 4029 mlme_priv->disconnect_info.peer_discon_ies.len = ie->len; 4030 4031 mlme_legacy_debug("peer disconnect IEs"); 4032 QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_MLME, QDF_TRACE_LEVEL_DEBUG, 4033 mlme_priv->disconnect_info.peer_discon_ies.ptr, 4034 mlme_priv->disconnect_info.peer_discon_ies.len); 4035 } 4036 4037 void mlme_free_peer_disconnect_ies(struct wlan_objmgr_vdev *vdev) 4038 { 4039 struct mlme_legacy_priv *mlme_priv; 4040 4041 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4042 if (!mlme_priv) { 4043 mlme_legacy_err("vdev legacy private object is NULL"); 4044 return; 4045 } 4046 4047 if (mlme_priv->disconnect_info.peer_discon_ies.ptr) { 4048 qdf_mem_free(mlme_priv->disconnect_info.peer_discon_ies.ptr); 4049 mlme_priv->disconnect_info.peer_discon_ies.ptr = NULL; 4050 mlme_priv->disconnect_info.peer_discon_ies.len = 0; 4051 } 4052 } 4053 4054 struct element_info *mlme_get_peer_disconnect_ies(struct wlan_objmgr_vdev *vdev) 4055 { 4056 struct mlme_legacy_priv *mlme_priv; 4057 4058 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4059 if (!mlme_priv) { 4060 mlme_legacy_err("vdev legacy private object is NULL"); 4061 return NULL; 4062 } 4063 4064 return &mlme_priv->disconnect_info.peer_discon_ies; 4065 } 4066 4067 void mlme_free_peer_assoc_rsp_ie(struct peer_mlme_priv_obj *peer_priv) 4068 { 4069 if (!peer_priv) { 4070 mlme_legacy_debug("peer priv is NULL"); 4071 return; 4072 } 4073 4074 if (peer_priv->assoc_rsp.ptr) { 4075 qdf_mem_free(peer_priv->assoc_rsp.ptr); 4076 peer_priv->assoc_rsp.ptr = NULL; 4077 peer_priv->assoc_rsp.len = 0; 4078 } 4079 } 4080 4081 void mlme_set_peer_assoc_rsp_ie(struct wlan_objmgr_psoc *psoc, 4082 uint8_t *peer_addr, struct element_info *ie) 4083 { 4084 struct wlan_objmgr_peer *peer; 4085 struct peer_mlme_priv_obj *peer_priv; 4086 4087 if (!ie || !ie->len || !ie->ptr || !peer_addr) { 4088 mlme_legacy_debug("Assoc IE is NULL"); 4089 return; 4090 } 4091 4092 peer = wlan_objmgr_get_peer_by_mac(psoc, peer_addr, WLAN_LEGACY_MAC_ID); 4093 if (!peer) 4094 return; 4095 4096 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 4097 WLAN_UMAC_COMP_MLME); 4098 4099 if (!peer_priv) 4100 goto end; 4101 4102 /* Free existing assoc_rsp */ 4103 mlme_free_peer_assoc_rsp_ie(peer_priv); 4104 4105 peer_priv->assoc_rsp.ptr = qdf_mem_malloc(ie->len); 4106 if (!peer_priv->assoc_rsp.ptr) 4107 goto end; 4108 4109 qdf_mem_copy(peer_priv->assoc_rsp.ptr, ie->ptr, ie->len); 4110 peer_priv->assoc_rsp.len = ie->len; 4111 end: 4112 wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_MAC_ID); 4113 } 4114 4115 void mlme_set_follow_ap_edca_flag(struct wlan_objmgr_vdev *vdev, bool flag) 4116 { 4117 struct mlme_legacy_priv *mlme_priv; 4118 4119 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4120 if (!mlme_priv) { 4121 mlme_legacy_err("vdev legacy private object is NULL"); 4122 return; 4123 } 4124 4125 mlme_priv->follow_ap_edca = flag; 4126 } 4127 4128 bool mlme_get_follow_ap_edca_flag(struct wlan_objmgr_vdev *vdev) 4129 { 4130 struct mlme_legacy_priv *mlme_priv; 4131 4132 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4133 if (!mlme_priv) { 4134 mlme_legacy_err("vdev legacy private object is NULL"); 4135 return false; 4136 } 4137 4138 return mlme_priv->follow_ap_edca; 4139 } 4140 4141 void mlme_set_reconn_after_assoc_timeout_flag(struct wlan_objmgr_psoc *psoc, 4142 uint8_t vdev_id, bool flag) 4143 { 4144 struct wlan_objmgr_vdev *vdev; 4145 struct mlme_legacy_priv *mlme_priv; 4146 4147 if (!psoc) 4148 return; 4149 4150 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4151 WLAN_LEGACY_MAC_ID); 4152 if (!vdev) 4153 return; 4154 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4155 if (!mlme_priv) { 4156 mlme_legacy_err("vdev legacy private object is NULL"); 4157 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4158 return; 4159 } 4160 4161 mlme_priv->reconn_after_assoc_timeout = flag; 4162 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4163 } 4164 4165 bool mlme_get_reconn_after_assoc_timeout_flag(struct wlan_objmgr_psoc *psoc, 4166 uint8_t vdev_id) 4167 { 4168 struct wlan_objmgr_vdev *vdev; 4169 struct mlme_legacy_priv *mlme_priv; 4170 bool reconn_after_assoc_timeout; 4171 4172 if (!psoc) 4173 return false; 4174 4175 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4176 WLAN_LEGACY_MAC_ID); 4177 if (!vdev) 4178 return false; 4179 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4180 if (!mlme_priv) { 4181 mlme_legacy_err("vdev legacy private object is NULL"); 4182 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4183 return false; 4184 } 4185 4186 reconn_after_assoc_timeout = mlme_priv->reconn_after_assoc_timeout; 4187 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4188 4189 return reconn_after_assoc_timeout; 4190 } 4191 4192 void mlme_set_peer_pmf_status(struct wlan_objmgr_peer *peer, 4193 bool is_pmf_enabled) 4194 { 4195 struct peer_mlme_priv_obj *peer_priv; 4196 4197 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 4198 WLAN_UMAC_COMP_MLME); 4199 if (!peer_priv) { 4200 mlme_legacy_err(" peer mlme component object is NULL"); 4201 return; 4202 } 4203 peer_priv->is_pmf_enabled = is_pmf_enabled; 4204 } 4205 4206 bool mlme_get_peer_pmf_status(struct wlan_objmgr_peer *peer) 4207 { 4208 struct peer_mlme_priv_obj *peer_priv; 4209 4210 peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer, 4211 WLAN_UMAC_COMP_MLME); 4212 if (!peer_priv) { 4213 mlme_legacy_err("peer mlme component object is NULL"); 4214 return false; 4215 } 4216 4217 return peer_priv->is_pmf_enabled; 4218 } 4219 4220 enum QDF_OPMODE wlan_get_opmode_from_vdev_id(struct wlan_objmgr_pdev *pdev, 4221 uint8_t vdev_id) 4222 { 4223 struct wlan_objmgr_vdev *vdev; 4224 enum QDF_OPMODE opmode = QDF_MAX_NO_OF_MODE; 4225 4226 if (!pdev) 4227 return opmode; 4228 4229 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4230 WLAN_LEGACY_MAC_ID); 4231 if (!vdev) 4232 return opmode; 4233 4234 opmode = wlan_vdev_mlme_get_opmode(vdev); 4235 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4236 4237 return opmode; 4238 } 4239 4240 QDF_STATUS wlan_mlme_get_bssid_vdev_id(struct wlan_objmgr_pdev *pdev, 4241 uint8_t vdev_id, 4242 struct qdf_mac_addr *bss_peer_mac) 4243 { 4244 struct wlan_objmgr_vdev *vdev; 4245 QDF_STATUS status; 4246 4247 if (!pdev) 4248 return QDF_STATUS_E_INVAL; 4249 4250 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4251 WLAN_LEGACY_MAC_ID); 4252 if (!vdev) 4253 return QDF_STATUS_E_INVAL; 4254 4255 status = wlan_vdev_get_bss_peer_mac(vdev, bss_peer_mac); 4256 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4257 4258 return status; 4259 } 4260 4261 qdf_freq_t wlan_get_operation_chan_freq(struct wlan_objmgr_vdev *vdev) 4262 { 4263 qdf_freq_t chan_freq = 0; 4264 struct wlan_channel *chan; 4265 4266 if (!vdev) 4267 return chan_freq; 4268 4269 chan = wlan_vdev_get_active_channel(vdev); 4270 if (chan) 4271 chan_freq = chan->ch_freq; 4272 4273 return chan_freq; 4274 } 4275 4276 qdf_freq_t wlan_get_operation_chan_freq_vdev_id(struct wlan_objmgr_pdev *pdev, 4277 uint8_t vdev_id) 4278 { 4279 qdf_freq_t chan_freq = 0; 4280 struct wlan_objmgr_vdev *vdev; 4281 4282 if (!pdev) 4283 return chan_freq; 4284 4285 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4286 WLAN_LEGACY_MAC_ID); 4287 if (!vdev) 4288 return chan_freq; 4289 chan_freq = wlan_get_operation_chan_freq(vdev); 4290 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4291 4292 return chan_freq; 4293 } 4294 4295 void wlan_vdev_set_dot11mode(struct wlan_mlme_cfg *mac_mlme_cfg, 4296 enum QDF_OPMODE device_mode, 4297 struct vdev_mlme_obj *vdev_mlme) 4298 { 4299 uint8_t dot11_mode_indx; 4300 uint8_t *mld_addr; 4301 enum mlme_vdev_dot11_mode vdev_dot11_mode; 4302 uint32_t mac_dot11_mode = 4303 mac_mlme_cfg->dot11_mode.vdev_type_dot11_mode; 4304 4305 switch (device_mode) { 4306 default: 4307 case QDF_STA_MODE: 4308 dot11_mode_indx = STA_DOT11_MODE_INDX; 4309 break; 4310 case QDF_P2P_CLIENT_MODE: 4311 case QDF_P2P_DEVICE_MODE: 4312 dot11_mode_indx = P2P_DEV_DOT11_MODE_INDX; 4313 break; 4314 case QDF_TDLS_MODE: 4315 dot11_mode_indx = TDLS_DOT11_MODE_INDX; 4316 break; 4317 case QDF_NAN_DISC_MODE: 4318 dot11_mode_indx = NAN_DISC_DOT11_MODE_INDX; 4319 break; 4320 case QDF_NDI_MODE: 4321 dot11_mode_indx = NDI_DOT11_MODE_INDX; 4322 break; 4323 case QDF_OCB_MODE: 4324 dot11_mode_indx = OCB_DOT11_MODE_INDX; 4325 break; 4326 } 4327 4328 vdev_dot11_mode = QDF_GET_BITS(mac_dot11_mode, dot11_mode_indx, 4); 4329 if (vdev_dot11_mode == MLME_VDEV_DOT11_MODE_AUTO || 4330 vdev_dot11_mode == MLME_VDEV_DOT11_MODE_11BE) { 4331 mld_addr = wlan_vdev_mlme_get_mldaddr(vdev_mlme->vdev); 4332 if (qdf_is_macaddr_zero((struct qdf_mac_addr *)mld_addr)) { 4333 vdev_dot11_mode = MLME_VDEV_DOT11_MODE_11AX; 4334 vdev_mlme->proto.vdev_dot11_mode = vdev_dot11_mode; 4335 } 4336 } 4337 mlme_debug("vdev%d: dot11_mode %d", wlan_vdev_get_id(vdev_mlme->vdev), 4338 vdev_dot11_mode); 4339 } 4340 4341 bool wlan_is_open_wep_cipher(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id) 4342 { 4343 struct wlan_objmgr_vdev *vdev; 4344 int32_t ucast_cipher; 4345 bool is_open_wep = false; 4346 4347 if (!pdev) 4348 return is_open_wep; 4349 4350 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4351 WLAN_LEGACY_MAC_ID); 4352 if (!vdev) 4353 return is_open_wep; 4354 ucast_cipher = wlan_crypto_get_param(vdev, 4355 WLAN_CRYPTO_PARAM_UCAST_CIPHER); 4356 if (!ucast_cipher || 4357 ((QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_NONE) == 4358 ucast_cipher)) || 4359 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP) || 4360 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_40) || 4361 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_104)) 4362 is_open_wep = true; 4363 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4364 4365 return is_open_wep; 4366 } 4367 4368 bool wlan_vdev_is_open_mode(struct wlan_objmgr_vdev *vdev) 4369 { 4370 int32_t ucast_cipher; 4371 4372 ucast_cipher = wlan_crypto_get_param(vdev, 4373 WLAN_CRYPTO_PARAM_UCAST_CIPHER); 4374 if (!ucast_cipher || 4375 ((QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_NONE) == 4376 ucast_cipher))) 4377 return true; 4378 4379 return false; 4380 } 4381 4382 bool wlan_vdev_id_is_open_cipher(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id) 4383 { 4384 struct wlan_objmgr_vdev *vdev; 4385 bool is_open = false; 4386 4387 if (!pdev) 4388 return is_open; 4389 4390 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4391 WLAN_LEGACY_MAC_ID); 4392 if (!vdev) 4393 return is_open; 4394 is_open = wlan_vdev_is_open_mode(vdev); 4395 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4396 4397 return is_open; 4398 } 4399 4400 bool wlan_vdev_id_is_11n_allowed(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id) 4401 { 4402 struct wlan_objmgr_vdev *vdev; 4403 bool is_11n_allowed = true; 4404 int32_t ucast_cipher; 4405 4406 if (!pdev) 4407 return is_11n_allowed; 4408 4409 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4410 WLAN_LEGACY_MAC_ID); 4411 if (!vdev) 4412 return is_11n_allowed; 4413 ucast_cipher = wlan_crypto_get_param(vdev, 4414 WLAN_CRYPTO_PARAM_UCAST_CIPHER); 4415 4416 if (ucast_cipher == -1) 4417 goto err; 4418 if (QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_TKIP) || 4419 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP) || 4420 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_40) || 4421 QDF_HAS_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_104)) { 4422 QDF_CLEAR_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_TKIP); 4423 QDF_CLEAR_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP); 4424 QDF_CLEAR_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_40); 4425 QDF_CLEAR_PARAM(ucast_cipher, WLAN_CRYPTO_CIPHER_WEP_104); 4426 if (!ucast_cipher) 4427 is_11n_allowed = false; 4428 } 4429 err: 4430 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4431 4432 return is_11n_allowed; 4433 } 4434 4435 4436 bool wlan_is_vdev_id_up(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id) 4437 { 4438 struct wlan_objmgr_vdev *vdev; 4439 bool is_up = false; 4440 4441 if (!pdev) 4442 return is_up; 4443 4444 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4445 WLAN_LEGACY_MAC_ID); 4446 if (vdev) { 4447 is_up = QDF_IS_STATUS_SUCCESS(wlan_vdev_is_up(vdev)); 4448 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4449 } 4450 4451 return is_up; 4452 } 4453 4454 4455 QDF_STATUS 4456 wlan_get_op_chan_freq_info_vdev_id(struct wlan_objmgr_pdev *pdev, 4457 uint8_t vdev_id, qdf_freq_t *op_freq, 4458 qdf_freq_t *freq_seg_0, 4459 enum phy_ch_width *ch_width) 4460 { 4461 struct wlan_objmgr_vdev *vdev; 4462 struct wlan_channel *chan; 4463 QDF_STATUS status = QDF_STATUS_E_INVAL; 4464 4465 *op_freq = 0; 4466 *freq_seg_0 = 0; 4467 *ch_width = 0; 4468 4469 if (!pdev) 4470 return QDF_STATUS_E_INVAL; 4471 4472 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 4473 WLAN_LEGACY_MAC_ID); 4474 if (!vdev) 4475 goto rel_ref; 4476 if (wlan_vdev_mlme_is_active(vdev) != QDF_STATUS_SUCCESS) 4477 goto rel_ref; 4478 chan = wlan_vdev_get_active_channel(vdev); 4479 if (!chan) 4480 goto rel_ref; 4481 4482 /* If operating mode is STA / P2P-CLI then get the channel width 4483 * from phymode. This is due the reason where actual operating 4484 * channel width is configured as part of WMI_PEER_ASSOC_CMDID 4485 * which could be downgraded while the peer associated. 4486 * If there is a failure or operating mode is not STA / P2P-CLI 4487 * then get channel width from wlan_channel. 4488 */ 4489 status = wlan_mlme_get_sta_ch_width(vdev, ch_width); 4490 if (QDF_IS_STATUS_ERROR(status)) 4491 *ch_width = chan->ch_width; 4492 4493 *op_freq = chan->ch_freq; 4494 *freq_seg_0 = chan->ch_cfreq1; 4495 status = QDF_STATUS_SUCCESS; 4496 4497 rel_ref: 4498 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 4499 4500 return status; 4501 } 4502 4503 QDF_STATUS wlan_strip_ie(uint8_t *addn_ie, uint16_t *addn_ielen, 4504 uint8_t eid, enum size_of_len_field size_of_len_field, 4505 uint8_t *oui, uint8_t oui_length, 4506 uint8_t *extracted_ie, uint32_t eid_max_len) 4507 { 4508 uint8_t *tmp_buf = NULL; 4509 uint16_t tmp_len = 0; 4510 int left = *addn_ielen; 4511 uint8_t *ptr = addn_ie; 4512 uint8_t elem_id; 4513 uint16_t elem_len, ie_len, extracted_ie_len = 0; 4514 4515 if (!addn_ie) { 4516 mlme_debug("NULL addn_ie pointer"); 4517 return QDF_STATUS_E_INVAL; 4518 } 4519 if (!left) 4520 return QDF_STATUS_E_INVAL; 4521 4522 tmp_buf = qdf_mem_malloc(left); 4523 if (!tmp_buf) 4524 return QDF_STATUS_E_NOMEM; 4525 4526 if (extracted_ie) 4527 qdf_mem_zero(extracted_ie, eid_max_len + size_of_len_field + 1); 4528 4529 while (left >= 2) { 4530 elem_id = ptr[0]; 4531 left -= 1; 4532 if (size_of_len_field == TWO_BYTE) { 4533 elem_len = *((uint16_t *)&ptr[1]); 4534 left -= 2; 4535 } else { 4536 elem_len = ptr[1]; 4537 left -= 1; 4538 } 4539 if (elem_len > left) { 4540 mlme_err("Invalid IEs eid: %d elem_len: %d left: %d", 4541 elem_id, elem_len, left); 4542 qdf_mem_free(tmp_buf); 4543 return QDF_STATUS_E_FAILURE; 4544 } 4545 4546 if (eid != elem_id || 4547 (oui && qdf_mem_cmp(oui, 4548 &ptr[size_of_len_field + 1], 4549 oui_length))) { 4550 qdf_mem_copy(tmp_buf + tmp_len, &ptr[0], 4551 elem_len + size_of_len_field + 1); 4552 tmp_len += (elem_len + size_of_len_field + 1); 4553 } else { 4554 /* 4555 * eid matched and if provided OUI also matched 4556 * take oui IE and store in provided buffer. 4557 */ 4558 if (extracted_ie) { 4559 ie_len = elem_len + size_of_len_field + 1; 4560 if (ie_len <= eid_max_len - extracted_ie_len) { 4561 qdf_mem_copy( 4562 extracted_ie + extracted_ie_len, 4563 &ptr[0], ie_len); 4564 extracted_ie_len += ie_len; 4565 } 4566 } 4567 } 4568 left -= elem_len; 4569 ptr += (elem_len + size_of_len_field + 1); 4570 } 4571 qdf_mem_copy(addn_ie, tmp_buf, tmp_len); 4572 4573 *addn_ielen = tmp_len; 4574 qdf_mem_free(tmp_buf); 4575 4576 return QDF_STATUS_SUCCESS; 4577 } 4578 4579 bool wlan_is_channel_present_in_list(qdf_freq_t *freq_lst, 4580 uint32_t num_chan, qdf_freq_t chan_freq) 4581 { 4582 int i = 0; 4583 4584 /* Check for NULL pointer */ 4585 if (!freq_lst || (num_chan == 0)) 4586 return false; 4587 4588 /* Look for the channel in the list */ 4589 for (i = 0; (i < num_chan) && (i < CFG_VALID_CHANNEL_LIST_LEN); i++) { 4590 if (freq_lst[i] == chan_freq) 4591 return true; 4592 } 4593 4594 return false; 4595 } 4596 4597 bool wlan_roam_is_channel_valid(struct wlan_mlme_reg *reg, qdf_freq_t chan_freq) 4598 { 4599 bool valid = false; 4600 uint32_t i; 4601 uint32_t len = reg->valid_channel_list_num; 4602 4603 for (i = 0; (i < len); i++) { 4604 if (wlan_reg_is_dsrc_freq( 4605 reg->valid_channel_freq_list[i])) 4606 continue; 4607 4608 if (chan_freq == reg->valid_channel_freq_list[i]) { 4609 valid = true; 4610 break; 4611 } 4612 } 4613 4614 return valid; 4615 } 4616 4617 int8_t wlan_get_cfg_max_tx_power(struct wlan_objmgr_psoc *psoc, 4618 struct wlan_objmgr_pdev *pdev, 4619 uint32_t ch_freq) 4620 { 4621 uint32_t cfg_length = 0; 4622 int8_t max_tx_pwr = 0; 4623 struct pwr_channel_info *country_info = NULL; 4624 uint8_t count = 0; 4625 uint8_t maxChannels; 4626 int32_t rem_length = 0; 4627 struct wlan_mlme_psoc_ext_obj *mlme_obj; 4628 4629 mlme_obj = mlme_get_psoc_ext_obj(psoc); 4630 if (!mlme_obj) 4631 return max_tx_pwr; 4632 4633 if (WLAN_REG_IS_5GHZ_CH_FREQ(ch_freq)) { 4634 cfg_length = mlme_obj->cfg.power.max_tx_power_5.len; 4635 } else if (WLAN_REG_IS_24GHZ_CH_FREQ(ch_freq)) { 4636 cfg_length = mlme_obj->cfg.power.max_tx_power_24.len; 4637 4638 } else if (wlan_reg_is_6ghz_chan_freq(ch_freq)) { 4639 return wlan_reg_get_channel_reg_power_for_freq(pdev, 4640 ch_freq); 4641 } else { 4642 return max_tx_pwr; 4643 } 4644 4645 if (!cfg_length) 4646 goto error; 4647 4648 country_info = qdf_mem_malloc(cfg_length); 4649 if (!country_info) 4650 goto error; 4651 4652 if (WLAN_REG_IS_5GHZ_CH_FREQ(ch_freq)) { 4653 if (cfg_length > CFG_MAX_TX_POWER_5_LEN) 4654 goto error; 4655 qdf_mem_copy(country_info, 4656 mlme_obj->cfg.power.max_tx_power_5.data, 4657 cfg_length); 4658 } else if (WLAN_REG_IS_24GHZ_CH_FREQ(ch_freq)) { 4659 if (cfg_length > CFG_MAX_TX_POWER_2_4_LEN) 4660 goto error; 4661 qdf_mem_copy(country_info, 4662 mlme_obj->cfg.power.max_tx_power_24.data, 4663 cfg_length); 4664 } 4665 4666 /* Identify the channel and maxtxpower */ 4667 rem_length = cfg_length; 4668 while (rem_length >= (sizeof(struct pwr_channel_info))) { 4669 maxChannels = country_info[count].num_chan; 4670 max_tx_pwr = country_info[count].max_tx_pwr; 4671 count++; 4672 rem_length -= (sizeof(struct pwr_channel_info)); 4673 4674 if (ch_freq >= country_info[count].first_freq && 4675 ch_freq < (country_info[count].first_freq + maxChannels)) { 4676 break; 4677 } 4678 } 4679 4680 error: 4681 if (country_info) 4682 qdf_mem_free(country_info); 4683 4684 return max_tx_pwr; 4685 } 4686 4687 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) 4688 static 4689 const char *mlme_roam_state_to_string(enum roam_offload_state state) 4690 { 4691 switch (state) { 4692 case WLAN_ROAM_INIT: 4693 return "ROAM_INIT"; 4694 case WLAN_ROAM_DEINIT: 4695 return "ROAM_DEINIT"; 4696 case WLAN_ROAM_RSO_ENABLED: 4697 return "ROAM_RSO_ENABLED"; 4698 case WLAN_ROAM_RSO_STOPPED: 4699 return "ROAM_RSO_STOPPED"; 4700 case WLAN_ROAMING_IN_PROG: 4701 return "ROAMING_IN_PROG"; 4702 case WLAN_ROAM_SYNCH_IN_PROG: 4703 return "ROAM_SYNCH_IN_PROG"; 4704 case WLAN_MLO_ROAM_SYNCH_IN_PROG: 4705 return "MLO_ROAM_SYNCH_IN_PROG"; 4706 default: 4707 return ""; 4708 } 4709 } 4710 4711 static void 4712 mlme_print_roaming_state(uint8_t vdev_id, enum roam_offload_state cur_state, 4713 enum roam_offload_state new_state) 4714 { 4715 mlme_nofl_debug("CM_RSO: vdev%d: [%s(%d)] --> [%s(%d)]", 4716 vdev_id, mlme_roam_state_to_string(cur_state), 4717 cur_state, 4718 mlme_roam_state_to_string(new_state), new_state); 4719 4720 /* TODO: Try to print the state change requestor also */ 4721 } 4722 4723 bool 4724 mlme_get_supplicant_disabled_roaming(struct wlan_objmgr_psoc *psoc, 4725 uint8_t vdev_id) 4726 { 4727 struct wlan_objmgr_vdev *vdev; 4728 struct mlme_legacy_priv *mlme_priv; 4729 bool value; 4730 4731 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4732 WLAN_MLME_OBJMGR_ID); 4733 4734 if (!vdev) { 4735 mlme_legacy_err("vdev object is NULL"); 4736 return 0; 4737 } 4738 4739 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4740 if (!mlme_priv) { 4741 mlme_legacy_err("vdev legacy private object is NULL"); 4742 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4743 return 0; 4744 } 4745 4746 value = mlme_priv->mlme_roam.roam_cfg.supplicant_disabled_roaming; 4747 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4748 4749 return value; 4750 } 4751 4752 void mlme_set_supplicant_disabled_roaming(struct wlan_objmgr_psoc *psoc, 4753 uint8_t vdev_id, bool val) 4754 { 4755 struct wlan_objmgr_vdev *vdev; 4756 struct mlme_legacy_priv *mlme_priv; 4757 4758 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4759 WLAN_MLME_OBJMGR_ID); 4760 4761 if (!vdev) { 4762 mlme_legacy_err("vdev object is NULL"); 4763 return; 4764 } 4765 4766 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4767 if (!mlme_priv) { 4768 mlme_legacy_err("vdev legacy private object is NULL"); 4769 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4770 return; 4771 } 4772 4773 mlme_priv->mlme_roam.roam_cfg.supplicant_disabled_roaming = val; 4774 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4775 } 4776 4777 uint32_t 4778 mlme_get_roam_trigger_bitmap(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 4779 { 4780 struct wlan_objmgr_vdev *vdev; 4781 struct mlme_legacy_priv *mlme_priv; 4782 uint32_t roam_bitmap; 4783 4784 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4785 WLAN_MLME_OBJMGR_ID); 4786 4787 if (!vdev) { 4788 mlme_legacy_err("vdev object is NULL"); 4789 return 0; 4790 } 4791 4792 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4793 if (!mlme_priv) { 4794 mlme_legacy_err("vdev legacy private object is NULL"); 4795 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4796 return 0; 4797 } 4798 4799 roam_bitmap = mlme_priv->mlme_roam.roam_cfg.roam_trigger_bitmap; 4800 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4801 4802 return roam_bitmap; 4803 } 4804 4805 void mlme_set_roam_trigger_bitmap(struct wlan_objmgr_psoc *psoc, 4806 uint8_t vdev_id, uint32_t val) 4807 { 4808 struct wlan_objmgr_vdev *vdev; 4809 struct mlme_legacy_priv *mlme_priv; 4810 4811 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4812 WLAN_MLME_OBJMGR_ID); 4813 if (!vdev) { 4814 mlme_legacy_err("vdev object is NULL"); 4815 return; 4816 } 4817 4818 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4819 if (!mlme_priv) { 4820 mlme_legacy_err("vdev legacy private object is NULL"); 4821 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4822 return; 4823 } 4824 4825 mlme_priv->mlme_roam.roam_cfg.roam_trigger_bitmap = val; 4826 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4827 } 4828 4829 uint8_t 4830 mlme_get_operations_bitmap(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 4831 { 4832 struct wlan_objmgr_vdev *vdev; 4833 struct mlme_legacy_priv *mlme_priv; 4834 uint8_t bitmap; 4835 4836 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4837 WLAN_MLME_OBJMGR_ID); 4838 4839 if (!vdev) { 4840 mlme_legacy_err("vdev object is NULL"); 4841 return 0xFF; 4842 } 4843 4844 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4845 if (!mlme_priv) { 4846 mlme_legacy_err("vdev legacy private object is NULL"); 4847 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4848 return 0xFF; 4849 } 4850 4851 bitmap = mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap; 4852 mlme_legacy_debug("vdev[%d] bitmap[0x%x]", vdev_id, 4853 mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap); 4854 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4855 4856 return bitmap; 4857 } 4858 4859 void 4860 mlme_set_operations_bitmap(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 4861 enum wlan_cm_rso_control_requestor reqs, bool clear) 4862 { 4863 struct wlan_objmgr_vdev *vdev; 4864 struct mlme_legacy_priv *mlme_priv; 4865 4866 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4867 WLAN_MLME_OBJMGR_ID); 4868 if (!vdev) { 4869 mlme_legacy_err("vdev object is NULL"); 4870 return; 4871 } 4872 4873 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4874 if (!mlme_priv) { 4875 mlme_legacy_err("vdev legacy private object is NULL"); 4876 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4877 return; 4878 } 4879 4880 if (clear) 4881 mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap &= ~reqs; 4882 else 4883 mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap |= reqs; 4884 4885 mlme_legacy_debug("vdev[%d] bitmap[0x%x], reqs: %d, clear: %d", vdev_id, 4886 mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap, 4887 reqs, clear); 4888 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4889 } 4890 4891 void 4892 mlme_clear_operations_bitmap(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 4893 { 4894 struct wlan_objmgr_vdev *vdev; 4895 struct mlme_legacy_priv *mlme_priv; 4896 4897 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4898 WLAN_MLME_OBJMGR_ID); 4899 if (!vdev) { 4900 mlme_legacy_err("vdev object is NULL"); 4901 return; 4902 } 4903 4904 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4905 if (!mlme_priv) { 4906 mlme_legacy_err("vdev legacy private object is NULL"); 4907 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4908 return; 4909 } 4910 4911 mlme_priv->mlme_roam.roam_sm.mlme_operations_bitmap = 0; 4912 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4913 } 4914 4915 QDF_STATUS mlme_get_cfg_wlm_level(struct wlan_objmgr_psoc *psoc, 4916 uint8_t *level) 4917 { 4918 struct wlan_mlme_psoc_ext_obj *mlme_obj; 4919 4920 mlme_obj = mlme_get_psoc_ext_obj(psoc); 4921 if (!mlme_obj) 4922 return QDF_STATUS_E_FAILURE; 4923 4924 *level = mlme_obj->cfg.wlm_config.latency_level; 4925 4926 return QDF_STATUS_SUCCESS; 4927 } 4928 4929 QDF_STATUS mlme_get_cfg_wlm_reset(struct wlan_objmgr_psoc *psoc, 4930 bool *reset) 4931 { 4932 struct wlan_mlme_psoc_ext_obj *mlme_obj; 4933 4934 mlme_obj = mlme_get_psoc_ext_obj(psoc); 4935 if (!mlme_obj) 4936 return QDF_STATUS_E_FAILURE; 4937 4938 *reset = mlme_obj->cfg.wlm_config.latency_reset; 4939 4940 return QDF_STATUS_SUCCESS; 4941 } 4942 4943 enum roam_offload_state 4944 mlme_get_roam_state(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id) 4945 { 4946 struct wlan_objmgr_vdev *vdev; 4947 struct mlme_legacy_priv *mlme_priv; 4948 enum roam_offload_state roam_state; 4949 4950 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4951 WLAN_MLME_OBJMGR_ID); 4952 4953 if (!vdev) 4954 return WLAN_ROAM_DEINIT; 4955 4956 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4957 if (!mlme_priv) { 4958 mlme_legacy_err("vdev legacy private object is NULL"); 4959 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4960 return WLAN_ROAM_DEINIT; 4961 } 4962 4963 roam_state = mlme_priv->mlme_roam.roam_sm.state; 4964 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4965 4966 return roam_state; 4967 } 4968 4969 void mlme_set_roam_state(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, 4970 enum roam_offload_state new_state) 4971 { 4972 struct wlan_objmgr_vdev *vdev; 4973 struct mlme_legacy_priv *mlme_priv; 4974 4975 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id, 4976 WLAN_MLME_OBJMGR_ID); 4977 4978 if (!vdev) { 4979 mlme_err("vdev%d: vdev object is NULL", vdev_id); 4980 return; 4981 } 4982 4983 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 4984 if (!mlme_priv) { 4985 mlme_err("vdev%d: vdev legacy private object is NULL", vdev_id); 4986 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4987 return; 4988 } 4989 4990 mlme_print_roaming_state(vdev_id, mlme_priv->mlme_roam.roam_sm.state, 4991 new_state); 4992 mlme_priv->mlme_roam.roam_sm.state = new_state; 4993 wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_OBJMGR_ID); 4994 } 4995 4996 QDF_STATUS 4997 mlme_store_fw_scan_channels(struct wlan_objmgr_psoc *psoc, 4998 tSirUpdateChanList *chan_list) 4999 { 5000 struct wlan_mlme_psoc_ext_obj *mlme_obj; 5001 struct wlan_mlme_lfr_cfg *lfr; 5002 uint16_t i; 5003 5004 mlme_obj = mlme_get_psoc_ext_obj(psoc); 5005 if (!mlme_obj) { 5006 mlme_legacy_err("Failed to get MLME Obj"); 5007 return QDF_STATUS_E_FAILURE; 5008 } 5009 5010 lfr = &mlme_obj->cfg.lfr; 5011 qdf_mem_zero(&lfr->saved_freq_list, sizeof(lfr->saved_freq_list)); 5012 lfr->saved_freq_list.num_channels = chan_list->numChan; 5013 for (i = 0; i < chan_list->numChan; i++) 5014 lfr->saved_freq_list.freq[i] = chan_list->chanParam[i].freq; 5015 5016 mlme_legacy_debug("ROAM: save %d channels", 5017 chan_list->numChan); 5018 5019 return QDF_STATUS_SUCCESS; 5020 } 5021 5022 QDF_STATUS mlme_get_fw_scan_channels(struct wlan_objmgr_psoc *psoc, 5023 uint32_t *freq_list, 5024 uint8_t *saved_num_chan) 5025 { 5026 struct wlan_mlme_psoc_ext_obj *mlme_obj; 5027 struct wlan_mlme_lfr_cfg *lfr; 5028 uint16_t i; 5029 5030 if (!freq_list) { 5031 mlme_legacy_err("ROAM: Freq list is NULL"); 5032 *saved_num_chan = 0; 5033 return QDF_STATUS_E_FAILURE; 5034 } 5035 5036 mlme_obj = mlme_get_psoc_ext_obj(psoc); 5037 if (!mlme_obj) { 5038 mlme_legacy_err("Failed to get MLME Obj"); 5039 *saved_num_chan = 0; 5040 return QDF_STATUS_E_FAILURE; 5041 } 5042 5043 lfr = &mlme_obj->cfg.lfr; 5044 *saved_num_chan = lfr->saved_freq_list.num_channels; 5045 5046 for (i = 0; i < lfr->saved_freq_list.num_channels; i++) 5047 freq_list[i] = lfr->saved_freq_list.freq[i]; 5048 5049 return QDF_STATUS_SUCCESS; 5050 } 5051 #endif 5052 5053 QDF_STATUS wlan_mlme_get_mac_vdev_id(struct wlan_objmgr_pdev *pdev, 5054 uint8_t vdev_id, 5055 struct qdf_mac_addr *self_mac) 5056 { 5057 struct wlan_objmgr_vdev *vdev; 5058 5059 if (!pdev) 5060 return QDF_STATUS_E_INVAL; 5061 5062 vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id, 5063 WLAN_LEGACY_MAC_ID); 5064 if (!vdev) 5065 return QDF_STATUS_E_INVAL; 5066 5067 qdf_mem_copy(self_mac->bytes, 5068 wlan_vdev_mlme_get_macaddr(vdev), QDF_MAC_ADDR_SIZE); 5069 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID); 5070 5071 return QDF_STATUS_SUCCESS; 5072 } 5073 5074 qdf_freq_t 5075 wlan_get_sap_user_config_freq(struct wlan_objmgr_vdev *vdev) 5076 { 5077 struct mlme_legacy_priv *mlme_priv; 5078 enum QDF_OPMODE opmode = QDF_MAX_NO_OF_MODE; 5079 5080 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 5081 if (!mlme_priv) { 5082 mlme_legacy_err("vdev legacy private object is NULL"); 5083 return 0; 5084 } 5085 5086 opmode = wlan_vdev_mlme_get_opmode(vdev); 5087 if (opmode != QDF_SAP_MODE && opmode != QDF_P2P_GO_MODE) { 5088 mlme_debug("Cannot get user config freq for mode %d", opmode); 5089 return 0; 5090 } 5091 5092 return mlme_priv->mlme_ap.user_config_sap_ch_freq; 5093 } 5094 5095 QDF_STATUS 5096 wlan_set_sap_user_config_freq(struct wlan_objmgr_vdev *vdev, 5097 qdf_freq_t freq) 5098 { 5099 struct mlme_legacy_priv *mlme_priv; 5100 enum QDF_OPMODE opmode = QDF_MAX_NO_OF_MODE; 5101 5102 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 5103 if (!mlme_priv) { 5104 mlme_legacy_err("vdev legacy private object is NULL"); 5105 return QDF_STATUS_E_INVAL; 5106 } 5107 5108 opmode = wlan_vdev_mlme_get_opmode(vdev); 5109 if (opmode != QDF_SAP_MODE && opmode != QDF_P2P_GO_MODE) { 5110 mlme_debug("Cannot set user config freq for mode %d", opmode); 5111 return QDF_STATUS_E_FAILURE; 5112 } 5113 5114 mlme_priv->mlme_ap.user_config_sap_ch_freq = freq; 5115 return QDF_STATUS_SUCCESS; 5116 } 5117 5118 #ifdef CONFIG_BAND_6GHZ 5119 bool 5120 wlan_get_tpc_update_required_for_sta(struct wlan_objmgr_vdev *vdev) 5121 { 5122 struct mlme_legacy_priv *mlme_priv; 5123 enum QDF_OPMODE opmode; 5124 5125 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 5126 if (!mlme_priv) { 5127 mlme_legacy_err("vdev legacy private object is NULL"); 5128 return false; 5129 } 5130 5131 opmode = wlan_vdev_mlme_get_opmode(vdev); 5132 if (opmode != QDF_SAP_MODE && opmode != QDF_P2P_GO_MODE) { 5133 mlme_debug("Invalid opmode %d", opmode); 5134 return false; 5135 } 5136 5137 return mlme_priv->mlme_ap.update_required_scc_sta_power; 5138 } 5139 5140 QDF_STATUS 5141 wlan_set_tpc_update_required_for_sta(struct wlan_objmgr_vdev *vdev, bool value) 5142 { 5143 struct mlme_legacy_priv *mlme_priv; 5144 enum QDF_OPMODE opmode; 5145 5146 mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev); 5147 if (!mlme_priv) { 5148 mlme_legacy_err("vdev legacy private object is NULL"); 5149 return QDF_STATUS_E_INVAL; 5150 } 5151 5152 opmode = wlan_vdev_mlme_get_opmode(vdev); 5153 if (opmode != QDF_SAP_MODE && opmode != QDF_P2P_GO_MODE) { 5154 mlme_debug("Invalid mode %d", opmode); 5155 QDF_ASSERT(0); 5156 return QDF_STATUS_E_FAILURE; 5157 } 5158 5159 mlme_priv->mlme_ap.update_required_scc_sta_power = value; 5160 mlme_debug("Set change scc power as %d", value); 5161 return QDF_STATUS_SUCCESS; 5162 } 5163 #endif 5164 5165 QDF_STATUS wlan_mlme_get_sta_num_tx_chains(struct wlan_objmgr_psoc *psoc, 5166 struct wlan_objmgr_vdev *vdev, 5167 uint8_t *tx_chains) 5168 { 5169 bool dynamic_nss_chains_support; 5170 struct wlan_mlme_nss_chains *dynamic_cfg; 5171 enum band_info operating_band; 5172 QDF_STATUS status; 5173 struct vdev_mlme_obj *vdev_mlme; 5174 5175 status = wlan_mlme_cfg_get_dynamic_nss_chains_support 5176 (psoc, &dynamic_nss_chains_support); 5177 if (QDF_IS_STATUS_ERROR(status)) { 5178 mlme_err("Failed to get dynamic_nss_chains_support"); 5179 return QDF_STATUS_E_INVAL; 5180 } 5181 5182 vdev_mlme = 5183 wlan_objmgr_vdev_get_comp_private_obj(vdev, 5184 WLAN_UMAC_COMP_MLME); 5185 if (!vdev_mlme) { 5186 QDF_ASSERT(0); 5187 return false; 5188 } 5189 5190 if (dynamic_nss_chains_support) { 5191 dynamic_cfg = mlme_get_dynamic_vdev_config(vdev); 5192 if (!dynamic_cfg) { 5193 mlme_err("nss chain dynamic config NULL"); 5194 return QDF_STATUS_E_INVAL; 5195 } 5196 5197 operating_band = ucfg_cm_get_connected_band(vdev); 5198 switch (operating_band) { 5199 case BAND_2G: 5200 *tx_chains = 5201 dynamic_cfg->num_tx_chains[NSS_CHAINS_BAND_2GHZ]; 5202 break; 5203 case BAND_5G: 5204 *tx_chains = 5205 dynamic_cfg->num_tx_chains[NSS_CHAINS_BAND_5GHZ]; 5206 break; 5207 default: 5208 mlme_err("Band %d Not 2G or 5G", operating_band); 5209 return QDF_STATUS_E_INVAL; 5210 } 5211 } 5212 5213 return QDF_STATUS_SUCCESS; 5214 } 5215 5216 QDF_STATUS wlan_mlme_get_sta_tx_nss(struct wlan_objmgr_psoc *psoc, 5217 struct wlan_objmgr_vdev *vdev, 5218 uint8_t *tx_nss) 5219 { 5220 uint8_t proto_generic_nss; 5221 bool dynamic_nss_chains_support; 5222 struct wlan_mlme_nss_chains *dynamic_cfg; 5223 enum band_info operating_band; 5224 QDF_STATUS status; 5225 5226 status = wlan_mlme_cfg_get_dynamic_nss_chains_support 5227 (psoc, &dynamic_nss_chains_support); 5228 if (QDF_IS_STATUS_ERROR(status)) { 5229 mlme_err("Failed to get dynamic_nss_chains_support"); 5230 return QDF_STATUS_E_INVAL; 5231 } 5232 5233 proto_generic_nss = wlan_vdev_mlme_get_nss(vdev); 5234 if (dynamic_nss_chains_support) { 5235 dynamic_cfg = mlme_get_dynamic_vdev_config(vdev); 5236 if (!dynamic_cfg) { 5237 mlme_err("nss chain dynamic config NULL"); 5238 return QDF_STATUS_E_INVAL; 5239 } 5240 5241 operating_band = ucfg_cm_get_connected_band(vdev); 5242 switch (operating_band) { 5243 case BAND_2G: 5244 *tx_nss = dynamic_cfg->tx_nss[NSS_CHAINS_BAND_2GHZ]; 5245 break; 5246 case BAND_5G: 5247 *tx_nss = dynamic_cfg->tx_nss[NSS_CHAINS_BAND_5GHZ]; 5248 break; 5249 default: 5250 mlme_err("Band %d Not 2G or 5G", operating_band); 5251 return QDF_STATUS_E_INVAL; 5252 } 5253 5254 if (*tx_nss > proto_generic_nss) 5255 *tx_nss = proto_generic_nss; 5256 } else { 5257 *tx_nss = proto_generic_nss; 5258 } 5259 5260 return QDF_STATUS_SUCCESS; 5261 } 5262 5263 QDF_STATUS wlan_mlme_get_sta_num_rx_chains(struct wlan_objmgr_psoc *psoc, 5264 struct wlan_objmgr_vdev *vdev, 5265 uint8_t *rx_chains) 5266 { 5267 bool dynamic_nss_chains_support; 5268 struct wlan_mlme_nss_chains *dynamic_cfg; 5269 enum band_info operating_band; 5270 QDF_STATUS status; 5271 struct vdev_mlme_obj *vdev_mlme; 5272 5273 status = wlan_mlme_cfg_get_dynamic_nss_chains_support 5274 (psoc, &dynamic_nss_chains_support); 5275 if (QDF_IS_STATUS_ERROR(status)) { 5276 mlme_err("Failed to get dynamic_nss_chains_support"); 5277 return QDF_STATUS_E_INVAL; 5278 } 5279 vdev_mlme = 5280 wlan_objmgr_vdev_get_comp_private_obj(vdev, 5281 WLAN_UMAC_COMP_MLME); 5282 if (!vdev_mlme) { 5283 QDF_ASSERT(0); 5284 return false; 5285 } 5286 5287 if (dynamic_nss_chains_support) { 5288 dynamic_cfg = mlme_get_dynamic_vdev_config(vdev); 5289 if (!dynamic_cfg) { 5290 mlme_err("nss chain dynamic config NULL"); 5291 return QDF_STATUS_E_INVAL; 5292 } 5293 5294 operating_band = ucfg_cm_get_connected_band(vdev); 5295 switch (operating_band) { 5296 case BAND_2G: 5297 *rx_chains = 5298 dynamic_cfg->num_rx_chains[NSS_CHAINS_BAND_2GHZ]; 5299 break; 5300 case BAND_5G: 5301 *rx_chains = 5302 dynamic_cfg->num_rx_chains[NSS_CHAINS_BAND_5GHZ]; 5303 break; 5304 default: 5305 mlme_err("Band %d Not 2G or 5G", operating_band); 5306 return QDF_STATUS_E_INVAL; 5307 } 5308 } 5309 5310 return QDF_STATUS_SUCCESS; 5311 } 5312 5313 QDF_STATUS wlan_mlme_get_sta_rx_nss(struct wlan_objmgr_psoc *psoc, 5314 struct wlan_objmgr_vdev *vdev, 5315 uint8_t *rx_nss) 5316 { 5317 uint8_t proto_generic_nss; 5318 bool dynamic_nss_chains_support; 5319 struct wlan_mlme_nss_chains *dynamic_cfg; 5320 enum band_info operating_band; 5321 QDF_STATUS status; 5322 5323 status = wlan_mlme_cfg_get_dynamic_nss_chains_support 5324 (psoc, &dynamic_nss_chains_support); 5325 if (QDF_IS_STATUS_ERROR(status)) { 5326 mlme_err("Failed to get dynamic_nss_chains_support"); 5327 return QDF_STATUS_E_INVAL; 5328 } 5329 5330 proto_generic_nss = wlan_vdev_mlme_get_nss(vdev); 5331 if (dynamic_nss_chains_support) { 5332 dynamic_cfg = mlme_get_dynamic_vdev_config(vdev); 5333 if (!dynamic_cfg) { 5334 mlme_err("nss chain dynamic config NULL"); 5335 return QDF_STATUS_E_INVAL; 5336 } 5337 5338 operating_band = ucfg_cm_get_connected_band(vdev); 5339 switch (operating_band) { 5340 case BAND_2G: 5341 *rx_nss = dynamic_cfg->rx_nss[NSS_CHAINS_BAND_2GHZ]; 5342 break; 5343 case BAND_5G: 5344 *rx_nss = dynamic_cfg->rx_nss[NSS_CHAINS_BAND_5GHZ]; 5345 break; 5346 default: 5347 mlme_err("Band %d Not 2G or 5G", operating_band); 5348 return QDF_STATUS_E_INVAL; 5349 } 5350 5351 if (*rx_nss > proto_generic_nss) 5352 *rx_nss = proto_generic_nss; 5353 } else { 5354 *rx_nss = proto_generic_nss; 5355 } 5356 5357 return QDF_STATUS_SUCCESS; 5358 } 5359 5360 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 5361 QDF_STATUS 5362 wmi_extract_peer_oper_mode_event(wmi_unified_t wmi_handle, 5363 uint8_t *event, 5364 uint32_t len, 5365 struct peer_oper_mode_event *data) 5366 { 5367 if (wmi_handle->ops->extract_peer_oper_mode_event) 5368 return wmi_handle->ops->extract_peer_oper_mode_event(wmi_handle, 5369 event, 5370 len, data); 5371 return QDF_STATUS_E_FAILURE; 5372 } 5373 5374 int mlme_peer_oper_mode_change_event_handler(ol_scn_t scn, 5375 uint8_t *event, 5376 uint32_t len) 5377 { 5378 struct wlan_objmgr_psoc *psoc; 5379 struct wmi_unified *wmi_handle; 5380 struct peer_oper_mode_event data = {0}; 5381 struct wlan_mlme_rx_ops *mlme_rx_ops; 5382 QDF_STATUS qdf_status; 5383 5384 psoc = target_if_get_psoc_from_scn_hdl(scn); 5385 if (!psoc) { 5386 target_if_err("psoc is null"); 5387 return -EINVAL; 5388 } 5389 5390 wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); 5391 if (!wmi_handle) { 5392 mlme_err("wmi_handle is null"); 5393 return -EINVAL; 5394 } 5395 5396 qdf_status = wmi_extract_peer_oper_mode_event(wmi_handle, event, 5397 len, &data); 5398 if (QDF_IS_STATUS_ERROR(qdf_status)) { 5399 mlme_err("parsing of event failed, %d", qdf_status); 5400 return -EINVAL; 5401 } 5402 5403 mlme_rx_ops = mlme_get_rx_ops(psoc); 5404 if (!mlme_rx_ops || !mlme_rx_ops->peer_oper_mode_eventid) { 5405 mlme_err("No valid roam rx ops"); 5406 return -EINVAL; 5407 } 5408 5409 qdf_status = mlme_rx_ops->peer_oper_mode_eventid(psoc, &data); 5410 if (QDF_IS_STATUS_ERROR(qdf_status)) { 5411 mlme_err("peer_oper_mode_change_event Failed"); 5412 return -EINVAL; 5413 } 5414 5415 return QDF_STATUS_SUCCESS; 5416 } 5417 5418 QDF_STATUS wlan_mlme_register_common_events(struct wlan_objmgr_psoc *psoc) 5419 { 5420 QDF_STATUS ret; 5421 wmi_unified_t handle = get_wmi_unified_hdl_from_psoc(psoc); 5422 5423 if (!handle) { 5424 mlme_err("handle is NULL"); 5425 return QDF_STATUS_E_FAILURE; 5426 } 5427 5428 /* Register for peer operating mode change devent */ 5429 ret = wmi_unified_register_event_handler(handle, 5430 wmi_peer_oper_mode_change_event_id, 5431 mlme_peer_oper_mode_change_event_handler, 5432 WMI_RX_SERIALIZER_CTX); 5433 if (QDF_IS_STATUS_ERROR(ret)) { 5434 mlme_err("wmi event(%u) registration failed, ret: %d", 5435 wmi_peer_oper_mode_change_event_id, ret); 5436 return QDF_STATUS_E_FAILURE; 5437 } 5438 return QDF_STATUS_SUCCESS; 5439 } 5440 #endif 5441