util.c 73.4 KB
Newer Older
J
Johannes Berg 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * utilities for mac80211
 */

#include <net/mac80211.h>
#include <linux/netdevice.h>
16
#include <linux/export.h>
J
Johannes Berg 已提交
17 18 19 20 21 22
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>
#include <linux/bitmap.h>
23
#include <linux/crc32.h>
24
#include <net/net_namespace.h>
J
Johannes Berg 已提交
25
#include <net/cfg80211.h>
26
#include <net/rtnetlink.h>
J
Johannes Berg 已提交
27 28

#include "ieee80211_i.h"
29
#include "driver-ops.h"
J
Johannes Berg 已提交
30
#include "rate.h"
31
#include "mesh.h"
J
Johannes Berg 已提交
32
#include "wme.h"
33
#include "led.h"
J
Johannes Berg 已提交
34
#include "wep.h"
J
Johannes Berg 已提交
35 36

/* privid for wiphys to determine whether they belong to us or not */
37
const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
J
Johannes Berg 已提交
38

39 40 41 42 43 44 45 46 47
struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
{
	struct ieee80211_local *local;
	BUG_ON(!wiphy);

	local = wiphy_priv(wiphy);
	return &local->hw;
}
EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
J
Johannes Berg 已提交
48

49
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
50
			enum nl80211_iftype type)
J
Johannes Berg 已提交
51
{
52
	__le16 fc = hdr->frame_control;
J
Johannes Berg 已提交
53

54 55
	 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
	if (len < 16)
J
Johannes Berg 已提交
56 57
		return NULL;

58
	if (ieee80211_is_data(fc)) {
59 60
		if (len < 24) /* drop incorrect hdr len (data) */
			return NULL;
61 62

		if (ieee80211_has_a4(fc))
J
Johannes Berg 已提交
63
			return NULL;
64 65 66
		if (ieee80211_has_tods(fc))
			return hdr->addr1;
		if (ieee80211_has_fromds(fc))
J
Johannes Berg 已提交
67
			return hdr->addr2;
68 69 70 71 72

		return hdr->addr3;
	}

	if (ieee80211_is_mgmt(fc)) {
73 74
		if (len < 24) /* drop incorrect hdr len (mgmt) */
			return NULL;
J
Johannes Berg 已提交
75
		return hdr->addr3;
76 77 78
	}

	if (ieee80211_is_ctl(fc)) {
W
Weilong Chen 已提交
79
		if (ieee80211_is_pspoll(fc))
J
Johannes Berg 已提交
80
			return hdr->addr1;
81 82

		if (ieee80211_is_back_req(fc)) {
83
			switch (type) {
84
			case NL80211_IFTYPE_STATION:
85
				return hdr->addr2;
86 87
			case NL80211_IFTYPE_AP:
			case NL80211_IFTYPE_AP_VLAN:
88 89
				return hdr->addr1;
			default:
90
				break; /* fall through to the return */
91 92
			}
		}
J
Johannes Berg 已提交
93 94 95 96 97
	}

	return NULL;
}

98
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
J
Johannes Berg 已提交
99
{
100
	struct sk_buff *skb;
J
Johannes Berg 已提交
101 102
	struct ieee80211_hdr *hdr;

103
	skb_queue_walk(&tx->skbs, skb) {
J
Johannes Berg 已提交
104 105
		hdr = (struct ieee80211_hdr *) skb->data;
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
106
	}
J
Johannes Berg 已提交
107 108
}

109
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
110 111
			     int rate, int erp, int short_preamble,
			     int shift)
J
Johannes Berg 已提交
112 113 114 115 116 117 118 119 120 121
{
	int dur;

	/* calculate duration (in microseconds, rounded up to next higher
	 * integer if it includes a fractional microsecond) to send frame of
	 * len bytes (does not include FCS) at the given rate. Duration will
	 * also include SIFS.
	 *
	 * rate is in 100 kbps, so divident is multiplied by 10 in the
	 * DIV_ROUND_UP() operations.
122 123 124
	 *
	 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
	 * is assumed to be 0 otherwise.
J
Johannes Berg 已提交
125 126
	 */

127
	if (band == IEEE80211_BAND_5GHZ || erp) {
J
Johannes Berg 已提交
128 129 130 131 132 133 134 135 136
		/*
		 * OFDM:
		 *
		 * N_DBPS = DATARATE x 4
		 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
		 *	(16 = SIGNAL time, 6 = tail bits)
		 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
		 *
		 * T_SYM = 4 usec
137
		 * 802.11a - 18.5.2: aSIFSTime = 16 usec
J
Johannes Berg 已提交
138 139 140 141
		 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
		 *	signal ext = 6 usec
		 */
		dur = 16; /* SIFS + signal ext */
142 143 144 145 146 147 148 149
		dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
		dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */

		/* IEEE 802.11-2012 18.3.2.4: all values above are:
		 *  * times 4 for 5 MHz
		 *  * times 2 for 10 MHz
		 */
		dur *= 1 << shift;
150 151 152 153 154 155

		/* rates should already consider the channel bandwidth,
		 * don't apply divisor again.
		 */
		dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
					4 * rate); /* T_SYM x N_SYM */
J
Johannes Berg 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	} else {
		/*
		 * 802.11b or 802.11g with 802.11b compatibility:
		 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
		 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
		 *
		 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
		 * aSIFSTime = 10 usec
		 * aPreambleLength = 144 usec or 72 usec with short preamble
		 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
		 */
		dur = 10; /* aSIFSTime = 10 usec */
		dur += short_preamble ? (72 + 24) : (144 + 48);

		dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
	}

	return dur;
}

/* Exported duration function for driver use */
177 178
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
179
					enum ieee80211_band band,
180 181
					size_t frame_len,
					struct ieee80211_rate *rate)
J
Johannes Berg 已提交
182
{
183
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
184
	u16 dur;
185
	int erp, shift = 0;
186
	bool short_preamble = false;
J
Johannes Berg 已提交
187

188
	erp = 0;
189 190
	if (vif) {
		sdata = vif_to_sdata(vif);
J
Johannes Berg 已提交
191
		short_preamble = sdata->vif.bss_conf.use_short_preamble;
192 193
		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
			erp = rate->flags & IEEE80211_RATE_ERP_G;
194
		shift = ieee80211_vif_get_shift(vif);
195
	}
196

197
	dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
198
				       short_preamble, shift);
J
Johannes Berg 已提交
199 200 201 202 203

	return cpu_to_le16(dur);
}
EXPORT_SYMBOL(ieee80211_generic_frame_duration);

204 205
__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
			      struct ieee80211_vif *vif, size_t frame_len,
206
			      const struct ieee80211_tx_info *frame_txctl)
J
Johannes Berg 已提交
207 208 209
{
	struct ieee80211_local *local = hw_to_local(hw);
	struct ieee80211_rate *rate;
210
	struct ieee80211_sub_if_data *sdata;
211
	bool short_preamble;
212
	int erp, shift = 0, bitrate;
J
Johannes Berg 已提交
213
	u16 dur;
214 215
	struct ieee80211_supported_band *sband;

216
	sband = local->hw.wiphy->bands[frame_txctl->band];
J
Johannes Berg 已提交
217

218
	short_preamble = false;
219

220
	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
221 222

	erp = 0;
223 224
	if (vif) {
		sdata = vif_to_sdata(vif);
J
Johannes Berg 已提交
225
		short_preamble = sdata->vif.bss_conf.use_short_preamble;
226 227
		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
			erp = rate->flags & IEEE80211_RATE_ERP_G;
228
		shift = ieee80211_vif_get_shift(vif);
229
	}
J
Johannes Berg 已提交
230

231 232
	bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);

J
Johannes Berg 已提交
233
	/* CTS duration */
234
	dur = ieee80211_frame_duration(sband->band, 10, bitrate,
235
				       erp, short_preamble, shift);
J
Johannes Berg 已提交
236
	/* Data frame duration */
237
	dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
238
					erp, short_preamble, shift);
J
Johannes Berg 已提交
239
	/* ACK duration */
240
	dur += ieee80211_frame_duration(sband->band, 10, bitrate,
241
					erp, short_preamble, shift);
J
Johannes Berg 已提交
242 243 244 245 246

	return cpu_to_le16(dur);
}
EXPORT_SYMBOL(ieee80211_rts_duration);

247 248
__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
				    struct ieee80211_vif *vif,
J
Johannes Berg 已提交
249
				    size_t frame_len,
250
				    const struct ieee80211_tx_info *frame_txctl)
J
Johannes Berg 已提交
251 252 253
{
	struct ieee80211_local *local = hw_to_local(hw);
	struct ieee80211_rate *rate;
254
	struct ieee80211_sub_if_data *sdata;
255
	bool short_preamble;
256
	int erp, shift = 0, bitrate;
J
Johannes Berg 已提交
257
	u16 dur;
258 259
	struct ieee80211_supported_band *sband;

260
	sband = local->hw.wiphy->bands[frame_txctl->band];
J
Johannes Berg 已提交
261

262
	short_preamble = false;
263

264
	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
265
	erp = 0;
266 267
	if (vif) {
		sdata = vif_to_sdata(vif);
J
Johannes Berg 已提交
268
		short_preamble = sdata->vif.bss_conf.use_short_preamble;
269 270
		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
			erp = rate->flags & IEEE80211_RATE_ERP_G;
271
		shift = ieee80211_vif_get_shift(vif);
272
	}
J
Johannes Berg 已提交
273

274 275
	bitrate = DIV_ROUND_UP(rate->bitrate, 1 << shift);

J
Johannes Berg 已提交
276
	/* Data frame duration */
277
	dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
278
				       erp, short_preamble, shift);
279
	if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
J
Johannes Berg 已提交
280
		/* ACK duration */
281
		dur += ieee80211_frame_duration(sband->band, 10, bitrate,
282
						erp, short_preamble, shift);
J
Johannes Berg 已提交
283 284 285 286 287 288
	}

	return cpu_to_le16(dur);
}
EXPORT_SYMBOL(ieee80211_ctstoself_duration);

289 290 291
void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
{
	struct ieee80211_sub_if_data *sdata;
292 293 294 295
	int n_acs = IEEE80211_NUM_ACS;

	if (local->hw.queues < IEEE80211_NUM_ACS)
		n_acs = 1;
296 297 298 299

	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
		int ac;

300 301 302
		if (!sdata->dev)
			continue;

303 304 305 306
		if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
		    local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
			continue;

307
		for (ac = 0; ac < n_acs; ac++) {
308 309 310 311 312 313 314 315 316 317 318
			int ac_queue = sdata->vif.hw_queue[ac];

			if (ac_queue == queue ||
			    (sdata->vif.cab_queue == queue &&
			     local->queue_stop_reasons[ac_queue] == 0 &&
			     skb_queue_empty(&local->pending[ac_queue])))
				netif_wake_subqueue(sdata->dev, ac);
		}
	}
}

K
Kalle Valo 已提交
319 320
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
				   enum queue_stop_reason reason)
