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_probe_resp(fc)))
1036 iwl_mvm_probe_resp_set_noa(mvm, skb);
1037
1038 dev_cmd = iwl_mvm_set_tx_params(mvm, skb, info, hdrlen,
1039 sta, mvmsta->sta_id);
1040 if (!dev_cmd)
1041 goto drop;
1042
1043
1044
1045
1046
1047
1048 info->flags &= ~IEEE80211_TX_STATUS_EOSP;
1049
1050 spin_lock(&mvmsta->lock);
1051
1052
1053
1054
1055
1056 if (ieee80211_is_data_qos(fc) && !ieee80211_is_qos_nullfunc(fc)) {
1057 tid = ieee80211_get_tid(hdr);
1058 if (WARN_ONCE(tid >= IWL_MAX_TID_COUNT, "Invalid TID %d", tid))
1059 goto drop_unlock_sta;
1060
1061 is_ampdu = info->flags & IEEE80211_TX_CTL_AMPDU;
1062 if (WARN_ONCE(is_ampdu &&
1063 mvmsta->tid_data[tid].state != IWL_AGG_ON,
1064 "Invalid internal agg state %d for TID %d",
1065 mvmsta->tid_data[tid].state, tid))
1066 goto drop_unlock_sta;
1067
1068 seq_number = mvmsta->tid_data[tid].seq_number;
1069 seq_number &= IEEE80211_SCTL_SEQ;
1070
1071 if (!iwl_mvm_has_new_tx_api(mvm)) {
1072 struct iwl_tx_cmd *tx_cmd = (void *)dev_cmd->payload;
1073
1074 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
1075 hdr->seq_ctrl |= cpu_to_le16(seq_number);
1076
1077 tx_cmd->hdr->seq_ctrl = hdr->seq_ctrl;
1078 }
1079 } else if (ieee80211_is_data(fc) && !ieee80211_is_data_qos(fc)) {
1080 tid = IWL_TID_NON_QOS;
1081 }
1082
1083 txq_id = mvmsta->tid_data[tid].txq_id;
1084
1085 WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
1086
1087 if (WARN_ONCE(txq_id == IWL_MVM_INVALID_QUEUE, "Invalid TXQ id")) {
1088 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
1089 spin_unlock(&mvmsta->lock);
1090 return -1;
1091 }
1092
1093 if (!iwl_mvm_has_new_tx_api(mvm)) {
1094
1095 mvm->queue_info[txq_id].last_frame_time[tid] = jiffies;
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107 if (unlikely(mvm->queue_info[txq_id].status ==
1108 IWL_MVM_QUEUE_SHARED &&
1109 iwl_mvm_txq_should_update(mvm, txq_id)))
1110 schedule_work(&mvm->add_stream_wk);
1111 }
1112
1113 IWL_DEBUG_TX(mvm, "TX to [%d|%d] Q:%d - seq: 0x%x len %d\n",
1114 mvmsta->sta_id, tid, txq_id,
1115 IEEE80211_SEQ_TO_SN(seq_number), skb->len);
1116
1117
1118 iwl_mvm_skb_prepare_status(skb, dev_cmd);
1119
1120 if (iwl_trans_tx(mvm->trans, skb, dev_cmd, txq_id))
1121 goto drop_unlock_sta;
1122
1123 if (tid < IWL_MAX_TID_COUNT && !ieee80211_has_morefrags(fc))
1124 mvmsta->tid_data[tid].seq_number = seq_number + 0x10;
1125
1126 spin_unlock(&mvmsta->lock);
1127
1128 if (iwl_mvm_tx_pkt_queued(mvm, mvmsta,
1129 tid == IWL_MAX_TID_COUNT ? 0 : tid))
1130 goto drop;
1131
1132 return 0;
1133
1134drop_unlock_sta:
1135 iwl_trans_free_tx_cmd(mvm->trans, dev_cmd);
1136 spin_unlock(&mvmsta->lock);
1137drop:
1138 IWL_DEBUG_TX(mvm, "TX to [%d|%d] dropped\n", mvmsta->sta_id, tid);
1139 return -1;
1140}
1141
1142int iwl_mvm_tx_skb_sta(struct iwl_mvm *mvm, struct sk_buff *skb,
1143 struct ieee80211_sta *sta)
1144{
1145 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1146 struct ieee80211_tx_info info;
1147 struct sk_buff_head mpdus_skbs;
1148 unsigned int payload_len;
1149 int ret;
1150
1151 if (WARN_ON_ONCE(!mvmsta))
1152 return -1;
1153
1154 if (WARN_ON_ONCE(mvmsta->sta_id == IWL_MVM_INVALID_STA))
1155 return -1;
1156
1157 memcpy(&info, skb->cb, sizeof(info));
1158
1159 if (!skb_is_gso(skb))
1160 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1161
1162 payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
1163 tcp_hdrlen(skb) + skb->data_len;
1164
1165 if (payload_len <= skb_shinfo(skb)->gso_size)
1166 return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1167
1168 __skb_queue_head_init(&mpdus_skbs);
1169
1170 ret = iwl_mvm_tx_tso(mvm, skb, &info, sta, &mpdus_skbs);
1171 if (ret)
1172 return ret;
1173
1174 if (WARN_ON(skb_queue_empty(&mpdus_skbs)))
1175 return ret;
1176
1177 while (!skb_queue_empty(&mpdus_skbs)) {
1178 skb = __skb_dequeue(&mpdus_skbs);
1179
1180 ret = iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
1181 if (ret) {
1182 __skb_queue_purge(&mpdus_skbs);
1183 return ret;
1184 }
1185 }
1186
1187 return 0;
1188}
1189
1190static void iwl_mvm_check_ratid_empty(struct iwl_mvm *mvm,
1191 struct ieee80211_sta *sta, u8 tid)
1192{
1193 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1194 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
1195 struct ieee80211_vif *vif = mvmsta->vif;
1196 u16 normalized_ssn;
1197
1198 lockdep_assert_held(&mvmsta->lock);
1199
1200 if ((tid_data->state == IWL_AGG_ON ||
1201 tid_data->state == IWL_EMPTYING_HW_QUEUE_DELBA) &&
1202 iwl_mvm_tid_queued(mvm, tid_data) == 0) {
1203
1204
1205
1206
1207
1208 ieee80211_sta_set_buffered(sta, tid, false);
1209 }
1210
1211
1212
1213
1214
1215 normalized_ssn = tid_data->ssn;
1216 if (mvm->trans->trans_cfg->gen2)
1217 normalized_ssn &= 0xff;
1218
1219 if (normalized_ssn != tid_data->next_reclaimed)
1220 return;
1221
1222 switch (tid_data->state) {
1223 case IWL_EMPTYING_HW_QUEUE_ADDBA:
1224 IWL_DEBUG_TX_QUEUES(mvm,
1225 "Can continue addBA flow ssn = next_recl = %d\n",
1226 tid_data->next_reclaimed);
1227 tid_data->state = IWL_AGG_STARTING;
1228 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1229 break;
1230
1231 case IWL_EMPTYING_HW_QUEUE_DELBA:
1232 IWL_DEBUG_TX_QUEUES(mvm,
1233 "Can continue DELBA flow ssn = next_recl = %d\n",
1234 tid_data->next_reclaimed);
1235 tid_data->state = IWL_AGG_OFF;
1236 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1237 break;
1238
1239 default:
1240 break;
1241 }
1242}
1243
1244#ifdef CONFIG_IWLWIFI_DEBUG
1245const char *iwl_mvm_get_tx_fail_reason(u32 status)
1246{
1247#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
1248#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
1249
1250 switch (status & TX_STATUS_MSK) {
1251 case TX_STATUS_SUCCESS:
1252 return "SUCCESS";
1253 TX_STATUS_POSTPONE(DELAY);
1254 TX_STATUS_POSTPONE(FEW_BYTES);
1255 TX_STATUS_POSTPONE(BT_PRIO);
1256 TX_STATUS_POSTPONE(QUIET_PERIOD);
1257 TX_STATUS_POSTPONE(CALC_TTAK);
1258 TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
1259 TX_STATUS_FAIL(SHORT_LIMIT);
1260 TX_STATUS_FAIL(LONG_LIMIT);
1261 TX_STATUS_FAIL(UNDERRUN);
1262 TX_STATUS_FAIL(DRAIN_FLOW);
1263 TX_STATUS_FAIL(RFKILL_FLUSH);
1264 TX_STATUS_FAIL(LIFE_EXPIRE);
1265 TX_STATUS_FAIL(DEST_PS);
1266 TX_STATUS_FAIL(HOST_ABORTED);
1267 TX_STATUS_FAIL(BT_RETRY);
1268 TX_STATUS_FAIL(STA_INVALID);
1269 TX_STATUS_FAIL(FRAG_DROPPED);
1270 TX_STATUS_FAIL(TID_DISABLE);
1271 TX_STATUS_FAIL(FIFO_FLUSHED);
1272 TX_STATUS_FAIL(SMALL_CF_POLL);
1273 TX_STATUS_FAIL(FW_DROP);
1274 TX_STATUS_FAIL(STA_COLOR_MISMATCH);
1275 }
1276
1277 return "UNKNOWN";
1278
1279#undef TX_STATUS_FAIL
1280#undef TX_STATUS_POSTPONE
1281}
1282#endif
1283
1284void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
1285 enum nl80211_band band,
1286 struct ieee80211_tx_rate *r)
1287{
1288 if (rate_n_flags & RATE_HT_MCS_GF_MSK)
1289 r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
1290 switch (rate_n_flags & RATE_MCS_CHAN_WIDTH_MSK) {
1291 case RATE_MCS_CHAN_WIDTH_20:
1292 break;
1293 case RATE_MCS_CHAN_WIDTH_40:
1294 r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
1295 break;
1296 case RATE_MCS_CHAN_WIDTH_80:
1297 r->flags |= IEEE80211_TX_RC_80_MHZ_WIDTH;
1298 break;
1299 case RATE_MCS_CHAN_WIDTH_160:
1300 r->flags |= IEEE80211_TX_RC_160_MHZ_WIDTH;
1301 break;
1302 }
1303 if (rate_n_flags & RATE_MCS_SGI_MSK)
1304 r->flags |= IEEE80211_TX_RC_SHORT_GI;
1305 if (rate_n_flags & RATE_MCS_HT_MSK) {
1306 r->flags |= IEEE80211_TX_RC_MCS;
1307 r->idx = rate_n_flags & RATE_HT_MCS_INDEX_MSK;
1308 } else if (rate_n_flags & RATE_MCS_VHT_MSK) {
1309 ieee80211_rate_set_vht(
1310 r, rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK,
1311 ((rate_n_flags & RATE_VHT_MCS_NSS_MSK) >>
1312 RATE_VHT_MCS_NSS_POS) + 1);
1313 r->flags |= IEEE80211_TX_RC_VHT_MCS;
1314 } else {
1315 r->idx = iwl_mvm_legacy_rate_to_mac80211_idx(rate_n_flags,
1316 band);
1317 }
1318}
1319
1320
1321
1322
1323static void iwl_mvm_hwrate_to_tx_status(u32 rate_n_flags,
1324 struct ieee80211_tx_info *info)
1325{
1326 struct ieee80211_tx_rate *r = &info->status.rates[0];
1327
1328 info->status.antenna =
1329 ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
1330 iwl_mvm_hwrate_to_tx_rate(rate_n_flags, info->band, r);
1331}
1332
1333static void iwl_mvm_tx_status_check_trigger(struct iwl_mvm *mvm,
1334 u32 status, __le16 frame_control)
1335{
1336 struct iwl_fw_dbg_trigger_tlv *trig;
1337 struct iwl_fw_dbg_trigger_tx_status *status_trig;
1338 int i;
1339
1340 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS) {
1341 enum iwl_fw_ini_time_point tp =
1342 IWL_FW_INI_TIME_POINT_TX_FAILED;
1343
1344 if (ieee80211_is_action(frame_control))
1345 tp = IWL_FW_INI_TIME_POINT_TX_WFD_ACTION_FRAME_FAILED;
1346
1347 iwl_dbg_tlv_time_point(&mvm->fwrt,
1348 tp, NULL);
1349 return;
1350 }
1351
1352 trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, NULL,
1353 FW_DBG_TRIGGER_TX_STATUS);
1354 if (!trig)
1355 return;
1356
1357 status_trig = (void *)trig->data;
1358
1359 for (i = 0; i < ARRAY_SIZE(status_trig->statuses); i++) {
1360
1361 if (!status_trig->statuses[i].status)
1362 break;
1363
1364 if (status_trig->statuses[i].status != (status & TX_STATUS_MSK))
1365 continue;
1366
1367 iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
1368 "Tx status %d was received",
1369 status & TX_STATUS_MSK);
1370 break;
1371 }
1372}
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387static inline u32 iwl_mvm_get_scd_ssn(struct iwl_mvm *mvm,
1388 struct iwl_mvm_tx_resp *tx_resp)
1389{
1390 return le32_to_cpup((__le32 *)iwl_mvm_get_agg_status(mvm, tx_resp) +
1391 tx_resp->frame_count) & 0xfff;
1392}
1393
1394static void iwl_mvm_rx_tx_cmd_single(struct iwl_mvm *mvm,
1395 struct iwl_rx_packet *pkt)
1396{
1397 struct ieee80211_sta *sta;
1398 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1399 int txq_id = SEQ_TO_QUEUE(sequence);
1400
1401 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1402 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1403 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1404 struct agg_tx_status *agg_status =
1405 iwl_mvm_get_agg_status(mvm, tx_resp);
1406 u32 status = le16_to_cpu(agg_status->status);
1407 u16 ssn = iwl_mvm_get_scd_ssn(mvm, tx_resp);
1408 struct sk_buff_head skbs;
1409 u8 skb_freed = 0;
1410 u8 lq_color;
1411 u16 next_reclaimed, seq_ctl;
1412 bool is_ndp = false;
1413
1414 __skb_queue_head_init(&skbs);
1415
1416 if (iwl_mvm_has_new_tx_api(mvm))
1417 txq_id = le16_to_cpu(tx_resp->tx_queue);
1418
1419 seq_ctl = le16_to_cpu(tx_resp->seq_ctl);
1420
1421
1422 iwl_trans_reclaim(mvm->trans, txq_id, ssn, &skbs);
1423
1424 while (!skb_queue_empty(&skbs)) {
1425 struct sk_buff *skb = __skb_dequeue(&skbs);
1426 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1427 struct ieee80211_hdr *hdr = (void *)skb->data;
1428 bool flushed = false;
1429
1430 skb_freed++;
1431
1432 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1433
1434 memset(&info->status, 0, sizeof(info->status));
1435
1436
1437 switch (status & TX_STATUS_MSK) {
1438 case TX_STATUS_SUCCESS:
1439 case TX_STATUS_DIRECT_DONE:
1440 info->flags |= IEEE80211_TX_STAT_ACK;
1441 break;
1442 case TX_STATUS_FAIL_FIFO_FLUSHED:
1443 case TX_STATUS_FAIL_DRAIN_FLOW:
1444 flushed = true;
1445 break;
1446 case TX_STATUS_FAIL_DEST_PS:
1447
1448
1449
1450 WARN_ON(1);
1451 info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
1452 break;
1453 default:
1454 break;
1455 }
1456
1457 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS &&
1458 ieee80211_is_mgmt(hdr->frame_control))
1459 iwl_mvm_toggle_tx_ant(mvm, &mvm->mgmt_last_antenna_idx);
1460
1461
1462
1463
1464
1465
1466 if (skb_freed > 1)
1467 info->flags |= IEEE80211_TX_STAT_ACK;
1468
1469 iwl_mvm_tx_status_check_trigger(mvm, status, hdr->frame_control);
1470
1471 info->status.rates[0].count = tx_resp->failure_frame + 1;
1472 iwl_mvm_hwrate_to_tx_status(le32_to_cpu(tx_resp->initial_rate),
1473 info);
1474 info->status.status_driver_data[1] =
1475 (void *)(uintptr_t)le32_to_cpu(tx_resp->initial_rate);
1476
1477
1478 if (info->flags & IEEE80211_TX_CTL_AMPDU &&
1479 !(info->flags & IEEE80211_TX_STAT_ACK) &&
1480 !(info->flags & IEEE80211_TX_STAT_TX_FILTERED) && !flushed)
1481 info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
1482 info->flags &= ~IEEE80211_TX_CTL_AMPDU;
1483
1484
1485 if (ieee80211_is_back_req(hdr->frame_control))
1486 seq_ctl = 0;
1487 else if (status != TX_STATUS_SUCCESS)
1488 seq_ctl = le16_to_cpu(hdr->seq_ctrl);
1489
1490 if (unlikely(!seq_ctl)) {
1491 struct ieee80211_hdr *hdr = (void *)skb->data;
1492
1493
1494
1495
1496
1497
1498
1499
1500 if (ieee80211_is_qos_nullfunc(hdr->frame_control))
1501 is_ndp = true;
1502 }
1503
1504
1505
1506
1507
1508 info->status.tx_time =
1509 le16_to_cpu(tx_resp->wireless_media_time);
1510 BUILD_BUG_ON(ARRAY_SIZE(info->status.status_driver_data) < 1);
1511 lq_color = TX_RES_RATE_TABLE_COL_GET(tx_resp->tlc_info);
1512 info->status.status_driver_data[0] =
1513 RS_DRV_DATA_PACK(lq_color, tx_resp->reduced_tpc);
1514
1515 ieee80211_tx_status(mvm->hw, skb);
1516 }
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532 next_reclaimed = ssn;
1533
1534 IWL_DEBUG_TX_REPLY(mvm,
1535 "TXQ %d status %s (0x%08x)\n",
1536 txq_id, iwl_mvm_get_tx_fail_reason(status), status);
1537
1538 IWL_DEBUG_TX_REPLY(mvm,
1539 "\t\t\t\tinitial_rate 0x%x retries %d, idx=%d ssn=%d next_reclaimed=0x%x seq_ctl=0x%x\n",
1540 le32_to_cpu(tx_resp->initial_rate),
1541 tx_resp->failure_frame, SEQ_TO_INDEX(sequence),
1542 ssn, next_reclaimed, seq_ctl);
1543
1544 rcu_read_lock();
1545
1546 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1547
1548
1549
1550
1551 if (WARN_ON_ONCE(!sta))
1552 goto out;
1553
1554 if (!IS_ERR(sta)) {
1555 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1556
1557 iwl_mvm_tx_airtime(mvm, mvmsta,
1558 le16_to_cpu(tx_resp->wireless_media_time));
1559
1560 if ((status & TX_STATUS_MSK) != TX_STATUS_SUCCESS &&
1561 mvmsta->sta_state < IEEE80211_STA_AUTHORIZED)
1562 iwl_mvm_toggle_tx_ant(mvm, &mvmsta->tx_ant);
1563
1564 if (sta->wme && tid != IWL_MGMT_TID) {
1565 struct iwl_mvm_tid_data *tid_data =
1566 &mvmsta->tid_data[tid];
1567 bool send_eosp_ndp = false;
1568
1569 spin_lock_bh(&mvmsta->lock);
1570
1571 if (!is_ndp) {
1572 tid_data->next_reclaimed = next_reclaimed;
1573 IWL_DEBUG_TX_REPLY(mvm,
1574 "Next reclaimed packet:%d\n",
1575 next_reclaimed);
1576 } else {
1577 IWL_DEBUG_TX_REPLY(mvm,
1578 "NDP - don't update next_reclaimed\n");
1579 }
1580
1581 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1582
1583 if (mvmsta->sleep_tx_count) {
1584 mvmsta->sleep_tx_count--;
1585 if (mvmsta->sleep_tx_count &&
1586 !iwl_mvm_tid_queued(mvm, tid_data)) {
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600 send_eosp_ndp = true;
1601 }
1602 }
1603
1604 spin_unlock_bh(&mvmsta->lock);
1605 if (send_eosp_ndp) {
1606 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta,
1607 IEEE80211_FRAME_RELEASE_UAPSD,
1608 1, tid, false, false);
1609 mvmsta->sleep_tx_count = 0;
1610 ieee80211_send_eosp_nullfunc(sta, tid);
1611 }
1612 }
1613
1614 if (mvmsta->next_status_eosp) {
1615 mvmsta->next_status_eosp = false;
1616 ieee80211_sta_eosp(sta);
1617 }
1618 }
1619out:
1620 rcu_read_unlock();
1621}
1622
1623#ifdef CONFIG_IWLWIFI_DEBUG
1624#define AGG_TX_STATE_(x) case AGG_TX_STATE_ ## x: return #x
1625static const char *iwl_get_agg_tx_status(u16 status)
1626{
1627 switch (status & AGG_TX_STATE_STATUS_MSK) {
1628 AGG_TX_STATE_(TRANSMITTED);
1629 AGG_TX_STATE_(UNDERRUN);
1630 AGG_TX_STATE_(BT_PRIO);
1631 AGG_TX_STATE_(FEW_BYTES);
1632 AGG_TX_STATE_(ABORT);
1633 AGG_TX_STATE_(TX_ON_AIR_DROP);
1634 AGG_TX_STATE_(LAST_SENT_TRY_CNT);
1635 AGG_TX_STATE_(LAST_SENT_BT_KILL);
1636 AGG_TX_STATE_(SCD_QUERY);
1637 AGG_TX_STATE_(TEST_BAD_CRC32);
1638 AGG_TX_STATE_(RESPONSE);
1639 AGG_TX_STATE_(DUMP_TX);
1640 AGG_TX_STATE_(DELAY_TX);
1641 }
1642
1643 return "UNKNOWN";
1644}
1645
1646static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1647 struct iwl_rx_packet *pkt)
1648{
1649 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1650 struct agg_tx_status *frame_status =
1651 iwl_mvm_get_agg_status(mvm, tx_resp);
1652 int i;
1653 bool tirgger_timepoint = false;
1654
1655 for (i = 0; i < tx_resp->frame_count; i++) {
1656 u16 fstatus = le16_to_cpu(frame_status[i].status);
1657
1658 tirgger_timepoint |= ((fstatus & AGG_TX_STATE_STATUS_MSK) !=
1659 AGG_TX_STATE_TRANSMITTED);
1660 IWL_DEBUG_TX_REPLY(mvm,
1661 "status %s (0x%04x), try-count (%d) seq (0x%x)\n",
1662 iwl_get_agg_tx_status(fstatus),
1663 fstatus & AGG_TX_STATE_STATUS_MSK,
1664 (fstatus & AGG_TX_STATE_TRY_CNT_MSK) >>
1665 AGG_TX_STATE_TRY_CNT_POS,
1666 le16_to_cpu(frame_status[i].sequence));
1667 }
1668
1669 if (tirgger_timepoint)
1670 iwl_dbg_tlv_time_point(&mvm->fwrt,
1671 IWL_FW_INI_TIME_POINT_TX_FAILED, NULL);
1672
1673}
1674#else
1675static void iwl_mvm_rx_tx_cmd_agg_dbg(struct iwl_mvm *mvm,
1676 struct iwl_rx_packet *pkt)
1677{}
1678#endif
1679
1680static void iwl_mvm_rx_tx_cmd_agg(struct iwl_mvm *mvm,
1681 struct iwl_rx_packet *pkt)
1682{
1683 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1684 int sta_id = IWL_MVM_TX_RES_GET_RA(tx_resp->ra_tid);
1685 int tid = IWL_MVM_TX_RES_GET_TID(tx_resp->ra_tid);
1686 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
1687 struct iwl_mvm_sta *mvmsta;
1688 int queue = SEQ_TO_QUEUE(sequence);
1689 struct ieee80211_sta *sta;
1690
1691 if (WARN_ON_ONCE(queue < IWL_MVM_DQA_MIN_DATA_QUEUE &&
1692 (queue != IWL_MVM_DQA_BSS_CLIENT_QUEUE)))
1693 return;
1694
1695 iwl_mvm_rx_tx_cmd_agg_dbg(mvm, pkt);
1696
1697 rcu_read_lock();
1698
1699 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1700
1701 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1702 if (WARN_ON_ONCE(!sta || !sta->wme)) {
1703 rcu_read_unlock();
1704 return;
1705 }
1706
1707 if (!WARN_ON_ONCE(!mvmsta)) {
1708 mvmsta->tid_data[tid].rate_n_flags =
1709 le32_to_cpu(tx_resp->initial_rate);
1710 mvmsta->tid_data[tid].tx_time =
1711 le16_to_cpu(tx_resp->wireless_media_time);
1712 mvmsta->tid_data[tid].lq_color =
1713 TX_RES_RATE_TABLE_COL_GET(tx_resp->tlc_info);
1714 iwl_mvm_tx_airtime(mvm, mvmsta,
1715 le16_to_cpu(tx_resp->wireless_media_time));
1716 }
1717
1718 rcu_read_unlock();
1719}
1720
1721void iwl_mvm_rx_tx_cmd(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1722{
1723 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1724 struct iwl_mvm_tx_resp *tx_resp = (void *)pkt->data;
1725
1726 if (tx_resp->frame_count == 1)
1727 iwl_mvm_rx_tx_cmd_single(mvm, pkt);
1728 else
1729 iwl_mvm_rx_tx_cmd_agg(mvm, pkt);
1730}
1731
1732static void iwl_mvm_tx_reclaim(struct iwl_mvm *mvm, int sta_id, int tid,
1733 int txq, int index,
1734 struct ieee80211_tx_info *tx_info, u32 rate,
1735 bool is_flush)
1736{
1737 struct sk_buff_head reclaimed_skbs;
1738 struct iwl_mvm_tid_data *tid_data = NULL;
1739 struct ieee80211_sta *sta;
1740 struct iwl_mvm_sta *mvmsta = NULL;
1741 struct sk_buff *skb;
1742 int freed;
1743
1744 if (WARN_ONCE(sta_id >= mvm->fw->ucode_capa.num_stations ||
1745 tid > IWL_MAX_TID_COUNT,
1746 "sta_id %d tid %d", sta_id, tid))
1747 return;
1748
1749 rcu_read_lock();
1750
1751 sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);
1752
1753
1754 if (WARN_ON_ONCE(!sta)) {
1755 rcu_read_unlock();
1756 return;
1757 }
1758
1759 __skb_queue_head_init(&reclaimed_skbs);
1760
1761
1762
1763
1764
1765
1766 iwl_trans_reclaim(mvm->trans, txq, index, &reclaimed_skbs);
1767
1768 skb_queue_walk(&reclaimed_skbs, skb) {
1769 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1770
1771 iwl_trans_free_tx_cmd(mvm->trans, info->driver_data[1]);
1772
1773 memset(&info->status, 0, sizeof(info->status));
1774
1775
1776
1777
1778 if (!is_flush)
1779 info->flags |= IEEE80211_TX_STAT_ACK;
1780 }
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790 if (IS_ERR(sta))
1791 goto out;
1792
1793 mvmsta = iwl_mvm_sta_from_mac80211(sta);
1794 tid_data = &mvmsta->tid_data[tid];
1795
1796 if (tid_data->txq_id != txq) {
1797 IWL_ERR(mvm,
1798 "invalid reclaim request: Q %d, tid %d\n",
1799 tid_data->txq_id, tid);
1800 rcu_read_unlock();
1801 return;
1802 }
1803
1804 spin_lock_bh(&mvmsta->lock);
1805
1806 tid_data->next_reclaimed = index;
1807
1808 iwl_mvm_check_ratid_empty(mvm, sta, tid);
1809
1810 freed = 0;
1811
1812
1813 tx_info->status.status_driver_data[0] =
1814 RS_DRV_DATA_PACK(tid_data->lq_color,
1815 tx_info->status.status_driver_data[0]);
1816 tx_info->status.status_driver_data[1] = (void *)(uintptr_t)rate;
1817
1818 skb_queue_walk(&reclaimed_skbs, skb) {
1819 struct ieee80211_hdr *hdr = (void *)skb->data;
1820 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1821
1822 if (!is_flush) {
1823 if (ieee80211_is_data_qos(hdr->frame_control))
1824 freed++;
1825 else
1826 WARN_ON_ONCE(tid != IWL_MAX_TID_COUNT);
1827 }
1828
1829
1830
1831 if (freed == 1) {
1832 info->flags |= IEEE80211_TX_STAT_AMPDU;
1833 memcpy(&info->status, &tx_info->status,
1834 sizeof(tx_info->status));
1835 iwl_mvm_hwrate_to_tx_status(rate, info);
1836 }
1837 }
1838
1839 spin_unlock_bh(&mvmsta->lock);
1840
1841
1842
1843
1844
1845 if (!is_flush && skb_queue_empty(&reclaimed_skbs)) {
1846 struct ieee80211_chanctx_conf *chanctx_conf = NULL;
1847
1848 if (mvmsta->vif)
1849 chanctx_conf =
1850 rcu_dereference(mvmsta->vif->chanctx_conf);
1851
1852 if (WARN_ON_ONCE(!chanctx_conf))
1853 goto out;
1854
1855 tx_info->band = chanctx_conf->def.chan->band;
1856 iwl_mvm_hwrate_to_tx_status(rate, tx_info);
1857
1858 if (!iwl_mvm_has_tlc_offload(mvm)) {
1859 IWL_DEBUG_TX_REPLY(mvm,
1860 "No reclaim. Update rs directly\n");
1861 iwl_mvm_rs_tx_status(mvm, sta, tid, tx_info, false);
1862 }
1863 }
1864
1865out:
1866 rcu_read_unlock();
1867
1868 while (!skb_queue_empty(&reclaimed_skbs)) {
1869 skb = __skb_dequeue(&reclaimed_skbs);
1870 ieee80211_tx_status(mvm->hw, skb);
1871 }
1872}
1873
1874void iwl_mvm_rx_ba_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
1875{
1876 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1877 unsigned int pkt_len = iwl_rx_packet_payload_len(pkt);
1878 int sta_id, tid, txq, index;
1879 struct ieee80211_tx_info ba_info = {};
1880 struct iwl_mvm_ba_notif *ba_notif;
1881 struct iwl_mvm_tid_data *tid_data;
1882 struct iwl_mvm_sta *mvmsta;
1883
1884 ba_info.flags = IEEE80211_TX_STAT_AMPDU;
1885
1886 if (iwl_mvm_has_new_tx_api(mvm)) {
1887 struct iwl_mvm_compressed_ba_notif *ba_res =
1888 (void *)pkt->data;
1889 u8 lq_color = TX_RES_RATE_TABLE_COL_GET(ba_res->tlc_rate_info);
1890 u16 tfd_cnt;
1891 int i;
1892
1893 if (unlikely(sizeof(*ba_res) > pkt_len))
1894 return;
1895
1896 sta_id = ba_res->sta_id;
1897 ba_info.status.ampdu_ack_len = (u8)le16_to_cpu(ba_res->done);
1898 ba_info.status.ampdu_len = (u8)le16_to_cpu(ba_res->txed);
1899 ba_info.status.tx_time =
1900 (u16)le32_to_cpu(ba_res->wireless_time);
1901 ba_info.status.status_driver_data[0] =
1902 (void *)(uintptr_t)ba_res->reduced_txp;
1903
1904 tfd_cnt = le16_to_cpu(ba_res->tfd_cnt);
1905 if (!tfd_cnt || struct_size(ba_res, tfd, tfd_cnt) > pkt_len)
1906 return;
1907
1908 rcu_read_lock();
1909
1910 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921 for (i = 0; i < tfd_cnt; i++) {
1922 struct iwl_mvm_compressed_ba_tfd *ba_tfd =
1923 &ba_res->tfd[i];
1924
1925 tid = ba_tfd->tid;
1926 if (tid == IWL_MGMT_TID)
1927 tid = IWL_MAX_TID_COUNT;
1928
1929 if (mvmsta)
1930 mvmsta->tid_data[i].lq_color = lq_color;
1931
1932 iwl_mvm_tx_reclaim(mvm, sta_id, tid,
1933 (int)(le16_to_cpu(ba_tfd->q_num)),
1934 le16_to_cpu(ba_tfd->tfd_index),
1935 &ba_info,
1936 le32_to_cpu(ba_res->tx_rate), false);
1937 }
1938
1939 if (mvmsta)
1940 iwl_mvm_tx_airtime(mvm, mvmsta,
1941 le32_to_cpu(ba_res->wireless_time));
1942 rcu_read_unlock();
1943
1944 IWL_DEBUG_TX_REPLY(mvm,
1945 "BA_NOTIFICATION Received from sta_id = %d, flags %x, sent:%d, acked:%d\n",
1946 sta_id, le32_to_cpu(ba_res->flags),
1947 le16_to_cpu(ba_res->txed),
1948 le16_to_cpu(ba_res->done));
1949 return;
1950 }
1951
1952 ba_notif = (void *)pkt->data;
1953 sta_id = ba_notif->sta_id;
1954 tid = ba_notif->tid;
1955
1956 txq = le16_to_cpu(ba_notif->scd_flow);
1957
1958
1959 index = le16_to_cpu(ba_notif->scd_ssn);
1960
1961 rcu_read_lock();
1962 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm, sta_id);
1963 if (WARN_ON_ONCE(!mvmsta)) {
1964 rcu_read_unlock();
1965 return;
1966 }
1967
1968 tid_data = &mvmsta->tid_data[tid];
1969
1970 ba_info.status.ampdu_ack_len = ba_notif->txed_2_done;
1971 ba_info.status.ampdu_len = ba_notif->txed;
1972 ba_info.status.tx_time = tid_data->tx_time;
1973 ba_info.status.status_driver_data[0] =
1974 (void *)(uintptr_t)ba_notif->reduced_txp;
1975
1976 rcu_read_unlock();
1977
1978 iwl_mvm_tx_reclaim(mvm, sta_id, tid, txq, index, &ba_info,
1979 tid_data->rate_n_flags, false);
1980
1981 IWL_DEBUG_TX_REPLY(mvm,
1982 "BA_NOTIFICATION Received from %pM, sta_id = %d\n",
1983 ba_notif->sta_addr, ba_notif->sta_id);
1984
1985 IWL_DEBUG_TX_REPLY(mvm,
1986 "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = %d, scd_ssn = %d sent:%d, acked:%d\n",
1987 ba_notif->tid, le16_to_cpu(ba_notif->seq_ctl),
1988 le64_to_cpu(ba_notif->bitmap), txq, index,
1989 ba_notif->txed, ba_notif->txed_2_done);
1990
1991 IWL_DEBUG_TX_REPLY(mvm, "reduced txp from ba notif %d\n",
1992 ba_notif->reduced_txp);
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003int iwl_mvm_flush_tx_path(struct iwl_mvm *mvm, u32 tfd_msk)
2004{
2005 int ret;
2006 struct iwl_tx_path_flush_cmd_v1 flush_cmd = {
2007 .queues_ctl = cpu_to_le32(tfd_msk),
2008 .flush_ctl = cpu_to_le16(DUMP_TX_FIFO_FLUSH),
2009 };
2010
2011 WARN_ON(iwl_mvm_has_new_tx_api(mvm));
2012 ret = iwl_mvm_send_cmd_pdu(mvm, TXPATH_FLUSH, 0,
2013 sizeof(flush_cmd), &flush_cmd);
2014 if (ret)
2015 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
2016 return ret;
2017}
2018
2019int iwl_mvm_flush_sta_tids(struct iwl_mvm *mvm, u32 sta_id, u16 tids)
2020{
2021 int ret;
2022 struct iwl_tx_path_flush_cmd_rsp *rsp;
2023 struct iwl_tx_path_flush_cmd flush_cmd = {
2024 .sta_id = cpu_to_le32(sta_id),
2025 .tid_mask = cpu_to_le16(tids),
2026 };
2027
2028 struct iwl_host_cmd cmd = {
2029 .id = TXPATH_FLUSH,
2030 .len = { sizeof(flush_cmd), },
2031 .data = { &flush_cmd, },
2032 };
2033
2034 WARN_ON(!iwl_mvm_has_new_tx_api(mvm));
2035
2036 if (iwl_fw_lookup_notif_ver(mvm->fw, LONG_GROUP, TXPATH_FLUSH, 0) > 0)
2037 cmd.flags |= CMD_WANT_SKB;
2038
2039 IWL_DEBUG_TX_QUEUES(mvm, "flush for sta id %d tid mask 0x%x\n",
2040 sta_id, tids);
2041
2042 ret = iwl_mvm_send_cmd(mvm, &cmd);
2043
2044 if (ret) {
2045 IWL_ERR(mvm, "Failed to send flush command (%d)\n", ret);
2046 return ret;
2047 }
2048
2049 if (cmd.flags & CMD_WANT_SKB) {
2050 int i;
2051 int num_flushed_queues;
2052
2053 if (WARN_ON_ONCE(iwl_rx_packet_payload_len(cmd.resp_pkt) != sizeof(*rsp))) {
2054 ret = -EIO;
2055 goto free_rsp;
2056 }
2057
2058 rsp = (void *)cmd.resp_pkt->data;
2059
2060 if (WARN_ONCE(le16_to_cpu(rsp->sta_id) != sta_id,
2061 "sta_id %d != rsp_sta_id %d",
2062 sta_id, le16_to_cpu(rsp->sta_id))) {
2063 ret = -EIO;
2064 goto free_rsp;
2065 }
2066
2067 num_flushed_queues = le16_to_cpu(rsp->num_flushed_queues);
2068 if (WARN_ONCE(num_flushed_queues > IWL_TX_FLUSH_QUEUE_RSP,
2069 "num_flushed_queues %d", num_flushed_queues)) {
2070 ret = -EIO;
2071 goto free_rsp;
2072 }
2073
2074 for (i = 0; i < num_flushed_queues; i++) {
2075 struct ieee80211_tx_info tx_info = {};
2076 struct iwl_flush_queue_info *queue_info = &rsp->queues[i];
2077 int tid = le16_to_cpu(queue_info->tid);
2078 int read_before = le16_to_cpu(queue_info->read_before_flush);
2079 int read_after = le16_to_cpu(queue_info->read_after_flush);
2080 int queue_num = le16_to_cpu(queue_info->queue_num);
2081
2082 if (tid == IWL_MGMT_TID)
2083 tid = IWL_MAX_TID_COUNT;
2084
2085 IWL_DEBUG_TX_QUEUES(mvm,
2086 "tid %d queue_id %d read-before %d read-after %d\n",
2087 tid, queue_num, read_before, read_after);
2088
2089 iwl_mvm_tx_reclaim(mvm, sta_id, tid, queue_num, read_after,
2090 &tx_info, 0, true);
2091 }
2092free_rsp:
2093 iwl_free_resp(&cmd);
2094 }
2095 return ret;
2096}
2097
2098int iwl_mvm_flush_sta(struct iwl_mvm *mvm, void *sta, bool internal)
2099{
2100 struct iwl_mvm_int_sta *int_sta = sta;
2101 struct iwl_mvm_sta *mvm_sta = sta;
2102
2103 BUILD_BUG_ON(offsetof(struct iwl_mvm_int_sta, sta_id) !=
2104 offsetof(struct iwl_mvm_sta, sta_id));
2105
2106 if (iwl_mvm_has_new_tx_api(mvm))
2107 return iwl_mvm_flush_sta_tids(mvm, mvm_sta->sta_id, 0xffff);
2108
2109 if (internal)
2110 return iwl_mvm_flush_tx_path(mvm, int_sta->tfd_queue_msk);
2111
2112 return iwl_mvm_flush_tx_path(mvm, mvm_sta->tfd_queue_msk);
2113}
2114