tx.c 108 KB
Newer Older
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
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 *
 * 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.
 *
 *
 * Transmit and frame generation functions.
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <linux/bitmap.h>
21
#include <linux/rcupdate.h>
22
#include <linux/export.h>
23
#include <net/net_namespace.h>
24
25
26
27
28
29
#include <net/ieee80211_radiotap.h>
#include <net/cfg80211.h>
#include <net/mac80211.h>
#include <asm/unaligned.h>

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

/* misc utils */

40
41
42
43
44
45
46
47
48
49
static inline void ieee80211_tx_stats(struct net_device *dev, u32 len)
{
	struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);

	u64_stats_update_begin(&tstats->syncp);
	tstats->tx_packets++;
	tstats->tx_bytes += len;
	u64_stats_update_end(&tstats->syncp);
}

50
51
static __le16 ieee80211_duration(struct ieee80211_tx_data *tx,
				 struct sk_buff *skb, int group_addr,
Johannes Berg's avatar
Johannes Berg committed
52
				 int next_frag_len)
53
{
54
	int rate, mrate, erp, dur, i, shift = 0;
55
	struct ieee80211_rate *txrate;
56
	struct ieee80211_local *local = tx->local;
57
	struct ieee80211_supported_band *sband;
58
	struct ieee80211_hdr *hdr;
59
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
60
61
62
63
64
65
66
67
68
69
	struct ieee80211_chanctx_conf *chanctx_conf;
	u32 rate_flags = 0;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(tx->sdata->vif.chanctx_conf);
	if (chanctx_conf) {
		shift = ieee80211_chandef_get_shift(&chanctx_conf->def);
		rate_flags = ieee80211_chandef_rate_flags(&chanctx_conf->def);
	}
	rcu_read_unlock();
70
71

	/* assume HW handles this */
72
	if (tx->rate.flags & (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS))
73
74
75
		return 0;

	/* uh huh? */
76
	if (WARN_ON_ONCE(tx->rate.idx < 0))
77
		return 0;
78

79
	sband = local->hw.wiphy->bands[info->band];
80
	txrate = &sband->bitrates[tx->rate.idx];
81

82
	erp = txrate->flags & IEEE80211_RATE_ERP_G;
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

	/*
	 * data and mgmt (except PS Poll):
	 * - during CFP: 32768
	 * - during contention period:
	 *   if addr1 is group address: 0
	 *   if more fragments = 0 and addr1 is individual address: time to
	 *      transmit one ACK plus SIFS
	 *   if more fragments = 1 and addr1 is individual address: time to
	 *      transmit next fragment plus 2 x ACK plus 3 x SIFS
	 *
	 * IEEE 802.11, 9.6:
	 * - control response frame (CTS or ACK) shall be transmitted using the
	 *   same rate as the immediately previous frame in the frame exchange
	 *   sequence, if this rate belongs to the PHY mandatory rates, or else
	 *   at the highest possible rate belonging to the PHY rates in the
	 *   BSSBasicRateSet
	 */
101
	hdr = (struct ieee80211_hdr *)skb->data;
102
	if (ieee80211_is_ctl(hdr->frame_control)) {
103
		/* TODO: These control frames are not currently sent by
104
		 * mac80211, but should they be implemented, this function
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
		 * needs to be updated to support duration field calculation.
		 *
		 * RTS: time needed to transmit pending data/mgmt frame plus
		 *    one CTS frame plus one ACK frame plus 3 x SIFS
		 * CTS: duration of immediately previous RTS minus time
		 *    required to transmit CTS and its SIFS
		 * ACK: 0 if immediately previous directed data/mgmt had
		 *    more=0, with more=1 duration in ACK frame is duration
		 *    from previous frame minus time needed to transmit ACK
		 *    and its SIFS
		 * PS Poll: BIT(15) | BIT(14) | aid
		 */
		return 0;
	}

	/* data/mgmt */
	if (0 /* FIX: data/mgmt during CFP */)
Johannes Berg's avatar
Johannes Berg committed
122
		return cpu_to_le16(32768);
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

	if (group_addr) /* Group address as the destination - no ACK */
		return 0;

	/* Individual destination address:
	 * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
	 * CTS and ACK frames shall be transmitted using the highest rate in
	 * basic rate set that is less than or equal to the rate of the
	 * immediately previous frame and that is using the same modulation
	 * (CCK or OFDM). If no basic rate set matches with these requirements,
	 * the highest mandatory rate of the PHY that is less than or equal to
	 * the rate of the previous frame is used.
	 * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
	 */
	rate = -1;
138
139
140
141
	/* use lowest available if everything fails */
	mrate = sband->bitrates[0].bitrate;
	for (i = 0; i < sband->n_bitrates; i++) {
		struct ieee80211_rate *r = &sband->bitrates[i];
142

143
144
		if (r->bitrate > txrate->bitrate)
			break;
145

146
147
148
		if ((rate_flags & r->flags) != rate_flags)
			continue;

149
		if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
150
			rate = DIV_ROUND_UP(r->bitrate, 1 << shift);
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

		switch (sband->band) {
		case IEEE80211_BAND_2GHZ: {
			u32 flag;
			if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
				flag = IEEE80211_RATE_MANDATORY_G;
			else
				flag = IEEE80211_RATE_MANDATORY_B;
			if (r->flags & flag)
				mrate = r->bitrate;
			break;
		}
		case IEEE80211_BAND_5GHZ:
			if (r->flags & IEEE80211_RATE_MANDATORY_A)
				mrate = r->bitrate;
			break;
167
168
		case IEEE80211_BAND_60GHZ:
			/* TODO, for now fall through */
169
170
171
172
		case IEEE80211_NUM_BANDS:
			WARN_ON(1);
			break;
		}
173
174
175
176
	}
	if (rate == -1) {
		/* No matching basic rate found; use highest suitable mandatory
		 * PHY rate */
177
		rate = DIV_ROUND_UP(mrate, 1 << shift);
178
179
	}

180
181
	/* Don't calculate ACKs for QoS Frames with NoAck Policy set */
	if (ieee80211_is_data_qos(hdr->frame_control) &&
182
	    *(ieee80211_get_qos_ctl(hdr)) & IEEE80211_QOS_CTL_ACK_POLICY_NOACK)
183
184
185
186
187
		dur = 0;
	else
		/* Time needed to transmit ACK
		 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
		 * to closest integer */
188
		dur = ieee80211_frame_duration(sband->band, 10, rate, erp,
189
190
				tx->sdata->vif.bss_conf.use_short_preamble,
				shift);
191
192
193
194
195
196

	if (next_frag_len) {
		/* Frame is fragmented: duration increases with time needed to
		 * transmit next fragment plus ACK and 2 x SIFS. */
		dur *= 2; /* ACK + SIFS */
		/* next fragment */
197
		dur += ieee80211_frame_duration(sband->band, next_frag_len,
198
				txrate->bitrate, erp,
199
200
				tx->sdata->vif.bss_conf.use_short_preamble,
				shift);
201
202
	}

Johannes Berg's avatar
Johannes Berg committed
203
	return cpu_to_le16(dur);
204
205
206
}