J
Johannes Berg 已提交
321 322 323
{
	struct ieee80211_local *local = hw_to_local(hw);

J
Johannes Berg 已提交
324 325
	trace_wake_queue(local, queue, reason);

326 327
	if (WARN_ON(queue >= hw->queues))
		return;
K
Kalle Valo 已提交
328

329 330 331
	if (!test_bit(reason, &local->queue_stop_reasons[queue]))
		return;

332 333 334 335 336 337
	__clear_bit(reason, &local->queue_stop_reasons[queue]);

	if (local->queue_stop_reasons[queue] != 0)
		/* someone still has this queue stopped */
		return;

338 339
	if (skb_queue_empty(&local->pending[queue])) {
		rcu_read_lock();
340
		ieee80211_propagate_queue_wake(local, queue);
341 342
		rcu_read_unlock();
	} else
J
Johannes Berg 已提交
343
		tasklet_schedule(&local->tx_pending_tasklet);
J
Johannes Berg 已提交
344
}
K
Kalle Valo 已提交
345

346 347
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
				    enum queue_stop_reason reason)
K
Kalle Valo 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360 361
{
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
	__ieee80211_wake_queue(hw, queue, reason);
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
{
	ieee80211_wake_queue_by_reason(hw, queue,
				       IEEE80211_QUEUE_STOP_REASON_DRIVER);
}
J
Johannes Berg 已提交
362 363
EXPORT_SYMBOL(ieee80211_wake_queue);

K
Kalle Valo 已提交
364 365
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
				   enum queue_stop_reason reason)
J
Johannes Berg 已提交
366 367
{
	struct ieee80211_local *local = hw_to_local(hw);
368
	struct ieee80211_sub_if_data *sdata;
369
	int n_acs = IEEE80211_NUM_ACS;
J
Johannes Berg 已提交
370

J
Johannes Berg 已提交
371 372
	trace_stop_queue(local, queue, reason);

373 374
	if (WARN_ON(queue >= hw->queues))
		return;
375

376 377 378
	if (test_bit(reason, &local->queue_stop_reasons[queue]))
		return;

379
	__set_bit(reason, &local->queue_stop_reasons[queue]);
380

381 382 383
	if (local->hw.queues < IEEE80211_NUM_ACS)
		n_acs = 1;

384
	rcu_read_lock();
385 386 387
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
		int ac;

388 389 390
		if (!sdata->dev)
			continue;

391
		for (ac = 0; ac < n_acs; ac++) {
392 393 394 395 396
			if (sdata->vif.hw_queue[ac] == queue ||
			    sdata->vif.cab_queue == queue)
				netif_stop_subqueue(sdata->dev, ac);
		}
	}
397
	rcu_read_unlock();
J
Johannes Berg 已提交
398
}
K
Kalle Valo 已提交
399

400 401
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
				    enum queue_stop_reason reason)
K
Kalle Valo 已提交
402 403 404 405 406 407 408 409 410 411 412 413 414 415
{
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
	__ieee80211_stop_queue(hw, queue, reason);
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
{
	ieee80211_stop_queue_by_reason(hw, queue,
				       IEEE80211_QUEUE_STOP_REASON_DRIVER);
}
J
Johannes Berg 已提交
416 417
EXPORT_SYMBOL(ieee80211_stop_queue);

418 419 420 421 422
void ieee80211_add_pending_skb(struct ieee80211_local *local,
			       struct sk_buff *skb)
{
	struct ieee80211_hw *hw = &local->hw;
	unsigned long flags;
423
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
424
	int queue = info->hw_queue;
425 426

	if (WARN_ON(!info->control.vif)) {
427
		ieee80211_free_txskb(&local->hw, skb);
428 429
		return;
	}
430 431 432

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
	__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
J
Johannes Berg 已提交
433
	__skb_queue_tail(&local->pending[queue], skb);
434 435 436 437
	__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

438 439
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
				struct sk_buff_head *skbs)
440 441 442 443
{
	struct ieee80211_hw *hw = &local->hw;
	struct sk_buff *skb;
	unsigned long flags;
444
	int queue, i;
445 446 447

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
	while ((skb = skb_dequeue(skbs))) {
448 449 450
		struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

		if (WARN_ON(!info->control.vif)) {
451
			ieee80211_free_txskb(&local->hw, skb);
452 453 454
			continue;
		}

455
		queue = info->hw_queue;
456 457 458 459

		__ieee80211_stop_queue(hw, queue,
				IEEE80211_QUEUE_STOP_REASON_SKB_ADD);

J
Johannes Berg 已提交
460
		__skb_queue_tail(&local->pending[queue], skb);
461 462
	}

J
Johannes Berg 已提交
463
	for (i = 0; i < hw->queues; i++)
464 465 466 467 468
		__ieee80211_wake_queue(hw, i,
			IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

K
Kalle Valo 已提交
469
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
470 471
				     unsigned long queues,
				     enum queue_stop_reason reason)
J
Johannes Berg 已提交
472
{
K
Kalle Valo 已提交
473 474
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;
J
Johannes Berg 已提交
475 476
	int i;

K
Kalle Valo 已提交
477 478
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

479
	for_each_set_bit(i, &queues, hw->queues)
K
Kalle Valo 已提交
480 481 482 483 484 485 486
		__ieee80211_stop_queue(hw, i, reason);

	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

void ieee80211_stop_queues(struct ieee80211_hw *hw)
{
487
	ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
K
Kalle Valo 已提交
488
					IEEE80211_QUEUE_STOP_REASON_DRIVER);
J
Johannes Berg 已提交
489 490 491
}
EXPORT_SYMBOL(ieee80211_stop_queues);

492 493 494
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
{
	struct ieee80211_local *local = hw_to_local(hw);
J
Johannes Berg 已提交
495 496
	unsigned long flags;
	int ret;
497

498 499
	if (WARN_ON(queue >= hw->queues))
		return true;
500

J
Johannes Berg 已提交
501
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
502 503
	ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
		       &local->queue_stop_reasons[queue]);
J
Johannes Berg 已提交
504 505
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
	return ret;
506 507 508
}
EXPORT_SYMBOL(ieee80211_queue_stopped);

K
Kalle Valo 已提交
509
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
510
				     unsigned long queues,
K
Kalle Valo 已提交
511
				     enum queue_stop_reason reason)
J
Johannes Berg 已提交
512
{
K
Kalle Valo 已提交
513 514
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;
J
Johannes Berg 已提交
515 516
	int i;

K
Kalle Valo 已提交
517 518
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

519
	for_each_set_bit(i, &queues, hw->queues)
K
Kalle Valo 已提交
520 521 522 523 524 525 526
		__ieee80211_wake_queue(hw, i, reason);

	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

void ieee80211_wake_queues(struct ieee80211_hw *hw)
{
527 528
	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_DRIVER);
J
Johannes Berg 已提交
529 530
}
EXPORT_SYMBOL(ieee80211_wake_queues);
531

532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
void ieee80211_flush_queues(struct ieee80211_local *local,
			    struct ieee80211_sub_if_data *sdata)
{
	u32 queues;

	if (!local->ops->flush)
		return;

	if (sdata && local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) {
		int ac;

		queues = 0;

		for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
			queues |= BIT(sdata->vif.hw_queue[ac]);
		if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
			queues |= BIT(sdata->vif.cab_queue);
	} else {
		/* all queues */
		queues = BIT(local->hw.queues) - 1;
	}

554 555 556
	ieee80211_stop_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_FLUSH);

557
	drv_flush(local, sdata, queues, false);
558 559 560

	ieee80211_wake_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_FLUSH);
561 562
}

563 564 565 566 567
static void __iterate_active_interfaces(struct ieee80211_local *local,
					u32 iter_flags,
					void (*iterator)(void *data, u8 *mac,
						struct ieee80211_vif *vif),
					void *data)
568 569 570
{
	struct ieee80211_sub_if_data *sdata;

571
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
572
		switch (sdata->vif.type) {
573
		case NL80211_IFTYPE_MONITOR:
574 575 576
			if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
				continue;
			break;
577
		case NL80211_IFTYPE_AP_VLAN:
578
			continue;
579
		default:
580 581
			break;
		}
582 583 584
		if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
		    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
			continue;
585
		if (ieee80211_sdata_running(sdata))
586
			iterator(data, sdata->vif.addr,
587 588 589
				 &sdata->vif);
	}

590 591 592
	sdata = rcu_dereference_check(local->monitor_sdata,
				      lockdep_is_held(&local->iflist_mtx) ||
				      lockdep_rtnl_is_held());
593 594 595
	if (sdata &&
	    (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
	     sdata->flags & IEEE80211_SDATA_IN_DRIVER))
596
		iterator(data, sdata->vif.addr, &sdata->vif);
597
}
598

599 600 601 602 603 604 605 606 607 608
void ieee80211_iterate_active_interfaces(
	struct ieee80211_hw *hw, u32 iter_flags,
	void (*iterator)(void *data, u8 *mac,
			 struct ieee80211_vif *vif),
	void *data)
{
	struct ieee80211_local *local = hw_to_local(hw);

	mutex_lock(&local->iflist_mtx);
	__iterate_active_interfaces(local, iter_flags, iterator, data);
609
	mutex_unlock(&local->iflist_mtx);
610 611 612 613
}
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);

void ieee80211_iterate_active_interfaces_atomic(
614
	struct ieee80211_hw *hw, u32 iter_flags,
615 616 617 618 619 620
	void (*iterator)(void *data, u8 *mac,
			 struct ieee80211_vif *vif),
	void *data)
{
	struct ieee80211_local *local = hw_to_local(hw);

621
	rcu_read_lock();
622 623 624 625
	__iterate_active_interfaces(local, iter_flags, iterator, data);
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
626

627 628 629 630 631 632 633
void ieee80211_iterate_active_interfaces_rtnl(
	struct ieee80211_hw *hw, u32 iter_flags,
	void (*iterator)(void *data, u8 *mac,
			 struct ieee80211_vif *vif),
	void *data)
{
	struct ieee80211_local *local = hw_to_local(hw);
634

635
	ASSERT_RTNL();
636

637
	__iterate_active_interfaces(local, iter_flags, iterator, data);
638
}
639
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
640

J
Johannes Berg 已提交
641 642 643 644 645 646 647 648 649 650 651
struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

	if (!ieee80211_sdata_running(sdata) ||
	    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
		return NULL;
	return &sdata->vif;
}
EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);

652 653 654 655 656 657 658 659 660
/*
 * Nothing should have been stuffed into the workqueue during
 * the suspend->resume cycle. If this WARN is seen then there
 * is a bug with either the driver suspend or something in
 * mac80211 stuffing into the workqueue which we haven't yet
 * cleared during mac80211's suspend cycle.
 */
static bool ieee80211_can_queue_work(struct ieee80211_local *local)
{
J
Johannes Berg 已提交
661 662 663
	if (WARN(local->suspended && !local->resuming,
		 "queueing ieee80211 work while going to suspend\n"))
		return false;
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691

	return true;
}

void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
{
	struct ieee80211_local *local = hw_to_local(hw);

	if (!ieee80211_can_queue_work(local))
		return;

	queue_work(local->workqueue, work);
}
EXPORT_SYMBOL(ieee80211_queue_work);

void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
				  struct delayed_work *dwork,
				  unsigned long delay)
{
	struct ieee80211_local *local = hw_to_local(hw);

	if (!ieee80211_can_queue_work(local))
		return;

	queue_delayed_work(local->workqueue, dwork, delay);
}
EXPORT_SYMBOL(ieee80211_queue_delayed_work);

