xmit.c 21.6 KB
Newer Older
1
2
3
4
5
6
7
/*

  Broadcom B43 wireless driver

  Transmission (TX/RX) related functions.

  Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
8
  Copyright (C) 2005 Stefano Brivio <stefano.brivio@polimi.it>
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
  Copyright (C) 2005, 2006 Michael Buesch <mb@bu3sch.de>
  Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
  Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; see the file COPYING.  If not, write to
  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  Boston, MA 02110-1301, USA.

*/

30
#include "xmit.h"
31
#include "phy_common.h"
32
#include "dma.h"
33
#include "pio.h"
Michael Buesch's avatar
Michael Buesch committed
34

35

36
37
/* Extract the bitrate index out of a CCK PLCP header. */
static int b43_plcp_get_bitrate_idx_cck(struct b43_plcp_hdr6 *plcp)
38
39
40
{
	switch (plcp->raw[0]) {
	case 0x0A:
41
		return 0;
42
	case 0x14:
43
		return 1;
44
	case 0x37:
45
		return 2;
46
	case 0x6E:
47
		return 3;
48
	}
49
	return -1;
50
51
}

52
/* Extract the bitrate index out of an OFDM PLCP header. */
53
static int b43_plcp_get_bitrate_idx_ofdm(struct b43_plcp_hdr6 *plcp, bool aphy)
54
{
55
56
	int base = aphy ? 0 : 4;

57
58
	switch (plcp->raw[0] & 0xF) {
	case 0xB:
59
		return base + 0;
60
	case 0xF:
61
		return base + 1;
62
	case 0xA:
63
		return base + 2;
64
	case 0xE:
65
		return base + 3;
66
	case 0x9:
67
		return base + 4;
68
	case 0xD:
69
		return base + 5;
70
	case 0x8:
71
		return base + 6;
72
	case 0xC:
73
		return base + 7;
74
	}
75
	return -1;
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
}

u8 b43_plcp_get_ratecode_cck(const u8 bitrate)
{
	switch (bitrate) {
	case B43_CCK_RATE_1MB:
		return 0x0A;
	case B43_CCK_RATE_2MB:
		return 0x14;
	case B43_CCK_RATE_5MB:
		return 0x37;
	case B43_CCK_RATE_11MB:
		return 0x6E;
	}
	B43_WARN_ON(1);
	return 0;
}

u8 b43_plcp_get_ratecode_ofdm(const u8 bitrate)
{
	switch (bitrate) {
	case B43_OFDM_RATE_6MB:
		return 0xB;
	case B43_OFDM_RATE_9MB:
		return 0xF;
	case B43_OFDM_RATE_12MB:
		return 0xA;
	case B43_OFDM_RATE_18MB:
		return 0xE;
	case B43_OFDM_RATE_24MB:
		return 0x9;
	case B43_OFDM_RATE_36MB:
		return 0xD;
	case B43_OFDM_RATE_48MB:
		return 0x8;
	case B43_OFDM_RATE_54MB:
		return 0xC;
	}
	B43_WARN_ON(1);
	return 0;
}

void b43_generate_plcp_hdr(struct b43_plcp_hdr4 *plcp,
			   const u16 octets, const u8 bitrate)
{
	__u8 *raw = plcp->raw;

	if (b43_is_ofdm_rate(bitrate)) {
Michael Buesch's avatar
Michael Buesch committed
124
125
126
		u32 d;

		d = b43_plcp_get_ratecode_ofdm(bitrate);
127
		B43_WARN_ON(octets & 0xF000);
Michael Buesch's avatar
Michael Buesch committed
128
		d |= (octets << 5);
129
		plcp->data = cpu_to_le32(d);
130
131
132
133
134
135
136
137
138
139
140
141
142
	} else {
		u32 plen;

		plen = octets * 16 / bitrate;
		if ((octets * 16 % bitrate) > 0) {
			plen++;
			if ((bitrate == B43_CCK_RATE_11MB)
			    && ((octets * 8 % 11) < 4)) {
				raw[1] = 0x84;
			} else
				raw[1] = 0x04;
		} else
			raw[1] = 0x04;
143
		plcp->data |= cpu_to_le32(plen << 16);
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
		raw[0] = b43_plcp_get_ratecode_cck(bitrate);
	}
}

