xmit.c 25 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>
Michael Büsch's avatar
Michael Büsch committed
9
  Copyright (C) 2005, 2006 Michael Buesch <m@bues.ch>
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
  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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
static const struct b43_tx_legacy_rate_phy_ctl_entry b43_tx_legacy_rate_phy_ctl[] = {
	{ B43_CCK_RATE_1MB,	0x0,			0x0 },
	{ B43_CCK_RATE_2MB,	0x0,			0x1 },
	{ B43_CCK_RATE_5MB,	0x0,			0x2 },
	{ B43_CCK_RATE_11MB,	0x0,			0x3 },
	{ B43_OFDM_RATE_6MB,	B43_TXH_PHY1_CRATE_1_2,	B43_TXH_PHY1_MODUL_BPSK },
	{ B43_OFDM_RATE_9MB,	B43_TXH_PHY1_CRATE_3_4,	B43_TXH_PHY1_MODUL_BPSK },
	{ B43_OFDM_RATE_12MB,	B43_TXH_PHY1_CRATE_1_2,	B43_TXH_PHY1_MODUL_QPSK },
	{ B43_OFDM_RATE_18MB,	B43_TXH_PHY1_CRATE_3_4,	B43_TXH_PHY1_MODUL_QPSK },
	{ B43_OFDM_RATE_24MB,	B43_TXH_PHY1_CRATE_1_2,	B43_TXH_PHY1_MODUL_QAM16 },
	{ B43_OFDM_RATE_36MB,	B43_TXH_PHY1_CRATE_3_4,	B43_TXH_PHY1_MODUL_QAM16 },
	{ B43_OFDM_RATE_48MB,	B43_TXH_PHY1_CRATE_2_3,	B43_TXH_PHY1_MODUL_QAM64 },
	{ B43_OFDM_RATE_54MB,	B43_TXH_PHY1_CRATE_3_4,	B43_TXH_PHY1_MODUL_QAM64 },
};

static const struct b43_tx_legacy_rate_phy_ctl_entry *
b43_tx_legacy_rate_phy_ctl_ent(u8 bitrate)
{
	const struct b43_tx_legacy_rate_phy_ctl_entry *e;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(b43_tx_legacy_rate_phy_ctl); i++) {
		e = &(b43_tx_legacy_rate_phy_ctl[i]);
		if (e->bitrate == bitrate)
			return e;
	}

	B43_WARN_ON(1);
	return NULL;
}
65

66
67
/* Extract the bitrate index out of a CCK PLCP header. */
static int b43_plcp_get_bitrate_idx_cck(struct b43_plcp_hdr6 *plcp)
68
69
70
{
	switch (plcp->raw[0]) {
	case 0x0A:
71
		return 0;
72
	case 0x14:
73
		return 1;
74
	case 0x37:
75
		return 2;
76
	case 0x6E:
77
		return 3;
78
	}
79
	return -1;
80
81
}

82
/* Extract the bitrate index out of an OFDM PLCP header. */
83
static int b43_plcp_get_bitrate_idx_ofdm(struct b43_plcp_hdr6 *plcp, bool aphy)
84
{
85
86
	int base = aphy ? 0 : 4;

87
88
	switch (plcp->raw[0] & 0xF) {
	case 0xB:
89
		return base + 0;
90
	case 0xF:
91
		return base + 1;
92
	case 0xA:
93
		return base + 2;
94
	case 0xE:
95
		return base + 3;
96
	case 0x9:
97
		return base + 4;
98
	case 0xD:
99
		return base + 5;
100
	case 0x8:
101
		return base + 6;
102
	case 0xC:
103
		return base + 7;
104
	}
105
	return -1;
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
}

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
154
155
156
		u32 d;

		d = b43_plcp_get_ratecode_ofdm(bitrate);
157
		B43_WARN_ON(octets & 0xF000);
Michael Buesch's avatar
Michael Buesch committed
158
		d |= (octets << 5);
159
		plcp->data = cpu_to_le32(d);
160
161
162
163
164
165
166
167
168
169
170
171
172
	} 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;
173
		plcp->data |= cpu_to_le32(plen << 16);
174
175
176
177
		raw[0] = b43_plcp_get_ratecode_cck(bitrate);
	}
}

