2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * utilities for mac80211
14 #include <net/mac80211.h>
15 #include <linux/netdevice.h>
16 #include <linux/export.h>
17 #include <linux/types.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/etherdevice.h>
21 #include <linux/if_arp.h>
22 #include <linux/bitmap.h>
23 #include <linux/crc32.h>
24 #include <net/net_namespace.h>
25 #include <net/cfg80211.h>
26 #include <net/rtnetlink.h>
28 #include "ieee80211_i.h"
29 #include "driver-ops.h"
36 /* privid for wiphys to determine whether they belong to us or not */
37 void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
39 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
41 struct ieee80211_local *local;
44 local = wiphy_priv(wiphy);
47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
49 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
50 enum nl80211_iftype type)
52 __le16 fc = hdr->frame_control;
54 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
58 if (ieee80211_is_data(fc)) {
59 if (len < 24) /* drop incorrect hdr len (data) */
62 if (ieee80211_has_a4(fc))
64 if (ieee80211_has_tods(fc))
66 if (ieee80211_has_fromds(fc))
72 if (ieee80211_is_mgmt(fc)) {
73 if (len < 24) /* drop incorrect hdr len (mgmt) */
78 if (ieee80211_is_ctl(fc)) {
79 if(ieee80211_is_pspoll(fc))
82 if (ieee80211_is_back_req(fc)) {
84 case NL80211_IFTYPE_STATION:
86 case NL80211_IFTYPE_AP:
87 case NL80211_IFTYPE_AP_VLAN:
90 break; /* fall through to the return */
98 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
101 struct ieee80211_hdr *hdr;
103 skb_queue_walk(&tx->skbs, skb) {
104 hdr = (struct ieee80211_hdr *) skb->data;
105 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
109 int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
110 int rate, int erp, int short_preamble,
115 /* calculate duration (in microseconds, rounded up to next higher
116 * integer if it includes a fractional microsecond) to send frame of
117 * len bytes (does not include FCS) at the given rate. Duration will
120 * rate is in 100 kbps, so divident is multiplied by 10 in the
121 * DIV_ROUND_UP() operations.
123 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
124 * is assumed to be 0 otherwise.
127 if (band == IEEE80211_BAND_5GHZ || erp) {
131 * N_DBPS = DATARATE x 4
132 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
133 * (16 = SIGNAL time, 6 = tail bits)
134 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
137 * 802.11a - 18.5.2: aSIFSTime = 16 usec
138 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
139 * signal ext = 6 usec
141 dur = 16; /* SIFS + signal ext */
142 dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
143 dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
145 /* IEEE 802.11-2012 18.3.2.4: all values above are:
146 * * times 4 for 5 MHz
147 * * times 2 for 10 MHz
151 /* rates should already consider the channel bandwidth,
152 * don't apply divisor again.
154 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
155 4 * rate); /* T_SYM x N_SYM */
158 * 802.11b or 802.11g with 802.11b compatibility:
159 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
160 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
162 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
163 * aSIFSTime = 10 usec
164 * aPreambleLength = 144 usec or 72 usec with short preamble
165 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
167 dur = 10; /* aSIFSTime = 10 usec */
168 dur += short_preamble ? (72 + 24) : (144 + 48);
170 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
176 /* Exported duration function for driver use */
177 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
178 struct ieee80211_vif *vif,
179 enum ieee80211_band band,
181 struct ieee80211_rate *rate)
183 struct ieee80211_sub_if_data *sdata;
186 bool short_preamble = false;
190 sdata = vif_to_sdata(vif);
191 short_preamble = sdata->vif.bss_conf.use_short_preamble;
192 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
193 erp = rate->flags & IEEE80211_RATE_ERP_G;
194 shift = ieee80211_vif_get_shift(vif);
197 dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
198 short_preamble, shift);
200 return cpu_to_le16(dur);
202 EXPORT_SYMBOL(ieee80211_generic_frame_duration);
204 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
205 struct ieee80211_vif *vif, size_t frame_len,
206 const struct ieee80211_tx_info *frame_txctl)
208 struct ieee80211_local *local = hw_to_local(hw);
209 struct ieee80211_rate *rate;
210 struct ieee80211_sub_if_data *sdata;
212 int erp, shift = 0, bitrate;
214 struct ieee80211_supported_band *sband;
216 sband = local->hw.wiphy->bands[frame_txctl->band];
218 short_preamble = false;
220 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
224 sdata = vif_to_sdata(vif);
225 short_preamble = sdata->vif.bss_conf.use_short_preamble;
226 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
227 erp = rate->flags & IEEE80211_RATE_ERP_G;
228 shift = ieee80211_vif_get_shift(vif);
231 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
234 dur = ieee80211_frame_duration(sband->band, 10, bitrate,
235 erp, short_preamble, shift);
236 /* Data frame duration */
237 dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
238 erp, short_preamble, shift);
240 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
241 erp, short_preamble, shift);
243 return cpu_to_le16(dur);
245 EXPORT_SYMBOL(ieee80211_rts_duration);
247 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
248 struct ieee80211_vif *vif,
250 const struct ieee80211_tx_info *frame_txctl)
252 struct ieee80211_local *local = hw_to_local(hw);
253 struct ieee80211_rate *rate;
254 struct ieee80211_sub_if_data *sdata;
256 int erp, shift = 0, bitrate;
258 struct ieee80211_supported_band *sband;
260 sband = local->hw.wiphy->bands[frame_txctl->band];
262 short_preamble = false;
264 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
267 sdata = vif_to_sdata(vif);
268 short_preamble = sdata->vif.bss_conf.use_short_preamble;
269 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
270 erp = rate->flags & IEEE80211_RATE_ERP_G;
271 shift = ieee80211_vif_get_shift(vif);
274 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
276 /* Data frame duration */
277 dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
278 erp, short_preamble, shift);
279 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
281 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
282 erp, short_preamble, shift);
285 return cpu_to_le16(dur);
287 EXPORT_SYMBOL(ieee80211_ctstoself_duration);
289 void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
291 struct ieee80211_sub_if_data *sdata;
292 int n_acs = IEEE80211_NUM_ACS;
294 if (local->hw.queues < IEEE80211_NUM_ACS)
297 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
303 if (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state))
306 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
307 local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
310 for (ac = 0; ac < n_acs; ac++) {
311 int ac_queue = sdata->vif.hw_queue[ac];
313 if (ac_queue == queue ||
314 (sdata->vif.cab_queue == queue &&
315 local->queue_stop_reasons[ac_queue] == 0 &&
316 skb_queue_empty(&local->pending[ac_queue])))
317 netif_wake_subqueue(sdata->dev, ac);
322 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
323 enum queue_stop_reason reason)
325 struct ieee80211_local *local = hw_to_local(hw);
327 trace_wake_queue(local, queue, reason);
329 if (WARN_ON(queue >= hw->queues))
332 if (!test_bit(reason, &local->queue_stop_reasons[queue]))
335 __clear_bit(reason, &local->queue_stop_reasons[queue]);
337 if (local->queue_stop_reasons[queue] != 0)
338 /* someone still has this queue stopped */
341 if (skb_queue_empty(&local->pending[queue])) {
343 ieee80211_propagate_queue_wake(local, queue);
346 tasklet_schedule(&local->tx_pending_tasklet);
349 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
350 enum queue_stop_reason reason)
352 struct ieee80211_local *local = hw_to_local(hw);
355 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
356 __ieee80211_wake_queue(hw, queue, reason);
357 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
360 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
362 ieee80211_wake_queue_by_reason(hw, queue,
363 IEEE80211_QUEUE_STOP_REASON_DRIVER);
365 EXPORT_SYMBOL(ieee80211_wake_queue);
367 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
368 enum queue_stop_reason reason)
370 struct ieee80211_local *local = hw_to_local(hw);
371 struct ieee80211_sub_if_data *sdata;
372 int n_acs = IEEE80211_NUM_ACS;
374 trace_stop_queue(local, queue, reason);
376 if (WARN_ON(queue >= hw->queues))
379 if (test_bit(reason, &local->queue_stop_reasons[queue]))
382 __set_bit(reason, &local->queue_stop_reasons[queue]);
384 if (local->hw.queues < IEEE80211_NUM_ACS)
388 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
394 for (ac = 0; ac < n_acs; ac++) {
395 if (sdata->vif.hw_queue[ac] == queue ||
396 sdata->vif.cab_queue == queue)
397 netif_stop_subqueue(sdata->dev, ac);
403 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
404 enum queue_stop_reason reason)
406 struct ieee80211_local *local = hw_to_local(hw);
409 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
410 __ieee80211_stop_queue(hw, queue, reason);
411 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
414 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
416 ieee80211_stop_queue_by_reason(hw, queue,
417 IEEE80211_QUEUE_STOP_REASON_DRIVER);
419 EXPORT_SYMBOL(ieee80211_stop_queue);
421 void ieee80211_add_pending_skb(struct ieee80211_local *local,
424 struct ieee80211_hw *hw = &local->hw;
426 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
427 int queue = info->hw_queue;
429 if (WARN_ON(!info->control.vif)) {
430 ieee80211_free_txskb(&local->hw, skb);
434 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
435 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
436 __skb_queue_tail(&local->pending[queue], skb);
437 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
438 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
441 void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
442 struct sk_buff_head *skbs,
443 void (*fn)(void *data), void *data)
445 struct ieee80211_hw *hw = &local->hw;
450 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
451 while ((skb = skb_dequeue(skbs))) {
452 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
454 if (WARN_ON(!info->control.vif)) {
455 ieee80211_free_txskb(&local->hw, skb);
459 queue = info->hw_queue;
461 __ieee80211_stop_queue(hw, queue,
462 IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
464 __skb_queue_tail(&local->pending[queue], skb);
470 for (i = 0; i < hw->queues; i++)
471 __ieee80211_wake_queue(hw, i,
472 IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
473 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
476 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
477 unsigned long queues,
478 enum queue_stop_reason reason)
480 struct ieee80211_local *local = hw_to_local(hw);
484 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
486 for_each_set_bit(i, &queues, hw->queues)
487 __ieee80211_stop_queue(hw, i, reason);
489 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
492 void ieee80211_stop_queues(struct ieee80211_hw *hw)
494 ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
495 IEEE80211_QUEUE_STOP_REASON_DRIVER);
497 EXPORT_SYMBOL(ieee80211_stop_queues);
499 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
501 struct ieee80211_local *local = hw_to_local(hw);
505 if (WARN_ON(queue >= hw->queues))
508 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
509 ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
510 &local->queue_stop_reasons[queue]);
511 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
514 EXPORT_SYMBOL(ieee80211_queue_stopped);
516 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
517 unsigned long queues,
518 enum queue_stop_reason reason)
520 struct ieee80211_local *local = hw_to_local(hw);
524 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
526 for_each_set_bit(i, &queues, hw->queues)
527 __ieee80211_wake_queue(hw, i, reason);
529 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
532 void ieee80211_wake_queues(struct ieee80211_hw *hw)
534 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
535 IEEE80211_QUEUE_STOP_REASON_DRIVER);
537 EXPORT_SYMBOL(ieee80211_wake_queues);
539 void ieee80211_flush_queues(struct ieee80211_local *local,
540 struct ieee80211_sub_if_data *sdata)
544 if (!local->ops->flush)
547 if (sdata && local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) {
552 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
553 queues |= BIT(sdata->vif.hw_queue[ac]);
554 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
555 queues |= BIT(sdata->vif.cab_queue);
558 queues = BIT(local->hw.queues) - 1;
561 ieee80211_stop_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
562 IEEE80211_QUEUE_STOP_REASON_FLUSH);
564 drv_flush(local, queues, false);
566 ieee80211_wake_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
567 IEEE80211_QUEUE_STOP_REASON_FLUSH);
570 static void __iterate_active_interfaces(struct ieee80211_local *local,
572 void (*iterator)(void *data, u8 *mac,
573 struct ieee80211_vif *vif),
576 struct ieee80211_sub_if_data *sdata;
578 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
579 switch (sdata->vif.type) {
580 case NL80211_IFTYPE_MONITOR:
581 if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
584 case NL80211_IFTYPE_AP_VLAN:
589 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
590 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
592 if (ieee80211_sdata_running(sdata))
593 iterator(data, sdata->vif.addr,
597 sdata = rcu_dereference_check(local->monitor_sdata,
598 lockdep_is_held(&local->iflist_mtx) ||
599 lockdep_rtnl_is_held());
601 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
602 sdata->flags & IEEE80211_SDATA_IN_DRIVER))
603 iterator(data, sdata->vif.addr, &sdata->vif);
606 void ieee80211_iterate_active_interfaces(
607 struct ieee80211_hw *hw, u32 iter_flags,
608 void (*iterator)(void *data, u8 *mac,
609 struct ieee80211_vif *vif),
612 struct ieee80211_local *local = hw_to_local(hw);
614 mutex_lock(&local->iflist_mtx);
615 __iterate_active_interfaces(local, iter_flags, iterator, data);
616 mutex_unlock(&local->iflist_mtx);
618 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
620 void ieee80211_iterate_active_interfaces_atomic(
621 struct ieee80211_hw *hw, u32 iter_flags,
622 void (*iterator)(void *data, u8 *mac,
623 struct ieee80211_vif *vif),
626 struct ieee80211_local *local = hw_to_local(hw);
629 __iterate_active_interfaces(local, iter_flags, iterator, data);
632 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
634 void ieee80211_iterate_active_interfaces_rtnl(
635 struct ieee80211_hw *hw, u32 iter_flags,
636 void (*iterator)(void *data, u8 *mac,
637 struct ieee80211_vif *vif),
640 struct ieee80211_local *local = hw_to_local(hw);
644 __iterate_active_interfaces(local, iter_flags, iterator, data);
646 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
649 * Nothing should have been stuffed into the workqueue during
650 * the suspend->resume cycle. If this WARN is seen then there
651 * is a bug with either the driver suspend or something in
652 * mac80211 stuffing into the workqueue which we haven't yet
653 * cleared during mac80211's suspend cycle.
655 static bool ieee80211_can_queue_work(struct ieee80211_local *local)
657 if (WARN(local->suspended && !local->resuming,
658 "queueing ieee80211 work while going to suspend\n"))
664 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
666 struct ieee80211_local *local = hw_to_local(hw);
668 if (!ieee80211_can_queue_work(local))
671 queue_work(local->workqueue, work);
673 EXPORT_SYMBOL(ieee80211_queue_work);
675 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
676 struct delayed_work *dwork,
679 struct ieee80211_local *local = hw_to_local(hw);
681 if (!ieee80211_can_queue_work(local))
684 queue_delayed_work(local->workqueue, dwork, delay);
686 EXPORT_SYMBOL(ieee80211_queue_delayed_work);
688 u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
689 struct ieee802_11_elems *elems,
693 const u8 *pos = start;
694 bool calc_crc = filter != 0;
695 DECLARE_BITMAP(seen_elems, 256);
698 bitmap_zero(seen_elems, 256);
699 memset(elems, 0, sizeof(*elems));
700 elems->ie_start = start;
701 elems->total_len = len;
705 bool elem_parse_failed;
712 elems->parse_error = true;
718 case WLAN_EID_SUPP_RATES:
719 case WLAN_EID_FH_PARAMS:
720 case WLAN_EID_DS_PARAMS:
721 case WLAN_EID_CF_PARAMS:
723 case WLAN_EID_IBSS_PARAMS:
724 case WLAN_EID_CHALLENGE:
726 case WLAN_EID_ERP_INFO:
727 case WLAN_EID_EXT_SUPP_RATES:
728 case WLAN_EID_HT_CAPABILITY:
729 case WLAN_EID_HT_OPERATION:
730 case WLAN_EID_VHT_CAPABILITY:
731 case WLAN_EID_VHT_OPERATION:
732 case WLAN_EID_MESH_ID:
733 case WLAN_EID_MESH_CONFIG:
734 case WLAN_EID_PEER_MGMT:
739 case WLAN_EID_CHANNEL_SWITCH:
740 case WLAN_EID_EXT_CHANSWITCH_ANN:
741 case WLAN_EID_COUNTRY:
742 case WLAN_EID_PWR_CONSTRAINT:
743 case WLAN_EID_TIMEOUT_INTERVAL:
744 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
745 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
747 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
748 * that if the content gets bigger it might be needed more than once
750 if (test_bit(id, seen_elems)) {
751 elems->parse_error = true;
759 if (calc_crc && id < 64 && (filter & (1ULL << id)))
760 crc = crc32_be(crc, pos - 2, elen + 2);
762 elem_parse_failed = false;
767 elems->ssid_len = elen;
769 case WLAN_EID_SUPP_RATES:
770 elems->supp_rates = pos;
771 elems->supp_rates_len = elen;
773 case WLAN_EID_DS_PARAMS:
775 elems->ds_params = pos;
777 elem_parse_failed = true;
780 if (elen >= sizeof(struct ieee80211_tim_ie)) {
781 elems->tim = (void *)pos;
782 elems->tim_len = elen;
784 elem_parse_failed = true;
786 case WLAN_EID_CHALLENGE:
787 elems->challenge = pos;
788 elems->challenge_len = elen;
790 case WLAN_EID_VENDOR_SPECIFIC:
791 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
793 /* Microsoft OUI (00:50:F2) */
796 crc = crc32_be(crc, pos - 2, elen + 2);
798 if (elen >= 5 && pos[3] == 2) {
799 /* OUI Type 2 - WMM IE */
801 elems->wmm_info = pos;
802 elems->wmm_info_len = elen;
803 } else if (pos[4] == 1) {
804 elems->wmm_param = pos;
805 elems->wmm_param_len = elen;
812 elems->rsn_len = elen;
814 case WLAN_EID_ERP_INFO:
816 elems->erp_info = pos;
818 elem_parse_failed = true;
820 case WLAN_EID_EXT_SUPP_RATES:
821 elems->ext_supp_rates = pos;
822 elems->ext_supp_rates_len = elen;
824 case WLAN_EID_HT_CAPABILITY:
825 if (elen >= sizeof(struct ieee80211_ht_cap))
826 elems->ht_cap_elem = (void *)pos;
828 elem_parse_failed = true;
830 case WLAN_EID_HT_OPERATION:
831 if (elen >= sizeof(struct ieee80211_ht_operation))
832 elems->ht_operation = (void *)pos;
834 elem_parse_failed = true;
836 case WLAN_EID_VHT_CAPABILITY:
837 if (elen >= sizeof(struct ieee80211_vht_cap))
838 elems->vht_cap_elem = (void *)pos;
840 elem_parse_failed = true;
842 case WLAN_EID_VHT_OPERATION:
843 if (elen >= sizeof(struct ieee80211_vht_operation))
844 elems->vht_operation = (void *)pos;
846 elem_parse_failed = true;
848 case WLAN_EID_OPMODE_NOTIF:
850 elems->opmode_notif = pos;
852 elem_parse_failed = true;
854 case WLAN_EID_MESH_ID:
855 elems->mesh_id = pos;
856 elems->mesh_id_len = elen;
858 case WLAN_EID_MESH_CONFIG:
859 if (elen >= sizeof(struct ieee80211_meshconf_ie))
860 elems->mesh_config = (void *)pos;
862 elem_parse_failed = true;
864 case WLAN_EID_PEER_MGMT:
865 elems->peering = pos;
866 elems->peering_len = elen;
868 case WLAN_EID_MESH_AWAKE_WINDOW:
870 elems->awake_window = (void *)pos;
874 elems->preq_len = elen;
878 elems->prep_len = elen;
882 elems->perr_len = elen;
885 if (elen >= sizeof(struct ieee80211_rann_ie))
886 elems->rann = (void *)pos;
888 elem_parse_failed = true;
890 case WLAN_EID_CHANNEL_SWITCH:
891 if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
892 elem_parse_failed = true;
895 elems->ch_switch_ie = (void *)pos;
897 case WLAN_EID_EXT_CHANSWITCH_ANN:
898 if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
899 elem_parse_failed = true;
902 elems->ext_chansw_ie = (void *)pos;
904 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
905 if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
906 elem_parse_failed = true;
909 elems->sec_chan_offs = (void *)pos;
911 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
913 elen != sizeof(*elems->wide_bw_chansw_ie)) {
914 elem_parse_failed = true;
917 elems->wide_bw_chansw_ie = (void *)pos;
919 case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
921 elem_parse_failed = true;
925 * This is a bit tricky, but as we only care about
926 * the wide bandwidth channel switch element, so
927 * just parse it out manually.
929 ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
932 if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
933 elems->wide_bw_chansw_ie =
936 elem_parse_failed = true;
939 case WLAN_EID_COUNTRY:
940 elems->country_elem = pos;
941 elems->country_elem_len = elen;
943 case WLAN_EID_PWR_CONSTRAINT:
945 elem_parse_failed = true;
948 elems->pwr_constr_elem = pos;
950 case WLAN_EID_TIMEOUT_INTERVAL:
951 if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
952 elems->timeout_int = (void *)pos;
954 elem_parse_failed = true;
960 if (elem_parse_failed)
961 elems->parse_error = true;
963 __set_bit(id, seen_elems);
970 elems->parse_error = true;
975 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
978 struct ieee80211_local *local = sdata->local;
979 struct ieee80211_tx_queue_params qparam;
980 struct ieee80211_chanctx_conf *chanctx_conf;
982 bool use_11b, enable_qos;
985 if (!local->ops->conf_tx)
988 if (local->hw.queues < IEEE80211_NUM_ACS)
991 memset(&qparam, 0, sizeof(qparam));
994 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
995 use_11b = (chanctx_conf &&
996 chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ) &&
997 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
1001 * By default disable QoS in STA mode for old access points, which do
1002 * not support 802.11e. New APs will provide proper queue parameters,
1003 * that we will configure later.
1005 enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION);
1007 /* Set defaults according to 802.11-2007 Table 7-37 */
1014 /* Confiure old 802.11b/g medium access rules. */
1015 qparam.cw_max = aCWmax;
1016 qparam.cw_min = aCWmin;
1020 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1021 /* Update if QoS is enabled. */
1024 case IEEE80211_AC_BK:
1025 qparam.cw_max = aCWmax;
1026 qparam.cw_min = aCWmin;
1030 /* never happens but let's not leave undefined */
1032 case IEEE80211_AC_BE:
1033 qparam.cw_max = aCWmax;
1034 qparam.cw_min = aCWmin;
1038 case IEEE80211_AC_VI:
1039 qparam.cw_max = aCWmin;
1040 qparam.cw_min = (aCWmin + 1) / 2 - 1;
1042 qparam.txop = 6016/32;
1044 qparam.txop = 3008/32;
1047 case IEEE80211_AC_VO:
1048 qparam.cw_max = (aCWmin + 1) / 2 - 1;
1049 qparam.cw_min = (aCWmin + 1) / 4 - 1;
1051 qparam.txop = 3264/32;
1053 qparam.txop = 1504/32;
1059 qparam.uapsd = false;
1061 sdata->tx_conf[ac] = qparam;
1062 drv_conf_tx(local, sdata, ac, &qparam);
1065 if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1066 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
1067 sdata->vif.bss_conf.qos = enable_qos;
1069 ieee80211_bss_info_change_notify(sdata,
1074 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1075 u16 transaction, u16 auth_alg, u16 status,
1076 const u8 *extra, size_t extra_len, const u8 *da,
1077 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1080 struct ieee80211_local *local = sdata->local;
1081 struct sk_buff *skb;
1082 struct ieee80211_mgmt *mgmt;
1085 /* 24 + 6 = header + auth_algo + auth_transaction + status_code */
1086 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 6 + extra_len);
1090 skb_reserve(skb, local->hw.extra_tx_headroom);
1092 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
1093 memset(mgmt, 0, 24 + 6);
1094 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1095 IEEE80211_STYPE_AUTH);
1096 memcpy(mgmt->da, da, ETH_ALEN);
1097 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1098 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1099 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1100 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1101 mgmt->u.auth.status_code = cpu_to_le16(status);
1103 memcpy(skb_put(skb, extra_len), extra, extra_len);
1105 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1106 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1107 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1111 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1113 ieee80211_tx_skb(sdata, skb);
1116 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1117 const u8 *bssid, u16 stype, u16 reason,
1118 bool send_frame, u8 *frame_buf)
1120 struct ieee80211_local *local = sdata->local;
1121 struct sk_buff *skb;
1122 struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1125 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1126 mgmt->duration = 0; /* initialize only */
1127 mgmt->seq_ctrl = 0; /* initialize only */
1128 memcpy(mgmt->da, bssid, ETH_ALEN);
1129 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1130 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1131 /* u.deauth.reason_code == u.disassoc.reason_code */
1132 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1135 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1136 IEEE80211_DEAUTH_FRAME_LEN);
1140 skb_reserve(skb, local->hw.extra_tx_headroom);
1143 memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN),
1144 mgmt, IEEE80211_DEAUTH_FRAME_LEN);
1146 if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1147 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1148 IEEE80211_SKB_CB(skb)->flags |=
1149 IEEE80211_TX_INTFL_DONT_ENCRYPT;
1151 ieee80211_tx_skb(sdata, skb);
1155 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1156 size_t buffer_len, const u8 *ie, size_t ie_len,
1157 enum ieee80211_band band, u32 rate_mask,
1158 struct cfg80211_chan_def *chandef)
1160 struct ieee80211_supported_band *sband;
1161 u8 *pos = buffer, *end = buffer + buffer_len;
1162 size_t offset = 0, noffset;
1163 int supp_rates_len, i;
1170 sband = local->hw.wiphy->bands[band];
1171 if (WARN_ON_ONCE(!sband))
1174 rate_flags = ieee80211_chandef_rate_flags(chandef);
1175 shift = ieee80211_chandef_get_shift(chandef);
1178 for (i = 0; i < sband->n_bitrates; i++) {
1179 if ((BIT(i) & rate_mask) == 0)
1180 continue; /* skip rate */
1181 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1184 rates[num_rates++] =
1185 (u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
1189 supp_rates_len = min_t(int, num_rates, 8);
1191 if (end - pos < 2 + supp_rates_len)
1193 *pos++ = WLAN_EID_SUPP_RATES;
1194 *pos++ = supp_rates_len;
1195 memcpy(pos, rates, supp_rates_len);
1196 pos += supp_rates_len;
1198 /* insert "request information" if in custom IEs */
1200 static const u8 before_extrates[] = {
1202 WLAN_EID_SUPP_RATES,
1205 noffset = ieee80211_ie_split(ie, ie_len,
1207 ARRAY_SIZE(before_extrates),
1209 if (end - pos < noffset - offset)
1211 memcpy(pos, ie + offset, noffset - offset);
1212 pos += noffset - offset;
1216 ext_rates_len = num_rates - supp_rates_len;
1217 if (ext_rates_len > 0) {
1218 if (end - pos < 2 + ext_rates_len)
1220 *pos++ = WLAN_EID_EXT_SUPP_RATES;
1221 *pos++ = ext_rates_len;
1222 memcpy(pos, rates + supp_rates_len, ext_rates_len);
1223 pos += ext_rates_len;
1226 if (chandef->chan && sband->band == IEEE80211_BAND_2GHZ) {
1229 *pos++ = WLAN_EID_DS_PARAMS;
1231 *pos++ = ieee80211_frequency_to_channel(
1232 chandef->chan->center_freq);
1235 /* insert custom IEs that go before HT */
1237 static const u8 before_ht[] = {
1239 WLAN_EID_SUPP_RATES,
1241 WLAN_EID_EXT_SUPP_RATES,
1243 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1245 noffset = ieee80211_ie_split(ie, ie_len,
1246 before_ht, ARRAY_SIZE(before_ht),
1248 if (end - pos < noffset - offset)
1250 memcpy(pos, ie + offset, noffset - offset);
1251 pos += noffset - offset;
1255 if (sband->ht_cap.ht_supported) {
1256 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
1258 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1263 * If adding more here, adjust code in main.c
1264 * that calculates local->scan_ies_len.
1267 /* add any remaining custom IEs */
1270 if (end - pos < noffset - offset)
1272 memcpy(pos, ie + offset, noffset - offset);
1273 pos += noffset - offset;
1276 if (sband->vht_cap.vht_supported) {
1277 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
1279 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1280 sband->vht_cap.cap);
1283 return pos - buffer;
1285 WARN_ONCE(1, "not enough space for preq IEs\n");
1286 return pos - buffer;
1289 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1290 u8 *dst, u32 ratemask,
1291 struct ieee80211_channel *chan,
1292 const u8 *ssid, size_t ssid_len,
1293 const u8 *ie, size_t ie_len,
1296 struct ieee80211_local *local = sdata->local;
1297 struct cfg80211_chan_def chandef;
1298 struct sk_buff *skb;
1299 struct ieee80211_mgmt *mgmt;
1303 * Do not send DS Channel parameter for directed probe requests
1304 * in order to maximize the chance that we get a response. Some
1305 * badly-behaved APs don't respond when this parameter is included.
1307 chandef.width = sdata->vif.bss_conf.chandef.width;
1309 chandef.chan = NULL;
1311 chandef.chan = chan;
1313 skb = ieee80211_probereq_get(&local->hw, &sdata->vif,
1314 ssid, ssid_len, 100 + ie_len);
1318 ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
1320 ie, ie_len, chan->band,
1321 ratemask, &chandef);
1322 skb_put(skb, ies_len);
1325 mgmt = (struct ieee80211_mgmt *) skb->data;
1326 memcpy(mgmt->da, dst, ETH_ALEN);
1327 memcpy(mgmt->bssid, dst, ETH_ALEN);
1330 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1335 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
1336 const u8 *ssid, size_t ssid_len,
1337 const u8 *ie, size_t ie_len,
1338 u32 ratemask, bool directed, u32 tx_flags,
1339 struct ieee80211_channel *channel, bool scan)
1341 struct sk_buff *skb;
1343 skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel,
1345 ie, ie_len, directed);
1347 IEEE80211_SKB_CB(skb)->flags |= tx_flags;
1349 ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band);
1351 ieee80211_tx_skb(sdata, skb);
1355 u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1356 struct ieee802_11_elems *elems,
1357 enum ieee80211_band band, u32 *basic_rates)
1359 struct ieee80211_supported_band *sband;
1360 struct ieee80211_rate *bitrates;
1362 u32 supp_rates, rate_flags;
1364 sband = sdata->local->hw.wiphy->bands[band];
1366 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
1367 shift = ieee80211_vif_get_shift(&sdata->vif);
1369 if (WARN_ON(!sband))
1372 bitrates = sband->bitrates;
1373 num_rates = sband->n_bitrates;
1375 for (i = 0; i < elems->supp_rates_len +
1376 elems->ext_supp_rates_len; i++) {
1380 if (i < elems->supp_rates_len)
1381 rate = elems->supp_rates[i];
1382 else if (elems->ext_supp_rates)
1383 rate = elems->ext_supp_rates
1384 [i - elems->supp_rates_len];
1385 own_rate = 5 * (rate & 0x7f);
1386 is_basic = !!(rate & 0x80);
1388 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1391 for (j = 0; j < num_rates; j++) {
1393 if ((rate_flags & sband->bitrates[j].flags)
1397 brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
1400 if (brate == own_rate) {
1401 supp_rates |= BIT(j);
1402 if (basic_rates && is_basic)
1403 *basic_rates |= BIT(j);
1410 void ieee80211_stop_device(struct ieee80211_local *local)
1412 ieee80211_led_radio(local, false);
1413 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
1415 cancel_work_sync(&local->reconfig_filter);
1417 flush_workqueue(local->workqueue);
1421 static void ieee80211_assign_chanctx(struct ieee80211_local *local,
1422 struct ieee80211_sub_if_data *sdata)
1424 struct ieee80211_chanctx_conf *conf;
1425 struct ieee80211_chanctx *ctx;
1427 if (!local->use_chanctx)
1430 mutex_lock(&local->chanctx_mtx);
1431 conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1432 lockdep_is_held(&local->chanctx_mtx));
1434 ctx = container_of(conf, struct ieee80211_chanctx, conf);
1435 drv_assign_vif_chanctx(local, sdata, ctx);
1437 mutex_unlock(&local->chanctx_mtx);
1440 int ieee80211_reconfig(struct ieee80211_local *local)
1442 struct ieee80211_hw *hw = &local->hw;
1443 struct ieee80211_sub_if_data *sdata;
1444 struct ieee80211_chanctx *ctx;
1445 struct sta_info *sta;
1447 bool reconfig_due_to_wowlan = false;
1450 if (local->suspended)
1451 local->resuming = true;
1453 if (local->wowlan) {
1454 res = drv_resume(local);
1455 local->wowlan = false;
1457 local->resuming = false;
1464 * res is 1, which means the driver requested
1465 * to go through a regular reset on wakeup.
1467 reconfig_due_to_wowlan = true;
1470 /* everything else happens only if HW was up & running */
1471 if (!local->open_count)
1475 * Upon resume hardware can sometimes be goofy due to
1476 * various platform / driver / bus issues, so restarting
1477 * the device may at times not work immediately. Propagate
1480 res = drv_start(local);
1482 WARN(local->suspended, "Hardware became unavailable "
1483 "upon resume. This could be a software issue "
1484 "prior to suspend or a hardware issue.\n");
1488 /* setup fragmentation threshold */
1489 drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
1491 /* setup RTS threshold */
1492 drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
1494 /* reset coverage class */
1495 drv_set_coverage_class(local, hw->wiphy->coverage_class);
1497 ieee80211_led_radio(local, true);
1498 ieee80211_mod_tpt_led_trig(local,
1499 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1501 /* add interfaces */
1502 sdata = rtnl_dereference(local->monitor_sdata);
1504 /* in HW restart it exists already */
1505 WARN_ON(local->resuming);
1506 res = drv_add_interface(local, sdata);
1508 rcu_assign_pointer(local->monitor_sdata, NULL);
1514 list_for_each_entry(sdata, &local->interfaces, list) {
1515 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1516 sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1517 ieee80211_sdata_running(sdata))
1518 res = drv_add_interface(local, sdata);
1521 /* add channel contexts */
1522 if (local->use_chanctx) {
1523 mutex_lock(&local->chanctx_mtx);
1524 list_for_each_entry(ctx, &local->chanctx_list, list)
1525 WARN_ON(drv_add_chanctx(local, ctx));
1526 mutex_unlock(&local->chanctx_mtx);
1529 list_for_each_entry(sdata, &local->interfaces, list) {
1530 if (!ieee80211_sdata_running(sdata))
1532 ieee80211_assign_chanctx(local, sdata);
1535 sdata = rtnl_dereference(local->monitor_sdata);
1536 if (sdata && ieee80211_sdata_running(sdata))
1537 ieee80211_assign_chanctx(local, sdata);
1540 mutex_lock(&local->sta_mtx);
1541 list_for_each_entry(sta, &local->sta_list, list) {
1542 enum ieee80211_sta_state state;
1547 /* AP-mode stations will be added later */
1548 if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
1551 for (state = IEEE80211_STA_NOTEXIST;
1552 state < sta->sta_state; state++)
1553 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1556 mutex_unlock(&local->sta_mtx);
1558 /* reconfigure tx conf */
1559 if (hw->queues >= IEEE80211_NUM_ACS) {
1560 list_for_each_entry(sdata, &local->interfaces, list) {
1561 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1562 sdata->vif.type == NL80211_IFTYPE_MONITOR ||
1563 !ieee80211_sdata_running(sdata))
1566 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1567 drv_conf_tx(local, sdata, i,
1568 &sdata->tx_conf[i]);
1572 /* reconfigure hardware */
1573 ieee80211_hw_config(local, ~0);
1575 ieee80211_configure_filter(local);
1577 /* Finally also reconfigure all the BSS information */
1578 list_for_each_entry(sdata, &local->interfaces, list) {
1581 if (!ieee80211_sdata_running(sdata))
1584 /* common change flags for all interface types */
1585 changed = BSS_CHANGED_ERP_CTS_PROT |
1586 BSS_CHANGED_ERP_PREAMBLE |
1587 BSS_CHANGED_ERP_SLOT |
1589 BSS_CHANGED_BASIC_RATES |
1590 BSS_CHANGED_BEACON_INT |
1595 BSS_CHANGED_TXPOWER;
1597 switch (sdata->vif.type) {
1598 case NL80211_IFTYPE_STATION:
1599 changed |= BSS_CHANGED_ASSOC |
1600 BSS_CHANGED_ARP_FILTER |
1603 /* Re-send beacon info report to the driver */
1604 if (sdata->u.mgd.have_beacon)
1605 changed |= BSS_CHANGED_BEACON_INFO;
1608 ieee80211_bss_info_change_notify(sdata, changed);
1609 sdata_unlock(sdata);
1611 case NL80211_IFTYPE_ADHOC:
1612 changed |= BSS_CHANGED_IBSS;
1614 case NL80211_IFTYPE_AP:
1615 changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
1617 if (sdata->vif.type == NL80211_IFTYPE_AP) {
1618 changed |= BSS_CHANGED_AP_PROBE_RESP;
1620 if (rcu_access_pointer(sdata->u.ap.beacon))
1621 drv_start_ap(local, sdata);
1625 case NL80211_IFTYPE_MESH_POINT:
1626 if (sdata->vif.bss_conf.enable_beacon) {
1627 changed |= BSS_CHANGED_BEACON |
1628 BSS_CHANGED_BEACON_ENABLED;
1629 ieee80211_bss_info_change_notify(sdata, changed);
1632 case NL80211_IFTYPE_WDS:
1634 case NL80211_IFTYPE_AP_VLAN:
1635 case NL80211_IFTYPE_MONITOR:
1636 /* ignore virtual */
1638 case NL80211_IFTYPE_P2P_DEVICE:
1639 changed = BSS_CHANGED_IDLE;
1641 case NL80211_IFTYPE_UNSPECIFIED:
1642 case NUM_NL80211_IFTYPES:
1643 case NL80211_IFTYPE_P2P_CLIENT:
1644 case NL80211_IFTYPE_P2P_GO:
1650 ieee80211_recalc_ps(local, -1);
1653 * The sta might be in psm against the ap (e.g. because
1654 * this was the state before a hw restart), so we
1655 * explicitly send a null packet in order to make sure
1656 * it'll sync against the ap (and get out of psm).
1658 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
1659 list_for_each_entry(sdata, &local->interfaces, list) {
1660 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1662 if (!sdata->u.mgd.associated)
1665 ieee80211_send_nullfunc(local, sdata, 0);
1669 /* APs are now beaconing, add back stations */
1670 mutex_lock(&local->sta_mtx);
1671 list_for_each_entry(sta, &local->sta_list, list) {
1672 enum ieee80211_sta_state state;
1677 if (sta->sdata->vif.type != NL80211_IFTYPE_AP)
1680 for (state = IEEE80211_STA_NOTEXIST;
1681 state < sta->sta_state; state++)
1682 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1685 mutex_unlock(&local->sta_mtx);
1688 list_for_each_entry(sdata, &local->interfaces, list)
1689 if (ieee80211_sdata_running(sdata))
1690 ieee80211_enable_keys(sdata);
1693 local->in_reconfig = false;
1696 if (local->monitors == local->open_count && local->monitors > 0)
1697 ieee80211_add_virtual_monitor(local);
1700 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
1701 * sessions can be established after a resume.
1703 * Also tear down aggregation sessions since reconfiguring
1704 * them in a hardware restart scenario is not easily done
1705 * right now, and the hardware will have lost information
1706 * about the sessions, but we and the AP still think they
1707 * are active. This is really a workaround though.
1709 if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
1710 mutex_lock(&local->sta_mtx);
1712 list_for_each_entry(sta, &local->sta_list, list) {
1713 ieee80211_sta_tear_down_BA_sessions(
1714 sta, AGG_STOP_LOCAL_REQUEST);
1715 clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
1718 mutex_unlock(&local->sta_mtx);
1721 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
1722 IEEE80211_QUEUE_STOP_REASON_SUSPEND);
1725 * If this is for hw restart things are still running.
1726 * We may want to change that later, however.
1728 if (!local->suspended || reconfig_due_to_wowlan)
1729 drv_restart_complete(local);
1731 if (!local->suspended)
1735 /* first set suspended false, then resuming */
1736 local->suspended = false;
1738 local->resuming = false;
1740 list_for_each_entry(sdata, &local->interfaces, list) {
1741 if (!ieee80211_sdata_running(sdata))
1743 if (sdata->vif.type == NL80211_IFTYPE_STATION)
1744 ieee80211_sta_restart(sdata);
1747 mod_timer(&local->sta_cleanup, jiffies + 1);
1754 void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
1756 struct ieee80211_sub_if_data *sdata;
1757 struct ieee80211_local *local;
1758 struct ieee80211_key *key;
1763 sdata = vif_to_sdata(vif);
1764 local = sdata->local;
1766 if (WARN_ON(!local->resuming))
1769 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
1772 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
1774 mutex_lock(&local->key_mtx);
1775 list_for_each_entry(key, &sdata->key_list, list)
1776 key->flags |= KEY_FLAG_TAINTED;
1777 mutex_unlock(&local->key_mtx);
1779 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
1781 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
1783 struct ieee80211_local *local = sdata->local;
1784 struct ieee80211_chanctx_conf *chanctx_conf;
1785 struct ieee80211_chanctx *chanctx;
1787 mutex_lock(&local->chanctx_mtx);
1789 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1790 lockdep_is_held(&local->chanctx_mtx));
1792 if (WARN_ON_ONCE(!chanctx_conf))
1795 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
1796 ieee80211_recalc_smps_chanctx(local, chanctx);
1798 mutex_unlock(&local->chanctx_mtx);
1801 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id)
1805 for (i = 0; i < n_ids; i++)
1812 * ieee80211_ie_split - split an IE buffer according to ordering
1814 * @ies: the IE buffer
1815 * @ielen: the length of the IE buffer
1816 * @ids: an array with element IDs that are allowed before
1818 * @n_ids: the size of the element ID array
1819 * @offset: offset where to start splitting in the buffer
1821 * This function splits an IE buffer by updating the @offset
1822 * variable to point to the location where the buffer should be
1825 * It assumes that the given IE buffer is well-formed, this
1826 * has to be guaranteed by the caller!
1828 * It also assumes that the IEs in the buffer are ordered
1829 * correctly, if not the result of using this function will not
1830 * be ordered correctly either, i.e. it does no reordering.
1832 * The function returns the offset where the next part of the
1833 * buffer starts, which may be @ielen if the entire (remainder)
1834 * of the buffer should be used.
1836 size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
1837 const u8 *ids, int n_ids, size_t offset)
1839 size_t pos = offset;
1841 while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos]))
1842 pos += 2 + ies[pos + 1];
1847 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
1849 size_t pos = offset;
1851 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
1852 pos += 2 + ies[pos + 1];
1857 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
1861 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
1863 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
1867 * Scale up threshold values before storing it, as the RSSI averaging
1868 * algorithm uses a scaled up value as well. Change this scaling
1869 * factor if the RSSI averaging algorithm changes.
1871 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
1872 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
1875 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
1879 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1881 WARN_ON(rssi_min_thold == rssi_max_thold ||
1882 rssi_min_thold > rssi_max_thold);
1884 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
1887 EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
1889 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
1891 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1893 _ieee80211_enable_rssi_reports(sdata, 0, 0);
1895 EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
1897 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1902 *pos++ = WLAN_EID_HT_CAPABILITY;
1903 *pos++ = sizeof(struct ieee80211_ht_cap);
1904 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
1906 /* capability flags */
1907 tmp = cpu_to_le16(cap);
1908 memcpy(pos, &tmp, sizeof(u16));
1911 /* AMPDU parameters */
1912 *pos++ = ht_cap->ampdu_factor |
1913 (ht_cap->ampdu_density <<
1914 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
1917 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
1918 pos += sizeof(ht_cap->mcs);
1920 /* extended capabilities */
1921 pos += sizeof(__le16);
1923 /* BF capabilities */
1924 pos += sizeof(__le32);
1926 /* antenna selection */
1932 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
1937 *pos++ = WLAN_EID_VHT_CAPABILITY;
1938 *pos++ = sizeof(struct ieee80211_vht_cap);
1939 memset(pos, 0, sizeof(struct ieee80211_vht_cap));
1941 /* capability flags */
1942 tmp = cpu_to_le32(cap);
1943 memcpy(pos, &tmp, sizeof(u32));
1947 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
1948 pos += sizeof(vht_cap->vht_mcs);
1953 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1954 const struct cfg80211_chan_def *chandef,
1957 struct ieee80211_ht_operation *ht_oper;
1958 /* Build HT Information */
1959 *pos++ = WLAN_EID_HT_OPERATION;
1960 *pos++ = sizeof(struct ieee80211_ht_operation);
1961 ht_oper = (struct ieee80211_ht_operation *)pos;
1962 ht_oper->primary_chan = ieee80211_frequency_to_channel(
1963 chandef->chan->center_freq);
1964 switch (chandef->width) {
1965 case NL80211_CHAN_WIDTH_160:
1966 case NL80211_CHAN_WIDTH_80P80:
1967 case NL80211_CHAN_WIDTH_80:
1968 case NL80211_CHAN_WIDTH_40:
1969 if (chandef->center_freq1 > chandef->chan->center_freq)
1970 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1972 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1975 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1978 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
1979 chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
1980 chandef->width != NL80211_CHAN_WIDTH_20)
1981 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
1983 ht_oper->operation_mode = cpu_to_le16(prot_mode);
1984 ht_oper->stbc_param = 0x0000;
1986 /* It seems that Basic MCS set and Supported MCS set
1987 are identical for the first 10 bytes */
1988 memset(&ht_oper->basic_set, 0, 16);
1989 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
1991 return pos + sizeof(struct ieee80211_ht_operation);
1994 void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
1995 const struct ieee80211_ht_operation *ht_oper,
1996 struct cfg80211_chan_def *chandef)
1998 enum nl80211_channel_type channel_type;
2001 cfg80211_chandef_create(chandef, control_chan,
2002 NL80211_CHAN_NO_HT);
2006 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2007 case IEEE80211_HT_PARAM_CHA_SEC_NONE:
2008 channel_type = NL80211_CHAN_HT20;
2010 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2011 channel_type = NL80211_CHAN_HT40PLUS;
2013 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2014 channel_type = NL80211_CHAN_HT40MINUS;
2017 channel_type = NL80211_CHAN_NO_HT;
2020 cfg80211_chandef_create(chandef, control_chan, channel_type);
2023 int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
2024 const struct ieee80211_supported_band *sband,
2025 const u8 *srates, int srates_len, u32 *rates)
2027 u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
2028 int shift = ieee80211_chandef_get_shift(chandef);
2029 struct ieee80211_rate *br;
2030 int brate, rate, i, j, count = 0;
2034 for (i = 0; i < srates_len; i++) {
2035 rate = srates[i] & 0x7f;
2037 for (j = 0; j < sband->n_bitrates; j++) {
2038 br = &sband->bitrates[j];
2039 if ((rate_flags & br->flags) != rate_flags)
2042 brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
2043 if (brate == rate) {
2053 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
2054 struct sk_buff *skb, bool need_basic,
2055 enum ieee80211_band band)
2057 struct ieee80211_local *local = sdata->local;
2058 struct ieee80211_supported_band *sband;
2061 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2064 shift = ieee80211_vif_get_shift(&sdata->vif);
2065 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2066 sband = local->hw.wiphy->bands[band];
2068 for (i = 0; i < sband->n_bitrates; i++) {
2069 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2076 if (skb_tailroom(skb) < rates + 2)
2079 pos = skb_put(skb, rates + 2);
2080 *pos++ = WLAN_EID_SUPP_RATES;
2082 for (i = 0; i < rates; i++) {
2084 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2087 if (need_basic && basic_rates & BIT(i))
2089 rate = sband->bitrates[i].bitrate;
2090 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
2092 *pos++ = basic | (u8) rate;
2098 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
2099 struct sk_buff *skb, bool need_basic,
2100 enum ieee80211_band band)
2102 struct ieee80211_local *local = sdata->local;
2103 struct ieee80211_supported_band *sband;
2104 int rate, skip, shift;
2105 u8 i, exrates, *pos;
2106 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2109 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2110 shift = ieee80211_vif_get_shift(&sdata->vif);
2112 sband = local->hw.wiphy->bands[band];
2114 for (i = 0; i < sband->n_bitrates; i++) {
2115 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2125 if (skb_tailroom(skb) < exrates + 2)
2129 pos = skb_put(skb, exrates + 2);
2130 *pos++ = WLAN_EID_EXT_SUPP_RATES;
2133 for (i = 8; i < sband->n_bitrates; i++) {
2135 if ((rate_flags & sband->bitrates[i].flags)
2140 if (need_basic && basic_rates & BIT(i))
2142 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
2144 *pos++ = basic | (u8) rate;
2150 int ieee80211_ave_rssi(struct ieee80211_vif *vif)
2152 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2153 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2155 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
2156 /* non-managed type inferfaces */
2159 return ifmgd->ave_beacon_signal / 16;
2161 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
2163 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
2168 /* TODO: consider rx_highest */
2170 if (mcs->rx_mask[3])
2172 if (mcs->rx_mask[2])
2174 if (mcs->rx_mask[1])
2180 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
2181 * @local: mac80211 hw info struct
2182 * @status: RX status
2183 * @mpdu_len: total MPDU length (including FCS)
2184 * @mpdu_offset: offset into MPDU to calculate timestamp at
2186 * This function calculates the RX timestamp at the given MPDU offset, taking
2187 * into account what the RX timestamp was. An offset of 0 will just normalize
2188 * the timestamp to TSF at beginning of MPDU reception.
2190 u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
2191 struct ieee80211_rx_status *status,
2192 unsigned int mpdu_len,
2193 unsigned int mpdu_offset)
2195 u64 ts = status->mactime;
2196 struct rate_info ri;
2199 if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
2202 memset(&ri, 0, sizeof(ri));
2204 /* Fill cfg80211 rate info */
2205 if (status->flag & RX_FLAG_HT) {
2206 ri.mcs = status->rate_idx;
2207 ri.flags |= RATE_INFO_FLAGS_MCS;
2208 if (status->flag & RX_FLAG_40MHZ)
2209 ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
2210 if (status->flag & RX_FLAG_SHORT_GI)
2211 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2212 } else if (status->flag & RX_FLAG_VHT) {
2213 ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
2214 ri.mcs = status->rate_idx;
2215 ri.nss = status->vht_nss;
2216 if (status->flag & RX_FLAG_40MHZ)
2217 ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
2218 if (status->flag & RX_FLAG_80MHZ)
2219 ri.flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
2220 if (status->flag & RX_FLAG_80P80MHZ)
2221 ri.flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
2222 if (status->flag & RX_FLAG_160MHZ)
2223 ri.flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
2224 if (status->flag & RX_FLAG_SHORT_GI)
2225 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2227 struct ieee80211_supported_band *sband;
2231 if (status->flag & RX_FLAG_10MHZ)
2233 if (status->flag & RX_FLAG_5MHZ)
2236 sband = local->hw.wiphy->bands[status->band];
2237 bitrate = sband->bitrates[status->rate_idx].bitrate;
2238 ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
2241 rate = cfg80211_calculate_bitrate(&ri);
2243 /* rewind from end of MPDU */
2244 if (status->flag & RX_FLAG_MACTIME_END)
2245 ts -= mpdu_len * 8 * 10 / rate;
2247 ts += mpdu_offset * 8 * 10 / rate;
2252 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
2254 struct ieee80211_sub_if_data *sdata;
2256 mutex_lock(&local->iflist_mtx);
2257 list_for_each_entry(sdata, &local->interfaces, list) {
2258 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
2260 if (sdata->wdev.cac_started) {
2261 ieee80211_vif_release_channel(sdata);
2262 cfg80211_cac_event(sdata->dev,
2263 NL80211_RADAR_CAC_ABORTED,
2267 mutex_unlock(&local->iflist_mtx);
2270 void ieee80211_dfs_radar_detected_work(struct work_struct *work)
2272 struct ieee80211_local *local =
2273 container_of(work, struct ieee80211_local, radar_detected_work);
2274 struct cfg80211_chan_def chandef;
2276 ieee80211_dfs_cac_cancel(local);
2278 if (local->use_chanctx)
2279 /* currently not handled */
2282 chandef = local->hw.conf.chandef;
2283 cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
2287 void ieee80211_radar_detected(struct ieee80211_hw *hw)
2289 struct ieee80211_local *local = hw_to_local(hw);
2291 trace_api_radar_detected(local);
2293 ieee80211_queue_work(hw, &local->radar_detected_work);
2295 EXPORT_SYMBOL(ieee80211_radar_detected);
2297 u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
2303 case NL80211_CHAN_WIDTH_20:
2304 c->width = NL80211_CHAN_WIDTH_20_NOHT;
2305 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2307 case NL80211_CHAN_WIDTH_40:
2308 c->width = NL80211_CHAN_WIDTH_20;
2309 c->center_freq1 = c->chan->center_freq;
2310 ret = IEEE80211_STA_DISABLE_40MHZ |
2311 IEEE80211_STA_DISABLE_VHT;
2313 case NL80211_CHAN_WIDTH_80:
2314 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
2318 c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
2319 c->width = NL80211_CHAN_WIDTH_40;
2320 ret = IEEE80211_STA_DISABLE_VHT;
2322 case NL80211_CHAN_WIDTH_80P80:
2323 c->center_freq2 = 0;
2324 c->width = NL80211_CHAN_WIDTH_80;
2325 ret = IEEE80211_STA_DISABLE_80P80MHZ |
2326 IEEE80211_STA_DISABLE_160MHZ;
2328 case NL80211_CHAN_WIDTH_160:
2330 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
2333 c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
2334 c->width = NL80211_CHAN_WIDTH_80;
2335 ret = IEEE80211_STA_DISABLE_80P80MHZ |
2336 IEEE80211_STA_DISABLE_160MHZ;
2339 case NL80211_CHAN_WIDTH_20_NOHT:
2341 c->width = NL80211_CHAN_WIDTH_20_NOHT;
2342 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2344 case NL80211_CHAN_WIDTH_5:
2345 case NL80211_CHAN_WIDTH_10:
2348 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2352 WARN_ON_ONCE(!cfg80211_chandef_valid(c));