tx.c 56.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *
 * 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>
20
#include <linux/rcupdate.h>
21
#include <net/net_namespace.h>
22 23 24 25 26 27
#include <net/ieee80211_radiotap.h>
#include <net/cfg80211.h>
#include <net/mac80211.h>
#include <asm/unaligned.h>

#include "ieee80211_i.h"
J
Johannes Berg 已提交
28
#include "led.h"
29
#include "mesh.h"
30 31 32
#include "wep.h"
#include "wpa.h"
#include "wme.h"
J
Johannes Berg 已提交
33
#include "rate.h"
34 35 36 37 38 39 40 41 42 43 44

#define IEEE80211_TX_OK		0
#define IEEE80211_TX_AGAIN	1
#define IEEE80211_TX_FRAG_AGAIN	2

/* misc utils */

#ifdef CONFIG_MAC80211_LOWTX_FRAME_DUMP
static void ieee80211_dump_frame(const char *ifname, const char *title,
				 const struct sk_buff *skb)
{
45 46
	const struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
	unsigned int hdrlen;
47
	DECLARE_MAC_BUF(mac);
48 49 50 51 52 53 54

	printk(KERN_DEBUG "%s: %s (len=%d)", ifname, title, skb->len);
	if (skb->len < 4) {
		printk("\n");
		return;
	}

55
	hdrlen = ieee80211_hdrlen(hdr->frame_control);
56 57 58 59
	if (hdrlen > skb->len)
		hdrlen = skb->len;
	if (hdrlen >= 4)
		printk(" FC=0x%04x DUR=0x%04x",
60
		    le16_to_cpu(hdr->frame_control), le16_to_cpu(hdr->duration_id));
61
	if (hdrlen >= 10)
62
		printk(" A1=%s", print_mac(mac, hdr->addr1));
63
	if (hdrlen >= 16)
64
		printk(" A2=%s", print_mac(mac, hdr->addr2));
65
	if (hdrlen >= 24)
66
		printk(" A3=%s", print_mac(mac, hdr->addr3));
67
	if (hdrlen >= 30)
68
		printk(" A4=%s", print_mac(mac, hdr->addr4));
69 70 71 72 73 74 75 76 77
	printk("\n");
}
#else /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */
static inline void ieee80211_dump_frame(const char *ifname, const char *title,
					struct sk_buff *skb)
{
}
#endif /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */

J
Johannes Berg 已提交
78 79
static __le16 ieee80211_duration(struct ieee80211_tx_data *tx, int group_addr,
				 int next_frag_len)
80 81
{
	int rate, mrate, erp, dur, i;
82
	struct ieee80211_rate *txrate;
83
	struct ieee80211_local *local = tx->local;
84
	struct ieee80211_supported_band *sband;
85
	struct ieee80211_hdr *hdr;
86

87 88
	sband = local->hw.wiphy->bands[tx->channel->band];
	txrate = &sband->bitrates[tx->rate_idx];
89 90 91 92

	erp = 0;
	if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
		erp = txrate->flags & IEEE80211_RATE_ERP_G;
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

	/*
	 * 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
	 */
111 112
	hdr = (struct ieee80211_hdr *)tx->skb->data;
	if (ieee80211_is_ctl(hdr->frame_control)) {
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
		/* TODO: These control frames are not currently sent by
		 * 80211.o, but should they be implemented, this function
		 * 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 */)
J
Johannes Berg 已提交
132
		return cpu_to_le16(32768);
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147

	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;
148 149 150 151
	/* 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];
152

153 154
		if (r->bitrate > txrate->bitrate)
			break;
155

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
		if (tx->sdata->basic_rates & BIT(i))
			rate = r->bitrate;

		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;
		case IEEE80211_NUM_BANDS:
			WARN_ON(1);
			break;
		}
178 179 180 181 182 183 184 185 186 187 188 189
	}
	if (rate == -1) {
		/* No matching basic rate found; use highest suitable mandatory
		 * PHY rate */
		rate = mrate;
	}

	/* Time needed to transmit ACK
	 * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
	 * to closest integer */

	dur = ieee80211_frame_duration(local, 10, rate, erp,
190
				tx->sdata->bss_conf.use_short_preamble);
191 192 193 194 195 196 197

	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 */
		dur += ieee80211_frame_duration(local, next_frag_len,
198
				txrate->bitrate, erp,
199
				tx->sdata->bss_conf.use_short_preamble);
200 201
	}

J
Johannes Berg 已提交
202
	return cpu_to_le16(dur);
203 204 205 206 207 208 209 210 211 212 213
}

static int inline is_ieee80211_device(struct net_device *dev,
				      struct net_device *master)
{
	return (wdev_priv(dev->ieee80211_ptr) ==
		wdev_priv(master->ieee80211_ptr));
}

/* tx handlers */

214
static ieee80211_tx_result debug_noinline
215
ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
216
{
217

218 219
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
220 221
	u32 sta_flags;

222
	if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
223
		return TX_CONTINUE;
224

Z
Zhu Yi 已提交
225
	if (unlikely(tx->local->sta_sw_scanning) &&
226
	    !ieee80211_is_probe_req(hdr->frame_control))
227
		return TX_DROP;
228

229 230 231
	if (tx->sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT)
		return TX_CONTINUE;

232
	if (tx->flags & IEEE80211_TX_PS_BUFFERED)
233
		return TX_CONTINUE;
234

235
	sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0;
236

237
	if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
238
		if (unlikely(!(sta_flags & WLAN_STA_ASSOC) &&
239
			     tx->sdata->vif.type != IEEE80211_IF_TYPE_IBSS &&
240
			     ieee80211_is_data(hdr->frame_control))) {
241
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
242
			DECLARE_MAC_BUF(mac);
243
			printk(KERN_DEBUG "%s: dropped data frame to not "
244 245
			       "associated station %s\n",
			       tx->dev->name, print_mac(mac, hdr->addr1));
246 247
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
			I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
248
			return TX_DROP;
249 250
		}
	} else {
251
		if (unlikely(ieee80211_is_data(hdr->frame_control) &&
252
			     tx->local->num_sta == 0 &&
253
			     tx->sdata->vif.type != IEEE80211_IF_TYPE_IBSS)) {
254 255 256 257
			/*
			 * No associated STAs - no need to send multicast
			 * frames.
			 */
258
			return TX_DROP;
259
		}
260
		return TX_CONTINUE;
261 262
	}

263
	return TX_CONTINUE;
264 265 266 267 268 269 270 271 272 273 274 275 276
}

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

277 278 279 280 281 282
	/*
	 * virtual interfaces are protected by RCU
	 */
	rcu_read_lock();

	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
283
		struct ieee80211_if_ap *ap;
284
		if (sdata->vif.type != IEEE80211_IF_TYPE_AP)
285 286 287 288 289 290 291 292 293 294
			continue;
		ap = &sdata->u.ap;
		skb = skb_dequeue(&ap->ps_bc_buf);
		if (skb) {
			purged++;
			dev_kfree_skb(skb);
		}
		total += skb_queue_len(&ap->ps_bc_buf);
	}

295
	list_for_each_entry_rcu(sta, &local->sta_list, list) {
296 297 298 299 300 301 302
		skb = skb_dequeue(&sta->ps_tx_buf);
		if (skb) {
			purged++;
			dev_kfree_skb(skb);
		}
		total += skb_queue_len(&sta->ps_tx_buf);
	}
303 304

	rcu_read_unlock();
305 306

	local->total_ps_buffered = total;
307
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
308
	printk(KERN_DEBUG "%s: PS buffers full - purged %d frames\n",
309
	       wiphy_name(local->hw.wiphy), purged);
310
#endif
311 312
}

313
static ieee80211_tx_result
314
ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
315
{
316
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
317
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
318

319 320 321 322 323 324 325 326
	/*
	 * broadcast/multicast frame
	 *
	 * If any of the associated stations is in power save mode,
	 * the frame is buffered to be sent after DTIM beacon frame.
	 * This is done either by the hardware or us.
	 */

327 328 329 330 331
	/* powersaving STAs only in AP/VLAN mode */
	if (!tx->sdata->bss)
		return TX_CONTINUE;

	/* no buffering for ordered frames */
332
	if (ieee80211_has_order(hdr->frame_control))
333
		return TX_CONTINUE;
334 335 336

	/* no stations in PS mode */
	if (!atomic_read(&tx->sdata->bss->num_sta_ps))
337
		return TX_CONTINUE;
338 339 340

	/* buffered in mac80211 */
	if (tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING) {
341 342 343 344
		if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
			purge_old_ps_buffers(tx->local);
		if (skb_queue_len(&tx->sdata->bss->ps_bc_buf) >=
		    AP_MAX_BC_BUFFER) {
345
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
346 347 348 349 350
			if (net_ratelimit()) {
				printk(KERN_DEBUG "%s: BC TX buffer full - "
				       "dropping the oldest frame\n",
				       tx->dev->name);
			}
351
#endif
352 353 354 355
			dev_kfree_skb(skb_dequeue(&tx->sdata->bss->ps_bc_buf));
		} else
			tx->local->total_ps_buffered++;
		skb_queue_tail(&tx->sdata->bss->ps_bc_buf, tx->skb);
356
		return TX_QUEUED;
357 358
	}

359
	/* buffered in hardware */
360
	info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
361

362
	return TX_CONTINUE;
363 364
}

