1 /* 2 * Copyright (c) 2012-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 any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 /** 19 * DOC: This file contains MLME SCORING related CFG/INI Items. 20 */ 21 22 #ifndef __CFG_MLME_SCORE_PARAMS_H 23 #define __CFG_MLME_SCORE_PARAMS_H 24 25 #ifdef CONNECTION_ROAMING_CFG 26 #define RoamAPScore_RSSIWeight_min 0 27 #define RoamAPScore_RSSIWeight_max 100 28 #define RoamAPScore_RSSIWeight_default 65 29 # define ROAMAPSCORE_CUWEIGHT_MIN 0 30 # define ROAMAPSCORE_CUWEIGHT_MAX 100 31 # define ROAMAPSCORE_CUWEIGHT_DEFAULT 35 32 #else 33 #define RoamAPScore_RSSIWeight_min 0 34 #define RoamAPScore_RSSIWeight_max 100 35 #define RoamAPScore_RSSIWeight_default 20 36 # define ROAMAPSCORE_CUWEIGHT_MIN 0 37 # define ROAMAPSCORE_CUWEIGHT_MAX 100 38 # define ROAMAPSCORE_CUWEIGHT_DEFAULT 25 39 #endif 40 /* 41 * <ini> 42 * rssi_weightage/RoamAPScore_RSSIWeight - RSSI Weightage to calculate best 43 * candidate 44 * @Min: 0 45 * @Max: 100 46 * @Default: 20 47 * 48 * This ini is used to increase/decrease RSSI weightage in best candidate 49 * selection. AP with better RSSI will get more weightage. 50 * 51 * Related: None 52 * 53 * Supported Feature: STA Candidate selection 54 * 55 * Usage: External 56 * 57 * </ini> 58 */ 59 #define CFG_SCORING_RSSI_WEIGHTAGE CFG_INI_UINT( \ 60 "rssi_weightage RoamAPScore_RSSIWeight", \ 61 RoamAPScore_RSSIWeight_min, \ 62 RoamAPScore_RSSIWeight_max, \ 63 RoamAPScore_RSSIWeight_default, \ 64 CFG_VALUE_OR_DEFAULT, \ 65 "RSSI Weightage") 66 67 /* 68 * <ini> 69 * ht_caps_weightage - HT caps weightage to calculate best candidate 70 * @Min: 0 71 * @Max: 100 72 * @Default: 2 73 * 74 * This ini is used to increase/decrease HT caps weightage in best candidate 75 * selection. If AP supports HT caps, AP will get additional Weightage with 76 * this param. Weightage will be given only if dot11mode is HT capable. 77 * 78 * Related: None 79 * 80 * Supported Feature: STA Candidate selection 81 * 82 * Usage: External 83 * 84 * </ini> 85 */ 86 #define CFG_SCORING_HT_CAPS_WEIGHTAGE CFG_INI_UINT( \ 87 "ht_caps_weightage", \ 88 0, \ 89 100, \ 90 2, \ 91 CFG_VALUE_OR_DEFAULT, \ 92 "HT Caps Weightage") 93 94 /* 95 * <ini> 96 * vht_caps_weightage - VHT caps Weightage to calculate best candidate 97 * @Min: 0 98 * @Max: 100 99 * @Default: 1 100 * 101 * This ini is used to increase/decrease VHT caps weightage in best candidate 102 * selection. If AP supports VHT caps, AP will get additional weightage with 103 * this param. Weightage will be given only if dot11mode is VHT capable. 104 * 105 * Related: None 106 * 107 * Supported Feature: STA Candidate selection 108 * 109 * Usage: External 110 * 111 * </ini> 112 */ 113 #define CFG_SCORING_VHT_CAPS_WEIGHTAGE CFG_INI_UINT( \ 114 "vht_caps_weightage", \ 115 0, \ 116 100, \ 117 1, \ 118 CFG_VALUE_OR_DEFAULT, \ 119 "HT Caps Weightage") 120 121 /* 122 * <ini> 123 * he_caps_weightage - HE caps Weightage to calculate best candidate 124 * @Min: 0 125 * @Max: 100 126 * @Default: 2 127 * 128 * This ini is used to increase/decrease HE caps weightage in best candidate 129 * selection. If AP supports HE caps, AP will get additional weightage with 130 * this param. Weightage will be given only if dot11mode is HE capable. 131 * 132 * Related: None 133 * 134 * Supported Feature: STA Candidate selection 135 * 136 * Usage: External 137 * 138 * </ini> 139 */ 140 #define CFG_SCORING_HE_CAPS_WEIGHTAGE CFG_INI_UINT( \ 141 "he_caps_weightage", \ 142 0, \ 143 100, \ 144 2, \ 145 CFG_VALUE_OR_DEFAULT, \ 146 "HE Caps Weightage") 147 148 /* 149 * <ini> 150 * chan_width_weightage - Channel Width Weightage to calculate best candidate 151 * @Min: 0 152 * @Max: 100 153 * @Default: 20 154 * 155 * This ini is used to increase/decrease Channel Width weightage in best 156 * candidate selection. AP with Higher channel width will get higher weightage 157 * 158 * Related: bandwidth_weight_per_index 159 * 160 * Supported Feature: STA Candidate selection 161 * 162 * Usage: External 163 * 164 * </ini> 165 */ 166 #define CFG_SCORING_CHAN_WIDTH_WEIGHTAGE CFG_INI_UINT( \ 167 "chan_width_weightage", \ 168 0, \ 169 100, \ 170 20, \ 171 CFG_VALUE_OR_DEFAULT, \ 172 "Channel width weightage") 173 174 /* 175 * <ini> 176 * chan_band_weightage - Channel Band preference to 5GHZ to 177 * calculate best candidate 178 * @Min: 0 179 * @Max: 100 180 * @Default: 2 181 * 182 * This ini is used to increase/decrease Channel Band Preference weightage 183 * in best candidate selection. 5GHZ AP get this additional boost compare to 184 * 2GHZ AP before rssi_pref_5g_rssi_thresh and 2.4Ghz get weightage after 185 * rssi_pref_5g_rssi_thresh. 186 * 187 * Related: rssi_pref_5g_rssi_thresh, band_weight_per_index 188 * 189 * Supported Feature: STA Candidate selection 190 * 191 * Usage: External 192 * 193 * </ini> 194 */ 195 #define CFG_SCORING_CHAN_BAND_WEIGHTAGE CFG_INI_UINT( \ 196 "chan_band_weightage", \ 197 0, \ 198 100, \ 199 2, \ 200 CFG_VALUE_OR_DEFAULT, \ 201 "Channel Band Weightage") 202 203 /* 204 * <ini> 205 * nss_weightage - NSS Weightage to calculate best candidate 206 * @Min: 0 207 * @Max: 100 208 * @Default: 20 209 * 210 * This ini is used to increase/decrease NSS weightage in best candidate 211 * selection. If there are two AP, one AP supports 2x2 and another one supports 212 * 1x1 and station supports 2X2, first A will get this additional weightage 213 * depending on self-capability. 214 * 215 * Related: nss_weight_per_index 216 * 217 * Supported Feature: STA Candidate selection 218 * 219 * Usage: External 220 * 221 * </ini> 222 */ 223 #define CFG_SCORING_NSS_WEIGHTAGE CFG_INI_UINT( \ 224 "nss_weightage", \ 225 0, \ 226 100, \ 227 20, \ 228 CFG_VALUE_OR_DEFAULT, \ 229 "NSS Weightage") 230 /* 231 * <ini> 232 * beamforming_cap_weightage - Beam Forming Weightage to 233 * calculate best candidate 234 * @Min: 0 235 * @Max: 100 236 * @Default: 2 237 * 238 * This ini is used to increase/decrease Beam forming Weightage if some AP 239 * support Beam forming or not. If AP supports Beam forming, that AP will get 240 * additional boost of this weightage. 241 * 242 * Related: None 243 * 244 * Supported Feature: STA Candidate selection 245 * 246 * Usage: External 247 * 248 * </ini> 249 */ 250 #define CFG_SCORING_BEAMFORM_CAP_WEIGHTAGE CFG_INI_UINT( \ 251 "beamforming_cap_weightage", \ 252 0, \ 253 100, \ 254 PLATFORM_VALUE(2, 0), \ 255 CFG_VALUE_OR_DEFAULT, \ 256 "Beamforming Cap Weightage") 257 258 /* 259 * <ini> 260 * pcl_weightage - PCL Weightage to calculate best candidate 261 * @Min: 0 262 * @Max: 100 263 * @Default: 10 264 * 265 * This ini is used to increase/decrease PCL weightage in best candidate 266 * selection. If some APs are in PCL list, those AP will get addition 267 * weightage. 268 * 269 * Related: None 270 * 271 * Supported Feature: STA Candidate selection 272 * 273 * Usage: External 274 * 275 * </ini> 276 */ 277 #define CFG_SCORING_PCL_WEIGHTAGE CFG_INI_UINT( \ 278 "pcl_weightage", \ 279 0, \ 280 100, \ 281 PLATFORM_VALUE(10, 0), \ 282 CFG_VALUE_OR_DEFAULT, \ 283 "PCL Weightage") 284 285 /* 286 * <ini> 287 * channel_congestion_weightage - channel Congestion 288 * Weightage to 289 * calculate best candidate 290 * @Min: 0 291 * @Max: 100 292 * @Default: 25 293 * 294 * This ini is used to increase/decrease channel congestion weightage in 295 * candidate selection. Congestion is measured with the help of ESP/QBSS load. 296 * 297 * Related: num_esp_qbss_slots 298 * 299 * Supported Feature: STA Candidate selection 300 * 301 * Usage: External 302 * 303 * </ini> 304 */ 305 306 /* 307 * <ini> 308 * RoamAPScore_CUWeight - roamapscore cu weight 309 * Weightage to 310 * calculate best candidate 311 * @Min: 0 312 * @Max: 100 313 * @Default: 35 314 * 315 * This ini is used to increase/decrease channel congestion weightage in 316 * candidate selection. Congestion is measured with the help of ESP/QBSS load. 317 * 318 * Related: num_esp_qbss_slots 319 * 320 * Supported Feature: STA Candidate selection 321 * 322 * Usage: External 323 * 324 * </ini> 325 */ 326 #define CFG_SCORING_CHAN_CONGESTION_WEIGHTAGE CFG_INI_UINT( \ 327 "channel_congestion_weightage RoamAPScore_CUWeight", \ 328 ROAMAPSCORE_CUWEIGHT_MIN, \ 329 ROAMAPSCORE_CUWEIGHT_MAX, \ 330 ROAMAPSCORE_CUWEIGHT_DEFAULT, \ 331 CFG_VALUE_OR_DEFAULT, \ 332 "Channel Congestion Weightage") 333 334 /* 335 * <ini> 336 * oce_wan_weightage - OCE WAN DL capacity Weightage to calculate best candidate 337 * @Min: 0 338 * @Max: 100 339 * @Default: 2 340 * 341 * This ini is used to increase/decrease OCE WAN caps weightage in best 342 * candidate selection. If AP have OCE WAN information, give weightage depending 343 * on the downaload available capacity. 344 * 345 * Related: num_oce_wan_slots 346 * 347 * Supported Feature: STA Candidate selection 348 * 349 * Usage: External 350 * 351 * </ini> 352 */ 353 #define CFG_SCORING_OCE_WAN_WEIGHTAGE CFG_INI_UINT( \ 354 "oce_wan_weightage", \ 355 0, \ 356 100, \ 357 PLATFORM_VALUE(2, 0), \ 358 CFG_VALUE_OR_DEFAULT, \ 359 "OCE WAN Weightage") 360 361 /* 362 * <ini> 363 * oce_ap_tx_pwr_weightage - update scoring param based on ap tx power 364 * @Min: 0 365 * @Max: 10 366 * @Default: 5 367 * 368 * This ini is used to store calculate weightage based on ap tx power. 369 * 370 * Related: None 371 * 372 * Supported Feature: STA 373 * 374 * Usage: External 375 * 376 * </ini> 377 */ 378 #define CFG_OCE_AP_TX_PWR_WEIGHTAGE CFG_INI_UINT( \ 379 "oce_ap_tx_pwr_weightage", \ 380 0, \ 381 10, \ 382 PLATFORM_VALUE(5, 0), \ 383 CFG_VALUE_OR_DEFAULT,\ 384 "AP weigtage for OCE ap tx power") 385 386 /* 387 * <ini> 388 * oce_subnet_id_weightage - update scoring param based on subnet id 389 * @Min: 0 390 * @Max: 10 391 * @Default: 3 392 * 393 * This ini is used to calculate subnet id weightage in roam score. 394 * If the MBO-OCE ie has "IP subnet indication attribute", then host 395 * considers 50% of the "oce_subnet_id_weightage" value to calculate 396 * roam score for the initial connection and 100% of the 397 * "oce_subnet_id_weightage" value to calculate roam score for roaming 398 * case. 399 * "oce_ap_tx_pwr_weightage" adds a small amount of percentage advantage 400 * in roam score while selection of an AP candidate within the same subnet 401 * ID. If "oce_ap_tx_pwr_weightage" value is 0(min), roam score doesn't 402 * include percentage weightage for subnet id and if "oce_ap_tx_pwr_weightage" 403 * value is 10(max), then the weightage given because of same subnet ID is 404 * more in roam score. This ini is also used for WFA certification. 405 * 406 * Related: None 407 * 408 * Supported Feature: STA 409 * 410 * Usage: External 411 * 412 * </ini> 413 */ 414 #define CFG_OCE_SUBNET_ID_WEIGHTAGE CFG_INI_UINT( \ 415 "oce_subnet_id_weightage", \ 416 0, \ 417 10, \ 418 PLATFORM_VALUE(3, 0), \ 419 CFG_VALUE_OR_DEFAULT,\ 420 "AP weigtage for OCE subnet id") 421 422 /* 423 * <ini> 424 * sae_pk_ap_weightage - update scoring param based on SAE PK ap weightage 425 * @Min: 0 426 * @Max: 30 427 * @Default: 30 428 * 429 * This ini is used to calculate SAE PK ap weightage in roam score. SAE Public 430 * Key (SAE-PK) authentication is an extension of SAE that is intended for use 431 * cases where authentication is based on a password that might be 432 * distributed to or obtained by a potential adversary. With SAE-PK, the AP in 433 * an infrastructure network is additionally authenticated based on a static 434 * public/private key pair. This ini is also used for WFA certification. 435 * 436 * Related: None 437 * 438 * Supported Feature: STA 439 * 440 * Usage: External 441 * 442 * </ini> 443 */ 444 #define CFG_SAE_PK_AP_WEIGHTAGE CFG_INI_UINT( \ 445 "sae_pk_ap_weightage", \ 446 0, \ 447 30, \ 448 PLATFORM_VALUE(30, 0), \ 449 CFG_VALUE_OR_DEFAULT,\ 450 "SAE-PK AP weightage") 451 452 /* 453 * <ini> 454 * best_rssi_threshold - Best Rssi for score calculation 455 * @Min: 0 456 * @Max: 96 457 * @Default: 55 458 * 459 * This ini tells limit for best RSSI. RSSI better than this limit are 460 * considered as best RSSI. The best RSSI is given full rssi_weightage. 461 * 462 * Related: rssi_weightage 463 * 464 * Supported Feature: STA Candidate selection 465 * 466 * Usage: External 467 * 468 * </ini> 469 */ 470 #define CFG_SCORING_BEST_RSSI_THRESHOLD CFG_INI_UINT( \ 471 "best_rssi_threshold", \ 472 0, \ 473 96, \ 474 55, \ 475 CFG_VALUE_OR_DEFAULT, \ 476 "Best RSSI threshold") 477 478 /* 479 * <ini> 480 * good_rssi_threshold - Good Rssi for score calculation 481 * @Min: 0 482 * @Max: 96 483 * @Default: 70 484 * 485 * This ini tells limit for good RSSI. RSSI better than this limit and less 486 * than best_rssi_threshold is considered as good RSSI. 487 * 488 * Related: rssi_weightage, best_rssi_threshold 489 * 490 * Supported Feature: STA Candidate selection 491 * 492 * Usage: External 493 * 494 * </ini> 495 */ 496 #define CFG_SCORING_GOOD_RSSI_THRESHOLD CFG_INI_UINT( \ 497 "good_rssi_threshold", \ 498 0, \ 499 96, \ 500 70, \ 501 CFG_VALUE_OR_DEFAULT, \ 502 "Good RSSI threshold") 503 504 /* 505 * <ini> 506 * bad_rssi_threshold - Bad Rssi for score calculation 507 * @Min: 0 508 * @Max: 96 509 * @Default: 80 510 * 511 * This ini tells limit for Bad RSSI. RSSI greater then bad_rssi_threshold 512 * is considered as bad RSSI. 513 * 514 * Related: rssi_weightage, good_rssi_threshold 515 * 516 * Supported Feature: STA Candidate selection 517 * 518 * Usage: External 519 * 520 * </ini> 521 */ 522 #define CFG_SCORING_BAD_RSSI_THRESHOLD CFG_INI_UINT( \ 523 "bad_rssi_threshold", \ 524 0, \ 525 96, \ 526 80, \ 527 CFG_VALUE_OR_DEFAULT, \ 528 "Bad RSSI threshold") 529 530 /* 531 * <ini> 532 * good_rssi_pcnt - Percent Score to Good RSSI out of total RSSI score. 533 * @Min: 0 534 * @Max: 100 535 * @Default: 80 536 * 537 * This ini tells about how much percent should be given to good RSSI(RSSI 538 * between best_rssi_threshold and good_rssi_threshold) out of RSSI weightage. 539 * 540 * Related: rssi_weightage, best_rssi_threshold, good_rssi_threshold 541 * 542 * Supported Feature: STA Candidate selection 543 * 544 * Usage: External 545 * 546 * </ini> 547 */ 548 #define CFG_SCORING_GOOD_RSSI_PERCENT CFG_INI_UINT( \ 549 "good_rssi_pcnt", \ 550 0, \ 551 100, \ 552 80, \ 553 CFG_VALUE_OR_DEFAULT, \ 554 "Good RSSI Percent") 555 556 /* 557 * <ini> 558 * bad_rssi_pcnt - Percent Score to BAD RSSI out of total RSSI score. 559 * @Min: 0 560 * @Max: 100 561 * @Default: 25 562 * 563 * This ini tells about how much percent should be given to bad RSSI (RSSI 564 * between good_rssi_threshold and bad_rssi_threshold) out of RSSI weightage. 565 * 566 * Related: rssi_weightage, good_rssi_threshold, bad_rssi_threshold 567 * 568 * Supported Feature: STA Candidate selection 569 * 570 * Usage: External 571 * 572 * </ini> 573 */ 574 #define CFG_SCORING_BAD_RSSI_PERCENT CFG_INI_UINT( \ 575 "bad_rssi_pcnt", \ 576 0, \ 577 100, \ 578 25, \ 579 CFG_VALUE_OR_DEFAULT, \ 580 "Bad RSSI Percent") 581 582 /* 583 * <ini> 584 * good_rssi_bucket_size - Bucket size between best and good RSSI to score. 585 * @Min: 1 586 * @Max: 10 587 * @Default: 5 588 * 589 * This ini tells about bucket size for scoring between best and good RSSI. 590 * Below Best RSSI, 100% score will be given. Between best and good RSSI, RSSI 591 * is divided in buckets and score will be assigned bucket wise starting from 592 * good_rssi_pcnt. 593 * 594 * Related: rssi_weightage, good_rssi_pcnt 595 * 596 * Supported Feature: STA Candidate selection 597 * 598 * Usage: External 599 * 600 * </ini> 601 */ 602 #define CFG_SCORING_GOOD_RSSI_BUCKET_SIZE CFG_INI_UINT( \ 603 "good_rssi_bucket_size", \ 604 1, \ 605 10, \ 606 5, \ 607 CFG_VALUE_OR_DEFAULT, \ 608 "Good RSSI Bucket Size") 609 610 /* 611 * <ini> 612 * bad_rssi_bucket_size - Bucket size between good and bad RSSI to score. 613 * @Min: 1 614 * @Max: 10 615 * @Default: 5 616 * 617 * This ini tells about bucket size for scoring between good and bad RSSI. 618 * Between good and bad RSSI, RSSI is divided in buckets and score will be 619 * assigned bucket wise starting from bad_rssi_pcnt. 620 * 621 * Related: rssi_weightage, bad_rssi_pcnt 622 * 623 * Supported Feature: STA Candidate selection 624 * 625 * Usage: External 626 * 627 * </ini> 628 */ 629 #define CFG_SCORING_BAD_RSSI_BUCKET_SIZE CFG_INI_UINT( \ 630 "bad_rssi_bucket_size", \ 631 1, \ 632 10, \ 633 5, \ 634 CFG_VALUE_OR_DEFAULT, \ 635 "Bad RSSI Bucket Size") 636 637 /* 638 * <ini> 639 * rssi_pref_5g_rssi_thresh - A RSSI threshold above which 5 GHz is not favored 640 * @Min: 0 641 * @Max: 96 642 * @Default: 76 643 * 644 * 5G AP are given chan_band_weightage. This ini tells about RSSI threshold 645 * above which 5GHZ is not favored. 646 * 647 * Related: chan_band_weightage 648 * 649 * Supported Feature: STA Candidate selection 650 * 651 * Usage: External 652 * 653 * </ini> 654 */ 655 #define CFG_SCORING_RSSI_PREF_5G_THRESHOLD CFG_INI_UINT( \ 656 "rssi_pref_5g_rssi_thresh", \ 657 0, \ 658 96, \ 659 76, \ 660 CFG_VALUE_OR_DEFAULT, \ 661 "RSSI Pref 5G Threshold") 662 663 /* 664 * <ini> 665 * ConNonHint_TargetMinRSSI - min RSSI value for connection. 666 * @Min: -95 667 * @Max: -40 668 * @Default: -75 669 * 670 * This ini sets threshold for RSSI, below which BSSID is not considered for 671 * connection. 672 * 673 * Supported Feature: STA Candidate selection 674 * 675 * Usage: External 676 * 677 * </ini> 678 */ 679 #define CFG_CON_NON_HINT_TARGET_MIN_RSSI CFG_INI_UINT(\ 680 "ConNonHint_TargetMinRSSI",\ 681 -95, \ 682 -40,\ 683 -75, \ 684 CFG_VALUE_OR_DEFAULT, \ 685 "Threshold RSSI value for connection") 686 687 #ifdef WLAN_FEATURE_11BE 688 /* 689 * <ini> 690 * bandwidth_weight_per_index - percentage as per bandwidth 691 * @Min: 0x00000000 692 * @Max: 0x64646464 693 * @Default: 0x552A150A 694 * 695 * This INI give percentage value of chan_width_weightage to be used as per 696 * peer bandwidth. Self BW is also considered while calculating score. Eg if 697 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 698 * capability. 699 * 700 * Indexes are defined in this way. 701 * 0 Index (BITS 0-7): 20 MHz - Def 10% 702 * 1 Index (BITS 8-15): 40 MHz - Def 21% 703 * 2 Index (BITS 16-23): 80 MHz - Def 42% 704 * 3 Index (BITS 24-31): 160 MHz - Def 85% 705 * These percentage values are stored in HEX. For any index max value, can be 64 706 * 707 * Related: chan_width_weightage 708 * 709 * Supported Feature: STA Candidate selection 710 * 711 * Usage: External 712 * 713 * </ini> 714 */ 715 #define CFG_SCORING_BW_WEIGHT_PER_IDX CFG_INI_UINT( \ 716 "bandwidth_weight_per_index", \ 717 0x00000000, \ 718 0x64646464, \ 719 0x552A150A, \ 720 CFG_VALUE_OR_DEFAULT, \ 721 "Bandwidth weight per index") 722 #else 723 /* 724 * <ini> 725 * bandwidth_weight_per_index - percentage as per bandwidth 726 * @Min: 0x00000000 727 * @Max: 0x64646464 728 * @Default: 0x6432190C 729 * 730 * This INI give percentage value of chan_width_weightage to be used as per 731 * peer bandwidth. Self BW is also considered while calculating score. Eg if 732 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 733 * capability. 734 * 735 * Indexes are defined in this way. 736 * 0 Index (BITS 0-7): 20 MHz - Def 12% 737 * 1 Index (BITS 8-15): 40 MHz - Def 25% 738 * 2 Index (BITS 16-23): 80 MHz - Def 50% 739 * 3 Index (BITS 24-31): 160 MHz - Def 100% 740 * These percentage values are stored in HEX. For any index max value, can be 64 741 * 742 * Related: chan_width_weightage 743 * 744 * Supported Feature: STA Candidate selection 745 * 746 * Usage: External 747 * 748 * </ini> 749 */ 750 #define CFG_SCORING_BW_WEIGHT_PER_IDX CFG_INI_UINT( \ 751 "bandwidth_weight_per_index", \ 752 0x00000000, \ 753 0x64646464, \ 754 0x6432190C, \ 755 CFG_VALUE_OR_DEFAULT, \ 756 "Bandwidth weight per index") 757 #endif 758 759 /* 760 * <ini> 761 * nss_weight_per_index - percentage as per NSS 762 * @Min: 0x00000000 763 * @Max: 0x64646464 764 * @Default: 0x5032190C 765 * 766 * This INI give percentage value of nss_weightage to be used as per peer NSS. 767 * Self NSS capability is also considered. Eg if self NSS is 1x1 10% will be 768 * given for all AP irrespective of the AP capability. 769 * 770 * Indexes are defined in this way. 771 * 0 Index (BITS 0-7): 1X1- Def 12% 772 * 1 Index (BITS 8-15): 2X2- Def 25% 773 * 2 Index (BITS 16-23): 3X3- Def 50% 774 * 3 Index (BITS 24-31): 4X4- Def 80% 775 * These percentage values are stored in HEX. For any index max value, can be 64 776 * 777 * Related: nss_weightage 778 * 779 * Supported Feature: STA Candidate selection 780 * 781 * Usage: External 782 * 783 * </ini> 784 */ 785 #define CFG_SCORING_NSS_WEIGHT_PER_IDX CFG_INI_UINT( \ 786 "nss_weight_per_index", \ 787 0x00000000, \ 788 0x64646464, \ 789 0x5032190C, \ 790 CFG_VALUE_OR_DEFAULT, \ 791 "NSS weight per index") 792 793 /* 794 * <ini> 795 * band_weight_per_index - percentage as per band 796 * @Min: 0x00000000 797 * @Max: 0x64646464 798 * @Default: 0x0000644B 799 * 800 * This INI give percentage value of chan_band_weightage to be used as per band. 801 * If RSSI is greater than rssi_pref_5g_rssi_thresh preference is given for 5Ghz 802 * else, it's given for 2.4Ghz. 803 * 804 * Indexes are defined in this way. 805 * 0 Index (BITS 0-7): 2.4GHz - Def 10% 806 * 1 Index (BITS 8-15): 5GHz - Def 20% 807 * 2 Index (BITS 16-23): 6Ghz - Def - 100% 808 * 3 Index (BITS 24-31): Reserved 809 * These percentage values are stored in HEX. For any index max value, can be 64 810 * 811 * Related: chan_band_weightage, rssi_pref_5g_rssi_thresh 812 * 813 * Supported Feature: STA Candidate selection 814 * 815 * Usage: External 816 * 817 * </ini> 818 */ 819 #define CFG_SCORING_BAND_WEIGHT_PER_IDX CFG_INI_UINT( \ 820 "band_weight_per_index", \ 821 0x00000000, \ 822 0x64646464, \ 823 0x00644B32, \ 824 CFG_VALUE_OR_DEFAULT, \ 825 "Band weight per index") 826 827 /* 828 * <ini> 829 * num_esp_qbss_slots - number of slots in which the esp/qbss load will 830 * be divided 831 * 832 * @Min: 1 833 * @Max: 15 834 * @Default: 8 835 * 836 * Number of slots in which the esp/qbss load will be divided. Max 15. index 0 837 * is used for 'not_present. Num_slot will equally divide 100. e.g, if 838 * num_slot = 4 slot 1 = 0-25% load, slot 2 = 26-50% load, slot 3 = 51-75% load, 839 * slot 4 = 76-100% load. Remaining unused index can be 0. 840 * Following is load percentage, score percentage and score of num_slot = 8, 841 * weight=25. 842 * 0-12% 13-25% 26-38% 39-50% 51-63 %64-75% 76-88% 87-100% Not Present 843 * 100% 90% 80% 70% 50% 25% 10% 5% 50% 844 * 2500 2250 2000 1750 1250 625 250 125 1250 845 * 846 * Usage: External 847 * 848 * </ini> 849 */ 850 #define CFG_SCORING_NUM_ESP_QBSS_SLOTS CFG_INI_UINT( \ 851 "num_esp_qbss_slots", \ 852 1, \ 853 15, \ 854 8, \ 855 CFG_VALUE_OR_DEFAULT, \ 856 "Num ESP QPSS Slots") 857 858 /* 859 * <ini> 860 * esp_qbss_score_idx3_to_0 - percentage for esp/qbss load for slots 0-3 861 * @Min: 0x00000000 862 * @Max: 0x64646464 863 * @Default: 0x505A6432 864 * 865 * This INI give percentage value of channel_congestion_weightage to be used as 866 * index in which the load value falls. Index 0 is for percentage when ESP/QBSS 867 * is not present. 868 * 869 * Indexes are defined in this way. 870 * 0 Index (BITS 0-7): when ESP/QBSS is not present 871 * 1 Index (BITS 8-15): SLOT_1 872 * 2 Index (BITS 16-23): SLOT_2 873 * 3 Index (BITS 24-31): SLOT_3 874 * These percentage values are stored in HEX. For any index max value, can be 64 875 * 876 * Related: channel_congestion_weightage, num_esp_qbss_slots 877 * 878 * Supported Feature: STA Candidate selection 879 * 880 * Usage: External 881 * 882 * </ini> 883 */ 884 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_3_TO_0 CFG_INI_UINT( \ 885 "esp_qbss_score_idx3_to_0", \ 886 0x00000000, \ 887 0x64646464, \ 888 0x505A6432, \ 889 CFG_VALUE_OR_DEFAULT, \ 890 "ESP QPSS Score Index 3 to 0") 891 892 /* 893 * <ini> 894 * esp_qbss_score_idx7_to_4 - percentage for esp/qbss load for slots 4-7 895 * @Min: 0x00000000 896 * @Max: 0x64646464 897 * @Default: 0x0A193246 898 * 899 * This INI give percentage value of channel_congestion_weightage to be used as 900 * index in which the load value falls. Used only if num_esp_qbss_slots is 901 * greater than 3. 902 * 903 * Indexes are defined in this way. 904 * 0 Index (BITS 0-7): SLOT_4 905 * 1 Index (BITS 8-15): SLOT_5 906 * 2 Index (BITS 16-23): SLOT_6 907 * 3 Index (BITS 24-31): SLOT_7 908 * These percentage values are stored in HEX. For any index max value, can be 64 909 * 910 * Related: channel_congestion_weightage, num_esp_qbss_slots 911 * 912 * Supported Feature: STA Candidate selection 913 * 914 * Usage: External 915 * 916 * </ini> 917 */ 918 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_7_TO_4 CFG_INI_UINT( \ 919 "esp_qbss_score_idx7_to_4", \ 920 0x00000000, \ 921 0x64646464, \ 922 0x0A193246, \ 923 CFG_VALUE_OR_DEFAULT, \ 924 "ESP QPSS Score Index 7 to 4") 925 926 /* 927 * <ini> 928 * esp_qbss_score_idx11_to_8 - percentage for esp/qbss load for slots 8-11 929 * @Min: 0x00000000 930 * @Max: 0x64646464 931 * @Default: 0x00000005 932 * 933 * This INI give percentage value of channel_congestion_weightage to be used as 934 * index in which the load value falls. Used only if num_esp_qbss_slots is 935 * greater than 7. 936 * 937 * Indexes are defined in this way. 938 * 0 Index (BITS 0-7): SLOT_8 939 * 1 Index (BITS 8-15): SLOT_9 940 * 2 Index (BITS 16-23): SLOT_10 941 * 3 Index (BITS 24-31): SLOT_11 942 * These percentage values are stored in HEX. For any index max value, can be 64 943 * 944 * Related: channel_congestion_weightage, num_esp_qbss_slots 945 * 946 * Supported Feature: STA Candidate selection 947 * 948 * Usage: External 949 * 950 * </ini> 951 */ 952 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_11_TO_8 CFG_INI_UINT( \ 953 "esp_qbss_score_idx11_to_8", \ 954 0x00000000, \ 955 0x64646464, \ 956 0x00000005, \ 957 CFG_VALUE_OR_DEFAULT, \ 958 "ESP QPSS Score Index 11 to 8") 959 960 /* 961 * <ini> 962 * esp_qbss_score_idx15_to_12 - percentage for esp/qbss load for slots 12-15 963 * @Min: 0x00000000 964 * @Max: 0x64646464 965 * @Default: 0x00000000 966 * 967 * This INI give percentage value of channel_congestion_weightage to be used as 968 * index in which the load value falls. Used only if num_esp_qbss_slots is 969 * greater than 11. 970 * 971 * Indexes are defined in this way. 972 * 0 Index (BITS 0-7): SLOT_12 973 * 1 Index (BITS 8-15): SLOT_13 974 * 2 Index (BITS 16-23): SLOT_14 975 * 3 Index (BITS 24-31): SLOT_15 976 * These percentage values are stored in HEX. For any index max value, can be 64 977 * 978 * Related: channel_congestion_weightage, num_esp_qbss_slots 979 * 980 * Supported Feature: STA Candidate selection 981 * 982 * Usage: External 983 * 984 * </ini> 985 */ 986 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_15_TO_12 CFG_INI_UINT( \ 987 "esp_qbss_score_idx15_to_12", \ 988 0x00000000, \ 989 0x64646464, \ 990 0x00000000, \ 991 CFG_VALUE_OR_DEFAULT, \ 992 "ESP QPSS Score Index 15 to 12") 993 994 /* 995 * <ini> 996 * num_oce_wan_slots - number of slots in which the oce wan metrics will 997 * be divided 998 * 999 * @Min: 1 1000 * @Max: 15 1001 * @Default: 8 1002 * 1003 * Number of slots in which the oce wan metrics will be divided. Max 15. index 0 1004 * is used for not_present. Num_slot will equally divide 100. e.g, if 1005 * num_slot = 4 slot 1 = 0-3 DL CAP, slot 2 = 4-7 DL CAP, slot 3 = 8-11 DL CAP, 1006 * slot 4 = 12-15 DL CAP. Remaining unused index can be 0. 1007 * 1008 * Related: oce_wan_weightage 1009 * 1010 * Usage: External 1011 * 1012 * </ini> 1013 */ 1014 #define CFG_SCORING_NUM_OCE_WAN_SLOTS CFG_INI_UINT( \ 1015 "num_oce_wan_slots", \ 1016 1, \ 1017 15, \ 1018 15, \ 1019 CFG_VALUE_OR_DEFAULT, \ 1020 "Num OCE WAN Slots") 1021 1022 /* 1023 * <ini> 1024 * oce_wan_score_idx3_to_0 - percentage for OCE WAN metrics score for slots 0-3 1025 * @Min: 0x00000000 1026 * @Max: 0x64646464 1027 * @Default: 0x00000032 1028 * 1029 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1030 * index in which the DL CAP value falls. Index 0 is for percentage when 1031 * OCE WAN metrics DL CAP is not present. 1032 * 1033 * Indexes are defined in this way. 1034 * 0 Index (BITS 0-7): when OCE WAN metrics DL CAP is not present 1035 * 1 Index (BITS 8-15): SLOT_1 1036 * 2 Index (BITS 16-23): SLOT_2 1037 * 3 Index (BITS 24-31): SLOT_3 1038 * These percentage values are stored in HEX. For any index max value, can be 64 1039 * 1040 * Related: num_oce_wan_slots, oce_wan_weightage 1041 * 1042 * Supported Feature: STA Candidate selection 1043 * 1044 * Usage: External 1045 * 1046 * </ini> 1047 */ 1048 #define CFG_SCORING_OCE_WAN_SCORE_IDX_3_TO_0 CFG_INI_UINT( \ 1049 "oce_wan_score_idx3_to_0", \ 1050 0x00000000, \ 1051 0x64646464, \ 1052 0x00000032, \ 1053 CFG_VALUE_OR_DEFAULT, \ 1054 "OCE WAN Score Index 3 to 0") 1055 1056 /* 1057 * <ini> 1058 * oce_wan_score_idx7_to_4 - percentage for OCE WAN metrics score for slots 4-7 1059 * @Min: 0x00000000 1060 * @Max: 0x64646464 1061 * @Default: 0x00000000 1062 * 1063 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1064 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1065 * greater than 3. 1066 * 1067 * Indexes are defined in this way. 1068 * 0 Index (BITS 0-7): SLOT_4 1069 * 1 Index (BITS 8-15): SLOT_5 1070 * 2 Index (BITS 16-23): SLOT_6 1071 * 3 Index (BITS 24-31): SLOT_7 1072 * These percentage values are stored in HEX. For any index max value, can be 64 1073 * 1074 * Related: num_oce_wan_slots, oce_wan_weightage 1075 * 1076 * Supported Feature: STA Candidate selection 1077 * 1078 * Usage: External 1079 * 1080 * </ini> 1081 */ 1082 #define CFG_SCORING_OCE_WAN_SCORE_IDX_7_TO_4 CFG_INI_UINT( \ 1083 "oce_wan_score_idx7_to_4", \ 1084 0x00000000, \ 1085 0x64646464, \ 1086 0x00000000, \ 1087 CFG_VALUE_OR_DEFAULT, \ 1088 "OCE WAN Score Index 7 to 4") 1089 1090 /* 1091 * <ini> 1092 * oce_wan_score_idx11_to_8 - percentage for OCE WAN metrics score for slot 8-11 1093 * @Min: 0x00000000 1094 * @Max: 0x64646464 1095 * @Default: 0x06030000 1096 * 1097 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1098 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1099 * greater than 7. 1100 * 1101 * Indexes are defined in this way. 1102 * 0 Index (BITS 0-7): SLOT_8 1103 * 1 Index (BITS 8-15): SLOT_9 1104 * 2 Index (BITS 16-23): SLOT_10 1105 * 3 Index (BITS 24-31): SLOT_11 1106 * These percentage values are stored in HEX. For any index max value, can be 64 1107 * 1108 * Related: num_oce_wan_slots, oce_wan_weightage 1109 * 1110 * Supported Feature: STA Candidate selection 1111 * 1112 * Usage: External 1113 * 1114 * </ini> 1115 */ 1116 #define CFG_SCORING_OCE_WAN_SCORE_IDX_11_TO_8 CFG_INI_UINT( \ 1117 "oce_wan_score_idx11_to_8", \ 1118 0x00000000, \ 1119 0x64646464, \ 1120 0x06030000, \ 1121 CFG_VALUE_OR_DEFAULT, \ 1122 "OCE WAN Score Index 11 to 8") 1123 1124 /* 1125 * <ini> 1126 * oce_wan_score_idx15_to_12 - % for OCE WAN metrics score for slot 12-15 1127 * @Min: 0x00000000 1128 * @Max: 0x64646464 1129 * @Default: 0x6432190C 1130 * 1131 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1132 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1133 * greater than 11. 1134 * 1135 * Indexes are defined in this way. 1136 * 0 Index (BITS 0-7): SLOT_12 1137 * 1 Index (BITS 8-15): SLOT_13 1138 * 2 Index (BITS 16-23): SLOT_14 1139 * 3 Index (BITS 24-31): SLOT_15 1140 * These percentage values are stored in HEX. For any index max value, can be 64 1141 * 1142 * Related: num_oce_wan_slots, oce_wan_weightage 1143 * 1144 * Supported Feature: STA Candidate selection 1145 * 1146 * Usage: External 1147 * 1148 * </ini> 1149 */ 1150 #define CFG_SCORING_OCE_WAN_SCORE_IDX_15_TO_12 CFG_INI_UINT( \ 1151 "oce_wan_score_idx15_to_12", \ 1152 0x00000000, \ 1153 0x64646464, \ 1154 0x6432190C, \ 1155 CFG_VALUE_OR_DEFAULT, \ 1156 "OCE WAN Score Index 15 to 12") 1157 1158 /* 1159 * <ini> 1160 * is_bssid_hint_priority - Set priority for connection with bssid_hint 1161 * BSSID. 1162 * @Min: 0 1163 * @Max: 1 1164 * @Default: 1 - AP and 0 - non AP 1165 * 1166 * This ini is used to give priority to BSS for connection which comes 1167 * as part of bssid_hint 1168 * 1169 * Related: None 1170 * 1171 * Supported Feature: STA 1172 * 1173 * Usage: External 1174 * 1175 * </ini> 1176 */ 1177 #define CFG_IS_BSSID_HINT_PRIORITY CFG_INI_UINT(\ 1178 "is_bssid_hint_priority",\ 1179 0, 1, \ 1180 PLATFORM_VALUE(0, 1), \ 1181 CFG_VALUE_OR_DEFAULT, \ 1182 "Set priority for connection with bssid_hint") 1183 1184 /* 1185 * <ini> 1186 * vendor_roam_score_algorithm - Algorithm to calculate AP score 1187 * @Min: false 1188 * @Max: true 1189 * @Default: false 1190 * 1191 * By default the value is false and default roam algorithm will be used. 1192 * When the value is true, the V2 roaming algorithm will be used: 1193 * For this V2 algo, AP score calculation is based on ETP and below equation: 1194 * AP Score = (RSSIfactor * rssiweight(0.65)) + (CUfactor *cuweight(0.35)) 1195 * 1196 * Related: None 1197 * 1198 * Supported Feature: roam score algorithm 1199 * 1200 * Usage: External 1201 * 1202 * </ini> 1203 */ 1204 #define CFG_VENDOR_ROAM_SCORE_ALGORITHM \ 1205 CFG_INI_BOOL("vendor_roam_score_algorithm", false, \ 1206 "Roam candidate selection score algorithm") 1207 1208 #ifdef CONFIG_BAND_6GHZ 1209 /* 1210 * <ini> 1211 * check_6ghz_security - Enable check for 6Ghz allowed security 1212 * BSSID. 1213 * @Min: 0 1214 * @Max: 1 1215 * @Default: non AP 1, AP 0 1216 * 1217 * This ini is used to Enable check for 6Ghz allowed security. If enabled 1218 * only WPA3 and other allowed security will be allowed for 6Ghz connection 1219 * 1220 * Related: None 1221 * 1222 * Supported Feature: STA 1223 * 1224 * Usage: External 1225 * 1226 * </ini> 1227 */ 1228 #define CFG_CHECK_6GHZ_SECURITY CFG_INI_BOOL(\ 1229 "check_6ghz_security", PLATFORM_VALUE(1, 0), \ 1230 "Enable check for 6Ghz allowed security") 1231 /* 1232 * <ini> 1233 * key_mgmt_mask_6ghz - AKM bit mask (@wlan_crypto_key_mgmt) allowed in 6Ghz 1234 * channel 1235 * @Min: 0 1236 * @Max: 0xffffffff 1237 * @Default: 0xffffffff 1238 * 1239 * This ini is used to set allowed AKM check for 6Ghz. If enabled 1240 * only only AKM bits allowed will be used to connect to candidate. 1241 * valid only if check_6ghz_security is 0. By default all AKM are allowed 1242 * 1243 * Related: check_6Ghz_security 1244 * 1245 * Supported Feature: STA 1246 * 1247 * Usage: External 1248 * 1249 * </ini> 1250 */ 1251 #define CFG_6GHZ_ALLOWED_AKM_MASK CFG_INI_UINT(\ 1252 "key_mgmt_mask_6ghz",\ 1253 0, DEFAULT_KEYMGMT_6G_MASK, DEFAULT_KEYMGMT_6G_MASK,\ 1254 CFG_VALUE_OR_DEFAULT, \ 1255 "Set priority for connection with bssid_hint") 1256 1257 #define CFG_6GHZ_CONFIG \ 1258 CFG(CFG_CHECK_6GHZ_SECURITY) \ 1259 CFG(CFG_6GHZ_ALLOWED_AKM_MASK) 1260 #else 1261 #define CFG_6GHZ_CONFIG 1262 #endif 1263 1264 #ifdef WLAN_FEATURE_11BE 1265 /* 1266 * <ini> 1267 * bandwidth_weight_per_index_4_to_7 - percentage as per bandwidth 1268 * @Min: 0x00000000 1269 * @Max: 0x64646464 1270 * @Default: 0x4B402064 1271 * 1272 * This INI give percentage value of chan_width_weightage to be used as per 1273 * peer bandwidth. Self BW is also considered while calculating score. Eg if 1274 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 1275 * capability. 1276 * 1277 * Indexes are defined in this way. 1278 * 4 Index (BITS 0-7): 320 MHz - Def 100% 1279 * 5 Index (BITS 8-15): 80 MHz with 20MHZ punctured - Def 32% 1280 * 6 Index (BITS 16-23): 160 MHz with 40MHZ punctured - Def 64% 1281 * 7 Index (BITS 24-31): 160 MHz with 20MHZ punctured - Def 75% 1282 * These percentage values are stored in HEX. For any index max value, can be 64 1283 * 1284 * Indexes 0-3 are considered as part of the INI bandwidth_weight_per_index 1285 * 1286 * Related: chan_width_weightage 1287 * 1288 * Supported Feature: STA Candidate selection 1289 * 1290 * Usage: External 1291 * 1292 * </ini> 1293 */ 1294 #define CFG_SCORING_BW_WEIGHT_PER_IDX_4_TO_7 CFG_INI_UINT( \ 1295 "bandwidth_weight_per_index_4_to_7", \ 1296 0x00000000, \ 1297 0x64646464, \ 1298 0x4B402064, \ 1299 CFG_VALUE_OR_DEFAULT, \ 1300 "Bandwidth weight per index 4 to 7") 1301 1302 /* 1303 * <ini> 1304 * bandwidth_weight_per_index_8_to_11 - percentage as per bandwidth 1305 * @Min: 0x00000000 1306 * @Max: 0x64646464 1307 * @Default: 0x15584B3F 1308 * 1309 * This INI give percentage value of chan_width_weightage to be used as per 1310 * peer bandwidth. Self BW is also considered while calculating score. Eg if 1311 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 1312 * capability. 1313 * 1314 * Indexes are defined in this way. 1315 * 8 Index (BITS 0-7): 320 MHz with 40MHZ and 80MHZ punctured - Def 63% 1316 * 9 Index (BITS 8-15): 320 MHz with 80MHZ punctured - Def 75% 1317 * 10 Index (BITS 16-23): 320 MHz with 40MHZ punctured - Def 88% 1318 * 11 Index (BITS 24-31): 20+20 MHz - Def 21% 1319 * These percentage values are stored in HEX. For any index max value, can be 64 1320 * 1321 * Related: chan_width_weightage 1322 * 1323 * Supported Feature: STA Candidate selection 1324 * 1325 * Usage: External 1326 * 1327 * </ini> 1328 */ 1329 #define CFG_SCORING_BW_WEIGHT_PER_IDX_8_TO_11 CFG_INI_UINT( \ 1330 "bandwidth_weight_per_index_8_to_11", \ 1331 0x00000000, \ 1332 0x64646464, \ 1333 0x15584B3F, \ 1334 CFG_VALUE_OR_DEFAULT, \ 1335 "Bandwidth weight per index 8 to 11") 1336 1337 #define CFG_11BE_CONFIG \ 1338 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_4_TO_7) \ 1339 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_8_TO_11) 1340 #else 1341 #define CFG_11BE_CONFIG 1342 #endif 1343 1344 #ifdef WLAN_FEATURE_11BE_MLO 1345 /* 1346 * <ini> 1347 * eht_caps_weightage - EHT caps Weightage to calculate best candidate 1348 * @Min: 0 1349 * @Max: 100 1350 * @Default: 2 1351 * 1352 * This ini is used to increase/decrease EHT caps weightage in best candidate 1353 * selection. If AP supports EHT caps, AP will get additional weightage with 1354 * this param. Weightage will be given only if dot11mode is EHT capable. 1355 * 1356 * Related: None 1357 * 1358 * Supported Feature: STA Candidate selection 1359 * 1360 * Usage: External 1361 * 1362 * </ini> 1363 */ 1364 #define CFG_SCORING_EHT_CAPS_WEIGHTAGE CFG_INI_UINT( \ 1365 "eht_caps_weightage", \ 1366 0, \ 1367 100, \ 1368 2, \ 1369 CFG_VALUE_OR_DEFAULT, \ 1370 "EHT Caps Weightage") 1371 1372 /* 1373 * <ini> 1374 * mlo_weightage - MLO Weightage to calculate best candidate 1375 * @Min: 0 1376 * @Max: 100 1377 * @Default: 3 1378 * 1379 * This ini is used to increase/decrease MLO weightage in best candidate 1380 * selection. If AP supports MLO, AP will get additional weightage with 1381 * this param. 1382 * 1383 * Related: None 1384 * 1385 * Supported Feature: STA Candidate selection 1386 * 1387 * Usage: External 1388 * 1389 * </ini> 1390 */ 1391 #define CFG_SCORING_MLO_WEIGHTAGE CFG_INI_UINT( \ 1392 "mlo_weightage", \ 1393 0, \ 1394 100, \ 1395 3, \ 1396 CFG_VALUE_OR_DEFAULT, \ 1397 "MLO Weightage") 1398 1399 /* 1400 * <ini> 1401 * emlsr_weightage - eMLSR Weightage to calculate best candidate 1402 * @Min: 0 1403 * @Max: 100 1404 * @Default: 3 1405 * 1406 * This ini is used to increase/decrease eMLSR weightage in best candidate 1407 * selection. If AP supports eMLSR, AP will get additional weightage with 1408 * this param. 1409 * 1410 * Related: None 1411 * 1412 * Supported Feature: STA Candidate selection 1413 * 1414 * Usage: External 1415 * 1416 * </ini> 1417 */ 1418 #define CFG_SCORING_EMLSR_WEIGHTAGE CFG_INI_UINT( \ 1419 "emlsr_weightage", \ 1420 0, \ 1421 100, \ 1422 3, \ 1423 CFG_VALUE_OR_DEFAULT, \ 1424 "eMLSR Weightage") 1425 1426 /* 1427 * <ini> 1428 * wlm_indication_weightage - WLM indication Weightage to calculate best 1429 * candidate 1430 * @Min: 0 1431 * @Max: 100 1432 * @Default: 2 1433 * 1434 * This ini is used to increase/decrease WLM indication weightage in best 1435 * candidate selection. AP will get additional weightage with this param based 1436 * on WLM indicates ultra low latency or low latency. 1437 * 1438 * Related: None 1439 * 1440 * Supported Feature: STA Candidate selection 1441 * 1442 * Usage: External 1443 * 1444 * </ini> 1445 */ 1446 #define CFG_SCORING_WLM_INDICATION_WEIGHTAGE CFG_INI_UINT( \ 1447 "wlm_indication_weightage", \ 1448 0, \ 1449 100, \ 1450 2, \ 1451 CFG_VALUE_OR_DEFAULT, \ 1452 "WLM indication Weightage") 1453 1454 /* 1455 * <ini> 1456 * mlsr_link_selection - MLSR link selection criteria 1457 * @Min: 0 1458 * @Max: 1 1459 * @Default: 0 1460 * 1461 * This ini is used to select the link to operate in MLSR mode. 1462 * 1463 * The values are defined as follows: 1464 * 0 : ML Link with highest link score 1465 * 1 : Link corresponds to best average ML score 1466 * 1467 * Related: None 1468 * 1469 * Supported Feature: STA Candidate selection 1470 * 1471 * Usage: External 1472 * 1473 * </ini> 1474 */ 1475 #define CFG_SCORING_MLSR_LINK_SELECTION CFG_INI_UINT( \ 1476 "mlsr_link_selection", \ 1477 0, \ 1478 1, \ 1479 0, \ 1480 CFG_VALUE_OR_DEFAULT, \ 1481 "MLSR link selection") 1482 1483 /* 1484 * <ini> 1485 * joint_rssi_alpha - Joint RSSI alpha to select best ML candidate 1486 * @Min: 0 1487 * @Max: 100 1488 * @Default: 50 1489 * 1490 * This ini is used to increase/decrease joint RSSI alpha percentage for 1491 * an MLO candidate in best candidate selection. Using this the joint RSSI 1492 * will be calculated as below. 1493 * 1494 * joint_rssi = (alpha % Link1 RSSI) + ((100 - alpha)% Link2 RSSI) 1495 * 1496 * Related: low_band_rssi_boost 1497 * 1498 * Supported Feature: STA Candidate selection 1499 * 1500 * Usage: External 1501 * 1502 * </ini> 1503 */ 1504 #define CFG_SCORING_JOINT_RSSI_ALPHA CFG_INI_UINT( \ 1505 "joint_rssi_alpha", \ 1506 0, \ 1507 100, \ 1508 50, \ 1509 CFG_VALUE_OR_DEFAULT, \ 1510 "Joint RSSI alpha") 1511 1512 /* 1513 * <ini> 1514 * low_band_rssi_boost - Low band RSSI boost in joint RSSI calculation 1515 * @Min: 0 1516 * @Max: 1 1517 * @Default: 1 1518 * 1519 * If joint RSSI alpha is not 50 then joint RSSI calculation will depend on 1520 * this INI param as explained below. 1521 * 1522 * If this INI set to 1, then lower band will be given more weightage. 1523 * Otherwise higher band will get more weightage. 1524 * 1525 * Example: Joint RSSI alpha is 70 1526 * if (low_band_rssi_boost) 1527 * joint_rssi_5g_6g = (70 * 5g_rssi) + (30 * 6g_rssi) 1528 * else 1529 * joint_rssi_5g_6g = (30 * 5g_rssi) + (70 * 6g_rssi) 1530 * 1531 * Related: joint_rssi_alpha 1532 * 1533 * Supported Feature: STA Candidate selection 1534 * 1535 * Usage: External 1536 * 1537 * </ini> 1538 */ 1539 #define CFG_SCORING_LOW_BAND_RSSI_BOOST CFG_INI_BOOL( \ 1540 "low_band_rssi_boost", \ 1541 1, \ 1542 "Low band RSSI boost ") 1543 1544 /* 1545 * <ini> 1546 * joint_esp_alpha - Joint ESP alpha to select best ML candidate 1547 * @Min: 0 1548 * @Max: 100 1549 * @Default: 50 1550 * 1551 * This ini is used to increase/decrease joint ESP alpha percentage for 1552 * an MLO candidate in best candidate selection. Using this the joint ESP 1553 * will be calculated as below. 1554 * 1555 * joint_esp = (alpha % Link1 ESP) + ((100 - alpha)% Link2 ESP) 1556 * 1557 * Related: low_band_esp_boost 1558 * 1559 * Supported Feature: STA Candidate selection 1560 * 1561 * Usage: External 1562 * 1563 * </ini> 1564 */ 1565 #define CFG_SCORING_JOINT_ESP_ALPHA CFG_INI_UINT( \ 1566 "joint_esp_alpha", \ 1567 0, \ 1568 100, \ 1569 50, \ 1570 CFG_VALUE_OR_DEFAULT, \ 1571 "Joint ESP alpha") 1572 1573 /* 1574 * <ini> 1575 * low_band_esp_boost - Low band ESP boost in joint ESP calculation 1576 * @Min: 0 1577 * @Max: 1 1578 * @Default: 1 1579 * 1580 * If joint ESP alpha is not 50 then joint ESP calculation will depend on 1581 * this INI param as explained below. 1582 * 1583 * If this INI set to 1, then lower band will be given more weightage. 1584 * Otherwise higher band will get more weightage. 1585 * 1586 * Example: Joint ESP alpha is 70 1587 * if (low_band_esp_boost) 1588 * joint_esp_5g_6g = (70 * 5g_esp) + (30 * 6g_esp) 1589 * else 1590 * joint_esp_5g_6g = (30 * 5g_esp) + (70 * 6g_esp) 1591 * 1592 * Related: joint_esp_alpha 1593 * 1594 * Supported Feature: STA Candidate selection 1595 * 1596 * Usage: External 1597 * 1598 * </ini> 1599 */ 1600 #define CFG_SCORING_LOW_BAND_ESP_BOOST CFG_INI_BOOL( \ 1601 "low_band_esp_boost", \ 1602 1, \ 1603 "Low band ESP boost ") 1604 1605 /* 1606 * <ini> 1607 * joint_oce_alpha - Joint OCE alpha to select best ML candidate 1608 * @Min: 0 1609 * @Max: 100 1610 * @Default: 50 1611 * 1612 * This ini is used to increase/decrease joint OCE alpha percentage for 1613 * an MLO candidate in best candidate selection. Using this the joint OCE 1614 * will be calculated as below. 1615 * 1616 * joint_oce = (alpha % Link1 OCE) + ((100 - alpha)% Link2 OCE) 1617 * 1618 * Related: low_band_oce_boost 1619 * 1620 * Supported Feature: STA Candidate selection 1621 * 1622 * Usage: External 1623 * 1624 * </ini> 1625 */ 1626 #define CFG_SCORING_JOINT_OCE_ALPHA CFG_INI_UINT( \ 1627 "joint_oce_alpha", \ 1628 0, \ 1629 100, \ 1630 50, \ 1631 CFG_VALUE_OR_DEFAULT, \ 1632 "Joint OCE alpha") 1633 1634 /* 1635 * <ini> 1636 * low_band_oce_boost - Low band OCE boost in joint OCE calculation 1637 * @Min: 0 1638 * @Max: 1 1639 * @Default: 1 1640 * 1641 * If joint OCE alpha is not 50 then joint OCE calculation will depend on 1642 * this INI param as explained below. 1643 * 1644 * If this INI set to 1, then lower band will be given more weightage. 1645 * Otherwise higher band will get more weightage. 1646 * 1647 * Example: Joint OCE alpha is 70 1648 * if (low_band_oce_boost) 1649 * joint_oce_5g_6g = (70 * 5g_oce) + (30 * 6g_oce) 1650 * else 1651 * joint_oce_5g_6g = (30 * 5g_oce) + (70 * 6g_oce) 1652 * 1653 * Related: joint_oce_alpha 1654 * 1655 * Supported Feature: STA Candidate selection 1656 * 1657 * Usage: External 1658 * 1659 * </ini> 1660 */ 1661 #define CFG_SCORING_LOW_BAND_OCE_BOOST CFG_INI_BOOL( \ 1662 "low_band_oce_boost", \ 1663 1, \ 1664 "Low band OCE boost ") 1665 1666 /* 1667 * <ini> 1668 * bandwidth_weight_per_index_12_to_15 - percentage as per bandwidth 1669 * @Min: 0x00000000 1670 * @Max: 0x64646464 1671 * @Default: 0x342A2A1F 1672 * 1673 * This INI give percentage value of chan_width_weightage to be used as per 1674 * peer bandwidth for two links. Self BW is also considered while calculating 1675 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1676 * of the AP capability. 1677 * 1678 * Indexes are defined in this way. 1679 * 12 Index (BITS 0-7): 20+40 MHz - Def 31% 1680 * 13 Index (BITS 8-15): 40+40 MHz - Def 42% 1681 * 14 Index (BITS 16-23): 20+80 MHz with 20MHZ punctured - Def 42% 1682 * 15 Index (BITS 24-31): 20+80 MHz - Def 52% 1683 * These percentage values are stored in HEX. For any index max value, can be 64 1684 * 1685 * Related: chan_width_weightage 1686 * 1687 * Supported Feature: STA Candidate selection 1688 * 1689 * Usage: External 1690 * 1691 * </ini> 1692 */ 1693 #define CFG_SCORING_BW_WEIGHT_PER_IDX_12_TO_15 CFG_INI_UINT( \ 1694 "bandwidth_weight_per_index_12_to_15", \ 1695 0x00000000, \ 1696 0x64646464, \ 1697 0x342A2A1F, \ 1698 CFG_VALUE_OR_DEFAULT, \ 1699 "Bandwidth weight per index 12 to 15") 1700 1701 /* 1702 * <ini> 1703 * bandwidth_weight_per_index_16_to_19 - percentage as per bandwidth 1704 * @Min: 0x00000000 1705 * @Max: 0x64646464 1706 * @Default: 0x4B403F35 1707 * 1708 * This INI give percentage value of chan_width_weightage to be used as per 1709 * peer bandwidth for two links. Self BW is also considered while calculating 1710 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1711 * of the AP capability. 1712 * 1713 * Indexes are defined in this way. 1714 * 16 Index (BITS 0-7): 40+80 MHz with 20MHZ punctured - Def 53% 1715 * 17 Index (BITS 8-15): 40+80 MHz - Def 63% 1716 * 18 Index (BITS 16-23): 80+80 MHz with 40MHZ punctured - Def 64% 1717 * 19 Index (BITS 24-31): 80+80 MHz with 20MHZ punctured - Def 75% 1718 * These percentage values are stored in HEX. For any index max value, can be 64 1719 * 1720 * Related: chan_width_weightage 1721 * 1722 * Supported Feature: STA Candidate selection 1723 * 1724 * Usage: External 1725 * 1726 * </ini> 1727 */ 1728 #define CFG_SCORING_BW_WEIGHT_PER_IDX_16_TO_19 CFG_INI_UINT( \ 1729 "bandwidth_weight_per_index_16_to_19", \ 1730 0x00000000, \ 1731 0x64646464, \ 1732 0x4B403F35, \ 1733 CFG_VALUE_OR_DEFAULT, \ 1734 "Bandwidth weight per index 16 to 19") 1735 1736 /* 1737 * <ini> 1738 * bandwidth_weight_per_index_20_to_23 - percentage as per bandwidth 1739 * @Min: 0x00000000 1740 * @Max: 0x64646464 1741 * @Default: 0x574E4455 1742 * 1743 * This INI give percentage value of chan_width_weightage to be used as per 1744 * peer bandwidth for two links. Self BW is also considered while calculating 1745 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1746 * of the AP capability. 1747 * 1748 * Indexes are defined in this way. 1749 * 20 Index (BITS 0-7): 80+80 MHz - Def 85% 1750 * 21 Index (BITS 8-15): 20+160 MHz with 40MHZ punctured - Def 68% 1751 * 22 Index (BITS 16-23): 20+160 MHz with 20MHZ punctured - Def 78% 1752 * 23 Index (BITS 24-31): 20+160 MHz - Def 87% 1753 * These percentage values are stored in HEX. For any index max value, can be 64 1754 * 1755 * Related: chan_width_weightage 1756 * 1757 * Supported Feature: STA Candidate selection 1758 * 1759 * Usage: External 1760 * 1761 * </ini> 1762 */ 1763 #define CFG_SCORING_BW_WEIGHT_PER_IDX_20_TO_23 CFG_INI_UINT( \ 1764 "bandwidth_weight_per_index_20_to_23", \ 1765 0x00000000, \ 1766 0x64646464, \ 1767 0x574E4455, \ 1768 CFG_VALUE_OR_DEFAULT, \ 1769 "Bandwidth weight per index 20 to 23") 1770 1771 /* 1772 * <ini> 1773 * bandwidth_weight_per_index_24_to_27 - percentage as per bandwidth 1774 * @Min: 0x00000000 1775 * @Max: 0x64646464 1776 * @Default: 0x485A5148 1777 * 1778 * This INI give percentage value of chan_width_weightage to be used as per 1779 * peer bandwidth for two links. Self BW is also considered while calculating 1780 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1781 * of the AP capability. 1782 * 1783 * Indexes are defined in this way. 1784 * 24 Index (BITS 0-7): 40+160 MHz with 40MHZ punctured - Def 72% 1785 * 25 Index (BITS 8-15): 40+160 MHz with 20MHZ punctured - Def 81% 1786 * 26 Index (BITS 16-23): 40+160 MHz - Def 90% 1787 * 27 Index (BITS 24-31): 80+160 MHz with 60MHZ punctured - Def 72% 1788 * These percentage values are stored in HEX. For any index max value, can be 64 1789 * 1790 * Related: chan_width_weightage 1791 * 1792 * Supported Feature: STA Candidate selection 1793 * 1794 * Usage: External 1795 * 1796 * </ini> 1797 */ 1798 #define CFG_SCORING_BW_WEIGHT_PER_IDX_24_TO_27 CFG_INI_UINT( \ 1799 "bandwidth_weight_per_index_24_to_27", \ 1800 0x00000000, \ 1801 0x64646464, \ 1802 0x485A5148, \ 1803 CFG_VALUE_OR_DEFAULT, \ 1804 "Bandwidth weight per index 24 to 27") 1805 1806 /* 1807 * <ini> 1808 * bandwidth_weight_per_index_28_to_31 - percentage as per bandwidth 1809 * @Min: 0x00000000 1810 * @Max: 0x64646464 1811 * @Default: 0x4B5F5850 1812 * 1813 * This INI give percentage value of chan_width_weightage to be used as per 1814 * peer bandwidth for two links. Self BW is also considered while calculating 1815 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1816 * of the AP capability. 1817 * 1818 * Indexes are defined in this way. 1819 * 28 Index (BITS 0-7): 80+160 MHz with 40MHZ punctured - Def 80% 1820 * 29 Index (BITS 8-15): 80+160 MHz with 20MHZ punctured - Def 88% 1821 * 30 Index (BITS 16-23): 80+160 MHz - Def 95% 1822 * 31 Index (BITS 24-31): 160+160 MHz with 80MHZ punctured - Def 75% 1823 * These percentage values are stored in HEX. For any index max value, can be 64 1824 * 1825 * Related: chan_width_weightage 1826 * 1827 * Supported Feature: STA Candidate selection 1828 * 1829 * Usage: External 1830 * 1831 * </ini> 1832 */ 1833 #define CFG_SCORING_BW_WEIGHT_PER_IDX_28_TO_31 CFG_INI_UINT( \ 1834 "bandwidth_weight_per_index_28_to_31", \ 1835 0x00000000, \ 1836 0x64646464, \ 1837 0x4B5F5850, \ 1838 CFG_VALUE_OR_DEFAULT, \ 1839 "Bandwidth weight per index 28 to 31") 1840 1841 /* 1842 * <ini> 1843 * bandwidth_weight_per_index_32_to_35 - percentage as per bandwidth 1844 * @Min: 0x00000000 1845 * @Max: 0x64646464 1846 * @Default: 0x645E5852 1847 * 1848 * This INI give percentage value of chan_width_weightage to be used as per 1849 * peer bandwidth for two links. Self BW is also considered while calculating 1850 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1851 * of the AP capability. 1852 * 1853 * Indexes are defined in this way. 1854 * 32 Index (BITS 0-7): 160+160 MHz with 60MHZ punctured - Def 82% 1855 * 33 Index (BITS 8-15): 160+160 MHz with 40MHZ punctured - Def 88% 1856 * 34 Index (BITS 16-23): 160+160 MHz with 20MHZ punctured - Def 94% 1857 * 35 Index (BITS 24-31): 160+160 MHz - Def 100% 1858 * These percentage values are stored in HEX. For any index max value, can be 64 1859 * 1860 * Related: chan_width_weightage 1861 * 1862 * Supported Feature: STA Candidate selection 1863 * 1864 * Usage: External 1865 * 1866 * </ini> 1867 */ 1868 #define CFG_SCORING_BW_WEIGHT_PER_IDX_32_TO_35 CFG_INI_UINT( \ 1869 "bandwidth_weight_per_index_32_to_35", \ 1870 0x00000000, \ 1871 0x64646464, \ 1872 0x645E5852, \ 1873 CFG_VALUE_OR_DEFAULT, \ 1874 "Bandwidth weight per index 32 to 35") 1875 1876 /* 1877 * <ini> 1878 * ml_nss_weight_per_index_4_to_7 - percentage as per NSS 1879 * @Min: 0x00000000 1880 * @Max: 0x00646464 1881 * @Default: 0x00645019 1882 * 1883 * This INI give percentage value of nss_weightage to be used as per peer NSS. 1884 * Self NSS capability is also considered. Eg if self NSS is 1x1 10% will be 1885 * given for all AP irrespective of the AP capability. 1886 * 1887 * Indexes are defined in this way. 1888 * 4 Index (BITS 0-7): 2x2 + 2x2 - Def 25% 1889 * 5 Index (BITS 8-15): 4x4 + 4x4 - Def 80% 1890 * 6 Index (BITS 16-23): 8X8- Def 100% 1891 * 7 Index (BITS 24-31): Reserved - Def 0 1892 * These percentage values are stored in HEX. For any index max value, can be 64 1893 * 1894 * Indexes 0-3 are considered as part of the INI nss_weight_per_index 1895 * 1896 * Related: nss_weightage 1897 * 1898 * Supported Feature: STA Candidate selection 1899 * 1900 * Usage: External 1901 * 1902 * </ini> 1903 */ 1904 #define CFG_SCORING_ML_NSS_WEIGHT_PER_IDX_4_TO_7 CFG_INI_UINT( \ 1905 "ml_nss_weight_per_index_4_to_7", \ 1906 0x00000000, \ 1907 0x00646464, \ 1908 0x00645019, \ 1909 CFG_VALUE_OR_DEFAULT, \ 1910 "ML NSS weight per index 4 to 7") 1911 1912 #define CFG_MLO_CONFIG \ 1913 CFG(CFG_SCORING_EHT_CAPS_WEIGHTAGE) \ 1914 CFG(CFG_SCORING_EMLSR_WEIGHTAGE) \ 1915 CFG(CFG_SCORING_JOINT_ESP_ALPHA) \ 1916 CFG(CFG_SCORING_JOINT_OCE_ALPHA) \ 1917 CFG(CFG_SCORING_JOINT_RSSI_ALPHA) \ 1918 CFG(CFG_SCORING_LOW_BAND_ESP_BOOST) \ 1919 CFG(CFG_SCORING_LOW_BAND_OCE_BOOST) \ 1920 CFG(CFG_SCORING_LOW_BAND_RSSI_BOOST) \ 1921 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_12_TO_15) \ 1922 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_16_TO_19) \ 1923 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_20_TO_23) \ 1924 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_24_TO_27) \ 1925 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_28_TO_31) \ 1926 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_32_TO_35) \ 1927 CFG(CFG_SCORING_ML_NSS_WEIGHT_PER_IDX_4_TO_7) \ 1928 CFG(CFG_SCORING_MLO_WEIGHTAGE) \ 1929 CFG(CFG_SCORING_MLSR_LINK_SELECTION) \ 1930 CFG(CFG_SCORING_WLM_INDICATION_WEIGHTAGE) 1931 #else 1932 #define CFG_MLO_CONFIG 1933 #endif 1934 1935 #define CFG_MLME_SCORE_ALL \ 1936 CFG(CFG_SCORING_RSSI_WEIGHTAGE) \ 1937 CFG(CFG_SCORING_HT_CAPS_WEIGHTAGE) \ 1938 CFG(CFG_SCORING_VHT_CAPS_WEIGHTAGE) \ 1939 CFG(CFG_SCORING_HE_CAPS_WEIGHTAGE) \ 1940 CFG(CFG_SCORING_CHAN_WIDTH_WEIGHTAGE) \ 1941 CFG(CFG_SCORING_CHAN_BAND_WEIGHTAGE) \ 1942 CFG(CFG_SCORING_NSS_WEIGHTAGE) \ 1943 CFG(CFG_SCORING_BEAMFORM_CAP_WEIGHTAGE) \ 1944 CFG(CFG_SCORING_PCL_WEIGHTAGE) \ 1945 CFG(CFG_SCORING_CHAN_CONGESTION_WEIGHTAGE) \ 1946 CFG(CFG_SCORING_OCE_WAN_WEIGHTAGE) \ 1947 CFG(CFG_OCE_AP_TX_PWR_WEIGHTAGE) \ 1948 CFG(CFG_OCE_SUBNET_ID_WEIGHTAGE) \ 1949 CFG(CFG_SAE_PK_AP_WEIGHTAGE) \ 1950 CFG(CFG_SCORING_BEST_RSSI_THRESHOLD) \ 1951 CFG(CFG_SCORING_GOOD_RSSI_THRESHOLD) \ 1952 CFG(CFG_SCORING_BAD_RSSI_THRESHOLD) \ 1953 CFG(CFG_SCORING_GOOD_RSSI_PERCENT) \ 1954 CFG(CFG_SCORING_BAD_RSSI_PERCENT) \ 1955 CFG(CFG_SCORING_GOOD_RSSI_BUCKET_SIZE) \ 1956 CFG(CFG_SCORING_BAD_RSSI_BUCKET_SIZE) \ 1957 CFG(CFG_SCORING_RSSI_PREF_5G_THRESHOLD) \ 1958 CFG(CFG_CON_NON_HINT_TARGET_MIN_RSSI) \ 1959 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX) \ 1960 CFG(CFG_SCORING_NSS_WEIGHT_PER_IDX) \ 1961 CFG(CFG_SCORING_BAND_WEIGHT_PER_IDX) \ 1962 CFG(CFG_SCORING_NUM_ESP_QBSS_SLOTS) \ 1963 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_3_TO_0) \ 1964 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_7_TO_4) \ 1965 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_11_TO_8) \ 1966 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_15_TO_12) \ 1967 CFG(CFG_SCORING_NUM_OCE_WAN_SLOTS) \ 1968 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_3_TO_0) \ 1969 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_7_TO_4) \ 1970 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_11_TO_8) \ 1971 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_15_TO_12) \ 1972 CFG(CFG_IS_BSSID_HINT_PRIORITY) \ 1973 CFG(CFG_VENDOR_ROAM_SCORE_ALGORITHM) \ 1974 CFG_6GHZ_CONFIG \ 1975 CFG_11BE_CONFIG \ 1976 CFG_MLO_CONFIG 1977 1978 #endif /* __CFG_MLME_SCORE_PARAMS_H */ 1979