net/mac80211/chan.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * mac80211 - channel management
   4  * Copyright 2020 - 2022 Intel Corporation
   5  */
   6
   7 #include <linux/nl80211.h>
   8 #include <linux/export.h>
   9 #include <linux/rtnetlink.h>
  10 #include <net/cfg80211.h>
  11 #include "ieee80211_i.h"
  12 #include "driver-ops.h"
  13 #include "rate.h"
  14
  15 static int ieee80211_chanctx_num_assigned(struct ieee80211_local *local,
  16                                           struct ieee80211_chanctx *ctx)
  17 {
  18         struct ieee80211_link_data *link;
  19         int num = 0;
  20
  21         lockdep_assert_held(&local->chanctx_mtx);
  22
  23         list_for_each_entry(link, &ctx->assigned_links, assigned_chanctx_list)
  24                 num++;
  25
  26         return num;
  27 }
  28
  29 static int ieee80211_chanctx_num_reserved(struct ieee80211_local *local,
  30                                           struct ieee80211_chanctx *ctx)
  31 {
  32         struct ieee80211_link_data *link;
  33         int num = 0;
  34
  35         lockdep_assert_held(&local->chanctx_mtx);
  36
  37         list_for_each_entry(link, &ctx->reserved_links, reserved_chanctx_list)
  38                 num++;
  39
  40         return num;
  41 }
  42
  43 int ieee80211_chanctx_refcount(struct ieee80211_local *local,
  44                                struct ieee80211_chanctx *ctx)
  45 {
  46         return ieee80211_chanctx_num_assigned(local, ctx) +
  47                ieee80211_chanctx_num_reserved(local, ctx);
  48 }
  49
  50 static int ieee80211_num_chanctx(struct ieee80211_local *local)
  51 {
  52         struct ieee80211_chanctx *ctx;
  53         int num = 0;
  54
  55         lockdep_assert_held(&local->chanctx_mtx);
  56
  57         list_for_each_entry(ctx, &local->chanctx_list, list)
  58                 num++;
  59
  60         return num;
  61 }
  62
  63 static bool ieee80211_can_create_new_chanctx(struct ieee80211_local *local)
  64 {
  65         lockdep_assert_held(&local->chanctx_mtx);
  66         return ieee80211_num_chanctx(local) < ieee80211_max_num_channels(local);
  67 }
  68
  69 static struct ieee80211_chanctx *
  70 ieee80211_link_get_chanctx(struct ieee80211_link_data *link)
  71 {
  72         struct ieee80211_local *local __maybe_unused = link->sdata->local;
  73         struct ieee80211_chanctx_conf *conf;
  74
  75         conf = rcu_dereference_protected(link->conf->chanctx_conf,
  76                                          lockdep_is_held(&local->chanctx_mtx));
  77         if (!conf)
  78                 return NULL;
  79
  80         return container_of(conf, struct ieee80211_chanctx, conf);
  81 }
  82
  83 static const struct cfg80211_chan_def *
  84 ieee80211_chanctx_reserved_chandef(struct ieee80211_local *local,
  85                                    struct ieee80211_chanctx *ctx,
  86                                    const struct cfg80211_chan_def *compat)
  87 {
  88         struct ieee80211_link_data *link;
  89
  90         lockdep_assert_held(&local->chanctx_mtx);
  91
  92         list_for_each_entry(link, &ctx->reserved_links,
  93                             reserved_chanctx_list) {
  94                 if (!compat)
  95                         compat = &link->reserved_chandef;
  96
  97                 compat = cfg80211_chandef_compatible(&link->reserved_chandef,
  98                                                      compat);
  99                 if (!compat)
 100                         break;
 101         }
 102
 103         return compat;
 104 }
 105
 106 static const struct cfg80211_chan_def *
 107 ieee80211_chanctx_non_reserved_chandef(struct ieee80211_local *local,
 108                                        struct ieee80211_chanctx *ctx,
 109                                        const struct cfg80211_chan_def *compat)
 110 {
 111         struct ieee80211_link_data *link;
 112
 113         lockdep_assert_held(&local->chanctx_mtx);
 114
 115         list_for_each_entry(link, &ctx->assigned_links,
 116                             assigned_chanctx_list) {
 117                 struct ieee80211_bss_conf *link_conf = link->conf;
 118
 119                 if (link->reserved_chanctx)
 120                         continue;
 121
 122                 if (!compat)
 123                         compat = &link_conf->chandef;
 124
 125                 compat = cfg80211_chandef_compatible(
 126                                 &link_conf->chandef, compat);
 127                 if (!compat)
 128                         break;
 129         }
 130
 131         return compat;
 132 }
 133
 134 static const struct cfg80211_chan_def *
 135 ieee80211_chanctx_combined_chandef(struct ieee80211_local *local,
 136                                    struct ieee80211_chanctx *ctx,
 137                                    const struct cfg80211_chan_def *compat)
 138 {
 139         lockdep_assert_held(&local->chanctx_mtx);
 140
 141         compat = ieee80211_chanctx_reserved_chandef(local, ctx, compat);
 142         if (!compat)
 143                 return NULL;
 144
 145         compat = ieee80211_chanctx_non_reserved_chandef(local, ctx, compat);
 146         if (!compat)
 147                 return NULL;
 148
 149         return compat;
 150 }
 151
 152 static bool
 153 ieee80211_chanctx_can_reserve_chandef(struct ieee80211_local *local,
 154                                       struct ieee80211_chanctx *ctx,
 155                                       const struct cfg80211_chan_def *def)
 156 {
 157         lockdep_assert_held(&local->chanctx_mtx);
 158
 159         if (ieee80211_chanctx_combined_chandef(local, ctx, def))
 160                 return true;
 161
 162         if (!list_empty(&ctx->reserved_links) &&
 163             ieee80211_chanctx_reserved_chandef(local, ctx, def))
 164                 return true;
 165
 166         return false;
 167 }
 168
 169 static struct ieee80211_chanctx *
 170 ieee80211_find_reservation_chanctx(struct ieee80211_local *local,
 171                                    const struct cfg80211_chan_def *chandef,
 172                                    enum ieee80211_chanctx_mode mode)
 173 {
 174         struct ieee80211_chanctx *ctx;
 175
 176         lockdep_assert_held(&local->chanctx_mtx);
 177
 178         if (mode == IEEE80211_CHANCTX_EXCLUSIVE)
 179                 return NULL;
 180
 181         list_for_each_entry(ctx, &local->chanctx_list, list) {
 182                 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
 183                         continue;
 184
 185                 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE)
 186                         continue;
 187
 188                 if (!ieee80211_chanctx_can_reserve_chandef(local, ctx,
 189                                                            chandef))
 190                         continue;
 191
 192                 return ctx;
 193         }
 194
 195         return NULL;
 196 }
 197
 198 static enum nl80211_chan_width ieee80211_get_sta_bw(struct sta_info *sta,
 199                                                     unsigned int link_id)
 200 {
 201         enum ieee80211_sta_rx_bandwidth width;
 202         struct link_sta_info *link_sta;
 203
 204         link_sta = rcu_dereference(sta->link[link_id]);
 205
 206         /* no effect if this STA has no presence on this link */
 207         if (!link_sta)
 208                 return NL80211_CHAN_WIDTH_20_NOHT;
 209
 210         width = ieee80211_sta_cap_rx_bw(link_sta);
 211
 212         switch (width) {
 213         case IEEE80211_STA_RX_BW_20:
 214                 if (link_sta->pub->ht_cap.ht_supported)
 215                         return NL80211_CHAN_WIDTH_20;
 216                 else
 217                         return NL80211_CHAN_WIDTH_20_NOHT;
 218         case IEEE80211_STA_RX_BW_40:
 219                 return NL80211_CHAN_WIDTH_40;
 220         case IEEE80211_STA_RX_BW_80:
 221                 return NL80211_CHAN_WIDTH_80;
 222         case IEEE80211_STA_RX_BW_160:
 223                 /*
 224                  * This applied for both 160 and 80+80. since we use
 225                  * the returned value to consider degradation of
 226                  * ctx->conf.min_def, we have to make sure to take
 227                  * the bigger one (NL80211_CHAN_WIDTH_160).
 228                  * Otherwise we might try degrading even when not
 229                  * needed, as the max required sta_bw returned (80+80)
 230                  * might be smaller than the configured bw (160).
 231                  */
 232                 return NL80211_CHAN_WIDTH_160;
 233         case IEEE80211_STA_RX_BW_320:
 234                 return NL80211_CHAN_WIDTH_320;
 235         default:
 236                 WARN_ON(1);
 237                 return NL80211_CHAN_WIDTH_20;
 238         }
 239 }
 240
 241 static enum nl80211_chan_width
 242 ieee80211_get_max_required_bw(struct ieee80211_sub_if_data *sdata,
 243                               unsigned int link_id)
 244 {
 245         enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
 246         struct sta_info *sta;
 247
 248         list_for_each_entry_rcu(sta, &sdata->local->sta_list, list) {
 249                 if (sdata != sta->sdata &&
 250                     !(sta->sdata->bss && sta->sdata->bss == sdata->bss))
 251                         continue;
 252
 253                 max_bw = max(max_bw, ieee80211_get_sta_bw(sta, link_id));
 254         }
 255
 256         return max_bw;
 257 }
 258
 259 static enum nl80211_chan_width
 260 ieee80211_get_chanctx_vif_max_required_bw(struct ieee80211_sub_if_data *sdata,
 261                                           struct ieee80211_chanctx_conf *conf)
 262 {
 263         enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
 264         struct ieee80211_vif *vif = &sdata->vif;
 265         int link_id;
 266
 267         rcu_read_lock();
 268         for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
 269                 enum nl80211_chan_width width = NL80211_CHAN_WIDTH_20_NOHT;
 270                 struct ieee80211_bss_conf *link_conf =
 271                         rcu_dereference(sdata->vif.link_conf[link_id]);
 272
 273                 if (!link_conf)
 274                         continue;
 275
 276                 if (rcu_access_pointer(link_conf->chanctx_conf) != conf)
 277                         continue;
 278
 279                 switch (vif->type) {
 280                 case NL80211_IFTYPE_AP:
 281                 case NL80211_IFTYPE_AP_VLAN:
 282                         width = ieee80211_get_max_required_bw(sdata, link_id);
 283                         break;
 284                 case NL80211_IFTYPE_STATION:
 285                         /*
 286                          * The ap's sta->bandwidth is not set yet at this
 287                          * point, so take the width from the chandef, but
 288                          * account also for TDLS peers
 289                          */
 290                         width = max(link_conf->chandef.width,
 291                                     ieee80211_get_max_required_bw(sdata, link_id));
 292                         break;
 293                 case NL80211_IFTYPE_P2P_DEVICE:
 294                 case NL80211_IFTYPE_NAN:
 295                         continue;
 296                 case NL80211_IFTYPE_ADHOC:
 297                 case NL80211_IFTYPE_MESH_POINT:
 298                 case NL80211_IFTYPE_OCB:
 299                         width = link_conf->chandef.width;
 300                         break;
 301                 case NL80211_IFTYPE_WDS:
 302                 case NL80211_IFTYPE_UNSPECIFIED:
 303                 case NUM_NL80211_IFTYPES:
 304                 case NL80211_IFTYPE_MONITOR:
 305                 case NL80211_IFTYPE_P2P_CLIENT:
 306                 case NL80211_IFTYPE_P2P_GO:
 307                         WARN_ON_ONCE(1);
 308                 }
 309
 310                 max_bw = max(max_bw, width);
 311         }
 312         rcu_read_unlock();
 313
 314         return max_bw;
 315 }
 316
 317 static enum nl80211_chan_width
 318 ieee80211_get_chanctx_max_required_bw(struct ieee80211_local *local,
 319                                       struct ieee80211_chanctx_conf *conf)
 320 {
 321         struct ieee80211_sub_if_data *sdata;
 322         enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
 323
 324         rcu_read_lock();
 325         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 326                 enum nl80211_chan_width width;
 327
 328                 if (!ieee80211_sdata_running(sdata))
 329                         continue;
 330
 331                 width = ieee80211_get_chanctx_vif_max_required_bw(sdata, conf);
 332
 333                 max_bw = max(max_bw, width);
 334         }
 335
 336         /* use the configured bandwidth in case of monitor interface */
 337         sdata = rcu_dereference(local->monitor_sdata);
 338         if (sdata &&
 339             rcu_access_pointer(sdata->vif.bss_conf.chanctx_conf) == conf)
 340                 max_bw = max(max_bw, conf->def.width);
 341
 342         rcu_read_unlock();
 343
 344         return max_bw;
 345 }
 346
 347 /*
 348  * recalc the min required chan width of the channel context, which is
 349  * the max of min required widths of all the interfaces bound to this
 350  * channel context.
 351  */
 352 static u32 _ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
 353                                              struct ieee80211_chanctx *ctx)
 354 {
 355         enum nl80211_chan_width max_bw;
 356         struct cfg80211_chan_def min_def;
 357
 358         lockdep_assert_held(&local->chanctx_mtx);
 359
 360         /* don't optimize non-20MHz based and radar_enabled confs */
 361         if (ctx->conf.def.width == NL80211_CHAN_WIDTH_5 ||
 362             ctx->conf.def.width == NL80211_CHAN_WIDTH_10 ||
 363             ctx->conf.def.width == NL80211_CHAN_WIDTH_1 ||
 364             ctx->conf.def.width == NL80211_CHAN_WIDTH_2 ||
 365             ctx->conf.def.width == NL80211_CHAN_WIDTH_4 ||
 366             ctx->conf.def.width == NL80211_CHAN_WIDTH_8 ||
 367             ctx->conf.def.width == NL80211_CHAN_WIDTH_16 ||
 368             ctx->conf.radar_enabled) {
 369                 ctx->conf.min_def = ctx->conf.def;
 370                 return 0;
 371         }
 372
 373         max_bw = ieee80211_get_chanctx_max_required_bw(local, &ctx->conf);
 374
 375         /* downgrade chandef up to max_bw */
 376         min_def = ctx->conf.def;
 377         while (min_def.width > max_bw)
 378                 ieee80211_chandef_downgrade(&min_def);
 379
 380         if (cfg80211_chandef_identical(&ctx->conf.min_def, &min_def))
 381                 return 0;
 382
 383         ctx->conf.min_def = min_def;
 384         if (!ctx->driver_present)
 385                 return 0;
 386
 387         return IEEE80211_CHANCTX_CHANGE_MIN_WIDTH;
 388 }
 389
 390 /* calling this function is assuming that station vif is updated to
 391  * lates changes by calling ieee80211_link_update_chandef
 392  */
 393 static void ieee80211_chan_bw_change(struct ieee80211_local *local,
 394                                      struct ieee80211_chanctx *ctx,
 395                                      bool narrowed)
 396 {
 397         struct sta_info *sta;
 398         struct ieee80211_supported_band *sband =
 399                 local->hw.wiphy->bands[ctx->conf.def.chan->band];
 400
 401         rcu_read_lock();
 402         list_for_each_entry_rcu(sta, &local->sta_list,
 403                                 list) {
 404                 struct ieee80211_sub_if_data *sdata = sta->sdata;
 405                 enum ieee80211_sta_rx_bandwidth new_sta_bw;
 406                 unsigned int link_id;
 407
 408                 if (!ieee80211_sdata_running(sta->sdata))
 409                         continue;
 410
 411                 for (link_id = 0; link_id < ARRAY_SIZE(sta->sdata->link); link_id++) {
 412                         struct ieee80211_bss_conf *link_conf =
 413                                 rcu_dereference(sdata->vif.link_conf[link_id]);
 414                         struct link_sta_info *link_sta;
 415
 416                         if (!link_conf)
 417                                 continue;
 418
 419                         if (rcu_access_pointer(link_conf->chanctx_conf) != &ctx->conf)
 420                                 continue;
 421
 422                         link_sta = rcu_dereference(sta->link[link_id]);
 423                         if (!link_sta)
 424                                 continue;
 425
 426                         new_sta_bw = ieee80211_sta_cur_vht_bw(link_sta);
 427
 428                         /* nothing change */
 429                         if (new_sta_bw == link_sta->pub->bandwidth)
 430                                 continue;
 431
 432                         /* vif changed to narrow BW and narrow BW for station wasn't
 433                          * requested or vise versa */
 434                         if ((new_sta_bw < link_sta->pub->bandwidth) == !narrowed)
 435                                 continue;
 436
 437                         link_sta->pub->bandwidth = new_sta_bw;
 438                         rate_control_rate_update(local, sband, sta, link_id,
 439                                                  IEEE80211_RC_BW_CHANGED);
 440                 }
 441         }
 442         rcu_read_unlock();
 443 }
 444
 445 /*
 446  * recalc the min required chan width of the channel context, which is
 447  * the max of min required widths of all the interfaces bound to this
 448  * channel context.
 449  */
 450 void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
 451                                       struct ieee80211_chanctx *ctx)
 452 {
 453         u32 changed = _ieee80211_recalc_chanctx_min_def(local, ctx);
 454
 455         if (!changed)
 456                 return;
 457
 458         /* check is BW narrowed */
 459         ieee80211_chan_bw_change(local, ctx, true);
 460
 461         drv_change_chanctx(local, ctx, changed);
 462
 463         /* check is BW wider */
 464         ieee80211_chan_bw_change(local, ctx, false);
 465 }
 466
 467 static void ieee80211_change_chanctx(struct ieee80211_local *local,
 468                                      struct ieee80211_chanctx *ctx,
 469                                      struct ieee80211_chanctx *old_ctx,
 470                                      const struct cfg80211_chan_def *chandef)
 471 {
 472         u32 changed;
 473
 474         /* expected to handle only 20/40/80/160/320 channel widths */
 475         switch (chandef->width) {
 476         case NL80211_CHAN_WIDTH_20_NOHT:
 477         case NL80211_CHAN_WIDTH_20:
 478         case NL80211_CHAN_WIDTH_40:
 479         case NL80211_CHAN_WIDTH_80:
 480         case NL80211_CHAN_WIDTH_80P80:
 481         case NL80211_CHAN_WIDTH_160:
 482         case NL80211_CHAN_WIDTH_320:
 483                 break;
 484         default:
 485                 WARN_ON(1);
 486         }
 487
 488         /* Check maybe BW narrowed - we do this _before_ calling recalc_chanctx_min_def
 489          * due to maybe not returning from it, e.g in case new context was added
 490          * first time with all parameters up to date.
 491          */
 492         ieee80211_chan_bw_change(local, old_ctx, true);
 493
 494         if (cfg80211_chandef_identical(&ctx->conf.def, chandef)) {
 495                 ieee80211_recalc_chanctx_min_def(local, ctx);
 496                 return;
 497         }
 498
 499         WARN_ON(!cfg80211_chandef_compatible(&ctx->conf.def, chandef));
 500
 501         ctx->conf.def = *chandef;
 502
 503         /* check if min chanctx also changed */
 504         changed = IEEE80211_CHANCTX_CHANGE_WIDTH |
 505                   _ieee80211_recalc_chanctx_min_def(local, ctx);
 506         drv_change_chanctx(local, ctx, changed);
 507
 508         if (!local->use_chanctx) {
 509                 local->_oper_chandef = *chandef;
 510                 ieee80211_hw_config(local, 0);
 511         }
 512
 513         /* check is BW wider */
 514         ieee80211_chan_bw_change(local, old_ctx, false);
 515 }
 516
 517 static struct ieee80211_chanctx *
 518 ieee80211_find_chanctx(struct ieee80211_local *local,
 519                        const struct cfg80211_chan_def *chandef,
 520                        enum ieee80211_chanctx_mode mode)
 521 {
 522         struct ieee80211_chanctx *ctx;
 523
 524         lockdep_assert_held(&local->chanctx_mtx);
 525
 526         if (mode == IEEE80211_CHANCTX_EXCLUSIVE)
 527                 return NULL;
 528
 529         list_for_each_entry(ctx, &local->chanctx_list, list) {
 530                 const struct cfg80211_chan_def *compat;
 531
 532                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACE_NONE)
 533                         continue;
 534
 535                 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE)
 536                         continue;
 537
 538                 compat = cfg80211_chandef_compatible(&ctx->conf.def, chandef);
 539                 if (!compat)
 540                         continue;
 541
 542                 compat = ieee80211_chanctx_reserved_chandef(local, ctx,
 543                                                             compat);
 544                 if (!compat)
 545                         continue;
 546
 547                 ieee80211_change_chanctx(local, ctx, ctx, compat);
 548
 549                 return ctx;
 550         }
 551
 552         return NULL;
 553 }
 554
 555 bool ieee80211_is_radar_required(struct ieee80211_local *local)
 556 {
 557         struct ieee80211_sub_if_data *sdata;
 558
 559         lockdep_assert_held(&local->mtx);
 560
 561         rcu_read_lock();
 562         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 563                 unsigned int link_id;
 564
 565                 for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
 566                         struct ieee80211_link_data *link;
 567
 568                         link = rcu_dereference(sdata->link[link_id]);
 569
 570                         if (link && link->radar_required) {
 571                                 rcu_read_unlock();
 572                                 return true;
 573                         }
 574                 }
 575         }
 576         rcu_read_unlock();
 577
 578         return false;
 579 }
 580
 581 static bool
 582 ieee80211_chanctx_radar_required(struct ieee80211_local *local,
 583                                  struct ieee80211_chanctx *ctx)
 584 {
 585         struct ieee80211_chanctx_conf *conf = &ctx->conf;
 586         struct ieee80211_sub_if_data *sdata;
 587         bool required = false;
 588
 589         lockdep_assert_held(&local->chanctx_mtx);
 590         lockdep_assert_held(&local->mtx);
 591
 592         rcu_read_lock();
 593         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 594                 unsigned int link_id;
 595
 596                 if (!ieee80211_sdata_running(sdata))
 597                         continue;
 598                 for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
 599                         struct ieee80211_link_data *link;
 600
 601                         link = rcu_dereference(sdata->link[link_id]);
 602                         if (!link)
 603                                 continue;
 604
 605                         if (rcu_access_pointer(link->conf->chanctx_conf) != conf)
 606                                 continue;
 607                         if (!link->radar_required)
 608                                 continue;
 609                         required = true;
 610                         break;
 611                 }
 612
 613                 if (required)
 614                         break;
 615         }
 616         rcu_read_unlock();
 617
 618         return required;
 619 }
 620
 621 static struct ieee80211_chanctx *
 622 ieee80211_alloc_chanctx(struct ieee80211_local *local,
 623                         const struct cfg80211_chan_def *chandef,
 624                         enum ieee80211_chanctx_mode mode)
 625 {
 626         struct ieee80211_chanctx *ctx;
 627
 628         lockdep_assert_held(&local->chanctx_mtx);
 629
 630         ctx = kzalloc(sizeof(*ctx) + local->hw.chanctx_data_size, GFP_KERNEL);
 631         if (!ctx)
 632                 return NULL;
 633
 634         INIT_LIST_HEAD(&ctx->assigned_links);
 635         INIT_LIST_HEAD(&ctx->reserved_links);
 636         ctx->conf.def = *chandef;
 637         ctx->conf.rx_chains_static = 1;
 638         ctx->conf.rx_chains_dynamic = 1;
 639         ctx->mode = mode;
 640         ctx->conf.radar_enabled = false;
 641         ieee80211_recalc_chanctx_min_def(local, ctx);
 642
 643         return ctx;
 644 }
 645
 646 static int ieee80211_add_chanctx(struct ieee80211_local *local,
 647                                  struct ieee80211_chanctx *ctx)
 648 {
 649         u32 changed;
 650         int err;
 651
 652         lockdep_assert_held(&local->mtx);
 653         lockdep_assert_held(&local->chanctx_mtx);
 654
 655         if (!local->use_chanctx)
 656                 local->hw.conf.radar_enabled = ctx->conf.radar_enabled;
 657
 658         /* turn idle off *before* setting channel -- some drivers need that */
 659         changed = ieee80211_idle_off(local);
 660         if (changed)
 661                 ieee80211_hw_config(local, changed);
 662
 663         if (!local->use_chanctx) {
 664                 local->_oper_chandef = ctx->conf.def;
 665                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 666         } else {
 667                 err = drv_add_chanctx(local, ctx);
 668                 if (err) {
 669                         ieee80211_recalc_idle(local);
 670                         return err;
 671                 }
 672         }
 673
 674         return 0;
 675 }
 676
 677 static struct ieee80211_chanctx *
 678 ieee80211_new_chanctx(struct ieee80211_local *local,
 679                       const struct cfg80211_chan_def *chandef,
 680                       enum ieee80211_chanctx_mode mode)
 681 {
 682         struct ieee80211_chanctx *ctx;
 683         int err;
 684
 685         lockdep_assert_held(&local->mtx);
 686         lockdep_assert_held(&local->chanctx_mtx);
 687
 688         ctx = ieee80211_alloc_chanctx(local, chandef, mode);
 689         if (!ctx)
 690                 return ERR_PTR(-ENOMEM);
 691
 692         err = ieee80211_add_chanctx(local, ctx);
 693         if (err) {
 694                 kfree(ctx);
 695                 return ERR_PTR(err);
 696         }
 697
 698         list_add_rcu(&ctx->list, &local->chanctx_list);
 699         return ctx;
 700 }
 701
 702 static void ieee80211_del_chanctx(struct ieee80211_local *local,
 703                                   struct ieee80211_chanctx *ctx)
 704 {
 705         lockdep_assert_held(&local->chanctx_mtx);
 706
 707         if (!local->use_chanctx) {
 708                 struct cfg80211_chan_def *chandef = &local->_oper_chandef;
 709                 /* S1G doesn't have 20MHz, so get the correct width for the
 710                  * current channel.
 711                  */
 712                 if (chandef->chan->band == NL80211_BAND_S1GHZ)
 713                         chandef->width =
 714                                 ieee80211_s1g_channel_width(chandef->chan);
 715                 else
 716                         chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
 717                 chandef->center_freq1 = chandef->chan->center_freq;
 718                 chandef->freq1_offset = chandef->chan->freq_offset;
 719                 chandef->center_freq2 = 0;
 720
 721                 /* NOTE: Disabling radar is only valid here for
 722                  * single channel context. To be sure, check it ...
 723                  */
 724                 WARN_ON(local->hw.conf.radar_enabled &&
 725                         !list_empty(&local->chanctx_list));
 726
 727                 local->hw.conf.radar_enabled = false;
 728
 729                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 730         } else {
 731                 drv_remove_chanctx(local, ctx);
 732         }
 733
 734         ieee80211_recalc_idle(local);
 735 }
 736
 737 static void ieee80211_free_chanctx(struct ieee80211_local *local,
 738                                    struct ieee80211_chanctx *ctx)
 739 {
 740         lockdep_assert_held(&local->chanctx_mtx);
 741
 742         WARN_ON_ONCE(ieee80211_chanctx_refcount(local, ctx) != 0);
 743
 744         list_del_rcu(&ctx->list);
 745         ieee80211_del_chanctx(local, ctx);
 746         kfree_rcu(ctx, rcu_head);
 747 }
 748
 749 void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
 750                                        struct ieee80211_chanctx *ctx)
 751 {
 752         struct ieee80211_chanctx_conf *conf = &ctx->conf;
 753         struct ieee80211_sub_if_data *sdata;
 754         const struct cfg80211_chan_def *compat = NULL;
 755         struct sta_info *sta;
 756
 757         lockdep_assert_held(&local->chanctx_mtx);
 758
 759         rcu_read_lock();
 760         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 761                 int link_id;
 762
 763                 if (!ieee80211_sdata_running(sdata))
 764                         continue;
 765
 766                 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 767                         continue;
 768
 769                 for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
 770                         struct ieee80211_bss_conf *link_conf =
 771                                 rcu_dereference(sdata->vif.link_conf[link_id]);
 772
 773                         if (!link_conf)
 774                                 continue;
 775
 776                         if (rcu_access_pointer(link_conf->chanctx_conf) != conf)
 777                                 continue;
 778
 779                         if (!compat)
 780                                 compat = &link_conf->chandef;
 781
 782                         compat = cfg80211_chandef_compatible(&link_conf->chandef,
 783                                                              compat);
 784                         if (WARN_ON_ONCE(!compat))
 785                                 break;
 786                 }
 787         }
 788
 789         /* TDLS peers can sometimes affect the chandef width */
 790         list_for_each_entry_rcu(sta, &local->sta_list, list) {
 791                 if (!sta->uploaded ||
 792                     !test_sta_flag(sta, WLAN_STA_TDLS_WIDER_BW) ||
 793                     !test_sta_flag(sta, WLAN_STA_AUTHORIZED) ||
 794                     !sta->tdls_chandef.chan)
 795                         continue;
 796
 797                 compat = cfg80211_chandef_compatible(&sta->tdls_chandef,
 798                                                      compat);
 799                 if (WARN_ON_ONCE(!compat))
 800                         break;
 801         }
 802         rcu_read_unlock();
 803
 804         if (!compat)
 805                 return;
 806
 807         ieee80211_change_chanctx(local, ctx, ctx, compat);
 808 }
 809
 810 static void ieee80211_recalc_radar_chanctx(struct ieee80211_local *local,
 811                                            struct ieee80211_chanctx *chanctx)
 812 {
 813         bool radar_enabled;
 814
 815         lockdep_assert_held(&local->chanctx_mtx);
 816         /* for ieee80211_is_radar_required */
 817         lockdep_assert_held(&local->mtx);
 818
 819         radar_enabled = ieee80211_chanctx_radar_required(local, chanctx);
 820
 821         if (radar_enabled == chanctx->conf.radar_enabled)
 822                 return;
 823
 824         chanctx->conf.radar_enabled = radar_enabled;
 825
 826         if (!local->use_chanctx) {
 827                 local->hw.conf.radar_enabled = chanctx->conf.radar_enabled;
 828                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 829         }
 830
 831         drv_change_chanctx(local, chanctx, IEEE80211_CHANCTX_CHANGE_RADAR);
 832 }
 833
 834 static int ieee80211_assign_link_chanctx(struct ieee80211_link_data *link,
 835                                          struct ieee80211_chanctx *new_ctx)
 836 {
 837         struct ieee80211_sub_if_data *sdata = link->sdata;
 838         struct ieee80211_local *local = sdata->local;
 839         struct ieee80211_chanctx_conf *conf;
 840         struct ieee80211_chanctx *curr_ctx = NULL;
 841         int ret = 0;
 842
 843         if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_NAN))
 844                 return -ENOTSUPP;
 845
 846         conf = rcu_dereference_protected(link->conf->chanctx_conf,
 847                                          lockdep_is_held(&local->chanctx_mtx));
 848
 849         if (conf) {
 850                 curr_ctx = container_of(conf, struct ieee80211_chanctx, conf);
 851
 852                 drv_unassign_vif_chanctx(local, sdata, link->conf, curr_ctx);
 853                 conf = NULL;
 854                 list_del(&link->assigned_chanctx_list);
 855         }
 856
 857         if (new_ctx) {
 858                 ret = drv_assign_vif_chanctx(local, sdata, link->conf, new_ctx);
 859                 if (ret)
 860                         goto out;
 861
 862                 conf = &new_ctx->conf;
 863                 list_add(&link->assigned_chanctx_list,
 864                          &new_ctx->assigned_links);
 865         }
 866
 867 out:
 868         rcu_assign_pointer(link->conf->chanctx_conf, conf);
 869
 870         sdata->vif.cfg.idle = !conf;
 871
 872         if (curr_ctx && ieee80211_chanctx_num_assigned(local, curr_ctx) > 0) {
 873                 ieee80211_recalc_chanctx_chantype(local, curr_ctx);
 874                 ieee80211_recalc_smps_chanctx(local, curr_ctx);
 875                 ieee80211_recalc_radar_chanctx(local, curr_ctx);
 876                 ieee80211_recalc_chanctx_min_def(local, curr_ctx);
 877         }
 878
 879         if (new_ctx && ieee80211_chanctx_num_assigned(local, new_ctx) > 0) {
 880                 ieee80211_recalc_txpower(sdata, false);
 881                 ieee80211_recalc_chanctx_min_def(local, new_ctx);
 882         }
 883
 884         if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
 885             sdata->vif.type != NL80211_IFTYPE_MONITOR)
 886                 ieee80211_vif_cfg_change_notify(sdata, BSS_CHANGED_IDLE);
 887
 888         ieee80211_check_fast_xmit_iface(sdata);
 889
 890         return ret;
 891 }
 892
 893 void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
 894                                    struct ieee80211_chanctx *chanctx)
 895 {
 896         struct ieee80211_sub_if_data *sdata;
 897         u8 rx_chains_static, rx_chains_dynamic;
 898
 899         lockdep_assert_held(&local->chanctx_mtx);
 900
 901         rx_chains_static = 1;
 902         rx_chains_dynamic = 1;
 903
 904         rcu_read_lock();
 905         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 906                 u8 needed_static, needed_dynamic;
 907                 unsigned int link_id;
 908
 909                 if (!ieee80211_sdata_running(sdata))
 910                         continue;
 911
 912                 switch (sdata->vif.type) {
 913                 case NL80211_IFTYPE_STATION:
 914                         if (!sdata->u.mgd.associated)
 915                                 continue;
 916                         break;
 917                 case NL80211_IFTYPE_AP:
 918                 case NL80211_IFTYPE_ADHOC:
 919                 case NL80211_IFTYPE_MESH_POINT:
 920                 case NL80211_IFTYPE_OCB:
 921                         break;
 922                 default:
 923                         continue;
 924                 }
 925
 926                 for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
 927                         struct ieee80211_link_data *link;
 928
 929                         link = rcu_dereference(sdata->link[link_id]);
 930
 931                         if (!link)
 932                                 continue;
 933
 934                         if (rcu_access_pointer(link->conf->chanctx_conf) != &chanctx->conf)
 935                                 continue;
 936
 937                         switch (link->smps_mode) {
 938                         default:
 939                                 WARN_ONCE(1, "Invalid SMPS mode %d\n",
 940                                           link->smps_mode);
 941                                 fallthrough;
 942                         case IEEE80211_SMPS_OFF:
 943                                 needed_static = link->needed_rx_chains;
 944                                 needed_dynamic = link->needed_rx_chains;
 945                                 break;
 946                         case IEEE80211_SMPS_DYNAMIC:
 947                                 needed_static = 1;
 948                                 needed_dynamic = link->needed_rx_chains;
 949                                 break;
 950                         case IEEE80211_SMPS_STATIC:
 951                                 needed_static = 1;
 952                                 needed_dynamic = 1;
 953                                 break;
 954                         }
 955
 956                         rx_chains_static = max(rx_chains_static, needed_static);
 957                         rx_chains_dynamic = max(rx_chains_dynamic, needed_dynamic);
 958                 }
 959         }
 960
 961         /* Disable SMPS for the monitor interface */
 962         sdata = rcu_dereference(local->monitor_sdata);
 963         if (sdata &&
 964             rcu_access_pointer(sdata->vif.bss_conf.chanctx_conf) == &chanctx->conf)
 965                 rx_chains_dynamic = rx_chains_static = local->rx_chains;
 966
 967         rcu_read_unlock();
 968
 969         if (!local->use_chanctx) {
 970                 if (rx_chains_static > 1)
 971                         local->smps_mode = IEEE80211_SMPS_OFF;
 972                 else if (rx_chains_dynamic > 1)
 973                         local->smps_mode = IEEE80211_SMPS_DYNAMIC;
 974                 else
 975                         local->smps_mode = IEEE80211_SMPS_STATIC;
 976                 ieee80211_hw_config(local, 0);
 977         }
 978
 979         if (rx_chains_static == chanctx->conf.rx_chains_static &&
 980             rx_chains_dynamic == chanctx->conf.rx_chains_dynamic)
 981                 return;
 982
 983         chanctx->conf.rx_chains_static = rx_chains_static;
 984         chanctx->conf.rx_chains_dynamic = rx_chains_dynamic;
 985         drv_change_chanctx(local, chanctx, IEEE80211_CHANCTX_CHANGE_RX_CHAINS);
 986 }
 987
 988 static void
 989 __ieee80211_link_copy_chanctx_to_vlans(struct ieee80211_link_data *link,
 990                                        bool clear)
 991 {
 992         struct ieee80211_sub_if_data *sdata = link->sdata;
 993         unsigned int link_id = link->link_id;
 994         struct ieee80211_bss_conf *link_conf = link->conf;
 995         struct ieee80211_local *local __maybe_unused = sdata->local;
 996         struct ieee80211_sub_if_data *vlan;
 997         struct ieee80211_chanctx_conf *conf;
 998
 999         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_AP))
