tx.c 122 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
#include <net/ieee80211_radiotap.h>
#include <net/cfg80211.h>
#include <net/mac80211.h>
27 28
#include <net/codel.h>
#include <net/codel_impl.h>
29
#include <asm/unaligned.h>
30
#include <net/fq_impl.h>
31 32

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

/* misc utils */

43 44 45 46 47 48 49 50 51 52
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);
}

53 54
static __le16 ieee80211_duration(struct ieee80211_tx_data *tx,
				 struct sk_buff *skb, int group_addr,
Johannes Berg's avatar
Johannes Berg committed
55
				 int next_frag_len)
56
{
57
	int rate, mrate, erp, dur, i, shift = 0;
58
	struct ieee80211_rate *txrate;
59
	struct ieee80211_local *local = tx->local;
60
	struct ieee80211_supported_band *sband;
61
	struct ieee80211_hdr *hdr;
62
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
63 64 65 66 67 68 69 70 71 72
	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();
73 74

	/* assume HW handles this */
75
	if (tx->rate.flags & (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS))
76 77 78
		return 0;

	/* uh huh? */
79
	if (WARN_ON_ONCE(tx->rate.idx < 0))
80
		return 0;
81

82
	sband = local->hw.wiphy->bands[info->band];
83
	txrate = &sband->bitrates[tx->rate.idx];
84

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

	/*
	 * 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
	 */
104
	hdr = (struct ieee80211_hdr *)skb->data;
105
	if (ieee80211_is_ctl(hdr->frame_control)) {
106
		/* TODO: These control frames are not currently sent by
107
		 * mac80211, but should they be implemented, this function
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
		 * 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
125
		return cpu_to_le16(32768);
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

	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;
141 142 143 144
	/* 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];
145

146 147
		if (r->bitrate > txrate->bitrate)
			break;
148

149 150 151
		if ((rate_flags & r->flags) != rate_flags)
			continue;

152
		if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
153
			rate = DIV_ROUND_UP(r->bitrate, 1 << shift);
154 155

		switch (sband->band) {
156
		case NL80211_BAND_2GHZ: {
157 158 159 160 161 162 163 164 165
			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;
		}
166
		case NL80211_BAND_5GHZ:
167 168 169
			if (r->flags & IEEE80211_RATE_MANDATORY_A)
				mrate = r->bitrate;
			break;
170
		case NL80211_BAND_60GHZ:
171
			/* TODO, for now fall through */
172
		case NUM_NL80211_BANDS:
173 174 175
			WARN_ON(1);
			break;
		}
176 177 178 179
	}
	if (rate == -1) {
		/* No matching basic rate found; use highest suitable mandatory
		 * PHY rate */
180
		rate = DIV_ROUND_UP(mrate, 1 << shift);
181 182
	}

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

	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 */
200
		dur += ieee80211_frame_duration(sband->band, next_frag_len,
201
				txrate->bitrate, erp,
202 203
				tx->sdata->vif.bss_conf.use_short_preamble,
				shift);
204 205
	}

Johannes Berg's avatar
Johannes Berg committed
206
	return cpu_to_le16(dur);
207 208 209
}

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

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

	/* hardware does dynamic power save */
221
	if (ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
		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;

239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
	/* 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.
	 *
254
	 * Note: ifmgd->uapsd_queues access is racy here. If the value is
255 256 257
	 * changed via debugfs, user needs to reassociate manually to have
	 * everything in sync.
	 */
258 259 260
	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)
261 262
		return TX_CONTINUE;

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

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

277 278 279 280 281
	mod_timer(&local->dynamic_ps_timer, jiffies +
		  msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));

	return TX_CONTINUE;
}
282

283
static ieee80211_tx_result debug_noinline
284
ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
285
{
286

287 288
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
289
	bool assoc = false;
290

291
	if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
292
		return TX_CONTINUE;
293

294 295
	if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) &&
	    test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) &&
296 297 298 299 300 301 302 303 304 305 306 307 308
	    !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
		 */
309
		return TX_DROP;
310

