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  * Copyright 2013-2014  Intel Mobile Communications GmbH
   8  */
   9
  10 #include <linux/export.h>
  11 #include <net/cfg80211.h>
  12 #include "core.h"
  13 #include "rdev-ops.h"
  14
  15 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  16                              struct ieee80211_channel *chan,
  17                              enum nl80211_channel_type chan_type)
  18 {
  19         if (WARN_ON(!chan))
  20                 return;
  21
  22         chandef->chan = chan;
  23         chandef->center_freq2 = 0;
  24
  25         switch (chan_type) {
  26         case NL80211_CHAN_NO_HT:
  27                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  28                 chandef->center_freq1 = chan->center_freq;
  29                 break;
  30         case NL80211_CHAN_HT20:
  31                 chandef->width = NL80211_CHAN_WIDTH_20;
  32                 chandef->center_freq1 = chan->center_freq;
  33                 break;
  34         case NL80211_CHAN_HT40PLUS:
  35                 chandef->width = NL80211_CHAN_WIDTH_40;
  36                 chandef->center_freq1 = chan->center_freq + 10;
  37                 break;
  38         case NL80211_CHAN_HT40MINUS:
  39                 chandef->width = NL80211_CHAN_WIDTH_40;
  40                 chandef->center_freq1 = chan->center_freq - 10;
  41                 break;
  42         default:
  43                 WARN_ON(1);
  44         }
  45 }
  46 EXPORT_SYMBOL(cfg80211_chandef_create);
  47
  48 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
  49 {
  50         u32 control_freq;
  51
  52         if (!chandef->chan)
  53                 return false;
  54
  55         control_freq = chandef->chan->center_freq;
  56
  57         switch (chandef->width) {
  58         case NL80211_CHAN_WIDTH_5:
  59         case NL80211_CHAN_WIDTH_10:
  60         case NL80211_CHAN_WIDTH_20:
  61         case NL80211_CHAN_WIDTH_20_NOHT:
  62                 if (chandef->center_freq1 != control_freq)
  63                         return false;
  64                 if (chandef->center_freq2)
  65                         return false;
  66                 break;
  67         case NL80211_CHAN_WIDTH_40:
  68                 if (chandef->center_freq1 != control_freq + 10 &&
  69                     chandef->center_freq1 != control_freq - 10)
  70                         return false;
  71                 if (chandef->center_freq2)
  72                         return false;
  73                 break;
  74         case NL80211_CHAN_WIDTH_80P80:
  75                 if (chandef->center_freq1 != control_freq + 30 &&
  76                     chandef->center_freq1 != control_freq + 10 &&
  77                     chandef->center_freq1 != control_freq - 10 &&
  78                     chandef->center_freq1 != control_freq - 30)
  79                         return false;
  80                 if (!chandef->center_freq2)
  81                         return false;
  82                 /* adjacent is not allowed -- that's a 160 MHz channel */
  83                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
  84                     chandef->center_freq2 - chandef->center_freq1 == 80)
  85                         return false;
  86                 break;
  87         case NL80211_CHAN_WIDTH_80:
  88                 if (chandef->center_freq1 != control_freq + 30 &&
  89                     chandef->center_freq1 != control_freq + 10 &&
  90                     chandef->center_freq1 != control_freq - 10 &&
  91                     chandef->center_freq1 != control_freq - 30)
  92                         return false;
  93                 if (chandef->center_freq2)
  94                         return false;
  95                 break;
  96         case NL80211_CHAN_WIDTH_160:
  97                 if (chandef->center_freq1 != control_freq + 70 &&
  98                     chandef->center_freq1 != control_freq + 50 &&
  99                     chandef->center_freq1 != control_freq + 30 &&
 100                     chandef->center_freq1 != control_freq + 10 &&
 101                     chandef->center_freq1 != control_freq - 10 &&
 102                     chandef->center_freq1 != control_freq - 30 &&
 103                     chandef->center_freq1 != control_freq - 50 &&
 104                     chandef->center_freq1 != control_freq - 70)
 105                         return false;
 106                 if (chandef->center_freq2)
 107                         return false;
 108                 break;
 109         default:
 110                 return false;
 111         }
 112
 113         return true;
 114 }
 115 EXPORT_SYMBOL(cfg80211_chandef_valid);
 116
 117 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 118                                   u32 *pri40, u32 *pri80)
 119 {
 120         int tmp;
 121
 122         switch (c->width) {
 123         case NL80211_CHAN_WIDTH_40:
 124                 *pri40 = c->center_freq1;
 125                 *pri80 = 0;
 126                 break;
 127         case NL80211_CHAN_WIDTH_80:
 128         case NL80211_CHAN_WIDTH_80P80:
 129                 *pri80 = c->center_freq1;
 130                 /* n_P20 */
 131                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 132                 /* n_P40 */
 133                 tmp /= 2;
 134                 /* freq_P40 */
 135                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
 136                 break;
 137         case NL80211_CHAN_WIDTH_160:
 138                 /* n_P20 */
 139                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 140                 /* n_P40 */
 141                 tmp /= 2;
 142                 /* freq_P40 */
 143                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
 144                 /* n_P80 */
 145                 tmp /= 2;
 146                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
 147                 break;
 148         default:
 149                 WARN_ON_ONCE(1);
 150         }
 151 }
 152
 153 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 154 {
 155         int width;
 156
 157         switch (c->width) {
 158         case NL80211_CHAN_WIDTH_5:
 159                 width = 5;
 160                 break;
 161         case NL80211_CHAN_WIDTH_10:
 162                 width = 10;
 163                 break;
 164         case NL80211_CHAN_WIDTH_20:
 165         case NL80211_CHAN_WIDTH_20_NOHT:
 166                 width = 20;
 167                 break;
 168         case NL80211_CHAN_WIDTH_40:
 169                 width = 40;
 170                 break;
 171         case NL80211_CHAN_WIDTH_80P80:
 172         case NL80211_CHAN_WIDTH_80:
 173                 width = 80;
 174                 break;
 175         case NL80211_CHAN_WIDTH_160:
 176                 width = 160;
 177                 break;
 178         default:
 179                 WARN_ON_ONCE(1);
 180                 return -1;
 181         }
 182         return width;
 183 }
 184
 185 const struct cfg80211_chan_def *
 186 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 187                             const struct cfg80211_chan_def *c2)
 188 {
 189         u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 190
 191         /* If they are identical, return */
 192         if (cfg80211_chandef_identical(c1, c2))
 193                 return c1;
 194
 195         /* otherwise, must have same control channel */
 196         if (c1->chan != c2->chan)
 197                 return NULL;
 198
 199         /*
 200          * If they have the same width, but aren't identical,
 201          * then they can't be compatible.
 202          */
 203         if (c1->width == c2->width)
 204                 return NULL;
 205
 206         /*
 207          * can't be compatible if one of them is 5 or 10 MHz,
 208          * but they don't have the same width.
 209          */
 210         if (c1->width == NL80211_CHAN_WIDTH_5 ||
 211             c1->width == NL80211_CHAN_WIDTH_10 ||
 212             c2->width == NL80211_CHAN_WIDTH_5 ||
 213             c2->width == NL80211_CHAN_WIDTH_10)
 214                 return NULL;
 215
 216         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 217             c1->width == NL80211_CHAN_WIDTH_20)
 218                 return c2;
 219
 220         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 221             c2->width == NL80211_CHAN_WIDTH_20)
 222                 return c1;
 223
 224         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 225         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 226
 227         if (c1_pri40 != c2_pri40)
 228                 return NULL;
 229
 230         WARN_ON(!c1_pri80 && !c2_pri80);
 231         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 232                 return NULL;
 233
 234         if (c1->width > c2->width)
 235                 return c1;
 236         return c2;
 237 }
 238 EXPORT_SYMBOL(cfg80211_chandef_compatible);
 239
 240 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 241                                          u32 bandwidth,
 242                                          enum nl80211_dfs_state dfs_state)
 243 {
 244         struct ieee80211_channel *c;
 245         u32 freq;
 246
 247         for (freq = center_freq - bandwidth/2 + 10;
 248              freq <= center_freq + bandwidth/2 - 10;
 249              freq += 20) {
 250                 c = ieee80211_get_channel(wiphy, freq);
 251                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 252                         continue;
 253
 254                 c->dfs_state = dfs_state;
 255                 c->dfs_state_entered = jiffies;
 256         }
 257 }
 258
 259 void cfg80211_set_dfs_state(struct wiphy *wiphy,
 260                             const struct cfg80211_chan_def *chandef,
 261                             enum nl80211_dfs_state dfs_state)
 262 {
 263         int width;
 264
 265         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 266                 return;
 267
 268         width = cfg80211_chandef_get_width(chandef);
 269         if (width < 0)
 270                 return;
 271
 272         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 273                                      width, dfs_state);
 274
 275         if (!chandef->center_freq2)
 276                 return;
 277         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 278                                      width, dfs_state);
 279 }
 280
 281 static u32 cfg80211_get_start_freq(u32 center_freq,
 282                                    u32 bandwidth)
 283 {
 284         u32 start_freq;
 285
 286         if (bandwidth <= 20)
 287                 start_freq = center_freq;
 288         else
 289                 start_freq = center_freq - bandwidth/2 + 10;
 290
 291         return start_freq;
 292 }
 293
 294 static u32 cfg80211_get_end_freq(u32 center_freq,
 295                                  u32 bandwidth)
 296 {
 297         u32 end_freq;
 298
 299         if (bandwidth <= 20)
 300                 end_freq = center_freq;
 301         else
 302                 end_freq = center_freq + bandwidth/2 - 10;
 303
 304         return end_freq;
 305 }
 306
 307 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 308                                             u32 center_freq,
 309                                             u32 bandwidth)
 310 {
 311         struct ieee80211_channel *c;
 312         u32 freq, start_freq, end_freq;
 313
 314         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 315         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 316
 317         for (freq = start_freq; freq <= end_freq; freq += 20) {
 318                 c = ieee80211_get_channel(wiphy, freq);
 319                 if (!c)
 320                         return -EINVAL;
 321
 322                 if (c->flags & IEEE80211_CHAN_RADAR)
 323                         return 1;
 324         }
 325         return 0;
 326 }
 327
 328
 329 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 330                                   const struct cfg80211_chan_def *chandef,
 331                                   enum nl80211_iftype iftype)
 332 {
 333         int width;
 334         int ret;
 335
 336         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 337                 return -EINVAL;
 338
 339         switch (iftype) {
 340         case NL80211_IFTYPE_ADHOC:
 341         case NL80211_IFTYPE_AP:
 342         case NL80211_IFTYPE_P2P_GO:
 343         case NL80211_IFTYPE_MESH_POINT:
 344                 width = cfg80211_chandef_get_width(chandef);
 345                 if (width < 0)
 346                         return -EINVAL;
 347
 348                 ret = cfg80211_get_chans_dfs_required(wiphy,
 349                                                       chandef->center_freq1,
 350                                                       width);
 351                 if (ret < 0)
 352                         return ret;
 353                 else if (ret > 0)
 354                         return BIT(chandef->width);
 355
 356                 if (!chandef->center_freq2)
 357                         return 0;
 358
 359                 ret = cfg80211_get_chans_dfs_required(wiphy,
 360                                                       chandef->center_freq2,
 361                                                       width);
 362                 if (ret < 0)
 363                         return ret;
 364                 else if (ret > 0)
 365                         return BIT(chandef->width);
 366
 367                 break;
 368         case NL80211_IFTYPE_STATION:
 369         case NL80211_IFTYPE_OCB:
 370         case NL80211_IFTYPE_P2P_CLIENT:
 371         case NL80211_IFTYPE_MONITOR:
 372         case NL80211_IFTYPE_AP_VLAN:
 373         case NL80211_IFTYPE_WDS:
 374         case NL80211_IFTYPE_P2P_DEVICE:
 375         case NL80211_IFTYPE_NAN:
 376                 break;
 377         case NL80211_IFTYPE_UNSPECIFIED:
 378         case NUM_NL80211_IFTYPES:
 379                 WARN_ON(1);
 380         }
 381
 382         return 0;
 383 }
 384 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 385
 386 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 387                                          u32 center_freq,
 388                                          u32 bandwidth)
 389 {
 390         struct ieee80211_channel *c;
 391         u32 freq, start_freq, end_freq;
 392         int count = 0;
 393
 394         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 395         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 396
 397         /*
 398          * Check entire range of channels for the bandwidth.
 399          * Check all channels are DFS channels (DFS_USABLE or
 400          * DFS_AVAILABLE). Return number of usable channels
 401          * (require CAC). Allow DFS and non-DFS channel mix.
 402          */
 403         for (freq = start_freq; freq <= end_freq; freq += 20) {
 404                 c = ieee80211_get_channel(wiphy, freq);
 405                 if (!c)
 406                         return -EINVAL;
 407
 408                 if (c->flags & IEEE80211_CHAN_DISABLED)
 409                         return -EINVAL;
 410
 411                 if (c->flags & IEEE80211_CHAN_RADAR) {
 412                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 413                                 return -EINVAL;
 414
 415                         if (c->dfs_state == NL80211_DFS_USABLE)
 416                                 count++;
 417                 }
 418         }
 419
 420         return count;
 421 }
 422
 423 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 424                                  const struct cfg80211_chan_def *chandef)
 425 {
 426         int width;
 427         int r1, r2 = 0;
 428
 429         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 430                 return false;
 431
 432         width = cfg80211_chandef_get_width(chandef);
 433         if (width < 0)
 434                 return false;
 435
 436         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 437                                           width);
 438
 439         if (r1 < 0)
 440                 return false;
 441
 442         switch (chandef->width) {
 443         case NL80211_CHAN_WIDTH_80P80:
 444                 WARN_ON(!chandef->center_freq2);
 445                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
 446                                                    chandef->center_freq2,
 447                                                    width);
 448                 if (r2 < 0)
 449                         return false;
 450                 break;
 451         default:
 452                 WARN_ON(chandef->center_freq2);
 453                 break;
 454         }
 455
 456         return (r1 + r2 > 0);
 457 }
 458
 459 /*
 460  * Checks if center frequency of chan falls with in the bandwidth
 461  * range of chandef.
 462  */
 463 bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
 464                           struct ieee80211_channel *chan)
 465 {
 466         int width;
 467         u32 cf_offset, freq;
 468
 469         if (chandef->chan->center_freq == chan->center_freq)
 470                 return true;
 471
 472         width = cfg80211_chandef_get_width(chandef);
 473         if (width <= 20)
 474                 return false;
 475
 476         cf_offset = width / 2 - 10;
 477
 478         for (freq = chandef->center_freq1 - width / 2 + 10;
 479              freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
 480                 if (chan->center_freq == freq)
 481                         return true;
 482         }
 483
 484         if (!chandef->center_freq2)
 485                 return false;
 486
 487         for (freq = chandef->center_freq2 - width / 2 + 10;
 488              freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
 489                 if (chan->center_freq == freq)
 490                         return true;
 491         }
 492
 493         return false;
 494 }
 495
 496 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
 497 {
 498         bool active = false;
 499
 500         ASSERT_WDEV_LOCK(wdev);
 501
 502         if (!wdev->chandef.chan)
 503                 return false;
 504
 505         switch (wdev->iftype) {
 506         case NL80211_IFTYPE_AP:
 507         case NL80211_IFTYPE_P2P_GO:
 508                 active = wdev->beacon_interval != 0;
 509                 break;
 510         case NL80211_IFTYPE_ADHOC:
 511                 active = wdev->ssid_len != 0;
 512                 break;
 513         case NL80211_IFTYPE_MESH_POINT:
 514                 active = wdev->mesh_id_len != 0;
 515                 break;
 516         case NL80211_IFTYPE_STATION:
 517         case NL80211_IFTYPE_OCB:
 518         case NL80211_IFTYPE_P2P_CLIENT:
 519         case NL80211_IFTYPE_MONITOR:
 520         case NL80211_IFTYPE_AP_VLAN:
 521         case NL80211_IFTYPE_WDS:
 522         case NL80211_IFTYPE_P2P_DEVICE:
 523         /* Can NAN type be considered as beaconing interface? */
 524         case NL80211_IFTYPE_NAN:
 525                 break;
 526         case NL80211_IFTYPE_UNSPECIFIED:
 527         case NUM_NL80211_IFTYPES:
 528                 WARN_ON(1);
 529         }
 530
 531         return active;
 532 }
 533
 534 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
 535                                         struct ieee80211_channel *chan)
 536 {
 537         struct wireless_dev *wdev;
 538
 539         list_for_each_entry(wdev, &wiphy->wdev_list, list) {
 540                 wdev_lock(wdev);
 541                 if (!cfg80211_beaconing_iface_active(wdev)) {
 542                         wdev_unlock(wdev);
 543                         continue;
 544                 }
 545
 546                 if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
 547                         wdev_unlock(wdev);
 548                         return true;
 549                 }
 550                 wdev_unlock(wdev);
 551         }
 552
 553         return false;
 554 }
 555
 556 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
 557                                   struct ieee80211_channel *chan)
 558 {
 559         struct cfg80211_registered_device *rdev;
 560
 561         ASSERT_RTNL();
 562
 563         if (!(chan->flags & IEEE80211_CHAN_RADAR))
 564                 return false;
 565
 566         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
 567                 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
 568                         continue;
 569
 570                 if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
 571                         return true;
 572         }
 573
 574         return false;
 575 }
 576
 577 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 578                                              u32 center_freq,
 579                                              u32 bandwidth)
 580 {
 581         struct ieee80211_channel *c;
 582         u32 freq, start_freq, end_freq;
 583
 584         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 585         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 586
 587         /*
 588          * Check entire range of channels for the bandwidth.
 589          * If any channel in between is disabled or has not
 590          * had gone through CAC return false
 591          */
 592         for (freq = start_freq; freq <= end_freq; freq += 20) {
 593                 c = ieee80211_get_channel(wiphy, freq);
 594                 if (!c)
 595                         return false;
 596
 597                 if (c->flags & IEEE80211_CHAN_DISABLED)
 598                         return false;
 599
 600                 if ((c->flags & IEEE80211_CHAN_RADAR)  &&
 601                     (c->dfs_state != NL80211_DFS_AVAILABLE))
 602                         return false;
 603         }
 604
 605         return true;
 606 }
 607
 608 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 609                                 const struct cfg80211_chan_def *chandef)
 610 {
 611         int width;
 612         int r;
 613
 614         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 615                 return false;
 616
 617         width = cfg80211_chandef_get_width(chandef);
 618         if (width < 0)
 619                 return false;
 620
 621         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 622                                              width);
 623
 624         /* If any of channels unavailable for cf1 just return */
 625         if (!r)
 626                 return r;
 627
 628         switch (chandef->width) {
 629         case NL80211_CHAN_WIDTH_80P80:
 630                 WARN_ON(!chandef->center_freq2);
 631                 r = cfg80211_get_chans_dfs_available(wiphy,
 632                                                      chandef->center_freq2,
 633                                                      width);
 634                 break;
 635         default:
 636                 WARN_ON(chandef->center_freq2);
 637                 break;
 638         }
 639
 640         return r;
 641 }
 642
 643 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
 644                                                     u32 center_freq,
 645                                                     u32 bandwidth)
 646 {
 647         struct ieee80211_channel *c;
 648         u32 start_freq, end_freq, freq;
 649         unsigned int dfs_cac_ms = 0;
 650
 651         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 652         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 653
 654         for (freq = start_freq; freq <= end_freq; freq += 20) {
 655                 c = ieee80211_get_channel(wiphy, freq);
 656                 if (!c)
 657                         return 0;
 658
 659                 if (c->flags & IEEE80211_CHAN_DISABLED)
 660                         return 0;
 661
 662                 if (!(c->flags & IEEE80211_CHAN_RADAR))
 663                         continue;
 664
 665                 if (c->dfs_cac_ms > dfs_cac_ms)
 666                         dfs_cac_ms = c->dfs_cac_ms;
 667         }
 668
 669         return dfs_cac_ms;
 670 }
 671
 672 unsigned int
 673 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
 674                               const struct cfg80211_chan_def *chandef)
 675 {
 676         int width;
 677         unsigned int t1 = 0, t2 = 0;
 678
 679         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 680                 return 0;
 681
 682         width = cfg80211_chandef_get_width(chandef);
 683         if (width < 0)
 684                 return 0;
 685
 686         t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
 687                                              chandef->center_freq1,
 688                                              width);
 689
 690         if (!chandef->center_freq2)
 691                 return t1;
 692
 693         t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
 694                                              chandef->center_freq2,
 695                                              width);
 696
 697         return max(t1, t2);
 698 }
 699
 700 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 701                                         u32 center_freq, u32 bandwidth,
 702                                         u32 prohibited_flags)
 703 {
 704         struct ieee80211_channel *c;
 705         u32 freq, start_freq, end_freq;
 706
 707         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 708         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 709
 710         for (freq = start_freq; freq <= end_freq; freq += 20) {
 711                 c = ieee80211_get_channel(wiphy, freq);
 712                 if (!c || c->flags & prohibited_flags)
 713                         return false;
 714         }
 715
 716         return true;
 717 }
 718
 719 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 720                              const struct cfg80211_chan_def *chandef,
 721                              u32 prohibited_flags)
 722 {
 723         struct ieee80211_sta_ht_cap *ht_cap;
 724         struct ieee80211_sta_vht_cap *vht_cap;
 725         u32 width, control_freq, cap;
 726
 727         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 728                 return false;
 729
 730         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 731         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 732
 733         control_freq = chandef->chan->center_freq;
 734
 735         switch (chandef->width) {
 736         case NL80211_CHAN_WIDTH_5:
 737                 width = 5;
 738                 break;
 739         case NL80211_CHAN_WIDTH_10:
 740                 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
 741                 width = 10;
 742                 break;
 743         case NL80211_CHAN_WIDTH_20:
 744                 if (!ht_cap->ht_supported)
 745                         return false;
 746         case NL80211_CHAN_WIDTH_20_NOHT:
 747                 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
 748                 width = 20;
 749                 break;
 750         case NL80211_CHAN_WIDTH_40:
 751                 width = 40;
 752                 if (!ht_cap->ht_supported)
 753                         return false;
 754                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 755                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 756                         return false;
 757                 if (chandef->center_freq1 < control_freq &&
 758                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 759                         return false;
 760                 if (chandef->center_freq1 > control_freq &&
 761                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 762                         return false;
 763                 break;
 764         case NL80211_CHAN_WIDTH_80P80:
 765                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 766                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 767                         return false;
 768         case NL80211_CHAN_WIDTH_80:
 769                 if (!vht_cap->vht_supported)
 770                         return false;
 771                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 772                 width = 80;
 773                 break;
 774         case NL80211_CHAN_WIDTH_160:
 775                 if (!vht_cap->vht_supported)
 776                         return false;
 777                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 778                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
 779                     cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 780                         return false;
 781                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 782                 width = 160;
 783                 break;
 784         default:
 785                 WARN_ON_ONCE(1);
 786                 return false;
 787         }
 788
 789         /*
 790          * TODO: What if there are only certain 80/160/80+80 MHz channels
 791          *       allowed by the driver, or only certain combinations?
 792          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 793          *       80/160 MHz and in particular 80+80 MHz this isn't really
 794          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 795          *       no way to cover 80+80 MHz or more complex restrictions.
 796          *       Note that such restrictions also need to be advertised to
 797          *       userspace, for example for P2P channel selection.
 798          */
 799
 800         if (width > 20)
 801                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 802
 803         /* 5 and 10 MHz are only defined for the OFDM PHY */
 804         if (width < 20)
 805                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 806
 807
 808         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 809                                          width, prohibited_flags))
 810                 return false;
 811
 812         if (!chandef->center_freq2)
 813                 return true;
 814         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 815                                            width, prohibited_flags);
 816 }
 817 EXPORT_SYMBOL(cfg80211_chandef_usable);
 818
 819 /*
 820  * Check if the channel can be used under permissive conditions mandated by
 821  * some regulatory bodies, i.e., the channel is marked with
 822  * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
 823  * associated to an AP on the same channel or on the same UNII band
 824  * (assuming that the AP is an authorized master).
 825  * In addition allow operation on a channel on which indoor operation is
 826  * allowed, iff we are currently operating in an indoor environment.
 827  */
 828 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
 829                                         enum nl80211_iftype iftype,
 830                                         struct ieee80211_channel *chan)
 831 {
 832         struct wireless_dev *wdev;
 833         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 834
 835         ASSERT_RTNL();
 836
 837         if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
 838             !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
 839                 return false;
 840
 841         /* only valid for GO and TDLS off-channel (station/p2p-CL) */
 842         if (iftype != NL80211_IFTYPE_P2P_GO &&
 843             iftype != NL80211_IFTYPE_STATION &&
 844             iftype != NL80211_IFTYPE_P2P_CLIENT)
 845                 return false;
 846
 847         if (regulatory_indoor_allowed() &&
 848             (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
 849                 return true;
 850
 851         if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
 852                 return false;
 853
 854         /*
 855          * Generally, it is possible to rely on another device/driver to allow
 856          * the IR concurrent relaxation, however, since the device can further
 857          * enforce the relaxation (by doing a similar verifications as this),
 858          * and thus fail the GO instantiation, consider only the interfaces of
 859          * the current registered device.
 860          */
 861         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
 862                 struct ieee80211_channel *other_chan = NULL;
 863                 int r1, r2;
 864
 865                 wdev_lock(wdev);
 866                 if (wdev->iftype == NL80211_IFTYPE_STATION &&
 867                     wdev->current_bss)
 868                         other_chan = wdev->current_bss->pub.channel;
 869
 870                 /*
 871                  * If a GO already operates on the same GO_CONCURRENT channel,
 872                  * this one (maybe the same one) can beacon as well. We allow
 873                  * the operation even if the station we relied on with
 874                  * GO_CONCURRENT is disconnected now. But then we must make sure
 875                  * we're not outdoor on an indoor-only channel.
 876                  */
 877                 if (iftype == NL80211_IFTYPE_P2P_GO &&
 878                     wdev->iftype == NL80211_IFTYPE_P2P_GO &&
 879                     wdev->beacon_interval &&
 880                     !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
 881                         other_chan = wdev->chandef.chan;
 882                 wdev_unlock(wdev);
 883
 884                 if (!other_chan)
 885                         continue;
 886
 887                 if (chan == other_chan)
 888                         return true;
 889
 890                 if (chan->band != NL80211_BAND_5GHZ)
 891                         continue;
 892
 893                 r1 = cfg80211_get_unii(chan->center_freq);
 894                 r2 = cfg80211_get_unii(other_chan->center_freq);
 895
 896                 if (r1 != -EINVAL && r1 == r2) {
 897                         /*
 898                          * At some locations channels 149-165 are considered a
 899                          * bundle, but at other locations, e.g., Indonesia,
 900                          * channels 149-161 are considered a bundle while
 901                          * channel 165 is left out and considered to be in a
 902                          * different bundle. Thus, in case that there is a
 903                          * station interface connected to an AP on channel 165,
 904                          * it is assumed that channels 149-161 are allowed for
 905                          * GO operations. However, having a station interface
 906                          * connected to an AP on channels 149-161, does not
 907                          * allow GO operation on channel 165.
 908                          */
 909                         if (chan->center_freq == 5825 &&
 910                             other_chan->center_freq != 5825)
 911                                 continue;
 912                         return true;
 913                 }
 914         }
 915
 916         return false;
 917 }
 918
 919 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
 920                                      struct cfg80211_chan_def *chandef,
 921                                      enum nl80211_iftype iftype,
 922                                      bool check_no_ir)
 923 {
 924         bool res;
 925         u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
 926                                IEEE80211_CHAN_RADAR;
 927
 928         trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
 929
 930         if (check_no_ir)
 931                 prohibited_flags |= IEEE80211_CHAN_NO_IR;
 932
 933         if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
 934             cfg80211_chandef_dfs_available(wiphy, chandef)) {
 935                 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
 936                 prohibited_flags = IEEE80211_CHAN_DISABLED;
 937         }
 938
 939         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
 940
 941         trace_cfg80211_return_bool(res);
 942         return res;
 943 }
 944
 945 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
 946                              struct cfg80211_chan_def *chandef,
 947                              enum nl80211_iftype iftype)
 948 {
 949         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
 950 }
 951 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 952
 953 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
 954                                    struct cfg80211_chan_def *chandef,
 955                                    enum nl80211_iftype iftype)
 956 {
 957         bool check_no_ir;
 958
 959         ASSERT_RTNL();
 960
 961         /*
 962          * Under certain conditions suggested by some regulatory bodies a
 963          * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
 964          * only if such relaxations are not enabled and the conditions are not
 965          * met.
 966          */
 967         check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
 968                                                    chandef->chan);
 969
 970         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
 971 }
 972 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
 973
 974 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 975                                  struct cfg80211_chan_def *chandef)
 976 {
 977         if (!rdev->ops->set_monitor_channel)
 978                 return -EOPNOTSUPP;
 979         if (!cfg80211_has_monitors_only(rdev))
 980                 return -EBUSY;
 981
 982         return rdev_set_monitor_channel(rdev, chandef);
 983 }
 984
 985 void
 986 cfg80211_get_chan_state(struct wireless_dev *wdev,
 987                         struct ieee80211_channel **chan,
 988                         enum cfg80211_chan_mode *chanmode,
 989                         u8 *radar_detect)
 990 {
 991         int ret;
 992
 993         *chan = NULL;
 994         *chanmode = CHAN_MODE_UNDEFINED;
 995
 996         ASSERT_WDEV_LOCK(wdev);
 997
 998         if (wdev->netdev && !netif_running(wdev->netdev))
 999                 return;
1000
1001         switch (wdev->iftype) {
1002         case NL80211_IFTYPE_ADHOC:
1003                 if (wdev->current_bss) {
1004                         *chan = wdev->current_bss->pub.channel;
1005                         *chanmode = (wdev->ibss_fixed &&
1006                                      !wdev->ibss_dfs_possible)
1007                                   ? CHAN_MODE_SHARED
1008                                   : CHAN_MODE_EXCLUSIVE;
1009
1010                         /* consider worst-case - IBSS can try to return to the
1011                          * original user-specified channel as creator */
1012                         if (wdev->ibss_dfs_possible)
1013                                 *radar_detect |= BIT(wdev->chandef.width);
1014                         return;
1015                 }
1016                 break;
1017         case NL80211_IFTYPE_STATION:
1018         case NL80211_IFTYPE_P2P_CLIENT:
1019                 if (wdev->current_bss) {
1020                         *chan = wdev->current_bss->pub.channel;
1021                         *chanmode = CHAN_MODE_SHARED;
1022                         return;
1023                 }
1024                 break;
1025         case NL80211_IFTYPE_AP:
1026         case NL80211_IFTYPE_P2P_GO:
1027                 if (wdev->cac_started) {
1028                         *chan = wdev->chandef.chan;
1029                         *chanmode = CHAN_MODE_SHARED;
1030                         *radar_detect |= BIT(wdev->chandef.width);
1031                 } else if (wdev->beacon_interval) {
1032                         *chan = wdev->chandef.chan;
1033                         *chanmode = CHAN_MODE_SHARED;
1034
1035                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1036                                                             &wdev->chandef,
1037                                                             wdev->iftype);
1038                         WARN_ON(ret < 0);
1039                         if (ret > 0)
1040                                 *radar_detect |= BIT(wdev->chandef.width);
1041                 }
1042                 return;
1043         case NL80211_IFTYPE_MESH_POINT:
1044                 if (wdev->mesh_id_len) {
1045                         *chan = wdev->chandef.chan;
1046                         *chanmode = CHAN_MODE_SHARED;
1047
1048                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1049                                                             &wdev->chandef,
1050                                                             wdev->iftype);
1051                         WARN_ON(ret < 0);
1052                         if (ret > 0)
1053                                 *radar_detect |= BIT(wdev->chandef.width);
1054                 }
1055                 return;
1056         case NL80211_IFTYPE_OCB:
1057                 if (wdev->chandef.chan) {
1058                         *chan = wdev->chandef.chan;
1059                         *chanmode = CHAN_MODE_SHARED;
1060                         return;
1061                 }
1062                 break;
1063         case NL80211_IFTYPE_MONITOR:
1064         case NL80211_IFTYPE_AP_VLAN:
1065         case NL80211_IFTYPE_WDS:
1066         case NL80211_IFTYPE_P2P_DEVICE:
1067         case NL80211_IFTYPE_NAN:
1068                 /* these interface types don't really have a channel */
1069                 return;
1070         case NL80211_IFTYPE_UNSPECIFIED:
1071         case NUM_NL80211_IFTYPES:
1072                 WARN_ON(1);
1073         }
1074 }