util.c 82.6 KB
Newer Older
Johannes Berg's avatar
Johannes Berg committed
1
2
3
4
5
/*
 * 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>
6
 * Copyright 2013-2014  Intel Mobile Communications GmbH
Johannes Berg's avatar
Johannes Berg committed
7
8
9
10
11
12
13
14
15
16
 *
 * 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>
17
#include <linux/export.h>
Johannes Berg's avatar
Johannes Berg committed
18
19
20
21
22
23
#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>
24
#include <linux/crc32.h>
25
#include <net/net_namespace.h>
Johannes Berg's avatar
Johannes Berg committed
26
#include <net/cfg80211.h>
27
#include <net/rtnetlink.h>
Johannes Berg's avatar
Johannes Berg committed
28
29

#include "ieee80211_i.h"
30
#include "driver-ops.h"
Johannes Berg's avatar
Johannes Berg committed
31
#include "rate.h"
32
#include "mesh.h"
Johannes Berg's avatar
Johannes Berg committed
33
#include "wme.h"
34
#include "led.h"
Johannes Berg's avatar
Johannes Berg committed
35
#include "wep.h"
Johannes Berg's avatar
Johannes Berg committed
36
37

/* privid for wiphys to determine whether they belong to us or not */
38
const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
Johannes Berg's avatar
Johannes Berg committed
39

40
41
42
43
44
45
46
47
48
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);
Johannes Berg's avatar
Johannes Berg committed
49

50
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
51
			enum nl80211_iftype type)
Johannes Berg's avatar
Johannes Berg committed
52
{
53
	__le16 fc = hdr->frame_control;
Johannes Berg's avatar
Johannes Berg committed
54

55
56
	 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
	if (len < 16)
Johannes Berg's avatar
Johannes Berg committed
57
58
		return NULL;

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

		if (ieee80211_has_a4(fc))
Johannes Berg's avatar
Johannes Berg committed
64
			return NULL;
65
66
67
		if (ieee80211_has_tods(fc))
			return hdr->addr1;
		if (ieee80211_has_fromds(fc))
Johannes Berg's avatar
Johannes Berg committed
68
			return hdr->addr2;
69
70
71
72
73

		return hdr->addr3;
	}

	if (ieee80211_is_mgmt(fc)) {
74
75
		if (len < 24) /* drop incorrect hdr len (mgmt) */
			return NULL;
Johannes Berg's avatar
Johannes Berg committed
76
		return hdr->addr3;
77
78
79
	}

	if (ieee80211_is_ctl(fc)) {
Weilong Chen's avatar
Weilong Chen committed
80
		if (ieee80211_is_pspoll(fc))
Johannes Berg's avatar
Johannes Berg committed
81
			return hdr->addr1;
82
83

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

	return NULL;
}

99
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
Johannes Berg's avatar
Johannes Berg committed
100
{
101
	struct sk_buff *skb;
102
103
	struct ieee80211_hdr *hdr;

104
	skb_queue_walk(&tx->skbs, skb) {
105
106
		hdr = (struct ieee80211_hdr *) skb->data;
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
107
	}
Johannes Berg's avatar
Johannes Berg committed
108
109
}

110
int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
111
112
			     int rate, int erp, int short_preamble,
			     int shift)
Johannes Berg's avatar
Johannes Berg committed
113
114
115
116
117
118
119
120
121
122
{
	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.
123
124
125
	 *
	 * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
	 * is assumed to be 0 otherwise.
Johannes Berg's avatar
Johannes Berg committed
126
127
	 */

128
	if (band == IEEE80211_BAND_5GHZ || erp) {
Johannes Berg's avatar
Johannes Berg committed
129
130
131
132
133
134
135
136
137
		/*
		 * 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
138
		 * 802.11a - 18.5.2: aSIFSTime = 16 usec
Johannes Berg's avatar
Johannes Berg committed
139
140
141
142
		 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
		 *	signal ext = 6 usec
		 */
		dur = 16; /* SIFS + signal ext */
143
144
145
146
147
148
149
150
		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;
151
152
153
154
155
156

		/* 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 */
Johannes Berg's avatar
Johannes Berg committed
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
	} 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 */
178
179
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
180
					enum ieee80211_band band,
181
182
					size_t frame_len,
					struct ieee80211_rate *rate)
