1
2
3
4
5
6
7#include <linux/ieee80211.h>
8#include <linux/etherdevice.h>
9#include <linux/tcp.h>
10#include <net/ip.h>
11#include <net/ipv6.h>
12
13#include "iwl-trans.h"
14#include "iwl-eeprom-parse.h"
15#include "mvm.h"
16#include "sta.h"
17
18static void
19iwl_mvm_bar_check_trigger(struct iwl_mvm *mvm, const u8 *addr,
20 u16 tid, u16 ssn)
21{
22 struct iwl_fw_dbg_trigger_tlv *trig;
23 struct iwl_fw_dbg_trigger_ba *ba_trig;
24
25 trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, NULL, FW_DBG_TRIGGER_BA);
26 if (!trig)
27 return;
28
29 ba_trig = (void *)trig->data;
30
31 if (!(le16_to_cpu(ba_trig->tx_bar) & BIT(tid)))
32 return;
33
34 iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
35 "BAR sent to %pM, tid %d, ssn %d",
36 addr, tid, ssn);
37}
38
39#define OPT_HDR(type, skb, off) \
40 (type *)(skb_network_header(skb) + (off))
41
42static u16 iwl_mvm_tx_csum(struct iwl_mvm *mvm, struct sk_buff *skb,
43 struct ieee80211_hdr *hdr,
44 struct ieee80211_tx_info *info,
45 u16 offload_assist)
46{
47#if IS_ENABLED(CONFIG_INET)
48 u16 mh_len = ieee80211_hdrlen(hdr->frame_control);
49 u8 protocol = 0;
50
51
52 if (skb->ip_summed != CHECKSUM_PARTIAL)
53 goto out;
54
55
56 if (WARN_ONCE(!(mvm->hw->netdev_features & IWL_TX_CSUM_NETIF_FLAGS) ||
57 (skb->protocol != htons(ETH_P_IP) &&
58 skb->protocol != htons(ETH_P_IPV6)),
59 "No support for requested checksum\n")) {
60 skb_checksum_help(skb);
61 goto out;
62 }
63
64 if (skb->protocol == htons(ETH_P_IP)) {
65 protocol = ip_hdr(skb)->protocol;
66 } else {
67#if IS_ENABLED(CONFIG_IPV6)
68 struct ipv6hdr *ipv6h =
69 (struct ipv6hdr *)skb_network_header(skb);
70 unsigned int off = sizeof(*ipv6h);
71
72 protocol = ipv6h->nexthdr;
73 while (protocol != NEXTHDR_NONE && ipv6_ext_hdr(protocol)) {
74 struct ipv6_opt_hdr *hp;
75
76
77 if (protocol != NEXTHDR_ROUTING &&
78 protocol != NEXTHDR_HOP &&
79 protocol != NEXTHDR_DEST) {
80 skb_checksum_help(skb);
81 goto out;
82 }
83
84 hp = OPT_HDR(struct ipv6_opt_hdr, skb, off);
85 protocol = hp->nexthdr;
86 off += ipv6_optlen(hp);
87 }
88
89#endif
90 }
91
92 if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP) {
93 WARN_ON_ONCE(1);
94 skb_checksum_help(skb);
95 goto out;
96 }
97
98
99 offload_assist |= BIT(TX_CMD_OFFLD_L4_EN);
100
101
102
103
104
105
106 offload_assist |= (4 << TX_CMD_OFFLD_IP_HDR);
107
108
109 if (skb->protocol == htons(ETH_P_IP) &&
110 (offload_assist & BIT(TX_CMD_OFFLD_AMSDU))) {
111 ip_hdr(skb)->check = 0;
112 offload_assist |= BIT(TX_CMD_OFFLD_L3_EN);
113 }
114
115
116 if (protocol == IPPROTO_TCP)
117 tcp_hdr(skb)->check = 0;
118 else
119 udp_hdr(skb)->check = 0;
120
121
122
123
124
125
126 if (!iwl_mvm_has_new_tx_api(mvm) && info->control.hw_key &&
127 info->control.hw_key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
128 info->control.hw_key->cipher != WLAN_CIPHER_SUITE_WEP104)
129 mh_len += info->control.hw_key->iv_len;
130 mh_len /= 2;
131 offload_assist |= mh_len << TX_CMD_OFFLD_MH_SIZE;
132
133out:
134#endif
135 return offload_assist;
136}
137
138
139
140
141void iwl_mvm_set_tx_cmd(struct iwl_mvm *mvm, struct sk_buff *skb,
142 struct iwl_tx_cmd *tx_cmd,
143 struct ieee80211_tx_info *info, u8 sta_id)
144{
145 struct ieee80211_hdr *hdr = (void *)skb->data;
146 __le16 fc = hdr->frame_control;
147 u32 tx_flags = le32_to_cpu(tx_cmd->tx_flags);
148 u32 len = skb->len + FCS_LEN;
149 u16 offload_assist = 0;
150 u8 ac;
151
152 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK) ||
153 (ieee80211_is_probe_resp(fc) &&
154 !is_multicast_ether_addr(hdr->addr1)))
155 tx_flags |= TX_CMD_FLG_ACK;
156 else
157 tx_flags &= ~TX_CMD_FLG_ACK;
158
159 if (ieee80211_is_probe_resp(fc))
160 tx_flags |= TX_CMD_FLG_TSF;
161
162 if (ieee80211_has_morefrags(fc))
163 tx_flags |= TX_CMD_FLG_MORE_FRAG;
164
165 if (ieee80211_is_data_qos(fc)) {
166 u8 *qc = ieee80211_get_qos_ctl(hdr);
167 tx_cmd->tid_tspec = qc[0] & 0xf;
168 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
169 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
170 offload_assist |= BIT(TX_CMD_OFFLD_AMSDU);
171 } else if (ieee80211_is_back_req(fc)) {
172 struct ieee80211_bar *bar = (void *)skb->data;
173 u16 control = le16_to_cpu(bar->control);
174 u16 ssn = le16_to_cpu(bar->start_seq_num);
175
176 tx_flags |= TX_CMD_FLG_ACK | TX_CMD_FLG_BAR;
177 tx_cmd->tid_tspec = (control &
178 IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
179 IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
180 WARN_ON_ONCE(tx_cmd->tid_tspec >= IWL_MAX_TID_COUNT);
181 iwl_mvm_bar_check_trigger(mvm, bar->ra, tx_cmd->tid_tspec,
182 ssn);
183 } else {
184 if (ieee80211_is_data(fc))
185 tx_cmd->tid_tspec = IWL_TID_NON_QOS;
186 else
187 tx_cmd->tid_tspec = IWL_MAX_TID_COUNT;
188
189 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
190 tx_flags |= TX_CMD_FLG_SEQ_CTL;
191 else
192 tx_flags &= ~TX_CMD_FLG_SEQ_CTL;
193 }
194
195
196 if (tx_cmd->tid_tspec < IWL_MAX_TID_COUNT)
197 ac = tid_to_mac80211_ac[tx_cmd->tid_tspec];
198 else
199 ac = tid_to_mac80211_ac[0];
200
201 tx_flags |= iwl_mvm_bt_coex_tx_prio(mvm, hdr, info, ac) <<
202 TX_CMD_FLG_BT_PRIO_POS;
203
204 if (ieee80211_is_mgmt(fc)) {
205 if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
206 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_ASSOC);
207 else if (ieee80211_is_action(fc))
208 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_NONE);
209 else
210 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_MGMT);
211
212
213
214
215 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_AMPDU);
216 } else if (info->control.flags & IEEE80211_TX_CTRL_PORT_CTRL_PROTO) {
217 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_MGMT);
218 } else {
219 tx_cmd->pm_frame_timeout = cpu_to_le16(PM_FRAME_NONE);
220 }
221
222 if (ieee80211_is_data(fc) && len > mvm->rts_threshold &&
223 !is_multicast_ether_addr(hdr->addr1))
224 tx_flags |= TX_CMD_FLG_PROT_REQUIRE;
225
226 if (fw_has_capa(&mvm->fw->ucode_capa,
227 IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT) &&
228 ieee80211_action_contains_tpc(skb))
229 tx_flags |= TX_CMD_FLG_WRITE_TX_POWER;
230
231 tx_cmd->tx_flags = cpu_to_le32(tx_flags);
232
233 tx_cmd->len = cpu_to_le16((u16)skb->len);
234 tx_cmd->life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
235 tx_cmd->sta_id = sta_id;
236
237
238 if (ieee80211_hdrlen(fc) % 4 &&
239 !(offload_assist & BIT(TX_CMD_OFFLD_AMSDU)))
240 offload_assist |= BIT(TX_CMD_OFFLD_PAD);
241
242 tx_cmd->offload_assist |=
243 cpu_to_le16(iwl_mvm_tx_csum(mvm, skb, hdr, info,
244 offload_assist));
245}
246
247static u32 iwl_mvm_get_tx_ant(struct iwl_mvm *mvm,
248 struct ieee80211_tx_info *info,
249 struct ieee80211_sta *sta, __le16 fc)
250{
251 if (info->band == NL80211_BAND_2GHZ &&
252 !iwl_mvm_bt_coex_is_shared_ant_avail(mvm))
253 return mvm->cfg->non_shared_ant << RATE_MCS_ANT_POS;
254
255 if (sta && ieee80211_is_data(fc)) {
256 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
257
258 return BIT(mvmsta->tx_ant) << RATE_MCS_ANT_POS;
259 }
260
261 return BIT(mvm->mgmt_last_antenna_idx) << RATE_MCS_ANT_POS;
262}
263
264static u32 iwl_mvm_get_tx_rate(struct iwl_mvm *mvm,
265 struct ieee80211_tx_info *info,
266 struct ieee80211_sta *sta, __le16 fc)
267{
268 int rate_idx = -1;
269 u8 rate_plcp;
270 u32 rate_flags = 0;
271 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
272
273
274 if (!ieee80211_hw_check(mvm->hw, HAS_RATE_CONTROL)) {
275
276 WARN_ONCE(info->control.rates[0].flags & IEEE80211_TX_RC_MCS &&
277 !ieee80211_is_data(fc),
278 "Got a HT rate (flags:0x%x/mcs:%d/fc:0x%x/state:%d) for a non data frame\n",
279 info->control.rates[0].flags,
280 info->control.rates[0].idx,
281 le16_to_cpu(fc), mvmsta->sta_state);
282
283 rate_idx = info->control.rates[0].idx;
284 }
285
286
287 if (rate_idx < 0 || rate_idx >= IWL_RATE_COUNT_LEGACY)
288 rate_idx = rate_lowest_index(
289 &mvm->nvm_data->bands[info->band], sta);
290
291
292
293
294
295 if (info->band != NL80211_BAND_2GHZ)
296 rate_idx += IWL_FIRST_OFDM_RATE;
297
298
299 BUILD_BUG_ON(IWL_FIRST_CCK_RATE != 0);
300
301
302 rate_plcp = iwl_mvm_mac80211_idx_to_hwrate(rate_idx);
303
304
305 if ((rate_idx >= IWL_FIRST_CCK_RATE) && (rate_idx <= IWL_LAST_CCK_RATE))
306 rate_flags |= RATE_MCS_CCK_MSK;
307
308 return (u32)rate_plcp | rate_flags;
309}
310
311static u32 iwl_mvm_get_tx_rate_n_flags(struct iwl_mvm *mvm,
312 struct ieee80211_tx_info *info,
313 struct ieee80211_sta *sta, __le16 fc)
314{
315 return iwl_mvm_get_tx_rate(mvm, info, sta, fc) |
316 iwl_mvm_get_tx_ant(mvm, info, sta, fc);
317}
318
319
320
321
322void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,
323 struct ieee80211_tx_info *info,
324 struct ieee80211_sta *sta, __le16 fc)
325{
326
327 tx_cmd->rts_retry_limit = IWL_RTS_DFAULT_RETRY_LIMIT;
328
329
330 if (ieee80211_is_probe_resp(fc)) {
331 tx_cmd->data_retry_limit = IWL_MGMT_DFAULT_RETRY_LIMIT;
332 tx_cmd->rts_retry_limit =
333 min(tx_cmd->data_retry_limit, tx_cmd->rts_retry_limit);
334 } else if (ieee80211_is_back_req(fc)) {
335 tx_cmd->data_retry_limit = IWL_BAR_DFAULT_RETRY_LIMIT;
336 } else {
337 tx_cmd->data_retry_limit = IWL_DEFAULT_TX_RETRY;
338 }
339
340
341
342
343
344
345 if (ieee80211_is_data(fc) && sta) {
346 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
347
348 if (mvmsta->sta_state >= IEEE80211_STA_AUTHORIZED) {
349 tx_cmd->initial_rate_index = 0;
350 tx_cmd->tx_flags |= cpu_to_le32(TX_CMD_FLG_STA_RATE);
351 return;
352 }
353 } else if (ieee80211_is_back_req(fc)) {
354 tx_cmd->tx_flags |=
355 cpu_to_le32(TX_CMD_FLG_ACK | TX_CMD_FLG_BAR);
356 }
357
358
359 tx_cmd->rate_n_flags =
360 cpu_to_le32(iwl_mvm_get_tx_rate_n_flags(mvm, info, sta, fc));
361}
362
363static inline void iwl_mvm_set_tx_cmd_pn(struct ieee80211_tx_info *info,
364 u8 *crypto_hdr)
365{
366 struct ieee80211_key_conf *keyconf = info->control.hw_key;
367 u64 pn;
368
369 pn = atomic64_inc_return(&keyconf->tx_pn);
370 crypto_hdr[0] = pn;
371 crypto_hdr[2] = 0;
372 crypto_hdr[3] = 0x20 | (keyconf->keyidx << 6);
373 crypto_hdr[1] = pn >> 8;
374 crypto_hdr[4] = pn >> 16;
375 crypto_hdr[5] = pn >> 24;
376 crypto_hdr[6] = pn >> 32;
377 crypto_hdr[7] = pn >> 40;
378}
379
380
381
382
383static void iwl_mvm_set_tx_cmd_crypto(struct iwl_mvm *mvm,
384 struct ieee80211_tx_info *info,
385 struct iwl_tx_cmd *tx_cmd,
386 struct sk_buff *skb_frag,
387 int hdrlen)
388{
389 struct ieee80211_key_conf *keyconf = info->control.hw_key;
390 u8 *crypto_hdr = skb_frag->data + hdrlen;
391 enum iwl_tx_cmd_sec_ctrl type = TX_CMD_SEC_CCM;
392 u64 pn;
393
394 switch (keyconf->cipher) {
395 case WLAN_CIPHER_SUITE_CCMP:
396 iwl_mvm_set_tx_cmd_ccmp(info, tx_cmd);
397 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
398 break;
399
400 case WLAN_CIPHER_SUITE_TKIP:
401 tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
402 pn = atomic64_inc_return(&keyconf->tx_pn);
403 ieee80211_tkip_add_iv(crypto_hdr, keyconf, pn);
404 ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
405 break;
406
407 case WLAN_CIPHER_SUITE_WEP104:
408 tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
409 fallthrough;
410 case WLAN_CIPHER_SUITE_WEP40:
411 tx_cmd->sec_ctl |= TX_CMD_SEC_WEP |
412 ((keyconf->keyidx << TX_CMD_SEC_WEP_KEY_IDX_POS) &
413 TX_CMD_SEC_WEP_KEY_IDX_MSK);
414
415 memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
416 break;
417 case WLAN_CIPHER_SUITE_GCMP:
418 case WLAN_CIPHER_SUITE_GCMP_256:
419 type = TX_CMD_SEC_GCMP;
420 fallthrough;
421 case WLAN_CIPHER_SUITE_CCMP_256:
422
423
424
425
426
427
428 tx_cmd->sec_ctl |= type | TX_CMD_SEC_KEY_FROM_TABLE;
429 tx_cmd->key[0] = keyconf->hw_key_idx;
430 iwl_mvm_set_tx_cmd_pn(info, crypto_hdr);
431 break;
432 default:
433 tx_cmd->sec_ctl |= TX_CMD_SEC_EXT;
434 }
435}
436
437
438
439
440static struct iwl_device_tx_cmd *
441iwl_mvm_set_tx_params(struct iwl_mvm *mvm, struct sk_buff *skb,
442 struct ieee80211_tx_info *info, int hdrlen,
443 struct ieee80211_sta *sta, u8 sta_id)
444{
445 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
446 struct iwl_device_tx_cmd *dev_cmd;
447 struct iwl_tx_cmd *tx_cmd;
448
449 dev_cmd = iwl_trans_alloc_tx_cmd(mvm->trans);
450
451 if (unlikely(!dev_cmd))
452 return NULL;
453
454 dev_cmd->hdr.cmd = TX_CMD;
455
456 if (iwl_mvm_has_new_tx_api(mvm)) {
457 u16 offload_assist = 0;
458 u32 rate_n_flags = 0;
459 u16 flags = 0;
460 struct iwl_mvm_sta *mvmsta = sta ?
461 iwl_mvm_sta_from_mac80211(sta) : NULL;
462
463 if (ieee80211_is_data_qos(hdr->frame_control)) {
464 u8 *qc = ieee80211_get_qos_ctl(hdr);
465
466 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
467 offload_assist |= BIT(TX_CMD_OFFLD_AMSDU);
468 }
469
470 offload_assist = iwl_mvm_tx_csum(mvm, skb, hdr, info,
471 offload_assist);
472
473
474 if (ieee80211_hdrlen(hdr->frame_control) % 4 &&
475 !(offload_assist & BIT(TX_CMD_OFFLD_AMSDU)))
476 offload_assist |= BIT(TX_CMD_OFFLD_PAD);
477
478 if (!info->control.hw_key)
479 flags |= IWL_TX_FLAGS_ENCRYPT_DIS;
480
481
482
483
484
485
486 if (!sta || !ieee80211_is_data(hdr->frame_control) ||
487 mvmsta->sta_state < IEEE80211_STA_AUTHORIZED) {
488 flags |= IWL_TX_FLAGS_CMD_RATE;
489 rate_n_flags =
490 iwl_mvm_get_tx_rate_n_flags(mvm, info, sta,
491 hdr->frame_control);
492 }
493
494 if (mvm->trans->trans_cfg->device_family >=
495 IWL_DEVICE_FAMILY_AX210) {
496 struct iwl_tx_cmd_gen3 *cmd = (void *)dev_cmd->payload;
497
498 cmd->offload_assist |= cpu_to_le32(offload_assist);
499
500
501 cmd->len = cpu_to_le16((u16)skb->len);
502
503
504 memcpy(cmd->hdr, hdr, hdrlen);
505
506 cmd->flags = cpu_to_le16(flags);
507 cmd->rate_n_flags = cpu_to_le32(rate_n_flags);
508 } else {
509 struct iwl_tx_cmd_gen2 *cmd = (void *)dev_cmd->payload;
510
511 cmd->offload_assist |= cpu_to_le16(offload_assist);
512
513
514 cmd->len = cpu_to_le16((u16)skb->len);
515
516
517 memcpy(cmd->hdr, hdr, hdrlen);
518
519 cmd->flags = cpu_to_le32(flags);
520 cmd->rate_n_flags = cpu_to_le32(rate_n_flags);
521 }
522 goto out;
523 }
524
525 tx_cmd = (struct iwl_tx_cmd *)dev_cmd->payload;
526
527 if (info->control.hw_key)
528 iwl_mvm_set_tx_cmd_crypto(mvm, info, tx_cmd, skb, hdrlen);
529
530 iwl_mvm_set_tx_cmd(mvm, skb, tx_cmd, info, sta_id);
531
532 iwl_mvm_set_tx_cmd_rate(mvm, tx_cmd, info, sta, hdr->frame_control);
533
534
535 memcpy(tx_cmd->hdr, hdr, hdrlen);
536
537out:
538 return dev_cmd;
539}
540
541static void iwl_mvm_skb_prepare_status(struct sk_buff *skb,
542 struct iwl_device_tx_cmd *cmd)
543{
544 struct ieee80211_tx_info *skb_info = IEEE80211_SKB_CB(skb);
545
546 memset(&skb_info->status, 0, sizeof(skb_info->status));
547 memset(skb_info->driver_data, 0, sizeof(skb_info->driver_data));
548
549 skb_info->driver_data[1] = cmd;
550}
551
552static int iwl_mvm_get_ctrl_vif_queue(struct iwl_mvm *mvm,
553 struct ieee80211_tx_info *info,
554 struct ieee80211_hdr *hdr)
555{
556 struct iwl_mvm_vif *mvmvif =
557 iwl_mvm_vif_from_mac80211(info->control.vif);
558 __le16 fc = hdr->frame_control;
559
560 switch (info->control.vif->type) {
561 case NL80211_IFTYPE_AP:
562 case NL80211_IFTYPE_ADHOC:
563
564
565
566
567
568
569
570
571
572
573 if (ieee80211_is_mgmt(fc) &&
574 (!ieee80211_is_bufferable_mmpdu(fc) ||
575 ieee80211_is_deauth(fc) || ieee80211_is_disassoc(fc)))
576 return mvm->probe_queue;
577
578 if (!ieee80211_has_order(fc) && !ieee80211_is_probe_req(fc) &&
579 is_multicast_ether_addr(hdr->addr1))
580 return mvmvif->cab_queue;
581
582 WARN_ONCE(info->control.vif->type != NL80211_IFTYPE_ADHOC,
583 "fc=0x%02x", le16_to_cpu(fc));
584 return mvm->probe_queue;
585 case NL80211_IFTYPE_P2P_DEVICE:
586 if (ieee80211_is_mgmt(fc))
587 return mvm->p2p_dev_queue;
588
589 WARN_ON_ONCE(1);
590 return mvm->p2p_dev_queue;
591 default:
592 WARN_ONCE(1, "Not a ctrl vif, no available queue\n");
593 return -1;
594 }
595}
596
597static void iwl_mvm_probe_resp_set_noa(struct iwl_mvm *mvm,
598 struct sk_buff *skb)
599{
600 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
601 struct iwl_mvm_vif *mvmvif =
602 iwl_mvm_vif_from_mac80211(info->control.vif);
603 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
604 int base_len = (u8 *)mgmt->u.probe_resp.variable - (u8 *)mgmt;
605 struct iwl_probe_resp_data *resp_data;
606 u8 *ie, *pos;
607 u8 match[] = {
608 (WLAN_OUI_WFA >> 16) & 0xff,
609 (WLAN_OUI_WFA >> 8) & 0xff,
610 WLAN_OUI_WFA & 0xff,
611 WLAN_OUI_TYPE_WFA_P2P,
612 };
613
614 rcu_read_lock();
615
616 resp_data = rcu_dereference(mvmvif->probe_resp_data);
617 if (!resp_data)
618 goto out;
619
620 if (!resp_data->notif.noa_active)
621 goto out;
622
623 ie = (u8 *)cfg80211_find_ie_match(WLAN_EID_VENDOR_SPECIFIC,
624 mgmt->u.probe_resp.variable,
625 skb->len - base_len,
626 match, 4, 2);
627 if (!ie) {
628 IWL_DEBUG_TX(mvm, "probe resp doesn't have P2P IE\n");
629 goto out;
630 }
631
632 if (skb_tailroom(skb) < resp_data->noa_len) {
633 if (pskb_expand_head(skb, 0, resp_data->noa_len, GFP_ATOMIC)) {
634 IWL_ERR(mvm,
635 "Failed to reallocate probe resp\n");
636 goto out;
637 }
638 }
639
640 pos = skb_put(skb, resp_data->noa_len);
641
642 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
643
644 *pos++ = resp_data->noa_len - 2;
645 *pos++ = (WLAN_OUI_WFA >> 16) & 0xff;
646 *pos++ = (WLAN_OUI_WFA >> 8) & 0xff;
647 *pos++ = WLAN_OUI_WFA & 0xff;
648 *pos++ = WLAN_OUI_TYPE_WFA_P2P;
649
650 memcpy(pos, &resp_data->notif.noa_attr,
651 resp_data->noa_len - sizeof(struct ieee80211_vendor_ie));
652
653out:
654 rcu_read_unlock();
655}
656
657int iwl_mvm_tx_skb_non_sta(struct iwl_mvm *mvm, struct sk_buff *skb)
658{
659 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
660 struct ieee80211_tx_info info;
661 struct iwl_device_tx_cmd *dev_cmd;
662 u8 sta_id;
663 int hdrlen = ieee80211_hdrlen(hdr->frame_control);
664 __le16 fc = hdr->frame_control;
665 bool offchannel = IEEE80211_SKB_CB(skb)->flags &
666 IEEE80211_TX_CTL_TX_OFFCHAN;
667 int queue = -1;
668
669 if (IWL_MVM_NON_TRANSMITTING_AP && ieee80211_is_probe_resp(fc))
670 return -1;
671
672 memcpy(&info, skb->cb, sizeof(info));
673
674 if (WARN_ON_ONCE(skb->len > IEEE80211_MAX_DATA_LEN + hdrlen))
675 return -1;
676
677 if (WARN_ON_ONCE(info.flags & IEEE80211_TX_CTL_AMPDU))
678 return -1;
679
680 if (info.control.vif) {
681 struct iwl_mvm_vif *mvmvif =
682 iwl_mvm_vif_from_mac80211(info.control.vif);
683
684 if (info.control.vif->type == NL80211_IFTYPE_P2P_DEVICE ||
685 info.control.vif->type == NL80211_IFTYPE_AP ||
686 info.control.vif->type == NL80211_IFTYPE_ADHOC) {
687 if (!ieee80211_is_data(hdr->frame_control))
688 sta_id = mvmvif->bcast_sta.sta_id;
689 else
690 sta_id = mvmvif->mcast_sta.sta_id;
691
692 queue = iwl_mvm_get_ctrl_vif_queue(mvm, &info, hdr);
693 } else if (info.control.vif->type == NL80211_IFTYPE_MONITOR) {
694 queue = mvm->snif_queue;
695 sta_id = mvm->snif_sta.sta_id;
696 } else if (info.control.vif->type == NL80211_IFTYPE_STATION &&
697 offchannel) {
698
699
700
701
702
703
704
705
706 sta_id = mvm->aux_sta.sta_id;
707 queue = mvm->aux_queue;
708 }
709 }
710
711 if (queue < 0) {
712 IWL_ERR(mvm, "No queue was found. Dropping TX\n");
713 return -1;
714 }
715
716 if (unlikely(ieee80211_is_probe_resp(fc)))
717 iwl_mvm_probe_resp_set_noa(mvm, skb);
718
719 IWL_DEBUG_TX(mvm, "station Id %d, queue=%d\n", sta_id, queue);
720
721 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, &info, hdrlen, NULL, sta_id);
722 if (!dev_cmd)
723 return -1;
724
725
726 iwl_mvm_skb_prepare_status(skb, dev_cmd);
727
728 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, queue)) {
729 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
730 return -1;
731 }
732
733 return 0;
734}
735
736unsigned int iwl_mvm_max_amsdu_size(struct iwl_mvm *mvm,
737 struct ieee80211_sta *sta, unsigned int tid)
738{
739 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
740 enum nl80211_band band = mvmsta->vif->bss_conf.chandef.chan->band;
741 u8 ac = tid_to_mac80211_ac[tid];
742 unsigned int txf;
743 int lmac = iwl_mvm_get_lmac_id(mvm->fw, band);
744
745
746 if (sta->he_cap.has_he && !WARN_ON(!iwl_mvm_has_new_tx_api(mvm)))
747 ac += 4;
748
749 txf = iwl_mvm_mac_ac_to_tx_fifo(mvm, ac);
750
751
752
753
754
755
756
757 return min_t(unsigned int, mvmsta->max_amsdu_len,
758 mvm->fwrt.smem_cfg.lmac[lmac].txfifo_size[txf] - 256);
759}
760
761#ifdef CONFIG_INET
762
763static int
764iwl_mvm_tx_tso_segment(struct sk_buff *skb, unsigned int num_subframes,
765 netdev_features_t netdev_flags,
766 struct sk_buff_head *mpdus_skb)
767{
768 struct sk_buff *tmp, *next;
769 struct ieee80211_hdr *hdr = (void *)skb->data;
770 char cb[sizeof(skb->cb)];
771 u16 i = 0;
772 unsigned int tcp_payload_len;
773 unsigned int mss = skb_shinfo(skb)->gso_size;
774 bool ipv4 = (skb->protocol == htons(ETH_P_IP));
775 bool qos = ieee80211_is_data_qos(hdr->frame_control);
776 u16 ip_base_id = ipv4 ? ntohs(ip_hdr(skb)->id) : 0;
777
778 skb_shinfo(skb)->gso_size = num_subframes * mss;
779 memcpy(cb, skb->cb, sizeof(cb));
780
781 next = skb_gso_segment(skb, netdev_flags);
782 skb_shinfo(skb)->gso_size = mss;
783 skb_shinfo(skb)->gso_type = ipv4 ? SKB_GSO_TCPV4 : SKB_GSO_TCPV6;
784 if (WARN_ON_ONCE(IS_ERR(next)))
785 return -EINVAL;
786 else if (next)
787 consume_skb(skb);
788
789 skb_list_walk_safe(next, tmp, next) {
790 memcpy(tmp->cb, cb, sizeof(tmp->cb));
791
792
793
794
795
796
797 tcp_payload_len = skb_tail_pointer(tmp) -
798 skb_transport_header(tmp) -
799 tcp_hdrlen(tmp) + tmp->data_len;
800
801 if (ipv4)
802 ip_hdr(tmp)->id = htons(ip_base_id + i * num_subframes);
803
804 if (tcp_payload_len > mss) {
805 skb_shinfo(tmp)->gso_size = mss;
806 skb_shinfo(tmp)->gso_type = ipv4 ? SKB_GSO_TCPV4 :
807 SKB_GSO_TCPV6;
808 } else {
809 if (qos) {
810 u8 *qc;
811
812 if (ipv4)
813 ip_send_check(ip_hdr(tmp));
814
815 qc = ieee80211_get_qos_ctl((void *)tmp->data);
816 *qc &= ~IEEE80211_QOS_CTL_A_MSDU_PRESENT;
817 }
818 skb_shinfo(tmp)->gso_size = 0;
819 }
820
821 skb_mark_not_on_list(tmp);
822 __skb_queue_tail(mpdus_skb, tmp);
823 i++;
824 }
825
826 return 0;
827}
828
829static int iwl_mvm_tx_tso(struct iwl_mvm *mvm, struct sk_buff *skb,
830 struct ieee80211_tx_info *info,
831 struct ieee80211_sta *sta,
832 struct sk_buff_head *mpdus_skb)
833{
834 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
835 struct ieee80211_hdr *hdr = (void *)skb->data;
836 unsigned int mss = skb_shinfo(skb)->gso_size;
837 unsigned int num_subframes, tcp_payload_len, subf_len, max_amsdu_len;
838 u16 snap_ip_tcp, pad;
839 netdev_features_t netdev_flags = NETIF_F_CSUM_MASK | NETIF_F_SG;
840 u8 tid;
841
842 snap_ip_tcp = 8 + skb_transport_header(skb) - skb_network_header(skb) +
843 tcp_hdrlen(skb);
844
845 if (!mvmsta->max_amsdu_len ||
846 !ieee80211_is_data_qos(hdr->frame_control) ||
847 !mvmsta->amsdu_enabled)
848 return iwl_mvm_tx_tso_segment(skb, 1, netdev_flags, mpdus_skb);
849
850
851
852
853
854 if (skb->protocol == htons(ETH_P_IPV6) &&
855 ((struct ipv6hdr *)skb_network_header(skb))->nexthdr !=
856 IPPROTO_TCP) {
857 netdev_flags &= ~NETIF_F_CSUM_MASK;
858 return iwl_mvm_tx_tso_segment(skb, 1, netdev_flags, mpdus_skb);
859 }
860
861 tid = ieee80211_get_tid(hdr);
862 if (WARN_ON_ONCE(tid >= IWL_MAX_TID_COUNT))
863 return -EINVAL;
864
865
866
867
868
869 if ((info->flags & IEEE80211_TX_CTL_AMPDU &&
870 !mvmsta->tid_data[tid].amsdu_in_ampdu_allowed) ||
871 !(mvmsta->amsdu_enabled & BIT(tid)))
872 return iwl_mvm_tx_tso_segment(skb, 1, netdev_flags, mpdus_skb);
873
874
875
876
877 max_amsdu_len =
878 min_t(unsigned int, sta->max_amsdu_len,
879 iwl_mvm_max_amsdu_size(mvm, sta, tid));
880
881
882
883
884
885
886 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
887 !sta->vht_cap.vht_supported)
888 max_amsdu_len = min_t(unsigned int, max_amsdu_len, 4095);
889
890
891 subf_len = sizeof(struct ethhdr) + snap_ip_tcp + mss;
892 pad = (4 - subf_len) & 0x3;
893
894
895
896
897
898 num_subframes = (max_amsdu_len + pad) / (subf_len + pad);
899
900 if (sta->max_amsdu_subframes &&
901 num_subframes > sta->max_amsdu_subframes)
902 num_subframes = sta->max_amsdu_subframes;
903
904 tcp_payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
905 tcp_hdrlen(skb) + skb->data_len;
906
907
908
909
910
911
912
913 if ((num_subframes * 2 + skb_shinfo(skb)->nr_frags + 1) >
914 mvm->trans->max_skb_frags)
915 num_subframes = 1;
916
917 if (num_subframes > 1)
918 *ieee80211_get_qos_ctl(hdr) |= IEEE80211_QOS_CTL_A_MSDU_PRESENT;
919
920
921 if (num_subframes * mss >= tcp_payload_len) {
922 __skb_queue_tail(mpdus_skb, skb);
923 return 0;
924 }
925
926
927
928
929
930 return iwl_mvm_tx_tso_segment(skb, num_subframes, netdev_flags,
931 mpdus_skb);
932}
933#else
934static int iwl_mvm_tx_tso(struct iwl_mvm *mvm, struct sk_buff *skb,
935 struct ieee80211_tx_info *info,
936 struct ieee80211_sta *sta,
937 struct sk_buff_head *mpdus_skb)
938{
939
940 WARN_ON(1);
941
942 return -1;
943}
944#endif
945
946
947static bool iwl_mvm_txq_should_update(struct iwl_mvm *mvm, int txq_id)
948{
949 unsigned long queue_tid_bitmap = mvm->queue_info[txq_id].tid_bitmap;
950 unsigned long now = jiffies;
951 int tid;
952
953 if (WARN_ON(iwl_mvm_has_new_tx_api(mvm)))
954 return false;
955
956 for_each_set_bit(tid, &queue_tid_bitmap, IWL_MAX_TID_COUNT + 1) {
957 if (time_before(mvm->queue_info[txq_id].last_frame_time[tid] +
958 IWL_MVM_DQA_QUEUE_TIMEOUT, now))
959 return true;
960 }
961
962 return false;
963}
964
965static void iwl_mvm_tx_airtime(struct iwl_mvm *mvm,
966 struct iwl_mvm_sta *mvmsta,
967 int airtime)
968{
969 int mac = mvmsta->mac_id_n_color & FW_CTXT_ID_MSK;
970 struct iwl_mvm_tcm_mac *mdata;
971
972 if (mac >= NUM_MAC_INDEX_DRIVER)
973 return;
974
975 mdata = &mvm->tcm.data[mac];
976
977 if (mvm->tcm.paused)
978 return;
979
980 if (time_after(jiffies, mvm->tcm.ts + MVM_TCM_PERIOD))
981 schedule_delayed_work(&mvm->tcm.work, 0);
982
983 mdata->tx.airtime += airtime;
984}
985
986static int iwl_mvm_tx_pkt_queued(struct iwl_mvm *mvm,
987 struct iwl_mvm_sta *mvmsta, int tid)
988{
989 u32 ac = tid_to_mac80211_ac[tid];
990 int mac = mvmsta->mac_id_n_color & FW_CTXT_ID_MSK;
991 struct iwl_mvm_tcm_mac *mdata;
992
993 if (mac >= NUM_MAC_INDEX_DRIVER)
994 return -EINVAL;
995
996 mdata = &mvm->tcm.data[mac];
997
998 mdata->tx.pkts[ac]++;
999
1000 return 0;
1001}
1002
1003
1004
1005
1006
1007
1008static int iwl_mvm_tx_mpdu(struct iwl_mvm *mvm, struct sk_buff *skb,
1009 struct ieee80211_tx_info *info,
1010 struct ieee80211_sta *sta)
1011{
1012 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1013 struct iwl_mvm_sta *mvmsta;
1014 struct iwl_device_tx_cmd *dev_cmd;
1015 __le16 fc;
1016 u16 seq_number = 0;
1017 u8 tid = IWL_MAX_TID_COUNT;
1018 u16 txq_id;
1019 bool is_ampdu = false;
1020 int hdrlen;
1021
1022 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1023 fc = hdr->frame_control;
1024 hdrlen = ieee80211_hdrlen(fc);
1025
1026 if (IWL_MVM_NON_TRANSMITTING_AP && ieee80211_is_probe_resp(fc))
1027 return -1;
1028
1029 if (WARN_ON_ONCE(!mvmsta))
1030 return -1;
1031
1032 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_MVM_INVALID_STA))
1033 return -1;
1034
1035 if (unlikely(ieee80211_is_any_nullfunc(fc)) && sta->he_cap.has_he)
1036 return -1;
1037
1038 if (unlikely(ieee80211_is_probe_resp(fc)))
1039 iwl_mvm_probe_resp_set_noa(mvm, skb);
1040
1041 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, info, hdrlen,
1042 sta, mvmsta->sta_id);
1043 if (!dev_cmd)
1044 goto drop;
1045
1046
1047
1048
1049
1050
1051 info->flags &= ~IEEE80211_TX_STATUS_EOSP;
1052
1053 spin_lock(&mvmsta->lock);
1054
1055
1056
1057
1058
1059 if (ieee80211_is_data_qos(fc) && !ieee80211_is_qos_nullfunc(fc)) {
1060 tid = ieee80211_get_tid(hdr);
1061 if (WARN_ONCE(tid >= IWL_MAX_TID_COUNT, "Invalid TID %d", tid))
1062 goto drop_unlock_sta;
1063
1064 is_ampdu = info->flags & IEEE80211_TX_CTL_AMPDU;
1065 if (WARN_ONCE(is_ampdu &&
1066 mvmsta->tid_data[tid].state != IWL_AGG_ON,
1067 "Invalid internal agg state %d for TID %d",
1068 mvmsta->tid_data[tid].state, tid))
1069 goto drop_unlock_sta;
1070
1071 seq_number = mvmsta->tid_data[tid].seq_number;
1072 seq_number &= IEEE80211_SCTL_SEQ;
1073
1074 if (!iwl_mvm_has_new_tx_api(mvm)) {
1075 struct iwl_tx_cmd *tx_cmd = (void *)dev_cmd->payload;
1076
1077 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
1078 hdr->seq_ctrl |= cpu_to_le16(seq_number);
1079
1080 tx_cmd->hdr->seq_ctrl = hdr->seq_ctrl;
1081 }
1082 } else if (ieee80211_is_data(fc) && !ieee80211_is_data_qos(fc)) {
1083 tid = IWL_TID_NON_QOS;
1084 }
1085
1086 txq_id = mvmsta->tid_data[tid].txq_id;
1087
1088 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
1089
1090 if (WARN_ONCE(txq_id == IWL_MVM_INVALID_QUEUE, "Invalid TXQ id")) {
1091 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
1092 spin_unlock(&mvmsta->lock);
1093 return -1;
1094 }
1095
1096 if (!iwl_mvm_has_new_tx_api(mvm)) {
1097
1098 mvm->queue_info[txq_id].last_frame_time[tid] = jiffies;
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110 if (unlikely(mvm->queue_info[txq_id].status ==
1111 IWL_MVM_QUEUE_SHARED &&
1112 iwl_mvm_txq_should_update(mvm, txq_id)))
1113 schedule_work(&mvm->add_stream_wk);
1114 }
1115
1116 IWL_DEBUG_TX(mvm, "TX to [%d|%d] Q:%d - seq: 0x%x len %d\n",
1117 mvmsta->sta_id, tid, txq_id,
1118 IEEE80211_SEQ_TO_SN(seq_number), skb->len);
1119
1120
1121 iwl_mvm_skb_prepare_status(skb, dev_cmd);
1122
1123 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, txq_id))
1124 goto drop_unlock_sta;
1125
1126 if (tid < IWL_MAX_TID_COUNT && !ieee80211_has_morefrags(fc))
1127 mvmsta->tid_data[tid].seq_number = seq_number + 0x10;
1128
1129 spin_unlock(&mvmsta->lock);
1130
1131 if (iwl_mvm_tx_pkt_queued(mvm, mvmsta,
1132 tid == IWL_MAX_TID_COUNT ? 0 : tid))
1133 goto drop;
1134
1135 return 0;
1136
1137drop_unlock_sta:
1138 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
1139 spin_unlock(&mvmsta->lock);
1140drop:
1141 IWL_DEBUG_TX(mvm, "TX to [%d|%d] dropped\n", mvmsta->sta_id, tid);
1142 return -1;
1143}
1144
1145int iwl_mvm_tx_skb_sta(struct iwl_mvm *mvm, struct sk_buff *skb,
1146 struct ieee80211_sta *sta)
1147{
1148 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1149 struct ieee80211_tx_info info;
1150 struct sk_buff_head mpdus_skbs;
1151 unsigned int payload_len;
1152 int ret;
1153
1154 if (WARN_ON_ONCE(!mvmsta))
1155 return -1;
1156
1157 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_MVM_INVALID_STA))
1158 return -1;
1159
1160 memcpy(&info, skb->cb, sizeof(info));
1161
1162 if (!skb_is_gso(skb))
1163 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1164
1165 payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
1166 tcp_hdrlen(skb) + skb->data_len;
1167
1168 if (payload_len <= skb_shinfo(skb)->gso_size)
1169 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1170
1171 __skb_queue_head_init(&mpdus_skbs);
1172
1173 ret = iwl_mvm_tx_tso(mvm, skb, &info, sta, &mpdus_skbs);
1174 if (ret)
1175 return ret;
1176
1177 if (WARN_ON(skb_queue_empty(&mpdus_skbs)))
1178 return ret;
1179
1180 while (!skb_queue_empty(&mpdus_skbs)) {
1181 skb = __skb_dequeue(&mpdus_skbs);
1182
1183 ret = iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1184 if (ret) {
1185 __skb_queue_purge(&mpdus_skbs);
1186 return ret;
1187 }
1188 }
1189
1190 return 0;
1191}
1192
1193static void iwl_mvm_check_ratid_empty(struct iwl_mvm *mvm,
1194 struct ieee80211_sta *sta, u8 tid)
1195{
1196 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1197 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
1198 struct ieee80211_vif *vif = mvmsta->vif;
1199 u16 normalized_ssn;
1200
1201 lockdep_assert_held(&mvmsta->lock);
1202
1203 if ((tid_data->state == IWL_AGG_ON ||
1204 tid_data->state == IWL_EMPTYING_HW_QUEUE_DELBA) &&
1205 iwl_mvm_tid_queued(mvm, tid_data) == 0) {
1206
1207
1208
1209
1210
1211 ieee80211_sta_set_buffered(sta, tid, false);
1212 }
1213
1214
1215
1216
1217
1218 normalized_ssn = tid_data->ssn;
1219 if (mvm->trans->trans_cfg->gen2)
1220 normalized_ssn &= 0xff;
1221
1222 if (normalized_ssn != tid_data->next_reclaimed)
1223 return;
1224
1225 switch (tid_data->state) {
1226 case IWL_EMPTYING_HW_QUEUE_ADDBA:
1227 IWL_DEBUG_TX_QUEUES(mvm,
1228 "Can continue addBA flow ssn = next_recl = %d\n",
1229 tid_data->next_reclaimed);
1230 tid_data->state = IWL_AGG_STARTING;
1231 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1232 break;
1233
1234 case IWL_EMPTYING_HW_QUEUE_DELBA:
1235 IWL_DEBUG_TX_QUEUES(mvm,
1236 "Can continue DELBA flow ssn = next_recl = %d\n",
1237 tid_data->next_reclaimed);
1238 tid_data->state = IWL_AGG_OFF;
1239 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1240 break;
1241
1242 default:
1243 break;
1244 }
1245}
1246
1247#ifdef CONFIG_IWLWIFI_DEBUG
1248const char *iwl_mvm_get_tx_fail_reason(u32 status)
1249{
1250#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
1251#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
1252
1253 switch (status & TX_STATUS_MSK) {
1254 case TX_STATUS_SUCCESS:
1255 return "SUCCESS";
1256 TX_STATUS_POSTPONE(DELAY);
1257 TX_STATUS_POSTPONE(FEW_BYTES);
1258 TX_STATUS_POSTPONE(BT_PRIO);
1259 TX_STATUS_POSTPONE(QUIET_PERIOD);
1260 TX_STATUS_POSTPONE(CALC_TTAK);
1261 TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
1262 TX_STATUS_FAIL(SHORT_LIMIT);
1263 TX_STATUS_FAIL(LONG_LIMIT);
1264 TX_STATUS_FAIL(UNDERRUN);
1265 TX_STATUS_FAIL(DRAIN_FLOW);
1266 TX_STATUS_FAIL(RFKILL_FLUSH);
1267 TX_STATUS_FAIL(LIFE_EXPIRE);
1268 TX_STATUS_FAIL(DEST_PS);
1269 TX_STATUS_FAIL(HOST_ABORTED);
1270 TX_STATUS_FAIL(BT_RETRY);
1271 TX_STATUS_FAIL(STA_INVALID);
1272 TX_STATUS_FAIL(FRAG_DROPPED);
1273 TX_STATUS_FAIL(TID_DISABLE);
1274 TX_STATUS_FAIL(FIFO_FLUSHED);
1275 TX_STATUS_FAIL(SMALL_CF_POLL);
1276 TX_STATUS_FAIL(FW_DROP);
1277 TX_STATUS_FAIL(STA_COLOR_MISMATCH);
1278 }
1279
1280 return "UNKNOWN";
1281
1282#undef TX_STATUS_FAIL
1283#undef TX_STATUS_POSTPONE
1284}
1285#endif
1286
1287void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
1288 enum nl80211_band band,
1289 struct ieee80211_tx_rate *r)
1290{
1291 if (rate_n_flags & RATE_HT_MCS_GF_MSK)
1292 r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
1293 switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) {
1294 case RATE_MCS_CHAN_WIDTH_20:
1295 break;
1296 case RATE_MCS_CHAN_WIDTH_40:
1297 r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
1298 break;
1299 case RATE_MCS_CHAN_WIDTH_80:
1300 r->flags |= IEEE80211_TX_RC_80_MHZ_WIDTH;
1301 break;
1302 case RATE_MCS_CHAN_WIDTH_160:
1303 r->flags |= IEEE80211_TX_RC_160_MHZ_WIDTH;
1304 break;
1305 }
1306 if (rate_n_flags & RATE_MCS_SGI_MSK)
1307 r->flags |= IEEE80211_TX_RC_SHORT_GI;
1308 if (rate_n_flags & RATE_MCS_HT_MSK) {
1309 r->flags |= IEEE80211_TX_RC_MCS;
1310 r->idx = rate_n_flags & RATE_HT_MCS_INDEX_MSK;
1311 } else if (rate_n_flags & RATE_MCS_VHT_MSK) {
1312 ieee80211_rate_set_vht(
1313 r, rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK,
1314 ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >>
1315 RATE_VHT_MCS_NSS_POS) + 1);
1316 r->flags |= IEEE80211_TX_RC_VHT_MCS;
1317 } else {
1318 r->idx = iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags,
1319 band);
1320 }
1321}
1322
1323
1324
1325
1326static void iwl_mvm_hwrate_to_tx_status(u32 rate_n_flags,
1327 struct ieee80211_tx_info *info)
1328{
1329 struct ieee80211_tx_rate *r = &info->status.rates[0];
1330
1331 info->status.antenna =
1332 ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
1333 iwl_mvm_hwrate_to_tx_rate(rate_n_flags, info->band, r);
1334}
1335
1336static void iwl_mvm_tx_status_check_trigger(struct iwl_mvm *mvm,
1337 u32 status, __le16 frame_control)
1338{
1339 struct iwl_fw_dbg_trigger_tlv *trig;
1340 struct iwl_fw_dbg_trigger_tx_status *status_trig;
1341 int i;
1342
1343 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS) {
1344 enum iwl_fw_ini_time_point tp =
1345 IWL_FW_INI_TIME_POINT_TX_FAILED;
1346
1347 if (ieee80211_is_action(frame_control))
1348 tp = IWL_FW_INI_TIME_POINT_TX_WFD_ACTION_FRAME_FAILED;
1349
1350 iwl_dbg_tlv_time_point(&mvm->fwrt,
1351 tp, NULL);
1352 return;
1353 }
1354
1355 trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, NULL,
1356 FW_DBG_TRIGGER_TX_STATUS);
1357 if (!trig)
1358 return;
1359
1360 status_trig = (void *)trig->data;
1361
1362 for (i = 0; i < ARRAY_SIZE(status_trig->statuses); i++) {
1363
1364 if (!status_trig->statuses[i].status)
1365 break;
1366
1367 if (status_trig->statuses[i].status != (status & TX_STATUS_MSK))
1368 continue;
1369
1370 iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
1371 "Tx status %d was received",
1372 status & TX_STATUS_MSK);
1373 break;
1374 }
1375}
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390static inline u32 iwl_mvm_get_scd_ssn(struct iwl_mvm *mvm,
1391 struct iwl_mvm_tx_resp *tx_resp)
1392{
1393 return le32_to_cpup((__le32 *)iwl_mvm_get_agg_status(mvm, tx_resp) +
1394 tx_resp->frame_count) & 0xfff;
1395}
1396
1397static void iwl_mvm_rx_tx_cmd_single(struct iwl_mvm *mvm,
1398 struct iwl_rx_packet *pkt)
1399{
1400 struct ieee80211_sta *sta;
1401 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1402 int txq_id = SEQ_TO_QUEUE(sequence);
1403
1404 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1405 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1406 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1407 struct agg_tx_status *agg_status =
1408 iwl_mvm_get_agg_status(mvm, tx_resp);
1409 u32 status = le16_to_cpu(agg_status->status);
1410 u16 ssn = iwl_mvm_get_scd_ssn(mvm, tx_resp);
1411 struct sk_buff_head skbs;
1412 u8 skb_freed = 0;
1413 u8 lq_color;
1414 u16 next_reclaimed, seq_ctl;
1415 bool is_ndp = false;
1416
1417 __skb_queue_head_init(&skbs);
1418
1419 if (iwl_mvm_has_new_tx_api(mvm))
1420 txq_id = le16_to_cpu(tx_resp->tx_queue);
1421
1422 seq_ctl = le16_to_cpu(tx_resp->seq_ctl);
1423
1424
1425 iwl_trans_reclaim(mvm->trans, txq_id, ssn, &skbs);
1426
1427 while (!skb_queue_empty(&skbs)) {
1428 struct sk_buff *skb = __skb_dequeue(&skbs);
1429 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1430 struct ieee80211_hdr *hdr = (void *)skb->data;
1431 bool flushed = false;
1432
1433 skb_freed++;
1434
1435 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1436
1437 memset(&info->status, 0, sizeof(info->status));
1438
1439
1440 switch (status & TX_STATUS_MSK) {
1441 case TX_STATUS_SUCCESS:
1442 case TX_STATUS_DIRECT_DONE:
1443 info->flags |= IEEE80211_TX_STAT_ACK;
1444 break;
1445 case TX_STATUS_FAIL_FIFO_FLUSHED:
1446 case TX_STATUS_FAIL_DRAIN_FLOW:
1447 flushed = true;
1448 break;
1449 case TX_STATUS_FAIL_DEST_PS:
1450
1451
1452
1453 WARN_ON(1);
1454 info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
1455 break;
1456 default:
1457 break;
1458 }
1459
1460 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS &&
1461 ieee80211_is_mgmt(hdr->frame_control))
1462 iwl_mvm_toggle_tx_ant(mvm, &mvm->mgmt_last_antenna_idx);
1463
1464
1465
1466
1467
1468
1469 if (skb_freed > 1)
1470 info->flags |= IEEE80211_TX_STAT_ACK;
1471
1472 iwl_mvm_tx_status_check_trigger(mvm, status, hdr->frame_control);
1473
1474 info->status.rates[0].count = tx_resp->failure_frame + 1;
1475 iwl_mvm_hwrate_to_tx_status(le32_to_cpu(tx_resp->initial_rate),
1476 info);
1477 info->status.status_driver_data[1] =
1478 (void *)(uintptr_t)le32_to_cpu(tx_resp->initial_rate);
1479
1480
1481 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
1482 !(info->flags & IEEE80211_TX_STAT_ACK) &&
1483 !(info->flags & IEEE80211_TX_STAT_TX_FILTERED) && !flushed)
1484 info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
1485 info->flags &= ~IEEE80211_TX_CTL_AMPDU;
1486
1487
1488 if (ieee80211_is_back_req(hdr->frame_control))
1489 seq_ctl = 0;
1490 else if (status != TX_STATUS_SUCCESS)
1491 seq_ctl = le16_to_cpu(hdr->seq_ctrl);
1492
1493 if (unlikely(!seq_ctl)) {
1494 struct ieee80211_hdr *hdr = (void *)skb->data;
1495
1496
1497
1498
1499
1500
1501
1502
1503 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
1504 is_ndp = true;
1505 }
1506
1507
1508
1509
1510
1511 info->status.tx_time =
1512 le16_to_cpu(tx_resp->wireless_media_time);
1513 BUILD_BUG_ON(ARRAY_SIZE(info->status.status_driver_data) < 1);
1514 lq_color = TX_RES_RATE_TABLE_COL_GET(tx_resp->tlc_info);
1515 info->status.status_driver_data[0] =
1516 RS_DRV_DATA_PACK(lq_color, tx_resp->reduced_tpc);
1517
1518 ieee80211_tx_status(mvm->hw, skb);
1519 }
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535 next_reclaimed = ssn;
1536
1537 IWL_DEBUG_TX_REPLY(mvm,
1538 "TXQ %d status %s (0x%08x)\n",
1539 txq_id, iwl_mvm_get_tx_fail_reason(status), status);
1540
1541 IWL_DEBUG_TX_REPLY(mvm,
1542 "\t\t\t\tinitial_rate 0x%x retries %d, idx=%d ssn=%d next_reclaimed=0x%x seq_ctl=0x%x\n",
1543 le32_to_cpu(tx_resp->initial_rate),
1544 tx_resp->failure_frame, SEQ_TO_INDEX(sequence),
1545 ssn, next_reclaimed, seq_ctl);
1546
1547 rcu_read_lock();
1548
1549 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1550
1551
1552
1553
1554 if (WARN_ON_ONCE(!sta))
1555 goto out;
1556
1557 if (!IS_ERR(sta)) {
1558 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1559
1560 iwl_mvm_tx_airtime(mvm, mvmsta,
1561 le16_to_cpu(tx_resp->wireless_media_time));
1562
1563 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS &&
1564 mvmsta->sta_state < IEEE80211_STA_AUTHORIZED)
1565 iwl_mvm_toggle_tx_ant(mvm, &mvmsta->tx_ant);
1566
1567 if (sta->wme && tid != IWL_MGMT_TID) {
1568 struct iwl_mvm_tid_data *tid_data =
1569 &mvmsta->tid_data[tid];
1570 bool send_eosp_ndp = false;
1571
1572 spin_lock_bh(&mvmsta->lock);
1573
1574 if (!is_ndp) {
1575 tid_data->next_reclaimed = next_reclaimed;
1576 IWL_DEBUG_TX_REPLY(mvm,
1577 "Next reclaimed packet:%d\n",
1578 next_reclaimed);
1579 } else {
1580 IWL_DEBUG_TX_REPLY(mvm,
1581 "NDP - don't update next_reclaimed\n");
1582 }
1583
1584 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1585
1586 if (mvmsta->sleep_tx_count) {
1587 mvmsta->sleep_tx_count--;
1588 if (mvmsta->sleep_tx_count &&
1589 !iwl_mvm_tid_queued(mvm, tid_data)) {
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603 send_eosp_ndp = true;
1604 }
1605 }
1606
1607 spin_unlock_bh(&mvmsta->lock);
1608 if (send_eosp_ndp) {
1609 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta,
1610 IEEE80211_FRAME_RELEASE_UAPSD,
1611 1, tid, false, false);
1612 mvmsta->sleep_tx_count = 0;
1613 ieee80211_send_eosp_nullfunc(sta, tid);
1614 }
1615 }
1616
1617 if (mvmsta->next_status_eosp) {
1618 mvmsta->next_status_eosp = false;
1619 ieee80211_sta_eosp(sta);
1620 }
1621 }
1622out:
1623 rcu_read_unlock();
1624}
1625
1626#ifdef CONFIG_IWLWIFI_DEBUG
1627#define AGG_TX_STATE_(x) case AGG_TX_STATE_ ## x: return #x
1628static const char *iwl_get_agg_tx_status(u16 status)
1629{
1630 switch (status & AGG_TX_STATE_STATUS_MSK) {
1631 AGG_TX_STATE_(TRANSMITTED);
1632 AGG_TX_STATE_(UNDERRUN);
1633 AGG_TX_STATE_(BT_PRIO);
1634 AGG_TX_STATE_(FEW_BYTES);
1635 AGG_TX_STATE_(ABORT);
1636 AGG_TX_STATE_(TX_ON_AIR_DROP);
1637 AGG_TX_STATE_(LAST_SENT_TRY_CNT);
1638 AGG_TX_STATE_(LAST_SENT_BT_KILL);
1639 AGG_TX_STATE_(SCD_QUERY);
1640 AGG_TX_STATE_(TEST_BAD_CRC32);
1641 AGG_TX_STATE_(RESPONSE);
1642 AGG_TX_STATE_(DUMP_TX);
1643 AGG_TX_STATE_(DELAY_TX);
1644 }
1645
1646 return "UNKNOWN";
1647}
1648
1649static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1650 struct iwl_rx_packet *pkt)
1651{
1652 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1653 struct agg_tx_status *frame_status =
1654 iwl_mvm_get_agg_status(mvm, tx_resp);
1655 int i;
1656 bool tirgger_timepoint = false;
1657
1658 for (i = 0; i < tx_resp->frame_count; i++) {
1659 u16 fstatus = le16_to_cpu(frame_status[i].status);
1660
1661 tirgger_timepoint |= ((fstatus & AGG_TX_STATE_STATUS_MSK) !=
1662 AGG_TX_STATE_TRANSMITTED);
1663 IWL_DEBUG_TX_REPLY(mvm,
1664 "status %s (0x%04x), try-count (%d) seq (0x%x)\n",
1665 iwl_get_agg_tx_status(fstatus),
1666 fstatus & AGG_TX_STATE_STATUS_MSK,
1667 (fstatus & AGG_TX_STATE_TRY_CNT_MSK) >>
1668 AGG_TX_STATE_TRY_CNT_POS,
1669 le16_to_cpu(frame_status[i].sequence));
1670 }
1671
1672 if (tirgger_timepoint)
1673 iwl_dbg_tlv_time_point(&mvm->fwrt,
1674 IWL_FW_INI_TIME_POINT_TX_FAILED, NULL);
1675
1676}
1677#else
1678static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1679 struct iwl_rx_packet *pkt)
1680{}
1681#endif
1682
1683static void iwl_mvm_rx_tx_cmd_agg(struct iwl_mvm *mvm,
1684 struct iwl_rx_packet *pkt)
1685{
1686 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1687 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1688 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1689 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1690 struct iwl_mvm_sta *mvmsta;
1691 int queue = SEQ_TO_QUEUE(sequence);
1692 struct ieee80211_sta *sta;
1693
1694 if (WARN_ON_ONCE(queue < IWL_MVM_DQA_MIN_DATA_QUEUE &&
1695 (queue != IWL_MVM_DQA_BSS_CLIENT_QUEUE)))
1696 return;
1697
1698 iwl_mvm_rx_tx_cmd_agg_dbg(mvm, pkt);
1699
1700 rcu_read_lock();
1701
1702 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1703
1704 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1705 if (WARN_ON_ONCE(!sta || !sta->wme)) {
1706 rcu_read_unlock();
1707 return;
1708 }
1709
1710 if (!WARN_ON_ONCE(!mvmsta)) {
1711 mvmsta->tid_data[tid].rate_n_flags =
1712 le32_to_cpu(tx_resp->initial_rate);
1713 mvmsta->tid_data[tid].tx_time =
1714 le16_to_cpu(tx_resp->wireless_media_time);
1715 mvmsta->tid_data[tid].lq_color =
1716 TX_RES_RATE_TABLE_COL_GET(tx_resp->tlc_info);
1717 iwl_mvm_tx_airtime(mvm, mvmsta,
1718 le16_to_cpu(tx_resp->wireless_media_time));
1719 }
1720
1721 rcu_read_unlock();
1722}
1723
1724void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1725{
1726 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1727 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1728
1729 if (tx_resp->frame_count == 1)
1730 iwl_mvm_rx_tx_cmd_single(mvm, pkt);
1731 else
1732 iwl_mvm_rx_tx_cmd_agg(mvm, pkt);
1733}
1734
1735static void iwl_mvm_tx_reclaim(struct iwl_mvm *mvm, int sta_id, int tid,
1736 int txq, int index,
1737 struct ieee80211_tx_info *tx_info, u32 rate,
1738 bool is_flush)
1739{
1740 struct sk_buff_head reclaimed_skbs;
1741 struct iwl_mvm_tid_data *tid_data = NULL;
1742 struct ieee80211_sta *sta;
1743 struct iwl_mvm_sta *mvmsta = NULL;
1744 struct sk_buff *skb;
1745 int freed;
1746
1747 if (WARN_ONCE(sta_id >= mvm->fw->ucode_capa.num_stations ||
1748 tid > IWL_MAX_TID_COUNT,
1749 "sta_id %d tid %d", sta_id, tid))
1750 return;
1751
1752 rcu_read_lock();
1753
1754 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1755
1756
1757 if (WARN_ON_ONCE(!sta)) {
1758 rcu_read_unlock();
1759 return;
1760 }
1761
1762 __skb_queue_head_init(&reclaimed_skbs);
1763
1764
1765
1766
1767
1768
1769 iwl_trans_reclaim(mvm->trans, txq, index, &reclaimed_skbs);
1770
1771 skb_queue_walk(&reclaimed_skbs, skb) {
1772 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1773
1774 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1775
1776 memset(&info->status, 0, sizeof(info->status));
1777
1778
1779
1780
1781 if (!is_flush)
1782 info->flags |= IEEE80211_TX_STAT_ACK;
1783 }
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793 if (IS_ERR(sta))
1794 goto out;
1795
1796 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1797 tid_data = &mvmsta->tid_data[tid];
1798
1799 if (tid_data->txq_id != txq) {
1800 IWL_ERR(mvm,
1801 "invalid reclaim request: Q %d, tid %d\n",
1802 tid_data->txq_id, tid);
1803 rcu_read_unlock();
1804 return;
1805 }
1806
1807 spin_lock_bh(&mvmsta->lock);
1808
1809 tid_data->next_reclaimed = index;
1810
1811 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1812
1813 freed = 0;
1814
1815
1816 tx_info->status.status_driver_data[0] =
1817 RS_DRV_DATA_PACK(tid_data->lq_color,
1818 tx_info->status.status_driver_data[0]);
1819 tx_info->status.status_driver_data[1] = (void *)(uintptr_t)rate;
1820
1821 skb_queue_walk(&reclaimed_skbs, skb) {
1822 struct ieee80211_hdr *hdr = (void *)skb->data;
1823 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1824
1825 if (!is_flush) {
1826 if (ieee80211_is_data_qos(hdr->frame_control))
1827 freed++;
1828 else
1829 WARN_ON_ONCE(tid != IWL_MAX_TID_COUNT);
1830 }
1831
1832
1833
1834 if (freed == 1) {
1835 info->flags |= IEEE80211_TX_STAT_AMPDU;
1836 memcpy(&info->status, &tx_info->status,
1837 sizeof(tx_info->status));
1838 iwl_mvm_hwrate_to_tx_status(rate, info);
1839 }
1840 }
1841
1842 spin_unlock_bh(&mvmsta->lock);
1843
1844
1845
1846
1847
1848 if (!is_flush && skb_queue_empty(&reclaimed_skbs)) {
1849 struct ieee80211_chanctx_conf *chanctx_conf = NULL;
1850
1851 if (mvmsta->vif)
1852 chanctx_conf =
1853 rcu_dereference(mvmsta->vif->chanctx_conf);
1854
1855 if (WARN_ON_ONCE(!chanctx_conf))
1856 goto out;
1857
1858 tx_info->band = chanctx_conf->def.chan->band;
1859 iwl_mvm_hwrate_to_tx_status(rate, tx_info);
1860
1861 if (!iwl_mvm_has_tlc_offload(mvm)) {
1862 IWL_DEBUG_TX_REPLY(mvm,
1863 "No reclaim. Update rs directly\n");
1864 iwl_mvm_rs_tx_status(mvm, sta, tid, tx_info, false);
1865 }
1866 }
1867
1868out:
1869 rcu_read_unlock();
1870
1871 while (!skb_queue_empty(&reclaimed_skbs)) {
1872 skb = __skb_dequeue(&reclaimed_skbs);
1873 ieee80211_tx_status(mvm->hw, skb);
1874 }
1875}
1876
1877void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1878{
1879 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1880 unsigned int pkt_len = iwl_rx_packet_payload_len(pkt);
1881 int sta_id, tid, txq, index;
1882 struct ieee80211_tx_info ba_info = {};
1883 struct iwl_mvm_ba_notif *ba_notif;
1884 struct iwl_mvm_tid_data *tid_data;
1885 struct iwl_mvm_sta *mvmsta;
1886
1887 ba_info.flags = IEEE80211_TX_STAT_AMPDU;
1888
1889 if (iwl_mvm_has_new_tx_api(mvm)) {
1890 struct iwl_mvm_compressed_ba_notif *ba_res =
1891 (void *)pkt->data;
1892 u8 lq_color = TX_RES_RATE_TABLE_COL_GET(ba_res->tlc_rate_info);
1893 u16 tfd_cnt;
1894 int i;
1895
1896 if (unlikely(sizeof(*ba_res) > pkt_len))
1897 return;
1898
1899 sta_id = ba_res->sta_id;
1900 ba_info.status.ampdu_ack_len = (u8)le16_to_cpu(ba_res->done);
1901 ba_info.status.ampdu_len = (u8)le16_to_cpu(ba_res->txed);
1902 ba_info.status.tx_time =
1903 (u16)le32_to_cpu(ba_res->wireless_time);
1904 ba_info.status.status_driver_data[0] =
1905 (void *)(uintptr_t)ba_res->reduced_txp;
1906
1907 tfd_cnt = le16_to_cpu(ba_res->tfd_cnt);
1908 if (!tfd_cnt || struct_size(ba_res, tfd, tfd_cnt) > pkt_len)
1909 return;
1910
1911 rcu_read_lock();
1912
1913 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924 for (i = 0; i < tfd_cnt; i++) {
1925 struct iwl_mvm_compressed_ba_tfd *ba_tfd =
1926 &ba_res->tfd[i];
1927
1928 tid = ba_tfd->tid;
1929 if (tid == IWL_MGMT_TID)
1930 tid = IWL_MAX_TID_COUNT;
1931
1932 if (mvmsta)
1933 mvmsta->tid_data[i].lq_color = lq_color;
1934
1935 iwl_mvm_tx_reclaim(mvm, sta_id, tid,
1936 (int)(le16_to_cpu(ba_tfd->q_num)),
1937 le16_to_cpu(ba_tfd->tfd_index),
1938 &ba_info,
1939 le32_to_cpu(ba_res->tx_rate), false);
1940 }
1941
1942 if (mvmsta)
1943 iwl_mvm_tx_airtime(mvm, mvmsta,
1944 le32_to_cpu(ba_res->wireless_time));
1945 rcu_read_unlock();
1946
1947 IWL_DEBUG_TX_REPLY(mvm,
1948 "BA_NOTIFICATION Received from sta_id = %d, flags %x, sent:%d, acked:%d\n",
1949 sta_id, le32_to_cpu(ba_res->flags),
1950 le16_to_cpu(ba_res->txed),
1951 le16_to_cpu(ba_res->done));
1952 return;
1953 }
1954
1955 ba_notif = (void *)pkt->data;
1956 sta_id = ba_notif->sta_id;
1957 tid = ba_notif->tid;
1958
1959 txq = le16_to_cpu(ba_notif->scd_flow);
1960
1961
1962 index = le16_to_cpu(ba_notif->scd_ssn);
1963
1964 rcu_read_lock();
1965 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1966 if (WARN_ON_ONCE(!mvmsta)) {
1967 rcu_read_unlock();
1968 return;
1969 }
1970
1971 tid_data = &mvmsta->tid_data[tid];
1972
1973 ba_info.status.ampdu_ack_len = ba_notif->txed_2_done;
1974 ba_info.status.ampdu_len = ba_notif->txed;
1975 ba_info.status.tx_time = tid_data->tx_time;
1976 ba_info.status.status_driver_data[0] =
1977 (void *)(uintptr_t)ba_notif->reduced_txp;
1978
1979 rcu_read_unlock();
1980
1981 iwl_mvm_tx_reclaim(mvm, sta_id, tid, txq, index, &ba_info,
1982 tid_data->rate_n_flags, false);
1983
1984 IWL_DEBUG_TX_REPLY(mvm,
1985 "BA_NOTIFICATION Received from %pM, sta_id = %d\n",
1986 ba_notif->sta_addr, ba_notif->sta_id);
1987
1988 IWL_DEBUG_TX_REPLY(mvm,
1989 "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = %d, scd_ssn = %d sent:%d, acked:%d\n",
1990 ba_notif->tid, le16_to_cpu(ba_notif->seq_ctl),
1991 le64_to_cpu(ba_notif->bitmap), txq, index,
1992 ba_notif->txed, ba_notif->txed_2_done);
1993
1994 IWL_DEBUG_TX_REPLY(mvm, "reduced txp from ba notif %d\n",
1995 ba_notif->reduced_txp);
1996}
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk)
2007{
2008 int ret;
2009 struct iwl_tx_path_flush_cmd_v1 flush_cmd = {
2010 .queues_ctl = cpu_to_le32(tfd_msk),
2011 .flush_ctl = cpu_to_le16(DUMP_TX_FIFO_FLUSH),
2012 };
2013
2014 WARN_ON(iwl_mvm_has_new_tx_api(mvm));
2015 ret = iwl_mvm_send_cmd_pdu(mvm, TXPATH_FLUSH, 0,
2016 sizeof(flush_cmd), &flush_cmd);
2017 if (ret)
2018 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
2019 return ret;
2020}
2021
2022int iwl_mvm_flush_sta_tids(struct iwl_mvm *mvm, u32 sta_id, u16 tids)
2023{
2024 int ret;
2025 struct iwl_tx_path_flush_cmd_rsp *rsp;
2026 struct iwl_tx_path_flush_cmd flush_cmd = {
2027 .sta_id = cpu_to_le32(sta_id),
2028 .tid_mask = cpu_to_le16(tids),
2029 };
2030
2031 struct iwl_host_cmd cmd = {
2032 .id = TXPATH_FLUSH,
2033 .len = { sizeof(flush_cmd), },
2034 .data = { &flush_cmd, },
2035 };
2036
2037 WARN_ON(!iwl_mvm_has_new_tx_api(mvm));
2038
2039 if (iwl_fw_lookup_notif_ver(mvm->fw, LONG_GROUP, TXPATH_FLUSH, 0) > 0)
2040 cmd.flags |= CMD_WANT_SKB;
2041
2042 IWL_DEBUG_TX_QUEUES(mvm, "flush for sta id %d tid mask 0x%x\n",
2043 sta_id, tids);
2044
2045 ret = iwl_mvm_send_cmd(mvm, &cmd);
2046
2047 if (ret) {
2048 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
2049 return ret;
2050 }
2051
2052 if (cmd.flags & CMD_WANT_SKB) {
2053 int i;
2054 int num_flushed_queues;
2055
2056 if (WARN_ON_ONCE(iwl_rx_packet_payload_len(cmd.resp_pkt) != sizeof(*rsp))) {
2057 ret = -EIO;
2058 goto free_rsp;
2059 }
2060
2061 rsp = (void *)cmd.resp_pkt->data;
2062
2063 if (WARN_ONCE(le16_to_cpu(rsp->sta_id) != sta_id,
2064 "sta_id %d != rsp_sta_id %d",
2065 sta_id, le16_to_cpu(rsp->sta_id))) {
2066 ret = -EIO;
2067 goto free_rsp;
2068 }
2069
2070 num_flushed_queues = le16_to_cpu(rsp->num_flushed_queues);
2071 if (WARN_ONCE(num_flushed_queues > IWL_TX_FLUSH_QUEUE_RSP,
2072 "num_flushed_queues %d", num_flushed_queues)) {
2073 ret = -EIO;
2074 goto free_rsp;
2075 }
2076
2077 for (i = 0; i < num_flushed_queues; i++) {
2078 struct ieee80211_tx_info tx_info = {};
2079 struct iwl_flush_queue_info *queue_info = &rsp->queues[i];
2080 int tid = le16_to_cpu(queue_info->tid);
2081 int read_before = le16_to_cpu(queue_info->read_before_flush);
2082 int read_after = le16_to_cpu(queue_info->read_after_flush);
2083 int queue_num = le16_to_cpu(queue_info->queue_num);
2084
2085 if (tid == IWL_MGMT_TID)
2086 tid = IWL_MAX_TID_COUNT;
2087
2088 IWL_DEBUG_TX_QUEUES(mvm,
2089 "tid %d queue_id %d read-before %d read-after %d\n",
2090 tid, queue_num, read_before, read_after);
2091
2092 iwl_mvm_tx_reclaim(mvm, sta_id, tid, queue_num, read_after,
2093 &tx_info, 0, true);
2094 }
2095free_rsp:
2096 iwl_free_resp(&cmd);
2097 }
2098 return ret;
2099}
2100
2101int iwl_mvm_flush_sta(struct iwl_mvm *mvm, void *sta, bool internal)
2102{
2103 struct iwl_mvm_int_sta *int_sta = sta;
2104 struct iwl_mvm_sta *mvm_sta = sta;
2105
2106 BUILD_BUG_ON(offsetof(struct iwl_mvm_int_sta, sta_id) !=
2107 offsetof(struct iwl_mvm_sta, sta_id));
2108
2109 if (iwl_mvm_has_new_tx_api(mvm))
2110 return iwl_mvm_flush_sta_tids(mvm, mvm_sta->sta_id, 0xffff);
2111
2112 if (internal)
2113 return iwl_mvm_flush_tx_path(mvm, int_sta->tfd_queue_msk);
2114
2115 return iwl_mvm_flush_tx_path(mvm, mvm_sta->tfd_queue_msk);
2116}
2117