/* tx handlers */
207
208
209
210
static ieee80211_tx_result debug_noinline
ieee80211_tx_h_dynamic_ps(struct ieee80211_tx_data *tx)
{
	struct ieee80211_local *local = tx->local;
211
	struct ieee80211_if_managed *ifmgd;
212
213

	/* driver doesn't support power save */
214
	if (!ieee80211_hw_check(&local->hw, SUPPORTS_PS))
215
216
217
		return TX_CONTINUE;

	/* hardware does dynamic power save */
218
	if (ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
		return TX_CONTINUE;

	/* dynamic power save disabled */
	if (local->hw.conf.dynamic_ps_timeout <= 0)
		return TX_CONTINUE;

	/* we are scanning, don't enable power save */
	if (local->scanning)
		return TX_CONTINUE;

	if (!local->ps_sdata)
		return TX_CONTINUE;

	/* No point if we're going to suspend */
	if (local->quiescing)
		return TX_CONTINUE;

236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
	/* dynamic ps is supported only in managed mode */
	if (tx->sdata->vif.type != NL80211_IFTYPE_STATION)
		return TX_CONTINUE;

	ifmgd = &tx->sdata->u.mgd;

	/*
	 * Don't wakeup from power save if u-apsd is enabled, voip ac has
	 * u-apsd enabled and the frame is in voip class. This effectively
	 * means that even if all access categories have u-apsd enabled, in
	 * practise u-apsd is only used with the voip ac. This is a
	 * workaround for the case when received voip class packets do not
	 * have correct qos tag for some reason, due the network or the
	 * peer application.
	 *
251
	 * Note: ifmgd->uapsd_queues access is racy here. If the value is
252
253
254
	 * changed via debugfs, user needs to reassociate manually to have
	 * everything in sync.
	 */
255
256
257
	if ((ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) &&
	    (ifmgd->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) &&
	    skb_get_queue_mapping(tx->skb) == IEEE80211_AC_VO)
258
259
		return TX_CONTINUE;

260
261
	if (local->hw.conf.flags & IEEE80211_CONF_PS) {
		ieee80211_stop_queues_by_reason(&local->hw,
262
						IEEE80211_MAX_QUEUE_MAP,
263
264
						IEEE80211_QUEUE_STOP_REASON_PS,
						false);
265
		ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
266
267
268
269
		ieee80211_queue_work(&local->hw,
				     &local->dynamic_ps_disable_work);
	}

270
271
272
273
	/* Don't restart the timer if we're not disassociated */
	if (!ifmgd->associated)
		return TX_CONTINUE;

274
275
276
277
278
	mod_timer(&local->dynamic_ps_timer, jiffies +
		  msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));

	return TX_CONTINUE;
}
279

