net/wireless/chan.c

   1 /*
   2  * This file contains helper code to handle channel
   3  * settings and keeping track of what is possible at
   4  * any point in time.
   5  *
   6  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
   7  */
   8
   9 #include <linux/export.h>
  10 #include <net/cfg80211.h>
  11 #include "core.h"
  12 #include "rdev-ops.h"
  13
  14 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  15                              struct ieee80211_channel *chan,
  16                              enum nl80211_channel_type chan_type)
  17 {
  18         if (WARN_ON(!chan))
  19                 return;
  20
  21         chandef->chan = chan;
  22         chandef->center_freq2 = 0;
  23
  24         switch (chan_type) {
  25         case NL80211_CHAN_NO_HT:
  26                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  27                 chandef->center_freq1 = chan->center_freq;
  28                 break;
  29         case NL80211_CHAN_HT20:
  30                 chandef->width = NL80211_CHAN_WIDTH_20;
  31                 chandef->center_freq1 = chan->center_freq;
  32                 break;
  33         case NL80211_CHAN_HT40PLUS:
  34                 chandef->width = NL80211_CHAN_WIDTH_40;
  35                 chandef->center_freq1 = chan->center_freq + 10;
  36                 break;
  37         case NL80211_CHAN_HT40MINUS:
  38                 chandef->width = NL80211_CHAN_WIDTH_40;
  39                 chandef->center_freq1 = chan->center_freq - 10;
  40                 break;
  41         default:
  42                 WARN_ON(1);
  43         }
  44 }
  45 EXPORT_SYMBOL(cfg80211_chandef_create);
  46
  47 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
  48 {
  49         u32 control_freq;
  50
  51         if (!chandef->chan)
  52                 return false;
  53
  54         control_freq = chandef->chan->center_freq;
  55
  56         switch (chandef->width) {
  57         case NL80211_CHAN_WIDTH_5:
  58         case NL80211_CHAN_WIDTH_10:
  59         case NL80211_CHAN_WIDTH_20:
  60         case NL80211_CHAN_WIDTH_20_NOHT:
  61                 if (chandef->center_freq1 != control_freq)
  62                         return false;
  63                 if (chandef->center_freq2)
  64                         return false;
  65                 break;
  66         case NL80211_CHAN_WIDTH_40:
  67                 if (chandef->center_freq1 != control_freq + 10 &&
  68                     chandef->center_freq1 != control_freq - 10)
  69                         return false;
  70                 if (chandef->center_freq2)
  71                         return false;
  72                 break;
  73         case NL80211_CHAN_WIDTH_80P80:
  74                 if (chandef->center_freq1 != control_freq + 30 &&
  75                     chandef->center_freq1 != control_freq + 10 &&
  76                     chandef->center_freq1 != control_freq - 10 &&
  77                     chandef->center_freq1 != control_freq - 30)
  78                         return false;
  79                 if (!chandef->center_freq2)
  80                         return false;
  81                 /* adjacent is not allowed -- that's a 160 MHz channel */
  82                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
  83                     chandef->center_freq2 - chandef->center_freq1 == 80)
  84                         return false;
  85                 break;
  86         case NL80211_CHAN_WIDTH_80:
  87                 if (chandef->center_freq1 != control_freq + 30 &&
  88                     chandef->center_freq1 != control_freq + 10 &&
  89                     chandef->center_freq1 != control_freq - 10 &&
  90                     chandef->center_freq1 != control_freq - 30)
  91                         return false;
  92                 if (chandef->center_freq2)
  93                         return false;
  94                 break;
  95         case NL80211_CHAN_WIDTH_160:
  96                 if (chandef->center_freq1 != control_freq + 70 &&
  97                     chandef->center_freq1 != control_freq + 50 &&
  98                     chandef->center_freq1 != control_freq + 30 &&
  99                     chandef->center_freq1 != control_freq + 10 &&
 100                     chandef->center_freq1 != control_freq - 10 &&
 101                     chandef->center_freq1 != control_freq - 30 &&
 102                     chandef->center_freq1 != control_freq - 50 &&
 103                     chandef->center_freq1 != control_freq - 70)
 104                         return false;
 105                 if (chandef->center_freq2)
 106                         return false;
 107                 break;
 108         default:
 109                 return false;
 110         }
 111
 112         return true;
 113 }
 114 EXPORT_SYMBOL(cfg80211_chandef_valid);
 115
 116 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 117                                   int *pri40, int *pri80)
 118 {
 119         int tmp;
 120
 121         switch (c->width) {
 122         case NL80211_CHAN_WIDTH_40:
 123                 *pri40 = c->center_freq1;
 124                 *pri80 = 0;
 125                 break;
 126         case NL80211_CHAN_WIDTH_80:
 127         case NL80211_CHAN_WIDTH_80P80:
 128                 *pri80 = c->center_freq1;
 129                 /* n_P20 */
 130                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 131                 /* n_P40 */
 132                 tmp /= 2;
 133                 /* freq_P40 */
 134                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
 135                 break;
 136         case NL80211_CHAN_WIDTH_160:
 137                 /* n_P20 */
 138                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 139                 /* n_P40 */
 140                 tmp /= 2;
 141                 /* freq_P40 */
 142                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
 143                 /* n_P80 */
 144                 tmp /= 2;
 145                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
 146                 break;
 147         default:
 148                 WARN_ON_ONCE(1);
 149         }
 150 }
 151
 152 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 153 {
 154         int width;
 155
 156         switch (c->width) {
 157         case NL80211_CHAN_WIDTH_5:
 158                 width = 5;
 159                 break;
 160         case NL80211_CHAN_WIDTH_10:
 161                 width = 10;
 162                 break;
 163         case NL80211_CHAN_WIDTH_20:
 164         case NL80211_CHAN_WIDTH_20_NOHT:
 165                 width = 20;
 166                 break;
 167         case NL80211_CHAN_WIDTH_40:
 168                 width = 40;
 169                 break;
 170         case NL80211_CHAN_WIDTH_80P80:
 171         case NL80211_CHAN_WIDTH_80:
 172                 width = 80;
 173                 break;
 174         case NL80211_CHAN_WIDTH_160:
 175                 width = 160;
 176                 break;
 177         default:
 178                 WARN_ON_ONCE(1);
 179                 return -1;
 180         }
 181         return width;
 182 }
 183
 184 const struct cfg80211_chan_def *
 185 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 186                             const struct cfg80211_chan_def *c2)
 187 {
 188         u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 189
 190         /* If they are identical, return */
 191         if (cfg80211_chandef_identical(c1, c2))
 192                 return c1;
 193
 194         /* otherwise, must have same control channel */
 195         if (c1->chan != c2->chan)
 196                 return NULL;
 197
 198         /*
 199          * If they have the same width, but aren't identical,
 200          * then they can't be compatible.
 201          */
 202         if (c1->width == c2->width)
 203                 return NULL;
 204
 205         /*
 206          * can't be compatible if one of them is 5 or 10 MHz,
 207          * but they don't have the same width.
 208          */
 209         if (c1->width == NL80211_CHAN_WIDTH_5 ||
 210             c1->width == NL80211_CHAN_WIDTH_10 ||
 211             c2->width == NL80211_CHAN_WIDTH_5 ||
 212             c2->width == NL80211_CHAN_WIDTH_10)
 213                 return NULL;
 214
 215         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 216             c1->width == NL80211_CHAN_WIDTH_20)
 217                 return c2;
 218
 219         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 220             c2->width == NL80211_CHAN_WIDTH_20)
 221                 return c1;
 222
 223         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 224         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 225
 226         if (c1_pri40 != c2_pri40)
 227                 return NULL;
 228
 229         WARN_ON(!c1_pri80 && !c2_pri80);
 230         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 231                 return NULL;
 232
 233         if (c1->width > c2->width)
 234                 return c1;
 235         return c2;
 236 }
 237 EXPORT_SYMBOL(cfg80211_chandef_compatible);
 238
 239 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 240                                          u32 bandwidth,
 241                                          enum nl80211_dfs_state dfs_state)
 242 {
 243         struct ieee80211_channel *c;
 244         u32 freq;
 245
 246         for (freq = center_freq - bandwidth/2 + 10;
 247              freq <= center_freq + bandwidth/2 - 10;
 248              freq += 20) {
 249                 c = ieee80211_get_channel(wiphy, freq);
 250                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 251                         continue;
 252
 253                 c->dfs_state = dfs_state;
 254                 c->dfs_state_entered = jiffies;
 255         }
 256 }
 257
 258 void cfg80211_set_dfs_state(struct wiphy *wiphy,
 259                             const struct cfg80211_chan_def *chandef,
 260                             enum nl80211_dfs_state dfs_state)
 261 {
 262         int width;
 263
 264         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 265                 return;
 266
 267         width = cfg80211_chandef_get_width(chandef);
 268         if (width < 0)
 269                 return;
 270
 271         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 272                                      width, dfs_state);
 273
 274         if (!chandef->center_freq2)
 275                 return;
 276         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 277                                      width, dfs_state);
 278 }
 279
 280 static u32 cfg80211_get_start_freq(u32 center_freq,
 281                                    u32 bandwidth)
 282 {
 283         u32 start_freq;
 284
 285         if (bandwidth <= 20)
 286                 start_freq = center_freq;
 287         else
 288                 start_freq = center_freq - bandwidth/2 + 10;
 289
 290         return start_freq;
 291 }
 292
 293 static u32 cfg80211_get_end_freq(u32 center_freq,
 294                                  u32 bandwidth)
 295 {
 296         u32 end_freq;
 297
 298         if (bandwidth <= 20)
 299                 end_freq = center_freq;
 300         else
 301                 end_freq = center_freq + bandwidth/2 - 10;
 302
 303         return end_freq;
 304 }
 305
 306 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 307                                             u32 center_freq,
 308                                             u32 bandwidth)
 309 {
 310         struct ieee80211_channel *c;
 311         u32 freq, start_freq, end_freq;
 312
 313         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 314         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 315
 316         for (freq = start_freq; freq <= end_freq; freq += 20) {
 317                 c = ieee80211_get_channel(wiphy, freq);
 318                 if (!c)
 319                         return -EINVAL;
 320
 321                 if (c->flags & IEEE80211_CHAN_RADAR)
 322                         return 1;
 323         }
 324         return 0;
 325 }
 326
 327
 328 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 329                                   const struct cfg80211_chan_def *chandef)
 330 {
 331         int width;
 332         int r;
 333
 334         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 335                 return -EINVAL;
 336
 337         width = cfg80211_chandef_get_width(chandef);
 338         if (width < 0)
 339                 return -EINVAL;
 340
 341         r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1,
 342                                             width);
 343         if (r)
 344                 return r;
 345
 346         if (!chandef->center_freq2)
 347                 return 0;
 348
 349         return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2,
 350                                                width);
 351 }
 352 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 353
 354 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 355                                          u32 center_freq,
 356                                          u32 bandwidth)
 357 {
 358         struct ieee80211_channel *c;
 359         u32 freq, start_freq, end_freq;
 360         int count = 0;
 361
 362         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 363         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 364
 365         /*
 366          * Check entire range of channels for the bandwidth.
 367          * Check all channels are DFS channels (DFS_USABLE or
 368          * DFS_AVAILABLE). Return number of usable channels
 369          * (require CAC). Allow DFS and non-DFS channel mix.
 370          */
 371         for (freq = start_freq; freq <= end_freq; freq += 20) {
 372                 c = ieee80211_get_channel(wiphy, freq);
 373                 if (!c)
 374                         return -EINVAL;
 375
 376                 if (c->flags & IEEE80211_CHAN_DISABLED)
 377                         return -EINVAL;
 378
 379                 if (c->flags & IEEE80211_CHAN_RADAR) {
 380                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 381                                 return -EINVAL;
 382
 383                         if (c->dfs_state == NL80211_DFS_USABLE)
 384                                 count++;
 385                 }
 386         }
 387
 388         return count;
 389 }
 390
 391 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 392                                  const struct cfg80211_chan_def *chandef)
 393 {
 394         int width;
 395         int r1, r2 = 0;
 396
 397         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 398                 return false;
 399
 400         width = cfg80211_chandef_get_width(chandef);
 401         if (width < 0)
 402                 return false;
 403
 404         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 405                                           width);
 406
 407         if (r1 < 0)
 408                 return false;
 409
 410         switch (chandef->width) {
 411         case NL80211_CHAN_WIDTH_80P80:
 412                 WARN_ON(!chandef->center_freq2);
 413                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
 414                                                    chandef->center_freq2,
 415                                                    width);
 416                 if (r2 < 0)
 417                         return false;
 418                 break;
 419         default:
 420                 WARN_ON(chandef->center_freq2);
 421                 break;
 422         }
 423
 424         return (r1 + r2 > 0);
 425 }
 426
 427
 428 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 429                                              u32 center_freq,
 430                                              u32 bandwidth)
 431 {
 432         struct ieee80211_channel *c;
 433         u32 freq, start_freq, end_freq;
 434
 435         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 436         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 437
 438         /*
 439          * Check entire range of channels for the bandwidth.
 440          * If any channel in between is disabled or has not
 441          * had gone through CAC return false
 442          */
 443         for (freq = start_freq; freq <= end_freq; freq += 20) {
 444                 c = ieee80211_get_channel(wiphy, freq);
 445                 if (!c)
 446                         return false;
 447
 448                 if (c->flags & IEEE80211_CHAN_DISABLED)
 449                         return false;
 450
 451                 if ((c->flags & IEEE80211_CHAN_RADAR)  &&
 452                     (c->dfs_state != NL80211_DFS_AVAILABLE))
 453                         return false;
 454         }
 455
 456         return true;
 457 }
 458
 459 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 460                                 const struct cfg80211_chan_def *chandef)
 461 {
 462         int width;
 463         int r;
 464
 465         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 466                 return false;
 467
 468         width = cfg80211_chandef_get_width(chandef);
 469         if (width < 0)
 470                 return false;
 471
 472         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 473                                              width);
 474
 475         /* If any of channels unavailable for cf1 just return */
 476         if (!r)
 477                 return r;
 478
 479         switch (chandef->width) {
 480         case NL80211_CHAN_WIDTH_80P80:
 481                 WARN_ON(!chandef->center_freq2);
 482                 r = cfg80211_get_chans_dfs_available(wiphy,
 483                                                      chandef->center_freq2,
 484                                                      width);
 485         default:
 486                 WARN_ON(chandef->center_freq2);
 487                 break;
 488         }
 489
 490         return r;
 491 }
 492
 493 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
 494                                                     u32 center_freq,
 495                                                     u32 bandwidth)
 496 {
 497         struct ieee80211_channel *c;
 498         u32 start_freq, end_freq, freq;
 499         unsigned int dfs_cac_ms = 0;
 500
 501         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 502         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 503
 504         for (freq = start_freq; freq <= end_freq; freq += 20) {
 505                 c = ieee80211_get_channel(wiphy, freq);
 506                 if (!c)
 507                         return 0;
 508
 509                 if (c->flags & IEEE80211_CHAN_DISABLED)
 510                         return 0;
 511
 512                 if (!(c->flags & IEEE80211_CHAN_RADAR))
 513                         continue;
 514
 515                 if (c->dfs_cac_ms > dfs_cac_ms)
 516                         dfs_cac_ms = c->dfs_cac_ms;
 517         }
 518
 519         return dfs_cac_ms;
 520 }
 521
 522 unsigned int
 523 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
 524                               const struct cfg80211_chan_def *chandef)
 525 {
 526         int width;
 527         unsigned int t1 = 0, t2 = 0;
 528
 529         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 530                 return 0;
 531
 532         width = cfg80211_chandef_get_width(chandef);
 533         if (width < 0)
 534                 return 0;
 535
 536         t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
 537                                              chandef->center_freq1,
 538                                              width);
 539
 540         if (!chandef->center_freq2)
 541                 return t1;
 542
 543         t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
 544                                              chandef->center_freq2,
 545                                              width);
 546
 547         return max(t1, t2);
 548 }
 549
 550 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 551                                         u32 center_freq, u32 bandwidth,
 552                                         u32 prohibited_flags)
 553 {
 554         struct ieee80211_channel *c;
 555         u32 freq, start_freq, end_freq;
 556
 557         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 558         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 559
 560         for (freq = start_freq; freq <= end_freq; freq += 20) {
 561                 c = ieee80211_get_channel(wiphy, freq);
 562                 if (!c || c->flags & prohibited_flags)
 563                         return false;
 564         }
 565
 566         return true;
 567 }
 568
 569 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 570                              const struct cfg80211_chan_def *chandef,
 571                              u32 prohibited_flags)
 572 {
 573         struct ieee80211_sta_ht_cap *ht_cap;
 574         struct ieee80211_sta_vht_cap *vht_cap;
 575         u32 width, control_freq;
 576
 577         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 578                 return false;
 579
 580         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 581         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 582
 583         control_freq = chandef->chan->center_freq;
 584
 585         switch (chandef->width) {
 586         case NL80211_CHAN_WIDTH_5:
 587                 width = 5;
 588                 break;
 589         case NL80211_CHAN_WIDTH_10:
 590                 width = 10;
 591                 break;
 592         case NL80211_CHAN_WIDTH_20:
 593                 if (!ht_cap->ht_supported)
 594                         return false;
 595         case NL80211_CHAN_WIDTH_20_NOHT:
 596                 width = 20;
 597                 break;
 598         case NL80211_CHAN_WIDTH_40:
 599                 width = 40;
 600                 if (!ht_cap->ht_supported)
 601                         return false;
 602                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 603                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 604                         return false;
 605                 if (chandef->center_freq1 < control_freq &&
 606                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 607                         return false;
 608                 if (chandef->center_freq1 > control_freq &&
 609                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 610                         return false;
 611                 break;
 612         case NL80211_CHAN_WIDTH_80P80:
 613                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
 614                         return false;
 615         case NL80211_CHAN_WIDTH_80:
 616                 if (!vht_cap->vht_supported)
 617                         return false;
 618                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 619                 width = 80;
 620                 break;
 621         case NL80211_CHAN_WIDTH_160:
 622                 if (!vht_cap->vht_supported)
 623                         return false;
 624                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
 625                         return false;
 626                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 627                 width = 160;
 628                 break;
 629         default:
 630                 WARN_ON_ONCE(1);
 631                 return false;
 632         }
 633
 634         /*
 635          * TODO: What if there are only certain 80/160/80+80 MHz channels
 636          *       allowed by the driver, or only certain combinations?
 637          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 638          *       80/160 MHz and in particular 80+80 MHz this isn't really
 639          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 640          *       no way to cover 80+80 MHz or more complex restrictions.
 641          *       Note that such restrictions also need to be advertised to
 642          *       userspace, for example for P2P channel selection.
 643          */
 644
 645         if (width > 20)
 646                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 647
 648         /* 5 and 10 MHz are only defined for the OFDM PHY */
 649         if (width < 20)
 650                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 651
 652
 653         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 654                                          width, prohibited_flags))
 655                 return false;
 656
 657         if (!chandef->center_freq2)
 658                 return true;
 659         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 660                                            width, prohibited_flags);
 661 }
 662 EXPORT_SYMBOL(cfg80211_chandef_usable);
 663
 664 /*
 665  * For GO only, check if the channel can be used under permissive conditions
 666  * mandated by the some regulatory bodies, i.e., the channel is marked with
 667  * IEEE80211_CHAN_GO_CONCURRENT and there is an additional station interface
 668  * associated to an AP on the same channel or on the same UNII band
 669  * (assuming that the AP is an authorized master).
 670  */
 671 static bool cfg80211_go_permissive_chan(struct cfg80211_registered_device *rdev,
 672                                         struct ieee80211_channel *chan)
 673 {
 674         struct wireless_dev *wdev_iter;
 675         struct wiphy *wiphy = wiphy_idx_to_wiphy(rdev->wiphy_idx);
 676
 677         ASSERT_RTNL();
 678
 679         if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
 680             !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR) ||
 681             !(chan->flags & IEEE80211_CHAN_GO_CONCURRENT))
 682                 return false;
 683
 684         /*
 685          * Generally, it is possible to rely on another device/driver to allow
 686          * the GO concurrent relaxation, however, since the device can further
 687          * enforce the relaxation (by doing a similar verifications as this),
 688          * and thus fail the GO instantiation, consider only the interfaces of
 689          * the current registered device.
 690          */
 691         list_for_each_entry(wdev_iter, &rdev->wdev_list, list) {
 692                 struct ieee80211_channel *other_chan = NULL;
 693                 int r1, r2;
 694
 695                 if (wdev_iter->iftype != NL80211_IFTYPE_STATION ||
 696                     !netif_running(wdev_iter->netdev))
 697                         continue;
 698
 699                 wdev_lock(wdev_iter);
 700                 if (wdev_iter->current_bss)
 701                         other_chan = wdev_iter->current_bss->pub.channel;
 702                 wdev_unlock(wdev_iter);
 703
 704                 if (!other_chan)
 705                         continue;
 706
 707                 if (chan == other_chan)
 708                         return true;
 709
 710                 if (chan->band != IEEE80211_BAND_5GHZ)
 711                         continue;
 712
 713                 r1 = cfg80211_get_unii(chan->center_freq);
 714                 r2 = cfg80211_get_unii(other_chan->center_freq);
 715
 716                 if (r1 != -EINVAL && r1 == r2)
 717                         return true;
 718         }
 719
 720         return false;
 721 }
 722
 723 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
 724                              struct cfg80211_chan_def *chandef,
 725                              enum nl80211_iftype iftype)
 726 {
 727         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 728         bool res;
 729         u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
 730                                IEEE80211_CHAN_RADAR;
 731
 732         trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype);
 733
 734         /*
 735          * Under certain conditions suggested by the some regulatory bodies
 736          * a GO can operate on channels marked with IEEE80211_NO_IR
 737          * so set this flag only if such relaxations are not enabled and
 738          * the conditions are not met.
 739          */
 740         if (iftype != NL80211_IFTYPE_P2P_GO ||
 741             !cfg80211_go_permissive_chan(rdev, chandef->chan))
 742                 prohibited_flags |= IEEE80211_CHAN_NO_IR;
 743
 744         if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 &&
 745             cfg80211_chandef_dfs_available(wiphy, chandef)) {
 746                 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
 747                 prohibited_flags = IEEE80211_CHAN_DISABLED;
 748         }
 749
 750         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
 751
 752         trace_cfg80211_return_bool(res);
 753         return res;
 754 }
 755 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 756
 757 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 758                                  struct cfg80211_chan_def *chandef)
 759 {
 760         if (!rdev->ops->set_monitor_channel)
 761                 return -EOPNOTSUPP;
 762         if (!cfg80211_has_monitors_only(rdev))
 763                 return -EBUSY;
 764
 765         return rdev_set_monitor_channel(rdev, chandef);
 766 }
 767
 768 void
 769 cfg80211_get_chan_state(struct wireless_dev *wdev,
 770                         struct ieee80211_channel **chan,
 771                         enum cfg80211_chan_mode *chanmode,
 772                         u8 *radar_detect)
 773 {
 774         *chan = NULL;
 775         *chanmode = CHAN_MODE_UNDEFINED;
 776
 777         ASSERT_WDEV_LOCK(wdev);
 778
 779         if (wdev->netdev && !netif_running(wdev->netdev))
 780                 return;
 781
 782         switch (wdev->iftype) {
 783         case NL80211_IFTYPE_ADHOC:
 784                 if (wdev->current_bss) {
 785                         *chan = wdev->current_bss->pub.channel;
 786                         *chanmode = (wdev->ibss_fixed &&
 787                                      !wdev->ibss_dfs_possible)
 788                                   ? CHAN_MODE_SHARED
 789                                   : CHAN_MODE_EXCLUSIVE;
 790
 791                         /* consider worst-case - IBSS can try to return to the
 792                          * original user-specified channel as creator */
 793                         if (wdev->ibss_dfs_possible)
 794                                 *radar_detect |= BIT(wdev->chandef.width);
 795                         return;
 796                 }
 797                 break;
 798         case NL80211_IFTYPE_STATION:
 799         case NL80211_IFTYPE_P2P_CLIENT:
 800                 if (wdev->current_bss) {
 801                         *chan = wdev->current_bss->pub.channel;
 802                         *chanmode = CHAN_MODE_SHARED;
 803                         return;
 804                 }
 805                 break;
 806         case NL80211_IFTYPE_AP:
 807         case NL80211_IFTYPE_P2P_GO:
 808                 if (wdev->cac_started) {
 809                         *chan = wdev->chandef.chan;
 810                         *chanmode = CHAN_MODE_SHARED;
 811                         *radar_detect |= BIT(wdev->chandef.width);
 812                 } else if (wdev->beacon_interval) {
 813                         *chan = wdev->chandef.chan;
 814                         *chanmode = CHAN_MODE_SHARED;
 815
 816                         if (cfg80211_chandef_dfs_required(wdev->wiphy,
 817                                                           &wdev->chandef))
 818                                 *radar_detect |= BIT(wdev->chandef.width);
 819                 }
 820                 return;
 821         case NL80211_IFTYPE_MESH_POINT:
 822                 if (wdev->mesh_id_len) {
 823                         *chan = wdev->chandef.chan;
 824                         *chanmode = CHAN_MODE_SHARED;
 825
 826                         if (cfg80211_chandef_dfs_required(wdev->wiphy,
 827                                                           &wdev->chandef))
 828                                 *radar_detect |= BIT(wdev->chandef.width);
 829                 }
 830                 return;
 831         case NL80211_IFTYPE_MONITOR:
 832         case NL80211_IFTYPE_AP_VLAN:
 833         case NL80211_IFTYPE_WDS:
 834         case NL80211_IFTYPE_P2P_DEVICE:
 835                 /* these interface types don't really have a channel */
 836                 return;
 837         case NL80211_IFTYPE_UNSPECIFIED:
 838         case NUM_NL80211_IFTYPES:
 839                 WARN_ON(1);
 840         }
 841 }