Johannes Berg's avatar
Johannes Berg committed
183
{
184
	struct ieee80211_sub_if_data *sdata;
Johannes Berg's avatar
Johannes Berg committed
185
	u16 dur;
186
	int erp, shift = 0;
187
	bool short_preamble = false;
Johannes Berg's avatar
Johannes Berg committed
188

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

198
	dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
199
				       short_preamble, shift);
Johannes Berg's avatar
Johannes Berg committed
200
201
202
203
204

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

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

217
	sband = local->hw.wiphy->bands[frame_txctl->band];
Johannes Berg's avatar
Johannes Berg committed
218

219
	short_preamble = false;
220

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

	erp = 0;
224
225
	if (vif) {
		sdata = vif_to_sdata(vif);
226
		short_preamble = sdata->vif.bss_conf.use_short_preamble;
227
228
		if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
			erp = rate->flags & IEEE80211_RATE_ERP_G;
229
		shift = ieee80211_vif_get_shift(vif);
230
	}
Johannes Berg's avatar
Johannes Berg committed
231

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

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

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

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

261
	sband = local->hw.wiphy->bands[frame_txctl->band];
Johannes Berg's avatar
Johannes Berg committed
262

263
	short_preamble = false;
264

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

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

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

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

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

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

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

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

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

308
		for (ac = 0; ac < n_acs; ac++) {
309
310
311
312
313
314
315
316
317
318
319
			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);
		}
	}
}

320
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
321
322
				   enum queue_stop_reason reason,
				   bool refcounted)
Johannes Berg's avatar
Johannes Berg committed
323
324
325
{
	struct ieee80211_local *local = hw_to_local(hw);

Johannes Berg's avatar
Johannes Berg committed
326
327
	trace_wake_queue(local, queue, reason);

328
329
	if (WARN_ON(queue >= hw->queues))
		return;
330

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

334
335
336
337
338
339
340
	if (!refcounted)
		local->q_stop_reasons[queue][reason] = 0;
	else
		local->q_stop_reasons[queue][reason]--;

	if (local->q_stop_reasons[queue][reason] == 0)
		__clear_bit(reason, &local->queue_stop_reasons[queue]);
341
342
343
344
345

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

346
347
	if (skb_queue_empty(&local->pending[queue])) {
		rcu_read_lock();
348
		ieee80211_propagate_queue_wake(local, queue);
349
350
		rcu_read_unlock();
	} else
Johannes Berg's avatar
Johannes Berg committed
351
		tasklet_schedule(&local->tx_pending_tasklet);
Johannes Berg's avatar
Johannes Berg committed
352
}
353

354
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
355
356
				    enum queue_stop_reason reason,
				    bool refcounted)
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);
362
	__ieee80211_wake_queue(hw, queue, reason, refcounted);
363
364
365
366
367
368
	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,
369
370
				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
				       false);
371
}
Johannes Berg's avatar
Johannes Berg committed
372
373
EXPORT_SYMBOL(ieee80211_wake_queue);

374
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
375
376
				   enum queue_stop_reason reason,
				   bool refcounted)
Johannes Berg's avatar
Johannes Berg committed
377
378
{
	struct ieee80211_local *local = hw_to_local(hw);
379
	struct ieee80211_sub_if_data *sdata;
380
	int n_acs = IEEE80211_NUM_ACS;
Johannes Berg's avatar
Johannes Berg committed
381

Johannes Berg's avatar
Johannes Berg committed
382
383
	trace_stop_queue(local, queue, reason);

384
385
	if (WARN_ON(queue >= hw->queues))
		return;
386

387
388
389
390
	if (!refcounted)
		local->q_stop_reasons[queue][reason] = 1;
	else
		local->q_stop_reasons[queue][reason]++;
391

392
393
	if (__test_and_set_bit(reason, &local->queue_stop_reasons[queue]))
		return;
394

395
396
397
	if (local->hw.queues < IEEE80211_NUM_ACS)
		n_acs = 1;

398
	rcu_read_lock();
399
400
401
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
		int ac;

402
403
404
		if (!sdata->dev)
			continue;

405
		for (ac = 0; ac < n_acs; ac++) {
406
407
408
409
410
			if (sdata->vif.hw_queue[ac] == queue ||
			    sdata->vif.cab_queue == queue)
				netif_stop_subqueue(sdata->dev, ac);
		}
	}