692
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
693 694 695 696
			       struct ieee802_11_elems *elems,
			       u64 filter, u32 crc)
{
	size_t left = len;
697
	const u8 *pos = start;
698
	bool calc_crc = filter != 0;
P
Paul Stewart 已提交
699
	DECLARE_BITMAP(seen_elems, 256);
700
	const u8 *ie;
701

P
Paul Stewart 已提交
702
	bitmap_zero(seen_elems, 256);
703 704 705 706 707 708
	memset(elems, 0, sizeof(*elems));
	elems->ie_start = start;
	elems->total_len = len;

	while (left >= 2) {
		u8 id, elen;
P
Paul Stewart 已提交
709
		bool elem_parse_failed;
710 711 712 713 714

		id = *pos++;
		elen = *pos++;
		left -= 2;

P
Paul Stewart 已提交
715 716
		if (elen > left) {
			elems->parse_error = true;
717
			break;
P
Paul Stewart 已提交
718 719
		}

720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
		switch (id) {
		case WLAN_EID_SSID:
		case WLAN_EID_SUPP_RATES:
		case WLAN_EID_FH_PARAMS:
		case WLAN_EID_DS_PARAMS:
		case WLAN_EID_CF_PARAMS:
		case WLAN_EID_TIM:
		case WLAN_EID_IBSS_PARAMS:
		case WLAN_EID_CHALLENGE:
		case WLAN_EID_RSN:
		case WLAN_EID_ERP_INFO:
		case WLAN_EID_EXT_SUPP_RATES:
		case WLAN_EID_HT_CAPABILITY:
		case WLAN_EID_HT_OPERATION:
		case WLAN_EID_VHT_CAPABILITY:
		case WLAN_EID_VHT_OPERATION:
		case WLAN_EID_MESH_ID:
		case WLAN_EID_MESH_CONFIG:
		case WLAN_EID_PEER_MGMT:
		case WLAN_EID_PREQ:
		case WLAN_EID_PREP:
		case WLAN_EID_PERR:
		case WLAN_EID_RANN:
		case WLAN_EID_CHANNEL_SWITCH:
		case WLAN_EID_EXT_CHANSWITCH_ANN:
		case WLAN_EID_COUNTRY:
		case WLAN_EID_PWR_CONSTRAINT:
		case WLAN_EID_TIMEOUT_INTERVAL:
748
		case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
749
		case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
750
		case WLAN_EID_CHAN_SWITCH_PARAM:
751 752 753 754
		/*
		 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
		 * that if the content gets bigger it might be needed more than once
		 */
755 756 757 758 759 760 761
			if (test_bit(id, seen_elems)) {
				elems->parse_error = true;
				left -= elen;
				pos += elen;
				continue;
			}
			break;
P
Paul Stewart 已提交
762
		}
763 764 765 766

		if (calc_crc && id < 64 && (filter & (1ULL << id)))
			crc = crc32_be(crc, pos - 2, elen + 2);

P
Paul Stewart 已提交
767 768
		elem_parse_failed = false;

769 770 771 772 773 774 775 776 777 778
		switch (id) {
		case WLAN_EID_SSID:
			elems->ssid = pos;
			elems->ssid_len = elen;
			break;
		case WLAN_EID_SUPP_RATES:
			elems->supp_rates = pos;
			elems->supp_rates_len = elen;
			break;
		case WLAN_EID_DS_PARAMS:
779 780 781 782
			if (elen >= 1)
				elems->ds_params = pos;
			else
				elem_parse_failed = true;
783 784 785 786 787
			break;
		case WLAN_EID_TIM:
			if (elen >= sizeof(struct ieee80211_tim_ie)) {
				elems->tim = (void *)pos;
				elems->tim_len = elen;
P
Paul Stewart 已提交
788 789
			} else
				elem_parse_failed = true;
790 791 792 793 794 795 796 797 798 799 800 801 802
			break;
		case WLAN_EID_CHALLENGE:
			elems->challenge = pos;
			elems->challenge_len = elen;
			break;
		case WLAN_EID_VENDOR_SPECIFIC:
			if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
			    pos[2] == 0xf2) {
				/* Microsoft OUI (00:50:F2) */

				if (calc_crc)
					crc = crc32_be(crc, pos - 2, elen + 2);

803
				if (elen >= 5 && pos[3] == 2) {
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819
					/* OUI Type 2 - WMM IE */
					if (pos[4] == 0) {
						elems->wmm_info = pos;
						elems->wmm_info_len = elen;
					} else if (pos[4] == 1) {
						elems->wmm_param = pos;
						elems->wmm_param_len = elen;
					}
				}
			}
			break;
		case WLAN_EID_RSN:
			elems->rsn = pos;
			elems->rsn_len = elen;
			break;
		case WLAN_EID_ERP_INFO:
820 821 822 823
			if (elen >= 1)
				elems->erp_info = pos;
			else
				elem_parse_failed = true;
824 825 826 827 828 829 830 831
			break;
		case WLAN_EID_EXT_SUPP_RATES:
			elems->ext_supp_rates = pos;
			elems->ext_supp_rates_len = elen;
			break;
		case WLAN_EID_HT_CAPABILITY:
			if (elen >= sizeof(struct ieee80211_ht_cap))
				elems->ht_cap_elem = (void *)pos;
P
Paul Stewart 已提交
832 833
			else
				elem_parse_failed = true;
834
			break;
835 836 837
		case WLAN_EID_HT_OPERATION:
			if (elen >= sizeof(struct ieee80211_ht_operation))
				elems->ht_operation = (void *)pos;
P
Paul Stewart 已提交
838 839
			else
				elem_parse_failed = true;
840
			break;
M
Mahesh Palivela 已提交
841 842 843 844 845 846 847 848 849 850 851 852
		case WLAN_EID_VHT_CAPABILITY:
			if (elen >= sizeof(struct ieee80211_vht_cap))
				elems->vht_cap_elem = (void *)pos;
			else
				elem_parse_failed = true;
			break;
		case WLAN_EID_VHT_OPERATION:
			if (elen >= sizeof(struct ieee80211_vht_operation))
				elems->vht_operation = (void *)pos;
			else
				elem_parse_failed = true;
			break;
853 854 855 856 857 858
		case WLAN_EID_OPMODE_NOTIF:
			if (elen > 0)
				elems->opmode_notif = pos;
			else
				elem_parse_failed = true;
			break;
859 860 861 862 863 864 865
		case WLAN_EID_MESH_ID:
			elems->mesh_id = pos;
			elems->mesh_id_len = elen;
			break;
		case WLAN_EID_MESH_CONFIG:
			if (elen >= sizeof(struct ieee80211_meshconf_ie))
				elems->mesh_config = (void *)pos;
P
Paul Stewart 已提交
866 867
			else
				elem_parse_failed = true;
868 869 870 871 872
			break;
		case WLAN_EID_PEER_MGMT:
			elems->peering = pos;
			elems->peering_len = elen;
			break;
M
Marco Porsch 已提交
873 874 875 876
		case WLAN_EID_MESH_AWAKE_WINDOW:
			if (elen >= 2)
				elems->awake_window = (void *)pos;
			break;
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
		case WLAN_EID_PREQ:
			elems->preq = pos;
			elems->preq_len = elen;
			break;
		case WLAN_EID_PREP:
			elems->prep = pos;
			elems->prep_len = elen;
			break;
		case WLAN_EID_PERR:
			elems->perr = pos;
			elems->perr_len = elen;
			break;
		case WLAN_EID_RANN:
			if (elen >= sizeof(struct ieee80211_rann_ie))
				elems->rann = (void *)pos;
P
Paul Stewart 已提交
892 893
			else
				elem_parse_failed = true;
894 895
			break;
		case WLAN_EID_CHANNEL_SWITCH:
896 897 898 899 900
			if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->ch_switch_ie = (void *)pos;
901
			break;
902 903 904 905 906 907 908
		case WLAN_EID_EXT_CHANSWITCH_ANN:
			if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->ext_chansw_ie = (void *)pos;
			break;
909 910 911 912 913 914 915
		case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
			if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->sec_chan_offs = (void *)pos;
			break;
916 917 918 919 920 921 922 923
		case WLAN_EID_CHAN_SWITCH_PARAM:
			if (elen !=
			    sizeof(*elems->mesh_chansw_params_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->mesh_chansw_params_ie = (void *)pos;
			break;
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
		case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
			if (!action ||
			    elen != sizeof(*elems->wide_bw_chansw_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->wide_bw_chansw_ie = (void *)pos;
			break;
		case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
			if (action) {
				elem_parse_failed = true;
				break;
			}
			/*
			 * This is a bit tricky, but as we only care about
			 * the wide bandwidth channel switch element, so
			 * just parse it out manually.
			 */
			ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
					      pos, elen);
			if (ie) {
				if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
					elems->wide_bw_chansw_ie =
						(void *)(ie + 2);
				else
					elem_parse_failed = true;
			}
			break;
952 953 954 955 956
		case WLAN_EID_COUNTRY:
			elems->country_elem = pos;
			elems->country_elem_len = elen;
			break;
		case WLAN_EID_PWR_CONSTRAINT:
957 958 959 960
			if (elen != 1) {
				elem_parse_failed = true;
				break;
			}
961 962 963
			elems->pwr_constr_elem = pos;
			break;
		case WLAN_EID_TIMEOUT_INTERVAL:
964 965 966 967
			if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
				elems->timeout_int = (void *)pos;
			else
				elem_parse_failed = true;
968 969 970 971 972
			break;
		default:
			break;
		}

P
Paul Stewart 已提交
973 974 975
		if (elem_parse_failed)
			elems->parse_error = true;
		else
976
			__set_bit(id, seen_elems);
P
Paul Stewart 已提交
977

978 979 980 981
		left -= elen;
		pos += elen;
	}

P
Paul Stewart 已提交
982 983 984
	if (left != 0)
		elems->parse_error = true;

985 986 987
	return crc;
}

988 989
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
			       bool bss_notify)
990 991 992
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_tx_queue_params qparam;
J
Johannes Berg 已提交
993
	struct ieee80211_chanctx_conf *chanctx_conf;
994
	int ac;
995
	bool use_11b, enable_qos;
996
	int aCWmin, aCWmax;
997 998 999 1000

	if (!local->ops->conf_tx)
		return;

1001 1002 1003
	if (local->hw.queues < IEEE80211_NUM_ACS)
		return;

1004 1005
	memset(&qparam, 0, sizeof(qparam));

J
Johannes Berg 已提交
1006 1007 1008
	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	use_11b = (chanctx_conf &&
1009
		   chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ) &&
1010
		 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
J
Johannes Berg 已提交
1011
	rcu_read_unlock();
1012

1013 1014 1015 1016 1017 1018 1019
	/*
	 * By default disable QoS in STA mode for old access points, which do
	 * not support 802.11e. New APs will provide proper queue parameters,
	 * that we will configure later.
	 */
	enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION);

1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
	/* Set defaults according to 802.11-2007 Table 7-37 */
	aCWmax = 1023;
	if (use_11b)
		aCWmin = 31;
	else
		aCWmin = 15;

	/* Confiure old 802.11b/g medium access rules. */
	qparam.cw_max = aCWmax;
	qparam.cw_min = aCWmin;
	qparam.txop = 0;
	qparam.aifs = 2;
1032

