LXR linux/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
  15void 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}
  46EXPORT_SYMBOL(cfg80211_chandef_create);
  47
  48bool 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}
 115EXPORT_SYMBOL(cfg80211_chandef_valid);
 116
 117static 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
 153static 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
 185const struct cfg80211_chan_def *
 186cfg80211_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}
 238EXPORT_SYMBOL(cfg80211_chandef_compatible);
 239
 240static 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
 259void 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
 281static 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
 294static 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
 307static 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
 329int 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}
 384EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 385
 386static 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
 423bool 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 */
 463bool 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
 496bool 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
 534static 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
 556bool 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
 577static 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
 608static 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
 643static 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
 672unsigned int
 673cfg80211_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
 700static 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
 719bool 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}
 817EXPORT_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 */
 828static 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
 919static 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
 945bool 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}
 951EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 952
 953bool 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}
 972EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
 973
 974int 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
 985void
 986cfg80211_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}
1075