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-2025 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 = (struct cfg80211_chan_def) { 31 .chan = chan, 32 .freq1_offset = chan->freq_offset, 33 }; 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 u32 cfg80211_get_start_freq(const struct cfg80211_chan_def *chandef, 59 u32 cf) 60 { 61 u32 start_freq, center_freq, bandwidth; 62 63 center_freq = MHZ_TO_KHZ((cf == 1) ? 64 chandef->center_freq1 : chandef->center_freq2); 65 bandwidth = MHZ_TO_KHZ(cfg80211_chandef_get_width(chandef)); 66 67 if (bandwidth <= MHZ_TO_KHZ(20)) 68 start_freq = center_freq; 69 else 70 start_freq = center_freq - bandwidth / 2 + MHZ_TO_KHZ(10); 71 72 return start_freq; 73 } 74 75 static u32 cfg80211_get_end_freq(const struct cfg80211_chan_def *chandef, 76 u32 cf) 77 { 78 u32 end_freq, center_freq, bandwidth; 79 80 center_freq = MHZ_TO_KHZ((cf == 1) ? 81 chandef->center_freq1 : chandef->center_freq2); 82 bandwidth = MHZ_TO_KHZ(cfg80211_chandef_get_width(chandef)); 83 84 if (bandwidth <= MHZ_TO_KHZ(20)) 85 end_freq = center_freq; 86 else 87 end_freq = center_freq + bandwidth / 2 - MHZ_TO_KHZ(10); 88 89 return end_freq; 90 } 91 92 #define for_each_subchan(chandef, freq, cf) \ 93 for (u32 punctured = chandef->punctured, \ 94 cf = 1, freq = cfg80211_get_start_freq(chandef, cf); \ 95 freq <= cfg80211_get_end_freq(chandef, cf); \ 96 freq += MHZ_TO_KHZ(20), \ 97 ((cf == 1 && chandef->center_freq2 != 0 && \ 98 freq > cfg80211_get_end_freq(chandef, cf)) ? \ 99 (cf++, freq = cfg80211_get_start_freq(chandef, cf), \ 100 punctured = 0) : (punctured >>= 1))) \ 101 if (!(punctured & 1)) 102 103 struct cfg80211_per_bw_puncturing_values { 104 u8 len; 105 const u16 *valid_values; 106 }; 107 108 static const u16 puncturing_values_80mhz[] = { 109 0x8, 0x4, 0x2, 0x1 110 }; 111 112 static const u16 puncturing_values_160mhz[] = { 113 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1, 0xc0, 0x30, 0xc, 0x3 114 }; 115 116 static const u16 puncturing_values_320mhz[] = { 117 0xc000, 0x3000, 0xc00, 0x300, 0xc0, 0x30, 0xc, 0x3, 0xf000, 0xf00, 118 0xf0, 0xf, 0xfc00, 0xf300, 0xf0c0, 0xf030, 0xf00c, 0xf003, 0xc00f, 119 0x300f, 0xc0f, 0x30f, 0xcf, 0x3f 120 }; 121 122 #define CFG80211_PER_BW_VALID_PUNCTURING_VALUES(_bw) \ 123 { \ 124 .len = ARRAY_SIZE(puncturing_values_ ## _bw ## mhz), \ 125 .valid_values = puncturing_values_ ## _bw ## mhz \ 126 } 127 128 static const struct cfg80211_per_bw_puncturing_values per_bw_puncturing[] = { 129 CFG80211_PER_BW_VALID_PUNCTURING_VALUES(80), 130 CFG80211_PER_BW_VALID_PUNCTURING_VALUES(160), 131 CFG80211_PER_BW_VALID_PUNCTURING_VALUES(320) 132 }; 133 134 static bool valid_puncturing_bitmap(const struct cfg80211_chan_def *chandef) 135 { 136 u32 idx, i, start_freq, primary_center = chandef->chan->center_freq; 137 138 switch (chandef->width) { 139 case NL80211_CHAN_WIDTH_80: 140 idx = 0; 141 start_freq = chandef->center_freq1 - 40; 142 break; 143 case NL80211_CHAN_WIDTH_160: 144 idx = 1; 145 start_freq = chandef->center_freq1 - 80; 146 break; 147 case NL80211_CHAN_WIDTH_320: 148 idx = 2; 149 start_freq = chandef->center_freq1 - 160; 150 break; 151 default: 152 return chandef->punctured == 0; 153 } 154 155 if (!chandef->punctured) 156 return true; 157 158 /* check if primary channel is punctured */ 159 if (chandef->punctured & (u16)BIT((primary_center - start_freq) / 20)) 160 return false; 161 162 for (i = 0; i < per_bw_puncturing[idx].len; i++) { 163 if (per_bw_puncturing[idx].valid_values[i] == chandef->punctured) 164 return true; 165 } 166 167 return false; 168 } 169 170 static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef) 171 { 172 int max_contiguous = 0; 173 int num_of_enabled = 0; 174 int contiguous = 0; 175 int i; 176 177 if (!chandef->edmg.channels || !chandef->edmg.bw_config) 178 return false; 179 180 if (!cfg80211_valid_60g_freq(chandef->chan->center_freq)) 181 return false; 182 183 for (i = 0; i < 6; i++) { 184 if (chandef->edmg.channels & BIT(i)) { 185 contiguous++; 186 num_of_enabled++; 187 } else { 188 contiguous = 0; 189 } 190 191 max_contiguous = max(contiguous, max_contiguous); 192 } 193 /* basic verification of edmg configuration according to 194 * IEEE P802.11ay/D4.0 section 9.4.2.251 195 */ 196 /* check bw_config against contiguous edmg channels */ 197 switch (chandef->edmg.bw_config) { 198 case IEEE80211_EDMG_BW_CONFIG_4: 199 case IEEE80211_EDMG_BW_CONFIG_8: 200 case IEEE80211_EDMG_BW_CONFIG_12: 201 if (max_contiguous < 1) 202 return false; 203 break; 204 case IEEE80211_EDMG_BW_CONFIG_5: 205 case IEEE80211_EDMG_BW_CONFIG_9: 206 case IEEE80211_EDMG_BW_CONFIG_13: 207 if (max_contiguous < 2) 208 return false; 209 break; 210 case IEEE80211_EDMG_BW_CONFIG_6: 211 case IEEE80211_EDMG_BW_CONFIG_10: 212 case IEEE80211_EDMG_BW_CONFIG_14: 213 if (max_contiguous < 3) 214 return false; 215 break; 216 case IEEE80211_EDMG_BW_CONFIG_7: 217 case IEEE80211_EDMG_BW_CONFIG_11: 218 case IEEE80211_EDMG_BW_CONFIG_15: 219 if (max_contiguous < 4) 220 return false; 221 break; 222 223 default: 224 return false; 225 } 226 227 /* check bw_config against aggregated (non contiguous) edmg channels */ 228 switch (chandef->edmg.bw_config) { 229 case IEEE80211_EDMG_BW_CONFIG_4: 230 case IEEE80211_EDMG_BW_CONFIG_5: 231 case IEEE80211_EDMG_BW_CONFIG_6: 232 case IEEE80211_EDMG_BW_CONFIG_7: 233 break; 234 case IEEE80211_EDMG_BW_CONFIG_8: 235 case IEEE80211_EDMG_BW_CONFIG_9: 236 case IEEE80211_EDMG_BW_CONFIG_10: 237 case IEEE80211_EDMG_BW_CONFIG_11: 238 if (num_of_enabled < 2) 239 return false; 240 break; 241 case IEEE80211_EDMG_BW_CONFIG_12: 242 case IEEE80211_EDMG_BW_CONFIG_13: 243 case IEEE80211_EDMG_BW_CONFIG_14: 244 case IEEE80211_EDMG_BW_CONFIG_15: 245 if (num_of_enabled < 4 || max_contiguous < 2) 246 return false; 247 break; 248 default: 249 return false; 250 } 251 252 return true; 253 } 254 255 int nl80211_chan_width_to_mhz(enum nl80211_chan_width chan_width) 256 { 257 int mhz; 258 259 switch (chan_width) { 260 case NL80211_CHAN_WIDTH_1: 261 mhz = 1; 262 break; 263 case NL80211_CHAN_WIDTH_2: 264 mhz = 2; 265 break; 266 case NL80211_CHAN_WIDTH_4: 267 mhz = 4; 268 break; 269 case NL80211_CHAN_WIDTH_8: 270 mhz = 8; 271 break; 272 case NL80211_CHAN_WIDTH_16: 273 mhz = 16; 274 break; 275 case NL80211_CHAN_WIDTH_5: 276 mhz = 5; 277 break; 278 case NL80211_CHAN_WIDTH_10: 279 mhz = 10; 280 break; 281 case NL80211_CHAN_WIDTH_20: 282 case NL80211_CHAN_WIDTH_20_NOHT: 283 mhz = 20; 284 break; 285 case NL80211_CHAN_WIDTH_40: 286 mhz = 40; 287 break; 288 case NL80211_CHAN_WIDTH_80P80: 289 case NL80211_CHAN_WIDTH_80: 290 mhz = 80; 291 break; 292 case NL80211_CHAN_WIDTH_160: 293 mhz = 160; 294 break; 295 case NL80211_CHAN_WIDTH_320: 296 mhz = 320; 297 break; 298 default: 299 WARN_ON_ONCE(1); 300 return -1; 301 } 302 return mhz; 303 } 304 EXPORT_SYMBOL(nl80211_chan_width_to_mhz); 305 306 static bool cfg80211_valid_center_freq(u32 center, 307 enum nl80211_chan_width width) 308 { 309 int bw; 310 int step; 311 312 /* We only do strict verification on 6 GHz */ 313 if (center < 5955 || center > 7115) 314 return true; 315 316 bw = nl80211_chan_width_to_mhz(width); 317 if (bw < 0) 318 return false; 319 320 /* Validate that the channels bw is entirely within the 6 GHz band */ 321 if (center - bw / 2 < 5945 || center + bw / 2 > 7125) 322 return false; 323 324 /* With 320 MHz the permitted channels overlap */ 325 if (bw == 320) 326 step = 160; 327 else 328 step = bw; 329 330 /* 331 * Valid channels are packed from lowest frequency towards higher ones. 332 * So test that the lower frequency aligns with one of these steps. 333 */ 334 return (center - bw / 2 - 5945) % step == 0; 335 } 336 337 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef) 338 { 339 u32 control_freq, oper_freq; 340 int oper_width, control_width; 341 342 if (!chandef->chan) 343 return false; 344 345 if (chandef->freq1_offset >= 1000) 346 return false; 347 348 control_freq = chandef->chan->center_freq; 349 350 switch (chandef->width) { 351 case NL80211_CHAN_WIDTH_5: 352 case NL80211_CHAN_WIDTH_10: 353 case NL80211_CHAN_WIDTH_20: 354 case NL80211_CHAN_WIDTH_20_NOHT: 355 if (ieee80211_chandef_to_khz(chandef) != 356 ieee80211_channel_to_khz(chandef->chan)) 357 return false; 358 if (chandef->center_freq2) 359 return false; 360 break; 361 case NL80211_CHAN_WIDTH_1: 362 case NL80211_CHAN_WIDTH_2: 363 case NL80211_CHAN_WIDTH_4: 364 case NL80211_CHAN_WIDTH_8: 365 case NL80211_CHAN_WIDTH_16: 366 if (chandef->chan->band != NL80211_BAND_S1GHZ) 367 return false; 368 369 control_freq = ieee80211_channel_to_khz(chandef->chan); 370 oper_freq = ieee80211_chandef_to_khz(chandef); 371 control_width = nl80211_chan_width_to_mhz( 372 ieee80211_s1g_channel_width( 373 chandef->chan)); 374 oper_width = cfg80211_chandef_get_width(chandef); 375 376 if (oper_width < 0 || control_width < 0) 377 return false; 378 if (chandef->center_freq2) 379 return false; 380 381 if (control_freq + MHZ_TO_KHZ(control_width) / 2 > 382 oper_freq + MHZ_TO_KHZ(oper_width) / 2) 383 return false; 384 385 if (control_freq - MHZ_TO_KHZ(control_width) / 2 < 386 oper_freq - MHZ_TO_KHZ(oper_width) / 2) 387 return false; 388 break; 389 case NL80211_CHAN_WIDTH_80P80: 390 if (!chandef->center_freq2) 391 return false; 392 /* adjacent is not allowed -- that's a 160 MHz channel */ 393 if (chandef->center_freq1 - chandef->center_freq2 == 80 || 394 chandef->center_freq2 - chandef->center_freq1 == 80) 395 return false; 396 break; 397 default: 398 if (chandef->center_freq2) 399 return false; 400 break; 401 } 402 403 switch (chandef->width) { 404 case NL80211_CHAN_WIDTH_5: 405 case NL80211_CHAN_WIDTH_10: 406 case NL80211_CHAN_WIDTH_20: 407 case NL80211_CHAN_WIDTH_20_NOHT: 408 case NL80211_CHAN_WIDTH_1: 409 case NL80211_CHAN_WIDTH_2: 410 case NL80211_CHAN_WIDTH_4: 411 case NL80211_CHAN_WIDTH_8: 412 case NL80211_CHAN_WIDTH_16: 413 /* all checked above */ 414 break; 415 case NL80211_CHAN_WIDTH_320: 416 if (chandef->center_freq1 == control_freq + 150 || 417 chandef->center_freq1 == control_freq + 130 || 418 chandef->center_freq1 == control_freq + 110 || 419 chandef->center_freq1 == control_freq + 90 || 420 chandef->center_freq1 == control_freq - 90 || 421 chandef->center_freq1 == control_freq - 110 || 422 chandef->center_freq1 == control_freq - 130 || 423 chandef->center_freq1 == control_freq - 150) 424 break; 425 fallthrough; 426 case NL80211_CHAN_WIDTH_160: 427 if (chandef->center_freq1 == control_freq + 70 || 428 chandef->center_freq1 == control_freq + 50 || 429 chandef->center_freq1 == control_freq - 50 || 430 chandef->center_freq1 == control_freq - 70) 431 break; 432 fallthrough; 433 case NL80211_CHAN_WIDTH_80P80: 434 case NL80211_CHAN_WIDTH_80: 435 if (chandef->center_freq1 == control_freq + 30 || 436 chandef->center_freq1 == control_freq - 30) 437 break; 438 fallthrough; 439 case NL80211_CHAN_WIDTH_40: 440 if (chandef->center_freq1 == control_freq + 10 || 441 chandef->center_freq1 == control_freq - 10) 442 break; 443 fallthrough; 444 default: 445 return false; 446 } 447 448 if (!cfg80211_valid_center_freq(chandef->center_freq1, chandef->width)) 449 return false; 450 451 if (chandef->width == NL80211_CHAN_WIDTH_80P80 && 452 !cfg80211_valid_center_freq(chandef->center_freq2, chandef->width)) 453 return false; 454 455 /* channel 14 is only for IEEE 802.11b */ 456 if (chandef->center_freq1 == 2484 && 457 chandef->width != NL80211_CHAN_WIDTH_20_NOHT) 458 return false; 459 460 if (cfg80211_chandef_is_edmg(chandef) && 461 !cfg80211_edmg_chandef_valid(chandef)) 462 return false; 463 464 return valid_puncturing_bitmap(chandef); 465 } 466 EXPORT_SYMBOL(cfg80211_chandef_valid); 467 468 int cfg80211_chandef_primary(const struct cfg80211_chan_def *c, 469 enum nl80211_chan_width primary_chan_width, 470 u16 *punctured) 471 { 472 int pri_width = nl80211_chan_width_to_mhz(primary_chan_width); 473 int width = cfg80211_chandef_get_width(c); 474 u32 control = c->chan->center_freq; 475 u32 center = c->center_freq1; 476 u16 _punct = 0; 477 478 if (WARN_ON_ONCE(pri_width < 0 || width < 0)) 479 return -1; 480 481 /* not intended to be called this way, can't determine */ 482 if (WARN_ON_ONCE(pri_width > width)) 483 return -1; 484 485 if (!punctured) 486 punctured = &_punct; 487 488 *punctured = c->punctured; 489 490 while (width > pri_width) { 491 unsigned int bits_to_drop = width / 20 / 2; 492 493 if (control > center) { 494 center += width / 4; 495 *punctured >>= bits_to_drop; 496 } else { 497 center -= width / 4; 498 *punctured &= (1 << bits_to_drop) - 1; 499 } 500 width /= 2; 501 } 502 503 return center; 504 } 505 EXPORT_SYMBOL(cfg80211_chandef_primary); 506 507 static const struct cfg80211_chan_def * 508 check_chandef_primary_compat(const struct cfg80211_chan_def *c1, 509 const struct cfg80211_chan_def *c2, 510 enum nl80211_chan_width primary_chan_width) 511 { 512 u16 punct_c1 = 0, punct_c2 = 0; 513 514 /* check primary is compatible -> error if not */ 515 if (cfg80211_chandef_primary(c1, primary_chan_width, &punct_c1) != 516 cfg80211_chandef_primary(c2, primary_chan_width, &punct_c2)) 517 return ERR_PTR(-EINVAL); 518 519 if (punct_c1 != punct_c2) 520 return ERR_PTR(-EINVAL); 521 522 /* assumes c1 is smaller width, if that was just checked -> done */ 523 if (c1->width == primary_chan_width) 524 return c2; 525 526 /* otherwise continue checking the next width */ 527 return NULL; 528 } 529 530 static const struct cfg80211_chan_def * 531 _cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1, 532 const struct cfg80211_chan_def *c2) 533 { 534 const struct cfg80211_chan_def *ret; 535 536 /* If they are identical, return */ 537 if (cfg80211_chandef_identical(c1, c2)) 538 return c2; 539 540 /* otherwise, must have same control channel */ 541 if (c1->chan != c2->chan) 542 return NULL; 543 544 /* 545 * If they have the same width, but aren't identical, 546 * then they can't be compatible. 547 */ 548 if (c1->width == c2->width) 549 return NULL; 550 551 /* 552 * can't be compatible if one of them is 5/10 MHz or S1G 553 * but they don't have the same width. 554 */ 555 #define NARROW_OR_S1G(width) ((width) == NL80211_CHAN_WIDTH_5 || \ 556 (width) == NL80211_CHAN_WIDTH_10 || \ 557 (width) == NL80211_CHAN_WIDTH_1 || \ 558 (width) == NL80211_CHAN_WIDTH_2 || \ 559 (width) == NL80211_CHAN_WIDTH_4 || \ 560 (width) == NL80211_CHAN_WIDTH_8 || \ 561 (width) == NL80211_CHAN_WIDTH_16) 562 563 if (NARROW_OR_S1G(c1->width) || NARROW_OR_S1G(c2->width)) 564 return NULL; 565 566 /* 567 * Make sure that c1 is always the narrower one, so that later 568 * we either return NULL or c2 and don't have to check both 569 * directions. 570 */ 571 if (c1->width > c2->width) 572 swap(c1, c2); 573 574 /* 575 * No further checks needed if the "narrower" one is only 20 MHz. 576 * Here "narrower" includes being a 20 MHz non-HT channel vs. a 577 * 20 MHz HT (or later) one. 578 */ 579 if (c1->width <= NL80211_CHAN_WIDTH_20) 580 return c2; 581 582 ret = check_chandef_primary_compat(c1, c2, NL80211_CHAN_WIDTH_40); 583 if (ret) 584 return ret; 585 586 ret = check_chandef_primary_compat(c1, c2, NL80211_CHAN_WIDTH_80); 587 if (ret) 588 return ret; 589 590 /* 591 * If c1 is 80+80, then c2 is 160 or higher, but that cannot 592 * match. If c2 was also 80+80 it was already either accepted 593 * or rejected above (identical or not, respectively.) 594 */ 595 if (c1->width == NL80211_CHAN_WIDTH_80P80) 596 return NULL; 597 598 ret = check_chandef_primary_compat(c1, c2, NL80211_CHAN_WIDTH_160); 599 if (ret) 600 return ret; 601 602 /* 603 * Getting here would mean they're both wider than 160, have the 604 * same primary 160, but are not identical - this cannot happen 605 * since they must be 320 (no wider chandefs exist, at least yet.) 606 */ 607 WARN_ON_ONCE(1); 608 609 return NULL; 610 } 611 612 const struct cfg80211_chan_def * 613 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1, 614 const struct cfg80211_chan_def *c2) 615 { 616 const struct cfg80211_chan_def *ret; 617 618 ret = _cfg80211_chandef_compatible(c1, c2); 619 if (IS_ERR(ret)) 620 return NULL; 621 return ret; 622 } 623 EXPORT_SYMBOL(cfg80211_chandef_compatible); 624 625 void cfg80211_set_dfs_state(struct wiphy *wiphy, 626 const struct cfg80211_chan_def *chandef, 627 enum nl80211_dfs_state dfs_state) 628 { 629 struct ieee80211_channel *c; 630 int width; 631 632 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 633 return; 634 635 width = cfg80211_chandef_get_width(chandef); 636 if (width < 0) 637 return; 638 639 for_each_subchan(chandef, freq, cf) { 640 c = ieee80211_get_channel_khz(wiphy, freq); 641 if (!c || !(c->flags & IEEE80211_CHAN_RADAR)) 642 continue; 643 644 c->dfs_state = dfs_state; 645 c->dfs_state_entered = jiffies; 646 } 647 } 648 649 static bool 650 cfg80211_dfs_permissive_check_wdev(struct cfg80211_registered_device *rdev, 651 enum nl80211_iftype iftype, 652 struct wireless_dev *wdev, 653 struct ieee80211_channel *chan) 654 { 655 unsigned int link_id; 656 657 for_each_valid_link(wdev, link_id) { 658 struct ieee80211_channel *other_chan = NULL; 659 struct cfg80211_chan_def chandef = {}; 660 int ret; 661 662 /* In order to avoid daisy chaining only allow BSS STA */ 663 if (wdev->iftype != NL80211_IFTYPE_STATION || 664 !wdev->links[link_id].client.current_bss) 665 continue; 666 667 other_chan = 668 wdev->links[link_id].client.current_bss->pub.channel; 669 670 if (!other_chan) 671 continue; 672 673 if (chan == other_chan) 674 return true; 675 676 /* continue if we can't get the channel */ 677 ret = rdev_get_channel(rdev, wdev, link_id, &chandef); 678 if (ret) 679 continue; 680 681 if (cfg80211_is_sub_chan(&chandef, chan, false)) 682 return true; 683 } 684 685 return false; 686 } 687 688 /* 689 * Check if P2P GO is allowed to operate on a DFS channel 690 */ 691 static bool cfg80211_dfs_permissive_chan(struct wiphy *wiphy, 692 enum nl80211_iftype iftype, 693 struct ieee80211_channel *chan) 694 { 695 struct wireless_dev *wdev; 696 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 697 698 lockdep_assert_held(&rdev->wiphy.mtx); 699 700 if (!wiphy_ext_feature_isset(&rdev->wiphy, 701 NL80211_EXT_FEATURE_DFS_CONCURRENT) || 702 !(chan->flags & IEEE80211_CHAN_DFS_CONCURRENT)) 703 return false; 704 705 /* only valid for P2P GO */ 706 if (iftype != NL80211_IFTYPE_P2P_GO) 707 return false; 708 709 /* 710 * Allow only if there's a concurrent BSS 711 */ 712 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 713 bool ret = cfg80211_dfs_permissive_check_wdev(rdev, iftype, 714 wdev, chan); 715 if (ret) 716 return ret; 717 } 718 719 return false; 720 } 721 722 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy, 723 const struct cfg80211_chan_def *chandef, 724 enum nl80211_iftype iftype) 725 { 726 struct ieee80211_channel *c; 727 728 for_each_subchan(chandef, freq, cf) { 729 c = ieee80211_get_channel_khz(wiphy, freq); 730 if (!c) 731 return -EINVAL; 732 733 if (c->flags & IEEE80211_CHAN_RADAR && 734 !cfg80211_dfs_permissive_chan(wiphy, iftype, c)) 735 return 1; 736 } 737 738 return 0; 739 } 740 741 742 int cfg80211_chandef_dfs_required(struct wiphy *wiphy, 743 const struct cfg80211_chan_def *chandef, 744 enum nl80211_iftype iftype) 745 { 746 int width; 747 int ret; 748 749 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 750 return -EINVAL; 751 752 switch (iftype) { 753 case NL80211_IFTYPE_ADHOC: 754 case NL80211_IFTYPE_AP: 755 case NL80211_IFTYPE_P2P_GO: 756 case NL80211_IFTYPE_MESH_POINT: 757 width = cfg80211_chandef_get_width(chandef); 758 if (width < 0) 759 return -EINVAL; 760 761 ret = cfg80211_get_chans_dfs_required(wiphy, chandef, iftype); 762 763 return (ret > 0) ? BIT(chandef->width) : ret; 764 break; 765 case NL80211_IFTYPE_STATION: 766 case NL80211_IFTYPE_OCB: 767 case NL80211_IFTYPE_P2P_CLIENT: 768 case NL80211_IFTYPE_MONITOR: 769 case NL80211_IFTYPE_AP_VLAN: 770 case NL80211_IFTYPE_P2P_DEVICE: 771 case NL80211_IFTYPE_NAN: 772 break; 773 case NL80211_IFTYPE_WDS: 774 case NL80211_IFTYPE_UNSPECIFIED: 775 case NUM_NL80211_IFTYPES: 776 WARN_ON(1); 777 } 778 779 return 0; 780 } 781 EXPORT_SYMBOL(cfg80211_chandef_dfs_required); 782 783 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy, 784 const struct cfg80211_chan_def *chandef) 785 { 786 struct ieee80211_channel *c; 787 int width, count = 0; 788 789 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 790 return false; 791 792 width = cfg80211_chandef_get_width(chandef); 793 if (width < 0) 794 return false; 795 796 /* 797 * Check entire range of channels for the bandwidth. 798 * Check all channels are DFS channels (DFS_USABLE or 799 * DFS_AVAILABLE). Return number of usable channels 800 * (require CAC). Allow DFS and non-DFS channel mix. 801 */ 802 for_each_subchan(chandef, freq, cf) { 803 c = ieee80211_get_channel_khz(wiphy, freq); 804 if (!c) 805 return false; 806 807 if (c->flags & IEEE80211_CHAN_DISABLED) 808 return false; 809 810 if (c->flags & IEEE80211_CHAN_RADAR) { 811 if (c->dfs_state == NL80211_DFS_UNAVAILABLE) 812 return false; 813 814 if (c->dfs_state == NL80211_DFS_USABLE) 815 count++; 816 } 817 } 818 819 return count > 0; 820 } 821 EXPORT_SYMBOL(cfg80211_chandef_dfs_usable); 822 823 /* 824 * Checks if center frequency of chan falls with in the bandwidth 825 * range of chandef. 826 */ 827 bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef, 828 struct ieee80211_channel *chan, 829 bool primary_only) 830 { 831 int width; 832 u32 freq; 833 834 if (!chandef->chan) 835 return false; 836 837 if (chandef->chan->center_freq == chan->center_freq) 838 return true; 839 840 if (primary_only) 841 return false; 842 843 width = cfg80211_chandef_get_width(chandef); 844 if (width <= 20) 845 return false; 846 847 for (freq = chandef->center_freq1 - width / 2 + 10; 848 freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) { 849 if (chan->center_freq == freq) 850 return true; 851 } 852 853 if (!chandef->center_freq2) 854 return false; 855 856 for (freq = chandef->center_freq2 - width / 2 + 10; 857 freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) { 858 if (chan->center_freq == freq) 859 return true; 860 } 861 862 return false; 863 } 864 865 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev) 866 { 867 unsigned int link; 868 869 lockdep_assert_wiphy(wdev->wiphy); 870 871 switch (wdev->iftype) { 872 case NL80211_IFTYPE_AP: 873 case NL80211_IFTYPE_P2P_GO: 874 for_each_valid_link(wdev, link) { 875 if (wdev->links[link].ap.beacon_interval) 876 return true; 877 } 878 break; 879 case NL80211_IFTYPE_ADHOC: 880 if (wdev->u.ibss.ssid_len) 881 return true; 882 break; 883 case NL80211_IFTYPE_MESH_POINT: 884 if (wdev->u.mesh.id_len) 885 return true; 886 break; 887 case NL80211_IFTYPE_STATION: 888 case NL80211_IFTYPE_OCB: 889 case NL80211_IFTYPE_P2P_CLIENT: 890 case NL80211_IFTYPE_MONITOR: 891 case NL80211_IFTYPE_AP_VLAN: 892 case NL80211_IFTYPE_P2P_DEVICE: 893 /* Can NAN type be considered as beaconing interface? */ 894 case NL80211_IFTYPE_NAN: 895 break; 896 case NL80211_IFTYPE_UNSPECIFIED: 897 case NL80211_IFTYPE_WDS: 898 case NUM_NL80211_IFTYPES: 899 WARN_ON(1); 900 } 901 902 return false; 903 } 904 905 bool cfg80211_wdev_on_sub_chan(struct wireless_dev *wdev, 906 struct ieee80211_channel *chan, 907 bool primary_only) 908 { 909 unsigned int link; 910 911 switch (wdev->iftype) { 912 case NL80211_IFTYPE_AP: 913 case NL80211_IFTYPE_P2P_GO: 914 for_each_valid_link(wdev, link) { 915 if (cfg80211_is_sub_chan(&wdev->links[link].ap.chandef, 916 chan, primary_only)) 917 return true; 918 } 919 break; 920 case NL80211_IFTYPE_ADHOC: 921 return cfg80211_is_sub_chan(&wdev->u.ibss.chandef, chan, 922 primary_only); 923 case NL80211_IFTYPE_MESH_POINT: 924 return cfg80211_is_sub_chan(&wdev->u.mesh.chandef, chan, 925 primary_only); 926 default: 927 break; 928 } 929 930 return false; 931 } 932 933 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy, 934 struct ieee80211_channel *chan) 935 { 936 struct wireless_dev *wdev; 937 938 lockdep_assert_wiphy(wiphy); 939 940 list_for_each_entry(wdev, &wiphy->wdev_list, list) { 941 if (!cfg80211_beaconing_iface_active(wdev)) 942 continue; 943 944 if (cfg80211_wdev_on_sub_chan(wdev, chan, false)) 945 return true; 946 } 947 948 return false; 949 } 950 951 static bool 952 cfg80211_offchan_chain_is_active(struct cfg80211_registered_device *rdev, 953 struct ieee80211_channel *channel) 954 { 955 if (!rdev->background_radar_wdev) 956 return false; 957 958 if (!cfg80211_chandef_valid(&rdev->background_radar_chandef)) 959 return false; 960 961 return cfg80211_is_sub_chan(&rdev->background_radar_chandef, channel, 962 false); 963 } 964 965 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy, 966 struct ieee80211_channel *chan) 967 { 968 struct cfg80211_registered_device *rdev; 969 970 ASSERT_RTNL(); 971 972 if (!(chan->flags & IEEE80211_CHAN_RADAR)) 973 return false; 974 975 for_each_rdev(rdev) { 976 bool found; 977 978 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy)) 979 continue; 980 981 guard(wiphy)(&rdev->wiphy); 982 983 found = cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan) || 984 cfg80211_offchan_chain_is_active(rdev, chan); 985 986 if (found) 987 return true; 988 } 989 990 return false; 991 } 992 993 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy, 994 const struct cfg80211_chan_def *chandef) 995 { 996 struct ieee80211_channel *c; 997 int width; 998 bool dfs_offload; 999 1000 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 1001 return false; 1002 1003 width = cfg80211_chandef_get_width(chandef); 1004 if (width < 0) 1005 return false; 1006 1007 dfs_offload = wiphy_ext_feature_isset(wiphy, 1008 NL80211_EXT_FEATURE_DFS_OFFLOAD); 1009 1010 /* 1011 * Check entire range of channels for the bandwidth. 1012 * If any channel in between is disabled or has not 1013 * had gone through CAC return false 1014 */ 1015 for_each_subchan(chandef, freq, cf) { 1016 c = ieee80211_get_channel_khz(wiphy, freq); 1017 if (!c) 1018 return false; 1019 1020 if (c->flags & IEEE80211_CHAN_DISABLED) 1021 return false; 1022 1023 if ((c->flags & IEEE80211_CHAN_RADAR) && 1024 (c->dfs_state != NL80211_DFS_AVAILABLE) && 1025 !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload)) 1026 return false; 1027 } 1028 1029 return true; 1030 } 1031 1032 unsigned int 1033 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy, 1034 const struct cfg80211_chan_def *chandef) 1035 { 1036 struct ieee80211_channel *c; 1037 int width; 1038 unsigned int t1 = 0, t2 = 0; 1039 1040 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 1041 return 0; 1042 1043 width = cfg80211_chandef_get_width(chandef); 1044 if (width < 0) 1045 return 0; 1046 1047 for_each_subchan(chandef, freq, cf) { 1048 c = ieee80211_get_channel_khz(wiphy, freq); 1049 if (!c || (c->flags & IEEE80211_CHAN_DISABLED)) { 1050 if (cf == 1) 1051 t1 = INT_MAX; 1052 else 1053 t2 = INT_MAX; 1054 continue; 1055 } 1056 1057 if (!(c->flags & IEEE80211_CHAN_RADAR)) 1058 continue; 1059 1060 if (cf == 1 && c->dfs_cac_ms > t1) 1061 t1 = c->dfs_cac_ms; 1062 1063 if (cf == 2 && c->dfs_cac_ms > t2) 1064 t2 = c->dfs_cac_ms; 1065 } 1066 1067 if (t1 == INT_MAX && t2 == INT_MAX) 1068 return 0; 1069 1070 if (t1 == INT_MAX) 1071 return t2; 1072 1073 if (t2 == INT_MAX) 1074 return t1; 1075 1076 return max(t1, t2); 1077 } 1078 EXPORT_SYMBOL(cfg80211_chandef_dfs_cac_time); 1079 1080 /* check if the operating channels are valid and supported */ 1081 static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels, 1082 enum ieee80211_edmg_bw_config edmg_bw_config, 1083 int primary_channel, 1084 struct ieee80211_edmg *edmg_cap) 1085 { 1086 struct ieee80211_channel *chan; 1087 int i, freq; 1088 int channels_counter = 0; 1089 1090 if (!edmg_channels && !edmg_bw_config) 1091 return true; 1092 1093 if ((!edmg_channels && edmg_bw_config) || 1094 (edmg_channels && !edmg_bw_config)) 1095 return false; 1096 1097 if (!(edmg_channels & BIT(primary_channel - 1))) 1098 return false; 1099 1100 /* 60GHz channels 1..6 */ 1101 for (i = 0; i < 6; i++) { 1102 if (!(edmg_channels & BIT(i))) 1103 continue; 1104 1105 if (!(edmg_cap->channels & BIT(i))) 1106 return false; 1107 1108 channels_counter++; 1109 1110 freq = ieee80211_channel_to_frequency(i + 1, 1111 NL80211_BAND_60GHZ); 1112 chan = ieee80211_get_channel(wiphy, freq); 1113 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) 1114 return false; 1115 } 1116 1117 /* IEEE802.11 allows max 4 channels */ 1118 if (channels_counter > 4) 1119 return false; 1120 1121 /* check bw_config is a subset of what driver supports 1122 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13) 1123 */ 1124 if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4)) 1125 return false; 1126 1127 if (edmg_bw_config > edmg_cap->bw_config) 1128 return false; 1129 1130 return true; 1131 } 1132 1133 bool _cfg80211_chandef_usable(struct wiphy *wiphy, 1134 const struct cfg80211_chan_def *chandef, 1135 u32 prohibited_flags, 1136 u32 permitting_flags) 1137 { 1138 struct ieee80211_sta_ht_cap *ht_cap; 1139 struct ieee80211_sta_vht_cap *vht_cap; 1140 struct ieee80211_edmg *edmg_cap; 1141 u32 width, control_freq, cap; 1142 bool ext_nss_cap, support_80_80 = false, support_320 = false; 1143 const struct ieee80211_sband_iftype_data *iftd; 1144 struct ieee80211_supported_band *sband; 1145 struct ieee80211_channel *c; 1146 int i; 1147 1148 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 1149 return false; 1150 1151 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 1152 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 1153 edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap; 1154 ext_nss_cap = __le16_to_cpu(vht_cap->vht_mcs.tx_highest) & 1155 IEEE80211_VHT_EXT_NSS_BW_CAPABLE; 1156 1157 if (edmg_cap->channels && 1158 !cfg80211_edmg_usable(wiphy, 1159 chandef->edmg.channels, 1160 chandef->edmg.bw_config, 1161 chandef->chan->hw_value, 1162 edmg_cap)) 1163 return false; 1164 1165 control_freq = chandef->chan->center_freq; 1166 1167 switch (chandef->width) { 1168 case NL80211_CHAN_WIDTH_1: 1169 width = 1; 1170 break; 1171 case NL80211_CHAN_WIDTH_2: 1172 width = 2; 1173 break; 1174 case NL80211_CHAN_WIDTH_4: 1175 width = 4; 1176 break; 1177 case NL80211_CHAN_WIDTH_8: 1178 width = 8; 1179 break; 1180 case NL80211_CHAN_WIDTH_16: 1181 width = 16; 1182 break; 1183 case NL80211_CHAN_WIDTH_5: 1184 width = 5; 1185 break; 1186 case NL80211_CHAN_WIDTH_10: 1187 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ; 1188 width = 10; 1189 break; 1190 case NL80211_CHAN_WIDTH_20: 1191 if (!ht_cap->ht_supported && 1192 chandef->chan->band != NL80211_BAND_6GHZ) 1193 return false; 1194 fallthrough; 1195 case NL80211_CHAN_WIDTH_20_NOHT: 1196 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ; 1197 width = 20; 1198 break; 1199 case NL80211_CHAN_WIDTH_40: 1200 width = 40; 1201 if (chandef->chan->band == NL80211_BAND_6GHZ) 1202 break; 1203 if (!ht_cap->ht_supported) 1204 return false; 1205 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 1206 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 1207 return false; 1208 if (chandef->center_freq1 < control_freq && 1209 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 1210 return false; 1211 if (chandef->center_freq1 > control_freq && 1212 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 1213 return false; 1214 break; 1215 case NL80211_CHAN_WIDTH_80P80: 1216 cap = vht_cap->cap; 1217 support_80_80 = 1218 (cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) || 1219 (cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ && 1220 cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) || 1221 (ext_nss_cap && 1222 u32_get_bits(cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1); 1223 if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80) 1224 return false; 1225 fallthrough; 1226 case NL80211_CHAN_WIDTH_80: 1227 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 1228 width = 80; 1229 if (chandef->chan->band == NL80211_BAND_6GHZ) 1230 break; 1231 if (!vht_cap->vht_supported) 1232 return false; 1233 break; 1234 case NL80211_CHAN_WIDTH_160: 1235 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 1236 width = 160; 1237 if (chandef->chan->band == NL80211_BAND_6GHZ) 1238 break; 1239 if (!vht_cap->vht_supported) 1240 return false; 1241 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK; 1242 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ && 1243 cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ && 1244 !(ext_nss_cap && 1245 (vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK))) 1246 return false; 1247 break; 1248 case NL80211_CHAN_WIDTH_320: 1249 prohibited_flags |= IEEE80211_CHAN_NO_320MHZ; 1250 width = 320; 1251 1252 if (chandef->chan->band != NL80211_BAND_6GHZ) 1253 return false; 1254 1255 sband = wiphy->bands[NL80211_BAND_6GHZ]; 1256 if (!sband) 1257 return false; 1258 1259 for_each_sband_iftype_data(sband, i, iftd) { 1260 if (!iftd->eht_cap.has_eht) 1261 continue; 1262 1263 if (iftd->eht_cap.eht_cap_elem.phy_cap_info[0] & 1264 IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) { 1265 support_320 = true; 1266 break; 1267 } 1268 } 1269 1270 if (!support_320) 1271 return false; 1272 break; 1273 default: 1274 WARN_ON_ONCE(1); 1275 return false; 1276 } 1277 1278 /* 1279 * TODO: What if there are only certain 80/160/80+80 MHz channels 1280 * allowed by the driver, or only certain combinations? 1281 * For 40 MHz the driver can set the NO_HT40 flags, but for 1282 * 80/160 MHz and in particular 80+80 MHz this isn't really 1283 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 1284 * no way to cover 80+80 MHz or more complex restrictions. 1285 * Note that such restrictions also need to be advertised to 1286 * userspace, for example for P2P channel selection. 1287 */ 1288 1289 if (width > 20) 1290 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 1291 1292 /* 5 and 10 MHz are only defined for the OFDM PHY */ 1293 if (width < 20) 1294 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 1295 1296 for_each_subchan(chandef, freq, cf) { 1297 c = ieee80211_get_channel_khz(wiphy, freq); 1298 if (!c) 1299 return false; 1300 if (c->flags & permitting_flags) 1301 continue; 1302 if (c->flags & prohibited_flags) 1303 return false; 1304 } 1305 1306 return true; 1307 } 1308 1309 bool cfg80211_chandef_usable(struct wiphy *wiphy, 1310 const struct cfg80211_chan_def *chandef, 1311 u32 prohibited_flags) 1312 { 1313 return _cfg80211_chandef_usable(wiphy, chandef, prohibited_flags, 0); 1314 } 1315 EXPORT_SYMBOL(cfg80211_chandef_usable); 1316 1317 static bool cfg80211_ir_permissive_check_wdev(enum nl80211_iftype iftype, 1318 struct wireless_dev *wdev, 1319 struct ieee80211_channel *chan) 1320 { 1321 struct ieee80211_channel *other_chan = NULL; 1322 unsigned int link_id; 1323 int r1, r2; 1324 1325 for_each_valid_link(wdev, link_id) { 1326 if (wdev->iftype == NL80211_IFTYPE_STATION && 1327 wdev->links[link_id].client.current_bss) 1328 other_chan = wdev->links[link_id].client.current_bss->pub.channel; 1329 1330 /* 1331 * If a GO already operates on the same GO_CONCURRENT channel, 1332 * this one (maybe the same one) can beacon as well. We allow 1333 * the operation even if the station we relied on with 1334 * GO_CONCURRENT is disconnected now. But then we must make sure 1335 * we're not outdoor on an indoor-only channel. 1336 */ 1337 if (iftype == NL80211_IFTYPE_P2P_GO && 1338 wdev->iftype == NL80211_IFTYPE_P2P_GO && 1339 wdev->links[link_id].ap.beacon_interval && 1340 !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY)) 1341 other_chan = wdev->links[link_id].ap.chandef.chan; 1342 1343 if (!other_chan) 1344 continue; 1345 1346 if (chan == other_chan) 1347 return true; 1348 1349 if (chan->band != NL80211_BAND_5GHZ && 1350 chan->band != NL80211_BAND_6GHZ) 1351 continue; 1352 1353 r1 = cfg80211_get_unii(chan->center_freq); 1354 r2 = cfg80211_get_unii(other_chan->center_freq); 1355 1356 if (r1 != -EINVAL && r1 == r2) { 1357 /* 1358 * At some locations channels 149-165 are considered a 1359 * bundle, but at other locations, e.g., Indonesia, 1360 * channels 149-161 are considered a bundle while 1361 * channel 165 is left out and considered to be in a 1362 * different bundle. Thus, in case that there is a 1363 * station interface connected to an AP on channel 165, 1364 * it is assumed that channels 149-161 are allowed for 1365 * GO operations. However, having a station interface 1366 * connected to an AP on channels 149-161, does not 1367 * allow GO operation on channel 165. 1368 */ 1369 if (chan->center_freq == 5825 && 1370 other_chan->center_freq != 5825) 1371 continue; 1372 return true; 1373 } 1374 } 1375 1376 return false; 1377 } 1378 1379 /* 1380 * Check if the channel can be used under permissive conditions mandated by 1381 * some regulatory bodies, i.e., the channel is marked with 1382 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface 1383 * associated to an AP on the same channel or on the same UNII band 1384 * (assuming that the AP is an authorized master). 1385 * In addition allow operation on a channel on which indoor operation is 1386 * allowed, iff we are currently operating in an indoor environment. 1387 */ 1388 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy, 1389 enum nl80211_iftype iftype, 1390 struct ieee80211_channel *chan) 1391 { 1392 struct wireless_dev *wdev; 1393 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 1394 1395 lockdep_assert_held(&rdev->wiphy.mtx); 1396 1397 if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) || 1398 !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR)) 1399 return false; 1400 1401 /* only valid for GO and TDLS off-channel (station/p2p-CL) */ 1402 if (iftype != NL80211_IFTYPE_P2P_GO && 1403 iftype != NL80211_IFTYPE_STATION && 1404 iftype != NL80211_IFTYPE_P2P_CLIENT) 1405 return false; 1406 1407 if (regulatory_indoor_allowed() && 1408 (chan->flags & IEEE80211_CHAN_INDOOR_ONLY)) 1409 return true; 1410 1411 if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT)) 1412 return false; 1413 1414 /* 1415 * Generally, it is possible to rely on another device/driver to allow 1416 * the IR concurrent relaxation, however, since the device can further 1417 * enforce the relaxation (by doing a similar verifications as this), 1418 * and thus fail the GO instantiation, consider only the interfaces of 1419 * the current registered device. 1420 */ 1421 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 1422 bool ret; 1423 1424 ret = cfg80211_ir_permissive_check_wdev(iftype, wdev, chan); 1425 if (ret) 1426 return ret; 1427 } 1428 1429 return false; 1430 } 1431 1432 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy, 1433 struct cfg80211_chan_def *chandef, 1434 enum nl80211_iftype iftype, 1435 u32 prohibited_flags, 1436 u32 permitting_flags) 1437 { 1438 bool res, check_radar; 1439 int dfs_required; 1440 1441 trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, 1442 prohibited_flags, 1443 permitting_flags); 1444 1445 if (!_cfg80211_chandef_usable(wiphy, chandef, 1446 IEEE80211_CHAN_DISABLED, 0)) 1447 return false; 1448 1449 dfs_required = cfg80211_chandef_dfs_required(wiphy, chandef, iftype); 1450 check_radar = dfs_required != 0; 1451 1452 if (dfs_required > 0 && 1453 cfg80211_chandef_dfs_available(wiphy, chandef)) { 1454 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */ 1455 prohibited_flags &= ~IEEE80211_CHAN_NO_IR; 1456 check_radar = false; 1457 } 1458 1459 if (check_radar && 1460 !_cfg80211_chandef_usable(wiphy, chandef, 1461 IEEE80211_CHAN_RADAR, 0)) 1462 return false; 1463 1464 res = _cfg80211_chandef_usable(wiphy, chandef, 1465 prohibited_flags, 1466 permitting_flags); 1467 1468 trace_cfg80211_return_bool(res); 1469 return res; 1470 } 1471 1472 bool cfg80211_reg_check_beaconing(struct wiphy *wiphy, 1473 struct cfg80211_chan_def *chandef, 1474 struct cfg80211_beaconing_check_config *cfg) 1475 { 1476 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 1477 u32 permitting_flags = 0; 1478 bool check_no_ir = true; 1479 1480 /* 1481 * Under certain conditions suggested by some regulatory bodies a 1482 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag 1483 * only if such relaxations are not enabled and the conditions are not 1484 * met. 1485 */ 1486 if (cfg->relax) { 1487 lockdep_assert_held(&rdev->wiphy.mtx); 1488 check_no_ir = !cfg80211_ir_permissive_chan(wiphy, cfg->iftype, 1489 chandef->chan); 1490 } 1491 1492 if (cfg->reg_power == IEEE80211_REG_VLP_AP) 1493 permitting_flags |= IEEE80211_CHAN_ALLOW_6GHZ_VLP_AP; 1494 1495 if ((cfg->iftype == NL80211_IFTYPE_P2P_GO || 1496 cfg->iftype == NL80211_IFTYPE_AP) && 1497 (chandef->width == NL80211_CHAN_WIDTH_20_NOHT || 1498 chandef->width == NL80211_CHAN_WIDTH_20)) 1499 permitting_flags |= IEEE80211_CHAN_ALLOW_20MHZ_ACTIVITY; 1500 1501 return _cfg80211_reg_can_beacon(wiphy, chandef, cfg->iftype, 1502 check_no_ir ? IEEE80211_CHAN_NO_IR : 0, 1503 permitting_flags); 1504 } 1505 EXPORT_SYMBOL(cfg80211_reg_check_beaconing); 1506 1507 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 1508 struct net_device *dev, 1509 struct cfg80211_chan_def *chandef) 1510 { 1511 if (!rdev->ops->set_monitor_channel) 1512 return -EOPNOTSUPP; 1513 if (!cfg80211_has_monitors_only(rdev)) 1514 return -EBUSY; 1515 1516 return rdev_set_monitor_channel(rdev, dev, chandef); 1517 } 1518 1519 bool cfg80211_any_usable_channels(struct wiphy *wiphy, 1520 unsigned long sband_mask, 1521 u32 prohibited_flags) 1522 { 1523 int idx; 1524 1525 prohibited_flags |= IEEE80211_CHAN_DISABLED; 1526 1527 for_each_set_bit(idx, &sband_mask, NUM_NL80211_BANDS) { 1528 struct ieee80211_supported_band *sband = wiphy->bands[idx]; 1529 int chanidx; 1530 1531 if (!sband) 1532 continue; 1533 1534 for (chanidx = 0; chanidx < sband->n_channels; chanidx++) { 1535 struct ieee80211_channel *chan; 1536 1537 chan = &sband->channels[chanidx]; 1538 1539 if (chan->flags & prohibited_flags) 1540 continue; 1541 1542 return true; 1543 } 1544 } 1545 1546 return false; 1547 } 1548 EXPORT_SYMBOL(cfg80211_any_usable_channels); 1549 1550 struct cfg80211_chan_def *wdev_chandef(struct wireless_dev *wdev, 1551 unsigned int link_id) 1552 { 1553 lockdep_assert_wiphy(wdev->wiphy); 1554 1555 WARN_ON(wdev->valid_links && !(wdev->valid_links & BIT(link_id))); 1556 WARN_ON(!wdev->valid_links && link_id > 0); 1557 1558 switch (wdev->iftype) { 1559 case NL80211_IFTYPE_MESH_POINT: 1560 return &wdev->u.mesh.chandef; 1561 case NL80211_IFTYPE_ADHOC: 1562 return &wdev->u.ibss.chandef; 1563 case NL80211_IFTYPE_OCB: 1564 return &wdev->u.ocb.chandef; 1565 case NL80211_IFTYPE_AP: 1566 case NL80211_IFTYPE_P2P_GO: 1567 return &wdev->links[link_id].ap.chandef; 1568 default: 1569 return NULL; 1570 } 1571 } 1572 EXPORT_SYMBOL(wdev_chandef); 1573