static u8 b43_calc_fallback_rate(u8 bitrate)
{
	switch (bitrate) {
	case B43_CCK_RATE_1MB:
		return B43_CCK_RATE_1MB;
	case B43_CCK_RATE_2MB:
		return B43_CCK_RATE_1MB;
	case B43_CCK_RATE_5MB:
		return B43_CCK_RATE_2MB;
	case B43_CCK_RATE_11MB:
		return B43_CCK_RATE_5MB;
	case B43_OFDM_RATE_6MB:
		return B43_CCK_RATE_5MB;
	case B43_OFDM_RATE_9MB:
		return B43_OFDM_RATE_6MB;
	case B43_OFDM_RATE_12MB:
		return B43_OFDM_RATE_9MB;
	case B43_OFDM_RATE_18MB:
		return B43_OFDM_RATE_12MB;
	case B43_OFDM_RATE_24MB:
		return B43_OFDM_RATE_18MB;
	case B43_OFDM_RATE_36MB:
		return B43_OFDM_RATE_24MB;
	case B43_OFDM_RATE_48MB:
		return B43_OFDM_RATE_36MB;
	case B43_OFDM_RATE_54MB:
		return B43_OFDM_RATE_48MB;
	}
	B43_WARN_ON(1);
	return 0;
}

180
/* Generate a TX data header. */
181
182
int b43_generate_txhdr(struct b43_wldev *dev,
		       u8 *_txhdr,
gregor kowski's avatar
gregor kowski committed
183
		       struct sk_buff *skb_frag,
184
		       struct ieee80211_tx_info *info,
185
		       u16 cookie)
