net/wireless/chan.c

   1 /*
   2  * This file contains helper code to handle channel
   3  * settings and keeping track of what is possible at
   4  * any point in time.
   5  *
   6  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
   7  */
   8
   9 #include <linux/export.h>
  10 #include <net/cfg80211.h>
  11 #include "core.h"
  12 #include "rdev-ops.h"
  13
  14 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  15                              struct ieee80211_channel *chan,
  16                              enum nl80211_channel_type chan_type)
  17 {
  18         if (WARN_ON(!chan))
  19                 return;
  20
  21         chandef->chan = chan;
  22         chandef->center_freq2 = 0;
  23
  24         switch (chan_type) {
  25         case NL80211_CHAN_NO_HT:
  26                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  27                 chandef->center_freq1 = chan->center_freq;
  28                 break;
  29         case NL80211_CHAN_HT20:
  30                 chandef->width = NL80211_CHAN_WIDTH_20;
  31                 chandef->center_freq1 = chan->center_freq;
  32                 break;
  33         case NL80211_CHAN_HT40PLUS:
  34                 chandef->width = NL80211_CHAN_WIDTH_40;
  35                 chandef->center_freq1 = chan->center_freq + 10;
  36                 break;
  37         case NL80211_CHAN_HT40MINUS:
  38                 chandef->width = NL80211_CHAN_WIDTH_40;
  39                 chandef->center_freq1 = chan->center_freq - 10;
  40                 break;
  41         default:
  42                 WARN_ON(1);
  43         }
  44 }
  45 EXPORT_SYMBOL(cfg80211_chandef_create);
  46
  47 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
  48 {
  49         u32 control_freq;
  50
  51         if (!chandef->chan)
  52                 return false;
  53
  54         control_freq = chandef->chan->center_freq;
  55
  56         switch (chandef->width) {
  57         case NL80211_CHAN_WIDTH_5:
  58         case NL80211_CHAN_WIDTH_10:
  59         case NL80211_CHAN_WIDTH_20:
  60         case NL80211_CHAN_WIDTH_20_NOHT:
  61                 if (chandef->center_freq1 != control_freq)
  62                         return false;
  63                 if (chandef->center_freq2)
  64                         return false;
  65                 break;
  66         case NL80211_CHAN_WIDTH_40:
  67                 if (chandef->center_freq1 != control_freq + 10 &&
  68                     chandef->center_freq1 != control_freq - 10)
  69                         return false;
  70                 if (chandef->center_freq2)
  71                         return false;
  72                 break;
  73         case NL80211_CHAN_WIDTH_80P80:
  74                 if (chandef->center_freq1 != control_freq + 30 &&
  75                     chandef->center_freq1 != control_freq + 10 &&
  76                     chandef->center_freq1 != control_freq - 10 &&
  77                     chandef->center_freq1 != control_freq - 30)
  78                         return false;
  79                 if (!chandef->center_freq2)
  80                         return false;
  81                 /* adjacent is not allowed -- that's a 160 MHz channel */
  82                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
  83                     chandef->center_freq2 - chandef->center_freq1 == 80)
  84                         return false;
  85                 break;
  86         case NL80211_CHAN_WIDTH_80:
  87                 if (chandef->center_freq1 != control_freq + 30 &&
  88                     chandef->center_freq1 != control_freq + 10 &&
  89                     chandef->center_freq1 != control_freq - 10 &&
  90                     chandef->center_freq1 != control_freq - 30)
  91                         return false;
  92                 if (chandef->center_freq2)
  93                         return false;
  94                 break;
  95         case NL80211_CHAN_WIDTH_160:
  96                 if (chandef->center_freq1 != control_freq + 70 &&
  97                     chandef->center_freq1 != control_freq + 50 &&
  98                     chandef->center_freq1 != control_freq + 30 &&
  99                     chandef->center_freq1 != control_freq + 10 &&
 100                     chandef->center_freq1 != control_freq - 10 &&
 101                     chandef->center_freq1 != control_freq - 30 &&
 102                     chandef->center_freq1 != control_freq - 50 &&
 103                     chandef->center_freq1 != control_freq - 70)
 104                         return false;
 105                 if (chandef->center_freq2)
 106                         return false;
 107                 break;
 108         default:
 109                 return false;
 110         }
 111
 112         return true;
 113 }
 114 EXPORT_SYMBOL(cfg80211_chandef_valid);
 115
 116 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 117                                   int *pri40, int *pri80)
 118 {
 119         int tmp;
 120
 121         switch (c->width) {
 122         case NL80211_CHAN_WIDTH_40:
 123                 *pri40 = c->center_freq1;
 124                 *pri80 = 0;
 125                 break;
 126         case NL80211_CHAN_WIDTH_80:
 127         case NL80211_CHAN_WIDTH_80P80:
 128                 *pri80 = c->center_freq1;
 129                 /* n_P20 */
 130                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 131                 /* n_P40 */
 132                 tmp /= 2;
 133                 /* freq_P40 */
 134                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
 135                 break;
 136         case NL80211_CHAN_WIDTH_160:
 137                 /* n_P20 */
 138                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 139                 /* n_P40 */
 140                 tmp /= 2;
 141                 /* freq_P40 */
 142                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
 143                 /* n_P80 */
 144                 tmp /= 2;
 145                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
 146                 break;
 147         default:
 148                 WARN_ON_ONCE(1);
 149         }
 150 }
 151
 152 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 153 {
 154         int width;
 155
 156         switch (c->width) {
 157         case NL80211_CHAN_WIDTH_5:
 158                 width = 5;
 159                 break;
 160         case NL80211_CHAN_WIDTH_10:
 161                 width = 10;
 162                 break;
 163         case NL80211_CHAN_WIDTH_20:
 164         case NL80211_CHAN_WIDTH_20_NOHT:
 165                 width = 20;
 166                 break;
 167         case NL80211_CHAN_WIDTH_40:
 168                 width = 40;
 169                 break;
 170         case NL80211_CHAN_WIDTH_80P80:
 171         case NL80211_CHAN_WIDTH_80:
 172                 width = 80;
 173                 break;
 174         case NL80211_CHAN_WIDTH_160:
 175                 width = 160;
 176                 break;
 177         default:
 178                 WARN_ON_ONCE(1);
 179                 return -1;
 180         }
 181         return width;
 182 }
 183
 184 const struct cfg80211_chan_def *
 185 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 186                             const struct cfg80211_chan_def *c2)
 187 {
 188         u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 189
 190         /* If they are identical, return */
 191         if (cfg80211_chandef_identical(c1, c2))
 192                 return c1;
 193
 194         /* otherwise, must have same control channel */
 195         if (c1->chan != c2->chan)
 196                 return NULL;
 197
 198         /*
 199          * If they have the same width, but aren't identical,
 200          * then they can't be compatible.
 201          */
 202         if (c1->width == c2->width)
 203                 return NULL;
 204
 205         /*
 206          * can't be compatible if one of them is 5 or 10 MHz,
 207          * but they don't have the same width.
 208          */
 209         if (c1->width == NL80211_CHAN_WIDTH_5 ||
 210             c1->width == NL80211_CHAN_WIDTH_10 ||
 211             c2->width == NL80211_CHAN_WIDTH_5 ||
 212             c2->width == NL80211_CHAN_WIDTH_10)
 213                 return NULL;
 214
 215         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 216             c1->width == NL80211_CHAN_WIDTH_20)
 217                 return c2;
 218
 219         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 220             c2->width == NL80211_CHAN_WIDTH_20)
 221                 return c1;
 222
 223         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 224         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 225
 226         if (c1_pri40 != c2_pri40)
 227                 return NULL;
 228
 229         WARN_ON(!c1_pri80 && !c2_pri80);
 230         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 231                 return NULL;
 232
 233         if (c1->width > c2->width)
 234                 return c1;
 235         return c2;
 236 }
 237 EXPORT_SYMBOL(cfg80211_chandef_compatible);
 238
 239 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 240                                          u32 bandwidth,
 241                                          enum nl80211_dfs_state dfs_state)
 242 {
 243         struct ieee80211_channel *c;
 244         u32 freq;
 245
 246         for (freq = center_freq - bandwidth/2 + 10;
 247              freq <= center_freq + bandwidth/2 - 10;
 248              freq += 20) {
 249                 c = ieee80211_get_channel(wiphy, freq);
 250                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 251                         continue;
 252
 253                 c->dfs_state = dfs_state;
 254                 c->dfs_state_entered = jiffies;
 255         }
 256 }
 257
 258 void cfg80211_set_dfs_state(struct wiphy *wiphy,
 259                             const struct cfg80211_chan_def *chandef,
 260                             enum nl80211_dfs_state dfs_state)
 261 {
 262         int width;
 263
 264         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 265                 return;
 266
 267         width = cfg80211_chandef_get_width(chandef);
 268         if (width < 0)
 269                 return;
 270
 271         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 272                                      width, dfs_state);
 273
 274         if (!chandef->center_freq2)
 275                 return;
 276         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 277                                      width, dfs_state);
 278 }
 279
 280 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 281                                             u32 center_freq,
 282                                             u32 bandwidth)
 283 {
 284         struct ieee80211_channel *c;
 285         u32 freq, start_freq, end_freq;
 286
 287         if (bandwidth <= 20) {
 288                 start_freq = center_freq;
 289                 end_freq = center_freq;
 290         } else {
 291                 start_freq = center_freq - bandwidth/2 + 10;
 292                 end_freq = center_freq + bandwidth/2 - 10;
 293         }
 294
 295         for (freq = start_freq; freq <= end_freq; freq += 20) {
 296                 c = ieee80211_get_channel(wiphy, freq);
 297                 if (!c)
 298                         return -EINVAL;
 299
 300                 if (c->flags & IEEE80211_CHAN_RADAR)
 301                         return 1;
 302         }
 303         return 0;
 304 }
 305
 306
 307 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 308                                   const struct cfg80211_chan_def *chandef)
 309 {
 310         int width;
 311         int r;
 312
 313         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 314                 return -EINVAL;
 315
 316         width = cfg80211_chandef_get_width(chandef);
 317         if (width < 0)
 318                 return -EINVAL;
 319
 320         r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1,
 321                                             width);
 322         if (r)
 323                 return r;
 324
 325         if (!chandef->center_freq2)
 326                 return 0;
 327
 328         return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2,
 329                                                width);
 330 }
 331
 332 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 333                                         u32 center_freq, u32 bandwidth,
 334                                         u32 prohibited_flags)
 335 {
 336         struct ieee80211_channel *c;
 337         u32 freq, start_freq, end_freq;
 338
 339         if (bandwidth <= 20) {
 340                 start_freq = center_freq;
 341                 end_freq = center_freq;
 342         } else {
 343                 start_freq = center_freq - bandwidth/2 + 10;
 344                 end_freq = center_freq + bandwidth/2 - 10;
 345         }
 346
 347         for (freq = start_freq; freq <= end_freq; freq += 20) {
 348                 c = ieee80211_get_channel(wiphy, freq);
 349                 if (!c)
 350                         return false;
 351
 352                 /* check for radar flags */
 353                 if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) &&
 354                     (c->dfs_state != NL80211_DFS_AVAILABLE))
 355                         return false;
 356
 357                 /* check for the other flags */
 358                 if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR)
 359                         return false;
 360         }
 361
 362         return true;
 363 }
 364
 365 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 366                              const struct cfg80211_chan_def *chandef,
 367                              u32 prohibited_flags)
 368 {
 369         struct ieee80211_sta_ht_cap *ht_cap;
 370         struct ieee80211_sta_vht_cap *vht_cap;
 371         u32 width, control_freq;
 372
 373         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 374                 return false;
 375
 376         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 377         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 378
 379         control_freq = chandef->chan->center_freq;
 380
 381         switch (chandef->width) {
 382         case NL80211_CHAN_WIDTH_5:
 383                 width = 5;
 384                 break;
 385         case NL80211_CHAN_WIDTH_10:
 386                 width = 10;
 387                 break;
 388         case NL80211_CHAN_WIDTH_20:
 389                 if (!ht_cap->ht_supported)
 390                         return false;
 391         case NL80211_CHAN_WIDTH_20_NOHT:
 392                 width = 20;
 393                 break;
 394         case NL80211_CHAN_WIDTH_40:
 395                 width = 40;
 396                 if (!ht_cap->ht_supported)
 397                         return false;
 398                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 399                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 400                         return false;
 401                 if (chandef->center_freq1 < control_freq &&
 402                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 403                         return false;
 404                 if (chandef->center_freq1 > control_freq &&
 405                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 406                         return false;
 407                 break;
 408         case NL80211_CHAN_WIDTH_80P80:
 409                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
 410                         return false;
 411         case NL80211_CHAN_WIDTH_80:
 412                 if (!vht_cap->vht_supported)
 413                         return false;
 414                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 415                 width = 80;
 416                 break;
 417         case NL80211_CHAN_WIDTH_160:
 418                 if (!vht_cap->vht_supported)
 419                         return false;
 420                 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
 421                         return false;
 422                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 423                 width = 160;
 424                 break;
 425         default:
 426                 WARN_ON_ONCE(1);
 427                 return false;
 428         }
 429
 430         /*
 431          * TODO: What if there are only certain 80/160/80+80 MHz channels
 432          *       allowed by the driver, or only certain combinations?
 433          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 434          *       80/160 MHz and in particular 80+80 MHz this isn't really
 435          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 436          *       no way to cover 80+80 MHz or more complex restrictions.
 437          *       Note that such restrictions also need to be advertised to
 438          *       userspace, for example for P2P channel selection.
 439          */
 440
 441         if (width > 20)
 442                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 443
 444         /* 5 and 10 MHz are only defined for the OFDM PHY */
 445         if (width < 20)
 446                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 447
 448
 449         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 450                                          width, prohibited_flags))
 451                 return false;
 452
 453         if (!chandef->center_freq2)
 454                 return true;
 455         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 456                                            width, prohibited_flags);
 457 }
 458 EXPORT_SYMBOL(cfg80211_chandef_usable);
 459
 460 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
 461                              struct cfg80211_chan_def *chandef)
 462 {
 463         bool res;
 464
 465         trace_cfg80211_reg_can_beacon(wiphy, chandef);
 466
 467         res = cfg80211_chandef_usable(wiphy, chandef,
 468                                       IEEE80211_CHAN_DISABLED |
 469                                       IEEE80211_CHAN_PASSIVE_SCAN |
 470                                       IEEE80211_CHAN_NO_IBSS |
 471                                       IEEE80211_CHAN_RADAR);
 472
 473         trace_cfg80211_return_bool(res);
 474         return res;
 475 }
 476 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
 477
 478 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 479                                  struct cfg80211_chan_def *chandef)
 480 {
 481         if (!rdev->ops->set_monitor_channel)
 482                 return -EOPNOTSUPP;
 483         if (!cfg80211_has_monitors_only(rdev))
 484                 return -EBUSY;
 485
 486         return rdev_set_monitor_channel(rdev, chandef);
 487 }
 488
 489 void
 490 cfg80211_get_chan_state(struct wireless_dev *wdev,
 491                         struct ieee80211_channel **chan,
 492                         enum cfg80211_chan_mode *chanmode)
 493 {
 494         *chan = NULL;
 495         *chanmode = CHAN_MODE_UNDEFINED;
 496
 497         ASSERT_WDEV_LOCK(wdev);
 498
 499         if (wdev->netdev && !netif_running(wdev->netdev))
 500                 return;
 501
 502         switch (wdev->iftype) {
 503         case NL80211_IFTYPE_ADHOC:
 504                 if (wdev->current_bss) {
 505                         *chan = wdev->current_bss->pub.channel;
 506                         *chanmode = wdev->ibss_fixed
 507                                   ? CHAN_MODE_SHARED
 508                                   : CHAN_MODE_EXCLUSIVE;
 509                         return;
 510                 }
 511         case NL80211_IFTYPE_STATION:
 512         case NL80211_IFTYPE_P2P_CLIENT:
 513                 if (wdev->current_bss) {
 514                         *chan = wdev->current_bss->pub.channel;
 515                         *chanmode = CHAN_MODE_SHARED;
 516                         return;
 517                 }
 518                 break;
 519         case NL80211_IFTYPE_AP:
 520         case NL80211_IFTYPE_P2P_GO:
 521                 if (wdev->cac_started) {
 522                         *chan = wdev->channel;
 523                         *chanmode = CHAN_MODE_SHARED;
 524                 } else if (wdev->beacon_interval) {
 525                         *chan = wdev->channel;
 526                         *chanmode = CHAN_MODE_SHARED;
 527                 }
 528                 return;
 529         case NL80211_IFTYPE_MESH_POINT:
 530                 if (wdev->mesh_id_len) {
 531                         *chan = wdev->channel;
 532                         *chanmode = CHAN_MODE_SHARED;
 533                 }
 534                 return;
 535         case NL80211_IFTYPE_MONITOR:
 536         case NL80211_IFTYPE_AP_VLAN:
 537         case NL80211_IFTYPE_WDS:
 538                 /* these interface types don't really have a channel */
 539                 return;
 540         case NL80211_IFTYPE_P2P_DEVICE:
 541                 if (wdev->wiphy->features &
 542                                 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
 543                         *chanmode = CHAN_MODE_EXCLUSIVE;
 544                 return;
 545         case NL80211_IFTYPE_UNSPECIFIED:
 546         case NUM_NL80211_IFTYPES:
 547                 WARN_ON(1);
 548         }
 549
 550         return;
 551 }