net/mac80211/chan.c

   1 /*
   2  * mac80211 - channel management
   3  */
   4
   5 #include <linux/nl80211.h>
   6 #include <linux/export.h>
   7 #include <linux/rtnetlink.h>
   8 #include <net/cfg80211.h>
   9 #include "ieee80211_i.h"
  10 #include "driver-ops.h"
  11
  12 static int ieee80211_chanctx_num_assigned(struct ieee80211_local *local,
  13                                           struct ieee80211_chanctx *ctx)
  14 {
  15         struct ieee80211_sub_if_data *sdata;
  16         int num = 0;
  17
  18         lockdep_assert_held(&local->chanctx_mtx);
  19
  20         list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
  21                 num++;
  22
  23         return num;
  24 }
  25
  26 static int ieee80211_chanctx_num_reserved(struct ieee80211_local *local,
  27                                           struct ieee80211_chanctx *ctx)
  28 {
  29         struct ieee80211_sub_if_data *sdata;
  30         int num = 0;
  31
  32         lockdep_assert_held(&local->chanctx_mtx);
  33
  34         list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
  35                 num++;
  36
  37         return num;
  38 }
  39
  40 int ieee80211_chanctx_refcount(struct ieee80211_local *local,
  41                                struct ieee80211_chanctx *ctx)
  42 {
  43         return ieee80211_chanctx_num_assigned(local, ctx) +
  44                ieee80211_chanctx_num_reserved(local, ctx);
  45 }
  46
  47 static int ieee80211_num_chanctx(struct ieee80211_local *local)
  48 {
  49         struct ieee80211_chanctx *ctx;
  50         int num = 0;
  51
  52         lockdep_assert_held(&local->chanctx_mtx);
  53
  54         list_for_each_entry(ctx, &local->chanctx_list, list)
  55                 num++;
  56
  57         return num;
  58 }
  59
  60 static bool ieee80211_can_create_new_chanctx(struct ieee80211_local *local)
  61 {
  62         lockdep_assert_held(&local->chanctx_mtx);
  63         return ieee80211_num_chanctx(local) < ieee80211_max_num_channels(local);
  64 }
  65
  66 static const struct cfg80211_chan_def *
  67 ieee80211_chanctx_reserved_chandef(struct ieee80211_local *local,
  68                                    struct ieee80211_chanctx *ctx,
  69                                    const struct cfg80211_chan_def *compat)
  70 {
  71         struct ieee80211_sub_if_data *sdata;
  72
  73         lockdep_assert_held(&local->chanctx_mtx);
  74
  75         list_for_each_entry(sdata, &ctx->reserved_vifs,
  76                             reserved_chanctx_list) {
  77                 if (!compat)
  78                         compat = &sdata->reserved_chandef;
  79
  80                 compat = cfg80211_chandef_compatible(&sdata->reserved_chandef,
  81                                                      compat);
  82                 if (!compat)
  83                         break;
  84         }
  85
  86         return compat;
  87 }
  88
  89 static const struct cfg80211_chan_def *
  90 ieee80211_chanctx_non_reserved_chandef(struct ieee80211_local *local,
  91                                        struct ieee80211_chanctx *ctx,
  92                                        const struct cfg80211_chan_def *compat)
  93 {
  94         struct ieee80211_sub_if_data *sdata;
  95
  96         lockdep_assert_held(&local->chanctx_mtx);
  97
  98         list_for_each_entry(sdata, &ctx->assigned_vifs,
  99                             assigned_chanctx_list) {
 100                 if (sdata->reserved_chanctx != NULL)
 101                         continue;
 102
 103                 if (!compat)
 104                         compat = &sdata->vif.bss_conf.chandef;
 105
 106                 compat = cfg80211_chandef_compatible(
 107                                 &sdata->vif.bss_conf.chandef, compat);
 108                 if (!compat)
 109                         break;
 110         }
 111
 112         return compat;
 113 }
 114
 115 static const struct cfg80211_chan_def *
 116 ieee80211_chanctx_combined_chandef(struct ieee80211_local *local,
 117                                    struct ieee80211_chanctx *ctx,
 118                                    const struct cfg80211_chan_def *compat)
 119 {
 120         lockdep_assert_held(&local->chanctx_mtx);
 121
 122         compat = ieee80211_chanctx_reserved_chandef(local, ctx, compat);
 123         if (!compat)
 124                 return NULL;
 125
 126         compat = ieee80211_chanctx_non_reserved_chandef(local, ctx, compat);
 127         if (!compat)
 128                 return NULL;
 129
 130         return compat;
 131 }
 132
 133 static bool
 134 ieee80211_chanctx_can_reserve_chandef(struct ieee80211_local *local,
 135                                       struct ieee80211_chanctx *ctx,
 136                                       const struct cfg80211_chan_def *def)
 137 {
 138         lockdep_assert_held(&local->chanctx_mtx);
 139
 140         if (ieee80211_chanctx_combined_chandef(local, ctx, def))
 141                 return true;
 142
 143         if (!list_empty(&ctx->reserved_vifs) &&
 144             ieee80211_chanctx_reserved_chandef(local, ctx, def))
 145                 return true;
 146
 147         return false;
 148 }
 149
 150 static struct ieee80211_chanctx *
 151 ieee80211_find_reservation_chanctx(struct ieee80211_local *local,
 152                                    const struct cfg80211_chan_def *chandef,
 153                                    enum ieee80211_chanctx_mode mode)
 154 {
 155         struct ieee80211_chanctx *ctx;
 156
 157         lockdep_assert_held(&local->chanctx_mtx);
 158
 159         if (mode == IEEE80211_CHANCTX_EXCLUSIVE)
 160                 return NULL;
 161
 162         list_for_each_entry(ctx, &local->chanctx_list, list) {
 163                 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE)
 164                         continue;
 165
 166                 if (!ieee80211_chanctx_can_reserve_chandef(local, ctx,
 167                                                            chandef))
 168                         continue;
 169
 170                 return ctx;
 171         }
 172
 173         return NULL;
 174 }
 175
 176 static enum nl80211_chan_width ieee80211_get_sta_bw(struct ieee80211_sta *sta)
 177 {
 178         switch (sta->bandwidth) {
 179         case IEEE80211_STA_RX_BW_20:
 180                 if (sta->ht_cap.ht_supported)
 181                         return NL80211_CHAN_WIDTH_20;
 182                 else
 183                         return NL80211_CHAN_WIDTH_20_NOHT;
 184         case IEEE80211_STA_RX_BW_40:
 185                 return NL80211_CHAN_WIDTH_40;
 186         case IEEE80211_STA_RX_BW_80:
 187                 return NL80211_CHAN_WIDTH_80;
 188         case IEEE80211_STA_RX_BW_160:
 189                 /*
 190                  * This applied for both 160 and 80+80. since we use
 191                  * the returned value to consider degradation of
 192                  * ctx->conf.min_def, we have to make sure to take
 193                  * the bigger one (NL80211_CHAN_WIDTH_160).
 194                  * Otherwise we might try degrading even when not
 195                  * needed, as the max required sta_bw returned (80+80)
 196                  * might be smaller than the configured bw (160).
 197                  */
 198                 return NL80211_CHAN_WIDTH_160;
 199         default:
 200                 WARN_ON(1);
 201                 return NL80211_CHAN_WIDTH_20;
 202         }
 203 }
 204
 205 static enum nl80211_chan_width
 206 ieee80211_get_max_required_bw(struct ieee80211_sub_if_data *sdata)
 207 {
 208         enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
 209         struct sta_info *sta;
 210
 211         rcu_read_lock();
 212         list_for_each_entry_rcu(sta, &sdata->local->sta_list, list) {
 213                 if (sdata != sta->sdata &&
 214                     !(sta->sdata->bss && sta->sdata->bss == sdata->bss))
 215                         continue;
 216
 217                 if (!sta->uploaded)
 218                         continue;
 219
 220                 max_bw = max(max_bw, ieee80211_get_sta_bw(&sta->sta));
 221         }
 222         rcu_read_unlock();
 223
 224         return max_bw;
 225 }
 226
 227 static enum nl80211_chan_width
 228 ieee80211_get_chanctx_max_required_bw(struct ieee80211_local *local,
 229                                       struct ieee80211_chanctx_conf *conf)
 230 {
 231         struct ieee80211_sub_if_data *sdata;
 232         enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
 233
 234         rcu_read_lock();
 235         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 236                 struct ieee80211_vif *vif = &sdata->vif;
 237                 enum nl80211_chan_width width = NL80211_CHAN_WIDTH_20_NOHT;
 238
 239                 if (!ieee80211_sdata_running(sdata))
 240                         continue;
 241
 242                 if (rcu_access_pointer(sdata->vif.chanctx_conf) != conf)
 243                         continue;
 244
 245                 switch (vif->type) {
 246                 case NL80211_IFTYPE_AP:
 247                 case NL80211_IFTYPE_AP_VLAN:
 248                         width = ieee80211_get_max_required_bw(sdata);
 249                         break;
 250                 case NL80211_IFTYPE_P2P_DEVICE:
 251                         continue;
 252                 case NL80211_IFTYPE_STATION:
 253                 case NL80211_IFTYPE_ADHOC:
 254                 case NL80211_IFTYPE_WDS:
 255                 case NL80211_IFTYPE_MESH_POINT:
 256                         width = vif->bss_conf.chandef.width;
 257                         break;
 258                 case NL80211_IFTYPE_UNSPECIFIED:
 259                 case NUM_NL80211_IFTYPES:
 260                 case NL80211_IFTYPE_MONITOR:
 261                 case NL80211_IFTYPE_P2P_CLIENT:
 262                 case NL80211_IFTYPE_P2P_GO:
 263                         WARN_ON_ONCE(1);
 264                 }
 265                 max_bw = max(max_bw, width);
 266         }
 267
 268         /* use the configured bandwidth in case of monitor interface */
 269         sdata = rcu_dereference(local->monitor_sdata);
 270         if (sdata && rcu_access_pointer(sdata->vif.chanctx_conf) == conf)
 271                 max_bw = max(max_bw, conf->def.width);
 272
 273         rcu_read_unlock();
 274
 275         return max_bw;
 276 }
 277
 278 /*
 279  * recalc the min required chan width of the channel context, which is
 280  * the max of min required widths of all the interfaces bound to this
 281  * channel context.
 282  */
 283 void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
 284                                       struct ieee80211_chanctx *ctx)
 285 {
 286         enum nl80211_chan_width max_bw;
 287         struct cfg80211_chan_def min_def;
 288
 289         lockdep_assert_held(&local->chanctx_mtx);
 290
 291         /* don't optimize 5MHz, 10MHz, and radar_enabled confs */
 292         if (ctx->conf.def.width == NL80211_CHAN_WIDTH_5 ||
 293             ctx->conf.def.width == NL80211_CHAN_WIDTH_10 ||
 294             ctx->conf.radar_enabled) {
 295                 ctx->conf.min_def = ctx->conf.def;
 296                 return;
 297         }
 298
 299         max_bw = ieee80211_get_chanctx_max_required_bw(local, &ctx->conf);
 300
 301         /* downgrade chandef up to max_bw */
 302         min_def = ctx->conf.def;
 303         while (min_def.width > max_bw)
 304                 ieee80211_chandef_downgrade(&min_def);
 305
 306         if (cfg80211_chandef_identical(&ctx->conf.min_def, &min_def))
 307                 return;
 308
 309         ctx->conf.min_def = min_def;
 310         if (!ctx->driver_present)
 311                 return;
 312
 313         drv_change_chanctx(local, ctx, IEEE80211_CHANCTX_CHANGE_MIN_WIDTH);
 314 }
 315
 316 static void ieee80211_change_chanctx(struct ieee80211_local *local,
 317                                      struct ieee80211_chanctx *ctx,
 318                                      const struct cfg80211_chan_def *chandef)
 319 {
 320         if (cfg80211_chandef_identical(&ctx->conf.def, chandef))
 321                 return;
 322
 323         WARN_ON(!cfg80211_chandef_compatible(&ctx->conf.def, chandef));
 324
 325         ctx->conf.def = *chandef;
 326         drv_change_chanctx(local, ctx, IEEE80211_CHANCTX_CHANGE_WIDTH);
 327         ieee80211_recalc_chanctx_min_def(local, ctx);
 328
 329         if (!local->use_chanctx) {
 330                 local->_oper_chandef = *chandef;
 331                 ieee80211_hw_config(local, 0);
 332         }
 333 }
 334
 335 static struct ieee80211_chanctx *
 336 ieee80211_find_chanctx(struct ieee80211_local *local,
 337                        const struct cfg80211_chan_def *chandef,
 338                        enum ieee80211_chanctx_mode mode)
 339 {
 340         struct ieee80211_chanctx *ctx;
 341
 342         lockdep_assert_held(&local->chanctx_mtx);
 343
 344         if (mode == IEEE80211_CHANCTX_EXCLUSIVE)
 345                 return NULL;
 346
 347         list_for_each_entry(ctx, &local->chanctx_list, list) {
 348                 const struct cfg80211_chan_def *compat;
 349
 350                 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE)
 351                         continue;
 352
 353                 compat = cfg80211_chandef_compatible(&ctx->conf.def, chandef);
 354                 if (!compat)
 355                         continue;
 356
 357                 compat = ieee80211_chanctx_reserved_chandef(local, ctx,
 358                                                             compat);
 359                 if (!compat)
 360                         continue;
 361
 362                 ieee80211_change_chanctx(local, ctx, compat);
 363
 364                 return ctx;
 365         }
 366
 367         return NULL;
 368 }
 369
 370 static bool ieee80211_is_radar_required(struct ieee80211_local *local)
 371 {
 372         struct ieee80211_sub_if_data *sdata;
 373
 374         lockdep_assert_held(&local->mtx);
 375
 376         rcu_read_lock();
 377         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 378                 if (sdata->radar_required) {
 379                         rcu_read_unlock();
 380                         return true;
 381                 }
 382         }
 383         rcu_read_unlock();
 384
 385         return false;
 386 }
 387
 388 static struct ieee80211_chanctx *
 389 ieee80211_alloc_chanctx(struct ieee80211_local *local,
 390                         const struct cfg80211_chan_def *chandef,
 391                         enum ieee80211_chanctx_mode mode)
 392 {
 393         struct ieee80211_chanctx *ctx;
 394
 395         lockdep_assert_held(&local->chanctx_mtx);
 396
 397         ctx = kzalloc(sizeof(*ctx) + local->hw.chanctx_data_size, GFP_KERNEL);
 398         if (!ctx)
 399                 return NULL;
 400
 401         INIT_LIST_HEAD(&ctx->assigned_vifs);
 402         INIT_LIST_HEAD(&ctx->reserved_vifs);
 403         ctx->conf.def = *chandef;
 404         ctx->conf.rx_chains_static = 1;
 405         ctx->conf.rx_chains_dynamic = 1;
 406         ctx->mode = mode;
 407         ctx->conf.radar_enabled = ieee80211_is_radar_required(local);
 408         ieee80211_recalc_chanctx_min_def(local, ctx);
 409
 410         return ctx;
 411 }
 412
 413 static int ieee80211_add_chanctx(struct ieee80211_local *local,
 414                                  struct ieee80211_chanctx *ctx)
 415 {
 416         u32 changed;
 417         int err;
 418
 419         lockdep_assert_held(&local->mtx);
 420         lockdep_assert_held(&local->chanctx_mtx);
 421
 422         if (!local->use_chanctx)
 423                 local->hw.conf.radar_enabled = ctx->conf.radar_enabled;
 424
 425         /* turn idle off *before* setting channel -- some drivers need that */
 426         changed = ieee80211_idle_off(local);
 427         if (changed)
 428                 ieee80211_hw_config(local, changed);
 429
 430         if (!local->use_chanctx) {
 431                 local->_oper_chandef = ctx->conf.def;
 432                 ieee80211_hw_config(local, 0);
 433         } else {
 434                 err = drv_add_chanctx(local, ctx);
 435                 if (err) {
 436                         ieee80211_recalc_idle(local);
 437                         return err;
 438                 }
 439         }
 440
 441         return 0;
 442 }
 443
 444 static struct ieee80211_chanctx *
 445 ieee80211_new_chanctx(struct ieee80211_local *local,
 446                       const struct cfg80211_chan_def *chandef,
 447                       enum ieee80211_chanctx_mode mode)
 448 {
 449         struct ieee80211_chanctx *ctx;
 450         int err;
 451
 452         lockdep_assert_held(&local->mtx);
 453         lockdep_assert_held(&local->chanctx_mtx);
 454
 455         ctx = ieee80211_alloc_chanctx(local, chandef, mode);
 456         if (!ctx)
 457                 return ERR_PTR(-ENOMEM);
 458
 459         err = ieee80211_add_chanctx(local, ctx);
 460         if (err) {
 461                 kfree(ctx);
 462                 return ERR_PTR(err);
 463         }
 464
 465         list_add_rcu(&ctx->list, &local->chanctx_list);
 466         return ctx;
 467 }
 468
 469 static void ieee80211_del_chanctx(struct ieee80211_local *local,
 470                                   struct ieee80211_chanctx *ctx)
 471 {
 472         lockdep_assert_held(&local->chanctx_mtx);
 473
 474         if (!local->use_chanctx) {
 475                 struct cfg80211_chan_def *chandef = &local->_oper_chandef;
 476                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
 477                 chandef->center_freq1 = chandef->chan->center_freq;
 478                 chandef->center_freq2 = 0;
 479
 480                 /* NOTE: Disabling radar is only valid here for
 481                  * single channel context. To be sure, check it ...
 482                  */
 483                 WARN_ON(local->hw.conf.radar_enabled &&
 484                         !list_empty(&local->chanctx_list));
 485
 486                 local->hw.conf.radar_enabled = false;
 487
 488                 ieee80211_hw_config(local, 0);
 489         } else {
 490                 drv_remove_chanctx(local, ctx);
 491         }
 492
 493         ieee80211_recalc_idle(local);
 494 }
 495
 496 static void ieee80211_free_chanctx(struct ieee80211_local *local,
 497                                    struct ieee80211_chanctx *ctx)
 498 {
 499         lockdep_assert_held(&local->chanctx_mtx);
 500
 501         WARN_ON_ONCE(ieee80211_chanctx_refcount(local, ctx) != 0);
 502
 503         list_del_rcu(&ctx->list);
 504         ieee80211_del_chanctx(local, ctx);
 505         kfree_rcu(ctx, rcu_head);
 506 }
 507
 508 static void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
 509                                               struct ieee80211_chanctx *ctx)
 510 {
 511         struct ieee80211_chanctx_conf *conf = &ctx->conf;
 512         struct ieee80211_sub_if_data *sdata;
 513         const struct cfg80211_chan_def *compat = NULL;
 514
 515         lockdep_assert_held(&local->chanctx_mtx);
 516
 517         rcu_read_lock();
 518         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 519
 520                 if (!ieee80211_sdata_running(sdata))
 521                         continue;
 522                 if (rcu_access_pointer(sdata->vif.chanctx_conf) != conf)
 523                         continue;
 524
 525                 if (!compat)
 526                         compat = &sdata->vif.bss_conf.chandef;
 527
 528                 compat = cfg80211_chandef_compatible(
 529                                 &sdata->vif.bss_conf.chandef, compat);
 530                 if (!compat)
 531                         break;
 532         }
 533         rcu_read_unlock();
 534
 535         if (WARN_ON_ONCE(!compat))
 536                 return;
 537
 538         ieee80211_change_chanctx(local, ctx, compat);
 539 }
 540
 541 static void ieee80211_recalc_radar_chanctx(struct ieee80211_local *local,
 542                                            struct ieee80211_chanctx *chanctx)
 543 {
 544         bool radar_enabled;
 545
 546         lockdep_assert_held(&local->chanctx_mtx);
 547         /* for setting local->radar_detect_enabled */
 548         lockdep_assert_held(&local->mtx);
 549
 550         radar_enabled = ieee80211_is_radar_required(local);
 551
 552         if (radar_enabled == chanctx->conf.radar_enabled)
 553                 return;
 554
 555         chanctx->conf.radar_enabled = radar_enabled;
 556         local->radar_detect_enabled = chanctx->conf.radar_enabled;
 557
 558         if (!local->use_chanctx) {
 559                 local->hw.conf.radar_enabled = chanctx->conf.radar_enabled;
 560                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 561         }
 562
 563         drv_change_chanctx(local, chanctx, IEEE80211_CHANCTX_CHANGE_RADAR);
 564 }
 565
 566 static int ieee80211_assign_vif_chanctx(struct ieee80211_sub_if_data *sdata,
 567                                         struct ieee80211_chanctx *new_ctx)
 568 {
 569         struct ieee80211_local *local = sdata->local;
 570         struct ieee80211_chanctx_conf *conf;
 571         struct ieee80211_chanctx *curr_ctx = NULL;
 572         int ret = 0;
 573
 574         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 575                                          lockdep_is_held(&local->chanctx_mtx));
 576
 577         if (conf) {
 578                 curr_ctx = container_of(conf, struct ieee80211_chanctx, conf);
 579
 580                 drv_unassign_vif_chanctx(local, sdata, curr_ctx);
 581                 conf = NULL;
 582                 list_del(&sdata->assigned_chanctx_list);
 583         }
 584
 585         if (new_ctx) {
 586                 ret = drv_assign_vif_chanctx(local, sdata, new_ctx);
 587                 if (ret)
 588                         goto out;
 589
 590                 conf = &new_ctx->conf;
 591                 list_add(&sdata->assigned_chanctx_list,
 592                          &new_ctx->assigned_vifs);
 593         }
 594
 595 out:
 596         rcu_assign_pointer(sdata->vif.chanctx_conf, conf);
 597
 598         sdata->vif.bss_conf.idle = !conf;
 599
 600         if (curr_ctx && ieee80211_chanctx_num_assigned(local, curr_ctx) > 0) {
 601                 ieee80211_recalc_chanctx_chantype(local, curr_ctx);
 602                 ieee80211_recalc_smps_chanctx(local, curr_ctx);
 603                 ieee80211_recalc_radar_chanctx(local, curr_ctx);
 604                 ieee80211_recalc_chanctx_min_def(local, curr_ctx);
 605         }
 606
 607         if (new_ctx && ieee80211_chanctx_num_assigned(local, new_ctx) > 0) {
 608                 ieee80211_recalc_txpower(sdata);
 609                 ieee80211_recalc_chanctx_min_def(local, new_ctx);
 610         }
 611
 612         if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
 613             sdata->vif.type != NL80211_IFTYPE_MONITOR)
 614                 ieee80211_bss_info_change_notify(sdata,
 615                                                  BSS_CHANGED_IDLE);
 616
 617         return ret;
 618 }
 619
 620 static void __ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata)
 621 {
 622         struct ieee80211_local *local = sdata->local;
 623         struct ieee80211_chanctx_conf *conf;
 624         struct ieee80211_chanctx *ctx;
 625
 626         lockdep_assert_held(&local->chanctx_mtx);
 627
 628         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 629                                          lockdep_is_held(&local->chanctx_mtx));
 630         if (!conf)
 631                 return;
 632
 633         ctx = container_of(conf, struct ieee80211_chanctx, conf);
 634
 635         if (sdata->reserved_chanctx)
 636                 ieee80211_vif_unreserve_chanctx(sdata);
 637
 638         ieee80211_assign_vif_chanctx(sdata, NULL);
 639         if (ieee80211_chanctx_refcount(local, ctx) == 0)
 640                 ieee80211_free_chanctx(local, ctx);
 641 }
 642
 643 void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
 644                                    struct ieee80211_chanctx *chanctx)
 645 {
 646         struct ieee80211_sub_if_data *sdata;
 647         u8 rx_chains_static, rx_chains_dynamic;
 648
 649         lockdep_assert_held(&local->chanctx_mtx);
 650
 651         rx_chains_static = 1;
 652         rx_chains_dynamic = 1;
 653
 654         rcu_read_lock();
 655         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 656                 u8 needed_static, needed_dynamic;
 657
 658                 if (!ieee80211_sdata_running(sdata))
 659                         continue;
 660
 661                 if (rcu_access_pointer(sdata->vif.chanctx_conf) !=
 662                                                 &chanctx->conf)
 663                         continue;
 664
 665                 switch (sdata->vif.type) {
 666                 case NL80211_IFTYPE_P2P_DEVICE:
 667                         continue;
 668                 case NL80211_IFTYPE_STATION:
 669                         if (!sdata->u.mgd.associated)
 670                                 continue;
 671                         break;
 672                 case NL80211_IFTYPE_AP_VLAN:
 673                         continue;
 674                 case NL80211_IFTYPE_AP:
 675                 case NL80211_IFTYPE_ADHOC:
 676                 case NL80211_IFTYPE_WDS:
 677                 case NL80211_IFTYPE_MESH_POINT:
 678                         break;
 679                 default:
 680                         WARN_ON_ONCE(1);
 681                 }
 682
 683                 switch (sdata->smps_mode) {
 684                 default:
 685                         WARN_ONCE(1, "Invalid SMPS mode %d\n",
 686                                   sdata->smps_mode);
 687                         /* fall through */
 688                 case IEEE80211_SMPS_OFF:
 689                         needed_static = sdata->needed_rx_chains;
 690                         needed_dynamic = sdata->needed_rx_chains;
 691                         break;
 692                 case IEEE80211_SMPS_DYNAMIC:
 693                         needed_static = 1;
 694                         needed_dynamic = sdata->needed_rx_chains;
 695                         break;
 696                 case IEEE80211_SMPS_STATIC:
 697                         needed_static = 1;
 698                         needed_dynamic = 1;
 699                         break;
 700                 }
 701
 702                 rx_chains_static = max(rx_chains_static, needed_static);
 703                 rx_chains_dynamic = max(rx_chains_dynamic, needed_dynamic);
 704         }
 705         rcu_read_unlock();
 706
 707         if (!local->use_chanctx) {
 708                 if (rx_chains_static > 1)
 709                         local->smps_mode = IEEE80211_SMPS_OFF;
 710                 else if (rx_chains_dynamic > 1)
 711                         local->smps_mode = IEEE80211_SMPS_DYNAMIC;
 712                 else
 713                         local->smps_mode = IEEE80211_SMPS_STATIC;
 714                 ieee80211_hw_config(local, 0);
 715         }
 716
 717         if (rx_chains_static == chanctx->conf.rx_chains_static &&
 718             rx_chains_dynamic == chanctx->conf.rx_chains_dynamic)
 719                 return;
 720
 721         chanctx->conf.rx_chains_static = rx_chains_static;
 722         chanctx->conf.rx_chains_dynamic = rx_chains_dynamic;
 723         drv_change_chanctx(local, chanctx, IEEE80211_CHANCTX_CHANGE_RX_CHAINS);
 724 }
 725
 726 int ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
 727                               const struct cfg80211_chan_def *chandef,
 728                               enum ieee80211_chanctx_mode mode)
 729 {
 730         struct ieee80211_local *local = sdata->local;
 731         struct ieee80211_chanctx *ctx;
 732         u8 radar_detect_width = 0;
 733         int ret;
 734
 735         lockdep_assert_held(&local->mtx);
 736
 737         WARN_ON(sdata->dev && netif_carrier_ok(sdata->dev));
 738
 739         mutex_lock(&local->chanctx_mtx);
 740
 741         ret = cfg80211_chandef_dfs_required(local->hw.wiphy,
 742                                             chandef,
 743                                             sdata->wdev.iftype);
 744         if (ret < 0)
 745                 goto out;
 746         if (ret > 0)
 747                 radar_detect_width = BIT(chandef->width);
 748
 749         sdata->radar_required = ret;
 750
 751         ret = ieee80211_check_combinations(sdata, chandef, mode,
 752                                            radar_detect_width);
 753         if (ret < 0)
 754                 goto out;
 755
 756         __ieee80211_vif_release_channel(sdata);
 757
 758         ctx = ieee80211_find_chanctx(local, chandef, mode);
 759         if (!ctx)
 760                 ctx = ieee80211_new_chanctx(local, chandef, mode);
 761         if (IS_ERR(ctx)) {
 762                 ret = PTR_ERR(ctx);
 763                 goto out;
 764         }
 765
 766         sdata->vif.bss_conf.chandef = *chandef;
 767
 768         ret = ieee80211_assign_vif_chanctx(sdata, ctx);
 769         if (ret) {
 770                 /* if assign fails refcount stays the same */
 771                 if (ieee80211_chanctx_refcount(local, ctx) == 0)
 772                         ieee80211_free_chanctx(local, ctx);
 773                 goto out;
 774         }
 775
 776         ieee80211_recalc_smps_chanctx(local, ctx);
 777         ieee80211_recalc_radar_chanctx(local, ctx);
 778  out:
 779         mutex_unlock(&local->chanctx_mtx);
 780         return ret;
 781 }
 782
 783 static int __ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
 784                                           struct ieee80211_chanctx *ctx,
 785                                           u32 *changed)
 786 {
 787         struct ieee80211_local *local = sdata->local;
 788         const struct cfg80211_chan_def *chandef = &sdata->csa_chandef;
 789         u32 chanctx_changed = 0;
 790
 791         if (!cfg80211_chandef_usable(sdata->local->hw.wiphy, chandef,
 792                                      IEEE80211_CHAN_DISABLED))
 793                 return -EINVAL;
 794
 795         if (ieee80211_chanctx_refcount(local, ctx) != 1)
 796                 return -EINVAL;
 797
 798         if (sdata->vif.bss_conf.chandef.width != chandef->width) {
 799                 chanctx_changed = IEEE80211_CHANCTX_CHANGE_WIDTH;
 800                 *changed |= BSS_CHANGED_BANDWIDTH;
 801         }
 802
 803         sdata->vif.bss_conf.chandef = *chandef;
 804         ctx->conf.def = *chandef;
 805
 806         chanctx_changed |= IEEE80211_CHANCTX_CHANGE_CHANNEL;
 807         drv_change_chanctx(local, ctx, chanctx_changed);
 808
 809         ieee80211_recalc_chanctx_chantype(local, ctx);
 810         ieee80211_recalc_smps_chanctx(local, ctx);
 811         ieee80211_recalc_radar_chanctx(local, ctx);
 812         ieee80211_recalc_chanctx_min_def(local, ctx);
 813
 814         return 0;
 815 }
 816
 817 int ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
 818                                  u32 *changed)
 819 {
 820         struct ieee80211_local *local = sdata->local;
 821         struct ieee80211_chanctx_conf *conf;
 822         struct ieee80211_chanctx *ctx;
 823         int ret;
 824
 825         lockdep_assert_held(&local->mtx);
 826
 827         /* should never be called if not performing a channel switch. */
 828         if (WARN_ON(!sdata->vif.csa_active))
 829                 return -EINVAL;
 830
 831         mutex_lock(&local->chanctx_mtx);
 832         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 833                                          lockdep_is_held(&local->chanctx_mtx));
 834         if (!conf) {
 835                 ret = -EINVAL;
 836                 goto out;
 837         }
 838
 839         ctx = container_of(conf, struct ieee80211_chanctx, conf);
 840
 841         ret = __ieee80211_vif_change_channel(sdata, ctx, changed);
 842  out:
 843         mutex_unlock(&local->chanctx_mtx);
 844         return ret;
 845 }
 846
 847 static void
 848 __ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
 849                                       bool clear)
 850 {
 851         struct ieee80211_local *local = sdata->local;
 852         struct ieee80211_sub_if_data *vlan;
 853         struct ieee80211_chanctx_conf *conf;
 854
 855         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_AP))
 856                 return;
 857
 858         lockdep_assert_held(&local->mtx);
 859
 860         /* Check that conf exists, even when clearing this function
 861          * must be called with the AP's channel context still there
 862          * as it would otherwise cause VLANs to have an invalid
 863          * channel context pointer for a while, possibly pointing
 864          * to a channel context that has already been freed.
 865          */
 866         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 867                                 lockdep_is_held(&local->chanctx_mtx));
 868         WARN_ON(!conf);
 869
 870         if (clear)
 871                 conf = NULL;
 872
 873         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
 874                 rcu_assign_pointer(vlan->vif.chanctx_conf, conf);
 875 }
 876
 877 void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data *sdata,
 878                                          bool clear)
 879 {
 880         struct ieee80211_local *local = sdata->local;
 881
 882         mutex_lock(&local->chanctx_mtx);
 883
 884         __ieee80211_vif_copy_chanctx_to_vlans(sdata, clear);
 885
 886         mutex_unlock(&local->chanctx_mtx);
 887 }
 888
 889 int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data *sdata)
 890 {
 891         struct ieee80211_chanctx *ctx = sdata->reserved_chanctx;
 892
 893         lockdep_assert_held(&sdata->local->chanctx_mtx);
 894
 895         if (WARN_ON(!ctx))
 896                 return -EINVAL;
 897
 898         list_del(&sdata->reserved_chanctx_list);
 899         sdata->reserved_chanctx = NULL;
 900
 901         if (ieee80211_chanctx_refcount(sdata->local, ctx) == 0)
 902                 ieee80211_free_chanctx(sdata->local, ctx);
 903
 904         return 0;
 905 }
 906
 907 int ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data *sdata,
 908                                   const struct cfg80211_chan_def *chandef,
 909                                   enum ieee80211_chanctx_mode mode,
 910                                   bool radar_required)
 911 {
 912         struct ieee80211_local *local = sdata->local;
 913         struct ieee80211_chanctx_conf *conf;
 914         struct ieee80211_chanctx *new_ctx, *curr_ctx;
 915         int ret = 0;
 916
 917         mutex_lock(&local->chanctx_mtx);
 918
 919         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 920                                          lockdep_is_held(&local->chanctx_mtx));
 921         if (!conf) {
 922                 ret = -EINVAL;
 923                 goto out;
 924         }
 925
 926         curr_ctx = container_of(conf, struct ieee80211_chanctx, conf);
 927
 928         new_ctx = ieee80211_find_reservation_chanctx(local, chandef, mode);
 929         if (!new_ctx) {
 930                 if (ieee80211_chanctx_refcount(local, curr_ctx) == 1 &&
 931                     (local->hw.flags & IEEE80211_HW_CHANGE_RUNNING_CHANCTX)) {
 932                         /* if we're the only users of the chanctx and
 933                          * the driver supports changing a running
 934                          * context, reserve our current context
 935                          */
 936                         new_ctx = curr_ctx;
 937                 } else if (ieee80211_can_create_new_chanctx(local)) {
 938                         /* create a new context and reserve it */
 939                         new_ctx = ieee80211_new_chanctx(local, chandef, mode);
 940                         if (IS_ERR(new_ctx)) {
 941                                 ret = PTR_ERR(new_ctx);
 942                                 goto out;
 943                         }
 944                 } else {
 945                         ret = -EBUSY;
 946                         goto out;
 947                 }
 948         }
 949
 950         list_add(&sdata->reserved_chanctx_list, &new_ctx->reserved_vifs);
 951         sdata->reserved_chanctx = new_ctx;
 952         sdata->reserved_chandef = *chandef;
 953         sdata->reserved_radar_required = radar_required;
 954 out:
 955         mutex_unlock(&local->chanctx_mtx);
 956         return ret;
 957 }
 958
 959 int ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data *sdata,
 960                                        u32 *changed)
 961 {
 962         struct ieee80211_local *local = sdata->local;
 963         struct ieee80211_chanctx *ctx;
 964         struct ieee80211_chanctx *old_ctx;
 965         struct ieee80211_chanctx_conf *conf;
 966         int ret;
 967         u32 tmp_changed = *changed;
 968
 969         /* TODO: need to recheck if the chandef is usable etc.? */
 970
 971         lockdep_assert_held(&local->mtx);
 972
 973         mutex_lock(&local->chanctx_mtx);
 974
 975         ctx = sdata->reserved_chanctx;
 976         if (WARN_ON(!ctx)) {
 977                 ret = -EINVAL;
 978                 goto out;
 979         }
 980
 981         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
 982                                          lockdep_is_held(&local->chanctx_mtx));
 983         if (!conf) {
 984                 ret = -EINVAL;
 985                 goto out;
 986         }
 987
 988         old_ctx = container_of(conf, struct ieee80211_chanctx, conf);
 989
 990         if (sdata->vif.bss_conf.chandef.width != sdata->reserved_chandef.width)
 991                 tmp_changed |= BSS_CHANGED_BANDWIDTH;
 992
 993         sdata->vif.bss_conf.chandef = sdata->reserved_chandef;
 994
 995         /* unref our reservation */
 996         sdata->reserved_chanctx = NULL;
 997         sdata->radar_required = sdata->reserved_radar_required;
 998         list_del(&sdata->reserved_chanctx_list);
 999
