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