411
	rcu_read_unlock();
Johannes Berg's avatar
Johannes Berg committed
412
}
413

414
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
415
416
				    enum queue_stop_reason reason,
				    bool refcounted)
417
418
419
420
421
{
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
422
	__ieee80211_stop_queue(hw, queue, reason, refcounted);
423
424
425
426
427
428
	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,
429
430
				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
				       false);
431
}
Johannes Berg's avatar
Johannes Berg committed
432
433
EXPORT_SYMBOL(ieee80211_stop_queue);

434
435
436
437
438
void ieee80211_add_pending_skb(struct ieee80211_local *local,
			       struct sk_buff *skb)
{
	struct ieee80211_hw *hw = &local->hw;
	unsigned long flags;
439
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
440
	int queue = info->hw_queue;
441
442

	if (WARN_ON(!info->control.vif)) {
443
		ieee80211_free_txskb(&local->hw, skb);
444
445
		return;
	}
446
447

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
448
449
	__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
			       false);
Johannes Berg's avatar
Johannes Berg committed
450
	__skb_queue_tail(&local->pending[queue], skb);
451
452
	__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
			       false);
453
454
455
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

456
457
void ieee80211_add_pending_skbs(struct ieee80211_local *local,
				struct sk_buff_head *skbs)
458
459
460
461
{
	struct ieee80211_hw *hw = &local->hw;
	struct sk_buff *skb;
	unsigned long flags;
462
	int queue, i;
463
464
465

	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
	while ((skb = skb_dequeue(skbs))) {
466
467
468
		struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

		if (WARN_ON(!info->control.vif)) {
469
			ieee80211_free_txskb(&local->hw, skb);
470
471
472
			continue;
		}

473
		queue = info->hw_queue;
474
475

		__ieee80211_stop_queue(hw, queue,
476
477
				IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
				false);
478

Johannes Berg's avatar
Johannes Berg committed
479
		__skb_queue_tail(&local->pending[queue], skb);
480
481
	}

Johannes Berg's avatar
Johannes Berg committed
482
	for (i = 0; i < hw->queues; i++)
483
		__ieee80211_wake_queue(hw, i,
484
485
			IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
			false);
486
487
488
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
}

489
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
490
				     unsigned long queues,
491
492
				     enum queue_stop_reason reason,
				     bool refcounted)
Johannes Berg's avatar
Johannes Berg committed
493
{
494
495
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;
Johannes Berg's avatar
Johannes Berg committed
496
497
	int i;

498
499
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

500
	for_each_set_bit(i, &queues, hw->queues)
501
		__ieee80211_stop_queue(hw, i, reason, refcounted);
502
503
504
505
506
507

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

void ieee80211_stop_queues(struct ieee80211_hw *hw)
{
508
	ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
509
510
					IEEE80211_QUEUE_STOP_REASON_DRIVER,
					false);
Johannes Berg's avatar
Johannes Berg committed
511
512
513
}
EXPORT_SYMBOL(ieee80211_stop_queues);

514
515
516
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
{
	struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg's avatar
Johannes Berg committed
517
518
	unsigned long flags;
	int ret;
519

520
521
	if (WARN_ON(queue >= hw->queues))
		return true;
522

Johannes Berg's avatar
Johannes Berg committed
523
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
524
525
	ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
		       &local->queue_stop_reasons[queue]);
Johannes Berg's avatar
Johannes Berg committed
526
527
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
	return ret;
528
529
530
}
EXPORT_SYMBOL(ieee80211_queue_stopped);

531
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
532
				     unsigned long queues,
533
534
				     enum queue_stop_reason reason,
				     bool refcounted)
