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