178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
static u16 b43_generate_tx_phy_ctl1(struct b43_wldev *dev, u8 bitrate)
{
	const struct b43_phy *phy = &dev->phy;
	const struct b43_tx_legacy_rate_phy_ctl_entry *e;
	u16 control = 0;
	u16 bw;

	if (phy->type == B43_PHYTYPE_LP)
		bw = B43_TXH_PHY1_BW_20;
	else /* FIXME */
		bw = B43_TXH_PHY1_BW_20;

	if (0) { /* FIXME: MIMO */
	} else if (b43_is_cck_rate(bitrate) && phy->type != B43_PHYTYPE_LP) {
		control = bw;
	} else {
		control = bw;
		e = b43_tx_legacy_rate_phy_ctl_ent(bitrate);
		if (e) {
			control |= e->coding_rate;
			control |= e->modulation;
		}
		control |= B43_TXH_PHY1_MODE_SISO;
	}

	return control;
}

206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
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;
}

238
/* Generate a TX data header. */
239
240
int b43_generate_txhdr(struct b43_wldev *dev,
		       u8 *_txhdr,
gregor kowski's avatar
gregor kowski committed
241
		       struct sk_buff *skb_frag,
242
		       struct ieee80211_tx_info *info,
243
		       u16 cookie)
244
{
gregor kowski's avatar
gregor kowski committed
245
246
	const unsigned char *fragment_data = skb_frag->data;
	unsigned int fragment_len = skb_frag->len;
247
	struct b43_txhdr *txhdr = (struct b43_txhdr *)_txhdr;
248
249
250
	const struct b43_phy *phy = &dev->phy;
	const struct ieee80211_hdr *wlhdr =
	    (const struct ieee80211_hdr *)fragment_data;
251
	int use_encryption = !!info->control.hw_key;
252
	__le16 fctl = wlhdr->frame_control;
253
	struct ieee80211_rate *fbrate;
254
255
256
257
258
259
	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;
260
	struct ieee80211_rate *txrate;
261
	struct ieee80211_tx_rate *rates;
262
263
264

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

265
	txrate = ieee80211_get_tx_rate(dev->wl->hw, info);
266
	rate = txrate ? txrate->hw_value : B43_CCK_RATE_1MB;
267
	rate_ofdm = b43_is_ofdm_rate(rate);
268
	fbrate = ieee80211_get_alt_retry_rate(dev->wl->hw, info, 0) ? : txrate;
269
	rate_fb = fbrate->hw_value;
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
	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 {
288
289
		txhdr->dur_fb = ieee80211_generic_frame_duration(
			dev->wl->hw, info->control.vif, fragment_len, fbrate);
290
291
292
293
	}

	plcp_fragment_len = fragment_len + FCS_LEN;
	if (use_encryption) {
294
		u8 key_idx = info->control.hw_key->hw_key_idx;
295
296
297
298
		struct b43_key *key;
		int wlhdr_len;
		size_t iv_len;

299
		B43_WARN_ON(key_idx >= ARRAY_SIZE(dev->key));
300
		key = &(dev->key[key_idx]);
Michael Buesch's avatar
Michael Buesch committed
301

302
303
304
305
306
307
308
		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
309
		}
310
311

		/* Hardware appends ICV. */
312
		plcp_fragment_len += info->control.hw_key->icv_len;
313
314
315
316
317
318

		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;
319
		wlhdr_len = ieee80211_hdrlen(fctl);
gregor kowski's avatar
gregor kowski committed
320
321
322
323
324
325
		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.
			 */
326
			ieee80211_get_tkip_p1k(info->control.hw_key, skb_frag, phase1key);
327
328
329
330
331
			/* 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
332
333
334
335
336
337
338
			/* 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);
		}
339
	}
340
	switch (dev->fw.hdr_format) {
341
342
343
344
	case B43_FW_HDR_598:
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->format_598.plcp),
				      plcp_fragment_len, rate);
		break;
345
	case B43_FW_HDR_351:
346
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->format_351.plcp),
347
				      plcp_fragment_len, rate);
348
349
		break;
	case B43_FW_HDR_410:
350
		b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->format_410.plcp),
351
				      plcp_fragment_len, rate);
352
		break;
353
	}
354
355
356
357
358
	b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->plcp_fb),
			      plcp_fragment_len, rate_fb);

	/* Extra Frame Types */
	if (rate_fb_ofdm)
359
360
361
		extra_ft |= B43_TXH_EFT_FB_OFDM;
	else
		extra_ft |= B43_TXH_EFT_FB_CCK;
362
363
364
365
366
367
368
369
370

	/* 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)
371
372
373
		phy_ctl |= B43_TXH_PHY_ENC_OFDM;
	else
		phy_ctl |= B43_TXH_PHY_ENC_CCK;
374
	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
375
		phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
376

377
	switch (b43_ieee80211_antenna_sanitize(dev, info->antenna_sel_tx)) {
378
	case 0: /* Default */
379
		phy_ctl |= B43_TXH_PHY_ANT01AUTO;
380
		break;
381
	case 1: /* Antenna 0 */
382
		phy_ctl |= B43_TXH_PHY_ANT0;
383
		break;
384
	case 2: /* Antenna 1 */
385
386
387
388
389
390
391
		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;
392
393
394
395
396
		break;
	default:
		B43_WARN_ON(1);
	}