365
static ieee80211_tx_result
366
ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
367 368
{
	struct sta_info *sta = tx->sta;
369
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
370
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
371
	u32 staflags;
372
	DECLARE_MAC_BUF(mac);
373

374
	if (unlikely(!sta || ieee80211_is_probe_resp(hdr->frame_control)))
375
		return TX_CONTINUE;
376

377 378 379 380
	staflags = get_sta_flags(sta);

	if (unlikely((staflags & WLAN_STA_PS) &&
		     !(staflags & WLAN_STA_PSPOLL))) {
381
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
382
		printk(KERN_DEBUG "STA %s aid %d: PS buffer (entries "
383
		       "before %d)\n",
384
		       print_mac(mac, sta->addr), sta->aid,
385 386 387 388 389 390
		       skb_queue_len(&sta->ps_tx_buf));
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
		if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
			purge_old_ps_buffers(tx->local);
		if (skb_queue_len(&sta->ps_tx_buf) >= STA_MAX_TX_BUFFER) {
			struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf);
391
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
392
			if (net_ratelimit()) {
393
				printk(KERN_DEBUG "%s: STA %s TX "
394
				       "buffer full - dropping oldest frame\n",
395
				       tx->dev->name, print_mac(mac, sta->addr));
396
			}
397
#endif
398 399 400
			dev_kfree_skb(old);
		} else
			tx->local->total_ps_buffered++;
401

402
		/* Queue frame to be sent after STA sends an PS Poll frame */
403 404 405
		if (skb_queue_empty(&sta->ps_tx_buf))
			sta_info_set_tim_bit(sta);

406
		info->control.jiffies = jiffies;
407
		skb_queue_tail(&sta->ps_tx_buf, tx->skb);
408
		return TX_QUEUED;
409 410
	}
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
411
	else if (unlikely(test_sta_flags(sta, WLAN_STA_PS))) {
412
		printk(KERN_DEBUG "%s: STA %s in PS mode, but pspoll "
413
		       "set -> send frame\n", tx->dev->name,
414
		       print_mac(mac, sta->addr));
415 416
	}
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
417
	clear_sta_flags(sta, WLAN_STA_PSPOLL);
418

419
	return TX_CONTINUE;
420 421
}

422
static ieee80211_tx_result debug_noinline
423
ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
424
{
425
	if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
426
		return TX_CONTINUE;
427

428
	if (tx->flags & IEEE80211_TX_UNICAST)
429 430 431 432 433
		return ieee80211_tx_h_unicast_ps_buf(tx);
	else
		return ieee80211_tx_h_multicast_ps_buf(tx);
}

434
static ieee80211_tx_result debug_noinline
435
ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
436
{
437
	struct ieee80211_key *key;
438
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
439
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
440

441
	if (unlikely(tx->skb->do_not_encrypt))
442
		tx->key = NULL;
443 444 445 446
	else if (tx->sta && (key = rcu_dereference(tx->sta->key)))
		tx->key = key;
	else if ((key = rcu_dereference(tx->sdata->default_key)))
		tx->key = key;
447
	else if (tx->sdata->drop_unencrypted &&
448
		 (tx->skb->protocol != cpu_to_be16(ETH_P_PAE)) &&
449
		 !(info->flags & IEEE80211_TX_CTL_INJECTED)) {
450
		I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
451
		return TX_DROP;
452
	} else
453 454 455 456
		tx->key = NULL;

	if (tx->key) {
		tx->key->tx_rx_count++;
457
		/* TODO: add threshold stuff again */
458 459 460

		switch (tx->key->conf.alg) {
		case ALG_WEP:
461
			if (ieee80211_is_auth(hdr->frame_control))
462 463 464
				break;
		case ALG_TKIP:
		case ALG_CCMP:
465
			if (!ieee80211_is_data_present(hdr->frame_control))
466 467 468
				tx->key = NULL;
			break;
		}
469 470
	}

471
	if (!tx->key || !(tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
472
		tx->skb->do_not_encrypt = 1;
473

474
	return TX_CONTINUE;
475 476
}

477
static ieee80211_tx_result debug_noinline
478
ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
479
{
480
	struct rate_selection rsel;
481
	struct ieee80211_supported_band *sband;
482
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
483

484
	sband = tx->local->hw.wiphy->bands[tx->channel->band];
485

486
	if (likely(tx->rate_idx < 0)) {
487
		rate_control_get_rate(tx->dev, sband, tx->skb, &rsel);
488 489
		tx->rate_idx = rsel.rate_idx;
		if (unlikely(rsel.probe_idx >= 0)) {
490
			info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE;
491
			tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG;
492
			info->control.alt_retry_rate_idx = tx->rate_idx;
493
			tx->rate_idx = rsel.probe_idx;
494
		} else
495
			info->control.alt_retry_rate_idx = -1;
496

497
		if (unlikely(tx->rate_idx < 0))
498
			return TX_DROP;
499
	} else
500
		info->control.alt_retry_rate_idx = -1;
501

502
	if (tx->sdata->bss_conf.use_cts_prot &&
503 504 505
	    (tx->flags & IEEE80211_TX_FRAGMENTED) && (rsel.nonerp_idx >= 0)) {
		tx->last_frag_rate_idx = tx->rate_idx;
		if (rsel.probe_idx >= 0)
506
			tx->flags &= ~IEEE80211_TX_PROBE_LAST_FRAG;
507
		else
508
			tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG;
509
		tx->rate_idx = rsel.nonerp_idx;
510 511
		info->tx_rate_idx = rsel.nonerp_idx;
		info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
512
	} else {
513
		tx->last_frag_rate_idx = tx->rate_idx;
514
		info->tx_rate_idx = tx->rate_idx;
515
	}
516
	info->tx_rate_idx = tx->rate_idx;
517

518
	return TX_CONTINUE;
519 520
}

521
static ieee80211_tx_result debug_noinline
522
ieee80211_tx_h_misc(struct ieee80211_tx_data *tx)
523
{
524
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
525
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
526 527 528
	struct ieee80211_supported_band *sband;

	sband = tx->local->hw.wiphy->bands[tx->channel->band];
529

530 531 532 533
	if (tx->sta)
		info->control.aid = tx->sta->aid;

	if (!info->control.retry_limit) {
534
		if (!is_multicast_ether_addr(hdr->addr1)) {
535 536 537
			int len = min_t(int, tx->skb->len + FCS_LEN,
					tx->local->fragmentation_threshold);
			if (len > tx->local->rts_threshold
538
			    && tx->local->rts_threshold <
539 540 541 542 543
						IEEE80211_MAX_RTS_THRESHOLD) {
				info->flags |= IEEE80211_TX_CTL_USE_RTS_CTS;
				info->flags |=
					IEEE80211_TX_CTL_LONG_RETRY_LIMIT;
				info->control.retry_limit =
544 545
					tx->local->long_retry_limit;
			} else {
546
				info->control.retry_limit =
547 548
					tx->local->short_retry_limit;
			}
549
		} else {
550
			info->control.retry_limit = 1;
551 552 553
		}
	}

554
	if (tx->flags & IEEE80211_TX_FRAGMENTED) {
555 556 557 558
		/* Do not use multiple retry rates when sending fragmented
		 * frames.
		 * TODO: The last fragment could still use multiple retry
		 * rates. */
559
		info->control.alt_retry_rate_idx = -1;
560 561 562 563 564
	}

	/* Use CTS protection for unicast frames sent using extended rates if
	 * there are associated non-ERP stations and RTS/CTS is not configured
	 * for the frame. */
565
	if ((tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) &&
566
	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_ERP_G) &&
567
	    (tx->flags & IEEE80211_TX_UNICAST) &&
568
	    tx->sdata->bss_conf.use_cts_prot &&
569 570
	    !(info->flags & IEEE80211_TX_CTL_USE_RTS_CTS))
		info->flags |= IEEE80211_TX_CTL_USE_CTS_PROTECT;
571

572 573 574
	/* Transmit data frames using short preambles if the driver supports
	 * short preambles at the selected rate and short preambles are
	 * available on the network at the current point in time. */
575
	if (ieee80211_is_data(hdr->frame_control) &&
576
	    (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
577
	    tx->sdata->bss_conf.use_short_preamble &&
578
	    (!tx->sta || test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))) {
579
		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
580 581
	}

582 583
	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) {
584 585
		struct ieee80211_rate *rate;
		s8 baserate = -1;
586 587
		int idx;

588
		/* Do not use multiple retry rates when using RTS/CTS */
589
		info->control.alt_retry_rate_idx = -1;
590 591

		/* Use min(data rate, max base rate) as CTS/RTS rate */
592
		rate = &sband->bitrates[tx->rate_idx];
593 594 595 596 597

		for (idx = 0; idx < sband->n_bitrates; idx++) {
			if (sband->bitrates[idx].bitrate > rate->bitrate)
				continue;
			if (tx->sdata->basic_rates & BIT(idx) &&
598 599 600 601
			    (baserate < 0 ||
			     (sband->bitrates[baserate].bitrate
			      < sband->bitrates[idx].bitrate)))
				baserate = idx;
602
		}
603

604
		if (baserate >= 0)
605
			info->control.rts_cts_rate_idx = baserate;
606
		else
607
			info->control.rts_cts_rate_idx = 0;
608 609
	}

610
	if (tx->sta)
611
		info->control.aid = tx->sta->aid;
612 613 614 615

	return TX_CONTINUE;
}