280
static ieee80211_tx_result debug_noinline
281
ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
282
{
283

284
285
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
286
	bool assoc = false;
287

288
	if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
289
		return TX_CONTINUE;
290

291
292
	if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) &&
	    test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) &&
293
294
295
296
297
298
299
300
301
302
303
304
305
	    !ieee80211_is_probe_req(hdr->frame_control) &&
	    !ieee80211_is_nullfunc(hdr->frame_control))
		/*
		 * When software scanning only nullfunc frames (to notify
		 * the sleep state to the AP) and probe requests (for the
		 * active scan) are allowed, all other frames should not be
		 * sent and we should not get here, but if we do
		 * nonetheless, drop them to avoid sending them
		 * off-channel. See the link below and
		 * ieee80211_start_scan() for more.
		 *
		 * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089
		 */
306
		return TX_DROP;
307

308
309
310
	if (tx->sdata->vif.type == NL80211_IFTYPE_OCB)
		return TX_CONTINUE;

Bill Jordan's avatar
Bill Jordan committed
311
312
313
	if (tx->sdata->vif.type == NL80211_IFTYPE_WDS)
		return TX_CONTINUE;

314
	if (tx->flags & IEEE80211_TX_PS_BUFFERED)
315
		return TX_CONTINUE;
316

317
318
	if (tx->sta)
		assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
319

320
	if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
321
		if (unlikely(!assoc &&
322
			     ieee80211_is_data(hdr->frame_control))) {
323
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Johannes Berg's avatar
Johannes Berg committed
324
325
326
327
			sdata_info(tx->sdata,
				   "dropped data frame to not associated station %pM\n",
				   hdr->addr1);
#endif
328
			I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
329
			return TX_DROP;
330
		}
331
332
	} else if (unlikely(tx->sdata->vif.type == NL80211_IFTYPE_AP &&
			    ieee80211_is_data(hdr->frame_control) &&
333
			    !atomic_read(&tx->sdata->u.ap.num_mcast_sta))) {
334
335
336
337
338
		/*
		 * No associated STAs - no need to send multicast
		 * frames.
		 */
		return TX_DROP;
339
340
	}

341
	return TX_CONTINUE;
342
343
344
345
346
347
348
349
350
351
352
353
354
}

/* This function is called whenever the AP is about to exceed the maximum limit
 * of buffered frames for power saving STAs. This situation should not really
 * happen often during normal operation, so dropping the oldest buffered packet
 * from each queue should be OK to make some room for new frames. */
static void purge_old_ps_buffers(struct ieee80211_local *local)
{
	int total = 0, purged = 0;
	struct sk_buff *skb;
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;

355
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
356
357
358
359
		struct ps_data *ps;

		if (sdata->vif.type == NL80211_IFTYPE_AP)
			ps = &sdata->u.ap.ps;
360
361
		else if (ieee80211_vif_is_mesh(&sdata->vif))
			ps = &sdata->u.mesh.ps;
362
		else
363
			continue;
364
365

		skb = skb_dequeue(&ps->bc_buf);
366
367
368
369
		if (skb) {
			purged++;
			dev_kfree_skb(skb);
		}
370
		total += skb_queue_len(&ps->bc_buf);
371
372
	}

373
374
375
376
	/*
	 * Drop one frame from each station from the lowest-priority
	 * AC that has frames at all.
	 */
377
	list_for_each_entry_rcu(sta, &local->sta_list, list) {
378
379
380
381
382
383
384
		int ac;

		for (ac = IEEE80211_AC_BK; ac >= IEEE80211_AC_VO; ac--) {
			skb = skb_dequeue(&sta->ps_tx_buf[ac]);
			total += skb_queue_len(&sta->ps_tx_buf[ac]);
			if (skb) {
				purged++;
385
				ieee80211_free_txskb(&local->hw, skb);
386
387
				break;
			}
388
389
		}
	}
