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