1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <net/mac80211.h>
15#include <linux/netdevice.h>
16#include <linux/export.h>
17#include <linux/types.h>
18#include <linux/slab.h>
19#include <linux/skbuff.h>
20#include <linux/etherdevice.h>
21#include <linux/if_arp.h>
22#include <linux/bitmap.h>
23#include <linux/crc32.h>
24#include <net/net_namespace.h>
25#include <net/cfg80211.h>
26#include <net/rtnetlink.h>
27
28#include "ieee80211_i.h"
29#include "driver-ops.h"
30#include "rate.h"
31#include "mesh.h"
32#include "wme.h"
33#include "led.h"
34#include "wep.h"
35
36
37const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
38
39struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
40{
41 struct ieee80211_local *local;
42
43 local = wiphy_priv(wiphy);
44 return &local->hw;
45}
46EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
47
48u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
49 enum nl80211_iftype type)
50{
51 __le16 fc = hdr->frame_control;
52
53 if (ieee80211_is_data(fc)) {
54 if (len < 24)
55 return NULL;
56
57 if (ieee80211_has_a4(fc))
58 return NULL;
59 if (ieee80211_has_tods(fc))
60 return hdr->addr1;
61 if (ieee80211_has_fromds(fc))
62 return hdr->addr2;
63
64 return hdr->addr3;
65 }
66
67 if (ieee80211_is_s1g_beacon(fc)) {
68 struct ieee80211_ext *ext = (void *) hdr;
69
70 return ext->u.s1g_beacon.sa;
71 }
72
73 if (ieee80211_is_mgmt(fc)) {
74 if (len < 24)
75 return NULL;
76 return hdr->addr3;
77 }
78
79 if (ieee80211_is_ctl(fc)) {
80 if (ieee80211_is_pspoll(fc))
81 return hdr->addr1;
82
83 if (ieee80211_is_back_req(fc)) {
84 switch (type) {
85 case NL80211_IFTYPE_STATION:
86 return hdr->addr2;
87 case NL80211_IFTYPE_AP:
88 case NL80211_IFTYPE_AP_VLAN:
89 return hdr->addr1;
90 default:
91 break;
92 }
93 }
94 }
95
96 return NULL;
97}
98EXPORT_SYMBOL(ieee80211_get_bssid);
99
100void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
101{
102 struct sk_buff *skb;
103 struct ieee80211_hdr *hdr;
104
105 skb_queue_walk(&tx->skbs, skb) {
106 hdr = (struct ieee80211_hdr *) skb->data;
107 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
108 }
109}
110
111int ieee80211_frame_duration(enum nl80211_band band, size_t len,
112 int rate, int erp, int short_preamble,
113 int shift)
114{
115 int dur;
116
117
118
119
120
121
122
123
124
125
126
127
128
129 if (band == NL80211_BAND_5GHZ || erp) {
130
131
132
133
134
135
136
137
138
139
140
141
142
143 dur = 16;
144 dur += 16;
145 dur += 4;
146
147
148
149
150
151 dur *= 1 << shift;
152
153
154
155
156 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
157 4 * rate);
158 } else {
159
160
161
162
163
164
165
166
167
168
169 dur = 10;
170 dur += short_preamble ? (72 + 24) : (144 + 48);
171
172 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
173 }
174
175 return dur;
176}
177
178
179__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
180 struct ieee80211_vif *vif,
181 enum nl80211_band band,
182 size_t frame_len,
183 struct ieee80211_rate *rate)
184{
185 struct ieee80211_sub_if_data *sdata;
186 u16 dur;
187 int erp, shift = 0;
188 bool short_preamble = false;
189
190 erp = 0;
191 if (vif) {
192 sdata = vif_to_sdata(vif);
193 short_preamble = sdata->vif.bss_conf.use_short_preamble;
194 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
195 erp = rate->flags & IEEE80211_RATE_ERP_G;
196 shift = ieee80211_vif_get_shift(vif);
197 }
198
199 dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
200 short_preamble, shift);
201
202 return cpu_to_le16(dur);
203}
204EXPORT_SYMBOL(ieee80211_generic_frame_duration);
205
206__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
207 struct ieee80211_vif *vif, size_t frame_len,
208 const struct ieee80211_tx_info *frame_txctl)
209{
210 struct ieee80211_local *local = hw_to_local(hw);
211 struct ieee80211_rate *rate;
212 struct ieee80211_sub_if_data *sdata;
213 bool short_preamble;
214 int erp, shift = 0, bitrate;
215 u16 dur;
216 struct ieee80211_supported_band *sband;
217
218 sband = local->hw.wiphy->bands[frame_txctl->band];
219
220 short_preamble = false;
221
222 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
223
224 erp = 0;
225 if (vif) {
226 sdata = vif_to_sdata(vif);
227 short_preamble = sdata->vif.bss_conf.use_short_preamble;
228 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
229 erp = rate->flags & IEEE80211_RATE_ERP_G;
230 shift = ieee80211_vif_get_shift(vif);
231 }
232
233 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
234
235
236 dur = ieee80211_frame_duration(sband->band, 10, bitrate,
237 erp, short_preamble, shift);
238
239 dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
240 erp, short_preamble, shift);
241
242 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
243 erp, short_preamble, shift);
244
245 return cpu_to_le16(dur);
246}
247EXPORT_SYMBOL(ieee80211_rts_duration);
248
249__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
250 struct ieee80211_vif *vif,
251 size_t frame_len,
252 const struct ieee80211_tx_info *frame_txctl)
253{
254 struct ieee80211_local *local = hw_to_local(hw);
255 struct ieee80211_rate *rate;
256 struct ieee80211_sub_if_data *sdata;
257 bool short_preamble;
258 int erp, shift = 0, bitrate;
259 u16 dur;
260 struct ieee80211_supported_band *sband;
261
262 sband = local->hw.wiphy->bands[frame_txctl->band];
263
264 short_preamble = false;
265
266 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
267 erp = 0;
268 if (vif) {
269 sdata = vif_to_sdata(vif);
270 short_preamble = sdata->vif.bss_conf.use_short_preamble;
271 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
272 erp = rate->flags & IEEE80211_RATE_ERP_G;
273 shift = ieee80211_vif_get_shift(vif);
274 }
275
276 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
277
278
279 dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
280 erp, short_preamble, shift);
281 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
282
283 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
284 erp, short_preamble, shift);
285 }
286
287 return cpu_to_le16(dur);
288}
289EXPORT_SYMBOL(ieee80211_ctstoself_duration);
290
291static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac)
292{
293 struct ieee80211_local *local = sdata->local;
294 struct ieee80211_vif *vif = &sdata->vif;
295 struct fq *fq = &local->fq;
296 struct ps_data *ps = NULL;
297 struct txq_info *txqi;
298 struct sta_info *sta;
299 int i;
300
301 local_bh_disable();
302 spin_lock(&fq->lock);
303
304 if (sdata->vif.type == NL80211_IFTYPE_AP)
305 ps = &sdata->bss->ps;
306
307 sdata->vif.txqs_stopped[ac] = false;
308
309 list_for_each_entry_rcu(sta, &local->sta_list, list) {
310 if (sdata != sta->sdata)
311 continue;
312
313 for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
314 struct ieee80211_txq *txq = sta->sta.txq[i];
315
316 if (!txq)
317 continue;
318
319 txqi = to_txq_info(txq);
320
321 if (ac != txq->ac)
322 continue;
323
324 if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX,
325 &txqi->flags))
326 continue;
327
328 spin_unlock(&fq->lock);
329 drv_wake_tx_queue(local, txqi);
330 spin_lock(&fq->lock);
331 }
332 }
333
334 if (!vif->txq)
335 goto out;
336
337 txqi = to_txq_info(vif->txq);
338
339 if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txqi->flags) ||
340 (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac)
341 goto out;
342
343 spin_unlock(&fq->lock);
344
345 drv_wake_tx_queue(local, txqi);
346 local_bh_enable();
347 return;
348out:
349 spin_unlock(&fq->lock);
350 local_bh_enable();
351}
352
353static void
354__releases(&local->queue_stop_reason_lock)
355__acquires(&local->queue_stop_reason_lock)
356_ieee80211_wake_txqs(struct ieee80211_local *local, unsigned long *flags)
357{
358 struct ieee80211_sub_if_data *sdata;
359 int n_acs = IEEE80211_NUM_ACS;
360 int i;
361
362 rcu_read_lock();
363
364 if (local->hw.queues < IEEE80211_NUM_ACS)
365 n_acs = 1;
366
367 for (i = 0; i < local->hw.queues; i++) {
368 if (local->queue_stop_reasons[i])
369 continue;
370
371 spin_unlock_irqrestore(&local->queue_stop_reason_lock, *flags);
372 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
373 int ac;
374
375 for (ac = 0; ac < n_acs; ac++) {
376 int ac_queue = sdata->vif.hw_queue[ac];
377
378 if (ac_queue == i ||
379 sdata->vif.cab_queue == i)
380 __ieee80211_wake_txqs(sdata, ac);
381 }
382 }
383 spin_lock_irqsave(&local->queue_stop_reason_lock, *flags);
384 }
385
386 rcu_read_unlock();
387}
388
389void ieee80211_wake_txqs(struct tasklet_struct *t)
390{
391 struct ieee80211_local *local = from_tasklet(local, t,
392 wake_txqs_tasklet);
393 unsigned long flags;
394
395 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
396 _ieee80211_wake_txqs(local, &flags);
397 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
398}
399
400void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
401{
402 struct ieee80211_sub_if_data *sdata;
403 int n_acs = IEEE80211_NUM_ACS;
404
405 if (local->ops->wake_tx_queue)
406 return;
407
408 if (local->hw.queues < IEEE80211_NUM_ACS)
409 n_acs = 1;
410
411 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
412 int ac;
413
414 if (!sdata->dev)
415 continue;
416
417 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
418 local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
419 continue;
420
421 for (ac = 0; ac < n_acs; ac++) {
422 int ac_queue = sdata->vif.hw_queue[ac];
423
424 if (ac_queue == queue ||
425 (sdata->vif.cab_queue == queue &&
426 local->queue_stop_reasons[ac_queue] == 0 &&
427 skb_queue_empty(&local->pending[ac_queue])))
428 netif_wake_subqueue(sdata->dev, ac);
429 }
430 }
431}
432
433static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
434 enum queue_stop_reason reason,
435 bool refcounted,
436 unsigned long *flags)
437{
438 struct ieee80211_local *local = hw_to_local(hw);
439
440 trace_wake_queue(local, queue, reason);
441
442 if (WARN_ON(queue >= hw->queues))
443 return;
444
445 if (!test_bit(reason, &local->queue_stop_reasons[queue]))
446 return;
447
448 if (!refcounted) {
449 local->q_stop_reasons[queue][reason] = 0;
450 } else {
451 local->q_stop_reasons[queue][reason]--;
452 if (WARN_ON(local->q_stop_reasons[queue][reason] < 0))
453 local->q_stop_reasons[queue][reason] = 0;
454 }
455
456 if (local->q_stop_reasons[queue][reason] == 0)
457 __clear_bit(reason, &local->queue_stop_reasons[queue]);
458
459 if (local->queue_stop_reasons[queue] != 0)
460
461 return;
462
463 if (skb_queue_empty(&local->pending[queue])) {
464 rcu_read_lock();
465 ieee80211_propagate_queue_wake(local, queue);
466 rcu_read_unlock();
467 } else
468 tasklet_schedule(&local->tx_pending_tasklet);
469
470
471
472
473
474
475
476
477 if (local->ops->wake_tx_queue) {
478 if (reason == IEEE80211_QUEUE_STOP_REASON_DRIVER)
479 tasklet_schedule(&local->wake_txqs_tasklet);
480 else
481 _ieee80211_wake_txqs(local, flags);
482 }
483}
484
485void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
486 enum queue_stop_reason reason,
487 bool refcounted)
488{
489 struct ieee80211_local *local = hw_to_local(hw);
490 unsigned long flags;
491
492 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
493 __ieee80211_wake_queue(hw, queue, reason, refcounted, &flags);
494 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
495}
496
497void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
498{
499 ieee80211_wake_queue_by_reason(hw, queue,
500 IEEE80211_QUEUE_STOP_REASON_DRIVER,
501 false);
502}
503EXPORT_SYMBOL(ieee80211_wake_queue);
504
505static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
506 enum queue_stop_reason reason,
507 bool refcounted)
508{
509 struct ieee80211_local *local = hw_to_local(hw);
510 struct ieee80211_sub_if_data *sdata;
511 int n_acs = IEEE80211_NUM_ACS;
512
513 trace_stop_queue(local, queue, reason);
514
515 if (WARN_ON(queue >= hw->queues))
516 return;
517
518 if (!refcounted)
519 local->q_stop_reasons[queue][reason] = 1;
520 else
521 local->q_stop_reasons[queue][reason]++;
522
523 if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
524 return;
525
526 if (local->hw.queues < IEEE80211_NUM_ACS)
527 n_acs = 1;
528
529 rcu_read_lock();
530 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
531 int ac;
532
533 if (!sdata->dev)
534 continue;
535
536 for (ac = 0; ac < n_acs; ac++) {
537 if (sdata->vif.hw_queue[ac] == queue ||
538 sdata->vif.cab_queue == queue) {
539 if (!local->ops->wake_tx_queue) {
540 netif_stop_subqueue(sdata->dev, ac);
541 continue;
542 }
543 spin_lock(&local->fq.lock);
544 sdata->vif.txqs_stopped[ac] = true;
545 spin_unlock(&local->fq.lock);
546 }
547 }
548 }
549 rcu_read_unlock();
550}
551
552void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
553 enum queue_stop_reason reason,
554 bool refcounted)
555{
556 struct ieee80211_local *local = hw_to_local(hw);
557 unsigned long flags;
558
559 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
560 __ieee80211_stop_queue(hw, queue, reason, refcounted);
561 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
562}
563
564void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
565{
566 ieee80211_stop_queue_by_reason(hw, queue,
567 IEEE80211_QUEUE_STOP_REASON_DRIVER,
568 false);
569}
570EXPORT_SYMBOL(ieee80211_stop_queue);
571
572void ieee80211_add_pending_skb(struct ieee80211_local *local,
573 struct sk_buff *skb)
574{
575 struct ieee80211_hw *hw = &local->hw;
576 unsigned long flags;
577 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
578 int queue = info->hw_queue;
579
580 if (WARN_ON(!info->control.vif)) {
581 ieee80211_free_txskb(&local->hw, skb);
582 return;
583 }
584
585 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
586 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
587 false);
588 __skb_queue_tail(&local->pending[queue], skb);
589 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
590 false, &flags);
591 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
592}
593
594void ieee80211_add_pending_skbs(struct ieee80211_local *local,
595 struct sk_buff_head *skbs)
596{
597 struct ieee80211_hw *hw = &local->hw;
598 struct sk_buff *skb;
599 unsigned long flags;
600 int queue, i;
601
602 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
603 while ((skb = skb_dequeue(skbs))) {
604 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
605
606 if (WARN_ON(!info->control.vif)) {
607 ieee80211_free_txskb(&local->hw, skb);
608 continue;
609 }
610
611 queue = info->hw_queue;
612
613 __ieee80211_stop_queue(hw, queue,
614 IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
615 false);
616
617 __skb_queue_tail(&local->pending[queue], skb);
618 }
619
620 for (i = 0; i < hw->queues; i++)
621 __ieee80211_wake_queue(hw, i,
622 IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
623 false, &flags);
624 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
625}
626
627void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
628 unsigned long queues,
629 enum queue_stop_reason reason,
630 bool refcounted)
631{
632 struct ieee80211_local *local = hw_to_local(hw);
633 unsigned long flags;
634 int i;
635
636 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
637
638 for_each_set_bit(i, &queues, hw->queues)
639 __ieee80211_stop_queue(hw, i, reason, refcounted);
640
641 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
642}
643
644void ieee80211_stop_queues(struct ieee80211_hw *hw)
645{
646 ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
647 IEEE80211_QUEUE_STOP_REASON_DRIVER,
648 false);
649}
650EXPORT_SYMBOL(ieee80211_stop_queues);
651
652int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
653{
654 struct ieee80211_local *local = hw_to_local(hw);
655 unsigned long flags;
656 int ret;
657
658 if (WARN_ON(queue >= hw->queues))
659 return true;
660
661 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
662 ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
663 &local->queue_stop_reasons[queue]);
664 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
665 return ret;
666}
667EXPORT_SYMBOL(ieee80211_queue_stopped);
668
669void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
670 unsigned long queues,
671 enum queue_stop_reason reason,
672 bool refcounted)
673{
674 struct ieee80211_local *local = hw_to_local(hw);
675 unsigned long flags;
676 int i;
677
678 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
679
680 for_each_set_bit(i, &queues, hw->queues)
681 __ieee80211_wake_queue(hw, i, reason, refcounted, &flags);
682
683 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
684}
685
686void ieee80211_wake_queues(struct ieee80211_hw *hw)
687{
688 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
689 IEEE80211_QUEUE_STOP_REASON_DRIVER,
690 false);
691}
692EXPORT_SYMBOL(ieee80211_wake_queues);
693
694static unsigned int
695ieee80211_get_vif_queues(struct ieee80211_local *local,
696 struct ieee80211_sub_if_data *sdata)
697{
698 unsigned int queues;
699
700 if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
701 int ac;
702
703 queues = 0;
704
705 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
706 queues |= BIT(sdata->vif.hw_queue[ac]);
707 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
708 queues |= BIT(sdata->vif.cab_queue);
709 } else {
710
711 queues = BIT(local->hw.queues) - 1;
712 }
713
714 return queues;
715}
716
717void __ieee80211_flush_queues(struct ieee80211_local *local,
718 struct ieee80211_sub_if_data *sdata,
719 unsigned int queues, bool drop)
720{
721 if (!local->ops->flush)
722 return;
723
724
725
726
727
728 if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
729 queues = ieee80211_get_vif_queues(local, sdata);
730
731 ieee80211_stop_queues_by_reason(&local->hw, queues,
732 IEEE80211_QUEUE_STOP_REASON_FLUSH,
733 false);
734
735 drv_flush(local, sdata, queues, drop);
736
737 ieee80211_wake_queues_by_reason(&local->hw, queues,
738 IEEE80211_QUEUE_STOP_REASON_FLUSH,
739 false);
740}
741
742void ieee80211_flush_queues(struct ieee80211_local *local,
743 struct ieee80211_sub_if_data *sdata, bool drop)
744{
745 __ieee80211_flush_queues(local, sdata, 0, drop);
746}
747
748void ieee80211_stop_vif_queues(struct ieee80211_local *local,
749 struct ieee80211_sub_if_data *sdata,
750 enum queue_stop_reason reason)
751{
752 ieee80211_stop_queues_by_reason(&local->hw,
753 ieee80211_get_vif_queues(local, sdata),
754 reason, true);
755}
756
757void ieee80211_wake_vif_queues(struct ieee80211_local *local,
758 struct ieee80211_sub_if_data *sdata,
759 enum queue_stop_reason reason)
760{
761 ieee80211_wake_queues_by_reason(&local->hw,
762 ieee80211_get_vif_queues(local, sdata),
763 reason, true);
764}
765
766static void __iterate_interfaces(struct ieee80211_local *local,
767 u32 iter_flags,
768 void (*iterator)(void *data, u8 *mac,
769 struct ieee80211_vif *vif),
770 void *data)
771{
772 struct ieee80211_sub_if_data *sdata;
773 bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE;
774
775 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
776 switch (sdata->vif.type) {
777 case NL80211_IFTYPE_MONITOR:
778 if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
779 continue;
780 break;
781 case NL80211_IFTYPE_AP_VLAN:
782 continue;
783 default:
784 break;
785 }
786 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
787 active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
788 continue;
789 if ((iter_flags & IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER) &&
790 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
791 continue;
792 if (ieee80211_sdata_running(sdata) || !active_only)
793 iterator(data, sdata->vif.addr,
794 &sdata->vif);
795 }
796
797 sdata = rcu_dereference_check(local->monitor_sdata,
798 lockdep_is_held(&local->iflist_mtx) ||
799 lockdep_rtnl_is_held());
800 if (sdata &&
801 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only ||
802 sdata->flags & IEEE80211_SDATA_IN_DRIVER))
803 iterator(data, sdata->vif.addr, &sdata->vif);
804}
805
806void ieee80211_iterate_interfaces(
807 struct ieee80211_hw *hw, u32 iter_flags,
808 void (*iterator)(void *data, u8 *mac,
809 struct ieee80211_vif *vif),
810 void *data)
811{
812 struct ieee80211_local *local = hw_to_local(hw);
813
814 mutex_lock(&local->iflist_mtx);
815 __iterate_interfaces(local, iter_flags, iterator, data);
816 mutex_unlock(&local->iflist_mtx);
817}
818EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
819
820void ieee80211_iterate_active_interfaces_atomic(
821 struct ieee80211_hw *hw, u32 iter_flags,
822 void (*iterator)(void *data, u8 *mac,
823 struct ieee80211_vif *vif),
824 void *data)
825{
826 struct ieee80211_local *local = hw_to_local(hw);
827
828 rcu_read_lock();
829 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
830 iterator, data);
831 rcu_read_unlock();
832}
833EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
834
835void ieee80211_iterate_active_interfaces_mtx(
836 struct ieee80211_hw *hw, u32 iter_flags,
837 void (*iterator)(void *data, u8 *mac,
838 struct ieee80211_vif *vif),
839 void *data)
840{
841 struct ieee80211_local *local = hw_to_local(hw);
842
843 lockdep_assert_wiphy(hw->wiphy);
844
845 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
846 iterator, data);
847}
848EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx);
849
850static void __iterate_stations(struct ieee80211_local *local,
851 void (*iterator)(void *data,
852 struct ieee80211_sta *sta),
853 void *data)
854{
855 struct sta_info *sta;
856
857 list_for_each_entry_rcu(sta, &local->sta_list, list) {
858 if (!sta->uploaded)
859 continue;
860
861 iterator(data, &sta->sta);
862 }
863}
864
865void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
866 void (*iterator)(void *data,
867 struct ieee80211_sta *sta),
868 void *data)
869{
870 struct ieee80211_local *local = hw_to_local(hw);
871
872 rcu_read_lock();
873 __iterate_stations(local, iterator, data);
874 rcu_read_unlock();
875}
876EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
877
878struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
879{
880 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
881
882 if (!ieee80211_sdata_running(sdata) ||
883 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
884 return NULL;
885 return &sdata->vif;
886}
887EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
888
889struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
890{
891 if (!vif)
892 return NULL;
893
894 return &vif_to_sdata(vif)->wdev;
895}
896EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev);
897
898
899
900
901
902
903
904
905
906
907static bool ieee80211_can_queue_work(struct ieee80211_local *local)
908{
909 if (local->quiescing || (local->suspended && !local->resuming)) {
910 pr_warn("queueing ieee80211 work while going to suspend\n");
911 return false;
912 }
913
914 return true;
915}
916
917void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
918{
919 struct ieee80211_local *local = hw_to_local(hw);
920
921 if (!ieee80211_can_queue_work(local))
922 return;
923
924 queue_work(local->workqueue, work);
925}
926EXPORT_SYMBOL(ieee80211_queue_work);
927
928void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
929 struct delayed_work *dwork,
930 unsigned long delay)
931{
932 struct ieee80211_local *local = hw_to_local(hw);
933
934 if (!ieee80211_can_queue_work(local))
935 return;
936
937 queue_delayed_work(local->workqueue, dwork, delay);
938}
939EXPORT_SYMBOL(ieee80211_queue_delayed_work);
940
941static void ieee80211_parse_extension_element(u32 *crc,
942 const struct element *elem,
943 struct ieee802_11_elems *elems)
944{
945 const void *data = elem->data + 1;
946 u8 len = elem->datalen - 1;
947
948 switch (elem->data[0]) {
949 case WLAN_EID_EXT_HE_MU_EDCA:
950 if (len >= sizeof(*elems->mu_edca_param_set)) {
951 elems->mu_edca_param_set = data;
952 if (crc)
953 *crc = crc32_be(*crc, (void *)elem,
954 elem->datalen + 2);
955 }
956 break;
957 case WLAN_EID_EXT_HE_CAPABILITY:
958 elems->he_cap = data;
959 elems->he_cap_len = len;
960 break;
961 case WLAN_EID_EXT_HE_OPERATION:
962 if (len >= sizeof(*elems->he_operation) &&
963 len >= ieee80211_he_oper_size(data) - 1) {
964 if (crc)
965 *crc = crc32_be(*crc, (void *)elem,
966 elem->datalen + 2);
967 elems->he_operation = data;
968 }
969 break;
970 case WLAN_EID_EXT_UORA:
971 if (len >= 1)
972 elems->uora_element = data;
973 break;
974 case WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME:
975 if (len == 3)
976 elems->max_channel_switch_time = data;
977 break;
978 case WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION:
979 if (len >= sizeof(*elems->mbssid_config_ie))
980 elems->mbssid_config_ie = data;
981 break;
982 case WLAN_EID_EXT_HE_SPR:
983 if (len >= sizeof(*elems->he_spr) &&
984 len >= ieee80211_he_spr_size(data))
985 elems->he_spr = data;
986 break;
987 case WLAN_EID_EXT_HE_6GHZ_CAPA:
988 if (len >= sizeof(*elems->he_6ghz_capa))
989 elems->he_6ghz_capa = data;
990 break;
991 }
992}
993
994static u32
995_ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
996 struct ieee802_11_elems *elems,
997 u64 filter, u32 crc,
998 const struct element *check_inherit)
999{
1000 const struct element *elem;
1001 bool calc_crc = filter != 0;
1002 DECLARE_BITMAP(seen_elems, 256);
1003 const u8 *ie;
1004
1005 bitmap_zero(seen_elems, 256);
1006
1007 for_each_element(elem, start, len) {
1008 bool elem_parse_failed;
1009 u8 id = elem->id;
1010 u8 elen = elem->datalen;
1011 const u8 *pos = elem->data;
1012
1013 if (check_inherit &&
1014 !cfg80211_is_element_inherited(elem,
1015 check_inherit))
1016 continue;
1017
1018 switch (id) {
1019 case WLAN_EID_SSID:
1020 case WLAN_EID_SUPP_RATES:
1021 case WLAN_EID_FH_PARAMS:
1022 case WLAN_EID_DS_PARAMS:
1023 case WLAN_EID_CF_PARAMS:
1024 case WLAN_EID_TIM:
1025 case WLAN_EID_IBSS_PARAMS:
1026 case WLAN_EID_CHALLENGE:
1027 case WLAN_EID_RSN:
1028 case WLAN_EID_ERP_INFO:
1029 case WLAN_EID_EXT_SUPP_RATES:
1030 case WLAN_EID_HT_CAPABILITY:
1031 case WLAN_EID_HT_OPERATION:
1032 case WLAN_EID_VHT_CAPABILITY:
1033 case WLAN_EID_VHT_OPERATION:
1034 case WLAN_EID_MESH_ID:
1035 case WLAN_EID_MESH_CONFIG:
1036 case WLAN_EID_PEER_MGMT:
1037 case WLAN_EID_PREQ:
1038 case WLAN_EID_PREP:
1039 case WLAN_EID_PERR:
1040 case WLAN_EID_RANN:
1041 case WLAN_EID_CHANNEL_SWITCH:
1042 case WLAN_EID_EXT_CHANSWITCH_ANN:
1043 case WLAN_EID_COUNTRY:
1044 case WLAN_EID_PWR_CONSTRAINT:
1045 case WLAN_EID_TIMEOUT_INTERVAL:
1046 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
1047 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
1048 case WLAN_EID_CHAN_SWITCH_PARAM:
1049 case WLAN_EID_EXT_CAPABILITY:
1050 case WLAN_EID_CHAN_SWITCH_TIMING:
1051 case WLAN_EID_LINK_ID:
1052 case WLAN_EID_BSS_MAX_IDLE_PERIOD:
1053 case WLAN_EID_RSNX:
1054 case WLAN_EID_S1G_BCN_COMPAT:
1055 case WLAN_EID_S1G_CAPABILITIES:
1056 case WLAN_EID_S1G_OPERATION:
1057 case WLAN_EID_AID_RESPONSE:
1058 case WLAN_EID_S1G_SHORT_BCN_INTERVAL:
1059
1060
1061
1062
1063 if (test_bit(id, seen_elems)) {
1064 elems->parse_error = true;
1065 continue;
1066 }
1067 break;
1068 }
1069
1070 if (calc_crc && id < 64 && (filter & (1ULL << id)))
1071 crc = crc32_be(crc, pos - 2, elen + 2);
1072
1073 elem_parse_failed = false;
1074
1075 switch (id) {
1076 case WLAN_EID_LINK_ID:
1077 if (elen + 2 < sizeof(struct ieee80211_tdls_lnkie)) {
1078 elem_parse_failed = true;
1079 break;
1080 }
1081 elems->lnk_id = (void *)(pos - 2);
1082 break;
1083 case WLAN_EID_CHAN_SWITCH_TIMING:
1084 if (elen < sizeof(struct ieee80211_ch_switch_timing)) {
1085 elem_parse_failed = true;
1086 break;
1087 }
1088 elems->ch_sw_timing = (void *)pos;
1089 break;
1090 case WLAN_EID_EXT_CAPABILITY:
1091 elems->ext_capab = pos;
1092 elems->ext_capab_len = elen;
1093 break;
1094 case WLAN_EID_SSID:
1095 elems->ssid = pos;
1096 elems->ssid_len = elen;
1097 break;
1098 case WLAN_EID_SUPP_RATES:
1099 elems->supp_rates = pos;
1100 elems->supp_rates_len = elen;
1101 break;
1102 case WLAN_EID_DS_PARAMS:
1103 if (elen >= 1)
1104 elems->ds_params = pos;
1105 else
1106 elem_parse_failed = true;
1107 break;
1108 case WLAN_EID_TIM:
1109 if (elen >= sizeof(struct ieee80211_tim_ie)) {
1110 elems->tim = (void *)pos;
1111 elems->tim_len = elen;
1112 } else
1113 elem_parse_failed = true;
1114 break;
1115 case WLAN_EID_CHALLENGE:
1116 elems->challenge = pos;
1117 elems->challenge_len = elen;
1118 break;
1119 case WLAN_EID_VENDOR_SPECIFIC:
1120 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
1121 pos[2] == 0xf2) {
1122
1123
1124 if (calc_crc)
1125 crc = crc32_be(crc, pos - 2, elen + 2);
1126
1127 if (elen >= 5 && pos[3] == 2) {
1128
1129 if (pos[4] == 0) {
1130 elems->wmm_info = pos;
1131 elems->wmm_info_len = elen;
1132 } else if (pos[4] == 1) {
1133 elems->wmm_param = pos;
1134 elems->wmm_param_len = elen;
1135 }
1136 }
1137 }
1138 break;
1139 case WLAN_EID_RSN:
1140 elems->rsn = pos;
1141 elems->rsn_len = elen;
1142 break;
1143 case WLAN_EID_ERP_INFO:
1144 if (elen >= 1)
1145 elems->erp_info = pos;
1146 else
1147 elem_parse_failed = true;
1148 break;
1149 case WLAN_EID_EXT_SUPP_RATES:
1150 elems->ext_supp_rates = pos;
1151 elems->ext_supp_rates_len = elen;
1152 break;
1153 case WLAN_EID_HT_CAPABILITY:
1154 if (elen >= sizeof(struct ieee80211_ht_cap))
1155 elems->ht_cap_elem = (void *)pos;
1156 else
1157 elem_parse_failed = true;
1158 break;
1159 case WLAN_EID_HT_OPERATION:
1160 if (elen >= sizeof(struct ieee80211_ht_operation))
1161 elems->ht_operation = (void *)pos;
1162 else
1163 elem_parse_failed = true;
1164 break;
1165 case WLAN_EID_VHT_CAPABILITY:
1166 if (elen >= sizeof(struct ieee80211_vht_cap))
1167 elems->vht_cap_elem = (void *)pos;
1168 else
1169 elem_parse_failed = true;
1170 break;
1171 case WLAN_EID_VHT_OPERATION:
1172 if (elen >= sizeof(struct ieee80211_vht_operation)) {
1173 elems->vht_operation = (void *)pos;
1174 if (calc_crc)
1175 crc = crc32_be(crc, pos - 2, elen + 2);
1176 break;
1177 }
1178 elem_parse_failed = true;
1179 break;
1180 case WLAN_EID_OPMODE_NOTIF:
1181 if (elen > 0) {
1182 elems->opmode_notif = pos;
1183 if (calc_crc)
1184 crc = crc32_be(crc, pos - 2, elen + 2);
1185 break;
1186 }
1187 elem_parse_failed = true;
1188 break;
1189 case WLAN_EID_MESH_ID:
1190 elems->mesh_id = pos;
1191 elems->mesh_id_len = elen;
1192 break;
1193 case WLAN_EID_MESH_CONFIG:
1194 if (elen >= sizeof(struct ieee80211_meshconf_ie))
1195 elems->mesh_config = (void *)pos;
1196 else
1197 elem_parse_failed = true;
1198 break;
1199 case WLAN_EID_PEER_MGMT:
1200 elems->peering = pos;
1201 elems->peering_len = elen;
1202 break;
1203 case WLAN_EID_MESH_AWAKE_WINDOW:
1204 if (elen >= 2)
1205 elems->awake_window = (void *)pos;
1206 break;
1207 case WLAN_EID_PREQ:
1208 elems->preq = pos;
1209 elems->preq_len = elen;
1210 break;
1211 case WLAN_EID_PREP:
1212 elems->prep = pos;
1213 elems->prep_len = elen;
1214 break;
1215 case WLAN_EID_PERR:
1216 elems->perr = pos;
1217 elems->perr_len = elen;
1218 break;
1219 case WLAN_EID_RANN:
1220 if (elen >= sizeof(struct ieee80211_rann_ie))
1221 elems->rann = (void *)pos;
1222 else
1223 elem_parse_failed = true;
1224 break;
1225 case WLAN_EID_CHANNEL_SWITCH:
1226 if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
1227 elem_parse_failed = true;
1228 break;
1229 }
1230 elems->ch_switch_ie = (void *)pos;
1231 break;
1232 case WLAN_EID_EXT_CHANSWITCH_ANN:
1233 if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
1234 elem_parse_failed = true;
1235 break;
1236 }
1237 elems->ext_chansw_ie = (void *)pos;
1238 break;
1239 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
1240 if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
1241 elem_parse_failed = true;
1242 break;
1243 }
1244 elems->sec_chan_offs = (void *)pos;
1245 break;
1246 case WLAN_EID_CHAN_SWITCH_PARAM:
1247 if (elen <
1248 sizeof(*elems->mesh_chansw_params_ie)) {
1249 elem_parse_failed = true;
1250 break;
1251 }
1252 elems->mesh_chansw_params_ie = (void *)pos;
1253 break;
1254 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
1255 if (!action ||
1256 elen < sizeof(*elems->wide_bw_chansw_ie)) {
1257 elem_parse_failed = true;
1258 break;
1259 }
1260 elems->wide_bw_chansw_ie = (void *)pos;
1261 break;
1262 case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
1263 if (action) {
1264 elem_parse_failed = true;
1265 break;
1266 }
1267
1268
1269
1270
1271
1272 ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
1273 pos, elen);
1274 if (ie) {
1275 if (ie[1] >= sizeof(*elems->wide_bw_chansw_ie))
1276 elems->wide_bw_chansw_ie =
1277 (void *)(ie + 2);
1278 else
1279 elem_parse_failed = true;
1280 }
1281 break;
1282 case WLAN_EID_COUNTRY:
1283 elems->country_elem = pos;
1284 elems->country_elem_len = elen;
1285 break;
1286 case WLAN_EID_PWR_CONSTRAINT:
1287 if (elen != 1) {
1288 elem_parse_failed = true;
1289 break;
1290 }
1291 elems->pwr_constr_elem = pos;
1292 break;
1293 case WLAN_EID_CISCO_VENDOR_SPECIFIC:
1294
1295
1296
1297
1298
1299 if (elen < 4) {
1300 elem_parse_failed = true;
1301 break;
1302 }
1303
1304 if (pos[0] != 0x00 || pos[1] != 0x40 ||
1305 pos[2] != 0x96 || pos[3] != 0x00)
1306 break;
1307
1308 if (elen != 6) {
1309 elem_parse_failed = true;
1310 break;
1311 }
1312
1313 if (calc_crc)
1314 crc = crc32_be(crc, pos - 2, elen + 2);
1315
1316 elems->cisco_dtpc_elem = pos;
1317 break;
1318 case WLAN_EID_ADDBA_EXT:
1319 if (elen < sizeof(struct ieee80211_addba_ext_ie)) {
1320 elem_parse_failed = true;
1321 break;
1322 }
1323 elems->addba_ext_ie = (void *)pos;
1324 break;
1325 case WLAN_EID_TIMEOUT_INTERVAL:
1326 if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
1327 elems->timeout_int = (void *)pos;
1328 else
1329 elem_parse_failed = true;
1330 break;
1331 case WLAN_EID_BSS_MAX_IDLE_PERIOD:
1332 if (elen >= sizeof(*elems->max_idle_period_ie))
1333 elems->max_idle_period_ie = (void *)pos;
1334 break;
1335 case WLAN_EID_RSNX:
1336 elems->rsnx = pos;
1337 elems->rsnx_len = elen;
1338 break;
1339 case WLAN_EID_TX_POWER_ENVELOPE:
1340 if (elen < 1 ||
1341 elen > sizeof(struct ieee80211_tx_pwr_env))
1342 break;
1343
1344 if (elems->tx_pwr_env_num >= ARRAY_SIZE(elems->tx_pwr_env))
1345 break;
1346
1347 elems->tx_pwr_env[elems->tx_pwr_env_num] = (void *)pos;
1348 elems->tx_pwr_env_len[elems->tx_pwr_env_num] = elen;
1349 elems->tx_pwr_env_num++;
1350 break;
1351 case WLAN_EID_EXTENSION:
1352 ieee80211_parse_extension_element(calc_crc ?
1353 &crc : NULL,
1354 elem, elems);
1355 break;
1356 case WLAN_EID_S1G_CAPABILITIES:
1357 if (elen >= sizeof(*elems->s1g_capab))
1358 elems->s1g_capab = (void *)pos;
1359 else
1360 elem_parse_failed = true;
1361 break;
1362 case WLAN_EID_S1G_OPERATION:
1363 if (elen == sizeof(*elems->s1g_oper))
1364 elems->s1g_oper = (void *)pos;
1365 else
1366 elem_parse_failed = true;
1367 break;
1368 case WLAN_EID_S1G_BCN_COMPAT:
1369 if (elen == sizeof(*elems->s1g_bcn_compat))
1370 elems->s1g_bcn_compat = (void *)pos;
1371 else
1372 elem_parse_failed = true;
1373 break;
1374 case WLAN_EID_AID_RESPONSE:
1375 if (elen == sizeof(struct ieee80211_aid_response_ie))
1376 elems->aid_resp = (void *)pos;
1377 else
1378 elem_parse_failed = true;
1379 break;
1380 default:
1381 break;
1382 }
1383
1384 if (elem_parse_failed)
1385 elems->parse_error = true;
1386 else
1387 __set_bit(id, seen_elems);
1388 }
1389
1390 if (!for_each_element_completed(elem, start, len))
1391 elems->parse_error = true;
1392
1393 return crc;
1394}
1395
1396static size_t ieee802_11_find_bssid_profile(const u8 *start, size_t len,
1397 struct ieee802_11_elems *elems,
1398 u8 *transmitter_bssid,
1399 u8 *bss_bssid,
1400 u8 *nontransmitted_profile)
1401{
1402 const struct element *elem, *sub;
1403 size_t profile_len = 0;
1404 bool found = false;
1405
1406 if (!bss_bssid || !transmitter_bssid)
1407 return profile_len;
1408
1409 for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID, start, len) {
1410 if (elem->datalen < 2)
1411 continue;
1412
1413 for_each_element(sub, elem->data + 1, elem->datalen - 1) {
1414 u8 new_bssid[ETH_ALEN];
1415 const u8 *index;
1416
1417 if (sub->id != 0 || sub->datalen < 4) {
1418
1419 continue;
1420 }
1421
1422 if (sub->data[0] != WLAN_EID_NON_TX_BSSID_CAP ||
1423 sub->data[1] != 2) {
1424
1425
1426
1427
1428
1429 continue;
1430 }
1431
1432 memset(nontransmitted_profile, 0, len);
1433 profile_len = cfg80211_merge_profile(start, len,
1434 elem,
1435 sub,
1436 nontransmitted_profile,
1437 len);
1438
1439
1440 index = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX,
1441 nontransmitted_profile,
1442 profile_len);
1443 if (!index || index[1] < 1 || index[2] == 0) {
1444
1445 continue;
1446 }
1447
1448 cfg80211_gen_new_bssid(transmitter_bssid,
1449 elem->data[0],
1450 index[2],
1451 new_bssid);
1452 if (ether_addr_equal(new_bssid, bss_bssid)) {
1453 found = true;
1454 elems->bssid_index_len = index[1];
1455 elems->bssid_index = (void *)&index[2];
1456 break;
1457 }
1458 }
1459 }
1460
1461 return found ? profile_len : 0;
1462}
1463
1464u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
1465 struct ieee802_11_elems *elems,
1466 u64 filter, u32 crc, u8 *transmitter_bssid,
1467 u8 *bss_bssid)
1468{
1469 const struct element *non_inherit = NULL;
1470 u8 *nontransmitted_profile;
1471 int nontransmitted_profile_len = 0;
1472
1473 memset(elems, 0, sizeof(*elems));
1474 elems->ie_start = start;
1475 elems->total_len = len;
1476
1477 nontransmitted_profile = kmalloc(len, GFP_ATOMIC);
1478 if (nontransmitted_profile) {
1479 nontransmitted_profile_len =
1480 ieee802_11_find_bssid_profile(start, len, elems,
1481 transmitter_bssid,
1482 bss_bssid,
1483 nontransmitted_profile);
1484 non_inherit =
1485 cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
1486 nontransmitted_profile,
1487 nontransmitted_profile_len);
1488 }
1489
1490 crc = _ieee802_11_parse_elems_crc(start, len, action, elems, filter,
1491 crc, non_inherit);
1492
1493
1494 if (nontransmitted_profile_len)
1495 _ieee802_11_parse_elems_crc(nontransmitted_profile,
1496 nontransmitted_profile_len,
1497 action, elems, 0, 0, NULL);
1498
1499 if (elems->tim && !elems->parse_error) {
1500 const struct ieee80211_tim_ie *tim_ie = elems->tim;
1501
1502 elems->dtim_period = tim_ie->dtim_period;
1503 elems->dtim_count = tim_ie->dtim_count;
1504 }
1505
1506
1507 if (elems->bssid_index &&
1508 elems->bssid_index_len >=
1509 offsetofend(struct ieee80211_bssid_index, dtim_period))
1510 elems->dtim_period = elems->bssid_index->dtim_period;
1511
1512 if (elems->bssid_index &&
1513 elems->bssid_index_len >=
1514 offsetofend(struct ieee80211_bssid_index, dtim_count))
1515 elems->dtim_count = elems->bssid_index->dtim_count;
1516
1517 kfree(nontransmitted_profile);
1518
1519 return crc;
1520}
1521
1522void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
1523 struct ieee80211_tx_queue_params
1524 *qparam, int ac)
1525{
1526 struct ieee80211_chanctx_conf *chanctx_conf;
1527 const struct ieee80211_reg_rule *rrule;
1528 const struct ieee80211_wmm_ac *wmm_ac;
1529 u16 center_freq = 0;
1530
1531 if (sdata->vif.type != NL80211_IFTYPE_AP &&
1532 sdata->vif.type != NL80211_IFTYPE_STATION)
1533 return;
1534
1535 rcu_read_lock();
1536 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1537 if (chanctx_conf)
1538 center_freq = chanctx_conf->def.chan->center_freq;
1539
1540 if (!center_freq) {
1541 rcu_read_unlock();
1542 return;
1543 }
1544
1545 rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq));
1546
1547 if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) {
1548 rcu_read_unlock();
1549 return;
1550 }
1551
1552 if (sdata->vif.type == NL80211_IFTYPE_AP)
1553 wmm_ac = &rrule->wmm_rule.ap[ac];
1554 else
1555 wmm_ac = &rrule->wmm_rule.client[ac];
1556 qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min);
1557 qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max);
1558 qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn);
1559 qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32);
1560 rcu_read_unlock();
1561}
1562
1563void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
1564 bool bss_notify, bool enable_qos)
1565{
1566 struct ieee80211_local *local = sdata->local;
1567 struct ieee80211_tx_queue_params qparam;
1568 struct ieee80211_chanctx_conf *chanctx_conf;
1569 int ac;
1570 bool use_11b;
1571 bool is_ocb;
1572 int aCWmin, aCWmax;
1573
1574 if (!local->ops->conf_tx)
1575 return;
1576
1577 if (local->hw.queues < IEEE80211_NUM_ACS)
1578 return;
1579
1580 memset(&qparam, 0, sizeof(qparam));
1581
1582 rcu_read_lock();
1583 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1584 use_11b = (chanctx_conf &&
1585 chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) &&
1586 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
1587 rcu_read_unlock();
1588
1589 is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB);
1590
1591
1592 aCWmax = 1023;
1593 if (use_11b)
1594 aCWmin = 31;
1595 else
1596 aCWmin = 15;
1597
1598
1599 qparam.cw_max = aCWmax;
1600 qparam.cw_min = aCWmin;
1601 qparam.txop = 0;
1602 qparam.aifs = 2;
1603
1604 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1605
1606 if (enable_qos) {
1607 switch (ac) {
1608 case IEEE80211_AC_BK:
1609 qparam.cw_max = aCWmax;
1610 qparam.cw_min = aCWmin;
1611 qparam.txop = 0;
1612 if (is_ocb)
1613 qparam.aifs = 9;
1614 else
1615 qparam.aifs = 7;
1616 break;
1617
1618 default:
1619 case IEEE80211_AC_BE:
1620 qparam.cw_max = aCWmax;
1621 qparam.cw_min = aCWmin;
1622 qparam.txop = 0;
1623 if (is_ocb)
1624 qparam.aifs = 6;
1625 else
1626 qparam.aifs = 3;
1627 break;
1628 case IEEE80211_AC_VI:
1629 qparam.cw_max = aCWmin;
1630 qparam.cw_min = (aCWmin + 1) / 2 - 1;
1631 if (is_ocb)
1632 qparam.txop = 0;
1633 else if (use_11b)
1634 qparam.txop = 6016/32;
1635 else
1636 qparam.txop = 3008/32;
1637
1638 if (is_ocb)
1639 qparam.aifs = 3;
1640 else
1641 qparam.aifs = 2;
1642 break;
1643 case IEEE80211_AC_VO:
1644 qparam.cw_max = (aCWmin + 1) / 2 - 1;
1645 qparam.cw_min = (aCWmin + 1) / 4 - 1;
1646 if (is_ocb)
1647 qparam.txop = 0;
1648 else if (use_11b)
1649 qparam.txop = 3264/32;
1650 else
1651 qparam.txop = 1504/32;
1652 qparam.aifs = 2;
1653 break;
1654 }
1655 }
1656 ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac);
1657
1658 qparam.uapsd = false;
1659
1660 sdata->tx_conf[ac] = qparam;
1661 drv_conf_tx(local, sdata, ac, &qparam);
1662 }
1663
1664 if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1665 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
1666 sdata->vif.type != NL80211_IFTYPE_NAN) {
1667 sdata->vif.bss_conf.qos = enable_qos;
1668 if (bss_notify)
1669 ieee80211_bss_info_change_notify(sdata,
1670 BSS_CHANGED_QOS);
1671 }
1672}
1673
1674void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1675 u16 transaction, u16 auth_alg, u16 status,
1676 const u8 *extra, size_t extra_len, const u8 *da,
1677 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1678 u32 tx_flags)
1679{
1680 struct ieee80211_local *local = sdata->local;
1681 struct sk_buff *skb;
1682 struct ieee80211_mgmt *mgmt;
1683 int err;
1684
1685
1686 skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN +
1687 24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN);
1688 if (!skb)
1689 return;
1690
1691 skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN);
1692
1693 mgmt = skb_put_zero(skb, 24 + 6);
1694 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1695 IEEE80211_STYPE_AUTH);
1696 memcpy(mgmt->da, da, ETH_ALEN);
1697 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1698 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1699 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1700 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1701 mgmt->u.auth.status_code = cpu_to_le16(status);
1702 if (extra)
1703 skb_put_data(skb, extra, extra_len);
1704
1705 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1706 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1707 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1708 if (WARN_ON(err)) {
1709 kfree_skb(skb);
1710 return;
1711 }
1712 }
1713
1714 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1715 tx_flags;
1716 ieee80211_tx_skb(sdata, skb);
1717}
1718
1719void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1720 const u8 *da, const u8 *bssid,
1721 u16 stype, u16 reason,
1722 bool send_frame, u8 *frame_buf)
1723{
1724 struct ieee80211_local *local = sdata->local;
1725 struct sk_buff *skb;
1726 struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1727
1728
1729 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1730 mgmt->duration = 0;
1731 mgmt->seq_ctrl = 0;
1732 memcpy(mgmt->da, da, ETH_ALEN);
1733 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1734 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1735
1736 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1737
1738 if (send_frame) {
1739 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1740 IEEE80211_DEAUTH_FRAME_LEN);
1741 if (!skb)
1742 return;
1743
1744 skb_reserve(skb, local->hw.extra_tx_headroom);
1745
1746
1747 skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN);
1748
1749 if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1750 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1751 IEEE80211_SKB_CB(skb)->flags |=
1752 IEEE80211_TX_INTFL_DONT_ENCRYPT;
1753
1754 ieee80211_tx_skb(sdata, skb);
1755 }
1756}
1757
1758static u8 *ieee80211_write_he_6ghz_cap(u8 *pos, __le16 cap, u8 *end)
1759{
1760 if ((end - pos) < 5)
1761 return pos;
1762
1763 *pos++ = WLAN_EID_EXTENSION;
1764 *pos++ = 1 + sizeof(cap);
1765 *pos++ = WLAN_EID_EXT_HE_6GHZ_CAPA;
1766 memcpy(pos, &cap, sizeof(cap));
1767
1768 return pos + 2;
1769}
1770
1771static int ieee80211_build_preq_ies_band(struct ieee80211_sub_if_data *sdata,
1772 u8 *buffer, size_t buffer_len,
1773 const u8 *ie, size_t ie_len,
1774 enum nl80211_band band,
1775 u32 rate_mask,
1776 struct cfg80211_chan_def *chandef,
1777 size_t *offset, u32 flags)
1778{
1779 struct ieee80211_local *local = sdata->local;
1780 struct ieee80211_supported_band *sband;
1781 const struct ieee80211_sta_he_cap *he_cap;
1782 u8 *pos = buffer, *end = buffer + buffer_len;
1783 size_t noffset;
1784 int supp_rates_len, i;
1785 u8 rates[32];
1786 int num_rates;
1787 int ext_rates_len;
1788 int shift;
1789 u32 rate_flags;
1790 bool have_80mhz = false;
1791
1792 *offset = 0;
1793
1794 sband = local->hw.wiphy->bands[band];
1795 if (WARN_ON_ONCE(!sband))
1796 return 0;
1797
1798 rate_flags = ieee80211_chandef_rate_flags(chandef);
1799 shift = ieee80211_chandef_get_shift(chandef);
1800
1801 num_rates = 0;
1802 for (i = 0; i < sband->n_bitrates; i++) {
1803 if ((BIT(i) & rate_mask) == 0)
1804 continue;
1805 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1806 continue;
1807
1808 rates[num_rates++] =
1809 (u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
1810 (1 << shift) * 5);
1811 }
1812
1813 supp_rates_len = min_t(int, num_rates, 8);
1814
1815 if (end - pos < 2 + supp_rates_len)
1816 goto out_err;
1817 *pos++ = WLAN_EID_SUPP_RATES;
1818 *pos++ = supp_rates_len;
1819 memcpy(pos, rates, supp_rates_len);
1820 pos += supp_rates_len;
1821
1822
1823 if (ie && ie_len) {
1824 static const u8 before_extrates[] = {
1825 WLAN_EID_SSID,
1826 WLAN_EID_SUPP_RATES,
1827 WLAN_EID_REQUEST,
1828 };
1829 noffset = ieee80211_ie_split(ie, ie_len,
1830 before_extrates,
1831 ARRAY_SIZE(before_extrates),
1832 *offset);
1833 if (end - pos < noffset - *offset)
1834 goto out_err;
1835 memcpy(pos, ie + *offset, noffset - *offset);
1836 pos += noffset - *offset;
1837 *offset = noffset;
1838 }
1839
1840 ext_rates_len = num_rates - supp_rates_len;
1841 if (ext_rates_len > 0) {
1842 if (end - pos < 2 + ext_rates_len)
1843 goto out_err;
1844 *pos++ = WLAN_EID_EXT_SUPP_RATES;
1845 *pos++ = ext_rates_len;
1846 memcpy(pos, rates + supp_rates_len, ext_rates_len);
1847 pos += ext_rates_len;
1848 }
1849
1850 if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
1851 if (end - pos < 3)
1852 goto out_err;
1853 *pos++ = WLAN_EID_DS_PARAMS;
1854 *pos++ = 1;
1855 *pos++ = ieee80211_frequency_to_channel(
1856 chandef->chan->center_freq);
1857 }
1858
1859 if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT)
1860 goto done;
1861
1862
1863 if (ie && ie_len) {
1864 static const u8 before_ht[] = {
1865
1866
1867
1868
1869 WLAN_EID_DS_PARAMS,
1870 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1871 };
1872 noffset = ieee80211_ie_split(ie, ie_len,
1873 before_ht, ARRAY_SIZE(before_ht),
1874 *offset);
1875 if (end - pos < noffset - *offset)
1876 goto out_err;
1877 memcpy(pos, ie + *offset, noffset - *offset);
1878 pos += noffset - *offset;
1879 *offset = noffset;
1880 }
1881
1882 if (sband->ht_cap.ht_supported) {
1883 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
1884 goto out_err;
1885 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1886 sband->ht_cap.cap);
1887 }
1888
1889
1890 if (ie && ie_len) {
1891 static const u8 before_vht[] = {
1892
1893
1894
1895
1896 WLAN_EID_BSS_COEX_2040,
1897 WLAN_EID_EXT_CAPABILITY,
1898 WLAN_EID_SSID_LIST,
1899 WLAN_EID_CHANNEL_USAGE,
1900 WLAN_EID_INTERWORKING,
1901 WLAN_EID_MESH_ID,
1902
1903 };
1904 noffset = ieee80211_ie_split(ie, ie_len,
1905 before_vht, ARRAY_SIZE(before_vht),
1906 *offset);
1907 if (end - pos < noffset - *offset)
1908 goto out_err;
1909 memcpy(pos, ie + *offset, noffset - *offset);
1910 pos += noffset - *offset;
1911 *offset = noffset;
1912 }
1913
1914
1915 for (i = 0; i < sband->n_channels; i++) {
1916 if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
1917 IEEE80211_CHAN_NO_80MHZ))
1918 continue;
1919
1920 have_80mhz = true;
1921 break;
1922 }
1923
1924 if (sband->vht_cap.vht_supported && have_80mhz) {
1925 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
1926 goto out_err;
1927 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1928 sband->vht_cap.cap);
1929 }
1930
1931
1932 if (ie && ie_len) {
1933 static const u8 before_he[] = {
1934
1935
1936
1937
1938 WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS,
1939 WLAN_EID_AP_CSN,
1940
1941 };
1942 noffset = ieee80211_ie_split(ie, ie_len,
1943 before_he, ARRAY_SIZE(before_he),
1944 *offset);
1945 if (end - pos < noffset - *offset)
1946 goto out_err;
1947 memcpy(pos, ie + *offset, noffset - *offset);
1948 pos += noffset - *offset;
1949 *offset = noffset;
1950 }
1951
1952 he_cap = ieee80211_get_he_iftype_cap(sband,
1953 ieee80211_vif_type_p2p(&sdata->vif));
1954 if (he_cap &&
1955 cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1956 IEEE80211_CHAN_NO_HE)) {
1957 pos = ieee80211_ie_build_he_cap(pos, he_cap, end);
1958 if (!pos)
1959 goto out_err;
1960 }
1961
1962 if (cfg80211_any_usable_channels(local->hw.wiphy,
1963 BIT(NL80211_BAND_6GHZ),
1964 IEEE80211_CHAN_NO_HE)) {
1965 struct ieee80211_supported_band *sband6;
1966
1967 sband6 = local->hw.wiphy->bands[NL80211_BAND_6GHZ];
1968 he_cap = ieee80211_get_he_iftype_cap(sband6,
1969 ieee80211_vif_type_p2p(&sdata->vif));
1970
1971 if (he_cap) {
1972 enum nl80211_iftype iftype =
1973 ieee80211_vif_type_p2p(&sdata->vif);
1974 __le16 cap = ieee80211_get_he_6ghz_capa(sband, iftype);
1975
1976 pos = ieee80211_write_he_6ghz_cap(pos, cap, end);
1977 }
1978 }
1979
1980
1981
1982
1983
1984
1985 return pos - buffer;
1986 out_err:
1987 WARN_ONCE(1, "not enough space for preq IEs\n");
1988 done:
1989 return pos - buffer;
1990}
1991
1992int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer,
1993 size_t buffer_len,
1994 struct ieee80211_scan_ies *ie_desc,
1995 const u8 *ie, size_t ie_len,
1996 u8 bands_used, u32 *rate_masks,
1997 struct cfg80211_chan_def *chandef,
1998 u32 flags)
1999{
2000 size_t pos = 0, old_pos = 0, custom_ie_offset = 0;
2001 int i;
2002
2003 memset(ie_desc, 0, sizeof(*ie_desc));
2004
2005 for (i = 0; i < NUM_NL80211_BANDS; i++) {
2006 if (bands_used & BIT(i)) {
2007 pos += ieee80211_build_preq_ies_band(sdata,
2008 buffer + pos,
2009 buffer_len - pos,
2010 ie, ie_len, i,
2011 rate_masks[i],
2012 chandef,
2013 &custom_ie_offset,
2014 flags);
2015 ie_desc->ies[i] = buffer + old_pos;
2016 ie_desc->len[i] = pos - old_pos;
2017 old_pos = pos;
2018 }
2019 }
2020
2021
2022 if (ie && ie_len) {
2023 if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset,
2024 "not enough space for preq custom IEs\n"))
2025 return pos;
2026 memcpy(buffer + pos, ie + custom_ie_offset,
2027 ie_len - custom_ie_offset);
2028 ie_desc->common_ies = buffer + pos;
2029 ie_desc->common_ie_len = ie_len - custom_ie_offset;
2030 pos += ie_len - custom_ie_offset;
2031 }
2032
2033 return pos;
2034};
2035
2036struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
2037 const u8 *src, const u8 *dst,
2038 u32 ratemask,
2039 struct ieee80211_channel *chan,
2040 const u8 *ssid, size_t ssid_len,
2041 const u8 *ie, size_t ie_len,
2042 u32 flags)
2043{
2044 struct ieee80211_local *local = sdata->local;
2045 struct cfg80211_chan_def chandef;
2046 struct sk_buff *skb;
2047 struct ieee80211_mgmt *mgmt;
2048 int ies_len;
2049 u32 rate_masks[NUM_NL80211_BANDS] = {};
2050 struct ieee80211_scan_ies dummy_ie_desc;
2051
2052
2053
2054
2055
2056
2057 chandef.width = sdata->vif.bss_conf.chandef.width;
2058 if (flags & IEEE80211_PROBE_FLAG_DIRECTED)
2059 chandef.chan = NULL;
2060 else
2061 chandef.chan = chan;
2062
2063 skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
2064 100 + ie_len);
2065 if (!skb)
2066 return NULL;
2067
2068 rate_masks[chan->band] = ratemask;
2069 ies_len = ieee80211_build_preq_ies(sdata, skb_tail_pointer(skb),
2070 skb_tailroom(skb), &dummy_ie_desc,
2071 ie, ie_len, BIT(chan->band),
2072 rate_masks, &chandef, flags);
2073 skb_put(skb, ies_len);
2074
2075 if (dst) {
2076 mgmt = (struct ieee80211_mgmt *) skb->data;
2077 memcpy(mgmt->da, dst, ETH_ALEN);
2078 memcpy(mgmt->bssid, dst, ETH_ALEN);
2079 }
2080
2081 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
2082
2083 return skb;
2084}
2085
2086u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
2087 struct ieee802_11_elems *elems,
2088 enum nl80211_band band, u32 *basic_rates)
2089{
2090 struct ieee80211_supported_band *sband;
2091 size_t num_rates;
2092 u32 supp_rates, rate_flags;
2093 int i, j, shift;
2094
2095 sband = sdata->local->hw.wiphy->bands[band];
2096 if (WARN_ON(!sband))
2097 return 1;
2098
2099 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2100 shift = ieee80211_vif_get_shift(&sdata->vif);
2101
2102 num_rates = sband->n_bitrates;
2103 supp_rates = 0;
2104 for (i = 0; i < elems->supp_rates_len +
2105 elems->ext_supp_rates_len; i++) {
2106 u8 rate = 0;
2107 int own_rate;
2108 bool is_basic;
2109 if (i < elems->supp_rates_len)
2110 rate = elems->supp_rates[i];
2111 else if (elems->ext_supp_rates)
2112 rate = elems->ext_supp_rates
2113 [i - elems->supp_rates_len];
2114 own_rate = 5 * (rate & 0x7f);
2115 is_basic = !!(rate & 0x80);
2116
2117 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
2118 continue;
2119
2120 for (j = 0; j < num_rates; j++) {
2121 int brate;
2122 if ((rate_flags & sband->bitrates[j].flags)
2123 != rate_flags)
2124 continue;
2125
2126 brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
2127 1 << shift);
2128
2129 if (brate == own_rate) {
2130 supp_rates |= BIT(j);
2131 if (basic_rates && is_basic)
2132 *basic_rates |= BIT(j);
2133 }
2134 }
2135 }
2136 return supp_rates;
2137}
2138
2139void ieee80211_stop_device(struct ieee80211_local *local)
2140{
2141 ieee80211_led_radio(local, false);
2142 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
2143
2144 cancel_work_sync(&local->reconfig_filter);
2145
2146 flush_workqueue(local->workqueue);
2147 drv_stop(local);
2148}
2149
2150static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
2151 bool aborted)
2152{
2153
2154
2155
2156
2157
2158
2159
2160 if (test_bit(SCAN_COMPLETED, &local->scanning)) {
2161
2162
2163
2164
2165
2166 if (aborted)
2167 set_bit(SCAN_ABORTED, &local->scanning);
2168 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
2169 flush_delayed_work(&local->scan_work);
2170 }
2171}
2172
2173static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
2174{
2175 struct ieee80211_sub_if_data *sdata;
2176 struct ieee80211_chanctx *ctx;
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188 local->resuming = false;
2189 local->suspended = false;
2190 local->in_reconfig = false;
2191
2192 ieee80211_flush_completed_scan(local, true);
2193
2194
2195
2196
2197 ieee80211_sched_scan_end(local);
2198
2199 list_for_each_entry(sdata, &local->interfaces, list)
2200 sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
2201
2202
2203
2204
2205 mutex_lock(&local->chanctx_mtx);
2206 list_for_each_entry(ctx, &local->chanctx_list, list)
2207 ctx->driver_present = false;
2208 mutex_unlock(&local->chanctx_mtx);
2209}
2210
2211static void ieee80211_assign_chanctx(struct ieee80211_local *local,
2212 struct ieee80211_sub_if_data *sdata)
2213{
2214 struct ieee80211_chanctx_conf *conf;
2215 struct ieee80211_chanctx *ctx;
2216
2217 if (!local->use_chanctx)
2218 return;
2219
2220 mutex_lock(&local->chanctx_mtx);
2221 conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2222 lockdep_is_held(&local->chanctx_mtx));
2223 if (conf) {
2224 ctx = container_of(conf, struct ieee80211_chanctx, conf);
2225 drv_assign_vif_chanctx(local, sdata, ctx);
2226 }
2227 mutex_unlock(&local->chanctx_mtx);
2228}
2229
2230static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
2231{
2232 struct ieee80211_local *local = sdata->local;
2233 struct sta_info *sta;
2234
2235
2236 mutex_lock(&local->sta_mtx);
2237 list_for_each_entry(sta, &local->sta_list, list) {
2238 enum ieee80211_sta_state state;
2239
2240 if (!sta->uploaded || sta->sdata != sdata)
2241 continue;
2242
2243 for (state = IEEE80211_STA_NOTEXIST;
2244 state < sta->sta_state; state++)
2245 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
2246 state + 1));
2247 }
2248 mutex_unlock(&local->sta_mtx);
2249}
2250
2251static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
2252{
2253 struct cfg80211_nan_func *func, **funcs;
2254 int res, id, i = 0;
2255
2256 res = drv_start_nan(sdata->local, sdata,
2257 &sdata->u.nan.conf);
2258 if (WARN_ON(res))
2259 return res;
2260
2261 funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
2262 sizeof(*funcs),
2263 GFP_KERNEL);
2264 if (!funcs)
2265 return -ENOMEM;
2266
2267
2268
2269
2270
2271 spin_lock_bh(&sdata->u.nan.func_lock);
2272
2273 idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
2274 funcs[i++] = func;
2275
2276 spin_unlock_bh(&sdata->u.nan.func_lock);
2277
2278 for (i = 0; funcs[i]; i++) {
2279 res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
2280 if (WARN_ON(res))
2281 ieee80211_nan_func_terminated(&sdata->vif,
2282 funcs[i]->instance_id,
2283 NL80211_NAN_FUNC_TERM_REASON_ERROR,
2284 GFP_KERNEL);
2285 }
2286
2287 kfree(funcs);
2288
2289 return 0;
2290}
2291
2292int ieee80211_reconfig(struct ieee80211_local *local)
2293{
2294 struct ieee80211_hw *hw = &local->hw;
2295 struct ieee80211_sub_if_data *sdata;
2296 struct ieee80211_chanctx *ctx;
2297 struct sta_info *sta;
2298 int res, i;
2299 bool reconfig_due_to_wowlan = false;
2300 struct ieee80211_sub_if_data *sched_scan_sdata;
2301 struct cfg80211_sched_scan_request *sched_scan_req;
2302 bool sched_scan_stopped = false;
2303 bool suspended = local->suspended;
2304
2305
2306 if (!local->open_count)
2307 goto wake_up;
2308
2309#ifdef CONFIG_PM
2310 if (suspended)
2311 local->resuming = true;
2312
2313 if (local->wowlan) {
2314
2315
2316
2317
2318
2319
2320 local->suspended = false;
2321 res = drv_resume(local);
2322 local->wowlan = false;
2323 if (res < 0) {
2324 local->resuming = false;
2325 return res;
2326 }
2327 if (res == 0)
2328 goto wake_up;
2329 WARN_ON(res > 1);
2330
2331
2332
2333
2334
2335 reconfig_due_to_wowlan = true;
2336 local->suspended = true;
2337 }
2338#endif
2339
2340
2341
2342
2343
2344
2345
2346
2347 if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
2348 cancel_work_sync(&local->restart_work);
2349
2350 local->started = false;
2351
2352
2353
2354
2355
2356
2357
2358 res = drv_start(local);
2359 if (res) {
2360 if (suspended)
2361 WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
2362 else
2363 WARN(1, "Hardware became unavailable during restart.\n");
2364 ieee80211_handle_reconfig_failure(local);
2365 return res;
2366 }
2367
2368
2369 drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
2370
2371
2372 drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
2373
2374
2375 drv_set_coverage_class(local, hw->wiphy->coverage_class);
2376
2377 ieee80211_led_radio(local, true);
2378 ieee80211_mod_tpt_led_trig(local,
2379 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
2380
2381
2382 sdata = rtnl_dereference(local->monitor_sdata);
2383 if (sdata) {
2384
2385 WARN_ON(local->resuming);
2386 res = drv_add_interface(local, sdata);
2387 if (WARN_ON(res)) {
2388 RCU_INIT_POINTER(local->monitor_sdata, NULL);
2389 synchronize_net();
2390 kfree(sdata);
2391 }
2392 }
2393
2394 list_for_each_entry(sdata, &local->interfaces, list) {
2395 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2396 sdata->vif.type != NL80211_IFTYPE_MONITOR &&
2397 ieee80211_sdata_running(sdata)) {
2398 res = drv_add_interface(local, sdata);
2399 if (WARN_ON(res))
2400 break;
2401 }
2402 }
2403
2404
2405
2406
2407 if (res) {
2408 list_for_each_entry_continue_reverse(sdata, &local->interfaces,
2409 list)
2410 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
2411 sdata->vif.type != NL80211_IFTYPE_MONITOR &&
2412 ieee80211_sdata_running(sdata))
2413 drv_remove_interface(local, sdata);
2414 ieee80211_handle_reconfig_failure(local);
2415 return res;
2416 }
2417
2418
2419 if (local->use_chanctx) {
2420 mutex_lock(&local->chanctx_mtx);
2421 list_for_each_entry(ctx, &local->chanctx_list, list)
2422 if (ctx->replace_state !=
2423 IEEE80211_CHANCTX_REPLACES_OTHER)
2424 WARN_ON(drv_add_chanctx(local, ctx));
2425 mutex_unlock(&local->chanctx_mtx);
2426
2427 sdata = rtnl_dereference(local->monitor_sdata);
2428 if (sdata && ieee80211_sdata_running(sdata))
2429 ieee80211_assign_chanctx(local, sdata);
2430 }
2431
2432
2433 ieee80211_hw_config(local, ~0);
2434
2435 ieee80211_configure_filter(local);
2436
2437
2438 list_for_each_entry(sdata, &local->interfaces, list) {
2439 u32 changed;
2440
2441 if (!ieee80211_sdata_running(sdata))
2442 continue;
2443
2444 ieee80211_assign_chanctx(local, sdata);
2445
2446 switch (sdata->vif.type) {
2447 case NL80211_IFTYPE_AP_VLAN:
2448 case NL80211_IFTYPE_MONITOR:
2449 break;
2450 case NL80211_IFTYPE_ADHOC:
2451 if (sdata->vif.bss_conf.ibss_joined)
2452 WARN_ON(drv_join_ibss(local, sdata));
2453 fallthrough;
2454 default:
2455 ieee80211_reconfig_stations(sdata);
2456 fallthrough;
2457 case NL80211_IFTYPE_AP:
2458 for (i = 0; i < IEEE80211_NUM_ACS; i++)
2459 drv_conf_tx(local, sdata, i,
2460 &sdata->tx_conf[i]);
2461 break;
2462 }
2463
2464
2465 changed = BSS_CHANGED_ERP_CTS_PROT |
2466 BSS_CHANGED_ERP_PREAMBLE |
2467 BSS_CHANGED_ERP_SLOT |
2468 BSS_CHANGED_HT |
2469 BSS_CHANGED_BASIC_RATES |
2470 BSS_CHANGED_BEACON_INT |
2471 BSS_CHANGED_BSSID |
2472 BSS_CHANGED_CQM |
2473 BSS_CHANGED_QOS |
2474 BSS_CHANGED_IDLE |
2475 BSS_CHANGED_TXPOWER |
2476 BSS_CHANGED_MCAST_RATE;
2477
2478 if (sdata->vif.mu_mimo_owner)
2479 changed |= BSS_CHANGED_MU_GROUPS;
2480
2481 switch (sdata->vif.type) {
2482 case NL80211_IFTYPE_STATION:
2483 changed |= BSS_CHANGED_ASSOC |
2484 BSS_CHANGED_ARP_FILTER |
2485 BSS_CHANGED_PS;
2486
2487
2488 if (sdata->u.mgd.have_beacon)
2489 changed |= BSS_CHANGED_BEACON_INFO;
2490
2491 if (sdata->vif.bss_conf.max_idle_period ||
2492 sdata->vif.bss_conf.protected_keep_alive)
2493 changed |= BSS_CHANGED_KEEP_ALIVE;
2494
2495 sdata_lock(sdata);
2496 ieee80211_bss_info_change_notify(sdata, changed);
2497 sdata_unlock(sdata);
2498 break;
2499 case NL80211_IFTYPE_OCB:
2500 changed |= BSS_CHANGED_OCB;
2501 ieee80211_bss_info_change_notify(sdata, changed);
2502 break;
2503 case NL80211_IFTYPE_ADHOC:
2504 changed |= BSS_CHANGED_IBSS;
2505 fallthrough;
2506 case NL80211_IFTYPE_AP:
2507 changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
2508
2509 if (sdata->vif.bss_conf.ftm_responder == 1 &&
2510 wiphy_ext_feature_isset(sdata->local->hw.wiphy,
2511 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
2512 changed |= BSS_CHANGED_FTM_RESPONDER;
2513
2514 if (sdata->vif.type == NL80211_IFTYPE_AP) {
2515 changed |= BSS_CHANGED_AP_PROBE_RESP;
2516
2517 if (rcu_access_pointer(sdata->u.ap.beacon))
2518 drv_start_ap(local, sdata);
2519 }
2520 fallthrough;
2521 case NL80211_IFTYPE_MESH_POINT:
2522 if (sdata->vif.bss_conf.enable_beacon) {
2523 changed |= BSS_CHANGED_BEACON |
2524 BSS_CHANGED_BEACON_ENABLED;
2525 ieee80211_bss_info_change_notify(sdata, changed);
2526 }
2527 break;
2528 case NL80211_IFTYPE_NAN:
2529 res = ieee80211_reconfig_nan(sdata);
2530 if (res < 0) {
2531 ieee80211_handle_reconfig_failure(local);
2532 return res;
2533 }
2534 break;
2535 case NL80211_IFTYPE_AP_VLAN:
2536 case NL80211_IFTYPE_MONITOR:
2537 case NL80211_IFTYPE_P2P_DEVICE:
2538
2539 break;
2540 case NL80211_IFTYPE_UNSPECIFIED:
2541 case NUM_NL80211_IFTYPES:
2542 case NL80211_IFTYPE_P2P_CLIENT:
2543 case NL80211_IFTYPE_P2P_GO:
2544 case NL80211_IFTYPE_WDS:
2545 WARN_ON(1);
2546 break;
2547 }
2548 }
2549
2550 ieee80211_recalc_ps(local);
2551
2552
2553
2554
2555
2556
2557
2558 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
2559 list_for_each_entry(sdata, &local->interfaces, list) {
2560 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2561 continue;
2562 if (!sdata->u.mgd.associated)
2563 continue;
2564
2565 ieee80211_send_nullfunc(local, sdata, false);
2566 }
2567 }
2568
2569
2570 mutex_lock(&local->sta_mtx);
2571 list_for_each_entry(sta, &local->sta_list, list) {
2572 enum ieee80211_sta_state state;
2573
2574 if (!sta->uploaded)
2575 continue;
2576
2577 if (sta->sdata->vif.type != NL80211_IFTYPE_AP &&
2578 sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
2579 continue;
2580
2581 for (state = IEEE80211_STA_NOTEXIST;
2582 state < sta->sta_state; state++)
2583 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
2584 state + 1));
2585 }
2586 mutex_unlock(&local->sta_mtx);
2587
2588
2589 list_for_each_entry(sdata, &local->interfaces, list)
2590 ieee80211_reenable_keys(sdata);
2591
2592
2593 mutex_lock(&local->mtx);
2594 sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
2595 lockdep_is_held(&local->mtx));
2596 sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
2597 lockdep_is_held(&local->mtx));
2598 if (sched_scan_sdata && sched_scan_req)
2599
2600
2601
2602
2603
2604
2605
2606 if (sched_scan_req->n_scan_plans > 1 ||
2607 __ieee80211_request_sched_scan_start(sched_scan_sdata,
2608 sched_scan_req)) {
2609 RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
2610 RCU_INIT_POINTER(local->sched_scan_req, NULL);
2611 sched_scan_stopped = true;
2612 }
2613 mutex_unlock(&local->mtx);
2614
2615 if (sched_scan_stopped)
2616 cfg80211_sched_scan_stopped_locked(local->hw.wiphy, 0);
2617
2618 wake_up:
2619
2620 if (local->monitors == local->open_count && local->monitors > 0)
2621 ieee80211_add_virtual_monitor(local);
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633 if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
2634 mutex_lock(&local->sta_mtx);
2635
2636 list_for_each_entry(sta, &local->sta_list, list) {
2637 if (!local->resuming)
2638 ieee80211_sta_tear_down_BA_sessions(
2639 sta, AGG_STOP_LOCAL_REQUEST);
2640 clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
2641 }
2642
2643 mutex_unlock(&local->sta_mtx);
2644 }
2645
2646 if (local->in_reconfig) {
2647 local->in_reconfig = false;
2648 barrier();
2649
2650
2651 mutex_lock(&local->mtx);
2652 ieee80211_start_next_roc(local);
2653 mutex_unlock(&local->mtx);
2654
2655
2656 list_for_each_entry(sdata, &local->interfaces, list)
2657 ieee80211_queue_work(&local->hw, &sdata->work);
2658 }
2659
2660 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
2661 IEEE80211_QUEUE_STOP_REASON_SUSPEND,
2662 false);
2663
2664
2665
2666
2667
2668 if (local->open_count && (!suspended || reconfig_due_to_wowlan))
2669 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
2670
2671 if (!suspended)
2672 return 0;
2673
2674#ifdef CONFIG_PM
2675
2676 local->suspended = false;
2677 mb();
2678 local->resuming = false;
2679
2680 ieee80211_flush_completed_scan(local, false);
2681
2682 if (local->open_count && !reconfig_due_to_wowlan)
2683 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
2684
2685 list_for_each_entry(sdata, &local->interfaces, list) {
2686 if (!ieee80211_sdata_running(sdata))
2687 continue;
2688 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2689 ieee80211_sta_restart(sdata);
2690 }
2691
2692 mod_timer(&local->sta_cleanup, jiffies + 1);
2693#else
2694 WARN_ON(1);
2695#endif
2696
2697 return 0;
2698}
2699
2700void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
2701{
2702 struct ieee80211_sub_if_data *sdata;
2703 struct ieee80211_local *local;
2704 struct ieee80211_key *key;
2705
2706 if (WARN_ON(!vif))
2707 return;
2708
2709 sdata = vif_to_sdata(vif);
2710 local = sdata->local;
2711
2712 if (WARN_ON(!local->resuming))
2713 return;
2714
2715 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2716 return;
2717
2718 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
2719
2720 mutex_lock(&local->key_mtx);
2721 list_for_each_entry(key, &sdata->key_list, list)
2722 key->flags |= KEY_FLAG_TAINTED;
2723 mutex_unlock(&local->key_mtx);
2724}
2725EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
2726
2727void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
2728{
2729 struct ieee80211_local *local = sdata->local;
2730 struct ieee80211_chanctx_conf *chanctx_conf;
2731 struct ieee80211_chanctx *chanctx;
2732
2733 mutex_lock(&local->chanctx_mtx);
2734
2735 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2736 lockdep_is_held(&local->chanctx_mtx));
2737
2738
2739
2740
2741
2742
2743
2744 if (!chanctx_conf)
2745 goto unlock;
2746
2747 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2748 ieee80211_recalc_smps_chanctx(local, chanctx);
2749 unlock:
2750 mutex_unlock(&local->chanctx_mtx);
2751}
2752
2753void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
2754{
2755 struct ieee80211_local *local = sdata->local;
2756 struct ieee80211_chanctx_conf *chanctx_conf;
2757 struct ieee80211_chanctx *chanctx;
2758
2759 mutex_lock(&local->chanctx_mtx);
2760
2761 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2762 lockdep_is_held(&local->chanctx_mtx));
2763
2764 if (WARN_ON_ONCE(!chanctx_conf))
2765 goto unlock;
2766
2767 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2768 ieee80211_recalc_chanctx_min_def(local, chanctx);
2769 unlock:
2770 mutex_unlock(&local->chanctx_mtx);
2771}
2772
2773size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
2774{
2775 size_t pos = offset;
2776
2777 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
2778 pos += 2 + ies[pos + 1];
2779
2780 return pos;
2781}
2782
2783static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
2784 int rssi_min_thold,
2785 int rssi_max_thold)
2786{
2787 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
2788
2789 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2790 return;
2791
2792
2793
2794
2795
2796
2797 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
2798 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
2799}
2800
2801void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
2802 int rssi_min_thold,
2803 int rssi_max_thold)
2804{
2805 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2806
2807 WARN_ON(rssi_min_thold == rssi_max_thold ||
2808 rssi_min_thold > rssi_max_thold);
2809
2810 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
2811 rssi_max_thold);
2812}
2813EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
2814
2815void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
2816{
2817 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2818
2819 _ieee80211_enable_rssi_reports(sdata, 0, 0);
2820}
2821EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
2822
2823u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2824 u16 cap)
2825{
2826 __le16 tmp;
2827
2828 *pos++ = WLAN_EID_HT_CAPABILITY;
2829 *pos++ = sizeof(struct ieee80211_ht_cap);
2830 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
2831
2832
2833 tmp = cpu_to_le16(cap);
2834 memcpy(pos, &tmp, sizeof(u16));
2835 pos += sizeof(u16);
2836
2837
2838 *pos++ = ht_cap->ampdu_factor |
2839 (ht_cap->ampdu_density <<
2840 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
2841
2842
2843 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
2844 pos += sizeof(ht_cap->mcs);
2845
2846
2847 pos += sizeof(__le16);
2848
2849
2850 pos += sizeof(__le32);
2851
2852
2853 pos += sizeof(u8);
2854
2855 return pos;
2856}
2857
2858u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2859 u32 cap)
2860{
2861 __le32 tmp;
2862
2863 *pos++ = WLAN_EID_VHT_CAPABILITY;
2864 *pos++ = sizeof(struct ieee80211_vht_cap);
2865 memset(pos, 0, sizeof(struct ieee80211_vht_cap));
2866
2867
2868 tmp = cpu_to_le32(cap);
2869 memcpy(pos, &tmp, sizeof(u32));
2870 pos += sizeof(u32);
2871
2872
2873 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
2874 pos += sizeof(vht_cap->vht_mcs);
2875
2876 return pos;
2877}
2878
2879u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata, u8 iftype)
2880{
2881 const struct ieee80211_sta_he_cap *he_cap;
2882 struct ieee80211_supported_band *sband;
2883 u8 n;
2884
2885 sband = ieee80211_get_sband(sdata);
2886 if (!sband)
2887 return 0;
2888
2889 he_cap = ieee80211_get_he_iftype_cap(sband, iftype);
2890 if (!he_cap)
2891 return 0;
2892
2893 n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2894 return 2 + 1 +
2895 sizeof(he_cap->he_cap_elem) + n +
2896 ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2897 he_cap->he_cap_elem.phy_cap_info);
2898}
2899
2900u8 *ieee80211_ie_build_he_cap(u8 *pos,
2901 const struct ieee80211_sta_he_cap *he_cap,
2902 u8 *end)
2903{
2904 u8 n;
2905 u8 ie_len;
2906 u8 *orig_pos = pos;
2907
2908
2909
2910
2911
2912
2913 if (!he_cap)
2914 return orig_pos;
2915
2916 n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2917 ie_len = 2 + 1 +
2918 sizeof(he_cap->he_cap_elem) + n +
2919 ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2920 he_cap->he_cap_elem.phy_cap_info);
2921
2922 if ((end - pos) < ie_len)
2923 return orig_pos;
2924
2925 *pos++ = WLAN_EID_EXTENSION;
2926 pos++;
2927 *pos++ = WLAN_EID_EXT_HE_CAPABILITY;
2928
2929
2930 memcpy(pos, &he_cap->he_cap_elem, sizeof(he_cap->he_cap_elem));
2931 pos += sizeof(he_cap->he_cap_elem);
2932
2933 memcpy(pos, &he_cap->he_mcs_nss_supp, n);
2934 pos += n;
2935
2936
2937 if ((he_cap->he_cap_elem.phy_cap_info[6] &
2938 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
2939 goto end;
2940
2941
2942
2943
2944
2945 n = hweight8(he_cap->ppe_thres[0] &
2946 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
2947 n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >>
2948 IEEE80211_PPE_THRES_NSS_POS));
2949
2950
2951
2952
2953
2954 n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
2955 n = DIV_ROUND_UP(n, 8);
2956
2957
2958 memcpy(pos, &he_cap->ppe_thres, n);
2959 pos += n;
2960
2961end:
2962 orig_pos[1] = (pos - orig_pos) - 2;
2963 return pos;
2964}
2965
2966void ieee80211_ie_build_he_6ghz_cap(struct ieee80211_sub_if_data *sdata,
2967 struct sk_buff *skb)
2968{
2969 struct ieee80211_supported_band *sband;
2970 const struct ieee80211_sband_iftype_data *iftd;
2971 enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
2972 u8 *pos;
2973 u16 cap;
2974
2975 if (!cfg80211_any_usable_channels(sdata->local->hw.wiphy,
2976 BIT(NL80211_BAND_6GHZ),
2977 IEEE80211_CHAN_NO_HE))
2978 return;
2979
2980 sband = sdata->local->hw.wiphy->bands[NL80211_BAND_6GHZ];
2981
2982 iftd = ieee80211_get_sband_iftype_data(sband, iftype);
2983 if (!iftd)
2984 return;
2985
2986
2987 if (!iftd->he_6ghz_capa.capa)
2988 return;
2989
2990 cap = le16_to_cpu(iftd->he_6ghz_capa.capa);
2991 cap &= ~IEEE80211_HE_6GHZ_CAP_SM_PS;
2992
2993 switch (sdata->smps_mode) {
2994 case IEEE80211_SMPS_AUTOMATIC:
2995 case IEEE80211_SMPS_NUM_MODES:
2996 WARN_ON(1);
2997 fallthrough;
2998 case IEEE80211_SMPS_OFF:
2999 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED,
3000 IEEE80211_HE_6GHZ_CAP_SM_PS);
3001 break;
3002 case IEEE80211_SMPS_STATIC:
3003 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC,
3004 IEEE80211_HE_6GHZ_CAP_SM_PS);
3005 break;
3006 case IEEE80211_SMPS_DYNAMIC:
3007 cap |= u16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC,
3008 IEEE80211_HE_6GHZ_CAP_SM_PS);
3009 break;
3010 }
3011
3012 pos = skb_put(skb, 2 + 1 + sizeof(cap));
3013 ieee80211_write_he_6ghz_cap(pos, cpu_to_le16(cap),
3014 pos + 2 + 1 + sizeof(cap));
3015}
3016
3017u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
3018 const struct cfg80211_chan_def *chandef,
3019 u16 prot_mode, bool rifs_mode)
3020{
3021 struct ieee80211_ht_operation *ht_oper;
3022
3023 *pos++ = WLAN_EID_HT_OPERATION;
3024 *pos++ = sizeof(struct ieee80211_ht_operation);
3025 ht_oper = (struct ieee80211_ht_operation *)pos;
3026 ht_oper->primary_chan = ieee80211_frequency_to_channel(
3027 chandef->chan->center_freq);
3028 switch (chandef->width) {
3029 case NL80211_CHAN_WIDTH_160:
3030 case NL80211_CHAN_WIDTH_80P80:
3031 case NL80211_CHAN_WIDTH_80:
3032 case NL80211_CHAN_WIDTH_40:
3033 if (chandef->center_freq1 > chandef->chan->center_freq)
3034 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3035 else
3036 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3037 break;
3038 default:
3039 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
3040 break;
3041 }
3042 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
3043 chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
3044 chandef->width != NL80211_CHAN_WIDTH_20)
3045 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
3046
3047 if (rifs_mode)
3048 ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
3049
3050 ht_oper->operation_mode = cpu_to_le16(prot_mode);
3051 ht_oper->stbc_param = 0x0000;
3052
3053
3054
3055 memset(&ht_oper->basic_set, 0, 16);
3056 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
3057
3058 return pos + sizeof(struct ieee80211_ht_operation);
3059}
3060
3061void ieee80211_ie_build_wide_bw_cs(u8 *pos,
3062 const struct cfg80211_chan_def *chandef)
3063{
3064 *pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH;
3065 *pos++ = 3;
3066
3067 switch (chandef->width) {
3068 case NL80211_CHAN_WIDTH_80:
3069 *pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
3070 break;
3071 case NL80211_CHAN_WIDTH_160:
3072 *pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
3073 break;
3074 case NL80211_CHAN_WIDTH_80P80:
3075 *pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
3076 break;
3077 default:
3078 *pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
3079 }
3080
3081
3082 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
3083
3084 if (chandef->center_freq2)
3085 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
3086 else
3087 *pos++ = 0;
3088}
3089
3090u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
3091 const struct cfg80211_chan_def *chandef)
3092{
3093 struct ieee80211_vht_operation *vht_oper;
3094
3095 *pos++ = WLAN_EID_VHT_OPERATION;
3096 *pos++ = sizeof(struct ieee80211_vht_operation);
3097 vht_oper = (struct ieee80211_vht_operation *)pos;
3098 vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
3099 chandef->center_freq1);
3100 if (chandef->center_freq2)
3101 vht_oper->center_freq_seg1_idx =
3102 ieee80211_frequency_to_channel(chandef->center_freq2);
3103 else
3104 vht_oper->center_freq_seg1_idx = 0x00;
3105
3106 switch (chandef->width) {
3107 case NL80211_CHAN_WIDTH_160:
3108
3109
3110
3111
3112 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3113 vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
3114 if (chandef->chan->center_freq < chandef->center_freq1)
3115 vht_oper->center_freq_seg0_idx -= 8;
3116 else
3117 vht_oper->center_freq_seg0_idx += 8;
3118 break;
3119 case NL80211_CHAN_WIDTH_80P80:
3120
3121
3122
3123
3124 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3125 break;
3126 case NL80211_CHAN_WIDTH_80:
3127 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
3128 break;
3129 default:
3130 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
3131 break;
3132 }
3133
3134
3135 vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
3136
3137 return pos + sizeof(struct ieee80211_vht_operation);
3138}
3139
3140u8 *ieee80211_ie_build_he_oper(u8 *pos, struct cfg80211_chan_def *chandef)
3141{
3142 struct ieee80211_he_operation *he_oper;
3143 struct ieee80211_he_6ghz_oper *he_6ghz_op;
3144 u32 he_oper_params;
3145 u8 ie_len = 1 + sizeof(struct ieee80211_he_operation);
3146
3147 if (chandef->chan->band == NL80211_BAND_6GHZ)
3148 ie_len += sizeof(struct ieee80211_he_6ghz_oper);
3149
3150 *pos++ = WLAN_EID_EXTENSION;
3151 *pos++ = ie_len;
3152 *pos++ = WLAN_EID_EXT_HE_OPERATION;
3153
3154 he_oper_params = 0;
3155 he_oper_params |= u32_encode_bits(1023,
3156 IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
3157 he_oper_params |= u32_encode_bits(1,
3158 IEEE80211_HE_OPERATION_ER_SU_DISABLE);
3159 he_oper_params |= u32_encode_bits(1,
3160 IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED);
3161 if (chandef->chan->band == NL80211_BAND_6GHZ)
3162 he_oper_params |= u32_encode_bits(1,
3163 IEEE80211_HE_OPERATION_6GHZ_OP_INFO);
3164
3165 he_oper = (struct ieee80211_he_operation *)pos;
3166 he_oper->he_oper_params = cpu_to_le32(he_oper_params);
3167
3168
3169 he_oper->he_mcs_nss_set = cpu_to_le16(0xffff);
3170 pos += sizeof(struct ieee80211_he_operation);
3171
3172 if (chandef->chan->band != NL80211_BAND_6GHZ)
3173 goto out;
3174
3175
3176 he_6ghz_op = (struct ieee80211_he_6ghz_oper *)pos;
3177 he_6ghz_op->minrate = 6;
3178 he_6ghz_op->primary =
3179 ieee80211_frequency_to_channel(chandef->chan->center_freq);
3180 he_6ghz_op->ccfs0 =
3181 ieee80211_frequency_to_channel(chandef->center_freq1);
3182 if (chandef->center_freq2)
3183 he_6ghz_op->ccfs1 =
3184 ieee80211_frequency_to_channel(chandef->center_freq2);
3185 else
3186 he_6ghz_op->ccfs1 = 0;
3187
3188 switch (chandef->width) {
3189 case NL80211_CHAN_WIDTH_160:
3190
3191
3192
3193 he_6ghz_op->control =
3194 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
3195 he_6ghz_op->ccfs1 = he_6ghz_op->ccfs0;
3196 if (chandef->chan->center_freq < chandef->center_freq1)
3197 he_6ghz_op->ccfs0 -= 8;
3198 else
3199 he_6ghz_op->ccfs0 += 8;
3200 fallthrough;
3201 case NL80211_CHAN_WIDTH_80P80:
3202 he_6ghz_op->control =
3203 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
3204 break;
3205 case NL80211_CHAN_WIDTH_80:
3206 he_6ghz_op->control =
3207 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ;
3208 break;
3209 case NL80211_CHAN_WIDTH_40:
3210 he_6ghz_op->control =
3211 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ;
3212 break;
3213 default:
3214 he_6ghz_op->control =
3215 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ;
3216 break;
3217 }
3218
3219 pos += sizeof(struct ieee80211_he_6ghz_oper);
3220
3221out:
3222 return pos;
3223}
3224
3225bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
3226 struct cfg80211_chan_def *chandef)
3227{
3228 enum nl80211_channel_type channel_type;
3229
3230 if (!ht_oper)
3231 return false;
3232
3233 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
3234 case IEEE80211_HT_PARAM_CHA_SEC_NONE:
3235 channel_type = NL80211_CHAN_HT20;
3236 break;
3237 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
3238 channel_type = NL80211_CHAN_HT40PLUS;
3239 break;
3240 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
3241 channel_type = NL80211_CHAN_HT40MINUS;
3242 break;
3243 default:
3244 channel_type = NL80211_CHAN_NO_HT;
3245 return false;
3246 }
3247
3248 cfg80211_chandef_create(chandef, chandef->chan, channel_type);
3249 return true;
3250}
3251
3252bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
3253 const struct ieee80211_vht_operation *oper,
3254 const struct ieee80211_ht_operation *htop,
3255 struct cfg80211_chan_def *chandef)
3256{
3257 struct cfg80211_chan_def new = *chandef;
3258 int cf0, cf1;
3259 int ccfs0, ccfs1, ccfs2;
3260 int ccf0, ccf1;
3261 u32 vht_cap;
3262 bool support_80_80 = false;
3263 bool support_160 = false;
3264 u8 ext_nss_bw_supp = u32_get_bits(vht_cap_info,
3265 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
3266 u8 supp_chwidth = u32_get_bits(vht_cap_info,
3267 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK);
3268
3269 if (!oper || !htop)
3270 return false;
3271
3272 vht_cap = hw->wiphy->bands[chandef->chan->band]->vht_cap.cap;
3273 support_160 = (vht_cap & (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK |
3274 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK));
3275 support_80_80 = ((vht_cap &
3276 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
3277 (vht_cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
3278 vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
3279 ((vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) >>
3280 IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT > 1));
3281 ccfs0 = oper->center_freq_seg0_idx;
3282 ccfs1 = oper->center_freq_seg1_idx;
3283 ccfs2 = (le16_to_cpu(htop->operation_mode) &
3284 IEEE80211_HT_OP_MODE_CCFS2_MASK)
3285 >> IEEE80211_HT_OP_MODE_CCFS2_SHIFT;
3286
3287 ccf0 = ccfs0;
3288
3289
3290 if (!ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW))
3291 ext_nss_bw_supp = 0;
3292
3293
3294
3295
3296
3297
3298
3299 switch ((supp_chwidth << 4) | ext_nss_bw_supp) {
3300 default:
3301 case 0x00:
3302 ccf1 = 0;
3303 support_160 = false;
3304 support_80_80 = false;
3305 break;
3306 case 0x01:
3307 support_80_80 = false;
3308 fallthrough;
3309 case 0x02:
3310 case 0x03:
3311 ccf1 = ccfs2;
3312 break;
3313 case 0x10:
3314 ccf1 = ccfs1;
3315 break;
3316 case 0x11:
3317 case 0x12:
3318 if (!ccfs1)
3319 ccf1 = ccfs2;
3320 else
3321 ccf1 = ccfs1;
3322 break;
3323 case 0x13:
3324 case 0x20:
3325 case 0x23:
3326 ccf1 = ccfs1;
3327 break;
3328 }
3329
3330 cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band);
3331 cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band);
3332
3333 switch (oper->chan_width) {
3334 case IEEE80211_VHT_CHANWIDTH_USE_HT:
3335
3336 break;
3337 case IEEE80211_VHT_CHANWIDTH_80MHZ:
3338 new.width = NL80211_CHAN_WIDTH_80;
3339 new.center_freq1 = cf0;
3340
3341 if (ccf1) {
3342 unsigned int diff;
3343
3344 diff = abs(ccf1 - ccf0);
3345 if ((diff == 8) && support_160) {
3346 new.width = NL80211_CHAN_WIDTH_160;
3347 new.center_freq1 = cf1;
3348 } else if ((diff > 8) && support_80_80) {
3349 new.width = NL80211_CHAN_WIDTH_80P80;
3350 new.center_freq2 = cf1;
3351 }
3352 }
3353 break;
3354 case IEEE80211_VHT_CHANWIDTH_160MHZ:
3355
3356 new.width = NL80211_CHAN_WIDTH_160;
3357 new.center_freq1 = cf0;
3358 break;
3359 case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
3360
3361 new.width = NL80211_CHAN_WIDTH_80P80;
3362 new.center_freq1 = cf0;
3363 new.center_freq2 = cf1;
3364 break;
3365 default:
3366 return false;
3367 }
3368
3369 if (!cfg80211_chandef_valid(&new))
3370 return false;
3371
3372 *chandef = new;
3373 return true;
3374}
3375
3376bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_sub_if_data *sdata,
3377 const struct ieee80211_he_operation *he_oper,
3378 struct cfg80211_chan_def *chandef)
3379{
3380 struct ieee80211_local *local = sdata->local;
3381 struct ieee80211_supported_band *sband;
3382 enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
3383 const struct ieee80211_sta_he_cap *he_cap;
3384 struct cfg80211_chan_def he_chandef = *chandef;
3385 const struct ieee80211_he_6ghz_oper *he_6ghz_oper;
3386 bool support_80_80, support_160;
3387 u8 he_phy_cap;
3388 u32 freq;
3389
3390 if (chandef->chan->band != NL80211_BAND_6GHZ)
3391 return true;
3392
3393 sband = local->hw.wiphy->bands[NL80211_BAND_6GHZ];
3394
3395 he_cap = ieee80211_get_he_iftype_cap(sband, iftype);
3396 if (!he_cap) {
3397 sdata_info(sdata, "Missing iftype sband data/HE cap");
3398 return false;
3399 }
3400
3401 he_phy_cap = he_cap->he_cap_elem.phy_cap_info[0];
3402 support_160 =
3403 he_phy_cap &
3404 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G;
3405 support_80_80 =
3406 he_phy_cap &
3407 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G;
3408
3409 if (!he_oper) {
3410 sdata_info(sdata,
3411 "HE is not advertised on (on %d MHz), expect issues\n",
3412 chandef->chan->center_freq);
3413 return false;
3414 }
3415
3416 he_6ghz_oper = ieee80211_he_6ghz_oper(he_oper);
3417
3418 if (!he_6ghz_oper) {
3419 sdata_info(sdata,
3420 "HE 6GHz operation missing (on %d MHz), expect issues\n",
3421 chandef->chan->center_freq);
3422 return false;
3423 }
3424
3425 freq = ieee80211_channel_to_frequency(he_6ghz_oper->primary,
3426 NL80211_BAND_6GHZ);
3427 he_chandef.chan = ieee80211_get_channel(sdata->local->hw.wiphy, freq);
3428
3429 switch (u8_get_bits(he_6ghz_oper->control,
3430 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH)) {
3431 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ:
3432 he_chandef.width = NL80211_CHAN_WIDTH_20;
3433 break;
3434 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ:
3435 he_chandef.width = NL80211_CHAN_WIDTH_40;
3436 break;
3437 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ:
3438 he_chandef.width = NL80211_CHAN_WIDTH_80;
3439 break;
3440 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ:
3441 he_chandef.width = NL80211_CHAN_WIDTH_80;
3442 if (!he_6ghz_oper->ccfs1)
3443 break;
3444 if (abs(he_6ghz_oper->ccfs1 - he_6ghz_oper->ccfs0) == 8) {
3445 if (support_160)
3446 he_chandef.width = NL80211_CHAN_WIDTH_160;
3447 } else {
3448 if (support_80_80)
3449 he_chandef.width = NL80211_CHAN_WIDTH_80P80;
3450 }
3451 break;
3452 }
3453
3454 if (he_chandef.width == NL80211_CHAN_WIDTH_160) {
3455 he_chandef.center_freq1 =
3456 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3457 NL80211_BAND_6GHZ);
3458 } else {
3459 he_chandef.center_freq1 =
3460 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0,
3461 NL80211_BAND_6GHZ);
3462 if (support_80_80 || support_160)
3463 he_chandef.center_freq2 =
3464 ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3465 NL80211_BAND_6GHZ);
3466 }
3467
3468 if (!cfg80211_chandef_valid(&he_chandef)) {
3469 sdata_info(sdata,
3470 "HE 6GHz operation resulted in invalid chandef: %d MHz/%d/%d MHz/%d MHz\n",
3471 he_chandef.chan ? he_chandef.chan->center_freq : 0,
3472 he_chandef.width,
3473 he_chandef.center_freq1,
3474 he_chandef.center_freq2);
3475 return false;
3476 }
3477
3478 *chandef = he_chandef;
3479
3480 return true;
3481}
3482
3483bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie *oper,
3484 struct cfg80211_chan_def *chandef)
3485{
3486 u32 oper_freq;
3487
3488 if (!oper)
3489 return false;
3490
3491 switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER, oper->ch_width)) {
3492 case IEEE80211_S1G_CHANWIDTH_1MHZ:
3493 chandef->width = NL80211_CHAN_WIDTH_1;
3494 break;
3495 case IEEE80211_S1G_CHANWIDTH_2MHZ:
3496 chandef->width = NL80211_CHAN_WIDTH_2;
3497 break;
3498 case IEEE80211_S1G_CHANWIDTH_4MHZ:
3499 chandef->width = NL80211_CHAN_WIDTH_4;
3500 break;
3501 case IEEE80211_S1G_CHANWIDTH_8MHZ:
3502 chandef->width = NL80211_CHAN_WIDTH_8;
3503 break;
3504 case IEEE80211_S1G_CHANWIDTH_16MHZ:
3505 chandef->width = NL80211_CHAN_WIDTH_16;
3506 break;
3507 default:
3508 return false;
3509 }
3510
3511 oper_freq = ieee80211_channel_to_freq_khz(oper->oper_ch,
3512 NL80211_BAND_S1GHZ);
3513 chandef->center_freq1 = KHZ_TO_MHZ(oper_freq);
3514 chandef->freq1_offset = oper_freq % 1000;
3515
3516 return true;
3517}
3518
3519int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
3520 const struct ieee80211_supported_band *sband,
3521 const u8 *srates, int srates_len, u32 *rates)
3522{
3523 u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
3524 int shift = ieee80211_chandef_get_shift(chandef);
3525 struct ieee80211_rate *br;
3526 int brate, rate, i, j, count = 0;
3527
3528 *rates = 0;
3529
3530 for (i = 0; i < srates_len; i++) {
3531 rate = srates[i] & 0x7f;
3532
3533 for (j = 0; j < sband->n_bitrates; j++) {
3534 br = &sband->bitrates[j];
3535 if ((rate_flags & br->flags) != rate_flags)
3536 continue;
3537
3538 brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
3539 if (brate == rate) {
3540 *rates |= BIT(j);
3541 count++;
3542 break;
3543 }
3544 }
3545 }
3546 return count;
3547}
3548
3549int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
3550 struct sk_buff *skb, bool need_basic,
3551 enum nl80211_band band)
3552{
3553 struct ieee80211_local *local = sdata->local;
3554 struct ieee80211_supported_band *sband;
3555 int rate, shift;
3556 u8 i, rates, *pos;
3557 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
3558 u32 rate_flags;
3559
3560 shift = ieee80211_vif_get_shift(&sdata->vif);
3561 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
3562 sband = local->hw.wiphy->bands[band];
3563 rates = 0;
3564 for (i = 0; i < sband->n_bitrates; i++) {
3565 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3566 continue;
3567 rates++;
3568 }
3569 if (rates > 8)
3570 rates = 8;
3571
3572 if (skb_tailroom(skb) < rates + 2)
3573 return -ENOMEM;
3574
3575 pos = skb_put(skb, rates + 2);
3576 *pos++ = WLAN_EID_SUPP_RATES;
3577 *pos++ = rates;
3578 for (i = 0; i < rates; i++) {
3579 u8 basic = 0;
3580 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3581 continue;
3582
3583 if (need_basic && basic_rates & BIT(i))
3584 basic = 0x80;
3585 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
3586 5 * (1 << shift));
3587 *pos++ = basic | (u8) rate;
3588 }
3589
3590 return 0;
3591}
3592
3593int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
3594 struct sk_buff *skb, bool need_basic,
3595 enum nl80211_band band)
3596{
3597 struct ieee80211_local *local = sdata->local;
3598 struct ieee80211_supported_band *sband;
3599 int rate, shift;
3600 u8 i, exrates, *pos;
3601 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
3602 u32 rate_flags;
3603
3604 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
3605 shift = ieee80211_vif_get_shift(&sdata->vif);
3606
3607 sband = local->hw.wiphy->bands[band];
3608 exrates = 0;
3609 for (i = 0; i < sband->n_bitrates; i++) {
3610 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3611 continue;
3612 exrates++;
3613 }
3614
3615 if (exrates > 8)
3616 exrates -= 8;
3617 else
3618 exrates = 0;
3619
3620 if (skb_tailroom(skb) < exrates + 2)
3621 return -ENOMEM;
3622
3623 if (exrates) {
3624 pos = skb_put(skb, exrates + 2);
3625 *pos++ = WLAN_EID_EXT_SUPP_RATES;
3626 *pos++ = exrates;
3627 for (i = 8; i < sband->n_bitrates; i++) {
3628 u8 basic = 0;
3629 if ((rate_flags & sband->bitrates[i].flags)
3630 != rate_flags)
3631 continue;
3632 if (need_basic && basic_rates & BIT(i))
3633 basic = 0x80;
3634 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
3635 5 * (1 << shift));
3636 *pos++ = basic | (u8) rate;
3637 }
3638 }
3639 return 0;
3640}
3641
3642int ieee80211_ave_rssi(struct ieee80211_vif *vif)
3643{
3644 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3645 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3646
3647 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
3648
3649 return 0;
3650 }
3651 return -ewma_beacon_signal_read(&ifmgd->ave_beacon_signal);
3652}
3653EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
3654
3655u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
3656{
3657 if (!mcs)
3658 return 1;
3659
3660
3661
3662 if (mcs->rx_mask[3])
3663 return 4;
3664 if (mcs->rx_mask[2])
3665 return 3;
3666 if (mcs->rx_mask[1])
3667 return 2;
3668 return 1;
3669}
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
3683 struct ieee80211_rx_status *status,
3684 unsigned int mpdu_len,
3685 unsigned int mpdu_offset)
3686{
3687 u64 ts = status->mactime;
3688 struct rate_info ri;
3689 u16 rate;
3690 u8 n_ltf;
3691
3692 if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
3693 return 0;
3694
3695 memset(&ri, 0, sizeof(ri));
3696
3697 ri.bw = status->bw;
3698
3699
3700 switch (status->encoding) {
3701 case RX_ENC_HE:
3702 ri.flags |= RATE_INFO_FLAGS_HE_MCS;
3703 ri.mcs = status->rate_idx;
3704 ri.nss = status->nss;
3705 ri.he_ru_alloc = status->he_ru;
3706 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3707 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3708
3709
3710
3711
3712
3713 if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3714 mpdu_offset += 2;
3715 ts += 36;
3716
3717
3718
3719
3720
3721
3722
3723
3724 }
3725
3726 break;
3727 case RX_ENC_HT:
3728 ri.mcs = status->rate_idx;
3729 ri.flags |= RATE_INFO_FLAGS_MCS;
3730 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3731 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3732
3733
3734
3735
3736
3737 if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3738 mpdu_offset += 2;
3739 if (status->enc_flags & RX_ENC_FLAG_HT_GF)
3740 ts += 24;
3741 else
3742 ts += 32;
3743
3744
3745
3746
3747
3748 n_ltf = ((ri.mcs >> 3) & 3) + 1;
3749 n_ltf = n_ltf == 3 ? 4 : n_ltf;
3750 ts += n_ltf * 4;
3751 }
3752
3753 break;
3754 case RX_ENC_VHT:
3755 ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
3756 ri.mcs = status->rate_idx;
3757 ri.nss = status->nss;
3758 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3759 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3760
3761
3762
3763
3764
3765 if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3766 mpdu_offset += 2;
3767 ts += 36;
3768
3769
3770
3771
3772 n_ltf = (ri.nss != 1) && (ri.nss % 2) ?
3773 ri.nss + 1 : ri.nss;
3774 ts += 4 * n_ltf;
3775 }
3776
3777 break;
3778 default:
3779 WARN_ON(1);
3780 fallthrough;
3781 case RX_ENC_LEGACY: {
3782 struct ieee80211_supported_band *sband;
3783 int shift = 0;
3784 int bitrate;
3785
3786 switch (status->bw) {
3787 case RATE_INFO_BW_10:
3788 shift = 1;
3789 break;
3790 case RATE_INFO_BW_5:
3791 shift = 2;
3792 break;
3793 }
3794
3795 sband = local->hw.wiphy->bands[status->band];
3796 bitrate = sband->bitrates[status->rate_idx].bitrate;
3797 ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
3798
3799 if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
3800 if (status->band == NL80211_BAND_5GHZ) {
3801 ts += 20 << shift;
3802 mpdu_offset += 2;
3803 } else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
3804 ts += 96;
3805 } else {
3806 ts += 192;
3807 }
3808 }
3809 break;
3810 }
3811 }
3812
3813 rate = cfg80211_calculate_bitrate(&ri);
3814 if (WARN_ONCE(!rate,
3815 "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
3816 (unsigned long long)status->flag, status->rate_idx,
3817 status->nss))
3818 return 0;
3819
3820
3821 if (status->flag & RX_FLAG_MACTIME_END)
3822 ts -= mpdu_len * 8 * 10 / rate;
3823
3824 ts += mpdu_offset * 8 * 10 / rate;
3825
3826 return ts;
3827}
3828
3829void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
3830{
3831 struct ieee80211_sub_if_data *sdata;
3832 struct cfg80211_chan_def chandef;
3833
3834
3835 lockdep_assert_wiphy(local->hw.wiphy);
3836
3837 mutex_lock(&local->mtx);
3838 list_for_each_entry(sdata, &local->interfaces, list) {
3839
3840
3841
3842
3843 cancel_delayed_work(&sdata->dfs_cac_timer_work);
3844
3845 if (sdata->wdev.cac_started) {
3846 chandef = sdata->vif.bss_conf.chandef;
3847 ieee80211_vif_release_channel(sdata);
3848 cfg80211_cac_event(sdata->dev,
3849 &chandef,
3850 NL80211_RADAR_CAC_ABORTED,
3851 GFP_KERNEL);
3852 }
3853 }
3854 mutex_unlock(&local->mtx);
3855}
3856
3857void ieee80211_dfs_radar_detected_work(struct work_struct *work)
3858{
3859 struct ieee80211_local *local =
3860 container_of(work, struct ieee80211_local, radar_detected_work);
3861 struct cfg80211_chan_def chandef = local->hw.conf.chandef;
3862 struct ieee80211_chanctx *ctx;
3863 int num_chanctx = 0;
3864
3865 mutex_lock(&local->chanctx_mtx);
3866 list_for_each_entry(ctx, &local->chanctx_list, list) {
3867 if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3868 continue;
3869
3870 num_chanctx++;
3871 chandef = ctx->conf.def;
3872 }
3873 mutex_unlock(&local->chanctx_mtx);
3874
3875 wiphy_lock(local->hw.wiphy);
3876 ieee80211_dfs_cac_cancel(local);
3877 wiphy_unlock(local->hw.wiphy);
3878
3879 if (num_chanctx > 1)
3880
3881 WARN_ON(1);
3882 else
3883 cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
3884}
3885
3886void ieee80211_radar_detected(struct ieee80211_hw *hw)
3887{
3888 struct ieee80211_local *local = hw_to_local(hw);
3889
3890 trace_api_radar_detected(local);
3891
3892 schedule_work(&local->radar_detected_work);
3893}
3894EXPORT_SYMBOL(ieee80211_radar_detected);
3895
3896u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
3897{
3898 u32 ret;
3899 int tmp;
3900
3901 switch (c->width) {
3902 case NL80211_CHAN_WIDTH_20:
3903 c->width = NL80211_CHAN_WIDTH_20_NOHT;
3904 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3905 break;
3906 case NL80211_CHAN_WIDTH_40:
3907 c->width = NL80211_CHAN_WIDTH_20;
3908 c->center_freq1 = c->chan->center_freq;
3909 ret = IEEE80211_STA_DISABLE_40MHZ |
3910 IEEE80211_STA_DISABLE_VHT;
3911 break;
3912 case NL80211_CHAN_WIDTH_80:
3913 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
3914
3915 tmp /= 2;
3916
3917 c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
3918 c->width = NL80211_CHAN_WIDTH_40;
3919 ret = IEEE80211_STA_DISABLE_VHT;
3920 break;
3921 case NL80211_CHAN_WIDTH_80P80:
3922 c->center_freq2 = 0;
3923 c->width = NL80211_CHAN_WIDTH_80;
3924 ret = IEEE80211_STA_DISABLE_80P80MHZ |
3925 IEEE80211_STA_DISABLE_160MHZ;
3926 break;
3927 case NL80211_CHAN_WIDTH_160:
3928
3929 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
3930
3931 tmp /= 4;
3932 c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
3933 c->width = NL80211_CHAN_WIDTH_80;
3934 ret = IEEE80211_STA_DISABLE_80P80MHZ |
3935 IEEE80211_STA_DISABLE_160MHZ;
3936 break;
3937 default:
3938 case NL80211_CHAN_WIDTH_20_NOHT:
3939 WARN_ON_ONCE(1);
3940 c->width = NL80211_CHAN_WIDTH_20_NOHT;
3941 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3942 break;
3943 case NL80211_CHAN_WIDTH_1:
3944 case NL80211_CHAN_WIDTH_2:
3945 case NL80211_CHAN_WIDTH_4:
3946 case NL80211_CHAN_WIDTH_8:
3947 case NL80211_CHAN_WIDTH_16:
3948 case NL80211_CHAN_WIDTH_5:
3949 case NL80211_CHAN_WIDTH_10:
3950 WARN_ON_ONCE(1);
3951
3952 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
3953 break;
3954 }
3955
3956 WARN_ON_ONCE(!cfg80211_chandef_valid(c));
3957
3958 return ret;
3959}
3960
3961
3962
3963
3964
3965bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
3966 enum ieee80211_smps_mode smps_mode_new)
3967{
3968 if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
3969 smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
3970 return false;
3971
3972 switch (smps_mode_old) {
3973 case IEEE80211_SMPS_STATIC:
3974 return false;
3975 case IEEE80211_SMPS_DYNAMIC:
3976 return smps_mode_new == IEEE80211_SMPS_STATIC;
3977 case IEEE80211_SMPS_OFF:
3978 return smps_mode_new != IEEE80211_SMPS_OFF;
3979 default:
3980 WARN_ON(1);
3981 }
3982
3983 return false;
3984}
3985
3986int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
3987 struct cfg80211_csa_settings *csa_settings)
3988{
3989 struct sk_buff *skb;
3990 struct ieee80211_mgmt *mgmt;
3991 struct ieee80211_local *local = sdata->local;
3992 int freq;
3993 int hdr_len = offsetofend(struct ieee80211_mgmt,
3994 u.action.u.chan_switch);
3995 u8 *pos;
3996
3997 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3998 sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3999 return -EOPNOTSUPP;
4000
4001 skb = dev_alloc_skb(local->tx_headroom + hdr_len +
4002 5 +
4003 3 +
4004 5 +
4005 8);
4006 if (!skb)
4007 return -ENOMEM;
4008
4009 skb_reserve(skb, local->tx_headroom);
4010 mgmt = skb_put_zero(skb, hdr_len);
4011 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
4012 IEEE80211_STYPE_ACTION);
4013
4014 eth_broadcast_addr(mgmt->da);
4015 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
4016 if (ieee80211_vif_is_mesh(&sdata->vif)) {
4017 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
4018 } else {
4019 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
4020 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
4021 }
4022 mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
4023 mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
4024 pos = skb_put(skb, 5);
4025 *pos++ = WLAN_EID_CHANNEL_SWITCH;
4026 *pos++ = 3;
4027 *pos++ = csa_settings->block_tx ? 1 : 0;
4028 freq = csa_settings->chandef.chan->center_freq;
4029 *pos++ = ieee80211_frequency_to_channel(freq);
4030 *pos++ = csa_settings->count;
4031
4032 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
4033 enum nl80211_channel_type ch_type;
4034
4035 skb_put(skb, 3);
4036 *pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;
4037 *pos++ = 1;
4038 ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
4039 if (ch_type == NL80211_CHAN_HT40PLUS)
4040 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
4041 else
4042 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
4043 }
4044
4045 if (ieee80211_vif_is_mesh(&sdata->vif)) {
4046 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
4047
4048 skb_put(skb, 8);
4049 *pos++ = WLAN_EID_CHAN_SWITCH_PARAM;
4050 *pos++ = 6;
4051 *pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL;
4052 *pos = 0x00;
4053 *pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
4054 *pos++ |= csa_settings->block_tx ?
4055 WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
4056 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos);
4057 pos += 2;
4058 put_unaligned_le16(ifmsh->pre_value, pos);
4059 pos += 2;
4060 }
4061
4062 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
4063 csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
4064 csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
4065 skb_put(skb, 5);
4066 ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
4067 }
4068
4069 ieee80211_tx_skb(sdata, skb);
4070 return 0;
4071}
4072
4073bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
4074{
4075 return !(cs == NULL || cs->cipher == 0 ||
4076 cs->hdr_len < cs->pn_len + cs->pn_off ||
4077 cs->hdr_len <= cs->key_idx_off ||
4078 cs->key_idx_shift > 7 ||
4079 cs->key_idx_mask == 0);
4080}
4081
4082bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
4083{
4084 int i;
4085
4086
4087 WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
4088
4089 for (i = 0; i < n; i++)
4090 if (!ieee80211_cs_valid(&cs[i]))
4091 return false;
4092
4093 return true;
4094}
4095
4096const struct ieee80211_cipher_scheme *
4097ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
4098 enum nl80211_iftype iftype)
4099{
4100 const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
4101 int n = local->hw.n_cipher_schemes;
4102 int i;
4103 const struct ieee80211_cipher_scheme *cs = NULL;
4104
4105 for (i = 0; i < n; i++) {
4106 if (l[i].cipher == cipher) {
4107 cs = &l[i];
4108 break;
4109 }
4110 }
4111
4112 if (!cs || !(cs->iftype & BIT(iftype)))
4113 return NULL;
4114
4115 return cs;
4116}
4117
4118int ieee80211_cs_headroom(struct ieee80211_local *local,
4119 struct cfg80211_crypto_settings *crypto,
4120 enum nl80211_iftype iftype)
4121{
4122 const struct ieee80211_cipher_scheme *cs;
4123 int headroom = IEEE80211_ENCRYPT_HEADROOM;
4124 int i;
4125
4126 for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
4127 cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
4128 iftype);
4129
4130 if (cs && headroom < cs->hdr_len)
4131 headroom = cs->hdr_len;
4132 }
4133
4134 cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
4135 if (cs && headroom < cs->hdr_len)
4136 headroom = cs->hdr_len;
4137
4138 return headroom;
4139}
4140
4141static bool
4142ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
4143{
4144 s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
4145 int skip;
4146
4147 if (end > 0)
4148 return false;
4149
4150
4151 if (data->count[i] == 1)
4152 return false;
4153
4154 if (data->desc[i].interval == 0)
4155 return false;
4156
4157
4158 skip = DIV_ROUND_UP(-end, data->desc[i].interval);
4159 if (data->count[i] < 255) {
4160 if (data->count[i] <= skip) {
4161 data->count[i] = 0;
4162 return false;
4163 }
4164
4165 data->count[i] -= skip;
4166 }
4167
4168 data->desc[i].start += skip * data->desc[i].interval;
4169
4170 return true;
4171}
4172
4173static bool
4174ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
4175 s32 *offset)
4176{
4177 bool ret = false;
4178 int i;
4179
4180 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4181 s32 cur;
4182
4183 if (!data->count[i])
4184 continue;
4185
4186 if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
4187 ret = true;
4188
4189 cur = data->desc[i].start - tsf;
4190 if (cur > *offset)
4191 continue;
4192
4193 cur = data->desc[i].start + data->desc[i].duration - tsf;
4194 if (cur > *offset)
4195 *offset = cur;
4196 }
4197
4198 return ret;
4199}
4200
4201static u32
4202ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
4203{
4204 s32 offset = 0;
4205 int tries = 0;
4206
4207
4208
4209
4210 int max_tries = 5;
4211
4212 ieee80211_extend_absent_time(data, tsf, &offset);
4213 do {
4214 if (!ieee80211_extend_absent_time(data, tsf, &offset))
4215 break;
4216
4217 tries++;
4218 } while (tries < max_tries);
4219
4220 return offset;
4221}
4222
4223void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
4224{
4225 u32 next_offset = BIT(31) - 1;
4226 int i;
4227
4228 data->absent = 0;
4229 data->has_next_tsf = false;
4230 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4231 s32 start;
4232
4233 if (!data->count[i])
4234 continue;
4235
4236 ieee80211_extend_noa_desc(data, tsf, i);
4237 start = data->desc[i].start - tsf;
4238 if (start <= 0)
4239 data->absent |= BIT(i);
4240
4241 if (next_offset > start)
4242 next_offset = start;
4243
4244 data->has_next_tsf = true;
4245 }
4246
4247 if (data->absent)
4248 next_offset = ieee80211_get_noa_absent_time(data, tsf);
4249
4250 data->next_tsf = tsf + next_offset;
4251}
4252EXPORT_SYMBOL(ieee80211_update_p2p_noa);
4253
4254int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
4255 struct ieee80211_noa_data *data, u32 tsf)
4256{
4257 int ret = 0;
4258 int i;
4259
4260 memset(data, 0, sizeof(*data));
4261
4262 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
4263 const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
4264
4265 if (!desc->count || !desc->duration)
4266 continue;
4267
4268 data->count[i] = desc->count;
4269 data->desc[i].start = le32_to_cpu(desc->start_time);
4270 data->desc[i].duration = le32_to_cpu(desc->duration);
4271 data->desc[i].interval = le32_to_cpu(desc->interval);
4272
4273 if (data->count[i] > 1 &&
4274 data->desc[i].interval < data->desc[i].duration)
4275 continue;
4276
4277 ieee80211_extend_noa_desc(data, tsf, i);
4278 ret++;
4279 }
4280
4281 if (ret)
4282 ieee80211_update_p2p_noa(data, tsf);
4283
4284 return ret;
4285}
4286EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
4287
4288void ieee80211_recalc_dtim(struct ieee80211_local *local,
4289 struct ieee80211_sub_if_data *sdata)
4290{
4291 u64 tsf = drv_get_tsf(local, sdata);
4292 u64 dtim_count = 0;
4293 u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
4294 u8 dtim_period = sdata->vif.bss_conf.dtim_period;
4295 struct ps_data *ps;
4296 u8 bcns_from_dtim;
4297
4298 if (tsf == -1ULL || !beacon_int || !dtim_period)
4299 return;
4300
4301 if (sdata->vif.type == NL80211_IFTYPE_AP ||
4302 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
4303 if (!sdata->bss)
4304 return;
4305
4306 ps = &sdata->bss->ps;
4307 } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
4308 ps = &sdata->u.mesh.ps;
4309 } else {
4310 return;
4311 }
4312
4313
4314
4315
4316
4317
4318 do_div(tsf, beacon_int);
4319 bcns_from_dtim = do_div(tsf, dtim_period);
4320
4321 if (!bcns_from_dtim)
4322 dtim_count = 0;
4323 else
4324 dtim_count = dtim_period - bcns_from_dtim;
4325
4326 ps->dtim_count = dtim_count;
4327}
4328
4329static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
4330 struct ieee80211_chanctx *ctx)
4331{
4332 struct ieee80211_sub_if_data *sdata;
4333 u8 radar_detect = 0;
4334
4335 lockdep_assert_held(&local->chanctx_mtx);
4336
4337 if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
4338 return 0;
4339
4340 list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
4341 if (sdata->reserved_radar_required)
4342 radar_detect |= BIT(sdata->reserved_chandef.width);
4343
4344
4345
4346
4347
4348 WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
4349 !list_empty(&ctx->assigned_vifs));
4350
4351 list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
4352 if (sdata->radar_required)
4353 radar_detect |= BIT(sdata->vif.bss_conf.chandef.width);
4354
4355 return radar_detect;
4356}
4357
4358int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
4359 const struct cfg80211_chan_def *chandef,
4360 enum ieee80211_chanctx_mode chanmode,
4361 u8 radar_detect)
4362{
4363 struct ieee80211_local *local = sdata->local;
4364 struct ieee80211_sub_if_data *sdata_iter;
4365 enum nl80211_iftype iftype = sdata->wdev.iftype;
4366 struct ieee80211_chanctx *ctx;
4367 int total = 1;
4368 struct iface_combination_params params = {
4369 .radar_detect = radar_detect,
4370 };
4371
4372 lockdep_assert_held(&local->chanctx_mtx);
4373
4374 if (WARN_ON(hweight32(radar_detect) > 1))
4375 return -EINVAL;
4376
4377 if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4378 !chandef->chan))
4379 return -EINVAL;
4380
4381 if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
4382 return -EINVAL;
4383
4384 if (sdata->vif.type == NL80211_IFTYPE_AP ||
4385 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
4386
4387
4388
4389
4390
4391 params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
4392 }
4393
4394
4395 if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) {
4396 if (radar_detect)
4397 return -EINVAL;
4398 return 0;
4399 }
4400
4401 if (chandef)
4402 params.num_different_channels = 1;
4403
4404 if (iftype != NL80211_IFTYPE_UNSPECIFIED)
4405 params.iftype_num[iftype] = 1;
4406
4407 list_for_each_entry(ctx, &local->chanctx_list, list) {
4408 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4409 continue;
4410 params.radar_detect |=
4411 ieee80211_chanctx_radar_detect(local, ctx);
4412 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
4413 params.num_different_channels++;
4414 continue;
4415 }
4416 if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4417 cfg80211_chandef_compatible(chandef,
4418 &ctx->conf.def))
4419 continue;
4420 params.num_different_channels++;
4421 }
4422
4423 list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
4424 struct wireless_dev *wdev_iter;
4425
4426 wdev_iter = &sdata_iter->wdev;
4427
4428 if (sdata_iter == sdata ||
4429 !ieee80211_sdata_running(sdata_iter) ||
4430 cfg80211_iftype_allowed(local->hw.wiphy,
4431 wdev_iter->iftype, 0, 1))
4432 continue;
4433
4434 params.iftype_num[wdev_iter->iftype]++;
4435 total++;
4436 }
4437
4438 if (total == 1 && !params.radar_detect)
4439 return 0;
4440
4441 return cfg80211_check_combinations(local->hw.wiphy, ¶ms);
4442}
4443
4444static void
4445ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
4446 void *data)
4447{
4448 u32 *max_num_different_channels = data;
4449
4450 *max_num_different_channels = max(*max_num_different_channels,
4451 c->num_different_channels);
4452}
4453
4454int ieee80211_max_num_channels(struct ieee80211_local *local)
4455{
4456 struct ieee80211_sub_if_data *sdata;
4457 struct ieee80211_chanctx *ctx;
4458 u32 max_num_different_channels = 1;
4459 int err;
4460 struct iface_combination_params params = {0};
4461
4462 lockdep_assert_held(&local->chanctx_mtx);
4463
4464 list_for_each_entry(ctx, &local->chanctx_list, list) {
4465 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4466 continue;
4467
4468 params.num_different_channels++;
4469
4470 params.radar_detect |=
4471 ieee80211_chanctx_radar_detect(local, ctx);
4472 }
4473
4474 list_for_each_entry_rcu(sdata, &local->interfaces, list)
4475 params.iftype_num[sdata->wdev.iftype]++;
4476
4477 err = cfg80211_iter_combinations(local->hw.wiphy, ¶ms,
4478 ieee80211_iter_max_chans,
4479 &max_num_different_channels);
4480 if (err < 0)
4481 return err;
4482
4483 return max_num_different_channels;
4484}
4485
4486void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata,
4487 struct ieee80211_sta_s1g_cap *caps,
4488 struct sk_buff *skb)
4489{
4490 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
4491 struct ieee80211_s1g_cap s1g_capab;
4492 u8 *pos;
4493 int i;
4494
4495 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
4496 return;
4497
4498 if (!caps->s1g)
4499 return;
4500
4501 memcpy(s1g_capab.capab_info, caps->cap, sizeof(caps->cap));
4502 memcpy(s1g_capab.supp_mcs_nss, caps->nss_mcs, sizeof(caps->nss_mcs));
4503
4504
4505 for (i = 0; i < sizeof(ifmgd->s1g_capa.capab_info); i++) {
4506 u8 mask = ifmgd->s1g_capa_mask.capab_info[i];
4507
4508 s1g_capab.capab_info[i] &= ~mask;
4509 s1g_capab.capab_info[i] |= ifmgd->s1g_capa.capab_info[i] & mask;
4510 }
4511
4512
4513 for (i = 0; i < sizeof(ifmgd->s1g_capa.supp_mcs_nss); i++) {
4514 u8 mask = ifmgd->s1g_capa_mask.supp_mcs_nss[i];
4515
4516 s1g_capab.supp_mcs_nss[i] &= ~mask;
4517 s1g_capab.supp_mcs_nss[i] |=
4518 ifmgd->s1g_capa.supp_mcs_nss[i] & mask;
4519 }
4520
4521 pos = skb_put(skb, 2 + sizeof(s1g_capab));
4522 *pos++ = WLAN_EID_S1G_CAPABILITIES;
4523 *pos++ = sizeof(s1g_capab);
4524
4525 memcpy(pos, &s1g_capab, sizeof(s1g_capab));
4526}
4527
4528void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata,
4529 struct sk_buff *skb)
4530{
4531 u8 *pos = skb_put(skb, 3);
4532
4533 *pos++ = WLAN_EID_AID_REQUEST;
4534 *pos++ = 1;
4535 *pos++ = 0;
4536}
4537
4538u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
4539{
4540 *buf++ = WLAN_EID_VENDOR_SPECIFIC;
4541 *buf++ = 7;
4542 *buf++ = 0x00;
4543 *buf++ = 0x50;
4544 *buf++ = 0xf2;
4545 *buf++ = 2;
4546 *buf++ = 0;
4547 *buf++ = 1;
4548 *buf++ = qosinfo;
4549
4550 return buf;
4551}
4552
4553void ieee80211_txq_get_depth(struct ieee80211_txq *txq,
4554 unsigned long *frame_cnt,
4555 unsigned long *byte_cnt)
4556{
4557 struct txq_info *txqi = to_txq_info(txq);
4558 u32 frag_cnt = 0, frag_bytes = 0;
4559 struct sk_buff *skb;
4560
4561 skb_queue_walk(&txqi->frags, skb) {
4562 frag_cnt++;
4563 frag_bytes += skb->len;
4564 }
4565
4566 if (frame_cnt)
4567 *frame_cnt = txqi->tin.backlog_packets + frag_cnt;
4568
4569 if (byte_cnt)
4570 *byte_cnt = txqi->tin.backlog_bytes + frag_bytes;
4571}
4572EXPORT_SYMBOL(ieee80211_txq_get_depth);
4573
4574const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = {
4575 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO,
4576 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI,
4577 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE,
4578 IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
4579};
4580
4581u16 ieee80211_encode_usf(int listen_interval)
4582{
4583 static const int listen_int_usf[] = { 1, 10, 1000, 10000 };
4584 u16 ui, usf = 0;
4585
4586
4587 while (usf < IEEE80211_MAX_USF) {
4588 if (listen_interval % listen_int_usf[usf + 1])
4589 break;
4590 usf += 1;
4591 }
4592 ui = listen_interval / listen_int_usf[usf];
4593
4594
4595 WARN_ON_ONCE(ui > IEEE80211_MAX_UI);
4596 listen_interval = FIELD_PREP(LISTEN_INT_USF, usf) |
4597 FIELD_PREP(LISTEN_INT_UI, ui);
4598
4599 return (u16) listen_interval;
4600}
4601