390

391
	local->total_ps_buffered = total;
Johannes Berg's avatar
Johannes Berg committed
392
	ps_dbg_hw(&local->hw, "PS buffers full - purged %d frames\n", purged);
393
394
}

395
static ieee80211_tx_result
396
ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
397
{
398
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
399
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
400
	struct ps_data *ps;
401

402
403
404
	/*
	 * broadcast/multicast frame
	 *
405
	 * If any of the associated/peer stations is in power save mode,
406
407
408
409
	 * the frame is buffered to be sent after DTIM beacon frame.
	 * This is done either by the hardware or us.
	 */

410
	/* powersaving STAs currently only in AP/VLAN/mesh mode */
411
412
413
414
415
416
	if (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
	    tx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		if (!tx->sdata->bss)
			return TX_CONTINUE;

		ps = &tx->sdata->bss->ps;
417
418
	} else if (ieee80211_vif_is_mesh(&tx->sdata->vif)) {
		ps = &tx->sdata->u.mesh.ps;
419
	} else {
420
		return TX_CONTINUE;
421
422
	}

423
424

	/* no buffering for ordered frames */
425
	if (ieee80211_has_order(hdr->frame_control))
426
		return TX_CONTINUE;
427

428
429
430
	if (ieee80211_is_probe_req(hdr->frame_control))
		return TX_CONTINUE;

431
	if (ieee80211_hw_check(&tx->local->hw, QUEUE_CONTROL))
432
433
		info->hw_queue = tx->sdata->vif.cab_queue;

434
	/* no stations in PS mode */
435
	if (!atomic_read(&ps->num_sta_ps))
436
		return TX_CONTINUE;
437

438
	info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
439

440
	/* device releases frame after DTIM beacon */
441
	if (!ieee80211_hw_check(&tx->local->hw, HOST_BROADCAST_PS_BUFFERING))
442
443
		return TX_CONTINUE;

444
	/* buffered in mac80211 */
445
446
447
	if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
		purge_old_ps_buffers(tx->local);

448
	if (skb_queue_len(&ps->bc_buf) >= AP_MAX_BC_BUFFER) {
Johannes Berg's avatar
Johannes Berg committed
449
450
		ps_dbg(tx->sdata,
		       "BC TX buffer full - dropping the oldest frame\n");
451
		dev_kfree_skb(skb_dequeue(&ps->bc_buf));
452
453
	} else
		tx->local->total_ps_buffered++;
454

455
	skb_queue_tail(&ps->bc_buf, tx->skb);
456

457
	return TX_QUEUED;
458
459
}

460
461
462
463
464
465
static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta,
			     struct sk_buff *skb)
{
	if (!ieee80211_is_mgmt(fc))
		return 0;

466
	if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP))
467
468
		return 0;

469
	if (!ieee80211_is_robust_mgmt_frame(skb))
470
471
472
473
474
		return 0;

	return 1;
}

475
static ieee80211_tx_result
476
ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
477
478
{
	struct sta_info *sta = tx->sta;
479
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
480
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
481
	struct ieee80211_local *local = tx->local;
482

483
	if (unlikely(!sta))
484
		return TX_CONTINUE;
485

486
	if (unlikely((test_sta_flag(sta, WLAN_STA_PS_STA) ||
487
488
		      test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
		      test_sta_flag(sta, WLAN_STA_PS_DELIVER)) &&
489
		     !(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER))) {
490
491
		int ac = skb_get_queue_mapping(tx->skb);

492
493
494
495
496
497
		if (ieee80211_is_mgmt(hdr->frame_control) &&
		    !ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
			info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
			return TX_CONTINUE;
		}

Johannes Berg's avatar
Johannes Berg committed
498
499
		ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n",
		       sta->sta.addr, sta->sta.aid, ac);
500
501
		if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
			purge_old_ps_buffers(tx->local);
502
503
504
505
506
507
508
509
510

		/* sync with ieee80211_sta_ps_deliver_wakeup */
		spin_lock(&sta->ps_lock);
		/*
		 * STA woke up the meantime and all the frames on ps_tx_buf have
		 * been queued to pending queue. No reordering can happen, go
		 * ahead and Tx the packet.
		 */
		if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
511
512
		    !test_sta_flag(sta, WLAN_STA_PS_DRIVER) &&
		    !test_sta_flag(sta, WLAN_STA_PS_DELIVER)) {
513
514
515
516
			spin_unlock(&sta->ps_lock);
			return TX_CONTINUE;
		}