616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
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;
	u16 *seq;
	u8 *qc;
	int tid;

	/* only for injected frames */
	if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
		return TX_CONTINUE;

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

	if (!ieee80211_is_data_qos(hdr->frame_control)) {
		info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
		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;
	seq = &tx->sta->tid_seq[tid];

	hdr->seq_ctrl = cpu_to_le16(*seq);

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

	return TX_CONTINUE;
}

659
static ieee80211_tx_result debug_noinline
660 661
ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
{
662
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
663 664 665 666 667 668 669 670 671 672
	size_t hdrlen, per_fragm, num_fragm, payload_len, left;
	struct sk_buff **frags, *first, *frag;
	int i;
	u16 seq;
	u8 *pos;
	int frag_threshold = tx->local->fragmentation_threshold;

	if (!(tx->flags & IEEE80211_TX_FRAGMENTED))
		return TX_CONTINUE;

673 674
	/*
	 * Warn when submitting a fragmented A-MPDU frame and drop it.
675 676
	 * This scenario is handled in __ieee80211_tx_prepare but extra
	 * caution taken here as fragmented ampdu may cause Tx stop.
677 678
	 */
	if (WARN_ON(tx->flags & IEEE80211_TX_CTL_AMPDU ||
679 680
		    skb_get_queue_mapping(tx->skb) >=
			ieee80211_num_regular_queues(&tx->local->hw)))
681 682
		return TX_DROP;

683 684
	first = tx->skb;

685
	hdrlen = ieee80211_hdrlen(hdr->frame_control);
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
	payload_len = first->len - hdrlen;
	per_fragm = frag_threshold - hdrlen - FCS_LEN;
	num_fragm = DIV_ROUND_UP(payload_len, per_fragm);

	frags = kzalloc(num_fragm * sizeof(struct sk_buff *), GFP_ATOMIC);
	if (!frags)
		goto fail;

	hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
	seq = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ;
	pos = first->data + hdrlen + per_fragm;
	left = payload_len - per_fragm;
	for (i = 0; i < num_fragm - 1; i++) {
		struct ieee80211_hdr *fhdr;
		size_t copylen;

		if (left <= 0)
			goto fail;

		/* reserve enough extra head and tail room for possible
		 * encryption */
		frag = frags[i] =
			dev_alloc_skb(tx->local->tx_headroom +
				      frag_threshold +
				      IEEE80211_ENCRYPT_HEADROOM +
				      IEEE80211_ENCRYPT_TAILROOM);
		if (!frag)
			goto fail;
		/* Make sure that all fragments use the same priority so
		 * that they end up using the same TX queue */
		frag->priority = first->priority;
		skb_reserve(frag, tx->local->tx_headroom +
				  IEEE80211_ENCRYPT_HEADROOM);
		fhdr = (struct ieee80211_hdr *) skb_put(frag, hdrlen);
		memcpy(fhdr, first->data, hdrlen);
		if (i == num_fragm - 2)
			fhdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS);
		fhdr->seq_ctrl = cpu_to_le16(seq | ((i + 1) & IEEE80211_SCTL_FRAG));
		copylen = left > per_fragm ? per_fragm : left;
		memcpy(skb_put(frag, copylen), pos, copylen);
J
Johannes Berg 已提交
726 727
		memcpy(frag->cb, first->cb, sizeof(frag->cb));
		skb_copy_queue_mapping(frag, first);
728
		frag->do_not_encrypt = first->do_not_encrypt;
729 730 731

		pos += copylen;
		left -= copylen;
732
	}
733 734 735 736
	skb_trim(first, hdrlen + per_fragm);

	tx->num_extra_frag = num_fragm - 1;
	tx->extra_frag = frags;
737

738
	return TX_CONTINUE;
739 740 741 742 743 744 745 746 747 748

 fail:
	if (frags) {
		for (i = 0; i < num_fragm - 1; i++)
			if (frags[i])
				dev_kfree_skb(frags[i]);
		kfree(frags);
	}
	I802_DEBUG_INC(tx->local->tx_handlers_drop_fragment);
	return TX_DROP;
749 750
}

751
static ieee80211_tx_result debug_noinline
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
{
	if (!tx->key)
		return TX_CONTINUE;

	switch (tx->key->conf.alg) {
	case ALG_WEP:
		return ieee80211_crypto_wep_encrypt(tx);
	case ALG_TKIP:
		return ieee80211_crypto_tkip_encrypt(tx);
	case ALG_CCMP:
		return ieee80211_crypto_ccmp_encrypt(tx);
	}

	/* not reached */
	WARN_ON(1);
	return TX_DROP;
}

771
static ieee80211_tx_result debug_noinline
J
Johannes Berg 已提交
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
	int next_len, i;
	int group_addr = is_multicast_ether_addr(hdr->addr1);

	if (!(tx->flags & IEEE80211_TX_FRAGMENTED)) {
		hdr->duration_id = ieee80211_duration(tx, group_addr, 0);
		return TX_CONTINUE;
	}

	hdr->duration_id = ieee80211_duration(tx, group_addr,
					      tx->extra_frag[0]->len);

	for (i = 0; i < tx->num_extra_frag; i++) {
		if (i + 1 < tx->num_extra_frag) {
			next_len = tx->extra_frag[i + 1]->len;
		} else {
			next_len = 0;
			tx->rate_idx = tx->last_frag_rate_idx;
		}

		hdr = (struct ieee80211_hdr *)tx->extra_frag[i]->data;
		hdr->duration_id = ieee80211_duration(tx, 0, next_len);
	}

	return TX_CONTINUE;
}

801
static ieee80211_tx_result debug_noinline
802
ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
803
{
804
	int i;
805

806 807
	if (!tx->sta)
		return TX_CONTINUE;
808

809 810 811
	tx->sta->tx_packets++;
	tx->sta->tx_fragments++;
	tx->sta->tx_bytes += tx->skb->len;
812
	if (tx->extra_frag) {
813 814 815
		tx->sta->tx_fragments += tx->num_extra_frag;
		for (i = 0; i < tx->num_extra_frag; i++)
			tx->sta->tx_bytes += tx->extra_frag[i]->len;
816 817
	}

818
	return TX_CONTINUE;
819 820 821 822 823 824 825 826 827
}


/* actual transmit path */

/*
 * deal with packet injection down monitor interface
 * with Radiotap Header -- only called for monitor mode interface
 */
828
static ieee80211_tx_result
829
__ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
830
			      struct sk_buff *skb)
831 832 833 834 835 836 837 838 839 840 841 842
{
	/*
	 * this is the moment to interpret and discard the radiotap header that
	 * must be at the start of the packet injected in Monitor mode
	 *
	 * Need to take some care with endian-ness since radiotap
	 * args are little-endian
	 */

	struct ieee80211_radiotap_iterator iterator;
	struct ieee80211_radiotap_header *rthdr =
		(struct ieee80211_radiotap_header *) skb->data;
843
	struct ieee80211_supported_band *sband;
844
	int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len);
845
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
846

847
	sband = tx->local->hw.wiphy->bands[tx->channel->band];
848

849
	skb->do_not_encrypt = 1;
850
	info->flags |= IEEE80211_TX_CTL_INJECTED;