397
	rates = info->control.rates;
398
	/* MAC control */
399
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
400
		mac_ctl |= B43_TXH_MAC_ACK;
401
402
	/* use hardware sequence counter as the non-TID counter */
	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
403
		mac_ctl |= B43_TXH_MAC_HWSEQ;
404
	if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
405
		mac_ctl |= B43_TXH_MAC_STMSDU;
406
	if (phy->type == B43_PHYTYPE_A)
407
		mac_ctl |= B43_TXH_MAC_5GHZ;
408
409
410
411
412
413
414
415

	/* 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;
416
		mac_ctl |= B43_TXH_MAC_LONGFRAME;
417
418
419
	} else {
		rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
	}
420
421

	/* Generate the RTS or CTS-to-self frame */
422
423
	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
	    (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
424
		unsigned int len;
425
		struct ieee80211_hdr *uninitialized_var(hdr);
426
427
		int rts_rate, rts_rate_fb;
		int rts_rate_ofdm, rts_rate_fb_ofdm;
428
		struct b43_plcp_hdr6 *uninitialized_var(plcp);
429
		struct ieee80211_rate *rts_cts_rate;
430

431
		rts_cts_rate = ieee80211_get_rts_cts_rate(dev->wl->hw, info);
432
433

		rts_rate = rts_cts_rate ? rts_cts_rate->hw_value : B43_CCK_RATE_1MB;
434
435
436
437
		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);

438
		if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
439
			struct ieee80211_cts *uninitialized_var(cts);
440

441
			switch (dev->fw.hdr_format) {
442
443
444
445
			case B43_FW_HDR_598:
				cts = (struct ieee80211_cts *)
					(txhdr->format_598.rts_frame);
				break;
446
			case B43_FW_HDR_351:
447
				cts = (struct ieee80211_cts *)
448
					(txhdr->format_351.rts_frame);
449
450
				break;
			case B43_FW_HDR_410:
451
				cts = (struct ieee80211_cts *)
452
					(txhdr->format_410.rts_frame);
453
				break;
454
			}
455
			ieee80211_ctstoself_get(dev->wl->hw, info->control.vif,
456
						fragment_data, fragment_len,
457
						info, cts);
458
			mac_ctl |= B43_TXH_MAC_SENDCTS;
459
460
			len = sizeof(struct ieee80211_cts);
		} else {
461
			struct ieee80211_rts *uninitialized_var(rts);
462

463
			switch (dev->fw.hdr_format) {
464
465
466
467
			case B43_FW_HDR_598:
				rts = (struct ieee80211_rts *)
					(txhdr->format_598.rts_frame);
				break;
468
			case B43_FW_HDR_351:
469
				rts = (struct ieee80211_rts *)
470
					(txhdr->format_351.rts_frame);
471
472
				break;
			case B43_FW_HDR_410:
473
				rts = (struct ieee80211_rts *)
474
					(txhdr->format_410.rts_frame);
475
				break;
476
			}
477
			ieee80211_rts_get(dev->wl->hw, info->control.vif,
478
					  fragment_data, fragment_len,
479
					  info, rts);
480
			mac_ctl |= B43_TXH_MAC_SENDRTS;
481
482
483
			len = sizeof(struct ieee80211_rts);
		}
		len += FCS_LEN;
484
485

		/* Generate the PLCP headers for the RTS/CTS frame */
486
		switch (dev->fw.hdr_format) {
487
488
489
		case B43_FW_HDR_598:
			plcp = &txhdr->format_598.rts_plcp;
			break;
490
		case B43_FW_HDR_351:
491
			plcp = &txhdr->format_351.rts_plcp;
492
493
			break;
		case B43_FW_HDR_410:
494
			plcp = &txhdr->format_410.rts_plcp;
495
496
			break;
		}
497
498
499
500
		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,
501
				      len, rts_rate_fb);
502

