xmit.c 19 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
30
  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.

*/

#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
	}
	B43_WARN_ON(1);
50
	return -1;
51
52
}

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

58
59
	switch (plcp->raw[0] & 0xF) {
	case 0xB:
60
		return base + 0;
61
	case 0xF:
62
		return base + 1;
63
	case 0xA:
64
		return base + 2;
65
	case 0xE:
66
		return base + 3;
67
	case 0x9:
68
		return base + 4;
69
	case 0xD:
70
		return base + 5;
71
	case 0x8:
72
		return base + 6;
73
	case 0xC:
74
		return base + 7;
75
76
	}
	B43_WARN_ON(1);
77
	return -1;
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
124
125
126
}

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)
{
	__le32 *data = &(plcp->data);
	__u8 *raw = plcp->raw;

	if (b43_is_ofdm_rate(bitrate)) {
Michael Buesch's avatar
Michael Buesch committed
127
128
129
		u32 d;

		d = b43_plcp_get_ratecode_ofdm(bitrate);
130
		B43_WARN_ON(octets & 0xF000);
Michael Buesch's avatar
Michael Buesch committed
131
132
		d |= (octets << 5);
		*data = cpu_to_le32(d);
133
134
135
136
137
138
139
140
141
142
143
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
180
181
182
	} 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;
		*data |= cpu_to_le32(plen << 16);
		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;
}

183
/* Generate a TX data header. */
184
185
186
187
int b43_generate_txhdr(struct b43_wldev *dev,
		       u8 *_txhdr,
		       const unsigned char *fragment_data,
		       unsigned int fragment_len,
188
		       const struct ieee80211_tx_info *info,
189
		       u16 cookie)
190
{
191
	struct b43_txhdr *txhdr = (struct b43_txhdr *)_txhdr;
192
193
194
	const struct b43_phy *phy = &dev->phy;
	const struct ieee80211_hdr *wlhdr =
	    (const struct ieee80211_hdr *)fragment_data;
195
	int use_encryption = !!info->control.hw_key;
196
	__le16 fctl = wlhdr->frame_control;
197
	struct ieee80211_rate *fbrate;
198
199
200
201
202
203
	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;
204
	struct ieee80211_rate *txrate;
205
206
207

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

208
	txrate = ieee80211_get_tx_rate(dev->wl->hw, info);
209
	rate = txrate ? txrate->hw_value : B43_CCK_RATE_1MB;
210
	rate_ofdm = b43_is_ofdm_rate(rate);
211
	fbrate = ieee80211_get_alt_retry_rate(dev->wl->hw, info, 0) ? : txrate;
212
	rate_fb = fbrate->hw_value;
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
	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 {
231
232
		txhdr->dur_fb = ieee80211_generic_frame_duration(
			dev->wl->hw, info->control.vif, fragment_len, fbrate);
233
234
235
236
	}

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

		B43_WARN_ON(key_idx >= dev->max_nr_keys);
		key = &(dev->key[key_idx]);
Michael Buesch's avatar
Michael Buesch committed
244

245
246
247
248
249
250
251
		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
252
		}
253
254

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

		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;
262
		wlhdr_len = ieee80211_hdrlen(fctl);
263
		iv_len = min((size_t) info->control.hw_key->iv_len,
264
265
			     ARRAY_SIZE(txhdr->iv));
		memcpy(txhdr->iv, ((u8 *) wlhdr) + wlhdr_len, iv_len);
266
	}
267
268
269
270
271
272
273
	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);
	}
274
275
276
277
278
	b43_generate_plcp_hdr((struct b43_plcp_hdr4 *)(&txhdr->plcp_fb),
			      plcp_fragment_len, rate_fb);

	/* Extra Frame Types */
	if (rate_fb_ofdm)
279
280
281
		extra_ft |= B43_TXH_EFT_FB_OFDM;
	else
		extra_ft |= B43_TXH_EFT_FB_CCK;
282
283
284
285
286
287
288
289
290

	/* 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)
291
292
293
		phy_ctl |= B43_TXH_PHY_ENC_OFDM;
	else
		phy_ctl |= B43_TXH_PHY_ENC_CCK;
294
	if (info->flags & IEEE80211_TX_CTL_SHORT_PREAMBLE)
295
		phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
296

297
	switch (b43_ieee80211_antenna_sanitize(dev, info->antenna_sel_tx)) {
298
	case 0: /* Default */
299
		phy_ctl |= B43_TXH_PHY_ANT01AUTO;
300
		break;
301
	case 1: /* Antenna 0 */