851
	tx->flags &= ~IEEE80211_TX_FRAGMENTED;
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880

	/*
	 * for every radiotap entry that is present
	 * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
	 * entries present, or -EINVAL on error)
	 */

	while (!ret) {
		int i, target_rate;

		ret = ieee80211_radiotap_iterator_next(&iterator);

		if (ret)
			continue;

		/* see if this argument is something we can use */
		switch (iterator.this_arg_index) {
		/*
		 * You must take care when dereferencing iterator.this_arg
		 * for multibyte types... the pointer is not aligned.  Use
		 * get_unaligned((type *)iterator.this_arg) to dereference
		 * iterator.this_arg for type "type" safely on all arches.
		*/
		case IEEE80211_RADIOTAP_RATE:
			/*
			 * radiotap rate u8 is in 500kbps units eg, 0x02=1Mbps
			 * ieee80211 rate int is in 100kbps units eg, 0x0a=1Mbps
			 */
			target_rate = (*iterator.this_arg) * 5;
881 882
			for (i = 0; i < sband->n_bitrates; i++) {
				struct ieee80211_rate *r;
883

884 885 886
				r = &sband->bitrates[i];

				if (r->bitrate == target_rate) {
887
					tx->rate_idx = i;
888 889
					break;
				}
890 891 892 893 894 895 896 897
			}
			break;

		case IEEE80211_RADIOTAP_ANTENNA:
			/*
			 * radiotap uses 0 for 1st ant, mac80211 is 1 for
			 * 1st ant
			 */
898
			info->antenna_sel_tx = (*iterator.this_arg) + 1;
899 900
			break;

901
#if 0
902 903 904
		case IEEE80211_RADIOTAP_DBM_TX_POWER:
			control->power_level = *iterator.this_arg;
			break;
905
#endif
906 907 908 909 910 911 912 913 914 915 916

		case IEEE80211_RADIOTAP_FLAGS:
			if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
				/*
				 * this indicates that the skb we have been
				 * handed has the 32-bit FCS CRC at the end...
				 * we should react to that by snipping it off
				 * because it will be recomputed and added
				 * on transmission
				 */
				if (skb->len < (iterator.max_length + FCS_LEN))
917
					return TX_DROP;
918 919 920

				skb_trim(skb, skb->len - FCS_LEN);
			}
921
			if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
922
				tx->skb->do_not_encrypt = 0;
923
			if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
924
				tx->flags |= IEEE80211_TX_FRAGMENTED;
925 926
			break;

927 928 929 930 931 932
		/*
		 * Please update the file
		 * Documentation/networking/mac80211-injection.txt
		 * when parsing new fields here.
		 */

933 934 935 936 937 938
		default:
			break;
		}
	}

	if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
939
		return TX_DROP;
940 941 942 943 944 945 946 947

	/*
	 * remove the radiotap header
	 * iterator->max_length was sanity-checked against
	 * skb->len by iterator init
	 */
	skb_pull(skb, iterator.max_length);

948
	return TX_CONTINUE;
949 950
}

951 952 953
/*
 * initialises @tx
 */
954
static ieee80211_tx_result
955
__ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
956
		       struct sk_buff *skb,
957
		       struct net_device *dev)
958 959
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
960
	struct ieee80211_hdr *hdr;
961
	struct ieee80211_sub_if_data *sdata;
962
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
963 964 965 966 967 968 969 970

	int hdrlen;

	memset(tx, 0, sizeof(*tx));
	tx->skb = skb;
	tx->dev = dev; /* use original interface */
	tx->local = local;
	tx->sdata = IEEE80211_DEV_TO_SUB_IF(dev);
971
	tx->channel = local->hw.conf.channel;
972 973
	tx->rate_idx = -1;
	tx->last_frag_rate_idx = -1;
974
	/*
975 976
	 * Set this flag (used below to indicate "automatic fragmentation"),
	 * it will be cleared/left by radiotap as desired.
977
	 */
978
	tx->flags |= IEEE80211_TX_FRAGMENTED;
979 980 981

	/* process and remove the injection radiotap header */
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
982
	if (unlikely(sdata->vif.type == IEEE80211_IF_TYPE_MNTR)) {
983 984
		if (__ieee80211_parse_tx_radiotap(tx, skb) == TX_DROP)
			return TX_DROP;
985

986
		/*
987 988 989
		 * __ieee80211_parse_tx_radiotap has now removed
		 * the radiotap header that was present and pre-filled
		 * 'tx' with tx control information.
990 991 992
		 */
	}

993 994
	hdr = (struct ieee80211_hdr *) skb->data;

995
	tx->sta = sta_info_get(local, hdr->addr1);
996

997
	if (is_multicast_ether_addr(hdr->addr1)) {
998
		tx->flags &= ~IEEE80211_TX_UNICAST;
999
		info->flags |= IEEE80211_TX_CTL_NO_ACK;
1000
	} else {
1001
		tx->flags |= IEEE80211_TX_UNICAST;
1002
		info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
1003
	}
1004

1005 1006
	if (tx->flags & IEEE80211_TX_FRAGMENTED) {
		if ((tx->flags & IEEE80211_TX_UNICAST) &&
1007
		    skb->len + FCS_LEN > local->fragmentation_threshold &&
1008 1009
		    !local->ops->set_frag_threshold &&
		    !(info->flags & IEEE80211_TX_CTL_AMPDU))
1010
			tx->flags |= IEEE80211_TX_FRAGMENTED;
1011
		else
1012
			tx->flags &= ~IEEE80211_TX_FRAGMENTED;
1013 1014
	}

1015
	if (!tx->sta)
1016
		info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1017
	else if (test_and_clear_sta_flags(tx->sta, WLAN_STA_CLEAR_PS_FILT))
1018
		info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1019

1020
	hdrlen = ieee80211_hdrlen(hdr->frame_control);
1021 1022 1023 1024
	if (skb->len > hdrlen + sizeof(rfc1042_header) + 2) {
		u8 *pos = &skb->data[hdrlen + sizeof(rfc1042_header)];
		tx->ethertype = (pos[0] << 8) | pos[1];
	}
1025
	info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
1026

1027
	return TX_CONTINUE;
1028 1029
}

1030
/*
1031 1032
 * NB: @tx is uninitialised when passed in here
 */
1033
static int ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
1034
				struct sk_buff *skb,
1035
				struct net_device *mdev)
1036 1037 1038
{
	struct net_device *dev;

1039
	dev = dev_get_by_index(&init_net, skb->iif);
1040 1041 1042 1043 1044 1045
	if (unlikely(dev && !is_ieee80211_device(dev, mdev))) {
		dev_put(dev);
		dev = NULL;
	}
	if (unlikely(!dev))
		return -ENODEV;
1046
	/* initialises tx with control */
1047
	__ieee80211_tx_prepare(tx, skb, dev);
1048
	dev_put(dev);
1049 1050 1051 1052
	return 0;
}

static int __ieee80211_tx(struct ieee80211_local *local, struct sk_buff *skb,
1053
			  struct ieee80211_tx_data *tx)
1054
{
1055
	struct ieee80211_tx_info *info;
1056 1057 1058
	int ret, i;

	if (skb) {
1059 1060 1061 1062
		if (netif_subqueue_stopped(local->mdev, skb))
			return IEEE80211_TX_AGAIN;
		info =  IEEE80211_SKB_CB(skb);

1063 1064
		ieee80211_dump_frame(wiphy_name(local->hw.wiphy),
				     "TX to low-level driver", skb);
1065
		ret = local->ops->tx(local_to_hw(local), skb);
1066 1067 1068 1069 1070
		if (ret)
			return IEEE80211_TX_AGAIN;
		local->mdev->trans_start = jiffies;
		ieee80211_led_tx(local, 1);
	}
1071 1072 1073
	if (tx->extra_frag) {
		for (i = 0; i < tx->num_extra_frag; i++) {
			if (!tx->extra_frag[i])
1074
				continue;
1075 1076 1077 1078 1079
			info = IEEE80211_SKB_CB(tx->extra_frag[i]);
			info->flags &= ~(IEEE80211_TX_CTL_USE_RTS_CTS |
					 IEEE80211_TX_CTL_USE_CTS_PROTECT |
					 IEEE80211_TX_CTL_CLEAR_PS_FILT |
					 IEEE80211_TX_CTL_FIRST_FRAGMENT);
1080 1081
			if (netif_subqueue_stopped(local->mdev,
						   tx->extra_frag[i]))
1082
				return IEEE80211_TX_FRAG_AGAIN;
1083
			if (i == tx->num_extra_frag) {
1084
				info->tx_rate_idx = tx->last_frag_rate_idx;
1085

1086
				if (tx->flags & IEEE80211_TX_PROBE_LAST_FRAG)
1087 1088
					info->flags |=
						IEEE80211_TX_CTL_RATE_CTRL_PROBE;
1089
				else
1090 1091
					info->flags &=
						~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
1092 1093
			}

1094
			ieee80211_dump_frame(wiphy_name(local->hw.wiphy),
1095
					     "TX to low-level driver",
1096
					     tx->extra_frag[i]);
1097
			ret = local->ops->tx(local_to_hw(local),
1098
					    tx->extra_frag[i]);
1099 1100 1101 1102
			if (ret)
				return IEEE80211_TX_FRAG_AGAIN;
			local->mdev->trans_start = jiffies;
			ieee80211_led_tx(local, 1);
1103
			tx->extra_frag[i] = NULL;
1104
		}
1105 1106
		kfree(tx->extra_frag);
		tx->extra_frag = NULL;
1107 1108 1109 1110
	}
	return IEEE80211_TX_OK;
}

