From b239910861a456b0a7dcf0c15f08b6af54509d82 Mon Sep 17 00:00:00 2001 From: Francesco Magliocca Date: Thu, 4 Nov 2021 22:47:06 +0100 Subject: [PATCH] Patch rx_desc memory layout --- htt.h | 49 ++++++-------- htt_rx.c | 184 +++++++++++++++++++++++++++++++++++----------------- htt_tx.c | 36 +++-------- hw.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++++- hw.h | 64 ++++++++++++++++++ rx_desc.h | 65 ++++++++++++++++++- 6 files changed, 470 insertions(+), 117 deletions(-) diff --git a/htt.h b/htt.h index ec689e3..612b700 100644 --- a/htt.h +++ b/htt.h @@ -240,14 +240,7 @@ enum htt_rx_ring_flags { #define HTT_RX_RING_FILL_LEVEL (((HTT_RX_RING_SIZE) / 2) - 1) #define HTT_RX_RING_FILL_LEVEL_DUAL_MAC (HTT_RX_RING_SIZE - 1) -struct htt_rx_ring_setup_ring32 { - __le32 fw_idx_shadow_reg_paddr; - __le32 rx_ring_base_paddr; - __le16 rx_ring_len; /* in 4-byte words */ - __le16 rx_ring_bufsize; /* rx skb size - in bytes */ - __le16 flags; /* %HTT_RX_RING_FLAGS_ */ - __le16 fw_idx_init_val; - +struct htt_rx_ring_rx_desc_offsets { /* the following offsets are in 4-byte units */ __le16 mac80211_hdr_offset; __le16 msdu_payload_offset; @@ -261,6 +254,17 @@ struct htt_rx_ring_setup_ring32 { __le16 frag_info_offset; } __packed; +struct htt_rx_ring_setup_ring32 { + __le32 fw_idx_shadow_reg_paddr; + __le32 rx_ring_base_paddr; + __le16 rx_ring_len; /* in 4-byte words */ + __le16 rx_ring_bufsize; /* rx skb size - in bytes */ + __le16 flags; /* %HTT_RX_RING_FLAGS_ */ + __le16 fw_idx_init_val; + + struct htt_rx_ring_rx_desc_offsets offsets; +} __packed; + struct htt_rx_ring_setup_ring64 { __le64 fw_idx_shadow_reg_paddr; __le64 rx_ring_base_paddr; @@ -269,17 +273,7 @@ struct htt_rx_ring_setup_ring64 { __le16 flags; /* %HTT_RX_RING_FLAGS_ */ __le16 fw_idx_init_val; - /* the following offsets are in 4-byte units */ - __le16 mac80211_hdr_offset; - __le16 msdu_payload_offset; - __le16 ppdu_start_offset; - __le16 ppdu_end_offset; - __le16 mpdu_start_offset; - __le16 mpdu_end_offset; - __le16 msdu_start_offset; - __le16 msdu_end_offset; - __le16 rx_attention_offset; - __le16 frag_info_offset; + struct htt_rx_ring_rx_desc_offsets offsets; } __packed; struct htt_rx_ring_setup_hdr { @@ -2187,6 +2181,11 @@ static inline bool ath10k_htt_rx_proc_rx_frag_ind(struct ath10k_htt *htt, /* This structure layout is programmed via rx ring setup * so that FW knows how to transfer the rx descriptor to the host. * Buffers like this are placed on the rx ring. + * Unfortunately, though, QCA6174's firmware doesn't currently behave correctly + * when modifying the structure layout of the rx descriptor + * (even if it correctly programmed during the rx ring setup). + * Therefore we must keep two different memory layouts and use + * ath10k_hw_ops for correctly accessing rx descriptor metadata (msdu_start, msdu_end, etc..). */ struct htt_rx_desc { union { @@ -2196,15 +2195,9 @@ struct htt_rx_desc { struct fw_rx_desc_base fw_desc; u32 pad; } __packed; - struct { - struct rx_attention attention; - struct rx_frag_info frag_info; - struct rx_mpdu_start mpdu_start; - struct rx_msdu_start msdu_start; - struct rx_msdu_end msdu_end; - struct rx_mpdu_end mpdu_end; - struct rx_ppdu_start ppdu_start; - struct rx_ppdu_end ppdu_end; + union { + struct rx_metadata metadata; + struct rx_metadata_for_qca6174 metadata_for_qca6174; } __packed; u8 rx_hdr_status[RX_HTT_HDR_STATUS_LEN]; u8 msdu_payload[]; diff --git a/htt_rx.c b/htt_rx.c index adbaeb6..f3f791f 100644 --- a/htt_rx.c +++ b/htt_rx.c @@ -21,7 +21,7 @@ #define HTT_RX_RING_REFILL_RESCHED_MS 5 -static int ath10k_htt_rx_get_csum_state(struct sk_buff *skb); +static int ath10k_htt_rx_get_csum_state(struct ath10k_hw_params *hw, struct sk_buff *skb); static struct sk_buff * ath10k_htt_rx_find_skb_paddr(struct ath10k *ar, u64 paddr) @@ -128,6 +128,7 @@ static void *ath10k_htt_get_vaddr_ring_64(struct ath10k_htt *htt) static int __ath10k_htt_rx_ring_fill_n(struct ath10k_htt *htt, int num) { + struct ath10k_hw_params *hw = &htt->ar->hw_params; struct htt_rx_desc *rx_desc; struct ath10k_skb_rxcb *rxcb; struct sk_buff *skb; @@ -164,7 +165,7 @@ static int __ath10k_htt_rx_ring_fill_n(struct ath10k_htt *htt, int num) /* Clear rx_desc attention word before posting to Rx ring */ rx_desc = (struct htt_rx_desc *)skb->data; - rx_desc->attention.flags = __cpu_to_le32(0); + ath10k_rx_desc_get_attention(hw, rx_desc)->flags = __cpu_to_le32(0); paddr = dma_map_single(htt->ar->dev, skb->data, skb->len + skb_tailroom(skb), @@ -343,9 +344,14 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt, struct sk_buff_head *amsdu) { struct ath10k *ar = htt->ar; + struct ath10k_hw_params *hw = &ar->hw_params; int msdu_len, msdu_chaining = 0; struct sk_buff *msdu; struct htt_rx_desc *rx_desc; + struct rx_attention *rx_desc_attention; + struct rx_frag_info_common *rx_desc_frag_info_common; + struct rx_msdu_start_common *rx_desc_msdu_start_common; + struct rx_msdu_end_common *rx_desc_msdu_end_common; lockdep_assert_held(&htt->rx_ring.lock); @@ -361,6 +367,10 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt, __skb_queue_tail(amsdu, msdu); rx_desc = (struct htt_rx_desc *)msdu->data; + rx_desc_attention = ath10k_rx_desc_get_attention(hw, rx_desc); + rx_desc_msdu_start_common = ath10k_rx_desc_get_msdu_start(hw, rx_desc); + rx_desc_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rx_desc); + rx_desc_frag_info_common = ath10k_rx_desc_get_frag_info(hw, rx_desc); /* FIXME: we must report msdu payload since this is what caller * expects now @@ -376,18 +386,18 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt, * To prevent the case that we handle a stale Rx descriptor, * just assert for now until we have a way to recover. */ - if (!(__le32_to_cpu(rx_desc->attention.flags) + if (!(__le32_to_cpu(rx_desc_attention->flags) & RX_ATTENTION_FLAGS_MSDU_DONE)) { __skb_queue_purge(amsdu); return -EIO; } - msdu_len_invalid = !!(__le32_to_cpu(rx_desc->attention.flags) + msdu_len_invalid = !!(__le32_to_cpu(rx_desc_attention->flags) & (RX_ATTENTION_FLAGS_MPDU_LENGTH_ERR | RX_ATTENTION_FLAGS_MSDU_LENGTH_ERR)); - msdu_len = MS(__le32_to_cpu(rx_desc->msdu_start.common.info0), + msdu_len = MS(__le32_to_cpu(rx_desc_msdu_start_common->info0), RX_MSDU_START_INFO0_MSDU_LENGTH); - msdu_chained = rx_desc->frag_info.ring2_more_count; + msdu_chained = rx_desc_frag_info_common->ring2_more_count; if (msdu_len_invalid) msdu_len = 0; @@ -411,10 +421,11 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt, msdu_chaining = 1; } - last_msdu = __le32_to_cpu(rx_desc->msdu_end.common.info0) & + last_msdu = __le32_to_cpu(rx_desc_msdu_end_common->info0) & RX_MSDU_END_INFO0_LAST_MSDU; - trace_ath10k_htt_rx_desc(ar, &rx_desc->attention, + // FIXME: why are we skipping the first part of the rx_desc? + trace_ath10k_htt_rx_desc(ar, rx_desc + sizeof(u32), sizeof(*rx_desc) - sizeof(u32)); if (last_msdu) @@ -631,8 +642,10 @@ static int ath10k_htt_rx_pop_paddr32_list(struct ath10k_htt *htt, struct sk_buff_head *list) { struct ath10k *ar = htt->ar; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_in_ord_msdu_desc *msdu_desc = ev->msdu_descs32; struct htt_rx_desc *rxd; + struct rx_attention *rxd_attention; struct sk_buff *msdu; int msdu_count, ret; bool is_offload; @@ -668,6 +681,7 @@ static int ath10k_htt_rx_pop_paddr32_list(struct ath10k_htt *htt, if (!is_offload) { rxd = (void *)msdu->data; + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); trace_ath10k_htt_rx_desc(ar, rxd, sizeof(*rxd)); @@ -675,7 +689,7 @@ static int ath10k_htt_rx_pop_paddr32_list(struct ath10k_htt *htt, skb_pull(msdu, sizeof(*rxd)); skb_put(msdu, __le16_to_cpu(msdu_desc->msdu_len)); - if (!(__le32_to_cpu(rxd->attention.flags) & + if (!(__le32_to_cpu(rxd_attention->flags) & RX_ATTENTION_FLAGS_MSDU_DONE)) { ath10k_warn(htt->ar, "tried to pop an incomplete frame, oops!\n"); return -EIO; @@ -693,8 +707,10 @@ static int ath10k_htt_rx_pop_paddr64_list(struct ath10k_htt *htt, struct sk_buff_head *list) { struct ath10k *ar = htt->ar; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_in_ord_msdu_desc_ext *msdu_desc = ev->msdu_descs64; struct htt_rx_desc *rxd; + struct rx_attention *rxd_attention; struct sk_buff *msdu; int msdu_count, ret; bool is_offload; @@ -729,6 +745,7 @@ static int ath10k_htt_rx_pop_paddr64_list(struct ath10k_htt *htt, if (!is_offload) { rxd = (void *)msdu->data; + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); trace_ath10k_htt_rx_desc(ar, rxd, sizeof(*rxd)); @@ -736,7 +753,7 @@ static int ath10k_htt_rx_pop_paddr64_list(struct ath10k_htt *htt, skb_pull(msdu, sizeof(*rxd)); skb_put(msdu, __le16_to_cpu(msdu_desc->msdu_len)); - if (!(__le32_to_cpu(rxd->attention.flags) & + if (!(__le32_to_cpu(rxd_attention->flags) & RX_ATTENTION_FLAGS_MSDU_DONE)) { ath10k_warn(htt->ar, "tried to pop an incomplete frame, oops!\n"); return -EIO; @@ -944,6 +961,13 @@ static void ath10k_htt_rx_h_rates(struct ath10k *ar, struct ieee80211_rx_status *status, struct htt_rx_desc *rxd) { + struct ath10k_hw_params *hw = &ar->hw_params; + struct rx_attention *rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); + struct rx_mpdu_start *rxd_mpdu_start = ath10k_rx_desc_get_mpdu_start(hw, rxd); + struct rx_mpdu_end *rxd_mpdu_end = ath10k_rx_desc_get_mpdu_end(hw, rxd); + struct rx_msdu_start_common *rxd_msdu_start_common = ath10k_rx_desc_get_msdu_start(hw, rxd); + struct rx_msdu_end_common *rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + struct rx_ppdu_start *rxd_ppdu_start = ath10k_rx_desc_get_ppdu_start(hw, rxd); struct ieee80211_supported_band *sband; u8 cck, rate, bw, sgi, mcs, nss; u8 preamble = 0; @@ -951,9 +975,9 @@ static void ath10k_htt_rx_h_rates(struct ath10k *ar, u32 info1, info2, info3; u32 stbc, nsts_su; - info1 = __le32_to_cpu(rxd->ppdu_start.info1); - info2 = __le32_to_cpu(rxd->ppdu_start.info2); - info3 = __le32_to_cpu(rxd->ppdu_start.info3); + info1 = __le32_to_cpu(rxd_ppdu_start->info1); + info2 = __le32_to_cpu(rxd_ppdu_start->info2); + info3 = __le32_to_cpu(rxd_ppdu_start->info3); preamble = MS(info1, RX_PPDU_START_INFO1_PREAMBLE_TYPE); @@ -1022,20 +1046,20 @@ static void ath10k_htt_rx_h_rates(struct ath10k *ar, if (mcs > 0x09) { ath10k_warn(ar, "invalid MCS received %u\n", mcs); ath10k_warn(ar, "rxd %08x mpdu start %08x %08x msdu start %08x %08x ppdu start %08x %08x %08x %08x %08x\n", - __le32_to_cpu(rxd->attention.flags), - __le32_to_cpu(rxd->mpdu_start.info0), - __le32_to_cpu(rxd->mpdu_start.info1), - __le32_to_cpu(rxd->msdu_start.common.info0), - __le32_to_cpu(rxd->msdu_start.common.info1), - rxd->ppdu_start.info0, - __le32_to_cpu(rxd->ppdu_start.info1), - __le32_to_cpu(rxd->ppdu_start.info2), - __le32_to_cpu(rxd->ppdu_start.info3), - __le32_to_cpu(rxd->ppdu_start.info4)); + __le32_to_cpu(rxd_attention->flags), + __le32_to_cpu(rxd_mpdu_start->info0), + __le32_to_cpu(rxd_mpdu_start->info1), + __le32_to_cpu(rxd_msdu_start_common->info0), + __le32_to_cpu(rxd_msdu_start_common->info1), + rxd_ppdu_start->info0, + __le32_to_cpu(rxd_ppdu_start->info1), + __le32_to_cpu(rxd_ppdu_start->info2), + __le32_to_cpu(rxd_ppdu_start->info3), + __le32_to_cpu(rxd_ppdu_start->info4)); ath10k_warn(ar, "msdu end %08x mpdu end %08x\n", - __le32_to_cpu(rxd->msdu_end.common.info0), - __le32_to_cpu(rxd->mpdu_end.info0)); + __le32_to_cpu(rxd_msdu_end_common->info0), + __le32_to_cpu(rxd_mpdu_end->info0)); ath10k_dbg_dump(ar, ATH10K_DBG_HTT_DUMP, NULL, "rx desc msdu payload: ", @@ -1059,6 +1083,10 @@ static void ath10k_htt_rx_h_rates(struct ath10k *ar, static struct ieee80211_channel * ath10k_htt_rx_h_peer_channel(struct ath10k *ar, struct htt_rx_desc *rxd) { + struct ath10k_hw_params *hw = &ar->hw_params; + struct rx_attention *rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); + struct rx_msdu_end_common *rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + struct rx_mpdu_start *rxd_mpdu_start = ath10k_rx_desc_get_mpdu_start(hw, rxd); struct ath10k_peer *peer; struct ath10k_vif *arvif; struct cfg80211_chan_def def; @@ -1069,15 +1097,15 @@ ath10k_htt_rx_h_peer_channel(struct ath10k *ar, struct htt_rx_desc *rxd) if (!rxd) return NULL; - if (rxd->attention.flags & + if (rxd_attention->flags & __cpu_to_le32(RX_ATTENTION_FLAGS_PEER_IDX_INVALID)) return NULL; - if (!(rxd->msdu_end.common.info0 & + if (!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_FIRST_MSDU))) return NULL; - peer_id = MS(__le32_to_cpu(rxd->mpdu_start.info0), + peer_id = MS(__le32_to_cpu(rxd_mpdu_start->info0), RX_MPDU_START_INFO0_PEER_IDX); peer = ath10k_peer_find_by_id(ar, peer_id); @@ -1167,14 +1195,16 @@ static void ath10k_htt_rx_h_signal(struct ath10k *ar, struct ieee80211_rx_status *status, struct htt_rx_desc *rxd) { + struct ath10k_hw_params *hw = &ar->hw_params; + struct rx_ppdu_start *rxd_ppdu_start = ath10k_rx_desc_get_ppdu_start(hw, rxd); int i; for (i = 0; i < IEEE80211_MAX_CHAINS ; i++) { status->chains &= ~BIT(i); - if (rxd->ppdu_start.rssi_chains[i].pri20_mhz != 0x80) { + if (rxd_ppdu_start->rssi_chains[i].pri20_mhz != 0x80) { status->chain_signal[i] = ATH10K_DEFAULT_NOISE_FLOOR + - rxd->ppdu_start.rssi_chains[i].pri20_mhz; + rxd_ppdu_start->rssi_chains[i].pri20_mhz; status->chains |= BIT(i); } @@ -1182,7 +1212,7 @@ static void ath10k_htt_rx_h_signal(struct ath10k *ar, /* FIXME: Get real NF */ status->signal = ATH10K_DEFAULT_NOISE_FLOOR + - rxd->ppdu_start.rssi_comb; + rxd_ppdu_start->rssi_comb; status->flag &= ~RX_FLAG_NO_SIGNAL_VAL; } @@ -1190,13 +1220,15 @@ static void ath10k_htt_rx_h_mactime(struct ath10k *ar, struct ieee80211_rx_status *status, struct htt_rx_desc *rxd) { + struct ath10k_hw_params *hw = &ar->hw_params; + struct rx_ppdu_end_common *rxd_ppdu_end_common = ath10k_rx_desc_get_ppdu_end(hw, rxd); /* FIXME: TSF is known only at the end of PPDU, in the last MPDU. This * means all prior MSDUs in a PPDU are reported to mac80211 without the * TSF. Is it worth holding frames until end of PPDU is known? * * FIXME: Can we get/compute 64bit TSF? */ - status->mactime = __le32_to_cpu(rxd->ppdu_end.common.tsf_timestamp); + status->mactime = __le32_to_cpu(rxd_ppdu_end_common->tsf_timestamp); status->flag |= RX_FLAG_MACTIME_END; } @@ -1206,7 +1238,9 @@ static void ath10k_htt_rx_h_ppdu(struct ath10k *ar, u32 vdev_id) { struct sk_buff *first; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_attention *rxd_attention; bool is_first_ppdu; bool is_last_ppdu; @@ -1215,10 +1249,11 @@ static void ath10k_htt_rx_h_ppdu(struct ath10k *ar, first = skb_peek(amsdu); rxd = (void *)first->data - sizeof(*rxd); + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); - is_first_ppdu = !!(rxd->attention.flags & + is_first_ppdu = !!(rxd_attention->flags & __cpu_to_le32(RX_ATTENTION_FLAGS_FIRST_MPDU)); - is_last_ppdu = !!(rxd->attention.flags & + is_last_ppdu = !!(rxd_attention->flags & __cpu_to_le32(RX_ATTENTION_FLAGS_LAST_MPDU)); if (is_first_ppdu) { @@ -1357,7 +1392,9 @@ static void ath10k_htt_rx_h_undecap_raw(struct ath10k *ar, const u8 first_hdr[64]) { struct ieee80211_hdr *hdr; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_msdu_end_common *rxd_msdu_end_common; size_t hdr_len; size_t crypto_len; bool is_first; @@ -1367,9 +1404,10 @@ static void ath10k_htt_rx_h_undecap_raw(struct ath10k *ar, u8 *qos; rxd = (void *)msdu->data - sizeof(*rxd); - is_first = !!(rxd->msdu_end.common.info0 & + rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + is_first = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_FIRST_MSDU)); - is_last = !!(rxd->msdu_end.common.info0 & + is_last = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_LAST_MSDU)); /* Delivered decapped frame: @@ -1387,7 +1425,7 @@ static void ath10k_htt_rx_h_undecap_raw(struct ath10k *ar, * error packets. If limit exceeds, hw sends all remaining MSDUs as * a single last MSDU with this msdu limit error set. */ - msdu_limit_err = ath10k_rx_desc_msdu_limit_error(&ar->hw_params, rxd); + msdu_limit_err = ath10k_rx_desc_msdu_limit_error(hw, rxd); /* If MSDU limit error happens, then don't warn on, the partial raw MSDU * without first MSDU is expected in that case, and handled later here. @@ -1537,18 +1575,21 @@ static void *ath10k_htt_rx_h_find_rfc1042(struct ath10k *ar, enum htt_rx_mpdu_encrypt_type enctype) { struct ieee80211_hdr *hdr; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_msdu_end_common *rxd_msdu_end_common; size_t hdr_len, crypto_len; void *rfc1042; bool is_first, is_last, is_amsdu; int bytes_aligned = ar->hw_params.decap_align_bytes; rxd = (void *)msdu->data - sizeof(*rxd); + rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); hdr = (void *)rxd->rx_hdr_status; - is_first = !!(rxd->msdu_end.common.info0 & + is_first = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_FIRST_MSDU)); - is_last = !!(rxd->msdu_end.common.info0 & + is_last = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_LAST_MSDU)); is_amsdu = !(is_first && is_last); @@ -1674,6 +1715,7 @@ static void ath10k_htt_rx_h_undecap(struct ath10k *ar, bool is_decrypted) { struct htt_rx_desc *rxd; + struct rx_msdu_start_common *rxd_msdu_start_common; enum rx_msdu_decap_format decap; /* First msdu's decapped header: @@ -1688,7 +1730,8 @@ static void ath10k_htt_rx_h_undecap(struct ath10k *ar, */ rxd = (void *)msdu->data - sizeof(*rxd); - decap = MS(__le32_to_cpu(rxd->msdu_start.common.info1), + rxd_msdu_start_common = ath10k_rx_desc_get_msdu_start(&ar->hw_params, rxd); + decap = MS(__le32_to_cpu(rxd_msdu_start_common->info1), RX_MSDU_START_INFO1_DECAP_FORMAT); switch (decap) { @@ -1710,17 +1753,21 @@ static void ath10k_htt_rx_h_undecap(struct ath10k *ar, } } -static int ath10k_htt_rx_get_csum_state(struct sk_buff *skb) +static int ath10k_htt_rx_get_csum_state(struct ath10k_hw_params *hw, struct sk_buff *skb) { struct htt_rx_desc *rxd; + struct rx_attention *rxd_attention; + struct rx_msdu_start_common *rxd_msdu_start_common; u32 flags, info; bool is_ip4, is_ip6; bool is_tcp, is_udp; bool ip_csum_ok, tcpudp_csum_ok; rxd = (void *)skb->data - sizeof(*rxd); - flags = __le32_to_cpu(rxd->attention.flags); - info = __le32_to_cpu(rxd->msdu_start.common.info1); + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); + rxd_msdu_start_common = ath10k_rx_desc_get_msdu_start(hw, rxd); + flags = __le32_to_cpu(rxd_attention->flags); + info = __le32_to_cpu(rxd_msdu_start_common->info1); is_ip4 = !!(info & RX_MSDU_START_INFO1_IPV4_PROTO); is_ip6 = !!(info & RX_MSDU_START_INFO1_IPV6_PROTO); @@ -1741,9 +1788,9 @@ static int ath10k_htt_rx_get_csum_state(struct sk_buff *skb) return CHECKSUM_UNNECESSARY; } -static void ath10k_htt_rx_h_csum_offload(struct sk_buff *msdu) +static void ath10k_htt_rx_h_csum_offload(struct ath10k_hw_params *hw, struct sk_buff *msdu) { - msdu->ip_summed = ath10k_htt_rx_get_csum_state(msdu); + msdu->ip_summed = ath10k_htt_rx_get_csum_state(hw, msdu); } static u64 ath10k_htt_rx_h_get_pn(struct ath10k *ar, struct sk_buff *skb, @@ -1835,7 +1882,11 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar, struct sk_buff *first; struct sk_buff *last; struct sk_buff *msdu, *temp; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_attention *rxd_attention; + struct rx_mpdu_start *rxd_mpdu_start; + struct ieee80211_hdr *hdr; enum htt_rx_mpdu_encrypt_type enctype; u8 first_hdr[64]; @@ -1854,11 +1905,13 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar, first = skb_peek(amsdu); rxd = (void *)first->data - sizeof(*rxd); + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); + rxd_mpdu_start = ath10k_rx_desc_get_mpdu_start(hw, rxd); - is_mgmt = !!(rxd->attention.flags & + is_mgmt = !!(rxd_attention->flags & __cpu_to_le32(RX_ATTENTION_FLAGS_MGMT_TYPE)); - enctype = MS(__le32_to_cpu(rxd->mpdu_start.info0), + enctype = MS(__le32_to_cpu(rxd_mpdu_start->info0), RX_MPDU_START_INFO0_ENCRYPT_TYPE); /* First MSDU's Rx descriptor in an A-MSDU contains full 802.11 @@ -1883,7 +1936,8 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar, /* Some attention flags are valid only in the last MSDU. */ last = skb_peek_tail(amsdu); rxd = (void *)last->data - sizeof(*rxd); - attention = __le32_to_cpu(rxd->attention.flags); + rxd_attention = ath10k_rx_desc_get_attention(hw, rxd); + attention = __le32_to_cpu(rxd_attention->flags); has_fcs_err = !!(attention & RX_ATTENTION_FLAGS_FCS_ERR); has_crypto_err = !!(attention & RX_ATTENTION_FLAGS_DECRYPT_ERR); @@ -1971,7 +2025,7 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar, continue; } - ath10k_htt_rx_h_csum_offload(msdu); + ath10k_htt_rx_h_csum_offload(&ar->hw_params, msdu); if (frag && !fill_crypt_header && enctype == HTT_RX_MPDU_ENCRYPT_TKIP_WPA) @@ -2083,12 +2137,17 @@ static void ath10k_htt_rx_h_unchain(struct ath10k *ar, unsigned long *unchain_cnt) { struct sk_buff *first; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_msdu_start_common *rxd_msdu_start_common; + struct rx_frag_info_common *rxd_frag_info; enum rx_msdu_decap_format decap; first = skb_peek(amsdu); rxd = (void *)first->data - sizeof(*rxd); - decap = MS(__le32_to_cpu(rxd->msdu_start.common.info1), + rxd_msdu_start_common = ath10k_rx_desc_get_msdu_start(hw, rxd); + rxd_frag_info = ath10k_rx_desc_get_frag_info(hw, rxd); + decap = MS(__le32_to_cpu(rxd_msdu_start_common->info1), RX_MSDU_START_INFO1_DECAP_FORMAT); /* FIXME: Current unchaining logic can only handle simple case of raw @@ -2097,7 +2156,7 @@ static void ath10k_htt_rx_h_unchain(struct ath10k *ar, * try re-constructing such frames - it'll be pretty much garbage. */ if (decap != RX_MSDU_DECAP_RAW || - skb_queue_len(amsdu) != 1 + rxd->frag_info.ring2_more_count) { + skb_queue_len(amsdu) != 1 + rxd_frag_info->ring2_more_count) { *drop_cnt += skb_queue_len(amsdu); __skb_queue_purge(amsdu); return; @@ -2112,7 +2171,10 @@ static bool ath10k_htt_rx_validate_amsdu(struct ath10k *ar, u8 *subframe_hdr; struct sk_buff *first; bool is_first, is_last; + struct ath10k_hw_params *hw = &ar->hw_params; struct htt_rx_desc *rxd; + struct rx_msdu_end_common *rxd_msdu_end_common; + struct rx_mpdu_start *rxd_mpdu_start; struct ieee80211_hdr *hdr; size_t hdr_len, crypto_len; enum htt_rx_mpdu_encrypt_type enctype; @@ -2121,11 +2183,13 @@ static bool ath10k_htt_rx_validate_amsdu(struct ath10k *ar, first = skb_peek(amsdu); rxd = (void *)first->data - sizeof(*rxd); + rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + rxd_mpdu_start = ath10k_rx_desc_get_mpdu_start(hw, rxd); hdr = (void *)rxd->rx_hdr_status; - is_first = !!(rxd->msdu_end.common.info0 & + is_first = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_FIRST_MSDU)); - is_last = !!(rxd->msdu_end.common.info0 & + is_last = !!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_LAST_MSDU)); /* Return in case of non-aggregated msdu */ @@ -2136,7 +2200,7 @@ static bool ath10k_htt_rx_validate_amsdu(struct ath10k *ar, if (!is_first) return false; - enctype = MS(__le32_to_cpu(rxd->mpdu_start.info0), + enctype = MS(__le32_to_cpu(rxd_mpdu_start->info0), RX_MPDU_START_INFO0_ENCRYPT_TYPE); hdr_len = ieee80211_hdrlen(hdr->frame_control); @@ -3028,11 +3092,13 @@ static void ath10k_htt_rx_delba(struct ath10k *ar, struct htt_resp *resp) spin_unlock_bh(&ar->data_lock); } -static int ath10k_htt_rx_extract_amsdu(struct sk_buff_head *list, +static int ath10k_htt_rx_extract_amsdu(struct ath10k_hw_params *hw, + struct sk_buff_head *list, struct sk_buff_head *amsdu) { struct sk_buff *msdu; struct htt_rx_desc *rxd; + struct rx_msdu_end_common *rxd_msdu_end_common; if (skb_queue_empty(list)) return -ENOBUFS; @@ -3044,14 +3110,16 @@ static int ath10k_htt_rx_extract_amsdu(struct sk_buff_head *list, __skb_queue_tail(amsdu, msdu); rxd = (void *)msdu->data - sizeof(*rxd); - if (rxd->msdu_end.common.info0 & + rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + if (rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_LAST_MSDU)) break; } msdu = skb_peek_tail(amsdu); rxd = (void *)msdu->data - sizeof(*rxd); - if (!(rxd->msdu_end.common.info0 & + rxd_msdu_end_common = ath10k_rx_desc_get_msdu_end(hw, rxd); + if (!(rxd_msdu_end_common->info0 & __cpu_to_le32(RX_MSDU_END_INFO0_LAST_MSDU))) { skb_queue_splice_init(amsdu, list); return -EAGAIN; @@ -3194,7 +3262,7 @@ static int ath10k_htt_rx_in_ord_ind(struct ath10k *ar, struct sk_buff *skb) while (!skb_queue_empty(&list)) { __skb_queue_head_init(&amsdu); - ret = ath10k_htt_rx_extract_amsdu(&list, &amsdu); + ret = ath10k_htt_rx_extract_amsdu(&ar->hw_params, &list, &amsdu); switch (ret) { case 0: /* Note: The in-order indication may report interleaved diff --git a/htt_tx.c b/htt_tx.c index d6b8bdc..7436d73 100644 --- a/htt_tx.c +++ b/htt_tx.c @@ -793,47 +793,26 @@ static int ath10k_htt_send_frag_desc_bank_cfg_64(struct ath10k_htt *htt) return 0; } -static void ath10k_htt_fill_rx_desc_offset_32(void *rx_ring) +static void ath10k_htt_fill_rx_desc_offset_32(struct ath10k_hw_params *hw, void *rx_ring) { struct htt_rx_ring_setup_ring32 *ring = (struct htt_rx_ring_setup_ring32 *)rx_ring; -#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4) - ring->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status)); - ring->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload)); - ring->ppdu_start_offset = __cpu_to_le16(desc_offset(ppdu_start)); - ring->ppdu_end_offset = __cpu_to_le16(desc_offset(ppdu_end)); - ring->mpdu_start_offset = __cpu_to_le16(desc_offset(mpdu_start)); - ring->mpdu_end_offset = __cpu_to_le16(desc_offset(mpdu_end)); - ring->msdu_start_offset = __cpu_to_le16(desc_offset(msdu_start)); - ring->msdu_end_offset = __cpu_to_le16(desc_offset(msdu_end)); - ring->rx_attention_offset = __cpu_to_le16(desc_offset(attention)); - ring->frag_info_offset = __cpu_to_le16(desc_offset(frag_info)); -#undef desc_offset + ath10k_rx_desc_get_offsets(hw, &ring->offsets); } -static void ath10k_htt_fill_rx_desc_offset_64(void *rx_ring) +static void ath10k_htt_fill_rx_desc_offset_64(struct ath10k_hw_params *hw, void *rx_ring) { struct htt_rx_ring_setup_ring64 *ring = (struct htt_rx_ring_setup_ring64 *)rx_ring; -#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4) - ring->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status)); - ring->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload)); - ring->ppdu_start_offset = __cpu_to_le16(desc_offset(ppdu_start)); - ring->ppdu_end_offset = __cpu_to_le16(desc_offset(ppdu_end)); - ring->mpdu_start_offset = __cpu_to_le16(desc_offset(mpdu_start)); - ring->mpdu_end_offset = __cpu_to_le16(desc_offset(mpdu_end)); - ring->msdu_start_offset = __cpu_to_le16(desc_offset(msdu_start)); - ring->msdu_end_offset = __cpu_to_le16(desc_offset(msdu_end)); - ring->rx_attention_offset = __cpu_to_le16(desc_offset(attention)); - ring->frag_info_offset = __cpu_to_le16(desc_offset(frag_info)); -#undef desc_offset + ath10k_rx_desc_get_offsets(hw, &ring->offsets); } static int ath10k_htt_send_rx_ring_cfg_32(struct ath10k_htt *htt) { struct ath10k *ar = htt->ar; + struct ath10k_hw_params *hw = &ar->hw_params; struct sk_buff *skb; struct htt_cmd *cmd; struct htt_rx_ring_setup_ring32 *ring; @@ -893,7 +872,7 @@ static int ath10k_htt_send_rx_ring_cfg_32(struct ath10k_htt *htt) ring->flags = __cpu_to_le16(flags); ring->fw_idx_init_val = __cpu_to_le16(fw_idx); - ath10k_htt_fill_rx_desc_offset_32(ring); + ath10k_htt_fill_rx_desc_offset_32(hw, ring); ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); if (ret) { dev_kfree_skb_any(skb); @@ -906,6 +885,7 @@ static int ath10k_htt_send_rx_ring_cfg_32(struct ath10k_htt *htt) static int ath10k_htt_send_rx_ring_cfg_64(struct ath10k_htt *htt) { struct ath10k *ar = htt->ar; + struct ath10k_hw_params *hw = &ar->hw_params; struct sk_buff *skb; struct htt_cmd *cmd; struct htt_rx_ring_setup_ring64 *ring; @@ -962,7 +942,7 @@ static int ath10k_htt_send_rx_ring_cfg_64(struct ath10k_htt *htt) ring->flags = __cpu_to_le16(flags); ring->fw_idx_init_val = __cpu_to_le16(fw_idx); - ath10k_htt_fill_rx_desc_offset_64(ring); + ath10k_htt_fill_rx_desc_offset_64(hw, ring); ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); if (ret) { dev_kfree_skb_any(skb); diff --git a/hw.c b/hw.c index 57c58af..060012b 100644 --- a/hw.c +++ b/hw.c @@ -11,6 +11,7 @@ #include "hif.h" #include "wmi-ops.h" #include "bmi.h" +#include "rx_desc.h" const struct ath10k_hw_regs qca988x_regs = { .rtc_soc_base_address = 0x00004000, @@ -1129,6 +1130,110 @@ static int ath10k_get_htt_tx_data_rssi_pad(struct htt_resp *resp) return pad_bytes; } +static inline void ath10k_rx_desc_default_get_offsets(struct htt_rx_ring_rx_desc_offsets *off) +{ +/* In the current memory layout, rx metadata are not direct members of htt_rx_desc, + * so we need to get their offset in two steps + */ +#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4) +#define metadata_offset(x) (offsetof(struct rx_metadata, x) / 4) +#define desc_metadata_offset(x) (desc_offset(metadata) + metadata_offset(x)) + off->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status)); + off->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload)); + off->ppdu_start_offset = __cpu_to_le16(desc_metadata_offset(ppdu_start)); + off->ppdu_end_offset = __cpu_to_le16(desc_metadata_offset(ppdu_end)); + off->mpdu_start_offset = __cpu_to_le16(desc_metadata_offset(mpdu_start)); + off->mpdu_end_offset = __cpu_to_le16(desc_metadata_offset(mpdu_end)); + off->msdu_start_offset = __cpu_to_le16(desc_metadata_offset(msdu_start)); + off->msdu_end_offset = __cpu_to_le16(desc_metadata_offset(msdu_end)); + off->rx_attention_offset = __cpu_to_le16(desc_metadata_offset(attention)); + off->frag_info_offset = __cpu_to_le16(desc_metadata_offset(frag_info)); +#undef desc_metadata_offset +#undef metadata_offset +#undef desc_offset +} + +void ath10k_rx_desc_get_offsets(struct ath10k_hw_params *hw, + struct htt_rx_ring_rx_desc_offsets *off) +{ + if(hw->hw_ops->rx_desc_get_offsets) + hw->hw_ops->rx_desc_get_offsets(off); + else + ath10k_rx_desc_default_get_offsets(off); +} + +struct rx_attention * +ath10k_rx_desc_get_attention(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_attention) + return hw->hw_ops->rx_desc_get_attention(rxd); + return &rxd->metadata.attention; +} + +struct rx_frag_info_common * +ath10k_rx_desc_get_frag_info(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_frag_info) + return hw->hw_ops->rx_desc_get_frag_info(rxd); + return &rxd->metadata.frag_info.common; +} + +struct rx_mpdu_start * +ath10k_rx_desc_get_mpdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_mpdu_start) + return hw->hw_ops->rx_desc_get_mpdu_start(rxd); + return &rxd->metadata.mpdu_start; +} + +struct rx_mpdu_end * +ath10k_rx_desc_get_mpdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_mpdu_end) + return hw->hw_ops->rx_desc_get_mpdu_end(rxd); + return &rxd->metadata.mpdu_end; +} + +struct rx_msdu_start_common * +ath10k_rx_desc_get_msdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_msdu_start) + return hw->hw_ops->rx_desc_get_msdu_start(rxd); + return &rxd->metadata.msdu_start.common; +} + +struct rx_msdu_end_common * +ath10k_rx_desc_get_msdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_msdu_end) + return hw->hw_ops->rx_desc_get_msdu_end(rxd); + return &rxd->metadata.msdu_end.common; +} + +struct rx_ppdu_start * +ath10k_rx_desc_get_ppdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_ppdu_start) + return hw->hw_ops->rx_desc_get_ppdu_start(rxd); + return &rxd->metadata.ppdu_start; +} + +struct rx_ppdu_end_common * +ath10k_rx_desc_get_ppdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd) +{ + if(hw->hw_ops->rx_desc_get_ppdu_end) + return hw->hw_ops->rx_desc_get_ppdu_end(rxd); + return &rxd->metadata.ppdu_end.common; +} + const struct ath10k_hw_ops qca988x_ops = { .set_coverage_class = ath10k_hw_qca988x_set_coverage_class, .is_rssi_enable = ath10k_htt_tx_rssi_enable, @@ -1136,13 +1241,13 @@ const struct ath10k_hw_ops qca988x_ops = { static int ath10k_qca99x0_rx_desc_get_l3_pad_bytes(struct htt_rx_desc *rxd) { - return MS(__le32_to_cpu(rxd->msdu_end.qca99x0.info1), + return MS(__le32_to_cpu(rxd->metadata.msdu_end.qca99x0.info1), RX_MSDU_END_INFO1_L3_HDR_PAD); } static bool ath10k_qca99x0_rx_desc_msdu_limit_error(struct htt_rx_desc *rxd) { - return !!(rxd->msdu_end.common.info0 & + return !!(rxd->metadata.msdu_end.common.info0 & __cpu_to_le32(RX_MSDU_END_INFO0_MSDU_LIMIT_ERR)); } @@ -1152,10 +1257,90 @@ const struct ath10k_hw_ops qca99x0_ops = { .is_rssi_enable = ath10k_htt_tx_rssi_enable, }; +static void ath10k_rx_desc_qca6174_get_offsets(struct htt_rx_ring_rx_desc_offsets *off) +{ +/* In the current memory layout, rx metadata are not direct members of htt_rx_desc, + * so we need to get their offset in two steps + */ +#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4) +#define metadata_offset(x) (offsetof(struct rx_metadata_for_qca6174, x) / 4) +#define desc_metadata_offset(x) (desc_offset(metadata_for_qca6174) + metadata_offset(x)) + off->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status)); + off->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload)); + off->ppdu_start_offset = __cpu_to_le16(desc_metadata_offset(ppdu_start)); + off->ppdu_end_offset = __cpu_to_le16(desc_metadata_offset(ppdu_end)); + off->mpdu_start_offset = __cpu_to_le16(desc_metadata_offset(mpdu_start)); + off->mpdu_end_offset = __cpu_to_le16(desc_metadata_offset(mpdu_end)); + off->msdu_start_offset = __cpu_to_le16(desc_metadata_offset(msdu_start)); + off->msdu_end_offset = __cpu_to_le16(desc_metadata_offset(msdu_end)); + off->rx_attention_offset = __cpu_to_le16(desc_metadata_offset(attention)); + off->frag_info_offset = __cpu_to_le16(desc_metadata_offset(frag_info)); +#undef desc_metadata_offset +#undef metadata_offset +#undef desc_offset +} + +static struct rx_attention * +ath10k_rx_desc_qca6174_get_attention(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.attention; +} + +static struct rx_frag_info_common * +ath10k_rx_desc_qca6174_get_frag_info(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.frag_info.common; +} + +static struct rx_mpdu_start * +ath10k_rx_desc_qca6174_get_mpdu_start(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.mpdu_start; +} + +static struct rx_mpdu_end * +ath10k_rx_desc_qca6174_get_mpdu_end(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.mpdu_end; +} + +static struct rx_msdu_start_common * +ath10k_rx_desc_qca6174_get_msdu_start(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.msdu_start.common; +} + +static struct rx_msdu_end_common * +ath10k_rx_desc_qca6174_get_msdu_end(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.msdu_end.common; +} + +static struct rx_ppdu_start * +ath10k_rx_desc_qca6174_get_ppdu_start(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.ppdu_start; +} + +static struct rx_ppdu_end_common * +ath10k_rx_desc_qca6174_get_ppdu_end(struct htt_rx_desc *rxd) +{ + return &rxd->metadata_for_qca6174.ppdu_end.common; +} + const struct ath10k_hw_ops qca6174_ops = { .set_coverage_class = ath10k_hw_qca988x_set_coverage_class, .enable_pll_clk = ath10k_hw_qca6174_enable_pll_clock, .is_rssi_enable = ath10k_htt_tx_rssi_enable, + .rx_desc_get_offsets = ath10k_rx_desc_qca6174_get_offsets, + .rx_desc_get_attention = ath10k_rx_desc_qca6174_get_attention, + .rx_desc_get_frag_info = ath10k_rx_desc_qca6174_get_frag_info, + .rx_desc_get_mpdu_start = ath10k_rx_desc_qca6174_get_mpdu_start, + .rx_desc_get_mpdu_end = ath10k_rx_desc_qca6174_get_mpdu_end, + .rx_desc_get_msdu_start = ath10k_rx_desc_qca6174_get_msdu_start, + .rx_desc_get_msdu_end = ath10k_rx_desc_qca6174_get_msdu_end, + .rx_desc_get_ppdu_start = ath10k_rx_desc_qca6174_get_ppdu_start, + .rx_desc_get_ppdu_end = ath10k_rx_desc_qca6174_get_ppdu_end, }; const struct ath10k_hw_ops qca6174_sdio_ops = { diff --git a/hw.h b/hw.h index 6b03c77..3e3aee7 100644 --- a/hw.h +++ b/hw.h @@ -630,6 +630,15 @@ struct ath10k_hw_params { struct htt_rx_desc; struct htt_resp; struct htt_data_tx_completion_ext; +struct htt_rx_ring_rx_desc_offsets; +struct rx_attention; +struct rx_frag_info_common; +struct rx_mpdu_start; +struct rx_mpdu_end; +struct rx_msdu_start_common; +struct rx_msdu_end_common; +struct rx_ppdu_start; +struct rx_ppdu_end_common; /* Defines needed for Rx descriptor abstraction */ struct ath10k_hw_ops { @@ -639,6 +648,16 @@ struct ath10k_hw_ops { bool (*rx_desc_get_msdu_limit_error)(struct htt_rx_desc *rxd); int (*tx_data_rssi_pad_bytes)(struct htt_resp *htt); int (*is_rssi_enable)(struct htt_resp *resp); + + void (*rx_desc_get_offsets)(struct htt_rx_ring_rx_desc_offsets *offs); + struct rx_attention *(*rx_desc_get_attention)(struct htt_rx_desc *rxd); + struct rx_frag_info_common *(*rx_desc_get_frag_info)(struct htt_rx_desc *rxd); + struct rx_mpdu_start *(*rx_desc_get_mpdu_start)(struct htt_rx_desc *rxd); + struct rx_mpdu_end *(*rx_desc_get_mpdu_end)(struct htt_rx_desc *rxd); + struct rx_msdu_start_common *(*rx_desc_get_msdu_start)(struct htt_rx_desc *rxd); + struct rx_msdu_end_common *(*rx_desc_get_msdu_end)(struct htt_rx_desc *rxd); + struct rx_ppdu_start *(*rx_desc_get_ppdu_start)(struct htt_rx_desc *rxd); + struct rx_ppdu_end_common *(*rx_desc_get_ppdu_end)(struct htt_rx_desc *rxd); }; extern const struct ath10k_hw_ops qca988x_ops; @@ -685,6 +704,51 @@ ath10k_is_rssi_enable(struct ath10k_hw_params *hw, return 0; } + +void ath10k_rx_desc_get_offsets(struct ath10k_hw_params *hw, + struct htt_rx_ring_rx_desc_offsets *off); + + +struct rx_attention * +ath10k_rx_desc_get_attention(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_frag_info_common * +ath10k_rx_desc_get_frag_info(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_mpdu_start * +ath10k_rx_desc_get_mpdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_mpdu_end * +ath10k_rx_desc_get_mpdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_msdu_start_common * +ath10k_rx_desc_get_msdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_msdu_end_common * +ath10k_rx_desc_get_msdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_ppdu_start * +ath10k_rx_desc_get_ppdu_start(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + +struct rx_ppdu_end_common * +ath10k_rx_desc_get_ppdu_end(struct ath10k_hw_params *hw, + struct htt_rx_desc *rxd); + + /* Target specific defines for MAIN firmware */ #define TARGET_NUM_VDEVS 8 #define TARGET_NUM_PEER_AST 2 diff --git a/rx_desc.h b/rx_desc.h index 705b629..20b8170 100644 --- a/rx_desc.h +++ b/rx_desc.h @@ -196,17 +196,31 @@ struct rx_attention { * descriptor. */ -struct rx_frag_info { +struct rx_frag_info_common { u8 ring0_more_count; u8 ring1_more_count; u8 ring2_more_count; u8 ring3_more_count; +} __packed; + +struct rx_frag_info_wcn3990 { u8 ring4_more_count; u8 ring5_more_count; u8 ring6_more_count; u8 ring7_more_count; } __packed; +struct rx_frag_info { + struct rx_frag_info_common common; + union { + struct rx_frag_info_wcn3990 wcn3990; + } __packed; +} __packed; + +struct rx_frag_info_for_qca6174 { + struct rx_frag_info_common common; +} __packed; + /* * ring0_more_count * Indicates the number of more buffers associated with RX DMA @@ -479,6 +493,13 @@ struct rx_msdu_start { } __packed; } __packed; +struct rx_msdu_start_for_qca6174 { + struct rx_msdu_start_common common; + union { + struct rx_msdu_start_qca99x0 qca99x0; + } __packed; +} __packed; + /* * msdu_length * MSDU length in bytes after decapsulation. This field is @@ -617,6 +638,13 @@ struct rx_msdu_end { } __packed; } __packed; +struct rx_msdu_end_for_qca6174 { + struct rx_msdu_end_common common; + union { + struct rx_msdu_end_qca99x0 qca99x0; + } __packed; +} __packed; + /* *ip_hdr_chksum * This can include the IP header checksum or the pseudo header @@ -1144,6 +1172,16 @@ struct rx_ppdu_end { } __packed; } __packed; +struct rx_ppdu_end_for_qca6174 { + struct rx_ppdu_end_common common; + union { + struct rx_ppdu_end_qca988x qca988x; + struct rx_ppdu_end_qca6174 qca6174; + struct rx_ppdu_end_qca99x0 qca99x0; + struct rx_ppdu_end_qca9984 qca9984; + } __packed; +} __packed; + /* * evm_p0 * EVM for pilot 0. Contain EVM for streams: 0, 1, 2 and 3. @@ -1263,6 +1301,31 @@ struct rx_ppdu_end { * to 0. */ +struct rx_metadata { + struct rx_attention attention; + struct rx_frag_info frag_info; + struct rx_mpdu_start mpdu_start; + struct rx_msdu_start msdu_start; + struct rx_msdu_end msdu_end; + struct rx_mpdu_end mpdu_end; + struct rx_ppdu_start ppdu_start; + struct rx_ppdu_end ppdu_end; +} __packed; + +/* QCA6174's dedicated rx descriptor metadata to make sure the firmware + * works correctly. + */ +struct rx_metadata_for_qca6174 { + struct rx_attention attention; + struct rx_frag_info_for_qca6174 frag_info; + struct rx_mpdu_start mpdu_start; + struct rx_msdu_start_for_qca6174 msdu_start; + struct rx_msdu_end_for_qca6174 msdu_end; + struct rx_mpdu_end mpdu_end; + struct rx_ppdu_start ppdu_start; + struct rx_ppdu_end_for_qca6174 ppdu_end; +} __packed; + #define FW_RX_DESC_INFO0_DISCARD BIT(0) #define FW_RX_DESC_INFO0_FORWARD BIT(1) #define FW_RX_DESC_INFO0_INSPECT BIT(5)