2 * mac80211 - channel management
5 #include <linux/nl80211.h>
6 #include <linux/export.h>
7 #include <linux/rtnetlink.h>
8 #include <net/cfg80211.h>
9 #include "ieee80211_i.h"
10 #include "driver-ops.h"
12 static int ieee80211_chanctx_num_assigned(struct ieee80211_local
*local
,
13 struct ieee80211_chanctx
*ctx
)
15 struct ieee80211_sub_if_data
*sdata
;
18 lockdep_assert_held(&local
->chanctx_mtx
);
20 list_for_each_entry(sdata
, &ctx
->assigned_vifs
, assigned_chanctx_list
)
26 static int ieee80211_chanctx_num_reserved(struct ieee80211_local
*local
,
27 struct ieee80211_chanctx
*ctx
)
29 struct ieee80211_sub_if_data
*sdata
;
32 lockdep_assert_held(&local
->chanctx_mtx
);
34 list_for_each_entry(sdata
, &ctx
->reserved_vifs
, reserved_chanctx_list
)
40 int ieee80211_chanctx_refcount(struct ieee80211_local
*local
,
41 struct ieee80211_chanctx
*ctx
)
43 return ieee80211_chanctx_num_assigned(local
, ctx
) +
44 ieee80211_chanctx_num_reserved(local
, ctx
);
47 static int ieee80211_num_chanctx(struct ieee80211_local
*local
)
49 struct ieee80211_chanctx
*ctx
;
52 lockdep_assert_held(&local
->chanctx_mtx
);
54 list_for_each_entry(ctx
, &local
->chanctx_list
, list
)
60 static bool ieee80211_can_create_new_chanctx(struct ieee80211_local
*local
)
62 lockdep_assert_held(&local
->chanctx_mtx
);
63 return ieee80211_num_chanctx(local
) < ieee80211_max_num_channels(local
);
66 static struct ieee80211_chanctx
*
67 ieee80211_vif_get_chanctx(struct ieee80211_sub_if_data
*sdata
)
69 struct ieee80211_local
*local __maybe_unused
= sdata
->local
;
70 struct ieee80211_chanctx_conf
*conf
;
72 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
73 lockdep_is_held(&local
->chanctx_mtx
));
77 return container_of(conf
, struct ieee80211_chanctx
, conf
);
80 static const struct cfg80211_chan_def
*
81 ieee80211_chanctx_reserved_chandef(struct ieee80211_local
*local
,
82 struct ieee80211_chanctx
*ctx
,
83 const struct cfg80211_chan_def
*compat
)
85 struct ieee80211_sub_if_data
*sdata
;
87 lockdep_assert_held(&local
->chanctx_mtx
);
89 list_for_each_entry(sdata
, &ctx
->reserved_vifs
,
90 reserved_chanctx_list
) {
92 compat
= &sdata
->reserved_chandef
;
94 compat
= cfg80211_chandef_compatible(&sdata
->reserved_chandef
,
103 static const struct cfg80211_chan_def
*
104 ieee80211_chanctx_non_reserved_chandef(struct ieee80211_local
*local
,
105 struct ieee80211_chanctx
*ctx
,
106 const struct cfg80211_chan_def
*compat
)
108 struct ieee80211_sub_if_data
*sdata
;
110 lockdep_assert_held(&local
->chanctx_mtx
);
112 list_for_each_entry(sdata
, &ctx
->assigned_vifs
,
113 assigned_chanctx_list
) {
114 if (sdata
->reserved_chanctx
!= NULL
)
118 compat
= &sdata
->vif
.bss_conf
.chandef
;
120 compat
= cfg80211_chandef_compatible(
121 &sdata
->vif
.bss_conf
.chandef
, compat
);
129 static const struct cfg80211_chan_def
*
130 ieee80211_chanctx_combined_chandef(struct ieee80211_local
*local
,
131 struct ieee80211_chanctx
*ctx
,
132 const struct cfg80211_chan_def
*compat
)
134 lockdep_assert_held(&local
->chanctx_mtx
);
136 compat
= ieee80211_chanctx_reserved_chandef(local
, ctx
, compat
);
140 compat
= ieee80211_chanctx_non_reserved_chandef(local
, ctx
, compat
);
148 ieee80211_chanctx_can_reserve_chandef(struct ieee80211_local
*local
,
149 struct ieee80211_chanctx
*ctx
,
150 const struct cfg80211_chan_def
*def
)
152 lockdep_assert_held(&local
->chanctx_mtx
);
154 if (ieee80211_chanctx_combined_chandef(local
, ctx
, def
))
157 if (!list_empty(&ctx
->reserved_vifs
) &&
158 ieee80211_chanctx_reserved_chandef(local
, ctx
, def
))
164 static struct ieee80211_chanctx
*
165 ieee80211_find_reservation_chanctx(struct ieee80211_local
*local
,
166 const struct cfg80211_chan_def
*chandef
,
167 enum ieee80211_chanctx_mode mode
)
169 struct ieee80211_chanctx
*ctx
;
171 lockdep_assert_held(&local
->chanctx_mtx
);
173 if (mode
== IEEE80211_CHANCTX_EXCLUSIVE
)
176 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
177 if (ctx
->replace_state
== IEEE80211_CHANCTX_WILL_BE_REPLACED
)
180 if (ctx
->mode
== IEEE80211_CHANCTX_EXCLUSIVE
)
183 if (!ieee80211_chanctx_can_reserve_chandef(local
, ctx
,
193 static enum nl80211_chan_width
ieee80211_get_sta_bw(struct ieee80211_sta
*sta
)
195 switch (sta
->bandwidth
) {
196 case IEEE80211_STA_RX_BW_20
:
197 if (sta
->ht_cap
.ht_supported
)
198 return NL80211_CHAN_WIDTH_20
;
200 return NL80211_CHAN_WIDTH_20_NOHT
;
201 case IEEE80211_STA_RX_BW_40
:
202 return NL80211_CHAN_WIDTH_40
;
203 case IEEE80211_STA_RX_BW_80
:
204 return NL80211_CHAN_WIDTH_80
;
205 case IEEE80211_STA_RX_BW_160
:
207 * This applied for both 160 and 80+80. since we use
208 * the returned value to consider degradation of
209 * ctx->conf.min_def, we have to make sure to take
210 * the bigger one (NL80211_CHAN_WIDTH_160).
211 * Otherwise we might try degrading even when not
212 * needed, as the max required sta_bw returned (80+80)
213 * might be smaller than the configured bw (160).
215 return NL80211_CHAN_WIDTH_160
;
218 return NL80211_CHAN_WIDTH_20
;
222 static enum nl80211_chan_width
223 ieee80211_get_max_required_bw(struct ieee80211_sub_if_data
*sdata
)
225 enum nl80211_chan_width max_bw
= NL80211_CHAN_WIDTH_20_NOHT
;
226 struct sta_info
*sta
;
229 list_for_each_entry_rcu(sta
, &sdata
->local
->sta_list
, list
) {
230 if (sdata
!= sta
->sdata
&&
231 !(sta
->sdata
->bss
&& sta
->sdata
->bss
== sdata
->bss
))
237 max_bw
= max(max_bw
, ieee80211_get_sta_bw(&sta
->sta
));
244 static enum nl80211_chan_width
245 ieee80211_get_chanctx_max_required_bw(struct ieee80211_local
*local
,
246 struct ieee80211_chanctx_conf
*conf
)
248 struct ieee80211_sub_if_data
*sdata
;
249 enum nl80211_chan_width max_bw
= NL80211_CHAN_WIDTH_20_NOHT
;
252 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
253 struct ieee80211_vif
*vif
= &sdata
->vif
;
254 enum nl80211_chan_width width
= NL80211_CHAN_WIDTH_20_NOHT
;
256 if (!ieee80211_sdata_running(sdata
))
259 if (rcu_access_pointer(sdata
->vif
.chanctx_conf
) != conf
)
263 case NL80211_IFTYPE_AP
:
264 case NL80211_IFTYPE_AP_VLAN
:
265 width
= ieee80211_get_max_required_bw(sdata
);
267 case NL80211_IFTYPE_P2P_DEVICE
:
269 case NL80211_IFTYPE_STATION
:
270 case NL80211_IFTYPE_ADHOC
:
271 case NL80211_IFTYPE_WDS
:
272 case NL80211_IFTYPE_MESH_POINT
:
273 case NL80211_IFTYPE_OCB
:
274 width
= vif
->bss_conf
.chandef
.width
;
276 case NL80211_IFTYPE_UNSPECIFIED
:
277 case NUM_NL80211_IFTYPES
:
278 case NL80211_IFTYPE_MONITOR
:
279 case NL80211_IFTYPE_P2P_CLIENT
:
280 case NL80211_IFTYPE_P2P_GO
:
283 max_bw
= max(max_bw
, width
);
286 /* use the configured bandwidth in case of monitor interface */
287 sdata
= rcu_dereference(local
->monitor_sdata
);
288 if (sdata
&& rcu_access_pointer(sdata
->vif
.chanctx_conf
) == conf
)
289 max_bw
= max(max_bw
, conf
->def
.width
);
297 * recalc the min required chan width of the channel context, which is
298 * the max of min required widths of all the interfaces bound to this
301 void ieee80211_recalc_chanctx_min_def(struct ieee80211_local
*local
,
302 struct ieee80211_chanctx
*ctx
)
304 enum nl80211_chan_width max_bw
;
305 struct cfg80211_chan_def min_def
;
307 lockdep_assert_held(&local
->chanctx_mtx
);
309 /* don't optimize 5MHz, 10MHz, and radar_enabled confs */
310 if (ctx
->conf
.def
.width
== NL80211_CHAN_WIDTH_5
||
311 ctx
->conf
.def
.width
== NL80211_CHAN_WIDTH_10
||
312 ctx
->conf
.radar_enabled
) {
313 ctx
->conf
.min_def
= ctx
->conf
.def
;
317 max_bw
= ieee80211_get_chanctx_max_required_bw(local
, &ctx
->conf
);
319 /* downgrade chandef up to max_bw */
320 min_def
= ctx
->conf
.def
;
321 while (min_def
.width
> max_bw
)
322 ieee80211_chandef_downgrade(&min_def
);
324 if (cfg80211_chandef_identical(&ctx
->conf
.min_def
, &min_def
))
327 ctx
->conf
.min_def
= min_def
;
328 if (!ctx
->driver_present
)
331 drv_change_chanctx(local
, ctx
, IEEE80211_CHANCTX_CHANGE_MIN_WIDTH
);
334 static void ieee80211_change_chanctx(struct ieee80211_local
*local
,
335 struct ieee80211_chanctx
*ctx
,
336 const struct cfg80211_chan_def
*chandef
)
338 if (cfg80211_chandef_identical(&ctx
->conf
.def
, chandef
))
341 WARN_ON(!cfg80211_chandef_compatible(&ctx
->conf
.def
, chandef
));
343 ctx
->conf
.def
= *chandef
;
344 drv_change_chanctx(local
, ctx
, IEEE80211_CHANCTX_CHANGE_WIDTH
);
345 ieee80211_recalc_chanctx_min_def(local
, ctx
);
347 if (!local
->use_chanctx
) {
348 local
->_oper_chandef
= *chandef
;
349 ieee80211_hw_config(local
, 0);
353 static struct ieee80211_chanctx
*
354 ieee80211_find_chanctx(struct ieee80211_local
*local
,
355 const struct cfg80211_chan_def
*chandef
,
356 enum ieee80211_chanctx_mode mode
)
358 struct ieee80211_chanctx
*ctx
;
360 lockdep_assert_held(&local
->chanctx_mtx
);
362 if (mode
== IEEE80211_CHANCTX_EXCLUSIVE
)
365 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
366 const struct cfg80211_chan_def
*compat
;
368 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACE_NONE
)
371 if (ctx
->mode
== IEEE80211_CHANCTX_EXCLUSIVE
)
374 compat
= cfg80211_chandef_compatible(&ctx
->conf
.def
, chandef
);
378 compat
= ieee80211_chanctx_reserved_chandef(local
, ctx
,
383 ieee80211_change_chanctx(local
, ctx
, compat
);
391 bool ieee80211_is_radar_required(struct ieee80211_local
*local
)
393 struct ieee80211_sub_if_data
*sdata
;
395 lockdep_assert_held(&local
->mtx
);
398 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
399 if (sdata
->radar_required
) {
410 ieee80211_chanctx_radar_required(struct ieee80211_local
*local
,
411 struct ieee80211_chanctx
*ctx
)
413 struct ieee80211_chanctx_conf
*conf
= &ctx
->conf
;
414 struct ieee80211_sub_if_data
*sdata
;
415 bool required
= false;
417 lockdep_assert_held(&local
->chanctx_mtx
);
418 lockdep_assert_held(&local
->mtx
);
421 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
422 if (!ieee80211_sdata_running(sdata
))
424 if (rcu_access_pointer(sdata
->vif
.chanctx_conf
) != conf
)
426 if (!sdata
->radar_required
)
437 static struct ieee80211_chanctx
*
438 ieee80211_alloc_chanctx(struct ieee80211_local
*local
,
439 const struct cfg80211_chan_def
*chandef
,
440 enum ieee80211_chanctx_mode mode
)
442 struct ieee80211_chanctx
*ctx
;
444 lockdep_assert_held(&local
->chanctx_mtx
);
446 ctx
= kzalloc(sizeof(*ctx
) + local
->hw
.chanctx_data_size
, GFP_KERNEL
);
450 INIT_LIST_HEAD(&ctx
->assigned_vifs
);
451 INIT_LIST_HEAD(&ctx
->reserved_vifs
);
452 ctx
->conf
.def
= *chandef
;
453 ctx
->conf
.rx_chains_static
= 1;
454 ctx
->conf
.rx_chains_dynamic
= 1;
456 ctx
->conf
.radar_enabled
= false;
457 ieee80211_recalc_chanctx_min_def(local
, ctx
);
462 static int ieee80211_add_chanctx(struct ieee80211_local
*local
,
463 struct ieee80211_chanctx
*ctx
)
468 lockdep_assert_held(&local
->mtx
);
469 lockdep_assert_held(&local
->chanctx_mtx
);
471 if (!local
->use_chanctx
)
472 local
->hw
.conf
.radar_enabled
= ctx
->conf
.radar_enabled
;
474 /* turn idle off *before* setting channel -- some drivers need that */
475 changed
= ieee80211_idle_off(local
);
477 ieee80211_hw_config(local
, changed
);
479 if (!local
->use_chanctx
) {
480 local
->_oper_chandef
= ctx
->conf
.def
;
481 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
483 err
= drv_add_chanctx(local
, ctx
);
485 ieee80211_recalc_idle(local
);
493 static struct ieee80211_chanctx
*
494 ieee80211_new_chanctx(struct ieee80211_local
*local
,
495 const struct cfg80211_chan_def
*chandef
,
496 enum ieee80211_chanctx_mode mode
)
498 struct ieee80211_chanctx
*ctx
;
501 lockdep_assert_held(&local
->mtx
);
502 lockdep_assert_held(&local
->chanctx_mtx
);
504 ctx
= ieee80211_alloc_chanctx(local
, chandef
, mode
);
506 return ERR_PTR(-ENOMEM
);
508 err
= ieee80211_add_chanctx(local
, ctx
);
514 list_add_rcu(&ctx
->list
, &local
->chanctx_list
);
518 static void ieee80211_del_chanctx(struct ieee80211_local
*local
,
519 struct ieee80211_chanctx
*ctx
)
521 lockdep_assert_held(&local
->chanctx_mtx
);
523 if (!local
->use_chanctx
) {
524 struct cfg80211_chan_def
*chandef
= &local
->_oper_chandef
;
525 chandef
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
526 chandef
->center_freq1
= chandef
->chan
->center_freq
;
527 chandef
->center_freq2
= 0;
529 /* NOTE: Disabling radar is only valid here for
530 * single channel context. To be sure, check it ...
532 WARN_ON(local
->hw
.conf
.radar_enabled
&&
533 !list_empty(&local
->chanctx_list
));
535 local
->hw
.conf
.radar_enabled
= false;
537 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
539 drv_remove_chanctx(local
, ctx
);
542 ieee80211_recalc_idle(local
);
545 static void ieee80211_free_chanctx(struct ieee80211_local
*local
,
546 struct ieee80211_chanctx
*ctx
)
548 lockdep_assert_held(&local
->chanctx_mtx
);
550 WARN_ON_ONCE(ieee80211_chanctx_refcount(local
, ctx
) != 0);
552 list_del_rcu(&ctx
->list
);
553 ieee80211_del_chanctx(local
, ctx
);
554 kfree_rcu(ctx
, rcu_head
);
557 static void ieee80211_recalc_chanctx_chantype(struct ieee80211_local
*local
,
558 struct ieee80211_chanctx
*ctx
)
560 struct ieee80211_chanctx_conf
*conf
= &ctx
->conf
;
561 struct ieee80211_sub_if_data
*sdata
;
562 const struct cfg80211_chan_def
*compat
= NULL
;
564 lockdep_assert_held(&local
->chanctx_mtx
);
567 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
569 if (!ieee80211_sdata_running(sdata
))
571 if (rcu_access_pointer(sdata
->vif
.chanctx_conf
) != conf
)
573 if (sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
)
577 compat
= &sdata
->vif
.bss_conf
.chandef
;
579 compat
= cfg80211_chandef_compatible(
580 &sdata
->vif
.bss_conf
.chandef
, compat
);
581 if (WARN_ON_ONCE(!compat
))
589 ieee80211_change_chanctx(local
, ctx
, compat
);
592 static void ieee80211_recalc_radar_chanctx(struct ieee80211_local
*local
,
593 struct ieee80211_chanctx
*chanctx
)
597 lockdep_assert_held(&local
->chanctx_mtx
);
598 /* for ieee80211_is_radar_required */
599 lockdep_assert_held(&local
->mtx
);
601 radar_enabled
= ieee80211_chanctx_radar_required(local
, chanctx
);
603 if (radar_enabled
== chanctx
->conf
.radar_enabled
)
606 chanctx
->conf
.radar_enabled
= radar_enabled
;
608 if (!local
->use_chanctx
) {
609 local
->hw
.conf
.radar_enabled
= chanctx
->conf
.radar_enabled
;
610 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
613 drv_change_chanctx(local
, chanctx
, IEEE80211_CHANCTX_CHANGE_RADAR
);
616 static int ieee80211_assign_vif_chanctx(struct ieee80211_sub_if_data
*sdata
,
617 struct ieee80211_chanctx
*new_ctx
)
619 struct ieee80211_local
*local
= sdata
->local
;
620 struct ieee80211_chanctx_conf
*conf
;
621 struct ieee80211_chanctx
*curr_ctx
= NULL
;
624 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
625 lockdep_is_held(&local
->chanctx_mtx
));
628 curr_ctx
= container_of(conf
, struct ieee80211_chanctx
, conf
);
630 drv_unassign_vif_chanctx(local
, sdata
, curr_ctx
);
632 list_del(&sdata
->assigned_chanctx_list
);
636 ret
= drv_assign_vif_chanctx(local
, sdata
, new_ctx
);
640 conf
= &new_ctx
->conf
;
641 list_add(&sdata
->assigned_chanctx_list
,
642 &new_ctx
->assigned_vifs
);
646 rcu_assign_pointer(sdata
->vif
.chanctx_conf
, conf
);
648 sdata
->vif
.bss_conf
.idle
= !conf
;
650 if (curr_ctx
&& ieee80211_chanctx_num_assigned(local
, curr_ctx
) > 0) {
651 ieee80211_recalc_chanctx_chantype(local
, curr_ctx
);
652 ieee80211_recalc_smps_chanctx(local
, curr_ctx
);
653 ieee80211_recalc_radar_chanctx(local
, curr_ctx
);
654 ieee80211_recalc_chanctx_min_def(local
, curr_ctx
);
657 if (new_ctx
&& ieee80211_chanctx_num_assigned(local
, new_ctx
) > 0) {
658 ieee80211_recalc_txpower(sdata
, false);
659 ieee80211_recalc_chanctx_min_def(local
, new_ctx
);
662 if (sdata
->vif
.type
!= NL80211_IFTYPE_P2P_DEVICE
&&
663 sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
)
664 ieee80211_bss_info_change_notify(sdata
,
670 void ieee80211_recalc_smps_chanctx(struct ieee80211_local
*local
,
671 struct ieee80211_chanctx
*chanctx
)
673 struct ieee80211_sub_if_data
*sdata
;
674 u8 rx_chains_static
, rx_chains_dynamic
;
676 lockdep_assert_held(&local
->chanctx_mtx
);
678 rx_chains_static
= 1;
679 rx_chains_dynamic
= 1;
682 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
683 u8 needed_static
, needed_dynamic
;
685 if (!ieee80211_sdata_running(sdata
))
688 if (rcu_access_pointer(sdata
->vif
.chanctx_conf
) !=
692 switch (sdata
->vif
.type
) {
693 case NL80211_IFTYPE_P2P_DEVICE
:
695 case NL80211_IFTYPE_STATION
:
696 if (!sdata
->u
.mgd
.associated
)
699 case NL80211_IFTYPE_AP_VLAN
:
701 case NL80211_IFTYPE_AP
:
702 case NL80211_IFTYPE_ADHOC
:
703 case NL80211_IFTYPE_WDS
:
704 case NL80211_IFTYPE_MESH_POINT
:
705 case NL80211_IFTYPE_OCB
:
711 switch (sdata
->smps_mode
) {
713 WARN_ONCE(1, "Invalid SMPS mode %d\n",
716 case IEEE80211_SMPS_OFF
:
717 needed_static
= sdata
->needed_rx_chains
;
718 needed_dynamic
= sdata
->needed_rx_chains
;
720 case IEEE80211_SMPS_DYNAMIC
:
722 needed_dynamic
= sdata
->needed_rx_chains
;
724 case IEEE80211_SMPS_STATIC
:
730 rx_chains_static
= max(rx_chains_static
, needed_static
);
731 rx_chains_dynamic
= max(rx_chains_dynamic
, needed_dynamic
);
734 /* Disable SMPS for the monitor interface */
735 sdata
= rcu_dereference(local
->monitor_sdata
);
737 rcu_access_pointer(sdata
->vif
.chanctx_conf
) == &chanctx
->conf
)
738 rx_chains_dynamic
= rx_chains_static
= local
->rx_chains
;
742 if (!local
->use_chanctx
) {
743 if (rx_chains_static
> 1)
744 local
->smps_mode
= IEEE80211_SMPS_OFF
;
745 else if (rx_chains_dynamic
> 1)
746 local
->smps_mode
= IEEE80211_SMPS_DYNAMIC
;
748 local
->smps_mode
= IEEE80211_SMPS_STATIC
;
749 ieee80211_hw_config(local
, 0);
752 if (rx_chains_static
== chanctx
->conf
.rx_chains_static
&&
753 rx_chains_dynamic
== chanctx
->conf
.rx_chains_dynamic
)
756 chanctx
->conf
.rx_chains_static
= rx_chains_static
;
757 chanctx
->conf
.rx_chains_dynamic
= rx_chains_dynamic
;
758 drv_change_chanctx(local
, chanctx
, IEEE80211_CHANCTX_CHANGE_RX_CHAINS
);
762 __ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data
*sdata
,
765 struct ieee80211_local
*local __maybe_unused
= sdata
->local
;
766 struct ieee80211_sub_if_data
*vlan
;
767 struct ieee80211_chanctx_conf
*conf
;
769 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_AP
))
772 lockdep_assert_held(&local
->mtx
);
774 /* Check that conf exists, even when clearing this function
775 * must be called with the AP's channel context still there
776 * as it would otherwise cause VLANs to have an invalid
777 * channel context pointer for a while, possibly pointing
778 * to a channel context that has already been freed.
780 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
781 lockdep_is_held(&local
->chanctx_mtx
));
787 list_for_each_entry(vlan
, &sdata
->u
.ap
.vlans
, u
.vlan
.list
)
788 rcu_assign_pointer(vlan
->vif
.chanctx_conf
, conf
);
791 void ieee80211_vif_copy_chanctx_to_vlans(struct ieee80211_sub_if_data
*sdata
,
794 struct ieee80211_local
*local
= sdata
->local
;
796 mutex_lock(&local
->chanctx_mtx
);
798 __ieee80211_vif_copy_chanctx_to_vlans(sdata
, clear
);
800 mutex_unlock(&local
->chanctx_mtx
);
803 int ieee80211_vif_unreserve_chanctx(struct ieee80211_sub_if_data
*sdata
)
805 struct ieee80211_chanctx
*ctx
= sdata
->reserved_chanctx
;
807 lockdep_assert_held(&sdata
->local
->chanctx_mtx
);
812 list_del(&sdata
->reserved_chanctx_list
);
813 sdata
->reserved_chanctx
= NULL
;
815 if (ieee80211_chanctx_refcount(sdata
->local
, ctx
) == 0) {
816 if (ctx
->replace_state
== IEEE80211_CHANCTX_REPLACES_OTHER
) {
817 if (WARN_ON(!ctx
->replace_ctx
))
820 WARN_ON(ctx
->replace_ctx
->replace_state
!=
821 IEEE80211_CHANCTX_WILL_BE_REPLACED
);
822 WARN_ON(ctx
->replace_ctx
->replace_ctx
!= ctx
);
824 ctx
->replace_ctx
->replace_ctx
= NULL
;
825 ctx
->replace_ctx
->replace_state
=
826 IEEE80211_CHANCTX_REPLACE_NONE
;
828 list_del_rcu(&ctx
->list
);
829 kfree_rcu(ctx
, rcu_head
);
831 ieee80211_free_chanctx(sdata
->local
, ctx
);
838 int ieee80211_vif_reserve_chanctx(struct ieee80211_sub_if_data
*sdata
,
839 const struct cfg80211_chan_def
*chandef
,
840 enum ieee80211_chanctx_mode mode
,
843 struct ieee80211_local
*local
= sdata
->local
;
844 struct ieee80211_chanctx
*new_ctx
, *curr_ctx
, *ctx
;
846 lockdep_assert_held(&local
->chanctx_mtx
);
848 curr_ctx
= ieee80211_vif_get_chanctx(sdata
);
849 if (curr_ctx
&& local
->use_chanctx
&& !local
->ops
->switch_vif_chanctx
)
852 new_ctx
= ieee80211_find_reservation_chanctx(local
, chandef
, mode
);
854 if (ieee80211_can_create_new_chanctx(local
)) {
855 new_ctx
= ieee80211_new_chanctx(local
, chandef
, mode
);
857 return PTR_ERR(new_ctx
);
860 (curr_ctx
->replace_state
==
861 IEEE80211_CHANCTX_WILL_BE_REPLACED
) ||
862 !list_empty(&curr_ctx
->reserved_vifs
)) {
864 * Another vif already requested this context
865 * for a reservation. Find another one hoping
866 * all vifs assigned to it will also switch
869 * TODO: This needs a little more work as some
870 * cases (more than 2 chanctx capable devices)
871 * may fail which could otherwise succeed
872 * provided some channel context juggling was
875 * Consider ctx1..3, vif1..6, each ctx has 2
876 * vifs. vif1 and vif2 from ctx1 request new
877 * different chandefs starting 2 in-place
878 * reserations with ctx4 and ctx5 replacing
879 * ctx1 and ctx2 respectively. Next vif5 and
880 * vif6 from ctx3 reserve ctx4. If vif3 and
881 * vif4 remain on ctx2 as they are then this
882 * fails unless `replace_ctx` from ctx5 is
883 * replaced with ctx3.
885 list_for_each_entry(ctx
, &local
->chanctx_list
,
887 if (ctx
->replace_state
!=
888 IEEE80211_CHANCTX_REPLACE_NONE
)
891 if (!list_empty(&ctx
->reserved_vifs
))
900 * If that's true then all available contexts already
901 * have reservations and cannot be used.
904 (curr_ctx
->replace_state
==
905 IEEE80211_CHANCTX_WILL_BE_REPLACED
) ||
906 !list_empty(&curr_ctx
->reserved_vifs
))
909 new_ctx
= ieee80211_alloc_chanctx(local
, chandef
, mode
);
913 new_ctx
->replace_ctx
= curr_ctx
;
914 new_ctx
->replace_state
=
915 IEEE80211_CHANCTX_REPLACES_OTHER
;
917 curr_ctx
->replace_ctx
= new_ctx
;
918 curr_ctx
->replace_state
=
919 IEEE80211_CHANCTX_WILL_BE_REPLACED
;
921 list_add_rcu(&new_ctx
->list
, &local
->chanctx_list
);
925 list_add(&sdata
->reserved_chanctx_list
, &new_ctx
->reserved_vifs
);
926 sdata
->reserved_chanctx
= new_ctx
;
927 sdata
->reserved_chandef
= *chandef
;
928 sdata
->reserved_radar_required
= radar_required
;
929 sdata
->reserved_ready
= false;
935 ieee80211_vif_chanctx_reservation_complete(struct ieee80211_sub_if_data
*sdata
)
937 switch (sdata
->vif
.type
) {
938 case NL80211_IFTYPE_ADHOC
:
939 case NL80211_IFTYPE_AP
:
940 case NL80211_IFTYPE_MESH_POINT
:
941 case NL80211_IFTYPE_OCB
:
942 ieee80211_queue_work(&sdata
->local
->hw
,
943 &sdata
->csa_finalize_work
);
945 case NL80211_IFTYPE_STATION
:
946 ieee80211_queue_work(&sdata
->local
->hw
,
947 &sdata
->u
.mgd
.chswitch_work
);
949 case NL80211_IFTYPE_UNSPECIFIED
:
950 case NL80211_IFTYPE_AP_VLAN
:
951 case NL80211_IFTYPE_WDS
:
952 case NL80211_IFTYPE_MONITOR
:
953 case NL80211_IFTYPE_P2P_CLIENT
:
954 case NL80211_IFTYPE_P2P_GO
:
955 case NL80211_IFTYPE_P2P_DEVICE
:
956 case NUM_NL80211_IFTYPES
:
963 ieee80211_vif_update_chandef(struct ieee80211_sub_if_data
*sdata
,
964 const struct cfg80211_chan_def
*chandef
)
966 struct ieee80211_sub_if_data
*vlan
;
968 sdata
->vif
.bss_conf
.chandef
= *chandef
;
970 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP
)
973 list_for_each_entry(vlan
, &sdata
->u
.ap
.vlans
, u
.vlan
.list
)
974 vlan
->vif
.bss_conf
.chandef
= *chandef
;
978 ieee80211_vif_use_reserved_reassign(struct ieee80211_sub_if_data
*sdata
)
980 struct ieee80211_local
*local
= sdata
->local
;
981 struct ieee80211_vif_chanctx_switch vif_chsw
[1] = {};
982 struct ieee80211_chanctx
*old_ctx
, *new_ctx
;
983 const struct cfg80211_chan_def
*chandef
;
987 lockdep_assert_held(&local
->mtx
);
988 lockdep_assert_held(&local
->chanctx_mtx
);
990 new_ctx
= sdata
->reserved_chanctx
;
991 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
993 if (WARN_ON(!sdata
->reserved_ready
))
996 if (WARN_ON(!new_ctx
))
999 if (WARN_ON(!old_ctx
))
1002 if (WARN_ON(new_ctx
->replace_state
==
1003 IEEE80211_CHANCTX_REPLACES_OTHER
))
1006 chandef
= ieee80211_chanctx_non_reserved_chandef(local
, new_ctx
,
1007 &sdata
->reserved_chandef
);
1008 if (WARN_ON(!chandef
))
1011 vif_chsw
[0].vif
= &sdata
->vif
;
1012 vif_chsw
[0].old_ctx
= &old_ctx
->conf
;
1013 vif_chsw
[0].new_ctx
= &new_ctx
->conf
;
1015 list_del(&sdata
->reserved_chanctx_list
);
1016 sdata
->reserved_chanctx
= NULL
;
1018 err
= drv_switch_vif_chanctx(local
, vif_chsw
, 1,
1019 CHANCTX_SWMODE_REASSIGN_VIF
);
1021 if (ieee80211_chanctx_refcount(local
, new_ctx
) == 0)
1022 ieee80211_free_chanctx(local
, new_ctx
);
1027 list_move(&sdata
->assigned_chanctx_list
, &new_ctx
->assigned_vifs
);
1028 rcu_assign_pointer(sdata
->vif
.chanctx_conf
, &new_ctx
->conf
);
1030 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
)
1031 __ieee80211_vif_copy_chanctx_to_vlans(sdata
, false);
1033 if (ieee80211_chanctx_refcount(local
, old_ctx
) == 0)
1034 ieee80211_free_chanctx(local
, old_ctx
);
1036 if (sdata
->vif
.bss_conf
.chandef
.width
!= sdata
->reserved_chandef
.width
)
1037 changed
= BSS_CHANGED_BANDWIDTH
;
1039 ieee80211_vif_update_chandef(sdata
, &sdata
->reserved_chandef
);
1041 ieee80211_recalc_smps_chanctx(local
, new_ctx
);
1042 ieee80211_recalc_radar_chanctx(local
, new_ctx
);
1043 ieee80211_recalc_chanctx_min_def(local
, new_ctx
);
1046 ieee80211_bss_info_change_notify(sdata
, changed
);
1049 ieee80211_vif_chanctx_reservation_complete(sdata
);
1054 ieee80211_vif_use_reserved_assign(struct ieee80211_sub_if_data
*sdata
)
1056 struct ieee80211_local
*local
= sdata
->local
;
1057 struct ieee80211_chanctx
*old_ctx
, *new_ctx
;
1058 const struct cfg80211_chan_def
*chandef
;
1061 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
1062 new_ctx
= sdata
->reserved_chanctx
;
1064 if (WARN_ON(!sdata
->reserved_ready
))
1067 if (WARN_ON(old_ctx
))
1070 if (WARN_ON(!new_ctx
))
1073 if (WARN_ON(new_ctx
->replace_state
==
1074 IEEE80211_CHANCTX_REPLACES_OTHER
))
1077 chandef
= ieee80211_chanctx_non_reserved_chandef(local
, new_ctx
,
1078 &sdata
->reserved_chandef
);
1079 if (WARN_ON(!chandef
))
1082 list_del(&sdata
->reserved_chanctx_list
);
1083 sdata
->reserved_chanctx
= NULL
;
1085 err
= ieee80211_assign_vif_chanctx(sdata
, new_ctx
);
1087 if (ieee80211_chanctx_refcount(local
, new_ctx
) == 0)
1088 ieee80211_free_chanctx(local
, new_ctx
);
1094 ieee80211_vif_chanctx_reservation_complete(sdata
);
1099 ieee80211_vif_has_in_place_reservation(struct ieee80211_sub_if_data
*sdata
)
1101 struct ieee80211_chanctx
*old_ctx
, *new_ctx
;
1103 lockdep_assert_held(&sdata
->local
->chanctx_mtx
);
1105 new_ctx
= sdata
->reserved_chanctx
;
1106 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
1111 if (WARN_ON(!new_ctx
))
1114 if (old_ctx
->replace_state
!= IEEE80211_CHANCTX_WILL_BE_REPLACED
)
1117 if (new_ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1123 static int ieee80211_chsw_switch_hwconf(struct ieee80211_local
*local
,
1124 struct ieee80211_chanctx
*new_ctx
)
1126 const struct cfg80211_chan_def
*chandef
;
1128 lockdep_assert_held(&local
->mtx
);
1129 lockdep_assert_held(&local
->chanctx_mtx
);
1131 chandef
= ieee80211_chanctx_reserved_chandef(local
, new_ctx
, NULL
);
1132 if (WARN_ON(!chandef
))
1135 local
->hw
.conf
.radar_enabled
= new_ctx
->conf
.radar_enabled
;
1136 local
->_oper_chandef
= *chandef
;
1137 ieee80211_hw_config(local
, 0);
1142 static int ieee80211_chsw_switch_vifs(struct ieee80211_local
*local
,
1145 struct ieee80211_vif_chanctx_switch
*vif_chsw
;
1146 struct ieee80211_sub_if_data
*sdata
;
1147 struct ieee80211_chanctx
*ctx
, *old_ctx
;
1150 lockdep_assert_held(&local
->mtx
);
1151 lockdep_assert_held(&local
->chanctx_mtx
);
1153 vif_chsw
= kzalloc(sizeof(vif_chsw
[0]) * n_vifs
, GFP_KERNEL
);
1158 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
1159 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1162 if (WARN_ON(!ctx
->replace_ctx
)) {
1167 list_for_each_entry(sdata
, &ctx
->reserved_vifs
,
1168 reserved_chanctx_list
) {
1169 if (!ieee80211_vif_has_in_place_reservation(
1173 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
1174 vif_chsw
[i
].vif
= &sdata
->vif
;
1175 vif_chsw
[i
].old_ctx
= &old_ctx
->conf
;
1176 vif_chsw
[i
].new_ctx
= &ctx
->conf
;
1182 err
= drv_switch_vif_chanctx(local
, vif_chsw
, n_vifs
,
1183 CHANCTX_SWMODE_SWAP_CONTEXTS
);
1190 static int ieee80211_chsw_switch_ctxs(struct ieee80211_local
*local
)
1192 struct ieee80211_chanctx
*ctx
;
1195 lockdep_assert_held(&local
->mtx
);
1196 lockdep_assert_held(&local
->chanctx_mtx
);
1198 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
1199 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1202 if (!list_empty(&ctx
->replace_ctx
->assigned_vifs
))
1205 ieee80211_del_chanctx(local
, ctx
->replace_ctx
);
1206 err
= ieee80211_add_chanctx(local
, ctx
);
1214 WARN_ON(ieee80211_add_chanctx(local
, ctx
));
1215 list_for_each_entry_continue_reverse(ctx
, &local
->chanctx_list
, list
) {
1216 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1219 if (!list_empty(&ctx
->replace_ctx
->assigned_vifs
))
1222 ieee80211_del_chanctx(local
, ctx
);
1223 WARN_ON(ieee80211_add_chanctx(local
, ctx
->replace_ctx
));
1229 static int ieee80211_vif_use_reserved_switch(struct ieee80211_local
*local
)
1231 struct ieee80211_sub_if_data
*sdata
, *sdata_tmp
;
1232 struct ieee80211_chanctx
*ctx
, *ctx_tmp
, *old_ctx
;
1233 struct ieee80211_chanctx
*new_ctx
= NULL
;
1234 int i
, err
, n_assigned
, n_reserved
, n_ready
;
1235 int n_ctx
= 0, n_vifs_switch
= 0, n_vifs_assign
= 0, n_vifs_ctxless
= 0;
1237 lockdep_assert_held(&local
->mtx
);
1238 lockdep_assert_held(&local
->chanctx_mtx
);
1241 * If there are 2 independent pairs of channel contexts performing
1242 * cross-switch of their vifs this code will still wait until both are
1243 * ready even though it could be possible to switch one before the
1246 * For practical reasons and code simplicity just do a single huge
1251 * Verify if the reservation is still feasible.
1252 * - if it's not then disconnect
1253 * - if it is but not all vifs necessary are ready then defer
1256 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
1257 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1260 if (WARN_ON(!ctx
->replace_ctx
)) {
1265 if (!local
->use_chanctx
)
1274 list_for_each_entry(sdata
, &ctx
->replace_ctx
->assigned_vifs
,
1275 assigned_chanctx_list
) {
1277 if (sdata
->reserved_chanctx
) {
1279 if (sdata
->reserved_ready
)
1284 if (n_assigned
!= n_reserved
) {
1285 if (n_ready
== n_reserved
) {
1286 wiphy_info(local
->hw
.wiphy
,
1287 "channel context reservation cannot be finalized because some interfaces aren't switching\n");
1295 ctx
->conf
.radar_enabled
= false;
1296 list_for_each_entry(sdata
, &ctx
->reserved_vifs
,
1297 reserved_chanctx_list
) {
1298 if (ieee80211_vif_has_in_place_reservation(sdata
) &&
1299 !sdata
->reserved_ready
)
1302 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
1304 if (old_ctx
->replace_state
==
1305 IEEE80211_CHANCTX_WILL_BE_REPLACED
)
1313 if (sdata
->reserved_radar_required
)
1314 ctx
->conf
.radar_enabled
= true;
1318 if (WARN_ON(n_ctx
== 0) ||
1319 WARN_ON(n_vifs_switch
== 0 &&
1320 n_vifs_assign
== 0 &&
1321 n_vifs_ctxless
== 0) ||
1322 WARN_ON(n_ctx
> 1 && !local
->use_chanctx
) ||
1323 WARN_ON(!new_ctx
&& !local
->use_chanctx
)) {
1329 * All necessary vifs are ready. Perform the switch now depending on
1330 * reservations and driver capabilities.
1333 if (local
->use_chanctx
) {
1334 if (n_vifs_switch
> 0) {
1335 err
= ieee80211_chsw_switch_vifs(local
, n_vifs_switch
);
1340 if (n_vifs_assign
> 0 || n_vifs_ctxless
> 0) {
1341 err
= ieee80211_chsw_switch_ctxs(local
);
1346 err
= ieee80211_chsw_switch_hwconf(local
, new_ctx
);
1352 * Update all structures, values and pointers to point to new channel
1357 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
1358 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1361 if (WARN_ON(!ctx
->replace_ctx
)) {
1366 list_for_each_entry(sdata
, &ctx
->reserved_vifs
,
1367 reserved_chanctx_list
) {
1370 if (!ieee80211_vif_has_in_place_reservation(sdata
))
1373 rcu_assign_pointer(sdata
->vif
.chanctx_conf
, &ctx
->conf
);
1375 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
)
1376 __ieee80211_vif_copy_chanctx_to_vlans(sdata
,
1379 sdata
->radar_required
= sdata
->reserved_radar_required
;
1381 if (sdata
->vif
.bss_conf
.chandef
.width
!=
1382 sdata
->reserved_chandef
.width
)
1383 changed
= BSS_CHANGED_BANDWIDTH
;
1385 ieee80211_vif_update_chandef(sdata
, &sdata
->reserved_chandef
);
1387 ieee80211_bss_info_change_notify(sdata
,
1390 ieee80211_recalc_txpower(sdata
, false);
1393 ieee80211_recalc_chanctx_chantype(local
, ctx
);
1394 ieee80211_recalc_smps_chanctx(local
, ctx
);
1395 ieee80211_recalc_radar_chanctx(local
, ctx
);
1396 ieee80211_recalc_chanctx_min_def(local
, ctx
);
1398 list_for_each_entry_safe(sdata
, sdata_tmp
, &ctx
->reserved_vifs
,
1399 reserved_chanctx_list
) {
1400 if (ieee80211_vif_get_chanctx(sdata
) != ctx
)
1403 list_del(&sdata
->reserved_chanctx_list
);
1404 list_move(&sdata
->assigned_chanctx_list
,
1405 &ctx
->assigned_vifs
);
1406 sdata
->reserved_chanctx
= NULL
;
1408 ieee80211_vif_chanctx_reservation_complete(sdata
);
1412 * This context might have been a dependency for an already
1413 * ready re-assign reservation interface that was deferred. Do
1414 * not propagate error to the caller though. The in-place
1415 * reservation for originally requested interface has already
1416 * succeeded at this point.
1418 list_for_each_entry_safe(sdata
, sdata_tmp
, &ctx
->reserved_vifs
,
1419 reserved_chanctx_list
) {
1420 if (WARN_ON(ieee80211_vif_has_in_place_reservation(
1424 if (WARN_ON(sdata
->reserved_chanctx
!= ctx
))
1427 if (!sdata
->reserved_ready
)
1430 if (ieee80211_vif_get_chanctx(sdata
))
1431 err
= ieee80211_vif_use_reserved_reassign(
1434 err
= ieee80211_vif_use_reserved_assign(sdata
);
1438 "failed to finalize (re-)assign reservation (err=%d)\n",
1440 ieee80211_vif_unreserve_chanctx(sdata
);
1441 cfg80211_stop_iface(local
->hw
.wiphy
,
1449 * Finally free old contexts
1452 list_for_each_entry_safe(ctx
, ctx_tmp
, &local
->chanctx_list
, list
) {
1453 if (ctx
->replace_state
!= IEEE80211_CHANCTX_WILL_BE_REPLACED
)
1456 ctx
->replace_ctx
->replace_ctx
= NULL
;
1457 ctx
->replace_ctx
->replace_state
=
1458 IEEE80211_CHANCTX_REPLACE_NONE
;
1460 list_del_rcu(&ctx
->list
);
1461 kfree_rcu(ctx
, rcu_head
);
1467 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
1468 if (ctx
->replace_state
!= IEEE80211_CHANCTX_REPLACES_OTHER
)
1471 list_for_each_entry_safe(sdata
, sdata_tmp
, &ctx
->reserved_vifs
,
1472 reserved_chanctx_list
) {
1473 ieee80211_vif_unreserve_chanctx(sdata
);
1474 ieee80211_vif_chanctx_reservation_complete(sdata
);
1481 static void __ieee80211_vif_release_channel(struct ieee80211_sub_if_data
*sdata
)
1483 struct ieee80211_local
*local
= sdata
->local
;
1484 struct ieee80211_chanctx_conf
*conf
;
1485 struct ieee80211_chanctx
*ctx
;
1486 bool use_reserved_switch
= false;
1488 lockdep_assert_held(&local
->chanctx_mtx
);
1490 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
1491 lockdep_is_held(&local
->chanctx_mtx
));
1495 ctx
= container_of(conf
, struct ieee80211_chanctx
, conf
);
1497 if (sdata
->reserved_chanctx
) {
1498 if (sdata
->reserved_chanctx
->replace_state
==
1499 IEEE80211_CHANCTX_REPLACES_OTHER
&&
1500 ieee80211_chanctx_num_reserved(local
,
1501 sdata
->reserved_chanctx
) > 1)
1502 use_reserved_switch
= true;
1504 ieee80211_vif_unreserve_chanctx(sdata
);
1507 ieee80211_assign_vif_chanctx(sdata
, NULL
);
1508 if (ieee80211_chanctx_refcount(local
, ctx
) == 0)
1509 ieee80211_free_chanctx(local
, ctx
);
1511 sdata
->radar_required
= false;
1513 /* Unreserving may ready an in-place reservation. */
1514 if (use_reserved_switch
)
1515 ieee80211_vif_use_reserved_switch(local
);
1518 int ieee80211_vif_use_channel(struct ieee80211_sub_if_data
*sdata
,
1519 const struct cfg80211_chan_def
*chandef
,
1520 enum ieee80211_chanctx_mode mode
)
1522 struct ieee80211_local
*local
= sdata
->local
;
1523 struct ieee80211_chanctx
*ctx
;
1524 u8 radar_detect_width
= 0;
1527 lockdep_assert_held(&local
->mtx
);
1529 WARN_ON(sdata
->dev
&& netif_carrier_ok(sdata
->dev
));
1531 mutex_lock(&local
->chanctx_mtx
);
1533 ret
= cfg80211_chandef_dfs_required(local
->hw
.wiphy
,
1535 sdata
->wdev
.iftype
);
1539 radar_detect_width
= BIT(chandef
->width
);
1541 sdata
->radar_required
= ret
;
1543 ret
= ieee80211_check_combinations(sdata
, chandef
, mode
,
1544 radar_detect_width
);
1548 __ieee80211_vif_release_channel(sdata
);
1550 ctx
= ieee80211_find_chanctx(local
, chandef
, mode
);
1552 ctx
= ieee80211_new_chanctx(local
, chandef
, mode
);
1558 ieee80211_vif_update_chandef(sdata
, chandef
);
1560 ret
= ieee80211_assign_vif_chanctx(sdata
, ctx
);
1562 /* if assign fails refcount stays the same */
1563 if (ieee80211_chanctx_refcount(local
, ctx
) == 0)
1564 ieee80211_free_chanctx(local
, ctx
);
1568 ieee80211_recalc_smps_chanctx(local
, ctx
);
1569 ieee80211_recalc_radar_chanctx(local
, ctx
);
1572 sdata
->radar_required
= false;
1574 mutex_unlock(&local
->chanctx_mtx
);
1578 int ieee80211_vif_use_reserved_context(struct ieee80211_sub_if_data
*sdata
)
1580 struct ieee80211_local
*local
= sdata
->local
;
1581 struct ieee80211_chanctx
*new_ctx
;
1582 struct ieee80211_chanctx
*old_ctx
;
1585 lockdep_assert_held(&local
->mtx
);
1586 lockdep_assert_held(&local
->chanctx_mtx
);
1588 new_ctx
= sdata
->reserved_chanctx
;
1589 old_ctx
= ieee80211_vif_get_chanctx(sdata
);
1591 if (WARN_ON(!new_ctx
))
1594 if (WARN_ON(new_ctx
->replace_state
==
1595 IEEE80211_CHANCTX_WILL_BE_REPLACED
))
1598 if (WARN_ON(sdata
->reserved_ready
))
1601 sdata
->reserved_ready
= true;
1603 if (new_ctx
->replace_state
== IEEE80211_CHANCTX_REPLACE_NONE
) {
1605 err
= ieee80211_vif_use_reserved_reassign(sdata
);
1607 err
= ieee80211_vif_use_reserved_assign(sdata
);
1614 * In-place reservation may need to be finalized now either if:
1615 * a) sdata is taking part in the swapping itself and is the last one
1616 * b) sdata has switched with a re-assign reservation to an existing
1617 * context readying in-place switching of old_ctx
1619 * In case of (b) do not propagate the error up because the requested
1620 * sdata already switched successfully. Just spill an extra warning.
1621 * The ieee80211_vif_use_reserved_switch() already stops all necessary
1622 * interfaces upon failure.
1625 old_ctx
->replace_state
== IEEE80211_CHANCTX_WILL_BE_REPLACED
) ||
1626 new_ctx
->replace_state
== IEEE80211_CHANCTX_REPLACES_OTHER
) {
1627 err
= ieee80211_vif_use_reserved_switch(local
);
1628 if (err
&& err
!= -EAGAIN
) {
1629 if (new_ctx
->replace_state
==
1630 IEEE80211_CHANCTX_REPLACES_OTHER
)
1633 wiphy_info(local
->hw
.wiphy
,
1634 "depending in-place reservation failed (err=%d)\n",
1642 int ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data
*sdata
,
1643 const struct cfg80211_chan_def
*chandef
,
1646 struct ieee80211_local
*local
= sdata
->local
;
1647 struct ieee80211_chanctx_conf
*conf
;
1648 struct ieee80211_chanctx
*ctx
;
1649 const struct cfg80211_chan_def
*compat
;
1652 if (!cfg80211_chandef_usable(sdata
->local
->hw
.wiphy
, chandef
,
1653 IEEE80211_CHAN_DISABLED
))
1656 mutex_lock(&local
->chanctx_mtx
);
1657 if (cfg80211_chandef_identical(chandef
, &sdata
->vif
.bss_conf
.chandef
)) {
1662 if (chandef
->width
== NL80211_CHAN_WIDTH_20_NOHT
||
1663 sdata
->vif
.bss_conf
.chandef
.width
== NL80211_CHAN_WIDTH_20_NOHT
) {
1668 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
1669 lockdep_is_held(&local
->chanctx_mtx
));
1675 ctx
= container_of(conf
, struct ieee80211_chanctx
, conf
);
1677 compat
= cfg80211_chandef_compatible(&conf
->def
, chandef
);
1683 switch (ctx
->replace_state
) {
1684 case IEEE80211_CHANCTX_REPLACE_NONE
:
1685 if (!ieee80211_chanctx_reserved_chandef(local
, ctx
, compat
)) {
1690 case IEEE80211_CHANCTX_WILL_BE_REPLACED
:
1691 /* TODO: Perhaps the bandwidth change could be treated as a
1692 * reservation itself? */
1695 case IEEE80211_CHANCTX_REPLACES_OTHER
:
1696 /* channel context that is going to replace another channel
1697 * context doesn't really exist and shouldn't be assigned
1703 ieee80211_vif_update_chandef(sdata
, chandef
);
1705 ieee80211_recalc_chanctx_chantype(local
, ctx
);
1707 *changed
|= BSS_CHANGED_BANDWIDTH
;
1710 mutex_unlock(&local
->chanctx_mtx
);
1714 void ieee80211_vif_release_channel(struct ieee80211_sub_if_data
*sdata
)
1716 WARN_ON(sdata
->dev
&& netif_carrier_ok(sdata
->dev
));
1718 lockdep_assert_held(&sdata
->local
->mtx
);
1720 mutex_lock(&sdata
->local
->chanctx_mtx
);
1721 __ieee80211_vif_release_channel(sdata
);
1722 mutex_unlock(&sdata
->local
->chanctx_mtx
);
1725 void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data
*sdata
)
1727 struct ieee80211_local
*local
= sdata
->local
;
1728 struct ieee80211_sub_if_data
*ap
;
1729 struct ieee80211_chanctx_conf
*conf
;
1731 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
|| !sdata
->bss
))
1734 ap
= container_of(sdata
->bss
, struct ieee80211_sub_if_data
, u
.ap
);
1736 mutex_lock(&local
->chanctx_mtx
);
1738 conf
= rcu_dereference_protected(ap
->vif
.chanctx_conf
,
1739 lockdep_is_held(&local
->chanctx_mtx
));
1740 rcu_assign_pointer(sdata
->vif
.chanctx_conf
, conf
);
1741 mutex_unlock(&local
->chanctx_mtx
);
1744 void ieee80211_iter_chan_contexts_atomic(
1745 struct ieee80211_hw
*hw
,
1746 void (*iter
)(struct ieee80211_hw
*hw
,
1747 struct ieee80211_chanctx_conf
*chanctx_conf
,
1751 struct ieee80211_local
*local
= hw_to_local(hw
);
1752 struct ieee80211_chanctx
*ctx
;
1755 list_for_each_entry_rcu(ctx
, &local
->chanctx_list
, list
)
1756 if (ctx
->driver_present
)
1757 iter(hw
, &ctx
->conf
, iter_data
);
1760 EXPORT_SYMBOL_GPL(ieee80211_iter_chan_contexts_atomic
);