1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
/*
 * Invoke TX handlers, return 0 on success and non-zero if the
 * frame was dropped or queued.
 */
static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
{
	struct sk_buff *skb = tx->skb;
	ieee80211_tx_result res = TX_DROP;
	int i;

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
#define CALL_TXH(txh)		\
	res = txh(tx);		\
	if (res != TX_CONTINUE)	\
		goto txh_done;

	CALL_TXH(ieee80211_tx_h_check_assoc)
	CALL_TXH(ieee80211_tx_h_ps_buf)
	CALL_TXH(ieee80211_tx_h_select_key)
	CALL_TXH(ieee80211_tx_h_michael_mic_add)
	CALL_TXH(ieee80211_tx_h_rate_ctrl)
	CALL_TXH(ieee80211_tx_h_misc)
1132
	CALL_TXH(ieee80211_tx_h_sequence)
1133 1134 1135 1136 1137 1138
	CALL_TXH(ieee80211_tx_h_fragment)
	/* handlers after fragment must be aware of tx info fragmentation! */
	CALL_TXH(ieee80211_tx_h_encrypt)
	CALL_TXH(ieee80211_tx_h_calculate_duration)
	CALL_TXH(ieee80211_tx_h_stats)
#undef CALL_TXH
1139

1140
 txh_done:
1141
	if (unlikely(res == TX_DROP)) {
1142
		I802_DEBUG_INC(tx->local->tx_handlers_drop);
1143 1144 1145 1146 1147 1148 1149
		dev_kfree_skb(skb);
		for (i = 0; i < tx->num_extra_frag; i++)
			if (tx->extra_frag[i])
				dev_kfree_skb(tx->extra_frag[i]);
		kfree(tx->extra_frag);
		return -1;
	} else if (unlikely(res == TX_QUEUED)) {
1150
		I802_DEBUG_INC(tx->local->tx_handlers_queued);
1151 1152 1153 1154 1155 1156
		return -1;
	}

	return 0;
}

1157
static int ieee80211_tx(struct net_device *dev, struct sk_buff *skb)
1158 1159 1160
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct sta_info *sta;
1161
	struct ieee80211_tx_data tx;
1162
	ieee80211_tx_result res_prepare;
1163
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1164
	int ret, i;
1165
	u16 queue;
1166

1167 1168 1169
	queue = skb_get_queue_mapping(skb);

	WARN_ON(test_bit(queue, local->queues_pending));
1170 1171 1172 1173 1174 1175

	if (unlikely(skb->len < 10)) {
		dev_kfree_skb(skb);
		return 0;
	}

1176 1177
	rcu_read_lock();

1178
	/* initialises tx */
1179
	res_prepare = __ieee80211_tx_prepare(&tx, skb, dev);
1180

1181
	if (res_prepare == TX_DROP) {
1182
		dev_kfree_skb(skb);
1183
		rcu_read_unlock();
1184 1185 1186 1187
		return 0;
	}

	sta = tx.sta;
1188
	tx.channel = local->hw.conf.channel;
1189
	info->band = tx.channel->band;
1190

1191 1192
	if (invoke_tx_handlers(&tx))
		goto out;
1193 1194 1195 1196

retry:
	ret = __ieee80211_tx(local, skb, &tx);
	if (ret) {
1197 1198 1199 1200 1201 1202 1203
		struct ieee80211_tx_stored_packet *store;

		/*
		 * Since there are no fragmented frames on A-MPDU
		 * queues, there's no reason for a driver to reject
		 * a frame there, warn and drop it.
		 */
1204
		if (WARN_ON(queue >= ieee80211_num_regular_queues(&local->hw)))
1205 1206 1207
			goto drop;

		store = &local->pending_packet[queue];
1208 1209 1210

		if (ret == IEEE80211_TX_FRAG_AGAIN)
			skb = NULL;
1211

1212
		set_bit(queue, local->queues_pending);
1213
		smp_mb();
1214 1215 1216 1217 1218
		/*
		 * When the driver gets out of buffers during sending of
		 * fragments and calls ieee80211_stop_queue, the netif
		 * subqueue is stopped. There is, however, a small window
		 * in which the PENDING bit is not yet set. If a buffer
1219 1220
		 * gets available in that window (i.e. driver calls
		 * ieee80211_wake_queue), we would end up with ieee80211_tx
1221
		 * called with the PENDING bit still set. Prevent this by
1222
		 * continuing transmitting here when that situation is
1223 1224 1225 1226
		 * possible to have happened.
		 */
		if (!__netif_subqueue_stopped(local->mdev, queue)) {
			clear_bit(queue, local->queues_pending);
1227 1228 1229
			goto retry;
		}
		store->skb = skb;
1230 1231
		store->extra_frag = tx.extra_frag;
		store->num_extra_frag = tx.num_extra_frag;
1232
		store->last_frag_rate_idx = tx.last_frag_rate_idx;
1233
		store->last_frag_rate_ctrl_probe =
1234
			!!(tx.flags & IEEE80211_TX_PROBE_LAST_FRAG);
1235
	}
1236
 out:
1237
	rcu_read_unlock();
1238 1239 1240 1241 1242
	return 0;

 drop:
	if (skb)
		dev_kfree_skb(skb);
1243 1244 1245 1246
	for (i = 0; i < tx.num_extra_frag; i++)
		if (tx.extra_frag[i])
			dev_kfree_skb(tx.extra_frag[i]);
	kfree(tx.extra_frag);
1247
	rcu_read_unlock();
1248 1249 1250 1251 1252
	return 0;
}

/* device xmit handlers */

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
static int ieee80211_skb_resize(struct ieee80211_local *local,
				struct sk_buff *skb,
				int head_need, bool may_encrypt)
{
	int tail_need = 0;

	/*
	 * This could be optimised, devices that do full hardware
	 * crypto (including TKIP MMIC) need no tailroom... But we
	 * have no drivers for such devices currently.
	 */
	if (may_encrypt) {
		tail_need = IEEE80211_ENCRYPT_TAILROOM;
		tail_need -= skb_tailroom(skb);
		tail_need = max_t(int, tail_need, 0);
	}

	if (head_need || tail_need) {
		/* Sorry. Can't account for this any more */
		skb_orphan(skb);
	}

	if (skb_header_cloned(skb))
		I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
	else
		I802_DEBUG_INC(local->tx_expand_skb_head);

	if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
		printk(KERN_DEBUG "%s: failed to reallocate TX buffer\n",
		       wiphy_name(local->hw.wiphy));
		return -ENOMEM;
	}

	/* update truesize too */
	skb->truesize += head_need + tail_need;

	return 0;
}

1292 1293 1294
int ieee80211_master_start_xmit(struct sk_buff *skb,
				struct net_device *dev)
{
1295
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1296
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1297 1298 1299
	struct net_device *odev = NULL;
	struct ieee80211_sub_if_data *osdata;
	int headroom;
1300
	bool may_encrypt;
1301 1302
	int ret;

1303 1304
	if (skb->iif)
		odev = dev_get_by_index(&init_net, skb->iif);
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
	if (unlikely(odev && !is_ieee80211_device(odev, dev))) {
		dev_put(odev);
		odev = NULL;
	}
	if (unlikely(!odev)) {
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
		printk(KERN_DEBUG "%s: Discarded packet with nonexistent "
		       "originating device\n", dev->name);
#endif
		dev_kfree_skb(skb);
		return 0;
	}
1317

1318 1319 1320 1321
	memset(info, 0, sizeof(*info));

	info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;

1322 1323
	osdata = IEEE80211_DEV_TO_SUB_IF(odev);

1324 1325 1326 1327 1328 1329
	if (ieee80211_vif_is_mesh(&osdata->vif) &&
	    ieee80211_is_data(hdr->frame_control)) {
		if (ieee80211_is_data(hdr->frame_control)) {
			if (is_multicast_ether_addr(hdr->addr3))
				memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
			else
1330
				if (mesh_nexthop_lookup(skb, osdata))
1331 1332 1333 1334 1335 1336 1337
					return  0;
			if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0)
				IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.sta,
							     fwded_frames);
		}
	}