503
		switch (dev->fw.hdr_format) {
504
505
506
507
		case B43_FW_HDR_598:
			hdr = (struct ieee80211_hdr *)
				(&txhdr->format_598.rts_frame);
			break;
508
		case B43_FW_HDR_351:
509
			hdr = (struct ieee80211_hdr *)
510
				(&txhdr->format_351.rts_frame);
511
512
			break;
		case B43_FW_HDR_410:
513
			hdr = (struct ieee80211_hdr *)
514
				(&txhdr->format_410.rts_frame);
515
			break;
516
		}
517
		txhdr->rts_dur_fb = hdr->duration_id;
518

519
		if (rts_rate_ofdm) {
520
			extra_ft |= B43_TXH_EFT_RTS_OFDM;
521
522
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_ofdm(rts_rate);
523
524
		} else {
			extra_ft |= B43_TXH_EFT_RTS_CCK;
525
526
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_cck(rts_rate);
527
		}
528
		if (rts_rate_fb_ofdm)
529
530
531
			extra_ft |= B43_TXH_EFT_RTSFB_OFDM;
		else
			extra_ft |= B43_TXH_EFT_RTSFB_CCK;
532
533
534
535
536
537
538
539

		if (rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS &&
		    phy->type == B43_PHYTYPE_N) {
			txhdr->phy_ctl1_rts = cpu_to_le16(
				b43_generate_tx_phy_ctl1(dev, rts_rate));
			txhdr->phy_ctl1_rts_fb = cpu_to_le16(
				b43_generate_tx_phy_ctl1(dev, rts_rate_fb));
		}
540
541
542
	}

	/* Magic cookie */
543
	switch (dev->fw.hdr_format) {
544
545
546
	case B43_FW_HDR_598:
		txhdr->format_598.cookie = cpu_to_le16(cookie);
		break;
547
	case B43_FW_HDR_351:
548
		txhdr->format_351.cookie = cpu_to_le16(cookie);
549
550
		break;
	case B43_FW_HDR_410:
551
		txhdr->format_410.cookie = cpu_to_le16(cookie);
552
553
		break;
	}
554

555
556
557
558
559
560
561
	if (phy->type == B43_PHYTYPE_N) {
		txhdr->phy_ctl1 =
			cpu_to_le16(b43_generate_tx_phy_ctl1(dev, rate));
		txhdr->phy_ctl1_fb =
			cpu_to_le16(b43_generate_tx_phy_ctl1(dev, rate_fb));
	}

562
563
564
565
566
	/* Apply the bitfields */
	txhdr->mac_ctl = cpu_to_le32(mac_ctl);
	txhdr->phy_ctl = cpu_to_le16(phy_ctl);
	txhdr->extra_ft = extra_ft;

567
	return 0;
568
569
570
571
572
573
574
}

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;
575
	struct b43_phy_g *gphy = phy->g;
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
	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 {
Rafał Miłecki's avatar
Rafał Miłecki committed
591
			if (dev->dev->bus_sprom->
592
593
594
			    boardflags_lo & B43_BFL_RSSI) {
				if (in_rssi > 63)
					in_rssi = 63;
595
596
				B43_WARN_ON(phy->type != B43_PHYTYPE_G);
				tmp = gphy->nrssi_lt[in_rssi];
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
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
				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;
655
	__le16 fctl;
656
657
658
	u16 phystat0, phystat3;
	u16 uninitialized_var(chanstat), uninitialized_var(mactime);
	u32 uninitialized_var(macstat);
659
	u16 chanid;
660
	u16 phytype;
661
662
663
664
665
666
667
	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);
668
669
670
671
672
673
674
675
676
677
678
679
680
	switch (dev->fw.hdr_format) {
	case B43_FW_HDR_598:
		macstat = le32_to_cpu(rxhdr->format_598.mac_status);
		mactime = le16_to_cpu(rxhdr->format_598.mac_time);
		chanstat = le16_to_cpu(rxhdr->format_598.channel);
		break;
	case B43_FW_HDR_410:
	case B43_FW_HDR_351:
		macstat = le32_to_cpu(rxhdr->format_351.mac_status);
		mactime = le16_to_cpu(rxhdr->format_351.mac_time);
		chanstat = le16_to_cpu(rxhdr->format_351.channel);
		break;
	}
681
	phytype = chanstat & B43_RX_CHAN_PHYTYPE;
682

683
	if (unlikely(macstat & B43_RX_MAC_FCSERR)) {
684
		dev->wl->ieee_stats.dot11FCSErrorCount++;
685
686
687
688
689
690
		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;
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
	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);
712
	fctl = wlhdr->frame_control;
713
714
715
716
717
718
719
720
721
722
723

	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);
724
		B43_WARN_ON(keyidx >= ARRAY_SIZE(dev->key));