517
518
		if (skb_queue_len(&sta->ps_tx_buf[ac]) >= STA_MAX_TX_BUFFER) {
			struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf[ac]);
Johannes Berg's avatar
Johannes Berg committed
519
520
521
			ps_dbg(tx->sdata,
			       "STA %pM TX buffer for AC %d full - dropping oldest frame\n",
			       sta->sta.addr, ac);
522
			ieee80211_free_txskb(&local->hw, old);
523
524
		} else
			tx->local->total_ps_buffered++;
525

526
		info->control.jiffies = jiffies;
527
		info->control.vif = &tx->sdata->vif;
528
		info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
529
		info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
530
		skb_queue_tail(&sta->ps_tx_buf[ac], tx->skb);
531
		spin_unlock(&sta->ps_lock);
532
533
534
535
536
537

		if (!timer_pending(&local->sta_cleanup))
			mod_timer(&local->sta_cleanup,
				  round_jiffies(jiffies +
						STA_INFO_CLEANUP_INTERVAL));

538
539
540
541
542
543
		/*
		 * We queued up some frames, so the TIM bit might
		 * need to be set, recalculate it.
		 */
		sta_info_recalc_tim(sta);

544
		return TX_QUEUED;
Johannes Berg's avatar
Johannes Berg committed
545
546
547
548
	} else if (unlikely(test_sta_flag(sta, WLAN_STA_PS_STA))) {
		ps_dbg(tx->sdata,
		       "STA %pM in PS mode, but polling/in SP -> send frame\n",
		       sta->sta.addr);
549
550
	}

551
	return TX_CONTINUE;
552
553
}

554
static ieee80211_tx_result debug_noinline
555
ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
556
{
557
	if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
558
		return TX_CONTINUE;
559

560
	if (tx->flags & IEEE80211_TX_UNICAST)
561
562
563
564
565
		return ieee80211_tx_h_unicast_ps_buf(tx);
	else
		return ieee80211_tx_h_multicast_ps_buf(tx);
}

566
567
568
569
570
static ieee80211_tx_result debug_noinline
ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx)
{
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);

571
572
573
574
	if (unlikely(tx->sdata->control_port_protocol == tx->skb->protocol)) {
		if (tx->sdata->control_port_no_encrypt)
			info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
		info->control.flags |= IEEE80211_TX_CTRL_PORT_CTRL_PROTO;
575
		info->flags |= IEEE80211_TX_CTL_USE_MINRATE;
576
	}
577
578
579
580

	return TX_CONTINUE;
}

581
static ieee80211_tx_result debug_noinline
582
ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
583
{
584
	struct ieee80211_key *key;
585
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
586
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
587

Johannes Berg's avatar
Johannes Berg committed
588
	if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
589
		tx->key = NULL;
590
591
	else if (tx->sta &&
		 (key = rcu_dereference(tx->sta->ptk[tx->sta->ptk_idx])))
592
		tx->key = key;
593
	else if (ieee80211_is_mgmt(hdr->frame_control) &&
594
		 is_multicast_ether_addr(hdr->addr1) &&
595
		 ieee80211_is_robust_mgmt_frame(tx->skb) &&
596
597
		 (key = rcu_dereference(tx->sdata->default_mgmt_key)))
		tx->key = key;
598
599
600
601
602
	else if (is_multicast_ether_addr(hdr->addr1) &&
		 (key = rcu_dereference(tx->sdata->default_multicast_key)))
		tx->key = key;
	else if (!is_multicast_ether_addr(hdr->addr1) &&
		 (key = rcu_dereference(tx->sdata->default_unicast_key)))
603
		tx->key = key;
604
	else
605
		tx->key = NULL;
606
607

	if (tx->key) {
608
609
		bool skip_hw = false;

610
		/* TODO: add threshold stuff again */
611

612
613
614
615
		switch (tx->key->conf.cipher) {
		case WLAN_CIPHER_SUITE_WEP40:
		case WLAN_CIPHER_SUITE_WEP104:
		case WLAN_CIPHER_SUITE_TKIP:
616
			if (!ieee80211_is_data_present(hdr->frame_control))
617
618
				tx->key = NULL;
			break;
619
		case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen's avatar
Jouni Malinen committed
620
		case WLAN_CIPHER_SUITE_CCMP_256:
621
622
		case WLAN_CIPHER_SUITE_GCMP:
		case WLAN_CIPHER_SUITE_GCMP_256:
623
624
625
626
			if (!ieee80211_is_data_present(hdr->frame_control) &&
			    !ieee80211_use_mfp(hdr->frame_control, tx->sta,
					       tx->skb))
				tx->key = NULL;
627
628
			else
				skip_hw = (tx->key->conf.flags &
629
					   IEEE80211_KEY_FLAG_SW_MGMT_TX) &&
630
					ieee80211_is_mgmt(hdr->frame_control);
631
			break;
632
		case WLAN_CIPHER_SUITE_AES_CMAC:
633
		case WLAN_CIPHER_SUITE_BIP_CMAC_256:
634
635
		case WLAN_CIPHER_SUITE_BIP_GMAC_128:
		case WLAN_CIPHER_SUITE_BIP_GMAC_256:
636
637
638
			if (!ieee80211_is_mgmt(hdr->frame_control))
				tx->key = NULL;
			break;
639
		}
640

641
642
		if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&
			     !ieee80211_is_deauth(hdr->frame_control)))