1033 1034
	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
		/* Update if QoS is enabled. */
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
		if (enable_qos) {
			switch (ac) {
			case IEEE80211_AC_BK:
				qparam.cw_max = aCWmax;
				qparam.cw_min = aCWmin;
				qparam.txop = 0;
				qparam.aifs = 7;
				break;
			/* never happens but let's not leave undefined */
			default:
			case IEEE80211_AC_BE:
				qparam.cw_max = aCWmax;
				qparam.cw_min = aCWmin;
				qparam.txop = 0;
				qparam.aifs = 3;
				break;
			case IEEE80211_AC_VI:
				qparam.cw_max = aCWmin;
				qparam.cw_min = (aCWmin + 1) / 2 - 1;
				if (use_11b)
					qparam.txop = 6016/32;
				else
					qparam.txop = 3008/32;
				qparam.aifs = 2;
				break;
			case IEEE80211_AC_VO:
				qparam.cw_max = (aCWmin + 1) / 2 - 1;
				qparam.cw_min = (aCWmin + 1) / 4 - 1;
				if (use_11b)
					qparam.txop = 3264/32;
				else
					qparam.txop = 1504/32;
				qparam.aifs = 2;
				break;
			}
1070
		}
1071

K
Kalle Valo 已提交
1072 1073
		qparam.uapsd = false;

1074 1075
		sdata->tx_conf[ac] = qparam;
		drv_conf_tx(local, sdata, ac, &qparam);
1076
	}
1077

1078 1079
	if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
	    sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
1080
		sdata->vif.bss_conf.qos = enable_qos;
1081 1082 1083
		if (bss_notify)
			ieee80211_bss_info_change_notify(sdata,
							 BSS_CHANGED_QOS);
1084
	}
1085
}
J
Johannes Berg 已提交
1086

1087
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1088
			 u16 transaction, u16 auth_alg, u16 status,
J
Johannes Berg 已提交
1089
			 const u8 *extra, size_t extra_len, const u8 *da,
1090 1091
			 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
			 u32 tx_flags)
1092 1093 1094 1095
{
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
J
Johannes Berg 已提交
1096
	int err;
1097

1098 1099
	/* 24 + 6 = header + auth_algo + auth_transaction + status_code */
	skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 6 + extra_len);
1100
	if (!skb)
1101
		return;
1102

1103 1104 1105 1106 1107 1108
	skb_reserve(skb, local->hw.extra_tx_headroom);

	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
	memset(mgmt, 0, 24 + 6);
	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
					  IEEE80211_STYPE_AUTH);
1109
	memcpy(mgmt->da, da, ETH_ALEN);
1110
	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1111 1112 1113
	memcpy(mgmt->bssid, bssid, ETH_ALEN);
	mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
	mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1114
	mgmt->u.auth.status_code = cpu_to_le16(status);
1115 1116 1117
	if (extra)
		memcpy(skb_put(skb, extra_len), extra, extra_len);

J
Johannes Berg 已提交
1118 1119 1120 1121 1122 1123
	if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
		mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
		err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
		WARN_ON(err);
	}

1124 1125
	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
					tx_flags;
1126
	ieee80211_tx_skb(sdata, skb);
1127 1128
}

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
				    const u8 *bssid, u16 stype, u16 reason,
				    bool send_frame, u8 *frame_buf)
{
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt = (void *)frame_buf;

	/* build frame */
	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
	mgmt->duration = 0; /* initialize only */
	mgmt->seq_ctrl = 0; /* initialize only */
	memcpy(mgmt->da, bssid, ETH_ALEN);
	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
	memcpy(mgmt->bssid, bssid, ETH_ALEN);
	/* u.deauth.reason_code == u.disassoc.reason_code */
	mgmt->u.deauth.reason_code = cpu_to_le16(reason);

	if (send_frame) {
		skb = dev_alloc_skb(local->hw.extra_tx_headroom +
				    IEEE80211_DEAUTH_FRAME_LEN);
		if (!skb)
			return;

		skb_reserve(skb, local->hw.extra_tx_headroom);

		/* copy in frame */
		memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN),
		       mgmt, IEEE80211_DEAUTH_FRAME_LEN);

		if (sdata->vif.type != NL80211_IFTYPE_STATION ||
		    !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
			IEEE80211_SKB_CB(skb)->flags |=
				IEEE80211_TX_INTFL_DONT_ENCRYPT;

		ieee80211_tx_skb(sdata, skb);
	}
}

1168
int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1169
			     size_t buffer_len, const u8 *ie, size_t ie_len,
1170
			     enum ieee80211_band band, u32 rate_mask,
1171
			     struct cfg80211_chan_def *chandef)
1172 1173
{
	struct ieee80211_supported_band *sband;
1174
	u8 *pos = buffer, *end = buffer + buffer_len;
1175 1176
	size_t offset = 0, noffset;
	int supp_rates_len, i;
1177 1178 1179
	u8 rates[32];
	int num_rates;
	int ext_rates_len;
1180 1181
	int shift;
	u32 rate_flags;
1182

1183
	sband = local->hw.wiphy->bands[band];
1184 1185
	if (WARN_ON_ONCE(!sband))
		return 0;
1186

1187 1188 1189
	rate_flags = ieee80211_chandef_rate_flags(chandef);
	shift = ieee80211_chandef_get_shift(chandef);

1190 1191 1192 1193
	num_rates = 0;
	for (i = 0; i < sband->n_bitrates; i++) {
		if ((BIT(i) & rate_mask) == 0)
			continue; /* skip rate */
1194 1195 1196 1197 1198 1199
		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
			continue;

		rates[num_rates++] =
			(u8) DIV_ROUND_UP(sband->bitrates[i].bitrate,
					  (1 << shift) * 5);
1200 1201 1202
	}

	supp_rates_len = min_t(int, num_rates, 8);
1203

1204 1205
	if (end - pos < 2 + supp_rates_len)
		goto out_err;
1206
	*pos++ = WLAN_EID_SUPP_RATES;
1207
	*pos++ = supp_rates_len;
1208 1209
	memcpy(pos, rates, supp_rates_len);
	pos += supp_rates_len;
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221

	/* insert "request information" if in custom IEs */
	if (ie && ie_len) {
		static const u8 before_extrates[] = {
			WLAN_EID_SSID,
			WLAN_EID_SUPP_RATES,
			WLAN_EID_REQUEST,
		};
		noffset = ieee80211_ie_split(ie, ie_len,
					     before_extrates,
					     ARRAY_SIZE(before_extrates),
					     offset);
1222 1223
		if (end - pos < noffset - offset)
			goto out_err;
1224 1225 1226 1227 1228
		memcpy(pos, ie + offset, noffset - offset);
		pos += noffset - offset;
		offset = noffset;
	}

1229 1230
	ext_rates_len = num_rates - supp_rates_len;
	if (ext_rates_len > 0) {
1231 1232
		if (end - pos < 2 + ext_rates_len)
			goto out_err;
1233
		*pos++ = WLAN_EID_EXT_SUPP_RATES;
1234 1235 1236
		*pos++ = ext_rates_len;
		memcpy(pos, rates + supp_rates_len, ext_rates_len);
		pos += ext_rates_len;
1237 1238
	}

1239
	if (chandef->chan && sband->band == IEEE80211_BAND_2GHZ) {
1240 1241
		if (end - pos < 3)
			goto out_err;
1242 1243
		*pos++ = WLAN_EID_DS_PARAMS;
		*pos++ = 1;
1244 1245
		*pos++ = ieee80211_frequency_to_channel(
				chandef->chan->center_freq);
1246 1247
	}

1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
	/* insert custom IEs that go before HT */
	if (ie && ie_len) {
		static const u8 before_ht[] = {
			WLAN_EID_SSID,
			WLAN_EID_SUPP_RATES,
			WLAN_EID_REQUEST,
			WLAN_EID_EXT_SUPP_RATES,
			WLAN_EID_DS_PARAMS,
			WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
		};
		noffset = ieee80211_ie_split(ie, ie_len,
					     before_ht, ARRAY_SIZE(before_ht),
					     offset);
1261 1262
		if (end - pos < noffset - offset)
			goto out_err;
1263 1264 1265
		memcpy(pos, ie + offset, noffset - offset);
		pos += noffset - offset;
		offset = noffset;
1266 1267
	}

1268 1269 1270
	if (sband->ht_cap.ht_supported) {
		if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
			goto out_err;
B
Ben Greear 已提交
1271 1272
		pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
						sband->ht_cap.cap);
1273
	}
1274

1275 1276 1277 1278 1279
	/*
	 * If adding more here, adjust code in main.c
	 * that calculates local->scan_ies_len.
	 */

1280
	/* insert custom IEs that go before VHT */
1281
	if (ie && ie_len) {
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
		static const u8 before_vht[] = {
			WLAN_EID_SSID,
			WLAN_EID_SUPP_RATES,
			WLAN_EID_REQUEST,
			WLAN_EID_EXT_SUPP_RATES,
			WLAN_EID_DS_PARAMS,
			WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
			WLAN_EID_HT_CAPABILITY,
			WLAN_EID_BSS_COEX_2040,
			WLAN_EID_EXT_CAPABILITY,
			WLAN_EID_SSID_LIST,
			WLAN_EID_CHANNEL_USAGE,
			WLAN_EID_INTERWORKING,
			/* mesh ID can't happen here */
			/* 60 GHz can't happen here right now */
		};
		noffset = ieee80211_ie_split(ie, ie_len,
					     before_vht, ARRAY_SIZE(before_vht),
					     offset);
1301 1302
		if (end - pos < noffset - offset)
			goto out_err;
1303 1304
		memcpy(pos, ie + offset, noffset - offset);
		pos += noffset - offset;
1305
		offset = noffset;
1306 1307
	}

1308 1309 1310
	if (sband->vht_cap.vht_supported) {
		if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
			goto out_err;
1311 1312
		pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
						 sband->vht_cap.cap);
1313
	}
1314

1315 1316 1317 1318 1319 1320 1321 1322 1323
	/* add any remaining custom IEs */
	if (ie && ie_len) {
		noffset = ie_len;
		if (end - pos < noffset - offset)
			goto out_err;
		memcpy(pos, ie + offset, noffset - offset);
		pos += noffset - offset;
	}

1324 1325 1326
	return pos - buffer;
 out_err:
	WARN_ONCE(1, "not enough space for preq IEs\n");
1327 1328 1329
	return pos - buffer;
}

1330
struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1331
					  u8 *dst, u32 ratemask,
1332
					  struct ieee80211_channel *chan,
1333
					  const u8 *ssid, size_t ssid_len,
1334 1335
					  const u8 *ie, size_t ie_len,
					  bool directed)
1336 1337
{
	struct ieee80211_local *local = sdata->local;
1338
	struct cfg80211_chan_def chandef;
1339 1340
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
1341
	int ies_len;
1342

1343 1344 1345 1346 1347
	/*
	 * Do not send DS Channel parameter for directed probe requests
	 * in order to maximize the chance that we get a response.  Some
	 * badly-behaved APs don't respond when this parameter is included.
	 */
1348
	chandef.width = sdata->vif.bss_conf.chandef.width;
1349
	if (directed)
1350
		chandef.chan = NULL;
1351
	else
1352
		chandef.chan = chan;
1353

1354
	skb = ieee80211_probereq_get(&local->hw, &sdata->vif,
1355
				     ssid, ssid_len, 100 + ie_len);
1356
	if (!skb)
1357 1358 1359 1360 1361
		return NULL;

	ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
					   skb_tailroom(skb),
					   ie, ie_len, chan->band,
1362
					   ratemask, &chandef);
1363
	skb_put(skb, ies_len);