302
		phy_ctl |= B43_TXH_PHY_ANT0;
303
		break;
304
	case 2: /* Antenna 1 */
305
306
307
308
309
310
311
		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;
312
313
314
315
316
317
		break;
	default:
		B43_WARN_ON(1);
	}

	/* MAC control */
318
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
319
		mac_ctl |= B43_TXH_MAC_ACK;
320
321
	/* use hardware sequence counter as the non-TID counter */
	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
322
		mac_ctl |= B43_TXH_MAC_HWSEQ;
323
	if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
324
		mac_ctl |= B43_TXH_MAC_STMSDU;
325
	if (phy->type == B43_PHYTYPE_A)
326
		mac_ctl |= B43_TXH_MAC_5GHZ;
327
	if (info->flags & IEEE80211_TX_CTL_LONG_RETRY_LIMIT)
328
		mac_ctl |= B43_TXH_MAC_LONGFRAME;
329
330

	/* Generate the RTS or CTS-to-self frame */
331
332
	if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) ||
	    (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) {
333
334
335
336
		unsigned int len;
		struct ieee80211_hdr *hdr;
		int rts_rate, rts_rate_fb;
		int rts_rate_ofdm, rts_rate_fb_ofdm;
337
		struct b43_plcp_hdr6 *plcp;
338
		struct ieee80211_rate *rts_cts_rate;
339

340
		rts_cts_rate = ieee80211_get_rts_cts_rate(dev->wl->hw, info);
341
342

		rts_rate = rts_cts_rate ? rts_cts_rate->hw_value : B43_CCK_RATE_1MB;
343
344
345
346
		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);

347
		if (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT) {
348
349
350
351
352
353
354
355
356
			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);
			}
357
			ieee80211_ctstoself_get(dev->wl->hw, info->control.vif,
358
						fragment_data, fragment_len,
359
						info, cts);
360
			mac_ctl |= B43_TXH_MAC_SENDCTS;
361
362
			len = sizeof(struct ieee80211_cts);
		} else {
363
364
365
366
367
368
369
370
371
			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);
			}
372
			ieee80211_rts_get(dev->wl->hw, info->control.vif,
373
					  fragment_data, fragment_len,
374
					  info, rts);
375
			mac_ctl |= B43_TXH_MAC_SENDRTS;
376
377
378
			len = sizeof(struct ieee80211_rts);
		}
		len += FCS_LEN;
379
380
381
382
383
384
385
386
387
388

		/* 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,
389
				      len, rts_rate_fb);
390
391
392
393
394
395
396
397

		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);
		}
398
		txhdr->rts_dur_fb = hdr->duration_id;
399

400
		if (rts_rate_ofdm) {
401
			extra_ft |= B43_TXH_EFT_RTS_OFDM;
402
403
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_ofdm(rts_rate);
404
405
		} else {
			extra_ft |= B43_TXH_EFT_RTS_CCK;
406
407
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_cck(rts_rate);
408
		}
409
		if (rts_rate_fb_ofdm)
410
411
412
			extra_ft |= B43_TXH_EFT_RTSFB_OFDM;
		else
			extra_ft |= B43_TXH_EFT_RTSFB_CCK;
413
414
415
	}

	/* Magic cookie */
416
417
418
419
	if (b43_is_old_txhdr_format(dev))
		txhdr->old_format.cookie = cpu_to_le16(cookie);
	else
		txhdr->new_format.cookie = cpu_to_le16(cookie);
420
421
422
423
424
425

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

426
	return 0;
427
428
429
430
431
432
433
}

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;
434
	struct b43_phy_g *gphy = phy->g;
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
	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 {
450
			if (dev->dev->bus->sprom.
451
452
453
			    boardflags_lo & B43_BFL_RSSI) {
				if (in_rssi > 63)
					in_rssi = 63;
454
455
				B43_WARN_ON(phy->type != B43_PHYTYPE_G);
				tmp = gphy->nrssi_lt[in_rssi];
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
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
				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;
514
	__le16 fctl;
515
516
517
	u16 phystat0, phystat3, chanstat, mactime;
	u32 macstat;
	u16 chanid;
518
	u16 phytype;
519
520
521
522
523
524
525
526
527
528
	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);
529
	phytype = chanstat & B43_RX_CHAN_PHYTYPE;
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553

	if (macstat & B43_RX_MAC_FCSERR)
		dev->wl->ieee_stats.dot11FCSErrorCount++;
	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);
554
	fctl = wlhdr->frame_control;