1000         if (old_ctx == ctx) {
1001                 /* This is our own context, just change it */
1002                 ret = __ieee80211_vif_change_channel(sdata, old_ctx,
1003                                                      &tmp_changed);
1004                 if (ret)
1005                         goto out;
1006         } else {
1007                 ret = ieee80211_assign_vif_chanctx(sdata, ctx);
1008                 if (ieee80211_chanctx_refcount(local, old_ctx) == 0)
1009                         ieee80211_free_chanctx(local, old_ctx);
1010                 if (ret) {
1011                         /* if assign fails refcount stays the same */
1012                         if (ieee80211_chanctx_refcount(local, ctx) == 0)
1013                                 ieee80211_free_chanctx(local, ctx);
1014                         goto out;
1015                 }
1016
1017                 if (sdata->vif.type == NL80211_IFTYPE_AP)
1018                         __ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
1019         }
1020
1021         *changed = tmp_changed;
1022
1023         ieee80211_recalc_chanctx_chantype(local, ctx);
1024         ieee80211_recalc_smps_chanctx(local, ctx);
1025         ieee80211_recalc_radar_chanctx(local, ctx);
1026         ieee80211_recalc_chanctx_min_def(local, ctx);
1027 out:
1028         mutex_unlock(&local->chanctx_mtx);
1029         return ret;
1030 }
1031
1032 int ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
1033                                    const struct cfg80211_chan_def *chandef,
1034                                    u32 *changed)
1035 {
1036         struct ieee80211_local *local = sdata->local;
1037         struct ieee80211_chanctx_conf *conf;
1038         struct ieee80211_chanctx *ctx;
1039         int ret;
1040
1041         if (!cfg80211_chandef_usable(sdata->local->hw.wiphy, chandef,
1042                                      IEEE80211_CHAN_DISABLED))
1043                 return -EINVAL;
1044
1045         mutex_lock(&local->chanctx_mtx);
1046         if (cfg80211_chandef_identical(chandef, &sdata->vif.bss_conf.chandef)) {
1047                 ret = 0;
1048                 goto out;
1049         }
1050
1051         if (chandef->width == NL80211_CHAN_WIDTH_20_NOHT ||
1052             sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT) {
1053                 ret = -EINVAL;
1054                 goto out;
1055         }
1056
1057         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1058                                          lockdep_is_held(&local->chanctx_mtx));
1059         if (!conf) {
1060                 ret = -EINVAL;
1061                 goto out;
1062         }
1063
1064         ctx = container_of(conf, struct ieee80211_chanctx, conf);
1065         if (!cfg80211_chandef_compatible(&conf->def, chandef)) {
1066                 ret = -EINVAL;
1067                 goto out;
1068         }
1069
1070         sdata->vif.bss_conf.chandef = *chandef;
1071
1072         ieee80211_recalc_chanctx_chantype(local, ctx);
1073
1074         *changed |= BSS_CHANGED_BANDWIDTH;
1075         ret = 0;
1076  out:
1077         mutex_unlock(&local->chanctx_mtx);
1078         return ret;
1079 }
1080
1081 void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata)
1082 {
1083         WARN_ON(sdata->dev && netif_carrier_ok(sdata->dev));
1084
1085         lockdep_assert_held(&sdata->local->mtx);
1086
1087         mutex_lock(&sdata->local->chanctx_mtx);
1088         __ieee80211_vif_release_channel(sdata);
1089         mutex_unlock(&sdata->local->chanctx_mtx);
1090 }
1091
1092 void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata)
1093 {
1094         struct ieee80211_local *local = sdata->local;
1095         struct ieee80211_sub_if_data *ap;
1096         struct ieee80211_chanctx_conf *conf;
1097
1098         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->bss))
1099                 return;
1100
1101         ap = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
1102
1103         mutex_lock(&local->chanctx_mtx);
1104
1105         conf = rcu_dereference_protected(ap->vif.chanctx_conf,
1106                                          lockdep_is_held(&local->chanctx_mtx));
1107         rcu_assign_pointer(sdata->vif.chanctx_conf, conf);
1108         mutex_unlock(&local->chanctx_mtx);
1109 }
1110
1111 void ieee80211_iter_chan_contexts_atomic(
1112         struct ieee80211_hw *hw,
1113         void (*iter)(struct ieee80211_hw *hw,
1114                      struct ieee80211_chanctx_conf *chanctx_conf,
1115                      void *data),
1116         void *iter_data)
1117 {
1118         struct ieee80211_local *local = hw_to_local(hw);
1119         struct ieee80211_chanctx *ctx;
1120
1121         rcu_read_lock();
1122         list_for_each_entry_rcu(ctx, &local->chanctx_list, list)
1123                 if (ctx->driver_present)
1124                         iter(hw, &ctx->conf, iter_data);
1125         rcu_read_unlock();
1126 }
1127 EXPORT_SYMBOL_GPL(ieee80211_iter_chan_contexts_atomic);