1364

1365
	if (dst) {
1366
		mgmt = (struct ieee80211_mgmt *) skb->data;
1367 1368 1369 1370
		memcpy(mgmt->da, dst, ETH_ALEN);
		memcpy(mgmt->bssid, dst, ETH_ALEN);
	}

1371
	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1372

1373 1374 1375 1376 1377
	return skb;
}

void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
			      const u8 *ssid, size_t ssid_len,
1378
			      const u8 *ie, size_t ie_len,
1379
			      u32 ratemask, bool directed, u32 tx_flags,
J
Johannes Berg 已提交
1380
			      struct ieee80211_channel *channel, bool scan)
1381 1382 1383
{
	struct sk_buff *skb;

1384
	skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel,
1385
					ssid, ssid_len,
1386
					ie, ie_len, directed);
1387
	if (skb) {
1388
		IEEE80211_SKB_CB(skb)->flags |= tx_flags;
J
Johannes Berg 已提交
1389 1390 1391 1392
		if (scan)
			ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band);
		else
			ieee80211_tx_skb(sdata, skb);
1393
	}
1394 1395
}

1396
u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1397
			    struct ieee802_11_elems *elems,
1398
			    enum ieee80211_band band, u32 *basic_rates)
1399 1400 1401
{
	struct ieee80211_supported_band *sband;
	size_t num_rates;
1402 1403 1404 1405 1406 1407
	u32 supp_rates, rate_flags;
	int i, j, shift;
	sband = sdata->local->hw.wiphy->bands[band];

	rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
	shift = ieee80211_vif_get_shift(&sdata->vif);
1408

1409 1410
	if (WARN_ON(!sband))
		return 1;
1411 1412 1413 1414 1415 1416 1417

	num_rates = sband->n_bitrates;
	supp_rates = 0;
	for (i = 0; i < elems->supp_rates_len +
		     elems->ext_supp_rates_len; i++) {
		u8 rate = 0;
		int own_rate;
1418
		bool is_basic;
1419 1420 1421 1422 1423 1424
		if (i < elems->supp_rates_len)
			rate = elems->supp_rates[i];
		else if (elems->ext_supp_rates)
			rate = elems->ext_supp_rates
				[i - elems->supp_rates_len];
		own_rate = 5 * (rate & 0x7f);
1425 1426 1427 1428 1429 1430
		is_basic = !!(rate & 0x80);

		if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
			continue;

		for (j = 0; j < num_rates; j++) {
1431 1432 1433 1434 1435 1436 1437 1438 1439
			int brate;
			if ((rate_flags & sband->bitrates[j].flags)
			    != rate_flags)
				continue;

			brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
					     1 << shift);

			if (brate == own_rate) {
1440
				supp_rates |= BIT(j);
1441 1442 1443 1444
				if (basic_rates && is_basic)
					*basic_rates |= BIT(j);
			}
		}
1445 1446 1447
	}
	return supp_rates;
}
1448

1449 1450 1451
void ieee80211_stop_device(struct ieee80211_local *local)
{
	ieee80211_led_radio(local, false);
1452
	ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
1453 1454 1455 1456

	cancel_work_sync(&local->reconfig_filter);

	flush_workqueue(local->workqueue);
1457
	drv_stop(local);
1458 1459
}

1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
static void ieee80211_assign_chanctx(struct ieee80211_local *local,
				     struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_chanctx_conf *conf;
	struct ieee80211_chanctx *ctx;

	if (!local->use_chanctx)
		return;

	mutex_lock(&local->chanctx_mtx);
	conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					 lockdep_is_held(&local->chanctx_mtx));
	if (conf) {
		ctx = container_of(conf, struct ieee80211_chanctx, conf);
		drv_assign_vif_chanctx(local, sdata, ctx);
	}
	mutex_unlock(&local->chanctx_mtx);
}

1479 1480 1481 1482
int ieee80211_reconfig(struct ieee80211_local *local)
{
	struct ieee80211_hw *hw = &local->hw;
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
1483
	struct ieee80211_chanctx *ctx;
1484
	struct sta_info *sta;
1485
	int res, i;
J
Johannes Berg 已提交
1486
	bool reconfig_due_to_wowlan = false;
1487 1488
	struct ieee80211_sub_if_data *sched_scan_sdata;
	bool sched_scan_stopped = false;
J
Johannes Berg 已提交
1489

1490
#ifdef CONFIG_PM
J
Johannes Berg 已提交
1491 1492
	if (local->suspended)
		local->resuming = true;
1493

1494 1495
	if (local->wowlan) {
		res = drv_resume(local);
1496
		local->wowlan = false;
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
		if (res < 0) {
			local->resuming = false;
			return res;
		}
		if (res == 0)
			goto wake_up;
		WARN_ON(res > 1);
		/*
		 * res is 1, which means the driver requested
		 * to go through a regular reset on wakeup.
		 */
J
Johannes Berg 已提交
1508
		reconfig_due_to_wowlan = true;
1509 1510
	}
#endif
1511 1512 1513
	/* everything else happens only if HW was up & running */
	if (!local->open_count)
		goto wake_up;
1514

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
	/*
	 * Upon resume hardware can sometimes be goofy due to
	 * various platform / driver / bus issues, so restarting
	 * the device may at times not work immediately. Propagate
	 * the error.
	 */
	res = drv_start(local);
	if (res) {
		WARN(local->suspended, "Hardware became unavailable "
		     "upon resume. This could be a software issue "
		     "prior to suspend or a hardware issue.\n");
		return res;
1527 1528
	}

1529 1530 1531 1532 1533 1534 1535 1536 1537
	/* setup fragmentation threshold */
	drv_set_frag_threshold(local, hw->wiphy->frag_threshold);

	/* setup RTS threshold */
	drv_set_rts_threshold(local, hw->wiphy->rts_threshold);

	/* reset coverage class */
	drv_set_coverage_class(local, hw->wiphy->coverage_class);

1538 1539 1540 1541
	ieee80211_led_radio(local, true);
	ieee80211_mod_tpt_led_trig(local,
				   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);

1542
	/* add interfaces */
1543 1544
	sdata = rtnl_dereference(local->monitor_sdata);
	if (sdata) {
1545 1546
		/* in HW restart it exists already */
		WARN_ON(local->resuming);
1547 1548
		res = drv_add_interface(local, sdata);
		if (WARN_ON(res)) {
M
Monam Agarwal 已提交
1549
			RCU_INIT_POINTER(local->monitor_sdata, NULL);
1550 1551 1552 1553 1554
			synchronize_net();
			kfree(sdata);
		}
	}

1555 1556 1557
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1558
		    ieee80211_sdata_running(sdata))
1559
			res = drv_add_interface(local, sdata);
1560 1561
	}

J
Johannes Berg 已提交
1562
	/* add channel contexts */
1563 1564 1565 1566 1567 1568
	if (local->use_chanctx) {
		mutex_lock(&local->chanctx_mtx);
		list_for_each_entry(ctx, &local->chanctx_list, list)
			WARN_ON(drv_add_chanctx(local, ctx));
		mutex_unlock(&local->chanctx_mtx);
	}
J
Johannes Berg 已提交
1569

1570 1571 1572
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (!ieee80211_sdata_running(sdata))
			continue;
1573
		ieee80211_assign_chanctx(local, sdata);
1574 1575
	}

1576
	sdata = rtnl_dereference(local->monitor_sdata);
1577 1578
	if (sdata && ieee80211_sdata_running(sdata))
		ieee80211_assign_chanctx(local, sdata);
1579

1580
	/* add STAs back */
1581 1582
	mutex_lock(&local->sta_mtx);
	list_for_each_entry(sta, &local->sta_list, list) {
1583
		enum ieee80211_sta_state state;
J
Johannes Berg 已提交
1584

1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
		if (!sta->uploaded)
			continue;

		/* AP-mode stations will be added later */
		if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
			continue;

		for (state = IEEE80211_STA_NOTEXIST;
		     state < sta->sta_state; state++)
			WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
					      state + 1));
1596
	}
1597
	mutex_unlock(&local->sta_mtx);
1598

1599
	/* reconfigure tx conf */
1600 1601 1602 1603 1604 1605
	if (hw->queues >= IEEE80211_NUM_ACS) {
		list_for_each_entry(sdata, &local->interfaces, list) {
			if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
			    sdata->vif.type == NL80211_IFTYPE_MONITOR ||
			    !ieee80211_sdata_running(sdata))
				continue;
1606

1607 1608 1609 1610
			for (i = 0; i < IEEE80211_NUM_ACS; i++)
				drv_conf_tx(local, sdata, i,
					    &sdata->tx_conf[i]);
		}
1611
	}
1612

1613 1614 1615 1616 1617 1618 1619
	/* reconfigure hardware */
	ieee80211_hw_config(local, ~0);

	ieee80211_configure_filter(local);

	/* Finally also reconfigure all the BSS information */
	list_for_each_entry(sdata, &local->interfaces, list) {
1620 1621
		u32 changed;

1622
		if (!ieee80211_sdata_running(sdata))
1623
			continue;
1624 1625 1626 1627 1628 1629 1630 1631 1632

		/* common change flags for all interface types */
		changed = BSS_CHANGED_ERP_CTS_PROT |
			  BSS_CHANGED_ERP_PREAMBLE |
			  BSS_CHANGED_ERP_SLOT |
			  BSS_CHANGED_HT |
			  BSS_CHANGED_BASIC_RATES |
			  BSS_CHANGED_BEACON_INT |
			  BSS_CHANGED_BSSID |
1633
			  BSS_CHANGED_CQM |
1634
			  BSS_CHANGED_QOS |
1635 1636
			  BSS_CHANGED_IDLE |
			  BSS_CHANGED_TXPOWER;
1637

1638 1639
		switch (sdata->vif.type) {
		case NL80211_IFTYPE_STATION:
1640
			changed |= BSS_CHANGED_ASSOC |
E
Eliad Peller 已提交
1641 1642
				   BSS_CHANGED_ARP_FILTER |
				   BSS_CHANGED_PS;
1643

1644 1645 1646
			/* Re-send beacon info report to the driver */
			if (sdata->u.mgd.have_beacon)
				changed |= BSS_CHANGED_BEACON_INFO;
1647

1648
			sdata_lock(sdata);
1649
			ieee80211_bss_info_change_notify(sdata, changed);
1650
			sdata_unlock(sdata);
1651
			break;
1652
		case NL80211_IFTYPE_ADHOC:
1653 1654
			changed |= BSS_CHANGED_IBSS;
			/* fall through */
1655
		case NL80211_IFTYPE_AP:
1656
			changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
1657

1658
			if (sdata->vif.type == NL80211_IFTYPE_AP) {
1659 1660
				changed |= BSS_CHANGED_AP_PROBE_RESP;

1661 1662 1663 1664
				if (rcu_access_pointer(sdata->u.ap.beacon))
					drv_start_ap(local, sdata);
			}

1665
			/* fall through */
1666
		case NL80211_IFTYPE_MESH_POINT:
1667 1668 1669 1670 1671
			if (sdata->vif.bss_conf.enable_beacon) {
				changed |= BSS_CHANGED_BEACON |
					   BSS_CHANGED_BEACON_ENABLED;
				ieee80211_bss_info_change_notify(sdata, changed);
			}
1672 1673 1674 1675 1676 1677 1678
			break;
		case NL80211_IFTYPE_WDS:
			break;
		case NL80211_IFTYPE_AP_VLAN:
		case NL80211_IFTYPE_MONITOR:
			/* ignore virtual */
			break;
1679
		case NL80211_IFTYPE_P2P_DEVICE:
1680 1681
			changed = BSS_CHANGED_IDLE;
			break;
1682
		case NL80211_IFTYPE_UNSPECIFIED:
1683
		case NUM_NL80211_IFTYPES:
1684 1685
		case NL80211_IFTYPE_P2P_CLIENT:
		case NL80211_IFTYPE_P2P_GO:
1686 1687 1688 1689 1690
			WARN_ON(1);
			break;
		}
	}