311 312 313
	if (tx->sdata->vif.type == NL80211_IFTYPE_OCB)
		return TX_CONTINUE;

Bill Jordan's avatar
Bill Jordan committed
314 315 316
	if (tx->sdata->vif.type == NL80211_IFTYPE_WDS)
		return TX_CONTINUE;

317
	if (tx->flags & IEEE80211_TX_PS_BUFFERED)
318
		return TX_CONTINUE;
319

320 321
	if (tx->sta)
		assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
322

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

344
	return TX_CONTINUE;
345 346 347 348 349 350 351 352 353 354 355 356 357
}

/* 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;

358
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
359 360 361 362
		struct ps_data *ps;

		if (sdata->vif.type == NL80211_IFTYPE_AP)
			ps = &sdata->u.ap.ps;
363 364
		else if (ieee80211_vif_is_mesh(&sdata->vif))
			ps = &sdata->u.mesh.ps;
365
		else
366
			continue;
367 368

		skb = skb_dequeue(&ps->bc_buf);
369 370
		if (skb) {
			purged++;
371
			ieee80211_free_txskb(&local->hw, skb);
372
		}
373
		total += skb_queue_len(&ps->bc_buf);
374 375
	}

376 377 378 379
	/*
	 * Drop one frame from each station from the lowest-priority
	 * AC that has frames at all.
	 */
380
	list_for_each_entry_rcu(sta, &local->sta_list, list) {
381 382 383 384 385 386 387
		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++;
388
				ieee80211_free_txskb(&local->hw, skb);
389 390
				break;
			}
391 392
		}
	}
393

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

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

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

413
	/* powersaving STAs currently only in AP/VLAN/mesh mode */
414 415 416 417 418 419
	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;
420 421
	} else if (ieee80211_vif_is_mesh(&tx->sdata->vif)) {
		ps = &tx->sdata->u.mesh.ps;
422
	} else {
423
		return TX_CONTINUE;
424 425
	}

426 427

	/* no buffering for ordered frames */
428
	if (ieee80211_has_order(hdr->frame_control))
429
		return TX_CONTINUE;
430

431 432 433
	if (ieee80211_is_probe_req(hdr->frame_control))
		return TX_CONTINUE;

434
	if (ieee80211_hw_check(&tx->local->hw, QUEUE_CONTROL))
435 436
		info->hw_queue = tx->sdata->vif.cab_queue;

437 438
	/* no stations in PS mode and no buffered packets */
	if (!atomic_read(&ps->num_sta_ps) && skb_queue_empty(&ps->bc_buf))
439
		return TX_CONTINUE;
440

441
	info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
442

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

447
	/* buffered in mac80211 */
448 449 450
	if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
		purge_old_ps_buffers(tx->local);

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

458
	skb_queue_tail(&ps->bc_buf, tx->skb);
459

460
	return TX_QUEUED;
461 462
}

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

469
	if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP))
470 471
		return 0;

472
	if (!ieee80211_is_robust_mgmt_frame(skb))
473 474 475 476 477
		return 0;

	return 1;
}

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

486
	if (unlikely(!sta))
487
		return TX_CONTINUE;
488

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

495 496 497 498 499 500
		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
501 502
		ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n",
		       sta->sta.addr, sta->sta.aid, ac);
503 504
		if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
			purge_old_ps_buffers(tx->local);