186
{
gregor kowski's avatar
gregor kowski committed
187
188
	const unsigned char *fragment_data = skb_frag->data;
	unsigned int fragment_len = skb_frag->len;
189
	struct b43_txhdr *txhdr = (struct b43_txhdr *)_txhdr;
190
191
192
	const struct b43_phy *phy = &dev->phy;
	const struct ieee80211_hdr *wlhdr =
	    (const struct ieee80211_hdr *)fragment_data;
193
	int use_encryption = !!info->control.hw_key;
194
	__le16 fctl = wlhdr->frame_control;
195
	struct ieee80211_rate *fbrate;
196
197
198
199
200
201
	u8 rate, rate_fb;
	int rate_ofdm, rate_fb_ofdm;
	unsigned int plcp_fragment_len;
	u32 mac_ctl = 0;
	u16 phy_ctl = 0;
	u8 extra_ft = 0;
202
	struct ieee80211_rate *txrate;
203
	struct ieee80211_tx_rate *rates;
204
205
206

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

207
	txrate = ieee80211_get_tx_rate(dev->wl->hw, info);
208
	rate = txrate ? txrate->hw_value : B43_CCK_RATE_1MB;
209
	rate_ofdm = b43_is_ofdm_rate(rate);
210
	fbrate = ieee80211_get_alt_retry_rate(dev->wl->hw, info, 0) ? : txrate;
211
	rate_fb = fbrate->hw_value;
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
	rate_fb_ofdm = b43_is_ofdm_rate(rate_fb);

	if (rate_ofdm)
		txhdr->phy_rate = b43_plcp_get_ratecode_ofdm(rate);
	else
		txhdr->phy_rate = b43_plcp_get_ratecode_cck(rate);
	txhdr->mac_frame_ctl = wlhdr->frame_control;
	memcpy(txhdr->tx_receiver, wlhdr->addr1, 6);

	/* Calculate duration for fallback rate */
	if ((rate_fb == rate) ||
	    (wlhdr->duration_id & cpu_to_le16(0x8000)) ||
	    (wlhdr->duration_id == cpu_to_le16(0))) {
		/* If the fallback rate equals the normal rate or the
		 * dur_id field contains an AID, CFP magic or 0,
		 * use the original dur_id field. */
		txhdr->dur_fb = wlhdr->duration_id;
	} else {
230
231
		txhdr->dur_fb = ieee80211_generic_frame_duration(
			dev->wl->hw, info->control.vif, fragment_len, fbrate);
232
233
234
235
	}

	plcp_fragment_len = fragment_len + FCS_LEN;
	if (use_encryption) {
236
		u8 key_idx = info->control.hw_key->hw_key_idx;
237
238
239
240
		struct b43_key *key;
		int wlhdr_len;
		size_t iv_len;

241
		B43_WARN_ON(key_idx >= ARRAY_SIZE(dev->key));
242
		key = &(dev->key[key_idx]);
Michael Buesch's avatar
Michael Buesch committed
243

244
245
246
247
248
249
250
		if (unlikely(!key->keyconf)) {
			/* This key is invalid. This might only happen
			 * in a short timeframe after machine resume before
			 * we were able to reconfigure keys.
			 * Drop this packet completely. Do not transmit it
			 * unencrypted to avoid leaking information. */
			return -ENOKEY;
Michael Buesch's avatar
Michael Buesch committed
251
		}
252
253

		/* Hardware appends ICV. */
254
		plcp_fragment_len += info->control.hw_key->icv_len;
255
256
257
258
259
260

		key_idx = b43_kidx_to_fw(dev, key_idx);
		mac_ctl |= (key_idx << B43_TXH_MAC_KEYIDX_SHIFT) &
			   B43_TXH_MAC_KEYIDX;
		mac_ctl |= (key->algorithm << B43_TXH_MAC_KEYALG_SHIFT) &
			   B43_TXH_MAC_KEYALG;
261
		wlhdr_len = ieee80211_hdrlen(fctl);
gregor kowski's avatar
gregor kowski committed
262
263
264
265
266
267
268
269
		if (key->algorithm == B43_SEC_ALGO_TKIP) {
			u16 phase1key[5];
			int i;
			/* we give the phase1key and iv16 here, the key is stored in
			 * shm. With that the hardware can do phase 2 and encryption.
			 */
			ieee80211_get_tkip_key(info->control.hw_key, skb_frag,
					IEEE80211_TKIP_P1_KEY, (u8*)phase1key);
270
271
272
273
274
			/* phase1key is in host endian. Copy to little-endian txhdr->iv. */
			for (i = 0; i < 5; i++) {
				txhdr->iv[i * 2 + 0] = phase1key[i];
				txhdr->iv[i * 2 + 1] = phase1key[i] >> 8;
			}
gregor kowski's avatar
gregor kowski committed
275
276
277
278
279
280
281
			/* iv16 */
			memcpy(txhdr->iv + 10, ((u8 *) wlhdr) + wlhdr_len, 3);
		} else {
			iv_len = min((size_t) info->control.hw_key->iv_len,
				     ARRAY_SIZE(txhdr->iv));
			memcpy(txhdr->iv, ((u8 *) wlhdr) + wlhdr_len, iv_len);
		}
282
	}
283
284
285
286
287
288
289
	if (b43_is_old_txhdr_format(dev)) {
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->old_format.plcp),
				      plcp_fragment_len, rate);
	} else {
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->new_format.plcp),
				      plcp_fragment_len, rate);
	}
290
291
292
293
294
	b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->plcp_fb),
			      plcp_fragment_len, rate_fb);

	/* Extra Frame Types */
	if (rate_fb_ofdm)
295
296
297
		extra_ft |= B43_TXH_EFT_FB_OFDM;
	else
		extra_ft |= B43_TXH_EFT_FB_CCK;
298
299
300
301
302
303
304
305
306

	/* Set channel radio code. Note that the micrcode ORs 0x100 to
	 * this value before comparing it to the value in SHM, if this
	 * is a 5Ghz packet.
	 */
	txhdr->chan_radio_code = phy->channel;

	/* PHY TX Control word */
	if (rate_ofdm)
