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