Johannes Berg's avatar
Johannes Berg committed
535
{
536
537
	struct ieee80211_local *local = hw_to_local(hw);
	unsigned long flags;
Johannes Berg's avatar
Johannes Berg committed
538
539
	int i;

540
541
	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

542
	for_each_set_bit(i, &queues, hw->queues)
543
		__ieee80211_wake_queue(hw, i, reason, refcounted);
544
545
546
547
548
549

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

void ieee80211_wake_queues(struct ieee80211_hw *hw)
{
550
	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
551
552
					IEEE80211_QUEUE_STOP_REASON_DRIVER,
					false);
Johannes Berg's avatar
Johannes Berg committed
553
554
}
EXPORT_SYMBOL(ieee80211_wake_queues);
555

556
557
558
static unsigned int
ieee80211_get_vif_queues(struct ieee80211_local *local,
			 struct ieee80211_sub_if_data *sdata)
559
{
560
	unsigned int queues;
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575

	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;
	}

576
577
578
	return queues;
}

579
580
void __ieee80211_flush_queues(struct ieee80211_local *local,
			      struct ieee80211_sub_if_data *sdata,
581
			      unsigned int queues, bool drop)
582
583
584
585
{
	if (!local->ops->flush)
		return;

586
587
588
589
590
591
	/*
	 * If no queue was set, or if the HW doesn't support
	 * IEEE80211_HW_QUEUE_CONTROL - flush all queues
	 */
	if (!queues || !(local->hw.flags & IEEE80211_HW_QUEUE_CONTROL))
		queues = ieee80211_get_vif_queues(local, sdata);
592

593
	ieee80211_stop_queues_by_reason(&local->hw, queues,
594
595
					IEEE80211_QUEUE_STOP_REASON_FLUSH,
					false);
596

597
	drv_flush(local, sdata, queues, drop);
598

599
	ieee80211_wake_queues_by_reason(&local->hw, queues,
600
601
					IEEE80211_QUEUE_STOP_REASON_FLUSH,
					false);
602
603
}

604
void ieee80211_flush_queues(struct ieee80211_local *local,
605
			    struct ieee80211_sub_if_data *sdata, bool drop)
606
{
607
	__ieee80211_flush_queues(local, sdata, 0, drop);
608
609
}

610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
void ieee80211_stop_vif_queues(struct ieee80211_local *local,
			       struct ieee80211_sub_if_data *sdata,
			       enum queue_stop_reason reason)
{
	ieee80211_stop_queues_by_reason(&local->hw,
					ieee80211_get_vif_queues(local, sdata),
					reason, true);
}

void ieee80211_wake_vif_queues(struct ieee80211_local *local,
			       struct ieee80211_sub_if_data *sdata,
			       enum queue_stop_reason reason)
{
	ieee80211_wake_queues_by_reason(&local->hw,
					ieee80211_get_vif_queues(local, sdata),
					reason, true);
}

628
629
630
631
632
static void __iterate_active_interfaces(struct ieee80211_local *local,
					u32 iter_flags,
					void (*iterator)(void *data, u8 *mac,
						struct ieee80211_vif *vif),
					void *data)
633
634
635
{
	struct ieee80211_sub_if_data *sdata;

636
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
637
		switch (sdata->vif.type) {
638
		case NL80211_IFTYPE_MONITOR:
639
640
641
			if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
				continue;
			break;
642
		case NL80211_IFTYPE_AP_VLAN:
643
			continue;
644
		default:
645
646
			break;
		}
647
648
649
		if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
		    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
			continue;
650
		if (ieee80211_sdata_running(sdata))
651
			iterator(data, sdata->vif.addr,
652
653
654
				 &sdata->vif);
	}

655
656
657
	sdata = rcu_dereference_check(local->monitor_sdata,
				      lockdep_is_held(&local->iflist_mtx) ||
				      lockdep_rtnl_is_held());
658
659
660
	if (sdata &&
	    (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
	     sdata->flags & IEEE80211_SDATA_IN_DRIVER))
661
		iterator(data, sdata->vif.addr, &sdata->vif);
662
}
663

664
665
666
667
668
669
670
671
672
673
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);
674
	mutex_unlock(&local->iflist_mtx);