307
308
309
		phy_ctl |= B43_TXH_PHY_ENC_OFDM;
	else
		phy_ctl |= B43_TXH_PHY_ENC_CCK;
310
	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
311
		phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
312

313
	switch (b43_ieee80211_antenna_sanitize(dev, info->antenna_sel_tx)) {
314
	case 0: /* Default */
315
		phy_ctl |= B43_TXH_PHY_ANT01AUTO;
316
		break;
317
	case 1: /* Antenna 0 */
318
		phy_ctl |= B43_TXH_PHY_ANT0;
319
		break;
320
	case 2: /* Antenna 1 */
321
322
323
324
325
326
327
		phy_ctl |= B43_TXH_PHY_ANT1;
		break;
	case 3: /* Antenna 2 */
		phy_ctl |= B43_TXH_PHY_ANT2;
		break;
	case 4: /* Antenna 3 */
		phy_ctl |= B43_TXH_PHY_ANT3;
328
329
330
331
332
		break;
	default:
		B43_WARN_ON(1);
	}

333
	rates = info->control.rates;
334
	/* MAC control */
335
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
336
		mac_ctl |= B43_TXH_MAC_ACK;
337
338
	/* use hardware sequence counter as the non-TID counter */
	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
339
		mac_ctl |= B43_TXH_MAC_HWSEQ;
340
	if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
341
		mac_ctl |= B43_TXH_MAC_STMSDU;
342
	if (phy->type == B43_PHYTYPE_A)
343
		mac_ctl |= B43_TXH_MAC_5GHZ;
344
345
346
347
348
349
350
351

	/* Overwrite rates[0].count to make the retry calculation
	 * in the tx status easier. need the actual retry limit to
	 * detect whether the fallback rate was used.
	 */
	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
	    (rates[0].count <= dev->wl->hw->conf.long_frame_max_tx_count)) {
		rates[0].count = dev->wl->hw->conf.long_frame_max_tx_count;
352
		mac_ctl |= B43_TXH_MAC_LONGFRAME;
353
354
355
	} else {
		rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
	}
356
357

	/* Generate the RTS or CTS-to-self frame */
358
359
	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
	    (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
360
361
362
363
		unsigned int len;
		struct ieee80211_hdr *hdr;
		int rts_rate, rts_rate_fb;
		int rts_rate_ofdm, rts_rate_fb_ofdm;
364
		struct b43_plcp_hdr6 *plcp;
365
		struct ieee80211_rate *rts_cts_rate;
366

367
		rts_cts_rate = ieee80211_get_rts_cts_rate(dev->wl->hw, info);
368
369

		rts_rate = rts_cts_rate ? rts_cts_rate->hw_value : B43_CCK_RATE_1MB;
370
371
372
373
		rts_rate_ofdm = b43_is_ofdm_rate(rts_rate);
		rts_rate_fb = b43_calc_fallback_rate(rts_rate);
		rts_rate_fb_ofdm = b43_is_ofdm_rate(rts_rate_fb);

374
		if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
375
376
377
378
379
380
381
382
383
			struct ieee80211_cts *cts;

			if (b43_is_old_txhdr_format(dev)) {
				cts = (struct ieee80211_cts *)
					(txhdr->old_format.rts_frame);
			} else {
				cts = (struct ieee80211_cts *)
					(txhdr->new_format.rts_frame);
			}
384
			ieee80211_ctstoself_get(dev->wl->hw, info->control.vif,
385
						fragment_data, fragment_len,
386
						info, cts);
387
			mac_ctl |= B43_TXH_MAC_SENDCTS;
388
389
			len = sizeof(struct ieee80211_cts);
		} else {
390
391
392
393
394
395
396
397
398
			struct ieee80211_rts *rts;

			if (b43_is_old_txhdr_format(dev)) {
				rts = (struct ieee80211_rts *)
					(txhdr->old_format.rts_frame);
			} else {
				rts = (struct ieee80211_rts *)
					(txhdr->new_format.rts_frame);
			}
399
			ieee80211_rts_get(dev->wl->hw, info->control.vif,
400
					  fragment_data, fragment_len,
401
					  info, rts);
402
			mac_ctl |= B43_TXH_MAC_SENDRTS;
403
404
405
			len = sizeof(struct ieee80211_rts);
		}
		len += FCS_LEN;