1691 1692
	ieee80211_recalc_ps(local, -1);

1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
	/*
	 * The sta might be in psm against the ap (e.g. because
	 * this was the state before a hw restart), so we
	 * explicitly send a null packet in order to make sure
	 * it'll sync against the ap (and get out of psm).
	 */
	if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
		list_for_each_entry(sdata, &local->interfaces, list) {
			if (sdata->vif.type != NL80211_IFTYPE_STATION)
				continue;
1703 1704
			if (!sdata->u.mgd.associated)
				continue;
1705 1706 1707 1708 1709

			ieee80211_send_nullfunc(local, sdata, 0);
		}
	}

1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
	/* APs are now beaconing, add back stations */
	mutex_lock(&local->sta_mtx);
	list_for_each_entry(sta, &local->sta_list, list) {
		enum ieee80211_sta_state state;

		if (!sta->uploaded)
			continue;

		if (sta->sdata->vif.type != NL80211_IFTYPE_AP)
			continue;

		for (state = IEEE80211_STA_NOTEXIST;
		     state < sta->sta_state; state++)
			WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
					      state + 1));
	}
	mutex_unlock(&local->sta_mtx);

1728 1729 1730 1731 1732
	/* add back keys */
	list_for_each_entry(sdata, &local->interfaces, list)
		if (ieee80211_sdata_running(sdata))
			ieee80211_enable_keys(sdata);

1733
 wake_up:
1734 1735 1736
	local->in_reconfig = false;
	barrier();

1737 1738 1739
	if (local->monitors == local->open_count && local->monitors > 0)
		ieee80211_add_virtual_monitor(local);

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
	/*
	 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
	 * sessions can be established after a resume.
	 *
	 * Also tear down aggregation sessions since reconfiguring
	 * them in a hardware restart scenario is not easily done
	 * right now, and the hardware will have lost information
	 * about the sessions, but we and the AP still think they
	 * are active. This is really a workaround though.
	 */
1750
	if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
1751 1752 1753
		mutex_lock(&local->sta_mtx);

		list_for_each_entry(sta, &local->sta_list, list) {
1754 1755
			ieee80211_sta_tear_down_BA_sessions(
					sta, AGG_STOP_LOCAL_REQUEST);
J
Johannes Berg 已提交
1756
			clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
1757
		}
1758 1759

		mutex_unlock(&local->sta_mtx);
1760 1761
	}

1762 1763
	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_SUSPEND);
1764

1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
	/*
	 * Reconfigure sched scan if it was interrupted by FW restart or
	 * suspend.
	 */
	mutex_lock(&local->mtx);
	sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
						lockdep_is_held(&local->mtx));
	if (sched_scan_sdata && local->sched_scan_req)
		/*
		 * Sched scan stopped, but we don't want to report it. Instead,
		 * we're trying to reschedule.
		 */
		if (__ieee80211_request_sched_scan_start(sched_scan_sdata,
							 local->sched_scan_req))
			sched_scan_stopped = true;
	mutex_unlock(&local->mtx);

	if (sched_scan_stopped)
		cfg80211_sched_scan_stopped(local->hw.wiphy);

1785 1786 1787 1788
	/*
	 * If this is for hw restart things are still running.
	 * We may want to change that later, however.
	 */
1789
	if (!local->suspended || reconfig_due_to_wowlan)
1790
		drv_restart_complete(local);
1791 1792

	if (!local->suspended)
1793 1794 1795
		return 0;

#ifdef CONFIG_PM
J
Johannes Berg 已提交
1796
	/* first set suspended false, then resuming */
1797
	local->suspended = false;
J
Johannes Berg 已提交
1798 1799
	mb();
	local->resuming = false;
1800

1801 1802 1803 1804 1805 1806 1807
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (!ieee80211_sdata_running(sdata))
			continue;
		if (sdata->vif.type == NL80211_IFTYPE_STATION)
			ieee80211_sta_restart(sdata);
	}

1808
	mod_timer(&local->sta_cleanup, jiffies + 1);
1809 1810 1811
#else
	WARN_ON(1);
#endif
1812

1813 1814
	return 0;
}
1815

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
{
	struct ieee80211_sub_if_data *sdata;
	struct ieee80211_local *local;
	struct ieee80211_key *key;

	if (WARN_ON(!vif))
		return;

	sdata = vif_to_sdata(vif);
	local = sdata->local;

	if (WARN_ON(!local->resuming))
		return;

	if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
		return;

	sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;

	mutex_lock(&local->key_mtx);
	list_for_each_entry(key, &sdata->key_list, list)
		key->flags |= KEY_FLAG_TAINTED;
	mutex_unlock(&local->key_mtx);
}
EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);

1843
void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
1844
{
1845 1846 1847
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_chanctx *chanctx;
1848

1849
	mutex_lock(&local->chanctx_mtx);
1850

1851 1852
	chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					lockdep_is_held(&local->chanctx_mtx));
1853

1854
	if (WARN_ON_ONCE(!chanctx_conf))
1855
		goto unlock;
1856

1857 1858
	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
	ieee80211_recalc_smps_chanctx(local, chanctx);
1859
 unlock:
1860
	mutex_unlock(&local->chanctx_mtx);
1861
}
1862

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_chanctx *chanctx;

	mutex_lock(&local->chanctx_mtx);

	chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					lockdep_is_held(&local->chanctx_mtx));

	if (WARN_ON_ONCE(!chanctx_conf))
		goto unlock;

	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
	ieee80211_recalc_chanctx_min_def(local, chanctx);
 unlock:
	mutex_unlock(&local->chanctx_mtx);
}

1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id)
{
	int i;

	for (i = 0; i < n_ids; i++)
		if (ids[i] == id)
			return true;
	return false;
}

/**
 * ieee80211_ie_split - split an IE buffer according to ordering
 *
 * @ies: the IE buffer
 * @ielen: the length of the IE buffer
 * @ids: an array with element IDs that are allowed before
 *	the split
 * @n_ids: the size of the element ID array
 * @offset: offset where to start splitting in the buffer
 *
 * This function splits an IE buffer by updating the @offset
 * variable to point to the location where the buffer should be
 * split.
 *
 * It assumes that the given IE buffer is well-formed, this
 * has to be guaranteed by the caller!
 *
 * It also assumes that the IEs in the buffer are ordered
 * correctly, if not the result of using this function will not
 * be ordered correctly either, i.e. it does no reordering.
 *
 * The function returns the offset where the next part of the
 * buffer starts, which may be @ielen if the entire (remainder)
 * of the buffer should be used.
 */
size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
			  const u8 *ids, int n_ids, size_t offset)
{
	size_t pos = offset;

	while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos]))
		pos += 2 + ies[pos + 1];

	return pos;
}

size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
{
	size_t pos = offset;

	while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
		pos += 2 + ies[pos + 1];

	return pos;
}
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977

static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
					    int rssi_min_thold,
					    int rssi_max_thold)
{
	trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);

	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
		return;

	/*
	 * Scale up threshold values before storing it, as the RSSI averaging
	 * algorithm uses a scaled up value as well. Change this scaling
	 * factor if the RSSI averaging algorithm changes.
	 */
	sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
	sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
}

void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
				    int rssi_min_thold,
				    int rssi_max_thold)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);

	WARN_ON(rssi_min_thold == rssi_max_thold ||
		rssi_min_thold > rssi_max_thold);

	_ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
				       rssi_max_thold);
}
EXPORT_SYMBOL(ieee80211_enable_rssi_reports);

void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);

	_ieee80211_enable_rssi_reports(sdata, 0, 0);
}
EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
1978

B
Ben Greear 已提交
1979
u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
			      u16 cap)
{
	__le16 tmp;

	*pos++ = WLAN_EID_HT_CAPABILITY;
	*pos++ = sizeof(struct ieee80211_ht_cap);
	memset(pos, 0, sizeof(struct ieee80211_ht_cap));

	/* capability flags */
	tmp = cpu_to_le16(cap);
	memcpy(pos, &tmp, sizeof(u16));
	pos += sizeof(u16);

	/* AMPDU parameters */
B
Ben Greear 已提交
1994 1995
	*pos++ = ht_cap->ampdu_factor |
		 (ht_cap->ampdu_density <<
1996 1997 1998
			IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);

	/* MCS set */
B
Ben Greear 已提交
1999 2000
	memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
	pos += sizeof(ht_cap->mcs);
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013

	/* extended capabilities */
	pos += sizeof(__le16);

	/* BF capabilities */
	pos += sizeof(__le32);

	/* antenna selection */
	pos += sizeof(u8);

	return pos;
}

2014
u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2015
			       u32 cap)
2016 2017 2018 2019
{
	__le32 tmp;

	*pos++ = WLAN_EID_VHT_CAPABILITY;
M
Mahesh Palivela 已提交
2020 2021
	*pos++ = sizeof(struct ieee80211_vht_cap);
	memset(pos, 0, sizeof(struct ieee80211_vht_cap));
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034

	/* capability flags */
	tmp = cpu_to_le32(cap);
	memcpy(pos, &tmp, sizeof(u32));
	pos += sizeof(u32);

	/* VHT MCS set */
	memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
	pos += sizeof(vht_cap->vht_mcs);

	return pos;
}

2035
u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2036
			       const struct cfg80211_chan_def *chandef,
2037
			       u16 prot_mode)
2038
{
2039
	struct ieee80211_ht_operation *ht_oper;
2040
	/* Build HT Information */
2041 2042 2043
	*pos++ = WLAN_EID_HT_OPERATION;
	*pos++ = sizeof(struct ieee80211_ht_operation);
	ht_oper = (struct ieee80211_ht_operation *)pos;
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
	ht_oper->primary_chan = ieee80211_frequency_to_channel(
					chandef->chan->center_freq);
	switch (chandef->width) {
	case NL80211_CHAN_WIDTH_160:
	case NL80211_CHAN_WIDTH_80P80:
	case NL80211_CHAN_WIDTH_80:
	case NL80211_CHAN_WIDTH_40:
		if (chandef->center_freq1 > chandef->chan->center_freq)
			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
		else
			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2055 2056
		break;
	default:
2057
		ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
2058 2059
		break;
	}
2060
	if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
2061 2062
	    chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
	    chandef->width != NL80211_CHAN_WIDTH_20)
2063
		ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
2064

2065
	ht_oper->operation_mode = cpu_to_le16(prot_mode);
2066
	ht_oper->stbc_param = 0x0000;
2067 2068 2069

	/* It seems that Basic MCS set and Supported MCS set
	   are identical for the first 10 bytes */
2070 2071
	memset(&ht_oper->basic_set, 0, 16);
	memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
2072

2073
	return pos + sizeof(struct ieee80211_ht_operation);
2074 2075
}

