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

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

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

	plcp_fragment_len = fragment_len + FCS_LEN;
	if (use_encryption) {
235
		u8 key_idx = info->control.hw_key->hw_key_idx;
236 237 238 239 240 241
		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
242

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

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

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

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

	/* 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)
289 290 291
		phy_ctl |= B43_TXH_PHY_ENC_OFDM;
	else
		phy_ctl |= B43_TXH_PHY_ENC_CCK;
292
	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
293
		phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
294

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

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

	/* 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;
334
		mac_ctl |= B43_TXH_MAC_LONGFRAME;
335 336 337
	} else {
		rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
	}
338 339

	/* Generate the RTS or CTS-to-self frame */
340 341
	if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
	    (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
342 343 344 345
		unsigned int len;
		struct ieee80211_hdr *hdr;
		int rts_rate, rts_rate_fb;
		int rts_rate_ofdm, rts_rate_fb_ofdm;
346
		struct b43_plcp_hdr6 *plcp;
347
		struct ieee80211_rate *rts_cts_rate;
348

349
		rts_cts_rate = ieee80211_get_rts_cts_rate(dev->wl->hw, info);
350 351

		rts_rate = rts_cts_rate ? rts_cts_rate->hw_value : B43_CCK_RATE_1MB;
352 353 354 355
		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);

356
		if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
357 358 359 360 361 362 363 364 365
			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);
			}
366
			ieee80211_ctstoself_get(dev->wl->hw, info->control.vif,
367
						fragment_data, fragment_len,
368
						info, cts);
369
			mac_ctl |= B43_TXH_MAC_SENDCTS;
370 371
			len = sizeof(struct ieee80211_cts);
		} else {
372 373 374 375 376 377 378 379 380
			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);
			}
381
			ieee80211_rts_get(dev->wl->hw, info->control.vif,
382
					  fragment_data, fragment_len,
383
					  info, rts);
384
			mac_ctl |= B43_TXH_MAC_SENDRTS;
385 386 387
			len = sizeof(struct ieee80211_rts);
		}
		len += FCS_LEN;
388 389 390 391 392 393 394 395 396 397

		/* 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,
398
				      len, rts_rate_fb);
399 400 401 402 403 404 405 406

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

409
		if (rts_rate_ofdm) {
410
			extra_ft |= B43_TXH_EFT_RTS_OFDM;
411 412
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_ofdm(rts_rate);
413 414
		} else {
			extra_ft |= B43_TXH_EFT_RTS_CCK;
415 416
			txhdr->phy_rate_rts =
			    b43_plcp_get_ratecode_cck(rts_rate);
417
		}
418
		if (rts_rate_fb_ofdm)
419 420 421
			extra_ft |= B43_TXH_EFT_RTSFB_OFDM;
		else
			extra_ft |= B43_TXH_EFT_RTSFB_CCK;
422 423 424
	}

	/* Magic cookie */
425 426 427 428
	if (b43_is_old_txhdr_format(dev))
		txhdr->old_format.cookie = cpu_to_le16(cookie);
	else
		txhdr->new_format.cookie = cpu_to_le16(cookie);
429 430 431 432 433 434

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

435
	return 0;
436 437 438 439 440 441 442
}

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;
443
	struct b43_phy_g *gphy = phy->g;
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
	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 {
459
			if (dev->dev->bus->sprom.
460 461 462
			    boardflags_lo & B43_BFL_RSSI) {
				if (in_rssi > 63)
					in_rssi = 63;
463 464
				B43_WARN_ON(phy->type != B43_PHYTYPE_G);
				tmp = gphy->nrssi_lt[in_rssi];
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 514 515 516 517 518 519 520 521 522
				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;
523
	__le16 fctl;
524 525 526
	u16 phystat0, phystat3, chanstat, mactime;
	u32 macstat;
	u16 chanid;
527
	u16 phytype;
528 529 530 531 532 533 534 535 536 537
	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);
538
	phytype = chanstat & B43_RX_CHAN_PHYTYPE;
539

540
	if (unlikely(macstat & B43_RX_MAC_FCSERR)) {
541
		dev->wl->ieee_stats.dot11FCSErrorCount++;
542 543 544 545 546 547
		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;
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
	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);
569
	fctl = wlhdr->frame_control;
570 571 572 573 574 575 576 577 578 579 580 581 582 583

	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) {
584
			wlhdr_len = ieee80211_hdrlen(fctl);
585 586 587 588 589 590 591 592 593
			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
594
	/* Link quality statistics */
595
	status.noise = dev->stats.link_noise;
Michael Buesch's avatar
Michael Buesch committed
596 597 598 599 600 601
	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 {
602
		status.signal = b43_rssi_postprocess(dev, rxhdr->jssi,
Michael Buesch's avatar
Michael Buesch committed
603 604 605
						  (phystat0 & B43_RX_PHYST0_OFDM),
						  (phystat0 & B43_RX_PHYST0_GAINCTL),
						  (phystat3 & B43_RX_PHYST3_TRSTATE));
606
		status.qual = (rxhdr->jssi * 100) / B43_RX_MAX_SSI;
Michael Buesch's avatar
Michael Buesch committed
607 608
	}

609
	if (phystat0 & B43_RX_PHYST0_OFDM)
610 611
		status.rate_idx = b43_plcp_get_bitrate_idx_ofdm(plcp,
						phytype == B43_PHYTYPE_A);
612
	else
613
		status.rate_idx = b43_plcp_get_bitrate_idx_cck(plcp);
614 615 616 617 618 619
	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;
	}