1000                 return;
1001
1002         lockdep_assert_held(&local->mtx);
1003
1004         /* Check that conf exists, even when clearing this function
1005          * must be called with the AP's channel context still there
1006          * as it would otherwise cause VLANs to have an invalid
1007          * channel context pointer for a while, possibly pointing
1008          * to a channel context that has already been freed.
1009          */
1010         conf = rcu_dereference_protected(link_conf->chanctx_conf,
1011                                          lockdep_is_held(&local->chanctx_mtx));
1012         WARN_ON(!conf);
1013
1014         if (clear)
1015                 conf = NULL;
1016
1017         rcu_read_lock();
1018         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
1019                 struct ieee80211_bss_conf *vlan_conf;
1020
1021                 vlan_conf = rcu_dereference(vlan->vif.link_conf[link_id]);
1022                 if (WARN_ON(!vlan_conf))
1023                         continue;
1024
1025                 rcu_assign_pointer(vlan_conf->chanctx_conf, conf);
1026         }
1027         rcu_read_unlock();
1028 }
1029
1030 void ieee80211_link_copy_chanctx_to_vlans(struct ieee80211_link_data *link,
1031                                           bool clear)
1032 {
1033         struct ieee80211_local *local = link->sdata->local;
1034
1035         mutex_lock(&local->chanctx_mtx);
1036
1037         __ieee80211_link_copy_chanctx_to_vlans(link, clear);
1038
1039         mutex_unlock(&local->chanctx_mtx);
1040 }
1041
1042 int ieee80211_link_unreserve_chanctx(struct ieee80211_link_data *link)
1043 {
1044         struct ieee80211_sub_if_data *sdata = link->sdata;
1045         struct ieee80211_chanctx *ctx = link->reserved_chanctx;
1046
1047         lockdep_assert_held(&sdata->local->chanctx_mtx);
1048
1049         if (WARN_ON(!ctx))
1050                 return -EINVAL;
1051
1052         list_del(&link->reserved_chanctx_list);
1053         link->reserved_chanctx = NULL;
1054
1055         if (ieee80211_chanctx_refcount(sdata->local, ctx) == 0) {
1056                 if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER) {
1057                         if (WARN_ON(!ctx->replace_ctx))
1058                                 return -EINVAL;
1059
1060                         WARN_ON(ctx->replace_ctx->replace_state !=
1061                                 IEEE80211_CHANCTX_WILL_BE_REPLACED);
1062                         WARN_ON(ctx->replace_ctx->replace_ctx != ctx);
1063
1064                         ctx->replace_ctx->replace_ctx = NULL;
1065                         ctx->replace_ctx->replace_state =
1066                                         IEEE80211_CHANCTX_REPLACE_NONE;
1067
1068                         list_del_rcu(&ctx->list);
1069                         kfree_rcu(ctx, rcu_head);
1070                 } else {
1071                         ieee80211_free_chanctx(sdata->local, ctx);
1072                 }
1073         }
1074
1075         return 0;
1076 }
1077
1078 int ieee80211_link_reserve_chanctx(struct ieee80211_link_data *link,
1079                                    const struct cfg80211_chan_def *chandef,
1080                                    enum ieee80211_chanctx_mode mode,
1081                                    bool radar_required)
1082 {
1083         struct ieee80211_sub_if_data *sdata = link->sdata;
1084         struct ieee80211_local *local = sdata->local;
1085         struct ieee80211_chanctx *new_ctx, *curr_ctx, *ctx;
1086
1087         lockdep_assert_held(&local->chanctx_mtx);
1088
1089         curr_ctx = ieee80211_link_get_chanctx(link);
1090         if (curr_ctx && local->use_chanctx && !local->ops->switch_vif_chanctx)
1091                 return -ENOTSUPP;
1092
1093         new_ctx = ieee80211_find_reservation_chanctx(local, chandef, mode);
1094         if (!new_ctx) {
1095                 if (ieee80211_can_create_new_chanctx(local)) {
1096                         new_ctx = ieee80211_new_chanctx(local, chandef, mode);
1097                         if (IS_ERR(new_ctx))
1098                                 return PTR_ERR(new_ctx);
1099                 } else {
1100                         if (!curr_ctx ||
1101                             (curr_ctx->replace_state ==
1102                              IEEE80211_CHANCTX_WILL_BE_REPLACED) ||
1103                             !list_empty(&curr_ctx->reserved_links)) {
1104                                 /*
1105                                  * Another link already requested this context
1106                                  * for a reservation. Find another one hoping
1107                                  * all links assigned to it will also switch
1108                                  * soon enough.
1109                                  *
1110                                  * TODO: This needs a little more work as some
1111                                  * cases (more than 2 chanctx capable devices)
1112                                  * may fail which could otherwise succeed
1113                                  * provided some channel context juggling was
1114                                  * performed.
1115                                  *
1116                                  * Consider ctx1..3, link1..6, each ctx has 2
1117                                  * links. link1 and link2 from ctx1 request new
1118                                  * different chandefs starting 2 in-place
1119                                  * reserations with ctx4 and ctx5 replacing
1120                                  * ctx1 and ctx2 respectively. Next link5 and
1121                                  * link6 from ctx3 reserve ctx4. If link3 and
1122                                  * link4 remain on ctx2 as they are then this
1123                                  * fails unless `replace_ctx` from ctx5 is
1124                                  * replaced with ctx3.
1125                                  */
1126                                 list_for_each_entry(ctx, &local->chanctx_list,
1127                                                     list) {
1128                                         if (ctx->replace_state !=
1129                                             IEEE80211_CHANCTX_REPLACE_NONE)
1130                                                 continue;
1131
1132                                         if (!list_empty(&ctx->reserved_links))
1133                                                 continue;
1134
1135                                         curr_ctx = ctx;
1136                                         break;
1137                                 }
1138                         }
1139
1140                         /*
1141                          * If that's true then all available contexts already
1142                          * have reservations and cannot be used.
1143                          */
1144                         if (!curr_ctx ||
1145                             (curr_ctx->replace_state ==
1146                              IEEE80211_CHANCTX_WILL_BE_REPLACED) ||
1147                             !list_empty(&curr_ctx->reserved_links))
1148                                 return -EBUSY;
1149
1150                         new_ctx = ieee80211_alloc_chanctx(local, chandef, mode);
1151                         if (!new_ctx)
1152                                 return -ENOMEM;
1153
1154                         new_ctx->replace_ctx = curr_ctx;
1155                         new_ctx->replace_state =
1156                                         IEEE80211_CHANCTX_REPLACES_OTHER;
1157
1158                         curr_ctx->replace_ctx = new_ctx;
1159                         curr_ctx->replace_state =
1160                                         IEEE80211_CHANCTX_WILL_BE_REPLACED;
1161
1162                         list_add_rcu(&new_ctx->list, &local->chanctx_list);
1163                 }
1164         }
1165
1166         list_add(&link->reserved_chanctx_list, &new_ctx->reserved_links);
1167         link->reserved_chanctx = new_ctx;
1168         link->reserved_chandef = *chandef;
1169         link->reserved_radar_required = radar_required;
1170         link->reserved_ready = false;
1171
1172         return 0;
1173 }
1174
1175 static void
1176 ieee80211_link_chanctx_reservation_complete(struct ieee80211_link_data *link)
1177 {
1178         struct ieee80211_sub_if_data *sdata = link->sdata;
1179
1180         switch (sdata->vif.type) {
1181         case NL80211_IFTYPE_ADHOC:
1182         case NL80211_IFTYPE_AP:
1183         case NL80211_IFTYPE_MESH_POINT:
1184         case NL80211_IFTYPE_OCB:
1185                 ieee80211_queue_work(&sdata->local->hw,
1186                                      &link->csa_finalize_work);
1187                 break;
1188         case NL80211_IFTYPE_STATION:
1189                 ieee80211_queue_work(&sdata->local->hw,
1190                                      &link->u.mgd.chswitch_work);
1191                 break;
1192         case NL80211_IFTYPE_UNSPECIFIED:
1193         case NL80211_IFTYPE_AP_VLAN:
1194         case NL80211_IFTYPE_WDS:
1195         case NL80211_IFTYPE_MONITOR:
1196         case NL80211_IFTYPE_P2P_CLIENT:
1197         case NL80211_IFTYPE_P2P_GO:
1198         case NL80211_IFTYPE_P2P_DEVICE:
1199         case NL80211_IFTYPE_NAN:
1200         case NUM_NL80211_IFTYPES:
1201                 WARN_ON(1);
1202                 break;
1203         }
1204 }
1205
1206 static void
1207 ieee80211_link_update_chandef(struct ieee80211_link_data *link,
1208                               const struct cfg80211_chan_def *chandef)
1209 {
1210         struct ieee80211_sub_if_data *sdata = link->sdata;
1211         unsigned int link_id = link->link_id;
1212         struct ieee80211_sub_if_data *vlan;
1213
1214         link->conf->chandef = *chandef;
1215
1216         if (sdata->vif.type != NL80211_IFTYPE_AP)
1217                 return;
1218
1219         rcu_read_lock();
1220         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
1221                 struct ieee80211_bss_conf *vlan_conf;
1222
1223                 vlan_conf = rcu_dereference(vlan->vif.link_conf[link_id]);
1224                 if (WARN_ON(!vlan_conf))
1225                         continue;
1226
1227                 vlan_conf->chandef = *chandef;
1228         }
1229         rcu_read_unlock();
1230 }
1231
1232 static int
1233 ieee80211_link_use_reserved_reassign(struct ieee80211_link_data *link)
1234 {
1235         struct ieee80211_sub_if_data *sdata = link->sdata;
1236         struct ieee80211_bss_conf *link_conf = link->conf;
1237         struct ieee80211_local *local = sdata->local;
1238         struct ieee80211_vif_chanctx_switch vif_chsw[1] = {};
1239         struct ieee80211_chanctx *old_ctx, *new_ctx;
1240         const struct cfg80211_chan_def *chandef;
1241         u32 changed = 0;
1242         int err;
1243
1244         lockdep_assert_held(&local->mtx);
1245         lockdep_assert_held(&local->chanctx_mtx);
1246
1247         new_ctx = link->reserved_chanctx;
1248         old_ctx = ieee80211_link_get_chanctx(link);
1249
1250         if (WARN_ON(!link->reserved_ready))
1251                 return -EBUSY;
1252
1253         if (WARN_ON(!new_ctx))
1254                 return -EINVAL;
1255
1256         if (WARN_ON(!old_ctx))
1257                 return -EINVAL;
1258
1259         if (WARN_ON(new_ctx->replace_state ==
1260                     IEEE80211_CHANCTX_REPLACES_OTHER))
1261                 return -EINVAL;
1262
1263         chandef = ieee80211_chanctx_non_reserved_chandef(local, new_ctx,
1264                                 &link->reserved_chandef);
1265         if (WARN_ON(!chandef))
1266                 return -EINVAL;
1267
1268         if (link_conf->chandef.width != link->reserved_chandef.width)
1269                 changed = BSS_CHANGED_BANDWIDTH;
1270
1271         ieee80211_link_update_chandef(link, &link->reserved_chandef);
1272
1273         ieee80211_change_chanctx(local, new_ctx, old_ctx, chandef);
1274
1275         vif_chsw[0].vif = &sdata->vif;
1276         vif_chsw[0].old_ctx = &old_ctx->conf;
1277         vif_chsw[0].new_ctx = &new_ctx->conf;
1278         vif_chsw[0].link_conf = link->conf;
1279
1280         list_del(&link->reserved_chanctx_list);
1281         link->reserved_chanctx = NULL;
1282
1283         err = drv_switch_vif_chanctx(local, vif_chsw, 1,
1284                                      CHANCTX_SWMODE_REASSIGN_VIF);
1285         if (err) {
1286                 if (ieee80211_chanctx_refcount(local, new_ctx) == 0)
1287                         ieee80211_free_chanctx(local, new_ctx);
1288
1289                 goto out;
1290         }
1291
1292         list_move(&link->assigned_chanctx_list, &new_ctx->assigned_links);
1293         rcu_assign_pointer(link_conf->chanctx_conf, &new_ctx->conf);
1294
1295         if (sdata->vif.type == NL80211_IFTYPE_AP)
1296                 __ieee80211_link_copy_chanctx_to_vlans(link, false);
1297
1298         ieee80211_check_fast_xmit_iface(sdata);
1299
1300         if (ieee80211_chanctx_refcount(local, old_ctx) == 0)
1301                 ieee80211_free_chanctx(local, old_ctx);
1302
1303         ieee80211_recalc_chanctx_min_def(local, new_ctx);
1304         ieee80211_recalc_smps_chanctx(local, new_ctx);
1305         ieee80211_recalc_radar_chanctx(local, new_ctx);
1306
1307         if (changed)
1308                 ieee80211_link_info_change_notify(sdata, link, changed);
1309
1310 out:
1311         ieee80211_link_chanctx_reservation_complete(link);
1312         return err;
1313 }
1314
1315 static int
1316 ieee80211_link_use_reserved_assign(struct ieee80211_link_data *link)
1317 {
1318         struct ieee80211_sub_if_data *sdata = link->sdata;
1319         struct ieee80211_local *local = sdata->local;
1320         struct ieee80211_chanctx *old_ctx, *new_ctx;
1321         const struct cfg80211_chan_def *chandef;
1322         int err;
1323
1324         old_ctx = ieee80211_link_get_chanctx(link);
1325         new_ctx = link->reserved_chanctx;
1326
1327         if (WARN_ON(!link->reserved_ready))
1328                 return -EINVAL;
1329
1330         if (WARN_ON(old_ctx))
1331                 return -EINVAL;
1332
1333         if (WARN_ON(!new_ctx))
1334                 return -EINVAL;
1335
1336         if (WARN_ON(new_ctx->replace_state ==
1337                     IEEE80211_CHANCTX_REPLACES_OTHER))
1338                 return -EINVAL;
1339
1340         chandef = ieee80211_chanctx_non_reserved_chandef(local, new_ctx,
1341                                 &link->reserved_chandef);
1342         if (WARN_ON(!chandef))
1343                 return -EINVAL;
1344
1345         ieee80211_change_chanctx(local, new_ctx, new_ctx, chandef);
1346
1347         list_del(&link->reserved_chanctx_list);
1348         link->reserved_chanctx = NULL;
1349
1350         err = ieee80211_assign_link_chanctx(link, new_ctx);
1351         if (err) {
1352                 if (ieee80211_chanctx_refcount(local, new_ctx) == 0)
1353                         ieee80211_free_chanctx(local, new_ctx);
1354
1355                 goto out;
1356         }
1357
1358 out:
1359         ieee80211_link_chanctx_reservation_complete(link);
1360         return err;
1361 }
1362
1363 static bool
1364 ieee80211_link_has_in_place_reservation(struct ieee80211_link_data *link)
1365 {
1366         struct ieee80211_sub_if_data *sdata = link->sdata;
1367         struct ieee80211_chanctx *old_ctx, *new_ctx;
1368
1369         lockdep_assert_held(&sdata->local->chanctx_mtx);
1370
1371         new_ctx = link->reserved_chanctx;
1372         old_ctx = ieee80211_link_get_chanctx(link);
1373
1374         if (!old_ctx)
1375                 return false;
1376
1377         if (WARN_ON(!new_ctx))
1378                 return false;
1379
1380         if (old_ctx->replace_state != IEEE80211_CHANCTX_WILL_BE_REPLACED)
1381                 return false;
1382
1383         if (new_ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1384                 return false;
1385
1386         return true;
1387 }
1388
1389 static int ieee80211_chsw_switch_hwconf(struct ieee80211_local *local,
1390                                         struct ieee80211_chanctx *new_ctx)
1391 {
1392         const struct cfg80211_chan_def *chandef;
1393
1394         lockdep_assert_held(&local->mtx);
1395         lockdep_assert_held(&local->chanctx_mtx);
1396
1397         chandef = ieee80211_chanctx_reserved_chandef(local, new_ctx, NULL);
1398         if (WARN_ON(!chandef))
1399                 return -EINVAL;
1400
1401         local->hw.conf.radar_enabled = new_ctx->conf.radar_enabled;
1402         local->_oper_chandef = *chandef;
1403         ieee80211_hw_config(local, 0);
1404
1405         return 0;
1406 }
1407
1408 static int ieee80211_chsw_switch_vifs(struct ieee80211_local *local,
1409                                       int n_vifs)
1410 {
1411         struct ieee80211_vif_chanctx_switch *vif_chsw;
1412         struct ieee80211_link_data *link;
1413         struct ieee80211_chanctx *ctx, *old_ctx;
1414         int i, err;
1415
1416         lockdep_assert_held(&local->mtx);
1417         lockdep_assert_held(&local->chanctx_mtx);
1418
1419         vif_chsw = kcalloc(n_vifs, sizeof(vif_chsw[0]), GFP_KERNEL);
1420         if (!vif_chsw)
1421                 return -ENOMEM;
1422
1423         i = 0;
1424         list_for_each_entry(ctx, &local->chanctx_list, list) {
1425                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1426                         continue;
1427
1428                 if (WARN_ON(!ctx->replace_ctx)) {
1429                         err = -EINVAL;
1430                         goto out;
1431                 }
1432
1433                 list_for_each_entry(link, &ctx->reserved_links,
1434                                     reserved_chanctx_list) {
1435                         if (!ieee80211_link_has_in_place_reservation(link))
1436                                 continue;
1437
1438                         old_ctx = ieee80211_link_get_chanctx(link);
1439                         vif_chsw[i].vif = &link->sdata->vif;
1440                         vif_chsw[i].old_ctx = &old_ctx->conf;
1441                         vif_chsw[i].new_ctx = &ctx->conf;
1442                         vif_chsw[i].link_conf = link->conf;
1443
1444                         i++;
1445                 }
1446         }
1447
1448         err = drv_switch_vif_chanctx(local, vif_chsw, n_vifs,
1449                                      CHANCTX_SWMODE_SWAP_CONTEXTS);
1450
1451 out:
1452         kfree(vif_chsw);
1453         return err;
1454 }
1455
1456 static int ieee80211_chsw_switch_ctxs(struct ieee80211_local *local)
1457 {
1458         struct ieee80211_chanctx *ctx;
1459         int err;
1460
1461         lockdep_assert_held(&local->mtx);
1462         lockdep_assert_held(&local->chanctx_mtx);
1463
1464         list_for_each_entry(ctx, &local->chanctx_list, list) {
1465                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1466                         continue;
1467
1468                 if (!list_empty(&ctx->replace_ctx->assigned_links))
1469                         continue;
1470
1471                 ieee80211_del_chanctx(local, ctx->replace_ctx);
1472                 err = ieee80211_add_chanctx(local, ctx);
1473                 if (err)
1474                         goto err;
1475         }
1476
1477         return 0;
1478
1479 err:
1480         WARN_ON(ieee80211_add_chanctx(local, ctx));
1481         list_for_each_entry_continue_reverse(ctx, &local->chanctx_list, list) {
1482                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1483                         continue;
1484
1485                 if (!list_empty(&ctx->replace_ctx->assigned_links))
1486                         continue;
1487
1488                 ieee80211_del_chanctx(local, ctx);
1489                 WARN_ON(ieee80211_add_chanctx(local, ctx->replace_ctx));
1490         }
1491
1492         return err;
1493 }
1494
1495 static int ieee80211_vif_use_reserved_switch(struct ieee80211_local *local)
1496 {
1497         struct ieee80211_chanctx *ctx, *ctx_tmp, *old_ctx;
1498         struct ieee80211_chanctx *new_ctx = NULL;
1499         int err, n_assigned, n_reserved, n_ready;
1500         int n_ctx = 0, n_vifs_switch = 0, n_vifs_assign = 0, n_vifs_ctxless = 0;
1501
1502         lockdep_assert_held(&local->mtx);
1503         lockdep_assert_held(&local->chanctx_mtx);
1504
1505         /*
1506          * If there are 2 independent pairs of channel contexts performing
1507          * cross-switch of their vifs this code will still wait until both are
1508          * ready even though it could be possible to switch one before the
1509          * other is ready.
1510          *
1511          * For practical reasons and code simplicity just do a single huge
1512          * switch.
1513          */
1514
1515         /*
1516          * Verify if the reservation is still feasible.
1517          *  - if it's not then disconnect
1518          *  - if it is but not all vifs necessary are ready then defer
1519          */
1520
1521         list_for_each_entry(ctx, &local->chanctx_list, list) {
1522                 struct ieee80211_link_data *link;
1523
1524                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1525                         continue;
1526
1527                 if (WARN_ON(!ctx->replace_ctx)) {
1528                         err = -EINVAL;
1529                         goto err;
1530                 }
1531
1532                 if (!local->use_chanctx)
1533                         new_ctx = ctx;
1534
1535                 n_ctx++;
1536
1537                 n_assigned = 0;
1538                 n_reserved = 0;
1539                 n_ready = 0;
1540
1541                 list_for_each_entry(link, &ctx->replace_ctx->assigned_links,
1542                                     assigned_chanctx_list) {
1543                         n_assigned++;
1544                         if (link->reserved_chanctx) {
1545                                 n_reserved++;
1546                                 if (link->reserved_ready)
1547                                         n_ready++;
1548                         }
1549                 }
1550
1551                 if (n_assigned != n_reserved) {
1552                         if (n_ready == n_reserved) {
1553                                 wiphy_info(local->hw.wiphy,
1554                                            "channel context reservation cannot be finalized because some interfaces aren't switching\n");
1555                                 err = -EBUSY;
1556                                 goto err;
1557                         }
1558
1559                         return -EAGAIN;
1560                 }
1561
1562                 ctx->conf.radar_enabled = false;
1563                 list_for_each_entry(link, &ctx->reserved_links,
1564                                     reserved_chanctx_list) {
1565                         if (ieee80211_link_has_in_place_reservation(link) &&
1566                             !link->reserved_ready)
1567                                 return -EAGAIN;
1568
1569                         old_ctx = ieee80211_link_get_chanctx(link);
1570                         if (old_ctx) {
1571                                 if (old_ctx->replace_state ==
1572                                     IEEE80211_CHANCTX_WILL_BE_REPLACED)
1573                                         n_vifs_switch++;
1574                                 else
1575                                         n_vifs_assign++;
1576                         } else {
1577                                 n_vifs_ctxless++;
1578                         }
1579
1580                         if (link->reserved_radar_required)
1581                                 ctx->conf.radar_enabled = true;
1582                 }
1583         }
1584
1585         if (WARN_ON(n_ctx == 0) ||
1586             WARN_ON(n_vifs_switch == 0 &&
1587                     n_vifs_assign == 0 &&
1588                     n_vifs_ctxless == 0) ||
1589             WARN_ON(n_ctx > 1 && !local->use_chanctx) ||
1590             WARN_ON(!new_ctx && !local->use_chanctx)) {
1591                 err = -EINVAL;
1592                 goto err;
1593         }
1594
1595         /*
1596          * All necessary vifs are ready. Perform the switch now depending on
1597          * reservations and driver capabilities.
1598          */
1599
1600         if (local->use_chanctx) {
1601                 if (n_vifs_switch > 0) {
1602                         err = ieee80211_chsw_switch_vifs(local, n_vifs_switch);
1603                         if (err)
1604                                 goto err;
1605                 }
1606
1607                 if (n_vifs_assign > 0 || n_vifs_ctxless > 0) {
1608                         err = ieee80211_chsw_switch_ctxs(local);
1609                         if (err)
1610                                 goto err;
1611                 }
1612         } else {
1613                 err = ieee80211_chsw_switch_hwconf(local, new_ctx);
1614                 if (err)
1615                         goto err;
1616         }
1617
1618         /*
1619          * Update all structures, values and pointers to point to new channel
1620          * context(s).
1621          */
1622         list_for_each_entry(ctx, &local->chanctx_list, list) {
1623                 struct ieee80211_link_data *link, *link_tmp;
1624
1625                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1626                         continue;
1627
1628                 if (WARN_ON(!ctx->replace_ctx)) {
1629                         err = -EINVAL;
1630                         goto err;
1631                 }
1632
1633                 list_for_each_entry(link, &ctx->reserved_links,
1634                                     reserved_chanctx_list) {
1635                         struct ieee80211_sub_if_data *sdata = link->sdata;
1636                         struct ieee80211_bss_conf *link_conf = link->conf;
1637                         u32 changed = 0;
1638
1639                         if (!ieee80211_link_has_in_place_reservation(link))
1640                                 continue;
1641
1642                         rcu_assign_pointer(link_conf->chanctx_conf,
1643                                            &ctx->conf);
1644
1645                         if (sdata->vif.type == NL80211_IFTYPE_AP)
1646                                 __ieee80211_link_copy_chanctx_to_vlans(link,
1647                                                                        false);
1648
1649                         ieee80211_check_fast_xmit_iface(sdata);
1650
1651                         link->radar_required = link->reserved_radar_required;
1652
1653                         if (link_conf->chandef.width != link->reserved_chandef.width)
1654                                 changed = BSS_CHANGED_BANDWIDTH;
1655
1656                         ieee80211_link_update_chandef(link, &link->reserved_chandef);
1657                         if (changed)
1658                                 ieee80211_link_info_change_notify(sdata,
1659                                                                   link,
1660                                                                   changed);
1661
1662                         ieee80211_recalc_txpower(sdata, false);
1663                 }
1664
1665                 ieee80211_recalc_chanctx_chantype(local, ctx);
1666                 ieee80211_recalc_smps_chanctx(local, ctx);
1667                 ieee80211_recalc_radar_chanctx(local, ctx);
1668                 ieee80211_recalc_chanctx_min_def(local, ctx);
1669
1670                 list_for_each_entry_safe(link, link_tmp, &ctx->reserved_links,
1671                                          reserved_chanctx_list) {
1672                         if (ieee80211_link_get_chanctx(link) != ctx)
1673                                 continue;
1674
1675                         list_del(&link->reserved_chanctx_list);
1676                         list_move(&link->assigned_chanctx_list,
1677                                   &ctx->assigned_links);
1678                         link->reserved_chanctx = NULL;
1679
1680                         ieee80211_link_chanctx_reservation_complete(link);
1681                 }
1682
1683                 /*
1684                  * This context might have been a dependency for an already
1685                  * ready re-assign reservation interface that was deferred. Do
1686                  * not propagate error to the caller though. The in-place
1687                  * reservation for originally requested interface has already
1688                  * succeeded at this point.
1689                  */
1690                 list_for_each_entry_safe(link, link_tmp, &ctx->reserved_links,
1691                                          reserved_chanctx_list) {
1692                         if (WARN_ON(ieee80211_link_has_in_place_reservation(link)))
1693                                 continue;
1694
1695                         if (WARN_ON(link->reserved_chanctx != ctx))
1696                                 continue;
1697
1698                         if (!link->reserved_ready)
1699                                 continue;
1700
1701                         if (ieee80211_link_get_chanctx(link))
1702                                 err = ieee80211_link_use_reserved_reassign(link);
1703                         else
1704                                 err = ieee80211_link_use_reserved_assign(link);
1705
1706                         if (err) {
1707                                 link_info(link,
1708                                           "failed to finalize (re-)assign reservation (err=%d)\n",
1709                                           err);
1710                                 ieee80211_link_unreserve_chanctx(link);
1711                                 cfg80211_stop_iface(local->hw.wiphy,
1712                                                     &link->sdata->wdev,
1713                                                     GFP_KERNEL);
1714                         }
1715                 }
1716         }
1717
1718         /*
1719          * Finally free old contexts
1720          */
1721
1722         list_for_each_entry_safe(ctx, ctx_tmp, &local->chanctx_list, list) {
1723                 if (ctx->replace_state != IEEE80211_CHANCTX_WILL_BE_REPLACED)
1724                         continue;
1725
1726                 ctx->replace_ctx->replace_ctx = NULL;
1727                 ctx->replace_ctx->replace_state =
1728                                 IEEE80211_CHANCTX_REPLACE_NONE;
1729
1730                 list_del_rcu(&ctx->list);
1731                 kfree_rcu(ctx, rcu_head);
1732         }
1733
1734         return 0;
1735
1736 err:
1737         list_for_each_entry(ctx, &local->chanctx_list, list) {
1738                 struct ieee80211_link_data *link, *link_tmp;
1739
1740                 if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1741                         continue;
1742
1743                 list_for_each_entry_safe(link, link_tmp, &ctx->reserved_links,
1744                                          reserved_chanctx_list) {
1745                         ieee80211_link_unreserve_chanctx(link);
1746                         ieee80211_link_chanctx_reservation_complete(link);
1747                 }
1748         }
1749
1750         return err;
1751 }
1752
1753 static void __ieee80211_link_release_channel(struct ieee80211_link_data *link)
1754 {
1755         struct ieee80211_sub_if_data *sdata = link->sdata;
1756         struct ieee80211_bss_conf *link_conf = link->conf;
1757         struct ieee80211_local *local = sdata->local;
1758         struct ieee80211_chanctx_conf *conf;
1759         struct ieee80211_chanctx *ctx;
1760         bool use_reserved_switch = false;
1761
1762         lockdep_assert_held(&local->chanctx_mtx);
1763
1764         conf = rcu_dereference_protected(link_conf->chanctx_conf,
1765                                          lockdep_is_held(&local->chanctx_mtx));
1766         if (!conf)
1767                 return;
1768
1769         ctx = container_of(conf, struct ieee80211_chanctx, conf);
1770
1771         if (link->reserved_chanctx) {
1772                 if (link->reserved_chanctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
1773                     ieee80211_chanctx_num_reserved(local, link->reserved_chanctx) > 1)
1774                         use_reserved_switch = true;
1775
1776                 ieee80211_link_unreserve_chanctx(link);
1777         }
1778
1779         ieee80211_assign_link_chanctx(link, NULL);
1780         if (ieee80211_chanctx_refcount(local, ctx) == 0)
1781                 ieee80211_free_chanctx(local, ctx);
1782
1783         link->radar_required = false;
1784
1785         /* Unreserving may ready an in-place reservation. */
1786         if (use_reserved_switch)
1787                 ieee80211_vif_use_reserved_switch(local);
1788 }
1789
1790 int ieee80211_link_use_channel(struct ieee80211_link_data *link,
1791                                const struct cfg80211_chan_def *chandef,
1792                                enum ieee80211_chanctx_mode mode)
1793 {
1794         struct ieee80211_sub_if_data *sdata = link->sdata;
1795         struct ieee80211_local *local = sdata->local;
1796         struct ieee80211_chanctx *ctx;
1797         u8 radar_detect_width = 0;
1798         int ret;
1799
1800         lockdep_assert_held(&local->mtx);
1801
1802         mutex_lock(&local->chanctx_mtx);
1803
1804         ret = cfg80211_chandef_dfs_required(local->hw.wiphy,
1805                                             chandef,
1806                                             sdata->wdev.iftype);
1807         if (ret < 0)
1808                 goto out;
1809         if (ret > 0)
1810                 radar_detect_width = BIT(chandef->width);
1811
1812         link->radar_required = ret;
1813
1814         ret = ieee80211_check_combinations(sdata, chandef, mode,
1815                                            radar_detect_width);
1816         if (ret < 0)
1817                 goto out;
1818
1819         __ieee80211_link_release_channel(link);
1820
1821         ctx = ieee80211_find_chanctx(local, chandef, mode);
1822         if (!ctx)
1823                 ctx = ieee80211_new_chanctx(local, chandef, mode);
1824         if (IS_ERR(ctx)) {
1825                 ret = PTR_ERR(ctx);
1826                 goto out;
1827         }
1828
1829         ieee80211_link_update_chandef(link, chandef);
1830
1831         ret = ieee80211_assign_link_chanctx(link, ctx);
1832         if (ret) {
1833                 /* if assign fails refcount stays the same */
1834                 if (ieee80211_chanctx_refcount(local, ctx) == 0)
1835                         ieee80211_free_chanctx(local, ctx);
1836                 goto out;
1837         }
1838
1839         ieee80211_recalc_smps_chanctx(local, ctx);
1840         ieee80211_recalc_radar_chanctx(local, ctx);
1841  out:
1842         if (ret)
1843                 link->radar_required = false;
1844
1845         mutex_unlock(&local->chanctx_mtx);
1846         return ret;
1847 }
1848
1849 int ieee80211_link_use_reserved_context(struct ieee80211_link_data *link)
1850 {
1851         struct ieee80211_sub_if_data *sdata = link->sdata;
1852         struct ieee80211_local *local = sdata->local;
1853         struct ieee80211_chanctx *new_ctx;
1854         struct ieee80211_chanctx *old_ctx;
1855         int err;
1856
1857         lockdep_assert_held(&local->mtx);
1858         lockdep_assert_held(&local->chanctx_mtx);
1859
1860         new_ctx = link->reserved_chanctx;
1861         old_ctx = ieee80211_link_get_chanctx(link);
1862
1863         if (WARN_ON(!new_ctx))
1864                 return -EINVAL;
1865
1866         if (WARN_ON(new_ctx->replace_state ==
1867                     IEEE80211_CHANCTX_WILL_BE_REPLACED))
1868                 return -EINVAL;
1869
1870         if (WARN_ON(link->reserved_ready))
1871                 return -EINVAL;
1872
1873         link->reserved_ready = true;
1874
1875         if (new_ctx->replace_state == IEEE80211_CHANCTX_REPLACE_NONE) {
1876                 if (old_ctx)
1877                         return ieee80211_link_use_reserved_reassign(link);
1878
1879                 return ieee80211_link_use_reserved_assign(link);
1880         }
1881
1882         /*
1883          * In-place reservation may need to be finalized now either if:
1884          *  a) sdata is taking part in the swapping itself and is the last one
1885          *  b) sdata has switched with a re-assign reservation to an existing
1886          *     context readying in-place switching of old_ctx
1887          *
1888          * In case of (b) do not propagate the error up because the requested
1889          * sdata already switched successfully. Just spill an extra warning.
1890          * The ieee80211_vif_use_reserved_switch() already stops all necessary
1891          * interfaces upon failure.
1892          */
1893         if ((old_ctx &&
1894              old_ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED) ||
1895             new_ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER) {
1896                 err = ieee80211_vif_use_reserved_switch(local);
1897                 if (err && err != -EAGAIN) {
1898                         if (new_ctx->replace_state ==
1899                             IEEE80211_CHANCTX_REPLACES_OTHER)
1900                                 return err;
1901
1902                         wiphy_info(local->hw.wiphy,
1903                                    "depending in-place reservation failed (err=%d)\n",
1904                                    err);
1905                 }
1906         }
1907
1908         return 0;
1909 }
1910
1911 int ieee80211_link_change_bandwidth(struct ieee80211_link_data *link,
1912                                     const struct cfg80211_chan_def *chandef,
1913                                     u32 *changed)
1914 {
1915         struct ieee80211_sub_if_data *sdata = link->sdata;
1916         struct ieee80211_bss_conf *link_conf = link->conf;
1917         struct ieee80211_local *local = sdata->local;
1918         struct ieee80211_chanctx_conf *conf;
1919         struct ieee80211_chanctx *ctx;
1920         const struct cfg80211_chan_def *compat;
1921         int ret;
1922
1923         if (!cfg80211_chandef_usable(sdata->local->hw.wiphy, chandef,
1924                                      IEEE80211_CHAN_DISABLED))
1925                 return -EINVAL;
1926
1927         mutex_lock(&local->chanctx_mtx);
1928         if (cfg80211_chandef_identical(chandef, &link_conf->chandef)) {
1929                 ret = 0;
1930                 goto out;
1931         }
1932
1933         if (chandef->width == NL80211_CHAN_WIDTH_20_NOHT ||
1934             link_conf->chandef.width == NL80211_CHAN_WIDTH_20_NOHT) {
1935                 ret = -EINVAL;
1936                 goto out;
1937         }
1938
1939         conf = rcu_dereference_protected(link_conf->chanctx_conf,
1940                                          lockdep_is_held(&local->chanctx_mtx));
1941         if (!conf) {
1942                 ret = -EINVAL;
1943                 goto out;
1944         }
1945
1946         ctx = container_of(conf, struct ieee80211_chanctx, conf);
1947
1948         compat = cfg80211_chandef_compatible(&conf->def, chandef);
1949         if (!compat) {
1950                 ret = -EINVAL;
1951                 goto out;
1952         }
1953
1954         switch (ctx->replace_state) {
1955         case IEEE80211_CHANCTX_REPLACE_NONE:
1956                 if (!ieee80211_chanctx_reserved_chandef(local, ctx, compat)) {
1957                         ret = -EBUSY;
1958                         goto out;
1959                 }
1960                 break;
1961         case IEEE80211_CHANCTX_WILL_BE_REPLACED:
1962                 /* TODO: Perhaps the bandwidth change could be treated as a
1963                  * reservation itself? */
1964                 ret = -EBUSY;
1965                 goto out;
1966         case IEEE80211_CHANCTX_REPLACES_OTHER:
1967                 /* channel context that is going to replace another channel
1968                  * context doesn't really exist and shouldn't be assigned
1969                  * anywhere yet */
1970                 WARN_ON(1);
1971                 break;
1972         }
1973
1974         ieee80211_link_update_chandef(link, chandef);
1975
1976         ieee80211_recalc_chanctx_chantype(local, ctx);
1977
1978         *changed |= BSS_CHANGED_BANDWIDTH;
1979         ret = 0;
1980  out:
1981         mutex_unlock(&local->chanctx_mtx);
1982         return ret;
1983 }
1984
1985 void ieee80211_link_release_channel(struct ieee80211_link_data *link)
1986 {
1987         struct ieee80211_sub_if_data *sdata = link->sdata;
1988
1989         mutex_lock(&sdata->local->chanctx_mtx);
1990         if (rcu_access_pointer(link->conf->chanctx_conf)) {
1991                 lockdep_assert_held(&sdata->local->mtx);
1992                 __ieee80211_link_release_channel(link);
1993         }
1994         mutex_unlock(&sdata->local->chanctx_mtx);
1995 }
1996
1997 void ieee80211_link_vlan_copy_chanctx(struct ieee80211_link_data *link)
1998 {
1999         struct ieee80211_sub_if_data *sdata = link->sdata;
2000         unsigned int link_id = link->link_id;
2001         struct ieee80211_bss_conf *link_conf = link->conf;
2002         struct ieee80211_bss_conf *ap_conf;
2003         struct ieee80211_local *local = sdata->local;
2004         struct ieee80211_sub_if_data *ap;
2005         struct ieee80211_chanctx_conf *conf;
2006
2007         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->bss))
2008                 return;
2009
2010         ap = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
2011
2012         mutex_lock(&local->chanctx_mtx);
2013
2014         rcu_read_lock();
2015         ap_conf = rcu_dereference(ap->vif.link_conf[link_id]);
2016         conf = rcu_dereference_protected(ap_conf->chanctx_conf,
2017                                          lockdep_is_held(&local->chanctx_mtx));
2018         rcu_assign_pointer(link_conf->chanctx_conf, conf);
2019         rcu_read_unlock();
2020         mutex_unlock(&local->chanctx_mtx);
2021 }
2022
2023 void ieee80211_iter_chan_contexts_atomic(
2024         struct ieee80211_hw *hw,
2025         void (*iter)(struct ieee80211_hw *hw,
2026                      struct ieee80211_chanctx_conf *chanctx_conf,
2027                      void *data),
2028         void *iter_data)
2029 {
2030         struct ieee80211_local *local = hw_to_local(hw);
2031         struct ieee80211_chanctx *ctx;
2032
2033         rcu_read_lock();
2034         list_for_each_entry_rcu(ctx, &local->chanctx_list, list)
2035                 if (ctx->driver_present)
2036                         iter(hw, &ctx->conf, iter_data);
2037         rcu_read_unlock();
2038 }
2039 EXPORT_SYMBOL_GPL(ieee80211_iter_chan_contexts_atomic);