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