675
676
677
678
}
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);

void ieee80211_iterate_active_interfaces_atomic(
679
	struct ieee80211_hw *hw, u32 iter_flags,
680
681
682
683
684
685
	void (*iterator)(void *data, u8 *mac,
			 struct ieee80211_vif *vif),
	void *data)
{
	struct ieee80211_local *local = hw_to_local(hw);

686
	rcu_read_lock();
687
688
689
690
	__iterate_active_interfaces(local, iter_flags, iterator, data);
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
691

692
693
694
695
696
697
698
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);
699

700
	ASSERT_RTNL();
701

702
	__iterate_active_interfaces(local, iter_flags, iterator, data);
703
}
704
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_rtnl);
705

706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
static void __iterate_stations(struct ieee80211_local *local,
			       void (*iterator)(void *data,
						struct ieee80211_sta *sta),
			       void *data)
{
	struct sta_info *sta;

	list_for_each_entry_rcu(sta, &local->sta_list, list) {
		if (!sta->uploaded)
			continue;

		iterator(data, &sta->sta);
	}
}

void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
			void (*iterator)(void *data,
					 struct ieee80211_sta *sta),
			void *data)
{
	struct ieee80211_local *local = hw_to_local(hw);

	rcu_read_lock();
	__iterate_stations(local, iterator, data);
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);

734
735
736
737
738
739
740
741
742
743
744
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);

745
746
747
748
749
750
751
752
753
/*
 * 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)
{
Johannes Berg's avatar
Johannes Berg committed
754
755
756
	if (WARN(local->suspended && !local->resuming,
		 "queueing ieee80211 work while going to suspend\n"))
		return false;
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784

	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);

785
u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
786
787
788
789
			       struct ieee802_11_elems *elems,
			       u64 filter, u32 crc)
{
	size_t left = len;
790
	const u8 *pos = start;
791
	bool calc_crc = filter != 0;
792
	DECLARE_BITMAP(seen_elems, 256);
793
	const u8 *ie;
794

795
	bitmap_zero(seen_elems, 256);
796
797
798
799
800
801
	memset(elems, 0, sizeof(*elems));
	elems->ie_start = start;
	elems->total_len = len;

	while (left >= 2) {
		u8 id, elen;
802
		bool elem_parse_failed;
803
804
805
806
807

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

808
809
		if (elen > left) {
			elems->parse_error = true;
810
			break;
811
812
		}

813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
		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:
841
		case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
842
		case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
843
		case WLAN_EID_CHAN_SWITCH_PARAM:
844
		case WLAN_EID_EXT_CAPABILITY:
845
846
		case WLAN_EID_CHAN_SWITCH_TIMING:
		case WLAN_EID_LINK_ID:
847
848
849
850
		/*
		 * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
		 * that if the content gets bigger it might be needed more than once
		 */
851
852
853
854
855
856
857
			if (test_bit(id, seen_elems)) {
				elems->parse_error = true;
				left -= elen;
				pos += elen;
				continue;
			}
			break;
858
		}
859
860
861
862

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

863
864
		elem_parse_failed = false;

865
		switch (id) {
866
867
868
869
870
871
872
873
874
875
876
877
878
879
		case WLAN_EID_LINK_ID:
			if (elen + 2 != sizeof(struct ieee80211_tdls_lnkie)) {
				elem_parse_failed = true;
				break;
			}
			elems->lnk_id = (void *)(pos - 2);
			break;
		case WLAN_EID_CHAN_SWITCH_TIMING:
			if (elen != sizeof(struct ieee80211_ch_switch_timing)) {
				elem_parse_failed = true;
				break;
			}
			elems->ch_sw_timing = (void *)pos;
			break;
880
881
882
883
		case WLAN_EID_EXT_CAPABILITY:
			elems->ext_capab = pos;
			elems->ext_capab_len = elen;
			break;
884
885
886
887
888
889
890
891
892
		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:
893
894
895
896
			if (elen >= 1)
				elems->ds_params = pos;
			else
				elem_parse_failed = true;
897
898
899
900
901
			break;
		case WLAN_EID_TIM:
			if (elen >= sizeof(struct ieee80211_tim_ie)) {
				elems->tim = (void *)pos;
				elems->tim_len = elen;
902
903
			} else
				elem_parse_failed = true;
904
905
906
907
908
909
910
911
912
913
914
915
916
			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);

