From 27d6b43bfb8e7340187d691e74332c90bac48fed Mon Sep 17 00:00:00 2001 From: Rakesh Pillai Date: Tue, 16 Feb 2021 23:33:36 -0800 Subject: [PATCH] qcacmn: HAL RX-TLV changes for beryllium Add HAL rx tlv changes for WCN7850 Change-Id: Ie76c608ed57c6a4f8adac97e1efc7888d2036f52 CRs-Fixed: 2891049 --- dp/wifi3.0/be/dp_be.c | 116 ++ dp/wifi3.0/dp_internal.h | 16 +- dp/wifi3.0/dp_main.c | 179 +-- dp/wifi3.0/dp_rx.c | 151 +-- dp/wifi3.0/dp_types.h | 6 + dp/wifi3.0/li/dp_li.c | 172 +++ dp/wifi3.0/li/dp_li_tx.c | 2 + hal/wifi3.0/be/hal_be_generic_api.h | 48 +- hal/wifi3.0/be/hal_be_rx_tlv.h | 1848 +++++++++++++++++++++++++++ hal/wifi3.0/wcn7850/hal_7850.c | 55 +- 10 files changed, 2294 insertions(+), 299 deletions(-) create mode 100644 hal/wifi3.0/be/hal_be_rx_tlv.h diff --git a/dp/wifi3.0/be/dp_be.c b/dp/wifi3.0/be/dp_be.c index 58ee0d4b5c..35a5924789 100644 --- a/dp/wifi3.0/be/dp_be.c +++ b/dp/wifi3.0/be/dp_be.c @@ -15,6 +15,9 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ + +#include +#include #include "dp_be.h" #include "dp_be_tx.h" #include "dp_be_rx.h" @@ -96,6 +99,117 @@ qdf_size_t dp_get_soc_context_size_be(void) return sizeof(struct dp_soc_be); } +/** + * dp_rxdma_ring_sel_cfg_be() - Setup RXDMA ring config + * @soc: Common DP soc handle + * + * Return: QDF_STATUS + */ +static QDF_STATUS +dp_rxdma_ring_sel_cfg_be(struct dp_soc *soc) +{ + int i; + int mac_id; + struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; + struct dp_srng *rx_mac_srng; + QDF_STATUS status = QDF_STATUS_SUCCESS; + + /* + * In Beryllium chipset msdu_start, mpdu_end + * and rx_attn are part of msdu_end/mpdu_start + */ + htt_tlv_filter.msdu_start = 0; + htt_tlv_filter.mpdu_end = 0; + htt_tlv_filter.attention = 0; + htt_tlv_filter.mpdu_start = 1; + htt_tlv_filter.msdu_end = 1; + htt_tlv_filter.packet = 1; + htt_tlv_filter.packet_header = 1; + + htt_tlv_filter.ppdu_start = 0; + htt_tlv_filter.ppdu_end = 0; + htt_tlv_filter.ppdu_end_user_stats = 0; + htt_tlv_filter.ppdu_end_user_stats_ext = 0; + htt_tlv_filter.ppdu_end_status_done = 0; + htt_tlv_filter.enable_fp = 1; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_mo = 0; + + htt_tlv_filter.fp_mgmt_filter = 0; + htt_tlv_filter.fp_ctrl_filter = FILTER_CTRL_BA_REQ; + htt_tlv_filter.fp_data_filter = (FILTER_DATA_UCAST | + FILTER_DATA_MCAST | + FILTER_DATA_DATA); + htt_tlv_filter.mo_mgmt_filter = 0; + htt_tlv_filter.mo_ctrl_filter = 0; + htt_tlv_filter.mo_data_filter = 0; + htt_tlv_filter.md_data_filter = 0; + + htt_tlv_filter.offset_valid = true; + + /* Not subscribing to mpdu_end, msdu_start and rx_attn */ + htt_tlv_filter.rx_mpdu_end_offset = 0; + htt_tlv_filter.rx_msdu_start_offset = 0; + htt_tlv_filter.rx_attn_offset = 0; + + htt_tlv_filter.rx_packet_offset = soc->rx_pkt_tlv_size; + htt_tlv_filter.rx_header_offset = + hal_rx_pkt_tlv_offset_get(soc->hal_soc); + htt_tlv_filter.rx_mpdu_start_offset = + hal_rx_mpdu_start_offset_get(soc->hal_soc); + htt_tlv_filter.rx_msdu_end_offset = + hal_rx_msdu_end_offset_get(soc->hal_soc); + + dp_info("TLV subscription\n" + "msdu_start %d, mpdu_end %d, attention %d" + "mpdu_start %d, msdu_end %d, pkt_hdr %d, pkt %d\n" + "TLV offsets\n" + "msdu_start %d, mpdu_end %d, attention %d" + "mpdu_start %d, msdu_end %d, pkt_hdr %d, pkt %d\n", + htt_tlv_filter.msdu_start, + htt_tlv_filter.mpdu_end, + htt_tlv_filter.attention, + htt_tlv_filter.mpdu_start, + htt_tlv_filter.msdu_end, + htt_tlv_filter.packet_header, + htt_tlv_filter.packet, + htt_tlv_filter.rx_msdu_start_offset, + htt_tlv_filter.rx_mpdu_end_offset, + htt_tlv_filter.rx_attn_offset, + htt_tlv_filter.rx_mpdu_start_offset, + htt_tlv_filter.rx_msdu_end_offset, + htt_tlv_filter.rx_header_offset, + htt_tlv_filter.rx_packet_offset); + + for (i = 0; i < MAX_PDEV_CNT; i++) { + struct dp_pdev *pdev = soc->pdev_list[i]; + + if (!pdev) + continue; + + for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) { + int mac_for_pdev = + dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); + /* + * Obtain lmac id from pdev to access the LMAC ring + * in soc context + */ + int lmac_id = + dp_get_lmac_id_for_pdev_id(soc, mac_id, + pdev->pdev_id); + + rx_mac_srng = dp_get_rxdma_ring(pdev, lmac_id); + htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, + rx_mac_srng->hal_srng, + RXDMA_BUF, RX_DATA_BUFFER_SIZE, + &htt_tlv_filter); + } + } + return status; + +} + void dp_initialize_arch_ops_be(struct dp_arch_ops *arch_ops) { arch_ops->tx_hw_enqueue = dp_tx_hw_enqueue_be; @@ -110,4 +224,6 @@ void dp_initialize_arch_ops_be(struct dp_arch_ops *arch_ops) arch_ops->txrx_vdev_detach = dp_vdev_detach_be; arch_ops->tx_comp_get_params_from_hal_desc = dp_tx_comp_get_params_from_hal_desc_be; + arch_ops->dp_rxdma_ring_sel_cfg = dp_rxdma_ring_sel_cfg_be; + } diff --git a/dp/wifi3.0/dp_internal.h b/dp/wifi3.0/dp_internal.h index 812177b5ae..10bec34201 100644 --- a/dp/wifi3.0/dp_internal.h +++ b/dp/wifi3.0/dp_internal.h @@ -421,6 +421,20 @@ static inline void dp_wds_ext_peer_init(struct dp_peer *peer) } #endif /* QCA_SUPPORT_WDS_EXTENDED */ +#ifdef QCA_HOST2FW_RXBUF_RING +static inline +struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) +{ + return &pdev->rx_mac_buf_ring[lmac_id]; +} +#else +static inline +struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) +{ + return &pdev->soc->rx_refill_buf_ring[lmac_id]; +} +#endif + /** * The lmac ID for a particular channel band is fixed. * 2.4GHz band uses lmac_id = 1 @@ -2440,7 +2454,7 @@ static inline uint32_t dp_history_get_next_index(qdf_atomic_t *curr_idx, * * Return: None */ -void dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding); +void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding); /** * dp_soc_is_full_mon_enable () - Return if full monitor mode is enabled diff --git a/dp/wifi3.0/dp_main.c b/dp/wifi3.0/dp_main.c index c662ad217a..402ffd7cb8 100644 --- a/dp/wifi3.0/dp_main.c +++ b/dp/wifi3.0/dp_main.c @@ -5461,18 +5461,6 @@ static QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc, } #endif -#ifdef QCA_HOST2FW_RXBUF_RING -static struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) -{ - return &pdev->rx_mac_buf_ring[lmac_id]; -} -#else -static struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) -{ - return &pdev->soc->rx_refill_buf_ring[lmac_id]; -} -#endif - /* * dp_rxdma_ring_config() - configure the RX DMA rings * @@ -5646,169 +5634,6 @@ static QDF_STATUS dp_rxdma_ring_config(struct dp_soc *soc) } #endif -#ifdef NO_RX_PKT_HDR_TLV -static QDF_STATUS -dp_rxdma_ring_sel_cfg(struct dp_soc *soc) -{ - int i; - int mac_id; - struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; - QDF_STATUS status = QDF_STATUS_SUCCESS; - - htt_tlv_filter.mpdu_start = 1; - htt_tlv_filter.msdu_start = 1; - htt_tlv_filter.mpdu_end = 1; - htt_tlv_filter.msdu_end = 1; - htt_tlv_filter.attention = 1; - htt_tlv_filter.packet = 1; - htt_tlv_filter.packet_header = 0; - - htt_tlv_filter.ppdu_start = 0; - htt_tlv_filter.ppdu_end = 0; - htt_tlv_filter.ppdu_end_user_stats = 0; - htt_tlv_filter.ppdu_end_user_stats_ext = 0; - htt_tlv_filter.ppdu_end_status_done = 0; - htt_tlv_filter.enable_fp = 1; - htt_tlv_filter.enable_md = 0; - htt_tlv_filter.enable_md = 0; - htt_tlv_filter.enable_mo = 0; - - htt_tlv_filter.fp_mgmt_filter = 0; - htt_tlv_filter.fp_ctrl_filter = FILTER_CTRL_BA_REQ; - htt_tlv_filter.fp_data_filter = (FILTER_DATA_UCAST | - FILTER_DATA_MCAST | - FILTER_DATA_DATA); - htt_tlv_filter.mo_mgmt_filter = 0; - htt_tlv_filter.mo_ctrl_filter = 0; - htt_tlv_filter.mo_data_filter = 0; - htt_tlv_filter.md_data_filter = 0; - - htt_tlv_filter.offset_valid = true; - - htt_tlv_filter.rx_packet_offset = RX_PKT_TLVS_LEN; - /*Not subscribing rx_pkt_header*/ - htt_tlv_filter.rx_header_offset = 0; - htt_tlv_filter.rx_mpdu_start_offset = - hal_rx_mpdu_start_offset_get(soc->hal_soc); - htt_tlv_filter.rx_mpdu_end_offset = - hal_rx_mpdu_end_offset_get(soc->hal_soc); - htt_tlv_filter.rx_msdu_start_offset = - hal_rx_msdu_start_offset_get(soc->hal_soc); - htt_tlv_filter.rx_msdu_end_offset = - hal_rx_msdu_end_offset_get(soc->hal_soc); - htt_tlv_filter.rx_attn_offset = - hal_rx_attn_offset_get(soc->hal_soc); - - for (i = 0; i < MAX_PDEV_CNT; i++) { - struct dp_pdev *pdev = soc->pdev_list[i]; - - if (!pdev) - continue; - - for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) { - int mac_for_pdev = - dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); - /* - * Obtain lmac id from pdev to access the LMAC ring - * in soc context - */ - int lmac_id = - dp_get_lmac_id_for_pdev_id(soc, mac_id, - pdev->pdev_id); - - htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, - soc->rx_refill_buf_ring[lmac_id]. - hal_srng, - RXDMA_BUF, RX_DATA_BUFFER_SIZE, - &htt_tlv_filter); - } - } - return status; -} -#else - -static QDF_STATUS -dp_rxdma_ring_sel_cfg(struct dp_soc *soc) -{ - int i; - int mac_id; - struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; - struct dp_srng *rx_mac_srng; - QDF_STATUS status = QDF_STATUS_SUCCESS; - - htt_tlv_filter.mpdu_start = 1; - htt_tlv_filter.msdu_start = 1; - htt_tlv_filter.mpdu_end = 1; - htt_tlv_filter.msdu_end = 1; - htt_tlv_filter.attention = 1; - htt_tlv_filter.packet = 1; - htt_tlv_filter.packet_header = 1; - - htt_tlv_filter.ppdu_start = 0; - htt_tlv_filter.ppdu_end = 0; - htt_tlv_filter.ppdu_end_user_stats = 0; - htt_tlv_filter.ppdu_end_user_stats_ext = 0; - htt_tlv_filter.ppdu_end_status_done = 0; - htt_tlv_filter.enable_fp = 1; - htt_tlv_filter.enable_md = 0; - htt_tlv_filter.enable_md = 0; - htt_tlv_filter.enable_mo = 0; - - htt_tlv_filter.fp_mgmt_filter = 0; - htt_tlv_filter.fp_ctrl_filter = FILTER_CTRL_BA_REQ; - htt_tlv_filter.fp_data_filter = (FILTER_DATA_UCAST | - FILTER_DATA_MCAST | - FILTER_DATA_DATA); - htt_tlv_filter.mo_mgmt_filter = 0; - htt_tlv_filter.mo_ctrl_filter = 0; - htt_tlv_filter.mo_data_filter = 0; - htt_tlv_filter.md_data_filter = 0; - - htt_tlv_filter.offset_valid = true; - - htt_tlv_filter.rx_packet_offset = RX_PKT_TLVS_LEN; - htt_tlv_filter.rx_header_offset = - hal_rx_pkt_tlv_offset_get(soc->hal_soc); - htt_tlv_filter.rx_mpdu_start_offset = - hal_rx_mpdu_start_offset_get(soc->hal_soc); - htt_tlv_filter.rx_mpdu_end_offset = - hal_rx_mpdu_end_offset_get(soc->hal_soc); - htt_tlv_filter.rx_msdu_start_offset = - hal_rx_msdu_start_offset_get(soc->hal_soc); - htt_tlv_filter.rx_msdu_end_offset = - hal_rx_msdu_end_offset_get(soc->hal_soc); - htt_tlv_filter.rx_attn_offset = - hal_rx_attn_offset_get(soc->hal_soc); - - for (i = 0; i < MAX_PDEV_CNT; i++) { - struct dp_pdev *pdev = soc->pdev_list[i]; - - if (!pdev) - continue; - - for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) { - int mac_for_pdev = - dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); - /* - * Obtain lmac id from pdev to access the LMAC ring - * in soc context - */ - int lmac_id = - dp_get_lmac_id_for_pdev_id(soc, mac_id, - pdev->pdev_id); - - rx_mac_srng = dp_get_rxdma_ring(pdev, lmac_id); - htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, - rx_mac_srng->hal_srng, - RXDMA_BUF, RX_DATA_BUFFER_SIZE, - &htt_tlv_filter); - } - } - return status; - -} -#endif - /* * dp_rx_target_fst_config() - configure the RXOLE Flow Search Engine * @@ -5927,7 +5752,7 @@ dp_soc_attach_target_wifi3(struct cdp_soc_t *cdp_soc) return status; } - status = dp_rxdma_ring_sel_cfg(soc); + status = soc->arch_ops.dp_rxdma_ring_sel_cfg(soc); if (status != QDF_STATUS_SUCCESS) { dp_err("Failed to send htt ring config message to target"); return status; @@ -12906,6 +12731,8 @@ dp_soc_attach(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, soc->ctrl_psoc = ctrl_psoc; soc->osdev = qdf_osdev; soc->num_hw_dscp_tid_map = HAL_MAX_HW_DSCP_TID_MAPS; + hal_rx_get_tlv_size(soc->hal_soc, &soc->rx_pkt_tlv_size, + &soc->rx_mon_pkt_tlv_size); dp_configure_arch_ops(soc); diff --git a/dp/wifi3.0/dp_rx.c b/dp/wifi3.0/dp_rx.c index e90b15f215..883274f40c 100644 --- a/dp/wifi3.0/dp_rx.c +++ b/dp/wifi3.0/dp_rx.c @@ -775,7 +775,7 @@ void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf, center_chan_freq); } rx_info->rs_channel = primary_chan_num; - pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr); + pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr); rate_mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr); bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr); nss = hal_rx_msdu_start_nss_get(vdev->pdev->soc->hal_soc, rx_tlv_hdr); @@ -937,9 +937,7 @@ uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu, struct ieee80211_frame *wh; qdf_nbuf_t curr_nbuf, next_nbuf; uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu); - uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr); - - rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr); + uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr); if (!HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, rx_tlv_hdr)) { dp_rx_debug("%pK: Drop decapped frames", soc); @@ -995,7 +993,7 @@ uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu, out: msg.wh = wh; - qdf_nbuf_pull_head(mpdu, RX_PKT_TLVS_LEN); + qdf_nbuf_pull_head(mpdu, soc->rx_pkt_tlv_size); msg.nbuf = mpdu; msg.vdev_id = vdev->vdev_id; @@ -1058,7 +1056,7 @@ uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu, struct dp_vdev *vdev = NULL; struct ieee80211_frame *wh; uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu); - uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr); + uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr); wh = (struct ieee80211_frame *)rx_pkt_hdr; @@ -1138,23 +1136,24 @@ void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc, /** * dp_rx_print_offload_info() - Print offload info from RX TLV * @soc: dp soc handle - * @rx_tlv: RX TLV for which offload information is to be printed + * @msdu: MSDU for which the offload info is to be printed * * Return: None */ -static void dp_rx_print_offload_info(struct dp_soc *soc, uint8_t *rx_tlv) +static void dp_rx_print_offload_info(struct dp_soc *soc, + qdf_nbuf_t msdu) { dp_verbose_debug("----------------------RX DESC LRO/GRO----------------------"); - dp_verbose_debug("lro_eligible 0x%x", HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv)); - dp_verbose_debug("pure_ack 0x%x", HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv)); - dp_verbose_debug("chksum 0x%x", hal_rx_tlv_get_tcp_chksum(soc->hal_soc, - rx_tlv)); - dp_verbose_debug("TCP seq num 0x%x", HAL_RX_TLV_GET_TCP_SEQ(rx_tlv)); - dp_verbose_debug("TCP ack num 0x%x", HAL_RX_TLV_GET_TCP_ACK(rx_tlv)); - dp_verbose_debug("TCP window 0x%x", HAL_RX_TLV_GET_TCP_WIN(rx_tlv)); - dp_verbose_debug("TCP protocol 0x%x", HAL_RX_TLV_GET_TCP_PROTO(rx_tlv)); - dp_verbose_debug("TCP offset 0x%x", HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv)); - dp_verbose_debug("toeplitz 0x%x", HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv)); + dp_verbose_debug("lro_eligible 0x%x", + QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu)); + dp_verbose_debug("pure_ack 0x%x", QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu)); + dp_verbose_debug("chksum 0x%x", QDF_NBUF_CB_RX_TCP_CHKSUM(msdu)); + dp_verbose_debug("TCP seq num 0x%x", QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu)); + dp_verbose_debug("TCP ack num 0x%x", QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu)); + dp_verbose_debug("TCP window 0x%x", QDF_NBUF_CB_RX_TCP_WIN(msdu)); + dp_verbose_debug("TCP protocol 0x%x", QDF_NBUF_CB_RX_TCP_PROTO(msdu)); + dp_verbose_debug("TCP offset 0x%x", QDF_NBUF_CB_RX_TCP_OFFSET(msdu)); + dp_verbose_debug("toeplitz 0x%x", QDF_NBUF_CB_RX_FLOW_ID(msdu)); dp_verbose_debug("---------------------------------------------------------"); } @@ -1171,38 +1170,31 @@ static void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv, qdf_nbuf_t msdu, uint32_t *rx_ol_pkt_cnt) { + struct hal_offload_info offload_info; + if (!wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx)) return; /* Filling up RX offload info only for TCP packets */ - if (!HAL_RX_TLV_GET_TCP_PROTO(rx_tlv)) + if (hal_rx_tlv_get_offload_info(soc->hal_soc, rx_tlv, &offload_info)) return; *rx_ol_pkt_cnt = *rx_ol_pkt_cnt + 1; - QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = - HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv); - QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) = - HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv); + QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = offload_info.lro_eligible; + QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) = offload_info.tcp_pure_ack; QDF_NBUF_CB_RX_TCP_CHKSUM(msdu) = hal_rx_tlv_get_tcp_chksum(soc->hal_soc, rx_tlv); - QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu) = - HAL_RX_TLV_GET_TCP_SEQ(rx_tlv); - QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu) = - HAL_RX_TLV_GET_TCP_ACK(rx_tlv); - QDF_NBUF_CB_RX_TCP_WIN(msdu) = - HAL_RX_TLV_GET_TCP_WIN(rx_tlv); - QDF_NBUF_CB_RX_TCP_PROTO(msdu) = - HAL_RX_TLV_GET_TCP_PROTO(rx_tlv); - QDF_NBUF_CB_RX_IPV6_PROTO(msdu) = - HAL_RX_TLV_GET_IPV6(rx_tlv); - QDF_NBUF_CB_RX_TCP_OFFSET(msdu) = - HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv); - QDF_NBUF_CB_RX_FLOW_ID(msdu) = - HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv); + QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu) = offload_info.tcp_seq_num; + QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu) = offload_info.tcp_ack_num; + QDF_NBUF_CB_RX_TCP_WIN(msdu) = offload_info.tcp_win; + QDF_NBUF_CB_RX_TCP_PROTO(msdu) = offload_info.tcp_proto; + QDF_NBUF_CB_RX_IPV6_PROTO(msdu) = offload_info.ipv6_proto; + QDF_NBUF_CB_RX_TCP_OFFSET(msdu) = offload_info.tcp_offset; + QDF_NBUF_CB_RX_FLOW_ID(msdu) = offload_info.flow_id; - dp_rx_print_offload_info(soc, rx_tlv); + dp_rx_print_offload_info(soc, msdu); } #else static void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv, @@ -1214,24 +1206,26 @@ static void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv, /** * dp_rx_adjust_nbuf_len() - set appropriate msdu length in nbuf. * + * @soc: DP soc handle * @nbuf: pointer to msdu. * @mpdu_len: mpdu length * * Return: returns true if nbuf is last msdu of mpdu else retuns false. */ -static inline bool dp_rx_adjust_nbuf_len(qdf_nbuf_t nbuf, uint16_t *mpdu_len) +static inline bool dp_rx_adjust_nbuf_len(struct dp_soc *soc, + qdf_nbuf_t nbuf, uint16_t *mpdu_len) { bool last_nbuf; - if (*mpdu_len > (RX_DATA_BUFFER_SIZE - RX_PKT_TLVS_LEN)) { + if (*mpdu_len > (RX_DATA_BUFFER_SIZE - soc->rx_pkt_tlv_size)) { qdf_nbuf_set_pktlen(nbuf, RX_DATA_BUFFER_SIZE); last_nbuf = false; } else { - qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + RX_PKT_TLVS_LEN)); + qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + soc->rx_pkt_tlv_size)); last_nbuf = true; } - *mpdu_len -= (RX_DATA_BUFFER_SIZE - RX_PKT_TLVS_LEN); + *mpdu_len -= (RX_DATA_BUFFER_SIZE - soc->rx_pkt_tlv_size); return last_nbuf; } @@ -1267,8 +1261,8 @@ qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf) */ if (qdf_nbuf_is_rx_chfrag_start(nbuf) && qdf_nbuf_is_rx_chfrag_end(nbuf)) { - qdf_nbuf_set_pktlen(nbuf, mpdu_len + RX_PKT_TLVS_LEN); - qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN); + qdf_nbuf_set_pktlen(nbuf, mpdu_len + soc->rx_pkt_tlv_size); + qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size); return nbuf; } @@ -1291,7 +1285,7 @@ qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf) * nbufs will form the frag_list of the parent nbuf. */ qdf_nbuf_set_rx_chfrag_start(parent, 1); - last_nbuf = dp_rx_adjust_nbuf_len(parent, &mpdu_len); + last_nbuf = dp_rx_adjust_nbuf_len(soc, parent, &mpdu_len); /* * HW issue: MSDU cont bit is set but reported MPDU length can fit @@ -1301,7 +1295,7 @@ qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf) */ if (last_nbuf) { DP_STATS_INC(soc, rx.err.msdu_continuation_err, 1); - qdf_nbuf_pull_head(parent, RX_PKT_TLVS_LEN); + qdf_nbuf_pull_head(parent, soc->rx_pkt_tlv_size); return parent; } @@ -1311,8 +1305,8 @@ qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf) * till we hit the last_nbuf of the list. */ do { - last_nbuf = dp_rx_adjust_nbuf_len(nbuf, &mpdu_len); - qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN); + last_nbuf = dp_rx_adjust_nbuf_len(soc, nbuf, &mpdu_len); + qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size); frag_list_len += qdf_nbuf_len(nbuf); if (last_nbuf) { @@ -1328,7 +1322,7 @@ qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf) qdf_nbuf_append_ext_list(parent, frag_list, frag_list_len); parent->next = next; - qdf_nbuf_pull_head(parent, RX_PKT_TLVS_LEN); + qdf_nbuf_pull_head(parent, soc->rx_pkt_tlv_size); return parent; } @@ -1759,8 +1753,13 @@ static inline void dp_rx_cksum_offload(struct dp_pdev *pdev, uint8_t *rx_tlv_hdr) { qdf_nbuf_rx_cksum_t cksum = {0}; - bool ip_csum_err = hal_rx_attn_ip_cksum_fail_get(rx_tlv_hdr); - bool tcp_udp_csum_er = hal_rx_attn_tcp_udp_cksum_fail_get(rx_tlv_hdr); + //TODO - Move this to ring desc api + //HAL_RX_MSDU_DESC_IP_CHKSUM_FAIL_GET + //HAL_RX_MSDU_DESC_TCP_UDP_CHKSUM_FAIL_GET + uint32_t ip_csum_err, tcp_udp_csum_er; + + hal_rx_tlv_csum_err_get(pdev->soc->hal_soc, rx_tlv_hdr, &ip_csum_err, + &tcp_udp_csum_er); if (qdf_likely(!ip_csum_err && !tcp_udp_csum_er)) { cksum.l4_result = QDF_NBUF_RX_CKSUM_TCP_UDP_UNNECESSARY; @@ -1848,18 +1847,22 @@ static void dp_rx_msdu_stats_update(struct dp_soc *soc, if (!soc->process_rx_status) return; - is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(rx_tlv_hdr); + /* + * TODO - For WCN7850 this field is present in ring_desc + * Try to use ring desc instead of tlv. + */ + is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(soc->hal_soc, rx_tlv_hdr); DP_STATS_INCC(peer, rx.ampdu_cnt, 1, is_ampdu); DP_STATS_INCC(peer, rx.non_ampdu_cnt, 1, !(is_ampdu)); - sgi = hal_rx_msdu_start_sgi_get(rx_tlv_hdr); - mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr); + sgi = hal_rx_tlv_sgi_get(soc->hal_soc, rx_tlv_hdr); + mcs = hal_rx_tlv_rate_mcs_get(soc->hal_soc, rx_tlv_hdr); tid = qdf_nbuf_get_tid_val(nbuf); - bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr); + bw = hal_rx_tlv_bw_get(soc->hal_soc, rx_tlv_hdr); reception_type = hal_rx_msdu_start_reception_type_get(soc->hal_soc, rx_tlv_hdr); nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr); - pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr); + pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr); DP_STATS_INCC(peer, rx.rx_mpdu_cnt[mcs], 1, ((mcs < MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf))); @@ -1877,9 +1880,9 @@ static void dp_rx_msdu_stats_update(struct dp_soc *soc, DP_STATS_INC(peer, rx.sgi_count[sgi], 1); DP_STATS_INCC(peer, rx.err.mic_err, 1, - hal_rx_mpdu_end_mic_err_get(rx_tlv_hdr)); + hal_rx_tlv_mic_err_get(soc->hal_soc, rx_tlv_hdr)); DP_STATS_INCC(peer, rx.err.decrypt_err, 1, - hal_rx_mpdu_end_decrypt_err_get(rx_tlv_hdr)); + hal_rx_tlv_decrypt_err_get(soc->hal_soc, rx_tlv_hdr)); DP_STATS_INC(peer, rx.wme_ac_type[TID_TO_WME_AC(tid)], 1); DP_STATS_INC(peer, rx.reception_type[reception_type], 1); @@ -1906,7 +1909,7 @@ static void dp_rx_msdu_stats_update(struct dp_soc *soc, ((mcs < MAX_MCS) && (pkt_type == DOT11_AX))); if ((soc->process_rx_status) && - hal_rx_attn_first_mpdu_get(rx_tlv_hdr)) { + hal_rx_tlv_first_mpdu_get(soc->hal_soc, rx_tlv_hdr)) { #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE if (!vdev->pdev) return; @@ -2076,13 +2079,11 @@ void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf) hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr); msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf); - pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN; + pkt_len = msdu_len + l2_hdr_offset + soc->rx_pkt_tlv_size; QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1; qdf_nbuf_set_pktlen(nbuf, pkt_len); - qdf_nbuf_pull_head(nbuf, - RX_PKT_TLVS_LEN + - l2_hdr_offset); + qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size + l2_hdr_offset); if (dp_rx_is_special_frame(nbuf, frame_mask)) { qdf_nbuf_set_exc_frame(nbuf, 1); @@ -2151,10 +2152,10 @@ uint32_t dp_rx_srng_get_num_pending(hal_soc_handle_t hal_soc, #endif /* QCA_HOST_MODE_WIFI_DISABLED */ #ifdef WLAN_SUPPORT_RX_FISA -void dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding) +void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding) { QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding; - qdf_nbuf_pull_head(nbuf, l3_padding + RX_PKT_TLVS_LEN); + qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size); } /** @@ -2170,9 +2171,9 @@ void dp_rx_set_hdr_pad(qdf_nbuf_t nbuf, uint32_t l3_padding) QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding; } #else -void dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding) +void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding) { - qdf_nbuf_pull_head(nbuf, l3_padding + RX_PKT_TLVS_LEN); + qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size); } static inline @@ -2223,7 +2224,6 @@ dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num, hal_ring_desc_t ring_desc) { struct dp_buf_info_record *record; - uint8_t rbm; struct hal_buf_info hbi; uint32_t idx; @@ -2231,7 +2231,10 @@ dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num, return; hal_rx_reo_buf_paddr_get(ring_desc, &hbi); - rbm = hal_rx_ret_buf_manager_get(ring_desc); + + /* buffer_addr_info is the first element of ring_desc */ + hal_rx_buf_cookie_rbm_get(soc->hal_soc, (uint32_t *)ring_desc, + &hbi); idx = dp_history_get_next_index(&soc->rx_ring_history[ring_num]->index, DP_RX_HIST_MAX); @@ -2242,7 +2245,7 @@ dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num, record->timestamp = qdf_get_log_timestamp(); record->hbi.paddr = hbi.paddr; record->hbi.sw_cookie = hbi.sw_cookie; - record->hbi.rbm = rbm; + record->hbi.rbm = hbi.rbm; } #else static inline void @@ -2308,12 +2311,12 @@ void dp_rx_deliver_to_pkt_capture_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf, hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, &msdu_metadata); msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf); pkt_len = msdu_len + msdu_metadata.l3_hdr_pad + - RX_PKT_TLVS_LEN; + soc->rx_pkt_tlv_size; l2_hdr_offset = hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr); qdf_nbuf_set_pktlen(nbuf, pkt_len); - dp_rx_skip_tlvs(nbuf, msdu_metadata.l3_hdr_pad); + dp_rx_skip_tlvs(soc, nbuf, msdu_metadata.l3_hdr_pad); dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA, soc, nbuf, HTT_INVALID_VDEV, is_offload, 0); @@ -3333,7 +3336,7 @@ dp_pdev_rx_buffers_attach(struct dp_soc *dp_soc, uint32_t mac_id, __func__, RX_DESC_REPLENISHED); - hal_rxdma_buff_addr_info_set(rxdma_ring_entry, paddr, + hal_rxdma_buff_addr_info_set(dp_soc->hal_soc ,rxdma_ring_entry, paddr, desc_list->rx_desc.cookie, rx_desc_pool->owner); dp_ipa_handle_rx_buf_smmu_mapping( @@ -3594,7 +3597,7 @@ bool dp_rx_deliver_special_frame(struct dp_soc *soc, struct dp_peer *peer, skip_len = l2_hdr_offset; } else { msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf); - skip_len = l2_hdr_offset + RX_PKT_TLVS_LEN; + skip_len = l2_hdr_offset + soc->rx_pkt_tlv_size; qdf_nbuf_set_pktlen(nbuf, msdu_len + skip_len); } diff --git a/dp/wifi3.0/dp_types.h b/dp/wifi3.0/dp_types.h index abed13dacc..a64ae87d23 100644 --- a/dp/wifi3.0/dp_types.h +++ b/dp/wifi3.0/dp_types.h @@ -1532,6 +1532,7 @@ struct dp_arch_ops { struct dp_vdev *vdev); QDF_STATUS (*txrx_vdev_detach)(struct dp_soc *soc, struct dp_vdev *vdev); + QDF_STATUS (*dp_rxdma_ring_sel_cfg)(struct dp_soc *soc); /* TX RX Arch Ops */ QDF_STATUS (*tx_hw_enqueue)(struct dp_soc *soc, struct dp_vdev *vdev, @@ -2005,6 +2006,11 @@ struct dp_soc { #endif /* BM id for first WBM2SW ring */ uint32_t wbm_sw0_bm_id; + + /* rx monitor pkt tlv size */ + uint16_t rx_mon_pkt_tlv_size; + /* rx pkt tlv size */ + uint16_t rx_pkt_tlv_size; }; #ifdef IPA_OFFLOAD diff --git a/dp/wifi3.0/li/dp_li.c b/dp/wifi3.0/li/dp_li.c index ee4b818c05..20a0106fc6 100644 --- a/dp/wifi3.0/li/dp_li.c +++ b/dp/wifi3.0/li/dp_li.c @@ -17,6 +17,8 @@ */ #include "dp_types.h" +#include +#include #include "dp_li.h" #include "dp_li_tx.h" #include "dp_li_rx.h" @@ -74,6 +76,175 @@ qdf_size_t dp_get_soc_context_size_li(void) return sizeof(struct dp_soc); } +#ifdef NO_RX_PKT_HDR_TLV +/** + * dp_rxdma_ring_sel_cfg_li() - Setup RXDMA ring config + * @soc: Common DP soc handle + * + * Return: QDF_STATUS + */ +static QDF_STATUS +dp_rxdma_ring_sel_cfg_li(struct dp_soc *soc) +{ + int i; + int mac_id; + struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; + QDF_STATUS status = QDF_STATUS_SUCCESS; + + htt_tlv_filter.mpdu_start = 1; + htt_tlv_filter.msdu_start = 1; + htt_tlv_filter.mpdu_end = 1; + htt_tlv_filter.msdu_end = 1; + htt_tlv_filter.attention = 1; + htt_tlv_filter.packet = 1; + htt_tlv_filter.packet_header = 0; + + htt_tlv_filter.ppdu_start = 0; + htt_tlv_filter.ppdu_end = 0; + htt_tlv_filter.ppdu_end_user_stats = 0; + htt_tlv_filter.ppdu_end_user_stats_ext = 0; + htt_tlv_filter.ppdu_end_status_done = 0; + htt_tlv_filter.enable_fp = 1; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_mo = 0; + + htt_tlv_filter.fp_mgmt_filter = 0; + htt_tlv_filter.fp_ctrl_filter = FILTER_CTRL_BA_REQ; + htt_tlv_filter.fp_data_filter = (FILTER_DATA_UCAST | + FILTER_DATA_MCAST | + FILTER_DATA_DATA); + htt_tlv_filter.mo_mgmt_filter = 0; + htt_tlv_filter.mo_ctrl_filter = 0; + htt_tlv_filter.mo_data_filter = 0; + htt_tlv_filter.md_data_filter = 0; + + htt_tlv_filter.offset_valid = true; + + htt_tlv_filter.rx_packet_offset = soc->rx_pkt_tlv_size; + /*Not subscribing rx_pkt_header*/ + htt_tlv_filter.rx_header_offset = 0; + htt_tlv_filter.rx_mpdu_start_offset = + hal_rx_mpdu_start_offset_get(soc->hal_soc); + htt_tlv_filter.rx_mpdu_end_offset = + hal_rx_mpdu_end_offset_get(soc->hal_soc); + htt_tlv_filter.rx_msdu_start_offset = + hal_rx_msdu_start_offset_get(soc->hal_soc); + htt_tlv_filter.rx_msdu_end_offset = + hal_rx_msdu_end_offset_get(soc->hal_soc); + htt_tlv_filter.rx_attn_offset = + hal_rx_attn_offset_get(soc->hal_soc); + + for (i = 0; i < MAX_PDEV_CNT; i++) { + struct dp_pdev *pdev = soc->pdev_list[i]; + + if (!pdev) + continue; + + for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) { + int mac_for_pdev = + dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); + /* + * Obtain lmac id from pdev to access the LMAC ring + * in soc context + */ + int lmac_id = + dp_get_lmac_id_for_pdev_id(soc, mac_id, + pdev->pdev_id); + + htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, + soc->rx_refill_buf_ring[lmac_id]. + hal_srng, + RXDMA_BUF, RX_DATA_BUFFER_SIZE, + &htt_tlv_filter); + } + } + return status; +} +#else + +static QDF_STATUS +dp_rxdma_ring_sel_cfg_li(struct dp_soc *soc) +{ + int i; + int mac_id; + struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; + struct dp_srng *rx_mac_srng; + QDF_STATUS status = QDF_STATUS_SUCCESS; + + htt_tlv_filter.mpdu_start = 1; + htt_tlv_filter.msdu_start = 1; + htt_tlv_filter.mpdu_end = 1; + htt_tlv_filter.msdu_end = 1; + htt_tlv_filter.attention = 1; + htt_tlv_filter.packet = 1; + htt_tlv_filter.packet_header = 1; + + htt_tlv_filter.ppdu_start = 0; + htt_tlv_filter.ppdu_end = 0; + htt_tlv_filter.ppdu_end_user_stats = 0; + htt_tlv_filter.ppdu_end_user_stats_ext = 0; + htt_tlv_filter.ppdu_end_status_done = 0; + htt_tlv_filter.enable_fp = 1; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_md = 0; + htt_tlv_filter.enable_mo = 0; + + htt_tlv_filter.fp_mgmt_filter = 0; + htt_tlv_filter.fp_ctrl_filter = FILTER_CTRL_BA_REQ; + htt_tlv_filter.fp_data_filter = (FILTER_DATA_UCAST | + FILTER_DATA_MCAST | + FILTER_DATA_DATA); + htt_tlv_filter.mo_mgmt_filter = 0; + htt_tlv_filter.mo_ctrl_filter = 0; + htt_tlv_filter.mo_data_filter = 0; + htt_tlv_filter.md_data_filter = 0; + + htt_tlv_filter.offset_valid = true; + + htt_tlv_filter.rx_packet_offset = soc->rx_pkt_tlv_size; + htt_tlv_filter.rx_header_offset = + hal_rx_pkt_tlv_offset_get(soc->hal_soc); + htt_tlv_filter.rx_mpdu_start_offset = + hal_rx_mpdu_start_offset_get(soc->hal_soc); + htt_tlv_filter.rx_mpdu_end_offset = + hal_rx_mpdu_end_offset_get(soc->hal_soc); + htt_tlv_filter.rx_msdu_start_offset = + hal_rx_msdu_start_offset_get(soc->hal_soc); + htt_tlv_filter.rx_msdu_end_offset = + hal_rx_msdu_end_offset_get(soc->hal_soc); + htt_tlv_filter.rx_attn_offset = + hal_rx_attn_offset_get(soc->hal_soc); + + for (i = 0; i < MAX_PDEV_CNT; i++) { + struct dp_pdev *pdev = soc->pdev_list[i]; + + if (!pdev) + continue; + + for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) { + int mac_for_pdev = + dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); + /* + * Obtain lmac id from pdev to access the LMAC ring + * in soc context + */ + int lmac_id = + dp_get_lmac_id_for_pdev_id(soc, mac_id, + pdev->pdev_id); + + rx_mac_srng = dp_get_rxdma_ring(pdev, lmac_id); + htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, + rx_mac_srng->hal_srng, + RXDMA_BUF, RX_DATA_BUFFER_SIZE, + &htt_tlv_filter); + } + } + return status; + +} +#endif + void dp_initialize_arch_ops_li(struct dp_arch_ops *arch_ops) { arch_ops->tx_hw_enqueue = dp_tx_hw_enqueue_li; @@ -87,4 +258,5 @@ void dp_initialize_arch_ops_li(struct dp_arch_ops *arch_ops) arch_ops->tx_comp_get_params_from_hal_desc = dp_tx_comp_get_params_from_hal_desc_li; arch_ops->dp_rx_process = dp_rx_process_li; + arch_ops->dp_rxdma_ring_sel_cfg = dp_rxdma_ring_sel_cfg_li; } diff --git a/dp/wifi3.0/li/dp_li_tx.c b/dp/wifi3.0/li/dp_li_tx.c index 79fd039496..f24c0f92d4 100644 --- a/dp/wifi3.0/li/dp_li_tx.c +++ b/dp/wifi3.0/li/dp_li_tx.c @@ -20,6 +20,8 @@ #include "dp_tx.h" #include "dp_li_tx.h" #include "dp_tx_desc.h" +#include +#include #include #include diff --git a/hal/wifi3.0/be/hal_be_generic_api.h b/hal/wifi3.0/be/hal_be_generic_api.h index 41d9c27690..a02f336057 100644 --- a/hal/wifi3.0/be/hal_be_generic_api.h +++ b/hal/wifi3.0/be/hal_be_generic_api.h @@ -1452,14 +1452,14 @@ hal_rx_status_get_tlv_info_generic_be(void *rx_tlv_hdr, void *ppduinfo, case WIFIRX_MPDU_START_E: { uint8_t *rx_mpdu_start = (uint8_t *)rx_tlv; - uint32_t ppdu_id = HAL_RX_GET_PPDU_ID(rx_mpdu_start); + uint32_t ppdu_id = HAL_RX_GET_PPDU_ID(rx_tlv); uint8_t filter_category = 0; ppdu_info->nac_info.fc_valid = - HAL_RX_GET_FC_VALID(rx_mpdu_start); + HAL_RX_GET_FC_VALID(rx_tlv); ppdu_info->nac_info.to_ds_flag = - HAL_RX_GET_TO_DS_FLAG(rx_mpdu_start); + HAL_RX_GET_TO_DS_FLAG(rx_tlv); ppdu_info->nac_info.frame_control = HAL_RX_GET(rx_mpdu_start, @@ -1467,7 +1467,7 @@ hal_rx_status_get_tlv_info_generic_be(void *rx_tlv_hdr, void *ppduinfo, MPDU_FRAME_CONTROL_FIELD); ppdu_info->sw_frame_group_id = - HAL_RX_GET_SW_FRAME_GROUP_ID(rx_mpdu_start); + HAL_RX_GET_SW_FRAME_GROUP_ID(rx_tlv); if (ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_NULL_DATA) { @@ -1481,7 +1481,7 @@ hal_rx_status_get_tlv_info_generic_be(void *rx_tlv_hdr, void *ppduinfo, ppdu_info); ppdu_info->nac_info.mac_addr2_valid = - HAL_RX_GET_MAC_ADDR2_VALID(rx_mpdu_start); + HAL_RX_TLV_MPDU_MAC_ADDR_AD2_VALID_GET(rx_tlv); *(uint16_t *)&ppdu_info->nac_info.mac_addr2[0] = HAL_RX_GET(rx_mpdu_start, @@ -1505,7 +1505,7 @@ hal_rx_status_get_tlv_info_generic_be(void *rx_tlv_hdr, void *ppduinfo, } filter_category = - HAL_RX_GET_FILTER_CATEGORY(rx_mpdu_start); + HAL_RX_GET_FILTER_CATEGORY(rx_tlv); if (filter_category == 0) ppdu_info->rx_status.rxpcu_filter_pass = 1; @@ -1679,42 +1679,6 @@ void hal_tx_update_tidmap_prty_generic_be(struct hal_soc *soc, uint8_t value) (value & HWIO_TCL_R0_TID_MAP_PRTY_RMSK)); } -/** - * hal_rx_mpdu_end_offset_get_generic(): API to get the - * mpdu_end structure offset rx_pkt_tlv structure - * - * NOTE: API returns offset of attn TLV from structure - * rx_pkt_tlvs - */ -static uint32_t hal_rx_mpdu_end_offset_get_generic(void) -{ - return RX_PKT_TLV_OFFSET(mpdu_end_tlv); -} - -/** - * hal_rx_attn_offset_get_generic(): API to get the - * msdu_end structure offset rx_pkt_tlv structure - * - * NOTE: API returns offset of attn TLV from structure - * rx_pkt_tlvs - */ -static uint32_t hal_rx_attn_offset_get_generic(void) -{ - return RX_PKT_TLV_OFFSET(attn_tlv); -} - -/** - * hal_rx_msdu_start_offset_get_generic(): API to get the - * msdu_start structure offset rx_pkt_tlv structure - * - * NOTE: API returns offset of attn TLV from structure - * rx_pkt_tlvs - */ -static uint32_t hal_rx_msdu_start_offset_get_generic(void) -{ - return RX_PKT_TLV_OFFSET(msdu_start_tlv); -} - /** * hal_rx_get_tlv_size_generic_be() - Get rx packet tlv size * @rx_pkt_tlv_size: TLV size for regular RX packets diff --git a/hal/wifi3.0/be/hal_be_rx_tlv.h b/hal/wifi3.0/be/hal_be_rx_tlv.h new file mode 100644 index 0000000000..c5ecedd4ff --- /dev/null +++ b/hal/wifi3.0/be/hal_be_rx_tlv.h @@ -0,0 +1,1848 @@ +/* + * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all + * copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _HAL_BE_RX_TLV_H_ +#define _HAL_BE_RX_TLV_H_ + +/* + * Structures & Macros to obtain fields from the TLV's in the Rx packet + * pre-header. + */ + +#define HAL_RX_BE_PKT_HDR_TLV_LEN 112 + +#ifdef CONFIG_WORD_BASED_TLV +#else +typedef struct rx_mpdu_start hal_rx_mpdu_start_t; +typedef struct rx_msdu_end hal_rx_msdu_end_t; +#endif + +/* + * Each RX descriptor TLV is preceded by 1 QWORD "tag" + */ + +struct rx_mpdu_start_tlv { + uint64_t tag; + hal_rx_mpdu_start_t rx_mpdu_start; +}; + +struct rx_msdu_end_tlv { + uint64_t tag; + hal_rx_msdu_end_t rx_msdu_end; +}; + +struct rx_pkt_hdr_tlv { + uint64_t tag; /* 8 B */ + uint64_t phy_ppdu_id; /* 8 B */ + char rx_pkt_hdr[HAL_RX_BE_PKT_HDR_TLV_LEN]; /* 112 B */ +}; + +#define RX_BE_PADDING0_BYTES 8 +#define RX_BE_PADDING1_BYTES 8 + +struct rx_pkt_tlvs { + struct rx_msdu_end_tlv msdu_end_tlv; /* 120 bytes */ + uint8_t rx_padding0[RX_BE_PADDING0_BYTES]; /* 8 bytes */ + struct rx_mpdu_start_tlv mpdu_start_tlv; /* 120 bytes */ + struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */ +}; + +#define SIZE_OF_DATA_RX_TLV sizeof(struct rx_pkt_tlvs) + +#define RX_PKT_TLVS_LEN SIZE_OF_DATA_RX_TLV + +#define RX_PKT_TLV_OFFSET(field) qdf_offsetof(struct rx_pkt_tlvs, field) + +#ifndef CONFIG_WORD_BASED_TLV +#define HAL_RX_MSDU_END(_rx_pkt_tlv) \ + (((struct rx_pkt_tlvs *)_rx_pkt_tlv)->msdu_end_tlv.rx_msdu_end) + +#define HAL_RX_MPDU_START(_rx_pkt_tlv) \ + (((struct rx_pkt_tlvs *)_rx_pkt_tlv)->mpdu_start_tlv. \ + rx_mpdu_start.rx_mpdu_info_details) +#endif /* CONFIG_WORD_BASED_TLV */ + +#define HAL_RX_TLV_MSDU_DONE_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).msdu_done + +#define HAL_RX_TLV_DECAP_FROMAT_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).decap_format + +#define HAL_RX_TLV_GET_TCP_PURE_ACK(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_only_ack + +#define HAL_RX_TLV_GET_TCP_PROTO(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_proto + +#define HAL_RX_TLV_GET_UDP_PROTO(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).udp_proto + +#define HAL_RX_TLV_GET_IPV6(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).ipv6_proto + +#define HAL_RX_TLV_GET_IP_OFFSET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).l3_offset + +#define HAL_RX_TLV_GET_TCP_OFFSET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).l4_offset + +#define HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_id_toeplitz + +#define HAL_RX_TLV_MSDU_LEN_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).msdu_length + +#define HAL_RX_TLV_CCE_MATCH_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).cce_match + +#define HAL_RX_TLV_PHY_PPDU_ID_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).phy_ppdu_id + +#define HAL_RX_TLV_BW_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).receive_bandwidth + +#define HAL_RX_TLV_FLOWID_TOEPLITZ_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_id_toeplitz + +#define HAL_RX_TLV_SGI_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).sgi + +#define HAL_RX_TLV_RATE_MCS_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).rate_mcs + +#define HAL_RX_TLV_DECRYPT_STATUS_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).decrypt_status_code + +#define HAL_RX_TLV_RSSI_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).user_rssi + +#define HAL_RX_TLV_FREQ_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).sw_phy_meta_data + +#define HAL_RX_TLV_PKT_TYPE_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).pkt_type + +#define HAL_RX_TLV_DECRYPT_ERR_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).decrypt_err + +#define HAL_RX_TLV_MIC_ERR_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tkip_mic_err + +#define HAL_RX_TLV_MIMO_SS_BITMAP(_rx_pkt_tlv)\ + HAL_RX_MSDU_END(_rx_pkt_tlv).mimo_ss_bitmap + +#define HAL_RX_TLV_ANT_SIGNAL_DB_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).user_rssi + +#define HAL_RX_TLV_STBC_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).stbc + +#define HAL_RX_TLV_RECEPTION_TYPE_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).reception_type + +#define HAL_RX_TLV_IP_CSUM_FAIL_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).ip_chksum_fail + +#define HAL_RX_TLV_TCP_UDP_CSUM_FAIL_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_udp_chksum_fail + +#define HAL_RX_TLV_MPDU_LEN_ERR_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).mpdu_length_err + +#define HAL_RX_TLV_MPDU_FCS_ERR_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).fcs_err + +#define HAL_RX_TLV_IS_MCAST_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).mcast_bcast + +#define HAL_RX_TLV_FIRST_MPDU_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).first_mpdu + +/** +* LRO information needed from the TLVs +*/ +#define HAL_RX_TLV_GET_LRO_ELIGIBLE(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).lro_eligible + +#define HAL_RX_TLV_GET_TCP_ACK(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_ack_number + +#define HAL_RX_TLV_GET_TCP_SEQ(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_seq_number + +#define HAL_RX_TLV_GET_TCP_WIN(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).window_size + +#define HAL_RX_TLV_PEER_META_DATA_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).peer_meta_data + +#define HAL_RX_TLV_AMPDU_FLAG_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).ampdu_flag + +#define HAL_RX_TLV_KEYID_OCTET_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).key_id_octet + +#define HAL_RX_MPDU_SEQUENCE_NUMBER_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_sequence_number + +#define HAL_RX_TLV_SA_SW_PEER_ID_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).sa_sw_peer_id + +#define HAL_RX_TLV_L3_HEADER_PADDING_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).l3_header_padding + +#define HAL_RX_TLV_SA_IDX_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).sa_idx + +#define HAL_RX_TLV_DA_IDX_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).da_idx_or_sw_peer_id + +#define HAL_RX_TLV_FIRST_MSDU_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).first_msdu + +#define HAL_RX_TLV_LAST_MSDU_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).last_msdu + +/* + * Get tid from RX_MPDU_START + */ +#define HAL_RX_TLV_TID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).tid + +#define HAL_RX_TLV_DA_IS_MCBC_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).da_is_mcbc + +#define HAL_RX_TLV_SA_IS_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).sa_is_valid + +#define HAL_RX_TLV_MPDU_ENCRYPTION_INFO_VALID(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).frame_encryption_info_valid + +#define HAL_RX_TLV_MPDU_PN_31_0_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).pn_31_0 + +#define HAL_RX_TLV_MPDU_PN_63_32_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).pn_63_32 + +#define HAL_RX_TLV_MPDU_PN_95_64_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).pn_95_64 + +#define HAL_RX_TLV_MPDU_PN_127_96_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).pn_127_96 + +#define HAL_RX_TLV_DA_IS_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).da_is_valid + +#define HAL_RX_TLV_MPDU_MAC_ADDR_AD4_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad4_valid + +#define HAL_RX_TLV_SW_PEER_ID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).sw_peer_id + +#define HAL_RX_TLV_MPDU_GET_TODS(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).to_ds + +#define HAL_RX_TLV_MPDU_GET_FROMDS(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).fr_ds + +#define HAL_RX_TLV_MPDU_GET_FRAME_CONTROL_VALID(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_frame_control_valid + +#define HAL_RX_TLV_MPDU_MAC_ADDR_AD1_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad1_valid + +#define HAL_RX_TLV_MPDU_AD1_31_0_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad1_31_0 + +#define HAL_RX_TLV_MPDU_AD1_47_32_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad1_47_32 + +#define HAL_RX_TLV_MPDU_MAC_ADDR_AD2_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad2_valid + +#define HAL_RX_TLV_MPDU_AD2_15_0_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad2_15_0 + +#define HAL_RX_TLV_MPDU_AD2_47_16_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad2_47_16 + +#define HAL_RX_TLV_MPDU_MAC_ADDR_AD3_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad3_valid + +#define HAL_RX_TLV_MPDU_AD3_31_0_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad3_31_0 + +#define HAL_RX_TLV_MPDU_AD3_47_32_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad3_47_32 + +#define HAL_RX_TLV_MPDU_AD4_31_0_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad4_31_0 + +#define HAL_RX_TLV_MPDU_AD4_47_32_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mac_addr_ad4_47_32 + +#define HAL_RX_TLV_MPDU_GET_SEQUENCE_CONTROL_VALID(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_sequence_control_valid + +#define HAL_RX_TLV_SW_FRAME_GROUP_ID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).sw_frame_group_id + +#define HAL_RX_TLV_MPDU_QOS_CONTROL_VALID_GET(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_qos_control_valid + +#define HAL_RX_GET_FC_VALID(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_frame_control_valid + +#define HAL_RX_GET_TO_DS_FLAG(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).to_ds + +#define HAL_RX_GET_FILTER_CATEGORY(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).rxpcu_mpdu_filter_in_category + +#define HAL_RX_GET_PPDU_ID(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).phy_ppdu_id + +#define HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(_rx_pkt_tlv) \ + HAL_RX_MPDU_START(_rx_pkt_tlv).mpdu_frame_control_field + +#define HAL_RX_TLV_FLOW_IDX_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_idx + +#define HAL_RX_TLV_REO_DEST_IND_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).reo_destination_indication + +#define HAL_RX_TLV_FLOW_IDX_INVALID_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_idx_invalid + +#define HAL_RX_TLV_FLOW_IDX_TIMEOUT_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_idx_timeout + +#define HAL_RX_TLV_FSE_METADATA_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).fse_metadata + +#define HAL_RX_TLV_CCE_METADATA_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).cce_metadata + +#define HAL_RX_TLV_DECRYPT_STATUS_GET(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).decrypt_status_code + +#define HAL_RX_TLV_GET_TCP_CHKSUM(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).tcp_udp_chksum + +#define HAL_RX_TLV_GET_FLOW_AGGR_CONT(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).flow_aggregation_continuation + +#define HAL_RX_TLV_GET_FLOW_AGGR_COUNT(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).aggregation_count + +#define HAL_RX_TLV_GET_FISA_TIMEOUT(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).fisa_timeout + +#define HAL_RX_TLV_GET_FISA_CUMULATIVE_L4_CHECKSUM(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).cumulative_l4_checksum + +#define HAL_RX_TLV_GET_FISA_CUMULATIVE_IP_LENGTH(_rx_pkt_tlv) \ + HAL_RX_MSDU_END(_rx_pkt_tlv).cumulative_ip_length + +static inline +uint32_t hal_rx_tlv_decap_format_get_be(void *hw_desc_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)hw_desc_addr; + + return rx_pkt_tlvs->msdu_end_tlv.rx_msdu_end.decap_format; +} + +static inline uint32_t hal_rx_tlv_msdu_done_get_be(uint8_t *buf) +{ + return HAL_RX_TLV_MSDU_DONE_GET(buf); +} + +/* + * hal_rx_attn_first_mpdu_get(): get fist_mpdu bit from rx attention + * @buf: pointer to rx_pkt_tlvs + * + * reutm: uint32_t(first_msdu) + */ +static inline uint32_t hal_rx_tlv_first_mpdu_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FIRST_MPDU_GET(rx_pkt_tlvs); +} + +/* + * hal_rx_attn_phy_ppdu_id_get(): get phy_ppdu_id value + * from rx attention + * @buf: pointer to rx_pkt_tlvs + * + * Return: phy_ppdu_id + */ +static inline uint16_t hal_rx_tlv_phy_ppdu_id_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_PHY_PPDU_ID_GET(rx_pkt_tlvs); +} + +/* + * hal_rx_msdu_cce_match_get(): get CCE match bit + * from rx attention + * @buf: pointer to rx_pkt_tlvs + * Return: CCE match value + */ +static inline bool hal_rx_msdu_cce_match_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_CCE_MATCH_GET(rx_pkt_tlvs); +} + +/* + * Get peer_meta_data from RX_MPDU_INFO within RX_MPDU_START + */ + +static inline uint32_t hal_rx_mpdu_peer_meta_data_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_PEER_META_DATA_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_mpdu_info_ampdu_flag_get_be(): get ampdu flag bit + * from rx mpdu info + * @buf: pointer to rx_pkt_tlvs + * + * Return: ampdu flag + */ +static inline bool hal_rx_mpdu_info_ampdu_flag_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return !!HAL_RX_TLV_AMPDU_FLAG_GET(rx_pkt_tlvs); +} + +/* + * @ hal_rx_mpdu_peer_meta_data_set: set peer meta data in RX mpdu start tlv + * + * @ buf: rx_tlv_hdr of the received packet + * @ peer_mdata: peer meta data to be set. + * @ Return: void + */ +static inline void +hal_rx_mpdu_peer_meta_data_set_be(uint8_t *buf, uint32_t peer_mdata) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + HAL_RX_TLV_PEER_META_DATA_GET(rx_pkt_tlvs) = peer_mdata; +} + + /** + * hal_rx_tlv_msdu_len_get(): API to get the MSDU length + * from rx_msdu_start TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: msdu length + */ +static inline uint32_t hal_rx_tlv_msdu_len_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MSDU_LEN_GET(rx_pkt_tlvs); +} + + /** + * hal_rx_tlv_msdu_len_set(): API to set the MSDU length + * from rx_msdu_start TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * @len: msdu length + * + * Return: none + */ +static inline void hal_rx_tlv_msdu_len_set_be(uint8_t *buf, uint32_t len) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + HAL_RX_TLV_MSDU_LEN_GET(rx_pkt_tlvs) = len; +} + +/* + * hal_rx_tlv_bw_get(): API to get the Bandwidth + * Interval from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(bw) + */ +static inline uint32_t hal_rx_tlv_bw_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_BW_GET(rx_pkt_tlvs); +} + + /** + * hal_rx_tlv_toeplitz_get: API to get the toeplitz hash + * from rx_msdu_start TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: toeplitz hash + */ +static inline uint32_t hal_rx_tlv_toeplitz_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FLOWID_TOEPLITZ_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_tlv_msdu_sgi_get(): API to get the Short Gaurd + * Interval from rx_msdu_start TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * Return: uint32_t(sgi) + */ +static inline uint32_t hal_rx_tlv_sgi_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_SGI_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_tlv_msdu_rate_mcs_get(): API to get the MCS rate + * from rx_msdu_start TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * Return: uint32_t(rate_mcs) + */ +static inline uint32_t hal_rx_tlv_rate_mcs_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t rate_mcs; + + rate_mcs = HAL_RX_TLV_RATE_MCS_GET(rx_pkt_tlvs); + + return rate_mcs; +} + +/* + * hal_rx_tlv_msdu_get_is_decrypted(): API to get the decrypt status of the + * packet from rx_attention + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(decryt status) + */ + +static inline uint32_t hal_rx_tlv_msdu_get_is_decrypted_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t is_decrypt = 0; + uint32_t decrypt_status; + + decrypt_status = HAL_RX_TLV_DECRYPT_STATUS_GET(rx_pkt_tlvs); + + if (!decrypt_status) + is_decrypt = 1; + + return is_decrypt; +} + +/* + * Get key index from RX_MSDU_END + */ +/* + * hal_rx_msdu_get_keyid(): API to get the key id if the decrypted packet + * from rx_msdu_end + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(key id) + */ + +static inline uint32_t hal_rx_msdu_get_keyid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t keyid_octet; + + keyid_octet = HAL_RX_TLV_KEYID_OCTET_GET(rx_pkt_tlvs); + + return keyid_octet & 0x3; +} + +/* + * hal_rx_tlv_get_rssi(): API to get the rssi of received pkt + * from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(rssi) + */ + +static inline uint32_t hal_rx_tlv_get_rssi_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t rssi; + + rssi = HAL_RX_TLV_RSSI_GET(rx_pkt_tlvs); + + return rssi; +} + +/* + * hal_rx_tlv_get_freq(): API to get the frequency of operating channel + * from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(frequency) + */ + +static inline uint32_t hal_rx_tlv_get_freq_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t freq; + + freq = HAL_RX_TLV_FREQ_GET(rx_pkt_tlvs); + + return freq; +} + + +/* + * hal_rx_tlv_get_pkt_type(): API to get the pkt type + * from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(pkt type) + */ + +static inline uint32_t hal_rx_tlv_get_pkt_type_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t pkt_type; + + pkt_type = HAL_RX_TLV_PKT_TYPE_GET(rx_pkt_tlvs); + + return pkt_type; +} + +/******************************************************************************* + * RX ERROR APIS + ******************************************************************************/ + +/** + * hal_rx_tlv_decrypt_err_get(): API to get the Decrypt ERR + * from rx_mpdu_end TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * Return: uint32_t(decrypt_err) + */ +static inline uint32_t hal_rx_tlv_decrypt_err_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t decrypt_err; + + decrypt_err = HAL_RX_TLV_DECRYPT_ERR_GET(rx_pkt_tlvs); + + return decrypt_err; +} + +/** + * hal_rx_tlv_mic_err_get(): API to get the MIC ERR + * from rx_tlv TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * Return: uint32_t(mic_err) + */ +static inline uint32_t hal_rx_tlv_mic_err_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t mic_err; + + mic_err = HAL_RX_TLV_MIC_ERR_GET(rx_pkt_tlvs); + + return mic_err; +} + +/** + * hal_rx_mpdu_sequence_number_get() - Get mpdu sequence number + * @buf: pointer to packet buffer + * + * Return: mpdu sequence + */ +static inline int hal_rx_mpdu_sequence_number_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_MPDU_SEQUENCE_NUMBER_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_msdu_packet_metadata_get(): API to get the + * msdu information from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * @ hal_rx_msdu_metadata: pointer to the msdu info structure + */ +static void +hal_rx_msdu_packet_metadata_get_generic_be(uint8_t *buf, + void *pkt_msdu_metadata) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct hal_rx_msdu_metadata *msdu_metadata = + (struct hal_rx_msdu_metadata *)pkt_msdu_metadata; + + msdu_metadata->l3_hdr_pad = + HAL_RX_TLV_L3_HEADER_PADDING_GET(rx_pkt_tlvs); + msdu_metadata->sa_idx = HAL_RX_TLV_SA_IDX_GET(rx_pkt_tlvs); + msdu_metadata->da_idx = HAL_RX_TLV_DA_IDX_GET(rx_pkt_tlvs); + msdu_metadata->sa_sw_peer_id = + HAL_RX_TLV_SA_SW_PEER_ID_GET(rx_pkt_tlvs); +} + +/* + * hal_rx_msdu_start_nss_get_7850(): API to get the NSS + * Interval from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(nss) + */ +static uint32_t hal_rx_tlv_nss_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t mimo_ss_bitmap; + + mimo_ss_bitmap = HAL_RX_TLV_MIMO_SS_BITMAP(rx_pkt_tlvs); + + return qdf_get_hweight8(mimo_ss_bitmap); +} + +#ifdef GET_MSDU_AGGREGATION +#define HAL_RX_GET_MSDU_AGGREGATION(rx_desc, rs)\ +{\ + bool first_msdu, last_msdu; \ + first_msdu = HAL_RX_TLV_FIRST_MSDU_GET(rx_desc);\ + last_msdu = HAL_RX_TLV_LAST_MSDU_GET(rx_desc);\ + if (first_msdu && last_msdu)\ + rs->rs_flags &= (~IEEE80211_AMSDU_FLAG);\ + else\ + rs->rs_flags |= (IEEE80211_AMSDU_FLAG); \ +} \ + +#define HAL_RX_SET_MSDU_AGGREGATION((rs_mpdu), (rs_ppdu))\ +{\ + if (rs_mpdu->rs_flags & IEEE80211_AMSDU_FLAG)\ + rs_ppdu->rs_flags |= IEEE80211_AMSDU_FLAG;\ +} \ + +#else +#define HAL_RX_GET_MSDU_AGGREGATION(rx_desc, rs) +#define HAL_RX_SET_MSDU_AGGREGATION(rs_mpdu, rs_ppdu) +#endif + +/** + * hal_rx_mon_hw_desc_get_mpdu_status_be(): Retrieve MPDU status + * + * @ hw_desc_addr: Start address of Rx HW TLVs + * @ rs: Status for monitor mode + * + * Return: void + */ +static void +hal_rx_mon_hw_desc_get_mpdu_status_be(void *hw_desc_addr, + struct mon_rx_status *rs) +{ + uint32_t reg_value; + struct rx_pkt_tlvs *rx_desc = + (struct rx_pkt_tlvs *)hw_desc_addr; + const uint32_t sgi_hw_to_cdp[] = { + CDP_SGI_0_8_US, + CDP_SGI_0_4_US, + CDP_SGI_1_6_US, + CDP_SGI_3_2_US, + }; + + HAL_RX_GET_MSDU_AGGREGATION(rx_desc, rs); + + rs->ant_signal_db = HAL_RX_TLV_ANT_SIGNAL_DB_GET(rx_desc); + rs->is_stbc = HAL_RX_TLV_STBC_GET(rx_desc); + + reg_value = HAL_RX_TLV_SGI_GET(rx_desc); + rs->sgi = sgi_hw_to_cdp[reg_value]; + + reg_value = HAL_RX_TLV_RECEPTION_TYPE_GET(rx_desc); + rs->beamformed = (reg_value == HAL_RX_RECEPTION_TYPE_MU_MIMO) ? 1 : 0; + /* TODO: rs->beamformed should be set for SU beamforming also */ +} + +static inline uint32_t hal_rx_tlv_tid_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t tid; + + tid = HAL_RX_TLV_TID_GET(rx_pkt_tlvs); + + return tid; +} + +/* + * hal_rx_tlv_reception_type_get(): API to get the reception type + * Interval from rx_msdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(reception_type) + */ +static inline +uint32_t hal_rx_tlv_reception_type_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t reception_type; + + reception_type = HAL_RX_TLV_RECEPTION_TYPE_GET(rx_pkt_tlvs); + + return reception_type; +} + +/** + * hal_rx_msdu_end_da_idx_get_be: API to get da_idx + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: da index + */ +static inline uint16_t hal_rx_msdu_end_da_idx_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint16_t da_idx; + + da_idx = HAL_RX_TLV_DA_IDX_GET(rx_pkt_tlvs); + + return da_idx; +} + +/** + * hal_rx_get_rx_fragment_number_be(): Function to retrieve rx fragment number + * + * @nbuf: Network buffer + * Returns: rx fragment number + */ +static inline +uint8_t hal_rx_get_rx_fragment_number_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + /* Return first 4 bits as fragment number */ + return (HAL_RX_MPDU_SEQUENCE_NUMBER_GET(rx_pkt_tlvs) & + DOT11_SEQ_FRAG_MASK); +} + +/** + * hal_rx_msdu_end_da_is_mcbc_get_be(): API to check if pkt is MCBC + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: da_is_mcbc + */ +static inline uint8_t +hal_rx_tlv_da_is_mcbc_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_DA_IS_MCBC_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_tlvd_sa_is_valid_get_be(): API to get the sa_is_valid bit from + * rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: sa_is_valid bit + */ +static inline uint8_t +hal_rx_tlv_sa_is_valid_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t sa_is_valid; + + sa_is_valid = HAL_RX_TLV_SA_IS_VALID_GET(rx_pkt_tlvs); + + return sa_is_valid; +} + +/** + * hal_rx_tlv_sa_idx_get_be(): API to get the sa_idx from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: sa_idx (SA AST index) + */ +static inline +uint16_t hal_rx_tlv_sa_idx_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint16_t sa_idx; + + sa_idx = HAL_RX_TLV_SA_IDX_GET(rx_pkt_tlvs); + + return sa_idx; +} + +/** + * hal_rx_desc_is_first_msdu_be() - Check if first msdu + * + * @hal_soc_hdl: hal_soc handle + * @hw_desc_addr: hardware descriptor address + * + * Return: 0 - success/ non-zero failure + */ +static inline uint32_t hal_rx_desc_is_first_msdu_be(void *hw_desc_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)hw_desc_addr; + + return HAL_RX_TLV_FIRST_MSDU_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_tlv_l3_hdr_padding_get_be(): API to get the l3_header padding + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: number of l3 header padding bytes + */ +static inline uint32_t hal_rx_tlv_l3_hdr_padding_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t l3_header_padding; + + l3_header_padding = HAL_RX_TLV_L3_HEADER_PADDING_GET(rx_pkt_tlvs); + + return l3_header_padding; +} + +/* + * @ hal_rx_encryption_info_valid_be: Returns encryption type. + * + * @ buf: rx_tlv_hdr of the received packet + * @ Return: encryption type + */ +static inline uint32_t hal_rx_encryption_info_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t encryption_info = + HAL_RX_TLV_MPDU_ENCRYPTION_INFO_VALID(rx_pkt_tlvs); + + return encryption_info; +} + +/* + * @ hal_rx_print_pn_be: Prints the PN of rx packet. + * + * @ buf: rx_tlv_hdr of the received packet + * @ Return: void + */ +static inline void hal_rx_print_pn_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + uint32_t pn_31_0 = HAL_RX_TLV_MPDU_PN_31_0_GET(rx_pkt_tlvs); + uint32_t pn_63_32 = HAL_RX_TLV_MPDU_PN_63_32_GET(rx_pkt_tlvs); + uint32_t pn_95_64 = HAL_RX_TLV_MPDU_PN_95_64_GET(rx_pkt_tlvs); + uint32_t pn_127_96 = HAL_RX_TLV_MPDU_PN_127_96_GET(rx_pkt_tlvs); + + hal_debug("PN number pn_127_96 0x%x pn_95_64 0x%x pn_63_32 0x%x pn_31_0 0x%x ", + pn_127_96, pn_95_64, pn_63_32, pn_31_0); +} + +static inline void hal_rx_tlv_get_pn_num_be(uint8_t *buf, uint64_t *pn_num) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + pn_num[0] = HAL_RX_TLV_MPDU_PN_31_0_GET(rx_pkt_tlvs); + pn_num[0] |= ((uint64_t)HAL_RX_TLV_MPDU_PN_63_32_GET(rx_pkt_tlvs) << 32); + + pn_num[1] = HAL_RX_TLV_MPDU_PN_95_64_GET(rx_pkt_tlvs); + pn_num[1] |= ((uint64_t)HAL_RX_TLV_MPDU_PN_127_96_GET(rx_pkt_tlvs) << 32); +} + +/** + * hal_rx_tlv_first_msdu_get_be: API to get first msdu status + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: first_msdu + */ +static inline uint8_t hal_rx_tlv_first_msdu_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t first_msdu; + + first_msdu = HAL_RX_TLV_FIRST_MSDU_GET(rx_pkt_tlvs); + + return first_msdu; +} + +/** + * hal_rx_tlv_da_is_valid_get_be: API to check if da is valid + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: da_is_valid + */ +static inline uint8_t hal_rx_tlv_da_is_valid_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t da_is_valid; + + da_is_valid = HAL_RX_TLV_DA_IS_VALID_GET(rx_pkt_tlvs); + + return da_is_valid; +} + +/** + * hal_rx_tlv_last_msdu_get_be: API to get last msdu status + * from rx_msdu_end TLV + * + * @ buf: pointer to the start of RX PKT TLV headers + * Return: last_msdu + */ +static inline uint8_t hal_rx_tlv_last_msdu_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t last_msdu; + + last_msdu = HAL_RX_TLV_LAST_MSDU_GET(rx_pkt_tlvs); + + return last_msdu; +} + +/* + * hal_rx_get_mpdu_mac_ad4_valid_be(): Retrieves if mpdu 4th addr is valid + * + * @nbuf: Network buffer + * Returns: value of mpdu 4th address valid field + */ +static inline bool hal_rx_get_mpdu_mac_ad4_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + bool ad4_valid = 0; + + ad4_valid = HAL_RX_TLV_MPDU_MAC_ADDR_AD4_VALID_GET(rx_pkt_tlvs); + + return ad4_valid; +} + +/** + * hal_rx_mpdu_start_sw_peer_id_get_be: Retrieve sw peer_id + * @buf: network buffer + * + * Return: sw peer_id + */ +static inline uint32_t hal_rx_mpdu_start_sw_peer_id_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_SW_PEER_ID_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_mpdu_get_to_ds_be(): API to get the tods info + * from rx_mpdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(to_ds) + */ +static inline uint32_t hal_rx_mpdu_get_to_ds_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MPDU_GET_TODS(rx_pkt_tlvs); +} + +/* + * hal_rx_mpdu_get_fr_ds_be(): API to get the from ds info + * from rx_mpdu_start + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(fr_ds) + */ +static inline uint32_t hal_rx_mpdu_get_fr_ds_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MPDU_GET_FROMDS(rx_pkt_tlvs); +} + +/* + * hal_rx_get_mpdu_frame_control_valid_be(): Retrieves mpdu + * frame control valid + * + * @nbuf: Network buffer + * Returns: value of frame control valid field + */ +static inline uint8_t hal_rx_get_mpdu_frame_control_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MPDU_GET_FRAME_CONTROL_VALID(rx_pkt_tlvs); +} + +/* + * hal_rx_mpdu_get_addr1_be(): API to check get address1 of the mpdu + * + * @buf: pointer to the start of RX PKT TLV headera + * @mac_addr: pointer to mac address + * Return: success/failure + */ +static inline QDF_STATUS hal_rx_mpdu_get_addr1_be(uint8_t *buf, + uint8_t *mac_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct __attribute__((__packed__)) hal_addr1 { + uint32_t ad1_31_0; + uint16_t ad1_47_32; + }; + struct hal_addr1 *addr = (struct hal_addr1 *)mac_addr; + uint32_t mac_addr_ad1_valid; + + mac_addr_ad1_valid = HAL_RX_TLV_MPDU_MAC_ADDR_AD1_VALID_GET(rx_pkt_tlvs); + + if (mac_addr_ad1_valid) { + addr->ad1_31_0 = HAL_RX_TLV_MPDU_AD1_31_0_GET(rx_pkt_tlvs); + addr->ad1_47_32 = HAL_RX_TLV_MPDU_AD1_47_32_GET(rx_pkt_tlvs); + return QDF_STATUS_SUCCESS; + } + + return QDF_STATUS_E_FAILURE; +} + +/* + * hal_rx_mpdu_get_addr2_be(): API to check get address2 of the mpdu + * in the packet + * + * @buf: pointer to the start of RX PKT TLV header + * @mac_addr: pointer to mac address + * Return: success/failure + */ +static inline QDF_STATUS hal_rx_mpdu_get_addr2_be(uint8_t *buf, + uint8_t *mac_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct __attribute__((__packed__)) hal_addr2 { + uint16_t ad2_15_0; + uint32_t ad2_47_16; + }; + struct hal_addr2 *addr = (struct hal_addr2 *)mac_addr; + uint32_t mac_addr_ad2_valid; + + mac_addr_ad2_valid = HAL_RX_TLV_MPDU_MAC_ADDR_AD2_VALID_GET(rx_pkt_tlvs); + + if (mac_addr_ad2_valid) { + addr->ad2_15_0 = HAL_RX_TLV_MPDU_AD2_15_0_GET(rx_pkt_tlvs); + addr->ad2_47_16 = HAL_RX_TLV_MPDU_AD2_47_16_GET(rx_pkt_tlvs); + return QDF_STATUS_SUCCESS; + } + + return QDF_STATUS_E_FAILURE; +} + +/* + * hal_rx_mpdu_get_addr3_be(): API to get address3 of the mpdu + * in the packet + * + * @buf: pointer to the start of RX PKT TLV header + * @mac_addr: pointer to mac address + * Return: success/failure + */ +static inline QDF_STATUS hal_rx_mpdu_get_addr3_be(uint8_t *buf, + uint8_t *mac_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct __attribute__((__packed__)) hal_addr3 { + uint32_t ad3_31_0; + uint16_t ad3_47_32; + }; + struct hal_addr3 *addr = (struct hal_addr3 *)mac_addr; + uint32_t mac_addr_ad3_valid; + + mac_addr_ad3_valid = HAL_RX_TLV_MPDU_MAC_ADDR_AD3_VALID_GET(rx_pkt_tlvs); + + if (mac_addr_ad3_valid) { + addr->ad3_31_0 = HAL_RX_TLV_MPDU_AD3_31_0_GET(rx_pkt_tlvs); + addr->ad3_47_32 = HAL_RX_TLV_MPDU_AD3_47_32_GET(rx_pkt_tlvs); + return QDF_STATUS_SUCCESS; + } + + return QDF_STATUS_E_FAILURE; +} + +/* + * hal_rx_mpdu_get_addr4_be(): API to get address4 of the mpdu + * in the packet + * + * @buf: pointer to the start of RX PKT TLV header + * @mac_addr: pointer to mac address + * Return: success/failure + */ +static inline QDF_STATUS hal_rx_mpdu_get_addr4_be(uint8_t *buf, + uint8_t *mac_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct __attribute__((__packed__)) hal_addr4 { + uint32_t ad4_31_0; + uint16_t ad4_47_32; + }; + struct hal_addr4 *addr = (struct hal_addr4 *)mac_addr; + uint32_t mac_addr_ad4_valid; + + mac_addr_ad4_valid = HAL_RX_TLV_MPDU_MAC_ADDR_AD4_VALID_GET(rx_pkt_tlvs); + + if (mac_addr_ad4_valid) { + addr->ad4_31_0 = HAL_RX_TLV_MPDU_AD4_31_0_GET(rx_pkt_tlvs); + addr->ad4_47_32 = HAL_RX_TLV_MPDU_AD4_47_32_GET(rx_pkt_tlvs); + return QDF_STATUS_SUCCESS; + } + + return QDF_STATUS_E_FAILURE; +} + +/* + * hal_rx_get_mpdu_sequence_control_valid_be(): Get mpdu + * sequence control valid + * + * @nbuf: Network buffer + * Returns: value of sequence control valid field + */ +static inline uint8_t hal_rx_get_mpdu_sequence_control_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MPDU_GET_SEQUENCE_CONTROL_VALID(rx_pkt_tlvs); +} + +/** + * hal_rx_is_unicast_be: check packet is unicast frame or not. + * + * @ buf: pointer to rx pkt TLV. + * + * Return: true on unicast. + */ +static inline bool hal_rx_is_unicast_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t grp_id; + + grp_id = HAL_RX_TLV_SW_FRAME_GROUP_ID_GET(rx_pkt_tlvs); + + return (HAL_MPDU_SW_FRAME_GROUP_UNICAST_DATA == grp_id) ? true : false; +} + +/** + * hal_rx_tid_get_be: get tid based on qos control valid. + * @hal_soc_hdl: hal_soc handle + * @ buf: pointer to rx pkt TLV. + * + * Return: tid + */ +static inline uint32_t hal_rx_tid_get_be(hal_soc_handle_t hal_soc_hdl, + uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint8_t qos_control_valid = + HAL_RX_TLV_MPDU_QOS_CONTROL_VALID_GET(rx_pkt_tlvs); + + if (qos_control_valid) + return hal_rx_tlv_tid_get_be(buf); + + return HAL_RX_NON_QOS_TID; +} + +/** + * hal_rx_hw_desc_get_ppduid_get_be(): retrieve ppdu id + * @rx_tlv_hdr: start address of rx_pkt_tlvs + * @rxdma_dst_ring_desc: Rx HW descriptor + * + * Return: ppdu id + */ +static inline uint32_t +hal_rx_hw_desc_get_ppduid_get_be(void *rx_tlv_hdr, void *rxdma_dst_ring_desc) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)rx_tlv_hdr; + + return HAL_RX_TLV_PHY_PPDU_ID_GET(rx_pkt_tlvs); +} + +static inline +uint8_t hal_rx_get_fc_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_GET_FC_VALID(rx_pkt_tlvs); +} + +static inline uint8_t hal_rx_get_to_ds_flag_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_GET_TO_DS_FLAG(rx_pkt_tlvs); +} + +static inline uint8_t hal_rx_get_mac_addr2_valid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_MPDU_MAC_ADDR_AD2_VALID_GET(rx_pkt_tlvs); +} + +static inline uint8_t hal_rx_get_filter_category_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_GET_FILTER_CATEGORY(rx_pkt_tlvs); +} + +static inline uint32_t +hal_rx_get_ppdu_id_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_GET_PPDU_ID(rx_pkt_tlvs); +} + +/** + * hal_rx_msdu_flow_idx_get_be: API to get flow index + * from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * + * Return: flow index value from MSDU END TLV + */ +static inline uint32_t hal_rx_msdu_flow_idx_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FLOW_IDX_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_get_reo_destination_indication_be: API to get + * reo_destination_indication from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * @reo_destination_indication: pointer to return value of + * reo_destination_indication + * + * Return: none + */ +static inline void +hal_rx_msdu_get_reo_destination_indication_be(uint8_t *buf, + uint32_t *reo_destination_indication) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + *reo_destination_indication = HAL_RX_TLV_REO_DEST_IND_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_flow_idx_invalid_be: API to get flow index invalid + * from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * + * Return: flow index invalid value from MSDU END TLV + */ +static inline bool hal_rx_msdu_flow_idx_invalid_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FLOW_IDX_INVALID_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_flow_idx_timeout_be: API to get flow index timeout + * from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * + * Return: flow index timeout value from MSDU END TLV + */ +static inline bool hal_rx_msdu_flow_idx_timeout_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FLOW_IDX_TIMEOUT_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_fse_metadata_get_be: API to get FSE metadata + * from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * + * Return: fse metadata value from MSDU END TLV + */ +static inline uint32_t hal_rx_msdu_fse_metadata_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_FSE_METADATA_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_cce_metadata_get_be: API to get CCE metadata + * from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * + * Return: cce_metadata + */ +static inline uint16_t +hal_rx_msdu_cce_metadata_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_CCE_METADATA_GET(pkt_tlvs); +} + +/** + * hal_rx_msdu_get_flow_params_be: API to get flow index, flow index invalid + * and flow index timeout from rx_msdu_end TLV + * @buf: pointer to the start of RX PKT TLV headers + * @flow_invalid: pointer to return value of flow_idx_valid + * @flow_timeout: pointer to return value of flow_idx_timeout + * @flow_index: pointer to return value of flow_idx + * + * Return: none + */ +static inline void +hal_rx_msdu_get_flow_params_be(uint8_t *buf, + bool *flow_invalid, + bool *flow_timeout, + uint32_t *flow_index) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + *flow_invalid = HAL_RX_TLV_FLOW_IDX_INVALID_GET(pkt_tlvs); + *flow_timeout = HAL_RX_TLV_FLOW_IDX_TIMEOUT_GET(pkt_tlvs); + *flow_index = HAL_RX_TLV_FLOW_IDX_GET(pkt_tlvs); +} + +/** + * hal_rx_tlv_get_tcp_chksum_be() - API to get tcp checksum + * @buf: rx_tlv_hdr + * + * Return: tcp checksum + */ +static inline uint16_t +hal_rx_tlv_get_tcp_chksum_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_TCP_CHKSUM(rx_pkt_tlvs); +} + +/** + * hal_rx_get_rx_sequence_be(): Function to retrieve rx sequence number + * + * @nbuf: Network buffer + * Returns: rx sequence number + */ +static inline +uint16_t hal_rx_get_rx_sequence_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_MPDU_SEQUENCE_NUMBER_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_get_fisa_cumulative_l4_checksum_be() - Retrieve cumulative + * checksum + * @buf: buffer pointer + * + * Return: cumulative checksum + */ +static inline +uint16_t hal_rx_get_fisa_cumulative_l4_checksum_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_FISA_CUMULATIVE_L4_CHECKSUM(rx_pkt_tlvs); +} + +/** + * hal_rx_get_fisa_cumulative_ip_length_be() - Retrieve cumulative + * ip length + * @buf: buffer pointer + * + * Return: cumulative length + */ +static inline +uint16_t hal_rx_get_fisa_cumulative_ip_length_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_FISA_CUMULATIVE_IP_LENGTH(rx_pkt_tlvs); +} + +/** + * hal_rx_get_udp_proto_be() - Retrieve udp proto value + * @buf: buffer + * + * Return: udp proto bit + */ +static inline +bool hal_rx_get_udp_proto_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_UDP_PROTO(rx_pkt_tlvs); +} + +/** + * hal_rx_get_flow_agg_continuation_be() - retrieve flow agg + * continuation + * @buf: buffer + * + * Return: flow agg + */ +static inline +bool hal_rx_get_flow_agg_continuation_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_FLOW_AGGR_CONT(rx_pkt_tlvs); +} + +/** + * hal_rx_get_flow_agg_count_be()- Retrieve flow agg count + * @buf: buffer + * + * Return: flow agg count + */ +static inline +uint8_t hal_rx_get_flow_agg_count_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_FLOW_AGGR_COUNT(rx_pkt_tlvs); +} + +/** + * hal_rx_get_fisa_timeout_be() - Retrieve fisa timeout + * @buf: buffer + * + * Return: fisa timeout + */ +static inline +bool hal_rx_get_fisa_timeout_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + return HAL_RX_TLV_GET_FISA_TIMEOUT(rx_pkt_tlvs); +} + +/** + * hal_rx_mpdu_start_tlv_tag_valid_be () - API to check if RX_MPDU_START + * tlv tag is valid + * + *@rx_tlv_hdr: start address of rx_pkt_tlvs + * + * Return: true if RX_MPDU_START is valied, else false. + */ +static inline uint8_t hal_rx_mpdu_start_tlv_tag_valid_be(void *rx_tlv_hdr) +{ + struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)rx_tlv_hdr; + uint32_t tlv_tag; + + tlv_tag = HAL_RX_GET_USER_TLV32_TYPE(&rx_desc->mpdu_start_tlv); + + return tlv_tag == WIFIRX_MPDU_START_E ? true : false; +} + +/** + * hal_rx_msdu_end_offset_get_generic(): API to get the + * msdu_end structure offset rx_pkt_tlv structure + * + * NOTE: API returns offset of msdu_end TLV from structure + * rx_pkt_tlvs + */ +static inline uint32_t hal_rx_msdu_end_offset_get_generic(void) +{ + return RX_PKT_TLV_OFFSET(msdu_end_tlv); +} + +/** + * hal_rx_mpdu_start_offset_get_generic(): API to get the + * mpdu_start structure offset rx_pkt_tlv structure + * + * NOTE: API returns offset of attn TLV from structure + * rx_pkt_tlvs + */ +static inline uint32_t hal_rx_mpdu_start_offset_get_generic(void) +{ + return RX_PKT_TLV_OFFSET(mpdu_start_tlv); +} + +static inline uint32_t hal_rx_pkt_tlv_offset_get_generic(void) +{ + return RX_PKT_TLV_OFFSET(pkt_hdr_tlv); +} + +static inline int +hal_rx_tlv_get_offload_info_be(uint8_t *rx_tlv, + struct hal_offload_info *offload_info) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)rx_tlv; + offload_info->tcp_proto = HAL_RX_TLV_GET_TCP_PROTO(rx_pkt_tlvs); + + if (!offload_info->tcp_proto) + return -EINVAL; + + offload_info->lro_eligible = HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_pkt_tlvs); + offload_info->tcp_pure_ack = HAL_RX_TLV_GET_TCP_PURE_ACK(rx_pkt_tlvs); + offload_info->ipv6_proto = HAL_RX_TLV_GET_IPV6(rx_pkt_tlvs); + offload_info->tcp_offset = HAL_RX_TLV_GET_TCP_OFFSET(rx_pkt_tlvs); + offload_info->tcp_win = HAL_RX_TLV_GET_TCP_WIN(rx_pkt_tlvs); + offload_info->tcp_seq_num = HAL_RX_TLV_GET_TCP_SEQ(rx_pkt_tlvs); + offload_info->tcp_ack_num = HAL_RX_TLV_GET_TCP_ACK(rx_pkt_tlvs); + offload_info->flow_id = HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_pkt_tlvs); + + return 0; +} + +/* + * hal_rx_attn_phy_ppdu_id_get(): get phy_ppdu_id value + * from rx attention + * @buf: pointer to rx_pkt_tlvs + * + * Return: phy_ppdu_id + */ +static inline uint16_t hal_rx_attn_phy_ppdu_id_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint16_t phy_ppdu_id; + + phy_ppdu_id = HAL_RX_TLV_PHY_PPDU_ID_GET(rx_pkt_tlvs); + + return phy_ppdu_id; +} + +/** +* hal_rx_msdu_start_msdu_len_get(): API to get the MSDU length +* from rx_msdu_start TLV +* +* @ buf: pointer to the start of RX PKT TLV headers +* Return: msdu length +*/ +static inline uint32_t hal_rx_msdu_start_msdu_len_get_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t msdu_len; + +// msdu_len = HAL_RX_MSDU_START_MSDU_LEN_GET(msdu_start); + msdu_len = HAL_RX_TLV_MSDU_LEN_GET(rx_pkt_tlvs); + + return msdu_len; +} + +/** + * hal_rx_get_frame_ctrl_field(): Function to retrieve frame control field + * + * @nbuf: Network buffer + * Returns: rx more fragment bit + * + */ +static inline uint16_t hal_rx_get_frame_ctrl_field_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint16_t frame_ctrl = 0; + + frame_ctrl = HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(rx_pkt_tlvs); + + return frame_ctrl; +} + +static inline int hal_rx_get_proto_params_be(uint8_t *buf, void *proto_params) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + struct hal_proto_params *param = (struct hal_proto_params *)proto_params; + + param->tcp_proto = HAL_RX_TLV_GET_IP_OFFSET(rx_pkt_tlvs); + param->udp_proto = HAL_RX_TLV_GET_UDP_PROTO(rx_pkt_tlvs); + param->ipv6_proto = HAL_RX_TLV_GET_IPV6(rx_pkt_tlvs); + + return 0; +} + +/* + * hal_rx_tlv_get_is_decrypted_be(): API to get the decrypt status of the + * packet from msdu_end + * + * @buf: pointer to the start of RX PKT TLV header + * Return: uint32_t(decryt status) + */ +static inline uint32_t hal_rx_tlv_get_is_decrypted_be(uint8_t *buf) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t is_decrypt = 0; + uint32_t decrypt_status; + + decrypt_status = HAL_RX_TLV_DECRYPT_STATUS_GET(rx_pkt_tlvs); + + if (!decrypt_status) + is_decrypt = 1; + + return is_decrypt; +} + +static inline int hal_rx_get_l3_l4_offsets_be(uint8_t *buf, + uint32_t *l3_hdr_offset, + uint32_t *l4_hdr_offset) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = (struct rx_pkt_tlvs *)buf; + + *l3_hdr_offset = HAL_RX_TLV_GET_IP_OFFSET(rx_pkt_tlvs); + *l4_hdr_offset = HAL_RX_TLV_GET_TCP_OFFSET(rx_pkt_tlvs); + + return 0; +} + +//TODO - Currently going with NO-PKT-HDR, need to add pkt hdr tlv and check +static inline uint8_t *hal_rx_pkt_hdr_get_be(uint8_t *buf) +{ + return buf + RX_PKT_TLVS_LEN; +} + +/** + * hal_rx_priv_info_set_in_tlv_be(): Save the private info to + * the reserved bytes of rx_tlv_hdr + * @buf: start of rx_tlv_hdr + * @priv_data: hal_wbm_err_desc_info structure + * @len: length of the private data + * Return: void + */ +static inline void hal_rx_priv_info_set_in_tlv_be(uint8_t *buf, + uint8_t *priv_data, + uint32_t len) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t copy_len = (len > RX_BE_PADDING0_BYTES) ? + RX_BE_PADDING0_BYTES : len; + + qdf_mem_copy(pkt_tlvs->rx_padding0, priv_data, copy_len); +} + +/** + * hal_rx_priv_info_get_from_tlv_be(): retrieve the private data from + * the reserved bytes of rx_tlv_hdr. + * @buf: start of rx_tlv_hdr + * @priv_data: Handle to get the private data, output parameter. + * @len: length of the private data + * Return: void + */ +static inline void hal_rx_priv_info_get_from_tlv_be(uint8_t *buf, + uint8_t *priv_data, + uint32_t len) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint32_t copy_len = (len > RX_BE_PADDING0_BYTES) ? + RX_BE_PADDING0_BYTES : len; + + qdf_mem_copy(priv_data, pkt_tlvs->rx_padding0, copy_len); +} + +/** + * hal_rx_tlv_csum_err_get_be() - Get IP and tcp-udp checksum fail flag + * @rx_tlv_hdr: start address of rx_tlv_hdr + * @ip_csum_err: buffer to return ip_csum_fail flag + * @tcp_udp_csum_fail: placeholder to return tcp-udp checksum fail flag + * + * Return: None + */ +static inline void +hal_rx_tlv_csum_err_get_be(uint8_t *rx_tlv_hdr, uint32_t *ip_csum_err, + uint32_t *tcp_udp_csum_err) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)rx_tlv_hdr; + + *ip_csum_err = HAL_RX_TLV_IP_CSUM_FAIL_GET(rx_pkt_tlvs); + *tcp_udp_csum_err = HAL_RX_TLV_TCP_UDP_CSUM_FAIL_GET(rx_pkt_tlvs); +} + +static inline +uint32_t hal_rx_tlv_mpdu_len_err_get_be(void *hw_desc_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)hw_desc_addr; + + return HAL_RX_TLV_MPDU_LEN_ERR_GET(rx_pkt_tlvs); +} + +static inline +uint32_t hal_rx_tlv_mpdu_fcs_err_get_be(void *hw_desc_addr) +{ + struct rx_pkt_tlvs *rx_pkt_tlvs = + (struct rx_pkt_tlvs *)hw_desc_addr; + + return HAL_RX_TLV_MPDU_FCS_ERR_GET(rx_pkt_tlvs); +} + +/** + * hal_rx_get_rx_more_frag_bit(): Function to retrieve more fragment bit + * + * @nbuf: Network buffer + * Returns: rx more fragment bit + */ +static inline +uint8_t hal_rx_get_rx_more_frag_bit(uint8_t *buf) +{ + struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; + uint16_t frame_ctrl = 0; + + frame_ctrl = HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(pkt_tlvs) >> + DOT11_FC1_MORE_FRAG_OFFSET; + + /* more fragment bit if at offset bit 4 */ + return frame_ctrl; +} + +/* + * hal_rx_msdu_is_wlan_mcast_generic_be(): Check if the buffer is for multicast + * address + * @nbuf: Network buffer + * + * Returns: flag to indicate whether the nbuf has MC/BC address + */ +static inline uint32_t hal_rx_msdu_is_wlan_mcast_generic_be(qdf_nbuf_t nbuf) +{ + uint8_t *buf = qdf_nbuf_data(nbuf); + + return HAL_RX_TLV_IS_MCAST_GET(buf);; +} + +/** + * hal_rx_msdu_start_msdu_len_set_be(): API to set the MSDU length + * from rx_msdu_start TLV + * + * @buf: pointer to the start of RX PKT TLV headers + * @len: msdu length + * + * Return: none + */ +static inline void +hal_rx_msdu_start_msdu_len_set_be(uint8_t *buf, uint32_t len) +{ + HAL_RX_TLV_MSDU_LEN_GET(buf) = len; +} + +#endif /* _HAL_BE_RX_TLV_H_ */ diff --git a/hal/wifi3.0/wcn7850/hal_7850.c b/hal/wifi3.0/wcn7850/hal_7850.c index 0057570fc8..5f1b1d2516 100644 --- a/hal/wifi3.0/wcn7850/hal_7850.c +++ b/hal/wifi3.0/wcn7850/hal_7850.c @@ -115,7 +115,6 @@ #include "hal_7850_tx.h" #include "hal_7850_rx.h" -#include "hal_7850_rx_tlv.h" #include "hal_be_rx_tlv.h" #include @@ -256,6 +255,55 @@ void *hal_dst_mpdu_desc_info_7850(void *dst_ring_desc) return (void *)HAL_DST_MPDU_DESC_INFO(dst_ring_desc); } +/* + * hal_rx_get_tlv_7850(): API to get the tlv + * + * @rx_tlv: TLV data extracted from the rx packet + * Return: uint8_t + */ +static uint8_t hal_rx_get_tlv_7850(void *rx_tlv) +{ + return HAL_RX_GET(rx_tlv, PHYRX_RSSI_LEGACY, RECEIVE_BANDWIDTH); +} + +/** + * hal_rx_proc_phyrx_other_receive_info_tlv_7850() + * - process other receive info TLV + * @rx_tlv_hdr: pointer to TLV header + * @ppdu_info: pointer to ppdu_info + * + * Return: None + */ +static +void hal_rx_proc_phyrx_other_receive_info_tlv_7850(void *rx_tlv_hdr, + void *ppdu_info_handle) +{ + uint32_t tlv_tag, tlv_len; + uint32_t temp_len, other_tlv_len, other_tlv_tag; + void *rx_tlv = (uint8_t *)rx_tlv_hdr + HAL_RX_TLV32_HDR_SIZE; + void *other_tlv_hdr = NULL; + void *other_tlv = NULL; + + tlv_tag = HAL_RX_GET_USER_TLV32_TYPE(rx_tlv_hdr); + tlv_len = HAL_RX_GET_USER_TLV32_LEN(rx_tlv_hdr); + temp_len = 0; + + other_tlv_hdr = rx_tlv + HAL_RX_TLV32_HDR_SIZE; + + other_tlv_tag = HAL_RX_GET_USER_TLV32_TYPE(other_tlv_hdr); + other_tlv_len = HAL_RX_GET_USER_TLV32_LEN(other_tlv_hdr); + temp_len += other_tlv_len; + other_tlv = other_tlv_hdr + HAL_RX_TLV32_HDR_SIZE; + + switch (other_tlv_tag) { + default: + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, + "%s unhandled TLV type: %d, TLV len:%d", + __func__, other_tlv_tag, other_tlv_len); + break; + } +} + /** * hal_reo_config_7850(): Set reo config parameters * @soc: hal soc handle @@ -696,11 +744,6 @@ static void hal_hw_txrx_ops_attach_wcn7850(struct hal_soc *hal_soc) /* rx - TLV struct offsets */ hal_soc->ops->hal_rx_msdu_end_offset_get = hal_rx_msdu_end_offset_get_generic; -// hal_soc->ops->hal_rx_attn_offset_get = hal_rx_attn_offset_get_generic; -// hal_soc->ops->hal_rx_msdu_start_offset_get = -// hal_rx_msdu_start_offset_get_generic; -// hal_soc->ops->hal_rx_mpdu_end_offset_get = -// hal_rx_mpdu_end_offset_get_generic; hal_soc->ops->hal_rx_mpdu_start_offset_get = hal_rx_mpdu_start_offset_get_generic; hal_soc->ops->hal_rx_pkt_tlv_offset_get =