1338
	may_encrypt = !skb->do_not_encrypt;
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349

	headroom = osdata->local->tx_headroom;
	if (may_encrypt)
		headroom += IEEE80211_ENCRYPT_HEADROOM;
	headroom -= skb_headroom(skb);
	headroom = max_t(int, 0, headroom);

	if (ieee80211_skb_resize(osdata->local, skb, headroom, may_encrypt)) {
		dev_kfree_skb(skb);
		dev_put(odev);
		return 0;
1350 1351
	}

1352 1353
	info->control.vif = &osdata->vif;
	ret = ieee80211_tx(odev, skb);
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
	dev_put(odev);

	return ret;
}

int ieee80211_monitor_start_xmit(struct sk_buff *skb,
				 struct net_device *dev)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_radiotap_header *prthdr =
		(struct ieee80211_radiotap_header *)skb->data;
1365
	u16 len_rthdr;
1366

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
	/* check for not even having the fixed radiotap header part */
	if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
		goto fail; /* too short to be possibly valid */

	/* is it a header version we can trust to find length from? */
	if (unlikely(prthdr->it_version))
		goto fail; /* only version 0 is supported */

	/* then there must be a radiotap header with a length we can use */
	len_rthdr = ieee80211_get_radiotap_len(skb->data);

	/* does the skb contain enough to deliver on the alleged length? */
	if (unlikely(skb->len < len_rthdr))
		goto fail; /* skb too short for claimed rt header extent */
1381 1382 1383

	skb->dev = local->mdev;

1384
	/* needed because we set skb device to master */
1385
	skb->iif = dev->ifindex;
1386

1387 1388 1389
	/* sometimes we do encrypt injected frames, will be fixed
	 * up in radiotap parser if not wanted */
	skb->do_not_encrypt = 0;
1390 1391 1392 1393 1394 1395 1396

	/*
	 * fix up the pointers accounting for the radiotap
	 * header still being in there.  We are being given
	 * a precooked IEEE80211 header so no need for
	 * normal processing
	 */
1397
	skb_set_mac_header(skb, len_rthdr);
1398
	/*
1399 1400
	 * these are just fixed to the end of the rt area since we
	 * don't have any better information and at this point, nobody cares
1401
	 */
1402 1403
	skb_set_network_header(skb, len_rthdr);
	skb_set_transport_header(skb, len_rthdr);
1404

1405 1406
	/* pass the radiotap header up to the next stage intact */
	dev_queue_xmit(skb);
1407
	return NETDEV_TX_OK;
1408 1409 1410 1411

fail:
	dev_kfree_skb(skb);
	return NETDEV_TX_OK; /* meaning, we dealt with the skb */
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
}

/**
 * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
 * subinterfaces (wlan#, WDS, and VLAN interfaces)
 * @skb: packet to be sent
 * @dev: incoming interface
 *
 * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
 * not be freed, and caller is responsible for either retrying later or freeing
 * skb).
 *
 * This function takes in an Ethernet header and encapsulates it with suitable
 * IEEE 802.11 header based on which interface the packet is coming in. The
 * encapsulated packet will then be passed to master interface, wlan#.11, for
 * transmission (through low-level driver).
 */
int ieee80211_subif_start_xmit(struct sk_buff *skb,
			       struct net_device *dev)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_sub_if_data *sdata;
	int ret = 1, head_need;
1435 1436
	u16 ethertype, hdrlen,  meshhdrlen = 0;
	__le16 fc;
1437
	struct ieee80211_hdr hdr;
1438
	struct ieee80211s_hdr mesh_hdr;
1439 1440
	const u8 *encaps_data;
	int encaps_len, skip_header_bytes;
1441
	int nh_pos, h_pos;
1442
	struct sta_info *sta;
1443
	u32 sta_flags = 0;
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	if (unlikely(skb->len < ETH_HLEN)) {
		ret = 0;
		goto fail;
	}

	nh_pos = skb_network_header(skb) - skb->data;
	h_pos = skb_transport_header(skb) - skb->data;

	/* convert Ethernet header to proper 802.11 header (based on
	 * operation mode) */
	ethertype = (skb->data[12] << 8) | skb->data[13];
1457
	fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
1458

1459
	switch (sdata->vif.type) {
1460 1461
	case IEEE80211_IF_TYPE_AP:
	case IEEE80211_IF_TYPE_VLAN:
1462
		fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
1463 1464 1465 1466 1467
		/* DA BSSID SA */
		memcpy(hdr.addr1, skb->data, ETH_ALEN);
		memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
		memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
		hdrlen = 24;
1468 1469
		break;
	case IEEE80211_IF_TYPE_WDS:
1470
		fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1471 1472 1473 1474 1475 1476
		/* RA TA DA SA */
		memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
		memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
		memcpy(hdr.addr3, skb->data, ETH_ALEN);
		memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
		hdrlen = 30;
1477
		break;
1478 1479
#ifdef CONFIG_MAC80211_MESH
	case IEEE80211_IF_TYPE_MESH_POINT:
1480
		fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
1481
		/* RA TA DA SA */
1482
		memset(hdr.addr1, 0, ETH_ALEN);
1483 1484 1485
		memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
		memcpy(hdr.addr3, skb->data, ETH_ALEN);
		memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
1486 1487 1488 1489 1490
		if (!sdata->u.sta.mshcfg.dot11MeshTTL) {
			/* Do not send frames with mesh_ttl == 0 */
			sdata->u.sta.mshstats.dropped_frames_ttl++;
			ret = 0;
			goto fail;
1491
		}
1492
		meshhdrlen = ieee80211_new_mesh_header(&mesh_hdr, sdata);
1493 1494 1495
		hdrlen = 30;
		break;
#endif
1496
	case IEEE80211_IF_TYPE_STA:
1497
		fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
1498 1499 1500 1501 1502
		/* BSSID SA DA */
		memcpy(hdr.addr1, sdata->u.sta.bssid, ETH_ALEN);
		memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
		memcpy(hdr.addr3, skb->data, ETH_ALEN);
		hdrlen = 24;
1503 1504
		break;
	case IEEE80211_IF_TYPE_IBSS:
1505 1506 1507 1508 1509
		/* DA SA BSSID */
		memcpy(hdr.addr1, skb->data, ETH_ALEN);
		memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
		memcpy(hdr.addr3, sdata->u.sta.bssid, ETH_ALEN);
		hdrlen = 24;
1510 1511
		break;
	default:
1512 1513 1514 1515
		ret = 0;
		goto fail;
	}

1516 1517 1518 1519 1520 1521
	/*
	 * There's no need to try to look up the destination
	 * if it is a multicast address (which can only happen
	 * in AP mode)
	 */
	if (!is_multicast_ether_addr(hdr.addr1)) {
1522
		rcu_read_lock();
1523
		sta = sta_info_get(local, hdr.addr1);
1524
		if (sta)
1525
			sta_flags = get_sta_flags(sta);
1526
		rcu_read_unlock();
1527 1528
	}

1529
	/* receiver and we are QoS enabled, use a QoS type frame */
1530 1531
	if (sta_flags & WLAN_STA_WME &&
	    ieee80211_num_regular_queues(&local->hw) >= 4) {
1532
		fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1533 1534 1535 1536
		hdrlen += 2;
	}

	/*
1537 1538
	 * Drop unicast frames to unauthorised stations unless they are
	 * EAPOL frames from the local station.
1539
	 */
1540 1541
	if (!ieee80211_vif_is_mesh(&sdata->vif) &&
		unlikely(!is_multicast_ether_addr(hdr.addr1) &&
1542 1543
		      !(sta_flags & WLAN_STA_AUTHORIZED) &&
		      !(ethertype == ETH_P_PAE &&
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
		       compare_ether_addr(dev->dev_addr,
					  skb->data + ETH_ALEN) == 0))) {
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
		DECLARE_MAC_BUF(mac);

		if (net_ratelimit())
			printk(KERN_DEBUG "%s: dropped frame to %s"
			       " (unauthorized port)\n", dev->name,
			       print_mac(mac, hdr.addr1));
#endif

		I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);

		ret = 0;
		goto fail;
	}

