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