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 <[email protected]>
   7  */
   8
   9 #include <linux/export.h>
  10 #include <net/cfg80211.h>
  11 #include "core.h"
  12 #include "rdev-ops.h"
  13
  14 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  15                              struct ieee80211_channel *chan,
  16                              enum nl80211_channel_type chan_type)
  17 {
  18         if (WARN_ON(!chan))
  19                 return;
  20
  21         chandef->chan = chan;
  22         chandef->center_freq2 = 0;
  23
  24         switch (chan_type) {
  25         case NL80211_CHAN_NO_HT:
  26                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  27                 chandef->center_freq1 = chan->center_freq;
  28                 break;
  29         case NL80211_CHAN_HT20:
  30                 chandef->width = NL80211_CHAN_WIDTH_20;
  31                 chandef->center_freq1 = chan->center_freq;
  32                 break;
  33         case NL80211_CHAN_HT40PLUS:
  34                 chandef->width = NL80211_CHAN_WIDTH_40;
  35                 chandef->center_freq1 = chan->center_freq + 10;
  36                 break;
  37         case NL80211_CHAN_HT40MINUS:
  38                 chandef->width = NL80211_CHAN_WIDTH_40;
  39                 chandef->center_freq1 = chan->center_freq - 10;
  40                 break;
  41         default:
  42                 WARN_ON(1);
  43         }
  44 }
  45 EXPORT_SYMBOL(cfg80211_chandef_create);
  46
  47 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
  48 {
  49         u32 control_freq;
  50
  51         if (!chandef->chan)
  52                 return false;
  53
  54         control_freq = chandef->chan->center_freq;
  55
  56         switch (chandef->width) {
  57         case NL80211_CHAN_WIDTH_5:
  58         case NL80211_CHAN_WIDTH_10:
  59         case NL80211_CHAN_WIDTH_20:
  60         case NL80211_CHAN_WIDTH_20_NOHT:
  61                 if (chandef->center_freq1 != control_freq)
  62                         return false;
  63                 if (chandef->center_freq2)
  64                         return false;
  65                 break;
  66         case NL80211_CHAN_WIDTH_40:
  67                 if (chandef->center_freq1 != control_freq + 10 &&
  68                     chandef->center_freq1 != control_freq - 10)
  69                         return false;
  70                 if (chandef->center_freq2)
  71                         return false;
  72                 break;
  73         case NL80211_CHAN_WIDTH_80P80:
  74                 if (chandef->center_freq1 != control_freq + 30 &&
  75                     chandef->center_freq1 != control_freq + 10 &&
  76                     chandef->center_freq1 != control_freq - 10 &&
  77                     chandef->center_freq1 != control_freq - 30)
  78                         return false;
  79                 if (!chandef->center_freq2)
  80                         return false;
  81                 /* adjacent is not allowed -- that's a 160 MHz channel */
  82                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
  83                     chandef->center_freq2 - chandef->center_freq1 == 80)
  84                         return false;
  85                 break;
  86         case NL80211_CHAN_WIDTH_80:
  87                 if (chandef->center_freq1 != control_freq + 30 &&
  88                     chandef->center_freq1 != control_freq + 10 &&
  89                     chandef->center_freq1 != control_freq - 10 &&
  90                     chandef->center_freq1 != control_freq - 30)
  91                         return false;
  92                 if (chandef->center_freq2)
  93                         return false;
  94                 break;
  95         case NL80211_CHAN_WIDTH_160:
  96                 if (chandef->center_freq1 != control_freq + 70 &&
  97                     chandef->center_freq1 != control_freq + 50 &&
  98                     chandef->center_freq1 != control_freq + 30 &&
  99                     chandef->center_freq1 != control_freq + 10 &&
 100                     chandef->center_freq1 != control_freq - 10 &&
 101                     chandef->center_freq1 != control_freq - 30 &&
 102                     chandef->center_freq1 != control_freq - 50 &&
 103                     chandef->center_freq1 != control_freq - 70)
 104                         return false;
 105                 if (chandef->center_freq2)
 106                         return false;
 107                 break;
 108         default:
 109                 return false;
 110         }
 111
 112         return true;
 113 }
 114 EXPORT_SYMBOL(cfg80211_chandef_valid);
 115
 116 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 117                                   int *pri40, int *pri80)
 118 {
 119         int tmp;
 120
 121         switch (c->width) {
 122         case NL80211_CHAN_WIDTH_40:
 123                 *pri40 = c->center_freq1;
 124                 *pri80 = 0;
 125                 break;
 126         case NL80211_CHAN_WIDTH_80:
 127         case NL80211_CHAN_WIDTH_80P80:
 128                 *pri80 = c->center_freq1;
 129                 /* n_P20 */
 130                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 131                 /* n_P40 */
 132                 tmp /= 2;
 133                 /* freq_P40 */
 134                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
 135                 break;
 136         case NL80211_CHAN_WIDTH_160:
 137                 /* n_P20 */
 138                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 139                 /* n_P40 */
 140                 tmp /= 2;
 141                 /* freq_P40 */
 142                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
 143                 /* n_P80 */
 144                 tmp /= 2;
 145                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
 146                 break;
 147         default:
 148                 WARN_ON_ONCE(1);
 149         }
 150 }
 151
 152 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 153 {
 154         int width;
 155
 156         switch (c->width) {
 157         case NL80211_CHAN_WIDTH_5:
 158                 width = 5;
 159                 break;
 160         case NL80211_CHAN_WIDTH_10:
 161                 width = 10;
 162                 break;
 163         case NL80211_CHAN_WIDTH_20:
 164         case NL80211_CHAN_WIDTH_20_NOHT:
 165                 width = 20;
 166                 break;
 167         case NL80211_CHAN_WIDTH_40:
 168                 width = 40;
 169                 break;
 170         case NL80211_CHAN_WIDTH_80P80:
 171         case NL80211_CHAN_WIDTH_80:
 172                 width = 80;
 173                 break;
 174         case NL80211_CHAN_WIDTH_160:
 175                 width = 160;
 176                 break;
 177         default:
 178                 WARN_ON_ONCE(1);
 179                 return -1;
 180         }
 181         return width;
 182 }
 183
 184 const struct cfg80211_chan_def *
 185 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 186                             const struct cfg80211_chan_def *c2)
 187 {
 188         u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 189
 190         /* If they are identical, return */
 191         if (cfg80211_chandef_identical(c1, c2))
 192                 return c1;
 193
 194         /* otherwise, must have same control channel */
 195         if (c1->chan != c2->chan)
 196                 return NULL;
 197
 198         /*
 199          * If they have the same width, but aren't identical,
 200          * then they can't be compatible.
 201          */
 202         if (c1->width == c2->width)
 203                 return NULL;
 204
 205         /*
 206          * can't be compatible if one of them is 5 or 10 MHz,
 207          * but they don't have the same width.
 208          */
 209         if (c1->width == NL80211_CHAN_WIDTH_5 ||
 210             c1->width == NL80211_CHAN_WIDTH_10 ||
 211             c2->width == NL80211_CHAN_WIDTH_5 ||
 212             c2->width == NL80211_CHAN_WIDTH_10)
 213                 return NULL;
 214
 215         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 216             c1->width == NL80211_CHAN_WIDTH_20)
 217                 return c2;
 218
 219         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 220             c2->width == NL80211_CHAN_WIDTH_20)
 221                 return c1;
 222
 223         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 224         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 225
 226         if (c1_pri40 != c2_pri40)
 227                 return NULL;
 228
 229         WARN_ON(!c1_pri80 && !c2_pri80);
 230         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 231                 return NULL;
 232
 233         if (c1->width > c2->width)
 234                 return c1;
 235         return c2;
 236 }
 237 EXPORT_SYMBOL(cfg80211_chandef_compatible);
 238
 239 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 240                                          u32 bandwidth,
 241                                          enum nl80211_dfs_state dfs_state)
 242 {
 243         struct ieee80211_channel *c;
 244         u32 freq;
 245
 246         for (freq = center_freq - bandwidth/2 + 10;
 247              freq <= center_freq + bandwidth/2 - 10;
 248              freq += 20) {
 249                 c = ieee80211_get_channel(wiphy, freq);
 250                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 251                         continue;
 252
 253                 c->dfs_state = dfs_state;
 254                 c->dfs_state_entered = jiffies;
 255         }
 256 }
 257
 258 void cfg80211_set_dfs_state(struct wiphy *wiphy,
 259                             const struct cfg80211_chan_def *chandef,
 260                             enum nl80211_dfs_state dfs_state)
 261 {
 262         int width;
 263
 264         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 265                 return;
 266
 267         width = cfg80211_chandef_get_width(chandef);
 268         if (width < 0)
 269                 return;
 270
 271         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 272                                      width, dfs_state);
 273
 274         if (!chandef->center_freq2)
 275                 return;
 276         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 277                                      width, dfs_state);
 278 }
 279
 280 static u32 cfg80211_get_start_freq(u32 center_freq,
 281                                    u32 bandwidth)
 282 {
 283         u32 start_freq;
 284
 285         if (bandwidth <= 20)
 286                 start_freq = center_freq;
 287         else
 288                 start_freq = center_freq - bandwidth/2 + 10;
 289
 290         return start_freq;
 291 }
 292
 293 static u32 cfg80211_get_end_freq(u32 center_freq,
 294                                  u32 bandwidth)
 295 {
 296         u32 end_freq;
 297
 298         if (bandwidth <= 20)
 299                 end_freq = center_freq;
 300         else
 301                 end_freq = center_freq + bandwidth/2 - 10;
 302
 303         return end_freq;
 304 }
 305
 306 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 307                                             u32 center_freq,
 308                                             u32 bandwidth)
 309 {
 310         struct ieee80211_channel *c;
 311         u32 freq, start_freq, end_freq;
 312
 313         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 314         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 315
 316         for (freq = start_freq; freq <= end_freq; freq += 20) {
 317                 c = ieee80211_get_channel(wiphy, freq);
 318                 if (!c)
 319                         return -EINVAL;
 320
 321                 if (c->flags & IEEE80211_CHAN_RADAR)
 322                         return 1;
 323         }
 324         return 0;
 325 }
 326
 327
 328 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 329                                   const struct cfg80211_chan_def *chandef)
 330 {
 331         int width;
 332         int r;
 333
 334         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 335                 return -EINVAL;
 336
 337         width = cfg80211_chandef_get_width(chandef);
 338         if (width < 0)
 339                 return -EINVAL;
 340
 341         r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1,
 342                                             width);
 343         if (r)
 344                 return r;
 345
 346         if (!chandef->center_freq2)
 347                 return 0;
 348
 349         return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2,
 350                                                width);
 351 }
 352 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 353
 354 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 355                                          u32 center_freq,
 356                                          u32 bandwidth)
 357 {
 358         struct ieee80211_channel *c;
 359         u32 freq, start_freq, end_freq;
 360         int count = 0;
 361
 362         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 363         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 364
 365         /*
 366          * Check entire range of channels for the bandwidth.
 367          * Check all channels are DFS channels (DFS_USABLE or
 368          * DFS_AVAILABLE). Return number of usable channels
 369          * (require CAC). Allow DFS and non-DFS channel mix.
 370          */
 371         for (freq = start_freq; freq <= end_freq; freq += 20) {
 372                 c = ieee80211_get_channel(wiphy, freq);
 373                 if (!c)
 374                         return -EINVAL;
 375
 376                 if (c->flags & IEEE80211_CHAN_DISABLED)
 377                         return -EINVAL;
 378
 379                 if (c->flags & IEEE80211_CHAN_RADAR) {
 380                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 381                                 return -EINVAL;
 382
 383                         if (c->dfs_state == NL80211_DFS_USABLE)
 384                                 count++;
 385                 }
 386         }
 387
 388         return count;
 389 }
 390
 391 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 392                                  const struct cfg80211_chan_def *chandef)
 393 {
 394         int width;
 395         int r1, r2 = 0;
 396
 397         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 398                 return false;
 399
 400         width = cfg80211_chandef_get_width(chandef);
 401         if (width < 0)
 402                 return false;
 403
 404         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 405                                           width);
 406
 407         if (r1 < 0)
 408                 return false;
 409
 410         switch (chandef->width) {
 411         case NL80211_CHAN_WIDTH_80P80:
 412                 WARN_ON(!chandef->center_freq2);
 413                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
 414                                                    chandef->center_freq2,
 415                                                    width);
 416                 if (r2 < 0)
 417                         return false;
 418                 break;
 419         default:
 420                 WARN_ON(chandef->center_freq2);
 421                 break;
 422         }
 423
 424         return (r1 + r2 > 0);
 425 }
 426
 427
 428 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 429                                              u32 center_freq,
 430                                              u32 bandwidth)
 431 {
 432         struct ieee80211_channel *c;
 433         u32 freq, start_freq, end_freq;
 434
 435         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 436         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 437
 438         /*
 439          * Check entire range of channels for the bandwidth.
 440          * If any channel in between is disabled or has not
 441          * had gone through CAC return false
 442          */
 443         for (freq = start_freq; freq <= end_freq; freq += 20) {
 444                 c = ieee80211_get_channel(wiphy, freq);
 445                 if (!c)
 446                         return false;
 447
 448                 if (c->flags & IEEE80211_CHAN_DISABLED)
 449                         return false;
 450
 451                 if ((c->flags & IEEE80211_CHAN_RADAR)  &&
 452                     (c->dfs_state != NL80211_DFS_AVAILABLE))
 453                         return false;
 454         }
 455
 456         return true;
 457 }
 458
 459 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 460                                 const struct cfg80211_chan_def *chandef)
 461 {
 462         int width;
 463         int r;
 464
 465         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 466                 return false;
 467
 468         width = cfg80211_chandef_get_width(chandef);
 469         if (width < 0)
 470                 return false;
 471
 472         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 473                                              width);
 474
 475         /* If any of channels unavailable for cf1 just return */
 476         if (!r)
 477                 return r;
 478
 479         switch (chandef->width) {
 480         case NL80211_CHAN_WIDTH_80P80:
 481                 WARN_ON(!chandef->center_freq2);
 482                 r = cfg80211_get_chans_dfs_available(wiphy,
 483                                                      chandef->center_freq2,
 484                                                      width);
 485         default:
 486                 WARN_ON(chandef->center_freq2);
 487                 break;
 488         }
 489
 490         return r;
 491 }
 492
 493
 494 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 495                                         u32 center_freq, u32 bandwidth,
 496                                         u32 prohibited_flags)
 497 {
 498         struct ieee80211_channel *c;
 499         u32 freq, start_freq, end_freq;
 500
 501         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 502         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 503
 504         for (freq = start_freq; freq <= end_freq; freq += 20) {
 505                 c = ieee80211_get_channel(wiphy, freq);
 506                 if (!c || c->flags & prohibited_flags)
 507                         return false;
 508         }
 509
 510         return true;
 511 }
 512
 513 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 514                              const struct cfg80211_chan_def *chandef,
 515                              u32 prohibited_flags)
 516 {
 517         struct ieee80211_sta_ht_cap *ht_cap;
 518         struct ieee80211_sta_vht_cap *vht_cap;
 519         u32 width, control_freq;
 520
 521         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 522                 return false;
 523
 524         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 525         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 526
 527         control_freq = chandef->chan->center_freq;
 528
 529         switch (chandef->width) {
 530         case NL80211_CHAN_WIDTH_5:
 531                 width = 5;
 532                 break;
 533         case NL80211_CHAN_WIDTH_10:
 534                 width = 10;
 535                 break;
 536         case NL80211_CHAN_WIDTH_20:
 537                 if (!ht_cap->ht_supported)
 538                         return false;
 539         case NL80211_CHAN_WIDTH_20_NOHT:
 540                 width = 20;
 541                 break;
 542         case NL80211_CHAN_WIDTH_40:
 543                 width = 40;
 544                 if (!ht_cap->ht_supported)
 545                         return false;
 546                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 547                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 548                         return false;
 549                 if (chandef->center_freq1 < control_freq &&
 550                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 551                         return false;
 552                 if (chandef->center_freq1 > control_freq &&
 553                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 554                         return false;
 555                 break;
 556         case NL80211_CHAN_WIDTH_80P80:
 557                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
 558                         return false;
 559         case NL80211_CHAN_WIDTH_80:
 560                 if (!vht_cap->vht_supported)
 561                         return false;
 562                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 563                 width = 80;
 564                 break;
 565         case NL80211_CHAN_WIDTH_160:
 566                 if (!vht_cap->vht_supported)
 567                         return false;
 568                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
 569                         return false;
 570                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 571                 width = 160;
 572                 break;
 573         default:
 574                 WARN_ON_ONCE(1);
 575                 return false;
 576         }
 577
 578         /*
 579          * TODO: What if there are only certain 80/160/80+80 MHz channels
 580          *       allowed by the driver, or only certain combinations?
 581          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 582          *       80/160 MHz and in particular 80+80 MHz this isn't really
 583          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 584          *       no way to cover 80+80 MHz or more complex restrictions.
 585          *       Note that such restrictions also need to be advertised to
 586          *       userspace, for example for P2P channel selection.
 587          */
 588
 589         if (width > 20)
 590                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 591
 592         /* 5 and 10 MHz are only defined for the OFDM PHY */
 593         if (width < 20)
 594                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 595
 596
 597         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 598                                          width, prohibited_flags))
 599                 return false;
 600
 601         if (!chandef->center_freq2)
 602                 return true;
 603         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 604                                            width, prohibited_flags);
 605 }
 606 EXPORT_SYMBOL(cfg80211_chandef_usable);
 607
 608 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
 609                              struct cfg80211_chan_def *chandef)
 610 {
 611         bool res;
 612         u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
 613                                IEEE80211_CHAN_NO_IR |
 614                                IEEE80211_CHAN_RADAR;
 615
 616         trace_cfg80211_reg_can_beacon(wiphy, chandef);
 617
 618         if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 &&
 619             cfg80211_chandef_dfs_available(wiphy, chandef)) {
 620                 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
 621                 prohibited_flags = IEEE80211_CHAN_DISABLED;
 622         }
 623
 624         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
 625
 626         trace_cfg80211_return_bool(res);
 627         return res;
 628 }
 629 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 630
 631 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 632                                  struct cfg80211_chan_def *chandef)
 633 {
 634         if (!rdev->ops->set_monitor_channel)
 635                 return -EOPNOTSUPP;
 636         if (!cfg80211_has_monitors_only(rdev))
 637                 return -EBUSY;
 638
 639         return rdev_set_monitor_channel(rdev, chandef);
 640 }
 641
 642 void
 643 cfg80211_get_chan_state(struct wireless_dev *wdev,
 644                         struct ieee80211_channel **chan,
 645                         enum cfg80211_chan_mode *chanmode)
 646 {
 647         *chan = NULL;
 648         *chanmode = CHAN_MODE_UNDEFINED;
 649
 650         ASSERT_WDEV_LOCK(wdev);
 651
 652         if (wdev->netdev && !netif_running(wdev->netdev))
 653                 return;
 654
 655         switch (wdev->iftype) {
 656         case NL80211_IFTYPE_ADHOC:
 657                 if (wdev->current_bss) {
 658                         *chan = wdev->current_bss->pub.channel;
 659                         *chanmode = (wdev->ibss_fixed &&
 660                                      !wdev->ibss_dfs_possible)
 661                                   ? CHAN_MODE_SHARED
 662                                   : CHAN_MODE_EXCLUSIVE;
 663                         return;
 664                 }
 665                 break;
 666         case NL80211_IFTYPE_STATION:
 667         case NL80211_IFTYPE_P2P_CLIENT:
 668                 if (wdev->current_bss) {
 669                         *chan = wdev->current_bss->pub.channel;
 670                         *chanmode = CHAN_MODE_SHARED;
 671                         return;
 672                 }
 673                 break;
 674         case NL80211_IFTYPE_AP:
 675         case NL80211_IFTYPE_P2P_GO:
 676                 if (wdev->cac_started) {
 677                         *chan = wdev->channel;
 678                         *chanmode = CHAN_MODE_SHARED;
 679                 } else if (wdev->beacon_interval) {
 680                         *chan = wdev->channel;
 681                         *chanmode = CHAN_MODE_SHARED;
 682                 }
 683                 return;
 684         case NL80211_IFTYPE_MESH_POINT:
 685                 if (wdev->mesh_id_len) {
 686                         *chan = wdev->channel;
 687                         *chanmode = CHAN_MODE_SHARED;
 688                 }
 689                 return;
 690         case NL80211_IFTYPE_MONITOR:
 691         case NL80211_IFTYPE_AP_VLAN:
 692         case NL80211_IFTYPE_WDS:
 693                 /* these interface types don't really have a channel */
 694                 return;
 695         case NL80211_IFTYPE_P2P_DEVICE:
 696                 if (wdev->wiphy->features &
 697                                 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
 698                         *chanmode = CHAN_MODE_EXCLUSIVE;
 699                 return;
 700         case NL80211_IFTYPE_UNSPECIFIED:
 701         case NUM_NL80211_IFTYPES:
 702                 WARN_ON(1);
 703         }
 704
 705         return;
 706 }