643
644
			return TX_DROP;

645
		if (!skip_hw && tx->key &&
Johannes Berg's avatar
Johannes Berg committed
646
		    tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
647
			info->control.hw_key = &tx->key->conf;
648
649
	}

650
	return TX_CONTINUE;
651
652
}

653
static ieee80211_tx_result debug_noinline
654
ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
655
{
656
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
657
658
	struct ieee80211_hdr *hdr = (void *)tx->skb->data;
	struct ieee80211_supported_band *sband;
659
	u32 len;
660
	struct ieee80211_tx_rate_control txrc;
661
	struct ieee80211_sta_rates *ratetbl = NULL;
662
	bool assoc = false;
663

664
	memset(&txrc, 0, sizeof(txrc));
665

666
	sband = tx->local->hw.wiphy->bands[info->band];
667

668
	len = min_t(u32, tx->skb->len + FCS_LEN,
669
			 tx->local->hw.wiphy->frag_threshold);
670
671

	/* set up the tx rate control struct we give the RC algo */
Johannes Berg's avatar
Johannes Berg committed
672
	txrc.hw = &tx->local->hw;
673
674
675
676
	txrc.sband = sband;
	txrc.bss_conf = &tx->sdata->vif.bss_conf;
	txrc.skb = tx->skb;
	txrc.reported_rate.idx = -1;
677
	txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[info->band];
678
679
680
681
	if (txrc.rate_idx_mask == (1 << sband->n_bitrates) - 1)
		txrc.max_rate_idx = -1;
	else
		txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
682
683
684
685
686

	if (tx->sdata->rc_has_mcs_mask[info->band])
		txrc.rate_idx_mcs_mask =
			tx->sdata->rc_rateidx_mcs_mask[info->band];

687
	txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
688
		    tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
689
690
		    tx->sdata->vif.type == NL80211_IFTYPE_ADHOC ||
		    tx->sdata->vif.type == NL80211_IFTYPE_OCB);
691
692

	/* set up RTS protection if desired */
693
	if (len > tx->local->hw.wiphy->rts_threshold) {
694
		txrc.rts = true;
695
696
	}

697
	info->control.use_rts = txrc.rts;
698
699
	info->control.use_cts_prot = tx->sdata->vif.bss_conf.use_cts_prot;

700
701
702
703
704
705
706
707
	/*
	 * Use short preamble if the BSS can handle it, but not for
	 * management frames unless we know the receiver can handle
	 * that -- the management frame might be to a station that
	 * just wants a probe response.
	 */
	if (tx->sdata->vif.bss_conf.use_short_preamble &&
	    (ieee80211_is_data(hdr->frame_control) ||
708
	     (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
709
710
711
		txrc.short_preamble = true;

	info->control.short_preamble = txrc.short_preamble;
712

713
714
715
716
	/* don't ask rate control when rate already injected via radiotap */
	if (info->control.flags & IEEE80211_TX_CTRL_RATE_INJECT)
		return TX_CONTINUE;

717
718
	if (tx->sta)
		assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
719
720
721
722
723

	/*
	 * Lets not bother rate control if we're associated and cannot
	 * talk to the sta. This should not happen.
	 */
724
	if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) && assoc &&
725
726
727
728
		 !rate_usable_index_exists(sband, &tx->sta->sta),
		 "%s: Dropped data frame as no usable bitrate found while "
		 "scanning and associated. Target station: "
		 "%pM on %d GHz band\n",
729
		 tx->sdata->name, hdr->addr1,
730
		 info->band ? 5 : 2))
731
		return TX_DROP;
732

733
734
735
736
	/*
	 * If we're associated with the sta at this point we know we can at
	 * least send the frame at the lowest bit rate.
	 */
