blob: 93b5bb849ad7174181d64bbadf938d1fd93aa4c3 [file] [log] [blame]
Johannes Bergc2d15602007-07-27 15:43:23 +02001/*
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>
Johannes Bergd98ad832014-09-03 15:24:57 +03006 * Copyright 2013-2014 Intel Mobile Communications GmbH
Johannes Bergda6a4352017-04-26 12:14:59 +02007 * Copyright (C) 2015-2017 Intel Deutschland GmbH
Haim Dreyfusse552af02018-03-28 13:24:10 +03008 * Copyright (C) 2018 Intel Corporation
Johannes Bergc2d15602007-07-27 15:43:23 +02009 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 * utilities for mac80211
15 */
16
17#include <net/mac80211.h>
18#include <linux/netdevice.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040019#include <linux/export.h>
Johannes Bergc2d15602007-07-27 15:43:23 +020020#include <linux/types.h>
21#include <linux/slab.h>
22#include <linux/skbuff.h>
23#include <linux/etherdevice.h>
24#include <linux/if_arp.h>
Johannes Bergc2d15602007-07-27 15:43:23 +020025#include <linux/bitmap.h>
Johannes Bergdd769862011-11-18 16:54:50 +010026#include <linux/crc32.h>
Eric W. Biederman881d9662007-09-17 11:56:21 -070027#include <net/net_namespace.h>
Johannes Bergc2d15602007-07-27 15:43:23 +020028#include <net/cfg80211.h>
Johannes Bergdabeb342007-11-09 01:57:29 +010029#include <net/rtnetlink.h>
Johannes Bergc2d15602007-07-27 15:43:23 +020030
31#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020032#include "driver-ops.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040033#include "rate.h"
Luis Carlos Coboee385852008-02-23 15:17:11 +010034#include "mesh.h"
Johannes Bergc2d15602007-07-27 15:43:23 +020035#include "wme.h"
Johannes Bergf2753dd2009-04-14 10:09:24 +020036#include "led.h"
Johannes Bergfffd0932009-07-08 14:22:54 +020037#include "wep.h"
Johannes Bergc2d15602007-07-27 15:43:23 +020038
39/* privid for wiphys to determine whether they belong to us or not */
Johannes Berg8a47cea2014-01-20 23:55:44 +010040const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
Johannes Bergc2d15602007-07-27 15:43:23 +020041
Luis R. Rodriguez9a953712009-01-22 15:05:53 -080042struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
43{
44 struct ieee80211_local *local;
45 BUG_ON(!wiphy);
46
47 local = wiphy_priv(wiphy);
48 return &local->hw;
49}
50EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
Johannes Bergc2d15602007-07-27 15:43:23 +020051
Johannes Berg5cf121c2008-02-25 16:27:43 +010052void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
Johannes Bergc2d15602007-07-27 15:43:23 +020053{
Johannes Berg252b86c2011-11-16 15:28:55 +010054 struct sk_buff *skb;
Johannes Berg2de8e0d2009-03-23 17:28:35 +010055 struct ieee80211_hdr *hdr;
Johannes Bergc2d15602007-07-27 15:43:23 +020056
Johannes Berg252b86c2011-11-16 15:28:55 +010057 skb_queue_walk(&tx->skbs, skb) {
Johannes Berg2de8e0d2009-03-23 17:28:35 +010058 hdr = (struct ieee80211_hdr *) skb->data;
59 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
Johannes Berg252b86c2011-11-16 15:28:55 +010060 }
Johannes Bergc2d15602007-07-27 15:43:23 +020061}
62
Johannes Berg57fbcce2016-04-12 15:56:15 +020063int ieee80211_frame_duration(enum nl80211_band band, size_t len,
Simon Wunderlich438b61b2013-07-08 16:55:51 +020064 int rate, int erp, int short_preamble,
65 int shift)
Johannes Bergc2d15602007-07-27 15:43:23 +020066{
67 int dur;
68
69 /* calculate duration (in microseconds, rounded up to next higher
70 * integer if it includes a fractional microsecond) to send frame of
71 * len bytes (does not include FCS) at the given rate. Duration will
72 * also include SIFS.
73 *
74 * rate is in 100 kbps, so divident is multiplied by 10 in the
75 * DIV_ROUND_UP() operations.
Simon Wunderlich438b61b2013-07-08 16:55:51 +020076 *
77 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
78 * is assumed to be 0 otherwise.
Johannes Bergc2d15602007-07-27 15:43:23 +020079 */
80
Johannes Berg57fbcce2016-04-12 15:56:15 +020081 if (band == NL80211_BAND_5GHZ || erp) {
Johannes Bergc2d15602007-07-27 15:43:23 +020082 /*
83 * OFDM:
84 *
85 * N_DBPS = DATARATE x 4
86 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
87 * (16 = SIGNAL time, 6 = tail bits)
88 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
89 *
90 * T_SYM = 4 usec
Simon Wunderlich438b61b2013-07-08 16:55:51 +020091 * 802.11a - 18.5.2: aSIFSTime = 16 usec
Johannes Bergc2d15602007-07-27 15:43:23 +020092 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
93 * signal ext = 6 usec
94 */
Johannes Bergc2d15602007-07-27 15:43:23 +020095 dur = 16; /* SIFS + signal ext */
Simon Wunderlich438b61b2013-07-08 16:55:51 +020096 dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
97 dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
Simon Wunderlich438b61b2013-07-08 16:55:51 +020098
99 /* IEEE 802.11-2012 18.3.2.4: all values above are:
100 * * times 4 for 5 MHz
101 * * times 2 for 10 MHz
102 */
103 dur *= 1 << shift;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200104
105 /* rates should already consider the channel bandwidth,
106 * don't apply divisor again.
107 */
108 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
109 4 * rate); /* T_SYM x N_SYM */
Johannes Bergc2d15602007-07-27 15:43:23 +0200110 } else {
111 /*
112 * 802.11b or 802.11g with 802.11b compatibility:
113 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
114 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
115 *
116 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
117 * aSIFSTime = 10 usec
118 * aPreambleLength = 144 usec or 72 usec with short preamble
119 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
120 */
121 dur = 10; /* aSIFSTime = 10 usec */
122 dur += short_preamble ? (72 + 24) : (144 + 48);
123
124 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
125 }
126
127 return dur;
128}
129
130/* Exported duration function for driver use */
Johannes Berg32bfd352007-12-19 01:31:26 +0100131__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
132 struct ieee80211_vif *vif,
Johannes Berg57fbcce2016-04-12 15:56:15 +0200133 enum nl80211_band band,
Johannes Berg8318d782008-01-24 19:38:38 +0100134 size_t frame_len,
135 struct ieee80211_rate *rate)
Johannes Bergc2d15602007-07-27 15:43:23 +0200136{
Johannes Berg25d834e2008-09-12 22:52:47 +0200137 struct ieee80211_sub_if_data *sdata;
Johannes Bergc2d15602007-07-27 15:43:23 +0200138 u16 dur;
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200139 int erp, shift = 0;
Johannes Berg25d834e2008-09-12 22:52:47 +0200140 bool short_preamble = false;
Johannes Bergc2d15602007-07-27 15:43:23 +0200141
Johannes Berg8318d782008-01-24 19:38:38 +0100142 erp = 0;
Johannes Berg25d834e2008-09-12 22:52:47 +0200143 if (vif) {
144 sdata = vif_to_sdata(vif);
Johannes Bergbda39332008-10-11 01:51:51 +0200145 short_preamble = sdata->vif.bss_conf.use_short_preamble;
Johannes Berg25d834e2008-09-12 22:52:47 +0200146 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
147 erp = rate->flags & IEEE80211_RATE_ERP_G;
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200148 shift = ieee80211_vif_get_shift(vif);
Johannes Berg25d834e2008-09-12 22:52:47 +0200149 }
Johannes Berg8318d782008-01-24 19:38:38 +0100150
Michal Kazior4ee73f32012-04-11 08:47:56 +0200151 dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200152 short_preamble, shift);
Johannes Bergc2d15602007-07-27 15:43:23 +0200153
154 return cpu_to_le16(dur);
155}
156EXPORT_SYMBOL(ieee80211_generic_frame_duration);
157
Johannes Berg32bfd352007-12-19 01:31:26 +0100158__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
159 struct ieee80211_vif *vif, size_t frame_len,
Johannes Berge039fa42008-05-15 12:55:29 +0200160 const struct ieee80211_tx_info *frame_txctl)
Johannes Bergc2d15602007-07-27 15:43:23 +0200161{
162 struct ieee80211_local *local = hw_to_local(hw);
163 struct ieee80211_rate *rate;
Johannes Berg25d834e2008-09-12 22:52:47 +0200164 struct ieee80211_sub_if_data *sdata;
Johannes Berg471b3ef2007-12-28 14:32:58 +0100165 bool short_preamble;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200166 int erp, shift = 0, bitrate;
Johannes Bergc2d15602007-07-27 15:43:23 +0200167 u16 dur;
Johannes Berg2e92e6f2008-05-15 12:55:27 +0200168 struct ieee80211_supported_band *sband;
169
Michal Kazior4ee73f32012-04-11 08:47:56 +0200170 sband = local->hw.wiphy->bands[frame_txctl->band];
Johannes Bergc2d15602007-07-27 15:43:23 +0200171
Johannes Berg25d834e2008-09-12 22:52:47 +0200172 short_preamble = false;
Daniel Drake7e9ed182007-07-27 15:43:24 +0200173
Johannes Berge039fa42008-05-15 12:55:29 +0200174 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
Johannes Berg8318d782008-01-24 19:38:38 +0100175
176 erp = 0;
Johannes Berg25d834e2008-09-12 22:52:47 +0200177 if (vif) {
178 sdata = vif_to_sdata(vif);
Johannes Bergbda39332008-10-11 01:51:51 +0200179 short_preamble = sdata->vif.bss_conf.use_short_preamble;
Johannes Berg25d834e2008-09-12 22:52:47 +0200180 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
181 erp = rate->flags & IEEE80211_RATE_ERP_G;
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200182 shift = ieee80211_vif_get_shift(vif);
Johannes Berg25d834e2008-09-12 22:52:47 +0200183 }
Johannes Bergc2d15602007-07-27 15:43:23 +0200184
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200185 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
186
Johannes Bergc2d15602007-07-27 15:43:23 +0200187 /* CTS duration */
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200188 dur = ieee80211_frame_duration(sband->band, 10, bitrate,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200189 erp, short_preamble, shift);
Johannes Bergc2d15602007-07-27 15:43:23 +0200190 /* Data frame duration */
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200191 dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200192 erp, short_preamble, shift);
Johannes Bergc2d15602007-07-27 15:43:23 +0200193 /* ACK duration */
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200194 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200195 erp, short_preamble, shift);
Johannes Bergc2d15602007-07-27 15:43:23 +0200196
197 return cpu_to_le16(dur);
198}
199EXPORT_SYMBOL(ieee80211_rts_duration);
200
Johannes Berg32bfd352007-12-19 01:31:26 +0100201__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
202 struct ieee80211_vif *vif,
Johannes Bergc2d15602007-07-27 15:43:23 +0200203 size_t frame_len,
Johannes Berge039fa42008-05-15 12:55:29 +0200204 const struct ieee80211_tx_info *frame_txctl)
Johannes Bergc2d15602007-07-27 15:43:23 +0200205{
206 struct ieee80211_local *local = hw_to_local(hw);
207 struct ieee80211_rate *rate;
Johannes Berg25d834e2008-09-12 22:52:47 +0200208 struct ieee80211_sub_if_data *sdata;
Johannes Berg471b3ef2007-12-28 14:32:58 +0100209 bool short_preamble;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200210 int erp, shift = 0, bitrate;
Johannes Bergc2d15602007-07-27 15:43:23 +0200211 u16 dur;
Johannes Berg2e92e6f2008-05-15 12:55:27 +0200212 struct ieee80211_supported_band *sband;
213
Michal Kazior4ee73f32012-04-11 08:47:56 +0200214 sband = local->hw.wiphy->bands[frame_txctl->band];
Johannes Bergc2d15602007-07-27 15:43:23 +0200215
Johannes Berg25d834e2008-09-12 22:52:47 +0200216 short_preamble = false;
Daniel Drake7e9ed182007-07-27 15:43:24 +0200217
Johannes Berge039fa42008-05-15 12:55:29 +0200218 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
Johannes Berg8318d782008-01-24 19:38:38 +0100219 erp = 0;
Johannes Berg25d834e2008-09-12 22:52:47 +0200220 if (vif) {
221 sdata = vif_to_sdata(vif);
Johannes Bergbda39332008-10-11 01:51:51 +0200222 short_preamble = sdata->vif.bss_conf.use_short_preamble;
Johannes Berg25d834e2008-09-12 22:52:47 +0200223 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
224 erp = rate->flags & IEEE80211_RATE_ERP_G;
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200225 shift = ieee80211_vif_get_shift(vif);
Johannes Berg25d834e2008-09-12 22:52:47 +0200226 }
Johannes Bergc2d15602007-07-27 15:43:23 +0200227
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200228 bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);
229
Johannes Bergc2d15602007-07-27 15:43:23 +0200230 /* Data frame duration */
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200231 dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200232 erp, short_preamble, shift);
Johannes Berge039fa42008-05-15 12:55:29 +0200233 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
Johannes Bergc2d15602007-07-27 15:43:23 +0200234 /* ACK duration */
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200235 dur += ieee80211_frame_duration(sband->band, 10, bitrate,
Simon Wunderlich438b61b2013-07-08 16:55:51 +0200236 erp, short_preamble, shift);
Johannes Bergc2d15602007-07-27 15:43:23 +0200237 }
238
Johannes Bergc2d15602007-07-27 15:43:23 +0200239 return cpu_to_le16(dur);
240}
241EXPORT_SYMBOL(ieee80211_ctstoself_duration);
242
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200243void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
244{
245 struct ieee80211_sub_if_data *sdata;
Johannes Berga6f38ac2012-07-04 12:49:59 +0200246 int n_acs = IEEE80211_NUM_ACS;
247
Michal Kazior80a83cf2016-05-19 10:37:48 +0200248 if (local->ops->wake_tx_queue)
249 return;
250
Johannes Berga6f38ac2012-07-04 12:49:59 +0200251 if (local->hw.queues < IEEE80211_NUM_ACS)
252 n_acs = 1;
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200253
254 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
255 int ac;
256
Johannes Bergf142c6b2012-06-18 20:07:15 +0200257 if (!sdata->dev)
258 continue;
259
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200260 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
261 local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
262 continue;
263
Johannes Berga6f38ac2012-07-04 12:49:59 +0200264 for (ac = 0; ac < n_acs; ac++) {
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200265 int ac_queue = sdata->vif.hw_queue[ac];
266
267 if (ac_queue == queue ||
268 (sdata->vif.cab_queue == queue &&
269 local->queue_stop_reasons[ac_queue] == 0 &&
270 skb_queue_empty(&local->pending[ac_queue])))
271 netif_wake_subqueue(sdata->dev, ac);
272 }
273 }
274}
275
Kalle Valoce7c9112008-12-18 23:35:20 +0200276static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300277 enum queue_stop_reason reason,
278 bool refcounted)
Johannes Bergc2d15602007-07-27 15:43:23 +0200279{
280 struct ieee80211_local *local = hw_to_local(hw);
281
Johannes Bergb5878a22010-04-07 16:48:40 +0200282 trace_wake_queue(local, queue, reason);
283
Johannes Berge4e72fb2009-03-23 17:28:42 +0100284 if (WARN_ON(queue >= hw->queues))
285 return;
Kalle Valoce7c9112008-12-18 23:35:20 +0200286
Johannes Bergada15122012-03-28 11:04:27 +0200287 if (!test_bit(reason, &local->queue_stop_reasons[queue]))
288 return;
289
Johannes Berg856142c2015-11-24 15:29:53 +0100290 if (!refcounted) {
Luciano Coelhocca07b02014-06-13 16:30:05 +0300291 local->q_stop_reasons[queue][reason] = 0;
Johannes Berg856142c2015-11-24 15:29:53 +0100292 } else {
Luciano Coelhocca07b02014-06-13 16:30:05 +0300293 local->q_stop_reasons[queue][reason]--;
Johannes Berg856142c2015-11-24 15:29:53 +0100294 if (WARN_ON(local->q_stop_reasons[queue][reason] < 0))
295 local->q_stop_reasons[queue][reason] = 0;
296 }
Luciano Coelhocca07b02014-06-13 16:30:05 +0300297
298 if (local->q_stop_reasons[queue][reason] == 0)
299 __clear_bit(reason, &local->queue_stop_reasons[queue]);
Johannes Berg96f5e662009-02-12 00:51:53 +0100300
301 if (local->queue_stop_reasons[queue] != 0)
302 /* someone still has this queue stopped */
303 return;
304
Johannes Berg7236fe22010-03-22 13:42:43 -0700305 if (skb_queue_empty(&local->pending[queue])) {
306 rcu_read_lock();
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200307 ieee80211_propagate_queue_wake(local, queue);
Johannes Berg7236fe22010-03-22 13:42:43 -0700308 rcu_read_unlock();
309 } else
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200310 tasklet_schedule(&local->tx_pending_tasklet);
Johannes Bergc2d15602007-07-27 15:43:23 +0200311}
Kalle Valoce7c9112008-12-18 23:35:20 +0200312
Johannes Berg96f5e662009-02-12 00:51:53 +0100313void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300314 enum queue_stop_reason reason,
315 bool refcounted)
Kalle Valoce7c9112008-12-18 23:35:20 +0200316{
317 struct ieee80211_local *local = hw_to_local(hw);
318 unsigned long flags;
319
320 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
Luciano Coelhocca07b02014-06-13 16:30:05 +0300321 __ieee80211_wake_queue(hw, queue, reason, refcounted);
Kalle Valoce7c9112008-12-18 23:35:20 +0200322 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
323}
324
325void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
326{
327 ieee80211_wake_queue_by_reason(hw, queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300328 IEEE80211_QUEUE_STOP_REASON_DRIVER,
329 false);
Kalle Valoce7c9112008-12-18 23:35:20 +0200330}
Johannes Bergc2d15602007-07-27 15:43:23 +0200331EXPORT_SYMBOL(ieee80211_wake_queue);
332
Kalle Valoce7c9112008-12-18 23:35:20 +0200333static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300334 enum queue_stop_reason reason,
335 bool refcounted)
Johannes Bergc2d15602007-07-27 15:43:23 +0200336{
337 struct ieee80211_local *local = hw_to_local(hw);
Johannes Bergcf0277e2010-01-05 18:00:58 +0100338 struct ieee80211_sub_if_data *sdata;
Johannes Berga6f38ac2012-07-04 12:49:59 +0200339 int n_acs = IEEE80211_NUM_ACS;
Johannes Bergc2d15602007-07-27 15:43:23 +0200340
Johannes Bergb5878a22010-04-07 16:48:40 +0200341 trace_stop_queue(local, queue, reason);
342
Johannes Berge4e72fb2009-03-23 17:28:42 +0100343 if (WARN_ON(queue >= hw->queues))
344 return;
Johannes Berg96f5e662009-02-12 00:51:53 +0100345
Luciano Coelhocca07b02014-06-13 16:30:05 +0300346 if (!refcounted)
347 local->q_stop_reasons[queue][reason] = 1;
348 else
349 local->q_stop_reasons[queue][reason]++;
Johannes Bergada15122012-03-28 11:04:27 +0200350
Luciano Coelhocca07b02014-06-13 16:30:05 +0300351 if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
352 return;
Johannes Bergcf0277e2010-01-05 18:00:58 +0100353
Michal Kazior80a83cf2016-05-19 10:37:48 +0200354 if (local->ops->wake_tx_queue)
355 return;
356
Johannes Berga6f38ac2012-07-04 12:49:59 +0200357 if (local->hw.queues < IEEE80211_NUM_ACS)
358 n_acs = 1;
359
Johannes Bergcf0277e2010-01-05 18:00:58 +0100360 rcu_read_lock();
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200361 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
362 int ac;
363
Johannes Bergf142c6b2012-06-18 20:07:15 +0200364 if (!sdata->dev)
365 continue;
366
Johannes Berga6f38ac2012-07-04 12:49:59 +0200367 for (ac = 0; ac < n_acs; ac++) {
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200368 if (sdata->vif.hw_queue[ac] == queue ||
369 sdata->vif.cab_queue == queue)
370 netif_stop_subqueue(sdata->dev, ac);
371 }
372 }
Johannes Bergcf0277e2010-01-05 18:00:58 +0100373 rcu_read_unlock();
Johannes Bergc2d15602007-07-27 15:43:23 +0200374}
Kalle Valoce7c9112008-12-18 23:35:20 +0200375
Johannes Berg96f5e662009-02-12 00:51:53 +0100376void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300377 enum queue_stop_reason reason,
378 bool refcounted)
Kalle Valoce7c9112008-12-18 23:35:20 +0200379{
380 struct ieee80211_local *local = hw_to_local(hw);
381 unsigned long flags;
382
383 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
Luciano Coelhocca07b02014-06-13 16:30:05 +0300384 __ieee80211_stop_queue(hw, queue, reason, refcounted);
Kalle Valoce7c9112008-12-18 23:35:20 +0200385 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
386}
387
388void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
389{
390 ieee80211_stop_queue_by_reason(hw, queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300391 IEEE80211_QUEUE_STOP_REASON_DRIVER,
392 false);
Kalle Valoce7c9112008-12-18 23:35:20 +0200393}
Johannes Bergc2d15602007-07-27 15:43:23 +0200394EXPORT_SYMBOL(ieee80211_stop_queue);
395
Johannes Berg8f77f382009-06-07 21:58:37 +0200396void ieee80211_add_pending_skb(struct ieee80211_local *local,
397 struct sk_buff *skb)
398{
399 struct ieee80211_hw *hw = &local->hw;
400 unsigned long flags;
Johannes Berga7bc3762009-07-27 10:33:31 +0200401 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200402 int queue = info->hw_queue;
Johannes Berga7bc3762009-07-27 10:33:31 +0200403
404 if (WARN_ON(!info->control.vif)) {
Felix Fietkaud4fa14c2012-10-10 22:40:23 +0200405 ieee80211_free_txskb(&local->hw, skb);
Johannes Berga7bc3762009-07-27 10:33:31 +0200406 return;
407 }
Johannes Berg8f77f382009-06-07 21:58:37 +0200408
409 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
Luciano Coelhocca07b02014-06-13 16:30:05 +0300410 __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
411 false);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200412 __skb_queue_tail(&local->pending[queue], skb);
Luciano Coelhocca07b02014-06-13 16:30:05 +0300413 __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
414 false);
Johannes Berg8f77f382009-06-07 21:58:37 +0200415 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
416}
417
Johannes Berge3685e02014-02-20 11:19:58 +0100418void ieee80211_add_pending_skbs(struct ieee80211_local *local,
419 struct sk_buff_head *skbs)
Johannes Berg8f77f382009-06-07 21:58:37 +0200420{
421 struct ieee80211_hw *hw = &local->hw;
422 struct sk_buff *skb;
423 unsigned long flags;
Johannes Bergb0b97a82011-09-29 16:04:30 +0200424 int queue, i;
Johannes Berg8f77f382009-06-07 21:58:37 +0200425
426 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
Johannes Berg8f77f382009-06-07 21:58:37 +0200427 while ((skb = skb_dequeue(skbs))) {
Johannes Berga7bc3762009-07-27 10:33:31 +0200428 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
429
430 if (WARN_ON(!info->control.vif)) {
Felix Fietkaud4fa14c2012-10-10 22:40:23 +0200431 ieee80211_free_txskb(&local->hw, skb);
Johannes Berga7bc3762009-07-27 10:33:31 +0200432 continue;
433 }
434
Johannes Berg3a25a8c2012-04-03 16:28:50 +0200435 queue = info->hw_queue;
Johannes Berg4644ae82012-03-28 11:04:28 +0200436
437 __ieee80211_stop_queue(hw, queue,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300438 IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
439 false);
Johannes Berg4644ae82012-03-28 11:04:28 +0200440
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200441 __skb_queue_tail(&local->pending[queue], skb);
Johannes Berg8f77f382009-06-07 21:58:37 +0200442 }
443
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200444 for (i = 0; i < hw->queues; i++)
Johannes Berg8f77f382009-06-07 21:58:37 +0200445 __ieee80211_wake_queue(hw, i,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300446 IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
447 false);
Johannes Berg8f77f382009-06-07 21:58:37 +0200448 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
Johannes Berg8f77f382009-06-07 21:58:37 +0200449}
450
Kalle Valoce7c9112008-12-18 23:35:20 +0200451void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
Johannes Berg445ea4e2013-02-13 12:25:28 +0100452 unsigned long queues,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300453 enum queue_stop_reason reason,
454 bool refcounted)
Johannes Bergc2d15602007-07-27 15:43:23 +0200455{
Kalle Valoce7c9112008-12-18 23:35:20 +0200456 struct ieee80211_local *local = hw_to_local(hw);
457 unsigned long flags;
Johannes Bergc2d15602007-07-27 15:43:23 +0200458 int i;
459
Kalle Valoce7c9112008-12-18 23:35:20 +0200460 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
461
Johannes Berg445ea4e2013-02-13 12:25:28 +0100462 for_each_set_bit(i, &queues, hw->queues)
Luciano Coelhocca07b02014-06-13 16:30:05 +0300463 __ieee80211_stop_queue(hw, i, reason, refcounted);
Kalle Valoce7c9112008-12-18 23:35:20 +0200464
465 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
466}
467
468void ieee80211_stop_queues(struct ieee80211_hw *hw)
469{
Johannes Berg445ea4e2013-02-13 12:25:28 +0100470 ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300471 IEEE80211_QUEUE_STOP_REASON_DRIVER,
472 false);
Johannes Bergc2d15602007-07-27 15:43:23 +0200473}
474EXPORT_SYMBOL(ieee80211_stop_queues);
475
Tomas Winkler92ab8532008-07-24 21:02:04 +0300476int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
477{
478 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200479 unsigned long flags;
480 int ret;
Johannes Berg96f5e662009-02-12 00:51:53 +0100481
Johannes Berge4e72fb2009-03-23 17:28:42 +0100482 if (WARN_ON(queue >= hw->queues))
483 return true;
Johannes Berg96f5e662009-02-12 00:51:53 +0100484
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200485 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
Thomas Pedersen2419ea12013-04-10 15:41:40 -0700486 ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
487 &local->queue_stop_reasons[queue]);
Johannes Berg3b8d81e02009-06-17 17:43:56 +0200488 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
489 return ret;
Tomas Winkler92ab8532008-07-24 21:02:04 +0300490}
491EXPORT_SYMBOL(ieee80211_queue_stopped);
492
Kalle Valoce7c9112008-12-18 23:35:20 +0200493void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
Johannes Berg445ea4e2013-02-13 12:25:28 +0100494 unsigned long queues,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300495 enum queue_stop_reason reason,
496 bool refcounted)
Johannes Bergc2d15602007-07-27 15:43:23 +0200497{
Kalle Valoce7c9112008-12-18 23:35:20 +0200498 struct ieee80211_local *local = hw_to_local(hw);
499 unsigned long flags;
Johannes Bergc2d15602007-07-27 15:43:23 +0200500 int i;
501
Kalle Valoce7c9112008-12-18 23:35:20 +0200502 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
503
Johannes Berg445ea4e2013-02-13 12:25:28 +0100504 for_each_set_bit(i, &queues, hw->queues)
Luciano Coelhocca07b02014-06-13 16:30:05 +0300505 __ieee80211_wake_queue(hw, i, reason, refcounted);
Kalle Valoce7c9112008-12-18 23:35:20 +0200506
507 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
508}
509
510void ieee80211_wake_queues(struct ieee80211_hw *hw)
511{
Johannes Berg445ea4e2013-02-13 12:25:28 +0100512 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300513 IEEE80211_QUEUE_STOP_REASON_DRIVER,
514 false);
Johannes Bergc2d15602007-07-27 15:43:23 +0200515}
516EXPORT_SYMBOL(ieee80211_wake_queues);
Johannes Bergdabeb342007-11-09 01:57:29 +0100517
Luciano Coelho26da23b2014-06-13 16:30:06 +0300518static unsigned int
519ieee80211_get_vif_queues(struct ieee80211_local *local,
520 struct ieee80211_sub_if_data *sdata)
Johannes Berg39ecc012013-02-13 12:11:00 +0100521{
Luciano Coelho26da23b2014-06-13 16:30:06 +0300522 unsigned int queues;
Johannes Berg39ecc012013-02-13 12:11:00 +0100523
Johannes Berg30686bf2015-06-02 21:39:54 +0200524 if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
Johannes Berg39ecc012013-02-13 12:11:00 +0100525 int ac;
526
527 queues = 0;
528
529 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
530 queues |= BIT(sdata->vif.hw_queue[ac]);
531 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
532 queues |= BIT(sdata->vif.cab_queue);
533 } else {
534 /* all queues */
535 queues = BIT(local->hw.queues) - 1;
536 }
537
Luciano Coelho26da23b2014-06-13 16:30:06 +0300538 return queues;
539}
540
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200541void __ieee80211_flush_queues(struct ieee80211_local *local,
542 struct ieee80211_sub_if_data *sdata,
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200543 unsigned int queues, bool drop)
Luciano Coelho26da23b2014-06-13 16:30:06 +0300544{
Luciano Coelho26da23b2014-06-13 16:30:06 +0300545 if (!local->ops->flush)
546 return;
547
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200548 /*
549 * If no queue was set, or if the HW doesn't support
550 * IEEE80211_HW_QUEUE_CONTROL - flush all queues
551 */
Johannes Berg30686bf2015-06-02 21:39:54 +0200552 if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200553 queues = ieee80211_get_vif_queues(local, sdata);
Luciano Coelho26da23b2014-06-13 16:30:06 +0300554
Luciano Coelho59f48fe2014-06-13 16:30:04 +0300555 ieee80211_stop_queues_by_reason(&local->hw, queues,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300556 IEEE80211_QUEUE_STOP_REASON_FLUSH,
557 false);
Johannes Berg445ea4e2013-02-13 12:25:28 +0100558
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200559 drv_flush(local, sdata, queues, drop);
Johannes Berg445ea4e2013-02-13 12:25:28 +0100560
Luciano Coelho59f48fe2014-06-13 16:30:04 +0300561 ieee80211_wake_queues_by_reason(&local->hw, queues,
Luciano Coelhocca07b02014-06-13 16:30:05 +0300562 IEEE80211_QUEUE_STOP_REASON_FLUSH,
563 false);
Johannes Berg39ecc012013-02-13 12:11:00 +0100564}
565
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200566void ieee80211_flush_queues(struct ieee80211_local *local,
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200567 struct ieee80211_sub_if_data *sdata, bool drop)
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200568{
Emmanuel Grumbach3b24f4c2015-01-07 15:42:39 +0200569 __ieee80211_flush_queues(local, sdata, 0, drop);
Liad Kaufman4f9610d2014-11-09 18:50:21 +0200570}
571
Luciano Coelho26da23b2014-06-13 16:30:06 +0300572void ieee80211_stop_vif_queues(struct ieee80211_local *local,
573 struct ieee80211_sub_if_data *sdata,
574 enum queue_stop_reason reason)
575{
576 ieee80211_stop_queues_by_reason(&local->hw,
577 ieee80211_get_vif_queues(local, sdata),
578 reason, true);
579}
580
581void ieee80211_wake_vif_queues(struct ieee80211_local *local,
582 struct ieee80211_sub_if_data *sdata,
583 enum queue_stop_reason reason)
584{
585 ieee80211_wake_queues_by_reason(&local->hw,
586 ieee80211_get_vif_queues(local, sdata),
587 reason, true);
588}
589
Arik Nemtsov3384d752015-03-01 09:10:15 +0200590static void __iterate_interfaces(struct ieee80211_local *local,
591 u32 iter_flags,
592 void (*iterator)(void *data, u8 *mac,
593 struct ieee80211_vif *vif),
594 void *data)
Johannes Bergdabeb342007-11-09 01:57:29 +0100595{
Johannes Bergdabeb342007-11-09 01:57:29 +0100596 struct ieee80211_sub_if_data *sdata;
Arik Nemtsov3384d752015-03-01 09:10:15 +0200597 bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE;
Johannes Bergdabeb342007-11-09 01:57:29 +0100598
Johannes Berge38bad42007-11-28 10:55:32 +0100599 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg51fb61e2007-12-19 01:31:27 +0100600 switch (sdata->vif.type) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200601 case NL80211_IFTYPE_MONITOR:
Aviya Erenfeldd8212182016-08-29 23:25:15 +0300602 if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
Felix Fietkau31eba5b2013-05-28 13:01:53 +0200603 continue;
604 break;
Johannes Berg05c914f2008-09-11 00:01:58 +0200605 case NL80211_IFTYPE_AP_VLAN:
Johannes Bergdabeb342007-11-09 01:57:29 +0100606 continue;
Johannes Berg2ca27bc2010-09-16 14:58:23 +0200607 default:
Johannes Bergdabeb342007-11-09 01:57:29 +0100608 break;
609 }
Johannes Berg8b2c9822012-11-06 20:23:30 +0100610 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
Arik Nemtsov3384d752015-03-01 09:10:15 +0200611 active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
Johannes Berg8b2c9822012-11-06 20:23:30 +0100612 continue;
Arik Nemtsov3384d752015-03-01 09:10:15 +0200613 if (ieee80211_sdata_running(sdata) || !active_only)
Johannes Berg47846c92009-11-25 17:46:19 +0100614 iterator(data, sdata->vif.addr,
Johannes Berg32bfd352007-12-19 01:31:26 +0100615 &sdata->vif);
Johannes Bergdabeb342007-11-09 01:57:29 +0100616 }
Johannes Berge38bad42007-11-28 10:55:32 +0100617
Johannes Bergc7c71062013-08-21 22:07:20 +0200618 sdata = rcu_dereference_check(local->monitor_sdata,
619 lockdep_is_held(&local->iflist_mtx) ||
620 lockdep_rtnl_is_held());
Johannes Berg8b2c9822012-11-06 20:23:30 +0100621 if (sdata &&
Arik Nemtsov3384d752015-03-01 09:10:15 +0200622 (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only ||
Johannes Berg8b2c9822012-11-06 20:23:30 +0100623 sdata->flags & IEEE80211_SDATA_IN_DRIVER))
Johannes Berg685fb722012-07-11 16:38:09 +0200624 iterator(data, sdata->vif.addr, &sdata->vif);
Johannes Bergc7c71062013-08-21 22:07:20 +0200625}
Johannes Berg685fb722012-07-11 16:38:09 +0200626
Arik Nemtsov3384d752015-03-01 09:10:15 +0200627void ieee80211_iterate_interfaces(
Johannes Bergc7c71062013-08-21 22:07:20 +0200628 struct ieee80211_hw *hw, u32 iter_flags,
629 void (*iterator)(void *data, u8 *mac,
630 struct ieee80211_vif *vif),
631 void *data)
632{
633 struct ieee80211_local *local = hw_to_local(hw);
634
635 mutex_lock(&local->iflist_mtx);
Arik Nemtsov3384d752015-03-01 09:10:15 +0200636 __iterate_interfaces(local, iter_flags, iterator, data);
Johannes Bergc7c71062013-08-21 22:07:20 +0200637 mutex_unlock(&local->iflist_mtx);
638}
Arik Nemtsov3384d752015-03-01 09:10:15 +0200639EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
Johannes Bergc7c71062013-08-21 22:07:20 +0200640
641void ieee80211_iterate_active_interfaces_atomic(
642 struct ieee80211_hw *hw, u32 iter_flags,
643 void (*iterator)(void *data, u8 *mac,
644 struct ieee80211_vif *vif),
645 void *data)
646{
647 struct ieee80211_local *local = hw_to_local(hw);
648
649 rcu_read_lock();
Arik Nemtsov3384d752015-03-01 09:10:15 +0200650 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
651 iterator, data);
Johannes Berge38bad42007-11-28 10:55:32 +0100652 rcu_read_unlock();
Johannes Bergdabeb342007-11-09 01:57:29 +0100653}
Ivo van Doorn2f561fe2008-05-10 13:40:49 +0200654EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
Johannes Berg37ffc8d2008-09-08 16:40:36 +0200655
Johannes Bergc7c71062013-08-21 22:07:20 +0200656void ieee80211_iterate_active_interfaces_rtnl(
657 struct ieee80211_hw *hw, u32 iter_flags,
658 void (*iterator)(void *data, u8 *mac,
659 struct ieee80211_vif *vif),
660 void *data)
661{
662 struct ieee80211_local *local = hw_to_local(hw);
663
664 ASSERT_RTNL();
665
Arik Nemtsov3384d752015-03-01 09:10:15 +0200666 __iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
667 iterator, data);
Johannes Bergc7c71062013-08-21 22:07:20 +0200668}
669EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
670
Arik Nemtsov0fc1e042014-10-22 12:30:59 +0300671static void __iterate_stations(struct ieee80211_local *local,
672 void (*iterator)(void *data,
673 struct ieee80211_sta *sta),
674 void *data)
675{
676 struct sta_info *sta;
677
678 list_for_each_entry_rcu(sta, &local->sta_list, list) {
679 if (!sta->uploaded)
680 continue;
681
682 iterator(data, &sta->sta);
683 }
684}
685
686void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
687 void (*iterator)(void *data,
688 struct ieee80211_sta *sta),
689 void *data)
690{
691 struct ieee80211_local *local = hw_to_local(hw);
692
693 rcu_read_lock();
694 __iterate_stations(local, iterator, data);
695 rcu_read_unlock();
696}
697EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
698
Johannes Bergad7e7182013-11-13 13:37:47 +0100699struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
700{
701 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
702
703 if (!ieee80211_sdata_running(sdata) ||
704 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
705 return NULL;
706 return &sdata->vif;
707}
708EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
709
Emmanuel Grumbachdc5a1ad2015-03-12 08:53:24 +0200710struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
711{
Johannes Berg6513e982015-06-10 20:18:55 +0300712 struct ieee80211_sub_if_data *sdata;
713
714 if (!vif)
715 return NULL;
716
717 sdata = vif_to_sdata(vif);
Emmanuel Grumbachdc5a1ad2015-03-12 08:53:24 +0200718
719 if (!ieee80211_sdata_running(sdata) ||
720 !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
721 return NULL;
722
723 return &sdata->wdev;
724}
725EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev);
726
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400727/*
728 * Nothing should have been stuffed into the workqueue during
Emmanuel Grumbach4afaff12015-01-22 23:32:46 +0200729 * the suspend->resume cycle. Since we can't check each caller
730 * of this function if we are already quiescing / suspended,
731 * check here and don't WARN since this can actually happen when
732 * the rx path (for example) is racing against __ieee80211_suspend
733 * and suspending / quiescing was set after the rx path checked
734 * them.
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400735 */
736static bool ieee80211_can_queue_work(struct ieee80211_local *local)
737{
Emmanuel Grumbach4afaff12015-01-22 23:32:46 +0200738 if (local->quiescing || (local->suspended && !local->resuming)) {
739 pr_warn("queueing ieee80211 work while going to suspend\n");
Johannes Bergceb99fe2009-11-19 14:29:39 +0100740 return false;
Emmanuel Grumbach4afaff12015-01-22 23:32:46 +0200741 }
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400742
743 return true;
744}
745
746void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
747{
748 struct ieee80211_local *local = hw_to_local(hw);
749
750 if (!ieee80211_can_queue_work(local))
751 return;
752
753 queue_work(local->workqueue, work);
754}
755EXPORT_SYMBOL(ieee80211_queue_work);
756
757void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
758 struct delayed_work *dwork,
759 unsigned long delay)
760{
761 struct ieee80211_local *local = hw_to_local(hw);
762
763 if (!ieee80211_can_queue_work(local))
764 return;
765
766 queue_delayed_work(local->workqueue, dwork, delay);
767}
768EXPORT_SYMBOL(ieee80211_queue_delayed_work);
769
Johannes Berg35d865a2013-05-28 10:54:03 +0200770u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
Johannes Bergdd769862011-11-18 16:54:50 +0100771 struct ieee802_11_elems *elems,
772 u64 filter, u32 crc)
773{
774 size_t left = len;
Johannes Berg35d865a2013-05-28 10:54:03 +0200775 const u8 *pos = start;
Johannes Bergdd769862011-11-18 16:54:50 +0100776 bool calc_crc = filter != 0;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800777 DECLARE_BITMAP(seen_elems, 256);
Johannes Bergb2e506b2013-03-26 14:54:16 +0100778 const u8 *ie;
Johannes Bergdd769862011-11-18 16:54:50 +0100779
Paul Stewartfcff4f12012-02-23 17:59:53 -0800780 bitmap_zero(seen_elems, 256);
Johannes Bergdd769862011-11-18 16:54:50 +0100781 memset(elems, 0, sizeof(*elems));
782 elems->ie_start = start;
783 elems->total_len = len;
784
785 while (left >= 2) {
786 u8 id, elen;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800787 bool elem_parse_failed;
Johannes Bergdd769862011-11-18 16:54:50 +0100788
789 id = *pos++;
790 elen = *pos++;
791 left -= 2;
792
Paul Stewartfcff4f12012-02-23 17:59:53 -0800793 if (elen > left) {
794 elems->parse_error = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100795 break;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800796 }
797
Johannes Berg9690fb12012-10-24 14:19:53 +0200798 switch (id) {
799 case WLAN_EID_SSID:
800 case WLAN_EID_SUPP_RATES:
801 case WLAN_EID_FH_PARAMS:
802 case WLAN_EID_DS_PARAMS:
803 case WLAN_EID_CF_PARAMS:
804 case WLAN_EID_TIM:
805 case WLAN_EID_IBSS_PARAMS:
806 case WLAN_EID_CHALLENGE:
807 case WLAN_EID_RSN:
808 case WLAN_EID_ERP_INFO:
809 case WLAN_EID_EXT_SUPP_RATES:
810 case WLAN_EID_HT_CAPABILITY:
811 case WLAN_EID_HT_OPERATION:
812 case WLAN_EID_VHT_CAPABILITY:
813 case WLAN_EID_VHT_OPERATION:
814 case WLAN_EID_MESH_ID:
815 case WLAN_EID_MESH_CONFIG:
816 case WLAN_EID_PEER_MGMT:
817 case WLAN_EID_PREQ:
818 case WLAN_EID_PREP:
819 case WLAN_EID_PERR:
820 case WLAN_EID_RANN:
821 case WLAN_EID_CHANNEL_SWITCH:
822 case WLAN_EID_EXT_CHANSWITCH_ANN:
823 case WLAN_EID_COUNTRY:
824 case WLAN_EID_PWR_CONSTRAINT:
825 case WLAN_EID_TIMEOUT_INTERVAL:
Johannes Berg85220d72013-03-25 18:29:27 +0100826 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
Johannes Bergb2e506b2013-03-26 14:54:16 +0100827 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
Chun-Yeow Yeoh8f2535b2013-10-14 19:08:27 -0700828 case WLAN_EID_CHAN_SWITCH_PARAM:
Arik Nemtsov9041c1f2014-11-09 18:50:15 +0200829 case WLAN_EID_EXT_CAPABILITY:
Arik Nemtsov538375842014-11-09 18:50:18 +0200830 case WLAN_EID_CHAN_SWITCH_TIMING:
831 case WLAN_EID_LINK_ID:
Avraham Sterne38a0172017-04-26 10:58:47 +0300832 case WLAN_EID_BSS_MAX_IDLE_PERIOD:
Johannes Bergb2e506b2013-03-26 14:54:16 +0100833 /*
834 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
835 * that if the content gets bigger it might be needed more than once
836 */
Johannes Berg9690fb12012-10-24 14:19:53 +0200837 if (test_bit(id, seen_elems)) {
838 elems->parse_error = true;
839 left -= elen;
840 pos += elen;
841 continue;
842 }
843 break;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800844 }
Johannes Bergdd769862011-11-18 16:54:50 +0100845
846 if (calc_crc && id < 64 && (filter & (1ULL << id)))
847 crc = crc32_be(crc, pos - 2, elen + 2);
848
Paul Stewartfcff4f12012-02-23 17:59:53 -0800849 elem_parse_failed = false;
850
Johannes Bergdd769862011-11-18 16:54:50 +0100851 switch (id) {
Arik Nemtsov538375842014-11-09 18:50:18 +0200852 case WLAN_EID_LINK_ID:
853 if (elen + 2 != sizeof(struct ieee80211_tdls_lnkie)) {
854 elem_parse_failed = true;
855 break;
856 }
857 elems->lnk_id = (void *)(pos - 2);
858 break;
859 case WLAN_EID_CHAN_SWITCH_TIMING:
860 if (elen != sizeof(struct ieee80211_ch_switch_timing)) {
861 elem_parse_failed = true;
862 break;
863 }
864 elems->ch_sw_timing = (void *)pos;
865 break;
Arik Nemtsov9041c1f2014-11-09 18:50:15 +0200866 case WLAN_EID_EXT_CAPABILITY:
867 elems->ext_capab = pos;
868 elems->ext_capab_len = elen;
869 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100870 case WLAN_EID_SSID:
871 elems->ssid = pos;
872 elems->ssid_len = elen;
873 break;
874 case WLAN_EID_SUPP_RATES:
875 elems->supp_rates = pos;
876 elems->supp_rates_len = elen;
877 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100878 case WLAN_EID_DS_PARAMS:
Johannes Berg1cd8e882013-03-27 14:30:12 +0100879 if (elen >= 1)
880 elems->ds_params = pos;
881 else
882 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100883 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100884 case WLAN_EID_TIM:
885 if (elen >= sizeof(struct ieee80211_tim_ie)) {
886 elems->tim = (void *)pos;
887 elems->tim_len = elen;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800888 } else
889 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100890 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100891 case WLAN_EID_CHALLENGE:
892 elems->challenge = pos;
893 elems->challenge_len = elen;
894 break;
895 case WLAN_EID_VENDOR_SPECIFIC:
896 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
897 pos[2] == 0xf2) {
898 /* Microsoft OUI (00:50:F2) */
899
900 if (calc_crc)
901 crc = crc32_be(crc, pos - 2, elen + 2);
902
Johannes Berg441a33b2013-02-12 16:27:04 +0100903 if (elen >= 5 && pos[3] == 2) {
Johannes Bergdd769862011-11-18 16:54:50 +0100904 /* OUI Type 2 - WMM IE */
905 if (pos[4] == 0) {
906 elems->wmm_info = pos;
907 elems->wmm_info_len = elen;
908 } else if (pos[4] == 1) {
909 elems->wmm_param = pos;
910 elems->wmm_param_len = elen;
911 }
912 }
913 }
914 break;
915 case WLAN_EID_RSN:
916 elems->rsn = pos;
917 elems->rsn_len = elen;
918 break;
919 case WLAN_EID_ERP_INFO:
Johannes Berg1946bed2013-03-27 14:31:53 +0100920 if (elen >= 1)
921 elems->erp_info = pos;
922 else
923 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100924 break;
925 case WLAN_EID_EXT_SUPP_RATES:
926 elems->ext_supp_rates = pos;
927 elems->ext_supp_rates_len = elen;
928 break;
929 case WLAN_EID_HT_CAPABILITY:
930 if (elen >= sizeof(struct ieee80211_ht_cap))
931 elems->ht_cap_elem = (void *)pos;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800932 else
933 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100934 break;
Johannes Berg074d46d2012-03-15 19:45:16 +0100935 case WLAN_EID_HT_OPERATION:
936 if (elen >= sizeof(struct ieee80211_ht_operation))
937 elems->ht_operation = (void *)pos;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800938 else
939 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100940 break;
Mahesh Palivela818255e2012-10-10 11:33:04 +0000941 case WLAN_EID_VHT_CAPABILITY:
942 if (elen >= sizeof(struct ieee80211_vht_cap))
943 elems->vht_cap_elem = (void *)pos;
944 else
945 elem_parse_failed = true;
946 break;
947 case WLAN_EID_VHT_OPERATION:
948 if (elen >= sizeof(struct ieee80211_vht_operation))
949 elems->vht_operation = (void *)pos;
950 else
951 elem_parse_failed = true;
952 break;
Johannes Bergbee7f5862013-02-07 22:24:55 +0100953 case WLAN_EID_OPMODE_NOTIF:
954 if (elen > 0)
955 elems->opmode_notif = pos;
956 else
957 elem_parse_failed = true;
958 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100959 case WLAN_EID_MESH_ID:
960 elems->mesh_id = pos;
961 elems->mesh_id_len = elen;
962 break;
963 case WLAN_EID_MESH_CONFIG:
964 if (elen >= sizeof(struct ieee80211_meshconf_ie))
965 elems->mesh_config = (void *)pos;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800966 else
967 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100968 break;
969 case WLAN_EID_PEER_MGMT:
970 elems->peering = pos;
971 elems->peering_len = elen;
972 break;
Marco Porsch3f52b7e2013-01-30 18:14:08 +0100973 case WLAN_EID_MESH_AWAKE_WINDOW:
974 if (elen >= 2)
975 elems->awake_window = (void *)pos;
976 break;
Johannes Bergdd769862011-11-18 16:54:50 +0100977 case WLAN_EID_PREQ:
978 elems->preq = pos;
979 elems->preq_len = elen;
980 break;
981 case WLAN_EID_PREP:
982 elems->prep = pos;
983 elems->prep_len = elen;
984 break;
985 case WLAN_EID_PERR:
986 elems->perr = pos;
987 elems->perr_len = elen;
988 break;
989 case WLAN_EID_RANN:
990 if (elen >= sizeof(struct ieee80211_rann_ie))
991 elems->rann = (void *)pos;
Paul Stewartfcff4f12012-02-23 17:59:53 -0800992 else
993 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +0100994 break;
995 case WLAN_EID_CHANNEL_SWITCH:
Johannes Berg5bc14202012-08-01 16:13:02 +0200996 if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
997 elem_parse_failed = true;
998 break;
999 }
1000 elems->ch_switch_ie = (void *)pos;
Johannes Bergdd769862011-11-18 16:54:50 +01001001 break;
Johannes Bergb4f286a12013-03-26 14:13:58 +01001002 case WLAN_EID_EXT_CHANSWITCH_ANN:
1003 if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
1004 elem_parse_failed = true;
1005 break;
1006 }
1007 elems->ext_chansw_ie = (void *)pos;
1008 break;
Johannes Berg85220d72013-03-25 18:29:27 +01001009 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
1010 if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
1011 elem_parse_failed = true;
1012 break;
1013 }
1014 elems->sec_chan_offs = (void *)pos;
1015 break;
Chun-Yeow Yeoh8f2535b2013-10-14 19:08:27 -07001016 case WLAN_EID_CHAN_SWITCH_PARAM:
1017 if (elen !=
1018 sizeof(*elems->mesh_chansw_params_ie)) {
1019 elem_parse_failed = true;
1020 break;
1021 }
1022 elems->mesh_chansw_params_ie = (void *)pos;
1023 break;
Johannes Bergb2e506b2013-03-26 14:54:16 +01001024 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
1025 if (!action ||
1026 elen != sizeof(*elems->wide_bw_chansw_ie)) {
1027 elem_parse_failed = true;
1028 break;
1029 }
1030 elems->wide_bw_chansw_ie = (void *)pos;
1031 break;
1032 case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
1033 if (action) {
1034 elem_parse_failed = true;
1035 break;
1036 }
1037 /*
1038 * This is a bit tricky, but as we only care about
1039 * the wide bandwidth channel switch element, so
1040 * just parse it out manually.
1041 */
1042 ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
1043 pos, elen);
1044 if (ie) {
1045 if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
1046 elems->wide_bw_chansw_ie =
1047 (void *)(ie + 2);
1048 else
1049 elem_parse_failed = true;
1050 }
1051 break;
Johannes Bergdd769862011-11-18 16:54:50 +01001052 case WLAN_EID_COUNTRY:
1053 elems->country_elem = pos;
1054 elems->country_elem_len = elen;
1055 break;
1056 case WLAN_EID_PWR_CONSTRAINT:
Johannes Berg761a48d2012-09-05 13:07:00 +02001057 if (elen != 1) {
1058 elem_parse_failed = true;
1059 break;
1060 }
Johannes Bergdd769862011-11-18 16:54:50 +01001061 elems->pwr_constr_elem = pos;
Johannes Bergdd769862011-11-18 16:54:50 +01001062 break;
Steinar H. Gundersonc8d65912014-09-03 06:48:37 -07001063 case WLAN_EID_CISCO_VENDOR_SPECIFIC:
1064 /* Lots of different options exist, but we only care
1065 * about the Dynamic Transmit Power Control element.
1066 * First check for the Cisco OUI, then for the DTPC
1067 * tag (0x00).
1068 */
1069 if (elen < 4) {
1070 elem_parse_failed = true;
1071 break;
1072 }
1073
1074 if (pos[0] != 0x00 || pos[1] != 0x40 ||
1075 pos[2] != 0x96 || pos[3] != 0x00)
1076 break;
1077
1078 if (elen != 6) {
1079 elem_parse_failed = true;
1080 break;
1081 }
1082
1083 if (calc_crc)
1084 crc = crc32_be(crc, pos - 2, elen + 2);
1085
1086 elems->cisco_dtpc_elem = pos;
1087 break;
Johannes Bergdd769862011-11-18 16:54:50 +01001088 case WLAN_EID_TIMEOUT_INTERVAL:
Johannes Berg79ba1d82013-03-27 14:38:07 +01001089 if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
1090 elems->timeout_int = (void *)pos;
1091 else
1092 elem_parse_failed = true;
Johannes Bergdd769862011-11-18 16:54:50 +01001093 break;
Avraham Sterne38a0172017-04-26 10:58:47 +03001094 case WLAN_EID_BSS_MAX_IDLE_PERIOD:
1095 if (elen >= sizeof(*elems->max_idle_period_ie))
1096 elems->max_idle_period_ie = (void *)pos;
1097 break;
Johannes Bergdd769862011-11-18 16:54:50 +01001098 default:
1099 break;
1100 }
1101
Paul Stewartfcff4f12012-02-23 17:59:53 -08001102 if (elem_parse_failed)
1103 elems->parse_error = true;
1104 else
Johannes Berg5df45692012-10-24 14:22:37 +02001105 __set_bit(id, seen_elems);
Paul Stewartfcff4f12012-02-23 17:59:53 -08001106
Johannes Bergdd769862011-11-18 16:54:50 +01001107 left -= elen;
1108 pos += elen;
1109 }
1110
Paul Stewartfcff4f12012-02-23 17:59:53 -08001111 if (left != 0)
1112 elems->parse_error = true;
1113
Johannes Bergdd769862011-11-18 16:54:50 +01001114 return crc;
1115}
1116
Haim Dreyfusse552af02018-03-28 13:24:10 +03001117void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
1118 struct ieee80211_tx_queue_params
1119 *qparam, int ac)
1120{
1121 struct ieee80211_chanctx_conf *chanctx_conf;
1122 const struct ieee80211_reg_rule *rrule;
Stanislaw Gruszka38cb87e2018-08-22 13:52:21 +02001123 const struct ieee80211_wmm_ac *wmm_ac;
Haim Dreyfusse552af02018-03-28 13:24:10 +03001124 u16 center_freq = 0;
1125
1126 if (sdata->vif.type != NL80211_IFTYPE_AP &&
1127 sdata->vif.type != NL80211_IFTYPE_STATION)
1128 return;
1129
1130 rcu_read_lock();
1131 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1132 if (chanctx_conf)
1133 center_freq = chanctx_conf->def.chan->center_freq;
1134
1135 if (!center_freq) {
1136 rcu_read_unlock();
1137 return;
1138 }
1139
1140 rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq));
1141
Stanislaw Gruszka38cb87e2018-08-22 13:52:21 +02001142 if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) {
Haim Dreyfusse552af02018-03-28 13:24:10 +03001143 rcu_read_unlock();
1144 return;
1145 }
1146
1147 if (sdata->vif.type == NL80211_IFTYPE_AP)
Stanislaw Gruszka38cb87e2018-08-22 13:52:21 +02001148 wmm_ac = &rrule->wmm_rule.ap[ac];
Haim Dreyfusse552af02018-03-28 13:24:10 +03001149 else
Stanislaw Gruszka38cb87e2018-08-22 13:52:21 +02001150 wmm_ac = &rrule->wmm_rule.client[ac];
Haim Dreyfusse552af02018-03-28 13:24:10 +03001151 qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min);
1152 qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max);
1153 qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn);
Dreyfuss, Haimabd76d22018-08-31 11:31:04 +03001154 qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32);
Haim Dreyfusse552af02018-03-28 13:24:10 +03001155 rcu_read_unlock();
1156}
1157
Johannes Berg3abead52012-03-02 15:56:59 +01001158void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
Johannes Bergcec66282015-10-22 17:46:04 +02001159 bool bss_notify, bool enable_qos)
Johannes Berg5825fe102008-09-09 12:56:01 +02001160{
1161 struct ieee80211_local *local = sdata->local;
1162 struct ieee80211_tx_queue_params qparam;
Johannes Berg55de9082012-07-26 17:24:39 +02001163 struct ieee80211_chanctx_conf *chanctx_conf;
Johannes Berg54bcbc62012-03-28 11:04:25 +02001164 int ac;
Johannes Bergcec66282015-10-22 17:46:04 +02001165 bool use_11b;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001166 bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */
Johannes Bergaa837e12009-05-07 16:16:24 +02001167 int aCWmin, aCWmax;
Johannes Berg5825fe102008-09-09 12:56:01 +02001168
1169 if (!local->ops->conf_tx)
1170 return;
1171
Johannes Berg54bcbc62012-03-28 11:04:25 +02001172 if (local->hw.queues < IEEE80211_NUM_ACS)
1173 return;
1174
Johannes Berg5825fe102008-09-09 12:56:01 +02001175 memset(&qparam, 0, sizeof(qparam));
1176
Johannes Berg55de9082012-07-26 17:24:39 +02001177 rcu_read_lock();
1178 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1179 use_11b = (chanctx_conf &&
Johannes Berg57fbcce2016-04-12 15:56:15 +02001180 chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) &&
Johannes Bergaa837e12009-05-07 16:16:24 +02001181 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
Johannes Berg55de9082012-07-26 17:24:39 +02001182 rcu_read_unlock();
Johannes Berg5825fe102008-09-09 12:56:01 +02001183
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001184 is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB);
1185
Fred Zhou1f4ffde2013-09-09 23:03:41 +08001186 /* Set defaults according to 802.11-2007 Table 7-37 */
1187 aCWmax = 1023;
1188 if (use_11b)
1189 aCWmin = 31;
1190 else
1191 aCWmin = 15;
Johannes Berg5825fe102008-09-09 12:56:01 +02001192
Fred Zhou1f4ffde2013-09-09 23:03:41 +08001193 /* Confiure old 802.11b/g medium access rules. */
1194 qparam.cw_max = aCWmax;
1195 qparam.cw_min = aCWmin;
1196 qparam.txop = 0;
1197 qparam.aifs = 2;
1198
1199 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1200 /* Update if QoS is enabled. */
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001201 if (enable_qos) {
1202 switch (ac) {
1203 case IEEE80211_AC_BK:
1204 qparam.cw_max = aCWmax;
1205 qparam.cw_min = aCWmin;
1206 qparam.txop = 0;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001207 if (is_ocb)
1208 qparam.aifs = 9;
1209 else
1210 qparam.aifs = 7;
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001211 break;
1212 /* never happens but let's not leave undefined */
1213 default:
1214 case IEEE80211_AC_BE:
1215 qparam.cw_max = aCWmax;
1216 qparam.cw_min = aCWmin;
1217 qparam.txop = 0;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001218 if (is_ocb)
1219 qparam.aifs = 6;
1220 else
1221 qparam.aifs = 3;
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001222 break;
1223 case IEEE80211_AC_VI:
1224 qparam.cw_max = aCWmin;
1225 qparam.cw_min = (aCWmin + 1) / 2 - 1;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001226 if (is_ocb)
1227 qparam.txop = 0;
1228 else if (use_11b)
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001229 qparam.txop = 6016/32;
1230 else
1231 qparam.txop = 3008/32;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001232
1233 if (is_ocb)
1234 qparam.aifs = 3;
1235 else
1236 qparam.aifs = 2;
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001237 break;
1238 case IEEE80211_AC_VO:
1239 qparam.cw_max = (aCWmin + 1) / 2 - 1;
1240 qparam.cw_min = (aCWmin + 1) / 4 - 1;
Rostislav Lisovy239281f2014-11-03 10:33:19 +01001241 if (is_ocb)
1242 qparam.txop = 0;
1243 else if (use_11b)
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001244 qparam.txop = 3264/32;
1245 else
1246 qparam.txop = 1504/32;
1247 qparam.aifs = 2;
1248 break;
1249 }
Johannes Bergaa837e12009-05-07 16:16:24 +02001250 }
Haim Dreyfusse552af02018-03-28 13:24:10 +03001251 ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac);
Johannes Berg5825fe102008-09-09 12:56:01 +02001252
Kalle Valoab133152010-01-12 10:42:31 +02001253 qparam.uapsd = false;
1254
Johannes Berg54bcbc62012-03-28 11:04:25 +02001255 sdata->tx_conf[ac] = qparam;
1256 drv_conf_tx(local, sdata, ac, &qparam);
Johannes Bergaa837e12009-05-07 16:16:24 +02001257 }
Stanislaw Gruszkae1b3ec12010-03-29 12:18:34 +02001258
Johannes Bergf142c6b2012-06-18 20:07:15 +02001259 if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
Ayala Beker708d50e2016-09-20 17:31:14 +03001260 sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
1261 sdata->vif.type != NL80211_IFTYPE_NAN) {
Stanislaw Gruszkaa8ce85442012-05-30 10:56:46 +02001262 sdata->vif.bss_conf.qos = enable_qos;
Johannes Berg3abead52012-03-02 15:56:59 +01001263 if (bss_notify)
1264 ieee80211_bss_info_change_notify(sdata,
1265 BSS_CHANGED_QOS);
Sujithd9734972010-07-23 10:47:11 +05301266 }
Johannes Berg5825fe102008-09-09 12:56:01 +02001267}
Johannes Berge50db652008-09-09 15:07:09 +02001268
Johannes Berg46900292009-02-15 12:44:28 +01001269void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
Jouni Malinen700e8ea2012-09-30 19:29:37 +03001270 u16 transaction, u16 auth_alg, u16 status,
Johannes Berg4a3cb702013-02-12 16:43:19 +01001271 const u8 *extra, size_t extra_len, const u8 *da,
Johannes Berg1672c0e32013-01-29 15:02:27 +01001272 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1273 u32 tx_flags)
Johannes Berg46900292009-02-15 12:44:28 +01001274{
1275 struct ieee80211_local *local = sdata->local;
1276 struct sk_buff *skb;
1277 struct ieee80211_mgmt *mgmt;
Johannes Bergfffd0932009-07-08 14:22:54 +02001278 int err;
Johannes Berg46900292009-02-15 12:44:28 +01001279
Fred Zhou15e230a2013-09-24 10:33:01 +08001280 /* 24 + 6 = header + auth_algo + auth_transaction + status_code */
Max Stepanov744462a2014-06-10 20:00:08 +03001281 skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN +
1282 24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN);
Joe Perchesd15b8452011-08-29 14:17:31 -07001283 if (!skb)
Johannes Berg46900292009-02-15 12:44:28 +01001284 return;
Joe Perchesd15b8452011-08-29 14:17:31 -07001285
Max Stepanov744462a2014-06-10 20:00:08 +03001286 skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN);
Johannes Berg46900292009-02-15 12:44:28 +01001287
Johannes Bergb080db52017-06-16 14:29:19 +02001288 mgmt = skb_put_zero(skb, 24 + 6);
Johannes Berg46900292009-02-15 12:44:28 +01001289 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1290 IEEE80211_STYPE_AUTH);
Antonio Quartulliefa6a092012-01-09 19:43:06 +01001291 memcpy(mgmt->da, da, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +01001292 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +01001293 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1294 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1295 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
Jouni Malinen700e8ea2012-09-30 19:29:37 +03001296 mgmt->u.auth.status_code = cpu_to_le16(status);
Johannes Berg46900292009-02-15 12:44:28 +01001297 if (extra)
Johannes Berg59ae1d12017-06-16 14:29:20 +02001298 skb_put_data(skb, extra, extra_len);
Johannes Berg46900292009-02-15 12:44:28 +01001299
Johannes Bergfffd0932009-07-08 14:22:54 +02001300 if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1301 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1302 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1303 WARN_ON(err);
1304 }
1305
Johannes Berg1672c0e32013-01-29 15:02:27 +01001306 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1307 tx_flags;
Johannes Berg62ae67b2009-11-18 18:42:05 +01001308 ieee80211_tx_skb(sdata, skb);
Johannes Berg46900292009-02-15 12:44:28 +01001309}
1310
Antonio Quartulli6ae16772012-09-07 13:28:52 +02001311void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1312 const u8 *bssid, u16 stype, u16 reason,
1313 bool send_frame, u8 *frame_buf)
1314{
1315 struct ieee80211_local *local = sdata->local;
1316 struct sk_buff *skb;
1317 struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1318
1319 /* build frame */
1320 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1321 mgmt->duration = 0; /* initialize only */
1322 mgmt->seq_ctrl = 0; /* initialize only */
1323 memcpy(mgmt->da, bssid, ETH_ALEN);
1324 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1325 memcpy(mgmt->bssid, bssid, ETH_ALEN);
1326 /* u.deauth.reason_code == u.disassoc.reason_code */
1327 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1328
1329 if (send_frame) {
1330 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1331 IEEE80211_DEAUTH_FRAME_LEN);
1332 if (!skb)
1333 return;
1334
1335 skb_reserve(skb, local->hw.extra_tx_headroom);
1336
1337 /* copy in frame */
Johannes Berg59ae1d12017-06-16 14:29:20 +02001338 skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN);
Antonio Quartulli6ae16772012-09-07 13:28:52 +02001339
1340 if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1341 !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1342 IEEE80211_SKB_CB(skb)->flags |=
1343 IEEE80211_TX_INTFL_DONT_ENCRYPT;
1344
1345 ieee80211_tx_skb(sdata, skb);
1346 }
1347}
1348
David Spinadelc56ef672014-02-05 15:21:13 +02001349static int ieee80211_build_preq_ies_band(struct ieee80211_local *local,
1350 u8 *buffer, size_t buffer_len,
1351 const u8 *ie, size_t ie_len,
Johannes Berg57fbcce2016-04-12 15:56:15 +02001352 enum nl80211_band band,
David Spinadelc56ef672014-02-05 15:21:13 +02001353 u32 rate_mask,
1354 struct cfg80211_chan_def *chandef,
1355 size_t *offset)
Johannes Bergde95a542009-04-01 11:58:36 +02001356{
1357 struct ieee80211_supported_band *sband;
Johannes Bergc604b9f2012-11-29 12:45:18 +01001358 u8 *pos = buffer, *end = buffer + buffer_len;
David Spinadelc56ef672014-02-05 15:21:13 +02001359 size_t noffset;
Johannes Berg8e664fb2009-12-23 13:15:38 +01001360 int supp_rates_len, i;
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001361 u8 rates[32];
1362 int num_rates;
1363 int ext_rates_len;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001364 int shift;
1365 u32 rate_flags;
Johannes Berg40a11ca2014-11-24 15:49:44 +01001366 bool have_80mhz = false;
Johannes Bergde95a542009-04-01 11:58:36 +02001367
David Spinadelc56ef672014-02-05 15:21:13 +02001368 *offset = 0;
1369
Johannes Berg4d36ec52009-10-27 20:59:55 +01001370 sband = local->hw.wiphy->bands[band];
Arik Nemtsovd811b3d2012-07-09 19:57:28 +03001371 if (WARN_ON_ONCE(!sband))
1372 return 0;
Johannes Bergde95a542009-04-01 11:58:36 +02001373
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001374 rate_flags = ieee80211_chandef_rate_flags(chandef);
1375 shift = ieee80211_chandef_get_shift(chandef);
1376
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001377 num_rates = 0;
1378 for (i = 0; i < sband->n_bitrates; i++) {
1379 if ((BIT(i) & rate_mask) == 0)
1380 continue; /* skip rate */
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001381 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1382 continue;
1383
1384 rates[num_rates++] =
1385 (u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
1386 (1 << shift) * 5);
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001387 }
1388
1389 supp_rates_len = min_t(int, num_rates, 8);
Johannes Berg8e664fb2009-12-23 13:15:38 +01001390
Johannes Bergc604b9f2012-11-29 12:45:18 +01001391 if (end - pos < 2 + supp_rates_len)
1392 goto out_err;
Johannes Bergde95a542009-04-01 11:58:36 +02001393 *pos++ = WLAN_EID_SUPP_RATES;
Johannes Berg8e664fb2009-12-23 13:15:38 +01001394 *pos++ = supp_rates_len;
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001395 memcpy(pos, rates, supp_rates_len);
1396 pos += supp_rates_len;
Johannes Bergde95a542009-04-01 11:58:36 +02001397
Johannes Berg8e664fb2009-12-23 13:15:38 +01001398 /* insert "request information" if in custom IEs */
1399 if (ie && ie_len) {
1400 static const u8 before_extrates[] = {
1401 WLAN_EID_SSID,
1402 WLAN_EID_SUPP_RATES,
1403 WLAN_EID_REQUEST,
1404 };
1405 noffset = ieee80211_ie_split(ie, ie_len,
1406 before_extrates,
1407 ARRAY_SIZE(before_extrates),
David Spinadelc56ef672014-02-05 15:21:13 +02001408 *offset);
1409 if (end - pos < noffset - *offset)
Johannes Bergc604b9f2012-11-29 12:45:18 +01001410 goto out_err;
David Spinadelc56ef672014-02-05 15:21:13 +02001411 memcpy(pos, ie + *offset, noffset - *offset);
1412 pos += noffset - *offset;
1413 *offset = noffset;
Johannes Berg8e664fb2009-12-23 13:15:38 +01001414 }
Johannes Bergde95a542009-04-01 11:58:36 +02001415
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001416 ext_rates_len = num_rates - supp_rates_len;
1417 if (ext_rates_len > 0) {
Johannes Bergc604b9f2012-11-29 12:45:18 +01001418 if (end - pos < 2 + ext_rates_len)
1419 goto out_err;
Johannes Berg8e664fb2009-12-23 13:15:38 +01001420 *pos++ = WLAN_EID_EXT_SUPP_RATES;
Jouni Malinen8dcb2002010-08-28 19:36:10 +03001421 *pos++ = ext_rates_len;
1422 memcpy(pos, rates + supp_rates_len, ext_rates_len);
1423 pos += ext_rates_len;
Johannes Berg8e664fb2009-12-23 13:15:38 +01001424 }
1425
Johannes Berg57fbcce2016-04-12 15:56:15 +02001426 if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
Johannes Bergc604b9f2012-11-29 12:45:18 +01001427 if (end - pos < 3)
1428 goto out_err;
Jouni Malinen651b5222010-08-28 19:37:51 +03001429 *pos++ = WLAN_EID_DS_PARAMS;
1430 *pos++ = 1;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001431 *pos++ = ieee80211_frequency_to_channel(
1432 chandef->chan->center_freq);
Jouni Malinen651b5222010-08-28 19:37:51 +03001433 }
1434
Johannes Berg8e664fb2009-12-23 13:15:38 +01001435 /* insert custom IEs that go before HT */
1436 if (ie && ie_len) {
1437 static const u8 before_ht[] = {
Johannes Berga7f26d82017-08-05 11:44:32 +03001438 /*
1439 * no need to list the ones split off already
1440 * (or generated here)
1441 */
Johannes Berg8e664fb2009-12-23 13:15:38 +01001442 WLAN_EID_DS_PARAMS,
1443 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1444 };
1445 noffset = ieee80211_ie_split(ie, ie_len,
1446 before_ht, ARRAY_SIZE(before_ht),
David Spinadelc56ef672014-02-05 15:21:13 +02001447 *offset);
1448 if (end - pos < noffset - *offset)
Johannes Bergc604b9f2012-11-29 12:45:18 +01001449 goto out_err;
David Spinadelc56ef672014-02-05 15:21:13 +02001450 memcpy(pos, ie + *offset, noffset - *offset);
1451 pos += noffset - *offset;
1452 *offset = noffset;
Johannes Bergde95a542009-04-01 11:58:36 +02001453 }
1454
Johannes Bergc604b9f2012-11-29 12:45:18 +01001455 if (sband->ht_cap.ht_supported) {
1456 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
1457 goto out_err;
Ben Greearef96a8422011-11-18 11:32:00 -08001458 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1459 sband->ht_cap.cap);
Johannes Bergc604b9f2012-11-29 12:45:18 +01001460 }
Johannes Berg5ef2d412009-03-31 12:12:07 +02001461
Johannes Bergde95a542009-04-01 11:58:36 +02001462 /*
1463 * If adding more here, adjust code in main.c
1464 * that calculates local->scan_ies_len.
1465 */
1466
Johannes Berg4d952302014-02-04 09:48:34 +01001467 /* insert custom IEs that go before VHT */
Johannes Berg8e664fb2009-12-23 13:15:38 +01001468 if (ie && ie_len) {
Johannes Berg4d952302014-02-04 09:48:34 +01001469 static const u8 before_vht[] = {
Johannes Berga7f26d82017-08-05 11:44:32 +03001470 /*
1471 * no need to list the ones split off already
1472 * (or generated here)
1473 */
Johannes Berg4d952302014-02-04 09:48:34 +01001474 WLAN_EID_BSS_COEX_2040,
1475 WLAN_EID_EXT_CAPABILITY,
1476 WLAN_EID_SSID_LIST,
1477 WLAN_EID_CHANNEL_USAGE,
1478 WLAN_EID_INTERWORKING,
Liad Kaufmanb44eebe2017-08-05 11:44:29 +03001479 WLAN_EID_MESH_ID,
Johannes Berga7f26d82017-08-05 11:44:32 +03001480 /* 60 GHz (Multi-band, DMG, MMS) can't happen */
Johannes Berg4d952302014-02-04 09:48:34 +01001481 };
1482 noffset = ieee80211_ie_split(ie, ie_len,
1483 before_vht, ARRAY_SIZE(before_vht),
David Spinadelc56ef672014-02-05 15:21:13 +02001484 *offset);
1485 if (end - pos < noffset - *offset)
Johannes Bergc604b9f2012-11-29 12:45:18 +01001486 goto out_err;
David Spinadelc56ef672014-02-05 15:21:13 +02001487 memcpy(pos, ie + *offset, noffset - *offset);
1488 pos += noffset - *offset;
1489 *offset = noffset;
Johannes Bergde95a542009-04-01 11:58:36 +02001490 }
1491
Johannes Berg40a11ca2014-11-24 15:49:44 +01001492 /* Check if any channel in this sband supports at least 80 MHz */
1493 for (i = 0; i < sband->n_channels; i++) {
Arik Nemtsovfa44b982015-01-01 13:43:17 +02001494 if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
1495 IEEE80211_CHAN_NO_80MHZ))
1496 continue;
1497
1498 have_80mhz = true;
1499 break;
Johannes Berg40a11ca2014-11-24 15:49:44 +01001500 }
1501
1502 if (sband->vht_cap.vht_supported && have_80mhz) {
Johannes Bergc604b9f2012-11-29 12:45:18 +01001503 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
1504 goto out_err;
Mahesh Palivelaba0afa22012-07-02 11:25:12 +00001505 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1506 sband->vht_cap.cap);
Johannes Bergc604b9f2012-11-29 12:45:18 +01001507 }
Mahesh Palivelaba0afa22012-07-02 11:25:12 +00001508
Johannes Bergde95a542009-04-01 11:58:36 +02001509 return pos - buffer;
Johannes Bergc604b9f2012-11-29 12:45:18 +01001510 out_err:
1511 WARN_ONCE(1, "not enough space for preq IEs\n");
1512 return pos - buffer;
Johannes Bergde95a542009-04-01 11:58:36 +02001513}
1514
David Spinadelc56ef672014-02-05 15:21:13 +02001515int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1516 size_t buffer_len,
1517 struct ieee80211_scan_ies *ie_desc,
1518 const u8 *ie, size_t ie_len,
1519 u8 bands_used, u32 *rate_masks,
1520 struct cfg80211_chan_def *chandef)
1521{
1522 size_t pos = 0, old_pos = 0, custom_ie_offset = 0;
1523 int i;
1524
1525 memset(ie_desc, 0, sizeof(*ie_desc));
1526
Johannes Berg57fbcce2016-04-12 15:56:15 +02001527 for (i = 0; i < NUM_NL80211_BANDS; i++) {
David Spinadelc56ef672014-02-05 15:21:13 +02001528 if (bands_used & BIT(i)) {
1529 pos += ieee80211_build_preq_ies_band(local,
1530 buffer + pos,
1531 buffer_len - pos,
1532 ie, ie_len, i,
1533 rate_masks[i],
1534 chandef,
1535 &custom_ie_offset);
1536 ie_desc->ies[i] = buffer + old_pos;
1537 ie_desc->len[i] = pos - old_pos;
1538 old_pos = pos;
1539 }
1540 }
1541
1542 /* add any remaining custom IEs */
1543 if (ie && ie_len) {
1544 if (WARN_ONCE(buffer_len - pos < ie_len - custom_ie_offset,
1545 "not enough space for preq custom IEs\n"))
1546 return pos;
1547 memcpy(buffer + pos, ie + custom_ie_offset,
1548 ie_len - custom_ie_offset);
1549 ie_desc->common_ies = buffer + pos;
1550 ie_desc->common_ie_len = ie_len - custom_ie_offset;
1551 pos += ie_len - custom_ie_offset;
1552 }
1553
1554 return pos;
1555};
1556
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001557struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
Johannes Berga344d672014-06-12 22:24:31 +02001558 const u8 *src, const u8 *dst,
1559 u32 ratemask,
Johannes Berg6b778632012-07-23 14:53:27 +02001560 struct ieee80211_channel *chan,
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001561 const u8 *ssid, size_t ssid_len,
Paul Stewarta806c552011-06-23 09:00:11 -08001562 const u8 *ie, size_t ie_len,
1563 bool directed)
Johannes Berg46900292009-02-15 12:44:28 +01001564{
1565 struct ieee80211_local *local = sdata->local;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001566 struct cfg80211_chan_def chandef;
Johannes Berg46900292009-02-15 12:44:28 +01001567 struct sk_buff *skb;
1568 struct ieee80211_mgmt *mgmt;
Johannes Bergb9a9ada2012-11-29 13:00:10 +01001569 int ies_len;
Johannes Berg57fbcce2016-04-12 15:56:15 +02001570 u32 rate_masks[NUM_NL80211_BANDS] = {};
David Spinadelc56ef672014-02-05 15:21:13 +02001571 struct ieee80211_scan_ies dummy_ie_desc;
Johannes Berg46900292009-02-15 12:44:28 +01001572
Paul Stewarta806c552011-06-23 09:00:11 -08001573 /*
1574 * Do not send DS Channel parameter for directed probe requests
1575 * in order to maximize the chance that we get a response. Some
1576 * badly-behaved APs don't respond when this parameter is included.
1577 */
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001578 chandef.width = sdata->vif.bss_conf.chandef.width;
Paul Stewarta806c552011-06-23 09:00:11 -08001579 if (directed)
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001580 chandef.chan = NULL;
Paul Stewarta806c552011-06-23 09:00:11 -08001581 else
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001582 chandef.chan = chan;
Jouni Malinen651b5222010-08-28 19:37:51 +03001583
Johannes Berga344d672014-06-12 22:24:31 +02001584 skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
1585 100 + ie_len);
Johannes Berg5b2bbf72011-11-08 13:04:41 +01001586 if (!skb)
Johannes Bergb9a9ada2012-11-29 13:00:10 +01001587 return NULL;
1588
David Spinadelc56ef672014-02-05 15:21:13 +02001589 rate_masks[chan->band] = ratemask;
Johannes Bergb9a9ada2012-11-29 13:00:10 +01001590 ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
David Spinadelc56ef672014-02-05 15:21:13 +02001591 skb_tailroom(skb), &dummy_ie_desc,
1592 ie, ie_len, BIT(chan->band),
1593 rate_masks, &chandef);
Johannes Bergb9a9ada2012-11-29 13:00:10 +01001594 skb_put(skb, ies_len);
Kalle Valo7c12ce82010-01-05 20:16:44 +02001595
Johannes Berg46900292009-02-15 12:44:28 +01001596 if (dst) {
Kalle Valo7c12ce82010-01-05 20:16:44 +02001597 mgmt = (struct ieee80211_mgmt *) skb->data;
Johannes Berg46900292009-02-15 12:44:28 +01001598 memcpy(mgmt->da, dst, ETH_ALEN);
1599 memcpy(mgmt->bssid, dst, ETH_ALEN);
Johannes Berg46900292009-02-15 12:44:28 +01001600 }
Johannes Berg46900292009-02-15 12:44:28 +01001601
Johannes Berg62ae67b2009-11-18 18:42:05 +01001602 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
Johannes Berg5b2bbf72011-11-08 13:04:41 +01001603
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001604 return skb;
1605}
1606
Johannes Berga344d672014-06-12 22:24:31 +02001607void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata,
1608 const u8 *src, const u8 *dst,
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001609 const u8 *ssid, size_t ssid_len,
Paul Stewarta806c552011-06-23 09:00:11 -08001610 const u8 *ie, size_t ie_len,
Johannes Berg1672c0e32013-01-29 15:02:27 +01001611 u32 ratemask, bool directed, u32 tx_flags,
Johannes Berg55de9082012-07-26 17:24:39 +02001612 struct ieee80211_channel *channel, bool scan)
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001613{
1614 struct sk_buff *skb;
1615
Johannes Berga344d672014-06-12 22:24:31 +02001616 skb = ieee80211_build_probe_req(sdata, src, dst, ratemask, channel,
Johannes Berg6b778632012-07-23 14:53:27 +02001617 ssid, ssid_len,
Johannes Berg85a237f2011-07-18 18:08:36 +02001618 ie, ie_len, directed);
Rajkumar Manoharanaad14ce2011-09-25 14:53:31 +05301619 if (skb) {
Johannes Berg1672c0e32013-01-29 15:02:27 +01001620 IEEE80211_SKB_CB(skb)->flags |= tx_flags;
Johannes Berg55de9082012-07-26 17:24:39 +02001621 if (scan)
1622 ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band);
1623 else
1624 ieee80211_tx_skb(sdata, skb);
Rajkumar Manoharanaad14ce2011-09-25 14:53:31 +05301625 }
Johannes Berg46900292009-02-15 12:44:28 +01001626}
1627
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001628u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
Johannes Berg46900292009-02-15 12:44:28 +01001629 struct ieee802_11_elems *elems,
Johannes Berg57fbcce2016-04-12 15:56:15 +02001630 enum nl80211_band band, u32 *basic_rates)
Johannes Berg46900292009-02-15 12:44:28 +01001631{
1632 struct ieee80211_supported_band *sband;
Johannes Berg46900292009-02-15 12:44:28 +01001633 size_t num_rates;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001634 u32 supp_rates, rate_flags;
1635 int i, j, shift;
Mohammed Shafi Shajakhan21a8e9d2017-04-27 12:45:38 +05301636
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001637 sband = sdata->local->hw.wiphy->bands[band];
Mohammed Shafi Shajakhan21a8e9d2017-04-27 12:45:38 +05301638 if (WARN_ON(!sband))
1639 return 1;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001640
1641 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
1642 shift = ieee80211_vif_get_shift(&sdata->vif);
Johannes Berg46900292009-02-15 12:44:28 +01001643
Johannes Berg46900292009-02-15 12:44:28 +01001644 num_rates = sband->n_bitrates;
1645 supp_rates = 0;
1646 for (i = 0; i < elems->supp_rates_len +
1647 elems->ext_supp_rates_len; i++) {
1648 u8 rate = 0;
1649 int own_rate;
Ashok Nagarajan9ebb61a2012-04-02 21:21:21 -07001650 bool is_basic;
Johannes Berg46900292009-02-15 12:44:28 +01001651 if (i < elems->supp_rates_len)
1652 rate = elems->supp_rates[i];
1653 else if (elems->ext_supp_rates)
1654 rate = elems->ext_supp_rates
1655 [i - elems->supp_rates_len];
1656 own_rate = 5 * (rate & 0x7f);
Ashok Nagarajan9ebb61a2012-04-02 21:21:21 -07001657 is_basic = !!(rate & 0x80);
1658
1659 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1660 continue;
1661
1662 for (j = 0; j < num_rates; j++) {
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001663 int brate;
1664 if ((rate_flags & sband->bitrates[j].flags)
1665 != rate_flags)
1666 continue;
1667
1668 brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
1669 1 << shift);
1670
1671 if (brate == own_rate) {
Johannes Berg46900292009-02-15 12:44:28 +01001672 supp_rates |= BIT(j);
Ashok Nagarajan9ebb61a2012-04-02 21:21:21 -07001673 if (basic_rates && is_basic)
1674 *basic_rates |= BIT(j);
1675 }
1676 }
Johannes Berg46900292009-02-15 12:44:28 +01001677 }
1678 return supp_rates;
1679}
Johannes Bergf2753dd2009-04-14 10:09:24 +02001680
Johannes Berg84f6a012009-08-20 20:02:20 +02001681void ieee80211_stop_device(struct ieee80211_local *local)
1682{
1683 ieee80211_led_radio(local, false);
Johannes Berg67408c82010-11-30 08:59:23 +01001684 ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
Johannes Berg84f6a012009-08-20 20:02:20 +02001685
1686 cancel_work_sync(&local->reconfig_filter);
Johannes Berg84f6a012009-08-20 20:02:20 +02001687
1688 flush_workqueue(local->workqueue);
Lennert Buytenhek678f4152010-01-10 14:07:53 +01001689 drv_stop(local);
Johannes Berg84f6a012009-08-20 20:02:20 +02001690}
1691
Johannes Berg74430f92015-12-08 16:04:38 +02001692static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
1693 bool aborted)
1694{
1695 /* It's possible that we don't handle the scan completion in
1696 * time during suspend, so if it's still marked as completed
1697 * here, queue the work and flush it to clean things up.
1698 * Instead of calling the worker function directly here, we
1699 * really queue it to avoid potential races with other flows
1700 * scheduling the same work.
1701 */
1702 if (test_bit(SCAN_COMPLETED, &local->scanning)) {
1703 /* If coming from reconfiguration failure, abort the scan so
1704 * we don't attempt to continue a partial HW scan - which is
1705 * possible otherwise if (e.g.) the 2.4 GHz portion was the
1706 * completed scan, and a 5 GHz portion is still pending.
1707 */
1708 if (aborted)
1709 set_bit(SCAN_ABORTED, &local->scanning);
1710 ieee80211_queue_delayed_work(&local->hw, &local->scan_work, 0);
1711 flush_delayed_work(&local->scan_work);
1712 }
1713}
1714
Johannes Bergf6837ba82014-04-30 14:19:04 +02001715static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
1716{
1717 struct ieee80211_sub_if_data *sdata;
1718 struct ieee80211_chanctx *ctx;
1719
1720 /*
1721 * We get here if during resume the device can't be restarted properly.
1722 * We might also get here if this happens during HW reset, which is a
1723 * slightly different situation and we need to drop all connections in
1724 * the latter case.
1725 *
1726 * Ask cfg80211 to turn off all interfaces, this will result in more
1727 * warnings but at least we'll then get into a clean stopped state.
1728 */
1729
1730 local->resuming = false;
1731 local->suspended = false;
Eliad Peller7584f882015-06-10 20:19:37 +03001732 local->in_reconfig = false;
Johannes Bergf6837ba82014-04-30 14:19:04 +02001733
Johannes Berg74430f92015-12-08 16:04:38 +02001734 ieee80211_flush_completed_scan(local, true);
1735
Johannes Bergf6837ba82014-04-30 14:19:04 +02001736 /* scheduled scan clearly can't be running any more, but tell
1737 * cfg80211 and clear local state
1738 */
1739 ieee80211_sched_scan_end(local);
1740
1741 list_for_each_entry(sdata, &local->interfaces, list)
1742 sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
1743
1744 /* Mark channel contexts as not being in the driver any more to avoid
1745 * removing them from the driver during the shutdown process...
1746 */
1747 mutex_lock(&local->chanctx_mtx);
1748 list_for_each_entry(ctx, &local->chanctx_list, list)
1749 ctx->driver_present = false;
1750 mutex_unlock(&local->chanctx_mtx);
1751
1752 cfg80211_shutdown_all_interfaces(local->hw.wiphy);
1753}
1754
Stanislaw Gruszka153a5fc42013-02-28 10:55:30 +01001755static void ieee80211_assign_chanctx(struct ieee80211_local *local,
1756 struct ieee80211_sub_if_data *sdata)
1757{
1758 struct ieee80211_chanctx_conf *conf;
1759 struct ieee80211_chanctx *ctx;
1760
1761 if (!local->use_chanctx)
1762 return;
1763
1764 mutex_lock(&local->chanctx_mtx);
1765 conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1766 lockdep_is_held(&local->chanctx_mtx));
1767 if (conf) {
1768 ctx = container_of(conf, struct ieee80211_chanctx, conf);
1769 drv_assign_vif_chanctx(local, sdata, ctx);
1770 }
1771 mutex_unlock(&local->chanctx_mtx);
1772}
1773
Johannes Berg1ea2c862015-12-08 16:04:39 +02001774static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
1775{
1776 struct ieee80211_local *local = sdata->local;
1777 struct sta_info *sta;
1778
1779 /* add STAs back */
1780 mutex_lock(&local->sta_mtx);
1781 list_for_each_entry(sta, &local->sta_list, list) {
1782 enum ieee80211_sta_state state;
1783
1784 if (!sta->uploaded || sta->sdata != sdata)
1785 continue;
1786
1787 for (state = IEEE80211_STA_NOTEXIST;
1788 state < sta->sta_state; state++)
1789 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1790 state + 1));
1791 }
1792 mutex_unlock(&local->sta_mtx);
1793}
1794
Ayala Beker167e33f2016-09-20 17:31:20 +03001795static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
1796{
1797 struct cfg80211_nan_func *func, **funcs;
1798 int res, id, i = 0;
1799
1800 res = drv_start_nan(sdata->local, sdata,
1801 &sdata->u.nan.conf);
1802 if (WARN_ON(res))
1803 return res;
1804
Kees Cook6396bb22018-06-12 14:03:40 -07001805 funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
1806 sizeof(*funcs),
1807 GFP_KERNEL);
Ayala Beker167e33f2016-09-20 17:31:20 +03001808 if (!funcs)
1809 return -ENOMEM;
1810
1811 /* Add all the functions:
1812 * This is a little bit ugly. We need to call a potentially sleeping
1813 * callback for each NAN function, so we can't hold the spinlock.
1814 */
1815 spin_lock_bh(&sdata->u.nan.func_lock);
1816
1817 idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
1818 funcs[i++] = func;
1819
1820 spin_unlock_bh(&sdata->u.nan.func_lock);
1821
1822 for (i = 0; funcs[i]; i++) {
1823 res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
1824 if (WARN_ON(res))
1825 ieee80211_nan_func_terminated(&sdata->vif,
1826 funcs[i]->instance_id,
1827 NL80211_NAN_FUNC_TERM_REASON_ERROR,
1828 GFP_KERNEL);
1829 }
1830
1831 kfree(funcs);
1832
1833 return 0;
1834}
1835
Johannes Bergf2753dd2009-04-14 10:09:24 +02001836int ieee80211_reconfig(struct ieee80211_local *local)
1837{
1838 struct ieee80211_hw *hw = &local->hw;
1839 struct ieee80211_sub_if_data *sdata;
Johannes Berg55de9082012-07-26 17:24:39 +02001840 struct ieee80211_chanctx *ctx;
Johannes Bergf2753dd2009-04-14 10:09:24 +02001841 struct sta_info *sta;
Eliad Peller2683d652011-07-14 20:29:42 +03001842 int res, i;
Johannes Bergd8881302013-01-10 23:55:33 +01001843 bool reconfig_due_to_wowlan = false;
David Spinadeld43c6b62013-12-08 21:48:57 +02001844 struct ieee80211_sub_if_data *sched_scan_sdata;
Johannes Berg6ea0a692014-11-19 11:55:49 +01001845 struct cfg80211_sched_scan_request *sched_scan_req;
David Spinadeld43c6b62013-12-08 21:48:57 +02001846 bool sched_scan_stopped = false;
Eliad Pellerb0485e92015-07-08 15:41:47 +03001847 bool suspended = local->suspended;
Johannes Bergd8881302013-01-10 23:55:33 +01001848
Eliad Peller0f8b8242014-12-14 11:05:53 +02001849 /* nothing to do if HW shouldn't run */
1850 if (!local->open_count)
1851 goto wake_up;
1852
Johannes Berg8f21b0a2013-01-11 00:28:01 +01001853#ifdef CONFIG_PM
Eliad Pellerb0485e92015-07-08 15:41:47 +03001854 if (suspended)
Johannes Bergceb99fe2009-11-19 14:29:39 +01001855 local->resuming = true;
Johannes Bergf2753dd2009-04-14 10:09:24 +02001856
Johannes Bergeecc4802011-05-04 15:37:29 +02001857 if (local->wowlan) {
Eliad Pellerb0485e92015-07-08 15:41:47 +03001858 /*
1859 * In the wowlan case, both mac80211 and the device
1860 * are functional when the resume op is called, so
1861 * clear local->suspended so the device could operate
1862 * normally (e.g. pass rx frames).
1863 */
1864 local->suspended = false;
Johannes Bergeecc4802011-05-04 15:37:29 +02001865 res = drv_resume(local);
Johannes Berg27b3eb92013-08-07 20:11:55 +02001866 local->wowlan = false;
Johannes Bergeecc4802011-05-04 15:37:29 +02001867 if (res < 0) {
1868 local->resuming = false;
1869 return res;
1870 }
1871 if (res == 0)
1872 goto wake_up;
1873 WARN_ON(res > 1);
1874 /*
1875 * res is 1, which means the driver requested
1876 * to go through a regular reset on wakeup.
Eliad Pellerb0485e92015-07-08 15:41:47 +03001877 * restore local->suspended in this case.
Johannes Bergeecc4802011-05-04 15:37:29 +02001878 */
Johannes Bergd8881302013-01-10 23:55:33 +01001879 reconfig_due_to_wowlan = true;
Eliad Pellerb0485e92015-07-08 15:41:47 +03001880 local->suspended = true;
Johannes Bergeecc4802011-05-04 15:37:29 +02001881 }
1882#endif
Johannes Berg94f9b972011-07-14 16:48:54 +02001883
1884 /*
Eliad Peller43d6df02015-10-25 10:59:35 +02001885 * In case of hw_restart during suspend (without wowlan),
1886 * cancel restart work, as we are reconfiguring the device
1887 * anyway.
1888 * Note that restart_work is scheduled on a frozen workqueue,
1889 * so we can't deadlock in this case.
1890 */
1891 if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
1892 cancel_work_sync(&local->restart_work);
1893
Eliad Peller968a76c2015-10-25 10:59:36 +02001894 local->started = false;
1895
Eliad Peller43d6df02015-10-25 10:59:35 +02001896 /*
Johannes Berg94f9b972011-07-14 16:48:54 +02001897 * Upon resume hardware can sometimes be goofy due to
1898 * various platform / driver / bus issues, so restarting
1899 * the device may at times not work immediately. Propagate
1900 * the error.
1901 */
1902 res = drv_start(local);
1903 if (res) {
Eliad Pellerb0485e92015-07-08 15:41:47 +03001904 if (suspended)
Johannes Bergf6837ba82014-04-30 14:19:04 +02001905 WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
1906 else
1907 WARN(1, "Hardware became unavailable during restart.\n");
1908 ieee80211_handle_reconfig_failure(local);
Johannes Berg94f9b972011-07-14 16:48:54 +02001909 return res;
Johannes Bergf2753dd2009-04-14 10:09:24 +02001910 }
1911
Yogesh Ashok Powar7f2819752011-12-30 16:34:25 +05301912 /* setup fragmentation threshold */
1913 drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
1914
1915 /* setup RTS threshold */
1916 drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
1917
1918 /* reset coverage class */
1919 drv_set_coverage_class(local, hw->wiphy->coverage_class);
1920
Johannes Berg94f9b972011-07-14 16:48:54 +02001921 ieee80211_led_radio(local, true);
1922 ieee80211_mod_tpt_led_trig(local,
1923 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1924
Johannes Bergf2753dd2009-04-14 10:09:24 +02001925 /* add interfaces */
Johannes Berg4b6f1dd2012-04-03 14:35:57 +02001926 sdata = rtnl_dereference(local->monitor_sdata);
1927 if (sdata) {
Johannes Berg3c3e21e2013-03-27 23:20:27 +01001928 /* in HW restart it exists already */
1929 WARN_ON(local->resuming);
Johannes Berg4b6f1dd2012-04-03 14:35:57 +02001930 res = drv_add_interface(local, sdata);
1931 if (WARN_ON(res)) {
Monam Agarwal0c2bef462014-03-24 00:51:43 +05301932 RCU_INIT_POINTER(local->monitor_sdata, NULL);
Johannes Berg4b6f1dd2012-04-03 14:35:57 +02001933 synchronize_net();
1934 kfree(sdata);
1935 }
1936 }
1937
Johannes Bergf2753dd2009-04-14 10:09:24 +02001938 list_for_each_entry(sdata, &local->interfaces, list) {
1939 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1940 sdata->vif.type != NL80211_IFTYPE_MONITOR &&
Luciano Coelhoc8fff3d2015-03-01 09:10:04 +02001941 ieee80211_sdata_running(sdata)) {
Johannes Berg7b7eab62011-11-03 14:41:13 +01001942 res = drv_add_interface(local, sdata);
Luciano Coelhoc8fff3d2015-03-01 09:10:04 +02001943 if (WARN_ON(res))
1944 break;
1945 }
1946 }
1947
1948 /* If adding any of the interfaces failed above, roll back and
1949 * report failure.
1950 */
1951 if (res) {
1952 list_for_each_entry_continue_reverse(sdata, &local->interfaces,
1953 list)
1954 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1955 sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1956 ieee80211_sdata_running(sdata))
1957 drv_remove_interface(local, sdata);
1958 ieee80211_handle_reconfig_failure(local);
1959 return res;
Johannes Bergf2753dd2009-04-14 10:09:24 +02001960 }
1961
Johannes Berg55de9082012-07-26 17:24:39 +02001962 /* add channel contexts */
Arend van Sprielf0dea9c2012-11-19 12:01:05 +01001963 if (local->use_chanctx) {
1964 mutex_lock(&local->chanctx_mtx);
1965 list_for_each_entry(ctx, &local->chanctx_list, list)
Michal Kazior5bcae312014-06-25 12:35:06 +02001966 if (ctx->replace_state !=
1967 IEEE80211_CHANCTX_REPLACES_OTHER)
1968 WARN_ON(drv_add_chanctx(local, ctx));
Arend van Sprielf0dea9c2012-11-19 12:01:05 +01001969 mutex_unlock(&local->chanctx_mtx);
Johannes Berg55de9082012-07-26 17:24:39 +02001970
Zhao, Gang7df180f2014-04-26 09:43:40 +08001971 sdata = rtnl_dereference(local->monitor_sdata);
1972 if (sdata && ieee80211_sdata_running(sdata))
1973 ieee80211_assign_chanctx(local, sdata);
1974 }
Johannes Bergfe5f2552012-11-19 22:19:08 +01001975
Johannes Bergf2753dd2009-04-14 10:09:24 +02001976 /* reconfigure hardware */
1977 ieee80211_hw_config(local, ~0);
1978
Johannes Bergf2753dd2009-04-14 10:09:24 +02001979 ieee80211_configure_filter(local);
Johannes Bergf2753dd2009-04-14 10:09:24 +02001980
1981 /* Finally also reconfigure all the BSS information */
1982 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Bergac8dd502010-05-05 09:44:02 +02001983 u32 changed;
1984
Johannes Berg9607e6b662009-12-23 13:15:31 +01001985 if (!ieee80211_sdata_running(sdata))
Johannes Bergf2753dd2009-04-14 10:09:24 +02001986 continue;
Johannes Bergac8dd502010-05-05 09:44:02 +02001987
Johannes Berg1ea2c862015-12-08 16:04:39 +02001988 ieee80211_assign_chanctx(local, sdata);
1989
1990 switch (sdata->vif.type) {
1991 case NL80211_IFTYPE_AP_VLAN:
1992 case NL80211_IFTYPE_MONITOR:
1993 break;
1994 default:
1995 ieee80211_reconfig_stations(sdata);
1996 /* fall through */
1997 case NL80211_IFTYPE_AP: /* AP stations are handled later */
1998 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1999 drv_conf_tx(local, sdata, i,
2000 &sdata->tx_conf[i]);
2001 break;
2002 }
2003
Johannes Bergac8dd502010-05-05 09:44:02 +02002004 /* common change flags for all interface types */
2005 changed = BSS_CHANGED_ERP_CTS_PROT |
2006 BSS_CHANGED_ERP_PREAMBLE |
2007 BSS_CHANGED_ERP_SLOT |
2008 BSS_CHANGED_HT |
2009 BSS_CHANGED_BASIC_RATES |
2010 BSS_CHANGED_BEACON_INT |
2011 BSS_CHANGED_BSSID |
Johannes Berg4ced3f72010-07-19 16:39:04 +02002012 BSS_CHANGED_CQM |
Eliad Peller55de47f2011-11-01 15:16:55 +02002013 BSS_CHANGED_QOS |
Johannes Berg1ea6f9c2012-10-24 10:59:25 +02002014 BSS_CHANGED_IDLE |
Pradeep Kumar Chitrapudcbe73c2018-03-22 12:18:03 -07002015 BSS_CHANGED_TXPOWER |
2016 BSS_CHANGED_MCAST_RATE;
Johannes Bergac8dd502010-05-05 09:44:02 +02002017
Sara Sharonb5a33d52016-02-16 12:48:18 +02002018 if (sdata->vif.mu_mimo_owner)
Sara Sharon23a1f8d2015-12-08 16:04:31 +02002019 changed |= BSS_CHANGED_MU_GROUPS;
2020
Johannes Bergf2753dd2009-04-14 10:09:24 +02002021 switch (sdata->vif.type) {
2022 case NL80211_IFTYPE_STATION:
Eliad Peller0d392e92011-12-12 14:10:49 +02002023 changed |= BSS_CHANGED_ASSOC |
Eliad Pellerab095872012-07-27 12:33:22 +03002024 BSS_CHANGED_ARP_FILTER |
2025 BSS_CHANGED_PS;
Emmanuel Grumbachc65dd142012-12-12 10:12:24 +02002026
Alexander Bondar989c6502013-05-16 17:34:17 +03002027 /* Re-send beacon info report to the driver */
2028 if (sdata->u.mgd.have_beacon)
2029 changed |= BSS_CHANGED_BEACON_INFO;
Emmanuel Grumbachc65dd142012-12-12 10:12:24 +02002030
Avraham Sterne38a0172017-04-26 10:58:47 +03002031 if (sdata->vif.bss_conf.max_idle_period ||
2032 sdata->vif.bss_conf.protected_keep_alive)
2033 changed |= BSS_CHANGED_KEEP_ALIVE;
2034
Johannes Berg8d61ffa2013-05-10 12:32:47 +02002035 sdata_lock(sdata);
Johannes Bergac8dd502010-05-05 09:44:02 +02002036 ieee80211_bss_info_change_notify(sdata, changed);
Johannes Berg8d61ffa2013-05-10 12:32:47 +02002037 sdata_unlock(sdata);
Johannes Bergac8dd502010-05-05 09:44:02 +02002038 break;
Rostislav Lisovy6e0bd6c2014-11-03 10:33:18 +01002039 case NL80211_IFTYPE_OCB:
Rostislav Lisovy239281f2014-11-03 10:33:19 +01002040 changed |= BSS_CHANGED_OCB;
2041 ieee80211_bss_info_change_notify(sdata, changed);
Rostislav Lisovy6e0bd6c2014-11-03 10:33:18 +01002042 break;
Johannes Bergf2753dd2009-04-14 10:09:24 +02002043 case NL80211_IFTYPE_ADHOC:
Johannes Bergac8dd502010-05-05 09:44:02 +02002044 changed |= BSS_CHANGED_IBSS;
2045 /* fall through */
Johannes Bergf2753dd2009-04-14 10:09:24 +02002046 case NL80211_IFTYPE_AP:
Johannes Berg339afbf2012-11-14 15:21:17 +01002047 changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
Arik Nemtsove7979ac2011-11-22 19:33:18 +02002048
Johannes Berg10416382012-10-19 15:44:42 +02002049 if (sdata->vif.type == NL80211_IFTYPE_AP) {
Arik Nemtsove7979ac2011-11-22 19:33:18 +02002050 changed |= BSS_CHANGED_AP_PROBE_RESP;
2051
Johannes Berg10416382012-10-19 15:44:42 +02002052 if (rcu_access_pointer(sdata->u.ap.beacon))
2053 drv_start_ap(local, sdata);
2054 }
2055
Arik Nemtsov78274932011-09-04 11:11:32 +03002056 /* fall through */
Johannes Bergf2753dd2009-04-14 10:09:24 +02002057 case NL80211_IFTYPE_MESH_POINT:
Johannes Berg8da34932012-12-14 14:17:26 +01002058 if (sdata->vif.bss_conf.enable_beacon) {
2059 changed |= BSS_CHANGED_BEACON |
2060 BSS_CHANGED_BEACON_ENABLED;
2061 ieee80211_bss_info_change_notify(sdata, changed);
2062 }
Johannes Bergf2753dd2009-04-14 10:09:24 +02002063 break;
Ayala Beker167e33f2016-09-20 17:31:20 +03002064 case NL80211_IFTYPE_NAN:
2065 res = ieee80211_reconfig_nan(sdata);
2066 if (res < 0) {
2067 ieee80211_handle_reconfig_failure(local);
2068 return res;
2069 }
2070 break;
Johannes Bergf2753dd2009-04-14 10:09:24 +02002071 case NL80211_IFTYPE_WDS:
Johannes Bergf2753dd2009-04-14 10:09:24 +02002072 case NL80211_IFTYPE_AP_VLAN:
2073 case NL80211_IFTYPE_MONITOR:
Johannes Berg98104fde2012-06-16 00:19:54 +02002074 case NL80211_IFTYPE_P2P_DEVICE:
Zhao, Gangb2057862014-04-26 09:43:41 +08002075 /* nothing to do */
Johannes Bergf142c6b2012-06-18 20:07:15 +02002076 break;
Johannes Bergf2753dd2009-04-14 10:09:24 +02002077 case NL80211_IFTYPE_UNSPECIFIED:
Johannes Berg2e161f782010-08-12 15:38:38 +02002078 case NUM_NL80211_IFTYPES:
Johannes Berg2ca27bc2010-09-16 14:58:23 +02002079 case NL80211_IFTYPE_P2P_CLIENT:
2080 case NL80211_IFTYPE_P2P_GO:
Johannes Bergf2753dd2009-04-14 10:09:24 +02002081 WARN_ON(1);
2082 break;
2083 }
2084 }
2085
Johannes Berg4a733ef2015-10-14 18:02:43 +02002086 ieee80211_recalc_ps(local);
Eyal Shapira8e1b23b2011-11-09 12:29:06 +02002087
Johannes Berg2a419052010-06-10 10:21:29 +02002088 /*
Eliad Peller6e1b1b22012-01-26 13:36:05 +02002089 * The sta might be in psm against the ap (e.g. because
2090 * this was the state before a hw restart), so we
2091 * explicitly send a null packet in order to make sure
2092 * it'll sync against the ap (and get out of psm).
2093 */
2094 if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
2095 list_for_each_entry(sdata, &local->interfaces, list) {
2096 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2097 continue;
Johannes Berg20f544e2012-11-08 14:06:28 +01002098 if (!sdata->u.mgd.associated)
2099 continue;
Eliad Peller6e1b1b22012-01-26 13:36:05 +02002100
Johannes Berg076cdcb2015-09-24 16:14:55 +02002101 ieee80211_send_nullfunc(local, sdata, false);
Eliad Peller6e1b1b22012-01-26 13:36:05 +02002102 }
2103 }
2104
Arik Nemtsov2e8d3972012-06-03 23:31:56 +03002105 /* APs are now beaconing, add back stations */
2106 mutex_lock(&local->sta_mtx);
2107 list_for_each_entry(sta, &local->sta_list, list) {
2108 enum ieee80211_sta_state state;
2109
2110 if (!sta->uploaded)
2111 continue;
2112
mpubbise@codeaurora.org19103a42018-07-02 15:40:14 +05302113 if (sta->sdata->vif.type != NL80211_IFTYPE_AP &&
2114 sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
Arik Nemtsov2e8d3972012-06-03 23:31:56 +03002115 continue;
2116
2117 for (state = IEEE80211_STA_NOTEXIST;
2118 state < sta->sta_state; state++)
2119 WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
2120 state + 1));
2121 }
2122 mutex_unlock(&local->sta_mtx);
2123
Eyal Shapira7b21aea2012-05-29 02:00:22 -07002124 /* add back keys */
2125 list_for_each_entry(sdata, &local->interfaces, list)
Michal Kaziorf9dca802015-05-13 09:16:48 +00002126 ieee80211_reset_crypto_tx_tailroom(sdata);
2127
2128 list_for_each_entry(sdata, &local->interfaces, list)
Eyal Shapira7b21aea2012-05-29 02:00:22 -07002129 if (ieee80211_sdata_running(sdata))
2130 ieee80211_enable_keys(sdata);
2131
Eliad Peller0d440ea2015-10-25 10:59:33 +02002132 /* Reconfigure sched scan if it was interrupted by FW restart */
2133 mutex_lock(&local->mtx);
2134 sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
2135 lockdep_is_held(&local->mtx));
2136 sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
2137 lockdep_is_held(&local->mtx));
2138 if (sched_scan_sdata && sched_scan_req)
2139 /*
2140 * Sched scan stopped, but we don't want to report it. Instead,
2141 * we're trying to reschedule. However, if more than one scan
2142 * plan was set, we cannot reschedule since we don't know which
2143 * scan plan was currently running (and some scan plans may have
2144 * already finished).
2145 */
2146 if (sched_scan_req->n_scan_plans > 1 ||
2147 __ieee80211_request_sched_scan_start(sched_scan_sdata,
Eliad Pellerb9f628f2015-12-16 15:45:45 +02002148 sched_scan_req)) {
2149 RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
2150 RCU_INIT_POINTER(local->sched_scan_req, NULL);
Eliad Peller0d440ea2015-10-25 10:59:33 +02002151 sched_scan_stopped = true;
Eliad Pellerb9f628f2015-12-16 15:45:45 +02002152 }
Eliad Peller0d440ea2015-10-25 10:59:33 +02002153 mutex_unlock(&local->mtx);
2154
2155 if (sched_scan_stopped)
Arend Van Sprielb34939b2017-04-28 13:40:28 +01002156 cfg80211_sched_scan_stopped_rtnl(local->hw.wiphy, 0);
Eliad Peller0d440ea2015-10-25 10:59:33 +02002157
Eliad Pellerc6209482012-07-02 15:08:25 +03002158 wake_up:
Arik Nemtsov04800ad2012-06-06 11:25:02 +03002159
Johannes Berg3c3e21e2013-03-27 23:20:27 +01002160 if (local->monitors == local->open_count && local->monitors > 0)
2161 ieee80211_add_virtual_monitor(local);
2162
Eliad Peller6e1b1b22012-01-26 13:36:05 +02002163 /*
Johannes Berg2a419052010-06-10 10:21:29 +02002164 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
2165 * sessions can be established after a resume.
2166 *
2167 * Also tear down aggregation sessions since reconfiguring
2168 * them in a hardware restart scenario is not easily done
2169 * right now, and the hardware will have lost information
2170 * about the sessions, but we and the AP still think they
2171 * are active. This is really a workaround though.
2172 */
Johannes Berg30686bf2015-06-02 21:39:54 +02002173 if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
Johannes Berg2a419052010-06-10 10:21:29 +02002174 mutex_lock(&local->sta_mtx);
2175
2176 list_for_each_entry(sta, &local->sta_list, list) {
Eliad Peller27392712015-09-21 15:50:26 +03002177 if (!local->resuming)
2178 ieee80211_sta_tear_down_BA_sessions(
2179 sta, AGG_STOP_LOCAL_REQUEST);
Johannes Bergc2c98fd2011-09-29 16:04:36 +02002180 clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
Wey-Yi Guy74e2bd12010-02-03 09:28:55 -08002181 }
Johannes Berg2a419052010-06-10 10:21:29 +02002182
2183 mutex_unlock(&local->sta_mtx);
Wey-Yi Guy74e2bd12010-02-03 09:28:55 -08002184 }
Wey-Yi Guy74e2bd12010-02-03 09:28:55 -08002185
Sara Sharon23163802017-10-29 11:51:08 +02002186 if (local->in_reconfig) {
2187 local->in_reconfig = false;
2188 barrier();
2189
2190 /* Restart deferred ROCs */
2191 mutex_lock(&local->mtx);
2192 ieee80211_start_next_roc(local);
2193 mutex_unlock(&local->mtx);
2194 }
2195
Johannes Berg445ea4e2013-02-13 12:25:28 +01002196 ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
Luciano Coelhocca07b02014-06-13 16:30:05 +03002197 IEEE80211_QUEUE_STOP_REASON_SUSPEND,
2198 false);
Johannes Bergf2753dd2009-04-14 10:09:24 +02002199
Johannes Berg5bb644a2009-05-17 11:40:42 +02002200 /*
2201 * If this is for hw restart things are still running.
2202 * We may want to change that later, however.
2203 */
Eliad Pellerb0485e92015-07-08 15:41:47 +03002204 if (local->open_count && (!suspended || reconfig_due_to_wowlan))
Eliad Pellercf2c92d2014-11-04 11:43:54 +02002205 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
Johannes Berg8f21b0a2013-01-11 00:28:01 +01002206
Eliad Pellerb0485e92015-07-08 15:41:47 +03002207 if (!suspended)
Johannes Berg5bb644a2009-05-17 11:40:42 +02002208 return 0;
2209
2210#ifdef CONFIG_PM
Johannes Bergceb99fe2009-11-19 14:29:39 +01002211 /* first set suspended false, then resuming */
Johannes Berg5bb644a2009-05-17 11:40:42 +02002212 local->suspended = false;
Johannes Bergceb99fe2009-11-19 14:29:39 +01002213 mb();
2214 local->resuming = false;
Johannes Berg5bb644a2009-05-17 11:40:42 +02002215
Johannes Berg74430f92015-12-08 16:04:38 +02002216 ieee80211_flush_completed_scan(local, false);
Luciano Coelho9120d94e2015-01-24 10:30:02 +02002217
Eliad Peller0f8b8242014-12-14 11:05:53 +02002218 if (local->open_count && !reconfig_due_to_wowlan)
Eliad Pellercf2c92d2014-11-04 11:43:54 +02002219 drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
2220
Johannes Bergb8360ab2013-04-29 14:57:44 +02002221 list_for_each_entry(sdata, &local->interfaces, list) {
2222 if (!ieee80211_sdata_running(sdata))
2223 continue;
2224 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2225 ieee80211_sta_restart(sdata);
2226 }
2227
Johannes Berg26d59532011-04-01 13:52:48 +02002228 mod_timer(&local->sta_cleanup, jiffies + 1);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002229#else
2230 WARN_ON(1);
2231#endif
David Spinadeld43c6b62013-12-08 21:48:57 +02002232
Johannes Bergf2753dd2009-04-14 10:09:24 +02002233 return 0;
2234}
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -04002235
Johannes Berg95acac62011-07-12 12:30:59 +02002236void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
2237{
2238 struct ieee80211_sub_if_data *sdata;
2239 struct ieee80211_local *local;
2240 struct ieee80211_key *key;
2241
2242 if (WARN_ON(!vif))
2243 return;
2244
2245 sdata = vif_to_sdata(vif);
2246 local = sdata->local;
2247
2248 if (WARN_ON(!local->resuming))
2249 return;
2250
2251 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2252 return;
2253
2254 sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
2255
2256 mutex_lock(&local->key_mtx);
2257 list_for_each_entry(key, &sdata->key_list, list)
2258 key->flags |= KEY_FLAG_TAINTED;
2259 mutex_unlock(&local->key_mtx);
2260}
2261EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
2262
Johannes Berg04ecd252012-09-11 14:34:12 +02002263void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
Johannes Berg0f782312009-12-01 13:37:02 +01002264{
Johannes Berg04ecd252012-09-11 14:34:12 +02002265 struct ieee80211_local *local = sdata->local;
2266 struct ieee80211_chanctx_conf *chanctx_conf;
2267 struct ieee80211_chanctx *chanctx;
Johannes Berg0f782312009-12-01 13:37:02 +01002268
Johannes Berg04ecd252012-09-11 14:34:12 +02002269 mutex_lock(&local->chanctx_mtx);
Johannes Berg0f782312009-12-01 13:37:02 +01002270
Johannes Berg04ecd252012-09-11 14:34:12 +02002271 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2272 lockdep_is_held(&local->chanctx_mtx));
Johannes Berg0f782312009-12-01 13:37:02 +01002273
Andrei Otcheretianskic189a682015-10-25 10:59:40 +02002274 /*
2275 * This function can be called from a work, thus it may be possible
2276 * that the chanctx_conf is removed (due to a disconnection, for
2277 * example).
2278 * So nothing should be done in such case.
2279 */
2280 if (!chanctx_conf)
Johannes Berg5d8e4232012-09-11 10:17:11 +02002281 goto unlock;
Johannes Berg0f782312009-12-01 13:37:02 +01002282
Johannes Berg04ecd252012-09-11 14:34:12 +02002283 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2284 ieee80211_recalc_smps_chanctx(local, chanctx);
Johannes Berg5d8e4232012-09-11 10:17:11 +02002285 unlock:
Johannes Berg04ecd252012-09-11 14:34:12 +02002286 mutex_unlock(&local->chanctx_mtx);
Johannes Berg0f782312009-12-01 13:37:02 +01002287}
Johannes Berg8e664fb2009-12-23 13:15:38 +01002288
Eliad Peller21f659b2013-11-11 20:14:01 +02002289void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
2290{
2291 struct ieee80211_local *local = sdata->local;
2292 struct ieee80211_chanctx_conf *chanctx_conf;
2293 struct ieee80211_chanctx *chanctx;
2294
2295 mutex_lock(&local->chanctx_mtx);
2296
2297 chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
2298 lockdep_is_held(&local->chanctx_mtx));
2299
2300 if (WARN_ON_ONCE(!chanctx_conf))
2301 goto unlock;
2302
2303 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2304 ieee80211_recalc_chanctx_min_def(local, chanctx);
2305 unlock:
2306 mutex_unlock(&local->chanctx_mtx);
2307}
2308
Johannes Berg8e664fb2009-12-23 13:15:38 +01002309size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
2310{
2311 size_t pos = offset;
2312
2313 while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
2314 pos += 2 + ies[pos + 1];
2315
2316 return pos;
2317}
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -07002318
2319static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
2320 int rssi_min_thold,
2321 int rssi_max_thold)
2322{
2323 trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
2324
2325 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2326 return;
2327
2328 /*
2329 * Scale up threshold values before storing it, as the RSSI averaging
2330 * algorithm uses a scaled up value as well. Change this scaling
2331 * factor if the RSSI averaging algorithm changes.
2332 */
2333 sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
2334 sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
2335}
2336
2337void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
2338 int rssi_min_thold,
2339 int rssi_max_thold)
2340{
2341 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2342
2343 WARN_ON(rssi_min_thold == rssi_max_thold ||
2344 rssi_min_thold > rssi_max_thold);
2345
2346 _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
2347 rssi_max_thold);
2348}
2349EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
2350
2351void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
2352{
2353 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2354
2355 _ieee80211_enable_rssi_reports(sdata, 0, 0);
2356}
2357EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
Arik Nemtsov768db3432011-09-28 14:12:51 +03002358
Ben Greearef96a8422011-11-18 11:32:00 -08002359u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
Alexander Simon42e7aa72011-10-26 14:47:26 -07002360 u16 cap)
2361{
2362 __le16 tmp;
2363
2364 *pos++ = WLAN_EID_HT_CAPABILITY;
2365 *pos++ = sizeof(struct ieee80211_ht_cap);
2366 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
2367
2368 /* capability flags */
2369 tmp = cpu_to_le16(cap);
2370 memcpy(pos, &tmp, sizeof(u16));
2371 pos += sizeof(u16);
2372
2373 /* AMPDU parameters */
Ben Greearef96a8422011-11-18 11:32:00 -08002374 *pos++ = ht_cap->ampdu_factor |
2375 (ht_cap->ampdu_density <<
Alexander Simon42e7aa72011-10-26 14:47:26 -07002376 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
2377
2378 /* MCS set */
Ben Greearef96a8422011-11-18 11:32:00 -08002379 memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
2380 pos += sizeof(ht_cap->mcs);
Alexander Simon42e7aa72011-10-26 14:47:26 -07002381
2382 /* extended capabilities */
2383 pos += sizeof(__le16);
2384
2385 /* BF capabilities */
2386 pos += sizeof(__le32);
2387
2388 /* antenna selection */
2389 pos += sizeof(u8);
2390
2391 return pos;
2392}
2393
Mahesh Palivelaba0afa22012-07-02 11:25:12 +00002394u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
Johannes Bergcc3983d2012-12-07 12:45:06 +01002395 u32 cap)
Mahesh Palivelaba0afa22012-07-02 11:25:12 +00002396{
2397 __le32 tmp;
2398
2399 *pos++ = WLAN_EID_VHT_CAPABILITY;
Mahesh Palivelad4950282012-10-10 11:25:40 +00002400 *pos++ = sizeof(struct ieee80211_vht_cap);
2401 memset(pos, 0, sizeof(struct ieee80211_vht_cap));
Mahesh Palivelaba0afa22012-07-02 11:25:12 +00002402
2403 /* capability flags */
2404 tmp = cpu_to_le32(cap);
2405 memcpy(pos, &tmp, sizeof(u32));
2406 pos += sizeof(u32);
2407
2408 /* VHT MCS set */
2409 memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
2410 pos += sizeof(vht_cap->vht_mcs);
2411
2412 return pos;
2413}
2414
Johannes Berg074d46d2012-03-15 19:45:16 +01002415u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
Johannes Berg4bf88532012-11-09 11:39:59 +01002416 const struct cfg80211_chan_def *chandef,
Arik Nemtsov57f255f2015-10-25 10:59:34 +02002417 u16 prot_mode, bool rifs_mode)
Alexander Simon42e7aa72011-10-26 14:47:26 -07002418{
Johannes Berg074d46d2012-03-15 19:45:16 +01002419 struct ieee80211_ht_operation *ht_oper;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002420 /* Build HT Information */
Johannes Berg074d46d2012-03-15 19:45:16 +01002421 *pos++ = WLAN_EID_HT_OPERATION;
2422 *pos++ = sizeof(struct ieee80211_ht_operation);
2423 ht_oper = (struct ieee80211_ht_operation *)pos;
Johannes Berg4bf88532012-11-09 11:39:59 +01002424 ht_oper->primary_chan = ieee80211_frequency_to_channel(
2425 chandef->chan->center_freq);
2426 switch (chandef->width) {
2427 case NL80211_CHAN_WIDTH_160:
2428 case NL80211_CHAN_WIDTH_80P80:
2429 case NL80211_CHAN_WIDTH_80:
2430 case NL80211_CHAN_WIDTH_40:
2431 if (chandef->center_freq1 > chandef->chan->center_freq)
2432 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2433 else
2434 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002435 break;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002436 default:
Johannes Berg074d46d2012-03-15 19:45:16 +01002437 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002438 break;
2439 }
Thomas Pedersenaee286c2012-04-18 19:24:14 -07002440 if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
Johannes Berg4bf88532012-11-09 11:39:59 +01002441 chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
2442 chandef->width != NL80211_CHAN_WIDTH_20)
Johannes Berg074d46d2012-03-15 19:45:16 +01002443 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
Simon Wunderlichff3cc5f2011-11-30 16:56:33 +01002444
Arik Nemtsov57f255f2015-10-25 10:59:34 +02002445 if (rifs_mode)
2446 ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
2447
Ashok Nagarajan431e3152012-04-30 14:20:29 -07002448 ht_oper->operation_mode = cpu_to_le16(prot_mode);
Johannes Berg074d46d2012-03-15 19:45:16 +01002449 ht_oper->stbc_param = 0x0000;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002450
2451 /* It seems that Basic MCS set and Supported MCS set
2452 are identical for the first 10 bytes */
Johannes Berg074d46d2012-03-15 19:45:16 +01002453 memset(&ht_oper->basic_set, 0, 16);
2454 memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
Alexander Simon42e7aa72011-10-26 14:47:26 -07002455
Johannes Berg074d46d2012-03-15 19:45:16 +01002456 return pos + sizeof(struct ieee80211_ht_operation);
Alexander Simon42e7aa72011-10-26 14:47:26 -07002457}
2458
Simon Wunderlich75d627d2017-05-23 17:00:42 +02002459void ieee80211_ie_build_wide_bw_cs(u8 *pos,
2460 const struct cfg80211_chan_def *chandef)
2461{
2462 *pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH; /* EID */
2463 *pos++ = 3; /* IE length */
2464 /* New channel width */
2465 switch (chandef->width) {
2466 case NL80211_CHAN_WIDTH_80:
2467 *pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
2468 break;
2469 case NL80211_CHAN_WIDTH_160:
2470 *pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
2471 break;
2472 case NL80211_CHAN_WIDTH_80P80:
2473 *pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
2474 break;
2475 default:
2476 *pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
2477 }
2478
2479 /* new center frequency segment 0 */
2480 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
2481 /* new center frequency segment 1 */
2482 if (chandef->center_freq2)
2483 *pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
2484 else
2485 *pos++ = 0;
2486}
2487
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002488u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2489 const struct cfg80211_chan_def *chandef)
2490{
2491 struct ieee80211_vht_operation *vht_oper;
2492
2493 *pos++ = WLAN_EID_VHT_OPERATION;
2494 *pos++ = sizeof(struct ieee80211_vht_operation);
2495 vht_oper = (struct ieee80211_vht_operation *)pos;
Johannes Berg2fb51c32017-02-15 15:02:06 +01002496 vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002497 chandef->center_freq1);
2498 if (chandef->center_freq2)
Johannes Berg2fb51c32017-02-15 15:02:06 +01002499 vht_oper->center_freq_seg1_idx =
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002500 ieee80211_frequency_to_channel(chandef->center_freq2);
Chun-Yeow Yeohf020ae42015-09-04 10:58:05 +08002501 else
Johannes Berg2fb51c32017-02-15 15:02:06 +01002502 vht_oper->center_freq_seg1_idx = 0x00;
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002503
2504 switch (chandef->width) {
2505 case NL80211_CHAN_WIDTH_160:
Jouni Malinen23665aa2016-02-01 11:40:55 +02002506 /*
2507 * Convert 160 MHz channel width to new style as interop
2508 * workaround.
2509 */
2510 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
Johannes Berg2fb51c32017-02-15 15:02:06 +01002511 vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
Jouni Malinen23665aa2016-02-01 11:40:55 +02002512 if (chandef->chan->center_freq < chandef->center_freq1)
Johannes Berg2fb51c32017-02-15 15:02:06 +01002513 vht_oper->center_freq_seg0_idx -= 8;
Jouni Malinen23665aa2016-02-01 11:40:55 +02002514 else
Johannes Berg2fb51c32017-02-15 15:02:06 +01002515 vht_oper->center_freq_seg0_idx += 8;
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002516 break;
2517 case NL80211_CHAN_WIDTH_80P80:
Jouni Malinen23665aa2016-02-01 11:40:55 +02002518 /*
2519 * Convert 80+80 MHz channel width to new style as interop
2520 * workaround.
2521 */
2522 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
Arik Nemtsovfb28ec02015-03-01 09:10:02 +02002523 break;
2524 case NL80211_CHAN_WIDTH_80:
2525 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2526 break;
2527 default:
2528 vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
2529 break;
2530 }
2531
2532 /* don't require special VHT peer rates */
2533 vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
2534
2535 return pos + sizeof(struct ieee80211_vht_operation);
2536}
2537
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002538bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
2539 struct cfg80211_chan_def *chandef)
Alexander Simon42e7aa72011-10-26 14:47:26 -07002540{
2541 enum nl80211_channel_type channel_type;
2542
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002543 if (!ht_oper)
2544 return false;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002545
Johannes Berg074d46d2012-03-15 19:45:16 +01002546 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
Alexander Simon42e7aa72011-10-26 14:47:26 -07002547 case IEEE80211_HT_PARAM_CHA_SEC_NONE:
2548 channel_type = NL80211_CHAN_HT20;
2549 break;
2550 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2551 channel_type = NL80211_CHAN_HT40PLUS;
2552 break;
2553 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2554 channel_type = NL80211_CHAN_HT40MINUS;
2555 break;
2556 default:
2557 channel_type = NL80211_CHAN_NO_HT;
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002558 return false;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002559 }
2560
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002561 cfg80211_chandef_create(chandef, chandef->chan, channel_type);
2562 return true;
Alexander Simon42e7aa72011-10-26 14:47:26 -07002563}
2564
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002565bool ieee80211_chandef_vht_oper(const struct ieee80211_vht_operation *oper,
2566 struct cfg80211_chan_def *chandef)
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002567{
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002568 struct cfg80211_chan_def new = *chandef;
2569 int cf1, cf2;
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002570
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002571 if (!oper)
2572 return false;
2573
Johannes Berg2fb51c32017-02-15 15:02:06 +01002574 cf1 = ieee80211_channel_to_frequency(oper->center_freq_seg0_idx,
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002575 chandef->chan->band);
Johannes Berg2fb51c32017-02-15 15:02:06 +01002576 cf2 = ieee80211_channel_to_frequency(oper->center_freq_seg1_idx,
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002577 chandef->chan->band);
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002578
2579 switch (oper->chan_width) {
2580 case IEEE80211_VHT_CHANWIDTH_USE_HT:
2581 break;
2582 case IEEE80211_VHT_CHANWIDTH_80MHZ:
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002583 new.width = NL80211_CHAN_WIDTH_80;
2584 new.center_freq1 = cf1;
Jouni Malinen23665aa2016-02-01 11:40:55 +02002585 /* If needed, adjust based on the newer interop workaround. */
Johannes Berg2fb51c32017-02-15 15:02:06 +01002586 if (oper->center_freq_seg1_idx) {
Jouni Malinen23665aa2016-02-01 11:40:55 +02002587 unsigned int diff;
2588
Johannes Berg2fb51c32017-02-15 15:02:06 +01002589 diff = abs(oper->center_freq_seg1_idx -
2590 oper->center_freq_seg0_idx);
Jouni Malinen23665aa2016-02-01 11:40:55 +02002591 if (diff == 8) {
2592 new.width = NL80211_CHAN_WIDTH_160;
2593 new.center_freq1 = cf2;
2594 } else if (diff > 8) {
2595 new.width = NL80211_CHAN_WIDTH_80P80;
2596 new.center_freq2 = cf2;
2597 }
2598 }
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002599 break;
2600 case IEEE80211_VHT_CHANWIDTH_160MHZ:
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002601 new.width = NL80211_CHAN_WIDTH_160;
2602 new.center_freq1 = cf1;
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002603 break;
2604 case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002605 new.width = NL80211_CHAN_WIDTH_80P80;
2606 new.center_freq1 = cf1;
2607 new.center_freq2 = cf2;
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002608 break;
2609 default:
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002610 return false;
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002611 }
2612
Johannes Berg8ac3c7042015-12-18 15:08:34 +01002613 if (!cfg80211_chandef_valid(&new))
2614 return false;
2615
2616 *chandef = new;
2617 return true;
Janusz.Dziedzic@tieto.comabcff6e2015-03-20 06:37:01 +01002618}
2619
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002620int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
2621 const struct ieee80211_supported_band *sband,
2622 const u8 *srates, int srates_len, u32 *rates)
2623{
2624 u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
2625 int shift = ieee80211_chandef_get_shift(chandef);
2626 struct ieee80211_rate *br;
2627 int brate, rate, i, j, count = 0;
2628
2629 *rates = 0;
2630
2631 for (i = 0; i < srates_len; i++) {
2632 rate = srates[i] & 0x7f;
2633
2634 for (j = 0; j < sband->n_bitrates; j++) {
2635 br = &sband->bitrates[j];
2636 if ((rate_flags & br->flags) != rate_flags)
2637 continue;
2638
2639 brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
2640 if (brate == rate) {
2641 *rates |= BIT(j);
2642 count++;
2643 break;
2644 }
2645 }
2646 }
2647 return count;
2648}
2649
Johannes Bergfc8a7322012-06-28 10:33:25 +02002650int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
Johannes Berg6b778632012-07-23 14:53:27 +02002651 struct sk_buff *skb, bool need_basic,
Johannes Berg57fbcce2016-04-12 15:56:15 +02002652 enum nl80211_band band)
Arik Nemtsov768db3432011-09-28 14:12:51 +03002653{
Arik Nemtsov768db3432011-09-28 14:12:51 +03002654 struct ieee80211_local *local = sdata->local;
2655 struct ieee80211_supported_band *sband;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002656 int rate, shift;
Arik Nemtsov768db3432011-09-28 14:12:51 +03002657 u8 i, rates, *pos;
Johannes Bergfc8a7322012-06-28 10:33:25 +02002658 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002659 u32 rate_flags;
Arik Nemtsov768db3432011-09-28 14:12:51 +03002660
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002661 shift = ieee80211_vif_get_shift(&sdata->vif);
2662 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
Johannes Berg6b778632012-07-23 14:53:27 +02002663 sband = local->hw.wiphy->bands[band];
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002664 rates = 0;
2665 for (i = 0; i < sband->n_bitrates; i++) {
2666 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2667 continue;
2668 rates++;
2669 }
Arik Nemtsov768db3432011-09-28 14:12:51 +03002670 if (rates > 8)
2671 rates = 8;
2672
2673 if (skb_tailroom(skb) < rates + 2)
2674 return -ENOMEM;
2675
2676 pos = skb_put(skb, rates + 2);
2677 *pos++ = WLAN_EID_SUPP_RATES;
2678 *pos++ = rates;
2679 for (i = 0; i < rates; i++) {
Ashok Nagarajan657c3e02012-04-02 21:21:20 -07002680 u8 basic = 0;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002681 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2682 continue;
2683
Ashok Nagarajan657c3e02012-04-02 21:21:20 -07002684 if (need_basic && basic_rates & BIT(i))
2685 basic = 0x80;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002686 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
2687 5 * (1 << shift));
2688 *pos++ = basic | (u8) rate;
Arik Nemtsov768db3432011-09-28 14:12:51 +03002689 }
2690
2691 return 0;
2692}
2693
Johannes Bergfc8a7322012-06-28 10:33:25 +02002694int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
Johannes Berg6b778632012-07-23 14:53:27 +02002695 struct sk_buff *skb, bool need_basic,
Johannes Berg57fbcce2016-04-12 15:56:15 +02002696 enum nl80211_band band)
Arik Nemtsov768db3432011-09-28 14:12:51 +03002697{
Arik Nemtsov768db3432011-09-28 14:12:51 +03002698 struct ieee80211_local *local = sdata->local;
2699 struct ieee80211_supported_band *sband;
Chun-Yeow Yeohcc63ec72013-09-07 23:40:44 -07002700 int rate, shift;
Arik Nemtsov768db3432011-09-28 14:12:51 +03002701 u8 i, exrates, *pos;
Johannes Bergfc8a7322012-06-28 10:33:25 +02002702 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002703 u32 rate_flags;
2704
2705 rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2706 shift = ieee80211_vif_get_shift(&sdata->vif);
Arik Nemtsov768db3432011-09-28 14:12:51 +03002707
Johannes Berg6b778632012-07-23 14:53:27 +02002708 sband = local->hw.wiphy->bands[band];
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002709 exrates = 0;
2710 for (i = 0; i < sband->n_bitrates; i++) {
2711 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
2712 continue;
2713 exrates++;
2714 }
2715
Arik Nemtsov768db3432011-09-28 14:12:51 +03002716 if (exrates > 8)
2717 exrates -= 8;
2718 else
2719 exrates = 0;
2720
2721 if (skb_tailroom(skb) < exrates + 2)
2722 return -ENOMEM;
2723
2724 if (exrates) {
2725 pos = skb_put(skb, exrates + 2);
2726 *pos++ = WLAN_EID_EXT_SUPP_RATES;
2727 *pos++ = exrates;
2728 for (i = 8; i < sband->n_bitrates; i++) {
Ashok Nagarajan657c3e02012-04-02 21:21:20 -07002729 u8 basic = 0;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002730 if ((rate_flags & sband->bitrates[i].flags)
2731 != rate_flags)
2732 continue;
Ashok Nagarajan657c3e02012-04-02 21:21:20 -07002733 if (need_basic && basic_rates & BIT(i))
2734 basic = 0x80;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002735 rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
2736 5 * (1 << shift));
2737 *pos++ = basic | (u8) rate;
Arik Nemtsov768db3432011-09-28 14:12:51 +03002738 }
2739 }
2740 return 0;
2741}
Wey-Yi Guy1dae27f2012-04-13 12:02:57 -07002742
2743int ieee80211_ave_rssi(struct ieee80211_vif *vif)
2744{
2745 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2746 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2747
Wey-Yi Guybe6bcab2012-04-23 09:30:32 -07002748 if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
2749 /* non-managed type inferfaces */
2750 return 0;
2751 }
Johannes Berg338c17a2015-08-28 10:52:54 +02002752 return -ewma_beacon_signal_read(&ifmgd->ave_beacon_signal);
Wey-Yi Guy1dae27f2012-04-13 12:02:57 -07002753}
Wey-Yi Guy0d8a0a12012-04-20 11:57:00 -07002754EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
Johannes Berg04ecd252012-09-11 14:34:12 +02002755
2756u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
2757{
2758 if (!mcs)
2759 return 1;
2760
2761 /* TODO: consider rx_highest */
2762
2763 if (mcs->rx_mask[3])
2764 return 4;
2765 if (mcs->rx_mask[2])
2766 return 3;
2767 if (mcs->rx_mask[1])
2768 return 2;
2769 return 1;
2770}
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002771
2772/**
2773 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
2774 * @local: mac80211 hw info struct
2775 * @status: RX status
2776 * @mpdu_len: total MPDU length (including FCS)
2777 * @mpdu_offset: offset into MPDU to calculate timestamp at
2778 *
2779 * This function calculates the RX timestamp at the given MPDU offset, taking
2780 * into account what the RX timestamp was. An offset of 0 will just normalize
2781 * the timestamp to TSF at beginning of MPDU reception.
2782 */
2783u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
2784 struct ieee80211_rx_status *status,
2785 unsigned int mpdu_len,
2786 unsigned int mpdu_offset)
2787{
2788 u64 ts = status->mactime;
2789 struct rate_info ri;
2790 u16 rate;
2791
2792 if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
2793 return 0;
2794
2795 memset(&ri, 0, sizeof(ri));
2796
Johannes Berg35f49622018-04-20 13:49:21 +03002797 ri.bw = status->bw;
2798
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002799 /* Fill cfg80211 rate info */
Johannes Bergda6a4352017-04-26 12:14:59 +02002800 switch (status->encoding) {
2801 case RX_ENC_HT:
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002802 ri.mcs = status->rate_idx;
2803 ri.flags |= RATE_INFO_FLAGS_MCS;
Johannes Berg7fdd69c2017-04-26 11:13:00 +02002804 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002805 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
Johannes Bergda6a4352017-04-26 12:14:59 +02002806 break;
2807 case RX_ENC_VHT:
Johannes Berg56146182012-11-09 15:07:02 +01002808 ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
2809 ri.mcs = status->rate_idx;
Johannes Berg8613c942017-04-26 13:51:41 +02002810 ri.nss = status->nss;
Johannes Berg7fdd69c2017-04-26 11:13:00 +02002811 if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
Johannes Berg56146182012-11-09 15:07:02 +01002812 ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
Johannes Bergda6a4352017-04-26 12:14:59 +02002813 break;
2814 default:
2815 WARN_ON(1);
2816 /* fall through */
2817 case RX_ENC_LEGACY: {
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002818 struct ieee80211_supported_band *sband;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002819 int shift = 0;
2820 int bitrate;
2821
Johannes Bergda6a4352017-04-26 12:14:59 +02002822 switch (status->bw) {
2823 case RATE_INFO_BW_10:
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002824 shift = 1;
Johannes Bergda6a4352017-04-26 12:14:59 +02002825 break;
2826 case RATE_INFO_BW_5:
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002827 shift = 2;
Johannes Bergda6a4352017-04-26 12:14:59 +02002828 break;
Johannes Bergb51f3be2015-01-15 16:14:02 +01002829 }
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002830
2831 sband = local->hw.wiphy->bands[status->band];
Simon Wunderlich2103dec2013-07-08 16:55:53 +02002832 bitrate = sband->bitrates[status->rate_idx].bitrate;
2833 ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
Johannes Bergf4a0f0c2016-01-25 15:46:34 +02002834
2835 if (status->flag & RX_FLAG_MACTIME_PLCP_START) {
2836 /* TODO: handle HT/VHT preambles */
Johannes Berg57fbcce2016-04-12 15:56:15 +02002837 if (status->band == NL80211_BAND_5GHZ) {
Johannes Bergf4a0f0c2016-01-25 15:46:34 +02002838 ts += 20 << shift;
2839 mpdu_offset += 2;
Johannes Berg7fdd69c2017-04-26 11:13:00 +02002840 } else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
Johannes Bergf4a0f0c2016-01-25 15:46:34 +02002841 ts += 96;
2842 } else {
2843 ts += 192;
2844 }
2845 }
Johannes Bergda6a4352017-04-26 12:14:59 +02002846 break;
2847 }
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002848 }
2849
2850 rate = cfg80211_calculate_bitrate(&ri);
Johannes Bergd86aa4f2013-10-11 15:47:06 +02002851 if (WARN_ONCE(!rate,
Sara Sharonf980ebc2016-02-24 11:49:45 +02002852 "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
2853 (unsigned long long)status->flag, status->rate_idx,
Johannes Berg8613c942017-04-26 13:51:41 +02002854 status->nss))
Johannes Bergd86aa4f2013-10-11 15:47:06 +02002855 return 0;
Thomas Pedersenf4bda332012-11-13 10:46:27 -08002856
2857 /* rewind from end of MPDU */
2858 if (status->flag & RX_FLAG_MACTIME_END)
2859 ts -= mpdu_len * 8 * 10 / rate;
2860
2861 ts += mpdu_offset * 8 * 10 / rate;
2862
2863 return ts;
2864}
Simon Wunderlich164eb022013-02-08 18:16:20 +01002865
2866void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
2867{
2868 struct ieee80211_sub_if_data *sdata;
Janusz Dziedzicd2859df2013-11-06 13:55:51 +01002869 struct cfg80211_chan_def chandef;
Simon Wunderlich164eb022013-02-08 18:16:20 +01002870
Johannes Berg4a199062017-04-26 10:58:53 +03002871 /* for interface list, to avoid linking iflist_mtx and chanctx_mtx */
2872 ASSERT_RTNL();
2873
Johannes Berg34a37402013-12-18 09:43:33 +01002874 mutex_lock(&local->mtx);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002875 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg34a37402013-12-18 09:43:33 +01002876 /* it might be waiting for the local->mtx, but then
2877 * by the time it gets it, sdata->wdev.cac_started
2878 * will no longer be true
2879 */
2880 cancel_delayed_work(&sdata->dfs_cac_timer_work);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002881
2882 if (sdata->wdev.cac_started) {
Janusz Dziedzicd2859df2013-11-06 13:55:51 +01002883 chandef = sdata->vif.bss_conf.chandef;
Simon Wunderlich164eb022013-02-08 18:16:20 +01002884 ieee80211_vif_release_channel(sdata);
2885 cfg80211_cac_event(sdata->dev,
Janusz Dziedzicd2859df2013-11-06 13:55:51 +01002886 &chandef,
Simon Wunderlich164eb022013-02-08 18:16:20 +01002887 NL80211_RADAR_CAC_ABORTED,
2888 GFP_KERNEL);
2889 }
2890 }
Johannes Berg34a37402013-12-18 09:43:33 +01002891 mutex_unlock(&local->mtx);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002892}
2893
2894void ieee80211_dfs_radar_detected_work(struct work_struct *work)
2895{
2896 struct ieee80211_local *local =
2897 container_of(work, struct ieee80211_local, radar_detected_work);
Janusz Dziedzic84a3d1c2013-11-05 14:48:46 +01002898 struct cfg80211_chan_def chandef = local->hw.conf.chandef;
Michal Kazior486cf4c2014-10-10 12:43:23 +02002899 struct ieee80211_chanctx *ctx;
2900 int num_chanctx = 0;
2901
2902 mutex_lock(&local->chanctx_mtx);
2903 list_for_each_entry(ctx, &local->chanctx_list, list) {
2904 if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
2905 continue;
2906
2907 num_chanctx++;
2908 chandef = ctx->conf.def;
2909 }
2910 mutex_unlock(&local->chanctx_mtx);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002911
Johannes Berg4a199062017-04-26 10:58:53 +03002912 rtnl_lock();
Simon Wunderlich164eb022013-02-08 18:16:20 +01002913 ieee80211_dfs_cac_cancel(local);
Johannes Berg4a199062017-04-26 10:58:53 +03002914 rtnl_unlock();
Simon Wunderlich164eb022013-02-08 18:16:20 +01002915
Michal Kazior486cf4c2014-10-10 12:43:23 +02002916 if (num_chanctx > 1)
2917 /* XXX: multi-channel is not supported yet */
Simon Wunderlich164eb022013-02-08 18:16:20 +01002918 WARN_ON(1);
Janusz Dziedzic84a3d1c2013-11-05 14:48:46 +01002919 else
Simon Wunderlich164eb022013-02-08 18:16:20 +01002920 cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002921}
2922
2923void ieee80211_radar_detected(struct ieee80211_hw *hw)
2924{
2925 struct ieee80211_local *local = hw_to_local(hw);
2926
2927 trace_api_radar_detected(local);
2928
Johannes Berg4a199062017-04-26 10:58:53 +03002929 schedule_work(&local->radar_detected_work);
Simon Wunderlich164eb022013-02-08 18:16:20 +01002930}
2931EXPORT_SYMBOL(ieee80211_radar_detected);
Simon Wunderliche6b7cde2013-08-28 13:41:29 +02002932
2933u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
2934{
2935 u32 ret;
2936 int tmp;
2937
2938 switch (c->width) {
2939 case NL80211_CHAN_WIDTH_20:
2940 c->width = NL80211_CHAN_WIDTH_20_NOHT;
2941 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2942 break;
2943 case NL80211_CHAN_WIDTH_40:
2944 c->width = NL80211_CHAN_WIDTH_20;
2945 c->center_freq1 = c->chan->center_freq;
2946 ret = IEEE80211_STA_DISABLE_40MHZ |
2947 IEEE80211_STA_DISABLE_VHT;
2948 break;
2949 case NL80211_CHAN_WIDTH_80:
2950 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
2951 /* n_P40 */
2952 tmp /= 2;
2953 /* freq_P40 */
2954 c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
2955 c->width = NL80211_CHAN_WIDTH_40;
2956 ret = IEEE80211_STA_DISABLE_VHT;
2957 break;
2958 case NL80211_CHAN_WIDTH_80P80:
2959 c->center_freq2 = 0;
2960 c->width = NL80211_CHAN_WIDTH_80;
2961 ret = IEEE80211_STA_DISABLE_80P80MHZ |
2962 IEEE80211_STA_DISABLE_160MHZ;
2963 break;
2964 case NL80211_CHAN_WIDTH_160:
2965 /* n_P20 */
2966 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
2967 /* n_P80 */
2968 tmp /= 4;
2969 c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
2970 c->width = NL80211_CHAN_WIDTH_80;
2971 ret = IEEE80211_STA_DISABLE_80P80MHZ |
2972 IEEE80211_STA_DISABLE_160MHZ;
2973 break;
2974 default:
2975 case NL80211_CHAN_WIDTH_20_NOHT:
2976 WARN_ON_ONCE(1);
2977 c->width = NL80211_CHAN_WIDTH_20_NOHT;
2978 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2979 break;
2980 case NL80211_CHAN_WIDTH_5:
2981 case NL80211_CHAN_WIDTH_10:
2982 WARN_ON_ONCE(1);
2983 /* keep c->width */
2984 ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
2985 break;
2986 }
2987
2988 WARN_ON_ONCE(!cfg80211_chandef_valid(c));
2989
2990 return ret;
2991}
Emmanuel Grumbach687da132013-10-01 16:45:43 +03002992
2993/*
2994 * Returns true if smps_mode_new is strictly more restrictive than
2995 * smps_mode_old.
2996 */
2997bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
2998 enum ieee80211_smps_mode smps_mode_new)
2999{
3000 if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
3001 smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
3002 return false;
3003
3004 switch (smps_mode_old) {
3005 case IEEE80211_SMPS_STATIC:
3006 return false;
3007 case IEEE80211_SMPS_DYNAMIC:
3008 return smps_mode_new == IEEE80211_SMPS_STATIC;
3009 case IEEE80211_SMPS_OFF:
3010 return smps_mode_new != IEEE80211_SMPS_OFF;
3011 default:
3012 WARN_ON(1);
3013 }
3014
3015 return false;
3016}
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003017
3018int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
3019 struct cfg80211_csa_settings *csa_settings)
3020{
3021 struct sk_buff *skb;
3022 struct ieee80211_mgmt *mgmt;
3023 struct ieee80211_local *local = sdata->local;
3024 int freq;
Johannes Berg4c121fd62017-09-08 11:54:46 +02003025 int hdr_len = offsetofend(struct ieee80211_mgmt,
3026 u.action.u.chan_switch);
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003027 u8 *pos;
3028
3029 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3030 sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3031 return -EOPNOTSUPP;
3032
3033 skb = dev_alloc_skb(local->tx_headroom + hdr_len +
3034 5 + /* channel switch announcement element */
3035 3 + /* secondary channel offset element */
Simon Wunderlich75d627d2017-05-23 17:00:42 +02003036 5 + /* wide bandwidth channel switch announcement */
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003037 8); /* mesh channel switch parameters element */
3038 if (!skb)
3039 return -ENOMEM;
3040
3041 skb_reserve(skb, local->tx_headroom);
Johannes Bergb080db52017-06-16 14:29:19 +02003042 mgmt = skb_put_zero(skb, hdr_len);
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003043 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3044 IEEE80211_STYPE_ACTION);
3045
3046 eth_broadcast_addr(mgmt->da);
3047 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
3048 if (ieee80211_vif_is_mesh(&sdata->vif)) {
3049 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
3050 } else {
3051 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
3052 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
3053 }
3054 mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
3055 mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
3056 pos = skb_put(skb, 5);
3057 *pos++ = WLAN_EID_CHANNEL_SWITCH; /* EID */
3058 *pos++ = 3; /* IE length */
3059 *pos++ = csa_settings->block_tx ? 1 : 0; /* CSA mode */
3060 freq = csa_settings->chandef.chan->center_freq;
3061 *pos++ = ieee80211_frequency_to_channel(freq); /* channel */
3062 *pos++ = csa_settings->count; /* count */
3063
3064 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
3065 enum nl80211_channel_type ch_type;
3066
3067 skb_put(skb, 3);
3068 *pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET; /* EID */
3069 *pos++ = 1; /* IE length */
3070 ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
3071 if (ch_type == NL80211_CHAN_HT40PLUS)
3072 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3073 else
3074 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3075 }
3076
3077 if (ieee80211_vif_is_mesh(&sdata->vif)) {
3078 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003079
3080 skb_put(skb, 8);
3081 *pos++ = WLAN_EID_CHAN_SWITCH_PARAM; /* EID */
3082 *pos++ = 6; /* IE length */
3083 *pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL; /* Mesh TTL */
3084 *pos = 0x00; /* Mesh Flag: Tx Restrict, Initiator, Reason */
3085 *pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
3086 *pos++ |= csa_settings->block_tx ?
3087 WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
3088 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
3089 pos += 2;
Chun-Yeow Yeohca91dc92013-11-12 10:31:48 +08003090 put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003091 pos += 2;
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003092 }
3093
Simon Wunderlich75d627d2017-05-23 17:00:42 +02003094 if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
3095 csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
3096 csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
3097 skb_put(skb, 5);
3098 ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
3099 }
3100
Chun-Yeow Yeohc6da6742013-10-14 19:08:28 -07003101 ieee80211_tx_skb(sdata, skb);
3102 return 0;
3103}
Max Stepanov2475b1cc2013-03-24 14:23:27 +02003104
3105bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
3106{
3107 return !(cs == NULL || cs->cipher == 0 ||
3108 cs->hdr_len < cs->pn_len + cs->pn_off ||
3109 cs->hdr_len <= cs->key_idx_off ||
3110 cs->key_idx_shift > 7 ||
3111 cs->key_idx_mask == 0);
3112}
3113
3114bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
3115{
3116 int i;
3117
3118 /* Ensure we have enough iftype bitmap space for all iftype values */
3119 WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
3120
3121 for (i = 0; i < n; i++)
3122 if (!ieee80211_cs_valid(&cs[i]))
3123 return false;
3124
3125 return true;
3126}
3127
3128const struct ieee80211_cipher_scheme *
3129ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
3130 enum nl80211_iftype iftype)
3131{
3132 const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
3133 int n = local->hw.n_cipher_schemes;
3134 int i;
3135 const struct ieee80211_cipher_scheme *cs = NULL;
3136
3137 for (i = 0; i < n; i++) {
3138 if (l[i].cipher == cipher) {
3139 cs = &l[i];
3140 break;
3141 }
3142 }
3143
3144 if (!cs || !(cs->iftype & BIT(iftype)))
3145 return NULL;
3146
3147 return cs;
3148}
3149
3150int ieee80211_cs_headroom(struct ieee80211_local *local,
3151 struct cfg80211_crypto_settings *crypto,
3152 enum nl80211_iftype iftype)
3153{
3154 const struct ieee80211_cipher_scheme *cs;
3155 int headroom = IEEE80211_ENCRYPT_HEADROOM;
3156 int i;
3157
3158 for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
3159 cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
3160 iftype);
3161
3162 if (cs && headroom < cs->hdr_len)
3163 headroom = cs->hdr_len;
3164 }
3165
3166 cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
3167 if (cs && headroom < cs->hdr_len)
3168 headroom = cs->hdr_len;
3169
3170 return headroom;
3171}
Felix Fietkaua7022e62013-12-16 21:49:14 +01003172
3173static bool
3174ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
3175{
3176 s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
3177 int skip;
3178
3179 if (end > 0)
3180 return false;
3181
Janusz.Dziedzic@tieto.com519ee692015-10-27 08:35:11 +01003182 /* One shot NOA */
3183 if (data->count[i] == 1)
3184 return false;
3185
3186 if (data->desc[i].interval == 0)
3187 return false;
3188
Felix Fietkaua7022e62013-12-16 21:49:14 +01003189 /* End time is in the past, check for repetitions */
3190 skip = DIV_ROUND_UP(-end, data->desc[i].interval);
3191 if (data->count[i] < 255) {
3192 if (data->count[i] <= skip) {
3193 data->count[i] = 0;
3194 return false;
3195 }
3196
3197 data->count[i] -= skip;
3198 }
3199
3200 data->desc[i].start += skip * data->desc[i].interval;
3201
3202 return true;
3203}
3204
3205static bool
3206ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
3207 s32 *offset)
3208{
3209 bool ret = false;
3210 int i;
3211
3212 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3213 s32 cur;
3214
3215 if (!data->count[i])
3216 continue;
3217
3218 if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
3219 ret = true;
3220
3221 cur = data->desc[i].start - tsf;
3222 if (cur > *offset)
3223 continue;
3224
3225 cur = data->desc[i].start + data->desc[i].duration - tsf;
3226 if (cur > *offset)
3227 *offset = cur;
3228 }
3229
3230 return ret;
3231}
3232
3233static u32
3234ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
3235{
3236 s32 offset = 0;
3237 int tries = 0;
3238 /*
3239 * arbitrary limit, used to avoid infinite loops when combined NoA
3240 * descriptors cover the full time period.
3241 */
3242 int max_tries = 5;
3243
3244 ieee80211_extend_absent_time(data, tsf, &offset);
3245 do {
3246 if (!ieee80211_extend_absent_time(data, tsf, &offset))
3247 break;
3248
3249 tries++;
3250 } while (tries < max_tries);
3251
3252 return offset;
3253}
3254
3255void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
3256{
3257 u32 next_offset = BIT(31) - 1;
3258 int i;
3259
3260 data->absent = 0;
3261 data->has_next_tsf = false;
3262 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3263 s32 start;
3264
3265 if (!data->count[i])
3266 continue;
3267
3268 ieee80211_extend_noa_desc(data, tsf, i);
3269 start = data->desc[i].start - tsf;
3270 if (start <= 0)
3271 data->absent |= BIT(i);
3272
3273 if (next_offset > start)
3274 next_offset = start;
3275
3276 data->has_next_tsf = true;
3277 }
3278
3279 if (data->absent)
3280 next_offset = ieee80211_get_noa_absent_time(data, tsf);
3281
3282 data->next_tsf = tsf + next_offset;
3283}
3284EXPORT_SYMBOL(ieee80211_update_p2p_noa);
3285
3286int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
3287 struct ieee80211_noa_data *data, u32 tsf)
3288{
3289 int ret = 0;
3290 int i;
3291
3292 memset(data, 0, sizeof(*data));
3293
3294 for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3295 const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
3296
3297 if (!desc->count || !desc->duration)
3298 continue;
3299
3300 data->count[i] = desc->count;
3301 data->desc[i].start = le32_to_cpu(desc->start_time);
3302 data->desc[i].duration = le32_to_cpu(desc->duration);
3303 data->desc[i].interval = le32_to_cpu(desc->interval);
3304
3305 if (data->count[i] > 1 &&
3306 data->desc[i].interval < data->desc[i].duration)
3307 continue;
3308
3309 ieee80211_extend_noa_desc(data, tsf, i);
3310 ret++;
3311 }
3312
3313 if (ret)
3314 ieee80211_update_p2p_noa(data, tsf);
3315
3316 return ret;
3317}
3318EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
Thomas Pedersen057d5f42013-12-19 10:25:15 -08003319
3320void ieee80211_recalc_dtim(struct ieee80211_local *local,
3321 struct ieee80211_sub_if_data *sdata)
3322{
3323 u64 tsf = drv_get_tsf(local, sdata);
3324 u64 dtim_count = 0;
3325 u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
3326 u8 dtim_period = sdata->vif.bss_conf.dtim_period;
3327 struct ps_data *ps;
3328 u8 bcns_from_dtim;
3329
3330 if (tsf == -1ULL || !beacon_int || !dtim_period)
3331 return;
3332
3333 if (sdata->vif.type == NL80211_IFTYPE_AP ||
3334 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
3335 if (!sdata->bss)
3336 return;
3337
3338 ps = &sdata->bss->ps;
3339 } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
3340 ps = &sdata->u.mesh.ps;
3341 } else {
3342 return;
3343 }
3344
3345 /*
3346 * actually finds last dtim_count, mac80211 will update in
3347 * __beacon_add_tim().
3348 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
3349 */
3350 do_div(tsf, beacon_int);
3351 bcns_from_dtim = do_div(tsf, dtim_period);
3352 /* just had a DTIM */
3353 if (!bcns_from_dtim)
3354 dtim_count = 0;
3355 else
3356 dtim_count = dtim_period - bcns_from_dtim;
3357
3358 ps->dtim_count = dtim_count;
3359}
Luciano Coelho73de86a2014-02-13 11:31:59 +02003360
Michal Kazior71e61952014-06-25 12:35:07 +02003361static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
3362 struct ieee80211_chanctx *ctx)
3363{
3364 struct ieee80211_sub_if_data *sdata;
3365 u8 radar_detect = 0;
3366
3367 lockdep_assert_held(&local->chanctx_mtx);
3368
3369 if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
3370 return 0;
3371
3372 list_for_each_entry(sdata, &ctx->reserved_vifs, reserved_chanctx_list)
3373 if (sdata->reserved_radar_required)
3374 radar_detect |= BIT(sdata->reserved_chandef.width);
3375
3376 /*
3377 * An in-place reservation context should not have any assigned vifs
3378 * until it replaces the other context.
3379 */
3380 WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
3381 !list_empty(&ctx->assigned_vifs));
3382
3383 list_for_each_entry(sdata, &ctx->assigned_vifs, assigned_chanctx_list)
3384 if (sdata->radar_required)
3385 radar_detect |= BIT(sdata->vif.bss_conf.chandef.width);
3386
3387 return radar_detect;
3388}
3389
Luciano Coelho73de86a2014-02-13 11:31:59 +02003390int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
3391 const struct cfg80211_chan_def *chandef,
3392 enum ieee80211_chanctx_mode chanmode,
3393 u8 radar_detect)
3394{
3395 struct ieee80211_local *local = sdata->local;
3396 struct ieee80211_sub_if_data *sdata_iter;
3397 enum nl80211_iftype iftype = sdata->wdev.iftype;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003398 struct ieee80211_chanctx *ctx;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003399 int total = 1;
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303400 struct iface_combination_params params = {
3401 .radar_detect = radar_detect,
3402 };
Luciano Coelho73de86a2014-02-13 11:31:59 +02003403
3404 lockdep_assert_held(&local->chanctx_mtx);
3405
3406 if (WARN_ON(hweight32(radar_detect) > 1))
3407 return -EINVAL;
3408
Luciano Coelhob6a55012014-02-27 11:07:21 +02003409 if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
3410 !chandef->chan))
Luciano Coelho73de86a2014-02-13 11:31:59 +02003411 return -EINVAL;
3412
3413 if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
3414 return -EINVAL;
3415
Johannes Bergac668af2016-10-21 14:25:14 +02003416 if (sdata->vif.type == NL80211_IFTYPE_AP ||
3417 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
3418 /*
3419 * always passing this is harmless, since it'll be the
3420 * same value that cfg80211 finds if it finds the same
3421 * interface ... and that's always allowed
3422 */
3423 params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
3424 }
3425
Luciano Coelho73de86a2014-02-13 11:31:59 +02003426 /* Always allow software iftypes */
3427 if (local->hw.wiphy->software_iftypes & BIT(iftype)) {
3428 if (radar_detect)
3429 return -EINVAL;
3430 return 0;
3431 }
3432
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303433 if (chandef)
3434 params.num_different_channels = 1;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003435
3436 if (iftype != NL80211_IFTYPE_UNSPECIFIED)
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303437 params.iftype_num[iftype] = 1;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003438
3439 list_for_each_entry(ctx, &local->chanctx_list, list) {
Michal Kazior5bcae312014-06-25 12:35:06 +02003440 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
3441 continue;
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303442 params.radar_detect |=
3443 ieee80211_chanctx_radar_detect(local, ctx);
Luciano Coelho73de86a2014-02-13 11:31:59 +02003444 if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303445 params.num_different_channels++;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003446 continue;
3447 }
Luciano Coelhob6a55012014-02-27 11:07:21 +02003448 if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
Luciano Coelho73de86a2014-02-13 11:31:59 +02003449 cfg80211_chandef_compatible(chandef,
3450 &ctx->conf.def))
3451 continue;
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303452 params.num_different_channels++;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003453 }
3454
3455 list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
3456 struct wireless_dev *wdev_iter;
3457
3458 wdev_iter = &sdata_iter->wdev;
3459
3460 if (sdata_iter == sdata ||
Andrei Otcheretianski0f611d22015-03-12 08:53:30 +02003461 !ieee80211_sdata_running(sdata_iter) ||
Luciano Coelho73de86a2014-02-13 11:31:59 +02003462 local->hw.wiphy->software_iftypes & BIT(wdev_iter->iftype))
3463 continue;
3464
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303465 params.iftype_num[wdev_iter->iftype]++;
Luciano Coelho73de86a2014-02-13 11:31:59 +02003466 total++;
3467 }
3468
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303469 if (total == 1 && !params.radar_detect)
Luciano Coelho73de86a2014-02-13 11:31:59 +02003470 return 0;
3471
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303472 return cfg80211_check_combinations(local->hw.wiphy, &params);
Luciano Coelho73de86a2014-02-13 11:31:59 +02003473}
Michal Kazior6fa001b2014-04-09 15:29:23 +02003474
3475static void
3476ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
3477 void *data)
3478{
3479 u32 *max_num_different_channels = data;
3480
3481 *max_num_different_channels = max(*max_num_different_channels,
3482 c->num_different_channels);
3483}
3484
3485int ieee80211_max_num_channels(struct ieee80211_local *local)
3486{
3487 struct ieee80211_sub_if_data *sdata;
Michal Kazior6fa001b2014-04-09 15:29:23 +02003488 struct ieee80211_chanctx *ctx;
Michal Kazior6fa001b2014-04-09 15:29:23 +02003489 u32 max_num_different_channels = 1;
3490 int err;
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303491 struct iface_combination_params params = {0};
Michal Kazior6fa001b2014-04-09 15:29:23 +02003492
3493 lockdep_assert_held(&local->chanctx_mtx);
3494
3495 list_for_each_entry(ctx, &local->chanctx_list, list) {
Michal Kazior5bcae312014-06-25 12:35:06 +02003496 if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
3497 continue;
3498
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303499 params.num_different_channels++;
Michal Kazior6fa001b2014-04-09 15:29:23 +02003500
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303501 params.radar_detect |=
3502 ieee80211_chanctx_radar_detect(local, ctx);
Michal Kazior6fa001b2014-04-09 15:29:23 +02003503 }
3504
3505 list_for_each_entry_rcu(sdata, &local->interfaces, list)
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303506 params.iftype_num[sdata->wdev.iftype]++;
Michal Kazior6fa001b2014-04-09 15:29:23 +02003507
Purushottam Kushwahae2273002016-10-12 18:25:35 +05303508 err = cfg80211_iter_combinations(local->hw.wiphy, &params,
3509 ieee80211_iter_max_chans,
Michal Kazior6fa001b2014-04-09 15:29:23 +02003510 &max_num_different_channels);
3511 if (err < 0)
3512 return err;
3513
3514 return max_num_different_channels;
3515}
Arik Nemtsov40b861a2014-07-17 17:14:23 +03003516
3517u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
3518{
3519 *buf++ = WLAN_EID_VENDOR_SPECIFIC;
3520 *buf++ = 7; /* len */
3521 *buf++ = 0x00; /* Microsoft OUI 00:50:F2 */
3522 *buf++ = 0x50;
3523 *buf++ = 0xf2;
3524 *buf++ = 2; /* WME */
3525 *buf++ = 0; /* WME info */
3526 *buf++ = 1; /* WME ver */
3527 *buf++ = qosinfo; /* U-APSD no in use */
3528
3529 return buf;
3530}
Felix Fietkauba8c3d62015-03-27 21:30:37 +01003531
Michal Kaziorf2ac7e302016-01-27 15:26:12 +01003532void ieee80211_txq_get_depth(struct ieee80211_txq *txq,
3533 unsigned long *frame_cnt,
3534 unsigned long *byte_cnt)
3535{
3536 struct txq_info *txqi = to_txq_info(txq);
Toke Høiland-Jørgensenbb42f2d2016-09-22 19:04:20 +02003537 u32 frag_cnt = 0, frag_bytes = 0;
3538 struct sk_buff *skb;
3539
3540 skb_queue_walk(&txqi->frags, skb) {
3541 frag_cnt++;
3542 frag_bytes += skb->len;
3543 }
Michal Kaziorf2ac7e302016-01-27 15:26:12 +01003544
3545 if (frame_cnt)
Toke Høiland-Jørgensenbb42f2d2016-09-22 19:04:20 +02003546 *frame_cnt = txqi->tin.backlog_packets + frag_cnt;
Michal Kaziorf2ac7e302016-01-27 15:26:12 +01003547
3548 if (byte_cnt)
Toke Høiland-Jørgensenbb42f2d2016-09-22 19:04:20 +02003549 *byte_cnt = txqi->tin.backlog_bytes + frag_bytes;
Michal Kaziorf2ac7e302016-01-27 15:26:12 +01003550}
3551EXPORT_SYMBOL(ieee80211_txq_get_depth);
Emmanuel Grumbachf438ceb2016-10-18 23:12:12 +03003552
3553const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = {
3554 IEEE80211_WMM_IE_STA_QOSINFO_AC_VO,
3555 IEEE80211_WMM_IE_STA_QOSINFO_AC_VI,
3556 IEEE80211_WMM_IE_STA_QOSINFO_AC_BE,
3557 IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
3558};