1 // SPDX-License-Identifier: BSD-3-Clause-Clear
3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
6 #include <linux/ieee80211.h>
7 #include <linux/kernel.h>
8 #include <linux/skbuff.h>
9 #include <crypto/hash.h>
19 #define ATH11K_DP_RX_FRAGMENT_TIMEOUT_MS (2 * HZ)
21 static u8 *ath11k_dp_rx_h_80211_hdr(struct hal_rx_desc *desc)
23 return desc->hdr_status;
26 static enum hal_encrypt_type ath11k_dp_rx_h_mpdu_start_enctype(struct hal_rx_desc *desc)
28 if (!(__le32_to_cpu(desc->mpdu_start.info1) &
29 RX_MPDU_START_INFO1_ENCRYPT_INFO_VALID))
30 return HAL_ENCRYPT_TYPE_OPEN;
32 return FIELD_GET(RX_MPDU_START_INFO2_ENC_TYPE,
33 __le32_to_cpu(desc->mpdu_start.info2));
36 static u8 ath11k_dp_rx_h_msdu_start_decap_type(struct hal_rx_desc *desc)
38 return FIELD_GET(RX_MSDU_START_INFO2_DECAP_FORMAT,
39 __le32_to_cpu(desc->msdu_start.info2));
42 static u8 ath11k_dp_rx_h_msdu_start_mesh_ctl_present(struct hal_rx_desc *desc)
44 return FIELD_GET(RX_MSDU_START_INFO2_MESH_CTRL_PRESENT,
45 __le32_to_cpu(desc->msdu_start.info2));
48 static bool ath11k_dp_rx_h_mpdu_start_seq_ctrl_valid(struct hal_rx_desc *desc)
50 return !!FIELD_GET(RX_MPDU_START_INFO1_MPDU_SEQ_CTRL_VALID,
51 __le32_to_cpu(desc->mpdu_start.info1));
54 static bool ath11k_dp_rx_h_mpdu_start_fc_valid(struct hal_rx_desc *desc)
56 return !!FIELD_GET(RX_MPDU_START_INFO1_MPDU_FCTRL_VALID,
57 __le32_to_cpu(desc->mpdu_start.info1));
60 static bool ath11k_dp_rx_h_mpdu_start_more_frags(struct sk_buff *skb)
62 struct ieee80211_hdr *hdr;
64 hdr = (struct ieee80211_hdr *)(skb->data + HAL_RX_DESC_SIZE);
65 return ieee80211_has_morefrags(hdr->frame_control);
68 static u16 ath11k_dp_rx_h_mpdu_start_frag_no(struct sk_buff *skb)
70 struct ieee80211_hdr *hdr;
72 hdr = (struct ieee80211_hdr *)(skb->data + HAL_RX_DESC_SIZE);
73 return le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
76 static u16 ath11k_dp_rx_h_mpdu_start_seq_no(struct hal_rx_desc *desc)
78 return FIELD_GET(RX_MPDU_START_INFO1_MPDU_SEQ_NUM,
79 __le32_to_cpu(desc->mpdu_start.info1));
82 static bool ath11k_dp_rx_h_attn_msdu_done(struct hal_rx_desc *desc)
84 return !!FIELD_GET(RX_ATTENTION_INFO2_MSDU_DONE,
85 __le32_to_cpu(desc->attention.info2));
88 static bool ath11k_dp_rx_h_attn_l4_cksum_fail(struct hal_rx_desc *desc)
90 return !!FIELD_GET(RX_ATTENTION_INFO1_TCP_UDP_CKSUM_FAIL,
91 __le32_to_cpu(desc->attention.info1));
94 static bool ath11k_dp_rx_h_attn_ip_cksum_fail(struct hal_rx_desc *desc)
96 return !!FIELD_GET(RX_ATTENTION_INFO1_IP_CKSUM_FAIL,
97 __le32_to_cpu(desc->attention.info1));
100 static bool ath11k_dp_rx_h_attn_is_decrypted(struct hal_rx_desc *desc)
102 return (FIELD_GET(RX_ATTENTION_INFO2_DCRYPT_STATUS_CODE,
103 __le32_to_cpu(desc->attention.info2)) ==
104 RX_DESC_DECRYPT_STATUS_CODE_OK);
107 static u32 ath11k_dp_rx_h_attn_mpdu_err(struct hal_rx_desc *desc)
109 u32 info = __le32_to_cpu(desc->attention.info1);
112 if (info & RX_ATTENTION_INFO1_FCS_ERR)
113 errmap |= DP_RX_MPDU_ERR_FCS;
115 if (info & RX_ATTENTION_INFO1_DECRYPT_ERR)
116 errmap |= DP_RX_MPDU_ERR_DECRYPT;
118 if (info & RX_ATTENTION_INFO1_TKIP_MIC_ERR)
119 errmap |= DP_RX_MPDU_ERR_TKIP_MIC;
121 if (info & RX_ATTENTION_INFO1_A_MSDU_ERROR)
122 errmap |= DP_RX_MPDU_ERR_AMSDU_ERR;
124 if (info & RX_ATTENTION_INFO1_OVERFLOW_ERR)
125 errmap |= DP_RX_MPDU_ERR_OVERFLOW;
127 if (info & RX_ATTENTION_INFO1_MSDU_LEN_ERR)
128 errmap |= DP_RX_MPDU_ERR_MSDU_LEN;
130 if (info & RX_ATTENTION_INFO1_MPDU_LEN_ERR)
131 errmap |= DP_RX_MPDU_ERR_MPDU_LEN;
136 static u16 ath11k_dp_rx_h_msdu_start_msdu_len(struct hal_rx_desc *desc)
138 return FIELD_GET(RX_MSDU_START_INFO1_MSDU_LENGTH,
139 __le32_to_cpu(desc->msdu_start.info1));
142 static u8 ath11k_dp_rx_h_msdu_start_sgi(struct hal_rx_desc *desc)
144 return FIELD_GET(RX_MSDU_START_INFO3_SGI,
145 __le32_to_cpu(desc->msdu_start.info3));
148 static u8 ath11k_dp_rx_h_msdu_start_rate_mcs(struct hal_rx_desc *desc)
150 return FIELD_GET(RX_MSDU_START_INFO3_RATE_MCS,
151 __le32_to_cpu(desc->msdu_start.info3));
154 static u8 ath11k_dp_rx_h_msdu_start_rx_bw(struct hal_rx_desc *desc)
156 return FIELD_GET(RX_MSDU_START_INFO3_RECV_BW,
157 __le32_to_cpu(desc->msdu_start.info3));
160 static u32 ath11k_dp_rx_h_msdu_start_freq(struct hal_rx_desc *desc)
162 return __le32_to_cpu(desc->msdu_start.phy_meta_data);
165 static u8 ath11k_dp_rx_h_msdu_start_pkt_type(struct hal_rx_desc *desc)
167 return FIELD_GET(RX_MSDU_START_INFO3_PKT_TYPE,
168 __le32_to_cpu(desc->msdu_start.info3));
171 static u8 ath11k_dp_rx_h_msdu_start_nss(struct hal_rx_desc *desc)
173 u8 mimo_ss_bitmap = FIELD_GET(RX_MSDU_START_INFO3_MIMO_SS_BITMAP,
174 __le32_to_cpu(desc->msdu_start.info3));
176 return hweight8(mimo_ss_bitmap);
179 static u8 ath11k_dp_rx_h_mpdu_start_tid(struct hal_rx_desc *desc)
181 return FIELD_GET(RX_MPDU_START_INFO2_TID,
182 __le32_to_cpu(desc->mpdu_start.info2));
185 static u16 ath11k_dp_rx_h_mpdu_start_peer_id(struct hal_rx_desc *desc)
187 return __le16_to_cpu(desc->mpdu_start.sw_peer_id);
190 static u8 ath11k_dp_rx_h_msdu_end_l3pad(struct hal_rx_desc *desc)
192 return FIELD_GET(RX_MSDU_END_INFO2_L3_HDR_PADDING,
193 __le32_to_cpu(desc->msdu_end.info2));
196 static bool ath11k_dp_rx_h_msdu_end_first_msdu(struct hal_rx_desc *desc)
198 return !!FIELD_GET(RX_MSDU_END_INFO2_FIRST_MSDU,
199 __le32_to_cpu(desc->msdu_end.info2));
202 static bool ath11k_dp_rx_h_msdu_end_last_msdu(struct hal_rx_desc *desc)
204 return !!FIELD_GET(RX_MSDU_END_INFO2_LAST_MSDU,
205 __le32_to_cpu(desc->msdu_end.info2));
208 static void ath11k_dp_rx_desc_end_tlv_copy(struct hal_rx_desc *fdesc,
209 struct hal_rx_desc *ldesc)
211 memcpy((u8 *)&fdesc->msdu_end, (u8 *)&ldesc->msdu_end,
212 sizeof(struct rx_msdu_end));
213 memcpy((u8 *)&fdesc->attention, (u8 *)&ldesc->attention,
214 sizeof(struct rx_attention));
215 memcpy((u8 *)&fdesc->mpdu_end, (u8 *)&ldesc->mpdu_end,
216 sizeof(struct rx_mpdu_end));
219 static u32 ath11k_dp_rxdesc_get_mpdulen_err(struct hal_rx_desc *rx_desc)
221 struct rx_attention *rx_attn;
223 rx_attn = &rx_desc->attention;
225 return FIELD_GET(RX_ATTENTION_INFO1_MPDU_LEN_ERR,
226 __le32_to_cpu(rx_attn->info1));
229 static u32 ath11k_dp_rxdesc_get_decap_format(struct hal_rx_desc *rx_desc)
231 struct rx_msdu_start *rx_msdu_start;
233 rx_msdu_start = &rx_desc->msdu_start;
235 return FIELD_GET(RX_MSDU_START_INFO2_DECAP_FORMAT,
236 __le32_to_cpu(rx_msdu_start->info2));
239 static u8 *ath11k_dp_rxdesc_get_80211hdr(struct hal_rx_desc *rx_desc)
243 rx_pkt_hdr = &rx_desc->msdu_payload[0];
248 static bool ath11k_dp_rxdesc_mpdu_valid(struct hal_rx_desc *rx_desc)
252 tlv_tag = FIELD_GET(HAL_TLV_HDR_TAG,
253 __le32_to_cpu(rx_desc->mpdu_start_tag));
255 return tlv_tag == HAL_RX_MPDU_START ? true : false;
258 static u32 ath11k_dp_rxdesc_get_ppduid(struct hal_rx_desc *rx_desc)
260 return __le16_to_cpu(rx_desc->mpdu_start.phy_ppdu_id);
263 /* Returns number of Rx buffers replenished */
264 int ath11k_dp_rxbufs_replenish(struct ath11k_base *ab, int mac_id,
265 struct dp_rxdma_ring *rx_ring,
267 enum hal_rx_buf_return_buf_manager mgr,
270 struct hal_srng *srng;
279 req_entries = min(req_entries, rx_ring->bufs_max);
281 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
283 spin_lock_bh(&srng->lock);
285 ath11k_hal_srng_access_begin(ab, srng);
287 num_free = ath11k_hal_srng_src_num_free(ab, srng, true);
288 if (!req_entries && (num_free > (rx_ring->bufs_max * 3) / 4))
289 req_entries = num_free;
291 req_entries = min(num_free, req_entries);
292 num_remain = req_entries;
294 while (num_remain > 0) {
295 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE +
296 DP_RX_BUFFER_ALIGN_SIZE);
300 if (!IS_ALIGNED((unsigned long)skb->data,
301 DP_RX_BUFFER_ALIGN_SIZE)) {
303 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
307 paddr = dma_map_single(ab->dev, skb->data,
308 skb->len + skb_tailroom(skb),
310 if (dma_mapping_error(ab->dev, paddr))
313 spin_lock_bh(&rx_ring->idr_lock);
314 buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0,
315 rx_ring->bufs_max * 3, gfp);
316 spin_unlock_bh(&rx_ring->idr_lock);
320 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
322 goto fail_idr_remove;
324 ATH11K_SKB_RXCB(skb)->paddr = paddr;
326 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
327 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
331 ath11k_hal_rx_buf_addr_info_set(desc, paddr, cookie, mgr);
334 ath11k_hal_srng_access_end(ab, srng);
336 spin_unlock_bh(&srng->lock);
338 return req_entries - num_remain;
341 spin_lock_bh(&rx_ring->idr_lock);
342 idr_remove(&rx_ring->bufs_idr, buf_id);
343 spin_unlock_bh(&rx_ring->idr_lock);
345 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
348 dev_kfree_skb_any(skb);
350 ath11k_hal_srng_access_end(ab, srng);
352 spin_unlock_bh(&srng->lock);
354 return req_entries - num_remain;
357 static int ath11k_dp_rxdma_buf_ring_free(struct ath11k *ar,
358 struct dp_rxdma_ring *rx_ring)
360 struct ath11k_pdev_dp *dp = &ar->dp;
364 spin_lock_bh(&rx_ring->idr_lock);
365 idr_for_each_entry(&rx_ring->bufs_idr, skb, buf_id) {
366 idr_remove(&rx_ring->bufs_idr, buf_id);
367 /* TODO: Understand where internal driver does this dma_unmap of
370 dma_unmap_single(ar->ab->dev, ATH11K_SKB_RXCB(skb)->paddr,
371 skb->len + skb_tailroom(skb), DMA_FROM_DEVICE);
372 dev_kfree_skb_any(skb);
375 idr_destroy(&rx_ring->bufs_idr);
376 spin_unlock_bh(&rx_ring->idr_lock);
378 rx_ring = &dp->rx_mon_status_refill_ring;
380 spin_lock_bh(&rx_ring->idr_lock);
381 idr_for_each_entry(&rx_ring->bufs_idr, skb, buf_id) {
382 idr_remove(&rx_ring->bufs_idr, buf_id);
383 /* XXX: Understand where internal driver does this dma_unmap of
386 dma_unmap_single(ar->ab->dev, ATH11K_SKB_RXCB(skb)->paddr,
387 skb->len + skb_tailroom(skb), DMA_BIDIRECTIONAL);
388 dev_kfree_skb_any(skb);
391 idr_destroy(&rx_ring->bufs_idr);
392 spin_unlock_bh(&rx_ring->idr_lock);
396 static int ath11k_dp_rxdma_pdev_buf_free(struct ath11k *ar)
398 struct ath11k_pdev_dp *dp = &ar->dp;
399 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
401 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
403 rx_ring = &dp->rxdma_mon_buf_ring;
404 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
406 rx_ring = &dp->rx_mon_status_refill_ring;
407 ath11k_dp_rxdma_buf_ring_free(ar, rx_ring);
411 static int ath11k_dp_rxdma_ring_buf_setup(struct ath11k *ar,
412 struct dp_rxdma_ring *rx_ring,
415 struct ath11k_pdev_dp *dp = &ar->dp;
418 num_entries = rx_ring->refill_buf_ring.size /
419 ath11k_hal_srng_get_entrysize(ringtype);
421 rx_ring->bufs_max = num_entries;
422 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id, rx_ring, num_entries,
423 HAL_RX_BUF_RBM_SW3_BM, GFP_KERNEL);
427 static int ath11k_dp_rxdma_pdev_buf_setup(struct ath11k *ar)
429 struct ath11k_pdev_dp *dp = &ar->dp;
430 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
432 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_BUF);
434 rx_ring = &dp->rxdma_mon_buf_ring;
435 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_MONITOR_BUF);
437 rx_ring = &dp->rx_mon_status_refill_ring;
438 ath11k_dp_rxdma_ring_buf_setup(ar, rx_ring, HAL_RXDMA_MONITOR_STATUS);
443 static void ath11k_dp_rx_pdev_srng_free(struct ath11k *ar)
445 struct ath11k_pdev_dp *dp = &ar->dp;
447 ath11k_dp_srng_cleanup(ar->ab, &dp->rx_refill_buf_ring.refill_buf_ring);
448 ath11k_dp_srng_cleanup(ar->ab, &dp->rxdma_err_dst_ring);
449 ath11k_dp_srng_cleanup(ar->ab, &dp->rx_mon_status_refill_ring.refill_buf_ring);
450 ath11k_dp_srng_cleanup(ar->ab, &dp->rxdma_mon_buf_ring.refill_buf_ring);
453 void ath11k_dp_pdev_reo_cleanup(struct ath11k_base *ab)
455 struct ath11k_dp *dp = &ab->dp;
458 for (i = 0; i < DP_REO_DST_RING_MAX; i++)
459 ath11k_dp_srng_cleanup(ab, &dp->reo_dst_ring[i]);
462 int ath11k_dp_pdev_reo_setup(struct ath11k_base *ab)
464 struct ath11k_dp *dp = &ab->dp;
468 for (i = 0; i < DP_REO_DST_RING_MAX; i++) {
469 ret = ath11k_dp_srng_setup(ab, &dp->reo_dst_ring[i],
471 DP_REO_DST_RING_SIZE);
473 ath11k_warn(ab, "failed to setup reo_dst_ring\n");
474 goto err_reo_cleanup;
481 ath11k_dp_pdev_reo_cleanup(ab);
486 static int ath11k_dp_rx_pdev_srng_alloc(struct ath11k *ar)
488 struct ath11k_pdev_dp *dp = &ar->dp;
489 struct dp_srng *srng = NULL;
492 ret = ath11k_dp_srng_setup(ar->ab,
493 &dp->rx_refill_buf_ring.refill_buf_ring,
495 dp->mac_id, DP_RXDMA_BUF_RING_SIZE);
497 ath11k_warn(ar->ab, "failed to setup rx_refill_buf_ring\n");
501 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_err_dst_ring,
502 HAL_RXDMA_DST, 0, dp->mac_id,
503 DP_RXDMA_ERR_DST_RING_SIZE);
505 ath11k_warn(ar->ab, "failed to setup rxdma_err_dst_ring\n");
509 srng = &dp->rx_mon_status_refill_ring.refill_buf_ring;
510 ret = ath11k_dp_srng_setup(ar->ab,
512 HAL_RXDMA_MONITOR_STATUS, 0, dp->mac_id,
513 DP_RXDMA_MON_STATUS_RING_SIZE);
516 "failed to setup rx_mon_status_refill_ring\n");
519 ret = ath11k_dp_srng_setup(ar->ab,
520 &dp->rxdma_mon_buf_ring.refill_buf_ring,
521 HAL_RXDMA_MONITOR_BUF, 0, dp->mac_id,
522 DP_RXDMA_MONITOR_BUF_RING_SIZE);
525 "failed to setup HAL_RXDMA_MONITOR_BUF\n");
529 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_mon_dst_ring,
530 HAL_RXDMA_MONITOR_DST, 0, dp->mac_id,
531 DP_RXDMA_MONITOR_DST_RING_SIZE);
534 "failed to setup HAL_RXDMA_MONITOR_DST\n");
538 ret = ath11k_dp_srng_setup(ar->ab, &dp->rxdma_mon_desc_ring,
539 HAL_RXDMA_MONITOR_DESC, 0, dp->mac_id,
540 DP_RXDMA_MONITOR_DESC_RING_SIZE);
543 "failed to setup HAL_RXDMA_MONITOR_DESC\n");
550 void ath11k_dp_reo_cmd_list_cleanup(struct ath11k_base *ab)
552 struct ath11k_dp *dp = &ab->dp;
553 struct dp_reo_cmd *cmd, *tmp;
554 struct dp_reo_cache_flush_elem *cmd_cache, *tmp_cache;
556 spin_lock_bh(&dp->reo_cmd_lock);
557 list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) {
558 list_del(&cmd->list);
559 dma_unmap_single(ab->dev, cmd->data.paddr,
560 cmd->data.size, DMA_BIDIRECTIONAL);
561 kfree(cmd->data.vaddr);
565 list_for_each_entry_safe(cmd_cache, tmp_cache,
566 &dp->reo_cmd_cache_flush_list, list) {
567 list_del(&cmd_cache->list);
568 dma_unmap_single(ab->dev, cmd_cache->data.paddr,
569 cmd_cache->data.size, DMA_BIDIRECTIONAL);
570 kfree(cmd_cache->data.vaddr);
573 spin_unlock_bh(&dp->reo_cmd_lock);
576 static void ath11k_dp_reo_cmd_free(struct ath11k_dp *dp, void *ctx,
577 enum hal_reo_cmd_status status)
579 struct dp_rx_tid *rx_tid = ctx;
581 if (status != HAL_REO_CMD_SUCCESS)
582 ath11k_warn(dp->ab, "failed to flush rx tid hw desc, tid %d status %d\n",
583 rx_tid->tid, status);
585 dma_unmap_single(dp->ab->dev, rx_tid->paddr, rx_tid->size,
587 kfree(rx_tid->vaddr);
590 static void ath11k_dp_reo_cache_flush(struct ath11k_base *ab,
591 struct dp_rx_tid *rx_tid)
593 struct ath11k_hal_reo_cmd cmd = {0};
594 unsigned long tot_desc_sz, desc_sz;
597 tot_desc_sz = rx_tid->size;
598 desc_sz = ath11k_hal_reo_qdesc_size(0, HAL_DESC_REO_NON_QOS_TID);
600 while (tot_desc_sz > desc_sz) {
601 tot_desc_sz -= desc_sz;
602 cmd.addr_lo = lower_32_bits(rx_tid->paddr + tot_desc_sz);
603 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
604 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
605 HAL_REO_CMD_FLUSH_CACHE, &cmd,
609 "failed to send HAL_REO_CMD_FLUSH_CACHE, tid %d (%d)\n",
613 memset(&cmd, 0, sizeof(cmd));
614 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
615 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
616 cmd.flag |= HAL_REO_CMD_FLG_NEED_STATUS;
617 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
618 HAL_REO_CMD_FLUSH_CACHE,
619 &cmd, ath11k_dp_reo_cmd_free);
621 ath11k_err(ab, "failed to send HAL_REO_CMD_FLUSH_CACHE cmd, tid %d (%d)\n",
623 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
625 kfree(rx_tid->vaddr);
629 static void ath11k_dp_rx_tid_del_func(struct ath11k_dp *dp, void *ctx,
630 enum hal_reo_cmd_status status)
632 struct ath11k_base *ab = dp->ab;
633 struct dp_rx_tid *rx_tid = ctx;
634 struct dp_reo_cache_flush_elem *elem, *tmp;
636 if (status == HAL_REO_CMD_DRAIN) {
638 } else if (status != HAL_REO_CMD_SUCCESS) {
639 /* Shouldn't happen! Cleanup in case of other failure? */
640 ath11k_warn(ab, "failed to delete rx tid %d hw descriptor %d\n",
641 rx_tid->tid, status);
645 elem = kzalloc(sizeof(*elem), GFP_ATOMIC);
650 memcpy(&elem->data, rx_tid, sizeof(*rx_tid));
652 spin_lock_bh(&dp->reo_cmd_lock);
653 list_add_tail(&elem->list, &dp->reo_cmd_cache_flush_list);
654 spin_unlock_bh(&dp->reo_cmd_lock);
656 /* Flush and invalidate aged REO desc from HW cache */
657 spin_lock_bh(&dp->reo_cmd_lock);
658 list_for_each_entry_safe(elem, tmp, &dp->reo_cmd_cache_flush_list,
660 if (time_after(jiffies, elem->ts +
661 msecs_to_jiffies(DP_REO_DESC_FREE_TIMEOUT_MS))) {
662 list_del(&elem->list);
663 spin_unlock_bh(&dp->reo_cmd_lock);
665 ath11k_dp_reo_cache_flush(ab, &elem->data);
667 spin_lock_bh(&dp->reo_cmd_lock);
670 spin_unlock_bh(&dp->reo_cmd_lock);
674 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
676 kfree(rx_tid->vaddr);
679 void ath11k_peer_rx_tid_delete(struct ath11k *ar,
680 struct ath11k_peer *peer, u8 tid)
682 struct ath11k_hal_reo_cmd cmd = {0};
683 struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
689 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
690 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
691 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
692 cmd.upd0 |= HAL_REO_CMD_UPD0_VLD;
693 ret = ath11k_dp_tx_send_reo_cmd(ar->ab, rx_tid,
694 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
695 ath11k_dp_rx_tid_del_func);
697 ath11k_err(ar->ab, "failed to send HAL_REO_CMD_UPDATE_RX_QUEUE cmd, tid %d (%d)\n",
699 dma_unmap_single(ar->ab->dev, rx_tid->paddr, rx_tid->size,
701 kfree(rx_tid->vaddr);
704 rx_tid->active = false;
707 static int ath11k_dp_rx_link_desc_return(struct ath11k_base *ab,
709 enum hal_wbm_rel_bm_act action)
711 struct ath11k_dp *dp = &ab->dp;
712 struct hal_srng *srng;
716 srng = &ab->hal.srng_list[dp->wbm_desc_rel_ring.ring_id];
718 spin_lock_bh(&srng->lock);
720 ath11k_hal_srng_access_begin(ab, srng);
722 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
728 ath11k_hal_rx_msdu_link_desc_set(ab, (void *)desc, (void *)link_desc,
732 ath11k_hal_srng_access_end(ab, srng);
734 spin_unlock_bh(&srng->lock);
739 static void ath11k_dp_rx_frags_cleanup(struct dp_rx_tid *rx_tid, bool rel_link_desc)
741 struct ath11k_base *ab = rx_tid->ab;
743 lockdep_assert_held(&ab->base_lock);
745 if (rx_tid->dst_ring_desc) {
747 ath11k_dp_rx_link_desc_return(ab, (u32 *)rx_tid->dst_ring_desc,
748 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
749 kfree(rx_tid->dst_ring_desc);
750 rx_tid->dst_ring_desc = NULL;
754 rx_tid->last_frag_no = 0;
755 rx_tid->rx_frag_bitmap = 0;
756 __skb_queue_purge(&rx_tid->rx_frags);
759 void ath11k_peer_rx_tid_cleanup(struct ath11k *ar, struct ath11k_peer *peer)
761 struct dp_rx_tid *rx_tid;
764 lockdep_assert_held(&ar->ab->base_lock);
766 for (i = 0; i <= IEEE80211_NUM_TIDS; i++) {
767 rx_tid = &peer->rx_tid[i];
769 ath11k_peer_rx_tid_delete(ar, peer, i);
770 ath11k_dp_rx_frags_cleanup(rx_tid, true);
772 spin_unlock_bh(&ar->ab->base_lock);
773 del_timer_sync(&rx_tid->frag_timer);
774 spin_lock_bh(&ar->ab->base_lock);
778 static int ath11k_peer_rx_tid_reo_update(struct ath11k *ar,
779 struct ath11k_peer *peer,
780 struct dp_rx_tid *rx_tid,
781 u32 ba_win_sz, u16 ssn,
784 struct ath11k_hal_reo_cmd cmd = {0};
787 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
788 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
789 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
790 cmd.upd0 = HAL_REO_CMD_UPD0_BA_WINDOW_SIZE;
791 cmd.ba_window_size = ba_win_sz;
794 cmd.upd0 |= HAL_REO_CMD_UPD0_SSN;
795 cmd.upd2 = FIELD_PREP(HAL_REO_CMD_UPD2_SSN, ssn);
798 ret = ath11k_dp_tx_send_reo_cmd(ar->ab, rx_tid,
799 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
802 ath11k_warn(ar->ab, "failed to update rx tid queue, tid %d (%d)\n",
807 rx_tid->ba_win_sz = ba_win_sz;
812 static void ath11k_dp_rx_tid_mem_free(struct ath11k_base *ab,
813 const u8 *peer_mac, int vdev_id, u8 tid)
815 struct ath11k_peer *peer;
816 struct dp_rx_tid *rx_tid;
818 spin_lock_bh(&ab->base_lock);
820 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
822 ath11k_warn(ab, "failed to find the peer to free up rx tid mem\n");
826 rx_tid = &peer->rx_tid[tid];
830 dma_unmap_single(ab->dev, rx_tid->paddr, rx_tid->size,
832 kfree(rx_tid->vaddr);
834 rx_tid->active = false;
837 spin_unlock_bh(&ab->base_lock);
840 int ath11k_peer_rx_tid_setup(struct ath11k *ar, const u8 *peer_mac, int vdev_id,
841 u8 tid, u32 ba_win_sz, u16 ssn,
842 enum hal_pn_type pn_type)
844 struct ath11k_base *ab = ar->ab;
845 struct ath11k_peer *peer;
846 struct dp_rx_tid *rx_tid;
853 spin_lock_bh(&ab->base_lock);
855 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
857 ath11k_warn(ab, "failed to find the peer to set up rx tid\n");
858 spin_unlock_bh(&ab->base_lock);
862 rx_tid = &peer->rx_tid[tid];
863 /* Update the tid queue if it is already setup */
864 if (rx_tid->active) {
865 paddr = rx_tid->paddr;
866 ret = ath11k_peer_rx_tid_reo_update(ar, peer, rx_tid,
867 ba_win_sz, ssn, true);
868 spin_unlock_bh(&ab->base_lock);
870 ath11k_warn(ab, "failed to update reo for rx tid %d\n", tid);
874 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id,
878 ath11k_warn(ab, "failed to send wmi command to update rx reorder queue, tid :%d (%d)\n",
885 rx_tid->ba_win_sz = ba_win_sz;
887 /* TODO: Optimize the memory allocation for qos tid based on the
888 * the actual BA window size in REO tid update path.
890 if (tid == HAL_DESC_REO_NON_QOS_TID)
891 hw_desc_sz = ath11k_hal_reo_qdesc_size(ba_win_sz, tid);
893 hw_desc_sz = ath11k_hal_reo_qdesc_size(DP_BA_WIN_SZ_MAX, tid);
895 vaddr = kzalloc(hw_desc_sz + HAL_LINK_DESC_ALIGN - 1, GFP_ATOMIC);
897 spin_unlock_bh(&ab->base_lock);
901 addr_aligned = PTR_ALIGN(vaddr, HAL_LINK_DESC_ALIGN);
903 ath11k_hal_reo_qdesc_setup(addr_aligned, tid, ba_win_sz,
906 paddr = dma_map_single(ab->dev, addr_aligned, hw_desc_sz,
909 ret = dma_mapping_error(ab->dev, paddr);
911 spin_unlock_bh(&ab->base_lock);
915 rx_tid->vaddr = vaddr;
916 rx_tid->paddr = paddr;
917 rx_tid->size = hw_desc_sz;
918 rx_tid->active = true;
920 spin_unlock_bh(&ab->base_lock);
922 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id, peer_mac,
923 paddr, tid, 1, ba_win_sz);
925 ath11k_warn(ar->ab, "failed to setup rx reorder queue, tid :%d (%d)\n",
927 ath11k_dp_rx_tid_mem_free(ab, peer_mac, vdev_id, tid);
938 int ath11k_dp_rx_ampdu_start(struct ath11k *ar,
939 struct ieee80211_ampdu_params *params)
941 struct ath11k_base *ab = ar->ab;
942 struct ath11k_sta *arsta = (void *)params->sta->drv_priv;
943 int vdev_id = arsta->arvif->vdev_id;
946 ret = ath11k_peer_rx_tid_setup(ar, params->sta->addr, vdev_id,
947 params->tid, params->buf_size,
948 params->ssn, arsta->pn_type);
950 ath11k_warn(ab, "failed to setup rx tid %d\n", ret);
955 int ath11k_dp_rx_ampdu_stop(struct ath11k *ar,
956 struct ieee80211_ampdu_params *params)
958 struct ath11k_base *ab = ar->ab;
959 struct ath11k_peer *peer;
960 struct ath11k_sta *arsta = (void *)params->sta->drv_priv;
961 int vdev_id = arsta->arvif->vdev_id;
966 spin_lock_bh(&ab->base_lock);
968 peer = ath11k_peer_find(ab, vdev_id, params->sta->addr);
970 ath11k_warn(ab, "failed to find the peer to stop rx aggregation\n");
971 spin_unlock_bh(&ab->base_lock);
975 paddr = peer->rx_tid[params->tid].paddr;
976 active = peer->rx_tid[params->tid].active;
979 spin_unlock_bh(&ab->base_lock);
983 ret = ath11k_peer_rx_tid_reo_update(ar, peer, peer->rx_tid, 1, 0, false);
984 spin_unlock_bh(&ab->base_lock);
986 ath11k_warn(ab, "failed to update reo for rx tid %d: %d\n",
991 ret = ath11k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id,
992 params->sta->addr, paddr,
995 ath11k_warn(ab, "failed to send wmi to delete rx tid %d\n",
1001 int ath11k_dp_peer_rx_pn_replay_config(struct ath11k_vif *arvif,
1002 const u8 *peer_addr,
1003 enum set_key_cmd key_cmd,
1004 struct ieee80211_key_conf *key)
1006 struct ath11k *ar = arvif->ar;
1007 struct ath11k_base *ab = ar->ab;
1008 struct ath11k_hal_reo_cmd cmd = {0};
1009 struct ath11k_peer *peer;
1010 struct dp_rx_tid *rx_tid;
1014 /* NOTE: Enable PN/TSC replay check offload only for unicast frames.
1015 * We use mac80211 PN/TSC replay check functionality for bcast/mcast
1018 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1021 cmd.flag |= HAL_REO_CMD_FLG_NEED_STATUS;
1022 cmd.upd0 |= HAL_REO_CMD_UPD0_PN |
1023 HAL_REO_CMD_UPD0_PN_SIZE |
1024 HAL_REO_CMD_UPD0_PN_VALID |
1025 HAL_REO_CMD_UPD0_PN_CHECK |
1026 HAL_REO_CMD_UPD0_SVLD;
1028 switch (key->cipher) {
1029 case WLAN_CIPHER_SUITE_TKIP:
1030 case WLAN_CIPHER_SUITE_CCMP:
1031 case WLAN_CIPHER_SUITE_CCMP_256:
1032 case WLAN_CIPHER_SUITE_GCMP:
1033 case WLAN_CIPHER_SUITE_GCMP_256:
1034 if (key_cmd == SET_KEY) {
1035 cmd.upd1 |= HAL_REO_CMD_UPD1_PN_CHECK;
1043 spin_lock_bh(&ab->base_lock);
1045 peer = ath11k_peer_find(ab, arvif->vdev_id, peer_addr);
1047 ath11k_warn(ab, "failed to find the peer to configure pn replay detection\n");
1048 spin_unlock_bh(&ab->base_lock);
1052 for (tid = 0; tid <= IEEE80211_NUM_TIDS; tid++) {
1053 rx_tid = &peer->rx_tid[tid];
1054 if (!rx_tid->active)
1056 cmd.addr_lo = lower_32_bits(rx_tid->paddr);
1057 cmd.addr_hi = upper_32_bits(rx_tid->paddr);
1058 ret = ath11k_dp_tx_send_reo_cmd(ab, rx_tid,
1059 HAL_REO_CMD_UPDATE_RX_QUEUE,
1062 ath11k_warn(ab, "failed to configure rx tid %d queue for pn replay detection %d\n",
1068 spin_unlock_bh(&ar->ab->base_lock);
1073 static inline int ath11k_get_ppdu_user_index(struct htt_ppdu_stats *ppdu_stats,
1078 for (i = 0; i < HTT_PPDU_STATS_MAX_USERS - 1; i++) {
1079 if (ppdu_stats->user_stats[i].is_valid_peer_id) {
1080 if (peer_id == ppdu_stats->user_stats[i].peer_id)
1090 static int ath11k_htt_tlv_ppdu_stats_parse(struct ath11k_base *ab,
1091 u16 tag, u16 len, const void *ptr,
1094 struct htt_ppdu_stats_info *ppdu_info;
1095 struct htt_ppdu_user_stats *user_stats;
1099 ppdu_info = (struct htt_ppdu_stats_info *)data;
1102 case HTT_PPDU_STATS_TAG_COMMON:
1103 if (len < sizeof(struct htt_ppdu_stats_common)) {
1104 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1108 memcpy((void *)&ppdu_info->ppdu_stats.common, ptr,
1109 sizeof(struct htt_ppdu_stats_common));
1111 case HTT_PPDU_STATS_TAG_USR_RATE:
1112 if (len < sizeof(struct htt_ppdu_stats_user_rate)) {
1113 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1118 peer_id = ((struct htt_ppdu_stats_user_rate *)ptr)->sw_peer_id;
1119 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1123 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1124 user_stats->peer_id = peer_id;
1125 user_stats->is_valid_peer_id = true;
1126 memcpy((void *)&user_stats->rate, ptr,
1127 sizeof(struct htt_ppdu_stats_user_rate));
1128 user_stats->tlv_flags |= BIT(tag);
1130 case HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON:
1131 if (len < sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn)) {
1132 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1137 peer_id = ((struct htt_ppdu_stats_usr_cmpltn_cmn *)ptr)->sw_peer_id;
1138 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1142 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1143 user_stats->peer_id = peer_id;
1144 user_stats->is_valid_peer_id = true;
1145 memcpy((void *)&user_stats->cmpltn_cmn, ptr,
1146 sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn));
1147 user_stats->tlv_flags |= BIT(tag);
1149 case HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS:
1151 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status)) {
1152 ath11k_warn(ab, "Invalid len %d for the tag 0x%x\n",
1158 ((struct htt_ppdu_stats_usr_cmpltn_ack_ba_status *)ptr)->sw_peer_id;
1159 cur_user = ath11k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
1163 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
1164 user_stats->peer_id = peer_id;
1165 user_stats->is_valid_peer_id = true;
1166 memcpy((void *)&user_stats->ack_ba, ptr,
1167 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status));
1168 user_stats->tlv_flags |= BIT(tag);
1174 int ath11k_dp_htt_tlv_iter(struct ath11k_base *ab, const void *ptr, size_t len,
1175 int (*iter)(struct ath11k_base *ar, u16 tag, u16 len,
1176 const void *ptr, void *data),
1179 const struct htt_tlv *tlv;
1180 const void *begin = ptr;
1181 u16 tlv_tag, tlv_len;
1185 if (len < sizeof(*tlv)) {
1186 ath11k_err(ab, "htt tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n",
1187 ptr - begin, len, sizeof(*tlv));
1190 tlv = (struct htt_tlv *)ptr;
1191 tlv_tag = FIELD_GET(HTT_TLV_TAG, tlv->header);
1192 tlv_len = FIELD_GET(HTT_TLV_LEN, tlv->header);
1193 ptr += sizeof(*tlv);
1194 len -= sizeof(*tlv);
1196 if (tlv_len > len) {
1197 ath11k_err(ab, "htt tlv parse failure of tag %hhu at byte %zd (%zu bytes left, %hhu expected)\n",
1198 tlv_tag, ptr - begin, len, tlv_len);
1201 ret = iter(ab, tlv_tag, tlv_len, ptr, data);
1211 static inline u32 ath11k_he_gi_to_nl80211_he_gi(u8 sgi)
1216 case RX_MSDU_START_SGI_0_8_US:
1217 ret = NL80211_RATE_INFO_HE_GI_0_8;
1219 case RX_MSDU_START_SGI_1_6_US:
1220 ret = NL80211_RATE_INFO_HE_GI_1_6;
1222 case RX_MSDU_START_SGI_3_2_US:
1223 ret = NL80211_RATE_INFO_HE_GI_3_2;
1231 ath11k_update_per_peer_tx_stats(struct ath11k *ar,
1232 struct htt_ppdu_stats *ppdu_stats, u8 user)
1234 struct ath11k_base *ab = ar->ab;
1235 struct ath11k_peer *peer;
1236 struct ieee80211_sta *sta;
1237 struct ath11k_sta *arsta;
1238 struct htt_ppdu_stats_user_rate *user_rate;
1239 struct ath11k_per_peer_tx_stats *peer_stats = &ar->peer_tx_stats;
1240 struct htt_ppdu_user_stats *usr_stats = &ppdu_stats->user_stats[user];
1241 struct htt_ppdu_stats_common *common = &ppdu_stats->common;
1243 u8 flags, mcs, nss, bw, sgi, dcm, rate_idx = 0;
1245 u16 rate = 0, succ_pkts = 0;
1246 u32 tx_duration = 0;
1247 u8 tid = HTT_PPDU_STATS_NON_QOS_TID;
1248 bool is_ampdu = false;
1253 if (!(usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_RATE)))
1256 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON))
1258 HTT_USR_CMPLTN_IS_AMPDU(usr_stats->cmpltn_cmn.flags);
1260 if (usr_stats->tlv_flags &
1261 BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS)) {
1262 succ_bytes = usr_stats->ack_ba.success_bytes;
1263 succ_pkts = FIELD_GET(HTT_PPDU_STATS_ACK_BA_INFO_NUM_MSDU_M,
1264 usr_stats->ack_ba.info);
1265 tid = FIELD_GET(HTT_PPDU_STATS_ACK_BA_INFO_TID_NUM,
1266 usr_stats->ack_ba.info);
1269 if (common->fes_duration_us)
1270 tx_duration = common->fes_duration_us;
1272 user_rate = &usr_stats->rate;
1273 flags = HTT_USR_RATE_PREAMBLE(user_rate->rate_flags);
1274 bw = HTT_USR_RATE_BW(user_rate->rate_flags) - 2;
1275 nss = HTT_USR_RATE_NSS(user_rate->rate_flags) + 1;
1276 mcs = HTT_USR_RATE_MCS(user_rate->rate_flags);
1277 sgi = HTT_USR_RATE_GI(user_rate->rate_flags);
1278 dcm = HTT_USR_RATE_DCM(user_rate->rate_flags);
1280 /* Note: If host configured fixed rates and in some other special
1281 * cases, the broadcast/management frames are sent in different rates.
1282 * Firmware rate's control to be skipped for this?
1285 if (flags == WMI_RATE_PREAMBLE_HE && mcs > 11) {
1286 ath11k_warn(ab, "Invalid HE mcs %hhd peer stats", mcs);
1290 if (flags == WMI_RATE_PREAMBLE_HE && mcs > ATH11K_HE_MCS_MAX) {
1291 ath11k_warn(ab, "Invalid HE mcs %hhd peer stats", mcs);
1295 if (flags == WMI_RATE_PREAMBLE_VHT && mcs > ATH11K_VHT_MCS_MAX) {
1296 ath11k_warn(ab, "Invalid VHT mcs %hhd peer stats", mcs);
1300 if (flags == WMI_RATE_PREAMBLE_HT && (mcs > ATH11K_HT_MCS_MAX || nss < 1)) {
1301 ath11k_warn(ab, "Invalid HT mcs %hhd nss %hhd peer stats",
1306 if (flags == WMI_RATE_PREAMBLE_CCK || flags == WMI_RATE_PREAMBLE_OFDM) {
1307 ret = ath11k_mac_hw_ratecode_to_legacy_rate(mcs,
1316 spin_lock_bh(&ab->base_lock);
1317 peer = ath11k_peer_find_by_id(ab, usr_stats->peer_id);
1319 if (!peer || !peer->sta) {
1320 spin_unlock_bh(&ab->base_lock);
1326 arsta = (struct ath11k_sta *)sta->drv_priv;
1328 memset(&arsta->txrate, 0, sizeof(arsta->txrate));
1331 case WMI_RATE_PREAMBLE_OFDM:
1332 arsta->txrate.legacy = rate;
1334 case WMI_RATE_PREAMBLE_CCK:
1335 arsta->txrate.legacy = rate;
1337 case WMI_RATE_PREAMBLE_HT:
1338 arsta->txrate.mcs = mcs + 8 * (nss - 1);
1339 arsta->txrate.flags = RATE_INFO_FLAGS_MCS;
1341 arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1343 case WMI_RATE_PREAMBLE_VHT:
1344 arsta->txrate.mcs = mcs;
1345 arsta->txrate.flags = RATE_INFO_FLAGS_VHT_MCS;
1347 arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1349 case WMI_RATE_PREAMBLE_HE:
1350 arsta->txrate.mcs = mcs;
1351 arsta->txrate.flags = RATE_INFO_FLAGS_HE_MCS;
1352 arsta->txrate.he_dcm = dcm;
1353 arsta->txrate.he_gi = ath11k_he_gi_to_nl80211_he_gi(sgi);
1354 arsta->txrate.he_ru_alloc = ath11k_he_ru_tones_to_nl80211_he_ru_alloc(
1355 (user_rate->ru_end -
1356 user_rate->ru_start) + 1);
1360 arsta->txrate.nss = nss;
1361 arsta->txrate.bw = ath11k_mac_bw_to_mac80211_bw(bw);
1362 arsta->tx_duration += tx_duration;
1363 memcpy(&arsta->last_txrate, &arsta->txrate, sizeof(struct rate_info));
1365 /* PPDU stats reported for mgmt packet doesn't have valid tx bytes.
1366 * So skip peer stats update for mgmt packets.
1368 if (tid < HTT_PPDU_STATS_NON_QOS_TID) {
1369 memset(peer_stats, 0, sizeof(*peer_stats));
1370 peer_stats->succ_pkts = succ_pkts;
1371 peer_stats->succ_bytes = succ_bytes;
1372 peer_stats->is_ampdu = is_ampdu;
1373 peer_stats->duration = tx_duration;
1374 peer_stats->ba_fails =
1375 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) +
1376 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags);
1378 if (ath11k_debug_is_extd_tx_stats_enabled(ar))
1379 ath11k_accumulate_per_peer_tx_stats(arsta,
1380 peer_stats, rate_idx);
1383 spin_unlock_bh(&ab->base_lock);
1387 static void ath11k_htt_update_ppdu_stats(struct ath11k *ar,
1388 struct htt_ppdu_stats *ppdu_stats)
1392 for (user = 0; user < HTT_PPDU_STATS_MAX_USERS - 1; user++)
1393 ath11k_update_per_peer_tx_stats(ar, ppdu_stats, user);
1397 struct htt_ppdu_stats_info *ath11k_dp_htt_get_ppdu_desc(struct ath11k *ar,
1400 struct htt_ppdu_stats_info *ppdu_info;
1402 spin_lock_bh(&ar->data_lock);
1403 if (!list_empty(&ar->ppdu_stats_info)) {
1404 list_for_each_entry(ppdu_info, &ar->ppdu_stats_info, list) {
1405 if (ppdu_info->ppdu_id == ppdu_id) {
1406 spin_unlock_bh(&ar->data_lock);
1411 if (ar->ppdu_stat_list_depth > HTT_PPDU_DESC_MAX_DEPTH) {
1412 ppdu_info = list_first_entry(&ar->ppdu_stats_info,
1413 typeof(*ppdu_info), list);
1414 list_del(&ppdu_info->list);
1415 ar->ppdu_stat_list_depth--;
1416 ath11k_htt_update_ppdu_stats(ar, &ppdu_info->ppdu_stats);
1420 spin_unlock_bh(&ar->data_lock);
1422 ppdu_info = kzalloc(sizeof(*ppdu_info), GFP_KERNEL);
1426 spin_lock_bh(&ar->data_lock);
1427 list_add_tail(&ppdu_info->list, &ar->ppdu_stats_info);
1428 ar->ppdu_stat_list_depth++;
1429 spin_unlock_bh(&ar->data_lock);
1434 static int ath11k_htt_pull_ppdu_stats(struct ath11k_base *ab,
1435 struct sk_buff *skb)
1437 struct ath11k_htt_ppdu_stats_msg *msg;
1438 struct htt_ppdu_stats_info *ppdu_info;
1444 msg = (struct ath11k_htt_ppdu_stats_msg *)skb->data;
1445 len = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PAYLOAD_SIZE, msg->info);
1446 pdev_id = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PDEV_ID, msg->info);
1447 ppdu_id = msg->ppdu_id;
1450 ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
1456 if (ath11k_debug_is_pktlog_lite_mode_enabled(ar))
1457 trace_ath11k_htt_ppdu_stats(ar, skb->data, len);
1459 ppdu_info = ath11k_dp_htt_get_ppdu_desc(ar, ppdu_id);
1465 ppdu_info->ppdu_id = ppdu_id;
1466 ret = ath11k_dp_htt_tlv_iter(ab, msg->data, len,
1467 ath11k_htt_tlv_ppdu_stats_parse,
1470 ath11k_warn(ab, "Failed to parse tlv %d\n", ret);
1480 static void ath11k_htt_pktlog(struct ath11k_base *ab, struct sk_buff *skb)
1482 struct htt_pktlog_msg *data = (struct htt_pktlog_msg *)skb->data;
1483 struct ath_pktlog_hdr *hdr = (struct ath_pktlog_hdr *)data;
1487 pdev_id = FIELD_GET(HTT_T2H_PPDU_STATS_INFO_PDEV_ID, data->hdr);
1488 ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
1490 ath11k_warn(ab, "invalid pdev id %d on htt pktlog\n", pdev_id);
1494 trace_ath11k_htt_pktlog(ar, data->payload, hdr->size);
1497 static void ath11k_htt_backpressure_event_handler(struct ath11k_base *ab,
1498 struct sk_buff *skb)
1500 u32 *data = (u32 *)skb->data;
1501 u8 pdev_id, ring_type, ring_id;
1503 u32 backpressure_time;
1505 pdev_id = FIELD_GET(HTT_BACKPRESSURE_EVENT_PDEV_ID_M, *data);
1506 ring_type = FIELD_GET(HTT_BACKPRESSURE_EVENT_RING_TYPE_M, *data);
1507 ring_id = FIELD_GET(HTT_BACKPRESSURE_EVENT_RING_ID_M, *data);
1510 hp = FIELD_GET(HTT_BACKPRESSURE_EVENT_HP_M, *data);
1511 tp = FIELD_GET(HTT_BACKPRESSURE_EVENT_TP_M, *data);
1514 backpressure_time = *data;
1516 ath11k_dbg(ab, ATH11K_DBG_DP_HTT, "htt backpressure event, pdev %d, ring type %d,ring id %d, hp %d tp %d, backpressure time %d\n",
1517 pdev_id, ring_type, ring_id, hp, tp, backpressure_time);
1520 void ath11k_dp_htt_htc_t2h_msg_handler(struct ath11k_base *ab,
1521 struct sk_buff *skb)
1523 struct ath11k_dp *dp = &ab->dp;
1524 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data;
1525 enum htt_t2h_msg_type type = FIELD_GET(HTT_T2H_MSG_TYPE, *(u32 *)resp);
1528 u8 mac_addr[ETH_ALEN];
1532 ath11k_dbg(ab, ATH11K_DBG_DP_HTT, "dp_htt rx msg type :0x%0x\n", type);
1535 case HTT_T2H_MSG_TYPE_VERSION_CONF:
1536 dp->htt_tgt_ver_major = FIELD_GET(HTT_T2H_VERSION_CONF_MAJOR,
1537 resp->version_msg.version);
1538 dp->htt_tgt_ver_minor = FIELD_GET(HTT_T2H_VERSION_CONF_MINOR,
1539 resp->version_msg.version);
1540 complete(&dp->htt_tgt_version_received);
1542 case HTT_T2H_MSG_TYPE_PEER_MAP:
1543 vdev_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_VDEV_ID,
1544 resp->peer_map_ev.info);
1545 peer_id = FIELD_GET(HTT_T2H_PEER_MAP_INFO_PEER_ID,
1546 resp->peer_map_ev.info);
1547 peer_mac_h16 = FIELD_GET(HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16,
1548 resp->peer_map_ev.info1);
1549 ath11k_dp_get_mac_addr(resp->peer_map_ev.mac_addr_l32,
1550 peer_mac_h16, mac_addr);
1551 ast_hash = FIELD_GET(HTT_T2H_PEER_MAP_INFO2_AST_HASH_VAL,
1552 resp->peer_map_ev.info2);
1553 ath11k_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash);
1555 case HTT_T2H_MSG_TYPE_PEER_UNMAP:
1556 peer_id = FIELD_GET(HTT_T2H_PEER_UNMAP_INFO_PEER_ID,
1557 resp->peer_unmap_ev.info);
1558 ath11k_peer_unmap_event(ab, peer_id);
1560 case HTT_T2H_MSG_TYPE_PPDU_STATS_IND:
1561 ath11k_htt_pull_ppdu_stats(ab, skb);
1563 case HTT_T2H_MSG_TYPE_EXT_STATS_CONF:
1564 ath11k_dbg_htt_ext_stats_handler(ab, skb);
1566 case HTT_T2H_MSG_TYPE_PKTLOG:
1567 ath11k_htt_pktlog(ab, skb);
1569 case HTT_T2H_MSG_TYPE_BKPRESSURE_EVENT_IND:
1570 ath11k_htt_backpressure_event_handler(ab, skb);
1573 ath11k_warn(ab, "htt event %d not handled\n", type);
1577 dev_kfree_skb_any(skb);
1580 static int ath11k_dp_rx_msdu_coalesce(struct ath11k *ar,
1581 struct sk_buff_head *msdu_list,
1582 struct sk_buff *first, struct sk_buff *last,
1583 u8 l3pad_bytes, int msdu_len)
1585 struct sk_buff *skb;
1586 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(first);
1587 int buf_first_hdr_len, buf_first_len;
1588 struct hal_rx_desc *ldesc;
1593 /* As the msdu is spread across multiple rx buffers,
1594 * find the offset to the start of msdu for computing
1595 * the length of the msdu in the first buffer.
1597 buf_first_hdr_len = HAL_RX_DESC_SIZE + l3pad_bytes;
1598 buf_first_len = DP_RX_BUFFER_SIZE - buf_first_hdr_len;
1600 if (WARN_ON_ONCE(msdu_len <= buf_first_len)) {
1601 skb_put(first, buf_first_hdr_len + msdu_len);
1602 skb_pull(first, buf_first_hdr_len);
1606 ldesc = (struct hal_rx_desc *)last->data;
1607 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(ldesc);
1608 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(ldesc);
1610 /* MSDU spans over multiple buffers because the length of the MSDU
1611 * exceeds DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE. So assume the data
1612 * in the first buf is of length DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE.
1614 skb_put(first, DP_RX_BUFFER_SIZE);
1615 skb_pull(first, buf_first_hdr_len);
1617 /* When an MSDU spread over multiple buffers attention, MSDU_END and
1618 * MPDU_END tlvs are valid only in the last buffer. Copy those tlvs.
1620 ath11k_dp_rx_desc_end_tlv_copy(rxcb->rx_desc, ldesc);
1622 space_extra = msdu_len - (buf_first_len + skb_tailroom(first));
1623 if (space_extra > 0 &&
1624 (pskb_expand_head(first, 0, space_extra, GFP_ATOMIC) < 0)) {
1625 /* Free up all buffers of the MSDU */
1626 while ((skb = __skb_dequeue(msdu_list)) != NULL) {
1627 rxcb = ATH11K_SKB_RXCB(skb);
1628 if (!rxcb->is_continuation) {
1629 dev_kfree_skb_any(skb);
1632 dev_kfree_skb_any(skb);
1637 rem_len = msdu_len - buf_first_len;
1638 while ((skb = __skb_dequeue(msdu_list)) != NULL && rem_len > 0) {
1639 rxcb = ATH11K_SKB_RXCB(skb);
1640 if (rxcb->is_continuation)
1641 buf_len = DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE;
1645 if (buf_len > (DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE)) {
1647 dev_kfree_skb_any(skb);
1651 skb_put(skb, buf_len + HAL_RX_DESC_SIZE);
1652 skb_pull(skb, HAL_RX_DESC_SIZE);
1653 skb_copy_from_linear_data(skb, skb_put(first, buf_len),
1655 dev_kfree_skb_any(skb);
1658 if (!rxcb->is_continuation)
1665 static struct sk_buff *ath11k_dp_rx_get_msdu_last_buf(struct sk_buff_head *msdu_list,
1666 struct sk_buff *first)
1668 struct sk_buff *skb;
1669 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(first);
1671 if (!rxcb->is_continuation)
1674 skb_queue_walk(msdu_list, skb) {
1675 rxcb = ATH11K_SKB_RXCB(skb);
1676 if (!rxcb->is_continuation)
1683 static void ath11k_dp_rx_h_csum_offload(struct sk_buff *msdu)
1685 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1686 bool ip_csum_fail, l4_csum_fail;
1688 ip_csum_fail = ath11k_dp_rx_h_attn_ip_cksum_fail(rxcb->rx_desc);
1689 l4_csum_fail = ath11k_dp_rx_h_attn_l4_cksum_fail(rxcb->rx_desc);
1691 msdu->ip_summed = (ip_csum_fail || l4_csum_fail) ?
1692 CHECKSUM_NONE : CHECKSUM_UNNECESSARY;
1695 static int ath11k_dp_rx_crypto_mic_len(struct ath11k *ar,
1696 enum hal_encrypt_type enctype)
1699 case HAL_ENCRYPT_TYPE_OPEN:
1700 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1701 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1703 case HAL_ENCRYPT_TYPE_CCMP_128:
1704 return IEEE80211_CCMP_MIC_LEN;
1705 case HAL_ENCRYPT_TYPE_CCMP_256:
1706 return IEEE80211_CCMP_256_MIC_LEN;
1707 case HAL_ENCRYPT_TYPE_GCMP_128:
1708 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1709 return IEEE80211_GCMP_MIC_LEN;
1710 case HAL_ENCRYPT_TYPE_WEP_40:
1711 case HAL_ENCRYPT_TYPE_WEP_104:
1712 case HAL_ENCRYPT_TYPE_WEP_128:
1713 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1714 case HAL_ENCRYPT_TYPE_WAPI:
1718 ath11k_warn(ar->ab, "unsupported encryption type %d for mic len\n", enctype);
1722 static int ath11k_dp_rx_crypto_param_len(struct ath11k *ar,
1723 enum hal_encrypt_type enctype)
1726 case HAL_ENCRYPT_TYPE_OPEN:
1728 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1729 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1730 return IEEE80211_TKIP_IV_LEN;
1731 case HAL_ENCRYPT_TYPE_CCMP_128:
1732 return IEEE80211_CCMP_HDR_LEN;
1733 case HAL_ENCRYPT_TYPE_CCMP_256:
1734 return IEEE80211_CCMP_256_HDR_LEN;
1735 case HAL_ENCRYPT_TYPE_GCMP_128:
1736 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1737 return IEEE80211_GCMP_HDR_LEN;
1738 case HAL_ENCRYPT_TYPE_WEP_40:
1739 case HAL_ENCRYPT_TYPE_WEP_104:
1740 case HAL_ENCRYPT_TYPE_WEP_128:
1741 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1742 case HAL_ENCRYPT_TYPE_WAPI:
1746 ath11k_warn(ar->ab, "unsupported encryption type %d\n", enctype);
1750 static int ath11k_dp_rx_crypto_icv_len(struct ath11k *ar,
1751 enum hal_encrypt_type enctype)
1754 case HAL_ENCRYPT_TYPE_OPEN:
1755 case HAL_ENCRYPT_TYPE_CCMP_128:
1756 case HAL_ENCRYPT_TYPE_CCMP_256:
1757 case HAL_ENCRYPT_TYPE_GCMP_128:
1758 case HAL_ENCRYPT_TYPE_AES_GCMP_256:
1760 case HAL_ENCRYPT_TYPE_TKIP_NO_MIC:
1761 case HAL_ENCRYPT_TYPE_TKIP_MIC:
1762 return IEEE80211_TKIP_ICV_LEN;
1763 case HAL_ENCRYPT_TYPE_WEP_40:
1764 case HAL_ENCRYPT_TYPE_WEP_104:
1765 case HAL_ENCRYPT_TYPE_WEP_128:
1766 case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4:
1767 case HAL_ENCRYPT_TYPE_WAPI:
1771 ath11k_warn(ar->ab, "unsupported encryption type %d\n", enctype);
1775 static void ath11k_dp_rx_h_undecap_nwifi(struct ath11k *ar,
1776 struct sk_buff *msdu,
1778 enum hal_encrypt_type enctype,
1779 struct ieee80211_rx_status *status)
1781 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1782 u8 decap_hdr[DP_MAX_NWIFI_HDR_LEN];
1783 struct ieee80211_hdr *hdr;
1790 /* copy SA & DA and pull decapped header */
1791 hdr = (struct ieee80211_hdr *)msdu->data;
1792 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1793 ether_addr_copy(da, ieee80211_get_DA(hdr));
1794 ether_addr_copy(sa, ieee80211_get_SA(hdr));
1795 skb_pull(msdu, ieee80211_hdrlen(hdr->frame_control));
1797 if (rxcb->is_first_msdu) {
1798 /* original 802.11 header is valid for the first msdu
1799 * hence we can reuse the same header
1801 hdr = (struct ieee80211_hdr *)first_hdr;
1802 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1804 /* Each A-MSDU subframe will be reported as a separate MSDU,
1805 * so strip the A-MSDU bit from QoS Ctl.
1807 if (ieee80211_is_data_qos(hdr->frame_control)) {
1808 qos = ieee80211_get_qos_ctl(hdr);
1809 qos[0] &= ~IEEE80211_QOS_CTL_A_MSDU_PRESENT;
1812 /* Rebuild qos header if this is a middle/last msdu */
1813 hdr->frame_control |= __cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1815 /* Reset the order bit as the HT_Control header is stripped */
1816 hdr->frame_control &= ~(__cpu_to_le16(IEEE80211_FCTL_ORDER));
1818 qos_ctl = rxcb->tid;
1820 if (ath11k_dp_rx_h_msdu_start_mesh_ctl_present(rxcb->rx_desc))
1821 qos_ctl |= IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT;
1823 /* TODO Add other QoS ctl fields when required */
1825 /* copy decap header before overwriting for reuse below */
1826 memcpy(decap_hdr, (uint8_t *)hdr, hdr_len);
1829 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
1830 memcpy(skb_push(msdu,
1831 ath11k_dp_rx_crypto_param_len(ar, enctype)),
1832 (void *)hdr + hdr_len,
1833 ath11k_dp_rx_crypto_param_len(ar, enctype));
1836 if (!rxcb->is_first_msdu) {
1837 memcpy(skb_push(msdu,
1838 IEEE80211_QOS_CTL_LEN), &qos_ctl,
1839 IEEE80211_QOS_CTL_LEN);
1840 memcpy(skb_push(msdu, hdr_len), decap_hdr, hdr_len);
1844 memcpy(skb_push(msdu, hdr_len), hdr, hdr_len);
1846 /* original 802.11 header has a different DA and in
1847 * case of 4addr it may also have different SA
1849 hdr = (struct ieee80211_hdr *)msdu->data;
1850 ether_addr_copy(ieee80211_get_DA(hdr), da);
1851 ether_addr_copy(ieee80211_get_SA(hdr), sa);
1854 static void ath11k_dp_rx_h_undecap_raw(struct ath11k *ar, struct sk_buff *msdu,
1855 enum hal_encrypt_type enctype,
1856 struct ieee80211_rx_status *status,
1859 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1860 struct ieee80211_hdr *hdr;
1864 if (!rxcb->is_first_msdu ||
1865 !(rxcb->is_first_msdu && rxcb->is_last_msdu)) {
1870 skb_trim(msdu, msdu->len - FCS_LEN);
1875 hdr = (void *)msdu->data;
1878 if (status->flag & RX_FLAG_IV_STRIPPED) {
1879 skb_trim(msdu, msdu->len -
1880 ath11k_dp_rx_crypto_mic_len(ar, enctype));
1882 skb_trim(msdu, msdu->len -
1883 ath11k_dp_rx_crypto_icv_len(ar, enctype));
1886 if (status->flag & RX_FLAG_MIC_STRIPPED)
1887 skb_trim(msdu, msdu->len -
1888 ath11k_dp_rx_crypto_mic_len(ar, enctype));
1891 if (status->flag & RX_FLAG_ICV_STRIPPED)
1892 skb_trim(msdu, msdu->len -
1893 ath11k_dp_rx_crypto_icv_len(ar, enctype));
1897 if ((status->flag & RX_FLAG_MMIC_STRIPPED) &&
1898 !ieee80211_has_morefrags(hdr->frame_control) &&
1899 enctype == HAL_ENCRYPT_TYPE_TKIP_MIC)
1900 skb_trim(msdu, msdu->len - IEEE80211_CCMP_MIC_LEN);
1903 if (status->flag & RX_FLAG_IV_STRIPPED) {
1904 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1905 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
1907 memmove((void *)msdu->data + crypto_len,
1908 (void *)msdu->data, hdr_len);
1909 skb_pull(msdu, crypto_len);
1913 static void *ath11k_dp_rx_h_find_rfc1042(struct ath11k *ar,
1914 struct sk_buff *msdu,
1915 enum hal_encrypt_type enctype)
1917 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
1918 struct ieee80211_hdr *hdr;
1919 size_t hdr_len, crypto_len;
1923 is_amsdu = !(rxcb->is_first_msdu && rxcb->is_last_msdu);
1924 hdr = (struct ieee80211_hdr *)ath11k_dp_rx_h_80211_hdr(rxcb->rx_desc);
1927 if (rxcb->is_first_msdu) {
1928 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1929 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
1931 rfc1042 += hdr_len + crypto_len;
1935 rfc1042 += sizeof(struct ath11k_dp_amsdu_subframe_hdr);
1940 static void ath11k_dp_rx_h_undecap_eth(struct ath11k *ar,
1941 struct sk_buff *msdu,
1943 enum hal_encrypt_type enctype,
1944 struct ieee80211_rx_status *status)
1946 struct ieee80211_hdr *hdr;
1953 rfc1042 = ath11k_dp_rx_h_find_rfc1042(ar, msdu, enctype);
1954 if (WARN_ON_ONCE(!rfc1042))
1957 /* pull decapped header and copy SA & DA */
1958 eth = (struct ethhdr *)msdu->data;
1959 ether_addr_copy(da, eth->h_dest);
1960 ether_addr_copy(sa, eth->h_source);
1961 skb_pull(msdu, sizeof(struct ethhdr));
1963 /* push rfc1042/llc/snap */
1964 memcpy(skb_push(msdu, sizeof(struct ath11k_dp_rfc1042_hdr)), rfc1042,
1965 sizeof(struct ath11k_dp_rfc1042_hdr));
1967 /* push original 802.11 header */
1968 hdr = (struct ieee80211_hdr *)first_hdr;
1969 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1971 if (!(status->flag & RX_FLAG_IV_STRIPPED)) {
1972 memcpy(skb_push(msdu,
1973 ath11k_dp_rx_crypto_param_len(ar, enctype)),
1974 (void *)hdr + hdr_len,
1975 ath11k_dp_rx_crypto_param_len(ar, enctype));
1978 memcpy(skb_push(msdu, hdr_len), hdr, hdr_len);
1980 /* original 802.11 header has a different DA and in
1981 * case of 4addr it may also have different SA
1983 hdr = (struct ieee80211_hdr *)msdu->data;
1984 ether_addr_copy(ieee80211_get_DA(hdr), da);
1985 ether_addr_copy(ieee80211_get_SA(hdr), sa);
1988 static void ath11k_dp_rx_h_undecap(struct ath11k *ar, struct sk_buff *msdu,
1989 struct hal_rx_desc *rx_desc,
1990 enum hal_encrypt_type enctype,
1991 struct ieee80211_rx_status *status,
1997 first_hdr = ath11k_dp_rx_h_80211_hdr(rx_desc);
1998 decap = ath11k_dp_rx_h_msdu_start_decap_type(rx_desc);
2001 case DP_RX_DECAP_TYPE_NATIVE_WIFI:
2002 ath11k_dp_rx_h_undecap_nwifi(ar, msdu, first_hdr,
2005 case DP_RX_DECAP_TYPE_RAW:
2006 ath11k_dp_rx_h_undecap_raw(ar, msdu, enctype, status,
2009 case DP_RX_DECAP_TYPE_ETHERNET2_DIX:
2010 /* TODO undecap support for middle/last msdu's of amsdu */
2011 ath11k_dp_rx_h_undecap_eth(ar, msdu, first_hdr,
2014 case DP_RX_DECAP_TYPE_8023:
2015 /* TODO: Handle undecap for these formats */
2020 static void ath11k_dp_rx_h_mpdu(struct ath11k *ar,
2021 struct sk_buff *msdu,
2022 struct hal_rx_desc *rx_desc,
2023 struct ieee80211_rx_status *rx_status)
2025 bool fill_crypto_hdr, mcast;
2026 enum hal_encrypt_type enctype;
2027 bool is_decrypted = false;
2028 struct ieee80211_hdr *hdr;
2029 struct ath11k_peer *peer;
2032 hdr = (struct ieee80211_hdr *)msdu->data;
2034 /* PN for multicast packets will be checked in mac80211 */
2036 mcast = is_multicast_ether_addr(hdr->addr1);
2037 fill_crypto_hdr = mcast;
2039 is_decrypted = ath11k_dp_rx_h_attn_is_decrypted(rx_desc);
2041 spin_lock_bh(&ar->ab->base_lock);
2042 peer = ath11k_peer_find_by_addr(ar->ab, hdr->addr2);
2045 enctype = peer->sec_type_grp;
2047 enctype = peer->sec_type;
2049 enctype = HAL_ENCRYPT_TYPE_OPEN;
2051 spin_unlock_bh(&ar->ab->base_lock);
2053 err_bitmap = ath11k_dp_rx_h_attn_mpdu_err(rx_desc);
2055 /* Clear per-MPDU flags while leaving per-PPDU flags intact */
2056 rx_status->flag &= ~(RX_FLAG_FAILED_FCS_CRC |
2057 RX_FLAG_MMIC_ERROR |
2059 RX_FLAG_IV_STRIPPED |
2060 RX_FLAG_MMIC_STRIPPED);
2062 if (err_bitmap & DP_RX_MPDU_ERR_FCS)
2063 rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
2064 if (err_bitmap & DP_RX_MPDU_ERR_TKIP_MIC)
2065 rx_status->flag |= RX_FLAG_MMIC_ERROR;
2068 rx_status->flag |= RX_FLAG_DECRYPTED | RX_FLAG_MMIC_STRIPPED;
2070 if (fill_crypto_hdr)
2071 rx_status->flag |= RX_FLAG_MIC_STRIPPED |
2072 RX_FLAG_ICV_STRIPPED;
2074 rx_status->flag |= RX_FLAG_IV_STRIPPED |
2075 RX_FLAG_PN_VALIDATED;
2078 ath11k_dp_rx_h_csum_offload(msdu);
2079 ath11k_dp_rx_h_undecap(ar, msdu, rx_desc,
2080 enctype, rx_status, is_decrypted);
2082 if (!is_decrypted || fill_crypto_hdr)
2085 hdr = (void *)msdu->data;
2086 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_PROTECTED);
2089 static void ath11k_dp_rx_h_rate(struct ath11k *ar, struct hal_rx_desc *rx_desc,
2090 struct ieee80211_rx_status *rx_status)
2092 struct ieee80211_supported_band *sband;
2093 enum rx_msdu_start_pkt_type pkt_type;
2099 pkt_type = ath11k_dp_rx_h_msdu_start_pkt_type(rx_desc);
2100 bw = ath11k_dp_rx_h_msdu_start_rx_bw(rx_desc);
2101 rate_mcs = ath11k_dp_rx_h_msdu_start_rate_mcs(rx_desc);
2102 nss = ath11k_dp_rx_h_msdu_start_nss(rx_desc);
2103 sgi = ath11k_dp_rx_h_msdu_start_sgi(rx_desc);
2106 case RX_MSDU_START_PKT_TYPE_11A:
2107 case RX_MSDU_START_PKT_TYPE_11B:
2108 is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B);
2109 sband = &ar->mac.sbands[rx_status->band];
2110 rx_status->rate_idx = ath11k_mac_hw_rate_to_idx(sband, rate_mcs,
2113 case RX_MSDU_START_PKT_TYPE_11N:
2114 rx_status->encoding = RX_ENC_HT;
2115 if (rate_mcs > ATH11K_HT_MCS_MAX) {
2117 "Received with invalid mcs in HT mode %d\n",
2121 rx_status->rate_idx = rate_mcs + (8 * (nss - 1));
2123 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
2124 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2126 case RX_MSDU_START_PKT_TYPE_11AC:
2127 rx_status->encoding = RX_ENC_VHT;
2128 rx_status->rate_idx = rate_mcs;
2129 if (rate_mcs > ATH11K_VHT_MCS_MAX) {
2131 "Received with invalid mcs in VHT mode %d\n",
2135 rx_status->nss = nss;
2137 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI;
2138 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2140 case RX_MSDU_START_PKT_TYPE_11AX:
2141 rx_status->rate_idx = rate_mcs;
2142 if (rate_mcs > ATH11K_HE_MCS_MAX) {
2144 "Received with invalid mcs in HE mode %d\n",
2148 rx_status->encoding = RX_ENC_HE;
2149 rx_status->nss = nss;
2150 rx_status->he_gi = ath11k_he_gi_to_nl80211_he_gi(sgi);
2151 rx_status->bw = ath11k_mac_bw_to_mac80211_bw(bw);
2156 static void ath11k_dp_rx_h_ppdu(struct ath11k *ar, struct hal_rx_desc *rx_desc,
2157 struct ieee80211_rx_status *rx_status)
2161 rx_status->freq = 0;
2162 rx_status->rate_idx = 0;
2164 rx_status->encoding = RX_ENC_LEGACY;
2165 rx_status->bw = RATE_INFO_BW_20;
2167 rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL;
2169 channel_num = ath11k_dp_rx_h_msdu_start_freq(rx_desc);
2171 if (channel_num >= 1 && channel_num <= 14) {
2172 rx_status->band = NL80211_BAND_2GHZ;
2173 } else if (channel_num >= 36 && channel_num <= 173) {
2174 rx_status->band = NL80211_BAND_5GHZ;
2176 spin_lock_bh(&ar->data_lock);
2177 rx_status->band = ar->rx_channel->band;
2179 ieee80211_frequency_to_channel(ar->rx_channel->center_freq);
2180 spin_unlock_bh(&ar->data_lock);
2181 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "rx_desc: ",
2182 rx_desc, sizeof(struct hal_rx_desc));
2185 rx_status->freq = ieee80211_channel_to_frequency(channel_num,
2188 ath11k_dp_rx_h_rate(ar, rx_desc, rx_status);
2191 static char *ath11k_print_get_tid(struct ieee80211_hdr *hdr, char *out,
2197 if (!ieee80211_is_data_qos(hdr->frame_control))
2200 qc = ieee80211_get_qos_ctl(hdr);
2201 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
2202 snprintf(out, size, "tid %d", tid);
2207 static void ath11k_dp_rx_deliver_msdu(struct ath11k *ar, struct napi_struct *napi,
2208 struct sk_buff *msdu)
2210 static const struct ieee80211_radiotap_he known = {
2211 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
2212 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN),
2213 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN),
2215 struct ieee80211_rx_status *status;
2216 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data;
2217 struct ieee80211_radiotap_he *he = NULL;
2220 status = IEEE80211_SKB_RXCB(msdu);
2221 if (status->encoding == RX_ENC_HE) {
2222 he = skb_push(msdu, sizeof(known));
2223 memcpy(he, &known, sizeof(known));
2224 status->flag |= RX_FLAG_RADIOTAP_HE;
2227 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
2228 "rx skb %pK len %u peer %pM %s %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",
2231 ieee80211_get_SA(hdr),
2232 ath11k_print_get_tid(hdr, tid, sizeof(tid)),
2233 is_multicast_ether_addr(ieee80211_get_DA(hdr)) ?
2235 (__le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4,
2236 (status->encoding == RX_ENC_LEGACY) ? "legacy" : "",
2237 (status->encoding == RX_ENC_HT) ? "ht" : "",
2238 (status->encoding == RX_ENC_VHT) ? "vht" : "",
2239 (status->encoding == RX_ENC_HE) ? "he" : "",
2240 (status->bw == RATE_INFO_BW_40) ? "40" : "",
2241 (status->bw == RATE_INFO_BW_80) ? "80" : "",
2242 (status->bw == RATE_INFO_BW_160) ? "160" : "",
2243 status->enc_flags & RX_ENC_FLAG_SHORT_GI ? "sgi " : "",
2247 status->band, status->flag,
2248 !!(status->flag & RX_FLAG_FAILED_FCS_CRC),
2249 !!(status->flag & RX_FLAG_MMIC_ERROR),
2250 !!(status->flag & RX_FLAG_AMSDU_MORE));
2252 /* TODO: trace rx packet */
2254 ieee80211_rx_napi(ar->hw, NULL, msdu, napi);
2257 static int ath11k_dp_rx_process_msdu(struct ath11k *ar,
2258 struct sk_buff *msdu,
2259 struct sk_buff_head *msdu_list)
2261 struct hal_rx_desc *rx_desc, *lrx_desc;
2262 struct ieee80211_rx_status rx_status = {0};
2263 struct ieee80211_rx_status *status;
2264 struct ath11k_skb_rxcb *rxcb;
2265 struct ieee80211_hdr *hdr;
2266 struct sk_buff *last_buf;
2272 last_buf = ath11k_dp_rx_get_msdu_last_buf(msdu_list, msdu);
2275 "No valid Rx buffer to access Atten/MSDU_END/MPDU_END tlvs\n");
2280 rx_desc = (struct hal_rx_desc *)msdu->data;
2281 lrx_desc = (struct hal_rx_desc *)last_buf->data;
2282 if (!ath11k_dp_rx_h_attn_msdu_done(lrx_desc)) {
2283 ath11k_warn(ar->ab, "msdu_done bit in attention is not set\n");
2288 rxcb = ATH11K_SKB_RXCB(msdu);
2289 rxcb->rx_desc = rx_desc;
2290 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(rx_desc);
2291 l3_pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(lrx_desc);
2293 if (rxcb->is_frag) {
2294 skb_pull(msdu, HAL_RX_DESC_SIZE);
2295 } else if (!rxcb->is_continuation) {
2296 if ((msdu_len + HAL_RX_DESC_SIZE) > DP_RX_BUFFER_SIZE) {
2297 hdr_status = ath11k_dp_rx_h_80211_hdr(rx_desc);
2299 ath11k_warn(ar->ab, "invalid msdu len %u\n", msdu_len);
2300 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", hdr_status,
2301 sizeof(struct ieee80211_hdr));
2302 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", rx_desc,
2303 sizeof(struct hal_rx_desc));
2306 skb_put(msdu, HAL_RX_DESC_SIZE + l3_pad_bytes + msdu_len);
2307 skb_pull(msdu, HAL_RX_DESC_SIZE + l3_pad_bytes);
2309 ret = ath11k_dp_rx_msdu_coalesce(ar, msdu_list,
2311 l3_pad_bytes, msdu_len);
2314 "failed to coalesce msdu rx buffer%d\n", ret);
2319 hdr = (struct ieee80211_hdr *)msdu->data;
2321 /* Process only data frames */
2322 if (!ieee80211_is_data(hdr->frame_control))
2325 ath11k_dp_rx_h_ppdu(ar, rx_desc, &rx_status);
2326 ath11k_dp_rx_h_mpdu(ar, msdu, rx_desc, &rx_status);
2328 rx_status.flag |= RX_FLAG_SKIP_MONITOR | RX_FLAG_DUP_VALIDATED;
2330 status = IEEE80211_SKB_RXCB(msdu);
2331 *status = rx_status;
2338 static void ath11k_dp_rx_process_received_packets(struct ath11k_base *ab,
2339 struct napi_struct *napi,
2340 struct sk_buff_head *msdu_list,
2341 int *quota, int ring_id)
2343 struct ath11k_skb_rxcb *rxcb;
2344 struct sk_buff *msdu;
2349 if (skb_queue_empty(msdu_list))
2354 while (*quota && (msdu = __skb_dequeue(msdu_list))) {
2355 rxcb = ATH11K_SKB_RXCB(msdu);
2356 mac_id = rxcb->mac_id;
2357 ar = ab->pdevs[mac_id].ar;
2358 if (!rcu_dereference(ab->pdevs_active[mac_id])) {
2359 dev_kfree_skb_any(msdu);
2363 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
2364 dev_kfree_skb_any(msdu);
2368 ret = ath11k_dp_rx_process_msdu(ar, msdu, msdu_list);
2370 ath11k_dbg(ab, ATH11K_DBG_DATA,
2371 "Unable to process msdu %d", ret);
2372 dev_kfree_skb_any(msdu);
2376 ath11k_dp_rx_deliver_msdu(ar, napi, msdu);
2383 int ath11k_dp_process_rx(struct ath11k_base *ab, int ring_id,
2384 struct napi_struct *napi, int budget)
2386 struct ath11k_dp *dp = &ab->dp;
2387 struct dp_rxdma_ring *rx_ring;
2388 int num_buffs_reaped[MAX_RADIOS] = {0};
2389 struct sk_buff_head msdu_list;
2390 struct ath11k_skb_rxcb *rxcb;
2391 int total_msdu_reaped = 0;
2392 struct hal_srng *srng;
2393 struct sk_buff *msdu;
2401 __skb_queue_head_init(&msdu_list);
2403 srng = &ab->hal.srng_list[dp->reo_dst_ring[ring_id].ring_id];
2405 spin_lock_bh(&srng->lock);
2407 ath11k_hal_srng_access_begin(ab, srng);
2410 while ((rx_desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
2411 struct hal_reo_dest_ring *desc = (struct hal_reo_dest_ring *)rx_desc;
2412 enum hal_reo_dest_ring_push_reason push_reason;
2415 cookie = FIELD_GET(BUFFER_ADDR_INFO1_SW_COOKIE,
2416 desc->buf_addr_info.info1);
2417 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
2419 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID, cookie);
2421 ar = ab->pdevs[mac_id].ar;
2422 rx_ring = &ar->dp.rx_refill_buf_ring;
2423 spin_lock_bh(&rx_ring->idr_lock);
2424 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
2426 ath11k_warn(ab, "frame rx with invalid buf_id %d\n",
2428 spin_unlock_bh(&rx_ring->idr_lock);
2432 idr_remove(&rx_ring->bufs_idr, buf_id);
2433 spin_unlock_bh(&rx_ring->idr_lock);
2435 rxcb = ATH11K_SKB_RXCB(msdu);
2436 dma_unmap_single(ab->dev, rxcb->paddr,
2437 msdu->len + skb_tailroom(msdu),
2440 num_buffs_reaped[mac_id]++;
2441 total_msdu_reaped++;
2443 push_reason = FIELD_GET(HAL_REO_DEST_RING_INFO0_PUSH_REASON,
2446 HAL_REO_DEST_RING_PUSH_REASON_ROUTING_INSTRUCTION) {
2447 dev_kfree_skb_any(msdu);
2448 ab->soc_stats.hal_reo_error[dp->reo_dst_ring[ring_id].ring_id]++;
2452 rxcb->is_first_msdu = !!(desc->rx_msdu_info.info0 &
2453 RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU);
2454 rxcb->is_last_msdu = !!(desc->rx_msdu_info.info0 &
2455 RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU);
2456 rxcb->is_continuation = !!(desc->rx_msdu_info.info0 &
2457 RX_MSDU_DESC_INFO0_MSDU_CONTINUATION);
2458 rxcb->mac_id = mac_id;
2459 rxcb->tid = FIELD_GET(HAL_REO_DEST_RING_INFO0_RX_QUEUE_NUM,
2462 __skb_queue_tail(&msdu_list, msdu);
2464 if (total_msdu_reaped >= quota && !rxcb->is_continuation) {
2470 /* Hw might have updated the head pointer after we cached it.
2471 * In this case, even though there are entries in the ring we'll
2472 * get rx_desc NULL. Give the read another try with updated cached
2473 * head pointer so that we can reap complete MPDU in the current
2476 if (!done && ath11k_hal_srng_dst_num_free(ab, srng, true)) {
2477 ath11k_hal_srng_access_end(ab, srng);
2481 ath11k_hal_srng_access_end(ab, srng);
2483 spin_unlock_bh(&srng->lock);
2485 if (!total_msdu_reaped)
2488 for (i = 0; i < ab->num_radios; i++) {
2489 if (!num_buffs_reaped[i])
2492 ar = ab->pdevs[i].ar;
2493 rx_ring = &ar->dp.rx_refill_buf_ring;
2495 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, num_buffs_reaped[i],
2496 HAL_RX_BUF_RBM_SW3_BM, GFP_ATOMIC);
2499 ath11k_dp_rx_process_received_packets(ab, napi, &msdu_list,
2503 return budget - quota;
2506 static void ath11k_dp_rx_update_peer_stats(struct ath11k_sta *arsta,
2507 struct hal_rx_mon_ppdu_info *ppdu_info)
2509 struct ath11k_rx_peer_stats *rx_stats = arsta->rx_stats;
2515 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count +
2516 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count;
2518 rx_stats->num_msdu += num_msdu;
2519 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count +
2520 ppdu_info->tcp_ack_msdu_count;
2521 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count;
2522 rx_stats->other_msdu_count += ppdu_info->other_msdu_count;
2524 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A ||
2525 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) {
2527 ppdu_info->mcs = HAL_RX_MAX_MCS;
2528 ppdu_info->tid = IEEE80211_NUM_TIDS;
2531 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS)
2532 rx_stats->nss_count[ppdu_info->nss - 1] += num_msdu;
2534 if (ppdu_info->mcs <= HAL_RX_MAX_MCS)
2535 rx_stats->mcs_count[ppdu_info->mcs] += num_msdu;
2537 if (ppdu_info->gi < HAL_RX_GI_MAX)
2538 rx_stats->gi_count[ppdu_info->gi] += num_msdu;
2540 if (ppdu_info->bw < HAL_RX_BW_MAX)
2541 rx_stats->bw_count[ppdu_info->bw] += num_msdu;
2543 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX)
2544 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu;
2546 if (ppdu_info->tid <= IEEE80211_NUM_TIDS)
2547 rx_stats->tid_count[ppdu_info->tid] += num_msdu;
2549 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX)
2550 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu;
2552 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX)
2553 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu;
2555 if (ppdu_info->is_stbc)
2556 rx_stats->stbc_count += num_msdu;
2558 if (ppdu_info->beamformed)
2559 rx_stats->beamformed_count += num_msdu;
2561 if (ppdu_info->num_mpdu_fcs_ok > 1)
2562 rx_stats->ampdu_msdu_count += num_msdu;
2564 rx_stats->non_ampdu_msdu_count += num_msdu;
2566 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok;
2567 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err;
2568 rx_stats->dcm_count += ppdu_info->dcm;
2569 rx_stats->ru_alloc_cnt[ppdu_info->ru_alloc] += num_msdu;
2571 arsta->rssi_comb = ppdu_info->rssi_comb;
2572 rx_stats->rx_duration += ppdu_info->rx_duration;
2573 arsta->rx_duration = rx_stats->rx_duration;
2576 static struct sk_buff *ath11k_dp_rx_alloc_mon_status_buf(struct ath11k_base *ab,
2577 struct dp_rxdma_ring *rx_ring,
2578 int *buf_id, gfp_t gfp)
2580 struct sk_buff *skb;
2583 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE +
2584 DP_RX_BUFFER_ALIGN_SIZE);
2587 goto fail_alloc_skb;
2589 if (!IS_ALIGNED((unsigned long)skb->data,
2590 DP_RX_BUFFER_ALIGN_SIZE)) {
2591 skb_pull(skb, PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) -
2595 paddr = dma_map_single(ab->dev, skb->data,
2596 skb->len + skb_tailroom(skb),
2598 if (unlikely(dma_mapping_error(ab->dev, paddr)))
2601 spin_lock_bh(&rx_ring->idr_lock);
2602 *buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0,
2603 rx_ring->bufs_max, gfp);
2604 spin_unlock_bh(&rx_ring->idr_lock);
2606 goto fail_dma_unmap;
2608 ATH11K_SKB_RXCB(skb)->paddr = paddr;
2612 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
2615 dev_kfree_skb_any(skb);
2620 int ath11k_dp_rx_mon_status_bufs_replenish(struct ath11k_base *ab, int mac_id,
2621 struct dp_rxdma_ring *rx_ring,
2623 enum hal_rx_buf_return_buf_manager mgr,
2626 struct hal_srng *srng;
2628 struct sk_buff *skb;
2635 req_entries = min(req_entries, rx_ring->bufs_max);
2637 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
2639 spin_lock_bh(&srng->lock);
2641 ath11k_hal_srng_access_begin(ab, srng);
2643 num_free = ath11k_hal_srng_src_num_free(ab, srng, true);
2645 req_entries = min(num_free, req_entries);
2646 num_remain = req_entries;
2648 while (num_remain > 0) {
2649 skb = ath11k_dp_rx_alloc_mon_status_buf(ab, rx_ring,
2653 paddr = ATH11K_SKB_RXCB(skb)->paddr;
2655 desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
2659 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
2660 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
2664 ath11k_hal_rx_buf_addr_info_set(desc, paddr, cookie, mgr);
2667 ath11k_hal_srng_access_end(ab, srng);
2669 spin_unlock_bh(&srng->lock);
2671 return req_entries - num_remain;
2674 spin_lock_bh(&rx_ring->idr_lock);
2675 idr_remove(&rx_ring->bufs_idr, buf_id);
2676 spin_unlock_bh(&rx_ring->idr_lock);
2677 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb),
2679 dev_kfree_skb_any(skb);
2680 ath11k_hal_srng_access_end(ab, srng);
2681 spin_unlock_bh(&srng->lock);
2683 return req_entries - num_remain;
2686 static int ath11k_dp_rx_reap_mon_status_ring(struct ath11k_base *ab, int mac_id,
2687 int *budget, struct sk_buff_head *skb_list)
2689 struct ath11k *ar = ab->pdevs[mac_id].ar;
2690 struct ath11k_pdev_dp *dp = &ar->dp;
2691 struct dp_rxdma_ring *rx_ring = &dp->rx_mon_status_refill_ring;
2692 struct hal_srng *srng;
2693 void *rx_mon_status_desc;
2694 struct sk_buff *skb;
2695 struct ath11k_skb_rxcb *rxcb;
2696 struct hal_tlv_hdr *tlv;
2701 int num_buffs_reaped = 0;
2703 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id];
2705 spin_lock_bh(&srng->lock);
2707 ath11k_hal_srng_access_begin(ab, srng);
2710 rx_mon_status_desc =
2711 ath11k_hal_srng_src_peek(ab, srng);
2712 if (!rx_mon_status_desc)
2715 ath11k_hal_rx_buf_addr_info_get(rx_mon_status_desc, &paddr,
2718 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID, cookie);
2720 spin_lock_bh(&rx_ring->idr_lock);
2721 skb = idr_find(&rx_ring->bufs_idr, buf_id);
2723 ath11k_warn(ab, "rx monitor status with invalid buf_id %d\n",
2725 spin_unlock_bh(&rx_ring->idr_lock);
2729 idr_remove(&rx_ring->bufs_idr, buf_id);
2730 spin_unlock_bh(&rx_ring->idr_lock);
2732 rxcb = ATH11K_SKB_RXCB(skb);
2734 dma_sync_single_for_cpu(ab->dev, rxcb->paddr,
2735 skb->len + skb_tailroom(skb),
2738 dma_unmap_single(ab->dev, rxcb->paddr,
2739 skb->len + skb_tailroom(skb),
2742 tlv = (struct hal_tlv_hdr *)skb->data;
2743 if (FIELD_GET(HAL_TLV_HDR_TAG, tlv->tl) !=
2744 HAL_RX_STATUS_BUFFER_DONE) {
2745 ath11k_hal_srng_src_get_next_entry(ab, srng);
2749 __skb_queue_tail(skb_list, skb);
2752 skb = ath11k_dp_rx_alloc_mon_status_buf(ab, rx_ring,
2753 &buf_id, GFP_ATOMIC);
2756 ath11k_hal_rx_buf_addr_info_set(rx_mon_status_desc, 0, 0,
2757 HAL_RX_BUF_RBM_SW3_BM);
2761 rxcb = ATH11K_SKB_RXCB(skb);
2763 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, mac_id) |
2764 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
2766 ath11k_hal_rx_buf_addr_info_set(rx_mon_status_desc, rxcb->paddr,
2767 cookie, HAL_RX_BUF_RBM_SW3_BM);
2768 ath11k_hal_srng_src_get_next_entry(ab, srng);
2771 ath11k_hal_srng_access_end(ab, srng);
2772 spin_unlock_bh(&srng->lock);
2774 return num_buffs_reaped;
2777 int ath11k_dp_rx_process_mon_status(struct ath11k_base *ab, int mac_id,
2778 struct napi_struct *napi, int budget)
2780 struct ath11k *ar = ab->pdevs[mac_id].ar;
2781 enum hal_rx_mon_status hal_status;
2782 struct sk_buff *skb;
2783 struct sk_buff_head skb_list;
2784 struct hal_rx_mon_ppdu_info ppdu_info;
2785 struct ath11k_peer *peer;
2786 struct ath11k_sta *arsta;
2787 int num_buffs_reaped = 0;
2789 __skb_queue_head_init(&skb_list);
2791 num_buffs_reaped = ath11k_dp_rx_reap_mon_status_ring(ab, mac_id, &budget,
2793 if (!num_buffs_reaped)
2796 while ((skb = __skb_dequeue(&skb_list))) {
2797 memset(&ppdu_info, 0, sizeof(ppdu_info));
2798 ppdu_info.peer_id = HAL_INVALID_PEERID;
2800 if (ath11k_debug_is_pktlog_rx_stats_enabled(ar))
2801 trace_ath11k_htt_rxdesc(ar, skb->data, DP_RX_BUFFER_SIZE);
2803 hal_status = ath11k_hal_rx_parse_mon_status(ab, &ppdu_info, skb);
2805 if (ppdu_info.peer_id == HAL_INVALID_PEERID ||
2806 hal_status != HAL_RX_MON_STATUS_PPDU_DONE) {
2807 dev_kfree_skb_any(skb);
2812 spin_lock_bh(&ab->base_lock);
2813 peer = ath11k_peer_find_by_id(ab, ppdu_info.peer_id);
2815 if (!peer || !peer->sta) {
2816 ath11k_dbg(ab, ATH11K_DBG_DATA,
2817 "failed to find the peer with peer_id %d\n",
2819 spin_unlock_bh(&ab->base_lock);
2821 dev_kfree_skb_any(skb);
2825 arsta = (struct ath11k_sta *)peer->sta->drv_priv;
2826 ath11k_dp_rx_update_peer_stats(arsta, &ppdu_info);
2828 if (ath11k_debug_is_pktlog_peer_valid(ar, peer->addr))
2829 trace_ath11k_htt_rxdesc(ar, skb->data, DP_RX_BUFFER_SIZE);
2831 spin_unlock_bh(&ab->base_lock);
2834 dev_kfree_skb_any(skb);
2837 return num_buffs_reaped;
2840 static void ath11k_dp_rx_frag_timer(struct timer_list *timer)
2842 struct dp_rx_tid *rx_tid = from_timer(rx_tid, timer, frag_timer);
2844 spin_lock_bh(&rx_tid->ab->base_lock);
2845 if (rx_tid->last_frag_no &&
2846 rx_tid->rx_frag_bitmap == GENMASK(rx_tid->last_frag_no, 0)) {
2847 spin_unlock_bh(&rx_tid->ab->base_lock);
2850 ath11k_dp_rx_frags_cleanup(rx_tid, true);
2851 spin_unlock_bh(&rx_tid->ab->base_lock);
2854 int ath11k_peer_rx_frag_setup(struct ath11k *ar, const u8 *peer_mac, int vdev_id)
2856 struct ath11k_base *ab = ar->ab;
2857 struct crypto_shash *tfm;
2858 struct ath11k_peer *peer;
2859 struct dp_rx_tid *rx_tid;
2862 tfm = crypto_alloc_shash("michael_mic", 0, 0);
2864 return PTR_ERR(tfm);
2866 spin_lock_bh(&ab->base_lock);
2868 peer = ath11k_peer_find(ab, vdev_id, peer_mac);
2870 ath11k_warn(ab, "failed to find the peer to set up fragment info\n");
2871 spin_unlock_bh(&ab->base_lock);
2875 for (i = 0; i <= IEEE80211_NUM_TIDS; i++) {
2876 rx_tid = &peer->rx_tid[i];
2878 timer_setup(&rx_tid->frag_timer, ath11k_dp_rx_frag_timer, 0);
2879 skb_queue_head_init(&rx_tid->rx_frags);
2882 peer->tfm_mmic = tfm;
2883 spin_unlock_bh(&ab->base_lock);
2888 static int ath11k_dp_rx_h_michael_mic(struct crypto_shash *tfm, u8 *key,
2889 struct ieee80211_hdr *hdr, u8 *data,
2890 size_t data_len, u8 *mic)
2892 SHASH_DESC_ON_STACK(desc, tfm);
2893 u8 mic_hdr[16] = {0};
2902 ret = crypto_shash_setkey(tfm, key, 8);
2906 ret = crypto_shash_init(desc);
2910 /* TKIP MIC header */
2911 memcpy(mic_hdr, ieee80211_get_DA(hdr), ETH_ALEN);
2912 memcpy(mic_hdr + ETH_ALEN, ieee80211_get_SA(hdr), ETH_ALEN);
2913 if (ieee80211_is_data_qos(hdr->frame_control))
2914 tid = ieee80211_get_tid(hdr);
2917 ret = crypto_shash_update(desc, mic_hdr, 16);
2920 ret = crypto_shash_update(desc, data, data_len);
2923 ret = crypto_shash_final(desc, mic);
2925 shash_desc_zero(desc);
2929 static int ath11k_dp_rx_h_verify_tkip_mic(struct ath11k *ar, struct ath11k_peer *peer,
2930 struct sk_buff *msdu)
2932 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)msdu->data;
2933 struct ieee80211_rx_status *rxs = IEEE80211_SKB_RXCB(msdu);
2934 struct ieee80211_key_conf *key_conf;
2935 struct ieee80211_hdr *hdr;
2936 u8 mic[IEEE80211_CCMP_MIC_LEN];
2937 int head_len, tail_len, ret;
2943 if (ath11k_dp_rx_h_mpdu_start_enctype(rx_desc) != HAL_ENCRYPT_TYPE_TKIP_MIC)
2946 hdr = (struct ieee80211_hdr *)(msdu->data + HAL_RX_DESC_SIZE);
2947 hdr_len = ieee80211_hdrlen(hdr->frame_control);
2948 head_len = hdr_len + HAL_RX_DESC_SIZE + IEEE80211_TKIP_IV_LEN;
2949 tail_len = IEEE80211_CCMP_MIC_LEN + IEEE80211_TKIP_ICV_LEN + FCS_LEN;
2951 if (!is_multicast_ether_addr(hdr->addr1))
2952 key_idx = peer->ucast_keyidx;
2954 key_idx = peer->mcast_keyidx;
2956 key_conf = peer->keys[key_idx];
2958 data = msdu->data + head_len;
2959 data_len = msdu->len - head_len - tail_len;
2960 key = &key_conf->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
2962 ret = ath11k_dp_rx_h_michael_mic(peer->tfm_mmic, key, hdr, data, data_len, mic);
2963 if (ret || memcmp(mic, data + data_len, IEEE80211_CCMP_MIC_LEN))
2969 (ATH11K_SKB_RXCB(msdu))->is_first_msdu = 1;
2970 (ATH11K_SKB_RXCB(msdu))->is_last_msdu = 1;
2972 rxs->flag |= RX_FLAG_MMIC_ERROR | RX_FLAG_MMIC_STRIPPED |
2973 RX_FLAG_IV_STRIPPED | RX_FLAG_DECRYPTED;
2974 skb_pull(msdu, HAL_RX_DESC_SIZE);
2976 ath11k_dp_rx_h_ppdu(ar, rx_desc, rxs);
2977 ath11k_dp_rx_h_undecap(ar, msdu, rx_desc,
2978 HAL_ENCRYPT_TYPE_TKIP_MIC, rxs, true);
2979 ieee80211_rx(ar->hw, msdu);
2983 static void ath11k_dp_rx_h_undecap_frag(struct ath11k *ar, struct sk_buff *msdu,
2984 enum hal_encrypt_type enctype, u32 flags)
2986 struct ieee80211_hdr *hdr;
2993 hdr = (struct ieee80211_hdr *)(msdu->data + HAL_RX_DESC_SIZE);
2995 if (flags & RX_FLAG_MIC_STRIPPED)
2996 skb_trim(msdu, msdu->len -
2997 ath11k_dp_rx_crypto_mic_len(ar, enctype));
2999 if (flags & RX_FLAG_ICV_STRIPPED)
3000 skb_trim(msdu, msdu->len -
3001 ath11k_dp_rx_crypto_icv_len(ar, enctype));
3003 if (flags & RX_FLAG_IV_STRIPPED) {
3004 hdr_len = ieee80211_hdrlen(hdr->frame_control);
3005 crypto_len = ath11k_dp_rx_crypto_param_len(ar, enctype);
3007 memmove((void *)msdu->data + HAL_RX_DESC_SIZE + crypto_len,
3008 (void *)msdu->data + HAL_RX_DESC_SIZE, hdr_len);
3009 skb_pull(msdu, crypto_len);
3013 static int ath11k_dp_rx_h_defrag(struct ath11k *ar,
3014 struct ath11k_peer *peer,
3015 struct dp_rx_tid *rx_tid,
3016 struct sk_buff **defrag_skb)
3018 struct hal_rx_desc *rx_desc;
3019 struct sk_buff *skb, *first_frag, *last_frag;
3020 struct ieee80211_hdr *hdr;
3021 enum hal_encrypt_type enctype;
3022 bool is_decrypted = false;
3027 first_frag = skb_peek(&rx_tid->rx_frags);
3028 last_frag = skb_peek_tail(&rx_tid->rx_frags);
3030 skb_queue_walk(&rx_tid->rx_frags, skb) {
3032 rx_desc = (struct hal_rx_desc *)skb->data;
3033 hdr = (struct ieee80211_hdr *)(skb->data + HAL_RX_DESC_SIZE);
3035 enctype = ath11k_dp_rx_h_mpdu_start_enctype(rx_desc);
3036 if (enctype != HAL_ENCRYPT_TYPE_OPEN)
3037 is_decrypted = ath11k_dp_rx_h_attn_is_decrypted(rx_desc);
3040 if (skb != first_frag)
3041 flags |= RX_FLAG_IV_STRIPPED;
3042 if (skb != last_frag)
3043 flags |= RX_FLAG_ICV_STRIPPED |
3044 RX_FLAG_MIC_STRIPPED;
3047 /* RX fragments are always raw packets */
3048 if (skb != last_frag)
3049 skb_trim(skb, skb->len - FCS_LEN);
3050 ath11k_dp_rx_h_undecap_frag(ar, skb, enctype, flags);
3052 if (skb != first_frag)
3053 skb_pull(skb, HAL_RX_DESC_SIZE +
3054 ieee80211_hdrlen(hdr->frame_control));
3055 msdu_len += skb->len;
3058 extra_space = msdu_len - (DP_RX_BUFFER_SIZE + skb_tailroom(first_frag));
3059 if (extra_space > 0 &&
3060 (pskb_expand_head(first_frag, 0, extra_space, GFP_ATOMIC) < 0))
3063 __skb_unlink(first_frag, &rx_tid->rx_frags);
3064 while ((skb = __skb_dequeue(&rx_tid->rx_frags))) {
3065 skb_put_data(first_frag, skb->data, skb->len);
3066 dev_kfree_skb_any(skb);
3069 hdr = (struct ieee80211_hdr *)(first_frag->data + HAL_RX_DESC_SIZE);
3070 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
3071 ATH11K_SKB_RXCB(first_frag)->is_frag = 1;
3073 if (ath11k_dp_rx_h_verify_tkip_mic(ar, peer, first_frag))
3076 *defrag_skb = first_frag;
3080 static int ath11k_dp_rx_h_defrag_reo_reinject(struct ath11k *ar, struct dp_rx_tid *rx_tid,
3081 struct sk_buff *defrag_skb)
3083 struct ath11k_base *ab = ar->ab;
3084 struct ath11k_pdev_dp *dp = &ar->dp;
3085 struct dp_rxdma_ring *rx_refill_ring = &dp->rx_refill_buf_ring;
3086 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)defrag_skb->data;
3087 struct hal_reo_entrance_ring *reo_ent_ring;
3088 struct hal_reo_dest_ring *reo_dest_ring;
3089 struct dp_link_desc_bank *link_desc_banks;
3090 struct hal_rx_msdu_link *msdu_link;
3091 struct hal_rx_msdu_details *msdu0;
3092 struct hal_srng *srng;
3094 u32 desc_bank, msdu_info, mpdu_info;
3095 u32 dst_idx, cookie;
3096 u32 *msdu_len_offset;
3099 link_desc_banks = ab->dp.link_desc_banks;
3100 reo_dest_ring = rx_tid->dst_ring_desc;
3102 ath11k_hal_rx_reo_ent_paddr_get(ab, reo_dest_ring, &paddr, &desc_bank);
3103 msdu_link = (struct hal_rx_msdu_link *)(link_desc_banks[desc_bank].vaddr +
3104 (paddr - link_desc_banks[desc_bank].paddr));
3105 msdu0 = &msdu_link->msdu_link[0];
3106 dst_idx = FIELD_GET(RX_MSDU_DESC_INFO0_REO_DEST_IND, msdu0->rx_msdu_info.info0);
3107 memset(msdu0, 0, sizeof(*msdu0));
3109 msdu_info = FIELD_PREP(RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU, 1) |
3110 FIELD_PREP(RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU, 1) |
3111 FIELD_PREP(RX_MSDU_DESC_INFO0_MSDU_CONTINUATION, 0) |
3112 FIELD_PREP(RX_MSDU_DESC_INFO0_MSDU_LENGTH,
3113 defrag_skb->len - HAL_RX_DESC_SIZE) |
3114 FIELD_PREP(RX_MSDU_DESC_INFO0_REO_DEST_IND, dst_idx) |
3115 FIELD_PREP(RX_MSDU_DESC_INFO0_VALID_SA, 1) |
3116 FIELD_PREP(RX_MSDU_DESC_INFO0_VALID_DA, 1);
3117 msdu0->rx_msdu_info.info0 = msdu_info;
3119 /* change msdu len in hal rx desc */
3120 msdu_len_offset = (u32 *)&rx_desc->msdu_start;
3121 *msdu_len_offset &= ~(RX_MSDU_START_INFO1_MSDU_LENGTH);
3122 *msdu_len_offset |= defrag_skb->len - HAL_RX_DESC_SIZE;
3124 paddr = dma_map_single(ab->dev, defrag_skb->data,
3125 defrag_skb->len + skb_tailroom(defrag_skb),
3127 if (dma_mapping_error(ab->dev, paddr))
3130 spin_lock_bh(&rx_refill_ring->idr_lock);
3131 buf_id = idr_alloc(&rx_refill_ring->bufs_idr, defrag_skb, 0,
3132 rx_refill_ring->bufs_max * 3, GFP_ATOMIC);
3133 spin_unlock_bh(&rx_refill_ring->idr_lock);
3139 ATH11K_SKB_RXCB(defrag_skb)->paddr = paddr;
3140 cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, dp->mac_id) |
3141 FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
3143 ath11k_hal_rx_buf_addr_info_set(msdu0, paddr, cookie, HAL_RX_BUF_RBM_SW3_BM);
3145 /* Fill mpdu details into reo entrace ring */
3146 srng = &ab->hal.srng_list[ab->dp.reo_reinject_ring.ring_id];
3148 spin_lock_bh(&srng->lock);
3149 ath11k_hal_srng_access_begin(ab, srng);
3151 reo_ent_ring = (struct hal_reo_entrance_ring *)
3152 ath11k_hal_srng_src_get_next_entry(ab, srng);
3153 if (!reo_ent_ring) {
3154 ath11k_hal_srng_access_end(ab, srng);
3155 spin_unlock_bh(&srng->lock);
3159 memset(reo_ent_ring, 0, sizeof(*reo_ent_ring));
3161 ath11k_hal_rx_reo_ent_paddr_get(ab, reo_dest_ring, &paddr, &desc_bank);
3162 ath11k_hal_rx_buf_addr_info_set(reo_ent_ring, paddr, desc_bank,
3163 HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST);
3165 mpdu_info = FIELD_PREP(RX_MPDU_DESC_INFO0_MSDU_COUNT, 1) |
3166 FIELD_PREP(RX_MPDU_DESC_INFO0_SEQ_NUM, rx_tid->cur_sn) |
3167 FIELD_PREP(RX_MPDU_DESC_INFO0_FRAG_FLAG, 0) |
3168 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_SA, 1) |
3169 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_DA, 1) |
3170 FIELD_PREP(RX_MPDU_DESC_INFO0_RAW_MPDU, 1) |
3171 FIELD_PREP(RX_MPDU_DESC_INFO0_VALID_PN, 1);
3173 reo_ent_ring->rx_mpdu_info.info0 = mpdu_info;
3174 reo_ent_ring->rx_mpdu_info.meta_data = reo_dest_ring->rx_mpdu_info.meta_data;
3175 reo_ent_ring->queue_addr_lo = reo_dest_ring->queue_addr_lo;
3176 reo_ent_ring->info0 = FIELD_PREP(HAL_REO_ENTR_RING_INFO0_QUEUE_ADDR_HI,
3177 FIELD_GET(HAL_REO_DEST_RING_INFO0_QUEUE_ADDR_HI,
3178 reo_dest_ring->info0)) |
3179 FIELD_PREP(HAL_REO_ENTR_RING_INFO0_DEST_IND, dst_idx);
3180 ath11k_hal_srng_access_end(ab, srng);
3181 spin_unlock_bh(&srng->lock);
3186 spin_lock_bh(&rx_refill_ring->idr_lock);
3187 idr_remove(&rx_refill_ring->bufs_idr, buf_id);
3188 spin_unlock_bh(&rx_refill_ring->idr_lock);
3190 dma_unmap_single(ab->dev, paddr, defrag_skb->len + skb_tailroom(defrag_skb),
3195 static int ath11k_dp_rx_h_cmp_frags(struct sk_buff *a, struct sk_buff *b)
3199 frag1 = ath11k_dp_rx_h_mpdu_start_frag_no(a);
3200 frag2 = ath11k_dp_rx_h_mpdu_start_frag_no(b);
3202 return frag1 - frag2;
3205 static void ath11k_dp_rx_h_sort_frags(struct sk_buff_head *frag_list,
3206 struct sk_buff *cur_frag)
3208 struct sk_buff *skb;
3211 skb_queue_walk(frag_list, skb) {
3212 cmp = ath11k_dp_rx_h_cmp_frags(skb, cur_frag);
3215 __skb_queue_before(frag_list, skb, cur_frag);
3218 __skb_queue_tail(frag_list, cur_frag);
3221 static u64 ath11k_dp_rx_h_get_pn(struct sk_buff *skb)
3223 struct ieee80211_hdr *hdr;
3227 hdr = (struct ieee80211_hdr *)(skb->data + HAL_RX_DESC_SIZE);
3228 ehdr = skb->data + HAL_RX_DESC_SIZE + ieee80211_hdrlen(hdr->frame_control);
3231 pn |= (u64)ehdr[1] << 8;
3232 pn |= (u64)ehdr[4] << 16;
3233 pn |= (u64)ehdr[5] << 24;
3234 pn |= (u64)ehdr[6] << 32;
3235 pn |= (u64)ehdr[7] << 40;
3241 ath11k_dp_rx_h_defrag_validate_incr_pn(struct ath11k *ar, struct dp_rx_tid *rx_tid)
3243 enum hal_encrypt_type encrypt_type;
3244 struct sk_buff *first_frag, *skb;
3245 struct hal_rx_desc *desc;
3249 first_frag = skb_peek(&rx_tid->rx_frags);
3250 desc = (struct hal_rx_desc *)first_frag->data;
3252 encrypt_type = ath11k_dp_rx_h_mpdu_start_enctype(desc);
3253 if (encrypt_type != HAL_ENCRYPT_TYPE_CCMP_128 &&
3254 encrypt_type != HAL_ENCRYPT_TYPE_CCMP_256 &&
3255 encrypt_type != HAL_ENCRYPT_TYPE_GCMP_128 &&
3256 encrypt_type != HAL_ENCRYPT_TYPE_AES_GCMP_256)
3259 last_pn = ath11k_dp_rx_h_get_pn(first_frag);
3260 skb_queue_walk(&rx_tid->rx_frags, skb) {
3261 if (skb == first_frag)
3264 cur_pn = ath11k_dp_rx_h_get_pn(skb);
3265 if (cur_pn != last_pn + 1)
3272 static int ath11k_dp_rx_frag_h_mpdu(struct ath11k *ar,
3273 struct sk_buff *msdu,
3276 struct ath11k_base *ab = ar->ab;
3277 struct hal_rx_desc *rx_desc;
3278 struct ath11k_peer *peer;
3279 struct dp_rx_tid *rx_tid;
3280 struct sk_buff *defrag_skb = NULL;
3287 rx_desc = (struct hal_rx_desc *)msdu->data;
3288 peer_id = ath11k_dp_rx_h_mpdu_start_peer_id(rx_desc);
3289 tid = ath11k_dp_rx_h_mpdu_start_tid(rx_desc);
3290 seqno = ath11k_dp_rx_h_mpdu_start_seq_no(rx_desc);
3291 frag_no = ath11k_dp_rx_h_mpdu_start_frag_no(msdu);
3292 more_frags = ath11k_dp_rx_h_mpdu_start_more_frags(msdu);
3294 if (!ath11k_dp_rx_h_mpdu_start_seq_ctrl_valid(rx_desc) ||
3295 !ath11k_dp_rx_h_mpdu_start_fc_valid(rx_desc) ||
3296 tid > IEEE80211_NUM_TIDS)
3299 /* received unfragmented packet in reo
3300 * exception ring, this shouldn't happen
3301 * as these packets typically come from
3304 if (WARN_ON_ONCE(!frag_no && !more_frags))
3307 spin_lock_bh(&ab->base_lock);
3308 peer = ath11k_peer_find_by_id(ab, peer_id);
3310 ath11k_warn(ab, "failed to find the peer to de-fragment received fragment peer_id %d\n",
3315 rx_tid = &peer->rx_tid[tid];
3317 if ((!skb_queue_empty(&rx_tid->rx_frags) && seqno != rx_tid->cur_sn) ||
3318 skb_queue_empty(&rx_tid->rx_frags)) {
3319 /* Flush stored fragments and start a new sequence */
3320 ath11k_dp_rx_frags_cleanup(rx_tid, true);
3321 rx_tid->cur_sn = seqno;
3324 if (rx_tid->rx_frag_bitmap & BIT(frag_no)) {
3325 /* Fragment already present */
3330 if (frag_no > __fls(rx_tid->rx_frag_bitmap))
3331 __skb_queue_tail(&rx_tid->rx_frags, msdu);
3333 ath11k_dp_rx_h_sort_frags(&rx_tid->rx_frags, msdu);
3335 rx_tid->rx_frag_bitmap |= BIT(frag_no);
3337 rx_tid->last_frag_no = frag_no;
3340 rx_tid->dst_ring_desc = kmemdup(ring_desc,
3341 sizeof(*rx_tid->dst_ring_desc),
3343 if (!rx_tid->dst_ring_desc) {
3348 ath11k_dp_rx_link_desc_return(ab, ring_desc,
3349 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3352 if (!rx_tid->last_frag_no ||
3353 rx_tid->rx_frag_bitmap != GENMASK(rx_tid->last_frag_no, 0)) {
3354 mod_timer(&rx_tid->frag_timer, jiffies +
3355 ATH11K_DP_RX_FRAGMENT_TIMEOUT_MS);
3359 spin_unlock_bh(&ab->base_lock);
3360 del_timer_sync(&rx_tid->frag_timer);
3361 spin_lock_bh(&ab->base_lock);
3363 peer = ath11k_peer_find_by_id(ab, peer_id);
3365 goto err_frags_cleanup;
3367 if (!ath11k_dp_rx_h_defrag_validate_incr_pn(ar, rx_tid))
3368 goto err_frags_cleanup;
3370 if (ath11k_dp_rx_h_defrag(ar, peer, rx_tid, &defrag_skb))
3371 goto err_frags_cleanup;
3374 goto err_frags_cleanup;
3376 if (ath11k_dp_rx_h_defrag_reo_reinject(ar, rx_tid, defrag_skb))
3377 goto err_frags_cleanup;
3379 ath11k_dp_rx_frags_cleanup(rx_tid, false);
3383 dev_kfree_skb_any(defrag_skb);
3384 ath11k_dp_rx_frags_cleanup(rx_tid, true);
3386 spin_unlock_bh(&ab->base_lock);
3391 ath11k_dp_process_rx_err_buf(struct ath11k *ar, u32 *ring_desc, int buf_id, bool drop)
3393 struct ath11k_pdev_dp *dp = &ar->dp;
3394 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
3395 struct sk_buff *msdu;
3396 struct ath11k_skb_rxcb *rxcb;
3397 struct hal_rx_desc *rx_desc;
3401 spin_lock_bh(&rx_ring->idr_lock);
3402 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
3404 ath11k_warn(ar->ab, "rx err buf with invalid buf_id %d\n",
3406 spin_unlock_bh(&rx_ring->idr_lock);
3410 idr_remove(&rx_ring->bufs_idr, buf_id);
3411 spin_unlock_bh(&rx_ring->idr_lock);
3413 rxcb = ATH11K_SKB_RXCB(msdu);
3414 dma_unmap_single(ar->ab->dev, rxcb->paddr,
3415 msdu->len + skb_tailroom(msdu),
3419 dev_kfree_skb_any(msdu);
3424 if (!rcu_dereference(ar->ab->pdevs_active[ar->pdev_idx])) {
3425 dev_kfree_skb_any(msdu);
3429 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
3430 dev_kfree_skb_any(msdu);
3434 rx_desc = (struct hal_rx_desc *)msdu->data;
3435 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(rx_desc);
3436 if ((msdu_len + HAL_RX_DESC_SIZE) > DP_RX_BUFFER_SIZE) {
3437 hdr_status = ath11k_dp_rx_h_80211_hdr(rx_desc);
3438 ath11k_warn(ar->ab, "invalid msdu leng %u", msdu_len);
3439 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", hdr_status,
3440 sizeof(struct ieee80211_hdr));
3441 ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "", rx_desc,
3442 sizeof(struct hal_rx_desc));
3443 dev_kfree_skb_any(msdu);
3447 skb_put(msdu, HAL_RX_DESC_SIZE + msdu_len);
3449 if (ath11k_dp_rx_frag_h_mpdu(ar, msdu, ring_desc)) {
3450 dev_kfree_skb_any(msdu);
3451 ath11k_dp_rx_link_desc_return(ar->ab, ring_desc,
3452 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3459 int ath11k_dp_process_rx_err(struct ath11k_base *ab, struct napi_struct *napi,
3462 u32 msdu_cookies[HAL_NUM_RX_MSDUS_PER_LINK_DESC];
3463 struct dp_link_desc_bank *link_desc_banks;
3464 enum hal_rx_buf_return_buf_manager rbm;
3465 int tot_n_bufs_reaped, quota, ret, i;
3466 int n_bufs_reaped[MAX_RADIOS] = {0};
3467 struct dp_rxdma_ring *rx_ring;
3468 struct dp_srng *reo_except;
3469 u32 desc_bank, num_msdus;
3470 struct hal_srng *srng;
3471 struct ath11k_dp *dp;
3480 tot_n_bufs_reaped = 0;
3484 reo_except = &dp->reo_except_ring;
3485 link_desc_banks = dp->link_desc_banks;
3487 srng = &ab->hal.srng_list[reo_except->ring_id];
3489 spin_lock_bh(&srng->lock);
3491 ath11k_hal_srng_access_begin(ab, srng);
3494 (desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
3495 struct hal_reo_dest_ring *reo_desc = (struct hal_reo_dest_ring *)desc;
3497 ab->soc_stats.err_ring_pkts++;
3498 ret = ath11k_hal_desc_reo_parse_err(ab, desc, &paddr,
3501 ath11k_warn(ab, "failed to parse error reo desc %d\n",
3505 link_desc_va = link_desc_banks[desc_bank].vaddr +
3506 (paddr - link_desc_banks[desc_bank].paddr);
3507 ath11k_hal_rx_msdu_link_info_get(link_desc_va, &num_msdus, msdu_cookies,
3509 if (rbm != HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST &&
3510 rbm != HAL_RX_BUF_RBM_SW3_BM) {
3511 ab->soc_stats.invalid_rbm++;
3512 ath11k_warn(ab, "invalid return buffer manager %d\n", rbm);
3513 ath11k_dp_rx_link_desc_return(ab, desc,
3514 HAL_WBM_REL_BM_ACT_REL_MSDU);
3518 is_frag = !!(reo_desc->rx_mpdu_info.info0 & RX_MPDU_DESC_INFO0_FRAG_FLAG);
3520 /* Process only rx fragments with one msdu per link desc below, and drop
3521 * msdu's indicated due to error reasons.
3523 if (!is_frag || num_msdus > 1) {
3525 /* Return the link desc back to wbm idle list */
3526 ath11k_dp_rx_link_desc_return(ab, desc,
3527 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3530 for (i = 0; i < num_msdus; i++) {
3531 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
3534 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID,
3537 ar = ab->pdevs[mac_id].ar;
3539 if (!ath11k_dp_process_rx_err_buf(ar, desc, buf_id, drop)) {
3540 n_bufs_reaped[mac_id]++;
3541 tot_n_bufs_reaped++;
3545 if (tot_n_bufs_reaped >= quota) {
3546 tot_n_bufs_reaped = quota;
3550 budget = quota - tot_n_bufs_reaped;
3554 ath11k_hal_srng_access_end(ab, srng);
3556 spin_unlock_bh(&srng->lock);
3558 for (i = 0; i < ab->num_radios; i++) {
3559 if (!n_bufs_reaped[i])
3562 ar = ab->pdevs[i].ar;
3563 rx_ring = &ar->dp.rx_refill_buf_ring;
3565 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, n_bufs_reaped[i],
3566 HAL_RX_BUF_RBM_SW3_BM, GFP_ATOMIC);
3569 return tot_n_bufs_reaped;
3572 static void ath11k_dp_rx_null_q_desc_sg_drop(struct ath11k *ar,
3574 struct sk_buff_head *msdu_list)
3576 struct sk_buff *skb, *tmp;
3577 struct ath11k_skb_rxcb *rxcb;
3580 n_buffs = DIV_ROUND_UP(msdu_len,
3581 (DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE));
3583 skb_queue_walk_safe(msdu_list, skb, tmp) {
3584 rxcb = ATH11K_SKB_RXCB(skb);
3585 if (rxcb->err_rel_src == HAL_WBM_REL_SRC_MODULE_REO &&
3586 rxcb->err_code == HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO) {
3589 __skb_unlink(skb, msdu_list);
3590 dev_kfree_skb_any(skb);
3596 static int ath11k_dp_rx_h_null_q_desc(struct ath11k *ar, struct sk_buff *msdu,
3597 struct ieee80211_rx_status *status,
3598 struct sk_buff_head *msdu_list)
3601 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
3603 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3605 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(desc);
3607 if (!rxcb->is_frag && ((msdu_len + HAL_RX_DESC_SIZE) > DP_RX_BUFFER_SIZE)) {
3608 /* First buffer will be freed by the caller, so deduct it's length */
3609 msdu_len = msdu_len - (DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE);
3610 ath11k_dp_rx_null_q_desc_sg_drop(ar, msdu_len, msdu_list);
3614 if (!ath11k_dp_rx_h_attn_msdu_done(desc)) {
3616 "msdu_done bit not set in null_q_des processing\n");
3617 __skb_queue_purge(msdu_list);
3621 /* Handle NULL queue descriptor violations arising out a missing
3622 * REO queue for a given peer or a given TID. This typically
3623 * may happen if a packet is received on a QOS enabled TID before the
3624 * ADDBA negotiation for that TID, when the TID queue is setup. Or
3625 * it may also happen for MC/BC frames if they are not routed to the
3626 * non-QOS TID queue, in the absence of any other default TID queue.
3627 * This error can show up both in a REO destination or WBM release ring.
3630 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(desc);
3631 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(desc);
3633 if (rxcb->is_frag) {
3634 skb_pull(msdu, HAL_RX_DESC_SIZE);
3636 l3pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(desc);
3638 if ((HAL_RX_DESC_SIZE + l3pad_bytes + msdu_len) > DP_RX_BUFFER_SIZE)
3641 skb_put(msdu, HAL_RX_DESC_SIZE + l3pad_bytes + msdu_len);
3642 skb_pull(msdu, HAL_RX_DESC_SIZE + l3pad_bytes);
3644 ath11k_dp_rx_h_ppdu(ar, desc, status);
3646 ath11k_dp_rx_h_mpdu(ar, msdu, desc, status);
3648 rxcb->tid = ath11k_dp_rx_h_mpdu_start_tid(desc);
3650 /* Please note that caller will having the access to msdu and completing
3651 * rx with mac80211. Need not worry about cleaning up amsdu_list.
3657 static bool ath11k_dp_rx_h_reo_err(struct ath11k *ar, struct sk_buff *msdu,
3658 struct ieee80211_rx_status *status,
3659 struct sk_buff_head *msdu_list)
3661 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3664 ar->ab->soc_stats.reo_error[rxcb->err_code]++;
3666 switch (rxcb->err_code) {
3667 case HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO:
3668 if (ath11k_dp_rx_h_null_q_desc(ar, msdu, status, msdu_list))
3671 case HAL_REO_DEST_RING_ERROR_CODE_PN_CHECK_FAILED:
3672 /* TODO: Do not drop PN failed packets in the driver;
3673 * instead, it is good to drop such packets in mac80211
3674 * after incrementing the replay counters.
3679 /* TODO: Review other errors and process them to mac80211
3689 static void ath11k_dp_rx_h_tkip_mic_err(struct ath11k *ar, struct sk_buff *msdu,
3690 struct ieee80211_rx_status *status)
3693 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
3695 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3697 rxcb->is_first_msdu = ath11k_dp_rx_h_msdu_end_first_msdu(desc);
3698 rxcb->is_last_msdu = ath11k_dp_rx_h_msdu_end_last_msdu(desc);
3700 l3pad_bytes = ath11k_dp_rx_h_msdu_end_l3pad(desc);
3701 msdu_len = ath11k_dp_rx_h_msdu_start_msdu_len(desc);
3702 skb_put(msdu, HAL_RX_DESC_SIZE + l3pad_bytes + msdu_len);
3703 skb_pull(msdu, HAL_RX_DESC_SIZE + l3pad_bytes);
3705 ath11k_dp_rx_h_ppdu(ar, desc, status);
3707 status->flag |= (RX_FLAG_MMIC_STRIPPED | RX_FLAG_MMIC_ERROR |
3710 ath11k_dp_rx_h_undecap(ar, msdu, desc,
3711 HAL_ENCRYPT_TYPE_TKIP_MIC, status, false);
3714 static bool ath11k_dp_rx_h_rxdma_err(struct ath11k *ar, struct sk_buff *msdu,
3715 struct ieee80211_rx_status *status)
3717 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3720 ar->ab->soc_stats.rxdma_error[rxcb->err_code]++;
3722 switch (rxcb->err_code) {
3723 case HAL_REO_ENTR_RING_RXDMA_ECODE_TKIP_MIC_ERR:
3724 ath11k_dp_rx_h_tkip_mic_err(ar, msdu, status);
3727 /* TODO: Review other rxdma error code to check if anything is
3728 * worth reporting to mac80211
3737 static void ath11k_dp_rx_wbm_err(struct ath11k *ar,
3738 struct napi_struct *napi,
3739 struct sk_buff *msdu,
3740 struct sk_buff_head *msdu_list)
3742 struct ath11k_skb_rxcb *rxcb = ATH11K_SKB_RXCB(msdu);
3743 struct ieee80211_rx_status rxs = {0};
3744 struct ieee80211_rx_status *status;
3747 switch (rxcb->err_rel_src) {
3748 case HAL_WBM_REL_SRC_MODULE_REO:
3749 drop = ath11k_dp_rx_h_reo_err(ar, msdu, &rxs, msdu_list);
3751 case HAL_WBM_REL_SRC_MODULE_RXDMA:
3752 drop = ath11k_dp_rx_h_rxdma_err(ar, msdu, &rxs);
3755 /* msdu will get freed */
3760 dev_kfree_skb_any(msdu);
3764 status = IEEE80211_SKB_RXCB(msdu);
3767 ath11k_dp_rx_deliver_msdu(ar, napi, msdu);
3770 int ath11k_dp_rx_process_wbm_err(struct ath11k_base *ab,
3771 struct napi_struct *napi, int budget)
3774 struct ath11k_dp *dp = &ab->dp;
3775 struct dp_rxdma_ring *rx_ring;
3776 struct hal_rx_wbm_rel_info err_info;
3777 struct hal_srng *srng;
3778 struct sk_buff *msdu;
3779 struct sk_buff_head msdu_list[MAX_RADIOS];
3780 struct ath11k_skb_rxcb *rxcb;
3783 int num_buffs_reaped[MAX_RADIOS] = {0};
3784 int total_num_buffs_reaped = 0;
3787 for (i = 0; i < MAX_RADIOS; i++)
3788 __skb_queue_head_init(&msdu_list[i]);
3790 srng = &ab->hal.srng_list[dp->rx_rel_ring.ring_id];
3792 spin_lock_bh(&srng->lock);
3794 ath11k_hal_srng_access_begin(ab, srng);
3797 rx_desc = ath11k_hal_srng_dst_get_next_entry(ab, srng);
3801 ret = ath11k_hal_wbm_desc_parse_err(ab, rx_desc, &err_info);
3804 "failed to parse rx error in wbm_rel ring desc %d\n",
3809 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID, err_info.cookie);
3810 mac_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_PDEV_ID, err_info.cookie);
3812 ar = ab->pdevs[mac_id].ar;
3813 rx_ring = &ar->dp.rx_refill_buf_ring;
3815 spin_lock_bh(&rx_ring->idr_lock);
3816 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
3818 ath11k_warn(ab, "frame rx with invalid buf_id %d pdev %d\n",
3820 spin_unlock_bh(&rx_ring->idr_lock);
3824 idr_remove(&rx_ring->bufs_idr, buf_id);
3825 spin_unlock_bh(&rx_ring->idr_lock);
3827 rxcb = ATH11K_SKB_RXCB(msdu);
3828 dma_unmap_single(ab->dev, rxcb->paddr,
3829 msdu->len + skb_tailroom(msdu),
3832 num_buffs_reaped[mac_id]++;
3833 total_num_buffs_reaped++;
3836 if (err_info.push_reason !=
3837 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
3838 dev_kfree_skb_any(msdu);
3842 rxcb->err_rel_src = err_info.err_rel_src;
3843 rxcb->err_code = err_info.err_code;
3844 rxcb->rx_desc = (struct hal_rx_desc *)msdu->data;
3845 __skb_queue_tail(&msdu_list[mac_id], msdu);
3848 ath11k_hal_srng_access_end(ab, srng);
3850 spin_unlock_bh(&srng->lock);
3852 if (!total_num_buffs_reaped)
3855 for (i = 0; i < ab->num_radios; i++) {
3856 if (!num_buffs_reaped[i])
3859 ar = ab->pdevs[i].ar;
3860 rx_ring = &ar->dp.rx_refill_buf_ring;
3862 ath11k_dp_rxbufs_replenish(ab, i, rx_ring, num_buffs_reaped[i],
3863 HAL_RX_BUF_RBM_SW3_BM, GFP_ATOMIC);
3867 for (i = 0; i < ab->num_radios; i++) {
3868 if (!rcu_dereference(ab->pdevs_active[i])) {
3869 __skb_queue_purge(&msdu_list[i]);
3873 ar = ab->pdevs[i].ar;
3875 if (test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) {
3876 __skb_queue_purge(&msdu_list[i]);
3880 while ((msdu = __skb_dequeue(&msdu_list[i])) != NULL)
3881 ath11k_dp_rx_wbm_err(ar, napi, msdu, &msdu_list[i]);
3885 return total_num_buffs_reaped;
3888 int ath11k_dp_process_rxdma_err(struct ath11k_base *ab, int mac_id, int budget)
3890 struct ath11k *ar = ab->pdevs[mac_id].ar;
3891 struct dp_srng *err_ring = &ar->dp.rxdma_err_dst_ring;
3892 struct dp_rxdma_ring *rx_ring = &ar->dp.rx_refill_buf_ring;
3893 struct dp_link_desc_bank *link_desc_banks = ab->dp.link_desc_banks;
3894 struct hal_srng *srng;
3895 u32 msdu_cookies[HAL_NUM_RX_MSDUS_PER_LINK_DESC];
3896 enum hal_rx_buf_return_buf_manager rbm;
3897 enum hal_reo_entr_rxdma_ecode rxdma_err_code;
3898 struct ath11k_skb_rxcb *rxcb;
3899 struct sk_buff *skb;
3900 struct hal_reo_entrance_ring *entr_ring;
3902 int num_buf_freed = 0;
3911 srng = &ab->hal.srng_list[err_ring->ring_id];
3913 spin_lock_bh(&srng->lock);
3915 ath11k_hal_srng_access_begin(ab, srng);
3918 (desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
3919 ath11k_hal_rx_reo_ent_paddr_get(ab, desc, &paddr, &desc_bank);
3921 entr_ring = (struct hal_reo_entrance_ring *)desc;
3923 FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_ERROR_CODE,
3925 ab->soc_stats.rxdma_error[rxdma_err_code]++;
3927 link_desc_va = link_desc_banks[desc_bank].vaddr +
3928 (paddr - link_desc_banks[desc_bank].paddr);
3929 ath11k_hal_rx_msdu_link_info_get(link_desc_va, &num_msdus,
3930 msdu_cookies, &rbm);
3932 for (i = 0; i < num_msdus; i++) {
3933 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
3936 spin_lock_bh(&rx_ring->idr_lock);
3937 skb = idr_find(&rx_ring->bufs_idr, buf_id);
3939 ath11k_warn(ab, "rxdma error with invalid buf_id %d\n",
3941 spin_unlock_bh(&rx_ring->idr_lock);
3945 idr_remove(&rx_ring->bufs_idr, buf_id);
3946 spin_unlock_bh(&rx_ring->idr_lock);
3948 rxcb = ATH11K_SKB_RXCB(skb);
3949 dma_unmap_single(ab->dev, rxcb->paddr,
3950 skb->len + skb_tailroom(skb),
3952 dev_kfree_skb_any(skb);
3957 ath11k_dp_rx_link_desc_return(ab, desc,
3958 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
3961 ath11k_hal_srng_access_end(ab, srng);
3963 spin_unlock_bh(&srng->lock);
3966 ath11k_dp_rxbufs_replenish(ab, mac_id, rx_ring, num_buf_freed,
3967 HAL_RX_BUF_RBM_SW3_BM, GFP_ATOMIC);
3969 return budget - quota;
3972 void ath11k_dp_process_reo_status(struct ath11k_base *ab)
3974 struct ath11k_dp *dp = &ab->dp;
3975 struct hal_srng *srng;
3976 struct dp_reo_cmd *cmd, *tmp;
3980 struct hal_reo_status reo_status;
3982 srng = &ab->hal.srng_list[dp->reo_status_ring.ring_id];
3984 memset(&reo_status, 0, sizeof(reo_status));
3986 spin_lock_bh(&srng->lock);
3988 ath11k_hal_srng_access_begin(ab, srng);
3990 while ((reo_desc = ath11k_hal_srng_dst_get_next_entry(ab, srng))) {
3991 tag = FIELD_GET(HAL_SRNG_TLV_HDR_TAG, *reo_desc);
3994 case HAL_REO_GET_QUEUE_STATS_STATUS:
3995 ath11k_hal_reo_status_queue_stats(ab, reo_desc,
3998 case HAL_REO_FLUSH_QUEUE_STATUS:
3999 ath11k_hal_reo_flush_queue_status(ab, reo_desc,
4002 case HAL_REO_FLUSH_CACHE_STATUS:
4003 ath11k_hal_reo_flush_cache_status(ab, reo_desc,
4006 case HAL_REO_UNBLOCK_CACHE_STATUS:
4007 ath11k_hal_reo_unblk_cache_status(ab, reo_desc,
4010 case HAL_REO_FLUSH_TIMEOUT_LIST_STATUS:
4011 ath11k_hal_reo_flush_timeout_list_status(ab, reo_desc,
4014 case HAL_REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS:
4015 ath11k_hal_reo_desc_thresh_reached_status(ab, reo_desc,
4018 case HAL_REO_UPDATE_RX_REO_QUEUE_STATUS:
4019 ath11k_hal_reo_update_rx_reo_queue_status(ab, reo_desc,
4023 ath11k_warn(ab, "Unknown reo status type %d\n", tag);
4027 spin_lock_bh(&dp->reo_cmd_lock);
4028 list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) {
4029 if (reo_status.uniform_hdr.cmd_num == cmd->cmd_num) {
4031 list_del(&cmd->list);
4035 spin_unlock_bh(&dp->reo_cmd_lock);
4038 cmd->handler(dp, (void *)&cmd->data,
4039 reo_status.uniform_hdr.cmd_status);
4046 ath11k_hal_srng_access_end(ab, srng);
4048 spin_unlock_bh(&srng->lock);
4051 void ath11k_dp_rx_pdev_free(struct ath11k_base *ab, int mac_id)
4053 struct ath11k *ar = ab->pdevs[mac_id].ar;
4055 ath11k_dp_rx_pdev_srng_free(ar);
4056 ath11k_dp_rxdma_pdev_buf_free(ar);
4059 int ath11k_dp_rx_pdev_alloc(struct ath11k_base *ab, int mac_id)
4061 struct ath11k *ar = ab->pdevs[mac_id].ar;
4062 struct ath11k_pdev_dp *dp = &ar->dp;
4066 ret = ath11k_dp_rx_pdev_srng_alloc(ar);
4068 ath11k_warn(ab, "failed to setup rx srngs\n");
4072 ret = ath11k_dp_rxdma_pdev_buf_setup(ar);
4074 ath11k_warn(ab, "failed to setup rxdma ring\n");
4078 ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id;
4079 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id, mac_id, HAL_RXDMA_BUF);
4081 ath11k_warn(ab, "failed to configure rx_refill_buf_ring %d\n",
4086 ring_id = dp->rxdma_err_dst_ring.ring_id;
4087 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id, mac_id, HAL_RXDMA_DST);
4089 ath11k_warn(ab, "failed to configure rxdma_err_dest_ring %d\n",
4094 ring_id = dp->rxdma_mon_buf_ring.refill_buf_ring.ring_id;
4095 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id,
4096 mac_id, HAL_RXDMA_MONITOR_BUF);
4098 ath11k_warn(ab, "failed to configure rxdma_mon_buf_ring %d\n",
4102 ret = ath11k_dp_tx_htt_srng_setup(ab,
4103 dp->rxdma_mon_dst_ring.ring_id,
4104 mac_id, HAL_RXDMA_MONITOR_DST);
4106 ath11k_warn(ab, "failed to configure rxdma_mon_dst_ring %d\n",
4110 ret = ath11k_dp_tx_htt_srng_setup(ab,
4111 dp->rxdma_mon_desc_ring.ring_id,
4112 mac_id, HAL_RXDMA_MONITOR_DESC);
4114 ath11k_warn(ab, "failed to configure rxdma_mon_dst_ring %d\n",
4118 ring_id = dp->rx_mon_status_refill_ring.refill_buf_ring.ring_id;
4119 ret = ath11k_dp_tx_htt_srng_setup(ab, ring_id, mac_id,
4120 HAL_RXDMA_MONITOR_STATUS);
4123 "failed to configure mon_status_refill_ring %d\n",
4130 static void ath11k_dp_mon_set_frag_len(u32 *total_len, u32 *frag_len)
4132 if (*total_len >= (DP_RX_BUFFER_SIZE - sizeof(struct hal_rx_desc))) {
4133 *frag_len = DP_RX_BUFFER_SIZE - sizeof(struct hal_rx_desc);
4134 *total_len -= *frag_len;
4136 *frag_len = *total_len;
4142 int ath11k_dp_rx_monitor_link_desc_return(struct ath11k *ar,
4143 void *p_last_buf_addr_info,
4146 struct ath11k_pdev_dp *dp = &ar->dp;
4147 struct dp_srng *dp_srng;
4149 void *src_srng_desc;
4152 dp_srng = &dp->rxdma_mon_desc_ring;
4153 hal_srng = &ar->ab->hal.srng_list[dp_srng->ring_id];
4155 ath11k_hal_srng_access_begin(ar->ab, hal_srng);
4157 src_srng_desc = ath11k_hal_srng_src_get_next_entry(ar->ab, hal_srng);
4159 if (src_srng_desc) {
4160 struct ath11k_buffer_addr *src_desc =
4161 (struct ath11k_buffer_addr *)src_srng_desc;
4163 *src_desc = *((struct ath11k_buffer_addr *)p_last_buf_addr_info);
4165 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4166 "Monitor Link Desc Ring %d Full", mac_id);
4170 ath11k_hal_srng_access_end(ar->ab, hal_srng);
4175 void ath11k_dp_rx_mon_next_link_desc_get(void *rx_msdu_link_desc,
4176 dma_addr_t *paddr, u32 *sw_cookie,
4177 void **pp_buf_addr_info)
4179 struct hal_rx_msdu_link *msdu_link =
4180 (struct hal_rx_msdu_link *)rx_msdu_link_desc;
4181 struct ath11k_buffer_addr *buf_addr_info;
4184 buf_addr_info = (struct ath11k_buffer_addr *)&msdu_link->buf_addr_info;
4186 ath11k_hal_rx_buf_addr_info_get(buf_addr_info, paddr, sw_cookie, &rbm);
4188 *pp_buf_addr_info = (void *)buf_addr_info;
4191 static int ath11k_dp_pkt_set_pktlen(struct sk_buff *skb, u32 len)
4193 if (skb->len > len) {
4196 if (skb_tailroom(skb) < len - skb->len) {
4197 if ((pskb_expand_head(skb, 0,
4198 len - skb->len - skb_tailroom(skb),
4200 dev_kfree_skb_any(skb);
4204 skb_put(skb, (len - skb->len));
4209 static void ath11k_hal_rx_msdu_list_get(struct ath11k *ar,
4210 void *msdu_link_desc,
4211 struct hal_rx_msdu_list *msdu_list,
4214 struct hal_rx_msdu_details *msdu_details = NULL;
4215 struct rx_msdu_desc *msdu_desc_info = NULL;
4216 struct hal_rx_msdu_link *msdu_link = NULL;
4218 u32 last = FIELD_PREP(RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU, 1);
4219 u32 first = FIELD_PREP(RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU, 1);
4222 msdu_link = (struct hal_rx_msdu_link *)msdu_link_desc;
4223 msdu_details = &msdu_link->msdu_link[0];
4225 for (i = 0; i < HAL_RX_NUM_MSDU_DESC; i++) {
4226 if (FIELD_GET(BUFFER_ADDR_INFO0_ADDR,
4227 msdu_details[i].buf_addr_info.info0) == 0) {
4228 msdu_desc_info = &msdu_details[i - 1].rx_msdu_info;
4229 msdu_desc_info->info0 |= last;
4233 msdu_desc_info = &msdu_details[i].rx_msdu_info;
4236 msdu_desc_info->info0 |= first;
4237 else if (i == (HAL_RX_NUM_MSDU_DESC - 1))
4238 msdu_desc_info->info0 |= last;
4239 msdu_list->msdu_info[i].msdu_flags = msdu_desc_info->info0;
4240 msdu_list->msdu_info[i].msdu_len =
4241 HAL_RX_MSDU_PKT_LENGTH_GET(msdu_desc_info->info0);
4242 msdu_list->sw_cookie[i] =
4243 FIELD_GET(BUFFER_ADDR_INFO1_SW_COOKIE,
4244 msdu_details[i].buf_addr_info.info1);
4245 tmp = FIELD_GET(BUFFER_ADDR_INFO1_RET_BUF_MGR,
4246 msdu_details[i].buf_addr_info.info1);
4247 msdu_list->rbm[i] = tmp;
4252 static u32 ath11k_dp_rx_mon_comp_ppduid(u32 msdu_ppdu_id, u32 *ppdu_id,
4257 if ((*ppdu_id < msdu_ppdu_id) &&
4258 ((msdu_ppdu_id - *ppdu_id) < DP_NOT_PPDU_ID_WRAP_AROUND)) {
4259 *ppdu_id = msdu_ppdu_id;
4261 } else if ((*ppdu_id > msdu_ppdu_id) &&
4262 ((*ppdu_id - msdu_ppdu_id) > DP_NOT_PPDU_ID_WRAP_AROUND)) {
4263 /* mon_dst is behind than mon_status
4264 * skip dst_ring and free it
4267 *ppdu_id = msdu_ppdu_id;
4273 static void ath11k_dp_mon_get_buf_len(struct hal_rx_msdu_desc_info *info,
4274 bool *is_frag, u32 *total_len,
4275 u32 *frag_len, u32 *msdu_cnt)
4277 if (info->msdu_flags & RX_MSDU_DESC_INFO0_MSDU_CONTINUATION) {
4279 *total_len = info->msdu_len;
4282 ath11k_dp_mon_set_frag_len(total_len,
4286 ath11k_dp_mon_set_frag_len(total_len,
4289 *frag_len = info->msdu_len;
4297 ath11k_dp_rx_mon_mpdu_pop(struct ath11k *ar,
4298 void *ring_entry, struct sk_buff **head_msdu,
4299 struct sk_buff **tail_msdu, u32 *npackets,
4302 struct ath11k_pdev_dp *dp = &ar->dp;
4303 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4304 struct dp_rxdma_ring *rx_ring = &dp->rxdma_mon_buf_ring;
4305 struct sk_buff *msdu = NULL, *last = NULL;
4306 struct hal_rx_msdu_list msdu_list;
4307 void *p_buf_addr_info, *p_last_buf_addr_info;
4308 struct hal_rx_desc *rx_desc;
4309 void *rx_msdu_link_desc;
4312 u32 rx_buf_size, rx_pkt_offset, sw_cookie;
4313 u32 rx_bufs_used = 0, i = 0;
4314 u32 msdu_ppdu_id = 0, msdu_cnt = 0;
4315 u32 total_len = 0, frag_len = 0;
4316 bool is_frag, is_first_msdu;
4317 bool drop_mpdu = false;
4318 struct ath11k_skb_rxcb *rxcb;
4319 struct hal_reo_entrance_ring *ent_desc =
4320 (struct hal_reo_entrance_ring *)ring_entry;
4323 ath11k_hal_rx_reo_ent_buf_paddr_get(ring_entry, &paddr,
4324 &sw_cookie, &p_last_buf_addr_info,
4327 if (FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_PUSH_REASON,
4329 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
4331 FIELD_GET(HAL_REO_ENTR_RING_INFO1_RXDMA_ERROR_CODE,
4333 if (rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_FLUSH_REQUEST_ERR ||
4334 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_MPDU_LEN_ERR ||
4335 rxdma_err == HAL_REO_ENTR_RING_RXDMA_ECODE_OVERFLOW_ERR) {
4337 pmon->rx_mon_stats.dest_mpdu_drop++;
4342 is_first_msdu = true;
4345 if (pmon->mon_last_linkdesc_paddr == paddr) {
4346 pmon->rx_mon_stats.dup_mon_linkdesc_cnt++;
4347 return rx_bufs_used;
4351 (void *)pmon->link_desc_banks[sw_cookie].vaddr +
4352 (paddr - pmon->link_desc_banks[sw_cookie].paddr);
4354 ath11k_hal_rx_msdu_list_get(ar, rx_msdu_link_desc, &msdu_list,
4357 for (i = 0; i < num_msdus; i++) {
4360 if (pmon->mon_last_buf_cookie == msdu_list.sw_cookie[i]) {
4361 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4362 "i %d last_cookie %d is same\n",
4363 i, pmon->mon_last_buf_cookie);
4365 pmon->rx_mon_stats.dup_mon_buf_cnt++;
4368 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID,
4369 msdu_list.sw_cookie[i]);
4371 spin_lock_bh(&rx_ring->idr_lock);
4372 msdu = idr_find(&rx_ring->bufs_idr, buf_id);
4373 spin_unlock_bh(&rx_ring->idr_lock);
4375 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4376 "msdu_pop: invalid buf_id %d\n", buf_id);
4379 rxcb = ATH11K_SKB_RXCB(msdu);
4380 if (!rxcb->unmapped) {
4381 dma_unmap_single(ar->ab->dev, rxcb->paddr,
4388 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4389 "i %d drop msdu %p *ppdu_id %x\n",
4391 dev_kfree_skb_any(msdu);
4396 rx_desc = (struct hal_rx_desc *)msdu->data;
4398 rx_pkt_offset = sizeof(struct hal_rx_desc);
4399 l2_hdr_offset = ath11k_dp_rx_h_msdu_end_l3pad(rx_desc);
4401 if (is_first_msdu) {
4402 if (!ath11k_dp_rxdesc_mpdu_valid(rx_desc)) {
4404 dev_kfree_skb_any(msdu);
4406 pmon->mon_last_linkdesc_paddr = paddr;
4411 ath11k_dp_rxdesc_get_ppduid(rx_desc);
4413 if (ath11k_dp_rx_mon_comp_ppduid(msdu_ppdu_id,
4418 dev_kfree_skb_any(msdu);
4422 return rx_bufs_used;
4424 pmon->mon_last_linkdesc_paddr = paddr;
4425 is_first_msdu = false;
4427 ath11k_dp_mon_get_buf_len(&msdu_list.msdu_info[i],
4428 &is_frag, &total_len,
4429 &frag_len, &msdu_cnt);
4430 rx_buf_size = rx_pkt_offset + l2_hdr_offset + frag_len;
4432 ath11k_dp_pkt_set_pktlen(msdu, rx_buf_size);
4441 pmon->mon_last_buf_cookie = msdu_list.sw_cookie[i];
4443 spin_lock_bh(&rx_ring->idr_lock);
4444 idr_remove(&rx_ring->bufs_idr, buf_id);
4445 spin_unlock_bh(&rx_ring->idr_lock);
4448 ath11k_dp_rx_mon_next_link_desc_get(rx_msdu_link_desc, &paddr,
4452 if (ath11k_dp_rx_monitor_link_desc_return(ar,
4453 p_last_buf_addr_info,
4455 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4456 "dp_rx_monitor_link_desc_return failed");
4458 p_last_buf_addr_info = p_buf_addr_info;
4460 } while (paddr && msdu_cnt);
4470 return rx_bufs_used;
4473 static void ath11k_dp_rx_msdus_set_payload(struct sk_buff *msdu)
4475 u32 rx_pkt_offset, l2_hdr_offset;
4477 rx_pkt_offset = sizeof(struct hal_rx_desc);
4478 l2_hdr_offset = ath11k_dp_rx_h_msdu_end_l3pad((struct hal_rx_desc *)msdu->data);
4479 skb_pull(msdu, rx_pkt_offset + l2_hdr_offset);
4482 static struct sk_buff *
4483 ath11k_dp_rx_mon_merg_msdus(struct ath11k *ar,
4484 u32 mac_id, struct sk_buff *head_msdu,
4485 struct sk_buff *last_msdu,
4486 struct ieee80211_rx_status *rxs)
4488 struct sk_buff *msdu, *mpdu_buf, *prev_buf;
4489 u32 decap_format, wifi_hdr_len;
4490 struct hal_rx_desc *rx_desc;
4493 struct ieee80211_hdr_3addr *wh;
4498 goto err_merge_fail;
4500 rx_desc = (struct hal_rx_desc *)head_msdu->data;
4502 if (ath11k_dp_rxdesc_get_mpdulen_err(rx_desc))
4505 decap_format = ath11k_dp_rxdesc_get_decap_format(rx_desc);
4507 ath11k_dp_rx_h_ppdu(ar, rx_desc, rxs);
4509 if (decap_format == DP_RX_DECAP_TYPE_RAW) {
4510 ath11k_dp_rx_msdus_set_payload(head_msdu);
4512 prev_buf = head_msdu;
4513 msdu = head_msdu->next;
4516 ath11k_dp_rx_msdus_set_payload(msdu);
4522 prev_buf->next = NULL;
4524 skb_trim(prev_buf, prev_buf->len - HAL_RX_FCS_LEN);
4525 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) {
4529 rx_desc = (struct hal_rx_desc *)head_msdu->data;
4530 hdr_desc = ath11k_dp_rxdesc_get_80211hdr(rx_desc);
4533 wifi_hdr_len = sizeof(struct ieee80211_hdr_3addr);
4534 wh = (struct ieee80211_hdr_3addr *)hdr_desc;
4536 if (ieee80211_is_data_qos(wh->frame_control)) {
4537 struct ieee80211_qos_hdr *qwh =
4538 (struct ieee80211_qos_hdr *)hdr_desc;
4540 qos_field = qwh->qos_ctrl;
4546 rx_desc = (struct hal_rx_desc *)msdu->data;
4547 hdr_desc = ath11k_dp_rxdesc_get_80211hdr(rx_desc);
4550 dest = skb_push(msdu, sizeof(__le16));
4552 goto err_merge_fail;
4553 memcpy(dest, hdr_desc, wifi_hdr_len);
4554 memcpy(dest + wifi_hdr_len,
4555 (u8 *)&qos_field, sizeof(__le16));
4557 ath11k_dp_rx_msdus_set_payload(msdu);
4561 dest = skb_put(prev_buf, HAL_RX_FCS_LEN);
4563 goto err_merge_fail;
4565 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4566 "mpdu_buf %pK mpdu_buf->len %u",
4567 prev_buf, prev_buf->len);
4569 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4570 "decap format %d is not supported!\n",
4572 goto err_merge_fail;
4578 if (mpdu_buf && decap_format != DP_RX_DECAP_TYPE_RAW) {
4579 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4580 "err_merge_fail mpdu_buf %pK", mpdu_buf);
4581 /* Free the head buffer */
4582 dev_kfree_skb_any(mpdu_buf);
4587 static int ath11k_dp_rx_mon_deliver(struct ath11k *ar, u32 mac_id,
4588 struct sk_buff *head_msdu,
4589 struct sk_buff *tail_msdu,
4590 struct napi_struct *napi)
4592 struct ath11k_pdev_dp *dp = &ar->dp;
4593 struct sk_buff *mon_skb, *skb_next, *header;
4594 struct ieee80211_rx_status *rxs = &dp->rx_status, *status;
4596 mon_skb = ath11k_dp_rx_mon_merg_msdus(ar, mac_id, head_msdu,
4600 goto mon_deliver_fail;
4606 skb_next = mon_skb->next;
4608 rxs->flag &= ~RX_FLAG_AMSDU_MORE;
4610 rxs->flag |= RX_FLAG_AMSDU_MORE;
4612 if (mon_skb == header) {
4614 rxs->flag &= ~RX_FLAG_ALLOW_SAME_PN;
4616 rxs->flag |= RX_FLAG_ALLOW_SAME_PN;
4618 rxs->flag |= RX_FLAG_ONLY_MONITOR;
4620 status = IEEE80211_SKB_RXCB(mon_skb);
4623 ath11k_dp_rx_deliver_msdu(ar, napi, mon_skb);
4631 mon_skb = head_msdu;
4633 skb_next = mon_skb->next;
4634 dev_kfree_skb_any(mon_skb);
4640 static void ath11k_dp_rx_mon_dest_process(struct ath11k *ar, u32 quota,
4641 struct napi_struct *napi)
4643 struct ath11k_pdev_dp *dp = &ar->dp;
4644 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4649 struct ath11k_pdev_mon_stats *rx_mon_stats;
4652 mon_dst_srng = &ar->ab->hal.srng_list[dp->rxdma_mon_dst_ring.ring_id];
4654 if (!mon_dst_srng) {
4656 "HAL Monitor Destination Ring Init Failed -- %pK",
4661 spin_lock_bh(&pmon->mon_lock);
4663 ath11k_hal_srng_access_begin(ar->ab, mon_dst_srng);
4665 ppdu_id = pmon->mon_ppdu_info.ppdu_id;
4667 rx_mon_stats = &pmon->rx_mon_stats;
4669 while ((ring_entry = ath11k_hal_srng_dst_peek(ar->ab, mon_dst_srng))) {
4670 struct sk_buff *head_msdu, *tail_msdu;
4675 rx_bufs_used += ath11k_dp_rx_mon_mpdu_pop(ar, ring_entry,
4678 &npackets, &ppdu_id);
4680 if (ppdu_id != pmon->mon_ppdu_info.ppdu_id) {
4681 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
4682 ath11k_dbg(ar->ab, ATH11K_DBG_DATA,
4683 "dest_rx: new ppdu_id %x != status ppdu_id %x",
4684 ppdu_id, pmon->mon_ppdu_info.ppdu_id);
4687 if (head_msdu && tail_msdu) {
4688 ath11k_dp_rx_mon_deliver(ar, dp->mac_id, head_msdu,
4690 rx_mon_stats->dest_mpdu_done++;
4693 ring_entry = ath11k_hal_srng_dst_get_next_entry(ar->ab,
4696 ath11k_hal_srng_access_end(ar->ab, mon_dst_srng);
4698 spin_unlock_bh(&pmon->mon_lock);
4701 rx_mon_stats->dest_ppdu_done++;
4702 ath11k_dp_rxbufs_replenish(ar->ab, dp->mac_id,
4703 &dp->rxdma_mon_buf_ring,
4705 HAL_RX_BUF_RBM_SW3_BM, GFP_ATOMIC);
4709 static void ath11k_dp_rx_mon_status_process_tlv(struct ath11k *ar,
4711 struct napi_struct *napi)
4713 struct ath11k_pdev_dp *dp = &ar->dp;
4714 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4715 struct hal_rx_mon_ppdu_info *ppdu_info;
4716 struct sk_buff *status_skb;
4717 u32 tlv_status = HAL_TLV_STATUS_BUF_DONE;
4718 struct ath11k_pdev_mon_stats *rx_mon_stats;
4720 ppdu_info = &pmon->mon_ppdu_info;
4721 rx_mon_stats = &pmon->rx_mon_stats;
4723 if (pmon->mon_ppdu_status != DP_PPDU_STATUS_START)
4726 while (!skb_queue_empty(&pmon->rx_status_q)) {
4727 status_skb = skb_dequeue(&pmon->rx_status_q);
4729 tlv_status = ath11k_hal_rx_parse_mon_status(ar->ab, ppdu_info,
4731 if (tlv_status == HAL_TLV_STATUS_PPDU_DONE) {
4732 rx_mon_stats->status_ppdu_done++;
4733 pmon->mon_ppdu_status = DP_PPDU_STATUS_DONE;
4734 ath11k_dp_rx_mon_dest_process(ar, quota, napi);
4735 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
4737 dev_kfree_skb_any(status_skb);
4741 static int ath11k_dp_mon_process_rx(struct ath11k_base *ab, int mac_id,
4742 struct napi_struct *napi, int budget)
4744 struct ath11k *ar = ab->pdevs[mac_id].ar;
4745 struct ath11k_pdev_dp *dp = &ar->dp;
4746 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4747 int num_buffs_reaped = 0;
4749 num_buffs_reaped = ath11k_dp_rx_reap_mon_status_ring(ar->ab, dp->mac_id, &budget,
4750 &pmon->rx_status_q);
4751 if (num_buffs_reaped)
4752 ath11k_dp_rx_mon_status_process_tlv(ar, budget, napi);
4754 return num_buffs_reaped;
4757 int ath11k_dp_rx_process_mon_rings(struct ath11k_base *ab, int mac_id,
4758 struct napi_struct *napi, int budget)
4760 struct ath11k *ar = ab->pdevs[mac_id].ar;
4763 if (test_bit(ATH11K_FLAG_MONITOR_ENABLED, &ar->monitor_flags))
4764 ret = ath11k_dp_mon_process_rx(ab, mac_id, napi, budget);
4766 ret = ath11k_dp_rx_process_mon_status(ab, mac_id, napi, budget);
4770 static int ath11k_dp_rx_pdev_mon_status_attach(struct ath11k *ar)
4772 struct ath11k_pdev_dp *dp = &ar->dp;
4773 struct ath11k_mon_data *pmon = (struct ath11k_mon_data *)&dp->mon_data;
4775 skb_queue_head_init(&pmon->rx_status_q);
4777 pmon->mon_ppdu_status = DP_PPDU_STATUS_START;
4779 memset(&pmon->rx_mon_stats, 0,
4780 sizeof(pmon->rx_mon_stats));
4784 int ath11k_dp_rx_pdev_mon_attach(struct ath11k *ar)
4786 struct ath11k_pdev_dp *dp = &ar->dp;
4787 struct ath11k_mon_data *pmon = &dp->mon_data;
4788 struct hal_srng *mon_desc_srng = NULL;
4789 struct dp_srng *dp_srng;
4791 u32 n_link_desc = 0;
4793 ret = ath11k_dp_rx_pdev_mon_status_attach(ar);
4795 ath11k_warn(ar->ab, "pdev_mon_status_attach() failed");
4799 dp_srng = &dp->rxdma_mon_desc_ring;
4800 n_link_desc = dp_srng->size /
4801 ath11k_hal_srng_get_entrysize(HAL_RXDMA_MONITOR_DESC);
4803 &ar->ab->hal.srng_list[dp->rxdma_mon_desc_ring.ring_id];
4805 ret = ath11k_dp_link_desc_setup(ar->ab, pmon->link_desc_banks,
4806 HAL_RXDMA_MONITOR_DESC, mon_desc_srng,
4809 ath11k_warn(ar->ab, "mon_link_desc_pool_setup() failed");
4812 pmon->mon_last_linkdesc_paddr = 0;
4813 pmon->mon_last_buf_cookie = DP_RX_DESC_COOKIE_MAX + 1;
4814 spin_lock_init(&pmon->mon_lock);
4818 static int ath11k_dp_mon_link_free(struct ath11k *ar)
4820 struct ath11k_pdev_dp *dp = &ar->dp;
4821 struct ath11k_mon_data *pmon = &dp->mon_data;
4823 ath11k_dp_link_desc_cleanup(ar->ab, pmon->link_desc_banks,
4824 HAL_RXDMA_MONITOR_DESC,
4825 &dp->rxdma_mon_desc_ring);
4829 int ath11k_dp_rx_pdev_mon_detach(struct ath11k *ar)
4831 ath11k_dp_mon_link_free(ar);