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