737
738
	rate_control_get_rate(tx->sdata, tx->sta, &txrc);

739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
	if (tx->sta && !info->control.skip_table)
		ratetbl = rcu_dereference(tx->sta->sta.rates);

	if (unlikely(info->control.rates[0].idx < 0)) {
		if (ratetbl) {
			struct ieee80211_tx_rate rate = {
				.idx = ratetbl->rate[0].idx,
				.flags = ratetbl->rate[0].flags,
				.count = ratetbl->rate[0].count
			};

			if (ratetbl->rate[0].idx < 0)
				return TX_DROP;

			tx->rate = rate;
		} else {
			return TX_DROP;
		}
	} else {
		tx->rate = info->control.rates[0];
	}
760

761
	if (txrc.reported_rate.idx < 0) {
762
		txrc.reported_rate = tx->rate;
763
		if (tx->sta && ieee80211_is_data(hdr->frame_control))
764
			tx->sta->tx_stats.last_rate = txrc.reported_rate;
765
	} else if (tx->sta)
766
		tx->sta->tx_stats.last_rate = txrc.reported_rate;
767

768
769
770
	if (ratetbl)
		return TX_CONTINUE;

771
772
	if (unlikely(!info->control.rates[0].count))
		info->control.rates[0].count = 1;
773

774
775
776
777
	if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
			 (info->flags & IEEE80211_TX_CTL_NO_ACK)))
		info->control.rates[0].count = 1;

778
779
780
	return TX_CONTINUE;
}

781
782
783
784
785
786
787
788
789
790
791
static __le16 ieee80211_tx_next_seq(struct sta_info *sta, int tid)
{
	u16 *seq = &sta->tid_seq[tid];
	__le16 ret = cpu_to_le16(*seq);

	/* Increase the sequence number. */
	*seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;

	return ret;
}

792
793
794
795
796
797
798
799
static ieee80211_tx_result debug_noinline
ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
{
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
	u8 *qc;
	int tid;

800
801
802
803
804
	/*
	 * Packet injection may want to control the sequence
	 * number, if we have no matching interface then we
	 * neither assign one ourselves nor ask the driver to.
	 */
805
	if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR))
806
807
		return TX_CONTINUE;

808
809
810
811
812
813
	if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
		return TX_CONTINUE;

	if (ieee80211_hdrlen(hdr->frame_control) < 24)
		return TX_CONTINUE;

814
815
816
	if (ieee80211_is_qos_nullfunc(hdr->frame_control))
		return TX_CONTINUE;

817
818
819
	/*
	 * Anything but QoS data that has a sequence number field
	 * (is long enough) gets a sequence number from the global
820
821
	 * counter.  QoS data frames with a multicast destination
	 * also use the global counter (802.11-2012 9.3.2.10).
822
	 */
823
824
	if (!ieee80211_is_data_qos(hdr->frame_control) ||
	    is_multicast_ether_addr(hdr->addr1)) {
825
		/* driver should assign sequence number */
826
		info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
827
828
829
		/* for pure STA mode without beacons, we can do it */
		hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
		tx->sdata->sequence_number += 0x10;
830
		if (tx->sta)
831
			tx->sta->tx_stats.msdu[IEEE80211_NUM_TIDS]++;
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
		return TX_CONTINUE;
	}

	/*
	 * This should be true for injected/management frames only, for
	 * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
	 * above since they are not QoS-data frames.
	 */
	if (!tx->sta)
		return TX_CONTINUE;

	/* include per-STA, per-TID sequence counter */

	qc = ieee80211_get_qos_ctl(hdr);
	tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
847
	tx->sta->tx_stats.msdu[tid]++;
848

849
850
	if (!tx->sta->sta.txq[0])
		hdr->seq_ctrl = ieee80211_tx_next_seq(tx->sta, tid);
851
852
853
854

	return TX_CONTINUE;
}

