aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/mvm/tx.c
diff options
context:
space:
mode:
authorJohannes Berg <johannes.berg@intel.com>2013-01-24 08:25:36 -0500
committerJohannes Berg <johannes.berg@intel.com>2013-02-01 05:27:15 -0500
commit8ca151b568b67a7b72dcfc6ee6ea7c107ddd795c (patch)
treedac0236038f3791140e9f864c5db2be873c568f0 /drivers/net/wireless/iwlwifi/mvm/tx.c
parentb1e1adfa7d30cd0e8ad9a5c6a89e8c45ebe084f4 (diff)
iwlwifi: add the MVM driver
Newer firmware revisions have a completely new firmware API. This is the new driver for this new API. I've listed the people who directly contributed code, but many others from various teams have contributed in other ways. Cc: Alexander Bondar <alexander.bondar@intel.com> Cc: Amit Beka <amit.beka@intel.com> Cc: Amnon Paz <amnonx.paz@intel.com> Cc: Assaf Krauss <assaf.krauss@intel.com> Cc: David Spinadel <david.spinadel@intel.com> Cc: Dor Shaish <dor.shaish@intel.com> Cc: Emmanuel Grumbach <emmanuel.grumbach@intel.com> Cc: Eytan Lifshitz <eytan.lifshitz@intel.com> Cc: Ilan Peer <ilan.peer@intel.com> Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Diffstat (limited to 'drivers/net/wireless/iwlwifi/mvm/tx.c')
-rw-r--r--drivers/net/wireless/iwlwifi/mvm/tx.c916
1 files changed, 916 insertions, 0 deletions
diff --git a/drivers/net/wireless/iwlwifi/mvm/tx.c b/drivers/net/wireless/iwlwifi/mvm/tx.c
new file mode 100644
index 000000000000..cada8efe0cca
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/mvm/tx.c
@@ -0,0 +1,916 @@
1/******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22 * USA
23 *
24 * The full GNU General Public License is included in this distribution
25 * in the file called LICENSE.GPL.
26 *
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30 *
31 * BSD LICENSE
32 *
33 * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 *
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
45 * distribution.
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *
62 *****************************************************************************/
63#include <linux/ieee80211.h>
64#include <linux/etherdevice.h>
65
66#include "iwl-trans.h"
67#include "iwl-eeprom-parse.h"
68#include "mvm.h"
69#include "sta.h"
70
71/*
72 * Sets most of the Tx cmd's fields
73 */
74static void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb,
75 struct iwl_tx_cmd *tx_cmd,
76 struct ieee80211_tx_info *info, u8 sta_id)
77{
78 struct ieee80211_hdr *hdr = (void *)skb->data;
79 __le16 fc = hdr->frame_control;
80 u32 tx_flags = le32_to_cpu(tx_cmd->tx_flags);
81 u32 len = skb->len + FCS_LEN;
82
83 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
84 tx_flags |= TX_CMD_FLG_ACK;
85 else
86 tx_flags &= ~TX_CMD_FLG_ACK;
87
88 if (ieee80211_is_probe_resp(fc))
89 tx_flags |= TX_CMD_FLG_TSF;
90 else if (ieee80211_is_back_req(fc))
91 tx_flags |= TX_CMD_FLG_ACK | TX_CMD_FLG_BAR;
92
93 /* High prio packet (wrt. BT coex) if it is EAPOL, MCAST or MGMT */
94 if (info->band == IEEE80211_BAND_2GHZ &&
95 (skb->protocol == cpu_to_be16(ETH_P_PAE) ||
96 is_multicast_ether_addr(hdr->addr1) ||
97 ieee80211_is_back_req(fc) ||
98 ieee80211_is_mgmt(fc)))
99 tx_flags |= TX_CMD_FLG_BT_DIS;
100
101 if (ieee80211_has_morefrags(fc))
102 tx_flags |= TX_CMD_FLG_MORE_FRAG;
103
104 if (ieee80211_is_data_qos(fc)) {
105 u8 *qc = ieee80211_get_qos_ctl(hdr);
106 tx_cmd->tid_tspec = qc[0] & 0xf;
107 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
108 } else {
109 tx_cmd->tid_tspec = IWL_TID_NON_QOS;
110 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
111 tx_flags |= TX_CMD_FLG_SEQ_CTL;
112 else
113 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
114 }
115
116 if (ieee80211_is_mgmt(fc)) {
117 if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
118 tx_cmd->pm_frame_timeout = cpu_to_le16(3);
119 else
120 tx_cmd->pm_frame_timeout = cpu_to_le16(2);
121
122 /* The spec allows Action frames in A-MPDU, we don't support
123 * it
124 */
125 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_AMPDU);
126 } else {
127 tx_cmd->pm_frame_timeout = 0;
128 }
129
130 if (info->flags & IEEE80211_TX_CTL_AMPDU)
131 tx_flags |= TX_CMD_FLG_PROT_REQUIRE;
132
133 if (ieee80211_is_data(fc) && len > mvm->rts_threshold &&
134 !is_multicast_ether_addr(ieee80211_get_DA(hdr)))
135 tx_flags |= TX_CMD_FLG_PROT_REQUIRE;
136
137 tx_cmd->driver_txop = 0;
138 tx_cmd->tx_flags = cpu_to_le32(tx_flags);
139 /* Total # bytes to be transmitted */
140 tx_cmd->len = cpu_to_le16((u16)skb->len);
141 tx_cmd->next_frame_len = 0;
142 tx_cmd->life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
143 tx_cmd->sta_id = sta_id;
144}
145
146/*
147 * Sets the fields in the Tx cmd that are rate related
148 */
149static void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm,
150 struct iwl_tx_cmd *tx_cmd,
151 struct ieee80211_tx_info *info,
152 struct ieee80211_sta *sta,
153 __le16 fc)
154{
155 u32 rate_flags;
156 int rate_idx;
157 u8 rate_plcp;
158
159 /* Set retry limit on RTS packets */
160 tx_cmd->rts_retry_limit = IWL_RTS_DFAULT_RETRY_LIMIT;
161
162 /* Set retry limit on DATA packets and Probe Responses*/
163 if (ieee80211_is_probe_resp(fc)) {
164 tx_cmd->data_retry_limit = IWL_MGMT_DFAULT_RETRY_LIMIT;
165 tx_cmd->rts_retry_limit =
166 min(tx_cmd->data_retry_limit, tx_cmd->rts_retry_limit);
167 } else if (ieee80211_is_back_req(fc)) {
168 tx_cmd->data_retry_limit = IWL_BAR_DFAULT_RETRY_LIMIT;
169 } else {
170 tx_cmd->data_retry_limit = IWL_DEFAULT_TX_RETRY;
171 }
172
173 /*
174 * for data packets, rate info comes from the table inside he fw. This
175 * table is controlled by LINK_QUALITY commands
176 */
177
178 if (ieee80211_is_data(fc)) {
179 tx_cmd->initial_rate_index = 0;
180 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_STA_RATE);
181 return;
182 } else if (ieee80211_is_back_req(fc)) {
183 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_STA_RATE);
184 }
185
186 /* HT rate doesn't make sense for a non data frame */
187 WARN_ONCE(info->control.rates[0].flags & IEEE80211_TX_RC_MCS,
188 "Got an HT rate for a non data frame 0x%x\n",
189 info->control.rates[0].flags);
190
191 rate_idx = info->control.rates[0].idx;
192 /* if the rate isn't a well known legacy rate, take the lowest one */
193 if (rate_idx < 0 || rate_idx > IWL_RATE_COUNT_LEGACY)
194 rate_idx = rate_lowest_index(
195 &mvm->nvm_data->bands[info->band], sta);
196
197 /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
198 if (info->band == IEEE80211_BAND_5GHZ)
199 rate_idx += IWL_FIRST_OFDM_RATE;
200
201 /* For 2.4 GHZ band, check that there is no need to remap */
202 BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0);
203
204 /* Get PLCP rate for tx_cmd->rate_n_flags */
205 rate_plcp = iwl_mvm_mac80211_idx_to_hwrate(rate_idx);
206
207 mvm->mgmt_last_antenna_idx =
208 iwl_mvm_next_antenna(mvm, mvm->nvm_data->valid_tx_ant,
209 mvm->mgmt_last_antenna_idx);
210 rate_flags = BIT(mvm->mgmt_last_antenna_idx) << RATE_MCS_ANT_POS;
211
212 /* Set CCK flag as needed */
213 if ((rate_idx >= IWL_FIRST_CCK_RATE) && (rate_idx <= IWL_LAST_CCK_RATE))
214 rate_flags |= RATE_MCS_CCK_MSK;
215
216 /* Set the rate in the TX cmd */
217 tx_cmd->rate_n_flags = cpu_to_le32((u32)rate_plcp | rate_flags);
218}
219
220/*
221 * Sets the fields in the Tx cmd that are crypto related
222 */
223static void iwl_mvm_set_tx_cmd_crypto(struct iwl_mvm *mvm,
224 struct ieee80211_tx_info *info,
225 struct iwl_tx_cmd *tx_cmd,
226 struct sk_buff *skb_frag)
227{
228 struct ieee80211_key_conf *keyconf = info->control.hw_key;
229
230 switch (keyconf->cipher) {
231 case WLAN_CIPHER_SUITE_CCMP:
232 tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
233 memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
234 if (info->flags & IEEE80211_TX_CTL_AMPDU)
235 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_CCMP_AGG);
236 break;
237
238 case WLAN_CIPHER_SUITE_TKIP:
239 tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
240 ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
241 break;
242
243 case WLAN_CIPHER_SUITE_WEP104:
244 tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
245 /* fall through */
246 case WLAN_CIPHER_SUITE_WEP40:
247 tx_cmd->sec_ctl |= TX_CMD_SEC_WEP |
248 ((keyconf->keyidx << TX_CMD_SEC_WEP_KEY_IDX_POS) &
249 TX_CMD_SEC_WEP_KEY_IDX_MSK);
250
251 memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
252 break;
253 default:
254 IWL_ERR(mvm, "Unknown encode cipher %x\n", keyconf->cipher);
255 break;
256 }
257}
258
259/*
260 * Allocates and sets the Tx cmd the driver data pointers in the skb
261 */
262static struct iwl_device_cmd *
263iwl_mvm_set_tx_params(struct iwl_mvm *mvm, struct sk_buff *skb,
264 struct ieee80211_sta *sta, u8 sta_id)
265{
266 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
267 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
268 struct iwl_device_cmd *dev_cmd;
269 struct iwl_tx_cmd *tx_cmd;
270
271 dev_cmd = iwl_trans_alloc_tx_cmd(mvm->trans);
272
273 if (unlikely(!dev_cmd))
274 return NULL;
275
276 memset(dev_cmd, 0, sizeof(*dev_cmd));
277 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
278
279 if (info->control.hw_key)
280 iwl_mvm_set_tx_cmd_crypto(mvm, info, tx_cmd, skb);
281
282 iwl_mvm_set_tx_cmd(mvm, skb, tx_cmd, info, sta_id);
283
284 iwl_mvm_set_tx_cmd_rate(mvm, tx_cmd, info, sta, hdr->frame_control);
285
286 memset(&info->status, 0, sizeof(info->status));
287
288 info->driver_data[0] = NULL;
289 info->driver_data[1] = dev_cmd;
290
291 return dev_cmd;
292}
293
294int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb)
295{
296 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
297 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
298 struct iwl_device_cmd *dev_cmd;
299 struct iwl_tx_cmd *tx_cmd;
300 u8 sta_id;
301
302 if (WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_AMPDU))
303 return -1;
304
305 if (WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&
306 (!info->control.vif ||
307 info->hw_queue != info->control.vif->cab_queue)))
308 return -1;
309
310 /*
311 * If the interface on which frame is sent is the P2P_DEVICE
312 * or an AP/GO interface use the broadcast station associated
313 * with it; otherwise use the AUX station.
314 */
315 if (info->control.vif &&
316 (info->control.vif->type == NL80211_IFTYPE_P2P_DEVICE ||
317 info->control.vif->type == NL80211_IFTYPE_AP)) {
318 struct iwl_mvm_vif *mvmvif =
319 iwl_mvm_vif_from_mac80211(info->control.vif);
320 sta_id = mvmvif->bcast_sta.sta_id;
321 } else {
322 sta_id = mvm->aux_sta.sta_id;
323 }
324
325 IWL_DEBUG_TX(mvm, "station Id %d, queue=%d\n", sta_id, info->hw_queue);
326
327 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, NULL, sta_id);
328 if (!dev_cmd)
329 return -1;
330
331 /* From now on, we cannot access info->control */
332 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
333
334 /* Copy MAC header from skb into command buffer */
335 memcpy(tx_cmd->hdr, hdr, ieee80211_hdrlen(hdr->frame_control));
336
337 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, info->hw_queue)) {
338 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
339 return -1;
340 }
341
342 return 0;
343}
344
345/*
346 * Sets the fields in the Tx cmd that are crypto related
347 */
348int iwl_mvm_tx_skb(struct iwl_mvm *mvm, struct sk_buff *skb,
349 struct ieee80211_sta *sta)
350{
351 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
352 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
353 struct iwl_mvm_sta *mvmsta;
354 struct iwl_device_cmd *dev_cmd;
355 struct iwl_tx_cmd *tx_cmd;
356 __le16 fc;
357 u16 seq_number = 0;
358 u8 tid = IWL_MAX_TID_COUNT;
359 u8 txq_id = info->hw_queue;
360 bool is_data_qos = false, is_ampdu = false;
361
362 mvmsta = (void *)sta->drv_priv;
363 fc = hdr->frame_control;
364
365 if (WARN_ON_ONCE(!mvmsta))
366 return -1;
367
368 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_INVALID_STATION))
369 return -1;
370
371 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, sta, mvmsta->sta_id);
372 if (!dev_cmd)
373 goto drop;
374
375 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
376 /* From now on, we cannot access info->control */
377
378 spin_lock(&mvmsta->lock);
379
380 if (ieee80211_is_data_qos(fc) && !ieee80211_is_qos_nullfunc(fc)) {
381 u8 *qc = NULL;
382 qc = ieee80211_get_qos_ctl(hdr);
383 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
384 if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
385 goto drop_unlock_sta;
386
387 seq_number = mvmsta->tid_data[tid].seq_number;
388 seq_number &= IEEE80211_SCTL_SEQ;
389 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
390 hdr->seq_ctrl |= cpu_to_le16(seq_number);
391 seq_number += 0x10;
392 is_data_qos = true;
393 is_ampdu = info->flags & IEEE80211_TX_CTL_AMPDU;
394 }
395
396 /* Copy MAC header from skb into command buffer */
397 memcpy(tx_cmd->hdr, hdr, ieee80211_hdrlen(fc));
398
399 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
400
401 if (is_ampdu) {
402 if (WARN_ON_ONCE(mvmsta->tid_data[tid].state != IWL_AGG_ON))
403 goto drop_unlock_sta;
404 txq_id = mvmsta->tid_data[tid].txq_id;
405 }
406
407 IWL_DEBUG_TX(mvm, "TX to [%d|%d] Q:%d - seq: 0x%x\n", mvmsta->sta_id,
408 tid, txq_id, seq_number);
409
410 /* NOTE: aggregation will need changes here (for txq id) */
411 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, txq_id))
412 goto drop_unlock_sta;
413
414 if (is_data_qos && !ieee80211_has_morefrags(fc))
415 mvmsta->tid_data[tid].seq_number = seq_number;
416
417 spin_unlock(&mvmsta->lock);
418
419 if (mvmsta->vif->type == NL80211_IFTYPE_AP &&
420 txq_id < IWL_FIRST_AMPDU_QUEUE)
421 atomic_inc(&mvmsta->pending_frames);
422
423 return 0;
424
425drop_unlock_sta:
426 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
427 spin_unlock(&mvmsta->lock);
428drop:
429 return -1;
430}
431
432static void iwl_mvm_check_ratid_empty(struct iwl_mvm *mvm,
433 struct ieee80211_sta *sta, u8 tid)
434{
435 struct iwl_mvm_sta *mvmsta = (void *)sta->drv_priv;
436 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
437 struct ieee80211_vif *vif = mvmsta->vif;
438
439 lockdep_assert_held(&mvmsta->lock);
440
441 if (tid_data->ssn != tid_data->next_reclaimed)
442 return;
443
444 switch (tid_data->state) {
445 case IWL_EMPTYING_HW_QUEUE_ADDBA:
446 IWL_DEBUG_TX_QUEUES(mvm,
447 "Can continue addBA flow ssn = next_recl = %d\n",
448 tid_data->next_reclaimed);
449 tid_data->state = IWL_AGG_STARTING;
450 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
451 break;
452
453 case IWL_EMPTYING_HW_QUEUE_DELBA:
454 IWL_DEBUG_TX_QUEUES(mvm,
455 "Can continue DELBA flow ssn = next_recl = %d\n",
456 tid_data->next_reclaimed);
457 iwl_trans_txq_disable(mvm->trans, tid_data->txq_id);
458 tid_data->state = IWL_AGG_OFF;
459 /*
460 * we can't hold the mutex - but since we are after a sequence
461 * point (call to iwl_trans_txq_disable), so we don't even need
462 * a memory barrier.
463 */
464 mvm->queue_to_mac80211[tid_data->txq_id] =
465 IWL_INVALID_MAC80211_QUEUE;
466 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
467 break;
468
469 default:
470 break;
471 }
472}
473
474#ifdef CONFIG_IWLWIFI_DEBUG
475const char *iwl_mvm_get_tx_fail_reason(u32 status)
476{
477#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
478#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
479
480 switch (status & TX_STATUS_MSK) {
481 case TX_STATUS_SUCCESS:
482 return "SUCCESS";
483 TX_STATUS_POSTPONE(DELAY);
484 TX_STATUS_POSTPONE(FEW_BYTES);
485 TX_STATUS_POSTPONE(BT_PRIO);
486 TX_STATUS_POSTPONE(QUIET_PERIOD);
487 TX_STATUS_POSTPONE(CALC_TTAK);
488 TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
489 TX_STATUS_FAIL(SHORT_LIMIT);
490 TX_STATUS_FAIL(LONG_LIMIT);
491 TX_STATUS_FAIL(UNDERRUN);
492 TX_STATUS_FAIL(DRAIN_FLOW);
493 TX_STATUS_FAIL(RFKILL_FLUSH);
494 TX_STATUS_FAIL(LIFE_EXPIRE);
495 TX_STATUS_FAIL(DEST_PS);
496 TX_STATUS_FAIL(HOST_ABORTED);
497 TX_STATUS_FAIL(BT_RETRY);
498 TX_STATUS_FAIL(STA_INVALID);
499 TX_STATUS_FAIL(FRAG_DROPPED);
500 TX_STATUS_FAIL(TID_DISABLE);
501 TX_STATUS_FAIL(FIFO_FLUSHED);
502 TX_STATUS_FAIL(SMALL_CF_POLL);
503 TX_STATUS_FAIL(FW_DROP);
504 TX_STATUS_FAIL(STA_COLOR_MISMATCH);
505 }
506
507 return "UNKNOWN";
508
509#undef TX_STATUS_FAIL
510#undef TX_STATUS_POSTPONE
511}
512#endif /* CONFIG_IWLWIFI_DEBUG */
513
514/**
515 * translate ucode response to mac80211 tx status control values
516 */
517static void iwl_mvm_hwrate_to_tx_control(u32 rate_n_flags,
518 struct ieee80211_tx_info *info)
519{
520 struct ieee80211_tx_rate *r = &info->status.rates[0];
521
522 info->status.antenna =
523 ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
524 if (rate_n_flags & RATE_HT_MCS_GF_MSK)
525 r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
526 switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) {
527 case RATE_MCS_CHAN_WIDTH_20:
528 break;
529 case RATE_MCS_CHAN_WIDTH_40:
530 r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
531 break;
532 case RATE_MCS_CHAN_WIDTH_80:
533 r->flags |= IEEE80211_TX_RC_80_MHZ_WIDTH;
534 break;
535 case RATE_MCS_CHAN_WIDTH_160:
536 r->flags |= IEEE80211_TX_RC_160_MHZ_WIDTH;
537 break;
538 }
539 if (rate_n_flags & RATE_MCS_SGI_MSK)
540 r->flags |= IEEE80211_TX_RC_SHORT_GI;
541 if (rate_n_flags & RATE_MCS_HT_MSK) {
542 r->flags |= IEEE80211_TX_RC_MCS;
543 r->idx = rate_n_flags & RATE_HT_MCS_INDEX_MSK;
544 } else if (rate_n_flags & RATE_MCS_VHT_MSK) {
545 ieee80211_rate_set_vht(
546 r, rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK,
547 ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >>
548 RATE_VHT_MCS_NSS_POS) + 1);
549 r->flags |= IEEE80211_TX_RC_VHT_MCS;
550 } else {
551 r->idx = iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags,
552 info->band);
553 }
554}
555
556static void iwl_mvm_rx_tx_cmd_single(struct iwl_mvm *mvm,
557 struct iwl_rx_packet *pkt)
558{
559 struct ieee80211_sta *sta;
560 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
561 int txq_id = SEQ_TO_QUEUE(sequence);
562 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
563 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
564 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
565 u32 status = le16_to_cpu(tx_resp->status.status);
566 u16 ssn = iwl_mvm_get_scd_ssn(tx_resp);
567 struct iwl_mvm_sta *mvmsta;
568 struct sk_buff_head skbs;
569 u8 skb_freed = 0;
570 u16 next_reclaimed, seq_ctl;
571
572 __skb_queue_head_init(&skbs);
573
574 seq_ctl = le16_to_cpu(tx_resp->seq_ctl);
575
576 /* we can free until ssn % q.n_bd not inclusive */
577 iwl_trans_reclaim(mvm->trans, txq_id, ssn, &skbs);
578
579 while (!skb_queue_empty(&skbs)) {
580 struct sk_buff *skb = __skb_dequeue(&skbs);
581 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
582
583 skb_freed++;
584
585 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
586
587 memset(&info->status, 0, sizeof(info->status));
588
589 info->flags &= ~IEEE80211_TX_CTL_AMPDU;
590
591 /* inform mac80211 about what happened with the frame */
592 switch (status & TX_STATUS_MSK) {
593 case TX_STATUS_SUCCESS:
594 case TX_STATUS_DIRECT_DONE:
595 info->flags |= IEEE80211_TX_STAT_ACK;
596 break;
597 case TX_STATUS_FAIL_DEST_PS:
598 info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
599 break;
600 default:
601 break;
602 }
603
604 info->status.rates[0].count = tx_resp->failure_frame + 1;
605 iwl_mvm_hwrate_to_tx_control(le32_to_cpu(tx_resp->initial_rate),
606 info);
607
608 /* Single frame failure in an AMPDU queue => send BAR */
609 if (txq_id >= IWL_FIRST_AMPDU_QUEUE &&
610 !(info->flags & IEEE80211_TX_STAT_ACK)) {
611 /* there must be only one skb in the skb_list */
612 WARN_ON_ONCE(skb_freed > 1 ||
613 !skb_queue_empty(&skbs));
614 info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
615 }
616
617 /* W/A FW bug: seq_ctl is wrong when the queue is flushed */
618 if (status == TX_STATUS_FAIL_FIFO_FLUSHED) {
619 struct ieee80211_hdr *hdr = (void *)skb->data;
620 seq_ctl = le16_to_cpu(hdr->seq_ctrl);
621 }
622
623 ieee80211_tx_status(mvm->hw, skb);
624 }
625
626 if (txq_id >= IWL_FIRST_AMPDU_QUEUE) {
627 /* If this is an aggregation queue, we use the ssn since:
628 * ssn = wifi seq_num % 256.
629 * The seq_ctl is the sequence control of the packet to which
630 * this Tx response relates. But if there is a hole in the
631 * bitmap of the BA we received, this Tx response may allow to
632 * reclaim the hole and all the subsequent packets that were
633 * already acked. In that case, seq_ctl != ssn, and the next
634 * packet to be reclaimed will be ssn and not seq_ctl. In that
635 * case, several packets will be reclaimed even if
636 * frame_count = 1.
637 *
638 * The ssn is the index (% 256) of the latest packet that has
639 * treated (acked / dropped) + 1.
640 */
641 next_reclaimed = ssn;
642 } else {
643 /* The next packet to be reclaimed is the one after this one */
644 next_reclaimed = SEQ_TO_SN(seq_ctl + 0x10);
645 }
646
647 IWL_DEBUG_TX_REPLY(mvm,
648 "TXQ %d status %s (0x%08x)\n\t\t\t\tinitial_rate 0x%x "
649 "retries %d, idx=%d ssn=%d next_reclaimed=0x%x seq_ctl=0x%x\n",
650 txq_id, iwl_mvm_get_tx_fail_reason(status),
651 status, le32_to_cpu(tx_resp->initial_rate),
652 tx_resp->failure_frame, SEQ_TO_INDEX(sequence),
653 ssn, next_reclaimed, seq_ctl);
654
655 rcu_read_lock();
656
657 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
658
659 if (!IS_ERR_OR_NULL(sta)) {
660 mvmsta = (void *)sta->drv_priv;
661
662 if (tid != IWL_TID_NON_QOS) {
663 struct iwl_mvm_tid_data *tid_data =
664 &mvmsta->tid_data[tid];
665
666 spin_lock(&mvmsta->lock);
667 tid_data->next_reclaimed = next_reclaimed;
668 IWL_DEBUG_TX_REPLY(mvm, "Next reclaimed packet:%d\n",
669 next_reclaimed);
670 iwl_mvm_check_ratid_empty(mvm, sta, tid);
671 spin_unlock(&mvmsta->lock);
672 }
673
674#ifdef CONFIG_PM_SLEEP
675 mvmsta->last_seq_ctl = seq_ctl;
676#endif
677 } else {
678 sta = NULL;
679 mvmsta = NULL;
680 }
681
682 /*
683 * If the txq is not an AMPDU queue, there is no chance we freed
684 * several skbs. Check that out...
685 * If there are no pending frames for this STA, notify mac80211 that
686 * this station can go to sleep in its STA table.
687 */
688 if (txq_id < IWL_FIRST_AMPDU_QUEUE && mvmsta &&
689 !WARN_ON(skb_freed > 1) &&
690 mvmsta->vif->type == NL80211_IFTYPE_AP &&
691 atomic_sub_and_test(skb_freed, &mvmsta->pending_frames)) {
692 ieee80211_sta_block_awake(mvm->hw, sta, false);
693 set_bit(sta_id, mvm->sta_drained);
694 schedule_work(&mvm->sta_drained_wk);
695 }
696
697 rcu_read_unlock();
698}
699
700#ifdef CONFIG_IWLWIFI_DEBUG
701#define AGG_TX_STATE_(x) case AGG_TX_STATE_ ## x: return #x
702static const char *iwl_get_agg_tx_status(u16 status)
703{
704 switch (status & AGG_TX_STATE_STATUS_MSK) {
705 AGG_TX_STATE_(TRANSMITTED);
706 AGG_TX_STATE_(UNDERRUN);
707 AGG_TX_STATE_(BT_PRIO);
708 AGG_TX_STATE_(FEW_BYTES);
709 AGG_TX_STATE_(ABORT);
710 AGG_TX_STATE_(LAST_SENT_TTL);
711 AGG_TX_STATE_(LAST_SENT_TRY_CNT);
712 AGG_TX_STATE_(LAST_SENT_BT_KILL);
713 AGG_TX_STATE_(SCD_QUERY);
714 AGG_TX_STATE_(TEST_BAD_CRC32);
715 AGG_TX_STATE_(RESPONSE);
716 AGG_TX_STATE_(DUMP_TX);
717 AGG_TX_STATE_(DELAY_TX);
718 }
719
720 return "UNKNOWN";
721}
722
723static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
724 struct iwl_rx_packet *pkt)
725{
726 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
727 struct agg_tx_status *frame_status = &tx_resp->status;
728 int i;
729
730 for (i = 0; i < tx_resp->frame_count; i++) {
731 u16 fstatus = le16_to_cpu(frame_status[i].status);
732
733 IWL_DEBUG_TX_REPLY(mvm,
734 "status %s (0x%04x), try-count (%d) seq (0x%x)\n",
735 iwl_get_agg_tx_status(fstatus),
736 fstatus & AGG_TX_STATE_STATUS_MSK,
737 (fstatus & AGG_TX_STATE_TRY_CNT_MSK) >>
738 AGG_TX_STATE_TRY_CNT_POS,
739 le16_to_cpu(frame_status[i].sequence));
740 }
741}
742#else
743static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
744 struct iwl_rx_packet *pkt)
745{}
746#endif /* CONFIG_IWLWIFI_DEBUG */
747
748static void iwl_mvm_rx_tx_cmd_agg(struct iwl_mvm *mvm,
749 struct iwl_rx_packet *pkt)
750{
751 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
752 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
753 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
754 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
755 struct ieee80211_sta *sta;
756
757 if (WARN_ON_ONCE(SEQ_TO_QUEUE(sequence) < IWL_FIRST_AMPDU_QUEUE))
758 return;
759
760 if (WARN_ON_ONCE(tid == IWL_TID_NON_QOS))
761 return;
762
763 iwl_mvm_rx_tx_cmd_agg_dbg(mvm, pkt);
764
765 rcu_read_lock();
766
767 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
768
769 if (!WARN_ON_ONCE(IS_ERR_OR_NULL(sta))) {
770 struct iwl_mvm_sta *mvmsta = (void *)sta->drv_priv;
771 mvmsta->tid_data[tid].rate_n_flags =
772 le32_to_cpu(tx_resp->initial_rate);
773 }
774
775 rcu_read_unlock();
776}
777
778int iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb,
779 struct iwl_device_cmd *cmd)
780{
781 struct iwl_rx_packet *pkt = rxb_addr(rxb);
782 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
783
784 if (tx_resp->frame_count == 1)
785 iwl_mvm_rx_tx_cmd_single(mvm, pkt);
786 else
787 iwl_mvm_rx_tx_cmd_agg(mvm, pkt);
788
789 return 0;
790}
791
792int iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb,
793 struct iwl_device_cmd *cmd)
794{
795 struct iwl_rx_packet *pkt = rxb_addr(rxb);
796 struct iwl_mvm_ba_notif *ba_notif = (void *)pkt->data;
797 struct sk_buff_head reclaimed_skbs;
798 struct iwl_mvm_tid_data *tid_data;
799 struct ieee80211_tx_info *info;
800 struct ieee80211_sta *sta;
801 struct iwl_mvm_sta *mvmsta;
802 struct ieee80211_hdr *hdr;
803 struct sk_buff *skb;
804 int sta_id, tid, freed;
805
806 /* "flow" corresponds to Tx queue */
807 u16 scd_flow = le16_to_cpu(ba_notif->scd_flow);
808
809 /* "ssn" is start of block-ack Tx window, corresponds to index
810 * (in Tx queue's circular buffer) of first TFD/frame in window */
811 u16 ba_resp_scd_ssn = le16_to_cpu(ba_notif->scd_ssn);
812
813 sta_id = ba_notif->sta_id;
814 tid = ba_notif->tid;
815
816 rcu_read_lock();
817
818 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
819
820 /* Reclaiming frames for a station that has been deleted ? */
821 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta))) {
822 rcu_read_unlock();
823 return 0;
824 }
825
826 mvmsta = (void *)sta->drv_priv;
827 tid_data = &mvmsta->tid_data[tid];
828
829 if (WARN_ONCE(tid_data->txq_id != scd_flow, "Q %d, tid %d, flow %d",
830 tid_data->txq_id, tid, scd_flow)) {
831 rcu_read_unlock();
832 return 0;
833 }
834
835 spin_lock(&mvmsta->lock);
836
837 __skb_queue_head_init(&reclaimed_skbs);
838
839 /*
840 * Release all TFDs before the SSN, i.e. all TFDs in front of
841 * block-ack window (we assume that they've been successfully
842 * transmitted ... if not, it's too late anyway).
843 */
844 iwl_trans_reclaim(mvm->trans, scd_flow, ba_resp_scd_ssn,
845 &reclaimed_skbs);
846
847 IWL_DEBUG_TX_REPLY(mvm,
848 "BA_NOTIFICATION Received from %pM, sta_id = %d\n",
849 (u8 *)&ba_notif->sta_addr_lo32,
850 ba_notif->sta_id);
851 IWL_DEBUG_TX_REPLY(mvm,
852 "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = %d, scd_ssn = %d sent:%d, acked:%d\n",
853 ba_notif->tid, le16_to_cpu(ba_notif->seq_ctl),
854 (unsigned long long)le64_to_cpu(ba_notif->bitmap),
855 scd_flow, ba_resp_scd_ssn, ba_notif->txed,
856 ba_notif->txed_2_done);
857
858 tid_data->next_reclaimed = ba_resp_scd_ssn;
859
860 iwl_mvm_check_ratid_empty(mvm, sta, tid);
861
862 freed = 0;
863
864 skb_queue_walk(&reclaimed_skbs, skb) {
865 hdr = (struct ieee80211_hdr *)skb->data;
866
867 if (ieee80211_is_data_qos(hdr->frame_control))
868 freed++;
869 else
870 WARN_ON_ONCE(1);
871
872 info = IEEE80211_SKB_CB(skb);
873 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
874
875 if (freed == 1) {
876 /* this is the first skb we deliver in this batch */
877 /* put the rate scaling data there */
878 info = IEEE80211_SKB_CB(skb);
879 memset(&info->status, 0, sizeof(info->status));
880 info->flags |= IEEE80211_TX_STAT_ACK;
881 info->flags |= IEEE80211_TX_STAT_AMPDU;
882 info->status.ampdu_ack_len = ba_notif->txed_2_done;
883 info->status.ampdu_len = ba_notif->txed;
884 iwl_mvm_hwrate_to_tx_control(tid_data->rate_n_flags,
885 info);
886 }
887 }
888
889 spin_unlock(&mvmsta->lock);
890
891 rcu_read_unlock();
892
893 while (!skb_queue_empty(&reclaimed_skbs)) {
894 skb = __skb_dequeue(&reclaimed_skbs);
895 ieee80211_tx_status(mvm->hw, skb);
896 }
897
898 return 0;
899}
900
901int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk, bool sync)
902{
903 int ret;
904 struct iwl_tx_path_flush_cmd flush_cmd = {
905 .queues_ctl = cpu_to_le32(tfd_msk),
906 .flush_ctl = cpu_to_le16(DUMP_TX_FIFO_FLUSH),
907 };
908
909 u32 flags = sync ? CMD_SYNC : CMD_ASYNC;
910
911 ret = iwl_mvm_send_cmd_pdu(mvm, TXPATH_FLUSH, flags,
912 sizeof(flush_cmd), &flush_cmd);
913 if (ret)
914 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
915 return ret;
916}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-21 04:27:59 -0500