b43legacy: Convert to use of the new SPROM structure
[linux-2.6.git] / drivers / net / wireless / b43legacy / xmit.c
1 /*
2
3   Broadcom B43legacy wireless driver
4
5   Transmission (TX/RX) related functions.
6
7   Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
8   Copyright (C) 2005 Stefano Brivio <stefano.brivio@polimi.it>
9   Copyright (C) 2005, 2006 Michael Buesch <mb@bu3sch.de>
10   Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
11   Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
12   Copyright (C) 2007 Larry Finger <Larry.Finger@lwfinger.net>
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_cck(struct b43legacy_plcp_hdr6 *plcp)
41 {
42         switch (plcp->raw[0]) {
43         case 0x0A:
44                 return B43legacy_CCK_RATE_1MB;
45         case 0x14:
46                 return B43legacy_CCK_RATE_2MB;
47         case 0x37:
48                 return B43legacy_CCK_RATE_5MB;
49         case 0x6E:
50                 return B43legacy_CCK_RATE_11MB;
51         }
52         B43legacy_BUG_ON(1);
53         return 0;
54 }
55
56 /* Extract the bitrate out of an OFDM PLCP header. */
57 static u8 b43legacy_plcp_get_bitrate_ofdm(struct b43legacy_plcp_hdr6 *plcp)
58 {
59         switch (plcp->raw[0] & 0xF) {
60         case 0xB:
61                 return B43legacy_OFDM_RATE_6MB;
62         case 0xF:
63                 return B43legacy_OFDM_RATE_9MB;
64         case 0xA:
65                 return B43legacy_OFDM_RATE_12MB;
66         case 0xE:
67                 return B43legacy_OFDM_RATE_18MB;
68         case 0x9:
69                 return B43legacy_OFDM_RATE_24MB;
70         case 0xD:
71                 return B43legacy_OFDM_RATE_36MB;
72         case 0x8:
73                 return B43legacy_OFDM_RATE_48MB;
74         case 0xC:
75                 return B43legacy_OFDM_RATE_54MB;
76         }
77         B43legacy_BUG_ON(1);
78         return 0;
79 }
80
81 u8 b43legacy_plcp_get_ratecode_cck(const u8 bitrate)
82 {
83         switch (bitrate) {
84         case B43legacy_CCK_RATE_1MB:
85                 return 0x0A;
86         case B43legacy_CCK_RATE_2MB:
87                 return 0x14;
88         case B43legacy_CCK_RATE_5MB:
89                 return 0x37;
90         case B43legacy_CCK_RATE_11MB:
91                 return 0x6E;
92         }
93         B43legacy_BUG_ON(1);
94         return 0;
95 }
96
97 u8 b43legacy_plcp_get_ratecode_ofdm(const u8 bitrate)
98 {
99         switch (bitrate) {
100         case B43legacy_OFDM_RATE_6MB:
101                 return 0xB;
102         case B43legacy_OFDM_RATE_9MB:
103                 return 0xF;
104         case B43legacy_OFDM_RATE_12MB:
105                 return 0xA;
106         case B43legacy_OFDM_RATE_18MB:
107                 return 0xE;
108         case B43legacy_OFDM_RATE_24MB:
109                 return 0x9;
110         case B43legacy_OFDM_RATE_36MB:
111                 return 0xD;
112         case B43legacy_OFDM_RATE_48MB:
113                 return 0x8;
114         case B43legacy_OFDM_RATE_54MB:
115                 return 0xC;
116         }
117         B43legacy_BUG_ON(1);
118         return 0;
119 }
120
121 void b43legacy_generate_plcp_hdr(struct b43legacy_plcp_hdr4 *plcp,
122                                  const u16 octets, const u8 bitrate)
123 {
124         __le32 *data = &(plcp->data);
125         __u8 *raw = plcp->raw;
126
127         if (b43legacy_is_ofdm_rate(bitrate)) {
128                 u16 d;
129
130                 d = b43legacy_plcp_get_ratecode_ofdm(bitrate);
131                 B43legacy_WARN_ON(octets & 0xF000);
132                 d |= (octets << 5);
133                 *data = cpu_to_le32(d);
134         } else {
135                 u32 plen;
136
137                 plen = octets * 16 / bitrate;
138                 if ((octets * 16 % bitrate) > 0) {
139                         plen++;
140                         if ((bitrate == B43legacy_CCK_RATE_11MB)
141                             && ((octets * 8 % 11) < 4))
142                                 raw[1] = 0x84;
143                         else
144                                 raw[1] = 0x04;
145                 } else
146                         raw[1] = 0x04;
147                 *data |= cpu_to_le32(plen << 16);
148                 raw[0] = b43legacy_plcp_get_ratecode_cck(bitrate);
149         }
150 }
151
152 static u8 b43legacy_calc_fallback_rate(u8 bitrate)
153 {
154         switch (bitrate) {
155         case B43legacy_CCK_RATE_1MB:
156                 return B43legacy_CCK_RATE_1MB;
157         case B43legacy_CCK_RATE_2MB:
158                 return B43legacy_CCK_RATE_1MB;
159         case B43legacy_CCK_RATE_5MB:
160                 return B43legacy_CCK_RATE_2MB;
161         case B43legacy_CCK_RATE_11MB:
162                 return B43legacy_CCK_RATE_5MB;
163         case B43legacy_OFDM_RATE_6MB:
164                 return B43legacy_CCK_RATE_5MB;
165         case B43legacy_OFDM_RATE_9MB:
166                 return B43legacy_OFDM_RATE_6MB;
167         case B43legacy_OFDM_RATE_12MB:
168                 return B43legacy_OFDM_RATE_9MB;
169         case B43legacy_OFDM_RATE_18MB:
170                 return B43legacy_OFDM_RATE_12MB;
171         case B43legacy_OFDM_RATE_24MB:
172                 return B43legacy_OFDM_RATE_18MB;
173         case B43legacy_OFDM_RATE_36MB:
174                 return B43legacy_OFDM_RATE_24MB;
175         case B43legacy_OFDM_RATE_48MB:
176                 return B43legacy_OFDM_RATE_36MB;
177         case B43legacy_OFDM_RATE_54MB:
178                 return B43legacy_OFDM_RATE_48MB;
179         }
180         B43legacy_BUG_ON(1);
181         return 0;
182 }
183
184 static void generate_txhdr_fw3(struct b43legacy_wldev *dev,
185                                struct b43legacy_txhdr_fw3 *txhdr,
186                                const unsigned char *fragment_data,
187                                unsigned int fragment_len,
188                                const struct ieee80211_tx_control *txctl,
189                                u16 cookie)
190 {
191         const struct ieee80211_hdr *wlhdr;
192         int use_encryption = (!(txctl->flags & IEEE80211_TXCTL_DO_NOT_ENCRYPT));
193         u16 fctl;
194         u8 rate;
195         u8 rate_fb;
196         int rate_ofdm;
197         int rate_fb_ofdm;
198         unsigned int plcp_fragment_len;
199         u32 mac_ctl = 0;
200         u16 phy_ctl = 0;
201
202         wlhdr = (const struct ieee80211_hdr *)fragment_data;
203         fctl = le16_to_cpu(wlhdr->frame_control);
204
205         memset(txhdr, 0, sizeof(*txhdr));
206
207         rate = txctl->tx_rate;
208         rate_ofdm = b43legacy_is_ofdm_rate(rate);
209         rate_fb = (txctl->alt_retry_rate == -1) ? rate : txctl->alt_retry_rate;
210         rate_fb_ofdm = b43legacy_is_ofdm_rate(rate_fb);
211
212         txhdr->mac_frame_ctl = wlhdr->frame_control;
213         memcpy(txhdr->tx_receiver, wlhdr->addr1, 6);
214
215         /* Calculate duration for fallback rate */
216         if ((rate_fb == rate) ||
217             (wlhdr->duration_id & cpu_to_le16(0x8000)) ||
218             (wlhdr->duration_id == cpu_to_le16(0))) {
219                 /* If the fallback rate equals the normal rate or the
220                  * dur_id field contains an AID, CFP magic or 0,
221                  * use the original dur_id field. */
222                 txhdr->dur_fb = wlhdr->duration_id;
223         } else {
224                 int fbrate_base100kbps = B43legacy_RATE_TO_100KBPS(rate_fb);
225                 txhdr->dur_fb = ieee80211_generic_frame_duration(dev->wl->hw,
226                                                          dev->wl->if_id,
227                                                          fragment_len,
228                                                          fbrate_base100kbps);
229         }
230
231         plcp_fragment_len = fragment_len + FCS_LEN;
232         if (use_encryption) {
233                 u8 key_idx = (u16)(txctl->key_idx);
234                 struct b43legacy_key *key;
235                 int wlhdr_len;
236                 size_t iv_len;
237
238                 B43legacy_WARN_ON(key_idx >= dev->max_nr_keys);
239                 key = &(dev->key[key_idx]);
240
241                 if (key->enabled) {
242                         /* Hardware appends ICV. */
243                         plcp_fragment_len += txctl->icv_len;
244
245                         key_idx = b43legacy_kidx_to_fw(dev, key_idx);
246                         mac_ctl |= (key_idx << B43legacy_TX4_MAC_KEYIDX_SHIFT) &
247                                    B43legacy_TX4_MAC_KEYIDX;
248                         mac_ctl |= (key->algorithm <<
249                                    B43legacy_TX4_MAC_KEYALG_SHIFT) &
250                                    B43legacy_TX4_MAC_KEYALG;
251                         wlhdr_len = ieee80211_get_hdrlen(fctl);
252                         iv_len = min((size_t)txctl->iv_len,
253                                      ARRAY_SIZE(txhdr->iv));
254                         memcpy(txhdr->iv, ((u8 *)wlhdr) + wlhdr_len, iv_len);
255                 }
256         }
257         b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
258                                     (&txhdr->plcp), plcp_fragment_len,
259                                     rate);
260         b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
261                                     (&txhdr->plcp_fb), plcp_fragment_len,
262                                     rate_fb);
263
264         /* PHY TX Control word */
265         if (rate_ofdm)
266                 phy_ctl |= B43legacy_TX4_PHY_OFDM;
267         if (dev->short_preamble)
268                 phy_ctl |= B43legacy_TX4_PHY_SHORTPRMBL;
269         switch (txctl->antenna_sel_tx) {
270         case 0:
271                 phy_ctl |= B43legacy_TX4_PHY_ANTLAST;
272                 break;
273         case 1:
274                 phy_ctl |= B43legacy_TX4_PHY_ANT0;
275                 break;
276         case 2:
277                 phy_ctl |= B43legacy_TX4_PHY_ANT1;
278                 break;
279         default:
280                 B43legacy_BUG_ON(1);
281         }
282
283         /* MAC control */
284         if (!(txctl->flags & IEEE80211_TXCTL_NO_ACK))
285                 mac_ctl |= B43legacy_TX4_MAC_ACK;
286         if (!(((fctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) &&
287               ((fctl & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PSPOLL)))
288                 mac_ctl |= B43legacy_TX4_MAC_HWSEQ;
289         if (txctl->flags & IEEE80211_TXCTL_FIRST_FRAGMENT)
290                 mac_ctl |= B43legacy_TX4_MAC_STMSDU;
291         if (rate_fb_ofdm)
292                 mac_ctl |= B43legacy_TX4_MAC_FALLBACKOFDM;
293         if (txctl->flags & IEEE80211_TXCTL_LONG_RETRY_LIMIT)
294                 mac_ctl |= B43legacy_TX4_MAC_LONGFRAME;
295
296         /* Generate the RTS or CTS-to-self frame */
297         if ((txctl->flags & IEEE80211_TXCTL_USE_RTS_CTS) ||
298             (txctl->flags & IEEE80211_TXCTL_USE_CTS_PROTECT)) {
299                 unsigned int len;
300                 struct ieee80211_hdr *hdr;
301                 int rts_rate;
302                 int rts_rate_fb;
303                 int rts_rate_ofdm;
304                 int rts_rate_fb_ofdm;
305
306                 rts_rate = txctl->rts_cts_rate;
307                 rts_rate_ofdm = b43legacy_is_ofdm_rate(rts_rate);
308                 rts_rate_fb = b43legacy_calc_fallback_rate(rts_rate);
309                 rts_rate_fb_ofdm = b43legacy_is_ofdm_rate(rts_rate_fb);
310                 if (rts_rate_fb_ofdm)
311                         mac_ctl |= B43legacy_TX4_MAC_CTSFALLBACKOFDM;
312
313                 if (txctl->flags & IEEE80211_TXCTL_USE_CTS_PROTECT) {
314                         ieee80211_ctstoself_get(dev->wl->hw,
315                                                 dev->wl->if_id,
316                                                 fragment_data,
317                                                 fragment_len, txctl,
318                                                 (struct ieee80211_cts *)
319                                                 (txhdr->rts_frame));
320                         mac_ctl |= B43legacy_TX4_MAC_SENDCTS;
321                         len = sizeof(struct ieee80211_cts);
322                 } else {
323                         ieee80211_rts_get(dev->wl->hw,
324                                           dev->wl->if_id,
325                                           fragment_data, fragment_len, txctl,
326                                           (struct ieee80211_rts *)
327                                           (txhdr->rts_frame));
328                         mac_ctl |= B43legacy_TX4_MAC_SENDRTS;
329                         len = sizeof(struct ieee80211_rts);
330                 }
331                 len += FCS_LEN;
332                 b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
333                                             (&txhdr->rts_plcp),
334                                             len, rts_rate);
335                 b43legacy_generate_plcp_hdr((struct b43legacy_plcp_hdr4 *)
336                                             (&txhdr->rts_plcp_fb),
337                                             len, rts_rate_fb);
338                 hdr = (struct ieee80211_hdr *)(&txhdr->rts_frame);
339                 txhdr->rts_dur_fb = hdr->duration_id;
340         }
341
342         /* Magic cookie */
343         txhdr->cookie = cpu_to_le16(cookie);
344
345         /* Apply the bitfields */
346         txhdr->mac_ctl = cpu_to_le32(mac_ctl);
347         txhdr->phy_ctl = cpu_to_le16(phy_ctl);
348 }
349
350 void b43legacy_generate_txhdr(struct b43legacy_wldev *dev,
351                               u8 *txhdr,
352                               const unsigned char *fragment_data,
353                               unsigned int fragment_len,
354                               const struct ieee80211_tx_control *txctl,
355                               u16 cookie)
356 {
357         generate_txhdr_fw3(dev, (struct b43legacy_txhdr_fw3 *)txhdr,
358                            fragment_data, fragment_len,
359                            txctl, cookie);
360 }
361
362 static s8 b43legacy_rssi_postprocess(struct b43legacy_wldev *dev,
363                                      u8 in_rssi, int ofdm,
364                                      int adjust_2053, int adjust_2050)
365 {
366         struct b43legacy_phy *phy = &dev->phy;
367         s32 tmp;
368
369         switch (phy->radio_ver) {
370         case 0x2050:
371                 if (ofdm) {
372                         tmp = in_rssi;
373                         if (tmp > 127)
374                                 tmp -= 256;
375                         tmp *= 73;
376                         tmp /= 64;
377                         if (adjust_2050)
378                                 tmp += 25;
379                         else
380                                 tmp -= 3;
381                 } else {
382                         if (dev->dev->bus->sprom.boardflags_lo
383                             & B43legacy_BFL_RSSI) {
384                                 if (in_rssi > 63)
385                                         in_rssi = 63;
386                                 tmp = phy->nrssi_lt[in_rssi];
387                                 tmp = 31 - tmp;
388                                 tmp *= -131;
389                                 tmp /= 128;
390                                 tmp -= 57;
391                         } else {
392                                 tmp = in_rssi;
393                                 tmp = 31 - tmp;
394                                 tmp *= -149;
395                                 tmp /= 128;
396                                 tmp -= 68;
397                         }
398                         if (phy->type == B43legacy_PHYTYPE_G &&
399                             adjust_2050)
400                                 tmp += 25;
401                 }
402                 break;
403         case 0x2060:
404                 if (in_rssi > 127)
405                         tmp = in_rssi - 256;
406                 else
407                         tmp = in_rssi;
408                 break;
409         default:
410                 tmp = in_rssi;
411                 tmp -= 11;
412                 tmp *= 103;
413                 tmp /= 64;
414                 if (adjust_2053)
415                         tmp -= 109;
416                 else
417                         tmp -= 83;
418         }
419
420         return (s8)tmp;
421 }
422
423 void b43legacy_rx(struct b43legacy_wldev *dev,
424                   struct sk_buff *skb,
425                   const void *_rxhdr)
426 {
427         struct ieee80211_rx_status status;
428         struct b43legacy_plcp_hdr6 *plcp;
429         struct ieee80211_hdr *wlhdr;
430         const struct b43legacy_rxhdr_fw3 *rxhdr = _rxhdr;
431         u16 fctl;
432         u16 phystat0;
433         u16 phystat3;
434         u16 chanstat;
435         u16 mactime;
436         u32 macstat;
437         u16 chanid;
438         u8 jssi;
439         int padding;
440
441         memset(&status, 0, sizeof(status));
442
443         /* Get metadata about the frame from the header. */
444         phystat0 = le16_to_cpu(rxhdr->phy_status0);
445         phystat3 = le16_to_cpu(rxhdr->phy_status3);
446         jssi = rxhdr->jssi;
447         macstat = le16_to_cpu(rxhdr->mac_status);
448         mactime = le16_to_cpu(rxhdr->mac_time);
449         chanstat = le16_to_cpu(rxhdr->channel);
450
451         if (macstat & B43legacy_RX_MAC_FCSERR)
452                 dev->wl->ieee_stats.dot11FCSErrorCount++;
453
454         /* Skip PLCP and padding */
455         padding = (macstat & B43legacy_RX_MAC_PADDING) ? 2 : 0;
456         if (unlikely(skb->len < (sizeof(struct b43legacy_plcp_hdr6) +
457             padding))) {
458                 b43legacydbg(dev->wl, "RX: Packet size underrun (1)\n");
459                 goto drop;
460         }
461         plcp = (struct b43legacy_plcp_hdr6 *)(skb->data + padding);
462         skb_pull(skb, sizeof(struct b43legacy_plcp_hdr6) + padding);
463         /* The skb contains the Wireless Header + payload data now */
464         if (unlikely(skb->len < (2+2+6/*minimum hdr*/ + FCS_LEN))) {
465                 b43legacydbg(dev->wl, "RX: Packet size underrun (2)\n");
466                 goto drop;
467         }
468         wlhdr = (struct ieee80211_hdr *)(skb->data);
469         fctl = le16_to_cpu(wlhdr->frame_control);
470
471         if ((macstat & B43legacy_RX_MAC_DEC) &&
472             !(macstat & B43legacy_RX_MAC_DECERR)) {
473                 unsigned int keyidx;
474                 int wlhdr_len;
475                 int iv_len;
476                 int icv_len;
477
478                 keyidx = ((macstat & B43legacy_RX_MAC_KEYIDX)
479                           >> B43legacy_RX_MAC_KEYIDX_SHIFT);
480                 /* We must adjust the key index here. We want the "physical"
481                  * key index, but the ucode passed it slightly different.
482                  */
483                 keyidx = b43legacy_kidx_to_raw(dev, keyidx);
484                 B43legacy_WARN_ON(keyidx >= dev->max_nr_keys);
485
486                 if (dev->key[keyidx].algorithm != B43legacy_SEC_ALGO_NONE) {
487                         /* Remove PROTECTED flag to mark it as decrypted. */
488                         B43legacy_WARN_ON(!(fctl & IEEE80211_FCTL_PROTECTED));
489                         fctl &= ~IEEE80211_FCTL_PROTECTED;
490                         wlhdr->frame_control = cpu_to_le16(fctl);
491
492                         wlhdr_len = ieee80211_get_hdrlen(fctl);
493                         if (unlikely(skb->len < (wlhdr_len + 3))) {
494                                 b43legacydbg(dev->wl, "RX: Packet size"
495                                              " underrun3\n");
496                                 goto drop;
497                         }
498                         if (skb->data[wlhdr_len + 3] & (1 << 5)) {
499                                 /* The Ext-IV Bit is set in the "KeyID"
500                                  * octet of the IV.
501                                  */
502                                 iv_len = 8;
503                                 icv_len = 8;
504                         } else {
505                                 iv_len = 4;
506                                 icv_len = 4;
507                         }
508                         if (unlikely(skb->len < (wlhdr_len + iv_len +
509                             icv_len))) {
510                                 b43legacydbg(dev->wl, "RX: Packet size"
511                                              " underrun4\n");
512                                 goto drop;
513                         }
514                         /* Remove the IV */
515                         memmove(skb->data + iv_len, skb->data, wlhdr_len);
516                         skb_pull(skb, iv_len);
517                         /* Remove the ICV */
518                         skb_trim(skb, skb->len - icv_len);
519
520                         status.flag |= RX_FLAG_DECRYPTED;
521                 }
522         }
523
524         status.ssi = b43legacy_rssi_postprocess(dev, jssi,
525                                       (phystat0 & B43legacy_RX_PHYST0_OFDM),
526                                       (phystat0 & B43legacy_RX_PHYST0_GAINCTL),
527                                       (phystat3 & B43legacy_RX_PHYST3_TRSTATE));
528         status.noise = dev->stats.link_noise;
529         status.signal = (jssi * 100) / B43legacy_RX_MAX_SSI;
530         if (phystat0 & B43legacy_RX_PHYST0_OFDM)
531                 status.rate = b43legacy_plcp_get_bitrate_ofdm(plcp);
532         else
533                 status.rate = b43legacy_plcp_get_bitrate_cck(plcp);
534         status.antenna = !!(phystat0 & B43legacy_RX_PHYST0_ANT);
535         status.mactime = mactime;
536         status.flag |= RX_FLAG_TSFT;
537
538         chanid = (chanstat & B43legacy_RX_CHAN_ID) >>
539                   B43legacy_RX_CHAN_ID_SHIFT;
540         switch (chanstat & B43legacy_RX_CHAN_PHYTYPE) {
541         case B43legacy_PHYTYPE_B:
542                 status.phymode = MODE_IEEE80211B;
543                 status.freq = chanid + 2400;
544                 status.channel = b43legacy_freq_to_channel_bg(chanid + 2400);
545                 break;
546         case B43legacy_PHYTYPE_G:
547                 status.phymode = MODE_IEEE80211G;
548                 status.freq = chanid + 2400;
549                 status.channel = b43legacy_freq_to_channel_bg(chanid + 2400);
550                 break;
551         default:
552                 b43legacywarn(dev->wl, "Unexpected value for chanstat (0x%X)\n",
553                        chanstat);
554         }
555
556         dev->stats.last_rx = jiffies;
557         ieee80211_rx_irqsafe(dev->wl->hw, skb, &status);
558
559         return;
560 drop:
561         b43legacydbg(dev->wl, "RX: Packet dropped\n");
562         dev_kfree_skb_any(skb);
563 }
564
565 void b43legacy_handle_txstatus(struct b43legacy_wldev *dev,
566                              const struct b43legacy_txstatus *status)
567 {
568         b43legacy_debugfs_log_txstat(dev, status);
569
570         if (status->intermediate)
571                 return;
572         if (status->for_ampdu)
573                 return;
574         if (!status->acked)
575                 dev->wl->ieee_stats.dot11ACKFailureCount++;
576         if (status->rts_count) {
577                 if (status->rts_count == 0xF) /* FIXME */
578                         dev->wl->ieee_stats.dot11RTSFailureCount++;
579                 else
580                         dev->wl->ieee_stats.dot11RTSSuccessCount++;
581         }
582
583         if (b43legacy_using_pio(dev))
584                 b43legacy_pio_handle_txstatus(dev, status);
585         else
586                 b43legacy_dma_handle_txstatus(dev, status);
587 }
588
589 /* Handle TX status report as received through DMA/PIO queues */
590 void b43legacy_handle_hwtxstatus(struct b43legacy_wldev *dev,
591                                  const struct b43legacy_hwtxstatus *hw)
592 {
593         struct b43legacy_txstatus status;
594         u8 tmp;
595
596         status.cookie = le16_to_cpu(hw->cookie);
597         status.seq = le16_to_cpu(hw->seq);
598         status.phy_stat = hw->phy_stat;
599         tmp = hw->count;
600         status.frame_count = (tmp >> 4);
601         status.rts_count = (tmp & 0x0F);
602         tmp = hw->flags;
603         status.supp_reason = ((tmp & 0x1C) >> 2);
604         status.pm_indicated = !!(tmp & 0x80);
605         status.intermediate = !!(tmp & 0x40);
606         status.for_ampdu = !!(tmp & 0x20);
607         status.acked = !!(tmp & 0x02);
608
609         b43legacy_handle_txstatus(dev, &status);
610 }
611
612 /* Stop any TX operation on the device (suspend the hardware queues) */
613 void b43legacy_tx_suspend(struct b43legacy_wldev *dev)
614 {
615         if (b43legacy_using_pio(dev))
616                 b43legacy_pio_freeze_txqueues(dev);
617         else
618                 b43legacy_dma_tx_suspend(dev);
619 }
620
621 /* Resume any TX operation on the device (resume the hardware queues) */
622 void b43legacy_tx_resume(struct b43legacy_wldev *dev)
623 {
624         if (b43legacy_using_pio(dev))
625                 b43legacy_pio_thaw_txqueues(dev);
626         else
627                 b43legacy_dma_tx_resume(dev);
628 }
629
630 /* Initialize the QoS parameters */
631 void b43legacy_qos_init(struct b43legacy_wldev *dev)
632 {
633         /* FIXME: This function must probably be called from the mac80211
634          * config callback. */
635 return;
636
637         b43legacy_hf_write(dev, b43legacy_hf_read(dev) | B43legacy_HF_EDCF);
638         /* FIXME kill magic */
639         b43legacy_write16(dev, 0x688,
640                           b43legacy_read16(dev, 0x688) | 0x4);
641
642
643         /*TODO: We might need some stack support here to get the values. */
644 }