505 506 507 508 509 510 511 512 513

		/* 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) &&
514 515
		    !test_sta_flag(sta, WLAN_STA_PS_DRIVER) &&
		    !test_sta_flag(sta, WLAN_STA_PS_DELIVER)) {
516 517 518 519
			spin_unlock(&sta->ps_lock);
			return TX_CONTINUE;
		}

520 521
		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
522 523 524
			ps_dbg(tx->sdata,
			       "STA %pM TX buffer for AC %d full - dropping oldest frame\n",
			       sta->sta.addr, ac);
525
			ieee80211_free_txskb(&local->hw, old);
526 527
		} else
			tx->local->total_ps_buffered++;
528

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

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

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

547
		return TX_QUEUED;
Johannes Berg's avatar
Johannes Berg committed
548 549 550 551
	} 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);
552 553
	}

554
	return TX_CONTINUE;
555 556
}

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

563
	if (tx->flags & IEEE80211_TX_UNICAST)
564 565 566 567 568
		return ieee80211_tx_h_unicast_ps_buf(tx);
	else
		return ieee80211_tx_h_multicast_ps_buf(tx);
}

569 570 571 572 573
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);

574 575 576 577
	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;
578
		info->flags |= IEEE80211_TX_CTL_USE_MINRATE;
579
	}
580 581 582 583

	return TX_CONTINUE;
}

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

Johannes Berg's avatar
Johannes Berg committed
591
	if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
592
		tx->key = NULL;
593 594
	else if (tx->sta &&
		 (key = rcu_dereference(tx->sta->ptk[tx->sta->ptk_idx])))
595
		tx->key = key;
596 597 598
	else if (ieee80211_is_group_privacy_action(tx->skb) &&
		(key = rcu_dereference(tx->sdata->default_multicast_key)))
		tx->key = key;
599
	else if (ieee80211_is_mgmt(hdr->frame_control) &&
600
		 is_multicast_ether_addr(hdr->addr1) &&
601
		 ieee80211_is_robust_mgmt_frame(tx->skb) &&
602 603
		 (key = rcu_dereference(tx->sdata->default_mgmt_key)))
		tx->key = key;
604 605 606 607 608
	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)))
609
		tx->key = key;
610
	else
611
		tx->key = NULL;
612 613

	if (tx->key) {
614 615
		bool skip_hw = false;

616
		/* TODO: add threshold stuff again */
617

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

648 649
		if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&
			     !ieee80211_is_deauth(hdr->frame_control)))
650 651
			return TX_DROP;

652
		if (!skip_hw && tx->key &&
Johannes Berg's avatar
Johannes Berg committed
653
		    tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
654
			info->control.hw_key = &tx->key->conf;
655 656
	}

657
	return TX_CONTINUE;
658 659
}

660
static ieee80211_tx_result debug_noinline
661
ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
662
{
663
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
664 665
	struct ieee80211_hdr *hdr = (void *)tx->skb->data;
	struct ieee80211_supported_band *sband;
666
	u32 len;
667
	struct ieee80211_tx_rate_control txrc;
668
	struct ieee80211_sta_rates *ratetbl = NULL;
669
	bool assoc = false;
670

671
	memset(&txrc, 0, sizeof(txrc));
672

673
	sband = tx->local->hw.wiphy->bands[info->band];
674

675
	len = min_t(u32, tx->skb->len + FCS_LEN,
676
			 tx->local->hw.wiphy->frag_threshold);
677 678

	/* set up the tx rate control struct we give the RC algo */
Johannes Berg's avatar
Johannes Berg committed
679
	txrc.hw = &tx->local->hw;
680 681 682 683
	txrc.sband = sband;
	txrc.bss_conf = &tx->sdata->vif.bss_conf;
	txrc.skb = tx->skb;
	txrc.reported_rate.idx = -1;
684
	txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[info->band];
685 686 687 688
	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;
689 690 691 692 693

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

694
	txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
695
		    tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
696 697
		    tx->sdata->vif.type == NL80211_IFTYPE_ADHOC ||
		    tx->sdata->vif.type == NL80211_IFTYPE_OCB);
698 699

	/* set up RTS protection if desired */
700
	if (len > tx->local->hw.wiphy->rts_threshold) {
701
		txrc.rts = true;
702 703
	}

704
	info->control.use_rts = txrc.rts;
705 706
	info->control.use_cts_prot = tx->sdata->vif.bss_conf.use_cts_prot;

707 708 709 710 711 712 713 714
	/*
	 * 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) ||
715
	     (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
716 717 718
		txrc.short_preamble = true;

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

720 721 722 723
	/* don't ask rate control when rate already injected via radiotap */
	if (info->control.flags & IEEE80211_TX_CTRL_RATE_INJECT)
		return TX_CONTINUE;

