net/wireless/chan.c

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