555
556
557
558
559
560
561
562
563
564
565
566
567
568

	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);
		B43_WARN_ON(keyidx >= dev->max_nr_keys);

		if (dev->key[keyidx].algorithm != B43_SEC_ALGO_NONE) {
569
			wlhdr_len = ieee80211_hdrlen(fctl);
570
571
572
573
574
575
576
577
578
			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
579
	/* Link quality statistics */
580
	status.noise = dev->stats.link_noise;
Michael Buesch's avatar
Michael Buesch committed
581
582
583
584
585
586
	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 {
587
		status.signal = b43_rssi_postprocess(dev, rxhdr->jssi,
Michael Buesch's avatar
Michael Buesch committed
588
589
590
						  (phystat0 & B43_RX_PHYST0_OFDM),
						  (phystat0 & B43_RX_PHYST0_GAINCTL),
						  (phystat3 & B43_RX_PHYST3_TRSTATE));
591
		status.qual = (rxhdr->jssi * 100) / B43_RX_MAX_SSI;
Michael Buesch's avatar
Michael Buesch committed
592
593
	}

594
	if (phystat0 & B43_RX_PHYST0_OFDM)
595
596
		status.rate_idx = b43_plcp_get_bitrate_idx_ofdm(plcp,
						phytype == B43_PHYTYPE_A);
597
	else
598
		status.rate_idx = b43_plcp_get_bitrate_idx_cck(plcp);
599
	status.antenna = !!(phystat0 & B43_RX_PHYST0_ANT);
600
601

	/*
602
603
604
605
606
607
	 * 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.
608
	 */
609
	if (ieee80211_is_beacon(fctl) || dev->wl->radiotap_enabled) {
610
611
612
613
614
615
616
617
618
619
		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;
	}
620
621
622
623

	chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
	switch (chanstat & B43_RX_CHAN_PHYTYPE) {
	case B43_PHYTYPE_A:
624
		status.band = IEEE80211_BAND_5GHZ;
625
626
627
		B43_WARN_ON(1);
		/* FIXME: We don't really know which value the "chanid" contains.
		 *        So the following assignment might be wrong. */
628
		status.freq = b43_channel_to_freq_5ghz(chanid);
629
630
		break;
	case B43_PHYTYPE_G:
631
		status.band = IEEE80211_BAND_2GHZ;
632
633
		/* chanid is the radio channel cookie value as used
		 * to tune the radio. */
634
		status.freq = chanid + 2400;
635
636
637
638
		break;
	case B43_PHYTYPE_N:
		/* chanid is the SHM channel cookie. Which is the plain
		 * channel number in b43. */
639
640
641
642
643
644
645
		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);
		}
646
647
648
		break;
	default:
		B43_WARN_ON(1);
649
		goto drop;
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
	}

	dev->stats.last_rx = jiffies;
	ieee80211_rx_irqsafe(dev->wl->hw, skb, &status);

	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++;
	}

679
680
681
682
	if (b43_using_pio_transfers(dev))
		b43_pio_handle_txstatus(dev, status);
	else
		b43_dma_handle_txstatus(dev, status);
683
684

	b43_phy_txpower_check(dev, 0);
685
686
}

687
688
689
/* Fill out the mac80211 TXstatus report based on the b43-specific
 * txstatus report data. This returns a boolean whether the frame was
 * successfully transmitted. */
690
bool b43_fill_txstatus_report(struct ieee80211_tx_info *report,
691
			      const struct b43_txstatus *status)
692
{
693
694
695
696
	bool frame_success = 1;

	if (status->acked) {
		/* The frame was ACKed. */
697
		report->flags |= IEEE80211_TX_STAT_ACK;
698
699
	} else {
		/* The frame was not ACKed... */
700
		if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {
701
702
			/* ...but we expected an ACK. */
			frame_success = 0;
703
			report->status.excessive_retries = 1;
704
705
706
707
		}
	}
	if (status->frame_count == 0) {
		/* The frame was not transmitted at all. */
708
		report->status.retry_count = 0;
709
	} else
710
		report->status.retry_count = status->frame_count - 1;
711
712

	return frame_success;
713
714
715
716
717
}

/* Stop any TX operation on the device (suspend the hardware queues) */
void b43_tx_suspend(struct b43_wldev *dev)
{
718
719
720
721
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_suspend(dev);
	else
		b43_dma_tx_suspend(dev);
722
723
724
725
726
}

/* Resume any TX operation on the device (resume the hardware queues) */
void b43_tx_resume(struct b43_wldev *dev)
{
727
728
729
730
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_resume(dev);
	else
		b43_dma_tx_resume(dev);
731
}