2076
void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
J
Johannes Berg 已提交
2077
				  const struct ieee80211_ht_operation *ht_oper,
2078
				  struct cfg80211_chan_def *chandef)
2079 2080 2081
{
	enum nl80211_channel_type channel_type;

2082 2083 2084 2085 2086
	if (!ht_oper) {
		cfg80211_chandef_create(chandef, control_chan,
					NL80211_CHAN_NO_HT);
		return;
	}
2087

2088
	switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
	case IEEE80211_HT_PARAM_CHA_SEC_NONE:
		channel_type = NL80211_CHAN_HT20;
		break;
	case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
		channel_type = NL80211_CHAN_HT40PLUS;
		break;
	case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
		channel_type = NL80211_CHAN_HT40MINUS;
		break;
	default:
		channel_type = NL80211_CHAN_NO_HT;
	}

2102
	cfg80211_chandef_create(chandef, control_chan, channel_type);
2103 2104
}

2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
int ieee80211_parse_bitrates(struct cfg80211_chan_def *chandef,
			     const struct ieee80211_supported_band *sband,
			     const u8 *srates, int srates_len, u32 *rates)
{
	u32 rate_flags = ieee80211_chandef_rate_flags(chandef);
	int shift = ieee80211_chandef_get_shift(chandef);
	struct ieee80211_rate *br;
	int brate, rate, i, j, count = 0;

	*rates = 0;

	for (i = 0; i < srates_len; i++) {
		rate = srates[i] & 0x7f;

		for (j = 0; j < sband->n_bitrates; j++) {
			br = &sband->bitrates[j];
			if ((rate_flags & br->flags) != rate_flags)
				continue;

			brate = DIV_ROUND_UP(br->bitrate, (1 << shift) * 5);
			if (brate == rate) {
				*rates |= BIT(j);
				count++;
				break;
			}
		}
	}
	return count;
}

2135
int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
2136 2137
			    struct sk_buff *skb, bool need_basic,
			    enum ieee80211_band band)
2138 2139 2140
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_supported_band *sband;
2141
	int rate, shift;
2142
	u8 i, rates, *pos;
2143
	u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2144
	u32 rate_flags;
2145

2146 2147
	shift = ieee80211_vif_get_shift(&sdata->vif);
	rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
2148
	sband = local->hw.wiphy->bands[band];
2149 2150 2151 2152 2153 2154
	rates = 0;
	for (i = 0; i < sband->n_bitrates; i++) {
		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
			continue;
		rates++;
	}
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
	if (rates > 8)
		rates = 8;

	if (skb_tailroom(skb) < rates + 2)
		return -ENOMEM;

	pos = skb_put(skb, rates + 2);
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos++ = rates;
	for (i = 0; i < rates; i++) {
2165
		u8 basic = 0;
2166 2167 2168
		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
			continue;

2169 2170
		if (need_basic && basic_rates & BIT(i))
			basic = 0x80;
2171
		rate = sband->bitrates[i].bitrate;
2172 2173 2174
		rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
				    5 * (1 << shift));
		*pos++ = basic | (u8) rate;
2175 2176 2177 2178 2179
	}

	return 0;
}

2180
int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
2181 2182
				struct sk_buff *skb, bool need_basic,
				enum ieee80211_band band)
2183 2184 2185
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_supported_band *sband;
2186
	int rate, shift;
2187
	u8 i, exrates, *pos;
2188
	u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2189 2190 2191 2192
	u32 rate_flags;

	rate_flags = ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chandef);
	shift = ieee80211_vif_get_shift(&sdata->vif);
2193

2194
	sband = local->hw.wiphy->bands[band];
2195 2196 2197 2198 2199 2200 2201
	exrates = 0;
	for (i = 0; i < sband->n_bitrates; i++) {
		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
			continue;
		exrates++;
	}

2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214
	if (exrates > 8)
		exrates -= 8;
	else
		exrates = 0;

	if (skb_tailroom(skb) < exrates + 2)
		return -ENOMEM;

	if (exrates) {
		pos = skb_put(skb, exrates + 2);
		*pos++ = WLAN_EID_EXT_SUPP_RATES;
		*pos++ = exrates;
		for (i = 8; i < sband->n_bitrates; i++) {
2215
			u8 basic = 0;
2216 2217 2218
			if ((rate_flags & sband->bitrates[i].flags)
			    != rate_flags)
				continue;
2219 2220
			if (need_basic && basic_rates & BIT(i))
				basic = 0x80;
2221 2222 2223
			rate = DIV_ROUND_UP(sband->bitrates[i].bitrate,
					    5 * (1 << shift));
			*pos++ = basic | (u8) rate;
2224 2225 2226 2227
		}
	}
	return 0;
}
2228 2229 2230 2231 2232 2233

int ieee80211_ave_rssi(struct ieee80211_vif *vif)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

2234 2235 2236 2237
	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
		/* non-managed type inferfaces */
		return 0;
	}
2238
	return ifmgd->ave_beacon_signal / 16;
2239
}
2240
EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256

u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
{
	if (!mcs)
		return 1;

	/* TODO: consider rx_highest */

	if (mcs->rx_mask[3])
		return 4;
	if (mcs->rx_mask[2])
		return 3;
	if (mcs->rx_mask[1])
		return 2;
	return 1;
}
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290

/**
 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
 * @local: mac80211 hw info struct
 * @status: RX status
 * @mpdu_len: total MPDU length (including FCS)
 * @mpdu_offset: offset into MPDU to calculate timestamp at
 *
 * This function calculates the RX timestamp at the given MPDU offset, taking
 * into account what the RX timestamp was. An offset of 0 will just normalize
 * the timestamp to TSF at beginning of MPDU reception.
 */
u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
				     struct ieee80211_rx_status *status,
				     unsigned int mpdu_len,
				     unsigned int mpdu_offset)
{
	u64 ts = status->mactime;
	struct rate_info ri;
	u16 rate;

	if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
		return 0;

	memset(&ri, 0, sizeof(ri));

	/* Fill cfg80211 rate info */
	if (status->flag & RX_FLAG_HT) {
		ri.mcs = status->rate_idx;
		ri.flags |= RATE_INFO_FLAGS_MCS;
		if (status->flag & RX_FLAG_40MHZ)
			ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
		if (status->flag & RX_FLAG_SHORT_GI)
			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2291 2292 2293 2294 2295 2296
	} else if (status->flag & RX_FLAG_VHT) {
		ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
		ri.mcs = status->rate_idx;
		ri.nss = status->vht_nss;
		if (status->flag & RX_FLAG_40MHZ)
			ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
2297
		if (status->vht_flag & RX_VHT_FLAG_80MHZ)
2298
			ri.flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
2299
		if (status->vht_flag & RX_VHT_FLAG_80P80MHZ)
2300
			ri.flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
2301
		if (status->vht_flag & RX_VHT_FLAG_160MHZ)
2302 2303 2304
			ri.flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
		if (status->flag & RX_FLAG_SHORT_GI)
			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2305 2306
	} else {
		struct ieee80211_supported_band *sband;
2307 2308 2309 2310 2311 2312 2313
		int shift = 0;
		int bitrate;

		if (status->flag & RX_FLAG_10MHZ)
			shift = 1;
		if (status->flag & RX_FLAG_5MHZ)
			shift = 2;
2314 2315

		sband = local->hw.wiphy->bands[status->band];
2316 2317
		bitrate = sband->bitrates[status->rate_idx].bitrate;
		ri.legacy = DIV_ROUND_UP(bitrate, (1 << shift));
2318 2319 2320
	}

	rate = cfg80211_calculate_bitrate(&ri);
2321 2322 2323 2324
	if (WARN_ONCE(!rate,
		      "Invalid bitrate: flags=0x%x, idx=%d, vht_nss=%d\n",
		      status->flag, status->rate_idx, status->vht_nss))
		return 0;
2325 2326 2327 2328 2329 2330 2331 2332 2333

	/* rewind from end of MPDU */
	if (status->flag & RX_FLAG_MACTIME_END)
		ts -= mpdu_len * 8 * 10 / rate;

	ts += mpdu_offset * 8 * 10 / rate;

	return ts;
}
2334 2335 2336 2337

void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;
2338
	struct cfg80211_chan_def chandef;
2339

2340
	mutex_lock(&local->mtx);
2341 2342
	mutex_lock(&local->iflist_mtx);
	list_for_each_entry(sdata, &local->interfaces, list) {
2343 2344 2345 2346 2347
		/* it might be waiting for the local->mtx, but then
		 * by the time it gets it, sdata->wdev.cac_started
		 * will no longer be true
		 */
		cancel_delayed_work(&sdata->dfs_cac_timer_work);
2348 2349

		if (sdata->wdev.cac_started) {
2350
			chandef = sdata->vif.bss_conf.chandef;
2351 2352
			ieee80211_vif_release_channel(sdata);
			cfg80211_cac_event(sdata->dev,
2353
					   &chandef,
2354 2355 2356 2357 2358
					   NL80211_RADAR_CAC_ABORTED,
					   GFP_KERNEL);
		}
	}
	mutex_unlock(&local->iflist_mtx);
2359
	mutex_unlock(&local->mtx);
2360 2361 2362 2363 2364 2365
}

void ieee80211_dfs_radar_detected_work(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, radar_detected_work);
2366
	struct cfg80211_chan_def chandef = local->hw.conf.chandef;
2367 2368 2369 2370 2371 2372

	ieee80211_dfs_cac_cancel(local);

	if (local->use_chanctx)
		/* currently not handled */
		WARN_ON(1);
2373
	else
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
		cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
}

void ieee80211_radar_detected(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	trace_api_radar_detected(local);

	ieee80211_queue_work(hw, &local->radar_detected_work);
}
EXPORT_SYMBOL(ieee80211_radar_detected);
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445

u32 ieee80211_chandef_downgrade(struct cfg80211_chan_def *c)
{
	u32 ret;
	int tmp;

	switch (c->width) {
	case NL80211_CHAN_WIDTH_20:
		c->width = NL80211_CHAN_WIDTH_20_NOHT;
		ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
		break;
	case NL80211_CHAN_WIDTH_40:
		c->width = NL80211_CHAN_WIDTH_20;
		c->center_freq1 = c->chan->center_freq;
		ret = IEEE80211_STA_DISABLE_40MHZ |
		      IEEE80211_STA_DISABLE_VHT;
		break;
	case NL80211_CHAN_WIDTH_80:
		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
		/* n_P40 */
		tmp /= 2;
		/* freq_P40 */
		c->center_freq1 = c->center_freq1 - 20 + 40 * tmp;
		c->width = NL80211_CHAN_WIDTH_40;
		ret = IEEE80211_STA_DISABLE_VHT;
		break;
	case NL80211_CHAN_WIDTH_80P80:
		c->center_freq2 = 0;
		c->width = NL80211_CHAN_WIDTH_80;
		ret = IEEE80211_STA_DISABLE_80P80MHZ |
		      IEEE80211_STA_DISABLE_160MHZ;
		break;
	case NL80211_CHAN_WIDTH_160:
		/* n_P20 */
		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
		/* n_P80 */
		tmp /= 4;
		c->center_freq1 = c->center_freq1 - 40 + 80 * tmp;
		c->width = NL80211_CHAN_WIDTH_80;
		ret = IEEE80211_STA_DISABLE_80P80MHZ |
		      IEEE80211_STA_DISABLE_160MHZ;
		break;
	default:
	case NL80211_CHAN_WIDTH_20_NOHT:
		WARN_ON_ONCE(1);
		c->width = NL80211_CHAN_WIDTH_20_NOHT;
		ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
		break;
	case NL80211_CHAN_WIDTH_5:
	case NL80211_CHAN_WIDTH_10:
		WARN_ON_ONCE(1);
		/* keep c->width */
		ret = IEEE80211_STA_DISABLE_HT | IEEE80211_STA_DISABLE_VHT;
		break;
	}

	WARN_ON_ONCE(!cfg80211_chandef_valid(c));

	return ret;
}
2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470