725
726

		if (dev->key[keyidx].algorithm != B43_SEC_ALGO_NONE) {
727
			wlhdr_len = ieee80211_hdrlen(fctl);
728
729
730
731
732
733
734
735
736
			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
737
738
739
740
741
742
743
	/* Link quality statistics */
	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 {
744
		status.signal = b43_rssi_postprocess(dev, rxhdr->jssi,
Michael Buesch's avatar
Michael Buesch committed
745
746
747
748
749
						  (phystat0 & B43_RX_PHYST0_OFDM),
						  (phystat0 & B43_RX_PHYST0_GAINCTL),
						  (phystat3 & B43_RX_PHYST3_TRSTATE));
	}

750
	if (phystat0 & B43_RX_PHYST0_OFDM)
751
752
		status.rate_idx = b43_plcp_get_bitrate_idx_ofdm(plcp,
						phytype == B43_PHYTYPE_A);
753
	else
754
		status.rate_idx = b43_plcp_get_bitrate_idx_cck(plcp);
755
756
757
758
759
760
	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;
	}
761
	status.antenna = !!(phystat0 & B43_RX_PHYST0_ANT);
762
763

	/*
764
765
766
767
768
769
	 * 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.
770
	 */
771
	if (ieee80211_is_beacon(fctl) || dev->wl->radiotap_enabled) {
772
773
774
775
776
777
778
779
		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;
Johannes Berg's avatar
Johannes Berg committed
780
		status.flag |= RX_FLAG_MACTIME_MPDU;
781
	}
782
783
784
785

	chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
	switch (chanstat & B43_RX_CHAN_PHYTYPE) {
	case B43_PHYTYPE_A:
786
		status.band = IEEE80211_BAND_5GHZ;
787
788
789
		B43_WARN_ON(1);
		/* FIXME: We don't really know which value the "chanid" contains.
		 *        So the following assignment might be wrong. */
790
		status.freq = b43_channel_to_freq_5ghz(chanid);
791
792
		break;
	case B43_PHYTYPE_G:
793
		status.band = IEEE80211_BAND_2GHZ;
794
795
		/* chanid is the radio channel cookie value as used
		 * to tune the radio. */
796
		status.freq = chanid + 2400;
797
798
		break;
	case B43_PHYTYPE_N:
799
	case B43_PHYTYPE_LP:
800
801
		/* chanid is the SHM channel cookie. Which is the plain
		 * channel number in b43. */
802
803
804
805
806
807
808
		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);
		}
809
810
811
		break;
	default:
		B43_WARN_ON(1);
812
		goto drop;
813
814
	}

815
	memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
John W. Linville's avatar
John W. Linville committed
816
	ieee80211_rx_ni(dev->wl->hw, skb);
817

818
819
820
#if B43_DEBUG
	dev->rx_count++;
#endif
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
	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++;
	}

845
846
847
848
	if (b43_using_pio_transfers(dev))
		b43_pio_handle_txstatus(dev, status);
	else
		b43_dma_handle_txstatus(dev, status);
849
850

	b43_phy_txpower_check(dev, 0);
851
852
}

853
854
855
/* Fill out the mac80211 TXstatus report based on the b43-specific
 * txstatus report data. This returns a boolean whether the frame was
 * successfully transmitted. */
856
857
bool b43_fill_txstatus_report(struct b43_wldev *dev,
			      struct ieee80211_tx_info *report,
858
			      const struct b43_txstatus *status)
859
{
860
	bool frame_success = 1;
861
862
863
864
865
866
867
	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);
868
869
870

	if (status->acked) {
		/* The frame was ACKed. */
871
		report->flags |= IEEE80211_TX_STAT_ACK;
872
873
	} else {
		/* The frame was not ACKed... */
874
		if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {
875
876
877
878
879
880
			/* ...but we expected an ACK. */
			frame_success = 0;
		}
	}
	if (status->frame_count == 0) {
		/* The frame was not transmitted at all. */
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
		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;
		}
	}
903
904

	return frame_success;
905
906
907
908
909
}

/* Stop any TX operation on the device (suspend the hardware queues) */
void b43_tx_suspend(struct b43_wldev *dev)
{
910
911
912
913
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_suspend(dev);
	else
		b43_dma_tx_suspend(dev);
914
915
916
917
918
}

/* Resume any TX operation on the device (resume the hardware queues) */
void b43_tx_resume(struct b43_wldev *dev)
{
919
920
921
922
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_resume(dev);
	else
		b43_dma_tx_resume(dev);
923
}