406
407
408
409
410
411
412
413
414
415

		/* Generate the PLCP headers for the RTS/CTS frame */
		if (b43_is_old_txhdr_format(dev))
			plcp = &txhdr->old_format.rts_plcp;
		else
			plcp = &txhdr->new_format.rts_plcp;
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)plcp,
				      len, rts_rate);
		plcp = &txhdr->rts_plcp_fb;
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)plcp,
416
				      len, rts_rate_fb);
417
418
419
420
421
422
423
424

		if (b43_is_old_txhdr_format(dev)) {
			hdr = (struct ieee80211_hdr *)
				(&txhdr->old_format.rts_frame);
		} else {
			hdr = (struct ieee80211_hdr *)
				(&txhdr->new_format.rts_frame);
		}
425
		txhdr->rts_dur_fb = hdr->duration_id;
426

427
		if (rts_rate_ofdm) {
428
			extra_ft |= B43_TXH_EFT_RTS_OFDM;
429
430
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_ofdm(rts_rate);
431
432
		} else {
			extra_ft |= B43_TXH_EFT_RTS_CCK;
433
434
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_cck(rts_rate);
435
		}
436
		if (rts_rate_fb_ofdm)
437
438
439
			extra_ft |= B43_TXH_EFT_RTSFB_OFDM;
		else
			extra_ft |= B43_TXH_EFT_RTSFB_CCK;
440
441
442
	}

	/* Magic cookie */
443
444
445
446
	if (b43_is_old_txhdr_format(dev))
		txhdr->old_format.cookie = cpu_to_le16(cookie);
	else
		txhdr->new_format.cookie = cpu_to_le16(cookie);
447
448
449
450
451
452

	/* Apply the bitfields */
	txhdr->mac_ctl = cpu_to_le32(mac_ctl);
	txhdr->phy_ctl = cpu_to_le16(phy_ctl);
	txhdr->extra_ft = extra_ft;

453
	return 0;
454
455
456
457
458
459
460
}

static s8 b43_rssi_postprocess(struct b43_wldev *dev,
			       u8 in_rssi, int ofdm,
			       int adjust_2053, int adjust_2050)
{
	struct b43_phy *phy = &dev->phy;
461
	struct b43_phy_g *gphy = phy->g;
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
	s32 tmp;

	switch (phy->radio_ver) {
	case 0x2050:
		if (ofdm) {
			tmp = in_rssi;
			if (tmp > 127)
				tmp -= 256;
			tmp *= 73;
			tmp /= 64;
			if (adjust_2050)
				tmp += 25;
			else
				tmp -= 3;
		} else {
477
			if (dev->dev->bus->sprom.
478
479
480
			    boardflags_lo & B43_BFL_RSSI) {
				if (in_rssi > 63)
					in_rssi = 63;
481
482
				B43_WARN_ON(phy->type != B43_PHYTYPE_G);
				tmp = gphy->nrssi_lt[in_rssi];
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
				tmp = 31 - tmp;
				tmp *= -131;
				tmp /= 128;
				tmp -= 57;
			} else {
				tmp = in_rssi;
				tmp = 31 - tmp;
				tmp *= -149;
				tmp /= 128;
				tmp -= 68;
			}
			if (phy->type == B43_PHYTYPE_G && adjust_2050)
				tmp += 25;
		}
		break;
	case 0x2060:
		if (in_rssi > 127)
			tmp = in_rssi - 256;
		else
			tmp = in_rssi;
		break;
	default:
		tmp = in_rssi;
		tmp -= 11;
		tmp *= 103;
		tmp /= 64;
		if (adjust_2053)
			tmp -= 109;
		else
			tmp -= 83;
	}

	return (s8) tmp;
}

