]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/wireless/intel/iwlwifi/mvm/tx.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ASoC: rockchip: add bindings for rk3368 i2s
[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / intel / iwlwifi / mvm / tx.c
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 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10 * Copyright(c) 2016 Intel Deutschland GmbH
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of version 2 of the GNU General Public License as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * USA
25 *
26 * The full GNU General Public License is included in this distribution
27 * in the file called COPYING.
28 *
29 * Contact Information:
30 * Intel Linux Wireless <linuxwifi@intel.com>
31 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
32 *
33 * BSD LICENSE
34 *
35 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
36 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
37 * All rights reserved.
38 *
39 * Redistribution and use in source and binary forms, with or without
40 * modification, are permitted provided that the following conditions
41 * are met:
42 *
43 * * Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * * Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in
47 * the documentation and/or other materials provided with the
48 * distribution.
49 * * Neither the name Intel Corporation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
54 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
55 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
56 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
57 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
58 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
59 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
60 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
61 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
62 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
63 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64 *
65 *****************************************************************************/
66 #include <linux/ieee80211.h>
67 #include <linux/etherdevice.h>
68 #include <linux/tcp.h>
69 #include <net/ip.h>
70 #include <net/ipv6.h>
71
72 #include "iwl-trans.h"
73 #include "iwl-eeprom-parse.h"
74 #include "mvm.h"
75 #include "sta.h"
76 #include "fw-dbg.h"
77
78 static void
79 iwl_mvm_bar_check_trigger(struct iwl_mvm *mvm, const u8 *addr,
80 u16 tid, u16 ssn)
81 {
82 struct iwl_fw_dbg_trigger_tlv *trig;
83 struct iwl_fw_dbg_trigger_ba *ba_trig;
84
85 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
86 return;
87
88 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
89 ba_trig = (void *)trig->data;
90
91 if (!iwl_fw_dbg_trigger_check_stop(mvm, NULL, trig))
92 return;
93
94 if (!(le16_to_cpu(ba_trig->tx_bar) & BIT(tid)))
95 return;
96
97 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
98 "BAR sent to %pM, tid %d, ssn %d",
99 addr, tid, ssn);
100 }
101
102 #define OPT_HDR(type, skb, off) \
103 (type *)(skb_network_header(skb) + (off))
104
105 static u16 iwl_mvm_tx_csum(struct iwl_mvm *mvm, struct sk_buff *skb,
106 struct ieee80211_hdr *hdr,
107 struct ieee80211_tx_info *info)
108 {
109 u16 offload_assist = 0;
110 #if IS_ENABLED(CONFIG_INET)
111 u16 mh_len = ieee80211_hdrlen(hdr->frame_control);
112 u8 protocol = 0;
113
114 /*
115 * Do not compute checksum if already computed or if transport will
116 * compute it
117 */
118 if (skb->ip_summed != CHECKSUM_PARTIAL || IWL_MVM_SW_TX_CSUM_OFFLOAD)
119 goto out;
120
121 /* We do not expect to be requested to csum stuff we do not support */
122 if (WARN_ONCE(!(mvm->hw->netdev_features & IWL_TX_CSUM_NETIF_FLAGS) ||
123 (skb->protocol != htons(ETH_P_IP) &&
124 skb->protocol != htons(ETH_P_IPV6)),
125 "No support for requested checksum\n")) {
126 skb_checksum_help(skb);
127 goto out;
128 }
129
130 if (skb->protocol == htons(ETH_P_IP)) {
131 protocol = ip_hdr(skb)->protocol;
132 } else {
133 #if IS_ENABLED(CONFIG_IPV6)
134 struct ipv6hdr *ipv6h =
135 (struct ipv6hdr *)skb_network_header(skb);
136 unsigned int off = sizeof(*ipv6h);
137
138 protocol = ipv6h->nexthdr;
139 while (protocol != NEXTHDR_NONE && ipv6_ext_hdr(protocol)) {
140 struct ipv6_opt_hdr *hp;
141
142 /* only supported extension headers */
143 if (protocol != NEXTHDR_ROUTING &&
144 protocol != NEXTHDR_HOP &&
145 protocol != NEXTHDR_DEST) {
146 skb_checksum_help(skb);
147 goto out;
148 }
149
150 hp = OPT_HDR(struct ipv6_opt_hdr, skb, off);
151 protocol = hp->nexthdr;
152 off += ipv6_optlen(hp);
153 }
154 /* if we get here - protocol now should be TCP/UDP */
155 #endif
156 }
157
158 if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP) {
159 WARN_ON_ONCE(1);
160 skb_checksum_help(skb);
161 goto out;
162 }
163
164 /* enable L4 csum */
165 offload_assist |= BIT(TX_CMD_OFFLD_L4_EN);
166
167 /*
168 * Set offset to IP header (snap).
169 * We don't support tunneling so no need to take care of inner header.
170 * Size is in words.
171 */
172 offload_assist |= (4 << TX_CMD_OFFLD_IP_HDR);
173
174 /* Do IPv4 csum for AMSDU only (no IP csum for Ipv6) */
175 if (skb->protocol == htons(ETH_P_IP) &&
176 (offload_assist & BIT(TX_CMD_OFFLD_AMSDU))) {
177 ip_hdr(skb)->check = 0;
178 offload_assist |= BIT(TX_CMD_OFFLD_L3_EN);
179 }
180
181 /* reset UDP/TCP header csum */
182 if (protocol == IPPROTO_TCP)
183 tcp_hdr(skb)->check = 0;
184 else
185 udp_hdr(skb)->check = 0;
186
187 /* mac header len should include IV, size is in words */
188 if (info->control.hw_key)
189 mh_len += info->control.hw_key->iv_len;
190 mh_len /= 2;
191 offload_assist |= mh_len << TX_CMD_OFFLD_MH_SIZE;
192
193 out:
194 #endif
195 return offload_assist;
196 }
197
198 /*
199 * Sets most of the Tx cmd's fields
200 */
201 void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb,
202 struct iwl_tx_cmd *tx_cmd,
203 struct ieee80211_tx_info *info, u8 sta_id)
204 {
205 struct ieee80211_hdr *hdr = (void *)skb->data;
206 __le16 fc = hdr->frame_control;
207 u32 tx_flags = le32_to_cpu(tx_cmd->tx_flags);
208 u32 len = skb->len + FCS_LEN;
209 u8 ac;
210
211 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
212 tx_flags |= TX_CMD_FLG_ACK;
213 else
214 tx_flags &= ~TX_CMD_FLG_ACK;
215
216 if (ieee80211_is_probe_resp(fc))
217 tx_flags |= TX_CMD_FLG_TSF;
218
219 if (ieee80211_has_morefrags(fc))
220 tx_flags |= TX_CMD_FLG_MORE_FRAG;
221
222 if (ieee80211_is_data_qos(fc)) {
223 u8 *qc = ieee80211_get_qos_ctl(hdr);
224 tx_cmd->tid_tspec = qc[0] & 0xf;
225 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
226 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
227 tx_cmd->offload_assist |=
228 cpu_to_le16(BIT(TX_CMD_OFFLD_AMSDU));
229 } else if (ieee80211_is_back_req(fc)) {
230 struct ieee80211_bar *bar = (void *)skb->data;
231 u16 control = le16_to_cpu(bar->control);
232 u16 ssn = le16_to_cpu(bar->start_seq_num);
233
234 tx_flags |= TX_CMD_FLG_ACK | TX_CMD_FLG_BAR;
235 tx_cmd->tid_tspec = (control &
236 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
237 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
238 WARN_ON_ONCE(tx_cmd->tid_tspec >= IWL_MAX_TID_COUNT);
239 iwl_mvm_bar_check_trigger(mvm, bar->ra, tx_cmd->tid_tspec,
240 ssn);
241 } else {
242 tx_cmd->tid_tspec = IWL_TID_NON_QOS;
243 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
244 tx_flags |= TX_CMD_FLG_SEQ_CTL;
245 else
246 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
247 }
248
249 /* Default to 0 (BE) when tid_spec is set to IWL_TID_NON_QOS */
250 if (tx_cmd->tid_tspec < IWL_MAX_TID_COUNT)
251 ac = tid_to_mac80211_ac[tx_cmd->tid_tspec];
252 else
253 ac = tid_to_mac80211_ac[0];
254
255 tx_flags |= iwl_mvm_bt_coex_tx_prio(mvm, hdr, info, ac) <<
256 TX_CMD_FLG_BT_PRIO_POS;
257
258 if (ieee80211_is_mgmt(fc)) {
259 if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
260 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_ASSOC);
261 else if (ieee80211_is_action(fc))
262 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_NONE);
263 else
264 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_MGMT);
265
266 /* The spec allows Action frames in A-MPDU, we don't support
267 * it
268 */
269 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_AMPDU);
270 } else if (info->control.flags & IEEE80211_TX_CTRL_PORT_CTRL_PROTO) {
271 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_MGMT);
272 } else {
273 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_NONE);
274 }
275
276 if (ieee80211_is_data(fc) && len > mvm->rts_threshold &&
277 !is_multicast_ether_addr(ieee80211_get_DA(hdr)))
278 tx_flags |= TX_CMD_FLG_PROT_REQUIRE;
279
280 if (fw_has_capa(&mvm->fw->ucode_capa,
281 IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT) &&
282 ieee80211_action_contains_tpc(skb))
283 tx_flags |= TX_CMD_FLG_WRITE_TX_POWER;
284
285 tx_cmd->tx_flags = cpu_to_le32(tx_flags);
286 /* Total # bytes to be transmitted - PCIe code will adjust for A-MSDU */
287 tx_cmd->len = cpu_to_le16((u16)skb->len);
288 tx_cmd->life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
289 tx_cmd->sta_id = sta_id;
290
291 /* padding is inserted later in transport */
292 if (ieee80211_hdrlen(fc) % 4 &&
293 !(tx_cmd->offload_assist & cpu_to_le16(BIT(TX_CMD_OFFLD_AMSDU))))
294 tx_cmd->offload_assist |= cpu_to_le16(BIT(TX_CMD_OFFLD_PAD));
295
296 tx_cmd->offload_assist |=
297 cpu_to_le16(iwl_mvm_tx_csum(mvm, skb, hdr, info));
298 }
299
300 static u32 iwl_mvm_get_tx_rate(struct iwl_mvm *mvm,
301 struct ieee80211_tx_info *info,
302 struct ieee80211_sta *sta)
303 {
304 int rate_idx;
305 u8 rate_plcp;
306 u32 rate_flags;
307
308 /* HT rate doesn't make sense for a non data frame */
309 WARN_ONCE(info->control.rates[0].flags & IEEE80211_TX_RC_MCS,
310 "Got an HT rate (flags:0x%x/mcs:%d) for a non data frame\n",
311 info->control.rates[0].flags,
312 info->control.rates[0].idx);
313
314 rate_idx = info->control.rates[0].idx;
315 /* if the rate isn't a well known legacy rate, take the lowest one */
316 if (rate_idx < 0 || rate_idx >= IWL_RATE_COUNT_LEGACY)
317 rate_idx = rate_lowest_index(
318 &mvm->nvm_data->bands[info->band], sta);
319
320 /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
321 if (info->band == NL80211_BAND_5GHZ)
322 rate_idx += IWL_FIRST_OFDM_RATE;
323
324 /* For 2.4 GHZ band, check that there is no need to remap */
325 BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0);
326
327 /* Get PLCP rate for tx_cmd->rate_n_flags */
328 rate_plcp = iwl_mvm_mac80211_idx_to_hwrate(rate_idx);
329
330 if (info->band == NL80211_BAND_2GHZ &&
331 !iwl_mvm_bt_coex_is_shared_ant_avail(mvm))
332 rate_flags = mvm->cfg->non_shared_ant << RATE_MCS_ANT_POS;
333 else
334 rate_flags =
335 BIT(mvm->mgmt_last_antenna_idx) << RATE_MCS_ANT_POS;
336
337 /* Set CCK flag as needed */
338 if ((rate_idx >= IWL_FIRST_CCK_RATE) && (rate_idx <= IWL_LAST_CCK_RATE))
339 rate_flags |= RATE_MCS_CCK_MSK;
340
341 return (u32)rate_plcp | rate_flags;
342 }
343
344 /*
345 * Sets the fields in the Tx cmd that are rate related
346 */
347 void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,
348 struct ieee80211_tx_info *info,
349 struct ieee80211_sta *sta, __le16 fc)
350 {
351 /* Set retry limit on RTS packets */
352 tx_cmd->rts_retry_limit = IWL_RTS_DFAULT_RETRY_LIMIT;
353
354 /* Set retry limit on DATA packets and Probe Responses*/
355 if (ieee80211_is_probe_resp(fc)) {
356 tx_cmd->data_retry_limit = IWL_MGMT_DFAULT_RETRY_LIMIT;
357 tx_cmd->rts_retry_limit =
358 min(tx_cmd->data_retry_limit, tx_cmd->rts_retry_limit);
359 } else if (ieee80211_is_back_req(fc)) {
360 tx_cmd->data_retry_limit = IWL_BAR_DFAULT_RETRY_LIMIT;
361 } else {
362 tx_cmd->data_retry_limit = IWL_DEFAULT_TX_RETRY;
363 }
364
365 /*
366 * for data packets, rate info comes from the table inside the fw. This
367 * table is controlled by LINK_QUALITY commands
368 */
369
370 if (ieee80211_is_data(fc) && sta) {
371 tx_cmd->initial_rate_index = 0;
372 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_STA_RATE);
373 return;
374 } else if (ieee80211_is_back_req(fc)) {
375 tx_cmd->tx_flags |=
376 cpu_to_le32(TX_CMD_FLG_ACK | TX_CMD_FLG_BAR);
377 }
378
379 mvm->mgmt_last_antenna_idx =
380 iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm),
381 mvm->mgmt_last_antenna_idx);
382
383 /* Set the rate in the TX cmd */
384 tx_cmd->rate_n_flags = cpu_to_le32(iwl_mvm_get_tx_rate(mvm, info, sta));
385 }
386
387 static inline void iwl_mvm_set_tx_cmd_pn(struct ieee80211_tx_info *info,
388 u8 *crypto_hdr)
389 {
390 struct ieee80211_key_conf *keyconf = info->control.hw_key;
391 u64 pn;
392
393 pn = atomic64_inc_return(&keyconf->tx_pn);
394 crypto_hdr[0] = pn;
395 crypto_hdr[2] = 0;
396 crypto_hdr[3] = 0x20 | (keyconf->keyidx << 6);
397 crypto_hdr[1] = pn >> 8;
398 crypto_hdr[4] = pn >> 16;
399 crypto_hdr[5] = pn >> 24;
400 crypto_hdr[6] = pn >> 32;
401 crypto_hdr[7] = pn >> 40;
402 }
403
404 /*
405 * Sets the fields in the Tx cmd that are crypto related
406 */
407 static void iwl_mvm_set_tx_cmd_crypto(struct iwl_mvm *mvm,
408 struct ieee80211_tx_info *info,
409 struct iwl_tx_cmd *tx_cmd,
410 struct sk_buff *skb_frag,
411 int hdrlen)
412 {
413 struct ieee80211_key_conf *keyconf = info->control.hw_key;
414 u8 *crypto_hdr = skb_frag->data + hdrlen;
415 u64 pn;
416
417 switch (keyconf->cipher) {
418 case WLAN_CIPHER_SUITE_CCMP:
419 case WLAN_CIPHER_SUITE_CCMP_256:
420 iwl_mvm_set_tx_cmd_ccmp(info, tx_cmd);
421 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
422 break;
423
424 case WLAN_CIPHER_SUITE_TKIP:
425 tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
426 pn = atomic64_inc_return(&keyconf->tx_pn);
427 ieee80211_tkip_add_iv(crypto_hdr, keyconf, pn);
428 ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
429 break;
430
431 case WLAN_CIPHER_SUITE_WEP104:
432 tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
433 /* fall through */
434 case WLAN_CIPHER_SUITE_WEP40:
435 tx_cmd->sec_ctl |= TX_CMD_SEC_WEP |
436 ((keyconf->keyidx << TX_CMD_SEC_WEP_KEY_IDX_POS) &
437 TX_CMD_SEC_WEP_KEY_IDX_MSK);
438
439 memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
440 break;
441 case WLAN_CIPHER_SUITE_GCMP:
442 case WLAN_CIPHER_SUITE_GCMP_256:
443 /* TODO: Taking the key from the table might introduce a race
444 * when PTK rekeying is done, having an old packets with a PN
445 * based on the old key but the message encrypted with a new
446 * one.
447 * Need to handle this.
448 */
449 tx_cmd->sec_ctl |= TX_CMD_SEC_GCMP | TX_CMD_SEC_KEY_FROM_TABLE;
450 tx_cmd->key[0] = keyconf->hw_key_idx;
451 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
452 break;
453 default:
454 tx_cmd->sec_ctl |= TX_CMD_SEC_EXT;
455 }
456 }
457
458 /*
459 * Allocates and sets the Tx cmd the driver data pointers in the skb
460 */
461 static struct iwl_device_cmd *
462 iwl_mvm_set_tx_params(struct iwl_mvm *mvm, struct sk_buff *skb,
463 struct ieee80211_tx_info *info, int hdrlen,
464 struct ieee80211_sta *sta, u8 sta_id)
465 {
466 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
467 struct iwl_device_cmd *dev_cmd;
468 struct iwl_tx_cmd *tx_cmd;
469
470 dev_cmd = iwl_trans_alloc_tx_cmd(mvm->trans);
471
472 if (unlikely(!dev_cmd))
473 return NULL;
474
475 memset(dev_cmd, 0, sizeof(*dev_cmd));
476 dev_cmd->hdr.cmd = TX_CMD;
477 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
478
479 if (info->control.hw_key)
480 iwl_mvm_set_tx_cmd_crypto(mvm, info, tx_cmd, skb, hdrlen);
481
482 iwl_mvm_set_tx_cmd(mvm, skb, tx_cmd, info, sta_id);
483
484 iwl_mvm_set_tx_cmd_rate(mvm, tx_cmd, info, sta, hdr->frame_control);
485
486 return dev_cmd;
487 }
488
489 static void iwl_mvm_skb_prepare_status(struct sk_buff *skb,
490 struct iwl_device_cmd *cmd)
491 {
492 struct ieee80211_tx_info *skb_info = IEEE80211_SKB_CB(skb);
493
494 memset(&skb_info->status, 0, sizeof(skb_info->status));
495 memset(skb_info->driver_data, 0, sizeof(skb_info->driver_data));
496
497 skb_info->driver_data[1] = cmd;
498 }
499
500 static int iwl_mvm_get_ctrl_vif_queue(struct iwl_mvm *mvm,
501 struct ieee80211_tx_info *info, __le16 fc)
502 {
503 if (!iwl_mvm_is_dqa_supported(mvm))
504 return info->hw_queue;
505
506 switch (info->control.vif->type) {
507 case NL80211_IFTYPE_AP:
508 /*
509 * Handle legacy hostapd as well, where station may be added
510 * only after assoc. Take care of the case where we send a
511 * deauth to a station that we don't have.
512 */
513 if (ieee80211_is_probe_resp(fc) || ieee80211_is_auth(fc) ||
514 ieee80211_is_deauth(fc))
515 return IWL_MVM_DQA_AP_PROBE_RESP_QUEUE;
516 if (info->hw_queue == info->control.vif->cab_queue)
517 return info->hw_queue;
518
519 WARN_ONCE(1, "fc=0x%02x", le16_to_cpu(fc));
520 return IWL_MVM_DQA_AP_PROBE_RESP_QUEUE;
521 case NL80211_IFTYPE_P2P_DEVICE:
522 if (ieee80211_is_mgmt(fc))
523 return IWL_MVM_DQA_P2P_DEVICE_QUEUE;
524 if (info->hw_queue == info->control.vif->cab_queue)
525 return info->hw_queue;
526
527 WARN_ON_ONCE(1);
528 return IWL_MVM_DQA_P2P_DEVICE_QUEUE;
529 default:
530 WARN_ONCE(1, "Not a ctrl vif, no available queue\n");
531 return -1;
532 }
533 }
534
535 int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb)
536 {
537 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
538 struct ieee80211_tx_info *skb_info = IEEE80211_SKB_CB(skb);
539 struct ieee80211_tx_info info;
540 struct iwl_device_cmd *dev_cmd;
541 struct iwl_tx_cmd *tx_cmd;
542 u8 sta_id;
543 int hdrlen = ieee80211_hdrlen(hdr->frame_control);
544 int queue;
545
546 /* IWL_MVM_OFFCHANNEL_QUEUE is used for ROC packets that can be used
547 * in 2 different types of vifs, P2P & STATION. P2P uses the offchannel
548 * queue. STATION (HS2.0) uses the auxiliary context of the FW,
549 * and hence needs to be sent on the aux queue
550 */
551 if (skb_info->hw_queue == IWL_MVM_OFFCHANNEL_QUEUE &&
552 skb_info->control.vif->type == NL80211_IFTYPE_STATION)
553 skb_info->hw_queue = mvm->aux_queue;
554
555 memcpy(&info, skb->cb, sizeof(info));
556
557 if (WARN_ON_ONCE(info.flags & IEEE80211_TX_CTL_AMPDU))
558 return -1;
559
560 if (WARN_ON_ONCE(info.flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&
561 (!info.control.vif ||
562 info.hw_queue != info.control.vif->cab_queue)))
563 return -1;
564
565 queue = info.hw_queue;
566
567 /*
568 * If the interface on which the frame is sent is the P2P_DEVICE
569 * or an AP/GO interface use the broadcast station associated
570 * with it; otherwise if the interface is a managed interface
571 * use the AP station associated with it for multicast traffic
572 * (this is not possible for unicast packets as a TLDS discovery
573 * response are sent without a station entry); otherwise use the
574 * AUX station.
575 * In DQA mode, if vif is of type STATION and frames are not multicast
576 * or offchannel, they should be sent from the BSS queue.
577 * For example, TDLS setup frames should be sent on this queue,
578 * as they go through the AP.
579 */
580 sta_id = mvm->aux_sta.sta_id;
581 if (info.control.vif) {
582 struct iwl_mvm_vif *mvmvif =
583 iwl_mvm_vif_from_mac80211(info.control.vif);
584
585 if (info.control.vif->type == NL80211_IFTYPE_P2P_DEVICE ||
586 info.control.vif->type == NL80211_IFTYPE_AP) {
587 sta_id = mvmvif->bcast_sta.sta_id;
588 queue = iwl_mvm_get_ctrl_vif_queue(mvm, &info,
589 hdr->frame_control);
590 if (queue < 0)
591 return -1;
592
593 } else if (info.control.vif->type == NL80211_IFTYPE_STATION &&
594 is_multicast_ether_addr(hdr->addr1)) {
595 u8 ap_sta_id = ACCESS_ONCE(mvmvif->ap_sta_id);
596
597 if (ap_sta_id != IWL_MVM_STATION_COUNT)
598 sta_id = ap_sta_id;
599 } else if (iwl_mvm_is_dqa_supported(mvm) &&
600 info.control.vif->type == NL80211_IFTYPE_STATION &&
601 queue != mvm->aux_queue) {
602 queue = IWL_MVM_DQA_BSS_CLIENT_QUEUE;
603 }
604 }
605
606 IWL_DEBUG_TX(mvm, "station Id %d, queue=%d\n", sta_id, queue);
607
608 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, &info, hdrlen, NULL, sta_id);
609 if (!dev_cmd)
610 return -1;
611
612 /* From now on, we cannot access info->control */
613 iwl_mvm_skb_prepare_status(skb, dev_cmd);
614
615 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
616
617 /* Copy MAC header from skb into command buffer */
618 memcpy(tx_cmd->hdr, hdr, hdrlen);
619
620 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, queue)) {
621 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
622 return -1;
623 }
624
625 /*
626 * Increase the pending frames counter, so that later when a reply comes
627 * in and the counter is decreased - we don't start getting negative
628 * values.
629 * Note that we don't need to make sure it isn't agg'd, since we're
630 * TXing non-sta
631 */
632 atomic_inc(&mvm->pending_frames[sta_id]);
633
634 return 0;
635 }
636
637 #ifdef CONFIG_INET
638 static int iwl_mvm_tx_tso(struct iwl_mvm *mvm, struct sk_buff *skb,
639 struct ieee80211_tx_info *info,
640 struct ieee80211_sta *sta,
641 struct sk_buff_head *mpdus_skb)
642 {
643 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
644 struct ieee80211_hdr *hdr = (void *)skb->data;
645 unsigned int mss = skb_shinfo(skb)->gso_size;
646 struct sk_buff *tmp, *next;
647 char cb[sizeof(skb->cb)];
648 unsigned int num_subframes, tcp_payload_len, subf_len, max_amsdu_len;
649 bool ipv4 = (skb->protocol == htons(ETH_P_IP));
650 u16 ip_base_id = ipv4 ? ntohs(ip_hdr(skb)->id) : 0;
651 u16 snap_ip_tcp, pad, i = 0;
652 unsigned int dbg_max_amsdu_len;
653 netdev_features_t netdev_features = NETIF_F_CSUM_MASK | NETIF_F_SG;
654 u8 *qc, tid, txf;
655
656 snap_ip_tcp = 8 + skb_transport_header(skb) - skb_network_header(skb) +
657 tcp_hdrlen(skb);
658
659 qc = ieee80211_get_qos_ctl(hdr);
660 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
661 if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
662 return -EINVAL;
663
664 dbg_max_amsdu_len = ACCESS_ONCE(mvm->max_amsdu_len);
665
666 if (!sta->max_amsdu_len ||
667 !ieee80211_is_data_qos(hdr->frame_control) ||
668 (!mvmsta->tlc_amsdu && !dbg_max_amsdu_len)) {
669 num_subframes = 1;
670 pad = 0;
671 goto segment;
672 }
673
674 /*
675 * Do not build AMSDU for IPv6 with extension headers.
676 * ask stack to segment and checkum the generated MPDUs for us.
677 */
678 if (skb->protocol == htons(ETH_P_IPV6) &&
679 ((struct ipv6hdr *)skb_network_header(skb))->nexthdr !=
680 IPPROTO_TCP) {
681 num_subframes = 1;
682 pad = 0;
683 netdev_features &= ~NETIF_F_CSUM_MASK;
684 goto segment;
685 }
686
687 /*
688 * No need to lock amsdu_in_ampdu_allowed since it can't be modified
689 * during an BA session.
690 */
691 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
692 !mvmsta->tid_data[tid].amsdu_in_ampdu_allowed) {
693 num_subframes = 1;
694 pad = 0;
695 goto segment;
696 }
697
698 max_amsdu_len = sta->max_amsdu_len;
699
700 /* the Tx FIFO to which this A-MSDU will be routed */
701 txf = iwl_mvm_ac_to_tx_fifo[tid_to_mac80211_ac[tid]];
702
703 /*
704 * Don't send an AMSDU that will be longer than the TXF.
705 * Add a security margin of 256 for the TX command + headers.
706 * We also want to have the start of the next packet inside the
707 * fifo to be able to send bursts.
708 */
709 max_amsdu_len = min_t(unsigned int, max_amsdu_len,
710 mvm->shared_mem_cfg.txfifo_size[txf] - 256);
711
712 if (unlikely(dbg_max_amsdu_len))
713 max_amsdu_len = min_t(unsigned int, max_amsdu_len,
714 dbg_max_amsdu_len);
715
716 /*
717 * Limit A-MSDU in A-MPDU to 4095 bytes when VHT is not
718 * supported. This is a spec requirement (IEEE 802.11-2015
719 * section 8.7.3 NOTE 3).
720 */
721 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
722 !sta->vht_cap.vht_supported)
723 max_amsdu_len = min_t(unsigned int, max_amsdu_len, 4095);
724
725 /* Sub frame header + SNAP + IP header + TCP header + MSS */
726 subf_len = sizeof(struct ethhdr) + snap_ip_tcp + mss;
727 pad = (4 - subf_len) & 0x3;
728
729 /*
730 * If we have N subframes in the A-MSDU, then the A-MSDU's size is
731 * N * subf_len + (N - 1) * pad.
732 */
733 num_subframes = (max_amsdu_len + pad) / (subf_len + pad);
734 if (num_subframes > 1)
735 *qc |= IEEE80211_QOS_CTL_A_MSDU_PRESENT;
736
737 tcp_payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
738 tcp_hdrlen(skb) + skb->data_len;
739
740 /*
741 * Make sure we have enough TBs for the A-MSDU:
742 * 2 for each subframe
743 * 1 more for each fragment
744 * 1 more for the potential data in the header
745 */
746 num_subframes =
747 min_t(unsigned int, num_subframes,
748 (mvm->trans->max_skb_frags - 1 -
749 skb_shinfo(skb)->nr_frags) / 2);
750
751 /* This skb fits in one single A-MSDU */
752 if (num_subframes * mss >= tcp_payload_len) {
753 __skb_queue_tail(mpdus_skb, skb);
754 return 0;
755 }
756
757 /*
758 * Trick the segmentation function to make it
759 * create SKBs that can fit into one A-MSDU.
760 */
761 segment:
762 skb_shinfo(skb)->gso_size = num_subframes * mss;
763 memcpy(cb, skb->cb, sizeof(cb));
764
765 next = skb_gso_segment(skb, netdev_features);
766 skb_shinfo(skb)->gso_size = mss;
767 if (WARN_ON_ONCE(IS_ERR(next)))
768 return -EINVAL;
769 else if (next)
770 consume_skb(skb);
771
772 while (next) {
773 tmp = next;
774 next = tmp->next;
775
776 memcpy(tmp->cb, cb, sizeof(tmp->cb));
777 /*
778 * Compute the length of all the data added for the A-MSDU.
779 * This will be used to compute the length to write in the TX
780 * command. We have: SNAP + IP + TCP for n -1 subframes and
781 * ETH header for n subframes.
782 */
783 tcp_payload_len = skb_tail_pointer(tmp) -
784 skb_transport_header(tmp) -
785 tcp_hdrlen(tmp) + tmp->data_len;
786
787 if (ipv4)
788 ip_hdr(tmp)->id = htons(ip_base_id + i * num_subframes);
789
790 if (tcp_payload_len > mss) {
791 skb_shinfo(tmp)->gso_size = mss;
792 } else {
793 qc = ieee80211_get_qos_ctl((void *)tmp->data);
794
795 if (ipv4)
796 ip_send_check(ip_hdr(tmp));
797 *qc &= ~IEEE80211_QOS_CTL_A_MSDU_PRESENT;
798 skb_shinfo(tmp)->gso_size = 0;
799 }
800
801 tmp->prev = NULL;
802 tmp->next = NULL;
803
804 __skb_queue_tail(mpdus_skb, tmp);
805 i++;
806 }
807
808 return 0;
809 }
810 #else /* CONFIG_INET */
811 static int iwl_mvm_tx_tso(struct iwl_mvm *mvm, struct sk_buff *skb,
812 struct ieee80211_tx_info *info,
813 struct ieee80211_sta *sta,
814 struct sk_buff_head *mpdus_skb)
815 {
816 /* Impossible to get TSO with CONFIG_INET */
817 WARN_ON(1);
818
819 return -1;
820 }
821 #endif
822
823 static void iwl_mvm_tx_add_stream(struct iwl_mvm *mvm,
824 struct iwl_mvm_sta *mvm_sta, u8 tid,
825 struct sk_buff *skb)
826 {
827 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
828 u8 mac_queue = info->hw_queue;
829 struct sk_buff_head *deferred_tx_frames;
830
831 lockdep_assert_held(&mvm_sta->lock);
832
833 mvm_sta->deferred_traffic_tid_map |= BIT(tid);
834 set_bit(mvm_sta->sta_id, mvm->sta_deferred_frames);
835
836 deferred_tx_frames = &mvm_sta->tid_data[tid].deferred_tx_frames;
837
838 skb_queue_tail(deferred_tx_frames, skb);
839
840 /*
841 * The first deferred frame should've stopped the MAC queues, so we
842 * should never get a second deferred frame for the RA/TID.
843 */
844 if (!WARN(skb_queue_len(deferred_tx_frames) != 1,
845 "RATID %d/%d has %d deferred frames\n", mvm_sta->sta_id, tid,
846 skb_queue_len(deferred_tx_frames))) {
847 iwl_mvm_stop_mac_queues(mvm, BIT(mac_queue));
848 schedule_work(&mvm->add_stream_wk);
849 }
850 }
851
852 /* Check if there are any timed-out TIDs on a given shared TXQ */
853 static bool iwl_mvm_txq_should_update(struct iwl_mvm *mvm, int txq_id)
854 {
855 unsigned long queue_tid_bitmap = mvm->queue_info[txq_id].tid_bitmap;
856 unsigned long now = jiffies;
857 int tid;
858
859 for_each_set_bit(tid, &queue_tid_bitmap, IWL_MAX_TID_COUNT + 1) {
860 if (time_before(mvm->queue_info[txq_id].last_frame_time[tid] +
861 IWL_MVM_DQA_QUEUE_TIMEOUT, now))
862 return true;
863 }
864
865 return false;
866 }
867
868 /*
869 * Sets the fields in the Tx cmd that are crypto related
870 */
871 static int iwl_mvm_tx_mpdu(struct iwl_mvm *mvm, struct sk_buff *skb,
872 struct ieee80211_tx_info *info,
873 struct ieee80211_sta *sta)
874 {
875 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
876 struct iwl_mvm_sta *mvmsta;
877 struct iwl_device_cmd *dev_cmd;
878 struct iwl_tx_cmd *tx_cmd;
879 __le16 fc;
880 u16 seq_number = 0;
881 u8 tid = IWL_MAX_TID_COUNT;
882 u8 txq_id = info->hw_queue;
883 bool is_ampdu = false;
884 int hdrlen;
885
886 mvmsta = iwl_mvm_sta_from_mac80211(sta);
887 fc = hdr->frame_control;
888 hdrlen = ieee80211_hdrlen(fc);
889
890 if (WARN_ON_ONCE(!mvmsta))
891 return -1;
892
893 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_MVM_STATION_COUNT))
894 return -1;
895
896 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, info, hdrlen,
897 sta, mvmsta->sta_id);
898 if (!dev_cmd)
899 goto drop;
900
901 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
902
903 /*
904 * we handle that entirely ourselves -- for uAPSD the firmware
905 * will always send a notification, and for PS-Poll responses
906 * we'll notify mac80211 when getting frame status
907 */
908 info->flags &= ~IEEE80211_TX_STATUS_EOSP;
909
910 spin_lock(&mvmsta->lock);
911
912 /* nullfunc frames should go to the MGMT queue regardless of QOS,
913 * the condition of !ieee80211_is_qos_nullfunc(fc) keeps the default
914 * assignment of MGMT TID
915 */
916 if (ieee80211_is_data_qos(fc) && !ieee80211_is_qos_nullfunc(fc)) {
917 u8 *qc = NULL;
918 qc = ieee80211_get_qos_ctl(hdr);
919 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
920 if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
921 goto drop_unlock_sta;
922
923 seq_number = mvmsta->tid_data[tid].seq_number;
924 seq_number &= IEEE80211_SCTL_SEQ;
925 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
926 hdr->seq_ctrl |= cpu_to_le16(seq_number);
927 is_ampdu = info->flags & IEEE80211_TX_CTL_AMPDU;
928 if (WARN_ON_ONCE(is_ampdu &&
929 mvmsta->tid_data[tid].state != IWL_AGG_ON))
930 goto drop_unlock_sta;
931 }
932
933 if (iwl_mvm_is_dqa_supported(mvm) || is_ampdu)
934 txq_id = mvmsta->tid_data[tid].txq_id;
935 if (sta->tdls && !iwl_mvm_is_dqa_supported(mvm)) {
936 /* default to TID 0 for non-QoS packets */
937 u8 tdls_tid = tid == IWL_MAX_TID_COUNT ? 0 : tid;
938
939 txq_id = mvmsta->hw_queue[tid_to_mac80211_ac[tdls_tid]];
940 }
941
942 /* Copy MAC header from skb into command buffer */
943 memcpy(tx_cmd->hdr, hdr, hdrlen);
944
945 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
946
947 /* Check if TXQ needs to be allocated or re-activated */
948 if (unlikely(txq_id == IEEE80211_INVAL_HW_QUEUE ||
949 !mvmsta->tid_data[tid].is_tid_active) &&
950 iwl_mvm_is_dqa_supported(mvm)) {
951 /* If TXQ needs to be allocated... */
952 if (txq_id == IEEE80211_INVAL_HW_QUEUE) {
953 iwl_mvm_tx_add_stream(mvm, mvmsta, tid, skb);
954
955 /*
956 * The frame is now deferred, and the worker scheduled
957 * will re-allocate it, so we can free it for now.
958 */
959 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
960 spin_unlock(&mvmsta->lock);
961 return 0;
962 }
963
964 /* If we are here - TXQ exists and needs to be re-activated */
965 spin_lock(&mvm->queue_info_lock);
966 mvm->queue_info[txq_id].status = IWL_MVM_QUEUE_READY;
967 mvmsta->tid_data[tid].is_tid_active = true;
968 spin_unlock(&mvm->queue_info_lock);
969
970 IWL_DEBUG_TX_QUEUES(mvm, "Re-activating queue %d for TX\n",
971 txq_id);
972 }
973
974 if (iwl_mvm_is_dqa_supported(mvm)) {
975 /* Keep track of the time of the last frame for this RA/TID */
976 mvm->queue_info[txq_id].last_frame_time[tid] = jiffies;
977
978 /*
979 * If we have timed-out TIDs - schedule the worker that will
980 * reconfig the queues and update them
981 *
982 * Note that the mvm->queue_info_lock isn't being taken here in
983 * order to not serialize the TX flow. This isn't dangerous
984 * because scheduling mvm->add_stream_wk can't ruin the state,
985 * and if we DON'T schedule it due to some race condition then
986 * next TX we get here we will.
987 */
988 if (unlikely(mvm->queue_info[txq_id].status ==
989 IWL_MVM_QUEUE_SHARED &&
990 iwl_mvm_txq_should_update(mvm, txq_id)))
991 schedule_work(&mvm->add_stream_wk);
992 }
993
994 IWL_DEBUG_TX(mvm, "TX to [%d|%d] Q:%d - seq: 0x%x\n", mvmsta->sta_id,
995 tid, txq_id, IEEE80211_SEQ_TO_SN(seq_number));
996
997 /* From now on, we cannot access info->control */
998 iwl_mvm_skb_prepare_status(skb, dev_cmd);
999
1000 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, txq_id))
1001 goto drop_unlock_sta;
1002
1003 if (tid < IWL_MAX_TID_COUNT && !ieee80211_has_morefrags(fc))
1004 mvmsta->tid_data[tid].seq_number = seq_number + 0x10;
1005
1006 spin_unlock(&mvmsta->lock);
1007
1008 /* Increase pending frames count if this isn't AMPDU */
1009 if ((iwl_mvm_is_dqa_supported(mvm) &&
1010 mvmsta->tid_data[tx_cmd->tid_tspec].state != IWL_AGG_ON &&
1011 mvmsta->tid_data[tx_cmd->tid_tspec].state != IWL_AGG_STARTING) ||
1012 (!iwl_mvm_is_dqa_supported(mvm) && !is_ampdu))
1013 atomic_inc(&mvm->pending_frames[mvmsta->sta_id]);
1014
1015 return 0;
1016
1017 drop_unlock_sta:
1018 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
1019 spin_unlock(&mvmsta->lock);
1020 drop:
1021 return -1;
1022 }
1023
1024 int iwl_mvm_tx_skb(struct iwl_mvm *mvm, struct sk_buff *skb,
1025 struct ieee80211_sta *sta)
1026 {
1027 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1028 struct ieee80211_tx_info info;
1029 struct sk_buff_head mpdus_skbs;
1030 unsigned int payload_len;
1031 int ret;
1032
1033 if (WARN_ON_ONCE(!mvmsta))
1034 return -1;
1035
1036 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_MVM_STATION_COUNT))
1037 return -1;
1038
1039 memcpy(&info, skb->cb, sizeof(info));
1040
1041 if (!skb_is_gso(skb))
1042 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1043
1044 payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
1045 tcp_hdrlen(skb) + skb->data_len;
1046
1047 if (payload_len <= skb_shinfo(skb)->gso_size)
1048 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1049
1050 __skb_queue_head_init(&mpdus_skbs);
1051
1052 ret = iwl_mvm_tx_tso(mvm, skb, &info, sta, &mpdus_skbs);
1053 if (ret)
1054 return ret;
1055
1056 if (WARN_ON(skb_queue_empty(&mpdus_skbs)))
1057 return ret;
1058
1059 while (!skb_queue_empty(&mpdus_skbs)) {
1060 skb = __skb_dequeue(&mpdus_skbs);
1061
1062 ret = iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1063 if (ret) {
1064 __skb_queue_purge(&mpdus_skbs);
1065 return ret;
1066 }
1067 }
1068
1069 return 0;
1070 }
1071
1072 static void iwl_mvm_check_ratid_empty(struct iwl_mvm *mvm,
1073 struct ieee80211_sta *sta, u8 tid)
1074 {
1075 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1076 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
1077 struct ieee80211_vif *vif = mvmsta->vif;
1078
1079 lockdep_assert_held(&mvmsta->lock);
1080
1081 if ((tid_data->state == IWL_AGG_ON ||
1082 tid_data->state == IWL_EMPTYING_HW_QUEUE_DELBA) &&
1083 iwl_mvm_tid_queued(tid_data) == 0) {
1084 /*
1085 * Now that this aggregation queue is empty tell mac80211 so it
1086 * knows we no longer have frames buffered for the station on
1087 * this TID (for the TIM bitmap calculation.)
1088 */
1089 ieee80211_sta_set_buffered(sta, tid, false);
1090 }
1091
1092 if (tid_data->ssn != tid_data->next_reclaimed)
1093 return;
1094
1095 switch (tid_data->state) {
1096 case IWL_EMPTYING_HW_QUEUE_ADDBA:
1097 IWL_DEBUG_TX_QUEUES(mvm,
1098 "Can continue addBA flow ssn = next_recl = %d\n",
1099 tid_data->next_reclaimed);
1100 tid_data->state = IWL_AGG_STARTING;
1101 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1102 break;
1103
1104 case IWL_EMPTYING_HW_QUEUE_DELBA:
1105 IWL_DEBUG_TX_QUEUES(mvm,
1106 "Can continue DELBA flow ssn = next_recl = %d\n",
1107 tid_data->next_reclaimed);
1108 if (!iwl_mvm_is_dqa_supported(mvm)) {
1109 u8 mac80211_ac = tid_to_mac80211_ac[tid];
1110
1111 iwl_mvm_disable_txq(mvm, tid_data->txq_id,
1112 vif->hw_queue[mac80211_ac], tid,
1113 CMD_ASYNC);
1114 }
1115 tid_data->state = IWL_AGG_OFF;
1116 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1117 break;
1118
1119 default:
1120 break;
1121 }
1122 }
1123
1124 #ifdef CONFIG_IWLWIFI_DEBUG
1125 const char *iwl_mvm_get_tx_fail_reason(u32 status)
1126 {
1127 #define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
1128 #define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
1129
1130 switch (status & TX_STATUS_MSK) {
1131 case TX_STATUS_SUCCESS:
1132 return "SUCCESS";
1133 TX_STATUS_POSTPONE(DELAY);
1134 TX_STATUS_POSTPONE(FEW_BYTES);
1135 TX_STATUS_POSTPONE(BT_PRIO);
1136 TX_STATUS_POSTPONE(QUIET_PERIOD);
1137 TX_STATUS_POSTPONE(CALC_TTAK);
1138 TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
1139 TX_STATUS_FAIL(SHORT_LIMIT);
1140 TX_STATUS_FAIL(LONG_LIMIT);
1141 TX_STATUS_FAIL(UNDERRUN);
1142 TX_STATUS_FAIL(DRAIN_FLOW);
1143 TX_STATUS_FAIL(RFKILL_FLUSH);
1144 TX_STATUS_FAIL(LIFE_EXPIRE);
1145 TX_STATUS_FAIL(DEST_PS);
1146 TX_STATUS_FAIL(HOST_ABORTED);
1147 TX_STATUS_FAIL(BT_RETRY);
1148 TX_STATUS_FAIL(STA_INVALID);
1149 TX_STATUS_FAIL(FRAG_DROPPED);
1150 TX_STATUS_FAIL(TID_DISABLE);
1151 TX_STATUS_FAIL(FIFO_FLUSHED);
1152 TX_STATUS_FAIL(SMALL_CF_POLL);
1153 TX_STATUS_FAIL(FW_DROP);
1154 TX_STATUS_FAIL(STA_COLOR_MISMATCH);
1155 }
1156
1157 return "UNKNOWN";
1158
1159 #undef TX_STATUS_FAIL
1160 #undef TX_STATUS_POSTPONE
1161 }
1162 #endif /* CONFIG_IWLWIFI_DEBUG */
1163
1164 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
1165 enum nl80211_band band,
1166 struct ieee80211_tx_rate *r)
1167 {
1168 if (rate_n_flags & RATE_HT_MCS_GF_MSK)
1169 r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
1170 switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) {
1171 case RATE_MCS_CHAN_WIDTH_20:
1172 break;
1173 case RATE_MCS_CHAN_WIDTH_40:
1174 r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
1175 break;
1176 case RATE_MCS_CHAN_WIDTH_80:
1177 r->flags |= IEEE80211_TX_RC_80_MHZ_WIDTH;
1178 break;
1179 case RATE_MCS_CHAN_WIDTH_160:
1180 r->flags |= IEEE80211_TX_RC_160_MHZ_WIDTH;
1181 break;
1182 }
1183 if (rate_n_flags & RATE_MCS_SGI_MSK)
1184 r->flags |= IEEE80211_TX_RC_SHORT_GI;
1185 if (rate_n_flags & RATE_MCS_HT_MSK) {
1186 r->flags |= IEEE80211_TX_RC_MCS;
1187 r->idx = rate_n_flags & RATE_HT_MCS_INDEX_MSK;
1188 } else if (rate_n_flags & RATE_MCS_VHT_MSK) {
1189 ieee80211_rate_set_vht(
1190 r, rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK,
1191 ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >>
1192 RATE_VHT_MCS_NSS_POS) + 1);
1193 r->flags |= IEEE80211_TX_RC_VHT_MCS;
1194 } else {
1195 r->idx = iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags,
1196 band);
1197 }
1198 }
1199
1200 /**
1201 * translate ucode response to mac80211 tx status control values
1202 */
1203 static void iwl_mvm_hwrate_to_tx_status(u32 rate_n_flags,
1204 struct ieee80211_tx_info *info)
1205 {
1206 struct ieee80211_tx_rate *r = &info->status.rates[0];
1207
1208 info->status.antenna =
1209 ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
1210 iwl_mvm_hwrate_to_tx_rate(rate_n_flags, info->band, r);
1211 }
1212
1213 static void iwl_mvm_tx_status_check_trigger(struct iwl_mvm *mvm,
1214 u32 status)
1215 {
1216 struct iwl_fw_dbg_trigger_tlv *trig;
1217 struct iwl_fw_dbg_trigger_tx_status *status_trig;
1218 int i;
1219
1220 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TX_STATUS))
1221 return;
1222
1223 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TX_STATUS);
1224 status_trig = (void *)trig->data;
1225
1226 if (!iwl_fw_dbg_trigger_check_stop(mvm, NULL, trig))
1227 return;
1228
1229 for (i = 0; i < ARRAY_SIZE(status_trig->statuses); i++) {
1230 /* don't collect on status 0 */
1231 if (!status_trig->statuses[i].status)
1232 break;
1233
1234 if (status_trig->statuses[i].status != (status & TX_STATUS_MSK))
1235 continue;
1236
1237 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
1238 "Tx status %d was received",
1239 status & TX_STATUS_MSK);
1240 break;
1241 }
1242 }
1243
1244 static void iwl_mvm_rx_tx_cmd_single(struct iwl_mvm *mvm,
1245 struct iwl_rx_packet *pkt)
1246 {
1247 struct ieee80211_sta *sta;
1248 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1249 int txq_id = SEQ_TO_QUEUE(sequence);
1250 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1251 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1252 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1253 u32 status = le16_to_cpu(tx_resp->status.status);
1254 u16 ssn = iwl_mvm_get_scd_ssn(tx_resp);
1255 struct iwl_mvm_sta *mvmsta;
1256 struct sk_buff_head skbs;
1257 u8 skb_freed = 0;
1258 u16 next_reclaimed, seq_ctl;
1259 bool is_ndp = false;
1260 bool txq_agg = false; /* Is this TXQ aggregated */
1261
1262 __skb_queue_head_init(&skbs);
1263
1264 seq_ctl = le16_to_cpu(tx_resp->seq_ctl);
1265
1266 /* we can free until ssn % q.n_bd not inclusive */
1267 iwl_trans_reclaim(mvm->trans, txq_id, ssn, &skbs);
1268
1269 while (!skb_queue_empty(&skbs)) {
1270 struct sk_buff *skb = __skb_dequeue(&skbs);
1271 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1272
1273 skb_freed++;
1274
1275 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1276
1277 memset(&info->status, 0, sizeof(info->status));
1278
1279 /* inform mac80211 about what happened with the frame */
1280 switch (status & TX_STATUS_MSK) {
1281 case TX_STATUS_SUCCESS:
1282 case TX_STATUS_DIRECT_DONE:
1283 info->flags |= IEEE80211_TX_STAT_ACK;
1284 break;
1285 case TX_STATUS_FAIL_DEST_PS:
1286 info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
1287 break;
1288 default:
1289 break;
1290 }
1291
1292 iwl_mvm_tx_status_check_trigger(mvm, status);
1293
1294 info->status.rates[0].count = tx_resp->failure_frame + 1;
1295 iwl_mvm_hwrate_to_tx_status(le32_to_cpu(tx_resp->initial_rate),
1296 info);
1297 info->status.status_driver_data[1] =
1298 (void *)(uintptr_t)le32_to_cpu(tx_resp->initial_rate);
1299
1300 /* Single frame failure in an AMPDU queue => send BAR */
1301 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
1302 !(info->flags & IEEE80211_TX_STAT_ACK) &&
1303 !(info->flags & IEEE80211_TX_STAT_TX_FILTERED))
1304 info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
1305 info->flags &= ~IEEE80211_TX_CTL_AMPDU;
1306
1307 /* W/A FW bug: seq_ctl is wrong when the status isn't success */
1308 if (status != TX_STATUS_SUCCESS) {
1309 struct ieee80211_hdr *hdr = (void *)skb->data;
1310 seq_ctl = le16_to_cpu(hdr->seq_ctrl);
1311 }
1312
1313 if (unlikely(!seq_ctl)) {
1314 struct ieee80211_hdr *hdr = (void *)skb->data;
1315
1316 /*
1317 * If it is an NDP, we can't update next_reclaim since
1318 * its sequence control is 0. Note that for that same
1319 * reason, NDPs are never sent to A-MPDU'able queues
1320 * so that we can never have more than one freed frame
1321 * for a single Tx resonse (see WARN_ON below).
1322 */
1323 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
1324 is_ndp = true;
1325 }
1326
1327 /*
1328 * TODO: this is not accurate if we are freeing more than one
1329 * packet.
1330 */
1331 info->status.tx_time =
1332 le16_to_cpu(tx_resp->wireless_media_time);
1333 BUILD_BUG_ON(ARRAY_SIZE(info->status.status_driver_data) < 1);
1334 info->status.status_driver_data[0] =
1335 (void *)(uintptr_t)tx_resp->reduced_tpc;
1336
1337 ieee80211_tx_status(mvm->hw, skb);
1338 }
1339
1340 if (iwl_mvm_is_dqa_supported(mvm) || txq_id >= mvm->first_agg_queue) {
1341 /* If this is an aggregation queue, we use the ssn since:
1342 * ssn = wifi seq_num % 256.
1343 * The seq_ctl is the sequence control of the packet to which
1344 * this Tx response relates. But if there is a hole in the
1345 * bitmap of the BA we received, this Tx response may allow to
1346 * reclaim the hole and all the subsequent packets that were
1347 * already acked. In that case, seq_ctl != ssn, and the next
1348 * packet to be reclaimed will be ssn and not seq_ctl. In that
1349 * case, several packets will be reclaimed even if
1350 * frame_count = 1.
1351 *
1352 * The ssn is the index (% 256) of the latest packet that has
1353 * treated (acked / dropped) + 1.
1354 */
1355 next_reclaimed = ssn;
1356 } else {
1357 /* The next packet to be reclaimed is the one after this one */
1358 next_reclaimed = IEEE80211_SEQ_TO_SN(seq_ctl + 0x10);
1359 }
1360
1361 IWL_DEBUG_TX_REPLY(mvm,
1362 "TXQ %d status %s (0x%08x)\n",
1363 txq_id, iwl_mvm_get_tx_fail_reason(status), status);
1364
1365 IWL_DEBUG_TX_REPLY(mvm,
1366 "\t\t\t\tinitial_rate 0x%x retries %d, idx=%d ssn=%d next_reclaimed=0x%x seq_ctl=0x%x\n",
1367 le32_to_cpu(tx_resp->initial_rate),
1368 tx_resp->failure_frame, SEQ_TO_INDEX(sequence),
1369 ssn, next_reclaimed, seq_ctl);
1370
1371 rcu_read_lock();
1372
1373 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1374 /*
1375 * sta can't be NULL otherwise it'd mean that the sta has been freed in
1376 * the firmware while we still have packets for it in the Tx queues.
1377 */
1378 if (WARN_ON_ONCE(!sta))
1379 goto out;
1380
1381 if (!IS_ERR(sta)) {
1382 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1383
1384 if (tid != IWL_TID_NON_QOS) {
1385 struct iwl_mvm_tid_data *tid_data =
1386 &mvmsta->tid_data[tid];
1387 bool send_eosp_ndp = false;
1388
1389 spin_lock_bh(&mvmsta->lock);
1390 if (iwl_mvm_is_dqa_supported(mvm)) {
1391 enum iwl_mvm_agg_state state;
1392
1393 state = mvmsta->tid_data[tid].state;
1394 txq_agg = (state == IWL_AGG_ON ||
1395 state == IWL_EMPTYING_HW_QUEUE_DELBA);
1396 } else {
1397 txq_agg = txq_id >= mvm->first_agg_queue;
1398 }
1399
1400 if (!is_ndp) {
1401 tid_data->next_reclaimed = next_reclaimed;
1402 IWL_DEBUG_TX_REPLY(mvm,
1403 "Next reclaimed packet:%d\n",
1404 next_reclaimed);
1405 } else {
1406 IWL_DEBUG_TX_REPLY(mvm,
1407 "NDP - don't update next_reclaimed\n");
1408 }
1409
1410 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1411
1412 if (mvmsta->sleep_tx_count) {
1413 mvmsta->sleep_tx_count--;
1414 if (mvmsta->sleep_tx_count &&
1415 !iwl_mvm_tid_queued(tid_data)) {
1416 /*
1417 * The number of frames in the queue
1418 * dropped to 0 even if we sent less
1419 * frames than we thought we had on the
1420 * Tx queue.
1421 * This means we had holes in the BA
1422 * window that we just filled, ask
1423 * mac80211 to send EOSP since the
1424 * firmware won't know how to do that.
1425 * Send NDP and the firmware will send
1426 * EOSP notification that will trigger
1427 * a call to ieee80211_sta_eosp().
1428 */
1429 send_eosp_ndp = true;
1430 }
1431 }
1432
1433 spin_unlock_bh(&mvmsta->lock);
1434 if (send_eosp_ndp) {
1435 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta,
1436 IEEE80211_FRAME_RELEASE_UAPSD,
1437 1, tid, false, false);
1438 mvmsta->sleep_tx_count = 0;
1439 ieee80211_send_eosp_nullfunc(sta, tid);
1440 }
1441 }
1442
1443 if (mvmsta->next_status_eosp) {
1444 mvmsta->next_status_eosp = false;
1445 ieee80211_sta_eosp(sta);
1446 }
1447 } else {
1448 mvmsta = NULL;
1449 }
1450
1451 /*
1452 * If the txq is not an AMPDU queue, there is no chance we freed
1453 * several skbs. Check that out...
1454 */
1455 if (txq_agg)
1456 goto out;
1457
1458 /* We can't free more than one frame at once on a shared queue */
1459 WARN_ON(!iwl_mvm_is_dqa_supported(mvm) && (skb_freed > 1));
1460
1461 /* If we have still frames for this STA nothing to do here */
1462 if (!atomic_sub_and_test(skb_freed, &mvm->pending_frames[sta_id]))
1463 goto out;
1464
1465 if (mvmsta && mvmsta->vif->type == NL80211_IFTYPE_AP) {
1466
1467 /*
1468 * If there are no pending frames for this STA and
1469 * the tx to this station is not disabled, notify
1470 * mac80211 that this station can now wake up in its
1471 * STA table.
1472 * If mvmsta is not NULL, sta is valid.
1473 */
1474
1475 spin_lock_bh(&mvmsta->lock);
1476
1477 if (!mvmsta->disable_tx)
1478 ieee80211_sta_block_awake(mvm->hw, sta, false);
1479
1480 spin_unlock_bh(&mvmsta->lock);
1481 }
1482
1483 if (PTR_ERR(sta) == -EBUSY || PTR_ERR(sta) == -ENOENT) {
1484 /*
1485 * We are draining and this was the last packet - pre_rcu_remove
1486 * has been called already. We might be after the
1487 * synchronize_net already.
1488 * Don't rely on iwl_mvm_rm_sta to see the empty Tx queues.
1489 */
1490 set_bit(sta_id, mvm->sta_drained);
1491 schedule_work(&mvm->sta_drained_wk);
1492 }
1493
1494 out:
1495 rcu_read_unlock();
1496 }
1497
1498 #ifdef CONFIG_IWLWIFI_DEBUG
1499 #define AGG_TX_STATE_(x) case AGG_TX_STATE_ ## x: return #x
1500 static const char *iwl_get_agg_tx_status(u16 status)
1501 {
1502 switch (status & AGG_TX_STATE_STATUS_MSK) {
1503 AGG_TX_STATE_(TRANSMITTED);
1504 AGG_TX_STATE_(UNDERRUN);
1505 AGG_TX_STATE_(BT_PRIO);
1506 AGG_TX_STATE_(FEW_BYTES);
1507 AGG_TX_STATE_(ABORT);
1508 AGG_TX_STATE_(LAST_SENT_TTL);
1509 AGG_TX_STATE_(LAST_SENT_TRY_CNT);
1510 AGG_TX_STATE_(LAST_SENT_BT_KILL);
1511 AGG_TX_STATE_(SCD_QUERY);
1512 AGG_TX_STATE_(TEST_BAD_CRC32);
1513 AGG_TX_STATE_(RESPONSE);
1514 AGG_TX_STATE_(DUMP_TX);
1515 AGG_TX_STATE_(DELAY_TX);
1516 }
1517
1518 return "UNKNOWN";
1519 }
1520
1521 static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1522 struct iwl_rx_packet *pkt)
1523 {
1524 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1525 struct agg_tx_status *frame_status = &tx_resp->status;
1526 int i;
1527
1528 for (i = 0; i < tx_resp->frame_count; i++) {
1529 u16 fstatus = le16_to_cpu(frame_status[i].status);
1530
1531 IWL_DEBUG_TX_REPLY(mvm,
1532 "status %s (0x%04x), try-count (%d) seq (0x%x)\n",
1533 iwl_get_agg_tx_status(fstatus),
1534 fstatus & AGG_TX_STATE_STATUS_MSK,
1535 (fstatus & AGG_TX_STATE_TRY_CNT_MSK) >>
1536 AGG_TX_STATE_TRY_CNT_POS,
1537 le16_to_cpu(frame_status[i].sequence));
1538 }
1539 }
1540 #else
1541 static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1542 struct iwl_rx_packet *pkt)
1543 {}
1544 #endif /* CONFIG_IWLWIFI_DEBUG */
1545
1546 static void iwl_mvm_rx_tx_cmd_agg(struct iwl_mvm *mvm,
1547 struct iwl_rx_packet *pkt)
1548 {
1549 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1550 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1551 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1552 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1553 struct iwl_mvm_sta *mvmsta;
1554 int queue = SEQ_TO_QUEUE(sequence);
1555
1556 if (WARN_ON_ONCE(queue < mvm->first_agg_queue &&
1557 (!iwl_mvm_is_dqa_supported(mvm) ||
1558 (queue != IWL_MVM_DQA_BSS_CLIENT_QUEUE))))
1559 return;
1560
1561 if (WARN_ON_ONCE(tid == IWL_TID_NON_QOS))
1562 return;
1563
1564 iwl_mvm_rx_tx_cmd_agg_dbg(mvm, pkt);
1565
1566 rcu_read_lock();
1567
1568 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1569
1570 if (!WARN_ON_ONCE(!mvmsta)) {
1571 mvmsta->tid_data[tid].rate_n_flags =
1572 le32_to_cpu(tx_resp->initial_rate);
1573 mvmsta->tid_data[tid].tx_time =
1574 le16_to_cpu(tx_resp->wireless_media_time);
1575 }
1576
1577 rcu_read_unlock();
1578 }
1579
1580 void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1581 {
1582 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1583 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1584
1585 if (tx_resp->frame_count == 1)
1586 iwl_mvm_rx_tx_cmd_single(mvm, pkt);
1587 else
1588 iwl_mvm_rx_tx_cmd_agg(mvm, pkt);
1589 }
1590
1591 static void iwl_mvm_tx_reclaim(struct iwl_mvm *mvm, int sta_id, int tid,
1592 int txq, int index,
1593 struct ieee80211_tx_info *ba_info, u32 rate)
1594 {
1595 struct sk_buff_head reclaimed_skbs;
1596 struct iwl_mvm_tid_data *tid_data;
1597 struct ieee80211_sta *sta;
1598 struct iwl_mvm_sta *mvmsta;
1599 struct sk_buff *skb;
1600 int freed;
1601
1602 if (WARN_ONCE(sta_id >= IWL_MVM_STATION_COUNT ||
1603 tid >= IWL_MAX_TID_COUNT,
1604 "sta_id %d tid %d", sta_id, tid))
1605 return;
1606
1607 rcu_read_lock();
1608
1609 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1610
1611 /* Reclaiming frames for a station that has been deleted ? */
1612 if (WARN_ON_ONCE(IS_ERR_OR_NULL(sta))) {
1613 rcu_read_unlock();
1614 return;
1615 }
1616
1617 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1618 tid_data = &mvmsta->tid_data[tid];
1619
1620 if (tid_data->txq_id != txq) {
1621 IWL_ERR(mvm,
1622 "invalid BA notification: Q %d, tid %d\n",
1623 tid_data->txq_id, tid);
1624 rcu_read_unlock();
1625 return;
1626 }
1627
1628 spin_lock_bh(&mvmsta->lock);
1629
1630 __skb_queue_head_init(&reclaimed_skbs);
1631
1632 /*
1633 * Release all TFDs before the SSN, i.e. all TFDs in front of
1634 * block-ack window (we assume that they've been successfully
1635 * transmitted ... if not, it's too late anyway).
1636 */
1637 iwl_trans_reclaim(mvm->trans, txq, index, &reclaimed_skbs);
1638
1639 tid_data->next_reclaimed = index;
1640
1641 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1642
1643 freed = 0;
1644 ba_info->status.status_driver_data[1] = (void *)(uintptr_t)rate;
1645
1646 skb_queue_walk(&reclaimed_skbs, skb) {
1647 struct ieee80211_hdr *hdr = (void *)skb->data;
1648 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1649
1650 if (ieee80211_is_data_qos(hdr->frame_control))
1651 freed++;
1652 else
1653 WARN_ON_ONCE(1);
1654
1655 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1656
1657 memset(&info->status, 0, sizeof(info->status));
1658 /* Packet was transmitted successfully, failures come as single
1659 * frames because before failing a frame the firmware transmits
1660 * it without aggregation at least once.
1661 */
1662 info->flags |= IEEE80211_TX_STAT_ACK;
1663
1664 /* this is the first skb we deliver in this batch */
1665 /* put the rate scaling data there */
1666 if (freed == 1) {
1667 info->flags |= IEEE80211_TX_STAT_AMPDU;
1668 memcpy(&info->status, &ba_info->status,
1669 sizeof(ba_info->status));
1670 iwl_mvm_hwrate_to_tx_status(rate, info);
1671 }
1672 }
1673
1674 spin_unlock_bh(&mvmsta->lock);
1675
1676 /* We got a BA notif with 0 acked or scd_ssn didn't progress which is
1677 * possible (i.e. first MPDU in the aggregation wasn't acked)
1678 * Still it's important to update RS about sent vs. acked.
1679 */
1680 if (skb_queue_empty(&reclaimed_skbs)) {
1681 struct ieee80211_chanctx_conf *chanctx_conf = NULL;
1682
1683 if (mvmsta->vif)
1684 chanctx_conf =
1685 rcu_dereference(mvmsta->vif->chanctx_conf);
1686
1687 if (WARN_ON_ONCE(!chanctx_conf))
1688 goto out;
1689
1690 ba_info->band = chanctx_conf->def.chan->band;
1691 iwl_mvm_hwrate_to_tx_status(rate, ba_info);
1692
1693 IWL_DEBUG_TX_REPLY(mvm, "No reclaim. Update rs directly\n");
1694 iwl_mvm_rs_tx_status(mvm, sta, tid, ba_info, false);
1695 }
1696
1697 out:
1698 rcu_read_unlock();
1699
1700 while (!skb_queue_empty(&reclaimed_skbs)) {
1701 skb = __skb_dequeue(&reclaimed_skbs);
1702 ieee80211_tx_status(mvm->hw, skb);
1703 }
1704 }
1705
1706 void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1707 {
1708 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1709 int sta_id, tid, txq, index;
1710 struct ieee80211_tx_info ba_info = {};
1711 struct iwl_mvm_ba_notif *ba_notif;
1712 struct iwl_mvm_tid_data *tid_data;
1713 struct iwl_mvm_sta *mvmsta;
1714
1715 if (iwl_mvm_has_new_tx_api(mvm)) {
1716 struct iwl_mvm_compressed_ba_notif *ba_res =
1717 (void *)pkt->data;
1718
1719 sta_id = ba_res->sta_id;
1720 ba_info.status.ampdu_ack_len = (u8)le16_to_cpu(ba_res->done);
1721 ba_info.status.ampdu_len = (u8)le16_to_cpu(ba_res->txed);
1722 ba_info.status.tx_time =
1723 (u16)le32_to_cpu(ba_res->wireless_time);
1724 ba_info.status.status_driver_data[0] =
1725 (void *)(uintptr_t)ba_res->reduced_txp;
1726
1727 /*
1728 * TODO:
1729 * When supporting multi TID aggregations - we need to move
1730 * next_reclaimed to be per TXQ and not per TID or handle it
1731 * in a different way.
1732 * This will go together with SN and AddBA offload and cannot
1733 * be handled properly for now.
1734 */
1735 WARN_ON(le16_to_cpu(ba_res->tfd_cnt) != 1);
1736 iwl_mvm_tx_reclaim(mvm, sta_id, ba_res->ra_tid[0].tid,
1737 (int)ba_res->tfd[0].q_num,
1738 le16_to_cpu(ba_res->tfd[0].tfd_index),
1739 &ba_info, le32_to_cpu(ba_res->tx_rate));
1740
1741 IWL_DEBUG_TX_REPLY(mvm,
1742 "BA_NOTIFICATION Received from sta_id = %d, flags %x, sent:%d, acked:%d\n",
1743 sta_id, le32_to_cpu(ba_res->flags),
1744 le16_to_cpu(ba_res->txed),
1745 le16_to_cpu(ba_res->done));
1746 return;
1747 }
1748
1749 ba_notif = (void *)pkt->data;
1750 sta_id = ba_notif->sta_id;
1751 tid = ba_notif->tid;
1752 /* "flow" corresponds to Tx queue */
1753 txq = le16_to_cpu(ba_notif->scd_flow);
1754 /* "ssn" is start of block-ack Tx window, corresponds to index
1755 * (in Tx queue's circular buffer) of first TFD/frame in window */
1756 index = le16_to_cpu(ba_notif->scd_ssn);
1757
1758 rcu_read_lock();
1759 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1760 if (WARN_ON_ONCE(!mvmsta)) {
1761 rcu_read_unlock();
1762 return;
1763 }
1764
1765 tid_data = &mvmsta->tid_data[tid];
1766
1767 ba_info.status.ampdu_ack_len = ba_notif->txed_2_done;
1768 ba_info.status.ampdu_len = ba_notif->txed;
1769 ba_info.status.tx_time = tid_data->tx_time;
1770 ba_info.status.status_driver_data[0] =
1771 (void *)(uintptr_t)ba_notif->reduced_txp;
1772
1773 rcu_read_unlock();
1774
1775 iwl_mvm_tx_reclaim(mvm, sta_id, tid, txq, index, &ba_info,
1776 tid_data->rate_n_flags);
1777
1778 IWL_DEBUG_TX_REPLY(mvm,
1779 "BA_NOTIFICATION Received from %pM, sta_id = %d\n",
1780 (u8 *)&ba_notif->sta_addr_lo32, ba_notif->sta_id);
1781
1782 IWL_DEBUG_TX_REPLY(mvm,
1783 "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = %d, scd_ssn = %d sent:%d, acked:%d\n",
1784 ba_notif->tid, le16_to_cpu(ba_notif->seq_ctl),
1785 le64_to_cpu(ba_notif->bitmap), txq, index,
1786 ba_notif->txed, ba_notif->txed_2_done);
1787
1788 IWL_DEBUG_TX_REPLY(mvm, "reduced txp from ba notif %d\n",
1789 ba_notif->reduced_txp);
1790 }
1791
1792 /*
1793 * Note that there are transports that buffer frames before they reach
1794 * the firmware. This means that after flush_tx_path is called, the
1795 * queue might not be empty. The race-free way to handle this is to:
1796 * 1) set the station as draining
1797 * 2) flush the Tx path
1798 * 3) wait for the transport queues to be empty
1799 */
1800 int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk, u32 flags)
1801 {
1802 int ret;
1803 struct iwl_tx_path_flush_cmd flush_cmd = {
1804 .queues_ctl = cpu_to_le32(tfd_msk),
1805 .flush_ctl = cpu_to_le16(DUMP_TX_FIFO_FLUSH),
1806 };
1807
1808 ret = iwl_mvm_send_cmd_pdu(mvm, TXPATH_FLUSH, flags,
1809 sizeof(flush_cmd), &flush_cmd);
1810 if (ret)
1811 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
1812 return ret;
1813 }
ubuntu-bionic-kernel mirror