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