//TODO
#if 0
static s8 b43_rssinoise_postprocess(struct b43_wldev *dev, u8 in_rssi)
{
	struct b43_phy *phy = &dev->phy;
	s8 ret;

	if (phy->type == B43_PHYTYPE_A) {
		//TODO: Incomplete specs.
		ret = 0;
	} else
		ret = b43_rssi_postprocess(dev, in_rssi, 0, 1, 1);

	return ret;
}
#endif

void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
{
	struct ieee80211_rx_status status;
	struct b43_plcp_hdr6 *plcp;
	struct ieee80211_hdr *wlhdr;
	const struct b43_rxhdr_fw4 *rxhdr = _rxhdr;
541
	__le16 fctl;
542
543
544
	u16 phystat0, phystat3, chanstat, mactime;
	u32 macstat;
	u16 chanid;
545
	u16 phytype;
546
547
548
549
550
551
552
553
554
555
	int padding;

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

	/* Get metadata about the frame from the header. */
	phystat0 = le16_to_cpu(rxhdr->phy_status0);
	phystat3 = le16_to_cpu(rxhdr->phy_status3);
	macstat = le32_to_cpu(rxhdr->mac_status);
	mactime = le16_to_cpu(rxhdr->mac_time);
	chanstat = le16_to_cpu(rxhdr->channel);
556
	phytype = chanstat & B43_RX_CHAN_PHYTYPE;
557

558
	if (unlikely(macstat & B43_RX_MAC_FCSERR)) {
559
		dev->wl->ieee_stats.dot11FCSErrorCount++;
560
561
562
563
564
565
		status.flag |= RX_FLAG_FAILED_FCS_CRC;
	}
	if (unlikely(phystat0 & (B43_RX_PHYST0_PLCPHCF | B43_RX_PHYST0_PLCPFV)))
		status.flag |= RX_FLAG_FAILED_PLCP_CRC;
	if (phystat0 & B43_RX_PHYST0_SHORTPRMBL)
		status.flag |= RX_FLAG_SHORTPRE;
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
	if (macstat & B43_RX_MAC_DECERR) {
		/* Decryption with the given key failed.
		 * Drop the packet. We also won't be able to decrypt it with
		 * the key in software. */
		goto drop;
	}

	/* Skip PLCP and padding */
	padding = (macstat & B43_RX_MAC_PADDING) ? 2 : 0;
	if (unlikely(skb->len < (sizeof(struct b43_plcp_hdr6) + padding))) {
		b43dbg(dev->wl, "RX: Packet size underrun (1)\n");
		goto drop;
	}
	plcp = (struct b43_plcp_hdr6 *)(skb->data + padding);
	skb_pull(skb, sizeof(struct b43_plcp_hdr6) + padding);
	/* The skb contains the Wireless Header + payload data now */
	if (unlikely(skb->len < (2 + 2 + 6 /*minimum hdr */  + FCS_LEN))) {
		b43dbg(dev->wl, "RX: Packet size underrun (2)\n");
		goto drop;
	}
	wlhdr = (struct ieee80211_hdr *)(skb->data);
587
	fctl = wlhdr->frame_control;
588
589
590
591
592
593
594
595
596
597
598

	if (macstat & B43_RX_MAC_DEC) {
		unsigned int keyidx;
		int wlhdr_len;

		keyidx = ((macstat & B43_RX_MAC_KEYIDX)
			  >> B43_RX_MAC_KEYIDX_SHIFT);
		/* We must adjust the key index here. We want the "physical"
		 * key index, but the ucode passed it slightly different.
		 */
		keyidx = b43_kidx_to_raw(dev, keyidx);
599
		B43_WARN_ON(keyidx >= ARRAY_SIZE(dev->key));
600
601

		if (dev->key[keyidx].algorithm != B43_SEC_ALGO_NONE) {
602
			wlhdr_len = ieee80211_hdrlen(fctl);
603
604
605
606
607
608
609
610
611
			if (unlikely(skb->len < (wlhdr_len + 3))) {
				b43dbg(dev->wl,
				       "RX: Packet size underrun (3)\n");
				goto drop;
			}
			status.flag |= RX_FLAG_DECRYPTED;
		}
	}

Michael Buesch's avatar
Michael Buesch committed
612
	/* Link quality statistics */
613
	status.noise = dev->stats.link_noise;
Michael Buesch's avatar
Michael Buesch committed
614
615
616
617
618
619
	if ((chanstat & B43_RX_CHAN_PHYTYPE) == B43_PHYTYPE_N) {
//		s8 rssi = max(rxhdr->power0, rxhdr->power1);
		//TODO: Find out what the rssi value is (dBm or percentage?)
		//      and also find out what the maximum possible value is.
		//      Fill status.ssi and status.signal fields.
	} else {
620
		status.signal = b43_rssi_postprocess(dev, rxhdr->jssi,
Michael Buesch's avatar
Michael Buesch committed
621
622
623
						  (phystat0 & B43_RX_PHYST0_OFDM),
						  (phystat0 & B43_RX_PHYST0_GAINCTL),
						  (phystat3 & B43_RX_PHYST3_TRSTATE));
624
		status.qual = (rxhdr->jssi * 100) / B43_RX_MAX_SSI;
Michael Buesch's avatar
Michael Buesch committed
625
626
	}

627
	if (phystat0 & B43_RX_PHYST0_OFDM)
628
629
		status.rate_idx = b43_plcp_get_bitrate_idx_ofdm(plcp,
						phytype == B43_PHYTYPE_A);
630
	else
631
		status.rate_idx = b43_plcp_get_bitrate_idx_cck(plcp);
632
633
634
635
636
637
	if (unlikely(status.rate_idx == -1)) {
		/* PLCP seems to be corrupted.
		 * Drop the frame, if we are not interested in corrupted frames. */
		if (!(dev->wl->filter_flags & FIF_PLCPFAIL))
			goto drop;
	}
638
	status.antenna = !!(phystat0 & B43_RX_PHYST0_ANT);
639
640

	/*
641
642
643
644
645
646
	 * All frames on monitor interfaces and beacons always need a full
	 * 64-bit timestamp. Monitor interfaces need it for diagnostic
	 * purposes and beacons for IBSS merging.
	 * This code assumes we get to process the packet within 16 bits
	 * of timestamp, i.e. about 65 milliseconds after the PHY received
	 * the first symbol.
647
	 */
648
	if (ieee80211_is_beacon(fctl) || dev->wl->radiotap_enabled) {
649
650
651
652
653
654
655
656
657
658
		u16 low_mactime_now;

		b43_tsf_read(dev, &status.mactime);
		low_mactime_now = status.mactime;
		status.mactime = status.mactime & ~0xFFFFULL;
		status.mactime += mactime;
		if (low_mactime_now <= mactime)
			status.mactime -= 0x10000;
		status.flag |= RX_FLAG_TSFT;
	}
659
660
661
662

	chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
	switch (chanstat & B43_RX_CHAN_PHYTYPE) {
	case B43_PHYTYPE_A:
663
		status.band = IEEE80211_BAND_5GHZ;
664
665
666
		B43_WARN_ON(1);
		/* FIXME: We don't really know which value the "chanid" contains.
		 *        So the following assignment might be wrong. */
667
		status.freq = b43_channel_to_freq_5ghz(chanid);
668
669
		break;
	case B43_PHYTYPE_G:
670
		status.band = IEEE80211_BAND_2GHZ;
671
672
		/* chanid is the radio channel cookie value as used
		 * to tune the radio. */
673
		status.freq = chanid + 2400;
674
675
		break;
	case B43_PHYTYPE_N:
676
	case B43_PHYTYPE_LP:
677
678
		/* chanid is the SHM channel cookie. Which is the plain
		 * channel number in b43. */
679
680
681
682
683
684
685
		if (chanstat & B43_RX_CHAN_5GHZ) {
			status.band = IEEE80211_BAND_5GHZ;
			status.freq = b43_freq_to_channel_5ghz(chanid);
		} else {
			status.band = IEEE80211_BAND_2GHZ;
			status.freq = b43_freq_to_channel_2ghz(chanid);
		}
686
687
688
		break;
	default:
		B43_WARN_ON(1);
689
		goto drop;
690
691
	}

692
	memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
693
694

	local_bh_disable();
695
	ieee80211_rx(dev->wl->hw, skb);
696
	local_bh_enable();
697

698
699
700
#if B43_DEBUG
	dev->rx_count++;
#endif
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
	return;
drop:
	b43dbg(dev->wl, "RX: Packet dropped\n");
	dev_kfree_skb_any(skb);
}

