1// SPDX-License-Identifier: GPL-2.0 2/* 3 * This file contains helper code to handle channel 4 * settings and keeping track of what is possible at 5 * any point in time. 6 * 7 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> 8 * Copyright 2013-2014 Intel Mobile Communications GmbH 9 * Copyright 2018-2020 Intel Corporation 10 */ 11 12#include <linux/export.h> 13#include <linux/bitfield.h> 14#include <net/cfg80211.h> 15#include "core.h" 16#include "rdev-ops.h" 17 18static bool cfg80211_valid_60g_freq(u32 freq) 19{ 20 return freq >= 58320 && freq <= 70200; 21} 22 23void cfg80211_chandef_create(struct cfg80211_chan_def *chandef, 24 struct ieee80211_channel *chan, 25 enum nl80211_channel_type chan_type) 26{ 27 if (WARN_ON(!chan)) 28 return; 29 30 chandef->chan = chan; 31 chandef->freq1_offset = chan->freq_offset; 32 chandef->center_freq2 = 0; 33 chandef->edmg.bw_config = 0; 34 chandef->edmg.channels = 0; 35 36 switch (chan_type) { 37 case NL80211_CHAN_NO_HT: 38 chandef->width = NL80211_CHAN_WIDTH_20_NOHT; 39 chandef->center_freq1 = chan->center_freq; 40 break; 41 case NL80211_CHAN_HT20: 42 chandef->width = NL80211_CHAN_WIDTH_20; 43 chandef->center_freq1 = chan->center_freq; 44 break; 45 case NL80211_CHAN_HT40PLUS: 46 chandef->width = NL80211_CHAN_WIDTH_40; 47 chandef->center_freq1 = chan->center_freq + 10; 48 break; 49 case NL80211_CHAN_HT40MINUS: 50 chandef->width = NL80211_CHAN_WIDTH_40; 51 chandef->center_freq1 = chan->center_freq - 10; 52 break; 53 default: 54 WARN_ON(1); 55 } 56} 57EXPORT_SYMBOL(cfg80211_chandef_create); 58 59static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef) 60{ 61 int max_contiguous = 0; 62 int num_of_enabled = 0; 63 int contiguous = 0; 64 int i; 65 66 if (!chandef->edmg.channels || !chandef->edmg.bw_config) 67 return false; 68 69 if (!cfg80211_valid_60g_freq(chandef->chan->center_freq)) 70 return false; 71 72 for (i = 0; i < 6; i++) { 73 if (chandef->edmg.channels & BIT(i)) { 74 contiguous++; 75 num_of_enabled++; 76 } else { 77 contiguous = 0; 78 } 79 80 max_contiguous = max(contiguous, max_contiguous); 81 } 82 /* basic verification of edmg configuration according to 83 * IEEE P802.11ay/D4.0 section 9.4.2.251 84 */ 85 /* check bw_config against contiguous edmg channels */ 86 switch (chandef->edmg.bw_config) { 87 case IEEE80211_EDMG_BW_CONFIG_4: 88 case IEEE80211_EDMG_BW_CONFIG_8: 89 case IEEE80211_EDMG_BW_CONFIG_12: 90 if (max_contiguous < 1) 91 return false; 92 break; 93 case IEEE80211_EDMG_BW_CONFIG_5: 94 case IEEE80211_EDMG_BW_CONFIG_9: 95 case IEEE80211_EDMG_BW_CONFIG_13: 96 if (max_contiguous < 2) 97 return false; 98 break; 99 case IEEE80211_EDMG_BW_CONFIG_6: 100 case IEEE80211_EDMG_BW_CONFIG_10: 101 case IEEE80211_EDMG_BW_CONFIG_14: 102 if (max_contiguous < 3) 103 return false; 104 break; 105 case IEEE80211_EDMG_BW_CONFIG_7: 106 case IEEE80211_EDMG_BW_CONFIG_11: 107 case IEEE80211_EDMG_BW_CONFIG_15: 108 if (max_contiguous < 4) 109 return false; 110 break; 111 112 default: 113 return false; 114 } 115 116 /* check bw_config against aggregated (non contiguous) edmg channels */ 117 switch (chandef->edmg.bw_config) { 118 case IEEE80211_EDMG_BW_CONFIG_4: 119 case IEEE80211_EDMG_BW_CONFIG_5: 120 case IEEE80211_EDMG_BW_CONFIG_6: 121 case IEEE80211_EDMG_BW_CONFIG_7: 122 break; 123 case IEEE80211_EDMG_BW_CONFIG_8: 124 case IEEE80211_EDMG_BW_CONFIG_9: 125 case IEEE80211_EDMG_BW_CONFIG_10: 126 case IEEE80211_EDMG_BW_CONFIG_11: 127 if (num_of_enabled < 2) 128 return false; 129 break; 130 case IEEE80211_EDMG_BW_CONFIG_12: 131 case IEEE80211_EDMG_BW_CONFIG_13: 132 case IEEE80211_EDMG_BW_CONFIG_14: 133 case IEEE80211_EDMG_BW_CONFIG_15: 134 if (num_of_enabled < 4 || max_contiguous < 2) 135 return false; 136 break; 137 default: 138 return false; 139 } 140 141 return true; 142} 143 144static int nl80211_chan_width_to_mhz(enum nl80211_chan_width chan_width) 145{ 146 int mhz; 147 148 switch (chan_width) { 149 case NL80211_CHAN_WIDTH_1: 150 mhz = 1; 151 break; 152 case NL80211_CHAN_WIDTH_2: 153 mhz = 2; 154 break; 155 case NL80211_CHAN_WIDTH_4: 156 mhz = 4; 157 break; 158 case NL80211_CHAN_WIDTH_8: 159 mhz = 8; 160 break; 161 case NL80211_CHAN_WIDTH_16: 162 mhz = 16; 163 break; 164 case NL80211_CHAN_WIDTH_5: 165 mhz = 5; 166 break; 167 case NL80211_CHAN_WIDTH_10: 168 mhz = 10; 169 break; 170 case NL80211_CHAN_WIDTH_20: 171 case NL80211_CHAN_WIDTH_20_NOHT: 172 mhz = 20; 173 break; 174 case NL80211_CHAN_WIDTH_40: 175 mhz = 40; 176 break; 177 case NL80211_CHAN_WIDTH_80P80: 178 case NL80211_CHAN_WIDTH_80: 179 mhz = 80; 180 break; 181 case NL80211_CHAN_WIDTH_160: 182 mhz = 160; 183 break; 184 default: 185 WARN_ON_ONCE(1); 186 return -1; 187 } 188 return mhz; 189} 190 191static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c) 192{ 193 return nl80211_chan_width_to_mhz(c->width); 194} 195 196bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef) 197{ 198 u32 control_freq, oper_freq; 199 int oper_width, control_width; 200 201 if (!chandef->chan) 202 return false; 203 204 if (chandef->freq1_offset >= 1000) 205 return false; 206 207 control_freq = chandef->chan->center_freq; 208 209 switch (chandef->width) { 210 case NL80211_CHAN_WIDTH_5: 211 case NL80211_CHAN_WIDTH_10: 212 case NL80211_CHAN_WIDTH_20: 213 case NL80211_CHAN_WIDTH_20_NOHT: 214 if (ieee80211_chandef_to_khz(chandef) != 215 ieee80211_channel_to_khz(chandef->chan)) 216 return false; 217 if (chandef->center_freq2) 218 return false; 219 break; 220 case NL80211_CHAN_WIDTH_1: 221 case NL80211_CHAN_WIDTH_2: 222 case NL80211_CHAN_WIDTH_4: 223 case NL80211_CHAN_WIDTH_8: 224 case NL80211_CHAN_WIDTH_16: 225 if (chandef->chan->band != NL80211_BAND_S1GHZ) 226 return false; 227 228 control_freq = ieee80211_channel_to_khz(chandef->chan); 229 oper_freq = ieee80211_chandef_to_khz(chandef); 230 control_width = nl80211_chan_width_to_mhz( 231 ieee80211_s1g_channel_width( 232 chandef->chan)); 233 oper_width = cfg80211_chandef_get_width(chandef); 234 235 if (oper_width < 0 || control_width < 0) 236 return false; 237 if (chandef->center_freq2) 238 return false; 239 240 if (control_freq + MHZ_TO_KHZ(control_width) / 2 > 241 oper_freq + MHZ_TO_KHZ(oper_width) / 2) 242 return false; 243 244 if (control_freq - MHZ_TO_KHZ(control_width) / 2 < 245 oper_freq - MHZ_TO_KHZ(oper_width) / 2) 246 return false; 247 break; 248 case NL80211_CHAN_WIDTH_40: 249 if (chandef->center_freq1 != control_freq + 10 && 250 chandef->center_freq1 != control_freq - 10) 251 return false; 252 if (chandef->center_freq2) 253 return false; 254 break; 255 case NL80211_CHAN_WIDTH_80P80: 256 if (chandef->center_freq1 != control_freq + 30 && 257 chandef->center_freq1 != control_freq + 10 && 258 chandef->center_freq1 != control_freq - 10 && 259 chandef->center_freq1 != control_freq - 30) 260 return false; 261 if (!chandef->center_freq2) 262 return false; 263 /* adjacent is not allowed -- that's a 160 MHz channel */ 264 if (chandef->center_freq1 - chandef->center_freq2 == 80 || 265 chandef->center_freq2 - chandef->center_freq1 == 80) 266 return false; 267 break; 268 case NL80211_CHAN_WIDTH_80: 269 if (chandef->center_freq1 != control_freq + 30 && 270 chandef->center_freq1 != control_freq + 10 && 271 chandef->center_freq1 != control_freq - 10 && 272 chandef->center_freq1 != control_freq - 30) 273 return false; 274 if (chandef->center_freq2) 275 return false; 276 break; 277 case NL80211_CHAN_WIDTH_160: 278 if (chandef->center_freq1 != control_freq + 70 && 279 chandef->center_freq1 != control_freq + 50 && 280 chandef->center_freq1 != control_freq + 30 && 281 chandef->center_freq1 != control_freq + 10 && 282 chandef->center_freq1 != control_freq - 10 && 283 chandef->center_freq1 != control_freq - 30 && 284 chandef->center_freq1 != control_freq - 50 && 285 chandef->center_freq1 != control_freq - 70) 286 return false; 287 if (chandef->center_freq2) 288 return false; 289 break; 290 default: 291 return false; 292 } 293 294 /* channel 14 is only for IEEE 802.11b */ 295 if (chandef->center_freq1 == 2484 && 296 chandef->width != NL80211_CHAN_WIDTH_20_NOHT) 297 return false; 298 299 if (cfg80211_chandef_is_edmg(chandef) && 300 !cfg80211_edmg_chandef_valid(chandef)) 301 return false; 302 303 return true; 304} 305EXPORT_SYMBOL(cfg80211_chandef_valid); 306 307static void chandef_primary_freqs(const struct cfg80211_chan_def *c, 308 u32 *pri40, u32 *pri80) 309{ 310 int tmp; 311 312 switch (c->width) { 313 case NL80211_CHAN_WIDTH_40: 314 *pri40 = c->center_freq1; 315 *pri80 = 0; 316 break; 317 case NL80211_CHAN_WIDTH_80: 318 case NL80211_CHAN_WIDTH_80P80: 319 *pri80 = c->center_freq1; 320 /* n_P20 */ 321 tmp = (30 + c->chan->center_freq - c->center_freq1)/20; 322 /* n_P40 */ 323 tmp /= 2; 324 /* freq_P40 */ 325 *pri40 = c->center_freq1 - 20 + 40 * tmp; 326 break; 327 case NL80211_CHAN_WIDTH_160: 328 /* n_P20 */ 329 tmp = (70 + c->chan->center_freq - c->center_freq1)/20; 330 /* n_P40 */ 331 tmp /= 2; 332 /* freq_P40 */ 333 *pri40 = c->center_freq1 - 60 + 40 * tmp; 334 /* n_P80 */ 335 tmp /= 2; 336 *pri80 = c->center_freq1 - 40 + 80 * tmp; 337 break; 338 default: 339 WARN_ON_ONCE(1); 340 } 341} 342 343const struct cfg80211_chan_def * 344cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1, 345 const struct cfg80211_chan_def *c2) 346{ 347 u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80; 348 349 /* If they are identical, return */ 350 if (cfg80211_chandef_identical(c1, c2)) 351 return c1; 352 353 /* otherwise, must have same control channel */ 354 if (c1->chan != c2->chan) 355 return NULL; 356 357 /* 358 * If they have the same width, but aren't identical, 359 * then they can't be compatible. 360 */ 361 if (c1->width == c2->width) 362 return NULL; 363 364 /* 365 * can't be compatible if one of them is 5 or 10 MHz, 366 * but they don't have the same width. 367 */ 368 if (c1->width == NL80211_CHAN_WIDTH_5 || 369 c1->width == NL80211_CHAN_WIDTH_10 || 370 c2->width == NL80211_CHAN_WIDTH_5 || 371 c2->width == NL80211_CHAN_WIDTH_10) 372 return NULL; 373 374 if (c1->width == NL80211_CHAN_WIDTH_20_NOHT || 375 c1->width == NL80211_CHAN_WIDTH_20) 376 return c2; 377 378 if (c2->width == NL80211_CHAN_WIDTH_20_NOHT || 379 c2->width == NL80211_CHAN_WIDTH_20) 380 return c1; 381 382 chandef_primary_freqs(c1, &c1_pri40, &c1_pri80); 383 chandef_primary_freqs(c2, &c2_pri40, &c2_pri80); 384 385 if (c1_pri40 != c2_pri40) 386 return NULL; 387 388 WARN_ON(!c1_pri80 && !c2_pri80); 389 if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80) 390 return NULL; 391 392 if (c1->width > c2->width) 393 return c1; 394 return c2; 395} 396EXPORT_SYMBOL(cfg80211_chandef_compatible); 397 398static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq, 399 u32 bandwidth, 400 enum nl80211_dfs_state dfs_state) 401{ 402 struct ieee80211_channel *c; 403 u32 freq; 404 405 for (freq = center_freq - bandwidth/2 + 10; 406 freq <= center_freq + bandwidth/2 - 10; 407 freq += 20) { 408 c = ieee80211_get_channel(wiphy, freq); 409 if (!c || !(c->flags & IEEE80211_CHAN_RADAR)) 410 continue; 411 412 c->dfs_state = dfs_state; 413 c->dfs_state_entered = jiffies; 414 } 415} 416 417void cfg80211_set_dfs_state(struct wiphy *wiphy, 418 const struct cfg80211_chan_def *chandef, 419 enum nl80211_dfs_state dfs_state) 420{ 421 int width; 422 423 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 424 return; 425 426 width = cfg80211_chandef_get_width(chandef); 427 if (width < 0) 428 return; 429 430 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1, 431 width, dfs_state); 432 433 if (!chandef->center_freq2) 434 return; 435 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2, 436 width, dfs_state); 437} 438 439static u32 cfg80211_get_start_freq(u32 center_freq, 440 u32 bandwidth) 441{ 442 u32 start_freq; 443 444 bandwidth = MHZ_TO_KHZ(bandwidth); 445 if (bandwidth <= MHZ_TO_KHZ(20)) 446 start_freq = center_freq; 447 else 448 start_freq = center_freq - bandwidth / 2 + MHZ_TO_KHZ(10); 449 450 return start_freq; 451} 452 453static u32 cfg80211_get_end_freq(u32 center_freq, 454 u32 bandwidth) 455{ 456 u32 end_freq; 457 458 bandwidth = MHZ_TO_KHZ(bandwidth); 459 if (bandwidth <= MHZ_TO_KHZ(20)) 460 end_freq = center_freq; 461 else 462 end_freq = center_freq + bandwidth / 2 - MHZ_TO_KHZ(10); 463 464 return end_freq; 465} 466 467static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy, 468 u32 center_freq, 469 u32 bandwidth) 470{ 471 struct ieee80211_channel *c; 472 u32 freq, start_freq, end_freq; 473 474 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 475 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 476 477 for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) { 478 c = ieee80211_get_channel_khz(wiphy, freq); 479 if (!c) 480 return -EINVAL; 481 482 if (c->flags & IEEE80211_CHAN_RADAR) 483 return 1; 484 } 485 return 0; 486} 487 488 489int cfg80211_chandef_dfs_required(struct wiphy *wiphy, 490 const struct cfg80211_chan_def *chandef, 491 enum nl80211_iftype iftype) 492{ 493 int width; 494 int ret; 495 496 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 497 return -EINVAL; 498 499 switch (iftype) { 500 case NL80211_IFTYPE_ADHOC: 501 case NL80211_IFTYPE_AP: 502 case NL80211_IFTYPE_P2P_GO: 503 case NL80211_IFTYPE_MESH_POINT: 504 width = cfg80211_chandef_get_width(chandef); 505 if (width < 0) 506 return -EINVAL; 507 508 ret = cfg80211_get_chans_dfs_required(wiphy, 509 ieee80211_chandef_to_khz(chandef), 510 width); 511 if (ret < 0) 512 return ret; 513 else if (ret > 0) 514 return BIT(chandef->width); 515 516 if (!chandef->center_freq2) 517 return 0; 518 519 ret = cfg80211_get_chans_dfs_required(wiphy, 520 MHZ_TO_KHZ(chandef->center_freq2), 521 width); 522 if (ret < 0) 523 return ret; 524 else if (ret > 0) 525 return BIT(chandef->width); 526 527 break; 528 case NL80211_IFTYPE_STATION: 529 case NL80211_IFTYPE_OCB: 530 case NL80211_IFTYPE_P2P_CLIENT: 531 case NL80211_IFTYPE_MONITOR: 532 case NL80211_IFTYPE_AP_VLAN: 533 case NL80211_IFTYPE_WDS: 534 case NL80211_IFTYPE_P2P_DEVICE: 535 case NL80211_IFTYPE_NAN: 536 break; 537 case NL80211_IFTYPE_UNSPECIFIED: 538 case NUM_NL80211_IFTYPES: 539 WARN_ON(1); 540 } 541 542 return 0; 543} 544EXPORT_SYMBOL(cfg80211_chandef_dfs_required); 545 546static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy, 547 u32 center_freq, 548 u32 bandwidth) 549{ 550 struct ieee80211_channel *c; 551 u32 freq, start_freq, end_freq; 552 int count = 0; 553 554 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 555 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 556 557 /* 558 * Check entire range of channels for the bandwidth. 559 * Check all channels are DFS channels (DFS_USABLE or 560 * DFS_AVAILABLE). Return number of usable channels 561 * (require CAC). Allow DFS and non-DFS channel mix. 562 */ 563 for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) { 564 c = ieee80211_get_channel_khz(wiphy, freq); 565 if (!c) 566 return -EINVAL; 567 568 if (c->flags & IEEE80211_CHAN_DISABLED) 569 return -EINVAL; 570 571 if (c->flags & IEEE80211_CHAN_RADAR) { 572 if (c->dfs_state == NL80211_DFS_UNAVAILABLE) 573 return -EINVAL; 574 575 if (c->dfs_state == NL80211_DFS_USABLE) 576 count++; 577 } 578 } 579 580 return count; 581} 582 583bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy, 584 const struct cfg80211_chan_def *chandef) 585{ 586 int width; 587 int r1, r2 = 0; 588 589 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 590 return false; 591 592 width = cfg80211_chandef_get_width(chandef); 593 if (width < 0) 594 return false; 595 596 r1 = cfg80211_get_chans_dfs_usable(wiphy, 597 MHZ_TO_KHZ(chandef->center_freq1), 598 width); 599 600 if (r1 < 0) 601 return false; 602 603 switch (chandef->width) { 604 case NL80211_CHAN_WIDTH_80P80: 605 WARN_ON(!chandef->center_freq2); 606 r2 = cfg80211_get_chans_dfs_usable(wiphy, 607 MHZ_TO_KHZ(chandef->center_freq2), 608 width); 609 if (r2 < 0) 610 return false; 611 break; 612 default: 613 WARN_ON(chandef->center_freq2); 614 break; 615 } 616 617 return (r1 + r2 > 0); 618} 619 620/* 621 * Checks if center frequency of chan falls with in the bandwidth 622 * range of chandef. 623 */ 624bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef, 625 struct ieee80211_channel *chan) 626{ 627 int width; 628 u32 freq; 629 630 if (chandef->chan->center_freq == chan->center_freq) 631 return true; 632 633 width = cfg80211_chandef_get_width(chandef); 634 if (width <= 20) 635 return false; 636 637 for (freq = chandef->center_freq1 - width / 2 + 10; 638 freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) { 639 if (chan->center_freq == freq) 640 return true; 641 } 642 643 if (!chandef->center_freq2) 644 return false; 645 646 for (freq = chandef->center_freq2 - width / 2 + 10; 647 freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) { 648 if (chan->center_freq == freq) 649 return true; 650 } 651 652 return false; 653} 654 655bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev) 656{ 657 bool active = false; 658 659 ASSERT_WDEV_LOCK(wdev); 660 661 if (!wdev->chandef.chan) 662 return false; 663 664 switch (wdev->iftype) { 665 case NL80211_IFTYPE_AP: 666 case NL80211_IFTYPE_P2P_GO: 667 active = wdev->beacon_interval != 0; 668 break; 669 case NL80211_IFTYPE_ADHOC: 670 active = wdev->ssid_len != 0; 671 break; 672 case NL80211_IFTYPE_MESH_POINT: 673 active = wdev->mesh_id_len != 0; 674 break; 675 case NL80211_IFTYPE_STATION: 676 case NL80211_IFTYPE_OCB: 677 case NL80211_IFTYPE_P2P_CLIENT: 678 case NL80211_IFTYPE_MONITOR: 679 case NL80211_IFTYPE_AP_VLAN: 680 case NL80211_IFTYPE_WDS: 681 case NL80211_IFTYPE_P2P_DEVICE: 682 /* Can NAN type be considered as beaconing interface? */ 683 case NL80211_IFTYPE_NAN: 684 break; 685 case NL80211_IFTYPE_UNSPECIFIED: 686 case NUM_NL80211_IFTYPES: 687 WARN_ON(1); 688 } 689 690 return active; 691} 692 693static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy, 694 struct ieee80211_channel *chan) 695{ 696 struct wireless_dev *wdev; 697 698 list_for_each_entry(wdev, &wiphy->wdev_list, list) { 699 wdev_lock(wdev); 700 if (!cfg80211_beaconing_iface_active(wdev)) { 701 wdev_unlock(wdev); 702 continue; 703 } 704 705 if (cfg80211_is_sub_chan(&wdev->chandef, chan)) { 706 wdev_unlock(wdev); 707 return true; 708 } 709 wdev_unlock(wdev); 710 } 711 712 return false; 713} 714 715bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy, 716 struct ieee80211_channel *chan) 717{ 718 struct cfg80211_registered_device *rdev; 719 720 ASSERT_RTNL(); 721 722 if (!(chan->flags & IEEE80211_CHAN_RADAR)) 723 return false; 724 725 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 726 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy)) 727 continue; 728 729 if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan)) 730 return true; 731 } 732 733 return false; 734} 735 736static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy, 737 u32 center_freq, 738 u32 bandwidth) 739{ 740 struct ieee80211_channel *c; 741 u32 freq, start_freq, end_freq; 742 bool dfs_offload; 743 744 dfs_offload = wiphy_ext_feature_isset(wiphy, 745 NL80211_EXT_FEATURE_DFS_OFFLOAD); 746 747 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 748 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 749 750 /* 751 * Check entire range of channels for the bandwidth. 752 * If any channel in between is disabled or has not 753 * had gone through CAC return false 754 */ 755 for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) { 756 c = ieee80211_get_channel_khz(wiphy, freq); 757 if (!c) 758 return false; 759 760 if (c->flags & IEEE80211_CHAN_DISABLED) 761 return false; 762 763 if ((c->flags & IEEE80211_CHAN_RADAR) && 764 (c->dfs_state != NL80211_DFS_AVAILABLE) && 765 !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload)) 766 return false; 767 } 768 769 return true; 770} 771 772static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy, 773 const struct cfg80211_chan_def *chandef) 774{ 775 int width; 776 int r; 777 778 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 779 return false; 780 781 width = cfg80211_chandef_get_width(chandef); 782 if (width < 0) 783 return false; 784 785 r = cfg80211_get_chans_dfs_available(wiphy, 786 MHZ_TO_KHZ(chandef->center_freq1), 787 width); 788 789 /* If any of channels unavailable for cf1 just return */ 790 if (!r) 791 return r; 792 793 switch (chandef->width) { 794 case NL80211_CHAN_WIDTH_80P80: 795 WARN_ON(!chandef->center_freq2); 796 r = cfg80211_get_chans_dfs_available(wiphy, 797 MHZ_TO_KHZ(chandef->center_freq2), 798 width); 799 break; 800 default: 801 WARN_ON(chandef->center_freq2); 802 break; 803 } 804 805 return r; 806} 807 808static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy, 809 u32 center_freq, 810 u32 bandwidth) 811{ 812 struct ieee80211_channel *c; 813 u32 start_freq, end_freq, freq; 814 unsigned int dfs_cac_ms = 0; 815 816 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 817 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 818 819 for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) { 820 c = ieee80211_get_channel_khz(wiphy, freq); 821 if (!c) 822 return 0; 823 824 if (c->flags & IEEE80211_CHAN_DISABLED) 825 return 0; 826 827 if (!(c->flags & IEEE80211_CHAN_RADAR)) 828 continue; 829 830 if (c->dfs_cac_ms > dfs_cac_ms) 831 dfs_cac_ms = c->dfs_cac_ms; 832 } 833 834 return dfs_cac_ms; 835} 836 837unsigned int 838cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy, 839 const struct cfg80211_chan_def *chandef) 840{ 841 int width; 842 unsigned int t1 = 0, t2 = 0; 843 844 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 845 return 0; 846 847 width = cfg80211_chandef_get_width(chandef); 848 if (width < 0) 849 return 0; 850 851 t1 = cfg80211_get_chans_dfs_cac_time(wiphy, 852 MHZ_TO_KHZ(chandef->center_freq1), 853 width); 854 855 if (!chandef->center_freq2) 856 return t1; 857 858 t2 = cfg80211_get_chans_dfs_cac_time(wiphy, 859 MHZ_TO_KHZ(chandef->center_freq2), 860 width); 861 862 return max(t1, t2); 863} 864 865static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy, 866 u32 center_freq, u32 bandwidth, 867 u32 prohibited_flags) 868{ 869 struct ieee80211_channel *c; 870 u32 freq, start_freq, end_freq; 871 872 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 873 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 874 875 for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) { 876 c = ieee80211_get_channel_khz(wiphy, freq); 877 if (!c || c->flags & prohibited_flags) 878 return false; 879 } 880 881 return true; 882} 883 884/* check if the operating channels are valid and supported */ 885static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels, 886 enum ieee80211_edmg_bw_config edmg_bw_config, 887 int primary_channel, 888 struct ieee80211_edmg *edmg_cap) 889{ 890 struct ieee80211_channel *chan; 891 int i, freq; 892 int channels_counter = 0; 893 894 if (!edmg_channels && !edmg_bw_config) 895 return true; 896 897 if ((!edmg_channels && edmg_bw_config) || 898 (edmg_channels && !edmg_bw_config)) 899 return false; 900 901 if (!(edmg_channels & BIT(primary_channel - 1))) 902 return false; 903 904 /* 60GHz channels 1..6 */ 905 for (i = 0; i < 6; i++) { 906 if (!(edmg_channels & BIT(i))) 907 continue; 908 909 if (!(edmg_cap->channels & BIT(i))) 910 return false; 911 912 channels_counter++; 913 914 freq = ieee80211_channel_to_frequency(i + 1, 915 NL80211_BAND_60GHZ); 916 chan = ieee80211_get_channel(wiphy, freq); 917 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) 918 return false; 919 } 920 921 /* IEEE802.11 allows max 4 channels */ 922 if (channels_counter > 4) 923 return false; 924 925 /* check bw_config is a subset of what driver supports 926 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13) 927 */ 928 if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4)) 929 return false; 930 931 if (edmg_bw_config > edmg_cap->bw_config) 932 return false; 933 934 return true; 935} 936 937bool cfg80211_chandef_usable(struct wiphy *wiphy, 938 const struct cfg80211_chan_def *chandef, 939 u32 prohibited_flags) 940{ 941 struct ieee80211_sta_ht_cap *ht_cap; 942 struct ieee80211_sta_vht_cap *vht_cap; 943 struct ieee80211_edmg *edmg_cap; 944 u32 width, control_freq, cap; 945 bool support_80_80 = false; 946 947 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 948 return false; 949 950 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 951 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 952 edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap; 953 954 if (edmg_cap->channels && 955 !cfg80211_edmg_usable(wiphy, 956 chandef->edmg.channels, 957 chandef->edmg.bw_config, 958 chandef->chan->hw_value, 959 edmg_cap)) 960 return false; 961 962 control_freq = chandef->chan->center_freq; 963 964 switch (chandef->width) { 965 case NL80211_CHAN_WIDTH_1: 966 width = 1; 967 break; 968 case NL80211_CHAN_WIDTH_2: 969 width = 2; 970 break; 971 case NL80211_CHAN_WIDTH_4: 972 width = 4; 973 break; 974 case NL80211_CHAN_WIDTH_8: 975 width = 8; 976 break; 977 case NL80211_CHAN_WIDTH_16: 978 width = 16; 979 break; 980 case NL80211_CHAN_WIDTH_5: 981 width = 5; 982 break; 983 case NL80211_CHAN_WIDTH_10: 984 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ; 985 width = 10; 986 break; 987 case NL80211_CHAN_WIDTH_20: 988 if (!ht_cap->ht_supported && 989 chandef->chan->band != NL80211_BAND_6GHZ) 990 return false; 991 fallthrough; 992 case NL80211_CHAN_WIDTH_20_NOHT: 993 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ; 994 width = 20; 995 break; 996 case NL80211_CHAN_WIDTH_40: 997 width = 40; 998 if (chandef->chan->band == NL80211_BAND_6GHZ) 999 break; 1000 if (!ht_cap->ht_supported) 1001 return false; 1002 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 1003 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 1004 return false; 1005 if (chandef->center_freq1 < control_freq && 1006 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 1007 return false; 1008 if (chandef->center_freq1 > control_freq && 1009 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 1010 return false; 1011 break; 1012 case NL80211_CHAN_WIDTH_80P80: 1013 cap = vht_cap->cap; 1014 support_80_80 = 1015 (cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) || 1016 (cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ && 1017 cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) || 1018 u32_get_bits(cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1; 1019 if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80) 1020 return false; 1021 fallthrough; 1022 case NL80211_CHAN_WIDTH_80: 1023 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 1024 width = 80; 1025 if (chandef->chan->band == NL80211_BAND_6GHZ) 1026 break; 1027 if (!vht_cap->vht_supported) 1028 return false; 1029 break; 1030 case NL80211_CHAN_WIDTH_160: 1031 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 1032 width = 160; 1033 if (chandef->chan->band == NL80211_BAND_6GHZ) 1034 break; 1035 if (!vht_cap->vht_supported) 1036 return false; 1037 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK; 1038 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ && 1039 cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ && 1040 !(vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)) 1041 return false; 1042 break; 1043 default: 1044 WARN_ON_ONCE(1); 1045 return false; 1046 } 1047 1048 /* 1049 * TODO: What if there are only certain 80/160/80+80 MHz channels 1050 * allowed by the driver, or only certain combinations? 1051 * For 40 MHz the driver can set the NO_HT40 flags, but for 1052 * 80/160 MHz and in particular 80+80 MHz this isn't really 1053 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 1054 * no way to cover 80+80 MHz or more complex restrictions. 1055 * Note that such restrictions also need to be advertised to 1056 * userspace, for example for P2P channel selection. 1057 */ 1058 1059 if (width > 20) 1060 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 1061 1062 /* 5 and 10 MHz are only defined for the OFDM PHY */ 1063 if (width < 20) 1064 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 1065 1066 1067 if (!cfg80211_secondary_chans_ok(wiphy, 1068 ieee80211_chandef_to_khz(chandef), 1069 width, prohibited_flags)) 1070 return false; 1071 1072 if (!chandef->center_freq2) 1073 return true; 1074 return cfg80211_secondary_chans_ok(wiphy, 1075 MHZ_TO_KHZ(chandef->center_freq2), 1076 width, prohibited_flags); 1077} 1078EXPORT_SYMBOL(cfg80211_chandef_usable); 1079 1080/* 1081 * Check if the channel can be used under permissive conditions mandated by 1082 * some regulatory bodies, i.e., the channel is marked with 1083 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface 1084 * associated to an AP on the same channel or on the same UNII band 1085 * (assuming that the AP is an authorized master). 1086 * In addition allow operation on a channel on which indoor operation is 1087 * allowed, iff we are currently operating in an indoor environment. 1088 */ 1089static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy, 1090 enum nl80211_iftype iftype, 1091 struct ieee80211_channel *chan) 1092{ 1093 struct wireless_dev *wdev; 1094 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 1095 1096 ASSERT_RTNL(); 1097 1098 if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) || 1099 !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR)) 1100 return false; 1101 1102 /* only valid for GO and TDLS off-channel (station/p2p-CL) */ 1103 if (iftype != NL80211_IFTYPE_P2P_GO && 1104 iftype != NL80211_IFTYPE_STATION && 1105 iftype != NL80211_IFTYPE_P2P_CLIENT) 1106 return false; 1107 1108 if (regulatory_indoor_allowed() && 1109 (chan->flags & IEEE80211_CHAN_INDOOR_ONLY)) 1110 return true; 1111 1112 if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT)) 1113 return false; 1114 1115 /* 1116 * Generally, it is possible to rely on another device/driver to allow 1117 * the IR concurrent relaxation, however, since the device can further 1118 * enforce the relaxation (by doing a similar verifications as this), 1119 * and thus fail the GO instantiation, consider only the interfaces of 1120 * the current registered device. 1121 */ 1122 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 1123 struct ieee80211_channel *other_chan = NULL; 1124 int r1, r2; 1125 1126 wdev_lock(wdev); 1127 if (wdev->iftype == NL80211_IFTYPE_STATION && 1128 wdev->current_bss) 1129 other_chan = wdev->current_bss->pub.channel; 1130 1131 /* 1132 * If a GO already operates on the same GO_CONCURRENT channel, 1133 * this one (maybe the same one) can beacon as well. We allow 1134 * the operation even if the station we relied on with 1135 * GO_CONCURRENT is disconnected now. But then we must make sure 1136 * we're not outdoor on an indoor-only channel. 1137 */ 1138 if (iftype == NL80211_IFTYPE_P2P_GO && 1139 wdev->iftype == NL80211_IFTYPE_P2P_GO && 1140 wdev->beacon_interval && 1141 !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY)) 1142 other_chan = wdev->chandef.chan; 1143 wdev_unlock(wdev); 1144 1145 if (!other_chan) 1146 continue; 1147 1148 if (chan == other_chan) 1149 return true; 1150 1151 if (chan->band != NL80211_BAND_5GHZ && 1152 chan->band != NL80211_BAND_6GHZ) 1153 continue; 1154 1155 r1 = cfg80211_get_unii(chan->center_freq); 1156 r2 = cfg80211_get_unii(other_chan->center_freq); 1157 1158 if (r1 != -EINVAL && r1 == r2) { 1159 /* 1160 * At some locations channels 149-165 are considered a 1161 * bundle, but at other locations, e.g., Indonesia, 1162 * channels 149-161 are considered a bundle while 1163 * channel 165 is left out and considered to be in a 1164 * different bundle. Thus, in case that there is a 1165 * station interface connected to an AP on channel 165, 1166 * it is assumed that channels 149-161 are allowed for 1167 * GO operations. However, having a station interface 1168 * connected to an AP on channels 149-161, does not 1169 * allow GO operation on channel 165. 1170 */ 1171 if (chan->center_freq == 5825 && 1172 other_chan->center_freq != 5825) 1173 continue; 1174 return true; 1175 } 1176 } 1177 1178 return false; 1179} 1180 1181static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy, 1182 struct cfg80211_chan_def *chandef, 1183 enum nl80211_iftype iftype, 1184 bool check_no_ir) 1185{ 1186 bool res; 1187 u32 prohibited_flags = IEEE80211_CHAN_DISABLED | 1188 IEEE80211_CHAN_RADAR; 1189 1190 trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir); 1191 1192 if (check_no_ir) 1193 prohibited_flags |= IEEE80211_CHAN_NO_IR; 1194 1195 if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 && 1196 cfg80211_chandef_dfs_available(wiphy, chandef)) { 1197 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */ 1198 prohibited_flags = IEEE80211_CHAN_DISABLED; 1199 } 1200 1201 res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags); 1202 1203 trace_cfg80211_return_bool(res); 1204 return res; 1205} 1206 1207bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 1208 struct cfg80211_chan_def *chandef, 1209 enum nl80211_iftype iftype) 1210{ 1211 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true); 1212} 1213EXPORT_SYMBOL(cfg80211_reg_can_beacon); 1214 1215bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy, 1216 struct cfg80211_chan_def *chandef, 1217 enum nl80211_iftype iftype) 1218{ 1219 bool check_no_ir; 1220 1221 ASSERT_RTNL(); 1222 1223 /* 1224 * Under certain conditions suggested by some regulatory bodies a 1225 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag 1226 * only if such relaxations are not enabled and the conditions are not 1227 * met. 1228 */ 1229 check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype, 1230 chandef->chan); 1231 1232 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir); 1233} 1234EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax); 1235 1236int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 1237 struct cfg80211_chan_def *chandef) 1238{ 1239 if (!rdev->ops->set_monitor_channel) 1240 return -EOPNOTSUPP; 1241 if (!cfg80211_has_monitors_only(rdev)) 1242 return -EBUSY; 1243 1244 return rdev_set_monitor_channel(rdev, chandef); 1245} 1246 1247void 1248cfg80211_get_chan_state(struct wireless_dev *wdev, 1249 struct ieee80211_channel **chan, 1250 enum cfg80211_chan_mode *chanmode, 1251 u8 *radar_detect) 1252{ 1253 int ret; 1254 1255 *chan = NULL; 1256 *chanmode = CHAN_MODE_UNDEFINED; 1257 1258 ASSERT_WDEV_LOCK(wdev); 1259 1260 if (wdev->netdev && !netif_running(wdev->netdev)) 1261 return; 1262 1263 switch (wdev->iftype) { 1264 case NL80211_IFTYPE_ADHOC: 1265 if (wdev->current_bss) { 1266 *chan = wdev->current_bss->pub.channel; 1267 *chanmode = (wdev->ibss_fixed && 1268 !wdev->ibss_dfs_possible) 1269 ? CHAN_MODE_SHARED 1270 : CHAN_MODE_EXCLUSIVE; 1271 1272 /* consider worst-case - IBSS can try to return to the 1273 * original user-specified channel as creator */ 1274 if (wdev->ibss_dfs_possible) 1275 *radar_detect |= BIT(wdev->chandef.width); 1276 return; 1277 } 1278 break; 1279 case NL80211_IFTYPE_STATION: 1280 case NL80211_IFTYPE_P2P_CLIENT: 1281 if (wdev->current_bss) { 1282 *chan = wdev->current_bss->pub.channel; 1283 *chanmode = CHAN_MODE_SHARED; 1284 return; 1285 } 1286 break; 1287 case NL80211_IFTYPE_AP: 1288 case NL80211_IFTYPE_P2P_GO: 1289 if (wdev->cac_started) { 1290 *chan = wdev->chandef.chan; 1291 *chanmode = CHAN_MODE_SHARED; 1292 *radar_detect |= BIT(wdev->chandef.width); 1293 } else if (wdev->beacon_interval) { 1294 *chan = wdev->chandef.chan; 1295 *chanmode = CHAN_MODE_SHARED; 1296 1297 ret = cfg80211_chandef_dfs_required(wdev->wiphy, 1298 &wdev->chandef, 1299 wdev->iftype); 1300 WARN_ON(ret < 0); 1301 if (ret > 0) 1302 *radar_detect |= BIT(wdev->chandef.width); 1303 } 1304 return; 1305 case NL80211_IFTYPE_MESH_POINT: 1306 if (wdev->mesh_id_len) { 1307 *chan = wdev->chandef.chan; 1308 *chanmode = CHAN_MODE_SHARED; 1309 1310 ret = cfg80211_chandef_dfs_required(wdev->wiphy, 1311 &wdev->chandef, 1312 wdev->iftype); 1313 WARN_ON(ret < 0); 1314 if (ret > 0) 1315 *radar_detect |= BIT(wdev->chandef.width); 1316 } 1317 return; 1318 case NL80211_IFTYPE_OCB: 1319 if (wdev->chandef.chan) { 1320 *chan = wdev->chandef.chan; 1321 *chanmode = CHAN_MODE_SHARED; 1322 return; 1323 } 1324 break; 1325 case NL80211_IFTYPE_MONITOR: 1326 case NL80211_IFTYPE_AP_VLAN: 1327 case NL80211_IFTYPE_WDS: 1328 case NL80211_IFTYPE_P2P_DEVICE: 1329 case NL80211_IFTYPE_NAN: 1330 /* these interface types don't really have a channel */ 1331 return; 1332 case NL80211_IFTYPE_UNSPECIFIED: 1333 case NUM_NL80211_IFTYPES: 1334 WARN_ON(1); 1335 } 1336} 1337