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