3 Broadcom B43 wireless driver
5 Transmission (TX/RX) related functions.
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>
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
26 Boston, MA 02110-1301, USA.
31 #include "phy_common.h"
36 /* Extract the bitrate index out of a CCK PLCP header. */
37 static int b43_plcp_get_bitrate_idx_cck(struct b43_plcp_hdr6
*plcp
)
39 switch (plcp
->raw
[0]) {
53 /* Extract the bitrate index out of an OFDM PLCP header. */
54 static u8
b43_plcp_get_bitrate_idx_ofdm(struct b43_plcp_hdr6
*plcp
, bool aphy
)
56 int base
= aphy
? 0 : 4;
58 switch (plcp
->raw
[0] & 0xF) {
80 u8
b43_plcp_get_ratecode_cck(const u8 bitrate
)
83 case B43_CCK_RATE_1MB
:
85 case B43_CCK_RATE_2MB
:
87 case B43_CCK_RATE_5MB
:
89 case B43_CCK_RATE_11MB
:
96 u8
b43_plcp_get_ratecode_ofdm(const u8 bitrate
)
99 case B43_OFDM_RATE_6MB
:
101 case B43_OFDM_RATE_9MB
:
103 case B43_OFDM_RATE_12MB
:
105 case B43_OFDM_RATE_18MB
:
107 case B43_OFDM_RATE_24MB
:
109 case B43_OFDM_RATE_36MB
:
111 case B43_OFDM_RATE_48MB
:
113 case B43_OFDM_RATE_54MB
:
120 void b43_generate_plcp_hdr(struct b43_plcp_hdr4
*plcp
,
121 const u16 octets
, const u8 bitrate
)
123 __le32
*data
= &(plcp
->data
);
124 __u8
*raw
= plcp
->raw
;
126 if (b43_is_ofdm_rate(bitrate
)) {
129 d
= b43_plcp_get_ratecode_ofdm(bitrate
);
130 B43_WARN_ON(octets
& 0xF000);
132 *data
= cpu_to_le32(d
);
136 plen
= octets
* 16 / bitrate
;
137 if ((octets
* 16 % bitrate
) > 0) {
139 if ((bitrate
== B43_CCK_RATE_11MB
)
140 && ((octets
* 8 % 11) < 4)) {
146 *data
|= cpu_to_le32(plen
<< 16);
147 raw
[0] = b43_plcp_get_ratecode_cck(bitrate
);
151 static u8
b43_calc_fallback_rate(u8 bitrate
)
154 case B43_CCK_RATE_1MB
:
155 return B43_CCK_RATE_1MB
;
156 case B43_CCK_RATE_2MB
:
157 return B43_CCK_RATE_1MB
;
158 case B43_CCK_RATE_5MB
:
159 return B43_CCK_RATE_2MB
;
160 case B43_CCK_RATE_11MB
:
161 return B43_CCK_RATE_5MB
;
162 case B43_OFDM_RATE_6MB
:
163 return B43_CCK_RATE_5MB
;
164 case B43_OFDM_RATE_9MB
:
165 return B43_OFDM_RATE_6MB
;
166 case B43_OFDM_RATE_12MB
:
167 return B43_OFDM_RATE_9MB
;
168 case B43_OFDM_RATE_18MB
:
169 return B43_OFDM_RATE_12MB
;
170 case B43_OFDM_RATE_24MB
:
171 return B43_OFDM_RATE_18MB
;
172 case B43_OFDM_RATE_36MB
:
173 return B43_OFDM_RATE_24MB
;
174 case B43_OFDM_RATE_48MB
:
175 return B43_OFDM_RATE_36MB
;
176 case B43_OFDM_RATE_54MB
:
177 return B43_OFDM_RATE_48MB
;
183 /* Generate a TX data header. */
184 int b43_generate_txhdr(struct b43_wldev
*dev
,
186 const unsigned char *fragment_data
,
187 unsigned int fragment_len
,
188 struct ieee80211_tx_info
*info
,
191 struct b43_txhdr
*txhdr
= (struct b43_txhdr
*)_txhdr
;
192 const struct b43_phy
*phy
= &dev
->phy
;
193 const struct ieee80211_hdr
*wlhdr
=
194 (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
;
199 int rate_ofdm
, rate_fb_ofdm
;
200 unsigned int plcp_fragment_len
;
204 struct ieee80211_rate
*txrate
;
205 struct ieee80211_tx_rate
*rates
;
207 memset(txhdr
, 0, sizeof(*txhdr
));
209 txrate
= ieee80211_get_tx_rate(dev
->wl
->hw
, info
);
210 rate
= txrate
? txrate
->hw_value
: B43_CCK_RATE_1MB
;
211 rate_ofdm
= b43_is_ofdm_rate(rate
);
212 fbrate
= ieee80211_get_alt_retry_rate(dev
->wl
->hw
, info
, 0) ? : txrate
;
213 rate_fb
= fbrate
->hw_value
;
214 rate_fb_ofdm
= b43_is_ofdm_rate(rate_fb
);
217 txhdr
->phy_rate
= b43_plcp_get_ratecode_ofdm(rate
);
219 txhdr
->phy_rate
= b43_plcp_get_ratecode_cck(rate
);
220 txhdr
->mac_frame_ctl
= wlhdr
->frame_control
;
221 memcpy(txhdr
->tx_receiver
, wlhdr
->addr1
, 6);
223 /* Calculate duration for fallback rate */
224 if ((rate_fb
== rate
) ||
225 (wlhdr
->duration_id
& cpu_to_le16(0x8000)) ||
226 (wlhdr
->duration_id
== cpu_to_le16(0))) {
227 /* If the fallback rate equals the normal rate or the
228 * dur_id field contains an AID, CFP magic or 0,
229 * use the original dur_id field. */
230 txhdr
->dur_fb
= wlhdr
->duration_id
;
232 txhdr
->dur_fb
= ieee80211_generic_frame_duration(
233 dev
->wl
->hw
, info
->control
.vif
, fragment_len
, fbrate
);
236 plcp_fragment_len
= fragment_len
+ FCS_LEN
;
237 if (use_encryption
) {
238 u8 key_idx
= info
->control
.hw_key
->hw_key_idx
;
243 B43_WARN_ON(key_idx
>= dev
->max_nr_keys
);
244 key
= &(dev
->key
[key_idx
]);
246 if (unlikely(!key
->keyconf
)) {
247 /* This key is invalid. This might only happen
248 * in a short timeframe after machine resume before
249 * we were able to reconfigure keys.
250 * Drop this packet completely. Do not transmit it
251 * unencrypted to avoid leaking information. */
255 /* Hardware appends ICV. */
256 plcp_fragment_len
+= info
->control
.hw_key
->icv_len
;
258 key_idx
= b43_kidx_to_fw(dev
, key_idx
);
259 mac_ctl
|= (key_idx
<< B43_TXH_MAC_KEYIDX_SHIFT
) &
261 mac_ctl
|= (key
->algorithm
<< B43_TXH_MAC_KEYALG_SHIFT
) &
263 wlhdr_len
= ieee80211_hdrlen(fctl
);
264 iv_len
= min((size_t) info
->control
.hw_key
->iv_len
,
265 ARRAY_SIZE(txhdr
->iv
));
266 memcpy(txhdr
->iv
, ((u8
*) wlhdr
) + wlhdr_len
, iv_len
);
268 if (b43_is_old_txhdr_format(dev
)) {
269 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->old_format
.plcp
),
270 plcp_fragment_len
, rate
);
272 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->new_format
.plcp
),
273 plcp_fragment_len
, rate
);
275 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->plcp_fb
),
276 plcp_fragment_len
, rate_fb
);
278 /* Extra Frame Types */
280 extra_ft
|= B43_TXH_EFT_FB_OFDM
;
282 extra_ft
|= B43_TXH_EFT_FB_CCK
;
284 /* Set channel radio code. Note that the micrcode ORs 0x100 to
285 * this value before comparing it to the value in SHM, if this
288 txhdr
->chan_radio_code
= phy
->channel
;
290 /* PHY TX Control word */
292 phy_ctl
|= B43_TXH_PHY_ENC_OFDM
;
294 phy_ctl
|= B43_TXH_PHY_ENC_CCK
;
295 if (info
->control
.rates
[0].flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
)
296 phy_ctl
|= B43_TXH_PHY_SHORTPRMBL
;
298 switch (b43_ieee80211_antenna_sanitize(dev
, info
->antenna_sel_tx
)) {
299 case 0: /* Default */
300 phy_ctl
|= B43_TXH_PHY_ANT01AUTO
;
302 case 1: /* Antenna 0 */
303 phy_ctl
|= B43_TXH_PHY_ANT0
;
305 case 2: /* Antenna 1 */
306 phy_ctl
|= B43_TXH_PHY_ANT1
;
308 case 3: /* Antenna 2 */
309 phy_ctl
|= B43_TXH_PHY_ANT2
;
311 case 4: /* Antenna 3 */
312 phy_ctl
|= B43_TXH_PHY_ANT3
;
318 rates
= info
->control
.rates
;
320 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
))
321 mac_ctl
|= B43_TXH_MAC_ACK
;
322 /* use hardware sequence counter as the non-TID counter */
323 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
)
324 mac_ctl
|= B43_TXH_MAC_HWSEQ
;
325 if (info
->flags
& IEEE80211_TX_CTL_FIRST_FRAGMENT
)
326 mac_ctl
|= B43_TXH_MAC_STMSDU
;
327 if (phy
->type
== B43_PHYTYPE_A
)
328 mac_ctl
|= B43_TXH_MAC_5GHZ
;
330 /* Overwrite rates[0].count to make the retry calculation
331 * in the tx status easier. need the actual retry limit to
332 * detect whether the fallback rate was used.
334 if ((rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) ||
335 (rates
[0].count
<= dev
->wl
->hw
->conf
.long_frame_max_tx_count
)) {
336 rates
[0].count
= dev
->wl
->hw
->conf
.long_frame_max_tx_count
;
337 mac_ctl
|= B43_TXH_MAC_LONGFRAME
;
339 rates
[0].count
= dev
->wl
->hw
->conf
.short_frame_max_tx_count
;
342 /* Generate the RTS or CTS-to-self frame */
343 if ((rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) ||
344 (rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
)) {
346 struct ieee80211_hdr
*hdr
;
347 int rts_rate
, rts_rate_fb
;
348 int rts_rate_ofdm
, rts_rate_fb_ofdm
;
349 struct b43_plcp_hdr6
*plcp
;
350 struct ieee80211_rate
*rts_cts_rate
;
352 rts_cts_rate
= ieee80211_get_rts_cts_rate(dev
->wl
->hw
, info
);
354 rts_rate
= rts_cts_rate
? rts_cts_rate
->hw_value
: B43_CCK_RATE_1MB
;
355 rts_rate_ofdm
= b43_is_ofdm_rate(rts_rate
);
356 rts_rate_fb
= b43_calc_fallback_rate(rts_rate
);
357 rts_rate_fb_ofdm
= b43_is_ofdm_rate(rts_rate_fb
);
359 if (rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
) {
360 struct ieee80211_cts
*cts
;
362 if (b43_is_old_txhdr_format(dev
)) {
363 cts
= (struct ieee80211_cts
*)
364 (txhdr
->old_format
.rts_frame
);
366 cts
= (struct ieee80211_cts
*)
367 (txhdr
->new_format
.rts_frame
);
369 ieee80211_ctstoself_get(dev
->wl
->hw
, info
->control
.vif
,
370 fragment_data
, fragment_len
,
372 mac_ctl
|= B43_TXH_MAC_SENDCTS
;
373 len
= sizeof(struct ieee80211_cts
);
375 struct ieee80211_rts
*rts
;
377 if (b43_is_old_txhdr_format(dev
)) {
378 rts
= (struct ieee80211_rts
*)
379 (txhdr
->old_format
.rts_frame
);
381 rts
= (struct ieee80211_rts
*)
382 (txhdr
->new_format
.rts_frame
);
384 ieee80211_rts_get(dev
->wl
->hw
, info
->control
.vif
,
385 fragment_data
, fragment_len
,
387 mac_ctl
|= B43_TXH_MAC_SENDRTS
;
388 len
= sizeof(struct ieee80211_rts
);
392 /* Generate the PLCP headers for the RTS/CTS frame */
393 if (b43_is_old_txhdr_format(dev
))
394 plcp
= &txhdr
->old_format
.rts_plcp
;
396 plcp
= &txhdr
->new_format
.rts_plcp
;
397 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)plcp
,
399 plcp
= &txhdr
->rts_plcp_fb
;
400 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)plcp
,
403 if (b43_is_old_txhdr_format(dev
)) {
404 hdr
= (struct ieee80211_hdr
*)
405 (&txhdr
->old_format
.rts_frame
);
407 hdr
= (struct ieee80211_hdr
*)
408 (&txhdr
->new_format
.rts_frame
);
410 txhdr
->rts_dur_fb
= hdr
->duration_id
;
413 extra_ft
|= B43_TXH_EFT_RTS_OFDM
;
414 txhdr
->phy_rate_rts
=
415 b43_plcp_get_ratecode_ofdm(rts_rate
);
417 extra_ft
|= B43_TXH_EFT_RTS_CCK
;
418 txhdr
->phy_rate_rts
=
419 b43_plcp_get_ratecode_cck(rts_rate
);
421 if (rts_rate_fb_ofdm
)
422 extra_ft
|= B43_TXH_EFT_RTSFB_OFDM
;
424 extra_ft
|= B43_TXH_EFT_RTSFB_CCK
;
428 if (b43_is_old_txhdr_format(dev
))
429 txhdr
->old_format
.cookie
= cpu_to_le16(cookie
);
431 txhdr
->new_format
.cookie
= cpu_to_le16(cookie
);
433 /* Apply the bitfields */
434 txhdr
->mac_ctl
= cpu_to_le32(mac_ctl
);
435 txhdr
->phy_ctl
= cpu_to_le16(phy_ctl
);
436 txhdr
->extra_ft
= extra_ft
;
441 static s8
b43_rssi_postprocess(struct b43_wldev
*dev
,
442 u8 in_rssi
, int ofdm
,
443 int adjust_2053
, int adjust_2050
)
445 struct b43_phy
*phy
= &dev
->phy
;
446 struct b43_phy_g
*gphy
= phy
->g
;
449 switch (phy
->radio_ver
) {
462 if (dev
->dev
->bus
->sprom
.
463 boardflags_lo
& B43_BFL_RSSI
) {
466 B43_WARN_ON(phy
->type
!= B43_PHYTYPE_G
);
467 tmp
= gphy
->nrssi_lt
[in_rssi
];
479 if (phy
->type
== B43_PHYTYPE_G
&& adjust_2050
)
505 static s8
b43_rssinoise_postprocess(struct b43_wldev
*dev
, u8 in_rssi
)
507 struct b43_phy
*phy
= &dev
->phy
;
510 if (phy
->type
== B43_PHYTYPE_A
) {
511 //TODO: Incomplete specs.
514 ret
= b43_rssi_postprocess(dev
, in_rssi
, 0, 1, 1);
520 void b43_rx(struct b43_wldev
*dev
, struct sk_buff
*skb
, const void *_rxhdr
)
522 struct ieee80211_rx_status status
;
523 struct b43_plcp_hdr6
*plcp
;
524 struct ieee80211_hdr
*wlhdr
;
525 const struct b43_rxhdr_fw4
*rxhdr
= _rxhdr
;
527 u16 phystat0
, phystat3
, chanstat
, mactime
;
533 memset(&status
, 0, sizeof(status
));
535 /* Get metadata about the frame from the header. */
536 phystat0
= le16_to_cpu(rxhdr
->phy_status0
);
537 phystat3
= le16_to_cpu(rxhdr
->phy_status3
);
538 macstat
= le32_to_cpu(rxhdr
->mac_status
);
539 mactime
= le16_to_cpu(rxhdr
->mac_time
);
540 chanstat
= le16_to_cpu(rxhdr
->channel
);
541 phytype
= chanstat
& B43_RX_CHAN_PHYTYPE
;
543 if (macstat
& B43_RX_MAC_FCSERR
)
544 dev
->wl
->ieee_stats
.dot11FCSErrorCount
++;
545 if (macstat
& B43_RX_MAC_DECERR
) {
546 /* Decryption with the given key failed.
547 * Drop the packet. We also won't be able to decrypt it with
548 * the key in software. */
552 /* Skip PLCP and padding */
553 padding
= (macstat
& B43_RX_MAC_PADDING
) ? 2 : 0;
554 if (unlikely(skb
->len
< (sizeof(struct b43_plcp_hdr6
) + padding
))) {
555 b43dbg(dev
->wl
, "RX: Packet size underrun (1)\n");
558 plcp
= (struct b43_plcp_hdr6
*)(skb
->data
+ padding
);
559 skb_pull(skb
, sizeof(struct b43_plcp_hdr6
) + padding
);
560 /* The skb contains the Wireless Header + payload data now */
561 if (unlikely(skb
->len
< (2 + 2 + 6 /*minimum hdr */ + FCS_LEN
))) {
562 b43dbg(dev
->wl
, "RX: Packet size underrun (2)\n");
565 wlhdr
= (struct ieee80211_hdr
*)(skb
->data
);
566 fctl
= wlhdr
->frame_control
;
568 if (macstat
& B43_RX_MAC_DEC
) {
572 keyidx
= ((macstat
& B43_RX_MAC_KEYIDX
)
573 >> B43_RX_MAC_KEYIDX_SHIFT
);
574 /* We must adjust the key index here. We want the "physical"
575 * key index, but the ucode passed it slightly different.
577 keyidx
= b43_kidx_to_raw(dev
, keyidx
);
578 B43_WARN_ON(keyidx
>= dev
->max_nr_keys
);
580 if (dev
->key
[keyidx
].algorithm
!= B43_SEC_ALGO_NONE
) {
581 wlhdr_len
= ieee80211_hdrlen(fctl
);
582 if (unlikely(skb
->len
< (wlhdr_len
+ 3))) {
584 "RX: Packet size underrun (3)\n");
587 status
.flag
|= RX_FLAG_DECRYPTED
;
591 /* Link quality statistics */
592 status
.noise
= dev
->stats
.link_noise
;
593 if ((chanstat
& B43_RX_CHAN_PHYTYPE
) == B43_PHYTYPE_N
) {
594 // s8 rssi = max(rxhdr->power0, rxhdr->power1);
595 //TODO: Find out what the rssi value is (dBm or percentage?)
596 // and also find out what the maximum possible value is.
597 // Fill status.ssi and status.signal fields.
599 status
.signal
= b43_rssi_postprocess(dev
, rxhdr
->jssi
,
600 (phystat0
& B43_RX_PHYST0_OFDM
),
601 (phystat0
& B43_RX_PHYST0_GAINCTL
),
602 (phystat3
& B43_RX_PHYST3_TRSTATE
));
603 status
.qual
= (rxhdr
->jssi
* 100) / B43_RX_MAX_SSI
;
606 if (phystat0
& B43_RX_PHYST0_OFDM
)
607 status
.rate_idx
= b43_plcp_get_bitrate_idx_ofdm(plcp
,
608 phytype
== B43_PHYTYPE_A
);
610 status
.rate_idx
= b43_plcp_get_bitrate_idx_cck(plcp
);
611 status
.antenna
= !!(phystat0
& B43_RX_PHYST0_ANT
);
614 * All frames on monitor interfaces and beacons always need a full
615 * 64-bit timestamp. Monitor interfaces need it for diagnostic
616 * purposes and beacons for IBSS merging.
617 * This code assumes we get to process the packet within 16 bits
618 * of timestamp, i.e. about 65 milliseconds after the PHY received
621 if (ieee80211_is_beacon(fctl
) || dev
->wl
->radiotap_enabled
) {
624 b43_tsf_read(dev
, &status
.mactime
);
625 low_mactime_now
= status
.mactime
;
626 status
.mactime
= status
.mactime
& ~0xFFFFULL
;
627 status
.mactime
+= mactime
;
628 if (low_mactime_now
<= mactime
)
629 status
.mactime
-= 0x10000;
630 status
.flag
|= RX_FLAG_TSFT
;
633 chanid
= (chanstat
& B43_RX_CHAN_ID
) >> B43_RX_CHAN_ID_SHIFT
;
634 switch (chanstat
& B43_RX_CHAN_PHYTYPE
) {
636 status
.band
= IEEE80211_BAND_5GHZ
;
638 /* FIXME: We don't really know which value the "chanid" contains.
639 * So the following assignment might be wrong. */
640 status
.freq
= b43_channel_to_freq_5ghz(chanid
);
643 status
.band
= IEEE80211_BAND_2GHZ
;
644 /* chanid is the radio channel cookie value as used
645 * to tune the radio. */
646 status
.freq
= chanid
+ 2400;
649 /* chanid is the SHM channel cookie. Which is the plain
650 * channel number in b43. */
651 if (chanstat
& B43_RX_CHAN_5GHZ
) {
652 status
.band
= IEEE80211_BAND_5GHZ
;
653 status
.freq
= b43_freq_to_channel_5ghz(chanid
);
655 status
.band
= IEEE80211_BAND_2GHZ
;
656 status
.freq
= b43_freq_to_channel_2ghz(chanid
);
664 dev
->stats
.last_rx
= jiffies
;
665 ieee80211_rx_irqsafe(dev
->wl
->hw
, skb
, &status
);
669 b43dbg(dev
->wl
, "RX: Packet dropped\n");
670 dev_kfree_skb_any(skb
);
673 void b43_handle_txstatus(struct b43_wldev
*dev
,
674 const struct b43_txstatus
*status
)
676 b43_debugfs_log_txstat(dev
, status
);
678 if (status
->intermediate
)
680 if (status
->for_ampdu
)
683 dev
->wl
->ieee_stats
.dot11ACKFailureCount
++;
684 if (status
->rts_count
) {
685 if (status
->rts_count
== 0xF) //FIXME
686 dev
->wl
->ieee_stats
.dot11RTSFailureCount
++;
688 dev
->wl
->ieee_stats
.dot11RTSSuccessCount
++;
691 if (b43_using_pio_transfers(dev
))
692 b43_pio_handle_txstatus(dev
, status
);
694 b43_dma_handle_txstatus(dev
, status
);
696 b43_phy_txpower_check(dev
, 0);
699 /* Fill out the mac80211 TXstatus report based on the b43-specific
700 * txstatus report data. This returns a boolean whether the frame was
701 * successfully transmitted. */
702 bool b43_fill_txstatus_report(struct b43_wldev
*dev
,
703 struct ieee80211_tx_info
*report
,
704 const struct b43_txstatus
*status
)
706 bool frame_success
= 1;
709 /* preserve the confiured retry limit before clearing the status
710 * The xmit function has overwritten the rc's value with the actual
711 * retry limit done by the hardware */
712 retry_limit
= report
->status
.rates
[0].count
;
713 ieee80211_tx_info_clear_status(report
);
716 /* The frame was ACKed. */
717 report
->flags
|= IEEE80211_TX_STAT_ACK
;
719 /* The frame was not ACKed... */
720 if (!(report
->flags
& IEEE80211_TX_CTL_NO_ACK
)) {
721 /* ...but we expected an ACK. */
725 if (status
->frame_count
== 0) {
726 /* The frame was not transmitted at all. */
727 report
->status
.rates
[0].count
= 0;
728 } else if (status
->rts_count
> dev
->wl
->hw
->conf
.short_frame_max_tx_count
) {
730 * If the short retries (RTS, not data frame) have exceeded
731 * the limit, the hw will not have tried the selected rate,
732 * but will have used the fallback rate instead.
733 * Don't let the rate control count attempts for the selected
734 * rate in this case, otherwise the statistics will be off.
736 report
->status
.rates
[0].count
= 0;
737 report
->status
.rates
[1].count
= status
->frame_count
;
739 if (status
->frame_count
> retry_limit
) {
740 report
->status
.rates
[0].count
= retry_limit
;
741 report
->status
.rates
[1].count
= status
->frame_count
-
745 report
->status
.rates
[0].count
= status
->frame_count
;
746 report
->status
.rates
[1].idx
= -1;
750 return frame_success
;
753 /* Stop any TX operation on the device (suspend the hardware queues) */
754 void b43_tx_suspend(struct b43_wldev
*dev
)
756 if (b43_using_pio_transfers(dev
))
757 b43_pio_tx_suspend(dev
);
759 b43_dma_tx_suspend(dev
);
762 /* Resume any TX operation on the device (resume the hardware queues) */
763 void b43_tx_resume(struct b43_wldev
*dev
)
765 if (b43_using_pio_transfers(dev
))
766 b43_pio_tx_resume(dev
);
768 b43_dma_tx_resume(dev
);