1561
	hdr.frame_control = fc;
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
	hdr.duration_id = 0;
	hdr.seq_ctrl = 0;

	skip_header_bytes = ETH_HLEN;
	if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
		encaps_data = bridge_tunnel_header;
		encaps_len = sizeof(bridge_tunnel_header);
		skip_header_bytes -= 2;
	} else if (ethertype >= 0x600) {
		encaps_data = rfc1042_header;
		encaps_len = sizeof(rfc1042_header);
		skip_header_bytes -= 2;
	} else {
		encaps_data = NULL;
		encaps_len = 0;
	}

	skb_pull(skb, skip_header_bytes);
	nh_pos -= skip_header_bytes;
	h_pos -= skip_header_bytes;

	/* TODO: implement support for fragments so that there is no need to
	 * reallocate and copy payload; it might be enough to support one
	 * extra fragment that would be copied in the beginning of the frame
	 * data.. anyway, it would be nice to include this into skb structure
	 * somehow
	 *
	 * There are few options for this:
	 * use skb->cb as an extra space for 802.11 header
	 * allocate new buffer if not enough headroom
	 * make sure that there is enough headroom in every skb by increasing
	 * build in headroom in __dev_alloc_skb() (linux/skbuff.h) and
	 * alloc_skb() (net/core/skbuff.c)
	 */
1596
	head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
1597

1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
	/*
	 * So we need to modify the skb header and hence need a copy of
	 * that. The head_need variable above doesn't, so far, include
	 * the needed header space that we don't need right away. If we
	 * can, then we don't reallocate right now but only after the
	 * frame arrives at the master device (if it does...)
	 *
	 * If we cannot, however, then we will reallocate to include all
	 * the ever needed space. Also, if we need to reallocate it anyway,
	 * make it big enough for everything we may ever need.
	 */
1609

1610
	if (head_need > 0 || skb_cloned(skb)) {
1611 1612 1613 1614
		head_need += IEEE80211_ENCRYPT_HEADROOM;
		head_need += local->tx_headroom;
		head_need = max_t(int, 0, head_need);
		if (ieee80211_skb_resize(local, skb, head_need, true))
1615 1616 1617 1618 1619 1620 1621 1622
			goto fail;
	}

	if (encaps_data) {
		memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
		nh_pos += encaps_len;
		h_pos += encaps_len;
	}
1623

1624 1625 1626 1627 1628 1629
	if (meshhdrlen > 0) {
		memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
		nh_pos += meshhdrlen;
		h_pos += meshhdrlen;
	}

1630
	if (ieee80211_is_data_qos(fc)) {
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
		__le16 *qos_control;

		qos_control = (__le16*) skb_push(skb, 2);
		memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
		/*
		 * Maybe we could actually set some fields here, for now just
		 * initialise to zero to indicate no special operation.
		 */
		*qos_control = 0;
	} else
		memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);

1643 1644 1645
	nh_pos += hdrlen;
	h_pos += hdrlen;

1646
	skb->iif = dev->ifindex;
1647

1648
	skb->dev = local->mdev;
1649 1650
	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671

	/* Update skb pointers to various headers since this modified frame
	 * is going to go through Linux networking code that may potentially
	 * need things like pointer to IP header. */
	skb_set_mac_header(skb, 0);
	skb_set_network_header(skb, nh_pos);
	skb_set_transport_header(skb, h_pos);

	dev->trans_start = jiffies;
	dev_queue_xmit(skb);

	return 0;

 fail:
	if (!ret)
		dev_kfree_skb(skb);

	return ret;
}


1672 1673 1674 1675
/*
 * ieee80211_clear_tx_pending may not be called in a context where
 * it is possible that it packets could come in again.
 */
1676 1677 1678 1679 1680
void ieee80211_clear_tx_pending(struct ieee80211_local *local)
{
	int i, j;
	struct ieee80211_tx_stored_packet *store;

1681 1682
	for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) {
		if (!test_bit(i, local->queues_pending))
1683 1684 1685 1686 1687 1688
			continue;
		store = &local->pending_packet[i];
		kfree_skb(store->skb);
		for (j = 0; j < store->num_extra_frag; j++)
			kfree_skb(store->extra_frag[j]);
		kfree(store->extra_frag);
1689
		clear_bit(i, local->queues_pending);
1690 1691 1692
	}
}

1693 1694 1695 1696
/*
 * Transmit all pending packets. Called from tasklet, locks master device
 * TX lock so that no new packets can come in.
 */
1697 1698 1699 1700 1701
void ieee80211_tx_pending(unsigned long data)
{
	struct ieee80211_local *local = (struct ieee80211_local *)data;
	struct net_device *dev = local->mdev;
	struct ieee80211_tx_stored_packet *store;
1702
	struct ieee80211_tx_data tx;
1703
	int i, ret;
1704 1705

	netif_tx_lock_bh(dev);
1706 1707
	for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) {
		/* Check that this queue is ok */
1708 1709
		if (__netif_subqueue_stopped(local->mdev, i) &&
		    !test_bit(i, local->queues_pending_run))
1710
			continue;
1711 1712

		if (!test_bit(i, local->queues_pending)) {
1713
			clear_bit(i, local->queues_pending_run);
1714
			ieee80211_wake_queue(&local->hw, i);
1715 1716
			continue;
		}
1717

1718 1719 1720
		clear_bit(i, local->queues_pending_run);
		netif_start_subqueue(local->mdev, i);

1721
		store = &local->pending_packet[i];
1722 1723
		tx.extra_frag = store->extra_frag;
		tx.num_extra_frag = store->num_extra_frag;
1724
		tx.last_frag_rate_idx = store->last_frag_rate_idx;
1725 1726
		tx.flags = 0;
		if (store->last_frag_rate_ctrl_probe)
1727
			tx.flags |= IEEE80211_TX_PROBE_LAST_FRAG;
1728 1729 1730 1731 1732
		ret = __ieee80211_tx(local, store->skb, &tx);
		if (ret) {
			if (ret == IEEE80211_TX_FRAG_AGAIN)
				store->skb = NULL;
		} else {
1733 1734
			clear_bit(i, local->queues_pending);
			ieee80211_wake_queue(&local->hw, i);
1735 1736 1737 1738 1739 1740 1741 1742 1743
		}
	}
	netif_tx_unlock_bh(dev);
}

/* functions for drivers to get certain frames */

static void ieee80211_beacon_add_tim(struct ieee80211_local *local,
				     struct ieee80211_if_ap *bss,
1744 1745
				     struct sk_buff *skb,
				     struct beacon_data *beacon)
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
{
	u8 *pos, *tim;
	int aid0 = 0;
	int i, have_bits = 0, n1, n2;

	/* Generate bitmap for TIM only if there are any STAs in power save
	 * mode. */
	if (atomic_read(&bss->num_sta_ps) > 0)
		/* in the hope that this is faster than
		 * checking byte-for-byte */
		have_bits = !bitmap_empty((unsigned long*)bss->tim,
					  IEEE80211_MAX_AID+1);

	if (bss->dtim_count == 0)
1760
		bss->dtim_count = beacon->dtim_period - 1;
1761 1762 1763 1764 1765 1766 1767
	else
		bss->dtim_count--;

	tim = pos = (u8 *) skb_put(skb, 6);
	*pos++ = WLAN_EID_TIM;
	*pos++ = 4;
	*pos++ = bss->dtim_count;
1768
	*pos++ = beacon->dtim_period;
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804

	if (bss->dtim_count == 0 && !skb_queue_empty(&bss->ps_bc_buf))
		aid0 = 1;

	if (have_bits) {
		/* Find largest even number N1 so that bits numbered 1 through
		 * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
		 * (N2 + 1) x 8 through 2007 are 0. */
		n1 = 0;
		for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) {
			if (bss->tim[i]) {
				n1 = i & 0xfe;
				break;
			}
		}
		n2 = n1;
		for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
			if (bss->tim[i]) {
				n2 = i;
				break;
			}
		}

		/* Bitmap control */
		*pos++ = n1 | aid0;
		/* Part Virt Bitmap */
		memcpy(pos, bss->tim + n1, n2 - n1 + 1);

		tim[1] = n2 - n1 + 4;
		skb_put(skb, n2 - n1);
	} else {
		*pos++ = aid0; /* Bitmap control */
		*pos++ = 0; /* Part Virt Bitmap */
	}
}

1805
struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
1806
				     struct ieee80211_vif *vif)
