1 // SPDX-License-Identifier: BSD-3-Clause-Clear
3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
7 #include <linux/ieee80211.h>
8 #include <linux/kernel.h>
9 #include <linux/skbuff.h>
10 #include <crypto/hash.h>
13 #include "debugfs_htt_stats.h"
14 #include "debugfs_sta.h"
22 #define ATH11K_DP_RX_FRAGMENT_TIMEOUT_MS (2 * HZ)
25 u8 *ath11k_dp_rx_h_80211_hdr(struct ath11k_base *ab, struct hal_rx_desc *desc)
27 return ab->hw_params.hw_ops->rx_desc_get_hdr_status(desc);
31 enum hal_encrypt_type ath11k_dp_rx_h_mpdu_start_enctype(struct ath11k_base *ab,
32 struct hal_rx_desc *desc)
34 if (!ab->hw_params.hw_ops->rx_desc_encrypt_valid(desc))
35 return HAL_ENCRYPT_TYPE_OPEN;
37 return ab->hw_params.hw_ops->rx_desc_get_encrypt_type(desc);
40 static inline u8 ath11k_dp_rx_h_msdu_start_decap_type(struct ath11k_base *ab,
41 struct hal_rx_desc *desc)
43 return ab->hw_params.hw_ops->rx_desc_get_decap_type(desc);
47 bool ath11k_dp_rx_h_msdu_start_ldpc_support(struct ath11k_base *ab,
48 struct hal_rx_desc *desc)
50 return ab->hw_params.hw_ops->rx_desc_get_ldpc_support(desc);
54 u8 ath11k_dp_rx_h_msdu_start_mesh_ctl_present(struct ath11k_base *ab,
55 struct hal_rx_desc *desc)
57 return ab->hw_params.hw_ops->rx_desc_get_mesh_ctl(desc);
61 bool ath11k_dp_rx_h_mpdu_start_seq_ctrl_valid(struct ath11k_base *ab,
62 struct hal_rx_desc *desc)
64 return ab->hw_params.hw_ops->rx_desc_get_mpdu_seq_ctl_vld(desc);
67 static inline bool ath11k_dp_rx_h_mpdu_start_fc_valid(struct ath11k_base *ab,
68 struct hal_rx_desc *desc)
70 return ab->hw_params.hw_ops->rx_desc_get_mpdu_fc_valid(desc);
73 static inline bool ath11k_dp_rx_h_mpdu_start_more_frags(struct ath11k_base *ab,
76 struct ieee80211_hdr *hdr;
78 hdr = (struct ieee80211_hdr *)(skb->data + ab->hw_params.hal_desc_sz);
79 return ieee80211_has_morefrags(hdr->frame_control);
82 static inline u16 ath11k_dp_rx_h_mpdu_start_frag_no(struct ath11k_base *ab,
85 struct ieee80211_hdr *hdr;
87 hdr = (struct ieee80211_hdr *)(skb->data + ab->hw_params.hal_desc_sz);
88 return le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
91 static inline u16 ath11k_dp_rx_h_mpdu_start_seq_no(struct ath11k_base *ab,
92 struct hal_rx_desc *desc)
94 return ab->hw_params.hw_ops->rx_desc_get_mpdu_start_seq_no(desc);
97 static inline void *ath11k_dp_rx_get_attention(struct ath11k_base *ab,
98 struct hal_rx_desc *desc)
100 return ab->hw_params.hw_ops->rx_desc_get_attention(desc);
103 static inline bool ath11k_dp_rx_h_attn_msdu_done(struct rx_attention *attn)
105 return !!FIELD_GET(RX_ATTENTION_INFO2_MSDU_DONE,
106 __le32_to_cpu(attn->info2));
109 static inline bool ath11k_dp_rx_h_attn_l4_cksum_fail(struct rx_attention *attn)
111 return !!FIELD_GET(RX_ATTENTION_INFO1_TCP_UDP_CKSUM_FAIL,
112 __le32_to_cpu(attn->info1));
115 static inline bool ath11k_dp_rx_h_attn_ip_cksum_fail(struct rx_attention *attn)
117 return !!FIELD_GET(RX_ATTENTION_INFO1_IP_CKSUM_FAIL,
118 __le32_to_cpu(attn->info1));
121 static inline bool ath11k_dp_rx_h_attn_is_decrypted(struct rx_attention *attn)
123 return (FIELD_GET(RX_ATTENTION_INFO2_DCRYPT_STATUS_CODE,
124 __le32_to_cpu(attn->info2)) ==
125 RX_DESC_DECRYPT_STATUS_CODE_OK);
128 static u32 ath11k_dp_rx_h_attn_mpdu_err(struct rx_attention *attn)
130 u32 info = __le32_to_cpu(attn->info1);
133 if (info & RX_ATTENTION_INFO1_FCS_ERR)
134 errmap |= DP_RX_MPDU_ERR_FCS;
136 if (info & RX_ATTENTION_INFO1_DECRYPT_ERR)
137 errmap |= DP_RX_MPDU_ERR_DECRYPT;
139 if (info & RX_ATTENTION_INFO1_TKIP_MIC_ERR)
140 errmap |= DP_RX_MPDU_ERR_TKIP_MIC;
142 if (info & RX_ATTENTION_INFO1_A_MSDU_ERROR)
143 errmap |= DP_RX_MPDU_ERR_AMSDU_ERR;
145 if (info & RX_ATTENTION_INFO1_OVERFLOW_ERR)
146 errmap |= DP_RX_MPDU_ERR_OVERFLOW;
148 if (info & RX_ATTENTION_INFO1_MSDU_LEN_ERR)
149 errmap |= DP_RX_MPDU_ERR_MSDU_LEN;
151 if (info & RX_ATTENTION_INFO1_MPDU_LEN_ERR)
152 errmap |= DP_RX_MPDU_ERR_MPDU_LEN;
157 static bool ath11k_dp_rx_h_attn_msdu_len_err(struct ath11k_base *ab,
158 struct hal_rx_desc *desc)
160 struct rx_attention *rx_attention;
163 rx_attention = ath11k_dp_rx_get_attention(ab, desc);
164 errmap = ath11k_dp_rx_h_attn_mpdu_err(rx_attention);
166 return errmap & DP_RX_MPDU_ERR_MSDU_LEN;
169 static inline u16 ath11k_dp_rx_h_msdu_start_msdu_len(struct ath11k_base *ab,
170 struct hal_rx_desc *desc)
172 return ab->hw_params.hw_ops->rx_desc_get_msdu_len(desc);
175 static inline u8 ath11k_dp_rx_h_msdu_start_sgi(struct ath11k_base *ab,
176 struct hal_rx_desc *desc)
178 return ab->hw_params.hw_ops->rx_desc_get_msdu_sgi(desc);
181 static inline u8 ath11k_dp_rx_h_msdu_start_rate_mcs(struct ath11k_base *ab,
182 struct hal_rx_desc *desc)
184 return ab->hw_params.hw_ops->rx_desc_get_msdu_rate_mcs(desc);
187 static inline u8 ath11k_dp_rx_h_msdu_start_rx_bw(struct ath11k_base *ab,
188 struct hal_rx_desc *desc)
190 return ab->hw_params.hw_ops->rx_desc_get_msdu_rx_bw(desc);
193 static inline u32 ath11k_dp_rx_h_msdu_start_freq(struct ath11k_base *ab,
194 struct hal_rx_desc *desc)
196 return ab->hw_params.hw_ops->rx_desc_get_msdu_freq(desc);
199 static inline u8 ath11k_dp_rx_h_msdu_start_pkt_type(struct ath11k_base *ab,
200 struct hal_rx_desc *desc)
202 return ab->hw_params.hw_ops->rx_desc_get_msdu_pkt_type(desc);
205 static inline u8 ath11k_dp_rx_h_msdu_start_nss(struct ath11k_base *ab,
206 struct hal_rx_desc *desc)
208 return hweight8(ab->hw_params.hw_ops->rx_desc_get_msdu_nss(desc));
211 static inline u8 ath11k_dp_rx_h_mpdu_start_tid(struct ath11k_base *ab,
212 struct hal_rx_desc *desc)
214 return ab->hw_params.hw_ops->rx_desc_get_mpdu_tid(desc);
217 static inline u16 ath11k_dp_rx_h_mpdu_start_peer_id(struct ath11k_base *ab,
218 struct hal_rx_desc *desc)
220 return ab->hw_params.hw_ops->rx_desc_get_mpdu_peer_id(desc);
223 static inline u8 ath11k_dp_rx_h_msdu_end_l3pad(struct ath11k_base *ab,
224 struct hal_rx_desc *desc)
226 return ab->hw_params.hw_ops->rx_desc_get_l3_pad_bytes(desc);
229 static inline bool ath11k_dp_rx_h_msdu_end_first_msdu(struct ath11k_base *ab,
230 struct hal_rx_desc *desc)
232 return ab->hw_params.hw_ops->rx_desc_get_first_msdu(desc);
235 static bool ath11k_dp_rx_h_msdu_end_last_msdu(struct ath11k_base *ab,
236 struct hal_rx_desc *desc)
238 return ab->hw_params.hw_ops->rx_desc_get_last_msdu(desc);
241 static void ath11k_dp_rx_desc_end_tlv_copy(struct ath11k_base *ab,
242 struct hal_rx_desc *fdesc,
243 struct hal_rx_desc *ldesc)
245 ab->hw_params.hw_ops->rx_desc_copy_attn_end_tlv(fdesc, ldesc);
248 static inline u32 ath11k_dp_rxdesc_get_mpdulen_err(struct rx_attention *attn)
250 return FIELD_GET(RX_ATTENTION_INFO1_MPDU_LEN_ERR,
251 __le32_to_cpu(attn->info1));
254 static inline u8 *ath11k_dp_rxdesc_get_80211hdr(struct ath11k_base *ab,
255 struct hal_rx_desc *rx_desc)
259 rx_pkt_hdr = ab->hw_params.hw_ops->rx_desc_get_msdu_payload(rx_desc);
264 static inline bool ath11k_dp_rxdesc_mpdu_valid(struct ath11k_base *ab,
265 struct hal_rx_desc *rx_desc)
269 tlv_tag = ab->hw_params.hw_ops->rx_desc_get_mpdu_start_tag(rx_desc);
271 return tlv_tag == HAL_RX_MPDU_START;
274 static inline u32 ath11k_dp_rxdesc_get_ppduid(struct ath11k_base *ab,
275 struct hal_rx_desc *rx_desc)
277 return ab->hw_params.hw_ops->rx_desc_get_mpdu_ppdu_id(rx_desc);
280 static inline void ath11k_dp_rxdesc_set_msdu_len(struct ath11k_base *ab,
281 struct hal_rx_desc *desc,
284 ab->hw_params.hw_ops->rx_desc_set_msdu_len(desc, len);
287 static bool ath11k_dp_rx_h_attn_is_mcbc(struct ath11k_base *ab,
288 struct hal_rx_desc *desc)
290 struct rx_attention *attn = ath11k_dp_rx_get_attention(ab, desc);
292 return ath11k_dp_rx_h_msdu_end_first_msdu(ab, desc) &&
293 (!!FIELD_GET(RX_ATTENTION_INFO1_MCAST_BCAST,
294 __le32_to_cpu(attn->info1)));
297 static bool ath11k_dp_rxdesc_mac_addr2_valid(struct ath11k_base *ab,
298 struct hal_rx_desc *desc)
300 return ab->hw_params.hw_ops->rx_desc_mac_addr2_valid(desc);
303 static u8 *ath11k_dp_rxdesc_mpdu_start_addr2(struct ath11k_base *ab,
304 struct hal_rx_desc *desc)
306 return ab->hw_params.hw_ops->rx_desc_mpdu_start_addr2(desc);
309 static void ath11k_dp_service_mon_ring(struct timer_list *t)
311 struct ath11k_base *ab = from_timer(ab, t, mon_reap_timer);
314 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++)
315 ath11k_dp_rx_process_mon_rings(ab, i, NULL, DP_MON_SERVICE_BUDGET);
317 mod_timer(&ab->mon_reap_timer, jiffies +
318 msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
321 static int ath11k_dp_purge_mon_ring(struct ath11k_base *ab)
324 unsigned long timeout = jiffies + msecs_to_jiffies(DP_MON_PURGE_TIMEOUT_MS);
327 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++)
328 reaped += ath11k_dp_rx_process_mon_rings(ab, i,
330 DP_MON_SERVICE_BUDGET);
332 /* nothing more to reap */
333 if (reaped < DP_MON_SERVICE_BUDGET)
336 } while (time_before(jiffies, timeout));
338 ath11k_warn(ab, "dp mon ring purge timeout");
343 /* Returns number of Rx buffers replenished */
344 int ath11k_dp_rxbufs_replenish(struct ath11k_base *ab, int mac_id,
345 struct dp_rxdma_ring *rx_ring,
347 enum hal_rx_buf_return_buf_manager mgr)
349 struct hal_srng *srng;
358 req_entries = min(req_entries, rx_ring->bufs_max);
360 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
362 spin_lock_bh(&srng->lock);
364 ath11k_hal_srng_access_begin(ab, srng);
366 num_free = ath11k_hal_srng_src_num_free(ab, srng, true);
367 if (!req_entries && (num_free > (rx_ring->bufs_max * 3) / 4))
368 req_entries = num_free;
370 req_entries = min(num_free, req_entries);
371 num_remain = req_entries;
373 while (num_remain > 0) {
374 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE +
375 DP_RX_BUFFER_ALIGN_SIZE);
379 if (!IS_ALIGNED((unsigned long)skb->data,
380 DP_RX_BUFFER_ALIGN_SIZE)) {
382 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
386 paddr = dma_map_single(ab->dev, skb->data,
387 skb->len + skb_tailroom(skb),
389 if (dma_mapping_error(ab->dev, paddr))
392 spin_lock_bh(&rx_ring->idr_lock);
393 buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 1,
394 (rx_ring->bufs_max * 3) + 1, GFP_ATOMIC);
395 spin_unlock_bh(&rx_ring->idr_lock);
399 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
401 goto fail_idr_remove;
403 ATH11K_SKB_RXCB(skb)->paddr = paddr;
405 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
406 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
410 ath11k_hal_rx_buf_addr_info_set(desc, paddr, cookie, mgr);
413 ath11k_hal_srng_access_end(ab, srng);
415 spin_unlock_bh(&srng->lock);
417 return req_entries - num_remain;
420 spin_lock_bh(&rx_ring->idr_lock);
421 idr_remove(&rx_ring->bufs_idr, buf_id);
422 spin_unlock_bh(&rx_ring->idr_lock);
424 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
427 dev_kfree_skb_any(skb);
429 ath11k_hal_srng_access_end(ab, srng);
431 spin_unlock_bh(&srng->lock);
433 return req_entries - num_remain;
436 static int ath11k_dp_rxdma_buf_ring_free(struct ath11k *ar,
437 struct dp_rxdma_ring *rx_ring)
442 spin_lock_bh(&rx_ring->idr_lock);
443 idr_for_each_entry(&rx_ring->bufs_idr, skb, buf_id) {
444 idr_remove(&rx_ring->bufs_idr, buf_id);
445 /* TODO: Understand where internal driver does this dma_unmap
448 dma_unmap_single(ar->ab->dev, ATH11K_SKB_RXCB(skb)->paddr,
449 skb->len + skb_tailroom(skb), DMA_FROM_DEVICE);
450 dev_kfree_skb_any(skb);
453 idr_destroy(&rx_ring->bufs_idr);
454 spin_unlock_bh(&rx_ring->idr_lock);
459 static int ath11k_dp_rxdma_pdev_buf_free(struct ath11k *ar)
461 struct ath11k_pdev_dp *dp = &ar->dp;
462 struct ath11k_base *ab = ar->ab;
463 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
466 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
468 rx_ring = &dp->rxdma_mon_buf_ring;
469 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
471 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
472 rx_ring = &dp->rx_mon_status_refill_ring[i];
473 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
479 static int ath11k_dp_rxdma_ring_buf_setup(struct ath11k *ar,
480 struct dp_rxdma_ring *rx_ring,
483 struct ath11k_pdev_dp *dp = &ar->dp;
486 num_entries = rx_ring->refill_buf_ring.size /
487 ath11k_hal_srng_get_entrysize(ar->ab, ringtype);
489 rx_ring->bufs_max = num_entries;
490 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id, rx_ring, num_entries,
491 ar->ab->hw_params.hal_params->rx_buf_rbm);
495 static int ath11k_dp_rxdma_pdev_buf_setup(struct ath11k *ar)
497 struct ath11k_pdev_dp *dp = &ar->dp;
498 struct ath11k_base *ab = ar->ab;
499 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
502 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_BUF);
504 if (ar->ab->hw_params.rxdma1_enable) {
505 rx_ring = &dp->rxdma_mon_buf_ring;
506 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_MONITOR_BUF);
509 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
510 rx_ring = &dp->rx_mon_status_refill_ring[i];
511 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_MONITOR_STATUS);
517 static void ath11k_dp_rx_pdev_srng_free(struct ath11k *ar)
519 struct ath11k_pdev_dp *dp = &ar->dp;
520 struct ath11k_base *ab = ar->ab;
523 ath11k_dp_srng_cleanup(ab, &dp->rx_refill_buf_ring.refill_buf_ring);
525 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
526 if (ab->hw_params.rx_mac_buf_ring)
527 ath11k_dp_srng_cleanup(ab, &dp->rx_mac_buf_ring[i]);
529 ath11k_dp_srng_cleanup(ab, &dp->rxdma_err_dst_ring[i]);
530 ath11k_dp_srng_cleanup(ab,
531 &dp->rx_mon_status_refill_ring[i].refill_buf_ring);
534 ath11k_dp_srng_cleanup(ab, &dp->rxdma_mon_buf_ring.refill_buf_ring);
537 void ath11k_dp_pdev_reo_cleanup(struct ath11k_base *ab)
539 struct ath11k_dp *dp = &ab->dp;
542 for (i = 0; i < DP_REO_DST_RING_MAX; i++)
543 ath11k_dp_srng_cleanup(ab, &dp->reo_dst_ring[i]);
546 int ath11k_dp_pdev_reo_setup(struct ath11k_base *ab)
548 struct ath11k_dp *dp = &ab->dp;
552 for (i = 0; i < DP_REO_DST_RING_MAX; i++) {
553 ret = ath11k_dp_srng_setup(ab, &dp->reo_dst_ring[i],
555 DP_REO_DST_RING_SIZE);
557 ath11k_warn(ab, "failed to setup reo_dst_ring\n");
558 goto err_reo_cleanup;
565 ath11k_dp_pdev_reo_cleanup(ab);
570 static int ath11k_dp_rx_pdev_srng_alloc(struct ath11k *ar)
572 struct ath11k_pdev_dp *dp = &ar->dp;
573 struct ath11k_base *ab = ar->ab;
574 struct dp_srng *srng = NULL;
578 ret = ath11k_dp_srng_setup(ar->ab,
579 &dp->rx_refill_buf_ring.refill_buf_ring,
581 dp->mac_id, DP_RXDMA_BUF_RING_SIZE);
583 ath11k_warn(ar->ab, "failed to setup rx_refill_buf_ring\n");
587 if (ar->ab->hw_params.rx_mac_buf_ring) {
588 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
589 ret = ath11k_dp_srng_setup(ar->ab,
590 &dp->rx_mac_buf_ring[i],
592 dp->mac_id + i, 1024);
594 ath11k_warn(ar->ab, "failed to setup rx_mac_buf_ring %d\n",
601 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
602 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_err_dst_ring[i],
603 HAL_RXDMA_DST, 0, dp->mac_id + i,
604 DP_RXDMA_ERR_DST_RING_SIZE);
606 ath11k_warn(ar->ab, "failed to setup rxdma_err_dst_ring %d\n", i);
611 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
612 srng = &dp->rx_mon_status_refill_ring[i].refill_buf_ring;
613 ret = ath11k_dp_srng_setup(ar->ab,
615 HAL_RXDMA_MONITOR_STATUS, 0, dp->mac_id + i,
616 DP_RXDMA_MON_STATUS_RING_SIZE);
619 "failed to setup rx_mon_status_refill_ring %d\n", i);
624 /* if rxdma1_enable is false, then it doesn't need
625 * to setup rxdam_mon_buf_ring, rxdma_mon_dst_ring
626 * and rxdma_mon_desc_ring.
627 * init reap timer for QCA6390.
629 if (!ar->ab->hw_params.rxdma1_enable) {
630 //init mon status buffer reap timer
631 timer_setup(&ar->ab->mon_reap_timer,
632 ath11k_dp_service_mon_ring, 0);
636 ret = ath11k_dp_srng_setup(ar->ab,
637 &dp->rxdma_mon_buf_ring.refill_buf_ring,
638 HAL_RXDMA_MONITOR_BUF, 0, dp->mac_id,
639 DP_RXDMA_MONITOR_BUF_RING_SIZE);
642 "failed to setup HAL_RXDMA_MONITOR_BUF\n");
646 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_mon_dst_ring,
647 HAL_RXDMA_MONITOR_DST, 0, dp->mac_id,
648 DP_RXDMA_MONITOR_DST_RING_SIZE);
651 "failed to setup HAL_RXDMA_MONITOR_DST\n");
655 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_mon_desc_ring,
656 HAL_RXDMA_MONITOR_DESC, 0, dp->mac_id,
657 DP_RXDMA_MONITOR_DESC_RING_SIZE);
660 "failed to setup HAL_RXDMA_MONITOR_DESC\n");
667 void ath11k_dp_reo_cmd_list_cleanup(struct ath11k_base *ab)
669 struct ath11k_dp *dp = &ab->dp;
670 struct dp_reo_cmd *cmd, *tmp;
671 struct dp_reo_cache_flush_elem *cmd_cache, *tmp_cache;
672 struct dp_rx_tid *rx_tid;
674 spin_lock_bh(&dp->reo_cmd_lock);
675 list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) {
676 list_del(&cmd->list);
679 dma_unmap_single(ab->dev, rx_tid->paddr,
680 rx_tid->size, DMA_BIDIRECTIONAL);
681 kfree(rx_tid->vaddr);
682 rx_tid->vaddr = NULL;
687 list_for_each_entry_safe(cmd_cache, tmp_cache,
688 &dp->reo_cmd_cache_flush_list, list) {
689 list_del(&cmd_cache->list);
690 dp->reo_cmd_cache_flush_count--;
691 rx_tid = &cmd_cache->data;
693 dma_unmap_single(ab->dev, rx_tid->paddr,
694 rx_tid->size, DMA_BIDIRECTIONAL);
695 kfree(rx_tid->vaddr);
696 rx_tid->vaddr = NULL;
700 spin_unlock_bh(&dp->reo_cmd_lock);
703 static void ath11k_dp_reo_cmd_free(struct ath11k_dp *dp, void *ctx,
704 enum hal_reo_cmd_status status)
706 struct dp_rx_tid *rx_tid = ctx;
708 if (status != HAL_REO_CMD_SUCCESS)
709 ath11k_warn(dp->ab, "failed to flush rx tid hw desc, tid %d status %d\n",
710 rx_tid->tid, status);
712 dma_unmap_single(dp->ab->dev, rx_tid->paddr, rx_tid->size,
714 kfree(rx_tid->vaddr);
715 rx_tid->vaddr = NULL;
719 static void ath11k_dp_reo_cache_flush(struct ath11k_base *ab,
720 struct dp_rx_tid *rx_tid)
722 struct ath11k_hal_reo_cmd cmd = {0};
723 unsigned long tot_desc_sz, desc_sz;
726 tot_desc_sz = rx_tid->size;
727 desc_sz = ath11k_hal_reo_qdesc_size(0, HAL_DESC_REO_NON_QOS_TID);
729 while (tot_desc_sz > desc_sz) {
730 tot_desc_sz -= desc_sz;
731 cmd.addr_lo = lower_32_bits(rx_tid->paddr + tot_desc_sz);
732 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
733 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
734 HAL_REO_CMD_FLUSH_CACHE, &cmd,
738 "failed to send HAL_REO_CMD_FLUSH_CACHE, tid %d (%d)\n",
742 memset(&cmd, 0, sizeof(cmd));
743 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
744 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
745 cmd.flag |= HAL_REO_CMD_FLG_NEED_STATUS;
746 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
747 HAL_REO_CMD_FLUSH_CACHE,
748 &cmd, ath11k_dp_reo_cmd_free);
750 ath11k_err(ab, "failed to send HAL_REO_CMD_FLUSH_CACHE cmd, tid %d (%d)\n",
752 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
754 kfree(rx_tid->vaddr);
755 rx_tid->vaddr = NULL;
759 static void ath11k_dp_rx_tid_del_func(struct ath11k_dp *dp, void *ctx,
760 enum hal_reo_cmd_status status)
762 struct ath11k_base *ab = dp->ab;
763 struct dp_rx_tid *rx_tid = ctx;
764 struct dp_reo_cache_flush_elem *elem, *tmp;
766 if (status == HAL_REO_CMD_DRAIN) {
768 } else if (status != HAL_REO_CMD_SUCCESS) {
769 /* Shouldn't happen! Cleanup in case of other failure? */
770 ath11k_warn(ab, "failed to delete rx tid %d hw descriptor %d\n",
771 rx_tid->tid, status);
775 elem = kzalloc(sizeof(*elem), GFP_ATOMIC);
780 memcpy(&elem->data, rx_tid, sizeof(*rx_tid));
782 spin_lock_bh(&dp->reo_cmd_lock);
783 list_add_tail(&elem->list, &dp->reo_cmd_cache_flush_list);
784 dp->reo_cmd_cache_flush_count++;
786 /* Flush and invalidate aged REO desc from HW cache */
787 list_for_each_entry_safe(elem, tmp, &dp->reo_cmd_cache_flush_list,
789 if (dp->reo_cmd_cache_flush_count > DP_REO_DESC_FREE_THRESHOLD ||
790 time_after(jiffies, elem->ts +
791 msecs_to_jiffies(DP_REO_DESC_FREE_TIMEOUT_MS))) {
792 list_del(&elem->list);
793 dp->reo_cmd_cache_flush_count--;
794 spin_unlock_bh(&dp->reo_cmd_lock);
796 ath11k_dp_reo_cache_flush(ab, &elem->data);
798 spin_lock_bh(&dp->reo_cmd_lock);
801 spin_unlock_bh(&dp->reo_cmd_lock);
805 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
807 kfree(rx_tid->vaddr);
808 rx_tid->vaddr = NULL;
811 void ath11k_peer_rx_tid_delete(struct ath11k *ar,
812 struct ath11k_peer *peer, u8 tid)
814 struct ath11k_hal_reo_cmd cmd = {0};
815 struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
821 rx_tid->active = false;
823 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
824 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
825 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
826 cmd.upd0 |= HAL_REO_CMD_UPD0_VLD;
827 ret = ath11k_dp_tx_send_reo_cmd(ar->ab, rx_tid,
828 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
829 ath11k_dp_rx_tid_del_func);
831 if (ret != -ESHUTDOWN)
832 ath11k_err(ar->ab, "failed to send HAL_REO_CMD_UPDATE_RX_QUEUE cmd, tid %d (%d)\n",
834 dma_unmap_single(ar->ab->dev, rx_tid->paddr, rx_tid->size,
836 kfree(rx_tid->vaddr);
837 rx_tid->vaddr = NULL;
844 static int ath11k_dp_rx_link_desc_return(struct ath11k_base *ab,
846 enum hal_wbm_rel_bm_act action)
848 struct ath11k_dp *dp = &ab->dp;
849 struct hal_srng *srng;
853 srng = &ab->hal.srng_list[dp->wbm_desc_rel_ring.ring_id];
855 spin_lock_bh(&srng->lock);
857 ath11k_hal_srng_access_begin(ab, srng);
859 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
865 ath11k_hal_rx_msdu_link_desc_set(ab, (void *)desc, (void *)link_desc,
869 ath11k_hal_srng_access_end(ab, srng);
871 spin_unlock_bh(&srng->lock);
876 static void ath11k_dp_rx_frags_cleanup(struct dp_rx_tid *rx_tid, bool rel_link_desc)
878 struct ath11k_base *ab = rx_tid->ab;
880 lockdep_assert_held(&ab->base_lock);
882 if (rx_tid->dst_ring_desc) {
884 ath11k_dp_rx_link_desc_return(ab, (u32 *)rx_tid->dst_ring_desc,
885 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
886 kfree(rx_tid->dst_ring_desc);
887 rx_tid->dst_ring_desc = NULL;
891 rx_tid->last_frag_no = 0;
892 rx_tid->rx_frag_bitmap = 0;
893 __skb_queue_purge(&rx_tid->rx_frags);
896 void ath11k_peer_frags_flush(struct ath11k *ar, struct ath11k_peer *peer)
898 struct dp_rx_tid *rx_tid;
901 lockdep_assert_held(&ar->ab->base_lock);
903 for (i = 0; i <= IEEE80211_NUM_TIDS; i++) {
904 rx_tid = &peer->rx_tid[i];
906 spin_unlock_bh(&ar->ab->base_lock);
907 del_timer_sync(&rx_tid->frag_timer);
908 spin_lock_bh(&ar->ab->base_lock);
910 ath11k_dp_rx_frags_cleanup(rx_tid, true);
914 void ath11k_peer_rx_tid_cleanup(struct ath11k *ar, struct ath11k_peer *peer)
916 struct dp_rx_tid *rx_tid;
919 lockdep_assert_held(&ar->ab->base_lock);
921 for (i = 0; i <= IEEE80211_NUM_TIDS; i++) {
922 rx_tid = &peer->rx_tid[i];
924 ath11k_peer_rx_tid_delete(ar, peer, i);
925 ath11k_dp_rx_frags_cleanup(rx_tid, true);
927 spin_unlock_bh(&ar->ab->base_lock);
928 del_timer_sync(&rx_tid->frag_timer);
929 spin_lock_bh(&ar->ab->base_lock);
933 static int ath11k_peer_rx_tid_reo_update(struct ath11k *ar,
934 struct ath11k_peer *peer,
935 struct dp_rx_tid *rx_tid,
936 u32 ba_win_sz, u16 ssn,
939 struct ath11k_hal_reo_cmd cmd = {0};
942 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
943 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
944 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
945 cmd.upd0 = HAL_REO_CMD_UPD0_BA_WINDOW_SIZE;
946 cmd.ba_window_size = ba_win_sz;
949 cmd.upd0 |= HAL_REO_CMD_UPD0_SSN;
950 cmd.upd2 = FIELD_PREP(HAL_REO_CMD_UPD2_SSN, ssn);
953 ret = ath11k_dp_tx_send_reo_cmd(ar->ab, rx_tid,
954 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
957 ath11k_warn(ar->ab, "failed to update rx tid queue, tid %d (%d)\n",
962 rx_tid->ba_win_sz = ba_win_sz;
967 static void ath11k_dp_rx_tid_mem_free(struct ath11k_base *ab,
968 const u8 *peer_mac, int vdev_id, u8 tid)
970 struct ath11k_peer *peer;
971 struct dp_rx_tid *rx_tid;
973 spin_lock_bh(&ab->base_lock);
975 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
977 ath11k_warn(ab, "failed to find the peer to free up rx tid mem\n");
981 rx_tid = &peer->rx_tid[tid];
985 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
987 kfree(rx_tid->vaddr);
988 rx_tid->vaddr = NULL;
990 rx_tid->active = false;
993 spin_unlock_bh(&ab->base_lock);
996 int ath11k_peer_rx_tid_setup(struct ath11k *ar, const u8 *peer_mac, int vdev_id,
997 u8 tid, u32 ba_win_sz, u16 ssn,
998 enum hal_pn_type pn_type)
1000 struct ath11k_base *ab = ar->ab;
1001 struct ath11k_peer *peer;
1002 struct dp_rx_tid *rx_tid;
1009 spin_lock_bh(&ab->base_lock);
1011 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
1013 ath11k_warn(ab, "failed to find the peer %pM to set up rx tid\n",
1015 spin_unlock_bh(&ab->base_lock);
1019 rx_tid = &peer->rx_tid[tid];
1020 /* Update the tid queue if it is already setup */
1021 if (rx_tid->active) {
1022 paddr = rx_tid->paddr;
1023 ret = ath11k_peer_rx_tid_reo_update(ar, peer, rx_tid,
1024 ba_win_sz, ssn, true);
1025 spin_unlock_bh(&ab->base_lock);
1027 ath11k_warn(ab, "failed to update reo for peer %pM rx tid %d\n: %d",
1028 peer_mac, tid, ret);
1032 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id,
1036 ath11k_warn(ab, "failed to send wmi rx reorder queue for peer %pM tid %d: %d\n",
1037 peer_mac, tid, ret);
1043 rx_tid->ba_win_sz = ba_win_sz;
1045 /* TODO: Optimize the memory allocation for qos tid based on
1046 * the actual BA window size in REO tid update path.
1048 if (tid == HAL_DESC_REO_NON_QOS_TID)
1049 hw_desc_sz = ath11k_hal_reo_qdesc_size(ba_win_sz, tid);
1051 hw_desc_sz = ath11k_hal_reo_qdesc_size(DP_BA_WIN_SZ_MAX, tid);
1053 vaddr = kzalloc(hw_desc_sz + HAL_LINK_DESC_ALIGN - 1, GFP_ATOMIC);
1055 spin_unlock_bh(&ab->base_lock);
1059 addr_aligned = PTR_ALIGN(vaddr, HAL_LINK_DESC_ALIGN);
1061 ath11k_hal_reo_qdesc_setup(addr_aligned, tid, ba_win_sz,
1064 paddr = dma_map_single(ab->dev, addr_aligned, hw_desc_sz,
1067 ret = dma_mapping_error(ab->dev, paddr);
1069 spin_unlock_bh(&ab->base_lock);
1070 ath11k_warn(ab, "failed to setup dma map for peer %pM rx tid %d: %d\n",
1071 peer_mac, tid, ret);
1075 rx_tid->vaddr = vaddr;
1076 rx_tid->paddr = paddr;
1077 rx_tid->size = hw_desc_sz;
1078 rx_tid->active = true;
1080 spin_unlock_bh(&ab->base_lock);
1082 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id, peer_mac,
1083 paddr, tid, 1, ba_win_sz);
1085 ath11k_warn(ar->ab, "failed to setup rx reorder queue for peer %pM tid %d: %d\n",
1086 peer_mac, tid, ret);
1087 ath11k_dp_rx_tid_mem_free(ab, peer_mac, vdev_id, tid);
1093 kfree(rx_tid->vaddr);
1094 rx_tid->vaddr = NULL;
1099 int ath11k_dp_rx_ampdu_start(struct ath11k *ar,
1100 struct ieee80211_ampdu_params *params)
1102 struct ath11k_base *ab = ar->ab;
1103 struct ath11k_sta *arsta = ath11k_sta_to_arsta(params->sta);
1104 int vdev_id = arsta->arvif->vdev_id;
1107 ret = ath11k_peer_rx_tid_setup(ar, params->sta->addr, vdev_id,
1108 params->tid, params->buf_size,
1109 params->ssn, arsta->pn_type);
1111 ath11k_warn(ab, "failed to setup rx tid %d\n", ret);
1116 int ath11k_dp_rx_ampdu_stop(struct ath11k *ar,
1117 struct ieee80211_ampdu_params *params)
1119 struct ath11k_base *ab = ar->ab;
1120 struct ath11k_peer *peer;
1121 struct ath11k_sta *arsta = ath11k_sta_to_arsta(params->sta);
1122 int vdev_id = arsta->arvif->vdev_id;
1127 spin_lock_bh(&ab->base_lock);
1129 peer = ath11k_peer_find(ab, vdev_id, params->sta->addr);
1131 ath11k_warn(ab, "failed to find the peer to stop rx aggregation\n");
1132 spin_unlock_bh(&ab->base_lock);
1136 paddr = peer->rx_tid[params->tid].paddr;
1137 active = peer->rx_tid[params->tid].active;
1140 spin_unlock_bh(&ab->base_lock);
1144 ret = ath11k_peer_rx_tid_reo_update(ar, peer, peer->rx_tid, 1, 0, false);
1145 spin_unlock_bh(&ab->base_lock);
1147 ath11k_warn(ab, "failed to update reo for rx tid %d: %d\n",
1152 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id,
1153 params->sta->addr, paddr,
1156 ath11k_warn(ab, "failed to send wmi to delete rx tid %d\n",
1162 int ath11k_dp_peer_rx_pn_replay_config(struct ath11k_vif *arvif,
1163 const u8 *peer_addr,
1164 enum set_key_cmd key_cmd,
1165 struct ieee80211_key_conf *key)
1167 struct ath11k *ar = arvif->ar;
1168 struct ath11k_base *ab = ar->ab;
1169 struct ath11k_hal_reo_cmd cmd = {0};
1170 struct ath11k_peer *peer;
1171 struct dp_rx_tid *rx_tid;
1175 /* NOTE: Enable PN/TSC replay check offload only for unicast frames.
1176 * We use mac80211 PN/TSC replay check functionality for bcast/mcast
1179 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1182 cmd.flag |= HAL_REO_CMD_FLG_NEED_STATUS;
1183 cmd.upd0 |= HAL_REO_CMD_UPD0_PN |
1184 HAL_REO_CMD_UPD0_PN_SIZE |
1185 HAL_REO_CMD_UPD0_PN_VALID |
1186 HAL_REO_CMD_UPD0_PN_CHECK |
1187 HAL_REO_CMD_UPD0_SVLD;
1189 switch (key->cipher) {
1190 case WLAN_CIPHER_SUITE_TKIP:
1191 case WLAN_CIPHER_SUITE_CCMP:
1192 case WLAN_CIPHER_SUITE_CCMP_256:
1193 case WLAN_CIPHER_SUITE_GCMP:
1194 case WLAN_CIPHER_SUITE_GCMP_256:
1195 if (key_cmd == SET_KEY) {
1196 cmd.upd1 |= HAL_REO_CMD_UPD1_PN_CHECK;
1204 spin_lock_bh(&ab->base_lock);
1206 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
1208 ath11k_warn(ab, "failed to find the peer to configure pn replay detection\n");
1209 spin_unlock_bh(&ab->base_lock);
1213 for (tid = 0; tid <= IEEE80211_NUM_TIDS; tid++) {
1214 rx_tid = &peer->rx_tid[tid];
1215 if (!rx_tid->active)
1217 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
1218 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
1219 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
1220 HAL_REO_CMD_UPDATE_RX_QUEUE,
1223 ath11k_warn(ab, "failed to configure rx tid %d queue for pn replay detection %d\n",
1229 spin_unlock_bh(&ab->base_lock);
1234 static inline int ath11k_get_ppdu_user_index(struct htt_ppdu_stats *ppdu_stats,
1239 for (i = 0; i < HTT_PPDU_STATS_MAX_USERS - 1; i++) {
1240 if (ppdu_stats->user_stats[i].is_valid_peer_id) {
1241 if (peer_id == ppdu_stats->user_stats[i].peer_id)
1251 static int ath11k_htt_tlv_ppdu_stats_parse(struct ath11k_base *ab,
1252 u16 tag, u16 len, const void *ptr,
1255 struct htt_ppdu_stats_info *ppdu_info;
1256 struct htt_ppdu_user_stats *user_stats;
1263 case HTT_PPDU_STATS_TAG_COMMON:
1264 if (len < sizeof(struct htt_ppdu_stats_common)) {
1265 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1269 memcpy((void *)&ppdu_info->ppdu_stats.common, ptr,
1270 sizeof(struct htt_ppdu_stats_common));
1272 case HTT_PPDU_STATS_TAG_USR_RATE:
1273 if (len < sizeof(struct htt_ppdu_stats_user_rate)) {
1274 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1279 peer_id = ((struct htt_ppdu_stats_user_rate *)ptr)->sw_peer_id;
1280 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1284 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1285 user_stats->peer_id = peer_id;
1286 user_stats->is_valid_peer_id = true;
1287 memcpy((void *)&user_stats->rate, ptr,
1288 sizeof(struct htt_ppdu_stats_user_rate));
1289 user_stats->tlv_flags |= BIT(tag);
1291 case HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON:
1292 if (len < sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn)) {
1293 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1298 peer_id = ((struct htt_ppdu_stats_usr_cmpltn_cmn *)ptr)->sw_peer_id;
1299 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1303 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1304 user_stats->peer_id = peer_id;
1305 user_stats->is_valid_peer_id = true;
1306 memcpy((void *)&user_stats->cmpltn_cmn, ptr,
1307 sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn));
1308 user_stats->tlv_flags |= BIT(tag);
1310 case HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS:
1312 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status)) {
1313 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1319 ((struct htt_ppdu_stats_usr_cmpltn_ack_ba_status *)ptr)->sw_peer_id;
1320 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1324 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1325 user_stats->peer_id = peer_id;
1326 user_stats->is_valid_peer_id = true;
1327 memcpy((void *)&user_stats->ack_ba, ptr,
1328 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status));
1329 user_stats->tlv_flags |= BIT(tag);
1335 int ath11k_dp_htt_tlv_iter(struct ath11k_base *ab, const void *ptr, size_t len,
1336 int (*iter)(struct ath11k_base *ar, u16 tag, u16 len,
1337 const void *ptr, void *data),
1340 const struct htt_tlv *tlv;
1341 const void *begin = ptr;
1342 u16 tlv_tag, tlv_len;
1346 if (len < sizeof(*tlv)) {
1347 ath11k_err(ab, "htt tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n",
1348 ptr - begin, len, sizeof(*tlv));
1351 tlv = (struct htt_tlv *)ptr;
1352 tlv_tag = FIELD_GET(HTT_TLV_TAG, tlv->header);
1353 tlv_len = FIELD_GET(HTT_TLV_LEN, tlv->header);
1354 ptr += sizeof(*tlv);
1355 len -= sizeof(*tlv);
1357 if (tlv_len > len) {
1358 ath11k_err(ab, "htt tlv parse failure of tag %u at byte %zd (%zu bytes left, %u expected)\n",
1359 tlv_tag, ptr - begin, len, tlv_len);
1362 ret = iter(ab, tlv_tag, tlv_len, ptr, data);
1373 ath11k_update_per_peer_tx_stats(struct ath11k *ar,
1374 struct htt_ppdu_stats *ppdu_stats, u8 user)
1376 struct ath11k_base *ab = ar->ab;
1377 struct ath11k_peer *peer;
1378 struct ieee80211_sta *sta;
1379 struct ath11k_sta *arsta;
1380 struct htt_ppdu_stats_user_rate *user_rate;
1381 struct ath11k_per_peer_tx_stats *peer_stats = &ar->peer_tx_stats;
1382 struct htt_ppdu_user_stats *usr_stats = &ppdu_stats->user_stats[user];
1383 struct htt_ppdu_stats_common *common = &ppdu_stats->common;
1385 u8 flags, mcs, nss, bw, sgi, dcm, rate_idx = 0;
1387 u16 rate = 0, succ_pkts = 0;
1388 u32 tx_duration = 0;
1389 u8 tid = HTT_PPDU_STATS_NON_QOS_TID;
1390 bool is_ampdu = false;
1392 if (!(usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_RATE)))
1395 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON))
1397 HTT_USR_CMPLTN_IS_AMPDU(usr_stats->cmpltn_cmn.flags);
1399 if (usr_stats->tlv_flags &
1400 BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS)) {
1401 succ_bytes = usr_stats->ack_ba.success_bytes;
1402 succ_pkts = FIELD_GET(HTT_PPDU_STATS_ACK_BA_INFO_NUM_MSDU_M,
1403 usr_stats->ack_ba.info);
1404 tid = FIELD_GET(HTT_PPDU_STATS_ACK_BA_INFO_TID_NUM,
1405 usr_stats->ack_ba.info);
1408 if (common->fes_duration_us)
1409 tx_duration = common->fes_duration_us;
1411 user_rate = &usr_stats->rate;
1412 flags = HTT_USR_RATE_PREAMBLE(user_rate->rate_flags);
1413 bw = HTT_USR_RATE_BW(user_rate->rate_flags) - 2;
1414 nss = HTT_USR_RATE_NSS(user_rate->rate_flags) + 1;
1415 mcs = HTT_USR_RATE_MCS(user_rate->rate_flags);
1416 sgi = HTT_USR_RATE_GI(user_rate->rate_flags);
1417 dcm = HTT_USR_RATE_DCM(user_rate->rate_flags);
1419 /* Note: If host configured fixed rates and in some other special
1420 * cases, the broadcast/management frames are sent in different rates.
1421 * Firmware rate's control to be skipped for this?
1424 if (flags == WMI_RATE_PREAMBLE_HE && mcs > ATH11K_HE_MCS_MAX) {
1425 ath11k_warn(ab, "Invalid HE mcs %d peer stats", mcs);
1429 if (flags == WMI_RATE_PREAMBLE_VHT && mcs > ATH11K_VHT_MCS_MAX) {
1430 ath11k_warn(ab, "Invalid VHT mcs %d peer stats", mcs);
1434 if (flags == WMI_RATE_PREAMBLE_HT && (mcs > ATH11K_HT_MCS_MAX || nss < 1)) {
1435 ath11k_warn(ab, "Invalid HT mcs %d nss %d peer stats",
1440 if (flags == WMI_RATE_PREAMBLE_CCK || flags == WMI_RATE_PREAMBLE_OFDM) {
1441 ret = ath11k_mac_hw_ratecode_to_legacy_rate(mcs,
1450 spin_lock_bh(&ab->base_lock);
1451 peer = ath11k_peer_find_by_id(ab, usr_stats->peer_id);
1453 if (!peer || !peer->sta) {
1454 spin_unlock_bh(&ab->base_lock);
1460 arsta = ath11k_sta_to_arsta(sta);
1462 memset(&arsta->txrate, 0, sizeof(arsta->txrate));
1465 case WMI_RATE_PREAMBLE_OFDM:
1466 arsta->txrate.legacy = rate;
1468 case WMI_RATE_PREAMBLE_CCK:
1469 arsta->txrate.legacy = rate;
1471 case WMI_RATE_PREAMBLE_HT:
1472 arsta->txrate.mcs = mcs + 8 * (nss - 1);
1473 arsta->txrate.flags = RATE_INFO_FLAGS_MCS;
1475 arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1477 case WMI_RATE_PREAMBLE_VHT:
1478 arsta->txrate.mcs = mcs;
1479 arsta->txrate.flags = RATE_INFO_FLAGS_VHT_MCS;
1481 arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1483 case WMI_RATE_PREAMBLE_HE:
1484 arsta->txrate.mcs = mcs;
1485 arsta->txrate.flags = RATE_INFO_FLAGS_HE_MCS;
1486 arsta->txrate.he_dcm = dcm;
1487 arsta->txrate.he_gi = ath11k_mac_he_gi_to_nl80211_he_gi(sgi);
1488 arsta->txrate.he_ru_alloc = ath11k_mac_phy_he_ru_to_nl80211_he_ru_alloc
1489 ((user_rate->ru_end -
1490 user_rate->ru_start) + 1);
1494 arsta->txrate.nss = nss;
1496 arsta->txrate.bw = ath11k_mac_bw_to_mac80211_bw(bw);
1497 arsta->tx_duration += tx_duration;
1498 memcpy(&arsta->last_txrate, &arsta->txrate, sizeof(struct rate_info));
1500 /* PPDU stats reported for mgmt packet doesn't have valid tx bytes.
1501 * So skip peer stats update for mgmt packets.
1503 if (tid < HTT_PPDU_STATS_NON_QOS_TID) {
1504 memset(peer_stats, 0, sizeof(*peer_stats));
1505 peer_stats->succ_pkts = succ_pkts;
1506 peer_stats->succ_bytes = succ_bytes;
1507 peer_stats->is_ampdu = is_ampdu;
1508 peer_stats->duration = tx_duration;
1509 peer_stats->ba_fails =
1510 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) +
1511 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags);
1513 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar))
1514 ath11k_debugfs_sta_add_tx_stats(arsta, peer_stats, rate_idx);
1517 spin_unlock_bh(&ab->base_lock);
1521 static void ath11k_htt_update_ppdu_stats(struct ath11k *ar,
1522 struct htt_ppdu_stats *ppdu_stats)
1526 for (user = 0; user < HTT_PPDU_STATS_MAX_USERS - 1; user++)
1527 ath11k_update_per_peer_tx_stats(ar, ppdu_stats, user);
1531 struct htt_ppdu_stats_info *ath11k_dp_htt_get_ppdu_desc(struct ath11k *ar,
1534 struct htt_ppdu_stats_info *ppdu_info;
1536 lockdep_assert_held(&ar->data_lock);
1538 if (!list_empty(&ar->ppdu_stats_info)) {
1539 list_for_each_entry(ppdu_info, &ar->ppdu_stats_info, list) {
1540 if (ppdu_info->ppdu_id == ppdu_id)
1544 if (ar->ppdu_stat_list_depth > HTT_PPDU_DESC_MAX_DEPTH) {
1545 ppdu_info = list_first_entry(&ar->ppdu_stats_info,
1546 typeof(*ppdu_info), list);
1547 list_del(&ppdu_info->list);
1548 ar->ppdu_stat_list_depth--;
1549 ath11k_htt_update_ppdu_stats(ar, &ppdu_info->ppdu_stats);
1554 ppdu_info = kzalloc(sizeof(*ppdu_info), GFP_ATOMIC);
1558 list_add_tail(&ppdu_info->list, &ar->ppdu_stats_info);
1559 ar->ppdu_stat_list_depth++;
1564 static int ath11k_htt_pull_ppdu_stats(struct ath11k_base *ab,
1565 struct sk_buff *skb)
1567 struct ath11k_htt_ppdu_stats_msg *msg;
1568 struct htt_ppdu_stats_info *ppdu_info;
1574 msg = (struct ath11k_htt_ppdu_stats_msg *)skb->data;
1575 len = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PAYLOAD_SIZE, msg->info);
1576 pdev_id = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PDEV_ID, msg->info);
1577 ppdu_id = msg->ppdu_id;
1580 ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
1586 if (ath11k_debugfs_is_pktlog_lite_mode_enabled(ar))
1587 trace_ath11k_htt_ppdu_stats(ar, skb->data, len);
1589 spin_lock_bh(&ar->data_lock);
1590 ppdu_info = ath11k_dp_htt_get_ppdu_desc(ar, ppdu_id);
1593 goto out_unlock_data;
1596 ppdu_info->ppdu_id = ppdu_id;
1597 ret = ath11k_dp_htt_tlv_iter(ab, msg->data, len,
1598 ath11k_htt_tlv_ppdu_stats_parse,
1601 ath11k_warn(ab, "Failed to parse tlv %d\n", ret);
1602 goto out_unlock_data;
1606 spin_unlock_bh(&ar->data_lock);
1614 static void ath11k_htt_pktlog(struct ath11k_base *ab, struct sk_buff *skb)
1616 struct htt_pktlog_msg *data = (struct htt_pktlog_msg *)skb->data;
1617 struct ath_pktlog_hdr *hdr = (struct ath_pktlog_hdr *)data;
1621 pdev_id = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PDEV_ID, data->hdr);
1625 ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
1627 ath11k_warn(ab, "invalid pdev id %d on htt pktlog\n", pdev_id);
1631 trace_ath11k_htt_pktlog(ar, data->payload, hdr->size,
1632 ar->ab->pktlog_defs_checksum);
1638 static void ath11k_htt_backpressure_event_handler(struct ath11k_base *ab,
1639 struct sk_buff *skb)
1641 u32 *data = (u32 *)skb->data;
1642 u8 pdev_id, ring_type, ring_id, pdev_idx;
1644 u32 backpressure_time;
1645 struct ath11k_bp_stats *bp_stats;
1647 pdev_id = FIELD_GET(HTT_BACKPRESSURE_EVENT_PDEV_ID_M, *data);
1648 ring_type = FIELD_GET(HTT_BACKPRESSURE_EVENT_RING_TYPE_M, *data);
1649 ring_id = FIELD_GET(HTT_BACKPRESSURE_EVENT_RING_ID_M, *data);
1652 hp = FIELD_GET(HTT_BACKPRESSURE_EVENT_HP_M, *data);
1653 tp = FIELD_GET(HTT_BACKPRESSURE_EVENT_TP_M, *data);
1656 backpressure_time = *data;
1658 ath11k_dbg(ab, ATH11K_DBG_DP_HTT, "backpressure event, pdev %d, ring type %d,ring id %d, hp %d tp %d, backpressure time %d\n",
1659 pdev_id, ring_type, ring_id, hp, tp, backpressure_time);
1661 if (ring_type == HTT_BACKPRESSURE_UMAC_RING_TYPE) {
1662 if (ring_id >= HTT_SW_UMAC_RING_IDX_MAX)
1665 bp_stats = &ab->soc_stats.bp_stats.umac_ring_bp_stats[ring_id];
1666 } else if (ring_type == HTT_BACKPRESSURE_LMAC_RING_TYPE) {
1667 pdev_idx = DP_HW2SW_MACID(pdev_id);
1669 if (ring_id >= HTT_SW_LMAC_RING_IDX_MAX || pdev_idx >= MAX_RADIOS)
1672 bp_stats = &ab->soc_stats.bp_stats.lmac_ring_bp_stats[ring_id][pdev_idx];
1674 ath11k_warn(ab, "unknown ring type received in htt bp event %d\n",
1679 spin_lock_bh(&ab->base_lock);
1683 bp_stats->jiffies = jiffies;
1684 spin_unlock_bh(&ab->base_lock);
1687 void ath11k_dp_htt_htc_t2h_msg_handler(struct ath11k_base *ab,
1688 struct sk_buff *skb)
1690 struct ath11k_dp *dp = &ab->dp;
1691 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data;
1692 enum htt_t2h_msg_type type = FIELD_GET(HTT_T2H_MSG_TYPE, *(u32 *)resp);
1695 u8 mac_addr[ETH_ALEN];
1700 ath11k_dbg(ab, ATH11K_DBG_DP_HTT, "dp_htt rx msg type :0x%0x\n", type);
1703 case HTT_T2H_MSG_TYPE_VERSION_CONF:
1704 dp->htt_tgt_ver_major = FIELD_GET(HTT_T2H_VERSION_CONF_MAJOR,
1705 resp->version_msg.version);
1706 dp->htt_tgt_ver_minor = FIELD_GET(HTT_T2H_VERSION_CONF_MINOR,
1707 resp->version_msg.version);
1708 complete(&dp->htt_tgt_version_received);
1710 case HTT_T2H_MSG_TYPE_PEER_MAP:
1711 vdev_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_VDEV_ID,
1712 resp->peer_map_ev.info);
1713 peer_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_PEER_ID,
1714 resp->peer_map_ev.info);
1715 peer_mac_h16 = FIELD_GET(HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16,
1716 resp->peer_map_ev.info1);
1717 ath11k_dp_get_mac_addr(resp->peer_map_ev.mac_addr_l32,
1718 peer_mac_h16, mac_addr);
1719 ath11k_peer_map_event(ab, vdev_id, peer_id, mac_addr, 0, 0);
1721 case HTT_T2H_MSG_TYPE_PEER_MAP2:
1722 vdev_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_VDEV_ID,
1723 resp->peer_map_ev.info);
1724 peer_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_PEER_ID,
1725 resp->peer_map_ev.info);
1726 peer_mac_h16 = FIELD_GET(HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16,
1727 resp->peer_map_ev.info1);
1728 ath11k_dp_get_mac_addr(resp->peer_map_ev.mac_addr_l32,
1729 peer_mac_h16, mac_addr);
1730 ast_hash = FIELD_GET(HTT_T2H_PEER_MAP_INFO2_AST_HASH_VAL,
1731 resp->peer_map_ev.info2);
1732 hw_peer_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO1_HW_PEER_ID,
1733 resp->peer_map_ev.info1);
1734 ath11k_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash,
1737 case HTT_T2H_MSG_TYPE_PEER_UNMAP:
1738 case HTT_T2H_MSG_TYPE_PEER_UNMAP2:
1739 peer_id = FIELD_GET(HTT_T2H_PEER_UNMAP_INFO_PEER_ID,
1740 resp->peer_unmap_ev.info);
1741 ath11k_peer_unmap_event(ab, peer_id);
1743 case HTT_T2H_MSG_TYPE_PPDU_STATS_IND:
1744 ath11k_htt_pull_ppdu_stats(ab, skb);
1746 case HTT_T2H_MSG_TYPE_EXT_STATS_CONF:
1747 ath11k_debugfs_htt_ext_stats_handler(ab, skb);
1749 case HTT_T2H_MSG_TYPE_PKTLOG:
1750 ath11k_htt_pktlog(ab, skb);
1752 case HTT_T2H_MSG_TYPE_BKPRESSURE_EVENT_IND:
1753 ath11k_htt_backpressure_event_handler(ab, skb);
1756 ath11k_warn(ab, "htt event %d not handled\n", type);
1760 dev_kfree_skb_any(skb);
1763 static int ath11k_dp_rx_msdu_coalesce(struct ath11k *ar,
1764 struct sk_buff_head *msdu_list,
1765 struct sk_buff *first, struct sk_buff *last,
1766 u8 l3pad_bytes, int msdu_len)
1768 struct ath11k_base *ab = ar->ab;
1769 struct sk_buff *skb;
1770 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(first);
1771 int buf_first_hdr_len, buf_first_len;
1772 struct hal_rx_desc *ldesc;
1773 int space_extra, rem_len, buf_len;
1774 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
1776 /* As the msdu is spread across multiple rx buffers,
1777 * find the offset to the start of msdu for computing
1778 * the length of the msdu in the first buffer.
1780 buf_first_hdr_len = hal_rx_desc_sz + l3pad_bytes;
1781 buf_first_len = DP_RX_BUFFER_SIZE - buf_first_hdr_len;
1783 if (WARN_ON_ONCE(msdu_len <= buf_first_len)) {
1784 skb_put(first, buf_first_hdr_len + msdu_len);
1785 skb_pull(first, buf_first_hdr_len);
1789 ldesc = (struct hal_rx_desc *)last->data;
1790 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(ab, ldesc);
1791 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(ab, ldesc);
1793 /* MSDU spans over multiple buffers because the length of the MSDU
1794 * exceeds DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE. So assume the data
1795 * in the first buf is of length DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE.
1797 skb_put(first, DP_RX_BUFFER_SIZE);
1798 skb_pull(first, buf_first_hdr_len);
1800 /* When an MSDU spread over multiple buffers attention, MSDU_END and
1801 * MPDU_END tlvs are valid only in the last buffer. Copy those tlvs.
1803 ath11k_dp_rx_desc_end_tlv_copy(ab, rxcb->rx_desc, ldesc);
1805 space_extra = msdu_len - (buf_first_len + skb_tailroom(first));
1806 if (space_extra > 0 &&
1807 (pskb_expand_head(first, 0, space_extra, GFP_ATOMIC) < 0)) {
1808 /* Free up all buffers of the MSDU */
1809 while ((skb = __skb_dequeue(msdu_list)) != NULL) {
1810 rxcb = ATH11K_SKB_RXCB(skb);
1811 if (!rxcb->is_continuation) {
1812 dev_kfree_skb_any(skb);
1815 dev_kfree_skb_any(skb);
1820 rem_len = msdu_len - buf_first_len;
1821 while ((skb = __skb_dequeue(msdu_list)) != NULL && rem_len > 0) {
1822 rxcb = ATH11K_SKB_RXCB(skb);
1823 if (rxcb->is_continuation)
1824 buf_len = DP_RX_BUFFER_SIZE - hal_rx_desc_sz;
1828 if (buf_len > (DP_RX_BUFFER_SIZE - hal_rx_desc_sz)) {
1830 dev_kfree_skb_any(skb);
1834 skb_put(skb, buf_len + hal_rx_desc_sz);
1835 skb_pull(skb, hal_rx_desc_sz);
1836 skb_copy_from_linear_data(skb, skb_put(first, buf_len),
1838 dev_kfree_skb_any(skb);
1841 if (!rxcb->is_continuation)
1848 static struct sk_buff *ath11k_dp_rx_get_msdu_last_buf(struct sk_buff_head *msdu_list,
1849 struct sk_buff *first)
1851 struct sk_buff *skb;
1852 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(first);
1854 if (!rxcb->is_continuation)
1857 skb_queue_walk(msdu_list, skb) {
1858 rxcb = ATH11K_SKB_RXCB(skb);
1859 if (!rxcb->is_continuation)
1866 static void ath11k_dp_rx_h_csum_offload(struct ath11k *ar, struct sk_buff *msdu)
1868 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1869 struct rx_attention *rx_attention;
1870 bool ip_csum_fail, l4_csum_fail;
1872 rx_attention = ath11k_dp_rx_get_attention(ar->ab, rxcb->rx_desc);
1873 ip_csum_fail = ath11k_dp_rx_h_attn_ip_cksum_fail(rx_attention);
1874 l4_csum_fail = ath11k_dp_rx_h_attn_l4_cksum_fail(rx_attention);
1876 msdu->ip_summed = (ip_csum_fail || l4_csum_fail) ?
1877 CHECKSUM_NONE : CHECKSUM_UNNECESSARY;
1880 static int ath11k_dp_rx_crypto_mic_len(struct ath11k *ar,
1881 enum hal_encrypt_type enctype)
1884 case HAL_ENCRYPT_TYPE_OPEN:
1885 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1886 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1888 case HAL_ENCRYPT_TYPE_CCMP_128:
1889 return IEEE80211_CCMP_MIC_LEN;
1890 case HAL_ENCRYPT_TYPE_CCMP_256:
1891 return IEEE80211_CCMP_256_MIC_LEN;
1892 case HAL_ENCRYPT_TYPE_GCMP_128:
1893 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1894 return IEEE80211_GCMP_MIC_LEN;
1895 case HAL_ENCRYPT_TYPE_WEP_40:
1896 case HAL_ENCRYPT_TYPE_WEP_104:
1897 case HAL_ENCRYPT_TYPE_WEP_128:
1898 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1899 case HAL_ENCRYPT_TYPE_WAPI:
1903 ath11k_warn(ar->ab, "unsupported encryption type %d for mic len\n", enctype);
1907 static int ath11k_dp_rx_crypto_param_len(struct ath11k *ar,
1908 enum hal_encrypt_type enctype)
1911 case HAL_ENCRYPT_TYPE_OPEN:
1913 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1914 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1915 return IEEE80211_TKIP_IV_LEN;
1916 case HAL_ENCRYPT_TYPE_CCMP_128:
1917 return IEEE80211_CCMP_HDR_LEN;
1918 case HAL_ENCRYPT_TYPE_CCMP_256:
1919 return IEEE80211_CCMP_256_HDR_LEN;
1920 case HAL_ENCRYPT_TYPE_GCMP_128:
1921 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1922 return IEEE80211_GCMP_HDR_LEN;
1923 case HAL_ENCRYPT_TYPE_WEP_40:
1924 case HAL_ENCRYPT_TYPE_WEP_104:
1925 case HAL_ENCRYPT_TYPE_WEP_128:
1926 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1927 case HAL_ENCRYPT_TYPE_WAPI:
1931 ath11k_warn(ar->ab, "unsupported encryption type %d\n", enctype);
1935 static int ath11k_dp_rx_crypto_icv_len(struct ath11k *ar,
1936 enum hal_encrypt_type enctype)
1939 case HAL_ENCRYPT_TYPE_OPEN:
1940 case HAL_ENCRYPT_TYPE_CCMP_128:
1941 case HAL_ENCRYPT_TYPE_CCMP_256:
1942 case HAL_ENCRYPT_TYPE_GCMP_128:
1943 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1945 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1946 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1947 return IEEE80211_TKIP_ICV_LEN;
1948 case HAL_ENCRYPT_TYPE_WEP_40:
1949 case HAL_ENCRYPT_TYPE_WEP_104:
1950 case HAL_ENCRYPT_TYPE_WEP_128:
1951 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1952 case HAL_ENCRYPT_TYPE_WAPI:
1956 ath11k_warn(ar->ab, "unsupported encryption type %d\n", enctype);
1960 static void ath11k_dp_rx_h_undecap_nwifi(struct ath11k *ar,
1961 struct sk_buff *msdu,
1963 enum hal_encrypt_type enctype,
1964 struct ieee80211_rx_status *status)
1966 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1967 u8 decap_hdr[DP_MAX_NWIFI_HDR_LEN];
1968 struct ieee80211_hdr *hdr;
1975 /* copy SA & DA and pull decapped header */
1976 hdr = (struct ieee80211_hdr *)msdu->data;
1977 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1978 ether_addr_copy(da, ieee80211_get_DA(hdr));
1979 ether_addr_copy(sa, ieee80211_get_SA(hdr));
1980 skb_pull(msdu, ieee80211_hdrlen(hdr->frame_control));
1982 if (rxcb->is_first_msdu) {
1983 /* original 802.11 header is valid for the first msdu
1984 * hence we can reuse the same header
1986 hdr = (struct ieee80211_hdr *)first_hdr;
1987 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1989 /* Each A-MSDU subframe will be reported as a separate MSDU,
1990 * so strip the A-MSDU bit from QoS Ctl.
1992 if (ieee80211_is_data_qos(hdr->frame_control)) {
1993 qos = ieee80211_get_qos_ctl(hdr);
1994 qos[0] &= ~IEEE80211_QOS_CTL_A_MSDU_PRESENT;
1997 /* Rebuild qos header if this is a middle/last msdu */
1998 hdr->frame_control |= __cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
2000 /* Reset the order bit as the HT_Control header is stripped */
2001 hdr->frame_control &= ~(__cpu_to_le16(IEEE80211_FCTL_ORDER));
2003 qos_ctl = rxcb->tid;
2005 if (ath11k_dp_rx_h_msdu_start_mesh_ctl_present(ar->ab, rxcb->rx_desc))
2006 qos_ctl |= IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT;
2008 /* TODO Add other QoS ctl fields when required */
2010 /* copy decap header before overwriting for reuse below */
2011 memcpy(decap_hdr, (uint8_t *)hdr, hdr_len);
2014 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
2015 memcpy(skb_push(msdu,
2016 ath11k_dp_rx_crypto_param_len(ar, enctype)),
2017 (void *)hdr + hdr_len,
2018 ath11k_dp_rx_crypto_param_len(ar, enctype));
2021 if (!rxcb->is_first_msdu) {
2022 memcpy(skb_push(msdu,
2023 IEEE80211_QOS_CTL_LEN), &qos_ctl,
2024 IEEE80211_QOS_CTL_LEN);
2025 memcpy(skb_push(msdu, hdr_len), decap_hdr, hdr_len);
2029 memcpy(skb_push(msdu, hdr_len), hdr, hdr_len);
2031 /* original 802.11 header has a different DA and in
2032 * case of 4addr it may also have different SA
2034 hdr = (struct ieee80211_hdr *)msdu->data;
2035 ether_addr_copy(ieee80211_get_DA(hdr), da);
2036 ether_addr_copy(ieee80211_get_SA(hdr), sa);
2039 static void ath11k_dp_rx_h_undecap_raw(struct ath11k *ar, struct sk_buff *msdu,
2040 enum hal_encrypt_type enctype,
2041 struct ieee80211_rx_status *status,
2044 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
2045 struct ieee80211_hdr *hdr;
2049 if (!rxcb->is_first_msdu ||
2050 !(rxcb->is_first_msdu && rxcb->is_last_msdu)) {
2055 skb_trim(msdu, msdu->len - FCS_LEN);
2060 hdr = (void *)msdu->data;
2063 if (status->flag & RX_FLAG_IV_STRIPPED) {
2064 skb_trim(msdu, msdu->len -
2065 ath11k_dp_rx_crypto_mic_len(ar, enctype));
2067 skb_trim(msdu, msdu->len -
2068 ath11k_dp_rx_crypto_icv_len(ar, enctype));
2071 if (status->flag & RX_FLAG_MIC_STRIPPED)
2072 skb_trim(msdu, msdu->len -
2073 ath11k_dp_rx_crypto_mic_len(ar, enctype));
2076 if (status->flag & RX_FLAG_ICV_STRIPPED)
2077 skb_trim(msdu, msdu->len -
2078 ath11k_dp_rx_crypto_icv_len(ar, enctype));
2082 if ((status->flag & RX_FLAG_MMIC_STRIPPED) &&
2083 !ieee80211_has_morefrags(hdr->frame_control) &&
2084 enctype == HAL_ENCRYPT_TYPE_TKIP_MIC)
2085 skb_trim(msdu, msdu->len - IEEE80211_CCMP_MIC_LEN);
2088 if (status->flag & RX_FLAG_IV_STRIPPED) {
2089 hdr_len = ieee80211_hdrlen(hdr->frame_control);
2090 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
2092 memmove((void *)msdu->data + crypto_len,
2093 (void *)msdu->data, hdr_len);
2094 skb_pull(msdu, crypto_len);
2098 static void *ath11k_dp_rx_h_find_rfc1042(struct ath11k *ar,
2099 struct sk_buff *msdu,
2100 enum hal_encrypt_type enctype)
2102 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
2103 struct ieee80211_hdr *hdr;
2104 size_t hdr_len, crypto_len;
2108 is_amsdu = !(rxcb->is_first_msdu && rxcb->is_last_msdu);
2109 hdr = (struct ieee80211_hdr *)ath11k_dp_rx_h_80211_hdr(ar->ab, rxcb->rx_desc);
2112 if (rxcb->is_first_msdu) {
2113 hdr_len = ieee80211_hdrlen(hdr->frame_control);
2114 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
2116 rfc1042 += hdr_len + crypto_len;
2120 rfc1042 += sizeof(struct ath11k_dp_amsdu_subframe_hdr);
2125 static void ath11k_dp_rx_h_undecap_eth(struct ath11k *ar,
2126 struct sk_buff *msdu,
2128 enum hal_encrypt_type enctype,
2129 struct ieee80211_rx_status *status)
2131 struct ieee80211_hdr *hdr;
2138 rfc1042 = ath11k_dp_rx_h_find_rfc1042(ar, msdu, enctype);
2139 if (WARN_ON_ONCE(!rfc1042))
2142 /* pull decapped header and copy SA & DA */
2143 eth = (struct ethhdr *)msdu->data;
2144 ether_addr_copy(da, eth->h_dest);
2145 ether_addr_copy(sa, eth->h_source);
2146 skb_pull(msdu, sizeof(struct ethhdr));
2148 /* push rfc1042/llc/snap */
2149 memcpy(skb_push(msdu, sizeof(struct ath11k_dp_rfc1042_hdr)), rfc1042,
2150 sizeof(struct ath11k_dp_rfc1042_hdr));
2152 /* push original 802.11 header */
2153 hdr = (struct ieee80211_hdr *)first_hdr;
2154 hdr_len = ieee80211_hdrlen(hdr->frame_control);
2156 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
2157 memcpy(skb_push(msdu,
2158 ath11k_dp_rx_crypto_param_len(ar, enctype)),
2159 (void *)hdr + hdr_len,
2160 ath11k_dp_rx_crypto_param_len(ar, enctype));
2163 memcpy(skb_push(msdu, hdr_len), hdr, hdr_len);
2165 /* original 802.11 header has a different DA and in
2166 * case of 4addr it may also have different SA
2168 hdr = (struct ieee80211_hdr *)msdu->data;
2169 ether_addr_copy(ieee80211_get_DA(hdr), da);
2170 ether_addr_copy(ieee80211_get_SA(hdr), sa);
2173 static void ath11k_dp_rx_h_undecap(struct ath11k *ar, struct sk_buff *msdu,
2174 struct hal_rx_desc *rx_desc,
2175 enum hal_encrypt_type enctype,
2176 struct ieee80211_rx_status *status,
2181 struct ethhdr *ehdr;
2183 first_hdr = ath11k_dp_rx_h_80211_hdr(ar->ab, rx_desc);
2184 decap = ath11k_dp_rx_h_msdu_start_decap_type(ar->ab, rx_desc);
2187 case DP_RX_DECAP_TYPE_NATIVE_WIFI:
2188 ath11k_dp_rx_h_undecap_nwifi(ar, msdu, first_hdr,
2191 case DP_RX_DECAP_TYPE_RAW:
2192 ath11k_dp_rx_h_undecap_raw(ar, msdu, enctype, status,
2195 case DP_RX_DECAP_TYPE_ETHERNET2_DIX:
2196 ehdr = (struct ethhdr *)msdu->data;
2198 /* mac80211 allows fast path only for authorized STA */
2199 if (ehdr->h_proto == cpu_to_be16(ETH_P_PAE)) {
2200 ATH11K_SKB_RXCB(msdu)->is_eapol = true;
2201 ath11k_dp_rx_h_undecap_eth(ar, msdu, first_hdr,
2206 /* PN for mcast packets will be validated in mac80211;
2207 * remove eth header and add 802.11 header.
2209 if (ATH11K_SKB_RXCB(msdu)->is_mcbc && decrypted)
2210 ath11k_dp_rx_h_undecap_eth(ar, msdu, first_hdr,
2213 case DP_RX_DECAP_TYPE_8023:
2214 /* TODO: Handle undecap for these formats */
2219 static struct ath11k_peer *
2220 ath11k_dp_rx_h_find_peer(struct ath11k_base *ab, struct sk_buff *msdu)
2222 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
2223 struct hal_rx_desc *rx_desc = rxcb->rx_desc;
2224 struct ath11k_peer *peer = NULL;
2226 lockdep_assert_held(&ab->base_lock);
2229 peer = ath11k_peer_find_by_id(ab, rxcb->peer_id);
2234 if (!rx_desc || !(ath11k_dp_rxdesc_mac_addr2_valid(ab, rx_desc)))
2237 peer = ath11k_peer_find_by_addr(ab,
2238 ath11k_dp_rxdesc_mpdu_start_addr2(ab, rx_desc));
2242 static void ath11k_dp_rx_h_mpdu(struct ath11k *ar,
2243 struct sk_buff *msdu,
2244 struct hal_rx_desc *rx_desc,
2245 struct ieee80211_rx_status *rx_status)
2247 bool fill_crypto_hdr;
2248 enum hal_encrypt_type enctype;
2249 bool is_decrypted = false;
2250 struct ath11k_skb_rxcb *rxcb;
2251 struct ieee80211_hdr *hdr;
2252 struct ath11k_peer *peer;
2253 struct rx_attention *rx_attention;
2256 /* PN for multicast packets will be checked in mac80211 */
2257 rxcb = ATH11K_SKB_RXCB(msdu);
2258 fill_crypto_hdr = ath11k_dp_rx_h_attn_is_mcbc(ar->ab, rx_desc);
2259 rxcb->is_mcbc = fill_crypto_hdr;
2261 if (rxcb->is_mcbc) {
2262 rxcb->peer_id = ath11k_dp_rx_h_mpdu_start_peer_id(ar->ab, rx_desc);
2263 rxcb->seq_no = ath11k_dp_rx_h_mpdu_start_seq_no(ar->ab, rx_desc);
2266 spin_lock_bh(&ar->ab->base_lock);
2267 peer = ath11k_dp_rx_h_find_peer(ar->ab, msdu);
2270 enctype = peer->sec_type_grp;
2272 enctype = peer->sec_type;
2274 enctype = ath11k_dp_rx_h_mpdu_start_enctype(ar->ab, rx_desc);
2276 spin_unlock_bh(&ar->ab->base_lock);
2278 rx_attention = ath11k_dp_rx_get_attention(ar->ab, rx_desc);
2279 err_bitmap = ath11k_dp_rx_h_attn_mpdu_err(rx_attention);
2280 if (enctype != HAL_ENCRYPT_TYPE_OPEN && !err_bitmap)
2281 is_decrypted = ath11k_dp_rx_h_attn_is_decrypted(rx_attention);
2283 /* Clear per-MPDU flags while leaving per-PPDU flags intact */
2284 rx_status->flag &= ~(RX_FLAG_FAILED_FCS_CRC |
2285 RX_FLAG_MMIC_ERROR |
2287 RX_FLAG_IV_STRIPPED |
2288 RX_FLAG_MMIC_STRIPPED);
2290 if (err_bitmap & DP_RX_MPDU_ERR_FCS)
2291 rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
2292 if (err_bitmap & DP_RX_MPDU_ERR_TKIP_MIC)
2293 rx_status->flag |= RX_FLAG_MMIC_ERROR;
2296 rx_status->flag |= RX_FLAG_DECRYPTED | RX_FLAG_MMIC_STRIPPED;
2298 if (fill_crypto_hdr)
2299 rx_status->flag |= RX_FLAG_MIC_STRIPPED |
2300 RX_FLAG_ICV_STRIPPED;
2302 rx_status->flag |= RX_FLAG_IV_STRIPPED |
2303 RX_FLAG_PN_VALIDATED;
2306 ath11k_dp_rx_h_csum_offload(ar, msdu);
2307 ath11k_dp_rx_h_undecap(ar, msdu, rx_desc,
2308 enctype, rx_status, is_decrypted);
2310 if (!is_decrypted || fill_crypto_hdr)
2313 if (ath11k_dp_rx_h_msdu_start_decap_type(ar->ab, rx_desc) !=
2314 DP_RX_DECAP_TYPE_ETHERNET2_DIX) {
2315 hdr = (void *)msdu->data;
2316 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_PROTECTED);
2320 static void ath11k_dp_rx_h_rate(struct ath11k *ar, struct hal_rx_desc *rx_desc,
2321 struct ieee80211_rx_status *rx_status)
2323 struct ieee80211_supported_band *sband;
2324 enum rx_msdu_start_pkt_type pkt_type;
2328 bool is_cck, is_ldpc;
2330 pkt_type = ath11k_dp_rx_h_msdu_start_pkt_type(ar->ab, rx_desc);
2331 bw = ath11k_dp_rx_h_msdu_start_rx_bw(ar->ab, rx_desc);
2332 rate_mcs = ath11k_dp_rx_h_msdu_start_rate_mcs(ar->ab, rx_desc);
2333 nss = ath11k_dp_rx_h_msdu_start_nss(ar->ab, rx_desc);
2334 sgi = ath11k_dp_rx_h_msdu_start_sgi(ar->ab, rx_desc);
2337 case RX_MSDU_START_PKT_TYPE_11A:
2338 case RX_MSDU_START_PKT_TYPE_11B:
2339 is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B);
2340 sband = &ar->mac.sbands[rx_status->band];
2341 rx_status->rate_idx = ath11k_mac_hw_rate_to_idx(sband, rate_mcs,
2344 case RX_MSDU_START_PKT_TYPE_11N:
2345 rx_status->encoding = RX_ENC_HT;
2346 if (rate_mcs > ATH11K_HT_MCS_MAX) {
2348 "Received with invalid mcs in HT mode %d\n",
2352 rx_status->rate_idx = rate_mcs + (8 * (nss - 1));
2354 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
2355 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2357 case RX_MSDU_START_PKT_TYPE_11AC:
2358 rx_status->encoding = RX_ENC_VHT;
2359 rx_status->rate_idx = rate_mcs;
2360 if (rate_mcs > ATH11K_VHT_MCS_MAX) {
2362 "Received with invalid mcs in VHT mode %d\n",
2366 rx_status->nss = nss;
2368 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
2369 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2370 is_ldpc = ath11k_dp_rx_h_msdu_start_ldpc_support(ar->ab, rx_desc);
2372 rx_status->enc_flags |= RX_ENC_FLAG_LDPC;
2374 case RX_MSDU_START_PKT_TYPE_11AX:
2375 rx_status->rate_idx = rate_mcs;
2376 if (rate_mcs > ATH11K_HE_MCS_MAX) {
2378 "Received with invalid mcs in HE mode %d\n",
2382 rx_status->encoding = RX_ENC_HE;
2383 rx_status->nss = nss;
2384 rx_status->he_gi = ath11k_mac_he_gi_to_nl80211_he_gi(sgi);
2385 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2390 static void ath11k_dp_rx_h_ppdu(struct ath11k *ar, struct hal_rx_desc *rx_desc,
2391 struct ieee80211_rx_status *rx_status)
2394 u32 center_freq, meta_data;
2395 struct ieee80211_channel *channel;
2397 rx_status->freq = 0;
2398 rx_status->rate_idx = 0;
2400 rx_status->encoding = RX_ENC_LEGACY;
2401 rx_status->bw = RATE_INFO_BW_20;
2403 rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL;
2405 meta_data = ath11k_dp_rx_h_msdu_start_freq(ar->ab, rx_desc);
2406 channel_num = meta_data;
2407 center_freq = meta_data >> 16;
2409 if (center_freq >= ATH11K_MIN_6G_FREQ &&
2410 center_freq <= ATH11K_MAX_6G_FREQ) {
2411 rx_status->band = NL80211_BAND_6GHZ;
2412 rx_status->freq = center_freq;
2413 } else if (channel_num >= 1 && channel_num <= 14) {
2414 rx_status->band = NL80211_BAND_2GHZ;
2415 } else if (channel_num >= 36 && channel_num <= 177) {
2416 rx_status->band = NL80211_BAND_5GHZ;
2418 spin_lock_bh(&ar->data_lock);
2419 channel = ar->rx_channel;
2421 rx_status->band = channel->band;
2423 ieee80211_frequency_to_channel(channel->center_freq);
2425 spin_unlock_bh(&ar->data_lock);
2426 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "rx_desc: ",
2427 rx_desc, sizeof(struct hal_rx_desc));
2430 if (rx_status->band != NL80211_BAND_6GHZ)
2431 rx_status->freq = ieee80211_channel_to_frequency(channel_num,
2434 ath11k_dp_rx_h_rate(ar, rx_desc, rx_status);
2437 static void ath11k_dp_rx_deliver_msdu(struct ath11k *ar, struct napi_struct *napi,
2438 struct sk_buff *msdu,
2439 struct ieee80211_rx_status *status)
2441 static const struct ieee80211_radiotap_he known = {
2442 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
2443 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN),
2444 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN),
2446 struct ieee80211_rx_status *rx_status;
2447 struct ieee80211_radiotap_he *he = NULL;
2448 struct ieee80211_sta *pubsta = NULL;
2449 struct ath11k_peer *peer;
2450 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
2451 u8 decap = DP_RX_DECAP_TYPE_RAW;
2452 bool is_mcbc = rxcb->is_mcbc;
2453 bool is_eapol = rxcb->is_eapol;
2455 if (status->encoding == RX_ENC_HE &&
2456 !(status->flag & RX_FLAG_RADIOTAP_HE) &&
2457 !(status->flag & RX_FLAG_SKIP_MONITOR)) {
2458 he = skb_push(msdu, sizeof(known));
2459 memcpy(he, &known, sizeof(known));
2460 status->flag |= RX_FLAG_RADIOTAP_HE;
2463 if (!(status->flag & RX_FLAG_ONLY_MONITOR))
2464 decap = ath11k_dp_rx_h_msdu_start_decap_type(ar->ab, rxcb->rx_desc);
2466 spin_lock_bh(&ar->ab->base_lock);
2467 peer = ath11k_dp_rx_h_find_peer(ar->ab, msdu);
2468 if (peer && peer->sta)
2470 spin_unlock_bh(&ar->ab->base_lock);
2472 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
2473 "rx skb %p len %u peer %pM %d %s sn %u %s%s%s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u flag 0x%x fcs-err %i mic-err %i amsdu-more %i\n",
2476 peer ? peer->addr : NULL,
2478 is_mcbc ? "mcast" : "ucast",
2480 (status->encoding == RX_ENC_LEGACY) ? "legacy" : "",
2481 (status->encoding == RX_ENC_HT) ? "ht" : "",
2482 (status->encoding == RX_ENC_VHT) ? "vht" : "",
2483 (status->encoding == RX_ENC_HE) ? "he" : "",
2484 (status->bw == RATE_INFO_BW_40) ? "40" : "",
2485 (status->bw == RATE_INFO_BW_80) ? "80" : "",
2486 (status->bw == RATE_INFO_BW_160) ? "160" : "",
2487 status->enc_flags & RX_ENC_FLAG_SHORT_GI ? "sgi " : "",
2491 status->band, status->flag,
2492 !!(status->flag & RX_FLAG_FAILED_FCS_CRC),
2493 !!(status->flag & RX_FLAG_MMIC_ERROR),
2494 !!(status->flag & RX_FLAG_AMSDU_MORE));
2496 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DP_RX, NULL, "dp rx msdu: ",
2497 msdu->data, msdu->len);
2499 rx_status = IEEE80211_SKB_RXCB(msdu);
2500 *rx_status = *status;
2502 /* TODO: trace rx packet */
2504 /* PN for multicast packets are not validate in HW,
2505 * so skip 802.3 rx path
2506 * Also, fast_rx expects the STA to be authorized, hence
2507 * eapol packets are sent in slow path.
2509 if (decap == DP_RX_DECAP_TYPE_ETHERNET2_DIX && !is_eapol &&
2510 !(is_mcbc && rx_status->flag & RX_FLAG_DECRYPTED))
2511 rx_status->flag |= RX_FLAG_8023;
2513 ieee80211_rx_napi(ar->hw, pubsta, msdu, napi);
2516 static int ath11k_dp_rx_process_msdu(struct ath11k *ar,
2517 struct sk_buff *msdu,
2518 struct sk_buff_head *msdu_list,
2519 struct ieee80211_rx_status *rx_status)
2521 struct ath11k_base *ab = ar->ab;
2522 struct hal_rx_desc *rx_desc, *lrx_desc;
2523 struct rx_attention *rx_attention;
2524 struct ath11k_skb_rxcb *rxcb;
2525 struct sk_buff *last_buf;
2530 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
2532 last_buf = ath11k_dp_rx_get_msdu_last_buf(msdu_list, msdu);
2535 "No valid Rx buffer to access Atten/MSDU_END/MPDU_END tlvs\n");
2540 rx_desc = (struct hal_rx_desc *)msdu->data;
2541 if (ath11k_dp_rx_h_attn_msdu_len_err(ab, rx_desc)) {
2542 ath11k_warn(ar->ab, "msdu len not valid\n");
2547 lrx_desc = (struct hal_rx_desc *)last_buf->data;
2548 rx_attention = ath11k_dp_rx_get_attention(ab, lrx_desc);
2549 if (!ath11k_dp_rx_h_attn_msdu_done(rx_attention)) {
2550 ath11k_warn(ab, "msdu_done bit in attention is not set\n");
2555 rxcb = ATH11K_SKB_RXCB(msdu);
2556 rxcb->rx_desc = rx_desc;
2557 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(ab, rx_desc);
2558 l3_pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(ab, lrx_desc);
2560 if (rxcb->is_frag) {
2561 skb_pull(msdu, hal_rx_desc_sz);
2562 } else if (!rxcb->is_continuation) {
2563 if ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE) {
2564 hdr_status = ath11k_dp_rx_h_80211_hdr(ab, rx_desc);
2566 ath11k_warn(ab, "invalid msdu len %u\n", msdu_len);
2567 ath11k_dbg_dump(ab, ATH11K_DBG_DATA, NULL, "", hdr_status,
2568 sizeof(struct ieee80211_hdr));
2569 ath11k_dbg_dump(ab, ATH11K_DBG_DATA, NULL, "", rx_desc,
2570 sizeof(struct hal_rx_desc));
2573 skb_put(msdu, hal_rx_desc_sz + l3_pad_bytes + msdu_len);
2574 skb_pull(msdu, hal_rx_desc_sz + l3_pad_bytes);
2576 ret = ath11k_dp_rx_msdu_coalesce(ar, msdu_list,
2578 l3_pad_bytes, msdu_len);
2581 "failed to coalesce msdu rx buffer%d\n", ret);
2586 ath11k_dp_rx_h_ppdu(ar, rx_desc, rx_status);
2587 ath11k_dp_rx_h_mpdu(ar, msdu, rx_desc, rx_status);
2589 rx_status->flag |= RX_FLAG_SKIP_MONITOR | RX_FLAG_DUP_VALIDATED;
2597 static void ath11k_dp_rx_process_received_packets(struct ath11k_base *ab,
2598 struct napi_struct *napi,
2599 struct sk_buff_head *msdu_list,
2602 struct sk_buff *msdu;
2604 struct ieee80211_rx_status rx_status = {0};
2607 if (skb_queue_empty(msdu_list))
2610 if (unlikely(!rcu_access_pointer(ab->pdevs_active[mac_id]))) {
2611 __skb_queue_purge(msdu_list);
2615 ar = ab->pdevs[mac_id].ar;
2616 if (unlikely(test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags))) {
2617 __skb_queue_purge(msdu_list);
2621 while ((msdu = __skb_dequeue(msdu_list))) {
2622 ret = ath11k_dp_rx_process_msdu(ar, msdu, msdu_list, &rx_status);
2623 if (unlikely(ret)) {
2624 ath11k_dbg(ab, ATH11K_DBG_DATA,
2625 "Unable to process msdu %d", ret);
2626 dev_kfree_skb_any(msdu);
2630 ath11k_dp_rx_deliver_msdu(ar, napi, msdu, &rx_status);
2634 int ath11k_dp_process_rx(struct ath11k_base *ab, int ring_id,
2635 struct napi_struct *napi, int budget)
2637 struct ath11k_dp *dp = &ab->dp;
2638 struct dp_rxdma_ring *rx_ring;
2639 int num_buffs_reaped[MAX_RADIOS] = {0};
2640 struct sk_buff_head msdu_list[MAX_RADIOS];
2641 struct ath11k_skb_rxcb *rxcb;
2642 int total_msdu_reaped = 0;
2643 struct hal_srng *srng;
2644 struct sk_buff *msdu;
2648 struct hal_reo_dest_ring *desc;
2649 enum hal_reo_dest_ring_push_reason push_reason;
2653 for (i = 0; i < MAX_RADIOS; i++)
2654 __skb_queue_head_init(&msdu_list[i]);
2656 srng = &ab->hal.srng_list[dp->reo_dst_ring[ring_id].ring_id];
2658 spin_lock_bh(&srng->lock);
2661 ath11k_hal_srng_access_begin(ab, srng);
2663 while (likely(desc =
2664 (struct hal_reo_dest_ring *)ath11k_hal_srng_dst_get_next_entry(ab,
2666 cookie = FIELD_GET(BUFFER_ADDR_INFO1_SW_COOKIE,
2667 desc->buf_addr_info.info1);
2668 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
2670 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID, cookie);
2672 if (unlikely(buf_id == 0))
2675 ar = ab->pdevs[mac_id].ar;
2676 rx_ring = &ar->dp.rx_refill_buf_ring;
2677 spin_lock_bh(&rx_ring->idr_lock);
2678 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
2679 if (unlikely(!msdu)) {
2680 ath11k_warn(ab, "frame rx with invalid buf_id %d\n",
2682 spin_unlock_bh(&rx_ring->idr_lock);
2686 idr_remove(&rx_ring->bufs_idr, buf_id);
2687 spin_unlock_bh(&rx_ring->idr_lock);
2689 rxcb = ATH11K_SKB_RXCB(msdu);
2690 dma_unmap_single(ab->dev, rxcb->paddr,
2691 msdu->len + skb_tailroom(msdu),
2694 num_buffs_reaped[mac_id]++;
2696 push_reason = FIELD_GET(HAL_REO_DEST_RING_INFO0_PUSH_REASON,
2698 if (unlikely(push_reason !=
2699 HAL_REO_DEST_RING_PUSH_REASON_ROUTING_INSTRUCTION)) {
2700 dev_kfree_skb_any(msdu);
2701 ab->soc_stats.hal_reo_error[dp->reo_dst_ring[ring_id].ring_id]++;
2705 rxcb->is_first_msdu = !!(desc->rx_msdu_info.info0 &
2706 RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU);
2707 rxcb->is_last_msdu = !!(desc->rx_msdu_info.info0 &
2708 RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU);
2709 rxcb->is_continuation = !!(desc->rx_msdu_info.info0 &
2710 RX_MSDU_DESC_INFO0_MSDU_CONTINUATION);
2711 rxcb->peer_id = FIELD_GET(RX_MPDU_DESC_META_DATA_PEER_ID,
2712 desc->rx_mpdu_info.meta_data);
2713 rxcb->seq_no = FIELD_GET(RX_MPDU_DESC_INFO0_SEQ_NUM,
2714 desc->rx_mpdu_info.info0);
2715 rxcb->tid = FIELD_GET(HAL_REO_DEST_RING_INFO0_RX_QUEUE_NUM,
2718 rxcb->mac_id = mac_id;
2719 __skb_queue_tail(&msdu_list[mac_id], msdu);
2721 if (rxcb->is_continuation) {
2724 total_msdu_reaped++;
2728 if (total_msdu_reaped >= budget)
2732 /* Hw might have updated the head pointer after we cached it.
2733 * In this case, even though there are entries in the ring we'll
2734 * get rx_desc NULL. Give the read another try with updated cached
2735 * head pointer so that we can reap complete MPDU in the current
2738 if (unlikely(!done && ath11k_hal_srng_dst_num_free(ab, srng, true))) {
2739 ath11k_hal_srng_access_end(ab, srng);
2743 ath11k_hal_srng_access_end(ab, srng);
2745 spin_unlock_bh(&srng->lock);
2747 if (unlikely(!total_msdu_reaped))
2750 for (i = 0; i < ab->num_radios; i++) {
2751 if (!num_buffs_reaped[i])
2754 ath11k_dp_rx_process_received_packets(ab, napi, &msdu_list[i], i);
2756 ar = ab->pdevs[i].ar;
2757 rx_ring = &ar->dp.rx_refill_buf_ring;
2759 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, num_buffs_reaped[i],
2760 ab->hw_params.hal_params->rx_buf_rbm);
2763 return total_msdu_reaped;
2766 static void ath11k_dp_rx_update_peer_stats(struct ath11k_sta *arsta,
2767 struct hal_rx_mon_ppdu_info *ppdu_info)
2769 struct ath11k_rx_peer_stats *rx_stats = arsta->rx_stats;
2776 arsta->rssi_comb = ppdu_info->rssi_comb;
2777 ewma_avg_rssi_add(&arsta->avg_rssi, ppdu_info->rssi_comb);
2779 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count +
2780 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count;
2782 rx_stats->num_msdu += num_msdu;
2783 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count +
2784 ppdu_info->tcp_ack_msdu_count;
2785 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count;
2786 rx_stats->other_msdu_count += ppdu_info->other_msdu_count;
2788 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
2789 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) {
2791 ppdu_info->mcs = HAL_RX_MAX_MCS;
2792 ppdu_info->tid = IEEE80211_NUM_TIDS;
2795 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS)
2796 rx_stats->nss_count[ppdu_info->nss - 1] += num_msdu;
2798 if (ppdu_info->mcs <= HAL_RX_MAX_MCS)
2799 rx_stats->mcs_count[ppdu_info->mcs] += num_msdu;
2801 if (ppdu_info->gi < HAL_RX_GI_MAX)
2802 rx_stats->gi_count[ppdu_info->gi] += num_msdu;
2804 if (ppdu_info->bw < HAL_RX_BW_MAX)
2805 rx_stats->bw_count[ppdu_info->bw] += num_msdu;
2807 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
2808 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
2810 if (ppdu_info->tid <= IEEE80211_NUM_TIDS)
2811 rx_stats->tid_count[ppdu_info->tid] += num_msdu;
2813 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX)
2814 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu;
2816 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
2817 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
2819 if (ppdu_info->is_stbc)
2820 rx_stats->stbc_count += num_msdu;
2822 if (ppdu_info->beamformed)
2823 rx_stats->beamformed_count += num_msdu;
2825 if (ppdu_info->num_mpdu_fcs_ok > 1)
2826 rx_stats->ampdu_msdu_count += num_msdu;
2828 rx_stats->non_ampdu_msdu_count += num_msdu;
2830 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok;
2831 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err;
2832 rx_stats->dcm_count += ppdu_info->dcm;
2833 rx_stats->ru_alloc_cnt[ppdu_info->ru_alloc] += num_msdu;
2835 arsta->rssi_comb = ppdu_info->rssi_comb;
2837 BUILD_BUG_ON(ARRAY_SIZE(arsta->chain_signal) >
2838 ARRAY_SIZE(ppdu_info->rssi_chain_pri20));
2840 for (i = 0; i < ARRAY_SIZE(arsta->chain_signal); i++)
2841 arsta->chain_signal[i] = ppdu_info->rssi_chain_pri20[i];
2843 rx_stats->rx_duration += ppdu_info->rx_duration;
2844 arsta->rx_duration = rx_stats->rx_duration;
2847 static struct sk_buff *ath11k_dp_rx_alloc_mon_status_buf(struct ath11k_base *ab,
2848 struct dp_rxdma_ring *rx_ring,
2851 struct sk_buff *skb;
2854 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE +
2855 DP_RX_BUFFER_ALIGN_SIZE);
2858 goto fail_alloc_skb;
2860 if (!IS_ALIGNED((unsigned long)skb->data,
2861 DP_RX_BUFFER_ALIGN_SIZE)) {
2862 skb_pull(skb, PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
2866 paddr = dma_map_single(ab->dev, skb->data,
2867 skb->len + skb_tailroom(skb),
2869 if (unlikely(dma_mapping_error(ab->dev, paddr)))
2872 spin_lock_bh(&rx_ring->idr_lock);
2873 *buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0,
2874 rx_ring->bufs_max, GFP_ATOMIC);
2875 spin_unlock_bh(&rx_ring->idr_lock);
2877 goto fail_dma_unmap;
2879 ATH11K_SKB_RXCB(skb)->paddr = paddr;
2883 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
2886 dev_kfree_skb_any(skb);
2891 int ath11k_dp_rx_mon_status_bufs_replenish(struct ath11k_base *ab, int mac_id,
2892 struct dp_rxdma_ring *rx_ring,
2894 enum hal_rx_buf_return_buf_manager mgr)
2896 struct hal_srng *srng;
2898 struct sk_buff *skb;
2905 req_entries = min(req_entries, rx_ring->bufs_max);
2907 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
2909 spin_lock_bh(&srng->lock);
2911 ath11k_hal_srng_access_begin(ab, srng);
2913 num_free = ath11k_hal_srng_src_num_free(ab, srng, true);
2915 req_entries = min(num_free, req_entries);
2916 num_remain = req_entries;
2918 while (num_remain > 0) {
2919 skb = ath11k_dp_rx_alloc_mon_status_buf(ab, rx_ring,
2923 paddr = ATH11K_SKB_RXCB(skb)->paddr;
2925 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
2929 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
2930 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
2934 ath11k_hal_rx_buf_addr_info_set(desc, paddr, cookie, mgr);
2937 ath11k_hal_srng_access_end(ab, srng);
2939 spin_unlock_bh(&srng->lock);
2941 return req_entries - num_remain;
2944 spin_lock_bh(&rx_ring->idr_lock);
2945 idr_remove(&rx_ring->bufs_idr, buf_id);
2946 spin_unlock_bh(&rx_ring->idr_lock);
2947 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
2949 dev_kfree_skb_any(skb);
2950 ath11k_hal_srng_access_end(ab, srng);
2951 spin_unlock_bh(&srng->lock);
2953 return req_entries - num_remain;
2956 #define ATH11K_DP_RX_FULL_MON_PPDU_ID_WRAP 32535
2959 ath11k_dp_rx_mon_update_status_buf_state(struct ath11k_mon_data *pmon,
2960 struct hal_tlv_hdr *tlv)
2962 struct hal_rx_ppdu_start *ppdu_start;
2963 u16 ppdu_id_diff, ppdu_id, tlv_len;
2966 /* PPDU id is part of second tlv, move ptr to second tlv */
2967 tlv_len = FIELD_GET(HAL_TLV_HDR_LEN, tlv->tl);
2969 ptr += sizeof(*tlv) + tlv_len;
2970 tlv = (struct hal_tlv_hdr *)ptr;
2972 if (FIELD_GET(HAL_TLV_HDR_TAG, tlv->tl) != HAL_RX_PPDU_START)
2975 ptr += sizeof(*tlv);
2976 ppdu_start = (struct hal_rx_ppdu_start *)ptr;
2977 ppdu_id = FIELD_GET(HAL_RX_PPDU_START_INFO0_PPDU_ID,
2978 __le32_to_cpu(ppdu_start->info0));
2980 if (pmon->sw_mon_entries.ppdu_id < ppdu_id) {
2981 pmon->buf_state = DP_MON_STATUS_LEAD;
2982 ppdu_id_diff = ppdu_id - pmon->sw_mon_entries.ppdu_id;
2983 if (ppdu_id_diff > ATH11K_DP_RX_FULL_MON_PPDU_ID_WRAP)
2984 pmon->buf_state = DP_MON_STATUS_LAG;
2985 } else if (pmon->sw_mon_entries.ppdu_id > ppdu_id) {
2986 pmon->buf_state = DP_MON_STATUS_LAG;
2987 ppdu_id_diff = pmon->sw_mon_entries.ppdu_id - ppdu_id;
2988 if (ppdu_id_diff > ATH11K_DP_RX_FULL_MON_PPDU_ID_WRAP)
2989 pmon->buf_state = DP_MON_STATUS_LEAD;
2993 static int ath11k_dp_rx_reap_mon_status_ring(struct ath11k_base *ab, int mac_id,
2994 int *budget, struct sk_buff_head *skb_list)
2997 const struct ath11k_hw_hal_params *hal_params;
2998 struct ath11k_pdev_dp *dp;
2999 struct dp_rxdma_ring *rx_ring;
3000 struct ath11k_mon_data *pmon;
3001 struct hal_srng *srng;
3002 void *rx_mon_status_desc;
3003 struct sk_buff *skb;
3004 struct ath11k_skb_rxcb *rxcb;
3005 struct hal_tlv_hdr *tlv;
3007 int buf_id, srng_id;
3010 int num_buffs_reaped = 0;
3012 ar = ab->pdevs[ath11k_hw_mac_id_to_pdev_id(&ab->hw_params, mac_id)].ar;
3014 pmon = &dp->mon_data;
3015 srng_id = ath11k_hw_mac_id_to_srng_id(&ab->hw_params, mac_id);
3016 rx_ring = &dp->rx_mon_status_refill_ring[srng_id];
3018 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
3020 spin_lock_bh(&srng->lock);
3022 ath11k_hal_srng_access_begin(ab, srng);
3025 rx_mon_status_desc =
3026 ath11k_hal_srng_src_peek(ab, srng);
3027 if (!rx_mon_status_desc) {
3028 pmon->buf_state = DP_MON_STATUS_REPLINISH;
3032 ath11k_hal_rx_buf_addr_info_get(rx_mon_status_desc, &paddr,
3035 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID, cookie);
3037 spin_lock_bh(&rx_ring->idr_lock);
3038 skb = idr_find(&rx_ring->bufs_idr, buf_id);
3039 spin_unlock_bh(&rx_ring->idr_lock);
3042 ath11k_warn(ab, "rx monitor status with invalid buf_id %d\n",
3044 pmon->buf_state = DP_MON_STATUS_REPLINISH;
3048 rxcb = ATH11K_SKB_RXCB(skb);
3050 dma_sync_single_for_cpu(ab->dev, rxcb->paddr,
3051 skb->len + skb_tailroom(skb),
3054 tlv = (struct hal_tlv_hdr *)skb->data;
3055 if (FIELD_GET(HAL_TLV_HDR_TAG, tlv->tl) !=
3056 HAL_RX_STATUS_BUFFER_DONE) {
3057 ath11k_warn(ab, "mon status DONE not set %lx, buf_id %d\n",
3058 FIELD_GET(HAL_TLV_HDR_TAG,
3060 /* If done status is missing, hold onto status
3061 * ring until status is done for this status
3063 * Keep HP in mon_status_ring unchanged,
3064 * and break from here.
3065 * Check status for same buffer for next time
3067 pmon->buf_state = DP_MON_STATUS_NO_DMA;
3071 spin_lock_bh(&rx_ring->idr_lock);
3072 idr_remove(&rx_ring->bufs_idr, buf_id);
3073 spin_unlock_bh(&rx_ring->idr_lock);
3074 if (ab->hw_params.full_monitor_mode) {
3075 ath11k_dp_rx_mon_update_status_buf_state(pmon, tlv);
3076 if (paddr == pmon->mon_status_paddr)
3077 pmon->buf_state = DP_MON_STATUS_MATCH;
3080 dma_unmap_single(ab->dev, rxcb->paddr,
3081 skb->len + skb_tailroom(skb),
3084 __skb_queue_tail(skb_list, skb);
3086 pmon->buf_state = DP_MON_STATUS_REPLINISH;
3089 skb = ath11k_dp_rx_alloc_mon_status_buf(ab, rx_ring,
3093 hal_params = ab->hw_params.hal_params;
3094 ath11k_hal_rx_buf_addr_info_set(rx_mon_status_desc, 0, 0,
3095 hal_params->rx_buf_rbm);
3099 rxcb = ATH11K_SKB_RXCB(skb);
3101 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
3102 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
3104 ath11k_hal_rx_buf_addr_info_set(rx_mon_status_desc, rxcb->paddr,
3106 ab->hw_params.hal_params->rx_buf_rbm);
3107 ath11k_hal_srng_src_get_next_entry(ab, srng);
3110 ath11k_hal_srng_access_end(ab, srng);
3111 spin_unlock_bh(&srng->lock);
3113 return num_buffs_reaped;
3116 static void ath11k_dp_rx_frag_timer(struct timer_list *timer)
3118 struct dp_rx_tid *rx_tid = from_timer(rx_tid, timer, frag_timer);
3120 spin_lock_bh(&rx_tid->ab->base_lock);
3121 if (rx_tid->last_frag_no &&
3122 rx_tid->rx_frag_bitmap == GENMASK(rx_tid->last_frag_no, 0)) {
3123 spin_unlock_bh(&rx_tid->ab->base_lock);
3126 ath11k_dp_rx_frags_cleanup(rx_tid, true);
3127 spin_unlock_bh(&rx_tid->ab->base_lock);
3130 int ath11k_peer_rx_frag_setup(struct ath11k *ar, const u8 *peer_mac, int vdev_id)
3132 struct ath11k_base *ab = ar->ab;
3133 struct crypto_shash *tfm;
3134 struct ath11k_peer *peer;
3135 struct dp_rx_tid *rx_tid;
3138 tfm = crypto_alloc_shash("michael_mic", 0, 0);
3140 ath11k_warn(ab, "failed to allocate michael_mic shash: %ld\n",
3142 return PTR_ERR(tfm);
3145 spin_lock_bh(&ab->base_lock);
3147 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
3149 ath11k_warn(ab, "failed to find the peer to set up fragment info\n");
3150 spin_unlock_bh(&ab->base_lock);
3151 crypto_free_shash(tfm);
3155 for (i = 0; i <= IEEE80211_NUM_TIDS; i++) {
3156 rx_tid = &peer->rx_tid[i];
3158 timer_setup(&rx_tid->frag_timer, ath11k_dp_rx_frag_timer, 0);
3159 skb_queue_head_init(&rx_tid->rx_frags);
3162 peer->tfm_mmic = tfm;
3163 peer->dp_setup_done = true;
3164 spin_unlock_bh(&ab->base_lock);
3169 static int ath11k_dp_rx_h_michael_mic(struct crypto_shash *tfm, u8 *key,
3170 struct ieee80211_hdr *hdr, u8 *data,
3171 size_t data_len, u8 *mic)
3173 SHASH_DESC_ON_STACK(desc, tfm);
3174 u8 mic_hdr[16] = {0};
3183 ret = crypto_shash_setkey(tfm, key, 8);
3187 ret = crypto_shash_init(desc);
3191 /* TKIP MIC header */
3192 memcpy(mic_hdr, ieee80211_get_DA(hdr), ETH_ALEN);
3193 memcpy(mic_hdr + ETH_ALEN, ieee80211_get_SA(hdr), ETH_ALEN);
3194 if (ieee80211_is_data_qos(hdr->frame_control))
3195 tid = ieee80211_get_tid(hdr);
3198 ret = crypto_shash_update(desc, mic_hdr, 16);
3201 ret = crypto_shash_update(desc, data, data_len);
3204 ret = crypto_shash_final(desc, mic);
3206 shash_desc_zero(desc);
3210 static int ath11k_dp_rx_h_verify_tkip_mic(struct ath11k *ar, struct ath11k_peer *peer,
3211 struct sk_buff *msdu)
3213 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)msdu->data;
3214 struct ieee80211_rx_status *rxs = IEEE80211_SKB_RXCB(msdu);
3215 struct ieee80211_key_conf *key_conf;
3216 struct ieee80211_hdr *hdr;
3217 u8 mic[IEEE80211_CCMP_MIC_LEN];
3218 int head_len, tail_len, ret;
3220 u32 hdr_len, hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3224 if (ath11k_dp_rx_h_mpdu_start_enctype(ar->ab, rx_desc) !=
3225 HAL_ENCRYPT_TYPE_TKIP_MIC)
3228 hdr = (struct ieee80211_hdr *)(msdu->data + hal_rx_desc_sz);
3229 hdr_len = ieee80211_hdrlen(hdr->frame_control);
3230 head_len = hdr_len + hal_rx_desc_sz + IEEE80211_TKIP_IV_LEN;
3231 tail_len = IEEE80211_CCMP_MIC_LEN + IEEE80211_TKIP_ICV_LEN + FCS_LEN;
3233 if (!is_multicast_ether_addr(hdr->addr1))
3234 key_idx = peer->ucast_keyidx;
3236 key_idx = peer->mcast_keyidx;
3238 key_conf = peer->keys[key_idx];
3240 data = msdu->data + head_len;
3241 data_len = msdu->len - head_len - tail_len;
3242 key = &key_conf->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
3244 ret = ath11k_dp_rx_h_michael_mic(peer->tfm_mmic, key, hdr, data, data_len, mic);
3245 if (ret || memcmp(mic, data + data_len, IEEE80211_CCMP_MIC_LEN))
3251 (ATH11K_SKB_RXCB(msdu))->is_first_msdu = true;
3252 (ATH11K_SKB_RXCB(msdu))->is_last_msdu = true;
3254 rxs->flag |= RX_FLAG_MMIC_ERROR | RX_FLAG_MMIC_STRIPPED |
3255 RX_FLAG_IV_STRIPPED | RX_FLAG_DECRYPTED;
3256 skb_pull(msdu, hal_rx_desc_sz);
3258 ath11k_dp_rx_h_ppdu(ar, rx_desc, rxs);
3259 ath11k_dp_rx_h_undecap(ar, msdu, rx_desc,
3260 HAL_ENCRYPT_TYPE_TKIP_MIC, rxs, true);
3261 ieee80211_rx(ar->hw, msdu);
3265 static void ath11k_dp_rx_h_undecap_frag(struct ath11k *ar, struct sk_buff *msdu,
3266 enum hal_encrypt_type enctype, u32 flags)
3268 struct ieee80211_hdr *hdr;
3271 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3276 hdr = (struct ieee80211_hdr *)(msdu->data + hal_rx_desc_sz);
3278 if (flags & RX_FLAG_MIC_STRIPPED)
3279 skb_trim(msdu, msdu->len -
3280 ath11k_dp_rx_crypto_mic_len(ar, enctype));
3282 if (flags & RX_FLAG_ICV_STRIPPED)
3283 skb_trim(msdu, msdu->len -
3284 ath11k_dp_rx_crypto_icv_len(ar, enctype));
3286 if (flags & RX_FLAG_IV_STRIPPED) {
3287 hdr_len = ieee80211_hdrlen(hdr->frame_control);
3288 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
3290 memmove((void *)msdu->data + hal_rx_desc_sz + crypto_len,
3291 (void *)msdu->data + hal_rx_desc_sz, hdr_len);
3292 skb_pull(msdu, crypto_len);
3296 static int ath11k_dp_rx_h_defrag(struct ath11k *ar,
3297 struct ath11k_peer *peer,
3298 struct dp_rx_tid *rx_tid,
3299 struct sk_buff **defrag_skb)
3301 struct hal_rx_desc *rx_desc;
3302 struct sk_buff *skb, *first_frag, *last_frag;
3303 struct ieee80211_hdr *hdr;
3304 struct rx_attention *rx_attention;
3305 enum hal_encrypt_type enctype;
3306 bool is_decrypted = false;
3309 u32 flags, hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3311 first_frag = skb_peek(&rx_tid->rx_frags);
3312 last_frag = skb_peek_tail(&rx_tid->rx_frags);
3314 skb_queue_walk(&rx_tid->rx_frags, skb) {
3316 rx_desc = (struct hal_rx_desc *)skb->data;
3317 hdr = (struct ieee80211_hdr *)(skb->data + hal_rx_desc_sz);
3319 enctype = ath11k_dp_rx_h_mpdu_start_enctype(ar->ab, rx_desc);
3320 if (enctype != HAL_ENCRYPT_TYPE_OPEN) {
3321 rx_attention = ath11k_dp_rx_get_attention(ar->ab, rx_desc);
3322 is_decrypted = ath11k_dp_rx_h_attn_is_decrypted(rx_attention);
3326 if (skb != first_frag)
3327 flags |= RX_FLAG_IV_STRIPPED;
3328 if (skb != last_frag)
3329 flags |= RX_FLAG_ICV_STRIPPED |
3330 RX_FLAG_MIC_STRIPPED;
3333 /* RX fragments are always raw packets */
3334 if (skb != last_frag)
3335 skb_trim(skb, skb->len - FCS_LEN);
3336 ath11k_dp_rx_h_undecap_frag(ar, skb, enctype, flags);
3338 if (skb != first_frag)
3339 skb_pull(skb, hal_rx_desc_sz +
3340 ieee80211_hdrlen(hdr->frame_control));
3341 msdu_len += skb->len;
3344 extra_space = msdu_len - (DP_RX_BUFFER_SIZE + skb_tailroom(first_frag));
3345 if (extra_space > 0 &&
3346 (pskb_expand_head(first_frag, 0, extra_space, GFP_ATOMIC) < 0))
3349 __skb_unlink(first_frag, &rx_tid->rx_frags);
3350 while ((skb = __skb_dequeue(&rx_tid->rx_frags))) {
3351 skb_put_data(first_frag, skb->data, skb->len);
3352 dev_kfree_skb_any(skb);
3355 hdr = (struct ieee80211_hdr *)(first_frag->data + hal_rx_desc_sz);
3356 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
3357 ATH11K_SKB_RXCB(first_frag)->is_frag = 1;
3359 if (ath11k_dp_rx_h_verify_tkip_mic(ar, peer, first_frag))
3362 *defrag_skb = first_frag;
3366 static int ath11k_dp_rx_h_defrag_reo_reinject(struct ath11k *ar, struct dp_rx_tid *rx_tid,
3367 struct sk_buff *defrag_skb)
3369 struct ath11k_base *ab = ar->ab;
3370 struct ath11k_pdev_dp *dp = &ar->dp;
3371 struct dp_rxdma_ring *rx_refill_ring = &dp->rx_refill_buf_ring;
3372 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)defrag_skb->data;
3373 struct hal_reo_entrance_ring *reo_ent_ring;
3374 struct hal_reo_dest_ring *reo_dest_ring;
3375 struct dp_link_desc_bank *link_desc_banks;
3376 struct hal_rx_msdu_link *msdu_link;
3377 struct hal_rx_msdu_details *msdu0;
3378 struct hal_srng *srng;
3380 u32 desc_bank, msdu_info, mpdu_info;
3381 u32 dst_idx, cookie, hal_rx_desc_sz;
3384 hal_rx_desc_sz = ab->hw_params.hal_desc_sz;
3385 link_desc_banks = ab->dp.link_desc_banks;
3386 reo_dest_ring = rx_tid->dst_ring_desc;
3388 ath11k_hal_rx_reo_ent_paddr_get(ab, reo_dest_ring, &paddr, &desc_bank);
3389 msdu_link = (struct hal_rx_msdu_link *)(link_desc_banks[desc_bank].vaddr +
3390 (paddr - link_desc_banks[desc_bank].paddr));
3391 msdu0 = &msdu_link->msdu_link[0];
3392 dst_idx = FIELD_GET(RX_MSDU_DESC_INFO0_REO_DEST_IND, msdu0->rx_msdu_info.info0);
3393 memset(msdu0, 0, sizeof(*msdu0));
3395 msdu_info = FIELD_PREP(RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU, 1) |
3396 FIELD_PREP(RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU, 1) |
3397 FIELD_PREP(RX_MSDU_DESC_INFO0_MSDU_CONTINUATION, 0) |
3398 FIELD_PREP(RX_MSDU_DESC_INFO0_MSDU_LENGTH,
3399 defrag_skb->len - hal_rx_desc_sz) |
3400 FIELD_PREP(RX_MSDU_DESC_INFO0_REO_DEST_IND, dst_idx) |
3401 FIELD_PREP(RX_MSDU_DESC_INFO0_VALID_SA, 1) |
3402 FIELD_PREP(RX_MSDU_DESC_INFO0_VALID_DA, 1);
3403 msdu0->rx_msdu_info.info0 = msdu_info;
3405 /* change msdu len in hal rx desc */
3406 ath11k_dp_rxdesc_set_msdu_len(ab, rx_desc, defrag_skb->len - hal_rx_desc_sz);
3408 paddr = dma_map_single(ab->dev, defrag_skb->data,
3409 defrag_skb->len + skb_tailroom(defrag_skb),
3411 if (dma_mapping_error(ab->dev, paddr))
3414 spin_lock_bh(&rx_refill_ring->idr_lock);
3415 buf_id = idr_alloc(&rx_refill_ring->bufs_idr, defrag_skb, 0,
3416 rx_refill_ring->bufs_max * 3, GFP_ATOMIC);
3417 spin_unlock_bh(&rx_refill_ring->idr_lock);
3423 ATH11K_SKB_RXCB(defrag_skb)->paddr = paddr;
3424 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, dp->mac_id) |
3425 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
3427 ath11k_hal_rx_buf_addr_info_set(msdu0, paddr, cookie,
3428 ab->hw_params.hal_params->rx_buf_rbm);
3430 /* Fill mpdu details into reo entrance ring */
3431 srng = &ab->hal.srng_list[ab->dp.reo_reinject_ring.ring_id];
3433 spin_lock_bh(&srng->lock);
3434 ath11k_hal_srng_access_begin(ab, srng);
3436 reo_ent_ring = (struct hal_reo_entrance_ring *)
3437 ath11k_hal_srng_src_get_next_entry(ab, srng);
3438 if (!reo_ent_ring) {
3439 ath11k_hal_srng_access_end(ab, srng);
3440 spin_unlock_bh(&srng->lock);
3444 memset(reo_ent_ring, 0, sizeof(*reo_ent_ring));
3446 ath11k_hal_rx_reo_ent_paddr_get(ab, reo_dest_ring, &paddr, &desc_bank);
3447 ath11k_hal_rx_buf_addr_info_set(reo_ent_ring, paddr, desc_bank,
3448 HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST);
3450 mpdu_info = FIELD_PREP(RX_MPDU_DESC_INFO0_MSDU_COUNT, 1) |
3451 FIELD_PREP(RX_MPDU_DESC_INFO0_SEQ_NUM, rx_tid->cur_sn) |
3452 FIELD_PREP(RX_MPDU_DESC_INFO0_FRAG_FLAG, 0) |
3453 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_SA, 1) |
3454 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_DA, 1) |
3455 FIELD_PREP(RX_MPDU_DESC_INFO0_RAW_MPDU, 1) |
3456 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_PN, 1);
3458 reo_ent_ring->rx_mpdu_info.info0 = mpdu_info;
3459 reo_ent_ring->rx_mpdu_info.meta_data = reo_dest_ring->rx_mpdu_info.meta_data;
3460 reo_ent_ring->queue_addr_lo = reo_dest_ring->queue_addr_lo;
3461 reo_ent_ring->info0 = FIELD_PREP(HAL_REO_ENTR_RING_INFO0_QUEUE_ADDR_HI,
3462 FIELD_GET(HAL_REO_DEST_RING_INFO0_QUEUE_ADDR_HI,
3463 reo_dest_ring->info0)) |
3464 FIELD_PREP(HAL_REO_ENTR_RING_INFO0_DEST_IND, dst_idx);
3465 ath11k_hal_srng_access_end(ab, srng);
3466 spin_unlock_bh(&srng->lock);
3471 spin_lock_bh(&rx_refill_ring->idr_lock);
3472 idr_remove(&rx_refill_ring->bufs_idr, buf_id);
3473 spin_unlock_bh(&rx_refill_ring->idr_lock);
3475 dma_unmap_single(ab->dev, paddr, defrag_skb->len + skb_tailroom(defrag_skb),
3480 static int ath11k_dp_rx_h_cmp_frags(struct ath11k *ar,
3481 struct sk_buff *a, struct sk_buff *b)
3485 frag1 = ath11k_dp_rx_h_mpdu_start_frag_no(ar->ab, a);
3486 frag2 = ath11k_dp_rx_h_mpdu_start_frag_no(ar->ab, b);
3488 return frag1 - frag2;
3491 static void ath11k_dp_rx_h_sort_frags(struct ath11k *ar,
3492 struct sk_buff_head *frag_list,
3493 struct sk_buff *cur_frag)
3495 struct sk_buff *skb;
3498 skb_queue_walk(frag_list, skb) {
3499 cmp = ath11k_dp_rx_h_cmp_frags(ar, skb, cur_frag);
3502 __skb_queue_before(frag_list, skb, cur_frag);
3505 __skb_queue_tail(frag_list, cur_frag);
3508 static u64 ath11k_dp_rx_h_get_pn(struct ath11k *ar, struct sk_buff *skb)
3510 struct ieee80211_hdr *hdr;
3513 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3515 hdr = (struct ieee80211_hdr *)(skb->data + hal_rx_desc_sz);
3516 ehdr = skb->data + hal_rx_desc_sz + ieee80211_hdrlen(hdr->frame_control);
3519 pn |= (u64)ehdr[1] << 8;
3520 pn |= (u64)ehdr[4] << 16;
3521 pn |= (u64)ehdr[5] << 24;
3522 pn |= (u64)ehdr[6] << 32;
3523 pn |= (u64)ehdr[7] << 40;
3529 ath11k_dp_rx_h_defrag_validate_incr_pn(struct ath11k *ar, struct dp_rx_tid *rx_tid)
3531 enum hal_encrypt_type encrypt_type;
3532 struct sk_buff *first_frag, *skb;
3533 struct hal_rx_desc *desc;
3537 first_frag = skb_peek(&rx_tid->rx_frags);
3538 desc = (struct hal_rx_desc *)first_frag->data;
3540 encrypt_type = ath11k_dp_rx_h_mpdu_start_enctype(ar->ab, desc);
3541 if (encrypt_type != HAL_ENCRYPT_TYPE_CCMP_128 &&
3542 encrypt_type != HAL_ENCRYPT_TYPE_CCMP_256 &&
3543 encrypt_type != HAL_ENCRYPT_TYPE_GCMP_128 &&
3544 encrypt_type != HAL_ENCRYPT_TYPE_AES_GCMP_256)
3547 last_pn = ath11k_dp_rx_h_get_pn(ar, first_frag);
3548 skb_queue_walk(&rx_tid->rx_frags, skb) {
3549 if (skb == first_frag)
3552 cur_pn = ath11k_dp_rx_h_get_pn(ar, skb);
3553 if (cur_pn != last_pn + 1)
3560 static int ath11k_dp_rx_frag_h_mpdu(struct ath11k *ar,
3561 struct sk_buff *msdu,
3564 struct ath11k_base *ab = ar->ab;
3565 struct hal_rx_desc *rx_desc;
3566 struct ath11k_peer *peer;
3567 struct dp_rx_tid *rx_tid;
3568 struct sk_buff *defrag_skb = NULL;
3576 rx_desc = (struct hal_rx_desc *)msdu->data;
3577 peer_id = ath11k_dp_rx_h_mpdu_start_peer_id(ar->ab, rx_desc);
3578 tid = ath11k_dp_rx_h_mpdu_start_tid(ar->ab, rx_desc);
3579 seqno = ath11k_dp_rx_h_mpdu_start_seq_no(ar->ab, rx_desc);
3580 frag_no = ath11k_dp_rx_h_mpdu_start_frag_no(ar->ab, msdu);
3581 more_frags = ath11k_dp_rx_h_mpdu_start_more_frags(ar->ab, msdu);
3582 is_mcbc = ath11k_dp_rx_h_attn_is_mcbc(ar->ab, rx_desc);
3584 /* Multicast/Broadcast fragments are not expected */
3588 if (!ath11k_dp_rx_h_mpdu_start_seq_ctrl_valid(ar->ab, rx_desc) ||
3589 !ath11k_dp_rx_h_mpdu_start_fc_valid(ar->ab, rx_desc) ||
3590 tid > IEEE80211_NUM_TIDS)
3593 /* received unfragmented packet in reo
3594 * exception ring, this shouldn't happen
3595 * as these packets typically come from
3598 if (WARN_ON_ONCE(!frag_no && !more_frags))
3601 spin_lock_bh(&ab->base_lock);
3602 peer = ath11k_peer_find_by_id(ab, peer_id);
3604 ath11k_warn(ab, "failed to find the peer to de-fragment received fragment peer_id %d\n",
3609 if (!peer->dp_setup_done) {
3610 ath11k_warn(ab, "The peer %pM [%d] has uninitialized datapath\n",
3611 peer->addr, peer_id);
3616 rx_tid = &peer->rx_tid[tid];
3618 if ((!skb_queue_empty(&rx_tid->rx_frags) && seqno != rx_tid->cur_sn) ||
3619 skb_queue_empty(&rx_tid->rx_frags)) {
3620 /* Flush stored fragments and start a new sequence */
3621 ath11k_dp_rx_frags_cleanup(rx_tid, true);
3622 rx_tid->cur_sn = seqno;
3625 if (rx_tid->rx_frag_bitmap & BIT(frag_no)) {
3626 /* Fragment already present */
3631 if (!rx_tid->rx_frag_bitmap || (frag_no > __fls(rx_tid->rx_frag_bitmap)))
3632 __skb_queue_tail(&rx_tid->rx_frags, msdu);
3634 ath11k_dp_rx_h_sort_frags(ar, &rx_tid->rx_frags, msdu);
3636 rx_tid->rx_frag_bitmap |= BIT(frag_no);
3638 rx_tid->last_frag_no = frag_no;
3641 rx_tid->dst_ring_desc = kmemdup(ring_desc,
3642 sizeof(*rx_tid->dst_ring_desc),
3644 if (!rx_tid->dst_ring_desc) {
3649 ath11k_dp_rx_link_desc_return(ab, ring_desc,
3650 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3653 if (!rx_tid->last_frag_no ||
3654 rx_tid->rx_frag_bitmap != GENMASK(rx_tid->last_frag_no, 0)) {
3655 mod_timer(&rx_tid->frag_timer, jiffies +
3656 ATH11K_DP_RX_FRAGMENT_TIMEOUT_MS);
3660 spin_unlock_bh(&ab->base_lock);
3661 del_timer_sync(&rx_tid->frag_timer);
3662 spin_lock_bh(&ab->base_lock);
3664 peer = ath11k_peer_find_by_id(ab, peer_id);
3666 goto err_frags_cleanup;
3668 if (!ath11k_dp_rx_h_defrag_validate_incr_pn(ar, rx_tid))
3669 goto err_frags_cleanup;
3671 if (ath11k_dp_rx_h_defrag(ar, peer, rx_tid, &defrag_skb))
3672 goto err_frags_cleanup;
3675 goto err_frags_cleanup;
3677 if (ath11k_dp_rx_h_defrag_reo_reinject(ar, rx_tid, defrag_skb))
3678 goto err_frags_cleanup;
3680 ath11k_dp_rx_frags_cleanup(rx_tid, false);
3684 dev_kfree_skb_any(defrag_skb);
3685 ath11k_dp_rx_frags_cleanup(rx_tid, true);
3687 spin_unlock_bh(&ab->base_lock);
3692 ath11k_dp_process_rx_err_buf(struct ath11k *ar, u32 *ring_desc, int buf_id, bool drop)
3694 struct ath11k_pdev_dp *dp = &ar->dp;
3695 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
3696 struct sk_buff *msdu;
3697 struct ath11k_skb_rxcb *rxcb;
3698 struct hal_rx_desc *rx_desc;
3701 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3703 spin_lock_bh(&rx_ring->idr_lock);
3704 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
3706 ath11k_warn(ar->ab, "rx err buf with invalid buf_id %d\n",
3708 spin_unlock_bh(&rx_ring->idr_lock);
3712 idr_remove(&rx_ring->bufs_idr, buf_id);
3713 spin_unlock_bh(&rx_ring->idr_lock);
3715 rxcb = ATH11K_SKB_RXCB(msdu);
3716 dma_unmap_single(ar->ab->dev, rxcb->paddr,
3717 msdu->len + skb_tailroom(msdu),
3721 dev_kfree_skb_any(msdu);
3726 if (!rcu_dereference(ar->ab->pdevs_active[ar->pdev_idx])) {
3727 dev_kfree_skb_any(msdu);
3731 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
3732 dev_kfree_skb_any(msdu);
3736 rx_desc = (struct hal_rx_desc *)msdu->data;
3737 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(ar->ab, rx_desc);
3738 if ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE) {
3739 hdr_status = ath11k_dp_rx_h_80211_hdr(ar->ab, rx_desc);
3740 ath11k_warn(ar->ab, "invalid msdu leng %u", msdu_len);
3741 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", hdr_status,
3742 sizeof(struct ieee80211_hdr));
3743 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", rx_desc,
3744 sizeof(struct hal_rx_desc));
3745 dev_kfree_skb_any(msdu);
3749 skb_put(msdu, hal_rx_desc_sz + msdu_len);
3751 if (ath11k_dp_rx_frag_h_mpdu(ar, msdu, ring_desc)) {
3752 dev_kfree_skb_any(msdu);
3753 ath11k_dp_rx_link_desc_return(ar->ab, ring_desc,
3754 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3761 int ath11k_dp_process_rx_err(struct ath11k_base *ab, struct napi_struct *napi,
3764 u32 msdu_cookies[HAL_NUM_RX_MSDUS_PER_LINK_DESC];
3765 struct dp_link_desc_bank *link_desc_banks;
3766 enum hal_rx_buf_return_buf_manager rbm;
3767 int tot_n_bufs_reaped, quota, ret, i;
3768 int n_bufs_reaped[MAX_RADIOS] = {0};
3769 struct dp_rxdma_ring *rx_ring;
3770 struct dp_srng *reo_except;
3771 u32 desc_bank, num_msdus;
3772 struct hal_srng *srng;
3773 struct ath11k_dp *dp;
3782 tot_n_bufs_reaped = 0;
3786 reo_except = &dp->reo_except_ring;
3787 link_desc_banks = dp->link_desc_banks;
3789 srng = &ab->hal.srng_list[reo_except->ring_id];
3791 spin_lock_bh(&srng->lock);
3793 ath11k_hal_srng_access_begin(ab, srng);
3796 (desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
3797 struct hal_reo_dest_ring *reo_desc = (struct hal_reo_dest_ring *)desc;
3799 ab->soc_stats.err_ring_pkts++;
3800 ret = ath11k_hal_desc_reo_parse_err(ab, desc, &paddr,
3803 ath11k_warn(ab, "failed to parse error reo desc %d\n",
3807 link_desc_va = link_desc_banks[desc_bank].vaddr +
3808 (paddr - link_desc_banks[desc_bank].paddr);
3809 ath11k_hal_rx_msdu_link_info_get(link_desc_va, &num_msdus, msdu_cookies,
3811 if (rbm != HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST &&
3812 rbm != HAL_RX_BUF_RBM_SW3_BM) {
3813 ab->soc_stats.invalid_rbm++;
3814 ath11k_warn(ab, "invalid return buffer manager %d\n", rbm);
3815 ath11k_dp_rx_link_desc_return(ab, desc,
3816 HAL_WBM_REL_BM_ACT_REL_MSDU);
3820 is_frag = !!(reo_desc->rx_mpdu_info.info0 & RX_MPDU_DESC_INFO0_FRAG_FLAG);
3822 /* Process only rx fragments with one msdu per link desc below, and drop
3823 * msdu's indicated due to error reasons.
3825 if (!is_frag || num_msdus > 1) {
3827 /* Return the link desc back to wbm idle list */
3828 ath11k_dp_rx_link_desc_return(ab, desc,
3829 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3832 for (i = 0; i < num_msdus; i++) {
3833 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
3836 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID,
3839 ar = ab->pdevs[mac_id].ar;
3841 if (!ath11k_dp_process_rx_err_buf(ar, desc, buf_id, drop)) {
3842 n_bufs_reaped[mac_id]++;
3843 tot_n_bufs_reaped++;
3847 if (tot_n_bufs_reaped >= quota) {
3848 tot_n_bufs_reaped = quota;
3852 budget = quota - tot_n_bufs_reaped;
3856 ath11k_hal_srng_access_end(ab, srng);
3858 spin_unlock_bh(&srng->lock);
3860 for (i = 0; i < ab->num_radios; i++) {
3861 if (!n_bufs_reaped[i])
3864 ar = ab->pdevs[i].ar;
3865 rx_ring = &ar->dp.rx_refill_buf_ring;
3867 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, n_bufs_reaped[i],
3868 ab->hw_params.hal_params->rx_buf_rbm);
3871 return tot_n_bufs_reaped;
3874 static void ath11k_dp_rx_null_q_desc_sg_drop(struct ath11k *ar,
3876 struct sk_buff_head *msdu_list)
3878 struct sk_buff *skb, *tmp;
3879 struct ath11k_skb_rxcb *rxcb;
3882 n_buffs = DIV_ROUND_UP(msdu_len,
3883 (DP_RX_BUFFER_SIZE - ar->ab->hw_params.hal_desc_sz));
3885 skb_queue_walk_safe(msdu_list, skb, tmp) {
3886 rxcb = ATH11K_SKB_RXCB(skb);
3887 if (rxcb->err_rel_src == HAL_WBM_REL_SRC_MODULE_REO &&
3888 rxcb->err_code == HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO) {
3891 __skb_unlink(skb, msdu_list);
3892 dev_kfree_skb_any(skb);
3898 static int ath11k_dp_rx_h_null_q_desc(struct ath11k *ar, struct sk_buff *msdu,
3899 struct ieee80211_rx_status *status,
3900 struct sk_buff_head *msdu_list)
3903 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
3904 struct rx_attention *rx_attention;
3906 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3907 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
3909 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(ar->ab, desc);
3911 if (!rxcb->is_frag && ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE)) {
3912 /* First buffer will be freed by the caller, so deduct it's length */
3913 msdu_len = msdu_len - (DP_RX_BUFFER_SIZE - hal_rx_desc_sz);
3914 ath11k_dp_rx_null_q_desc_sg_drop(ar, msdu_len, msdu_list);
3918 rx_attention = ath11k_dp_rx_get_attention(ar->ab, desc);
3919 if (!ath11k_dp_rx_h_attn_msdu_done(rx_attention)) {
3921 "msdu_done bit not set in null_q_des processing\n");
3922 __skb_queue_purge(msdu_list);
3926 /* Handle NULL queue descriptor violations arising out a missing
3927 * REO queue for a given peer or a given TID. This typically
3928 * may happen if a packet is received on a QOS enabled TID before the
3929 * ADDBA negotiation for that TID, when the TID queue is setup. Or
3930 * it may also happen for MC/BC frames if they are not routed to the
3931 * non-QOS TID queue, in the absence of any other default TID queue.
3932 * This error can show up both in a REO destination or WBM release ring.
3935 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(ar->ab, desc);
3936 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(ar->ab, desc);
3938 if (rxcb->is_frag) {
3939 skb_pull(msdu, hal_rx_desc_sz);
3941 l3pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(ar->ab, desc);
3943 if ((hal_rx_desc_sz + l3pad_bytes + msdu_len) > DP_RX_BUFFER_SIZE)
3946 skb_put(msdu, hal_rx_desc_sz + l3pad_bytes + msdu_len);
3947 skb_pull(msdu, hal_rx_desc_sz + l3pad_bytes);
3949 ath11k_dp_rx_h_ppdu(ar, desc, status);
3951 ath11k_dp_rx_h_mpdu(ar, msdu, desc, status);
3953 rxcb->tid = ath11k_dp_rx_h_mpdu_start_tid(ar->ab, desc);
3955 /* Please note that caller will having the access to msdu and completing
3956 * rx with mac80211. Need not worry about cleaning up amsdu_list.
3962 static bool ath11k_dp_rx_h_reo_err(struct ath11k *ar, struct sk_buff *msdu,
3963 struct ieee80211_rx_status *status,
3964 struct sk_buff_head *msdu_list)
3966 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3969 ar->ab->soc_stats.reo_error[rxcb->err_code]++;
3971 switch (rxcb->err_code) {
3972 case HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO:
3973 if (ath11k_dp_rx_h_null_q_desc(ar, msdu, status, msdu_list))
3976 case HAL_REO_DEST_RING_ERROR_CODE_PN_CHECK_FAILED:
3977 /* TODO: Do not drop PN failed packets in the driver;
3978 * instead, it is good to drop such packets in mac80211
3979 * after incrementing the replay counters.
3983 /* TODO: Review other errors and process them to mac80211
3993 static void ath11k_dp_rx_h_tkip_mic_err(struct ath11k *ar, struct sk_buff *msdu,
3994 struct ieee80211_rx_status *status)
3997 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
3999 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
4000 u32 hal_rx_desc_sz = ar->ab->hw_params.hal_desc_sz;
4002 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(ar->ab, desc);
4003 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(ar->ab, desc);
4005 l3pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(ar->ab, desc);
4006 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(ar->ab, desc);
4007 skb_put(msdu, hal_rx_desc_sz + l3pad_bytes + msdu_len);
4008 skb_pull(msdu, hal_rx_desc_sz + l3pad_bytes);
4010 ath11k_dp_rx_h_ppdu(ar, desc, status);
4012 status->flag |= (RX_FLAG_MMIC_STRIPPED | RX_FLAG_MMIC_ERROR |
4015 ath11k_dp_rx_h_undecap(ar, msdu, desc,
4016 HAL_ENCRYPT_TYPE_TKIP_MIC, status, false);
4019 static bool ath11k_dp_rx_h_rxdma_err(struct ath11k *ar, struct sk_buff *msdu,
4020 struct ieee80211_rx_status *status)
4022 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
4025 ar->ab->soc_stats.rxdma_error[rxcb->err_code]++;
4027 switch (rxcb->err_code) {
4028 case HAL_REO_ENTR_RING_RXDMA_ECODE_TKIP_MIC_ERR:
4029 ath11k_dp_rx_h_tkip_mic_err(ar, msdu, status);
4032 /* TODO: Review other rxdma error code to check if anything is
4033 * worth reporting to mac80211
4042 static void ath11k_dp_rx_wbm_err(struct ath11k *ar,
4043 struct napi_struct *napi,
4044 struct sk_buff *msdu,
4045 struct sk_buff_head *msdu_list)
4047 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
4048 struct ieee80211_rx_status rxs = {0};
4051 switch (rxcb->err_rel_src) {
4052 case HAL_WBM_REL_SRC_MODULE_REO:
4053 drop = ath11k_dp_rx_h_reo_err(ar, msdu, &rxs, msdu_list);
4055 case HAL_WBM_REL_SRC_MODULE_RXDMA:
4056 drop = ath11k_dp_rx_h_rxdma_err(ar, msdu, &rxs);
4059 /* msdu will get freed */
4064 dev_kfree_skb_any(msdu);
4068 ath11k_dp_rx_deliver_msdu(ar, napi, msdu, &rxs);
4071 int ath11k_dp_rx_process_wbm_err(struct ath11k_base *ab,
4072 struct napi_struct *napi, int budget)
4075 struct ath11k_dp *dp = &ab->dp;
4076 struct dp_rxdma_ring *rx_ring;
4077 struct hal_rx_wbm_rel_info err_info;
4078 struct hal_srng *srng;
4079 struct sk_buff *msdu;
4080 struct sk_buff_head msdu_list[MAX_RADIOS];
4081 struct ath11k_skb_rxcb *rxcb;
4084 int num_buffs_reaped[MAX_RADIOS] = {0};
4085 int total_num_buffs_reaped = 0;
4088 for (i = 0; i < ab->num_radios; i++)
4089 __skb_queue_head_init(&msdu_list[i]);
4091 srng = &ab->hal.srng_list[dp->rx_rel_ring.ring_id];
4093 spin_lock_bh(&srng->lock);
4095 ath11k_hal_srng_access_begin(ab, srng);
4098 rx_desc = ath11k_hal_srng_dst_get_next_entry(ab, srng);
4102 ret = ath11k_hal_wbm_desc_parse_err(ab, rx_desc, &err_info);
4105 "failed to parse rx error in wbm_rel ring desc %d\n",
4110 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID, err_info.cookie);
4111 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID, err_info.cookie);
4113 ar = ab->pdevs[mac_id].ar;
4114 rx_ring = &ar->dp.rx_refill_buf_ring;
4116 spin_lock_bh(&rx_ring->idr_lock);
4117 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
4119 ath11k_warn(ab, "frame rx with invalid buf_id %d pdev %d\n",
4121 spin_unlock_bh(&rx_ring->idr_lock);
4125 idr_remove(&rx_ring->bufs_idr, buf_id);
4126 spin_unlock_bh(&rx_ring->idr_lock);
4128 rxcb = ATH11K_SKB_RXCB(msdu);
4129 dma_unmap_single(ab->dev, rxcb->paddr,
4130 msdu->len + skb_tailroom(msdu),
4133 num_buffs_reaped[mac_id]++;
4134 total_num_buffs_reaped++;
4137 if (err_info.push_reason !=
4138 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
4139 dev_kfree_skb_any(msdu);
4143 rxcb->err_rel_src = err_info.err_rel_src;
4144 rxcb->err_code = err_info.err_code;
4145 rxcb->rx_desc = (struct hal_rx_desc *)msdu->data;
4146 __skb_queue_tail(&msdu_list[mac_id], msdu);
4149 ath11k_hal_srng_access_end(ab, srng);
4151 spin_unlock_bh(&srng->lock);
4153 if (!total_num_buffs_reaped)
4156 for (i = 0; i < ab->num_radios; i++) {
4157 if (!num_buffs_reaped[i])
4160 ar = ab->pdevs[i].ar;
4161 rx_ring = &ar->dp.rx_refill_buf_ring;
4163 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, num_buffs_reaped[i],
4164 ab->hw_params.hal_params->rx_buf_rbm);
4168 for (i = 0; i < ab->num_radios; i++) {
4169 if (!rcu_dereference(ab->pdevs_active[i])) {
4170 __skb_queue_purge(&msdu_list[i]);
4174 ar = ab->pdevs[i].ar;
4176 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
4177 __skb_queue_purge(&msdu_list[i]);
4181 while ((msdu = __skb_dequeue(&msdu_list[i])) != NULL)
4182 ath11k_dp_rx_wbm_err(ar, napi, msdu, &msdu_list[i]);
4186 return total_num_buffs_reaped;
4189 int ath11k_dp_process_rxdma_err(struct ath11k_base *ab, int mac_id, int budget)
4192 struct dp_srng *err_ring;
4193 struct dp_rxdma_ring *rx_ring;
4194 struct dp_link_desc_bank *link_desc_banks = ab->dp.link_desc_banks;
4195 struct hal_srng *srng;
4196 u32 msdu_cookies[HAL_NUM_RX_MSDUS_PER_LINK_DESC];
4197 enum hal_rx_buf_return_buf_manager rbm;
4198 enum hal_reo_entr_rxdma_ecode rxdma_err_code;
4199 struct ath11k_skb_rxcb *rxcb;
4200 struct sk_buff *skb;
4201 struct hal_reo_entrance_ring *entr_ring;
4203 int num_buf_freed = 0;
4212 ar = ab->pdevs[ath11k_hw_mac_id_to_pdev_id(&ab->hw_params, mac_id)].ar;
4213 err_ring = &ar->dp.rxdma_err_dst_ring[ath11k_hw_mac_id_to_srng_id(&ab->hw_params,
4215 rx_ring = &ar->dp.rx_refill_buf_ring;
4217 srng = &ab->hal.srng_list[err_ring->ring_id];
4219 spin_lock_bh(&srng->lock);
4221 ath11k_hal_srng_access_begin(ab, srng);
4224 (desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
4225 ath11k_hal_rx_reo_ent_paddr_get(ab, desc, &paddr, &desc_bank);
4227 entr_ring = (struct hal_reo_entrance_ring *)desc;
4229 FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_ERROR_CODE,
4231 ab->soc_stats.rxdma_error[rxdma_err_code]++;
4233 link_desc_va = link_desc_banks[desc_bank].vaddr +
4234 (paddr - link_desc_banks[desc_bank].paddr);
4235 ath11k_hal_rx_msdu_link_info_get(link_desc_va, &num_msdus,
4236 msdu_cookies, &rbm);
4238 for (i = 0; i < num_msdus; i++) {
4239 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
4242 spin_lock_bh(&rx_ring->idr_lock);
4243 skb = idr_find(&rx_ring->bufs_idr, buf_id);
4245 ath11k_warn(ab, "rxdma error with invalid buf_id %d\n",
4247 spin_unlock_bh(&rx_ring->idr_lock);
4251 idr_remove(&rx_ring->bufs_idr, buf_id);
4252 spin_unlock_bh(&rx_ring->idr_lock);
4254 rxcb = ATH11K_SKB_RXCB(skb);
4255 dma_unmap_single(ab->dev, rxcb->paddr,
4256 skb->len + skb_tailroom(skb),
4258 dev_kfree_skb_any(skb);
4263 ath11k_dp_rx_link_desc_return(ab, desc,
4264 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
4267 ath11k_hal_srng_access_end(ab, srng);
4269 spin_unlock_bh(&srng->lock);
4272 ath11k_dp_rxbufs_replenish(ab, mac_id, rx_ring, num_buf_freed,
4273 ab->hw_params.hal_params->rx_buf_rbm);
4275 return budget - quota;
4278 void ath11k_dp_process_reo_status(struct ath11k_base *ab)
4280 struct ath11k_dp *dp = &ab->dp;
4281 struct hal_srng *srng;
4282 struct dp_reo_cmd *cmd, *tmp;
4286 struct hal_reo_status reo_status;
4288 srng = &ab->hal.srng_list[dp->reo_status_ring.ring_id];
4290 memset(&reo_status, 0, sizeof(reo_status));
4292 spin_lock_bh(&srng->lock);
4294 ath11k_hal_srng_access_begin(ab, srng);
4296 while ((reo_desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
4297 tag = FIELD_GET(HAL_SRNG_TLV_HDR_TAG, *reo_desc);
4300 case HAL_REO_GET_QUEUE_STATS_STATUS:
4301 ath11k_hal_reo_status_queue_stats(ab, reo_desc,
4304 case HAL_REO_FLUSH_QUEUE_STATUS:
4305 ath11k_hal_reo_flush_queue_status(ab, reo_desc,
4308 case HAL_REO_FLUSH_CACHE_STATUS:
4309 ath11k_hal_reo_flush_cache_status(ab, reo_desc,
4312 case HAL_REO_UNBLOCK_CACHE_STATUS:
4313 ath11k_hal_reo_unblk_cache_status(ab, reo_desc,
4316 case HAL_REO_FLUSH_TIMEOUT_LIST_STATUS:
4317 ath11k_hal_reo_flush_timeout_list_status(ab, reo_desc,
4320 case HAL_REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS:
4321 ath11k_hal_reo_desc_thresh_reached_status(ab, reo_desc,
4324 case HAL_REO_UPDATE_RX_REO_QUEUE_STATUS:
4325 ath11k_hal_reo_update_rx_reo_queue_status(ab, reo_desc,
4329 ath11k_warn(ab, "Unknown reo status type %d\n", tag);
4333 spin_lock_bh(&dp->reo_cmd_lock);
4334 list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) {
4335 if (reo_status.uniform_hdr.cmd_num == cmd->cmd_num) {
4337 list_del(&cmd->list);
4341 spin_unlock_bh(&dp->reo_cmd_lock);
4344 cmd->handler(dp, (void *)&cmd->data,
4345 reo_status.uniform_hdr.cmd_status);
4352 ath11k_hal_srng_access_end(ab, srng);
4354 spin_unlock_bh(&srng->lock);
4357 void ath11k_dp_rx_pdev_free(struct ath11k_base *ab, int mac_id)
4359 struct ath11k *ar = ab->pdevs[mac_id].ar;
4361 ath11k_dp_rx_pdev_srng_free(ar);
4362 ath11k_dp_rxdma_pdev_buf_free(ar);
4365 int ath11k_dp_rx_pdev_alloc(struct ath11k_base *ab, int mac_id)
4367 struct ath11k *ar = ab->pdevs[mac_id].ar;
4368 struct ath11k_pdev_dp *dp = &ar->dp;
4373 ret = ath11k_dp_rx_pdev_srng_alloc(ar);
4375 ath11k_warn(ab, "failed to setup rx srngs\n");
4379 ret = ath11k_dp_rxdma_pdev_buf_setup(ar);
4381 ath11k_warn(ab, "failed to setup rxdma ring\n");
4385 ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id;
4386 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id, mac_id, HAL_RXDMA_BUF);
4388 ath11k_warn(ab, "failed to configure rx_refill_buf_ring %d\n",
4393 if (ab->hw_params.rx_mac_buf_ring) {
4394 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
4395 ring_id = dp->rx_mac_buf_ring[i].ring_id;
4396 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id,
4397 mac_id + i, HAL_RXDMA_BUF);
4399 ath11k_warn(ab, "failed to configure rx_mac_buf_ring%d %d\n",
4406 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
4407 ring_id = dp->rxdma_err_dst_ring[i].ring_id;
4408 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id,
4409 mac_id + i, HAL_RXDMA_DST);
4411 ath11k_warn(ab, "failed to configure rxdma_err_dest_ring%d %d\n",
4417 if (!ab->hw_params.rxdma1_enable)
4418 goto config_refill_ring;
4420 ring_id = dp->rxdma_mon_buf_ring.refill_buf_ring.ring_id;
4421 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id,
4422 mac_id, HAL_RXDMA_MONITOR_BUF);
4424 ath11k_warn(ab, "failed to configure rxdma_mon_buf_ring %d\n",
4428 ret = ath11k_dp_tx_htt_srng_setup(ab,
4429 dp->rxdma_mon_dst_ring.ring_id,
4430 mac_id, HAL_RXDMA_MONITOR_DST);
4432 ath11k_warn(ab, "failed to configure rxdma_mon_dst_ring %d\n",
4436 ret = ath11k_dp_tx_htt_srng_setup(ab,
4437 dp->rxdma_mon_desc_ring.ring_id,
4438 mac_id, HAL_RXDMA_MONITOR_DESC);
4440 ath11k_warn(ab, "failed to configure rxdma_mon_dst_ring %d\n",
4446 for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) {
4447 ring_id = dp->rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
4448 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id, mac_id + i,
4449 HAL_RXDMA_MONITOR_STATUS);
4452 "failed to configure mon_status_refill_ring%d %d\n",
4461 static void ath11k_dp_mon_set_frag_len(u32 *total_len, u32 *frag_len)
4463 if (*total_len >= (DP_RX_BUFFER_SIZE - sizeof(struct hal_rx_desc))) {
4464 *frag_len = DP_RX_BUFFER_SIZE - sizeof(struct hal_rx_desc);
4465 *total_len -= *frag_len;
4467 *frag_len = *total_len;
4473 int ath11k_dp_rx_monitor_link_desc_return(struct ath11k *ar,
4474 void *p_last_buf_addr_info,
4477 struct ath11k_pdev_dp *dp = &ar->dp;
4478 struct dp_srng *dp_srng;
4480 void *src_srng_desc;
4483 if (ar->ab->hw_params.rxdma1_enable) {
4484 dp_srng = &dp->rxdma_mon_desc_ring;
4485 hal_srng = &ar->ab->hal.srng_list[dp_srng->ring_id];
4487 dp_srng = &ar->ab->dp.wbm_desc_rel_ring;
4488 hal_srng = &ar->ab->hal.srng_list[dp_srng->ring_id];
4491 ath11k_hal_srng_access_begin(ar->ab, hal_srng);
4493 src_srng_desc = ath11k_hal_srng_src_get_next_entry(ar->ab, hal_srng);
4495 if (src_srng_desc) {
4496 struct ath11k_buffer_addr *src_desc = src_srng_desc;
4498 *src_desc = *((struct ath11k_buffer_addr *)p_last_buf_addr_info);
4500 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4501 "Monitor Link Desc Ring %d Full", mac_id);
4505 ath11k_hal_srng_access_end(ar->ab, hal_srng);
4510 void ath11k_dp_rx_mon_next_link_desc_get(void *rx_msdu_link_desc,
4511 dma_addr_t *paddr, u32 *sw_cookie,
4513 void **pp_buf_addr_info)
4515 struct hal_rx_msdu_link *msdu_link = rx_msdu_link_desc;
4516 struct ath11k_buffer_addr *buf_addr_info;
4518 buf_addr_info = (struct ath11k_buffer_addr *)&msdu_link->buf_addr_info;
4520 ath11k_hal_rx_buf_addr_info_get(buf_addr_info, paddr, sw_cookie, rbm);
4522 *pp_buf_addr_info = (void *)buf_addr_info;
4525 static int ath11k_dp_pkt_set_pktlen(struct sk_buff *skb, u32 len)
4527 if (skb->len > len) {
4530 if (skb_tailroom(skb) < len - skb->len) {
4531 if ((pskb_expand_head(skb, 0,
4532 len - skb->len - skb_tailroom(skb),
4534 dev_kfree_skb_any(skb);
4538 skb_put(skb, (len - skb->len));
4543 static void ath11k_hal_rx_msdu_list_get(struct ath11k *ar,
4544 void *msdu_link_desc,
4545 struct hal_rx_msdu_list *msdu_list,
4548 struct hal_rx_msdu_details *msdu_details = NULL;
4549 struct rx_msdu_desc *msdu_desc_info = NULL;
4550 struct hal_rx_msdu_link *msdu_link = NULL;
4552 u32 last = FIELD_PREP(RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU, 1);
4553 u32 first = FIELD_PREP(RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU, 1);
4556 msdu_link = msdu_link_desc;
4557 msdu_details = &msdu_link->msdu_link[0];
4559 for (i = 0; i < HAL_RX_NUM_MSDU_DESC; i++) {
4560 if (FIELD_GET(BUFFER_ADDR_INFO0_ADDR,
4561 msdu_details[i].buf_addr_info.info0) == 0) {
4562 msdu_desc_info = &msdu_details[i - 1].rx_msdu_info;
4563 msdu_desc_info->info0 |= last;
4567 msdu_desc_info = &msdu_details[i].rx_msdu_info;
4570 msdu_desc_info->info0 |= first;
4571 else if (i == (HAL_RX_NUM_MSDU_DESC - 1))
4572 msdu_desc_info->info0 |= last;
4573 msdu_list->msdu_info[i].msdu_flags = msdu_desc_info->info0;
4574 msdu_list->msdu_info[i].msdu_len =
4575 HAL_RX_MSDU_PKT_LENGTH_GET(msdu_desc_info->info0);
4576 msdu_list->sw_cookie[i] =
4577 FIELD_GET(BUFFER_ADDR_INFO1_SW_COOKIE,
4578 msdu_details[i].buf_addr_info.info1);
4579 tmp = FIELD_GET(BUFFER_ADDR_INFO1_RET_BUF_MGR,
4580 msdu_details[i].buf_addr_info.info1);
4581 msdu_list->rbm[i] = tmp;
4586 static u32 ath11k_dp_rx_mon_comp_ppduid(u32 msdu_ppdu_id, u32 *ppdu_id,
4591 if ((*ppdu_id < msdu_ppdu_id) &&
4592 ((msdu_ppdu_id - *ppdu_id) < DP_NOT_PPDU_ID_WRAP_AROUND)) {
4593 *ppdu_id = msdu_ppdu_id;
4595 } else if ((*ppdu_id > msdu_ppdu_id) &&
4596 ((*ppdu_id - msdu_ppdu_id) > DP_NOT_PPDU_ID_WRAP_AROUND)) {
4597 /* mon_dst is behind than mon_status
4598 * skip dst_ring and free it
4601 *ppdu_id = msdu_ppdu_id;
4607 static void ath11k_dp_mon_get_buf_len(struct hal_rx_msdu_desc_info *info,
4608 bool *is_frag, u32 *total_len,
4609 u32 *frag_len, u32 *msdu_cnt)
4611 if (info->msdu_flags & RX_MSDU_DESC_INFO0_MSDU_CONTINUATION) {
4613 *total_len = info->msdu_len;
4616 ath11k_dp_mon_set_frag_len(total_len,
4620 ath11k_dp_mon_set_frag_len(total_len,
4623 *frag_len = info->msdu_len;
4631 ath11k_dp_rx_mon_mpdu_pop(struct ath11k *ar, int mac_id,
4632 void *ring_entry, struct sk_buff **head_msdu,
4633 struct sk_buff **tail_msdu, u32 *npackets,
4636 struct ath11k_pdev_dp *dp = &ar->dp;
4637 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4638 struct dp_rxdma_ring *rx_ring = &dp->rxdma_mon_buf_ring;
4639 struct sk_buff *msdu = NULL, *last = NULL;
4640 struct hal_rx_msdu_list msdu_list;
4641 void *p_buf_addr_info, *p_last_buf_addr_info;
4642 struct hal_rx_desc *rx_desc;
4643 void *rx_msdu_link_desc;
4646 u32 rx_buf_size, rx_pkt_offset, sw_cookie;
4647 u32 rx_bufs_used = 0, i = 0;
4648 u32 msdu_ppdu_id = 0, msdu_cnt = 0;
4649 u32 total_len = 0, frag_len = 0;
4650 bool is_frag, is_first_msdu;
4651 bool drop_mpdu = false;
4652 struct ath11k_skb_rxcb *rxcb;
4653 struct hal_reo_entrance_ring *ent_desc = ring_entry;
4655 u32 rx_link_buf_info[2];
4658 if (!ar->ab->hw_params.rxdma1_enable)
4659 rx_ring = &dp->rx_refill_buf_ring;
4661 ath11k_hal_rx_reo_ent_buf_paddr_get(ring_entry, &paddr,
4663 &p_last_buf_addr_info, &rbm,
4666 if (FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_PUSH_REASON,
4668 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
4670 FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_ERROR_CODE,
4672 if (rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_FLUSH_REQUEST_ERR ||
4673 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_MPDU_LEN_ERR ||
4674 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_OVERFLOW_ERR) {
4676 pmon->rx_mon_stats.dest_mpdu_drop++;
4681 is_first_msdu = true;
4684 if (pmon->mon_last_linkdesc_paddr == paddr) {
4685 pmon->rx_mon_stats.dup_mon_linkdesc_cnt++;
4686 return rx_bufs_used;
4689 if (ar->ab->hw_params.rxdma1_enable)
4691 (void *)pmon->link_desc_banks[sw_cookie].vaddr +
4692 (paddr - pmon->link_desc_banks[sw_cookie].paddr);
4695 (void *)ar->ab->dp.link_desc_banks[sw_cookie].vaddr +
4696 (paddr - ar->ab->dp.link_desc_banks[sw_cookie].paddr);
4698 ath11k_hal_rx_msdu_list_get(ar, rx_msdu_link_desc, &msdu_list,
4701 for (i = 0; i < num_msdus; i++) {
4704 if (pmon->mon_last_buf_cookie == msdu_list.sw_cookie[i]) {
4705 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4706 "i %d last_cookie %d is same\n",
4707 i, pmon->mon_last_buf_cookie);
4709 pmon->rx_mon_stats.dup_mon_buf_cnt++;
4712 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
4713 msdu_list.sw_cookie[i]);
4715 spin_lock_bh(&rx_ring->idr_lock);
4716 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
4717 spin_unlock_bh(&rx_ring->idr_lock);
4719 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4720 "msdu_pop: invalid buf_id %d\n", buf_id);
4723 rxcb = ATH11K_SKB_RXCB(msdu);
4724 if (!rxcb->unmapped) {
4725 dma_unmap_single(ar->ab->dev, rxcb->paddr,
4732 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4733 "i %d drop msdu %p *ppdu_id %x\n",
4735 dev_kfree_skb_any(msdu);
4740 rx_desc = (struct hal_rx_desc *)msdu->data;
4742 rx_pkt_offset = sizeof(struct hal_rx_desc);
4743 l2_hdr_offset = ath11k_dp_rx_h_msdu_end_l3pad(ar->ab, rx_desc);
4745 if (is_first_msdu) {
4746 if (!ath11k_dp_rxdesc_mpdu_valid(ar->ab, rx_desc)) {
4748 dev_kfree_skb_any(msdu);
4750 pmon->mon_last_linkdesc_paddr = paddr;
4755 ath11k_dp_rxdesc_get_ppduid(ar->ab, rx_desc);
4757 if (ath11k_dp_rx_mon_comp_ppduid(msdu_ppdu_id,
4762 dev_kfree_skb_any(msdu);
4766 return rx_bufs_used;
4768 pmon->mon_last_linkdesc_paddr = paddr;
4769 is_first_msdu = false;
4771 ath11k_dp_mon_get_buf_len(&msdu_list.msdu_info[i],
4772 &is_frag, &total_len,
4773 &frag_len, &msdu_cnt);
4774 rx_buf_size = rx_pkt_offset + l2_hdr_offset + frag_len;
4776 ath11k_dp_pkt_set_pktlen(msdu, rx_buf_size);
4785 pmon->mon_last_buf_cookie = msdu_list.sw_cookie[i];
4787 spin_lock_bh(&rx_ring->idr_lock);
4788 idr_remove(&rx_ring->bufs_idr, buf_id);
4789 spin_unlock_bh(&rx_ring->idr_lock);
4792 ath11k_hal_rx_buf_addr_info_set(rx_link_buf_info, paddr, sw_cookie, rbm);
4794 ath11k_dp_rx_mon_next_link_desc_get(rx_msdu_link_desc, &paddr,
4798 if (ar->ab->hw_params.rxdma1_enable) {
4799 if (ath11k_dp_rx_monitor_link_desc_return(ar,
4800 p_last_buf_addr_info,
4802 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4803 "dp_rx_monitor_link_desc_return failed");
4805 ath11k_dp_rx_link_desc_return(ar->ab, rx_link_buf_info,
4806 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
4809 p_last_buf_addr_info = p_buf_addr_info;
4811 } while (paddr && msdu_cnt);
4821 return rx_bufs_used;
4824 static void ath11k_dp_rx_msdus_set_payload(struct ath11k *ar, struct sk_buff *msdu)
4826 u32 rx_pkt_offset, l2_hdr_offset;
4828 rx_pkt_offset = ar->ab->hw_params.hal_desc_sz;
4829 l2_hdr_offset = ath11k_dp_rx_h_msdu_end_l3pad(ar->ab,
4830 (struct hal_rx_desc *)msdu->data);
4831 skb_pull(msdu, rx_pkt_offset + l2_hdr_offset);
4834 static struct sk_buff *
4835 ath11k_dp_rx_mon_merg_msdus(struct ath11k *ar,
4836 u32 mac_id, struct sk_buff *head_msdu,
4837 struct sk_buff *last_msdu,
4838 struct ieee80211_rx_status *rxs, bool *fcs_err)
4840 struct ath11k_base *ab = ar->ab;
4841 struct sk_buff *msdu, *prev_buf;
4842 struct hal_rx_desc *rx_desc;
4844 u8 *dest, decap_format;
4845 struct ieee80211_hdr_3addr *wh;
4846 struct rx_attention *rx_attention;
4850 goto err_merge_fail;
4852 rx_desc = (struct hal_rx_desc *)head_msdu->data;
4853 rx_attention = ath11k_dp_rx_get_attention(ab, rx_desc);
4854 err_bitmap = ath11k_dp_rx_h_attn_mpdu_err(rx_attention);
4856 if (err_bitmap & DP_RX_MPDU_ERR_FCS)
4859 if (ath11k_dp_rxdesc_get_mpdulen_err(rx_attention))
4862 decap_format = ath11k_dp_rx_h_msdu_start_decap_type(ab, rx_desc);
4864 ath11k_dp_rx_h_ppdu(ar, rx_desc, rxs);
4866 if (decap_format == DP_RX_DECAP_TYPE_RAW) {
4867 ath11k_dp_rx_msdus_set_payload(ar, head_msdu);
4869 prev_buf = head_msdu;
4870 msdu = head_msdu->next;
4873 ath11k_dp_rx_msdus_set_payload(ar, msdu);
4879 prev_buf->next = NULL;
4881 skb_trim(prev_buf, prev_buf->len - HAL_RX_FCS_LEN);
4882 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) {
4885 rx_desc = (struct hal_rx_desc *)head_msdu->data;
4886 hdr_desc = ath11k_dp_rxdesc_get_80211hdr(ab, rx_desc);
4889 wh = (struct ieee80211_hdr_3addr *)hdr_desc;
4891 if (ieee80211_is_data_qos(wh->frame_control))
4897 ath11k_dp_rx_msdus_set_payload(ar, msdu);
4899 dest = skb_push(msdu, sizeof(__le16));
4901 goto err_merge_fail;
4902 memcpy(dest, hdr_desc, sizeof(struct ieee80211_qos_hdr));
4907 dest = skb_put(prev_buf, HAL_RX_FCS_LEN);
4909 goto err_merge_fail;
4911 ath11k_dbg(ab, ATH11K_DBG_DATA,
4912 "mpdu_buf %p mpdu_buf->len %u",
4913 prev_buf, prev_buf->len);
4915 ath11k_dbg(ab, ATH11K_DBG_DATA,
4916 "decap format %d is not supported!\n",
4918 goto err_merge_fail;
4928 ath11k_dp_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info *rx_status,
4933 put_unaligned_le16(rx_status->he_data1, &rtap_buf[rtap_len]);
4936 put_unaligned_le16(rx_status->he_data2, &rtap_buf[rtap_len]);
4939 put_unaligned_le16(rx_status->he_data3, &rtap_buf[rtap_len]);
4942 put_unaligned_le16(rx_status->he_data4, &rtap_buf[rtap_len]);
4945 put_unaligned_le16(rx_status->he_data5, &rtap_buf[rtap_len]);
4948 put_unaligned_le16(rx_status->he_data6, &rtap_buf[rtap_len]);
4952 ath11k_dp_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info *rx_status,
4957 put_unaligned_le16(rx_status->he_flags1, &rtap_buf[rtap_len]);
4960 put_unaligned_le16(rx_status->he_flags2, &rtap_buf[rtap_len]);
4963 rtap_buf[rtap_len] = rx_status->he_RU[0];
4966 rtap_buf[rtap_len] = rx_status->he_RU[1];
4969 rtap_buf[rtap_len] = rx_status->he_RU[2];
4972 rtap_buf[rtap_len] = rx_status->he_RU[3];
4975 static void ath11k_update_radiotap(struct ath11k *ar,
4976 struct hal_rx_mon_ppdu_info *ppduinfo,
4977 struct sk_buff *mon_skb,
4978 struct ieee80211_rx_status *rxs)
4980 struct ieee80211_supported_band *sband;
4983 rxs->flag |= RX_FLAG_MACTIME_START;
4984 rxs->signal = ppduinfo->rssi_comb + ATH11K_DEFAULT_NOISE_FLOOR;
4987 rxs->nss = ppduinfo->nss;
4989 if (ppduinfo->he_mu_flags) {
4990 rxs->flag |= RX_FLAG_RADIOTAP_HE_MU;
4991 rxs->encoding = RX_ENC_HE;
4992 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he_mu));
4993 ath11k_dp_rx_update_radiotap_he_mu(ppduinfo, ptr);
4994 } else if (ppduinfo->he_flags) {
4995 rxs->flag |= RX_FLAG_RADIOTAP_HE;
4996 rxs->encoding = RX_ENC_HE;
4997 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he));
4998 ath11k_dp_rx_update_radiotap_he(ppduinfo, ptr);
4999 rxs->rate_idx = ppduinfo->rate;
5000 } else if (ppduinfo->vht_flags) {
5001 rxs->encoding = RX_ENC_VHT;
5002 rxs->rate_idx = ppduinfo->rate;
5003 } else if (ppduinfo->ht_flags) {
5004 rxs->encoding = RX_ENC_HT;
5005 rxs->rate_idx = ppduinfo->rate;
5007 rxs->encoding = RX_ENC_LEGACY;
5008 sband = &ar->mac.sbands[rxs->band];
5009 rxs->rate_idx = ath11k_mac_hw_rate_to_idx(sband, ppduinfo->rate,
5010 ppduinfo->cck_flag);
5013 rxs->mactime = ppduinfo->tsft;
5016 static int ath11k_dp_rx_mon_deliver(struct ath11k *ar, u32 mac_id,
5017 struct sk_buff *head_msdu,
5018 struct hal_rx_mon_ppdu_info *ppduinfo,
5019 struct sk_buff *tail_msdu,
5020 struct napi_struct *napi)
5022 struct ath11k_pdev_dp *dp = &ar->dp;
5023 struct sk_buff *mon_skb, *skb_next, *header;
5024 struct ieee80211_rx_status *rxs = &dp->rx_status;
5025 bool fcs_err = false;
5027 mon_skb = ath11k_dp_rx_mon_merg_msdus(ar, mac_id, head_msdu,
5028 tail_msdu, rxs, &fcs_err);
5031 goto mon_deliver_fail;
5038 rxs->flag = RX_FLAG_FAILED_FCS_CRC;
5041 skb_next = mon_skb->next;
5043 rxs->flag &= ~RX_FLAG_AMSDU_MORE;
5045 rxs->flag |= RX_FLAG_AMSDU_MORE;
5047 if (mon_skb == header) {
5049 rxs->flag &= ~RX_FLAG_ALLOW_SAME_PN;
5051 rxs->flag |= RX_FLAG_ALLOW_SAME_PN;
5053 rxs->flag |= RX_FLAG_ONLY_MONITOR;
5054 ath11k_update_radiotap(ar, ppduinfo, mon_skb, rxs);
5056 ath11k_dp_rx_deliver_msdu(ar, napi, mon_skb, rxs);
5064 mon_skb = head_msdu;
5066 skb_next = mon_skb->next;
5067 dev_kfree_skb_any(mon_skb);
5073 /* The destination ring processing is stuck if the destination is not
5074 * moving while status ring moves 16 PPDU. The destination ring processing
5075 * skips this destination ring PPDU as a workaround.
5077 #define MON_DEST_RING_STUCK_MAX_CNT 16
5079 static void ath11k_dp_rx_mon_dest_process(struct ath11k *ar, int mac_id,
5080 u32 quota, struct napi_struct *napi)
5082 struct ath11k_pdev_dp *dp = &ar->dp;
5083 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
5084 const struct ath11k_hw_hal_params *hal_params;
5090 struct ath11k_pdev_mon_stats *rx_mon_stats;
5092 u32 mpdu_rx_bufs_used;
5094 if (ar->ab->hw_params.rxdma1_enable)
5095 ring_id = dp->rxdma_mon_dst_ring.ring_id;
5097 ring_id = dp->rxdma_err_dst_ring[mac_id].ring_id;
5099 mon_dst_srng = &ar->ab->hal.srng_list[ring_id];
5101 spin_lock_bh(&pmon->mon_lock);
5103 ath11k_hal_srng_access_begin(ar->ab, mon_dst_srng);
5105 ppdu_id = pmon->mon_ppdu_info.ppdu_id;
5107 rx_mon_stats = &pmon->rx_mon_stats;
5109 while ((ring_entry = ath11k_hal_srng_dst_peek(ar->ab, mon_dst_srng))) {
5110 struct sk_buff *head_msdu, *tail_msdu;
5115 mpdu_rx_bufs_used = ath11k_dp_rx_mon_mpdu_pop(ar, mac_id, ring_entry,
5118 &npackets, &ppdu_id);
5120 rx_bufs_used += mpdu_rx_bufs_used;
5122 if (mpdu_rx_bufs_used) {
5123 dp->mon_dest_ring_stuck_cnt = 0;
5125 dp->mon_dest_ring_stuck_cnt++;
5126 rx_mon_stats->dest_mon_not_reaped++;
5129 if (dp->mon_dest_ring_stuck_cnt > MON_DEST_RING_STUCK_MAX_CNT) {
5130 rx_mon_stats->dest_mon_stuck++;
5131 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
5132 "status ring ppdu_id=%d dest ring ppdu_id=%d mon_dest_ring_stuck_cnt=%d dest_mon_not_reaped=%u dest_mon_stuck=%u\n",
5133 pmon->mon_ppdu_info.ppdu_id, ppdu_id,
5134 dp->mon_dest_ring_stuck_cnt,
5135 rx_mon_stats->dest_mon_not_reaped,
5136 rx_mon_stats->dest_mon_stuck);
5137 pmon->mon_ppdu_info.ppdu_id = ppdu_id;
5141 if (ppdu_id != pmon->mon_ppdu_info.ppdu_id) {
5142 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
5143 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
5144 "dest_rx: new ppdu_id %x != status ppdu_id %x dest_mon_not_reaped = %u dest_mon_stuck = %u\n",
5145 ppdu_id, pmon->mon_ppdu_info.ppdu_id,
5146 rx_mon_stats->dest_mon_not_reaped,
5147 rx_mon_stats->dest_mon_stuck);
5150 if (head_msdu && tail_msdu) {
5151 ath11k_dp_rx_mon_deliver(ar, dp->mac_id, head_msdu,
5152 &pmon->mon_ppdu_info,
5154 rx_mon_stats->dest_mpdu_done++;
5157 ring_entry = ath11k_hal_srng_dst_get_next_entry(ar->ab,
5160 ath11k_hal_srng_access_end(ar->ab, mon_dst_srng);
5162 spin_unlock_bh(&pmon->mon_lock);
5165 rx_mon_stats->dest_ppdu_done++;
5166 hal_params = ar->ab->hw_params.hal_params;
5168 if (ar->ab->hw_params.rxdma1_enable)
5169 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id,
5170 &dp->rxdma_mon_buf_ring,
5172 hal_params->rx_buf_rbm);
5174 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id,
5175 &dp->rx_refill_buf_ring,
5177 hal_params->rx_buf_rbm);
5181 int ath11k_dp_rx_process_mon_status(struct ath11k_base *ab, int mac_id,
5182 struct napi_struct *napi, int budget)
5184 struct ath11k *ar = ath11k_ab_to_ar(ab, mac_id);
5185 enum hal_rx_mon_status hal_status;
5186 struct sk_buff *skb;
5187 struct sk_buff_head skb_list;
5188 struct ath11k_peer *peer;
5189 struct ath11k_sta *arsta;
5190 int num_buffs_reaped = 0;
5193 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&ar->dp.mon_data;
5194 struct ath11k_pdev_mon_stats *rx_mon_stats = &pmon->rx_mon_stats;
5195 struct hal_rx_mon_ppdu_info *ppdu_info = &pmon->mon_ppdu_info;
5197 __skb_queue_head_init(&skb_list);
5199 num_buffs_reaped = ath11k_dp_rx_reap_mon_status_ring(ab, mac_id, &budget,
5201 if (!num_buffs_reaped)
5204 memset(ppdu_info, 0, sizeof(*ppdu_info));
5205 ppdu_info->peer_id = HAL_INVALID_PEERID;
5207 while ((skb = __skb_dequeue(&skb_list))) {
5208 if (ath11k_debugfs_is_pktlog_lite_mode_enabled(ar)) {
5209 log_type = ATH11K_PKTLOG_TYPE_LITE_RX;
5210 rx_buf_sz = DP_RX_BUFFER_SIZE_LITE;
5211 } else if (ath11k_debugfs_is_pktlog_rx_stats_enabled(ar)) {
5212 log_type = ATH11K_PKTLOG_TYPE_RX_STATBUF;
5213 rx_buf_sz = DP_RX_BUFFER_SIZE;
5215 log_type = ATH11K_PKTLOG_TYPE_INVALID;
5219 if (log_type != ATH11K_PKTLOG_TYPE_INVALID)
5220 trace_ath11k_htt_rxdesc(ar, skb->data, log_type, rx_buf_sz);
5222 memset(ppdu_info, 0, sizeof(*ppdu_info));
5223 ppdu_info->peer_id = HAL_INVALID_PEERID;
5224 hal_status = ath11k_hal_rx_parse_mon_status(ab, ppdu_info, skb);
5226 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags) &&
5227 pmon->mon_ppdu_status == DP_PPDU_STATUS_START &&
5228 hal_status == HAL_TLV_STATUS_PPDU_DONE) {
5229 rx_mon_stats->status_ppdu_done++;
5230 pmon->mon_ppdu_status = DP_PPDU_STATUS_DONE;
5231 ath11k_dp_rx_mon_dest_process(ar, mac_id, budget, napi);
5232 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
5235 if (ppdu_info->peer_id == HAL_INVALID_PEERID ||
5236 hal_status != HAL_RX_MON_STATUS_PPDU_DONE) {
5237 dev_kfree_skb_any(skb);
5242 spin_lock_bh(&ab->base_lock);
5243 peer = ath11k_peer_find_by_id(ab, ppdu_info->peer_id);
5245 if (!peer || !peer->sta) {
5246 ath11k_dbg(ab, ATH11K_DBG_DATA,
5247 "failed to find the peer with peer_id %d\n",
5248 ppdu_info->peer_id);
5252 arsta = ath11k_sta_to_arsta(peer->sta);
5253 ath11k_dp_rx_update_peer_stats(arsta, ppdu_info);
5255 if (ath11k_debugfs_is_pktlog_peer_valid(ar, peer->addr))
5256 trace_ath11k_htt_rxdesc(ar, skb->data, log_type, rx_buf_sz);
5259 spin_unlock_bh(&ab->base_lock);
5262 dev_kfree_skb_any(skb);
5263 memset(ppdu_info, 0, sizeof(*ppdu_info));
5264 ppdu_info->peer_id = HAL_INVALID_PEERID;
5267 return num_buffs_reaped;
5271 ath11k_dp_rx_full_mon_mpdu_pop(struct ath11k *ar,
5272 void *ring_entry, struct sk_buff **head_msdu,
5273 struct sk_buff **tail_msdu,
5274 struct hal_sw_mon_ring_entries *sw_mon_entries)
5276 struct ath11k_pdev_dp *dp = &ar->dp;
5277 struct ath11k_mon_data *pmon = &dp->mon_data;
5278 struct dp_rxdma_ring *rx_ring = &dp->rxdma_mon_buf_ring;
5279 struct sk_buff *msdu = NULL, *last = NULL;
5280 struct hal_sw_monitor_ring *sw_desc = ring_entry;
5281 struct hal_rx_msdu_list msdu_list;
5282 struct hal_rx_desc *rx_desc;
5283 struct ath11k_skb_rxcb *rxcb;
5284 void *rx_msdu_link_desc;
5285 void *p_buf_addr_info, *p_last_buf_addr_info;
5287 u32 rx_buf_size, rx_pkt_offset, l2_hdr_offset;
5288 u32 rx_bufs_used = 0, msdu_cnt = 0;
5289 u32 total_len = 0, frag_len = 0, sw_cookie;
5292 bool is_frag, is_first_msdu;
5293 bool drop_mpdu = false;
5295 ath11k_hal_rx_sw_mon_ring_buf_paddr_get(ring_entry, sw_mon_entries);
5297 sw_cookie = sw_mon_entries->mon_dst_sw_cookie;
5298 sw_mon_entries->end_of_ppdu = false;
5299 sw_mon_entries->drop_ppdu = false;
5300 p_last_buf_addr_info = sw_mon_entries->dst_buf_addr_info;
5301 msdu_cnt = sw_mon_entries->msdu_cnt;
5303 sw_mon_entries->end_of_ppdu =
5304 FIELD_GET(HAL_SW_MON_RING_INFO0_END_OF_PPDU, sw_desc->info0);
5305 if (sw_mon_entries->end_of_ppdu)
5306 return rx_bufs_used;
5308 if (FIELD_GET(HAL_SW_MON_RING_INFO0_RXDMA_PUSH_REASON,
5310 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
5312 FIELD_GET(HAL_SW_MON_RING_INFO0_RXDMA_ERROR_CODE,
5314 if (rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_FLUSH_REQUEST_ERR ||
5315 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_MPDU_LEN_ERR ||
5316 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_OVERFLOW_ERR) {
5317 pmon->rx_mon_stats.dest_mpdu_drop++;
5323 is_first_msdu = true;
5327 (u8 *)pmon->link_desc_banks[sw_cookie].vaddr +
5328 (sw_mon_entries->mon_dst_paddr -
5329 pmon->link_desc_banks[sw_cookie].paddr);
5331 ath11k_hal_rx_msdu_list_get(ar, rx_msdu_link_desc, &msdu_list,
5334 for (i = 0; i < num_msdus; i++) {
5335 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
5336 msdu_list.sw_cookie[i]);
5338 spin_lock_bh(&rx_ring->idr_lock);
5339 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
5341 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
5342 "full mon msdu_pop: invalid buf_id %d\n",
5344 spin_unlock_bh(&rx_ring->idr_lock);
5347 idr_remove(&rx_ring->bufs_idr, buf_id);
5348 spin_unlock_bh(&rx_ring->idr_lock);
5350 rxcb = ATH11K_SKB_RXCB(msdu);
5351 if (!rxcb->unmapped) {
5352 dma_unmap_single(ar->ab->dev, rxcb->paddr,
5359 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
5360 "full mon: i %d drop msdu %p *ppdu_id %x\n",
5361 i, msdu, sw_mon_entries->ppdu_id);
5362 dev_kfree_skb_any(msdu);
5367 rx_desc = (struct hal_rx_desc *)msdu->data;
5369 rx_pkt_offset = sizeof(struct hal_rx_desc);
5370 l2_hdr_offset = ath11k_dp_rx_h_msdu_end_l3pad(ar->ab, rx_desc);
5372 if (is_first_msdu) {
5373 if (!ath11k_dp_rxdesc_mpdu_valid(ar->ab, rx_desc)) {
5375 dev_kfree_skb_any(msdu);
5379 is_first_msdu = false;
5382 ath11k_dp_mon_get_buf_len(&msdu_list.msdu_info[i],
5383 &is_frag, &total_len,
5384 &frag_len, &msdu_cnt);
5386 rx_buf_size = rx_pkt_offset + l2_hdr_offset + frag_len;
5388 ath11k_dp_pkt_set_pktlen(msdu, rx_buf_size);
5400 ath11k_dp_rx_mon_next_link_desc_get(rx_msdu_link_desc,
5401 &sw_mon_entries->mon_dst_paddr,
5402 &sw_mon_entries->mon_dst_sw_cookie,
5406 if (ath11k_dp_rx_monitor_link_desc_return(ar,
5407 p_last_buf_addr_info,
5409 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
5410 "full mon: dp_rx_monitor_link_desc_return failed\n");
5412 p_last_buf_addr_info = p_buf_addr_info;
5414 } while (sw_mon_entries->mon_dst_paddr && msdu_cnt);
5421 return rx_bufs_used;
5424 static int ath11k_dp_rx_full_mon_prepare_mpdu(struct ath11k_dp *dp,
5425 struct dp_full_mon_mpdu *mon_mpdu,
5426 struct sk_buff *head,
5427 struct sk_buff *tail)
5429 mon_mpdu = kzalloc(sizeof(*mon_mpdu), GFP_ATOMIC);
5433 list_add_tail(&mon_mpdu->list, &dp->dp_full_mon_mpdu_list);
5434 mon_mpdu->head = head;
5435 mon_mpdu->tail = tail;
5440 static void ath11k_dp_rx_full_mon_drop_ppdu(struct ath11k_dp *dp,
5441 struct dp_full_mon_mpdu *mon_mpdu)
5443 struct dp_full_mon_mpdu *tmp;
5444 struct sk_buff *tmp_msdu, *skb_next;
5446 if (list_empty(&dp->dp_full_mon_mpdu_list))
5449 list_for_each_entry_safe(mon_mpdu, tmp, &dp->dp_full_mon_mpdu_list, list) {
5450 list_del(&mon_mpdu->list);
5452 tmp_msdu = mon_mpdu->head;
5454 skb_next = tmp_msdu->next;
5455 dev_kfree_skb_any(tmp_msdu);
5456 tmp_msdu = skb_next;
5463 static int ath11k_dp_rx_full_mon_deliver_ppdu(struct ath11k *ar,
5465 struct ath11k_mon_data *pmon,
5466 struct napi_struct *napi)
5468 struct ath11k_pdev_mon_stats *rx_mon_stats;
5469 struct dp_full_mon_mpdu *tmp;
5470 struct dp_full_mon_mpdu *mon_mpdu = pmon->mon_mpdu;
5471 struct sk_buff *head_msdu, *tail_msdu;
5472 struct ath11k_base *ab = ar->ab;
5473 struct ath11k_dp *dp = &ab->dp;
5476 rx_mon_stats = &pmon->rx_mon_stats;
5478 list_for_each_entry_safe(mon_mpdu, tmp, &dp->dp_full_mon_mpdu_list, list) {
5479 list_del(&mon_mpdu->list);
5480 head_msdu = mon_mpdu->head;
5481 tail_msdu = mon_mpdu->tail;
5482 if (head_msdu && tail_msdu) {
5483 ret = ath11k_dp_rx_mon_deliver(ar, mac_id, head_msdu,
5484 &pmon->mon_ppdu_info,
5486 rx_mon_stats->dest_mpdu_done++;
5487 ath11k_dbg(ar->ab, ATH11K_DBG_DATA, "full mon: deliver ppdu\n");
5496 ath11k_dp_rx_process_full_mon_status_ring(struct ath11k_base *ab, int mac_id,
5497 struct napi_struct *napi, int budget)
5499 struct ath11k *ar = ab->pdevs[mac_id].ar;
5500 struct ath11k_pdev_dp *dp = &ar->dp;
5501 struct ath11k_mon_data *pmon = &dp->mon_data;
5502 struct hal_sw_mon_ring_entries *sw_mon_entries;
5503 int quota = 0, work = 0, count;
5505 sw_mon_entries = &pmon->sw_mon_entries;
5507 while (pmon->hold_mon_dst_ring) {
5508 quota = ath11k_dp_rx_process_mon_status(ab, mac_id,
5510 if (pmon->buf_state == DP_MON_STATUS_MATCH) {
5511 count = sw_mon_entries->status_buf_count;
5513 quota += ath11k_dp_rx_process_mon_status(ab, mac_id,
5517 ath11k_dp_rx_full_mon_deliver_ppdu(ar, dp->mac_id,
5519 pmon->hold_mon_dst_ring = false;
5520 } else if (!pmon->mon_status_paddr ||
5521 pmon->buf_state == DP_MON_STATUS_LEAD) {
5522 sw_mon_entries->drop_ppdu = true;
5523 pmon->hold_mon_dst_ring = false;
5532 if (sw_mon_entries->drop_ppdu)
5533 ath11k_dp_rx_full_mon_drop_ppdu(&ab->dp, pmon->mon_mpdu);
5538 static int ath11k_dp_full_mon_process_rx(struct ath11k_base *ab, int mac_id,
5539 struct napi_struct *napi, int budget)
5541 struct ath11k *ar = ab->pdevs[mac_id].ar;
5542 struct ath11k_pdev_dp *dp = &ar->dp;
5543 struct ath11k_mon_data *pmon = &dp->mon_data;
5544 struct hal_sw_mon_ring_entries *sw_mon_entries;
5545 struct ath11k_pdev_mon_stats *rx_mon_stats;
5546 struct sk_buff *head_msdu, *tail_msdu;
5547 void *mon_dst_srng = &ar->ab->hal.srng_list[dp->rxdma_mon_dst_ring.ring_id];
5549 u32 rx_bufs_used = 0, mpdu_rx_bufs_used;
5551 bool break_dst_ring = false;
5553 spin_lock_bh(&pmon->mon_lock);
5555 sw_mon_entries = &pmon->sw_mon_entries;
5556 rx_mon_stats = &pmon->rx_mon_stats;
5558 if (pmon->hold_mon_dst_ring) {
5559 spin_unlock_bh(&pmon->mon_lock);
5560 goto reap_status_ring;
5563 ath11k_hal_srng_access_begin(ar->ab, mon_dst_srng);
5564 while ((ring_entry = ath11k_hal_srng_dst_peek(ar->ab, mon_dst_srng))) {
5568 mpdu_rx_bufs_used = ath11k_dp_rx_full_mon_mpdu_pop(ar, ring_entry,
5572 rx_bufs_used += mpdu_rx_bufs_used;
5574 if (!sw_mon_entries->end_of_ppdu) {
5576 ret = ath11k_dp_rx_full_mon_prepare_mpdu(&ab->dp,
5581 break_dst_ring = true;
5586 if (!sw_mon_entries->ppdu_id &&
5587 !sw_mon_entries->mon_status_paddr) {
5588 break_dst_ring = true;
5593 rx_mon_stats->dest_ppdu_done++;
5594 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
5595 pmon->buf_state = DP_MON_STATUS_LAG;
5596 pmon->mon_status_paddr = sw_mon_entries->mon_status_paddr;
5597 pmon->hold_mon_dst_ring = true;
5599 ring_entry = ath11k_hal_srng_dst_get_next_entry(ar->ab,
5605 ath11k_hal_srng_access_end(ar->ab, mon_dst_srng);
5606 spin_unlock_bh(&pmon->mon_lock);
5609 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id,
5610 &dp->rxdma_mon_buf_ring,
5612 HAL_RX_BUF_RBM_SW3_BM);
5616 quota = ath11k_dp_rx_process_full_mon_status_ring(ab, mac_id,
5622 int ath11k_dp_rx_process_mon_rings(struct ath11k_base *ab, int mac_id,
5623 struct napi_struct *napi, int budget)
5625 struct ath11k *ar = ath11k_ab_to_ar(ab, mac_id);
5628 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags) &&
5629 ab->hw_params.full_monitor_mode)
5630 ret = ath11k_dp_full_mon_process_rx(ab, mac_id, napi, budget);
5632 ret = ath11k_dp_rx_process_mon_status(ab, mac_id, napi, budget);
5637 static int ath11k_dp_rx_pdev_mon_status_attach(struct ath11k *ar)
5639 struct ath11k_pdev_dp *dp = &ar->dp;
5640 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
5642 skb_queue_head_init(&pmon->rx_status_q);
5644 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
5646 memset(&pmon->rx_mon_stats, 0,
5647 sizeof(pmon->rx_mon_stats));
5651 int ath11k_dp_rx_pdev_mon_attach(struct ath11k *ar)
5653 struct ath11k_pdev_dp *dp = &ar->dp;
5654 struct ath11k_mon_data *pmon = &dp->mon_data;
5655 struct hal_srng *mon_desc_srng = NULL;
5656 struct dp_srng *dp_srng;
5658 u32 n_link_desc = 0;
5660 ret = ath11k_dp_rx_pdev_mon_status_attach(ar);
5662 ath11k_warn(ar->ab, "pdev_mon_status_attach() failed");
5666 /* if rxdma1_enable is false, no need to setup
5667 * rxdma_mon_desc_ring.
5669 if (!ar->ab->hw_params.rxdma1_enable)
5672 dp_srng = &dp->rxdma_mon_desc_ring;
5673 n_link_desc = dp_srng->size /
5674 ath11k_hal_srng_get_entrysize(ar->ab, HAL_RXDMA_MONITOR_DESC);
5676 &ar->ab->hal.srng_list[dp->rxdma_mon_desc_ring.ring_id];
5678 ret = ath11k_dp_link_desc_setup(ar->ab, pmon->link_desc_banks,
5679 HAL_RXDMA_MONITOR_DESC, mon_desc_srng,
5682 ath11k_warn(ar->ab, "mon_link_desc_pool_setup() failed");
5685 pmon->mon_last_linkdesc_paddr = 0;
5686 pmon->mon_last_buf_cookie = DP_RX_DESC_COOKIE_MAX + 1;
5687 spin_lock_init(&pmon->mon_lock);
5692 static int ath11k_dp_mon_link_free(struct ath11k *ar)
5694 struct ath11k_pdev_dp *dp = &ar->dp;
5695 struct ath11k_mon_data *pmon = &dp->mon_data;
5697 ath11k_dp_link_desc_cleanup(ar->ab, pmon->link_desc_banks,
5698 HAL_RXDMA_MONITOR_DESC,
5699 &dp->rxdma_mon_desc_ring);
5703 int ath11k_dp_rx_pdev_mon_detach(struct ath11k *ar)
5705 ath11k_dp_mon_link_free(ar);
5709 int ath11k_dp_rx_pktlog_start(struct ath11k_base *ab)
5711 /* start reap timer */
5712 mod_timer(&ab->mon_reap_timer,
5713 jiffies + msecs_to_jiffies(ATH11K_MON_TIMER_INTERVAL));
5718 int ath11k_dp_rx_pktlog_stop(struct ath11k_base *ab, bool stop_timer)
5723 del_timer_sync(&ab->mon_reap_timer);
5725 /* reap all the monitor related rings */
5726 ret = ath11k_dp_purge_mon_ring(ab);
5728 ath11k_warn(ab, "failed to purge dp mon ring: %d\n", ret);