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                                   enum nl80211_iftype iftype)
 331 {
 332         int width;
 333         int ret;
 334
 335         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 336                 return -EINVAL;
 337
 338         switch (iftype) {
 339         case NL80211_IFTYPE_ADHOC:
 340         case NL80211_IFTYPE_AP:
 341         case NL80211_IFTYPE_P2P_GO:
 342         case NL80211_IFTYPE_MESH_POINT:
 343                 width = cfg80211_chandef_get_width(chandef);
 344                 if (width < 0)
 345                         return -EINVAL;
 346
 347                 ret = cfg80211_get_chans_dfs_required(wiphy,
 348                                                       chandef->center_freq1,
 349                                                       width);
 350                 if (ret < 0)
 351                         return ret;
 352                 else if (ret > 0)
 353                         return BIT(chandef->width);
 354
 355                 if (!chandef->center_freq2)
 356                         return 0;
 357
 358                 ret = cfg80211_get_chans_dfs_required(wiphy,
 359                                                       chandef->center_freq2,
 360                                                       width);
 361                 if (ret < 0)
 362                         return ret;
 363                 else if (ret > 0)
 364                         return BIT(chandef->width);
 365
 366                 break;
 367         case NL80211_IFTYPE_STATION:
 368         case NL80211_IFTYPE_P2P_CLIENT:
 369         case NL80211_IFTYPE_MONITOR:
 370         case NL80211_IFTYPE_AP_VLAN:
 371         case NL80211_IFTYPE_WDS:
 372         case NL80211_IFTYPE_P2P_DEVICE:
 373                 break;
 374         case NL80211_IFTYPE_UNSPECIFIED:
 375         case NUM_NL80211_IFTYPES:
 376                 WARN_ON(1);
 377         }
 378
 379         return 0;
 380 }
 381 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 382
 383 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 384                                          u32 center_freq,
 385                                          u32 bandwidth)
 386 {
 387         struct ieee80211_channel *c;
 388         u32 freq, start_freq, end_freq;
 389         int count = 0;
 390
 391         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 392         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 393
 394         /*
 395          * Check entire range of channels for the bandwidth.
 396          * Check all channels are DFS channels (DFS_USABLE or
 397          * DFS_AVAILABLE). Return number of usable channels
 398          * (require CAC). Allow DFS and non-DFS channel mix.
 399          */
 400         for (freq = start_freq; freq <= end_freq; freq += 20) {
 401                 c = ieee80211_get_channel(wiphy, freq);
 402                 if (!c)
 403                         return -EINVAL;
 404
 405                 if (c->flags & IEEE80211_CHAN_DISABLED)
 406                         return -EINVAL;
 407
 408                 if (c->flags & IEEE80211_CHAN_RADAR) {
 409                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 410                                 return -EINVAL;
 411
 412                         if (c->dfs_state == NL80211_DFS_USABLE)
 413                                 count++;
 414                 }
 415         }
 416
 417         return count;
 418 }
 419
 420 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 421                                  const struct cfg80211_chan_def *chandef)
 422 {
 423         int width;
 424         int r1, r2 = 0;
 425
 426         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 427                 return false;
 428
 429         width = cfg80211_chandef_get_width(chandef);
 430         if (width < 0)
 431                 return false;
 432
 433         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 434                                           width);
 435
 436         if (r1 < 0)
 437                 return false;
 438
 439         switch (chandef->width) {
 440         case NL80211_CHAN_WIDTH_80P80:
 441                 WARN_ON(!chandef->center_freq2);
 442                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
 443                                                    chandef->center_freq2,
 444                                                    width);
 445                 if (r2 < 0)
 446                         return false;
 447                 break;
 448         default:
 449                 WARN_ON(chandef->center_freq2);
 450                 break;
 451         }
 452
 453         return (r1 + r2 > 0);
 454 }
 455
 456
 457 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 458                                              u32 center_freq,
 459                                              u32 bandwidth)
 460 {
 461         struct ieee80211_channel *c;
 462         u32 freq, start_freq, end_freq;
 463
 464         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 465         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 466
 467         /*
 468          * Check entire range of channels for the bandwidth.
 469          * If any channel in between is disabled or has not
 470          * had gone through CAC return false
 471          */
 472         for (freq = start_freq; freq <= end_freq; freq += 20) {
 473                 c = ieee80211_get_channel(wiphy, freq);
 474                 if (!c)
 475                         return false;
 476
 477                 if (c->flags & IEEE80211_CHAN_DISABLED)
 478                         return false;
 479
 480                 if ((c->flags & IEEE80211_CHAN_RADAR)  &&
 481                     (c->dfs_state != NL80211_DFS_AVAILABLE))
 482                         return false;
 483         }
 484
 485         return true;
 486 }
 487
 488 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 489                                 const struct cfg80211_chan_def *chandef)
 490 {
 491         int width;
 492         int r;
 493
 494         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 495                 return false;
 496
 497         width = cfg80211_chandef_get_width(chandef);
 498         if (width < 0)
 499                 return false;
 500
 501         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 502                                              width);
 503
 504         /* If any of channels unavailable for cf1 just return */
 505         if (!r)
 506                 return r;
 507
 508         switch (chandef->width) {
 509         case NL80211_CHAN_WIDTH_80P80:
 510                 WARN_ON(!chandef->center_freq2);
 511                 r = cfg80211_get_chans_dfs_available(wiphy,
 512                                                      chandef->center_freq2,
 513                                                      width);
 514         default:
 515                 WARN_ON(chandef->center_freq2);
 516                 break;
 517         }
 518
 519         return r;
 520 }
 521
 522 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
 523                                                     u32 center_freq,
 524                                                     u32 bandwidth)
 525 {
 526         struct ieee80211_channel *c;
 527         u32 start_freq, end_freq, freq;
 528         unsigned int dfs_cac_ms = 0;
 529
 530         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 531         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 532
 533         for (freq = start_freq; freq <= end_freq; freq += 20) {
 534                 c = ieee80211_get_channel(wiphy, freq);
 535                 if (!c)
 536                         return 0;
 537
 538                 if (c->flags & IEEE80211_CHAN_DISABLED)
 539                         return 0;
 540
 541                 if (!(c->flags & IEEE80211_CHAN_RADAR))
 542                         continue;
 543
 544                 if (c->dfs_cac_ms > dfs_cac_ms)
 545                         dfs_cac_ms = c->dfs_cac_ms;
 546         }
 547
 548         return dfs_cac_ms;
 549 }
 550
 551 unsigned int
 552 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
 553                               const struct cfg80211_chan_def *chandef)
 554 {
 555         int width;
 556         unsigned int t1 = 0, t2 = 0;
 557
 558         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 559                 return 0;
 560
 561         width = cfg80211_chandef_get_width(chandef);
 562         if (width < 0)
 563                 return 0;
 564
 565         t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
 566                                              chandef->center_freq1,
 567                                              width);
 568
 569         if (!chandef->center_freq2)
 570                 return t1;
 571
 572         t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
 573                                              chandef->center_freq2,
 574                                              width);
 575
 576         return max(t1, t2);
 577 }
 578
 579 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 580                                         u32 center_freq, u32 bandwidth,
 581                                         u32 prohibited_flags)
 582 {
 583         struct ieee80211_channel *c;
 584         u32 freq, start_freq, end_freq;
 585
 586         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 587         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 588
 589         for (freq = start_freq; freq <= end_freq; freq += 20) {
 590                 c = ieee80211_get_channel(wiphy, freq);
 591                 if (!c || c->flags & prohibited_flags)
 592                         return false;
 593         }
 594
 595         return true;
 596 }
 597
 598 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 599                              const struct cfg80211_chan_def *chandef,
 600                              u32 prohibited_flags)
 601 {
 602         struct ieee80211_sta_ht_cap *ht_cap;
 603         struct ieee80211_sta_vht_cap *vht_cap;
 604         u32 width, control_freq;
 605
 606         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 607                 return false;
 608
 609         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 610         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 611
 612         control_freq = chandef->chan->center_freq;
 613
 614         switch (chandef->width) {
 615         case NL80211_CHAN_WIDTH_5:
 616                 width = 5;
 617                 break;
 618         case NL80211_CHAN_WIDTH_10:
 619                 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
 620                 width = 10;
 621                 break;
 622         case NL80211_CHAN_WIDTH_20:
 623                 if (!ht_cap->ht_supported)
 624                         return false;
 625         case NL80211_CHAN_WIDTH_20_NOHT:
 626                 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
 627                 width = 20;
 628                 break;
 629         case NL80211_CHAN_WIDTH_40:
 630                 width = 40;
 631                 if (!ht_cap->ht_supported)
 632                         return false;
 633                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 634                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 635                         return false;
 636                 if (chandef->center_freq1 < control_freq &&
 637                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 638                         return false;
 639                 if (chandef->center_freq1 > control_freq &&
 640                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 641                         return false;
 642                 break;
 643         case NL80211_CHAN_WIDTH_80P80:
 644                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
 645                         return false;
 646         case NL80211_CHAN_WIDTH_80:
 647                 if (!vht_cap->vht_supported)
 648                         return false;
 649                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 650                 width = 80;
 651                 break;
 652         case NL80211_CHAN_WIDTH_160:
 653                 if (!vht_cap->vht_supported)
 654                         return false;
 655                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
 656                         return false;
 657                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 658                 width = 160;
 659                 break;
 660         default:
 661                 WARN_ON_ONCE(1);
 662                 return false;
 663         }
 664
 665         /*
 666          * TODO: What if there are only certain 80/160/80+80 MHz channels
 667          *       allowed by the driver, or only certain combinations?
 668          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 669          *       80/160 MHz and in particular 80+80 MHz this isn't really
 670          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 671          *       no way to cover 80+80 MHz or more complex restrictions.
 672          *       Note that such restrictions also need to be advertised to
 673          *       userspace, for example for P2P channel selection.
 674          */
 675
 676         if (width > 20)
 677                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 678
 679         /* 5 and 10 MHz are only defined for the OFDM PHY */
 680         if (width < 20)
 681                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 682
 683
 684         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 685                                          width, prohibited_flags))
 686                 return false;
 687
 688         if (!chandef->center_freq2)
 689                 return true;
 690         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 691                                            width, prohibited_flags);
 692 }
 693 EXPORT_SYMBOL(cfg80211_chandef_usable);
 694
 695 /*
 696  * For GO only, check if the channel can be used under permissive conditions
 697  * mandated by the some regulatory bodies, i.e., the channel is marked with
 698  * IEEE80211_CHAN_GO_CONCURRENT and there is an additional station interface
 699  * associated to an AP on the same channel or on the same UNII band
 700  * (assuming that the AP is an authorized master).
 701  * In addition allow the GO to operate on a channel on which indoor operation is
 702  * allowed, iff we are currently operating in an indoor environment.
 703  */
 704 static bool cfg80211_go_permissive_chan(struct cfg80211_registered_device *rdev,
 705                                         struct ieee80211_channel *chan)
 706 {
 707         struct wireless_dev *wdev_iter;
 708         struct wiphy *wiphy = wiphy_idx_to_wiphy(rdev->wiphy_idx);
 709
 710         ASSERT_RTNL();
 711
 712         if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
 713             !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
 714                 return false;
 715
 716         if (regulatory_indoor_allowed() &&
 717             (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
 718                 return true;
 719
 720         if (!(chan->flags & IEEE80211_CHAN_GO_CONCURRENT))
 721                 return false;
 722
 723         /*
 724          * Generally, it is possible to rely on another device/driver to allow
 725          * the GO concurrent relaxation, however, since the device can further
 726          * enforce the relaxation (by doing a similar verifications as this),
 727          * and thus fail the GO instantiation, consider only the interfaces of
 728          * the current registered device.
 729          */
 730         list_for_each_entry(wdev_iter, &rdev->wdev_list, list) {
 731                 struct ieee80211_channel *other_chan = NULL;
 732                 int r1, r2;
 733
 734                 if (wdev_iter->iftype != NL80211_IFTYPE_STATION ||
 735                     !netif_running(wdev_iter->netdev))
 736                         continue;
 737
 738                 wdev_lock(wdev_iter);
 739                 if (wdev_iter->current_bss)
 740                         other_chan = wdev_iter->current_bss->pub.channel;
 741                 wdev_unlock(wdev_iter);
 742
 743                 if (!other_chan)
 744                         continue;
 745
 746                 if (chan == other_chan)
 747                         return true;
 748
 749                 if (chan->band != IEEE80211_BAND_5GHZ)
 750                         continue;
 751
 752                 r1 = cfg80211_get_unii(chan->center_freq);
 753                 r2 = cfg80211_get_unii(other_chan->center_freq);
 754
 755                 if (r1 != -EINVAL && r1 == r2) {
 756                         /*
 757                          * At some locations channels 149-165 are considered a
 758                          * bundle, but at other locations, e.g., Indonesia,
 759                          * channels 149-161 are considered a bundle while
 760                          * channel 165 is left out and considered to be in a
 761                          * different bundle. Thus, in case that there is a
 762                          * station interface connected to an AP on channel 165,
 763                          * it is assumed that channels 149-161 are allowed for
 764                          * GO operations. However, having a station interface
 765                          * connected to an AP on channels 149-161, does not
 766                          * allow GO operation on channel 165.
 767                          */
 768                         if (chan->center_freq == 5825 &&
 769                             other_chan->center_freq != 5825)
 770                                 continue;
 771                         return true;
 772                 }
 773         }
 774
 775         return false;
 776 }
 777
 778 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
 779                              struct cfg80211_chan_def *chandef,
 780                              enum nl80211_iftype iftype)
 781 {
 782         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 783         bool res;
 784         u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
 785                                IEEE80211_CHAN_RADAR;
 786
 787         trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype);
 788
 789         /*
 790          * Under certain conditions suggested by the some regulatory bodies
 791          * a GO can operate on channels marked with IEEE80211_NO_IR
 792          * so set this flag only if such relaxations are not enabled and
 793          * the conditions are not met.
 794          */
 795         if (iftype != NL80211_IFTYPE_P2P_GO ||
 796             !cfg80211_go_permissive_chan(rdev, chandef->chan))
 797                 prohibited_flags |= IEEE80211_CHAN_NO_IR;
 798
 799         if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
 800             cfg80211_chandef_dfs_available(wiphy, chandef)) {
 801                 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
 802                 prohibited_flags = IEEE80211_CHAN_DISABLED;
 803         }
 804
 805         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
 806
 807         trace_cfg80211_return_bool(res);
 808         return res;
 809 }
 810 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 811
 812 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 813                                  struct cfg80211_chan_def *chandef)
 814 {
 815         if (!rdev->ops->set_monitor_channel)
 816                 return -EOPNOTSUPP;
 817         if (!cfg80211_has_monitors_only(rdev))
 818                 return -EBUSY;
 819
 820         return rdev_set_monitor_channel(rdev, chandef);
 821 }
 822
 823 void
 824 cfg80211_get_chan_state(struct wireless_dev *wdev,
 825                         struct ieee80211_channel **chan,
 826                         enum cfg80211_chan_mode *chanmode,
 827                         u8 *radar_detect)
 828 {
 829         int ret;
 830
 831         *chan = NULL;
 832         *chanmode = CHAN_MODE_UNDEFINED;
 833
 834         ASSERT_WDEV_LOCK(wdev);
 835
 836         if (wdev->netdev && !netif_running(wdev->netdev))
 837                 return;
 838
 839         switch (wdev->iftype) {
 840         case NL80211_IFTYPE_ADHOC:
 841                 if (wdev->current_bss) {
 842                         *chan = wdev->current_bss->pub.channel;
 843                         *chanmode = (wdev->ibss_fixed &&
 844                                      !wdev->ibss_dfs_possible)
 845                                   ? CHAN_MODE_SHARED
 846                                   : CHAN_MODE_EXCLUSIVE;
 847
 848                         /* consider worst-case - IBSS can try to return to the
 849                          * original user-specified channel as creator */
 850                         if (wdev->ibss_dfs_possible)
 851                                 *radar_detect |= BIT(wdev->chandef.width);
 852                         return;
 853                 }
 854                 break;
 855         case NL80211_IFTYPE_STATION:
 856         case NL80211_IFTYPE_P2P_CLIENT:
 857                 if (wdev->current_bss) {
 858                         *chan = wdev->current_bss->pub.channel;
 859                         *chanmode = CHAN_MODE_SHARED;
 860                         return;
 861                 }
 862                 break;
 863         case NL80211_IFTYPE_AP:
 864         case NL80211_IFTYPE_P2P_GO:
 865                 if (wdev->cac_started) {
 866                         *chan = wdev->chandef.chan;
 867                         *chanmode = CHAN_MODE_SHARED;
 868                         *radar_detect |= BIT(wdev->chandef.width);
 869                 } else if (wdev->beacon_interval) {
 870                         *chan = wdev->chandef.chan;
 871                         *chanmode = CHAN_MODE_SHARED;
 872
 873                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
 874                                                             &wdev->chandef,
 875                                                             wdev->iftype);
 876                         WARN_ON(ret < 0);
 877                         if (ret > 0)
 878                                 *radar_detect |= BIT(wdev->chandef.width);
 879                 }
 880                 return;
 881         case NL80211_IFTYPE_MESH_POINT:
 882                 if (wdev->mesh_id_len) {
 883                         *chan = wdev->chandef.chan;
 884                         *chanmode = CHAN_MODE_SHARED;
 885
 886                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
 887                                                             &wdev->chandef,
 888                                                             wdev->iftype);
 889                         WARN_ON(ret < 0);
 890                         if (ret > 0)
 891                                 *radar_detect |= BIT(wdev->chandef.width);
 892                 }
 893                 return;
 894         case NL80211_IFTYPE_MONITOR:
 895         case NL80211_IFTYPE_AP_VLAN:
 896         case NL80211_IFTYPE_WDS:
 897         case NL80211_IFTYPE_P2P_DEVICE:
 898                 /* these interface types don't really have a channel */
 899                 return;
 900         case NL80211_IFTYPE_UNSPECIFIED:
 901         case NUM_NL80211_IFTYPES:
 902                 WARN_ON(1);
 903         }
 904 }