1807 1808
{
	struct ieee80211_local *local = hw_to_local(hw);
1809
	struct sk_buff *skb = NULL;
1810
	struct ieee80211_tx_info *info;
1811 1812 1813
	struct net_device *bdev;
	struct ieee80211_sub_if_data *sdata = NULL;
	struct ieee80211_if_ap *ap = NULL;
1814
	struct ieee80211_if_sta *ifsta = NULL;
1815
	struct rate_selection rsel;
1816
	struct beacon_data *beacon;
1817
	struct ieee80211_supported_band *sband;
J
Johannes Berg 已提交
1818
	struct ieee80211_mgmt *mgmt;
1819
	int *num_beacons;
1820
	enum ieee80211_band band = local->hw.conf.channel->band;
J
Johannes Berg 已提交
1821
	u8 *pos;
1822

1823
	sband = local->hw.wiphy->bands[band];
1824 1825

	rcu_read_lock();
1826

1827 1828
	sdata = vif_to_sdata(vif);
	bdev = sdata->dev;
1829

J
Johannes Berg 已提交
1830
	if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
1831 1832
		ap = &sdata->u.ap;
		beacon = rcu_dereference(ap->beacon);
J
Johannes Berg 已提交
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
		if (ap && beacon) {
			/*
			 * headroom, head length,
			 * tail length and maximum TIM length
			 */
			skb = dev_alloc_skb(local->tx_headroom +
					    beacon->head_len +
					    beacon->tail_len + 256);
			if (!skb)
				goto out;
1843

J
Johannes Berg 已提交
1844 1845 1846
			skb_reserve(skb, local->tx_headroom);
			memcpy(skb_put(skb, beacon->head_len), beacon->head,
			       beacon->head_len);
1847

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
			/*
			 * Not very nice, but we want to allow the driver to call
			 * ieee80211_beacon_get() as a response to the set_tim()
			 * callback. That, however, is already invoked under the
			 * sta_lock to guarantee consistent and race-free update
			 * of the tim bitmap in mac80211 and the driver.
			 */
			if (local->tim_in_locked_section) {
				ieee80211_beacon_add_tim(local, ap, skb, beacon);
			} else {
				unsigned long flags;

				spin_lock_irqsave(&local->sta_lock, flags);
				ieee80211_beacon_add_tim(local, ap, skb, beacon);
				spin_unlock_irqrestore(&local->sta_lock, flags);
			}
1864

J
Johannes Berg 已提交
1865 1866 1867
			if (beacon->tail)
				memcpy(skb_put(skb, beacon->tail_len),
				       beacon->tail, beacon->tail_len);
1868

J
Johannes Berg 已提交
1869
			num_beacons = &ap->num_beacons;
1870 1871 1872 1873 1874
		} else
			goto out;
	} else if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
		struct ieee80211_hdr *hdr;
		ifsta = &sdata->u.sta;
1875

1876 1877 1878 1879 1880 1881 1882 1883
		if (!ifsta->probe_resp)
			goto out;

		skb = skb_copy(ifsta->probe_resp, GFP_ATOMIC);
		if (!skb)
			goto out;

		hdr = (struct ieee80211_hdr *) skb->data;
1884 1885
		hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
						 IEEE80211_STYPE_BEACON);
1886 1887

		num_beacons = &ifsta->num_beacons;
J
Johannes Berg 已提交
1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
		/* headroom, head length, tail length and maximum TIM length */
		skb = dev_alloc_skb(local->tx_headroom + 400);
		if (!skb)
			goto out;

		skb_reserve(skb, local->hw.extra_tx_headroom);
		mgmt = (struct ieee80211_mgmt *)
			skb_put(skb, 24 + sizeof(mgmt->u.beacon));
		memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
1898 1899
		mgmt->frame_control =
		    cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
J
Johannes Berg 已提交
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
		memset(mgmt->da, 0xff, ETH_ALEN);
		memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
		/* BSSID is left zeroed, wildcard value */
		mgmt->u.beacon.beacon_int =
			cpu_to_le16(local->hw.conf.beacon_int);
		mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */

		pos = skb_put(skb, 2);
		*pos++ = WLAN_EID_SSID;
		*pos++ = 0x0;

1911
		mesh_mgmt_ies_add(skb, sdata);
1912 1913

		num_beacons = &sdata->u.sta.num_beacons;
1914 1915
	} else {
		WARN_ON(1);
1916
		goto out;
1917 1918
	}

1919 1920
	info = IEEE80211_SKB_CB(skb);

1921 1922
	skb->do_not_encrypt = 1;

1923 1924
	info->band = band;
	rate_control_get_rate(local->mdev, sband, skb, &rsel);
1925

1926 1927 1928 1929 1930 1931
	if (unlikely(rsel.rate_idx < 0)) {
		if (net_ratelimit()) {
			printk(KERN_DEBUG "%s: ieee80211_beacon_get: "
			       "no rate found\n",
			       wiphy_name(local->hw.wiphy));
		}
1932
		dev_kfree_skb_any(skb);
1933 1934
		skb = NULL;
		goto out;
1935
	}
1936 1937 1938

	info->control.vif = vif;
	info->tx_rate_idx = rsel.rate_idx;
1939 1940 1941 1942

	info->flags |= IEEE80211_TX_CTL_NO_ACK;
	info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
	info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
1943 1944 1945
	if (sdata->bss_conf.use_short_preamble &&
	    sband->bitrates[rsel.rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE)
		info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE;
1946

1947 1948
	info->antenna_sel_tx = local->hw.conf.antenna_sel_tx;
	info->control.retry_limit = 1;
1949

1950 1951
	(*num_beacons)++;
out:
1952
	rcu_read_unlock();
1953 1954 1955 1956
	return skb;
}
EXPORT_SYMBOL(ieee80211_beacon_get);

1957
void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1958
		       const void *frame, size_t frame_len,
1959
		       const struct ieee80211_tx_info *frame_txctl,
1960 1961 1962 1963
		       struct ieee80211_rts *rts)
{
	const struct ieee80211_hdr *hdr = frame;

1964 1965
	rts->frame_control =
	    cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
1966 1967
	rts->duration = ieee80211_rts_duration(hw, vif, frame_len,
					       frame_txctl);
1968 1969 1970 1971 1972
	memcpy(rts->ra, hdr->addr1, sizeof(rts->ra));
	memcpy(rts->ta, hdr->addr2, sizeof(rts->ta));
}
EXPORT_SYMBOL(ieee80211_rts_get);

1973
void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1974
			     const void *frame, size_t frame_len,
1975
			     const struct ieee80211_tx_info *frame_txctl,
1976 1977 1978 1979
			     struct ieee80211_cts *cts)
{
	const struct ieee80211_hdr *hdr = frame;

1980 1981
	cts->frame_control =
	    cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
1982 1983
	cts->duration = ieee80211_ctstoself_duration(hw, vif,
						     frame_len, frame_txctl);
1984 1985 1986 1987 1988
	memcpy(cts->ra, hdr->addr1, sizeof(cts->ra));
}
EXPORT_SYMBOL(ieee80211_ctstoself_get);

struct sk_buff *
1989
ieee80211_get_buffered_bc(struct ieee80211_hw *hw,
1990
			  struct ieee80211_vif *vif)
1991 1992
{
	struct ieee80211_local *local = hw_to_local(hw);
1993
	struct sk_buff *skb = NULL;
1994
	struct sta_info *sta;
1995
	struct ieee80211_tx_data tx;
1996 1997 1998
	struct net_device *bdev;
	struct ieee80211_sub_if_data *sdata;
	struct ieee80211_if_ap *bss = NULL;
1999
	struct beacon_data *beacon;
2000
	struct ieee80211_tx_info *info;
2001

2002 2003
	sdata = vif_to_sdata(vif);
	bdev = sdata->dev;
2004
	bss = &sdata->u.ap;
2005 2006

	if (!bss)
2007 2008
		return NULL;

2009 2010 2011
	rcu_read_lock();
	beacon = rcu_dereference(bss->beacon);

2012 2013
	if (sdata->vif.type != IEEE80211_IF_TYPE_AP || !beacon || !beacon->head)
		goto out;
2014

2015
	if (bss->dtim_count != 0)
2016
		goto out; /* send buffered bc/mc only after DTIM beacon */
2017

2018 2019 2020
	while (1) {
		skb = skb_dequeue(&bss->ps_bc_buf);
		if (!skb)
2021
			goto out;
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
		local->total_ps_buffered--;

		if (!skb_queue_empty(&bss->ps_bc_buf) && skb->len >= 2) {
			struct ieee80211_hdr *hdr =
				(struct ieee80211_hdr *) skb->data;
			/* more buffered multicast/broadcast frames ==> set
			 * MoreData flag in IEEE 802.11 header to inform PS
			 * STAs */
			hdr->frame_control |=
				cpu_to_le16(IEEE80211_FCTL_MOREDATA);
		}

2034
		if (!ieee80211_tx_prepare(&tx, skb, local->mdev))
2035 2036 2037
			break;
		dev_kfree_skb_any(skb);
	}
2038 2039 2040

	info = IEEE80211_SKB_CB(skb);

2041
	sta = tx.sta;
2042 2043
	tx.flags |= IEEE80211_TX_PS_BUFFERED;
	tx.channel = local->hw.conf.channel;
2044
	info->band = tx.channel->band;
2045

2046
	if (invoke_tx_handlers(&tx))
2047
		skb = NULL;
2048
 out:
2049
	rcu_read_unlock();
2050 2051 2052 2053

	return skb;
}
EXPORT_SYMBOL(ieee80211_get_buffered_bc);