1 // SPDX-License-Identifier: GPL-2.0-only
2 /******************************************************************************
4 * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
5 * Copyright (C) 2019 Intel Corporation
8 * Intel Linux Wireless <linuxwifi@intel.com>
9 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
11 *****************************************************************************/
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/sched.h>
16 #include <linux/ieee80211.h>
18 #include "iwl-trans.h"
19 #include "iwl-agn-hw.h"
23 static const u8 tid_to_ac
[] = {
34 static void iwlagn_tx_cmd_protection(struct iwl_priv
*priv
,
35 struct ieee80211_tx_info
*info
,
36 __le16 fc
, __le32
*tx_flags
)
38 if (info
->control
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
||
39 info
->control
.rates
[0].flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
||
40 info
->flags
& IEEE80211_TX_CTL_AMPDU
)
41 *tx_flags
|= TX_CMD_FLG_PROT_REQUIRE_MSK
;
45 * handle build REPLY_TX command notification.
47 static void iwlagn_tx_cmd_build_basic(struct iwl_priv
*priv
,
49 struct iwl_tx_cmd
*tx_cmd
,
50 struct ieee80211_tx_info
*info
,
51 struct ieee80211_hdr
*hdr
, u8 sta_id
)
53 __le16 fc
= hdr
->frame_control
;
54 __le32 tx_flags
= tx_cmd
->tx_flags
;
56 tx_cmd
->stop_time
.life_time
= TX_CMD_LIFE_TIME_INFINITE
;
58 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
))
59 tx_flags
|= TX_CMD_FLG_ACK_MSK
;
61 tx_flags
&= ~TX_CMD_FLG_ACK_MSK
;
63 if (ieee80211_is_probe_resp(fc
))
64 tx_flags
|= TX_CMD_FLG_TSF_MSK
;
65 else if (ieee80211_is_back_req(fc
))
66 tx_flags
|= TX_CMD_FLG_ACK_MSK
| TX_CMD_FLG_IMM_BA_RSP_MASK
;
67 else if (info
->band
== NL80211_BAND_2GHZ
&&
68 priv
->lib
->bt_params
&&
69 priv
->lib
->bt_params
->advanced_bt_coexist
&&
70 (ieee80211_is_auth(fc
) || ieee80211_is_assoc_req(fc
) ||
71 ieee80211_is_reassoc_req(fc
) ||
72 info
->control
.flags
& IEEE80211_TX_CTRL_PORT_CTRL_PROTO
))
73 tx_flags
|= TX_CMD_FLG_IGNORE_BT
;
76 tx_cmd
->sta_id
= sta_id
;
77 if (ieee80211_has_morefrags(fc
))
78 tx_flags
|= TX_CMD_FLG_MORE_FRAG_MSK
;
80 if (ieee80211_is_data_qos(fc
)) {
81 u8
*qc
= ieee80211_get_qos_ctl(hdr
);
82 tx_cmd
->tid_tspec
= qc
[0] & 0xf;
83 tx_flags
&= ~TX_CMD_FLG_SEQ_CTL_MSK
;
85 tx_cmd
->tid_tspec
= IWL_TID_NON_QOS
;
86 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
)
87 tx_flags
|= TX_CMD_FLG_SEQ_CTL_MSK
;
89 tx_flags
&= ~TX_CMD_FLG_SEQ_CTL_MSK
;
92 iwlagn_tx_cmd_protection(priv
, info
, fc
, &tx_flags
);
94 tx_flags
&= ~(TX_CMD_FLG_ANT_SEL_MSK
);
95 if (ieee80211_is_mgmt(fc
)) {
96 if (ieee80211_is_assoc_req(fc
) || ieee80211_is_reassoc_req(fc
))
97 tx_cmd
->timeout
.pm_frame_timeout
= cpu_to_le16(3);
99 tx_cmd
->timeout
.pm_frame_timeout
= cpu_to_le16(2);
101 tx_cmd
->timeout
.pm_frame_timeout
= 0;
104 tx_cmd
->driver_txop
= 0;
105 tx_cmd
->tx_flags
= tx_flags
;
106 tx_cmd
->next_frame_len
= 0;
109 static void iwlagn_tx_cmd_build_rate(struct iwl_priv
*priv
,
110 struct iwl_tx_cmd
*tx_cmd
,
111 struct ieee80211_tx_info
*info
,
112 struct ieee80211_sta
*sta
,
122 rts_retry_limit
= IWLAGN_LOW_RETRY_LIMIT
;
123 data_retry_limit
= IWLAGN_LOW_RETRY_LIMIT
;
125 /* Set retry limit on RTS packets */
126 rts_retry_limit
= IWLAGN_RTS_DFAULT_RETRY_LIMIT
;
128 /* Set retry limit on DATA packets and Probe Responses*/
129 if (ieee80211_is_probe_resp(fc
)) {
130 data_retry_limit
= IWLAGN_MGMT_DFAULT_RETRY_LIMIT
;
132 min(data_retry_limit
, rts_retry_limit
);
133 } else if (ieee80211_is_back_req(fc
))
134 data_retry_limit
= IWLAGN_BAR_DFAULT_RETRY_LIMIT
;
136 data_retry_limit
= IWLAGN_DEFAULT_TX_RETRY
;
139 tx_cmd
->data_retry_limit
= data_retry_limit
;
140 tx_cmd
->rts_retry_limit
= rts_retry_limit
;
142 /* DATA packets will use the uCode station table for rate/antenna
144 if (ieee80211_is_data(fc
)) {
145 tx_cmd
->initial_rate_index
= 0;
146 tx_cmd
->tx_flags
|= TX_CMD_FLG_STA_RATE_MSK
;
148 } else if (ieee80211_is_back_req(fc
))
149 tx_cmd
->tx_flags
|= TX_CMD_FLG_STA_RATE_MSK
;
152 * If the current TX rate stored in mac80211 has the MCS bit set, it's
153 * not really a TX rate. Thus, we use the lowest supported rate for
154 * this band. Also use the lowest supported rate if the stored rate
157 rate_idx
= info
->control
.rates
[0].idx
;
158 if (info
->control
.rates
[0].flags
& IEEE80211_TX_RC_MCS
||
159 (rate_idx
< 0) || (rate_idx
> IWL_RATE_COUNT_LEGACY
))
160 rate_idx
= rate_lowest_index(
161 &priv
->nvm_data
->bands
[info
->band
], sta
);
162 /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
163 if (info
->band
== NL80211_BAND_5GHZ
)
164 rate_idx
+= IWL_FIRST_OFDM_RATE
;
165 /* Get PLCP rate for tx_cmd->rate_n_flags */
166 rate_plcp
= iwl_rates
[rate_idx
].plcp
;
167 /* Zero out flags for this packet */
170 /* Set CCK flag as needed */
171 if ((rate_idx
>= IWL_FIRST_CCK_RATE
) && (rate_idx
<= IWL_LAST_CCK_RATE
))
172 rate_flags
|= RATE_MCS_CCK_MSK
;
174 /* Set up antennas */
175 if (priv
->lib
->bt_params
&&
176 priv
->lib
->bt_params
->advanced_bt_coexist
&&
177 priv
->bt_full_concurrent
) {
178 /* operated as 1x1 in full concurrency mode */
179 priv
->mgmt_tx_ant
= iwl_toggle_tx_ant(priv
, priv
->mgmt_tx_ant
,
180 first_antenna(priv
->nvm_data
->valid_tx_ant
));
182 priv
->mgmt_tx_ant
= iwl_toggle_tx_ant(
183 priv
, priv
->mgmt_tx_ant
,
184 priv
->nvm_data
->valid_tx_ant
);
185 rate_flags
|= iwl_ant_idx_to_flags(priv
->mgmt_tx_ant
);
187 /* Set the rate in the TX cmd */
188 tx_cmd
->rate_n_flags
= iwl_hw_set_rate_n_flags(rate_plcp
, rate_flags
);
191 static void iwlagn_tx_cmd_build_hwcrypto(struct iwl_priv
*priv
,
192 struct ieee80211_tx_info
*info
,
193 struct iwl_tx_cmd
*tx_cmd
,
194 struct sk_buff
*skb_frag
)
196 struct ieee80211_key_conf
*keyconf
= info
->control
.hw_key
;
198 switch (keyconf
->cipher
) {
199 case WLAN_CIPHER_SUITE_CCMP
:
200 tx_cmd
->sec_ctl
= TX_CMD_SEC_CCM
;
201 memcpy(tx_cmd
->key
, keyconf
->key
, keyconf
->keylen
);
202 if (info
->flags
& IEEE80211_TX_CTL_AMPDU
)
203 tx_cmd
->tx_flags
|= TX_CMD_FLG_AGG_CCMP_MSK
;
206 case WLAN_CIPHER_SUITE_TKIP
:
207 tx_cmd
->sec_ctl
= TX_CMD_SEC_TKIP
;
208 ieee80211_get_tkip_p2k(keyconf
, skb_frag
, tx_cmd
->key
);
211 case WLAN_CIPHER_SUITE_WEP104
:
212 tx_cmd
->sec_ctl
|= TX_CMD_SEC_KEY128
;
214 case WLAN_CIPHER_SUITE_WEP40
:
215 tx_cmd
->sec_ctl
|= (TX_CMD_SEC_WEP
|
216 (keyconf
->keyidx
& TX_CMD_SEC_MSK
) << TX_CMD_SEC_SHIFT
);
218 memcpy(&tx_cmd
->key
[3], keyconf
->key
, keyconf
->keylen
);
220 IWL_DEBUG_TX(priv
, "Configuring packet for WEP encryption "
221 "with key %d\n", keyconf
->keyidx
);
225 IWL_ERR(priv
, "Unknown encode cipher %x\n", keyconf
->cipher
);
231 * iwl_sta_id_or_broadcast - return sta_id or broadcast sta
232 * @context: the current context
233 * @sta: mac80211 station
235 * In certain circumstances mac80211 passes a station pointer
236 * that may be %NULL, for example during TX or key setup. In
237 * that case, we need to use the broadcast station, so this
238 * inline wraps that pattern.
240 static int iwl_sta_id_or_broadcast(struct iwl_rxon_context
*context
,
241 struct ieee80211_sta
*sta
)
246 return context
->bcast_sta_id
;
248 sta_id
= iwl_sta_id(sta
);
251 * mac80211 should not be passing a partially
252 * initialised station!
254 WARN_ON(sta_id
== IWL_INVALID_STATION
);
260 * start REPLY_TX command process
262 int iwlagn_tx_skb(struct iwl_priv
*priv
,
263 struct ieee80211_sta
*sta
,
266 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
267 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
268 struct iwl_station_priv
*sta_priv
= NULL
;
269 struct iwl_rxon_context
*ctx
= &priv
->contexts
[IWL_RXON_CTX_BSS
];
270 struct iwl_device_cmd
*dev_cmd
;
271 struct iwl_tx_cmd
*tx_cmd
;
274 u16 len
, seq_number
= 0;
275 u8 sta_id
, tid
= IWL_MAX_TID_COUNT
;
276 bool is_agg
= false, is_data_qos
= false;
279 if (info
->control
.vif
)
280 ctx
= iwl_rxon_ctx_from_vif(info
->control
.vif
);
282 if (iwl_is_rfkill(priv
)) {
283 IWL_DEBUG_DROP(priv
, "Dropping - RF KILL\n");
284 goto drop_unlock_priv
;
287 fc
= hdr
->frame_control
;
289 #ifdef CONFIG_IWLWIFI_DEBUG
290 if (ieee80211_is_auth(fc
))
291 IWL_DEBUG_TX(priv
, "Sending AUTH frame\n");
292 else if (ieee80211_is_assoc_req(fc
))
293 IWL_DEBUG_TX(priv
, "Sending ASSOC frame\n");
294 else if (ieee80211_is_reassoc_req(fc
))
295 IWL_DEBUG_TX(priv
, "Sending REASSOC frame\n");
298 if (unlikely(ieee80211_is_probe_resp(fc
))) {
299 struct iwl_wipan_noa_data
*noa_data
=
300 rcu_dereference(priv
->noa_data
);
303 pskb_expand_head(skb
, 0, noa_data
->length
,
305 skb_put_data(skb
, noa_data
->data
, noa_data
->length
);
306 hdr
= (struct ieee80211_hdr
*)skb
->data
;
310 hdr_len
= ieee80211_hdrlen(fc
);
312 /* For management frames use broadcast id to do not break aggregation */
313 if (!ieee80211_is_data(fc
))
314 sta_id
= ctx
->bcast_sta_id
;
316 /* Find index into station table for destination station */
317 sta_id
= iwl_sta_id_or_broadcast(ctx
, sta
);
318 if (sta_id
== IWL_INVALID_STATION
) {
319 IWL_DEBUG_DROP(priv
, "Dropping - INVALID STATION: %pM\n",
321 goto drop_unlock_priv
;
326 sta_priv
= (void *)sta
->drv_priv
;
328 if (sta_priv
&& sta_priv
->asleep
&&
329 (info
->flags
& IEEE80211_TX_CTL_NO_PS_BUFFER
)) {
331 * This sends an asynchronous command to the device,
332 * but we can rely on it being processed before the
333 * next frame is processed -- and the next frame to
334 * this station is the one that will consume this
336 * For now set the counter to just 1 since we do not
339 * FIXME: If we get two non-bufferable frames one
340 * after the other, we might only send out one of
341 * them because this is racy.
343 iwl_sta_modify_sleep_tx_count(priv
, sta_id
, 1);
346 dev_cmd
= iwl_trans_alloc_tx_cmd(priv
->trans
);
348 if (unlikely(!dev_cmd
))
349 goto drop_unlock_priv
;
351 memset(dev_cmd
, 0, sizeof(*dev_cmd
));
352 dev_cmd
->hdr
.cmd
= REPLY_TX
;
353 tx_cmd
= (struct iwl_tx_cmd
*) dev_cmd
->payload
;
355 /* Total # bytes to be transmitted */
357 tx_cmd
->len
= cpu_to_le16(len
);
359 if (info
->control
.hw_key
)
360 iwlagn_tx_cmd_build_hwcrypto(priv
, info
, tx_cmd
, skb
);
362 /* TODO need this for burst mode later on */
363 iwlagn_tx_cmd_build_basic(priv
, skb
, tx_cmd
, info
, hdr
, sta_id
);
365 iwlagn_tx_cmd_build_rate(priv
, tx_cmd
, info
, sta
, fc
);
367 memset(&info
->status
, 0, sizeof(info
->status
));
368 memset(info
->driver_data
, 0, sizeof(info
->driver_data
));
370 info
->driver_data
[0] = ctx
;
371 info
->driver_data
[1] = dev_cmd
;
372 /* From now on, we cannot access info->control */
374 spin_lock(&priv
->sta_lock
);
376 if (ieee80211_is_data_qos(fc
) && !ieee80211_is_qos_nullfunc(fc
)) {
378 struct iwl_tid_data
*tid_data
;
379 qc
= ieee80211_get_qos_ctl(hdr
);
380 tid
= qc
[0] & IEEE80211_QOS_CTL_TID_MASK
;
381 if (WARN_ON_ONCE(tid
>= IWL_MAX_TID_COUNT
))
382 goto drop_unlock_sta
;
383 tid_data
= &priv
->tid_data
[sta_id
][tid
];
385 /* aggregation is on for this <sta,tid> */
386 if (info
->flags
& IEEE80211_TX_CTL_AMPDU
&&
387 tid_data
->agg
.state
!= IWL_AGG_ON
) {
389 "TX_CTL_AMPDU while not in AGG: Tx flags = 0x%08x, agg.state = %d\n",
390 info
->flags
, tid_data
->agg
.state
);
391 IWL_ERR(priv
, "sta_id = %d, tid = %d seq_num = %d\n",
393 IEEE80211_SEQ_TO_SN(tid_data
->seq_number
));
394 goto drop_unlock_sta
;
397 /* We can receive packets from the stack in IWL_AGG_{ON,OFF}
398 * only. Check this here.
400 if (WARN_ONCE(tid_data
->agg
.state
!= IWL_AGG_ON
&&
401 tid_data
->agg
.state
!= IWL_AGG_OFF
,
402 "Tx while agg.state = %d\n", tid_data
->agg
.state
))
403 goto drop_unlock_sta
;
405 seq_number
= tid_data
->seq_number
;
406 seq_number
&= IEEE80211_SCTL_SEQ
;
407 hdr
->seq_ctrl
&= cpu_to_le16(IEEE80211_SCTL_FRAG
);
408 hdr
->seq_ctrl
|= cpu_to_le16(seq_number
);
411 if (info
->flags
& IEEE80211_TX_CTL_AMPDU
)
416 /* Copy MAC header from skb into command buffer */
417 memcpy(tx_cmd
->hdr
, hdr
, hdr_len
);
419 txq_id
= info
->hw_queue
;
422 txq_id
= priv
->tid_data
[sta_id
][tid
].agg
.txq_id
;
423 else if (info
->flags
& IEEE80211_TX_CTL_SEND_AFTER_DTIM
) {
425 * The microcode will clear the more data
426 * bit in the last frame it transmits.
428 hdr
->frame_control
|=
429 cpu_to_le16(IEEE80211_FCTL_MOREDATA
);
432 WARN_ON_ONCE(is_agg
&&
433 priv
->queue_to_mac80211
[txq_id
] != info
->hw_queue
);
435 IWL_DEBUG_TX(priv
, "TX to [%d|%d] Q:%d - seq: 0x%x\n", sta_id
, tid
,
438 if (iwl_trans_tx(priv
->trans
, skb
, dev_cmd
, txq_id
))
439 goto drop_unlock_sta
;
441 if (is_data_qos
&& !ieee80211_has_morefrags(fc
))
442 priv
->tid_data
[sta_id
][tid
].seq_number
= seq_number
;
444 spin_unlock(&priv
->sta_lock
);
447 * Avoid atomic ops if it isn't an associated client.
448 * Also, if this is a packet for aggregation, don't
449 * increase the counter because the ucode will stop
450 * aggregation queues when their respective station
453 if (sta_priv
&& sta_priv
->client
&& !is_agg
)
454 atomic_inc(&sta_priv
->pending_frames
);
460 iwl_trans_free_tx_cmd(priv
->trans
, dev_cmd
);
461 spin_unlock(&priv
->sta_lock
);
466 static int iwlagn_alloc_agg_txq(struct iwl_priv
*priv
, int mq
)
470 for (q
= IWLAGN_FIRST_AMPDU_QUEUE
;
471 q
< priv
->trans
->trans_cfg
->base_params
->num_of_queues
; q
++) {
472 if (!test_and_set_bit(q
, priv
->agg_q_alloc
)) {
473 priv
->queue_to_mac80211
[q
] = mq
;
481 static void iwlagn_dealloc_agg_txq(struct iwl_priv
*priv
, int q
)
483 clear_bit(q
, priv
->agg_q_alloc
);
484 priv
->queue_to_mac80211
[q
] = IWL_INVALID_MAC80211_QUEUE
;
487 int iwlagn_tx_agg_stop(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
,
488 struct ieee80211_sta
*sta
, u16 tid
)
490 struct iwl_tid_data
*tid_data
;
492 enum iwl_agg_state agg_state
;
494 sta_id
= iwl_sta_id(sta
);
496 if (sta_id
== IWL_INVALID_STATION
) {
497 IWL_ERR(priv
, "Invalid station for AGG tid %d\n", tid
);
501 spin_lock_bh(&priv
->sta_lock
);
503 tid_data
= &priv
->tid_data
[sta_id
][tid
];
504 txq_id
= tid_data
->agg
.txq_id
;
506 switch (tid_data
->agg
.state
) {
507 case IWL_EMPTYING_HW_QUEUE_ADDBA
:
509 * This can happen if the peer stops aggregation
510 * again before we've had a chance to drain the
511 * queue we selected previously, i.e. before the
512 * session was really started completely.
514 IWL_DEBUG_HT(priv
, "AGG stop before setup done\n");
516 case IWL_AGG_STARTING
:
518 * This can happen when the session is stopped before
519 * we receive ADDBA response
521 IWL_DEBUG_HT(priv
, "AGG stop before AGG became operational\n");
527 "Stopping AGG while state not ON or starting for %d on %d (%d)\n",
528 sta_id
, tid
, tid_data
->agg
.state
);
529 spin_unlock_bh(&priv
->sta_lock
);
533 tid_data
->agg
.ssn
= IEEE80211_SEQ_TO_SN(tid_data
->seq_number
);
535 /* There are still packets for this RA / TID in the HW */
536 if (!test_bit(txq_id
, priv
->agg_q_alloc
)) {
537 IWL_DEBUG_TX_QUEUES(priv
,
538 "stopping AGG on STA/TID %d/%d but hwq %d not used\n",
539 sta_id
, tid
, txq_id
);
540 } else if (tid_data
->agg
.ssn
!= tid_data
->next_reclaimed
) {
541 IWL_DEBUG_TX_QUEUES(priv
,
542 "Can't proceed: ssn %d, next_recl = %d\n",
544 tid_data
->next_reclaimed
);
545 tid_data
->agg
.state
= IWL_EMPTYING_HW_QUEUE_DELBA
;
546 spin_unlock_bh(&priv
->sta_lock
);
550 IWL_DEBUG_TX_QUEUES(priv
, "Can proceed: ssn = next_recl = %d\n",
553 agg_state
= tid_data
->agg
.state
;
554 tid_data
->agg
.state
= IWL_AGG_OFF
;
556 spin_unlock_bh(&priv
->sta_lock
);
558 if (test_bit(txq_id
, priv
->agg_q_alloc
)) {
560 * If the transport didn't know that we wanted to start
561 * agreggation, don't tell it that we want to stop them.
562 * This can happen when we don't get the addBA response on
563 * time, or we hadn't time to drain the AC queues.
565 if (agg_state
== IWL_AGG_ON
)
566 iwl_trans_txq_disable(priv
->trans
, txq_id
, true);
568 IWL_DEBUG_TX_QUEUES(priv
, "Don't disable tx agg: %d\n",
570 iwlagn_dealloc_agg_txq(priv
, txq_id
);
573 ieee80211_stop_tx_ba_cb_irqsafe(vif
, sta
->addr
, tid
);
578 int iwlagn_tx_agg_start(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
,
579 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
)
581 struct iwl_rxon_context
*ctx
= iwl_rxon_ctx_from_vif(vif
);
582 struct iwl_tid_data
*tid_data
;
583 int sta_id
, txq_id
, ret
;
585 IWL_DEBUG_HT(priv
, "TX AGG request on ra = %pM tid = %d\n",
588 sta_id
= iwl_sta_id(sta
);
589 if (sta_id
== IWL_INVALID_STATION
) {
590 IWL_ERR(priv
, "Start AGG on invalid station\n");
593 if (unlikely(tid
>= IWL_MAX_TID_COUNT
))
596 if (priv
->tid_data
[sta_id
][tid
].agg
.state
!= IWL_AGG_OFF
) {
597 IWL_ERR(priv
, "Start AGG when state is not IWL_AGG_OFF !\n");
601 txq_id
= iwlagn_alloc_agg_txq(priv
, ctx
->ac_to_queue
[tid_to_ac
[tid
]]);
603 IWL_DEBUG_TX_QUEUES(priv
,
604 "No free aggregation queue for %pM/%d\n",
609 ret
= iwl_sta_tx_modify_enable_tid(priv
, sta_id
, tid
);
613 spin_lock_bh(&priv
->sta_lock
);
614 tid_data
= &priv
->tid_data
[sta_id
][tid
];
615 tid_data
->agg
.ssn
= IEEE80211_SEQ_TO_SN(tid_data
->seq_number
);
616 tid_data
->agg
.txq_id
= txq_id
;
618 *ssn
= tid_data
->agg
.ssn
;
620 if (*ssn
== tid_data
->next_reclaimed
) {
621 IWL_DEBUG_TX_QUEUES(priv
, "Can proceed: ssn = next_recl = %d\n",
623 tid_data
->agg
.state
= IWL_AGG_STARTING
;
624 ieee80211_start_tx_ba_cb_irqsafe(vif
, sta
->addr
, tid
);
626 IWL_DEBUG_TX_QUEUES(priv
, "Can't proceed: ssn %d, "
627 "next_reclaimed = %d\n",
629 tid_data
->next_reclaimed
);
630 tid_data
->agg
.state
= IWL_EMPTYING_HW_QUEUE_ADDBA
;
632 spin_unlock_bh(&priv
->sta_lock
);
637 int iwlagn_tx_agg_flush(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
,
638 struct ieee80211_sta
*sta
, u16 tid
)
640 struct iwl_tid_data
*tid_data
;
641 enum iwl_agg_state agg_state
;
643 sta_id
= iwl_sta_id(sta
);
646 * First set the agg state to OFF to avoid calling
647 * ieee80211_stop_tx_ba_cb in iwlagn_check_ratid_empty.
649 spin_lock_bh(&priv
->sta_lock
);
651 tid_data
= &priv
->tid_data
[sta_id
][tid
];
652 txq_id
= tid_data
->agg
.txq_id
;
653 agg_state
= tid_data
->agg
.state
;
654 IWL_DEBUG_TX_QUEUES(priv
, "Flush AGG: sta %d tid %d q %d state %d\n",
655 sta_id
, tid
, txq_id
, tid_data
->agg
.state
);
657 tid_data
->agg
.state
= IWL_AGG_OFF
;
659 spin_unlock_bh(&priv
->sta_lock
);
661 if (iwlagn_txfifo_flush(priv
, BIT(txq_id
)))
662 IWL_ERR(priv
, "Couldn't flush the AGG queue\n");
664 if (test_bit(txq_id
, priv
->agg_q_alloc
)) {
666 * If the transport didn't know that we wanted to start
667 * agreggation, don't tell it that we want to stop them.
668 * This can happen when we don't get the addBA response on
669 * time, or we hadn't time to drain the AC queues.
671 if (agg_state
== IWL_AGG_ON
)
672 iwl_trans_txq_disable(priv
->trans
, txq_id
, true);
674 IWL_DEBUG_TX_QUEUES(priv
, "Don't disable tx agg: %d\n",
676 iwlagn_dealloc_agg_txq(priv
, txq_id
);
682 int iwlagn_tx_agg_oper(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
,
683 struct ieee80211_sta
*sta
, u16 tid
, u8 buf_size
)
685 struct iwl_station_priv
*sta_priv
= (void *) sta
->drv_priv
;
686 struct iwl_rxon_context
*ctx
= iwl_rxon_ctx_from_vif(vif
);
690 buf_size
= min_t(int, buf_size
, LINK_QUAL_AGG_FRAME_LIMIT_DEF
);
692 spin_lock_bh(&priv
->sta_lock
);
693 ssn
= priv
->tid_data
[sta_priv
->sta_id
][tid
].agg
.ssn
;
694 q
= priv
->tid_data
[sta_priv
->sta_id
][tid
].agg
.txq_id
;
695 priv
->tid_data
[sta_priv
->sta_id
][tid
].agg
.state
= IWL_AGG_ON
;
696 spin_unlock_bh(&priv
->sta_lock
);
698 fifo
= ctx
->ac_to_fifo
[tid_to_ac
[tid
]];
700 iwl_trans_txq_enable(priv
->trans
, q
, fifo
, sta_priv
->sta_id
, tid
,
704 * If the limit is 0, then it wasn't initialised yet,
705 * use the default. We can do that since we take the
706 * minimum below, and we don't want to go above our
707 * default due to hardware restrictions.
709 if (sta_priv
->max_agg_bufsize
== 0)
710 sta_priv
->max_agg_bufsize
=
711 LINK_QUAL_AGG_FRAME_LIMIT_DEF
;
714 * Even though in theory the peer could have different
715 * aggregation reorder buffer sizes for different sessions,
716 * our ucode doesn't allow for that and has a global limit
717 * for each station. Therefore, use the minimum of all the
718 * aggregation sessions and our default value.
720 sta_priv
->max_agg_bufsize
=
721 min(sta_priv
->max_agg_bufsize
, buf_size
);
723 if (priv
->hw_params
.use_rts_for_aggregation
) {
725 * switch to RTS/CTS if it is the prefer protection
726 * method for HT traffic
729 sta_priv
->lq_sta
.lq
.general_params
.flags
|=
730 LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK
;
732 priv
->agg_tids_count
++;
733 IWL_DEBUG_HT(priv
, "priv->agg_tids_count = %u\n",
734 priv
->agg_tids_count
);
736 sta_priv
->lq_sta
.lq
.agg_params
.agg_frame_cnt_limit
=
737 sta_priv
->max_agg_bufsize
;
739 IWL_DEBUG_HT(priv
, "Tx aggregation enabled on ra = %pM tid = %d\n",
742 return iwl_send_lq_cmd(priv
, ctx
,
743 &sta_priv
->lq_sta
.lq
, CMD_ASYNC
, false);
746 static void iwlagn_check_ratid_empty(struct iwl_priv
*priv
, int sta_id
, u8 tid
)
748 struct iwl_tid_data
*tid_data
= &priv
->tid_data
[sta_id
][tid
];
749 enum iwl_rxon_context_id ctx
;
750 struct ieee80211_vif
*vif
;
753 lockdep_assert_held(&priv
->sta_lock
);
755 addr
= priv
->stations
[sta_id
].sta
.sta
.addr
;
756 ctx
= priv
->stations
[sta_id
].ctxid
;
757 vif
= priv
->contexts
[ctx
].vif
;
759 switch (priv
->tid_data
[sta_id
][tid
].agg
.state
) {
760 case IWL_EMPTYING_HW_QUEUE_DELBA
:
761 /* There are no packets for this RA / TID in the HW any more */
762 if (tid_data
->agg
.ssn
== tid_data
->next_reclaimed
) {
763 IWL_DEBUG_TX_QUEUES(priv
,
764 "Can continue DELBA flow ssn = next_recl = %d\n",
765 tid_data
->next_reclaimed
);
766 iwl_trans_txq_disable(priv
->trans
,
767 tid_data
->agg
.txq_id
, true);
768 iwlagn_dealloc_agg_txq(priv
, tid_data
->agg
.txq_id
);
769 tid_data
->agg
.state
= IWL_AGG_OFF
;
770 ieee80211_stop_tx_ba_cb_irqsafe(vif
, addr
, tid
);
773 case IWL_EMPTYING_HW_QUEUE_ADDBA
:
774 /* There are no packets for this RA / TID in the HW any more */
775 if (tid_data
->agg
.ssn
== tid_data
->next_reclaimed
) {
776 IWL_DEBUG_TX_QUEUES(priv
,
777 "Can continue ADDBA flow ssn = next_recl = %d\n",
778 tid_data
->next_reclaimed
);
779 tid_data
->agg
.state
= IWL_AGG_STARTING
;
780 ieee80211_start_tx_ba_cb_irqsafe(vif
, addr
, tid
);
788 static void iwlagn_non_agg_tx_status(struct iwl_priv
*priv
,
789 struct iwl_rxon_context
*ctx
,
792 struct ieee80211_sta
*sta
;
793 struct iwl_station_priv
*sta_priv
;
796 sta
= ieee80211_find_sta(ctx
->vif
, addr1
);
798 sta_priv
= (void *)sta
->drv_priv
;
799 /* avoid atomic ops if this isn't a client */
800 if (sta_priv
->client
&&
801 atomic_dec_return(&sta_priv
->pending_frames
) == 0)
802 ieee80211_sta_block_awake(priv
->hw
, sta
, false);
808 * translate ucode response to mac80211 tx status control values
810 static void iwlagn_hwrate_to_tx_control(struct iwl_priv
*priv
, u32 rate_n_flags
,
811 struct ieee80211_tx_info
*info
)
813 struct ieee80211_tx_rate
*r
= &info
->status
.rates
[0];
815 info
->status
.antenna
=
816 ((rate_n_flags
& RATE_MCS_ANT_ABC_MSK
) >> RATE_MCS_ANT_POS
);
817 if (rate_n_flags
& RATE_MCS_HT_MSK
)
818 r
->flags
|= IEEE80211_TX_RC_MCS
;
819 if (rate_n_flags
& RATE_MCS_GF_MSK
)
820 r
->flags
|= IEEE80211_TX_RC_GREEN_FIELD
;
821 if (rate_n_flags
& RATE_MCS_HT40_MSK
)
822 r
->flags
|= IEEE80211_TX_RC_40_MHZ_WIDTH
;
823 if (rate_n_flags
& RATE_MCS_DUP_MSK
)
824 r
->flags
|= IEEE80211_TX_RC_DUP_DATA
;
825 if (rate_n_flags
& RATE_MCS_SGI_MSK
)
826 r
->flags
|= IEEE80211_TX_RC_SHORT_GI
;
827 r
->idx
= iwlagn_hwrate_to_mac80211_idx(rate_n_flags
, info
->band
);
830 #ifdef CONFIG_IWLWIFI_DEBUG
831 const char *iwl_get_tx_fail_reason(u32 status
)
833 #define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
834 #define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
836 switch (status
& TX_STATUS_MSK
) {
837 case TX_STATUS_SUCCESS
:
839 TX_STATUS_POSTPONE(DELAY
);
840 TX_STATUS_POSTPONE(FEW_BYTES
);
841 TX_STATUS_POSTPONE(BT_PRIO
);
842 TX_STATUS_POSTPONE(QUIET_PERIOD
);
843 TX_STATUS_POSTPONE(CALC_TTAK
);
844 TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY
);
845 TX_STATUS_FAIL(SHORT_LIMIT
);
846 TX_STATUS_FAIL(LONG_LIMIT
);
847 TX_STATUS_FAIL(FIFO_UNDERRUN
);
848 TX_STATUS_FAIL(DRAIN_FLOW
);
849 TX_STATUS_FAIL(RFKILL_FLUSH
);
850 TX_STATUS_FAIL(LIFE_EXPIRE
);
851 TX_STATUS_FAIL(DEST_PS
);
852 TX_STATUS_FAIL(HOST_ABORTED
);
853 TX_STATUS_FAIL(BT_RETRY
);
854 TX_STATUS_FAIL(STA_INVALID
);
855 TX_STATUS_FAIL(FRAG_DROPPED
);
856 TX_STATUS_FAIL(TID_DISABLE
);
857 TX_STATUS_FAIL(FIFO_FLUSHED
);
858 TX_STATUS_FAIL(INSUFFICIENT_CF_POLL
);
859 TX_STATUS_FAIL(PASSIVE_NO_RX
);
860 TX_STATUS_FAIL(NO_BEACON_ON_RADAR
);
865 #undef TX_STATUS_FAIL
866 #undef TX_STATUS_POSTPONE
868 #endif /* CONFIG_IWLWIFI_DEBUG */
870 static void iwlagn_count_agg_tx_err_status(struct iwl_priv
*priv
, u16 status
)
872 status
&= AGG_TX_STATUS_MSK
;
875 case AGG_TX_STATE_UNDERRUN_MSK
:
876 priv
->reply_agg_tx_stats
.underrun
++;
878 case AGG_TX_STATE_BT_PRIO_MSK
:
879 priv
->reply_agg_tx_stats
.bt_prio
++;
881 case AGG_TX_STATE_FEW_BYTES_MSK
:
882 priv
->reply_agg_tx_stats
.few_bytes
++;
884 case AGG_TX_STATE_ABORT_MSK
:
885 priv
->reply_agg_tx_stats
.abort
++;
887 case AGG_TX_STATE_LAST_SENT_TTL_MSK
:
888 priv
->reply_agg_tx_stats
.last_sent_ttl
++;
890 case AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK
:
891 priv
->reply_agg_tx_stats
.last_sent_try
++;
893 case AGG_TX_STATE_LAST_SENT_BT_KILL_MSK
:
894 priv
->reply_agg_tx_stats
.last_sent_bt_kill
++;
896 case AGG_TX_STATE_SCD_QUERY_MSK
:
897 priv
->reply_agg_tx_stats
.scd_query
++;
899 case AGG_TX_STATE_TEST_BAD_CRC32_MSK
:
900 priv
->reply_agg_tx_stats
.bad_crc32
++;
902 case AGG_TX_STATE_RESPONSE_MSK
:
903 priv
->reply_agg_tx_stats
.response
++;
905 case AGG_TX_STATE_DUMP_TX_MSK
:
906 priv
->reply_agg_tx_stats
.dump_tx
++;
908 case AGG_TX_STATE_DELAY_TX_MSK
:
909 priv
->reply_agg_tx_stats
.delay_tx
++;
912 priv
->reply_agg_tx_stats
.unknown
++;
917 static inline u32
iwlagn_get_scd_ssn(struct iwlagn_tx_resp
*tx_resp
)
919 return le32_to_cpup((__le32
*)&tx_resp
->status
+
920 tx_resp
->frame_count
) & IEEE80211_MAX_SN
;
923 static void iwl_rx_reply_tx_agg(struct iwl_priv
*priv
,
924 struct iwlagn_tx_resp
*tx_resp
)
926 struct agg_tx_status
*frame_status
= &tx_resp
->status
;
927 int tid
= (tx_resp
->ra_tid
& IWLAGN_TX_RES_TID_MSK
) >>
928 IWLAGN_TX_RES_TID_POS
;
929 int sta_id
= (tx_resp
->ra_tid
& IWLAGN_TX_RES_RA_MSK
) >>
930 IWLAGN_TX_RES_RA_POS
;
931 struct iwl_ht_agg
*agg
= &priv
->tid_data
[sta_id
][tid
].agg
;
932 u32 status
= le16_to_cpu(tx_resp
->status
.status
);
935 WARN_ON(tid
== IWL_TID_NON_QOS
);
937 if (agg
->wait_for_ba
)
938 IWL_DEBUG_TX_REPLY(priv
,
939 "got tx response w/o block-ack\n");
941 agg
->rate_n_flags
= le32_to_cpu(tx_resp
->rate_n_flags
);
942 agg
->wait_for_ba
= (tx_resp
->frame_count
> 1);
945 * If the BT kill count is non-zero, we'll get this
946 * notification again.
948 if (tx_resp
->bt_kill_count
&& tx_resp
->frame_count
== 1 &&
949 priv
->lib
->bt_params
&&
950 priv
->lib
->bt_params
->advanced_bt_coexist
) {
951 IWL_DEBUG_COEX(priv
, "receive reply tx w/ bt_kill\n");
954 if (tx_resp
->frame_count
== 1)
957 IWL_DEBUG_TX_REPLY(priv
, "TXQ %d initial_rate 0x%x ssn %d frm_cnt %d\n",
959 le32_to_cpu(tx_resp
->rate_n_flags
),
960 iwlagn_get_scd_ssn(tx_resp
), tx_resp
->frame_count
);
962 /* Construct bit-map of pending frames within Tx window */
963 for (i
= 0; i
< tx_resp
->frame_count
; i
++) {
964 u16 fstatus
= le16_to_cpu(frame_status
[i
].status
);
965 u8 retry_cnt
= (fstatus
& AGG_TX_TRY_MSK
) >> AGG_TX_TRY_POS
;
967 if (status
& AGG_TX_STATUS_MSK
)
968 iwlagn_count_agg_tx_err_status(priv
, fstatus
);
970 if (status
& (AGG_TX_STATE_FEW_BYTES_MSK
|
971 AGG_TX_STATE_ABORT_MSK
))
974 if (status
& AGG_TX_STATUS_MSK
|| retry_cnt
> 1)
975 IWL_DEBUG_TX_REPLY(priv
,
976 "%d: status %s (0x%04x), try-count (0x%01x)\n",
978 iwl_get_agg_tx_fail_reason(fstatus
),
979 fstatus
& AGG_TX_STATUS_MSK
,
984 #ifdef CONFIG_IWLWIFI_DEBUG
985 #define AGG_TX_STATE_FAIL(x) case AGG_TX_STATE_ ## x: return #x
987 const char *iwl_get_agg_tx_fail_reason(u16 status
)
989 status
&= AGG_TX_STATUS_MSK
;
991 case AGG_TX_STATE_TRANSMITTED
:
993 AGG_TX_STATE_FAIL(UNDERRUN_MSK
);
994 AGG_TX_STATE_FAIL(BT_PRIO_MSK
);
995 AGG_TX_STATE_FAIL(FEW_BYTES_MSK
);
996 AGG_TX_STATE_FAIL(ABORT_MSK
);
997 AGG_TX_STATE_FAIL(LAST_SENT_TTL_MSK
);
998 AGG_TX_STATE_FAIL(LAST_SENT_TRY_CNT_MSK
);
999 AGG_TX_STATE_FAIL(LAST_SENT_BT_KILL_MSK
);
1000 AGG_TX_STATE_FAIL(SCD_QUERY_MSK
);
1001 AGG_TX_STATE_FAIL(TEST_BAD_CRC32_MSK
);
1002 AGG_TX_STATE_FAIL(RESPONSE_MSK
);
1003 AGG_TX_STATE_FAIL(DUMP_TX_MSK
);
1004 AGG_TX_STATE_FAIL(DELAY_TX_MSK
);
1009 #endif /* CONFIG_IWLWIFI_DEBUG */
1011 static void iwlagn_count_tx_err_status(struct iwl_priv
*priv
, u16 status
)
1013 status
&= TX_STATUS_MSK
;
1016 case TX_STATUS_POSTPONE_DELAY
:
1017 priv
->reply_tx_stats
.pp_delay
++;
1019 case TX_STATUS_POSTPONE_FEW_BYTES
:
1020 priv
->reply_tx_stats
.pp_few_bytes
++;
1022 case TX_STATUS_POSTPONE_BT_PRIO
:
1023 priv
->reply_tx_stats
.pp_bt_prio
++;
1025 case TX_STATUS_POSTPONE_QUIET_PERIOD
:
1026 priv
->reply_tx_stats
.pp_quiet_period
++;
1028 case TX_STATUS_POSTPONE_CALC_TTAK
:
1029 priv
->reply_tx_stats
.pp_calc_ttak
++;
1031 case TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY
:
1032 priv
->reply_tx_stats
.int_crossed_retry
++;
1034 case TX_STATUS_FAIL_SHORT_LIMIT
:
1035 priv
->reply_tx_stats
.short_limit
++;
1037 case TX_STATUS_FAIL_LONG_LIMIT
:
1038 priv
->reply_tx_stats
.long_limit
++;
1040 case TX_STATUS_FAIL_FIFO_UNDERRUN
:
1041 priv
->reply_tx_stats
.fifo_underrun
++;
1043 case TX_STATUS_FAIL_DRAIN_FLOW
:
1044 priv
->reply_tx_stats
.drain_flow
++;
1046 case TX_STATUS_FAIL_RFKILL_FLUSH
:
1047 priv
->reply_tx_stats
.rfkill_flush
++;
1049 case TX_STATUS_FAIL_LIFE_EXPIRE
:
1050 priv
->reply_tx_stats
.life_expire
++;
1052 case TX_STATUS_FAIL_DEST_PS
:
1053 priv
->reply_tx_stats
.dest_ps
++;
1055 case TX_STATUS_FAIL_HOST_ABORTED
:
1056 priv
->reply_tx_stats
.host_abort
++;
1058 case TX_STATUS_FAIL_BT_RETRY
:
1059 priv
->reply_tx_stats
.bt_retry
++;
1061 case TX_STATUS_FAIL_STA_INVALID
:
1062 priv
->reply_tx_stats
.sta_invalid
++;
1064 case TX_STATUS_FAIL_FRAG_DROPPED
:
1065 priv
->reply_tx_stats
.frag_drop
++;
1067 case TX_STATUS_FAIL_TID_DISABLE
:
1068 priv
->reply_tx_stats
.tid_disable
++;
1070 case TX_STATUS_FAIL_FIFO_FLUSHED
:
1071 priv
->reply_tx_stats
.fifo_flush
++;
1073 case TX_STATUS_FAIL_INSUFFICIENT_CF_POLL
:
1074 priv
->reply_tx_stats
.insuff_cf_poll
++;
1076 case TX_STATUS_FAIL_PASSIVE_NO_RX
:
1077 priv
->reply_tx_stats
.fail_hw_drop
++;
1079 case TX_STATUS_FAIL_NO_BEACON_ON_RADAR
:
1080 priv
->reply_tx_stats
.sta_color_mismatch
++;
1083 priv
->reply_tx_stats
.unknown
++;
1088 static void iwlagn_set_tx_status(struct iwl_priv
*priv
,
1089 struct ieee80211_tx_info
*info
,
1090 struct iwlagn_tx_resp
*tx_resp
)
1092 u16 status
= le16_to_cpu(tx_resp
->status
.status
);
1094 info
->flags
&= ~IEEE80211_TX_CTL_AMPDU
;
1096 info
->status
.rates
[0].count
= tx_resp
->failure_frame
+ 1;
1097 info
->flags
|= iwl_tx_status_to_mac80211(status
);
1098 iwlagn_hwrate_to_tx_control(priv
, le32_to_cpu(tx_resp
->rate_n_flags
),
1100 if (!iwl_is_tx_success(status
))
1101 iwlagn_count_tx_err_status(priv
, status
);
1104 static void iwl_check_abort_status(struct iwl_priv
*priv
,
1105 u8 frame_count
, u32 status
)
1107 if (frame_count
== 1 && status
== TX_STATUS_FAIL_RFKILL_FLUSH
) {
1108 IWL_ERR(priv
, "Tx flush command to flush out all frames\n");
1109 if (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
1110 queue_work(priv
->workqueue
, &priv
->tx_flush
);
1114 void iwlagn_rx_reply_tx(struct iwl_priv
*priv
, struct iwl_rx_cmd_buffer
*rxb
)
1116 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1117 u16 sequence
= le16_to_cpu(pkt
->hdr
.sequence
);
1118 int txq_id
= SEQ_TO_QUEUE(sequence
);
1119 int cmd_index __maybe_unused
= SEQ_TO_INDEX(sequence
);
1120 struct iwlagn_tx_resp
*tx_resp
= (void *)pkt
->data
;
1121 struct ieee80211_hdr
*hdr
;
1122 u32 status
= le16_to_cpu(tx_resp
->status
.status
);
1123 u16 ssn
= iwlagn_get_scd_ssn(tx_resp
);
1127 struct ieee80211_tx_info
*info
;
1128 struct sk_buff_head skbs
;
1129 struct sk_buff
*skb
;
1130 struct iwl_rxon_context
*ctx
;
1131 bool is_agg
= (txq_id
>= IWLAGN_FIRST_AMPDU_QUEUE
);
1133 tid
= (tx_resp
->ra_tid
& IWLAGN_TX_RES_TID_MSK
) >>
1134 IWLAGN_TX_RES_TID_POS
;
1135 sta_id
= (tx_resp
->ra_tid
& IWLAGN_TX_RES_RA_MSK
) >>
1136 IWLAGN_TX_RES_RA_POS
;
1138 spin_lock_bh(&priv
->sta_lock
);
1141 WARN_ON_ONCE(sta_id
>= IWLAGN_STATION_COUNT
||
1142 tid
>= IWL_MAX_TID_COUNT
);
1143 if (txq_id
!= priv
->tid_data
[sta_id
][tid
].agg
.txq_id
)
1144 IWL_ERR(priv
, "txq_id mismatch: %d %d\n", txq_id
,
1145 priv
->tid_data
[sta_id
][tid
].agg
.txq_id
);
1146 iwl_rx_reply_tx_agg(priv
, tx_resp
);
1149 __skb_queue_head_init(&skbs
);
1151 if (tx_resp
->frame_count
== 1) {
1152 u16 next_reclaimed
= le16_to_cpu(tx_resp
->seq_ctl
);
1153 next_reclaimed
= IEEE80211_SEQ_TO_SN(next_reclaimed
+ 0x10);
1156 /* If this is an aggregation queue, we can rely on the
1157 * ssn since the wifi sequence number corresponds to
1158 * the index in the TFD ring (%256).
1159 * The seq_ctl is the sequence control of the packet
1160 * to which this Tx response relates. But if there is a
1161 * hole in the bitmap of the BA we received, this Tx
1162 * response may allow to reclaim the hole and all the
1163 * subsequent packets that were already acked.
1164 * In that case, seq_ctl != ssn, and the next packet
1165 * to be reclaimed will be ssn and not seq_ctl.
1167 next_reclaimed
= ssn
;
1170 if (tid
!= IWL_TID_NON_QOS
) {
1171 priv
->tid_data
[sta_id
][tid
].next_reclaimed
=
1173 IWL_DEBUG_TX_REPLY(priv
, "Next reclaimed packet:%d\n",
1175 iwlagn_check_ratid_empty(priv
, sta_id
, tid
);
1178 iwl_trans_reclaim(priv
->trans
, txq_id
, ssn
, &skbs
);
1182 /* process frames */
1183 skb_queue_walk(&skbs
, skb
) {
1184 hdr
= (struct ieee80211_hdr
*)skb
->data
;
1186 if (!ieee80211_is_data_qos(hdr
->frame_control
))
1187 priv
->last_seq_ctl
= tx_resp
->seq_ctl
;
1189 info
= IEEE80211_SKB_CB(skb
);
1190 ctx
= info
->driver_data
[0];
1191 iwl_trans_free_tx_cmd(priv
->trans
,
1192 info
->driver_data
[1]);
1194 memset(&info
->status
, 0, sizeof(info
->status
));
1196 if (status
== TX_STATUS_FAIL_PASSIVE_NO_RX
&&
1198 ctx
->vif
->type
== NL80211_IFTYPE_STATION
) {
1199 /* block and stop all queues */
1200 priv
->passive_no_rx
= true;
1201 IWL_DEBUG_TX_QUEUES(priv
,
1202 "stop all queues: passive channel\n");
1203 ieee80211_stop_queues(priv
->hw
);
1205 IWL_DEBUG_TX_REPLY(priv
,
1206 "TXQ %d status %s (0x%08x) "
1207 "rate_n_flags 0x%x retries %d\n",
1209 iwl_get_tx_fail_reason(status
),
1211 le32_to_cpu(tx_resp
->rate_n_flags
),
1212 tx_resp
->failure_frame
);
1214 IWL_DEBUG_TX_REPLY(priv
,
1215 "FrameCnt = %d, idx=%d\n",
1216 tx_resp
->frame_count
, cmd_index
);
1219 /* check if BAR is needed */
1220 if (is_agg
&& !iwl_is_tx_success(status
))
1221 info
->flags
|= IEEE80211_TX_STAT_AMPDU_NO_BACK
;
1222 iwlagn_set_tx_status(priv
, IEEE80211_SKB_CB(skb
),
1225 iwlagn_non_agg_tx_status(priv
, ctx
, hdr
->addr1
);
1230 if (tid
!= IWL_TID_NON_QOS
) {
1231 priv
->tid_data
[sta_id
][tid
].next_reclaimed
=
1233 IWL_DEBUG_TX_REPLY(priv
, "Next reclaimed packet:%d\n",
1237 if (!is_agg
&& freed
!= 1)
1238 IWL_ERR(priv
, "Q: %d, freed %d\n", txq_id
, freed
);
1240 IWL_DEBUG_TX_REPLY(priv
, "TXQ %d status %s (0x%08x)\n", txq_id
,
1241 iwl_get_tx_fail_reason(status
), status
);
1243 IWL_DEBUG_TX_REPLY(priv
,
1244 "\t\t\t\tinitial_rate 0x%x retries %d, idx=%d ssn=%d seq_ctl=0x%x\n",
1245 le32_to_cpu(tx_resp
->rate_n_flags
),
1246 tx_resp
->failure_frame
,
1247 SEQ_TO_INDEX(sequence
), ssn
,
1248 le16_to_cpu(tx_resp
->seq_ctl
));
1251 iwl_check_abort_status(priv
, tx_resp
->frame_count
, status
);
1252 spin_unlock_bh(&priv
->sta_lock
);
1254 while (!skb_queue_empty(&skbs
)) {
1255 skb
= __skb_dequeue(&skbs
);
1256 ieee80211_tx_status(priv
->hw
, skb
);
1261 * iwlagn_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA
1263 * Handles block-acknowledge notification from device, which reports success
1264 * of frames sent via aggregation.
1266 void iwlagn_rx_reply_compressed_ba(struct iwl_priv
*priv
,
1267 struct iwl_rx_cmd_buffer
*rxb
)
1269 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1270 struct iwl_compressed_ba_resp
*ba_resp
= (void *)pkt
->data
;
1271 struct iwl_ht_agg
*agg
;
1272 struct sk_buff_head reclaimed_skbs
;
1273 struct sk_buff
*skb
;
1278 /* "flow" corresponds to Tx queue */
1279 u16 scd_flow
= le16_to_cpu(ba_resp
->scd_flow
);
1281 /* "ssn" is start of block-ack Tx window, corresponds to index
1282 * (in Tx queue's circular buffer) of first TFD/frame in window */
1283 u16 ba_resp_scd_ssn
= le16_to_cpu(ba_resp
->scd_ssn
);
1285 if (scd_flow
>= priv
->trans
->trans_cfg
->base_params
->num_of_queues
) {
1287 "BUG_ON scd_flow is bigger than number of queues\n");
1291 sta_id
= ba_resp
->sta_id
;
1293 agg
= &priv
->tid_data
[sta_id
][tid
].agg
;
1295 spin_lock_bh(&priv
->sta_lock
);
1297 if (unlikely(!agg
->wait_for_ba
)) {
1298 if (unlikely(ba_resp
->bitmap
))
1299 IWL_ERR(priv
, "Received BA when not expected\n");
1300 spin_unlock_bh(&priv
->sta_lock
);
1304 if (unlikely(scd_flow
!= agg
->txq_id
)) {
1306 * FIXME: this is a uCode bug which need to be addressed,
1307 * log the information and return for now.
1308 * Since it is can possibly happen very often and in order
1309 * not to fill the syslog, don't use IWL_ERR or IWL_WARN
1311 IWL_DEBUG_TX_QUEUES(priv
,
1312 "Bad queue mapping txq_id=%d, agg_txq[sta:%d,tid:%d]=%d\n",
1313 scd_flow
, sta_id
, tid
, agg
->txq_id
);
1314 spin_unlock_bh(&priv
->sta_lock
);
1318 __skb_queue_head_init(&reclaimed_skbs
);
1320 /* Release all TFDs before the SSN, i.e. all TFDs in front of
1321 * block-ack window (we assume that they've been successfully
1322 * transmitted ... if not, it's too late anyway). */
1323 iwl_trans_reclaim(priv
->trans
, scd_flow
, ba_resp_scd_ssn
,
1326 IWL_DEBUG_TX_REPLY(priv
, "REPLY_COMPRESSED_BA [%d] Received from %pM, "
1329 (u8
*) &ba_resp
->sta_addr_lo32
,
1331 IWL_DEBUG_TX_REPLY(priv
, "TID = %d, SeqCtl = %d, bitmap = 0x%llx, "
1332 "scd_flow = %d, scd_ssn = %d sent:%d, acked:%d\n",
1333 ba_resp
->tid
, le16_to_cpu(ba_resp
->seq_ctl
),
1334 (unsigned long long)le64_to_cpu(ba_resp
->bitmap
),
1335 scd_flow
, ba_resp_scd_ssn
, ba_resp
->txed
,
1336 ba_resp
->txed_2_done
);
1338 /* Mark that the expected block-ack response arrived */
1339 agg
->wait_for_ba
= false;
1341 /* Sanity check values reported by uCode */
1342 if (ba_resp
->txed_2_done
> ba_resp
->txed
) {
1343 IWL_DEBUG_TX_REPLY(priv
,
1344 "bogus sent(%d) and ack(%d) count\n",
1345 ba_resp
->txed
, ba_resp
->txed_2_done
);
1347 * set txed_2_done = txed,
1348 * so it won't impact rate scale
1350 ba_resp
->txed
= ba_resp
->txed_2_done
;
1353 priv
->tid_data
[sta_id
][tid
].next_reclaimed
= ba_resp_scd_ssn
;
1355 iwlagn_check_ratid_empty(priv
, sta_id
, tid
);
1358 skb_queue_walk(&reclaimed_skbs
, skb
) {
1359 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
1360 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1362 if (ieee80211_is_data_qos(hdr
->frame_control
))
1367 iwl_trans_free_tx_cmd(priv
->trans
, info
->driver_data
[1]);
1369 memset(&info
->status
, 0, sizeof(info
->status
));
1370 /* Packet was transmitted successfully, failures come as single
1371 * frames because before failing a frame the firmware transmits
1372 * it without aggregation at least once.
1374 info
->flags
|= IEEE80211_TX_STAT_ACK
;
1377 /* this is the first skb we deliver in this batch */
1378 /* put the rate scaling data there */
1379 info
= IEEE80211_SKB_CB(skb
);
1380 memset(&info
->status
, 0, sizeof(info
->status
));
1381 info
->flags
|= IEEE80211_TX_STAT_AMPDU
;
1382 info
->status
.ampdu_ack_len
= ba_resp
->txed_2_done
;
1383 info
->status
.ampdu_len
= ba_resp
->txed
;
1384 iwlagn_hwrate_to_tx_control(priv
, agg
->rate_n_flags
,
1389 spin_unlock_bh(&priv
->sta_lock
);
1391 while (!skb_queue_empty(&reclaimed_skbs
)) {
1392 skb
= __skb_dequeue(&reclaimed_skbs
);
1393 ieee80211_tx_status(priv
->hw
, skb
);