Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
xmit.c
Go to the documentation of this file.
1 /*
2 
3  Broadcom B43legacy wireless driver
4 
5  Transmission (TX/RX) related functions.
6 
7  Copyright (C) 2005 Martin Langer <[email protected]>
8  Copyright (C) 2005 Stefano Brivio <[email protected]>
9  Copyright (C) 2005, 2006 Michael Buesch <[email protected]>
10  Copyright (C) 2005 Danny van Dyk <[email protected]>
11  Copyright (C) 2005 Andreas Jaggi <[email protected]>
12  Copyright (C) 2007 Larry Finger <[email protected]>
13 
14  This program is free software; you can redistribute it and/or modify
15  it under the terms of the GNU General Public License as published by
16  the Free Software Foundation; either version 2 of the License, or
17  (at your option) any later version.
18 
19  This program is distributed in the hope that it will be useful,
20  but WITHOUT ANY WARRANTY; without even the implied warranty of
21  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22  GNU General Public License for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with this program; see the file COPYING. If not, write to
26  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
27  Boston, MA 02110-1301, USA.
28 
29 */
30 
31 #include <net/dst.h>
32 
33 #include "xmit.h"
34 #include "phy.h"
35 #include "dma.h"
36 #include "pio.h"
37 
38 
39 /* Extract the bitrate out of a CCK PLCP header. */
40 static u8 b43legacy_plcp_get_bitrate_idx_cck(struct b43legacy_plcp_hdr6 *plcp)
41 {
42  switch (plcp->raw[0]) {
43  case 0x0A:
44  return 0;
45  case 0x14:
46  return 1;
47  case 0x37:
48  return 2;
49  case 0x6E:
50  return 3;
51  }
53  return -1;
54 }
55 
56 /* Extract the bitrate out of an OFDM PLCP header. */
57 static u8 b43legacy_plcp_get_bitrate_idx_ofdm(struct b43legacy_plcp_hdr6 *plcp,
58  bool aphy)
59 {
60  int base = aphy ? 0 : 4;
61 
62  switch (plcp->raw[0] & 0xF) {
63  case 0xB:
64  return base + 0;
65  case 0xF:
66  return base + 1;
67  case 0xA:
68  return base + 2;
69  case 0xE:
70  return base + 3;
71  case 0x9:
72  return base + 4;
73  case 0xD:
74  return base + 5;
75  case 0x8:
76  return base + 6;
77  case 0xC:
78  return base + 7;
79  }
81  return -1;
82 }
83 
85 {
86  switch (bitrate) {
88  return 0x0A;
90  return 0x14;
92  return 0x37;
94  return 0x6E;
95  }
97  return 0;
98 }
99 
101 {
102  switch (bitrate) {
104  return 0xB;
106  return 0xF;
108  return 0xA;
110  return 0xE;
112  return 0x9;
114  return 0xD;
116  return 0x8;
118  return 0xC;
119  }
120  B43legacy_BUG_ON(1);
121  return 0;
122 }
123 
124 void b43legacy_generate_plcp_hdr(struct b43legacy_plcp_hdr4 *plcp,
125  const u16 octets, const u8 bitrate)
126 {
127  __le32 *data = &(plcp->data);
128  __u8 *raw = plcp->raw;
129 
130  if (b43legacy_is_ofdm_rate(bitrate)) {
131  u16 d;
132 
134  B43legacy_WARN_ON(octets & 0xF000);
135  d |= (octets << 5);
136  *data = cpu_to_le32(d);
137  } else {
138  u32 plen;
139 
140  plen = octets * 16 / bitrate;
141  if ((octets * 16 % bitrate) > 0) {
142  plen++;
143  if ((bitrate == B43legacy_CCK_RATE_11MB)
144  && ((octets * 8 % 11) < 4))
145  raw[1] = 0x84;
146  else
147  raw[1] = 0x04;
148  } else
149  raw[1] = 0x04;
150  *data |= cpu_to_le32(plen << 16);
151  raw[0] = b43legacy_plcp_get_ratecode_cck(bitrate);
152  }
153 }
154 
155 static u8 b43legacy_calc_fallback_rate(u8 bitrate)
156 {
157  switch (bitrate) {
159  return B43legacy_CCK_RATE_1MB;
161  return B43legacy_CCK_RATE_1MB;
163  return B43legacy_CCK_RATE_2MB;
165  return B43legacy_CCK_RATE_5MB;
167  return B43legacy_CCK_RATE_5MB;
182  }
183  B43legacy_BUG_ON(1);
184  return 0;
185 }
186 
187 static int generate_txhdr_fw3(struct b43legacy_wldev *dev,
188  struct b43legacy_txhdr_fw3 *txhdr,
189  const unsigned char *fragment_data,
190  unsigned int fragment_len,
191  struct ieee80211_tx_info *info,
192  u16 cookie)
193 {
194  const struct ieee80211_hdr *wlhdr;
195  int use_encryption = !!info->control.hw_key;
196  u8 rate;
197  struct ieee80211_rate *rate_fb;
198  int rate_ofdm;
199  int rate_fb_ofdm;
200  unsigned int plcp_fragment_len;
201  u32 mac_ctl = 0;
202  u16 phy_ctl = 0;
203  struct ieee80211_rate *tx_rate;
204  struct ieee80211_tx_rate *rates;
205 
206  wlhdr = (const struct ieee80211_hdr *)fragment_data;
207 
208  memset(txhdr, 0, sizeof(*txhdr));
209 
210  tx_rate = ieee80211_get_tx_rate(dev->wl->hw, info);
211 
212  rate = tx_rate->hw_value;
213  rate_ofdm = b43legacy_is_ofdm_rate(rate);
214  rate_fb = ieee80211_get_alt_retry_rate(dev->wl->hw, info, 0) ? : tx_rate;
215  rate_fb_ofdm = b43legacy_is_ofdm_rate(rate_fb->hw_value);
216 
217  txhdr->mac_frame_ctl = wlhdr->frame_control;
218  memcpy(txhdr->tx_receiver, wlhdr->addr1, 6);
219 
220  /* Calculate duration for fallback rate */
221  if ((rate_fb->hw_value == rate) ||
222  (wlhdr->duration_id & cpu_to_le16(0x8000)) ||
223  (wlhdr->duration_id == cpu_to_le16(0))) {
224  /* If the fallback rate equals the normal rate or the
225  * dur_id field contains an AID, CFP magic or 0,
226  * use the original dur_id field. */
227  txhdr->dur_fb = wlhdr->duration_id;
228  } else {
229  txhdr->dur_fb = ieee80211_generic_frame_duration(dev->wl->hw,
230  info->control.vif,
231  info->band,
232  fragment_len,
233  rate_fb);
234  }
235 
236  plcp_fragment_len = fragment_len + FCS_LEN;
237  if (use_encryption) {
238  u8 key_idx = info->control.hw_key->hw_key_idx;
239  struct b43legacy_key *key;
240  int wlhdr_len;
241  size_t iv_len;
242 
243  B43legacy_WARN_ON(key_idx >= dev->max_nr_keys);
244  key = &(dev->key[key_idx]);
245 
246  if (key->enabled) {
247  /* Hardware appends ICV. */
248  plcp_fragment_len += info->control.hw_key->icv_len;
249 
250  key_idx = b43legacy_kidx_to_fw(dev, key_idx);
251  mac_ctl |= (key_idx << B43legacy_TX4_MAC_KEYIDX_SHIFT) &
253  mac_ctl |= (key->algorithm <<
256  wlhdr_len = ieee80211_hdrlen(wlhdr->frame_control);
257  iv_len = min((size_t)info->control.hw_key->iv_len,
258  ARRAY_SIZE(txhdr->iv));
259  memcpy(txhdr->iv, ((u8 *)wlhdr) + wlhdr_len, iv_len);
260  } else {
261  /* This key is invalid. This might only happen
262  * in a short timeframe after machine resume before
263  * we were able to reconfigure keys.
264  * Drop this packet completely. Do not transmit it
265  * unencrypted to avoid leaking information. */
266  return -ENOKEY;
267  }
268  }
269  b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
270  (&txhdr->plcp), plcp_fragment_len,
271  rate);
272  b43legacy_generate_plcp_hdr(&txhdr->plcp_fb, plcp_fragment_len,
273  rate_fb->hw_value);
274 
275  /* PHY TX Control word */
276  if (rate_ofdm)
277  phy_ctl |= B43legacy_TX4_PHY_ENC_OFDM;
278  if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
279  phy_ctl |= B43legacy_TX4_PHY_SHORTPRMBL;
280  phy_ctl |= B43legacy_TX4_PHY_ANTLAST;
281 
282  /* MAC control */
283  rates = info->control.rates;
284  if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
285  mac_ctl |= B43legacy_TX4_MAC_ACK;
287  mac_ctl |= B43legacy_TX4_MAC_HWSEQ;
289  mac_ctl |= B43legacy_TX4_MAC_STMSDU;
290  if (rate_fb_ofdm)
292 
293  /* Overwrite rates[0].count to make the retry calculation
294  * in the tx status easier. need the actual retry limit to
295  * detect whether the fallback rate was used.
296  */
297  if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
298  (rates[0].count <= dev->wl->hw->conf.long_frame_max_tx_count)) {
299  rates[0].count = dev->wl->hw->conf.long_frame_max_tx_count;
300  mac_ctl |= B43legacy_TX4_MAC_LONGFRAME;
301  } else {
302  rates[0].count = dev->wl->hw->conf.short_frame_max_tx_count;
303  }
304 
305  /* Generate the RTS or CTS-to-self frame */
306  if ((rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
307  (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)) {
308  unsigned int len;
309  struct ieee80211_hdr *hdr;
310  int rts_rate;
311  int rts_rate_fb;
312  int rts_rate_fb_ofdm;
313 
314  rts_rate = ieee80211_get_rts_cts_rate(dev->wl->hw, info)->hw_value;
315  rts_rate_fb = b43legacy_calc_fallback_rate(rts_rate);
316  rts_rate_fb_ofdm = b43legacy_is_ofdm_rate(rts_rate_fb);
317  if (rts_rate_fb_ofdm)
319 
320  if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
321  ieee80211_ctstoself_get(dev->wl->hw,
322  info->control.vif,
323  fragment_data,
324  fragment_len, info,
325  (struct ieee80211_cts *)
326  (txhdr->rts_frame));
327  mac_ctl |= B43legacy_TX4_MAC_SENDCTS;
328  len = sizeof(struct ieee80211_cts);
329  } else {
330  ieee80211_rts_get(dev->wl->hw,
331  info->control.vif,
332  fragment_data, fragment_len, info,
333  (struct ieee80211_rts *)
334  (txhdr->rts_frame));
335  mac_ctl |= B43legacy_TX4_MAC_SENDRTS;
336  len = sizeof(struct ieee80211_rts);
337  }
338  len += FCS_LEN;
339  b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
340  (&txhdr->rts_plcp),
341  len, rts_rate);
343  len, rts_rate_fb);
344  hdr = (struct ieee80211_hdr *)(&txhdr->rts_frame);
345  txhdr->rts_dur_fb = hdr->duration_id;
346  }
347 
348  /* Magic cookie */
349  txhdr->cookie = cpu_to_le16(cookie);
350 
351  /* Apply the bitfields */
352  txhdr->mac_ctl = cpu_to_le32(mac_ctl);
353  txhdr->phy_ctl = cpu_to_le16(phy_ctl);
354 
355  return 0;
356 }
357 
359  u8 *txhdr,
360  const unsigned char *fragment_data,
361  unsigned int fragment_len,
362  struct ieee80211_tx_info *info,
363  u16 cookie)
364 {
365  return generate_txhdr_fw3(dev, (struct b43legacy_txhdr_fw3 *)txhdr,
366  fragment_data, fragment_len,
367  info, cookie);
368 }
369 
370 static s8 b43legacy_rssi_postprocess(struct b43legacy_wldev *dev,
371  u8 in_rssi, int ofdm,
372  int adjust_2053, int adjust_2050)
373 {
374  struct b43legacy_phy *phy = &dev->phy;
375  s32 tmp;
376 
377  switch (phy->radio_ver) {
378  case 0x2050:
379  if (ofdm) {
380  tmp = in_rssi;
381  if (tmp > 127)
382  tmp -= 256;
383  tmp *= 73;
384  tmp /= 64;
385  if (adjust_2050)
386  tmp += 25;
387  else
388  tmp -= 3;
389  } else {
390  if (dev->dev->bus->sprom.boardflags_lo
391  & B43legacy_BFL_RSSI) {
392  if (in_rssi > 63)
393  in_rssi = 63;
394  tmp = phy->nrssi_lt[in_rssi];
395  tmp = 31 - tmp;
396  tmp *= -131;
397  tmp /= 128;
398  tmp -= 57;
399  } else {
400  tmp = in_rssi;
401  tmp = 31 - tmp;
402  tmp *= -149;
403  tmp /= 128;
404  tmp -= 68;
405  }
406  if (phy->type == B43legacy_PHYTYPE_G &&
407  adjust_2050)
408  tmp += 25;
409  }
410  break;
411  case 0x2060:
412  if (in_rssi > 127)
413  tmp = in_rssi - 256;
414  else
415  tmp = in_rssi;
416  break;
417  default:
418  tmp = in_rssi;
419  tmp -= 11;
420  tmp *= 103;
421  tmp /= 64;
422  if (adjust_2053)
423  tmp -= 109;
424  else
425  tmp -= 83;
426  }
427 
428  return (s8)tmp;
429 }
430 
431 void b43legacy_rx(struct b43legacy_wldev *dev,
432  struct sk_buff *skb,
433  const void *_rxhdr)
434 {
435  struct ieee80211_rx_status status;
436  struct b43legacy_plcp_hdr6 *plcp;
437  struct ieee80211_hdr *wlhdr;
438  const struct b43legacy_rxhdr_fw3 *rxhdr = _rxhdr;
439  __le16 fctl;
440  u16 phystat0;
441  u16 phystat3;
442  u16 chanstat;
443  u16 mactime;
444  u32 macstat;
445  u16 chanid;
446  u8 jssi;
447  int padding;
448 
449  memset(&status, 0, sizeof(status));
450 
451  /* Get metadata about the frame from the header. */
452  phystat0 = le16_to_cpu(rxhdr->phy_status0);
453  phystat3 = le16_to_cpu(rxhdr->phy_status3);
454  jssi = rxhdr->jssi;
455  macstat = le16_to_cpu(rxhdr->mac_status);
456  mactime = le16_to_cpu(rxhdr->mac_time);
457  chanstat = le16_to_cpu(rxhdr->channel);
458 
459  if (macstat & B43legacy_RX_MAC_FCSERR)
460  dev->wl->ieee_stats.dot11FCSErrorCount++;
461 
462  /* Skip PLCP and padding */
463  padding = (macstat & B43legacy_RX_MAC_PADDING) ? 2 : 0;
464  if (unlikely(skb->len < (sizeof(struct b43legacy_plcp_hdr6) +
465  padding))) {
466  b43legacydbg(dev->wl, "RX: Packet size underrun (1)\n");
467  goto drop;
468  }
469  plcp = (struct b43legacy_plcp_hdr6 *)(skb->data + padding);
470  skb_pull(skb, sizeof(struct b43legacy_plcp_hdr6) + padding);
471  /* The skb contains the Wireless Header + payload data now */
472  if (unlikely(skb->len < (2+2+6/*minimum hdr*/ + FCS_LEN))) {
473  b43legacydbg(dev->wl, "RX: Packet size underrun (2)\n");
474  goto drop;
475  }
476  wlhdr = (struct ieee80211_hdr *)(skb->data);
477  fctl = wlhdr->frame_control;
478 
479  if ((macstat & B43legacy_RX_MAC_DEC) &&
480  !(macstat & B43legacy_RX_MAC_DECERR)) {
481  unsigned int keyidx;
482  int wlhdr_len;
483  int iv_len;
484  int icv_len;
485 
486  keyidx = ((macstat & B43legacy_RX_MAC_KEYIDX)
488  /* We must adjust the key index here. We want the "physical"
489  * key index, but the ucode passed it slightly different.
490  */
491  keyidx = b43legacy_kidx_to_raw(dev, keyidx);
492  B43legacy_WARN_ON(keyidx >= dev->max_nr_keys);
493 
494  if (dev->key[keyidx].algorithm != B43legacy_SEC_ALGO_NONE) {
495  /* Remove PROTECTED flag to mark it as decrypted. */
496  B43legacy_WARN_ON(!ieee80211_has_protected(fctl));
498  wlhdr->frame_control = fctl;
499 
500  wlhdr_len = ieee80211_hdrlen(fctl);
501  if (unlikely(skb->len < (wlhdr_len + 3))) {
502  b43legacydbg(dev->wl, "RX: Packet size"
503  " underrun3\n");
504  goto drop;
505  }
506  if (skb->data[wlhdr_len + 3] & (1 << 5)) {
507  /* The Ext-IV Bit is set in the "KeyID"
508  * octet of the IV.
509  */
510  iv_len = 8;
511  icv_len = 8;
512  } else {
513  iv_len = 4;
514  icv_len = 4;
515  }
516  if (unlikely(skb->len < (wlhdr_len + iv_len +
517  icv_len))) {
518  b43legacydbg(dev->wl, "RX: Packet size"
519  " underrun4\n");
520  goto drop;
521  }
522  /* Remove the IV */
523  memmove(skb->data + iv_len, skb->data, wlhdr_len);
524  skb_pull(skb, iv_len);
525  /* Remove the ICV */
526  skb_trim(skb, skb->len - icv_len);
527 
528  status.flag |= RX_FLAG_DECRYPTED;
529  }
530  }
531 
532  status.signal = b43legacy_rssi_postprocess(dev, jssi,
533  (phystat0 & B43legacy_RX_PHYST0_OFDM),
534  (phystat0 & B43legacy_RX_PHYST0_GAINCTL),
535  (phystat3 & B43legacy_RX_PHYST3_TRSTATE));
536  /* change to support A PHY */
537  if (phystat0 & B43legacy_RX_PHYST0_OFDM)
538  status.rate_idx = b43legacy_plcp_get_bitrate_idx_ofdm(plcp, false);
539  else
540  status.rate_idx = b43legacy_plcp_get_bitrate_idx_cck(plcp);
541  status.antenna = !!(phystat0 & B43legacy_RX_PHYST0_ANT);
542 
543  /*
544  * All frames on monitor interfaces and beacons always need a full
545  * 64-bit timestamp. Monitor interfaces need it for diagnostic
546  * purposes and beacons for IBSS merging.
547  * This code assumes we get to process the packet within 16 bits
548  * of timestamp, i.e. about 65 milliseconds after the PHY received
549  * the first symbol.
550  */
551  if (ieee80211_is_beacon(fctl) || dev->wl->radiotap_enabled) {
552  u16 low_mactime_now;
553 
554  b43legacy_tsf_read(dev, &status.mactime);
555  low_mactime_now = status.mactime;
556  status.mactime = status.mactime & ~0xFFFFULL;
557  status.mactime += mactime;
558  if (low_mactime_now <= mactime)
559  status.mactime -= 0x10000;
560  status.flag |= RX_FLAG_MACTIME_MPDU;
561  }
562 
563  chanid = (chanstat & B43legacy_RX_CHAN_ID) >>
565  switch (chanstat & B43legacy_RX_CHAN_PHYTYPE) {
566  case B43legacy_PHYTYPE_B:
567  case B43legacy_PHYTYPE_G:
568  status.band = IEEE80211_BAND_2GHZ;
569  status.freq = chanid + 2400;
570  break;
571  default:
572  b43legacywarn(dev->wl, "Unexpected value for chanstat (0x%X)\n",
573  chanstat);
574  }
575 
576  memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
577  ieee80211_rx_irqsafe(dev->wl->hw, skb);
578 
579  return;
580 drop:
581  b43legacydbg(dev->wl, "RX: Packet dropped\n");
582  dev_kfree_skb_any(skb);
583 }
584 
586  const struct b43legacy_txstatus *status)
587 {
588  b43legacy_debugfs_log_txstat(dev, status);
589 
590  if (status->intermediate)
591  return;
592  if (status->for_ampdu)
593  return;
594  if (!status->acked)
595  dev->wl->ieee_stats.dot11ACKFailureCount++;
596  if (status->rts_count) {
597  if (status->rts_count == 0xF) /* FIXME */
598  dev->wl->ieee_stats.dot11RTSFailureCount++;
599  else
600  dev->wl->ieee_stats.dot11RTSSuccessCount++;
601  }
602 
603  if (b43legacy_using_pio(dev))
604  b43legacy_pio_handle_txstatus(dev, status);
605  else
606  b43legacy_dma_handle_txstatus(dev, status);
607 }
608 
609 /* Handle TX status report as received through DMA/PIO queues */
611  const struct b43legacy_hwtxstatus *hw)
612 {
613  struct b43legacy_txstatus status;
614  u8 tmp;
615 
616  status.cookie = le16_to_cpu(hw->cookie);
617  status.seq = le16_to_cpu(hw->seq);
618  status.phy_stat = hw->phy_stat;
619  tmp = hw->count;
620  status.frame_count = (tmp >> 4);
621  status.rts_count = (tmp & 0x0F);
622  tmp = hw->flags << 1;
623  status.supp_reason = ((tmp & 0x1C) >> 2);
624  status.pm_indicated = !!(tmp & 0x80);
625  status.intermediate = !!(tmp & 0x40);
626  status.for_ampdu = !!(tmp & 0x20);
627  status.acked = !!(tmp & 0x02);
628 
629  b43legacy_handle_txstatus(dev, &status);
630 }
631 
632 /* Stop any TX operation on the device (suspend the hardware queues) */
634 {
635  if (b43legacy_using_pio(dev))
637  else
639 }
640 
641 /* Resume any TX operation on the device (resume the hardware queues) */
643 {
644  if (b43legacy_using_pio(dev))
646  else
648 }
649 
650 /* Initialize the QoS parameters */
652 {
653  /* FIXME: This function must probably be called from the mac80211
654  * config callback. */
655 return;
656 
658  /* FIXME kill magic */
659  b43legacy_write16(dev, 0x688,
660  b43legacy_read16(dev, 0x688) | 0x4);
661 
662 
663  /*TODO: We might need some stack support here to get the values. */
664 }