917
				if (elen >= 5 && pos[3] == 2) {
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
					/* 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:
934
935
936
937
			if (elen >= 1)
				elems->erp_info = pos;
			else
				elem_parse_failed = true;
938
939
940
941
942
943
944
945
			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;
946
947
			else
				elem_parse_failed = true;
948
			break;
949
950
951
		case WLAN_EID_HT_OPERATION:
			if (elen >= sizeof(struct ieee80211_ht_operation))
				elems->ht_operation = (void *)pos;
952
953
			else
				elem_parse_failed = true;
954
			break;
Mahesh Palivela's avatar
Mahesh Palivela committed
955
956
957
958
959
960
961
962
963
964
965
966
		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;
967
968
969
970
971
972
		case WLAN_EID_OPMODE_NOTIF:
			if (elen > 0)
				elems->opmode_notif = pos;
			else
				elem_parse_failed = true;
			break;
973
974
975
976
977
978
979
		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;
980
981
			else
				elem_parse_failed = true;
982
983
984
985
986
			break;
		case WLAN_EID_PEER_MGMT:
			elems->peering = pos;
			elems->peering_len = elen;
			break;
987
988
989
990
		case WLAN_EID_MESH_AWAKE_WINDOW:
			if (elen >= 2)
				elems->awake_window = (void *)pos;
			break;
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
		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;
1006
1007
			else
				elem_parse_failed = true;
1008
1009
			break;
		case WLAN_EID_CHANNEL_SWITCH:
1010
1011
1012
1013
1014
			if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
				elem_parse_failed = true;
				break;
			}
			elems->ch_switch_ie = (void *)pos;
1015
			break;
1016
1017
1018
1019
1020
1021
1022
		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;
1023
1024
1025
1026
1027
1028
1029
		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;
1030
1031
1032
1033
1034
1035
1036
1037
		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;
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
		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;
1066
1067
1068
1069
1070
		case WLAN_EID_COUNTRY:
			elems->country_elem = pos;
			elems->country_elem_len = elen;
			break;
		case WLAN_EID_PWR_CONSTRAINT:
1071
1072
1073
1074
			if (elen != 1) {
				elem_parse_failed = true;
				break;
			}
1075
1076
			elems->pwr_constr_elem = pos;
			break;
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
		case WLAN_EID_CISCO_VENDOR_SPECIFIC:
			/* Lots of different options exist, but we only care
			 * about the Dynamic Transmit Power Control element.
			 * First check for the Cisco OUI, then for the DTPC
			 * tag (0x00).
			 */
			if (elen < 4) {
				elem_parse_failed = true;
				break;
			}

			if (pos[0] != 0x00 || pos[1] != 0x40 ||
			    pos[2] != 0x96 || pos[3] != 0x00)
				break;

			if (elen != 6) {
				elem_parse_failed = true;
				break;
			}

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

			elems->cisco_dtpc_elem = pos;
			break;
1102
		case WLAN_EID_TIMEOUT_INTERVAL:
1103
1104
1105
1106
			if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
				elems->timeout_int = (void *)pos;
			else
				elem_parse_failed = true;
1107
1108
1109
1110
1111
			break;
		default:
			break;
		}

1112
1113
1114
		if (elem_parse_failed)
			elems->parse_error = true;
		else
1115
			__set_bit(id, seen_elems);
1116

1117
1118
1119
1120
		left -= elen;
		pos += elen;
	}

1121
1122
1123
	if (left != 0)
		elems->parse_error = true;

1124
1125
1126
	return crc;
}

1127
1128
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
			       bool bss_notify)
1129
1130
1131
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_tx_queue_params qparam;
Johannes Berg's avatar
Johannes Berg committed
1132
	struct ieee80211_chanctx_conf *chanctx_conf;
1133
	int ac;
1134
	bool use_11b, enable_qos;
1135
	bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */
1136
	int aCWmin, aCWmax;
1137