1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2002-2005, Instant802 Networks, Inc.
4 * Copyright 2005-2006, Devicescape Software, Inc.
5 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
6 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
7 * Copyright 2013-2014 Intel Mobile Communications GmbH
8 * Copyright (C) 2015-2017 Intel Deutschland GmbH
9 * Copyright (C) 2018-2021 Intel Corporation
11 * utilities for mac80211
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>
28 #include "ieee80211_i.h"
29 #include "driver-ops.h"
36 /* privid for wiphys to determine whether they belong to us or not */
37 const void *const mac80211_wiphy_privid
= &mac80211_wiphy_privid
;
39 struct ieee80211_hw
*wiphy_to_ieee80211_hw(struct wiphy
*wiphy
)
41 struct ieee80211_local
*local
;
43 local
= wiphy_priv(wiphy
);
46 EXPORT_SYMBOL(wiphy_to_ieee80211_hw
);
48 u8
*ieee80211_get_bssid(struct ieee80211_hdr
*hdr
, size_t len
,
49 enum nl80211_iftype type
)
51 __le16 fc
= hdr
->frame_control
;
53 if (ieee80211_is_data(fc
)) {
54 if (len
< 24) /* drop incorrect hdr len (data) */
57 if (ieee80211_has_a4(fc
))
59 if (ieee80211_has_tods(fc
))
61 if (ieee80211_has_fromds(fc
))
67 if (ieee80211_is_s1g_beacon(fc
)) {
68 struct ieee80211_ext
*ext
= (void *) hdr
;
70 return ext
->u
.s1g_beacon
.sa
;
73 if (ieee80211_is_mgmt(fc
)) {
74 if (len
< 24) /* drop incorrect hdr len (mgmt) */
79 if (ieee80211_is_ctl(fc
)) {
80 if (ieee80211_is_pspoll(fc
))
83 if (ieee80211_is_back_req(fc
)) {
85 case NL80211_IFTYPE_STATION
:
87 case NL80211_IFTYPE_AP
:
88 case NL80211_IFTYPE_AP_VLAN
:
91 break; /* fall through to the return */
98 EXPORT_SYMBOL(ieee80211_get_bssid
);
100 void ieee80211_tx_set_protected(struct ieee80211_tx_data
*tx
)
103 struct ieee80211_hdr
*hdr
;
105 skb_queue_walk(&tx
->skbs
, skb
) {
106 hdr
= (struct ieee80211_hdr
*) skb
->data
;
107 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
111 int ieee80211_frame_duration(enum nl80211_band band
, size_t len
,
112 int rate
, int erp
, int short_preamble
,
117 /* calculate duration (in microseconds, rounded up to next higher
118 * integer if it includes a fractional microsecond) to send frame of
119 * len bytes (does not include FCS) at the given rate. Duration will
122 * rate is in 100 kbps, so divident is multiplied by 10 in the
123 * DIV_ROUND_UP() operations.
125 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
126 * is assumed to be 0 otherwise.
129 if (band
== NL80211_BAND_5GHZ
|| erp
) {
133 * N_DBPS = DATARATE x 4
134 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
135 * (16 = SIGNAL time, 6 = tail bits)
136 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
139 * 802.11a - 18.5.2: aSIFSTime = 16 usec
140 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
141 * signal ext = 6 usec
143 dur
= 16; /* SIFS + signal ext */
144 dur
+= 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
145 dur
+= 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
147 /* IEEE 802.11-2012 18.3.2.4: all values above are:
148 * * times 4 for 5 MHz
149 * * times 2 for 10 MHz
153 /* rates should already consider the channel bandwidth,
154 * don't apply divisor again.
156 dur
+= 4 * DIV_ROUND_UP((16 + 8 * (len
+ 4) + 6) * 10,
157 4 * rate
); /* T_SYM x N_SYM */
160 * 802.11b or 802.11g with 802.11b compatibility:
161 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
162 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
164 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
165 * aSIFSTime = 10 usec
166 * aPreambleLength = 144 usec or 72 usec with short preamble
167 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
169 dur
= 10; /* aSIFSTime = 10 usec */
170 dur
+= short_preamble
? (72 + 24) : (144 + 48);
172 dur
+= DIV_ROUND_UP(8 * (len
+ 4) * 10, rate
);
178 /* Exported duration function for driver use */
179 __le16
ieee80211_generic_frame_duration(struct ieee80211_hw
*hw
,
180 struct ieee80211_vif
*vif
,
181 enum nl80211_band band
,
183 struct ieee80211_rate
*rate
)
185 struct ieee80211_sub_if_data
*sdata
;
188 bool short_preamble
= false;
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
);
199 dur
= ieee80211_frame_duration(band
, frame_len
, rate
->bitrate
, erp
,
200 short_preamble
, shift
);
202 return cpu_to_le16(dur
);
204 EXPORT_SYMBOL(ieee80211_generic_frame_duration
);
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
)
210 struct ieee80211_local
*local
= hw_to_local(hw
);
211 struct ieee80211_rate
*rate
;
212 struct ieee80211_sub_if_data
*sdata
;
214 int erp
, shift
= 0, bitrate
;
216 struct ieee80211_supported_band
*sband
;
218 sband
= local
->hw
.wiphy
->bands
[frame_txctl
->band
];
220 short_preamble
= false;
222 rate
= &sband
->bitrates
[frame_txctl
->control
.rts_cts_rate_idx
];
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
);
233 bitrate
= DIV_ROUND_UP(rate
->bitrate
, 1 << shift
);
236 dur
= ieee80211_frame_duration(sband
->band
, 10, bitrate
,
237 erp
, short_preamble
, shift
);
238 /* Data frame duration */
239 dur
+= ieee80211_frame_duration(sband
->band
, frame_len
, bitrate
,
240 erp
, short_preamble
, shift
);
242 dur
+= ieee80211_frame_duration(sband
->band
, 10, bitrate
,
243 erp
, short_preamble
, shift
);
245 return cpu_to_le16(dur
);
247 EXPORT_SYMBOL(ieee80211_rts_duration
);
249 __le16
ieee80211_ctstoself_duration(struct ieee80211_hw
*hw
,
250 struct ieee80211_vif
*vif
,
252 const struct ieee80211_tx_info
*frame_txctl
)
254 struct ieee80211_local
*local
= hw_to_local(hw
);
255 struct ieee80211_rate
*rate
;
256 struct ieee80211_sub_if_data
*sdata
;
258 int erp
, shift
= 0, bitrate
;
260 struct ieee80211_supported_band
*sband
;
262 sband
= local
->hw
.wiphy
->bands
[frame_txctl
->band
];
264 short_preamble
= false;
266 rate
= &sband
->bitrates
[frame_txctl
->control
.rts_cts_rate_idx
];
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
);
276 bitrate
= DIV_ROUND_UP(rate
->bitrate
, 1 << shift
);
278 /* Data frame duration */
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
)) {
283 dur
+= ieee80211_frame_duration(sband
->band
, 10, bitrate
,
284 erp
, short_preamble
, shift
);
287 return cpu_to_le16(dur
);
289 EXPORT_SYMBOL(ieee80211_ctstoself_duration
);
291 static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data
*sdata
, int ac
)
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
;
302 spin_lock(&fq
->lock
);
304 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
)
305 ps
= &sdata
->bss
->ps
;
307 sdata
->vif
.txqs_stopped
[ac
] = false;
309 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
310 if (sdata
!= sta
->sdata
)
313 for (i
= 0; i
< ARRAY_SIZE(sta
->sta
.txq
); i
++) {
314 struct ieee80211_txq
*txq
= sta
->sta
.txq
[i
];
319 txqi
= to_txq_info(txq
);
324 if (!test_and_clear_bit(IEEE80211_TXQ_STOP_NETIF_TX
,
328 spin_unlock(&fq
->lock
);
329 drv_wake_tx_queue(local
, txqi
);
330 spin_lock(&fq
->lock
);
337 txqi
= to_txq_info(vif
->txq
);
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
)
343 spin_unlock(&fq
->lock
);
345 drv_wake_tx_queue(local
, txqi
);
349 spin_unlock(&fq
->lock
);
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
)
358 struct ieee80211_sub_if_data
*sdata
;
359 int n_acs
= IEEE80211_NUM_ACS
;
364 if (local
->hw
.queues
< IEEE80211_NUM_ACS
)
367 for (i
= 0; i
< local
->hw
.queues
; i
++) {
368 if (local
->queue_stop_reasons
[i
])
371 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, *flags
);
372 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
375 for (ac
= 0; ac
< n_acs
; ac
++) {
376 int ac_queue
= sdata
->vif
.hw_queue
[ac
];
379 sdata
->vif
.cab_queue
== i
)
380 __ieee80211_wake_txqs(sdata
, ac
);
383 spin_lock_irqsave(&local
->queue_stop_reason_lock
, *flags
);
389 void ieee80211_wake_txqs(struct tasklet_struct
*t
)
391 struct ieee80211_local
*local
= from_tasklet(local
, t
,
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
);
400 void ieee80211_propagate_queue_wake(struct ieee80211_local
*local
, int queue
)
402 struct ieee80211_sub_if_data
*sdata
;
403 int n_acs
= IEEE80211_NUM_ACS
;
405 if (local
->ops
->wake_tx_queue
)
408 if (local
->hw
.queues
< IEEE80211_NUM_ACS
)
411 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
417 if (sdata
->vif
.cab_queue
!= IEEE80211_INVAL_HW_QUEUE
&&
418 local
->queue_stop_reasons
[sdata
->vif
.cab_queue
] != 0)
421 for (ac
= 0; ac
< n_acs
; ac
++) {
422 int ac_queue
= sdata
->vif
.hw_queue
[ac
];
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
);
433 static void __ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
,
434 enum queue_stop_reason reason
,
436 unsigned long *flags
)
438 struct ieee80211_local
*local
= hw_to_local(hw
);
440 trace_wake_queue(local
, queue
, reason
);
442 if (WARN_ON(queue
>= hw
->queues
))
445 if (!test_bit(reason
, &local
->queue_stop_reasons
[queue
]))
449 local
->q_stop_reasons
[queue
][reason
] = 0;
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;
456 if (local
->q_stop_reasons
[queue
][reason
] == 0)
457 __clear_bit(reason
, &local
->queue_stop_reasons
[queue
]);
459 if (local
->queue_stop_reasons
[queue
] != 0)
460 /* someone still has this queue stopped */
463 if (skb_queue_empty(&local
->pending
[queue
])) {
465 ieee80211_propagate_queue_wake(local
, queue
);
468 tasklet_schedule(&local
->tx_pending_tasklet
);
471 * Calling _ieee80211_wake_txqs here can be a problem because it may
472 * release queue_stop_reason_lock which has been taken by
473 * __ieee80211_wake_queue's caller. It is certainly not very nice to
474 * release someone's lock, but it is fine because all the callers of
475 * __ieee80211_wake_queue call it right before releasing the lock.
477 if (local
->ops
->wake_tx_queue
) {
478 if (reason
== IEEE80211_QUEUE_STOP_REASON_DRIVER
)
479 tasklet_schedule(&local
->wake_txqs_tasklet
);
481 _ieee80211_wake_txqs(local
, flags
);
485 void ieee80211_wake_queue_by_reason(struct ieee80211_hw
*hw
, int queue
,
486 enum queue_stop_reason reason
,
489 struct ieee80211_local
*local
= hw_to_local(hw
);
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
);
497 void ieee80211_wake_queue(struct ieee80211_hw
*hw
, int queue
)
499 ieee80211_wake_queue_by_reason(hw
, queue
,
500 IEEE80211_QUEUE_STOP_REASON_DRIVER
,
503 EXPORT_SYMBOL(ieee80211_wake_queue
);
505 static void __ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
,
506 enum queue_stop_reason reason
,
509 struct ieee80211_local
*local
= hw_to_local(hw
);
510 struct ieee80211_sub_if_data
*sdata
;
511 int n_acs
= IEEE80211_NUM_ACS
;
513 trace_stop_queue(local
, queue
, reason
);
515 if (WARN_ON(queue
>= hw
->queues
))
519 local
->q_stop_reasons
[queue
][reason
] = 1;
521 local
->q_stop_reasons
[queue
][reason
]++;
523 if (__test_and_set_bit(reason
, &local
->queue_stop_reasons
[queue
]))
526 if (local
->hw
.queues
< IEEE80211_NUM_ACS
)
530 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
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
);
543 spin_lock(&local
->fq
.lock
);
544 sdata
->vif
.txqs_stopped
[ac
] = true;
545 spin_unlock(&local
->fq
.lock
);
552 void ieee80211_stop_queue_by_reason(struct ieee80211_hw
*hw
, int queue
,
553 enum queue_stop_reason reason
,
556 struct ieee80211_local
*local
= hw_to_local(hw
);
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
);
564 void ieee80211_stop_queue(struct ieee80211_hw
*hw
, int queue
)
566 ieee80211_stop_queue_by_reason(hw
, queue
,
567 IEEE80211_QUEUE_STOP_REASON_DRIVER
,
570 EXPORT_SYMBOL(ieee80211_stop_queue
);
572 void ieee80211_add_pending_skb(struct ieee80211_local
*local
,
575 struct ieee80211_hw
*hw
= &local
->hw
;
577 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
578 int queue
= info
->hw_queue
;
580 if (WARN_ON(!info
->control
.vif
)) {
581 ieee80211_free_txskb(&local
->hw
, skb
);
585 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
586 __ieee80211_stop_queue(hw
, queue
, IEEE80211_QUEUE_STOP_REASON_SKB_ADD
,
588 __skb_queue_tail(&local
->pending
[queue
], skb
);
589 __ieee80211_wake_queue(hw
, queue
, IEEE80211_QUEUE_STOP_REASON_SKB_ADD
,
591 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
594 void ieee80211_add_pending_skbs(struct ieee80211_local
*local
,
595 struct sk_buff_head
*skbs
)
597 struct ieee80211_hw
*hw
= &local
->hw
;
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
);
606 if (WARN_ON(!info
->control
.vif
)) {
607 ieee80211_free_txskb(&local
->hw
, skb
);
611 queue
= info
->hw_queue
;
613 __ieee80211_stop_queue(hw
, queue
,
614 IEEE80211_QUEUE_STOP_REASON_SKB_ADD
,
617 __skb_queue_tail(&local
->pending
[queue
], skb
);
620 for (i
= 0; i
< hw
->queues
; i
++)
621 __ieee80211_wake_queue(hw
, i
,
622 IEEE80211_QUEUE_STOP_REASON_SKB_ADD
,
624 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
627 void ieee80211_stop_queues_by_reason(struct ieee80211_hw
*hw
,
628 unsigned long queues
,
629 enum queue_stop_reason reason
,
632 struct ieee80211_local
*local
= hw_to_local(hw
);
636 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
638 for_each_set_bit(i
, &queues
, hw
->queues
)
639 __ieee80211_stop_queue(hw
, i
, reason
, refcounted
);
641 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
644 void ieee80211_stop_queues(struct ieee80211_hw
*hw
)
646 ieee80211_stop_queues_by_reason(hw
, IEEE80211_MAX_QUEUE_MAP
,
647 IEEE80211_QUEUE_STOP_REASON_DRIVER
,
650 EXPORT_SYMBOL(ieee80211_stop_queues
);
652 int ieee80211_queue_stopped(struct ieee80211_hw
*hw
, int queue
)
654 struct ieee80211_local
*local
= hw_to_local(hw
);
658 if (WARN_ON(queue
>= hw
->queues
))
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
);
667 EXPORT_SYMBOL(ieee80211_queue_stopped
);
669 void ieee80211_wake_queues_by_reason(struct ieee80211_hw
*hw
,
670 unsigned long queues
,
671 enum queue_stop_reason reason
,
674 struct ieee80211_local
*local
= hw_to_local(hw
);
678 spin_lock_irqsave(&local
->queue_stop_reason_lock
, flags
);
680 for_each_set_bit(i
, &queues
, hw
->queues
)
681 __ieee80211_wake_queue(hw
, i
, reason
, refcounted
, &flags
);
683 spin_unlock_irqrestore(&local
->queue_stop_reason_lock
, flags
);
686 void ieee80211_wake_queues(struct ieee80211_hw
*hw
)
688 ieee80211_wake_queues_by_reason(hw
, IEEE80211_MAX_QUEUE_MAP
,
689 IEEE80211_QUEUE_STOP_REASON_DRIVER
,
692 EXPORT_SYMBOL(ieee80211_wake_queues
);
695 ieee80211_get_vif_queues(struct ieee80211_local
*local
,
696 struct ieee80211_sub_if_data
*sdata
)
700 if (sdata
&& ieee80211_hw_check(&local
->hw
, QUEUE_CONTROL
)) {
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
);
711 queues
= BIT(local
->hw
.queues
) - 1;
717 void __ieee80211_flush_queues(struct ieee80211_local
*local
,
718 struct ieee80211_sub_if_data
*sdata
,
719 unsigned int queues
, bool drop
)
721 if (!local
->ops
->flush
)
725 * If no queue was set, or if the HW doesn't support
726 * IEEE80211_HW_QUEUE_CONTROL - flush all queues
728 if (!queues
|| !ieee80211_hw_check(&local
->hw
, QUEUE_CONTROL
))
729 queues
= ieee80211_get_vif_queues(local
, sdata
);
731 ieee80211_stop_queues_by_reason(&local
->hw
, queues
,
732 IEEE80211_QUEUE_STOP_REASON_FLUSH
,
735 drv_flush(local
, sdata
, queues
, drop
);
737 ieee80211_wake_queues_by_reason(&local
->hw
, queues
,
738 IEEE80211_QUEUE_STOP_REASON_FLUSH
,
742 void ieee80211_flush_queues(struct ieee80211_local
*local
,
743 struct ieee80211_sub_if_data
*sdata
, bool drop
)
745 __ieee80211_flush_queues(local
, sdata
, 0, drop
);
748 void ieee80211_stop_vif_queues(struct ieee80211_local
*local
,
749 struct ieee80211_sub_if_data
*sdata
,
750 enum queue_stop_reason reason
)
752 ieee80211_stop_queues_by_reason(&local
->hw
,
753 ieee80211_get_vif_queues(local
, sdata
),
757 void ieee80211_wake_vif_queues(struct ieee80211_local
*local
,
758 struct ieee80211_sub_if_data
*sdata
,
759 enum queue_stop_reason reason
)
761 ieee80211_wake_queues_by_reason(&local
->hw
,
762 ieee80211_get_vif_queues(local
, sdata
),
766 static void __iterate_interfaces(struct ieee80211_local
*local
,
768 void (*iterator
)(void *data
, u8
*mac
,
769 struct ieee80211_vif
*vif
),
772 struct ieee80211_sub_if_data
*sdata
;
773 bool active_only
= iter_flags
& IEEE80211_IFACE_ITER_ACTIVE
;
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
))
781 case NL80211_IFTYPE_AP_VLAN
:
786 if (!(iter_flags
& IEEE80211_IFACE_ITER_RESUME_ALL
) &&
787 active_only
&& !(sdata
->flags
& IEEE80211_SDATA_IN_DRIVER
))
789 if ((iter_flags
& IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER
) &&
790 !(sdata
->flags
& IEEE80211_SDATA_IN_DRIVER
))
792 if (ieee80211_sdata_running(sdata
) || !active_only
)
793 iterator(data
, sdata
->vif
.addr
,
797 sdata
= rcu_dereference_check(local
->monitor_sdata
,
798 lockdep_is_held(&local
->iflist_mtx
) ||
799 lockdep_rtnl_is_held());
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
);
806 void ieee80211_iterate_interfaces(
807 struct ieee80211_hw
*hw
, u32 iter_flags
,
808 void (*iterator
)(void *data
, u8
*mac
,
809 struct ieee80211_vif
*vif
),
812 struct ieee80211_local
*local
= hw_to_local(hw
);
814 mutex_lock(&local
->iflist_mtx
);
815 __iterate_interfaces(local
, iter_flags
, iterator
, data
);
816 mutex_unlock(&local
->iflist_mtx
);
818 EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces
);
820 void 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
),
826 struct ieee80211_local
*local
= hw_to_local(hw
);
829 __iterate_interfaces(local
, iter_flags
| IEEE80211_IFACE_ITER_ACTIVE
,
833 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic
);
835 void 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
),
841 struct ieee80211_local
*local
= hw_to_local(hw
);
843 lockdep_assert_wiphy(hw
->wiphy
);
845 __iterate_interfaces(local
, iter_flags
| IEEE80211_IFACE_ITER_ACTIVE
,
848 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx
);
850 static void __iterate_stations(struct ieee80211_local
*local
,
851 void (*iterator
)(void *data
,
852 struct ieee80211_sta
*sta
),
855 struct sta_info
*sta
;
857 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
861 iterator(data
, &sta
->sta
);
865 void ieee80211_iterate_stations_atomic(struct ieee80211_hw
*hw
,
866 void (*iterator
)(void *data
,
867 struct ieee80211_sta
*sta
),
870 struct ieee80211_local
*local
= hw_to_local(hw
);
873 __iterate_stations(local
, iterator
, data
);
876 EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic
);
878 struct ieee80211_vif
*wdev_to_ieee80211_vif(struct wireless_dev
*wdev
)
880 struct ieee80211_sub_if_data
*sdata
= IEEE80211_WDEV_TO_SUB_IF(wdev
);
882 if (!ieee80211_sdata_running(sdata
) ||
883 !(sdata
->flags
& IEEE80211_SDATA_IN_DRIVER
))
887 EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif
);
889 struct wireless_dev
*ieee80211_vif_to_wdev(struct ieee80211_vif
*vif
)
894 return &vif_to_sdata(vif
)->wdev
;
896 EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev
);
899 * Nothing should have been stuffed into the workqueue during
900 * the suspend->resume cycle. Since we can't check each caller
901 * of this function if we are already quiescing / suspended,
902 * check here and don't WARN since this can actually happen when
903 * the rx path (for example) is racing against __ieee80211_suspend
904 * and suspending / quiescing was set after the rx path checked
907 static bool ieee80211_can_queue_work(struct ieee80211_local
*local
)
909 if (local
->quiescing
|| (local
->suspended
&& !local
->resuming
)) {
910 pr_warn("queueing ieee80211 work while going to suspend\n");
917 void ieee80211_queue_work(struct ieee80211_hw
*hw
, struct work_struct
*work
)
919 struct ieee80211_local
*local
= hw_to_local(hw
);
921 if (!ieee80211_can_queue_work(local
))
924 queue_work(local
->workqueue
, work
);
926 EXPORT_SYMBOL(ieee80211_queue_work
);
928 void ieee80211_queue_delayed_work(struct ieee80211_hw
*hw
,
929 struct delayed_work
*dwork
,
932 struct ieee80211_local
*local
= hw_to_local(hw
);
934 if (!ieee80211_can_queue_work(local
))
937 queue_delayed_work(local
->workqueue
, dwork
, delay
);
939 EXPORT_SYMBOL(ieee80211_queue_delayed_work
);
941 static void ieee80211_parse_extension_element(u32
*crc
,
942 const struct element
*elem
,
943 struct ieee802_11_elems
*elems
)
945 const void *data
= elem
->data
+ 1;
946 u8 len
= elem
->datalen
- 1;
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
;
953 *crc
= crc32_be(*crc
, (void *)elem
,
957 case WLAN_EID_EXT_HE_CAPABILITY
:
958 elems
->he_cap
= data
;
959 elems
->he_cap_len
= len
;
961 case WLAN_EID_EXT_HE_OPERATION
:
962 if (len
>= sizeof(*elems
->he_operation
) &&
963 len
>= ieee80211_he_oper_size(data
) - 1) {
965 *crc
= crc32_be(*crc
, (void *)elem
,
967 elems
->he_operation
= data
;
970 case WLAN_EID_EXT_UORA
:
972 elems
->uora_element
= data
;
974 case WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME
:
976 elems
->max_channel_switch_time
= data
;
978 case WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION
:
979 if (len
>= sizeof(*elems
->mbssid_config_ie
))
980 elems
->mbssid_config_ie
= data
;
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
;
987 case WLAN_EID_EXT_HE_6GHZ_CAPA
:
988 if (len
>= sizeof(*elems
->he_6ghz_capa
))
989 elems
->he_6ghz_capa
= data
;
995 _ieee802_11_parse_elems_crc(const u8
*start
, size_t len
, bool action
,
996 struct ieee802_11_elems
*elems
,
998 const struct element
*check_inherit
)
1000 const struct element
*elem
;
1001 bool calc_crc
= filter
!= 0;
1002 DECLARE_BITMAP(seen_elems
, 256);
1005 bitmap_zero(seen_elems
, 256);
1007 for_each_element(elem
, start
, len
) {
1008 bool elem_parse_failed
;
1010 u8 elen
= elem
->datalen
;
1011 const u8
*pos
= elem
->data
;
1013 if (check_inherit
&&
1014 !cfg80211_is_element_inherited(elem
,
1020 case WLAN_EID_SUPP_RATES
:
1021 case WLAN_EID_FH_PARAMS
:
1022 case WLAN_EID_DS_PARAMS
:
1023 case WLAN_EID_CF_PARAMS
:
1025 case WLAN_EID_IBSS_PARAMS
:
1026 case WLAN_EID_CHALLENGE
:
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
:
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
:
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
:
1060 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
1061 * that if the content gets bigger it might be needed more than once
1063 if (test_bit(id
, seen_elems
)) {
1064 elems
->parse_error
= true;
1070 if (calc_crc
&& id
< 64 && (filter
& (1ULL << id
)))
1071 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
1073 elem_parse_failed
= false;
1076 case WLAN_EID_LINK_ID
:
1077 if (elen
+ 2 < sizeof(struct ieee80211_tdls_lnkie
)) {
1078 elem_parse_failed
= true;
1081 elems
->lnk_id
= (void *)(pos
- 2);
1083 case WLAN_EID_CHAN_SWITCH_TIMING
:
1084 if (elen
< sizeof(struct ieee80211_ch_switch_timing
)) {
1085 elem_parse_failed
= true;
1088 elems
->ch_sw_timing
= (void *)pos
;
1090 case WLAN_EID_EXT_CAPABILITY
:
1091 elems
->ext_capab
= pos
;
1092 elems
->ext_capab_len
= elen
;
1096 elems
->ssid_len
= elen
;
1098 case WLAN_EID_SUPP_RATES
:
1099 elems
->supp_rates
= pos
;
1100 elems
->supp_rates_len
= elen
;
1102 case WLAN_EID_DS_PARAMS
:
1104 elems
->ds_params
= pos
;
1106 elem_parse_failed
= true;
1109 if (elen
>= sizeof(struct ieee80211_tim_ie
)) {
1110 elems
->tim
= (void *)pos
;
1111 elems
->tim_len
= elen
;
1113 elem_parse_failed
= true;
1115 case WLAN_EID_CHALLENGE
:
1116 elems
->challenge
= pos
;
1117 elems
->challenge_len
= elen
;
1119 case WLAN_EID_VENDOR_SPECIFIC
:
1120 if (elen
>= 4 && pos
[0] == 0x00 && pos
[1] == 0x50 &&
1122 /* Microsoft OUI (00:50:F2) */
1125 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
1127 if (elen
>= 5 && pos
[3] == 2) {
1128 /* OUI Type 2 - WMM IE */
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
;
1141 elems
->rsn_len
= elen
;
1143 case WLAN_EID_ERP_INFO
:
1145 elems
->erp_info
= pos
;
1147 elem_parse_failed
= true;
1149 case WLAN_EID_EXT_SUPP_RATES
:
1150 elems
->ext_supp_rates
= pos
;
1151 elems
->ext_supp_rates_len
= elen
;
1153 case WLAN_EID_HT_CAPABILITY
:
1154 if (elen
>= sizeof(struct ieee80211_ht_cap
))
1155 elems
->ht_cap_elem
= (void *)pos
;
1157 elem_parse_failed
= true;
1159 case WLAN_EID_HT_OPERATION
:
1160 if (elen
>= sizeof(struct ieee80211_ht_operation
))
1161 elems
->ht_operation
= (void *)pos
;
1163 elem_parse_failed
= true;
1165 case WLAN_EID_VHT_CAPABILITY
:
1166 if (elen
>= sizeof(struct ieee80211_vht_cap
))
1167 elems
->vht_cap_elem
= (void *)pos
;
1169 elem_parse_failed
= true;
1171 case WLAN_EID_VHT_OPERATION
:
1172 if (elen
>= sizeof(struct ieee80211_vht_operation
)) {
1173 elems
->vht_operation
= (void *)pos
;
1175 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
1178 elem_parse_failed
= true;
1180 case WLAN_EID_OPMODE_NOTIF
:
1182 elems
->opmode_notif
= pos
;
1184 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
1187 elem_parse_failed
= true;
1189 case WLAN_EID_MESH_ID
:
1190 elems
->mesh_id
= pos
;
1191 elems
->mesh_id_len
= elen
;
1193 case WLAN_EID_MESH_CONFIG
:
1194 if (elen
>= sizeof(struct ieee80211_meshconf_ie
))
1195 elems
->mesh_config
= (void *)pos
;
1197 elem_parse_failed
= true;
1199 case WLAN_EID_PEER_MGMT
:
1200 elems
->peering
= pos
;
1201 elems
->peering_len
= elen
;
1203 case WLAN_EID_MESH_AWAKE_WINDOW
:
1205 elems
->awake_window
= (void *)pos
;
1209 elems
->preq_len
= elen
;
1213 elems
->prep_len
= elen
;
1217 elems
->perr_len
= elen
;
1220 if (elen
>= sizeof(struct ieee80211_rann_ie
))
1221 elems
->rann
= (void *)pos
;
1223 elem_parse_failed
= true;
1225 case WLAN_EID_CHANNEL_SWITCH
:
1226 if (elen
!= sizeof(struct ieee80211_channel_sw_ie
)) {
1227 elem_parse_failed
= true;
1230 elems
->ch_switch_ie
= (void *)pos
;
1232 case WLAN_EID_EXT_CHANSWITCH_ANN
:
1233 if (elen
!= sizeof(struct ieee80211_ext_chansw_ie
)) {
1234 elem_parse_failed
= true;
1237 elems
->ext_chansw_ie
= (void *)pos
;
1239 case WLAN_EID_SECONDARY_CHANNEL_OFFSET
:
1240 if (elen
!= sizeof(struct ieee80211_sec_chan_offs_ie
)) {
1241 elem_parse_failed
= true;
1244 elems
->sec_chan_offs
= (void *)pos
;
1246 case WLAN_EID_CHAN_SWITCH_PARAM
:
1248 sizeof(*elems
->mesh_chansw_params_ie
)) {
1249 elem_parse_failed
= true;
1252 elems
->mesh_chansw_params_ie
= (void *)pos
;
1254 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH
:
1256 elen
< sizeof(*elems
->wide_bw_chansw_ie
)) {
1257 elem_parse_failed
= true;
1260 elems
->wide_bw_chansw_ie
= (void *)pos
;
1262 case WLAN_EID_CHANNEL_SWITCH_WRAPPER
:
1264 elem_parse_failed
= true;
1268 * This is a bit tricky, but as we only care about
1269 * the wide bandwidth channel switch element, so
1270 * just parse it out manually.
1272 ie
= cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH
,
1275 if (ie
[1] >= sizeof(*elems
->wide_bw_chansw_ie
))
1276 elems
->wide_bw_chansw_ie
=
1279 elem_parse_failed
= true;
1282 case WLAN_EID_COUNTRY
:
1283 elems
->country_elem
= pos
;
1284 elems
->country_elem_len
= elen
;
1286 case WLAN_EID_PWR_CONSTRAINT
:
1288 elem_parse_failed
= true;
1291 elems
->pwr_constr_elem
= pos
;
1293 case WLAN_EID_CISCO_VENDOR_SPECIFIC
:
1294 /* Lots of different options exist, but we only care
1295 * about the Dynamic Transmit Power Control element.
1296 * First check for the Cisco OUI, then for the DTPC
1300 elem_parse_failed
= true;
1304 if (pos
[0] != 0x00 || pos
[1] != 0x40 ||
1305 pos
[2] != 0x96 || pos
[3] != 0x00)
1309 elem_parse_failed
= true;
1314 crc
= crc32_be(crc
, pos
- 2, elen
+ 2);
1316 elems
->cisco_dtpc_elem
= pos
;
1318 case WLAN_EID_ADDBA_EXT
:
1319 if (elen
< sizeof(struct ieee80211_addba_ext_ie
)) {
1320 elem_parse_failed
= true;
1323 elems
->addba_ext_ie
= (void *)pos
;
1325 case WLAN_EID_TIMEOUT_INTERVAL
:
1326 if (elen
>= sizeof(struct ieee80211_timeout_interval_ie
))
1327 elems
->timeout_int
= (void *)pos
;
1329 elem_parse_failed
= true;
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
;
1337 elems
->rsnx_len
= elen
;
1339 case WLAN_EID_EXTENSION
:
1340 ieee80211_parse_extension_element(calc_crc
?
1344 case WLAN_EID_S1G_CAPABILITIES
:
1345 if (elen
>= sizeof(*elems
->s1g_capab
))
1346 elems
->s1g_capab
= (void *)pos
;
1348 elem_parse_failed
= true;
1350 case WLAN_EID_S1G_OPERATION
:
1351 if (elen
== sizeof(*elems
->s1g_oper
))
1352 elems
->s1g_oper
= (void *)pos
;
1354 elem_parse_failed
= true;
1356 case WLAN_EID_S1G_BCN_COMPAT
:
1357 if (elen
== sizeof(*elems
->s1g_bcn_compat
))
1358 elems
->s1g_bcn_compat
= (void *)pos
;
1360 elem_parse_failed
= true;
1362 case WLAN_EID_AID_RESPONSE
:
1363 if (elen
== sizeof(struct ieee80211_aid_response_ie
))
1364 elems
->aid_resp
= (void *)pos
;
1366 elem_parse_failed
= true;
1372 if (elem_parse_failed
)
1373 elems
->parse_error
= true;
1375 __set_bit(id
, seen_elems
);
1378 if (!for_each_element_completed(elem
, start
, len
))
1379 elems
->parse_error
= true;
1384 static size_t ieee802_11_find_bssid_profile(const u8
*start
, size_t len
,
1385 struct ieee802_11_elems
*elems
,
1386 u8
*transmitter_bssid
,
1388 u8
*nontransmitted_profile
)
1390 const struct element
*elem
, *sub
;
1391 size_t profile_len
= 0;
1394 if (!bss_bssid
|| !transmitter_bssid
)
1397 for_each_element_id(elem
, WLAN_EID_MULTIPLE_BSSID
, start
, len
) {
1398 if (elem
->datalen
< 2)
1401 for_each_element(sub
, elem
->data
+ 1, elem
->datalen
- 1) {
1402 u8 new_bssid
[ETH_ALEN
];
1405 if (sub
->id
!= 0 || sub
->datalen
< 4) {
1406 /* not a valid BSS profile */
1410 if (sub
->data
[0] != WLAN_EID_NON_TX_BSSID_CAP
||
1411 sub
->data
[1] != 2) {
1412 /* The first element of the
1413 * Nontransmitted BSSID Profile is not
1414 * the Nontransmitted BSSID Capability
1420 memset(nontransmitted_profile
, 0, len
);
1421 profile_len
= cfg80211_merge_profile(start
, len
,
1424 nontransmitted_profile
,
1427 /* found a Nontransmitted BSSID Profile */
1428 index
= cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX
,
1429 nontransmitted_profile
,
1431 if (!index
|| index
[1] < 1 || index
[2] == 0) {
1432 /* Invalid MBSSID Index element */
1436 cfg80211_gen_new_bssid(transmitter_bssid
,
1440 if (ether_addr_equal(new_bssid
, bss_bssid
)) {
1442 elems
->bssid_index_len
= index
[1];
1443 elems
->bssid_index
= (void *)&index
[2];
1449 return found
? profile_len
: 0;
1452 u32
ieee802_11_parse_elems_crc(const u8
*start
, size_t len
, bool action
,
1453 struct ieee802_11_elems
*elems
,
1454 u64 filter
, u32 crc
, u8
*transmitter_bssid
,
1457 const struct element
*non_inherit
= NULL
;
1458 u8
*nontransmitted_profile
;
1459 int nontransmitted_profile_len
= 0;
1461 memset(elems
, 0, sizeof(*elems
));
1462 elems
->ie_start
= start
;
1463 elems
->total_len
= len
;
1465 nontransmitted_profile
= kmalloc(len
, GFP_ATOMIC
);
1466 if (nontransmitted_profile
) {
1467 nontransmitted_profile_len
=
1468 ieee802_11_find_bssid_profile(start
, len
, elems
,
1471 nontransmitted_profile
);
1473 cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE
,
1474 nontransmitted_profile
,
1475 nontransmitted_profile_len
);
1478 crc
= _ieee802_11_parse_elems_crc(start
, len
, action
, elems
, filter
,
1481 /* Override with nontransmitted profile, if found */
1482 if (nontransmitted_profile_len
)
1483 _ieee802_11_parse_elems_crc(nontransmitted_profile
,
1484 nontransmitted_profile_len
,
1485 action
, elems
, 0, 0, NULL
);
1487 if (elems
->tim
&& !elems
->parse_error
) {
1488 const struct ieee80211_tim_ie
*tim_ie
= elems
->tim
;
1490 elems
->dtim_period
= tim_ie
->dtim_period
;
1491 elems
->dtim_count
= tim_ie
->dtim_count
;
1494 /* Override DTIM period and count if needed */
1495 if (elems
->bssid_index
&&
1496 elems
->bssid_index_len
>=
1497 offsetofend(struct ieee80211_bssid_index
, dtim_period
))
1498 elems
->dtim_period
= elems
->bssid_index
->dtim_period
;
1500 if (elems
->bssid_index
&&
1501 elems
->bssid_index_len
>=
1502 offsetofend(struct ieee80211_bssid_index
, dtim_count
))
1503 elems
->dtim_count
= elems
->bssid_index
->dtim_count
;
1505 kfree(nontransmitted_profile
);
1510 void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data
*sdata
,
1511 struct ieee80211_tx_queue_params
1514 struct ieee80211_chanctx_conf
*chanctx_conf
;
1515 const struct ieee80211_reg_rule
*rrule
;
1516 const struct ieee80211_wmm_ac
*wmm_ac
;
1517 u16 center_freq
= 0;
1519 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP
&&
1520 sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
1524 chanctx_conf
= rcu_dereference(sdata
->vif
.chanctx_conf
);
1526 center_freq
= chanctx_conf
->def
.chan
->center_freq
;
1533 rrule
= freq_reg_info(sdata
->wdev
.wiphy
, MHZ_TO_KHZ(center_freq
));
1535 if (IS_ERR_OR_NULL(rrule
) || !rrule
->has_wmm
) {
1540 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
)
1541 wmm_ac
= &rrule
->wmm_rule
.ap
[ac
];
1543 wmm_ac
= &rrule
->wmm_rule
.client
[ac
];
1544 qparam
->cw_min
= max_t(u16
, qparam
->cw_min
, wmm_ac
->cw_min
);
1545 qparam
->cw_max
= max_t(u16
, qparam
->cw_max
, wmm_ac
->cw_max
);
1546 qparam
->aifs
= max_t(u8
, qparam
->aifs
, wmm_ac
->aifsn
);
1547 qparam
->txop
= min_t(u16
, qparam
->txop
, wmm_ac
->cot
/ 32);
1551 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data
*sdata
,
1552 bool bss_notify
, bool enable_qos
)
1554 struct ieee80211_local
*local
= sdata
->local
;
1555 struct ieee80211_tx_queue_params qparam
;
1556 struct ieee80211_chanctx_conf
*chanctx_conf
;
1559 bool is_ocb
; /* Use another EDCA parameters if dot11OCBActivated=true */
1562 if (!local
->ops
->conf_tx
)
1565 if (local
->hw
.queues
< IEEE80211_NUM_ACS
)
1568 memset(&qparam
, 0, sizeof(qparam
));
1571 chanctx_conf
= rcu_dereference(sdata
->vif
.chanctx_conf
);
1572 use_11b
= (chanctx_conf
&&
1573 chanctx_conf
->def
.chan
->band
== NL80211_BAND_2GHZ
) &&
1574 !(sdata
->flags
& IEEE80211_SDATA_OPERATING_GMODE
);
1577 is_ocb
= (sdata
->vif
.type
== NL80211_IFTYPE_OCB
);
1579 /* Set defaults according to 802.11-2007 Table 7-37 */
1586 /* Confiure old 802.11b/g medium access rules. */
1587 qparam
.cw_max
= aCWmax
;
1588 qparam
.cw_min
= aCWmin
;
1592 for (ac
= 0; ac
< IEEE80211_NUM_ACS
; ac
++) {
1593 /* Update if QoS is enabled. */
1596 case IEEE80211_AC_BK
:
1597 qparam
.cw_max
= aCWmax
;
1598 qparam
.cw_min
= aCWmin
;
1605 /* never happens but let's not leave undefined */
1607 case IEEE80211_AC_BE
:
1608 qparam
.cw_max
= aCWmax
;
1609 qparam
.cw_min
= aCWmin
;
1616 case IEEE80211_AC_VI
:
1617 qparam
.cw_max
= aCWmin
;
1618 qparam
.cw_min
= (aCWmin
+ 1) / 2 - 1;
1622 qparam
.txop
= 6016/32;
1624 qparam
.txop
= 3008/32;
1631 case IEEE80211_AC_VO
:
1632 qparam
.cw_max
= (aCWmin
+ 1) / 2 - 1;
1633 qparam
.cw_min
= (aCWmin
+ 1) / 4 - 1;
1637 qparam
.txop
= 3264/32;
1639 qparam
.txop
= 1504/32;
1644 ieee80211_regulatory_limit_wmm_params(sdata
, &qparam
, ac
);
1646 qparam
.uapsd
= false;
1648 sdata
->tx_conf
[ac
] = qparam
;
1649 drv_conf_tx(local
, sdata
, ac
, &qparam
);
1652 if (sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
&&
1653 sdata
->vif
.type
!= NL80211_IFTYPE_P2P_DEVICE
&&
1654 sdata
->vif
.type
!= NL80211_IFTYPE_NAN
) {
1655 sdata
->vif
.bss_conf
.qos
= enable_qos
;
1657 ieee80211_bss_info_change_notify(sdata
,
1662 void ieee80211_send_auth(struct ieee80211_sub_if_data
*sdata
,
1663 u16 transaction
, u16 auth_alg
, u16 status
,
1664 const u8
*extra
, size_t extra_len
, const u8
*da
,
1665 const u8
*bssid
, const u8
*key
, u8 key_len
, u8 key_idx
,
1668 struct ieee80211_local
*local
= sdata
->local
;
1669 struct sk_buff
*skb
;
1670 struct ieee80211_mgmt
*mgmt
;
1673 /* 24 + 6 = header + auth_algo + auth_transaction + status_code */
1674 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ IEEE80211_WEP_IV_LEN
+
1675 24 + 6 + extra_len
+ IEEE80211_WEP_ICV_LEN
);
1679 skb_reserve(skb
, local
->hw
.extra_tx_headroom
+ IEEE80211_WEP_IV_LEN
);
1681 mgmt
= skb_put_zero(skb
, 24 + 6);
1682 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
1683 IEEE80211_STYPE_AUTH
);
1684 memcpy(mgmt
->da
, da
, ETH_ALEN
);
1685 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
1686 memcpy(mgmt
->bssid
, bssid
, ETH_ALEN
);
1687 mgmt
->u
.auth
.auth_alg
= cpu_to_le16(auth_alg
);
1688 mgmt
->u
.auth
.auth_transaction
= cpu_to_le16(transaction
);
1689 mgmt
->u
.auth
.status_code
= cpu_to_le16(status
);
1691 skb_put_data(skb
, extra
, extra_len
);
1693 if (auth_alg
== WLAN_AUTH_SHARED_KEY
&& transaction
== 3) {
1694 mgmt
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
1695 err
= ieee80211_wep_encrypt(local
, skb
, key
, key_len
, key_idx
);
1702 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
|
1704 ieee80211_tx_skb(sdata
, skb
);
1707 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data
*sdata
,
1708 const u8
*da
, const u8
*bssid
,
1709 u16 stype
, u16 reason
,
1710 bool send_frame
, u8
*frame_buf
)
1712 struct ieee80211_local
*local
= sdata
->local
;
1713 struct sk_buff
*skb
;
1714 struct ieee80211_mgmt
*mgmt
= (void *)frame_buf
;
1717 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
| stype
);
1718 mgmt
->duration
= 0; /* initialize only */
1719 mgmt
->seq_ctrl
= 0; /* initialize only */
1720 memcpy(mgmt
->da
, da
, ETH_ALEN
);
1721 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
1722 memcpy(mgmt
->bssid
, bssid
, ETH_ALEN
);
1723 /* u.deauth.reason_code == u.disassoc.reason_code */
1724 mgmt
->u
.deauth
.reason_code
= cpu_to_le16(reason
);
1727 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
1728 IEEE80211_DEAUTH_FRAME_LEN
);
1732 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
1735 skb_put_data(skb
, mgmt
, IEEE80211_DEAUTH_FRAME_LEN
);
1737 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
||
1738 !(sdata
->u
.mgd
.flags
& IEEE80211_STA_MFP_ENABLED
))
1739 IEEE80211_SKB_CB(skb
)->flags
|=
1740 IEEE80211_TX_INTFL_DONT_ENCRYPT
;
1742 ieee80211_tx_skb(sdata
, skb
);
1746 static u8
*ieee80211_write_he_6ghz_cap(u8
*pos
, __le16 cap
, u8
*end
)
1748 if ((end
- pos
) < 5)
1751 *pos
++ = WLAN_EID_EXTENSION
;
1752 *pos
++ = 1 + sizeof(cap
);
1753 *pos
++ = WLAN_EID_EXT_HE_6GHZ_CAPA
;
1754 memcpy(pos
, &cap
, sizeof(cap
));
1759 static int ieee80211_build_preq_ies_band(struct ieee80211_sub_if_data
*sdata
,
1760 u8
*buffer
, size_t buffer_len
,
1761 const u8
*ie
, size_t ie_len
,
1762 enum nl80211_band band
,
1764 struct cfg80211_chan_def
*chandef
,
1765 size_t *offset
, u32 flags
)
1767 struct ieee80211_local
*local
= sdata
->local
;
1768 struct ieee80211_supported_band
*sband
;
1769 const struct ieee80211_sta_he_cap
*he_cap
;
1770 u8
*pos
= buffer
, *end
= buffer
+ buffer_len
;
1772 int supp_rates_len
, i
;
1778 bool have_80mhz
= false;
1782 sband
= local
->hw
.wiphy
->bands
[band
];
1783 if (WARN_ON_ONCE(!sband
))
1786 rate_flags
= ieee80211_chandef_rate_flags(chandef
);
1787 shift
= ieee80211_chandef_get_shift(chandef
);
1790 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1791 if ((BIT(i
) & rate_mask
) == 0)
1792 continue; /* skip rate */
1793 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
1796 rates
[num_rates
++] =
1797 (u8
) DIV_ROUND_UP(sband
->bitrates
[i
].bitrate
,
1801 supp_rates_len
= min_t(int, num_rates
, 8);
1803 if (end
- pos
< 2 + supp_rates_len
)
1805 *pos
++ = WLAN_EID_SUPP_RATES
;
1806 *pos
++ = supp_rates_len
;
1807 memcpy(pos
, rates
, supp_rates_len
);
1808 pos
+= supp_rates_len
;
1810 /* insert "request information" if in custom IEs */
1812 static const u8 before_extrates
[] = {
1814 WLAN_EID_SUPP_RATES
,
1817 noffset
= ieee80211_ie_split(ie
, ie_len
,
1819 ARRAY_SIZE(before_extrates
),
1821 if (end
- pos
< noffset
- *offset
)
1823 memcpy(pos
, ie
+ *offset
, noffset
- *offset
);
1824 pos
+= noffset
- *offset
;
1828 ext_rates_len
= num_rates
- supp_rates_len
;
1829 if (ext_rates_len
> 0) {
1830 if (end
- pos
< 2 + ext_rates_len
)
1832 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
1833 *pos
++ = ext_rates_len
;
1834 memcpy(pos
, rates
+ supp_rates_len
, ext_rates_len
);
1835 pos
+= ext_rates_len
;
1838 if (chandef
->chan
&& sband
->band
== NL80211_BAND_2GHZ
) {
1841 *pos
++ = WLAN_EID_DS_PARAMS
;
1843 *pos
++ = ieee80211_frequency_to_channel(
1844 chandef
->chan
->center_freq
);
1847 if (flags
& IEEE80211_PROBE_FLAG_MIN_CONTENT
)
1850 /* insert custom IEs that go before HT */
1852 static const u8 before_ht
[] = {
1854 * no need to list the ones split off already
1855 * (or generated here)
1858 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
1860 noffset
= ieee80211_ie_split(ie
, ie_len
,
1861 before_ht
, ARRAY_SIZE(before_ht
),
1863 if (end
- pos
< noffset
- *offset
)
1865 memcpy(pos
, ie
+ *offset
, noffset
- *offset
);
1866 pos
+= noffset
- *offset
;
1870 if (sband
->ht_cap
.ht_supported
) {
1871 if (end
- pos
< 2 + sizeof(struct ieee80211_ht_cap
))
1873 pos
= ieee80211_ie_build_ht_cap(pos
, &sband
->ht_cap
,
1877 /* insert custom IEs that go before VHT */
1879 static const u8 before_vht
[] = {
1881 * no need to list the ones split off already
1882 * (or generated here)
1884 WLAN_EID_BSS_COEX_2040
,
1885 WLAN_EID_EXT_CAPABILITY
,
1887 WLAN_EID_CHANNEL_USAGE
,
1888 WLAN_EID_INTERWORKING
,
1890 /* 60 GHz (Multi-band, DMG, MMS) can't happen */
1892 noffset
= ieee80211_ie_split(ie
, ie_len
,
1893 before_vht
, ARRAY_SIZE(before_vht
),
1895 if (end
- pos
< noffset
- *offset
)
1897 memcpy(pos
, ie
+ *offset
, noffset
- *offset
);
1898 pos
+= noffset
- *offset
;
1902 /* Check if any channel in this sband supports at least 80 MHz */
1903 for (i
= 0; i
< sband
->n_channels
; i
++) {
1904 if (sband
->channels
[i
].flags
& (IEEE80211_CHAN_DISABLED
|
1905 IEEE80211_CHAN_NO_80MHZ
))
1912 if (sband
->vht_cap
.vht_supported
&& have_80mhz
) {
1913 if (end
- pos
< 2 + sizeof(struct ieee80211_vht_cap
))
1915 pos
= ieee80211_ie_build_vht_cap(pos
, &sband
->vht_cap
,
1916 sband
->vht_cap
.cap
);
1919 /* insert custom IEs that go before HE */
1921 static const u8 before_he
[] = {
1923 * no need to list the ones split off before VHT
1926 WLAN_EID_EXTENSION
, WLAN_EID_EXT_FILS_REQ_PARAMS
,
1928 /* TODO: add 11ah/11aj/11ak elements */
1930 noffset
= ieee80211_ie_split(ie
, ie_len
,
1931 before_he
, ARRAY_SIZE(before_he
),
1933 if (end
- pos
< noffset
- *offset
)
1935 memcpy(pos
, ie
+ *offset
, noffset
- *offset
);
1936 pos
+= noffset
- *offset
;
1940 he_cap
= ieee80211_get_he_iftype_cap(sband
,
1941 ieee80211_vif_type_p2p(&sdata
->vif
));
1943 cfg80211_any_usable_channels(local
->hw
.wiphy
, BIT(sband
->band
),
1944 IEEE80211_CHAN_NO_HE
)) {
1945 pos
= ieee80211_ie_build_he_cap(pos
, he_cap
, end
);
1950 if (cfg80211_any_usable_channels(local
->hw
.wiphy
,
1951 BIT(NL80211_BAND_6GHZ
),
1952 IEEE80211_CHAN_NO_HE
)) {
1953 struct ieee80211_supported_band
*sband6
;
1955 sband6
= local
->hw
.wiphy
->bands
[NL80211_BAND_6GHZ
];
1956 he_cap
= ieee80211_get_he_iftype_cap(sband6
,
1957 ieee80211_vif_type_p2p(&sdata
->vif
));
1960 enum nl80211_iftype iftype
=
1961 ieee80211_vif_type_p2p(&sdata
->vif
);
1962 __le16 cap
= ieee80211_get_he_6ghz_capa(sband
, iftype
);
1964 pos
= ieee80211_write_he_6ghz_cap(pos
, cap
, end
);
1969 * If adding more here, adjust code in main.c
1970 * that calculates local->scan_ies_len.
1973 return pos
- buffer
;
1975 WARN_ONCE(1, "not enough space for preq IEs\n");
1977 return pos
- buffer
;
1980 int ieee80211_build_preq_ies(struct ieee80211_sub_if_data
*sdata
, u8
*buffer
,
1982 struct ieee80211_scan_ies
*ie_desc
,
1983 const u8
*ie
, size_t ie_len
,
1984 u8 bands_used
, u32
*rate_masks
,
1985 struct cfg80211_chan_def
*chandef
,
1988 size_t pos
= 0, old_pos
= 0, custom_ie_offset
= 0;
1991 memset(ie_desc
, 0, sizeof(*ie_desc
));
1993 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++) {
1994 if (bands_used
& BIT(i
)) {
1995 pos
+= ieee80211_build_preq_ies_band(sdata
,
2003 ie_desc
->ies
[i
] = buffer
+ old_pos
;
2004 ie_desc
->len
[i
] = pos
- old_pos
;
2009 /* add any remaining custom IEs */
2011 if (WARN_ONCE(buffer_len
- pos
< ie_len
- custom_ie_offset
,
2012 "not enough space for preq custom IEs\n"))
2014 memcpy(buffer
+ pos
, ie
+ custom_ie_offset
,
2015 ie_len
- custom_ie_offset
);
2016 ie_desc
->common_ies
= buffer
+ pos
;
2017 ie_desc
->common_ie_len
= ie_len
- custom_ie_offset
;
2018 pos
+= ie_len
- custom_ie_offset
;
2024 struct sk_buff
*ieee80211_build_probe_req(struct ieee80211_sub_if_data
*sdata
,
2025 const u8
*src
, const u8
*dst
,
2027 struct ieee80211_channel
*chan
,
2028 const u8
*ssid
, size_t ssid_len
,
2029 const u8
*ie
, size_t ie_len
,
2032 struct ieee80211_local
*local
= sdata
->local
;
2033 struct cfg80211_chan_def chandef
;
2034 struct sk_buff
*skb
;
2035 struct ieee80211_mgmt
*mgmt
;
2037 u32 rate_masks
[NUM_NL80211_BANDS
] = {};
2038 struct ieee80211_scan_ies dummy_ie_desc
;
2041 * Do not send DS Channel parameter for directed probe requests
2042 * in order to maximize the chance that we get a response. Some
2043 * badly-behaved APs don't respond when this parameter is included.
2045 chandef
.width
= sdata
->vif
.bss_conf
.chandef
.width
;
2046 if (flags
& IEEE80211_PROBE_FLAG_DIRECTED
)
2047 chandef
.chan
= NULL
;
2049 chandef
.chan
= chan
;
2051 skb
= ieee80211_probereq_get(&local
->hw
, src
, ssid
, ssid_len
,
2056 rate_masks
[chan
->band
] = ratemask
;
2057 ies_len
= ieee80211_build_preq_ies(sdata
, skb_tail_pointer(skb
),
2058 skb_tailroom(skb
), &dummy_ie_desc
,
2059 ie
, ie_len
, BIT(chan
->band
),
2060 rate_masks
, &chandef
, flags
);
2061 skb_put(skb
, ies_len
);
2064 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
2065 memcpy(mgmt
->da
, dst
, ETH_ALEN
);
2066 memcpy(mgmt
->bssid
, dst
, ETH_ALEN
);
2069 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
2074 u32
ieee80211_sta_get_rates(struct ieee80211_sub_if_data
*sdata
,
2075 struct ieee802_11_elems
*elems
,
2076 enum nl80211_band band
, u32
*basic_rates
)
2078 struct ieee80211_supported_band
*sband
;
2080 u32 supp_rates
, rate_flags
;
2083 sband
= sdata
->local
->hw
.wiphy
->bands
[band
];
2084 if (WARN_ON(!sband
))
2087 rate_flags
= ieee80211_chandef_rate_flags(&sdata
->vif
.bss_conf
.chandef
);
2088 shift
= ieee80211_vif_get_shift(&sdata
->vif
);
2090 num_rates
= sband
->n_bitrates
;
2092 for (i
= 0; i
< elems
->supp_rates_len
+
2093 elems
->ext_supp_rates_len
; i
++) {
2097 if (i
< elems
->supp_rates_len
)
2098 rate
= elems
->supp_rates
[i
];
2099 else if (elems
->ext_supp_rates
)
2100 rate
= elems
->ext_supp_rates
2101 [i
- elems
->supp_rates_len
];
2102 own_rate
= 5 * (rate
& 0x7f);
2103 is_basic
= !!(rate
& 0x80);
2105 if (is_basic
&& (rate
& 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY
)
2108 for (j
= 0; j
< num_rates
; j
++) {
2110 if ((rate_flags
& sband
->bitrates
[j
].flags
)
2114 brate
= DIV_ROUND_UP(sband
->bitrates
[j
].bitrate
,
2117 if (brate
== own_rate
) {
2118 supp_rates
|= BIT(j
);
2119 if (basic_rates
&& is_basic
)
2120 *basic_rates
|= BIT(j
);
2127 void ieee80211_stop_device(struct ieee80211_local
*local
)
2129 ieee80211_led_radio(local
, false);
2130 ieee80211_mod_tpt_led_trig(local
, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO
);
2132 cancel_work_sync(&local
->reconfig_filter
);
2134 flush_workqueue(local
->workqueue
);
2138 static void ieee80211_flush_completed_scan(struct ieee80211_local
*local
,
2141 /* It's possible that we don't handle the scan completion in
2142 * time during suspend, so if it's still marked as completed
2143 * here, queue the work and flush it to clean things up.
2144 * Instead of calling the worker function directly here, we
2145 * really queue it to avoid potential races with other flows
2146 * scheduling the same work.
2148 if (test_bit(SCAN_COMPLETED
, &local
->scanning
)) {
2149 /* If coming from reconfiguration failure, abort the scan so
2150 * we don't attempt to continue a partial HW scan - which is
2151 * possible otherwise if (e.g.) the 2.4 GHz portion was the
2152 * completed scan, and a 5 GHz portion is still pending.
2155 set_bit(SCAN_ABORTED
, &local
->scanning
);
2156 ieee80211_queue_delayed_work(&local
->hw
, &local
->scan_work
, 0);
2157 flush_delayed_work(&local
->scan_work
);
2161 static void ieee80211_handle_reconfig_failure(struct ieee80211_local
*local
)
2163 struct ieee80211_sub_if_data
*sdata
;
2164 struct ieee80211_chanctx
*ctx
;
2167 * We get here if during resume the device can't be restarted properly.
2168 * We might also get here if this happens during HW reset, which is a
2169 * slightly different situation and we need to drop all connections in
2172 * Ask cfg80211 to turn off all interfaces, this will result in more
2173 * warnings but at least we'll then get into a clean stopped state.
2176 local
->resuming
= false;
2177 local
->suspended
= false;
2178 local
->in_reconfig
= false;
2180 ieee80211_flush_completed_scan(local
, true);
2182 /* scheduled scan clearly can't be running any more, but tell
2183 * cfg80211 and clear local state
2185 ieee80211_sched_scan_end(local
);
2187 list_for_each_entry(sdata
, &local
->interfaces
, list
)
2188 sdata
->flags
&= ~IEEE80211_SDATA_IN_DRIVER
;
2190 /* Mark channel contexts as not being in the driver any more to avoid
2191 * removing them from the driver during the shutdown process...
2193 mutex_lock(&local
->chanctx_mtx
);
2194 list_for_each_entry(ctx
, &local
->chanctx_list
, list
)
2195 ctx
->driver_present
= false;
2196 mutex_unlock(&local
->chanctx_mtx
);
2199 static void ieee80211_assign_chanctx(struct ieee80211_local
*local
,
2200 struct ieee80211_sub_if_data
*sdata
)
2202 struct ieee80211_chanctx_conf
*conf
;
2203 struct ieee80211_chanctx
*ctx
;
2205 if (!local
->use_chanctx
)
2208 mutex_lock(&local
->chanctx_mtx
);
2209 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
2210 lockdep_is_held(&local
->chanctx_mtx
));
2212 ctx
= container_of(conf
, struct ieee80211_chanctx
, conf
);
2213 drv_assign_vif_chanctx(local
, sdata
, ctx
);
2215 mutex_unlock(&local
->chanctx_mtx
);
2218 static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data
*sdata
)
2220 struct ieee80211_local
*local
= sdata
->local
;
2221 struct sta_info
*sta
;
2224 mutex_lock(&local
->sta_mtx
);
2225 list_for_each_entry(sta
, &local
->sta_list
, list
) {
2226 enum ieee80211_sta_state state
;
2228 if (!sta
->uploaded
|| sta
->sdata
!= sdata
)
2231 for (state
= IEEE80211_STA_NOTEXIST
;
2232 state
< sta
->sta_state
; state
++)
2233 WARN_ON(drv_sta_state(local
, sta
->sdata
, sta
, state
,
2236 mutex_unlock(&local
->sta_mtx
);
2239 static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data
*sdata
)
2241 struct cfg80211_nan_func
*func
, **funcs
;
2244 res
= drv_start_nan(sdata
->local
, sdata
,
2245 &sdata
->u
.nan
.conf
);
2249 funcs
= kcalloc(sdata
->local
->hw
.max_nan_de_entries
+ 1,
2255 /* Add all the functions:
2256 * This is a little bit ugly. We need to call a potentially sleeping
2257 * callback for each NAN function, so we can't hold the spinlock.
2259 spin_lock_bh(&sdata
->u
.nan
.func_lock
);
2261 idr_for_each_entry(&sdata
->u
.nan
.function_inst_ids
, func
, id
)
2264 spin_unlock_bh(&sdata
->u
.nan
.func_lock
);
2266 for (i
= 0; funcs
[i
]; i
++) {
2267 res
= drv_add_nan_func(sdata
->local
, sdata
, funcs
[i
]);
2269 ieee80211_nan_func_terminated(&sdata
->vif
,
2270 funcs
[i
]->instance_id
,
2271 NL80211_NAN_FUNC_TERM_REASON_ERROR
,
2280 int ieee80211_reconfig(struct ieee80211_local
*local
)
2282 struct ieee80211_hw
*hw
= &local
->hw
;
2283 struct ieee80211_sub_if_data
*sdata
;
2284 struct ieee80211_chanctx
*ctx
;
2285 struct sta_info
*sta
;
2287 bool reconfig_due_to_wowlan
= false;
2288 struct ieee80211_sub_if_data
*sched_scan_sdata
;
2289 struct cfg80211_sched_scan_request
*sched_scan_req
;
2290 bool sched_scan_stopped
= false;
2291 bool suspended
= local
->suspended
;
2293 /* nothing to do if HW shouldn't run */
2294 if (!local
->open_count
)
2299 local
->resuming
= true;
2301 if (local
->wowlan
) {
2303 * In the wowlan case, both mac80211 and the device
2304 * are functional when the resume op is called, so
2305 * clear local->suspended so the device could operate
2306 * normally (e.g. pass rx frames).
2308 local
->suspended
= false;
2309 res
= drv_resume(local
);
2310 local
->wowlan
= false;
2312 local
->resuming
= false;
2319 * res is 1, which means the driver requested
2320 * to go through a regular reset on wakeup.
2321 * restore local->suspended in this case.
2323 reconfig_due_to_wowlan
= true;
2324 local
->suspended
= true;
2329 * In case of hw_restart during suspend (without wowlan),
2330 * cancel restart work, as we are reconfiguring the device
2332 * Note that restart_work is scheduled on a frozen workqueue,
2333 * so we can't deadlock in this case.
2335 if (suspended
&& local
->in_reconfig
&& !reconfig_due_to_wowlan
)
2336 cancel_work_sync(&local
->restart_work
);
2338 local
->started
= false;
2341 * Upon resume hardware can sometimes be goofy due to
2342 * various platform / driver / bus issues, so restarting
2343 * the device may at times not work immediately. Propagate
2346 res
= drv_start(local
);
2349 WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
2351 WARN(1, "Hardware became unavailable during restart.\n");
2352 ieee80211_handle_reconfig_failure(local
);
2356 /* setup fragmentation threshold */
2357 drv_set_frag_threshold(local
, hw
->wiphy
->frag_threshold
);
2359 /* setup RTS threshold */
2360 drv_set_rts_threshold(local
, hw
->wiphy
->rts_threshold
);
2362 /* reset coverage class */
2363 drv_set_coverage_class(local
, hw
->wiphy
->coverage_class
);
2365 ieee80211_led_radio(local
, true);
2366 ieee80211_mod_tpt_led_trig(local
,
2367 IEEE80211_TPT_LEDTRIG_FL_RADIO
, 0);
2369 /* add interfaces */
2370 sdata
= rtnl_dereference(local
->monitor_sdata
);
2372 /* in HW restart it exists already */
2373 WARN_ON(local
->resuming
);
2374 res
= drv_add_interface(local
, sdata
);
2376 RCU_INIT_POINTER(local
->monitor_sdata
, NULL
);
2382 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
2383 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
2384 sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
&&
2385 ieee80211_sdata_running(sdata
)) {
2386 res
= drv_add_interface(local
, sdata
);
2392 /* If adding any of the interfaces failed above, roll back and
2396 list_for_each_entry_continue_reverse(sdata
, &local
->interfaces
,
2398 if (sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
&&
2399 sdata
->vif
.type
!= NL80211_IFTYPE_MONITOR
&&
2400 ieee80211_sdata_running(sdata
))
2401 drv_remove_interface(local
, sdata
);
2402 ieee80211_handle_reconfig_failure(local
);
2406 /* add channel contexts */
2407 if (local
->use_chanctx
) {
2408 mutex_lock(&local
->chanctx_mtx
);
2409 list_for_each_entry(ctx
, &local
->chanctx_list
, list
)
2410 if (ctx
->replace_state
!=
2411 IEEE80211_CHANCTX_REPLACES_OTHER
)
2412 WARN_ON(drv_add_chanctx(local
, ctx
));
2413 mutex_unlock(&local
->chanctx_mtx
);
2415 sdata
= rtnl_dereference(local
->monitor_sdata
);
2416 if (sdata
&& ieee80211_sdata_running(sdata
))
2417 ieee80211_assign_chanctx(local
, sdata
);
2420 /* reconfigure hardware */
2421 ieee80211_hw_config(local
, ~0);
2423 ieee80211_configure_filter(local
);
2425 /* Finally also reconfigure all the BSS information */
2426 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
2429 if (!ieee80211_sdata_running(sdata
))
2432 ieee80211_assign_chanctx(local
, sdata
);
2434 switch (sdata
->vif
.type
) {
2435 case NL80211_IFTYPE_AP_VLAN
:
2436 case NL80211_IFTYPE_MONITOR
:
2438 case NL80211_IFTYPE_ADHOC
:
2439 if (sdata
->vif
.bss_conf
.ibss_joined
)
2440 WARN_ON(drv_join_ibss(local
, sdata
));
2443 ieee80211_reconfig_stations(sdata
);
2445 case NL80211_IFTYPE_AP
: /* AP stations are handled later */
2446 for (i
= 0; i
< IEEE80211_NUM_ACS
; i
++)
2447 drv_conf_tx(local
, sdata
, i
,
2448 &sdata
->tx_conf
[i
]);
2452 /* common change flags for all interface types */
2453 changed
= BSS_CHANGED_ERP_CTS_PROT
|
2454 BSS_CHANGED_ERP_PREAMBLE
|
2455 BSS_CHANGED_ERP_SLOT
|
2457 BSS_CHANGED_BASIC_RATES
|
2458 BSS_CHANGED_BEACON_INT
|
2463 BSS_CHANGED_TXPOWER
|
2464 BSS_CHANGED_MCAST_RATE
;
2466 if (sdata
->vif
.mu_mimo_owner
)
2467 changed
|= BSS_CHANGED_MU_GROUPS
;
2469 switch (sdata
->vif
.type
) {
2470 case NL80211_IFTYPE_STATION
:
2471 changed
|= BSS_CHANGED_ASSOC
|
2472 BSS_CHANGED_ARP_FILTER
|
2475 /* Re-send beacon info report to the driver */
2476 if (sdata
->u
.mgd
.have_beacon
)
2477 changed
|= BSS_CHANGED_BEACON_INFO
;
2479 if (sdata
->vif
.bss_conf
.max_idle_period
||
2480 sdata
->vif
.bss_conf
.protected_keep_alive
)
2481 changed
|= BSS_CHANGED_KEEP_ALIVE
;
2484 ieee80211_bss_info_change_notify(sdata
, changed
);
2485 sdata_unlock(sdata
);
2487 case NL80211_IFTYPE_OCB
:
2488 changed
|= BSS_CHANGED_OCB
;
2489 ieee80211_bss_info_change_notify(sdata
, changed
);
2491 case NL80211_IFTYPE_ADHOC
:
2492 changed
|= BSS_CHANGED_IBSS
;
2494 case NL80211_IFTYPE_AP
:
2495 changed
|= BSS_CHANGED_SSID
| BSS_CHANGED_P2P_PS
;
2497 if (sdata
->vif
.bss_conf
.ftm_responder
== 1 &&
2498 wiphy_ext_feature_isset(sdata
->local
->hw
.wiphy
,
2499 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER
))
2500 changed
|= BSS_CHANGED_FTM_RESPONDER
;
2502 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
) {
2503 changed
|= BSS_CHANGED_AP_PROBE_RESP
;
2505 if (rcu_access_pointer(sdata
->u
.ap
.beacon
))
2506 drv_start_ap(local
, sdata
);
2509 case NL80211_IFTYPE_MESH_POINT
:
2510 if (sdata
->vif
.bss_conf
.enable_beacon
) {
2511 changed
|= BSS_CHANGED_BEACON
|
2512 BSS_CHANGED_BEACON_ENABLED
;
2513 ieee80211_bss_info_change_notify(sdata
, changed
);
2516 case NL80211_IFTYPE_NAN
:
2517 res
= ieee80211_reconfig_nan(sdata
);
2519 ieee80211_handle_reconfig_failure(local
);
2523 case NL80211_IFTYPE_AP_VLAN
:
2524 case NL80211_IFTYPE_MONITOR
:
2525 case NL80211_IFTYPE_P2P_DEVICE
:
2528 case NL80211_IFTYPE_UNSPECIFIED
:
2529 case NUM_NL80211_IFTYPES
:
2530 case NL80211_IFTYPE_P2P_CLIENT
:
2531 case NL80211_IFTYPE_P2P_GO
:
2532 case NL80211_IFTYPE_WDS
:
2538 ieee80211_recalc_ps(local
);
2541 * The sta might be in psm against the ap (e.g. because
2542 * this was the state before a hw restart), so we
2543 * explicitly send a null packet in order to make sure
2544 * it'll sync against the ap (and get out of psm).
2546 if (!(local
->hw
.conf
.flags
& IEEE80211_CONF_PS
)) {
2547 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
2548 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
2550 if (!sdata
->u
.mgd
.associated
)
2553 ieee80211_send_nullfunc(local
, sdata
, false);
2557 /* APs are now beaconing, add back stations */
2558 mutex_lock(&local
->sta_mtx
);
2559 list_for_each_entry(sta
, &local
->sta_list
, list
) {
2560 enum ieee80211_sta_state state
;
2565 if (sta
->sdata
->vif
.type
!= NL80211_IFTYPE_AP
&&
2566 sta
->sdata
->vif
.type
!= NL80211_IFTYPE_AP_VLAN
)
2569 for (state
= IEEE80211_STA_NOTEXIST
;
2570 state
< sta
->sta_state
; state
++)
2571 WARN_ON(drv_sta_state(local
, sta
->sdata
, sta
, state
,
2574 mutex_unlock(&local
->sta_mtx
);
2577 list_for_each_entry(sdata
, &local
->interfaces
, list
)
2578 ieee80211_reenable_keys(sdata
);
2580 /* Reconfigure sched scan if it was interrupted by FW restart */
2581 mutex_lock(&local
->mtx
);
2582 sched_scan_sdata
= rcu_dereference_protected(local
->sched_scan_sdata
,
2583 lockdep_is_held(&local
->mtx
));
2584 sched_scan_req
= rcu_dereference_protected(local
->sched_scan_req
,
2585 lockdep_is_held(&local
->mtx
));
2586 if (sched_scan_sdata
&& sched_scan_req
)
2588 * Sched scan stopped, but we don't want to report it. Instead,
2589 * we're trying to reschedule. However, if more than one scan
2590 * plan was set, we cannot reschedule since we don't know which
2591 * scan plan was currently running (and some scan plans may have
2592 * already finished).
2594 if (sched_scan_req
->n_scan_plans
> 1 ||
2595 __ieee80211_request_sched_scan_start(sched_scan_sdata
,
2597 RCU_INIT_POINTER(local
->sched_scan_sdata
, NULL
);
2598 RCU_INIT_POINTER(local
->sched_scan_req
, NULL
);
2599 sched_scan_stopped
= true;
2601 mutex_unlock(&local
->mtx
);
2603 if (sched_scan_stopped
)
2604 cfg80211_sched_scan_stopped_locked(local
->hw
.wiphy
, 0);
2608 if (local
->monitors
== local
->open_count
&& local
->monitors
> 0)
2609 ieee80211_add_virtual_monitor(local
);
2612 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
2613 * sessions can be established after a resume.
2615 * Also tear down aggregation sessions since reconfiguring
2616 * them in a hardware restart scenario is not easily done
2617 * right now, and the hardware will have lost information
2618 * about the sessions, but we and the AP still think they
2619 * are active. This is really a workaround though.
2621 if (ieee80211_hw_check(hw
, AMPDU_AGGREGATION
)) {
2622 mutex_lock(&local
->sta_mtx
);
2624 list_for_each_entry(sta
, &local
->sta_list
, list
) {
2625 if (!local
->resuming
)
2626 ieee80211_sta_tear_down_BA_sessions(
2627 sta
, AGG_STOP_LOCAL_REQUEST
);
2628 clear_sta_flag(sta
, WLAN_STA_BLOCK_BA
);
2631 mutex_unlock(&local
->sta_mtx
);
2634 if (local
->in_reconfig
) {
2635 local
->in_reconfig
= false;
2638 /* Restart deferred ROCs */
2639 mutex_lock(&local
->mtx
);
2640 ieee80211_start_next_roc(local
);
2641 mutex_unlock(&local
->mtx
);
2643 /* Requeue all works */
2644 list_for_each_entry(sdata
, &local
->interfaces
, list
)
2645 ieee80211_queue_work(&local
->hw
, &sdata
->work
);
2648 ieee80211_wake_queues_by_reason(hw
, IEEE80211_MAX_QUEUE_MAP
,
2649 IEEE80211_QUEUE_STOP_REASON_SUSPEND
,
2653 * If this is for hw restart things are still running.
2654 * We may want to change that later, however.
2656 if (local
->open_count
&& (!suspended
|| reconfig_due_to_wowlan
))
2657 drv_reconfig_complete(local
, IEEE80211_RECONFIG_TYPE_RESTART
);
2663 /* first set suspended false, then resuming */
2664 local
->suspended
= false;
2666 local
->resuming
= false;
2668 ieee80211_flush_completed_scan(local
, false);
2670 if (local
->open_count
&& !reconfig_due_to_wowlan
)
2671 drv_reconfig_complete(local
, IEEE80211_RECONFIG_TYPE_SUSPEND
);
2673 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
2674 if (!ieee80211_sdata_running(sdata
))
2676 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
2677 ieee80211_sta_restart(sdata
);
2680 mod_timer(&local
->sta_cleanup
, jiffies
+ 1);
2688 void ieee80211_resume_disconnect(struct ieee80211_vif
*vif
)
2690 struct ieee80211_sub_if_data
*sdata
;
2691 struct ieee80211_local
*local
;
2692 struct ieee80211_key
*key
;
2697 sdata
= vif_to_sdata(vif
);
2698 local
= sdata
->local
;
2700 if (WARN_ON(!local
->resuming
))
2703 if (WARN_ON(vif
->type
!= NL80211_IFTYPE_STATION
))
2706 sdata
->flags
|= IEEE80211_SDATA_DISCONNECT_RESUME
;
2708 mutex_lock(&local
->key_mtx
);
2709 list_for_each_entry(key
, &sdata
->key_list
, list
)
2710 key
->flags
|= KEY_FLAG_TAINTED
;
2711 mutex_unlock(&local
->key_mtx
);
2713 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect
);
2715 void ieee80211_recalc_smps(struct ieee80211_sub_if_data
*sdata
)
2717 struct ieee80211_local
*local
= sdata
->local
;
2718 struct ieee80211_chanctx_conf
*chanctx_conf
;
2719 struct ieee80211_chanctx
*chanctx
;
2721 mutex_lock(&local
->chanctx_mtx
);
2723 chanctx_conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
2724 lockdep_is_held(&local
->chanctx_mtx
));
2727 * This function can be called from a work, thus it may be possible
2728 * that the chanctx_conf is removed (due to a disconnection, for
2730 * So nothing should be done in such case.
2735 chanctx
= container_of(chanctx_conf
, struct ieee80211_chanctx
, conf
);
2736 ieee80211_recalc_smps_chanctx(local
, chanctx
);
2738 mutex_unlock(&local
->chanctx_mtx
);
2741 void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data
*sdata
)
2743 struct ieee80211_local
*local
= sdata
->local
;
2744 struct ieee80211_chanctx_conf
*chanctx_conf
;
2745 struct ieee80211_chanctx
*chanctx
;
2747 mutex_lock(&local
->chanctx_mtx
);
2749 chanctx_conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
2750 lockdep_is_held(&local
->chanctx_mtx
));
2752 if (WARN_ON_ONCE(!chanctx_conf
))
2755 chanctx
= container_of(chanctx_conf
, struct ieee80211_chanctx
, conf
);
2756 ieee80211_recalc_chanctx_min_def(local
, chanctx
);
2758 mutex_unlock(&local
->chanctx_mtx
);
2761 size_t ieee80211_ie_split_vendor(const u8
*ies
, size_t ielen
, size_t offset
)
2763 size_t pos
= offset
;
2765 while (pos
< ielen
&& ies
[pos
] != WLAN_EID_VENDOR_SPECIFIC
)
2766 pos
+= 2 + ies
[pos
+ 1];
2771 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data
*sdata
,
2775 trace_api_enable_rssi_reports(sdata
, rssi_min_thold
, rssi_max_thold
);
2777 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
2781 * Scale up threshold values before storing it, as the RSSI averaging
2782 * algorithm uses a scaled up value as well. Change this scaling
2783 * factor if the RSSI averaging algorithm changes.
2785 sdata
->u
.mgd
.rssi_min_thold
= rssi_min_thold
*16;
2786 sdata
->u
.mgd
.rssi_max_thold
= rssi_max_thold
*16;
2789 void ieee80211_enable_rssi_reports(struct ieee80211_vif
*vif
,
2793 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
2795 WARN_ON(rssi_min_thold
== rssi_max_thold
||
2796 rssi_min_thold
> rssi_max_thold
);
2798 _ieee80211_enable_rssi_reports(sdata
, rssi_min_thold
,
2801 EXPORT_SYMBOL(ieee80211_enable_rssi_reports
);
2803 void ieee80211_disable_rssi_reports(struct ieee80211_vif
*vif
)
2805 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
2807 _ieee80211_enable_rssi_reports(sdata
, 0, 0);
2809 EXPORT_SYMBOL(ieee80211_disable_rssi_reports
);
2811 u8
*ieee80211_ie_build_ht_cap(u8
*pos
, struct ieee80211_sta_ht_cap
*ht_cap
,
2816 *pos
++ = WLAN_EID_HT_CAPABILITY
;
2817 *pos
++ = sizeof(struct ieee80211_ht_cap
);
2818 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
2820 /* capability flags */
2821 tmp
= cpu_to_le16(cap
);
2822 memcpy(pos
, &tmp
, sizeof(u16
));
2825 /* AMPDU parameters */
2826 *pos
++ = ht_cap
->ampdu_factor
|
2827 (ht_cap
->ampdu_density
<<
2828 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT
);
2831 memcpy(pos
, &ht_cap
->mcs
, sizeof(ht_cap
->mcs
));
2832 pos
+= sizeof(ht_cap
->mcs
);
2834 /* extended capabilities */
2835 pos
+= sizeof(__le16
);
2837 /* BF capabilities */
2838 pos
+= sizeof(__le32
);
2840 /* antenna selection */
2846 u8
*ieee80211_ie_build_vht_cap(u8
*pos
, struct ieee80211_sta_vht_cap
*vht_cap
,
2851 *pos
++ = WLAN_EID_VHT_CAPABILITY
;
2852 *pos
++ = sizeof(struct ieee80211_vht_cap
);
2853 memset(pos
, 0, sizeof(struct ieee80211_vht_cap
));
2855 /* capability flags */
2856 tmp
= cpu_to_le32(cap
);
2857 memcpy(pos
, &tmp
, sizeof(u32
));
2861 memcpy(pos
, &vht_cap
->vht_mcs
, sizeof(vht_cap
->vht_mcs
));
2862 pos
+= sizeof(vht_cap
->vht_mcs
);
2867 u8
ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data
*sdata
, u8 iftype
)
2869 const struct ieee80211_sta_he_cap
*he_cap
;
2870 struct ieee80211_supported_band
*sband
;
2873 sband
= ieee80211_get_sband(sdata
);
2877 he_cap
= ieee80211_get_he_iftype_cap(sband
, iftype
);
2881 n
= ieee80211_he_mcs_nss_size(&he_cap
->he_cap_elem
);
2883 sizeof(he_cap
->he_cap_elem
) + n
+
2884 ieee80211_he_ppe_size(he_cap
->ppe_thres
[0],
2885 he_cap
->he_cap_elem
.phy_cap_info
);
2888 u8
*ieee80211_ie_build_he_cap(u8
*pos
,
2889 const struct ieee80211_sta_he_cap
*he_cap
,
2896 /* Make sure we have place for the IE */
2898 * TODO: the 1 added is because this temporarily is under the EXTENSION
2899 * IE. Get rid of it when it moves.
2904 n
= ieee80211_he_mcs_nss_size(&he_cap
->he_cap_elem
);
2906 sizeof(he_cap
->he_cap_elem
) + n
+
2907 ieee80211_he_ppe_size(he_cap
->ppe_thres
[0],
2908 he_cap
->he_cap_elem
.phy_cap_info
);
2910 if ((end
- pos
) < ie_len
)
2913 *pos
++ = WLAN_EID_EXTENSION
;
2914 pos
++; /* We'll set the size later below */
2915 *pos
++ = WLAN_EID_EXT_HE_CAPABILITY
;
2918 memcpy(pos
, &he_cap
->he_cap_elem
, sizeof(he_cap
->he_cap_elem
));
2919 pos
+= sizeof(he_cap
->he_cap_elem
);
2921 memcpy(pos
, &he_cap
->he_mcs_nss_supp
, n
);
2924 /* Check if PPE Threshold should be present */
2925 if ((he_cap
->he_cap_elem
.phy_cap_info
[6] &
2926 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT
) == 0)
2930 * Calculate how many PPET16/PPET8 pairs are to come. Algorithm:
2931 * (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK)
2933 n
= hweight8(he_cap
->ppe_thres
[0] &
2934 IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK
);
2935 n
*= (1 + ((he_cap
->ppe_thres
[0] & IEEE80211_PPE_THRES_NSS_MASK
) >>
2936 IEEE80211_PPE_THRES_NSS_POS
));
2939 * Each pair is 6 bits, and we need to add the 7 "header" bits to the
2942 n
= (n
* IEEE80211_PPE_THRES_INFO_PPET_SIZE
* 2) + 7;
2943 n
= DIV_ROUND_UP(n
, 8);
2945 /* Copy PPE Thresholds */
2946 memcpy(pos
, &he_cap
->ppe_thres
, n
);
2950 orig_pos
[1] = (pos
- orig_pos
) - 2;
2954 void ieee80211_ie_build_he_6ghz_cap(struct ieee80211_sub_if_data
*sdata
,
2955 struct sk_buff
*skb
)
2957 struct ieee80211_supported_band
*sband
;
2958 const struct ieee80211_sband_iftype_data
*iftd
;
2959 enum nl80211_iftype iftype
= ieee80211_vif_type_p2p(&sdata
->vif
);
2963 if (!cfg80211_any_usable_channels(sdata
->local
->hw
.wiphy
,
2964 BIT(NL80211_BAND_6GHZ
),
2965 IEEE80211_CHAN_NO_HE
))
2968 sband
= sdata
->local
->hw
.wiphy
->bands
[NL80211_BAND_6GHZ
];
2970 iftd
= ieee80211_get_sband_iftype_data(sband
, iftype
);
2974 /* Check for device HE 6 GHz capability before adding element */
2975 if (!iftd
->he_6ghz_capa
.capa
)
2978 cap
= le16_to_cpu(iftd
->he_6ghz_capa
.capa
);
2979 cap
&= ~IEEE80211_HE_6GHZ_CAP_SM_PS
;
2981 switch (sdata
->smps_mode
) {
2982 case IEEE80211_SMPS_AUTOMATIC
:
2983 case IEEE80211_SMPS_NUM_MODES
:
2986 case IEEE80211_SMPS_OFF
:
2987 cap
|= u16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED
,
2988 IEEE80211_HE_6GHZ_CAP_SM_PS
);
2990 case IEEE80211_SMPS_STATIC
:
2991 cap
|= u16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC
,
2992 IEEE80211_HE_6GHZ_CAP_SM_PS
);
2994 case IEEE80211_SMPS_DYNAMIC
:
2995 cap
|= u16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC
,
2996 IEEE80211_HE_6GHZ_CAP_SM_PS
);
3000 pos
= skb_put(skb
, 2 + 1 + sizeof(cap
));
3001 ieee80211_write_he_6ghz_cap(pos
, cpu_to_le16(cap
),
3002 pos
+ 2 + 1 + sizeof(cap
));
3005 u8
*ieee80211_ie_build_ht_oper(u8
*pos
, struct ieee80211_sta_ht_cap
*ht_cap
,
3006 const struct cfg80211_chan_def
*chandef
,
3007 u16 prot_mode
, bool rifs_mode
)
3009 struct ieee80211_ht_operation
*ht_oper
;
3010 /* Build HT Information */
3011 *pos
++ = WLAN_EID_HT_OPERATION
;
3012 *pos
++ = sizeof(struct ieee80211_ht_operation
);
3013 ht_oper
= (struct ieee80211_ht_operation
*)pos
;
3014 ht_oper
->primary_chan
= ieee80211_frequency_to_channel(
3015 chandef
->chan
->center_freq
);
3016 switch (chandef
->width
) {
3017 case NL80211_CHAN_WIDTH_160
:
3018 case NL80211_CHAN_WIDTH_80P80
:
3019 case NL80211_CHAN_WIDTH_80
:
3020 case NL80211_CHAN_WIDTH_40
:
3021 if (chandef
->center_freq1
> chandef
->chan
->center_freq
)
3022 ht_oper
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_ABOVE
;
3024 ht_oper
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
3027 ht_oper
->ht_param
= IEEE80211_HT_PARAM_CHA_SEC_NONE
;
3030 if (ht_cap
->cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
&&
3031 chandef
->width
!= NL80211_CHAN_WIDTH_20_NOHT
&&
3032 chandef
->width
!= NL80211_CHAN_WIDTH_20
)
3033 ht_oper
->ht_param
|= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
;
3036 ht_oper
->ht_param
|= IEEE80211_HT_PARAM_RIFS_MODE
;
3038 ht_oper
->operation_mode
= cpu_to_le16(prot_mode
);
3039 ht_oper
->stbc_param
= 0x0000;
3041 /* It seems that Basic MCS set and Supported MCS set
3042 are identical for the first 10 bytes */
3043 memset(&ht_oper
->basic_set
, 0, 16);
3044 memcpy(&ht_oper
->basic_set
, &ht_cap
->mcs
, 10);
3046 return pos
+ sizeof(struct ieee80211_ht_operation
);
3049 void ieee80211_ie_build_wide_bw_cs(u8
*pos
,
3050 const struct cfg80211_chan_def
*chandef
)
3052 *pos
++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH
; /* EID */
3053 *pos
++ = 3; /* IE length */
3054 /* New channel width */
3055 switch (chandef
->width
) {
3056 case NL80211_CHAN_WIDTH_80
:
3057 *pos
++ = IEEE80211_VHT_CHANWIDTH_80MHZ
;
3059 case NL80211_CHAN_WIDTH_160
:
3060 *pos
++ = IEEE80211_VHT_CHANWIDTH_160MHZ
;
3062 case NL80211_CHAN_WIDTH_80P80
:
3063 *pos
++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ
;
3066 *pos
++ = IEEE80211_VHT_CHANWIDTH_USE_HT
;
3069 /* new center frequency segment 0 */
3070 *pos
++ = ieee80211_frequency_to_channel(chandef
->center_freq1
);
3071 /* new center frequency segment 1 */
3072 if (chandef
->center_freq2
)
3073 *pos
++ = ieee80211_frequency_to_channel(chandef
->center_freq2
);
3078 u8
*ieee80211_ie_build_vht_oper(u8
*pos
, struct ieee80211_sta_vht_cap
*vht_cap
,
3079 const struct cfg80211_chan_def
*chandef
)
3081 struct ieee80211_vht_operation
*vht_oper
;
3083 *pos
++ = WLAN_EID_VHT_OPERATION
;
3084 *pos
++ = sizeof(struct ieee80211_vht_operation
);
3085 vht_oper
= (struct ieee80211_vht_operation
*)pos
;
3086 vht_oper
->center_freq_seg0_idx
= ieee80211_frequency_to_channel(
3087 chandef
->center_freq1
);
3088 if (chandef
->center_freq2
)
3089 vht_oper
->center_freq_seg1_idx
=
3090 ieee80211_frequency_to_channel(chandef
->center_freq2
);
3092 vht_oper
->center_freq_seg1_idx
= 0x00;
3094 switch (chandef
->width
) {
3095 case NL80211_CHAN_WIDTH_160
:
3097 * Convert 160 MHz channel width to new style as interop
3100 vht_oper
->chan_width
= IEEE80211_VHT_CHANWIDTH_80MHZ
;
3101 vht_oper
->center_freq_seg1_idx
= vht_oper
->center_freq_seg0_idx
;
3102 if (chandef
->chan
->center_freq
< chandef
->center_freq1
)
3103 vht_oper
->center_freq_seg0_idx
-= 8;
3105 vht_oper
->center_freq_seg0_idx
+= 8;
3107 case NL80211_CHAN_WIDTH_80P80
:
3109 * Convert 80+80 MHz channel width to new style as interop
3112 vht_oper
->chan_width
= IEEE80211_VHT_CHANWIDTH_80MHZ
;
3114 case NL80211_CHAN_WIDTH_80
:
3115 vht_oper
->chan_width
= IEEE80211_VHT_CHANWIDTH_80MHZ
;
3118 vht_oper
->chan_width
= IEEE80211_VHT_CHANWIDTH_USE_HT
;
3122 /* don't require special VHT peer rates */
3123 vht_oper
->basic_mcs_set
= cpu_to_le16(0xffff);
3125 return pos
+ sizeof(struct ieee80211_vht_operation
);
3128 u8
*ieee80211_ie_build_he_oper(u8
*pos
, struct cfg80211_chan_def
*chandef
)
3130 struct ieee80211_he_operation
*he_oper
;
3131 struct ieee80211_he_6ghz_oper
*he_6ghz_op
;
3133 u8 ie_len
= 1 + sizeof(struct ieee80211_he_operation
);
3135 if (chandef
->chan
->band
== NL80211_BAND_6GHZ
)
3136 ie_len
+= sizeof(struct ieee80211_he_6ghz_oper
);
3138 *pos
++ = WLAN_EID_EXTENSION
;
3140 *pos
++ = WLAN_EID_EXT_HE_OPERATION
;
3143 he_oper_params
|= u32_encode_bits(1023, /* disabled */
3144 IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK
);
3145 he_oper_params
|= u32_encode_bits(1,
3146 IEEE80211_HE_OPERATION_ER_SU_DISABLE
);
3147 he_oper_params
|= u32_encode_bits(1,
3148 IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED
);
3149 if (chandef
->chan
->band
== NL80211_BAND_6GHZ
)
3150 he_oper_params
|= u32_encode_bits(1,
3151 IEEE80211_HE_OPERATION_6GHZ_OP_INFO
);
3153 he_oper
= (struct ieee80211_he_operation
*)pos
;
3154 he_oper
->he_oper_params
= cpu_to_le32(he_oper_params
);
3156 /* don't require special HE peer rates */
3157 he_oper
->he_mcs_nss_set
= cpu_to_le16(0xffff);
3158 pos
+= sizeof(struct ieee80211_he_operation
);
3160 if (chandef
->chan
->band
!= NL80211_BAND_6GHZ
)
3163 /* TODO add VHT operational */
3164 he_6ghz_op
= (struct ieee80211_he_6ghz_oper
*)pos
;
3165 he_6ghz_op
->minrate
= 6; /* 6 Mbps */
3166 he_6ghz_op
->primary
=
3167 ieee80211_frequency_to_channel(chandef
->chan
->center_freq
);
3169 ieee80211_frequency_to_channel(chandef
->center_freq1
);
3170 if (chandef
->center_freq2
)
3172 ieee80211_frequency_to_channel(chandef
->center_freq2
);
3174 he_6ghz_op
->ccfs1
= 0;
3176 switch (chandef
->width
) {
3177 case NL80211_CHAN_WIDTH_160
:
3178 /* Convert 160 MHz channel width to new style as interop
3181 he_6ghz_op
->control
=
3182 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ
;
3183 he_6ghz_op
->ccfs1
= he_6ghz_op
->ccfs0
;
3184 if (chandef
->chan
->center_freq
< chandef
->center_freq1
)
3185 he_6ghz_op
->ccfs0
-= 8;
3187 he_6ghz_op
->ccfs0
+= 8;
3189 case NL80211_CHAN_WIDTH_80P80
:
3190 he_6ghz_op
->control
=
3191 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ
;
3193 case NL80211_CHAN_WIDTH_80
:
3194 he_6ghz_op
->control
=
3195 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ
;
3197 case NL80211_CHAN_WIDTH_40
:
3198 he_6ghz_op
->control
=
3199 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ
;
3202 he_6ghz_op
->control
=
3203 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ
;
3207 pos
+= sizeof(struct ieee80211_he_6ghz_oper
);
3213 bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation
*ht_oper
,
3214 struct cfg80211_chan_def
*chandef
)
3216 enum nl80211_channel_type channel_type
;
3221 switch (ht_oper
->ht_param
& IEEE80211_HT_PARAM_CHA_SEC_OFFSET
) {
3222 case IEEE80211_HT_PARAM_CHA_SEC_NONE
:
3223 channel_type
= NL80211_CHAN_HT20
;
3225 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
3226 channel_type
= NL80211_CHAN_HT40PLUS
;
3228 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
3229 channel_type
= NL80211_CHAN_HT40MINUS
;
3232 channel_type
= NL80211_CHAN_NO_HT
;
3236 cfg80211_chandef_create(chandef
, chandef
->chan
, channel_type
);
3240 bool ieee80211_chandef_vht_oper(struct ieee80211_hw
*hw
, u32 vht_cap_info
,
3241 const struct ieee80211_vht_operation
*oper
,
3242 const struct ieee80211_ht_operation
*htop
,
3243 struct cfg80211_chan_def
*chandef
)
3245 struct cfg80211_chan_def
new = *chandef
;
3247 int ccfs0
, ccfs1
, ccfs2
;
3250 bool support_80_80
= false;
3251 bool support_160
= false;
3252 u8 ext_nss_bw_supp
= u32_get_bits(vht_cap_info
,
3253 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK
);
3254 u8 supp_chwidth
= u32_get_bits(vht_cap_info
,
3255 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK
);
3260 vht_cap
= hw
->wiphy
->bands
[chandef
->chan
->band
]->vht_cap
.cap
;
3261 support_160
= (vht_cap
& (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK
|
3262 IEEE80211_VHT_CAP_EXT_NSS_BW_MASK
));
3263 support_80_80
= ((vht_cap
&
3264 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ
) ||
3265 (vht_cap
& IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ
&&
3266 vht_cap
& IEEE80211_VHT_CAP_EXT_NSS_BW_MASK
) ||
3267 ((vht_cap
& IEEE80211_VHT_CAP_EXT_NSS_BW_MASK
) >>
3268 IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT
> 1));
3269 ccfs0
= oper
->center_freq_seg0_idx
;
3270 ccfs1
= oper
->center_freq_seg1_idx
;
3271 ccfs2
= (le16_to_cpu(htop
->operation_mode
) &
3272 IEEE80211_HT_OP_MODE_CCFS2_MASK
)
3273 >> IEEE80211_HT_OP_MODE_CCFS2_SHIFT
;
3277 /* if not supported, parse as though we didn't understand it */
3278 if (!ieee80211_hw_check(hw
, SUPPORTS_VHT_EXT_NSS_BW
))
3279 ext_nss_bw_supp
= 0;
3282 * Cf. IEEE 802.11 Table 9-250
3284 * We really just consider that because it's inefficient to connect
3285 * at a higher bandwidth than we'll actually be able to use.
3287 switch ((supp_chwidth
<< 4) | ext_nss_bw_supp
) {
3291 support_160
= false;
3292 support_80_80
= false;
3295 support_80_80
= false;
3318 cf0
= ieee80211_channel_to_frequency(ccf0
, chandef
->chan
->band
);
3319 cf1
= ieee80211_channel_to_frequency(ccf1
, chandef
->chan
->band
);
3321 switch (oper
->chan_width
) {
3322 case IEEE80211_VHT_CHANWIDTH_USE_HT
:
3323 /* just use HT information directly */
3325 case IEEE80211_VHT_CHANWIDTH_80MHZ
:
3326 new.width
= NL80211_CHAN_WIDTH_80
;
3327 new.center_freq1
= cf0
;
3328 /* If needed, adjust based on the newer interop workaround. */
3332 diff
= abs(ccf1
- ccf0
);
3333 if ((diff
== 8) && support_160
) {
3334 new.width
= NL80211_CHAN_WIDTH_160
;
3335 new.center_freq1
= cf1
;
3336 } else if ((diff
> 8) && support_80_80
) {
3337 new.width
= NL80211_CHAN_WIDTH_80P80
;
3338 new.center_freq2
= cf1
;
3342 case IEEE80211_VHT_CHANWIDTH_160MHZ
:
3343 /* deprecated encoding */
3344 new.width
= NL80211_CHAN_WIDTH_160
;
3345 new.center_freq1
= cf0
;
3347 case IEEE80211_VHT_CHANWIDTH_80P80MHZ
:
3348 /* deprecated encoding */
3349 new.width
= NL80211_CHAN_WIDTH_80P80
;
3350 new.center_freq1
= cf0
;
3351 new.center_freq2
= cf1
;
3357 if (!cfg80211_chandef_valid(&new))
3364 bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_sub_if_data
*sdata
,
3365 const struct ieee80211_he_operation
*he_oper
,
3366 struct cfg80211_chan_def
*chandef
)
3368 struct ieee80211_local
*local
= sdata
->local
;
3369 struct ieee80211_supported_band
*sband
;
3370 enum nl80211_iftype iftype
= ieee80211_vif_type_p2p(&sdata
->vif
);
3371 const struct ieee80211_sta_he_cap
*he_cap
;
3372 struct cfg80211_chan_def he_chandef
= *chandef
;
3373 const struct ieee80211_he_6ghz_oper
*he_6ghz_oper
;
3374 bool support_80_80
, support_160
;
3378 if (chandef
->chan
->band
!= NL80211_BAND_6GHZ
)
3381 sband
= local
->hw
.wiphy
->bands
[NL80211_BAND_6GHZ
];
3383 he_cap
= ieee80211_get_he_iftype_cap(sband
, iftype
);
3385 sdata_info(sdata
, "Missing iftype sband data/HE cap");
3389 he_phy_cap
= he_cap
->he_cap_elem
.phy_cap_info
[0];
3392 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G
;
3395 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G
;
3399 "HE is not advertised on (on %d MHz), expect issues\n",
3400 chandef
->chan
->center_freq
);
3404 he_6ghz_oper
= ieee80211_he_6ghz_oper(he_oper
);
3406 if (!he_6ghz_oper
) {
3408 "HE 6GHz operation missing (on %d MHz), expect issues\n",
3409 chandef
->chan
->center_freq
);
3413 freq
= ieee80211_channel_to_frequency(he_6ghz_oper
->primary
,
3415 he_chandef
.chan
= ieee80211_get_channel(sdata
->local
->hw
.wiphy
, freq
);
3417 switch (u8_get_bits(he_6ghz_oper
->control
,
3418 IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH
)) {
3419 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ
:
3420 he_chandef
.width
= NL80211_CHAN_WIDTH_20
;
3422 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ
:
3423 he_chandef
.width
= NL80211_CHAN_WIDTH_40
;
3425 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ
:
3426 he_chandef
.width
= NL80211_CHAN_WIDTH_80
;
3428 case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ
:
3429 he_chandef
.width
= NL80211_CHAN_WIDTH_80
;
3430 if (!he_6ghz_oper
->ccfs1
)
3432 if (abs(he_6ghz_oper
->ccfs1
- he_6ghz_oper
->ccfs0
) == 8) {
3434 he_chandef
.width
= NL80211_CHAN_WIDTH_160
;
3437 he_chandef
.width
= NL80211_CHAN_WIDTH_80P80
;
3442 if (he_chandef
.width
== NL80211_CHAN_WIDTH_160
) {
3443 he_chandef
.center_freq1
=
3444 ieee80211_channel_to_frequency(he_6ghz_oper
->ccfs1
,
3447 he_chandef
.center_freq1
=
3448 ieee80211_channel_to_frequency(he_6ghz_oper
->ccfs0
,
3450 if (support_80_80
|| support_160
)
3451 he_chandef
.center_freq2
=
3452 ieee80211_channel_to_frequency(he_6ghz_oper
->ccfs1
,
3456 if (!cfg80211_chandef_valid(&he_chandef
)) {
3458 "HE 6GHz operation resulted in invalid chandef: %d MHz/%d/%d MHz/%d MHz\n",
3459 he_chandef
.chan
? he_chandef
.chan
->center_freq
: 0,
3461 he_chandef
.center_freq1
,
3462 he_chandef
.center_freq2
);
3466 *chandef
= he_chandef
;
3471 bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie
*oper
,
3472 struct cfg80211_chan_def
*chandef
)
3479 switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER
, oper
->ch_width
)) {
3480 case IEEE80211_S1G_CHANWIDTH_1MHZ
:
3481 chandef
->width
= NL80211_CHAN_WIDTH_1
;
3483 case IEEE80211_S1G_CHANWIDTH_2MHZ
:
3484 chandef
->width
= NL80211_CHAN_WIDTH_2
;
3486 case IEEE80211_S1G_CHANWIDTH_4MHZ
:
3487 chandef
->width
= NL80211_CHAN_WIDTH_4
;
3489 case IEEE80211_S1G_CHANWIDTH_8MHZ
:
3490 chandef
->width
= NL80211_CHAN_WIDTH_8
;
3492 case IEEE80211_S1G_CHANWIDTH_16MHZ
:
3493 chandef
->width
= NL80211_CHAN_WIDTH_16
;
3499 oper_freq
= ieee80211_channel_to_freq_khz(oper
->oper_ch
,
3500 NL80211_BAND_S1GHZ
);
3501 chandef
->center_freq1
= KHZ_TO_MHZ(oper_freq
);
3502 chandef
->freq1_offset
= oper_freq
% 1000;
3507 int ieee80211_parse_bitrates(struct cfg80211_chan_def
*chandef
,
3508 const struct ieee80211_supported_band
*sband
,
3509 const u8
*srates
, int srates_len
, u32
*rates
)
3511 u32 rate_flags
= ieee80211_chandef_rate_flags(chandef
);
3512 int shift
= ieee80211_chandef_get_shift(chandef
);
3513 struct ieee80211_rate
*br
;
3514 int brate
, rate
, i
, j
, count
= 0;
3518 for (i
= 0; i
< srates_len
; i
++) {
3519 rate
= srates
[i
] & 0x7f;
3521 for (j
= 0; j
< sband
->n_bitrates
; j
++) {
3522 br
= &sband
->bitrates
[j
];
3523 if ((rate_flags
& br
->flags
) != rate_flags
)
3526 brate
= DIV_ROUND_UP(br
->bitrate
, (1 << shift
) * 5);
3527 if (brate
== rate
) {
3537 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data
*sdata
,
3538 struct sk_buff
*skb
, bool need_basic
,
3539 enum nl80211_band band
)
3541 struct ieee80211_local
*local
= sdata
->local
;
3542 struct ieee80211_supported_band
*sband
;
3545 u32 basic_rates
= sdata
->vif
.bss_conf
.basic_rates
;
3548 shift
= ieee80211_vif_get_shift(&sdata
->vif
);
3549 rate_flags
= ieee80211_chandef_rate_flags(&sdata
->vif
.bss_conf
.chandef
);
3550 sband
= local
->hw
.wiphy
->bands
[band
];
3552 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
3553 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
3560 if (skb_tailroom(skb
) < rates
+ 2)
3563 pos
= skb_put(skb
, rates
+ 2);
3564 *pos
++ = WLAN_EID_SUPP_RATES
;
3566 for (i
= 0; i
< rates
; i
++) {
3568 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
3571 if (need_basic
&& basic_rates
& BIT(i
))
3573 rate
= DIV_ROUND_UP(sband
->bitrates
[i
].bitrate
,
3575 *pos
++ = basic
| (u8
) rate
;
3581 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data
*sdata
,
3582 struct sk_buff
*skb
, bool need_basic
,
3583 enum nl80211_band band
)
3585 struct ieee80211_local
*local
= sdata
->local
;
3586 struct ieee80211_supported_band
*sband
;
3588 u8 i
, exrates
, *pos
;
3589 u32 basic_rates
= sdata
->vif
.bss_conf
.basic_rates
;
3592 rate_flags
= ieee80211_chandef_rate_flags(&sdata
->vif
.bss_conf
.chandef
);
3593 shift
= ieee80211_vif_get_shift(&sdata
->vif
);
3595 sband
= local
->hw
.wiphy
->bands
[band
];
3597 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
3598 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
3608 if (skb_tailroom(skb
) < exrates
+ 2)
3612 pos
= skb_put(skb
, exrates
+ 2);
3613 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
3615 for (i
= 8; i
< sband
->n_bitrates
; i
++) {
3617 if ((rate_flags
& sband
->bitrates
[i
].flags
)
3620 if (need_basic
&& basic_rates
& BIT(i
))
3622 rate
= DIV_ROUND_UP(sband
->bitrates
[i
].bitrate
,
3624 *pos
++ = basic
| (u8
) rate
;
3630 int ieee80211_ave_rssi(struct ieee80211_vif
*vif
)
3632 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
3633 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
3635 if (WARN_ON_ONCE(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)) {
3636 /* non-managed type inferfaces */
3639 return -ewma_beacon_signal_read(&ifmgd
->ave_beacon_signal
);
3641 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi
);
3643 u8
ieee80211_mcs_to_chains(const struct ieee80211_mcs_info
*mcs
)
3648 /* TODO: consider rx_highest */
3650 if (mcs
->rx_mask
[3])
3652 if (mcs
->rx_mask
[2])
3654 if (mcs
->rx_mask
[1])
3660 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
3661 * @local: mac80211 hw info struct
3662 * @status: RX status
3663 * @mpdu_len: total MPDU length (including FCS)
3664 * @mpdu_offset: offset into MPDU to calculate timestamp at
3666 * This function calculates the RX timestamp at the given MPDU offset, taking
3667 * into account what the RX timestamp was. An offset of 0 will just normalize
3668 * the timestamp to TSF at beginning of MPDU reception.
3670 u64
ieee80211_calculate_rx_timestamp(struct ieee80211_local
*local
,
3671 struct ieee80211_rx_status
*status
,
3672 unsigned int mpdu_len
,
3673 unsigned int mpdu_offset
)
3675 u64 ts
= status
->mactime
;
3676 struct rate_info ri
;
3680 if (WARN_ON(!ieee80211_have_rx_timestamp(status
)))
3683 memset(&ri
, 0, sizeof(ri
));
3687 /* Fill cfg80211 rate info */
3688 switch (status
->encoding
) {
3690 ri
.flags
|= RATE_INFO_FLAGS_HE_MCS
;
3691 ri
.mcs
= status
->rate_idx
;
3692 ri
.nss
= status
->nss
;
3693 ri
.he_ru_alloc
= status
->he_ru
;
3694 if (status
->enc_flags
& RX_ENC_FLAG_SHORT_GI
)
3695 ri
.flags
|= RATE_INFO_FLAGS_SHORT_GI
;
3698 * See P802.11ax_D6.0, section 27.3.4 for
3701 if (status
->flag
& RX_FLAG_MACTIME_PLCP_START
) {
3707 * For HE MU PPDU, add the HE-SIG-B.
3708 * For HE ER PPDU, add 8us for the HE-SIG-A.
3709 * For HE TB PPDU, add 4us for the HE-STF.
3710 * Add the HE-LTF durations - variable.
3716 ri
.mcs
= status
->rate_idx
;
3717 ri
.flags
|= RATE_INFO_FLAGS_MCS
;
3718 if (status
->enc_flags
& RX_ENC_FLAG_SHORT_GI
)
3719 ri
.flags
|= RATE_INFO_FLAGS_SHORT_GI
;
3722 * See P802.11REVmd_D3.0, section 19.3.2 for
3725 if (status
->flag
& RX_FLAG_MACTIME_PLCP_START
) {
3727 if (status
->enc_flags
& RX_ENC_FLAG_HT_GF
)
3733 * Add Data HT-LTFs per streams
3734 * TODO: add Extension HT-LTFs, 4us per LTF
3736 n_ltf
= ((ri
.mcs
>> 3) & 3) + 1;
3737 n_ltf
= n_ltf
== 3 ? 4 : n_ltf
;
3743 ri
.flags
|= RATE_INFO_FLAGS_VHT_MCS
;
3744 ri
.mcs
= status
->rate_idx
;
3745 ri
.nss
= status
->nss
;
3746 if (status
->enc_flags
& RX_ENC_FLAG_SHORT_GI
)
3747 ri
.flags
|= RATE_INFO_FLAGS_SHORT_GI
;
3750 * See P802.11REVmd_D3.0, section 21.3.2 for
3753 if (status
->flag
& RX_FLAG_MACTIME_PLCP_START
) {
3758 * Add VHT-LTFs per streams
3760 n_ltf
= (ri
.nss
!= 1) && (ri
.nss
% 2) ?
3761 ri
.nss
+ 1 : ri
.nss
;
3769 case RX_ENC_LEGACY
: {
3770 struct ieee80211_supported_band
*sband
;
3774 switch (status
->bw
) {
3775 case RATE_INFO_BW_10
:
3778 case RATE_INFO_BW_5
:
3783 sband
= local
->hw
.wiphy
->bands
[status
->band
];
3784 bitrate
= sband
->bitrates
[status
->rate_idx
].bitrate
;
3785 ri
.legacy
= DIV_ROUND_UP(bitrate
, (1 << shift
));
3787 if (status
->flag
& RX_FLAG_MACTIME_PLCP_START
) {
3788 if (status
->band
== NL80211_BAND_5GHZ
) {
3791 } else if (status
->enc_flags
& RX_ENC_FLAG_SHORTPRE
) {
3801 rate
= cfg80211_calculate_bitrate(&ri
);
3802 if (WARN_ONCE(!rate
,
3803 "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
3804 (unsigned long long)status
->flag
, status
->rate_idx
,
3808 /* rewind from end of MPDU */
3809 if (status
->flag
& RX_FLAG_MACTIME_END
)
3810 ts
-= mpdu_len
* 8 * 10 / rate
;
3812 ts
+= mpdu_offset
* 8 * 10 / rate
;
3817 void ieee80211_dfs_cac_cancel(struct ieee80211_local
*local
)
3819 struct ieee80211_sub_if_data
*sdata
;
3820 struct cfg80211_chan_def chandef
;
3822 /* for interface list, to avoid linking iflist_mtx and chanctx_mtx */
3823 lockdep_assert_wiphy(local
->hw
.wiphy
);
3825 mutex_lock(&local
->mtx
);
3826 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
3827 /* it might be waiting for the local->mtx, but then
3828 * by the time it gets it, sdata->wdev.cac_started
3829 * will no longer be true
3831 cancel_delayed_work(&sdata
->dfs_cac_timer_work
);
3833 if (sdata
->wdev
.cac_started
) {
3834 chandef
= sdata
->vif
.bss_conf
.chandef
;
3835 ieee80211_vif_release_channel(sdata
);
3836 cfg80211_cac_event(sdata
->dev
,
3838 NL80211_RADAR_CAC_ABORTED
,
3842 mutex_unlock(&local
->mtx
);
3845 void ieee80211_dfs_radar_detected_work(struct work_struct
*work
)
3847 struct ieee80211_local
*local
=
3848 container_of(work
, struct ieee80211_local
, radar_detected_work
);
3849 struct cfg80211_chan_def chandef
= local
->hw
.conf
.chandef
;
3850 struct ieee80211_chanctx
*ctx
;
3851 int num_chanctx
= 0;
3853 mutex_lock(&local
->chanctx_mtx
);
3854 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
3855 if (ctx
->replace_state
== IEEE80211_CHANCTX_REPLACES_OTHER
)
3859 chandef
= ctx
->conf
.def
;
3861 mutex_unlock(&local
->chanctx_mtx
);
3863 wiphy_lock(local
->hw
.wiphy
);
3864 ieee80211_dfs_cac_cancel(local
);
3865 wiphy_unlock(local
->hw
.wiphy
);
3867 if (num_chanctx
> 1)
3868 /* XXX: multi-channel is not supported yet */
3871 cfg80211_radar_event(local
->hw
.wiphy
, &chandef
, GFP_KERNEL
);
3874 void ieee80211_radar_detected(struct ieee80211_hw
*hw
)
3876 struct ieee80211_local
*local
= hw_to_local(hw
);
3878 trace_api_radar_detected(local
);
3880 schedule_work(&local
->radar_detected_work
);
3882 EXPORT_SYMBOL(ieee80211_radar_detected
);
3884 u32
ieee80211_chandef_downgrade(struct cfg80211_chan_def
*c
)
3890 case NL80211_CHAN_WIDTH_20
:
3891 c
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
3892 ret
= IEEE80211_STA_DISABLE_HT
| IEEE80211_STA_DISABLE_VHT
;
3894 case NL80211_CHAN_WIDTH_40
:
3895 c
->width
= NL80211_CHAN_WIDTH_20
;
3896 c
->center_freq1
= c
->chan
->center_freq
;
3897 ret
= IEEE80211_STA_DISABLE_40MHZ
|
3898 IEEE80211_STA_DISABLE_VHT
;
3900 case NL80211_CHAN_WIDTH_80
:
3901 tmp
= (30 + c
->chan
->center_freq
- c
->center_freq1
)/20;
3905 c
->center_freq1
= c
->center_freq1
- 20 + 40 * tmp
;
3906 c
->width
= NL80211_CHAN_WIDTH_40
;
3907 ret
= IEEE80211_STA_DISABLE_VHT
;
3909 case NL80211_CHAN_WIDTH_80P80
:
3910 c
->center_freq2
= 0;
3911 c
->width
= NL80211_CHAN_WIDTH_80
;
3912 ret
= IEEE80211_STA_DISABLE_80P80MHZ
|
3913 IEEE80211_STA_DISABLE_160MHZ
;
3915 case NL80211_CHAN_WIDTH_160
:
3917 tmp
= (70 + c
->chan
->center_freq
- c
->center_freq1
)/20;
3920 c
->center_freq1
= c
->center_freq1
- 40 + 80 * tmp
;
3921 c
->width
= NL80211_CHAN_WIDTH_80
;
3922 ret
= IEEE80211_STA_DISABLE_80P80MHZ
|
3923 IEEE80211_STA_DISABLE_160MHZ
;
3926 case NL80211_CHAN_WIDTH_20_NOHT
:
3928 c
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
3929 ret
= IEEE80211_STA_DISABLE_HT
| IEEE80211_STA_DISABLE_VHT
;
3931 case NL80211_CHAN_WIDTH_1
:
3932 case NL80211_CHAN_WIDTH_2
:
3933 case NL80211_CHAN_WIDTH_4
:
3934 case NL80211_CHAN_WIDTH_8
:
3935 case NL80211_CHAN_WIDTH_16
:
3936 case NL80211_CHAN_WIDTH_5
:
3937 case NL80211_CHAN_WIDTH_10
:
3940 ret
= IEEE80211_STA_DISABLE_HT
| IEEE80211_STA_DISABLE_VHT
;
3944 WARN_ON_ONCE(!cfg80211_chandef_valid(c
));
3950 * Returns true if smps_mode_new is strictly more restrictive than
3953 bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old
,
3954 enum ieee80211_smps_mode smps_mode_new
)
3956 if (WARN_ON_ONCE(smps_mode_old
== IEEE80211_SMPS_AUTOMATIC
||
3957 smps_mode_new
== IEEE80211_SMPS_AUTOMATIC
))
3960 switch (smps_mode_old
) {
3961 case IEEE80211_SMPS_STATIC
:
3963 case IEEE80211_SMPS_DYNAMIC
:
3964 return smps_mode_new
== IEEE80211_SMPS_STATIC
;
3965 case IEEE80211_SMPS_OFF
:
3966 return smps_mode_new
!= IEEE80211_SMPS_OFF
;
3974 int ieee80211_send_action_csa(struct ieee80211_sub_if_data
*sdata
,
3975 struct cfg80211_csa_settings
*csa_settings
)
3977 struct sk_buff
*skb
;
3978 struct ieee80211_mgmt
*mgmt
;
3979 struct ieee80211_local
*local
= sdata
->local
;
3981 int hdr_len
= offsetofend(struct ieee80211_mgmt
,
3982 u
.action
.u
.chan_switch
);
3985 if (sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
&&
3986 sdata
->vif
.type
!= NL80211_IFTYPE_MESH_POINT
)
3989 skb
= dev_alloc_skb(local
->tx_headroom
+ hdr_len
+
3990 5 + /* channel switch announcement element */
3991 3 + /* secondary channel offset element */
3992 5 + /* wide bandwidth channel switch announcement */
3993 8); /* mesh channel switch parameters element */
3997 skb_reserve(skb
, local
->tx_headroom
);
3998 mgmt
= skb_put_zero(skb
, hdr_len
);
3999 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
4000 IEEE80211_STYPE_ACTION
);
4002 eth_broadcast_addr(mgmt
->da
);
4003 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
4004 if (ieee80211_vif_is_mesh(&sdata
->vif
)) {
4005 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
4007 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
4008 memcpy(mgmt
->bssid
, ifibss
->bssid
, ETH_ALEN
);
4010 mgmt
->u
.action
.category
= WLAN_CATEGORY_SPECTRUM_MGMT
;
4011 mgmt
->u
.action
.u
.chan_switch
.action_code
= WLAN_ACTION_SPCT_CHL_SWITCH
;
4012 pos
= skb_put(skb
, 5);
4013 *pos
++ = WLAN_EID_CHANNEL_SWITCH
; /* EID */
4014 *pos
++ = 3; /* IE length */
4015 *pos
++ = csa_settings
->block_tx
? 1 : 0; /* CSA mode */
4016 freq
= csa_settings
->chandef
.chan
->center_freq
;
4017 *pos
++ = ieee80211_frequency_to_channel(freq
); /* channel */
4018 *pos
++ = csa_settings
->count
; /* count */
4020 if (csa_settings
->chandef
.width
== NL80211_CHAN_WIDTH_40
) {
4021 enum nl80211_channel_type ch_type
;
4024 *pos
++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET
; /* EID */
4025 *pos
++ = 1; /* IE length */
4026 ch_type
= cfg80211_get_chandef_type(&csa_settings
->chandef
);
4027 if (ch_type
== NL80211_CHAN_HT40PLUS
)
4028 *pos
++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE
;
4030 *pos
++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
4033 if (ieee80211_vif_is_mesh(&sdata
->vif
)) {
4034 struct ieee80211_if_mesh
*ifmsh
= &sdata
->u
.mesh
;
4037 *pos
++ = WLAN_EID_CHAN_SWITCH_PARAM
; /* EID */
4038 *pos
++ = 6; /* IE length */
4039 *pos
++ = sdata
->u
.mesh
.mshcfg
.dot11MeshTTL
; /* Mesh TTL */
4040 *pos
= 0x00; /* Mesh Flag: Tx Restrict, Initiator, Reason */
4041 *pos
|= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR
;
4042 *pos
++ |= csa_settings
->block_tx
?
4043 WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT
: 0x00;
4044 put_unaligned_le16(WLAN_REASON_MESH_CHAN
, pos
); /* Reason Cd */
4046 put_unaligned_le16(ifmsh
->pre_value
, pos
);/* Precedence Value */
4050 if (csa_settings
->chandef
.width
== NL80211_CHAN_WIDTH_80
||
4051 csa_settings
->chandef
.width
== NL80211_CHAN_WIDTH_80P80
||
4052 csa_settings
->chandef
.width
== NL80211_CHAN_WIDTH_160
) {
4054 ieee80211_ie_build_wide_bw_cs(pos
, &csa_settings
->chandef
);
4057 ieee80211_tx_skb(sdata
, skb
);
4061 bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme
*cs
)
4063 return !(cs
== NULL
|| cs
->cipher
== 0 ||
4064 cs
->hdr_len
< cs
->pn_len
+ cs
->pn_off
||
4065 cs
->hdr_len
<= cs
->key_idx_off
||
4066 cs
->key_idx_shift
> 7 ||
4067 cs
->key_idx_mask
== 0);
4070 bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme
*cs
, int n
)
4074 /* Ensure we have enough iftype bitmap space for all iftype values */
4075 WARN_ON((NUM_NL80211_IFTYPES
/ 8 + 1) > sizeof(cs
[0].iftype
));
4077 for (i
= 0; i
< n
; i
++)
4078 if (!ieee80211_cs_valid(&cs
[i
]))
4084 const struct ieee80211_cipher_scheme
*
4085 ieee80211_cs_get(struct ieee80211_local
*local
, u32 cipher
,
4086 enum nl80211_iftype iftype
)
4088 const struct ieee80211_cipher_scheme
*l
= local
->hw
.cipher_schemes
;
4089 int n
= local
->hw
.n_cipher_schemes
;
4091 const struct ieee80211_cipher_scheme
*cs
= NULL
;
4093 for (i
= 0; i
< n
; i
++) {
4094 if (l
[i
].cipher
== cipher
) {
4100 if (!cs
|| !(cs
->iftype
& BIT(iftype
)))
4106 int ieee80211_cs_headroom(struct ieee80211_local
*local
,
4107 struct cfg80211_crypto_settings
*crypto
,
4108 enum nl80211_iftype iftype
)
4110 const struct ieee80211_cipher_scheme
*cs
;
4111 int headroom
= IEEE80211_ENCRYPT_HEADROOM
;
4114 for (i
= 0; i
< crypto
->n_ciphers_pairwise
; i
++) {
4115 cs
= ieee80211_cs_get(local
, crypto
->ciphers_pairwise
[i
],
4118 if (cs
&& headroom
< cs
->hdr_len
)
4119 headroom
= cs
->hdr_len
;
4122 cs
= ieee80211_cs_get(local
, crypto
->cipher_group
, iftype
);
4123 if (cs
&& headroom
< cs
->hdr_len
)
4124 headroom
= cs
->hdr_len
;
4130 ieee80211_extend_noa_desc(struct ieee80211_noa_data
*data
, u32 tsf
, int i
)
4132 s32 end
= data
->desc
[i
].start
+ data
->desc
[i
].duration
- (tsf
+ 1);
4139 if (data
->count
[i
] == 1)
4142 if (data
->desc
[i
].interval
== 0)
4145 /* End time is in the past, check for repetitions */
4146 skip
= DIV_ROUND_UP(-end
, data
->desc
[i
].interval
);
4147 if (data
->count
[i
] < 255) {
4148 if (data
->count
[i
] <= skip
) {
4153 data
->count
[i
] -= skip
;
4156 data
->desc
[i
].start
+= skip
* data
->desc
[i
].interval
;
4162 ieee80211_extend_absent_time(struct ieee80211_noa_data
*data
, u32 tsf
,
4168 for (i
= 0; i
< IEEE80211_P2P_NOA_DESC_MAX
; i
++) {
4171 if (!data
->count
[i
])
4174 if (ieee80211_extend_noa_desc(data
, tsf
+ *offset
, i
))
4177 cur
= data
->desc
[i
].start
- tsf
;
4181 cur
= data
->desc
[i
].start
+ data
->desc
[i
].duration
- tsf
;
4190 ieee80211_get_noa_absent_time(struct ieee80211_noa_data
*data
, u32 tsf
)
4195 * arbitrary limit, used to avoid infinite loops when combined NoA
4196 * descriptors cover the full time period.
4200 ieee80211_extend_absent_time(data
, tsf
, &offset
);
4202 if (!ieee80211_extend_absent_time(data
, tsf
, &offset
))
4206 } while (tries
< max_tries
);
4211 void ieee80211_update_p2p_noa(struct ieee80211_noa_data
*data
, u32 tsf
)
4213 u32 next_offset
= BIT(31) - 1;
4217 data
->has_next_tsf
= false;
4218 for (i
= 0; i
< IEEE80211_P2P_NOA_DESC_MAX
; i
++) {
4221 if (!data
->count
[i
])
4224 ieee80211_extend_noa_desc(data
, tsf
, i
);
4225 start
= data
->desc
[i
].start
- tsf
;
4227 data
->absent
|= BIT(i
);
4229 if (next_offset
> start
)
4230 next_offset
= start
;
4232 data
->has_next_tsf
= true;
4236 next_offset
= ieee80211_get_noa_absent_time(data
, tsf
);
4238 data
->next_tsf
= tsf
+ next_offset
;
4240 EXPORT_SYMBOL(ieee80211_update_p2p_noa
);
4242 int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr
*attr
,
4243 struct ieee80211_noa_data
*data
, u32 tsf
)
4248 memset(data
, 0, sizeof(*data
));
4250 for (i
= 0; i
< IEEE80211_P2P_NOA_DESC_MAX
; i
++) {
4251 const struct ieee80211_p2p_noa_desc
*desc
= &attr
->desc
[i
];
4253 if (!desc
->count
|| !desc
->duration
)
4256 data
->count
[i
] = desc
->count
;
4257 data
->desc
[i
].start
= le32_to_cpu(desc
->start_time
);
4258 data
->desc
[i
].duration
= le32_to_cpu(desc
->duration
);
4259 data
->desc
[i
].interval
= le32_to_cpu(desc
->interval
);
4261 if (data
->count
[i
] > 1 &&
4262 data
->desc
[i
].interval
< data
->desc
[i
].duration
)
4265 ieee80211_extend_noa_desc(data
, tsf
, i
);
4270 ieee80211_update_p2p_noa(data
, tsf
);
4274 EXPORT_SYMBOL(ieee80211_parse_p2p_noa
);
4276 void ieee80211_recalc_dtim(struct ieee80211_local
*local
,
4277 struct ieee80211_sub_if_data
*sdata
)
4279 u64 tsf
= drv_get_tsf(local
, sdata
);
4281 u16 beacon_int
= sdata
->vif
.bss_conf
.beacon_int
* 1024;
4282 u8 dtim_period
= sdata
->vif
.bss_conf
.dtim_period
;
4286 if (tsf
== -1ULL || !beacon_int
|| !dtim_period
)
4289 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
4290 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
) {
4294 ps
= &sdata
->bss
->ps
;
4295 } else if (ieee80211_vif_is_mesh(&sdata
->vif
)) {
4296 ps
= &sdata
->u
.mesh
.ps
;
4302 * actually finds last dtim_count, mac80211 will update in
4303 * __beacon_add_tim().
4304 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
4306 do_div(tsf
, beacon_int
);
4307 bcns_from_dtim
= do_div(tsf
, dtim_period
);
4308 /* just had a DTIM */
4309 if (!bcns_from_dtim
)
4312 dtim_count
= dtim_period
- bcns_from_dtim
;
4314 ps
->dtim_count
= dtim_count
;
4317 static u8
ieee80211_chanctx_radar_detect(struct ieee80211_local
*local
,
4318 struct ieee80211_chanctx
*ctx
)
4320 struct ieee80211_sub_if_data
*sdata
;
4321 u8 radar_detect
= 0;
4323 lockdep_assert_held(&local
->chanctx_mtx
);
4325 if (WARN_ON(ctx
->replace_state
== IEEE80211_CHANCTX_WILL_BE_REPLACED
))
4328 list_for_each_entry(sdata
, &ctx
->reserved_vifs
, reserved_chanctx_list
)
4329 if (sdata
->reserved_radar_required
)
4330 radar_detect
|= BIT(sdata
->reserved_chandef
.width
);
4333 * An in-place reservation context should not have any assigned vifs
4334 * until it replaces the other context.
4336 WARN_ON(ctx
->replace_state
== IEEE80211_CHANCTX_REPLACES_OTHER
&&
4337 !list_empty(&ctx
->assigned_vifs
));
4339 list_for_each_entry(sdata
, &ctx
->assigned_vifs
, assigned_chanctx_list
)
4340 if (sdata
->radar_required
)
4341 radar_detect
|= BIT(sdata
->vif
.bss_conf
.chandef
.width
);
4343 return radar_detect
;
4346 int ieee80211_check_combinations(struct ieee80211_sub_if_data
*sdata
,
4347 const struct cfg80211_chan_def
*chandef
,
4348 enum ieee80211_chanctx_mode chanmode
,
4351 struct ieee80211_local
*local
= sdata
->local
;
4352 struct ieee80211_sub_if_data
*sdata_iter
;
4353 enum nl80211_iftype iftype
= sdata
->wdev
.iftype
;
4354 struct ieee80211_chanctx
*ctx
;
4356 struct iface_combination_params params
= {
4357 .radar_detect
= radar_detect
,
4360 lockdep_assert_held(&local
->chanctx_mtx
);
4362 if (WARN_ON(hweight32(radar_detect
) > 1))
4365 if (WARN_ON(chandef
&& chanmode
== IEEE80211_CHANCTX_SHARED
&&
4369 if (WARN_ON(iftype
>= NUM_NL80211_IFTYPES
))
4372 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
4373 sdata
->vif
.type
== NL80211_IFTYPE_MESH_POINT
) {
4375 * always passing this is harmless, since it'll be the
4376 * same value that cfg80211 finds if it finds the same
4377 * interface ... and that's always allowed
4379 params
.new_beacon_int
= sdata
->vif
.bss_conf
.beacon_int
;
4382 /* Always allow software iftypes */
4383 if (cfg80211_iftype_allowed(local
->hw
.wiphy
, iftype
, 0, 1)) {
4390 params
.num_different_channels
= 1;
4392 if (iftype
!= NL80211_IFTYPE_UNSPECIFIED
)
4393 params
.iftype_num
[iftype
] = 1;
4395 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
4396 if (ctx
->replace_state
== IEEE80211_CHANCTX_WILL_BE_REPLACED
)
4398 params
.radar_detect
|=
4399 ieee80211_chanctx_radar_detect(local
, ctx
);
4400 if (ctx
->mode
== IEEE80211_CHANCTX_EXCLUSIVE
) {
4401 params
.num_different_channels
++;
4404 if (chandef
&& chanmode
== IEEE80211_CHANCTX_SHARED
&&
4405 cfg80211_chandef_compatible(chandef
,
4408 params
.num_different_channels
++;
4411 list_for_each_entry_rcu(sdata_iter
, &local
->interfaces
, list
) {
4412 struct wireless_dev
*wdev_iter
;
4414 wdev_iter
= &sdata_iter
->wdev
;
4416 if (sdata_iter
== sdata
||
4417 !ieee80211_sdata_running(sdata_iter
) ||
4418 cfg80211_iftype_allowed(local
->hw
.wiphy
,
4419 wdev_iter
->iftype
, 0, 1))
4422 params
.iftype_num
[wdev_iter
->iftype
]++;
4426 if (total
== 1 && !params
.radar_detect
)
4429 return cfg80211_check_combinations(local
->hw
.wiphy
, ¶ms
);
4433 ieee80211_iter_max_chans(const struct ieee80211_iface_combination
*c
,
4436 u32
*max_num_different_channels
= data
;
4438 *max_num_different_channels
= max(*max_num_different_channels
,
4439 c
->num_different_channels
);
4442 int ieee80211_max_num_channels(struct ieee80211_local
*local
)
4444 struct ieee80211_sub_if_data
*sdata
;
4445 struct ieee80211_chanctx
*ctx
;
4446 u32 max_num_different_channels
= 1;
4448 struct iface_combination_params params
= {0};
4450 lockdep_assert_held(&local
->chanctx_mtx
);
4452 list_for_each_entry(ctx
, &local
->chanctx_list
, list
) {
4453 if (ctx
->replace_state
== IEEE80211_CHANCTX_WILL_BE_REPLACED
)
4456 params
.num_different_channels
++;
4458 params
.radar_detect
|=
4459 ieee80211_chanctx_radar_detect(local
, ctx
);
4462 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
)
4463 params
.iftype_num
[sdata
->wdev
.iftype
]++;
4465 err
= cfg80211_iter_combinations(local
->hw
.wiphy
, ¶ms
,
4466 ieee80211_iter_max_chans
,
4467 &max_num_different_channels
);
4471 return max_num_different_channels
;
4474 void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data
*sdata
,
4475 struct ieee80211_sta_s1g_cap
*caps
,
4476 struct sk_buff
*skb
)
4478 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
4479 struct ieee80211_s1g_cap s1g_capab
;
4483 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
4489 memcpy(s1g_capab
.capab_info
, caps
->cap
, sizeof(caps
->cap
));
4490 memcpy(s1g_capab
.supp_mcs_nss
, caps
->nss_mcs
, sizeof(caps
->nss_mcs
));
4492 /* override the capability info */
4493 for (i
= 0; i
< sizeof(ifmgd
->s1g_capa
.capab_info
); i
++) {
4494 u8 mask
= ifmgd
->s1g_capa_mask
.capab_info
[i
];
4496 s1g_capab
.capab_info
[i
] &= ~mask
;
4497 s1g_capab
.capab_info
[i
] |= ifmgd
->s1g_capa
.capab_info
[i
] & mask
;
4500 /* then MCS and NSS set */
4501 for (i
= 0; i
< sizeof(ifmgd
->s1g_capa
.supp_mcs_nss
); i
++) {
4502 u8 mask
= ifmgd
->s1g_capa_mask
.supp_mcs_nss
[i
];
4504 s1g_capab
.supp_mcs_nss
[i
] &= ~mask
;
4505 s1g_capab
.supp_mcs_nss
[i
] |=
4506 ifmgd
->s1g_capa
.supp_mcs_nss
[i
] & mask
;
4509 pos
= skb_put(skb
, 2 + sizeof(s1g_capab
));
4510 *pos
++ = WLAN_EID_S1G_CAPABILITIES
;
4511 *pos
++ = sizeof(s1g_capab
);
4513 memcpy(pos
, &s1g_capab
, sizeof(s1g_capab
));
4516 void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data
*sdata
,
4517 struct sk_buff
*skb
)
4519 u8
*pos
= skb_put(skb
, 3);
4521 *pos
++ = WLAN_EID_AID_REQUEST
;
4526 u8
*ieee80211_add_wmm_info_ie(u8
*buf
, u8 qosinfo
)
4528 *buf
++ = WLAN_EID_VENDOR_SPECIFIC
;
4529 *buf
++ = 7; /* len */
4530 *buf
++ = 0x00; /* Microsoft OUI 00:50:F2 */
4533 *buf
++ = 2; /* WME */
4534 *buf
++ = 0; /* WME info */
4535 *buf
++ = 1; /* WME ver */
4536 *buf
++ = qosinfo
; /* U-APSD no in use */
4541 void ieee80211_txq_get_depth(struct ieee80211_txq
*txq
,
4542 unsigned long *frame_cnt
,
4543 unsigned long *byte_cnt
)
4545 struct txq_info
*txqi
= to_txq_info(txq
);
4546 u32 frag_cnt
= 0, frag_bytes
= 0;
4547 struct sk_buff
*skb
;
4549 skb_queue_walk(&txqi
->frags
, skb
) {
4551 frag_bytes
+= skb
->len
;
4555 *frame_cnt
= txqi
->tin
.backlog_packets
+ frag_cnt
;
4558 *byte_cnt
= txqi
->tin
.backlog_bytes
+ frag_bytes
;
4560 EXPORT_SYMBOL(ieee80211_txq_get_depth
);
4562 const u8 ieee80211_ac_to_qos_mask
[IEEE80211_NUM_ACS
] = {
4563 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO
,
4564 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI
,
4565 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE
,
4566 IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
4569 u16
ieee80211_encode_usf(int listen_interval
)
4571 static const int listen_int_usf
[] = { 1, 10, 1000, 10000 };
4574 /* find greatest USF */
4575 while (usf
< IEEE80211_MAX_USF
) {
4576 if (listen_interval
% listen_int_usf
[usf
+ 1])
4580 ui
= listen_interval
/ listen_int_usf
[usf
];
4582 /* error if there is a remainder. Should've been checked by user */
4583 WARN_ON_ONCE(ui
> IEEE80211_MAX_UI
);
4584 listen_interval
= FIELD_PREP(LISTEN_INT_USF
, usf
) |
4585 FIELD_PREP(LISTEN_INT_UI
, ui
);
4587 return (u16
) listen_interval
;