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