855
static int ieee80211_fragment(struct ieee80211_tx_data *tx,
856
857
858
			      struct sk_buff *skb, int hdrlen,
			      int frag_threshold)
{
859
	struct ieee80211_local *local = tx->local;
860
	struct ieee80211_tx_info *info;
861
	struct sk_buff *tmp;
862
863
864
865
866
867
868
	int per_fragm = frag_threshold - hdrlen - FCS_LEN;
	int pos = hdrlen + per_fragm;
	int rem = skb->len - hdrlen - per_fragm;

	if (WARN_ON(rem < 0))
		return -EINVAL;

869
870
	/* first fragment was already added to queue by caller */

871
872
873
874
875
876
877
878
	while (rem) {
		int fraglen = per_fragm;

		if (fraglen > rem)
			fraglen = rem;
		rem -= fraglen;
		tmp = dev_alloc_skb(local->tx_headroom +
				    frag_threshold +
879
				    tx->sdata->encrypt_headroom +
880
881
882
				    IEEE80211_ENCRYPT_TAILROOM);
		if (!tmp)
			return -ENOMEM;
883
884
885

		__skb_queue_tail(&tx->skbs, tmp);

886
887
888
		skb_reserve(tmp,
			    local->tx_headroom + tx->sdata->encrypt_headroom);

889
890
		/* copy control information */
		memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
891
892
893
894
895
896
897
898

		info = IEEE80211_SKB_CB(tmp);
		info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
				 IEEE80211_TX_CTL_FIRST_FRAGMENT);

		if (rem)
			info->flags |= IEEE80211_TX_CTL_MORE_FRAMES;

899
900
901
902
903
904
905
906
907
908
909
		skb_copy_queue_mapping(tmp, skb);
		tmp->priority = skb->priority;
		tmp->dev = skb->dev;

		/* copy header and data */
		memcpy(skb_put(tmp, hdrlen), skb->data, hdrlen);
		memcpy(skb_put(tmp, fraglen), skb->data + pos, fraglen);

		pos += fraglen;
	}

910
	/* adjust first fragment's length */
911
	skb_trim(skb, hdrlen + per_fragm);
912
913
914
	return 0;
}

915
static ieee80211_tx_result debug_noinline
916
917
ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
{
918
919
920
	struct sk_buff *skb = tx->skb;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	struct ieee80211_hdr *hdr = (void *)skb->data;
921
	int frag_threshold = tx->local->hw.wiphy->frag_threshold;
922
923
	int hdrlen;
	int fragnum;
924

925
926
927
928
	/* no matter what happens, tx->skb moves to tx->skbs */
	__skb_queue_tail(&tx->skbs, skb);
	tx->skb = NULL;

929
930
931
932
	if (info->flags & IEEE80211_TX_CTL_DONTFRAG)
		return TX_CONTINUE;

	if (tx->local->ops->set_frag_threshold)
933
934
		return TX_CONTINUE;

935
936
	/*
	 * Warn when submitting a fragmented A-MPDU frame and drop it.
Johannes Berg's avatar
Johannes Berg committed
937
	 * This scenario is handled in ieee80211_tx_prepare but extra
938
	 * caution taken here as fragmented ampdu may cause Tx stop.
939
	 */
Sujith's avatar
Sujith committed
940
	if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
941
942
		return TX_DROP;

943
	hdrlen = ieee80211_hdrlen(hdr->frame_control);
944

945
	/* internal error, why isn't DONTFRAG set? */
946
	if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
947
		return TX_DROP;
948

949
950
951
952
953
954
955
956
	/*
	 * Now fragment the frame. This will allocate all the fragments and
	 * chain them (using skb as the first fragment) to skb->next.
	 * During transmission, we will remove the successfully transmitted
	 * fragments from this list. When the low-level driver rejects one
	 * of the fragments then we will simply pretend to accept the skb
	 * but store it away as pending.
	 */
957
	if (ieee80211_fragment(tx, skb, hdrlen, frag_threshold))
958
		return TX_DROP;
959

960
961
	/* update duration/seq/flags of fragments */
	fragnum = 0;
962
963

	skb_queue_walk(&tx->skbs, skb) {
964
		const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
965

966
967
		hdr = (void *)skb->data;
		info = IEEE80211_SKB_CB(skb);
968

969
		if (!skb_queue_is_last(&tx->skbs, skb)) {
970
			hdr->frame_control |= morefrags;
971
972
973
974
975
976
977
			/*
			 * No multi-rate retries for fragmented frames, that
			 * would completely throw off the NAV at other STAs.
			 */
			info->control.rates[1].idx = -1;
			info->control.rates[2].idx = -1;
			info->control.rates[3].idx = -1;
978
			BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4);
979
			info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
980
981
		} else {
			hdr->frame_control &= ~morefrags;
982
		}
983
984
		hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG);
		fragnum++;
985
	}
986

987
	return TX_CONTINUE;
988
989
}

990
991
992
static ieee80211_tx_result debug_noinline
ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
{
993
	struct sk_buff *skb;
994
	int ac = -1;
995
996
997
998

	if (!tx->sta)
		return TX_CONTINUE;

999
	skb_queue_walk(&tx->skbs, skb) {
1000
		ac = skb_get_queue_mapping(skb);