1 /* 2 * Copyright (c) 2012-2021, The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2022 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 #ifdef WLAN_FEATURE_11BE 637 /* 638 * <ini> 639 * bandwidth_weight_per_index - percentage as per bandwidth 640 * @Min: 0x00000000 641 * @Max: 0x64646464 642 * @Default: 0x552A150A 643 * 644 * This INI give percentage value of chan_width_weightage to be used as per 645 * peer bandwidth. Self BW is also considered while calculating score. Eg if 646 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 647 * capability. 648 * 649 * Indexes are defined in this way. 650 * 0 Index (BITS 0-7): 20 MHz - Def 10% 651 * 1 Index (BITS 8-15): 40 MHz - Def 21% 652 * 2 Index (BITS 16-23): 80 MHz - Def 42% 653 * 3 Index (BITS 24-31): 160 MHz - Def 85% 654 * These percentage values are stored in HEX. For any index max value, can be 64 655 * 656 * Related: chan_width_weightage 657 * 658 * Supported Feature: STA Candidate selection 659 * 660 * Usage: External 661 * 662 * </ini> 663 */ 664 #define CFG_SCORING_BW_WEIGHT_PER_IDX CFG_INI_UINT( \ 665 "bandwidth_weight_per_index", \ 666 0x00000000, \ 667 0x64646464, \ 668 0x552A150A, \ 669 CFG_VALUE_OR_DEFAULT, \ 670 "Bandwidth weight per index") 671 #else 672 /* 673 * <ini> 674 * bandwidth_weight_per_index - percentage as per bandwidth 675 * @Min: 0x00000000 676 * @Max: 0x64646464 677 * @Default: 0x6432190C 678 * 679 * This INI give percentage value of chan_width_weightage to be used as per 680 * peer bandwidth. Self BW is also considered while calculating score. Eg if 681 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 682 * capability. 683 * 684 * Indexes are defined in this way. 685 * 0 Index (BITS 0-7): 20 MHz - Def 12% 686 * 1 Index (BITS 8-15): 40 MHz - Def 25% 687 * 2 Index (BITS 16-23): 80 MHz - Def 50% 688 * 3 Index (BITS 24-31): 160 MHz - Def 100% 689 * These percentage values are stored in HEX. For any index max value, can be 64 690 * 691 * Related: chan_width_weightage 692 * 693 * Supported Feature: STA Candidate selection 694 * 695 * Usage: External 696 * 697 * </ini> 698 */ 699 #define CFG_SCORING_BW_WEIGHT_PER_IDX CFG_INI_UINT( \ 700 "bandwidth_weight_per_index", \ 701 0x00000000, \ 702 0x64646464, \ 703 0x6432190C, \ 704 CFG_VALUE_OR_DEFAULT, \ 705 "Bandwidth weight per index") 706 #endif 707 708 /* 709 * <ini> 710 * nss_weight_per_index - percentage as per NSS 711 * @Min: 0x00000000 712 * @Max: 0x64646464 713 * @Default: 0x5032190C 714 * 715 * This INI give percentage value of nss_weightage to be used as per peer NSS. 716 * Self NSS capability is also considered. Eg if self NSS is 1x1 10% will be 717 * given for all AP irrespective of the AP capability. 718 * 719 * Indexes are defined in this way. 720 * 0 Index (BITS 0-7): 1X1- Def 12% 721 * 1 Index (BITS 8-15): 2X2- Def 25% 722 * 2 Index (BITS 16-23): 3X3- Def 50% 723 * 3 Index (BITS 24-31): 4X4- Def 80% 724 * These percentage values are stored in HEX. For any index max value, can be 64 725 * 726 * Related: nss_weightage 727 * 728 * Supported Feature: STA Candidate selection 729 * 730 * Usage: External 731 * 732 * </ini> 733 */ 734 #define CFG_SCORING_NSS_WEIGHT_PER_IDX CFG_INI_UINT( \ 735 "nss_weight_per_index", \ 736 0x00000000, \ 737 0x64646464, \ 738 0x5032190C, \ 739 CFG_VALUE_OR_DEFAULT, \ 740 "NSS weight per index") 741 742 /* 743 * <ini> 744 * band_weight_per_index - percentage as per band 745 * @Min: 0x00000000 746 * @Max: 0x64646464 747 * @Default: 0x0000644B 748 * 749 * This INI give percentage value of chan_band_weightage to be used as per band. 750 * If RSSI is greater than rssi_pref_5g_rssi_thresh preference is given for 5Ghz 751 * else, it's given for 2.4Ghz. 752 * 753 * Indexes are defined in this way. 754 * 0 Index (BITS 0-7): 2.4GHz - Def 10% 755 * 1 Index (BITS 8-15): 5GHz - Def 20% 756 * 2 Index (BITS 16-23): 6Ghz - Def - 100% 757 * 3 Index (BITS 24-31): Reserved 758 * These percentage values are stored in HEX. For any index max value, can be 64 759 * 760 * Related: chan_band_weightage, rssi_pref_5g_rssi_thresh 761 * 762 * Supported Feature: STA Candidate selection 763 * 764 * Usage: External 765 * 766 * </ini> 767 */ 768 #define CFG_SCORING_BAND_WEIGHT_PER_IDX CFG_INI_UINT( \ 769 "band_weight_per_index", \ 770 0x00000000, \ 771 0x64646464, \ 772 0x00644B32, \ 773 CFG_VALUE_OR_DEFAULT, \ 774 "Band weight per index") 775 776 /* 777 * <ini> 778 * num_esp_qbss_slots - number of slots in which the esp/qbss load will 779 * be divided 780 * 781 * @Min: 1 782 * @Max: 15 783 * @Default: 8 784 * 785 * Number of slots in which the esp/qbss load will be divided. Max 15. index 0 786 * is used for 'not_present. Num_slot will equally divide 100. e.g, if 787 * num_slot = 4 slot 1 = 0-25% load, slot 2 = 26-50% load, slot 3 = 51-75% load, 788 * slot 4 = 76-100% load. Remaining unused index can be 0. 789 * Following is load percentage, score percentage and score of num_slot = 8, 790 * weight=25. 791 * 0-12% 13-25% 26-38% 39-50% 51-63 %64-75% 76-88% 87-100% Not Present 792 * 100% 90% 80% 70% 50% 25% 10% 5% 50% 793 * 2500 2250 2000 1750 1250 625 250 125 1250 794 * 795 * Usage: External 796 * 797 * </ini> 798 */ 799 #define CFG_SCORING_NUM_ESP_QBSS_SLOTS CFG_INI_UINT( \ 800 "num_esp_qbss_slots", \ 801 1, \ 802 15, \ 803 8, \ 804 CFG_VALUE_OR_DEFAULT, \ 805 "Num ESP QPSS Slots") 806 807 /* 808 * <ini> 809 * esp_qbss_score_idx3_to_0 - percentage for esp/qbss load for slots 0-3 810 * @Min: 0x00000000 811 * @Max: 0x64646464 812 * @Default: 0x505A6432 813 * 814 * This INI give percentage value of channel_congestion_weightage to be used as 815 * index in which the load value falls. Index 0 is for percentage when ESP/QBSS 816 * is not present. 817 * 818 * Indexes are defined in this way. 819 * 0 Index (BITS 0-7): when ESP/QBSS is not present 820 * 1 Index (BITS 8-15): SLOT_1 821 * 2 Index (BITS 16-23): SLOT_2 822 * 3 Index (BITS 24-31): SLOT_3 823 * These percentage values are stored in HEX. For any index max value, can be 64 824 * 825 * Related: channel_congestion_weightage, num_esp_qbss_slots 826 * 827 * Supported Feature: STA Candidate selection 828 * 829 * Usage: External 830 * 831 * </ini> 832 */ 833 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_3_TO_0 CFG_INI_UINT( \ 834 "esp_qbss_score_idx3_to_0", \ 835 0x00000000, \ 836 0x64646464, \ 837 0x505A6432, \ 838 CFG_VALUE_OR_DEFAULT, \ 839 "ESP QPSS Score Index 3 to 0") 840 841 /* 842 * <ini> 843 * esp_qbss_score_idx7_to_4 - percentage for esp/qbss load for slots 4-7 844 * @Min: 0x00000000 845 * @Max: 0x64646464 846 * @Default: 0x0A193246 847 * 848 * This INI give percentage value of channel_congestion_weightage to be used as 849 * index in which the load value falls. Used only if num_esp_qbss_slots is 850 * greater than 3. 851 * 852 * Indexes are defined in this way. 853 * 0 Index (BITS 0-7): SLOT_4 854 * 1 Index (BITS 8-15): SLOT_5 855 * 2 Index (BITS 16-23): SLOT_6 856 * 3 Index (BITS 24-31): SLOT_7 857 * These percentage values are stored in HEX. For any index max value, can be 64 858 * 859 * Related: channel_congestion_weightage, num_esp_qbss_slots 860 * 861 * Supported Feature: STA Candidate selection 862 * 863 * Usage: External 864 * 865 * </ini> 866 */ 867 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_7_TO_4 CFG_INI_UINT( \ 868 "esp_qbss_score_idx7_to_4", \ 869 0x00000000, \ 870 0x64646464, \ 871 0x0A193246, \ 872 CFG_VALUE_OR_DEFAULT, \ 873 "ESP QPSS Score Index 7 to 4") 874 875 /* 876 * <ini> 877 * esp_qbss_score_idx11_to_8 - percentage for esp/qbss load for slots 8-11 878 * @Min: 0x00000000 879 * @Max: 0x64646464 880 * @Default: 0x00000005 881 * 882 * This INI give percentage value of channel_congestion_weightage to be used as 883 * index in which the load value falls. Used only if num_esp_qbss_slots is 884 * greater than 7. 885 * 886 * Indexes are defined in this way. 887 * 0 Index (BITS 0-7): SLOT_8 888 * 1 Index (BITS 8-15): SLOT_9 889 * 2 Index (BITS 16-23): SLOT_10 890 * 3 Index (BITS 24-31): SLOT_11 891 * These percentage values are stored in HEX. For any index max value, can be 64 892 * 893 * Related: channel_congestion_weightage, num_esp_qbss_slots 894 * 895 * Supported Feature: STA Candidate selection 896 * 897 * Usage: External 898 * 899 * </ini> 900 */ 901 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_11_TO_8 CFG_INI_UINT( \ 902 "esp_qbss_score_idx11_to_8", \ 903 0x00000000, \ 904 0x64646464, \ 905 0x00000005, \ 906 CFG_VALUE_OR_DEFAULT, \ 907 "ESP QPSS Score Index 11 to 8") 908 909 /* 910 * <ini> 911 * esp_qbss_score_idx15_to_12 - percentage for esp/qbss load for slots 12-15 912 * @Min: 0x00000000 913 * @Max: 0x64646464 914 * @Default: 0x00000000 915 * 916 * This INI give percentage value of channel_congestion_weightage to be used as 917 * index in which the load value falls. Used only if num_esp_qbss_slots is 918 * greater than 11. 919 * 920 * Indexes are defined in this way. 921 * 0 Index (BITS 0-7): SLOT_12 922 * 1 Index (BITS 8-15): SLOT_13 923 * 2 Index (BITS 16-23): SLOT_14 924 * 3 Index (BITS 24-31): SLOT_15 925 * These percentage values are stored in HEX. For any index max value, can be 64 926 * 927 * Related: channel_congestion_weightage, num_esp_qbss_slots 928 * 929 * Supported Feature: STA Candidate selection 930 * 931 * Usage: External 932 * 933 * </ini> 934 */ 935 #define CFG_SCORING_ESP_QBSS_SCORE_IDX_15_TO_12 CFG_INI_UINT( \ 936 "esp_qbss_score_idx15_to_12", \ 937 0x00000000, \ 938 0x64646464, \ 939 0x00000000, \ 940 CFG_VALUE_OR_DEFAULT, \ 941 "ESP QPSS Score Index 15 to 12") 942 943 /* 944 * <ini> 945 * num_oce_wan_slots - number of slots in which the oce wan metrics will 946 * be divided 947 * 948 * @Min: 1 949 * @Max: 15 950 * @Default: 8 951 * 952 * Number of slots in which the oce wan metrics will be divided. Max 15. index 0 953 * is used for not_present. Num_slot will equally divide 100. e.g, if 954 * num_slot = 4 slot 1 = 0-3 DL CAP, slot 2 = 4-7 DL CAP, slot 3 = 8-11 DL CAP, 955 * slot 4 = 12-15 DL CAP. Remaining unused index can be 0. 956 * 957 * Related: oce_wan_weightage 958 * 959 * Usage: External 960 * 961 * </ini> 962 */ 963 #define CFG_SCORING_NUM_OCE_WAN_SLOTS CFG_INI_UINT( \ 964 "num_oce_wan_slots", \ 965 1, \ 966 15, \ 967 15, \ 968 CFG_VALUE_OR_DEFAULT, \ 969 "Num OCE WAN Slots") 970 971 /* 972 * <ini> 973 * oce_wan_score_idx3_to_0 - percentage for OCE WAN metrics score for slots 0-3 974 * @Min: 0x00000000 975 * @Max: 0x64646464 976 * @Default: 0x00000032 977 * 978 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 979 * index in which the DL CAP value falls. Index 0 is for percentage when 980 * OCE WAN metrics DL CAP is not present. 981 * 982 * Indexes are defined in this way. 983 * 0 Index (BITS 0-7): when OCE WAN metrics DL CAP is not present 984 * 1 Index (BITS 8-15): SLOT_1 985 * 2 Index (BITS 16-23): SLOT_2 986 * 3 Index (BITS 24-31): SLOT_3 987 * These percentage values are stored in HEX. For any index max value, can be 64 988 * 989 * Related: num_oce_wan_slots, oce_wan_weightage 990 * 991 * Supported Feature: STA Candidate selection 992 * 993 * Usage: External 994 * 995 * </ini> 996 */ 997 #define CFG_SCORING_OCE_WAN_SCORE_IDX_3_TO_0 CFG_INI_UINT( \ 998 "oce_wan_score_idx3_to_0", \ 999 0x00000000, \ 1000 0x64646464, \ 1001 0x00000032, \ 1002 CFG_VALUE_OR_DEFAULT, \ 1003 "OCE WAN Score Index 3 to 0") 1004 1005 /* 1006 * <ini> 1007 * oce_wan_score_idx7_to_4 - percentage for OCE WAN metrics score for slots 4-7 1008 * @Min: 0x00000000 1009 * @Max: 0x64646464 1010 * @Default: 0x00000000 1011 * 1012 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1013 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1014 * greater than 3. 1015 * 1016 * Indexes are defined in this way. 1017 * 0 Index (BITS 0-7): SLOT_4 1018 * 1 Index (BITS 8-15): SLOT_5 1019 * 2 Index (BITS 16-23): SLOT_6 1020 * 3 Index (BITS 24-31): SLOT_7 1021 * These percentage values are stored in HEX. For any index max value, can be 64 1022 * 1023 * Related: num_oce_wan_slots, oce_wan_weightage 1024 * 1025 * Supported Feature: STA Candidate selection 1026 * 1027 * Usage: External 1028 * 1029 * </ini> 1030 */ 1031 #define CFG_SCORING_OCE_WAN_SCORE_IDX_7_TO_4 CFG_INI_UINT( \ 1032 "oce_wan_score_idx7_to_4", \ 1033 0x00000000, \ 1034 0x64646464, \ 1035 0x00000000, \ 1036 CFG_VALUE_OR_DEFAULT, \ 1037 "OCE WAN Score Index 7 to 4") 1038 1039 /* 1040 * <ini> 1041 * oce_wan_score_idx11_to_8 - percentage for OCE WAN metrics score for slot 8-11 1042 * @Min: 0x00000000 1043 * @Max: 0x64646464 1044 * @Default: 0x06030000 1045 * 1046 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1047 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1048 * greater than 7. 1049 * 1050 * Indexes are defined in this way. 1051 * 0 Index (BITS 0-7): SLOT_8 1052 * 1 Index (BITS 8-15): SLOT_9 1053 * 2 Index (BITS 16-23): SLOT_10 1054 * 3 Index (BITS 24-31): SLOT_11 1055 * These percentage values are stored in HEX. For any index max value, can be 64 1056 * 1057 * Related: num_oce_wan_slots, oce_wan_weightage 1058 * 1059 * Supported Feature: STA Candidate selection 1060 * 1061 * Usage: External 1062 * 1063 * </ini> 1064 */ 1065 #define CFG_SCORING_OCE_WAN_SCORE_IDX_11_TO_8 CFG_INI_UINT( \ 1066 "oce_wan_score_idx11_to_8", \ 1067 0x00000000, \ 1068 0x64646464, \ 1069 0x06030000, \ 1070 CFG_VALUE_OR_DEFAULT, \ 1071 "OCE WAN Score Index 11 to 8") 1072 1073 /* 1074 * <ini> 1075 * oce_wan_score_idx15_to_12 - % for OCE WAN metrics score for slot 12-15 1076 * @Min: 0x00000000 1077 * @Max: 0x64646464 1078 * @Default: 0x6432190C 1079 * 1080 * This INI give percentage value of OCE WAN metrics DL CAP, to be used as 1081 * index in which the DL CAP value falls. Used only if num_oce_wan_slots is 1082 * greater than 11. 1083 * 1084 * Indexes are defined in this way. 1085 * 0 Index (BITS 0-7): SLOT_12 1086 * 1 Index (BITS 8-15): SLOT_13 1087 * 2 Index (BITS 16-23): SLOT_14 1088 * 3 Index (BITS 24-31): SLOT_15 1089 * These percentage values are stored in HEX. For any index max value, can be 64 1090 * 1091 * Related: num_oce_wan_slots, oce_wan_weightage 1092 * 1093 * Supported Feature: STA Candidate selection 1094 * 1095 * Usage: External 1096 * 1097 * </ini> 1098 */ 1099 #define CFG_SCORING_OCE_WAN_SCORE_IDX_15_TO_12 CFG_INI_UINT( \ 1100 "oce_wan_score_idx15_to_12", \ 1101 0x00000000, \ 1102 0x64646464, \ 1103 0x6432190C, \ 1104 CFG_VALUE_OR_DEFAULT, \ 1105 "OCE WAN Score Index 15 to 12") 1106 1107 /* 1108 * <ini> 1109 * is_bssid_hint_priority - Set priority for connection with bssid_hint 1110 * BSSID. 1111 * @Min: 0 1112 * @Max: 1 1113 * @Default: 1 - AP and 0 - non AP 1114 * 1115 * This ini is used to give priority to BSS for connection which comes 1116 * as part of bssid_hint 1117 * 1118 * Related: None 1119 * 1120 * Supported Feature: STA 1121 * 1122 * Usage: External 1123 * 1124 * </ini> 1125 */ 1126 #define CFG_IS_BSSID_HINT_PRIORITY CFG_INI_UINT(\ 1127 "is_bssid_hint_priority",\ 1128 0, 1, \ 1129 PLATFORM_VALUE(0, 1), \ 1130 CFG_VALUE_OR_DEFAULT, \ 1131 "Set priority for connection with bssid_hint") 1132 1133 /* 1134 * <ini> 1135 * vendor_roam_score_algorithm - Algorithm to calculate AP score 1136 * @Min: false 1137 * @Max: true 1138 * @Default: false 1139 * 1140 * By default the value is false and default roam algorithm will be used. 1141 * When the value is true, the V2 roaming algorithm will be used: 1142 * For this V2 algo, AP score calculation is based on ETP and below equation: 1143 * AP Score = (RSSIfactor * rssiweight(0.65)) + (CUfactor *cuweight(0.35)) 1144 * 1145 * Related: None 1146 * 1147 * Supported Feature: roam score algorithm 1148 * 1149 * Usage: External 1150 * 1151 * </ini> 1152 */ 1153 #define CFG_VENDOR_ROAM_SCORE_ALGORITHM \ 1154 CFG_INI_BOOL("vendor_roam_score_algorithm", false, \ 1155 "Roam candidate selection score algorithm") 1156 1157 #ifdef CONFIG_BAND_6GHZ 1158 /* 1159 * <ini> 1160 * check_6ghz_security - Enable check for 6Ghz allowed security 1161 * BSSID. 1162 * @Min: 0 1163 * @Max: 1 1164 * @Default: non AP 1, AP 0 1165 * 1166 * This ini is used to Enable check for 6Ghz allowed security. If enabled 1167 * only WPA3 and other allowed security will be allowed for 6Ghz connection 1168 * 1169 * Related: None 1170 * 1171 * Supported Feature: STA 1172 * 1173 * Usage: External 1174 * 1175 * </ini> 1176 */ 1177 #define CFG_CHECK_6GHZ_SECURITY CFG_INI_BOOL(\ 1178 "check_6ghz_security", PLATFORM_VALUE(1, 0), \ 1179 "Enable check for 6Ghz allowed security") 1180 /* 1181 * <ini> 1182 * key_mgmt_mask_6ghz - AKM bit mask (@wlan_crypto_key_mgmt) allowed in 6Ghz 1183 * channel 1184 * @Min: 0 1185 * @Max: 0xffffffff 1186 * @Default: 0xffffffff 1187 * 1188 * This ini is used to set allowed AKM check for 6Ghz. If enabled 1189 * only only AKM bits allowed will be used to connect to candidate. 1190 * valid only if check_6ghz_security is 0. By default all AKM are allowed 1191 * 1192 * Related: check_6Ghz_security 1193 * 1194 * Supported Feature: STA 1195 * 1196 * Usage: External 1197 * 1198 * </ini> 1199 */ 1200 #define CFG_6GHZ_ALLOWED_AKM_MASK CFG_INI_UINT(\ 1201 "key_mgmt_mask_6ghz",\ 1202 0, DEFAULT_KEYMGMT_6G_MASK, DEFAULT_KEYMGMT_6G_MASK,\ 1203 CFG_VALUE_OR_DEFAULT, \ 1204 "Set priority for connection with bssid_hint") 1205 1206 #define CFG_6GHZ_CONFIG \ 1207 CFG(CFG_CHECK_6GHZ_SECURITY) \ 1208 CFG(CFG_6GHZ_ALLOWED_AKM_MASK) 1209 #else 1210 #define CFG_6GHZ_CONFIG 1211 #endif 1212 1213 #ifdef WLAN_FEATURE_11BE 1214 /* 1215 * <ini> 1216 * bandwidth_weight_per_index_4_to_7 - percentage as per bandwidth 1217 * @Min: 0x00000000 1218 * @Max: 0x64646464 1219 * @Default: 0x4B402064 1220 * 1221 * This INI give percentage value of chan_width_weightage to be used as per 1222 * peer bandwidth. Self BW is also considered while calculating score. Eg if 1223 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 1224 * capability. 1225 * 1226 * Indexes are defined in this way. 1227 * 4 Index (BITS 0-7): 320 MHz - Def 100% 1228 * 5 Index (BITS 8-15): 80 MHz with 20MHZ punctured - Def 32% 1229 * 6 Index (BITS 16-23): 160 MHz with 40MHZ punctured - Def 64% 1230 * 7 Index (BITS 24-31): 160 MHz with 20MHZ punctured - Def 75% 1231 * These percentage values are stored in HEX. For any index max value, can be 64 1232 * 1233 * Indexes 0-3 are considered as part of the INI bandwidth_weight_per_index 1234 * 1235 * Related: chan_width_weightage 1236 * 1237 * Supported Feature: STA Candidate selection 1238 * 1239 * Usage: External 1240 * 1241 * </ini> 1242 */ 1243 #define CFG_SCORING_BW_WEIGHT_PER_IDX_4_TO_7 CFG_INI_UINT( \ 1244 "bandwidth_weight_per_index_4_to_7", \ 1245 0x00000000, \ 1246 0x64646464, \ 1247 0x4B402064, \ 1248 CFG_VALUE_OR_DEFAULT, \ 1249 "Bandwidth weight per index 4 to 7") 1250 1251 /* 1252 * <ini> 1253 * bandwidth_weight_per_index_8_to_11 - percentage as per bandwidth 1254 * @Min: 0x00000000 1255 * @Max: 0x64646464 1256 * @Default: 0x15584B3F 1257 * 1258 * This INI give percentage value of chan_width_weightage to be used as per 1259 * peer bandwidth. Self BW is also considered while calculating score. Eg if 1260 * self BW is 20 MHZ 10% will be given for all AP irrespective of the AP 1261 * capability. 1262 * 1263 * Indexes are defined in this way. 1264 * 8 Index (BITS 0-7): 320 MHz with 40MHZ and 80MHZ punctured - Def 63% 1265 * 9 Index (BITS 8-15): 320 MHz with 80MHZ punctured - Def 75% 1266 * 10 Index (BITS 16-23): 320 MHz with 40MHZ punctured - Def 88% 1267 * 11 Index (BITS 24-31): 20+20 MHz - Def 21% 1268 * These percentage values are stored in HEX. For any index max value, can be 64 1269 * 1270 * Related: chan_width_weightage 1271 * 1272 * Supported Feature: STA Candidate selection 1273 * 1274 * Usage: External 1275 * 1276 * </ini> 1277 */ 1278 #define CFG_SCORING_BW_WEIGHT_PER_IDX_8_TO_11 CFG_INI_UINT( \ 1279 "bandwidth_weight_per_index_8_to_11", \ 1280 0x00000000, \ 1281 0x64646464, \ 1282 0x15584B3F, \ 1283 CFG_VALUE_OR_DEFAULT, \ 1284 "Bandwidth weight per index 8 to 11") 1285 1286 #define CFG_11BE_CONFIG \ 1287 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_4_TO_7) \ 1288 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_8_TO_11) 1289 #else 1290 #define CFG_11BE_CONFIG 1291 #endif 1292 1293 #ifdef WLAN_FEATURE_11BE_MLO 1294 /** 1295 * <ini> 1296 * eht_caps_weightage - EHT caps Weightage to calculate best candidate 1297 * @Min: 0 1298 * @Max: 100 1299 * @Default: 2 1300 * 1301 * This ini is used to increase/decrease EHT caps weightage in best candidate 1302 * selection. If AP supports EHT caps, AP will get additional weightage with 1303 * this param. Weightage will be given only if dot11mode is EHT capable. 1304 * 1305 * Related: None 1306 * 1307 * Supported Feature: STA Candidate selection 1308 * 1309 * Usage: External 1310 * 1311 * </ini> 1312 */ 1313 #define CFG_SCORING_EHT_CAPS_WEIGHTAGE CFG_INI_UINT( \ 1314 "eht_caps_weightage", \ 1315 0, \ 1316 100, \ 1317 2, \ 1318 CFG_VALUE_OR_DEFAULT, \ 1319 "EHT Caps Weightage") 1320 1321 /** 1322 * <ini> 1323 * mlo_weightage - MLO Weightage to calculate best candidate 1324 * @Min: 0 1325 * @Max: 100 1326 * @Default: 3 1327 * 1328 * This ini is used to increase/decrease MLO weightage in best candidate 1329 * selection. If AP supports MLO, AP will get additional weightage with 1330 * this param. 1331 * 1332 * Related: None 1333 * 1334 * Supported Feature: STA Candidate selection 1335 * 1336 * Usage: External 1337 * 1338 * </ini> 1339 */ 1340 #define CFG_SCORING_MLO_WEIGHTAGE CFG_INI_UINT( \ 1341 "mlo_weightage", \ 1342 0, \ 1343 100, \ 1344 3, \ 1345 CFG_VALUE_OR_DEFAULT, \ 1346 "MLO Weightage") 1347 1348 /** 1349 * <ini> 1350 * emlsr_weightage - eMLSR Weightage to calculate best candidate 1351 * @Min: 0 1352 * @Max: 100 1353 * @Default: 3 1354 * 1355 * This ini is used to increase/decrease eMLSR weightage in best candidate 1356 * selection. If AP supports eMLSR, AP will get additional weightage with 1357 * this param. 1358 * 1359 * Related: None 1360 * 1361 * Supported Feature: STA Candidate selection 1362 * 1363 * Usage: External 1364 * 1365 * </ini> 1366 */ 1367 #define CFG_SCORING_EMLSR_WEIGHTAGE CFG_INI_UINT( \ 1368 "emlsr_weightage", \ 1369 0, \ 1370 100, \ 1371 3, \ 1372 CFG_VALUE_OR_DEFAULT, \ 1373 "eMLSR Weightage") 1374 1375 /** 1376 * <ini> 1377 * wlm_indication_weightage - WLM indication Weightage to calculate best 1378 * candidate 1379 * @Min: 0 1380 * @Max: 100 1381 * @Default: 2 1382 * 1383 * This ini is used to increase/decrease WLM indication weightage in best 1384 * candidate selection. AP will get additional weightage with this param based 1385 * on WLM indicates ultra low latency or low latency. 1386 * 1387 * Related: None 1388 * 1389 * Supported Feature: STA Candidate selection 1390 * 1391 * Usage: External 1392 * 1393 * </ini> 1394 */ 1395 #define CFG_SCORING_WLM_INDICATION_WEIGHTAGE CFG_INI_UINT( \ 1396 "wlm_indication_weightage", \ 1397 0, \ 1398 100, \ 1399 2, \ 1400 CFG_VALUE_OR_DEFAULT, \ 1401 "WLM indication Weightage") 1402 1403 /** 1404 * <ini> 1405 * mlsr_link_selection - MLSR link selection criteria 1406 * @Min: 0 1407 * @Max: 1 1408 * @Default: 0 1409 * 1410 * This ini is used to select the link to operate in MLSR mode. 1411 * 1412 * The values are defined as follows: 1413 * 0 : ML Link with highest link score 1414 * 1 : Link corresponds to best average ML score 1415 * 1416 * Related: None 1417 * 1418 * Supported Feature: STA Candidate selection 1419 * 1420 * Usage: External 1421 * 1422 * </ini> 1423 */ 1424 #define CFG_SCORING_MLSR_LINK_SELECTION CFG_INI_UINT( \ 1425 "mlsr_link_selection", \ 1426 0, \ 1427 1, \ 1428 0, \ 1429 CFG_VALUE_OR_DEFAULT, \ 1430 "MLSR link selection") 1431 1432 /** 1433 * <ini> 1434 * joint_rssi_alpha - Joint RSSI alpha to select best ML candidate 1435 * @Min: 0 1436 * @Max: 100 1437 * @Default: 50 1438 * 1439 * This ini is used to increase/decrease joint RSSI alpha percentage for 1440 * an MLO candidate in best candidate selection. Using this the joint RSSI 1441 * will be calculated as below. 1442 * 1443 * joint_rssi = (alpha % Link1 RSSI) + ((100 - alpha)% Link2 RSSI) 1444 * 1445 * Related: low_band_rssi_boost 1446 * 1447 * Supported Feature: STA Candidate selection 1448 * 1449 * Usage: External 1450 * 1451 * </ini> 1452 */ 1453 #define CFG_SCORING_JOINT_RSSI_ALPHA CFG_INI_UINT( \ 1454 "joint_rssi_alpha", \ 1455 0, \ 1456 100, \ 1457 50, \ 1458 CFG_VALUE_OR_DEFAULT, \ 1459 "Joint RSSI alpha") 1460 1461 /** 1462 * <ini> 1463 * low_band_rssi_boost - Low band RSSI boost in joint RSSI calculation 1464 * @Min: 0 1465 * @Max: 1 1466 * @Default: 1 1467 * 1468 * If joint RSSI alpha is not 50 then joint RSSI calculation will depend on 1469 * this INI param as explained below. 1470 * 1471 * If this INI set to 1, then lower band will be given more weightage. 1472 * Otherwise higher band will get more weightage. 1473 * 1474 * Example: Joint RSSI alpha is 70 1475 * if (low_band_rssi_boost) 1476 * joint_rssi_5g_6g = (70 * 5g_rssi) + (30 * 6g_rssi) 1477 * else 1478 * joint_rssi_5g_6g = (30 * 5g_rssi) + (70 * 6g_rssi) 1479 * 1480 * Related: joint_rssi_alpha 1481 * 1482 * Supported Feature: STA Candidate selection 1483 * 1484 * Usage: External 1485 * 1486 * </ini> 1487 */ 1488 #define CFG_SCORING_LOW_BAND_RSSI_BOOST CFG_INI_BOOL( \ 1489 "low_band_rssi_boost", \ 1490 1, \ 1491 "Low band RSSI boost ") 1492 1493 /** 1494 * <ini> 1495 * joint_esp_alpha - Joint ESP alpha to select best ML candidate 1496 * @Min: 0 1497 * @Max: 100 1498 * @Default: 50 1499 * 1500 * This ini is used to increase/decrease joint ESP alpha percentage for 1501 * an MLO candidate in best candidate selection. Using this the joint ESP 1502 * will be calculated as below. 1503 * 1504 * joint_esp = (alpha % Link1 ESP) + ((100 - alpha)% Link2 ESP) 1505 * 1506 * Related: low_band_esp_boost 1507 * 1508 * Supported Feature: STA Candidate selection 1509 * 1510 * Usage: External 1511 * 1512 * </ini> 1513 */ 1514 #define CFG_SCORING_JOINT_ESP_ALPHA CFG_INI_UINT( \ 1515 "joint_esp_alpha", \ 1516 0, \ 1517 100, \ 1518 50, \ 1519 CFG_VALUE_OR_DEFAULT, \ 1520 "Joint ESP alpha") 1521 1522 /** 1523 * <ini> 1524 * low_band_esp_boost - Low band ESP boost in joint ESP calculation 1525 * @Min: 0 1526 * @Max: 1 1527 * @Default: 1 1528 * 1529 * If joint ESP alpha is not 50 then joint ESP calculation will depend on 1530 * this INI param as explained below. 1531 * 1532 * If this INI set to 1, then lower band will be given more weightage. 1533 * Otherwise higher band will get more weightage. 1534 * 1535 * Example: Joint ESP alpha is 70 1536 * if (low_band_esp_boost) 1537 * joint_esp_5g_6g = (70 * 5g_esp) + (30 * 6g_esp) 1538 * else 1539 * joint_esp_5g_6g = (30 * 5g_esp) + (70 * 6g_esp) 1540 * 1541 * Related: joint_esp_alpha 1542 * 1543 * Supported Feature: STA Candidate selection 1544 * 1545 * Usage: External 1546 * 1547 * </ini> 1548 */ 1549 #define CFG_SCORING_LOW_BAND_ESP_BOOST CFG_INI_BOOL( \ 1550 "low_band_esp_boost", \ 1551 1, \ 1552 "Low band ESP boost ") 1553 1554 /** 1555 * <ini> 1556 * joint_oce_alpha - Joint OCE alpha to select best ML candidate 1557 * @Min: 0 1558 * @Max: 100 1559 * @Default: 50 1560 * 1561 * This ini is used to increase/decrease joint OCE alpha percentage for 1562 * an MLO candidate in best candidate selection. Using this the joint OCE 1563 * will be calculated as below. 1564 * 1565 * joint_oce = (alpha % Link1 OCE) + ((100 - alpha)% Link2 OCE) 1566 * 1567 * Related: low_band_oce_boost 1568 * 1569 * Supported Feature: STA Candidate selection 1570 * 1571 * Usage: External 1572 * 1573 * </ini> 1574 */ 1575 #define CFG_SCORING_JOINT_OCE_ALPHA CFG_INI_UINT( \ 1576 "joint_oce_alpha", \ 1577 0, \ 1578 100, \ 1579 50, \ 1580 CFG_VALUE_OR_DEFAULT, \ 1581 "Joint OCE alpha") 1582 1583 /** 1584 * <ini> 1585 * low_band_oce_boost - Low band OCE boost in joint OCE calculation 1586 * @Min: 0 1587 * @Max: 1 1588 * @Default: 1 1589 * 1590 * If joint OCE alpha is not 50 then joint OCE calculation will depend on 1591 * this INI param as explained below. 1592 * 1593 * If this INI set to 1, then lower band will be given more weightage. 1594 * Otherwise higher band will get more weightage. 1595 * 1596 * Example: Joint OCE alpha is 70 1597 * if (low_band_oce_boost) 1598 * joint_oce_5g_6g = (70 * 5g_oce) + (30 * 6g_oce) 1599 * else 1600 * joint_oce_5g_6g = (30 * 5g_oce) + (70 * 6g_oce) 1601 * 1602 * Related: joint_oce_alpha 1603 * 1604 * Supported Feature: STA Candidate selection 1605 * 1606 * Usage: External 1607 * 1608 * </ini> 1609 */ 1610 #define CFG_SCORING_LOW_BAND_OCE_BOOST CFG_INI_BOOL( \ 1611 "low_band_oce_boost", \ 1612 1, \ 1613 "Low band OCE boost ") 1614 1615 /* 1616 * <ini> 1617 * bandwidth_weight_per_index_12_to_15 - percentage as per bandwidth 1618 * @Min: 0x00000000 1619 * @Max: 0x64646464 1620 * @Default: 0x342A2A1F 1621 * 1622 * This INI give percentage value of chan_width_weightage to be used as per 1623 * peer bandwidth for two links. Self BW is also considered while calculating 1624 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1625 * of the AP capability. 1626 * 1627 * Indexes are defined in this way. 1628 * 12 Index (BITS 0-7): 20+40 MHz - Def 31% 1629 * 13 Index (BITS 8-15): 40+40 MHz - Def 42% 1630 * 14 Index (BITS 16-23): 20+80 MHz with 20MHZ punctured - Def 42% 1631 * 15 Index (BITS 24-31): 20+80 MHz - Def 52% 1632 * These percentage values are stored in HEX. For any index max value, can be 64 1633 * 1634 * Related: chan_width_weightage 1635 * 1636 * Supported Feature: STA Candidate selection 1637 * 1638 * Usage: External 1639 * 1640 * </ini> 1641 */ 1642 #define CFG_SCORING_BW_WEIGHT_PER_IDX_12_TO_15 CFG_INI_UINT( \ 1643 "bandwidth_weight_per_index_12_to_15", \ 1644 0x00000000, \ 1645 0x64646464, \ 1646 0x342A2A1F, \ 1647 CFG_VALUE_OR_DEFAULT, \ 1648 "Bandwidth weight per index 12 to 15") 1649 1650 /* 1651 * <ini> 1652 * bandwidth_weight_per_index_16_to_19 - percentage as per bandwidth 1653 * @Min: 0x00000000 1654 * @Max: 0x64646464 1655 * @Default: 0x4B403F35 1656 * 1657 * This INI give percentage value of chan_width_weightage to be used as per 1658 * peer bandwidth for two links. Self BW is also considered while calculating 1659 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1660 * of the AP capability. 1661 * 1662 * Indexes are defined in this way. 1663 * 16 Index (BITS 0-7): 40+80 MHz with 20MHZ punctured - Def 53% 1664 * 17 Index (BITS 8-15): 40+80 MHz - Def 63% 1665 * 18 Index (BITS 16-23): 80+80 MHz with 40MHZ punctured - Def 64% 1666 * 19 Index (BITS 24-31): 80+80 MHz with 20MHZ punctured - Def 75% 1667 * These percentage values are stored in HEX. For any index max value, can be 64 1668 * 1669 * Related: chan_width_weightage 1670 * 1671 * Supported Feature: STA Candidate selection 1672 * 1673 * Usage: External 1674 * 1675 * </ini> 1676 */ 1677 #define CFG_SCORING_BW_WEIGHT_PER_IDX_16_TO_19 CFG_INI_UINT( \ 1678 "bandwidth_weight_per_index_16_to_19", \ 1679 0x00000000, \ 1680 0x64646464, \ 1681 0x4B403F35, \ 1682 CFG_VALUE_OR_DEFAULT, \ 1683 "Bandwidth weight per index 16 to 19") 1684 1685 /* 1686 * <ini> 1687 * bandwidth_weight_per_index_20_to_23 - percentage as per bandwidth 1688 * @Min: 0x00000000 1689 * @Max: 0x64646464 1690 * @Default: 0x574E4455 1691 * 1692 * This INI give percentage value of chan_width_weightage to be used as per 1693 * peer bandwidth for two links. Self BW is also considered while calculating 1694 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1695 * of the AP capability. 1696 * 1697 * Indexes are defined in this way. 1698 * 20 Index (BITS 0-7): 80+80 MHz - Def 85% 1699 * 21 Index (BITS 8-15): 20+160 MHz with 40MHZ punctured - Def 68% 1700 * 22 Index (BITS 16-23): 20+160 MHz with 20MHZ punctured - Def 78% 1701 * 23 Index (BITS 24-31): 20+160 MHz - Def 87% 1702 * These percentage values are stored in HEX. For any index max value, can be 64 1703 * 1704 * Related: chan_width_weightage 1705 * 1706 * Supported Feature: STA Candidate selection 1707 * 1708 * Usage: External 1709 * 1710 * </ini> 1711 */ 1712 #define CFG_SCORING_BW_WEIGHT_PER_IDX_20_TO_23 CFG_INI_UINT( \ 1713 "bandwidth_weight_per_index_20_to_23", \ 1714 0x00000000, \ 1715 0x64646464, \ 1716 0x574E4455, \ 1717 CFG_VALUE_OR_DEFAULT, \ 1718 "Bandwidth weight per index 20 to 23") 1719 1720 /* 1721 * <ini> 1722 * bandwidth_weight_per_index_24_to_27 - percentage as per bandwidth 1723 * @Min: 0x00000000 1724 * @Max: 0x64646464 1725 * @Default: 0x485A5148 1726 * 1727 * This INI give percentage value of chan_width_weightage to be used as per 1728 * peer bandwidth for two links. Self BW is also considered while calculating 1729 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1730 * of the AP capability. 1731 * 1732 * Indexes are defined in this way. 1733 * 24 Index (BITS 0-7): 40+160 MHz with 40MHZ punctured - Def 72% 1734 * 25 Index (BITS 8-15): 40+160 MHz with 20MHZ punctured - Def 81% 1735 * 26 Index (BITS 16-23): 40+160 MHz - Def 90% 1736 * 27 Index (BITS 24-31): 80+160 MHz with 60MHZ punctured - Def 72% 1737 * These percentage values are stored in HEX. For any index max value, can be 64 1738 * 1739 * Related: chan_width_weightage 1740 * 1741 * Supported Feature: STA Candidate selection 1742 * 1743 * Usage: External 1744 * 1745 * </ini> 1746 */ 1747 #define CFG_SCORING_BW_WEIGHT_PER_IDX_24_TO_27 CFG_INI_UINT( \ 1748 "bandwidth_weight_per_index_24_to_27", \ 1749 0x00000000, \ 1750 0x64646464, \ 1751 0x485A5148, \ 1752 CFG_VALUE_OR_DEFAULT, \ 1753 "Bandwidth weight per index 24 to 27") 1754 1755 /* 1756 * <ini> 1757 * bandwidth_weight_per_index_28_to_31 - percentage as per bandwidth 1758 * @Min: 0x00000000 1759 * @Max: 0x64646464 1760 * @Default: 0x4B5F5850 1761 * 1762 * This INI give percentage value of chan_width_weightage to be used as per 1763 * peer bandwidth for two links. Self BW is also considered while calculating 1764 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1765 * of the AP capability. 1766 * 1767 * Indexes are defined in this way. 1768 * 28 Index (BITS 0-7): 80+160 MHz with 40MHZ punctured - Def 80% 1769 * 29 Index (BITS 8-15): 80+160 MHz with 20MHZ punctured - Def 88% 1770 * 30 Index (BITS 16-23): 80+160 MHz - Def 95% 1771 * 31 Index (BITS 24-31): 160+160 MHz with 80MHZ punctured - Def 75% 1772 * These percentage values are stored in HEX. For any index max value, can be 64 1773 * 1774 * Related: chan_width_weightage 1775 * 1776 * Supported Feature: STA Candidate selection 1777 * 1778 * Usage: External 1779 * 1780 * </ini> 1781 */ 1782 #define CFG_SCORING_BW_WEIGHT_PER_IDX_28_TO_31 CFG_INI_UINT( \ 1783 "bandwidth_weight_per_index_28_to_31", \ 1784 0x00000000, \ 1785 0x64646464, \ 1786 0x4B5F5850, \ 1787 CFG_VALUE_OR_DEFAULT, \ 1788 "Bandwidth weight per index 28 to 31") 1789 1790 /* 1791 * <ini> 1792 * bandwidth_weight_per_index_32_to_35 - percentage as per bandwidth 1793 * @Min: 0x00000000 1794 * @Max: 0x64646464 1795 * @Default: 0x645E5852 1796 * 1797 * This INI give percentage value of chan_width_weightage to be used as per 1798 * peer bandwidth for two links. Self BW is also considered while calculating 1799 * score. Eg if self BW is 20+20 MHZ 20% will be given for all AP irrespective 1800 * of the AP capability. 1801 * 1802 * Indexes are defined in this way. 1803 * 32 Index (BITS 0-7): 160+160 MHz with 60MHZ punctured - Def 82% 1804 * 33 Index (BITS 8-15): 160+160 MHz with 40MHZ punctured - Def 88% 1805 * 34 Index (BITS 16-23): 160+160 MHz with 20MHZ punctured - Def 94% 1806 * 35 Index (BITS 24-31): 160+160 MHz - Def 100% 1807 * These percentage values are stored in HEX. For any index max value, can be 64 1808 * 1809 * Related: chan_width_weightage 1810 * 1811 * Supported Feature: STA Candidate selection 1812 * 1813 * Usage: External 1814 * 1815 * </ini> 1816 */ 1817 #define CFG_SCORING_BW_WEIGHT_PER_IDX_32_TO_35 CFG_INI_UINT( \ 1818 "bandwidth_weight_per_index_32_to_35", \ 1819 0x00000000, \ 1820 0x64646464, \ 1821 0x645E5852, \ 1822 CFG_VALUE_OR_DEFAULT, \ 1823 "Bandwidth weight per index 32 to 35") 1824 1825 /* 1826 * <ini> 1827 * ml_nss_weight_per_index_4_to_7 - percentage as per NSS 1828 * @Min: 0x00000000 1829 * @Max: 0x00646464 1830 * @Default: 0x00645019 1831 * 1832 * This INI give percentage value of nss_weightage to be used as per peer NSS. 1833 * Self NSS capability is also considered. Eg if self NSS is 1x1 10% will be 1834 * given for all AP irrespective of the AP capability. 1835 * 1836 * Indexes are defined in this way. 1837 * 4 Index (BITS 0-7): 2x2 + 2x2 - Def 25% 1838 * 5 Index (BITS 8-15): 4x4 + 4x4 - Def 80% 1839 * 6 Index (BITS 16-23): 8X8- Def 100% 1840 * 7 Index (BITS 24-31): Reserved - Def 0 1841 * These percentage values are stored in HEX. For any index max value, can be 64 1842 * 1843 * Indexes 0-3 are considered as part of the INI nss_weight_per_index 1844 * 1845 * Related: nss_weightage 1846 * 1847 * Supported Feature: STA Candidate selection 1848 * 1849 * Usage: External 1850 * 1851 * </ini> 1852 */ 1853 #define CFG_SCORING_ML_NSS_WEIGHT_PER_IDX_4_TO_7 CFG_INI_UINT( \ 1854 "ml_nss_weight_per_index_4_to_7", \ 1855 0x00000000, \ 1856 0x00646464, \ 1857 0x00645019, \ 1858 CFG_VALUE_OR_DEFAULT, \ 1859 "ML NSS weight per index 4 to 7") 1860 1861 #define CFG_MLO_CONFIG \ 1862 CFG(CFG_SCORING_EHT_CAPS_WEIGHTAGE) \ 1863 CFG(CFG_SCORING_EMLSR_WEIGHTAGE) \ 1864 CFG(CFG_SCORING_JOINT_ESP_ALPHA) \ 1865 CFG(CFG_SCORING_JOINT_OCE_ALPHA) \ 1866 CFG(CFG_SCORING_JOINT_RSSI_ALPHA) \ 1867 CFG(CFG_SCORING_LOW_BAND_ESP_BOOST) \ 1868 CFG(CFG_SCORING_LOW_BAND_OCE_BOOST) \ 1869 CFG(CFG_SCORING_LOW_BAND_RSSI_BOOST) \ 1870 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_12_TO_15) \ 1871 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_16_TO_19) \ 1872 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_20_TO_23) \ 1873 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_24_TO_27) \ 1874 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_28_TO_31) \ 1875 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX_32_TO_35) \ 1876 CFG(CFG_SCORING_ML_NSS_WEIGHT_PER_IDX_4_TO_7) \ 1877 CFG(CFG_SCORING_MLO_WEIGHTAGE) \ 1878 CFG(CFG_SCORING_MLSR_LINK_SELECTION) \ 1879 CFG(CFG_SCORING_WLM_INDICATION_WEIGHTAGE) 1880 #else 1881 #define CFG_MLO_CONFIG 1882 #endif 1883 1884 #define CFG_MLME_SCORE_ALL \ 1885 CFG(CFG_SCORING_RSSI_WEIGHTAGE) \ 1886 CFG(CFG_SCORING_HT_CAPS_WEIGHTAGE) \ 1887 CFG(CFG_SCORING_VHT_CAPS_WEIGHTAGE) \ 1888 CFG(CFG_SCORING_HE_CAPS_WEIGHTAGE) \ 1889 CFG(CFG_SCORING_CHAN_WIDTH_WEIGHTAGE) \ 1890 CFG(CFG_SCORING_CHAN_BAND_WEIGHTAGE) \ 1891 CFG(CFG_SCORING_NSS_WEIGHTAGE) \ 1892 CFG(CFG_SCORING_BEAMFORM_CAP_WEIGHTAGE) \ 1893 CFG(CFG_SCORING_PCL_WEIGHTAGE) \ 1894 CFG(CFG_SCORING_CHAN_CONGESTION_WEIGHTAGE) \ 1895 CFG(CFG_SCORING_OCE_WAN_WEIGHTAGE) \ 1896 CFG(CFG_OCE_AP_TX_PWR_WEIGHTAGE) \ 1897 CFG(CFG_OCE_SUBNET_ID_WEIGHTAGE) \ 1898 CFG(CFG_SAE_PK_AP_WEIGHTAGE) \ 1899 CFG(CFG_SCORING_BEST_RSSI_THRESHOLD) \ 1900 CFG(CFG_SCORING_GOOD_RSSI_THRESHOLD) \ 1901 CFG(CFG_SCORING_BAD_RSSI_THRESHOLD) \ 1902 CFG(CFG_SCORING_GOOD_RSSI_PERCENT) \ 1903 CFG(CFG_SCORING_BAD_RSSI_PERCENT) \ 1904 CFG(CFG_SCORING_GOOD_RSSI_BUCKET_SIZE) \ 1905 CFG(CFG_SCORING_BAD_RSSI_BUCKET_SIZE) \ 1906 CFG(CFG_SCORING_RSSI_PREF_5G_THRESHOLD) \ 1907 CFG(CFG_SCORING_BW_WEIGHT_PER_IDX) \ 1908 CFG(CFG_SCORING_NSS_WEIGHT_PER_IDX) \ 1909 CFG(CFG_SCORING_BAND_WEIGHT_PER_IDX) \ 1910 CFG(CFG_SCORING_NUM_ESP_QBSS_SLOTS) \ 1911 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_3_TO_0) \ 1912 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_7_TO_4) \ 1913 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_11_TO_8) \ 1914 CFG(CFG_SCORING_ESP_QBSS_SCORE_IDX_15_TO_12) \ 1915 CFG(CFG_SCORING_NUM_OCE_WAN_SLOTS) \ 1916 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_3_TO_0) \ 1917 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_7_TO_4) \ 1918 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_11_TO_8) \ 1919 CFG(CFG_SCORING_OCE_WAN_SCORE_IDX_15_TO_12) \ 1920 CFG(CFG_IS_BSSID_HINT_PRIORITY) \ 1921 CFG(CFG_VENDOR_ROAM_SCORE_ALGORITHM) \ 1922 CFG_6GHZ_CONFIG \ 1923 CFG_11BE_CONFIG \ 1924 CFG_MLO_CONFIG 1925 1926 #endif /* __CFG_MLME_SCORE_PARAMS_H */ 1927