/*
 * Returns true if smps_mode_new is strictly more restrictive than
 * smps_mode_old.
 */
bool ieee80211_smps_is_restrictive(enum ieee80211_smps_mode smps_mode_old,
				   enum ieee80211_smps_mode smps_mode_new)
{
	if (WARN_ON_ONCE(smps_mode_old == IEEE80211_SMPS_AUTOMATIC ||
			 smps_mode_new == IEEE80211_SMPS_AUTOMATIC))
		return false;

	switch (smps_mode_old) {
	case IEEE80211_SMPS_STATIC:
		return false;
	case IEEE80211_SMPS_DYNAMIC:
		return smps_mode_new == IEEE80211_SMPS_STATIC;
	case IEEE80211_SMPS_OFF:
		return smps_mode_new != IEEE80211_SMPS_OFF;
	default:
		WARN_ON(1);
	}

	return false;
}
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543

int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
			      struct cfg80211_csa_settings *csa_settings)
{
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
	struct ieee80211_local *local = sdata->local;
	int freq;
	int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.chan_switch) +
			       sizeof(mgmt->u.action.u.chan_switch);
	u8 *pos;

	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
	    sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
		return -EOPNOTSUPP;

	skb = dev_alloc_skb(local->tx_headroom + hdr_len +
			    5 + /* channel switch announcement element */
			    3 + /* secondary channel offset element */
			    8); /* mesh channel switch parameters element */
	if (!skb)
		return -ENOMEM;

	skb_reserve(skb, local->tx_headroom);
	mgmt = (struct ieee80211_mgmt *)skb_put(skb, hdr_len);
	memset(mgmt, 0, hdr_len);
	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
					  IEEE80211_STYPE_ACTION);

	eth_broadcast_addr(mgmt->da);
	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
		memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
	} else {
		struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
		memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
	}
	mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
	mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
	pos = skb_put(skb, 5);
	*pos++ = WLAN_EID_CHANNEL_SWITCH;			/* EID */
	*pos++ = 3;						/* IE length */
	*pos++ = csa_settings->block_tx ? 1 : 0;		/* CSA mode */
	freq = csa_settings->chandef.chan->center_freq;
	*pos++ = ieee80211_frequency_to_channel(freq);		/* channel */
	*pos++ = csa_settings->count;				/* count */

	if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
		enum nl80211_channel_type ch_type;

		skb_put(skb, 3);
		*pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;	/* EID */
		*pos++ = 1;					/* IE length */
		ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
		if (ch_type == NL80211_CHAN_HT40PLUS)
			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
		else
			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
	}

	if (ieee80211_vif_is_mesh(&sdata->vif)) {
		struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;

		skb_put(skb, 8);
		*pos++ = WLAN_EID_CHAN_SWITCH_PARAM;		/* EID */
		*pos++ = 6;					/* IE length */
		*pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL;	/* Mesh TTL */
		*pos = 0x00;	/* Mesh Flag: Tx Restrict, Initiator, Reason */
		*pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
		*pos++ |= csa_settings->block_tx ?
			  WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
		put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
		pos += 2;
2544
		put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
2545 2546 2547 2548 2549 2550
		pos += 2;
	}

	ieee80211_tx_skb(sdata, skb);
	return 0;
}
2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618

bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
{
	return !(cs == NULL || cs->cipher == 0 ||
		 cs->hdr_len < cs->pn_len + cs->pn_off ||
		 cs->hdr_len <= cs->key_idx_off ||
		 cs->key_idx_shift > 7 ||
		 cs->key_idx_mask == 0);
}

bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
{
	int i;

	/* Ensure we have enough iftype bitmap space for all iftype values */
	WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));

	for (i = 0; i < n; i++)
		if (!ieee80211_cs_valid(&cs[i]))
			return false;

	return true;
}

const struct ieee80211_cipher_scheme *
ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
		 enum nl80211_iftype iftype)
{
	const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
	int n = local->hw.n_cipher_schemes;
	int i;
	const struct ieee80211_cipher_scheme *cs = NULL;

	for (i = 0; i < n; i++) {
		if (l[i].cipher == cipher) {
			cs = &l[i];
			break;
		}
	}

	if (!cs || !(cs->iftype & BIT(iftype)))
		return NULL;

	return cs;
}

int ieee80211_cs_headroom(struct ieee80211_local *local,
			  struct cfg80211_crypto_settings *crypto,
			  enum nl80211_iftype iftype)
{
	const struct ieee80211_cipher_scheme *cs;
	int headroom = IEEE80211_ENCRYPT_HEADROOM;
	int i;

	for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
		cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
				      iftype);

		if (cs && headroom < cs->hdr_len)
			headroom = cs->hdr_len;
	}

	cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
	if (cs && headroom < cs->hdr_len)
		headroom = cs->hdr_len;

	return headroom;
}
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758

static bool
ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
{
	s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
	int skip;

	if (end > 0)
		return false;

	/* End time is in the past, check for repetitions */
	skip = DIV_ROUND_UP(-end, data->desc[i].interval);
	if (data->count[i] < 255) {
		if (data->count[i] <= skip) {
			data->count[i] = 0;
			return false;
		}

		data->count[i] -= skip;
	}

	data->desc[i].start += skip * data->desc[i].interval;

	return true;
}

static bool
ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
			     s32 *offset)
{
	bool ret = false;
	int i;

	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
		s32 cur;

		if (!data->count[i])
			continue;

		if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
			ret = true;

		cur = data->desc[i].start - tsf;
		if (cur > *offset)
			continue;

		cur = data->desc[i].start + data->desc[i].duration - tsf;
		if (cur > *offset)
			*offset = cur;
	}

	return ret;
}

static u32
ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
{
	s32 offset = 0;
	int tries = 0;
	/*
	 * arbitrary limit, used to avoid infinite loops when combined NoA
	 * descriptors cover the full time period.
	 */
	int max_tries = 5;

	ieee80211_extend_absent_time(data, tsf, &offset);
	do {
		if (!ieee80211_extend_absent_time(data, tsf, &offset))
			break;

		tries++;
	} while (tries < max_tries);

	return offset;
}

void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
{
	u32 next_offset = BIT(31) - 1;
	int i;

	data->absent = 0;
	data->has_next_tsf = false;
	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
		s32 start;

		if (!data->count[i])
			continue;

		ieee80211_extend_noa_desc(data, tsf, i);
		start = data->desc[i].start - tsf;
		if (start <= 0)
			data->absent |= BIT(i);

		if (next_offset > start)
			next_offset = start;

		data->has_next_tsf = true;
	}

	if (data->absent)
		next_offset = ieee80211_get_noa_absent_time(data, tsf);

	data->next_tsf = tsf + next_offset;
}
EXPORT_SYMBOL(ieee80211_update_p2p_noa);

int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
			    struct ieee80211_noa_data *data, u32 tsf)
{
	int ret = 0;
	int i;

	memset(data, 0, sizeof(*data));

	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
		const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];

		if (!desc->count || !desc->duration)
			continue;

		data->count[i] = desc->count;
		data->desc[i].start = le32_to_cpu(desc->start_time);
		data->desc[i].duration = le32_to_cpu(desc->duration);
		data->desc[i].interval = le32_to_cpu(desc->interval);

		if (data->count[i] > 1 &&
		    data->desc[i].interval < data->desc[i].duration)
			continue;

		ieee80211_extend_noa_desc(data, tsf, i);
		ret++;
	}

	if (ret)
		ieee80211_update_p2p_noa(data, tsf);

	return ret;
}
EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799

void ieee80211_recalc_dtim(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata)
{
	u64 tsf = drv_get_tsf(local, sdata);
	u64 dtim_count = 0;
	u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
	u8 dtim_period = sdata->vif.bss_conf.dtim_period;
	struct ps_data *ps;
	u8 bcns_from_dtim;

	if (tsf == -1ULL || !beacon_int || !dtim_period)
		return;

	if (sdata->vif.type == NL80211_IFTYPE_AP ||
	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		if (!sdata->bss)
			return;

		ps = &sdata->bss->ps;
	} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
		ps = &sdata->u.mesh.ps;
	} else {
		return;
	}

	/*
	 * actually finds last dtim_count, mac80211 will update in
	 * __beacon_add_tim().
	 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
	 */
	do_div(tsf, beacon_int);
	bcns_from_dtim = do_div(tsf, dtim_period);
	/* just had a DTIM */
	if (!bcns_from_dtim)
		dtim_count = 0;
	else
		dtim_count = dtim_period - bcns_from_dtim;

	ps->dtim_count = dtim_count;
}
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810

int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
				 const struct cfg80211_chan_def *chandef,
				 enum ieee80211_chanctx_mode chanmode,
				 u8 radar_detect)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *sdata_iter;
	enum nl80211_iftype iftype = sdata->wdev.iftype;
	int num[NUM_NL80211_IFTYPES];
	struct ieee80211_chanctx *ctx;
2811
	int num_different_channels = 0;
2812 2813 2814 2815 2816 2817 2818
	int total = 1;

	lockdep_assert_held(&local->chanctx_mtx);

	if (WARN_ON(hweight32(radar_detect) > 1))
		return -EINVAL;

2819 2820
	if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
		    !chandef->chan))
2821 2822
		return -EINVAL;

2823 2824 2825
	if (chandef)
		num_different_channels = 1;

2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847
	if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
		return -EINVAL;

	/* Always allow software iftypes */
	if (local->hw.wiphy->software_iftypes & BIT(iftype)) {
		if (radar_detect)
			return -EINVAL;
		return 0;
	}

	memset(num, 0, sizeof(num));

	if (iftype != NL80211_IFTYPE_UNSPECIFIED)
		num[iftype] = 1;

	list_for_each_entry(ctx, &local->chanctx_list, list) {
		if (ctx->conf.radar_enabled)
			radar_detect |= BIT(ctx->conf.def.width);
		if (ctx->mode == IEEE80211_CHANCTX_EXCLUSIVE) {
			num_different_channels++;
			continue;
		}
2848
		if (chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875
		    cfg80211_chandef_compatible(chandef,
						&ctx->conf.def))
			continue;
		num_different_channels++;
	}

	list_for_each_entry_rcu(sdata_iter, &local->interfaces, list) {
		struct wireless_dev *wdev_iter;

		wdev_iter = &sdata_iter->wdev;

		if (sdata_iter == sdata ||
		    rcu_access_pointer(sdata_iter->vif.chanctx_conf) == NULL ||
		    local->hw.wiphy->software_iftypes & BIT(wdev_iter->iftype))
			continue;

		num[wdev_iter->iftype]++;
		total++;
	}

	if (total == 1 && !radar_detect)
		return 0;

	return cfg80211_check_combinations(local->hw.wiphy,
					   num_different_channels,
					   radar_detect, num);
}