void b43_handle_txstatus(struct b43_wldev *dev,
			 const struct b43_txstatus *status)
{
	b43_debugfs_log_txstat(dev, status);

	if (status->intermediate)
		return;
	if (status->for_ampdu)
		return;
	if (!status->acked)
		dev->wl->ieee_stats.dot11ACKFailureCount++;
	if (status->rts_count) {
		if (status->rts_count == 0xF)	//FIXME
			dev->wl->ieee_stats.dot11RTSFailureCount++;
		else
			dev->wl->ieee_stats.dot11RTSSuccessCount++;
	}

725
726
727
728
	if (b43_using_pio_transfers(dev))
		b43_pio_handle_txstatus(dev, status);
	else
		b43_dma_handle_txstatus(dev, status);
729
730

	b43_phy_txpower_check(dev, 0);
731
732
}

733
734
735
/* Fill out the mac80211 TXstatus report based on the b43-specific
 * txstatus report data. This returns a boolean whether the frame was
 * successfully transmitted. */
736
737
bool b43_fill_txstatus_report(struct b43_wldev *dev,
			      struct ieee80211_tx_info *report,
738
			      const struct b43_txstatus *status)
739
{
740
	bool frame_success = 1;
741
742
743
744
745
746
747
	int retry_limit;

	/* preserve the confiured retry limit before clearing the status
	 * The xmit function has overwritten the rc's value with the actual
	 * retry limit done by the hardware */
	retry_limit = report->status.rates[0].count;
	ieee80211_tx_info_clear_status(report);
748
749
750

	if (status->acked) {
		/* The frame was ACKed. */
751
		report->flags |= IEEE80211_TX_STAT_ACK;
752
753
	} else {
		/* The frame was not ACKed... */
754
		if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {
755
756
757
758
759
760
			/* ...but we expected an ACK. */
			frame_success = 0;
		}
	}
	if (status->frame_count == 0) {
		/* The frame was not transmitted at all. */
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
		report->status.rates[0].count = 0;
	} else if (status->rts_count > dev->wl->hw->conf.short_frame_max_tx_count) {
		/*
		 * If the short retries (RTS, not data frame) have exceeded
		 * the limit, the hw will not have tried the selected rate,
		 * but will have used the fallback rate instead.
		 * Don't let the rate control count attempts for the selected
		 * rate in this case, otherwise the statistics will be off.
		 */
		report->status.rates[0].count = 0;
		report->status.rates[1].count = status->frame_count;
	} else {
		if (status->frame_count > retry_limit) {
			report->status.rates[0].count = retry_limit;
			report->status.rates[1].count = status->frame_count -
					retry_limit;

		} else {
			report->status.rates[0].count = status->frame_count;
			report->status.rates[1].idx = -1;
		}
	}
783
784

	return frame_success;
785
786
787
788
789
}

/* Stop any TX operation on the device (suspend the hardware queues) */
void b43_tx_suspend(struct b43_wldev *dev)
{
790
791
792
793
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_suspend(dev);
	else
		b43_dma_tx_suspend(dev);
794
795
796
797
798
}

/* Resume any TX operation on the device (resume the hardware queues) */
void b43_tx_resume(struct b43_wldev *dev)
{
799
800
801
802
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_resume(dev);
	else
		b43_dma_tx_resume(dev);
803
}