620
	status.antenna = !!(phystat0 & B43_RX_PHYST0_ANT);
621 622

	/*
623 624 625 626 627 628
	 * 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.
629
	 */
630
	if (ieee80211_is_beacon(fctl) || dev->wl->radiotap_enabled) {
631 632 633 634 635 636 637 638 639 640
		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;
	}
641 642 643 644

	chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
	switch (chanstat & B43_RX_CHAN_PHYTYPE) {
	case B43_PHYTYPE_A:
645
		status.band = IEEE80211_BAND_5GHZ;
646 647 648
		B43_WARN_ON(1);
		/* FIXME: We don't really know which value the "chanid" contains.
		 *        So the following assignment might be wrong. */
649
		status.freq = b43_channel_to_freq_5ghz(chanid);
650 651
		break;
	case B43_PHYTYPE_G:
652
		status.band = IEEE80211_BAND_2GHZ;
653 654
		/* chanid is the radio channel cookie value as used
		 * to tune the radio. */
655
		status.freq = chanid + 2400;
656 657 658 659
		break;
	case B43_PHYTYPE_N:
		/* chanid is the SHM channel cookie. Which is the plain
		 * channel number in b43. */
660 661 662 663 664 665 666
		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);
		}
667 668 669
		break;
	default:
		B43_WARN_ON(1);
670
		goto drop;
671 672
	}

673 674
	memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
	ieee80211_rx_irqsafe(dev->wl->hw, skb);
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699

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

700 701 702 703
	if (b43_using_pio_transfers(dev))
		b43_pio_handle_txstatus(dev, status);
	else
		b43_dma_handle_txstatus(dev, status);
704 705

	b43_phy_txpower_check(dev, 0);
706 707
}

708 709 710
/* Fill out the mac80211 TXstatus report based on the b43-specific
 * txstatus report data. This returns a boolean whether the frame was
 * successfully transmitted. */
711 712
bool b43_fill_txstatus_report(struct b43_wldev *dev,
			      struct ieee80211_tx_info *report,
713
			      const struct b43_txstatus *status)
714
{
715
	bool frame_success = 1;
716 717 718 719 720 721 722
	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);
723 724 725

	if (status->acked) {
		/* The frame was ACKed. */
726
		report->flags |= IEEE80211_TX_STAT_ACK;
727 728
	} else {
		/* The frame was not ACKed... */
729
		if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {
730 731 732 733 734 735
			/* ...but we expected an ACK. */
			frame_success = 0;
		}
	}
	if (status->frame_count == 0) {
		/* The frame was not transmitted at all. */
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
		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;
		}
	}
758 759

	return frame_success;
760 761 762 763 764
}

/* Stop any TX operation on the device (suspend the hardware queues) */
void b43_tx_suspend(struct b43_wldev *dev)
{
765 766 767 768
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_suspend(dev);
	else
		b43_dma_tx_suspend(dev);
769 770 771 772 773
}

/* Resume any TX operation on the device (resume the hardware queues) */
void b43_tx_resume(struct b43_wldev *dev)
{
774 775 776 777
	if (b43_using_pio_transfers(dev))
		b43_pio_tx_resume(dev);
	else
		b43_dma_tx_resume(dev);
778
}