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