724 725
	if (tx->sta)
		assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
726 727 728 729 730

	/*
	 * Lets not bother rate control if we're associated and cannot
	 * talk to the sta. This should not happen.
	 */
731
	if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) && assoc &&
732 733 734 735
		 !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",
736
		 tx->sdata->name, hdr->addr1,
737
		 info->band ? 5 : 2))
738
		return TX_DROP;
739

740 741 742 743
	/*
	 * If we're associated with the sta at this point we know we can at
	 * least send the frame at the lowest bit rate.
	 */
744 745
	rate_control_get_rate(tx->sdata, tx->sta, &txrc);

746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	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];
	}
767

768
	if (txrc.reported_rate.idx < 0) {
769
		txrc.reported_rate = tx->rate;
770
		if (tx->sta && ieee80211_is_data(hdr->frame_control))
771
			tx->sta->tx_stats.last_rate = txrc.reported_rate;
772
	} else if (tx->sta)
773
		tx->sta->tx_stats.last_rate = txrc.reported_rate;
774

775 776 777
	if (ratetbl)
		return TX_CONTINUE;

778 779
	if (unlikely(!info->control.rates[0].count))
		info->control.rates[0].count = 1;
780

781 782 783 784
	if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
			 (info->flags & IEEE80211_TX_CTL_NO_ACK)))
		info->control.rates[0].count = 1;

785 786 787
	return TX_CONTINUE;
}

788 789 790 791 792 793 794 795 796 797 798
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;
}

799 800 801 802 803 804 805 806
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;

807 808 809 810 811
	/*
	 * 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.
	 */
812
	if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR))
813 814
		return TX_CONTINUE;

815 816 817 818 819 820
	if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
		return TX_CONTINUE;

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

821 822 823
	if (ieee80211_is_qos_nullfunc(hdr->frame_control))
		return TX_CONTINUE;

824 825 826
	/*
	 * Anything but QoS data that has a sequence number field
	 * (is long enough) gets a sequence number from the global
827 828
	 * counter.  QoS data frames with a multicast destination
	 * also use the global counter (802.11-2012 9.3.2.10).
829
	 */
830 831
	if (!ieee80211_is_data_qos(hdr->frame_control) ||
	    is_multicast_ether_addr(hdr->addr1)) {
832
		/* driver should assign sequence number */
833
		info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
834 835 836
		/* 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;
837
		if (tx->sta)
838
			tx->sta->tx_stats.msdu[IEEE80211_NUM_TIDS]++;
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
		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;
854
	tx->sta->tx_stats.msdu[tid]++;
855

856
	hdr->seq_ctrl = ieee80211_tx_next_seq(tx->sta, tid);
857 858 859 860

	return TX_CONTINUE;
}

861
static int ieee80211_fragment(struct ieee80211_tx_data *tx,
862 863 864
			      struct sk_buff *skb, int hdrlen,
			      int frag_threshold)
{
865
	struct ieee80211_local *local = tx->local;
866
	struct ieee80211_tx_info *info;
867
	struct sk_buff *tmp;
868 869 870 871 872 873 874
	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;

875 876
	/* first fragment was already added to queue by caller */

877 878 879 880 881 882 883 884
	while (rem) {
		int fraglen = per_fragm;

		if (fraglen > rem)
			fraglen = rem;
		rem -= fraglen;
		tmp = dev_alloc_skb(local->tx_headroom +
				    frag_threshold +
885
				    tx->sdata->encrypt_headroom +
886 887 888
				    IEEE80211_ENCRYPT_TAILROOM);
		if (!tmp)
			return -ENOMEM;
889 890 891

		__skb_queue_tail(&tx->skbs, tmp);

892 893 894
		skb_reserve(tmp,
			    local->tx_headroom + tx->sdata->encrypt_headroom);

895 896
		/* copy control information */
		memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
897 898 899 900 901 902 903 904

		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;

905 906 907 908 909 910 911 912 913 914 915
		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;
	}

916
	/* adjust first fragment's length */